cc: Clean up LayerTreeTest and TestHooks.

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 "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/element_animations.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/switches.h"
 #include "cc/blimp/image_serialization_processor.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/proto/compositor_message_to_impl.pb.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/fake_external_begin_frame_source.h"
 #include "cc/test/fake_image_serialization_processor.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
-#include "cc/test/remote_channel_impl_for_test.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_gpu_memory_buffer_manager.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/test/threaded_channel_for_test.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_host_single_thread_client.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/proxy_impl.h"
 #include "cc/trees/proxy_main.h"
+#include "cc/trees/remote_channel_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/threaded_channel.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
 
 void CreateVirtualViewportLayers(Layer* root_layer,
                                  scoped_refptr<Layer> outer_scroll_layer,
                                  const gfx::Size& inner_bounds,
@@ skipping 31 matching lines @@
                                  const gfx::Size& scroll_bounds,
                                  LayerTreeHost* host) {
   scoped_refptr<Layer> outer_viewport_scroll_layer = Layer::Create();
 
   outer_viewport_scroll_layer->SetBounds(scroll_bounds);
   outer_viewport_scroll_layer->SetIsDrawable(true);
   CreateVirtualViewportLayers(root_layer, outer_viewport_scroll_layer,
                               inner_bounds, outer_bounds, host);
 }
 
