Update Mac plugin IME handling to match updated spec

chrome/browser/renderer_host/render_widget_host_view_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.
 
 #include <QuartzCore/QuartzCore.h>
 
 #include "chrome/browser/renderer_host/render_widget_host_view_mac.h"
 
 #include "app/app_switches.h"
 #include "app/surface/io_surface_support_mac.h"
@@ skipping 45 matching lines @@
   if (flags & NSAlternateKeyMask) modifiers |= WebInputEvent::AltKey;
   if (flags & NSCommandKeyMask) modifiers |= WebInputEvent::MetaKey;
   return modifiers;
 }
 
 @interface RenderWidgetHostViewCocoa (Private)
 + (BOOL)shouldAutohideCursorForEvent:(NSEvent*)event;
 - (id)initWithRenderWidgetHostViewMac:(RenderWidgetHostViewMac*)r;
 - (void)keyEvent:(NSEvent *)theEvent wasKeyEquivalent:(BOOL)equiv;
 - (void)cancelChildPopups;
+- (void)checkForPluginImeCancellation;
 @end
 
 // This API was published since 10.6. Provide the declaration so it can be
 // // called below when building with the 10.5 SDK.
 #if MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_5
 @class NSTextInputContext;
 @interface NSResponder (AppKitDetails)
 - (NSTextInputContext *)inputContext;
 @end
 #endif
 
 namespace {
 
 // Maximum number of characters we allow in a tooltip.
 const size_t kMaxTooltipLength = 1024;
 
 // TODO(suzhe): Upstream this function.
 WebKit::WebColor WebColorFromNSColor(NSColor *color) {
   CGFloat r, g, b, a;
   [color getRed:&r green:&g blue:&b alpha:&a];
 
   return
       std::max(0, std::min(static_cast<int>(lroundf(255.0f * a)), 255)) << 24 |
       std::max(0, std::min(static_cast<int>(lroundf(255.0f * r)), 255)) << 16 |
       std::max(0, std::min(static_cast<int>(lroundf(255.0f * g)), 255)) << 8  |
       std::max(0, std::min(static_cast<int>(lroundf(255.0f * b)), 255));
 }
 
-// Extract underline information from an attributed string.
-// Mostly copied from third_party/WebKit/Source/WebKit/mac/WebView/WebHTMLView.mm
+// Extract underline information from an attributed string. Mostly copied from
+// third_party/WebKit/Source/WebKit/mac/WebView/WebHTMLView.mm
 void ExtractUnderlines(
     NSAttributedString* string,
     std::vector<WebKit::WebCompositionUnderline>* underlines) {
   int length = [[string string] length];
   int i = 0;
   while (i < length) {
     NSRange range;
     NSDictionary* attrs = [string attributesAtIndex:i
                               longestEffectiveRange:&range
                                             inRange:NSMakeRange(i, length - i)];
@@ skipping 768 matching lines @@
 
 void RenderWidgetHostViewMac::KillSelf() {
   if (shutdown_factory_.empty()) {
     [cocoa_view_ setHidden:YES];
     MessageLoop::current()->PostTask(FROM_HERE,
         shutdown_factory_.NewRunnableMethod(
             &RenderWidgetHostViewMac::ShutdownHost));
   }
 }
 
-void RenderWidgetHostViewMac::SetPluginImeEnabled(bool enabled, int plugin_id) {
-  [cocoa_view_ setPluginImeEnabled:(enabled ? YES : NO) forPlugin:plugin_id];
+void RenderWidgetHostViewMac::PluginFocusChanged(bool focused, int plugin_id) {
+  [cocoa_view_ pluginFocusChanged:(focused ? YES : NO) forPlugin:plugin_id];
+}
+
+void RenderWidgetHostViewMac::StartPluginIme() {
+  [cocoa_view_ setPluginImeActive:YES];
 }
 
 bool RenderWidgetHostViewMac::PostProcessEventForPluginIme(
     const NativeWebKeyboardEvent& event) {
   // Check WebInputEvent type since multiple types of events can be sent into
   // WebKit for the same OS event (e.g., RawKeyDown and Char), so filtering is
   // necessary to avoid double processing.
   // Also check the native type, since NSFlagsChanged is considered a key event
   // for WebKit purposes, but isn't considered a key event by the OS.
   if (event.type == WebInputEvent::RawKeyDown &&
       [event.os_event type] == NSKeyDown)
     return [cocoa_view_ postProcessEventForPluginIme:event.os_event];
   return false;
 }
 
-void RenderWidgetHostViewMac::PluginImeCompositionConfirmed(
+void RenderWidgetHostViewMac::PluginImeCompositionCompleted(
     const string16& text, int plugin_id) {
   if (render_widget_host_) {
-    render_widget_host_->Send(new ViewMsg_PluginImeCompositionConfirmed(
+    render_widget_host_->Send(new ViewMsg_PluginImeCompositionCompleted(
         render_widget_host_->routing_id(), text, plugin_id));
   }
 }
 
 gfx::PluginWindowHandle
 RenderWidgetHostViewMac::AllocateFakePluginWindowHandle(bool opaque,
                                                         bool root) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // |render_widget_host_| is set to NULL when |RWHVMac::Destroy()| has
@@ skipping 336 matching lines @@
 
   NSRect bounds = [enclosing_window frame];
   return FlipNSRectToRectScreen(bounds);
 }
 
 void RenderWidgetHostViewMac::SetActive(bool active) {
   if (render_widget_host_)
     render_widget_host_->SetActive(active);
   if (HasFocus())
     SetTextInputActive(active);
+  if (!active)
+    [cocoa_view_ setPluginImeActive:NO];
 }
 
 void RenderWidgetHostViewMac::SetWindowVisibility(bool visible) {
   if (render_widget_host_) {
     render_widget_host_->Send(new ViewMsg_SetWindowVisibility(
         render_widget_host_->routing_id(), visible));
   }
 }
 
 void RenderWidgetHostViewMac::WindowFrameChanged() {
@@ skipping 53 matching lines @@
 - (id)initWithRenderWidgetHostViewMac:(RenderWidgetHostViewMac*)r {
   self = [super initWithFrame:NSZeroRect];
   if (self) {
     editCommand_helper_.reset(new RWHVMEditCommandHelper);
     editCommand_helper_->AddEditingSelectorsToClass([self class]);
 
     renderWidgetHostView_.reset(r);
     canBeKeyView_ = YES;
     takesFocusOnlyOnMouseDown_ = NO;
     closeOnDeactivate_ = NO;
-    pluginImeIdentifier_ = -1;
+    focusedPluginIdentifier_ = -1;
   }
   return self;
 }
 
 - (void)setCanBeKeyView:(BOOL)can {
   canBeKeyView_ = can;
 }
 
 - (void)setTakesFocusOnlyOnMouseDown:(BOOL)b {
   takesFocusOnlyOnMouseDown_ = b;
@@ skipping 135 matching lines @@
 
   // These variables might be set when handling the keyboard event.
   // Clear them here so that we can know whether they have changed afterwards.
   textToBeInserted_.clear();
   markedText_.clear();
   underlines_.clear();
   unmarkTextCalled_ = NO;
   hasEditCommands_ = NO;
   editCommands_.clear();
 
+  // Before doing anything with a key down, check to see if plugin IME has been
+  // cancelled, since the plugin host needs to be informed of that before
+  // receiving the keydown.
+  if ([theEvent type] == NSKeyDown)
+    [self checkForPluginImeCancellation];
+
   // Sends key down events to input method first, then we can decide what should
   // be done according to input method's feedback.
   // If a plugin is active, bypass this step since events are forwarded directly
   // to the plugin IME.
-  if (pluginImeIdentifier_ == -1)
+  if (focusedPluginIdentifier_ == -1)
     [self interpretKeyEvents:[NSArray arrayWithObject:theEvent]];
 
   handlingKeyDown_ = NO;
 
   // Indicates if we should send the key event and corresponding editor commands
   // after processing the input method result.
   BOOL delayEventUntilAfterImeCompostion = NO;
 
   // To emulate Windows, over-write |event.windowsKeyCode| to VK_PROCESSKEY
   // while an input method is composing or inserting a text.
@@ skipping 887 matching lines @@
 }
 
 - (NSInteger)conversationIdentifier {
   return reinterpret_cast<NSInteger>(self);
 }
 
 // Each RenderWidgetHostViewCocoa has its own input context, but we return
 // nil when the caret is in non-editable content or password box to avoid
 // making input methods do their work.
 - (NSTextInputContext *)inputContext {
-  if (pluginImeIdentifier_ != -1)
+  if (focusedPluginIdentifier_ != -1)
     return [[ComplexTextInputPanel sharedComplexTextInputPanel] inputContext];
 
   switch(renderWidgetHostView_->text_input_type_) {
     case WebKit::WebTextInputTypeNone:
     case WebKit::WebTextInputTypePassword:
       return nil;
     default:
       return [super inputContext];
   }
 }
@@ skipping 212 matching lines @@
 - (void)confirmComposition {
   if (!hasMarkedText_)
     return;
 
   if (renderWidgetHostView_->render_widget_host_)
     renderWidgetHostView_->render_widget_host_->ImeConfirmComposition();
 
   [self cancelComposition];
 }
 
-- (void)setPluginImeEnabled:(BOOL)enabled forPlugin:(int)pluginId {
-  if ((enabled && pluginId == pluginImeIdentifier_) ||
-      (!enabled && pluginId != pluginImeIdentifier_))
+- (void)setPluginImeActive:(BOOL)active {
+  if (active == pluginImeActive_)
     return;
 
-  // If IME was already active then either it is being cancelled, or the plugin
-  // changed; either way the current input needs to be cleared.
-  if (pluginImeIdentifier_ != -1)
-    [[ComplexTextInputPanel sharedComplexTextInputPanel] cancelInput];
+  pluginImeActive_ = active;
+  if (!active) {
+    [[ComplexTextInputPanel sharedComplexTextInputPanel] cancelComposition];
+    renderWidgetHostView_->PluginImeCompositionCompleted(
+        string16(), focusedPluginIdentifier_);
+  }
+}
 
-  pluginImeIdentifier_ = enabled ? pluginId : -1;
+- (void)pluginFocusChanged:(BOOL)focused forPlugin:(int)pluginId {
+  if (focused)
+    focusedPluginIdentifier_ = pluginId;
+  else if (focusedPluginIdentifier_ == pluginId)
+    focusedPluginIdentifier_ = -1;
+
+  // Whenever plugin focus changes, plugin IME resets.
+  [self setPluginImeActive:NO];
 }
 
 - (BOOL)postProcessEventForPluginIme:(NSEvent*)event {
-  if (pluginImeIdentifier_ == -1)
-    return false;
-
-  // ComplexTextInputPanel 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;
-  }
-  if (!sImeSupported)
+  if (!pluginImeActive_)
     return false;
 
   ComplexTextInputPanel* inputPanel =
       [ComplexTextInputPanel sharedComplexTextInputPanel];
   NSString* composited_string = nil;
   BOOL handled = [inputPanel interpretKeyEvent:event
                                         string:&composited_string];
   if (composited_string) {
-    renderWidgetHostView_->PluginImeCompositionConfirmed(
-        base::SysNSStringToUTF16(composited_string), pluginImeIdentifier_);
+    renderWidgetHostView_->PluginImeCompositionCompleted(
+        base::SysNSStringToUTF16(composited_string), focusedPluginIdentifier_);
+    pluginImeActive_ = NO;
   }
   return handled;
 }
 
+- (void)checkForPluginImeCancellation {
+  if (pluginImeActive_ &&
+      ![[ComplexTextInputPanel sharedComplexTextInputPanel] inComposition]) {
+    renderWidgetHostView_->PluginImeCompositionCompleted(
+        string16(), focusedPluginIdentifier_);
+    pluginImeActive_ = NO;
+  }
+}
+
 - (ViewID)viewID {
   return VIEW_ID_TAB_CONTAINER_FOCUS_VIEW;
 }
 
 // Overriding a NSResponder method to support application services.
 
 - (id)validRequestorForSendType:(NSString*)sendType
                      returnType:(NSString*)returnType {
   id requestor = nil;
   BOOL sendTypeIsString = [sendType isEqual:NSStringPboardType];
@@ skipping 39 matching lines @@
   if (!string) return NO;
 
   // If the user is currently using an IME, confirm the IME input,
   // and then insert the text from the service, the same as TextEdit and Safari.
   [self confirmComposition];
   [self insertText:string];
   return YES;
 }
 
 @end