MacViews: Fix text input for password textfields.

ui/views/cocoa/bridged_content_view.mm

 // Copyright 2014 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 "ui/views/cocoa/bridged_content_view.h"
 
 #include "base/logging.h"
 #import "base/mac/mac_util.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
@@ skipping 52 matching lines @@
       : point;
 
   NSPoint point_in_window =
       ui::ConvertPointFromScreenToWindow(target_window, point_in_screen);
   NSRect content_rect =
       [target_window contentRectForFrameRect:[target_window frame]];
   return gfx::Point(point_in_window.x,
                     NSHeight(content_rect) - point_in_window.y);
 }
 
-// Checks if there's an active MenuController during key event dispatch. If
-// there is one, it gets preference, and it will likely swallow the event.
-bool DispatchEventToMenu(views::Widget* widget, ui::KeyEvent* event) {
-  MenuController* menuController = MenuController::GetActiveInstance();
-  if (menuController && menuController->owner() == widget) {
-    if (menuController->OnWillDispatchKeyEvent(event) == ui::POST_DISPATCH_NONE)
-      return true;
-  }
-  return false;
+// Dispatch |event| to |menu_controller| and return true if |event| is
+// swallowed.
+bool DispatchEventToMenu(MenuController* menu_controller, ui::KeyEvent* event) {
+  return menu_controller &&
+         menu_controller->OnWillDispatchKeyEvent(event) ==
+             ui::POST_DISPATCH_NONE;
 }
 
 // Returns true if |client| has RTL text.
 bool IsTextRTL(const ui::TextInputClient* client) {
   return client && client->GetTextDirection() == base::i18n::RIGHT_TO_LEFT;
 }
 
 // Returns the boundary rectangle for composition characters in the
 // |requested_range|. Sets |actual_range| corresponding to the returned
 // rectangle. For cases, where there is no composition text or the
@@ skipping 115 matching lines @@
   // send ui::EF_NONE as the key modifier to the KeyEvent constructor.
   // E.g. For Alt+S, [NSEvent characters] is 'ß' and not 'S'.
   return ui::KeyEvent([[event characters] characterAtIndex:0],
                       ui::KeyboardCodeFromNSEvent(event), ui::EF_NONE);
 }
 
 }  // namespace
 
 @interface BridgedContentView ()
 
+// Returns the active menu controller corresponding to |hostedView_|,
+// nil otherwise.
+- (MenuController*)activeMenuController;
+
 // Passes |event| to the InputMethod for dispatch.
 - (void)handleKeyEvent:(ui::KeyEvent*)event;
 
 // Handles an NSResponder Action Message by mapping it to a corresponding text
 // editing command from ui_strings.grd and, when not being sent to a
 // TextInputClient, the keyCode that toolkit-views expects internally.
 // For example, moveToLeftEndOfLine: would pass ui::VKEY_HOME in non-RTL locales
 // even though the Home key on Mac defaults to moveToBeginningOfDocument:.
 // This approach also allows action messages a user
 // may have remapped in ~/Library/KeyBindings/DefaultKeyBinding.dict to be
 // catered for.
 // Note: default key bindings in Mac can be read from StandardKeyBinding.dict
 // which lives in /System/Library/Frameworks/AppKit.framework/Resources. Do
 // `plutil -convert xml1 -o StandardKeyBinding.xml StandardKeyBinding.dict` to
 // get something readable.
 - (void)handleAction:(ui::TextEditCommand)command
              keyCode:(ui::KeyboardCode)keyCode
              domCode:(ui::DomCode)domCode
           eventFlags:(int)eventFlags;
 
 // Notification handler invoked when the Full Keyboard Access mode is changed.
 - (void)onFullKeyboardAccessModeChanged:(NSNotification*)notification;
 
+// Helper method which forwards |text| to the active menu or |textInputClient_|.
+- (void)insertTextInternal:(id)text;
+
 // Returns the native Widget's drag drop client. Possibly null.
 - (views::DragDropClientMac*)dragDropClient;
 
 // Menu action handlers.
 - (void)undo:(id)sender;
 - (void)redo:(id)sender;
 - (void)cut:(id)sender;
 - (void)copy:(id)sender;
 - (void)paste:(id)sender;
 - (void)selectAll:(id)sender;
