Revert 213493 "cc: Use a struct for CalcDrawProps inputs"

> cc: Use a struct for CalcDrawProps inputs
> 
> This is just a refactoring and should not change any behavior.
> 
> R=danakj@chromium.org
> BUG=none
> 
> Review URL: https://chromiumcodereview.appspot.com/19935003

TBR=enne@chromium.org

Review URL: https://codereview.chromium.org/20110002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@213495 0039d316-1c4b-4281-b951-d872f2087c98

12 files changed, 958 insertions, 528 deletions

diff --git a/cc/layers/contents_scaling_layer_unittest.cc b/cc/layers/contents_scaling_layer_unittest.cc
index a10f359..08d3c32 100644
--- a/cc/layers/contents_scaling_layer_unittest.cc
+++ b/cc/layers/contents_scaling_layer_unittest.cc
@@ -36,12 +36,19 @@ class MockContentsScalingLayer : public ContentsScalingLayer {
   gfx::RectF last_needs_display_rect_;
 };
 
-void CalcDrawProps(Layer* root, float device_scale_factor) {
+void CalcDrawProps(Layer* root, float device_scale) {
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root, gfx::Size(500, 500), &render_surface_layer_list);
-  inputs.device_scale_factor = device_scale_factor;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  LayerTreeHostCommon::CalculateDrawProperties(
+      root,
+      gfx::Size(500, 500),
+      gfx::Transform(),
+      device_scale,
+      1.f,
+      NULL,
+      1024,
+      false,
+      false,
+      &render_surface_layer_list);
 }
 
 TEST(ContentsScalingLayerTest, CheckContentsBounds) {
diff --git a/cc/layers/layer_iterator_unittest.cc b/cc/layers/layer_iterator_unittest.cc
index d828a41..ea8ec3b 100644
--- a/cc/layers/layer_iterator_unittest.cc
+++ b/cc/layers/layer_iterator_unittest.cc
@@ -137,9 +137,16 @@ TEST(LayerIteratorTest, SimpleTree) {
   root_layer->AddChild(fourth);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root_layer.get(), root_layer->bounds(), &render_surface_layer_list);
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  LayerTreeHostCommon::CalculateDrawProperties(root_layer.get(),
+                                               root_layer->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               256,
+                                               false,
+                                               false,
+                                               &render_surface_layer_list);
 
   IterateBackToFront(&render_surface_layer_list);
   EXPECT_COUNT(root_layer, 0, -1, 1);
@@ -177,9 +184,16 @@ TEST(LayerIteratorTest, ComplexTree) {
   root23->AddChild(root231);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root_layer.get(), root_layer->bounds(), &render_surface_layer_list);
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  LayerTreeHostCommon::CalculateDrawProperties(root_layer.get(),
+                                               root_layer->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               256,
+                                               false,
+                                               false,
+                                               &render_surface_layer_list);
 
   IterateBackToFront(&render_surface_layer_list);
   EXPECT_COUNT(root_layer, 0, -1, 1);
@@ -230,9 +244,16 @@ TEST(LayerIteratorTest, ComplexTreeMultiSurface) {
   root23->AddChild(root231);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root_layer.get(), root_layer->bounds(), &render_surface_layer_list);
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  LayerTreeHostCommon::CalculateDrawProperties(root_layer.get(),
+                                               root_layer->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               256,
+                                               false,
+                                               false,
+                                               &render_surface_layer_list);
 
   IterateBackToFront(&render_surface_layer_list);
   EXPECT_COUNT(root_layer, 0, -1, 1);
diff --git a/cc/layers/layer_position_constraint_unittest.cc b/cc/layers/layer_position_constraint_unittest.cc
index 821cd82..1e6084f 100644
--- a/cc/layers/layer_position_constraint_unittest.cc
+++ b/cc/layers/layer_position_constraint_unittest.cc
@@ -39,6 +39,7 @@ void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
                                     bool can_use_lcd_text) {
   gfx::Transform identity_matrix;
   std::vector<LayerImpl*> dummy_render_surface_layer_list;
+  int dummy_max_texture_size = 512;
   gfx::Size device_viewport_size =
       gfx::Size(root_layer->bounds().width() * device_scale_factor,
                 root_layer->bounds().height() * device_scale_factor);
@@ -46,13 +47,17 @@ void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
   // We are probably not testing what is intended if the root_layer bounds are
   // empty.
   DCHECK(!root_layer->bounds().IsEmpty());
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root_layer, device_viewport_size, &dummy_render_surface_layer_list);
-  inputs.device_scale_factor = device_scale_factor;
-  inputs.page_scale_factor = page_scale_factor;
-  inputs.page_scale_application_layer = page_scale_application_layer;
-  inputs.can_use_lcd_text = can_use_lcd_text;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  LayerTreeHostCommon::CalculateDrawProperties(
+      root_layer,
+      device_viewport_size,
+      gfx::Transform(),
+      device_scale_factor,
+      page_scale_factor,
+      page_scale_application_layer,
+      dummy_max_texture_size,
+      can_use_lcd_text,
+      false,
+      &dummy_render_surface_layer_list);
 }
 
 void ExecuteCalculateDrawProperties(LayerImpl* root_layer) {
diff --git a/cc/layers/solid_color_layer_impl_unittest.cc b/cc/layers/solid_color_layer_impl_unittest.cc
index 6fad107..62729ed 100644
--- a/cc/layers/solid_color_layer_impl_unittest.cc
+++ b/cc/layers/solid_color_layer_impl_unittest.cc
@@ -110,9 +110,16 @@ TEST(SolidColorLayerImplTest, VerifyOpaqueRect) {
   root->AddChild(layer);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root, gfx::Size(500, 500), &render_surface_layer_list);
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               gfx::Size(500, 500),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               1024,
+                                               false,
+                                               false,
+                                               &render_surface_layer_list);
 
   EXPECT_FALSE(layer->contents_opaque());
   layer->SetBackgroundColor(SkColorSetARGBInline(255, 10, 20, 30));
