Update Mac plugin IME handling to match updated spec

webkit/plugins/npapi/webplugin_delegate_impl_mac.mm

 // Copyright (c) 2010 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>
 #import <QuartzCore/QuartzCore.h>
 
 #include "webkit/plugins/npapi/webplugin_delegate_impl.h"
 
 #include <string>
 #include <unistd.h>
 #include <set>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/metrics/stats_counters.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
+#include "base/sys_info.h"
 #include "base/sys_string_conversions.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/plugins/npapi/plugin_instance.h"
 #include "webkit/plugins/npapi/plugin_lib.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 #include "webkit/plugins/npapi/plugin_stream_url.h"
 #include "webkit/plugins/npapi/plugin_web_event_converter_mac.h"
 #include "webkit/plugins/npapi/webplugin.h"
 #include "webkit/plugins/npapi/webplugin_accelerated_surface_mac.h"
@@ skipping 229 matching lines @@
       quirks_(0),
       buffer_context_(NULL),
       layer_(nil),
       surface_(NULL),
       renderer_(nil),
       containing_window_has_focus_(false),
       initial_window_focus_(false),
       container_is_visible_(false),
       have_called_set_window_(false),
       ime_enabled_(false),
+      keyup_ignore_count_(0),
       external_drag_tracker_(new ExternalDragTracker()),
       handle_event_depth_(0),
       first_set_window_call_(true),
       plugin_has_focus_(false),
       has_webkit_focus_(false),
       containing_view_has_focus_(true),
       creation_succeeded_(false) {
   memset(&window_, 0, sizeof(window_));
 #ifndef NP_NO_CARBON
   memset(&np_cg_context_, 0, sizeof(np_cg_context_));
@@ skipping 219 matching lines @@
         content_origin.y() != content_area_origin_.y()) {
       DLOG(WARNING) << "Stale plugin content area location: "
                     << content_area_origin_ << " instead of "
                     << content_origin;
       SetContentAreaOrigin(content_origin);
     }
 
     current_windowless_cursor_.GetCursorInfo(cursor_info);
   }
 