@@ skipping 117 matching lines @@
     return;
 
   views::FocusManager* focusManager =
       hostedView_->GetWidget()->GetFocusManager();
   if (focusManager)
     focusManager->SetKeyboardAccessible([NSApp isFullKeyboardAccessEnabled]);
 }
 
 // BridgedContentView private implementation.
 
+- (MenuController*)activeMenuController {
+  MenuController* menuController = MenuController::GetActiveInstance();
+  return menuController && menuController->owner() == hostedView_->GetWidget()
+             ? menuController
+             : nullptr;
+}
+
 - (void)handleKeyEvent:(ui::KeyEvent*)event {
   if (!hostedView_)
     return;
 
   DCHECK(event);
-  if (DispatchEventToMenu(hostedView_->GetWidget(), event))
+  if (DispatchEventToMenu([self activeMenuController], event))
     return;
 
   hostedView_->GetWidget()->GetInputMethod()->DispatchKeyEvent(event);
 }
 
 - (void)handleAction:(ui::TextEditCommand)command
              keyCode:(ui::KeyboardCode)keyCode
              domCode:(ui::DomCode)domCode
           eventFlags:(int)eventFlags {
   if (!hostedView_)
     return;
 
   // Generate a synthetic event with the keycode toolkit-views expects.
   ui::KeyEvent event(ui::ET_KEY_PRESSED, keyCode, domCode, eventFlags);
 
-  if (DispatchEventToMenu(hostedView_->GetWidget(), &event))
+  if (DispatchEventToMenu([self activeMenuController], &event))
     return;
 
   // If there's an active TextInputClient, schedule the editing command to be
   // performed.
   if (textInputClient_ && textInputClient_->IsTextEditCommandEnabled(command))
     textInputClient_->SetTextEditCommandForNextKeyEvent(command);
 
   hostedView_->GetWidget()->GetInputMethod()->DispatchKeyEvent(&event);
 }
 
 - (void)onFullKeyboardAccessModeChanged:(NSNotification*)notification {
   DCHECK([[notification name]
       isEqualToString:kFullKeyboardAccessChangedNotification]);
   [self updateFullKeyboardAccess];
 }
 
