RendererGLContext supports reparenting a GL context.

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 143 matching lines @@
 }
 
 RendererGLContext* RendererGLContext::CreateViewContext(
     GpuChannelHost* channel,
     gfx::PluginWindowHandle render_surface,
     int render_view_id,
     const char* allowed_extensions,
     const int32* attrib_list,
     const GURL& active_url) {
 #if defined(ENABLE_GPU)
-  scoped_ptr<RendererGLContext> context(new RendererGLContext(channel, NULL));
+  scoped_ptr<RendererGLContext> context(new RendererGLContext(channel));
   if (!context->Initialize(
       true,
       render_surface,
       render_view_id,
       gfx::Size(),
       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,
-    RendererGLContext* parent,
     const gfx::Size& size,
     const char* allowed_extensions,
     const int32* attrib_list,
     const GURL& active_url) {
 #if defined(ENABLE_GPU)
-  scoped_ptr<RendererGLContext> context(new RendererGLContext(channel, parent));
+  scoped_ptr<RendererGLContext> context(new RendererGLContext(channel));
   if (!context->Initialize(
       false,
       gfx::kNullPluginWindow,
       0,
       size,
       allowed_extensions,
       attrib_list,
       active_url))
     return NULL;
 
   return context.release();
 #else
   return NULL;
 #endif
 }
 
+bool RendererGLContext::SetParent(RendererGLContext* new_parent) {
+  // Allocate a texture ID with respect to the parent and change the parent.
+  uint32 new_parent_texture_id = 0;
+  if (new_parent) {
+    TRACE_EVENT0("gpu", "RendererGLContext::SetParent::flushParent");
+    // Flush any remaining commands in the parent context to make sure the
+    // texture id accounting stays consistent.
+    int32 token = new_parent->gles2_helper_->InsertToken();
+    new_parent->gles2_helper_->WaitForToken(token);
+    new_parent_texture_id = new_parent->gles2_implementation_->MakeTextureId();
+
+    if (!command_buffer_->SetParent(new_parent->command_buffer_,
+                                    new_parent_texture_id)) {

[piman, 2011/06/22 00:10:59]

Drive-by: since this happens out-of-band (with a message, not from the command
buffers), can this race with, say, latches ?
Case scenario:
child->SetLatch(child_to_parent)
parent1->WaitLatch(child_to_parent);
child->SetParent(parent2)
parent1->Finish()

What happens if the SetParent is executed before the SetLatch is executed ? Or
the WaitLatch ?

[apatrick_chromium, 2011/06/22 00:21:03]

It should be alright at the moment because SetParent is always called
immediately after the context is created with no latch related stuff in between.
There have been some latch related issues since this landed when trying to
create a canvas and using it to render to a window that doesn't yet exist (like
JavaScript synchronously opening a popup and then sticking a canvas in its DOM).
That doesn't work anyway though.

Going forward, I'm going to see if I can replace latches with proper glFlush /
glBindTexture semantics. I.e. call glFlush and the side effects are visible on
any other context on the channel, whether or not it was the parent at the time.

+      new_parent->gles2_implementation_->FreeTextureId(parent_texture_id_);
+      return false;
+    }
+  } else {
+    if (!command_buffer_->SetParent(NULL, 0))
+      return false;
+  }
+
+  // Free the previous parent's texture ID.
+  if (parent_.get() && parent_texture_id_ != 0)
+    parent_->gles2_implementation_->FreeTextureId(parent_texture_id_);
+
+  if (new_parent) {
+    parent_ = new_parent->AsWeakPtr();
+    parent_texture_id_ = new_parent_texture_id;
+  } else {
+    parent_.reset();
+    parent_texture_id_ = 0;
+  }
+
+  return true;
+}
+
 void RendererGLContext::ResizeOffscreen(const gfx::Size& size) {
   DCHECK(size.width() > 0 && size.height() > 0);
   if (size_ != size) {
     command_buffer_->ResizeOffscreenFrameBuffer(size);
     size_ = size;
   }
 }
 
 uint32 RendererGLContext::GetParentTextureId() {
   return parent_texture_id_;
@@ skipping 111 matching lines @@
 // TODO(gman): Remove This
 void RendererGLContext::DisableShaderTranslation() {
   gles2_implementation_->CommandBufferEnableCHROMIUM(
       PEPPER3D_SKIP_GLSL_TRANSLATION);
 }
 
 gpu::gles2::GLES2Implementation* RendererGLContext::GetImplementation() {
   return gles2_implementation_;
 }
 
-RendererGLContext::RendererGLContext(GpuChannelHost* channel,
-                                     RendererGLContext* parent)
+RendererGLContext::RendererGLContext(GpuChannelHost* channel)
     : channel_(channel),
-      parent_(parent ?
-          parent->AsWeakPtr() : base::WeakPtr<RendererGLContext>()),
+      parent_(base::WeakPtr<RendererGLContext>()),
       parent_texture_id_(0),
       child_to_parent_latch_(kInvalidLatchId),
       parent_to_child_latch_(kInvalidLatchId),
       latch_transfer_buffer_id_(-1),
       command_buffer_(NULL),
       gles2_helper_(NULL),
       transfer_buffer_id_(-1),
       gles2_implementation_(NULL),
       last_error_(SUCCESS),
       frame_number_(0) {
@@ skipping 10 matching lines @@
   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;
 
   // 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()) {
-    TRACE_EVENT0("gpu", "RendererGLContext::Initialize::flushParent");
-    // 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 24 matching lines @@
       TRACE_EVENT0("gpu",
                    "RendererGLContext::Initialize::CreateViewCommandBuffer");
       command_buffer_ = channel_->CreateViewCommandBuffer(
           render_surface,
           render_view_id,
           allowed_extensions,
           attribs,
           active_url);
     }
   } else {
-    CommandBufferProxy* parent_command_buffer =
-        parent_.get() ? parent_->command_buffer_ : NULL;
     command_buffer_ = channel_->CreateOffscreenCommandBuffer(
-        parent_command_buffer,
         size,
         allowed_extensions,
         attribs,
-        parent_texture_id_,
         active_url);
   }
   if (!command_buffer_) {
     Destroy();
     return false;
   }
 
   {
     TRACE_EVENT0("gpu",
                  "RendererGLContext::Initialize::InitializeCommandBuffer");
@@ skipping 42 matching lines @@
   latch_transfer_buffer_id_ = command_buffer_->RegisterTransferBuffer(
       latch_shm->shared_memory(), LatchAllocator::size(),
       gpu::kLatchSharedMemoryId);
   if (latch_transfer_buffer_id_ != gpu::kLatchSharedMemoryId) {
     Destroy();
     return false;
   }
 
   // If this is a child context, setup latches for synchronization between child
   // and parent.
-  if (parent_.get()) {
-    if (!CreateLatch(&child_to_parent_latch_) ||
-        !CreateLatch(&parent_to_child_latch_)) {
-      Destroy();
-      return false;
-    }
+  if (!CreateLatch(&child_to_parent_latch_) ||
+      !CreateLatch(&parent_to_child_latch_)) {
+    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);
 
   size_ = size;
 
   return true;
 }
 
 void RendererGLContext::Destroy() {
-  if (parent_.get() && parent_texture_id_ != 0) {
-    parent_->gles2_implementation_->FreeTextureId(parent_texture_id_);
-    parent_texture_id_ = 0;
-  }
+  SetParent(NULL);
 
   delete gles2_implementation_;
   gles2_implementation_ = NULL;
 
   if (child_to_parent_latch_ != kInvalidLatchId) {
     DestroyLatch(child_to_parent_latch_);
     child_to_parent_latch_ = kInvalidLatchId;
   }
   if (parent_to_child_latch_ != kInvalidLatchId) {
     DestroyLatch(parent_to_child_latch_);
@@ skipping 46 matching lines @@
   return false;
 }
 
 bool RendererGLContext::GetChildToParentLatch(uint32* child_to_parent_latch) {
   if (parent_.get()) {
     *child_to_parent_latch = child_to_parent_latch_;
     return true;
   }
   return false;
 }