Fix WebView accessibility

content/browser/accessibility/browser_accessibility_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 "content/browser/accessibility/browser_accessibility_manager.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "build/build_config.h"
@@ skipping 25 matching lines @@
   return nullptr;
 }
 
 }  // namespace
 
 // Map from AXTreeID to BrowserAccessibilityManager
 using AXTreeIDMap =
     base::hash_map<AXTreeIDRegistry::AXTreeID, BrowserAccessibilityManager*>;
 base::LazyInstance<AXTreeIDMap> g_ax_tree_id_map = LAZY_INSTANCE_INITIALIZER;
 
+// A function to call when focus changes, for testing only.
+base::LazyInstance<base::Closure> g_focus_change_callback_for_testing =
+    LAZY_INSTANCE_INITIALIZER;
+
 ui::AXTreeUpdate MakeAXTreeUpdate(
     const ui::AXNodeData& node1,
     const ui::AXNodeData& node2 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node3 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node4 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node5 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node6 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node7 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node8 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node9 /* = ui::AXNodeData() */,
@@ skipping 116 matching lines @@
   ui::AXNodeData empty_document;
   empty_document.id = 0;
   empty_document.role = ui::AX_ROLE_ROOT_WEB_AREA;
   ui::AXTreeUpdate update;
   update.nodes.push_back(empty_document);
   return update;
 }
 
 void BrowserAccessibilityManager::FireFocusEventsIfNeeded() {
   BrowserAccessibility* focus = GetFocus();
-  if (delegate_ && !delegate_->AccessibilityViewHasFocus())
-    focus = nullptr;
 
-  if (!CanFireEvents())
-    focus = nullptr;
+  // Don't fire focus events if the window itself doesn't have focus.
+  // Bypass this check if a global focus listener was set up for testing
+  // so that the test passes whether the window is active or not.
+  if (!g_focus_change_callback_for_testing.Pointer()) {

[dcheng, 2016/03/24 18:15:11]

I wonder if it'd be possible to snoop IPC messages in the browser test itself,
and listen for, say, AccessibilityHostMsg_Events to figure out when to check for
focus changes. Is there similar precedent for adding test-only callbacks like
this to test accessibility code?

[dmazzoni, 2016/03/25 05:02:22]

That's how most of the tests in content/ work, we use
AccessibilityNotificationWaiter,
but I didn't want to pull a ton of interfaces into content/public just to test
this one
thing. I posted some other alternatives to site-isolation-discuss, this seemed
like
the most logical first step.

I'm also worried that snooping on particular IPCs might be a bit fragile, since
we rely on the hook in FrameTree::SetFocusedFrame that depents on a RFH
IPC and may come totally independently of accessibility IPCs.

Either way, I think a test-only callback really does make sense in this case
because
there aren't supposed to be any other consumers of BrowserAccessibilityManager
in the Chrome codebase. It's the part of the code that directly implements
native APIs, and this test just really needs to make sure it's got the whole
frame
tree when it does it.

+    if (delegate_ &&!delegate_->AccessibilityViewHasFocus())
+      focus = nullptr;
+
+    if (!CanFireEvents())
+      focus = nullptr;
+  }
 
   // Don't allow the document to be focused if it has no children and
   // hasn't finished loading yet. Wait for at least a tiny bit of content,
   // or for the document to actually finish loading.
   if (focus &&
       focus == focus->manager()->GetRoot() &&
       focus->PlatformChildCount() == 0 &&
       !focus->HasState(ui::AX_STATE_BUSY) &&
       !focus->manager()->GetTreeData().loaded) {
     focus = nullptr;
   }
 
   if (focus && focus != last_focused_node_)
     FireFocusEvent(focus);
 
   last_focused_node_ = focus;
   last_focused_manager_ = focus ? focus->manager() : nullptr;
 }
 
 bool BrowserAccessibilityManager::CanFireEvents() {
   return true;
 }
 
 void BrowserAccessibilityManager::FireFocusEvent(BrowserAccessibility* node) {
   NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, node);
+  if (g_focus_change_callback_for_testing.Pointer())
+    g_focus_change_callback_for_testing.Get().Run();
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetRoot() {
   // tree_ can be null during destruction.
   if (!tree_)
     return nullptr;
 
   // tree_->root() can be null during AXTreeDelegate callbacks.
   ui::AXNode* root = tree_->root();
   return root ? GetFromAXNode(root) : nullptr;
@@ skipping 227 matching lines @@
   if (!root_manager)
     root_manager = this;
   int32_t focused_tree_id = root_manager->GetTreeData().focused_tree_id;
 
   BrowserAccessibilityManager* focused_manager = nullptr;
   if (focused_tree_id)
     focused_manager =BrowserAccessibilityManager::FromID(focused_tree_id);
   if (!focused_manager)
     focused_manager = root_manager;
 
-  int32_t focus_id = focused_manager->GetTreeData().focus_id;
-  BrowserAccessibility* obj = focused_manager->GetFromID(focus_id);
+  return focused_manager->GetFocusFromThisOrDescendantFrame();
+}
+
+BrowserAccessibility*
+BrowserAccessibilityManager::GetFocusFromThisOrDescendantFrame() {
+  int32_t focus_id = GetTreeData().focus_id;
+  BrowserAccessibility* obj = GetFromID(focus_id);
   if (!obj)
-    return focused_manager->GetRoot();
+    return GetRoot();
 
   if (obj->HasIntAttribute(ui::AX_ATTR_CHILD_TREE_ID)) {
     BrowserAccessibilityManager* child_manager =
         BrowserAccessibilityManager::FromID(
             obj->GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID));
     if (child_manager)
-      return child_manager->GetFocus();
+      return child_manager->GetFocusFromThisOrDescendantFrame();
   }
 
   return obj;
 }
 
 void BrowserAccessibilityManager::SetFocus(const BrowserAccessibility& node) {
   if (delegate_)
     delegate_->AccessibilitySetFocus(node.GetId());
 }
 
 void BrowserAccessibilityManager::SetFocusLocallyForTesting(
     BrowserAccessibility* node) {
   ui::AXTreeData data = GetTreeData();
   data.focus_id = node->GetId();
   tree_->UpdateData(data);
 }
 
+// static
+void BrowserAccessibilityManager::SetFocusChangeCallbackForTesting(
+    base::Closure callback) {
+  g_focus_change_callback_for_testing.Get() = callback;
+}
+
 void BrowserAccessibilityManager::DoDefaultAction(
     const BrowserAccessibility& node) {
   if (delegate_)
     delegate_->AccessibilityDoDefaultAction(node.GetId());
 }
 
 void BrowserAccessibilityManager::ScrollToMakeVisible(
     const BrowserAccessibility& node, gfx::Rect subfocus) {
   if (delegate_) {
     delegate_->AccessibilityScrollToMakeVisible(node.GetId(), subfocus);
@@ skipping 313 matching lines @@
       tree_->CreateTreeSource());
   ui::AXTreeSerializer<const ui::AXNode*,
                        ui::AXNodeData,
                        ui::AXTreeData> serializer(tree_source.get());
   ui::AXTreeUpdate update;
   serializer.SerializeChanges(tree_->root(), &update);
   return update;
 }
 
 }  // namespace content