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

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

7 files changed, 498 insertions, 886 deletions

diff --git a/cc/trees/damage_tracker_unittest.cc b/cc/trees/damage_tracker_unittest.cc
index a3dd636..9e45379 100644
--- a/cc/trees/damage_tracker_unittest.cc
+++ b/cc/trees/damage_tracker_unittest.cc
@@ -20,27 +20,17 @@
 namespace cc {
 namespace {
 
-void ExecuteCalculateDrawProperties(
-    LayerImpl* root,
-    LayerImplList& render_surface_layer_list) {
-  int dummy_max_texture_size = 512;
-
+void ExecuteCalculateDrawProperties(LayerImpl* root,
+                                    LayerImplList& render_surface_layer_list) {
   // 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::CalculateDrawProperties(root,
-                                               root->bounds(),
-                                               gfx::Transform(),
-                                               1.f,
-                                               1.f,
-                                               NULL,
-                                               dummy_max_texture_size,
-                                               false,
-                                               false,
-                                               &render_surface_layer_list);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root, root->bounds(), &render_surface_layer_list);
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 }
 
 void ClearDamageForAllSurfaces(LayerImpl* layer) {
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index 0d90c59..0f07b43 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::CalculateDrawProperties(
+    LayerTreeHostCommon::CalcDrawPropsMainInputs inputs(
         root_layer,
         device_viewport_size(),
         gfx::Transform(),
@@ -722,6 +722,7 @@ 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 dce396f..88acc47 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -1597,55 +1597,47 @@ static void CalculateDrawPropertiesInternal(
 }
 
 void LayerTreeHostCommon::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) {
+    CalcDrawPropsMainInputs* inputs) {
+  DCHECK(inputs->root_layer);
+  DCHECK(IsRootLayer(inputs->root_layer));
+  DCHECK(inputs->render_surface_layer_list);
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
-  gfx::Transform scaled_device_transform = device_transform;
-  scaled_device_transform.Scale(device_scale_factor, device_scale_factor);
+  gfx::Transform scaled_device_transform = inputs->device_transform;
+  scaled_device_transform.Scale(inputs->device_scale_factor,
+                                inputs->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(device_viewport_size);
+  gfx::Rect device_viewport_rect(inputs->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(root_layer, &recursive_data);
+  PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
 
   CalculateDrawPropertiesInternal<Layer, RenderSurfaceLayerList, RenderSurface>(
-      root_layer,
+      inputs->root_layer,
       scaled_device_transform,
       identity_matrix,
       identity_matrix,
-      root_layer,
+      inputs->root_layer,
       device_viewport_rect,
       device_viewport_rect,
       layer_or_ancestor_clips_descendants,
       NULL,
-      render_surface_layer_list,
+      inputs->render_surface_layer_list,
       &dummy_layer_list,
       NULL,
-      max_texture_size,
-      device_scale_factor,
-      page_scale_factor,
-      page_scale_application_layer,
+      inputs->max_texture_size,
+      inputs->device_scale_factor,
+      inputs->page_scale_factor,
+      inputs->page_scale_application_layer,
       in_subtree_of_page_scale_application_layer,
-      can_use_lcd_text,
-      can_adjust_raster_scales,
+      inputs->can_use_lcd_text,
+      inputs->can_adjust_raster_scales,
       subtree_is_visible,
       &total_drawable_content_rect);
 
@@ -1653,62 +1645,53 @@ void LayerTreeHostCommon::CalculateDrawProperties(
   DCHECK_EQ(0u, dummy_layer_list.size());
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
-  DCHECK(root_layer->render_surface());
+  DCHECK(inputs->root_layer->render_surface());
 }
 
 void LayerTreeHostCommon::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) {
+    CalcDrawPropsImplInputs* inputs) {
+  DCHECK(inputs->root_layer);
+  DCHECK(IsRootLayer(inputs->root_layer));
+  DCHECK(inputs->render_surface_layer_list);
+
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
-  gfx::Transform scaled_device_transform = device_transform;
-  scaled_device_transform.Scale(device_scale_factor, device_scale_factor);
+  gfx::Transform scaled_device_transform = inputs->device_transform;
+  scaled_device_transform.Scale(inputs->device_scale_factor,
+                                inputs->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(device_viewport_size);
+  gfx::Rect device_viewport_rect(inputs->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(root_layer, &recursive_data);
+  PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
 
-  CalculateDrawPropertiesInternal<LayerImpl,
-                                  LayerImplList,
-                                  RenderSurfaceImpl>(
-      root_layer,
+  CalculateDrawPropertiesInternal<LayerImpl, LayerImplList, RenderSurfaceImpl>(
+      inputs->root_layer,
       scaled_device_transform,
       identity_matrix,
       identity_matrix,
-      root_layer,
+      inputs->root_layer,
       device_viewport_rect,
       device_viewport_rect,
       layer_or_ancestor_clips_descendants,
       NULL,
-      render_surface_layer_list,
+      inputs->render_surface_layer_list,
       &dummy_layer_list,
       &layer_sorter,
-      max_texture_size,
-      device_scale_factor,
-      page_scale_factor,
-      page_scale_application_layer,
+      inputs->max_texture_size,
+      inputs->device_scale_factor,
+      inputs->page_scale_factor,
+      inputs->page_scale_application_layer,
       in_subtree_of_page_scale_application_layer,
-      can_use_lcd_text,
-      can_adjust_raster_scales,
+      inputs->can_use_lcd_text,
+      inputs->can_adjust_raster_scales,
       subtree_is_visible,
       &total_drawable_content_rect);
 
@@ -1716,7 +1699,7 @@ void LayerTreeHostCommon::CalculateDrawProperties(
   DCHECK_EQ(0u, dummy_layer_list.size());
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
-  DCHECK(root_layer->render_surface());
+  DCHECK(inputs->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 154d8a0..05affee 100644
--- a/cc/trees/layer_tree_host_common.h
+++ b/cc/trees/layer_tree_host_common.h
@@ -5,6 +5,7 @@
 #ifndef CC_TREES_LAYER_TREE_HOST_COMMON_H_
 #define CC_TREES_LAYER_TREE_HOST_COMMON_H_
 
+#include <limits>
 #include <vector>
 
 #include "base/bind.h"
@@ -27,28 +28,69 @@ class CC_EXPORT LayerTreeHostCommon {
                                         gfx::Rect layer_bound_rect,
                                         const gfx::Transform& transform);
 
-  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);
+  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);
 
   // Performs hit testing for a given render_surface_layer_list.
   static LayerImpl* FindLayerThatIsHitByPoint(
@@ -161,6 +203,51 @@ 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 0a8f5f6..272030a 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -90,7 +90,6 @@ 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);
@@ -100,17 +99,14 @@ class LayerTreeHostCommonTestBase {
     // We are probably not testing what is intended if the root_layer bounds are
     // empty.
     DCHECK(!root_layer->bounds().IsEmpty());
-    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());
+    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);
   }
 
   void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
@@ -120,7 +116,6 @@ 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);
@@ -128,17 +123,14 @@ class LayerTreeHostCommonTestBase {
     // We are probably not testing what is intended if the root_layer bounds are
     // empty.
     DCHECK(!root_layer->bounds().IsEmpty());
-    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);
+    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);
   }
 
   template <class LayerType>
@@ -1523,23 +1515,14 @@ 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::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);
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+        root.get(), root->bounds(), translate, &render_surface_layer_list);
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     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());
@@ -1549,17 +1532,10 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
   scale.Scale(2, 2);
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    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);
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+        root.get(), root->bounds(), scale, &render_surface_layer_list);
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     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());
@@ -1569,17 +1545,10 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
   rotate.Rotate(2);
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    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);
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+        root.get(), root->bounds(), rotate, &render_surface_layer_list);
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     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());
@@ -1591,17 +1560,10 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
   composite.ConcatTransform(rotate);
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    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);
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+        root.get(), root->bounds(), composite, &render_surface_layer_list);
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     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());
@@ -1612,17 +1574,11 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    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);
+    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);
     gfx::Transform device_scaled_translate = translate;
     device_scaled_translate.Scale(device_scale_factor, device_scale_factor);
     EXPECT_EQ(device_scaled_translate,
@@ -1637,17 +1593,12 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    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);
+    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);
     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);
