Sanitize inheritance in callers of utils.expose

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 exceptionHandler = require('uncaught_exception_handler');
 var IsInteractPermitted =
     requireNative('automationInternal').IsInteractPermitted;
@@ skipping 181 matching lines @@
 var schema = requireNative('automationInternal').GetSchemaAdditions();
 var utils = require('utils');
 
 /**
  * A single node in the Automation tree.
  * @param {AutomationRootNodeImpl} root The root of the tree.
  * @constructor
  */
 function AutomationNodeImpl(root) {
   this.rootImpl = root;
-  // Public attributes. No actual data gets set on this object.
-  this.listeners = {};
+  this.listeners = {__proto__: null};
 }
 
 AutomationNodeImpl.prototype = {
+  __proto__: null,
   treeID: -1,
   id: -1,
-  role: '',
-  state: { busy: true },
   isRootNode: false,
 
   get root() {
     return this.rootImpl.wrapper;
   },
 
   get parent() {
     if (this.hostNode_)
       return this.hostNode_;
     var parentID = GetParentID(this.treeID, this.id);
@@ skipping 47 matching lines @@
 
   get children() {
     if (this.childTree)
       return [this.childTree];
 
     var children = [];
     var count = GetChildCount(this.treeID, this.id);
     for (var i = 0; i < count; ++i) {
       var childID = GetChildIDAtIndex(this.treeID, this.id, i);
       var child = this.rootImpl.get(childID);
-      children.push(child);
+      $Array.push(children, child);
     }
     return children;
   },
 
   get previousSibling() {
     var parent = this.parent;
     var indexInParent = GetIndexInParent(this.treeID, this.id);
     if (parent && indexInParent > 0)
       return parent.children[indexInParent - 1];
     return undefined;
@@ skipping 30 matching lines @@
 
   showContextMenu: function() {
     this.performAction_('showContextMenu');
   },
 
   domQuerySelector: function(selector, callback) {
     automationInternal.querySelector(
       { treeID: this.rootImpl.treeID,
         automationNodeID: this.id,
         selector: selector },
-      this.domQuerySelectorCallback_.bind(this, callback));
+      $Function.bind(this.domQuerySelectorCallback_, this, callback));
   },
 
   find: function(params) {
     return this.findInternal_(params);
   },
 
   findAll: function(params) {
     return this.findInternal_(params, []);
   },
 
   matches: function(params) {
     return this.matchInternal_(params);
   },
 
   addEventListener: function(eventType, callback, capture) {
     this.removeEventListener(eventType, callback);
     if (!this.listeners[eventType])
       this.listeners[eventType] = [];
-    this.listeners[eventType].push({callback: callback, capture: !!capture});
+    $Array.push(this.listeners[eventType], {
+      __proto__: null,
+      callback: callback,
+      capture: !!capture,
+    });
   },
 
   // TODO(dtseng/aboxhall): Check this impl against spec.
   removeEventListener: function(eventType, callback) {
     if (this.listeners[eventType]) {
       var listeners = this.listeners[eventType];
       for (var i = 0; i < listeners.length; i++) {
         if (callback === listeners[i].callback)
-          listeners.splice(i, 1);
+          $Array.splice(listeners, i, 1);
       }
     }
   },
 
   toJSON: function() {
     return { treeID: this.treeID,
              id: this.id,
              role: this.role,
              attributes: this.attributes };
   },
 
   dispatchEvent: function(eventType) {
     var path = [];
     var parent = this.parent;
     while (parent) {
-      path.push(parent);
+      $Array.push(path, parent);
       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() {
     var parentID = GetParentID(this.treeID, this.id);
     var childTreeID = GetIntAttribute(this.treeID, this.id, 'childTreeId');
     var count = GetChildCount(this.treeID, this.id);
     var childIDs = [];
     for (var i = 0; i < count; ++i) {
       var childID = GetChildIDAtIndex(this.treeID, this.id, i);
-      childIDs.push(childID);
+      $Array.push(childIDs, childID);
     }
 
     var result = 'node id=' + this.id +
         ' role=' + this.role +
         ' state=' + $JSON.stringify(this.state) +
         ' parentID=' + parentID +
         ' childIds=' + $JSON.stringify(childIDs);
     if (this.hostNode_) {
       var hostNodeImpl = privates(this.hostNode_).impl;
       result += ' host treeID=' + hostNodeImpl.treeID +
@@ skipping 85 matching lines @@
       userCallback(null);
     }
     userCallback(resultNode);
   },
 
   findInternal_: function(params, opt_results) {
     var result = null;
     this.forAllDescendants_(function(node) {
       if (privates(node).impl.matchInternal_(params)) {
         if (opt_results)
-          opt_results.push(node);
+          $Array.push(opt_results, node);
         else
           result = node;
         return !opt_results;
       }
     });
     if (opt_results)
       return opt_results;
     return result;
   },
 
   /**
    * Executes a closure for all of this node's descendants, in pre-order.
    * Early-outs if the closure returns true.
    * @param {Function(AutomationNode):boolean} closure Closure to be executed
    *     for each node. Return true to early-out the traversal.
    */
   forAllDescendants_: function(closure) {
-    var stack = this.wrapper.children.reverse();
+    var stack = $Array.reverse(this.wrapper.children);
     while (stack.length > 0) {
-      var node = stack.pop();
+      var node = $Array.pop(stack);
       if (closure(node))
         return;
 
       var children = node.children;
       for (var i = children.length - 1; i >= 0; i--)
-        stack.push(children[i]);
+        $Array.push(stack, children[i]);
     }
   },
 
   matchInternal_: function(params) {
-    if (Object.keys(params).length == 0)
+    if ($Object.keys(params).length === 0)
       return false;
 
     if ('role' in params && this.role != params.role)
         return false;
 
     if ('state' in params) {
       for (var state in params.state) {
         if (params.state[state] != (state in this.state))
           return false;
       }
     }
     if ('attributes' in params) {
       for (var attribute in params.attributes) {
         var attrValue = params.attributes[attribute];
         if (typeof attrValue != 'object') {
           if (this[attribute] !== attrValue)
             return false;
-        } else if (attrValue instanceof RegExp) {
+        } else if (attrValue instanceof $RegExp.self) {
           if (typeof this[attribute] != 'string')
             return false;
           if (!attrValue.test(this[attribute]))
             return false;
         } else {
           // TODO(aboxhall): handle intlist case.
           return false;
         }
       }
     }
@@ skipping 90 matching lines @@
     'valueForRange',
     'minValueForRange',
     'maxValueForRange',
     'fontSize'];
 
 var htmlAttributes = [
     ['type', 'inputType']];
 
 var publicAttributes = [];
 
-stringAttributes.forEach(function (attributeName) {
-  publicAttributes.push(attributeName);
-  Object.defineProperty(AutomationNodeImpl.prototype, attributeName, {
+$Array.forEach(stringAttributes, function(attributeName) {
+  $Array.push(publicAttributes, attributeName);
+  $Object.defineProperty(AutomationNodeImpl.prototype, attributeName, {
+    __proto__: null,
     get: function() {
       return GetStringAttribute(this.treeID, this.id, attributeName);
     }
   });
 });
 
-boolAttributes.forEach(function (attributeName) {
-  publicAttributes.push(attributeName);
-  Object.defineProperty(AutomationNodeImpl.prototype, attributeName, {
+$Array.forEach(boolAttributes, function(attributeName) {
+  $Array.push(publicAttributes, attributeName);
+  $Object.defineProperty(AutomationNodeImpl.prototype, attributeName, {
+    __proto__: null,
     get: function() {
       return GetBoolAttribute(this.treeID, this.id, attributeName);
     }
   });
 });
 
-intAttributes.forEach(function (attributeName) {
-  publicAttributes.push(attributeName);
-  Object.defineProperty(AutomationNodeImpl.prototype, attributeName, {
+$Array.forEach(intAttributes, function(attributeName) {
+  $Array.push(publicAttributes, attributeName);
+  $Object.defineProperty(AutomationNodeImpl.prototype, attributeName, {
+    __proto__: null,
     get: function() {
       return GetIntAttribute(this.treeID, this.id, attributeName);
     }
   });
 });
 
-nodeRefAttributes.forEach(function (params) {
+$Array.forEach(nodeRefAttributes, function(params) {
   var srcAttributeName = params[0];
   var dstAttributeName = params[1];
-  publicAttributes.push(dstAttributeName);
-  Object.defineProperty(AutomationNodeImpl.prototype, dstAttributeName, {
+  $Array.push(publicAttributes, dstAttributeName);
+  $Object.defineProperty(AutomationNodeImpl.prototype, dstAttributeName, {
+    __proto__: null,
     get: function() {
       var id = GetIntAttribute(this.treeID, this.id, srcAttributeName);
       if (id)
         return this.rootImpl.get(id);
       else
         return undefined;
     }
   });
 });
 
-intListAttributes.forEach(function (attributeName) {
-  publicAttributes.push(attributeName);
-  Object.defineProperty(AutomationNodeImpl.prototype, attributeName, {
+$Array.forEach(intListAttributes, function(attributeName) {
+  $Array.push(publicAttributes, attributeName);
+  $Object.defineProperty(AutomationNodeImpl.prototype, attributeName, {
+    __proto__: null,
     get: function() {
       return GetIntListAttribute(this.treeID, this.id, attributeName);
     }
   });
 });
 
-nodeRefListAttributes.forEach(function (params) {
+$Array.forEach(nodeRefListAttributes, function(params) {
   var srcAttributeName = params[0];
   var dstAttributeName = params[1];
-  publicAttributes.push(dstAttributeName);
-  Object.defineProperty(AutomationNodeImpl.prototype, dstAttributeName, {
+  $Array.push(publicAttributes, dstAttributeName);
+  $Object.defineProperty(AutomationNodeImpl.prototype, dstAttributeName, {
+    __proto__: null,
     get: function() {
       var ids = GetIntListAttribute(this.treeID, this.id, srcAttributeName);
       if (!ids)
         return undefined;
       var result = [];
       for (var i = 0; i < ids.length; ++i) {
         var node = this.rootImpl.get(ids[i]);
         if (node)
-          result.push(node);
+          $Array.push(result, node);
       }
       return result;
     }
   });
 });
 
-floatAttributes.forEach(function (attributeName) {
-  publicAttributes.push(attributeName);
-  Object.defineProperty(AutomationNodeImpl.prototype, attributeName, {
+$Array.forEach(floatAttributes, function(attributeName) {
+  $Array.push(publicAttributes, attributeName);
+  $Object.defineProperty(AutomationNodeImpl.prototype, attributeName, {
+    __proto__: null,
     get: function() {
       return GetFloatAttribute(this.treeID, this.id, attributeName);
     }
   });
 });
 
-htmlAttributes.forEach(function (params) {
+$Array.forEach(htmlAttributes, function(params) {
   var srcAttributeName = params[0];
   var dstAttributeName = params[1];
-  publicAttributes.push(dstAttributeName);
-  Object.defineProperty(AutomationNodeImpl.prototype, dstAttributeName, {
+  $Array.push(publicAttributes, dstAttributeName);
+  $Object.defineProperty(AutomationNodeImpl.prototype, dstAttributeName, {
+    __proto__: null,
     get: function() {
       return GetHtmlAttribute(this.treeID, this.id, srcAttributeName);
     }
   });
 });
 
 /**
  * AutomationRootNode.
  *
  * An AutomationRootNode is the javascript end of an AXTree living in the
  * browser. AutomationRootNode handles unserializing incremental updates from
  * the source AXTree. Each update contains node data that form a complete tree
  * after applying the update.
  *
  * A brief note about ids used through this class. The source AXTree assigns
  * unique ids per node and we use these ids to build a hash to the actual
  * AutomationNode object.
  * Thus, tree traversals amount to a lookup in our hash.
  *
  * The tree itself is identified by the accessibility tree id of the
  * renderer widget host.
  * @constructor
  */
 function AutomationRootNodeImpl(treeID) {
-  AutomationNodeImpl.call(this, this);
+  $Function.call(AutomationNodeImpl, this, this);
   this.treeID = treeID;
-  this.axNodeDataCache_ = {};
+  this.axNodeDataCache_ = {__proto__: null};
 }
 
-AutomationRootNodeImpl.idToAutomationRootNode_ = {};
+utils.defineProperty(AutomationRootNodeImpl, 'idToAutomationRootNode_',
+    {__proto__: null});
 
-AutomationRootNodeImpl.get = function(treeID) {
+utils.defineProperty(AutomationRootNodeImpl, 'get', function(treeID) {
   var result = AutomationRootNodeImpl.idToAutomationRootNode_[treeID];
   return result || undefined;
-}
+});
 
-AutomationRootNodeImpl.getOrCreate = function(treeID) {
+utils.defineProperty(AutomationRootNodeImpl, 'getOrCreate', function(treeID) {
   if (AutomationRootNodeImpl.idToAutomationRootNode_[treeID])
     return AutomationRootNodeImpl.idToAutomationRootNode_[treeID];
   var result = new AutomationRootNode(treeID);
   AutomationRootNodeImpl.idToAutomationRootNode_[treeID] = result;
   return result;
-}
+});
 
-AutomationRootNodeImpl.destroy = function(treeID) {
+utils.defineProperty(AutomationRootNodeImpl, 'destroy', function(treeID) {
   delete AutomationRootNodeImpl.idToAutomationRootNode_[treeID];
-}
+});
 
 AutomationRootNodeImpl.prototype = {
   __proto__: AutomationNodeImpl.prototype,
 
   /**
    * @type {boolean}
    */
   isRootNode: true,
 
   /**
@@ skipping 115 matching lines @@
   },
 
   toString: function() {
     function toStringInternal(nodeImpl, indent) {
       if (!nodeImpl)
         return '';
       var output = '';
       if (nodeImpl.isRootNode)
         output += indent + 'tree id=' + nodeImpl.treeID + '\n';
       output += indent +
-          AutomationNodeImpl.prototype.toString.call(nodeImpl) +
-          '\n';
+        $Function.call(AutomationNodeImpl.prototype.toString, nodeImpl) + '\n';
       indent += '  ';
       var children = nodeImpl.children;
       for (var i = 0; i < children.length; ++i)
         output += toStringInternal(privates(children[i]).impl, indent);
       return output;
     }
     return toStringInternal(this, '');
   },
 };
 
@@ skipping 42 matching lines @@
     'docUrl',
     'docLoaded',
     'docLoadingProgress',
     'anchorObject',
     'anchorOffset',
     'focusObject',
     'focusOffset',
   ],
 });
 
-AutomationRootNode.get = function(treeID) {
+utils.defineProperty(AutomationRootNode, 'get', function(treeID) {
   return AutomationRootNodeImpl.get(treeID);
-}
+});
 
-AutomationRootNode.getOrCreate = function(treeID) {
+utils.defineProperty(AutomationRootNode, 'getOrCreate', function(treeID) {
   return AutomationRootNodeImpl.getOrCreate(treeID);
-}
+});
 
-AutomationRootNode.destroy = function(treeID) {
+utils.defineProperty(AutomationRootNode, 'destroy', function(treeID) {
   AutomationRootNodeImpl.destroy(treeID);
-}
+});
 
 exports.$set('AutomationNode', AutomationNode);
 exports.$set('AutomationRootNode', AutomationRootNode);