cc: Single-threaded impl-side painting for unit tests

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"
 #include "cc/output/output_surface.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/resource_update_controller.h"
-#include "cc/trees/blocking_task_runner.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_single_thread_client.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/scoped_abort_remaining_swap_promises.h"
 #include "ui/gfx/frame_time.h"
 
 namespace cc {
 
 scoped_ptr<Proxy> SingleThreadProxy::Create(
     LayerTreeHost* layer_tree_host,
@@ skipping 13 matching lines @@
       timing_history_(layer_tree_host->rendering_stats_instrumentation()),
       next_frame_is_newly_committed_frame_(false),
       inside_draw_(false),
       defer_commits_(false),
       commit_was_deferred_(false),
       commit_requested_(false),
       weak_factory_(this) {
   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);
 }
 
 SingleThreadProxy::~SingleThreadProxy() {
   TRACE_EVENT0("cc", "SingleThreadProxy::~SingleThreadProxy");
   DCHECK(Proxy::IsMainThread());
@@ skipping 89 matching lines @@
   client_->ScheduleAnimation();
   SetNeedsCommit();
 }
 
 void SingleThreadProxy::SetNeedsUpdateLayers() {
   TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsUpdateLayers");
   DCHECK(Proxy::IsMainThread());
   SetNeedsCommit();
 }
 
-void SingleThreadProxy::DoCommit(const BeginFrameArgs& begin_frame_args) {
+void SingleThreadProxy::DoCommit() {
   TRACE_EVENT0("cc", "SingleThreadProxy::DoCommit");
   DCHECK(Proxy::IsMainThread());
-  layer_tree_host_->WillBeginMainFrame();
-  layer_tree_host_->BeginMainFrame(begin_frame_args);
-  layer_tree_host_->AnimateLayers(begin_frame_args.frame_time);
-  layer_tree_host_->Layout();
+
   commit_requested_ = false;
-
-  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(
-        blocking_main_thread_task_runner());
+    commit_blocking_task_runner_.reset(new BlockingTaskRunner::CapturePostTasks(
+        blocking_main_thread_task_runner()));
 
     layer_tree_host_impl_->BeginCommit();
 
     if (PrioritizedResourceManager* contents_texture_manager =
         layer_tree_host_->contents_texture_manager()) {
       contents_texture_manager->PushTexturePrioritiesToBackings();
     }
     layer_tree_host_->BeginCommitOnImplThread(layer_tree_host_impl_.get());
 
     scoped_ptr<ResourceUpdateController> update_controller =
         ResourceUpdateController::Create(
             NULL,
             MainThreadTaskRunner(),
-            queue.Pass(),
+            queue_for_commit_.Pass(),
             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();
 
 #if DCHECK_IS_ON
     // 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();
     benchmark_instrumentation::IssueMainThreadRenderingStatsEvent(
         stats_instrumentation->main_thread_rendering_stats());
     stats_instrumentation->AccumulateAndClearMainThreadStats();
   }
+
+  if (layer_tree_host_->settings().impl_side_painting) {
+    // TODO(enne): just commit directly to the active tree.
+    //
+    // Synchronously activate during commit to satisfy any potential
+    // SetNextCommitWaitsForActivation calls.  Unfortunately, the tree
+    // might not be ready to draw, so DidActivateSyncTree must set
+    // the flag to force the tree to not draw until textures are ready.
+    NotifyReadyToActivate();
+  } else {
+    CommitComplete();
+  }
+}
+
+void SingleThreadProxy::CommitComplete() {
+  DCHECK(!layer_tree_host_impl_->pending_tree())
+      << "Activation is expected to have synchronously occurred by now.";
+  DCHECK(commit_blocking_task_runner_);
+
+  DebugScopedSetMainThread main(this);
+  commit_blocking_task_runner_.reset();
   layer_tree_host_->CommitComplete();
   layer_tree_host_->DidBeginMainFrame();
   timing_history_.DidCommit();
 
   next_frame_is_newly_committed_frame_ = true;
 }
 
 void SingleThreadProxy::SetNeedsCommit() {
   DCHECK(Proxy::IsMainThread());
   DebugScopedSetImplThread impl(this);
   client_->ScheduleComposite();
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->SetNeedsCommit();
   commit_requested_ = true;
 }
 
 void SingleThreadProxy::SetNeedsRedraw(const gfx::Rect& damage_rect) {
   TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsRedraw");
   DCHECK(Proxy::IsMainThread());
   DebugScopedSetImplThread impl(this);
   client_->ScheduleComposite();
   SetNeedsRedrawRectOnImplThread(damage_rect);
 }
 
 void SingleThreadProxy::SetNextCommitWaitsForActivation() {
-  // There is no activation here other than commit. So do nothing.
+  // Activation always forced in commit, so nothing to do.
   DCHECK(Proxy::IsMainThread());
 }
 
 void SingleThreadProxy::SetDeferCommits(bool defer_commits) {
   DCHECK(Proxy::IsMainThread());
   // Deferring commits only makes sense if there's a scheduler.
   if (!scheduler_on_impl_thread_)
     return;
   if (defer_commits_ == defer_commits)
     return;
@@ skipping 48 matching lines @@
 void SingleThreadProxy::OnCanDrawStateChanged(bool can_draw) {
   TRACE_EVENT1(
       "cc", "SingleThreadProxy::OnCanDrawStateChanged", "can_draw", can_draw);
   DCHECK(Proxy::IsImplThread());
   UpdateBackgroundAnimateTicking();
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->SetCanDraw(can_draw);
 }
 
 void SingleThreadProxy::NotifyReadyToActivate() {
-  // Impl-side painting only.
-  NOTREACHED();
+  TRACE_EVENT0("cc", "SingleThreadProxy::NotifyReadyToActivate");
+  DebugScopedSetImplThread impl(this);
+  if (scheduler_on_impl_thread_)
+    scheduler_on_impl_thread_->NotifyReadyToActivate();
 }
 
 void SingleThreadProxy::SetNeedsRedrawOnImplThread() {
   client_->ScheduleComposite();
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->SetNeedsRedraw();
 }
 
 void SingleThreadProxy::SetNeedsAnimateOnImplThread() {
   SetNeedsRedrawOnImplThread();
 }
 
 void SingleThreadProxy::SetNeedsManageTilesOnImplThread() {
-  // Impl-side painting only.
-  NOTREACHED();
+  TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsManageTilesOnImplThread");
+  if (scheduler_on_impl_thread_)
+    scheduler_on_impl_thread_->SetNeedsManageTiles();
 }
 
 void SingleThreadProxy::SetNeedsRedrawRectOnImplThread(
     const gfx::Rect& damage_rect) {
   layer_tree_host_impl_->SetViewportDamage(damage_rect);
   SetNeedsRedrawOnImplThread();
 }
 
 void SingleThreadProxy::DidInitializeVisibleTileOnImplThread() {
-  // Impl-side painting only.
-  NOTREACHED();
+  TRACE_EVENT0("cc", "SingleThreadProxy::DidInitializeVisibleTileOnImplThread");
+  if (scheduler_on_impl_thread_)
+    scheduler_on_impl_thread_->SetNeedsRedraw();
 }
 
 void SingleThreadProxy::SetNeedsCommitOnImplThread() {
   client_->ScheduleComposite();
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->SetNeedsCommit();
 }
 
 void SingleThreadProxy::PostAnimationEventsToMainThreadOnImplThread(
     scoped_ptr<AnimationEventsVector> events) {
@@ skipping 16 matching lines @@
 
   if (!contents_texture_manager || !resource_provider)
     return false;
 
   return contents_texture_manager->ReduceMemoryOnImplThread(
       limit_bytes, priority_cutoff, resource_provider);
 }
 
 bool SingleThreadProxy::IsInsideDraw() { return inside_draw_; }
 
+void SingleThreadProxy::DidActivateSyncTree() {
+  // Non-impl-side painting finishes commit in DoCommit.  Impl-side painting
+  // defers until here to simulate SetNextCommitWaitsForActivation.
+  if (layer_tree_host_impl_->settings().impl_side_painting) {
+    // This is required because NotifyReadyToActivate gets called when
+    // the pending tree is not actually ready in the SingleThreadProxy.
+    layer_tree_host_impl_->active_tree()->SetRequiresHighResToDraw();
+
+    // Since activation could cause tasks to run, post CommitComplete
+    // separately so that it runs after these tasks.  This is the loose
+    // equivalent of blocking commit until activation and also running
+    // all tasks posted during commit/activation before CommitComplete.
+    MainThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&SingleThreadProxy::CommitComplete,
+                   weak_factory_.GetWeakPtr()));
+  }
+
+  UpdateBackgroundAnimateTicking();
+  timing_history_.DidActivateSyncTree();
+}
+
+void SingleThreadProxy::DidManageTiles() {
+  DCHECK(layer_tree_host_impl_->settings().impl_side_painting);
+  DCHECK(Proxy::IsImplThread());
+  if (scheduler_on_impl_thread_)
+    scheduler_on_impl_thread_->DidManageTiles();
+}
+
 void SingleThreadProxy::UpdateRendererCapabilitiesOnImplThread() {
   DCHECK(IsImplThread());
   renderer_capabilities_for_main_thread_ =
       layer_tree_host_impl_->GetRendererCapabilities().MainThreadCapabilities();
 }
 
-void SingleThreadProxy::DidManageTiles() {
-  // Impl-side painting only.
-  NOTREACHED();
-}
-
 void SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() {
   TRACE_EVENT0("cc", "SingleThreadProxy::DidLoseOutputSurfaceOnImplThread");
   {
     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();
   }
   client_->DidAbortSwapBuffers();
   if (scheduler_on_impl_thread_)
@@ skipping 11 matching lines @@
   TRACE_EVENT0("cc", "SingleThreadProxy::DidSwapBuffersCompleteOnImplThread");
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->DidSwapBuffersComplete();
   layer_tree_host_->DidCompleteSwapBuffers();
 }
 
 void SingleThreadProxy::CompositeImmediately(base::TimeTicks frame_begin_time) {
   TRACE_EVENT0("cc", "SingleThreadProxy::CompositeImmediately");
   DCHECK(Proxy::IsMainThread());
   DCHECK(!layer_tree_host_->output_surface_lost());
+  DCHECK(!layer_tree_host_impl_->settings().impl_side_painting)
+      << "Impl-side painting and synchronous compositing are not supported.";
 
-  BeginFrameArgs begin_frame_args = BeginFrameArgs::Create(
-      frame_begin_time, base::TimeTicks(), BeginFrameArgs::DefaultInterval());
-  DoCommit(begin_frame_args);
+  {
+    BeginFrameArgs begin_frame_args(
+        BeginFrameArgs::Create(frame_begin_time,
+                               base::TimeTicks(),
+                               BeginFrameArgs::DefaultInterval()));
+    DoBeginMainFrame(begin_frame_args);
+    DoCommit();
 
-  LayerTreeHostImpl::FrameData frame;
-  DoComposite(frame_begin_time, &frame);
+    DCHECK_EQ(0u, layer_tree_host_->num_queued_swap_promises())
+        << "Commit should always succeed and transfer promises.";
+  }
+
+  {
+    DebugScopedSetImplThread impl(const_cast<SingleThreadProxy*>(this));
+    LayerTreeHostImpl::FrameData frame;
+    DoComposite(frame_begin_time, &frame);
+
+    // DoComposite could abort, but because this is a synchronous composite
+    // another draw will never be scheduled, so break remaining promises.
+    layer_tree_host_impl_->active_tree()->BreakSwapPromises(
+        SwapPromise::SWAP_FAILS);

[enne (OOO), 2014/10/08 00:34:49]

Here's the one thing I'm not sure about.  I could add a separate swap promise
enum failure for DRAW_FAILS, but I don't think this is all that interesting
external to cc.  It might make the test better, but then ui::Event would have to
handle this case, even though it's really about the same as the swap failing, in
my mind.

Is this good, or do you think it'd be worth making it more explicit?

[danakj, 2014/10/08 19:40:31]

This is fine. The commit didn't abort, but the swap didn't happen. We use this
in ~LayerTreeImpl also.

+  }
 }
 
 void SingleThreadProxy::AsValueInto(base::debug::TracedValue* state) const {
   // 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->BeginDictionary("layer_tree_host_impl");
   layer_tree_host_impl_->AsValueInto(state);
@@ skipping 24 matching lines @@
   DCHECK(Proxy::IsImplThread());
   layer_tree_host_impl_->UpdateBackgroundAnimateTicking(
       !ShouldComposite() && layer_tree_host_impl_->active_tree()->root_layer());
 }
 
 DrawResult SingleThreadProxy::DoComposite(base::TimeTicks frame_begin_time,
                                           LayerTreeHostImpl::FrameData* frame) {
   TRACE_EVENT0("cc", "SingleThreadProxy::DoComposite");
   DCHECK(!layer_tree_host_->output_surface_lost());
 
+  DrawResult draw_result;
+  bool draw_frame;
   {
     DebugScopedSetImplThread impl(this);
     base::AutoReset<bool> mark_inside(&inside_draw_, true);
 
     // 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()) {
       UpdateBackgroundAnimateTicking();
       return DRAW_ABORTED_CANT_DRAW;
     }
 
     timing_history_.DidStartDrawing();
 
     layer_tree_host_impl_->Animate(
         layer_tree_host_impl_->CurrentBeginFrameArgs().frame_time);
     UpdateBackgroundAnimateTicking();
 
-    layer_tree_host_impl_->PrepareToDraw(frame);
-    layer_tree_host_impl_->DrawLayers(frame, frame_begin_time);
+    draw_result = layer_tree_host_impl_->PrepareToDraw(frame);
+    draw_frame = draw_result == DRAW_SUCCESS;
+    if (draw_frame)
+      layer_tree_host_impl_->DrawLayers(frame, frame_begin_time);
     layer_tree_host_impl_->DidDrawAllLayers(*frame);
 
-    bool start_ready_animations = true;
+    bool start_ready_animations = draw_frame;
     layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
-
     layer_tree_host_impl_->ResetCurrentBeginFrameArgsForNextFrame();
 
     timing_history_.DidFinishDrawing();
   }
 
-  {
+  if (draw_frame) {
     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.
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
     BlockingTaskRunner::CapturePostTasks blocked(
         blocking_main_thread_task_runner());
     layer_tree_host_impl_->SwapBuffers(*frame);
   }
   DidCommitAndDrawFrame();
 
-  return DRAW_SUCCESS;
+  return draw_result;
 }
 
 void SingleThreadProxy::DidCommitAndDrawFrame() {
   if (next_frame_is_newly_committed_frame_) {
     DebugScopedSetMainThread main(this);
     next_frame_is_newly_committed_frame_ = false;
     layer_tree_host_->DidCommitAndDrawFrame();
   }
 }
 
@@ skipping 25 matching lines @@
 }
 
 void SingleThreadProxy::BeginMainFrame() {
   if (defer_commits_) {
     DCHECK(!commit_was_deferred_);
     commit_was_deferred_ = true;
     layer_tree_host_->DidDeferCommit();
     return;
   }
 
-  // This checker assumes NotifyReadyToCommit below causes a synchronous commit.
+  // This checker assumes NotifyReadyToCommit in this stack causes a synchronous
+  // commit.
   ScopedAbortRemainingSwapPromises swap_promise_checker(layer_tree_host_);
 
   if (!layer_tree_host_->visible()) {
     TRACE_EVENT_INSTANT0("cc", "EarlyOut_NotVisible", TRACE_EVENT_SCOPE_THREAD);
     BeginMainFrameAbortedOnImplThread();
     return;
   }
 
   if (layer_tree_host_->output_surface_lost()) {
     TRACE_EVENT_INSTANT0(
         "cc", "EarlyOut_OutputSurfaceLost", TRACE_EVENT_SCOPE_THREAD);
     BeginMainFrameAbortedOnImplThread();
     return;
   }
 
+  const BeginFrameArgs& begin_frame_args =
+      layer_tree_host_impl_->CurrentBeginFrameArgs();
+  DoBeginMainFrame(begin_frame_args);
+}
+
+void SingleThreadProxy::DoBeginMainFrame(
+    const BeginFrameArgs& begin_frame_args) {
+  layer_tree_host_->WillBeginMainFrame();
+  layer_tree_host_->BeginMainFrame(begin_frame_args);
+  layer_tree_host_->AnimateLayers(begin_frame_args.frame_time);
+  layer_tree_host_->Layout();
+
+  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());
+  }
+
+  DCHECK(!queue_for_commit_);
+  queue_for_commit_ = make_scoped_ptr(new ResourceUpdateQueue);
+
+  layer_tree_host_->UpdateLayers(queue_for_commit_.get());
+
   timing_history_.DidBeginMainFrame();
 
