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

content/renderer/gpu/renderer_gl_context.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.
 
 #include "content/renderer/gpu/renderer_gl_context.h"
 
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 65 matching lines @@
 
 }  // namespace anonymous
 
 RendererGLContext::~RendererGLContext() {
   Destroy();
 }
 
 RendererGLContext* RendererGLContext::CreateViewContext(
     GpuChannelHost* channel,
     int render_view_id,
+    RendererGLContext* share_group,
     const char* allowed_extensions,
     const int32* attrib_list,
     const GURL& active_url) {
 #if defined(ENABLE_GPU)
   scoped_ptr<RendererGLContext> context(new RendererGLContext(channel));
   if (!context->Initialize(
       true,
       render_view_id,
       gfx::Size(),
+      share_group,
       allowed_extensions,
       attrib_list,
       active_url))
     return NULL;
 
   return context.release();
 #else
   return NULL;
 #endif
 }
 
 #if defined(OS_MACOSX)
 void RendererGLContext::ResizeOnscreen(const gfx::Size& size) {
   DCHECK(size.width() > 0 && size.height() > 0);
   size_ = size;
   command_buffer_->SetWindowSize(size);
 }
 #endif
 
 RendererGLContext* RendererGLContext::CreateOffscreenContext(
     GpuChannelHost* channel,
     const gfx::Size& size,
+    RendererGLContext* share_group,
     const char* allowed_extensions,
     const int32* attrib_list,
     const GURL& active_url) {
 #if defined(ENABLE_GPU)
   scoped_ptr<RendererGLContext> context(new RendererGLContext(channel));
   if (!context->Initialize(
       false,
       0,
       size,
+      share_group,
       allowed_extensions,
       attrib_list,
       active_url))
     return NULL;
 
   return context.release();
 #else
   return NULL;
 #endif
 }
@@ skipping 52 matching lines @@
     command_buffer_->ResizeOffscreenFrameBuffer(size);
     size_ = size;
   }
 }
 
 uint32 RendererGLContext::GetParentTextureId() {
   return parent_texture_id_;
 }
 
 uint32 RendererGLContext::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_id = 0;
+  gles2_implementation_->GenTextures(1, &texture_id);
+  parent_->gles2_implementation_->Flush();

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

why is this doing a flush on the parent? shouldn't it be doing a flush on this
context, since it's really creating a texture here (and not on the parent)?

+  return texture_id;
 }
 
 void RendererGLContext::DeleteParentTexture(uint32 texture) {
-  if (parent_.get()) {
-    if (!MakeCurrent(parent_.get()))
-      return;
-    parent_->gles2_implementation_->DeleteTextures(1, &texture);
-  }
+  gles2_implementation_->DeleteTextures(1, &texture);
 }
 
 void RendererGLContext::SetSwapBuffersCallback(Callback0::Type* callback) {
   swap_buffers_callback_.reset(callback);
 }
 
 void RendererGLContext::SetContextLostCallback(
     Callback1<ContextLostReason>::Type* callback) {
   context_lost_callback_.reset(callback);
 }
@@ skipping 76 matching lines @@
       transfer_buffer_id_(-1),
       gles2_implementation_(NULL),
       last_error_(SUCCESS),
       frame_number_(0) {
   DCHECK(channel);
 }
 
 bool RendererGLContext::Initialize(bool onscreen,
                                    int render_view_id,
                                    const gfx::Size& size,
+                                   RendererGLContext* share_group,
                                    const char* allowed_extensions,
                                    const int32* attrib_list,
                                    const GURL& active_url) {
   DCHECK(size.width() >= 0 && size.height() >= 0);
   TRACE_EVENT2("gpu", "RendererGLContext::Initialize",
                    "on_screen", onscreen, "num_pixels", size.GetArea());
 
   if (channel_->state() != GpuChannelHost::kConnected)
     return false;
 
@@ skipping 27 matching lines @@
         break;
     }
   }
 
   // Create a proxy to a command buffer in the GPU process.
   if (onscreen) {
     TRACE_EVENT0("gpu",
                  "RendererGLContext::Initialize::CreateViewCommandBuffer");
     command_buffer_ = channel_->CreateViewCommandBuffer(
         render_view_id,
+        share_group ? share_group->command_buffer_ : NULL,
         allowed_extensions,
         attribs,
         active_url);
   } else {
     command_buffer_ = channel_->CreateOffscreenCommandBuffer(
         size,
+        share_group ? share_group->command_buffer_ : NULL,
         allowed_extensions,
         attribs,
         active_url);
   }
   if (!command_buffer_) {
     Destroy();
     return false;
   }
 
   {
@@ skipping 38 matching lines @@
     Destroy();
     return false;
   }
 
   // Create the object exposing the OpenGL API.
   gles2_implementation_ = new gpu::gles2::GLES2Implementation(
       gles2_helper_,
       transfer_buffer.size,
       transfer_buffer.ptr,
       transfer_buffer_id_,
-      false);
+      true);
 
   size_ = size;
 
   return true;
 }
 
 void RendererGLContext::Destroy() {
   TRACE_EVENT0("gpu", "RendererGLContext::Destroy");
   SetParent(NULL);
 
-  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;
+  }
 
   // Do not destroy this transfer buffer here, because commands are still
   // in flight on the GPU process that may access them. When the command buffer
   // is destroyed, the associated shared memory will be cleaned up.
   transfer_buffer_id_ = -1;
 
   delete gles2_helper_;
   gles2_helper_ = NULL;
 
   if (channel_ && command_buffer_) {
@@ skipping 12 matching lines @@
 void RendererGLContext::OnContextLost() {
   if (context_lost_callback_.get()) {
     RendererGLContext::ContextLostReason reason = kUnknown;
     if (command_buffer_) {
       reason = ConvertReason(
           command_buffer_->GetLastState().context_lost_reason);
     }
     context_lost_callback_->Run(reason);
   }
 }