views: add SelectionController test coverage

This change is in preparation for a fix to the right-click selection behavior
on Mac.

This change also has RenderTextHarfBuzz EnsureLayout() when getting a substring
range.

Bug: 856609
Change-Id: I85c81c630fc2e6ac79d01a7a25a6f3e30756fdb5
Reviewed-on: https://chromium-review.googlesource.com/1156844
Commit-Queue: Elly Fong-Jones <ellyjones@chromium.org>
Reviewed-by: Michael Wasserman <msw@chromium.org>
Cr-Commit-Position: refs/heads/master@{#579820}

ui/gfx/render_text_harfbuzz.cc

@@ -1436,6 +1436,7 @@ SelectionModel RenderTextHarfBuzz::AdjacentWordSelectionModel(
 }
 
 std::vector<Rect> RenderTextHarfBuzz::GetSubstringBounds(const Range& range) {
+  EnsureLayout();
   DCHECK(!update_display_run_list_);
   DCHECK(Range(0, text().length()).Contains(range));
   const size_t start =

ui/views/BUILD.gn

@@ -988,6 +988,7 @@ source_set("views_unittests_sources") {
     "layout/grid_layout_unittest.cc",
     "paint_info_unittest.cc",
     "rect_based_targeting_utils_unittest.cc",
+    "selection_controller_unittest.cc",
     "test/widget_test_unittest.cc",
     "view_model_unittest.cc",
     "view_model_utils_unittest.cc",

ui/views/selection_controller_unittest.cc

+// Copyright 2018 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/selection_controller.h"
+#include "base/macros.h"
+#include "base/strings/utf_string_conversions.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/events/event.h"
+#include "ui/events/event_constants.h"
+#include "ui/gfx/render_text.h"
+#include "ui/views/metrics.h"
+#include "ui/views/selection_controller_delegate.h"
+#include "ui/views/style/platform_style.h"
+
+namespace views {
+namespace {
+
+const gfx::Point CenterLeft(const gfx::Rect& rect) {
+  return gfx::Point(rect.x(), rect.CenterPoint().y());
+}
+
+const gfx::Point CenterRight(const gfx::Rect& rect) {
+  return gfx::Point(rect.right(), rect.CenterPoint().y());
+}
+
+class TestSelectionControllerDelegate : public SelectionControllerDelegate {
+ public:
+  TestSelectionControllerDelegate(gfx::RenderText* render_text)
+      : render_text_(render_text) {}
+  ~TestSelectionControllerDelegate() override = default;
+
+  gfx::RenderText* GetRenderTextForSelectionController() override {
+    return render_text_;
+  }
+
+  bool IsReadOnly() const override { return true; }
+  bool SupportsDrag() const override { return true; }
+  bool HasTextBeingDragged() const override { return false; }
+  void SetTextBeingDragged(bool value) override {}
+  int GetViewHeight() const override {
+    return render_text_->GetStringSize().height();
+  }
+  int GetViewWidth() const override {
+    return render_text_->GetStringSize().width();
+  }
+  int GetDragSelectionDelay() const override { return 0; }
+  void OnBeforePointerAction() override {}
+  void OnAfterPointerAction(bool text_changed,
+                            bool selection_changed) override {}
+  bool PasteSelectionClipboard() override { return false; }
+  void UpdateSelectionClipboard() override {}
+
+ private:
+  gfx::RenderText* render_text_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestSelectionControllerDelegate);
+};
+
+class SelectionControllerTest : public ::testing::Test {
+ public:
+  void SetUp() override {
+    render_text_ = gfx::RenderText::CreateHarfBuzzInstance();
+    delegate_ =
+        std::make_unique<TestSelectionControllerDelegate>(render_text_.get());
+    controller_ = std::make_unique<SelectionController>(delegate_.get());
+  }
+
+  SelectionControllerTest() = default;
+  ~SelectionControllerTest() override = default;
+
+  void SetText(const std::string& text) {
+    render_text_->SetText(base::ASCIIToUTF16(text));
+  }
+
+  std::string GetSelectedText() {
+    return base::UTF16ToASCII(
+        render_text_->GetTextFromRange(render_text_->selection()));
+  }
+
+  void LeftMouseDown(const gfx::Point& location, bool focused = false) {
+    PressMouseButton(location, ui::EF_LEFT_MOUSE_BUTTON, focused);
+  }
+
+  void LeftMouseUp() { ReleaseMouseButton(ui::EF_LEFT_MOUSE_BUTTON); }
+
+  void DragMouse(const gfx::Point& location) {
+    mouse_location_ = location;
+    controller_->OnMouseDragged(ui::MouseEvent(ui::ET_MOUSE_DRAGGED, location,
+                                               location, last_event_time_,
+                                               mouse_flags_, 0));
+  }
+
+  void RightMouseDown(const gfx::Point& location, bool focused = false) {
+    PressMouseButton(location, ui::EF_RIGHT_MOUSE_BUTTON, focused);
+  }
+
+  void RightMouseUp() { ReleaseMouseButton(ui::EF_RIGHT_MOUSE_BUTTON); }
+
+  const gfx::Rect BoundsOfChar(int index) {
+    return render_text_->GetSubstringBounds(gfx::Range(index, index + 1))[0];
+  }
+
+ private:
+  void PressMouseButton(const gfx::Point& location, int button, bool focused) {
+    DCHECK(!(mouse_flags_ & button));
+    mouse_flags_ |= button;
+    mouse_location_ = location;
+    // Ensure that mouse presses are spaced apart by at least the double-click
+    // interval to avoid triggering a double-click.
+    last_event_time_ +=
+        base::TimeDelta::FromMilliseconds(views::GetDoubleClickInterval() + 1);
+    controller_->OnMousePressed(
+        ui::MouseEvent(ui::ET_MOUSE_PRESSED, location, location,
+                       last_event_time_, mouse_flags_, button),
+        false,
+        focused ? SelectionController::FOCUSED
+                : SelectionController::UNFOCUSED);
+  }
+
+  void ReleaseMouseButton(int button) {
+    DCHECK(mouse_flags_ & button);
+    mouse_flags_ &= ~button;
+    controller_->OnMouseReleased(
+        ui::MouseEvent(ui::ET_MOUSE_RELEASED, mouse_location_, mouse_location_,
+                       last_event_time_, mouse_flags_, button));
+  }
+
+  std::unique_ptr<gfx::RenderText> render_text_;
+  std::unique_ptr<TestSelectionControllerDelegate> delegate_;
+  std::unique_ptr<SelectionController> controller_;
+
+  int mouse_flags_ = 0;
+  gfx::Point mouse_location_;
+  base::TimeTicks last_event_time_;
+
+  DISALLOW_COPY_AND_ASSIGN(SelectionControllerTest);
+};
+
+TEST_F(SelectionControllerTest, ClickAndDragToSelect) {
+  SetText("abc def");
+  EXPECT_EQ("", GetSelectedText());
+
+  LeftMouseDown(CenterLeft(BoundsOfChar(0)));
+  DragMouse(CenterRight(BoundsOfChar(0)));
+  EXPECT_EQ("a", GetSelectedText());
+
+  DragMouse(CenterRight(BoundsOfChar(2)));
+  EXPECT_EQ("abc", GetSelectedText());
+
+  LeftMouseUp();
+  EXPECT_EQ("abc", GetSelectedText());
+
+  LeftMouseDown(CenterRight(BoundsOfChar(3)));
+  EXPECT_EQ("", GetSelectedText());
+
+  DragMouse(CenterRight(BoundsOfChar(4)));
+  EXPECT_EQ("d", GetSelectedText());
+}
+
+TEST_F(SelectionControllerTest, RightClickWhenUnfocused) {
+  SetText("abc def");
+
+  RightMouseDown(CenterRight(BoundsOfChar(0)));
+  if (PlatformStyle::kSelectAllOnRightClickWhenUnfocused)
+    EXPECT_EQ("abc def", GetSelectedText());
+  else
+    EXPECT_EQ("", GetSelectedText());
+}
+
+// This tests the current incorrect behavior. When the behavior is fixed this
+// test can be updated.
+// TODO(ellyjones): Do that - https://crbug.com/856609
+TEST_F(SelectionControllerTest, RightClickPastEndSelectsLastWord) {
+  SetText("abc def");
+
+  RightMouseDown(CenterRight(BoundsOfChar(6)), true);
+  if (PlatformStyle::kSelectWordOnRightClick)
+    EXPECT_EQ("def", GetSelectedText());
+  else
+    EXPECT_EQ("", GetSelectedText());
+}
+
+}  // namespace
+}  // namespace views