Rename SurfaceState to MemoryManagerState

content/common/gpu/gpu_memory_manager.cc

 // 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.
 
 #include "content/common/gpu/gpu_memory_manager.h"
 
 #if defined(ENABLE_GPU)
 
 #include <algorithm>
 
@@ skipping 118 matching lines @@
                                          GetDefaultAvailableGpuMemory());
 
   // And never go above 1GB
   bytes_available_gpu_memory_ = std::min(bytes_available_gpu_memory_,
                                          static_cast<size_t>(1024*1024*1024));
 }
 
 bool GpuMemoryManager::StubWithSurfaceComparator::operator()(
     GpuCommandBufferStubBase* lhs,
     GpuCommandBufferStubBase* rhs) {
-  DCHECK(lhs->has_surface_state() && rhs->has_surface_state());
-  const GpuCommandBufferStubBase::SurfaceState& lhs_ss = lhs->surface_state();
-  const GpuCommandBufferStubBase::SurfaceState& rhs_ss = rhs->surface_state();
-  if (lhs_ss.visible)
-    return !rhs_ss.visible || (lhs_ss.last_used_time > rhs_ss.last_used_time);
+  DCHECK(lhs->memory_manager_state().has_surface &&
+         rhs->memory_manager_state().has_surface);
+  const GpuCommandBufferStubBase::MemoryManagerState& lhs_mms =
+      lhs->memory_manager_state();
+  const GpuCommandBufferStubBase::MemoryManagerState& rhs_mms =
+      rhs->memory_manager_state();
+  if (lhs_mms.visible)
+    return !rhs_mms.visible || (lhs_mms.last_used_time >
+                                rhs_mms.last_used_time);
   else
-    return !rhs_ss.visible && (lhs_ss.last_used_time > rhs_ss.last_used_time);
+    return !rhs_mms.visible && (lhs_mms.last_used_time >
+                                rhs_mms.last_used_time);
 };
 
 void GpuMemoryManager::ScheduleManage(bool immediate) {
   if (manage_immediate_scheduled_)
     return;
   if (immediate) {
     MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&GpuMemoryManager::Manage, AsWeakPtr()));
     manage_immediate_scheduled_ = true;
@@ skipping 104 matching lines @@
   // Create stub lists by separating out the two types received from client
   std::vector<GpuCommandBufferStubBase*> stubs_with_surface;
   std::vector<GpuCommandBufferStubBase*> stubs_without_surface;
   {
     std::vector<GpuCommandBufferStubBase*> stubs;
     client_->AppendAllCommandBufferStubs(stubs);
 
     for (std::vector<GpuCommandBufferStubBase*>::iterator it = stubs.begin();
         it != stubs.end(); ++it) {
       GpuCommandBufferStubBase* stub = *it;
-      if (!stub->client_has_memory_allocation_changed_callback())
+      if (!stub->memory_manager_state().
+         client_has_memory_allocation_changed_callback)
         continue;
-      if (stub->has_surface_state())
+      if (stub->memory_manager_state().has_surface)
         stubs_with_surface.push_back(stub);
       else
         stubs_without_surface.push_back(stub);
     }
   }
 
   // Sort stubs with surface into {visibility,last_used_time} order using
   // custom comparator
   std::sort(stubs_with_surface.begin(),
             stubs_with_surface.end(),
             StubWithSurfaceComparator());
   DCHECK(std::unique(stubs_with_surface.begin(), stubs_with_surface.end()) ==
          stubs_with_surface.end());
 
   // Separate stubs into memory allocation sets.
   std::vector<GpuCommandBufferStubBase*> stubs_with_surface_foreground,
                                          stubs_with_surface_background,
                                          stubs_with_surface_hibernated,
                                          stubs_without_surface_foreground,
                                          stubs_without_surface_background,
                                          stubs_without_surface_hibernated;
 
   for (size_t i = 0; i < stubs_with_surface.size(); ++i) {
     GpuCommandBufferStubBase* stub = stubs_with_surface[i];
-    DCHECK(stub->has_surface_state());
-    if (stub->surface_state().visible)
+    DCHECK(stub->memory_manager_state().has_surface);
+    if (stub->memory_manager_state().visible)
       stubs_with_surface_foreground.push_back(stub);
     else if (i < max_surfaces_with_frontbuffer_soft_limit_)
       stubs_with_surface_background.push_back(stub);
     else
       stubs_with_surface_hibernated.push_back(stub);
   }
   for (std::vector<GpuCommandBufferStubBase*>::const_iterator it =
       stubs_without_surface.begin(); it != stubs_without_surface.end(); ++it) {
     GpuCommandBufferStubBase* stub = *it;
-    DCHECK(!stub->has_surface_state());
+    DCHECK(!stub->memory_manager_state().has_surface);
 
     // Stubs without surfaces have deduced allocation state using the state
     // of surface stubs which are in the same context share group.
     if (IsInSameContextShareGroupAsAnyOf(stub, stubs_with_surface_foreground))
       stubs_without_surface_foreground.push_back(stub);
     else if (IsInSameContextShareGroupAsAnyOf(
         stub, stubs_with_surface_background))
       stubs_without_surface_background.push_back(stub);
     else
       stubs_without_surface_hibernated.push_back(stub);
@@ skipping 75 matching lines @@
       false);
 
   AssignMemoryAllocations(
       &stub_memory_stats_for_last_manage_,
       stubs_without_surface_hibernated,
       GpuMemoryAllocation(0, GpuMemoryAllocation::kHasNoBuffers),
       false);
 }
 
 #endif