Bring webdriver up to date with SDK changes, and a bit of refactoring.

pkg/webdriver/lib/webdriver.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library webdriver;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:json' as json;
 import 'dart:uri';
@@ skipping 16 matching lines @@
  *
  * There are a number of commands that use ids to access page elements.
  * These ids are not the HTML ids; they are opaque ids internal to
  * WebDriver. To get the id for an element you would first need to do
  * a search, get the results, and extract the WebDriver id from the returned
  * [Map] using the 'ELEMENT' key. For example:
  *
  *     String id;
  *     WebDriverSession session;
  *     Future f = web_driver.newSession('chrome');
- *     f.chain((_session) {
+ *     f.then((_session) {
  *       session = _session;
  *       return session.setUrl('http://my.web.site.com');
- *    }).chain((_) {
+ *    }).then((_) {
  *      return session.findElement('id', 'username');
- *    }).chain((element) {
+ *    }).then((element) {
  *      id = element['ELEMENT'];
  *      return session.sendKeyStrokesToElement(id,
  *          [ 'j', 'o', 'e', ' ', 'u', 's', 'e', 'r' ]);
- *    }).chain((_) {
+ *    }).then((_) {
  *      return session.submit(id);
- *    }).chain((_) {
+ *    }).then((_) {
  *      return session.close();
  *    }).then((_) {
  *      session = null;
  *    });
  */
 
 void writeStringToFile(String fileName, String contents) {
   new File(fileName).writeAsStringSync(contents);
 }
 
@@ skipping 149 matching lines @@
     }
   }
 
   WebDriverBase([
       this._host = 'localhost',
       this._port = 4444,
       this._path = '/wd/hub']) {
     _url = 'http://$_host:$_port$_path';
   }
 
