Move VISUAL_STATE promise to activation

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 52 matching lines @@
       needs_full_tree_sync_(true),
       next_activation_forces_redraw_(false),
       has_ever_been_drawn_(false),
       render_surface_layer_list_id_(0),
       top_controls_shrink_blink_size_(false),
       top_controls_height_(0),
       top_controls_shown_ratio_(top_controls_shown_ratio) {
 }
 
 LayerTreeImpl::~LayerTreeImpl() {
-  BreakSwapPromises(SwapPromise::SWAP_FAILS);
+  promises_.OnDidNotActivate(Promise::DidNotActivate::ACTIVATION_FAILS);
+  promises_.OnDidNotSwap(Promise::DidNotSwap::SWAP_FAILS);
 
   // Need to explicitly clear the tree prior to destroying this so that
   // the LayerTreeImpl pointer is still valid in the LayerImpl dtor.
   DCHECK(!root_layer_);
   DCHECK(layers_with_copy_output_request_.empty());
 }
 
 void LayerTreeImpl::Shutdown() {
   root_layer_ = nullptr;
 }
@@ skipping 108 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;
   }
 
-  target_tree->PassSwapPromises(&swap_promise_list_);
+  target_tree->PassPromises(&promises_);
 
   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);
 
   // Active tree already shares the page_scale_factor object with pending
   // tree so only the limits need to be provided.
   target_tree->PushPageScaleFactorAndLimits(nullptr, min_page_scale_factor(),
                                             max_page_scale_factor());
@@ skipping 769 matching lines @@
   typedef LayerIterator<LayerImpl> LayerIteratorType;
   LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list_);
   for (LayerIteratorType it = LayerIteratorType::Begin(
            &render_surface_layer_list_); it != end; ++it) {
     if (!it.represents_itself())
       continue;
     TracedValue::AppendIDRef(*it, state);
   }
   state->EndArray();
 
-  state->BeginArray("swap_promise_trace_ids");
-  for (size_t i = 0; i < swap_promise_list_.size(); i++)
-    state->AppendDouble(swap_promise_list_[i]->TraceId());
+  state->BeginArray("promise_trace_ids");
+  std::vector<int64> trace_ids;
+  promises_.GetTraceIds(&trace_ids);
+  for (size_t i = 0; i < trace_ids.size(); i++)
+    state->AppendDouble(trace_ids[i]);
   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;
 
@@ skipping 53 matching lines @@
 
   OuterViewportScrollLayer()->SetCurrentScrollOffsetFromDelegate(
       outer_viewport_offset);
   inner_viewport_offset = root_offset - outer_viewport_offset;
   InnerViewportScrollLayer()->SetCurrentScrollOffsetFromDelegate(
       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::PassPromises(PromiseList* other) {
+  promises_.PassPromises(other);
 }
 
-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();
+void LayerTreeImpl::QueuePromise(scoped_ptr<Promise> promise) {
+  promises_.QueuePromise(promise.Pass());
+}
+
+void LayerTreeImpl::BreakSwapPromises(Promise::DidNotSwap::Reason reason) {
+  promises_.OnDidNotSwap(reason);
 }
 
 void LayerTreeImpl::FinishSwapPromises(CompositorFrameMetadata* metadata) {
-  for (size_t i = 0; i < swap_promise_list_.size(); i++)
-    swap_promise_list_[i]->DidSwap(metadata);
-  swap_promise_list_.clear();
+  promises_.OnDidSwap(metadata);
 }
 
-void LayerTreeImpl::BreakSwapPromises(SwapPromise::DidNotSwapReason reason) {
-  for (size_t i = 0; i < swap_promise_list_.size(); i++)
-    swap_promise_list_[i]->DidNotSwap(reason);
-  swap_promise_list_.clear();
+void LayerTreeImpl::BreakActivationPromises(Promise::DidNotActivate::Reason reason) {
+  promises_.OnDidNotActivate(reason);
+}
+
+void LayerTreeImpl::FinishActivationPromises(CompositorFrameMetadata* metadata) {
+  promises_.OnDidActivate(metadata);
 }
 
 void LayerTreeImpl::DidModifyTilePriorities() {
   layer_tree_host_impl_->DidModifyTilePriorities();
 }
 
 void LayerTreeImpl::set_ui_resource_request_queue(
     const UIResourceRequestQueue& queue) {
   ui_resource_request_queue_ = queue;
 }
@@ skipping 465 matching lines @@
     scoped_ptr<PendingPageScaleAnimation> pending_animation) {
   pending_page_scale_animation_ = pending_animation.Pass();
 }
 
 scoped_ptr<PendingPageScaleAnimation>
     LayerTreeImpl::TakePendingPageScaleAnimation() {
   return pending_page_scale_animation_.Pass();
 }
 
 }  // namespace cc