Queue latency info swap promises in a separate already-active queue.

cc/trees/layer_tree_impl.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/layer_tree_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 206 matching lines @@
   // The request queue should have been processed and does not require a push.
   DCHECK_EQ(ui_resource_request_queue_.size(), 0u);
 
   target_tree->SetPropertyTrees(property_trees_);
 
   if (next_activation_forces_redraw_) {
     target_tree->ForceRedrawNextActivation();
     next_activation_forces_redraw_ = false;
   }
 
+  for (auto* swap_promise : pinned_swap_promise_list_)

[danakj, 2015/08/25 21:37:30]

Why is this here and not in DidBecomeActive like for the other list?

[Tobias Sargeant, 2015/08/26 11:06:49]

I've added a comment describing why this is here, but the problem is that
DidBecomeActive is called on the active tree (after unpinned promises are passed
to it), whereas pinned promises are retained by the pending tree and then fail
to swap with ACTIVATION_FAILED when the pending tree is deleted. To get around
that, we need to DidActivate the pinned swap promises and clear the pinned list
before the deletion occurs.

The other alternative would have been a new method on LTI that does the same
thing directly after PushPropertiesTo().

As it stands, I don't think that swap promise callbacks ever expect to be able
to access the pending/active tree, but maybe this should be pushed to as late as
possible in PushPropertiesTo? 

[danakj, 2015/08/26 18:16:16]

Is there a use case for pinned swap promises on the pending tree? Maybe we just
DCHECK IsActiveTree() somewhere and call it a day?

+    swap_promise->DidActivate();
+  pinned_swap_promise_list_.clear();
+
   target_tree->PassSwapPromises(&swap_promise_list_);
 
   target_tree->set_top_controls_shrink_blink_size(
       top_controls_shrink_blink_size_);
   target_tree->set_top_controls_height(top_controls_height_);
   target_tree->PushTopControls(nullptr);
 
   target_tree->set_hide_pinch_scrollbars_near_min_scale(
       hide_pinch_scrollbars_near_min_scale_);
 
@@ skipping 560 matching lines @@
   // if we were in a good state.
   layer_tree_host_impl_->ResetRequiresHighResToDraw();
 
   if (root_layer()) {
     LayerTreeHostCommon::CallFunctionForSubtree(
         root_layer(), [](LayerImpl* layer) { layer->DidBecomeActive(); });
   }
 
   for (auto* swap_promise : swap_promise_list_)
     swap_promise->DidActivate();
+

[danakj, 2015/08/25 21:37:31]

please don't add whitespace randomly

   devtools_instrumentation::DidActivateLayerTree(layer_tree_host_impl_->id(),
                                                  source_frame_number_);
 }
 
 bool LayerTreeImpl::RequiresHighResToDraw() const {
   return layer_tree_host_impl_->RequiresHighResToDraw();
 }
 
 bool LayerTreeImpl::ViewportSizeInvalid() const {
   return viewport_size_invalid_;
@@ skipping 207 matching lines @@
     if (!it.represents_itself())
       continue;
     TracedValue::AppendIDRef(*it, state);
   }
   state->EndArray();
 
   state->BeginArray("swap_promise_trace_ids");
   for (auto* swap_promise : swap_promise_list_)
     state->AppendDouble(swap_promise->TraceId());
   state->EndArray();
+
+  state->BeginArray("pinned_swap_promise_trace_ids");
+  for (auto* swap_promise : pinned_swap_promise_list_)
+    state->AppendDouble(swap_promise->TraceId());
+  state->EndArray();
 }
 
 void LayerTreeImpl::SetRootLayerScrollOffsetDelegate(
     LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) {
   if (root_layer_scroll_offset_delegate_ == root_layer_scroll_offset_delegate)
     return;
 
   root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate;
 
   if (root_layer_scroll_offset_delegate_) {
@@ skipping 57 matching lines @@
       inner_viewport_offset);
 
   UpdateRootScrollOffsetDelegate();
 }
 
 void LayerTreeImpl::QueueSwapPromise(scoped_ptr<SwapPromise> swap_promise) {
   DCHECK(swap_promise);
   swap_promise_list_.push_back(swap_promise.Pass());
 }
 
+void LayerTreeImpl::QueuePinnedSwapPromise(
+    scoped_ptr<SwapPromise> swap_promise) {
+  DCHECK(swap_promise);
+  pinned_swap_promise_list_.push_back(swap_promise.Pass());
+}
+
 void LayerTreeImpl::PassSwapPromises(
     ScopedPtrVector<SwapPromise>* new_swap_promise) {
-  swap_promise_list_.insert_and_take(swap_promise_list_.end(),
-                                     new_swap_promise);
-  new_swap_promise->clear();
+  for (auto* swap_promise : swap_promise_list_) {
+    swap_promise->DidNotSwap(SwapPromise::SWAP_FAILS);
+  }
+  swap_promise_list_.clear();
+  swap_promise_list_.swap(*new_swap_promise);
 }
 
 void LayerTreeImpl::FinishSwapPromises(CompositorFrameMetadata* metadata) {
   for (auto* swap_promise : swap_promise_list_)
     swap_promise->DidSwap(metadata);
   swap_promise_list_.clear();
+  for (auto* swap_promise : pinned_swap_promise_list_)
+    swap_promise->DidSwap(metadata);
+  pinned_swap_promise_list_.clear();
 }
 
 void LayerTreeImpl::BreakSwapPromises(SwapPromise::DidNotSwapReason reason) {
   for (auto* swap_promise : swap_promise_list_)
     swap_promise->DidNotSwap(reason);
   swap_promise_list_.clear();
+  for (auto* swap_promise : pinned_swap_promise_list_)
+    swap_promise->DidNotSwap(reason);
+  pinned_swap_promise_list_.clear();
 }
 
 void LayerTreeImpl::DidModifyTilePriorities() {
   layer_tree_host_impl_->DidModifyTilePriorities();
 }
 
 void LayerTreeImpl::set_ui_resource_request_queue(
     const UIResourceRequestQueue& queue) {
   ui_resource_request_queue_ = queue;
 }
@@ skipping 616 matching lines @@
                                                    const gfx::BoxF& box,
                                                    gfx::BoxF* bounds) const {
   *bounds = gfx::BoxF();
   return layer_tree_host_impl_->animation_host()
              ? layer_tree_host_impl_->animation_host()
                    ->TransformAnimationBoundsForBox(layer->id(), box, bounds)
              : true;
 }
 
 }  // namespace cc