cc: Chromify Layer and LayerImpl classes.

cc/layer_tree_host_unittest_occlusion.cc

 // Copyright 2012 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/layer_tree_host.h"
 
 #include "cc/layer.h"
 #include "cc/test/layer_tree_test_common.h"
 #include "cc/test/occlusion_tracker_test_common.h"
 
 namespace cc {
 namespace {
 
 class TestLayer : public Layer {
  public:
   static scoped_refptr<TestLayer> Create() {
     return make_scoped_refptr(new TestLayer());
   }
 
-  virtual void update(
-      ResourceUpdateQueue& update_queue,
+  virtual void Update(
+      ResourceUpdateQueue* update_queue,
       const OcclusionTracker* occlusion,
       RenderingStats* stats) OVERRIDE {
     if (!occlusion)
       return;
 
     // Gain access to internals of the OcclusionTracker.
     const TestOcclusionTracker* test_occlusion =
         static_cast<const TestOcclusionTracker*>(occlusion);
     occlusion_ = UnionRegions(
         test_occlusion->occlusion_from_inside_target(),
         test_occlusion->occlusion_from_outside_target());
   }
 
   const Region& occlusion() const { return occlusion_; }
   const Region& expected_occlusion() const { return expected_occlusion_; }
   void set_expected_occlusion(const Region& occlusion) {
     expected_occlusion_ = occlusion;
   }
 
  private:
   TestLayer() : Layer() {
-    setIsDrawable(true);
+    SetIsDrawable(true);
   }
   virtual ~TestLayer() { }
 
   Region occlusion_;
   Region expected_occlusion_;
 };
 
 class LayerTreeHostOcclusionTest : public ThreadedTest {
  public:
 
@@ skipping 24 matching lines @@
 
     for (size_t i = 0; i < layer->children().size(); ++i) {
       TestLayer* child = static_cast<TestLayer*>(layer->children()[i].get());
       VerifyOcclusion(child);
     }
   }
 
   void SetLayerPropertiesForTesting(
       TestLayer* layer, TestLayer* parent, const gfx::Transform& transform,
       const gfx::PointF& position, const gfx::Size& bounds, bool opaque) const {
-    layer->removeAllChildren();
+    layer->RemoveAllChildren();
     if (parent)
-      parent->addChild(layer);
-    layer->setTransform(transform);
-    layer->setPosition(position);
-    layer->setBounds(bounds);
-    layer->setContentsOpaque(opaque);
+      parent->AddChild(layer);
+    layer->SetTransform(transform);
+    layer->SetPosition(position);
+    layer->SetBounds(bounds);
+    layer->SetContentsOpaque(opaque);
 
-    layer->setAnchorPoint(gfx::PointF());
+    layer->SetAnchorPoint(gfx::PointF());
   }
 
  protected:
   scoped_refptr<TestLayer> root_;
   scoped_refptr<TestLayer> child_;
   scoped_refptr<TestLayer> child2_;
   scoped_refptr<TestLayer> grand_child_;
   scoped_refptr<TestLayer> mask_;
 
   gfx::Transform identity_matrix_;
 };
 
 
 class LayerTreeHostOcclusionTestOcclusionSurfaceClipping :
     public LayerTreeHostOcclusionTest {
  public:
   virtual void setupTree() OVERRIDE {
     // The child layer is a surface and the grandChild is opaque, but clipped to
     // the child and root
     SetLayerPropertiesForTesting(
         root_.get(), NULL, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), false);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(20, 500), true);
 
-    child_->setMasksToBounds(true);
-    child_->setForceRenderSurface(true);
+    child_->SetMasksToBounds(true);
+    child_->SetForceRenderSurface(true);
     
     child_->set_expected_occlusion(gfx::Rect(0, 0, 10, 190));
     root_->set_expected_occlusion(gfx::Rect(10, 10, 10, 190));
 
     m_layerTreeHost->setRootLayer(root_);
     ThreadedTest::setupTree();
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostOcclusionTestOcclusionSurfaceClipping)
 
 class LayerTreeHostOcclusionTestOcclusionSurfaceClippingOpaque :
     public LayerTreeHostOcclusionTest {
  public:
   virtual void setupTree() OVERRIDE {
     // If the child layer is opaque, then it adds to the occlusion seen by the
     // root_.
     SetLayerPropertiesForTesting(
         root_.get(), NULL, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(20, 500), true);
 
-    child_->setMasksToBounds(true);
-    child_->setForceRenderSurface(true);
+    child_->SetMasksToBounds(true);
+    child_->SetForceRenderSurface(true);
 
     child_->set_expected_occlusion(gfx::Rect(0, 0, 10, 190));
     root_->set_expected_occlusion(gfx::Rect(10, 10, 190, 190));
 
     m_layerTreeHost->setRootLayer(root_);
     ThreadedTest::setupTree();
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
@@ skipping 10 matching lines @@
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), false);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(20, 500), true);
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(20.f, 10.f), gfx::Size(10, 500), true);
 
