Views Textfield: copy-on-select and paste-on-middle-click.

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 91 matching lines @@
   GestureEventForTest(ui::EventType type, int x, int y, float delta_x,
                       float delta_y)
       : GestureEvent(type, x, y, 0, base::TimeDelta(),
                      ui::GestureEventDetails(type, delta_x, delta_y), 0) {
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GestureEventForTest);
 };
 
+base::string16 GetClipboardText(ui::ClipboardType type) {
+  base::string16 text;
+  ui::Clipboard::GetForCurrentThread()->ReadText(type, &text);
+  return text;
+}
+
+void SetClipboardText(ui::ClipboardType type, const std::string& text) {
+  ui::ScopedClipboardWriter(ui::Clipboard::GetForCurrentThread(), type)
+      .WriteText(ASCIIToUTF16(text));
+}
+
 }  // namespace
 
 namespace views {
 
 class TextfieldTest : public ViewsTestBase, public TextfieldController {
  public:
   TextfieldTest()
       : widget_(NULL),
         textfield_(NULL),
         model_(NULL),
@@ skipping 108 matching lines @@
           ch == ' ' ? ui::VKEY_SPACE :
           static_cast<ui::KeyboardCode>(ui::VKEY_A + ch - 'a');
       SendKeyEvent(code);
     } else {
       ui::KeyEvent event(ui::ET_KEY_PRESSED, ui::VKEY_UNKNOWN, 0, false);
       event.set_character(ch);
       input_method_->DispatchKeyEvent(event);
     }
   }
 
-  base::string16 GetClipboardText() const {
-    base::string16 text;
-    ui::Clipboard::GetForCurrentThread()->
-        ReadText(ui::CLIPBOARD_TYPE_COPY_PASTE, &text);
-    return text;
-  }
-
-  void SetClipboardText(const std::string& text) {
-    ui::ScopedClipboardWriter clipboard_writer(
-        ui::Clipboard::GetForCurrentThread(),
-        ui::CLIPBOARD_TYPE_COPY_PASTE);
-    clipboard_writer.WriteText(ASCIIToUTF16(text));
-  }
-
   View* GetFocusedView() {
     return widget_->GetFocusManager()->GetFocusedView();
   }
 
   int GetCursorPositionX(int cursor_pos) {
     return textfield_->GetRenderText()->GetCursorBounds(
         gfx::SelectionModel(cursor_pos, gfx::CURSOR_FORWARD), false).x();
   }
 
   // Get the current cursor bounds.
   gfx::Rect GetCursorBounds() {
     return textfield_->GetRenderText()->GetUpdatedCursorBounds();
   }
 
   // Get the cursor bounds of |sel|.
   gfx::Rect GetCursorBounds(const gfx::SelectionModel& sel) {
     return textfield_->GetRenderText()->GetCursorBounds(sel, true);
   }
 
   gfx::Rect GetDisplayRect() {
     return textfield_->GetRenderText()->display_rect();
   }
 
   // Mouse click on the point whose x-axis is |bound|'s x plus |x_offset| and
   // y-axis is in the middle of |bound|'s vertical range.
   void MouseClick(const gfx::Rect bound, int x_offset) {
-    gfx::Point point(bound.x() +  x_offset, bound.y() + bound.height() / 2);
+    gfx::Point point(bound.x() + x_offset, bound.y() + bound.height() / 2);
     ui::MouseEvent click(ui::ET_MOUSE_PRESSED, point, point,
                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
     textfield_->OnMousePressed(click);
     ui::MouseEvent release(ui::ET_MOUSE_RELEASED, point, point,
                            ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
     textfield_->OnMouseReleased(release);
   }
 
   // This is to avoid double/triple click.
   void NonClientMouseClick() {
     ui::MouseEvent click(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
                          ui::EF_LEFT_MOUSE_BUTTON | ui::EF_IS_NON_CLIENT,
                          ui::EF_LEFT_MOUSE_BUTTON);
     textfield_->OnMousePressed(click);
     ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
                            ui::EF_LEFT_MOUSE_BUTTON | ui::EF_IS_NON_CLIENT,
                            ui::EF_LEFT_MOUSE_BUTTON);
     textfield_->OnMouseReleased(release);
   }
 
-  // Wrap for visibility in test classes.
-  ui::TextInputType GetTextInputType() {
-    return textfield_->GetTextInputType();
-  }
-
   void VerifyTextfieldContextMenuContents(bool textfield_has_selection,
                                           bool can_undo,
                                           ui::MenuModel* menu) {
     EXPECT_EQ(can_undo, menu->IsEnabledAt(0 /* UNDO */));
     EXPECT_TRUE(menu->IsEnabledAt(1 /* Separator */));
     EXPECT_EQ(textfield_has_selection, menu->IsEnabledAt(2 /* CUT */));
     EXPECT_EQ(textfield_has_selection, menu->IsEnabledAt(3 /* COPY */));
-    EXPECT_NE(GetClipboardText().empty(), menu->IsEnabledAt(4 /* PASTE */));
+    EXPECT_NE(GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE).empty(),
+              menu->IsEnabledAt(4 /* PASTE */));
     EXPECT_EQ(textfield_has_selection, menu->IsEnabledAt(5 /* DELETE */));
     EXPECT_TRUE(menu->IsEnabledAt(6 /* Separator */));
     EXPECT_TRUE(menu->IsEnabledAt(7 /* SELECT ALL */));
   }
 
   // We need widget to populate wrapper class.
   Widget* widget_;
 
   TestTextfield* textfield_;
   TextfieldModel* model_;
