Windowless plugins: basic drawing works.

webkit/glue/plugins/webplugin_delegate_impl_gtk.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.
 
 // HACK: we need this #define in place before npapi.h is included for
 // plugins to work. However, all sorts of headers include npapi.h, so
 // the only way to be certain the define is in place is to put it
 // here.  You might ask, "Why not set it in npapi.h directly, or in
 // this directory's SConscript, then?"  but it turns out this define
 // makes npapi.h include Xlib.h, which in turn defines a ton of symbols
@@ skipping 90 matching lines @@
   if (!start_result)
     return false;
 
   windowless_ = instance_->windowless();
   if (windowless_) {
     // For windowless plugins we should set the containing window handle
     // as the instance window handle. This is what Safari does. Not having
     // a valid window handle causes subtle bugs with plugins which retreive
     // the window handle and validate the same. The window handle can be
     // retreived via NPN_GetValue of NPNVnetscapeWindow.
-    NOTIMPLEMENTED() << "windowless not implemented";
-    return false;
     // instance_->set_window_handle(parent_);
     // CreateDummyWindowForActivation();
     // handle_event_pump_messages_event_ = CreateEvent(NULL, TRUE, FALSE, NULL);
   } else {
     if (!WindowedCreatePlugin())
       return false;
   }
 
   plugin->SetWindow(windowed_handle_, /* unused event param */ NULL);
   plugin_url_ = url.spec();
@@ skipping 31 matching lines @@
     const gfx::Rect& clip_rect) {
   if (windowless_) {
     WindowlessUpdateGeometry(window_rect, clip_rect);
   } else {
     WindowedUpdateGeometry(window_rect, clip_rect);
   }
 }
 
 void WebPluginDelegateImpl::Paint(void* dc, const gfx::Rect& rect) {
   if (windowless_) {
-    // TODO(port): windowless painting.
-    // WindowlessPaint(dc, rect);
+    WindowlessPaint(dc, rect);
   }
 }
 
 void WebPluginDelegateImpl::Print(void* dc) {
   NOTIMPLEMENTED();
 }
 
 NPObject* WebPluginDelegateImpl::GetPluginScriptableObject() {
   return instance_->GetPluginScriptableObject();
 }
@@ skipping 228 matching lines @@
   NPError err = instance()->NPP_SetWindow(&window_);
   DCHECK(err == NPERR_NO_ERROR);
 }
 
 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};
-    win_pos.x = window_rect_.x();
-    win_pos.y = window_rect_.y();
-    win_pos.cx = window_rect_.width();
-    win_pos.cy = window_rect_.height();
-
-    NPEvent pos_changed_event;
-    pos_changed_event.event = WM_WINDOWPOSCHANGED;
-    pos_changed_event.wParam = 0;
-    pos_changed_event.lParam = PtrToUlong(&win_pos);
-
-    instance()->NPP_HandleEvent(&pos_changed_event);
   }
-  */
 }
 
-#if 0
-void WebPluginDelegateImpl::WindowlessPaint(HDC hdc,
+void WebPluginDelegateImpl::WindowlessPaint(void* context,
                                             const gfx::Rect& damage_rect) {
-  DCHECK(hdc);
+  // Compare to:
+  // http://mxr.mozilla.org/firefox/source/layout/generic/nsObjectFrame.cpp#4222
 
-  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();
+  DCHECK(context);
 
-  // We need to pass the HDC to the plugin via NPP_SetWindow in the
+  // We need to pass the DC to the plugin via NPP_SetWindow in the
   // first paint to ensure that it initiates rect invalidations.
-  if (window_.window == NULL)
+  // TODO(evanm): for now, it appears we always need to do this.
+  if (true)
     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);
+  XGraphicsExposeEvent event = {0};
+  event.type = GraphicsExpose;
+  event.display = GDK_DISPLAY();
+  event.drawable = (Drawable)context;
+  event.x = damage_rect.x();
+  event.y = damage_rect.y();
+  event.width = damage_rect.width();
+  event.height = damage_rect.height();
+
   static StatsRate plugin_paint("Plugin.Paint");
   StatsScope<StatsRate> scope(plugin_paint);
-  instance()->NPP_HandleEvent(&paint_event);
+  NPError err = instance()->NPP_HandleEvent(reinterpret_cast<XEvent*>(&event));
+  DCHECK(err == NPERR_NO_ERROR);
 }
-#endif
 
 void WebPluginDelegateImpl::WindowlessSetWindow(bool force_set_window) {
   if (!instance())
     return;
 
   if (window_rect_.IsEmpty())  // wait for geometry to be set.
     return;
 
   DCHECK(instance()->windowless());
+  // Mozilla docs say that this window param is not used for windowless
+  // plugins; rather, the window is passed during the GraphicsExpose event.
+  DCHECK(window_.window == 0);
 
   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;
 
+  NPSetWindowCallbackStruct* extra = new NPSetWindowCallbackStruct;
+  extra->display = GDK_DISPLAY();
+  GdkVisual* visual = gdk_visual_get_system();
+  extra->visual = GDK_VISUAL_XVISUAL(visual);
+  extra->depth = visual->depth;
+  // XXX we leak the colormap.
+  GdkColormap* colormap = gdk_colormap_new(gdk_visual_get_system(), FALSE);
+  extra->colormap = GDK_COLORMAP_XCOLORMAP(colormap);
+  window_.ws_info = extra;
+
+  if (!force_set_window)
+    windowless_needs_set_window_ = false;
+
   NPError err = instance()->NPP_SetWindow(&window_);
   DCHECK(err == NPERR_NO_ERROR);
 }
 
 void WebPluginDelegateImpl::SetFocus() {
   DCHECK(instance()->windowless());
 
   NOTIMPLEMENTED();
   /*  NPEvent focus_event;
   focus_event.event = WM_SETFOCUS;
@@ skipping 116 matching lines @@
 
 void WebPluginDelegateImpl::URLRequestRouted(const std::string&url,
                                              bool notify_needed,
                                              void* notify_data) {
   if (notify_needed) {
     instance()->SetURLLoadData(GURL(url.c_str()), notify_data);
   }
 }