RenderTextHarfBuzz: Add support for multi line text selection.

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 <stddef.h>
 #include <stdint.h>
 
 #include <set>
@@ skipping 580 matching lines @@
 
   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();
   }
 
+  int GetCursorYForTesting() {
+    return test_api_->GetRenderText()->GetLineOffset(0).y() + 1;
+  }
+
   // Get the current cursor bounds.
   gfx::Rect GetCursorBounds() {
     return test_api_->GetRenderText()->GetUpdatedCursorBounds();
   }
 
   // Get the cursor bounds of |sel|.
   gfx::Rect GetCursorBounds(const gfx::SelectionModel& sel) {
     return test_api_->GetRenderText()->GetCursorBounds(sel, true);
   }
 
@@ skipping 773 matching lines @@
   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.
   widget_->GetFocusManager()->AdvanceFocus(true);
   EXPECT_EQ(3, GetFocusedView()->id());
-  MoveMouseTo(gfx::Point());
+  MoveMouseTo(gfx::Point(0, GetCursorYForTesting()));
   ClickLeftMouseButton();
   EXPECT_EQ(1, GetFocusedView()->id());
 
   // Tab/Shift+Tab should also cycle focus, not insert a tab character.
   SendKeyEvent(ui::VKEY_TAB, false, false);
   EXPECT_EQ(2, GetFocusedView()->id());
   SendKeyEvent(ui::VKEY_TAB, false, false);
   EXPECT_EQ(3, GetFocusedView()->id());
   // Cycle back to the first textfield.
   SendKeyEvent(ui::VKEY_TAB, false, false);
@@ skipping 31 matching lines @@
   // Exercise the "paste enabled?" check in the verifier.
   SetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE, "Test");
   VerifyTextfieldContextMenuContents(true, true, GetContextMenuModel());
 }
 
 TEST_F(TextfieldTest, DoubleAndTripleClickTest) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
   // Test for double click.
-  MoveMouseTo(gfx::Point());
+  MoveMouseTo(gfx::Point(0, GetCursorYForTesting()));
   ClickLeftMouseButton();
   EXPECT_TRUE(textfield_->GetSelectedText().empty());
   ClickLeftMouseButton(ui::EF_IS_DOUBLE_CLICK);
   EXPECT_STR_EQ("hello", textfield_->GetSelectedText());
 
   // Test for triple click.
   ClickLeftMouseButton();
   EXPECT_STR_EQ("hello world", textfield_->GetSelectedText());
 
   // Another click should reset back to double click.
   ClickLeftMouseButton();
   EXPECT_STR_EQ("hello", textfield_->GetSelectedText());
 }
 
 // Tests text selection behavior on a right click.
 TEST_F(TextfieldTest, SelectWordOnRightClick) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
   // Verify right clicking within the selection does not alter the selection.
   textfield_->SelectRange(gfx::Range(1, 5));
   EXPECT_STR_EQ("ello", textfield_->GetSelectedText());
-  MoveMouseTo(gfx::Point(GetCursorPositionX(3), 0));
+  const int cursor_y = GetCursorYForTesting();
+  MoveMouseTo(gfx::Point(GetCursorPositionX(3), cursor_y));
   ClickRightMouseButton();
   EXPECT_STR_EQ("ello", textfield_->GetSelectedText());
 
   // Verify right clicking outside the selection, selects the word under the
   // cursor on platforms where this is expected.
-  MoveMouseTo(gfx::Point(GetCursorPositionX(8), 0));
+  MoveMouseTo(gfx::Point(GetCursorPositionX(8), cursor_y));
   const char* expected_right_click =
       PlatformStyle::kSelectWordOnRightClick ? "world" : "ello";
   ClickRightMouseButton();
   EXPECT_STR_EQ(expected_right_click, textfield_->GetSelectedText());
 }
 
 TEST_F(TextfieldTest, DragToSelect) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
   const int kStart = GetCursorPositionX(5);
   const int kEnd = 500;
