Revert of 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 729 matching lines @@
   ScheduleCommit();
 }
 
 bool RenderWidgetCompositor::CommitIsSynchronous() const {
   return !compositor_deps_->GetCompositorImplThreadTaskRunner().get() &&
          !layer_tree_host_->settings().single_thread_proxy_scheduler;
 }
 
 void RenderWidgetCompositor::ScheduleCommit() {
   if (CommitIsSynchronous()) {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&RenderWidgetCompositor::SynchronousCommit,
-                              weak_factory_.GetWeakPtr()));
+    layer_tree_host_->Composite(gfx::FrameTime::Now());
   } 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