cc: Chromify the LayerTreeHostImpl class.

cc/layer_tree_host_unittest_scroll.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/content_layer.h"
 #include "cc/layer.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_tree_impl.h"
@@ skipping 31 matching lines @@
       EXPECT_VECTOR_EQ(initial_scroll_, root->scroll_offset());
     else {
       EXPECT_VECTOR_EQ(initial_scroll_ + scroll_amount_, root->scroll_offset());
 
       // Pretend like Javascript updated the scroll position itself.
       root->SetScrollOffset(second_scroll_);
     }
   }
 
   virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    LayerImpl* root = impl->rootLayer();
+    LayerImpl* root = impl->active_tree()->root_layer();
     EXPECT_VECTOR_EQ(gfx::Vector2d(), root->scroll_delta());
 
     root->SetScrollable(true);
     root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     root->ScrollBy(scroll_amount_);
 
-    switch (impl->activeTree()->source_frame_number()) {
+    switch (impl->active_tree()->source_frame_number()) {
       case 0:
         EXPECT_VECTOR_EQ(initial_scroll_, root->scroll_offset());
         EXPECT_VECTOR_EQ(scroll_amount_, root->scroll_delta());
         postSetNeedsCommitToMainThread();
         break;
       case 1:
         EXPECT_VECTOR_EQ(root->scroll_offset(), second_scroll_);
         EXPECT_VECTOR_EQ(root->scroll_delta(), scroll_amount_);
         endTest();
         break;
@@ skipping 47 matching lines @@
             initial_scroll_ + scroll_amount_ + scroll_amount_);
       case 2:
         EXPECT_VECTOR_EQ(
             root->scroll_offset(),
             initial_scroll_ + scroll_amount_ + scroll_amount_);
         break;
     }
   }
 
   virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    LayerImpl* root = impl->rootLayer();
+    LayerImpl* root = impl->active_tree()->root_layer();
     root->SetScrollable(true);
     root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
 
