MacViews: tryjobs for toolkit_views=1

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>
 
@@ skipping 67 matching lines @@
       return key;
 
     key_handled_ = key;
 
     return key_handled_;
   }
 
   bool OnKeyReleased(const ui::KeyEvent& e) override {
     key_received_ = true;
     key_handled_ = views::Textfield::OnKeyReleased(e);
+    EXPECT_FALSE(key_handled_);  // Textfield doesn't override OnKeyReleased.
     return key_handled_;
   }
 
+  // On Mac, characters are inserted directly rather than attempting to get a
+  // unicode character from the ui::KeyEvent (which isn't always possible).
+  // Also, editing commands are translated from AppKit "action messages", which
+  // conform to custom keybindings a user may have. For these, count them as
+  // both received and handled. If a Mac key event does not map to a character
+  // or editing command, it falls back to OnKeyPressed(), which will be logged
+  // above as received, but not handled.
+
+  // ui::TextInputClient overrides:
+  void InsertChar(base::char16 ch, int flags) override {
+    views::Textfield::InsertChar(ch, flags);
+#if defined(OS_MACOSX)
+    key_received_ = true;
+#endif
+  }
+
+  void ExecuteEditingCommand(int command_id) override {
+    views::Textfield::ExecuteEditingCommand(command_id);
+#if defined(OS_MACOSX)
+    key_received_ = true;
+    key_handled_ = true;
+#endif
+  }
+
+  bool HandleAsKeyEventOnly(const ui::KeyEvent& key_event) override {
+#if defined(OS_MACOSX)
+    key_received_ = true;
+#endif
+    return views::Textfield::HandleAsKeyEventOnly(key_event);
+  }
+
   bool key_handled() const { return key_handled_; }
   bool key_received() const { return key_received_; }
 
   void clear() { key_received_ = key_handled_ = false; }
 
  private:
   bool key_handled_;
   bool key_received_;
 
   base::WeakPtrFactory<TestTextfield> weak_ptr_factory_;
@@ skipping 74 matching lines @@
 
   // TextfieldController:
   void ContentsChanged(Textfield* sender,
                        const base::string16& new_contents) override {
     // Paste calls TextfieldController::ContentsChanged() explicitly even if the
     // paste action did not change the content. So |new_contents| may match
     // |last_contents_|. For more info, see http://crbug.com/79002
     last_contents_ = new_contents;
   }
 
+  // views::TextfieldController:
+  bool HandleKeyEvent(views::Textfield* sender,
+                      const ui::KeyEvent& key_event) override {
+    if (!input_method_->HasMockComposition())
+      return false;
+
+    input_method_->InsertMockComposition();
+    input_method_->ClearMockComposition();
+    return true;
+  }
+
   void OnBeforeUserAction(Textfield* sender) override {
     ++on_before_user_action_;
   }
 
   void OnAfterUserAction(Textfield* sender) override {
     ++on_after_user_action_;
   }
 
   void OnAfterCutOrCopy(ui::ClipboardType clipboard_type) override {
     copied_to_clipboard_ = clipboard_type;
@@ skipping 138 matching lines @@
     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);
   }
 
