Add SwapPromise support to LayerTreeHost and LayerTreeImpl

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 24 matching lines @@
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion_tracker.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace {
 static int s_num_layer_tree_instances;
+const size_t kMaxQueuedSwapPromiseSize = 100;

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

where does this number come from?

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

see comments below.

 }
 
 namespace cc {
 
 RendererCapabilities::RendererCapabilities()
     : best_texture_format(RGBA_8888),
       using_partial_swap(false),
       using_set_visibility(false),
       using_egl_image(false),
       allow_partial_texture_updates(false),
@@ skipping 336 matching lines @@
     sync_tree->set_sent_page_scale_delta(1.f);
   }
 
   sync_tree->SetPageScaleFactorAndLimits(page_scale_factor_,
                                          min_page_scale_factor_,
                                          max_page_scale_factor_);
   sync_tree->SetPageScaleDelta(page_scale_delta / sent_page_scale_delta);
   sync_tree->SetLatencyInfo(latency_info_);
   latency_info_.Clear();
 
+  sync_tree->TakeSwapPromise(&swap_promise_list_);
+
   host_impl->SetViewportSize(device_viewport_size_);
   host_impl->SetOverdrawBottomHeight(overdraw_bottom_height_);
   host_impl->SetDeviceScaleFactor(device_scale_factor_);
   host_impl->SetDebugState(debug_state_);
   if (pending_page_scale_animation_) {
     host_impl->StartPageScaleAnimation(
         pending_page_scale_animation_->target_offset,
         pending_page_scale_animation_->use_anchor,
         pending_page_scale_animation_->scale,
         pending_page_scale_animation_->duration);
@@ skipping 872 matching lines @@
 }
 
 bool LayerTreeHost::ScheduleMicroBenchmark(
     const std::string& benchmark_name,
     scoped_ptr<base::Value> value,
     const MicroBenchmark::DoneCallback& callback) {
   return micro_benchmark_controller_.ScheduleRun(
       benchmark_name, value.Pass(), callback);
 }
 
+void LayerTreeHost::QueueSwapPromise(const SwapPromise& swap_promise) {
+  if (proxy_->HasImplThread()) {
+    DCHECK(proxy_->CommitRequested() || proxy_->BeginMainFrameRequested());
+  }
+  if (swap_promise_list_.size() > kMaxQueuedSwapPromiseSize) {
+    NOTREACHED() << "LayerTreeHost::swap_promise_list overflows";

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

i don't understand this. why have this limit?

does it ever make sense to have more than one swap promise on the main thread?

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

If SwapPromise is supposed to be used by different clients, then
there would be multiple clients inserting SwapPromise into the queue with
different behaviors of DidSwap() and DidNotSwap().

There is concern that in some rare case we could keep increasing the queue
unbounded without clearing them thus causing memory stress. So the limit is just
a guard against that. 

+    swap_promise_list_.clear();
+  }
+  swap_promise_list_.push_back(swap_promise);
+}
+
+bool LayerTreeHost::HasQueuedSwapPromise() {
+  return !swap_promise_list_.empty();
+}
+
+void LayerTreeHost::FinishSwapPromise() {
+  for (size_t i = 0; i < swap_promise_list_.size(); i++) {
+    swap_promise_list_[i].did_swap_callback.Run();
+  }
+  swap_promise_list_.clear();
+}
+
+void LayerTreeHost::BreakSwapPromise(const std::string& msg) {
+  for (size_t i = 0; i < swap_promise_list_.size(); i++) {
+    swap_promise_list_[i].swap_aborted_callback.Run(msg);
+  }
+  swap_promise_list_.clear();
+}
+
 }  // namespace cc