Make SingleThreadProxy a SchedulerClient

cc/trees/single_thread_proxy.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/single_thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/output/context_provider.h"
@@ skipping 15 matching lines @@
   return make_scoped_ptr(
       new SingleThreadProxy(layer_tree_host, client)).PassAs<Proxy>();
 }
 
 SingleThreadProxy::SingleThreadProxy(LayerTreeHost* layer_tree_host,
                                      LayerTreeHostSingleThreadClient* client)
     : Proxy(NULL),
       layer_tree_host_(layer_tree_host),
       client_(client),
       created_offscreen_context_provider_(false),
+      weak_factory_(this),
       next_frame_is_newly_committed_frame_(false),
-      inside_draw_(false) {
+      inside_draw_(false),
+      defer_commits_(false),
+      finish_commit_deferred_(false) {
   TRACE_EVENT0("cc", "SingleThreadProxy::SingleThreadProxy");
   DCHECK(Proxy::IsMainThread());
   DCHECK(layer_tree_host);
 
   // Impl-side painting not supported without threaded compositing.
   CHECK(!layer_tree_host->settings().impl_side_painting)
       << "Threaded compositing must be enabled to use impl-side painting.";
 }
 
 void SingleThreadProxy::Start() {
   DebugScopedSetImplThread impl(this);
   layer_tree_host_impl_ = layer_tree_host_->CreateLayerTreeHostImpl(this);
+  SchedulerSettings scheduler_settings(layer_tree_host_->settings());
+  scheduler_on_impl_thread_ =
+      Scheduler::Create(this, scheduler_settings, layer_tree_host_->id());
+  scheduler_on_impl_thread_->SetVisible(layer_tree_host_impl_->visible());
 }
 
 SingleThreadProxy::~SingleThreadProxy() {
   TRACE_EVENT0("cc", "SingleThreadProxy::~SingleThreadProxy");
   DCHECK(Proxy::IsMainThread());
   // Make sure Stop() got called or never Started.
   DCHECK(!layer_tree_host_impl_);
 }
 
 bool SingleThreadProxy::CompositeAndReadback(void* pixels,
                                              const gfx::Rect& rect) {
   TRACE_EVENT0("cc", "SingleThreadProxy::CompositeAndReadback");
   DCHECK(Proxy::IsMainThread());
-
-  gfx::Rect device_viewport_damage_rect = rect;
-
-  LayerTreeHostImpl::FrameData frame;
-  if (!CommitAndComposite(gfx::FrameTime::Now(),
-                          device_viewport_damage_rect,
-                          true,  // for_readback
-                          &frame))
+  // TODO(enne): make this go through the SetNeedsForcedCommitForReadback logic.
+  bool do_commit = true;
+  bool for_readback = true;
+  gfx::Rect device_viewport_damage_rect(rect);
+  if (CommitAndCompositeInternal(gfx::FrameTime::Now(),
+                                 device_viewport_damage_rect,
+                                 do_commit,
+                                 for_readback).draw_result !=
+      DrawSwapReadbackResult::DRAW_SUCCESS)
     return false;
 
   {
     DebugScopedSetImplThread impl(this);
     layer_tree_host_impl_->Readback(pixels, rect);
 
     if (layer_tree_host_impl_->IsContextLost())
       return false;
   }
 
@@ skipping 11 matching lines @@
 
 bool SingleThreadProxy::IsStarted() const {
   DCHECK(Proxy::IsMainThread());
   return layer_tree_host_impl_;
 }
 
 void SingleThreadProxy::SetLayerTreeHostClientReady() {
   TRACE_EVENT0("cc", "SingleThreadProxy::SetLayerTreeHostClientReady");
   // Scheduling is controlled by the embedder in the single thread case, so
   // nothing to do.
+  DCHECK(Proxy::IsMainThread());
+  DebugScopedSetImplThread impl(this);
+  scheduler_on_impl_thread_->SetCanStart();
 }
 
 void SingleThreadProxy::SetVisible(bool visible) {
   TRACE_EVENT0("cc", "SingleThreadProxy::SetVisible");
   DebugScopedSetImplThread impl(this);
   layer_tree_host_impl_->SetVisible(visible);
+  scheduler_on_impl_thread_->SetVisible(layer_tree_host_impl_->visible());
 
   // Changing visibility could change ShouldComposite().
   UpdateBackgroundAnimateTicking();
 }
 
 void SingleThreadProxy::CreateAndInitializeOutputSurface() {
   TRACE_EVENT0(
       "cc", "SingleThreadProxy::CreateAndInitializeOutputSurface");
   DCHECK(Proxy::IsMainThread());
 
@@ skipping 36 matching lines @@
     } else if (offscreen_context_provider.get()) {
       offscreen_context_provider->VerifyContexts();
       offscreen_context_provider = NULL;
     }
 
     layer_tree_host_impl_->SetOffscreenContextProvider(
         offscreen_context_provider);
   }
 
   OnOutputSurfaceInitializeAttempted(initialized);
+
+  // This must happen after OnCreateAndInitializeOutputSurfaceAttempted as it
+  // causes a commit and the output surface needs to be initialized beforehand.
+  if (initialized) {
+    DebugScopedSetImplThread impl(this);
+    scheduler_on_impl_thread_->DidCreateAndInitializeOutputSurface();
+  }
 }
 
 void SingleThreadProxy::OnOutputSurfaceInitializeAttempted(bool success) {
   LayerTreeHost::CreateResult result =
       layer_tree_host_->OnCreateAndInitializeOutputSurfaceAttempted(success);
   if (result == LayerTreeHost::CreateFailedButTryAgain) {
-    // Force another recreation attempt to happen by requesting another commit.
-    SetNeedsCommit();
+    if (!weak_ptr_)
+      weak_ptr_ = weak_factory_.GetWeakPtr();

[danakj, 2014/02/20 20:56:40]

I don't think you need a member variable for this. Just call GetWeakPtr()
directly in Bind().

[enne (OOO), 2014/02/20 21:07:13]

It seemed silly to create a new weak pointer every time this function was
called? Also, didn't you just suggest to use a factory in case there were
multiple users of this weak pointer?

[danakj, 2014/02/20 21:09:47]

This is called rarely, and I think it's not a typical pattern to store the
weakptr unless you're going to use it a lot on critical paths? ThreadProxy is
the only place I can think of that I've seen that. I suggested the factory
because that's the right way to get weakptrs. The other way is to subclass
SupportsWeakPtr but that's deprecated.

[enne (OOO), 2014/02/21 19:34:09]

Removed weak pointer.

+    Proxy::MainThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&SingleThreadProxy::CreateAndInitializeOutputSurface,
+                   weak_ptr_));
   }
 }
 
 const RendererCapabilities& SingleThreadProxy::GetRendererCapabilities() const {
   DCHECK(Proxy::IsMainThread());
   DCHECK(!layer_tree_host_->output_surface_lost());
   return renderer_capabilities_for_main_thread_;
 }
 
 void SingleThreadProxy::SetNeedsAnimate() {
   TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsAnimate");
   DCHECK(Proxy::IsMainThread());
-  client_->ScheduleAnimation();
+  SetNeedsCommit();
 }
 
 void SingleThreadProxy::SetNeedsUpdateLayers() {
   TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsUpdateLayers");
   DCHECK(Proxy::IsMainThread());
-  client_->ScheduleComposite();
+  SetNeedsCommit();
 }
 
