base: Fix parsing and add dalvik-heap-limit

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"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 133 matching lines @@
 #if defined(OS_ANDROID) || defined(OS_CHROMEOS)
   return bytes_available_gpu_memory_;
 #else
   // This is to avoid allowing a single page on to use a full 256MB of memory
   // (the current total limit). Long-scroll pages will hit this limit,
   // resulting in instability on some platforms (e.g, issue 141377).
   return bytes_available_gpu_memory_ / 2;
 #endif
 }
 
-uint64 GpuMemoryManager::CalcAvailableFromViewportArea(int viewport_area) {
-  // We can't query available GPU memory from the system on Android, but
-  // 18X the viewport and 50% of the dalvik heap size give us a good
-  // estimate of available GPU memory on a wide range of devices.
-  const int kViewportMultiplier = 18;
-  const unsigned int kComponentsPerPixel = 4; // GraphicsContext3D::RGBA
-  const unsigned int kBytesPerComponent = 1; // sizeof(GC3Dubyte)
-  uint64 viewport_limit = viewport_area * kViewportMultiplier *
-                                          kComponentsPerPixel *
-                                          kBytesPerComponent;
+uint64 GpuMemoryManager::CalcAvailableFromDalvikHeap() {
 #if !defined(OS_ANDROID)
-  return viewport_limit;
+  CHECK(false);
+  return 0;
 #else
+  // We can't query available GPU memory from the system on Android,
+  // but the dalvik heap size give us a good estimate of available
+  // GPU memory on a wide range of devices.
+
+  // The heap size tends to be about 1/4 of total ram on higher end
+  // devices, so we use 1/2 of that by default. For example both the
+  // Nexus 4/10 have 2GB of ram and 512MB Dalvik heap size. For lower
+  // end devices, 1/2 of the heap size can be too high, but this
+  // correlates well with having a small heap-growth-limit. So for
+  // devices with less ram, we factor in the growth limit.
+
+  // This is the result of the calculation below:
+  // Droid DNA 1080P  128MB
+  // Nexus S           56MB
+  // Galaxy Nexus     112MB
+  // Nexus 4/10       256MB
+  // Xoom              88MB
+
   static uint64 dalvik_limit = 0;
-  if (!dalvik_limit)
-      dalvik_limit = (base::SysInfo::DalvikHeapSizeMB() / 2) * 1024 * 1024;
-  return std::min(viewport_limit, dalvik_limit);
+  if (!dalvik_limit) {
+    uint64 heap_size   = base::SysInfo::DalvikHeapSizeMB();
+    uint64 heap_growth = base::SysInfo::DalvikHeapGrowthLimitMB();
+    uint64 limit = 0;
+
+    if (heap_size >= 350)
+        limit = heap_size / 2;
+    else
+        limit = (heap_size + (heap_growth * 2)) / 4;
+
+    dalvik_limit = limit * 1024 * 1024;
+  }
+
+  return dalvik_limit;
 #endif
 }
 
 uint64 GpuMemoryManager::CalcAvailableFromGpuTotal(uint64 total_gpu_memory) {
   // Allow Chrome to use 75% of total GPU memory, or all-but-64MB of GPU
   // memory, whichever is less.
   return std::min(3 * total_gpu_memory / 4, total_gpu_memory - 64*1024*1024);
 }
 
 void GpuMemoryManager::UpdateAvailableGpuMemory() {
   // If the amount of video memory to use was specified at the command
   // line, never change it.
   if (bytes_available_gpu_memory_overridden_)
     return;
 
 #if defined(OS_ANDROID)
   // On Android we use the surface size, so this finds the largest visible
   // surface size instead of lowest gpu's limit.
   int max_surface_area = 0;

[ccameron, 2013/02/11 20:05:33]

Can kill off max_surface_area here.

 #else
   // On non-Android, we use an operating system query when possible.
   // We do not have a reliable concept of multiple GPUs existing in
   // a system, so just be safe and go with the minimum encountered.
   uint64 bytes_min = 0;
 #endif
 
   // Only use the clients that are visible, because otherwise the set of clients
   // we are querying could become extremely large.
   for (ClientStateList::const_iterator it = clients_visible_mru_.begin();
@@ skipping 12 matching lines @@
 #else
     uint64 bytes = 0;
     if (client_state->client_->GetTotalGpuMemory(&bytes)) {
       if (!bytes_min || bytes < bytes_min)
         bytes_min = bytes;
     }
 #endif
   }
 
 #if defined(OS_ANDROID)
-  bytes_available_gpu_memory_ = CalcAvailableFromViewportArea(max_surface_area);
+  bytes_available_gpu_memory_ = CalcAvailableFromDalvikHeap();
 #else
   if (!bytes_min)
     return;
 
   bytes_available_gpu_memory_ = CalcAvailableFromGpuTotal(bytes_min);
 #endif
 
   // Never go below the default allocation
   bytes_available_gpu_memory_ = std::max(bytes_available_gpu_memory_,
                                          GetDefaultAvailableGpuMemory());
@@ skipping 813 matching lines @@
 
 void GpuMemoryManager::RemoveClientFromList(
     GpuMemoryManagerClientState* client_state) {
   DCHECK(client_state->list_iterator_valid_);
   ClientStateList* client_list = GetClientList(client_state);
   client_list->erase(client_state->list_iterator_);
   client_state->list_iterator_valid_ = false;
 }
 
 }  // namespace content