Use gpu::SharedMemoryLimits for in process GL contexts.

gpu/command_buffer/client/gl_in_process_context.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 "gpu/command_buffer/client/gl_in_process_context.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 25 matching lines @@
 #include "ui/gl/gl_image.h"
 
 #if defined(OS_ANDROID)
 #include "ui/gl/android/surface_texture.h"
 #endif
 
 namespace gpu {
 
 namespace {
 
-const int32_t kDefaultCommandBufferSize = 1024 * 1024;
-const unsigned int kDefaultStartTransferBufferSize = 4 * 1024 * 1024;
-const unsigned int kDefaultMinTransferBufferSize = 1 * 256 * 1024;
-const unsigned int kDefaultMaxTransferBufferSize = 16 * 1024 * 1024;
-
 class GLInProcessContextImpl
     : public GLInProcessContext,
       public base::SupportsWeakPtr<GLInProcessContextImpl> {
  public:
-  explicit GLInProcessContextImpl(
-      const GLInProcessContextSharedMemoryLimits& mem_limits);
+  GLInProcessContextImpl();
   ~GLInProcessContextImpl() override;
 
   bool Initialize(scoped_refptr<gfx::GLSurface> surface,
                   bool is_offscreen,
                   GLInProcessContext* share_context,
                   gfx::AcceleratedWidget window,
                   const gfx::Size& size,
                   const gpu::gles2::ContextCreationAttribHelper& attribs,
                   gfx::GpuPreference gpu_preference,
                   const scoped_refptr<InProcessCommandBuffer::Service>& service,
+                  const SharedMemoryLimits& mem_limits,
                   GpuMemoryBufferManager* gpu_memory_buffer_manager,
                   ImageFactory* image_factory);
 
   // GLInProcessContext implementation:
   gles2::GLES2Implementation* GetImplementation() override;
-  size_t GetMappedMemoryLimit() override;
   void SetLock(base::Lock* lock) override;
 
  private:
   void Destroy();
   void OnSignalSyncPoint(const base::Closure& callback);
 
   std::unique_ptr<gles2::GLES2CmdHelper> gles2_helper_;
   std::unique_ptr<TransferBuffer> transfer_buffer_;
   std::unique_ptr<gles2::GLES2Implementation> gles2_implementation_;
   std::unique_ptr<InProcessCommandBuffer> command_buffer_;
 
-  const GLInProcessContextSharedMemoryLimits mem_limits_;
-
   DISALLOW_COPY_AND_ASSIGN(GLInProcessContextImpl);
 };
 
-GLInProcessContextImpl::GLInProcessContextImpl(
-    const GLInProcessContextSharedMemoryLimits& mem_limits)
-    : mem_limits_(mem_limits) {}
+GLInProcessContextImpl::GLInProcessContextImpl() = default;
 
 GLInProcessContextImpl::~GLInProcessContextImpl() {
   Destroy();
 }
 
 gles2::GLES2Implementation* GLInProcessContextImpl::GetImplementation() {
   return gles2_implementation_.get();
 }
 
-size_t GLInProcessContextImpl::GetMappedMemoryLimit() {
-  return mem_limits_.mapped_memory_reclaim_limit;
-}
-
 void GLInProcessContextImpl::SetLock(base::Lock* lock) {
   NOTREACHED();
 }
 
 bool GLInProcessContextImpl::Initialize(
     scoped_refptr<gfx::GLSurface> surface,
     bool is_offscreen,
     GLInProcessContext* share_context,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     const gles2::ContextCreationAttribHelper& attribs,
     gfx::GpuPreference gpu_preference,
     const scoped_refptr<InProcessCommandBuffer::Service>& service,
+    const SharedMemoryLimits& mem_limits,
     GpuMemoryBufferManager* gpu_memory_buffer_manager,
     ImageFactory* image_factory) {
   DCHECK(size.width() >= 0 && size.height() >= 0);
 
   std::vector<int32_t> attrib_vector;
   attribs.Serialize(&attrib_vector);
 
   command_buffer_.reset(new InProcessCommandBuffer(service));
 
   scoped_refptr<gles2::ShareGroup> share_group;
@@ skipping 15 matching lines @@
                                    gpu_preference,
                                    share_command_buffer,
                                    gpu_memory_buffer_manager,
                                    image_factory)) {
     DLOG(ERROR) << "Failed to initialize InProcessCommmandBuffer";
     return false;
   }
 
   // Create the GLES2 helper, which writes the command buffer protocol.
   gles2_helper_.reset(new gles2::GLES2CmdHelper(command_buffer_.get()));
-  if (!gles2_helper_->Initialize(mem_limits_.command_buffer_size)) {
+  if (!gles2_helper_->Initialize(mem_limits.command_buffer_size)) {
     LOG(ERROR) << "Failed to initialize GLES2CmdHelper";
     Destroy();
     return false;
   }
 
   // Create a transfer buffer.
   transfer_buffer_.reset(new TransferBuffer(gles2_helper_.get()));
 
   // Check for consistency.
   DCHECK(!attribs.bind_generates_resource);
   const bool bind_generates_resource = false;
   const bool support_client_side_arrays = false;
 
   // Create the object exposing the OpenGL API.
   gles2_implementation_.reset(
       new gles2::GLES2Implementation(gles2_helper_.get(),
                                      share_group.get(),
                                      transfer_buffer_.get(),
                                      bind_generates_resource,
                                      attribs.lose_context_when_out_of_memory,
                                      support_client_side_arrays,
                                      command_buffer_.get()));
 
   if (!gles2_implementation_->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)) {
+          mem_limits.start_transfer_buffer_size,
+          mem_limits.min_transfer_buffer_size,
+          mem_limits.max_transfer_buffer_size,
+          mem_limits.mapped_memory_reclaim_limit)) {
     return false;
   }
 
   return true;
 }
 
 void GLInProcessContextImpl::Destroy() {
   if (gles2_implementation_) {
     // First flush the context to ensure that any pending frees of resources
     // are completed. Otherwise, if this context is part of a share group,
     // those resources might leak. Also, any remaining side effects of commands
     // issued on this context might not be visible to other contexts in the
     // share group.
     gles2_implementation_->Flush();
 
     gles2_implementation_.reset();
   }
 
   transfer_buffer_.reset();
   gles2_helper_.reset();
   command_buffer_.reset();
 }
 
 }  // anonymous namespace
 
