gpu: Refactor GpuMemoryBuffer framework for multi-process support.

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 <utility>
 #include <vector>
 
 #include <GLES2/gl2.h>
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
-#include "gpu/command_buffer/client/gpu_memory_buffer.h"
-#include "gpu/command_buffer/client/image_factory.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/constants.h"
-#include "gpu/command_buffer/common/id_allocator.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "ui/gfx/size.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/gl_surface.h"
 
 namespace gpu {
 
-using gles2::ImageManager;
-
 namespace {
 
 const int32 kCommandBufferSize = 1024 * 1024;
 // TODO(kbr): make the transfer buffer size configurable via context
 // creation attributes.
 const size_t kStartTransferBufferSize = 4 * 1024 * 1024;
 const size_t kMinTransferBufferSize = 1 * 256 * 1024;
 const size_t kMaxTransferBufferSize = 16 * 1024 * 1024;
 
 // In the normal command buffer implementation, all commands are passed over IPC
 // to the gpu process where they are fed to the GLES2Decoder from a single
 // thread. In layout tests, any thread could call this function. GLES2Decoder,
 // and in particular the GL implementations behind it, are not generally
 // threadsafe, so we guard entry points with a mutex.
 static base::LazyInstance<base::Lock> g_decoder_lock =
     LAZY_INSTANCE_INITIALIZER;
 
 class GLInProcessContextImpl;
 
 static base::LazyInstance<
     std::set<GLInProcessContextImpl*> >
         g_all_shared_contexts = LAZY_INSTANCE_INITIALIZER;
 
 static bool g_use_virtualized_gl_context = false;
 
-static GLInProcessContext::GpuMemoryBufferCreator* g_gpu_memory_buffer_creator =
-    NULL;
+static GpuMemoryBufferFactory* g_gpu_memory_buffer_factory = NULL;
 
 // Also calls DetachFromThreadHack on all GLES2Decoders before the lock is
 // released to maintain the invariant that all decoders are unbound while the
 // lock is not held. This is to workaround DumpRenderTree using WGC3DIPCBI with
 // shared resources on different threads.
 // Remove this as part of crbug.com/234964.
 class AutoLockAndDecoderDetachThread {
  public:
   AutoLockAndDecoderDetachThread(
       base::Lock& lock,
       const std::set<GLInProcessContextImpl*>& contexts);
   ~AutoLockAndDecoderDetachThread();
 
  private:
   base::AutoLock auto_lock_;
   const std::set<GLInProcessContextImpl*>& contexts_;
 };
 
 class GLInProcessContextImpl
     : public GLInProcessContext,
-      public gles2::ImageFactory,
       public base::SupportsWeakPtr<GLInProcessContextImpl> {
  public:
   explicit GLInProcessContextImpl(bool share_resources);
   virtual ~GLInProcessContextImpl();
 
   bool Initialize(bool is_offscreen,
                   gfx::AcceleratedWidget window,
                   const gfx::Size& size,
                   const char* allowed_extensions,
                   const int32* attrib_list,
                   gfx::GpuPreference gpu_preference,
                   const base::Closure& context_lost_callback);
 
   // GLInProcessContext implementation:
   virtual void SignalSyncPoint(unsigned sync_point,
                                const base::Closure& callback) OVERRIDE;
   virtual void SignalQuery(unsigned query, const base::Closure& callback)
       OVERRIDE;
   virtual gles2::GLES2Implementation* GetImplementation() OVERRIDE;
 
-  // ImageFactory implementation:
-  virtual scoped_ptr<GpuMemoryBuffer> CreateGpuMemoryBuffer(
-      int width, int height, GLenum internalformat,
-      unsigned* image_id) OVERRIDE;
-  virtual void DeleteGpuMemoryBuffer(unsigned image_id) OVERRIDE;
-
   // Other methods:
   gles2::GLES2Decoder* GetDecoder();
   bool GetBufferChanged(int32 transfer_buffer_id);
   void PumpCommands();
   void OnResizeView(gfx::Size size, float scale_factor);
   void OnContextLost();
 
  private:
   void Destroy();
   bool IsCommandBufferContextLost();
   void PollQueryCallbacks();
   void CallQueryCallback(size_t index);
   bool MakeCurrent();
 
-  gles2::ImageManager* GetImageManager();
-
   base::Closure context_lost_callback_;
   scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
+  scoped_refptr<gles2::ImageManager> image_manager_;
   scoped_ptr<CommandBuffer> command_buffer_;
   scoped_ptr<GpuScheduler> gpu_scheduler_;
   scoped_ptr<gles2::GLES2Decoder> decoder_;
   scoped_refptr<gfx::GLContext> context_;
   scoped_refptr<gfx::GLSurface> surface_;
   scoped_ptr<gles2::GLES2CmdHelper> gles2_helper_;
   scoped_ptr<TransferBuffer> transfer_buffer_;
   scoped_ptr<gles2::GLES2Implementation> gles2_implementation_;
   bool share_resources_;
   bool context_lost_;
@@ skipping 17 matching lines @@
   if (context->GetDecoder())
     context->GetDecoder()->DetachFromThreadHack();
 }
 
 AutoLockAndDecoderDetachThread::~AutoLockAndDecoderDetachThread() {
   std::for_each(contexts_.begin(),
                 contexts_.end(),
                 &DetachThread);
 }
 
-scoped_ptr<GpuMemoryBuffer> GLInProcessContextImpl::CreateGpuMemoryBuffer(
-    int width, int height, GLenum internalformat, unsigned int* image_id) {
-  // We're taking the lock here because we're accessing the ContextGroup's
-  // shared IdManager.
-  AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
-                                      g_all_shared_contexts.Get());
-  // For Android WebView we assume the |internalformat| will always be
-  // GL_RGBA8_OES.
-  DCHECK_EQ(static_cast<GLenum>(GL_RGBA8_OES), internalformat);
-  scoped_ptr<GpuMemoryBuffer> buffer =
-      g_gpu_memory_buffer_creator(width, height);
-
-  if (buffer.get() == NULL)
-    return buffer.Pass();
-
-  scoped_refptr<gfx::GLImage> gl_image =
-      gfx::GLImage::CreateGLImageForGpuMemoryBuffer(buffer->GetNativeBuffer(),
-                                                    gfx::Size(width, height));
-  *image_id = decoder_->GetContextGroup()
-      ->GetIdAllocator(gles2::id_namespaces::kImages)->AllocateID();
-  GetImageManager()->AddImage(gl_image.get(), *image_id);
-  return buffer.Pass();
-}
-
-void GLInProcessContextImpl::DeleteGpuMemoryBuffer(unsigned int image_id) {
-  // We're taking the lock here because we're accessing the ContextGroup's
-  // shared ImageManager.
-  AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
-                                      g_all_shared_contexts.Get());
-  GetImageManager()->RemoveImage(image_id);
-  decoder_->GetContextGroup()->GetIdAllocator(gles2::id_namespaces::kImages)
-      ->FreeID(image_id);
-}
-
 GLInProcessContextImpl::GLInProcessContextImpl(bool share_resources)
     : share_resources_(share_resources),
       context_lost_(false) {
 }
 
 GLInProcessContextImpl::~GLInProcessContextImpl() {
   Destroy();
 }
 
 bool GLInProcessContextImpl::MakeCurrent() {
@@ skipping 50 matching lines @@
 
 void GLInProcessContextImpl::OnResizeView(gfx::Size size, float scale_factor) {
   DCHECK(!surface_->IsOffscreen());
   surface_->Resize(size);
 }
 
 gles2::GLES2Implementation* GLInProcessContextImpl::GetImplementation() {
   return gles2_implementation_.get();
 }
 
-gles2::ImageManager* GLInProcessContextImpl::GetImageManager() {
-  return decoder_->GetContextGroup()->image_manager();
-}
-
 bool GLInProcessContextImpl::Initialize(
     bool is_offscreen,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     const char* allowed_extensions,
     const int32* attrib_list,
     gfx::GpuPreference gpu_preference,
     const base::Closure& context_lost_callback) {
   // Use one share group for all contexts.
   CR_DEFINE_STATIC_LOCAL(scoped_refptr<gfx::GLShareGroup>, share_group,
@@ skipping 27 matching lines @@
         break;
     }
   }
 
   {
     TransferBufferManager* manager = new TransferBufferManager();
     transfer_buffer_manager_.reset(manager);
     manager->Initialize();
   }
 
+  image_manager_ = new gles2::ImageManager();
+
   scoped_ptr<CommandBufferService> command_buffer(
-      new CommandBufferService(transfer_buffer_manager_.get()));
+      new CommandBufferService(transfer_buffer_manager_.get(),
+                               image_manager_.get(),
+                               g_gpu_memory_buffer_factory));
   command_buffer->SetPutOffsetChangeCallback(base::Bind(
       &GLInProcessContextImpl::PumpCommands, base::Unretained(this)));
   command_buffer->SetGetBufferChangeCallback(base::Bind(
       &GLInProcessContextImpl::GetBufferChanged, base::Unretained(this)));
   command_buffer->SetParseErrorCallback(base::Bind(
       &GLInProcessContextImpl::OnContextLost, base::Unretained(this)));
 
   command_buffer_ = command_buffer.Pass();
   if (!command_buffer_->Initialize()) {
     LOG(ERROR) << "Could not initialize command buffer.";
@@ skipping 107 matching lines @@
 
   // Create a transfer buffer.
   transfer_buffer_.reset(new TransferBuffer(gles2_helper_.get()));
 
   // Create the object exposing the OpenGL API.
   gles2_implementation_.reset(new gles2::GLES2Implementation(
       gles2_helper_.get(),
       context_group ? context_group->GetImplementation()->share_group() : NULL,
       transfer_buffer_.get(),
       true,
-      false,
-      this));
+      false));
 
   if (!gles2_implementation_->Initialize(
       kStartTransferBufferSize,
       kMinTransferBufferSize,
       kMaxTransferBufferSize)) {
     return false;
   }
 
   if (share_resources_) {
     AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
@@ skipping 114 matching lines @@
       allowed_extensions,
       attrib_list,
       gpu_preference,
       callback))
     return NULL;
 
   return context.release();
 }
 
 // static
-void GLInProcessContext::SetGpuMemoryBufferCreator(
-    GpuMemoryBufferCreator* creator) {
-  g_gpu_memory_buffer_creator = creator;
+void GLInProcessContext::SetGpuMemoryBufferFactory(
+    GpuMemoryBufferFactory* factory) {
+#if !defined(NDEBUG)
+  {
+    AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
+                                        g_all_shared_contexts.Get());
+    DCHECK(g_all_shared_contexts.Get().empty());
+  }
+#endif  // !defined(NDEBUG)
+  g_gpu_memory_buffer_factory = factory;
 }
 
 // static
 void GLInProcessContext::EnableVirtualizedContext() {
 #if !defined(NDEBUG)
   {
     AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
                                         g_all_shared_contexts.Get());
     DCHECK(g_all_shared_contexts.Get().empty());
   }
 #endif  // !defined(NDEBUG)
   g_use_virtualized_gl_context = true;
 }
 
 }  // namespace gpu