Textfield: suppress cursor repaints when there's a selection

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 237 matching lines @@
       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),
       skip_input_method_cancel_composition_(false),
-      cursor_visible_(false),
       drop_cursor_visible_(false),
       initiating_drag_(false),
       aggregated_clicks_(0),
       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()));
@@ skipping 579 matching lines @@
   gfx::RenderText* render_text = GetRenderText();
   const gfx::Range& selection = render_text->selection();
   drop_cursor_position_ = render_text->FindCursorPosition(event.location());
   bool in_selection = !selection.is_empty() &&
       selection.Contains(gfx::Range(drop_cursor_position_.caret_pos()));
   drop_cursor_visible_ = !in_selection;
   // TODO(msw): Pan over text when the user drags to the visible text edge.
   OnCaretBoundsChanged();
   SchedulePaint();
 
+  StopBlinkingCursor();
+
   if (initiating_drag_) {
     if (in_selection)
       return ui::DragDropTypes::DRAG_NONE;
     return event.IsControlDown() ? ui::DragDropTypes::DRAG_COPY :
                                    ui::DragDropTypes::DRAG_MOVE;
   }
   return ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_MOVE;
 }
 
 void Textfield::OnDragExited() {
   drop_cursor_visible_ = false;
+  if (ShouldBlinkCursor())
+    StartBlinkingCursor();
   SchedulePaint();
 }
 
 int Textfield::OnPerformDrop(const ui::DropTargetEvent& event) {
   DCHECK(CanDrop(event.data()));
   drop_cursor_visible_ = false;
 
   if (controller_) {
     int drag_operation = controller_->OnDrop(event.data());
     if (drag_operation != ui::DragDropTypes::DRAG_NONE)
@@ skipping 91 matching lines @@
 }
 
 void Textfield::OnPaint(gfx::Canvas* canvas) {
   OnPaintBackground(canvas);
   PaintTextAndCursor(canvas);
   OnPaintBorder(canvas);
 }
 
 void Textfield::OnFocus() {
   GetRenderText()->set_focused(true);
-  cursor_visible_ = true;
+  if (ShouldShowCursor())
+    GetRenderText()->set_cursor_visible(true);
   SchedulePaint();
   if (GetInputMethod())
     GetInputMethod()->SetFocusedTextInputClient(this);
   OnCaretBoundsChanged();
-
-  const size_t caret_blink_ms = Textfield::GetCaretBlinkMs();
-  if (caret_blink_ms != 0) {
-    cursor_repaint_timer_.Start(FROM_HERE,
-        base::TimeDelta::FromMilliseconds(caret_blink_ms), this,
-        &Textfield::UpdateCursor);
-  }
-
+  if (ShouldBlinkCursor())
+    StartBlinkingCursor();
   View::OnFocus();
   SchedulePaint();
 }
 
 void Textfield::OnBlur() {
-  GetRenderText()->set_focused(false);
+  gfx::RenderText* render_text = GetRenderText();
+  render_text->set_focused(false);
   if (GetInputMethod())
     GetInputMethod()->DetachTextInputClient(this);
-  cursor_repaint_timer_.Stop();
-  if (cursor_visible_) {
-    cursor_visible_ = false;
+  StopBlinkingCursor();
+  if (render_text->cursor_visible()) {
+    render_text->set_cursor_visible(false);
     RepaintCursor();
   }
 
   DestroyTouchSelection();
 
   // Border typically draws focus indicator.
   SchedulePaint();
 }
 
 gfx::Point Textfield::GetKeyboardContextMenuLocation() {
@@ skipping 780 matching lines @@
   SchedulePaint();
 }
 
 void Textfield::UpdateAfterChange(bool text_changed, bool cursor_changed) {
   if (text_changed) {
     if (controller_)
       controller_->ContentsChanged(this, text());
     NotifyAccessibilityEvent(ui::AX_EVENT_TEXT_CHANGED, true);
   }
   if (cursor_changed) {
-    cursor_visible_ = true;
+    GetRenderText()->set_cursor_visible(ShouldShowCursor());
     RepaintCursor();
-    if (cursor_repaint_timer_.IsRunning())
-      cursor_repaint_timer_.Reset();
+    if (ShouldBlinkCursor())
+      StartBlinkingCursor();
+    else
+      StopBlinkingCursor();
     if (!text_changed) {
       // TEXT_CHANGED implies TEXT_SELECTION_CHANGED, so we only need to fire
       // this if only the selection changed.
       NotifyAccessibilityEvent(ui::AX_EVENT_TEXT_SELECTION_CHANGED, true);
     }
   }
   if (text_changed || cursor_changed) {
     OnCaretBoundsChanged();
     SchedulePaint();
   }
 }
 
-void Textfield::UpdateCursor() {
-  const size_t caret_blink_ms = Textfield::GetCaretBlinkMs();
-  cursor_visible_ = !cursor_visible_ || (caret_blink_ms == 0);
-  RepaintCursor();
-}
-
 void Textfield::RepaintCursor() {
   gfx::Rect r(GetRenderText()->GetUpdatedCursorBounds());
   r.Inset(-1, -1, -1, -1);
   SchedulePaintInRect(r);
 }
 
 void Textfield::PaintTextAndCursor(gfx::Canvas* canvas) {
   TRACE_EVENT0("views", "Textfield::PaintTextAndCursor");
   canvas->Save();
 
   // Draw placeholder text if needed.
   gfx::RenderText* render_text = GetRenderText();
   if (text().empty() && !GetPlaceholderText().empty()) {
     canvas->DrawStringRect(GetPlaceholderText(), GetFontList(),
                            ui::MaterialDesignController::IsSecondaryUiMaterial()
                                ? SkColorSetA(GetTextColor(), 0x83)
                                : placeholder_text_color_,
                            render_text->display_rect());
   }
 
-  // Draw the text, cursor, and selection.
-  render_text->set_cursor_visible(cursor_visible_ && !drop_cursor_visible_ &&
-                                  !HasSelection());
   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) {
@@ skipping 180 matching lines @@
     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 {
+  return ShouldShowCursor() && Textfield::GetCaretBlinkMs() != 0;
+}
+
+void Textfield::StartBlinkingCursor() {
+  DCHECK(ShouldBlinkCursor());
+  cursor_blink_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(
+                                           Textfield::GetCaretBlinkMs()),
+                            this, &Textfield::OnCursorBlinkTimerFired);
+}
+
+void Textfield::StopBlinkingCursor() {
+  cursor_blink_timer_.Stop();
+}
+
+void Textfield::OnCursorBlinkTimerFired() {
+  DCHECK(ShouldBlinkCursor());
+  gfx::RenderText* render_text = GetRenderText();
+  render_text->set_cursor_visible(!render_text->cursor_visible());
+  RepaintCursor();
+}
+
 }  // namespace views