One accessibility tree per frame.

chrome/renderer/extensions/automation_internal_custom_bindings.cc

 // Copyright 2014 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 "chrome/renderer/extensions/automation_internal_custom_bindings.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
@@ skipping 118 matching lines @@
     if (parent->data().role == ui::AX_ROLE_WEB_AREA ||
         parent->data().role == ui::AX_ROLE_ROOT_WEB_AREA) {
       int sx = 0;
       int sy = 0;
       if (parent->data().GetIntAttribute(ui::AX_ATTR_SCROLL_X, &sx) &&
           parent->data().GetIntAttribute(ui::AX_ATTR_SCROLL_Y, &sy)) {
         bounds.Offset(-sx, -sy);
       }
       need_to_offset_web_area = true;
     }
-    parent = parent->parent();
+    parent = cache->owner->GetParent(parent, &cache);
   }
 
   return bounds;
 }
 
+ui::AXNode* FindNodeWithChildTreeId(ui::AXNode* node, int child_tree_id) {
+  if (child_tree_id == node->data().GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID))
+    return node;
+
+  for (int i = 0; i < node->child_count(); ++i) {
+    ui::AXNode* result =
+        FindNodeWithChildTreeId(node->ChildAtIndex(i), child_tree_id);
+    if (result)
+      return result;
+  }
+
+  return nullptr;
+}
+
 //
 // Helper class that helps implement bindings for a JavaScript function
 // that takes a single input argument consisting of a Tree ID. Looks up
 // the TreeCache and passes it to the function passed to the constructor.
 //
 
 typedef void (*TreeIDFunction)(v8::Isolate* isolate,
                                v8::ReturnValue<v8::Value> result,
                                TreeCache* cache);
 
@@ skipping 609 matching lines @@
 }
 
 bool AutomationInternalCustomBindings::GetFocusInternal(TreeCache* cache,
                                                         TreeCache** out_cache,
                                                         ui::AXNode** out_node) {
   int focus_id = cache->tree.data().focus_id;
   ui::AXNode* focus = cache->tree.GetFromId(focus_id);
   if (!focus)
     return false;
 
+  // If the focused node is the owner of a child tree, that indicates
+  // a node within the child tree is the one that actually has focus.
   while (focus->data().HasIntAttribute(ui::AX_ATTR_CHILD_TREE_ID)) {
     // Try to keep following focus recursively, by letting |tree_id| be the
     // new subtree to search in, while keeping |focus_tree_id| set to the tree
     // where we know we found a focused node.
     int child_tree_id =
         focus->data().GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID);
 
     TreeCache* child_cache = GetTreeCacheFromTreeID(child_tree_id);
     if (!child_cache)
       break;
 
+    // If the child cache is a frame tree that indicates a focused frame,
+    // jump to that frame if possible.
+    if (child_cache->tree.data().focused_tree_id > 0) {
+      TreeCache* focused_cache =
+          GetTreeCacheFromTreeID(child_cache->tree.data().focused_tree_id);
+      if (focused_cache)
+        child_cache = focused_cache;
+    }
+
     int child_focus_id = child_cache->tree.data().focus_id;
     ui::AXNode* child_focus = child_cache->tree.GetFromId(child_focus_id);
     if (!child_focus)
       break;
 
     focus = child_focus;
     cache = child_cache;
   }
 
   *out_cache = cache;
@@ skipping 76 matching lines @@
 
 void AutomationInternalCustomBindings::UpdateOverallTreeChangeObserverFilter() {
   tree_change_observer_overall_filter_ =
       api::automation::TREE_CHANGE_OBSERVER_FILTER_NOTREECHANGES;
   for (const auto& observer : tree_change_observers_) {
     tree_change_observer_overall_filter_ =
         std::max(observer.filter, tree_change_observer_overall_filter_);
   }
 }
 
+ui::AXNode* AutomationInternalCustomBindings::GetParent(
+    ui::AXNode* node,
+    TreeCache** in_out_cache) {
+  if (node->parent())
+    return node->parent();
+
+  int parent_tree_id = (*in_out_cache)->tree.data().parent_tree_id;
+  if (parent_tree_id < 0)
+    return nullptr;
+
+  TreeCache* parent_cache = GetTreeCacheFromTreeID(parent_tree_id);
+  if (!parent_cache)
+    return nullptr;
+
+  // Try to use the cached parent node from the most recent time this
+  // was called.
+  if (parent_cache->parent_node_id_from_parent_tree > 0) {
+    ui::AXNode* parent = parent_cache->tree.GetFromId(
+        parent_cache->parent_node_id_from_parent_tree);
+    if (parent) {
+      int parent_child_tree_id =
+          parent->data().GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID);
+      if (parent_child_tree_id == (*in_out_cache)->tree_id) {
+        *in_out_cache = parent_cache;
+        return parent;
+      }
+    }
+  }
+
+  // If that fails, search for it and cache it for next time.
+  ui::AXNode* parent = FindNodeWithChildTreeId(parent_cache->tree.root(),
+                                               (*in_out_cache)->tree_id);
+  if (parent) {
+    (*in_out_cache)->parent_node_id_from_parent_tree = parent->id();
+    *in_out_cache = parent_cache;
+    return parent;
+  }
+
+  return nullptr;
+}
+
 void AutomationInternalCustomBindings::RouteTreeIDFunction(
     const std::string& name,
     TreeIDFunction callback) {
   scoped_refptr<TreeIDWrapper> wrapper = new TreeIDWrapper(this, callback);
   RouteFunction(name, base::Bind(&TreeIDWrapper::Run, wrapper));
 }
 
 void AutomationInternalCustomBindings::RouteNodeIDFunction(
     const std::string& name,
     NodeIDFunction callback) {
@@ skipping 55 matching lines @@
     const ExtensionMsg_AccessibilityEventParams& params,
     bool is_active_profile) {
   is_active_profile_ = is_active_profile;
   int tree_id = params.tree_id;
   TreeCache* cache;
   auto iter = tree_id_to_tree_cache_map_.find(tree_id);
   if (iter == tree_id_to_tree_cache_map_.end()) {
     cache = new TreeCache();
     cache->tab_id = -1;
     cache->tree_id = params.tree_id;
+    cache->parent_node_id_from_parent_tree = -1;
     cache->tree.SetDelegate(this);
+    cache->owner = this;
     tree_id_to_tree_cache_map_.insert(std::make_pair(tree_id, cache));
     axtree_to_tree_cache_map_.insert(std::make_pair(&cache->tree, cache));
   } else {
     cache = iter->second;
   }
 
   // Update the internal state whether it's the active profile or not.
   cache->location_offset = params.location_offset;
   deleted_node_ids_.clear();
   if (!cache->tree.Unserialize(params.update)) {
@@ skipping 193 matching lines @@
   v8::Local<v8::Array> args(v8::Array::New(GetIsolate(), 2U));
   args->Set(0U, v8::Integer::New(GetIsolate(), tree_id));
   v8::Local<v8::Array> nodes(v8::Array::New(GetIsolate(), ids.size()));
   args->Set(1U, nodes);
   for (size_t i = 0; i < ids.size(); ++i)
     nodes->Set(i, v8::Integer::New(GetIsolate(), ids[i]));
   context()->DispatchEvent("automationInternal.onNodesRemoved", args);
 }
 
 }  // namespace extensions