selenium-webdriver 3.4.0 → 3.4.1

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

@@ -0,0 +1,139 @@
+# encoding: utf-8
+#
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you 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.
+
+module Selenium
+  module WebDriver
+    module Firefox
+      class Options
+        attr_reader :args, :prefs, :options, :profile
+        attr_accessor :binary, :log_level
+
+        KEY = 'moz:firefoxOptions'.freeze
+
+        #
+        # Create a new Options instance, only for W3C-capable versions of Firefox.
+        #
+        # @example
+        #   options = Selenium::WebDriver::Firefox::Options.new(args: ['--host=127.0.0.1'])
+        #   driver = Selenium::WebDriver.for :firefox, options: options
+        #
+        # @param [Hash] opts the pre-defined options to create the Firefox::Options with
+        # @option opts [String] :binary Path to the Firefox executable to use
+        # @option opts [Array<String>] :args List of command-line arguments to use when starting geckodriver
+        # @option opts [Profile, String] :profile Encoded profile string or Profile instance
+        # @option opts [String, Symbol] :log_level Log level for geckodriver
+        # @option opts [Hash] :prefs A hash with each entry consisting of the key of the preference and its value
+        # @option opts [Hash] :options A hash for raw options
+        #
+
+        def initialize(**opts)
+          @args = opts.delete(:args) || []
+          @binary = opts.delete(:binary)
+          @profile = opts.delete(:profile)
+          @log_level = opts.delete(:log_level)
+          @prefs = opts.delete(:prefs) || {}
+          @options = opts.delete(:options) || {}
+        end
+
+        #
+        # Add a command-line argument to use when starting Firefox.
+        #
+        # @example Start geckodriver on a specific host
+        #   options = Selenium::WebDriver::Firefox::Options.new
+        #   options.add_argument('--host=127.0.0.1')
+        #
+        # @param [String] arg The command-line argument to add
+        #
+
+        def add_argument(arg)
+          @args << arg
+        end
+
+        #
+        # Add a new option not yet handled by these bindings.
+        #
+        # @example
+        #   options = Selenium::WebDriver::Firefox::Options.new
+        #   options.add_option(:foo, 'bar')
+        #
+        # @param [String, Symbol] name Name of the option
+        # @param [Boolean, String, Integer] value Value of the option
+        #
+
+        def add_option(name, value)
+          @options[name] = value
+        end
+
+        #
+        # Add a preference that is only applied to the user profile in use.
+        #
+        # @example Set the default homepage
+        #   options = Selenium::WebDriver::Firefox::Options.new
+        #   options.add_preference('browser.startup.homepage', 'http://www.seleniumhq.com/')
+        #
+        # @param [String] name Key of the preference
+        # @param [Boolean, String, Integer] value Value of the preference
+        #
+
+        def add_preference(name, value)
+          prefs[name] = value
+        end
+
+        #
+        # Sets Firefox profile.
+        #
+        # @example Set the custom profile
+        #   profile = Selenium::WebDriver::Firefox::Profile.new
+        #   options = Selenium::WebDriver::Firefox::Options.new
+        #   options.profile = profile
+        #
+        # @example Use existing profile
+        #   options = Selenium::WebDriver::Firefox::Options.new
+        #   options.profile = 'myprofile'
+        #
+        # @param [Profile, String] profile Profile to be used
+        #
+
+        def profile=(profile)
+          @profile = if profile.is_a?(Profile)
+                       profile
+                     else
+                       Profile.from_name(profile)
+                     end
+        end
+
+        #
+        # @api private
+        #
+
+        def as_json(*)
+          opts = @options
+
+          opts[:profile] = @profile.encoded if @profile
+          opts[:args] = @args if @args.any?
+          opts[:binary] = @binary if @binary
+          opts[:prefs] = @prefs unless @prefs.empty?
+          opts[:log] = {level: @log_level} if @log_level
+
+          {KEY => opts}
+        end
+      end # Profile
+    end # Firefox
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/ie.rb

@@ -17,7 +17,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
-require 'selenium/webdriver/ie/bridge'
+require 'selenium/webdriver/ie/driver'
 require 'selenium/webdriver/ie/service'
 
 module Selenium

data/lib/selenium/webdriver/ie/{bridge.rb → driver.rb}

