Lazy initialize WGC3DInProcessCommandBufferImpl

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
@@ skipping 33 matching lines @@
 using gpu::gles2::GLES2CmdHelper;
 using gpu::gles2::GLES2Implementation;
 using gpu::GpuScheduler;
 using gpu::TransferBuffer;
 using gpu::TransferBufferManager;
 using gpu::TransferBufferManagerInterface;
 
 namespace webkit {
 namespace gpu {
 
-class GLInProcessContext : public base::SupportsWeakPtr<GLInProcessContext> {
+class GLInProcessContext {
  public:
   // These are the same error codes as used by EGL.
   enum Error {
     SUCCESS             = 0x3000,
     NOT_INITIALIZED     = 0x3001,
     BAD_ATTRIBUTE       = 0x3004,
     BAD_GLContext       = 0x3006,
     CONTEXT_LOST        = 0x300E
   };
 
@@ skipping 26 matching lines @@
 
   // Create a GLInProcessContext that renders to an offscreen frame buffer. If
   // parent is not NULL, that GLInProcessContext can access a copy of the
   // created GLInProcessContext's frame buffer that is updated every time
   // SwapBuffers is called. It is not as general as shared GLInProcessContexts
   // in other implementations of OpenGL. If parent is not NULL, it must be used
   // on the same thread as the parent. A child GLInProcessContext may not
   // outlive its parent.  attrib_list must be NULL or a NONE-terminated list of
   // attribute/value pairs.
   static GLInProcessContext* CreateOffscreenContext(
-      GLInProcessContext* parent,
       const gfx::Size& size,
-      GLInProcessContext* context_group,
+      bool share_resources,
       const char* allowed_extensions,
       const int32* attrib_list,
       gfx::GpuPreference gpu_preference);
 
   // For an offscreen frame buffer GLInProcessContext, return the texture ID
   // with respect to the parent GLInProcessContext. Returns zero if
   // GLInProcessContext does not have a parent.
   uint32 GetParentTextureId();
 
   // Create a new texture in the parent's GLInProcessContext.  Returns zero if
@@ skipping 23 matching lines @@
 
   // Return the current error.
   Error GetError();
 
   // Return true if GPU process reported GLInProcessContext lost or there was a
   // problem communicating with the GPU process.
   bool IsCommandBufferContextLost();
 
   CommandBufferService* GetCommandBufferService();
 
+  ::gpu::gles2::GLES2Decoder* GetDecoder();
+
  private:
-  explicit GLInProcessContext(GLInProcessContext* parent);
+  explicit GLInProcessContext(bool share_resources);
 
   bool Initialize(const gfx::Size& size,
-                  GLInProcessContext* context_group,
                   const char* allowed_extensions,
                   const int32* attrib_list,
                   gfx::GpuPreference gpu_preference);
   void Destroy();
 
   void OnContextLost();
 
-  base::WeakPtr<GLInProcessContext> parent_;
   base::Closure context_lost_callback_;
-  uint32 parent_texture_id_;
   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_;
   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;
 
-static base::LazyInstance<
-    std::set<WebGraphicsContext3DInProcessCommandBufferImpl*> >
-        g_all_shared_contexts = LAZY_INSTANCE_INITIALIZER;
-static base::LazyInstance<base::Lock>::Leaky
-    g_all_shared_contexts_lock = LAZY_INSTANCE_INITIALIZER;
-
 // Singleton used to initialize and terminate the gles2 library.
 class GLES2Initializer {
  public:
   GLES2Initializer() {
     gles2::Initialize();
   }
 
   ~GLES2Initializer() {
     gles2::Terminate();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GLES2Initializer);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 static base::LazyInstance<GLES2Initializer> g_gles2_initializer =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace anonymous
 
 GLInProcessContext::~GLInProcessContext() {
   Destroy();
 }
 
 GLInProcessContext* GLInProcessContext::CreateOffscreenContext(
-    GLInProcessContext* parent,
     const gfx::Size& size,
-    GLInProcessContext* context_group,
+    bool share_resources,
     const char* allowed_extensions,
     const int32* attrib_list,
     gfx::GpuPreference gpu_preference) {
-  scoped_ptr<GLInProcessContext> context(new GLInProcessContext(parent));
+  scoped_ptr<GLInProcessContext> context(
+      new GLInProcessContext(share_resources));
   if (!context->Initialize(
       size,
-      context_group,
       allowed_extensions,
       attrib_list,
       gpu_preference))
     return NULL;
 
   return context.release();
 }
 
 // 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;
 
+static base::LazyInstance<
+    std::set<GLInProcessContext*> >
+        g_all_shared_contexts = LAZY_INSTANCE_INITIALIZER;
+
+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);
+  ~AutoLockAndDecoderDetachThread();
+
+ private:
+  base::AutoLock auto_lock_;
+  const std::set<GLInProcessContext*>& contexts_;
+};
+
+AutoLockAndDecoderDetachThread::AutoLockAndDecoderDetachThread(
+    base::Lock& lock,
+    const std::set<GLInProcessContext*>& contexts)
+    : auto_lock_(lock),
+      contexts_(contexts) {
+}
+
+void DetachThread(GLInProcessContext* context) {
+  if (context->GetDecoder())
+    context->GetDecoder()->DetachFromThread();
+}
+
+AutoLockAndDecoderDetachThread::~AutoLockAndDecoderDetachThread() {
+  std::for_each(contexts_.begin(),
+                contexts_.end(),
+                &DetachThread);
+}
+
+}  // namespace
+
 void GLInProcessContext::PumpCommands() {
   if (!context_lost_) {
-    base::AutoLock lock(g_decoder_lock.Get());
+    AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
+                                        g_all_shared_contexts.Get());
     decoder_->MakeCurrent();
     gpu_scheduler_->PutChanged();
     ::gpu::CommandBuffer::State state = command_buffer_->GetState();
     if (::gpu::error::IsError(state.error)) {
       context_lost_ = true;
     }
   }
 }
 
 bool GLInProcessContext::GetBufferChanged(int32 transfer_buffer_id) {
   return gpu_scheduler_->SetGetBuffer(transfer_buffer_id);
 }
 
 uint32 GLInProcessContext::GetParentTextureId() {
-  return parent_texture_id_;
+  return 0;
 }
 
 uint32 GLInProcessContext::CreateParentTexture(const gfx::Size& size) {
   uint32 texture = 0;
   gles2_implementation_->GenTextures(1, &texture);
   gles2_implementation_->Flush();
   return texture;
 }
 
 void GLInProcessContext::DeleteParentTexture(uint32 texture) {
@@ skipping 52 matching lines @@
     return true;
   }
   CommandBuffer::State state = command_buffer_->GetState();
   return ::gpu::error::IsError(state.error);
 }
 
 CommandBufferService* GLInProcessContext::GetCommandBufferService() {
   return command_buffer_.get();
 }
 
