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 388 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;
+    AdvanceFocusIfNecessary();
 
     // 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;
+    AdvanceFocusIfNecessary();
     OnEnabledChanged();
   }
 }
 
 void View::OnEnabledChanged() {
   SchedulePaint();
 }
 
 // Transformations -------------------------------------------------------------
 
@@ skipping 696 matching lines @@
   if (view)
     view->previous_focusable_view_ = this;
   next_focusable_view_ = view;
 }
 
 void View::SetFocusable(bool focusable) {
   if (focusable_ == focusable)
     return;
 
   focusable_ = focusable;
+  AdvanceFocusIfNecessary();
 }
 
 bool View::IsFocusable() const {
   return focusable_ && enabled_ && IsDrawn();
 }
 
 bool View::IsAccessibilityFocusable() const {
   return (focusable_ || accessibility_focusable_) && enabled_ && IsDrawn();
 }
 
 void View::SetAccessibilityFocusable(bool accessibility_focusable) {
   if (accessibility_focusable_ == accessibility_focusable)
     return;
 
   accessibility_focusable_ = accessibility_focusable;
+  AdvanceFocusIfNecessary();
 }
 
 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 1192 matching lines @@
       View* prev = children_[index]->GetPreviousFocusableView();
       v->previous_focusable_view_ = prev;
       v->next_focusable_view_ = children_[index];
       if (prev)
         prev->next_focusable_view_ = v;
       children_[index]->previous_focusable_view_ = v;
     }
   }
 }
 
+void View::AdvanceFocusIfNecessary() {
+  // Focus should only be advanced if this is the focused view and has become
+  // unfocusable. If it is still focusable, we can return early avoiding furthur
+  // unnecessary checks.
+  if (IsAccessibilityFocusable())
+    return;
+
+  FocusManager* focus_manager = GetFocusManager();
+  if (focus_manager)
+    focus_manager->AdvanceFocusIfNecessary();
+}
+
 // System events ---------------------------------------------------------------
 
 void View::PropagateThemeChanged() {
   for (int i = child_count() - 1; i >= 0; --i)
     child_at(i)->PropagateThemeChanged();
   OnThemeChanged();
 }
 
 void View::PropagateLocaleChanged() {
   for (int i = child_count() - 1; i >= 0; --i)
@@ skipping 37 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