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

ui/views/controls/textfield/textfield.h

 // 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.
 
 #ifndef UI_VIEWS_CONTROLS_TEXTFIELD_TEXTFIELD_H_
 #define UI_VIEWS_CONTROLS_TEXTFIELD_TEXTFIELD_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 11 matching lines @@
 #include "ui/base/models/simple_menu_model.h"
 #include "ui/base/touch/touch_editing_controller.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/range/range.h"
 #include "ui/gfx/selection_model.h"
 #include "ui/gfx/text_constants.h"
 #include "ui/views/context_menu_controller.h"
 #include "ui/views/controls/textfield/textfield_model.h"
 #include "ui/views/drag_controller.h"
+#include "ui/views/focus/focus_manager.h"
 #include "ui/views/view.h"
 #include "ui/views/word_lookup_client.h"
 
 namespace views {
 
 class MenuRunner;
 class Painter;
 class TextfieldController;
 
 // A views/skia textfield implementation. No platform-specific code is used.
 class VIEWS_EXPORT Textfield : public View,
                                public TextfieldModel::Delegate,
                                public ContextMenuController,
                                public DragController,
+                               public FocusChangeListener,
                                public WordLookupClient,
                                public ui::TouchEditable,
                                public ui::TextInputClient {
  public:
   // The textfield's class name.
   static const char kViewClassName[];
 
   // The preferred size of the padding to be used around textfield text.
   static const int kTextPadding;
 
@@ skipping 74 matching lines @@
   void SetSelectionTextColor(SkColor color);
   void UseDefaultSelectionTextColor();
 
   // Gets/sets the selection background color to be used when painting the
   // Textfield. Call UseDefaultSelectionBackgroundColor() to restore the default
   // system color.
   SkColor GetSelectionBackgroundColor() const;
   void SetSelectionBackgroundColor(SkColor color);
   void UseDefaultSelectionBackgroundColor();
 
+  // Gets the selection background color for use when the Textfield was the last
+  // to be focused in a widget.
+  SkColor GetUnfocusedSelectionBackgroundColor() const;
+
   // Set drop shadows underneath the text.
   void SetShadows(const gfx::ShadowValues& shadows);
 
   // Gets/Sets whether or not the cursor is enabled.
   bool GetCursorEnabled() const;
   void SetCursorEnabled(bool enabled);
 
   // Gets/Sets the fonts used when rendering the text within the Textfield.
   const gfx::FontList& GetFontList() const;
   void SetFontList(const gfx::FontList& font_list);
@@ skipping 85 matching lines @@
   bool CanDrop(const ui::OSExchangeData& data) override;
   int OnDragUpdated(const ui::DropTargetEvent& event) override;
   void OnDragExited() override;
   int OnPerformDrop(const ui::DropTargetEvent& event) override;
   void OnDragDone() override;
   void GetAccessibleState(ui::AXViewState* state) override;
   void OnBoundsChanged(const gfx::Rect& previous_bounds) override;
   bool GetNeedsNotificationWhenVisibleBoundsChange() const override;
   void OnVisibleBoundsChanged() override;
   void OnEnabledChanged() override;
+  void ViewHierarchyChanged(
+      const ViewHierarchyChangedDetails& details) override;
   void OnPaint(gfx::Canvas* canvas) override;
   void OnFocus() override;
   void OnBlur() override;
   gfx::Point GetKeyboardContextMenuLocation() override;
   void OnNativeThemeChanged(const ui::NativeTheme* theme) override;
 
   // TextfieldModel::Delegate overrides:
   void OnCompositionTextConfirmedOrCleared() override;
 
   // ContextMenuController overrides:
   void ShowContextMenuForView(View* source,
                               const gfx::Point& point,
                               ui::MenuSourceType source_type) override;
 
   // DragController overrides:
   void WriteDragDataForView(View* sender,
                             const gfx::Point& press_pt,
                             ui::OSExchangeData* data) override;
   int GetDragOperationsForView(View* sender, const gfx::Point& p) override;
   bool CanStartDragForView(View* sender,
                            const gfx::Point& press_pt,
                            const gfx::Point& p) override;
 
+  // FocusChangeListener overrides:
+  void OnWillChangeFocus(View* focused_before, View* focused_now) override;
+  void OnDidChangeFocus(View* focused_before, View* focused_now) override;
+#if !defined(OS_MACOSX)
+  void OnFocusManagerDestroying() override;
+#endif
+
   // WordLookupClient overrides:
   bool GetDecoratedWordAtPoint(const gfx::Point& point,
                                gfx::DecoratedText* decorated_word,
                                gfx::Point* baseline_point) override;
 
   // ui::TouchEditable overrides:
   void SelectRect(const gfx::Point& start, const gfx::Point& end) override;
   void MoveCaretTo(const gfx::Point& point) override;
   void GetSelectionEndPoints(gfx::SelectionBound* anchor,
                              gfx::SelectionBound* focus) override;
@@ skipping 179 matching lines @@
   // what overriding color values should be used instead.
   bool use_default_text_color_;
   bool use_default_background_color_;
   bool use_default_selection_text_color_;
   bool use_default_selection_background_color_;
   SkColor text_color_;
   SkColor background_color_;
   SkColor selection_text_color_;
   SkColor selection_background_color_;
 
+  // In cases where the Widget is deleted before the Textfield, there is no
+  // longer a way to retrieve the FocusManager. It's still needed to remove this
+  // Textfield as an observer, so keep a reference to the FocusManager this
+  // Textfield is listening to, if any.
+  FocusManager* focus_manager_;

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

I don't think OWNERS will like this :/ Let's see if we can find a way to remove
it.

Something interesting I saw: View already has a FocusManager member to deal with
accelerators -- 

  // Focus manager accelerators registered on.
  FocusManager* accelerator_focus_manager_;


I don't know if reusing that is the right thing. But the hooks are probably
similar. One option might be to have NativeViewHierarchyChanged call something
like `OnWidgetChanging` instead of
UnregisterAccelerators/RegisterPendingAccelerators and pass the old FocusManager
(and the default View::OnWidgetChanging() does the accelerator management).


We could also override NativeViewHierarchyChanged, it says " Overriding this
method is useful for tracking which FocusManager manages this view." but doesn't
give any way to obtain the old focus manager :/

Let's discuss this..

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

I thought more about this. I think the data member is OK, but we should point it
out to OWNERS when going for owners review that it may duplicate a thing in the
base class View.

But I think there's a way to make it a bit neater. Rather than cleaning up in
the destructor, and the extra checks in ViewHierarchyChanged() it should be
enough to do something like

void Textfield::NativeViewHierarchyChanged() [override] {
  if (focus_manager_)
    focus_manager_->RemoveFocusChangeListener(this);
  focus_manager_ = GetFocusManager();
  if (focus_manager_)
    focus_manager_->AddFocusChangeListener(this);
}


With this - maybe it's possible to have TYPE_CONTROL Widgets inoke
NativeViewHierarchyChanged() before they destroy the FocusManager - then we
don't need OnFocusManagerDestroying() --it kinda seems like a bug that it has a
different lifetime for TYPE_CONTROL - maybe we can fix it :)

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

The cleanup in the destructor actually didn't have anything to do with the
TYPE_CONTROL things, but were actually for
TextfieldTest.DestroyingTextfieldFromOnKeyEvent, which creates a custom
Textfield controller that destroys the Textfield in its HandleKeyEvent() method.
Now that I've looked at it again though it seems it makes more sense for it to
be the responsibility of the programmer to ensure the Textfield is cleaned up
properly if someone ever wants to make a TextfieldController that does that
(since TextfieldDestroyerController calls OnBlur() manually before destruction
to avoid the DCHECK in the Textfield destructor). I've replaced the stuff in the
destructor with a call to remove the Textfield in the
TextfieldDestroyerController class.

As discussed offline, the TYPE_CONTROL Widgets not being destroyed properly in
Aura was decided to be a problem with the test not calling Widget::CloseNow() to
deal with it.

+
   // Text to display when empty.
   base::string16 placeholder_text_;
 
   // Placeholder text color.
   // TODO(estade): remove this when Harmony/MD is default.
   SkColor placeholder_text_color_;
 
   // True when the contents are deemed unacceptable and should be indicated as
   // such.
   bool invalid_;
@@ skipping 58 matching lines @@
 
   // Used to bind callback functions to this object.
   base::WeakPtrFactory<Textfield> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Textfield);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_CONTROLS_TEXTFIELD_TEXTFIELD_H_