Remove attributes and methods which should not be part of the public API

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;
 
@@ skipping 179 matching lines @@
                       'during phase ' + eventPhase + ': ' +
                       e.message + '\nStack trace: ' + e.stack);
       }
     }
   },
 
   performAction_: function(actionType, opt_args) {
     // Not yet initialized.
     if (this.rootImpl.processID === undefined ||
         this.rootImpl.routingID === undefined ||
-        this.wrapper.id === undefined) {
+        this.id === undefined) {
       return;
     }
 
     // Check permissions.
     if (!IsInteractPermitted()) {
       throw new Error(actionType + ' requires {"desktop": true} or' +
           ' {"interact": true} in the "automation" manifest key.');
     }
 
     automationInternal.performAction({ processID: this.rootImpl.processID,
                                        routingID: this.rootImpl.routingID,
-                                       automationNodeID: this.wrapper.id,
+                                       automationNodeID: this.id,
                                        actionType: actionType },
                                      opt_args || {});
   }
 };
 
 // Maps an attribute to its default value in an invalidated node.
 // These attributes are taken directly from the Automation idl.
 var AutomationAttributeDefaults = {
   'id': -1,
   'role': '',
@@ skipping 99 matching lines @@
                       null,
                       chrome);
         return false;
       }
       if (nodeToClear === this.wrapper) {
         this.invalidate_(nodeToClear);
       } else {
         var children = nodeToClear.children();
         for (var i = 0; i < children.length; i++)
           this.invalidate_(children[i]);
-        privates(nodeToClear).impl.childIds = []
-        updateState.pendingNodes[nodeToClear.id] = nodeToClear;
+        var nodeToClearImpl = privates(nodeToClear).impl;
+        nodeToClearImpl.childIds = []
+        updateState.pendingNodes[nodeToClearImpl.id] = nodeToClear;
       }
     }
 
     for (var i = 0; i < update.nodes.length; i++) {
       if (!this.updateNode_(update.nodes[i], updateState))
         return false;
     }
 
     if (Object.keys(updateState.pendingNodes).length > 0) {
       logging.WARNING('Nodes left pending by the update: ' +
@@ skipping 51 matching lines @@
       return;
     var children = node.children();
 
     for (var i = 0, child; child = children[i]; i++)
       this.invalidate_(child);
 
     // 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 = node.id;
+    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 ' + node.id + ' has duplicate child id ' +
-                        childId);
+        logging.WARNING('Node ' + privates(node).impl.id +
+                        ' has duplicate child id ' + childId);
         lastError.set('automation',
                       'Bad update received on automation tree',
                       null,
                       chrome);
         return false;
       }
       newChildIdSet[newChildIds[i]] = true;
     }
 
     // Delete the old children.
@@ skipping 14 matching lines @@
   },
 
   createNewChildren_: function(node, newChildIds, updateState) {
     logging.CHECK(node);
     var success = true;
     for (var i = 0; i < newChildIds.length; i++) {
       var childId = newChildIds[i];
       var childNode = this.axNodeDataCache_[childId];
       if (childNode) {
         if (childNode.parent() != node) {
-          var parentId = 0;
-          if (childNode.parent()) parentId = childNode.parent().id;
+          var parentId = -1;
+          if (childNode.parent()) {
+            var parentImpl = privates(childNode.parent()).impl;
+            parentId = parentImpl.id;
+          }
           // This is a serious error - nodes should never be reparented.
           // If this case occurs, continue so this node isn't left in an
           // inconsistent state, but return failure at the end.
           logging.WARNING('Node ' + childId + ' reparented from ' +
-                          parentId + ' to ' + node.id);
+                          parentId + ' to ' + privates(node).impl.id);
           lastError.set('automation',
                         'Bad update received on automation tree',
                         null,
                         chrome);
           success = false;
           continue;
         }
       } else {
         childNode = new AutomationNode(this);
         this.axNodeDataCache_[childId] = childNode;
         privates(childNode).impl.id = childId;
-        updateState.pendingNodes[childNode.id] = childNode;
-        updateState.newNodes[childNode.id] = childNode;
+        updateState.pendingNodes[childId] = childNode;
+        updateState.newNodes[childId] = childNode;
       }
       privates(childNode).impl.indexInParent = i;
-      privates(childNode).impl.parentID = node.id;
+      privates(childNode).impl.parentID = privates(node).impl.id;
     }
 
     return success;
   },
 
   setData_: function(node, nodeData) {
     var nodeImpl = privates(node).impl;
     for (var key in AutomationAttributeDefaults) {
       if (key in nodeData) {
         if (key == 'id' && nodeImpl[key] != nodeData[key]) {
@@ skipping 42 matching lines @@
         }
         return node.attributesInternal[attributeName];
       }.bind(this),
     });
   },
 
   updateNode_: function(nodeData, updateState) {
     var node = this.axNodeDataCache_[nodeData.id];
     var didUpdateRoot = false;
     if (node) {
-      delete updateState.pendingNodes[node.id];
+      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.');
         lastError.set('automation',
                       'Bad update received on automation tree',
                       null,
                       chrome);
         return false;
@@ skipping 13 matching lines @@
         this.invalidate_(this.wrapper);
       }
       return false;
     }
     var nodeImpl = privates(node).impl;
 
     var success = this.createNewChildren_(node,
                                           nodeData.childIds,
                                           updateState);
     nodeImpl.childIds = nodeData.childIds;
-    this.axNodeDataCache_[node.id] = node;
+    this.axNodeDataCache_[nodeImpl.id] = node;
 
     return success;
   }
 };
 
 
 var AutomationNode = utils.expose('AutomationNode',
                                   AutomationNodeImpl,
                                   { functions: ['parent',
                                                 'firstChild',
                                                 'lastChild',
                                                 'children',
                                                 'previousSibling',
                                                 'nextSibling',
                                                 'doDefault',
                                                 'focus',
                                                 'makeVisible',
                                                 'setSelection',
                                                 'addEventListener',
-                                                'removeEventListener',
-                                                'toString'],
+                                                'removeEventListener'],
                                     readonly: ['isRootNode',
-                                               'id',
                                                'role',
                                                'state',
                                                'location',
                                                'attributes',
-                                               'root',
-                                               'toString'] });
+                                               'root'] });
 
 var AutomationRootNode = utils.expose('AutomationRootNode',
                                       AutomationRootNodeImpl,
                                       { superclass: AutomationNode,
                                         functions: ['load'],
                                         readonly: ['loaded'] });
 
 exports.AutomationNode = AutomationNode;
 exports.AutomationRootNode = AutomationRootNode;