Move SharedMemoryLimits out of WebGraphicsContext3DCommandBufferImpl.

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 10 matching lines @@
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_trace_implementation.h"
 #include "gpu/command_buffer/client/gpu_switches.h"
+#include "gpu/command_buffer/client/shared_memory_limits.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "gpu/skia_bindings/gl_bindings_skia_cmd_buffer.h"
 #include "third_party/skia/include/core/SkTypes.h"
 
 namespace content {
 
@@ skipping 19 matching lines @@
     scoped_refptr<WebGraphicsContext3DCommandBufferImpl::ShareGroup> group =
         new WebGraphicsContext3DCommandBufferImpl::ShareGroup();
     share_groups[host] = group;
     return group;
   }
   return it->second;
 }
 
 } // namespace anonymous
 
-WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits::SharedMemoryLimits()
-    : command_buffer_size(kDefaultCommandBufferSize),
-      start_transfer_buffer_size(kDefaultStartTransferBufferSize),
-      min_transfer_buffer_size(kDefaultMinTransferBufferSize),
-      max_transfer_buffer_size(kDefaultMaxTransferBufferSize),
-      mapped_memory_reclaim_limit(gpu::gles2::GLES2Implementation::kNoLimit) {}
-
 WebGraphicsContext3DCommandBufferImpl::ShareGroup::ShareGroup() {
 }
 
 WebGraphicsContext3DCommandBufferImpl::ShareGroup::~ShareGroup() {
   DCHECK(contexts_.empty());
 }
 
 WebGraphicsContext3DCommandBufferImpl::WebGraphicsContext3DCommandBufferImpl(
     gpu::SurfaceHandle surface_handle,
     const GURL& active_url,
     gpu::GpuChannelHost* host,
     const gpu::gles2::ContextCreationAttribHelper& attributes,
     gfx::GpuPreference gpu_preference,
     bool share_resources,
     bool automatic_flushes,
-    const SharedMemoryLimits& limits,
     WebGraphicsContext3DCommandBufferImpl* share_context)
     : automatic_flushes_(automatic_flushes),
       attributes_(attributes),
       host_(host),
       surface_handle_(surface_handle),
       active_url_(active_url),
       gpu_preference_(gpu_preference),
-      mem_limits_(limits),
       weak_ptr_factory_(this) {
   DCHECK(host);
   switch (attributes.context_type) {
     case gpu::gles2::CONTEXT_TYPE_OPENGLES2:
     case gpu::gles2::CONTEXT_TYPE_OPENGLES3:
       context_type_ = CONTEXT_TYPE_UNKNOWN;
     case gpu::gles2::CONTEXT_TYPE_WEBGL1:
     case gpu::gles2::CONTEXT_TYPE_WEBGL2:
       context_type_ = OFFSCREEN_CONTEXT_FOR_WEBGL;
   }
   if (share_context) {
     DCHECK(!share_resources);
     share_group_ = share_context->share_group_;
   } else if (share_resources) {
     share_group_ = GetDefaultShareGroupForHost(host);
   } else {
     share_group_ = make_scoped_refptr(new ShareGroup);
   }
 }
 
 WebGraphicsContext3DCommandBufferImpl::
     ~WebGraphicsContext3DCommandBufferImpl() {
   if (real_gl_)
     real_gl_->SetLostContextCallback(base::Closure());
 
   Destroy();
 }
 
-bool WebGraphicsContext3DCommandBufferImpl::MaybeInitializeGL() {
+bool WebGraphicsContext3DCommandBufferImpl::MaybeInitializeGL(
+    const gpu::SharedMemoryLimits& memory_limits) {
   if (initialized_)
     return true;
 
   if (initialize_failed_)
     return false;
 
   TRACE_EVENT0("gpu", "WebGfxCtx3DCmdBfrImpl::MaybeInitializeGL");
 
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/125248 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "125248 WebGraphicsContext3DCommandBufferImpl::MaybeInitializeGL"));
 
-  if (!CreateContext()) {
+  if (!CreateContext(memory_limits)) {
     Destroy();
 
     initialize_failed_ = true;
     return false;
   }
 
   real_gl_->SetLostContextCallback(
       base::Bind(&WebGraphicsContext3DCommandBufferImpl::OnContextLost,
                  // The callback is unset in the destructor.
                  base::Unretained(this)));
@@ skipping 37 matching lines @@
       << "Context dead on arrival. Last error: "
       << command_buffer_->GetLastError();
   // Initialize the command buffer.
   bool result = command_buffer_->Initialize();
   LOG_IF(ERROR, !result) << "CommandBufferProxy::Initialize failed.";
   if (!result)
     UmaRecordContextInitFailed(context_type_);
   return result;
 }
 