-  gfx::Point start_point(kStart, 0);
-  gfx::Point end_point(kEnd, 0);
+  const int cursor_y = GetCursorYForTesting();
+  gfx::Point start_point(kStart, cursor_y);
+  gfx::Point end_point(kEnd, cursor_y);
 
   MoveMouseTo(start_point);
   PressLeftMouseButton();
   EXPECT_TRUE(textfield_->GetSelectedText().empty());
 
   // Check that dragging left selects the beginning of the string.
-  DragMouseTo(gfx::Point());
+  DragMouseTo(gfx::Point(0, cursor_y));
   base::string16 text_left = textfield_->GetSelectedText();
   EXPECT_STR_EQ("hello", text_left);
 
   // Check that dragging right selects the rest of the string.
   DragMouseTo(end_point);
   base::string16 text_right = textfield_->GetSelectedText();
   EXPECT_STR_EQ(" world", text_right);
 
   // Check that releasing in the same location does not alter the selection.
   ReleaseLeftMouseButton();
   EXPECT_EQ(text_right, textfield_->GetSelectedText());
 
   // Check that dragging from beyond the text length works too.
   MoveMouseTo(end_point);
   PressLeftMouseButton();
-  DragMouseTo(gfx::Point());
+  DragMouseTo(gfx::Point(0, cursor_y));
   ReleaseLeftMouseButton();
   EXPECT_EQ(textfield_->text(), textfield_->GetSelectedText());
 }
 
 // This test checks that dragging above the textfield selects to the beginning
 // and dragging below the textfield selects to the end, but only on platforms
 // where that is the expected behavior.
 TEST_F(TextfieldTest, DragUpOrDownSelectsToEnd) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
   const base::string16 expected_up = base::ASCIIToUTF16(
-      PlatformStyle::kTextDragVerticallyDragsToEnd ? "hello" : "lo");
+      gfx::RenderText::kDragToEndIfOutsideVerticalBounds ? "hello" : "lo");
   const base::string16 expected_down = base::ASCIIToUTF16(
-      PlatformStyle::kTextDragVerticallyDragsToEnd ? " world" : " w");
+      gfx::RenderText::kDragToEndIfOutsideVerticalBounds ? " world" : " w");
   const int kStartX = GetCursorPositionX(5);
   const int kDownX = GetCursorPositionX(7);
   const int kUpX = GetCursorPositionX(3);
-  gfx::Point start_point(kStartX, 0);
+  gfx::Point start_point(kStartX, GetCursorYForTesting());
   gfx::Point down_point(kDownX, 500);
   gfx::Point up_point(kUpX, -500);
 
   MoveMouseTo(start_point);
   PressLeftMouseButton();
   DragMouseTo(up_point);
   ReleaseLeftMouseButton();
   EXPECT_EQ(textfield_->GetSelectedText(), expected_up);
 
   // Click at |up_point|. This is important because drags do not count as clicks
@@ skipping 65 matching lines @@
 
 TEST_F(TextfieldTest, DragAndDrop_InitiateDrag) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello string world"));
 
   // Ensure the textfield will provide selected text for drag data.
   base::string16 string;
   ui::OSExchangeData data;
   const gfx::Range kStringRange(6, 12);
   textfield_->SelectRange(kStringRange);
-  const gfx::Point kStringPoint(GetCursorPositionX(9), 0);
+  const gfx::Point kStringPoint(GetCursorPositionX(9), GetCursorYForTesting());
   textfield_->WriteDragDataForView(NULL, kStringPoint, &data);
   EXPECT_TRUE(data.GetString(&string));
   EXPECT_EQ(textfield_->GetSelectedText(), string);
 
   // Ensure that disabled textfields do not support drag operations.
   textfield_->SetEnabled(false);
   EXPECT_EQ(ui::DragDropTypes::DRAG_NONE,
             textfield_->GetDragOperationsForView(NULL, kStringPoint));
   textfield_->SetEnabled(true);
   // Ensure that textfields without selections do not support drag operations.
@@ skipping 18 matching lines @@
   EXPECT_TRUE(textfield_->CanStartDragForView(NULL, kStringPoint,
                                               gfx::Point()));
   // Ensure that textfields support local moves.
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY,
       textfield_->GetDragOperationsForView(textfield_, kStringPoint));
 }
 
 TEST_F(TextfieldTest, DragAndDrop_ToTheRight) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
