Do not give GPU memory to backgrounded compositors.

cc/trees/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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 190 matching lines @@
       last_scroll_did_bubble_(false),
       wheel_scrolling_(false),
       scroll_layer_id_when_mouse_over_scrollbar_(0),
       tile_priorities_dirty_(false),
       root_layer_scroll_offset_delegate_(NULL),
       settings_(settings),
       visible_(true),
       cached_managed_memory_policy_(
           PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
           gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
-          0,
-          gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING,
           ManagedMemoryPolicy::kDefaultNumResourcesLimit),
       pinch_gesture_active_(false),
       pinch_gesture_end_should_clear_scrolling_layer_(false),
       fps_counter_(FrameRateCounter::Create(proxy_->HasImplThread())),
       paint_time_counter_(PaintTimeCounter::Create()),
       memory_history_(MemoryHistory::Create()),
       debug_rect_history_(DebugRectHistory::Create()),
       texture_mailbox_deleter_(new TextureMailboxDeleter),
       max_memory_needed_bytes_(0),
       last_sent_memory_visible_bytes_(0),
@@ skipping 836 matching lines @@
 }
 
 void LayerTreeHostImpl::DidInitializeVisibleTileForTesting() {
   DidInitializeVisibleTile();
 }
 
 void LayerTreeHostImpl::EnforceManagedMemoryPolicy(
     const ManagedMemoryPolicy& policy) {
 
   bool evicted_resources = client_->ReduceContentsTextureMemoryOnImplThread(
-      visible_ ? policy.bytes_limit_when_visible
-               : policy.bytes_limit_when_not_visible,
+      visible_ ? policy.bytes_limit_when_visible : 0,
       ManagedMemoryPolicy::PriorityCutoffToValue(
           visible_ ? policy.priority_cutoff_when_visible
-                   : policy.priority_cutoff_when_not_visible));
+                   : gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING));
   if (evicted_resources) {
     active_tree_->SetContentsTexturesPurged();
     if (pending_tree_)
       pending_tree_->SetContentsTexturesPurged();
     client_->SetNeedsCommitOnImplThread();
     client_->OnCanDrawStateChanged(CanDraw());
     client_->RenewTreePriority();
   }
   client_->SendManagedMemoryStats();
 
   UpdateTileManagerMemoryPolicy(policy);
 }
 
 void LayerTreeHostImpl::UpdateTileManagerMemoryPolicy(
     const ManagedMemoryPolicy& policy) {
   if (!tile_manager_)
     return;
 
   // TODO(reveman): We should avoid keeping around unused resources if
   // possible. crbug.com/224475
   global_tile_state_.memory_limit_in_bytes =
       visible_ ?
-      policy.bytes_limit_when_visible :
-      policy.bytes_limit_when_not_visible;
+      policy.bytes_limit_when_visible : 0;
   global_tile_state_.unused_memory_limit_in_bytes = static_cast<size_t>(
       (static_cast<int64>(global_tile_state_.memory_limit_in_bytes) *
        settings_.max_unused_resource_memory_percentage) / 100);
   global_tile_state_.memory_limit_policy =
       ManagedMemoryPolicy::PriorityCutoffToTileMemoryLimitPolicy(
           visible_ ?
           policy.priority_cutoff_when_visible :
-          policy.priority_cutoff_when_not_visible);
+          gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING);
   global_tile_state_.num_resources_limit = policy.num_resources_limit;
 
   DidModifyTilePriorities();
 }
 
 void LayerTreeHostImpl::DidModifyTilePriorities() {
   DCHECK(settings_.impl_side_painting);
   // Mark priorities as dirty and schedule a ManageTiles().
   tile_priorities_dirty_ = true;
   client_->SetNeedsManageTilesOnImplThread();
 }
 
 void LayerTreeHostImpl::DidInitializeVisibleTile() {
   // TODO(reveman): Determine tiles that changed and only damage
   // what's necessary.
   SetFullRootLayerDamage();
   if (client_ && !client_->IsInsideDraw())
     client_->DidInitializeVisibleTileOnImplThread();
 }
 
 void LayerTreeHostImpl::NotifyReadyToActivate() {
   client_->NotifyReadyToActivate();
 }
 
 void LayerTreeHostImpl::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
   SetManagedMemoryPolicy(policy, zero_budget_);
 }
 
-void LayerTreeHostImpl::SetDiscardBackBufferWhenNotVisible(bool discard) {
-  DCHECK(renderer_);
-  renderer_->SetDiscardBackBufferWhenNotVisible(discard);
-}
-
 void LayerTreeHostImpl::SetTreeActivationCallback(
     const base::Closure& callback) {
   DCHECK(proxy_->IsImplThread());
   DCHECK(settings_.impl_side_painting || callback.is_null());
   tree_activation_callback_ = callback;
 }
 
 void LayerTreeHostImpl::SetManagedMemoryPolicy(
     const ManagedMemoryPolicy& policy, bool zero_budget) {
   if (cached_managed_memory_policy_ == policy && zero_budget_ == zero_budget)
@@ skipping 404 matching lines @@
 
   if (!renderer_)
     return;
 
   renderer_->SetVisible(visible);
 }
 
 ManagedMemoryPolicy LayerTreeHostImpl::ActualManagedMemoryPolicy() const {
   ManagedMemoryPolicy actual = cached_managed_memory_policy_;
   if (debug_state_.rasterize_only_visible_content) {
-    actual.priority_cutoff_when_not_visible =
-        gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING;
     actual.priority_cutoff_when_visible =
         gpu::MemoryAllocation::CUTOFF_ALLOW_REQUIRED_ONLY;
   }
 
   if (zero_budget_) {
     actual.bytes_limit_when_visible = 0;
-    actual.bytes_limit_when_not_visible = 0;
   }
 
   return actual;
 }
 
 size_t LayerTreeHostImpl::memory_allocation_limit_bytes() const {
   return ActualManagedMemoryPolicy().bytes_limit_when_visible;
 }
 
 int LayerTreeHostImpl::memory_allocation_priority_cutoff() const {
@@ skipping 1231 matching lines @@
   std::set<UIResourceId>::iterator found_in_evicted =
       evicted_ui_resources_.find(uid);
   if (found_in_evicted == evicted_ui_resources_.end())
     return;
   evicted_ui_resources_.erase(found_in_evicted);
   if (evicted_ui_resources_.empty())
     client_->OnCanDrawStateChanged(CanDraw());
 }
 
 }  // namespace cc