@@ -1662,17 +1613,10 @@ TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    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);
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+        root.get(), root->bounds(), composite, &render_surface_layer_list);
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     gfx::Transform compositeSquared = composite;
     compositeSquared.ConcatTransform(composite);
     gfx::Transform compositeCubed = compositeSquared;
@@ -1719,17 +1663,12 @@ TEST_F(LayerTreeHostCommonTest,
   render_surface1->SetForceRenderSurface(true);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+      parent.get(),
+      parent->bounds(),
+      gfx::Transform(),
+      &render_surface_layer_list);
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // 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
@@ -1769,17 +1708,10 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForTransparentChild) {
   render_surface1->SetOpacity(0.f);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+      parent.get(), parent->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Since the layer is transparent, render_surface1->render_surface() should
   // not have gotten added anywhere.  Also, the drawable content rect should not
@@ -1828,20 +1760,12 @@ 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::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);
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+        parent.get(), parent->bounds(), &render_surface_layer_list);
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     // The root layer always creates a render surface
     EXPECT_TRUE(parent->render_surface());
@@ -1852,17 +1776,10 @@ TEST_F(LayerTreeHostCommonTest, ForceRenderSurface) {
   {
     RenderSurfaceLayerList render_surface_layer_list;
     render_surface1->SetForceRenderSurface(false);
-    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);
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+        parent.get(), parent->bounds(), &render_surface_layer_list);
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     EXPECT_TRUE(parent->render_surface());
     EXPECT_FALSE(render_surface1->render_surface());
     EXPECT_EQ(1U, render_surface_layer_list.size());
