cc: Rasterize cheap tiles immediately

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 30 matching lines @@
 #include "cc/solid_color_draw_quad.h"
 #include "cc/texture_uploader.h"
 #include "cc/top_controls_manager.h"
 #include "cc/tree_synchronizer.h"
 #include "cc/util.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 namespace {
 
+// Limits for the total number of cheap tile rasterizations we are allowed to
+// perform during a single frame and the time spent rasterizing.
+// TODO(skyostil): Determine these limits more dynamically.
+const int kMaxCheapRasterCount = 6;
+const int kMaxCheapRasterMilliseconds = 6;
+
 void didVisibilityChange(cc::LayerTreeHostImpl* id, bool visible)
 {
     if (visible) {
         TRACE_EVENT_ASYNC_BEGIN1("webkit", "LayerTreeHostImpl::setVisible", id, "LayerTreeHostImpl", id);
         return;
     }
 
     TRACE_EVENT_ASYNC_END0("webkit", "LayerTreeHostImpl::setVisible", id);
 }
 
@@ skipping 91 matching lines @@
     , m_memoryHistory(MemoryHistory::create())
     , m_debugRectHistory(DebugRectHistory::create())
     , m_numImplThreadScrolls(0)
     , m_numMainThreadScrolls(0)
     , m_cumulativeNumLayersDrawn(0)
     , m_cumulativeNumMissingTiles(0)
     , m_lastSentMemoryVisibleBytes(0)
     , m_lastSentMemoryVisibleAndNearbyBytes(0)
     , m_lastSentMemoryUseBytes(0)
     , m_animationRegistrar(AnimationRegistrar::create())
+    , m_cheapRasterCount(0)
 {
     DCHECK(m_proxy->isImplThread());
     didVisibilityChange(this, m_visible);
 
     if (settings.calculateTopControlsPosition)
         m_topControlsManager = TopControlsManager::Create(this, settings.topControlsHeight);
 
     setDebugState(settings.initialDebugState);
 
     // LTHI always has an active tree.
@@ skipping 536 matching lines @@
     if (m_client)
       m_client->setNeedsManageTilesOnImplThread();
 }
 
 void LayerTreeHostImpl::DidUploadVisibleHighResolutionTile()
 {
     if (m_client)
         m_client->didUploadVisibleHighResolutionTileOnImplThread();
 }
 
+bool LayerTreeHostImpl::CanDoAnotherCheapRaster() const
+{
+    DCHECK(m_settings.useCheapnessEstimator);
+    if (m_cheapRasterCount >= kMaxCheapRasterCount) {
+        TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDoAnotherCheapRaster did too many");
+        return false;
+    }
+    if (m_cheapRasterDeadline.is_null() || base::TimeTicks::Now() >= m_cheapRasterDeadline) {
+        TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDoAnotherCheapRaster out of time");
+        m_cheapRasterDeadline = base::TimeTicks();
+        return false;
+    }
+    return true;
+}
+
+void LayerTreeHostImpl::DidPerformCheapRaster()
+{
+    DCHECK(m_settings.useCheapnessEstimator);
+    m_cheapRasterCount++;
+    DCHECK(m_cheapRasterCount <= kMaxCheapRasterCount);
+}
+
 bool LayerTreeHostImpl::shouldClearRootRenderPass() const
 {
     return m_settings.shouldClearRootRenderPass;
 }
 
 void LayerTreeHostImpl::setManagedMemoryPolicy(const ManagedMemoryPolicy& policy)
 {
     if (m_managedMemoryPolicy == policy)
         return;
 
@@ skipping 112 matching lines @@
     return m_renderer && m_renderer->isContextLost();
 }
 
 const RendererCapabilities& LayerTreeHostImpl::rendererCapabilities() const
 {
     return m_renderer->capabilities();
 }
 
 bool LayerTreeHostImpl::swapBuffers()
 {
+    if (m_settings.useCheapnessEstimator) {
+        m_cheapRasterCount = 0;
+        m_cheapRasterDeadline = base::TimeTicks::Now() + base::TimeDelta::FromMilliseconds(kMaxCheapRasterMilliseconds);
+    }
     return m_renderer->swapBuffers();
 }
 
 const gfx::Size& LayerTreeHostImpl::deviceViewportSize() const
 {
     return m_deviceViewportSize;
 }
 
 const LayerTreeSettings& LayerTreeHostImpl::settings() const
 {
@@ skipping 868 matching lines @@
     if (m_tileManager)
         m_tileManager->SetRecordRenderingStats(m_debugState.recordRenderingStats());
 }
 
 void LayerTreeHostImpl::savePaintTime(const base::TimeDelta& totalPaintTime)
 {
     m_paintTimeCounter->SavePaintTime(totalPaintTime);
 }
 
 }  // namespace cc