-    child_->setMasksToBounds(true);
-    child_->setForceRenderSurface(true);
+    child_->SetMasksToBounds(true);
+    child_->SetForceRenderSurface(true);
 
     grand_child_->set_expected_occlusion(gfx::Rect(10, 0, 10, 190));
     child_->set_expected_occlusion(gfx::Rect(0, 0, 20, 190));
     root_->set_expected_occlusion(gfx::Rect(10, 10, 20, 190));
 
     m_layerTreeHost->setRootLayer(root_);
     ThreadedTest::setupTree();
   }
 };
 
@@ skipping 12 matching lines @@
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(20.f, 20.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(500, 500), true);
 
-    child_->setMasksToBounds(true);
-    child_->setForceRenderSurface(true);
-    child_->setMaskLayer(mask_.get());
+    child_->SetMasksToBounds(true);
+    child_->SetForceRenderSurface(true);
+    child_->SetMaskLayer(mask_.get());
 
     child_->set_expected_occlusion(gfx::Rect(0, 0, 180, 180));
     root_->set_expected_occlusion(gfx::Rect(10, 10, 190, 190));
 
     m_layerTreeHost->setRootLayer(root_);
     ThreadedTest::setupTree();
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostOcclusionTestOcclusionMask)
@@ skipping 11 matching lines @@
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(20, 500), true);
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(20.f, 10.f), gfx::Size(10, 500), true);
 
-    child_->setMasksToBounds(true);
-    child_->setForceRenderSurface(true);
-    child_->setMaskLayer(mask_.get());
+    child_->SetMasksToBounds(true);
+    child_->SetForceRenderSurface(true);
+    child_->SetMaskLayer(mask_.get());
   
     grand_child_->set_expected_occlusion(gfx::Rect(10, 0, 10, 190));
     child_->set_expected_occlusion(gfx::Rect(0, 0, 20, 190));
     root_->set_expected_occlusion(gfx::Rect(20, 10, 10, 190));
 
     m_layerTreeHost->setRootLayer(root_);
     ThreadedTest::setupTree();
   }
 };
 
@@ skipping 12 matching lines @@
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(20.f, 10.f), gfx::Size(10, 500), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(20, 500), true);
 
-    child_->setMasksToBounds(true);
-    child_->setForceRenderSurface(true);
-    child_->setOpacity(0.5f);
+    child_->SetMasksToBounds(true);
+    child_->SetForceRenderSurface(true);
+    child_->SetOpacity(0.5f);
 
     child_->set_expected_occlusion(gfx::Rect(0, 0, 10, 190));
     root_->set_expected_occlusion(gfx::Rect(20, 10, 10, 190));
 
     m_layerTreeHost->setRootLayer(root_);
     ThreadedTest::setupTree();
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostOcclusionTestOcclusionOpacity)
@@ skipping 11 matching lines @@
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(20, 500), true);
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(20.f, 10.f), gfx::Size(10, 500), true);
 