@@ -1955,17 +1872,10 @@ TEST_F(LayerTreeHostCommonTest, ClipRectCullsRenderSurfaces) {
   great_grand_child->SetOpacity(0.4f);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+      parent.get(), parent->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   ASSERT_EQ(2U, render_surface_layer_list.size());
   EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
@@ -2038,18 +1948,10 @@ TEST_F(LayerTreeHostCommonTest, ClipRectCullsSurfaceWithoutVisibleContent) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    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);
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+        parent.get(), parent->bounds(), &render_surface_layer_list);
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     // Without an animation, we should cull child and grand_child from the
     // render_surface_layer_list.
@@ -2063,18 +1965,10 @@ TEST_F(LayerTreeHostCommonTest, ClipRectCullsSurfaceWithoutVisibleContent) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    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);
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+        parent.get(), parent->bounds(), &render_surface_layer_list);
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     // With an animating transform, we should keep child and grand_child in the
     // render_surface_layer_list.
@@ -2168,22 +2062,13 @@ 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::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);
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+        root.get(), parent->bounds(), &render_surface_layer_list);
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     ASSERT_TRUE(root->render_surface());
     ASSERT_TRUE(child2->render_surface());
@@ -2206,17 +2091,10 @@ TEST_F(LayerTreeHostCommonTest, IsClippedIsSetCorrectly) {
   {
     RenderSurfaceLayerList render_surface_layer_list;
     parent->SetMasksToBounds(true);
-    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);
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+        root.get(), parent->bounds(), &render_surface_layer_list);
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     ASSERT_TRUE(root->render_surface());
     ASSERT_TRUE(child2->render_surface());
@@ -2238,17 +2116,10 @@ TEST_F(LayerTreeHostCommonTest, IsClippedIsSetCorrectly) {
     RenderSurfaceLayerList render_surface_layer_list;
     parent->SetMasksToBounds(false);
     child2->SetMasksToBounds(true);
-    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);
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+        root.get(), parent->bounds(), &render_surface_layer_list);
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     ASSERT_TRUE(root->render_surface());
     ASSERT_TRUE(child2->render_surface());
@@ -2348,17 +2219,10 @@ TEST_F(LayerTreeHostCommonTest, drawable_content_rectForLayers) {
   grand_child4->SetOpacity(0.5f);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+      parent.get(), parent->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   EXPECT_RECT_EQ(gfx::Rect(5, 5, 10, 10),
                  grand_child1->drawable_content_rect());
@@ -2494,18 +2358,10 @@ TEST_F(LayerTreeHostCommonTest, ClipRectIsPropagatedCorrectlyToSurfaces) {
   grand_child4->SetForceRenderSurface(true);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  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);
-
+  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+      parent.get(), parent->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   ASSERT_TRUE(grand_child1->render_surface());
   ASSERT_TRUE(grand_child2->render_surface());
   ASSERT_TRUE(grand_child3->render_surface());
@@ -3821,17 +3677,10 @@ TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithoutPreserves3d) {
                                false);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+      parent.get(), parent->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Verify which render surfaces were created.
   EXPECT_FALSE(front_facing_child->render_surface());
