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 22 matching lines @@
 #include "ui/native_theme/native_theme.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/background.h"
 #include "ui/views/controls/focus_ring.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 142 matching lines @@
       selection_text_color_(SK_ColorWHITE),
       selection_background_color_(SK_ColorBLUE),
       placeholder_text_color_(kDefaultPlaceholderTextColor),
       invalid_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_TEXT),
       text_input_flags_(0),
       performing_user_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),
       use_focus_ring_(ui::MaterialDesignController::IsSecondaryUiMaterial()),
       weak_ptr_factory_(this) {
   set_context_menu_controller(this);
   set_drag_controller(this);
   GetRenderText()->SetFontList(GetDefaultFontList());
   View::SetBorder(std::unique_ptr<Border>(new FocusableBorder()));
   SetFocusBehavior(FocusBehavior::ALWAYS);
 
@@ skipping 55 matching lines @@
   model_->InsertText(new_text);
   UpdateAfterChange(true, true);
 }
 
 base::string16 Textfield::GetSelectedText() const {
   return model_->GetSelectedText();
 }
 
 void Textfield::SelectAll(bool reversed) {
   model_->SelectAll(reversed);
-  UpdateSelectionClipboard();
+  if (HasSelection() && performing_user_action_)
+    UpdateSelectionClipboard();
   UpdateAfterChange(false, true);
 }
 
 void Textfield::SelectWordAt(const gfx::Point& point) {
   model_->MoveCursorTo(point, false);
   model_->SelectWord();
   UpdateAfterChange(false, true);
 }
 
 void Textfield::ClearSelection() {
@@ skipping 189 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 18 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();
-    }
+  bool handled = controller_ && controller_->HandleMouseEvent(this, event);
+  if (!handled &&
+      (event.IsOnlyLeftMouseButton() || event.IsOnlyRightMouseButton())) {
+    RequestFocus();
+    ShowImeIfNeeded();
+  }
 
 #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);
-      }
-    }
+  if (!handled && !HasFocus() && event.IsOnlyMiddleMouseButton())

[karandeepb, 2016/10/20 04:12:57]

This causes a behavior change (for the better IMO). On Linux, if you have some
selection in a textfield, and you press tab to remove focus from it. If you
middle click inside the (not visible) selection region of the (unfocused)
textfield, the current behavior is that the selection will be cleared
internally, but the cursor won't be drawn since the textfield won't request
focus.

This changes the behavior to first requesting focus and then clearing the
selection, so that middle clicking inside the selection region of an unfocused
textfield, moves the cursor to the end of the selection. 

There are some other bugs I found related to not clearing selection on blur-
1) If you hover inside the (not visible) selection region of an unfocused
textfield, we get an "arrow" as the cursor and not the text cursor.
2) If you left click inside the (not visible) selection region of an unfocused
textfield, the selection region flashes and reduces to a caret later.

[msw, 2016/10/21 02:14:15]

I hugely appreciate your attention to detail and explanations here!

The behavior change might be acceptable, but I'm not sure that it makes sense to
move the cursor to the end of the invisible selection, that might be confusing,
but it does match the focused behavior, afaik. I'd try to follow the example of
what some Linux GTK textfields do in this case, but it's such a minor corner
case that the behavior change you describe is probably okay.

We sure do have some weirdness that emerges from retaining, but not painting the
selection while unfocused. I originally drew the unfocused selection, but we
decided to change that a long time ago, and I don't recall the reasons for
retaining (rather than saving and restoring) the selection while blurred. That
said, saving and restoring selections has its own set of complications... Not to
make excuses, but middle-click selection clipboard behavior was also tacked-on
recently, partly by myself with little familiarity with the native behavior.

The last two points are indeed from retaining the selection. It seems like we
only want to retain the selection for tab-focus events, not mouse-focus events.
If that's the case, then you're right these are bugs, otherwise, (1) seems to
match the expected behavior (similar to your new behavior for middle-click,
right?), but there's no reason for (2) afaict, we should try to update the
cursor position before painting and avoid the flash. 

Feel free to file a bug or two, thanks!

[karandeepb, 2016/10/21 05:04:32]

Yeah I think it's still better than the current behavior of a middle click
inside the selection region of an unfocused textfield causing no user visible
change. The behavior can be further corrected while fixing bugs related to
retaining the selection on losing focus.
Interestingly, there's work ongoing to draw the unfocused selection -
https://codereview.chromium.org/2345183002/.
Will file bugs for these. These can probably be tackled all at once.

+    RequestFocus();
 #endif
-  }
 
-  return true;
+  return 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);
 }
 
 WordLookupClient* Textfield::GetWordLookupClient() {
   return this;
 }
 
 bool Textfield::OnKeyPressed(const ui::KeyEvent& event) {
   ui::TextEditCommand edit_command = scheduled_text_edit_command_;
   scheduled_text_edit_command_ = ui::TextEditCommand::INVALID_COMMAND;
 
@@ skipping 447 matching lines @@
 // Textfield, WordLookupClient overrides:
 
 bool Textfield::GetDecoratedWordAtPoint(const gfx::Point& point,
                                         gfx::DecoratedText* decorated_word,
                                         gfx::Point* baseline_point) {
   return GetRenderText()->GetDecoratedWordAtPoint(point, decorated_word,
                                                   baseline_point);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// Textfield, SelectionControllerDelegate overrides:
+
+bool Textfield::HasTextBeingDragged() const {
+  return initiating_drag_;
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // 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 445 matching lines @@
   skip_input_method_cancel_composition_ = false;
 
   UpdateAfterChange(true, true);
   OnAfterUserAction();
 }
 
 gfx::RenderText* Textfield::GetRenderText() const {
   return model_->render_text();
 }
 
+gfx::Point Textfield::GetLastClickLocation() const {
+  return selection_controller_->last_click_location();
+}
+
 base::string16 Textfield::GetSelectionClipboardText() const {
   base::string16 selection_clipboard_text;
   ui::Clipboard::GetForCurrentThread()->ReadText(
       ui::CLIPBOARD_TYPE_SELECTION, &selection_clipboard_text);
   return selection_clipboard_text;
 }
 
 void Textfield::ExecuteTextEditCommand(ui::TextEditCommand command) {
   DestroyTouchSelection();
 
@@ skipping 178 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, SelectionControllerDelegate overrides:
+
+gfx::RenderText* Textfield::GetRenderTextForSelectionController() {
+  return GetRenderText();
+}
+
+bool Textfield::IsReadOnly() const {
+  return read_only();
+}
+
+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();
+  if (model_->HasCompositionText())
+    model_->ConfirmCompositionText();
+}
+
+void Textfield::OnAfterMouseAction(bool text_changed, bool selection_changed) {
+  OnAfterUserAction();
+  UpdateAfterChange(text_changed, selection_changed);
+}
+
+bool Textfield::PasteSelectionClipboard() {
+  DCHECK(performing_user_action_);
+  DCHECK(!read_only());
+  const base::string16 selection_clipboard_text = GetSelectionClipboardText();
+  if (selection_clipboard_text.empty())
+    return false;
+
+  model_->InsertText(selection_clipboard_text);

[karandeepb, 2016/10/20 04:12:57]

Also, removed the UpdateAfterChange here.

[msw, 2016/10/21 02:14:16]

That might be worth a comment, ie. "Callers should call UpdateAfterChange after
this." Another option is moving more of the code to SelectionController, but I
don't think we'd want to add or call SelectionControllerDelegate::InsertText.

[karandeepb, 2016/10/21 05:04:32]

There are currently no callers within Textfield. Added a comment.

+  return true;
+}
+
+void Textfield::UpdateSelectionClipboard() {
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+  if (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()) {
@@ skipping 70 matching lines @@
     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);

[karandeepb, 2016/10/20 04:12:58]

Do you know if using TextfieldModel::MoveCursorTo(SelectionModel) rather than
TextfieldModel::MoveCursorTo(Point, bool) here deliberate?
MovecursorTo(SelectionModel) seems to have specific behavior for an active
composition, which won't be triggered with the way things are structured now.
Although I'd think it's not significant, happening only on Linux on a middle
click with active composition.

[msw, 2016/10/21 02:14:15]

I also doubt that it's deliberate. It seems like we should just call the
<point,bool> version; feel free to make that change.

[karandeepb, 2016/10/21 05:04:32]

Already doing it.

-  if (!selection_clipboard_text.empty()) {
-    model_->InsertText(selection_clipboard_text);
-    UpdateAfterChange(true, true);
-  }
-  OnAfterUserAction();
-}
-
 void Textfield::OnEditFailed() {
   PlatformStyle::OnTextfieldEditFailed();
 }
 
 bool Textfield::ShouldShowCursor() const {
   return HasFocus() && !HasSelection() && enabled() && !read_only() &&
          !drop_cursor_visible_;
 }
 
 bool Textfield::ShouldBlinkCursor() const {
@@ skipping 12 matching lines @@
 }
 
 void Textfield::OnCursorBlinkTimerFired() {
   DCHECK(ShouldBlinkCursor());
   gfx::RenderText* render_text = GetRenderText();
   render_text->set_cursor_visible(!render_text->cursor_visible());
   RepaintCursor();
 }
 
 }  // namespace views