Add SwapPromise support to LayerTreeHost and LayerTreeImpl

cc/trees/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/thread_proxy.h"
 
 #include <string>
+#include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/metrics/histogram.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/input/input_handler.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/scheduler/delay_based_time_source.h"
 #include "cc/scheduler/frame_rate_controller.h"
 #include "cc/scheduler/scheduler.h"
 #include "cc/trees/blocking_task_runner.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "ui/gfx/frame_time.h"
 
+namespace {
+
 // Measured in seconds.
 const double kSmoothnessTakesPriorityExpirationDelay = 0.25;
 
 const size_t kDurationHistorySize = 60;
 const double kCommitAndActivationDurationEstimationPercentile = 50.0;
 const double kDrawDurationEstimationPercentile = 100.0;
 const int kDrawDurationEstimatePaddingInMicroseconds = 0;
 
+class SwapPromiseChecker {
+ public:
+  explicit SwapPromiseChecker(cc::LayerTreeHost* layer_tree_host)
+        : layer_tree_host_(layer_tree_host) {}
+
+  ~SwapPromiseChecker() {
+    if (layer_tree_host_->HasQueuedSwapPromise())
+      layer_tree_host_->BreakSwapPromise("COMMIT ABORTED");
+  }
+
+ private:
+  cc::LayerTreeHost* layer_tree_host_;
+};
+
+}  // namespace
+
 namespace cc {
 
 struct ThreadProxy::ReadbackRequest {
   CompletionEvent completion;
   bool success;
   void* pixels;
   gfx::Rect rect;
 };
 
 struct ThreadProxy::CommitPendingRequest {
@@ skipping 678 matching lines @@
   if (!layer_tree_host_)
     return;
 
   if (defer_commits_) {
     pending_deferred_commit_ = begin_main_frame_state.Pass();
     layer_tree_host_->DidDeferCommit();
     TRACE_EVENT0("cc", "EarlyOut_DeferCommits");
     return;
   }
 
+  // If the commit finishes, LTH will transfer its swap promises to LTI.
+  // The dtor of SwapPromiseChecker will check LTH's swap promises, and
+  // call the swap aborted callback of the swap promises if the commit
+  // ever aborts.
+  SwapPromiseChecker swap_promise_checker(layer_tree_host_);

[jamesr, 2013/11/12 03:15:04]

it looks like this will invoke the aborted callback on the main thread

[Yufeng Shen (Slow to review), 2013/11/13 21:05:04]

See comments below.

+
   // Do not notify the impl thread of commit requests that occur during
   // the apply/animate/layout part of the BeginMainFrameAndCommit process since
   // those commit requests will get painted immediately. Once we have done
   // the paint, commit_requested_ will be set to false to allow new commit
   // requests to be scheduled.
   commit_requested_ = true;
   commit_request_sent_to_impl_thread_ = true;
 
   // On the other hand, the AnimationRequested flag needs to be cleared
   // here so that any animation requests generated by the apply or animate
@@ skipping 359 matching lines @@
       layer_tree_host_impl_->Readback(readback_request_on_impl_thread_->pixels,
                                       readback_request_on_impl_thread_->rect);
       result.did_readback = true;
     }
     readback_request_on_impl_thread_->success = result.did_readback;
     readback_request_on_impl_thread_->completion.Signal();
     readback_request_on_impl_thread_ = NULL;
   } else if (draw_frame) {
     DCHECK(swap_requested);
     result.did_swap = layer_tree_host_impl_->SwapBuffers(frame);
+    if (result.did_swap)
+      layer_tree_host_impl_->active_tree()->FinishSwapPromise();
+    else
+      layer_tree_host_impl_->active_tree()->BreakSwapPromise("DID NOT SWAP");

[jamesr, 2013/11/12 03:15:04]

whereas these calls will invoke callbacks from the compositor thread. is the
caller supposed to deal with this themselves? that seems like an extremely
error-prone interface if the callback is run and bound arguments destroyed from
different threads depending on what happens

what if we never make it to this point? for example, what if we lose the
OutputSurface in between the commit and the draw, or become invisible, or any
other case where the scheduler decides not to advance to drawing?

[Yufeng Shen (Slow to review), 2013/11/13 21:05:04]

Right.  I have in the new patch set changed the interface of
SwapPromise so that SwapPromise is now an abstract class that
has virtual interface  DidSwap() and DidNotSwap() which can
be called accordingly when swap buffer happens and fails.

I also put comments/warning that DidNotSwap() can happen
on main/impl thread. So it is better to have the subclass of
SwapPromise to carry the thread-safe member data (e.g. in
LatencyInfo case, copy the LatencyInfo into the a subclass
InputLatencySwapPromise), and so that when DidSwap/DidNotSwap()
are operating on the member data, it does not matter which thread
it is on.
An email thread "Swap Promises" was started for discussing this.

 
     // We don't know if we have incomplete tiles if we didn't actually swap.
     if (result.did_swap) {
       DCHECK(!frame.has_no_damage);
       SetSwapUsedIncompleteTileOnImplThread(frame.contains_incomplete_tile);
     }
   }
 
   // Tell the main thread that the the newly-commited frame was drawn.
   if (next_frame_is_newly_committed_frame_on_impl_thread_) {
@@ skipping 463 matching lines @@
     completion_event_for_commit_held_on_tree_activation_ = NULL;
   }
 
   UpdateBackgroundAnimateTicking();
 
   commit_to_activate_duration_history_.InsertSample(
       base::TimeTicks::HighResNow() - commit_complete_time_);
 }
 
 }  // namespace cc