Views: Draw Textfield selected text in gray when top-level Widget loses focus.

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 233 matching lines @@
       read_only_(false),
       default_width_in_chars_(0),
       use_default_text_color_(true),
       use_default_background_color_(true),
       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),
+      focus_manager_(nullptr),
       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),
       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);
 
   // These allow BrowserView to pass edit commands from the Chrome menu to us
   // when we're focused by simply asking the FocusManager to
   // ProcessAccelerator() with the relevant accelerators.
   AddAccelerator(ui::Accelerator(ui::VKEY_X, ui::EF_CONTROL_DOWN));
   AddAccelerator(ui::Accelerator(ui::VKEY_C, ui::EF_CONTROL_DOWN));
   AddAccelerator(ui::Accelerator(ui::VKEY_V, ui::EF_CONTROL_DOWN));
 }
 
 Textfield::~Textfield() {
+  // If not currently attached to a Widget, |focus_manager_| would be null.
+  if (focus_manager_) {
+    // The Textfield may still be listening to focus changes if the Textfield is
+    // destroyed by its controller from OnKey events.
+    focus_manager_->RemoveFocusChangeListener(this);
+    focus_manager_ = nullptr;
+  }
   if (GetInputMethod()) {
     // The textfield should have been blurred before destroy.
     DCHECK(this != GetInputMethod()->GetTextInputClient());
   }
 }
 
 void Textfield::SetReadOnly(bool read_only) {
   // Update read-only without changing the focusable state (or active, etc.).
   read_only_ = read_only;
   if (GetInputMethod())
@@ skipping 130 matching lines @@
 SkColor Textfield::GetSelectionBackgroundColor() const {
   return use_default_selection_background_color_ ?
       GetNativeTheme()->GetSystemColor(
           ui::NativeTheme::kColorId_TextfieldSelectionBackgroundFocused) :
       selection_background_color_;
 }
 
 void Textfield::SetSelectionBackgroundColor(SkColor color) {
   selection_background_color_ = color;
   use_default_selection_background_color_ = false;
-  GetRenderText()->set_selection_background_focused_color(
+  GetRenderText()->set_selection_background_color(
       GetSelectionBackgroundColor());
   SchedulePaint();
 }
 
 void Textfield::UseDefaultSelectionBackgroundColor() {
   use_default_selection_background_color_ = true;
-  GetRenderText()->set_selection_background_focused_color(
+  GetRenderText()->set_selection_background_color(
       GetSelectionBackgroundColor());
   SchedulePaint();
 }
 
+SkColor Textfield::GetUnfocusedSelectionBackgroundColor() const {
+  return GetNativeTheme()->GetSystemColor(
+      ui::NativeTheme::kColorId_TextfieldSelectionBackgroundUnfocused);
+}
+
 bool Textfield::GetCursorEnabled() const {
   return GetRenderText()->cursor_enabled();
 }
 
 void Textfield::SetCursorEnabled(bool enabled) {
   GetRenderText()->SetCursorEnabled(enabled);
 }
 
 const gfx::FontList& Textfield::GetFontList() const {
   return GetRenderText()->font_list();
@@ skipping 534 matching lines @@
     touch_selection_controller_->SelectionChanged();
 }
 
 void Textfield::OnEnabledChanged() {
   View::OnEnabledChanged();
   if (GetInputMethod())
     GetInputMethod()->OnTextInputTypeChanged(this);
   SchedulePaint();
 }
 
+void Textfield::ViewHierarchyChanged(
+    const ViewHierarchyChangedDetails& details) {
+  // Textfields only care about focus changes if the entire Widget has lost
+  // focus, so don't bother listening if there is no Widget.
+  if (!GetWidget())
+    return;
+
+  if (details.parent->Contains(this) && details.move_view == nullptr) {
+    if (details.is_add) {
+      FocusManager* focus_manager = GetFocusManager();
+      // There should never be two different FocusManagers for the same Widget
+      // at the same time.
+      DCHECK(!focus_manager_ && focus_manager);
+      focus_manager_ = focus_manager;
+      focus_manager_->AddFocusChangeListener(this);
+    } else {
+      DCHECK(focus_manager_);
+      focus_manager_->RemoveFocusChangeListener(this);
+      focus_manager_ = nullptr;
+    }
+  }
+}
+
 void Textfield::OnPaint(gfx::Canvas* canvas) {
   OnPaintBackground(canvas);
   PaintTextAndCursor(canvas);
   OnPaintBorder(canvas);
 }
 
 void Textfield::OnFocus() {
   GetRenderText()->set_focused(true);
+  GetRenderText()->set_selection_background_color(
+      GetSelectionBackgroundColor());

[tapted, 2016/10/24 06:04:16]

Can this move to OnWillChangeFocus? Just to keep the logic in one place..

[Patti Lor, 2016/10/27 00:17:27]

Done.

   if (ShouldShowCursor())
     GetRenderText()->set_cursor_visible(true);
   if (GetInputMethod())
     GetInputMethod()->SetFocusedTextInputClient(this);
   OnCaretBoundsChanged();
   if (ShouldBlinkCursor())
     StartBlinkingCursor();
   if (use_focus_ring_) {
     FocusRing::Install(this, invalid_
                                  ? ui::NativeTheme::kColorId_AlertSeverityHigh
@@ skipping 25 matching lines @@
 gfx::Point Textfield::GetKeyboardContextMenuLocation() {
   return GetCaretBounds().bottom_right();
 }
 
 void Textfield::OnNativeThemeChanged(const ui::NativeTheme* theme) {
   gfx::RenderText* render_text = GetRenderText();
   render_text->SetColor(GetTextColor());
   UpdateBackgroundColor();
   render_text->set_cursor_color(GetTextColor());
   render_text->set_selection_color(GetSelectionTextColor());
-  render_text->set_selection_background_focused_color(
-      GetSelectionBackgroundColor());
+  if (HasFocus()) {
+    render_text->set_selection_background_color(GetSelectionBackgroundColor());
+  } else {
+    render_text->set_selection_background_color(
+        GetUnfocusedSelectionBackgroundColor());
+  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Textfield, TextfieldModel::Delegate overrides:
 
 void Textfield::OnCompositionTextConfirmedOrCleared() {
   if (!skip_input_method_cancel_composition_)
     GetInputMethod()->CancelComposition(this);
 }
 
@@ skipping 56 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, FocusChangeListener overrides:
+
+void Textfield::OnWillChangeFocus(View* focus_before, View* focus_after) {
+  // If this was the last focused View before switching Widgets, draw the text
+  // selection grayed out.
+  if (focus_before == this && focus_after == nullptr) {
+    GetRenderText()->set_selection_background_color(
+        GetUnfocusedSelectionBackgroundColor());
+    GetRenderText()->set_draw_text_selection(true);
+  }  // If another View in the same Widget is focused, don't draw the selection.
+  else if (focus_before == this && focus_after != nullptr) {

[tapted, 2016/10/24 06:04:16]

nit: we usually have the `else` on the same line as the closing brace. Perhaps
we can break this up a bit with some early returns. E.g.

if (focus_after != this && focus_before != this)
  return;

SkColor selection_color = focus_after
    ? GetSelectionBackgroundColor()
    : GetUnfocusedSelectionBackgroundColor();

// Selection is drawn if |this| has focus, or the Widget loses activation, but
// not if another View in this Widget is gaining focus.
GetRenderText()->set_draw_text_selection(!focus_after || focus_after == this);
GetRenderText()->(selection_color);

[Patti Lor, 2016/10/27 00:17:27]

Done, thanks!

+    GetRenderText()->set_draw_text_selection(false);
+  }  // This is focused now, draw the text selection.
+  else if (focus_after == this) {
+    GetRenderText()->set_draw_text_selection(true);
+  }
+}
+
+void Textfield::OnDidChangeFocus(View* focused_before, View* focused_now) {}
+
+// On Windows and Linux, on Widget destruction, Textfields inside a TYPE_CONTROL
+// Widget will be destroyed after the FocusManager. Make sure to remove this

[tapted, 2016/10/24 03:11:19]

It might be a bug that Mac is different here, or we might just not test it,
having no need for TYPE_CONTROL yet. Can we remove the #ifdef?

[Patti Lor, 2016/10/27 00:17:27]

Yes - OnViewHierarchyChanged will get called before the Mac code can get around
to destroying the FocusManager, so removing the ifdef just means this will never
be called on Mac (at least in the case where TYPE_CONTROL Widgets are being
destroyed - there may be another case where this gets hit which I didn't think
of). Done.

+// Textfield as an observer before the FocusManager is destroyed.
+#if !defined(OS_MACOSX)
+void Textfield::OnFocusManagerDestroying() {
+  if (!focus_manager_)
+    return;
+
+  focus_manager_->RemoveFocusChangeListener(this);
+  focus_manager_ = nullptr;
+}
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
 // 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);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 966 matching lines @@
 }
 
 void Textfield::OnCursorBlinkTimerFired() {
   DCHECK(ShouldBlinkCursor());
   gfx::RenderText* render_text = GetRenderText();
   render_text->set_cursor_visible(!render_text->cursor_visible());
   RepaintCursor();
 }
 
 }  // namespace views