@@ -20,11 +20,16 @@
 module Selenium
   module WebDriver
     module IE
+
       #
+      # Driver implementation for Internet Explorer supporting
+      # both OSS and W3C dialects of JSON wire protocol.
       # @api private
       #
 
-      class Bridge < Remote::Bridge
+      class Driver < WebDriver::Driver
+        include DriverExtensions::TakesScreenshot
+
         def initialize(opts = {})
           opts[:desired_capabilities] ||= Remote::Capabilities.internet_explorer
 
@@ -34,17 +39,13 @@ module Selenium
 
             opts[:driver_opts] ||= {}
             if opts.key? :service_args
-              WebDriver.logger.warn <<-DEPRECATE.gsub(/\n +| {2,}/, ' ').freeze
-            [DEPRECATION] `:service_args` is deprecated. Pass switches using `driver_opts`
-              DEPRECATE
+              WebDriver.logger.deprecate ':service_args', "driver_opts: {args: #{opts[:service_args]}}"
               opts[:driver_opts][:args] = opts.delete(:service_args)
             end
 
             %i[log_level log_file implementation].each do |method|
               next unless opts.key? method
-              WebDriver.logger.warn <<-DEPRECATE.gsub(/\n +| {2,}/, ' ').freeze
-            [DEPRECATION] `#{method}` is deprecated. Pass switches using `driver_opts`
-              DEPRECATE
+              WebDriver.logger.deprecate ":#{method}", "driver_opts: {#{method}: '#{opts[method]}'}"
               opts[:driver_opts][method] = opts.delete(method)
             end
 
@@ -58,23 +59,22 @@ module Selenium
           end
           opts[:desired_capabilities][:native_events] = opts.delete(:native_events) != false
 
-          super(opts)
+          listener = opts.delete(:listener)
+          @bridge = Remote::Bridge.handshake(opts)
+          super(@bridge, listener: listener)
         end
 
         def browser
           :internet_explorer
         end
 
-        def driver_extensions
-          [DriverExtensions::TakesScreenshot]
-        end
-
         def quit
           super
         ensure
           @service.stop if @service
         end
-      end # Bridge
+
+      end # Driver
     end # IE
   end # WebDriver
 end # Selenium

data/lib/selenium/webdriver/phantomjs.rb

@@ -20,7 +20,7 @@
 require 'net/http'
 
 require 'selenium/webdriver/phantomjs/service'
-require 'selenium/webdriver/phantomjs/bridge'
+require 'selenium/webdriver/phantomjs/driver'
 
 module Selenium
   module WebDriver

data/lib/selenium/webdriver/phantomjs/{bridge.rb → driver.rb}

@@ -20,11 +20,15 @@
 module Selenium
   module WebDriver
     module PhantomJS
+
       #
+      # Driver implementation for PhantomJS.
       # @api private
       #
 
-      class Bridge < Remote::Bridge
+      class Driver < WebDriver::Driver
+        include DriverExtensions::TakesScreenshot
+
         def initialize(opts = {})
           opts[:desired_capabilities] ||= Remote::Capabilities.phantomjs
 
@@ -34,9 +38,7 @@ module Selenium
 
             opts[:driver_opts] ||= {}
             if opts.key? :args
-              WebDriver.logger.warn <<-DEPRECATE.gsub(/\n +| {2,}/, ' ').freeze
-            [DEPRECATION] `:args` is deprecated. Pass switches using `driver_opts`
-              DEPRECATE
+              WebDriver.logger.deprecate ':args', "driver_opts: {args: #{opts[:args]}}"
               opts[:driver_opts][:args] = opts.delete(:args)
             elsif opts[:desired_capabilities]['phantomjs.cli.args']
               opts[:driver_opts][:args] = opts[:desired_capabilities]['phantomjs.cli.args']
@@ -47,26 +49,21 @@ module Selenium
             opts[:url] = @service.uri
           end
 
-          super(opts)
+          listener = opts.delete(:listener)
+          @bridge = Remote::Bridge.handshake(opts)
+          super(@bridge, listener: listener)
         end
 
         def browser
           :phantomjs
         end
 
-        def driver_extensions
-          [DriverExtensions::TakesScreenshot]
-        end
-
-        def capabilities
-          @capabilities ||= Remote::Capabilities.phantomjs
-        end
-
         def quit
           super
         ensure
           @service.stop if @service
         end