+  // Sends Shift+Delete if supported, otherwise Cmd+X again.
+  void SendAlternateCut() {
+    if (TestingNativeMac())
+      SendKeyEvent(ui::VKEY_X, false, true);
+    else
+      SendKeyEvent(ui::VKEY_DELETE, true, false);
+  }
+
+  // Sends Ctrl+Insert if supported, otherwise Cmd+C again.
+  void SendAlternateCopy() {
+    if (TestingNativeMac())
+      SendKeyEvent(ui::VKEY_C, false, true);
+    else
+      SendKeyEvent(ui::VKEY_INSERT, false, true);
+  }
+
+  // Sends Shift+Insert if supported, otherwise Cmd+V again.
+  void SendAlternatePaste() {
+    if (TestingNativeMac())
+      SendKeyEvent(ui::VKEY_V, false, true);
+    else
+      SendKeyEvent(ui::VKEY_INSERT, true, false);
+  }
+
+  // Most platforms support Ctrl+Y as an alternative to Ctrl+Shift+Z, but on Mac
+  // that is bound to "Show full history", so is not mapped as an editing
+  // command. So, on Mac, send Cmd+Shift+Z.
+  void SendAlternateRedo() {
+    if (TestingNativeMac())
+      SendKeyEvent(ui::VKEY_Z, true, true);
+    else
+      SendKeyEvent(ui::VKEY_Y, false, true);
+  }
+
   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 220 matching lines @@
   model_->SelectAll(false);
   SetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE, "foo");
 
   // Cut and copy should be disabled.
   EXPECT_FALSE(textfield_->IsCommandIdEnabled(IDS_APP_CUT));
   textfield_->ExecuteCommand(IDS_APP_CUT, 0);
   SendKeyEvent(ui::VKEY_X, false, true);
   EXPECT_FALSE(textfield_->IsCommandIdEnabled(IDS_APP_COPY));
   textfield_->ExecuteCommand(IDS_APP_COPY, 0);
   SendKeyEvent(ui::VKEY_C, false, true);
-  SendKeyEvent(ui::VKEY_INSERT, false, true);
+  SendAlternateCopy();
   EXPECT_STR_EQ("foo", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_STR_EQ("password", textfield_->text());
   // [Shift]+[Delete] should just delete without copying text to the clipboard.
   textfield_->SelectAll(false);
   SendKeyEvent(ui::VKEY_DELETE, true, false);
 
   // Paste should work normally.
   EXPECT_TRUE(textfield_->IsCommandIdEnabled(IDS_APP_PASTE));
   textfield_->ExecuteCommand(IDS_APP_PASTE, 0);
   SendKeyEvent(ui::VKEY_V, false, true);
-  SendKeyEvent(ui::VKEY_INSERT, true, false);
+  SendAlternatePaste();
   EXPECT_STR_EQ("foo", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_STR_EQ("foofoofoo", textfield_->text());
 }
 
 TEST_F(TextfieldTest, TextInputType) {
   InitTextfield();
 
   // Defaults to TEXT
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, textfield_->GetTextInputType());
 
@@ skipping 31 matching lines @@
   SendKeyEvent(ui::VKEY_LEFT);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_TRUE(textfield_->key_handled());
   textfield_->clear();
 
   SendKeyEvent(ui::VKEY_RIGHT);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_TRUE(textfield_->key_handled());
   textfield_->clear();
 
-  SendKeyEvent(ui::VKEY_HOME);
+  bool shift = false;
+  SendHomeEvent(shift);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_TRUE(textfield_->key_handled());
   textfield_->clear();
 
-  SendKeyEvent(ui::VKEY_END);
+  SendEndEvent(shift);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_TRUE(textfield_->key_handled());
   textfield_->clear();
 
-  // F24, up/down key won't be handled.
-  SendKeyEvent(ui::VKEY_F24);
+  // F20, up/down key won't be handled.
+  SendKeyEvent(ui::VKEY_F20);
+#if defined(OS_MACOSX)
+  // On Mac, key combinations that don't map to editing commands are forwarded
+  // on to the next responder, usually ending up at the window, which will beep.
+  EXPECT_FALSE(textfield_->key_received());
+#else
   EXPECT_TRUE(textfield_->key_received());
+#endif
   EXPECT_FALSE(textfield_->key_handled());
   textfield_->clear();
 
   SendKeyEvent(ui::VKEY_UP);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_FALSE(textfield_->key_handled());
   textfield_->clear();
 
   SendKeyEvent(ui::VKEY_DOWN);
   EXPECT_TRUE(textfield_->key_received());
@@ skipping 51 matching lines @@
 TEST_F(TextfieldTest, CursorMovement) {
   InitTextfield();
 
   // Test with trailing whitespace.
   textfield_->SetText(ASCIIToUTF16("one two hre "));
 
   // Send the cursor at the end.
   SendKeyEvent(ui::VKEY_END);
 
   // Ctrl+Left should move the cursor just before the last word.
-  SendKeyEvent(ui::VKEY_LEFT, false, true);
+  bool shift = false;
+  SendWordEvent(ui::VKEY_LEFT, shift);
   SendKeyEvent(ui::VKEY_T);
   EXPECT_STR_EQ("one two thre ", textfield_->text());
   EXPECT_STR_EQ("one two thre ", last_contents_);
 
   // Ctrl+Right should move the cursor to the end of the last word.
-  SendKeyEvent(ui::VKEY_RIGHT, false, true);
+  SendWordEvent(ui::VKEY_RIGHT, shift);
   SendKeyEvent(ui::VKEY_E);
   EXPECT_STR_EQ("one two three ", textfield_->text());
   EXPECT_STR_EQ("one two three ", last_contents_);
 
   // Ctrl+Right again should move the cursor to the end.
-  SendKeyEvent(ui::VKEY_RIGHT, false, true);
+  SendWordEvent(ui::VKEY_RIGHT, shift);
   SendKeyEvent(ui::VKEY_BACK);
   EXPECT_STR_EQ("one two three", textfield_->text());
   EXPECT_STR_EQ("one two three", last_contents_);
 
   // Test with leading whitespace.
   textfield_->SetText(ASCIIToUTF16(" ne two"));
 
   // Send the cursor at the beginning.
-  SendKeyEvent(ui::VKEY_HOME);
+  SendHomeEvent(shift);
 
   // Ctrl+Right, then Ctrl+Left should move the cursor to the beginning of the
   // first word.
-  SendKeyEvent(ui::VKEY_RIGHT, false, true);
-  SendKeyEvent(ui::VKEY_LEFT, false, true);
+  SendWordEvent(ui::VKEY_RIGHT, shift);
+  SendWordEvent(ui::VKEY_LEFT, shift);
   SendKeyEvent(ui::VKEY_O);
   EXPECT_STR_EQ(" one two", textfield_->text());
   EXPECT_STR_EQ(" one two", last_contents_);
 
   // Ctrl+Left to move the cursor to the beginning of the first word.
-  SendKeyEvent(ui::VKEY_LEFT, false, true);
+  SendWordEvent(ui::VKEY_LEFT, shift);
   // Ctrl+Left again should move the cursor back to the very beginning.
-  SendKeyEvent(ui::VKEY_LEFT, false, true);
+  SendWordEvent(ui::VKEY_LEFT, shift);
   SendKeyEvent(ui::VKEY_DELETE);
   EXPECT_STR_EQ("one two", textfield_->text());
   EXPECT_STR_EQ("one two", last_contents_);
 }
 
 TEST_F(TextfieldTest, FocusTraversalTest) {
   InitTextfields(3);
   textfield_->RequestFocus();
 
   EXPECT_EQ(1, GetFocusedView()->id());
@@ skipping 257 matching lines @@
   EXPECT_STR_EQ("h welloorld", textfield_->text());
   textfield_->OnDragDone();
 
   // Undo/Redo the drag&drop change.
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("hello world", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("hello world", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("h welloorld", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("h welloorld", textfield_->text());
 }
 
 TEST_F(TextfieldTest, DragAndDrop_ToTheLeft) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
   base::string16 string;
   ui::OSExchangeData data;
   int formats = 0;
@@ skipping 28 matching lines @@
   EXPECT_STR_EQ("h worlellod", textfield_->text());
   textfield_->OnDragDone();
 
   // Undo/Redo the drag&drop change.
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("hello world", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("hello world", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("h worlellod", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("h worlellod", textfield_->text());
 }
 
 TEST_F(TextfieldTest, DragAndDrop_Canceled) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
   // Start dragging "worl".
   textfield_->SelectRange(gfx::Range(6, 10));
   gfx::Point point(GetCursorPositionX(8), 0);
@@ skipping 20 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("hello world"), textfield_->text());
 }
 
 TEST_F(TextfieldTest, ReadOnlyTest) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("read only"));
   textfield_->SetReadOnly(true);
   EXPECT_TRUE(textfield_->enabled());
   EXPECT_TRUE(textfield_->IsFocusable());
 
-  SendKeyEvent(ui::VKEY_HOME);
+  bool shift = false;
+  SendHomeEvent(shift);
   EXPECT_EQ(0U, textfield_->GetCursorPosition());
-  SendKeyEvent(ui::VKEY_END);
+  SendEndEvent(shift);
   EXPECT_EQ(9U, textfield_->GetCursorPosition());
 
-  SendKeyEvent(ui::VKEY_LEFT, false, false);
+  SendKeyEvent(ui::VKEY_LEFT, shift, false);
   EXPECT_EQ(8U, textfield_->GetCursorPosition());
-  SendKeyEvent(ui::VKEY_LEFT, false, true);
+  SendWordEvent(ui::VKEY_LEFT, shift);
   EXPECT_EQ(5U, textfield_->GetCursorPosition());
-  SendKeyEvent(ui::VKEY_LEFT, true, true);
+  shift = true;
+  SendWordEvent(ui::VKEY_LEFT, shift);
   EXPECT_EQ(0U, textfield_->GetCursorPosition());
   EXPECT_STR_EQ("read ", textfield_->GetSelectedText());
   textfield_->SelectAll(false);
   EXPECT_STR_EQ("read only", textfield_->GetSelectedText());
 
   // Cut should be disabled.
   SetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE, "Test");
   EXPECT_FALSE(textfield_->IsCommandIdEnabled(IDS_APP_CUT));
   textfield_->ExecuteCommand(IDS_APP_CUT, 0);
   SendKeyEvent(ui::VKEY_X, false, true);
-  SendKeyEvent(ui::VKEY_DELETE, true, false);
+  SendAlternateCut();
   EXPECT_STR_EQ("Test", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_STR_EQ("read only", textfield_->text());
 
   // Paste should be disabled.
   EXPECT_FALSE(textfield_->IsCommandIdEnabled(IDS_APP_PASTE));
   textfield_->ExecuteCommand(IDS_APP_PASTE, 0);
   SendKeyEvent(ui::VKEY_V, false, true);
-  SendKeyEvent(ui::VKEY_INSERT, true, false);
+  SendAlternatePaste();
   EXPECT_STR_EQ("read only", textfield_->text());
 
   // Copy should work normally.
   SetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE, "Test");
   EXPECT_TRUE(textfield_->IsCommandIdEnabled(IDS_APP_COPY));
   textfield_->ExecuteCommand(IDS_APP_COPY, 0);
   EXPECT_STR_EQ("read only", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   SetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE, "Test");
   SendKeyEvent(ui::VKEY_C, false, true);
   EXPECT_STR_EQ("read only", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   SetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE, "Test");
-  SendKeyEvent(ui::VKEY_INSERT, false, true);
+  SendAlternateCopy();
   EXPECT_STR_EQ("read only", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
 
   // SetText should work even in read only mode.
   textfield_->SetText(ASCIIToUTF16(" four five six "));
   EXPECT_STR_EQ(" four five six ", textfield_->text());
 
   textfield_->SelectAll(false);
   EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
 
   // Text field is unmodifiable and selection shouldn't change.
@@ skipping 29 matching lines @@
   EXPECT_STR_EQ("0456789", textfield_->text());
 
   ui::CompositionText composition;
   composition.text = UTF8ToUTF16("321");
   // Set composition through input method.
   input_method_->Clear();
   input_method_->SetCompositionTextForNextKey(composition);
   textfield_->clear();
 
   on_before_user_action_ = on_after_user_action_ = 0;
-  SendKeyEvent(ui::VKEY_A);
+  SendKeyEvent(ui::VKEY_RETURN);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_FALSE(textfield_->key_handled());
   EXPECT_TRUE(client->HasCompositionText());
   EXPECT_TRUE(client->GetCompositionTextRange(&range));
   EXPECT_STR_EQ("0321456789", textfield_->text());
   EXPECT_EQ(gfx::Range(1, 4), range);
   EXPECT_EQ(1, on_before_user_action_);
   EXPECT_EQ(1, on_after_user_action_);
 
   input_method_->SetResultTextForNextKey(UTF8ToUTF16("123"));
   on_before_user_action_ = on_after_user_action_ = 0;
   textfield_->clear();
-  SendKeyEvent(ui::VKEY_A);
+  SendKeyEvent(ui::VKEY_RETURN);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_FALSE(textfield_->key_handled());
   EXPECT_FALSE(client->HasCompositionText());
   EXPECT_FALSE(input_method_->cancel_composition_called());
   EXPECT_STR_EQ("0123456789", textfield_->text());
   EXPECT_EQ(1, on_before_user_action_);
   EXPECT_EQ(1, on_after_user_action_);
 
   input_method_->Clear();
   input_method_->SetCompositionTextForNextKey(composition);
   textfield_->clear();
-  SendKeyEvent(ui::VKEY_A);
+  SendKeyEvent(ui::VKEY_RETURN);
   EXPECT_TRUE(client->HasCompositionText());
   EXPECT_STR_EQ("0123321456789", textfield_->text());
 
   on_before_user_action_ = on_after_user_action_ = 0;
   textfield_->clear();
   SendKeyEvent(ui::VKEY_RIGHT);
   EXPECT_FALSE(client->HasCompositionText());
   EXPECT_TRUE(input_method_->cancel_composition_called());
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_TRUE(textfield_->key_handled());
@@ skipping 11 matching lines @@
   // On{Before,After}UserAction should be called by whatever user action
   // triggers clearing or setting a selection if appropriate.
   on_before_user_action_ = on_after_user_action_ = 0;
   textfield_->clear();
   textfield_->ClearSelection();
   textfield_->SelectAll(false);
   EXPECT_EQ(0, on_before_user_action_);
   EXPECT_EQ(0, on_after_user_action_);
 
   input_method_->Clear();
+
+  // Changing the Textfield to readonly shouldn't change the input client, since
+  // it's still required for selections and clipboard copy.
+  ui::TextInputClient* text_input_client = textfield_->GetTextInputClient();
+  EXPECT_TRUE(text_input_client);
+  EXPECT_NE(ui::TEXT_INPUT_TYPE_NONE, text_input_client->GetTextInputType());
   textfield_->SetReadOnly(true);
   EXPECT_TRUE(input_method_->text_input_type_changed());
-  EXPECT_FALSE(textfield_->GetTextInputClient());
+  EXPECT_EQ(text_input_client, textfield_->GetTextInputClient());
+  EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE, text_input_client->GetTextInputType());
 
   textfield_->SetReadOnly(false);
+  EXPECT_NE(ui::TEXT_INPUT_TYPE_NONE, text_input_client->GetTextInputType());
+
   input_method_->Clear();
   textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
   EXPECT_TRUE(input_method_->text_input_type_changed());
   EXPECT_TRUE(textfield_->GetTextInputClient());
 }
 
 TEST_F(TextfieldTest, UndoRedoTest) {
   InitTextfield();
   SendKeyEvent(ui::VKEY_A);
   EXPECT_STR_EQ("a", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("a", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("a", textfield_->text());
 
   // AppendText
   textfield_->AppendText(ASCIIToUTF16("b"));
   last_contents_.clear();  // AppendText doesn't call ContentsChanged.
   EXPECT_STR_EQ("ab", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("a", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("ab", textfield_->text());
 
   // SetText
   SendKeyEvent(ui::VKEY_C);
   // Undo'ing append moves the cursor to the end for now.
   // A no-op SetText won't add a new edit; see TextfieldModel::SetText.
   EXPECT_STR_EQ("abc", textfield_->text());
   textfield_->SetText(ASCIIToUTF16("abc"));
   EXPECT_STR_EQ("abc", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("ab", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("abc", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("abc", textfield_->text());
   textfield_->SetText(ASCIIToUTF16("123"));
   textfield_->SetText(ASCIIToUTF16("123"));
   EXPECT_STR_EQ("123", textfield_->text());
   SendKeyEvent(ui::VKEY_END, false, false);
   SendKeyEvent(ui::VKEY_4, false, false);
   EXPECT_STR_EQ("1234", textfield_->text());
   last_contents_.clear();
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("123", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   // the insert edit "c" and set edit "123" are merged to single edit,
   // so text becomes "ab" after undo.
   EXPECT_STR_EQ("ab", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("a", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("ab", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("123", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("1234", textfield_->text());
 
   // Undoing to the same text shouldn't call ContentsChanged.
   SendKeyEvent(ui::VKEY_A, false, true);  // select all
   SendKeyEvent(ui::VKEY_A);
   EXPECT_STR_EQ("a", textfield_->text());
   SendKeyEvent(ui::VKEY_B);
   SendKeyEvent(ui::VKEY_C);
   EXPECT_STR_EQ("abc", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("1234", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("abc", textfield_->text());
 
   // Delete/Backspace
   SendKeyEvent(ui::VKEY_BACK);
   EXPECT_STR_EQ("ab", textfield_->text());
-  SendKeyEvent(ui::VKEY_HOME);
+  bool shift = false;
+  SendHomeEvent(shift);
   SendKeyEvent(ui::VKEY_DELETE);
   EXPECT_STR_EQ("b", textfield_->text());
   SendKeyEvent(ui::VKEY_A, false, true);
   SendKeyEvent(ui::VKEY_DELETE);
   EXPECT_STR_EQ("", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("b", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("ab", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("abc", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("ab", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("b", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("", textfield_->text());
-  SendKeyEvent(ui::VKEY_Y, false, true);
+  SendAlternateRedo();
   EXPECT_STR_EQ("", textfield_->text());
 }
 
 TEST_F(TextfieldTest, CutCopyPaste) {
   InitTextfield();
 
   // Ensure IDS_APP_CUT cuts.
   textfield_->SetText(ASCIIToUTF16("123"));
   textfield_->SelectAll(false);
   EXPECT_TRUE(textfield_->IsCommandIdEnabled(IDS_APP_CUT));
@@ skipping 10 matching lines @@
   EXPECT_STR_EQ("456", textfield_->text());
   EXPECT_EQ(ui::CLIPBOARD_TYPE_LAST, GetAndResetCopiedToClipboard());
   SendKeyEvent(ui::VKEY_X, false, true);
   EXPECT_STR_EQ("456", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_STR_EQ("", textfield_->text());
   EXPECT_EQ(ui::CLIPBOARD_TYPE_COPY_PASTE, GetAndResetCopiedToClipboard());
 
   // Ensure [Shift]+[Delete] cuts.
   textfield_->SetText(ASCIIToUTF16("123"));
   textfield_->SelectAll(false);
-  SendKeyEvent(ui::VKEY_DELETE, true, false);
+  SendAlternateCut();
   EXPECT_STR_EQ("123", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_STR_EQ("", textfield_->text());
   EXPECT_EQ(ui::CLIPBOARD_TYPE_COPY_PASTE, GetAndResetCopiedToClipboard());
 
   // Ensure IDS_APP_COPY copies.
   textfield_->SetText(ASCIIToUTF16("789"));
   textfield_->SelectAll(false);
   EXPECT_TRUE(textfield_->IsCommandIdEnabled(IDS_APP_COPY));
   textfield_->ExecuteCommand(IDS_APP_COPY, 0);
   EXPECT_STR_EQ("789", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_EQ(ui::CLIPBOARD_TYPE_COPY_PASTE, GetAndResetCopiedToClipboard());
 
   // Ensure [Ctrl]+[c] copies and [Ctrl]+[Alt][c] does nothing.
   textfield_->SetText(ASCIIToUTF16("012"));
   textfield_->SelectAll(false);
   SendKeyEvent(ui::VKEY_C, true, false, true, false);
   EXPECT_STR_EQ("789", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_EQ(ui::CLIPBOARD_TYPE_LAST, GetAndResetCopiedToClipboard());
   SendKeyEvent(ui::VKEY_C, false, true);
   EXPECT_STR_EQ("012", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_EQ(ui::CLIPBOARD_TYPE_COPY_PASTE, GetAndResetCopiedToClipboard());
 
   // Ensure [Ctrl]+[Insert] copies.
   textfield_->SetText(ASCIIToUTF16("345"));
   textfield_->SelectAll(false);
-  SendKeyEvent(ui::VKEY_INSERT, false, true);
+  SendAlternateCopy();
   EXPECT_STR_EQ("345", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_STR_EQ("345", textfield_->text());
   EXPECT_EQ(ui::CLIPBOARD_TYPE_COPY_PASTE, GetAndResetCopiedToClipboard());
 
   // Ensure IDS_APP_PASTE, [Ctrl]+[V], and [Shift]+[Insert] pastes;
   // also ensure that [Ctrl]+[Alt]+[V] does nothing.
   SetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE, "abc");
   textfield_->SetText(base::string16());
   EXPECT_TRUE(textfield_->IsCommandIdEnabled(IDS_APP_PASTE));
   textfield_->ExecuteCommand(IDS_APP_PASTE, 0);
   EXPECT_STR_EQ("abc", textfield_->text());
   SendKeyEvent(ui::VKEY_V, false, true);
   EXPECT_STR_EQ("abcabc", textfield_->text());
-  SendKeyEvent(ui::VKEY_INSERT, true, false);
+  SendAlternatePaste();
   EXPECT_STR_EQ("abcabcabc", textfield_->text());
   SendKeyEvent(ui::VKEY_V, true, false, true, false);
   EXPECT_STR_EQ("abcabcabc", textfield_->text());
 
   // Ensure [Ctrl]+[Shift]+[Insert] is a no-op.
   textfield_->SelectAll(false);
   SendKeyEvent(ui::VKEY_INSERT, true, true);
   EXPECT_STR_EQ("abc", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_STR_EQ("abcabcabc", textfield_->text());
   EXPECT_EQ(ui::CLIPBOARD_TYPE_LAST, GetAndResetCopiedToClipboard());
 }
 
 TEST_F(TextfieldTest, OvertypeMode) {
   InitTextfield();
   // Overtype mode should be disabled (no-op [Insert]).
   textfield_->SetText(ASCIIToUTF16("2"));
-  SendKeyEvent(ui::VKEY_HOME);
+  bool shift = false;
+  SendHomeEvent(shift);
+  // Note: On Mac, there is no insert key. Insert sends kVK_Help. Currently,
+  // since there is no overtype on toolkit-views, the behavior happens to match.
+  // However, there's no enable-overtype equivalent key combination on OSX.
   SendKeyEvent(ui::VKEY_INSERT);
   SendKeyEvent(ui::VKEY_1, false, false);
   EXPECT_STR_EQ("12", textfield_->text());
 }
 
 TEST_F(TextfieldTest, TextCursorDisplayTest) {
   InitTextfield();
   // LTR-RTL string in LTR context.
   SendKeyEvent('a');
   EXPECT_STR_EQ("a", textfield_->text());
@@ skipping 157 matching lines @@
     NonClientMouseClick();
   }
 }
 
 TEST_F(TextfieldTest, HitOutsideTextAreaTest) {
   InitTextfield();
 
   // LTR-RTL string in LTR context.
   textfield_->SetText(WideToUTF16(L"ab\x05E1\x5E2"));
 
-  SendKeyEvent(ui::VKEY_HOME);
+  bool shift = false;
+  SendHomeEvent(shift);
   gfx::Rect bound = GetCursorBounds();
   MouseClick(bound, -10);
   EXPECT_EQ(bound, GetCursorBounds());
 
-  SendKeyEvent(ui::VKEY_END);
+  SendEndEvent(shift);
   bound = GetCursorBounds();
   MouseClick(bound, 10);
   EXPECT_EQ(bound, GetCursorBounds());
 
   NonClientMouseClick();
 
   // RTL-LTR string in LTR context.
   textfield_->SetText(WideToUTF16(L"\x05E1\x5E2" L"ab"));
 
-  SendKeyEvent(ui::VKEY_HOME);
+  SendHomeEvent(shift);
   bound = GetCursorBounds();
   MouseClick(bound, 10);
   EXPECT_EQ(bound, GetCursorBounds());
 
-  SendKeyEvent(ui::VKEY_END);
+  SendEndEvent(shift);
   bound = GetCursorBounds();
   MouseClick(bound, -10);
   EXPECT_EQ(bound, GetCursorBounds());
 }
 
 TEST_F(TextfieldTest, HitOutsideTextAreaInRTLTest) {
   std::string locale = l10n_util::GetApplicationLocale("");
   base::i18n::SetICUDefaultLocale("he");
 
   InitTextfield();
 
   // RTL-LTR string in RTL context.
   textfield_->SetText(WideToUTF16(L"\x05E1\x5E2" L"ab"));
-  SendKeyEvent(ui::VKEY_HOME);
+  bool shift = false;
+  SendHomeEvent(shift);
   gfx::Rect bound = GetCursorBounds();
   MouseClick(bound, 10);
   EXPECT_EQ(bound, GetCursorBounds());
 
-  SendKeyEvent(ui::VKEY_END);
+  SendEndEvent(shift);
   bound = GetCursorBounds();
   MouseClick(bound, -10);
   EXPECT_EQ(bound, GetCursorBounds());
 
   NonClientMouseClick();
 
   // LTR-RTL string in RTL context.
   textfield_->SetText(WideToUTF16(L"ab\x05E1\x5E2"));
-  SendKeyEvent(ui::VKEY_HOME);
+  SendHomeEvent(shift);
   bound = GetCursorBounds();
   MouseClick(bound, -10);
   EXPECT_EQ(bound, GetCursorBounds());
 
-  SendKeyEvent(ui::VKEY_END);
+  SendEndEvent(shift);
   bound = GetCursorBounds();
   MouseClick(bound, 10);
   EXPECT_EQ(bound, GetCursorBounds());
 
   // Reset locale.
   base::i18n::SetICUDefaultLocale(locale);
 }
 
 TEST_F(TextfieldTest, OverflowTest) {
   InitTextfield();
@@ skipping 315 matching lines @@
 // Tests that a textfield view can be destroyed from OnKeyEvent() on its
 // controller and it does not crash.
 TEST_F(TextfieldTest, DestroyingTextfieldFromOnKeyEvent) {
   InitTextfield();
 
   // The controller assumes ownership of the textfield.
   TextfieldDestroyerController controller(textfield_);
   EXPECT_TRUE(controller.target());
 
   // Send a key to trigger OnKeyEvent().
-  SendKeyEvent('X');
+  SendKeyEvent(ui::VKEY_RETURN);
 
   EXPECT_FALSE(controller.target());
 }
 
 class TextfieldTouchSelectionTest : public TextfieldTest {
  public:
   // TextfieldTest:
   void SetUp() override {
     TextfieldTest::SetUp();
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
@@ skipping 96 matching lines @@
 
   // Make textfield unfocusable and tap on it. Touch text selection should not
   // get activated.
   textfield_->SetFocusable(false);
   Tap(touch_point);
   EXPECT_FALSE(textfield_->HasFocus());
   EXPECT_FALSE(test_api_->touch_selection_controller());
   textfield_->SetFocusable(true);
 }
 
-TEST_F(TextfieldTouchSelectionTest, TapOnSelection) {
+// No touch on desktop Mac. Tracked in http://crbug.com/445520.
+#if defined(OS_MACOSX) && !defined(USE_AURA)
+#define MAYBE_TapOnSelection DISABLED_TapOnSelection
+#else
+#define MAYBE_TapOnSelection TapOnSelection
+#endif
+
+TEST_F(TextfieldTouchSelectionTest, MAYBE_TapOnSelection) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
   gfx::Range sel_range(2, 7);
   gfx::Range tap_range(5, 5);
   gfx::Rect tap_rect =
       GetCursorBounds(gfx::SelectionModel(tap_range, gfx::CURSOR_FORWARD));
   gfx::Point tap_point = tap_rect.CenterPoint();
 
   // Select range |sel_range| and check if touch selection handles are not
   // present and correct range is selected.
@@ skipping 12 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