Complete live region support in ChromeVox Next.

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 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 11 matching lines @@
       idToCallback[id].push(callback);
     else
       idToCallback[id] = [callback];
   } else {
     callback(targetTree);
   }
 };
 
 /**
  * Global list of tree change observers.
- * @type {Array<TreeChangeObserver>}
+ * @type {Object<number, TreeChangeObserver>}
  */
-automationUtil.treeChangeObservers = [];
+automationUtil.treeChangeObserverMap = {};
+
+/**
+ * The id of the next tree change observer.
+ * @type {number}
+ */
+automationUtil.nextTreeChangeObserverId = 1;
 
 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
@@ skipping 34 matching lines @@
           callback();
           return;
         }
       });
     } else {
       callback(desktopTree);
     }
   });
 
   function removeTreeChangeObserver(observer) {
-    var observers = automationUtil.treeChangeObservers;
-    for (var i = 0; i < observers.length; i++) {
-      if (observer == observers[i])
-        observers.splice(i, 1);
+    for (var id in automationUtil.treeChangeObserverMap) {
+      if (automationUtil.treeChangeObserverMap[id] == observer) {
+        RemoveTreeChangeObserver(id);
+        delete automationUtil.treeChangeObserverMap[id];
+        return;
+      }
     }
   }
   apiFunctions.setHandleRequest('removeTreeChangeObserver', function(observer) {
     removeTreeChangeObserver(observer);
   });
 
-  function addTreeChangeObserver(observer) {
+  function addTreeChangeObserver(filter, observer) {
     removeTreeChangeObserver(observer);
-    automationUtil.treeChangeObservers.push(observer);
+    var id = automationUtil.nextTreeChangeObserverId++;
+    AddTreeChangeObserver(id, filter);
+    automationUtil.treeChangeObserverMap[id] = observer;
   }
-  apiFunctions.setHandleRequest('addTreeChangeObserver', function(observer) {
-    addTreeChangeObserver(observer);
+  apiFunctions.setHandleRequest('addTreeChangeObserver',
+      function(filter, observer) {
+    addTreeChangeObserver(filter, observer);
   });
 
   apiFunctions.setHandleRequest('setDocumentSelection', function(params) {
     var anchorNodeImpl = privates(params.anchorObject).impl;
     var focusNodeImpl = privates(params.focusObject).impl;
     if (anchorNodeImpl.treeID !== focusNodeImpl.treeID)
       throw new Error('Selection anchor and focus must be in the same tree.');
     if (anchorNodeImpl.treeID === DESKTOP_TREE_ID) {
       throw new Error('Use AutomationNode.setSelection to set the selection ' +
           'in the desktop tree.');
     }
     automationInternal.performAction({ treeID: anchorNodeImpl.treeID,
                                        automationNodeID: anchorNodeImpl.id,
                                        actionType: 'setSelection'},
                                      { focusNodeID: focusNodeImpl.id,
                                        anchorOffset: params.anchorOffset,
                                        focusOffset: params.focusOffset });
   });
 
 });
 
-automationInternal.onTreeChange.addListener(function(treeID,
+automationInternal.onChildTreeID.addListener(function(treeID,
+                                                      nodeID) {
+  var tree = AutomationRootNode.getOrCreate(treeID);
+  if (!tree)
+    return;
+
+  var node = privates(tree).impl.get(nodeID);
+  if (!node)
+    return;
+
+  // 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 (!childTreeID)
+    return;
+
+  var subroot = AutomationRootNode.get(childTreeID);
+  if (!subroot) {
+    automationUtil.storeTreeCallback(childTreeID, function(root) {
+      privates(root).impl.setHostNode(node);
+
+      if (root.docLoaded)
+        privates(root).impl.dispatchEvent(schema.EventType.loadComplete);
+
+      privates(node).impl.dispatchEvent(schema.EventType.childrenChanged);
+    });
+
+    automationInternal.enableFrame(childTreeID);
+  } else {
+    privates(subroot).impl.setHostNode(node);
+  }
+});
+
+automationInternal.onTreeChange.addListener(function(observerID,
+                                                     treeID,
                                                      nodeID,
                                                      changeType) {
   var tree = AutomationRootNode.getOrCreate(treeID);
   if (!tree)
     return;
 
   var node = privates(tree).impl.get(nodeID);
   if (!node)
     return;
 
-  if (node.role == 'webView' || node.role == 'embeddedObject') {
-    // 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 (!childTreeID)
-      return;
+  var observer = automationUtil.treeChangeObserverMap[observerID];
+  if (!observer)
+    return;
 
-    var subroot = AutomationRootNode.get(childTreeID);
-    if (!subroot) {
-      automationUtil.storeTreeCallback(childTreeID, function(root) {
-        privates(root).impl.setHostNode(node);
-
-        if (root.docLoaded)
-          privates(root).impl.dispatchEvent(schema.EventType.loadComplete);
-
-        privates(node).impl.dispatchEvent(schema.EventType.childrenChanged);
-      });
-
-      automationInternal.enableFrame(childTreeID);
-    } else {
-      privates(subroot).impl.setHostNode(node);
-    }
-  }
-
-  var treeChange = {target: node, type: changeType};
-
-  // Make a copy of the observers in case one of these callbacks tries
-  // to change the list of observers.
-  var observers = automationUtil.treeChangeObservers.slice();
-  for (var i = 0; i < observers.length; i++) {
-    try {
-      observers[i](treeChange);
-    } catch (e) {
-      exceptionHandler.handle('Error in tree change observer for ' +
-          treeChange.type, e);
-    }
-  }
-
-  if (changeType == schema.TreeChangeType.nodeRemoved) {
-    privates(tree).impl.remove(nodeID);
+  try {
+    observer({target: node, type: changeType});
+  } catch (e) {
+    exceptionHandler.handle('Error in tree change observer for ' +
+        treeChange.type, e);
   }
 });
 
+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;
   var targetTree = AutomationRootNode.getOrCreate(id);
 
   if (!privates(targetTree).impl.onAccessibilityEvent(data))
     return;
 
@@ skipping 34 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;
 });