diff --git a/cc/layers/tiled_layer_unittest.cc b/cc/layers/tiled_layer_unittest.cc
index 0785d53..7eb1c8d 100644
--- a/cc/layers/tiled_layer_unittest.cc
+++ b/cc/layers/tiled_layer_unittest.cc
@@ -134,15 +134,17 @@ class TiledLayerTest : public testing::Test {
     if (occlusion_)
       occlusion_->SetRenderTarget(layer_tree_host_->root_layer());
 
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+    LayerTreeHostCommon::CalculateDrawProperties(
         layer_tree_host_->root_layer(),
         layer_tree_host_->device_viewport_size(),
+        gfx::Transform(),
+        layer_tree_host_->device_scale_factor(),
+        1.f,    // page_scale_factor
+        NULL,
+        layer_tree_host_->GetRendererCapabilities().max_texture_size,
+        false,  // can_use_lcd_text
+        true,  // can_adjust_raster_scale
         render_surface_layer_list);
-    inputs.device_scale_factor = layer_tree_host_->device_scale_factor();
-    inputs.max_texture_size =
-        layer_tree_host_->GetRendererCapabilities().max_texture_size;
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   }
 
   bool UpdateAndPush(const scoped_refptr<FakeTiledLayer>& layer1,
diff --git a/cc/trees/damage_tracker_unittest.cc b/cc/trees/damage_tracker_unittest.cc
index 9e45379..a3dd636 100644
--- a/cc/trees/damage_tracker_unittest.cc
+++ b/cc/trees/damage_tracker_unittest.cc
@@ -20,17 +20,27 @@
 namespace cc {
 namespace {
 
-void ExecuteCalculateDrawProperties(LayerImpl* root,
-                                    LayerImplList& render_surface_layer_list) {
+void ExecuteCalculateDrawProperties(
+    LayerImpl* root,
+    LayerImplList& render_surface_layer_list) {
+  int dummy_max_texture_size = 512;
+
   // Sanity check: The test itself should create the root layer's render
   //               surface, so that the surface (and its damage tracker) can
   //               persist across multiple calls to this function.
   ASSERT_TRUE(root->render_surface());
   ASSERT_FALSE(render_surface_layer_list.size());
 
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root, root->bounds(), &render_surface_layer_list);
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  LayerTreeHostCommon::CalculateDrawProperties(root,
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               false,
+                                               &render_surface_layer_list);
 }
 
 void ClearDamageForAllSurfaces(LayerImpl* layer) {
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index 0f07b43..0d90c59 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -711,7 +711,7 @@ bool LayerTreeHost::UpdateLayers(Layer* root_layer,
     }
 
     TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers::CalcDrawProps");
-    LayerTreeHostCommon::CalcDrawPropsMainInputs inputs(
+    LayerTreeHostCommon::CalculateDrawProperties(
         root_layer,
         device_viewport_size(),
         gfx::Transform(),
@@ -722,7 +722,6 @@ bool LayerTreeHost::UpdateLayers(Layer* root_layer,
         settings_.can_use_lcd_text,
         settings_.layer_transforms_should_scale_layer_contents,
         &update_list);
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     if (total_frames_used_for_lcd_text_metrics_ <=
         kTotalFramesToUseForLCDTextMetrics) {
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index 88acc47..dce396f 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -1597,47 +1597,55 @@ static void CalculateDrawPropertiesInternal(
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
-    CalcDrawPropsMainInputs* inputs) {
-  DCHECK(inputs->root_layer);
-  DCHECK(IsRootLayer(inputs->root_layer));
-  DCHECK(inputs->render_surface_layer_list);
+    Layer* root_layer,
+    gfx::Size device_viewport_size,
+    const gfx::Transform& device_transform,
+    float device_scale_factor,
+    float page_scale_factor,
+    Layer* page_scale_application_layer,
+    int max_texture_size,
+    bool can_use_lcd_text,
+    bool can_adjust_raster_scales,
+    RenderSurfaceLayerList* render_surface_layer_list) {
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
-  gfx::Transform scaled_device_transform = inputs->device_transform;
-  scaled_device_transform.Scale(inputs->device_scale_factor,
-                                inputs->device_scale_factor);
+  gfx::Transform scaled_device_transform = device_transform;
+  scaled_device_transform.Scale(device_scale_factor, device_scale_factor);
   RenderSurfaceLayerList dummy_layer_list;
 
   // The root layer's render_surface should receive the device viewport as the
   // initial clip rect.
   bool layer_or_ancestor_clips_descendants = true;
-  gfx::Rect device_viewport_rect(inputs->device_viewport_size);
+  gfx::Rect device_viewport_rect(device_viewport_size);
   bool in_subtree_of_page_scale_application_layer = false;
   bool subtree_is_visible = true;
 
+  // This function should have received a root layer.
+  DCHECK(IsRootLayer(root_layer));
+
   PreCalculateMetaInformationRecursiveData recursive_data;
-  PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
+  PreCalculateMetaInformation(root_layer, &recursive_data);
 
   CalculateDrawPropertiesInternal<Layer, RenderSurfaceLayerList, RenderSurface>(
-      inputs->root_layer,
+      root_layer,
       scaled_device_transform,
       identity_matrix,
       identity_matrix,
-      inputs->root_layer,
+      root_layer,
       device_viewport_rect,
       device_viewport_rect,
       layer_or_ancestor_clips_descendants,
       NULL,
-      inputs->render_surface_layer_list,
+      render_surface_layer_list,
       &dummy_layer_list,
       NULL,
-      inputs->max_texture_size,
-      inputs->device_scale_factor,
-      inputs->page_scale_factor,
-      inputs->page_scale_application_layer,
+      max_texture_size,
+      device_scale_factor,
+      page_scale_factor,
+      page_scale_application_layer,
       in_subtree_of_page_scale_application_layer,
-      inputs->can_use_lcd_text,
-      inputs->can_adjust_raster_scales,
+      can_use_lcd_text,
+      can_adjust_raster_scales,
       subtree_is_visible,
       &total_drawable_content_rect);
 
@@ -1645,53 +1653,62 @@ void LayerTreeHostCommon::CalculateDrawProperties(
   DCHECK_EQ(0u, dummy_layer_list.size());
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
-  DCHECK(inputs->root_layer->render_surface());
+  DCHECK(root_layer->render_surface());
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
-    CalcDrawPropsImplInputs* inputs) {
-  DCHECK(inputs->root_layer);
-  DCHECK(IsRootLayer(inputs->root_layer));
-  DCHECK(inputs->render_surface_layer_list);
-
+    LayerImpl* root_layer,
+    gfx::Size device_viewport_size,
+    const gfx::Transform& device_transform,
+    float device_scale_factor,
+    float page_scale_factor,
+    LayerImpl* page_scale_application_layer,
+    int max_texture_size,
+    bool can_use_lcd_text,
+    bool can_adjust_raster_scales,
+    LayerImplList* render_surface_layer_list) {
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
-  gfx::Transform scaled_device_transform = inputs->device_transform;
-  scaled_device_transform.Scale(inputs->device_scale_factor,
-                                inputs->device_scale_factor);
+  gfx::Transform scaled_device_transform = device_transform;
+  scaled_device_transform.Scale(device_scale_factor, device_scale_factor);
   LayerImplList dummy_layer_list;
   LayerSorter layer_sorter;
 
   // The root layer's render_surface should receive the device viewport as the
   // initial clip rect.
   bool layer_or_ancestor_clips_descendants = true;
-  gfx::Rect device_viewport_rect(inputs->device_viewport_size);
+  gfx::Rect device_viewport_rect(device_viewport_size);
   bool in_subtree_of_page_scale_application_layer = false;
   bool subtree_is_visible = true;
 
+  // This function should have received a root layer.
+  DCHECK(IsRootLayer(root_layer));
+
   PreCalculateMetaInformationRecursiveData recursive_data;
-  PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
+  PreCalculateMetaInformation(root_layer, &recursive_data);
 
-  CalculateDrawPropertiesInternal<LayerImpl, LayerImplList, RenderSurfaceImpl>(
-      inputs->root_layer,
+  CalculateDrawPropertiesInternal<LayerImpl,
+                                  LayerImplList,
+                                  RenderSurfaceImpl>(
+      root_layer,
       scaled_device_transform,
       identity_matrix,
       identity_matrix,
-      inputs->root_layer,
+      root_layer,
       device_viewport_rect,
       device_viewport_rect,
       layer_or_ancestor_clips_descendants,
       NULL,
-      inputs->render_surface_layer_list,
+      render_surface_layer_list,
       &dummy_layer_list,
       &layer_sorter,
-      inputs->max_texture_size,
-      inputs->device_scale_factor,
-      inputs->page_scale_factor,
-      inputs->page_scale_application_layer,
+      max_texture_size,
+      device_scale_factor,
+      page_scale_factor,
+      page_scale_application_layer,
       in_subtree_of_page_scale_application_layer,
-      inputs->can_use_lcd_text,
-      inputs->can_adjust_raster_scales,
+      can_use_lcd_text,
+      can_adjust_raster_scales,
       subtree_is_visible,
       &total_drawable_content_rect);
 
@@ -1699,7 +1716,7 @@ void LayerTreeHostCommon::CalculateDrawProperties(
   DCHECK_EQ(0u, dummy_layer_list.size());
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
-  DCHECK(inputs->root_layer->render_surface());
+  DCHECK(root_layer->render_surface());
 }
 
 static bool PointHitsRect(
diff --git a/cc/trees/layer_tree_host_common.h b/cc/trees/layer_tree_host_common.h
index 05affee..154d8a0 100644
--- a/cc/trees/layer_tree_host_common.h
+++ b/cc/trees/layer_tree_host_common.h
@@ -5,7 +5,6 @@
 #ifndef CC_TREES_LAYER_TREE_HOST_COMMON_H_
 #define CC_TREES_LAYER_TREE_HOST_COMMON_H_
 
-#include <limits>
 #include <vector>
 
 #include "base/bind.h"
@@ -28,69 +27,28 @@ class CC_EXPORT LayerTreeHostCommon {
                                         gfx::Rect layer_bound_rect,
                                         const gfx::Transform& transform);
 
-  template <typename LayerType, typename RenderSurfaceLayerListType>
-  struct CalcDrawPropsInputs {
-   public:
-    CalcDrawPropsInputs(LayerType* root_layer,
-                        gfx::Size device_viewport_size,
-                        const gfx::Transform& device_transform,
-                        float device_scale_factor,
-                        float page_scale_factor,
-                        LayerType* page_scale_application_layer,
-                        int max_texture_size,
-                        bool can_use_lcd_text,
-                        bool can_adjust_raster_scales,
-                        RenderSurfaceLayerListType* render_surface_layer_list)
-        : root_layer(root_layer),
-          device_viewport_size(device_viewport_size),
-          device_transform(device_transform),
-          device_scale_factor(device_scale_factor),
-          page_scale_factor(page_scale_factor),
-          page_scale_application_layer(page_scale_application_layer),
-          max_texture_size(max_texture_size),
-          can_use_lcd_text(can_use_lcd_text),
-          can_adjust_raster_scales(can_adjust_raster_scales),
-          render_surface_layer_list(render_surface_layer_list) {}
-
-    LayerType* root_layer;
-    gfx::Size device_viewport_size;
-    const gfx::Transform& device_transform;
-    float device_scale_factor;
-    float page_scale_factor;
-    LayerType* page_scale_application_layer;
-    int max_texture_size;
-    bool can_use_lcd_text;
-    bool can_adjust_raster_scales;
-    RenderSurfaceLayerListType* render_surface_layer_list;
-  };
-
-  template <typename LayerType, typename RenderSurfaceLayerListType>
-  struct CalcDrawPropsInputsForTesting
-      : public CalcDrawPropsInputs<LayerType, RenderSurfaceLayerListType> {
-    CalcDrawPropsInputsForTesting(
-        LayerType* root_layer,
-        gfx::Size device_viewport_size,
-        const gfx::Transform& device_transform,
-        RenderSurfaceLayerListType* render_surface_layer_list);
-    CalcDrawPropsInputsForTesting(
-        LayerType* root_layer,
-        gfx::Size device_viewport_size,
-        RenderSurfaceLayerListType* render_surface_layer_list);
-
-   private:
-    const gfx::Transform identity_transform_;
-  };
-
-  typedef CalcDrawPropsInputs<Layer, RenderSurfaceLayerList>
-      CalcDrawPropsMainInputs;
-  typedef CalcDrawPropsInputsForTesting<Layer, RenderSurfaceLayerList>
-      CalcDrawPropsMainInputsForTesting;
-  static void CalculateDrawProperties(CalcDrawPropsMainInputs* inputs);
-
-  typedef CalcDrawPropsInputs<LayerImpl, LayerImplList> CalcDrawPropsImplInputs;
-  typedef CalcDrawPropsInputsForTesting<LayerImpl, LayerImplList>
-      CalcDrawPropsImplInputsForTesting;
-  static void CalculateDrawProperties(CalcDrawPropsImplInputs* inputs);
+  static void CalculateDrawProperties(
+      Layer* root_layer,
+      gfx::Size device_viewport_size,
+      const gfx::Transform& device_transform,
+      float device_scale_factor,
+      float page_scale_factor,
+      Layer* page_scale_application_layer,
+      int max_texture_size,
+      bool can_use_lcd_text,
+      bool can_adjust_raster_scales,
+      RenderSurfaceLayerList* render_surface_layer_list);
+  static void CalculateDrawProperties(
+      LayerImpl* root_layer,
+      gfx::Size device_viewport_size,
+      const gfx::Transform& device_transform,
+      float device_scale_factor,
+      float page_scale_factor,
+      LayerImpl* page_scale_application_layer,
+      int max_texture_size,
+      bool can_use_lcd_text,
+      bool can_adjust_raster_scales,
+      LayerImplList* render_surface_layer_list);
 
   // Performs hit testing for a given render_surface_layer_list.
   static LayerImpl* FindLayerThatIsHitByPoint(
@@ -203,51 +161,6 @@ void LayerTreeHostCommon::CallFunctionForSubtree(
   }
 }
 
-template <typename LayerType, typename RenderSurfaceLayerListType>
-LayerTreeHostCommon::CalcDrawPropsInputsForTesting<LayerType,
-                                                   RenderSurfaceLayerListType>::
-    CalcDrawPropsInputsForTesting(
-        LayerType* root_layer,
-        gfx::Size device_viewport_size,
-        const gfx::Transform& device_transform,
-        RenderSurfaceLayerListType* render_surface_layer_list)
-    : CalcDrawPropsInputs<LayerType, RenderSurfaceLayerListType>(
-          root_layer,
-          device_viewport_size,
-          device_transform,
-          1.f,
-          1.f,
-          NULL,
-          std::numeric_limits<int>::max() / 2,
-          false,
-          false,
-          render_surface_layer_list) {
-  DCHECK(root_layer);
-  DCHECK(render_surface_layer_list);
-}
-
-template <typename LayerType, typename RenderSurfaceLayerListType>
-LayerTreeHostCommon::CalcDrawPropsInputsForTesting<LayerType,
-                                                   RenderSurfaceLayerListType>::
-    CalcDrawPropsInputsForTesting(
-        LayerType* root_layer,
-        gfx::Size device_viewport_size,
-        RenderSurfaceLayerListType* render_surface_layer_list)
-    : CalcDrawPropsInputs<LayerType, RenderSurfaceLayerListType>(
-          root_layer,
-          device_viewport_size,
-          identity_transform_,
-          1.f,
-          1.f,
-          NULL,
-          std::numeric_limits<int>::max() / 2,
-          false,
-          false,
-          render_surface_layer_list) {
-  DCHECK(root_layer);
-  DCHECK(render_surface_layer_list);
-}
-
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_COMMON_H_
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index 272030a..0a8f5f6 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -90,6 +90,7 @@ class LayerTreeHostCommonTestBase {
                                       bool can_use_lcd_text) {
     EXPECT_TRUE(page_scale_application_layer || (page_scale_factor == 1.f));
     gfx::Transform identity_matrix;
+    int dummy_max_texture_size = 512;
     gfx::Size device_viewport_size =
         gfx::Size(root_layer->bounds().width() * device_scale_factor,
                   root_layer->bounds().height() * device_scale_factor);
@@ -99,14 +100,17 @@ class LayerTreeHostCommonTestBase {
     // We are probably not testing what is intended if the root_layer bounds are
     // empty.
     DCHECK(!root_layer->bounds().IsEmpty());
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root_layer, device_viewport_size, render_surface_layer_list_.get());
-    inputs.device_scale_factor = device_scale_factor;
-    inputs.page_scale_factor = page_scale_factor;
-    inputs.page_scale_application_layer = page_scale_application_layer;
-    inputs.can_use_lcd_text = can_use_lcd_text;
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root_layer,
+        device_viewport_size,
+        gfx::Transform(),
+        device_scale_factor,
+        page_scale_factor,
+        page_scale_application_layer,
+        dummy_max_texture_size,
+        can_use_lcd_text,
+        true,  // can_adjust_raster_scale
+        render_surface_layer_list_.get());
   }
 
   void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
@@ -116,6 +120,7 @@ class LayerTreeHostCommonTestBase {
                                       bool can_use_lcd_text) {
     gfx::Transform identity_matrix;
     LayerImplList dummy_render_surface_layer_list;
+    int dummy_max_texture_size = 512;
     gfx::Size device_viewport_size =
         gfx::Size(root_layer->bounds().width() * device_scale_factor,
                   root_layer->bounds().height() * device_scale_factor);
@@ -123,14 +128,17 @@ class LayerTreeHostCommonTestBase {
     // We are probably not testing what is intended if the root_layer bounds are
     // empty.
     DCHECK(!root_layer->bounds().IsEmpty());
-    LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root_layer, device_viewport_size, &dummy_render_surface_layer_list);
-    inputs.device_scale_factor = device_scale_factor;
-    inputs.page_scale_factor = page_scale_factor;
-    inputs.page_scale_application_layer = page_scale_application_layer;
-    inputs.can_use_lcd_text = can_use_lcd_text;
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root_layer,
+        device_viewport_size,
+        gfx::Transform(),
+        device_scale_factor,
+        page_scale_factor,
+        page_scale_application_layer,
+        dummy_max_texture_size,
+        can_use_lcd_text,
+        true,  // can_adjust_raster_scale
+        &dummy_render_surface_layer_list);
   }
 
   template <class LayerType>
@@ -1515,14 +1523,23 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
                                gfx::Size(20, 20),
                                false);
 
+  int dummy_max_texture_size = 512;
+
   gfx::Transform translate;
   translate.Translate(50, 50);
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), translate, &render_surface_layer_list);
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        root->bounds(),
+        translate,
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
     EXPECT_EQ(translate, root->draw_properties().target_space_transform);
     EXPECT_EQ(translate, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
@@ -1532,10 +1549,17 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
   scale.Scale(2, 2);
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), scale, &render_surface_layer_list);
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        root->bounds(),
+        scale,
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
     EXPECT_EQ(scale, root->draw_properties().target_space_transform);
     EXPECT_EQ(scale, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
@@ -1545,10 +1569,17 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
   rotate.Rotate(2);
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), rotate, &render_surface_layer_list);
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        root->bounds(),
+        rotate,
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
     EXPECT_EQ(rotate, root->draw_properties().target_space_transform);
     EXPECT_EQ(rotate, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
@@ -1560,10 +1591,17 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
   composite.ConcatTransform(rotate);
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), composite, &render_surface_layer_list);
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        root->bounds(),
+        composite,
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
     EXPECT_EQ(composite, root->draw_properties().target_space_transform);
     EXPECT_EQ(composite, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
@@ -1574,11 +1612,17 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), translate, &render_surface_layer_list);
-    inputs.device_scale_factor = device_scale_factor;
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        root->bounds(),
+        translate,
+        device_scale_factor,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
     gfx::Transform device_scaled_translate = translate;
     device_scaled_translate.Scale(device_scale_factor, device_scale_factor);
     EXPECT_EQ(device_scaled_translate,
@@ -1593,12 +1637,17 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), translate, &render_surface_layer_list);
-    inputs.page_scale_factor = page_scale_factor;
-    inputs.page_scale_application_layer = root.get();
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        root->bounds(),
+        translate,
+        1.f,
+        page_scale_factor,
+        root.get(),
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
     gfx::Transform page_scaled_translate = translate;
     page_scaled_translate.Scale(page_scale_factor, page_scale_factor);
     EXPECT_EQ(translate, root->draw_properties().target_space_transform);
@@ -1613,10 +1662,17 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), composite, &render_surface_layer_list);
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        root->bounds(),
+        composite,
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
     gfx::Transform compositeSquared = composite;
     compositeSquared.ConcatTransform(composite);
     gfx::Transform compositeCubed = compositeSquared;
