MacViews: Implement Full Keyboard Access.

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 <stddef.h>
 
 #include <algorithm>
@@ skipping 97 matching lines @@
 //
 /////////////////////////////////////////////////////////////////////////////
 class VIEWS_EXPORT View : public ui::LayerDelegate,
                           public ui::LayerOwner,
                           public ui::AcceleratorTarget,
                           public ui::EventTarget,
                           public ui::EventHandler {
  public:
   typedef std::vector<View*> Views;
 
+  enum class FocusBehavior {
+    // Use when the view is to be focusable both in default and full keyboard
+    // access mode.
+    ALWAYS,
+
+    // Use when view is never focusable. Default.
+    NEVER,
+
+    // Use when the view is to be made focusable only during full keyboard mode.
+    ACCESSIBLE_ONLY,
+
+    // Use for controls. On Mac, this is the same as ACCESSIBLE_ONLY mode, while
+    // on other platforms it corresponds to ALWAYS.
+    CONTROL,

[sky, 2016/04/12 16:39:52]

CONTROL sounds good, but in practice it is really CONTROL_AS_UNDERSTOOD_BY_OSX,
which is hardly satisfying. The table approach I outlined and you implemented
here https://codereview.chromium.org/1870573003 suffers from needing a
centralized list of all possible controls. I'm ok with that approach, but the
ui/views code shouldn't contain a list of leaf view nodes defined else where,
e.g. DESKTOP_MEDIA_SOURCE_VIEW should be in chrome. That means you need both a
platformstyle in ui/views and one in other places defined their own leaf view
nodes (such as chrome, but likely other places as well).

I'm leaning toward ifdefs in the controls themselves. This avoids needing
multiple lists, and it avoids CONTROL_AS_UNDERSTOOD_BY_OSX.

More concretely I'm saying keep the FocusBehavior you have here, but not
CONTROL. Code like that in button becomes:

namespace {
View::FocusBehavior GetButtonFocusBehavior() {
#if defined(OS_MACOSX)
  return FocusBehavior::ACCESSIBLE_ONLY;
#else
  return FocusBehavior::ALWAYS;
#endif
}
}  // namespace

SetFocusBehavior(FocusBehavior::ACCESSIBLE_ONLY);

Thoughts?

+  };
+
   struct ViewHierarchyChangedDetails {
     ViewHierarchyChangedDetails()
         : is_add(false),
           parent(NULL),
           child(NULL),
           move_view(NULL) {}
 
     ViewHierarchyChangedDetails(bool is_add,
                                 View* parent,
                                 View* child,
@@ skipping 633 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 |focusable_| and |accessibility_focusable_| corresponding to the given
+  // |focus_behavior|.
+  void SetFocusBehavior(FocusBehavior focus_behavior);
+
   // 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.
+  // TODO(karandeepb): Make private.
   void SetFocusable(bool focusable);
 
   // Returns true if this view is |focusable_|, |enabled_| and drawn.
   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. It will
   // clear focus if the focused view is set to be non-focusable.
   // Note that this is false by default.
+  // TODO(karandeepb): Make private.
   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 772 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_