+  // Per the Cocoa Plugin IME spec, plugins shoudn't receive keydown or keyup
+  // events while composition is in progress. Treat them as handled, however,
+  // since IME is consuming them on behalf of the plugin.
+  if ((event.type == WebInputEvent::KeyDown && ime_enabled_) ||
+      (event.type == WebInputEvent::KeyUp && keyup_ignore_count_)) {
+    // Composition ends on a keydown, so ime_enabled_ will be false at keyup;
+    // because the keydown wasn't sent to the plugin, the keyup shouldn't be
+    // either (per the spec).
+    if (event.type == WebInputEvent::KeyDown)
+      ++keyup_ignore_count_;
+    else
+      --keyup_ignore_count_;
+    return true;
+  }
+
 #ifndef NP_NO_CARBON
   if (instance()->event_model() == NPEventModelCarbon) {
 #ifndef NP_NO_QUICKDRAW
     if (instance()->drawing_model() == NPDrawingModelQuickDraw) {
       if (quirks_ & PLUGIN_QUIRK_ALLOW_FASTER_QUICKDRAW_PATH) {
         // Mouse event handling doesn't work correctly in the fast path mode,
         // so any time we get a mouse event turn the fast path off, but set a
         // time to switch it on again (we don't rely just on MouseLeave because
         // we don't want poor performance in the case of clicking the play
         // button and then leaving the mouse there).
@@ skipping 60 matching lines @@
 
   // Send the plugin the event.
   scoped_ptr<ScopedCurrentPluginEvent> event_scope(NULL);
   if (instance()->event_model() == NPEventModelCocoa) {
     event_scope.reset(new ScopedCurrentPluginEvent(
         instance(), static_cast<NPCocoaEvent*>(plugin_event)));
   }
   int16_t handle_response = instance()->NPP_HandleEvent(plugin_event);
   bool handled = handle_response != kNPEventNotHandled;
 
-  if (handled && event.type == WebInputEvent::KeyDown) {
-    // Update IME state as requested by the plugin.
-    SetImeEnabled(handle_response == kNPEventStartIME);
+  // Start IME if requested by the plugin.
+  if (handled && handle_response == kNPEventStartIME &&
+      event.type == WebInputEvent::KeyDown) {
+    StartIme();
+    ++keyup_ignore_count_;
   }
 
   // Plugins don't give accurate information about whether or not they handled
   // events, so browsers on the Mac ignore the return value.
   // Scroll events are the exception, since the Cocoa spec defines a meaning
   // for the return value.
   if (WebInputEvent::isMouseEventType(event.type)) {
     handled = true;
   } else if (WebInputEvent::isKeyboardEventType(event.type)) {
     // For Command-key events, trust the return value since eating all menu
@@ skipping 185 matching lines @@
   // states (WindowlessSetWindow will then send it on the first call).
   if (!have_called_set_window_) {
     initial_window_focus_ = has_focus;
     return;
   }
 
   if (has_focus == containing_window_has_focus_)
     return;
   containing_window_has_focus_ = has_focus;
 
-  if (!has_focus)
-    SetImeEnabled(false);
-
 #ifndef NP_NO_QUICKDRAW
   // Make sure controls repaint with the correct look.
   if (quirks_ & PLUGIN_QUIRK_ALLOW_FASTER_QUICKDRAW_PATH)
     SetQuickDrawFastPathEnabled(false);
 #endif
 
   ScopedActiveDelegate active_delegate(this);
   switch (instance()->event_model()) {
 #ifndef NP_NO_CARBON
     case NPEventModelCarbon: {
@@ skipping 16 matching lines @@
       instance()->NPP_HandleEvent(&focus_event);
       break;
     }
   }
 }
 
 bool WebPluginDelegateImpl::PlatformSetPluginHasFocus(bool focused) {
   if (!have_called_set_window_)
     return false;
 
-  if (!focused)
-    SetImeEnabled(false);
+  plugin_->FocusChanged(focused);
 
   ScopedActiveDelegate active_delegate(this);
 
   switch (instance()->event_model()) {
 #ifndef NP_NO_CARBON
     case NPEventModelCarbon: {
       NPEvent focus_event = { 0 };
       if (focused)
         focus_event.what = NPEventType_GetFocusEvent;
       else
@@ skipping 45 matching lines @@
   if (!clip_rect_.IsEmpty())
     instance()->webplugin()->InvalidateRect(gfx::Rect());
 }
 
 void WebPluginDelegateImpl::WindowFrameChanged(const gfx::Rect& window_frame,
                                                const gfx::Rect& view_frame) {
   instance()->set_window_frame(window_frame);
   SetContentAreaOrigin(gfx::Point(view_frame.x(), view_frame.y()));
 }
 
-void WebPluginDelegateImpl::ImeCompositionConfirmed(const string16& text) {
+void WebPluginDelegateImpl::ImeCompositionCompleted(const string16& text) {
   if (instance()->event_model() != NPEventModelCocoa) {
-    DLOG(ERROR) << "IME text receieved in Carbon event model";
+    DLOG(ERROR) << "IME notification receieved in Carbon event model";
     return;
   }
 
-  NPCocoaEvent text_event;
-  memset(&text_event, 0, sizeof(NPCocoaEvent));
-  text_event.type = NPCocoaEventTextInput;
-  text_event.data.text.text =
-      reinterpret_cast<NPNSString*>(base::SysUTF16ToNSString(text));
-  instance()->NPP_HandleEvent(&text_event);
+  ime_enabled_ = false;
+
+  // If |text| is empty this was just called to tell us composition was
+  // cancelled externally (e.g., the user pressed esc).
+  if (!text.empty()) {
+    NPCocoaEvent text_event;
+    memset(&text_event, 0, sizeof(NPCocoaEvent));
+    text_event.type = NPCocoaEventTextInput;
+    text_event.data.text.text =
+        reinterpret_cast<NPNSString*>(base::SysUTF16ToNSString(text));
+    instance()->NPP_HandleEvent(&text_event);
+  }
 }
 
 void WebPluginDelegateImpl::SetThemeCursor(ThemeCursor cursor) {
   current_windowless_cursor_.InitFromThemeCursor(cursor);
 }
 
 void WebPluginDelegateImpl::SetCursor(const Cursor* cursor) {
   current_windowless_cursor_.InitFromCursor(cursor);
 }
 
@@ skipping 40 matching lines @@
     if (plugin_visible && !redraw_timer_->IsRunning() && windowed_handle()) {
       redraw_timer_->Start(
           base::TimeDelta::FromMilliseconds(kCoreAnimationRedrawPeriodMs),
           this, &WebPluginDelegateImpl::DrawLayerInSurface);
     } else if (!plugin_visible) {
       redraw_timer_->Stop();
     }
   }
 }
 
-void WebPluginDelegateImpl::SetImeEnabled(bool enabled) {
-  if (instance()->event_model() != NPEventModelCocoa)
+void WebPluginDelegateImpl::StartIme() {
+  if (instance()->event_model() != NPEventModelCocoa ||
+      !IsImeSupported()) {
     return;
-  if (enabled == ime_enabled_)
+  }
+  if (ime_enabled_)
     return;
-  ime_enabled_ = enabled;
-  plugin_->SetImeEnabled(enabled);
+  ime_enabled_ = true;
+  plugin_->StartIme();
+}
+
+bool WebPluginDelegateImpl::IsImeSupported() {
+  // Currently the plugin IME implementation only works on 10.6.
+  static BOOL sImeSupported = NO;
+  static BOOL sHaveCheckedSupport = NO;
+  if (!sHaveCheckedSupport) {
+    int32 major, minor, bugfix;
+    base::SysInfo::OperatingSystemVersionNumbers(&major, &minor, &bugfix);
+    sImeSupported = major > 10 || (major == 10 && minor > 5);
+    sHaveCheckedSupport = YES;
+  }
+  return sImeSupported;
 }
 
 #pragma mark -
 #pragma mark Core Animation Support
 
 void WebPluginDelegateImpl::DrawLayerInSurface() {
   // If we haven't plumbed up the surface yet, don't try to draw.
   if (!windowed_handle() || !renderer_)
     return;
 
@@ skipping 149 matching lines @@
   qd_manager_->SetFastPathEnabled(enabled);
   qd_port_.port = qd_manager_->port();
   WindowlessSetWindow();
   // Send a paint event so that the new buffer gets updated immediately.
   WindowlessPaint(buffer_context_, clip_rect_);
 }
 #endif  // !NP_NO_QUICKDRAW
 
 }  // namespace npapi
 }  // namespace webkit