RendererGLContext supports reparenting a GL context.

gpu/command_buffer/service/gles2_cmd_decoder.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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 694 matching lines @@
 
   // Overridden from AsyncAPIInterface.
   virtual const char* GetCommandName(unsigned int command_id) const;
 
   // Overridden from GLES2Decoder.
   virtual bool Initialize(const scoped_refptr<gfx::GLSurface>& surface,
                           const scoped_refptr<gfx::GLContext>& context,
                           const gfx::Size& size,
                           const DisallowedExtensions& disallowed_extensions,
                           const char* allowed_extensions,
-                          const std::vector<int32>& attribs,
-                          GLES2Decoder* parent,
-                          uint32 parent_client_texture_id);
+                          const std::vector<int32>& attribs);
   virtual void Destroy();
+  virtual bool SetParent(GLES2Decoder* parent_decoder,
+                         uint32 parent_texture_id);
   virtual void ResizeOffscreenFrameBuffer(const gfx::Size& size);
   virtual bool UpdateOffscreenFrameBufferSize();
   virtual bool MakeCurrent();
   virtual GLES2Util* GetGLES2Util() { return &util_; }
   virtual gfx::GLContext* GetGLContext() { return context_.get(); }
   virtual gfx::GLSurface* GetGLSurface() { return surface_.get(); }
   virtual ContextGroup* GetContextGroup() { return group_.get(); }
 
   virtual void SetResizeCallback(Callback1<gfx::Size>::Type* callback);
   virtual void SetSwapBuffersCallback(Callback0::Type* callback);