@@ skipping 134 matching lines @@
 #if defined(OS_LINUX)
   EXPECT_STR_EQ(" two", textfield_->text());
 #else
   EXPECT_STR_EQ(" two three four", textfield_->text());
 #endif
 }
 
 TEST_F(TextfieldTest, PasswordTest) {
   InitTextfield();
   textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
-  EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType());
+  EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, textfield_->GetTextInputType());
   EXPECT_TRUE(textfield_->enabled());
   EXPECT_TRUE(textfield_->IsFocusable());
 
   last_contents_.clear();
   textfield_->SetText(ASCIIToUTF16("password"));
   // Ensure text() and the callback returns the actual text instead of "*".
   EXPECT_STR_EQ("password", textfield_->text());
   EXPECT_TRUE(last_contents_.empty());
   model_->SelectAll(false);
-  SetClipboardText("foo");
+  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);
-  EXPECT_STR_EQ("foo", base::string16(GetClipboardText()));
+  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);
-  EXPECT_STR_EQ("foo", base::string16(GetClipboardText()));
+  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, GetTextInputType());
+  EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, textfield_->GetTextInputType());
 
   // And can be set.
   textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_URL);
-  EXPECT_EQ(ui::TEXT_INPUT_TYPE_URL, GetTextInputType());
+  EXPECT_EQ(ui::TEXT_INPUT_TYPE_URL, textfield_->GetTextInputType());
   textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
-  EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType());
+  EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, textfield_->GetTextInputType());
 
   // Readonly textfields have type NONE
   textfield_->SetReadOnly(true);
-  EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE, GetTextInputType());
+  EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE, textfield_->GetTextInputType());
 
   textfield_->SetReadOnly(false);
-  EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType());
+  EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, textfield_->GetTextInputType());
 
   // As do disabled textfields
   textfield_->SetEnabled(false);
-  EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE, GetTextInputType());
+  EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE, textfield_->GetTextInputType());
 
   textfield_->SetEnabled(true);
-  EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType());
+  EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, textfield_->GetTextInputType());
 }
 
 TEST_F(TextfieldTest, OnKeyPressReturnValueTest) {
   InitTextfield();
 
   // Character keys will be handled by input method.
   SendKeyEvent(ui::VKEY_A);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_FALSE(textfield_->key_handled());
   textfield_->clear();
@@ skipping 122 matching lines @@
   widget_->GetFocusManager()->AdvanceFocus(true);
   EXPECT_EQ(1, GetFocusedView()->id());
   // Cycle back to the last textfield.
   widget_->GetFocusManager()->AdvanceFocus(true);
   EXPECT_EQ(3, GetFocusedView()->id());
 
   // Request focus should still work.
   textfield_->RequestFocus();
   EXPECT_EQ(1, GetFocusedView()->id());
 
-  // Test if clicking on textfield view sets the focus to textfield_.
+  // Test if clicking on textfield view sets the focus.
   widget_->GetFocusManager()->AdvanceFocus(true);
   EXPECT_EQ(3, GetFocusedView()->id());
   ui::MouseEvent click(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
                        ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   textfield_->OnMousePressed(click);
   EXPECT_EQ(1, GetFocusedView()->id());
 }
 
 TEST_F(TextfieldTest, ContextMenuDisplayTest) {
   InitTextfield();
   EXPECT_TRUE(textfield_->context_menu_controller());
   textfield_->SetText(ASCIIToUTF16("hello world"));
   ui::Clipboard::GetForCurrentThread()->Clear(ui::CLIPBOARD_TYPE_COPY_PASTE);
   textfield_->ClearEditHistory();
   EXPECT_TRUE(GetContextMenuModel());
   VerifyTextfieldContextMenuContents(false, false, GetContextMenuModel());
 
   textfield_->SelectAll(false);
   VerifyTextfieldContextMenuContents(true, false, GetContextMenuModel());
 
   SendKeyEvent(ui::VKEY_T);
   VerifyTextfieldContextMenuContents(false, true, GetContextMenuModel());
 
   textfield_->SelectAll(false);
   VerifyTextfieldContextMenuContents(true, true, GetContextMenuModel());
 
   // Exercise the "paste enabled?" check in the verifier.
-  SetClipboardText("Test");
+  SetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE, "Test");
   VerifyTextfieldContextMenuContents(true, true, GetContextMenuModel());
 }
 
 TEST_F(TextfieldTest, DoubleAndTripleClickTest) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
   ui::MouseEvent click(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
                        ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
@@ skipping 310 matching lines @@
   EXPECT_EQ(8U, textfield_->GetCursorPosition());
   SendKeyEvent(ui::VKEY_LEFT, false, true);
   EXPECT_EQ(5U, textfield_->GetCursorPosition());
   SendKeyEvent(ui::VKEY_LEFT, true, true);
   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("Test");
+  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);
-  EXPECT_STR_EQ("Test", base::string16(GetClipboardText()));
+  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);
   EXPECT_STR_EQ("read only", textfield_->text());
 
   // Copy should work normally.
