Reimplement automation API on top of C++-backed AXTree.

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 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 schema = GetSchemaAdditions();
 
 /**
  * A namespace to export utility functions to other files in automation.
  */
 window.automationUtil = function() {};
 
 // TODO(aboxhall): Look into using WeakMap
-var idToAutomationRootNode = {};
 var idToCallback = {};
 
 var DESKTOP_TREE_ID = 0;
 
 automationUtil.storeTreeCallback = function(id, callback) {
   if (!callback)
     return;
 
-  var targetTree = idToAutomationRootNode[id];
+  var targetTree = AutomationRootNode.get(id);
   if (!targetTree) {
     // If we haven't cached the tree, hold the callback until the tree is
     // populated by the initial onAccessibilityEvent call.
     if (id in idToCallback)
       idToCallback[id].push(callback);
     else
       idToCallback[id] = [callback];
   } else {
     callback(targetTree);
   }
 };
 
 /**
  * Global list of tree change observers.
  * @type {Array<TreeChangeObserver>}
  */
 automationUtil.treeChangeObservers = [];
 
 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
     // a key in the idToAutomationRootNode map. The callback to
     // enableTab is bound to the callback passed in to getTree(), so that once
     // the tree is available (either due to having been cached earlier, or after
     // an accessibility event occurs which causes the tree to be populated), the
     // callback can be called.
     var params = { routingID: routingID, tabID: tabID };
     automationInternal.enableTab(params,
         function onEnable(id) {
           if (lastError.hasError(chrome)) {
             callback();
             return;
           }
           automationUtil.storeTreeCallback(id, callback);
         });
   });
 
   var desktopTree = null;
   apiFunctions.setHandleRequest('getDesktop', function(callback) {
-    desktopTree =
-        idToAutomationRootNode[DESKTOP_TREE_ID];
+    StartCachingAccessibilityTrees();
+    desktopTree = AutomationRootNode.get(DESKTOP_TREE_ID);
     if (!desktopTree) {
       if (DESKTOP_TREE_ID in idToCallback)
         idToCallback[DESKTOP_TREE_ID].push(callback);
       else
         idToCallback[DESKTOP_TREE_ID] = [callback];
 
       var routingID = GetRoutingID();
 
       // TODO(dtseng): Disable desktop tree once desktop object goes out of
       // scope.
       automationInternal.enableDesktop(routingID, function() {
         if (lastError.hasError(chrome)) {
-          delete idToAutomationRootNode[
-              DESKTOP_TREE_ID];
+          AutomationRootNode.destroy(DESKTOP_TREE_ID);
           callback();
           return;
         }
       });
     } else {
       callback(desktopTree);
     }
   });
 
   function removeTreeChangeObserver(observer) {
@@ skipping 10 matching lines @@
   function addTreeChangeObserver(observer) {
     removeTreeChangeObserver(observer);
     automationUtil.treeChangeObservers.push(observer);
   }
   apiFunctions.setHandleRequest('addTreeChangeObserver', function(observer) {
     addTreeChangeObserver(observer);
   });
 
 });
 
+automationInternal.onTreeChange.addListener(function(treeID,
+                                                     nodeID,
+                                                     changeType) {
+  var tree = AutomationRootNode.get(treeID);
+  if (!tree)
+    return;
+
+  var node = privates(tree).impl.get(nodeID);
+  if (!node)
+    return;
+
+  if (node.role == 'webView') {
+    // A WebView in the desktop tree has a different AX tree as its child.
+    // When we encounter a WebView with a child AX tree id that we don't
+    // currently have cached, explicitly request that AX tree from the
+    // browser process and set up a callback when it loads to attach that
+    // tree as a child of this node and fire appropriate events.
+    var childTreeID = GetIntAttribute(treeID, nodeID, 'childTreeId');
+    if (!AutomationRootNode.get(childTreeID)) {
+      automationUtil.storeTreeCallback(childTreeID, function(root) {
+        privates(root).impl.hostNode = node;

[not at google - send to devlin, 2015/06/17 21:14:48]

Glancing at this code (and not understanding it), the frequency of
"privates(root).impl" makes me think whatever this is doing should be pulled
into the class itself. Like,
privates(root).impl.setHostNodeForSomethingSomething(node).

[dmazzoni, 2015/06/18 07:23:53]

Done.

[not at google - send to devlin, 2015/06/18 17:34:38]

Is there a semantically reasonable function that could fire those
privates(root).impl.dispatchEvent() functions as well?

[dmazzoni, 2015/06/18 21:31:53]

I'm not sure why - I consider automation_custom_bindings.js and
automation_node.js to be almost friend classes - they're both implementing
private impl classes that the client doesn't see, I don't see any reason to add
layers of abstraction around calling a function on AutomationNodeImpl vs one on
AutomationNode. Or am I misunderstanding your concern?

+
+        if (root.docLoaded)
+          privates(root).impl.dispatchEvent(schema.EventType.loadComplete);
+
+        privates(node).impl.dispatchEvent(schema.EventType.childrenChanged);
+      });
+
+      automationInternal.enableFrame(childTreeID);
+    }
+  }
+
+  var treeChange = {target: node, type: changeType};
+  var observers = automationUtil.treeChangeObservers;

[not at google - send to devlin, 2015/06/17 21:14:48]

I don't know where this code came from, but note that extension events have had
problems with listeners adding or removing other listeners from within their
callbacks, which this code isn't safe against.

[dmazzoni, 2015/06/18 07:23:53]

Good idea. I changed it to make a copy of the array first.

+  for (var i = 0; i < observers.length; i++) {
+    try {
+      observers[i](treeChange);
+    } catch (e) {
+      logging.WARNING('Error in tree change observer for ' +
+          treeChange.type + ': ' + e.message +
+          '\nStack trace: ' + e.stack);
+    }
+  }
+
+  if (changeType == schema.TreeChangeType.nodeRemoved) {
+    privates(tree).impl.remove(nodeID);
+  }
+});
+
 // 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;
-  var targetTree = idToAutomationRootNode[id];
-  if (!targetTree) {
-    // If this is the first time we've gotten data for this tree, it will
-    // contain all of the tree's data, so create a new tree which will be
-    // bootstrapped from |data|.
-    targetTree = new AutomationRootNode(id);
-    idToAutomationRootNode[id] = targetTree;
-  }
+  var targetTree = AutomationRootNode.getOrCreate(id);
+
   if (!privates(targetTree).impl.onAccessibilityEvent(data))
     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)
-  if (id != DESKTOP_TREE_ID && !targetTree.attributes.url &&
+  if (id != DESKTOP_TREE_ID && !targetTree.url &&
       targetTree.children.length == 0) {
     return;
   }
 
   // If the tree wasn't available when getTree() was called, the callback will
   // have been cached in idToCallback, so call and delete it now that we
   // have the complete tree.
   for (var i = 0; i < idToCallback[id].length; i++) {
-    console.log('calling getTree() callback');
     var callback = idToCallback[id][i];
     callback(targetTree);
   }
   delete idToCallback[id];
 });
 
 automationInternal.onAccessibilityTreeDestroyed.addListener(function(id) {
-  var targetTree = idToAutomationRootNode[id];
+  // Destroy the AutomationRootNode.
+  var targetTree = AutomationRootNode.get(id);
   if (targetTree) {
     privates(targetTree).impl.destroy();
-    delete idToAutomationRootNode[id];
+    AutomationRootNode.destroy(id);
   } else {
     logging.WARNING('no targetTree to destroy');
   }
-  delete idToAutomationRootNode[id];
+
+  // Destroy the native cache of the accessibility tree.
+  DestroyAccessibilityTree(id);
 });
 
 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;
 });