@@ skipping 1154 matching lines @@
     bufferdata_faster_than_buffersubdata_ = false;
   }
 }
 
 bool GLES2DecoderImpl::Initialize(
     const scoped_refptr<gfx::GLSurface>& surface,
     const scoped_refptr<gfx::GLContext>& context,
     const gfx::Size& size,
     const DisallowedExtensions& disallowed_extensions,
     const char* allowed_extensions,
-    const std::vector<int32>& attribs,
-    GLES2Decoder* parent,
-    uint32 parent_client_texture_id) {
+    const std::vector<int32>& attribs) {
   DCHECK(context);
   DCHECK(!context_.get());
 
   // Take ownership of the GLSurface. TODO(apatrick): once the parent / child
   // context is retired, the decoder should not take an initial surface as
   // an argument to this function.
   // Maybe create a short lived offscreen GLSurface for the purpose of
   // initializing the decoder's GLContext.
   surface_ = surface;
 
   // Take ownership of the GLContext.
   context_ = context;
 
-  // Keep only a weak pointer to the parent so we don't unmap its client
-  // frame buffer after it has been destroyed.
-  if (parent)
-    parent_ = static_cast<GLES2DecoderImpl*>(parent)->AsWeakPtr();
-
   if (!MakeCurrent()) {
     LOG(ERROR) << "GLES2DecoderImpl::Initialize failed because "
                << "MakeCurrent failed.";
     Destroy();
     return false;
   }
 
   if (!group_->Initialize(disallowed_extensions, allowed_extensions)) {
     LOG(ERROR) << "GpuScheduler::InitializeCommon failed because group "
                << "failed to initialize.";
@@ skipping 137 matching lines @@
     offscreen_target_stencil_render_buffer_->Create();
 
     // Create the saved offscreen texture. The target frame buffer is copied
     // here when SwapBuffers is called.
     offscreen_saved_frame_buffer_.reset(new FrameBuffer(this));
     offscreen_saved_frame_buffer_->Create();
     //
     offscreen_saved_color_texture_.reset(new Texture(this));
     offscreen_saved_color_texture_->Create();
 
-    // Map the ID of the saved offscreen texture into the parent so that
-    // it can reference it.
-    if (parent_) {
-      GLuint service_id = offscreen_saved_color_texture_->id();
-      TextureManager::TextureInfo* info =
-          parent_->CreateTextureInfo(parent_client_texture_id, service_id);
-      info->SetNotOwned();
-      parent_->texture_manager()->SetInfoTarget(info, GL_TEXTURE_2D);
-    }
-
     // Allocate the render buffers at their initial size and check the status
     // of the frame buffers is okay.
     pending_offscreen_size_ = size;
     if (!UpdateOffscreenFrameBufferSize()) {
       LOG(ERROR) << "Could not allocate offscreen buffer storage.";
       Destroy();
       return false;
     }
 
     // Bind to the new default frame buffer (the offscreen target frame buffer).
@@ skipping 460 matching lines @@
   }
   return false;
 }
 
 void GLES2DecoderImpl::Destroy() {
   bool have_context = context_.get() && MakeCurrent();
 
   if (group_.get())
     group_->set_have_context(have_context);
 
+  SetParent(NULL, 0);
+
   if (have_context) {
     if (current_program_) {
       program_manager()->UnuseProgram(shader_manager(), current_program_);
       current_program_ = NULL;
     }
 
     if (attrib_0_buffer_id_) {
       glDeleteBuffersARB(1, &attrib_0_buffer_id_);
     }
     if (fixed_attrib_buffer_id_) {
       glDeleteBuffersARB(1, &fixed_attrib_buffer_id_);
     }
 
-    // Remove the saved frame buffer mapping from the parent decoder. The
-    // parent pointer is a weak pointer so it will be null if the parent has
-    // already been destroyed.
-    if (parent_) {
-      // First check the texture has been mapped into the parent. This might not
-      // be the case if initialization failed midway through.
-      GLuint service_id = offscreen_saved_color_texture_->id();
-      GLuint client_id = 0;
-      if (parent_->texture_manager()->GetClientId(service_id, &client_id)) {
-        parent_->texture_manager()->RemoveTextureInfo(feature_info_, client_id);
-      }
-
+    if (copy_texture_to_parent_texture_fb_)
       glDeleteFramebuffersEXT(1, &copy_texture_to_parent_texture_fb_);
-    }
 
     if (offscreen_target_frame_buffer_.get())
       offscreen_target_frame_buffer_->Destroy();
     if (offscreen_target_color_texture_.get())
       offscreen_target_color_texture_->Destroy();
     if (offscreen_target_color_render_buffer_.get())
       offscreen_target_color_render_buffer_->Destroy();
     if (offscreen_target_depth_render_buffer_.get())
       offscreen_target_depth_render_buffer_->Destroy();
     if (offscreen_target_stencil_render_buffer_.get())
@@ skipping 31 matching lines @@
 
   offscreen_target_frame_buffer_.reset();
   offscreen_target_color_texture_.reset();
   offscreen_target_color_render_buffer_.reset();
   offscreen_target_depth_render_buffer_.reset();
   offscreen_target_stencil_render_buffer_.reset();
   offscreen_saved_frame_buffer_.reset();
   offscreen_saved_color_texture_.reset();
 }
 
+bool GLES2DecoderImpl::SetParent(GLES2Decoder* new_parent,
+                                 uint32 new_parent_texture_id) {
+  // Remove the saved frame buffer mapping from the parent decoder. The
+  // parent pointer is a weak pointer so it will be null if the parent has
+  // already been destroyed.
+  if (parent_) {
+    // First check the texture has been mapped into the parent. This might not
+    // be the case if initialization failed midway through.
+    GLuint service_id = offscreen_saved_color_texture_->id();
+    GLuint client_id = 0;
+    if (parent_->texture_manager()->GetClientId(service_id, &client_id)) {
+      parent_->texture_manager()->RemoveTextureInfo(feature_info_, client_id);
+    }
+  }
+
+  GLES2DecoderImpl* new_parent_impl = static_cast<GLES2DecoderImpl*>(
+      new_parent);
+  if (new_parent_impl) {
+    // Map the ID of the saved offscreen texture into the parent so that
+    // it can reference it.
+    GLuint service_id = offscreen_saved_color_texture_->id();
+    TextureManager::TextureInfo* info =
+        new_parent_impl->CreateTextureInfo(new_parent_texture_id, service_id);
+    info->SetNotOwned();
+    new_parent_impl->texture_manager()->SetInfoTarget(info, GL_TEXTURE_2D);
+
+    parent_ = new_parent_impl->AsWeakPtr();
+  } else {
+    parent_.reset();
+  }
+
+  return true;
+}
+
 void GLES2DecoderImpl::ResizeOffscreenFrameBuffer(const gfx::Size& size) {
   // We can't resize the render buffers immediately because there might be a
   // partial frame rendered into them and we don't want the tail end of that
   // rendered into the reallocated storage. Defer until the next SwapBuffers.
   pending_offscreen_size_ = size;
 }
 
 void GLES2DecoderImpl::DoCopyTextureToParentTextureCHROMIUM(
     GLuint client_texture_id,
     GLuint parent_client_texture_id) {
@@ skipping 3987 matching lines @@
   return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu