Views: Extract text selection code from Textfield.

ui/views/controls/textfield/textfield.cc

 // Copyright (c) 2012 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 <string>
 #include <utility>
 
 #include "base/trace_event/trace_event.h"
@@ skipping 21 matching lines @@
 #include "ui/gfx/selection_bound.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/background.h"
 #include "ui/views/controls/focusable_border.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/controls/native/native_view_host.h"
 #include "ui/views/controls/textfield/textfield_controller.h"
 #include "ui/views/drag_utils.h"
-#include "ui/views/metrics.h"
 #include "ui/views/native_cursor.h"
 #include "ui/views/painter.h"
+#include "ui/views/selection_controller.h"
 #include "ui/views/style/platform_style.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(OS_WIN)
 #include "base/win/win_util.h"
 #include "ui/base/win/osk_display_manager.h"
 #endif
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
@@ skipping 22 matching lines @@
 const SkColor kDefaultPlaceholderTextColor = SK_ColorLTGRAY;
 
 void ConvertRectToScreen(const View* src, gfx::Rect* r) {
   DCHECK(src);
 
   gfx::Point new_origin = r->origin();
   View::ConvertPointToScreen(src, &new_origin);
   r->set_origin(new_origin);
 }
 
-// Get the drag selection timer delay, respecting animation scaling for testing.
-int GetDragSelectionDelay() {
-  switch (ui::ScopedAnimationDurationScaleMode::duration_scale_mode()) {
-      case ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION: return 100;
-      case ui::ScopedAnimationDurationScaleMode::FAST_DURATION:   return 25;
-      case ui::ScopedAnimationDurationScaleMode::SLOW_DURATION:   return 400;
-      case ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION:   return 1;
-      case ui::ScopedAnimationDurationScaleMode::ZERO_DURATION:   return 0;
-    }
-  return 100;
-}
-
 // Get the default command for a given key |event|.
 ui::TextEditCommand GetCommandForKeyEvent(const ui::KeyEvent& event) {
   if (event.type() != ui::ET_KEY_PRESSED || event.IsUnicodeKeyCode())
     return ui::TextEditCommand::INVALID_COMMAND;
 
   const bool shift = event.IsShiftDown();
   const bool control = event.IsControlDown();
   const bool alt = event.IsAltDown() || event.IsAltGrDown();
   switch (event.key_code()) {
     case ui::VKEY_Z:
@@ skipping 138 matching lines @@
       use_default_selection_text_color_(true),
       use_default_selection_background_color_(true),
       text_color_(SK_ColorBLACK),
       background_color_(SK_ColorWHITE),
       selection_text_color_(SK_ColorWHITE),
       selection_background_color_(SK_ColorBLUE),
       placeholder_text_color_(kDefaultPlaceholderTextColor),
       text_input_type_(ui::TEXT_INPUT_TYPE_TEXT),
       text_input_flags_(0),
       performing_user_action_(false),
+      performing_mouse_action_(false),
       skip_input_method_cancel_composition_(false),
       drop_cursor_visible_(false),
       initiating_drag_(false),
-      aggregated_clicks_(0),
+      selection_controller_(new SelectionController(this)),
       drag_start_display_offset_(0),
       touch_handles_hidden_due_to_scroll_(false),
       weak_ptr_factory_(this) {
   set_context_menu_controller(this);
   set_drag_controller(this);
   GetRenderText()->SetFontList(GetDefaultFontList());
   SetBorder(std::unique_ptr<Border>(new FocusableBorder()));
   SetFocusBehavior(FocusBehavior::ALWAYS);
 
   // These allow BrowserView to pass edit commands from the Chrome menu to us
@@ skipping 53 matching lines @@
     return;
   model_->InsertText(new_text);
   OnCaretBoundsChanged();
   SchedulePaint();
 }
 
 base::string16 Textfield::GetSelectedText() const {
   return model_->GetSelectedText();
 }
 
-void Textfield::SelectAll(bool reversed) {
-  model_->SelectAll(reversed);
-  UpdateSelectionClipboard();
-  UpdateAfterChange(false, true);
-}
-
-void Textfield::SelectWordAt(const gfx::Point& point) {
-  model_->MoveCursorTo(point, false);
-  model_->SelectWord();
-  UpdateAfterChange(false, true);
-}
-
-void Textfield::ClearSelection() {
-  model_->ClearSelection();
-  UpdateAfterChange(false, true);
-}
-
 bool Textfield::HasSelection() const {
   return !GetSelectedRange().is_empty();
 }
 
 SkColor Textfield::GetTextColor() const {
   if (!use_default_text_color_)
     return text_color_;
 
   return GetNativeTheme()->GetSystemColor(read_only() || !enabled() ?
       ui::NativeTheme::kColorId_TextfieldReadOnlyColor :
@@ skipping 114 matching lines @@
 }
 
 bool Textfield::IsIMEComposing() const {
   return model_->HasCompositionText();
 }
 
 const gfx::Range& Textfield::GetSelectedRange() const {
   return GetRenderText()->selection();
 }
 
-void Textfield::SelectRange(const gfx::Range& range) {
-  model_->SelectRange(range);
-  UpdateAfterChange(false, true);
-}
-
 const gfx::SelectionModel& Textfield::GetSelectionModel() const {
   return GetRenderText()->selection_model();
 }
 
 void Textfield::SelectSelectionModel(const gfx::SelectionModel& sel) {
   model_->SelectSelectionModel(sel);
   UpdateAfterChange(false, true);
 }
 
 size_t Textfield::GetCursorPosition() const {
@@ skipping 23 matching lines @@
 }
 
 void Textfield::ClearEditHistory() {
   model_->ClearEditHistory();
 }
 
 void Textfield::SetAccessibleName(const base::string16& name) {
   accessible_name_ = name;
 }
 
-bool Textfield::HasTextBeingDragged() {
-  return initiating_drag_;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // Textfield, View overrides:
 
 gfx::Insets Textfield::GetInsets() const {
   gfx::Insets insets = View::GetInsets();
   insets += gfx::Insets(kTextPadding, kTextPadding, kTextPadding, kTextPadding);
   return insets;
 }
 
 int Textfield::GetBaseline() const {
@@ skipping 11 matching lines @@
 }
 
 gfx::NativeCursor Textfield::GetCursor(const ui::MouseEvent& event) {
   bool in_selection = GetRenderText()->IsPointInSelection(event.location());
   bool drag_event = event.type() == ui::ET_MOUSE_DRAGGED;
   bool text_cursor = !initiating_drag_ && (drag_event || !in_selection);
   return text_cursor ? GetNativeIBeamCursor() : gfx::kNullCursor;
 }
 
 bool Textfield::OnMousePressed(const ui::MouseEvent& event) {
-  TrackMouseClicks(event);
-
-  if (!controller_ || !controller_->HandleMouseEvent(this, event)) {
-    if (event.IsOnlyLeftMouseButton() || event.IsOnlyRightMouseButton()) {
-      RequestFocus();
-      ShowImeIfNeeded();
-    }
-
-    if (event.IsOnlyLeftMouseButton()) {
-      OnBeforeUserAction();
-      initiating_drag_ = false;
-      switch (aggregated_clicks_) {
-        case 0:
-          if (GetRenderText()->IsPointInSelection(event.location()))
-            initiating_drag_ = true;
-          else
-            MoveCursorTo(event.location(), event.IsShiftDown());
-          break;
-        case 1:
-          SelectWordAt(event.location());
-          double_click_word_ = GetRenderText()->selection();
-          break;
-        case 2:
-          SelectAll(false);
-          break;
-        default:
-          NOTREACHED();
-      }
-      OnAfterUserAction();
-    }
-
-#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
-    if (event.IsOnlyMiddleMouseButton()) {
-      if (GetRenderText()->IsPointInSelection(event.location())) {
-        OnBeforeUserAction();
-        ClearSelection();
-        ui::ScopedClipboardWriter(
-            ui::CLIPBOARD_TYPE_SELECTION).WriteText(base::string16());
-        OnAfterUserAction();
-      } else if (!read_only()) {
-        PasteSelectionClipboard(event);
-      }
-    }
-#endif
+  bool handled = controller_ && controller_->HandleMouseEvent(this, event);
+  if (!handled &&
+      (event.IsOnlyLeftMouseButton() || event.IsOnlyRightMouseButton())) {
+    RequestFocus();
+    ShowImeIfNeeded();
   }
 
-  return true;
+  return handled | selection_controller_->OnMousePressed(event, handled);
 }
 
 bool Textfield::OnMouseDragged(const ui::MouseEvent& event) {
-  last_drag_location_ = event.location();
-
-  // Don't adjust the cursor on a potential drag and drop.
-  if (initiating_drag_ || !event.IsOnlyLeftMouseButton())
-    return true;
-
-  // A timer is used to continuously scroll while selecting beyond side edges.
-  const int x = event.location().x();
-  if ((x >= 0 && x <= width()) || GetDragSelectionDelay() == 0) {
-    drag_selection_timer_.Stop();
-    SelectThroughLastDragLocation();
-  } else if (!drag_selection_timer_.IsRunning()) {
-    // Select through the edge of the visible text, then start the scroll timer.
-    last_drag_location_.set_x(std::min(std::max(0, x), width()));
-    SelectThroughLastDragLocation();
-    drag_selection_timer_.Start(
-        FROM_HERE, base::TimeDelta::FromMilliseconds(GetDragSelectionDelay()),
-        this, &Textfield::SelectThroughLastDragLocation);
-  }
-
-  return true;
+  return selection_controller_->OnMouseDragged(event);
 }
 
 void Textfield::OnMouseReleased(const ui::MouseEvent& event) {
-  OnBeforeUserAction();
-  drag_selection_timer_.Stop();
-  // Cancel suspected drag initiations, the user was clicking in the selection.
-  if (initiating_drag_)
-    MoveCursorTo(event.location(), false);
-  initiating_drag_ = false;
-  UpdateSelectionClipboard();
-  OnAfterUserAction();
+  selection_controller_->OnMouseReleased(event);
 }
 
 bool Textfield::OnKeyPressed(const ui::KeyEvent& event) {
   ui::TextEditCommand edit_command = scheduled_text_edit_command_;
   scheduled_text_edit_command_ = ui::TextEditCommand::INVALID_COMMAND;
 
   // Since HandleKeyEvent() might destroy |this|, get a weak pointer and verify
   // it isn't null before proceeding.
   base::WeakPtr<Textfield> textfield(weak_ptr_factory_.GetWeakPtr());
 
@@ skipping 430 matching lines @@
   return drag_operations;
 }
 
 bool Textfield::CanStartDragForView(View* sender,
                                     const gfx::Point& press_pt,
                                     const gfx::Point& p) {
   return initiating_drag_ && GetRenderText()->IsPointInSelection(press_pt);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// Textfield, SelectionControllerHost overrides:
+
+bool Textfield::HasTextBeingDragged() const {
+  return initiating_drag_;
+}
+
+void Textfield::SelectAll(bool reversed) {
+  model_->SelectAll(reversed);
+  if (HasSelection())
+    UpdateSelectionClipboard();

[tapted, 2016/10/11 04:42:09]

this feels like something the SelectionController should be responsible for
managing

[karandeepb, 2016/10/14 09:27:34]

Not sure if this is still relevant. Also, it seems to me that this is redundant
anyway,

+  UpdateAfterChange(false, true);
+}
+
+void Textfield::SelectRange(const gfx::Range& range) {
+  model_->SelectRange(range);
+  UpdateAfterChange(false, true);
+}
+
+void Textfield::ClearSelection() {
+  model_->ClearSelection();
+  UpdateAfterChange(false, true);
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // Textfield, ui::TouchEditable overrides:
 
 void Textfield::SelectRect(const gfx::Point& start, const gfx::Point& end) {
   if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE)
     return;
 
   gfx::SelectionModel start_caret = GetRenderText()->FindCursorPosition(start);
   gfx::SelectionModel end_caret = GetRenderText()->FindCursorPosition(end);
   gfx::SelectionModel selection(
       gfx::Range(start_caret.caret_pos(), end_caret.caret_pos()),
@@ skipping 643 matching lines @@
       break;
     case ui::TextEditCommand::INSERT_TEXT:
     case ui::TextEditCommand::SET_MARK:
     case ui::TextEditCommand::UNSELECT:
     case ui::TextEditCommand::INVALID_COMMAND:
       NOTREACHED();
       break;
   }
 
   cursor_changed |= GetSelectionModel() != selection_model;
-  if (cursor_changed)
+  if (cursor_changed && HasSelection())
     UpdateSelectionClipboard();
   UpdateAfterChange(text_changed, cursor_changed);
   OnAfterUserAction();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Textfield, private:
 
+////////////////////////////////////////////////////////////////////////////////
+// Textfield, SelectionControllerHost overrides:
+
+gfx::RenderText* Textfield::GetRenderTextForSelection() {
+  return GetRenderText();
+}
+
+bool Textfield::IsReadOnly() const {
+  return false;
+}
+
+void Textfield::SetTextBeingDragged(bool value) {
+  initiating_drag_ = value;
+}
+
+int Textfield::GetViewHeight() const {
+  return height();
+}
+
+int Textfield::GetViewWidth() const {
+  return width();
+}
+
+int Textfield::GetDragSelectionDelay() const {
+  switch (ui::ScopedAnimationDurationScaleMode::duration_scale_mode()) {
+    case ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION:
+      return 100;
+    case ui::ScopedAnimationDurationScaleMode::FAST_DURATION:
+      return 25;
+    case ui::ScopedAnimationDurationScaleMode::SLOW_DURATION:
+      return 400;
+    case ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION:
+      return 1;
+    case ui::ScopedAnimationDurationScaleMode::ZERO_DURATION:
+      return 0;
+  }
+  return 100;
+}
+
+void Textfield::OnBeforeMouseAction() {
+  OnBeforeUserAction();
+  DCHECK(!performing_mouse_action_);
+  performing_mouse_action_ = true;
+}
+
+void Textfield::OnAfterMouseAction(bool text_changed, bool selection_changed) {
+  OnAfterUserAction();
+  DCHECK(performing_mouse_action_);
+  performing_mouse_action_ = false;
+  UpdateAfterChange(text_changed, selection_changed);
+}
+
+void Textfield::SelectWordAt(const gfx::Point& point) {
+  model_->MoveCursorTo(point, false);
+  SelectWord();
+}
+
+void Textfield::SelectWord() {
+  model_->SelectWord();
+  UpdateAfterChange(false, true);

[tapted, 2016/10/11 04:42:09]

yeah if these can move into TextfieldModel (or something it inherits from), we
can probably have the SelectionControllerHost interface narrowed down a lot more
-- perhaps just to UpdateAfterChange..

[karandeepb, 2016/10/14 09:27:34]

Have updated SelectionController and narrowed down the
SelectionController::Delegate interface. 

+}
+
+void Textfield::MoveCursorTo(const gfx::Point& point, bool select) {
+  if (model_->MoveCursorTo(point, select))
+    UpdateAfterChange(false, true);
+}
+
+void Textfield::SelectTillEdge(gfx::VisualCursorDirection direction) {
+  GetRenderText()->MoveCursor(gfx::LINE_BREAK, direction,
+                              gfx::SELECTION_RETAIN);
+  UpdateAfterChange(false, true);
+}
+
+void Textfield::PasteSelectionClipboard() {
+  if (read_only())
+    return;
+  const base::string16 selection_clipboard_text = GetSelectionClipboardText();
+  if (!HasFocus())
+    RequestFocus();
+  if (!selection_clipboard_text.empty()) {
+    model_->InsertText(selection_clipboard_text);
+    UpdateAfterChange(true, true);
+  }
+}
+
+void Textfield::UpdateSelectionClipboard() {
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+  if (performing_user_action_ &&
+      text_input_type_ != ui::TEXT_INPUT_TYPE_PASSWORD) {
+    ui::ScopedClipboardWriter(ui::CLIPBOARD_TYPE_SELECTION)
+        .WriteText(GetSelectedText());
+    if (controller_)
+      controller_->OnAfterCutOrCopy(ui::CLIPBOARD_TYPE_SELECTION);
+  }
+#endif
+}
+
 void Textfield::AccessibilitySetValue(const base::string16& new_value) {
   if (!read_only()) {
     SetText(new_value);
     ClearSelection();
   }
 }
 
 void Textfield::UpdateBackgroundColor() {
   const SkColor color = GetBackgroundColor();
   if (ui::MaterialDesignController::IsSecondaryUiMaterial()) {
     set_background(Background::CreateBackgroundPainter(
         true, Painter::CreateSolidRoundRectPainter(
                   color, FocusableBorder::kCornerRadiusDp)));
   } else {
     set_background(Background::CreateSolidBackground(color));
   }
   // Disable subpixel rendering when the background color is transparent
   // because it draws incorrect colors around the glyphs in that case.
   // See crbug.com/115198
   GetRenderText()->set_subpixel_rendering_suppressed(
       SkColorGetA(color) != SK_AlphaOPAQUE);
   SchedulePaint();
 }
 
 void Textfield::UpdateAfterChange(bool text_changed, bool cursor_changed) {
+  if (performing_mouse_action_)
+    return;
   if (text_changed) {
     if (controller_)
       controller_->ContentsChanged(this, text());
     NotifyAccessibilityEvent(ui::AX_EVENT_TEXT_CHANGED, true);
   }
   if (cursor_changed) {
     GetRenderText()->set_cursor_visible(ShouldShowCursor());
     RepaintCursor();
     if (ShouldBlinkCursor())
       StartBlinkingCursor();
@@ skipping 33 matching lines @@
 
   render_text->Draw(canvas);
 
   // Draw the detached drop cursor that marks where the text will be dropped.
   if (drop_cursor_visible_)
     render_text->DrawCursor(canvas, drop_cursor_position_);
 
   canvas->Restore();
 }
 
-void Textfield::MoveCursorTo(const gfx::Point& point, bool select) {
-  if (model_->MoveCursorTo(point, select))
-    UpdateAfterChange(false, true);
-}
-
-void Textfield::SelectThroughLastDragLocation() {
-  OnBeforeUserAction();
-
-  const bool drags_to_end = PlatformStyle::kTextfieldDragVerticallyDragsToEnd;
-  if (drags_to_end && last_drag_location_.y() < 0) {
-    model_->MoveCursor(gfx::BreakType::LINE_BREAK,
-                       gfx::VisualCursorDirection::CURSOR_LEFT,
-                       gfx::SELECTION_RETAIN);
-  } else if (drags_to_end && last_drag_location_.y() > height()) {
-    model_->MoveCursor(gfx::BreakType::LINE_BREAK,
-                       gfx::VisualCursorDirection::CURSOR_RIGHT,
-                       gfx::SELECTION_RETAIN);
-  } else {
-    model_->MoveCursorTo(last_drag_location_, true);
-  }
-
-  if (aggregated_clicks_ == 1) {
-    model_->SelectWord();
-    // Expand the selection so the initially selected word remains selected.
-    gfx::Range selection = GetRenderText()->selection();
-    const size_t min = std::min(selection.GetMin(),
-                                double_click_word_.GetMin());
-    const size_t max = std::max(selection.GetMax(),
-                                double_click_word_.GetMax());
-    const bool reversed = selection.is_reversed();
-    selection.set_start(reversed ? max : min);
-    selection.set_end(reversed ? min : max);
-    model_->SelectRange(selection);
-  }
-  UpdateAfterChange(false, true);
-  OnAfterUserAction();
-}
-
 void Textfield::OnCaretBoundsChanged() {
   if (GetInputMethod())
     GetInputMethod()->OnCaretBoundsChanged(this);
   if (touch_selection_controller_)
     touch_selection_controller_->SelectionChanged();
 }
 
 void Textfield::OnBeforeUserAction() {
   DCHECK(!performing_user_action_);
   performing_user_action_ = true;
@@ skipping 53 matching lines @@
     // IsCommandIdEnabled() as appropriate, for the commands added.
     if (controller_)
       controller_->UpdateContextMenu(context_menu_contents_.get());
   }
   context_menu_runner_.reset(new MenuRunner(context_menu_contents_.get(),
                                             MenuRunner::HAS_MNEMONICS |
                                                 MenuRunner::CONTEXT_MENU |
                                                 MenuRunner::ASYNC));
 }
 
-void Textfield::TrackMouseClicks(const ui::MouseEvent& event) {
-  if (event.IsOnlyLeftMouseButton()) {
-    base::TimeDelta time_delta = event.time_stamp() - last_click_time_;
-    if (!last_click_time_.is_null() &&
-        time_delta.InMilliseconds() <= GetDoubleClickInterval() &&
-        !ExceededDragThreshold(event.location() - last_click_location_)) {
-      // Upon clicking after a triple click, the count should go back to double
-      // click and alternate between double and triple. This assignment maps
-      // 0 to 1, 1 to 2, 2 to 1.
-      aggregated_clicks_ = (aggregated_clicks_ % 2) + 1;
-    } else {
-      aggregated_clicks_ = 0;
-    }
-    last_click_time_ = event.time_stamp();
-    last_click_location_ = event.location();
-  }
-}
-
 bool Textfield::ImeEditingAllowed() const {
   // Disallow input method editing of password fields.
   ui::TextInputType t = GetTextInputType();
   return (t != ui::TEXT_INPUT_TYPE_NONE && t != ui::TEXT_INPUT_TYPE_PASSWORD);
 }
 
 void Textfield::RevealPasswordChar(int index) {
   GetRenderText()->SetObscuredRevealIndex(index);
   SchedulePaint();
 
   if (index != -1) {
     password_reveal_timer_.Start(FROM_HERE, GetPasswordRevealDuration(),
         base::Bind(&Textfield::RevealPasswordChar,
                    weak_ptr_factory_.GetWeakPtr(), -1));
   }
 }
 
 void Textfield::CreateTouchSelectionControllerAndNotifyIt() {
   if (!HasFocus())
     return;
 
   if (!touch_selection_controller_) {
     touch_selection_controller_.reset(
         ui::TouchEditingControllerDeprecated::Create(this));
   }
   if (touch_selection_controller_)
     touch_selection_controller_->SelectionChanged();
 }
 
-void Textfield::UpdateSelectionClipboard() const {
-#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
-  if (performing_user_action_ && HasSelection() &&
-      text_input_type_ != ui::TEXT_INPUT_TYPE_PASSWORD) {
-    ui::ScopedClipboardWriter(
-        ui::CLIPBOARD_TYPE_SELECTION).WriteText(GetSelectedText());
-    if (controller_)
-      controller_->OnAfterCutOrCopy(ui::CLIPBOARD_TYPE_SELECTION);
-  }
-#endif
-}
-
-void Textfield::PasteSelectionClipboard(const ui::MouseEvent& event) {
-  DCHECK(event.IsOnlyMiddleMouseButton());
-  DCHECK(!read_only());
-  base::string16 selection_clipboard_text = GetSelectionClipboardText();
-  OnBeforeUserAction();
-  const gfx::SelectionModel mouse =
-      GetRenderText()->FindCursorPosition(event.location());
-  if (!HasFocus())
-    RequestFocus();
-  model_->MoveCursorTo(mouse);
-  if (!selection_clipboard_text.empty()) {
-    model_->InsertText(selection_clipboard_text);
-    UpdateAfterChange(true, true);
-  }
-  OnAfterUserAction();
-}
-
 void Textfield::OnKeypressUnhandled() {
   PlatformStyle::OnTextfieldKeypressUnhandled();
 }
 
 bool Textfield::ShouldShowCursor() const {
   return HasFocus() && !HasSelection() && enabled() && !read_only() &&
          !drop_cursor_visible_;
 }
 
 bool Textfield::ShouldBlinkCursor() const {
@@ skipping 11 matching lines @@
   cursor_blink_timer_.Stop();
 }
 
 void Textfield::OnCursorBlinkTimerFired() {
   DCHECK(ShouldBlinkCursor());
   gfx::RenderText* render_text = GetRenderText();
   render_text->set_cursor_visible(!render_text->cursor_visible());
   RepaintCursor();
 }
 
+gfx::Point Textfield::last_click_location() const {
+  return selection_controller_->last_click_location();
+}
+
 }  // namespace views