GpuMemoryManager should limit memory allocations based on viewport size for android.

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 {
 
 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,
+#if defined(OS_ANDROID)
+size_t CalculateBonusMemoryAllocationBasedOnSize(gfx::Size size) {
+  const int viewportMultiplier = 16;
+  unsigned int componentsPerPixel = 4; // GraphicsContext3D::RGBA

[jonathan.backer, 2012/05/04 14:25:28]

const

+  unsigned int bytesPerComponent = 1; // sizeof(GC3Dubyte)
+
+  if (size.IsEmpty())
+    return 0;
+
+  size_t limit = viewportMultiplier * size.width() * size.height() *
+                     componentsPerPixel * bytesPerComponent;
+  if (limit < GpuMemoryManager::kMinimumAllocationForTab)
+    limit = GpuMemoryManager::kMinimumAllocationForTab;
+  else if (limit > GpuMemoryManager::kMaximumAllocationForTabs)
+    limit = GpuMemoryManager::kMaximumAllocationForTabs;
+  return limit - GpuMemoryManager::kMinimumAllocationForTab;
+}
+#endif
+
+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,
@@ skipping 115 matching lines @@
     // 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);
   }
 
-  // Calculate memory allocation size in bytes given to each stub, by sharing
-  // global limit equally among those that need it.
+  size_t bonus_allocation = 0;
+#if !defined(OS_ANDROID)
+  // Calculate bonus allocation by splitting remainder of global limit equally
+  // after giving out the minimum to 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();
+#else
+  // On android, calculate bonus allocation based on surface size.
+  if (!stubs_with_surface_foreground.empty())
+    bonus_allocation = CalculateBonusMemoryAllocationBasedOnSize(
+        stubs_with_surface_foreground[0]->GetSurfaceSize());
+#endif
 
   // 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