-void SingleThreadProxy::DoCommit(scoped_ptr<ResourceUpdateQueue> queue) {
+void SingleThreadProxy::DoCommit(base::TimeTicks frame_begin_time) {
   TRACE_EVENT0("cc", "SingleThreadProxy::DoCommit");
   DCHECK(Proxy::IsMainThread());
+  layer_tree_host_->WillBeginMainFrame();
+  layer_tree_host_->Layout();
+  layer_tree_host_->AnimateLayers(frame_begin_time);
+
+  if (PrioritizedResourceManager* contents_texture_manager =
+          layer_tree_host_->contents_texture_manager()) {
+    contents_texture_manager->UnlinkAndClearEvictedBackings();
+    contents_texture_manager->SetMaxMemoryLimitBytes(
+        layer_tree_host_impl_->memory_allocation_limit_bytes());
+    contents_texture_manager->SetExternalPriorityCutoff(
+        layer_tree_host_impl_->memory_allocation_priority_cutoff());
+  }
+
+  scoped_ptr<ResourceUpdateQueue> queue =
+      make_scoped_ptr(new ResourceUpdateQueue);
+
+  layer_tree_host_->UpdateLayers(queue.get());
+
+  layer_tree_host_->WillCommit();
+
   // Commit immediately.
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
     DebugScopedSetImplThread impl(this);
 
     // This CapturePostTasks should be destroyed before CommitComplete() is
     // called since that goes out to the embedder, and we want the embedder
     // to receive its callbacks before that.
     BlockingTaskRunner::CapturePostTasks blocked;
 
@@ skipping 13 matching lines @@
             layer_tree_host_impl_->resource_provider());
     update_controller->Finalize();
 
     if (layer_tree_host_impl_->EvictedUIResourcesExist())
       layer_tree_host_->RecreateUIResources();
 
     layer_tree_host_->FinishCommitOnImplThread(layer_tree_host_impl_.get());
 
     layer_tree_host_impl_->CommitComplete();
 
+    UpdateBackgroundAnimateTicking();
+
 #ifndef NDEBUG
     // In the single-threaded case, the scale and scroll deltas should never be
     // touched on the impl layer tree.
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         layer_tree_host_impl_->ProcessScrollDeltas();
     DCHECK(!scroll_info->scrolls.size());
     DCHECK_EQ(1.f, scroll_info->page_scale_delta);
 #endif
 
     RenderingStatsInstrumentation* stats_instrumentation =
         layer_tree_host_->rendering_stats_instrumentation();
     BenchmarkInstrumentation::IssueMainThreadRenderingStatsEvent(
         stats_instrumentation->main_thread_rendering_stats());
     stats_instrumentation->AccumulateAndClearMainThreadStats();
   }
   layer_tree_host_->CommitComplete();
+  layer_tree_host_->DidBeginMainFrame();
+  timing_history_.DidCommit();
+
   next_frame_is_newly_committed_frame_ = true;
 }
 
 void SingleThreadProxy::SetNeedsCommit() {
-  DCHECK(Proxy::IsMainThread());
-  client_->ScheduleComposite();
+  scheduler_on_impl_thread_->SetNeedsCommit();
 }
 
 void SingleThreadProxy::SetNeedsRedraw(const gfx::Rect& damage_rect) {
   TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsRedraw");
+  DCHECK(Proxy::IsMainThread());
+  DebugScopedSetImplThread impl(this);
   SetNeedsRedrawRectOnImplThread(damage_rect);
-  client_->ScheduleComposite();
 }
 
 void SingleThreadProxy::SetNextCommitWaitsForActivation() {
   // There is no activation here other than commit. So do nothing.
+  DCHECK(Proxy::IsMainThread());
 }
 
 void SingleThreadProxy::SetDeferCommits(bool defer_commits) {
-  // Thread-only feature.
-  NOTREACHED();
+  DCHECK(Proxy::IsMainThread());
+  if (defer_commits_ == defer_commits)
+    return;
+
+  defer_commits_ = defer_commits;
+  if (!defer_commits_ && finish_commit_deferred_) {
+    scheduler_on_impl_thread_->FinishCommit();
+    finish_commit_deferred_ = false;
+  }
 }
 
-bool SingleThreadProxy::CommitRequested() const { return false; }
+bool SingleThreadProxy::CommitRequested() const {
+  DCHECK(Proxy::IsMainThread());
+  return finish_commit_deferred_;
+}
 
-bool SingleThreadProxy::BeginMainFrameRequested() const { return false; }
+bool SingleThreadProxy::BeginMainFrameRequested() const {
+  DCHECK(Proxy::IsMainThread());
+  return finish_commit_deferred_;
+}
 
 size_t SingleThreadProxy::MaxPartialTextureUpdates() const {
   return std::numeric_limits<size_t>::max();
 }
 
 void SingleThreadProxy::Stop() {
   TRACE_EVENT0("cc", "SingleThreadProxy::stop");
   DCHECK(Proxy::IsMainThread());
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
     DebugScopedSetImplThread impl(this);
 
     layer_tree_host_->DeleteContentsTexturesOnImplThread(
         layer_tree_host_impl_->resource_provider());
+    scheduler_on_impl_thread_.reset();
     layer_tree_host_impl_.reset();
   }
   layer_tree_host_ = NULL;
 }
 
 void SingleThreadProxy::OnCanDrawStateChanged(bool can_draw) {
   TRACE_EVENT1(
       "cc", "SingleThreadProxy::OnCanDrawStateChanged", "can_draw", can_draw);
   DCHECK(Proxy::IsImplThread());
   UpdateBackgroundAnimateTicking();
+  scheduler_on_impl_thread_->SetCanDraw(can_draw);
 }
 
 void SingleThreadProxy::NotifyReadyToActivate() {
-  // Thread-only feature.
+  // Impl-side painting only.
   NOTREACHED();
 }
 
 void SingleThreadProxy::SetNeedsRedrawOnImplThread() {
-  client_->ScheduleComposite();
+  scheduler_on_impl_thread_->SetNeedsRedraw();
 }
 
 void SingleThreadProxy::SetNeedsManageTilesOnImplThread() {
-  // Thread-only/Impl-side-painting-only feature.
+  // Impl-side painting only.
   NOTREACHED();
 }
 
 void SingleThreadProxy::SetNeedsRedrawRectOnImplThread(
     const gfx::Rect& damage_rect) {
-  // TODO(brianderson): Once we move render_widget scheduling into this class,
-  // we can treat redraw requests more efficiently than CommitAndRedraw
-  // requests.
   layer_tree_host_impl_->SetViewportDamage(damage_rect);
-  SetNeedsCommit();
+  SetNeedsRedrawOnImplThread();
 }
 
 void SingleThreadProxy::DidInitializeVisibleTileOnImplThread() {
   // Impl-side painting only.
   NOTREACHED();
 }
 
 void SingleThreadProxy::SetNeedsCommitOnImplThread() {
-  client_->ScheduleComposite();
+  scheduler_on_impl_thread_->SetNeedsCommit();
 }
 
 void SingleThreadProxy::PostAnimationEventsToMainThreadOnImplThread(
     scoped_ptr<AnimationEventsVector> events,
     base::Time wall_clock_time) {
   TRACE_EVENT0(
       "cc", "SingleThreadProxy::PostAnimationEventsToMainThreadOnImplThread");
   DCHECK(Proxy::IsImplThread());
   DebugScopedSetMainThread main(this);
   layer_tree_host_->SetAnimationEvents(events.Pass(), wall_clock_time);
@@ skipping 26 matching lines @@
     return;
 
   layer_tree_host_impl_->SendManagedMemoryStats(
       contents_texture_manager->MemoryVisibleBytes(),
       contents_texture_manager->MemoryVisibleAndNearbyBytes(),
       contents_texture_manager->MemoryUseBytes());
 }
 
 bool SingleThreadProxy::IsInsideDraw() { return inside_draw_; }
 
+void SingleThreadProxy::DidActivatePendingTree() {
+  // Impl-side painting only.
+  NOTREACHED();
+}
+
+void SingleThreadProxy::DidManageTiles() {
+  // Impl-side painting only.
+  NOTREACHED();
+}
+
 void SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() {
   TRACE_EVENT0("cc", "SingleThreadProxy::DidLoseOutputSurfaceOnImplThread");
-  // Cause a commit so we can notice the lost context.
-  SetNeedsCommitOnImplThread();
+  {
+    DebugScopedSetMainThread main(this);
+    // This must happen before we notify the scheduler as it may try to recreate
+    // the output surface if already in BEGIN_IMPL_FRAME_STATE_IDLE.
+    layer_tree_host_->DidLoseOutputSurface();
+  }
+
+  // TODO(enne): this client call could maybe be removed.
   client_->DidAbortSwapBuffers();
+
+  scheduler_on_impl_thread_->DidLoseOutputSurface();
 }
 
 void SingleThreadProxy::DidSwapBuffersOnImplThread() {
+  // TODO(enne): Maybe this is redundant with DidCommitAndDrawFrame and can be
+  // removed?
   client_->DidPostSwapBuffers();
 }
 
 void SingleThreadProxy::OnSwapBuffersCompleteOnImplThread() {
   TRACE_EVENT0("cc", "SingleThreadProxy::OnSwapBuffersCompleteOnImplThread");
   client_->DidCompleteSwapBuffers();
 }
 
