Implemented support for GL constext share groups in the renderer process.

webkit/gpu/webgraphicscontext3d_in_process_command_buffer_impl.cc

 // Copyright (c) 2011 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.
 
 #if defined(ENABLE_GPU)
 
 #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 <algorithm>
+#include <set>
 
 #include "base/string_tokenizer.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/common/constants.h"
+#include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/GLES2/gles2_command_buffer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/gfx/gl/gl_share_group.h"
 #include "webkit/glue/gl_bindings_skia_cmd_buffer.h"
 
 using gpu::Buffer;
@@ skipping 52 matching lines @@
   // accelerated compositor's output. On this platform, we actually pass
   // a gfx::PluginWindowHandle in place of the gfx::NativeViewId,
   // because the facility to allocate a fake PluginWindowHandle is
   // already in place. We could add more entry points and messages to
   // allocate both fake PluginWindowHandles and NativeViewIds and map
   // from fake NativeViewIds to PluginWindowHandles, but this seems like
   // unnecessary complexity at the moment.
   //
   static GLInProcessContext* CreateViewContext(
       gfx::PluginWindowHandle render_surface,
+      GLInProcessContext* context_group,
       const char* allowed_extensions,
       const int32* attrib_list,
       const GURL& active_arl);
 
 #if defined(OS_MACOSX)
   // On Mac OS X only, view GLInProcessContexts actually behave like offscreen
   // GLInProcessContexts, and require an explicit resize operation which is
   // slightly different from that of offscreen GLInProcessContexts.
   void ResizeOnscreen(const gfx::Size& size);
 #endif
 
   // 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,
       const char* allowed_extensions,
       const int32* attrib_list,
       const GURL& active_url);
 
   // Resize an offscreen frame buffer. The resize occurs on the next call to
   // SwapBuffers. This is to avoid waiting until all pending GL calls have been
   // executed by the GPU process. Everything rendered up to the call to
   // SwapBuffers will be lost. A lost GLInProcessContext will be reported if the
   // resize fails.
   void ResizeOffscreen(const gfx::Size& size);
@@ skipping 40 matching lines @@
   bool IsCommandBufferContextLost();
 
   CommandBufferService* GetCommandBufferService();
 
  private:
   GLInProcessContext(GLInProcessContext* parent);
 
   bool Initialize(bool onscreen,
                   gfx::PluginWindowHandle render_surface,
                   const gfx::Size& size,
+                  GLInProcessContext* context_group,
                   const char* allowed_extensions,
                   const int32* attrib_list,
                   const GURL& active_url);
   void Destroy();
 
   void OnSwapBuffers();
   void OnContextLost();
 
   base::WeakPtr<GLInProcessContext> parent_;
   scoped_ptr<Callback0::Type> swap_buffers_callback_;
