MacViews: Implement Full Keyboard Access.

ui/views/focus/focus_manager.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.
 
 #include "ui/views/focus/focus_manager.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/auto_reset.h"
@@ skipping 17 matching lines @@
 
 bool FocusManager::arrow_key_traversal_enabled_ = false;
 
 FocusManager::FocusManager(Widget* widget, FocusManagerDelegate* delegate)
     : widget_(widget),
       delegate_(delegate),
       focused_view_(NULL),
       accelerator_manager_(new ui::AcceleratorManager),
       shortcut_handling_suspended_(false),
       focus_change_reason_(kReasonDirectFocusChange),
-      is_changing_focus_(false) {
+      is_changing_focus_(false),
+      keyboard_accessible_(false) {
   DCHECK(widget_);
   stored_focused_view_storage_id_ =
       ViewStorage::GetInstance()->CreateStorageID();
 }
 
 FocusManager::~FocusManager() {
 }
 
 bool FocusManager::OnKeyEvent(const ui::KeyEvent& event) {
   const int key_code = event.key_code();
@@ skipping 241 matching lines @@
       // the starting views widget or |widget_|.
       Widget* widget = original_starting_view->GetWidget();
       if (widget->widget_delegate()->ShouldAdvanceFocusToTopLevelWidget())
         widget = widget_;
       return GetNextFocusableView(NULL, widget, reverse, true);
     }
   }
   return NULL;
 }
 
+void FocusManager::SetKeyboardAccessible(bool keyboard_accessible) {
+  if (keyboard_accessible == keyboard_accessible_)
+    return;
+
+  keyboard_accessible_ = keyboard_accessible;
+  // Disabling keyboard accessibility may cause the focused view to become not
+  // focusable. Hence advance focus if necessary.
+  AdvanceFocusIfNecessary();
+}
+
 void FocusManager::SetFocusedViewWithReason(
     View* view, FocusChangeReason reason) {
   if (focused_view_ == view)
     return;
 
   base::AutoReset<bool> auto_changing_focus(&is_changing_focus_, true);
   // Update the reason for the focus change (since this is checked by
   // some listeners), then notify all listeners.
   focus_change_reason_ = reason;
   FOR_EACH_OBSERVER(FocusChangeListener, focus_change_listeners_,
@@ skipping 24 matching lines @@
 }
 
 void FocusManager::AdvanceFocusIfNecessary() {
   // If widget is inactive, there is no focused view to check. The stored view
   // will also be checked for focusability when it is being restored.
   if (!widget_->IsActive())
     return;
 
   // If widget is active and focused view is not focusable, advance focus or,
   // if not possible, clear focus.
-  if (focused_view_ && !focused_view_->IsAccessibilityFocusable()) {
+  if (focused_view_ && !IsFocusable(focused_view_)) {
     AdvanceFocus(false);
-    if (focused_view_ && !focused_view_->IsAccessibilityFocusable())
+    if (focused_view_ && !IsFocusable(focused_view_))
       ClearFocus();
   }
 }
 
 void FocusManager::StoreFocusedView(bool clear_native_focus) {
   View* focused_view = focused_view_;
   // Don't do anything if no focused view. Storing the view (which is NULL), in
   // this case, would clobber the view that was previously saved.
   if (!focused_view_)
     return;
@@ skipping 14 matching lines @@
   }
 
   if (v)
     v->SchedulePaint();  // Remove focus border.
 }
 
 bool FocusManager::RestoreFocusedView() {
   View* view = GetStoredFocusView();
   if (view) {
     if (ContainsView(view)) {
+      // Todo change this.
       if (!view->IsFocusable() && view->IsAccessibilityFocusable()) {

[karandeepb, 2016/03/15 02:19:51]

I can't understand the rationale behind this line of code. It is introduced here
- https://codereview.chromium.org/3013023. Any insights?

[tapted, 2016/03/15 05:05:31]

So I think `RequestFocus` can be overridden by a View. Before that CL you link
to, the logic here would have bypassed any RequestFocus override, which is bad
[some things rely on that override]. So, where possible, RequstFocus should be
used rather than SetFocusedViewWithReason. 

But since the default implementation of View::RequestFocus checks only
`IsFocusable`, it can't be called for views that are only
`AccessibilityFocusable`, so for that case only, it falls back to calling
SetFocusedView directly.

[karandeepb, 2016/03/17 07:24:46]

Thanks!

         // RequestFocus would fail, but we want to restore focus to controls
         // that had focus in accessibility mode.
         SetFocusedViewWithReason(view, kReasonFocusRestore);
       } else {
         // This usually just sets the focus if this view is focusable, but
         // let the view override RequestFocus if necessary.
         view->RequestFocus();
 
         // If it succeeded, the reason would be incorrect; set it to
         // focus restore.
         if (focused_view_ == view)
           focus_change_reason_ = kReasonFocusRestore;
       }
     }
-    return true;
+    // The |keyboard_accessible_| mode may have changed while the widget was
+    // inactive.
+    AdvanceFocusIfNecessary();
   }
-  return false;
+  return view == focused_view_;
 }
 
 void FocusManager::SetStoredFocusView(View* focus_view) {
   ViewStorage* view_storage = ViewStorage::GetInstance();
   if (!view_storage) {
     // This should never happen but bug 981648 seems to indicate it could.
     NOTREACHED();
     return;
   }
 
@@ skipping 126 matching lines @@
     return true;
   }
   if (key_code == ui::VKEY_RIGHT || key_code == ui::VKEY_DOWN) {
     AdvanceFocus(false);
     return true;
   }
 
   return false;
 }
 
+bool FocusManager::IsFocusable(View* view) const {
+  DCHECK(view);
+  return keyboard_accessible_ ? view->IsAccessibilityFocusable()
+                              : view->IsFocusable();
+}
+
 }  // namespace views