Give up focus if the focused view becomes unfocusable

ui/views/view.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_VIEW_H_
 #define UI_VIEWS_VIEW_H_
 
 #include <algorithm>
 #include <map>
 #include <set>
@@ skipping 259 matching lines @@
   // Gets the maximum size of the view. Currently only used for sizing shell
   // windows.
   virtual gfx::Size GetMaximumSize();
 
   // Return the height necessary to display this view with the provided width.
   // View's implementation returns the value from getPreferredSize.cy.
   // Override if your View's preferred height depends upon the width (such
   // as with Labels).
   virtual int GetHeightForWidth(int w);
 
-  // Set whether this view is visible. Painting is scheduled as needed.
+  // Sets whether this view is visible. Painting is scheduled as needed. Also,
+  // clears focus if the focused view or one of its ancestors is set to be
+  // hidden.
   virtual void SetVisible(bool visible);
 
   // Return whether a view is visible
   bool visible() const { return visible_; }
 
   // Returns true if this view is drawn on screen.
   virtual bool IsDrawn() const;
 
   // Set whether this view is enabled. A disabled view does not receive keyboard
   // or mouse inputs. If |enabled| differs from the current value, SchedulePaint
-  // is invoked.
+  // is invoked. Also, clears focus if the focused view is disabled.
   void SetEnabled(bool enabled);
 
   // Returns whether the view is enabled.
   bool enabled() const { return enabled_; }
 
   // This indicates that the view completely fills its bounds in an opaque
   // color. This doesn't affect compositing but is a hint to the compositor to
   // optimize painting.
   // Note that this method does not implicitly create a layer if one does not
   // already exist for the View, but is a no-op in that case.
@@ skipping 456 matching lines @@
   // Returns the view that should be selected next when pressing Shift-Tab.
   View* GetPreviousFocusableView();
 
   // Sets the component that should be selected next when pressing Tab, and
   // makes the current view the precedent view of the specified one.
   // Note that by default views are linked in the order they have been added to
   // their container. Use this method if you want to modify the order.
   // IMPORTANT NOTE: loops in the focus hierarchy are not supported.
   void SetNextFocusableView(View* view);
 
-  // Sets whether this view is capable of taking focus.
+  // Sets whether this view is capable of taking focus. It will clear focus if
+  // the focused view is set to be non-focusable.
   // Note that this is false by default so that a view used as a container does
   // not get the focus.
-  void set_focusable(bool focusable) { focusable_ = focusable; }
+  void SetFocusable(bool focusable);
 
   // Returns true if this view is capable of taking focus.
   bool focusable() const { return focusable_ && enabled_ && visible_; }
 
   // Returns true if this view is |focusable_|, |enabled_| and drawn.
   virtual bool IsFocusable() const;
 
   // Return whether this view is focusable when the user requires full keyboard
   // access, even though it may not be normally focusable.
   bool IsAccessibilityFocusable() const;
 
   // Set whether this view can be made focusable if the user requires
-  // full keyboard access, even though it's not normally focusable.
+  // full keyboard access, even though it's not normally focusable. It will
+  // clear focus if the focused view is set to be non-focusable.
   // Note that this is false by default.
-  void set_accessibility_focusable(bool accessibility_focusable) {
-    accessibility_focusable_ = accessibility_focusable;
-  }
+  void SetAccessibilityFocusable(bool accessibility_focusable);
 
   // Convenience method to retrieve the FocusManager associated with the
   // Widget that contains this view.  This can return NULL if this view is not
   // part of a view hierarchy with a Widget.
   virtual FocusManager* GetFocusManager();
   virtual const FocusManager* GetFocusManager() const;
 
   // Request keyboard focus. The receiving view will become the focused view.
   virtual void RequestFocus();
 
@@ skipping 584 matching lines @@
   // |leave_data_intact| if true does not remove data from accelerators_ array,
   // so it could be re-registered with other focus manager
   void UnregisterAccelerators(bool leave_data_intact);
 
   // Focus ---------------------------------------------------------------------
 
   // Initialize the previous/next focusable views of the specified view relative
   // to the view at the specified index.
   void InitFocusSiblings(View* view, int index);
 
+  // Clears the focused view if it has become unfocusable.
+  void ClearFocusIfUnfocusable();
+
   // System events -------------------------------------------------------------
 
   // Used to propagate theme changed notifications from the root view to all
   // views in the hierarchy.
   virtual void PropagateThemeChanged();
 
   // Used to propagate locale changed notifications from the root view to all
   // views in the hierarchy.
   virtual void PropagateLocaleChanged();
 
@@ skipping 154 matching lines @@
   // Belongs to this view, but it's reference-counted on some platforms
   // so we can't use a scoped_ptr. It's dereferenced in the destructor.
   NativeViewAccessibility* native_view_accessibility_;
 
   DISALLOW_COPY_AND_ASSIGN(View);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_VIEW_H_