Add latency measurement system

cc/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/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 299 matching lines @@
     return true;
 }
 
 OutputSurface* LayerTreeHostImpl::outputSurface() const
 {
     return m_outputSurface.get();
 }
 
 void LayerTreeHostImpl::animate(base::TimeTicks monotonicTime, base::Time wallClockTime)
 {
+    setLatencyInfo(LatencyInfo());
     animatePageScale(monotonicTime);
     animateLayers(monotonicTime, wallClockTime);
     animateScrollbars(monotonicTime);
 }
 
 void LayerTreeHostImpl::manageTiles()
 {
     DCHECK(m_tileManager);
     m_tileManager->ManageTiles();
 
@@ skipping 601 matching lines @@
 
 const RendererCapabilities& LayerTreeHostImpl::rendererCapabilities() const
 {
     return m_renderer->capabilities();
 }
 
 bool LayerTreeHostImpl::swapBuffers()
 {
     DCHECK(m_renderer);
 
+    m_createdFrame = false;
+    TRACE_EVENT_ASYNC_END2("cc", "Frame", this, "implFrameNumber", m_latencyInfo.rendererImplFrameNumber, "mainFrameNumber", m_latencyInfo.rendererMainFrameNumber);
+    TRACE_EVENT_INSTANT1("cc", "Frame", "inputNumber", m_latencyInfo.inputNumber);
     m_fpsCounter->markEndOfFrame();
     return m_renderer->swapBuffers();
 }
 
+void LayerTreeHostImpl::setLatencyInfo(const LatencyInfo& latency_info) {
+    m_latencyInfo.rendererMainFrameNumber = std::max(latency_info.rendererMainFrameNumber, m_latencyInfo.rendererMainFrameNumber);
+    m_latencyInfo.rendererImplFrameNumber = std::max(latency_info.rendererImplFrameNumber, m_latencyInfo.rendererImplFrameNumber);
+    m_latencyInfo.inputNumber = std::max(latency_info.inputNumber, m_latencyInfo.inputNumber);
+    if (!m_createdFrame) {
+        m_createdFrame = true;
+        m_latencyInfo.rendererImplFrameNumber++;
+        TRACE_EVENT_ASYNC_BEGIN2("cc", "Frame", this, "implFrameNumber", m_latencyInfo.rendererImplFrameNumber, "mainFrameNumber", m_latencyInfo.rendererMainFrameNumber);
+    }
+    m_outputSurface->SetLatencyInfo(m_latencyInfo);
+}
+
+void LayerTreeHostImpl::OnReceivedLatencyInfo(const LatencyInfo& latency_info) {
+    m_client->onReceivedLatencyInfo(latency_info);
+}
+
 const gfx::Size& LayerTreeHostImpl::deviceViewportSize() const
 {
     return m_deviceViewportSize;
 }
 
 const LayerTreeSettings& LayerTreeHostImpl::settings() const
 {
     return m_settings;
 }
 
@@ skipping 370 matching lines @@
     return actualViewportEndPoint - viewportPoint;
 }
 
 static gfx::Vector2dF scrollLayerWithLocalDelta(LayerImpl& layerImpl, gfx::Vector2dF localDelta)
 {
     gfx::Vector2dF previousDelta(layerImpl.scrollDelta());
     layerImpl.scrollBy(localDelta);
     return layerImpl.scrollDelta() - previousDelta;
 }
 
-bool LayerTreeHostImpl::scrollBy(const gfx::Point& viewportPoint,
+bool LayerTreeHostImpl::scrollBy(int64 input_number,
+                                 const gfx::Point& viewportPoint,
                                  const gfx::Vector2d& scrollDelta)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBy");
     if (!currentlyScrollingLayer())
         return false;
 
     gfx::Vector2dF pendingDelta = scrollDelta;
     bool didScroll = false;
 
     for (LayerImpl* layerImpl = currentlyScrollingLayer(); layerImpl; layerImpl = layerImpl->parent()) {
@@ skipping 27 matching lines @@
         // Allow further movement only on an axis perpendicular to the direction in which the layer
         // moved.
         gfx::Vector2dF perpendicularAxis(-appliedDelta.y(), appliedDelta.x());
         pendingDelta = MathUtil::projectVector(pendingDelta, perpendicularAxis);
 
         if (gfx::ToFlooredVector2d(pendingDelta).IsZero())
             break;
     }
 
     if (didScroll) {
+        LatencyInfo latency_info;
+        latency_info.inputNumber = input_number;
+        setLatencyInfo(latency_info);
         m_client->setNeedsCommitOnImplThread();
         m_client->setNeedsRedrawOnImplThread();
         setNeedsUpdateDrawProperties();
     }
     return didScroll;
 }
 
 void LayerTreeHostImpl::clearCurrentlyScrollingLayer()
 {
     m_activeTree->ClearCurrentlyScrollingLayer();
@@ skipping 325 matching lines @@
     ScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], time);
 }
 
 }  // namespace cc