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 16 matching lines @@
       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),
       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.";
+
+  output_surface_creation_callback_.Reset(
+      base::Bind(&SingleThreadProxy::CreateAndInitializeOutputSurface,
+                 base::Unretained(this)));
 }
 
 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();
+    Proxy::MainThreadTaskRunner()->PostTask(
+        FROM_HERE, output_surface_creation_callback_.callback());

[danakj, 2014/02/19 20:42:39]

Looks like there's no reason to use a CancelableCallback here in single thread.
Just do the bind for the post task here and drop the callback member variable?

[enne (OOO), 2014/02/20 00:35:44]

This is because the STP could be destroyed before the PostTask occurs.  I could
add a weak pointer member variable here instead?

[danakj, 2014/02/20 19:30:55]

I see, ya I prefer a weak ptr factory. That'll make this more obvious what's
going on, and we can reuse it for other post tasks if we need to in the future.

[enne (OOO), 2014/02/20 20:01:39]

Done.

   }
 }
 
 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();

[danakj, 2014/02/19 20:42:39]

Is it a TODO to support SetNeedsUpdateLayers ie cancellable commit here?

[enne (OOO), 2014/02/20 00:35:44]

The cancellable commit is really about handling offscreen invalidations and
scrolling from the impl thread.  In general, I'm ok with saying that the STP
doesn't do this optimization because places where we use the STP don't need it. 
So, not even sure if it merits a TODO.

[danakj, 2014/02/20 19:30:55]

Or possibly occluded invalidations? That will be super common.

[enne (OOO), 2014/02/20 20:01:39]

These don't happen with impl-side painting, so...

[danakj, 2014/02/20 20:06:34]

 2014/02/20 20:01:39, enne wrote:
But this patch has nothing to do with impl-side painting, we'd be using STP
without impl-side painting here. So, we'll be invalidating tab load spinners
that are not visible, not uploading any textures cuz they are occluded, then
committing and drawing for no reason?  And we need to add occlusion something to
the browser compositor anyway. Idk, I thought this seemed more clear, am I way
off?

 }
 
-void SingleThreadProxy::DoCommit(scoped_ptr<ResourceUpdateQueue> queue) {
+void SingleThreadProxy::DoCommit(base::TimeTicks frame_begin_time) {
   TRACE_EVENT0("cc", "SingleThreadProxy::DoCommit");
-  DCHECK(Proxy::IsMainThread());
+  // DCHECK(Proxy::IsMainThread());

[danakj, 2014/02/19 20:42:39]

commented out? impl and main blocked?

[enne (OOO), 2014/02/20 00:35:44]

Uncommented.

+  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;

[danakj, 2014/02/19 20:42:39]

I noticed that ThreadProxy sets scheduler visibility to the LTHI's visibility
here. Should we do that here too? Or is it pointless there?

[enne (OOO), 2014/02/20 00:35:44]

SingleThreadProxy handles it immediately, rather than on commit.

[danakj, 2014/02/20 19:30:55]

ThreadProxy does also, it passes it over to SetVisibleOnImplThread(). There it
sets Visible on LTHI and Scheduler. Everywhere just sets it on scheduler, so
maybe the thread proxy one is pointless?

[enne (OOO), 2014/02/20 20:01:39]

That's possible.  Maybe the scheduler needs to be kicked but the SetVisible is a
no-op.  *makes a note to look into it*

 }
 
 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 28 matching lines @@
   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::DidLoseOutputSurfaceOnImplThread() {
   TRACE_EVENT0("cc", "SingleThreadProxy::DidLoseOutputSurfaceOnImplThread");
-  // Cause a commit so we can notice the lost context.
-  SetNeedsCommitOnImplThread();
+  {
+    DebugScopedSetMainThread main(this);
+    // This must happen before did lose output surface as the scheduler

[danakj, 2014/02/19 20:42:39]

"before did lose output surface" -> "before we notify the scheduler" ?

[enne (OOO), 2014/02/20 00:35:44]

Done.

+    // may try to recreate the output surface if already in begin impl frame

[danakj, 2014/02/19 20:42:39]

"if already in begin impl frame idle"

i know all those words, but not what they mean like that

[enne (OOO), 2014/02/20 00:35:44]

"begin impl frame idle" => BEGIN_IMPL_FRAME_STATE_IDLE

+    // idle.
+    layer_tree_host_->DidLoseOutputSurface();
+  }
+
+  scheduler_on_impl_thread_->DidLoseOutputSurface();

[danakj, 2014/02/19 20:42:39]

usually calling the scheduler is the last thing in the function since it can
trigger the next state in the state machine. should this be below
DidAbortSwapBuffers?

[enne (OOO), 2014/02/20 00:35:44]

Seems safer.  Done.

   client_->DidAbortSwapBuffers();

[danakj, 2014/02/19 20:42:39]

This is going to be.. weird..  I think. The scheduler is going to call this
method when the surface is lost, from the context callback, right? Then this
will call out to ui::Compositor observers. But there was not swap in play.

And this callback seems to only exist for unit tests for ui::Compositor, which
were testing the old code you're deleting. So can we get rid of this method
entirely?

[enne (OOO), 2014/02/20 00:35:44]

I see this getting used in:
* render_widget_compositor.cc (for scheduling another composite, which maybe is
redundant with the scheduler)
* compositor.cc (for observers, here's real code at the end of this call:
https://code.google.com/p/chromium/codesearch#chromium/src/ash/wm/window_anim...)
* compositor_impl_android.cc (which eventually gets to
https://code.google.com/p/chromium/codesearch#chromium/src/content/browser/an...)

[danakj, 2014/02/20 19:30:55]

Uh, hm. Really not clear why losing the graphics context would cause animations
to stop... so weird. Can you TODO to remove this? This feels wrong like it
should not exist.

[enne (OOO), 2014/02/20 20:01:39]

Done.

 }
 
 void SingleThreadProxy::DidSwapBuffersOnImplThread() {
   client_->DidPostSwapBuffers();

[danakj, 2014/02/19 20:42:39]

Can we get rid of this too?

[enne (OOO), 2014/02/20 00:35:44]

For the compositor_impl_android.cc path, the abort/swap cases route together
into the above code.  So, tentatively no.

[danakj, 2014/02/20 19:30:55]

Hm, we already have DidCommitAndDrawFrame() which they could hook off. This
seems redundant and I think it exists because we created completely different
hooks for single vs threaded mode way back. Can you put a TODO to merge this and
remove it at least?

[enne (OOO), 2014/02/20 20:01:39]

Done.

 }
 
 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 layer_tree_host_impl_->visible() && layer_tree_host_impl_->CanDraw();

[danakj, 2014/02/19 20:42:39]

why is this based on visible and not on Scheduler::WillDrawIfNeeded() like in
the thread proxy?

[enne (OOO), 2014/02/20 00:35:44]

Done.

+}
 
-  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();
+  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() {}

[danakj, 2014/02/19 20:42:39]

NOTREACHED Impl-side painting only?

[enne (OOO), 2014/02/20 00:35:44]

Done.  Did this for a few other functions too.

+
+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