Re-land http://codereview.chromium.org/211031 with a bug opened...

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>
 
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/stats_counters.h"
 #include "base/string_util.h"
 #include "webkit/api/public/WebInputEvent.h"
 #include "webkit/default_plugin/plugin_impl.h"
 #include "webkit/glue/glue_util.h"
 #include "webkit/glue/webplugin.h"
 #include "webkit/glue/plugins/fake_plugin_window_tracker_mac.h"
 #include "webkit/glue/plugins/plugin_constants_win.h"
 #include "webkit/glue/plugins/plugin_instance.h"
 #include "webkit/glue/plugins/plugin_lib.h"
 #include "webkit/glue/plugins/plugin_list.h"
 #include "webkit/glue/plugins/plugin_stream_url.h"
 #include "webkit/glue/webkit_glue.h"
 
+// If we're compiling support for the QuickDraw drawing model, turn off GCC
+// warnings about deprecated functions (since QuickDraw is a deprecated API).
+// According to the GCC documentation, this can only be done per file, not
+// pushed and popped like some options can be.
+#ifndef NP_NO_QUICKDRAW
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 using webkit_glue::WebPlugin;
 using webkit_glue::WebPluginDelegate;
 using webkit_glue::WebPluginResourceClient;
 using WebKit::WebCursorInfo;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebInputEvent;
 using WebKit::WebMouseEvent;
 
 // Important implementation notes: The Mac definition of NPAPI, particularly
 // the distinction between windowed and windowless modes, differs from the
@@ skipping 45 matching lines @@
 
 WebPluginDelegateImpl::WebPluginDelegateImpl(
     gfx::PluginWindowHandle containing_view,
     NPAPI::PluginInstance *instance)
     : windowless_needs_set_window_(true),
       // all Mac plugins are "windowless" in the Windows/X11 sense
       windowless_(true),
       plugin_(NULL),
       instance_(instance),
       parent_(containing_view),
+      qd_world_(0),
       quirks_(0),
       handle_event_depth_(0),
       user_gesture_message_posted_(this),
       user_gesture_msg_factory_(this),
       null_event_factory_(this),
       last_mouse_x_(0),
       last_mouse_y_(0) {
   memset(&window_, 0, sizeof(window_));
+#ifndef NP_NO_QUICKDRAW
+  memset(&qd_port_, 0, sizeof(qd_port_));
+#endif
 }
 
 WebPluginDelegateImpl::~WebPluginDelegateImpl() {
+#ifndef NP_NO_QUICKDRAW
+  if (qd_port_.port) {
+    DisposeGWorld(qd_port_.port);
+    DisposeGWorld(qd_world_);
+  }
+#endif
   FakePluginWindowTracker::SharedInstance()->RemoveFakeWindowForDelegate(
       this, reinterpret_cast<WindowRef>(cg_context_.window));
   DestroyInstance();
 }
 
 void WebPluginDelegateImpl::PluginDestroyed() {
   delete this;
 }
 
 bool WebPluginDelegateImpl::Initialize(const GURL& url,
@@ skipping 23 matching lines @@
   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(reinterpret_cast<WindowRef>(cg_context_.window),
                   kWindowContentRgn, &window_bounds);
-  window_.window = &cg_context_;
-  window_.type = NPWindowTypeWindow;
+
+  switch (instance_->drawing_model()) {
+#ifndef NP_NO_QUICKDRAW
+    case NPDrawingModelQuickDraw:
+      window_.window = &qd_port_;
+      window_.type = NPWindowTypeDrawable;
+      break;
+#endif
+    case NPDrawingModelCoreGraphics:
+      window_.window = &cg_context_;
+      window_.type = NPWindowTypeDrawable;
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
 
   plugin->SetWindow(NULL);
   plugin_url_ = url.spec();
 
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       null_event_factory_.NewRunnableMethod(
           &WebPluginDelegateImpl::OnNullEvent),
       kPluginIdleThrottleDelayMs);
   return true;
 }
@@ skipping 26 matching lines @@
   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;
