Implement actions for Automation 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 automationInternal =
+    require('binding').Binding.create('automationInternal').generate();
 var utils = require('utils');
 
 /**
  * A single node in the Automation tree.
  * @param {AutomationTree} owner The owning tree.
  * @constructor
  */
 var AutomationNodeImpl = function(owner) {
   this.owner = owner;
   this.child_ids = [];
-
   this.attributes = {};
+  this.listeners = {};
 };
 
 AutomationNodeImpl.prototype = {
   parent: function() {
     return this.owner.get(this.parent_id);
   },
 
   firstChild: function() {
     var node = this.owner.get(this.child_ids[0]);
     return node;
@@ skipping 18 matching lines @@
       return parent.children()[this.index_in_parent - 1];
     return undefined;
   },
 
   nextSibling: function() {
     var parent = this.parent();
     if (parent && this.index_in_parent < parent.children().length)
       return parent.children()[this.index_in_parent + 1];
     return undefined;
   },
+
+  doDefault: function() {
+    this.performAction_('doDefault');
+    },

[not at google - send to devlin, 2014/04/02 21:52:14]

indent -= 2

[David Tseng, 2014/04/03 01:27:41]

Done.

+
+  focus: function() {
+    this.performAction_('focus');
+  },
+
+  makeVisible: function() {
+    this.performAction_('makeVisible');
+  },
+
+  setSelection: function(startIndex, endIndex) {
+    this.performAction_('setSelection',
+                        {start_index: startIndex, end_index: endIndex});
+  },
+
+  addEventListener: function(eventType, callback, capture) {
+    this.removeEventListener(eventType, callback);
+    if (!this.listeners[eventType])
+      this.listeners[eventType] = [];
+    this.listeners[eventType].push([callback, capture]);
+  },
+
+  // TODO(dtseng/aboxhall): Check this impl against spec.

[not at google - send to devlin, 2014/04/02 21:52:14]

maybe this is too hacky, and I wish you could just "new EventTarget()" and do
this, but could you create a fake div element and fire events on that?

like:

function AutomationNodeImpl() {
  self.eventTarget = document.createElement('div');
}

here:

addEventListener: function(eventType, callback, capture) {
  self.eventTarget.addEventListener(eventTYpe, callback, capture);
}

same for removeEventListner

then when you disaptch the event

notifyEventListeners: function(eventType) {
  self.eventTarget.disptachEvent(new CustomEvent(eventType, {/*details*/}));
}

[aboxhall, 2014/04/02 22:01:15]

That won't work: note that we plan to implement capture and bubbling phases here
as well.

We'll be fleshing out the event listener stuff in a later CL.

[not at google - send to devlin, 2014/04/02 22:09:40]

Ok.

I hope that eventually you can pull that out into some external Event class
which this can delegate too, or if you're really lucky, blink will need to
expose something like that for itself (since they're rewriting the editing stuff
in JS).

[David Tseng, 2014/04/02 22:14:56]

That's sort of what I think we had in mind; this cl just got the bare minimum
going to be able to test actions. We'll update the design doc accordingly.

+  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][0])
+          listeners.splice(i, 1);
+      }
+    }
+  },
+
+  notifyEventListeners: function(eventType) {
+    var listeners = this.listeners[eventType];
+    if (!listeners)
+      return;
+    // TODO(dtseng/aboxhall): Implement capture/bubble.
+    for (var i = 0; i < listeners.length; i++)
+      listeners[i][0]();
+  },
+
+  performAction_: function(actionType, opt_args) {
+    // Not yet initialized.
+    if (!this.owner.processId ||
+        !this.owner.routingId ||
+        !this.wrapper.id)
+      return;
+    automationInternal.performAction(this.owner.processId,
+                                     this.owner.routingId,
+                                     this.wrapper.id,
+                                     actionType,
+                                     opt_args ? opt_args : {});
+  },
 };
 
-
 var AutomationNode = utils.expose('AutomationNode',
                                   AutomationNodeImpl,
                                   ['parent',
                                    'firstChild',
                                    'lastChild',
                                    'children',
                                    'previousSibling',
-                                   'nextSibling']);
+                                   'nextSibling',
+                                   'doDefault',
+                                   'focus',
+                                   'makeVisible',
+                                   'setSelection',
+                                   'addEventListener',
+                                   'removeEventListener']);
 exports.AutomationNode = AutomationNode;