cc: Move tiling management out of draw properties calculation.

cc/layers/picture_layer_impl_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
 
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_picture_pile_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/impl_side_painting_settings.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/mock_quad_culler.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #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 {
 
 class MockCanvas : public SkCanvas {
  public:
   explicit MockCanvas(int w, int h) : SkCanvas(w, h) {}
 
   virtual void drawRect(const SkRect& rect, const SkPaint& paint) OVERRIDE {
     // Capture calls before SkCanvas quickReject() kicks in.
@@ skipping 94 matching lines @@
         FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile);
     pending_layer->SetDrawsContent(true);
     pending_layer->SetAnchorPoint(gfx::PointF());
     pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
     pending_layer_->DoPostCommitInitializationIfNeeded();
   }
 
+  void SetupDrawPropertiesAndUpdateTilePriorities(
+      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->UpdateTilePriorities();
+  }
   static void VerifyAllTilesExistAndHavePile(
       const PictureLayerTiling* tiling,
       PicturePileImpl* pile) {
     for (PictureLayerTiling::CoverageIterator iter(
              tiling, tiling->contents_scale(), tiling->TilingRect());
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_EQ(pile, iter->picture_pile());
     }
   }
 
   void SetContentsScaleOnBothLayers(float contents_scale,
                                     float device_scale_factor,
                                     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);
+    SetupDrawPropertiesAndUpdateTilePriorities(pending_layer_,
+                                               contents_scale,
+                                               device_scale_factor,
+                                               page_scale_factor,
+                                               maximum_animation_contents_scale,
+                                               animating_transform);
+
+    SetupDrawPropertiesAndUpdateTilePriorities(active_layer_,
+                                               contents_scale,
+                                               device_scale_factor,
+                                               page_scale_factor,
+                                               maximum_animation_contents_scale,
+                                               animating_transform);
   }
 
   void ResetTilingsAndRasterScales() {
     pending_layer_->ReleaseResources();
     active_layer_->ReleaseResources();
   }
 
   void AssertAllTilesRequired(PictureLayerTiling* tiling) {
     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
     for (size_t i = 0; i < tiles.size(); ++i)
@@ skipping 16 matching lines @@
         settings.default_tile_size.width() * 7 / 2,
         settings.default_tile_size.height() * 7 / 2);
 
     scoped_refptr<FakePicturePileImpl> pending_pile =
         FakePicturePileImpl::CreateFilledPile(layer_size, layer_size);
     scoped_refptr<FakePicturePileImpl> active_pile =
         FakePicturePileImpl::CreateFilledPile(layer_size, layer_size);
 
     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);
+    SetupDrawPropertiesAndUpdateTilePriorities(
+        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();
     std::vector<Tile*> tiles =
         active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
     EXPECT_EQ(16u, tiles.size());
     std::vector<SkRect> rects;
     std::vector<Tile*>::const_iterator tile_iter;
     for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
       gfx::Point tile_center = (*tile_iter)->content_rect().CenterPoint();
@@ skipping 74 matching lines @@
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
 
   std::vector<TileManager::PairedPictureLayer> paired_layers;
   host_impl_.tile_manager()->GetPairedPictureLayers(&paired_layers);
   EXPECT_EQ(0u, paired_layers.size());
 
   // Update tile priorities will force the layer to register itself.
-  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);
-  active_layer_->UpdateTilePriorities();
-  host_impl_.pending_tree()->UpdateDrawProperties();
-  pending_layer_->CalculateContentsScale(1.f,
-                                         1.f,
-                                         1.f,
-                                         1.f,
-                                         false,
-                                         &dummy_contents_scale_x,
-                                         &dummy_contents_scale_y,
-                                         &dummy_content_bounds);
-  pending_layer_->UpdateTilePriorities();
+  SetupDrawPropertiesAndUpdateTilePriorities(
+      active_layer_, 1.f, 1.f, 1.f, 1.f, false);
+  SetupDrawPropertiesAndUpdateTilePriorities(
+      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
   host_impl_.tile_manager()->GetPairedPictureLayers(&paired_layers);
   EXPECT_EQ(1u, paired_layers.size());
   EXPECT_EQ(active_layer_, paired_layers[0].active_layer);
   EXPECT_EQ(pending_layer_, paired_layers[0].pending_layer);
 
   // Destroy and recreate tile manager.
   host_impl_.DidLoseOutputSurface();
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   host_impl_.InitializeRenderer(
       FakeOutputSurface::Create3d(context.Pass()).PassAs<OutputSurface>());
 
   host_impl_.tile_manager()->GetPairedPictureLayers(&paired_layers);
   EXPECT_EQ(0u, paired_layers.size());
 
-  active_layer_->CalculateContentsScale(1.f,
-                                        1.f,
-                                        1.f,
-                                        1.f,
-                                        false,
-                                        &dummy_contents_scale_x,
-                                        &dummy_contents_scale_y,
-                                        &dummy_content_bounds);
-  active_layer_->UpdateTilePriorities();
-  host_impl_.pending_tree()->UpdateDrawProperties();
-  pending_layer_->CalculateContentsScale(1.f,
-                                         1.f,
-                                         1.f,
-                                         1.f,
-                                         false,
-                                         &dummy_contents_scale_x,
-                                         &dummy_contents_scale_y,
-                                         &dummy_content_bounds);
-  pending_layer_->UpdateTilePriorities();
+  SetupDrawPropertiesAndUpdateTilePriorities(
+      active_layer_, 1.f, 1.f, 1.f, 1.f, false);
+
+  SetupDrawPropertiesAndUpdateTilePriorities(
+      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
   host_impl_.tile_manager()->GetPairedPictureLayers(&paired_layers);
   EXPECT_EQ(1u, paired_layers.size());
   EXPECT_EQ(active_layer_, paired_layers[0].active_layer);
   EXPECT_EQ(pending_layer_, paired_layers[0].pending_layer);
 }
 
 TEST_F(PictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
   base::TimeTicks time_ticks;
   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
 
   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);
 
   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);
