MacViews: Convert Cocoa action messages into editing commands for text fields

ui/views/controls/textfield/textfield_unittest.cc

 // 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.
 
 #include "ui/views/controls/textfield/textfield.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/pickle.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/ui_base_switches_util.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
+#include "ui/events/test/event_generator.h"
 #include "ui/gfx/render_text.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/controls/textfield/textfield_controller.h"
 #include "ui/views/controls/textfield/textfield_model.h"
 #include "ui/views/controls/textfield/textfield_test_api.h"
 #include "ui/views/focus/focus_manager.h"
 #include "ui/views/ime/mock_input_method.h"
 #include "ui/views/test/test_views_delegate.h"
 #include "ui/views/test/views_test_base.h"
 #include "ui/views/test/widget_test.h"
@@ skipping 161 matching lines @@
 
   void InitTextfield() {
     InitTextfields(1);
   }
 
   void InitTextfields(int count) {
     ASSERT_FALSE(textfield_);
     textfield_ = new TestTextfield();
     textfield_->set_controller(this);
     widget_ = new Widget();
-    Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
+
+    // The widget type must be an activatable type, and we don't want to worry
+    // about the non-client view, which leaves just TYPE_WINDOW_FRAMELESS.
+    Widget::InitParams params =
+        CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
+
     params.bounds = gfx::Rect(100, 100, 100, 100);
     widget_->Init(params);
     View* container = new View();
     widget_->SetContentsView(container);
     container->AddChildView(textfield_);
     textfield_->SetBoundsRect(params.bounds);
     textfield_->set_id(1);
     test_api_.reset(new TextfieldTestApi(textfield_));
 
     for (int i = 1; i < count; i++) {
       Textfield* textfield = new Textfield();
       container->AddChildView(textfield);
       textfield->set_id(i + 1);
     }
 
     model_ = test_api_->model();
     model_->ClearEditHistory();
 
     input_method_ = new MockInputMethod();
     widget_->ReplaceInputMethod(input_method_);
 
-    // Activate the widget and focus the textfield for input handling.
-    widget_->Activate();
+    // Since the window type is activatable, showing the widget will also
+    // activate it. Calling Activate directly is insufficient, since that does
+    // not also _focus_ an aura::Window (i.e. using the FocusClient). Both the
+    // widget and the textfield must have focus to properly handle input.
+    widget_->Show();
     textfield_->RequestFocus();
 
     // On Mac, activation is asynchronous since desktop widgets are used. We
     // don't want parallel tests to steal active status either, so fake it.
 #if defined(OS_MACOSX) && !defined(USE_AURA)
     fake_activation_ = test::WidgetTest::FakeWidgetIsActiveAlways();
 #endif
+
+    event_generator_.reset(
+        new ui::test::EventGenerator(GetContext(), widget_->GetNativeWindow()));
   }
 
   ui::MenuModel* GetContextMenuModel() {
     test_api_->UpdateContextMenu();
     return test_api_->context_menu_contents();
   }
 
+  // True if native Mac keystrokes should be used (to avoid ifdef litter).
+  bool TestingNativeMac() {
+#if defined(OS_MACOSX)
+    return true;
+#else
+    return false;
+#endif
+  }
+
  protected:
   void SendKeyEvent(ui::KeyboardCode key_code,
                     bool alt,
                     bool shift,
-                    bool control,
+                    bool control_or_command,
                     bool caps_lock) {
-    int flags = (alt ? ui::EF_ALT_DOWN : 0) |
-                (shift ? ui::EF_SHIFT_DOWN : 0) |
+    bool control = control_or_command;
+    bool command = false;
+
+    // By default, swap control and command for native events on Mac. This
+    // handles most cases.
+    if (TestingNativeMac())
+      std::swap(control, command);
+
+    int flags = (alt ? ui::EF_ALT_DOWN : 0) | (shift ? ui::EF_SHIFT_DOWN : 0) |
                 (control ? ui::EF_CONTROL_DOWN : 0) |
+                (command ? ui::EF_COMMAND_DOWN : 0) |
                 (caps_lock ? ui::EF_CAPS_LOCK_DOWN : 0);
-    ui::KeyEvent event(ui::ET_KEY_PRESSED, key_code, flags);
-    input_method_->DispatchKeyEvent(event);
+
+    event_generator_->PressKey(key_code, flags);
   }
 
