Implement scroll handler latency tracking

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"
@@ skipping 482 matching lines @@
   return layer_impl != NULL;
 }
 
 scoped_ptr<SwapPromiseMonitor>
 LayerTreeHostImpl::CreateLatencyInfoSwapPromiseMonitor(
     ui::LatencyInfo* latency) {
   return scoped_ptr<SwapPromiseMonitor>(
       new LatencyInfoSwapPromiseMonitor(latency, NULL, this));
 }
 
+void LayerTreeHostImpl::QueueScrollUpdateLatencyInfo(
+    const ui::LatencyInfo& latency_info) {
+  scroll_update_latency_infos_.push_back(latency_info);

[danakj, 2014/07/08 16:49:07]

Should we be dropping SwapPromises if the list gets too large like we do in
LayerTreeImpl::QueueSwapPromise?

[Sami, 2014/07/09 13:28:55]

Good point, I've added the same logic here.

+}
+
 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.
 
   for (int surface_index = render_surface_layer_list.size() - 1;
        surface_index >= 0;
@@ skipping 1948 matching lines @@
     // which the layer moved.
     gfx::Vector2dF perpendicular_axis(-applied_delta.y(), applied_delta.x());
     pending_delta = MathUtil::ProjectVector(pending_delta, perpendicular_axis);
 
     if (gfx::ToRoundedVector2d(pending_delta).IsZero())
       break;
   }
 
   bool did_scroll_content = did_scroll_x || did_scroll_y;
   if (did_scroll_content) {
+    // If we are scrolling with an active scroll handler, forward latency
+    // tracking information to the main thread so the delay introduced by the
+    // handler is accounted for.
+    if (scroll_affects_scroll_handler())
+      NotifySwapPromiseMonitorsOfForwardingToMainThread();
     client_->SetNeedsCommitOnImplThread();
     SetNeedsRedraw();
     client_->RenewTreePriority();
   }
 
   // Scrolling along an axis resets accumulated root overscroll for that axis.
   if (did_scroll_x)
     accumulated_root_overscroll_.set_x(0);
   if (did_scroll_y)
     accumulated_root_overscroll_.set_y(0);
@@ skipping 281 matching lines @@
   for (size_t i = 0; i < layer_impl->children().size(); ++i)
     CollectScrollDeltas(scroll_info, layer_impl->children()[i]);
 }
 
 scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::ProcessScrollDeltas() {
   scoped_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet());
 
   CollectScrollDeltas(scroll_info.get(), active_tree_->root_layer());
   scroll_info->page_scale_delta = active_tree_->page_scale_delta();
   active_tree_->set_sent_page_scale_delta(scroll_info->page_scale_delta);
+  std::swap(scroll_info->latency_infos, scroll_update_latency_infos_);
 
   return scroll_info.Pass();
 }
 
 void LayerTreeHostImpl::SetFullRootLayerDamage() {
   SetViewportDamage(gfx::Rect(DrawViewportSize()));
 }
 
 void LayerTreeHostImpl::RunOnDemandRasterTask(Task* on_demand_raster_task) {
   DCHECK(on_demand_task_graph_runner_);
@@ skipping 356 matching lines @@
 void LayerTreeHostImpl::RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
   swap_promise_monitor_.erase(monitor);
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
+void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfForwardingToMainThread() {
+  std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
+  for (; it != swap_promise_monitor_.end(); it++)
+    (*it)->OnForwardScrollUpdateToMainThreadOnImpl();
+}
+
 void LayerTreeHostImpl::RegisterPictureLayerImpl(PictureLayerImpl* layer) {
   DCHECK(std::find(picture_layers_.begin(), picture_layers_.end(), layer) ==
          picture_layers_.end());
   picture_layers_.push_back(layer);
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc