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"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
-#include "base/sys_info.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_memory_allocation.h"
 #include "content/common/gpu/gpu_memory_manager_client.h"
 #include "content/common/gpu/gpu_memory_tracking.h"
 #include "content/common/gpu/gpu_memory_uma_stats.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 
 namespace content {
 namespace {
@@ skipping 118 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;
-#if !defined(OS_ANDROID)
-  return viewport_limit;
-#else
-  static uint64 dalvik_limit = 0;
-  if (!dalvik_limit)
-      dalvik_limit = (base::SysInfo::DalvikHeapSizeMB() / 2) * 1024 * 1024;
-  return std::min(viewport_limit, 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;
-#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();
       it != clients_visible_mru_.end();
       ++it) {
     const GpuMemoryManagerClientState* client_state = *it;
     if (!client_state->has_surface_)
       continue;
     if (!client_state->visible_)
       continue;
 
-#if defined(OS_ANDROID)
-    gfx::Size surface_size = client_state->client_->GetSurfaceSize();
-    max_surface_area = std::max(max_surface_area, surface_size.width() *
-                                                  surface_size.height());
-#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);
-#else
   if (!bytes_min)
     return;
 
+#if defined(OS_ANDROID)
+  // We don't need to reduce the total on Android, since

[ccameron, 2013/02/12 01:56:23]

Nit: can you put this #if inside CalcAvialbleFromGpuTotal?

+  // the total is an estimate to begin with.
+  bytes_available_gpu_memory_ = bytes_min;
+#else
   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());
 
   // Never go above the maximum.
   bytes_available_gpu_memory_ = std::min(bytes_available_gpu_memory_,
                                          GetMaximumTotalGpuMemory());
@@ skipping 809 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