Keep track of accessibility focus across windows.

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 398 matching lines @@
                 base::Bind(&AutomationInternalCustomBindings::FN, \
                 base::Unretained(this)))
   ROUTE_FUNCTION(IsInteractPermitted);
   ROUTE_FUNCTION(GetSchemaAdditions);
   ROUTE_FUNCTION(GetRoutingID);
   ROUTE_FUNCTION(StartCachingAccessibilityTrees);
   ROUTE_FUNCTION(DestroyAccessibilityTree);
   ROUTE_FUNCTION(AddTreeChangeObserver);
   ROUTE_FUNCTION(RemoveTreeChangeObserver);
   ROUTE_FUNCTION(GetChildIDAtIndex);
+  ROUTE_FUNCTION(GetFocus);
+  ROUTE_FUNCTION(GetState);
   #undef ROUTE_FUNCTION
 
   // Bindings that take a Tree ID and return a property of the tree.
 
   RouteTreeIDFunction(
       "GetRootID", [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
                       TreeCache* cache) {
         result.Set(v8::Integer::New(isolate, cache->tree.root()->id()));
       });
   RouteTreeIDFunction(
@@ skipping 55 matching lines @@
                                           TreeCache* cache, ui::AXNode* node) {
     result.Set(v8::Integer::New(isolate, node->child_count()));
   });
   RouteNodeIDFunction(
       "GetIndexInParent",
       [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
          TreeCache* cache, ui::AXNode* node) {
         result.Set(v8::Integer::New(isolate, node->index_in_parent()));
       });
   RouteNodeIDFunction(
-      "GetState", [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
-                     TreeCache* cache, ui::AXNode* node) {
-        v8::Local<v8::Object> state(v8::Object::New(isolate));
-        uint32_t state_pos = 0, state_shifter = node->data().state;
-        while (state_shifter) {
-          if (state_shifter & 1) {
-            std::string key = ToString(static_cast<ui::AXState>(state_pos));
-            state->Set(CreateV8String(isolate, key),
-                       v8::Boolean::New(isolate, true));
-          }
-          state_shifter = state_shifter >> 1;
-          state_pos++;
-        }
-        result.Set(state);
-      });
-  RouteNodeIDFunction(
       "GetRole", [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
                     TreeCache* cache, ui::AXNode* node) {
         std::string role_name = ui::ToString(node->data().role);
         result.Set(v8::String::NewFromUtf8(isolate, role_name.c_str()));
       });
   RouteNodeIDFunction(
       "GetLocation", [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
                         TreeCache* cache, ui::AXNode* node) {
         gfx::Rect location = ComputeGlobalNodeBounds(cache, node);
         location.Offset(cache->location_offset);
@@ skipping 250 matching lines @@
        iter != tree_change_observers_.end(); ++iter) {
     if (iter->id == observer_id) {
       tree_change_observers_.erase(iter);
       break;
     }
   }
 
   UpdateOverallTreeChangeObserverFilter();
 }
 
+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;
+
+  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;
+
+    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;
+  *out_node = focus;
+  return true;
+}
+
+void AutomationInternalCustomBindings::GetFocus(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  if (args.Length() != 1 || !args[0]->IsNumber()) {
+    ThrowInvalidArgumentsException(this);
+    return;
+  }
+
+  int tree_id = args[0]->Int32Value();
+  TreeCache* cache = GetTreeCacheFromTreeID(tree_id);
+  if (!cache)
+    return;
+
+  TreeCache* focused_node_treecache = nullptr;

[David Tseng, 2016/02/17 23:55:56]

nit: focused_tree_cache

[dmazzoni, 2016/02/18 23:56:36]

Done.

+  ui::AXNode* focused_node = nullptr;
+  if (!GetFocusInternal(cache, &focused_node_treecache, &focused_node))
+    return;
+
+  v8::Isolate* isolate = GetIsolate();
+  v8::Local<v8::Object> result(v8::Object::New(isolate));
+  result->Set(CreateV8String(isolate, "treeId"),
+              v8::Integer::New(isolate, focused_node_treecache->tree_id));
+  result->Set(CreateV8String(isolate, "nodeId"),
+              v8::Integer::New(isolate, focused_node->id()));
+  args.GetReturnValue().Set(result);
+}
+
+void AutomationInternalCustomBindings::GetState(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  v8::Isolate* isolate = GetIsolate();
+  if (args.Length() < 2 || !args[0]->IsNumber() || !args[1]->IsNumber())
+    ThrowInvalidArgumentsException(this);
+
+  int tree_id = args[0]->Int32Value();
+  int node_id = args[1]->Int32Value();
+
+  TreeCache* cache = GetTreeCacheFromTreeID(tree_id);
+  if (!cache)
+    return;
+
+  ui::AXNode* node = cache->tree.GetFromId(node_id);
+  if (!node)
+    return;
+
+  v8::Local<v8::Object> state(v8::Object::New(isolate));
+  uint32_t state_pos = 0, state_shifter = node->data().state;
+  while (state_shifter) {
+    if (state_shifter & 1) {
+      std::string key = ToString(static_cast<ui::AXState>(state_pos));
+      state->Set(CreateV8String(isolate, key), v8::Boolean::New(isolate, true));
+    }
+    state_shifter = state_shifter >> 1;
+    state_pos++;
+  }
+
+  TreeCache* top_cache = GetTreeCacheFromTreeID(0);
+  if (!top_cache)
+    top_cache = cache;
+  TreeCache* focused_cache = nullptr;
+  ui::AXNode* focused_node = nullptr;
+  if (GetFocusInternal(top_cache, &focused_cache, &focused_node)) {
+    if (focused_cache == cache && focused_node == node) {
+      state->Set(CreateV8String(isolate, "focused"),
+                 v8::Boolean::New(isolate, true));
+    }
+  }
+  if (cache->tree.data().focus_id == node->id()) {
+    state->Set(CreateV8String(isolate, "focused"),
+               v8::Boolean::New(isolate, true));
+  }
+
+  args.GetReturnValue().Set(state);
+}
+
 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_);
   }
 }
 
 void AutomationInternalCustomBindings::RouteTreeIDFunction(
@@ skipping 264 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