-// Creates a SingleThreadProxy that notifies the supplied |test_hooks| of
-// various actions.
-class SingleThreadProxyForTest : public SingleThreadProxy {
- public:
-  static std::unique_ptr<Proxy> Create(
-      TestHooks* test_hooks,
-      LayerTreeHost* host,
-      LayerTreeHostSingleThreadClient* client,
-      TaskRunnerProvider* task_runner_provider) {
-    return base::WrapUnique(new SingleThreadProxyForTest(
-        test_hooks, host, client, task_runner_provider));
-  }
-
-  ~SingleThreadProxyForTest() override {}
-
- private:
-  SingleThreadProxyForTest(TestHooks* test_hooks,
-                           LayerTreeHost* host,
-                           LayerTreeHostSingleThreadClient* client,
-                           TaskRunnerProvider* task_runner_provider)
-      : SingleThreadProxy(host, client, task_runner_provider),
-        test_hooks_(test_hooks) {}
-
-  void ScheduledActionSendBeginMainFrame(const BeginFrameArgs& args) override {
-    test_hooks_->ScheduledActionWillSendBeginMainFrame();
-    SingleThreadProxy::ScheduledActionSendBeginMainFrame(args);
-    test_hooks_->ScheduledActionSendBeginMainFrame();
-  }
-
-  DrawResult ScheduledActionDrawAndSwapIfPossible() override {
-    DrawResult result =
-        SingleThreadProxy::ScheduledActionDrawAndSwapIfPossible();
-    test_hooks_->ScheduledActionDrawAndSwapIfPossible();
-    return result;
-  }
-
-  void ScheduledActionCommit() override {
-    SingleThreadProxy::ScheduledActionCommit();
-    test_hooks_->ScheduledActionCommit();
-  }
-
-  void ScheduledActionBeginOutputSurfaceCreation() override {
-    SingleThreadProxy::ScheduledActionBeginOutputSurfaceCreation();
-    test_hooks_->ScheduledActionBeginOutputSurfaceCreation();
-  }
-
-  void ScheduledActionPrepareTiles() override {
-    SingleThreadProxy::ScheduledActionPrepareTiles();
-    test_hooks_->ScheduledActionPrepareTiles();
-  }
-
-  void ScheduledActionInvalidateOutputSurface() override {
-    SingleThreadProxy::ScheduledActionInvalidateOutputSurface();
-    test_hooks_->ScheduledActionInvalidateOutputSurface();
-  }
-
-  void SendBeginMainFrameNotExpectedSoon() override {
-    SingleThreadProxy::SendBeginMainFrameNotExpectedSoon();
-    test_hooks_->SendBeginMainFrameNotExpectedSoon();
-  }
-
-  TestHooks* test_hooks_;
-};
-
 // Adapts LayerTreeHostImpl for test. Runs real code, then invokes test hooks.
 class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
  public:
   static std::unique_ptr<LayerTreeHostImplForTesting> Create(
       TestHooks* test_hooks,
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* host_impl_client,
       TaskRunnerProvider* task_runner_provider,
       SharedBitmapManager* shared_bitmap_manager,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
@@ skipping 43 matching lines @@
   void DidFinishImplFrame() override {
     LayerTreeHostImpl::DidFinishImplFrame();
     test_hooks_->DidFinishImplFrameOnThread(this);
   }
 
   void BeginMainFrameAborted(CommitEarlyOutReason reason) override {
     LayerTreeHostImpl::BeginMainFrameAborted(reason);
     test_hooks_->BeginMainFrameAbortedOnThread(this, reason);
   }
 
+  void BeginMainFrameCompleted() override {
+    LayerTreeHostImpl::BeginMainFrameCompleted();
+    test_hooks_->BeginMainFrameCompletedOnThread(this);
+  }
+
   void BeginCommit() override {
     LayerTreeHostImpl::BeginCommit();
     test_hooks_->BeginCommitOnThread(this);
   }
 
   void CommitComplete() override {
     test_hooks_->WillCommitCompleteOnThread(this);
     LayerTreeHostImpl::CommitComplete();
     test_hooks_->CommitCompleteOnThread(this);
   }
 
   bool PrepareTiles() override {
-    test_hooks_->WillPrepareTiles(this);
+    test_hooks_->WillPrepareTilesOnThread(this);
     return LayerTreeHostImpl::PrepareTiles();
   }
 
   DrawResult PrepareToDraw(FrameData* frame) override {
     DrawResult draw_result = LayerTreeHostImpl::PrepareToDraw(frame);
     return test_hooks_->PrepareToDrawOnThread(this, frame, draw_result);
   }
 
   void DrawLayers(FrameData* frame) override {
     LayerTreeHostImpl::DrawLayers(frame);
@@ skipping 141 matching lines @@
   }
 
   void DidCompleteSwapBuffers() override {
     test_hooks_->DidCompleteSwapBuffers();
   }
 
   void DidPostSwapBuffers() override {}
   void DidAbortSwapBuffers() override {}
   void RequestScheduleComposite() override { test_hooks_->ScheduleComposite(); }
   void DidCompletePageScaleAnimation() override {}
-  void BeginMainFrameNotExpectedSoon() override {}
+  void BeginMainFrameNotExpectedSoon() override {
+    test_hooks_->BeginMainFrameNotExpectedSoon();
+  }
 
  private:
   explicit LayerTreeHostClientForTesting(TestHooks* test_hooks)
       : test_hooks_(test_hooks) {}
 
   TestHooks* test_hooks_;
 };
 
 // Adapts LayerTreeHost for test. Injects LayerTreeHostImplForTesting.
 class LayerTreeHostForTesting : public LayerTreeHost {
@@ skipping 21 matching lines @@
 
     params.animation_host =
         AnimationHost::CreateForTesting(ThreadInstance::MAIN);
     std::unique_ptr<LayerTreeHostForTesting> layer_tree_host(
         new LayerTreeHostForTesting(test_hooks, &params, mode));
     std::unique_ptr<TaskRunnerProvider> task_runner_provider =
         TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
     std::unique_ptr<Proxy> proxy;
     switch (mode) {
       case CompositorMode::SINGLE_THREADED:
-        proxy = SingleThreadProxyForTest::Create(test_hooks,
-                                                 layer_tree_host.get(), client,
-                                                 task_runner_provider.get());
+        proxy = SingleThreadProxy::Create(layer_tree_host.get(), client,
+                                          task_runner_provider.get());
         break;
       case CompositorMode::THREADED:
         DCHECK(impl_task_runner.get());
-        proxy = ProxyMainForTest::CreateThreaded(
-            test_hooks, layer_tree_host.get(), task_runner_provider.get());
+        proxy = ProxyMain::CreateThreaded(layer_tree_host.get(),
+                                          task_runner_provider.get());
         break;
       case CompositorMode::REMOTE:
         DCHECK(!external_begin_frame_source);
         // The Remote LayerTreeHost on the client has the impl task runner.
         if (task_runner_provider->HasImplThread()) {
-          proxy = RemoteChannelImplForTest::Create(
-              test_hooks, layer_tree_host.get(), remote_proto_channel,
+          proxy = base::MakeUnique<RemoteChannelImpl>(
+              layer_tree_host.get(), remote_proto_channel,
               task_runner_provider.get());
         } else {
-          proxy = ProxyMainForTest::CreateRemote(
-              test_hooks, remote_proto_channel, layer_tree_host.get(),
-              task_runner_provider.get());
+          proxy = ProxyMain::CreateRemote(remote_proto_channel,
+                                          layer_tree_host.get(),
+                                          task_runner_provider.get());
 
           // The LayerTreeHost on the server will never have an output surface.
           // Set output_surface_lost_ to false by default.
           layer_tree_host->SetOutputSurfaceLostForTesting(false);
         }
         break;
     }
     layer_tree_host->InitializeForTesting(
         std::move(task_runner_provider), std::move(proxy),
         std::move(external_begin_frame_source));
     return layer_tree_host;
   }
 
   std::unique_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
       LayerTreeHostImplClient* host_impl_client) override {
     return LayerTreeHostImplForTesting::Create(
         test_hooks_, settings(), host_impl_client, task_runner_provider(),
         shared_bitmap_manager(), gpu_memory_buffer_manager(),
         task_graph_runner(), rendering_stats_instrumentation());
   }
 
   void SetNeedsCommit() override {
     if (!test_started_)
       return;
+    test_hooks_->DidSetNeedsCommit();
     LayerTreeHost::SetNeedsCommit();
   }
 
   void SetNeedsUpdateLayers() override {
     if (!test_started_)
       return;
+    test_hooks_->DidSetNeedsUpdateLayers();
     LayerTreeHost::SetNeedsUpdateLayers();
   }
 
   void set_test_started(bool started) { test_started_ = started; }
 
  private:
   LayerTreeHostForTesting(TestHooks* test_hooks,
                           LayerTreeHost::InitParams* params,
                           CompositorMode mode)
       : LayerTreeHost(params, mode),
