rainux-selenium-webdriver 0.0.17

data/firefox/src/extension/components/promptService.js

@@ -0,0 +1,208 @@
+// Spoof the prompt service. Interesting thread on mozillazine:
+// http://www.mail-archive.com/dev-tech-xpcom@lists.mozilla.org/msg00193.html
+
+const CC = Components.classes;
+const CI = Components.interfaces;
+
+const CONSOLE = CC["@mozilla.org/consoleservice;1"].getService(CI["nsIConsoleService"]);
+
+function dumpn(message) {
+  try {
+    CONSOLE.logStringMessage(message + "\n");
+  } catch (e) {
+    dump(message + "\n");
+  }
+}
+
+// Spoof implementation
+function DrivenPromptService() {
+  // as defined in nsPromptService.h
+  var ORIGINAL_PARENT_SERVICE_ID = "{A2112D6A-0E28-421f-B46A-25C0B308CBD0}";
+
+  // Keep a reference to the original service
+  var originalService = Components.classesByID[ORIGINAL_PARENT_SERVICE_ID].getService();
+
+  this.originalPromptService_ =
+  originalService.QueryInterface(Components.interfaces.nsIPromptService);
+
+  dumpn("Spoofing prompt service");
+}
+
+// Constants from nsIPromtService.idl
+DrivenPromptService.prototype = {
+  BUTTON_POS_0: 1,
+  BUTTON_POS_1: 256,
+  BUTTON_POS_2: 65536,
+
+  // Button Title Flags (used to set the labels of buttons in the prompt)
+  BUTTON_TITLE_OK: 1,
+  BUTTON_TITLE_CANCEL: 2,
+  BUTTON_TITLE_YES: 3,
+  BUTTON_TITLE_NO: 4,
+  BUTTON_TITLE_SAVE: 5,
+  BUTTON_TITLE_DONT_SAVE: 6,
+  BUTTON_TITLE_REVERT: 7,
+  BUTTON_TITLE_IS_STRING: 127,
+
+  // Button Default Flags (used to select which button is the default one)
+  BUTTON_POS_0_DEFAULT: 0,
+  BUTTON_POS_1_DEFAULT: 16777216,
+  BUTTON_POS_2_DEFAULT: 33554432,
+
+  // Causes the buttons to be initially disabled.  They are enabled after a
+  // timeout expires.  The implementation may interpret this loosely as the
+  // intent is to ensure that the user does not click through a security dialog
+  // too quickly.  Strictly speaking, the implementation could choose to ignore
+  // this flag.
+  BUTTON_DELAY_ENABLE: 67108864,
+
+  // Selects the standard set of OK/Cancel buttons.
+  STD_OK_CANCEL_BUTTONS: (this.BUTTON_TITLE_OK * this.BUTTON_POS_0) + (this.BUTTON_TITLE_CANCEL
+      * this.BUTTON_POS_1),
+
+  // Selects the standard set of Yes/No buttons.
+  STD_YES_NO_BUTTONS: (this.BUTTON_TITLE_YES * this.BUTTON_POS_0) + (this.BUTTON_TITLE_NO
+      * this.BUTTON_POS_1)
+};
+
+DrivenPromptService.prototype.findAssociatedDriver_ = function(window) {
+  var ww = CC["@mozilla.org/embedcomp/window-watcher;1"].getService(CI["nsIWindowWatcher"]);
+
+  // There might be an easy answer.
+  var win = ww.getChromeForWindow(window);
+  if (win) {
+    return win;
+  }
+
+  // There isn't. Grab the top window's default view
+  var parent = window ? window : ww.activeWindow;
+  if (parent.wrappedJSObject)
+    parent = parent.wrappedJSObject;
+  var top = parent.top;
+
+  // Now iterate over all open browsers to find the one we belong to
+  var wm = CC["@mozilla.org/appshell/window-mediator;1"].getService(CI["nsIWindowMediator"]);
+  var allWindows = wm.getEnumerator("navigator:browser");
+  while (allWindows.hasMoreElements()) {
+    var chrome = allWindows.getNext().QueryInterface(CI.nsIDOMWindow);
+    if (chrome.content == window) {
+      return chrome.fxdriver;
+    }
+  }
+
+  // There's no meaningful way we can reach this.
+  return undefined;
+};
+
+DrivenPromptService.prototype.alert = function(aParent, aDialogTitle, aText) {
+  // Try to grab the top level window
+  var driver = this.findAssociatedDriver_(aParent);
+
+  if (driver && driver.response_) {
+    var res = driver.response_;
+    // TODO(simon): We can't rely on the normal JSON library here because it might not be available
+    //              Come up with a cleaner way of doing this.
+    var json = "{ title: \"" + aDialogTitle + "\", text: \"" + aText + "\", __webdriverType: 'alert' }";
+
+    res.response = json;
+    res.send();
+  } else {
+    // TODO(simon): we should prevent the next command from blocking.
+  }
+
+  return this.originalPromptService_.alert(aParent, aDialogTitle, aText);
+};
+
+DrivenPromptService.prototype.alertCheck =
+function(aParent, aDialogTitle, aText, aCheckMsg, aCheckState) {
+  return this.originalPromptService_.alertCheck(aParent, aDialogTitle, aText, aCheckMsg, aCheckState);
+};
+
+DrivenPromptService.prototype.confirm = function(aParent, aDialogTitle, aText) {
+  return this.originalPromptService_.confirm(aParent, aDialogTitle, aText);
+};
+
+DrivenPromptService.prototype.confirmCheck =
+function(aParent, aDialogTitle, aText, aCheckMsg, aCheckState) {
+  return this.originalPromptService_.confirmCheck(aParent, aDialogTitle, aText, aCheckMsg, aCheckState);
+};
+
+DrivenPromptService.prototype.confirmEx =
+function(aParent, aDialogTitle, aText, aButtonFlags, aButton0Title, aButton1Title, aButton2Title, aCheckMsg, aCheckState) {
+  return this.originalPromptService_.confirmEx(aParent, aDialogTitle, aText, aButtonFlags, aButton0Title, aButton1Title, aButton2Title, aCheckMsg, aCheckState);
+};
+
+DrivenPromptService.prototype.prompt =
+function(aParent, aDialogTitle, aText, aValue, aCheckMsg, aCheckState) {
+  return this.originalPromptService_.prompt(aParent, aDialogTitle, aText, aValue, aCheckMsg, aCheckState);
+};
+
+DrivenPromptService.prototype.promptUsernameAndPassword =
+function(aParent, aDialogTitle, aText, aUsername, aPassword, aCheckMsg, aCheckState) {
+  return this.originalPromptService_.promptUsernameAndPassword(aParent, aDialogTitle, aText, aUsername, aPassword, aCheckMsg, aCheckState);
+};
+
+DrivenPromptService.prototype.promptPassword =
+function(aParent, aDialogTitle, aText, aPassword, aCheckMsg, aCheckState) {
+  return this.originalPromptService_.promptPassword(aParent, aDialogTitle, aText, aPassword, aCheckMsg, aCheckState);
+};
+
+DrivenPromptService.prototype.select =
+function(aParent, aDialogTitle, aText, aCount, aSelectList, aOutSelection) {
+  return this.originalPromptService_.select(aParent, aDialogTitle, aText, aCount, aSelectList, aOutSelection);
+};
+
+const PROMPT_CONTRACT_ID = "@mozilla.org/embedcomp/prompt-service;1";
+const DRIVEN_PROMPT_SERVICE_CLASS_ID = Components.ID('{e26dbdcd-d3ba-4ded-88c3-6cb07ee3e9e0}');
+
+var service = undefined;
+
+var PromptServiceSpoofFactory = {
+  createInstance: function (aOuter, aIID) {
+    if (aOuter != null)
+      throw Components.results.NS_ERROR_NO_AGGREGATION;
+    if (service == undefined) {
+      service = new DrivenPromptService();
+    }
+    return service;
+  }
+};
+
+function PromptServiceSpoofModule() {
+  this.firstTime_ = true;
+}
+
+PromptServiceSpoofModule.prototype.registerSelf = function(aCompMgr, aFileSpec, aLocation, aType) {
+  if (this.firstTime_) {
+    this.firstTime_ = false;
+    throw Components.results.NS_ERROR_FACTORY_REGISTER_AGAIN;
+  }
+  aCompMgr = aCompMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
+  aCompMgr.registerFactoryLocation(
+      DRIVEN_PROMPT_SERVICE_CLASS_ID, "Driven prompt service", PROMPT_CONTRACT_ID, aFileSpec, aLocation, aType);
+};
+
+PromptServiceSpoofModule.prototype.unregisterSelf = function(aCompMgr, aLocation, aType) {
+  dumpn("Unregistering\n");
+  aCompMgr =
+  aCompMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
+  aCompMgr.unregisterFactoryLocation(DRIVEN_PROMPT_SERVICE_CLASS_ID, aLocation);
+};
+
+PromptServiceSpoofModule.prototype.getClassObject = function(aCompMgr, aCID, aIID) {
+  if (!aIID.equals(Components.interfaces.nsIFactory))
+    throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
+
+  if (aCID.equals(DRIVEN_PROMPT_SERVICE_CLASS_ID))
+    return PromptServiceSpoofFactory;
+
+  throw Components.results.NS_ERROR_NO_INTERFACE;
+};
+
+PromptServiceSpoofModule.prototype.canUnload = function(aCompMgr) {
+  return true;
+};
+
+function NSGetModule(comMgr, fileSpec) {
+  return new PromptServiceSpoofModule();
+}