+
       end # Bridge
     end # PhantomJS
   end # WebDriver

data/lib/selenium/webdriver/remote.rb

@@ -19,21 +19,19 @@
 
 require 'uri'
 
-require 'selenium/webdriver/remote/capabilities'
-require 'selenium/webdriver/remote/w3c_capabilities'
 require 'selenium/webdriver/remote/bridge'
-require 'selenium/webdriver/remote/w3c_bridge'
-require 'selenium/webdriver/remote/server_error'
+require 'selenium/webdriver/remote/driver'
 require 'selenium/webdriver/remote/response'
-require 'selenium/webdriver/remote/commands'
-require 'selenium/webdriver/remote/w3c_commands'
+require 'selenium/webdriver/remote/server_error'
 require 'selenium/webdriver/remote/http/common'
 require 'selenium/webdriver/remote/http/default'
 
-module Selenium
-  module WebDriver
-    # @api private
-    module Remote
-    end # Remote
-  end # WebDriver
-end # Selenium
+require 'selenium/webdriver/remote/capabilities'
+require 'selenium/webdriver/remote/oss/bridge'
+require 'selenium/webdriver/remote/oss/commands'
+require 'selenium/webdriver/remote/oss/driver'
+
+require 'selenium/webdriver/remote/w3c/bridge'
+require 'selenium/webdriver/remote/w3c/capabilities'
+require 'selenium/webdriver/remote/w3c/commands'
+require 'selenium/webdriver/remote/w3c/driver'

data/lib/selenium/webdriver/remote/bridge.rb

@@ -20,653 +20,137 @@
 module Selenium
   module WebDriver
     module Remote
-      #
-      # Low level bridge to the remote server, through which the rest of the API works.
-      #
-      # @api private
-      #
-
       class Bridge
+        include Atoms
         include BridgeHelper
 
+        COMMANDS = {
+          new_session: [:post, 'session'.freeze]
+        }.freeze
+
         attr_accessor :context, :http, :file_detector
-        attr_reader :capabilities
+        attr_reader :capabilities, :dialect
 
         #
-        # @see W3CBridge#Initialize
+        # Implements protocol handshake which:
+        #
+        #   1. Creates session with driver.
+        #   2. Sniffs response.
+        #   3. Based on the response, understands which dialect we should use.
+        #
+        # @return [OSS:Bridge, W3C::Bridge]
+        #
+        def self.handshake(**opts)
+          desired_capabilities = opts.delete(:desired_capabilities)
+          bridge = new(opts)
+          capabilities = bridge.create_session(desired_capabilities)
+
+          case bridge.dialect
+          when :oss
+            Remote::OSS::Bridge.new(capabilities, bridge.session_id, opts)
+          when :w3c
+            Remote::W3C::Bridge.new(capabilities, bridge.session_id, opts)
+          else
+            raise WebDriverError, 'cannot understand dialect'
+          end
+        end
+
+        #
+        # Initializes the bridge with the given server URL
+        # @param [Hash] opts options for the driver
+        # @option opts [String] :url url for the remote server
+        # @option opts [Integer] :port port number for the remote server
+        # @option opts [Object] :http_client an HTTP client instance that implements the same protocol as Http::Default
+        # @option opts [Capabilities] :desired_capabilities an instance of Remote::Capabilities describing the capabilities you want
+        # @api private
         #
 
         def initialize(opts = {})
           opts = opts.dup
 
-          port = if opts.key?(:port)
-                   WebDriver.logger.warn <<-DEPRECATE.gsub(/\n +| {2,}/, ' ').freeze
-                   [DEPRECATION] `:port` is deprecated. Use `:url` with full path
-                   DEPRECATE
-                   opts.delete(:port)
-                 else
-                   4444
-                 end
+          WebDriver.logger.deprecate ':port', 'full URL' if opts.key?(:port)
+          port = opts.delete(:port) || 4444
 
           http_client = opts.delete(:http_client) { Http::Default.new }
-          desired_capabilities = opts.delete(:desired_capabilities) { Capabilities.firefox }
           url = opts.delete(:url) { "http://#{Platform.localhost}:#{port}/wd/hub" }
 
           unless opts.empty?
             raise ArgumentError, "unknown option#{'s' if opts.size != 1}: #{opts.inspect}"
           end
 
