Add beginnings of a injected wrappers for the interactions API. This requires

the mouse and keyboard state to be tracked outside of the atoms and injected
with each call. The new device state will be in returned in the response
object's value property.

This has been tested on OS X 10.8.5 against Safari 6.1, Chrome 33,
Firefox 25, and Opera 12.

Author: jleyba

javascript/atoms/keyboard.js

@@ -40,8 +40,7 @@ goog.require('goog.userAgent');
  * A keyboard that provides atomic typing actions.
  *
  * @constructor
- * @param {{pressed: !Array.<!bot.Keyboard.Key>,
-            currentPos: number}=} opt_state Optional keyboard state.
+ * @param {bot.Keyboard.State=} opt_state Optional keyboard state.
  * @extends {bot.Device}
  */
 bot.Keyboard = function(opt_state) {
@@ -63,12 +62,20 @@ bot.Keyboard = function(opt_state) {
       this.setKeyPressed_(/** @type {!bot.Keyboard.Key} */ (key), true);
     }, this);
 
-    this.currentPos_ = opt_state['currentPos'];
+    this.currentPos_ = opt_state['currentPos'] || 0;
   }
 };
 goog.inherits(bot.Keyboard, bot.Device);
 
 
+/**
+ * Describes the current state of a keyboard.
+ * @typedef {{pressed: !Array.<!bot.Keyboard.Key>,
+ *            currentPos: number}}
+ */
+bot.Keyboard.State;
+
+
 /**
  * Maps characters to (key,boolean) pairs, where the key generates the
  * character and the boolean is true when the shift must be pressed.
@@ -844,8 +851,7 @@ bot.Keyboard.prototype.moveCursor = function(element) {
 /**
  * Serialize the current state of the keyboard.
  *
- * @return {{pressed: !Array.<!bot.Keyboard.Key>, currentPos: number}} The
- *     current keyboard state.
+ * @return {bot.Keyboard.State} The current keyboard state.
  */
 bot.Keyboard.prototype.getState = function() {
   // Need to use quoted literals here, so the compiler will not rename the

javascript/atoms/mouse.js

@@ -68,7 +68,7 @@ bot.Mouse = function(opt_state, opt_modifiersState, opt_eventEmitter) {
   this.hasEverInteracted_ = false;
 
   if (opt_state) {
-    this.buttonPressed_ = opt_state.buttonPressed;
+    this.buttonPressed_ = opt_state.buttonPressed || null;
 
     try {
       if (bot.dom.isElement(opt_state.elementPressed)) {
@@ -78,9 +78,12 @@ bot.Mouse = function(opt_state, opt_modifiersState, opt_eventEmitter) {
       this.buttonPressed_ = null;
     }
 
-    this.clientXY_ = opt_state.clientXY;
-    this.nextClickIsDoubleClick_ = opt_state.nextClickIsDoubleClick;
-    this.hasEverInteracted_ = opt_state.hasEverInteracted;
+    this.clientXY_ = new goog.math.Coordinate(
+        opt_state.clientXY.x,
+        opt_state.clientXY.y);
+
+    this.nextClickIsDoubleClick_ = !!opt_state.nextClickIsDoubleClick;
+    this.hasEverInteracted_ = !!opt_state.hasEverInteracted;
 
     try {
       if (bot.dom.isElement(opt_state.element)) {

javascript/webdriver/atoms/fragments/inject/build.desc

@@ -174,3 +174,13 @@ js_fragment(name = "get_appcache_status",
   module = "webdriver.atoms.inject.storage.appcache",
   function = "webdriver.atoms.inject.storage.appcache.getStatus",
   deps = ["//javascript/webdriver/atoms/inject:deps"])
+
+js_fragment(name = "mouse_click",
+  module = "webdriver.atoms.inject.action",
+  function = "webdriver.atoms.inject.action.mouseClick",
+  deps = ["//javascript/webdriver/atoms/inject:deps"])
+
+js_fragment(name = "send_keys_to_active_element",
+  module = "webdriver.atoms.inject.action",
+  function = "webdriver.atoms.inject.action.sendKeysToActiveElement",
+  deps = ["//javascript/webdriver/atoms/inject:deps"])

javascript/webdriver/atoms/inject/action.js

@@ -19,11 +19,10 @@
 
 goog.provide('webdriver.atoms.inject.action');
 
-goog.require('bot.Keyboard');
-goog.require('bot.Mouse');
 goog.require('bot.action');
 goog.require('webdriver.atoms.element');
 goog.require('webdriver.atoms.inject');
+goog.require('webdriver.atoms.inputs');
 
 
 /**
@@ -86,20 +85,72 @@ webdriver.atoms.inject.action.click = function (element, opt_window) {
 };
 
 
+/**
+ * JSON representation of a {@link bot.Mouse.State} object.
+ * @typedef {{buttonPressed: ?bot.Mouse.Button,
+ *            elementPressed: ?bot.inject.JsonElement,
+ *            clientXY: {x: number, y: number},
+ *            nextClickIsDoubleClick: boolean,
+ *            hasEverInteracted: boolean,
+ *            element: ?bot.inject.JsonElement}}
+ */
+webdriver.atoms.inject.action.JsonMouseState;
+
+
+/**
+ * Clicks a mouse button.
+ *
+ * @param {bot.Mouse.Button} button The button to press.
+ * @param {webdriver.atoms.inject.action.JsonMouseState=} opt_mouseState The
+ *     current state of the mouse.
+ * @param {bot.inject.JsonWindow=} opt_window The window context for
+ *     the execution of the function.
+ * @return {string} A stringified {@link bot.response.ResponseObject}. The
+ *     mouse's new state, as a
+ *     {@link webdriver.atoms.inject.action.JsonMouseState} will be included
+ *     as the response value.
+ */
+webdriver.atoms.inject.action.mouseClick = function(
+    button, opt_mouseState, opt_window) {
+  return webdriver.atoms.inject.action.executeActionFunction_(
+      webdriver.atoms.inputs.mouseClick,
+      [button, opt_mouseState], opt_window);
+};
+
+
+/**
+ * Types a sequence of key strokes on the active element.
+ * @param {!Array.<string>} keys The keys to type.
+ * @param {bot.Keyboard.State=} opt_keyboardState The keyboard's state.
+ * @param {bot.inject.JsonWindow=} opt_window The window context for
+ *     the execution of the function.
+ * @return {string} A stringified {@link bot.response.ResponseObject}. The
+ *     keyboard's new state, as a {@link bot.Keyboard.State} will be included
+ *     as the response value.
+ */
+webdriver.atoms.inject.action.sendKeysToActiveElement = function(
+    keys, opt_keyboardState, opt_window) {
+  var persistModifiers = true;
+  return webdriver.atoms.inject.action.executeActionFunction_(
+      webdriver.atoms.inputs.sendKeys,
+      [null, keys, opt_keyboardState, persistModifiers], opt_window);
+};
+
+
 /**
  * @param {!Function} fn The function to call.
  * @param {!Array.<*>} args An array of function arguments for the function.
  * @param {bot.inject.JsonWindow=} opt_window The window context for
  *     the execution of the function.
  * @return {string} The serialized JSON wire protocol result of the function.
  */
-webdriver.atoms.inject.action.executeActionFunction_ =
-    function (fn, args, opt_window) {
+webdriver.atoms.inject.action.executeActionFunction_ = function (
+    fn, args, opt_window) {
   var response;
   try {
     var targetWindow = webdriver.atoms.inject.getWindow(opt_window);
-    var unwrappedArgs = /** @type {!Array} */(bot.inject.unwrapValue(args,
-        targetWindow.document));
+    var unwrappedArgs = /** @type {Array} */(bot.inject.unwrapValue(
+        args, targetWindow.document));
     var functionResult = fn.apply(null, unwrappedArgs);
     response = bot.inject.wrapResponse(functionResult);
   } catch (ex) {

javascript/webdriver/atoms/inputs.js

@@ -34,12 +34,10 @@ goog.require('webdriver.atoms.element');
  * @param {Element} element The element to send the keyboard input to, or
  *     {@code null} to use the document's active element.
  * @param {!Array.<string>} keys The keys to type on the element.
- * @param {{currentPos: number, pressed: !Array.<!bot.Keyboard.Key>}=} opt_state
- *     The predefined keyboard state to use.
+ * @param {bot.Keyboard.State=} opt_state The predefined keyboard state to use.
  * @param {boolean=} opt_persistModifiers Whether modifier keys should remain
  *     pressed when this function ends.
- * @return {{currentPos: number, pressed: !Array.<!bot.Keyboard.Key>}} The
- *     keyboard state.
+ * @return {bot.Keyboard.State} The keyboard state.
  */
 webdriver.atoms.inputs.sendKeys = function(
     element, keys, opt_state, opt_persistModifiers) {
@@ -170,10 +168,34 @@ webdriver.atoms.inputs.doubleClick = function(opt_state) {
  *
  * @param {bot.Mouse.State=} opt_state The serialized state of the mouse.
  * @return {!bot.Mouse.State} The mouse state.
+ * @deprecated Use {@link webdriver.atoms.inputs.mouseClick}.
  */
 webdriver.atoms.inputs.rightClick = function(opt_state) {
   var mouse = new bot.Mouse(opt_state);
   mouse.pressButton(bot.Mouse.Button.RIGHT);
   mouse.releaseButton();
   return mouse.getState();
 };
+
+
+/**
+ * Executes a mousedown/up with the given button at the current mouse
+ * location.
+ *
+ * @param {bot.Mouse.Button} button The button to press.
+ * @param {bot.Mouse.State=} opt_state The serialized state of the mouse.
+ * @return {!bot.Mouse.State} The mouse state.
+ */
+webdriver.atoms.inputs.mouseClick = function(button, opt_state) {
+  // If no target element is specified, try to find it from the
+  // client (x, y) location. No, this is not exact.
+  if (opt_state && opt_state.clientXY && !opt_state.element &&
+      document.elementFromPoint) {
+    opt_state.element = document.elementFromPoint(
+        opt_state.clientXY.x, opt_state.clientXY.y);
+  }
+  var mouse = new bot.Mouse(opt_state);
+  mouse.pressButton(button);
+  mouse.releaseButton();
+  return mouse.getState();
+};

javascript/webdriver/test/atoms/inject/interactions_test.html

@@ -0,0 +1,129 @@
+<!DOCTYPE html>
+<title>interactions_test</title>
+<script src="../../test_bootstrap.js"></script>
+<script>
+goog.require('bot.Keyboard');
+goog.require('bot.Mouse');
+goog.require('bot.color');
+goog.require('bot.dom');
+goog.require('bot.inject.cache');
+goog.require('bot.json');
+goog.require('bot.response');
+goog.require('goog.array');
+goog.require('goog.testing.jsunit');
+goog.require('webdriver.Key');
+goog.require('webdriver.atoms.inject.action');
+</script>
+<style>
+#click-box {
+  position: absolute;
+  width: 75px;
+  height: 75px;
+  top: 50px;
+  left: 50px;
+}
+</style>
+<body>
+<input id="focus-sync">
+<input id="text-input">
+<div id="click-box"></div>
+<script>
+var clickBox = document.getElementById('click-box');
+clickBox.style.background = 'red';
+clickBox.onclick = function(e) {
+  e = e || window.event;
+  clickBox.style.background = 'blue';
+  if (e.clientX > 100) {
+    clickBox.style.background = 'cyan';
+  }
+  if (e.clientY > 100) {
+    clickBox.style.background = 'yellow';
+  }
+};
+clickBox.oncontextmenu = function() {
+  clickBox.style.background = 'green';
+  return false;
+};
+
+
+function resetFocus() {
+  var sink = document.getElementById('focus-sync');
+  focusElement(sink);
+}
+
+
+function focusElement(el) {
+  el.focus();
+  assertEquals(el, bot.dom.getActiveElement(document));
+}
+
+
+function testSendKeysToActiveElement() {
+  resetFocus();
+
+  var input = document.getElementById('text-input');
+  focusElement(input);
+
+  var state = doType('foo');
+  assertEquals('foo', input.value);
+
+  resetFocus();
+
+  state['pressed'].push(bot.Keyboard.Keys.SHIFT);
+  state = doType('more', state);
+  assertEquals('foo', input.value);
+
+  focusElement(input);
+  doType(['bar', webdriver.Key.SHIFT, 'baz'], state);
+  assertEquals('fooBARbaz', input.value);
+
+  function doType(keys, opt_state) {
+    var res = webdriver.atoms.inject.action.sendKeysToActiveElement(
+        keys, opt_state);
+    res = bot.json.parse(res);
+    bot.response.checkResponse(res);
+    return res['value'];
+  }
+}
+
+function testMouseClick() {
+  assertEquals('initial state is wrong', 'rgba(255, 0, 0, 1)', getColor());
+
+  var state = doClick(bot.Mouse.Button.LEFT, {
+    clientXY: {x: 60, y: 60}  // Click over the clickBox.
+  });
+  assertEquals('rgba(0, 0, 255, 1)', getColor());
+  assertTrue(!!state['element']);
+  assertEquals(
+      clickBox, bot.inject.cache.getElement(state['element']['ELEMENT']));
+
+  state = doClick(bot.Mouse.Button.RIGHT, state);
+  assertEquals('rgba(0, 128, 0, 1)', getColor());
+
+  state.clientXY.x += 41;
+  assertEquals(101, state.clientXY.x);
+  doClick(bot.Mouse.Button.LEFT, state);
+  assertEquals('rgba(0, 255, 255, 1)', getColor());
+
+  state.clientXY.y += 41;
+  assertEquals(101, state.clientXY.y);
+  doClick(bot.Mouse.Button.LEFT, state);
+  assertEquals('rgba(255, 255, 0, 1)', getColor());
+
+  state.clientXY = {x: 50, y: 50};
+  doClick(bot.Mouse.Button.LEFT, state);
+  assertEquals('rgba(0, 0, 255, 1)', getColor());
+
+  function doClick(button, state) {
+    var res = webdriver.atoms.inject.action.mouseClick(button, state);
+    res = bot.json.parse(res);
+    bot.response.checkResponse(res);
+    return res['value'];
+  }
+
+  function getColor() {
+    var value = bot.dom.getEffectiveStyle(clickBox, 'backgroundColor');
+    return bot.color.standardizeColor('backgroundColor', value);
+  }
+}
+</script>