+::gpu::gles2::GLES2Decoder* GLInProcessContext::GetDecoder() {
+  return decoder_.get();
+}
+
 // TODO(gman): Remove This
 void GLInProcessContext::DisableShaderTranslation() {
   NOTREACHED();
 }
 
 GLES2Implementation* GLInProcessContext::GetImplementation() {
   return gles2_implementation_.get();
 }
 
-GLInProcessContext::GLInProcessContext(GLInProcessContext* parent)
-    : parent_(parent ?
-          parent->AsWeakPtr() : base::WeakPtr<GLInProcessContext>()),
-      parent_texture_id_(0),
-      last_error_(SUCCESS),
+GLInProcessContext::GLInProcessContext(bool share_resources)
+    : last_error_(SUCCESS),
+      share_resources_(share_resources),
       context_lost_(false) {
 }
 
 bool GLInProcessContext::Initialize(const gfx::Size& size,
-                                    GLInProcessContext* context_group,
                                     const char* allowed_extensions,
                                     const int32* attrib_list,
                                     gfx::GpuPreference gpu_preference) {
   // Use one share group for all contexts.
   CR_DEFINE_STATIC_LOCAL(scoped_refptr<gfx::GLShareGroup>, share_group,
                          (new gfx::GLShareGroup));
 
   DCHECK(size.width() >= 0 && size.height() >= 0);
 
   // Ensure the gles2 library is initialized first in a thread safe way.
   g_gles2_initializer.Get();
 
-  // Allocate a frame buffer ID with respect to the parent.
-  if (parent_.get()) {
-    // Flush any remaining commands in the parent context to make sure the
-    // texture id accounting stays consistent.
-    int32 token = parent_->gles2_helper_->InsertToken();
-    parent_->gles2_helper_->WaitForToken(token);
-    parent_texture_id_ = parent_->gles2_implementation_->MakeTextureId();
-  }
-
   std::vector<int32> attribs;
   while (attrib_list) {
     int32 attrib = *attrib_list++;
     switch (attrib) {
       // Known attributes
       case ALPHA_SIZE:
       case BLUE_SIZE:
       case GREEN_SIZE:
       case RED_SIZE:
       case DEPTH_SIZE:
@@ skipping 22 matching lines @@
   }
 
   command_buffer_.reset(
       new CommandBufferService(transfer_buffer_manager_.get()));
   if (!command_buffer_->Initialize()) {
     LOG(ERROR) << "Could not initialize command buffer.";
     Destroy();
     return false;
   }
 
-  // TODO(gman): This needs to be true if this is Pepper.
-  bool bind_generates_resource = false;
-  decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group ?
-      context_group->decoder_->GetContextGroup() :
-          new ::gpu::gles2::ContextGroup(
-              NULL, NULL, NULL, bind_generates_resource)));
+  GLInProcessContext* context_group = NULL;
 
