rainux-selenium-webdriver 0.0.17

data/chrome/src/extension/content_script.js

@@ -0,0 +1,1321 @@
+/**
+ * All functions which take elements assume that they are not null,
+ * and are present as passed on the DOM.
+ */
+
+ChromeDriverContentScript = {};
+
+ChromeDriverContentScript.internalElementArray = [];
+ChromeDriverContentScript.port = null;
+ChromeDriverContentScript.currentDocument = window.document;
+ChromeDriverContentScript.injectedEmbedElement = null;
+//Record this for async calls (execute), so returner knows what to return
+//(Also so that we can not re-start commands we have already started executing)
+ChromeDriverContentScript.currentSequenceNumber = -1;
+
+if (ChromeDriverContentScript.currentDocument.location != "about:blank") {
+  //If loading windows using window.open, the port is opened
+  //while we are on about:blank (which always reports window.name as ''),
+  //and we use port-per-tab semantics, so don't open the port if
+  //we're on about:blank
+  ChromeDriverContentScript.port = chrome.extension.connect({name: window.name});
+  ChromeDriverContentScript.port.onMessage.addListener(parsePortMessage);
+  var isFrameset = (ChromeDriverContentScript.currentDocument.getElementsByTagName("frameset").length > 0);
+  ChromeDriverContentScript.port.postMessage({response: {response: "newTabInformation",
+      value: {statusCode: "no-op", isFrameset: isFrameset, frameCount: window.frames.length,
+      portName: ChromeDriverContentScript.port.name}}, sequenceNumber: -1});
+}
+
+/**
+ * Parse messages coming in on the port.
+ * Sends relevant response back down the port
+ * @param message JSON message of format:
+ *                {request: {request: "some command"
+ *                           [, optional params]},
+ *                 sequenceNumber: some sequence number
+ *                 [, followup: message']}
+ *                 where message' is a message to parse after this one
+ */
+function parsePortMessage(message) {
+  if (message == null || message.request == null) {
+    console.log("Received bad request: " + JSON.stringify(message));
+    return;
+  }
+  if (message.sequenceNumber <= ChromeDriverContentScript.currentSequenceNumber) {
+    console.log("Already process{ed,ing} request with sequence number: " + message.sequenceNumber + ", ignoring request: " + message);
+    return;
+  }
+  
+  ChromeDriverContentScript.currentSequenceNumber = message.sequenceNumber;
+  
+  console.log("Received request: " + JSON.stringify(message) + " (" + window.name + ")");
+  //wait indicates whether this is a potentially page-changing change (see background.js's sendResponseByXHR)
+  var response = {response: message.request.request, value: null, wait: true};
+  if (message.request.elementId !== undefined && message.request.elementId != null) {
+    //If it seems an elementId has been passed, try to resolve that to an element
+    try {
+      var element = internalGetElement(message.request.elementId);
+    } catch(e) {
+      response.value = e;
+      ChromeDriverContentScript.port.postMessage({response: response, sequenceNumber: message.sequenceNumber});
+      return;
+    }
+  }
+  try {
+    switch (message.request.request) {
+    case "addCookie":
+      response.value = setCookie(message.request.cookie);
+      response.wait = false;
+      break;
+    case "clearElement":
+      response.value = clearElement(element);
+      break;
+    case "clickElement":
+      response.value = clickElement(element, message.request.elementId);
+      break;
+    case "nonNativeClickElement":
+      //TODO(danielwh): Focus/blur events for non-native clicking
+      element.scrollIntoView(true);
+      //TODO: Work out a way of firing events,
+      //now that synthesising them gives appendMessage errors
+      console.log("mouse downing");
+      Utils.fireMouseEventOn(element, "mousedown");
+        console.log("mouse up");
+      Utils.fireMouseEventOn(element, "mouseup");
+        console.log("mouse click");
+      Utils.fireMouseEventOn(element, "click");
+
+      if (element.click) {
+        console.log("click");
+        execute("try { arguments[0].click(); } catch(e){}", {type: "ELEMENT", value: addElementToInternalArray(element)});
+      }
+      response.value = {statusCode: 0};
+      break;
+    case "deleteAllCookies":
+      response.value = deleteAllCookies();
+      response.wait = false;
+      break;
+    case "deleteCookie":
+      response.value = deleteCookie(message.request.name);
+      response.wait = false;
+      break;
+    case "executeScript":
+      execute(message.request.script, message.request.args);
+      //Sends port message back to background page from its own callback
+      break;
+    case "getCookies":
+      response.value = getCookies();
+      response.wait = false;
+      break;
+    case "getCookie":
+      response.value = getCookieNamed(message.request.name);
+      response.wait = false;
+      break;
+    case "findChildElement":
+      response.value = getElement(false, message.request.using, message.request.value, message.request.id);
+      response.wait = false;
+      break;
+    case "findChildElements":
+      response.value = getElement(true, message.request.using, message.request.value, message.request.id);
+      response.wait = false;
+      break;
+    case "findElement":
+      response.value = getElement(false, message.request.using, message.request.value);
+      response.wait = false;
+      break;
+    case "findElements":
+      response.value = getElement(true, message.request.using, message.request.value);
+      response.wait = false;
+      break;
+    case "getElementAttribute":
+      response.value = getElementAttribute(element, message.request.attribute);
+      response.wait = false;
+      break;
+    case "getElementValueOfCssProperty":
+      response.value = {statusCode: 0, value: getStyle(element, message.request.css)};
+      response.wait = false;
+      break;
+    case "getElementLocation":
+      var coords = getElementCoords(element);
+      response.value = {statusCode: 0, value: {type: "POINT", x: coords[0], y: coords[1]}};
+      response.wait = false;
+      break;
+    case "getElementLocationOnceScrolledIntoView":
+      element.scrollIntoView(true);
+      var coords = getElementCoords(element);
+      response.value = {statusCode: 0, value: {type: "POINT", x: coords[0], y: coords[1]}};
+      break;
+    case "getElementSize":
+      response.value = {statusCode: 0, value: getOffsetSizeFromSubElements(element)};
+      response.wait = false;
+      break;
+    case "getElementTagName":
+      response.value = {statusCode: 0, value: element.tagName.toLowerCase()};
+      response.wait = false;
+      break;
+    case "getElementText":
+      response.value = {statusCode: 0, value: Utils.getText(element)};
+      response.wait = false;
+      break;
+    case "getElementValue":
+      response.value = {statusCode: 0, value: element.value};
+      response.wait = false;
+      break;
+    case "getFrameNameFromIndex":
+      //TODO(danielwh): Do this by simply looking it up in window.frames when Chrome is fixed.  Track: crbug.com 20773
+      getFrameNameFromIndex(message.request.index);
+      break;
+    case "getPageSource":
+      response.value = getSource();
+      response.wait = false;
+      break;
+    case "getTitle":
+      response.value = {statusCode: 0, value: Utils.trim(ChromeDriverContentScript.currentDocument.title)};
+      response.wait = false;
+      break;
+    case "getCurrentUrl":
+      response.value = {statusCode: 0, value: ChromeDriverContentScript.currentDocument.location.href};
+      response.wait = false;
+      break;
+    case "goBack":
+      history.back();
+      response.value = {statusCode: 0};
+      break;
+    case "goForward":
+      history.forward();
+      response.value = {statusCode: 0};
+      break;
+    case "hoverOverElement":
+      response.value = hoverElement(element, message.request.elementId);
+      break;
+    case "injectEmbed":
+      injectEmbed();
+      break;
+    case "isElementDisplayed":
+      response.value = {statusCode: 0, value: isElementDisplayed(element)};
+      response.wait = false;
+      break;
+    case "isElementEnabled":
+      response.value = {statusCode: 0, value: !element.disabled};
+      response.wait = false;
+      break;
+    case "isElementSelected":
+      response.value = {statusCode: 0, value: findWhetherElementIsSelected(element)};
+      response.wait = false;
+      break;
+    case "refresh":
+      ChromeDriverContentScript.currentDocument.location.reload(true);
+      response.value = {statusCode: 0};
+      break;
+    case "sendKeysToElement":
+      response.value = sendElementKeys(element, message.request.keys, message.request.elementId);
+      response.wait = false;
+      break;
+    case "sendElementNonNativeKeys":
+      response.value = sendElementNonNativeKeys(element, message.request.keys);
+      response.wait = false;
+      break;
+    case "setElementSelected":
+      response.value = selectElement(element);
+      break;
+    case "getActiveElement":
+      response.value = {statusCode: 0, value: [addElementToInternalArray(ChromeDriverContentScript.currentDocument.activeElement).toString()]};
+      response.wait = false;
+      break;
+    case "switchToNamedIFrameIfOneExists":
+      response.value = switchToNamedIFrameIfOneExists(message.request.name);
+      response.wait = false;
+      break;
+    case "submitElement":
+      response.value = submitElement(element);
+      break;
+    case "toggleElement":
+      response.value = toggleElement(element);
+      break;
+    case "sniffForMetaRedirects":
+      response.value = sniffForMetaRedirects();
+      break;
+    default:
+      response.value = {statusCode: 9, value: {message: message.request.request + " is unsupported"}};
+      break;
+    }
+  } catch (e) {
+    console.log("Caught exception " + e + ", sending error response");
+    ChromeDriverContentScript.port.postMessage({response: {statusCode: 13, value: {message: "An unexpected error occured while executing " + message.request.request + ", exception dump: " + e}}, sequenceNumber: message.sequenceNumber});
+  }
+  if (response.value != null) {
+    ChromeDriverContentScript.port.postMessage({response: response, sequenceNumber: message.sequenceNumber});
+    console.log("Sent response: " + JSON.stringify(response) + " (seq:" + message.sequenceNumber + ")");
+  }
+  if (message.request.followup) {
+    setTimeout(parsePortMessage(message.request.followup), 100);
+  }
+}
+
+/**
+ * Deletes all cookies accessible from the current page.
+ */
+function deleteAllCookies() {
+  var cookies = getAllCookiesAsStrings();
+  for (var i = 0; i < cookies.length; ++i) {
+    var cookie = cookies[i].split("=");
+    deleteCookie(cookie[0]);
+  }
+  return {statusCode: 0};
+}
+
+/**
+ * Deletes the cookie with the passed name, accessible from the current page (i.e. with path of the current directory or above)
+ * @param cookieName name of the cookie to delete
+ */
+function deleteCookie(cookieName) {
+  //It's possible we're trying to delete cookies within iframes.
+  //iframe stuff is unsupported in Chrome at the moment (track crbug.com/20773)
+  //But for the iframe to be loaded and have cookies, it must be of same origin,
+  //so we'll try deleting the cookie as if it was on this page anyway...
+  //(Yes, this is a hack)
+  //TODO(danielwh): Remove the cookieDocument stuff when Chrome fix frame support
+  try {
+    var fullpath = ChromeDriverContentScript.currentDocument.location.pathname;
+    var cookieDocument = ChromeDriverContentScript.currentDocument;
+  } catch (e) {
+    console.log("Falling back on non-iframe document to delete cookies");
+    var cookieDocument = document;
+    var fullpath = cookieDocument.location.pathname;
+  }
+  var hostParts = cookieDocument.location.hostname.split(".");
+  
+  fullpath = fullpath.split('/');
+  fullpath.pop(); //Get rid of the file
+  //TODO(danielwh): Tidy up these loops and this repeated code
+  for (var segment in fullpath) {
+    var path = '';
+    for (var i = 0; i < segment; ++i) {
+      path += fullpath[i + 1] + '/';
+    }
+    //Delete cookie with trailing /
+    cookieDocument.cookie = cookieName + '=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/' + path;
+    //Delete cookie without trailing /
+    cookieDocument.cookie = cookieName + '=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/' + path.substring(0, path.length - 1);
+    
+    var domain = "";
+    for (var i = hostParts.length - 1; i >= 0; --i) {
+      domain = "." + hostParts[i] + domain;
+      //Delete cookie with trailing /
+      cookieDocument.cookie = cookieName + '=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/' + path + ";domain=" + domain;
+      
+      cookieDocument.cookie = cookieName + '=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/' + path + ";domain=" + domain;
+      //Delete cookie without trailing /
+      cookieDocument.cookie = cookieName + '=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/' + path.substring(0, path.length - 1) + ";domain=" + domain;
+      
+      cookieDocument.cookie = cookieName + '=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/' + path.substring(0, path.length - 1) + ";domain=" + domain.substring(1);
+    }
+  }
+  return {statusCode: 0};
+}
+
+/**
+ * Get all cookies accessible from the current page as an array of
+ * {name: some name, value: some value, secure: false} values
+ */
+function getCookies() {
+  var cookies = [];
+  var cookieStrings = getAllCookiesAsStrings();
+  for (var i = 0; i < cookieStrings.length; ++i) {
+    var cookie = cookieStrings[i].split("=");
+    cookies.push({type: "COOKIE", name: cookie[0], value: cookie[1], secure: false});
+  }
+  return {statusCode: 0, value: cookies};
+}
+
+/**
+ * Get the cookie accessible from the current page with the passed name
+ * @param name name of the cookie
+ */
+function getCookieNamed(name) {
+  var cookies = [];
+  var cookieStrings = getAllCookiesAsStrings();
+  for (var i = 0; i < cookieStrings.length; ++i) {
+    var cookie = cookieStrings[i].split("=");
+    if (cookie[0] == name) {
+      return {statusCode: 0, value: {type: "COOKIE", name: cookie[0], value: cookie[1], secure: false}};
+    }
+  }
+  return {statusCode: 0, value: null};
+}
+
+/**
+ * Gets all cookies accessible from the current page as an array of
+ * key=value strings
+ */
+function getAllCookiesAsStrings() {
+  //It's possible we're trying to delete cookies within iframes.
+  //iframe stuff is unsupported in Chrome at the moment (track crbug.com/20773)
+  //But for the iframe to be loaded and have cookies, it must be of same origin,
+  //so we'll try deleting the cookie as if it was on this page anyway...
+  //(Yes, this is a hack)
+  //TODO(danielwh): Remove the cookieDocument stuff when Chrome fix frame support
+  var cookieDocument = ChromeDriverContentScript.currentDocument;
+  try {
+    var tempFullpath = ChromeDriverContentScript.currentDocument.location.pathname;
+  } catch (e) {
+    cookieDocument = document;
+  }
+  var cookieStrings = cookieDocument.cookie.split('; ');
+  var cookies = [];
+  for (var i = 0; i < cookieStrings.length; ++i) {
+    if (cookieStrings[i] == '') {
+      break;
+    }
+     cookies.push(cookieStrings[i]);
+  }
+   return cookies;
+}
+
+/**
+ * Add the passed cookie to the page's cookies
+ * @param cookie org.openqa.selenium.Cookie to add
+ */
+function setCookie(cookie) {
+  //It's possible we're trying to delete cookies within iframes.
+  //iframe stuff is unsupported in Chrome at the moment (track crbug.com/20773)
+  //But for the iframe to be loaded and have cookies, it must be of same origin,
+  //so we'll try deleting the cookie as if it was on this page anyway...
+  //(Yes, this is a hack)
+  //TODO(danielwh): Remove the cookieDocument stuff when Chrome fix frame support
+  try {
+    var currLocation = ChromeDriverContentScript.currentDocument.location;
+    var currDomain = currLocation.host;
+    var cookieDocument = ChromeDriverContentScript.currentDocument;
+  } catch (e) {
+    cookieDocument = document;
+    var currLocation = ChromeDriverContentScript.currentDocument.location;
+    var currDomain = currLocation.host;
+  }
+  
+  if (currLocation.port != 80) { currDomain += ":" + currLocation.port; }
+  if (cookie.domain != null && cookie.domain !== undefined &&
+      currDomain.indexOf(cookie.domain) == -1) {
+      // Not quite right, but close enough. (See r783)
+    return {statusCode: 2, value: {
+            message: "You may only set cookies for the current domain"}};
+  } else if (guessPageType() != "html") {
+    return {statusCode: 2, value: {
+            message: "You may only set cookies on html documents"}};
+  } else {
+    cookieDocument.cookie = cookie.name + '=' + escape(cookie.value) +
+        ((cookie.expiry == null || cookie.expiry === undefined) ?
+            '' : ';expires=' + (new Date(cookie.expiry.time)).toGMTString()) +
+        ((cookie.path == null || cookie.path === undefined) ?
+            '' : ';path=' + cookie.path);
+    return {statusCode: 0};
+  }
+}
+
+/**
+ * Get an element, or a set of elements, by some lookup
+ * Called by both findElement and findElements
+ * @param plural true if want array of all elements, false if singular element
+ * @param parsed array showing how to look up, e.g. ["id", "cheese"] or
+ *               [{"id": 0, using: "id", value: "cheese"}]
+ */
+function getElement(plural, lookupBy, lookupValue, id) {
+  var root = "";
+  var parent = null;
+  if (id !== undefined && id != null) {
+    try {
+      parent = internalGetElement(id);
+    } catch (e) {
+      return e;
+    }
+    //Looking for children
+    root = getXPathOfElement(parent);
+  } else {
+    parent = ChromeDriverContentScript.currentDocument;
+  }
+
+  var elements = [];
+  var attribute = '';
+  switch (lookupBy) {
+  case "class name":
+    elements = getElementsByXPath(root +
+        "//*[contains(concat(' ',normalize-space(@class),' '),' " +
+        lookupValue + " ')]");
+    break;
+  case "name":
+    attribute = 'name';
+    break;
+  case "id":
+    attribute = 'id';
+    break;
+  case "link text":
+    elements = getElementsByLinkText(parent, lookupValue);
+    break;
+  case "partial link text":
+    elements = getElementsByPartialLinkText(parent, lookupValue);
+    break;
+  case "tag name":
+    elements = getElementsByXPath(root + "//" + lookupValue);
+    break;
+  case "css":
+    elements = parent.querySelectorAll(lookupValue);
+    break;
+  case "xpath":
+    if (root != "" && lookupValue[0] != "/") {
+      //Because xpath is relative to the parent, if there is a parent, and the lookup seems to be implied sub-lookup, we add a /
+      root = root + "/";
+    }
+    var xpath = root + lookupValue;
+    try {
+      elements = getElementsByXPath(xpath);
+    } catch (e) {
+      return {statusCode: 19, value: {message: "Could not look up element by xpath " + xpath}};
+    }
+    break;
+  }
+  if (attribute != '') {
+    elements = getElementsByXPath(root + "//*[@" + attribute + "='" + lookupValue + "']");
+  }
+  if (elements == null || elements.length == 0) {
+    if (plural) {
+      //Fine, no elements matched
+      return {statusCode: 0, value: []};
+    } else {
+      //Problem - we were expecting an element
+      return {statusCode: 7, value: {
+          message: "Unable to find element with " + lookupBy + " " + lookupValue}};
+    }
+  } else {
+    var elementsToReturnArray = [];
+    if (plural) {
+      //Add all found elements to the page's elements, and push each to the array to return
+      var addedElements = addElementsToInternalArray(elements);
+      for (var addedElement in addedElements) {
+        elementsToReturnArray.push(addedElements[addedElement].toString());
+      }
+    } else {
+      if (!elements[0]) {
+        return {statusCode: 7, value: {
+          message: "Unable to find element with " + lookupBy + " " + lookupValue}};
+      }
+      //Add the first found elements to the page's elements, and push it to the array to return
+      elementsToReturnArray.push(addElementToInternalArray(elements[0]).toString());
+    }
+    return {statusCode: 0, value: elementsToReturnArray};
+  }
+}
+
+/**
+ * Adds the element to the internal element store, if it isn't already there.
+ * @return index of element in the array
+ */
+function addElementToInternalArray(element) {
+  for (var existingElement in ChromeDriverContentScript.internalElementArray) {
+    if (element == ChromeDriverContentScript.internalElementArray[existingElement]) {
+      return existingElement;
+    }
+  }
+  ChromeDriverContentScript.internalElementArray.push(element);
+  return (ChromeDriverContentScript.internalElementArray.length - 1);
+}
+
+function addElementsToInternalArray(elements) {
+  var toReturn = [];
+  for (var element in elements) {
+    toReturn.push(addElementToInternalArray(elements[element]));
+  }
+  return toReturn;
+}
+
+/**
+ * Gets an element which we have previously looked up by its internal ID
+ * @param elementIdAsString the element's internal ID
+ * @return element with the passed internal ID
+ * @throws if element ID was stale: wrapped up
+ *         org.openqa.selenium.StaleElementReferenceException ready to send
+ */
+function internalGetElement(elementIdAsString) {
+  var elementId = parseInt(elementIdAsString);
+  if (elementId != null && elementId >= 0 &&
+      ChromeDriverContentScript.internalElementArray.length >= elementId + 1) {
+    var element = ChromeDriverContentScript.internalElementArray[elementId];
+    var parent = element;
+    while (parent && parent != element.ownerDocument.documentElement) {
+      parent = parent.parentNode;
+    }
+    if (parent !== element.ownerDocument.documentElement) {
+      throw {statusCode: 10, value: {message: "Element is obsolete"}};
+    }
+    return element;
+  } else {
+    throw {statusCode: 10, value: {message: "Element is obsolete"}};
+  }
+}
+
+/**
+ * Ensures the passed element is in view, so that the native click event can be sent
+ * @return object to send back to background page to trigger a native click
+ */
+function clickElement(element, elementId) {
+  try {
+    checkElementIsDisplayed(element)
+  } catch (e) {
+    return e;
+  }
+  element.scrollIntoView(true);
+  var size = getOffsetSizeFromSubElements(element);
+  var coords = getElementCoords(element);
+  return {statusCode: "no-op", elementId: elementId,
+          x: parseInt(coords[0] - ChromeDriverContentScript.currentDocument.body.scrollLeft + (size.width ? size.width / 2 : 0)),
+          y: parseInt(coords[1] - ChromeDriverContentScript.currentDocument.body.scrollTop + (size.height ? size.height / 2 : 0))};
+}
+
+/**
+ * Ensures the passed element is in view, so that the native click event can be sent
+ * @return object to send back to background page to trigger a native click
+ */
+function hoverElement(element, elementId) {
+  try {
+    checkElementIsDisplayed(element)
+  } catch (e) {
+    return e;
+  }
+  element.scrollIntoView(true);
+  var size = getOffsetSizeFromSubElements(element)
+  var coords = getElementCoords(element);
+  console.log("element.clientX: " + element.clientX);
+  return {statusCode: "no-op", elementId: elementId,
+      oldX: 0,
+      oldY: 0,
+      newX: coords[0] - ChromeDriverContentScript.currentDocument.body.scrollLeft + (size.width ? size.width / 2 : 0),
+      newY: coords[1] - ChromeDriverContentScript.currentDocument.body.scrollTop + (size.height ? size.height / 2 : 0)};
+}
+
+/**
+ * Clears the passed element
+ */
+function clearElement(element) {
+  var oldValue = element.value;
+  element.value = '';
+  if (oldValue != '') {
+    //TODO: Work out a way of firing events,
+    //now that synthesising them gives appendMessage errors
+    Utils.fireHtmlEvent(element, "change");
+  }
+  return {statusCode: 0};
+}
+
+/**
+ * Gets the attribute of the element
+ * If the attribute is {disabled, selected, checked, index}, always returns
+ * the sensible default (i.e. never null)
+ */
+function getElementAttribute(element, attribute) {
+  var value = null;
+  switch (attribute.toLowerCase()) {
+  case "disabled":
+    value = (element.disabled ? element.disabled : "false");
+    break;
+  case "selected":
+    value = findWhetherElementIsSelected(element);
+    break;
+  case "checked":
+    value = (element.checked ? element.checked : "false");
+    break;
+  case "index":
+    value = element.index;
+    break;
+  }
+  if (value == null) {
+    value = element.getAttribute(attribute);
+  }
+  return {statusCode: 0, value: value};
+}
+
+/**
+ * Gets the source of the current document
+ */
+function getSource() {
+  if (guessPageType() == "html") {
+    return {statusCode: 0, value: ChromeDriverContentScript.currentDocument.getElementsByTagName("html")[0].outerHTML};
+  } else if (guessPageType() == "text") {
+    return {statusCode: 0, value: ChromeDriverContentScript.currentDocument.getElementsByTagName("pre")[0].innerHTML};
+  }
+}
+
+/**
+ * Get whether the element is currently displayed (i.e. can be seen in the browser)
+ */
+function isElementDisplayed(element) {
+  try {
+    checkElementIsDisplayed(element)
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Selects the element (i.e. sets its selected/checked value to true)
+ * @param element An option element or input element with type checkbox or radio
+ */
+function selectElement(element) {
+  var oldValue = true;
+  try {
+    checkElementIsDisplayed(element);
+    checkElementNotDisabled(element);
+    var tagName = element.tagName.toLowerCase();
+    if (tagName == "option") {
+      oldValue = element.selected;
+      element.selected = true;
+    } else if (tagName == "input") {
+      var type = element.getAttribute("type").toLowerCase();
+      if (type == "checkbox") {
+        oldValue = element.checked;
+        element.checked = true;
+      } else if (type == "radio") {
+        oldValue = element.checked;
+        element.checked = true;
+      } else {
+        throw {statusCode: 12, value: {message: "Cannot select an input." + type}};
+      }
+    } else {
+      throw {statusCode: 12, value: {message: "Cannot select a " + tagName}};
+    }
+  } catch(e) {
+    return e;
+  }
+  if (!oldValue) {
+    //TODO: Work out a way of firing events,
+    //now that synthesising them gives appendMessage errors
+    if (tagName == "option") {
+      var select = element;
+      while (select.parentNode != null && select.tagName.toLowerCase() != "select") {
+        select = select.parentNode;
+      }
+      if (select.tagName.toLowerCase() == "select") {
+        element = select;
+      } else {
+        //If we're not within a select element, fire the event from the option, and hope that it bubbles up
+        console.log("Falling back to event firing from option, not select element");
+      }
+    }
+    Utils.fireHtmlEvent(element, "change");
+  }
+  return {statusCode: 0};
+}
+
+/**
+ * Focus the element so that native code can type to it
+ * @param keys the string to type.  Must not be an array.
+ */
+function sendElementKeys(element, keys, elementId) {
+  try {
+    checkElementIsDisplayed(element)
+  } catch (e) {
+    return e;
+  }
+  var oldFocusedElement = ChromeDriverContentScript.currentDocument.activeElement;
+  if (oldFocusedElement != element) {
+    //TODO: Work out a way of firing events,
+    //now that synthesising them gives appendMessage errors
+    Utils.fireHtmlEventAndConditionallyPerformAction(oldFocusedElement, "blur", function() {oldFocusedElement.blur();});
+    Utils.fireHtmlEventAndConditionallyPerformAction(element, "focus", function() {element.focus();});
+  }
+  return {statusCode: "no-op", keys: keys, elementId: elementId};
+}
+
+/**
+ * @param keys the string to type.  Must not be an array.
+ */
+function sendElementNonNativeKeys(element, keys) {
+  //TODO(danielwh): Any kind of actually support for non-native keys
+  for (var i = 0; i < keys.length; i++) {
+    element.value += keys.charAt(i);
+  }
+  return {statusCode: 0};
+}
+
+/**
+ * Submits the element if it is a form, or the closest enclosing form otherwise
+ */
+function submitElement(element) {
+  while (element != null) {
+    if (element.tagName.toLowerCase() == "form") {
+      Utils.fireHtmlEventAndConditionallyPerformAction(element, "submit", function() {element.submit();});
+      return {statusCode: 0};
+    }
+    element = element.parentNode;
+  }
+  return {statusCode: 12, value: {message: "Cannot submit an element not in a form"}};
+}
+
+/**
+ * Toggles the element if it is an input element of type checkbox,
+ * or option element in a multi-select select element
+ */
+function toggleElement(element) {
+  var changed = false;
+  var oldValue = null;
+  var newValue = null;
+  try {
+    checkElementIsDisplayed(element);
+    checkElementNotDisabled(element);
+    var tagName = element.tagName.toLowerCase();
+    if (tagName == "option") {
+      var parent = element;
+      while (parent != null && parent.tagName.toLowerCase() != "select") {
+        parent = parent.parentNode;
+      }
+      if (parent == null) {
+        throw {statusCode: 12, value: {message: "option tag had no select tag parent"}};
+      }
+      oldValue = element.selected;
+      if (oldValue && !parent.multiple) {
+        throw {statusCode: 12, value: {message: "Cannot unselect a single element select"}};
+      }
+      newValue = element.selected = !oldValue;
+    } else if (tagName == "input") {
+      var type = element.getAttribute("type").toLowerCase();
+      if (type == "checkbox") {
+        oldValue = element.checked;
+        newValue = element.checked = !oldValue;
+        changed = true;
+      } else {
+        throw {statusCode: 12, value: {message: "Cannot toggle an input." + type}};
+      }
+    } else {
+      throw {statusCode: 12, value: {message: "Cannot toggle a " + tagName}};
+    }
+  } catch (e) {
+    return e;
+  }
+  console.log("New value: " + newValue);
+  
+  if (changed) {
+    //TODO: Work out a way of firing events,
+    //now that synthesising them gives appendMessage errors
+    Utils.fireHtmlEvent(element, "change");
+  }
+  return {statusCode: 0, value: newValue};
+}
+
+/**
+ * Gets the CSS property asked for
+ * @param style CSS property to get
+ */
+function getStyle(element, style) {
+  var value = ChromeDriverContentScript.currentDocument.defaultView.getComputedStyle(element, null).getPropertyValue(style);
+  return rgbToRRGGBB(value);
+}
+
+function switchToNamedIFrameIfOneExists(name) {
+  var iframes = ChromeDriverContentScript.currentDocument.getElementsByTagName("iframe");
+  for (var i = 0; i < iframes.length; ++i) {
+    if (iframes[i].name == name || iframes[i].id == name) {
+      ChromeDriverContentScript.currentDocument = iframes[i].contentDocument;
+      return {statusCode: 0};
+    }
+  }
+  return {statusCode: 8, value: {message: 'Could not find iframe to switch to by name:' + name}};
+}
+
+function sniffForMetaRedirects() {
+  for (var i = 0; i < ChromeDriverContentScript.currentDocument.getElementsByTagName("meta").length; ++i) {
+    if (ChromeDriverContentScript.currentDocument.getElementsByTagName("meta")[i].hasAttribute("http-equiv") &&
+        ChromeDriverContentScript.currentDocument.getElementsByTagName("meta")[i].getAttribute("http-equiv").toLowerCase == "refresh") {
+      return {statusCode: "no-op", value: true};
+    }
+  }
+  return {statusCode: "no-op", value: false};
+}
+
+function parseWrappedArguments(argument) {
+  //Parse the arguments into actual values (which are wrapped up in JSON)
+  if (argument.length !== undefined) {
+    var array = [];
+    for (var i = 0; i < argument.length; ++i) {
+      array.push(parseWrappedArguments(argument[i]));
+    }
+    return {success: true, value: array};
+  }
+  switch (argument.type) {
+  case "ELEMENT":
+    //Wrap up as a special object with the element's canonical xpath, which the page can work out
+    var element_id = argument.value;
+    var element = null;
+    try {
+      element = internalGetElement(element_id);
+    } catch (e) {
+      return {success: false, value: {response: "execute", value:
+          {statusCode: 10,
+           message: "Tried use obsolete element as argument when executing javascript."}}};
+    }
+    return {success: true, value: {webdriverElementXPath: getXPathOfElement(element)}};
+    break;
+  //Intentional falling through because Javascript will parse things properly
+  case "STRING":
+  case "BOOLEAN":
+  case "NUMBER":
+    return {success: true, value: argument.value};
+    break;
+  }
+  return {success: false, value: {statusCode: 17,
+        message: "Bad argument to javascript."}}
+}
+
+/**
+ * Execute arbitrary javascript in the page.
+ * Returns by callback to returnFromJavascriptInPage.
+ * Yes, this is *horribly* hacky.
+ * We can't share objects between content script and page, so have to wrap up arguments as JSON
+ * @param script script to execute as a string
+ * @param passedArgs array of arguments to pass to the script
+ * @param callback function to call when the result is returned.  Passed a DOMAttrModified event which should be parsed as returnFromJavascriptInPage
+ * TODO: Make the callback be passed the parsed result.
+ */
+function execute_(script, passedArgs, callback) {
+  console.log("executing " + script + ", args: " + JSON.stringify(passedArgs));
+  var func = "function(){" + script + "}";
+  var args = [];
+  for (var i = 0; i < passedArgs.length; ++i) {
+    console.log("Parsing: " + JSON.stringify(passedArgs[i]));
+    var value = parseWrappedArguments(passedArgs[i]);
+    if (value.success) {
+      args.push(value.value);
+    } else {
+      ChromeDriverContentScript.port.postMessage({response: value.value, sequenceNumber: ChromeDriverContentScript.currentSequenceNumber});
+      return;
+    }
+  }
+  //Add a script tag to the page, containing the script we wish to execute
+  var scriptTag = ChromeDriverContentScript.currentDocument.createElement('script');
+  var argsString = JSON.stringify(args).replace(/"/g, "\\\"");
+  scriptTag.innerText = 'var e = document.createEvent("MutationEvent");' +
+                        //Dump our arguments in an array
+                        'var args = JSON.parse("' + argsString + '");' +
+                        'var element = null;' +
+                        'for (var i = 0; i < args.length; ++i) {' +
+                          'if (args[i] && typeof(args[i]) == "object" && args[i].webdriverElementXPath) {' +
+                            //If this is an element (because it has the proper xpath), turn it into an actual element object
+                            'args[i] = document.evaluate(args[i].webdriverElementXPath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;' +
+                          '}' +
+                        '}' +
+                        'try {' +
+                          'var val = eval(' + func + ').apply(window, args);' +
+                          'if (typeof(val) == "string") { val = JSON.stringify(val); }' +
+                          //TODO(danielwh): Deal with the undefined != null case better
+                          'else if (val === undefined) { val = null; }' +
+                          'else if (typeof(val) == "object" && val && val.nodeType == 1) {' +
+                            //If we're returning an element, turn it into a special xpath-containing object
+                            'var path = "";' +
+                            'for (; val && val.nodeType == 1; val = val.parentNode) {' +
+                              'var index = 1;' +
+                              'for (var sibling = val.previousSibling; sibling; sibling = sibling.previousSibling) {' +
+                                'if (sibling.nodeType == 1 && sibling.tagName && sibling.tagName == val.tagName) {' +
+                                  'index++;' +
+                                '}' +
+                              '}' +
+                              'path = "/" + val.tagName + "[" + index + "]" + path;' +
+                            '}' +
+                            'val = JSON.stringify({webdriverElementXPath: path});' +
+                          '} else {' +
+                            'val = JSON.stringify(val);' +
+                          '}' +
+                          //Fire mutation event with newValue set to the JSON of our return value
+                          'e.initMutationEvent("DOMAttrModified", true, false, null, null, \'{\"value\": \' + val + \'}\', null, 0);' +
+                        '} catch (exn) {' +
+                          //Fire mutation event with prevValue set to EXCEPTION to indicate an error in the script
+                          'e.initMutationEvent("DOMAttrModified", true, false, null, "EXCEPTION", null, null, 0);' +
+                        '}' +
+                        'document.getElementsByTagName("script")[document.getElementsByTagName("script").length - 1].dispatchEvent(e);' +
+                        'document.getElementsByTagName("html")[0].removeChild(document.getElementsByTagName("script")[document.getElementsByTagName("script").length - 1]);';
+  scriptTag.addEventListener('DOMAttrModified', callback, false);
+  console.log("Injecting script element");
+  ChromeDriverContentScript.currentDocument.getElementsByTagName("html")[0].appendChild(scriptTag);
+}
+
+function execute(script, passedArgs) {
+  execute_(script, passedArgs, returnFromJavascriptInPage);
+}
+
+function parseReturnValueFromScript(result) {
+  console.log("Parsing: " + JSON.stringify(result));
+  var value = {"type":"NULL"};
+  if (result !== undefined && result != null && typeof(result) == "object") {
+    if (result.webdriverElementXPath) {
+      //If we're returning an element, turn it into an actual element object
+      value = {value: addElementToInternalArray(getElementsByXPath(result.webdriverElementXPath)[0]).toString(), type:"ELEMENT"};
+    } else if (result.length !== undefined) {
+      value = [];
+      for (var i = 0; i < result.length; ++i) {
+        value.push(parseReturnValueFromScript(result[i]));
+      }
+    }
+  } else if (result !== undefined && result != null) {
+    switch (typeof(result)) {
+    //Intentional falling through because we treat all "VALUE"s the same
+    case "string":
+    case "number":
+    case "boolean":
+      value = {value: result, type: "VALUE"};
+      break;
+    }
+  }
+  return value;
+}
+
+/**
+ * Callback from execute
+ */
+function returnFromJavascriptInPage(e) {
+  if (e.prevValue == "EXCEPTION") {
+    ChromeDriverContentScript.port.postMessage({sequenceNumber: ChromeDriverContentScript.currentSequenceNumber,
+        response: {response: "execute", value: {statusCode: 17,
+        message: "Tried to execute bad javascript."}}});
+    return;
+  }
+  console.log("Got result");
+  console.log("Result was: " + e.newValue.value);
+  var result = JSON.parse(e.newValue).value;
+  var value = parseReturnValueFromScript(result);
+  console.log("Return value: " + JSON.stringify(value));
+  ChromeDriverContentScript.port.postMessage({sequenceNumber: ChromeDriverContentScript.currentSequenceNumber, response: {response: "execute", value: {statusCode: 0, value: value}}});
+}
+
+function getFrameNameFromIndex(index) {
+  var scriptTag = ChromeDriverContentScript.currentDocument.createElement('script');
+  scriptTag.innerText = 'var e = document.createEvent("MutationEvent");' +
+                        'try {' +
+                          'var val = window.frames[' + index + '].name;' +
+                          'e.initMutationEvent("DOMAttrModified", true, false, null, null, val, null, 0);' +
+                        '} catch (exn) {' +
+                          //Fire mutation event with prevValue set to EXCEPTION to indicate an error in the script
+                          'e.initMutationEvent("DOMAttrModified", true, false, null, "EXCEPTION", null, null, 0);' +
+                        '}' +
+                        'document.getElementsByTagName("script")[document.getElementsByTagName("script").length - 1].dispatchEvent(e);' +
+                        'document.getElementsByTagName("html")[0].removeChild(document.getElementsByTagName("script")[document.getElementsByTagName("script").length - 1]);';
+  scriptTag.addEventListener('DOMAttrModified', returnFromGetFrameNameFromIndexJavascriptInPage, false);
+  try {
+    if (ChromeDriverContentScript.currentDocument.getElementsByTagName("frameset").length > 0) {
+      ChromeDriverContentScript.currentDocument.getElementsByTagName("frameset")[0].appendChild(scriptTag);
+    } else {
+      ChromeDriverContentScript.currentDocument.getElementsByTagName("html")[0].appendChild(scriptTag);
+    }
+  } catch (e) {
+    ChromeDriverContentScript.port.postMessage({sequenceNumber: ChromeDriverContentScript.currentSequenceNumber,
+        response: {response: "getFrameNameFromIndex", value: {statusCode: 8,
+        message: "Page seemed not to be a frameset.  Couldn't find frame"}}});
+  }
+}
+
+function returnFromGetFrameNameFromIndexJavascriptInPage(e) {
+  if (e.prevValue == "EXCEPTION") {
+    ChromeDriverContentScript.port.postMessage({sequenceNumber: ChromeDriverContentScript.currentSequenceNumber,
+        response: {response: "getFrameNameFromIndex", value: {statusCode: 8,
+        message: "No such frame"}}});
+  } else {
+    ChromeDriverContentScript.port.postMessage({sequenceNumber: ChromeDriverContentScript.currentSequenceNumber,
+        response: {response: "getFrameNameFromIndex", value: {statusCode: "no-op",
+        name: e.newValue}}});
+  }
+}
+
+/**
+ * Inject an embed tag so the native code can grab the HWND
+ */
+function injectEmbed() {
+  ChromeDriverContentScript.injectedEmbedElement = ChromeDriverContentScript.currentDocument.createElement('embed');
+  ChromeDriverContentScript.injectedEmbedElement.setAttribute("type", "application/x-chromedriver-reporter");
+  ChromeDriverContentScript.injectedEmbedElement.setAttribute("style", "width: 0; height: 0;");
+  ChromeDriverContentScript.currentDocument.getElementsByTagName("html")[0].appendChild(ChromeDriverContentScript.injectedEmbedElement);
+  //Give the embed time to render.  Hope that the followup doesn't count embeds or anything
+  setTimeout(removeInjectedEmbed, 100);
+}
+
+function removeInjectedEmbed() {
+  if (ChromeDriverContentScript.injectedEmbedElement != null) {
+    ChromeDriverContentScript.currentDocument.getElementsByTagName("html")[0].removeChild(ChromeDriverContentScript.injectedEmbedElement);
+    ChromeDriverContentScript.injectedEmbedElement = null;
+  }
+}
+
+/**
+ * Guesses whether we have an HTML document or a text file
+ */
+function guessPageType() {
+  var source = ChromeDriverContentScript.currentDocument.getElementsByTagName("html")[0].outerHTML;
+  var textSourceBegins = '<html><body><pre style="word-wrap: break-word; white-space: pre-wrap;">';
+  var textSourceEnds = '</pre></body></html>';
+  
+  if (source.substr(0, textSourceBegins.length) == textSourceBegins && 
+      source.substr(0 - textSourceEnds.length) == textSourceEnds) {
+    return "text";
+  } else {
+    return "html";
+  }
+}
+
+/**
+ * Gets an array of elements which match the passed xpath string
+ */
+function getElementsByXPath(xpath) {
+  var elements = [];
+  var foundElements = ChromeDriverContentScript.currentDocument.evaluate(xpath, ChromeDriverContentScript.currentDocument, null, XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
+  var this_element = foundElements.iterateNext();
+  while (this_element) {
+    elements.push(this_element);
+    this_element = foundElements.iterateNext();
+  }
+  return elements;
+}
+
+/**
+ * Gets canonical xpath of the passed element, e.g. /HTML/BODY/P[1]
+ */
+function getXPathOfElement(element) {
+  var path = "";
+  for (; element && element.nodeType == 1; element = element.parentNode) {
+    index = getElementIndexForXPath(element);
+    path = "/" + element.tagName + "[" + index + "]" + path;
+  }
+  return path;	
+}
+
+/**
+ * Returns n for the nth element of type element.tagName in the page
+ */
+function getElementIndexForXPath(element) {
+  var index = 1;
+  for (var sibling = element.previousSibling; sibling ; sibling = sibling.previousSibling) {
+    if (sibling.nodeType == 1 && sibling.tagName == element.tagName) {
+      index++;
+    }
+  }
+  return index;
+}
+
+/**
+ * Gets an array of link elements whose displayed text is linkText
+ */
+function getElementsByLinkText(parent, linkText) {
+  var links = parent.getElementsByTagName("a");
+  var matchingLinks = [];
+  for (var i = 0; i < links.length; i++) {
+    if (Utils.getText(links[i]) == linkText) {
+      matchingLinks.push(links[i]);
+    }
+  }
+  return matchingLinks;
+}
+
+/**
+ * Gets an array of link elements whose displayed text includes linkText
+ */
+function getElementsByPartialLinkText(parent, partialLinkText) {
+  var links = parent.getElementsByTagName("a");
+  var matchingLinks = [];
+  for (var i = 0; i < links.length; i++) {
+    if (Utils.getText(links[i]).indexOf(partialLinkText) > -1) {
+      matchingLinks.push(links[i]);
+    }
+  }
+  return matchingLinks;
+}
+
+/**
+ * Throws exception if element is not displayed
+ * @return nothing if element is displayed
+ * @throws ElementNotVisibleException object ready to be sent if element is not displayed
+ */
+function checkElementIsDisplayed(element) {
+  if (element.tagName.toLowerCase() == "title") {
+    //Always visible
+    return;
+  }
+  if (!Utils.isDisplayed(element)) {
+    throw {statusCode: 11, value: {message: "Element was not visible"}};
+  }
+}
+
+/**
+ * Throws exception if element is disabled
+ * @return nothing if element is enabled
+ * @throws UnsupoprtedOperationException object ready to be sent if element is disabled
+ */
+function checkElementNotDisabled(element) {
+  if (element.disabled) {
+    throw {statusCode: 12, value: {message: "Cannot operate on disabled element"}};
+  }
+}
+
+/**
+ * Checks whether element is selected/checked
+ * @return true if element is {selectable and selected, checkable and checked},
+ *         false otherwise
+ */
+function findWhetherElementIsSelected(element) {
+  var selected = false;
+  try {
+    var tagName = element.tagName.toLowerCase();
+    if (tagName == "option") {
+      selected = element.selected;
+    } else if (tagName == "input") {
+      var type = element.getAttribute("type").toLowerCase();
+      if (type == "checkbox" || type == "radio") {
+        selected = element.checked;
+      }
+    } else {
+      selected = element.getAttribute("selected");
+    }
+  } catch (e) {
+    selected = false;
+  }
+  return selected;
+}
+
+/**
+ * Gets the coordinates of the top-left corner of the element on the browser window
+ * (NOT the displayed portion, the WHOLE page)
+ * Heavily influenced by com.google.gwt.dom.client.DOMImplSafari,
+ * which is released under Apache 2
+ * It's not actually correct...
+ * @return array: [x, y]
+ */
+function getElementCoords(elem) {
+  var left = 0;
+  var top = 0;
+  if (frameElement) {
+    left += frameElement.offsetLeft;
+    top += frameElement.offsetTop;
+  }
+  try {
+    if (elem.getBoundingClientRect) {
+      var rect = elem.getBoundingClientRect();
+      left += rect.left + ChromeDriverContentScript.currentDocument.body.scrollLeft;
+      top += rect.top + ChromeDriverContentScript.currentDocument.body.scrollTop;
+      return [left, top];
+    }
+  } catch(e) {
+    var left = 0;
+    var top = 0;
+    if (frameElement) {
+      left += frameElement.offsetLeft;
+      top += frameElement.offsetTop;
+    }
+  }
+  
+  //The below is ugly and NOT ACTUALLY RIGHT
+  
+  // Unattached elements and elements (or their ancestors) with style
+  // 'display: none' have no offset{Top,Left}.
+  if (elem.offsetTop == null || elem.offsetLeft == null) {
+    return [left, top];
+  }
+
+  var doc = elem.ownerDocument;
+  var curr = elem.parentNode;
+  if (curr) {
+    // This intentionally excludes body which has a null offsetParent.
+    while (curr.offsetParent) {
+      top -= curr.scrollTop;
+      left -= curr.scrollLeft;
+
+      // In RTL mode, offsetLeft is relative to the left edge of the
+      // scrollable area when scrolled all the way to the right, so we need
+      // to add back that difference.
+      if (getStyle(curr, 'direction') == 'rtl') {
+        left += (curr.scrollWidth - curr.clientWidth);
+      }
+
+      curr = curr.parentNode;
+    }
+  }
+
+  while (elem) {
+    top += elem.offsetTop;
+    left += elem.offsetLeft;
+
+    if (getStyle(elem, 'position') == 'fixed') {
+      top += doc.body.scrollTop;
+      left += doc.body.scrollLeft;
+      return [left, top];
+    }
+
+
+    // Webkit bug: a top-level absolutely positioned element includes the
+    // body's offset position already.
+    var parent = elem.offsetParent;
+    if (parent && (parent.tagName == 'BODY') &&
+        (getStyle(elem, 'position') == 'absolute')) {
+      break;
+    }
+
+    elem = parent;
+  }
+  return [left, top];
+}
+
+/**
+ * Gets the maximum offsetHeight and offsetWidth of an element or those of its sub-elements
+ * In place because element.offset{Height,Width} returns incorrectly in WebKit (see bug 28810)
+ * @param element element to get max dimensions of
+ * @param width optional greatest width seen so far (omit when calling)
+ * @param height optional greatest height seen so far (omit when calling)
+ * @return an object of form: {type: "DIMENSION", width: maxOffsetWidth, height: maxOffsetHeight}
+ */
+function getOffsetSizeFromSubElements(element, maxWidth, maxHeight) {
+  if (element.getBoundingClientRect) {
+    var rect = element.getBoundingClientRect();
+    return {type: "DIMENSION", width: rect.width, height: rect.height};
+  }
+  //The below isn't correct, but is a hack with a decent probability of being correct, if the element has no BoundingClientRect
+  //TODO(danielwh): Fix this up a bit
+  maxWidth = (maxWidth === undefined || element.offsetWidth > maxWidth) ? element.offsetWidth : maxWidth;
+  maxHeight = (maxHeight === undefined || element.offsetHeight > maxHeight) ? element.offsetHeight : maxHeight;
+  for (var child in element.children) {
+    var childSize = getOffsetSizeFromSubElements(element.children[child], maxWidth, maxHeight);
+    maxWidth = (childSize.width > maxWidth) ? childSize.width : maxWidth;
+    maxHeight = (childSize.height > maxHeight) ? childSize.height : maxHeight;
+  }
+  return {type: "DIMENSION", width: maxWidth, height: maxHeight};
+}
+
+/**
+ * Converts rgb(x, y, z) colours to #RRGGBB colours
+ * @param rgb string of form either rgb(x, y, z) or rgba(x, y, z, a) with x, y, z, a numbers
+ * @return string of form #RRGGBB where RR, GG, BB are two-digit lower-case hex values
+ */
+function rgbToRRGGBB(rgb) {
+  var r, g, b;
+  var values = rgb.split(",");
+  if (values.length == 3 && values[0].length > 4 && values[0].substr(0, 4) == "rgb(") {
+    r = decimalToHex(values[0].substr(4));
+    g = decimalToHex(values[1]);
+    b = decimalToHex(values[2].substr(0, values[2].length - 1));
+    if (r == null || g == null || b == null) {
+      return null;
+    }
+    return "#" + r + g + b;
+  } else if (rgb == "rgba(0, 0, 0, 0)") {
+    return "transparent";
+  } else {
+    return rgb;
+  }
+}
+
+/**
+ * Convert a number from decimal to a hex string of at least two digits
+ * @return null if value was not an int, two digit string representation
+ *        (with leading zero if needed) of value in base 16 otherwise
+ */
+function decimalToHex(value) {
+  value = parseInt(value).toString(16);
+  if (value == null) {
+    return null;
+  }
+  if (value.length == 1) {
+    value = '0' + '' + value;
+  }
+  return value;
+}