@@ -1663,12 +1719,17 @@ TEST_F(LayerTreeHostCommonTest,
   render_surface1->SetForceRenderSurface(true);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      parent.get(),
-      parent->bounds(),
-      gfx::Transform(),
-      &render_surface_layer_list);
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
+                                               parent->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // The child layer's content is entirely outside the parent's clip rect, so
   // the intermediate render surface should not be listed here, even if it was
@@ -1708,10 +1769,17 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForTransparentChild) {
   render_surface1->SetOpacity(0.f);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      parent.get(), parent->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
+                                               parent->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Since the layer is transparent, render_surface1->render_surface() should
   // not have gotten added anywhere.  Also, the drawable content rect should not
@@ -1760,12 +1828,20 @@ TEST_F(LayerTreeHostCommonTest, ForceRenderSurface) {
   EXPECT_FALSE(parent->render_surface());
   EXPECT_FALSE(render_surface1->render_surface());
 
+  int dummy_max_texture_size = 512;
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        parent.get(), parent->bounds(), &render_surface_layer_list);
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        parent.get(),
+        parent->bounds(),
+        gfx::Transform(),
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
 
     // The root layer always creates a render surface
     EXPECT_TRUE(parent->render_surface());
@@ -1776,10 +1852,17 @@ TEST_F(LayerTreeHostCommonTest, ForceRenderSurface) {
   {
     RenderSurfaceLayerList render_surface_layer_list;
     render_surface1->SetForceRenderSurface(false);
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        parent.get(), parent->bounds(), &render_surface_layer_list);
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        parent.get(),
+        parent->bounds(),
+        gfx::Transform(),
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
     EXPECT_TRUE(parent->render_surface());
     EXPECT_FALSE(render_surface1->render_surface());
     EXPECT_EQ(1U, render_surface_layer_list.size());
@@ -1872,10 +1955,17 @@ TEST_F(LayerTreeHostCommonTest, ClipRectCullsRenderSurfaces) {
   great_grand_child->SetOpacity(0.4f);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      parent.get(), parent->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
+                                               parent->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   ASSERT_EQ(2U, render_surface_layer_list.size());
   EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
@@ -1948,10 +2038,18 @@ TEST_F(LayerTreeHostCommonTest, ClipRectCullsSurfaceWithoutVisibleContent) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        parent.get(), parent->bounds(), &render_surface_layer_list);
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    int dummy_max_texture_size = 512;
+    LayerTreeHostCommon::CalculateDrawProperties(
+        parent.get(),
+        parent->bounds(),
+        gfx::Transform(),
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
 
     // Without an animation, we should cull child and grand_child from the
     // render_surface_layer_list.
@@ -1965,10 +2063,18 @@ TEST_F(LayerTreeHostCommonTest, ClipRectCullsSurfaceWithoutVisibleContent) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        parent.get(), parent->bounds(), &render_surface_layer_list);
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    int dummy_max_texture_size = 512;
+    LayerTreeHostCommon::CalculateDrawProperties(
+        parent.get(),
+        parent->bounds(),
+        gfx::Transform(),
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
 
     // With an animating transform, we should keep child and grand_child in the
     // render_surface_layer_list.
@@ -2062,13 +2168,22 @@ TEST_F(LayerTreeHostCommonTest, IsClippedIsSetCorrectly) {
                                gfx::Size(100, 100),
                                false);
 
+  int dummy_max_texture_size = 512;
+
   // Case 1: nothing is clipped except the root render surface.
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), parent->bounds(), &render_surface_layer_list);
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        parent->bounds(),
+        gfx::Transform(),
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
 
     ASSERT_TRUE(root->render_surface());
     ASSERT_TRUE(child2->render_surface());
@@ -2091,10 +2206,17 @@ TEST_F(LayerTreeHostCommonTest, IsClippedIsSetCorrectly) {
   {
     RenderSurfaceLayerList render_surface_layer_list;
     parent->SetMasksToBounds(true);
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), parent->bounds(), &render_surface_layer_list);
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        parent->bounds(),
+        gfx::Transform(),
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
 
     ASSERT_TRUE(root->render_surface());
     ASSERT_TRUE(child2->render_surface());
@@ -2116,10 +2238,17 @@ TEST_F(LayerTreeHostCommonTest, IsClippedIsSetCorrectly) {
     RenderSurfaceLayerList render_surface_layer_list;
     parent->SetMasksToBounds(false);
     child2->SetMasksToBounds(true);
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), parent->bounds(), &render_surface_layer_list);
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        parent->bounds(),
+        gfx::Transform(),
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
 
     ASSERT_TRUE(root->render_surface());
     ASSERT_TRUE(child2->render_surface());