-  SetClipboardText("Test");
+  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", base::string16(GetClipboardText()));
-  SetClipboardText("Test");
+  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", base::string16(GetClipboardText()));
-  SetClipboardText("Test");
+  EXPECT_STR_EQ("read only", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
+  SetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE, "Test");
   SendKeyEvent(ui::VKEY_INSERT, false, true);
-  EXPECT_STR_EQ("read only", base::string16(GetClipboardText()));
+  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.
   SendKeyEvent(ui::VKEY_DELETE);
@@ skipping 204 matching lines @@
 }
 
 TEST_F(TextfieldTest, CutCopyPaste) {
   InitTextfield();
 
   // Ensure IDS_APP_CUT cuts.
   textfield_->SetText(ASCIIToUTF16("123"));
   textfield_->SelectAll(false);
   EXPECT_TRUE(textfield_->IsCommandIdEnabled(IDS_APP_CUT));
   textfield_->ExecuteCommand(IDS_APP_CUT, 0);
-  EXPECT_STR_EQ("123", base::string16(GetClipboardText()));
+  EXPECT_STR_EQ("123", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_STR_EQ("", textfield_->text());
 
   // Ensure [Ctrl]+[x] cuts and [Ctrl]+[Alt][x] does nothing.
   textfield_->SetText(ASCIIToUTF16("456"));
   textfield_->SelectAll(false);
   SendKeyEvent(ui::VKEY_X, true, false, true, false);
-  EXPECT_STR_EQ("123", base::string16(GetClipboardText()));
+  EXPECT_STR_EQ("123", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_STR_EQ("456", textfield_->text());
   SendKeyEvent(ui::VKEY_X, false, true);
-  EXPECT_STR_EQ("456", base::string16(GetClipboardText()));
+  EXPECT_STR_EQ("456", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_STR_EQ("", textfield_->text());
 
   // Ensure [Shift]+[Delete] cuts.
   textfield_->SetText(ASCIIToUTF16("123"));
   textfield_->SelectAll(false);
   SendKeyEvent(ui::VKEY_DELETE, true, false);
-  EXPECT_STR_EQ("123", base::string16(GetClipboardText()));
+  EXPECT_STR_EQ("123", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_STR_EQ("", textfield_->text());
 
   // 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", base::string16(GetClipboardText()));
+  EXPECT_STR_EQ("789", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
 
   // 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", base::string16(GetClipboardText()));
+  EXPECT_STR_EQ("789", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   SendKeyEvent(ui::VKEY_C, false, true);
-  EXPECT_STR_EQ("012", base::string16(GetClipboardText()));
+  EXPECT_STR_EQ("012", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
 
   // Ensure [Ctrl]+[Insert] copies.
   textfield_->SetText(ASCIIToUTF16("345"));
   textfield_->SelectAll(false);
   SendKeyEvent(ui::VKEY_INSERT, false, true);
-  EXPECT_STR_EQ("345", base::string16(GetClipboardText()));
+  EXPECT_STR_EQ("345", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_STR_EQ("345", textfield_->text());
 
   // Ensure IDS_APP_PASTE, [Ctrl]+[V], and [Shift]+[Insert] pastes;
   // also ensure that [Ctrl]+[Alt]+[V] does nothing.
-  SetClipboardText("abc");
+  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);
   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", base::string16(GetClipboardText()));
+  EXPECT_STR_EQ("abc", GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_STR_EQ("abcabcabc", textfield_->text());
 }
 
 TEST_F(TextfieldTest, OvertypeMode) {
   InitTextfield();
   // Overtype mode should be disabled (no-op [Insert]).
   textfield_->SetText(ASCIIToUTF16("2"));
   SendKeyEvent(ui::VKEY_HOME);
   SendKeyEvent(ui::VKEY_INSERT);
   SendKeyEvent(ui::VKEY_1, false, false);
@@ skipping 391 matching lines @@
   textfield_->OnMousePressed(press_event);
   EXPECT_EQ(gfx::Range(4, 7), textfield_->GetSelectedRange());
 
   // Drag the mouse to the beginning of the textfield.
   ui::MouseEvent drag_event(ui::ET_MOUSE_DRAGGED, beginning, beginning,
                             ui::EF_LEFT_MOUSE_BUTTON, 0);
   textfield_->OnMouseDragged(drag_event);
   EXPECT_EQ(gfx::Range(7, 0), textfield_->GetSelectedRange());
 }
 
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+TEST_F(TextfieldTest, SelectionClipboard) {
+  InitTextfield();
+  textfield_->SetText(ASCIIToUTF16("0123"));
+  gfx::Point point_1(GetCursorPositionX(1), 0);
+  gfx::Point point_2(GetCursorPositionX(2), 0);
+  gfx::Point point_3(GetCursorPositionX(3), 0);
+  gfx::Point point_4(GetCursorPositionX(4), 0);
+
+  // Text selected by the mouse should be placed on the selection clipboard.
+  ui::MouseEvent press(ui::ET_MOUSE_PRESSED, point_1, point_1,
+                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
+  textfield_->OnMousePressed(press);
+  ui::MouseEvent drag(ui::ET_MOUSE_DRAGGED, point_3, point_3,
+                      ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
+  textfield_->OnMouseDragged(drag);
+  ui::MouseEvent release(ui::ET_MOUSE_RELEASED, point_3, point_3,
+                         ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
+  textfield_->OnMouseReleased(release);
+  EXPECT_EQ(gfx::Range(1, 3), textfield_->GetSelectedRange());
+  EXPECT_STR_EQ("12", GetClipboardText(ui::CLIPBOARD_TYPE_SELECTION));
+
+  // Select-all should update the selection clipboard.
+  SendKeyEvent(ui::VKEY_A, false, true);
+  EXPECT_EQ(gfx::Range(0, 4), textfield_->GetSelectedRange());
+  EXPECT_STR_EQ("0123", GetClipboardText(ui::CLIPBOARD_TYPE_SELECTION));
+
+  // Shift-click selection modifications should update the clipboard.
+  NonClientMouseClick();
+  ui::MouseEvent press_2(ui::ET_MOUSE_PRESSED, point_2, point_2,
+                         ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
+  press_2.set_flags(press_2.flags() | ui::EF_SHIFT_DOWN);
+  textfield_->OnMousePressed(press_2);
+  ui::MouseEvent release_2(ui::ET_MOUSE_RELEASED, point_2, point_2,
+                           ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
+  textfield_->OnMouseReleased(release_2);
+  EXPECT_EQ(gfx::Range(0, 2), textfield_->GetSelectedRange());
+  EXPECT_STR_EQ("01", GetClipboardText(ui::CLIPBOARD_TYPE_SELECTION));
+
+  // Shift-Left/Right should update the selection clipboard.
+  SendKeyEvent(ui::VKEY_RIGHT, true, false);
+  EXPECT_STR_EQ("012", GetClipboardText(ui::CLIPBOARD_TYPE_SELECTION));
+  SendKeyEvent(ui::VKEY_LEFT, true, false);
+  EXPECT_STR_EQ("01", GetClipboardText(ui::CLIPBOARD_TYPE_SELECTION));
+  SendKeyEvent(ui::VKEY_RIGHT, true, true);
+  EXPECT_STR_EQ("0123", GetClipboardText(ui::CLIPBOARD_TYPE_SELECTION));
+
+  // Moving the cursor without a selection should not change the clipboard.
+  SendKeyEvent(ui::VKEY_LEFT, false, false);
+  EXPECT_EQ(gfx::Range(0, 0), textfield_->GetSelectedRange());
+  EXPECT_STR_EQ("0123", GetClipboardText(ui::CLIPBOARD_TYPE_SELECTION));
+
+  // Middle clicking should paste at the mouse (not cursor) location.
+  ui::MouseEvent middle(ui::ET_MOUSE_PRESSED, point_4, point_4,
+                        ui::EF_MIDDLE_MOUSE_BUTTON, ui::EF_MIDDLE_MOUSE_BUTTON);
+  textfield_->OnMousePressed(middle);
+  EXPECT_STR_EQ("01230123", textfield_->text());
+  EXPECT_EQ(gfx::Range(0, 0), textfield_->GetSelectedRange());
+  EXPECT_STR_EQ("0123", GetClipboardText(ui::CLIPBOARD_TYPE_SELECTION));
+
+  // Middle click pasting should adjust trailing cursors.
+  textfield_->SelectRange(gfx::Range(5, 5));
+  textfield_->OnMousePressed(middle);
+  EXPECT_STR_EQ("012301230123", textfield_->text());
+  EXPECT_EQ(gfx::Range(9, 9), textfield_->GetSelectedRange());
+
+  // Middle click pasting should adjust trailing selections.
+  textfield_->SelectRange(gfx::Range(7, 9));
+  textfield_->OnMousePressed(middle);
+  EXPECT_STR_EQ("0123012301230123", textfield_->text());
+  EXPECT_EQ(gfx::Range(11, 13), textfield_->GetSelectedRange());
+
+  // Middle clicking in the selection should clear the clipboard and selection.
+  textfield_->SelectRange(gfx::Range(2, 6));
+  textfield_->OnMousePressed(middle);
+  EXPECT_STR_EQ("0123012301230123", textfield_->text());
+  EXPECT_EQ(gfx::Range(6, 6), textfield_->GetSelectedRange());
+  EXPECT_TRUE(GetClipboardText(ui::CLIPBOARD_TYPE_SELECTION).empty());
+
+  // Double and triple clicking should update the clipboard contents.
+  textfield_->SetText(ASCIIToUTF16("ab cd ef"));
+  gfx::Point word(GetCursorPositionX(4), 0);
+  ui::MouseEvent press_word(ui::ET_MOUSE_PRESSED, word, word,
+                            ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
+  textfield_->OnMousePressed(press_word);
+  ui::MouseEvent release_word(ui::ET_MOUSE_RELEASED, word, word,
+                              ui::EF_LEFT_MOUSE_BUTTON,
+                              ui::EF_LEFT_MOUSE_BUTTON);
+  textfield_->OnMouseReleased(release_word);
+  ui::MouseEvent double_click(ui::ET_MOUSE_PRESSED, word, word,
+                              ui::EF_LEFT_MOUSE_BUTTON | ui::EF_IS_DOUBLE_CLICK,
+                              ui::EF_LEFT_MOUSE_BUTTON);
+  textfield_->OnMousePressed(double_click);
+  textfield_->OnMouseReleased(release_word);
+  EXPECT_EQ(gfx::Range(3, 5), textfield_->GetSelectedRange());
+  EXPECT_STR_EQ("cd", GetClipboardText(ui::CLIPBOARD_TYPE_SELECTION));
+  textfield_->OnMousePressed(press_word);
+  textfield_->OnMouseReleased(release_word);
+  EXPECT_EQ(gfx::Range(0, 8), textfield_->GetSelectedRange());
+  EXPECT_STR_EQ("ab cd ef", GetClipboardText(ui::CLIPBOARD_TYPE_SELECTION));
+}
+#endif
+
 // Touch selection and dragging currently only works for chromeos.
 #if defined(OS_CHROMEOS)
 TEST_F(TextfieldTest, TouchSelectionAndDraggingTest) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
   EXPECT_FALSE(GetTouchSelectionController());
   const int x = GetCursorPositionX(2);
   GestureEventForTest tap(ui::ET_GESTURE_TAP, x, 0, 1.0f, 0.0f);
   GestureEventForTest tap_down(ui::ET_GESTURE_TAP_DOWN, x, 0, 0.0f, 0.0f);
   GestureEventForTest long_press(ui::ET_GESTURE_LONG_PRESS, x, 0, 0.0f, 0.0f);
@@ skipping 104 matching lines @@
   // Set text which may fall back to a font which has taller baseline than
   // the default font.
   textfield_->SetText(UTF8ToUTF16("\xE0\xB9\x91"));
   const int new_baseline = textfield_->GetBaseline();
 
   // Regardless of the text, the baseline must be the same.
   EXPECT_EQ(new_baseline, old_baseline);
 }
 
 }  // namespace views