Send memory management policies to the tile manager

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 197 matching lines @@
 LayerTreeHostImpl::LayerTreeHostImpl(const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
     : m_client(client)
     , m_proxy(proxy)
     , m_scrollDeltaIsInViewportSpace(false)
     , m_settings(settings)
     , m_debugState(settings.initialDebugState)
     , m_deviceScaleFactor(1)
     , m_visible(true)
     , m_contentsTexturesPurged(false)
     , m_managedMemoryPolicy(PrioritizedResourceManager::defaultMemoryAllocationLimit(),
-                            PriorityCalculator::allowEverythingCutoff(),
+                            ManagedMemoryPolicy::CUTOFF_ALLOW_EVERYTHING,
                             0,
-                            PriorityCalculator::allowNothingCutoff())
+                            ManagedMemoryPolicy::CUTOFF_ALLOW_NOTHING)
     , m_backgroundColor(0)
     , m_hasTransparentBackground(false)
     , m_needsAnimateLayers(false)
     , m_needsUpdateDrawProperties(false)
     , m_pinchGestureActive(false)
     , m_fpsCounter(FrameRateCounter::create(m_proxy->hasImplThread()))
     , m_debugRectHistory(DebugRectHistory::create())
     , m_numImplThreadScrolls(0)
     , m_numMainThreadScrolls(0)
     , m_cumulativeNumLayersDrawn(0)
@@ skipping 552 matching lines @@
         return false;
 
     // If we return true, then we expect drawLayers() to be called before this function is called again.
     return true;
 }
 
 void LayerTreeHostImpl::enforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy)
 {
     bool evictedResources = m_client->reduceContentsTextureMemoryOnImplThread(
         m_visible ? policy.bytesLimitWhenVisible : policy.bytesLimitWhenNotVisible,
-        m_visible ? policy.priorityCutoffWhenVisible : policy.priorityCutoffWhenNotVisible);
+        ManagedMemoryPolicy::priorityCutoffValue(
+            m_visible ? policy.priorityCutoffWhenVisible : policy.priorityCutoffWhenNotVisible));
     if (evictedResources) {
         setContentsTexturesPurged();
         m_client->setNeedsCommitOnImplThread();
         m_client->onCanDrawStateChanged(canDraw());
     }
     m_client->sendManagedMemoryStats();
 
     if (m_tileManager) {
       // TODO(nduca): Pass something useful into the memory manager.
       LOG(INFO) << "Setting up initial tile manager policy";
       GlobalStateThatImpactsTilePriority new_state(m_tileManager->GlobalState());
-      new_state.memory_limit_in_bytes = PrioritizedResourceManager::defaultMemoryAllocationLimit();
-      new_state.memory_limit_policy = ALLOW_ANYTHING;
+      new_state.memory_limit_in_bytes = m_visible ? policy.bytesLimitWhenVisible : policy.bytesLimitWhenNotVisible;
+      new_state.memory_limit_policy = ManagedMemoryPolicy::priorityCutoffToMemoryLimitPolicy(
+           m_visible ? policy.priorityCutoffWhenVisible : policy.priorityCutoffWhenNotVisible);
       m_tileManager->SetGlobalState(new_state);

[nduca, 2012/12/19 21:46:32]

I think we might want a to just pass the enforce call into tile manager as
something like TemporarilySetGlobalState that uses a provided globalState, calls
manage tiles, but then rolls back to the old state.

     }
 }
 
 bool LayerTreeHostImpl::hasImplThread() const
 {
     return m_proxy->hasImplThread();
 }
 
 void LayerTreeHostImpl::ScheduleManageTiles()
 {
@@ skipping 872 matching lines @@
 }
 
 void LayerTreeHostImpl::sendManagedMemoryStats(
     size_t memoryVisibleBytes,
     size_t memoryVisibleAndNearbyBytes,
     size_t memoryUseBytes)
 {
     if (!renderer())
       return;
 
+    // XXX - these numbers are coming from the priorized texture manager.
+    // If we have a tile manager, the numbers should come from there!
+
     // Round the numbers being sent up to the next 8MB, to throttle the rate
     // at which we spam the GPU process.
     static const size_t roundingStep = 8 * 1024 * 1024;
     memoryVisibleBytes = RoundUp(memoryVisibleBytes, roundingStep);
     memoryVisibleAndNearbyBytes = RoundUp(memoryVisibleAndNearbyBytes, roundingStep);
     memoryUseBytes = RoundUp(memoryUseBytes, roundingStep);
     if (m_lastSentMemoryVisibleBytes == memoryVisibleBytes &&
         m_lastSentMemoryVisibleAndNearbyBytes == memoryVisibleAndNearbyBytes &&
         m_lastSentMemoryUseBytes == memoryUseBytes) {
         return;
@@ skipping 20 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