views: Convert IsFocusable() to just focusable() since it's just a simple accessor.

ui/views/view.h

 // Copyright (c) 2011 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_
 #pragma once
 
 #include <algorithm>
 #include <map>
@@ skipping 230 matching lines @@
   // 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.
   virtual void SetVisible(bool visible);
 
   // Return whether a view is visible
   bool visible() const { return visible_; }
 
-  // Return whether this view and its ancestors are visible. Returns true if the
-  // path from this view to the root view is 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.
   void SetEnabled(bool enabled);
 
   // Returns whether the view is enabled.
   bool enabled() const { return enabled_; }
 
@@ skipping 392 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 can accept the focus.
+  // Sets whether this view is capable of taking focus.
   // 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; }
 
+  // Returns true if this view is capable of taking focus.
+  bool focusable() const { return focusable_ && enabled_ && visible_; }
+
   // Returns true if the view is focusable (IsFocusable) and visible in the root
   // view. See also IsFocusable.
-  bool IsFocusableInRootView() const;
+  virtual bool IsFocusableInRootView() const;
 
   // Return whether this view is focusable when the user requires full keyboard
   // access, even though it may not be normally focusable.
   bool IsAccessibilityFocusableInRootView() const;
 
   // Set whether this view can be made focusable if the user requires
   // full keyboard access, even though it's not normally focusable.
   // Note that this is false by default.
   void set_accessibility_focusable(bool accessibility_focusable) {
     accessibility_focusable_ = 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 the keyboard focus. The receiving view will become the
   // focused view.
   virtual void RequestFocus();
 
   // Invoked when a view is about to be requested for focus due to the focus
   // traversal. Reverse is this request was generated going backward
   // (Shift-Tab).
-  virtual void AboutToRequestFocusFromTabTraversal(bool reverse) { }
+  virtual void AboutToRequestFocusFromTabTraversal(bool reverse) {}
 
   // Invoked when a key is pressed before the key event is processed (and
   // potentially eaten) by the focus manager for tab traversal, accelerators and
   // other focus related actions.
   // The default implementation returns false, ensuring that tab traversal and
   // accelerators processing is performed.
   // Subclasses should return true if they want to process the key event and not
   // have it processed as an accelerator (if any) or as a tab traversal (if the
   // key event is for the TAB key).  In that case, OnKeyPressed will
   // subsequently be invoked for that event.
@@ skipping 292 matching lines @@
   // Default value is false, in which case the View will hit-test against its
   // bounds.
   virtual bool HasHitTestMask() const;
 
   // Called by HitTest to retrieve a mask for hit-testing against. Subclasses
   // override to provide custom shaped hit test regions.
   virtual void GetHitTestMask(gfx::Path* mask) const;
 
   // Focus ---------------------------------------------------------------------
 
-  // Returns whether this view can accept focus.
-  // A view can accept focus if it's enabled, focusable and visible.
-  // This method is intended for views to use when calculating preferred size.
-  // The FocusManager and other places use IsFocusableInRootView.
-  virtual bool IsFocusable() const;
-
   // Override to be notified when focus has changed either to or from this View.
   virtual void OnFocus();
   virtual void OnBlur();
 
   // Handle view focus/blur events for this view.
   void Focus();
   void Blur();
 
   // System events -------------------------------------------------------------
 
@@ skipping 404 matching lines @@
   base::win::ScopedComPtr<NativeViewAccessibilityWin>
       native_view_accessibility_win_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(View);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_VIEW_H_