cc: Chromify the LayerTreeHostImpl class.

cc/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/picture_layer_impl.h"
 
 #include "cc/layer_tree_impl.h"
 #include "cc/picture_layer.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_impl_proxy.h"
@@ skipping 131 matching lines @@
   }
 
   std::vector<SkRect> rects_;
 };
 
 class PictureLayerImplTest : public testing::Test {
  public:
   PictureLayerImplTest()
       : host_impl_(ImplSidePaintingSettings(), &proxy_),
         id_(7) {
-    host_impl_.initializeRenderer(createFakeOutputSurface());
+    host_impl_.InitializeRenderer(createFakeOutputSurface());
   }
 
   virtual ~PictureLayerImplTest() {
   }
 
   void SetupTrees(
       scoped_refptr<PicturePileImpl> pending_pile,
       scoped_refptr<PicturePileImpl> active_pile) {
     SetupPendingTree(active_pile);
-    host_impl_.activatePendingTree();
+    host_impl_.ActivatePendingTree();
 
     active_layer_ = static_cast<TestablePictureLayerImpl*>(
-        host_impl_.activeTree()->LayerById(id_));
+        host_impl_.active_tree()->LayerById(id_));
 
     SetupPendingTree(pending_pile);
     pending_layer_ = static_cast<TestablePictureLayerImpl*>(
-        host_impl_.pendingTree()->LayerById(id_));
+        host_impl_.pending_tree()->LayerById(id_));
   }
 
   void AddDefaultTilingsWithInvalidation(const Region& invalidation) {
     active_layer_->AddTiling(2.3f);
     active_layer_->AddTiling(1.0f);
     active_layer_->AddTiling(0.5f);
     pending_layer_->invalidation() = invalidation;
     pending_layer_->SyncFromActiveLayer();
   }
 
   void SetupPendingTree(
       scoped_refptr<PicturePileImpl> pile) {
-    host_impl_.createPendingTree();
-    LayerTreeImpl* pending_tree = host_impl_.pendingTree();
+    host_impl_.CreatePendingTree();
+    LayerTreeImpl* pending_tree = host_impl_.pending_tree();
     // Clear recycled tree.
     pending_tree->DetachLayerTree();
 
     scoped_ptr<TestablePictureLayerImpl> pending_layer =
         TestablePictureLayerImpl::Create(pending_tree, id_, pile);
     pending_layer->SetDrawsContent(true);
     pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
   }
 
   static void VerifyAllTilesExistAndHavePile(
@@ skipping 28 matching lines @@
         settings.defaultTileSize.width() * 7 / 2,
         settings.defaultTileSize.height() * 7 / 2);
 
     scoped_refptr<TestablePicturePileImpl> pending_pile =
         TestablePicturePileImpl::CreateFilledPile(layer_size, layer_size);
     scoped_refptr<TestablePicturePileImpl> active_pile =
         TestablePicturePileImpl::CreateFilledPile(layer_size, layer_size);
 
     SetupTrees(pending_pile, active_pile);
 
-    host_impl_.activeTree()->SetPageScaleFactorAndLimits(1.f, 1.f, 1.f);
+    host_impl_.active_tree()->SetPageScaleFactorAndLimits(1.f, 1.f, 1.f);
     float result_scale_x, result_scale_y;
     gfx::Size result_bounds;
     active_layer_->CalculateContentsScale(
         1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
 
     // Add 1x1 rects at the centers of each tile, then re-record pile contents
     std::vector<Tile*> tiles =
         active_layer_->tilings().tiling_at(0)->AllTilesForTesting();
     EXPECT_EQ(16, tiles.size());
     std::vector<SkRect> rects;
@@ skipping 34 matching lines @@
   FakeImplProxy proxy_;
   FakeLayerTreeHostImpl host_impl_;
   int id_;
   TestablePictureLayerImpl* pending_layer_;
   TestablePictureLayerImpl* active_layer_;
 
   DISALLOW_COPY_AND_ASSIGN(PictureLayerImplTest);
 };
 
 TEST_F(PictureLayerImplTest, tileGridAlignment) {
-  host_impl_.setDeviceScaleFactor(1.f);
+  host_impl_.SetDeviceScaleFactor(1.f);
   TestTileGridAlignmentCommon();
 }
 
 TEST_F(PictureLayerImplTest, tileGridAlignmentHiDPI) {
-  host_impl_.setDeviceScaleFactor(2.f);
+  host_impl_.SetDeviceScaleFactor(2.f);
   TestTileGridAlignmentCommon();
 }
 
 TEST_F(PictureLayerImplTest, cloneNoInvalidation) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
 
   scoped_refptr<TestablePicturePileImpl> pending_pile =
       TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<TestablePicturePileImpl> active_pile =
