vapir-firefox 1.8.1 → 1.9.0

data/lib/vapir-firefox/browser.rb

@@ -85,7 +85,6 @@ require 'vapir-common/waiter'
 require 'vapir-common/browser'
 require 'vapir-firefox/window'
 require 'vapir-firefox/modal_dialog'
-require 'vapir-firefox/jssh_socket'
 require 'vapir-firefox/container'
 require 'vapir-firefox/page_container'
 
@@ -97,36 +96,115 @@ module Vapir
     include Firefox::Window
     include Firefox::ModalDialogContainer
 
-    # initializes a JsshSocket and stores in a class variable. 
-    def self.initialize_jssh_socket # :nodoc:
-      uninitialize_jssh_socket
-      @@jssh_socket=JsshSocket.new
-      @@firewatir_jssh_objects=@@jssh_socket.object("Vapir").assign({})
-      @@jssh_socket
+    # initializes a FirefoxSocket and stores in a class variable. 
+    def self.initialize_firefox_socket(socket_class, socket_options) # :nodoc:
+      uninitialize_firefox_socket
+      @@firefox_socket=socket_class.new(socket_options)
+      vapir_javascript_functions = {
+        :element_real_visibility => %Q(
+          function(element_to_check, document_object)
+          { var real_visibility = null;
+            while(element_to_check && real_visibility==null)
+            { var style = element_to_check.nodeType==1 ? document_object.defaultView.getComputedStyle(element_to_check, null) : null;
+              if(style)
+              { // only pay attention to the innermost definition that really defines visibility - one of 'hidden', 'collapse' (only for table elements), 
+                // or 'visible'. ignore 'inherit'; keep looking upward. 
+                // this makes it so that if we encounter an explicit 'visible', we don't pay attention to any 'hidden' further up. 
+                // this style is inherited - may be pointless for firefox, but IE uses the 'inherited' value. not sure if/when ff does.
+                if(style.visibility)
+                { var visibility=style.visibility.toLowerCase();
+                  if($A(['hidden', 'collapse', 'visible']).include(visibility))
+                  { real_visibility = visibility;
+                  }
+                }
+              }
+              element_to_check=element_to_check.parentNode;
+            }
+            return real_visibility;
+          }
+        ),
+        :element_displayed => %Q(
+          function(node, document_object)
+          { var style = node.nodeType==1 ? document_object.defaultView.getComputedStyle(node, null) : null;
+            var display = style && style.display;
+            var displayed = display ? display.toLowerCase() != 'none' : true;
+            return displayed;
+          }
+        ),
+        :visible_text_nodes => %Q(
+          function(element_object, document_object)
+          { var recurse_text_nodes = Vapir.Ycomb(function(recurse)
+            { return function(node, parent_visibility)
+              { if(node.nodeType==1 || node.nodeType==9)
+                { var style = node.nodeType==1 ? document_object.defaultView.getComputedStyle(node, null) : null;
+                  var our_visibility = style && style.visibility;
+                  if(!(our_visibility && $A(['hidden', 'collapse', 'visible']).include(our_visibility.toLowerCase())))
+                  { our_visibility = parent_visibility;
+                  }
+                  if(!Vapir.element_displayed(node, document_object))
+                  { return [];
+                  }
+                  else
+                  { return $A(node.childNodes).inject([], function(result, child_node)
+                    { return result.concat(recurse(child_node, our_visibility));
+                    });
+                  }
+                }
+                else if(node.nodeType==3)
+                { if(parent_visibility && $A(['hidden', 'collapse']).include(parent_visibility.toLowerCase()))
+                  { return [];
+                  }
+                  else
+                  { return [node.data];
+                  }
+                }
+                else
+                { return [];
+                }
+              };
+            });
+            var element_to_check = element_object;
+            while(element_to_check)
+            { // check for display property. this is not inherited, so ascend the heirarchy looking. 
+              //
+              // any parent with display of 'none' overrides a more-immediate visibility='visible', so if any parent has 
+              // display=none, this is not visible and has no visible child text nodes.
+              if(!Vapir.element_displayed(element_to_check, document_object))
+              { return [];
+              }
+              element_to_check=element_to_check.parentNode;
+            }
+            return recurse_text_nodes(element_object, Vapir.element_real_visibility(document_object, element_object));
+          }
+        )
+      }
+      vapir_javascript_functions.each do |name, function_string|
+        @@firefox_socket.root.Vapir[name]=@@firefox_socket.object(function_string)
+      end
+      @@firefox_socket
     end