+  void _failRequest(Completer completer, error, StackTrace stackTrace) {
+    if (completer != null) {
+      completer.completeError(new WebDriverError(-1, error), stackTrace);
+    }
+  }
+
   /**
    * Execute a request to the WebDriver server. [http_method] should be
    * one of 'GET', 'POST', or 'DELETE'. [command] is the text to append
    * to the base URL path to get the full URL. [params] are the additional
    * parameters. If a [List] or [Map] they will be posted as JSON parameters.
    * If a number or string, "/params" is appended to the URL.
    */
   void _serverRequest(String http_method, String command, Completer completer,
-                      [List successCodes, Map params, Function customHandler]) {
+                      {List successCodes, params, Function customHandler}) {
     var status = 0;
     var results = null;
     var message = null;
     if (successCodes == null) {
       successCodes = [ 200, 204 ];
     }
     try {
-      if (params != null && params is List && http_method != 'POST') {
-        throw new Exception(
-          'The http method called for ${command} is ${http_method} but it has '
-          'to be POST if you want to pass the JSON params '
-          '${json.stringify(params)}');
-      }
-
       var path = command;
-      if (params != null && (params is num || params is String)) {
-        path = '$path/$params';
+      if (params != null) {
+        if (params is num || params is String) {
+          path = '$path/$params';
+          params = null;
+        } else if (http_method != 'POST') {
+          throw new Exception(
+            'The http method called for ${command} is ${http_method} but it '
+            'must be POST if you want to pass the JSON params '
+            '${json.stringify(params)}');
+        }
       }
 
       var client = new HttpClient();
-      var connection = client.open(http_method, _host, _port, path);
-
-      connection.onRequest = (r) {
-        r.headers.add(HttpHeaders.ACCEPT, "application/json");
-        r.headers.add(
+      client.open(http_method, _host, _port, path).then((req) {
+        req.followRedirects = false;
+        req.headers.add(HttpHeaders.ACCEPT, "application/json");
+        req.headers.add(
             HttpHeaders.CONTENT_TYPE, 'application/json;charset=UTF-8');
-        OutputStream s = r.outputStream;
-        if (params != null && params is Map) {
-          s.writeString(json.stringify(params));
+        if (params != null) {
+          var body = json.stringify(params);
+          req.write(body);
         }
-        s.close();
-      };
-      connection.onError = (e) {
-        if (completer != null) {
-          completer.completeError(new WebDriverError(-1, e));
+        req.close().then((rsp) {
+          List<int> body = new List<int>();
+          rsp.listen(body.addAll, onDone: () {
+            var value = null;
+            // For some reason we get a bunch of NULs on the end
+            // of the text and the json.parse blows up on these, so
+            // strip them with trim().
+            // These NULs can be seen in the TCP packet, so it is not
+            // an issue with character encoding; it seems to be a bug
+            // in WebDriver stack.
+            results = new String.fromCharCodes(body).trim();
+            if (!successCodes.contains(rsp.statusCode)) {
+              _failRequest(completer, 
+                  'Unexpected response ${rsp.statusCode}; $results', null);
+              completer = null;
+              return;
+            }
+            if (status == 0 && results.length > 0) {
+              // 4xx responses send plain text; others send JSON.
+              if (rsp.statusCode < 400) {
+                results = json.parse(results);
+                status = results['status'];
+              }
+              if (results is Map && (results as Map).containsKey('value')) {
+                value = results['value'];
+              }
+              if (value is Map && value.containsKey('message')) {
+                message = value['message'];
+              }
+            }
+            if (status == 0) {
+              if (customHandler != null) {
+                customHandler(rsp, value);
+              } else if (completer != null) {
+                completer.complete(value);
+              }
+            }
+          }, onError: (e) {
+            _failRequest(completer, e.error, e.stackTrace);
+            completer = null;
+          });
+        })
+        .catchError((e) {
+          _failRequest(completer, e.error, e.stackTrace);
           completer = null;
-        }
-      };
-      connection.followRedirects = false;
-      connection.onResponse = (r) {
-        StringInputStream s = new StringInputStream(r.inputStream);
-        StringBuffer sbuf = new StringBuffer();
-        s.onData = () {
-          var data = s.read();
-          if (data != null) {
-            sbuf.write(data);
-          }
-        };
-        s.onClosed = () {
-          var value = null;
-          results  = sbuf.toString().trim();
-          // For some reason we get a bunch of NULs on the end
-          // of the text and the json.parse blows up on these, so
-          // strip them.
-          // These NULs can be seen in the TCP packet, so it is not
-          // an issue with character encoding; it seems to be a bug
-          // in WebDriver stack.
-          for (var i = results.length; --i >= 0;) {
-            var code = results.codeUnitAt(i);
-            if (code != 0) {
-              results = results.substring(0, i + 1);
-              break;
-            }
-          }
-          if (successCodes.indexOf(r.statusCode) < 0) {
-            throw 'Unexpected response ${r.statusCode}';
-          }
-          if (status == 0 && results.length > 0) {
-            // 4xx responses send plain text; others send JSON.
-            if (r.statusCode < 400) {
-              results = json.parse(results);
-              status = results['status'];
-            }
-            if (results is Map && (results as Map).containsKey('value')) {
-              value = results['value'];
-            }
-            if (value is Map && value.containsKey('message')) {
-              message = value['message'];
-            }
-          }
-          if (status == 0) {
-            if (customHandler != null) {
-              customHandler(r, value);
-            } else if (completer != null) {
-              completer.complete(value);
-            }
-          }
-        };
-      };
+        });
+      })
+      .catchError((e) {
+        _failRequest(completer, e.error, e.stackTrace);
+        completer = null;
+      });
     } catch (e, s) {
-      completer.completeError(
-          new WebDriverError(-1, e), s);
+      _failRequest(completer, e, s);
       completer = null;
     }
   }
 
-  Future _simpleCommand(method, extraPath, [successCodes, params]) {
-    var completer = new Completer();
-    _serverRequest(method, '${_path}/$extraPath', completer,
-          successCodes, params: params);
+  Future _get(String extraPath,
+      [Completer completer, Function customHandler]) {
+    if (completer == null) completer = new Completer();
+    _serverRequest('GET', '${_path}/$extraPath', completer,
+        customHandler: customHandler);
     return completer.future;
   }
 
-  Future _get(extraPath, [successCodes]) =>
-      _simpleCommand('GET', extraPath, successCodes);
+  Future _post(String extraPath, [params]) {
+    var completer = new Completer();
+    _serverRequest('POST', '${_path}/$extraPath', completer,
+        params: params);
+    return completer.future;
+  }
 
-  Future _post(extraPath, [successCodes, params]) =>
-      _simpleCommand('POST', extraPath, successCodes, params);
-
-  Future _delete(extraPath, [successCodes]) =>
-      _simpleCommand('DELETE', extraPath, successCodes);
+  Future _delete(String extraPath) {
+    var completer = new Completer();
+    _serverRequest('DELETE', '${_path}/$extraPath', completer);
+    return completer.future;
+  }
 }
 
 class WebDriver extends WebDriverBase {
 
   WebDriver(host, port, path) : super(host, port, path);
 
   /**
    * Create a new session. The server will attempt to create a session that
    * most closely matches the desired and required capabilities. Required
    * capabilities have higher priority than desired capabilities and must be
@@ skipping 78 matching lines @@
    */
   Future<WebDriverSession> newSession([
       browser = 'chrome', Map additional_capabilities]) {
     var completer = new Completer();
     if (additional_capabilities == null) {
       additional_capabilities = {};
     }
 
     additional_capabilities['browserName'] = browser;
 
-    _serverRequest('POST', '${_path}/session', null, [ 302 ],
+    _serverRequest('POST', '${_path}/session', completer,
+        successCodes: [ 302 ],
         customHandler: (r, v) {
           var url = r.headers.value(HttpHeaders.LOCATION);
           var session = new WebDriverSession.fromUrl(url);
           completer.complete(session);
-        }, params: { 'desiredCapabilities': additional_capabilities });
+        },
+        params: { 'desiredCapabilities': additional_capabilities });
     return completer.future;
   }
 
   /** Get the set of currently active sessions. */
   Future<List<WebDriverSession>> getSessions() {
     var completer = new Completer();
-    _get('sessions', (result) {
+    return _get('sessions', completer, (r, v) {
       var _sessions = [];
-      for (var session in result) {
-        _sessions.add(new WebDriverSession.fromUrl(
-          '${this._path}/session/${session["id"]}'));
+      for (var session in v) {
+        var url = 'http://${this._host}:${this._port}${this._path}/'
+            'session/${session["id"]}';
+        _sessions.add(new WebDriverSession.fromUrl(url));
       }
       completer.complete(_sessions);
     });
-    return completer.future;
   }
 
   /** Query the server's current status. */
   Future<Map> getStatus() => _get('status');
 }
 
 class WebDriverWindow extends WebDriverBase {
   WebDriverWindow.fromUrl(url) : super.fromUrl(url);
 
   /** Get the window size. */
   Future<Map> getSize() => _get('size');
 
   /**
-   * Set the window size.
+   * Set the window size. Note that this is flaky and often
+   * has no effect.
    *
    * Potential Errors:
    *   NoSuchWindow - If the specified window cannot be found.
    */
   Future<String> setSize(int width, int height) =>
-      _post('size', params: { 'width': width, 'height': height });
+      _post('size', { 'width': width, 'height': height });
 
   /** Get the window position. */
   Future<Map> getPosition() => _get('position');
 
   /**
-   * Set the window position.
+   * Set the window position. Note that this is flaky and often
+   * has no effect.
    *
    * Potential Errors: NoSuchWindow.
    */
   Future setPosition(int x, int y) =>
-      _post('position', params: { 'x': x, 'y': y });
+      _post('position', { 'x': x, 'y': y });
 
   /** Maximize the specified window if not already maximized. */
   Future maximize() => _post('maximize');
 }
 
 class WebDriverSession extends WebDriverBase {
   WebDriverSession.fromUrl(url) : super.fromUrl(url);
 
   /** Close the session. */
   Future close() => _delete('');
 
   /** Get the session capabilities. See [newSession] for details. */
   Future<Map> getCapabilities() => _get('');
 
   /**
    * Configure the amount of time in milliseconds that a script can execute
    * for before it is aborted and a Timeout error is returned to the client.
    */
   Future setScriptTimeout(t) =>
-      _post('timeouts', params: { 'type': 'script', 'ms': t });
+      _post('timeouts', { 'type': 'script', 'ms': t });
 
   /*Future<String> setImplicitWaitTimeout(t) =>
       simplePost('timeouts', { 'type': 'implicit', 'ms': t });*/
 
   /**
    * Configure the amount of time in milliseconds that a page can load for
    * before it is aborted and a Timeout error is returned to the client.
    */
   Future setPageLoadTimeout(t) =>
-      _post('timeouts', params: { 'type': 'page load', 'ms': t });
+      _post('timeouts', { 'type': 'page load', 'ms': t });
 
   /**
    * Set the amount of time, in milliseconds, that asynchronous scripts
    * executed by /session/:sessionId/execute_async are permitted to run
    * before they are aborted and a Timeout error is returned to the client.
    */
   Future setAsyncScriptTimeout(t) =>
-      _post('timeouts/async_script', params: { 'ms': t });
+      _post('timeouts/async_script', { 'ms': t });
 
   /**
    * Set the amount of time the driver should wait when searching for elements.
    * When searching for a single element, the driver should poll the page until
    * an element is found or the timeout expires, whichever occurs first. When
    * searching for multiple elements, the driver should poll the page until at
    * least one element is found or the timeout expires, at which point it should
    * return an empty list.
    *
    * If this command is never sent, the driver should default to an implicit
    * wait of 0ms.
    */
   Future setImplicitWaitTimeout(t) =>
-      _post('timeouts/implicit_wait', params: { 'ms': t });
+      _post('timeouts/implicit_wait', { 'ms': t });
 
   /**
    * Retrieve the current window handle.
    *
    * Potential Errors: NoSuchWindow.
    */
   Future<String> getWindowHandle() => _get('window_handle');
 
   /**
    * Retrieve a [WebDriverWindow] for the specified window. We don't
@@ skipping 13 matching lines @@
    *
    * Potential Errors: NoSuchWindow.
    */
   Future<String> getUrl() => _get('url');
 
   /**
    * Navigate to a new URL.
    *
    * Potential Errors: NoSuchWindow.
    */
-  Future setUrl(String url) => _post('url', params: { 'url': url });
+  Future setUrl(String url) => _post('url', { 'url': url });
 
   /**
    * Navigate forwards in the browser history, if possible.
    *
    * Potential Errors: NoSuchWindow.
    */
   Future navigateForward() => _post('forward');
 
   /**
    * Navigate backwards in the browser history, if possible.
@@ skipping 21 matching lines @@
    * and the values may be accessed via the arguments object in the order
    * specified.
    *
    * Arguments may be any JSON-primitive, array, or JSON object. JSON objects
    * that define a WebElement reference will be converted to the corresponding
    * DOM element. Likewise, any WebElements in the script result will be
    * returned to the client as WebElement JSON objects.
    *
    * Potential Errors: NoSuchWindow, StaleElementReference, JavaScriptError.
    */
-  Future execute(String script, [List args]) =>
-      _post('execute', params: { 'script': script, 'args': args });
+  Future execute(String script, [List args]) {
+    if (args == null) args = [];
+    return _post('execute', { 'script': script, 'args': args });
+  }
 
   /**
    * Inject a snippet of JavaScript into the page for execution in the context
    * of the currently selected frame. The executed script is assumed to be
    * asynchronous and must signal that it is done by invoking the provided
    * callback, which is always provided as the final argument to the function.
    * The value to this callback will be returned to the client.
    *
    * Asynchronous script commands may not span page loads. If an unload event
    * is fired while waiting for a script result, an error should be returned
    * to the client.
    *
    * The script argument defines the script to execute in the form of a function
    * body. The function will be invoked with the provided args array and the
    * values may be accessed via the arguments object in the order specified.
    * The final argument will always be a callback function that must be invoked
    * to signal that the script has finished.
    *
    * Arguments may be any JSON-primitive, array, or JSON object. JSON objects
    * that define a WebElement reference will be converted to the corresponding
    * DOM element. Likewise, any WebElements in the script result will be
    * returned to the client as WebElement JSON objects.
    *
    * Potential Errors: NoSuchWindow, StaleElementReference, Timeout (controlled
    * by the [setAsyncScriptTimeout] command), JavaScriptError (if the script
    * callback is not invoked before the timout expires).
    */
-  Future executeAsync(String script, [List args]) =>
-      _post('execute_async', params: { 'script': script, 'args': args });
+  Future executeAsync(String script, [List args]) {
+    if (args == null) args = [];
+    return _post('execute_async', { 'script': script, 'args': args });
+  }
 
   /**
    * Take a screenshot of the current page (PNG).
    *
    * Potential Errors: NoSuchWindow.
    */
   Future<List<int>> getScreenshot([fname]) {
     var completer = new Completer();
-    var result = _serverRequest('GET', '$_path/screenshot', completer,
-        customHandler: (r, v) {
+    return _get('screenshot', completer, (r, v) {
       var image = Base64Decoder.decode(v);
       if (fname != null) {
         writeBytesToFile(fname, image);
       }
       completer.complete(image);
     });
-    return completer.future;
   }
 
   /**
    * List all available IME (Input Method Editor) engines on the machine.
    * To use an engine, it has to be present in this list.
    *
    * Potential Errors: ImeNotAvailableException.
    */
   Future<List<String>> getAvailableImeEngines() =>
       _get('ime/available_engines');
@@ skipping 25 matching lines @@
    * Make an engine that is available (appears on the list returned by
    * getAvailableEngines) active. After this call, the engine will be added
    * to the list of engines loaded in the IME daemon and the input sent using
    * sendKeys will be converted by the active engine. Note that this is a
    * platform-independent method of activating IME (the platform-specific way
    * being using keyboard shortcuts).
    *
    * Potential Errors: ImeActivationFailedException, ImeNotAvailableException.
    */
   Future activateIme(String engine) =>
-      _post('ime/activate', params: { 'engine': engine });
+      _post('ime/activate', { 'engine': engine });
 
   /**
    * Change focus to another frame on the page. If the frame id is null,
    * the server should switch to the page's default content.
    * [id] is the Identifier for the frame to change focus to, and can be
    * a string, number, null, or JSON Object.
    *
    * Potential Errors: NoSuchWindow, NoSuchFrame.
    */
-  Future setFrameFocus(id) => _post('frame', params: { 'id': id });
+  Future setFrameFocus(id) => _post('frame', { 'id': id });
 
   /**
    * Change focus to another window. The window to change focus to may be
    * specified by [name], which is its server assigned window handle, or
    * the value of its name attribute.
    *
    * Potential Errors: NoSuchWindow.
    */
-  Future setWindowFocus(name) =>
-      _post('window', params: { 'name': name });
+  Future setWindowFocus(name) => _post('window', { 'name': name });
 
   /**
    * Close the current window.
    *
    * Potential Errors: NoSuchWindow.
    */
   Future closeWindow() => _delete('window');
 
   /**
    * Retrieve all cookies visible to the current page.
@@ skipping 17 matching lines @@
    * Potential Errors: NoSuchWindow.
    */
   Future<List<Map>> getCookies() => _get('cookie');
 
   /**
    * Set a cookie. If the cookie path is not specified, it should be set
    * to "/". Likewise, if the domain is omitted, it should default to the
    * current page's domain. See [getCookies] for the structure of a cookie
    * Map.
    */
-  Future setCookie(Map cookie) =>
-      _post('cookie', params: { 'cookie': cookie });
+  Future setCookie(Map cookie) => _post('cookie', { 'cookie': cookie });
 
   /**
    * Delete all cookies visible to the current page.
    *
    * Potential Errors: InvalidCookieDomain (the cookie's domain is not
    * visible from the current page), NoSuchWindow, UnableToSetCookie (if
    * attempting to set a cookie on a page that does not support cookies,
    * e.g. pages with mime-type text/plain).
    */
   Future deleteCookies() => _delete('cookie');
@@ skipping 43 matching lines @@
    *   partially matches the search value.
    *
    * 'tag name' - Returns an element whose tag name matches the search value.
    *
    * 'xpath' - Returns an element matching an XPath expression.
    *
    * Potential Errors: NoSuchWindow, NoSuchElement, XPathLookupError (if
    * using XPath and the input expression is invalid).
    */
   Future<String> findElement(String strategy, String searchValue) =>
-      _post('element', params: { 'using': strategy, 'value' : searchValue });
+      _post('element', { 'using': strategy, 'value' : searchValue });
 
   /**
    * Search for multiple elements on the page, starting from the document root.
    * The located elements will be returned as WebElement JSON objects. See
    * [findElement] for the locator strategies that each server supports.
    * Elements are be returned in the order located in the DOM.
    *
    * Potential Errors: NoSuchWindow, XPathLookupError.
    */
   Future<List<String>> findElements(String strategy, String searchValue) =>
-      _post('elements', params: { 'using': strategy, 'value' : searchValue });
+      _post('elements', { 'using': strategy, 'value' : searchValue });
 
   /**
    * Get the element on the page that currently has focus. The element will
    * be returned as a WebElement JSON object.
    *
    * Potential Errors: NoSuchWindow.
    */
   Future<String> getElementWithFocus() => _post('element/active');
 
   /**
    * Search for an element on the page, starting from element with id [id].
    * The located element will be returned as WebElement JSON objects. See
    * [findElement] for the locator strategies that each server supports.
    *
    * Potential Errors: NoSuchWindow, XPathLookupError.
    */
   Future<String>
       findElementFromId(String id, String strategy, String searchValue) {
-    _post('element/$id/element',
-              params: { 'using': strategy, 'value' : searchValue });
+    _post('element/$id/element', { 'using': strategy, 'value' : searchValue });
   }
 
   /**
    * Search for multiple elements on the page, starting from the element with
    * id [id].The located elements will be returned as WebElement JSON objects.
    * See [findElement] for the locator strategies that each server supports.
    * Elements are be returned in the order located in the DOM.
    *
    * Potential Errors: NoSuchWindow, XPathLookupError.
    */
@@ skipping 123 matching lines @@
    *   either the modifier is encountered again in the sequence, or the NULL
    *   (U+E000) key is encountered.
    *
    * - Each key sequence is terminated with an implicit NULL key.
    *   Subsequently, all depressed modifier keys are released (with
    *   corresponding keyup events) at the end of the sequence.
    *
    * Potential Errors: NoSuchWindow, StaleElementReference, ElementNotVisible.
    */
   Future sendKeyStrokesToElement(String id, List<String> keys) =>
-      _post('element/$id/value', params: { 'value': keys });
+      _post('element/$id/value', { 'value': keys });
 
   /**
    * Send a sequence of key strokes to the active element. This command is
    * similar to [sendKeyStrokesToElement] command in every aspect except the
    * implicit termination: The modifiers are not released at the end of the
    * call. Rather, the state of the modifier keys is kept between calls,
    * so mouse interactions can be performed while modifier keys are depressed.
    *
    * Potential Errors: NoSuchWindow.
    */
-  Future sendKeyStrokes(List<String> keys) =>
-      _post('keys', params: { 'value': keys });
+  Future sendKeyStrokes(List<String> keys) => _post('keys', { 'value': keys });
 
   /**
    * Query for an element's tag name, as a lower-case string.
    *
    * Potential Errors: NoSuchWindow, StaleElementReference.
    */
   Future<String> getElementTagName(String id) => _get('element/$id/name');
 
   /**
    * Clear a TEXTAREA or text INPUT element's value.
@@ skipping 84 matching lines @@
    * Potential Errors: NoAlertPresent.
    */
   Future<String> getAlertText() => _get('alert_text');
 
   /**
    * Sends keystrokes to a JavaScript prompt() dialog.
    *
    * Potential Errors: NoAlertPresent.
    */
   Future sendKeyStrokesToPrompt(String text) =>
-      _post('alert_text', params: { 'text': text });
+      _post('alert_text', { 'text': text });
 
   /**
    * Accepts the currently displayed alert dialog. Usually, this is equivalent
    * to clicking on the 'OK' button in the dialog.
    *
    * Potential Errors: NoAlertPresent.
    */
   Future acceptAlert() => _post('accept_alert');
 
   /**
    * Dismisses the currently displayed alert dialog. For confirm() and prompt()
    * dialogs, this is equivalent to clicking the 'Cancel' button. For alert()
    * dialogs, this is equivalent to clicking the 'OK' button.
    *
    * Potential Errors: NoAlertPresent.
    */
   Future dismissAlert() => _post('dismiss_alert');
 
   /**
    * Move the mouse by an offset of the specificed element. If no element is
    * specified, the move is relative to the current mouse cursor. If an
    * element is provided but no offset, the mouse will be moved to the center
    * of the element. If the element is not visible, it will be scrolled
    * into view.
    */
   Future moveTo(String id, int x, int y) =>
-      _post('moveto', params: { 'element': id, 'xoffset': x, 'yoffset' : y});
+      _post('moveto', { 'element': id, 'xoffset': x, 'yoffset' : y});
 
   /**
    * Click a mouse button (at the coordinates set by the last [moveTo] command).
    * Note that calling this command after calling [buttonDown] and before
    * calling [buttonUp] (or any out-of-order interactions sequence) will yield
    * undefined behaviour).
    *
    * [button] should be 0 for left, 1 for middle, or 2 for right.
    */
-  Future clickMouse([button = 0]) =>
-      _post('click', params: { 'button' : button });
+  Future clickMouse([button = 0]) => _post('click', { 'button' : button });
 
   /**
    * Click and hold the left mouse button (at the coordinates set by the last
    * [moveTo] command). Note that the next mouse-related command that should
    * follow is [buttonDown]. Any other mouse command (such as [click] or
    * another call to [buttonDown]) will yield undefined behaviour.
    *
    * [button] should be 0 for left, 1 for middle, or 2 for right.
    */
-  Future buttonDown([button = 0]) =>
-      _post('click', params: { 'button' : button });
+  Future buttonDown([button = 0]) => _post('click', { 'button' : button });
 
   /**
    * Releases the mouse button previously held (where the mouse is currently
    * at). Must be called once for every [buttonDown] command issued. See the
    * note in [click] and [buttonDown] about implications of out-of-order
    * commands.
    *
    * [button] should be 0 for left, 1 for middle, or 2 for right.
    */
-  Future buttonUp([button = 0]) =>
-      _post('click', params: { 'button' : button });
+  Future buttonUp([button = 0]) => _post('click', { 'button' : button });
 
   /** Double-clicks at the current mouse coordinates (set by [moveTo]). */
   Future doubleClick() => _post('doubleclick');
 
   /** Single tap on the touch enabled device on the element with id [id]. */
-  Future touchClick(String id) =>
-      _post('touch/click', params: { 'element': id });
+  Future touchClick(String id) => _post('touch/click', { 'element': id });
 
   /** Finger down on the screen. */
-  Future touchDown(int x, int y) =>
-      _post('touch/down', params: { 'x': x, 'y': y });
+  Future touchDown(int x, int y) => _post('touch/down', { 'x': x, 'y': y });
 
   /** Finger up on the screen. */
-  Future touchUp(int x, int y) =>
-      _post('touch/up', params: { 'x': x, 'y': y });
+  Future touchUp(int x, int y) => _post('touch/up', { 'x': x, 'y': y }); 
 
   /** Finger move on the screen. */
-  Future touchMove(int x, int y) =>
-      _post('touch/move', params: { 'x': x, 'y': y });
+  Future touchMove(int x, int y) => _post('touch/move', { 'x': x, 'y': y });
 
   /**
    * Scroll on the touch screen using finger based motion events. If [id] is
    * specified, scrolling will start at a particular screen location.
    */
   Future touchScroll(int xOffset, int yOffset, [String id = null]) {
     if (id == null) {
-      return _post('touch/scroll',
-          params: { 'xoffset': xOffset, 'yoffset': yOffset });
+      return _post('touch/scroll', { 'xoffset': xOffset, 'yoffset': yOffset });
     } else {
       return _post('touch/scroll',
-          params: { 'element': id, 'xoffset': xOffset, 'yoffset': yOffset });
+          { 'element': id, 'xoffset': xOffset, 'yoffset': yOffset });
     }
   }
 
   /** Double tap on the touch screen using finger motion events. */
   Future touchDoubleClick(String id) =>
-      _post('touch/doubleclick', params: { 'element': id });
+      _post('touch/doubleclick', { 'element': id });
 
   /** Long press on the touch screen using finger motion events. */
   Future touchLongClick(String id) =>
-      _post('touch/longclick', params: { 'element': id });
+      _post('touch/longclick', { 'element': id });
 
   /**
    * Flick on the touch screen using finger based motion events, starting
    * at a particular screen location. [speed] is in pixels-per-second.
    */
   Future touchFlickFrom(String id, int xOffset, int yOffset, int speed) =>
           _post('touch/flick',
-              params: { 'element': id, 'xoffset': xOffset, 'yoffset': yOffset,
+              { 'element': id, 'xoffset': xOffset, 'yoffset': yOffset,
                         'speed': speed });
 
   /**
    * Flick on the touch screen using finger based motion events. Use this
    * instead of [touchFlickFrom] if you don'tr care where the flick starts.
    */
   Future touchFlick(int xSpeed, int ySpeed) =>
-      _post('touch/flick', params: { 'xSpeed': xSpeed, 'ySpeed': ySpeed });
+      _post('touch/flick', { 'xSpeed': xSpeed, 'ySpeed': ySpeed });
 
   /**
    * Get the current geo location. Returns a [Map] with latitude,
    * longitude and altitude properties.
    */
   Future<Map> getGeolocation() => _get('location');
 
   /** Set the current geo location. */
   Future setLocation(double latitude, double longitude, double altitude) =>
-          _post('location', params:
+          _post('location',
               { 'latitude': latitude,
                 'longitude': longitude,
                 'altitude': altitude });
 
   /**
+   * Only a few drivers actually support the JSON storage commands.
+   * Currently it looks like this is the Android and iPhone drivers only.
+   * For the rest, we can achieve a similar effect with Javascript
+   * execution. The flag below is used to control whether to do this.
+   */
+  bool useJavascriptForStorageAPIs = true;
+
+  /**
    * Get all keys of the local storage. Completes with [null] if there
    * are no keys or the keys could not be retrieved.
    *
    * Potential Errors: NoSuchWindow.
    */
-  Future<List<String>> getLocalStorageKeys() => _get('local_storage');
+  Future<List<String>> getLocalStorageKeys() {
+    if (useJavascriptForStorageAPIs) {
+      return execute(
+          'var rtn = [];'
+          'for (var i = 0; i < window.localStorage.length; i++)'
+          '  rtn.push(window.localStorage.key(i));'
+          'return rtn;'); 
+    } else {
+      return _get('local_storage');
+    }
+  }
 
   /**
    * Set the local storage item for the given key.
    *
    * Potential Errors: NoSuchWindow.
    */
-  Future setLocalStorageItem(String key, String value) =>
-      _post('local_storage', params: { 'key': key, 'value': value });
+  Future setLocalStorageItem(String key, String value) {
+    if (useJavascriptForStorageAPIs) {
+      return execute('window.localStorage.setItem(arguments[0], arguments[1]);',
+          [key, value]); 
+    } else {
+      return _post('local_storage', { 'key': key, 'value': value });
+    }
+  }
 
   /**
    * Clear the local storage.
    *
    * Potential Errors: NoSuchWindow.
    */
-  Future clearLocalStorage() => _delete('local_storage');
+  Future clearLocalStorage() {
+    if (useJavascriptForStorageAPIs) {
+      return execute('return window.localStorage.clear();');
+    } else {
+      return _delete('local_storage');
+    }
+  }
 
   /**
    * Get the local storage item for the given key.
    *
    * Potential Errors: NoSuchWindow.
    */
-  Future<String> getLocalStorageValue(String key) =>
-      _get('local_storage/key/$key');
+  Future<String> getLocalStorageValue(String key) {
+    if (useJavascriptForStorageAPIs) {
+      return execute('return window.localStorage.getItem(arguments[0]);',
+          [key]); 
+    } else {
+      return _get('local_storage/key/$key');
+    }
+  }
 
   /**
    * Delete the local storage item for the given key.
    *
    * Potential Errors: NoSuchWindow.
    */
-  Future deleteLocalStorageValue(String key) =>
-      _delete('local_storage/key/$key');
+  Future deleteLocalStorageValue(String key) {
+    if (useJavascriptForStorageAPIs) {
+      return execute('return window.localStorage.removeItem(arguments[0]);',
+          [key]); 
+    } else {
+      return _delete('local_storage/key/$key');
+    }
+  }
 
   /**
    * Get the number of items in the local storage.
    *
    * Potential Errors: NoSuchWindow.
    */
-  Future<int> getLocalStorageCount() => _get('local_storage/size');
+  Future<int> getLocalStorageCount() {
+    if (useJavascriptForStorageAPIs) {
+      return execute('return window.localStorage.length;'); 
+    } else {
+      return _get('local_storage/size');
+    }
+  }
 
   /**
    * Get all keys of the session storage.
    *
    * Potential Errors: NoSuchWindow.
    */
-  Future<List<String>> getSessionStorageKeys() => _get('session_storage');
+  Future<List<String>> getSessionStorageKeys() {
+    if (useJavascriptForStorageAPIs) {
+      return execute(
+          'var rtn = [];'
+          'for (var i = 0; i < window.sessionStorage.length; i++)'
+          '  rtn.push(window.sessionStorage.key(i));'
+          'return rtn;'); 
+    } else {
+      return _get('session_storage');
+    }
+  }
 
   /**
    * Set the sessionstorage item for the given key.
    *
    * Potential Errors: NoSuchWindow.
    */
-  Future setSessionStorageItem(String key, String value) =>
-      _post('session_storage', params: { 'key': key, 'value': value });
+  Future setSessionStorageItem(String key, String value) {
+    if (useJavascriptForStorageAPIs) {
+      return execute(
+          'window.sessionStorage.setItem(arguments[0], arguments[1]);',
+              [key, value]); 
+    } else {
+      return _post('session_storage', { 'key': key, 'value': value });
+    }
+  }
 
   /**
    * Clear the session storage.
    *
    * Potential Errors: NoSuchWindow.
    */
-  Future clearSessionStorage() => _delete('session_storage');
+  Future clearSessionStorage() {
+    if (useJavascriptForStorageAPIs) {
+      return execute('window.sessionStorage.clear();');
+    } else {
+      return _delete('session_storage');
+    }
+  }
 
   /**
    * Get the session storage item for the given key.
    *
    * Potential Errors: NoSuchWindow.
    */
-  Future<String> getSessionStorageValue(String key) =>
-      _get('session_storage/key/$key');
+  Future<String> getSessionStorageValue(String key) {
+    if (useJavascriptForStorageAPIs) {
+      return execute('return window.sessionStorage.getItem(arguments[0]);',
+          [key]); 
+    } else {
+      return _get('session_storage/key/$key');
+    }
+  }
 
   /**
    * Delete the session storage item for the given key.
    *
    * Potential Errors: NoSuchWindow.
    */
-  Future deleteSessionStorageValue(String key) =>
-      _delete('session_storage/key/$key');
+  Future deleteSessionStorageValue(String key) {
+    if (useJavascriptForStorageAPIs) {
+      return execute('return window.sessionStorage.removeItem(arguments[0]);',
+          [key]); 
+    } else {
+      return _delete('session_storage/key/$key');
+    }
+  }
 
   /**
    * Get the number of items in the session storage.
    *
    * Potential Errors: NoSuchWindow.
    */
-  Future<String> getSessionStorageCount() => _get('session_storage/size');
+  Future<String> getSessionStorageCount() {
+    if (useJavascriptForStorageAPIs) {
+      return execute('return window.sessionStorage.length;');
+    } else {
+      return _get('session_storage/size');
+    }
+  }
 
-  /** Get available log types ('client', 'driver', 'browser', 'server'). */
+  /**
+   * Get available log types ('client', 'driver', 'browser', 'server').
+   * This works with Firefox but Chrome returns a 500 response due to a 
+   * bad cast.
+   */
   Future<List<String>> getLogTypes() => _get('log/types');
 
   /**
    * Get the log for a given log type. Log buffer is reset after each request.
    * Each log entry is a [Map] with these fields:
    *
    * 'timestamp' (int) - The timestamp of the entry.
    * 'level' (String) - The log level of the entry, for example, "INFO".
    * 'message' (String) - The log message.
+   *
+   * This works with Firefox but Chrome returns a 500 response due to a 
+   * bad cast.
    */
-  Future<List<Map>> getLogs(String type) =>
-      _post('log', params: { 'type': type });
+  Future<List<Map>> getLogs(String type) => _post('log', { 'type': type });
 }