@@ skipping 10 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(GLInProcessContext);
 };
 
 namespace {
 
 const int32 kCommandBufferSize = 1024 * 1024;
 // TODO(kbr): make the transfer buffer size configurable via context
 // creation attributes.
 const int32 kTransferBufferSize = 1024 * 1024;
 
+static base::LazyInstance<
+    std::set<WebGraphicsContext3DInProcessCommandBufferImpl*> > g_all_contexts(
+        base::LINKER_INITIALIZED);
+
 // 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(
     base::LINKER_INITIALIZED);
 
 }  // namespace anonymous
 
 GLInProcessContext::~GLInProcessContext() {
   Destroy();
 }
 
 GLInProcessContext* GLInProcessContext::CreateViewContext(
     gfx::PluginWindowHandle render_surface,
+    GLInProcessContext* context_group,
     const char* allowed_extensions,
     const int32* attrib_list,
     const GURL& active_url) {
 #if defined(ENABLE_GPU)
   scoped_ptr<GLInProcessContext> context(new GLInProcessContext(NULL));
   if (!context->Initialize(
       true,
       render_surface,
       gfx::Size(),
+      context_group,
       allowed_extensions,
       attrib_list,
       active_url))
     return NULL;
 
   return context.release();
 #else
   return NULL;
 #endif
 }
 
 #if defined(OS_MACOSX)
 void GLInProcessContext::ResizeOnscreen(const gfx::Size& size) {
   DCHECK(size.width() > 0 && size.height() > 0);
   size_ = size;
 }
 #endif
 
 GLInProcessContext* GLInProcessContext::CreateOffscreenContext(
     GLInProcessContext* parent,
     const gfx::Size& size,
+    GLInProcessContext* context_group,
     const char* allowed_extensions,
     const int32* attrib_list,
     const GURL& active_url) {
 #if defined(ENABLE_GPU)
   scoped_ptr<GLInProcessContext> context(new GLInProcessContext(parent));
   if (!context->Initialize(
       false,
       gfx::kNullPluginWindow,
       size,
+      context_group,
       allowed_extensions,
       attrib_list,
       active_url))
     return NULL;
 
   return context.release();
 #else
   return NULL;
 #endif
 }
 
 void GLInProcessContext::ResizeOffscreen(const gfx::Size& size) {
   DCHECK(size.width() > 0 && size.height() > 0);
   if (size_ != size) {
     gpu_scheduler_->ResizeOffscreenFrameBuffer(size);
     // TODO(gman): See if the next line is needed.
     gles2_implementation_->ResizeCHROMIUM(size.width(),  size.height());
     size_ = size;
   }
 }
 
 void GLInProcessContext::PumpCommands() {
   ::gpu::CommandBuffer::State state;
   do {
     gpu_scheduler_->PutChanged();
     MessageLoop::current()->RunAllPending();
     state = command_buffer_->GetState();
+    CHECK(state.error == ::gpu::error::kNoError);

[jamesr, 2011/08/03 21:51:20]

On second thought, can you get rid of the RunAllPending() call here?  I'd be
much happier without it, even if that means we had to change it if we later made
the command buffer scheduler use PostTask().  Right now this is just super scary
code :/

   } while (state.get_offset != state.put_offset);
 }
 
 uint32 GLInProcessContext::GetParentTextureId() {
   return parent_texture_id_;
 }
 
 uint32 GLInProcessContext::CreateParentTexture(const gfx::Size& size) {
-  // Allocate a texture ID with respect to the parent.
-  if (parent_.get()) {
-    if (!MakeCurrent(parent_.get()))
-      return 0;
-    uint32 texture_id = parent_->gles2_implementation_->MakeTextureId();
-    parent_->gles2_implementation_->BindTexture(GL_TEXTURE_2D, texture_id);
-    parent_->gles2_implementation_->TexParameteri(
-        GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    parent_->gles2_implementation_->TexParameteri(
-        GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    parent_->gles2_implementation_->TexParameteri(
-        GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    parent_->gles2_implementation_->TexParameteri(
-        GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-
-    parent_->gles2_implementation_->TexImage2D(GL_TEXTURE_2D,
-        0,  // mip level
-        GL_RGBA,
-        size.width(),
-        size.height(),
-        0,  // border
-        GL_RGBA,
-        GL_UNSIGNED_BYTE,
-        NULL);
-    // Make sure that the parent texture's storage is allocated before we let
-    // the caller attempt to use it.
-    int32 token = parent_->gles2_helper_->InsertToken();
-    parent_->gles2_helper_->WaitForToken(token);
-    return texture_id;
-  }
-  return 0;
+  uint32 texture = 0;
+  gles2_implementation_->GenTextures(1, &texture);
+  gles2_implementation_->Flush();
+  return texture;
 }
 
 void GLInProcessContext::DeleteParentTexture(uint32 texture) {
-  if (parent_.get()) {
-    if (!MakeCurrent(parent_.get()))
-      return;
-    parent_->gles2_implementation_->DeleteTextures(1, &texture);
-  }
+  gles2_implementation_->DeleteTextures(1, &texture);
 }
 
 void GLInProcessContext::SetSwapBuffersCallback(Callback0::Type* callback) {
   swap_buffers_callback_.reset(callback);
 }
 
 void GLInProcessContext::SetContextLostCallback(Callback0::Type* callback) {
   context_lost_callback_.reset(callback);
 }
 
@@ skipping 65 matching lines @@
       gpu_scheduler_(NULL),
       gles2_helper_(NULL),
       transfer_buffer_id_(-1),
       gles2_implementation_(NULL),
       last_error_(SUCCESS) {
 }
 
 bool GLInProcessContext::Initialize(bool onscreen,
                                     gfx::PluginWindowHandle render_surface,
                                     const gfx::Size& size,
+                                    GLInProcessContext* context_group,
                                     const char* allowed_extensions,
                                     const int32* attrib_list,
                                     const GURL& active_url) {
   // Use one share group for all contexts.
   static 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();
@@ skipping 32 matching lines @@
         attribs.push_back(NONE);
         attrib_list = NULL;
         break;
     }
   }
 
   command_buffer_.reset(new CommandBufferService);
   if (!command_buffer_->Initialize(kCommandBufferSize))
     return false;
 
-  gpu_scheduler_ = GpuScheduler::Create(command_buffer_.get(),
-                                        NULL,
-                                        NULL);
+  gpu_scheduler_ = GpuScheduler::Create(
+      command_buffer_.get(),
+      NULL,
+      context_group ?
+          context_group->gpu_scheduler_->decoder()->GetContextGroup() : NULL);
 
   if (onscreen) {
     if (render_surface == gfx::kNullPluginWindow) {
       LOG(ERROR) << "Invalid surface handle for onscreen context.";
       command_buffer_.reset();
     } else {
       if (!gpu_scheduler_->Initialize(render_surface,
                                       gfx::Size(),
                                       false,
                                       ::gpu::gles2::DisallowedExtensions(),
@@ skipping 53 matching lines @@
     Destroy();
     return false;
   }
 
   // Create the object exposing the OpenGL API.
   gles2_implementation_ = new GLES2Implementation(
       gles2_helper_,
       transfer_buffer.size,
       transfer_buffer.ptr,
       transfer_buffer_id_,
-      false);
+      true);
 
   size_ = size;
 
   return true;
 }
 
 void GLInProcessContext::Destroy() {
   if (parent_.get() && parent_texture_id_ != 0) {
     parent_->gles2_implementation_->FreeTextureId(parent_texture_id_);
     parent_texture_id_ = 0;
   }
 
-  delete gles2_implementation_;
-  gles2_implementation_ = NULL;
+  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();
+
+    delete gles2_implementation_;
+    gles2_implementation_ = NULL;
+  }
 
   if (command_buffer_.get() && transfer_buffer_id_ != -1) {
     command_buffer_->DestroyTransferBuffer(transfer_buffer_id_);
     transfer_buffer_id_ = -1;
   }
 
   delete gles2_helper_;
   gles2_helper_ = NULL;
 
   command_buffer_.reset();
@@ skipping 19 matching lines @@
 #endif  // defined(OS_MACOSX)
       context_lost_callback_(0),
       context_lost_reason_(GL_NO_ERROR),
       cached_width_(0),
       cached_height_(0),
       bound_fbo_(0) {
 }
 
 WebGraphicsContext3DInProcessCommandBufferImpl::
     ~WebGraphicsContext3DInProcessCommandBufferImpl() {
+  g_all_contexts.Pointer()->erase(this);
 }
 
 // This string should only be passed for WebGL contexts. Nothing ELSE!!!
 // Compositor contexts, Canvas2D contexts, Pepper Contexts, nor any other use of
 // a context should not pass this string.
 static const char* kWebGLPreferredGLExtensions =
     "GL_OES_packed_depth_stencil "
     "GL_OES_depth24 "
     "GL_CHROMIUM_webglsl";
 
@@ skipping 31 matching lines @@
     WebKit::WebGraphicsContext3D* view_context =
         web_view->graphicsContext3D();
     if (view_context) {
       WebGraphicsContext3DInProcessCommandBufferImpl* context_impl =
           static_cast<WebGraphicsContext3DInProcessCommandBufferImpl*>(
               view_context);
       parent_context = context_impl->context_;
     }
   }
 
+  // HACK: Assume this is a WebGL context by looking for the noExtensions
+  // attribute. WebGL contexts must not go in the share group because they
+  // rely on destruction of the context to clean up owned resources. Putting
+  // them in a share group would prevent this from happening.
+  WebGraphicsContext3DInProcessCommandBufferImpl* context_group = NULL;
+  if (!attributes.noExtensions)
+    context_group = g_all_contexts.Pointer()->empty() ?
+        NULL : *g_all_contexts.Pointer()->begin();
+
   context_ = GLInProcessContext::CreateOffscreenContext(
       parent_context,
       gfx::Size(1, 1),
+      context_group ? context_group->context_ : NULL,
       preferred_extensions,
       attribs,
       active_url);
   web_view_ = NULL;
 
   if (!context_)
     return false;
 
   gl_ = context_->GetImplementation();
   context_->SetContextLostCallback(
@@ skipping 12 matching lines @@
     attributes_.depth = depth_bits > 0;
     GLint stencil_bits = 0;
     getIntegerv(GL_STENCIL_BITS, &stencil_bits);
     attributes_.stencil = stencil_bits > 0;
     GLint samples = 0;
     getIntegerv(GL_SAMPLES, &samples);
     attributes_.antialias = samples > 0;
   }
   makeContextCurrent();
 
+  if (!attributes.noExtensions)
+    g_all_contexts.Pointer()->insert(this);
+
   return true;
 }
 
 bool WebGraphicsContext3DInProcessCommandBufferImpl::makeContextCurrent() {
   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
@@ skipping 906 matching lines @@
   if (context_lost_callback_) {
     context_lost_callback_->onContextLost();
   }
 }
 
 }  // namespace gpu
 }  // namespace webkit
 
 #endif  // defined(ENABLE_GPU)