+  SetupDrawPropertiesAndUpdateTilePriorities(
+      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;
   gfx::Rect viewport = gfx::Rect(layer_bounds);
   gfx::Transform transform;
   host_impl_.SetExternalDrawConstraints(
       transform, viewport, viewport, valid_for_tile_management);
   active_layer_->draw_properties().visible_content_rect = viewport;
   active_layer_->draw_properties().screen_space_transform = transform;
   active_layer_->UpdateTilePriorities();
@@ skipping 236 matching lines @@
 
 TEST_F(PictureLayerImplTest, ManageTilingsWithNoRecording) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
   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);
+  SetupDrawPropertiesAndUpdateTilePriorities(
+      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   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);
+  SetupDrawPropertiesAndUpdateTilePriorities(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());
   EXPECT_FLOAT_EQ(6.f * low_res_factor,
                   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);
+  SetupDrawPropertiesAndUpdateTilePriorities(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());
   EXPECT_FLOAT_EQ(6.6f * low_res_factor,
                   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);
+  SetupDrawPropertiesAndUpdateTilePriorities(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());
   EXPECT_FLOAT_EQ(7.26f * low_res_factor,
                   pending_layer_->tilings()->tiling_at(3)->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);
+  SetupDrawPropertiesAndUpdateTilePriorities(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());
   EXPECT_FLOAT_EQ(7.26f * low_res_factor,
                   pending_layer_->tilings()->tiling_at(3)->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, CreateTilingsEvenIfTwinHasNone) {
   // This test makes sure that if a layer can have tilings, then a commit makes
   // it not able to have tilings (empty size), and then a future commit that
   // makes it valid again should be able to create tilings.
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> empty_pile =
       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> valid_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
   float high_res_scale = 1.3f;
   float low_res_scale = high_res_scale * low_res_factor;
   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);
+  SetupDrawPropertiesAndUpdateTilePriorities(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());
   EXPECT_FLOAT_EQ(low_res_scale,
                   pending_layer_->LowResTiling()->contents_scale());
 
   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);
+  SetupDrawPropertiesAndUpdateTilePriorities(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);
+  SetupDrawPropertiesAndUpdateTilePriorities(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);
+  SetupDrawPropertiesAndUpdateTilePriorities(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,
                   pending_layer_->HighResTiling()->contents_scale());
   EXPECT_FLOAT_EQ(low_res_scale,
                   pending_layer_->LowResTiling()->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, ZoomOutCrash) {
   gfx::Size tile_size(400, 400);
@@ skipping 113 matching lines @@
 
 TEST_F(PictureLayerImplTest, CleanUpTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   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);
   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);
 
   float device_scale = 1.7f;
   float page_scale = 3.2f;
@@ skipping 53 matching lines @@
   // Now move the ideal scale to 1.0. Our target stays 1.2.
   SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, 1.f, false);
 
   // All the tilings are between are target and the ideal, so they are not
   // removed.
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   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);
+  SetupDrawPropertiesAndUpdateTilePriorities(
+      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.
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
 
   // 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);
+  SetupDrawPropertiesAndUpdateTilePriorities(
+      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
   // deleted.
   used_tilings.clear();
   used_tilings.push_back(active_layer_->tilings()->tiling_at(1));
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
 
   // If we remove it from our used tilings set, it is outside the range to keep
@@ skipping 133 matching lines @@
 
 TEST_F(PictureLayerImplTest, ReleaseResources) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   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);
+  SetupDrawPropertiesAndUpdateTilePriorities(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.
   active_layer_->ReleaseResources();
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
   pending_layer_->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);
+  SetupDrawPropertiesAndUpdateTilePriorities(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());
 }
 
 TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) {
   // The default max tile size is larger than 400x400.
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(5000, 5000);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   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);
+  SetupDrawPropertiesAndUpdateTilePriorities(
+      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();
 
   // The default value.
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
             host_impl_.settings().default_tile_size.ToString());
 
   Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
             tile->content_rect().size().ToString());
 
   pending_layer_->ReleaseResources();
 
   // Change the max texture size on the output surface context.
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   context->set_max_texture_size(140);
   host_impl_.DidLoseOutputSurface();
   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);