@@ skipping 179 matching lines @@
       TestablePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
   scoped_refptr<TestablePicturePileImpl> active_pile =
       TestablePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupTrees(pending_pile, active_pile);
 
   // These are included in the scale given to the layer.
-  host_impl_.setDeviceScaleFactor(1.f);
-  host_impl_.pendingTree()->SetPageScaleFactorAndLimits(1.f, 1.f, 1.f);
+  host_impl_.SetDeviceScaleFactor(1.f);
+  host_impl_.pending_tree()->SetPageScaleFactorAndLimits(1.f, 1.f, 1.f);
 
   pending_layer_->CalculateContentsScale(
       1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
 
   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<TestablePicturePileImpl> pending_pile =
       TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<TestablePicturePileImpl> active_pile =
       TestablePicturePileImpl::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().lowResContentsScaleFactor;
+  float low_res_factor = host_impl_.settings().lowResContentsScaleFactor;
   EXPECT_LT(low_res_factor, 1.f);
 
   // These are included in the scale given to the layer.
-  host_impl_.setDeviceScaleFactor(1.7f);
-  host_impl_.pendingTree()->SetPageScaleFactorAndLimits(3.2f, 3.2f, 3.2f);
+  host_impl_.SetDeviceScaleFactor(1.7f);
+  host_impl_.pending_tree()->SetPageScaleFactorAndLimits(3.2f, 3.2f, 3.2f);
 
   pending_layer_->CalculateContentsScale(
       1.3f, false, &result_scale_x, &result_scale_y, &result_bounds);
   ASSERT_EQ(2u, pending_layer_->tilings().num_tilings());
   EXPECT_FLOAT_EQ(
       1.3f,
       pending_layer_->tilings().tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.3f * low_res_factor,
       pending_layer_->tilings().tiling_at(1)->contents_scale());
 
   // If we change the layer's CSS scale factor, then we should not get new
   // tilings.
   pending_layer_->CalculateContentsScale(
       1.8f, false, &result_scale_x, &result_scale_y, &result_bounds);
   ASSERT_EQ(2u, pending_layer_->tilings().num_tilings());
   EXPECT_FLOAT_EQ(
       1.3f,
       pending_layer_->tilings().tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.3f * low_res_factor,
       pending_layer_->tilings().tiling_at(1)->contents_scale());
 
   // If we change the page scale factor, then we should get new tilings.
-  host_impl_.pendingTree()->SetPageScaleFactorAndLimits(2.2f, 2.2f, 2.2f);
+  host_impl_.pending_tree()->SetPageScaleFactorAndLimits(2.2f, 2.2f, 2.2f);
 
   pending_layer_->CalculateContentsScale(
       1.8f, false, &result_scale_x, &result_scale_y, &result_bounds);
   ASSERT_EQ(4u, pending_layer_->tilings().num_tilings());
   EXPECT_FLOAT_EQ(
       1.8f,
       pending_layer_->tilings().tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.8f * low_res_factor,
       pending_layer_->tilings().tiling_at(2)->contents_scale());
 
   // If we change the device scale factor, then we should get new tilings.
-  host_impl_.setDeviceScaleFactor(1.4f);
+  host_impl_.SetDeviceScaleFactor(1.4f);
 
   pending_layer_->CalculateContentsScale(
       1.9f, false, &result_scale_x, &result_scale_y, &result_bounds);
   ASSERT_EQ(6u, pending_layer_->tilings().num_tilings());
   EXPECT_FLOAT_EQ(
       1.9f,
       pending_layer_->tilings().tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.9f * 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.
-  host_impl_.setDeviceScaleFactor(2.2f);
-  host_impl_.pendingTree()->SetPageScaleFactorAndLimits(1.4f, 1.4f, 1.4f);
+  host_impl_.SetDeviceScaleFactor(2.2f);
+  host_impl_.pending_tree()->SetPageScaleFactorAndLimits(1.4f, 1.4f, 1.4f);
 
   pending_layer_->CalculateContentsScale(
       1.9f, false, &result_scale_x, &result_scale_y, &result_bounds);
   ASSERT_EQ(6u, pending_layer_->tilings().num_tilings());
   EXPECT_FLOAT_EQ(
       1.9f,
       pending_layer_->tilings().tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.9f * low_res_factor,
       pending_layer_->tilings().tiling_at(3)->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, CleanUpTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<TestablePicturePileImpl> pending_pile =
       TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<TestablePicturePileImpl> active_pile =
       TestablePicturePileImpl::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().lowResContentsScaleFactor;
+  float low_res_factor = host_impl_.settings().lowResContentsScaleFactor;
   EXPECT_LT(low_res_factor, 1.f);
 
   // These are included in the scale given to the layer.
-  host_impl_.setDeviceScaleFactor(1.7f);
-  host_impl_.pendingTree()->SetPageScaleFactorAndLimits(3.2f, 3.2f, 3.2f);
-  host_impl_.activeTree()->SetPageScaleFactorAndLimits(3.2f, 3.2f, 3.2f);
+  host_impl_.SetDeviceScaleFactor(1.7f);
+  host_impl_.pending_tree()->SetPageScaleFactorAndLimits(3.2f, 3.2f, 3.2f);
+  host_impl_.active_tree()->SetPageScaleFactorAndLimits(3.2f, 3.2f, 3.2f);
 
   SetContentsScaleOnBothLayers(1.f, false);
   ASSERT_EQ(2u, active_layer_->tilings().num_tilings());
 
   // We only have ideal tilings, so they aren't removed.
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer_->tilings().num_tilings());
 
   // Changing the ideal but not creating new tilings.
   SetContentsScaleOnBothLayers(1.5f, false);
   ASSERT_EQ(2u, active_layer_->tilings().num_tilings());
 
   // The tilings are still our target scale, so they aren't removed.
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer_->tilings().num_tilings());
 
   // Create a 1.2 scale tiling. Now we have 1.0 and 1.2 tilings. Ideal = 1.2.
-  host_impl_.pendingTree()->SetPageScaleFactorAndLimits(1.2f, 1.2f, 1.2f);
-  host_impl_.activeTree()->SetPageScaleFactorAndLimits(1.2f, 1.2f, 1.2f);
+  host_impl_.pending_tree()->SetPageScaleFactorAndLimits(1.2f, 1.2f, 1.2f);
+  host_impl_.active_tree()->SetPageScaleFactorAndLimits(1.2f, 1.2f, 1.2f);
   SetContentsScaleOnBothLayers(1.2f, false);
   ASSERT_EQ(4u, active_layer_->tilings().num_tilings());
   EXPECT_FLOAT_EQ(
       1.f,
       active_layer_->tilings().tiling_at(1)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.f * low_res_factor,
       active_layer_->tilings().tiling_at(3)->contents_scale());
 
   // Mark the non-ideal tilings as used. They won't be removed.
@@ skipping 52 matching lines @@
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer_->tilings().num_tilings());
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer_->tilings().num_tilings());
   
 }
 
 }  // namespace
 }  // namespace cc