-  gpu_scheduler_.reset(new GpuScheduler(command_buffer_.get(),
-                                        decoder_.get(),
-                                        decoder_.get()));
+  {
+    AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
+                                        g_all_shared_contexts.Get());
+    if (share_resources_ && !g_all_shared_contexts.Get().empty())
+      context_group = *g_all_shared_contexts.Get().begin();
 
-  decoder_->set_engine(gpu_scheduler_.get());
+    // TODO(gman): This needs to be true if this is Pepper.
+    bool bind_generates_resource = false;
+    decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group ?
+        context_group->decoder_->GetContextGroup() :
+            new ::gpu::gles2::ContextGroup(
+                NULL, NULL, NULL, bind_generates_resource)));
 
-  surface_ = gfx::GLSurface::CreateOffscreenGLSurface(false, gfx::Size(1, 1));
+    gpu_scheduler_.reset(new GpuScheduler(command_buffer_.get(),
+                                          decoder_.get(),
+                                          decoder_.get()));
 
-  if (!surface_.get()) {
-    LOG(ERROR) << "Could not create GLSurface.";
-    Destroy();
-    return false;
-  }
+    decoder_->set_engine(gpu_scheduler_.get());
 
-  context_ = gfx::GLContext::CreateGLContext(share_group.get(),
-                                             surface_.get(),
-                                             gpu_preference);
-  if (!context_.get()) {
-    LOG(ERROR) << "Could not create GLContext.";
-    Destroy();
-    return false;
-  }
+    surface_ = gfx::GLSurface::CreateOffscreenGLSurface(false, gfx::Size(1, 1));
 
-  if (!context_->MakeCurrent(surface_.get())) {
-    LOG(ERROR) << "Could not make context current.";
-    Destroy();
-    return false;
-  }
+    if (!surface_.get()) {
+      LOG(ERROR) << "Could not create GLSurface.";
+      Destroy();
+      return false;
+    }
 
-  ::gpu::gles2::DisallowedFeatures disallowed_features;
-  disallowed_features.swap_buffer_complete_callback = true;
-  disallowed_features.gpu_memory_manager = true;
-  if (!decoder_->Initialize(surface_,
-                            context_,
-                            true,
-                            size,
-                            disallowed_features,
-                            allowed_extensions,
-                            attribs)) {
-    LOG(ERROR) << "Could not initialize decoder.";
-    Destroy();
-    return false;
-  }
+    context_ = gfx::GLContext::CreateGLContext(share_group.get(),
+                                               surface_.get(),
+                                               gpu_preference);
+    if (!context_.get()) {
+      LOG(ERROR) << "Could not create GLContext.";
+      Destroy();
+      return false;
+    }
 
