cc: Set the mapped memory reclaim limit for the renderer compositor on Android

content/renderer/gpu/render_widget_compositor.cc

 // Copyright (c) 2013 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/renderer/gpu/render_widget_compositor.h"
 
 #include <limits>
 #include <string>
 
+#if defined(OS_ANDROID)
+#include "base/android/sys_utils.h"
+#endif
+
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "cc/base/switches.h"
 #include "cc/debug/layer_tree_debug_state.h"
 #include "cc/layers/layer.h"
 #include "cc/trees/layer_tree_host.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
@@ skipping 259 matching lines @@
       widget->UsingSynchronousRendererCompositor();
 #elif !defined(OS_MACOSX)
   if (cmd->HasSwitch(switches::kEnableOverlayScrollbars)) {
     settings.use_linear_fade_scrollbar_animator = true;
     settings.solid_color_scrollbars = true;
     settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
     settings.solid_color_scrollbar_thickness_dip = 3;
   }
 #endif
 
+// If we raster too fast we become upload bound, and pending
+// uploads consume memory. For maximum upload throughput, we would
+// want to allow for upload_throughput * pipeline_time of pending
+// uploads, after which we are just wasting memory. Since we don't
+// know our upload throughput yet, this just caps our memory usage.
+#if defined(OS_ANDROID)
+  size_t divider = 1;
+  if (base::android::SysUtils::IsLowEndDevice())
+    divider = 3;
+
+  // For reference Nexus10 can upload 1MB in about 2.5ms.
+  const size_t kMaxBytesUploadedPerMs = (2 * 1024 * 1024) / (5 * divider);
+#else
+  // For reference Chromebook Pixel can upload 1MB in about 0.5ms.
+  const size_t kMaxBytesUploadedPerMs = 1024 * 1024 * 2;
+#endif
+
+  // Assuming a two frame deep pipeline.
+  const size_t kMsPerFrame = 16;
+  settings.max_transfer_buffer_usage_bytes =
+      2 * kMsPerFrame * kMaxBytesUploadedPerMs;
+  compositor->SetMaxTransferBufferUsageBytes(
+      settings.max_transfer_buffer_usage_bytes);
+
   if (!compositor->initialize(settings))
     return scoped_ptr<RenderWidgetCompositor>();
 
   return compositor.Pass();
 }
 
 RenderWidgetCompositor::RenderWidgetCompositor(RenderWidget* widget,
                                                bool threaded)
     : threaded_(threaded),
       suppress_schedule_composite_(false),
-      widget_(widget) {
+      widget_(widget),
+      max_transfer_buffer_usage_bytes_(0) {
 }
 
 RenderWidgetCompositor::~RenderWidgetCompositor() {}
 
 const base::WeakPtr<cc::InputHandler>&
 RenderWidgetCompositor::GetInputHandler() {
   return layer_tree_host_->GetInputHandler();
 }
 
 void RenderWidgetCompositor::SetSuppressScheduleComposite(bool suppress) {
@@ skipping 235 matching lines @@
   widget_->webwidget()->layout();
 }
 
 void RenderWidgetCompositor::ApplyScrollAndScale(gfx::Vector2d scroll_delta,
                                                  float page_scale) {
   widget_->webwidget()->applyScrollAndScale(scroll_delta, page_scale);
 }
 
 scoped_ptr<cc::OutputSurface> RenderWidgetCompositor::CreateOutputSurface(
     bool fallback) {
-  return widget_->CreateOutputSurface(fallback);
+  return widget_->CreateOutputSurface(fallback,
+                                      max_transfer_buffer_usage_bytes_);

[danakj, 2013/08/23 23:25:39]

You could just pass the value from the layer_tree_host_->settings(). And not
need to store anything new here.

Or maybe RenderWidget could get the settings value directly too.

[kaanb, 2013/08/24 00:25:01]

Apparently there are cases where layer_tree_host_ is NULL when this method is
called and we're crashing if I try to access layer_tree_host_->settings()

[danakj, 2013/08/24 00:25:52]

What, this is called from LayertreeHost. Can you give a callstack?

 }
 
 void RenderWidgetCompositor::DidInitializeOutputSurface(bool success) {
   if (!success)
     widget_->webwidget()->didExitCompositingMode();
 }
 
 void RenderWidgetCompositor::WillCommit() {
   widget_->InstrumentWillComposite();
 }
@@ skipping 20 matching lines @@
 RenderWidgetCompositor::OffscreenContextProviderForMainThread() {
   return RenderThreadImpl::current()->OffscreenContextProviderForMainThread();
 }
 
 scoped_refptr<cc::ContextProvider>
 RenderWidgetCompositor::OffscreenContextProviderForCompositorThread() {
   return RenderThreadImpl::current()->
       OffscreenContextProviderForCompositorThread();
 }
 
+void RenderWidgetCompositor::SetMaxTransferBufferUsageBytes(
+    size_t max_transfer_buffer_usage_bytes) {
+  max_transfer_buffer_usage_bytes_ = max_transfer_buffer_usage_bytes;
+}
+
 }  // namespace content