Revert 134428 - GpuMemoryManager suggests values for renderer Contents Texture Managers' preferred …

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>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "content/common/gpu/gpu_command_buffer_stub.h"
 #include "content/common/gpu/gpu_memory_allocation.h"
 
 namespace {
 
+// These are predefined values (in bytes) for
+// GpuMemoryAllocation::gpuResourceSizeInBytes.  Currently, the value is only
+// used to check if it is 0 or non-0.  In the future, these values will not
+// come from constants, but rather will be distributed dynamically.
+enum {
+  kResourceSizeNonHibernatedTab = 1,
+  kResourceSizeHibernatedTab = 0
+};
+
 bool IsInSameContextShareGroupAsAnyOf(
     const GpuCommandBufferStubBase* stub,
     const std::vector<GpuCommandBufferStubBase*>& stubs) {
   for (std::vector<GpuCommandBufferStubBase*>::const_iterator it =
       stubs.begin(); it != stubs.end(); ++it) {
     if (stub->IsInSameContextShareGroup(**it))
       return true;
   }
   return false;
 }
 
-void AssignMemoryAllocations(std::vector<GpuCommandBufferStubBase*>& stubs,
-    GpuMemoryAllocation allocation) {
-  for (std::vector<GpuCommandBufferStubBase*>::iterator it = stubs.begin();
-      it != stubs.end(); ++it) {
-    (*it)->SetMemoryAllocation(allocation);
-  }
-}
-
 }
 
 GpuMemoryManager::GpuMemoryManager(GpuMemoryManagerClient* client,
         size_t max_surfaces_with_frontbuffer_soft_limit)
     : client_(client),
       manage_scheduled_(false),
       max_surfaces_with_frontbuffer_soft_limit_(
           max_surfaces_with_frontbuffer_soft_limit),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
@@ skipping 45 matching lines @@
 //  1. These contexts do not track {visibility,last_used_time}, so cannot
 //     sort them directly.
 //  2. These contexts may be used by, and thus affect, other contexts, and so
 //     cannot be less visible than any affected context.
 //  3. Contexts belong to share groups within which resources can be shared.
 //
 // As such, the rule for categorizing contexts without a surface is:
 //  1. Find the most visible context-with-a-surface within each
 //     context-without-a-surface's share group, and inherit its visibilty.
 void GpuMemoryManager::Manage() {
+  // Set up three allocation values for the three possible stub states
+  const GpuMemoryAllocation all_buffers_allocation(
+      kResourceSizeNonHibernatedTab, true, true);
+  const GpuMemoryAllocation front_buffers_allocation(
+      kResourceSizeNonHibernatedTab, false, true);
+  const GpuMemoryAllocation no_buffers_allocation(
+      kResourceSizeHibernatedTab, false, false);
+
   manage_scheduled_ = false;
 
   // 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())
-        continue;
       if (stub->has_surface_state())
         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;
+  std::vector<GpuCommandBufferStubBase*> all_buffers, front_buffers, no_buffers;
 
   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)
-      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);
+    if (stub->surface_state().visible) {
+      all_buffers.push_back(stub);
+      stub->SetMemoryAllocation(all_buffers_allocation);
+    } else if (i < max_surfaces_with_frontbuffer_soft_limit_) {
+      front_buffers.push_back(stub);
+      stub->SetMemoryAllocation(front_buffers_allocation);
+    } else {
+      no_buffers.push_back(stub);
+      stub->SetMemoryAllocation(no_buffers_allocation);
+    }
   }
+
+  // Now, go through the stubs without surfaces and deduce visibility using the
+  // visibility of stubs which are in the same context share group.
   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());
-
-    // 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);
+    if (IsInSameContextShareGroupAsAnyOf(stub, all_buffers)) {
+      stub->SetMemoryAllocation(all_buffers_allocation);
+    } else if (IsInSameContextShareGroupAsAnyOf(stub, front_buffers)) {
+      stub->SetMemoryAllocation(front_buffers_allocation);
+    } else {
+      stub->SetMemoryAllocation(no_buffers_allocation);
+    }
   }
-
-  // Calculate memory allocation size in bytes given to each stub, by sharing
-  // global limit equally among those that need it.
-  size_t num_stubs_need_mem = stubs_with_surface_foreground.size() +
-                              stubs_without_surface_foreground.size() +
-                              stubs_without_surface_background.size();
-  size_t base_allocation_size = kMinimumAllocationForTab * num_stubs_need_mem;
-  size_t bonus_allocation = 0;
-  if (base_allocation_size < kMaximumAllocationForTabs &&
-      !stubs_with_surface_foreground.empty())
-    bonus_allocation = (kMaximumAllocationForTabs - base_allocation_size) /
-                           stubs_with_surface_foreground.size();
-
-  // Now give out allocations to everyone.
-  AssignMemoryAllocations(stubs_with_surface_foreground,
-      GpuMemoryAllocation(kMinimumAllocationForTab + bonus_allocation,
-          GpuMemoryAllocation::kHasFrontbuffer |
-          GpuMemoryAllocation::kHasBackbuffer));
-
-  AssignMemoryAllocations(stubs_with_surface_background,
-      GpuMemoryAllocation(0, GpuMemoryAllocation::kHasFrontbuffer));
-
-  AssignMemoryAllocations(stubs_with_surface_hibernated,
-      GpuMemoryAllocation(0, GpuMemoryAllocation::kHasNoBuffers));
-
-  AssignMemoryAllocations(stubs_without_surface_foreground,
-      GpuMemoryAllocation(kMinimumAllocationForTab,
-          GpuMemoryAllocation::kHasNoBuffers));
-
-  AssignMemoryAllocations(stubs_without_surface_background,
-      GpuMemoryAllocation(kMinimumAllocationForTab,
-          GpuMemoryAllocation::kHasNoBuffers));
-
-  AssignMemoryAllocations(stubs_without_surface_hibernated,
-      GpuMemoryAllocation(0, GpuMemoryAllocation::kHasNoBuffers));
 }
 
 #endif