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 261 matching lines @@
       double hide_threshold;
       if (base::StringToDouble(top_threshold_str, &hide_threshold) &&
           hide_threshold >= 0.f && hide_threshold <= 1.f)
         settings.top_controls_hide_threshold = hide_threshold;
   }
 
   settings.use_pinch_virtual_viewport =
       cmd->HasSwitch(cc::switches::kEnablePinchVirtualViewport);
   settings.allow_antialiasing &=
       !cmd->HasSwitch(cc::switches::kDisableCompositedAntialiasing);
+  settings.single_thread_proxy_scheduler =
+      !cmd->HasSwitch(switches::kDisableSingleThreadProxyScheduler);
 
   // These flags should be mirrored by UI versions in ui/compositor/.
   settings.initial_debug_state.show_debug_borders =
       cmd->HasSwitch(cc::switches::kShowCompositedLayerBorders);
   settings.initial_debug_state.show_fps_counter =
       cmd->HasSwitch(cc::switches::kShowFPSCounter);
   settings.initial_debug_state.show_layer_animation_bounds_rects =
       cmd->HasSwitch(cc::switches::kShowLayerAnimationBounds);
   settings.initial_debug_state.show_paint_rects =
       cmd->HasSwitch(switches::kShowPaintRects);
@@ skipping 112 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) {
-  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;
-}
-
 bool RenderWidgetCompositor::BeginMainFrameRequested() const {
   return layer_tree_host_->BeginMainFrameRequested();
 }
 
 void RenderWidgetCompositor::SetNeedsDisplayOnAllLayers() {
   layer_tree_host_->SetNeedsDisplayOnAllLayers();
 }
 
 void RenderWidgetCompositor::SetRasterizeOnlyVisibleContent() {
   cc::LayerTreeDebugState current = layer_tree_host_->debug_state();
@@ skipping 92 matching lines @@
         this,
         this,
         shared_bitmap_manager,
         settings,
         base::MessageLoopProxy::current());
   }
   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 cc_blink::WebLayerImpl*>(&layer)->layer());
 }
 
 void RenderWidgetCompositor::clearRootLayer() {
   layer_tree_host_->SetRootLayer(scoped_refptr<cc::Layer>());
 }
@@ skipping 133 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();
+
+  if (!threaded_ &&
+      !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 76 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