RubyGems - selenium-webdriver - Versions diffs - 0.0.1 - Mend

selenium-webdriver 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (86) hide show

data/chrome/prebuilt/Win32/Release/npchromedriver.dll +0 -0
data/chrome/prebuilt/x64/Release/npchromedriver.dll +0 -0
data/chrome/src/extension/background.html +9 -0
data/chrome/src/extension/background.js +933 -0
data/chrome/src/extension/content_script.js +1286 -0
data/chrome/src/extension/manifest-nonwin.json +15 -0
data/chrome/src/extension/manifest-win.json +16 -0
data/chrome/src/extension/toolstrip.html +28 -0
data/chrome/src/extension/utils.js +196 -0
data/chrome/src/rb/lib/selenium/webdriver/chrome.rb +8 -0
data/chrome/src/rb/lib/selenium/webdriver/chrome/bridge.rb +324 -0
data/chrome/src/rb/lib/selenium/webdriver/chrome/command_executor.rb +70 -0
data/chrome/src/rb/lib/selenium/webdriver/chrome/launcher.rb +119 -0
data/common/src/js/abstractcommandprocessor.js +161 -0
data/common/src/js/asserts.js +296 -0
data/common/src/js/by.js +147 -0
data/common/src/js/command.js +274 -0
data/common/src/js/context.js +58 -0
data/common/src/js/extension/README +2 -0
data/common/src/js/extension/dommessenger.js +152 -0
data/common/src/js/factory.js +55 -0
data/common/src/js/future.js +118 -0
data/common/src/js/key.js +117 -0
data/common/src/js/localcommandprocessor.js +181 -0
data/common/src/js/logging.js +249 -0
data/common/src/js/testrunner.js +605 -0
data/common/src/js/timing.js +89 -0
data/common/src/js/wait.js +199 -0
data/common/src/js/webdriver.js +853 -0
data/common/src/js/webelement.js +683 -0
data/common/src/rb/lib/selenium-webdriver.rb +1 -0
data/common/src/rb/lib/selenium/webdriver.rb +52 -0
data/common/src/rb/lib/selenium/webdriver/bridge_helper.rb +88 -0
data/common/src/rb/lib/selenium/webdriver/child_process.rb +85 -0
data/common/src/rb/lib/selenium/webdriver/core_ext/dir.rb +41 -0
data/common/src/rb/lib/selenium/webdriver/driver.rb +128 -0
data/common/src/rb/lib/selenium/webdriver/element.rb +126 -0
data/common/src/rb/lib/selenium/webdriver/error.rb +68 -0
data/common/src/rb/lib/selenium/webdriver/find.rb +69 -0
data/common/src/rb/lib/selenium/webdriver/navigation.rb +23 -0
data/common/src/rb/lib/selenium/webdriver/options.rb +50 -0
data/common/src/rb/lib/selenium/webdriver/platform.rb +82 -0
data/common/src/rb/lib/selenium/webdriver/target_locator.rb +23 -0
data/firefox/prebuilt/nsICommandProcessor.xpt +0 -0
data/firefox/prebuilt/nsINativeEvents.xpt +0 -0
data/firefox/prebuilt/nsIResponseHandler.xpt +0 -0
data/firefox/src/extension/chrome.manifest +3 -0
data/firefox/src/extension/components/context.js +37 -0
data/firefox/src/extension/components/driver-component.js +127 -0
data/firefox/src/extension/components/firefoxDriver.js +706 -0
data/firefox/src/extension/components/json2.js +273 -0
data/firefox/src/extension/components/keytest.html +554 -0
data/firefox/src/extension/components/nsCommandProcessor.js +586 -0
data/firefox/src/extension/components/screenshooter.js +70 -0
data/firefox/src/extension/components/socketListener.js +185 -0
data/firefox/src/extension/components/utils.js +1200 -0
data/firefox/src/extension/components/webLoadingListener.js +57 -0
data/firefox/src/extension/components/webdriverserver.js +101 -0
data/firefox/src/extension/components/wrappedElement.js +609 -0
data/firefox/src/extension/content/fxdriver.xul +30 -0
data/firefox/src/extension/content/server.js +95 -0
data/firefox/src/extension/idl/nsICommandProcessor.idl +38 -0
data/firefox/src/extension/idl/nsIResponseHandler.idl +34 -0
data/firefox/src/extension/install.rdf +29 -0
data/firefox/src/rb/lib/selenium/webdriver/firefox.rb +21 -0
data/firefox/src/rb/lib/selenium/webdriver/firefox/binary.rb +86 -0
data/firefox/src/rb/lib/selenium/webdriver/firefox/bridge.rb +426 -0
data/firefox/src/rb/lib/selenium/webdriver/firefox/extension_connection.rb +82 -0
data/firefox/src/rb/lib/selenium/webdriver/firefox/launcher.rb +132 -0
data/firefox/src/rb/lib/selenium/webdriver/firefox/profile.rb +174 -0
data/firefox/src/rb/lib/selenium/webdriver/firefox/profiles_ini.rb +60 -0
data/firefox/src/rb/lib/selenium/webdriver/firefox/util.rb +23 -0
data/jobbie/prebuilt/Win32/Release/InternetExplorerDriver.dll +0 -0
data/jobbie/prebuilt/x64/Release/InternetExplorerDriver.dll +0 -0
data/jobbie/src/rb/lib/selenium/webdriver/ie.rb +14 -0
data/jobbie/src/rb/lib/selenium/webdriver/ie/bridge.rb +552 -0
data/jobbie/src/rb/lib/selenium/webdriver/ie/lib.rb +94 -0
data/jobbie/src/rb/lib/selenium/webdriver/ie/util.rb +147 -0
data/remote/client/src/rb/lib/selenium/webdriver/remote.rb +16 -0
data/remote/client/src/rb/lib/selenium/webdriver/remote/bridge.rb +374 -0
data/remote/client/src/rb/lib/selenium/webdriver/remote/capabilities.rb +105 -0
data/remote/client/src/rb/lib/selenium/webdriver/remote/commands.rb +53 -0
data/remote/client/src/rb/lib/selenium/webdriver/remote/default_http_client.rb +71 -0
data/remote/client/src/rb/lib/selenium/webdriver/remote/response.rb +43 -0
data/remote/client/src/rb/lib/selenium/webdriver/remote/server_error.rb +32 -0
metadata +182 -0