-bool WebGraphicsContext3DCommandBufferImpl::CreateContext() {
+bool WebGraphicsContext3DCommandBufferImpl::CreateContext(
+    const gpu::SharedMemoryLimits& memory_limits) {
   TRACE_EVENT0("gpu", "WebGfxCtx3DCmdBfrImpl::CreateContext");
   scoped_refptr<gpu::gles2::ShareGroup> gles2_share_group;
 
   std::unique_ptr<base::AutoLock> share_group_lock;
   bool add_to_share_group = false;
   if (!command_buffer_) {
     WebGraphicsContext3DCommandBufferImpl* share_context = NULL;
 
     share_group_lock.reset(new base::AutoLock(share_group_->lock()));
     share_context = share_group_->GetAnyContextLocked();
 
     if (!InitializeCommandBuffer(share_context)) {
       LOG(ERROR) << "Failed to initialize command buffer.";
       return false;
     }
 
     if (share_context)
       gles2_share_group = share_context->GetImplementation()->share_group();
 
     add_to_share_group = true;
   }
 
   // Create the GLES2 helper, which writes the command buffer protocol.
   gles2_helper_.reset(new gpu::gles2::GLES2CmdHelper(command_buffer_.get()));
-  if (!gles2_helper_->Initialize(mem_limits_.command_buffer_size)) {
+  if (!gles2_helper_->Initialize(memory_limits.command_buffer_size)) {
     LOG(ERROR) << "Failed to initialize GLES2CmdHelper.";
     return false;
   }
 
   if (!automatic_flushes_)
     gles2_helper_->SetAutomaticFlushes(false);
   // Create a transfer buffer used to copy resources between the renderer
   // process and the GPU process.
   transfer_buffer_ .reset(new gpu::TransferBuffer(gles2_helper_.get()));
 
   DCHECK(host_.get());
 
   const bool bind_generates_resource = attributes_.bind_generates_resource;
   const bool lose_context_when_out_of_memory =
       attributes_.lose_context_when_out_of_memory;
   const bool support_client_side_arrays = false;
 
   // Create the object exposing the OpenGL API.
   real_gl_.reset(new gpu::gles2::GLES2Implementation(
       gles2_helper_.get(), gles2_share_group.get(), transfer_buffer_.get(),
       bind_generates_resource, lose_context_when_out_of_memory,
       support_client_side_arrays, command_buffer_.get()));
   SetGLInterface(real_gl_.get());
 
-  if (!real_gl_->Initialize(
-      mem_limits_.start_transfer_buffer_size,
-      mem_limits_.min_transfer_buffer_size,
-      mem_limits_.max_transfer_buffer_size,
-      mem_limits_.mapped_memory_reclaim_limit)) {
+  if (!real_gl_->Initialize(memory_limits.start_transfer_buffer_size,
+                            memory_limits.min_transfer_buffer_size,
+                            memory_limits.max_transfer_buffer_size,
+                            memory_limits.mapped_memory_reclaim_limit)) {
     LOG(ERROR) << "Failed to initialize GLES2Implementation.";
     return false;
   }
 
   if (add_to_share_group)
     share_group_->AddContextLocked(this);
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableGpuClientTracing)) {
     trace_gl_.reset(new gpu::gles2::GLES2TraceImplementation(GetGLInterface()));
     SetGLInterface(trace_gl_.get());
   }
   return true;
 }
 
-bool WebGraphicsContext3DCommandBufferImpl::InitializeOnCurrentThread() {
-  if (!MaybeInitializeGL()) {
+bool WebGraphicsContext3DCommandBufferImpl::InitializeOnCurrentThread(
+    const gpu::SharedMemoryLimits& memory_limits) {
+  if (!MaybeInitializeGL(memory_limits)) {
     DLOG(ERROR) << "Failed to initialize context.";
     return false;
   }
   if (gpu::error::IsError(command_buffer_->GetLastError())) {
     LOG(ERROR) << "Context dead on arrival. Last error: "
                << command_buffer_->GetLastError();
     return false;
   }
 
   return true;
@@ skipping 38 matching lines @@
   {
     base::AutoLock lock(g_default_share_groups_lock.Get());
     g_default_share_groups.Get().erase(host_.get());
   }
 
   gpu::CommandBuffer::State state = command_buffer_->GetLastState();
   UmaRecordContextLost(context_type_, state.error, state.context_lost_reason);
 }
 
 }  // namespace content