aw: Make force-gpu-mem-available-mb work

android_webview/browser/browser_view_renderer.cc

 // Copyright 2014 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 "android_webview/browser/browser_view_renderer.h"
 
 #include "android_webview/browser/browser_view_renderer_client.h"
 #include "android_webview/browser/shared_renderer_state.h"
 #include "android_webview/common/aw_switches.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/android/jni_android.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "cc/output/compositor_frame.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
+#include "gpu/command_buffer/service/gpu_switches.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 using base::android::AttachCurrentThread;
 using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
 using content::BrowserThread;
 using content::SynchronousCompositorMemoryPolicy;
 
 namespace android_webview {
 
 namespace {
 
 const int64 kFallbackTickTimeoutInMilliseconds = 100;
 
 // Used to calculate memory allocation. Determined experimentally.
 const size_t kMemoryMultiplier = 20;
 const size_t kBytesPerPixel = 4;
 const size_t kMemoryAllocationStep = 5 * 1024 * 1024;
+uint64 g_memory_override_in_bytes = 0u;
 
 // Used to calculate tile allocation. Determined experimentally.
 const size_t kTileMultiplier = 12;
 const size_t kTileAllocationStep = 20;
 // This will be set by static function CalculateTileMemoryPolicy() during init.
 // See AwMainDelegate::BasicStartupComplete.
 size_t g_tile_area;
 
 class TracedValue : public base::debug::ConvertableToTraceFormat {
  public:
@@ skipping 13 matching lines @@
   virtual ~TracedValue() {}
   scoped_ptr<base::Value> value_;
 
   DISALLOW_COPY_AND_ASSIGN(TracedValue);
 };
 
 }  // namespace
 
 // static
 void BrowserViewRenderer::CalculateTileMemoryPolicy(bool use_zero_copy) {
+  CommandLine* cl = CommandLine::ForCurrentProcess();
+
+  // If the value was overridden on the command line, use the specified value.
+  bool client_hard_limit_bytes_overridden =
+      cl->HasSwitch(switches::kForceGpuMemAvailableMb);
+  if (client_hard_limit_bytes_overridden) {
+    base::StringToUint64(
+        base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+            switches::kForceGpuMemAvailableMb),
+        &g_memory_override_in_bytes);
+    g_memory_override_in_bytes *= 1024 * 1024;
+  }
+
   if (!use_zero_copy) {
     // Use chrome's default tile size, which varies from 256 to 512.
     // Be conservative here and use the smallest tile size possible.
     g_tile_area = 256 * 256;
 
     // Also use a high tile limit since there are no file descriptor issues.
     GlobalTileManager::GetInstance()->SetTileLimit(1000);
     return;
   }
 
-  CommandLine* cl = CommandLine::ForCurrentProcess();
   const char kDefaultTileSize[] = "384";
 
   if (!cl->HasSwitch(switches::kDefaultTileWidth))
     cl->AppendSwitchASCII(switches::kDefaultTileWidth, kDefaultTileSize);
 
   if (!cl->HasSwitch(switches::kDefaultTileHeight))
     cl->AppendSwitchASCII(switches::kDefaultTileHeight, kDefaultTileSize);
 
   size_t tile_size;
   base::StringToSizeT(kDefaultTileSize, &tile_size);
@@ skipping 74 matching lines @@
 SynchronousCompositorMemoryPolicy
 BrowserViewRenderer::CalculateDesiredMemoryPolicy() {
   SynchronousCompositorMemoryPolicy policy;
   size_t width = last_on_draw_global_visible_rect_.width();
   size_t height = last_on_draw_global_visible_rect_.height();
   policy.bytes_limit = kMemoryMultiplier * kBytesPerPixel * width * height;
   // Round up to a multiple of kMemoryAllocationStep.
   policy.bytes_limit =
       (policy.bytes_limit / kMemoryAllocationStep + 1) * kMemoryAllocationStep;
 
+  if (g_memory_override_in_bytes)
+    policy.bytes_limit = static_cast<size_t>(g_memory_override_in_bytes);
+
   size_t tiles = width * height * kTileMultiplier / g_tile_area;
   // Round up to a multiple of kTileAllocationStep. The minimum number of tiles
   // is also kTileAllocationStep.
   tiles = (tiles / kTileAllocationStep + 1) * kTileAllocationStep;
   policy.num_resources_limit = tiles;
   return policy;
 }
 
 // This function updates the cached memory policy in shared renderer state, as
 // well as the tile resource allocation in GlobalTileManager.
@@ skipping 605 matching lines @@
     base::StringAppendF(&str,
                         "surface width height: [%d %d] ",
                         draw_info->width,
                         draw_info->height);
     base::StringAppendF(&str, "is_layer: %d ", draw_info->is_layer);
   }
   return str;
 }
 
 }  // namespace android_webview