cc: Chromify Layer and LayerImpl classes.

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"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 namespace {
 
 class TestablePictureLayerImpl : public PictureLayerImpl {
  public:
-  static scoped_ptr<TestablePictureLayerImpl> create(
+  static scoped_ptr<TestablePictureLayerImpl> Create(
       LayerTreeImpl* treeImpl,
       int id,
       scoped_refptr<PicturePileImpl> pile)
   {
     return make_scoped_ptr(new TestablePictureLayerImpl(treeImpl, id, pile));
   }
 
   PictureLayerTilingSet& tilings() { return *tilings_; }
   Region& invalidation() { return invalidation_; }
 
   virtual gfx::Size CalculateTileSize(
       gfx::Size current_tile_size,
       gfx::Size /* content_bounds */) OVERRIDE {
     if (current_tile_size.IsEmpty())
       return gfx::Size(100, 100);
     return current_tile_size;
   }
 
   using PictureLayerImpl::AddTiling;
   using PictureLayerImpl::CleanUpTilingsOnActiveLayer;
 
  private:
   TestablePictureLayerImpl(
       LayerTreeImpl* treeImpl,
       int id,
       scoped_refptr<PicturePileImpl> pile)
       : PictureLayerImpl(treeImpl, id) {
     pile_ = pile;
-    setBounds(pile_->size());
+    SetBounds(pile_->size());
     CreateTilingSet();
   }
 };
 
 class ImplSidePaintingSettings : public LayerTreeSettings {
  public:
   ImplSidePaintingSettings() {
     implSidePainting = true;
   }
 };
@@ skipping 116 matching lines @@
   }
 
   void SetupPendingTree(
       scoped_refptr<PicturePileImpl> pile) {
     host_impl_.createPendingTree();
     LayerTreeImpl* pending_tree = host_impl_.pendingTree();
     // Clear recycled tree.
     pending_tree->DetachLayerTree();
 
     scoped_ptr<TestablePictureLayerImpl> pending_layer =
-        TestablePictureLayerImpl::create(pending_tree, id_, pile);
-    pending_layer->setDrawsContent(true);
+        TestablePictureLayerImpl::Create(pending_tree, id_, pile);
+    pending_layer->SetDrawsContent(true);
     pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
   }
 
   static void VerifyAllTilesExistAndHavePile(
       const PictureLayerTiling* tiling,
       PicturePileImpl* pile) {
     for (PictureLayerTiling::Iterator iter(tiling,
                                            tiling->contents_scale(),
                                            tiling->ContentRect(),
                                            PictureLayerTiling::LayerDeviceAlignmentUnknown);
          iter; ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_EQ(pile, iter->picture_pile());
     }
   }
 
   void SetContentsScaleOnBothLayers(float scale, bool animating_transform) {
     float result_scale_x, result_scale_y;
     gfx::Size result_bounds;
-    pending_layer_->calculateContentsScale(
+    pending_layer_->CalculateContentsScale(
         scale, animating_transform,
         &result_scale_x, &result_scale_y, &result_bounds);
-    active_layer_->calculateContentsScale(
+    active_layer_->CalculateContentsScale(
         scale, animating_transform,
         &result_scale_x, &result_scale_y, &result_bounds);
   }
 
  protected:
   void TestTileGridAlignmentCommon() {
     // Layer to span 4 raster tiles in x and in y
     ImplSidePaintingSettings settings;
     gfx::Size layer_size(
         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);
     float result_scale_x, result_scale_y;
     gfx::Size result_bounds;
-    active_layer_->calculateContentsScale(
+    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;
     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 239 matching lines @@
 
   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);
 
-  pending_layer_->calculateContentsScale(
+  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;
   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);
 
-  pending_layer_->calculateContentsScale(
+  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(
+  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);
 
-  pending_layer_->calculateContentsScale(
+  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);
 
-  pending_layer_->calculateContentsScale(
+  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);
 
-  pending_layer_->calculateContentsScale(
+  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());
 }
 
@@ skipping 69 matching lines @@
   // Now move the ideal scale to 1.0. Our target stays 1.2.
   SetContentsScaleOnBothLayers(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(4u, 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(
+  active_layer_->CalculateContentsScale(
       1.1f, false, &result_scale_x, &result_scale_y, &result_bounds);
 
   // 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(4u, 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(
+  pending_layer_->CalculateContentsScale(
       1.1f, false, &result_scale_x, &result_scale_y, &result_bounds);
 
   // 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));
   used_tilings.push_back(active_layer_->tilings().tiling_at(3));
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(4u, active_layer_->tilings().num_tilings());
 
   // If we remove it from our used tilings set, it is outside the range to keep
   // so it is deleted. Try one tiling at a time.
   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());
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer_->tilings().num_tilings());
   
 }
 
 }  // namespace
 }  // namespace cc