@@ -4019,17 +3868,10 @@ TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithPreserves3d) {
                                false);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+      parent.get(), parent->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Verify which render surfaces were created.
   EXPECT_FALSE(front_facing_child->render_surface());
@@ -4162,17 +4004,10 @@ TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
                                false);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+      parent.get(), parent->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   EXPECT_FALSE(child->render_surface());
   EXPECT_TRUE(animating_surface->render_surface());
@@ -4292,17 +4127,10 @@ TEST_F(LayerTreeHostCommonTest,
                                false);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+      parent.get(), parent->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Verify which render surfaces were created.
   EXPECT_TRUE(front_facing_surface->render_surface());
@@ -4374,17 +4202,10 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayer) {
   root->SetDrawsContent(true);
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -4451,17 +4272,10 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayerAndHud) {
   root->AddChild(hud.PassAs<LayerImpl>());
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), hud_bounds, &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -4520,17 +4334,10 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForUninvertibleTransform) {
   root->SetDrawsContent(true);
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -4598,17 +4405,10 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForSinglePositionedLayer) {
   root->SetDrawsContent(true);
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -4665,17 +4465,10 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForSingleRotatedLayer) {
   root->SetDrawsContent(true);
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -4745,17 +4538,10 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForSinglePerspectiveLayer) {
   root->SetDrawsContent(true);
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -4836,17 +4622,10 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayerWithScaledContents) {
   }
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   // The visible content rect for test_layer is actually 100x100, even though
@@ -4938,17 +4717,10 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForSimpleClippedLayer) {
   }
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -5073,17 +4845,10 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForMultiClippedRotatedLayer) {
   }
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   // The grand_child is expected to create a render surface because it
@@ -5203,17 +4968,10 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForNonClippingIntermediateLayer) {
   }
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -5322,17 +5080,10 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForMultipleLayers) {
   LayerImpl* grand_child1 = child1->children()[0];
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_TRUE(child1);
@@ -5479,17 +5230,10 @@ TEST_F(LayerTreeHostCommonTest, HitTestingForMultipleLayerLists) {
   LayerImpl* grand_child1 = child1->children()[0];
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_TRUE(child1);
@@ -5599,17 +5343,10 @@ TEST_F(LayerTreeHostCommonTest, HitCheckingTouchHandlerRegionsForSingleLayer) {
   root->SetDrawsContent(true);
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -5698,17 +5435,10 @@ TEST_F(LayerTreeHostCommonTest,
   root->SetTouchEventHandlerRegion(touch_handler_region);
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -5787,17 +5517,10 @@ TEST_F(LayerTreeHostCommonTest,
   root->SetTouchEventHandlerRegion(touch_handler_region);
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -5894,17 +5617,10 @@ TEST_F(LayerTreeHostCommonTest,
   }
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   // The visible content rect for test_layer is actually 100x100, even though
@@ -6004,21 +5720,18 @@ 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::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);
+
+  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);
 
   // Sanity check the scenario we just created.
   // The visible content rect for test_layer is actually 100x100, even though
@@ -6149,17 +5862,10 @@ TEST_F(LayerTreeHostCommonTest,
   }
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ -6290,22 +5996,16 @@ 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;
 
-  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);
+  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);
 
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, child);
@@ -6431,22 +6131,17 @@ 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;
 
-  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);
+  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);
 
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
@@ -6532,22 +6227,17 @@ 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;
 
-  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);
+  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);
 
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, child);
@@ -6672,24 +6362,18 @@ 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::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);
+    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);
@@ -6730,22 +6414,18 @@ TEST_F(LayerTreeHostCommonTest, ContentsScale) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    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);
+    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);
     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,
