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 33 matching lines @@
 
 namespace {
 static base::LazyInstance<base::Lock>::Leaky
     s_next_tree_id_lock = LAZY_INSTANCE_INITIALIZER;
 
 inline int GetNextTreeId() {
   static int s_next_tree_id = 1;
   base::AutoLock lock(s_next_tree_id_lock.Get());
   return s_next_tree_id++;
 }
-}
+
+const size_t kMaxQueuedSwapPromiseSize = 100;
+}  // namespace
 
 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),
       using_offscreen_context3d(false),
@@ skipping 313 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_);

[danakj, 2013/11/13 23:22:09]

This sounds like we're taking the swap promises from the sync tree.. can this be
PassSwapPromises()?

[Yufeng Shen (Slow to review), 2013/11/14 22:09:55]

hmmm, "take" reads more correctly to me than "pass", and the 
implementation of TakeSwapPromise(other) is 
using ScopedPtrVector::insert_and_take(other)
swap_promise_list_.insert_and_take(..., other) 
which also uses "take".

[danakj, 2013/11/20 03:00:55]

I think insert_and_take() says "insert these things and call Take() on them to
take them from me". It's delegating the Take() responsibility rather than doing
a Take() action itself.

Whereas ScopedPtrVector::take() takes something out of the set.
Also LayerImpl::TakeCopyRequests..() takes the copy requests and returns them to
the caller.
https://code.google.com/p/chromium/codesearch#chromium/src/cc/layers/layer_im...

So I think the pattern is Take() means give me something back generally. And
Pass() means to give my thing to someone else.

[Yufeng Shen (Slow to review), 2013/11/20 19:15:41]

Done.

+
   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 859 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(SwapPromise* swap_promise) {
+  if (proxy_->HasImplThread()) {
+    DCHECK(proxy_->CommitRequested() || proxy_->BeginMainFrameRequested());
+  }
+  if (swap_promise_list_.size() > kMaxQueuedSwapPromiseSize) {
+    NOTREACHED() << "LayerTreeHost::swap_promise_list overflows";

[danakj, 2013/11/13 23:22:09]

If you expect this to be hit validly, then don't NOTREACHED(), and just handle
it as you have.

If you expect this to not be hit validly, then NOTREACHED() and you don't need
to add infrastructure to deal with it.

ie. pick one please

[Yufeng Shen (Slow to review), 2013/11/14 22:09:55]

Done.

+    BreakSwapPromise(SwapPromise::SWAP_PROMISE_LIST_OVERFLOW);
+  }
+  swap_promise_list_.push_back(swap_promise);
+}
+
+bool LayerTreeHost::HasQueuedSwapPromise() {
+  return !swap_promise_list_.empty();
+}
+
+void LayerTreeHost::FinishSwapPromise() {

[danakj, 2013/11/13 23:22:09]

FinishSwapPromises?

[Yufeng Shen (Slow to review), 2013/11/14 22:09:55]

Done.

+  for (size_t i = 0; i < swap_promise_list_.size(); i++) {
+    swap_promise_list_[i]->DidSwap();
+  }
+  swap_promise_list_.clear();
+}
+
+void LayerTreeHost::BreakSwapPromise(SwapPromise::DidNotSwapReason reason) {

[danakj, 2013/11/13 23:22:09]

BreakSwapPromises?

[Yufeng Shen (Slow to review), 2013/11/14 22:09:55]

Done.

+  for (size_t i = 0; i < swap_promise_list_.size(); i++) {
+    swap_promise_list_[i]->DidNotSwap(reason);
+  }
+  swap_promise_list_.clear();
+}
+
 }  // namespace cc