+  const int cursor_y = GetCursorYForTesting();
 
   base::string16 string;
   ui::OSExchangeData data;
   int formats = 0;
   int operations = 0;
   std::set<ui::Clipboard::FormatType> format_types;
 
   // Start dragging "ello".
   textfield_->SelectRange(gfx::Range(1, 5));
-  gfx::Point point(GetCursorPositionX(3), 0);
+  gfx::Point point(GetCursorPositionX(3), cursor_y);
   MoveMouseTo(point);
   PressLeftMouseButton();
   EXPECT_TRUE(textfield_->CanStartDragForView(textfield_, point, point));
   operations = textfield_->GetDragOperationsForView(textfield_, point);
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY,
             operations);
   textfield_->WriteDragDataForView(nullptr, point, &data);
   EXPECT_TRUE(data.GetString(&string));
   EXPECT_EQ(textfield_->GetSelectedText(), string);
   EXPECT_TRUE(textfield_->GetDropFormats(&formats, &format_types));
   EXPECT_EQ(ui::OSExchangeData::STRING, formats);
   EXPECT_TRUE(format_types.empty());
 
   // Drop "ello" after "w".
-  const gfx::Point kDropPoint(GetCursorPositionX(7), 0);
+  const gfx::Point kDropPoint(GetCursorPositionX(7), cursor_y);
   EXPECT_TRUE(textfield_->CanDrop(data));
   ui::DropTargetEvent drop_a(data, kDropPoint, kDropPoint, operations);
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE, textfield_->OnDragUpdated(drop_a));
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE, textfield_->OnPerformDrop(drop_a));
   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_Z, true, true);
   EXPECT_STR_EQ("hello world", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, true, true);
   EXPECT_STR_EQ("h welloorld", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, true, true);
   EXPECT_STR_EQ("h welloorld", textfield_->text());
 }
 
 TEST_F(TextfieldTest, DragAndDrop_ToTheLeft) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
+  const int cursor_y = GetCursorYForTesting();
 
   base::string16 string;
   ui::OSExchangeData data;
   int formats = 0;
   int operations = 0;
   std::set<ui::Clipboard::FormatType> format_types;
 
   // Start dragging " worl".
   textfield_->SelectRange(gfx::Range(5, 10));
-  gfx::Point point(GetCursorPositionX(7), 0);
+  gfx::Point point(GetCursorPositionX(7), cursor_y);
   MoveMouseTo(point);
   PressLeftMouseButton();
   EXPECT_TRUE(textfield_->CanStartDragForView(textfield_, point, gfx::Point()));
   operations = textfield_->GetDragOperationsForView(textfield_, point);
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY,
             operations);
   textfield_->WriteDragDataForView(nullptr, point, &data);
   EXPECT_TRUE(data.GetString(&string));
   EXPECT_EQ(textfield_->GetSelectedText(), string);
   EXPECT_TRUE(textfield_->GetDropFormats(&formats, &format_types));
   EXPECT_EQ(ui::OSExchangeData::STRING, formats);
   EXPECT_TRUE(format_types.empty());
 
   // Drop " worl" after "h".
   EXPECT_TRUE(textfield_->CanDrop(data));
-  gfx::Point drop_point(GetCursorPositionX(1), 0);
+  gfx::Point drop_point(GetCursorPositionX(1), cursor_y);
   ui::DropTargetEvent drop_a(data, drop_point, drop_point, operations);
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE, textfield_->OnDragUpdated(drop_a));
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE, textfield_->OnPerformDrop(drop_a));
   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_Z, true, true);
   EXPECT_STR_EQ("hello world", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, true, true);
   EXPECT_STR_EQ("h worlellod", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, true, true);
   EXPECT_STR_EQ("h worlellod", textfield_->text());
 }
 
 TEST_F(TextfieldTest, DragAndDrop_Canceled) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
+  const int cursor_y = GetCursorYForTesting();
 
   // Start dragging "worl".
   textfield_->SelectRange(gfx::Range(6, 10));
