Fix the bug that closing a tab which owns a fullscreen Flash widget causes crash.

content/renderer/render_widget_fullscreen_pepper.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 "content/renderer/render_widget_fullscreen_pepper.h"
 
 #include "base/message_loop.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/gpu/gpu_channel_host.h"
 #include "content/renderer/pepper_platform_context_3d_impl.h"
@@ skipping 17 matching lines @@
 using WebKit::WebTextDirection;
 using WebKit::WebTextInputType;
 using WebKit::WebVector;
 using WebKit::WebWidget;
 
 namespace {
 
 // WebWidget that simply wraps the pepper plugin.
 class PepperWidget : public WebWidget {
  public:
-  PepperWidget(webkit::ppapi::PluginInstance* plugin,
-               RenderWidgetFullscreenPepper* widget)
-      : plugin_(plugin),
-        widget_(widget) {
+  explicit PepperWidget(RenderWidgetFullscreenPepper* widget)
+      : widget_(widget) {
   }
 
   virtual ~PepperWidget() {}
 
   // WebWidget API
   virtual void close() {
     delete this;
   }
 
   virtual WebSize size() {
     return size_;
   }
 
   virtual void willStartLiveResize() {
   }
 
   virtual void resize(const WebSize& size) {
+    if (!widget_->plugin())
+      return;
+
     size_ = size;
     WebRect plugin_rect(0, 0, size_.width, size_.height);
-    plugin_->ViewChanged(plugin_rect, plugin_rect);
+    widget_->plugin()->ViewChanged(plugin_rect, plugin_rect);
     widget_->Invalidate();
   }
 
   virtual void willEndLiveResize() {
   }
 
   virtual void animate(double frameBeginTime) {
   }
 
   virtual void layout() {
   }
 
   virtual void paint(WebCanvas* canvas, const WebRect& rect) {
+    if (!widget_->plugin())
+      return;
+
     WebRect plugin_rect(0, 0, size_.width, size_.height);
-    plugin_->Paint(canvas, plugin_rect, rect);
+    widget_->plugin()->Paint(canvas, plugin_rect, rect);
   }
 
   virtual void composite(bool finish) {
+    if (!widget_->plugin())
+      return;
+
     RendererGLContext* context = widget_->context();
     DCHECK(context);
     gpu::gles2::GLES2Implementation* gl = context->GetImplementation();
-    unsigned int texture = plugin_->GetBackingTextureId();
+    unsigned int texture = widget_->plugin()->GetBackingTextureId();
     gl->BindTexture(GL_TEXTURE_2D, texture);
     gl->DrawArrays(GL_TRIANGLES, 0, 3);
     widget_->SwapBuffers();
   }
 
   virtual void themeChanged() {
     NOTIMPLEMENTED();
   }
 
   virtual bool handleInputEvent(const WebInputEvent& event) {
+    if (!widget_->plugin())
+      return false;
+
     // This cursor info is ignored, we always set the cursor directly from
     // RenderWidgetFullscreenPepper::DidChangeCursor.
     WebCursorInfo cursor;
-    bool result = plugin_->HandleInputEvent(event, &cursor);
+    bool result = widget_->plugin()->HandleInputEvent(event, &cursor);
 
     // For normal web pages, WebViewImpl does input event translations and
     // generates context menu events. Since we don't have a WebView, we need to
     // do the necessary translation ourselves.
     if (WebInputEvent::isMouseEventType(event.type)) {
       const WebMouseEvent& mouse_event =
           reinterpret_cast<const WebMouseEvent&>(event);
       bool send_context_menu_event = false;
       // On Mac/Linux, we handle it on mouse down.
       // On Windows, we handle it on mouse up.
 #if defined(OS_WIN)
       send_context_menu_event =
           mouse_event.type == WebInputEvent::MouseUp &&
           mouse_event.button == WebMouseEvent::ButtonRight;
 #elif defined(OS_MACOSX)
       send_context_menu_event =
           mouse_event.type == WebInputEvent::MouseDown &&
           (mouse_event.button == WebMouseEvent::ButtonRight ||
            (mouse_event.button == WebMouseEvent::ButtonLeft &&
             mouse_event.modifiers & WebMouseEvent::ControlKey));
 #else
       send_context_menu_event =
           mouse_event.type == WebInputEvent::MouseDown &&
           mouse_event.button == WebMouseEvent::ButtonRight;
 #endif
       if (send_context_menu_event) {
         WebMouseEvent context_menu_event(mouse_event);
         context_menu_event.type = WebInputEvent::ContextMenu;
-        plugin_->HandleInputEvent(context_menu_event, &cursor);
+        widget_->plugin()->HandleInputEvent(context_menu_event, &cursor);
       }
     }
     return result;
   }
 
   virtual void mouseCaptureLost() {
     NOTIMPLEMENTED();
   }
 
   virtual void setFocus(bool focus) {
@@ skipping 34 matching lines @@
   }
 
   virtual bool caretOrSelectionRange(size_t* location, size_t* length) {
     return false;
   }
 
   virtual void setTextDirection(WebTextDirection) {
   }
 
   virtual bool isAcceleratedCompositingActive() const {
-    return widget_->context() && (plugin_->GetBackingTextureId() != 0);
+    return widget_->context() && widget_->plugin() &&
+        (widget_->plugin()->GetBackingTextureId() != 0);
   }
 
  private:
-  scoped_refptr<webkit::ppapi::PluginInstance> plugin_;
   RenderWidgetFullscreenPepper* widget_;
   WebSize size_;
 
   DISALLOW_COPY_AND_ASSIGN(PepperWidget);
 };
 
 void DestroyContext(RendererGLContext* context, GLuint program, GLuint buffer) {
   DCHECK(context);
   gpu::gles2::GLES2Implementation* gl = context->GetImplementation();
   if (program)
@@ skipping 118 matching lines @@
                                             const gfx::Rect& resizer_rect) {
   if (context_) {
     gpu::gles2::GLES2Implementation* gl = context_->GetImplementation();
     gl->ResizeCHROMIUM(size.width(), size.height());
     gl->Viewport(0, 0, size.width(), size.height());
   }
   RenderWidget::OnResize(size, resizer_rect);
 }
 
 WebWidget* RenderWidgetFullscreenPepper::CreateWebWidget() {
-  return new PepperWidget(plugin_, this);
+  return new PepperWidget(this);
 }
 
 bool RenderWidgetFullscreenPepper::SupportsAsynchronousSwapBuffers() {
   return context_ != NULL;
 }
 
 void RenderWidgetFullscreenPepper::CreateContext() {
   DCHECK(!context_);
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   GpuChannelHost* host = render_thread->EstablishGpuChannelSync(
@@ skipping 156 matching lines @@
   context_ = NULL;
   program_ = 0;
   buffer_ = 0;
   OnSwapBuffersAborted();
   CheckCompositing();
 }
 
 void RenderWidgetFullscreenPepper::OnSwapBuffersCompleteByRendererGLContext() {
   OnSwapBuffersComplete();
 }