cc: Improve frame/commit accounting

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 "config.h"
 
 #include "CCLayerTreeHostImpl.h"
 
 #include "CCAppendQuadsData.h"
 #include "CCDamageTracker.h"
@@ skipping 210 matching lines @@
     , m_scrollDeltaIsInScreenSpace(false)
     , m_settings(settings)
     , m_deviceScaleFactor(1)
     , m_visible(true)
     , m_contentsTexturesPurged(false)
     , m_memoryAllocationLimitBytes(CCPrioritizedTextureManager::defaultMemoryAllocationLimit())
     , m_backgroundColor(0)
     , m_hasTransparentBackground(false)
     , m_needsAnimateLayers(false)
     , m_pinchGestureActive(false)
+    , m_animationFrameCount(0)
     , m_fpsCounter(CCFrameRateCounter::create())
     , m_debugRectHistory(CCDebugRectHistory::create())
-    , m_numImplThreadScrolls(0)
-    , m_numMainThreadScrolls(0)
+    , m_implThreadScrollCount(0)
+    , m_mainThreadScrollCount(0)
 {
     ASSERT(CCProxy::isImplThread());
     didVisibilityChange(this, m_visible);
 }
 
 CCLayerTreeHostImpl::~CCLayerTreeHostImpl()
 {
     ASSERT(CCProxy::isImplThread());
     TRACE_EVENT0("cc", "CCLayerTreeHostImpl::~CCLayerTreeHostImpl()");
 
@@ skipping 782 matching lines @@
 
     // First find out which layer was hit from the saved list of visible layers
     // in the most recent frame.
     CCLayerImpl* layerImpl = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(viewportPoint, m_renderSurfaceLayerList);
 
     // Walk up the hierarchy and look for a scrollable layer.
     CCLayerImpl* potentiallyScrollingLayerImpl = 0;
     for (; layerImpl; layerImpl = layerImpl->parent()) {
         // The content layer can also block attempts to scroll outside the main thread.
         if (layerImpl->tryScroll(deviceViewportPoint, type) == ScrollOnMainThread) {
-            m_numMainThreadScrolls++;
+            m_mainThreadScrollCount++;
             return ScrollOnMainThread;
         }
 
         CCLayerImpl* scrollLayerImpl = findScrollLayerForContentLayer(layerImpl);
         if (!scrollLayerImpl)
             continue;
 
         ScrollStatus status = scrollLayerImpl->tryScroll(viewportPoint, type);
 
         // If any layer wants to divert the scroll event to the main thread, abort.
         if (status == ScrollOnMainThread) {
-            m_numMainThreadScrolls++;
+            m_mainThreadScrollCount++;
             return ScrollOnMainThread;
         }
 
         if (status == ScrollStarted && !potentiallyScrollingLayerImpl)
             potentiallyScrollingLayerImpl = scrollLayerImpl;
     }
 
     if (potentiallyScrollingLayerImpl) {
         m_currentlyScrollingLayerImpl = potentiallyScrollingLayerImpl;
         // Gesture events need to be transformed from screen coordinates to local layer coordinates
         // so that the scrolling contents exactly follow the user's finger. In contrast, wheel
         // events are already in local layer coordinates so we can just apply them directly.
         m_scrollDeltaIsInScreenSpace = (type == Gesture);
-        m_numImplThreadScrolls++;
+        m_implThreadScrollCount++;
         return ScrollStarted;
     }
     return ScrollIgnored;
 }
 
 static FloatSize scrollLayerWithScreenSpaceDelta(CCPinchZoomViewport* viewport, CCLayerImpl& layerImpl, const FloatPoint& screenSpacePoint, const FloatSize& screenSpaceDelta)
 {
     // Layers with non-invertible screen space transforms should not have passed the scroll hit
     // test in the first place.
     ASSERT(layerImpl.screenSpaceTransform().isInvertible());
@@ skipping 280 matching lines @@
         m_pageScaleAnimation.reset();
         m_client->setNeedsCommitOnImplThread();
     }
 }
 
 void CCLayerTreeHostImpl::animateLayers(double monotonicTime, double wallClockTime)
 {
     if (!CCSettings::acceleratedAnimationEnabled() || !m_needsAnimateLayers || !m_rootLayerImpl)
         return;
 
+    m_animationFrameCount++;
     TRACE_EVENT0("cc", "CCLayerTreeHostImpl::animateLayers");
 
     scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEventsVector));
 
     bool didAnimate = false;
     animateLayersRecursive(m_rootLayerImpl.get(), monotonicTime, wallClockTime, events.get(), didAnimate, m_needsAnimateLayers);
 
     if (!events->empty())
         m_client->postAnimationEventsToMainThreadOnImplThread(events.Pass(), wallClockTime);
 
@@ skipping 54 matching lines @@
         dumpRenderSurfaces(str, indent, layer->children()[i]);
 }
 
 int CCLayerTreeHostImpl::sourceAnimationFrameNumber() const
 {
     return fpsCounter()->currentFrameNumber();
 }
 
 void CCLayerTreeHostImpl::renderingStats(CCRenderingStats* stats) const
 {
-    stats->numFramesSentToScreen = fpsCounter()->currentFrameNumber();
-    stats->droppedFrameCount = fpsCounter()->droppedFrameCount();
-    stats->numImplThreadScrolls = m_numImplThreadScrolls;
-    stats->numMainThreadScrolls = m_numMainThreadScrolls;
+    fpsCounter()->renderingStats(stats);
+    stats->implThreadScrollCount = m_implThreadScrollCount;
+    stats->mainThreadScrollCount = m_mainThreadScrollCount;
+    stats->implAnimationFrameCount = m_animationFrameCount;
 }
 
 void CCLayerTreeHostImpl::animateScrollbars(double monotonicTime)
 {
     animateScrollbarsRecursive(m_rootLayerImpl.get(), monotonicTime);
 }
 
 void CCLayerTreeHostImpl::animateScrollbarsRecursive(CCLayerImpl* layer, double monotonicTime)
 {
     if (!layer)
         return;
 
     CCScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], monotonicTime);
 }
 
 }  // namespace cc