-  DCHECK(scheduler_on_impl_thread_);
-  scheduler_on_impl_thread_->NotifyBeginMainFrameStarted();
-  scheduler_on_impl_thread_->NotifyReadyToCommit();
+  if (scheduler_on_impl_thread_) {
+    scheduler_on_impl_thread_->NotifyBeginMainFrameStarted();
+    scheduler_on_impl_thread_->NotifyReadyToCommit();
+  }
 }
 
 void SingleThreadProxy::BeginMainFrameAbortedOnImplThread() {
   DebugScopedSetImplThread impl(this);
   DCHECK(scheduler_on_impl_thread_->CommitPending());
   DCHECK(!layer_tree_host_impl_->pending_tree());
 
   // TODO(enne): SingleThreadProxy does not support cancelling commits yet so
   // did_handle is always false.
   bool did_handle = false;
   layer_tree_host_impl_->BeginMainFrameAborted(did_handle);
   scheduler_on_impl_thread_->BeginMainFrameAborted(did_handle);
 }
 
 DrawResult SingleThreadProxy::ScheduledActionDrawAndSwapIfPossible() {
   DebugScopedSetImplThread impl(this);
   LayerTreeHostImpl::FrameData frame;
   return DoComposite(layer_tree_host_impl_->CurrentBeginFrameArgs().frame_time,
                      &frame);
 }
 
 DrawResult SingleThreadProxy::ScheduledActionDrawAndSwapForced() {
   NOTREACHED();
   return INVALID_RESULT;
 }
 
 void SingleThreadProxy::ScheduledActionCommit() {
   DebugScopedSetMainThread main(this);
-  DoCommit(layer_tree_host_impl_->CurrentBeginFrameArgs());
+  DoCommit();
 }
 
 void SingleThreadProxy::ScheduledActionAnimate() {
   TRACE_EVENT0("cc", "ScheduledActionAnimate");
   layer_tree_host_impl_->Animate(
       layer_tree_host_impl_->CurrentBeginFrameArgs().frame_time);
 }
 
 void SingleThreadProxy::ScheduledActionUpdateVisibleTiles() {
-  // Impl-side painting only.
-  NOTREACHED();
+  DebugScopedSetImplThread impl(this);
+  layer_tree_host_impl_->UpdateVisibleTiles();
 }
 
 void SingleThreadProxy::ScheduledActionActivateSyncTree() {
+  DebugScopedSetImplThread impl(this);
+  layer_tree_host_impl_->ActivateSyncTree();
 }
 
 void SingleThreadProxy::ScheduledActionBeginOutputSurfaceCreation() {
   DebugScopedSetMainThread main(this);
   DCHECK(scheduler_on_impl_thread_);
   // If possible, create the output surface in a post task.  Synchronously
   // creating the output surface makes tests more awkward since this differs
   // from the ThreadProxy behavior.  However, sometimes there is no
   // task runner.
   if (Proxy::MainThreadTaskRunner()) {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&SingleThreadProxy::RequestNewOutputSurface,
                    weak_factory_.GetWeakPtr()));
   } else {
     RequestNewOutputSurface();
   }
 }
 
 void SingleThreadProxy::ScheduledActionManageTiles() {
-  // Impl-side painting only.
-  NOTREACHED();
+  TRACE_EVENT0("cc", "SingleThreadProxy::ScheduledActionManageTiles");
+  DCHECK(layer_tree_host_impl_->settings().impl_side_painting);
+  DebugScopedSetImplThread impl(this);
+  layer_tree_host_impl_->ManageTiles();
 }
 
 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::DidBeginImplFrameDeadline() {
   layer_tree_host_impl_->ResetCurrentBeginFrameArgsForNextFrame();
 }
 
 }  // namespace cc