data/chrome/prebuilt/Win32/Release/npchromedriver.dll ADDED

Binary file

data/chrome/prebuilt/x64/Release/npchromedriver.dll ADDED

Binary file

data/chrome/src/extension/background.html ADDED

@@ -0,0 +1,9 @@
+<html>
+  <head>
+    <title>WebDriver</title>
+    <script type="text/javascript" src="background.js"></script>
+  </head>
+  <body>
+    <p><embed type="application/x-chromedriver" /></p>
+  </body>
+</html>

data/chrome/src/extension/background.js ADDED

@@ -0,0 +1,933 @@
+/** @namespace */
+ChromeDriver = {};
+/**
+ * Array of all information about currently loaded tabs (where a WebDriver
+ * window is probably a tab)
+ * Entries of form:
+ * {Int tabId, String windowName, Port mainPort, Boolean isFrameset, FrameData[] frames}
+ * FrameData ::= {[Int frameId], String frameName, Port framePort, FrameData[]}
+ * frameId can be undefined, if it has not yet been looked up, but should be
+ * added once it is known
+ * @type {Array.<Object>}  TODO(jmleyba): Type info
+ */
+ChromeDriver.tabs = [];
+/**
+ * Port to the currently active frame (or tab, if the current page is not a
+ * frameset).
+ * @type {?Port}
+ */
+ChromeDriver.activePort = null;
+/**
+ * ID of the currently active tab.
+ * @type {?string}
+ */
+ChromeDriver.activeTabId = null;
+/**
+ * Whether we should switch to the next tab which opens. Should be set if the
+ * last active tab was closed.
+ * @type {boolean}
+ */
+ChromeDriver.doFocusOnNextOpenedTab = true;
+/**
+ * Place to temporarily store the URL currently being loaded, so that we can
+ * retry if needed, because opening a URL is an async callback.
+ * @type {?string}
+ */
+ChromeDriver.urlBeingLoaded = null;
+/**
+ * URL we believe we're currently on.
+ * @type {?string}
+ */
+ChromeDriver.currentUrl = null;
+/**
+ * Whether we are loading a new URL that difers from the current URL only in
+ * fragment.
+ * @type {boolean}
+ */
+ChromeDriver.isGettingUrlButOnlyChangingByFragment = false;
+/**
+ * Whether we are currently executing a {@code ChromeDriver#close()}, and
+ * accordingly should send a success response when the tab closes.
+ * @type {boolean}
+ */
+ChromeDriver.isClosingTab = false;
+/**
+ * Whether we have sent a response to the {currently, most recently loading
+ * page.
+ * @type {boolean}
+ */
+ChromeDriver.hasSentResponseToThisPageLoading = false;
+/**
+ * Whether we believe a page is open to which we have no content script.
+ * @type {boolean}
+ */
+ChromeDriver.hasNoConnectionToPage = true;
+/**
+ * Stores the remaining frames to traverse when switching frames.
+ * @type {Array.<string>}
+ */
+ChromeDriver.restOfCurrentFramePath = [];
+/**
+ * Port to the frameset or main content page we currently have loaded, so that
+ * we can probe it for information about its frames.
+ * @type {?Port}
+ */
+ChromeDriver.portToUseForFrameLookups = null;
+/**
+ * The last request we sent that has not been answered, so that if we change
+ * page between sending a request and receiving a response, we can re-send it to
+ * the newly loaded page.
+ * @type {*}  TODO(jmleyba)
+ */
+ChromeDriver.lastRequestToBeSentWhichHasntBeenAnsweredYet = null;
+/**
+ * Whether the plugin has the OS-specific window handle for the active tab. This
+ * is called HWND rather than window handle to avoid confusion with the other
+ * use of window handle to mean 'name of window'.
+ * @type {boolean}
+ */
+ChromeDriver.hasHwnd = false;
+/**
+ * THe last XMLHttpRequest we made (used for communication with test language
+ * bindings).
+ * @type {?XMLHttpRequest}
+ */
+ChromeDriver.xmlHttpRequest = null;
+/**
+ * URL to ping for commands.
+ * TODO(danielwh): Get this from the initial URL - see http://crbug.com/11547,
+ * the ChromeDriverInternals wiki page.
+ * There is a patch to fix this on the Downloads page of the Selenium project
+ * @type {string}
+ */
+ChromeDriver.xmlHttpRequestUrl = "http://127.0.0.1:9700/chromeCommandExecutor";
+/**
+ * @type {number}
+ */
+ChromeDriver.requestSequenceNumber = 0;
+/**
+ * @type {number}
+ */
+ChromeDriver.getUrlRequestSequenceNumber = 0;
+/**
+ * Prefix prepended to the hopefully unique javascript window name, in hopes of
+ * further removing conflict.
+ * @type {string}
+ */
+ChromeDriver.windowHandlePrefix = '__webdriver_chromedriver_windowhandle';
+/**
+ * Whether we will not execute any commands because we are already executing
+ * one.
+ * @type {boolean}
+ */
+ChromeDriver.isBlockedWaitingForResponse = false;
+/**
+ * It's possible that the page has completed loading,
+ * but the content script has not yet fired.
+ * In this case, to not report that there is no page,
+ * when we are just too fast, we wait up to this amount of time.
+ * @type {number} unit: milliseconds
+ */
+ChromeDriver.timeoutUntilGiveUpOnContentScriptLoading = 5000;
+/**
+ * How long we are currently waiting for the content script to load
+ * after loading the page
+ * @type {number} unit: milliseconds
+ */
+ChromeDriver.currentlyWaitingUntilGiveUpOnContentScriptLoading;
+//Set ChromeDriver.currentlyWaitingUntilGiveUpOnContentScriptLoading;
+resetCurrentlyWaitingOnContentScriptTime();
+/**
+ * How long we wait between poling whether we have a content script,
+ * when loading a new page, up until
+ * ChromeDriver.timeoutUntilGiveUpOnContentScriptLoading
+ * @type {number} unit: milliseconds
+ */
+ChromeDriver.waitForContentScriptIncrement = 100;
+chrome.extension.onConnect.addListener(function(port) {
+  console.log("Connected to " + port.name);
+  // Note: The frameset port *always* connects before any frame port.  After
+  // that, the order is in page loading time
+  ChromeDriver.hasNoConnectionToPage = false;
+  var foundTab = false;
+  for (var tab in ChromeDriver.tabs) {
+    if (ChromeDriver.tabs[tab].tabId == port.tab.id) {
+      //We must be a new [i]frame in the page, because when a page closes, it is
+      // removed from ChromeDriver.tabs
+      //TODO(danielwh): Work out WHICH page it's a sub-frame of (I don't look
+      // forward to this)
+      ChromeDriver.tabs[tab].frames.push({
+        frameName: port.name,
+        framePort: port,
+        frames: []
+      });
+      //Loaded a frame.  Pushed it to the array.  We don't know which page it's
+      // a sub-frame of, in the case of nested frames, if they have the same
+      // names.  It would be nice to think people didn't use frames, let alone
+      // several layers of nesting of frames with the same name, but if it turns
+      // out to be a problem... Well, we'll see.
+      foundTab = true;
+      break;
+    }
+  }
+  if (!foundTab) {
+    //New tab!
+    //We don't know if it's a frameset yet, so we leave that as undefined
+    ChromeDriver.tabs.push({
+      tabId: port.tab.id,
+      windowName: ChromeDriver.windowHandlePrefix + "_" + port.tab.id,
+      mainPort: port,
+      frames: []
+    });
+  }
+  if (ChromeDriver.doFocusOnNextOpenedTab) {
+    ChromeDriver.activePort = port;
+    setActiveTabDetails(port.tab);
+    //Re-parse the last request we sent if we didn't get a response,
+    //because we ain't seeing a response any time soon
+    if (ChromeDriver.lastRequestToBeSentWhichHasntBeenAnsweredYet != null) {
+      if (ChromeDriver.urlBeingLoaded != null) {
+        ChromeDriver.lastRequestToBeSentWhichHasntBeenAnsweredYet = null;
+      } else {
+        ChromeDriver.isBlockedWaitingForResponse = false;
+        console.log("Re-trying request which was sent but not answered");
+        parseRequest(ChromeDriver.lastRequestToBeSentWhichHasntBeenAnsweredYet);
+      }
+    }
+  }
+  if (ChromeDriver.urlBeingLoaded != null) {
+    //This was the result of a getUrl.  Need to issue a response
+    sendEmptyResponseWhenTabIsLoaded(port.tab);
+  }
+  port.onMessage.addListener(parsePortMessage);
+  port.onDisconnect.addListener(function disconnectPort(port) {
+    console.log("Disconnected from " + port.name);
+    var remainingTabs = [];
+    for (var tab in ChromeDriver.tabs) {
+      if (ChromeDriver.tabs[tab].tabId == port.tab.id) {
+        if (ChromeDriver.tabs[tab].mainPort == port) {
+          //This main tab is being closed.
+          //Don't include it in the new version of ChromeDriver.tabs.
+          //Any subframes will also disconnect,
+          //but their tabId won't be present in the array,
+          //so they will be ignored.
+          continue;
+        } else {
+          //This is a subFrame being ditched
+          var remainingFrames = [];
+          for (var frame in ChromeDriver.tabs[tab].frames) {
+            if (ChromeDriver.tabs[tab].frames[frame].framePort == port) {
+              continue;
+            }
+            remainingFrames.push(ChromeDriver.tabs[tab].frames[frame]);
+          }
+          ChromeDriver.tabs[tab].frames = remainingFrames;
+        }
+      }
+      remainingTabs.push(ChromeDriver.tabs[tab]);
+    }
+    ChromeDriver.tabs = remainingTabs;
+    if (ChromeDriver.tabs.length == 0 || ChromeDriver.activePort == null ||
+        ChromeDriver.activePort.tab.id == port.tab.id) {
+      //If it is the active tab, perhaps we have followed a link,
+      //so we should focus on it.
+      //We have nothing better to focus on, anyway.
+      resetActiveTabDetails();
+    }
+    if (ChromeDriver.isClosingTab) {
+      //We are actively closing the tab, and expect a response to this
+      sendResponseToParsedRequest({statusCode: 0}, false)
+      ChromeDriver.isClosingTab = false;
+    }
+  });
+});
+//Tell the ChromeCommandExecutor that we are here
+sendResponseByXHR({statusCode: 0}, false);
+/**
+ * Sends the passed argument as the result of a command
+ * @param result object encapsulating result to send
+ * @param wait whether we expect this command to possibly make changes
+ * we need to wait for (e.g. adding elements, opening windows) - if so,
+ * we wait until we think these effects are done
+ */
+function sendResponseByXHR(result, wait) {
+  console.log("Sending result by XHR: " + JSON.stringify(result));
+  if (ChromeDriver.xmlHttpRequest != null) {
+    ChromeDriver.xmlHttpRequest.abort();
+  }
+  ChromeDriver.xmlHttpRequest = new XMLHttpRequest();
+  ChromeDriver.xmlHttpRequest.onreadystatechange =
+      handleXmlHttpRequestReadyStateChange;
+  ChromeDriver.xmlHttpRequest.open(
+      "POST", ChromeDriver.xmlHttpRequestUrl, true);
+  ChromeDriver.xmlHttpRequest.setRequestHeader(
+      "Content-type", "application/json");
+  //Default to waiting for page changes, just in case
+  //TODO(danielwh): Iterate over tabs checking their status
+  if (wait === undefined || wait == null || wait) {
+    setTimeout(sendResult, 600, [result]);
+  } else {
+    sendResult(result);
+  }
+}
+/**
+ * Actually sends the result by XHR
+ * Should only EVER be called by sendResponseByXHR,
+ * as it ignores things like setting up XHR and blocking,
+ * and just forces the sending over an assumed open XHR
+ * @param result String to send
+ */
+function sendResult(result) {
+  //TODO(danielwh): Iterate over tabs checking their status
+  ChromeDriver.xmlHttpRequest.send(result + "\nEOResponse\n");
+  console.log("Sent result by XHR: " + JSON.stringify(result));
+}
+/**
+ * Sends the response to a request, which has been parsed by parseRequest
+ * Should be used only from within parseRequest (or methods called from it),
+ * because it adheres to the blocking semantics of parseRequest
+ */
+function sendResponseToParsedRequest(toSend, wait) {
+  if (!ChromeDriver.isBlockedWaitingForResponse) {
+    console.log("Tried to send a response (" + toSend +
+                ") when not waiting for one.  Dropping response.");
+    return;
+  }
+  ChromeDriver.isBlockedWaitingForResponse = false;
+  ChromeDriver.lastRequestToBeSentWhichHasntBeenAnsweredYet = null;
+  console.log("SENDING RESPOND TO PARSED REQUEST");
+  sendResponseByXHR(JSON.stringify(toSend), wait);
+  setToolstripsBusy(false);
+}
+/**
+ * When we receive a request, dispatches parseRequest to execute it
+ */
+function handleXmlHttpRequestReadyStateChange() {
+  if (this.readyState == 4) {
+    if (this.status != 200) {
+      console.log("Request state was 4 but status: " + this.status +
+                  ".  responseText: " + this.responseText);
+    } else {
+      console.log("GOT XHR RESPONSE: " + this.responseText);
+      var request = JSON.parse(this.responseText);
+      if (request.request == "quit") {
+        //We're only allowed to send a response if we're blocked waiting for one, so pretend
+        console.log("SENDING QUIT XHR");
+        sendResponseByXHR(JSON.stringify({statusCode: 0}), false);
+      } else {
+        console.log("Got request to execute from XHR: " + this.responseText);
+        parseRequest(request);
+      }
+    }
+  }
+}
+/**
+ * Parses a request received from the ChromeCommandExecutor and either sends the
+ * response, or sends a message to the content script with a command to execute
+ * @param request object encapsulating the request (e.g.
+ *     {request: url, url: "http://www.google.co.uk"})
+ */
+function parseRequest(request) {
+  if (ChromeDriver.isBlockedWaitingForResponse) {
+    console.log("Already sent a request which hasn't been replied to yet. " +
+                "Not parsing any more.");
+    return;
+  }
+  ChromeDriver.isBlockedWaitingForResponse = true;
+  setToolstripsBusy(true);
+  switch (request.request) {
+  case "get":
+    getUrl(request.url);
+    break;
+  case "close":
+    //Doesn't re-focus the ChromeDriver.activePort on any tab.
+    chrome.tabs.remove(ChromeDriver.activeTabId);
+    ChromeDriver.isClosingTab = true;
+    break;
+  case "getCurrentWindowHandle":
+    //TODO(danielwh): Get window's handle, not frame's
+    var handle =
+        (ChromeDriver.activePort == null ? ChromeDriver.activePort.name : "");
+    sendResponseToParsedRequest({statusCode: 0, value:  handle}, false);
+    break;
+  case "getWindowHandles":
+    sendResponseToParsedRequest(getWindowHandles(), false);
+    break;
+  case "switchToDefaultContent":
+    switchToDefaultContent();
+    break;
+  case "switchToFrameByIndex":
+    switchToFrame(null, request.index);
+    break;
+  case "switchToFrameByName":
+    switchToFrame(request.name, null);
+    break;
+  case "switchToWindow":
+    ChromeDriver.hasHwnd = false;
+    if (request.windowName !== undefined) {
+      setActivePortByWindowName(request.windowName);
+    } else {
+      sendResponseToParsedRequest({
+        statusCode: 3,
+        value: {
+          message: 'Window to switch to was not given'
+        }
+      }, false);
+    }
+    break;
+  case "clickElement":
+  case "hoverOverElement":
+    // Falling through, as native events are handled the same
+  case "sendKeysToElement":
+    if (typeof(request.keys) == "object" && request.keys.length !== undefined) {
+      request.keys = request.keys.join("");
+    }
+    sendMessageOnActivePortAndAlsoKeepTrackOfIt(
+        wrapInjectEmbedIfNecessary(request));
+    break;
+  case "getCurrentUrl":
+  case "getTitle":
+    if (hasNoPage()) {
+      console.log("Not got a page, but asked for string, so sending empty string");
+      sendResponseToParsedRequest({statusCode: 0, value: ''});
+      break;
+    }
+    // Falling through, as if we do have a page, we want to treat this like a
+    // normal request
+  case "findElement":
+  case "findChildElement":
+    if (hasNoPage()) {
+      console.log("Not got a page, but asked for element, so throwing NoSuchElementException");
+      sendResponseToParsedRequest({statusCode: 7, value: {message: 'Was not on a page, so could not find elements'}});
+      break;
+    }
+    // Falling through, as if we do have a page, we want to treat this like a
+    // normal request
+  case "findElements":
+  case "findChildElements":
+    if (hasNoPage()) {
+      console.log("Not got a page, but asked for elements, so returning no elements");
+      sendResponseToParsedRequest({statusCode: 0, value: []});
+      break;
+    }
+  // Falling through, as if we do have a page, we want to treat this like a
+  // normal request
+  case "deleteAllCookies":
+  case "deleteCookie":
+    if (hasNoPage()) {
+      console.log("Not got a page, but asked to delete cookies, so returning ok");
+      sendResponseToParsedRequest({statusCode: 0});
+      break;
+    }
+  // Falling through, as if we do have a page, we want to treat this like a
+  // normal request
+  default:
+    var sequenceNumber = ChromeDriver.requestSequenceNumber;
+    ChromeDriver.requestSequenceNumber++;
+    sendMessageOnActivePortAndAlsoKeepTrackOfIt({
+      request: request,
+      sequenceNumber: sequenceNumber
+    });
+    break;
+  }
+}
+function sendMessageOnActivePortAndAlsoKeepTrackOfIt(message) {
+  ChromeDriver.lastRequestToBeSentWhichHasntBeenAnsweredYet = message.request;
+  try {
+    ChromeDriver.activePort.postMessage(message);
+  } catch (e) {
+    console.log("Tried to send request without an active port.  " +
+                "Request will retry when connected, but will hang until then.");
+  }
+}
+/**
+ * Parse messages coming in on the port (responses from the content script).
+ * @param message JSON message of format:
+ *                {response: "some command",
+ *                 value: {statusCode: STATUS_CODE
+ *                 [, optional params]}}
+ */
+function parsePortMessage(message) {
+  console.log(
+      "Received response from content script: " + JSON.stringify(message));
+  if (!message || !message.response || !message.response.value ||
+      message.response.value.statusCode === undefined ||
+      message.response.value.statusCode == null ||
+      message.sequenceNumber === undefined) {
+    // Should only ever happen if we sent a bad request,
+    // or the content script is broken
+    console.log("Got invalid response from the content script.");
+    return;
+  }
+  var toSend = {statusCode: 12};
+  ChromeDriver.lastRequestToBeSentWhichHasntBeenAnsweredYet = null;
+  switch (message.response.value.statusCode) {
+  // Error codes are loosely based on native exception codes, see
+  // common/src/cpp/webdriver-interactions/errorcodes.h
+  case 0:
+  case 2: //org.openqa.selenium.WebDriverException [Cookies]
+  case 3: //org.openqa.selenium.NoSuchWindowException
+  case 7: //org.openqa.selenium.NoSuchElementException
+  case 8: //org.openqa.selenium.NoSuchFrameException
+  case 9: //java.lang.UnsupportedOperationException [Unknown command]
+  case 10: //org.openqa.selenium.StaleElementReferenceException
+  case 11: //org.openqa.selenium.ElementNotVisibleException
+  case 12: //java.lang.UnsupportedOperationException [Invalid element state ]
+  case 17: //org.openqa.selenium.WebDriverException [Bad javascript]
+  case 19: //org.openqa.selenium.XPathLookupException
+  case 99: //org.openqa.selenium.WebDriverException [Native event]
+    toSend = {statusCode: message.response.value.statusCode, value: null};
+    if (message.response.value !== undefined && message.response.value != null &&
+        message.response.value.value !== undefined) {
+      toSend.value = message.response.value.value;
+    }
+    sendResponseToParsedRequest(toSend, message.response.wait);
+    break;
+  case "no-op":
+    //Some special operation which isn't sending HTTP
+    switch (message.response.response) {
+    case "clickElement":
+      try {
+        if (document.embeds[0].clickAt(message.response.value.x, message.response.value.y)) {
+          sendResponseToParsedRequest({statusCode: 0}, true);
+        } else {
+          sendResponseToParsedRequest({statusCode: 99}, true);
+        }
+      } catch(e) {
+        console.log("Error natively clicking.  Trying non-native.");
+        ChromeDriver.isBlockedWaitingForResponse = false;
+        parseRequest({
+          request: 'nonNativeClickElement',
+          elementId: message.response.value.elementId
+        });
+      }
+      break;
+    case "hoverElement":
+      try {
+        var points = message.response.value;
+        if (document.embeds[0].mouseMoveTo(15, points.oldX, points.oldY, points.newX, points.newY)) {
+          sendResponseToParsedRequest({statusCode: 0}, true);
+        } else {
+          sendResponseToParsedRequest({statusCode: 99}, true);
+        }
+      } catch(e) {
+        sendResponseToParsedRequest({statusCode: 99}, true);
+      }
+      break;
+    case "sendKeysToElement":
+      try {
+        if (document.embeds[0].sendKeys(message.response.value.keys)) {
+          sendResponseToParsedRequest({statusCode: 0}, true);
+        } else {
+          sendResponseToParsedRequest({statusCode: 99}, true);
+        }
+      } catch(e) {
+        console.log("Error natively sending keys.  Trying non-native.");
+        ChromeDriver.isBlockedWaitingForResponse = false;
+        parseRequest({
+          request: 'sendElementNonNativeKeys',
+          elementId: message.response.value.elementId,
+          keys: message.response.value.keys
+        });
+      }
+      break;
+    case "sniffForMetaRedirects":
+      if (!message.response.value.value &&
+          !ChromeDriver.hasSentResponseToThisPageLoading) {
+        ChromeDriver.urlBeingLoaded = null;
+        ChromeDriver.hasSentResponseToThisPageLoading = true;
+        switchToDefaultContent();
+      }
+      break;
+    case "newTabInformation":
+      var response = message.response.value;
+      for (var tab in ChromeDriver.tabs) {
+        //RACE CONDITION!!!
+        //This call should happen before another content script
+        //connects and returns this value,
+        //but if it doesn't, we may get mismatched information
+        if (ChromeDriver.tabs[tab].isFrameset === undefined) {
+          ChromeDriver.tabs[tab].isFrameset = response.isFrameset;
+          return;
+        } else {
+          for (var frame in ChromeDriver.tabs[tab].frames) {
+            var theFrame = ChromeDriver.tabs[tab].frames[frame];
+            if (theFrame.isFrameset === undefined) {
+              theFrame.isFrameset = response.isFrameset;
+              return;
+            }
+          }
+        }
+      }
+      break;
+    case "getFrameNameFromIndex":
+      var newName = message.response.value.name;
+      if (ChromeDriver.restOfCurrentFramePath.length != 0) {
+        newName += "." + ChromeDriver.restOfCurrentFramePath.join(".");
+      }
+      switchToFrameByName(newName);
+      break;
+    }
+    break;
+  }
+}
+/**
+ * If the plugin doesn't currently have an HWND for this page,
+ * we need to get one by injecting an embed
+ */
+function wrapInjectEmbedIfNecessary(requestObject) {
+  if (ChromeDriver.hasHwnd) {
+    var sequenceNumber = ChromeDriver.requestSequenceNumber;
+    ChromeDriver.requestSequenceNumber++;
+    return {
+      sequenceNumber: sequenceNumber,
+      request: requestObject
+    };
+  } else {
+    var wrappedObject = {
+      sequenceNumber: ChromeDriver.requestSequenceNumber,
+      request: {
+        request: "injectEmbed",
+        followup: {
+          sequenceNumber: ChromeDriver.requestSequenceNumber + 1,
+          request: requestObject
+        }
+      }
+    };
+    ChromeDriver.requestSequenceNumber += 2;
+    return wrappedObject;
+  }
+}
+/**
+ * Gets all current window handles
+ * @return an array containing all of the current window handles
+ */
+function getWindowHandles() {
+  var windowHandles = [];
+  for (var tab in ChromeDriver.tabs) {
+    windowHandles.push(ChromeDriver.tabs[tab].windowName);
+  }
+  return {statusCode: 0, value: windowHandles}
+}
+function resetActiveTabDetails() {
+  ChromeDriver.activePort = null;
+  ChromeDriver.hasHwnd = false;
+  ChromeDriver.activeTabId = null;
+  ChromeDriver.doFocusOnNextOpenedTab = true;
+  ChromeDriver.hasSentResponseToThisPageLoading = false;
+  ChromeDriver.portToUseForFrameLookups = null;
+  ChromeDriver.currentUrl = null;
+  resetCurrentlyWaitingOnContentScriptTime();
+}
+function setActiveTabDetails(tab) {
+  ChromeDriver.activeTabId = tab.id;
+  ChromeDriver.activeWindowId = tab.windowId;
+  ChromeDriver.doFocusOnNextOpenedTab = false;
+  ChromeDriver.currentUrl = tab.url;
+  resetCurrentlyWaitingOnContentScriptTime();
+}
+function switchToDefaultContent() {
+  ChromeDriver.hasHwnd = false;
+  for (var tab in ChromeDriver.tabs) {
+    if (ChromeDriver.tabs[tab].tabId == ChromeDriver.activeTabId) {
+      if (ChromeDriver.tabs[tab].isFrameset) {
+        ChromeDriver.isBlockedWaitingForResponse = false;
+        parseRequest({request: 'switchToFrameByIndex', index: 0});
+      } else {
+        ChromeDriver.activePort = ChromeDriver.tabs[tab].mainPort;
+        sendResponseToParsedRequest({statusCode: 0}, false);
+      }
+      return;
+    }
+  }
+}
+function switchToFrame(name, index) {
+  ChromeDriver.hasHwnd = false;
+  for (var tab in ChromeDriver.tabs) {
+    if (ChromeDriver.tabs[tab].tabId == ChromeDriver.activeTabId) {
+      ChromeDriver.portToUseForFrameLookups = ChromeDriver.tabs[tab].mainPort;
+      break;
+    }
+  }
+  if (name !== undefined && name != null) {
+    switchToFrameByName(name);
+  } else if (index !== undefined && index != null) {
+    getFrameNameFromIndex(index);
+  } else {
+    sendResponseToParsedRequest({
+      statusCode: 9,
+      value: {
+        message: "Switching frames other than by name or id is unsupported"
+      }
+    });
+  }
+}
+function switchToFrameByName(name) {
+  var names = name.split(".");
+  for (var tab in ChromeDriver.tabs) {
+    if (ChromeDriver.tabs[tab].tabId == ChromeDriver.activeTabId) {
+      var frame;
+      for (frame in ChromeDriver.tabs[tab].frames) {
+        // Maybe name was a fully qualified name, which perhaps just happened to
+        // include .s
+        if (ChromeDriver.tabs[tab].frames[frame].frameName == name) {
+          ChromeDriver.activePort =
+              ChromeDriver.tabs[tab].frames[frame].framePort;
+          ChromeDriver.restOfCurrentFramePath = [];
+          sendResponseToParsedRequest({statusCode: 0}, false);
+          return;
+        }
+      }
+      for (frame in ChromeDriver.tabs[tab].frames) {
+        // Maybe we're looking for a child, see if this is the parent of it
+        if (ChromeDriver.tabs[tab].frames[frame].frameName == names[0]) {
+          ChromeDriver.activePort =
+              ChromeDriver.tabs[tab].frames[frame].framePort;
+          ChromeDriver.portToUseForFrameLookups = ChromeDriver.activePort;
+          names.shift();
+          ChromeDriver.restOfCurrentFramePath = names;
+          if (names.length == 0) {
+            sendResponseToParsedRequest({statusCode: 0}, false);
+            return;
+          } else {
+            switchToFrameByName(names.join("."));
+            return;
+          }
+        }
+      }
+    }
+  }
+  //Maybe the "name" was actually an index? Let's find out...
+  var index = null;
+  try {
+    index = parseInt(names[0]);
+  } catch (e) {
+  }
+  if (!isNaN(index)) {
+    names.shift();
+    ChromeDriver.restOfCurrentFramePath = names;
+    getFrameNameFromIndex(index);
+    return;
+  }
+  ChromeDriver.isBlockedWaitingForResponse = false;
+  parseRequest({request: 'switchToNamedIFrameIfOneExists', name: name});
+}
+function getFrameNameFromIndex(index) {
+  var message = {
+    request: {
+      request: "getFrameNameFromIndex",
+      index: index
+    },
+    sequenceNumber: ChromeDriver.requestSequenceNumber
+  };
+  ChromeDriver.requestSequenceNumber++;
+  ChromeDriver.portToUseForFrameLookups.postMessage(message);
+}
+/**
+ * Closes the current tab if it exists, and opens a new one, in which it
+ * gets the URL passed
+ * @param url the URL to load
+ */
+function getUrl(url) {
+  ChromeDriver.urlBeingLoaded = url;
+  var tempActiveTagId = ChromeDriver.activeTabId;
+  if (url.indexOf("#") > -1 && ChromeDriver.currentUrl != null &&
+      ChromeDriver.currentUrl.split("#")[0] == url.split("#")[0]) {
+    ChromeDriver.isGettingUrlButOnlyChangingByFragment = true;
+  } else {
+    resetActiveTabDetails();
+  }
+  ChromeDriver.currentUrl = url;
+  if (tempActiveTagId == null) {
+    chrome.tabs.create({url: url, selected: true}, getUrlCallback);
+  } else {
+    ChromeDriver.activeTabId = tempActiveTagId;
+    if (ChromeDriver.isGettingUrlButOnlyChangingByFragment) {
+      chrome.tabs.update(ChromeDriver.activeTabId, {url: url, selected: true},
+          getUrlCallback);
+    } else {
+      // we need to create the new tab before deleting the old one
+      // in order to avoid hanging on OS X
+      var oldId = ChromeDriver.activeTabId;
+      resetActiveTabDetails();
+      chrome.tabs.create({url: url, selected: true}, getUrlCallback);
+      chrome.tabs.remove(oldId);
+    }
+  }
+}
+function getUrlCallback(tab) {
+  if (chrome.extension.lastError) {
+    // An error probably arose because Chrome didn't have a window yet
+    // (see crbug.com 19846)
+    // If we retry, we *should* be fine. Unless something really bad is
+    // happening, in which case we will probably hang indefinitely trying to
+    // reload the same URL
+    getUrl(ChromeDriver.urlBeingLoaded);
+    return;
+  }
+  if (tab == null) {
+    //chrome.tabs.update's callback doesn't pass a Tab argument,
+    //so we need to populate it ourselves
+    chrome.tabs.get(ChromeDriver.activeTabId, getUrlCallback);
+    return;
+  }
+  if (tab.status != "complete") {
+    // Use the helper calback so that we actually get updated version of the tab
+    // we're getting
+    setTimeout("getUrlCallbackById(" + tab.id + ")", 10);
+  } else {
+    ChromeDriver.getUrlRequestSequenceNumber++;
+    if (ChromeDriver.activePort == null) {
+      if (ChromeDriver.currentlyWaitingUntilGiveUpOnContentScriptLoading <= 0) {
+        ChromeDriver.hasNoConnectionToPage = true;
+        sendEmptyResponseWhenTabIsLoaded(tab);
+      } else {
+        ChromeDriver.currentlyWaitingUntilGiveUpOnContentScriptLoading -=
+          ChromeDriver.waitForContentScriptIncrement;
+        setTimeout("getUrlCallbackById(" + tab.id + ")", ChromeDriver.waitForContentScriptIncrement);
+        return;
+      }
+    }
+    setActiveTabDetails(tab);
+  }
+  if (ChromeDriver.isGettingUrlButOnlyChangingByFragment) {
+    ChromeDriver.urlBeingLoaded = null;
+    resetCurrentlyWaitingOnContentScriptTime();
+    sendResponseToParsedRequest({statusCode: 0}, false);
+    ChromeDriver.isGettingUrlButOnlyChangingByFragment = false;
+  }
+}
+function getUrlCallbackById(tabId) {
+  chrome.tabs.get(tabId, getUrlCallback);
+}
+function sendEmptyResponseWhenTabIsLoaded(tab) {
+  if (tab.status == "complete") {
+    if (ChromeDriver.activePort) {
+      ChromeDriver.isBlockedWaitingForResponse = false;
+      parseRequest({request: 'sniffForMetaRedirects'});
+    } else {
+      if (!ChromeDriver.hasSentResponseToThisPageLoading) {
+        ChromeDriver.urlBeingLoaded = null;
+        sendResponseToParsedRequest({statusCode: 0}, false);
+      }
+    }
+  } else {
+    chrome.tabs.get(tab.id, sendEmptyResponseWhenTabIsLoaded);
+  }
+}
+function setToolstripsBusy(busy) {
+  var toolstrips = chrome.extension.getToolstrips(ChromeDriver.activeWindowId);
+  for (var toolstrip in toolstrips) {
+    if (toolstrips[toolstrip].setWebdriverToolstripBusy &&
+        toolstrips[toolstrip].setWebdriverToolstripFree) {
+      if (busy) {
+        toolstrips[toolstrip].setWebdriverToolstripBusy();
+      } else {
+        toolstrips[toolstrip].setWebdriverToolstripFree();
+      }
+    }
+  }
+}
+function setActivePortByWindowName(handle) {
+  for (var tab in ChromeDriver.tabs) {
+    if (ChromeDriver.tabs[tab].windowName == handle ||
+        ChromeDriver.tabs[tab].mainPort.name == handle) {
+      ChromeDriver.activePort = ChromeDriver.tabs[tab].mainPort;
+      chrome.tabs.get(ChromeDriver.tabs[tab].tabId, setActiveTabDetails);
+      chrome.tabs.update(ChromeDriver.tabs[tab].tabId, {selected: true});
+      sendResponseToParsedRequest({statusCode: 0}, false);
+      return;
+    }
+  }
+  sendResponseToParsedRequest({statusCode: 3, value: {message: 'Could not find window to switch to by handle: ' + handle}}, false);
+}
+/**
+ * @return {boolean} Whether there is currently no active page.
+ */
+function hasNoPage() {
+  return ChromeDriver.hasNoConnectionToPage ||
+         ChromeDriver.activePort == null ||
+         ChromeDriver.activeTabId == null;
+}
+function resetCurrentlyWaitingOnContentScriptTime() {
+  ChromeDriver.currentlyWaitingUntilGiveUpOnContentScriptLoading =
+      ChromeDriver.timeoutUntilGiveUpOnContentScriptLoading;
+}