Add unit tests for nonuniform GPU memmgr policy

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 77 matching lines @@
                            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);
 
+  FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTestNonuniform,
+                           BackgroundMru);
+  FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTestNonuniform,
+                           BackgroundDiscardPersistent);
+  FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTestNonuniform,
+                           UnmanagedTracking);
+  FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTestNonuniform,
+                           DefaultAllocation);

[ccameron, 2013/01/30 21:03:19]

This list is getting fairly absurdly long.  There was the alternative of
friending the base class (GpuMemoryManagerTextNonuniform) and then adding hooks
in the base class for the derived tests to call.  That would be less messy IMO,
but my understanding is that the existing is the preferred mechanism.

+
   typedef std::map<gpu::gles2::MemoryTracker*, GpuMemoryTrackingGroup*>
       TrackingGroupMap;
 
   typedef std::list<GpuMemoryManagerClientState*> ClientStateList;
 
   void Manage();
   void SetClientsHibernatedState() const;
   uint64 GetVisibleClientAllocation() const;
   uint64 GetCurrentNonvisibleAvailableGpuMemory() const;
   void AssignSurfacesAllocationsNonuniform();
@@ skipping 29 matching lines @@
   // 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
   // reports. This is the default value.
   uint64 GetDefaultAvailableGpuMemory() const;
 
   // Maximum cap on total GPU memory, no matter how much the GPU reports.
   uint64 GetMaximumTotalGpuMemory() const;
 
-  // The maximum and minimum amount of memory that a tab may be assigned.
+  // The maximum and minimum amount of memory that a client may be assigned.
   uint64 GetMaximumClientAllocation() const;
-  uint64 GetMinimumClientAllocation() const;
+  uint64 GetMinimumClientAllocation() const {
+    return bytes_minimum_per_client_;
+  }
+  // The default amount of memory that a client is assigned, if it has not
+  // reported any memory usage stats yet.
+  uint64 GetDefaultClientAllocation() const {
+    return bytes_default_per_client_;
+  }
 
   // Get a reasonable memory limit from a viewport's surface area.
   static uint64 CalcAvailableFromViewportArea(int viewport_area);
   static uint64 CalcAvailableFromGpuTotal(uint64 total_gpu_memory);
 
   // Send memory usage stats to the browser process.
   void SendUmaStatsToBrowser();
 
   // Get the current number of bytes allocated.
   uint64 GetCurrentUsage() const {
@@ skipping 18 matching lines @@
       const GpuManagedMemoryStats& stats);
   void OnDestroyClientState(GpuMemoryManagerClientState* client);
 
   // Add or remove a client from its clients list (visible, nonvisible, or
   // nonsurface). When adding the client, add it to the front of the list.
   void AddClientToList(GpuMemoryManagerClientState* client_state);
   void RemoveClientFromList(GpuMemoryManagerClientState* client_state);
   ClientStateList* GetClientList(GpuMemoryManagerClientState* client_state);
 
   // Interfaces for testing
+  void TestingSetUseNonuniformMemoryPolicy(bool use_nonuniform_memory_policy) {
+    use_nonuniform_memory_policy_ = use_nonuniform_memory_policy;
+  }
   void TestingDisableScheduleManage() { disable_schedule_manage_ = true; }
   void TestingSetAvailableGpuMemory(uint64 bytes) {
     bytes_available_gpu_memory_ = bytes;
     bytes_available_gpu_memory_overridden_ = true;
   }
 
   void TestingSetMinimumClientAllocation(uint64 bytes) {
     bytes_minimum_per_client_ = bytes;
-    bytes_minimum_per_client_overridden_ = true;
+  }
+
+  void TestingSetDefaultClientAllocation(uint64 bytes) {
+    bytes_default_per_client_ = bytes;
   }
 
   void TestingSetUnmanagedLimitStep(uint64 bytes) {
     bytes_unmanaged_limit_step_ = bytes;
   }
 
   void TestingSetNonvisibleAvailableGpuMemory(uint64 bytes) {
     bytes_nonvisible_available_gpu_memory_ = bytes;
   }
 
@@ skipping 16 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_;
 
-  // The minimum allocation that may be given to a single renderer.
+  // The minimum and default allocations for a single client.
   uint64 bytes_minimum_per_client_;
-  bool bytes_minimum_per_client_overridden_;
+  uint64 bytes_default_per_client_;
 
   // The maximum amount of memory that can be allocated for GPU resources
   // in nonvisible renderers.
   uint64 bytes_nonvisible_available_gpu_memory_;
 
   // 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_;
@@ skipping 15 matching lines @@
 
   // 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_