cc: Send all begin frames using a PostTask.

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/memory/ptr_util.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 62 matching lines @@
             scheduler_settings.using_synchronous_renderer_compositor,
             CompositorTimingHistory::BROWSER_UMA,
             layer_tree_host_->rendering_stats_instrumentation()));
 
     BeginFrameSource* frame_source = nullptr;
     if (!layer_tree_host_->settings().use_output_surface_begin_frame_source) {
       frame_source = external_begin_frame_source_.get();
       if (!scheduler_settings.throttle_frame_production) {
         // Unthrottled source takes precedence over external sources.
         unthrottled_begin_frame_source_.reset(new BackToBackBeginFrameSource(
-            base::MakeUnique<DelayBasedTimeSource>(
-                task_runner_provider_->MainThreadTaskRunner())));
+            task_runner_provider_->MainThreadTaskRunner()));
         frame_source = unthrottled_begin_frame_source_.get();
       }
       if (!frame_source) {
         synthetic_begin_frame_source_.reset(new DelayBasedBeginFrameSource(
-            base::MakeUnique<DelayBasedTimeSource>(
-                task_runner_provider_->MainThreadTaskRunner())));
+            task_runner_provider_->MainThreadTaskRunner()));
         frame_source = synthetic_begin_frame_source_.get();
       }
     }
 
     scheduler_on_impl_thread_ =
         Scheduler::Create(this, scheduler_settings, layer_tree_host_->id(),
                           task_runner_provider_->MainThreadTaskRunner(),
                           frame_source, std::move(compositor_timing_history));
   }
 
@@ skipping 269 matching lines @@
   layer_tree_host_ = NULL;
 }
 
 void SingleThreadProxy::SetMutator(std::unique_ptr<LayerTreeMutator> mutator) {
   DCHECK(task_runner_provider_->IsMainThread());
   DebugScopedSetImplThread impl(task_runner_provider_);
   layer_tree_host_impl_->SetLayerTreeMutator(std::move(mutator));
 }
 
 void SingleThreadProxy::OnCanDrawStateChanged(bool can_draw) {
-  TRACE_EVENT1(
-      "cc", "SingleThreadProxy::OnCanDrawStateChanged", "can_draw", can_draw);
+  TRACE_EVENT1("cc", "SingleThreadProxy::OnCanDrawStateChanged", "can_draw",
+               can_draw);
   DCHECK(task_runner_provider_->IsImplThread());
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->SetCanDraw(can_draw);
 }
 
 void SingleThreadProxy::NotifyReadyToActivate() {
   TRACE_EVENT0("cc", "SingleThreadProxy::NotifyReadyToActivate");
   DebugScopedSetImplThread impl(task_runner_provider_);
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->NotifyReadyToActivate();
@@ skipping 48 matching lines @@
 
 void SingleThreadProxy::PostAnimationEventsToMainThreadOnImplThread(
     std::unique_ptr<AnimationEvents> events) {
   TRACE_EVENT0(
       "cc", "SingleThreadProxy::PostAnimationEventsToMainThreadOnImplThread");
   DCHECK(task_runner_provider_->IsImplThread());
   DebugScopedSetMainThread main(task_runner_provider_);
   layer_tree_host_->SetAnimationEvents(std::move(events));
 }
 
-bool SingleThreadProxy::IsInsideDraw() { return inside_draw_; }
+bool SingleThreadProxy::IsInsideDraw() {
+  return inside_draw_;
+}
 
 void SingleThreadProxy::DidActivateSyncTree() {
   // Synchronously call to CommitComplete. Resetting
   // |commit_blocking_task_runner| would make sure all tasks posted during
   // commit/activation before CommitComplete.
   CommitComplete();
 }
 
 void SingleThreadProxy::WillPrepareTiles() {
   DCHECK(task_runner_provider_->IsImplThread());
@@ skipping 132 matching lines @@
     DidFinishImplFrame();
   }
 }
 
 bool SingleThreadProxy::SupportsImplScrolling() const {
   return false;
 }
 
 bool SingleThreadProxy::ShouldComposite() const {
   DCHECK(task_runner_provider_->IsImplThread());
-  return layer_tree_host_impl_->visible() &&
-         layer_tree_host_impl_->CanDraw();
+  return layer_tree_host_impl_->visible() && layer_tree_host_impl_->CanDraw();
 }
 
 void SingleThreadProxy::ScheduleRequestNewOutputSurface() {
   if (output_surface_creation_callback_.IsCancelled() &&
       !output_surface_creation_requested_) {
     output_surface_creation_callback_.Reset(
         base::Bind(&SingleThreadProxy::RequestNewOutputSurface,
                    weak_factory_.GetWeakPtr()));
     task_runner_provider_->MainThreadTaskRunner()->PostTask(
         FROM_HERE, output_surface_creation_callback_.callback());
@@ skipping 115 matching lines @@
   DCHECK(!inside_impl_frame_)
       << "WillBeginImplFrame called while already inside an impl frame!";
   inside_impl_frame_ = true;
 #endif
   layer_tree_host_impl_->WillBeginImplFrame(args);
 }
 
 void SingleThreadProxy::ScheduledActionSendBeginMainFrame(
     const BeginFrameArgs& begin_frame_args) {
   TRACE_EVENT0("cc", "SingleThreadProxy::ScheduledActionSendBeginMainFrame");
-  // Although this proxy is single-threaded, it's problematic to synchronously
-  // 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.
+// Although this proxy is single-threaded, it's problematic to synchronously
+// 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.
 #if DCHECK_IS_ON()
   DCHECK(inside_impl_frame_)
       << "BeginMainFrame should only be sent inside a BeginImplFrame";
 #endif
 
   task_runner_provider_->MainThreadTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&SingleThreadProxy::BeginMainFrame,
                             weak_factory_.GetWeakPtr(), begin_frame_args));
 }
 
@@ skipping 23 matching lines @@
   ScopedAbortRemainingSwapPromises swap_promise_checker(layer_tree_host_);
 
   if (!layer_tree_host_->visible()) {
     TRACE_EVENT_INSTANT0("cc", "EarlyOut_NotVisible", TRACE_EVENT_SCOPE_THREAD);
     BeginMainFrameAbortedOnImplThread(
         CommitEarlyOutReason::ABORTED_NOT_VISIBLE);
     return;
   }
 
   if (layer_tree_host_->output_surface_lost()) {
-    TRACE_EVENT_INSTANT0(
-        "cc", "EarlyOut_OutputSurfaceLost", TRACE_EVENT_SCOPE_THREAD);
+    TRACE_EVENT_INSTANT0("cc", "EarlyOut_OutputSurfaceLost",
+                         TRACE_EVENT_SCOPE_THREAD);
     BeginMainFrameAbortedOnImplThread(
         CommitEarlyOutReason::ABORTED_OUTPUT_SURFACE_LOST);
     return;
   }
 
   // Prevent new commits from being requested inside DoBeginMainFrame.
   // Note: We do not want to prevent SetNeedsAnimate from requesting
   // a commit here.
   commit_requested_ = true;
 
@@ skipping 83 matching lines @@
 void SingleThreadProxy::DidFinishImplFrame() {
   layer_tree_host_impl_->DidFinishImplFrame();
 #if DCHECK_IS_ON()
   DCHECK(inside_impl_frame_)
       << "DidFinishImplFrame called while not inside an impl frame!";
   inside_impl_frame_ = false;
 #endif
 }
 
 }  // namespace cc