-          if desired_capabilities.is_a?(Symbol)
-            unless Capabilities.respond_to?(desired_capabilities)
-              raise Error::WebDriverError, "invalid desired capability: #{desired_capabilities.inspect}"
-            end
-
-            desired_capabilities = Capabilities.send(desired_capabilities)
-          end
-
           uri = url.is_a?(URI) ? url : URI.parse(url)
           uri.path += '/' unless uri.path =~ %r{\/$}
 
           http_client.server_url = uri
 
           @http = http_client
-          @capabilities = create_session(desired_capabilities)
-
           @file_detector = nil
         end
 
-        def browser
-          @browser ||= (
-            name = @capabilities.browser_name
-            name ? name.tr(' ', '_').to_sym : 'unknown'
-          )
-        end
-
-        def driver_extensions
-          [DriverExtensions::UploadsFiles,
-           DriverExtensions::TakesScreenshot,
-           DriverExtensions::HasSessionId,
-           DriverExtensions::Rotatable,
-           DriverExtensions::HasTouchScreen,
-           DriverExtensions::HasLocation,
-           DriverExtensions::HasNetworkConnection,
-           DriverExtensions::HasRemoteStatus,
-           DriverExtensions::HasWebStorage]
-        end
-
-        def commands(command)
-          COMMANDS[command]
-        end
-
         #
-        # Returns the current session ID.
+        # Creates session handling both OSS and W3C dialects.
         #
 
-        def session_id
-          @session_id || raise(Error::WebDriverError, 'no current session exists')
-        end
-
         def create_session(desired_capabilities)
-          resp = raw_execute :new_session, {}, {desiredCapabilities: desired_capabilities}
-          @session_id = resp['sessionId']
-          return Capabilities.json_create resp['value'] if @session_id
-
-          raise Error::WebDriverError, 'no sessionId in returned payload'
-        end
-
-        def status
-          execute :status
-        end
-
-        def get(url)
-          execute :get, {}, {url: url}
-        end
-
-        def session_capabilities
-          Capabilities.json_create execute(:get_capabilities)
-        end
-
-        def implicit_wait_timeout=(milliseconds)
-          execute :implicitly_wait, {}, {ms: milliseconds}
-        end
-
-        def script_timeout=(milliseconds)
-          execute :set_script_timeout, {}, {ms: milliseconds}
-        end
-
-        def timeout(type, milliseconds)
-          execute :set_timeout, {}, {type: type, ms: milliseconds}
-        end
-
-        #
-        # alerts
-        #
-
-        def accept_alert
-          execute :accept_alert
-        end
-
-        def dismiss_alert
-          execute :dismiss_alert
-        end
-
-        def alert=(keys)
-          execute :set_alert_value, {}, {text: keys.to_s}
-        end
-
-        def alert_text
-          execute :get_alert_text
-        end
-
-        def authentication(credentials)
-          execute :set_authentication, {}, credentials
-        end
-
-        #
-        # navigation
-        #
-
-        def go_back
-          execute :go_back
-        end
-
-        def go_forward
-          execute :go_forward
-        end
-
-        def url
-          execute :get_current_url
-        end
-
-        def title
-          execute :get_title
-        end
-
-        def page_source
-          execute :get_page_source
-        end
-
-        def switch_to_window(name)
-          execute :switch_to_window, {}, {name: name}
-        end
+          response = execute(:new_session, {}, merged_capabilties(desired_capabilities))
 
