Do not give GPU memory to backgrounded compositors.

content/common/gpu/gpu_memory_manager.h

 // Copyright (c) 2012 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.
 
 #ifndef CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_H_
 #define CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_H_
 
 #include <list>
 #include <map>
 
@@ skipping 98 matching lines @@
   void SetClientsHibernatedState() const;
   void AssignSurfacesAllocations();
   void AssignNonSurfacesAllocations();
 
   // Math helper function to compute the maximum value of cap such that
   // sum_i min(bytes[i], cap) <= bytes_sum_limit
   static uint64 ComputeCap(std::vector<uint64> bytes, uint64 bytes_sum_limit);
 
   // Compute the allocation for clients when visible and not visible.
   void ComputeVisibleSurfacesAllocations();
-  void ComputeNonvisibleSurfacesAllocations();
   void DistributeRemainingMemoryToVisibleSurfaces();
 
   // Compute the budget for a client. Allow at most bytes_above_required_cap
   // bytes above client_state's required level. Allow at most
   // bytes_above_minimum_cap bytes above client_state's minimum level. Allow
   // at most bytes_overall_cap bytes total.
   uint64 ComputeClientAllocationWhenVisible(
       GpuMemoryManagerClientState* client_state,
       uint64 bytes_above_required_cap,
       uint64 bytes_above_minimum_cap,
       uint64 bytes_overall_cap);
-  uint64 ComputeClientAllocationWhenNonvisible(
-      GpuMemoryManagerClientState* client_state);
 
   // Update the amount of GPU memory we think we have in the system, based
   // on what the stubs' contexts report.
   void UpdateAvailableGpuMemory();
   void UpdateUnmanagedMemoryLimits();
 
   // The amount of video memory which is available for allocation.
   uint64 GetAvailableGpuMemory() const;
 
   // Minimum value of available GPU memory, no matter how little the GPU
@@ skipping 82 matching lines @@
 
   base::CancelableClosure delayed_manage_callback_;
   bool manage_immediate_scheduled_;
 
   uint64 max_surfaces_with_frontbuffer_soft_limit_;
 
   // The maximum amount of memory that may be allocated for GPU resources
   uint64 bytes_available_gpu_memory_;
   bool bytes_available_gpu_memory_overridden_;
 
-  // Whether or not clients can be allocated memory when nonvisible.
-  bool allow_nonvisible_memory_;
-
   // The minimum and default allocations for a single client.
   uint64 bytes_minimum_per_client_;
   uint64 bytes_default_per_client_;
 
   // The current total memory usage, and historical maximum memory usage
   uint64 bytes_allocated_managed_current_;
-  uint64 bytes_allocated_managed_visible_;
-  uint64 bytes_allocated_managed_nonvisible_;
   uint64 bytes_allocated_unmanaged_current_;
   uint64 bytes_allocated_historical_max_;
 
   // If bytes_allocated_unmanaged_current_ leaves the interval [low_, high_),
   // then ScheduleManage to take the change into account.
   uint64 bytes_allocated_unmanaged_high_;
   uint64 bytes_allocated_unmanaged_low_;
 
   // Update bytes_allocated_unmanaged_low/high_ in intervals of step_.
   uint64 bytes_unmanaged_limit_step_;
 
   // Used to disable automatic changes to Manage() in testing.
   bool disable_schedule_manage_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuMemoryManager);
 };
 
 }  // namespace content
 
 #endif // CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_H_