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 18 matching lines @@
       .PassAs<Proxy>();
 }
 
 SingleThreadProxy::SingleThreadProxy(
     LayerTreeHost* layer_tree_host,
     LayerTreeHostSingleThreadClient* client,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner)
     : Proxy(main_task_runner, NULL),
       layer_tree_host_(layer_tree_host),
       client_(client),
+      timing_history_(layer_tree_host->rendering_stats_instrumentation()),
       next_frame_is_newly_committed_frame_(false),
-      inside_draw_(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() {
@@ skipping 19 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);
+  if (layer_tree_host_->settings().single_thread_proxy_scheduler &&
+      !scheduler_on_impl_thread_) {
+    SchedulerSettings scheduler_settings(layer_tree_host_->settings());
+    scheduler_on_impl_thread_ = Scheduler::Create(this,
+                                                  scheduler_settings,
+                                                  layer_tree_host_->id(),
+                                                  MainThreadTaskRunner());
+    scheduler_on_impl_thread_->SetCanStart();
+    scheduler_on_impl_thread_->SetVisible(layer_tree_host_impl_->visible());
+  }
 }
 
 void SingleThreadProxy::SetVisible(bool visible) {
   TRACE_EVENT0("cc", "SingleThreadProxy::SetVisible");
   DebugScopedSetImplThread impl(this);
   layer_tree_host_impl_->SetVisible(visible);
-
+  if (scheduler_on_impl_thread_)
+    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());
   DCHECK(layer_tree_host_->output_surface_lost());
 
   scoped_ptr<OutputSurface> output_surface =
       layer_tree_host_->CreateOutputSurface();
 
   renderer_capabilities_for_main_thread_ = RendererCapabilities();
 
   bool success = !!output_surface;
   if (success) {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
     DebugScopedSetImplThread impl(this);
     layer_tree_host_->DeleteContentsTexturesOnImplThread(
         layer_tree_host_impl_->resource_provider());
     success = layer_tree_host_impl_->InitializeRenderer(output_surface.Pass());
   }
 
   layer_tree_host_->OnCreateAndInitializeOutputSurfaceAttempted(success);
 
-  if (!success) {
-    // Force another recreation attempt to happen by requesting another commit.
-    SetNeedsCommit();
+  if (success) {
+    if (scheduler_on_impl_thread_)
+      scheduler_on_impl_thread_->DidCreateAndInitializeOutputSurface();
+  } else if (Proxy::MainThreadTaskRunner()) {
+    Proxy::MainThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&SingleThreadProxy::CreateAndInitializeOutputSurface,
+                   weak_factory_.GetWeakPtr()));
   }
 }
 
 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_->UpdateClientAnimations(frame_begin_time);
+  layer_tree_host_->AnimateLayers(frame_begin_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;
 
@@ 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();
+
 #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();
   }
   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);
-  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) {
+  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;
+
+  if (defer_commits)
+    TRACE_EVENT_ASYNC_BEGIN0("cc", "SingleThreadProxy::SetDeferCommits", this);
+  else
+    TRACE_EVENT_ASYNC_END0("cc", "SingleThreadProxy::SetDeferCommits", this);
+
+  defer_commits_ = defer_commits;
+  if (!defer_commits_ && commit_was_deferred_) {
+    scheduler_on_impl_thread_->NotifyBeginMainFrameStarted();
+    scheduler_on_impl_thread_->NotifyReadyToCommit();
+    commit_was_deferred_ = false;
+  }
 }
 
-bool SingleThreadProxy::CommitRequested() const { return false; }
+bool SingleThreadProxy::CommitRequested() const {
+  DCHECK(Proxy::IsMainThread());
+  return commit_requested_;
+}
 
-bool SingleThreadProxy::BeginMainFrameRequested() const { return false; }
+bool SingleThreadProxy::BeginMainFrameRequested() const {
+  DCHECK(Proxy::IsMainThread());
+  return commit_requested_;
+}
 
 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);
 
     BlockingTaskRunner::CapturePostTasks blocked;
     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();
+  if (scheduler_on_impl_thread_)
+    scheduler_on_impl_thread_->SetCanDraw(can_draw);
 }
 
 void SingleThreadProxy::NotifyReadyToActivate() {
-  // Thread-only feature.
+  // Impl-side painting only.
   NOTREACHED();
 }
 
 void SingleThreadProxy::SetNeedsRedrawOnImplThread() {
   client_->ScheduleComposite();
+  if (scheduler_on_impl_thread_)
+    scheduler_on_impl_thread_->SetNeedsRedraw();
 }
 
 void SingleThreadProxy::SetNeedsAnimateOnImplThread() {
   SetNeedsRedrawOnImplThread();
 }
 
 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();
