pepper: Use the RenderThread's shared context as the parent context.

content/renderer/pepper/pepper_platform_context_3d_impl.cc

 // Copyright (c) 2012 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/pepper/pepper_platform_context_3d_impl.h"
 
 #include "base/bind.h"
+#include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
-#include "content/renderer/pepper/pepper_parent_context_provider.h"
 #include "content/renderer/render_thread_impl.h"
 #include "googleurl/src/gurl.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/ipc/command_buffer_proxy.h"
 #include "ppapi/c/pp_graphics_3d.h"
 #include "ui/gl/gpu_preference.h"
 
 #ifdef ENABLE_GPU
 
 namespace content {
 
-PlatformContext3DImpl::PlatformContext3DImpl(
-    PepperParentContextProvider* parent_context_provider)
-      : parent_context_provider_(parent_context_provider),
-        parent_texture_id_(0),
-        has_alpha_(false),
-        command_buffer_(NULL),
-        weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+PlatformContext3DImpl::PlatformContext3DImpl()
+    : parent_texture_id_(0),
+      has_alpha_(false),
+      command_buffer_(NULL),
+      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 PlatformContext3DImpl::~PlatformContext3DImpl() {
-  if (parent_context_.get() && parent_texture_id_ != 0) {
+  if (parent_texture_id_) {
     // Flush any remaining commands in the parent context to make sure the
     // texture id accounting stays consistent.
     gpu::gles2::GLES2Implementation* parent_gles2 =
-        parent_context_->GetImplementation();
+        parent_context_provider_->Context3d()->GetImplementation();
     parent_gles2->helper()->CommandBufferHelper::Finish();
     parent_gles2->FreeTextureId(parent_texture_id_);
   }
 
   if (command_buffer_) {
     DCHECK(channel_.get());
     channel_->DestroyCommandBuffer(command_buffer_);
     command_buffer_ = NULL;
   }
 
   channel_ = NULL;
 }
 
 bool PlatformContext3DImpl::Init(const int32* attrib_list,
                                  PlatformContext3D* share_context) {
   // Ignore initializing more than once.
   if (command_buffer_)
     return true;
 
-  if (!parent_context_provider_)
-    return false;
-
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   if (!render_thread)
     return false;
 
   gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;
 
   channel_ = render_thread->EstablishGpuChannelSync(
       CAUSE_FOR_GPU_LAUNCH_PEPPERPLATFORMCONTEXT3DIMPL_INITIALIZE);
   if (!channel_.get())
     return false;
@@ skipping 49 matching lines @@
   if (!command_buffer_)
     return false;
 
   command_buffer_->SetChannelErrorCallback(
       base::Bind(&PlatformContext3DImpl::OnContextLost,
                  weak_ptr_factory_.GetWeakPtr()));
   command_buffer_->SetOnConsoleMessageCallback(
       base::Bind(&PlatformContext3DImpl::OnConsoleMessage,
                  weak_ptr_factory_.GetWeakPtr()));
 
-  // Fetch the parent context now, after any potential shutdown of the
-  // channel due to GPU switching, and creation of the Pepper 3D
-  // context with the discrete GPU preference.
-  WebGraphicsContext3DCommandBufferImpl* parent_context =
-      parent_context_provider_->GetParentContextForPlatformContext3D();
-  if (!parent_context)
+  parent_context_provider_ =
+      render_thread->OffscreenContextProviderForMainThread();
+  if (!parent_context_provider_->InitializeOnMainThread() ||
+      !parent_context_provider_->BindToCurrentThread()) {

[piman, 2013/03/08 04:43:16]

Is it ok to do those every time? Should this be done by
RenderThreadImpl::OffscreenContextProviderForMainThread then?

[danakj, 2013/03/08 18:13:34]

Ya this is a noop if you already did it once. I like requesting the context
provider to not have side effects.

[piman, 2013/03/08 18:27:08]

It does have side effect in the sense that it creates one. It's a bit of an
arbitrary distinction in that if InitializeOnMainThread was done in the
constructor that would happen too.

At the same time, it's a bit obscure what exact set of calls in what order has
to be done before the ContextProvider is usable, and this code is repeated in
several places... It'd be nice to factor into a single place.

[danakj, 2013/03/08 18:40:28]

It creates a context provider, which is just a wrapper basically, but not a
WGC3D. I wanted the getter for OffscreenContextProviderOnSomeThread to always
return a valid pointer rather than do initialization and maybe return a null. I
guess it could do this anyways, and the callsite could check initialized() or
valid() or something, idk.
I guess we can build in the assumption that ContextProvider is always created on
the main thread, and then it can call Initialize right away. The call site will
still want to call bind though. For the main thread one, it could avoid it I
guess, but for other threads it would need to be explicit, and I like it being
consistent I think?

Anyhow.. let me open a bug.

+    parent_context_provider_ = NULL;
     return false;
-
-  parent_context_provider_ = NULL;
-  parent_context_ = parent_context->AsWeakPtr();
+  }
 
   // Flush any remaining commands in the parent context to make sure the
   // texture id accounting stays consistent.
   gpu::gles2::GLES2Implementation* parent_gles2 =
-      parent_context_->GetImplementation();
+      parent_context_provider_->Context3d()->GetImplementation();
   parent_gles2->helper()->CommandBufferHelper::Finish();
   parent_texture_id_ = parent_gles2->MakeTextureId();
 
   CommandBufferProxyImpl* parent_command_buffer =
-      parent_context_->GetCommandBufferProxy();
-  if (!command_buffer_->SetParent(parent_command_buffer, parent_texture_id_))
-    return false;
-
+      parent_context_provider_->Context3d()->GetCommandBufferProxy();
+  command_buffer_->SetParent(parent_command_buffer, parent_texture_id_);
   return true;
 }
 
-void PlatformContext3DImpl::SetParentContext(
-    PepperParentContextProvider* parent_context_provider) {
-  if (parent_context_.get() && parent_texture_id_ != 0) {
-    // Flush any remaining commands in the parent context to make sure the
-    // texture id accounting stays consistent.
-    gpu::gles2::GLES2Implementation* parent_gles2 =
-        parent_context_->GetImplementation();
-    parent_gles2->helper()->CommandBufferHelper::Flush();
-    parent_gles2->FreeTextureId(parent_texture_id_);
-    parent_context_.reset();
-    parent_texture_id_ = 0;
-  }
-
-  WebGraphicsContext3DCommandBufferImpl* parent_context =
-      parent_context_provider->GetParentContextForPlatformContext3D();
-  if (!parent_context)
-    return;
-
-  parent_context_ = parent_context->AsWeakPtr();
-  // Flush any remaining commands in the parent context to make sure the
-  // texture id accounting stays consistent.
-  gpu::gles2::GLES2Implementation* parent_gles2 =
-      parent_context_->GetImplementation();
-  parent_gles2->helper()->CommandBufferHelper::Flush();
-  parent_texture_id_ = parent_gles2->MakeTextureId();
-
-  CommandBufferProxyImpl* parent_command_buffer =
-      parent_context_->GetCommandBufferProxy();
-  command_buffer_->SetParent(parent_command_buffer, parent_texture_id_);
-}
-
 unsigned PlatformContext3DImpl::GetBackingTextureId() {
   DCHECK(command_buffer_);
   return parent_texture_id_;
 }
 
 WebKit::WebGraphicsContext3D* PlatformContext3DImpl::GetParentContext() {
-  return parent_context_.get();
+  return parent_context_provider_->Context3d();
 }
 
 bool PlatformContext3DImpl::IsOpaque() {
   DCHECK(command_buffer_);
   return !has_alpha_;
 }
 
 gpu::CommandBuffer* PlatformContext3DImpl::GetCommandBuffer() {
   return command_buffer_;
 }
@@ skipping 26 matching lines @@
 void PlatformContext3DImpl::OnConsoleMessage(const std::string& msg, int id) {
   DCHECK(command_buffer_);
 
   if (!console_message_callback_.is_null())
     console_message_callback_.Run(msg, id);
 }
 
 }  // namespace content
 
 #endif  // ENABLE_GPU