cc: Move tiling management out of draw properties calculation.

This is mainly plumbing code.
As part of the changes, we are moving ManageTiling as part of 
UpdateTilePriorities.
We keep picturelayers content scale as 1,and maintain the remaining 
required scales in draw properties. This scales we apply later, 
to shared quad state and draw transform during AppendQuads.


BUG=None

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

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

14 files changed, 678 insertions, 486 deletions

diff --git a/cc/layers/draw_properties.h b/cc/layers/draw_properties.h
index 44be54b..a0bfc2a 100644
--- a/cc/layers/draw_properties.h
+++ b/cc/layers/draw_properties.h
@@ -36,7 +36,11 @@ struct CC_EXPORT DrawProperties {
         num_descendants_added(0),
         index_of_first_render_surface_layer_list_addition(0),
         num_render_surfaces_added(0),
-        last_drawn_render_surface_layer_list_id(0) {}
+        last_drawn_render_surface_layer_list_id(0),
+        ideal_contents_scale(0.f),
+        maximum_animation_contents_scale(0.f),
+        page_scale_factor(0.f),
+        device_scale_factor(0.f) {}
 
   // Transforms objects from content space to target surface space, where
   // this layer would be drawn.
@@ -132,6 +136,21 @@ struct CC_EXPORT DrawProperties {
   // or the layer doesn't contribute anything, then this ID will be either out
   // of date or 0.
   int last_drawn_render_surface_layer_list_id;
+
+  // The scale at which content for the layer should be rastered in order to be
+  // perfectly crisp.
+  float ideal_contents_scale;
+
+  // The maximum scale during the layers current animation at which content
+  // should be rastered at to be crisp.
+  float maximum_animation_contents_scale;
+
+  // The page scale factor that is applied to the layer. Since some layers may
+  // have page scale applied and others not, this may differ between layers.
+  float page_scale_factor;
+
+  // The device scale factor that is applied to the layer.
+  float device_scale_factor;
 };
 
 }  // namespace cc
