cc: Improve frame/commit accounting

cc/CCFrameRateController.cpp

 // 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 "CCFrameRateController.h"
 
 #include "CCDelayBasedTimeSource.h"
+#include "CCRenderingStats.h"
 #include "CCTimeSource.h"
 #include "TraceEvent.h"
 #include <wtf/CurrentTime.h>
 
 namespace {
 
 // This will be the maximum number of pending frames unless
 // CCFrameRateController::setMaxFramesPending is called.
 const int defaultMaxFramesPending = 2;
 
@@ skipping 16 matching lines @@
 
     CCFrameRateController* m_frameRateController;
 };
 
 CCFrameRateController::CCFrameRateController(PassRefPtr<CCTimeSource> timer)
     : m_client(0)
     , m_numFramesPending(0)
     , m_maxFramesPending(defaultMaxFramesPending)
     , m_timeSource(timer)
     , m_active(false)
+    , m_drawActive(false)
+    , m_commitActive(false)
     , m_swapBuffersCompleteSupported(true)
+    , m_compositorSyncCount(0)
+    , m_compositorSyncActiveCount(0)
+    , m_numBeginFrames(0)
+    , m_interval(m_timeSource->interval())
     , m_isTimeSourceThrottling(true)
 {
     m_timeSourceClientAdapter = CCFrameRateControllerTimeSourceAdapter::create(this);
     m_timeSource->setClient(m_timeSourceClientAdapter.get());
 }
 
 CCFrameRateController::CCFrameRateController(CCThread* thread)
     : m_client(0)
     , m_numFramesPending(0)
     , m_maxFramesPending(defaultMaxFramesPending)
     , m_active(false)
+    , m_drawActive(false)
+    , m_commitActive(false)
     , m_swapBuffersCompleteSupported(true)
+    , m_compositorSyncCount(0)
+    , m_compositorSyncActiveCount(0)
+    , m_numBeginFrames(0)
     , m_isTimeSourceThrottling(false)
 {
     m_manualTicker = adoptPtr(new CCTimer(thread, this));
 }
 
 CCFrameRateController::~CCFrameRateController()
 {
     if (m_isTimeSourceThrottling)
         m_timeSource->setActive(false);
 }
 
-void CCFrameRateController::setActive(bool active)
+void CCFrameRateController::setActive(bool drawActive, bool commitActive)
 {
-    if (m_active == active)
+    if (m_drawActive == drawActive && m_commitActive == commitActive)
         return;
-    TRACE_EVENT1("cc", "CCFrameRateController::setActive", "active", active);
+
+    TRACE_EVENT2("cc", "CCFrameRateController::setActive", "draw", drawActive, "commit", commitActive);
+
+    if (m_drawActive != drawActive) {
+        if (m_isTimeSourceThrottling)
+            m_timeSource->setActive(drawActive);
+        else {
+            if (drawActive)
+                postManualTick();
+            else
+                m_manualTicker->stop();
+        }
+    }
+
+    bool active = drawActive || commitActive;
+    if (m_active != active) {
+        base::TimeTicks now = base::TimeTicks::Now();
+        if (active)
+            m_activeTimestamp = now;
+        else if (m_interval != base::TimeDelta()) {
+            base::TimeDelta epsilon = base::TimeDelta::FromMicroseconds(1);
+            m_compositorSyncActiveCount += (now - m_activeTimestamp + m_interval - epsilon) / m_interval;
+        }
+    }
+
     m_active = active;
-
-    if (m_isTimeSourceThrottling)
-        m_timeSource->setActive(active);
-    else {
-        if (active)
-            postManualTick();
-        else
-            m_manualTicker->stop();
-    }
+    m_drawActive = drawActive;
+    m_commitActive = commitActive;
 }
 
 void CCFrameRateController::setMaxFramesPending(int maxFramesPending)
 {
     ASSERT(maxFramesPending > 0);
     m_maxFramesPending = maxFramesPending;
 }
 
 void CCFrameRateController::setTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval)
 {
+    if (interval != m_interval) {
+        base::TimeTicks now = base::TimeTicks::Now();
+        if (m_interval != base::TimeDelta())
+            m_compositorSyncCount += (now - m_intervalChangedTime) / m_interval;
+        m_intervalChangedTime = now;
+        m_interval = interval;
+    }
+
     if (m_isTimeSourceThrottling)
         m_timeSource->setTimebaseAndInterval(timebase, interval);
 }
 
 void CCFrameRateController::setSwapBuffersCompleteSupported(bool supported)
 {
     m_swapBuffersCompleteSupported = supported;
 }
 
 void CCFrameRateController::onTimerTick()
 {
-    ASSERT(m_active);
+    ASSERT(m_drawActive);
 
     // Check if we have too many frames in flight.
     bool throttled = m_numFramesPending >= m_maxFramesPending;
 
     if (m_client)
         m_client->vsyncTick(throttled);
 
     if (m_swapBuffersCompleteSupported && !m_isTimeSourceThrottling && m_numFramesPending < m_maxFramesPending)
         postManualTick();
 }
 
 void CCFrameRateController::postManualTick()
 {
-    if (m_active)
+    if (m_drawActive)
         m_manualTicker->startOneShot(0);
 }
 
 void CCFrameRateController::onTimerFired()
 {
     onTimerTick();
 }
 
 void CCFrameRateController::didBeginFrame()
 {
+    ASSERT(m_drawActive);
+
+    m_numBeginFrames++;
+
     if (m_swapBuffersCompleteSupported)
         m_numFramesPending++;
     else if (!m_isTimeSourceThrottling)
         postManualTick();
 }
 
 void CCFrameRateController::didFinishFrame()
 {
     ASSERT(m_swapBuffersCompleteSupported);
 
     m_numFramesPending--;
     if (!m_isTimeSourceThrottling)
         postManualTick();
 }
 
 void CCFrameRateController::didAbortAllPendingFrames()
 {
     m_numFramesPending = 0;
 }
 
 base::TimeTicks CCFrameRateController::nextTickTime()
 {
     if (m_isTimeSourceThrottling)
         return m_timeSource->nextTickTime();
 
     return base::TimeTicks();
 }
 
+
+void CCFrameRateController::renderingStats(CCRenderingStats* stats) const
+{
+    base::TimeTicks now = base::TimeTicks::Now();
+
+    stats->compositorSyncCount = m_compositorSyncCount;
+    if (m_interval != base::TimeDelta())
+        stats->compositorSyncCount += (now - m_intervalChangedTime) / m_interval;
+
+    stats->compositorSyncActiveCount = m_compositorSyncActiveCount;
+    if (m_active && m_interval != base::TimeDelta())
+        stats->compositorSyncActiveCount += (now - m_activeTimestamp) / m_interval;
+
+    stats->compositorFrameCount = m_numBeginFrames;
+    stats->droppedFrameCount = stats->compositorSyncActiveCount - m_numBeginFrames;
+
+    return;

[dtu, 2012/10/04 21:41:09]

nit: the return is still here.

[brianderson, 2012/10/05 00:17:32]

Doh, will get it in next patch

 }
+
+}