Don't call NPP_SetWindow during the painting of windowless plugins....

webkit/glue/plugins/webplugin_delegate_impl.cc

 // 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.
 
 #include "webkit/glue/plugins/webplugin_delegate_impl.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 49 matching lines @@
 base::LazyInstance<std::list<MSG> > g_throttle_queue(base::LINKER_INITIALIZED);
 
 // Helper object for patching the TrackPopupMenu API.
 base::LazyInstance<iat_patch::IATPatchFunction> g_iat_patch_track_popup_menu(
     base::LINKER_INITIALIZED);
 
 // Helper object for patching the SetCursor API.
 base::LazyInstance<iat_patch::IATPatchFunction> g_iat_patch_set_cursor(
     base::LINKER_INITIALIZED);
 
+// http://crbug.com/16114
+// Enforces providing a valid device context in NPWindow, so that NPP_SetWindow
+// is never called with NPNWindoTypeDrawable and NPWindow set to NULL.
+// Doing so allows removing NPP_SetWindow call during painting a windowless
+// plugin, which otherwise could trigger layout change while painting by
+// invoking NPN_Evaluate. Which would cause bad, bad crashes. Bad crashes.
+// TODO(dglazkov): If this approach doesn't produce regressions, move class to
+// webplugin_delegate_impl.h and implement for other platforms.
+class DrawableContextEnforcer {
+ public:
+  explicit DrawableContextEnforcer(NPWindow* window)
+      : window_(window),
+        disposable_dc_(window && !window->window) {
+    // If NPWindow is NULL, create a device context with monochrome 1x1 surface
+    // and stuff it to NPWindow.
+    if (disposable_dc_)
+      window_->window = CreateCompatibleDC(NULL);
+  }
+
+  ~DrawableContextEnforcer() {
+    if (!disposable_dc_)
+      return;
+
+    DeleteDC(static_cast<HDC>(window_->window));
+    window_->window = NULL;
+  }
+
+ private:
+  NPWindow* window_;
+  bool disposable_dc_;
+};
+
 }  // namespace
 
 WebPluginDelegate* WebPluginDelegate::Create(
     const FilePath& filename,
     const std::string& mime_type,
     gfx::PluginWindowHandle containing_view) {
   scoped_refptr<NPAPI::PluginLib> plugin =
       NPAPI::PluginLib::CreatePluginLib(filename);
   if (plugin.get() == NULL)
     return NULL;
@@ skipping 819 matching lines @@
   return result;
 }
 
 void WebPluginDelegateImpl::WindowlessUpdateGeometry(
     const gfx::Rect& window_rect,
     const gfx::Rect& clip_rect) {
   // Only resend to the instance if the geometry has changed.
   if (window_rect == window_rect_ && clip_rect == clip_rect_)
     return;
 
-  // Set this flag before entering the instance in case of side-effects.
-  windowless_needs_set_window_ = true;
-
   // We will inform the instance of this change when we call NPP_SetWindow.
   clip_rect_ = clip_rect;
   cutout_rects_.clear();
 
   if (window_rect_ != window_rect) {
     window_rect_ = window_rect;
 
     WindowlessSetWindow(true);
 
     WINDOWPOS win_pos = {0};
@@ skipping 14 matching lines @@
 void WebPluginDelegateImpl::WindowlessPaint(HDC hdc,
                                             const gfx::Rect& damage_rect) {
   DCHECK(hdc);
 
   RECT damage_rect_win;
   damage_rect_win.left   = damage_rect.x();  // + window_rect_.x();
   damage_rect_win.top    = damage_rect.y();  // + window_rect_.y();
   damage_rect_win.right  = damage_rect_win.left + damage_rect.width();
   damage_rect_win.bottom = damage_rect_win.top + damage_rect.height();
 
-  // We need to pass the HDC to the plugin via NPP_SetWindow in the
-  // first paint to ensure that it initiates rect invalidations.
-  if (window_.window == NULL)
-    windowless_needs_set_window_ = true;
-
   window_.window = hdc;
-  // TODO(darin): we should avoid calling NPP_SetWindow here since it may
-  // cause page layout to be invalidated.
-
-  // We really don't need to continually call SetWindow.
-  // m_needsSetWindow flags when the geometry has changed.
-  if (windowless_needs_set_window_)
-    WindowlessSetWindow(false);
 
   NPEvent paint_event;
   paint_event.event = WM_PAINT;
   // NOTE: NPAPI is not 64bit safe.  It puts pointers into 32bit values.
   paint_event.wParam = PtrToUlong(hdc);
   paint_event.lParam = PtrToUlong(&damage_rect_win);
   static StatsRate plugin_paint("Plugin.Paint");
   StatsScope<StatsRate> scope(plugin_paint);
   instance()->NPP_HandleEvent(&paint_event);
 }
 
 void WebPluginDelegateImpl::WindowlessSetWindow(bool force_set_window) {
   if (!instance())
     return;
 
   if (window_rect_.IsEmpty())  // wait for geometry to be set.
     return;
 
   DCHECK(instance()->windowless());
 
   window_.clipRect.top = clip_rect_.y();
   window_.clipRect.left = clip_rect_.x();
   window_.clipRect.bottom = clip_rect_.y() + clip_rect_.height();
   window_.clipRect.right = clip_rect_.x() + clip_rect_.width();
   window_.height = window_rect_.height();
   window_.width = window_rect_.width();
   window_.x = window_rect_.x();
   window_.y = window_rect_.y();
   window_.type = NPWindowTypeDrawable;
-
-  if (!force_set_window)
-    // Reset this flag before entering the instance in case of side-effects.
-    windowless_needs_set_window_ = false;
+  DrawableContextEnforcer enforcer(&window_);
 
   NPError err = instance()->NPP_SetWindow(&window_);
   DCHECK(err == NPERR_NO_ERROR);
 }
 
 void WebPluginDelegateImpl::SetFocus() {
   DCHECK(instance()->windowless());
 
   NPEvent focus_event;
   focus_event.event = WM_SETFOCUS;
@@ skipping 312 matching lines @@
 
   // It is ok to pass NULL here to GetCursor as we are not looking for cursor
   // types defined by Webkit.
   HCURSOR previous_cursor =
       g_current_plugin_instance->current_windowless_cursor_.GetCursor(NULL);
 
   g_current_plugin_instance->current_windowless_cursor_.InitFromExternalCursor(
       cursor);
   return previous_cursor;
 }