-  if (!decoder_->SetParent(
-      parent_.get() ? parent_->decoder_.get() : NULL,
-      parent_texture_id_)) {
-    LOG(ERROR) << "Could not set parent.";
-    Destroy();
-    return false;
+    if (!context_->MakeCurrent(surface_.get())) {
+      LOG(ERROR) << "Could not make context current.";
+      Destroy();
+      return false;
+    }
+
+    ::gpu::gles2::DisallowedFeatures disallowed_features;
+    disallowed_features.swap_buffer_complete_callback = true;
+    disallowed_features.gpu_memory_manager = true;
+    if (!decoder_->Initialize(surface_,
+                              context_,
+                              true,
+                              size,
+                              disallowed_features,
+                              allowed_extensions,
+                              attribs)) {
+      LOG(ERROR) << "Could not initialize decoder.";
+      Destroy();
+      return false;
+    }
   }
 
   command_buffer_->SetPutOffsetChangeCallback(
       base::Bind(&GLInProcessContext::PumpCommands, base::Unretained(this)));
   command_buffer_->SetGetBufferChangeCallback(
       base::Bind(
           &GLInProcessContext::GetBufferChanged, base::Unretained(this)));
   command_buffer_->SetParseErrorCallback(
       base::Bind(&GLInProcessContext::OnContextLost, base::Unretained(this)));
 
@@ skipping 15 matching lines @@
       true,
       false));
 
   if (!gles2_implementation_->Initialize(
       kStartTransferBufferSize,
       kMinTransferBufferSize,
       kMaxTransferBufferSize)) {
     return false;
   }
 
+  if (share_resources_) {
+    AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
+                                        g_all_shared_contexts.Get());
+    g_all_shared_contexts.Pointer()->insert(this);
+  }
+
   return true;
 }
 
 void GLInProcessContext::Destroy() {
   bool context_lost = IsCommandBufferContextLost();
 
-  if (parent_.get() && parent_texture_id_ != 0) {
-    parent_->gles2_implementation_->FreeTextureId(parent_texture_id_);
-    parent_texture_id_ = 0;
-  }
-
   if (gles2_implementation_.get()) {
     // 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();
 
+  AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
+                                      g_all_shared_contexts.Get());
   if (decoder_.get()) {
     decoder_->Destroy(!context_lost);
   }
+
+  g_all_shared_contexts.Pointer()->erase(this);
 }
 
 void GLInProcessContext::OnContextLost() {
   if (!context_lost_callback_.is_null())
     context_lost_callback_.Run();
 }
 
 WebGraphicsContext3DInProcessCommandBufferImpl::
-    WebGraphicsContext3DInProcessCommandBufferImpl()
-    : context_(NULL),
+    WebGraphicsContext3DInProcessCommandBufferImpl(
+        const WebKit::WebGraphicsContext3D::Attributes& attributes)
+    : initialized_(false),
+      initialize_failed_(false),
+      context_(NULL),
       gl_(NULL),
       context_lost_callback_(NULL),
       context_lost_reason_(GL_NO_ERROR),
+      attributes_(attributes),
       cached_width_(0),
       cached_height_(0),
       bound_fbo_(0) {
 }
 
 WebGraphicsContext3DInProcessCommandBufferImpl::
     ~WebGraphicsContext3DInProcessCommandBufferImpl() {
-  base::AutoLock a(g_all_shared_contexts_lock.Get());
-  g_all_shared_contexts.Pointer()->erase(this);
 }
 