-// Called by the legacy scheduling path (e.g. where render_widget does the
-// scheduling)
+void SingleThreadProxy::BeginImplFrame(const BeginFrameArgs& args) {
+  TRACE_EVENT0("cc", "ThreadProxy::BeginImplFrame");
+  scheduler_on_impl_thread_->BeginImplFrame(args);
+}
+
 void SingleThreadProxy::CompositeImmediately(base::TimeTicks frame_begin_time) {
   TRACE_EVENT0("cc", "SingleThreadProxy::CompositeImmediately");
+  bool do_commit = true;
+  bool for_readback = false;
   gfx::Rect device_viewport_damage_rect;
-
-  LayerTreeHostImpl::FrameData frame;
-  if (CommitAndComposite(frame_begin_time,
-                         device_viewport_damage_rect,
-                         false,  // for_readback
-                         &frame)) {
-    {
-      DebugScopedSetMainThreadBlocked main_thread_blocked(this);
-      DebugScopedSetImplThread impl(this);
-
-      // This CapturePostTasks should be destroyed before
-      // DidCommitAndDrawFrame() is called since that goes out to the embedder,
-      // and we want the embedder to receive its callbacks before that.
-      // NOTE: This maintains consistent ordering with the ThreadProxy since
-      // the DidCommitAndDrawFrame() must be post-tasked from the impl thread
-      // there as the main thread is not blocked, so any posted tasks inside
-      // the swap buffers will execute first.
-      BlockingTaskRunner::CapturePostTasks blocked;
-
-      layer_tree_host_impl_->SwapBuffers(frame);
-    }
-    DidSwapFrame();
-  }
+  CommitAndCompositeInternal(gfx::FrameTime::Now(),
+                             device_viewport_damage_rect,
+                             do_commit,
+                             for_readback);
 }
 
 scoped_ptr<base::Value> SingleThreadProxy::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   {
     // The following line casts away const modifiers because it is just
     // setting debug state. We still want the AsValue() function and its
     // call chain to be const throughout.
     DebugScopedSetImplThread impl(const_cast<SingleThreadProxy*>(this));
 
     state->Set("layer_tree_host_impl",
                layer_tree_host_impl_->AsValue().release());
   }
   return state.PassAs<base::Value>();
 }
 
 void SingleThreadProxy::ForceSerializeOnSwapBuffers() {
   {
     DebugScopedSetImplThread impl(this);
     if (layer_tree_host_impl_->renderer()) {
       DCHECK(!layer_tree_host_->output_surface_lost());
       layer_tree_host_impl_->renderer()->DoNoOp();
     }
   }
 }
 
