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

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
+#include <limits>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/math_util.h"
@@ skipping 44 matching lines @@
                              "LayerTreeHostImpl::SetVisible",
                              id,
                              "LayerTreeHostImpl",
                              id);
     return;
   }
 
   TRACE_EVENT_ASYNC_END0("webkit", "LayerTreeHostImpl::SetVisible", id);
 }
 
+size_t GetMaxTransferBufferUsageBytes(cc::ContextProvider* context_provider) {
+  if (context_provider) {
+    // We want to make sure the default transfer buffer size is equal to the
+    // amount of data that can be uploaded by the compositor to avoid stalling
+    // the pipeline.
+    // For reference Chromebook Pixel can upload 1MB in about 0.5ms.
+    const size_t kMaxBytesUploadedPerMs = 1024 * 1024 * 2;
+    // Assuming a two frame deep pipeline between CPU and GPU and we are
+    // drawing 60 frames per second which would require us to draw one
+    // frame in 16 milliseconds.
+    const size_t kMaxTransferBufferUsageBytes = 16 * 2 * kMaxBytesUploadedPerMs;
+    return std::min(
+        context_provider->ContextCapabilities().max_transfer_buffer_usage_bytes,
+        kMaxTransferBufferUsageBytes);
+  } else {
+    // Software compositing should not use this value in production. Just use a
+    // default value when testing uploads with the software compositor.
+    return std::numeric_limits<size_t>::max();
+  }
+}
+
 }  // namespace
 
 namespace cc {
 
 class LayerTreeHostImplTimeSourceAdapter : public TimeSourceClient {
  public:
   static scoped_ptr<LayerTreeHostImplTimeSourceAdapter> Create(
       LayerTreeHostImpl* layer_tree_host_impl,
       scoped_refptr<DelayBasedTimeSource> time_source) {
     return make_scoped_ptr(
@@ skipping 1505 matching lines @@
   }
 
   if (renderer_) {
     renderer_->SetVisible(visible_);
     SetFullRootLayerDamage();
   }
 }
 
 void LayerTreeHostImpl::CreateAndSetTileManager(
     ResourceProvider* resource_provider,
+    ContextProvider* context_provider,
     bool using_map_image) {
   DCHECK(settings_.impl_side_painting);
   DCHECK(resource_provider);
-  tile_manager_ = TileManager::Create(this,
-                                      resource_provider,
-                                      settings_.num_raster_threads,
-                                      rendering_stats_instrumentation_,
-                                      using_map_image);
+  tile_manager_ =
+      TileManager::Create(this,
+                          resource_provider,
+                          settings_.num_raster_threads,
+                          rendering_stats_instrumentation_,
+                          using_map_image,
+                          GetMaxTransferBufferUsageBytes(context_provider));
+
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
   need_to_update_visible_tiles_before_draw_ = false;
 }
 
 void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget) {
   SetManagedMemoryPolicy(cached_managed_memory_policy_, zero_budget);
 }
 
 bool LayerTreeHostImpl::InitializeRenderer(
     scoped_ptr<OutputSurface> output_surface) {
@@ skipping 23 matching lines @@
 
   bool skip_gl_renderer = false;
   CreateAndSetRenderer(
       output_surface.get(), resource_provider.get(), skip_gl_renderer);
 
   if (!renderer_)
     return false;
 
   if (settings_.impl_side_painting) {
     CreateAndSetTileManager(resource_provider.get(),
+                            output_surface->context_provider().get(),
                             GetRendererCapabilities().using_map_image);
   }
 
   // Setup BeginFrameEmulation if it's not supported natively
   if (!settings_.begin_frame_scheduling_enabled) {
     const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(
           base::Time::kMicrosecondsPerSecond /
           settings_.refresh_rate);
 
@@ skipping 92 matching lines @@
   tile_manager_.reset();
   resource_provider_->InitializeSoftware();
 
   bool skip_gl_renderer = true;
   CreateAndSetRenderer(
       output_surface_.get(), resource_provider_.get(), skip_gl_renderer);
   DCHECK(renderer_);
 
   EnforceZeroBudget(true);
   CreateAndSetTileManager(resource_provider_.get(),
+                          NULL,
                           GetRendererCapabilities().using_map_image);
   DCHECK(tile_manager_);
 
   SetOffscreenContextProvider(NULL);
 
   client_->SetNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::SetViewportSize(gfx::Size device_viewport_size) {
   if (device_viewport_size == device_viewport_size_)
@@ skipping 807 matching lines @@
 
 ResourceProvider::ResourceId LayerTreeHostImpl::ResourceIdForUIResource(
     UIResourceId uid) const {
   UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
   if (iter != ui_resource_map_.end())
     return iter->second;
   return 0;
 }
 
 }  // namespace cc