Revert "Make SingleThreadProxy a SchedulerClient"

cc/test/layer_tree_test.cc

 // Copyright 2011 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/test/layer_tree_test.h"
 
 #include "base/command_line.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_controller.h"
@@ skipping 294 matching lines @@
   virtual void DidCommit() OVERRIDE { test_hooks_->DidCommit(); }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     test_hooks_->DidCommitAndDrawFrame();
   }
 
   virtual void DidCompleteSwapBuffers() OVERRIDE {
     test_hooks_->DidCompleteSwapBuffers();
   }
 
+  virtual void ScheduleComposite() OVERRIDE {
+    test_hooks_->ScheduleComposite();
+  }
+
+  virtual void ScheduleAnimation() OVERRIDE {
+    test_hooks_->ScheduleAnimation();
+  }
+
   virtual void DidPostSwapBuffers() OVERRIDE {}
   virtual void DidAbortSwapBuffers() OVERRIDE {}
 
  private:
   explicit LayerTreeHostClientForTesting(TestHooks* test_hooks)
       : test_hooks_(test_hooks) {}
 
   TestHooks* test_hooks_;
 };
 
@@ skipping 54 matching lines @@
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
   TestHooks* test_hooks_;
   bool test_started_;
 };
 
 LayerTreeTest::LayerTreeTest()
     : beginning_(false),
       end_when_begin_returns_(false),
       timed_out_(false),
       scheduled_(false),
+      schedule_when_set_visible_true_(false),
       started_(false),
       ended_(false),
       delegating_renderer_(false),
       timeout_seconds_(0),
       weak_factory_(this) {
   main_thread_weak_ptr_ = weak_factory_.GetWeakPtr();
 
   // Tests should timeout quickly unless --cc-layer-tree-test-no-timeout was
   // specified (for running in a debugger).
   CommandLine* command_line = CommandLine::ForCurrentProcess();
@@ skipping 143 matching lines @@
   gfx::Size device_root_bounds = gfx::ToCeiledSize(
       gfx::ScaleSize(root_bounds, layer_tree_host_->device_scale_factor()));
   layer_tree_host_->SetViewportSize(device_root_bounds);
 }
 
 void LayerTreeTest::Timeout() {
   timed_out_ = true;
   EndTest();
 }
 
+void LayerTreeTest::ScheduleComposite() {
+  if (!started_ || scheduled_)
+    return;
+  scheduled_ = true;
+  main_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&LayerTreeTest::DispatchComposite, main_thread_weak_ptr_));
+}
+
 void LayerTreeTest::RealEndTest() {
   if (layer_tree_host_ && !timed_out_ &&
       proxy()->MainFrameWillHappenForTesting()) {
     main_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeTest::RealEndTest, main_thread_weak_ptr_));
     return;
   }
 
   base::MessageLoop::current()->Quit();
@@ skipping 32 matching lines @@
 
 void LayerTreeTest::DispatchSetNeedsRedrawRect(const gfx::Rect& damage_rect) {
   DCHECK(!proxy() || proxy()->IsMainThread());
 
   if (layer_tree_host_)
     layer_tree_host_->SetNeedsRedrawRect(damage_rect);
 }
 
 void LayerTreeTest::DispatchSetVisible(bool visible) {
   DCHECK(!proxy() || proxy()->IsMainThread());
-  if (layer_tree_host_)
-    layer_tree_host_->SetVisible(visible);
+
+  if (!layer_tree_host_)
+    return;
+
+  layer_tree_host_->SetVisible(visible);
+
+  // If the LTH is being made visible and a previous ScheduleComposite() was
+  // deferred because the LTH was not visible, re-schedule the composite now.
+  if (layer_tree_host_->visible() && schedule_when_set_visible_true_)
+    ScheduleComposite();
 }
 
 void LayerTreeTest::DispatchSetNextCommitForcesRedraw() {
   DCHECK(!proxy() || proxy()->IsMainThread());
 
   if (layer_tree_host_)
     layer_tree_host_->SetNextCommitForcesRedraw();
 }
 
+void LayerTreeTest::DispatchComposite() {
+  scheduled_ = false;
+
+  if (!layer_tree_host_)
+    return;
+
+  // If the LTH is not visible, defer the composite until the LTH is made
+  // visible.
+  if (!layer_tree_host_->visible()) {
+    schedule_when_set_visible_true_ = true;
+    return;
+  }
+
+  schedule_when_set_visible_true_ = false;
+  base::TimeTicks now = gfx::FrameTime::Now();
+  layer_tree_host_->Composite(now);
+}
+
 void LayerTreeTest::RunTest(bool threaded,
                             bool delegating_renderer,
                             bool impl_side_painting) {
   if (threaded) {
     impl_thread_.reset(new base::Thread("Compositor"));
     ASSERT_TRUE(impl_thread_->Start());
   }
 
   main_task_runner_ = base::MessageLoopProxy::current();
 
@@ skipping 73 matching lines @@
   return -1;
 }
 
 void LayerTreeTest::DestroyLayerTreeHost() {
   if (layer_tree_host_ && layer_tree_host_->root_layer())
     layer_tree_host_->root_layer()->SetLayerTreeHost(NULL);
   layer_tree_host_.reset();
 }
 
 }  // namespace cc