Enforce a memory limit on MappedMemoryManager

content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.cc

 // Copyright (c) 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 "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 
 #include "third_party/khronos/GLES2/gl2.h"
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
@@ skipping 216 matching lines @@
       cached_height_(0),
       weak_ptr_factory_(this),
       initialized_(false),
       gl_(NULL),
       frame_number_(0),
       bind_generates_resources_(false),
       use_echo_for_swap_ack_(true),
       command_buffer_size_(0),
       start_transfer_buffer_size_(0),
       min_transfer_buffer_size_(0),
-      max_transfer_buffer_size_(0) {
+      max_transfer_buffer_size_(0),
+      mapped_memory_limit_(gpu::gles2::GLES2Implementation::kNoLimit) {
 #if (defined(OS_MACOSX) || defined(OS_WIN)) && !defined(USE_AURA)
   // Get ViewMsg_SwapBuffers_ACK from browser for single-threaded path.
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   use_echo_for_swap_ack_ =
       command_line.HasSwitch(switches::kEnableThreadedCompositing);
 #endif
 }
 
 WebGraphicsContext3DCommandBufferImpl::
     ~WebGraphicsContext3DCommandBufferImpl() {
@@ skipping 11 matching lines @@
 bool WebGraphicsContext3DCommandBufferImpl::InitializeWithDefaultBufferSizes(
     const WebGraphicsContext3D::Attributes& attributes,
     bool bind_generates_resources,
     CauseForGpuLaunch cause) {
   return Initialize(attributes,
                     bind_generates_resources,
                     cause,
                     kDefaultCommandBufferSize,
                     kDefaultStartTransferBufferSize,
                     kDefaultMinTransferBufferSize,
-                    kDefaultMaxTransferBufferSize);
+                    kDefaultMaxTransferBufferSize,
+                    gpu::gles2::GLES2Implementation::kNoLimit);
 }
 
 bool WebGraphicsContext3DCommandBufferImpl::Initialize(
     const WebGraphicsContext3D::Attributes& attributes,
     bool bind_generates_resources,
     CauseForGpuLaunch cause,
     size_t command_buffer_size,
     size_t start_transfer_buffer_size,
     size_t min_transfer_buffer_size,
-    size_t max_transfer_buffer_size) {
+    size_t max_transfer_buffer_size,
+    size_t mapped_memory_limit) {
   TRACE_EVENT0("gpu", "WebGfxCtx3DCmdBfrImpl::initialize");
 
   attributes_ = attributes;
   bind_generates_resources_ = bind_generates_resources;
   DCHECK(!command_buffer_);
 
   if (!factory_)
     return false;
 
   if (attributes.preferDiscreteGPU)
     gpu_preference_ = gfx::PreferDiscreteGpu;
 
   host_ = factory_->EstablishGpuChannelSync(cause);
   if (!host_.get())
     return false;
 
   command_buffer_size_ = command_buffer_size;
   start_transfer_buffer_size_ = start_transfer_buffer_size;
   min_transfer_buffer_size_ = min_transfer_buffer_size;
   max_transfer_buffer_size_ = max_transfer_buffer_size;
+  mapped_memory_limit_ = mapped_memory_limit;
 
   return true;
 }
 
 bool WebGraphicsContext3DCommandBufferImpl::MaybeInitializeGL(
     const char* allowed_extensions) {
   if (initialized_)
     return true;
 
   if (initialize_failed_)
@@ skipping 163 matching lines @@
 
   if (attributes_.shareResources) {
     // Don't add ourselves to the list before others can get to our ShareGroup.
     g_all_shared_contexts.Pointer()->insert(this);
     lock.reset();
   }
 
   if (!real_gl_->Initialize(
       start_transfer_buffer_size_,
       min_transfer_buffer_size_,
-      max_transfer_buffer_size_)) {
+      max_transfer_buffer_size_,
+      mapped_memory_limit_)) {
     return false;
   }
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableGpuClientTracing)) {
     trace_gl_.reset(new gpu::gles2::GLES2TraceImplementation(gl_));
     gl_ = trace_gl_.get();
   }
 
   return true;
@@ skipping 1092 matching lines @@
 
 void WebGraphicsContext3DCommandBufferImpl::OnErrorMessage(
     const std::string& message, int id) {
   if (error_message_callback_) {
     WebKit::WebString str = WebKit::WebString::fromUTF8(message.c_str());
     error_message_callback_->onErrorMessage(str, id);
   }
 }
 
 }  // namespace content