Use LatencyInfoSwapPromise to track LatencyInfo through compositor

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 364 matching lines @@
   } else {
     page_scale_delta = sync_tree->page_scale_delta();
     sent_page_scale_delta = sync_tree->sent_page_scale_delta();
     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->PassSwapPromises(&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,
@@ skipping 301 matching lines @@
 
 void LayerTreeHost::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
   visible_ = visible;
   if (!visible)
     ReduceMemoryUsage();
   proxy_->SetVisible(visible);
 }
 
-void LayerTreeHost::SetLatencyInfo(const ui::LatencyInfo& latency_info) {
-  latency_info_.MergeWith(latency_info);
-}
-
 void LayerTreeHost::StartPageScaleAnimation(gfx::Vector2d target_offset,
                                             bool use_anchor,
                                             float scale,
                                             base::TimeDelta duration) {
   pending_page_scale_animation_.reset(new PendingPageScaleAnimation);
   pending_page_scale_animation_->target_offset = target_offset;
   pending_page_scale_animation_->use_anchor = use_anchor;
   pending_page_scale_animation_->scale = scale;
   pending_page_scale_animation_->duration = duration;
 
@@ skipping 542 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(scoped_ptr<SwapPromise> swap_promise) {
-  if (proxy_->HasImplThread()) {
-    DCHECK(proxy_->CommitRequested() || proxy_->BeginMainFrameRequested());
-  }
   DCHECK(swap_promise);
   if (swap_promise_list_.size() > kMaxQueuedSwapPromiseNumber)
     BreakSwapPromises(SwapPromise::SWAP_PROMISE_LIST_OVERFLOW);
   swap_promise_list_.push_back(swap_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();
 }
 
 }  // namespace cc