ui: Prefer +/- operators to apply offsets.

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_
 
 #if defined(ENABLE_GPU)
 
 #include <set>
@@ skipping 85 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
                            TestForegroundStubsGetBonusAllocation);
   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
                            TestUpdateAvailableGpuMemory);
   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
                            GpuMemoryAllocationCompareTests);
   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
                            StubMemoryStatsForLastManageTests);
   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
                            TestManagedUsageTracking);
+  FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
+                           TestBackgroundCutoff);
+  FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
+                           TestBackgroundMru);
 
   struct ClientState {
     ClientState(GpuMemoryManagerClient* client,
                 bool has_surface,
                 bool visible,
                 base::TimeTicks last_used_time);
     // The client to send allocations to.
     GpuMemoryManagerClient* client;
 
     // Offscreen commandbuffers will not have a surface.
@@ skipping 18 matching lines @@
                     ClientState* rhs);
   };
 
   typedef std::map<GpuMemoryManagerClient*, ClientState*> ClientMap;
 
   typedef std::vector<ClientState*> ClientStateVector;
 
   void Manage();
   void SetClientsHibernatedState(const ClientStateVector& clients) const;
   size_t GetVisibleClientAllocation(const ClientStateVector& clients) const;
+  size_t GetCurrentBackgroundedAvailableGpuMemory() const;
 
   // Update the amount of GPU memory we think we have in the system, based
   // on what the stubs' contexts report.
   void UpdateAvailableGpuMemory(const ClientStateVector& clients);
+  void UpdateBackgroundedAvailableGpuMemory();
 
   // The amount of video memory which is available for allocation.
   size_t GetAvailableGpuMemory() const;
 
-  // Default per-OS value for the amount of available GPU memory, used
-  // if we can't query the driver for an exact value.
+  // Minimum value of available GPU memory, no matter how little the GPU
+  // reports. This is the default value.
   size_t GetDefaultAvailableGpuMemory() const;
 
   // Maximum cap on total GPU memory, no matter how much the GPU reports.
   size_t GetMaximumTotalGpuMemory() const;
 
   // The maximum and minimum amount of memory that a tab may be assigned.
   size_t GetMaximumTabAllocation() const;
   size_t GetMinimumTabAllocation() const;
 
   // Get a reasonable memory limit from a viewport's surface area.
   static size_t CalcAvailableFromViewportArea(int viewport_area);
   static size_t CalcAvailableFromGpuTotal(size_t total_gpu_memory);
 
   // Interfaces for testing
   void TestingSetClientVisible(GpuMemoryManagerClient* client, bool visible);
   void TestingSetClientLastUsedTime(GpuMemoryManagerClient* client,
                                     base::TimeTicks last_used_time);
   void TestingSetClientHasSurface(GpuMemoryManagerClient* client,
                                   bool has_surface);
   bool TestingCompareClients(GpuMemoryManagerClient* lhs,
                              GpuMemoryManagerClient* rhs) const;
   void TestingDisableScheduleManage() { disable_schedule_manage_ = true; }
+  void TestingSetAvailableGpuMemory(size_t bytes) {
+    bytes_available_gpu_memory_ = bytes;
+    bytes_available_gpu_memory_overridden_ = true;
+  }
+
+  void TestingSetBackgroundedAvailableGpuMemory(size_t bytes) {
+    bytes_backgrounded_available_gpu_memory_ = bytes;
+  }
 
   // All clients of this memory manager which have callbacks we
   // can use to adjust memory usage
   ClientMap clients_;
 
   // All context groups' tracking structures
   std::set<GpuMemoryTrackingGroup*> tracking_groups_;
 
   base::CancelableClosure delayed_manage_callback_;
   bool manage_immediate_scheduled_;
 
   size_t max_surfaces_with_frontbuffer_soft_limit_;
 
   // The maximum amount of memory that may be allocated for GPU resources
   size_t bytes_available_gpu_memory_;
   bool bytes_available_gpu_memory_overridden_;
 
+  // The maximum amount of memory that can be allocated for GPU resources
+  // in backgrounded renderers.
+  size_t bytes_backgrounded_available_gpu_memory_;
+
   // The current total memory usage, and historical maximum memory usage
   size_t bytes_allocated_current_;
   size_t bytes_allocated_managed_visible_;
   size_t bytes_allocated_managed_backgrounded_;
 
   // The number of browser windows that exist. If we ever receive a
   // GpuMsg_SetVideoMemoryWindowCount, then we use this to compute memory
   // budgets, instead of doing more complicated stub-based calculations.
   bool window_count_has_been_received_;
   uint32 window_count_;
@@ skipping 22 matching lines @@
   // context is currently rendering on. Returns false if no extension exists
   // to get the exact amount of GPU memory.
   virtual bool GetTotalGpuMemory(size_t* bytes) = 0;
 };
 
 }  // namespace content
 
 #endif
 
 #endif // CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_H_