testRunner.layoutAndPaintAsyncThen ==> testRunner.compositeAsyncThen

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 34 matching lines @@
 #include "content/common/content_switches_internal.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/input/input_event_utils.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/gpu/render_widget_compositor_delegate.h"
 #include "content/renderer/input/input_handler_manager.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "third_party/WebKit/public/platform/WebCompositeAndReadbackAsyncCallback.h"
+#include "third_party/WebKit/public/platform/WebCompositeCallback.h"
 #include "third_party/WebKit/public/platform/WebCompositorMutatorClient.h"
-#include "third_party/WebKit/public/platform/WebLayoutAndPaintAsyncCallback.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebSelection.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/native_theme/native_theme_switches.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #include "ui/gfx/android/device_display_info.h"
@@ skipping 149 matching lines @@
   return compositor;
 }
 
 RenderWidgetCompositor::RenderWidgetCompositor(
     RenderWidgetCompositorDelegate* delegate,
     CompositorDependencies* compositor_deps)
     : num_failed_recreate_attempts_(0),
       delegate_(delegate),
       compositor_deps_(compositor_deps),
       never_visible_(false),
-      layout_and_paint_async_callback_(nullptr),
       remote_proto_channel_receiver_(nullptr),
       weak_factory_(this) {}
 
 void RenderWidgetCompositor::Initialize(float device_scale_factor) {
   base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
 
   // For web contents, layer transforms should scale up the contents of layers
   // to keep content always crisp when possible.
@@ skipping 561 matching lines @@
   layer_tree_host_->SetHaveScrollEventHandlers(has_handlers);
 }
 
 bool RenderWidgetCompositor::haveScrollEventHandlers() const {
   return layer_tree_host_->have_scroll_event_handlers();
 }
 
 void CompositeAndReadbackAsyncCallback(
     blink::WebCompositeAndReadbackAsyncCallback* callback,
     std::unique_ptr<cc::CopyOutputResult> result) {
-  if (result->HasBitmap()) {
+  if (callback->needsBitmap() && result->HasBitmap()) {
     std::unique_ptr<SkBitmap> result_bitmap = result->TakeBitmap();
     callback->didCompositeAndReadback(*result_bitmap);
   } else {
     callback->didCompositeAndReadback(SkBitmap());
   }
 }
 
 bool RenderWidgetCompositor::CompositeIsSynchronous() const {
   return !compositor_deps_->GetCompositorImplThreadTaskRunner().get() &&
          !layer_tree_host_->settings().single_thread_proxy_scheduler;
 }
 
-void RenderWidgetCompositor::layoutAndPaintAsync(
-    blink::WebLayoutAndPaintAsyncCallback* callback) {
-  DCHECK(!temporary_copy_output_request_ && !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_);
+  DCHECK(!temporary_copy_output_request_);
   temporary_copy_output_request_ =
       cc::CopyOutputRequest::CreateBitmapRequest(
           base::Bind(&CompositeAndReadbackAsyncCallback, callback));
 
   // 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,
@@ skipping 134 matching lines @@
   // in the output-surface-lost machinery.
   LOG_IF(FATAL, (num_failed_recreate_attempts_ >= MAX_OUTPUT_SURFACE_RETRIES))
       << "Failed to create a fallback OutputSurface.";
 
   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();
@@ skipping 141 matching lines @@
 #endif
   return actual;
 }
 
 void RenderWidgetCompositor::SetPaintedDeviceScaleFactor(
     float device_scale) {
   layer_tree_host_->SetPaintedDeviceScaleFactor(device_scale);
 }
 
 }  // namespace content