-    if (impl->activeTree()->source_frame_number() == 0 &&
-        impl->sourceAnimationFrameNumber() == 1) {
+    if (impl->active_tree()->source_frame_number() == 0 &&
+        impl->SourceAnimationFrameNumber() == 1) {
       // First draw after first commit.
       EXPECT_VECTOR_EQ(root->scroll_delta(), gfx::Vector2d());
       root->ScrollBy(scroll_amount_);
       EXPECT_VECTOR_EQ(root->scroll_delta(), scroll_amount_);
 
       EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
       postSetNeedsRedrawToMainThread();
-    } else if (impl->activeTree()->source_frame_number() == 0 &&
-               impl->sourceAnimationFrameNumber() == 2) {
+    } else if (impl->active_tree()->source_frame_number() == 0 &&
+               impl->SourceAnimationFrameNumber() == 2) {
       // Second draw after first commit.
       EXPECT_EQ(root->scroll_delta(), scroll_amount_);
       root->ScrollBy(scroll_amount_);
       EXPECT_VECTOR_EQ(root->scroll_delta(), scroll_amount_ + scroll_amount_);
 
       EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
       postSetNeedsCommitToMainThread();
-    } else if (impl->activeTree()->source_frame_number() == 1) {
+    } else if (impl->active_tree()->source_frame_number() == 1) {
       // Third or later draw after second commit.
-      EXPECT_GE(impl->sourceAnimationFrameNumber(), 3);
+      EXPECT_GE(impl->SourceAnimationFrameNumber(), 3);
       EXPECT_VECTOR_EQ(root->scroll_delta(), gfx::Vector2d());
       EXPECT_VECTOR_EQ(
           root->scroll_offset(),
           initial_scroll_ + scroll_amount_ + scroll_amount_);
       endTest();
     }
   }
 
   virtual void applyScrollAndScale(
       gfx::Vector2d scroll_delta, float scale) OVERRIDE {
@@ skipping 18 matching lines @@
   LayerTreeHostScrollTestFractionalScroll()
       : scroll_amount_(1.75, 0) {
   }
 
   virtual void beginTest() OVERRIDE {
     m_layerTreeHost->root_layer()->SetScrollable(true);
     postSetNeedsCommitToMainThread();
   }
 
   virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    LayerImpl* root = impl->rootLayer();
+    LayerImpl* root = impl->active_tree()->root_layer();
     root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
 
     // Check that a fractional scroll delta is correctly accumulated over
     // multiple commits.
-    switch (impl->activeTree()->source_frame_number()) {
+    switch (impl->active_tree()->source_frame_number()) {
       case 0:
         EXPECT_VECTOR_EQ(root->scroll_offset(), gfx::Vector2d(0, 0));
         EXPECT_VECTOR_EQ(root->scroll_delta(), gfx::Vector2d(0, 0));
         postSetNeedsCommitToMainThread();
         break;
       case 1:
         EXPECT_VECTOR_EQ(
             root->scroll_offset(),
             gfx::ToFlooredVector2d(scroll_amount_));
         EXPECT_VECTOR_EQ(
@@ skipping 123 matching lines @@
         break;
       case 2:
         EXPECT_VECTOR_EQ(
             javascript_scroll_ + scroll_amount_,
             expected_scroll_layer_->scroll_offset());
         break;
     }
   }
 
   virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    LayerImpl* root_impl = impl->rootLayer();
+    LayerImpl* root_impl = impl->active_tree()->root_layer();
     LayerImpl* root_scroll_layer_impl = root_impl->children()[0];
     LayerImpl* child_layer_impl = root_scroll_layer_impl->children()[0];
 
     LayerImpl* expected_scroll_layer_impl = NULL;
     LayerImpl* expected_no_scroll_layer_impl = NULL;
     if (scroll_child_layer_) {
       expected_scroll_layer_impl = child_layer_impl;
       expected_no_scroll_layer_impl = root_scroll_layer_impl;
     } else {
       expected_scroll_layer_impl = root_scroll_layer_impl;
       expected_no_scroll_layer_impl = child_layer_impl;
     }
 
     EXPECT_VECTOR_EQ(gfx::Vector2d(), root_impl->scroll_delta());
     EXPECT_VECTOR_EQ(
         gfx::Vector2d(),
         expected_no_scroll_layer_impl->scroll_delta());
 
     // Ensure device scale factor is affecting the layers.
     gfx::Size expected_content_bounds = gfx::ToCeiledSize(
         gfx::ScaleSize(root_scroll_layer_impl->bounds(), device_scale_factor_));
     EXPECT_SIZE_EQ(
         expected_content_bounds,
         root_scroll_layer_->content_bounds());
 
     expected_content_bounds = gfx::ToCeiledSize(
         gfx::ScaleSize(child_layer_impl->bounds(), device_scale_factor_));
     EXPECT_SIZE_EQ(expected_content_bounds, child_layer_->content_bounds());
 
-    switch (impl->activeTree()->source_frame_number()) {
+    switch (impl->active_tree()->source_frame_number()) {
       case 0: {
         // Gesture scroll on impl thread.
-        InputHandlerClient::ScrollStatus status = impl->scrollBegin(
+        InputHandlerClient::ScrollStatus status = impl->ScrollBegin(
             gfx::ToCeiledPoint(
                 expected_scroll_layer_impl->position() +
                 gfx::Vector2dF(0.5f, 0.5f)),
             InputHandlerClient::Gesture);
         EXPECT_EQ(InputHandlerClient::ScrollStarted, status);
-        impl->scrollBy(gfx::Point(), scroll_amount_);
-        impl->scrollEnd();
+        impl->ScrollBy(gfx::Point(), scroll_amount_);
+        impl->ScrollEnd();
 
         // Check the scroll is applied as a delta.
         EXPECT_VECTOR_EQ(
             initial_offset_,
             expected_scroll_layer_impl->scroll_offset());
         EXPECT_VECTOR_EQ(
             scroll_amount_,
             expected_scroll_layer_impl->scroll_delta());
         break;
       }
       case 1: {
         // Wheel scroll on impl thread.
-        InputHandlerClient::ScrollStatus status = impl->scrollBegin(
+        InputHandlerClient::ScrollStatus status = impl->ScrollBegin(
             gfx::ToCeiledPoint(
                 expected_scroll_layer_impl->position() +
                 gfx::Vector2dF(0.5f, 0.5f)),
             InputHandlerClient::Wheel);
         EXPECT_EQ(InputHandlerClient::ScrollStarted, status);
-        impl->scrollBy(gfx::Point(), scroll_amount_);
-        impl->scrollEnd();
+        impl->ScrollBy(gfx::Point(), scroll_amount_);
+        impl->ScrollEnd();
 
         // Check the scroll is applied as a delta.
         EXPECT_VECTOR_EQ(
             javascript_scroll_,
             expected_scroll_layer_impl->scroll_offset());
         EXPECT_VECTOR_EQ(
             scroll_amount_,
             expected_scroll_layer_impl->scroll_delta());
         break;
       }
@@ skipping 81 matching lines @@
 }
 
 class ImplSidePaintingScrollTest : public LayerTreeHostScrollTest {
  public:
   virtual void initializeSettings(LayerTreeSettings& settings) OVERRIDE {
     settings.implSidePainting = true;
   }
 
   virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     // Manual vsync tick.
-    if (impl->pendingTree())
+    if (impl->pending_tree())
       impl->setNeedsRedraw();
   }
 };
 
 class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
  public:
   ImplSidePaintingScrollTestSimple()
       : initial_scroll_(10, 20),
         main_thread_scroll_(40, 5),
         impl_thread_scroll1_(2, -1),
@@ skipping 21 matching lines @@
     }
   }
 
   virtual bool canActivatePendingTree() OVERRIDE {
     return can_activate_;
   }
 
   virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     // We force a second draw here of the first commit before activating
     // the second commit.
-    if (impl->activeTree()->source_frame_number() == 0)
+    if (impl->active_tree()->source_frame_number() == 0)
       impl->setNeedsRedraw();
   }
 
   virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     ImplSidePaintingScrollTest::drawLayersOnThread(impl);
 
-    LayerImpl* root = impl->rootLayer();
+    LayerImpl* root = impl->active_tree()->root_layer();
     root->SetScrollable(true);
     root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
 
     LayerImpl* pending_root =
-        impl->activeTree()->FindPendingTreeLayerById(root->id());
+        impl->active_tree()->FindPendingTreeLayerById(root->id());
 
-    switch (impl->activeTree()->source_frame_number()) {
+    switch (impl->active_tree()->source_frame_number()) {
       case 0:
-        if (!impl->pendingTree()) {
+        if (!impl->pending_tree()) {
           can_activate_ = false;
           EXPECT_VECTOR_EQ(root->scroll_delta(), gfx::Vector2d());
           root->ScrollBy(impl_thread_scroll1_);
 
           EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
           EXPECT_VECTOR_EQ(root->scroll_delta(), impl_thread_scroll1_);
           EXPECT_VECTOR_EQ(root->sent_scroll_delta(), gfx::Vector2d());
           postSetNeedsCommitToMainThread();
 
           // commitCompleteOnThread will trigger this function again
           // and cause us to take the else clause.
         } else {
           can_activate_ = true;
           ASSERT_TRUE(pending_root);
-          EXPECT_EQ(impl->pendingTree()->source_frame_number(), 1);
+          EXPECT_EQ(impl->pending_tree()->source_frame_number(), 1);
 
           root->ScrollBy(impl_thread_scroll2_);
           EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
           EXPECT_VECTOR_EQ(root->scroll_delta(),
               impl_thread_scroll1_ + impl_thread_scroll2_);
           EXPECT_VECTOR_EQ(root->sent_scroll_delta(), impl_thread_scroll1_);
 
           EXPECT_VECTOR_EQ(pending_root->scroll_offset(),
               initial_scroll_ + main_thread_scroll_ + impl_thread_scroll1_);
           EXPECT_VECTOR_EQ(pending_root->scroll_delta(), impl_thread_scroll2_);
           EXPECT_VECTOR_EQ(pending_root->sent_scroll_delta(), gfx::Vector2d());
         }
         break;
       case 1:
-        EXPECT_FALSE(impl->pendingTree());
+        EXPECT_FALSE(impl->pending_tree());
         EXPECT_VECTOR_EQ(root->scroll_offset(),
             initial_scroll_ + main_thread_scroll_ + impl_thread_scroll1_);
         EXPECT_VECTOR_EQ(root->scroll_delta(), impl_thread_scroll2_);
         EXPECT_VECTOR_EQ(root->sent_scroll_delta(), gfx::Vector2d());
         endTest();
         break;
     }
   }
 
   virtual void applyScrollAndScale(
@@ skipping 21 matching lines @@
 class LayerTreeHostScrollTestScrollZeroMaxScrollOffset
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollZeroMaxScrollOffset() {}
 
   virtual void beginTest() OVERRIDE {
     postSetNeedsCommitToMainThread();
   }
 
   virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    LayerImpl* root = impl->rootLayer();
+    LayerImpl* root = impl->active_tree()->root_layer();
     root->SetScrollable(true);
 
     root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     EXPECT_EQ(
         InputHandlerClient::ScrollStarted,
         root->TryScroll(
             gfx::PointF(0.0f, 1.0f),
             InputHandlerClient::Gesture));
 
     root->SetMaxScrollOffset(gfx::Vector2d(0, 0));
@@ skipping 14 matching lines @@
   }
 
   virtual void afterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostScrollTestScrollZeroMaxScrollOffset)
 
 
 }  // namespace
 }  // namespace cc