+  SetupDrawPropertiesAndUpdateTilePriorities(
+      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();
 
   // Verify the tiles are not larger than the context's max texture size.
   tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_GE(140, tile->content_rect().width());
   EXPECT_GE(140, tile->content_rect().height());
 }
 
 TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
   // The default max tile size is larger than 400x400.
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(500, 500);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   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);
+  SetupDrawPropertiesAndUpdateTilePriorities(
+      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();
 
   // The default value. The layer is smaller than this.
   EXPECT_EQ(gfx::Size(512, 512).ToString(),
             host_impl_.settings().max_untiled_layer_size.ToString());
 
   // There should be a single tile since the layer is small.
   PictureLayerTiling* high_res_tiling = pending_layer_->tilings()->tiling_at(0);
   EXPECT_EQ(1u, high_res_tiling->AllTilesForTesting().size());
 
   pending_layer_->ReleaseResources();
 
   // Change the max texture size on the output surface context.
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   context->set_max_texture_size(140);
   host_impl_.DidLoseOutputSurface();
   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);
+  SetupDrawPropertiesAndUpdateTilePriorities(
+      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();
 
   // There should be more than one tile since the max texture size won't cover
   // the layer.
   high_res_tiling = pending_layer_->tilings()->tiling_at(0);
   EXPECT_LT(1u, high_res_tiling->AllTilesForTesting().size());
 
   // Verify the tiles are not larger than the context's max texture size.
   Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_GE(140, tile->content_rect().width());
   EXPECT_GE(140, tile->content_rect().height());
 }
 
 TEST_F(PictureLayerImplTest, DisallowTileDrawQuads) {
   MockQuadCuller quad_culler;
 
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   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);
 
-  active_layer_->SetContentBounds(layer_bounds);
   active_layer_->draw_properties().visible_content_rect =
       gfx::Rect(layer_bounds);
 
   gfx::Rect layer_invalidation(150, 200, 30, 180);
   Region invalidation(layer_invalidation);
   AddDefaultTilingsWithInvalidation(invalidation);
 
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_RESOURCELESS_SOFTWARE, NULL);
   active_layer_->AppendQuads(&quad_culler, &data);
@@ skipping 397 matching lines @@
             pending_layer_->tilings()->TilingAtScale(1.0f)->resolution());
   ASSERT_TRUE(pending_layer_->tilings()->TilingAtScale(1.5f));
   EXPECT_EQ(NON_IDEAL_RESOLUTION,
             pending_layer_->tilings()->TilingAtScale(1.5f)->resolution());
 }
 
 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);
+  SetupDrawPropertiesAndUpdateTilePriorities(
+      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());
 
   ResetTilingsAndRasterScales();
 
   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);
+  SetupDrawPropertiesAndUpdateTilePriorities(
+      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());
 }
 
 TEST_F(PictureLayerImplTest, NoTilingIfDoesNotDrawContent) {
   // Set up layers with tilings.
   SetupDefaultTrees(gfx::Size(10, 10));
   SetContentsScaleOnBothLayers(1.f, 1.f, 1.f, 1.f, false);
   pending_layer_->PushPropertiesTo(active_layer_);
   EXPECT_TRUE(pending_layer_->DrawsContent());
@@ skipping 323 matching lines @@
     std::copy(tiles.begin(), tiles.end(), std::back_inserter(all_tiles));
   }
 
   std::set<Tile*> all_tiles_set(all_tiles.begin(), all_tiles.end());
 
   bool mark_required = false;
   for (std::vector<Tile*>::iterator it = all_tiles.begin();
        it != all_tiles.end();
        ++it) {
     Tile* tile = *it;
+

[danakj, 2014/05/23 17:07:34]

nit: don't add whitespace here

     if (mark_required)
       tile->MarkRequiredForActivation();
     mark_required = !mark_required;
   }
 
   // Sanity checks.
   EXPECT_EQ(91u, all_tiles.size());
   EXPECT_EQ(91u, all_tiles_set.size());
 
   // Empty iterator.
@@ skipping 186 matching lines @@
   contents_scale = 0.5f;
 
   SetContentsScaleOnBothLayers(contents_scale,
                                device_scale,
                                page_scale,
                                maximum_animation_scale,
                                animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
 }
 
+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);
+
+  SetupDrawPropertiesAndUpdateTilePriorities(
+      pending_layer_, 2.5f, 1.f, 1.f, 1.f, false);
+
+  active_layer_->draw_properties().visible_content_rect =
+      gfx::Rect(layer_bounds);
+
+  float max_contents_scale = active_layer_->MaximumTilingContentScale();
+  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
+  // MaximumTilingContentScale 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
+  // MaximumTilingContentScale 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
+  // MaximumTilingContentScale 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