-    child_->setMasksToBounds(true);
-    child_->setForceRenderSurface(true);
-    child_->setOpacity(0.5f);
+    child_->SetMasksToBounds(true);
+    child_->SetForceRenderSurface(true);
+    child_->SetOpacity(0.5f);
 
     grand_child_->set_expected_occlusion(gfx::Rect(10, 0, 10, 190));
     child_->set_expected_occlusion(gfx::Rect(0, 0, 20, 190));
     root_->set_expected_occlusion(gfx::Rect(20, 10, 10, 190));
 
     m_layerTreeHost->setRootLayer(root_);
     ThreadedTest::setupTree();
   }
 };
 
@@ skipping 21 matching lines @@
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), childTransform,
         gfx::PointF(30.f, 30.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 70.f), gfx::Size(500, 500), true);
 
-    child_->setMasksToBounds(true);
-    child_->setFilters(filters);
+    child_->SetMasksToBounds(true);
+    child_->SetFilters(filters);
 
     grand_child_->set_expected_occlusion(gfx::Rect(40, 330, 130, 190));
     child_->set_expected_occlusion(UnionRegions(
         gfx::Rect(10, 330, 160, 170), gfx::Rect(40, 500, 130, 20)));
     root_->set_expected_occlusion(gfx::Rect(10, 70, 190, 130));
 
     m_layerTreeHost->setRootLayer(root_);
     ThreadedTest::setupTree();
   }
 };
@@ skipping 22 matching lines @@
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), childTransform,
         gfx::PointF(30.f, 30.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 70.f), gfx::Size(500, 500), true);
 
-    child_->setMasksToBounds(true);
-    child_->setFilters(filters);
+    child_->SetMasksToBounds(true);
+    child_->SetFilters(filters);
 
     child_->set_expected_occlusion(gfx::Rect(10, 330, 160, 170));
     root_->set_expected_occlusion(gfx::Rect(10, 70, 190, 130));
 
     m_layerTreeHost->setRootLayer(root_);
     ThreadedTest::setupTree();
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
@@ skipping 10 matching lines @@
     int root_width = 400;
     int root_height = 400;
 
     for (int i = 0; i < num_surfaces; ++i) {
       layers.push_back(TestLayer::Create());
       if (!i) {
         SetLayerPropertiesForTesting(
             layers.back().get(), NULL, identity_matrix_,
             gfx::PointF(0.f, 0.f),
             gfx::Size(root_width, root_height), true);
-        layers.back()->createRenderSurface();
+        layers.back()->CreateRenderSurface();
       } else {
         SetLayerPropertiesForTesting(
             layers.back().get(), layers[layers.size() - 2].get(),
             identity_matrix_,
             gfx::PointF(1.f, 1.f),
             gfx::Size(root_width-i, root_height-i), true);
-        layers.back()->setForceRenderSurface(true);
+        layers.back()->SetForceRenderSurface(true);
       }
     }
 
     for (int i = 1; i < num_surfaces; ++i) {
       scoped_refptr<TestLayer> child = TestLayer::Create();
       SetLayerPropertiesForTesting(
           child.get(), layers[i].get(), identity_matrix_,
           gfx::PointF(0.f, 0.f), gfx::Size(root_width, root_height), false);
     }
 
     for (int i = 0; i < num_surfaces-1; ++i) {
       gfx::Rect expected_occlusion(1, 1, root_width-i-1, root_height-i-1);
       layers[i]->set_expected_occlusion(expected_occlusion);
     }
 
     m_layerTreeHost->setRootLayer(layers[0].get());
     ThreadedTest::setupTree();
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostOcclusionTestManySurfaces)
 
 }  // namespace
 }  // namespace cc