NOT FOR REVIEW. ax tree focus with debugging

chrome/renderer/resources/extensions/automation_custom_bindings.js

 // 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.
 
 // Custom bindings for the automation API.
 var AutomationNode = require('automationNode').AutomationNode;
 var AutomationRootNode = require('automationNode').AutomationRootNode;
 var automation = require('binding').Binding.create('automation');
 var automationInternal =
     require('binding').Binding.create('automationInternal').generate();
 var eventBindings = require('event_bindings');
 var Event = eventBindings.Event;
 var exceptionHandler = require('uncaught_exception_handler');
 var forEach = require('utils').forEach;
 var lastError = require('lastError');
 var logging = requireNative('logging');
 var nativeAutomationInternal = requireNative('automationInternal');
 var GetRoutingID = nativeAutomationInternal.GetRoutingID;
 var GetSchemaAdditions = nativeAutomationInternal.GetSchemaAdditions;
 var DestroyAccessibilityTree =
     nativeAutomationInternal.DestroyAccessibilityTree;
 var GetIntAttribute = nativeAutomationInternal.GetIntAttribute;
 var StartCachingAccessibilityTrees =
     nativeAutomationInternal.StartCachingAccessibilityTrees;
 var AddTreeChangeObserver = nativeAutomationInternal.AddTreeChangeObserver;
 var RemoveTreeChangeObserver =
     nativeAutomationInternal.RemoveTreeChangeObserver;
+var GetFocus = nativeAutomationInternal.GetFocus;
 var schema = GetSchemaAdditions();
 
 /**
  * A namespace to export utility functions to other files in automation.
  */
 window.automationUtil = function() {};
 
 // TODO(aboxhall): Look into using WeakMap
 var idToCallback = {};
 
@@ skipping 21 matching lines @@
  * @type {Object<number, TreeChangeObserver>}
  */
 automationUtil.treeChangeObserverMap = {};
 
 /**
  * The id of the next tree change observer.
  * @type {number}
  */
 automationUtil.nextTreeChangeObserverId = 1;
 
+/**
+ * @type {AutomationNode} The current focused node. This is only updated
+ *   when calling automationUtil.updateFocusedNode.
+ */
+automationUtil.focusedNode = null;
+
+/**
+ * Update automationUtil.focusedNode to be the node that currently has focus.
+ */
+automationUtil.updateFocusedNode = function() {
+  automationUtil.focusedNode = null;
+  console.log('updateFocusedNode calling GetFocus');
+  var focusedNodeInfo = GetFocus(DESKTOP_TREE_ID);
+  console.log('updateFocusedNode calling GetFocus done:');
+  console.log(focusedNodeInfo);
+  console.log(JSON.stringify(focusedNodeInfo));
+  if (!focusedNodeInfo) {
+    console.log('updateFocusedNode return 1');
+    return;
+  }
+  var tree = AutomationRootNode.getOrCreate(focusedNodeInfo.treeId);
+  if (tree) {
+    console.log('updateFocusedNode return 2');
+    automationUtil.focusedNode =
+        privates(tree).impl.get(focusedNodeInfo.nodeId);
+  } else {
+    console.log('updateFocusedNode return 3');
+  }
+
+  console.log('updateFocusedNode returning: ' + automationUtil.focusedNode);
+};
+
 automation.registerCustomHook(function(bindingsAPI) {
   var apiFunctions = bindingsAPI.apiFunctions;
 
   // TODO(aboxhall, dtseng): Make this return the speced AutomationRootNode obj.
   apiFunctions.setHandleRequest('getTree', function getTree(tabID, callback) {
     var routingID = GetRoutingID();
     StartCachingAccessibilityTrees();
 
     // enableTab() ensures the renderer for the active or specified tab has
     // accessibility enabled, and fetches its ax tree id to use as
@@ skipping 32 matching lines @@
           AutomationRootNode.destroy(DESKTOP_TREE_ID);
           callback();
           return;
         }
       });
     } else {
       callback(desktopTree);
     }
   });
 
+  apiFunctions.setHandleRequest('getFocus', function() {
+    console.log('automation_custom_bindings getFocus');
+    automationUtil.updateFocusedNode();
+    console.log('automation_custom_bindings getFocus 2');
+    console.log('automation_custom_bindings getFocus 2 returning: ' +
+        automationUtil.focusedNode);
+    return automationUtil.focusedNode;
+  });
+
   function removeTreeChangeObserver(observer) {
     for (var id in automationUtil.treeChangeObserverMap) {
       if (automationUtil.treeChangeObserverMap[id] == observer) {
         RemoveTreeChangeObserver(id);
         delete automationUtil.treeChangeObserverMap[id];
         return;
       }
     }
   }
   apiFunctions.setHandleRequest('removeTreeChangeObserver', function(observer) {
@@ skipping 93 matching lines @@
 automationInternal.onNodesRemoved.addListener(function(treeID, nodeIDs) {
   var tree = AutomationRootNode.getOrCreate(treeID);
   if (!tree)
     return;
 
   for (var i = 0; i < nodeIDs.length; i++) {
     privates(tree).impl.remove(nodeIDs[i]);
   }
 });
 
-// Listen to the automationInternal.onAccessibilityEvent event, which is
-// essentially a proxy for the AccessibilityHostMsg_Events IPC from the
-// renderer.
-automationInternal.onAccessibilityEvent.addListener(function(data) {
-  var id = data.treeID;
+/**
+ * Dispatch accessibility events fired on individual nodes to its
+ * corresponding AutomationNode. Handle focus events specially
+ * (see below).
+ */
+automationInternal.onAccessibilityEvent.addListener(function(eventParams) {
+  var id = eventParams.treeID;
   var targetTree = AutomationRootNode.getOrCreate(id);
 
-  if (!privates(targetTree).impl.onAccessibilityEvent(data))
+  // When we get a focus event, ignore the actual event target, and instead
+  // check what node has focus globally. If that represents a focus change,
+  // fire a focus event on the correct target.
+  if (eventParams.eventType == schema.EventType.focus) {
+    var previousFocusedNode = automationUtil.focusedNode;
+    automationUtil.updateFocusedNode();
+    if (automationUtil.focusedNode &&
+        automationUtil.focusedNode == previousFocusedNode) {
+      return;
+    }
+
+    if (automationUtil.focusedNode) {
+      targetTree = automationUtil.focusedNode.root;
+      eventParams.treeID = privates(targetTree).impl.treeID;
+      eventParams.targetID = privates(automationUtil.focusedNode).impl.id;
+    }
+  }
+
+  if (!privates(targetTree).impl.onAccessibilityEvent(eventParams))
     return;
 
   // If we're not waiting on a callback to getTree(), we can early out here.
   if (!(id in idToCallback))
     return;
 
   // We usually get a 'placeholder' tree first, which doesn't have any url
   // attribute or child nodes. If we've got that, wait for the full tree before
   // calling the callback.
   // TODO(dmazzoni): Don't send down placeholder (crbug.com/397553)
@@ skipping 26 matching lines @@
 });
 
 exports.binding = automation.generate();
 
 // Add additional accessibility bindings not specified in the automation IDL.
 // Accessibility and automation share some APIs (see
 // ui/accessibility/ax_enums.idl).
 forEach(schema, function(k, v) {
   exports.binding[k] = v;
 });