Make SingleThreadProxy a SchedulerClient

content/renderer/gpu/render_widget_compositor.cc

Index: content/renderer/gpu/render_widget_compositor.cc
diff --git a/content/renderer/gpu/render_widget_compositor.cc b/content/renderer/gpu/render_widget_compositor.cc
index 96a74c6d06fa30c0c9d76bd51fe06aa21e5cc88f..b71c6f57a171be533849595ba922582a8d94fa78 100644
--- a/content/renderer/gpu/render_widget_compositor.cc
+++ b/content/renderer/gpu/render_widget_compositor.cc
@@ -410,7 +410,6 @@ scoped_ptr<RenderWidgetCompositor> RenderWidgetCompositor::Create(
 RenderWidgetCompositor::RenderWidgetCompositor(RenderWidget* widget,
                                                bool threaded)
     : threaded_(threaded),
-      suppress_schedule_composite_(false),
       widget_(widget) {
 }
 
@@ -421,27 +420,10 @@ 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::UpdateAnimations(base::TimeTicks time) {
-  layer_tree_host_->UpdateClientAnimations(time);
-}
-
 void RenderWidgetCompositor::SetNeedsDisplayOnAllLayers() {
   layer_tree_host_->SetNeedsDisplayOnAllLayers();
 }
@@ -534,7 +516,10 @@ void RenderWidgetCompositor::Initialize(cc::LayerTreeSettings settings) {
 }
 
 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) {
@@ -687,11 +672,9 @@ void RenderWidgetCompositor::compositeAndReadbackAsync(
       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();
-    layer_tree_host_->Composite(gfx::FrameTime::Now());
-  }
+
+  if (!threaded_)
+    layer_tree_host_->CompositeNoSwap(gfx::FrameTime::Now());

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

This is the most unfortunate part of this patch.  In my epic failure of a
struggle against layout test flakiness, I was unable to wrangle tests to not be
(as) flaky without synchronously doing the commit and composite as a part of the
notifyDone callstack that.

I tried a bunch of other approaches (saving animation times, synchronous commit
but deferred composite), but either my implementation was bogus or there was
some other form of flakiness (e.g. accelerated video).

There may be some follow-up cleanup that would make this less awful, but for now
this grossness needs to live on.

The reason it doesn't swap is because the scheduler is really not expecting a
swap at this point and will explode if it piles up too many due to backpressure.
 This is just a readback, so it doesn't actually need to make it to the screen. 
Therefore, CompositeNoSwap.

 }
 
 void RenderWidgetCompositor::finishAllRendering() {
@@ -785,11 +768,6 @@ void RenderWidgetCompositor::DidCompleteSwapBuffers() {
     widget_->OnSwapBuffersComplete();
 }
 
-void RenderWidgetCompositor::ScheduleComposite() {
-  if (!suppress_schedule_composite_)
-    widget_->scheduleComposite();
-}
-
 void RenderWidgetCompositor::ScheduleAnimation() {
   widget_->scheduleAnimation();
 }