-bool WebGraphicsContext3DInProcessCommandBufferImpl::Initialize(
-    WebGraphicsContext3D::Attributes attributes,
-    WebKit::WebGraphicsContext3D* view_context) {
+bool WebGraphicsContext3DInProcessCommandBufferImpl::MaybeInitializeGL() {
+  if (initialized_)
+    return true;
+
+  if (initialize_failed_)
+    return false;
+
   // Convert WebGL context creation attributes into GLInProcessContext / EGL
   // size requests.
-  const int alpha_size = attributes.alpha ? 8 : 0;
-  const int depth_size = attributes.depth ? 24 : 0;
-  const int stencil_size = attributes.stencil ? 8 : 0;
-  const int samples = attributes.antialias ? 4 : 0;
-  const int sample_buffers = attributes.antialias ? 1 : 0;
+  const int alpha_size = attributes_.alpha ? 8 : 0;
+  const int depth_size = attributes_.depth ? 24 : 0;
+  const int stencil_size = attributes_.stencil ? 8 : 0;
+  const int samples = attributes_.antialias ? 4 : 0;
+  const int sample_buffers = attributes_.antialias ? 1 : 0;
   const int32 attribs[] = {
     GLInProcessContext::ALPHA_SIZE, alpha_size,
     GLInProcessContext::DEPTH_SIZE, depth_size,
     GLInProcessContext::STENCIL_SIZE, stencil_size,
     GLInProcessContext::SAMPLES, samples,
     GLInProcessContext::SAMPLE_BUFFERS, sample_buffers,
     GLInProcessContext::NONE,
   };
 
   const char* preferred_extensions = "*";
 
   // TODO(kbr): More work will be needed in this implementation to
   // properly support GPU switching. Like in the out-of-process
   // command buffer implementation, all previously created contexts
   // will need to be lost either when the first context requesting the
   // discrete GPU is created, or the last one is destroyed.
   gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;
 
-  GLInProcessContext* parent_context = NULL;
-  if (view_context) {
-    WebGraphicsContext3DInProcessCommandBufferImpl* context_impl =
-        static_cast<WebGraphicsContext3DInProcessCommandBufferImpl*>(
-            view_context);
-    parent_context = context_impl->context_;
-  }
-
-  WebGraphicsContext3DInProcessCommandBufferImpl* context_group = NULL;
-  base::AutoLock lock(g_all_shared_contexts_lock.Get());
-  if (attributes.shareResources)
-    context_group = g_all_shared_contexts.Pointer()->empty() ?
-        NULL : *g_all_shared_contexts.Pointer()->begin();
-
   context_ = GLInProcessContext::CreateOffscreenContext(
-      parent_context,
       gfx::Size(1, 1),
-      context_group ? context_group->context_ : NULL,
+      attributes_.shareResources,
       preferred_extensions,
       attribs,
       gpu_preference);
 
-  if (!context_)
+  if (!context_) {
+    initialize_failed_ = true;
     return false;
+  }
 
   gl_ = context_->GetImplementation();
 
-  if (gl_ && attributes.noExtensions)
+  if (gl_ && attributes_.noExtensions)
     gl_->EnableFeatureCHROMIUM("webgl_enable_glsl_webgl_validation");
 
   context_->SetContextLostCallback(
       base::Bind(
           &WebGraphicsContext3DInProcessCommandBufferImpl::OnContextLost,
           base::Unretained(this)));
 
   // Set attributes_ from created offscreen context.
   {
-    attributes_ = attributes;
     GLint alpha_bits = 0;
     getIntegerv(GL_ALPHA_BITS, &alpha_bits);
     attributes_.alpha = alpha_bits > 0;
     GLint depth_bits = 0;
     getIntegerv(GL_DEPTH_BITS, &depth_bits);
     attributes_.depth = depth_bits > 0;
     GLint stencil_bits = 0;
     getIntegerv(GL_STENCIL_BITS, &stencil_bits);
     attributes_.stencil = stencil_bits > 0;
     GLint sample_buffers = 0;
     getIntegerv(GL_SAMPLE_BUFFERS, &sample_buffers);
     attributes_.antialias = sample_buffers > 0;
   }
-  makeContextCurrent();
 
-  if (attributes.shareResources)
-    g_all_shared_contexts.Pointer()->insert(this);
-
+  initialized_ = true;
   return true;
 }
 
 bool WebGraphicsContext3DInProcessCommandBufferImpl::makeContextCurrent() {
+  if (!MaybeInitializeGL())
+    return false;
+
   return GLInProcessContext::MakeCurrent(context_);
 }
 
 void WebGraphicsContext3DInProcessCommandBufferImpl::ClearContext() {
   // NOTE: Comment in the line below to check for code that is not calling
   // eglMakeCurrent where appropriate. The issue is code using
   // WebGraphicsContext3D does not need to call makeContextCurrent. Code using
   // direct OpenGL bindings needs to call the appropriate form of
   // eglMakeCurrent. If it doesn't it will be issuing commands on the wrong
   // context. Uncommenting the line below clears the current context so that
@@ skipping 1032 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