+  if (scheduler_on_impl_thread_)
+    scheduler_on_impl_thread_->SetNeedsCommit();
 }
 
 void SingleThreadProxy::PostAnimationEventsToMainThreadOnImplThread(
     scoped_ptr<AnimationEventsVector> events) {
   TRACE_EVENT0(
       "cc", "SingleThreadProxy::PostAnimationEventsToMainThreadOnImplThread");
   DCHECK(Proxy::IsImplThread());
   DebugScopedSetMainThread main(this);
   layer_tree_host_->SetAnimationEvents(events.Pass());
 }
@@ skipping 16 matching lines @@
 }
 
 bool SingleThreadProxy::IsInsideDraw() { return inside_draw_; }
 
 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");
-  // 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();
+  }
   client_->DidAbortSwapBuffers();
+  if (scheduler_on_impl_thread_)
+    scheduler_on_impl_thread_->DidLoseOutputSurface();
 }
 
 void SingleThreadProxy::DidSwapBuffersOnImplThread() {
+  TRACE_EVENT0("cc", "SingleThreadProxy::DidSwapBuffersOnImplThread");
+  if (scheduler_on_impl_thread_)
+    scheduler_on_impl_thread_->DidSwapBuffers();
   client_->DidPostSwapBuffers();
 }
 
 void SingleThreadProxy::DidSwapBuffersCompleteOnImplThread() {
   TRACE_EVENT0("cc", "SingleThreadProxy::DidSwapBuffersCompleteOnImplThread");
-  client_->DidCompleteSwapBuffers();
+  if (scheduler_on_impl_thread_)
+    scheduler_on_impl_thread_->DidSwapBuffersComplete();
+  layer_tree_host_->DidCompleteSwapBuffers();
 }
 
-// Called by the legacy scheduling path (e.g. where render_widget does the
-// scheduling)
+void SingleThreadProxy::BeginFrame(const BeginFrameArgs& args) {
+  TRACE_EVENT0("cc", "SingleThreadProxy::BeginFrame");
+  if (scheduler_on_impl_thread_)
+    scheduler_on_impl_thread_->BeginImplFrame(args);
+}
+
 void SingleThreadProxy::CompositeImmediately(base::TimeTicks frame_begin_time) {
   TRACE_EVENT0("cc", "SingleThreadProxy::CompositeImmediately");
   DCHECK(Proxy::IsMainThread());
   DCHECK(!layer_tree_host_->output_surface_lost());
 
-  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();
-  DoCommit(queue.Pass());
-  layer_tree_host_->DidBeginMainFrame();
+  DoCommit(frame_begin_time);
 
   LayerTreeHostImpl::FrameData frame;
-  if (DoComposite(frame_begin_time, &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();
-  }
+  DoComposite(frame_begin_time, &frame);
 }
 
 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));
 
@@ skipping 22 matching lines @@
   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(
-    base::TimeTicks frame_begin_time,
-    LayerTreeHostImpl::FrameData* frame) {
+DrawResult SingleThreadProxy::DoComposite(base::TimeTicks frame_begin_time,
+                                          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);
 
     // 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 false;
+      return DRAW_ABORTED_CANT_DRAW;
     }
 
+    timing_history_.DidStartDrawing();
+
     layer_tree_host_impl_->Animate(
         layer_tree_host_impl_->CurrentFrameTimeTicks());
     UpdateBackgroundAnimateTicking();
 
     if (!layer_tree_host_impl_->IsContextLost()) {
       layer_tree_host_impl_->PrepareToDraw(frame);
       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();
+
+    timing_history_.DidFinishDrawing();
   }
 
-  if (lost_output_surface) {
-    layer_tree_host_->DidLoseOutputSurface();
-    return false;
+  {
+    DebugScopedSetImplThread impl(this);
+
+    if (layer_tree_host_impl_->IsContextLost()) {
+      DidLoseOutputSurfaceOnImplThread();
+    } else {
+      // 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;
+      layer_tree_host_impl_->SwapBuffers(*frame);
+    }
   }
+  DidCommitAndDrawFrame();
 
-  return true;
+  return DRAW_SUCCESS;
 }
 