@@ skipping 491 matching lines @@
   return layer_tree_host_.get();
 }
 
 LayerTreeHost* LayerTreeTest::remote_client_layer_tree_host() {
   DCHECK(!task_runner_provider() || task_runner_provider()->IsMainThread() ||
          task_runner_provider()->IsMainThreadBlocked());
   DCHECK(IsRemoteTest());
   return remote_client_layer_tree_host_.get();
 }
 
-ProxyMainForTest* LayerTreeTest::GetProxyMainForTest() const {
+ProxyMain* LayerTreeTest::GetProxyMain() const {
   DCHECK(HasImplThread());
-  return static_cast<ProxyMainForTest*>(proxy());
-}
-
-ProxyImplForTest* LayerTreeTest::GetProxyImplForTest() const {
-  DCHECK(HasImplThread());
-
-  if (IsRemoteTest()) {
-    return GetRemoteChannelImplForTest()->proxy_impl_for_test();
-  }
-
-  ProxyImplForTest* proxy_impl_for_test =
-      GetThreadedChannelForTest()->proxy_impl_for_test();
-
-  // We check for null ProxyImpl since ProxyImpl exists in the ThreadedChannel
-  // only after it is initialized.
-  DCHECK(proxy_impl_for_test);
-  return proxy_impl_for_test;
-}
-
-ThreadedChannelForTest* LayerTreeTest::GetThreadedChannelForTest() const {
-  DCHECK(mode_ == CompositorMode::THREADED);
-
-  return GetProxyMainForTest()->threaded_channel_for_test();
-}
-
-RemoteChannelImplForTest* LayerTreeTest::GetRemoteChannelImplForTest() const {
-  DCHECK(IsRemoteTest());
-  DCHECK(remote_client_layer_tree_host_);
-
-  return static_cast<RemoteChannelImplForTest*>(
-      remote_client_layer_tree_host_->proxy());
+  return static_cast<ProxyMain*>(proxy());
 }
 
 }  // namespace cc