-        def switch_to_frame(id)
-          execute :switch_to_frame, {}, {id: id}
-        end
-
-        def switch_to_parent_frame
-          execute :switch_to_parent_frame
-        end
-
-        def switch_to_default_content
-          switch_to_frame(nil)
-        end
-
-        def quit
-          execute :quit
-          http.close
-        rescue *http.quit_errors
-        end
-
-        def close
-          execute :close
-        end
-
-        def refresh
-          execute :refresh
-        end
-
-        #
-        # window handling
-        #
-
-        def window_handles
-          execute :get_window_handles
-        end
-
-        def window_handle
-          execute :get_current_window_handle
-        end
-
-        def resize_window(width, height, handle = :current)
-          execute :set_window_size, {window_handle: handle},
-                  {width: width,
-                   height: height}
-        end
-
-        def maximize_window(handle = :current)
-          execute :maximize_window, window_handle: handle
-        end
-
-        def window_size(handle = :current)
-          data = execute :get_window_size, window_handle: handle
-
-          Dimension.new data['width'], data['height']
-        end
-
-        def reposition_window(x, y, handle = :current)
-          execute :set_window_position, {window_handle: handle},
-                  {x: x, y: y}
-        end
-
-        def window_position(handle = :current)
-          data = execute :get_window_position, window_handle: handle
-
-          Point.new data['x'], data['y']
-        end
-
-        def screenshot
-          execute :screenshot
-        end
-
-        #
-        # HTML 5
-        #
-
-        def local_storage_item(key, value = nil)
-          if value
-            execute :set_local_storage_item, {}, {key: key, value: value}
-          else
-            execute :get_local_storage_item, key: key
-          end
-        end
-
-        def remove_local_storage_item(key)
-          execute :remove_local_storage_item, key: key
-        end
-
-        def local_storage_keys
-          execute :get_local_storage_keys
-        end
-
-        def clear_local_storage
-          execute :clear_local_storage
-        end
-
-        def local_storage_size
-          execute :get_local_storage_size
-        end
+          @session_id = response['sessionId']
+          oss_status = response['status']
+          value = response['value']
 
-        def session_storage_item(key, value = nil)
-          if value
-            execute :set_session_storage_item, {}, {key: key, value: value}
-          else
-            execute :get_session_storage_item, key: key
-          end
-        end
-
-        def remove_session_storage_item(key)
-          execute :remove_session_storage_item, key: key
-        end
-
-        def session_storage_keys
-          execute :get_session_storage_keys
-        end
-
-        def clear_session_storage
-          execute :clear_session_storage
-        end
+          if value.is_a?(Hash)
+            @session_id = value['sessionId'] if value.key?('sessionId')
 
-        def session_storage_size
-          execute :get_session_storage_size
-        end
-
-        def location
-          obj = execute(:get_location) || {}
-          Location.new obj['latitude'], obj['longitude'], obj['altitude']
-        end
-
-        def set_location(lat, lon, alt)
-          loc = {latitude: lat, longitude: lon, altitude: alt}
-          execute :set_location, {}, {location: loc}
-        end
-
-        def network_connection
-          execute :get_network_connection
-        end
-
-        def network_connection=(type)
-          execute :set_network_connection, {}, {parameters: {type: type}}
-        end
-
-        #
-        # javascript execution
-        #
-
-        def execute_script(script, *args)
-          assert_javascript_enabled
-
-          result = execute :execute_script, {}, {script: script, args: args}
-          unwrap_script_result result
-        end
-
-        def execute_async_script(script, *args)
-          assert_javascript_enabled
-
-          result = execute :execute_async_script, {}, {script: script, args: args}
-          unwrap_script_result result
-        end
-
-        #
-        # cookies
-        #
-
-        def options
-          @options ||= WebDriver::Options.new(self)
-        end
-
-        def add_cookie(cookie)
-          execute :add_cookie, {}, {cookie: cookie}
-        end
-
-        def delete_cookie(name)
-          execute :delete_cookie, name: name
-        end
-
-        def cookies
-          execute :get_cookies
-        end
-
-        def delete_all_cookies
-          execute :delete_all_cookies
-        end
-
-        #
-        # actions
-        #
-
-        #
-        # @return [ActionBuilder]
-        # @api public
-        #
-
-        def action
-          ActionBuilder.new Mouse.new(self), Keyboard.new(self)
-        end
-
-        def mouse
-          WebDriver.logger.warn <<-DEPRECATE.gsub(/\n +| {2,}/, ' ').freeze
-            [DEPRECATION] `Driver#mouse` is deprecated with w3c implementation. Instead use 
-            driver.action.<command>.perform
-          DEPRECATE
-          Mouse.new self
-        end
-
-        def keyboard
-          WebDriver.logger.warn <<-DEPRECATE.gsub(/\n +| {2,}/, ' ').freeze
-            [DEPRECATION] `Driver#keyboard` is deprecated with w3c implementation. Instead use 
-            driver.action.<command>.perform
-          DEPRECATE
-          Keyboard.new self
-        end
-
-        def click_element(element)
-          execute :click_element, id: element
-        end
-
-        def click
-          execute :click, {}, {button: 0}
-        end
-
-        def double_click
-          execute :double_click
-        end
-
-        def context_click
-          execute :click, {}, {button: 2}
-        end
-
-        def mouse_down
-          execute :mouse_down
-        end
-
-        def mouse_up
-          execute :mouse_up
-        end
-
-        def mouse_move_to(element, x = nil, y = nil)
-          params = {element: element}
-
-          if x && y
-            params[:xoffset] = x
-            params[:yoffset] = y
+            if value.key?('capabilities')
+              value = value['capabilities']
+            elsif value.key?('value')
+              value = value['value']
+            end
           end
 