diff --git a/cc/layers/picture_image_layer_impl.cc b/cc/layers/picture_image_layer_impl.cc
index 62bab45..d46ff8d 100644
--- a/cc/layers/picture_image_layer_impl.cc
+++ b/cc/layers/picture_image_layer_impl.cc
@@ -27,28 +27,6 @@ scoped_ptr<LayerImpl> PictureImageLayerImpl::CreateLayerImpl(
   return PictureImageLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
-void PictureImageLayerImpl::CalculateContentsScale(
-    float ideal_contents_scale,
-    float device_scale_factor,
-    float page_scale_factor,
-    float maximum_animation_contents_scale,
-    bool animating_transform_to_screen,
-    float* contents_scale_x,
-    float* contents_scale_y,
-    gfx::Size* content_bounds) {
-  // CalculateRasterContentsScale always returns 1.f, so make that the ideal
-  // scale.
-  ideal_contents_scale = 1.f;
-  PictureLayerImpl::CalculateContentsScale(ideal_contents_scale,
-                                           device_scale_factor,
-                                           page_scale_factor,
-                                           maximum_animation_contents_scale,
-                                           animating_transform_to_screen,
-                                           contents_scale_x,
-                                           contents_scale_y,
-                                           content_bounds);
-}
-
 void PictureImageLayerImpl::GetDebugBorderProperties(
     SkColor* color, float* width) const {
   *color = DebugColors::ImageLayerBorderColor();
@@ -74,4 +52,11 @@ void PictureImageLayerImpl::RecalculateRasterScales(
   low_res_raster_contents_scale_ = raster_contents_scale_;
 }
 
+void PictureImageLayerImpl::UpdateIdealScales() {
+  ideal_contents_scale_ = 1.f;
+  ideal_page_scale_ = 1.f;
+  ideal_device_scale_ = 1.f;
+  ideal_source_scale_ = 1.f;
+}
+
 }  // namespace cc
diff --git a/cc/layers/picture_image_layer_impl.h b/cc/layers/picture_image_layer_impl.h
index 483d5f2..9b76d85 100644
--- a/cc/layers/picture_image_layer_impl.h
+++ b/cc/layers/picture_image_layer_impl.h
@@ -21,14 +21,6 @@ class CC_EXPORT PictureImageLayerImpl : public PictureLayerImpl {
   virtual const char* LayerTypeAsString() const OVERRIDE;
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(
       LayerTreeImpl* tree_impl) OVERRIDE;
-  virtual void CalculateContentsScale(float ideal_contents_scale,
-                                      float device_scale_factor,
-                                      float page_scale_factor,
-                                      float maximum_animation_contents_scale,
-                                      bool animating_transform_to_screen,
-                                      float* contents_scale_x,
-                                      float* contents_scale_y,
-                                      gfx::Size* content_bounds) OVERRIDE;
 
  protected:
   PictureImageLayerImpl(LayerTreeImpl* tree_impl, int id);
@@ -41,6 +33,8 @@ class CC_EXPORT PictureImageLayerImpl : public PictureLayerImpl {
   virtual void GetDebugBorderProperties(
       SkColor* color, float* width) const OVERRIDE;
 
+  virtual void UpdateIdealScales() OVERRIDE;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(PictureImageLayerImpl);
 };
diff --git a/cc/layers/picture_image_layer_impl_unittest.cc b/cc/layers/picture_image_layer_impl_unittest.cc
index e8c993f..34cdf4c 100644
--- a/cc/layers/picture_image_layer_impl_unittest.cc
+++ b/cc/layers/picture_image_layer_impl_unittest.cc
@@ -24,7 +24,20 @@ class TestablePictureImageLayerImpl : public PictureImageLayerImpl {
   TestablePictureImageLayerImpl(LayerTreeImpl* tree_impl, int id)
       : PictureImageLayerImpl(tree_impl, id) {
   }
-
+  using PictureLayerImpl::UpdateIdealScales;
+  using PictureLayerImpl::MaximumTilingContentsScale;
+  using PictureLayerImpl::ManageTilings;
+  using PictureLayerImpl::DoPostCommitInitializationIfNeeded;
+
+  void ScaleAndManageTilings(bool animating_transform_to_screen,
+                             float maximum_animation_contents_scale) {
+    DoPostCommitInitializationIfNeeded();
+    UpdateIdealScales();
+    if (CanHaveTilings()) {
+      ManageTilings(animating_transform_to_screen,
+                    maximum_animation_contents_scale);
+    }
+  }
   PictureLayerTilingSet* tilings() { return tilings_.get(); }
 
   friend class PictureImageLayerImplTest;
@@ -60,12 +73,31 @@ class PictureImageLayerImplTest : public testing::Test {
     TestablePictureImageLayerImpl* layer =
         new TestablePictureImageLayerImpl(tree, id);
     layer->SetBounds(gfx::Size(100, 200));
+    layer->SetContentBounds(gfx::Size(100, 200));
     layer->tilings_.reset(new PictureLayerTilingSet(&tiling_client_,
                                                     layer->bounds()));
     layer->pile_ = tiling_client_.pile();
     return make_scoped_ptr(layer);
   }
 
+  void SetupDrawPropertiesAndManageTilings(
+      TestablePictureImageLayerImpl* layer,
+      float ideal_contents_scale,
+      float device_scale_factor,
+      float page_scale_factor,
+      float maximum_animation_contents_scale,
+      bool animating_transform_to_screen) {
+    layer->draw_properties().ideal_contents_scale = ideal_contents_scale;
+    layer->draw_properties().device_scale_factor = device_scale_factor;
+    layer->draw_properties().page_scale_factor = page_scale_factor;
+    layer->draw_properties().maximum_animation_contents_scale =
+        maximum_animation_contents_scale;
+    layer->draw_properties().screen_space_transform_is_animating =
+        animating_transform_to_screen;
+    layer->ScaleAndManageTilings(animating_transform_to_screen,
+                                 maximum_animation_contents_scale);
+  }
+
  protected:
   FakeImplProxy proxy_;
   FakeLayerTreeHostImpl host_impl_;
@@ -77,20 +109,11 @@ TEST_F(PictureImageLayerImplTest, CalculateContentsScale) {
   scoped_ptr<TestablePictureImageLayerImpl> layer(CreateLayer(1, PENDING_TREE));
   layer->SetDrawsContent(true);
 
-  float contents_scale_x;
-  float contents_scale_y;
-  gfx::Size content_bounds;
-  layer->CalculateContentsScale(2.f,
-                                3.f,
-                                4.f,
-                                1.f,
-                                false,
-                                &contents_scale_x,
-                                &contents_scale_y,
-                                &content_bounds);
-  EXPECT_FLOAT_EQ(1.f, contents_scale_x);
-  EXPECT_FLOAT_EQ(1.f, contents_scale_y);
-  EXPECT_EQ(layer->bounds(), content_bounds);
+  SetupDrawPropertiesAndManageTilings(layer.get(), 2.f, 3.f, 4.f, 1.f, false);
+
+  EXPECT_FLOAT_EQ(1.f, layer->contents_scale_x());
+  EXPECT_FLOAT_EQ(1.f, layer->contents_scale_y());
+  EXPECT_FLOAT_EQ(1.f, layer->MaximumTilingContentsScale());
 }
 
 TEST_F(PictureImageLayerImplTest, IgnoreIdealContentScale) {
@@ -105,31 +128,24 @@ TEST_F(PictureImageLayerImplTest, IgnoreIdealContentScale) {
   const float page_scale_factor = 4.f;
   const float maximum_animation_contents_scale = 1.f;
   const bool animating_transform_to_screen = false;
-  float contents_scale_x;
-  float contents_scale_y;
-  gfx::Size content_bounds;
-  pending_layer->CalculateContentsScale(suggested_ideal_contents_scale,
-                                        device_scale_factor,
-                                        page_scale_factor,
-                                        maximum_animation_contents_scale,
-                                        animating_transform_to_screen,
-                                        &contents_scale_x,
-                                        &contents_scale_y,
-                                        &content_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer.get(),
+                                      suggested_ideal_contents_scale,
+                                      device_scale_factor,
+                                      page_scale_factor,
+                                      maximum_animation_contents_scale,
+                                      animating_transform_to_screen);
 
   // Push to active layer.
   host_impl_.ActivatePendingTree();
   scoped_ptr<TestablePictureImageLayerImpl> active_layer(
       CreateLayer(1, ACTIVE_TREE));
   pending_layer->PushPropertiesTo(active_layer.get());
-  active_layer->CalculateContentsScale(suggested_ideal_contents_scale,
-                                       device_scale_factor,
-                                       page_scale_factor,
-                                       maximum_animation_contents_scale,
-                                       animating_transform_to_screen,
-                                       &contents_scale_x,
-                                       &contents_scale_y,
-                                       &content_bounds);
+  SetupDrawPropertiesAndManageTilings(active_layer.get(),
+                                      suggested_ideal_contents_scale,
+                                      device_scale_factor,
+                                      page_scale_factor,
+                                      maximum_animation_contents_scale,
+                                      animating_transform_to_screen);
 
   // Create tile and resource.
   active_layer->tilings()->tiling_at(0)->CreateAllTilesForTesting();
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 5cd1cb5..eabfdc6 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -138,10 +138,28 @@ void PictureLayerImpl::PushPropertiesTo(LayerImpl* base_layer) {
 void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
                                    AppendQuadsData* append_quads_data) {
   DCHECK(!needs_post_commit_initialization_);
-  gfx::Rect rect(visible_content_rect());
+
+  float max_contents_scale = MaximumTilingContentsScale();
+  gfx::Transform scaled_draw_transform = draw_transform();
+  scaled_draw_transform.Scale(SK_MScalar1 / max_contents_scale,
+                              SK_MScalar1 / max_contents_scale);
+  gfx::Size scaled_content_bounds =
+      gfx::ToCeiledSize(gfx::ScaleSize(content_bounds(), max_contents_scale));
+
+  gfx::Rect scaled_visible_content_rect =
+      gfx::ScaleToEnclosingRect(visible_content_rect(), max_contents_scale);
+  scaled_visible_content_rect.Intersect(gfx::Rect(scaled_content_bounds));
 
   SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
-  PopulateSharedQuadState(shared_quad_state);
+  shared_quad_state->SetAll(scaled_draw_transform,
+                            scaled_content_bounds,
+                            scaled_visible_content_rect,
+                            draw_properties().clip_rect,
+                            draw_properties().is_clipped,
+                            draw_properties().opacity,
+                            blend_mode());
+
+  gfx::Rect rect = scaled_visible_content_rect;
 
   if (current_draw_mode_ == DRAW_MODE_RESOURCELESS_SOFTWARE) {
     AppendDebugBorderQuad(
@@ -161,7 +179,6 @@ void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
     gfx::Size texture_size = rect.size();
     gfx::RectF texture_rect = gfx::RectF(texture_size);
     gfx::Rect quad_content_rect = rect;
-    float contents_scale = contents_scale_x();
 
     scoped_ptr<PictureDrawQuad> quad = PictureDrawQuad::Create();
     quad->SetNew(shared_quad_state,
@@ -172,7 +189,7 @@ void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
                  texture_size,
                  RGBA_8888,
                  quad_content_rect,
-                 contents_scale,
+                 max_contents_scale,
                  pile_);
     quad_sink->Append(quad.PassAs<DrawQuad>());
     append_quads_data->num_missing_tiles++;
@@ -183,7 +200,7 @@ void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
 
   if (ShowDebugBorders()) {
     for (PictureLayerTilingSet::CoverageIterator iter(
-        tilings_.get(), contents_scale_x(), rect, ideal_contents_scale_);
+             tilings_.get(), max_contents_scale, rect, ideal_contents_scale_);
          iter;
          ++iter) {
       SkColor color;
@@ -203,7 +220,7 @@ void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
         } else if (iter->priority(ACTIVE_TREE).resolution == LOW_RESOLUTION) {
           color = DebugColors::LowResTileBorderColor();
           width = DebugColors::LowResTileBorderWidth(layer_tree_impl());
-        } else if (iter->contents_scale() > contents_scale_x()) {
+        } else if (iter->contents_scale() > max_contents_scale) {
           color = DebugColors::ExtraHighResTileBorderColor();
           width = DebugColors::ExtraHighResTileBorderWidth(layer_tree_impl());
         } else {
@@ -235,7 +252,7 @@ void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
   size_t missing_tile_count = 0u;
   size_t on_demand_missing_tile_count = 0u;
   for (PictureLayerTilingSet::CoverageIterator iter(
-      tilings_.get(), contents_scale_x(), rect, ideal_contents_scale_);
+           tilings_.get(), max_contents_scale, rect, ideal_contents_scale_);
        iter;
        ++iter) {
     gfx::Rect geometry_rect = iter.geometry_rect();
@@ -372,8 +389,15 @@ void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
 void PictureLayerImpl::UpdateTilePriorities() {
   TRACE_EVENT0("cc", "PictureLayerImpl::UpdateTilePriorities");
 
-  DCHECK(!needs_post_commit_initialization_);
-  CHECK(should_update_tile_priorities_);
+  DoPostCommitInitializationIfNeeded();
+  UpdateIdealScales();
+  // TODO(sohanjg): Avoid needlessly update priorities when syncing to a
+  // non-updated tree which will then be updated immediately afterwards.
+  should_update_tile_priorities_ = true;
+  if (CanHaveTilings()) {
+    ManageTilings(draw_properties().screen_space_transform_is_animating,
+                  draw_properties().maximum_animation_contents_scale);
+  }
 
   if (layer_tree_impl()->device_viewport_valid_for_tile_management()) {
     visible_rect_for_tile_priority_ = visible_content_rect();
@@ -413,12 +437,15 @@ void PictureLayerImpl::UpdateTilePriorities() {
     }
   }
 
+  gfx::Rect visible_layer_rect = gfx::ScaleToEnclosingRect(
+      visible_rect_in_content_space, 1.f / contents_scale_x());
   WhichTree tree =
       layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
-
+  // TODO(sohanjg): Passing MaximumContentsScale as layer contents scale
+  // in UpdateTilePriorities is wrong and should be ideal contents scale.
   tilings_->UpdateTilePriorities(tree,
-                                 visible_rect_in_content_space,
-                                 contents_scale_x(),
+                                 visible_layer_rect,
+                                 MaximumTilingContentsScale(),
                                  current_frame_time_in_seconds);
 
   if (layer_tree_impl()->IsPendingTree())
@@ -458,74 +485,6 @@ void PictureLayerImpl::ReleaseResources() {
   layer_tree_impl()->set_needs_update_draw_properties();
 }
 
-void PictureLayerImpl::CalculateContentsScale(
-    float ideal_contents_scale,
-    float device_scale_factor,
-    float page_scale_factor,
-    float maximum_animation_contents_scale,
-    bool animating_transform_to_screen,
-    float* contents_scale_x,
-    float* contents_scale_y,
-    gfx::Size* content_bounds) {
-  DoPostCommitInitializationIfNeeded();
-
-  // This function sets valid raster scales and manages tilings, so tile
-  // priorities can now be updated.
-  should_update_tile_priorities_ = true;
-
-  if (!CanHaveTilings()) {
-    ideal_page_scale_ = page_scale_factor;
-    ideal_device_scale_ = device_scale_factor;
-    ideal_contents_scale_ = ideal_contents_scale;
-    ideal_source_scale_ =
-        ideal_contents_scale_ / ideal_page_scale_ / ideal_device_scale_;
-    *contents_scale_x = ideal_contents_scale_;
-    *contents_scale_y = ideal_contents_scale_;
-    *content_bounds = gfx::ToCeiledSize(gfx::ScaleSize(bounds(),
-                                                       ideal_contents_scale_,
-                                                       ideal_contents_scale_));
-    return;
-  }
-
-  float min_contents_scale = MinimumContentsScale();
-  DCHECK_GT(min_contents_scale, 0.f);
-  float min_page_scale = layer_tree_impl()->min_page_scale_factor();
-  DCHECK_GT(min_page_scale, 0.f);
-  float min_device_scale = 1.f;
-  float min_source_scale =
-      min_contents_scale / min_page_scale / min_device_scale;
-
-  float ideal_page_scale = page_scale_factor;
-  float ideal_device_scale = device_scale_factor;
-  float ideal_source_scale =
-      ideal_contents_scale / ideal_page_scale / ideal_device_scale;
-
-  ideal_contents_scale_ = std::max(ideal_contents_scale, min_contents_scale);
-  ideal_page_scale_ = ideal_page_scale;
-  ideal_device_scale_ = ideal_device_scale;
-  ideal_source_scale_ = std::max(ideal_source_scale, min_source_scale);
-
-  ManageTilings(animating_transform_to_screen,
-                maximum_animation_contents_scale);
-
-  // The content scale and bounds for a PictureLayerImpl is somewhat fictitious.
-  // There are (usually) several tilings at different scales.  However, the
-  // content bounds is the (integer!) space in which quads are generated.
-  // In order to guarantee that we can fill this integer space with any set of
-  // tilings (and then map back to floating point texture coordinates), the
-  // contents scale must be at least as large as the largest of the tilings.
-  float max_contents_scale = min_contents_scale;
-  for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
-    const PictureLayerTiling* tiling = tilings_->tiling_at(i);
-    max_contents_scale = std::max(max_contents_scale, tiling->contents_scale());
-  }
-
-  *contents_scale_x = max_contents_scale;
-  *contents_scale_y = max_contents_scale;
-  *content_bounds = gfx::ToCeiledSize(
-      gfx::ScaleSize(bounds(), max_contents_scale, max_contents_scale));
-}
-
 skia::RefPtr<SkPicture> PictureLayerImpl::GetPicture() {
   return pile_->GetFlattenedPicture();
 }
@@ -750,7 +709,7 @@ void PictureLayerImpl::SetIsMask(bool is_mask) {
 
 ResourceProvider::ResourceId PictureLayerImpl::ContentsResourceId() const {
   gfx::Rect content_rect(content_bounds());
-  float scale = contents_scale_x();
+  float scale = MaximumTilingContentsScale();
   PictureLayerTilingSet::CoverageIterator iter(
       tilings_.get(), scale, content_rect, ideal_contents_scale_);
 
@@ -1319,6 +1278,44 @@ void PictureLayerImpl::SanityCheckTilingState() const {
 #endif
 }
 
+float PictureLayerImpl::MaximumTilingContentsScale() const {
+  float max_contents_scale = MinimumContentsScale();
+  for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
+    const PictureLayerTiling* tiling = tilings_->tiling_at(i);
+    max_contents_scale = std::max(max_contents_scale, tiling->contents_scale());
+  }
+  return max_contents_scale;
+}
+
+void PictureLayerImpl::UpdateIdealScales() {
+  if (!CanHaveTilings()) {
+    ideal_page_scale_ = draw_properties().page_scale_factor;
+    ideal_device_scale_ = draw_properties().device_scale_factor;
+    ideal_contents_scale_ = draw_properties().ideal_contents_scale;
+    ideal_source_scale_ =
+        ideal_contents_scale_ / ideal_page_scale_ / ideal_device_scale_;
+    return;
+  }
+
+  float min_contents_scale = MinimumContentsScale();
+  DCHECK_GT(min_contents_scale, 0.f);
+  float min_page_scale = layer_tree_impl()->min_page_scale_factor();
+  DCHECK_GT(min_page_scale, 0.f);
+  float min_device_scale = 1.f;
+  float min_source_scale =
+      min_contents_scale / min_page_scale / min_device_scale;
+
+  float ideal_page_scale = draw_properties().page_scale_factor;
+  float ideal_device_scale = draw_properties().device_scale_factor;
+  float ideal_source_scale = draw_properties().ideal_contents_scale /
+                             ideal_page_scale / ideal_device_scale;
+  ideal_contents_scale_ =
+      std::max(draw_properties().ideal_contents_scale, min_contents_scale);
+  ideal_page_scale_ = draw_properties().page_scale_factor;
+  ideal_device_scale_ = draw_properties().device_scale_factor;
+  ideal_source_scale_ = std::max(ideal_source_scale, min_source_scale);
+}
+
 void PictureLayerImpl::GetDebugBorderProperties(
     SkColor* color,
     float* width) const {
@@ -1330,7 +1327,7 @@ void PictureLayerImpl::AsValueInto(base::DictionaryValue* state) const {
   const_cast<PictureLayerImpl*>(this)->DoPostCommitInitializationIfNeeded();
   LayerImpl::AsValueInto(state);
   state->SetDouble("ideal_contents_scale", ideal_contents_scale_);
-  state->SetDouble("geometry_contents_scale", contents_scale_x());
+  state->SetDouble("geometry_contents_scale", MaximumTilingContentsScale());
   state->Set("tilings", tilings_->AsValue().release());
   state->Set("pictures", pile_->AsValue().release());
   state->Set("invalidation", invalidation_.AsValue().release());
diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index 00c06b1..de4ee2a 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -96,14 +96,6 @@ class CC_EXPORT PictureLayerImpl
   virtual void DidBecomeActive() OVERRIDE;
   virtual void DidBeginTracing() OVERRIDE;
   virtual void ReleaseResources() OVERRIDE;
-  virtual void CalculateContentsScale(float ideal_contents_scale,
-                                      float device_scale_factor,
-                                      float page_scale_factor,
-                                      float maximum_animation_contents_scale,
-                                      bool animating_transform_to_screen,
-                                      float* contents_scale_x,
-                                      float* contents_scale_y,
-                                      gfx::Size* content_bounds) OVERRIDE;
   virtual skia::RefPtr<SkPicture> GetPicture() OVERRIDE;
 
   // PictureLayerTilingClient overrides.
@@ -179,6 +171,9 @@ class CC_EXPORT PictureLayerImpl
       SkColor* color, float* width) const OVERRIDE;
   virtual void AsValueInto(base::DictionaryValue* dict) const OVERRIDE;
 
+  virtual void UpdateIdealScales();
+  float MaximumTilingContentsScale() const;
+
   PictureLayerImpl* twin_layer_;
 
   scoped_ptr<PictureLayerTilingSet> tilings_;
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index cb4486b..40028de 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -26,6 +26,7 @@
 #include "cc/trees/layer_tree_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect_conversions.h"
+#include "ui/gfx/size_conversions.h"
 
 namespace cc {
 namespace {
@@ -139,6 +140,23 @@ class PictureLayerImplTest : public testing::Test {
     pending_layer_->DoPostCommitInitializationIfNeeded();
   }
 
+  void SetupDrawPropertiesAndManageTilings(
+      FakePictureLayerImpl* layer,
+      float ideal_contents_scale,
+      float device_scale_factor,
+      float page_scale_factor,
+      float maximum_animation_contents_scale,
+      bool animating_transform_to_screen) {
+    layer->draw_properties().ideal_contents_scale = ideal_contents_scale;
+    layer->draw_properties().device_scale_factor = device_scale_factor;
+    layer->draw_properties().page_scale_factor = page_scale_factor;
+    layer->draw_properties().maximum_animation_contents_scale =
+        maximum_animation_contents_scale;
+    layer->draw_properties().screen_space_transform_is_animating =
+        animating_transform_to_screen;
+    layer->ScaleAndManageTilings(animating_transform_to_screen,
+                                 maximum_animation_contents_scale);
+  }
   static void VerifyAllTilesExistAndHavePile(
       const PictureLayerTiling* tiling,
       PicturePileImpl* pile) {
@@ -156,24 +174,19 @@ class PictureLayerImplTest : public testing::Test {
                                     float page_scale_factor,
                                     float maximum_animation_contents_scale,
                                     bool animating_transform) {
-    float result_scale_x, result_scale_y;
-    gfx::Size result_bounds;
-    pending_layer_->CalculateContentsScale(contents_scale,
-                                           device_scale_factor,
-                                           page_scale_factor,
-                                           maximum_animation_contents_scale,
-                                           animating_transform,
-                                           &result_scale_x,
-                                           &result_scale_y,
-                                           &result_bounds);
-    active_layer_->CalculateContentsScale(contents_scale,
-                                          device_scale_factor,
-                                          page_scale_factor,
-                                          maximum_animation_contents_scale,
-                                          animating_transform,
-                                          &result_scale_x,
-                                          &result_scale_y,
-                                          &result_bounds);
+    SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                        contents_scale,
+                                        device_scale_factor,
+                                        page_scale_factor,
+                                        maximum_animation_contents_scale,
+                                        animating_transform);
+
+    SetupDrawPropertiesAndManageTilings(active_layer_,
+                                        contents_scale,
+                                        device_scale_factor,
+                                        page_scale_factor,
+                                        maximum_animation_contents_scale,
+                                        animating_transform);
   }
 
   void ResetTilingsAndRasterScales() {
@@ -210,16 +223,8 @@ class PictureLayerImplTest : public testing::Test {
 
     SetupTrees(pending_pile, active_pile);
 
-    float result_scale_x, result_scale_y;
-    gfx::Size result_bounds;
-    active_layer_->CalculateContentsScale(1.f,
-                                          1.f,
-                                          1.f,
-                                          1.f,
-                                          false,
-                                          &result_scale_x,
-                                          &result_scale_y,
-                                          &result_bounds);
+    SetupDrawPropertiesAndManageTilings(
+        active_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
     // Add 1x1 rects at the centers of each tile, then re-record pile contents
     active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
@@ -314,17 +319,7 @@ TEST_F(PictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
 
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
-  float dummy_contents_scale_x;
-  float dummy_contents_scale_y;
-  gfx::Size dummy_content_bounds;
-  active_layer_->CalculateContentsScale(1.f,
-                                        1.f,
-                                        1.f,
-                                        1.f,
-                                        false,
-                                        &dummy_contents_scale_x,
-                                        &dummy_contents_scale_y,
-                                        &dummy_content_bounds);
+  SetupDrawPropertiesAndManageTilings(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
   // UpdateTilePriorities with valid viewport. Should update tile viewport.
   bool valid_for_tile_management = true;
@@ -581,19 +576,10 @@ TEST_F(PictureLayerImplTest, ManageTilingsWithNoRecording) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
 
-  float result_scale_x, result_scale_y;
-  gfx::Size result_bounds;
-
   SetupTrees(pending_pile, active_pile);
 
-  pending_layer_->CalculateContentsScale(1.f,
-                                         1.f,
-                                         1.f,
-                                         1.f,
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(
+      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 }
@@ -607,23 +593,18 @@ TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  float result_scale_x, result_scale_y;
-  gfx::Size result_bounds;
-
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
-  pending_layer_->CalculateContentsScale(6.f,  // ideal contents scale
-                                         3.f,  // device scale
-                                         2.f,  // page scale
-                                         1.f,  // maximum animation scale
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      6.f,  // ideal contents scale
+                                      3.f,  // device scale
+                                      2.f,  // page scale
+                                      1.f,  // maximum animation scale
+                                      false);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(6.f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
@@ -631,14 +612,12 @@ TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
                   pending_layer_->tilings()->tiling_at(1)->contents_scale());
 
   // If we change the page scale factor, then we should get new tilings.
-  pending_layer_->CalculateContentsScale(6.6f,  // ideal contents scale
-                                         3.f,   // device scale
-                                         2.2f,  // page scale
-                                         1.f,   // maximum animation scale
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      6.6f,  // ideal contents scale
+                                      3.f,   // device scale
+                                      2.2f,  // page scale
+                                      1.f,   // maximum animation scale
+                                      false);
   ASSERT_EQ(4u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(6.6f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
@@ -646,14 +625,12 @@ TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
                   pending_layer_->tilings()->tiling_at(2)->contents_scale());
 
   // If we change the device scale factor, then we should get new tilings.
-  pending_layer_->CalculateContentsScale(7.26f,  // ideal contents scale
-                                         3.3f,   // device scale
-                                         2.2f,   // page scale
-                                         1.f,    // maximum animation scale
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      7.26f,  // ideal contents scale
+                                      3.3f,   // device scale
+                                      2.2f,   // page scale
+                                      1.f,    // maximum animation scale
+                                      false);
   ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
@@ -662,14 +639,12 @@ TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
 
   // If we change the device scale factor, but end up at the same total scale
   // factor somehow, then we don't get new tilings.
-  pending_layer_->CalculateContentsScale(7.26f,  // ideal contents scale
-                                         2.2f,   // device scale
-                                         3.3f,   // page scale
-                                         1.f,    // maximum animation scale
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      7.26f,  // ideal contents scale
+                                      2.2f,   // device scale
+                                      3.3f,   // page scale
+                                      1.f,    // maximum animation scale
+                                      false);
   ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
@@ -697,18 +672,14 @@ TEST_F(PictureLayerImplTest, CreateTilingsEvenIfTwinHasNone) {
   float device_scale = 1.7f;
   float page_scale = 3.2f;
   float maximum_animation_scale = 1.f;
-  float result_scale_x, result_scale_y;
-  gfx::Size result_bounds;
 
   SetupPendingTree(valid_pile);
-  pending_layer_->CalculateContentsScale(high_res_scale,
-                                         device_scale,
-                                         page_scale,
-                                         maximum_animation_scale,
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      high_res_scale,
+                                      device_scale,
+                                      page_scale,
+                                      maximum_animation_scale,
+                                      false);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(high_res_scale,
                   pending_layer_->HighResTiling()->contents_scale());
@@ -717,37 +688,31 @@ TEST_F(PictureLayerImplTest, CreateTilingsEvenIfTwinHasNone) {
 
   ActivateTree();
   SetupPendingTree(empty_pile);
-  pending_layer_->CalculateContentsScale(high_res_scale,
-                                         device_scale,
-                                         page_scale,
-                                         maximum_animation_scale,
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      high_res_scale,
+                                      device_scale,
+                                      page_scale,
+                                      maximum_animation_scale,
+                                      false);
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
   ASSERT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   ActivateTree();
-  active_layer_->CalculateContentsScale(high_res_scale,
-                                        device_scale,
-                                        page_scale,
-                                        maximum_animation_scale,
-                                        false,
-                                        &result_scale_x,
-                                        &result_scale_y,
-                                        &result_bounds);
+  SetupDrawPropertiesAndManageTilings(active_layer_,
+                                      high_res_scale,
+                                      device_scale,
+                                      page_scale,
+                                      maximum_animation_scale,
+                                      false);
   ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
 
   SetupPendingTree(valid_pile);
-  pending_layer_->CalculateContentsScale(high_res_scale,
-                                         device_scale,
-                                         page_scale,
-                                         maximum_animation_scale,
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      high_res_scale,
+                                      device_scale,
+                                      page_scale,
+                                      maximum_animation_scale,
+                                      false);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
   ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(high_res_scale,
@@ -881,8 +846,6 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  float result_scale_x, result_scale_y;
-  gfx::Size result_bounds;
   std::vector<PictureLayerTiling*> used_tilings;
 
   SetupTrees(pending_pile, active_pile);
@@ -956,14 +919,8 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
 
   // Now move the ideal scale to 1.1 on the active layer. Our target stays 1.2.
-  active_layer_->CalculateContentsScale(1.1f,
-                                        device_scale,
-                                        page_scale,
-                                        1.f,
-                                        false,
-                                        &result_scale_x,
-                                        &result_scale_y,
-                                        &result_bounds);
+  SetupDrawPropertiesAndManageTilings(
+      active_layer_, 1.1f, device_scale, page_scale, 1.f, false);
 
   // Because the pending layer's ideal scale is still 1.0, our tilings fall
   // in the range [1.0,1.2] and are kept.
@@ -973,14 +930,8 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
 
   // Move the ideal scale on the pending layer to 1.1 as well. Our target stays
   // 1.2 still.
-  pending_layer_->CalculateContentsScale(1.1f,
-                                         device_scale,
-                                         page_scale,
-                                         1.f,
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(
+      pending_layer_, 1.1f, device_scale, page_scale, 1.f, false);
 
   // Our 1.0 tiling now falls outside the range between our ideal scale and our
   // target raster scale. But it is in our used tilings set, so nothing is
@@ -1134,20 +1085,15 @@ TEST_F(PictureLayerImplTest, ReleaseResources) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  float result_scale_x, result_scale_y;
-  gfx::Size result_bounds;
-
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
-  pending_layer_->CalculateContentsScale(1.3f,  // ideal contents scale
-                                         2.7f,  // device scale
-                                         3.2f,  // page scale
-                                         1.f,   // maximum animation scale
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      1.3f,  // ideal contents scale
+                                      2.7f,  // device scale
+                                      3.2f,  // page scale
+                                      1.f,   // maximum animation scale
+                                      false);
   EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
 
   // All tilings should be removed when losing output surface.
@@ -1157,14 +1103,12 @@ TEST_F(PictureLayerImplTest, ReleaseResources) {
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   // This should create new tilings.
-  pending_layer_->CalculateContentsScale(1.3f,  // ideal contents scale
-                                         2.7f,  // device scale
-                                         3.2f,  // page scale
-                                         1.f,   // maximum animation scale
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      1.3f,  // ideal contents scale
+                                      2.7f,  // device scale
+                                      3.2f,  // page scale
+                                      1.f,   // maximum animation scale
+                                      false);
   EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
 }
 
@@ -1178,20 +1122,11 @@ TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  float result_scale_x, result_scale_y;
-  gfx::Size result_bounds;
-
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
-  pending_layer_->CalculateContentsScale(1.f,
-                                         1.f,
-                                         1.f,
-                                         1.f,
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(
+      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
@@ -1214,14 +1149,8 @@ TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) {
   host_impl_.InitializeRenderer(FakeOutputSurface::Create3d(
       context.Pass()).PassAs<OutputSurface>());
 
-  pending_layer_->CalculateContentsScale(1.f,
-                                         1.f,
-                                         1.f,
-                                         1.f,
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(
+      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
@@ -1242,20 +1171,11 @@ TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  float result_scale_x, result_scale_y;
-  gfx::Size result_bounds;
-
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
-  pending_layer_->CalculateContentsScale(1.f,
-                                         1.f,
-                                         1.f,
-                                         1.f,
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(
+      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
   ASSERT_LE(1u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
@@ -1278,14 +1198,8 @@ TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
   host_impl_.InitializeRenderer(FakeOutputSurface::Create3d(
       context.Pass()).PassAs<OutputSurface>());
 
-  pending_layer_->CalculateContentsScale(1.f,
-                                         1.f,
-                                         1.f,
-                                         1.f,
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(
+      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
   ASSERT_LE(1u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
@@ -1314,7 +1228,6 @@ TEST_F(PictureLayerImplTest, DisallowTileDrawQuads) {
 
   SetupTrees(pending_pile, active_pile);
 
-  active_layer_->SetContentBounds(layer_bounds);
   active_layer_->draw_properties().visible_content_rect =
       gfx::Rect(layer_bounds);
 
@@ -1679,17 +1592,8 @@ TEST_F(PictureLayerImplTest, HighResCreatedWhenBoundsShrink) {
   host_impl_.active_tree()->UpdateDrawProperties();
   EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties());
 
-  float result_scale_x;
-  float result_scale_y;
-  gfx::Size result_bounds;
-  active_layer_->CalculateContentsScale(0.5f,
-                                        0.5f,
-                                        0.5f,
-                                        0.5f,
-                                        false,
-                                        &result_scale_x,
-                                        &result_scale_y,
-                                        &result_bounds);
+  SetupDrawPropertiesAndManageTilings(
+      active_layer_, 0.5f, 0.5f, 0.5f, 0.5f, false);
   active_layer_->tilings()->RemoveAllTilings();
   PictureLayerTiling* tiling = active_layer_->tilings()->AddTiling(0.5f);
   active_layer_->tilings()->AddTiling(1.5f);
@@ -1732,20 +1636,12 @@ TEST_F(PictureLayerImplTest, NoLowResTilingWithGpuRasterization) {
   gfx::Size default_tile_size(host_impl_.settings().default_tile_size);
   gfx::Size layer_bounds(default_tile_size.width() * 4,
                          default_tile_size.height() * 4);
-  float result_scale_x, result_scale_y;
-  gfx::Size result_bounds;
 
   SetupDefaultTrees(layer_bounds);
   EXPECT_FALSE(host_impl_.use_gpu_rasterization());
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
-  pending_layer_->CalculateContentsScale(1.f,
-                                         1.f,
-                                         1.f,
-                                         1.f,
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(
+      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
   // Should have a low-res and a high-res tiling.
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
 
@@ -1753,14 +1649,9 @@ TEST_F(PictureLayerImplTest, NoLowResTilingWithGpuRasterization) {
 
   host_impl_.SetUseGpuRasterization(true);
   EXPECT_TRUE(host_impl_.use_gpu_rasterization());
-  pending_layer_->CalculateContentsScale(1.f,
-                                         1.f,
-                                         1.f,
-                                         1.f,
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(
+      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
+
   // Should only have the high-res tiling.
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
 }
@@ -2386,63 +2277,52 @@ TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  float result_scale_x, result_scale_y;
-  gfx::Size result_bounds;
-
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
-  pending_layer_->CalculateContentsScale(6.f,  // ideal contents scale
-                                         3.f,  // device scale
-                                         2.f,  // page scale
-                                         1.f,  // maximum animation scale
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      6.f,  // ideal contents scale
+                                      3.f,  // device scale
+                                      2.f,  // page scale
+                                      1.f,  // maximum animation scale
+                                      false);
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(6.f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
 
   // If we change the page scale factor, then we should get new tilings.
-  pending_layer_->CalculateContentsScale(6.6f,  // ideal contents scale
-                                         3.f,   // device scale
-                                         2.2f,  // page scale
-                                         1.f,   // maximum animation scale
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      6.6f,  // ideal contents scale
+                                      3.f,   // device scale
+                                      2.2f,  // page scale
+                                      1.f,   // maximum animation scale
+                                      false);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(6.6f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
 
   // If we change the device scale factor, then we should get new tilings.
-  pending_layer_->CalculateContentsScale(7.26f,  // ideal contents scale
-                                         3.3f,   // device scale
-                                         2.2f,   // page scale
-                                         1.f,    // maximum animation scale
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      7.26f,  // ideal contents scale
+                                      3.3f,   // device scale
+                                      2.2f,   // page scale
+                                      1.f,    // maximum animation scale
+                                      false);
   ASSERT_EQ(3u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
 
   // If we change the device scale factor, but end up at the same total scale
   // factor somehow, then we don't get new tilings.
-  pending_layer_->CalculateContentsScale(7.26f,  // ideal contents scale
-                                         2.2f,   // device scale
-                                         3.3f,   // page scale
-                                         1.f,    // maximum animation scale
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      7.26f,  // ideal contents scale
+                                      2.2f,   // device scale
+                                      3.3f,   // page scale
+                                      1.f,    // maximum animation scale
+                                      false);
   ASSERT_EQ(3u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
@@ -2537,17 +2417,7 @@ TEST_F(NoLowResPictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
 
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
-  float dummy_contents_scale_x;
-  float dummy_contents_scale_y;
-  gfx::Size dummy_content_bounds;
-  active_layer_->CalculateContentsScale(1.f,
-                                        1.f,
-                                        1.f,
-                                        1.f,
-                                        false,
-                                        &dummy_contents_scale_x,
-                                        &dummy_contents_scale_y,
-                                        &dummy_content_bounds);
+  SetupDrawPropertiesAndManageTilings(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
   // UpdateTilePriorities with valid viewport. Should update tile viewport.
   bool valid_for_tile_management = true;
@@ -2646,8 +2516,6 @@ TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  float result_scale_x, result_scale_y;
-  gfx::Size result_bounds;
   std::vector<PictureLayerTiling*> used_tilings;
 
   SetupTrees(pending_pile, active_pile);
@@ -2716,14 +2584,8 @@ TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
 
   // Now move the ideal scale to 1.1 on the active layer. Our target stays 1.2.
-  active_layer_->CalculateContentsScale(1.1f,
-                                        device_scale,
-                                        page_scale,
-                                        1.f,
-                                        false,
-                                        &result_scale_x,
-                                        &result_scale_y,
-                                        &result_bounds);
+  SetupDrawPropertiesAndManageTilings(
+      active_layer_, 1.1f, device_scale, page_scale, 1.f, false);
 
   // Because the pending layer's ideal scale is still 1.0, our tilings fall
   // in the range [1.0,1.2] and are kept.
@@ -2733,14 +2595,8 @@ TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
 
   // Move the ideal scale on the pending layer to 1.1 as well. Our target stays
   // 1.2 still.
-  pending_layer_->CalculateContentsScale(1.1f,
-                                         device_scale,
-                                         page_scale,
-                                         1.f,
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(
+      pending_layer_, 1.1f, device_scale, page_scale, 1.f, false);
 
   // Our 1.0 tiling now falls outside the range between our ideal scale and our
   // target raster scale. But it is in our used tilings set, so nothing is
@@ -2766,8 +2622,6 @@ TEST_F(PictureLayerImplTest, ScaleCollision) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  float result_scale_x, result_scale_y;
-  gfx::Size result_bounds;
   std::vector<PictureLayerTiling*> used_tilings;
 
   SetupTrees(pending_pile, active_pile);
@@ -2783,22 +2637,18 @@ TEST_F(PictureLayerImplTest, ScaleCollision) {
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
-  pending_layer_->CalculateContentsScale(pending_contents_scale,
-                                         device_scale_factor,
-                                         page_scale_factor,
-                                         maximum_animation_contents_scale,
-                                         animating_transform,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
-  active_layer_->CalculateContentsScale(active_contents_scale,
-                                        device_scale_factor,
-                                        page_scale_factor,
-                                        maximum_animation_contents_scale,
-                                        animating_transform,
-                                        &result_scale_x,
-                                        &result_scale_y,
-                                        &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      pending_contents_scale,
+                                      device_scale_factor,
+                                      page_scale_factor,
+                                      maximum_animation_contents_scale,
+                                      animating_transform);
+  SetupDrawPropertiesAndManageTilings(active_layer_,
+                                      active_contents_scale,
+                                      device_scale_factor,
+                                      page_scale_factor,
+                                      maximum_animation_contents_scale,
+                                      animating_transform);
 
   ASSERT_EQ(4u, pending_layer_->tilings()->num_tilings());
   ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
@@ -2846,20 +2696,15 @@ TEST_F(NoLowResPictureLayerImplTest, ReleaseResources) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  float result_scale_x, result_scale_y;
-  gfx::Size result_bounds;
-
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
-  pending_layer_->CalculateContentsScale(1.3f,  // ideal contents scale
-                                         2.7f,  // device scale
-                                         3.2f,  // page scale
-                                         1.f,   // maximum animation scale
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      1.3f,  // ideal contents scale
+                                      2.7f,  // device scale
+                                      3.2f,  // page scale
+                                      1.f,   // maximum animation scale
+                                      false);
   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
 
   // All tilings should be removed when losing output surface.
@@ -2869,16 +2714,61 @@ TEST_F(NoLowResPictureLayerImplTest, ReleaseResources) {
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   // This should create new tilings.
-  pending_layer_->CalculateContentsScale(1.3f,  // ideal contents scale
-                                         2.7f,  // device scale
-                                         3.2f,  // page scale
-                                         1.f,   // maximum animation scale
-                                         false,
-                                         &result_scale_x,
-                                         &result_scale_y,
-                                         &result_bounds);
+  SetupDrawPropertiesAndManageTilings(pending_layer_,
+                                      1.3f,  // ideal contents scale
+                                      2.7f,  // device scale
+                                      3.2f,  // page scale
+                                      1.f,   // maximum animation scale
+                                      false);
   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
 }
 
+TEST_F(PictureLayerImplTest, SharedQuadStateContainsMaxTilingScale) {
+  MockQuadCuller quad_culler;
+
+  gfx::Size tile_size(400, 400);
+  gfx::Size layer_bounds(1000, 2000);
+
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+
+  SetupTrees(pending_pile, active_pile);
+
+  SetupDrawPropertiesAndManageTilings(
+      pending_layer_, 2.5f, 1.f, 1.f, 1.f, false);
+  host_impl_.pending_tree()->UpdateDrawProperties();
+
+  active_layer_->draw_properties().visible_content_rect =
+      gfx::Rect(layer_bounds);
+  host_impl_.active_tree()->UpdateDrawProperties();
+
+  float max_contents_scale = active_layer_->MaximumTilingContentsScale();
+  gfx::Transform scaled_draw_transform = active_layer_->draw_transform();
+  scaled_draw_transform.Scale(SK_MScalar1 / max_contents_scale,
+                              SK_MScalar1 / max_contents_scale);
+
+  AppendQuadsData data;
+  active_layer_->AppendQuads(&quad_culler, &data);
+
+  // SharedQuadState should have be of size 1, as we are doing AppenQuad once.
+  EXPECT_EQ(1u, quad_culler.shared_quad_state_list().size());
+  // The content_to_target_transform should be scaled by the
+  // MaximumTilingContentsScale on the layer.
+  EXPECT_EQ(scaled_draw_transform.ToString(),
+            quad_culler.shared_quad_state_list()[0]
+                ->content_to_target_transform.ToString());
+  // The content_bounds should be scaled by the
+  // MaximumTilingContentsScale on the layer.
+  EXPECT_EQ(gfx::Size(2500u, 5000u).ToString(),
+            quad_culler.shared_quad_state_list()[0]->content_bounds.ToString());
+  // The visible_content_rect should be scaled by the
+  // MaximumTilingContentsScale on the layer.
+  EXPECT_EQ(
+      gfx::Rect(0u, 0u, 2500u, 5000u).ToString(),
+      quad_culler.shared_quad_state_list()[0]->visible_content_rect.ToString());
+}
+
 }  // namespace
 }  // namespace cc
diff --git a/cc/resources/picture_layer_tiling_set.cc b/cc/resources/picture_layer_tiling_set.cc
index fa76fc1..4192c92 100644
--- a/cc/resources/picture_layer_tiling_set.cc
+++ b/cc/resources/picture_layer_tiling_set.cc
@@ -309,12 +309,9 @@ PictureLayerTilingSet::CoverageIterator::operator bool() const {
 
 void PictureLayerTilingSet::UpdateTilePriorities(
     WhichTree tree,
-    const gfx::Rect& visible_content_rect,
+    const gfx::Rect& visible_layer_rect,
     float layer_contents_scale,
     double current_frame_time_in_seconds) {
-  gfx::Rect visible_layer_rect = gfx::ScaleToEnclosingRect(
-      visible_content_rect, 1.f / layer_contents_scale);
-
   for (size_t i = 0; i < tilings_.size(); ++i) {
     tilings_[i]->UpdateTilePriorities(tree,
                                       visible_layer_rect,
diff --git a/cc/resources/picture_layer_tiling_set.h b/cc/resources/picture_layer_tiling_set.h
index 53de7ce..5c8df60 100644
--- a/cc/resources/picture_layer_tiling_set.h
+++ b/cc/resources/picture_layer_tiling_set.h
@@ -55,7 +55,7 @@ class CC_EXPORT PictureLayerTilingSet {
   void RemoveAllTiles();
 
   void UpdateTilePriorities(WhichTree tree,
-                            const gfx::Rect& visible_content_rect,
+                            const gfx::Rect& visible_layer_rect,
                             float layer_contents_scale,
                             double current_frame_time_in_seconds);
 
diff --git a/cc/test/fake_picture_layer_impl.cc b/cc/test/fake_picture_layer_impl.cc
index 3f5b82a..8514bc3 100644
--- a/cc/test/fake_picture_layer_impl.cc
+++ b/cc/test/fake_picture_layer_impl.cc
@@ -19,6 +19,7 @@ FakePictureLayerImpl::FakePictureLayerImpl(
   pile_ = pile;
   CHECK(pile->tiling_rect().origin() == gfx::Point());
   SetBounds(pile_->tiling_rect().size());
+  SetContentBounds(pile_->tiling_rect().size());
 }
 
 FakePictureLayerImpl::FakePictureLayerImpl(LayerTreeImpl* tree_impl,
@@ -28,6 +29,7 @@ FakePictureLayerImpl::FakePictureLayerImpl(LayerTreeImpl* tree_impl,
     : PictureLayerImpl(tree_impl, id), append_quads_count_(0) {
   pile_ = pile;
   SetBounds(layer_bounds);
+  SetContentBounds(layer_bounds);
 }
 
 FakePictureLayerImpl::FakePictureLayerImpl(LayerTreeImpl* tree_impl, int id)
diff --git a/cc/test/fake_picture_layer_impl.h b/cc/test/fake_picture_layer_impl.h
index ae8f202..38caff8 100644
--- a/cc/test/fake_picture_layer_impl.h
+++ b/cc/test/fake_picture_layer_impl.h
@@ -48,6 +48,10 @@ class FakePictureLayerImpl : public PictureLayerImpl {
   using PictureLayerImpl::MinimumContentsScale;
   using PictureLayerImpl::SanityCheckTilingState;
 
+  using PictureLayerImpl::UpdateIdealScales;
+  using PictureLayerImpl::MaximumTilingContentsScale;
+  using PictureLayerImpl::ManageTilings;
+
   void SetNeedsPostCommitInitialization() {
     needs_post_commit_initialization_ = true;
   }
@@ -90,6 +94,15 @@ class FakePictureLayerImpl : public PictureLayerImpl {
   void SetAllTilesReadyInTiling(PictureLayerTiling* tiling);
   void ResetAllTilesPriorities();
 
+  void ScaleAndManageTilings(bool animating_transform_to_screen,
+                             float maximum_animation_contents_scale) {
+    UpdateIdealScales();
+    if (CanHaveTilings()) {
+      ManageTilings(animating_transform_to_screen,
+                    maximum_animation_contents_scale);
+    }
+  }
+
  protected:
   FakePictureLayerImpl(
       LayerTreeImpl* tree_impl,
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index 9cd7eef..ccaf894 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -81,7 +81,7 @@ inline gfx::Rect CalculateVisibleRectWithCachedLayerRect(
   minimal_surface_rect.Intersect(layer_rect_in_target_space);
 
   if (minimal_surface_rect.IsEmpty())
-      return gfx::Rect();
+    return gfx::Rect();
 
   // Project the corners of the target surface rect into the layer space.
   // This bounding rectangle may be larger than it needs to be (being
@@ -919,6 +919,20 @@ gfx::Transform ComputeScrollCompensationMatrixForChildren(
 }
 
 template <typename LayerType>
+static inline void UpdateLayerScaleDrawProperties(
+    LayerType* layer,
+    float ideal_contents_scale,
+    float maximum_animation_contents_scale,
+    float page_scale_factor,
+    float device_scale_factor) {
+  layer->draw_properties().ideal_contents_scale = ideal_contents_scale;
+  layer->draw_properties().maximum_animation_contents_scale =
+      maximum_animation_contents_scale;
+  layer->draw_properties().page_scale_factor = page_scale_factor;
+  layer->draw_properties().device_scale_factor = device_scale_factor;
+}
+
+template <typename LayerType>
 static inline void CalculateContentsScale(
     LayerType* layer,
     float contents_scale,
@@ -1760,6 +1774,40 @@ static void CalculateDrawPropertiesInternal(
       combined_maximum_animation_contents_scale,
       animating_transform_to_screen);
 
+  UpdateLayerScaleDrawProperties(
+      layer,
+      ideal_contents_scale,
+      combined_maximum_animation_contents_scale,
+      data_from_ancestor.in_subtree_of_page_scale_application_layer
+          ? globals.page_scale_factor
+          : 1.f,
+      globals.device_scale_factor);
+
+  LayerType* mask_layer = layer->mask_layer();
+  if (mask_layer) {
+    UpdateLayerScaleDrawProperties(
+        mask_layer,
+        ideal_contents_scale,
+        combined_maximum_animation_contents_scale,
+        data_from_ancestor.in_subtree_of_page_scale_application_layer
+            ? globals.page_scale_factor
+            : 1.f,
+        globals.device_scale_factor);
+  }
+
+  LayerType* replica_mask_layer =
+      layer->replica_layer() ? layer->replica_layer()->mask_layer() : NULL;
+  if (replica_mask_layer) {
+    UpdateLayerScaleDrawProperties(
+        replica_mask_layer,
+        ideal_contents_scale,
+        combined_maximum_animation_contents_scale,
+        data_from_ancestor.in_subtree_of_page_scale_application_layer
+            ? globals.page_scale_factor
+            : 1.f,
+        globals.device_scale_factor);
+  }
+
   // The draw_transform that gets computed below is effectively the layer's
   // draw_transform, unless the layer itself creates a render_surface. In that
   // case, the render_surface re-parents the transforms.
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index 77976c8..cfc7e5f 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -8358,5 +8358,238 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceLayerListMembership) {
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 }
+
+TEST_F(LayerTreeHostCommonTest, DrawPropertyScales) {
+  FakeImplProxy proxy;
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
+
+  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
+  LayerImpl* root_layer = root.get();
+  scoped_ptr<LayerImpl> child1 = LayerImpl::Create(host_impl.active_tree(), 2);
+  LayerImpl* child1_layer = child1.get();
+  scoped_ptr<LayerImpl> child2 = LayerImpl::Create(host_impl.active_tree(), 3);
+  LayerImpl* child2_layer = child2.get();
+
+  root->AddChild(child1.Pass());
+  root->AddChild(child2.Pass());
+
+  gfx::Transform identity_matrix, scale_transform_child1,
+      scale_transform_child2;
+  scale_transform_child1.Scale(2, 3);
+  scale_transform_child2.Scale(4, 5);
+
+  SetLayerPropertiesForTesting(root_layer,
+                               identity_matrix,
+                               gfx::Point3F(),
+                               gfx::PointF(),
+                               gfx::Size(1, 1),
+                               true,
+                               false);
+  SetLayerPropertiesForTesting(child1_layer,
+                               scale_transform_child1,
+                               gfx::Point3F(),
+                               gfx::PointF(),
+                               gfx::Size(),
+                               true,
+                               false);
+
+  child1_layer->SetMaskLayer(
+      LayerImpl::Create(host_impl.active_tree(), 4).Pass());
+
+  scoped_ptr<LayerImpl> replica_layer =
+      LayerImpl::Create(host_impl.active_tree(), 5);
+  replica_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 6));
+  child1_layer->SetReplicaLayer(replica_layer.Pass());
+
+  ExecuteCalculateDrawProperties(root_layer);
+
+  TransformOperations scale;
+  scale.AppendScale(5.f, 8.f, 3.f);
+
+  AddAnimatedTransformToLayer(child2_layer, 1.0, TransformOperations(), scale);
+  SetLayerPropertiesForTesting(child2_layer,
+                               scale_transform_child2,
+                               gfx::Point3F(),
+                               gfx::PointF(),
+                               gfx::Size(),
+                               true,
+                               false);
+
+  ExecuteCalculateDrawProperties(root_layer);
+
+  EXPECT_FLOAT_EQ(1.f, root_layer->draw_properties().ideal_contents_scale);
+  EXPECT_FLOAT_EQ(3.f, child1_layer->draw_properties().ideal_contents_scale);
+  EXPECT_FLOAT_EQ(
+      3.f, child1_layer->mask_layer()->draw_properties().ideal_contents_scale);
+  EXPECT_FLOAT_EQ(3.f,
+                  child1_layer->replica_layer()
+                      ->mask_layer()
+                      ->draw_properties()
+                      .ideal_contents_scale);
+  EXPECT_FLOAT_EQ(5.f, child2_layer->draw_properties().ideal_contents_scale);
+
+  EXPECT_FLOAT_EQ(
+      0.f, root_layer->draw_properties().maximum_animation_contents_scale);
+  EXPECT_FLOAT_EQ(
+      0.f, child1_layer->draw_properties().maximum_animation_contents_scale);
+  EXPECT_FLOAT_EQ(0.f,
+                  child1_layer->mask_layer()
+                      ->draw_properties()
+                      .maximum_animation_contents_scale);
+  EXPECT_FLOAT_EQ(0.f,
+                  child1_layer->replica_layer()
+                      ->mask_layer()
+                      ->draw_properties()
+                      .maximum_animation_contents_scale);
+  EXPECT_FLOAT_EQ(
+      8.f, child2_layer->draw_properties().maximum_animation_contents_scale);
+
+  EXPECT_FLOAT_EQ(1.f, root_layer->draw_properties().page_scale_factor);
+  EXPECT_FLOAT_EQ(1.f, child1_layer->draw_properties().page_scale_factor);
+  EXPECT_FLOAT_EQ(
+      1.f, child1_layer->mask_layer()->draw_properties().page_scale_factor);
+  EXPECT_FLOAT_EQ(1.f,
+                  child1_layer->replica_layer()
+                      ->mask_layer()
+                      ->draw_properties()
+                      .page_scale_factor);
+  EXPECT_FLOAT_EQ(1.f, child2_layer->draw_properties().page_scale_factor);
+
+  EXPECT_FLOAT_EQ(1.f, root_layer->draw_properties().device_scale_factor);
+  EXPECT_FLOAT_EQ(1.f, child1_layer->draw_properties().device_scale_factor);
+  EXPECT_FLOAT_EQ(
+      1.f, child1_layer->mask_layer()->draw_properties().device_scale_factor);
+  EXPECT_FLOAT_EQ(1.f,
+                  child1_layer->replica_layer()
+                      ->mask_layer()
+                      ->draw_properties()
+                      .device_scale_factor);
+  EXPECT_FLOAT_EQ(1.f, child2_layer->draw_properties().device_scale_factor);
+
+  // Changing page-scale would affect ideal_contents_scale and
+  // maximum_animation_contents_scale.
+
+  float page_scale_factor = 3.f;
+  float device_scale_factor = 1.0f;
+  std::vector<LayerImpl*> render_surface_layer_list;
+  gfx::Size device_viewport_size =
+      gfx::Size(root_layer->bounds().width() * device_scale_factor,
+                root_layer->bounds().height() * device_scale_factor);
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root_layer, device_viewport_size, &render_surface_layer_list);
+
+  inputs.page_scale_factor = page_scale_factor;
+  inputs.can_adjust_raster_scales = true;
+  inputs.page_scale_application_layer = root_layer;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+
+  EXPECT_FLOAT_EQ(1.f, root_layer->draw_properties().ideal_contents_scale);
+  EXPECT_FLOAT_EQ(9.f, child1_layer->draw_properties().ideal_contents_scale);
+  EXPECT_FLOAT_EQ(
+      9.f, child1_layer->mask_layer()->draw_properties().ideal_contents_scale);
+  EXPECT_FLOAT_EQ(9.f,
+                  child1_layer->replica_layer()
+                      ->mask_layer()
+                      ->draw_properties()
+                      .ideal_contents_scale);
+  EXPECT_FLOAT_EQ(15.f, child2_layer->draw_properties().ideal_contents_scale);
+
+  EXPECT_FLOAT_EQ(
+      0.f, root_layer->draw_properties().maximum_animation_contents_scale);
+  EXPECT_FLOAT_EQ(
+      0.f, child1_layer->draw_properties().maximum_animation_contents_scale);
+  EXPECT_FLOAT_EQ(0.f,
+                  child1_layer->mask_layer()
+                      ->draw_properties()
+                      .maximum_animation_contents_scale);
+  EXPECT_FLOAT_EQ(0.f,
+                  child1_layer->replica_layer()
+                      ->mask_layer()
+                      ->draw_properties()
+                      .maximum_animation_contents_scale);
+  EXPECT_FLOAT_EQ(
+      24.f, child2_layer->draw_properties().maximum_animation_contents_scale);
+
+  EXPECT_FLOAT_EQ(1.f, root_layer->draw_properties().page_scale_factor);
+  EXPECT_FLOAT_EQ(3.f, child1_layer->draw_properties().page_scale_factor);
+  EXPECT_FLOAT_EQ(
+      3.f, child1_layer->mask_layer()->draw_properties().page_scale_factor);
+  EXPECT_FLOAT_EQ(3.f,
+                  child1_layer->replica_layer()
+                      ->mask_layer()
+                      ->draw_properties()
+                      .page_scale_factor);
+  EXPECT_FLOAT_EQ(3.f, child2_layer->draw_properties().page_scale_factor);
+
+  EXPECT_FLOAT_EQ(1.f, root_layer->draw_properties().device_scale_factor);
+  EXPECT_FLOAT_EQ(1.f, child1_layer->draw_properties().device_scale_factor);
+  EXPECT_FLOAT_EQ(
+      1.f, child1_layer->mask_layer()->draw_properties().device_scale_factor);
+  EXPECT_FLOAT_EQ(1.f,
+                  child1_layer->replica_layer()
+                      ->mask_layer()
+                      ->draw_properties()
+                      .device_scale_factor);
+  EXPECT_FLOAT_EQ(1.f, child2_layer->draw_properties().device_scale_factor);
+
+  // Changing device-scale would affect ideal_contents_scale and
+  // maximum_animation_contents_scale.
+
+  device_scale_factor = 4.0f;
+  inputs.device_scale_factor = device_scale_factor;
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+
+  EXPECT_FLOAT_EQ(4.f, root_layer->draw_properties().ideal_contents_scale);
+  EXPECT_FLOAT_EQ(36.f, child1_layer->draw_properties().ideal_contents_scale);
+  EXPECT_FLOAT_EQ(
+      36.f, child1_layer->mask_layer()->draw_properties().ideal_contents_scale);
+  EXPECT_FLOAT_EQ(36.f,
+                  child1_layer->replica_layer()
+                      ->mask_layer()
+                      ->draw_properties()
+                      .ideal_contents_scale);
+  EXPECT_FLOAT_EQ(60.f, child2_layer->draw_properties().ideal_contents_scale);
+
+  EXPECT_FLOAT_EQ(
+      0.f, root_layer->draw_properties().maximum_animation_contents_scale);
+  EXPECT_FLOAT_EQ(
+      0.f, child1_layer->draw_properties().maximum_animation_contents_scale);
+  EXPECT_FLOAT_EQ(0.f,
+                  child1_layer->mask_layer()
+                      ->draw_properties()
+                      .maximum_animation_contents_scale);
+  EXPECT_FLOAT_EQ(0.f,
+                  child1_layer->replica_layer()
+                      ->mask_layer()
+                      ->draw_properties()
+                      .maximum_animation_contents_scale);
+  EXPECT_FLOAT_EQ(
+      96.f, child2_layer->draw_properties().maximum_animation_contents_scale);
+
+  EXPECT_FLOAT_EQ(1.f, root_layer->draw_properties().page_scale_factor);
+  EXPECT_FLOAT_EQ(3.f, child1_layer->draw_properties().page_scale_factor);
+  EXPECT_FLOAT_EQ(
+      3.f, child1_layer->mask_layer()->draw_properties().page_scale_factor);
+  EXPECT_FLOAT_EQ(3.f,
+                  child1_layer->replica_layer()
+                      ->mask_layer()
+                      ->draw_properties()
+                      .page_scale_factor);
+  EXPECT_FLOAT_EQ(3.f, child2_layer->draw_properties().page_scale_factor);
+
+  EXPECT_FLOAT_EQ(4.f, root_layer->draw_properties().device_scale_factor);
+  EXPECT_FLOAT_EQ(4.f, child1_layer->draw_properties().device_scale_factor);
+  EXPECT_FLOAT_EQ(
+      4.f, child1_layer->mask_layer()->draw_properties().device_scale_factor);
+  EXPECT_FLOAT_EQ(4.f,
+                  child1_layer->replica_layer()
+                      ->mask_layer()
+                      ->draw_properties()
+                      .device_scale_factor);
+  EXPECT_FLOAT_EQ(4.f, child2_layer->draw_properties().device_scale_factor);
+}
+
 }  // namespace
 }  // namespace cc
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 91f98ae..5057b2e 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -6530,12 +6530,14 @@ TEST_F(LayerTreeHostImplTest, UpdateTilesForMasksWithNoVisibleContent) {
       FakePictureLayerImpl::Create(host_impl_->pending_tree(), 2);
 
   layer_with_mask->SetBounds(bounds);
+  layer_with_mask->SetContentBounds(bounds);
 
   scoped_ptr<FakePictureLayerImpl> mask =
       FakePictureLayerImpl::Create(host_impl_->pending_tree(), 3);
 
   mask->SetIsMask(true);
   mask->SetBounds(bounds);
+  mask->SetContentBounds(bounds);
 
   FakePictureLayerImpl* pending_mask_content = mask.get();
   layer_with_mask->SetMaskLayer(mask.PassAs<LayerImpl>());
@@ -6544,6 +6546,7 @@ TEST_F(LayerTreeHostImplTest, UpdateTilesForMasksWithNoVisibleContent) {
       FakePictureLayerImpl::Create(host_impl_->pending_tree(), 4);
 
   child_of_layer_with_mask->SetBounds(bounds);
+  child_of_layer_with_mask->SetContentBounds(bounds);
   child_of_layer_with_mask->SetDrawsContent(true);
 
   layer_with_mask->AddChild(child_of_layer_with_mask.PassAs<LayerImpl>());