Make SingleThreadProxy a SchedulerClient

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 1491 matching lines @@
   gfx::SizeF dip_size =
       gfx::ScaleSize(device_viewport_size_, 1.f / device_scale_factor());
 
   float top_offset =
       top_controls_manager_ ? top_controls_manager_->content_top_offset() : 0.f;
   return gfx::SizeF(dip_size.width(),
                     dip_size.height() - top_offset - overdraw_bottom_height_);
 }
 
 void LayerTreeHostImpl::DidLoseOutputSurface() {
+#ifndef NDEBUG
+  // This must be set before calling the below functions as they may
+  // synchronously try to recreate the output surface.
+  did_lose_called_ = true;
+#endif
   if (resource_provider_)
     resource_provider_->DidLoseOutputSurface();
   // TODO(jamesr): The renderer_ check is needed to make some of the
   // LayerTreeHostContextTest tests pass, but shouldn't be necessary (or
   // important) in production. We should adjust the test to not need this.
   if (renderer_)
     client_->DidLoseOutputSurfaceOnImplThread();
-#ifndef NDEBUG
-  did_lose_called_ = true;
-#endif
 }
 
 void LayerTreeHostImpl::Readback(void* pixels,
                                  const gfx::Rect& rect_in_device_viewport) {
   DCHECK(renderer_);
   renderer_->GetFramebufferPixels(pixels, rect_in_device_viewport);
 }
 
 bool LayerTreeHostImpl::HaveRootScrollLayer() const {
   return !!InnerViewportScrollLayer();
@@ skipping 287 matching lines @@
         GetRendererCapabilities().using_map_image,
         GetRendererCapabilities().allow_rasterize_on_demand);
   }
 
   // Setup BeginImplFrameEmulation if it's not supported natively
   if (!settings_.begin_impl_frame_scheduling_enabled) {
     const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(
           base::Time::kMicrosecondsPerSecond /
           settings_.refresh_rate);
-
+    // If no compositor thread, then begin impl frame messages should just
+    // go back to the main thread.
+    base::SingleThreadTaskRunner* task_runner =
+        proxy_->ImplThreadTaskRunner() ? proxy_->ImplThreadTaskRunner()
+                                       : proxy_->MainThreadTaskRunner();
     output_surface->InitializeBeginImplFrameEmulation(
-        proxy_->ImplThreadTaskRunner(),
+        task_runner,
         settings_.throttle_frame_production,
         display_refresh_interval);
   }
 
   int max_frames_pending =
       output_surface->capabilities().max_frames_pending;
   if (max_frames_pending <= 0)
     max_frames_pending = OutputSurface::DEFAULT_MAX_FRAMES_PENDING;
   output_surface->SetMaxFramesPending(max_frames_pending);
 
@@ skipping 1156 matching lines @@
   swap_promise_monitor_.erase(monitor);
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 }  // namespace cc