cc: Control activation from the Scheduler

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 19 matching lines @@
 TestHooks::TestHooks() {}
 
 TestHooks::~TestHooks() {}
 
 bool TestHooks::PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                       LayerTreeHostImpl::FrameData* frame_data,
                                       bool result) {
   return true;
 }
 
-bool TestHooks::CanActivatePendingTree(LayerTreeHostImpl* host_impl) {
-  return true;
-}
+class LayerTreeHostImplClientInterposer : public LayerTreeHostImplClient {
+ public:
+  LayerTreeHostImplClientInterposer(LayerTreeHostImplClient* client)
+  : client_(client),
+    block_notify_ready_to_activate_(false),
+    notify_ready_to_activate_was_blocked_(false) { }
 
-bool TestHooks::CanActivatePendingTreeIfNeeded(LayerTreeHostImpl* host_impl) {
-  return true;
-}
+  // LayerTreeHostImplClient interface
+  virtual void DidTryInitializeRendererOnImplThread(
+      bool success,
+      scoped_refptr<ContextProvider> offscreen_context_provider) OVERRIDE {
+    client_->DidTryInitializeRendererOnImplThread(
+        success, offscreen_context_provider);
+  }
+
+  virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE {
+    client_->DidLoseOutputSurfaceOnImplThread();
+  }
+
+  virtual void OnSwapBuffersCompleteOnImplThread() OVERRIDE {
+    client_->OnSwapBuffersCompleteOnImplThread();
+  }
+
+  virtual void BeginFrameOnImplThread(const BeginFrameArgs& args) OVERRIDE {
+    client_->BeginFrameOnImplThread(args);
+  }
+
+  virtual void OnCanDrawStateChanged(bool can_draw) OVERRIDE {
+    client_->OnCanDrawStateChanged(can_draw);
+  }
+
+  virtual void NotifyReadyToActivate() OVERRIDE {
+    if (block_notify_ready_to_activate_)
+      notify_ready_to_activate_was_blocked_ = true;
+    else
+      client_->NotifyReadyToActivate();
+  }
+
+  virtual void SetNeedsRedrawOnImplThread() OVERRIDE {
+    client_->SetNeedsRedrawOnImplThread();
+  }
+
+  virtual void SetNeedsRedrawRectOnImplThread(gfx::Rect damage_rect) OVERRIDE {
+    client_->SetNeedsRedrawRectOnImplThread(damage_rect);
+  }
+
+  virtual void DidInitializeVisibleTileOnImplThread() OVERRIDE {
+    client_->DidInitializeVisibleTileOnImplThread();
+  }
+
+  virtual void SetNeedsCommitOnImplThread() OVERRIDE {
+    client_->SetNeedsCommitOnImplThread();
+  }
+
+  virtual void PostAnimationEventsToMainThreadOnImplThread(
+      scoped_ptr<AnimationEventsVector> events,
+      base::Time wall_clock_time) OVERRIDE {
+    client_->PostAnimationEventsToMainThreadOnImplThread(
+        events.Pass(), wall_clock_time);
+  }
+
+  virtual bool ReduceContentsTextureMemoryOnImplThread(
+      size_t limit_bytes,
+      int priority_cutoff) OVERRIDE {
+    return client_->ReduceContentsTextureMemoryOnImplThread(
+        limit_bytes, priority_cutoff);
+  }
+
+  virtual void ReduceWastedContentsTextureMemoryOnImplThread() {
+    client_->ReduceWastedContentsTextureMemoryOnImplThread();
+  }
+
+  virtual void SendManagedMemoryStats() OVERRIDE {
+    client_->SendManagedMemoryStats();
+  }
+
+  virtual bool IsInsideDraw() OVERRIDE {
+    return client_->IsInsideDraw();
+  }
+
+  virtual void RenewTreePriority() OVERRIDE {
+    client_->RenewTreePriority();
+  }
+
+  virtual void RequestScrollbarAnimationOnImplThread(base::TimeDelta delay)
+      OVERRIDE {
+    client_->RequestScrollbarAnimationOnImplThread(delay);
+  }
+
+  virtual void DidActivatePendingTree() OVERRIDE  {
+    client_->DidActivatePendingTree();
+  }
+
+  // Test hooks
+  void BlockNotifyReadyToActivate(bool block) {
+    block_notify_ready_to_activate_ = block;
+    if (!block && notify_ready_to_activate_was_blocked_) {
+      NotifyReadyToActivate();
+    }
+  }
+
+ private:
+  LayerTreeHostImplClient* client_;
+  bool block_notify_ready_to_activate_;
+  bool notify_ready_to_activate_was_blocked_;
+};
+
 
 // Adapts LayerTreeHostImpl for test. Runs real code, then invokes test hooks.
 class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
  public:
   static scoped_ptr<LayerTreeHostImplForTesting> Create(
       TestHooks* test_hooks,
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* host_impl_client,
       Proxy* proxy,
       RenderingStatsInstrumentation* stats_instrumentation) {
@@ skipping 11 matching lines @@
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* host_impl_client,
       Proxy* proxy,
       RenderingStatsInstrumentation* stats_instrumentation)
       : LayerTreeHostImpl(settings,
                           host_impl_client,
                           proxy,
                           stats_instrumentation),
         test_hooks_(test_hooks) {}
 