@@ -2219,10 +2348,17 @@ TEST_F(LayerTreeHostCommonTest, drawable_content_rectForLayers) {
   grand_child4->SetOpacity(0.5f);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      parent.get(), parent->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
+                                               parent->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   EXPECT_RECT_EQ(gfx::Rect(5, 5, 10, 10),
                  grand_child1->drawable_content_rect());
@@ -2358,10 +2494,18 @@ TEST_F(LayerTreeHostCommonTest, ClipRectIsPropagatedCorrectlyToSurfaces) {
   grand_child4->SetForceRenderSurface(true);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      parent.get(), parent->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
+                                               parent->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
+
   ASSERT_TRUE(grand_child1->render_surface());
   ASSERT_TRUE(grand_child2->render_surface());
   ASSERT_TRUE(grand_child3->render_surface());
@@ -3677,10 +3821,17 @@ TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithoutPreserves3d) {
                                false);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      parent.get(), parent->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
+                                               parent->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Verify which render surfaces were created.
   EXPECT_FALSE(front_facing_child->render_surface());
@@ -3868,10 +4019,17 @@ TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithPreserves3d) {
                                false);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      parent.get(), parent->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
+                                               parent->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Verify which render surfaces were created.
   EXPECT_FALSE(front_facing_child->render_surface());
