Make SingleThreadProxy a SchedulerClient

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 392 matching lines @@
 #endif
 
   compositor->Initialize(settings);
 
   return compositor.Pass();
 }
 
 RenderWidgetCompositor::RenderWidgetCompositor(RenderWidget* widget,
                                                bool threaded)
     : threaded_(threaded),
-      suppress_schedule_composite_(false),
       widget_(widget) {
 }
 
 RenderWidgetCompositor::~RenderWidgetCompositor() {}
 
 const base::WeakPtr<cc::InputHandler>&
 RenderWidgetCompositor::GetInputHandler() {
   return layer_tree_host_->GetInputHandler();
 }
 
 void RenderWidgetCompositor::SetSuppressScheduleComposite(bool suppress) {

[enne (OOO), 2014/07/10 20:37:42]

This no longer makes any sense in an FCM world, and deferring commits was just
wrong.

I will remove it in a follow-up.

[jamesr, 2014/07/10 21:55:40]

Which part doesn't make sense?  Suppressing composition during part of the page
load is very important for performance and FOUC prevention.  How this should
actually be accomplished is tricky, but the behavior is important.

[danakj, 2014/07/10 21:57:14]

This is done by SetDeferCommits in WebViewImpl now, right?

[enne (OOO), 2014/07/10 22:03:49]

SetSuppressScheduleComposite != SetDeferCommits.

ScheduleComposite is the non-cc::Scheduler way for cc to tell its embedder to
schedule a composite.  Currently, WebViewImpl sets and unsets this during the
course of setRootGraphicslayer to prevent this call from going out.  The
intersection of the sets (code still using ScheduleComposite) and (code calling
SetSuppressScheduleComposite) is empty.

Preventing commits during page load is done by SetDeferCommits and is set during
setIsAcceleratedCompositingActive(false) and unset later on in a few places
where it seems likely that the page has loaded.  This needs to stay, for sure.

-  if (suppress_schedule_composite_ == suppress)
-    return;
-
-  if (suppress)
-    TRACE_EVENT_ASYNC_BEGIN0("gpu",
-        "RenderWidgetCompositor::SetSuppressScheduleComposite", this);
-  else
-    TRACE_EVENT_ASYNC_END0("gpu",
-        "RenderWidgetCompositor::SetSuppressScheduleComposite", this);
-  suppress_schedule_composite_ = suppress;
+  layer_tree_host_->SetDeferCommits(suppress);
 }
 
 bool RenderWidgetCompositor::BeginMainFrameRequested() const {
   return layer_tree_host_->BeginMainFrameRequested();
 }
 
-void RenderWidgetCompositor::UpdateAnimations(base::TimeTicks time) {
-  layer_tree_host_->UpdateClientAnimations(time);
-}
-
 void RenderWidgetCompositor::SetNeedsDisplayOnAllLayers() {
   layer_tree_host_->SetNeedsDisplayOnAllLayers();
 }
 
 void RenderWidgetCompositor::SetRasterizeOnlyVisibleContent() {
   cc::LayerTreeDebugState current = layer_tree_host_->debug_state();
   current.rasterize_only_visible_content = true;
   layer_tree_host_->SetDebugState(current);
 }
 
@@ skipping 72 matching lines @@
     layer_tree_host_ = cc::LayerTreeHost::CreateThreaded(
         this, shared_bitmap_manager, settings, compositor_message_loop_proxy);
   } else {
     layer_tree_host_ = cc::LayerTreeHost::CreateSingleThreaded(
         this, this, shared_bitmap_manager, settings);
   }
   DCHECK(layer_tree_host_);
 }
 
 void RenderWidgetCompositor::setSurfaceReady() {
-  layer_tree_host_->SetLayerTreeHostClientReady();
+  // In tests without a RenderThreadImpl, don't set ready as this kicks
+  // off creating output surfaces that the test can't create.
+  if (RenderThreadImpl::current())
+    layer_tree_host_->SetLayerTreeHostClientReady();
 }
 
 void RenderWidgetCompositor::setRootLayer(const blink::WebLayer& layer) {
   layer_tree_host_->SetRootLayer(
       static_cast<const WebLayerImpl*>(&layer)->layer());
 }
 
 void RenderWidgetCompositor::clearRootLayer() {
   layer_tree_host_->SetRootLayer(scoped_refptr<cc::Layer>());
 }
@@ skipping 132 matching lines @@
   }
 }
 
 void RenderWidgetCompositor::compositeAndReadbackAsync(
     blink::WebCompositeAndReadbackAsyncCallback* callback) {
   DCHECK(layer_tree_host_->root_layer());
   scoped_ptr<cc::CopyOutputRequest> request =
       cc::CopyOutputRequest::CreateBitmapRequest(
           base::Bind(&CompositeAndReadbackAsyncCallback, callback));
   layer_tree_host_->root_layer()->RequestCopyOfOutput(request.Pass());
-  if (!threaded_) {
-    widget_->webwidget()->animate(0.0);
-    widget_->webwidget()->layout();
+
+  // Synchronous non-scheduled compositors need an immediate composite
+  // so that the readback comes back.
+  if (!layer_tree_host_->settings().single_thread_proxy_scheduler)
     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);
 }
 
@@ skipping 73 matching lines @@
 void RenderWidgetCompositor::DidCommitAndDrawFrame() {
   widget_->didCommitAndDrawCompositorFrame();
 }
 
 void RenderWidgetCompositor::DidCompleteSwapBuffers() {
   widget_->didCompleteSwapBuffers();
   if (!threaded_)
     widget_->OnSwapBuffersComplete();
 }
 
-void RenderWidgetCompositor::ScheduleComposite() {
-  if (!suppress_schedule_composite_)
-    widget_->scheduleComposite();
-}
-
 void RenderWidgetCompositor::ScheduleAnimation() {
   widget_->scheduleAnimation();
 }
 
 void RenderWidgetCompositor::DidPostSwapBuffers() {
   widget_->OnSwapBuffersPosted();
 }
 
 void RenderWidgetCompositor::DidAbortSwapBuffers() {
   widget_->OnSwapBuffersAborted();
 }
 
 void RenderWidgetCompositor::RateLimitSharedMainThreadContext() {
   cc::ContextProvider* provider =
       RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
   provider->ContextGL()->RateLimitOffscreenContextCHROMIUM();
 }
 
 }  // namespace content