-          execute :mouse_move_to, {}, params
-        end
-
-        def send_keys_to_active_element(key)
-          execute :send_keys_to_active_element, {}, {value: key}
-        end
-
-        def send_keys_to_element(element, keys)
-          if @file_detector
-            local_file = @file_detector.call(keys)
-            keys = upload(local_file) if local_file
+          unless @session_id
+            raise Error::WebDriverError, 'no sessionId in returned payload'
           end
 
-          execute :send_keys_to_element, {id: element}, {value: Array(keys)}
-        end
-
-        def upload(local_file)
-          unless File.file?(local_file)
-            raise Error::WebDriverError, "you may only upload files: #{local_file.inspect}"
-          end
-
-          execute :upload_file, {}, {file: Zipper.zip_file(local_file)}
-        end
-
-        def clear_element(element)
-          execute :clear_element, id: element
-        end
-
-        def submit_element(element)
-          execute :submit_element, id: element
-        end
-
-        def drag_element(element, right_by, down_by)
-          execute :drag_element, {id: element}, {x: right_by, y: down_by}
-        end
-
-        def touch_single_tap(element)
-          execute :touch_single_tap, {}, {element: element}
-        end
-
-        def touch_double_tap(element)
-          execute :touch_double_tap, {}, {element: element}
-        end
-
-        def touch_long_press(element)
-          execute :touch_long_press, {}, {element: element}
-        end
-
-        def touch_down(x, y)
-          execute :touch_down, {}, {x: x, y: y}
-        end
-
-        def touch_up(x, y)
-          execute :touch_up, {}, {x: x, y: y}
-        end
-
-        def touch_move(x, y)
-          execute :touch_move, {}, {x: x, y: y}
-        end
-
-        def touch_scroll(element, x, y)
-          if element
-            execute :touch_scroll, {}, {element: element,
-                                       xoffset: x,
-                                       yoffset: y}
+          if oss_status
+            WebDriver.logger.info 'Detected OSS dialect.'
+            @dialect = :oss
+            Capabilities.json_create(value)
           else
-            execute :touch_scroll, {}, {xoffset: x, yoffset: y}
+            WebDriver.logger.info 'Detected W3C dialect.'
+            @dialect = :w3c
+            W3C::Capabilities.json_create(value)
           end
         end
 
-        def touch_flick(xspeed, yspeed)
-          execute :touch_flick, {}, {xspeed: xspeed, yspeed: yspeed}
-        end
-
-        def touch_element_flick(element, right_by, down_by, speed)
-          execute :touch_flick, {}, {element: element,
-                                    xoffset: right_by,
-                                    yoffset: down_by,
-                                    speed: speed}
-        end
-
-        def screen_orientation=(orientation)
-          execute :set_screen_orientation, {}, {orientation: orientation}
-        end
-
-        def screen_orientation
-          execute :get_screen_orientation
-        end
-
         #
-        # logs
+        # Returns the current session ID.
         #
 
-        def available_log_types
-          types = execute :get_available_log_types
-          Array(types).map(&:to_sym)
+        def session_id
+          @session_id || raise(Error::WebDriverError, 'no current session exists')
         end
 
-        def log(type)
-          data = execute :get_log, {}, {type: type.to_s}
-
-          Array(data).map do |l|
-            begin
-              LogEntry.new l.fetch('level', 'UNKNOWN'), l.fetch('timestamp'), l.fetch('message')
-            rescue KeyError
-              next
-            end
+        def browser
+          @browser ||= begin
+            name = @capabilities.browser_name
+            name ? name.tr(' ', '_').to_sym : 'unknown'
           end
         end
 