+#ifndef NP_NO_QUICKDRAW
+    if (instance()->drawing_model() == NPDrawingModelQuickDraw) {
+      if (qd_port_.port) {
+        DisposeGWorld(qd_port_.port);
+        DisposeGWorld(qd_world_);
+        qd_port_.port = NULL;
+        qd_world_ = NULL;
+      }
+      Rect window_bounds = {
+        0, 0, window_rect_.height(), window_rect_.width()
+      };
+      // Create a GWorld pointing at the same bits as our CGContextRef
+      NewGWorldFromPtr(&qd_world_, k32BGRAPixelFormat, &window_bounds,
+          NULL, NULL, 0,
+          static_cast<Ptr>(CGBitmapContextGetData(context)),
+          static_cast<SInt32>(CGBitmapContextGetBytesPerRow(context)));
+      // Create a GWorld for the plugin to paint into whenever it wants
+      NewGWorld(&qd_port_.port, k32ARGBPixelFormat, &window_bounds,
+          NULL, NULL, kNativeEndianPixMap);
+      SetGWorld(qd_port_.port, NULL);
+      // Fill with black
+      ForeColor(blackColor);
+      BackColor(whiteColor);
+      PaintRect(&window_bounds);
+    }
+#endif
     WindowlessSetWindow(true);
   }
 }
 
 void WebPluginDelegateImpl::Paint(CGContextRef context, const gfx::Rect& rect) {
   DCHECK(windowless_);
   WindowlessPaint(context, rect);
 }
 
 void WebPluginDelegateImpl::Print(CGContextRef context) {
@@ skipping 73 matching lines @@
 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);
+  switch (instance()->drawing_model()) {
+#ifndef NP_NO_QUICKDRAW
+    case NPDrawingModelQuickDraw:
+    {
+      // Plugins using the QuickDraw drawing model do not restrict their
+      // drawing to update events the way that CoreGraphics-based plugins
+      // do.  When we are asked to paint, we therefore just copy from the
+      // plugin's persistent offscreen GWorld into our shared memory bitmap
+      // context.
+      Rect window_bounds = {
+        0, 0, window_rect_.height(), window_rect_.width()
+      };
+      PixMapHandle plugin_pixmap = GetGWorldPixMap(qd_port_.port);
+      if (LockPixels(plugin_pixmap)) {
+        PixMapHandle shared_pixmap = GetGWorldPixMap(qd_world_);
+        if (LockPixels(shared_pixmap)) {
+          SetGWorld(qd_world_, NULL);
+          // Set foreground and background colors to avoid "colorizing" the
+          // image.
+          ForeColor(blackColor);
+          BackColor(whiteColor);
+          CopyBits(reinterpret_cast<BitMap*>(*plugin_pixmap),
+                   reinterpret_cast<BitMap*>(*shared_pixmap),
+                   &window_bounds, &window_bounds, srcCopy, NULL);
+          UnlockPixels(shared_pixmap);
+        }
+        UnlockPixels(plugin_pixmap);
+      }
+      break;
+    }
+#endif
+    case NPDrawingModelCoreGraphics:
+    {
+      NPEvent paint_event;
 
-  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);
+      // Save and restore the NSGraphicsContext state in case the plugin uses
+      // Cocoa drawing.
+      [NSGraphicsContext saveGraphicsState];
+      [NSGraphicsContext setCurrentContext:
+           [NSGraphicsContext graphicsContextWithGraphicsPort:context
+                                                      flipped:YES]];
+      CGContextSaveGState(context);
 
-  CGContextRestoreGState(context);
-  [NSGraphicsContext restoreGraphicsState];
+      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);
+      [NSGraphicsContext restoreGraphicsState];
+      break;
+    }
+  }
 }
 
 // Moves our dummy window to the given offset relative to the last known
 // location of the real renderer window's content view.
 // If new_width or new_height is non-zero, the window size (content region)
 // will be updated accordingly; if they are zero, the existing size will be
 // preserved.
 static void UpdateDummyWindowBoundsWithOffset(WindowRef window,
                                               int x_offset, int y_offset,
                                               int new_width, int new_height) {
@@ skipping 29 matching lines @@
   window_.height = window_rect_.height();
   window_.width = window_rect_.width();
   window_.x = 0;
   window_.y = 0;
 
   UpdateDummyWindowBoundsWithOffset(
       reinterpret_cast<WindowRef>(cg_context_.window), window_rect_.x(),
       window_rect_.y(), window_rect_.width(), window_rect_.height());
 
   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 133 matching lines @@
 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)) {
+    LOG(WARNING) << "NPEventFromWebInputEvent failed";
     return false;
   }
   np_event.when = TickCount();
   if (np_event.what == nullEvent) {
     last_mouse_x_ = np_event.where.h;
     last_mouse_y_ = np_event.where.v;
     return true;  // Let the recurring task actually send the event.
   }
 
   // If this is a mouse event, we need to make sure our dummy window has the
   // correct location before we send the event to the plugin, so that any
   // coordinate conversion the plugin does will work out.
   if (WebInputEventIsWebMouseEvent(event)) {
     const WebMouseEvent* mouse_event =
         static_cast<const WebMouseEvent*>(&event);
     UpdateWindowLocation(reinterpret_cast<WindowRef>(cg_context_.window),
                          *mouse_event);
   }
