Use surface copy requests for layout tests.

content/test/layouttest_support.cc

 // Copyright (c) 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 "content/public/test/layouttest_support.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
+#include "cc/output/copy_output_request.h"
 #include "cc/test/pixel_test_output_surface.h"
 #include "cc/test/test_delegating_output_surface.h"
 #include "components/scheduler/test/renderer_scheduler_test_support.h"
 #include "components/test_runner/test_common.h"
 #include "components/test_runner/web_frame_test_proxy.h"
 #include "components/test_runner/web_view_test_proxy.h"
 #include "content/browser/bluetooth/bluetooth_device_chooser_controller.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
@@ skipping 147 matching lines @@
 }
 
 void SetMockDeviceMotionData(const WebDeviceMotionData& data) {
   RendererBlinkPlatformImpl::SetMockDeviceMotionDataForTesting(data);
 }
 
 void SetMockDeviceOrientationData(const WebDeviceOrientationData& data) {
   RendererBlinkPlatformImpl::SetMockDeviceOrientationDataForTesting(data);
 }
 
+namespace {
+
+// Invokes a callback on commit (on the main thread) to obtain the output
+// surface that should be used, then asks that output surface to submit the copy
+// request at SwapBuffers time.
+class CopyRequestSwapPromise : public cc::SwapPromise {
+ public:
+  using FindOutputSurfaceCallback =
+      base::Callback<cc::TestDelegatingOutputSurface*()>;
+  CopyRequestSwapPromise(std::unique_ptr<cc::CopyOutputRequest> request,
+                         FindOutputSurfaceCallback output_surface_callback)
+      : copy_request_(std::move(request)),
+        output_surface_callback_(std::move(output_surface_callback)) {}
+
+  // cc::SwapPromise implementation.
+  void OnCommit() override {
+    output_surface_ = output_surface_callback_.Run();
+    DCHECK(output_surface_);
+  }
+  void DidActivate() override {}
+  void DidSwap(cc::CompositorFrameMetadata*) override {
+    output_surface_->RequestCopyOfOutput(std::move(copy_request_));
+  }
+  void DidNotSwap(DidNotSwapReason r) override {
+    // The compositor should always swap in layout test mode.
+    DCHECK(false) << "did not swap for reason " << r;

[danakj, 2016/07/25 21:16:28]

nit: DCHECK(false) == NOTREACHED() (except on chromeos lol but whatever)

[jbroman, 2016/07/25 21:47:45]

Done.

+  }
+  int64_t TraceId() const override { return 0; }
+
+ private:
+  std::unique_ptr<cc::CopyOutputRequest> copy_request_;
+  FindOutputSurfaceCallback output_surface_callback_;
+  cc::TestDelegatingOutputSurface* output_surface_ = nullptr;

[danakj, 2016/07/25 21:16:28]

nit: output_surface_from_commit_ would document the lifetime/expectations of
this var a bit

[jbroman, 2016/07/25 21:47:45]

OK. This class is small enough that it's hard to miss, but fair enough.

+};
+
+}  // namespace
+
 class LayoutTestDependenciesImpl : public LayoutTestDependencies {
  public:
   std::unique_ptr<cc::OutputSurface> CreateOutputSurface(
+      int32_t routing_id,
       scoped_refptr<gpu::GpuChannelHost> gpu_channel,
       scoped_refptr<cc::ContextProvider> compositor_context_provider,
       scoped_refptr<cc::ContextProvider> worker_context_provider,
       CompositorDependencies* deps) override {
     // This is for an offscreen context for the compositor. So the default
     // framebuffer doesn't need alpha, depth, stencil, antialiasing.
     gpu::gles2::ContextCreationAttribHelper attributes;
     attributes.alpha_size = -1;
     attributes.depth_size = 0;
     attributes.stencil_size = 0;
@@ skipping 19 matching lines @@
 
     auto* task_runner = deps->GetCompositorImplThreadTaskRunner().get();
     bool synchronous_composite = !task_runner;
     if (!task_runner)
       task_runner = base::ThreadTaskRunnerHandle::Get().get();
 
     cc::LayerTreeSettings settings =
         RenderWidgetCompositor::GenerateLayerTreeSettings(
             *base::CommandLine::ForCurrentProcess(), deps, 1.f);
 
-    return base::MakeUnique<cc::TestDelegatingOutputSurface>(
+    auto output_surface = base::MakeUnique<cc::TestDelegatingOutputSurface>(
         std::move(compositor_context_provider),
         std::move(worker_context_provider), std::move(display_output_surface),
         deps->GetSharedBitmapManager(), deps->GetGpuMemoryBufferManager(),
         settings.renderer_settings, task_runner, synchronous_composite);
+    output_surfaces_[routing_id] = output_surface.get();
+    return std::move(output_surface);
   }
+
+  std::unique_ptr<cc::SwapPromise> RequestCopyOfOutput(
+      int32_t routing_id,
+      std::unique_ptr<cc::CopyOutputRequest> request) override {
+    // Note that we can't immediately check output_surfaces_, since it may not
+    // have been created yet. Instead, we wait until OnCommit to find the
+    // currently active OutputSurface for the given RenderWidget routing_id.
+    // LayoutTestDependenciesImpl will still be valid, because its lifetime is
+    // tied to RenderThreadImpl, which outlives layout test execution.
+    return base::MakeUnique<CopyRequestSwapPromise>(
+        std::move(request),
+        base::Bind(
+            [](const LayoutTestDependenciesImpl* self, int32_t routing_id) {

[danakj, 2016/07/25 21:16:28]

nit: I think I marginally prefer this be a private method on the class instead
of a lambda. You'll need to Unretained(this), and it'd be nice to move the
comment about LTDepsImpl being value onto the use of that unretained.

[jbroman, 2016/07/25 21:47:45]

As you command.

+              auto it = self->output_surfaces_.find(routing_id);
+              return it == self->output_surfaces_.end() ? nullptr : it->second;
+            },
+            this, routing_id));
+  }
+
+ private:
+  std::unordered_map<int32_t, cc::TestDelegatingOutputSurface*>
+      output_surfaces_;
 };
 
 void EnableRendererLayoutTestMode() {
   RenderThreadImpl::current()->set_layout_test_dependencies(
       base::MakeUnique<LayoutTestDependenciesImpl>());
 
 #if defined(OS_WIN)
   RegisterSideloadedTypefaces(SkFontMgr_New_DirectWrite());
 #endif
 }
@@ skipping 260 matching lines @@
   return result;
 }
 
 void SchedulerRunIdleTasks(const base::Closure& callback) {
     scheduler::RendererScheduler* scheduler =
         content::RenderThreadImpl::current()->GetRendererScheduler();
     scheduler::RunIdleTasksForTesting(scheduler, callback);
 }
 
 }  // namespace content