Let layoutAndPaintAsync() schedule commit asynchronously

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 <limits>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 722 matching lines @@
   DCHECK(!temporary_copy_output_request_ && !layout_and_paint_async_callback_);
   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.
   ScheduleCommit();
 }
 
-bool RenderWidgetCompositor::CommitIsSynchronous() const {
+bool RenderWidgetCompositor::CommitIsSynchronous() const

[no sievers, 2015/05/07 17:57:56]

nit: move brace back up

[Xianzhu, 2015/05/07 18:05:36]

Done.

+{
   return !compositor_deps_->GetCompositorImplThreadTaskRunner().get() &&
          !layer_tree_host_->settings().single_thread_proxy_scheduler;
 }
 
 void RenderWidgetCompositor::ScheduleCommit() {
   if (CommitIsSynchronous()) {
-    layer_tree_host_->Composite(gfx::FrameTime::Now());
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(&RenderWidgetCompositor::SynchronousCommit,
+                              weak_factory_.GetWeakPtr()));
   } else {
     layer_tree_host_->SetNeedsCommit();
   }
 }
 
+void RenderWidgetCompositor::SynchronousCommit() {
+  DCHECK(CommitIsSynchronous());
+  layer_tree_host_->Composite(gfx::FrameTime::Now());
+}
+
 void RenderWidgetCompositor::finishAllRendering() {
   layer_tree_host_->FinishAllRendering();
 }
 
 void RenderWidgetCompositor::setDeferCommits(bool defer_commits) {
   layer_tree_host_->SetDeferCommits(defer_commits);
 }
 
 int RenderWidgetCompositor::layerTreeId() const {
   return layer_tree_host_->id();
@@ skipping 145 matching lines @@
       << "Failed to create a fallback OutputSurface.";
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&RenderWidgetCompositor::RequestNewOutputSurface,
                             weak_factory_.GetWeakPtr()));
 }
 
 void RenderWidgetCompositor::WillCommit() {
   if (!layout_and_paint_async_callback_)
     return;
-
-  if (CommitIsSynchronous()) {
-    // The caller expects the callback to be called asynchronously.
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&RenderWidgetCompositor::DidLayoutAndPaintAsync,
-                              weak_factory_.GetWeakPtr()));
-  } else {
-    DidLayoutAndPaintAsync();
-  }
-}
-
-void RenderWidgetCompositor::DidLayoutAndPaintAsync() {
-  if (!layout_and_paint_async_callback_)
-    return;
   layout_and_paint_async_callback_->didLayoutAndPaint();
   layout_and_paint_async_callback_ = nullptr;
 }
 
 void RenderWidgetCompositor::DidCommit() {
   DCHECK(!temporary_copy_output_request_);
   widget_->DidCommitCompositorFrame();
   widget_->didBecomeReadyForAdditionalInput();
   compositor_deps_->GetRendererScheduler()->DidCommitFrameToCompositor();
 }
@@ skipping 29 matching lines @@
   cc::ContextProvider* provider =
       compositor_deps_->GetSharedMainThreadContextProvider();
   // provider can be NULL after the GPU process crashed enough times and we
   // don't want to restart it any more (falling back to software).
   if (!provider)
     return;
   provider->ContextGL()->RateLimitOffscreenContextCHROMIUM();
 }
 
 }  // namespace content