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 "base/basictypes.h"
 #include "base/containers/hash_tables.h"
@@ skipping 1591 matching lines @@
     renderer_->SetVisible(visible_);
     SetFullRootLayerDamage();
   }
 }
 
 void LayerTreeHostImpl::CreateAndSetTileManager(
     ResourceProvider* resource_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,
+                          settings_.max_transfer_buffer_usage_bytes);

[danakj, 2013/08/24 00:46:22]

So, after going through all of that.. I find it a bit weird that we give this
setting to both LayerTreeSettings, and to the OutputSurface that it's using.

Generally, settings that are tied to an OutputSurface come into the compositor
in the OutputSurface capabilities. When you're here, you have an output surface
that you could read off of.

So, I'd like to propose moving this from the LayerTreeSettings to the
OutputSurface caps.. Then you don't have 2 places caring about the setting in
RenderWidgetCompositor, as just the output surface creation path will care. That
would have the additional benefit of letting the embedder choose a new value
when the output surface changes, if it wanted to.

Also, perhaps this value would want to be different for a software vs a hardware
mode..

[kaanb, 2013/08/24 01:12:54]

Well, I don't think this is really tied to the output surface. It is mostly a
memory usage optimization parameter. But if it makes sense for everyone I'll
move it to OutputSurface::Capabilities

   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 908 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