cc: Complete swap promise for aborted commit after pending activation.

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 360 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 125 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 119 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.

[brianderson, 2016/07/28 18:10:53]

Should this go inside the dcheck and be indented?

[sunnyps, 2016/08/02 02:55:09]

Done.

 #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 18 matching lines @@
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->NotifyReadyToCommit();
 }
 
 void SingleThreadProxy::BeginMainFrameAbortedOnImplThread(
     CommitEarlyOutReason reason) {
   DebugScopedSetImplThread impl(task_runner_provider_);
   DCHECK(scheduler_on_impl_thread_->CommitPending());
   DCHECK(!layer_tree_host_impl_->pending_tree());
 
-  layer_tree_host_impl_->BeginMainFrameAborted(reason);
+  std::vector<std::unique_ptr<SwapPromise>> empty_swap_promises;
+  layer_tree_host_impl_->BeginMainFrameAborted(reason,
+                                               std::move(empty_swap_promises));
   scheduler_on_impl_thread_->BeginMainFrameAborted(reason);
 }
 
 DrawResult SingleThreadProxy::ScheduledActionDrawAndSwapIfPossible() {
   DebugScopedSetImplThread impl(task_runner_provider_);
   LayerTreeHostImpl::FrameData frame;
   return DoComposite(&frame);
 }
 
 DrawResult SingleThreadProxy::ScheduledActionDrawAndSwapForced() {
@@ skipping 44 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