-GLInProcessContextSharedMemoryLimits::GLInProcessContextSharedMemoryLimits()
-    : command_buffer_size(kDefaultCommandBufferSize),
-      start_transfer_buffer_size(kDefaultStartTransferBufferSize),
-      min_transfer_buffer_size(kDefaultMinTransferBufferSize),
-      max_transfer_buffer_size(kDefaultMaxTransferBufferSize),
-      mapped_memory_reclaim_limit(SharedMemoryLimits::kNoLimit) {}
-
 // static
 GLInProcessContext* GLInProcessContext::Create(
     scoped_refptr<gpu::InProcessCommandBuffer::Service> service,
     scoped_refptr<gfx::GLSurface> surface,
     bool is_offscreen,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     GLInProcessContext* share_context,
     const ::gpu::gles2::ContextCreationAttribHelper& attribs,
     gfx::GpuPreference gpu_preference,
-    const GLInProcessContextSharedMemoryLimits& memory_limits,
+    const SharedMemoryLimits& memory_limits,
     GpuMemoryBufferManager* gpu_memory_buffer_manager,
     ImageFactory* image_factory) {
   if (surface.get()) {
     DCHECK_EQ(surface->IsOffscreen(), is_offscreen);
     DCHECK(surface->GetSize() == size);
     DCHECK_EQ(gfx::kNullAcceleratedWidget, window);
   }
 
-  std::unique_ptr<GLInProcessContextImpl> context(
-      new GLInProcessContextImpl(memory_limits));
-  if (!context->Initialize(surface,
-                           is_offscreen,
-                           share_context,
-                           window,
-                           size,
-                           attribs,
-                           gpu_preference,
-                           service,
-                           gpu_memory_buffer_manager,
-                           image_factory))
+  std::unique_ptr<GLInProcessContextImpl> context(new GLInProcessContextImpl);
+  if (!context->Initialize(surface, is_offscreen, share_context, window, size,
+                           attribs, gpu_preference, service, memory_limits,
+                           gpu_memory_buffer_manager, image_factory))
     return NULL;
 
   return context.release();
 }
 
 }  // namespace gpu