-        #
-        # element properties
-        #
-
-        def element_tag_name(element)
-          execute :get_element_tag_name, id: element
-        end
-
-        def element_attribute(element, name)
-          execute :get_element_attribute, id: element.ref, name: name
-        end
-
-        # Backwards compatibility for w3c
-        def element_property(element, name)
-          execute_script 'return arguments[0][arguments[1]]', element, name
-        end
-
-        def element_value(element)
-          execute :get_element_value, id: element
-        end
-
-        def element_text(element)
-          execute :get_element_text, id: element
-        end
-
-        def element_location(element)
-          data = execute :get_element_location, id: element
-
-          Point.new data['x'], data['y']
-        end
-
-        def element_rect(element)
-          loc = execute :get_element_location, id: element
-          size = execute :get_element_size, id: element
-
-          Rectangle.new loc['x'], loc['y'], size['width'], size['height']
-        end
-
-        def element_location_once_scrolled_into_view(element)
-          data = execute :get_element_location_once_scrolled_into_view, id: element
-
-          Point.new data['x'], data['y']
-        end
-
-        def element_size(element)
-          data = execute :get_element_size, id: element
-
-          Dimension.new data['width'], data['height']
-        end
-
-        def element_enabled?(element)
-          execute :is_element_enabled, id: element
-        end
-
-        def element_selected?(element)
-          execute :is_element_selected, id: element
-        end
-
-        def element_displayed?(element)
-          execute :is_element_displayed, id: element
-        end
-
-        def element_value_of_css_property(element, prop)
-          execute :get_element_value_of_css_property, id: element, property_name: prop
-        end
-
-        #
-        # finding elements
-        #
-
-        def active_element
-          Element.new self, element_id_from(execute(:get_active_element))
-        end
-
-        alias_method :switch_to_active_element, :active_element
-
-        def find_element_by(how, what, parent = nil)
-          id = if parent
-                 execute :find_child_element, {id: parent}, {using: how, value: what}
-               else
-                 execute :find_element, {}, {using: how, value: what}
-               end
-
-          Element.new self, element_id_from(id)
-        end
-
-        def find_elements_by(how, what, parent = nil)
-          ids = if parent
-                  execute :find_child_elements, {id: parent}, {using: how, value: what}
-                else
-                  execute :find_elements, {}, {using: how, value: what}
-                end
-
-          ids.map { |id| Element.new self, element_id_from(id) }
-        end
-
         private
 
-        def assert_javascript_enabled
-          return if capabilities.javascript_enabled?
-          raise Error::UnsupportedOperationError, 'underlying webdriver instance does not support javascript'
-        end
-
-        #
-        # executes a command on the remote server.
-        #
-        #
-        # Returns the 'value' of the returned payload
-        #
-
-        def execute(*args)
-          raw_execute(*args)['value']
-        end
-
         #
         # executes a command on the remote server.
         #
         # @return [WebDriver::Remote::Response]
         #
 
-        def raw_execute(command, opts = {}, command_hash = nil)
+        def execute(command, opts = {}, command_hash = nil)
           verb, path = commands(command) || raise(ArgumentError, "unknown command: #{command.inspect}")
           path = path.dup
 
-          path[':session_id'] = @session_id if path.include?(':session_id')
+          path[':session_id'] = session_id if path.include?(':session_id')
 
           begin
             opts.each { |key, value| path[key.inspect] = escaper.escape(value.to_s) }
@@ -675,12 +159,29 @@ module Selenium
           end
 
           WebDriver.logger.info("-> #{verb.to_s.upcase} #{path}")
-          http.call verb, path, command_hash
+          http.call(verb, path, command_hash)
         end
 
         def escaper
           @escaper ||= defined?(URI::Parser) ? URI::Parser.new : URI
         end
+
+        def commands(command)
+          raise NotImplementedError unless command == :new_session
+          COMMANDS[command]
+        end
+
+        def merged_capabilties(oss_capabilities)
+          w3c_capabilties = W3C::Capabilities.from_oss(oss_capabilities)
+
+          {
+            desiredCapabilities: oss_capabilities,
+            capabilities: {
+              firstMatch: [w3c_capabilties]
+            }
+          }
+        end
+
       end # Bridge
     end # Remote
   end # WebDriver