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 15 matching lines @@
 using base::ASCIIToUTF16;
 using base::UTF8ToUTF16;
 using base::WideToUTF16;
 
 #define EXPECT_STR_EQ(ascii, utf16) EXPECT_EQ(ASCIIToUTF16(ascii), utf16)
 
 namespace {
 
 const base::char16 kHebrewLetterSamekh = 0x05E1;
 
+// The method used for dispatching key events. Either dispatch directly to the
+// MockInputMethod using the keycodes it expects internally, or dispatch to the
+// native window implementation using platform-specific keycodes, which should
+// be translated into the correct editing commands.
+enum EventDispatchMethod {
+  DISPATCH_TO_INPUT_METHOD,
+  DISPATCH_TO_WINDOW,
+};
+
 // A Textfield wrapper to intercept OnKey[Pressed|Released]() ressults.
 class TestTextfield : public views::Textfield {
  public:
   TestTextfield()
      : Textfield(),
        key_handled_(false),
        key_received_(false),
        weak_ptr_factory_(this) {}
 
   bool OnKeyPressed(const ui::KeyEvent& e) override {
@@ skipping 83 matching lines @@
   TextfieldTest()
       : widget_(NULL),
         textfield_(NULL),
         model_(NULL),
         input_method_(NULL),
         on_before_user_action_(0),
         on_after_user_action_(0),
         copied_to_clipboard_(ui::CLIPBOARD_TYPE_LAST) {
   }
 
+  // Provide an implementation of GetParam which parameterized subclasses can
+  // override using gtest's GetParam().
+  virtual EventDispatchMethod GetParamWithDefault() {
+    return DISPATCH_TO_INPUT_METHOD;
+  }
+
   // ::testing::Test:
   void TearDown() override {
     if (widget_)
       widget_->Close();
     ViewsTestBase::TearDown();
   }
 
   ui::ClipboardType GetAndResetCopiedToClipboard() {
     ui::ClipboardType clipboard_type = copied_to_clipboard_;
     copied_to_clipboard_ = ui::CLIPBOARD_TYPE_LAST;
@@ skipping 23 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
+
+    if (GetParamWithDefault() == DISPATCH_TO_WINDOW) {
+      event_generator_.reset(new ui::test::EventGenerator(
+          GetContext(), widget_->GetNativeWindow()));
+    }
   }
 
   ui::MenuModel* GetContextMenuModel() {
     test_api_->UpdateContextMenu();
     return test_api_->context_menu_contents();
   }
 
+  // On Mac, true if testing a views::TextField in an NSWindow using native
+  // NSEvents. On other platforms, a helper function to avoid ifdef litter.
+  bool TestingNativeMac() {
+#if defined(OS_MACOSX)
+    return GetParamWithDefault() == DISPATCH_TO_WINDOW;
+#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);
+
+    // If dispatching to the window, ask the event generator to generate
+    // events populated with native event information for each platform.
+    if (GetParamWithDefault() == DISPATCH_TO_WINDOW) {
+      event_generator_->PressKey(key_code, flags);
+      return;
+    }
+
     ui::KeyEvent event(ui::ET_KEY_PRESSED, key_code, flags);
     input_method_->DispatchKeyEvent(event);
   }
 
-  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 {
+      // TODO(tapted): Support DISPATCH_TO_WINDOW here.
       ui::KeyEvent event(ch, ui::VKEY_UNKNOWN, ui::EF_NONE);
       input_method_->DispatchKeyEvent(event);
     }
   }
 
   View* GetFocusedView() {
     return widget_->GetFocusManager()->GetFocusedView();
   }
 
   int GetCursorPositionX(int cursor_pos) {
@@ skipping 68 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_;

[oshima, 2015/01/30 17:44:17]

I believe the test was updated to use MockInputMethod before event generator was
introduced. I wonder if using event generator is good enough. Can we eliminate
MockInputMethod path?

[tapted, 2015/02/02 12:46:37]

Done.

Just a couple of surprises. And of course some test regressions on MacViews
running views_unittests (filed http://crbug.com/454353 to track), but I'd need
to fix them anyway.

 
   DISALLOW_COPY_AND_ASSIGN(TextfieldTest);
 };
 
+// TextfieldTest that overrides GetParamWithDefault() to override the default
+// using GetParam() from the gtest interface.
+class TextfieldTestWithParam
+    : public TextfieldTest,
+      public ::testing::WithParamInterface<EventDispatchMethod> {
+ public:
+  TextfieldTestWithParam() {}
+
+  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 */);
+  }
+
+  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);
+  }
+
+  // Overridden from TextfieldTest:
+  EventDispatchMethod GetParamWithDefault() override { return GetParam(); }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TextfieldTestWithParam);
+};
+
 TEST_F(TextfieldTest, ModelChangesTest) {
   InitTextfield();
 
   // TextfieldController::ContentsChanged() shouldn't be called when changing
   // text programmatically.
   last_contents_.clear();
   textfield_->SetText(ASCIIToUTF16("this is"));
 
   EXPECT_STR_EQ("this is", model_->text());
   EXPECT_STR_EQ("this is", textfield_->text());
@@ skipping 17 matching lines @@
   SendKeyEvent(ui::VKEY_E, false, false, false, false);
   SendKeyEvent(ui::VKEY_X, false, true,  false, true);
   SendKeyEvent(ui::VKEY_T, false, false, false, true);
   SendKeyEvent(ui::VKEY_1, false, true,  false, false);
   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) {
+TEST_P(TextfieldTestWithParam, 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) {
+TEST_P(TextfieldTestWithParam, 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');

[tapted, 2015/02/02 12:46:37]

These were using the SendKeyEvent(base::char16) overload, which only works for
space and letters. For '\n' it does `ui::KeyboardCode code = '\n' + 'a', which
isn't right. The method of clearing isn't interesting for these tests, so I've
just done SetText("");

[oshima, 2015/02/02 17:59:13]

Can you send VKEY_DELETE instead?

[tapted, 2015/02/02 22:26:44]

Done.

 
   // 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 662 matching lines @@
   EXPECT_EQ(sel_range, range);
 
   // 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);
 }
 
+// Instantiate parameterized tests. These are just the ones above using "TEST_P"
+// rather than "TEST_F".
+INSTANTIATE_TEST_CASE_P(
+    TextfieldTestWithParamInstance,
+    TextfieldTestWithParam,
+    ::testing::Values<EventDispatchMethod>(DISPATCH_TO_INPUT_METHOD,
+                                           DISPATCH_TO_WINDOW));
+
 }  // namespace views