Make names consistent in GpuMemoryManager

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 85 matching lines @@
                            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;
+  size_t GetCurrentNonvisibleAvailableGpuMemory() const;
   void AssignSurfacesAllocationsNonuniform();
   void AssignSurfacesAllocationsUniform();
   void AssignNonSurfacesAllocations();
 
   // 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();
+  void UpdateNonvisibleAvailableGpuMemory();
 
   // 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.
   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;
+  size_t GetMaximumClientAllocation() const;
+  size_t GetMinimumClientAllocation() 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);
 
   // Send memory usage stats to the browser process.
   void SendUmaStatsToBrowser();
 
   // Get the current number of bytes allocated.
   size_t GetCurrentUsage() const {
@@ skipping 32 matching lines @@
 
   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;
+  void TestingSetNonvisibleAvailableGpuMemory(size_t bytes) {
+    bytes_nonvisible_available_gpu_memory_ = bytes;
   }
 
   GpuChannelManager* channel_manager_;
 
   // The new memory policy does not uniformly assign memory to tabs, but
   // scales the assignments to the tabs' needs.
   bool use_nonuniform_memory_policy_;
 
   // A list of all visible and nonvisible clients, in most-recently-used
   // order (most recently used is first).
@@ skipping 13 matching lines @@
 
   // 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_;
+  // in nonvisible renderers.
+  size_t bytes_nonvisible_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_managed_nonvisible_;
   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.
+  // allocations, 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 // CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_H_