Implement automatic load of composed/embedded automation trees

chrome/renderer/resources/extensions/automation/automation_node.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.
 
 var AutomationEvent = require('automationEvent').AutomationEvent;
 var automationInternal =
     require('binding').Binding.create('automationInternal').generate();
 var IsInteractPermitted =
     requireNative('automationInternal').IsInteractPermitted;
 
 var lastError = require('lastError');
 var logging = requireNative('logging');
 var schema = requireNative('automationInternal').GetSchemaAdditions();
 var utils = require('utils');
 
 /**
+ * Maps an id in the form:
+ *     <process_id>_<routing_id>
+ *     to an AutomationNode with role type webArea.
+ * @type {!Object.<string, string>}
+ */
+var idToWebArea_ = {};
+
+/**
  * A single node in the Automation tree.
  * @param {AutomationRootNodeImpl} root The root of the tree.
  * @constructor
  */
 function AutomationNodeImpl(root) {
   this.rootImpl = root;
   this.childIds = [];
   // Public attributes. No actual data gets set on this object.
   this.attributes = {};
   // Internal object holding all attributes.
   this.attributesInternal = {};
   this.listeners = {};
   this.location = { left: 0, top: 0, width: 0, height: 0 };
 }
 
 AutomationNodeImpl.prototype = {
   id: -1,
   role: '',
   state: { busy: true },
   isRootNode: false,
 
   get root() {
     return this.rootImpl.wrapper;
   },
 
   parent: function() {
+    if (this.role == schema.RoleType.rootWebArea) {
+      var parentId = this.processID + '_' + this.routingID;
+      if (idToWebArea_[parentId])
+        return idToWebArea_[parentId];
+    }
     return this.rootImpl.get(this.parentID);
   },
 
   firstChild: function() {
-    var node = this.rootImpl.get(this.childIds[0]);
-    return node;
+    return this.lookupWebAreaChild_() || this.rootImpl.get(this.childIds[0]);
   },
 
   lastChild: function() {
     var childIds = this.childIds;
-    var node = this.rootImpl.get(childIds[childIds.length - 1]);
-    return node;
+    return this.lookupWebAreaChild_() ||
+        this.rootImpl.get(childIds[childIds.length - 1]);
   },
 
   children: function() {
     var children = [];
     for (var i = 0, childID; childID = this.childIds[i]; i++) {
       logging.CHECK(this.rootImpl.get(childID));
       children.push(this.rootImpl.get(childID));
     }
     return children;
   },
@@ skipping 46 matching lines @@
           listeners.splice(i, 1);
       }
     }
   },
 
   dispatchEvent: function(eventType) {
     var path = [];
     var parent = this.parent();
     while (parent) {
       path.push(parent);
-      // TODO(aboxhall/dtseng): handle unloaded parent node
       parent = parent.parent();
     }
     var event = new AutomationEvent(eventType, this.wrapper);
 
     // Dispatch the event through the propagation path in three phases:
     // - capturing: starting from the root and going down to the target's parent
     // - targeting: dispatching the event on the target itself
     // - bubbling: starting from the target's parent, going back up to the root.
     // At any stage, a listener may call stopPropagation() on the event, which
     // will immediately stop event propagation through this path.
     if (this.dispatchEventAtCapturing_(event, path)) {
       if (this.dispatchEventAtTargeting_(event, path))
         this.dispatchEventAtBubbling_(event, path);
     }
   },
 
   toString: function() {
     return 'node id=' + this.id +
         ' role=' + this.role +
         ' state=' + $JSON.stringify(this.state) +
         ' parentID=' + this.parentID +
         ' childIds=' + $JSON.stringify(this.childIds) +
         ' attributes=' + $JSON.stringify(this.attributes);
   },
 
+  lookupWebAreaChild_: function() {
+    if (this.role != schema.RoleType.webArea)
+      return null;
+
+    return automationUtil.idToAutomationRootNode[
+      automationUtil.createAutomationRootNodeID(
+          this.processID, this.routingID)];
+  },
+
   dispatchEventAtCapturing_: function(event, path) {
     privates(event).impl.eventPhase = Event.CAPTURING_PHASE;
     for (var i = path.length - 1; i >= 0; i--) {
       this.fireEventListeners_(path[i], event);
       if (privates(event).impl.propagationStopped)
         return false;
     }
     return true;
   },
 
@@ skipping 128 matching lines @@
   this.processID = processID;
   this.routingID = routingID;
   this.axNodeDataCache_ = {};
 }
 
 AutomationRootNodeImpl.prototype = {
   __proto__: AutomationNodeImpl.prototype,
 
   isRootNode: true,
 
+  loaded: false,
+
   get: function(id) {
     if (id == undefined)
       return undefined;
 
     return this.axNodeDataCache_[id];
   },
 
   unserialize: function(update) {
     var updateState = { pendingNodes: {}, newNodes: {} };
     var oldRootId = this.id;
@@ skipping 41 matching lines @@
                     null,
                     chrome);
       return false;
     }
     return true;
   },
 
   destroy: function() {
     this.dispatchEvent(schema.EventType.destroyed);
     this.invalidate_(this.wrapper);
+    idToWebArea_[automationUtil.createAutomationRootNodeID(this.processID,
+        this.routingID)] = undefined;
   },
 
   onAccessibilityEvent: function(eventParams) {
     if (!this.unserialize(eventParams.update)) {
       logging.WARNING('unserialization failed');
       return false;
     }
 
     var targetNode = this.get(eventParams.targetID);
     if (targetNode) {
@@ skipping 33 matching lines @@
 
     // Retrieve the internal AutomationNodeImpl instance for this node.
     // This object is not accessible outside of bindings code, but we can access
     // it here.
     var nodeImpl = privates(node).impl;
     var id = nodeImpl.id;
     for (var key in AutomationAttributeDefaults) {
       nodeImpl[key] = AutomationAttributeDefaults[key];
     }
     nodeImpl.childIds = [];
-    nodeImpl.loaded = false;
     nodeImpl.id = id;
     delete this.axNodeDataCache_[id];
   },
 
-  load: function(callback) {
-    // TODO(dtseng/aboxhall): Implement.
-    if (!this.loaded)
-      throw 'Unsupported state: root node is not loaded.';
-
-    setTimeout(callback, 0);
-  },
-
   deleteOldChildren_: function(node, newChildIds) {
     // Create a set of child ids in |src| for fast lookup, and return false
     // if a duplicate is found;
     var newChildIdSet = {};
     for (var i = 0; i < newChildIds.length; i++) {
       var childId = newChildIds[i];
       if (newChildIdSet[childId]) {
         logging.WARNING('Node ' + privates(node).impl.id +
                         ' has duplicate child id ' + childId);
         lastError.set('automation',
@@ skipping 51 matching lines @@
         childNode = new AutomationNode(this);
         this.axNodeDataCache_[childId] = childNode;
         privates(childNode).impl.id = childId;
         updateState.pendingNodes[childId] = childNode;
         updateState.newNodes[childId] = childNode;
       }
       privates(childNode).impl.indexInParent = i;
       privates(childNode).impl.parentID = privates(node).impl.id;
     }
 
+    if (node.role == schema.RoleType.webArea && node.children().length == 0) {
+      var pid = node.processID;
+      var rid = node.attributes.routingID;
+      var id = automationUtil.createAutomationRootNodeID(pid, rid);
+      var targetTree = automationUtil.idToAutomationRootNode[id];
+      if (!targetTree)
+        targetTree = new AutomationRootNode(pid, rid);
+      automationUtil.idToAutomationRootNode[id] = targetTree;
+    }
+
     return success;
   },
 
   setData_: function(node, nodeData) {
     var nodeImpl = privates(node).impl;
+
+    if (nodeData.role == schema.RoleType.webArea) {
+      nodeImpl.processID = nodeData.intAttributes.frameId;
+      nodeImpl.routingID = nodeData.intAttributes.childFrameId;
+      idToWebArea_[nodeImpl.processID +
+          '_' +
+          nodeImpl.routingID] = node;
+      delete nodeData.intAttributes['processId'];
+      delete nodeData.intAttributes['routingId'];
+    }
     for (var key in AutomationAttributeDefaults) {
       if (key in nodeData)
         nodeImpl[key] = nodeData[key];
       else
         nodeImpl[key] = AutomationAttributeDefaults[key];
     }
     for (var i = 0; i < AutomationAttributeTypes.length; i++) {
       var attributeType = AutomationAttributeTypes[i];
       for (var attributeName in nodeData[attributeType]) {
         nodeImpl.attributesInternal[attributeName] =
@@ skipping 26 matching lines @@
               return node.rootImpl.get(current);
             }, this);
           }
           return node.rootImpl.get(attributeId);
         }
         return node.attributesInternal[attributeName];
       }.bind(this),
     });
   },
 
+  load: function(callback) {
+    if (!this.loaded)
+      automationInternal.enableFrame(this.processID, this.routingID);
+
+    automationUtil.storeTreeCallback(this.processID, this.routingID,
+        function(root) {
+          privates(root).impl.loaded = true;
+          if (callback)
+            callback(root);
+        });
+  },
+
   updateNode_: function(nodeData, updateState) {
     var node = this.axNodeDataCache_[nodeData.id];
     var didUpdateRoot = false;
     if (node) {
       delete updateState.pendingNodes[privates(node).impl.id];
     } else {
       if (nodeData.role != schema.RoleType.rootWebArea &&
           nodeData.role != schema.RoleType.desktop) {
         logging.WARNING(String(nodeData.id) +
                      ' is not in the cache and not the new root.');
@@ skipping 38 matching lines @@
                                                 'firstChild',
                                                 'lastChild',
                                                 'children',
                                                 'previousSibling',
                                                 'nextSibling',
                                                 'doDefault',
                                                 'focus',
                                                 'makeVisible',
                                                 'setSelection',
                                                 'addEventListener',
-                                                'removeEventListener'],
+                                                'removeEventListener',
+                                                'load'],
                                     readonly: ['isRootNode',
                                                'role',
                                                'state',
                                                'location',
                                                'attributes',
                                                'root'] });
 
 var AutomationRootNode = utils.expose('AutomationRootNode',
                                       AutomationRootNodeImpl,
                                       { superclass: AutomationNode,
                                         functions: ['load'],
                                         readonly: ['loaded'] });
 
 exports.AutomationNode = AutomationNode;
 exports.AutomationRootNode = AutomationRootNode;