Use surface copy requests for layout tests.

content/renderer/gpu/render_widget_compositor.cc

 // Copyright (c) 2013 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/renderer/gpu/render_widget_compositor.h"
 
 #include <stddef.h>
 #include <limits>
 #include <string>
 #include <utility>
@@ skipping 877 matching lines @@
 bool RenderWidgetCompositor::CompositeIsSynchronous() const {
   if (!threaded_) {
     DCHECK(!layer_tree_host_->settings().single_thread_proxy_scheduler);
     return true;
   }
   return false;
 }
 
 void RenderWidgetCompositor::layoutAndPaintAsync(
     blink::WebLayoutAndPaintAsyncCallback* callback) {
-  DCHECK(!temporary_copy_output_request_ && !layout_and_paint_async_callback_);
+  DCHECK(!layout_and_paint_async_callback_);
   layout_and_paint_async_callback_ = callback;
 
   if (CompositeIsSynchronous()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&RenderWidgetCompositor::LayoutAndUpdateLayers,
                               weak_factory_.GetWeakPtr()));
   } else {
     layer_tree_host_->SetNeedsCommit();
   }
 }
 
 void RenderWidgetCompositor::LayoutAndUpdateLayers() {
   DCHECK(CompositeIsSynchronous());
   layer_tree_host_->LayoutAndUpdateLayers();
   InvokeLayoutAndPaintCallback();
 }
 
 void RenderWidgetCompositor::InvokeLayoutAndPaintCallback() {
   if (!layout_and_paint_async_callback_)
     return;
   layout_and_paint_async_callback_->didLayoutAndPaint();
   layout_and_paint_async_callback_ = nullptr;
 }
 
 void RenderWidgetCompositor::compositeAndReadbackAsync(
     blink::WebCompositeAndReadbackAsyncCallback* callback) {
-  DCHECK(!temporary_copy_output_request_ && !layout_and_paint_async_callback_);
-  temporary_copy_output_request_ =
-      cc::CopyOutputRequest::CreateBitmapRequest(
-          base::Bind(&CompositeAndReadbackAsyncCallback, callback));
+  DCHECK(!layout_and_paint_async_callback_);
+  scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
+      layer_tree_host_->task_runner_provider()->MainThreadTaskRunner();
+  std::unique_ptr<cc::CopyOutputRequest> request =
+      cc::CopyOutputRequest::CreateBitmapRequest(base::Bind(
+          [](blink::WebCompositeAndReadbackAsyncCallback* callback,
+             scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+             std::unique_ptr<cc::CopyOutputResult> result) {
+            task_runner->PostTask(FROM_HERE,
+                                  base::Bind(&CompositeAndReadbackAsyncCallback,
+                                             callback, base::Passed(&result)));
+          },
+          callback, base::Passed(&main_thread_task_runner)));
+  layer_tree_host_->QueueSwapPromise(
+      delegate_->RequestCopyOfOutputForLayoutTest(std::move(request)));
 
   // Force a commit to happen. The temporary copy output request will
   // be installed after layout which will happen as a part of the commit, for
   // widgets that delay the creation of their output surface.
   if (CompositeIsSynchronous()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&RenderWidgetCompositor::SynchronouslyComposite,
                               weak_factory_.GetWeakPtr()));
   } else {
     layer_tree_host_->SetNeedsCommit();
@@ skipping 68 matching lines @@
   double frame_time_sec = (args.frame_time - base::TimeTicks()).InSecondsF();
   delegate_->BeginMainFrame(frame_time_sec);
 }
 
 void RenderWidgetCompositor::BeginMainFrameNotExpectedSoon() {
   compositor_deps_->GetRendererScheduler()->BeginFrameNotExpectedSoon();
 }
 
 void RenderWidgetCompositor::UpdateLayerTreeHost() {
   delegate_->UpdateVisualState();
-  if (temporary_copy_output_request_) {
-    // For WebViewImpl, this will always have a root layer.  For other widgets,
-    // the widget may be closed before servicing this request, so ignore it.
-    if (cc::Layer* root_layer = layer_tree_host_->root_layer()) {
-      root_layer->RequestCopyOfOutput(
-          std::move(temporary_copy_output_request_));
-    } else {
-      temporary_copy_output_request_->SendEmptyResult();
-      temporary_copy_output_request_ = nullptr;
-    }
-  }
 }
 
 void RenderWidgetCompositor::ApplyViewportDeltas(
     const gfx::Vector2dF& inner_delta,
     const gfx::Vector2dF& outer_delta,
     const gfx::Vector2dF& elastic_overscroll_delta,
     float page_scale,
     float top_controls_delta) {
   delegate_->ApplyViewportDeltas(inner_delta, outer_delta,
                                  elastic_overscroll_delta, page_scale,
@@ skipping 36 matching lines @@
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&RenderWidgetCompositor::RequestNewOutputSurface,
                             weak_factory_.GetWeakPtr()));
 }
 
 void RenderWidgetCompositor::WillCommit() {
   InvokeLayoutAndPaintCallback();
 }
 
 void RenderWidgetCompositor::DidCommit() {
-  DCHECK(!temporary_copy_output_request_);
   delegate_->DidCommitCompositorFrame();
   compositor_deps_->GetRendererScheduler()->DidCommitFrameToCompositor();
 }
 
 void RenderWidgetCompositor::DidCommitAndDrawFrame() {
   delegate_->DidCommitAndDrawCompositorFrame();
 }
 
 void RenderWidgetCompositor::DidCompleteSwapBuffers() {
   delegate_->DidCompleteSwapBuffers();
@@ skipping 48 matching lines @@
 
   remote_proto_channel_receiver_->OnProtoReceived(std::move(deserialized));
 }
 
 void RenderWidgetCompositor::SetPaintedDeviceScaleFactor(
     float device_scale) {
   layer_tree_host_->SetPaintedDeviceScaleFactor(device_scale);
 }
 
 }  // namespace content