GPU client side changes for GpuMemoryBuffers

webkit/gpu/webgraphicscontext3d_in_process_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 "webkit/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 #include <GLES2/gl2.h>
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
 #include <algorithm>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
+#include "gpu/command_buffer/client/gpu_memory_buffer_factory.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/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/gl/gl_context.h"
+#include "ui/gl/gl_image.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/gl_surface.h"
 #include "webkit/gpu/gl_bindings_skia_cmd_buffer.h"
 
 using gpu::Buffer;
 using gpu::CommandBuffer;
 using gpu::CommandBufferService;
 using gpu::gles2::GLES2CmdHelper;
 using gpu::gles2::GLES2Implementation;
+using gpu::gles2::ImageFactory;
+using gpu::gles2::ImageManager;
+using gpu::GpuMemoryBuffer;
 using gpu::GpuScheduler;
 using gpu::TransferBuffer;
 using gpu::TransferBufferManager;
 using gpu::TransferBufferManagerInterface;
 
 namespace webkit {
 namespace gpu {
 
 class GLInProcessContext {
  public:
@@ skipping 98 matching lines @@
   bool Initialize(bool is_offscreen,
                   gfx::AcceleratedWidget window,
                   const gfx::Size& size,
                   const char* allowed_extensions,
                   const int32* attrib_list,
                   gfx::GpuPreference gpu_preference);
   void Destroy();
 
   void OnContextLost();
 
+  ::gpu::gles2::ImageManager* GetImageManager();
+
   base::Closure context_lost_callback_;
   scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
   scoped_ptr<CommandBufferService> command_buffer_;
   scoped_ptr< ::gpu::GpuScheduler> gpu_scheduler_;
   scoped_ptr< ::gpu::gles2::GLES2Decoder> decoder_;
   scoped_refptr<gfx::GLContext> context_;
   scoped_refptr<gfx::GLSurface> surface_;
   scoped_ptr<GLES2CmdHelper> gles2_helper_;
   scoped_ptr<TransferBuffer> transfer_buffer_;
   scoped_ptr<GLES2Implementation> gles2_implementation_;
+  scoped_ptr< ::gpu::gles2::ImageFactory> image_factory_;

[no sievers, 2013/05/14 21:10:03]

Instead of having the scoped_ptr here that only gets set when not sharing
resources, can you make ImageFactoryInProcess refcounted?

[kaanb, 2013/05/14 23:37:09]

Done.

   scoped_ptr<WebKit::WebGraphicsContext3D::WebGraphicsSyncPointCallback>
       signal_sync_point_callback_;
   Error last_error_;
   bool share_resources_;
   bool context_lost_;
 
   DISALLOW_COPY_AND_ASSIGN(GLInProcessContext);
 };
 
 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;
 
+class ImageFactoryInProcess : public ImageFactory {
+ public:
+  ImageFactoryInProcess();
+  explicit ImageFactoryInProcess(ImageManager* image_manager);
+  virtual ~ImageFactoryInProcess();
+  void SetImageManager(ImageManager* image_manager);

[no sievers, 2013/05/14 21:10:03]

Then this could go too.

[kaanb, 2013/05/14 23:37:09]

Done.

+
+  // methods from ImageFactory
+  virtual scoped_ptr<GpuMemoryBuffer> CreateGpuMemoryBuffer(
+      int width, int height, GLenum internalformat,
+      unsigned* image_id) OVERRIDE;
+  virtual void DeleteGpuMemoryBuffer(unsigned image_id) OVERRIDE;
+ private:
+  scoped_refptr<ImageManager> image_manager_;

[no sievers, 2013/05/14 22:18:08]

This is a problem too, since ImageManager is not RefCountedThreadSafe.

[kaanb, 2013/05/14 23:37:09]

I believe this is fine since ImageManager is ref'd by the ContextGroup?

+  unsigned next_id_;
+  base::Lock lock_;
+
+  DISALLOW_COPY_AND_ASSIGN(ImageFactoryInProcess);
+};
+
+ImageFactoryInProcess::ImageFactoryInProcess()
+    : image_manager_(NULL),
+      next_id_(0) {

[no sievers, 2013/05/14 21:10:03]

This could go.

[kaanb, 2013/05/14 23:37:09]

Done.

+}
+
+ImageFactoryInProcess::ImageFactoryInProcess(
+    ImageManager* image_manager) : image_manager_(image_manager),
+                                   next_id_(0) {
+}
+
+ImageFactoryInProcess::~ImageFactoryInProcess() {
+}
+
+void ImageFactoryInProcess::SetImageManager(ImageManager* image_manager) {
+  image_manager_ = image_manager;
+}
+
+scoped_ptr<GpuMemoryBuffer> ImageFactoryInProcess::CreateGpuMemoryBuffer(
+    int width, int height, GLenum internalformat, unsigned int* image_id) {
+  base::AutoLock scoped_lock(lock_);

[no sievers, 2013/05/14 21:10:03]

I think you actually need the global lock (AutoLockAndDecoderDetachThread) here,
because you are accessing the image manager here.

Imagine the case where the decoder looks up an image (from bindTexImage2D) on
one thread, while you are adding or removing an image through a client on
another thread.

[no sievers, 2013/05/14 21:22:06]

Damn, this is slightly ugly. There is at least one case where we'd potentially
end up attempting to recursively acquire the mutex:
GLInProcessContext::Destroy() holds g_decoder_lock while destroying
GLES2Implementation, which owns the buffer tracker, which tries to call into
ImageFactoryInProcess::DeleteGpuMemoryBuffer() for leaked buffers.
It's possible that deleting gles2_implementation_ does not need the mutex.

[kaanb, 2013/05/14 23:37:09]

Done.

+  // TODO(kaanb): Check with reviewers if GL_RGBA8_OES is the right
+  // constant to use. If not which header should we include to make GL_RGBA8
+  // visible?
+  // For Android WebView we assume the |internalformat| will always be
+  // GL_RGBA8_OES.
+  DCHECK_EQ(GL_RGBA8_OES, internalformat);
+  const GpuMemoryBuffer::Creator& create_gpu_memory_buffer_callback =
+      ::gpu::gles2::GetProcessDefaultGpuMemoryBufferFactory();
+  scoped_ptr<GpuMemoryBuffer> buffer =
+      create_gpu_memory_buffer_callback.Run(width, height);
+  scoped_refptr<gfx::GLImage> gl_image =
+      gfx::GLImage::CreateGLImageForGpuMemoryBuffer(buffer->GetNativeBuffer(),
+                                                    gfx::Size(width, height));
+  *image_id = ++next_id_;  // Valid image_ids start from 1.
+  image_manager_->AddImage(gl_image, *image_id);
+  return buffer.Pass();
+}
+
+void ImageFactoryInProcess::DeleteGpuMemoryBuffer(unsigned int image_id) {
+  base::AutoLock scoped_lock(lock_);
+  image_manager_->RemoveImage(image_id);
+}
+
 // Singleton used to initialize and terminate the gles2 library.
 class GLES2Initializer {
  public:
   GLES2Initializer() {
     gles2::Initialize();
   }
 
   ~GLES2Initializer() {
     gles2::Terminate();
   }
@@ skipping 42 matching lines @@
 // threadsafe, so we guard entry points with a mutex.
 static base::LazyInstance<base::Lock> g_decoder_lock =
     LAZY_INSTANCE_INITIALIZER;
 
 static base::LazyInstance<
     std::set<GLInProcessContext*> >
         g_all_shared_contexts = LAZY_INSTANCE_INITIALIZER;
 
 static bool g_use_virtualized_gl_context = false;
 
+static base::LazyInstance<ImageFactoryInProcess> g_image_factory =
+    LAZY_INSTANCE_INITIALIZER;

[no sievers, 2013/05/14 21:10:03]

You probably don't need this if you go with the refcounting (see above) and... 

[kaanb, 2013/05/14 23:37:09]

Done.

+
 namespace {
 
 // Also calls DetachFromThread on all GLES2Decoders before the lock is released
 // to maintain the invariant that all decoders are unbounded while the lock is
 // not held. This is to workaround DumpRenderTree uses WGC3DIPCBI with shared
 // resources on different threads.
 class AutoLockAndDecoderDetachThread {
  public:
   AutoLockAndDecoderDetachThread(base::Lock& lock,
                                  const std::set<GLInProcessContext*>& contexts);
@@ skipping 145 matching lines @@
 
 // TODO(gman): Remove This
 void GLInProcessContext::DisableShaderTranslation() {
   NOTREACHED();
 }
 
 GLES2Implementation* GLInProcessContext::GetImplementation() {
   return gles2_implementation_.get();
 }
 
+::gpu::gles2::ImageManager* GLInProcessContext::GetImageManager() {
+  return decoder_->GetContextGroup()->image_manager();
+}
+
 GLInProcessContext::GLInProcessContext(bool share_resources)
     : last_error_(SUCCESS),
       share_resources_(share_resources),
       context_lost_(false) {
 }
 
 bool GLInProcessContext::Initialize(
     bool is_offscreen,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
@@ skipping 156 matching lines @@
   // Create the GLES2 helper, which writes the command buffer protocol.
   gles2_helper_.reset(new GLES2CmdHelper(command_buffer_.get()));
   if (!gles2_helper_->Initialize(kCommandBufferSize)) {
     Destroy();
     return false;
   }
 
   // Create a transfer buffer.
   transfer_buffer_.reset(new TransferBuffer(gles2_helper_.get()));
 
+  if (share_resources_) {
+    g_image_factory.Pointer()->SetImageManager(GetImageManager());

[no sievers, 2013/05/14 21:10:03]

...if sharing resources grab the factory from the first context in
g_all_shared_contexts. But you need the lock to access that (see below).

[kaanb, 2013/05/14 23:37:09]

Done.

+  } else {
+    // Create the image factory, this object retains its ownership.
+    image_factory_.reset(new ImageFactoryInProcess(GetImageManager()));
+  }
+
   // Create the object exposing the OpenGL API.
   gles2_implementation_.reset(new GLES2Implementation(
       gles2_helper_.get(),
       context_group ? context_group->GetImplementation()->share_group() : NULL,
       transfer_buffer_.get(),
       true,
-      false));
+      false,
+      image_factory_.get()));
 
   if (!gles2_implementation_->Initialize(
       kStartTransferBufferSize,
       kMinTransferBufferSize,
       kMaxTransferBufferSize)) {
     return false;
   }
 
   if (share_resources_) {
     AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
@@ skipping 476 matching lines @@
   return gl_->glname(a1, a2);                                           \
 }
 
 #define DELEGATE_TO_GL_3(name, glname, t1, t2, t3)                      \
 void WebGraphicsContext3DInProcessCommandBufferImpl::name(              \
     t1 a1, t2 a2, t3 a3) {                                              \
   ClearContext();                                                       \
   gl_->glname(a1, a2, a3);                                              \
 }
 
+#define DELEGATE_TO_GL_3R(name, glname, t1, t2, t3, rt)                 \
+rt WebGraphicsContext3DInProcessCommandBufferImpl::name(                \
+    t1 a1, t2 a2, t3 a3) {                                              \
+  ClearContext();                                                       \
+  return gl_->glname(a1, a2, a3);                                       \
+}
+
 #define DELEGATE_TO_GL_4(name, glname, t1, t2, t3, t4)                  \
 void WebGraphicsContext3DInProcessCommandBufferImpl::name(              \
     t1 a1, t2 a2, t3 a3, t4 a4) {                                       \
   ClearContext();                                                       \
   gl_->glname(a1, a2, a3, a4);                                          \
 }
 
 #define DELEGATE_TO_GL_5(name, glname, t1, t2, t3, t4, t5)              \
 void WebGraphicsContext3DInProcessCommandBufferImpl::name(              \
     t1 a1, t2 a2, t3 a3, t4 a4, t5 a5) {                                \
@@ skipping 713 matching lines @@
 }
 
 void WebGraphicsContext3DInProcessCommandBufferImpl::OnContextLost() {
   // TODO(kbr): improve the precision here.
   context_lost_reason_ = GL_UNKNOWN_CONTEXT_RESET_ARB;
   if (context_lost_callback_) {
     context_lost_callback_->onContextLost();
   }
 }
 
+DELEGATE_TO_GL_3R(createImageCHROMIUM, CreateImageCHROMIUM,
+                  WGC3Dsizei, WGC3Dsizei, WGC3Denum, WGC3Duint);
+
+DELEGATE_TO_GL_1(destroyImageCHROMIUM, DestroyImageCHROMIUM, WGC3Duint);
+
+DELEGATE_TO_GL_3(getImageParameterivCHROMIUM, GetImageParameterivCHROMIUM,
+                 WGC3Duint, WGC3Denum, GLint*);
+
+DELEGATE_TO_GL_2R(mapImageCHROMIUM, MapImageCHROMIUM,
+                  WGC3Duint, WGC3Denum, void*);
+
+DELEGATE_TO_GL_1(unmapImageCHROMIUM, UnmapImageCHROMIUM, WGC3Duint);
+
 DELEGATE_TO_GL_3(bindUniformLocationCHROMIUM, BindUniformLocationCHROMIUM,
                  WebGLId, WGC3Dint, const WGC3Dchar*)
 
 DELEGATE_TO_GL(shallowFlushCHROMIUM, ShallowFlushCHROMIUM)
 
 DELEGATE_TO_GL_1(genMailboxCHROMIUM, GenMailboxCHROMIUM, WGC3Dbyte*)
 DELEGATE_TO_GL_2(produceTextureCHROMIUM, ProduceTextureCHROMIUM,
                  WGC3Denum, const WGC3Dbyte*)
 DELEGATE_TO_GL_2(consumeTextureCHROMIUM, ConsumeTextureCHROMIUM,
                  WGC3Denum, const WGC3Dbyte*)
@@ skipping 26 matching lines @@
 
 DELEGATE_TO_GL_9(asyncTexSubImage2DCHROMIUM, AsyncTexSubImage2DCHROMIUM,
     WGC3Denum, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dsizei, WGC3Dsizei,
     WGC3Denum, WGC3Denum, const void*)
 
 DELEGATE_TO_GL_1(waitAsyncTexImage2DCHROMIUM, WaitAsyncTexImage2DCHROMIUM,
     WGC3Denum)
 
 }  // namespace gpu
 }  // namespace webkit