@@ -6762,17 +6442,13 @@ TEST_F(LayerTreeHostCommonTest, ContentsScale) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    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);
+    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,
@@ -6791,17 +6467,13 @@ TEST_F(LayerTreeHostCommonTest, ContentsScale) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    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);
+    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,
@@ -6876,22 +6548,16 @@ 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::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);
+  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);
 
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
@@ -6960,24 +6626,18 @@ 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::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);
+    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,
@@ -6997,17 +6657,13 @@ TEST_F(LayerTreeHostCommonTest, SmallContentsScale) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    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);
+    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,
@@ -7115,27 +6771,22 @@ 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;
 
-  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);
+  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);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
-                           initial_parent_scale * initial_child_scale,
+                               initial_parent_scale * initial_child_scale,
                            surface_scale);
   EXPECT_CONTENTS_SCALE_EQ(1, surface_no_scale);
   EXPECT_CONTENTS_SCALE_EQ(
@@ -7331,22 +6982,16 @@ 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;
-  double page_scale_factor = 7;
+  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);
 
-  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,
@@ -7488,21 +7133,12 @@ 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::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);
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+        root.get(), root->bounds(), &render_surface_layer_list);
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale, parent);
     // The layers with animating transforms should not compute a contents scale
@@ -7515,17 +7151,10 @@ TEST_F(LayerTreeHostCommonTest, ContentsScaleForAnimatingLayer) {
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
-    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);
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+        root.get(), root->bounds(), &render_surface_layer_list);
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale, parent);
     // The layers with animating transforms should not compute a contents scale
@@ -7585,19 +7214,13 @@ 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::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);
+  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);
 
   // 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).
@@ -7722,20 +7345,14 @@ TEST_F(LayerTreeHostCommonTest,
   child->AddChild(duplicate_child_non_owner);
   child->SetReplicaLayer(replica.get());
 
-  RenderSurfaceLayerList render_surface_layer_list;
-  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);
+
+  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);
 
   // 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).
@@ -7880,17 +7497,10 @@ TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {
   root->AddChild(child.Pass());
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and two layers. The child
   // layer should be included even though it is transparent.
@@ -8089,17 +7699,10 @@ TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayer) {
   root->AddChild(child);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and two layers. The grand child has
   // hidden itself.
@@ -8151,17 +7754,10 @@ TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayerImpl) {
   root->AddChild(child.Pass());
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and two layers. The grand child has
   // hidden itself.
@@ -8212,17 +7808,10 @@ TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayers) {
   root->AddChild(child);
 
   RenderSurfaceLayerList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and one layers. The child has
   // hidden itself and the grand child.
@@ -8273,17 +7862,10 @@ TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) {
   root->AddChild(child.Pass());
 
   LayerImplList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and one layers. The child has
   // hidden itself and the grand child.
@@ -8388,17 +7970,10 @@ TEST_F(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {
   EXPECT_TRUE(copy_layer->HasCopyRequest());
 
   RenderSurfaceLayerList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   EXPECT_TRUE(root->draw_properties().layer_or_descendant_has_copy_request);
   EXPECT_TRUE(copy_grand_parent->draw_properties().
@@ -8500,17 +8075,10 @@ TEST_F(LayerTreeHostCommonTest, ClippedOutCopyRequest) {
   EXPECT_TRUE(copy_layer->HasCopyRequest());
 
   RenderSurfaceLayerList render_surface_layer_list;
-  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);
+  LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // 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 d69e7ff..860f067 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::CalculateDrawProperties(
+    LayerTreeHostCommon::CalcDrawPropsImplInputs inputs(
         root_layer(),
         layer_tree_host_impl_->DeviceViewport().size(),
         layer_tree_host_impl_->DeviceTransform(),
@@ -295,6 +295,7 @@ 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 5a1aae1..db019c5 100644
--- a/cc/trees/occlusion_tracker_unittest.cc
+++ b/cc/trees/occlusion_tracker_unittest.cc
@@ -309,21 +309,12 @@ 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::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_);
+    LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+        root, root->bounds(), &render_surface_layer_list_impl_);
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     layer_iterator_ = layer_iterator_begin_ =
         Types::TestLayerIterator::Begin(&render_surface_layer_list_impl_);
@@ -331,22 +322,13 @@ 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::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());
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+        root, root->bounds(), render_surface_layer_list_.get());
+    inputs.can_adjust_raster_scales = true;
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     layer_iterator_ = layer_iterator_begin_ =
         Types::TestLayerIterator::Begin(render_surface_layer_list_.get());