cc: Control activation from the Scheduler

cc/trees/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/trees/layer_tree_host.h"
 
 #include "base/memory/weak_ptr.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 704 matching lines @@
   }
 };
 
 class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
  public:
   ImplSidePaintingScrollTestSimple()
       : initial_scroll_(10, 20),
         main_thread_scroll_(40, 5),
         impl_thread_scroll1_(2, -1),
         impl_thread_scroll2_(-3, 10),
-        num_scrolls_(0),
-        can_activate_(true) {}
+        num_scrolls_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->root_layer()->SetScrollable(true);
     layer_tree_host()->root_layer()
         ->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     layer_tree_host()->root_layer()->SetScrollOffset(initial_scroll_);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void Layout() OVERRIDE {
     Layer* root = layer_tree_host()->root_layer();
     if (!layer_tree_host()->source_frame_number()) {
       EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
     } else {
       EXPECT_VECTOR_EQ(root->scroll_offset(),
                        initial_scroll_ + impl_thread_scroll1_);
 
       // Pretend like Javascript updated the scroll position itself with a
       // change of main_thread_scroll.
       root->SetScrollOffset(initial_scroll_ + main_thread_scroll_ +
                             impl_thread_scroll1_);
     }
   }
 
-  virtual bool CanActivatePendingTree(LayerTreeHostImpl* impl) OVERRIDE {
-    return can_activate_;
-  }
-
-  virtual bool CanActivatePendingTreeIfNeeded(LayerTreeHostImpl* impl)
-      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->active_tree()->source_frame_number() == 0)
       impl->SetNeedsRedraw();
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     ImplSidePaintingScrollTest::DrawLayersOnThread(impl);
 
     LayerImpl* root = impl->active_tree()->root_layer();
     LayerImpl* pending_root =
         impl->active_tree()->FindPendingTreeLayerById(root->id());
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         if (!impl->pending_tree()) {
-          can_activate_ = false;
+          impl->BlockNotifyReadyToActivateForTesting(true);
           EXPECT_VECTOR_EQ(root->ScrollDelta(), gfx::Vector2d());
           root->ScrollBy(impl_thread_scroll1_);
 
           EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
           EXPECT_VECTOR_EQ(root->ScrollDelta(), 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;
+          impl->BlockNotifyReadyToActivateForTesting(false);
           ASSERT_TRUE(pending_root);
           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->ScrollDelta(),
                            impl_thread_scroll1_ + impl_thread_scroll2_);
           EXPECT_VECTOR_EQ(root->sent_scroll_delta(), impl_thread_scroll1_);
 
           EXPECT_VECTOR_EQ(
@@ skipping 21 matching lines @@
   }
 
   virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_scrolls_); }
 
  private:
   gfx::Vector2d initial_scroll_;
   gfx::Vector2d main_thread_scroll_;
   gfx::Vector2d impl_thread_scroll1_;
   gfx::Vector2d impl_thread_scroll2_;
   int num_scrolls_;
-  bool can_activate_;
 };
 
 MULTI_THREAD_TEST_F(ImplSidePaintingScrollTestSimple);
 
 // This test makes sure that layers pick up scrolls that occur between
 // beginning a commit and finishing a commit (aka scroll deltas not
 // included in sent scroll delta) still apply to layers that don't
 // push properties.
 class ImplSidePaintingScrollTestImplOnlyScroll
     : public ImplSidePaintingScrollTest {
@@ skipping 285 matching lines @@
     RunTest(true, false, false);
 }
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyWholeTree) {
     scroll_destroy_whole_tree_ = true;
     RunTest(true, false, false);
 }
 
 }  // namespace
 }  // namespace cc