-  void SendKeyEvent(ui::KeyboardCode key_code, bool shift, bool control) {
-    SendKeyEvent(key_code, false, shift, control, false);
+  void SendKeyEvent(ui::KeyboardCode key_code,
+                    bool shift,
+                    bool control_or_command) {
+    SendKeyEvent(key_code, false, shift, control_or_command, false);
   }
 
   void SendKeyEvent(ui::KeyboardCode key_code) {
     SendKeyEvent(key_code, false, false);
   }
 
   void SendKeyEvent(base::char16 ch) {
     if (ch < 0x80) {
       ui::KeyboardCode code =
           ch == ' ' ? ui::VKEY_SPACE :
           static_cast<ui::KeyboardCode>(ui::VKEY_A + ch - 'a');
       SendKeyEvent(code);
     } else {
+      // For unicode characters, assume they come from IME rather than the
+      // keyboard. So they are dispatched directly to the input method.
       ui::KeyEvent event(ch, ui::VKEY_UNKNOWN, ui::EF_NONE);
       input_method_->DispatchKeyEvent(event);
     }
   }
 
+  // Sends a platform-specific move (and select) to start of line.
+  void SendHomeEvent(bool shift) {
+    if (TestingNativeMac()) {
+      // Use Cmd+Left on native Mac. An RTL-agnostic "end" doesn't have a
+      // default key-binding on Mac.
+      SendKeyEvent(ui::VKEY_LEFT, shift /* shift */, true /* command */);
+      return;
+    }
+    SendKeyEvent(ui::VKEY_HOME, shift /* shift */, false /* control */);
+  }
+
+  // Sends a platform-specific move (and select) to end of line.
+  void SendEndEvent(bool shift) {
+    if (TestingNativeMac()) {
+      SendKeyEvent(ui::VKEY_RIGHT, shift, true);  // Cmd+Right.
+      return;
+    }
+    SendKeyEvent(ui::VKEY_END, shift, false);
+  }
+
+  // Sends {delete, move, select} word {forward, backward}.
+  void SendWordEvent(ui::KeyboardCode key, bool shift) {
+    bool alt = false;
+    bool control = true;
+    bool caps = false;
+    if (TestingNativeMac()) {
+      // Use Alt+Left/Right/Backspace on native Mac.
+      alt = true;
+      control = false;
+    }
+    SendKeyEvent(key, alt, shift, control, caps);
+  }
+
   View* GetFocusedView() {
     return widget_->GetFocusManager()->GetFocusedView();
   }
 
   int GetCursorPositionX(int cursor_pos) {
     return test_api_->GetRenderText()->GetCursorBounds(
         gfx::SelectionModel(cursor_pos, gfx::CURSOR_FORWARD), false).x();
   }
 
   // Get the current cursor bounds.
@@ skipping 63 matching lines @@
 
   // Indicates how many times OnBeforeUserAction() is called.
   int on_before_user_action_;
 
   // Indicates how many times OnAfterUserAction() is called.
   int on_after_user_action_;
 
  private:
   ui::ClipboardType copied_to_clipboard_;
   scoped_ptr<test::WidgetTest::FakeActivation> fake_activation_;
+  scoped_ptr<ui::test::EventGenerator> event_generator_;
 
   DISALLOW_COPY_AND_ASSIGN(TextfieldTest);
 };
 
 TEST_F(TextfieldTest, ModelChangesTest) {
   InitTextfield();
 
   // TextfieldController::ContentsChanged() shouldn't be called when changing
   // text programmatically.
   last_contents_.clear();
@@ skipping 25 matching lines @@
   SendKeyEvent(ui::VKEY_1, false, false, false, false);
   SendKeyEvent(ui::VKEY_1, false, true,  false, true);
   SendKeyEvent(ui::VKEY_1, false, false, false, true);
   EXPECT_STR_EQ("TexT!1!1", textfield_->text());
 }
 
 TEST_F(TextfieldTest, ControlAndSelectTest) {
   // Insert a test string in a textfield.
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("one two three"));
-  SendKeyEvent(ui::VKEY_HOME,  false /* shift */, false /* control */);
+  SendHomeEvent(false);
   SendKeyEvent(ui::VKEY_RIGHT, true, false);
   SendKeyEvent(ui::VKEY_RIGHT, true, false);
   SendKeyEvent(ui::VKEY_RIGHT, true, false);
 
   EXPECT_STR_EQ("one", textfield_->GetSelectedText());
 
   // Test word select.
-  SendKeyEvent(ui::VKEY_RIGHT, true, true);
+  SendWordEvent(ui::VKEY_RIGHT, true);
   EXPECT_STR_EQ("one two", textfield_->GetSelectedText());