+- (void)insertTextInternal:(id)text {
+  if (!hostedView_)
+    return;
+
+  if ([text isKindOfClass:[NSAttributedString class]])
+    text = [text string];
+
+  bool isCharacterEvent = keyDownEvent_ && [text length] == 1;
+
+  // Forward the |text| to |textInputClient_| if no menu is active.
+  if (textInputClient_ && ![self activeMenuController]) {
+    // If a single character is inserted by keyDown's call to
+    // interpretKeyEvents: then use InsertChar() to allow editing events to be
+    // merged.
+    if (isCharacterEvent)
+      textInputClient_->InsertChar(GetCharacterEventFromNSEvent(keyDownEvent_));
+    else
+      textInputClient_->InsertText(base::SysNSStringToUTF16(text));
+    return;
+  }
+
+  // Only handle the case where no. of characters is 1. Cases not handled (not
+  // an exhaustive list):
+  // - |text| contains a unicode surrogate pair, i.e. a single grapheme which
+  //   requires two 16 bit characters. Currently Views menu only supports
+  //   mnemonics using a single 16 bit character, so it is ok to ignore this
+  //   case.
+  // - Programmatically created events.
+  // - Input from IME. But this case should not occur since inputContext is
+  //   nil.
+  if (isCharacterEvent) {
+    ui::KeyEvent charEvent = GetCharacterEventFromNSEvent(keyDownEvent_);
+    [self handleKeyEvent:&charEvent];
+  }
+}
+
 - (views::DragDropClientMac*)dragDropClient {
   views::BridgedNativeWidget* bridge =
       views::NativeWidgetMac::GetBridgeForNativeWindow([self window]);
   return bridge ? bridge->drag_drop_client() : nullptr;
 }
 
 - (void)undo:(id)sender {
   // This DCHECK is more strict than a similar check in handleAction:. It can be
   // done here because the actors sending these actions should be calling
   // validateUserInterfaceItem: before enabling UI that allows these messages to
@@ skipping 202 matching lines @@
 
 - (NSTextInputContext*)inputContext {
   // If the textInputClient_ does not exist, return nil since this view does not
   // conform to NSTextInputClient protocol.
   if (!textInputClient_)
     return nil;
 
   // If a menu is active, and -[NSView interpretKeyEvents:] asks for the
   // input context, return nil. This ensures the action message is sent to
   // the view, rather than any NSTextInputClient a subview has installed.
-  MenuController* menuController = MenuController::GetActiveInstance();
-  if (menuController && menuController->owner() == hostedView_->GetWidget())
+  if ([self activeMenuController])
     return nil;
 
   // When not in an editable mode, or while entering passwords
   // (http://crbug.com/23219), we don't want to show IME candidate windows.
   // Returning nil prevents this view from getting messages defined as part of
   // the NSTextInputClient protocol.
   switch (textInputClient_->GetTextInputType()) {
     case ui::TEXT_INPUT_TYPE_NONE:
     case ui::TEXT_INPUT_TYPE_PASSWORD:
       return nil;
@@ skipping 34 matching lines @@
 // views::Textfields are single-line only, map Paragraph and Document commands
 // to Line. Also, Up/Down commands correspond to beginning/end of line.
 
 // The insertText action message forwards to the TextInputClient unless a menu
 // is active. Note that NSResponder's interpretKeyEvents: implementation doesn't
 // direct insertText: through doCommandBySelector:, so this is still needed to
 // handle the case when inputContext: is nil. When inputContext: returns non-nil
 // text goes directly to insertText:replacementRange:.
 - (void)insertText:(id)text {
   DCHECK_EQ(nil, [self inputContext]);
-
-  // Only handle the case where no. of characters is 1. Cases not handled (not
-  // an exhaustive list):
-  // - |text| contains a unicode surrogate pair, i.e. a single grapheme which
-  //   requires two 16 bit characters. Currently Views menu only supports
-  //   mnemonics using a single 16 bit character, so it is ok to ignore this
-  //   case.
-  // - Programmatically created events.
-  // - Input from IME. But this case should not occur since inputContext is nil.
-  if (keyDownEvent_ && [text length] == 1) {
-    ui::KeyEvent charEvent = GetCharacterEventFromNSEvent(keyDownEvent_);
-    [self handleKeyEvent:&charEvent];
-  }
+  [self insertTextInternal:text];
 }
 
 // Selection movement and scrolling.
 
 - (void)moveForward:(id)sender {
   IsTextRTL(textInputClient_) ? [self moveLeft:sender]
                               : [self moveRight:sender];
 }
 
 - (void)moveRight:(id)sender {
@@ skipping 413 matching lines @@
 }
 
 - (BOOL)hasMarkedText {
   return textInputClient_ && textInputClient_->HasCompositionText();
 }
 
 - (void)insertText:(id)text replacementRange:(NSRange)replacementRange {
   if (!hostedView_)
     return;
 
-  if ([text isKindOfClass:[NSAttributedString class]])
-    text = [text string];
-
   // Verify inputContext is not nil, i.e. |textInputClient_| is valid and no
   // menu is active.
   DCHECK([self inputContext]);
 
   textInputClient_->DeleteRange(gfx::Range(replacementRange));
-
-  // If a single character is inserted by keyDown's call to interpretKeyEvents:
-  // then use InsertChar() to allow editing events to be merged.
-  if (keyDownEvent_ && [text length] == 1)
-    textInputClient_->InsertChar(GetCharacterEventFromNSEvent(keyDownEvent_));
-  else
-    textInputClient_->InsertText(base::SysNSStringToUTF16(text));
+  [self insertTextInternal:text];
 }
 
 - (NSRange)markedRange {
   if (!textInputClient_)
     return NSMakeRange(NSNotFound, 0);
 
   gfx::Range range;
   textInputClient_->GetCompositionTextRange(&range);
   return range.ToNSRange();
 }
@@ skipping 82 matching lines @@
   }
 
   return [super accessibilityAttributeValue:attribute];
 }
 
 - (id)accessibilityHitTest:(NSPoint)point {
   return [hostedView_->GetNativeViewAccessible() accessibilityHitTest:point];
 }
 
 @end