Move gpu memory calculations to Compositor.

content/renderer/gpu/render_widget_compositor.cc

Index: content/renderer/gpu/render_widget_compositor.cc
diff --git a/content/renderer/gpu/render_widget_compositor.cc b/content/renderer/gpu/render_widget_compositor.cc
index 7f83ee9415092d775890b5de5b2bc8e46667367a..5f9f49aad4333d3063f7e2ad96322a1edf9eadcf 100644
--- a/content/renderer/gpu/render_widget_compositor.cc
+++ b/content/renderer/gpu/render_widget_compositor.cc
@@ -466,6 +466,9 @@ void RenderWidgetCompositor::Initialize() {
   if (base::SysInfo::IsLowEndDevice())
     settings.max_staging_buffers /= 4;
 
+  cc::ManagedMemoryPolicy current = settings.memory_policy_;
+  settings.memory_policy_ = GetGpuMemoryPolicy(current);
+
   scoped_refptr<base::SingleThreadTaskRunner> compositor_thread_task_runner =
       compositor_deps_->GetCompositorImplThreadTaskRunner();
   scoped_refptr<base::SingleThreadTaskRunner>
@@ -1047,4 +1050,55 @@ void RenderWidgetCompositor::SetSurfaceIdNamespace(
   layer_tree_host_->set_surface_id_namespace(surface_id_namespace);
 }
 
+cc::ManagedMemoryPolicy RenderWidgetCompositor::GetGpuMemoryPolicy(
+    cc::ManagedMemoryPolicy& policy) {
+  cc::ManagedMemoryPolicy actual = policy;

[ccameron, 2015/09/11 18:22:58]

This needs an #if android around it.

[sohanjg, 2015/09/14 14:32:39]

Done.

+
+  // We can't query available GPU memory from the system on Android.
+  // Physical memory is also mis-reported sometimes (eg. Nexus 10 reports
+  // 1262MB when it actually has 2GB, while Razr M has 1GB but only reports
+  // 128MB java heap size). First we estimate physical memory using both.
+  size_t dalvik_mb = base::SysInfo::DalvikHeapSizeMB();
+  size_t physical_mb = base::SysInfo::AmountOfPhysicalMemoryMB();
+  size_t physical_memory_mb = 0;
+  if (dalvik_mb >= 256)
+    physical_memory_mb = dalvik_mb * 4;
+  else
+    physical_memory_mb = std::max(dalvik_mb * 4, (physical_mb * 4) / 3);
+
+  // Now we take a default of 1/8th of memory on high-memory devices,
+  // and gradually scale that back for low-memory devices (to be nicer
+  // to other apps so they don't get killed). Examples:
+  // Nexus 4/10(2GB)    256MB (normally 128MB)
+  // Droid Razr M(1GB)  114MB (normally 57MB)
+  // Galaxy Nexus(1GB)  100MB (normally 50MB)
+  // Xoom(1GB)          100MB (normally 50MB)
+  // Nexus S(low-end)   8MB (normally 8MB)
+  // Note that the compositor now uses only some of this memory for
+  // pre-painting and uses the rest only for 'emergencies'.
+  static size_t limit_bytes = 0;
+  if (limit_bytes == 0) {
+    // NOTE: Non-low-end devices use only 50% of these limits,
+    // except during 'emergencies' where 100% can be used.
+    if (!base::SysInfo::IsLowEndDevice()) {
+      if (physical_memory_mb >= 1536)
+        limit_bytes = physical_memory_mb / 8;  // >192MB
+      else if (physical_memory_mb >= 1152)
+        limit_bytes = physical_memory_mb / 8;  // >144MB
+      else if (physical_memory_mb >= 768)
+        limit_bytes = physical_memory_mb / 10;  // >76MB
+      else
+        limit_bytes = physical_memory_mb / 12;  // <64MB
+    } else {
+      // Low-end devices have 512MB or less memory by definition
+      // so we hard code the limit rather than relying on the heuristics
+      // above. Low-end devices use 4444 textures so we can use a lower limit.
+      limit_bytes = 8;
+    }
+    limit_bytes = limit_bytes * 1024 * 1024;
+  }
+  actual.bytes_limit_when_visible = limit_bytes;
+  return actual;
+}
+
 }  // namespace content