-  SendKeyEvent(ui::VKEY_RIGHT, true, true);
+  SendWordEvent(ui::VKEY_RIGHT, true);
   EXPECT_STR_EQ("one two three", textfield_->GetSelectedText());
-  SendKeyEvent(ui::VKEY_LEFT, true, true);
+  SendWordEvent(ui::VKEY_LEFT, true);
   EXPECT_STR_EQ("one two ", textfield_->GetSelectedText());
-  SendKeyEvent(ui::VKEY_LEFT, true, true);
+  SendWordEvent(ui::VKEY_LEFT, true);
   EXPECT_STR_EQ("one ", textfield_->GetSelectedText());
 
   // Replace the selected text.
   SendKeyEvent(ui::VKEY_Z, true, false);
   SendKeyEvent(ui::VKEY_E, true, false);
   SendKeyEvent(ui::VKEY_R, true, false);
   SendKeyEvent(ui::VKEY_O, true, false);
   SendKeyEvent(ui::VKEY_SPACE, false, false);
   EXPECT_STR_EQ("ZERO two three", textfield_->text());
 
-  SendKeyEvent(ui::VKEY_END, true, false);
+  SendEndEvent(true);
   EXPECT_STR_EQ("two three", textfield_->GetSelectedText());
-  SendKeyEvent(ui::VKEY_HOME, true, false);
+  SendHomeEvent(true);
   EXPECT_STR_EQ("ZERO ", textfield_->GetSelectedText());
 }
 
 TEST_F(TextfieldTest, InsertionDeletionTest) {
   // Insert a test string in a textfield.
   InitTextfield();
   for (size_t i = 0; i < 10; i++)
     SendKeyEvent(static_cast<ui::KeyboardCode>(ui::VKEY_A + i));
   EXPECT_STR_EQ("abcdefghij", textfield_->text());
 
   // Test the delete and backspace keys.
   textfield_->SelectRange(gfx::Range(5));
   for (int i = 0; i < 3; i++)
     SendKeyEvent(ui::VKEY_BACK);
   EXPECT_STR_EQ("abfghij", textfield_->text());
   for (int i = 0; i < 3; i++)
     SendKeyEvent(ui::VKEY_DELETE);
   EXPECT_STR_EQ("abij", textfield_->text());
 
   // Select all and replace with "k".
   textfield_->SelectAll(false);
   SendKeyEvent(ui::VKEY_K);
   EXPECT_STR_EQ("k", textfield_->text());
 
   // Delete the previous word from cursor.
+  bool shift = false;
   textfield_->SetText(ASCIIToUTF16("one two three four"));
-  SendKeyEvent(ui::VKEY_END);
-  SendKeyEvent(ui::VKEY_BACK, false, false, true, false);
+  SendEndEvent(shift);
+  SendWordEvent(ui::VKEY_BACK, shift);
   EXPECT_STR_EQ("one two three ", textfield_->text());
 
-  // Delete to a line break on Linux and ChromeOS, to a word break on Windows.
-  SendKeyEvent(ui::VKEY_LEFT, false, false, true, false);
-  SendKeyEvent(ui::VKEY_BACK, false, true, true, false);
+  // Delete to a line break on Linux and ChromeOS, to a word break on Windows
+  // and Mac.
+  SendWordEvent(ui::VKEY_LEFT, shift);
+  shift = true;
+  SendWordEvent(ui::VKEY_BACK, shift);
 #if defined(OS_LINUX)
   EXPECT_STR_EQ("three ", textfield_->text());
 #else
   EXPECT_STR_EQ("one three ", textfield_->text());
 #endif
 
   // Delete the next word from cursor.
   textfield_->SetText(ASCIIToUTF16("one two three four"));
-  SendKeyEvent(ui::VKEY_HOME);
-  SendKeyEvent(ui::VKEY_DELETE, false, false, true, false);
+  shift = false;
+  SendHomeEvent(shift);
+  SendWordEvent(ui::VKEY_DELETE, shift);
   EXPECT_STR_EQ(" two three four", textfield_->text());
 
-  // Delete to a line break on Linux and ChromeOS, to a word break on Windows.
-  SendKeyEvent(ui::VKEY_RIGHT, false, false, true, false);
-  SendKeyEvent(ui::VKEY_DELETE, false, true, true, false);
+  // Delete to a line break on Linux and ChromeOS, to a word break on Windows
+  // and Mac.
+  SendWordEvent(ui::VKEY_RIGHT, shift);
+  shift = true;
+  SendWordEvent(ui::VKEY_DELETE, shift);
 #if defined(OS_LINUX)
   EXPECT_STR_EQ(" two", textfield_->text());
 #else
   EXPECT_STR_EQ(" two four", textfield_->text());
 #endif
 }
 
 TEST_F(TextfieldTest, PasswordTest) {
   InitTextfield();
   textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
@@ skipping 934 matching lines @@
   x = GetCursorBounds().x();
   EXPECT_GE(1, std::abs(x - prev_x));
 
   SendKeyEvent(0x05E2);
   EXPECT_EQ(WideToUTF16(L"ab\x05E1\x5E2"), textfield_->text());
   x = GetCursorBounds().x();
   EXPECT_GE(1, std::abs(x - prev_x));
 
   // Clear text.
   SendKeyEvent(ui::VKEY_A, false, true);
-  SendKeyEvent('\n');
+  SendKeyEvent(ui::VKEY_DELETE);
 
   // RTL-LTR string in LTR context.
   SendKeyEvent(0x05E1);
   EXPECT_EQ(WideToUTF16(L"\x05E1"), textfield_->text());
   x = GetCursorBounds().x();
   EXPECT_EQ(GetDisplayRect().x(), x);
   prev_x = x;
 
   SendKeyEvent(0x05E2);
   EXPECT_EQ(WideToUTF16(L"\x05E1\x05E2"), textfield_->text());
@@ skipping 33 matching lines @@
   EXPECT_EQ(WideToUTF16(L"ab\x05E1"), textfield_->text());
   x = GetCursorBounds().x();
   EXPECT_GT(prev_x, x);
   prev_x = x;
 
   SendKeyEvent(0x05E2);
   EXPECT_EQ(WideToUTF16(L"ab\x05E1\x5E2"), textfield_->text());
   x = GetCursorBounds().x();
   EXPECT_GT(prev_x, x);
 
+  // Clear text.
   SendKeyEvent(ui::VKEY_A, false, true);
-  SendKeyEvent('\n');
+  SendKeyEvent(ui::VKEY_DELETE);
 
   // RTL-LTR string in RTL context.
   SendKeyEvent(0x05E1);
   EXPECT_EQ(WideToUTF16(L"\x05E1"), textfield_->text());
   x = GetCursorBounds().x();
   prev_x = x;
 
   SendKeyEvent(0x05E2);
   EXPECT_EQ(WideToUTF16(L"\x05E1\x05E2"), textfield_->text());
   x = GetCursorBounds().x();
@@ skipping 146 matching lines @@
     SendKeyEvent('a');
   SendKeyEvent(kHebrewLetterSamekh);
   EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
 
   // Test mouse pointing.
   MouseClick(GetCursorBounds(), -1);
   EXPECT_EQ(500U, textfield_->GetCursorPosition());
 
   // Clear text.
   SendKeyEvent(ui::VKEY_A, false, true);
-  SendKeyEvent('\n');
+  SendKeyEvent(ui::VKEY_DELETE);
 
   for (int i = 0; i < 500; ++i)
     SendKeyEvent(kHebrewLetterSamekh);
   SendKeyEvent('a');
   EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
 
   MouseClick(GetCursorBounds(), -1);
   EXPECT_EQ(501U, textfield_->GetCursorPosition());
 }
 
 TEST_F(TextfieldTest, OverflowInRTLTest) {
   std::string locale = l10n_util::GetApplicationLocale("");
   base::i18n::SetICUDefaultLocale("he");
 
   InitTextfield();
 
   base::string16 str;
   for (int i = 0; i < 500; ++i)
     SendKeyEvent('a');
   SendKeyEvent(kHebrewLetterSamekh);
   EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
 
   MouseClick(GetCursorBounds(), 1);
   EXPECT_EQ(501U, textfield_->GetCursorPosition());
 
   // Clear text.
   SendKeyEvent(ui::VKEY_A, false, true);
-  SendKeyEvent('\n');
+  SendKeyEvent(ui::VKEY_DELETE);
 
   for (int i = 0; i < 500; ++i)
     SendKeyEvent(kHebrewLetterSamekh);
   SendKeyEvent('a');
   EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
 
   MouseClick(GetCursorBounds(), 1);
   EXPECT_EQ(500U, textfield_->GetCursorPosition());
 
   // Reset locale.
@@ skipping 413 matching lines @@
 
   // Tap again on selection and check if touch selection handles are still
   // present and selection is changed to a cursor at tap location.
   Tap(tap_point);
   textfield_->GetSelectionRange(&range);
   EXPECT_TRUE(test_api_->touch_selection_controller());
   EXPECT_EQ(tap_range, range);
 }
 
 }  // namespace views