Add verbose logging for native accessibility events.

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 165 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() {
+void BrowserAccessibilityManager::NotifyAccessibilityEvent(
+    BrowserAccessibilityEvent::Source source,
+    ui::AXEvent event_type,
+    BrowserAccessibility* node) {
+  BrowserAccessibilityEvent::Create(source, event_type, node)->Fire();
+}
+
+void BrowserAccessibilityManager::FireFocusEventsIfNeeded(
+    BrowserAccessibilityEvent::Source source) {
   BrowserAccessibility* focus = GetFocus();
 
   // 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()) {
     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);
+    FireFocusEvent(source, 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);
+void BrowserAccessibilityManager::FireFocusEvent(
+    BrowserAccessibilityEvent::Source source,
+    BrowserAccessibility* node) {
+  NotifyAccessibilityEvent(source, ui::AX_EVENT_FOCUS, node);
 
   if (!g_focus_change_callback_for_testing.Get().is_null())
     g_focus_change_callback_for_testing.Get().Run();
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetRoot() {
   // tree_ can be null during destruction.
   if (!tree_)
     return nullptr;
 
@@ skipping 51 matching lines @@
 
   return nullptr;
 }
 
 const ui::AXTreeData& BrowserAccessibilityManager::GetTreeData() {
   return tree_->data();
 }
 
 void BrowserAccessibilityManager::OnWindowFocused() {
   if (this == GetRootManager())
-    FireFocusEventsIfNeeded();
+    FireFocusEventsIfNeeded(BrowserAccessibilityEvent::FromWindowFocusChange);
 }
 
 void BrowserAccessibilityManager::OnWindowBlurred() {
   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;
 }
 
 void BrowserAccessibilityManager::NavigationSucceeded() {
   user_is_navigating_away_ = false;
 }
 
 void BrowserAccessibilityManager::NavigationFailed() {
   user_is_navigating_away_ = false;
 }
 
-void BrowserAccessibilityManager::GotMouseDown() {
-  BrowserAccessibility* focus = GetFocus();
-  if (!focus)
-    return;
-
-  osk_state_ = OSK_ALLOWED_WITHIN_FOCUSED_OBJECT;
-  NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, focus);
-}
-
 bool BrowserAccessibilityManager::UseRootScrollOffsetsWhenComputingBounds() {
   return true;
 }
 
 void BrowserAccessibilityManager::OnAccessibilityEvents(
     const std::vector<AXEventNotificationDetails>& details) {
   // Process all changes to the accessibility tree first.
   for (uint32_t index = 0; index < details.size(); ++index) {
     const AXEventNotificationDetails& detail = details[index];
     if (!tree_->Unserialize(detail.update)) {
       if (delegate_) {
         LOG(ERROR) << tree_->error();
         delegate_->AccessibilityFatalError();
       } else {
         CHECK(false) << tree_->error();
       }
       return;
     }
   }
 
   // If the root's parent is in another accessibility tree but it wasn't
   // previously connected, post the proper notifications on the parent.
   BrowserAccessibility* parent = GetParentNodeFromParentTree();
   if (parent) {
     if (!connected_to_parent_tree_node_) {
       parent->OnDataChanged();
       parent->UpdatePlatformAttributes();
-      parent->manager()->NotifyAccessibilityEvent(
-          ui::AX_EVENT_CHILDREN_CHANGED, parent);
+      NotifyAccessibilityEvent(
+          BrowserAccessibilityEvent::FromChildFrameLoading,
+          ui::AX_EVENT_CHILDREN_CHANGED,
+          parent);
       connected_to_parent_tree_node_ = true;
     }
   } else {
     connected_to_parent_tree_node_ = false;
   }
 
   // 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();
+  GetRootManager()->FireFocusEventsIfNeeded(
+      BrowserAccessibilityEvent::FromBlink);
 
   // 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)
@@ skipping 11 matching lines @@
 
       // 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;
     }
 
     // Fire the native event.
-    NotifyAccessibilityEvent(event_type, GetFromAXNode(node));
+    BrowserAccessibility* event_target = GetFromAXNode(node);
+    if (event_target) {
+      NotifyAccessibilityEvent(
+          BrowserAccessibilityEvent::FromBlink,
+          event_type,
+          event_target);
+    }
   }
 }
 
 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;
     ui::AXNode* node = obj->node();
@@ skipping 54 matching lines @@
   // If an ancestor of this node is a leaf node, fire the notification on that.
   BrowserAccessibility* ancestor = node->GetParent();
   while (ancestor && ancestor != GetRoot()) {
     if (ancestor->PlatformIsLeaf())
       node = ancestor;
     ancestor = ancestor->GetParent();
   }
 
   // The "scrolled to anchor" notification is a great way to get a
   // screen reader to jump directly to a specific location in a document.
-  NotifyAccessibilityEvent(ui::AX_EVENT_SCROLLED_TO_ANCHOR, node);
+  NotifyAccessibilityEvent(
+      BrowserAccessibilityEvent::FromFindInPageResult,
+      ui::AX_EVENT_SCROLLED_TO_ANCHOR,
+      node);
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetActiveDescendantFocus(
     BrowserAccessibility* focus) {
   if (!focus)
     return NULL;
 
   int active_descendant_id;
   if (focus->GetIntAttribute(ui::AX_ATTR_ACTIVEDESCENDANT_ID,
                              &active_descendant_id)) {
@@ skipping 389 matching lines @@
       tree_source(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