OOPIF support for layout test pixel dumps.

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 <algorithm>
 #include <unordered_map>
@@ skipping 272 matching lines @@
 
 void SetMockDeviceOrientationData(const OrientationData& 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.
+// DO NOT SUBMIT - clean this up / do this right...
 class CopyRequestSwapPromise : public cc::SwapPromise {
  public:
   using FindLayerTreeFrameSinkCallback =
       base::Callback<viz::TestLayerTreeFrameSink*()>;
-  CopyRequestSwapPromise(
-      std::unique_ptr<cc::CopyOutputRequest> request,
-      FindLayerTreeFrameSinkCallback find_layer_tree_frame_sink_callback)
-      : copy_request_(std::move(request)),
-        find_layer_tree_frame_sink_callback_(
-            std::move(find_layer_tree_frame_sink_callback)) {}
+  CopyRequestSwapPromise(std::unique_ptr<cc::CopyOutputRequest> request)
+      : copy_request_(std::move(request)) {}
 
   // cc::SwapPromise implementation.
-  void OnCommit() override {
-    layer_tree_frame_sink_from_commit_ =
-        find_layer_tree_frame_sink_callback_.Run();
-    DCHECK(layer_tree_frame_sink_from_commit_);
-  }
+  void OnCommit() override { copy_request_->SendEmptyResult(); }
   void DidActivate() override {}
-  void WillSwap(cc::CompositorFrameMetadata*) override {
-    layer_tree_frame_sink_from_commit_->RequestCopyOfOutput(
-        std::move(copy_request_));
-  }
+  void WillSwap(cc::CompositorFrameMetadata*) override {}
   void DidSwap() override {}
   DidNotSwapAction DidNotSwap(DidNotSwapReason r) override {
     // The compositor should always swap in layout test mode.
     NOTREACHED() << "did not swap for reason " << r;
     return DidNotSwapAction::BREAK_PROMISE;
   }
   int64_t TraceId() const override { return 0; }
 
  private:
   std::unique_ptr<cc::CopyOutputRequest> copy_request_;
-  FindLayerTreeFrameSinkCallback find_layer_tree_frame_sink_callback_;
-  viz::TestLayerTreeFrameSink* layer_tree_frame_sink_from_commit_ = nullptr;
 };
 
 }  // namespace
 
 class LayoutTestDependenciesImpl : public LayoutTestDependencies,
                                    public viz::TestLayerTreeFrameSinkClient {
  public:
-  std::unique_ptr<cc::LayerTreeFrameSink> CreateLayerTreeFrameSink(
-      int32_t routing_id,
-      scoped_refptr<gpu::GpuChannelHost> gpu_channel,
-      scoped_refptr<cc::ContextProvider> compositor_context_provider,
-      scoped_refptr<cc::ContextProvider> worker_context_provider,
-      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
-      CompositorDependencies* deps) override {
-    // This could override the GpuChannel for a LayerTreeFrameSink that was
-    // previously being created but in that case the old GpuChannel would be
-    // lost as would the LayerTreeFrameSink.
-    gpu_channel_ = gpu_channel;
-
-    auto* task_runner = deps->GetCompositorImplThreadTaskRunner().get();
-    bool synchronous_composite = !task_runner;
-    if (!task_runner)
-      task_runner = base::ThreadTaskRunnerHandle::Get().get();
-
-    cc::RendererSettings renderer_settings;
-    base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
-    renderer_settings.enable_color_correct_rendering =
-        base::FeatureList::IsEnabled(features::kColorCorrectRendering);
-    renderer_settings.allow_antialiasing &=
-        !cmd->HasSwitch(cc::switches::kDisableCompositedAntialiasing);
-    renderer_settings.highp_threshold_min = 2048;
-
-    constexpr bool disable_display_vsync = false;
-    constexpr double refresh_rate = 60.0;
-    auto layer_tree_frame_sink = base::MakeUnique<viz::TestLayerTreeFrameSink>(
-        std::move(compositor_context_provider),
-        std::move(worker_context_provider), nullptr /* shared_bitmap_manager */,
-        gpu_memory_buffer_manager, renderer_settings, task_runner,
-        synchronous_composite, disable_display_vsync, refresh_rate);
-    layer_tree_frame_sink->SetClient(this);
-    layer_tree_frame_sinks_[routing_id] = layer_tree_frame_sink.get();
-    return std::move(layer_tree_frame_sink);
-  }
-
   std::unique_ptr<cc::SwapPromise> RequestCopyOfOutput(
       int32_t routing_id,
       std::unique_ptr<cc::CopyOutputRequest> request) override {
     // Note that we can't immediately check layer_tree_frame_sinks_, since it
     // may not have been created yet. Instead, we wait until OnCommit to find
     // the currently active LayerTreeFrameSink for the given RenderWidget
     // routing_id.
-    return base::MakeUnique<CopyRequestSwapPromise>(
-        std::move(request),
-        base::Bind(
-            &LayoutTestDependenciesImpl::FindLayerTreeFrameSink,
-            // |this| will still be valid, because its lifetime is tied to
-            // RenderThreadImpl, which outlives layout test execution.
-            base::Unretained(this), routing_id));
+    return base::MakeUnique<CopyRequestSwapPromise>(std::move(request));
   }
 
   // TestLayerTreeFrameSinkClient implementation.
   std::unique_ptr<cc::OutputSurface> CreateDisplayOutputSurface(
       scoped_refptr<cc::ContextProvider> compositor_context_provider) 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;
@@ skipping 216 matching lines @@
   }
 }
 
 bool IsNavigationInitiatedByRenderer(const blink::WebURLRequest& request) {
   RequestExtraData* extra_data =
       static_cast<RequestExtraData*>(request.GetExtraData());
   return extra_data && extra_data->navigation_initiated_by_renderer();
 }
 
 }  // namespace content