Mac: Simulate the OS-level focus handling that windows and linux 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 <unistd.h>
 #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 "third_party/WebKit/WebKit/chromium/public/WebInputEvent.h"
 #include "webkit/default_plugin/plugin_impl.h"
@@ skipping 45 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;
 
+base::LazyInstance<std::set<WebPluginDelegateImpl*> > g_active_delegates(
+    base::LINKER_INITIALIZED);
+
 }  // namespace
 
 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),
       null_event_factory_(this),
       waiting_to_die_(false),
       last_mouse_x_(0),
       last_mouse_y_(0),
+      have_focus_(false),
       handle_event_depth_(0),
       user_gesture_message_posted_(this),
       user_gesture_msg_factory_(this) {
   memset(&window_, 0, sizeof(window_));
 #ifndef NP_NO_QUICKDRAW
   memset(&qd_port_, 0, sizeof(qd_port_));
 #endif
   instance->set_windowless(true);
 
   const WebPluginInfo& plugin_info = instance_->plugin_lib()->plugin_info();
   if (plugin_info.name.find(L"QuickTime") != std::wstring::npos) {
     // In some cases, QuickTime inexpicably negotiates the CoreGraphics drawing
     // model, but then proceeds as if it were using QuickDraw. Until we support
     // CoreAnimation, just ignore what QuickTime asks for.
     quirks_ |= PLUGIN_QUIRK_IGNORE_NEGOTIATED_DRAWING_MODEL;
   }
+  std::set<WebPluginDelegateImpl*>* delegates = g_active_delegates.Pointer();
+  delegates->insert(this);
 }
 
 WebPluginDelegateImpl::~WebPluginDelegateImpl() {
+  std::set<WebPluginDelegateImpl*>* delegates = g_active_delegates.Pointer();
+  delegates->erase(this);
 #ifndef NP_NO_QUICKDRAW
   if (qd_port_.port) {
     DisposeGWorld(qd_port_.port);
     DisposeGWorld(qd_world_);
   }
 #endif
 }
 
 void WebPluginDelegateImpl::PluginDestroyed() {
   FakePluginWindowTracker::SharedInstance()->RemoveFakeWindowForDelegate(
@@ skipping 274 matching lines @@
 
   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() {
+std::set<WebPluginDelegateImpl*> WebPluginDelegateImpl::GetActiveDelegates() {
+  std::set<WebPluginDelegateImpl*>* delegates = g_active_delegates.Pointer();
+  return *delegates;
+}
+
+void WebPluginDelegateImpl::FocusNotify(WebPluginDelegateImpl* delegate) {
+  if (waiting_to_die_)
+    return;
+
+  have_focus_ = (delegate == this);
+
   switch (instance()->event_model()) {
     case NPEventModelCarbon: {
       NPEvent focus_event = { 0 };
-      focus_event.what = NPEventType_GetFocusEvent;
+      if (have_focus_)
+        focus_event.what = NPEventType_GetFocusEvent;
+      else
+        focus_event.what = NPEventType_LoseFocusEvent;
       focus_event.when = TickCount();
       instance()->NPP_HandleEvent(&focus_event);
       break;
     }
     case NPEventModelCocoa: {
       NPCocoaEvent focus_event;
       memset(&focus_event, 0, sizeof(focus_event));
       focus_event.type = NPCocoaEventFocusChanged;
-      focus_event.data.focus.hasFocus = true;
+      focus_event.data.focus.hasFocus = have_focus_;
       instance()->NPP_HandleEvent(reinterpret_cast<NPEvent*>(&focus_event));
       break;
     }
   }
 }
 
+void WebPluginDelegateImpl::SetFocus() {
+  if (focus_notifier_)
+    focus_notifier_(this);
+  else
+    FocusNotify(this);
+}
+
 int WebPluginDelegateImpl::PluginDrawingModel() {
   if (quirks_ & PLUGIN_QUIRK_IGNORE_NEGOTIATED_DRAWING_MODEL)
     return NPDrawingModelQuickDraw;
   return instance()->drawing_model();
 }
 
 static bool WebInputEventIsWebMouseEvent(const WebInputEvent& event) {
   switch (event.type) {
     case WebInputEvent::MouseMove:
     case WebInputEvent::MouseLeave:
@@ skipping 257 matching lines @@
   } else {
     // 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);
     }
+    // if we do not currently have focus and this is a mouseDown, trigger a
+    // notification that we are taking the keyboard focus.  We can't just key
+    // off of incoming calls to SetFocus, since WebKit may already think we
+    // have it if we were the most recently focused element on our parent tab.
+    if (np_event.what == mouseDown && !have_focus_)
+      SetFocus();
   }
 #endif
 
   bool ret = false;
   switch (PluginDrawingModel()) {
 #ifndef NP_NO_QUICKDRAW
     case NPDrawingModelQuickDraw:
       SetGWorld(qd_port_.port, NULL);
       ret = instance()->NPP_HandleEvent(&np_event) != 0;
       break;
@@ skipping 76 matching lines @@
 
 #ifndef NP_NO_CARBON
   if (instance_->event_model() == NPEventModelCarbon) {
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
         null_event_factory_.NewRunnableMethod(
             &WebPluginDelegateImpl::OnNullEvent),
         kPluginIdleThrottleDelayMs);
   }
 #endif
 }