-    # returns a connected JsshSocket. pass :reset_if_dead => true if you suspect an existing 
+    # returns a connected FirefoxSocket. pass :reset_if_dead => true if you suspect an existing 
     # socket may be dead, and you want a new one. a warning will be printed if this occurs. 
-    def self.jssh_socket(options={}) # :nodoc:
-      if options[:reset] || !(class_variable_defined?('@@jssh_socket') && @@jssh_socket)
-        initialize_jssh_socket
+    def self.firefox_socket(options={}) # :nodoc:
+      if options[:reset] || !(class_variable_defined?('@@firefox_socket') && @@firefox_socket)
+        initialize_firefox_socket(options[:socket_class], options[:socket_options])
       end
       if options[:reset_if_dead]
         begin
-          @@jssh_socket.assert_socket
-        rescue JsshConnectionError
-          Kernel.warn "WARNING: JsshSocket RESET: resetting jssh socket. Any active javascript references will not exist on the new socket!"
-          initialize_jssh_socket
+          @@firefox_socket.assert_socket
+        rescue FirefoxSocketConnectionError
+          Kernel.warn "WARNING: Firefox socket RESET: resetting connection to firefox. Any active javascript references will not exist on the new socket!"
+          initialize_firefox_socket(options[:socket_class], options[:socket_options])
         end
       end
-      @@jssh_socket
+      @@firefox_socket
     end
-    # unsets a the current jssh socket 
-    def self.uninitialize_jssh_socket # :nodoc:
-      @@jssh_socket=nil
-      @@firewatir_jssh_objects=nil
+    # unsets a the current firefox socket 
+    def self.uninitialize_firefox_socket # :nodoc:
+      @@firefox_socket=nil
     end
-    def jssh_socket(options=nil)
-      options ? self.class.jssh_socket(options) : @@jssh_socket
+    def firefox_socket(options=nil)
+      options ? self.class.firefox_socket(options) : @@firefox_socket
     end
 
     # Description: 
@@ -158,15 +236,14 @@ module Vapir
         @binary_path=options[:binary_path]
       end
       
-      # check for jssh not running, firefox may be open but not with -jssh
-      # if its not open at all, regardless of the :suppress_launch_process option start it
-      # error if running without jssh, we don't want to kill their current window (mac only)
+      require 'vapir-firefox/firefox_socket/base'
+      # check for extension not listening; firefox may be open but not listening (extension not set up) 
       begin
-        jssh_socket(:reset_if_dead => true).assert_socket
-      rescue JsshError
+        firefox_socket(:reset_if_dead => true, :socket_class => firefox_socket_class, :socket_options => firefox_socket_class_options).assert_socket
+      rescue FirefoxSocketConnectionError
         # here we're going to assume that since it's not connecting, we need to launch firefox. 
         if options[:attach]
-          raise Vapir::Exception::NoBrowserException, "cannot attach using #{options[:attach].inspect} - could not connect to Firefox with JSSH"
+          raise Vapir::Exception::NoBrowserException, "cannot attach using #{options[:attach].inspect} - could not connect to Firefox"
         else
           launch_browser(options)
           # if we just launched a the browser process, attach to the window
@@ -178,16 +255,16 @@ module Vapir
             options[:attach]=[:title, //]
           end
         end
-        ::Waiter.try_for(options[:timeout], :exception => Vapir::Exception::NoBrowserException.new("Could not connect to the JSSH socket on the browser after #{options[:timeout]} seconds. Either Firefox did not start or JSSH is not installed and listening.")) do
+        ::Waiter.try_for(options[:timeout], :exception => Vapir::Exception::NoBrowserException.new("Could not connect to the #{config.firefox_extension} socket on the browser after #{options[:timeout]} seconds. Either Firefox did not start or #{config.firefox_extension} is not installed and listening.")) do
           begin
-            jssh_socket(:reset_if_dead => true).assert_socket
+            firefox_socket(:reset_if_dead => true, :socket_class => firefox_socket_class, :socket_options => firefox_socket_class_options).assert_socket
             true
-          rescue JsshUnableToStart
+          rescue FirefoxSocketUnableToStart
             false
           end
         end
       end
-      @browser_jssh_objects = jssh_socket.object('{}').store_rand_object_key(@@firewatir_jssh_objects) # this is an object that holds stuff for this browser 
+      @browser_objects = firefox_socket.object('{}').store_rand_temp
       
       @pid = begin
         self.pid
@@ -196,7 +273,16 @@ module Vapir
       end
       
       if options[:attach]
-        attach(*options[:attach])
+        how, what = *options[:attach]
+        @browser_window_object = case how
+        when :browser_window_object
+          what
+        else
+          ::Waiter.try_for(options[:timeout], :exception => Vapir::Exception::NoMatchingWindowFoundException.new("Unable to locate a window with #{how} of #{what}")) do
+            find_window(how, what)
+          end
+        end
+        set_browser_document
       else
         open_window
       end
@@ -217,13 +303,14 @@ module Vapir
     end
     
     def exists?
-      # jssh_socket may be nil if the window has closed 
-      jssh_socket && browser_window_object && self.class.browser_window_objects.include?(browser_window_object)
+      # firefox_socket may be nil if the window has closed 
+      # if the socket disconnects, we'll assume that means the browser quit and therefore the window doesn't exist 
+      firefox_socket && firefox_socket.handling_connection_error(:handle => proc{ return false }) do
+        browser_window_object && self.class.browser_window_objects.include?(browser_window_object)
+      end
     end
     
     # Launches firebox browser
-    # options as .new
-
     def launch_browser(options = {})
       ff_options = []
       if(options[:profile])
@@ -232,7 +319,8 @@ module Vapir
 
       bin = path_to_bin()
       @self_launched_browser = true
-      @t = Thread.new { system(bin, '-jssh', *ff_options) } # TODO: launch process in such a way that @pid can be noted 
+      ff_options += firefox_socket_class.command_line_flags(firefox_socket_class_options).map(&:to_s)
+      @t = Thread.new { system(bin, *ff_options) } # TODO: launch process in such a way that @pid can be noted 
     end
     private :launch_browser
 
@@ -263,13 +351,13 @@ module Vapir
         end
         CGI.escape(key.to_s)+'='+CGI.escape(val)
       end.join("&")
-      stringStream = jssh_socket.Components.classes["@mozilla.org/io/string-input-stream;1"].createInstance(jssh_socket.Components.interfaces.nsIStringInputStream)
+      stringStream = firefox_socket.Components.classes["@mozilla.org/io/string-input-stream;1"].createInstance(firefox_socket.Components.interfaces.nsIStringInputStream)
       if stringStream.to_hash.key?('data')
         stringStream.data=dataString
       else
         stringStream.setData(dataString, dataString.unpack("U*").length)
       end
-      postData = jssh_socket.Components.classes["@mozilla.org/network/mime-input-stream;1"].createInstance(jssh_socket.Components.interfaces.nsIMIMEInputStream)
+      postData = firefox_socket.Components.classes["@mozilla.org/network/mime-input-stream;1"].createInstance(firefox_socket.Components.interfaces.nsIMIMEInputStream)
       postData.addHeader("Content-Type", "application/x-www-form-urlencoded")
       postData.addContentLength = true
       postData.setData(stringStream)
@@ -309,12 +397,12 @@ module Vapir
       @error_checkers = []
     end
 
-    #   Sets the document, window and browser variables to point to correct object in JSSh.
+    #   Sets the document, window and browser variables to point to correct objects.
     def set_browser_document
       unless browser_window_object
         raise "Window must be set (using open_window or attach) before the browser document can be set!"
       end
-      @browser_object=@browser_jssh_objects[:browser]= ::Waiter.try_for(2, :exception => Vapir::Exception::NoMatchingWindowFoundException.new("The browser could not be found on the specified Firefox window!")) do
+      @browser_object=@browser_objects[:browser]= ::Waiter.try_for(2, :exception => Vapir::Exception::NoMatchingWindowFoundException.new("The browser could not be found on the specified Firefox window!")) do
         if browser_window_object.respond_to?(:getBrowser)
           browser_window_object.getBrowser
         end
@@ -326,27 +414,27 @@ module Vapir
       @content_window_object=browser_object.contentWindow
         # note that browser_window_object.content is the same thing, but simpler to refer to stuff on browser_object since that is updated by the nsIWebProgressListener below
       @body_object=document_object.body
-      @browser_jssh_objects[:requests_in_progress]=[]
-      @requests_in_progress=@browser_jssh_objects[:requests_in_progress].to_array
-      @browser_jssh_objects[:unmatched_stopped_requests_count]=0
+      @browser_objects[:requests_in_progress]=[]
+      @requests_in_progress=@browser_objects[:requests_in_progress].to_array
+      @browser_objects[:unmatched_stopped_requests_count]=0
       
-      @updated_at_epoch_ms=@browser_jssh_objects.attr(:updated_at_epoch_ms).assign_expr('new Date().getTime()')
-      @updated_at_offset=Time.now.to_f-jssh_socket.value_json('new Date().getTime()')/1000.0
+      @updated_at_epoch_ms=@browser_objects.attr(:updated_at_epoch_ms).assign_expr('new Date().getTime()')
+      @updated_at_offset=Time.now.to_f-firefox_socket.value_json('new Date().getTime()')/1000.0
     
       # Add eventlistener for browser window so that we can reset the document back whenever there is redirect
       # or browser loads on its own after some time. Useful when you are searching for flight results etc and
       # page goes to search page after that it goes automatically to results page.
       # Details : http://zenit.senecac.on.ca/wiki/index.php/Mozilla.dev.tech.xul#What_is_an_example_of_addProgressListener.3F
-      @browser_jssh_objects[:listener_object]={}
-      listener_object=@browser_jssh_objects[:listener_object]
-      listener_object[:QueryInterface]=jssh_socket.function(:aIID) do %Q(
+      @browser_objects[:listener_object]={}
+      listener_object=@browser_objects[:listener_object]
+      listener_object[:QueryInterface]=firefox_socket.function(:aIID) do %Q(
            if(aIID.equals(Components.interfaces.nsIWebProgressListener) || aIID.equals(Components.interfaces.nsISupportsWeakReference) || aIID.equals(Components.interfaces.nsISupports))
            { return this;
            }
            throw Components.results.NS_NOINTERFACE;
       )
       end
-      listener_object[:onStateChange]= jssh_socket.function(:aWebProgress, :aRequest, :aStateFlag, :aStatus) do %Q(
+      listener_object[:onStateChange]= firefox_socket.function(:aWebProgress, :aRequest, :aStateFlags, :aStatus) do %Q(
            var requests_in_progress=#{@requests_in_progress.ref};
            if(aStateFlags & Components.interfaces.nsIWebProgressListener.STATE_STOP)
            { #{@updated_at_epoch_ms.ref}=new Date().getTime();
@@ -365,7 +453,7 @@ module Vapir
                }
              }
              if(!matched)
-             { #{@browser_jssh_objects.attr(:unmatched_stopped_requests_count).ref}++; //.push({webProgress: aWebProgress, request: aRequest, stateFlags: aStateFlags, status: aStatus});
+             { #{@browser_objects.attr(:unmatched_stopped_requests_count).ref}++; //.push({webProgress: aWebProgress, request: aRequest, stateFlags: aStateFlags, status: aStatus});
                // count any stop requests that we fail to match so that we can compare that count to the number of unmatched start requests. 
              }
            }
@@ -409,27 +497,28 @@ module Vapir
       assert_exists
       # we expect the browser may exit if there are no windows which aren't ourself. except on mac. 
       expect_exit = !self.class.window_objects.any?{|other_window| other_window != self.browser_window_object } && current_os != :macosx
-      begin
+
+      connection_error_handler = proc do
+        Vapir::Firefox.uninitialize_firefox_socket
+        wait_for_process_exit(@pid)
+      end
+      firefox_socket.handling_connection_error(:handle => connection_error_handler) do
         browser_window_object.close
-        # TODO/fix timeout; this shouldn't be a hard-coded magic number. 
-        ::Waiter.try_for(32, :exception => Exception::WindowFailedToCloseException.new("The browser window did not close")) do
+        ::Waiter.try_for(config.close_timeout, :exception => Exception::WindowFailedToCloseException.new("The browser window did not close")) do
           !exists?
         end
         if expect_exit
-          ::Waiter.try_for(8, :exception => nil) do
-            jssh_socket.assert_socket # this should error, going up past the waiter to the rescue block above 
+          ::Waiter.try_for(config.quit_timeout, :exception => nil) do
+            firefox_socket.assert_socket # this should error, going up past the waiter to #handling_connection_error
             false
           end
         else
-          jssh_socket.assert_socket
+          firefox_socket.assert_socket
         end
-      rescue JsshConnectionError # the socket may disconnect when we close the browser, causing the JsshSocket to complain 
-        Vapir::Firefox.uninitialize_jssh_socket
-        wait_for_process_exit(@pid)
       end
-        
+
       @browser_window_object=@browser_object=@document_object=@content_window_object=@body_object=nil
-      if @self_launched_browser && jssh_socket && !self.class.window_objects.any?{ true }
+      if @self_launched_browser && firefox_socket && !self.class.window_objects.any?{ true }
         quit_browser(:force => false)
       end
     end
@@ -444,9 +533,9 @@ module Vapir
       #
       # quit_browser(:force => true) will force the browser to quit. 
       #
-      # if there is no existing connection to JSSH, this will attempt to create one. If that fails, JsshUnableToStart will be raised. 
+      # if there is no existing connection to firefox, this will attempt to create one. If that fails, FirefoxSocketUnableToStart will be raised. 
       def quit_browser(options={})
-        jssh_socket(:reset_if_dead => true).assert_socket
+        firefox_socket(:reset_if_dead => true, :socket_class => firefox_socket_class, :socket_options => firefox_socket_class_options).assert_socket
         options=handle_options(options, :force => false)
         
         pid = @pid || begin
@@ -456,16 +545,14 @@ module Vapir
         end
         
         # from https://developer.mozilla.org/en/How_to_Quit_a_XUL_Application
-        appStartup= jssh_socket.Components.classes['@mozilla.org/toolkit/app-startup;1'].getService(jssh_socket.Components.interfaces.nsIAppStartup)
-        quitSeverity = options[:force] ? jssh_socket.Components.interfaces.nsIAppStartup.eForceQuit : jssh_socket.Components.interfaces.nsIAppStartup.eAttemptQuit
-        begin
+        appStartup= firefox_socket.Components.classes['@mozilla.org/toolkit/app-startup;1'].getService(firefox_socket.Components.interfaces.nsIAppStartup)
+        quitSeverity = options[:force] ? firefox_socket.Components.interfaces.nsIAppStartup.eForceQuit : firefox_socket.Components.interfaces.nsIAppStartup.eAttemptQuit
+        firefox_socket.handling_connection_error(:handle => proc{ Vapir::Firefox.uninitialize_firefox_socket }) do
           appStartup.quit(quitSeverity)
-          ::Waiter.try_for(8, :exception => Exception::WindowFailedToCloseException.new("The browser did not quit")) do
-            jssh_socket.assert_socket # this should error, going up past the waiter to the rescue block above 
+          ::Waiter.try_for(config.quit_timeout, :exception => Exception::WindowFailedToCloseException.new("The browser did not quit")) do
+            firefox_socket.assert_socket # this should error, going up past the waiter to #handling_connection_error
             false
           end
-        rescue JsshConnectionError
-          Vapir::Firefox.uninitialize_jssh_socket
         end
         
         wait_for_process_exit(pid)
@@ -481,8 +568,8 @@ module Vapir
       def pid
         begin
           begin
-            ctypes = jssh_socket.Components.utils.import("resource://gre/modules/ctypes.jsm").ctypes
-          rescue JsshJavascriptError
+            ctypes = firefox_socket.Components.utils.import("resource://gre/modules/ctypes.jsm").ctypes
+          rescue FirefoxSocketJavascriptError
             raise NotImplementedError, "Firefox 3.6 or greater is required for this method.\n\nOriginal error from firefox: #{$!.class}: #{$!.message}", $!.backtrace
           end
           lib, pidfunction, abi = *case current_os
@@ -491,12 +578,25 @@ module Vapir
           when :linux
             ["libc.so.6", 'getpid', ctypes.default_abi]
           when :windows
-            ['kernel32', 'GetCurrentProcessId', ctypes.stdcall_abi]
+            # winapi is correct - we do not want stdcall's mangling. ff4+ does the stdcall
+            # mangling correctly with ctypes.stdcall_abi, and since we don't want mangling, 
+            # that fails here. ff < 4 does not do stdcall mangling (and has no winapi abi 
+            # to skip mangling) so ends up working correctly. 
+            # so, we want winapi if it's defined to skip mangling, but if 
+            # it's not defined, use stdcall because it won't mangle anyway. 
+            #
+            # see https://bugzilla.mozilla.org/show_bug.cgi?id=585175
+            ['kernel32', 'GetCurrentProcessId', ctypes['winapi_abi'] || ctypes['stdcall_abi']]
           else
             raise NotImplementedError, "don't know how to get pid for #{current_os}"
           end
-          getpid = ctypes.open(lib).declare(pidfunction, abi, ctypes.int32_t)
-          getpid.call()
+           lib = ctypes.open(lib)
+          begin
+            getpid = lib.declare(pidfunction, abi, ctypes['int32_t'])
+            return getpid.call()
+          ensure
+            lib.close
+          end
         end
       end
       
@@ -540,7 +640,7 @@ module Vapir
       # the pfirefox process has exited. 
       def wait_for_process_exit(pid)
         if pid
-          ::Waiter.try_for(16, :exception => Exception::WindowFailedToCloseException.new("The browser did not quit")) do
+          ::Waiter.try_for(config.quit_timeout, :exception => Exception::WindowFailedToCloseException.new("The browser did not quit")) do
             !process_running?(pid)
           end
         else
@@ -571,45 +671,53 @@ module Vapir
           end
         end
       end
-    end
-    include FirefoxClassAndInstanceMethods
-    extend FirefoxClassAndInstanceMethods
-
-    
 
-    #   Used for attaching pop up window to an existing Firefox window, either by url or title.
-    #   ff.attach(:url, 'http://www.google.com')
-    #   ff.attach(:title, 'Google')
-    #
-    # Output:
-    #   Instance of newly attached window.
-    def attach(how, what)
-      @browser_window_object = case how
-      when :browser_window_object
-        what
-      else
-        find_window(how, what)
+      private
+      # returns the class inheriting from FirefoxSocket which will be used to connect to a firefox extension
+      def firefox_socket_class
+        if config.firefox_extension.is_a?(String) && config.firefox_extension.downcase=='mozrepl'
+          require 'vapir-firefox/firefox_socket/mozrepl'
+          MozreplSocket
+        elsif config.firefox_extension.is_a?(String) && config.firefox_extension.downcase=='jssh'
+          require 'vapir-firefox/firefox_socket/jssh'
+          JsshSocket
+        else
+          raise Vapir::Configuration::InvalidValueError, "Unrecognized firefox extension #{config.firefox_extension.inspect}. Vapir supports the JSSH and Mozrepl extensions."
+        end
       end
-      
-      unless @browser_window_object
-        raise Exception::NoMatchingWindowFoundException.new("Unable to locate window, using #{how} and #{what}")
+      # returns a hash of options in the current configuration, prefixed with the firefox extension 
+      # to be used, to pass along to to the firefox socket class as needed 
+      def firefox_socket_class_options
+        # pass any config options that look like firefox_jssh_something or firefox_mozrepl_something 
+        prefix = "firefox_#{config.firefox_extension}_"
+        config.defined_hash.inject({}) do |opts, (key, val)|
+          if key[0...prefix.length] == prefix
+            opts.merge(key[prefix.length..-1] => val)
+          else
+            opts
+          end
+        end
       end
-      set_browser_document
-      self
+      private :firefox_socket_class_options
     end
-    private :attach
+    include FirefoxClassAndInstanceMethods
+    extend FirefoxClassAndInstanceMethods
 
     # loads up a new window in an existing process
-    # Vapir::Browser.attach() with no arguments passed the attach method will create a new window
-    # this will only be called one time per instance we're only ever going to run in 1 window
     def open_window
       begin
         @browser_window_name="firewatir_window_%.16x"%rand(2**64)
       end while self.class.browser_window_objects.any?{|browser_window_object| browser_window_object.name == @browser_window_name }
-      watcher=jssh_socket.Components.classes["@mozilla.org/embedcomp/window-watcher;1"].getService(jssh_socket.Components.interfaces.nsIWindowWatcher)
+      watcher=firefox_socket.Components.classes["@mozilla.org/embedcomp/window-watcher;1"].getService(firefox_socket.Components.interfaces.nsIWindowWatcher)
       # nsIWindowWatcher is used to launch new top-level windows. see https://developer.mozilla.org/en/Working_with_windows_in_chrome_code
       
-      @browser_window_object=@browser_jssh_objects[:browser_window]=watcher.openWindow(nil, 'chrome://browser/content/browser.xul', @browser_window_name, 'resizable', nil)
+      # for openWindow's fourth argument, turn on all the features listed https://developer.mozilla.org/en/DOM/window.open 
+      # this doesn't enable anything that's not shown by default (for example, having personalbar won't turn on the bookmorks bar
+      # if it's set to not be shown), but lacking anything here does disable things which are on by default (if the bookmarks bar is
+      # set to show by default and personalbar is not set here, it will not show)
+      #
+      # see https://developer.mozilla.org/en/DOM/window.open
+      @browser_window_object=@browser_objects[:browser_window]=watcher.openWindow(nil, 'chrome://browser/content/browser.xul', @browser_window_name, 'chrome,resizable,toolbar,menubar,personalbar,location,status,scrollbars,titlebar', nil)
       return @browser_window_object
     end
     private :open_window
@@ -625,7 +733,7 @@ module Vapir
         Enumerator.new(self, :each_browser)
       end
       def each_browser_window_object
-        mediator=jssh_socket.Components.classes["@mozilla.org/appshell/window-mediator;1"].getService(jssh_socket.Components.interfaces.nsIWindowMediator)
+        mediator=firefox_socket.Components.classes["@mozilla.org/appshell/window-mediator;1"].getService(firefox_socket.Components.interfaces.nsIWindowMediator)
         enumerator=mediator.getEnumerator("navigator:browser")
         while enumerator.hasMoreElements
           win=enumerator.getNext
@@ -637,7 +745,7 @@ module Vapir
         Enumerator.new(self, :each_browser_window_object)
       end
       def each_window_object
-        mediator=jssh_socket.Components.classes["@mozilla.org/appshell/window-mediator;1"].getService(jssh_socket.Components.interfaces.nsIWindowMediator)
+        mediator=firefox_socket.Components.classes["@mozilla.org/appshell/window-mediator;1"].getService(firefox_socket.Components.interfaces.nsIWindowMediator)
         enumerator=mediator.getEnumerator(nil)
         while enumerator.hasMoreElements
           win=enumerator.getNext
@@ -650,7 +758,7 @@ module Vapir
       end
     end
     
-    # return the window jssh object for the browser window with the given title or url.
+    # return the window javascript object for the browser window with the given title or url.
     #   how - :url, :title, or :name
     #   what - string or regexp
     #
@@ -665,8 +773,11 @@ module Vapir
       raise ArgumentError, "how should be one of: #{hows.keys.inspect} (was #{orig_how.inspect})" unless how
       found_win=nil
       self.class.each_browser_window_object do |win|
-        found_win=win if Vapir::fuzzy_match(hows[how].call(win.getBrowser.contentDocument),what)
-        # we don't break here if found_win is set because we want the last match if there are multiple. 
+        contentDocument = win.getBrowser.contentDocument rescue nil # this can result in a Javascript TypeError: this.docShell is null if the window isn't ready yet 
+        if contentDocument && Vapir::fuzzy_match(hows[how].call(contentDocument),what)
+          found_win=win 
+          # we don't break here if found_win is set because we want the last match if there are multiple. 
+        end
       end
       return found_win
     end
@@ -692,8 +803,8 @@ module Vapir
       channel = nil
       ::Waiter.try_for(8, :exception => nil) do
         channel=browser.browser_object.docShell.currentDocumentChannel
-        channel.is_a?(JsshObject) && channel.instanceof(browser.jssh_socket.Components.interfaces.nsIHttpChannel) && channel.respond_to?(:responseStatus)
-      end || raise(RuntimeError, "expected currentDocumentChannel to exist and be a nsIHttpChannel but it wasn't; was #{channel.is_a?(JsshObject) ? channel.toString : channel.inspect}")
+        channel.is_a?(JavascriptObject) && channel.instanceof(browser.firefox_socket.Components.interfaces.nsIHttpChannel) && channel.respond_to?(:responseStatus)
+      end || raise(RuntimeError, "expected currentDocumentChannel to exist and be a nsIHttpChannel but it wasn't; was #{channel.is_a?(JavascriptObject) ? channel.toString : channel.inspect}")
       status = channel.responseStatus
     end
     
@@ -713,7 +824,7 @@ module Vapir
       unless options.is_a?(Hash)
         raise ArgumentError, "given options should be a Hash, not #{options.inspect} (#{options.class})\nold conflicting arguments of no_sleep or last_url are gone"
       end
-      options={:sleep => false, :last_url => nil, :timeout => 120}.merge(options)
+      options={:sleep => false, :last_url => nil, :timeout => config.wait_timeout}.merge(options)
       started=Time.now
       ::Waiter.try_for(options[:timeout] - (Time.now - started), :exception => "Waiting for the document to finish loading timed out") do
         browser_object.webProgress.isLoadingDocument==false
@@ -747,7 +858,7 @@ module Vapir
         end
       end
       ::Waiter.try_for(options[:timeout] - (Time.now - started), :exception => "Waiting for requests in progress to complete timed out.") do
-        @requests_in_progress.length<=@browser_jssh_objects[:unmatched_stopped_requests_count]
+        @requests_in_progress.length<=@browser_objects[:unmatched_stopped_requests_count]
       end
       run_error_checks
       return self
@@ -769,7 +880,7 @@ module Vapir
       
       if options[:dc] == :page
         options[:format] ||= 'png'
-        jssh_socket.call_function(:window => content_window_object, :options => options, :filename => File.expand_path(filename)) do
+        firefox_socket.call_function(:window => content_window_object, :options => options, :filename => File.expand_path(filename)) do
         %q(
           // this is adapted from Selenium's method Selenium.prototype.doCaptureEntirePageScreenshot
           var document = window.document;