Revert 237848 "Use LatencyInfoSwapPromise to track LatencyInfo t..."

trunk/src/cc/trees/layer_tree_host_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_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/animation/timing_function.h"
-#include "cc/base/latency_info_swap_promise.h"
 #include "cc/base/math_util.h"
 #include "cc/base/util.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/debug/debug_rect_history.h"
 #include "cc/debug/frame_rate_counter.h"
 #include "cc/debug/overdraw_metrics.h"
 #include "cc/debug/paint_time_counter.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/input/page_scale_animation.h"
@@ skipping 439 matching lines @@
 
   LayerImpl* layer_impl =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
           device_viewport_point,
           active_tree_->RenderSurfaceLayerList());
   return layer_impl != NULL;
 }
 
 void LayerTreeHostImpl::SetLatencyInfoForInputEvent(
     const ui::LatencyInfo& latency_info) {
-  scoped_ptr<SwapPromise> swap_promise(
-      new LatencyInfoSwapPromise(latency_info));
-  active_tree()->QueueSwapPromise(swap_promise.Pass());
+  active_tree()->SetLatencyInfo(latency_info);
 }
 
 void LayerTreeHostImpl::TrackDamageForAllSurfaces(
     LayerImpl* root_draw_layer,
     const LayerImplList& render_surface_layer_list) {
   // For now, we use damage tracking to compute a global scissor. To do this, we
   // must compute all damage tracking before drawing anything, so that we know
   // the root damage rect. The root damage rect is then used to scissor each
   // surface.
 
@@ skipping 774 matching lines @@
 }
 
 CompositorFrameMetadata LayerTreeHostImpl::MakeCompositorFrameMetadata() const {
   CompositorFrameMetadata metadata;
   metadata.device_scale_factor = device_scale_factor_;
   metadata.page_scale_factor = active_tree_->total_page_scale_factor();
   metadata.viewport_size = active_tree_->ScrollableViewportSize();
   metadata.root_layer_size = active_tree_->ScrollableSize();
   metadata.min_page_scale_factor = active_tree_->min_page_scale_factor();
   metadata.max_page_scale_factor = active_tree_->max_page_scale_factor();
+  metadata.latency_info = active_tree_->GetLatencyInfo();
   if (top_controls_manager_) {
     metadata.location_bar_offset =
         gfx::Vector2dF(0.f, top_controls_manager_->controls_top_offset());
     metadata.location_bar_content_translation =
         gfx::Vector2dF(0.f, top_controls_manager_->content_top_offset());
     metadata.overdraw_bottom_height = overdraw_bottom_height_;
   }
 
   if (!RootScrollLayer())
     return metadata;
@@ skipping 138 matching lines @@
 const RendererCapabilities& LayerTreeHostImpl::GetRendererCapabilities() const {
   return renderer_->Capabilities();
 }
 
 bool LayerTreeHostImpl::SwapBuffers(const LayerTreeHostImpl::FrameData& frame) {
   if (frame.has_no_damage) {
     active_tree()->BreakSwapPromises(SwapPromise::SWAP_FAILS);
     return false;
   }
   CompositorFrameMetadata metadata = MakeCompositorFrameMetadata();
-  active_tree()->FinishSwapPromises(&metadata);
   renderer_->SwapBuffers(metadata);
+  active_tree_->ClearLatencyInfo();
+  active_tree()->FinishSwapPromises();
   return true;
 }
 
 void LayerTreeHostImpl::SetNeedsBeginImplFrame(bool enable) {
   if (output_surface_)
     output_surface_->SetNeedsBeginImplFrame(enable);
 }
 
 gfx::SizeF LayerTreeHostImpl::UnscaledScrollableViewportSize() const {
   // Use the root container layer bounds if it clips to them, otherwise, the
@@ skipping 1431 matching lines @@
   if (evicted_ui_resources_.empty())
     client_->OnCanDrawStateChanged(CanDraw());
 }
 
 void LayerTreeHostImpl::ScheduleMicroBenchmark(
     scoped_ptr<MicroBenchmarkImpl> benchmark) {
   micro_benchmark_controller_.ScheduleRun(benchmark.Pass());
 }
 
 }  // namespace cc