cc: Make LayerTreeTests use a DelegatingRenderer and Display.

cc/test/layer_tree_test.cc

Index: cc/test/layer_tree_test.cc
diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index 49d4a70f5514022309333aae771db3a9817a3c3a..5f64fc2c3881949c67fd89e73b002d74a9c19e2d 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc
@@ -28,9 +28,8 @@
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/test_context_provider.h"
-#include "cc/test/test_gpu_memory_buffer_manager.h"
+#include "cc/test/test_delegating_output_surface.h"
 #include "cc/test/test_shared_bitmap_manager.h"
-#include "cc/test/test_task_graph_runner.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"
@@ -183,15 +182,6 @@ class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
     test_hooks_->DrawLayersOnThread(this);
   }
 
-  void DidSwapBuffersComplete() override {
-    LayerTreeHostImpl::DidSwapBuffersComplete();
-    test_hooks_->SwapBuffersCompleteOnThread();
-  }
-
-  void ReclaimResources(const ReturnedResourceArray& resources) override {
-    LayerTreeHostImpl::ReclaimResources(resources);
-  }
-
   void NotifyReadyToActivate() override {
     if (block_notify_ready_to_activate_for_testing_) {
       notify_ready_to_activate_was_blocked_ = true;
@@ -441,19 +431,34 @@ class LayerTreeHostForTesting : public LayerTreeHost {
   bool test_started_;
 };
 
+class LayerTreeTestDelegatingOutputSurfaceClient
+    : public TestDelegatingOutputSurfaceClient {
+ public:
+  explicit LayerTreeTestDelegatingOutputSurfaceClient(TestHooks* hooks)
+      : hooks_(hooks) {}
+
+  // TestDelegatingOutputSurfaceClient implementation.
+  void DisplayReceivedCompositorFrame(const CompositorFrame& frame) override {
+    hooks_->DisplayReceivedCompositorFrameOnThread(frame);
+  }
+  void DisplayWillDrawAndSwap(bool will_draw_and_swap,
+                              const RenderPassList& render_passes) override {
+    hooks_->DisplayWillDrawAndSwapOnThread(will_draw_and_swap, render_passes);
+  }
+  void DisplayDidDrawAndSwap() override {
+    hooks_->DisplayDidDrawAndSwapOnThread();
+  }
+
+ private:
+  TestHooks* hooks_;
+};
+
 LayerTreeTest::LayerTreeTest()
-    : external_begin_frame_source_(nullptr),
-      remote_proto_channel_bridge_(this),
+    : remote_proto_channel_bridge_(this),
       image_serialization_processor_(
           base::WrapUnique(new FakeImageSerializationProcessor)),
-      beginning_(false),
-      end_when_begin_returns_(false),
-      timed_out_(false),
-      scheduled_(false),
-      started_(false),
-      ended_(false),
-      delegating_renderer_(false),
-      timeout_seconds_(0),
+      delegating_output_surface_client_(
+          new LayerTreeTestDelegatingOutputSurfaceClient(this)),
       weak_factory_(this) {
   main_thread_weak_ptr_ = weak_factory_.GetWeakPtr();
 
@@ -600,16 +605,6 @@ void LayerTreeTest::PostNextCommitWaitsForActivationToMainThread() {
                  main_thread_weak_ptr_));
 }
 
-void LayerTreeTest::SetOutputSurfaceOnLayerTreeHost(
-    std::unique_ptr<OutputSurface> output_surface) {
-  if (IsRemoteTest()) {
-    DCHECK(remote_client_layer_tree_host_);
-    remote_client_layer_tree_host_->SetOutputSurface(std::move(output_surface));
-  } else {
-    layer_tree_host_->SetOutputSurface(std::move(output_surface));
-  }
-}
-
 std::unique_ptr<OutputSurface>
 LayerTreeTest::ReleaseOutputSurfaceOnLayerTreeHost() {
   if (IsRemoteTest()) {
@@ -635,14 +630,6 @@ void LayerTreeTest::WillBeginTest() {
 void LayerTreeTest::DoBeginTest() {
   client_ = LayerTreeHostClientForTesting::Create(this);
 
-  std::unique_ptr<FakeExternalBeginFrameSource> external_begin_frame_source;
-  if (settings_.use_external_begin_frame_source) {
-    DCHECK(!IsRemoteTest());
-    external_begin_frame_source.reset(new FakeExternalBeginFrameSource(
-        settings_.renderer_settings.refresh_rate, true));
-    external_begin_frame_source_ = external_begin_frame_source.get();
-  }
-
   DCHECK(!impl_thread_ || impl_thread_->task_runner().get());
 
   if (IsRemoteTest()) {
@@ -650,8 +637,7 @@ void LayerTreeTest::DoBeginTest() {
     layer_tree_host_ = LayerTreeHostForTesting::Create(
         this, mode_, client_.get(), &remote_proto_channel_bridge_.channel_main,
         nullptr, nullptr, task_graph_runner_.get(), settings_,
-        base::ThreadTaskRunnerHandle::Get(), nullptr,
-        std::move(external_begin_frame_source),
+        base::ThreadTaskRunnerHandle::Get(), nullptr, nullptr,
         image_serialization_processor_.get());
     DCHECK(remote_proto_channel_bridge_.channel_main.HasReceiver());
   } else {
@@ -659,8 +645,7 @@ void LayerTreeTest::DoBeginTest() {
         this, mode_, client_.get(), nullptr, shared_bitmap_manager_.get(),
         gpu_memory_buffer_manager_.get(), task_graph_runner_.get(), settings_,
         base::ThreadTaskRunnerHandle::Get(),
-        impl_thread_ ? impl_thread_->task_runner() : NULL,
-        std::move(external_begin_frame_source),
+        impl_thread_ ? impl_thread_->task_runner() : nullptr, nullptr,
         image_serialization_processor_.get());
   }
 
@@ -828,7 +813,11 @@ void LayerTreeTest::RunTest(CompositorMode mode, bool delegating_renderer) {
   settings_.verify_transform_tree_calculations = true;
   settings_.renderer_settings.buffer_to_texture_target_map =
       DefaultBufferToTextureTargetMapForTesting();
+  // The TestDelegatingOutputSurface will provide a BeginFrameSource.
+  settings_.use_output_surface_begin_frame_source = true;
   InitializeSettings(&settings_);
+  DCHECK(settings_.use_output_surface_begin_frame_source);
+  DCHECK(!settings_.use_external_begin_frame_source);
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
@@ -849,22 +838,46 @@ void LayerTreeTest::RunTest(CompositorMode mode, bool delegating_renderer) {
 }
 
 void LayerTreeTest::RequestNewOutputSurface() {
-  if (settings_.use_external_begin_frame_source &&
-      settings_.wait_for_beginframe_interval) {
-    DCHECK(external_begin_frame_source_);
+  scoped_refptr<TestContextProvider> shared_context_provider =
+      TestContextProvider::Create();
+  scoped_refptr<TestContextProvider> worker_context_provider =
+      TestContextProvider::CreateWorker();
+
+  auto delegating_output_surface = CreateDelegatingOutputSurface(
+      std::move(shared_context_provider), std::move(worker_context_provider));
+  delegating_output_surface->SetClient(delegating_output_surface_client_.get());
+
+  if (IsRemoteTest()) {
+    DCHECK(remote_client_layer_tree_host_);
+    remote_client_layer_tree_host_->SetOutputSurface(
+        std::move(delegating_output_surface));
+  } else {
+    layer_tree_host_->SetOutputSurface(std::move(delegating_output_surface));
   }
-  SetOutputSurfaceOnLayerTreeHost(CreateOutputSurface());
 }
 
-std::unique_ptr<OutputSurface> LayerTreeTest::CreateOutputSurface() {
-  if (delegating_renderer_)
-    return FakeOutputSurface::CreateDelegating3d();
+std::unique_ptr<TestDelegatingOutputSurface>
+LayerTreeTest::CreateDelegatingOutputSurface(
+    scoped_refptr<ContextProvider> compositor_context_provider,
+    scoped_refptr<ContextProvider> worker_context_provider) {
+  bool synchronous_composite =
+      !HasImplThread() &&
+      !layer_tree_host()->settings().single_thread_proxy_scheduler;
+  // Disable reclaim resources by default to act like the Display lives
+  // out-of-process.
+  bool force_disable_reclaim_resources = true;
+  return base::MakeUnique<TestDelegatingOutputSurface>(
+      compositor_context_provider, std::move(worker_context_provider),
+      CreateDisplayOutputSurface(compositor_context_provider),
+      shared_bitmap_manager(), gpu_memory_buffer_manager(),
+      layer_tree_host()->settings().renderer_settings, ImplThreadTaskRunner(),
+      synchronous_composite, force_disable_reclaim_resources);
+}
 
-  // Make a worker context in a non-delegating OutputSurface. This is an
-  // exceptional situation for these tests as they put a non-delegating
-  // OutputSurface into the LayerTreeHost.
-  return FakeOutputSurface::Create3d(TestContextProvider::Create(),
-                                     TestContextProvider::CreateWorker());
+std::unique_ptr<OutputSurface> LayerTreeTest::CreateDisplayOutputSurface(
+    scoped_refptr<ContextProvider> compositor_context_provider) {
+  // By default the Display shares a context with the LayerTreeHostImpl.
+  return FakeOutputSurface::Create3d(std::move(compositor_context_provider));
 }
 
 void LayerTreeTest::DestroyLayerTreeHost() {
@@ -909,10 +922,6 @@ void LayerTreeTest::CreateRemoteClientHost(
   DCHECK(task_runner_provider()->HasImplThread());
 }
 
-TaskGraphRunner* LayerTreeTest::task_graph_runner() const {
-  return task_graph_runner_.get();
-}
-
 TaskRunnerProvider* LayerTreeTest::task_runner_provider() const {
   // All LayerTreeTests can use the task runner provider to access the impl
   // thread. In the remote mode, the impl thread of the compositor lives on