One accessibility tree per frame.

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 107 matching lines @@
 }
 
 BrowserAccessibilityManager::BrowserAccessibilityManager(
     BrowserAccessibilityDelegate* delegate,
     BrowserAccessibilityFactory* factory)
     : delegate_(delegate),
       factory_(factory),
       tree_(new ui::AXSerializableTree()),
       user_is_navigating_away_(false),
       osk_state_(OSK_ALLOWED),
+      last_focused_node_(nullptr),
+      last_focused_manager_(nullptr),
       ax_tree_id_(AXTreeIDRegistry::kNoAXTreeID),
       parent_node_id_from_parent_tree_(0) {
   tree_->SetDelegate(this);
 }
 
 BrowserAccessibilityManager::BrowserAccessibilityManager(
     const ui::AXTreeUpdate& initial_tree,
     BrowserAccessibilityDelegate* delegate,
     BrowserAccessibilityFactory* factory)
     : delegate_(delegate),
@@ skipping 28 matching lines @@
 ui::AXTreeUpdate
 BrowserAccessibilityManager::GetEmptyDocument() {
   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 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) {

[David Tseng, 2016/03/04 16:50:20]

Why do we want to exclude focus for this case?

[dmazzoni, 2016/03/07 21:35:32]

I moved this from Windows-specific code to cross-platform code, it's otherwise
unchanged. It confused NVDA in particular. It seems like not a bad idea in
general to wait until the page loads at least a tiny bit of content before
focusing it.

+    focus = nullptr;
+  }
+
+  if (focus && focus != last_focused_node_)
+    FireFocusEvent(focus);
+
+  last_focused_node_ = focus;

[David Tseng, 2016/03/04 16:50:20]

This would set nullptr for the conditions above. Is that right?

[dmazzoni, 2016/03/07 21:35:32]

Yes, definitely intentional. Every single event we receive or every time the
window focus state changes, we call FireFocusEventsIfNeeded and that means we'll
know we haven't yet fired a focus event within this window yet and one is
needed.

+  last_focused_manager_ = focus ? focus->manager() : nullptr;

[David Tseng, 2016/03/04 16:50:20]

Why not remove the FocusManager member pointer and just get it from the last
focused node when we need it?

[dmazzoni, 2016/03/07 21:35:32]

Because we don't have an easy way of clearing last_focused_node_ when a node is
destroyed, so last_focused_node_ is not dereferencable. The comment in the
header notes that it shouldn't be dereferenced.

I guess an alternative would be a WeakPtr, would you prefer that or is this
okay?

+}
+
+bool BrowserAccessibilityManager::CanFireEvents() {
+  return true;
+}
+
+void BrowserAccessibilityManager::FireFocusEvent(BrowserAccessibility* node) {
+  NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, node);
+}
+
 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 45 matching lines @@
   }
 
   return nullptr;
 }
 
 const ui::AXTreeData& BrowserAccessibilityManager::GetTreeData() {
   return tree_->data();
 }
 
 void BrowserAccessibilityManager::OnWindowFocused() {
-  BrowserAccessibility* focus = GetFocus();
-  if (focus)
-    NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, focus);
+  if (this == GetRootManager())
+    FireFocusEventsIfNeeded();
 }
 
 void BrowserAccessibilityManager::OnWindowBlurred() {
-  BrowserAccessibility* focus = GetFocus();
-  if (focus)
-    NotifyAccessibilityEvent(ui::AX_EVENT_BLUR, focus);
+  if (this == GetRootManager()) {
+    last_focused_node_ = nullptr;
+    last_focused_manager_ = nullptr;
+  }
 }
 
 void BrowserAccessibilityManager::UserIsNavigatingAway() {
   user_is_navigating_away_ = true;
 }
 
 void BrowserAccessibilityManager::UserIsReloading() {
   user_is_navigating_away_ = true;
 }
 
@@ skipping 27 matching lines @@
       if (delegate_) {
         LOG(ERROR) << tree_->error();
         delegate_->AccessibilityFatalError();
       } else {
         CHECK(false) << tree_->error();
       }
       return;
     }
   }
 
-  // Now iterate over the events again and fire the events.
+  // Based on the changes to the tree, first fire focus events if needed.
+  // Screen readers might not do the right thing if they're not aware of what
+  // has focus, so always try that first. Nothing will be fired if the window
+  // itself isn't focused or if focus hasn't changed.
+  GetRootManager()->FireFocusEventsIfNeeded();
+
+  // Now iterate over the events again and fire the events other than focus
+  // events.
   for (uint32_t index = 0; index < details.size(); index++) {
     const AXEventNotificationDetails& detail = details[index];
 
     // Find the node corresponding to the id that's the target of the
     // event (which may not be the root of the update tree).
     ui::AXNode* node = tree_->GetFromId(detail.id);
     if (!node)
       continue;
 
     ui::AXEvent event_type = detail.event_type;
     if (event_type == ui::AX_EVENT_FOCUS ||
         event_type == ui::AX_EVENT_BLUR) {
       if (osk_state_ != OSK_DISALLOWED_BECAUSE_TAB_HIDDEN &&
           osk_state_ != OSK_DISALLOWED_BECAUSE_TAB_JUST_APPEARED)
         osk_state_ = OSK_ALLOWED;
 
-      // Don't send a native focus event if the window itself doesn't
-      // have focus.
-      if (!NativeViewHasFocus())
+      bool is_menu_list_option =
+          node->data().role == ui::AX_ROLE_MENU_LIST_OPTION;
+
+      // Skip all focus events other than ones on menu list options;
+      // we've already handled them, above. Menu list options are a weird
+      // exception because the menu list itself has focus but we need to fire
+      // focus events on the individual options.
+      if (!is_menu_list_option)
         continue;
     }
 
-    // Send the event event to the operating system.
+    // Fire the native event.
     NotifyAccessibilityEvent(event_type, GetFromAXNode(node));
   }
 }
 
 void BrowserAccessibilityManager::OnLocationChanges(
     const std::vector<AccessibilityHostMsg_LocationChangeParams>& params) {
   for (size_t i = 0; i < params.size(); ++i) {
     BrowserAccessibility* obj = GetFromID(params[i].id);
     if (!obj)
       continue;
@@ skipping 57 matching lines @@
 }
 
 bool BrowserAccessibilityManager::NativeViewHasFocus() {
   BrowserAccessibilityDelegate* delegate = GetDelegateFromRootManager();
   if (delegate)
     return delegate->AccessibilityViewHasFocus();
   return false;
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetFocus() {
-  int32_t focus_id = GetTreeData().focus_id;
-  BrowserAccessibility* obj = GetFromID(focus_id);
+  BrowserAccessibilityManager* root_manager = GetRootManager();
+  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);
   if (!obj)
-    return GetRoot();
+    return focused_manager->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 obj;
@@ skipping 337 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