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 1567 matching lines @@
   }
 
   if (renderer_) {
     renderer_->SetVisible(visible_);
     SetFullRootLayerDamage();
   }
 }
 
 void LayerTreeHostImpl::CreateAndSetTileManager(
     ResourceProvider* resource_provider,
-    bool using_map_image) {
+    bool using_map_image,
+    ContextProvider* context_provider) {
   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);
+                                      using_map_image,
+                                      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(),
-                            GetRendererCapabilities().using_map_image);
+                            GetRendererCapabilities().using_map_image,
+                            output_surface->context_provider().get());
   }
 
   // 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);
 
     output_surface->InitializeBeginFrameEmulation(
@@ skipping 91 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(),
-                          GetRendererCapabilities().using_map_image);
+                          GetRendererCapabilities().using_map_image,
+                          NULL);
+
   DCHECK(tile_manager_);
 
   SetOffscreenContextProvider(NULL);
 
   client_->SetNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::SetViewportSize(gfx::Size device_viewport_size) {
   if (device_viewport_size == device_viewport_size_)
     return;
@@ skipping 806 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