Give up focus if the focused view becomes unfocusable

ui/views/view.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.
 
 #define _USE_MATH_DEFINES // For VC++ to get M_PI. This has to be first.
 
 #include "ui/views/view.h"
 
 #include <algorithm>
 #include <cmath>
@@ skipping 436 matching lines @@
 
 void View::SetVisible(bool visible) {
   if (visible != visible_) {
     // If the View is currently visible, schedule paint to refresh parent.
     // TODO(beng): not sure we should be doing this if we have a layer.
     if (visible_)
       SchedulePaint();
 
     visible_ = visible;
 
+    if (!visible) {

[sky, 2013/12/07 00:29:13]

You have this code in a bunch of places. I think what you should do is create a
method something like, MoveFocusIfNecessary() that roughly does:

if (IsAccessibilityFocusable() || !Contains(focus_view))
  return;

focus_manager->AdvanceFocus(true);
if (Contains(focus_view))
  focus_manager->ClearFocus();

And write tests for this.

[mohsen, 2013/12/11 20:10:12]

I have extracted the common code and moved it to the FocusManager. This way, it
becomes much simpler and there is no need to see if this view (in some cases) is
equal to the focused view or (in other cases) contains the focused view. 

However, I still clear the focus instead of moving it to another view, as it
seems more natural to me. For example, if the user is typing in a textfield and,
for whatever reason, the textfield gets disabled, I think it is better to clear
the focus instead of moving the focus to another view, because the user may not
notice the change and continue typing and possibly override the other view's
data! But, if you think it is better to move focus to another view, it can be
done easily.

+      // If the View has focus or contains the focused view, clear focus.
+      FocusManager* focus_manager = GetFocusManager();
+      if (focus_manager && Contains(focus_manager->GetFocusedView()))
+        focus_manager->ClearFocus();
+    }
+
     // Notify the parent.
     if (parent_)
       parent_->ChildVisibilityChanged(this);
 
     // This notifies all sub-views recursively.
     PropagateVisibilityNotifications(this, visible_);
     UpdateLayerVisibility();
 
     // If we are newly visible, schedule paint.
     if (visible_)
       SchedulePaint();
   }
 }
 
 bool View::IsDrawn() const {
   return visible_ && parent_ ? parent_->IsDrawn() : false;
 }
 
 void View::SetEnabled(bool enabled) {
   if (enabled != enabled_) {
     enabled_ = enabled;
+    if (!enabled) {
+      // If the View has focus, clear focus.
+      FocusManager* focus_manager = GetFocusManager();
+      if (focus_manager && focus_manager->GetFocusedView() == this)
+        focus_manager->ClearFocus();
+    }
     OnEnabledChanged();
   }
 }
 
 void View::OnEnabledChanged() {
   SchedulePaint();
 }
 
 // Transformations -------------------------------------------------------------
 
@@ skipping 710 matching lines @@
 View* View::GetPreviousFocusableView() {
   return previous_focusable_view_;
 }
 
 void View::SetNextFocusableView(View* view) {
   if (view)
     view->previous_focusable_view_ = this;
   next_focusable_view_ = view;
 }
 
+void View::SetFocusable(bool focusable) {
+  focusable_ = focusable;
+  if (!focusable && !IsAccessibilityFocusable()) {
+    // If the View has focus, clear focus.
+    FocusManager* focus_manager = GetFocusManager();
+    if (focus_manager && focus_manager->GetFocusedView() == this)
+      focus_manager->ClearFocus();
+  }
+}
+
 bool View::IsFocusable() const {
   return focusable_ && enabled_ && IsDrawn();
 }
 
 bool View::IsAccessibilityFocusable() const {
   return (focusable_ || accessibility_focusable_) && enabled_ && IsDrawn();
 }
 
+void View::SetAccessibilityFocusable(bool accessibility_focusable) {
+  accessibility_focusable_ = accessibility_focusable;
+  if (!accessibility_focusable && !IsFocusable()) {
+    // If the View has focus, clear focus.
+    FocusManager* focus_manager = GetFocusManager();
+    if (focus_manager && focus_manager->GetFocusedView() == this)
+      focus_manager->ClearFocus();
+  }
+}
+
 FocusManager* View::GetFocusManager() {
   Widget* widget = GetWidget();
   return widget ? widget->GetFocusManager() : NULL;
 }
 
 const FocusManager* View::GetFocusManager() const {
   const Widget* widget = GetWidget();
   return widget ? widget->GetFocusManager() : NULL;
 }
 
@@ skipping 1160 matching lines @@
   // Message the RootView to do the drag and drop. That way if we're removed
   // the RootView can detect it and avoid calling us back.
   gfx::Point widget_location(event.location());
   ConvertPointToWidget(this, &widget_location);
   widget->RunShellDrag(this, data, widget_location, drag_operations, source);
   // WARNING: we may have been deleted.
   return true;
 }
 
 }  // namespace views