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

content/renderer/render_widget_fullscreen_pepper.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/render_widget_fullscreen_pepper.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 314 matching lines @@
   }
 
   virtual bool caretOrSelectionRange(size_t* location, size_t* length) {
     return false;
   }
 
   virtual void setTextDirection(WebTextDirection) {
   }
 
   virtual bool isAcceleratedCompositingActive() const {
-    return widget_->context() && widget_->plugin() &&
-        (widget_->plugin()->GetBackingTextureId() != 0);
+    return widget_->plugin() && widget_->plugin()->GetBackingTextureId();
   }
 
  private:
   RenderWidgetFullscreenPepper* widget_;
   WebSize size_;
 
   DISALLOW_COPY_AND_ASSIGN(PepperWidget);
 };
 
 void DestroyContext(WebGraphicsContext3DCommandBufferImpl* context,
@@ skipping 97 matching lines @@
 }
 
 void RenderWidgetFullscreenPepper::DidChangeCursor(
     const WebKit::WebCursorInfo& cursor) {
   didChangeCursor(cursor);
 }
 
 webkit::ppapi::PluginDelegate::PlatformContext3D*
 RenderWidgetFullscreenPepper::CreateContext3D() {
 #ifdef ENABLE_GPU
-  return new PlatformContext3DImpl(this);
+  return new PlatformContext3DImpl;
 #else
   return NULL;
 #endif
 }
 
-void RenderWidgetFullscreenPepper::ReparentContext(
-    webkit::ppapi::PluginDelegate::PlatformContext3D* context) {
-  static_cast<PlatformContext3DImpl*>(context)->SetParentContext(this);
-}
-
 bool RenderWidgetFullscreenPepper::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderWidgetFullscreenPepper, msg)
     IPC_MESSAGE_FORWARD(ViewMsg_LockMouse_ACK,
                         mouse_lock_dispatcher_.get(),
                         MouseLockDispatcher::OnLockMouseACK)
     IPC_MESSAGE_FORWARD(ViewMsg_MouseLockLost,
                         mouse_lock_dispatcher_.get(),
                         MouseLockDispatcher::OnMouseLockLost)
     IPC_MESSAGE_UNHANDLED(handled = false)
@@ skipping 78 matching lines @@
   unsigned int texture = plugin_->GetBackingTextureId();
   context_->bindTexture(GL_TEXTURE_2D, texture);
   context_->drawArrays(GL_TRIANGLES, 0, 3);
   SwapBuffers();
 }
 
 void RenderWidgetFullscreenPepper::CreateContext() {
   DCHECK(!context_);
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kDisableFlashFullscreen3d))
     return;

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

I just thought of something else: what about this part? Left as is, if this flag
is on, we will let the plugin create a context and a texture, but we will never
composite it.
I think it used to be that the ReparentContext would have failed and so Pepper
would fall back to software. Maybe John can comment on how this should work...

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

Right! You're right, SetParentContext() would early out and not make a texture.
Then isAcceleratedCompositingActive() would be false because it checks for the
texture id.

I think we can just move this check to CheckCompositing(). If it is on, we set
compositing=false, and we don't CreateContext() and we go down the
disable-compositing path.

How's that sound? Patch uploaded with that.

   WebKit::WebGraphicsContext3D::Attributes attributes;
   attributes.depth = false;
   attributes.stencil = false;
   attributes.antialias = false;
-  attributes.shareResources = false;
+  attributes.shareResources = true;
   attributes.preferDiscreteGPU = true;
   context_ = WebGraphicsContext3DCommandBufferImpl::CreateViewContext(
       RenderThreadImpl::current(),
       surface_id(),
       NULL,
       attributes,
       true /* bind generates resources */,
       active_url_,
       CAUSE_FOR_GPU_LAUNCH_RENDERWIDGETFULLSCREENPEPPER_CREATECONTEXT);
   if (!context_)
@@ skipping 100 matching lines @@
   context_->vertexAttribPointer(0, 2,
                                 GL_FLOAT, GL_FALSE,
                                 0, static_cast<WGC3Dintptr>(NULL));
   context_->enableVertexAttribArray(0);
   return true;
 }
 
 bool RenderWidgetFullscreenPepper::CheckCompositing() {
   bool compositing =
       webwidget_ && webwidget_->isAcceleratedCompositingActive();
+
+  if (compositing) {
+    if (context_ && context_->isContextLost()) {
+      DestroyContext(context_, program_, buffer_);
+      context_ = NULL;
+    }
+    if (!context_)
+      CreateContext();

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

If CreateContext fails, we should reset compositing to false, otherwise we'll
try to composite with no context and bad things will happen.

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

Done.

+  }
+
   if (compositing != is_accelerated_compositing_active_) {
     if (compositing)
       didActivateCompositor(-1);
-    else
+    else {
+      if (context_) {
+        DestroyContext(context_, program_, buffer_);
+        context_ = NULL;
+      }
       didDeactivateCompositor();
+    }
   }
   return compositing;
 }
 
 void RenderWidgetFullscreenPepper::SwapBuffers() {
   DCHECK(context_);
   context_->prepareTexture();
 
   // The compositor isn't actually active in this path, but pretend it is for
   // scheduling purposes.
   didCommitAndDrawCompositorFrame();
 }
 
-WebGraphicsContext3DCommandBufferImpl*
-RenderWidgetFullscreenPepper::GetParentContextForPlatformContext3D() {
-  if (!context_) {
-    CreateContext();
-  }
-  if (!context_)
-    return NULL;
-  return context_;
-}
-
 }  // namespace content