@@ -4004,10 +4162,17 @@ TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
                                false);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      parent.get(), parent->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
+                                               parent->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   EXPECT_FALSE(child->render_surface());
   EXPECT_TRUE(animating_surface->render_surface());
@@ -4127,10 +4292,17 @@ TEST_F(LayerTreeHostCommonTest,
                                false);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      parent.get(), parent->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
+                                               parent->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Verify which render surfaces were created.
   EXPECT_TRUE(front_facing_surface->render_surface());
@@ -4202,10 +4374,17 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayer) {
   root->SetDrawsContent(true);
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -4272,10 +4451,17 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayerAndHud) {
   root->AddChild(hud.PassAs<LayerImpl>());
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), hud_bounds, &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               hud_bounds,
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -4334,10 +4520,17 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForUninvertibleTransform) {
   root->SetDrawsContent(true);
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -4405,10 +4598,17 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForSinglePositionedLayer) {
   root->SetDrawsContent(true);
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -4465,10 +4665,17 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForSingleRotatedLayer) {
   root->SetDrawsContent(true);
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -4538,10 +4745,17 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForSinglePerspectiveLayer) {
   root->SetDrawsContent(true);
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -4622,10 +4836,17 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayerWithScaledContents) {
   }
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   // The visible content rect for test_layer is actually 100x100, even though
@@ -4717,10 +4938,17 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForSimpleClippedLayer) {
   }
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -4845,10 +5073,17 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForMultiClippedRotatedLayer) {
   }
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   // The grand_child is expected to create a render surface because it
@@ -4968,10 +5203,17 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForNonClippingIntermediateLayer) {
   }
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -5080,10 +5322,17 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForMultipleLayers) {
   LayerImpl* grand_child1 = child1->children()[0];
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   ASSERT_TRUE(child1);
@@ -5230,10 +5479,17 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForMultipleLayerLists) {
   LayerImpl* grand_child1 = child1->children()[0];
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   ASSERT_TRUE(child1);
@@ -5343,10 +5599,17 @@ TEST_F(LayerTreeHostCommonTest, HitCheckingTouchHandlerRegionsForSingleLayer) {
   root->SetDrawsContent(true);
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -5435,10 +5698,17 @@ TEST_F(LayerTreeHostCommonTest,
   root->SetTouchEventHandlerRegion(touch_handler_region);
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -5517,10 +5787,17 @@ TEST_F(LayerTreeHostCommonTest,
   root->SetTouchEventHandlerRegion(touch_handler_region);
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -5617,10 +5894,17 @@ TEST_F(LayerTreeHostCommonTest,
   }
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   // The visible content rect for test_layer is actually 100x100, even though
@@ -5720,18 +6004,21 @@ TEST_F(LayerTreeHostCommonTest,
   }
 
   LayerImplList render_surface_layer_list;
+  int dummy_max_texture_size = 512;
   float device_scale_factor = 3.f;
   float page_scale_factor = 5.f;
   gfx::Size scaled_bounds_for_root = gfx::ToCeiledSize(
       gfx::ScaleSize(root->bounds(), device_scale_factor * page_scale_factor));
-
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), scaled_bounds_for_root, &render_surface_layer_list);
-  inputs.device_scale_factor = device_scale_factor;
-  inputs.page_scale_factor = page_scale_factor;
-  inputs.page_scale_application_layer = root.get();
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               scaled_bounds_for_root,
+                                               gfx::Transform(),
+                                               device_scale_factor,
+                                               page_scale_factor,
+                                               root.get(),
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   // The visible content rect for test_layer is actually 100x100, even though
@@ -5862,10 +6149,17 @@ TEST_F(LayerTreeHostCommonTest,
   }
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -5996,16 +6290,22 @@ TEST_F(LayerTreeHostCommonTest, LayerTransformsInHighDPI) {
   parent->AddChild(child_empty);
   parent->AddChild(child_no_scale);
 
+  RenderSurfaceLayerList render_surface_layer_list;
+  int dummy_max_texture_size = 512;
+
   float device_scale_factor = 2.5f;
   float page_scale_factor = 1.f;
 
-  RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      parent.get(), parent->bounds(), &render_surface_layer_list);
-  inputs.device_scale_factor = device_scale_factor;
-  inputs.page_scale_factor = page_scale_factor;
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
+                                               parent->bounds(),
+                                               gfx::Transform(),
+                                               device_scale_factor,
+                                               page_scale_factor,
+                                               parent.get(),
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, child);
@@ -6131,17 +6431,22 @@ TEST_F(LayerTreeHostCommonTest, SurfaceLayerTransformsInHighDPI) {
   parent->AddChild(scale_surface);
   root->AddChild(parent);
 
+  RenderSurfaceLayerList render_surface_layer_list;
+  int dummy_max_texture_size = 512;
+
   float device_scale_factor = 2.5f;
   float page_scale_factor = 3.f;
 
-  RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root.get(), parent->bounds(), &render_surface_layer_list);
-  inputs.device_scale_factor = device_scale_factor;
-  inputs.page_scale_factor = page_scale_factor;
-  inputs.page_scale_application_layer = root;
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               parent->bounds(),
+                                               gfx::Transform(),
+                                               device_scale_factor,
+                                               page_scale_factor,
+                                               root,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
@@ -6227,17 +6532,22 @@ TEST_F(LayerTreeHostCommonTest,
   parent->AddChild(child);
   parent->AddChild(child_no_scale);
 
+  RenderSurfaceLayerList render_surface_layer_list;
+  int dummy_max_texture_size = 512;
+
   float device_scale_factor = 1.7f;
   float page_scale_factor = 1.f;
 
-  RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      parent.get(), parent->bounds(), &render_surface_layer_list);
-  inputs.device_scale_factor = device_scale_factor;
-  inputs.page_scale_factor = page_scale_factor;
-  inputs.page_scale_application_layer = parent.get();
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
+                                               parent->bounds(),
+                                               gfx::Transform(),
+                                               device_scale_factor,
+                                               page_scale_factor,
+                                               parent.get(),
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, child);
@@ -6362,18 +6672,24 @@ TEST_F(LayerTreeHostCommonTest, ContentsScale) {
   parent->AddChild(child_empty);
   parent->AddChild(child_no_scale);
 
+  int dummy_max_texture_size = 512;
+
   float device_scale_factor = 2.5f;
   float page_scale_factor = 1.f;
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
-    inputs.device_scale_factor = device_scale_factor;
-    inputs.page_scale_factor = page_scale_factor;
-    inputs.page_scale_application_layer = root.get();
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        root->bounds(),
+        gfx::Transform(),
+        device_scale_factor,
+        page_scale_factor,
+        root.get(),
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
 
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                              initial_parent_scale, parent);
@@ -6414,18 +6730,22 @@ TEST_F(LayerTreeHostCommonTest, ContentsScale) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
-    inputs.device_scale_factor = device_scale_factor;
-    inputs.page_scale_factor = page_scale_factor;
-    inputs.page_scale_application_layer = root.get();
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
-
-    EXPECT_CONTENTS_SCALE_EQ(
-        device_scale_factor * page_scale_factor * initial_parent_scale, parent);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        root->bounds(),
+        gfx::Transform(),
+        device_scale_factor,
+        page_scale_factor,
+        root.get(),
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
+    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
+                             initial_parent_scale,
+                             parent);
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
-                                 initial_parent_scale * initial_child_scale,
+                             initial_parent_scale * initial_child_scale,
                              child_scale);
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                              initial_parent_scale * initial_child_scale,
@@ -6442,13 +6762,17 @@ TEST_F(LayerTreeHostCommonTest, ContentsScale) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
-    inputs.device_scale_factor = device_scale_factor;
-    inputs.page_scale_factor = page_scale_factor;
-    inputs.page_scale_application_layer = root.get();
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        root->bounds(),
+        gfx::Transform(),
+        device_scale_factor,
+        page_scale_factor,
+        root.get(),
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
 
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                              initial_parent_scale,
@@ -6467,13 +6791,17 @@ TEST_F(LayerTreeHostCommonTest, ContentsScale) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
-    inputs.device_scale_factor = device_scale_factor;
-    inputs.page_scale_factor = page_scale_factor;
-    inputs.page_scale_application_layer = root.get();
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        root->bounds(),
+        gfx::Transform(),
+        device_scale_factor,
+        page_scale_factor,
+        root.get(),
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
 
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                              initial_parent_scale,
@@ -6548,16 +6876,22 @@ TEST_F(LayerTreeHostCommonTest,
   parent->AddChild(child_no_scale);
 
   RenderSurfaceLayerList render_surface_layer_list;
+  int dummy_max_texture_size = 512;
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 1.f;
 
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.device_scale_factor = device_scale_factor;
-  inputs.page_scale_factor = page_scale_factor;
-  inputs.page_scale_application_layer = root.get(),
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  LayerTreeHostCommon::CalculateDrawProperties(
+      root.get(),
+      root->bounds(),
+      gfx::Transform(),
+      device_scale_factor,
+      page_scale_factor,
+      root.get(),
+      dummy_max_texture_size,
+      false,
+      false,  // can_adjust_raster_scale
+      &render_surface_layer_list);
 
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
@@ -6626,18 +6960,24 @@ TEST_F(LayerTreeHostCommonTest, SmallContentsScale) {
 
   parent->AddChild(child_scale);
 
+  int dummy_max_texture_size = 512;
+
   float device_scale_factor = 2.5f;
   float page_scale_factor = 0.01f;
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
-    inputs.device_scale_factor = device_scale_factor;
-    inputs.page_scale_factor = page_scale_factor;
-    inputs.page_scale_application_layer = root.get();
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        root->bounds(),
+        gfx::Transform(),
+        device_scale_factor,
+        page_scale_factor,
+        root.get(),
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
 
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                              initial_parent_scale,
@@ -6657,13 +6997,17 @@ TEST_F(LayerTreeHostCommonTest, SmallContentsScale) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
-    inputs.device_scale_factor = device_scale_factor;
-    inputs.page_scale_factor = page_scale_factor;
-    inputs.page_scale_application_layer = root.get();
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        root->bounds(),
+        gfx::Transform(),
+        device_scale_factor,
+        page_scale_factor,
+        root.get(),
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
 
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                              initial_parent_scale,
@@ -6771,22 +7115,27 @@ TEST_F(LayerTreeHostCommonTest, ContentsScaleForSurfaces) {
   surface_no_scale->AddChild(surface_no_scale_child_scale);
   surface_no_scale->AddChild(surface_no_scale_child_no_scale);
 
+  RenderSurfaceLayerList render_surface_layer_list;
+  int dummy_max_texture_size = 512;
+
   double device_scale_factor = 5;
   double page_scale_factor = 7;
 
-  RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.device_scale_factor = device_scale_factor;
-  inputs.page_scale_factor = page_scale_factor;
-  inputs.page_scale_application_layer = root.get();
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
-
-  EXPECT_CONTENTS_SCALE_EQ(
-      device_scale_factor * page_scale_factor * initial_parent_scale, parent);
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               device_scale_factor,
+                                               page_scale_factor,
+                                               root.get(),
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
-                               initial_parent_scale * initial_child_scale,
+                           initial_parent_scale,
+                           parent);
+  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
+                           initial_parent_scale * initial_child_scale,
                            surface_scale);
   EXPECT_CONTENTS_SCALE_EQ(1, surface_no_scale);
   EXPECT_CONTENTS_SCALE_EQ(
@@ -6982,16 +7331,22 @@ TEST_F(LayerTreeHostCommonTest,
   surface_no_scale->AddChild(surface_no_scale_child_no_scale);
 
   RenderSurfaceLayerList render_surface_layer_list;
+  int dummy_max_texture_size = 512;
 
-  double device_scale_factor = 5.0;
-  double page_scale_factor = 7.0;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.device_scale_factor = device_scale_factor;
-  inputs.page_scale_factor = page_scale_factor;
-  inputs.page_scale_application_layer = root.get();
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  double device_scale_factor = 5;
+  double page_scale_factor = 7;
 
+  LayerTreeHostCommon::CalculateDrawProperties(
+      root.get(),
+      root->bounds(),
+      gfx::Transform(),
+      device_scale_factor,
+      page_scale_factor,
+      root.get(),
+      dummy_max_texture_size,
+      false,
+      false,  // can_adjust_raster_scale
+      &render_surface_layer_list);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
                            parent);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
@@ -7133,12 +7488,21 @@ TEST_F(LayerTreeHostCommonTest, ContentsScaleForAnimatingLayer) {
   int animation_id = AddAnimatedTransformToController(
       child_scale->layer_animation_controller(), 10.0, 30, 0);
 
+  int dummy_max_texture_size = 512;
+
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        root->bounds(),
+        gfx::Transform(),
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
 
     EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale, parent);
     // The layers with animating transforms should not compute a contents scale
@@ -7151,10 +7515,17 @@ TEST_F(LayerTreeHostCommonTest, ContentsScaleForAnimatingLayer) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root.get(),
+        root->bounds(),
+        gfx::Transform(),
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,
+        true,  // can_adjust_raster_scale
+        &render_surface_layer_list);
 
     EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale, parent);
     // The layers with animating transforms should not compute a contents scale