+  virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE {
+    test_hooks_->WillBeginFrameOnThread(this, args);
+    LayerTreeHostImpl::BeginFrame(args);
+  }
+
   virtual void BeginCommit() OVERRIDE {
     LayerTreeHostImpl::BeginCommit();
     test_hooks_->BeginCommitOnThread(this);
   }
 
   virtual void CommitComplete() OVERRIDE {
     LayerTreeHostImpl::CommitComplete();
     test_hooks_->CommitCompleteOnThread(this);
 
     if (!settings().impl_side_painting) {
@@ skipping 19 matching lines @@
     bool result = LayerTreeHostImpl::SwapBuffers(frame);
     test_hooks_->SwapBuffersOnThread(this, result);
     return result;
   }
 
   virtual void OnSwapBuffersComplete(const CompositorFrameAck* ack) OVERRIDE {
     LayerTreeHostImpl::OnSwapBuffersComplete(ack);
     test_hooks_->SwapBuffersCompleteOnThread(this);
   }
 
-  virtual void ActivatePendingTreeIfNeeded() OVERRIDE {
-    if (!pending_tree())
-      return;
-
-    if (!test_hooks_->CanActivatePendingTreeIfNeeded(this))
-      return;
-
-    LayerTreeHostImpl::ActivatePendingTreeIfNeeded();
-  }
-
   virtual void ActivatePendingTree() OVERRIDE {
-    if (!test_hooks_->CanActivatePendingTree(this))
-      return;
-
     test_hooks_->WillActivateTreeOnThread(this);
     LayerTreeHostImpl::ActivatePendingTree();
     DCHECK(!pending_tree());
     test_hooks_->DidActivateTreeOnThread(this);
   }
 
   virtual bool InitializeRenderer(scoped_ptr<OutputSurface> output_surface)
       OVERRIDE {
     bool success = LayerTreeHostImpl::InitializeRenderer(output_surface.Pass());
     test_hooks_->InitializedRendererOnThread(this, success);
@@ skipping 33 matching lines @@
  private:
   TestHooks* test_hooks_;
 };
 
 // Adapts LayerTreeHost for test. Injects LayerTreeHostImplForTesting.
 class LayerTreeHostForTesting : public cc::LayerTreeHost {
  public:
   static scoped_ptr<LayerTreeHostForTesting> Create(
       TestHooks* test_hooks,
       cc::LayerTreeHostClient* host_client,
+      scoped_ptr<LayerTreeHostImplClientInterposer> &impl_client_interposer,
       const cc::LayerTreeSettings& settings,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
     scoped_ptr<LayerTreeHostForTesting> layer_tree_host(
-        new LayerTreeHostForTesting(test_hooks, host_client, settings));
+        new LayerTreeHostForTesting(
+            test_hooks, host_client, impl_client_interposer, settings));
     bool success = layer_tree_host->Initialize(impl_task_runner);
     EXPECT_TRUE(success);
     return layer_tree_host.Pass();
   }
 
   virtual scoped_ptr<cc::LayerTreeHostImpl> CreateLayerTreeHostImpl(
       cc::LayerTreeHostImplClient* host_impl_client) OVERRIDE {
+    impl_client_interposer_.reset(
+        new LayerTreeHostImplClientInterposer(host_impl_client));

[brianderson, 2013/08/24 02:33:29]

I'm trying to think of a better way to do this... any ideas? Or is this
acceptable?

[enne (OOO), 2013/08/26 21:55:13]

This seems fine to me.  It's unfortunate that because of the way other code is
structured you have to do this with a has-a relationship instead of an is-a
(where you could inherit all the functions you are just thunking through).  That
said, you keep all of the complication in testing code, so this feels like a
pretty elegant solution to me.  :)

Bikeshedding, I would maybe name it Proxy instead of Interposer, since for me
that's a more common name for its job: it sits in front of the real client and
forwards requests to it.

     return LayerTreeHostImplForTesting::Create(
         test_hooks_,
         settings(),
-        host_impl_client,
+        impl_client_interposer_.get(),
         proxy(),
         rendering_stats_instrumentation()).PassAs<cc::LayerTreeHostImpl>();
   }
 
   virtual void SetNeedsCommit() OVERRIDE {
     if (!test_started_)
       return;
     LayerTreeHost::SetNeedsCommit();
   }
 
   void set_test_started(bool started) { test_started_ = started; }
 
   virtual void DidDeferCommit() OVERRIDE {
     test_hooks_->DidDeferCommit();
   }
 
  private:
-  LayerTreeHostForTesting(TestHooks* test_hooks,
-                          cc::LayerTreeHostClient* client,
-                          const cc::LayerTreeSettings& settings)
-      : LayerTreeHost(client, settings),
-        test_hooks_(test_hooks),
-        test_started_(false) {}
+  LayerTreeHostForTesting(
+      TestHooks* test_hooks,
+      cc::LayerTreeHostClient* client,
+      scoped_ptr<LayerTreeHostImplClientInterposer> &impl_client_interposer,
+      const cc::LayerTreeSettings& settings)
+  : LayerTreeHost(client, settings),
+    test_hooks_(test_hooks),
+    impl_client_interposer_(impl_client_interposer),
+    test_started_(false) {}
 
   TestHooks* test_hooks_;
+  scoped_ptr<LayerTreeHostImplClientInterposer> &impl_client_interposer_;
   bool test_started_;
 };
 
 // Implementation of LayerTreeHost callback interface.
 class LayerTreeHostClientForTesting : public LayerTreeHostClient {
  public:
   static scoped_ptr<LayerTreeHostClientForTesting> Create(
       TestHooks* test_hooks) {
     return make_scoped_ptr(new LayerTreeHostClientForTesting(test_hooks));
   }
@@ skipping 163 matching lines @@
                  visible));
 }
 
 void LayerTreeTest::DoBeginTest() {
   client_ = LayerTreeHostClientForTesting::Create(this);
 
   DCHECK(!impl_thread_ || impl_thread_->message_loop_proxy().get());
   layer_tree_host_ = LayerTreeHostForTesting::Create(
       this,
       client_.get(),
+      impl_client_,
       settings_,
       impl_thread_ ? impl_thread_->message_loop_proxy() : NULL);
   ASSERT_TRUE(layer_tree_host_);
 
   started_ = true;
   beginning_ = true;
   SetupTree();
   layer_tree_host_->SetLayerTreeHostClientReady();
   BeginTest();
   beginning_ = false;
@@ skipping 177 matching lines @@
 
   ASSERT_FALSE(layer_tree_host_.get());
   client_.reset();
   if (timed_out_) {
     FAIL() << "Test timed out";
     return;
   }
   AfterTest();
 }
 
+void LayerTreeTest::BlockNotifyReadyToActivate(bool block) {
+  impl_client_->BlockNotifyReadyToActivate(block);
+}
+
 scoped_ptr<OutputSurface> LayerTreeTest::CreateOutputSurface(bool fallback) {
   scoped_ptr<FakeOutputSurface> output_surface;
   if (delegating_renderer_)
     output_surface = FakeOutputSurface::CreateDelegating3d();
   else
     output_surface = FakeOutputSurface::Create3d();
   output_surface_ = output_surface.get();
   return output_surface.PassAs<OutputSurface>();
 }
 
@@ skipping 10 matching lines @@
 
 scoped_refptr<cc::ContextProvider> LayerTreeTest::
     OffscreenContextProviderForCompositorThread() {
   if (!compositor_thread_contexts_.get() ||
       compositor_thread_contexts_->DestroyedOnMainThread())
     compositor_thread_contexts_ = TestContextProvider::Create();
   return compositor_thread_contexts_;
 }
 
 }  // namespace cc