data/firefox/src/extension/components/screenshooter.js

@@ -0,0 +1,81 @@
+/*
+ Copyright 2007-2009 WebDriver committers
+ Copyright 2007-2009 Google Inc.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+
+function Screenshooter() {
+}
+
+
+Screenshooter.grab = function(window) {
+  var document = window.document;
+  var documentElement = document.documentElement;
+  var canvas = document.getElementById('fxdriver-screenshot-canvas');
+  if (canvas == null) {
+    canvas = document.createElement('canvas');
+    canvas.id = 'fxdriver-screenshot-canvas';
+    canvas.style.display = 'none';
+    documentElement.appendChild(canvas);
+  }
+  var width =
+      Math.max(documentElement.scrollWidth, document.body.scrollWidth);
+  var height =
+      Math.max(documentElement.scrollHeight, document.body.scrollHeight);
+  canvas.width = width;
+  canvas.height = height;
+  var context = canvas.getContext('2d');
+  context.drawWindow(window, 0, 0, width, height, 'rgb(255,255,255)');
+  return canvas;
+};
+
+
+Screenshooter.toBase64 = function(canvas) {
+  var dataUrl = canvas.toDataURL('image/png');
+  var index = dataUrl.indexOf('base64,');
+  if (index == -1) {
+    // No base64 data marker.
+    throw new Error("Invalid base64 data: " + dataUrl);
+  }
+  return dataUrl.substring(index + 'base64,'.length);
+};
+
+
+Screenshooter.save = function(canvas, filepath) {
+  var cc = Components.classes;
+  var ci = Components.interfaces;
+  var dataUrl = canvas.toDataURL('image/png');
+  var ioService = cc['@mozilla.org/network/io-service;1'].
+      getService(ci.nsIIOService);
+  var dataUri = ioService.newURI(dataUrl, 'UTF-8', null);
+  var channel = ioService.newChannelFromURI(dataUri);
+  var file = cc['@mozilla.org/file/local;1'].createInstance(ci.nsILocalFile);
+  file.initWithPath(filepath);
+  var inputStream = channel.open();
+  var binaryInputStream = cc['@mozilla.org/binaryinputstream;1'].
+      createInstance(ci.nsIBinaryInputStream);
+  binaryInputStream.setInputStream(inputStream);
+  var fileOutputStream = cc['@mozilla.org/network/safe-file-output-stream;1'].
+      createInstance(ci.nsIFileOutputStream);
+  fileOutputStream.init(file, -1, -1, null);
+  var n = binaryInputStream.available();
+  var bytes = binaryInputStream.readBytes(n);
+  fileOutputStream.write(bytes, n);
+  if (fileOutputStream instanceof ci.nsISafeOutputStream) {
+    fileOutputStream.finish();
+  } else {
+    fileOutputStream.close();
+  }
+};

data/firefox/src/extension/components/socketListener.js

@@ -0,0 +1,185 @@
+/*
+ Copyright 2007-2009 WebDriver committers
+ Copyright 2007-2009 Google Inc.
+ Portions copyright 2007 ThoughtWorks, Inc
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+/**
+ * @fileoverview Defines a class that reads commands from a socket and
+ * dispatches them to the nsICommandProcessor. When the response is ready, it is
+ * serialized and sent back to the client through the socket.
+ */
+
+
+/**
+ * Communicates with a client by reading and writing from a socket.
+ * @param {nsISocketTransport} transport The connected socket transport.
+ * @constructor
+ * @extends {nsIStreamListener}
+ */
+function SocketListener(transport) {
+  this.outstream = transport.
+      openOutputStream(Components.interfaces.nsITransport.OPEN_BLOCKING, 0, 0);
+
+  this.stream = transport.openInputStream(0, 0, 0);
+  var cin = Components.classes["@mozilla.org/intl/converter-input-stream;1"].
+      createInstance(Components.interfaces.nsIConverterInputStream);
+  cin.init(this.stream, SocketListener.CHARSET, 0, 0x0000);
+
+  this.inputStream = cin;
+
+  var pump = Components.classes["@mozilla.org/network/input-stream-pump;1"].
+      createInstance(Components.interfaces.nsIInputStreamPump);
+  pump.init(this.stream, -1, -1, 0, 0, false);
+  pump.asyncRead(this, null);
+
+  this.linesLeft = "";
+  this.data = "";
+  this.command = "";
+  this.step = 0;
+  this.readLength = false;
+
+  /**
+   * A reference to the command processor service. We grab the reference here
+   * instead of on the prototype since the component may not be loaded yet.
+   * @type {nsICommandProcessor}
+   * @private
+   */
+  this.commandProcessor_ = Components.
+      classes['@googlecode.com/webdriver/command-processor;1'].
+      getService(Components.interfaces.nsICommandProcessor);
+
+  /**
+   * The converter used when writing data back to the socket.
+   * @type {nsIScriptableUnicodeConverter}
+   * @private
+   */
+  this.converter_ = Components.
+      classes['@mozilla.org/intl/scriptableunicodeconverter'].
+      createInstance(Components.interfaces.nsIScriptableUnicodeConverter);
+
+  this.converter_.charset = SocketListener.CHARSET;
+}
+
+
+/**
+ * Charset used for socket I/O.
+ * @type {string}
+ */
+SocketListener.CHARSET = 'UTF-8';
+
+
+/**
+ * Signals the start of a request. Each request lasts for the life of the
+ * underlying socket connection and represents a session with a FirefoxDriver
+ * client. 
+ * @see {nsIRequestObserver#onStartRequest}
+ */
+SocketListener.prototype.onStartRequest = function(request, context) {
+};
+
+
+/**
+ * Signals the end of a request (e.g. the underlying socket connection was
+ * closed).
+ * @see {nsIRequestObserver#onStopRequest}
+ */
+SocketListener.prototype.onStopRequest = function(request, context, status) {
+};
+
+
+/**
+ * Called whenever another chunk of data is ready to be read from the socket.
+ * @param {nsIRequest} request The data's origin.
+ * @param {nsISupports} context User defined context.
+ * @param {nsIInputStream} inputStream The input stream containing the data
+ *     chunk.
+ * @param {number} offset The total number of bytes read by previous calls to
+ *     {@code #onDataAvailable}.
+ * @param {number} count The number of bytes available in the stream.
+ * @see {nsIStreamListener#onDataAvailable}
+ */
+SocketListener.prototype.onDataAvailable = function(request, context,
+                                                    inputStream, offset,
+                                                    count) {
+  var incoming = {};
+  var read = this.inputStream.readString(count, incoming);
+
+  var lines = incoming.value.split('\n');
+  for (var j = 0; j < lines.length; j++) {
+    if (0 == this.step) {
+      var head = lines[j].split(": ", 2);
+      if (head[0] == "Content-Length") {
+        this.linesLeft = Number(head[1]);
+        this.readLength = true;
+      } else if (lines[j].length == 0 && this.readLength) {
+        this.step++;
+      }
+    } else {
+      this.data += lines[j];
+      this.linesLeft -= read;
+
+      if (this.linesLeft <= 0) {
+        this.executeCommand_();
+        j++;  // Consume the empty line
+      }
+    }
+  }
+
+  if (this.linesLeft <= 0 && this.data) {
+    this.executeCommand_();
+  }
+};
+
+
+/**
+ * Parses the command data read from the socket into a JSON object and
+ * dispatches it to the command processesor.
+ * @private
+ */
+SocketListener.prototype.executeCommand_ = function() {
+  var self = this;
+  var command = this.data;
+  var callback = function(response) {
+    //Utils.dumpn('writing to socket:\n' + response);
+    var data = self.converter_.convertToByteArray(response, {});
+    var header = "Length: " + data.length + "\n\n";
+    self.outstream.write(header, header.length);
+    self.outstream.flush();
+
+    var stream = self.converter_.convertToInputStream(response);
+    self.outstream.writeFrom(stream, data.length);
+    self.outstream.flush();
+    stream.close();
+  };
+
+  // Clear data for the next read.
+  this.data = '';
+  this.linesLeft = 0;
+  this.step = 0;
+  this.readLength = 0;
+
+  try {
+    this.commandProcessor_.execute(command, callback);
+  } catch (e) {
+    Utils.dump(e);
+    Utils.dumpn(command);
+
+    // Something has gone seriously wrong. Quit the browser.
+    this.commandProcessor_.execute(
+        JSON.stringify({'commandName': 'quit'}),
+        function() {});
+  }
+};