Don't require a recreation of the context when fullscreening

webkit/plugins/ppapi/ppapi_plugin_instance.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 "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
@@ skipping 1581 matching lines @@
     KeepSizeAttributesBeforeFullscreen();
     SetSizeAttributesForFullscreen();
     container_->element().requestFullScreen();
   } else {
     container_->element().document().cancelFullScreen();
   }
   return true;
 }
 
 void PluginInstance::FlashSetFullscreen(bool fullscreen, bool delay_report) {
+  TRACE_EVENT0("ppapi", "PluginInstance::FlashSetFullscreen");
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
 
   // We check whether we are trying to switch to the state we're already going
   // to (i.e. if we're already switching to fullscreen but the fullscreen
   // container isn't ready yet, don't do anything more).
   if (fullscreen == FlashIsFullscreenOrPending())
     return;
 
   // Unbind current 2D or 3D graphics context.
-  BindGraphics(pp_instance(), 0);
   VLOG(1) << "Setting fullscreen to " << (fullscreen ? "on" : "off");
   if (fullscreen) {
     DCHECK(!fullscreen_container_);
+    setBackingTextureId(0, false);
     fullscreen_container_ = delegate_->CreateFullscreenContainer(this);
   } else {
     DCHECK(fullscreen_container_);
     fullscreen_container_->Destroy();
     fullscreen_container_ = NULL;
     UpdateFlashFullscreenState(false);
     if (!delay_report) {
       ReportGeometry();
     } else {
       MessageLoop::current()->PostTask(
           FROM_HERE, base::Bind(&PluginInstance::ReportGeometry, this));
     }
   }
 }
 
 void PluginInstance::UpdateFlashFullscreenState(bool flash_fullscreen) {
   bool is_mouselock_pending = TrackedCallback::IsPending(lock_mouse_callback_);
 
   if (flash_fullscreen == flash_fullscreen_) {
     // Manually clear callback when fullscreen fails with mouselock pending.
     if (!flash_fullscreen && is_mouselock_pending)
       TrackedCallback::ClearAndRun(&lock_mouse_callback_, PP_ERROR_FAILED);
     return;
   }
+  if (flash_fullscreen && !flash_fullscreen_) {
+    PPB_Graphics3D_Impl* graphics_3d  = GetBoundGraphics3D();
+    if (graphics_3d) {
+      fullscreen_container_->ReparentContext(graphics_3d->platform_context());
+    }
+  }
+
+  if (!flash_fullscreen && flash_fullscreen_) {
+    PPB_Graphics3D_Impl* graphics_3d  = GetBoundGraphics3D();
+    if (graphics_3d) {
+      delegate_->ReparentContext(graphics_3d->platform_context());
+      setBackingTextureId(graphics_3d->GetBackingTextureId(),
+                          graphics_3d->IsOpaque());
+    }
+  }

[piman, 2012/09/13 00:04:33]

I think you can write the 2 blocks above in a slightly simpler way. We returned
earlier if flash_fullscreen == flash_fullscreen_ so you know you have a
transition. So you can write this as something like:
PPB_Graphics3D_Impl* graphics_3d  = GetBoundGraphics3D();
if (graphics_3d) {
  if (flash_fullscreen) {
    fullscreen_container_->ReparentContext(graphics_3d->platform_context());
  } else {
    delegate_->ReparentContext(graphics_3d->platform_context());
    setBackingTextureId(graphics_3d->GetBackingTextureId(),
                        graphics_3d->IsOpaque());
  }
}

 
   bool old_plugin_focus = PluginHasFocus();
   flash_fullscreen_ = flash_fullscreen;
   if (is_mouselock_pending && !delegate()->IsMouseLocked(this)) {
     if (!delegate()->LockMouse(this))
       TrackedCallback::ClearAndRun(&lock_mouse_callback_, PP_ERROR_FAILED);
   }
 
   if (PluginHasFocus() != old_plugin_focus)
     SendFocusChangeNotification();
@@ skipping 341 matching lines @@
 
 void PluginInstance::ClosePendingUserGesture(PP_Instance instance,
                                              PP_TimeTicks timestamp) {
   // Do nothing so that the pending user gesture will stay open for
   // kUserGestureDurationInSeconds.
   // TODO(yzshen): remove the code for closing pending user gesture.
 }
 
 PP_Bool PluginInstance::BindGraphics(PP_Instance instance,
                                      PP_Resource device) {
+  TRACE_EVENT0("ppapi", "PluginInstance::BindGraphics");
   // The Graphics3D instance can't be destroyed until we call
   // setBackingTextureId.
   scoped_refptr< ::ppapi::Resource> old_graphics = bound_graphics_;
   if (bound_graphics_.get()) {
     if (GetBoundGraphics2D()) {
       GetBoundGraphics2D()->BindToInstance(NULL);
     } else if (GetBoundGraphics3D()) {
       GetBoundGraphics3D()->BindToInstance(false);
     }
     bound_graphics_ = NULL;
@@ skipping 654 matching lines @@
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit