rainux-selenium-webdriver 0.0.17

data/firefox/src/extension/content/fxdriver.xul

@@ -0,0 +1,30 @@
+<?xml version="1.0"?>
+
+<!--
+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.
+-->
+
+<overlay id="fxdriver-overlay" xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+    <script src="dommessenger.js" />
+    <script src="server.js" />
+    <statusbar id="status-bar">
+        <statusbarpanel>
+            <hbox>
+                <label id="fxdriver-label" value="WebDriver" tooltiptext="This Firefox can be remote controlled with WebDriver." />
+            </hbox>
+        </statusbarpanel>
+    </statusbar>
+</overlay>

data/firefox/src/extension/content/server.js

@@ -0,0 +1,95 @@
+/*
+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.
+*/
+
+var driver = false;
+var domMessenger = null;
+
+// This will configure a FirefoxDriver and DomMessenger for each
+// _browser window_ (not chrome window). Multiple tabs in the same window will
+// share a FirefoxDriver and DomMessenger instance.
+window.addEventListener("load", function(e) {
+    handle = Components.classes["@googlecode.com/webdriver/fxdriver;1"].createInstance(Components.interfaces.nsISupports);
+    var server = handle.wrappedJSObject;
+
+  if (!domMessenger) {
+    var appcontent = document.getElementById('appcontent');
+    if (appcontent) {
+      try {
+        var commandProcessor = Components.
+            classes['@googlecode.com/webdriver/command-processor;1'].
+            getService(Components.interfaces.nsICommandProcessor);
+        domMessenger = new DomMessenger(commandProcessor);
+        appcontent.addEventListener('DOMContentLoaded',
+            function(e) {
+              domMessenger.onPageLoad(e);
+            }, true);
+        appcontent.addEventListener('pagehide',
+            function(e) {
+              domMessenger.onPageUnload(e);
+            }, true);
+      } catch (ex) {
+        // Not catching this can really mess things up and lead to inexplicable
+        // and hard to debug behavior.
+        Components.utils.reportError(ex);
+      }
+    }
+  }
+
+    if (!driver) {
+        driver = server.newDriver(window);
+    } else {
+        if (window.content)
+            var frames = window.content.frames;
+
+        // If we are already focused on a frame, try and stay focused
+        if (driver.context.frameId !== undefined && frames) {
+            if (frames && frames.length > driver.context.frameId) {
+                // do nothing
+            } else {
+                if (frames && frames.length && "FRAME" == frames[0].frameElement.tagName) {
+                    if (!frames[driver.context.frameId]) {
+                        driver.context.frameId = 0;
+                    }
+                } else {
+                    driver.context.frameId = undefined;
+                }
+
+            }
+        } else {
+            // Other use a sensible default
+            if (frames && frames.length && "FRAME" == frames[0].frameElement.tagName) {
+                if (!frames[driver.context.frameId]) {
+                    driver.context.frameId = 0;
+                }
+            } else {
+                driver.context.frameId = undefined;
+            }
+        }
+    }
+    
+    server.startListening();
+
+}, true);
+
+//window.addEventListener("focus", function(e) {
+//    var active = e.originalTarget;
+//    var doc = gBrowser.selectedBrowser.contentDocument;
+//    if (active.ownerDocument == doc) {
+//        driver.activeElement = active;
+//    }
+//}, true);

data/firefox/src/extension/idl/nsICommandProcessor.idl

@@ -0,0 +1,38 @@
+/*
+ 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.
+ */
+
+#include "nsISupports.idl"
+#include "nsIResponseHandler.idl"
+
+/**
+ * Defines a single method for executing commands specified as a JSON string.
+ */
+[scriptable, uuid(4427729b-441e-47c3-8380-df0350cac636)]
+interface nsICommandProcessor : nsISupports {
+
+  /**
+   * Executes the given command specified in a JSON string. When the command
+   * is fully processed, the response will be sent to the given
+   * {@code nsIResponseHandler} callback as a JSON string.
+   *
+   * @param jsonCommandString The command to execute, specified in JSON format.
+   * @param responseHandler The callback to send the command response to.
+   */
+  void execute(in AUTF8String jsonCommandString,
+               in nsIResponseHandler responseHandler);
+};

data/firefox/src/extension/idl/nsIResponseHandler.idl

@@ -0,0 +1,34 @@
+/*
+ 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.
+ */
+
+#include "nsISupports.idl"
+
+/**
+ * Defines a callback used to process the response to a command sent to the
+ * {@code nsICommandProcessor}.
+ */
+[scriptable, function, uuid(0539a68f-b4a8-4543-bf2a-031cef89aff1)]
+interface nsIResponseHandler : nsISupports {
+
+  /**
+   * Handle a response from the {@code nsICommandProcessor}.
+   *
+   * @param jsonResponseString The command response as a string.
+   */
+  void handleResponse(in AUTF8String jsonResponseString);
+};

data/firefox/src/extension/install.rdf

@@ -0,0 +1,29 @@
+<?xml version="1.0"?>
+<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#">
+
+    <Description about="urn:mozilla:install-manifest">
+        <em:id>fxdriver@googlecode.com</em:id>
+        <em:name>Firefox WebDriver</em:name>
+        <em:version>2.0a2</em:version>
+        <em:description>WebDriver implementation for Firefox</em:description>
+        <em:creator>Simon Stewart</em:creator>
+
+        <!-- Firefox -->
+        <em:targetApplication>
+            <Description>
+                <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>
+                <em:minVersion>2.0</em:minVersion>
+                <em:maxVersion>3.*</em:maxVersion>
+            </Description>
+        </em:targetApplication>
+
+        <!-- Platforms where we're not compiling the native events -->
+        <em:targetPlatform>Darwin</em:targetPlatform>
+        <em:targetPlatform>Linux</em:targetPlatform>
+        <!-- Platforms where we are -->
+        <em:targetPlatform>WINNT_x86-msvc</em:targetPlatform>
+
+        <!-- We're probably missing lots of platforms here -->
+    </Description>
+
+</RDF>

data/firefox/src/rb/lib/selenium/webdriver/firefox.rb

@@ -0,0 +1,31 @@
+require "timeout"
+require "socket"
+
+require "selenium/webdriver/firefox/util"
+require "selenium/webdriver/firefox/binary"
+require "selenium/webdriver/firefox/profiles_ini"
+require "selenium/webdriver/firefox/profile"
+require "selenium/webdriver/firefox/extension_connection"
+require "selenium/webdriver/firefox/launcher"
+require "selenium/webdriver/firefox/bridge"
+
+module Selenium
+  module WebDriver
+    module Firefox
+
+       DEFAULT_PROFILE_NAME         = "WebDriver".freeze
+       DEFAULT_PORT                 = 7055
+       DEFAULT_ENABLE_NATIVE_EVENTS = [:windows, :linux].include? Platform.os
+       DEFAULT_SECURE_SSL           = false
+       DEFAULT_LOAD_NO_FOCUS_LIB    = Platform.os == :linux
+
+    end
+  end
+end
+
+
+# SocketError was added in Ruby 1.8.7.
+# If it's not defined, we add it here so it can be used in rescues.
+unless defined? SocketError
+  class SocketError < IOError; end
+end

data/firefox/src/rb/lib/selenium/webdriver/firefox/binary.rb

@@ -0,0 +1,107 @@
+module Selenium
+  module WebDriver
+    module Firefox
+      class Binary
+
+        def initialize
+          ENV['MOZ_NO_REMOTE'] = '1' # able to launch multiple instances
+          check_binary_exists
+        end
+
+        def create_base_profile(name)
+          execute("-CreateProfile", name)
+
+          status = nil
+          Timeout.timeout(15, Error::TimeOutError) do
+            _, status = wait
+          end
+
+
+          if status && status.to_i != 0
+            raise Error::WebDriverError, "could not create base profile: (exit status: #{status})"
+          end
+        end
+
+        def start_with(profile, *args)
+          ENV['XRE_PROFILE_PATH'] = profile.absolute_path
+          execute(*args)
+          cope_with_mac_strangeness(args) if Platform.mac?
+        end
+
+        def execute(*extra_args)
+          args = [path, "-no-remote", "--verbose"] + extra_args
+          @process = ChildProcess.new(*args).start
+        end
+
+        def cope_with_mac_strangeness(args)
+          sleep 0.3
+
+          if @process.ugly_death?
+            # process crashed, trying a restart. sleeping 5 seconds shorter than the java driver
+            sleep 5
+            execute(*args)
+          end
+
+          # ensure we're ok
+          sleep 0.3
+          if @process.ugly_death?
+            raise Error::WebDriverError, "unable to start Firefox cleanly, args: #{args.inspect}"
+          end
+        end
+
+        def kill
+          @process.kill if @process
+        end
+
+        def wait
+          @process.wait if @process
+        end
+
+        def pid
+          @process.pid if @process
+        end
+
+        private
+
+        def path
+          @path ||= case Platform.os
+                    when :macosx
+                      "/Applications/Firefox.app/Contents/MacOS/firefox-bin"
+                    when :windows
+                      windows_path
+                    when :linux, :unix
+                      "/usr/bin/firefox"
+                    else
+                      raise "Unknown platform: #{Platform.os}"
+                    end
+        end
+
+        def check_binary_exists
+          unless File.file?(path)
+            raise Error::WebDriverError, "Could not find Firefox binary. Make sure Firefox is installed (OS: #{Platform.os})"
+          end
+        end
+
+        def windows_path
+          windows_registry_path || (ENV['PROGRAMFILES'] || "\\Program Files") + "\\Mozilla Firefox\\firefox.exe"
+        end
+
+        def windows_registry_path
+          return if Platform.jruby? || Platform.ironruby?
+          require "win32/registry"
+
+          lm = Win32::Registry::HKEY_LOCAL_MACHINE
+          lm.open("SOFTWARE\\Mozilla\\Mozilla Firefox") do |reg|
+            main = lm.open("SOFTWARE\\Mozilla\\Mozilla Firefox\\#{reg.keys[0]}\\Main")
+            if entry = main.find {|key, type, data| key =~ /pathtoexe/i}
+              return entry.last
+            end
+          end
+        rescue Win32::Registry::Error
+          raise Error::WebDriverError, "Firefox not found in Windows registry, please make sure you have it installed."
+        end
+
+      end # Binary
+    end # Firefox
+  end # WebDriver
+end # Selenium

data/firefox/src/rb/lib/selenium/webdriver/firefox/bridge.rb

@@ -0,0 +1,484 @@
+module Selenium
+  module WebDriver
+    module Firefox
+      class Bridge
+        include BridgeHelper
+
+        def initialize(opts = {})
+          @binary     = Binary.new
+          @launcher   = Launcher.new(
+            @binary,
+            opts.delete(:port)    || DEFAULT_PORT,
+            opts.delete(:profile) || DEFAULT_PROFILE_NAME
+          )
+
+          unless opts.empty?
+            raise ArgumentError, "unknown option#{'s' if opts.size != 1}: #{opts.inspect}"
+          end
+
+          @launcher.launch
+          @connection = @launcher.connection
+          @context    = newSession
+        end
+
+        def browser
+          :firefox
+        end
+
+        def driver_extensions
+          [DriverExtensions::TakesScreenshot]
+        end
+
+        def quit
+          @connection.quit
+          @binary.wait rescue nil # might raise on windows
+
+          nil
+        end
+
+        def getPageSource
+          execute :getPageSource
+        end
+
+        def refresh
+          execute :refresh
+        end
+
+        def getWindowHandles
+          execute :getWindowHandles
+        end
+
+        def getCurrentWindowHandle
+          execute :getCurrentWindowHandle
+        end
+
+        def getScreenshotAsBase64
+          execute :getScreenshotAsBase64
+        end
+
+        def get(url)
+          execute :get,
+                  :parameters => [url]
+        end
+
+        def close
+          execute :close
+        # TODO: rescue ?
+        end
+
+        def goBack
+          execute :goBack
+        end
+
+        def goForward
+          execute :goForward
+        end
+
+        def getCurrentUrl
+          execute :getCurrentUrl
+        end
+
+        def getTitle
+          execute :title
+        end
+
+        def executeScript(string, *args)
+          typed_args = args.map { |e| wrap_script_argument(e) }
+
+          resp = raw_execute :executeScript, :parameters => [string, typed_args]
+          raise TypeError, "expected Hash" unless resp.kind_of? Hash
+
+          unwrap_script_argument resp["response"]
+        end
+
+        #
+        # Finders - TODO: should be shared with Chrome::Bridge
+        #
+
+        def findElementByClassName(parent, class_name)
+          find_element_by 'class name', class_name, parent
+        end
+
+        def findElementsByClassName(parent, class_name)
+          find_elements_by 'class name', class_name, parent
+        end
+
+        def findElementById(parent, id)
+          find_element_by 'id', id, parent
+        end
+
+        def findElementsById(parent, id)
+          find_elements_by 'id', id, parent
+        end
+
+        def findElementByLinkText(parent, link_text)
+          find_element_by 'link text', link_text, parent
+        end
+
+        def findElementsByLinkText(parent, link_text)
+          find_elements_by 'link text', link_text, parent
+        end
+
+        def findElementByPartialLinkText(parent, link_text)
+          find_element_by 'partial link text', link_text, parent
+        end
+
+        def findElementsByPartialLinkText(parent, link_text)
+          find_elements_by 'partial link text', link_text, parent
+        end
+
+        def findElementByName(parent, name)
+          find_element_by 'name', name, parent
+        end
+
+        def findElementsByName(parent, name)
+          find_elements_by 'name', name, parent
+        end
+
+        def findElementByTagName(parent, tag_name)
+          find_element_by 'tag name', tag_name, parent
+        end
+
+        def findElementsByTagName(parent, tag_name)
+          find_elements_by 'tag name', tag_name, parent
+        end
+
+        def findElementByXpath(parent, xpath)
+          find_element_by 'xpath', xpath, parent
+        end
+
+        def findElementsByXpath(parent, xpath)
+          find_elements_by 'xpath', xpath, parent
+        end
+
+        def findElementByCssSelector(parent, selector)
+          find_element_by 'css selector', selector, parent
+        end
+
+        def findElementsByCssSelector(parent, selector)
+          find_elements_by 'css selector', selector, parent
+        end
+
+        def findElementByJsExpr(parent, js_expr)
+          find_element_by 'js expr', js_expr, parent
+        end
+
+        def findElementsByJsExpr(parent, js_expr)
+          find_elements_by 'js expr', js_expr, parent
+        end
+
+        def findElementByJavascript(parent, javascript)
+          find_element_by 'javascript', javascript, parent
+        end
+
+        def findElementsByJavascript(parent, javascript)
+          find_elements_by 'javascript', javascript, parent
+        end
+
+        #
+        # Element functions
+        #
+
+        def clickElement(element)
+          # execute :clickElement, :element_id => element
+          execute :click,
+                  :element_id => element
+        end
+
+        def getElementTagName(element)
+          # execute :getElementTagName, :element_id => element
+          execute :getTagName,
+                  :element_id => element
+        end
+
+        def getElementAttribute(element, name)
+          # execute :getElementAttribute, :element_id => element, :parameters => [name]
+          execute :getAttribute,
+                  :element_id => element,
+                  :parameters => [name]
+        end
+
+        def getElementValue(element)
+          # execute :getElementValue, :element_id => element
+          execute :getValue,
+                  :element_id => element
+        end
+
+        def getElementText(element)
+          # execute :getElementText, :element_id => element
+          execute :getText,
+                  :element_id => element
+        end
+
+        def getElementLocation(element)
+          # data = execute :getElementLocation, :element_id => element
+          data = execute :getLocation,
+                         :element_id => element
+
+          Point.new data["x"], data["y"]
+        end
+
+        def getElementSize(element)
+          # execute :getElementSize, :element_id => element
+          data = execute :getSize,
+                         :element_id => element
+
+          Dimension.new data['width'], data['height']
+        end
+
+        def sendKeysToElement(element, string)
+          # execute :sendKeysToElement, :element_id => element, :parameters => [string.split(//u)]
+          execute :sendKeys,
+                  :element_id => element,
+                  :parameters => [string.to_s]
+        end
+
+        def clearElement(element)
+          # execute :clearElement, :element_id => element
+          execute :clear,
+                  :element_id => element
+        end
+
+        def isElementEnabled(element)
+          # execute :isElementEnabled, :element_id => element
+          !getElementAttribute(element, "disabled")
+        end
+
+        def isElementSelected(element)
+          # execute :isElementSelected, :element_id => element
+          execute :isSelected,
+                  :element_id => element
+        end
+
+        def isElementDisplayed(element)
+          # execute :isElementDisplayed, :element_id => element
+          execute :isDisplayed,
+                  :element_id => element
+        end
+
+        def submitElement(element)
+          # execute :submitElement, :element_id => element
+          execute :submit,
+                  :element_id => element
+        end
+
+        def toggleElement(element)
+          # execute :toggleElement, :element_id => element
+          execute :toggle,
+                  :element_id => element
+        end
+
+        def setElementSelected(element)
+          # execute :setElementSelected, :element_id => element
+          execute :setSelected,
+                  :element_id => element
+        end
+
+        def getElementValueOfCssProperty(element, prop)
+          # execute :getElementValueOfCssProperty, :element_id => element, :parameters => [prop]
+          execute :getValueOfCssProperty,
+                  :element_id => element,
+                  :parameters => [prop]
+        end
+
+        def hoverOverElement(element)
+          execute :hover,
+                  :element_id => element
+          # execute :hoverOverElement, :element_id => element
+        end
+
+        def dragElement(element, rigth_by, down_by)
+          execute :dragElement,
+                  :element_id => element,
+                  :parameters => [rigth_by, down_by]
+        end
+
+
+        def setSpeed(speed)
+          pixel_speed = case speed
+                        when "SLOW"   then '1'
+                        when "MEDIUM" then '10'
+                        when "FAST"   then '100'
+                        else
+                          raise ArgumentError, "unknown speed: #{speed.inspect}"
+                        end
+
+          execute :setMouseSpeed,
+                  :parameters => [pixel_speed]
+        end
+
+        def getSpeed
+          case execute(:getMouseSpeed)
+          when '1'    then  "SLOW"
+          when '10'   then  "MEDIUM"
+          when '100'  then  "FAST"
+          else
+            "FAST"
+          end
+        end
+
+        def addCookie(cookie)
+          execute :addCookie,
+                  :parameters => [cookie.to_json] # uhm, sending text instead of data
+        end
+
+        def deleteCookie(name)
+          execute :deleteCookie,
+                  :parameters => [{:name => name}.to_json] # ditto
+        end
+
+        def getAllCookies
+          data = execute :getCookie
+          data.map do |c|
+            parse_cookie_string(c) unless c.strip.empty?
+          end.compact
+        end
+
+        #
+        #  FF-specific?
+        #
+
+        def deleteAllCookies
+          execute :deleteAllCookies
+        end
+
+        def getCookieNamed(name)
+          getCookies.find { |c| c['name'] == name }
+        end
+
+        def switchToFrame(name)
+          execute :switchToFrame,
+                  :parameters => [name.to_s]
+        end
+
+        def switchToDefaultContent
+          execute :switchToDefaultContent
+        end
+
+        def switchToWindow(name)
+          @context = execute  :switchToWindow,
+                              :parameters => [name.to_s]
+        end
+
+        def switchToActiveElement
+          Element.new self, element_id_from(execute(:switchToActiveElement))
+        end
+        alias_method :getActiveElement, :switchToActiveElement
+
+        private
+
+        def find_element_by(how, what, parent = nil)
+          if parent
+            id = execute :findChildElement,
+                         :parameters => [{:id => parent, :using => how, :value => what}]
+          else
+            id = execute :findElement,
+                         :parameters => [how, what]
+          end
+
+          Element.new self, element_id_from(id)
+        end
+
+        def find_elements_by(how, what, parent = nil)
+          if parent
+            id_string = execute :findChildElements,
+                                :parameters => [{:id => parent, :using => how, :value => what}]
+          else
+            id_string = execute :findElements,
+                                :parameters => [how, what]
+          end
+
+          id_string.map { |id| Element.new self, element_id_from(id) }
+        end
+
+        def newSession
+          execute :newSession
+        end
+
+        def execute(*args)
+          raw_execute(*args)['response']
+        end
+
+        def raw_execute(command, opts = {})
+          request = {:commandName => command, :context => @context.to_s}
+
+          if eid = opts[:element_id]
+            request[:elementId] = eid
+          end
+
+          if params = opts[:parameters]
+            request[:parameters] = params
+          end
+
+          puts "--> #{request.inspect}" if $DEBUG
+
+          @connection.send_string request.to_json
+          resp = @connection.read_response
+
+          puts "<-- #{resp.inspect}" if $DEBUG
+
+          if resp['isError']
+            case resp['response']
+            when String
+              msg = resp['response']
+            when Hash
+              msg = resp['response']['message']
+            end
+
+            msg ||= resp.inspect
+            raise Error::WebDriverError, msg
+          end
+
+          if ctx = resp['context']
+            @context = ctx
+          end
+
+          resp
+        end
+
+        #
+        # wrap/unwrap will be shared with Chrome (overrides BridgeHelper for now)
+        #
+
+        def wrap_script_argument(arg)
+          case arg
+          when Integer, Float
+            { :type => "NUMBER", :value => arg }
+          when TrueClass, FalseClass, NilClass
+            { :type => "BOOLEAN", :value => !!arg }
+          when Element
+            { :type => "ELEMENT", :value => arg.ref }
+          when String
+            { :type => "STRING", :value => arg.to_s }
+          when Array # Enumerable?
+            arg.map { |e| wrap_script_argument(e) }
+          else
+            raise TypeError, "Parameter is not of recognized type: #{arg.inspect}:#{arg.class}"
+          end
+        end
+
+        def unwrap_script_argument(arg)
+          raise TypeError, "expected Hash" unless arg.kind_of? Hash
+          case arg["type"]
+          when "NULL"
+            nil
+          when "ELEMENT"
+            Element.new self, element_id_from(arg["value"])
+          when "ARRAY"
+            arg['value'].map { |e| unwrap_script_argument(e) }
+          # when "POINT"
+          #   Point.new arg['x'], arg['y']
+          # when "DIMENSION"
+          #   Dimension.new arg['width'], arg['height']
+          # when "COOKIE"
+          #   {:name => arg['name'], :value => arg['value']}
+          else
+            arg["value"]
+          end
+        end
+
+
+      end # Bridge
+    end # Firefox
+  end # WebDriver
+end # Selenium