Set up a interposing library for Carbon calls made by plugins.

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/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"
 
 using WebKit::WebCursorInfo;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebInputEvent;
@@ skipping 20 matching lines @@
 // this to keep the placeholder Carbon WindowRef's origin in sync with the
 // actual browser window, without having to pass that geometry over IPC.  If we
 // end up needing to interpose on Carbon APIs in the plugin process (in order
 // to simulate window activation, for example), this could be replaced by
 // interposing on GlobalToLocal and/or LocalToGlobal (see related TODO comments
 // below in WebPluginDelegateImpl::OnNullEvent()).
 
 int g_current_x_offset = 0;
 int g_current_y_offset = 0;
 
-WindowRef g_last_front_window = NULL;
-ProcessSerialNumber g_saved_front_process;
-
 }  // 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 20 matching lines @@
       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_));
 }
 
 WebPluginDelegateImpl::~WebPluginDelegateImpl() {
+  FakePluginWindowTracker::SharedInstance()->RemoveFakeWindowForDelegate(
+      this, cg_context_.window);
   DestroyInstance();
-
-  if (cg_context_.window)
-    DisposeWindow(cg_context_.window);
 }
 
 void WebPluginDelegateImpl::PluginDestroyed() {
   delete this;
 }
 
 bool WebPluginDelegateImpl::Initialize(const GURL& url,
                                        char** argn,
                                        char** argv,
                                        int argc,
                                        WebPlugin* plugin,
                                        bool load_manually) {
   plugin_ = plugin;
 
   instance_->set_web_plugin(plugin);
   NPAPI::PluginInstance* old_instance =
       NPAPI::PluginInstance::SetInitializingInstance(instance_);
 
 
   bool start_result = instance_->Start(url, argn, argv, argc, load_manually);
 
   NPAPI::PluginInstance::SetInitializingInstance(old_instance);
 
   if (!start_result)
     return false;
 
-  cg_context_.window = NULL;
+  FakePluginWindowTracker* window_tracker =
+      FakePluginWindowTracker::SharedInstance();
+  cg_context_.window = window_tracker->GenerateFakeWindowForDelegate(this);
+  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(
           &WebPluginDelegateImpl::OnNullEvent),
       kPluginIdleThrottleDelayMs);
   return true;
 }
 
 void WebPluginDelegateImpl::DestroyInstance() {
   if (instance_ && (instance_->npp()->ndata != NULL)) {
     // Shutdown all streams before destroying so that
     // no streams are left "in progress".  Need to do
     // this before calling set_web_plugin(NULL) because the
     // instance uses the helper to do the download.
     instance_->CloseStreams();
     instance_->NPP_Destroy();
     instance_->set_web_plugin(NULL);
     instance_ = 0;
   }
 }
 
 void WebPluginDelegateImpl::UpdateGeometry(
     const gfx::Rect& window_rect,
     const gfx::Rect& clip_rect) {
-
   DCHECK(windowless_);
   WindowlessUpdateGeometry(window_rect, clip_rect);
 }
 
 void WebPluginDelegateImpl::Paint(CGContextRef context, const gfx::Rect& rect) {
   DCHECK(windowless_);
   WindowlessPaint(context, rect);
 }
 
 void WebPluginDelegateImpl::Print(CGContextRef context) {
@@ skipping 102 matching lines @@
   paint_event.where.v = 0;
   paint_event.modifiers = 0;
   instance()->NPP_HandleEvent(&paint_event);
 
   CGContextRestoreGState(context);
   [NSGraphicsContext restoreGraphicsState];
 }
 
 // Moves our dummy window to the given offset relative to the last known
 // location of the real renderer window's content view.
