Add an UpdateContext call to WebPluginDelegateImpl on the Mac.

webkit/glue/plugins/webplugin_delegate_impl_mac.mm

 // Copyright (c) 2006-2008 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.
 
 #import <Cocoa/Cocoa.h>
 
 #include "webkit/glue/plugins/webplugin_delegate_impl.h"
 
 #include <string>
 #include <vector>
@@ skipping 113 matching lines @@
   bool start_result = instance_->Start(url, argn, argv, argc, load_manually);
 
   NPAPI::PluginInstance::SetInitializingInstance(old_instance);
 
   if (!start_result)
     return false;
 
   FakePluginWindowTracker* window_tracker =
       FakePluginWindowTracker::SharedInstance();
   cg_context_.window = window_tracker->GenerateFakeWindowForDelegate(this);
+  cg_context_.context = NULL;
   Rect window_bounds = { 0, 0, window_rect_.height(), window_rect_.width() };
   SetWindowBounds(cg_context_.window, kWindowContentRgn, &window_bounds);
   window_.window = &cg_context_;
   window_.type = NPWindowTypeWindow;
 
   plugin->SetWindow(NULL);
   plugin_url_ = url.spec();
 
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       null_event_factory_.NewRunnableMethod(
@@ skipping 15 matching lines @@
   }
 }
 
 void WebPluginDelegateImpl::UpdateGeometry(
     const gfx::Rect& window_rect,
     const gfx::Rect& clip_rect) {
   DCHECK(windowless_);
   WindowlessUpdateGeometry(window_rect, clip_rect);
 }
 
+void WebPluginDelegateImpl::UpdateContext(CGContextRef context) {
+  // Flash on the Mac apparently caches the context from the struct it recieves
+  // in NPP_SetWindow, and continue to use it even when the contents of the
+  // struct have changed, so we need to call NPP_SetWindow again if the context
+  // changes.
+  if (context != cg_context_.context) {
+    cg_context_.context = context;
+    WindowlessSetWindow(true);
+  }
+}
+
 void WebPluginDelegateImpl::Paint(CGContextRef context, const gfx::Rect& rect) {
   DCHECK(windowless_);
   WindowlessPaint(context, rect);
 }
 
 void WebPluginDelegateImpl::Print(CGContextRef context) {
   // Disabling the call to NPP_Print as it causes a crash in
   // flash in some cases. In any case this does not work as expected
   // as the EMF meta file dc passed in needs to be created with the
   // the plugin window dc as its sibling dc and the window rect
@@ skipping 63 matching lines @@
 
   if (window_rect_ != window_rect) {
     window_rect_ = window_rect;
 
     WindowlessSetWindow(true);
   }
 }
 
 void WebPluginDelegateImpl::WindowlessPaint(gfx::NativeDrawingContext context,
                                             const gfx::Rect& damage_rect) {
+  // If we somehow get a paint before we've set up the plugin window, bail.
+  if (!cg_context_.context)
+    return;
+  DCHECK(cg_context_.context == context);
+
   static StatsRate plugin_paint("Plugin.Paint");
   StatsScope<StatsRate> scope(plugin_paint);
 
   // We save and restore the NSGraphicsContext state in case the plugin uses
   // Cocoa drawing.
   [NSGraphicsContext saveGraphicsState];
   [NSGraphicsContext setCurrentContext:[NSGraphicsContext
                                         graphicsContextWithGraphicsPort:context
                                         flipped:YES]];
   CGContextSaveGState(context);
 
-  cg_context_.context = context;
-  if (window_.window == NULL)
-    windowless_needs_set_window_ = true;
-
-  window_.window = &cg_context_;
-
-  if (windowless_needs_set_window_)
-    WindowlessSetWindow(false);
-
   NPEvent paint_event;
   paint_event.what = updateEvt;
   paint_event.message = reinterpret_cast<uint32>(cg_context_.window);
   paint_event.when = TickCount();
   paint_event.where.h = 0;
   paint_event.where.v = 0;
   paint_event.modifiers = 0;
   instance()->NPP_HandleEvent(&paint_event);
 
   CGContextRestoreGState(context);
@@ skipping 34 matching lines @@
     return;
 
   window_.clipRect.top = 0;
   window_.clipRect.left = 0;
   window_.clipRect.bottom = window_rect_.height();
   window_.clipRect.right = window_rect_.width();
   window_.height = window_rect_.height();
   window_.width = window_rect_.width();
   window_.x = 0;
   window_.y = 0;
-  window_.type = NPWindowTypeWindow;
-
-  if (!force_set_window)
-    // Reset this flag before entering the instance in case of side-effects.
-    windowless_needs_set_window_ = false;
 
   UpdateDummyWindowBoundsWithOffset(cg_context_.window, window_rect_.x(),
                                     window_rect_.y(), window_rect_.width(),
                                     window_rect_.height());
 
-  if (!force_set_window)
-    windowless_needs_set_window_ = false;
   NPError err = instance()->NPP_SetWindow(&window_);
   DCHECK(err == NPERR_NO_ERROR);
 }
 
 void WebPluginDelegateImpl::SetFocus() {
   NPEvent focus_event = { 0 };
   focus_event.what = NPEventType_GetFocusEvent;
   focus_event.when = TickCount();
   instance()->NPP_HandleEvent(&focus_event);
 }
@@ skipping 124 matching lines @@
   // window structure or the menu bar, but neither should be involved here.
   g_current_x_offset = event.globalX - event.windowX;
   g_current_y_offset = event.globalY - event.windowY + 22;
 
   UpdateDummyWindowBoundsWithOffset(window, event.windowX - event.x,
                                     event.windowY - event.y, 0, 0);
 }
 
 bool WebPluginDelegateImpl::HandleInputEvent(const WebInputEvent& event,
                                              WebCursorInfo* cursor) {
+  // If we somehow get an event before we've set up the plugin window, bail.
+  if (!cg_context_.context)
+    return false;
   DCHECK(windowless_) << "events should only be received in windowless mode";
   DCHECK(cursor != NULL);
 
   NPEvent np_event = {0};
   if (!NPEventFromWebInputEvent(event, &np_event)) {
     return false;
   }
   np_event.when = TickCount();
   if (np_event.what == nullEvent) {
     last_mouse_x_ = np_event.where.h;
@@ skipping 56 matching lines @@
     np_event.modifiers |= btnState;
   np_event.where.h = last_mouse_x_;
   np_event.where.v = last_mouse_y_;
   instance()->NPP_HandleEvent(&np_event);
 
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       null_event_factory_.NewRunnableMethod(
           &WebPluginDelegateImpl::OnNullEvent),
       kPluginIdleThrottleDelayMs);
 }