Merge 114191 - [chromium] Remove viewport memory restrictions

Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 181 matching lines @@
 void CCLayerTreeHost::layout()
 {
     m_client->layout();
 }
 
 void CCLayerTreeHost::beginCommitOnImplThread(CCLayerTreeHostImpl* hostImpl)
 {
     ASSERT(CCProxy::isImplThread());
     TRACE_EVENT("CCLayerTreeHost::commitTo", this, 0);
 
-    m_contentsTextureManager->reduceMemoryToLimit(TextureManager::reclaimLimitBytes(viewportSize()));
+    m_contentsTextureManager->reduceMemoryToLimit(m_contentsTextureManager->preferredMemoryLimitBytes());
     m_contentsTextureManager->deleteEvictedTextures(hostImpl->contentsTextureAllocator());
 }
 
 // This function commits the CCLayerTreeHost to an impl tree. When modifying
 // this function, keep in mind that the function *runs* on the impl thread! Any
 // code that is logically a main thread operation, e.g. deletion of a LayerChromium,
 // should be delayed until the CCLayerTreeHost::commitComplete, which will run
 // after the commit, but on the main thread.
 void CCLayerTreeHost::finishCommitOnImplThread(CCLayerTreeHostImpl* hostImpl)
 {
@@ skipping 147 matching lines @@
 }
 
 void CCLayerTreeHost::setVisible(bool visible)
 {
     if (m_visible == visible)
         return;
 
     m_visible = visible;
 
     if (!visible && m_layerRendererInitialized) {
-        m_contentsTextureManager->reduceMemoryToLimit(TextureManager::lowLimitBytes(viewportSize()));
+        // Drop all unprotected textures.
+        m_contentsTextureManager->reduceMemoryToLimit(0);
         m_contentsTextureManager->unprotectAllTextures();
     }
 
     // Tells the proxy that visibility state has changed. This will in turn call
     // CCLayerTreeHost::didBecomeInvisibleOnImplThread on the appropriate thread, for
     // the case where !visible.
     m_proxy->setVisible(visible);
 }
 
 void CCLayerTreeHost::didBecomeInvisibleOnImplThread(CCLayerTreeHostImpl* hostImpl)
 {
     ASSERT(CCProxy::isImplThread());
     if (!m_layerRendererInitialized)
         return;
 
     if (m_proxy->layerRendererCapabilities().contextHasCachedFrontBuffer)
         contentsTextureManager()->evictAndDeleteAllTextures(hostImpl->contentsTextureAllocator());
     else {
-        contentsTextureManager()->reduceMemoryToLimit(TextureManager::reclaimLimitBytes(viewportSize()));
+        contentsTextureManager()->reduceMemoryToLimit(m_contentsTextureManager->preferredMemoryLimitBytes());
         contentsTextureManager()->deleteEvictedTextures(hostImpl->contentsTextureAllocator());
     }
 
     // Ensure that the dropped tiles are propagated to the impl tree.
     // If the frontbuffer is cached, then clobber the impl tree. Otherwise,
     // push over the tree changes.
     if (m_proxy->layerRendererCapabilities().contextHasCachedFrontBuffer) {
         hostImpl->setRootLayer(nullptr);
         return;
     }
@@ skipping 81 matching lines @@
 
     // Reset partial texture update requests.
     m_partialTextureUpdateRequests = 0;
 
     reserveTextures();
 
     paintLayerContents(m_updateList, PaintVisible);
     if (!m_triggerIdlePaints)
         return;
 
-    size_t preferredLimitBytes = TextureManager::reclaimLimitBytes(m_viewportSize);
-    size_t maxLimitBytes = TextureManager::highLimitBytes(m_viewportSize);
+    size_t preferredLimitBytes = m_contentsTextureManager->preferredMemoryLimitBytes();
+    size_t maxLimitBytes = m_contentsTextureManager->maxMemoryLimitBytes();
     m_contentsTextureManager->reduceMemoryToLimit(preferredLimitBytes);
     if (m_contentsTextureManager->currentMemoryUseBytes() >= preferredLimitBytes)
         return;
 
     // Idle painting should fail when we hit the preferred memory limit,
     // otherwise it will always push us towards the maximum limit.
     m_contentsTextureManager->setMaxMemoryLimitBytes(preferredLimitBytes);
     // The second (idle) paint will be a no-op in layers where painting already occured above.
     paintLayerContents(m_updateList, PaintIdle);
     m_contentsTextureManager->setMaxMemoryLimitBytes(maxLimitBytes);
@@ skipping 189 matching lines @@
     for (size_t eventIndex = 0; eventIndex < events.size(); ++eventIndex) {
         if (layer->id() == events[eventIndex].layerId)
             layer->notifyAnimationStarted(events[eventIndex], wallClockTime);
     }
 
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
 } // namespace WebCore