@@ -7214,13 +7585,19 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceTransformsInHighDPI) {
   child->SetReplicaLayer(replica.get());
 
   RenderSurfaceLayerList render_surface_layer_list;
+  int dummy_max_texture_size = 512;
 
   float device_scale_factor = 1.5f;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      parent.get(), parent->bounds(), &render_surface_layer_list);
-  inputs.device_scale_factor = device_scale_factor;
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
+                                               parent->bounds(),
+                                               gfx::Transform(),
+                                               device_scale_factor,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // We should have two render surfaces. The root's render surface and child's
   // render surface (it needs one because it has a replica layer).
@@ -7345,14 +7722,20 @@ TEST_F(LayerTreeHostCommonTest,
   child->AddChild(duplicate_child_non_owner);
   child->SetReplicaLayer(replica.get());
 
-  float device_scale_factor = 1.7f;
-
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      parent.get(), parent->bounds(), &render_surface_layer_list);
-  inputs.device_scale_factor = device_scale_factor;
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+
+  float device_scale_factor = 1.7f;
+  LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
+                                               parent->bounds(),
+                                               gfx::Transform(),
+                                               device_scale_factor,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // We should have two render surfaces. The root's render surface and child's
   // render surface (it needs one because it has a replica layer).
@@ -7497,10 +7880,17 @@ TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {
   root->AddChild(child.Pass());
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // We should have one render surface and two layers. The child
   // layer should be included even though it is transparent.
@@ -7699,10 +8089,17 @@ TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayer) {
   root->AddChild(child);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // We should have one render surface and two layers. The grand child has
   // hidden itself.
@@ -7754,10 +8151,17 @@ TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayerImpl) {
   root->AddChild(child.Pass());
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // We should have one render surface and two layers. The grand child has
   // hidden itself.
@@ -7808,10 +8212,17 @@ TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayers) {
   root->AddChild(child);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // We should have one render surface and one layers. The child has
   // hidden itself and the grand child.
@@ -7862,10 +8273,17 @@ TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) {
   root->AddChild(child.Pass());
 
   LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // We should have one render surface and one layers. The child has
   // hidden itself and the grand child.
@@ -7970,10 +8388,17 @@ TEST_F(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {
   EXPECT_TRUE(copy_layer->HasCopyRequest());
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   EXPECT_TRUE(root->draw_properties().layer_or_descendant_has_copy_request);
   EXPECT_TRUE(copy_grand_parent->draw_properties().
@@ -8075,10 +8500,17 @@ TEST_F(LayerTreeHostCommonTest, ClippedOutCopyRequest) {
   EXPECT_TRUE(copy_layer->HasCopyRequest());
 
   RenderSurfaceLayerList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  int dummy_max_texture_size = 512;
+  LayerTreeHostCommon::CalculateDrawProperties(root.get(),
+                                               root->bounds(),
+                                               gfx::Transform(),
+                                               1.f,
+                                               1.f,
+                                               NULL,
+                                               dummy_max_texture_size,
+                                               false,
+                                               true,  // can_adjust_raster_scale
+                                               &render_surface_layer_list);
 
   // We should have one render surface, as the others are clipped out.
   ASSERT_EQ(1u, render_surface_layer_list.size());
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 860f067..d69e7ff 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -284,7 +284,7 @@ void LayerTreeImpl::UpdateDrawProperties() {
                  IsActiveTree(),
                  "SourceFrameNumber",
                  source_frame_number_);
-    LayerTreeHostCommon::CalcDrawPropsImplInputs inputs(
+    LayerTreeHostCommon::CalculateDrawProperties(
         root_layer(),
         layer_tree_host_impl_->DeviceViewport().size(),
         layer_tree_host_impl_->DeviceTransform(),
@@ -295,7 +295,6 @@ void LayerTreeImpl::UpdateDrawProperties() {
         settings().can_use_lcd_text,
         settings().layer_transforms_should_scale_layer_contents,
         &render_surface_layer_list_);
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   }
 
   DCHECK(!needs_update_draw_properties_) <<
diff --git a/cc/trees/occlusion_tracker_unittest.cc b/cc/trees/occlusion_tracker_unittest.cc
index db019c5..5a1aae1 100644
--- a/cc/trees/occlusion_tracker_unittest.cc
+++ b/cc/trees/occlusion_tracker_unittest.cc
@@ -309,12 +309,21 @@ template <typename Types> class OcclusionTrackerTest : public testing::Test {
 
   void CalcDrawEtc(TestContentLayerImpl* root) {
     DCHECK(root == root_.get());
+    int dummy_max_texture_size = 512;
+
     DCHECK(!root->render_surface());
 
-    LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), &render_surface_layer_list_impl_);
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root,
+        root->bounds(),
+        gfx::Transform(),
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,  // can_use_lcd_text
+        true,  // can_adjust_raster_scales
+        &render_surface_layer_list_impl_);
 
     layer_iterator_ = layer_iterator_begin_ =
         Types::TestLayerIterator::Begin(&render_surface_layer_list_impl_);
@@ -322,13 +331,22 @@ template <typename Types> class OcclusionTrackerTest : public testing::Test {
 
   void CalcDrawEtc(TestContentLayer* root) {
     DCHECK(root == root_.get());
+    int dummy_max_texture_size = 512;
+
     DCHECK(!root->render_surface());
 
     render_surface_layer_list_.reset(new RenderSurfaceLayerList);
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root, root->bounds(), render_surface_layer_list_.get());
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    LayerTreeHostCommon::CalculateDrawProperties(
+        root,
+        root->bounds(),
+        gfx::Transform(),
+        1.f,
+        1.f,
+        NULL,
+        dummy_max_texture_size,
+        false,  // can_use_lcd_text
+        true,  // can_adjust_raster_scales
+        render_surface_layer_list_.get());
 
     layer_iterator_ = layer_iterator_begin_ =
         Types::TestLayerIterator::Begin(render_surface_layer_list_.get());