Move VISUAL_STATE promise to activation

cc/trees/layer_tree_host.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_host.h"
 
 #include <algorithm>
 #include <stack>
 #include <string>
 
@@ skipping 163 matching lines @@
 }
 
 LayerTreeHost::~LayerTreeHost() {
   TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
 
   if (root_layer_.get())
     root_layer_->SetLayerTreeHost(NULL);
 
   DCHECK(swap_promise_monitor_.empty());
 
-  BreakSwapPromises(SwapPromise::COMMIT_FAILS);
+  promises_.OnDidNotActivate(Promise::DidNotActivate::COMMIT_FAILS);
+  promises_.OnDidNotSwap(Promise::DidNotSwap::COMMIT_FAILS);
 
   if (proxy_) {
     DCHECK(proxy_->IsMainThread());
     proxy_->Stop();
   }
 
   // We must clear any pointers into the layer tree prior to destroying it.
   RegisterViewportLayers(NULL, NULL, NULL, NULL);
 
   if (root_layer_.get()) {
@@ skipping 131 matching lines @@
   }
 
   sync_tree->RegisterSelection(selection_);
 
   sync_tree->PushPageScaleFromMainThread(
       page_scale_factor_, min_page_scale_factor_, max_page_scale_factor_);
   sync_tree->elastic_overscroll()->PushFromMainThread(elastic_overscroll_);
   if (sync_tree->IsActiveTree())
     sync_tree->elastic_overscroll()->PushPendingToActive();
 
-  sync_tree->PassSwapPromises(&swap_promise_list_);
+  sync_tree->PassPromises(&promises_);
 
   sync_tree->set_top_controls_shrink_blink_size(
       top_controls_shrink_blink_size_);
   sync_tree->set_top_controls_height(top_controls_height_);
   sync_tree->PushTopControlsFromMainThread(top_controls_shown_ratio_);
 
   host_impl->set_has_gpu_rasterization_trigger(has_gpu_rasterization_trigger_);
   host_impl->set_content_is_suitable_for_gpu_rasterization(
       content_is_suitable_for_gpu_rasterization_);
   RecordGpuRasterizationHistogram();
@@ skipping 632 matching lines @@
 }
 
 void LayerTreeHost::ApplyScrollAndScale(ScrollAndScaleSet* info) {
   ScopedPtrVector<SwapPromise>::iterator it = info->swap_promises.begin();
   for (; it != info->swap_promises.end(); ++it) {
     scoped_ptr<SwapPromise> swap_promise(info->swap_promises.take(it));
     TRACE_EVENT_FLOW_STEP0("input",
                            "LatencyInfo.Flow",
                            TRACE_ID_DONT_MANGLE(swap_promise->TraceId()),
                            "Main thread scroll update");
-    QueueSwapPromise(swap_promise.Pass());
+    QueuePromise(swap_promise.Pass());
   }
 
   gfx::Vector2dF inner_viewport_scroll_delta;
   gfx::Vector2dF outer_viewport_scroll_delta;
 
   if (root_layer_.get()) {
     for (size_t i = 0; i < info->scrolls.size(); ++i) {
       Layer* layer = LayerTreeHostCommon::FindLayerInSubtree(
           root_layer_.get(), info->scrolls[i].layer_id);
       if (!layer)
@@ skipping 227 matching lines @@
 void LayerTreeHost::RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
   swap_promise_monitor_.erase(monitor);
 }
 
 void LayerTreeHost::NotifySwapPromiseMonitorsOfSetNeedsCommit() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsCommitOnMain();
 }
 
-void LayerTreeHost::QueueSwapPromise(scoped_ptr<SwapPromise> swap_promise) {
-  DCHECK(swap_promise);
-  swap_promise_list_.push_back(swap_promise.Pass());
+void LayerTreeHost::QueuePromise(scoped_ptr<Promise> promise) {
+  promises_.QueuePromise(promise.Pass());
 }
 
-void LayerTreeHost::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 LayerTreeHost::BreakSwapPromises(Promise::DidNotSwap::Reason reason) {
+  promises_.OnDidNotSwap(reason);
+}
+
+void LayerTreeHost::BreakActivationPromises(
+    Promise::DidNotActivate::Reason reason) {
+  promises_.OnDidNotActivate(reason);
 }
 
 void LayerTreeHost::set_surface_id_namespace(uint32_t id_namespace) {
   surface_id_namespace_ = id_namespace;
 }
 
 SurfaceSequence LayerTreeHost::CreateSurfaceSequence() {
   return SurfaceSequence(surface_id_namespace_, next_surface_sequence_++);
 }
 
 void LayerTreeHost::SetChildrenNeedBeginFrames(
     bool children_need_begin_frames) const {
   proxy_->SetChildrenNeedBeginFrames(children_need_begin_frames);
 }
 
 void LayerTreeHost::SendBeginFramesToChildren(
     const BeginFrameArgs& args) const {
   client_->SendBeginFramesToChildren(args);
 }
 
 void LayerTreeHost::SetAuthoritativeVSyncInterval(
     const base::TimeDelta& interval) {
   proxy_->SetAuthoritativeVSyncInterval(interval);
 }
 
 }  // namespace cc