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

cc/resources/tile_manager.cc

 // Copyright 2012 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/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 106 matching lines @@
   state->SetInteger("canceled_count", stats.canceled_count);
   return state.PassAs<base::Value>();
 }
 
 // static
 scoped_ptr<TileManager> TileManager::Create(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
-    bool use_map_image) {
+    bool use_map_image,
+    ContextProvider* context_provider) {
   return make_scoped_ptr(
       new TileManager(client,
                       resource_provider,
                       use_map_image ?
                       ImageRasterWorkerPool::Create(
                           resource_provider, num_raster_threads) :
                       PixelBufferRasterWorkerPool::Create(
-                          resource_provider, num_raster_threads),
+                          resource_provider,
+                          num_raster_threads,
+                          GetMaxBytesPendingUpload(context_provider)),
                       num_raster_threads,
                       rendering_stats_instrumentation));
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     scoped_ptr<RasterWorkerPool> raster_worker_pool,
     size_t num_raster_threads,
     RenderingStatsInstrumentation* rendering_stats_instrumentation)
@@ skipping 701 matching lines @@
 
     bytes_releasable_ += tile->bytes_consumed_if_allocated();
     ++resources_releasable_;
   }
 
   FreeUnusedResourcesForTile(tile);
   if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
     did_initialize_visible_tile_ = true;
 }
 
+// static
+size_t TileManager::GetMaxBytesPendingUpload(

[danakj, 2013/09/03 17:18:57]

this could be a file-static method in anonymous namespace.

[reveman, 2013/09/03 18:02:03]

Can we move this logic to the OutputSurface? And consistently refer to it as
TransferBufferUsage?

[danakj, 2013/09/03 18:06:04]

-1 to putting more code in output surface. that should not contain cc-internal
logic.

[reveman, 2013/09/03 18:37:24]

I don't want the TileManager to be aware of if software resources are used. The
logic doesn't have to move to OutputSurface, just some place where we're not
resource type agnostic like TileManager.

[danakj, 2013/09/03 19:06:31]

So, this limit is the max upload that the tile manager is going to use. I'm not
sure where would make more sense? Do you have any ideas? The next step out from
here is LayerTreeHostImpl::CreateAndSetTileManager()

[kaanb, 2013/09/03 20:43:11]

Moved to the anonymous namespace in LTHI

+    ContextProvider* context_provider) {
+  if (context_provider != NULL) {
+    // 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 kMaxBytesPendingUpload = 16 * 2 * kMaxBytesUploadedPerMs;
+    return std::min(
+        context_provider->ContextCapabilities().max_transfer_buffer_usage_bytes,
+        kMaxBytesPendingUpload);
+  } else {
+    // Software compositing should not use this path in production. Just use a
+    // default value when testing this path with software compositor.
+    return std::numeric_limits<size_t>::max();
+  }
+}
+
 }  // namespace cc