-  gfx::Point point(GetCursorPositionX(8), 0);
+  gfx::Point point(GetCursorPositionX(8), cursor_y);
   MoveMouseTo(point);
   PressLeftMouseButton();
   ui::OSExchangeData data;
   textfield_->WriteDragDataForView(nullptr, point, &data);
   EXPECT_TRUE(textfield_->CanDrop(data));
   // Drag the text over somewhere valid, outside the current selection.
-  gfx::Point drop_point(GetCursorPositionX(2), 0);
+  gfx::Point drop_point(GetCursorPositionX(2), cursor_y);
   ui::DropTargetEvent drop(data, drop_point, drop_point,
                            ui::DragDropTypes::DRAG_MOVE);
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE, textfield_->OnDragUpdated(drop));
   // "Cancel" the drag, via move and release over the selection, and OnDragDone.
-  gfx::Point drag_point(GetCursorPositionX(9), 0);
+  gfx::Point drag_point(GetCursorPositionX(9), cursor_y);
   DragMouseTo(drag_point);
   ReleaseLeftMouseButton();
   EXPECT_EQ(ASCIIToUTF16("hello world"), textfield_->text());
 }
 
 TEST_F(TextfieldTest, ReadOnlyTest) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("read only"));
   textfield_->SetReadOnly(true);
   EXPECT_TRUE(textfield_->enabled());
@@ skipping 842 matching lines @@
 
   // Drag the mouse to the beginning of the textfield.
   DragMouseTo(beginning);
   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);
+  const int cursor_y = GetCursorYForTesting();
+  gfx::Point point_1(GetCursorPositionX(1), cursor_y);
+  gfx::Point point_2(GetCursorPositionX(2), cursor_y);
+  gfx::Point point_3(GetCursorPositionX(3), cursor_y);
+  gfx::Point point_4(GetCursorPositionX(4), cursor_y);
 
   // Text selected by the mouse should be placed on the selection clipboard.
   ui::MouseEvent press(ui::ET_MOUSE_PRESSED, point_1, point_1,
                        ui::EventTimeForNow(), 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::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
                       ui::EF_LEFT_MOUSE_BUTTON);
   textfield_->OnMouseDragged(drag);
@@ skipping 77 matching lines @@
   // Middle clicking in the selection should clear the clipboard and selection.
   SetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE, "foo");
   textfield_->SelectRange(gfx::Range(2, 6));
   textfield_->OnMousePressed(middle);
   EXPECT_STR_EQ("012301230123", 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);
+  gfx::Point word(GetCursorPositionX(4), cursor_y);
   ui::MouseEvent press_word(ui::ET_MOUSE_PRESSED, word, word,
                             ui::EventTimeForNow(), 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::EventTimeForNow(), 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::EventTimeForNow(),
@@ skipping 64 matching lines @@
 }
 #endif
 
 // Long_Press gesture in Textfield can initiate a drag and drop now.
 TEST_F(TextfieldTest, TestLongPressInitiatesDragDrop) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("Hello string world"));
 
   // Ensure the textfield will provide selected text for drag data.
   textfield_->SelectRange(gfx::Range(6, 12));
-  const gfx::Point kStringPoint(GetCursorPositionX(9), 0);
+  const gfx::Point kStringPoint(GetCursorPositionX(9), GetCursorYForTesting());
 
   // Enable touch-drag-drop to make long press effective.
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableTouchDragDrop);
 
   // Create a long press event in the selected region should start a drag.
   GestureEventForTest long_press(
       kStringPoint.x(),
       kStringPoint.y(),
       ui::GestureEventDetails(ui::ET_GESTURE_LONG_PRESS));
@@ skipping 200 matching lines @@
   ui::AXNodeData node_data_protected;
   node_data_protected.state = 0;
   textfield_->GetAccessibleNodeData(&node_data_protected);
   EXPECT_EQ(ui::AX_ROLE_TEXT_FIELD, node_data_protected.role);
   EXPECT_EQ(ASCIIToUTF16("********"),
             node_data_protected.GetString16Attribute(ui::AX_ATTR_VALUE));
   EXPECT_TRUE(node_data_protected.HasStateFlag(ui::AX_STATE_PROTECTED));
 }
 
 }  // namespace views