-  CGContextSaveGState(cg_context_.context);
-  bool ret = instance()->NPP_HandleEvent(&np_event) != 0;
-  CGContextRestoreGState(cg_context_.context);
+  bool ret = false;
+  switch (instance()->drawing_model()) {
+#ifndef NP_NO_QUICKDRAW
+    case NPDrawingModelQuickDraw:
+      SetGWorld(qd_port_.port, NULL);
+      ret = instance()->NPP_HandleEvent(&np_event) != 0;
+      break;
+#endif
+    case NPDrawingModelCoreGraphics:
+      CGContextSaveGState(cg_context_.context);
+      ret = instance()->NPP_HandleEvent(&np_event) != 0;
+      CGContextRestoreGState(cg_context_.context);
+      break;
+  }
   return ret;
 }
 
 WebPluginResourceClient* WebPluginDelegateImpl::CreateResourceClient(
     int resource_id, const GURL& url, bool notify_needed,
     intptr_t notify_data, intptr_t existing_stream) {
   // Stream already exists. This typically happens for range requests
   // initiated via NPN_RequestRead.
   if (existing_stream) {
     NPAPI::PluginStream* plugin_stream =
         reinterpret_cast<NPAPI::PluginStream*>(existing_stream);
 
     plugin_stream->CancelRequest();
 
     return plugin_stream->AsResourceClient();
   }
 
   std::string mime_type;
   NPAPI::PluginStreamUrl *stream = instance()->CreateStream(
       resource_id, url, mime_type, notify_needed,
       reinterpret_cast<void*>(notify_data));
   return stream;
 }
 
 void WebPluginDelegateImpl::OnNullEvent() {
   if (!webkit_glue::IsPluginRunningInRendererProcess()) {
-    // If the plugin is running in a subprocess, drain any pending system
-    // events so that the plugin's event handlers will get called on any
-    // windows it has created.  Filter out activate/deactivate events on
-    // the fake browser window, but pass everything else through.
-    EventRecord event;
-    while (GetNextEvent(everyEvent, &event)) {
-      if (event.what == activateEvt && cg_context_.window &&
-          reinterpret_cast<void *>(event.message) != cg_context_.window)
-        continue;
-      instance()->NPP_HandleEvent(&event);
+    switch (instance_->event_model()) {
+      case NPEventModelCarbon:
+        // If the plugin is running in a subprocess, drain any pending system
+        // events so that the plugin's event handlers will get called on any
+        // windows it has created.  Filter out activate/deactivate events on
+        // the fake browser window, but pass everything else through.
+        EventRecord event;
+        while (GetNextEvent(everyEvent, &event)) {
+          if (event.what == activateEvt && cg_context_.window &&
+              reinterpret_cast<void *>(event.message) != cg_context_.window)
+            continue;
+          instance()->NPP_HandleEvent(&event);
+        }
+        break;
     }
   }
 
   // Send an idle event so that the plugin can do background work
   NPEvent np_event = {0};
   np_event.what = nullEvent;
   np_event.when = TickCount();
   np_event.modifiers = GetCurrentKeyModifiers();
   if (!Button())
     np_event.modifiers |= btnState;
   np_event.where.h = last_mouse_x_;
   np_event.where.v = last_mouse_y_;
   instance()->NPP_HandleEvent(&np_event);
 
+#ifndef NP_NO_QUICKDRAW
+  // Quickdraw-based plugins can draw at any time, so tell the renderer to
+  // repaint.
+  // TODO: only do this if the contents of the offscreen GWorld has changed,
+  // so as not to spam the renderer with an unchanging image.
+  if (instance_->drawing_model() == NPDrawingModelQuickDraw)
+    instance()->webplugin()->Invalidate();
+#endif
+
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       null_event_factory_.NewRunnableMethod(
           &WebPluginDelegateImpl::OnNullEvent),
       kPluginIdleThrottleDelayMs);
 }