-static void UpdateDummyWindowLocationWithOffset(WindowRef window,
-                                                int x_offset, int y_offset) {
+// 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) {
   int target_x = g_current_x_offset + x_offset;
   int target_y = g_current_y_offset + y_offset;
   Rect window_bounds;
   GetWindowBounds(window, kWindowContentRgn, &window_bounds);
   if ((window_bounds.left != target_x) ||
       (window_bounds.top != target_y)) {
-    int height = window_bounds.bottom - window_bounds.top;
-    int width = window_bounds.right - window_bounds.left;
+    int height = new_height ? new_height
+                            : window_bounds.bottom - window_bounds.top;
+    int width = new_width ? new_width
+                          : window_bounds.right - window_bounds.left;
     window_bounds.left = target_x;
     window_bounds.top = target_y;
     window_bounds.right = window_bounds.left + width;
     window_bounds.bottom = window_bounds.top + height;
     SetWindowBounds(window, kWindowContentRgn, &window_bounds);
   }
 }
 
 void WebPluginDelegateImpl::WindowlessSetWindow(bool force_set_window) {
   if (!instance())
     return;
 
   if (window_rect_.IsEmpty())  // wait for geometry to be set.
     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;
 
-  if (!cg_context_.window) {
-    // For all plugins we create a placeholder offscreen window for the use
-    // of NPWindow.  NPAPI on the Mac requires a Carbon WindowRef for the
-    // "browser window", even if we're not using the Quickdraw drawing model.
-    // Not having a valid window reference causes subtle bugs with plugins
-    // which retreive the NPWindow and validate the same. The NPWindow
-    // can be retreived via NPN_GetValue of NPNVnetscapeWindow.
-    Rect window_bounds = { 0, 0, window_rect_.height(), window_rect_.width() };
-    WindowRef window_ref;
-    if (CreateNewWindow(kDocumentWindowClass,
-                        kWindowStandardDocumentAttributes,
-                        &window_bounds,
-                        &window_ref) == noErr) {
-      cg_context_.window = window_ref;
-      SelectWindow(window_ref);
-      g_last_front_window = window_ref;
-    }
-  }
-  UpdateDummyWindowLocationWithOffset(cg_context_.window, window_rect_.x(),
-                                      window_rect_.y());
+  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;
@@ skipping 121 matching lines @@
   return false;
 }
 
 static void UpdateWindowLocation(WindowRef window, const WebMouseEvent& event) {
   // TODO: figure out where the vertical offset of 22 comes from (and if 22 is
   // exactly right) and replace with an appropriate calculation. It feels like
   // 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;
 
-  UpdateDummyWindowLocationWithOffset(window, event.windowX - event.x,
-                                      event.windowY - event.y);
+  UpdateDummyWindowBoundsWithOffset(window, event.windowX - event.x,
+                                    event.windowY - event.y, 0, 0);
 }
 
 bool WebPluginDelegateImpl::HandleInputEvent(const WebInputEvent& event,
                                              WebCursorInfo* cursor) {
   DCHECK(windowless_) << "events should only be received in windowless mode";
   DCHECK(cursor != NULL);
 
   NPEvent np_event = {0};
   if (!NPEventFromWebInputEvent(event, &np_event)) {
     return false;
@@ skipping 55 matching lines @@
   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);
 
-  WindowRef front_window = FrontWindow();
-  if (front_window == cg_context_.window) {
-    if (front_window != g_last_front_window) {
-      // If our dummy window is now the front window, but was not previously,
-      // it means that a plugin window has been destroyed. Make sure our fake
-      // browser window is selected.
-      // TODO: Use DYLD_INSERT_LIBRARIES to interpose on Carbon window
-      // APIs within the plugin process.  This will allow us to (a) get rid of
-      // the dummy window, and (b) explicitly track the creation and
-      // destruction of windows by the plugin.
-      g_last_front_window = front_window;
-      SelectWindow(cg_context_.window);
-
-      // If the plugin process is still the front process, bring the prior
-      // front process (normally this will be the browser process) back to
-      // the front.
-      // TODO: make this an IPC message so that the browser can properly
-      // reactivate the window.
-      ProcessSerialNumber this_process, front_process;
-      GetCurrentProcess(&this_process);
-      GetFrontProcess(&front_process);
-      Boolean matched = false;
-      SameProcess(&this_process, &front_process, &matched);
-      if (matched)
-        SetFrontProcess(&g_saved_front_process);
-      g_last_front_window = FrontWindow();
-    }
-  } else if (front_window != g_last_front_window) {
-    // The plugin has just created a new window and brought it to the front.
-    // bring the plugin process to the front so that the user can see it (for
-    // example, an alert or file selection dialog).
-    // TODO: make this an IPC to order the plugin process above the browser
-    // process but not necessarily the frontmost.
-    ProcessSerialNumber this_process;
-    GetCurrentProcess(&this_process);
-    GetFrontProcess(&g_saved_front_process);
-    SetFrontProcess(&this_process);
-    g_last_front_window = front_window;
-    SelectWindow(front_window);
-  }
-
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       null_event_factory_.NewRunnableMethod(
           &WebPluginDelegateImpl::OnNullEvent),
       kPluginIdleThrottleDelayMs);
 }