-bool SingleThreadProxy::CommitAndComposite(
-    base::TimeTicks frame_begin_time,
-    const gfx::Rect& device_viewport_damage_rect,
-    bool for_readback,
-    LayerTreeHostImpl::FrameData* frame) {
-  TRACE_EVENT0("cc", "SingleThreadProxy::CommitAndComposite");
-  DCHECK(Proxy::IsMainThread());
+bool SingleThreadProxy::ShouldComposite() const {
+  DCHECK(Proxy::IsImplThread());
+  return scheduler_on_impl_thread_->WillDrawIfNeeded();
+}
 
-  if (!layer_tree_host_->InitializeOutputSurfaceIfNeeded())
-    return false;
+void SingleThreadProxy::UpdateBackgroundAnimateTicking() {
+  DCHECK(Proxy::IsImplThread());
+  layer_tree_host_impl_->UpdateBackgroundAnimateTicking(
+      !ShouldComposite() && layer_tree_host_impl_->active_tree()->root_layer());
+}
 
-  layer_tree_host_->AnimateLayers(frame_begin_time);
-
-  if (PrioritizedResourceManager* contents_texture_manager =
-      layer_tree_host_->contents_texture_manager()) {
-    contents_texture_manager->UnlinkAndClearEvictedBackings();
-    contents_texture_manager->SetMaxMemoryLimitBytes(
-        layer_tree_host_impl_->memory_allocation_limit_bytes());
-    contents_texture_manager->SetExternalPriorityCutoff(
-        layer_tree_host_impl_->memory_allocation_priority_cutoff());
-  }
-
-  scoped_ptr<ResourceUpdateQueue> queue =
-      make_scoped_ptr(new ResourceUpdateQueue);
-  layer_tree_host_->UpdateLayers(queue.get());
-
-  layer_tree_host_->WillCommit();
-
+scoped_refptr<ContextProvider> SingleThreadProxy::OffscreenContextProvider() {
   scoped_refptr<ContextProvider> offscreen_context_provider;
   if (renderer_capabilities_for_main_thread_.using_offscreen_context3d &&
       layer_tree_host_->needs_offscreen_context()) {
     offscreen_context_provider =
         layer_tree_host_->client()->OffscreenContextProvider();
     if (offscreen_context_provider.get() &&
         !offscreen_context_provider->BindToCurrentThread())
       offscreen_context_provider = NULL;
 
     if (offscreen_context_provider.get())
       created_offscreen_context_provider_ = true;
   }
-
-  DoCommit(queue.Pass());
-  bool result = DoComposite(offscreen_context_provider,
-                            frame_begin_time,
-                            device_viewport_damage_rect,
-                            for_readback,
-                            frame);
-  layer_tree_host_->DidBeginMainFrame();
-  return result;
+  return offscreen_context_provider;
 }
 
-bool SingleThreadProxy::ShouldComposite() const {
-  DCHECK(Proxy::IsImplThread());
-  return layer_tree_host_impl_->visible() &&
-         layer_tree_host_impl_->CanDraw();
-}
-
-void SingleThreadProxy::UpdateBackgroundAnimateTicking() {
-  DCHECK(Proxy::IsImplThread());
-  layer_tree_host_impl_->UpdateBackgroundAnimateTicking(
-      !ShouldComposite() && layer_tree_host_impl_->active_tree()->root_layer());
-}
-
-bool SingleThreadProxy::DoComposite(
+DrawSwapReadbackResult::DrawResult SingleThreadProxy::DoComposite(
     scoped_refptr<ContextProvider> offscreen_context_provider,
     base::TimeTicks frame_begin_time,
     const gfx::Rect& device_viewport_damage_rect,
     bool for_readback,
     LayerTreeHostImpl::FrameData* frame) {
   TRACE_EVENT0("cc", "SingleThreadProxy::DoComposite");
   DCHECK(!layer_tree_host_->output_surface_lost());
 
   bool lost_output_surface = false;
   {
     DebugScopedSetImplThread impl(this);
     base::AutoReset<bool> mark_inside(&inside_draw_, true);
 
     layer_tree_host_impl_->SetOffscreenContextProvider(
         offscreen_context_provider);
 
     bool can_do_readback = layer_tree_host_impl_->renderer()->CanReadPixels();
 
     // We guard PrepareToDraw() with CanDraw() because it always returns a valid
     // frame, so can only be used when such a frame is possible. Since
     // DrawLayers() depends on the result of PrepareToDraw(), it is guarded on
     // CanDraw() as well.
     if (!ShouldComposite() || (for_readback && !can_do_readback)) {
       UpdateBackgroundAnimateTicking();
-      return false;
+      return DrawSwapReadbackResult::DRAW_ABORTED_CANT_DRAW;
     }
 
     layer_tree_host_impl_->Animate(
         layer_tree_host_impl_->CurrentFrameTimeTicks(),
         layer_tree_host_impl_->CurrentFrameTime());
     UpdateBackgroundAnimateTicking();
 
     if (!layer_tree_host_impl_->IsContextLost()) {
       layer_tree_host_impl_->PrepareToDraw(frame, device_viewport_damage_rect);
       layer_tree_host_impl_->DrawLayers(frame, frame_begin_time);
       layer_tree_host_impl_->DidDrawAllLayers(*frame);
     }
     lost_output_surface = layer_tree_host_impl_->IsContextLost();
 
     bool start_ready_animations = true;
     layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
 
     layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
   }
 
   if (lost_output_surface) {
     ContextProvider* offscreen_contexts =
         layer_tree_host_impl_->offscreen_context_provider();
     if (offscreen_contexts)
       offscreen_contexts->VerifyContexts();
-    layer_tree_host_->DidLoseOutputSurface();
-    return false;
+    DidLoseOutputSurfaceOnImplThread();
+    if (for_readback)
+      return DrawSwapReadbackResult::DRAW_ABORTED_CONTEXT_LOST;
   }
 
-  return true;
+  return DrawSwapReadbackResult::DRAW_SUCCESS;
 }
 
-void SingleThreadProxy::DidSwapFrame() {
+void SingleThreadProxy::DidCommitAndDrawFrame() {
   if (next_frame_is_newly_committed_frame_) {
     next_frame_is_newly_committed_frame_ = false;
     layer_tree_host_->DidCommitAndDrawFrame();
   }
 }
 
 bool SingleThreadProxy::CommitPendingForTesting() { return false; }
 
+scoped_ptr<base::Value> SingleThreadProxy::SchedulerStateAsValueForTesting() {
+  DebugScopedSetImplThread impl(this);
+  return scheduler_on_impl_thread_->StateAsValue().Pass();
+}
+
+void SingleThreadProxy::SetNeedsBeginImplFrame(bool enable) {
+  if (OutputSurface* surface = layer_tree_host_impl_->output_surface())
+    surface->SetNeedsBeginImplFrame(enable);
+}
+
+void SingleThreadProxy::ScheduledActionSendBeginMainFrame() {
+  if (defer_commits_) {
+    DCHECK(!finish_commit_deferred_);
+    finish_commit_deferred_ = true;
+    return;
+  }
+  timing_history_.DidBeginMainFrame();
+
+  // This is poorly named, but tells the scheduler that we are ready to
+  // start the commit.  In threaded mode, this is when the uploads are done.
+  // In single-threaded mode, it doesn't really matter.  Doing no work here
+  // and all the work in commit prevents needless carrying of state (like
+  // the upload queue) from BeginMainFrame to commit.
+  scheduler_on_impl_thread_->FinishCommit();
+}
+
+DrawSwapReadbackResult
+SingleThreadProxy::ScheduledActionDrawAndSwapIfPossible() {
+  bool do_commit = false;
+  bool for_readback = false;
+  gfx::Rect device_viewport_damage_rect;
+  return CommitAndCompositeInternal(gfx::FrameTime::Now(),
+                                    device_viewport_damage_rect,
+                                    do_commit,
+                                    for_readback);
+}
+
+DrawSwapReadbackResult SingleThreadProxy::ScheduledActionDrawAndSwapForced() {
+  return ScheduledActionDrawAndSwapIfPossible();
+}
+
+DrawSwapReadbackResult SingleThreadProxy::ScheduledActionDrawAndReadback() {
+  // The SingleThreadProxy never asks for a commit for readback,
+  // so this should never happen.
+  NOTREACHED();
+  DrawSwapReadbackResult result;
+  return result;
+}
+
+DrawSwapReadbackResult SingleThreadProxy::CommitAndCompositeInternal(
+    base::TimeTicks frame_begin_time,
+    gfx::Rect device_viewport_damage_rect,
+    bool do_commit,
+    bool for_readback) {
+  DCHECK(Proxy::IsMainThread());
+  DrawSwapReadbackResult result;
+
+  if (!layer_tree_host_->InitializeOutputSurfaceIfNeeded()) {
+    result.draw_result = DrawSwapReadbackResult::DRAW_ABORTED_CONTEXT_LOST;
+    return result;
+  }
+
+  if (do_commit)
+    DoCommit(frame_begin_time);
+
+  scoped_refptr<ContextProvider> offscreen_context_provider =
+      OffscreenContextProvider();

[danakj, 2014/02/20 20:56:40]

Hm ok one more question.

Is it going to be confusing that this is happening during Draw instead of during
commit here? It's definitely moving the ordering for this around in the
single-thread case too.

In the thread case, we do this during commit, since it comes from the main
thread. (Though maybe we don't need it at all in thread proxy anymore since
renderers don't have direct renderers, so idk). WDYT?

[enne (OOO), 2014/02/20 21:07:13]

Is there an ordering issue that you're concerned about here, or is this just an
inconsistency issue?

Looking at the original code, I don't see any reason this needed to be called
prior to DoCommit.

[danakj, 2014/02/20 21:09:47]

Just consistency. It comes to mind because when writing unit tests I've had to
do if (threaded) {} else {} many times because we called things at different
times. I've tried to eliminate those differences over time.

+  LayerTreeHostImpl::FrameData frame;
+  timing_history_.DidStartDrawing();
+  result.draw_result = DoComposite(offscreen_context_provider,
+                                   frame_begin_time,
+                                   device_viewport_damage_rect,
+                                   for_readback,
+                                   &frame);
+  if (result.draw_result != DrawSwapReadbackResult::DRAW_SUCCESS)
+    return result;
+
+  timing_history_.DidFinishDrawing();
+
+  result.did_readback = for_readback;
+
+  {
+    DebugScopedSetMainThreadBlocked main_thread_blocked(this);
+    DebugScopedSetImplThread impl(this);
+
+    // This CapturePostTasks should be destroyed before
+    // DidCommitAndDrawFrame() is called since that goes out to the embedder,
+    // and we want the embedder to receive its callbacks before that.
+    // NOTE: This maintains consistent ordering with the ThreadProxy since
+    // the DidCommitAndDrawFrame() must be post-tasked from the impl thread
+    // there as the main thread is not blocked, so any posted tasks inside
+    // the swap buffers will execute first.
+    BlockingTaskRunner::CapturePostTasks blocked;
+    result.did_swap = layer_tree_host_impl_->SwapBuffers(frame);
+  }
+
+  DidCommitAndDrawFrame();
+
+  return result;
+}
+
+void SingleThreadProxy::ScheduledActionCommit() {
+  DebugScopedSetMainThread main(this);
+  DoCommit(gfx::FrameTime::Now());
+}
+
+void SingleThreadProxy::ScheduledActionUpdateVisibleTiles() {
+  // Impl-side painting only.
+  NOTREACHED();
+}
+
+void SingleThreadProxy::ScheduledActionActivatePendingTree() {
+  // Impl-side painting only.
+  NOTREACHED();
+}
+
+void SingleThreadProxy::ScheduledActionBeginOutputSurfaceCreation() {
+  DebugScopedSetMainThread main(this);
+  layer_tree_host_->InitializeOutputSurfaceIfNeeded();
+}
+
+void SingleThreadProxy::ScheduledActionAcquireLayerTexturesForMainThread() {
+  scheduler_on_impl_thread_->SetMainThreadNeedsLayerTextures();
+}
+
+void SingleThreadProxy::ScheduledActionManageTiles() {
+  // Impl-side painting only.
+  NOTREACHED();
+}
+
+void SingleThreadProxy::DidAnticipatedDrawTimeChange(base::TimeTicks time) {}
+
+base::TimeDelta SingleThreadProxy::DrawDurationEstimate() {
+  return timing_history_.DrawDurationEstimate();
+}
+
+base::TimeDelta SingleThreadProxy::BeginMainFrameToCommitDurationEstimate() {
+  return timing_history_.BeginMainFrameToCommitDurationEstimate();
+}
+
+base::TimeDelta SingleThreadProxy::CommitToActivateDurationEstimate() {
+  return timing_history_.CommitToActivateDurationEstimate();
+}
+
+void SingleThreadProxy::PostBeginImplFrameDeadline(const base::Closure& closure,
+                                                   base::TimeTicks deadline) {
+  base::TimeDelta delta = deadline - gfx::FrameTime::Now();
+  if (delta <= base::TimeDelta())
+    delta = base::TimeDelta();
+  Proxy::MainThreadTaskRunner()->PostDelayedTask(FROM_HERE, closure, delta);
+}
+
+void SingleThreadProxy::DidBeginImplFrameDeadline() {
+  layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
+}
+
 }  // namespace cc