RendererGLContext supports reparenting a GL context.

gpu/command_buffer/service/gpu_scheduler.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/gpu_scheduler.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
@@ skipping 48 matching lines @@
 GpuScheduler::~GpuScheduler() {
   Destroy();
 }
 
 bool GpuScheduler::InitializeCommon(
     const scoped_refptr<gfx::GLSurface>& surface,
     const scoped_refptr<gfx::GLContext>& context,
     const gfx::Size& size,
     const gles2::DisallowedExtensions& disallowed_extensions,
     const char* allowed_extensions,
-    const std::vector<int32>& attribs,
-    gles2::GLES2Decoder* parent_decoder,
-    uint32 parent_texture_id) {
+    const std::vector<int32>& attribs) {
   DCHECK(context);
 
   if (!context->MakeCurrent(surface))
     return false;
 
 #if !defined(OS_MACOSX)
   // Set up swap interval for onscreen contexts.
   if (!surface->IsOffscreen()) {
     if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableGpuVsync))
       context->SetSwapInterval(0);
@@ skipping 22 matching lines @@
   }
 
   // Initialize the decoder with either the view or pbuffer GLContext.
   // TODO(apatrick): The GpuScheduler should know nothing about the surface the
   // decoder is rendering to. Get rid of the surface parameter.
   if (!decoder_->Initialize(surface,
                             context,
                             size,
                             disallowed_extensions,
                             allowed_extensions,
-                            attribs,
-                            parent_decoder,
-                            parent_texture_id)) {
+                            attribs)) {
     LOG(ERROR) << "GpuScheduler::InitializeCommon failed because decoder "
                << "failed to initialize.";
     Destroy();
     return false;
   }
 
   return true;
 }
 
 void GpuScheduler::DestroyCommon() {
   bool have_context = false;
   if (decoder_.get()) {
     have_context = decoder_->MakeCurrent();
     decoder_->Destroy();
     decoder_.reset();
   }
 
   parser_.reset();
 }
 
+bool GpuScheduler::SetParent(GpuScheduler* parent_scheduler,
+                             uint32 parent_texture_id) {
+  if (parent_scheduler)
+    return decoder_->SetParent(parent_scheduler->decoder_.get(),
+                               parent_texture_id);
+  else
+    return decoder_->SetParent(NULL, 0);
+}
+
 #if defined(OS_MACOSX)
 namespace {
 const unsigned int kMaxOutstandingSwapBuffersCallsPerOnscreenContext = 1;
 }
 #endif
 
 void GpuScheduler::PutChanged(bool sync) {
   TRACE_EVENT1("gpu", "GpuScheduler:PutChanged", "this", this);
   CommandBuffer::State state = command_buffer_->GetState();
   parser_->set_put(state.put_offset);
@@ skipping 160 matching lines @@
       method_factory_.NewRunnableMethod(&GpuScheduler::ProcessCommands));
 }
 
 void GpuScheduler::WillResize(gfx::Size size) {
   if (wrapped_resize_callback_.get()) {
     wrapped_resize_callback_->Run(size);
   }
 }
 
 }  // namespace gpu