Account for unmanaged (e.g, WebGL) use in memory manager

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 <list>
@@ skipping 69 matching lines @@
   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);
+  FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
+                           TestUnmanagedTracking);
 
   typedef std::map<gpu::gles2::MemoryTracker*, GpuMemoryTrackingGroup*>
       TrackingGroupMap;
 
   typedef std::list<GpuMemoryManagerClientState*> ClientStateList;
 
   void Manage();
   void SetClientsHibernatedState() const;
   size_t GetVisibleClientAllocation() 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();
+  void UpdateUnmanagedMemoryLimits();
   void UpdateBackgroundedAvailableGpuMemory();
 
   // The amount of video memory which is available for allocation.
   size_t GetAvailableGpuMemory() const;
 
   // 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.
@@ skipping 38 matching lines @@
   void RemoveClientFromList(GpuMemoryManagerClientState* client_state);
   ClientStateList* GetClientList(GpuMemoryManagerClientState* client_state);
 
   // Interfaces for testing
   void TestingDisableScheduleManage() { disable_schedule_manage_ = true; }
   void TestingSetAvailableGpuMemory(size_t bytes) {
     bytes_available_gpu_memory_ = bytes;
     bytes_available_gpu_memory_overridden_ = true;
   }
 
+  void TestingSetMinimumClientAllocation(size_t bytes) {
+    bytes_minimum_per_client_ = bytes;
+    bytes_minimum_per_client_overridden_ = true;
+  }
+
+  void TestingSetUnmanagedLimitStep(size_t bytes) {
+    bytes_unmanaged_limit_step_ = bytes;
+  }
+
   void TestingSetBackgroundedAvailableGpuMemory(size_t bytes) {
     bytes_backgrounded_available_gpu_memory_ = bytes;
   }
 
   GpuChannelManager* channel_manager_;
 
   // A list of all visible and nonvisible clients, in most-recently-used
   // order (most recently used is first).
   ClientStateList clients_visible_mru_;
   ClientStateList clients_nonvisible_mru_;
 
   // A list of all clients that don't have a surface.
   ClientStateList clients_nonsurface_;
 
   // All context groups' tracking structures
   TrackingGroupMap 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 minimum allocation that may be given to a single renderer.
+  size_t bytes_minimum_per_client_;
+  bool bytes_minimum_per_client_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_managed_current_;
   size_t bytes_allocated_managed_visible_;
   size_t bytes_allocated_managed_backgrounded_;
   size_t bytes_allocated_unmanaged_current_;
   size_t bytes_allocated_historical_max_;
 
+  // If bytes_allocated_unmanaged_current_ leaves the interval [low_, high_),
+  // then ScheduleManage to take the change into account.
+  size_t bytes_allocated_unmanaged_high_;
+  size_t bytes_allocated_unmanaged_low_;
+
+  // Update bytes_allocated_unmanaged_low/high_ in intervals of step_.
+  size_t bytes_unmanaged_limit_step_;
+
   // 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_;
 
   // Used to disable automatic changes to Manage() in testing.
   bool disable_schedule_manage_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuMemoryManager);
 };
 
 }  // namespace content
 
 #endif
 
 #endif // CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_H_