-void SingleThreadProxy::DidSwapFrame() {
+void SingleThreadProxy::DidCommitAndDrawFrame() {
   if (next_frame_is_newly_committed_frame_) {
+    DebugScopedSetMainThread main(this);
     next_frame_is_newly_committed_frame_ = false;
     layer_tree_host_->DidCommitAndDrawFrame();
   }
 }
 
 bool SingleThreadProxy::CommitPendingForTesting() { return false; }
 
+scoped_ptr<base::Value> SingleThreadProxy::SchedulerAsValueForTesting() {
+  DebugScopedSetImplThread impl(this);
+  if (!scheduler_on_impl_thread_)
+    return make_scoped_ptr(base::Value::CreateNullValue()).Pass();
+  return scheduler_on_impl_thread_->AsValue().Pass();
+}
+
+void SingleThreadProxy::SetNeedsBeginFrame(bool enable) {
+  layer_tree_host_impl_->SetNeedsBeginFrame(enable);
+}
+
+void SingleThreadProxy::WillBeginImplFrame(const BeginFrameArgs& args) {
+  layer_tree_host_impl_->WillBeginImplFrame(args);
+}
+
+void SingleThreadProxy::ScheduledActionSendBeginMainFrame() {
+  TRACE_EVENT0("cc", "SingleThreadProxy::ScheduledActionSendBeginMainFrame");
+  // Although this proxy is single-threaded, it's problematic to synchronously

[enne (OOO), 2014/07/30 22:26:59]

This is the fix for the flakiness around window screenshot callbacks timing out
on Mac.  This was Mac-only because other browser compositors are threaded.

The details are that DelegatedFrameHost would set the new frame information and
then in the same function set the latency info (containing the swap promise
callbacks for the screenshot).  Because SingleThreadProxy is mostly synchronous,
setting the frame would call SetNeedsCommit which would poke the scheduler to
ProcessScheduledActions which would then ScheduledActionBeginMainFrame.  This
function prior to this patch would synchronously start the commit.  This meant
that DelegatedFrameHost caused a commit between setting two properties, causing
one to be committed in one frame (the frame info, with the damage) and the other
to be committed in the next (the swap promise).  Because the second commit had
no damage, the draw/swap would early out and abort, cancelling the promise, and
leaving the snapshot callback hanging.  This was flaky, because the commit would
only happen if the timing was in the right part of the frame deadline.  In some
cases, no commit would occur and the frame info and swap promise would be put
together in the same frame, successfully completing the test.

The fix for this is to just make SendBeginMainFrame asynchronously call
BeginMainFrame (like ThreadProxy does).  This prevents weird synchronous commits
in the middle of a series of property changes.

[piman, 2014/07/30 22:31:00]

Desktop Windows/Linux aren't threaded. That said I'm willing to believe Mac
quirks exposed it only there.
LGTM on that. Re-entrancy would cause problems.

+  // have BeginMainFrame happen after ScheduledActionSendBeginMainFrame.  This
+  // could cause a commit to occur in between a series of SetNeedsCommit calls
+  // (i.e. property modifications) causing some to fall on one frame and some to
+  // fall on the next.  Doing it asynchronously instead matches the semantics of
+  // ThreadProxy::SetNeedsCommit where SetNeedsCommit will not cause a
+  // synchronous commit.
+  Proxy::MainThreadTaskRunner()->PostTask(

[piman, 2014/07/30 22:31:00]

nit: no need for Proxy::

+      FROM_HERE,
+      base::Bind(&SingleThreadProxy::BeginMainFrame,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void SingleThreadProxy::BeginMainFrame() {
+  if (defer_commits_) {
+    DCHECK(!commit_was_deferred_);
+    commit_was_deferred_ = true;
+    layer_tree_host_->DidDeferCommit();
+    return;
+  }
+  timing_history_.DidBeginMainFrame();
+
+  DCHECK(scheduler_on_impl_thread_);
+  scheduler_on_impl_thread_->NotifyBeginMainFrameStarted();
+  scheduler_on_impl_thread_->NotifyReadyToCommit();
+}
+
+DrawResult SingleThreadProxy::ScheduledActionDrawAndSwapIfPossible() {
+  DebugScopedSetImplThread impl(this);
+  if (layer_tree_host_impl_->IsContextLost()) {
+    DidCommitAndDrawFrame();
+    return DRAW_SUCCESS;
+  }
+
+  LayerTreeHostImpl::FrameData frame;
+  return DoComposite(layer_tree_host_impl_->CurrentFrameTimeTicks(), &frame);
+}
+
+DrawResult SingleThreadProxy::ScheduledActionDrawAndSwapForced() {
+  NOTREACHED();
+  return INVALID_RESULT;
+}
+
+void SingleThreadProxy::ScheduledActionCommit() {
+  DebugScopedSetMainThread main(this);
+  DoCommit(layer_tree_host_impl_->CurrentFrameTimeTicks());
+}
+
+void SingleThreadProxy::ScheduledActionAnimate() {
+  TRACE_EVENT0("cc", "ScheduledActionAnimate");
+  layer_tree_host_impl_->Animate(
+      layer_tree_host_impl_->CurrentFrameTimeTicks());
+}
+
+void SingleThreadProxy::ScheduledActionUpdateVisibleTiles() {
+  // Impl-side painting only.
+  NOTREACHED();
+}
+
+void SingleThreadProxy::ScheduledActionActivateSyncTree() {
+}
+
+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()) {
+    Proxy::MainThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&SingleThreadProxy::CreateAndInitializeOutputSurface,
+                   weak_factory_.GetWeakPtr()));
+  } else {
+    CreateAndInitializeOutputSurface();
+  }
+}
+
+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::DidBeginImplFrameDeadline() {
+  layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
+}
+
 }  // namespace cc