Fix toolbar keyboard accessibility on Views (alternative impl).

ui/views/accessible_pane_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.
 
 #include "ui/views/accessible_pane_view.h"
 
 #include "base/message_loop.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/views/focus/focus_search.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/widget/widget.h"
 
 namespace views {
 
+// Create tiny subclass of FocusSearch that overrides GetParent and Contains,
+// delegating these to methods in AccessiblePaneView. This is needed so that
+// subclasses of AccessiblePaneView can customize the focus search logic and
+// include views that aren't part of the AccessiblePaneView's view
+// hierarchy in the focus order.
+class AccessiblePaneViewFocusSearch : public FocusSearch {
+ public:
+  explicit AccessiblePaneViewFocusSearch(AccessiblePaneView* pane_view)
+      : FocusSearch(pane_view, true, true),
+        accessible_pane_view_(pane_view) {}
+
+ protected:
+  virtual View* GetParent(View* v) OVERRIDE {
+    return accessible_pane_view_->ContainsForFocusSearch(root(), v) ?
+        accessible_pane_view_->GetParentForFocusSearch(v) : NULL;
+  }
+
+  // Returns true if |v| is contained within the hierarchy rooted at |root|.
+  // Subclasses can override this if they need custom focus search behavior.
+  virtual bool Contains(View* root, const View* v) OVERRIDE {
+    return accessible_pane_view_->ContainsForFocusSearch(root, v);
+  }
+
+ private:
+  AccessiblePaneView* accessible_pane_view_;
+  DISALLOW_COPY_AND_ASSIGN(AccessiblePaneViewFocusSearch);
+};
+
 AccessiblePaneView::AccessiblePaneView()
     : pane_has_focus_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       focus_manager_(NULL),
       home_key_(ui::VKEY_HOME, ui::EF_NONE),
       end_key_(ui::VKEY_END, ui::EF_NONE),
       escape_key_(ui::VKEY_ESCAPE, ui::EF_NONE),
       left_key_(ui::VKEY_LEFT, ui::EF_NONE),
       right_key_(ui::VKEY_RIGHT, ui::EF_NONE) {
-  focus_search_.reset(new views::FocusSearch(this, true, true));
+  focus_search_.reset(new AccessiblePaneViewFocusSearch(this));
 }
 
 AccessiblePaneView::~AccessiblePaneView() {
   if (pane_has_focus_) {
     focus_manager_->RemoveFocusChangeListener(this);
   }
 }
 
 bool AccessiblePaneView::SetPaneFocus(views::View* initial_focus) {
   if (!visible())
     return false;
 
   if (!focus_manager_)
     focus_manager_ = GetFocusManager();
 
   focus_manager_->StoreFocusedView();
 
   // Use the provided initial focus if it's visible and enabled, otherwise
   // use the first focusable child.
   if (!initial_focus ||
-      !Contains(initial_focus) ||
+      !ContainsForFocusSearch(this, initial_focus) ||
       !initial_focus->visible() ||
       !initial_focus->enabled()) {
     initial_focus = GetFirstFocusableChild();
   }
 
   // Return false if there are no focusable children.
   if (!initial_focus)
     return false;
 
   focus_manager_->SetFocusedView(initial_focus);
@@ skipping 17 matching lines @@
 }
 
 bool AccessiblePaneView::SetPaneFocusAndFocusDefault() {
   return SetPaneFocus(GetDefaultFocusableChild());
 }
 
 views::View* AccessiblePaneView::GetDefaultFocusableChild() {
   return NULL;
 }
 
+View* AccessiblePaneView::GetParentForFocusSearch(View* v) {
+  return v->parent();
+}
+
+bool AccessiblePaneView::ContainsForFocusSearch(View* root, const View* v) {
+  return root->Contains(v);
+}
+
 void AccessiblePaneView::RemovePaneFocus() {
   focus_manager_->RemoveFocusChangeListener(this);
   pane_has_focus_ = false;
 
   focus_manager_->UnregisterAccelerator(home_key_, this);
   focus_manager_->UnregisterAccelerator(end_key_, this);
   focus_manager_->UnregisterAccelerator(escape_key_, this);
   focus_manager_->UnregisterAccelerator(left_key_, this);
   focus_manager_->UnregisterAccelerator(right_key_, this);
 }
@@ skipping 21 matching lines @@
   if (pane_has_focus_)
     return this;
   else
     return NULL;
 }
 
 bool AccessiblePaneView::AcceleratorPressed(
     const ui::Accelerator& accelerator) {
 
   const views::View* focused_view = focus_manager_->GetFocusedView();
-  if (!Contains(focused_view))
+  if (!ContainsForFocusSearch(this, focused_view))
     return false;
 
   switch (accelerator.key_code()) {
     case ui::VKEY_ESCAPE:
       RemovePaneFocus();
       focus_manager_->RestoreFocusedView();
       return true;
     case ui::VKEY_LEFT:
       focus_manager_->AdvanceFocus(true);
       return true;
@@ skipping 34 matching lines @@
 }
 
 void AccessiblePaneView::OnDidChangeFocus(views::View* focused_before,
                                           views::View* focused_now) {
   if (!focused_now)
     return;
 
   views::FocusManager::FocusChangeReason reason =
       focus_manager_->focus_change_reason();
 
-  if (!Contains(focused_now) ||
+  if (!ContainsForFocusSearch(this, focused_now) ||
       reason == views::FocusManager::kReasonDirectFocusChange) {
     // We should remove pane focus (i.e. make most of the controls
     // not focusable again) because the focus has left the pane,
     // or because the focus changed within the pane due to the user
     // directly focusing to a specific view (e.g., clicking on it).
     RemovePaneFocus();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // FocusTraversable overrides:
 
 views::FocusSearch* AccessiblePaneView::GetFocusSearch() {
   DCHECK(pane_has_focus_);
   return focus_search_.get();
 }
 
 views::FocusTraversable* AccessiblePaneView::GetFocusTraversableParent() {
   DCHECK(pane_has_focus_);
   return NULL;
 }
 
 views::View* AccessiblePaneView::GetFocusTraversableParentView() {
   DCHECK(pane_has_focus_);
   return NULL;
 }
 
 }  // namespace views