ferrum 0.11 → 0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c953c12b582e6d81031c8daa598f25d4f8b2dba8e6d736f227b2e8c461a83d41
-  data.tar.gz: 229fe35bc81a133eff2628e1b3e0e0d31d733da2b277e0dbe70c9699e80e2a15
+  metadata.gz: bde7c8e40700ace2d713cba69eee5828dcb888e5468c07a6b1e5e0d668e4c641
+  data.tar.gz: d52f7278dd76e670aa50721e6d70adc26297bbfb031ddac259dde5421c817a04
 SHA512:
-  metadata.gz: 1f48e9fac5bfbcf9959d855b1b7c7259f97d845e812f3fce6fa59dc6a3e6b5147cced16167c2a3603e964978a9d3b1e4e5b4f2c7b5b686454acaa47d1aadf6d3
-  data.tar.gz: aa9f267ea80365e636e8b047bc87e6d5fe6761814cbd1b59b3d14bc3350ccdd9e2199718ba57c774abdf5bc089ef000cdbd55d03d7dbd6158cee4c975ee9d9e0
+  metadata.gz: a7206d7a92d8483bd106fe262130492e7bf51e2db8b99f73c39ada0a674fb29c84bc948bdbb6f554b672ade9f4e3812a9158447b30d6f976cb4892b5e4e8df30
+  data.tar.gz: aef76b65c27dca2a5385d9881f9be8caccb85e804b31a26e421e35a43295baa3a5c818de856b49e3a7928139af4aeb588a5fae1cb67275440e5a0b3ddf97f76e

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019-2020 Dmitry Vorotilin
+Copyright (c) 2019-2022 Dmitry Vorotilin
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -3,7 +3,7 @@
 <img align="right"
      width="320" height="241"
      alt="Ferrum logo"
-     src="https://raw.githubusercontent.com/rubycdp/ferrum/master/logo.svg?sanitize=true">
+     src="https://raw.githubusercontent.com/rubycdp/ferrum/main/logo.svg?sanitize=true">
 
 #### As simple as Puppeteer, though even simpler.
 
@@ -23,12 +23,7 @@ going to crawl sites you better use Ferrum or
 [Vessel](https://github.com/rubycdp/vessel) because you crawl, not test.
 
 * [Vessel](https://github.com/rubycdp/vessel) high-level web crawling framework
-based on Ferrum. It looks like [Scrapy](https://scrapy.org/) except that it uses
-a real browser in order to grab data.
-
-Web design by [Evrone](https://evrone.com/), what else
-[we build with Ruby on Rails](https://evrone.com/ruby), what else
-[we do at Evrone](https://evrone.com/cases#case-studies).
+based on Ferrum and Mechanize.
 
 
 ## Index
@@ -40,7 +35,9 @@ Web design by [Evrone](https://evrone.com/), what else
 * [Navigation](https://github.com/rubycdp/ferrum#navigation)
 * [Finders](https://github.com/rubycdp/ferrum#finders)
 * [Screenshots](https://github.com/rubycdp/ferrum#screenshots)
+* [Cleaning Up](https://github.com/rubycdp/ferrum#cleaning-up)
 * [Network](https://github.com/rubycdp/ferrum#network)
+* [Proxy](https://github.com/rubycdp/ferrum#proxy)
 * [Mouse](https://github.com/rubycdp/ferrum#mouse)
 * [Keyboard](https://github.com/rubycdp/ferrum#keyboard)
 * [Cookies](https://github.com/rubycdp/ferrum#cookies)
@@ -48,9 +45,10 @@ Web design by [Evrone](https://evrone.com/), what else
 * [JavaScript](https://github.com/rubycdp/ferrum#javascript)
 * [Frames](https://github.com/rubycdp/ferrum#frames)
 * [Frame](https://github.com/rubycdp/ferrum#frame)
-* [Dialog](https://github.com/rubycdp/ferrum#dialog)
+* [Dialogs](https://github.com/rubycdp/ferrum#dialogs)
 * [Animation](https://github.com/rubycdp/ferrum#animation)
 * [Node](https://github.com/rubycdp/ferrum#node)
+* [Tracing](https://github.com/rubycdp/ferrum#tracing)
 * [Thread safety](https://github.com/rubycdp/ferrum#thread-safety)
 * [Development](https://github.com/rubycdp/ferrum#development)
 * [Contributing](https://github.com/rubycdp/ferrum#contributing)
@@ -61,7 +59,8 @@ Web design by [Evrone](https://evrone.com/), what else
 
 There's no official Chrome or Chromium package for Linux don't install it this
 way because it's either outdated or unofficial, both are bad. Download it from
-official [source](https://www.chromium.org/getting-involved/download-chromium).
+official source for [Chrome](https://www.google.com/chrome/) or
+[Chromium](https://www.chromium.org/getting-involved/download-chromium).
 Chrome binary should be in the `PATH` or `BROWSER_PATH` or you can pass it as an
 option to browser instance see `:browser_path` in
 [Customization](https://github.com/rubycdp/ferrum#customization).
@@ -155,7 +154,7 @@ Ferrum::Browser.new(options)
   * `:logger` (Object responding to `puts`) - When present, debug output is
       written to this object.
   * `:slowmo` (Integer | Float) - Set a delay in seconds to wait before sending command.
-      Usefull companion of headless option, so that you have time to see changes.
+      Useful companion of headless option, so that you have time to see changes.
   * `:timeout` (Numeric) - The number of seconds we'll wait for a response when
       communicating with browser. Default is 5.
   * `:js_errors` (Boolean) - When true, JavaScript errors get re-raised in Ruby.
@@ -173,15 +172,18 @@ Ferrum::Browser.new(options)
       options it passes to the browser, if you set this to `true` then only
       options you put in `:browser_options` will be passed to the browser,
       except required ones of course.
-  * `:port` (Integer) - Remote debugging port for headless Chrome
-  * `:host` (String) - Remote debugging address for headless Chrome
+  * `:port` (Integer) - Remote debugging port for headless Chrome.
+  * `:host` (String) - Remote debugging address for headless Chrome.
   * `:url` (String) - URL for a running instance of Chrome. If this is set, a
       browser process will not be spawned.
   * `:process_timeout` (Integer) - How long to wait for the Chrome process to
-      respond on startup
+      respond on startup.
   * `:ws_max_receive_size` (Integer) - How big messages to accept from Chrome
       over the web socket, in bytes. Defaults to 64MB. Incoming messages larger
       than this will cause a `Ferrum::DeadBrowserError`.
+  * `:proxy` (Hash) - Specify proxy settings, [read more](https://github.com/rubycdp/ferrum#proxy)
+  * `:save_path` (String) - Path to save attachments with [Content-Disposition](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition) header.
+  * `:env` (Hash) - Environment variables you'd like to pass through to the process
 
 
 ## Navigation
@@ -407,9 +409,28 @@ browser.mhtml(path: "google.mhtml") # => 87742
 ```
 
 
+## Cleaning Up
+
+#### reset
+
+Closes browser tabs opened by the `Browser` instance.
+
+```ruby
+# connect to a long-running Chrome process
+browser = Ferrum::Browser.new(url: 'http://localhost:9222')
+
+browser.go_to("https://github.com/")
+
+# clean up, lest the tab stays there hanging forever
+browser.reset
+
+browser.quit
+```
+
+
 ## Network
 
-browser.network
+`browser.network`
 
 #### traffic `Array<Network::Exchange>`
 
@@ -542,17 +563,78 @@ end
 browser.network.authorize(user: "login", password: "pass", type: :proxy)
 
 browser.go_to("https://google.com")
-
 ```
 
 You used to call `authorize` method without block, but since it's implemented using request interception there could be
 a collision with another part of your code that also uses request interception, so that authorize allows the request
 while your code denies but it's too late. The block is mandatory now.
 
+#### emulate_network_conditions(\*\*options)
+
+Activates emulation of network conditions.
+
+* options `Hash`
+  * :offline `Boolean` emulate internet disconnection, `false` by default
+  * :latency `Integer` minimum latency from request sent to response headers received (ms), `0` by
+    default
+  * :download_throughput `Integer` maximal aggregated download throughput (bytes/sec), `-1`
+    by default, disables download throttling
+  * :upload_throughput `Integer` maximal aggregated upload throughput (bytes/sec), `-1`
+    by default, disables download throttling
+  * :connection_type `String` connection type if known, one of: none, cellular2g, cellular3g, cellular4g,
+    bluetooth, ethernet, wifi, wimax, other. `nil` by default
+
+```ruby
+browser.network.emulate_network_conditions(connection_type: "cellular2g")
+browser.go_to("https://github.com/")
+```
+
+#### offline_mode
+
+Activates offline mode for a page.
+
+```ruby
+browser.network.offline_mode
+browser.go_to("https://github.com/") # => Ferrum::StatusError (Request to https://github.com/ failed to reach server, check DNS and server status)
+```
+
+
+## Proxy
+
+You can set a proxy with a `:proxy` option:
+
+```ruby
+browser = Ferrum::Browser.new(proxy: { host: "x.x.x.x", port: "8800", user: "user", password: "pa$$" })
+```
+
+`:bypass` can specify semi-colon-separated list of hosts for which proxy shouldn't be used:
+
+```ruby
+browser = Ferrum::Browser.new(proxy: { host: "x.x.x.x", port: "8800", bypass: "*.google.com;*foo.com" })
+```
+
+In general passing a proxy option when instantiating a browser results in a browser running with proxy command line
+flags, so that it affects all pages and contexts. You can create a page in a new context which can use its own proxy
+settings:
+
+```ruby
+browser = Ferrum::Browser.new
+
+browser.create_page(proxy: { host: "x.x.x.x", port: 31337, user: "user", password: "password" }) do |page|
+  page.go_to("https://api.ipify.org?format=json")
+  page.body # => "x.x.x.x"
+end
+
+browser.create_page(proxy: { host: "y.y.y.y", port: 31337, user: "user", password: "password" }) do |page|
+  page.go_to("https://api.ipify.org?format=json")
+  page.body # => "y.y.y.y"
+end
+```
+
 
 ### Mouse
 
-browser.mouse
+`browser.mouse`
 
 #### scroll_to(x, y)
 
@@ -639,13 +721,12 @@ Returns bitfield for a given keys
 
 ## Cookies
 
-browser.cookies
+`browser.cookies`
 
 #### all : `Hash<String, Cookie>`
 
 Returns cookies hash
 
-
 ```ruby
 browser.cookies.all # => {"NID"=>#<Ferrum::Cookies::Cookie:0x0000558624b37a40 @attributes={"name"=>"NID", "value"=>"...", "domain"=>".google.com", "path"=>"/", "expires"=>1583211046.575681, "size"=>178, "httpOnly"=>true, "secure"=>false, "session"=>false}>}
 ```
@@ -660,11 +741,11 @@ Returns cookie
 browser.cookies["NID"] # => <Ferrum::Cookies::Cookie:0x0000558624b67a88 @attributes={"name"=>"NID", "value"=>"...", "domain"=>".google.com", "path"=>"/", "expires"=>1583211046.575681, "size"=>178, "httpOnly"=>true, "secure"=>false, "session"=>false}>
 ```
 
-#### set(\*\*options) : `Boolean`
+#### set(value) : `Boolean`
 
-Sets given values as cookie
+Sets a cookie
 
-* options `Hash`
+* value `Hash`
   * :name `String`
   * :value `String`
   * :domain `String`
@@ -676,6 +757,13 @@ Sets given values as cookie
 browser.cookies.set(name: "stealth", value: "omg", domain: "google.com") # => true
 ```
 
+* value `Cookie`
+
+```ruby
+nid_cookie = browser.cookies["NID"] # => <Ferrum::Cookies::Cookie:0x0000558624b67a88>
+browser.cookies.set(nid_cookie) # => true
+```
+
 #### remove(\*\*options) : `Boolean`
 
 Removes given cookie
@@ -699,7 +787,7 @@ browser.cookies.clear # => true
 
 ## Headers
 
-browser.headers
+`browser.headers`
 
 #### get : `Hash`
 
@@ -798,9 +886,10 @@ browser.add_script_tag(url: "http://example.com/stylesheet.css") # => true
 browser.add_style_tag(content: "h1 { font-size: 40px; }") # => true
 
 ```
-#### bypass_csp(enabled) : `Boolean`
+#### bypass_csp(\*\*options) : `Boolean`
 
-* enabled `Boolean`, `true` by default
+* options `Hash`
+  * :enabled `Boolean`, `true` by default
 
 ```ruby
 browser.bypass_csp # => true
@@ -941,7 +1030,7 @@ browser.go_to("https://www.w3schools.com/tags/tag_frame.asp")
 browser.main_frame.doctype # => "<!DOCTYPE html>"
 ```
 
-#### set_content(html)
+#### content = html
 
 Sets a content of a given frame.
 
@@ -951,12 +1040,12 @@ Sets a content of a given frame.
 browser.go_to("https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe")
 frame = browser.frames[1]
 frame.body # <html lang="en"><head><style>body {transition: opacity ease-in 0.2s; }...
-frame.set_content("<html><head></head><body><p>lol</p></body></html>")
+frame.content = "<html><head></head><body><p>lol</p></body></html>"
 frame.body # => <html><head></head><body><p>lol</p></body></html>
 ```
 
 
-## Dialog
+## Dialogs
 
 #### accept(text)
 
@@ -1008,7 +1097,16 @@ browser.playback_rate # => 2000
 
 #### node? : `Boolean`
 #### frame_id
-#### frame
+#### frame  : `Frame`
+
+Returns [Frame](https://github.com/rubycdp/ferrum#frame) object for current node, you can keep using
+[Finders](https://github.com/rubycdp/ferrum#Finders) for that object:
+
+```ruby
+frame =  browser.at_xpath("//iframe").frame # => Frame
+frame.at_css("//a[text() = 'Log in']") # => Node
+```
+
 #### focus
 #### focusable?
 #### moving? : `Boolean`
@@ -1028,6 +1126,49 @@ browser.playback_rate # => 2000
 #### property
 #### attribute
 #### evaluate
+#### selected : `Array<Node>`
+#### select
+
+(chainable) Selects options by passed attribute.
+
+```ruby
+browser.at_xpath("//*[select]").select(["1"]) # => Node (select)
+browser.at_xpath("//*[select]").select(["text"], by: :text) # => Node (select)
+```
+
+Accept string, array or strings:
+```ruby
+browser.at_xpath("//*[select]").select("1")
+browser.at_xpath("//*[select]").select("1", "2")
+browser.at_xpath("//*[select]").select(["1", "2"])
+```
+
+
+## Tracing
+
+You can use `tracing.record` to create a trace file which can be opened in Chrome DevTools or
+[timeline viewer](https://chromedevtools.github.io/timeline-viewer/).
+
+```ruby
+page.tracing.record(path: "trace.json") do
+  page.go_to("https://www.google.com")
+end
+```
+
+#### tracing.record(\*\*options) : `String`
+
+Accepts block, records trace and by default returns trace data from `Tracing.tracingComplete` event as output. When
+`path` is specified returns `true` and stores trace data into file.
+
+* options `Hash`
+  * :path `String` save data on the disk, `nil` by default
+  * :encoding `Symbol` `:base64` | `:binary` encode output as Base64 or plain text. `:binary` by default
+  * :timeout `Float` wait until file streaming finishes in the specified time or raise error, defaults to `nil`
+  * :screenshots `Boolean` capture screenshots in the trace, `false` by default
+  * :trace_config `Hash<String, Object>` config for
+    [trace](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#type-TraceConfig), for categories
+    see [getCategories](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#method-getCategories),
+    only one trace config can be active at a time per browser.
 
 
 ## Thread safety ##
@@ -1091,9 +1232,12 @@ browser.quit
 
 After checking out the repo, run `bundle install` to install dependencies.
 
-Then, run `bundle exec rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Then, run `bundle exec rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will
+allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the
+version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version,
+push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 
 ## Contributing

data/lib/ferrum/browser/binary.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Ferrum
+  class Browser
+    module Binary
+      module_function
+
+      def find(commands)
+        enum(commands).first
+      end
+
+      def all(commands)
+        enum(commands).force
+      end
+
+      def enum(commands)
+        paths, exts = prepare_paths
+        cmds = Array(commands).product(paths, exts)
+        lazy_find(cmds)
+      end
+
+      def prepare_paths
+        exts = (ENV.key?("PATHEXT") ? ENV.fetch("PATHEXT").split(";") : []) << ""
+        paths = ENV["PATH"].split(File::PATH_SEPARATOR)
+        raise EmptyPathError if paths.empty?
+
+        [paths, exts]
+      end
+
+      # rubocop:disable Style/CollectionCompact
+      def lazy_find(cmds)
+        cmds.lazy.map do |cmd, path, ext|
+          absolute_path = File.absolute_path(cmd)
+          is_absolute_path = absolute_path == cmd
+          cmd = File.expand_path("#{cmd}#{ext}", path) unless is_absolute_path
+
+          next unless File.executable?(cmd)
+          next if File.directory?(cmd)
+
+          cmd
+        end.reject(&:nil?) # .compact isn't defined on Enumerator::Lazy
+      end
+      # rubocop:enable Style/CollectionCompact
+    end
+  end
+end

data/lib/ferrum/browser/client.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "concurrent-ruby"
 require "ferrum/browser/subscriber"
 require "ferrum/browser/web_socket"
 
@@ -9,22 +8,23 @@ module Ferrum
     class Client
       INTERRUPTIONS = %w[Fetch.requestPaused Fetch.authRequired].freeze
 
-      def initialize(browser, ws_url, id_starts_with: 0)
-        @browser = browser
+      def initialize(ws_url, connectable, logger: nil, ws_max_receive_size: nil, id_starts_with: 0)
+        @connectable = connectable
         @command_id = id_starts_with
         @pendings = Concurrent::Hash.new
-        @ws = WebSocket.new(ws_url, @browser.ws_max_receive_size, @browser.logger)
-        @subscriber, @interruptor = Subscriber.build(2)
+        @ws = WebSocket.new(ws_url, ws_max_receive_size, logger)
+        @subscriber, @interrupter = Subscriber.build(2)
 
         @thread = Thread.new do
           Thread.current.abort_on_exception = true
-          if Thread.current.respond_to?(:report_on_exception=)
-            Thread.current.report_on_exception = true
-          end
+          Thread.current.report_on_exception = true if Thread.current.respond_to?(:report_on_exception=)
+
+          loop do
+            message = @ws.messages.pop
+            break unless message
 
-          while message = @ws.messages.pop
             if INTERRUPTIONS.include?(message["method"])
-              @interruptor.async.call(message)
+              @interrupter.async.call(message)
             elsif message.key?("method")
               @subscriber.async.call(message)
             else
@@ -39,11 +39,12 @@ module Ferrum
         message = build_message(method, params)
         @pendings[message[:id]] = pending
         @ws.send_message(message)
-        data = pending.value!(@browser.timeout)
+        data = pending.value!(@connectable.timeout)
         @pendings.delete(message[:id])
 
         raise DeadBrowserError if data.nil? && @ws.messages.closed?
         raise TimeoutError unless data
+
         error, response = data.values_at("error", "result")
         raise_browser_error(error) if error
         response
@@ -52,14 +53,14 @@ module Ferrum
       def on(event, &block)
         case event
         when *INTERRUPTIONS
-          @interruptor.on(event, &block)
+          @interrupter.on(event, &block)
         else
           @subscriber.on(event, &block)
         end
       end
 
       def subscribed?(event)
-        [@interruptor, @subscriber].any? { |s| s.subscribed?(event) }
+        [@interrupter, @subscriber].any? { |s| s.subscribed?(event) }
       end
 
       def close
@@ -84,16 +85,16 @@ module Ferrum
         # Node has disappeared while we were trying to get it
         when "No node with given id found",
              "Could not find node with given id"
-          raise NodeNotFoundError.new(error)
+          raise NodeNotFoundError, error
         # Context is lost, page is reloading
         when "Cannot find context with specified id"
-          raise NoExecutionContextError.new(error)
+          raise NoExecutionContextError, error
         when "No target with given id found"
           raise NoSuchPageError
         when /Could not compute content quads/
           raise CoordinatesNotFoundError
         else
-          raise BrowserError.new(error)
+          raise BrowserError, error
         end
       end
     end

data/lib/ferrum/browser/command.rb

@@ -5,12 +5,12 @@ module Ferrum
     class Command
       NOT_FOUND = "Could not find an executable for the browser. Try to make " \
                   "it available on the PATH or set environment variable for " \
-                  "example BROWSER_PATH=\"/usr/bin/chrome\"".freeze
+                  "example BROWSER_PATH=\"/usr/bin/chrome\""
 
       # Currently only these browsers support CDP:
       # https://github.com/cyrus-and/chrome-remote-interface#implementations
       def self.build(options, user_data_dir)
-        defaults = case options[:browser_name]
+        defaults = case options.browser_name
                    when :firefox
                      Options::Firefox.options
                    when :chrome, :opera, :edge, nil
@@ -27,14 +27,16 @@ module Ferrum
       def initialize(defaults, options, user_data_dir)
         @flags = {}
         @defaults = defaults
-        @options, @user_data_dir = options, user_data_dir
-        @path = options[:browser_path] || ENV["BROWSER_PATH"] || defaults.detect_path
-        raise Cliver::Dependency::NotFound.new(NOT_FOUND) unless @path
+        @options = options
+        @user_data_dir = user_data_dir
+        @path = options.browser_path || ENV.fetch("BROWSER_PATH", nil) || defaults.detect_path
+        raise BinaryNotFoundError, NOT_FOUND unless @path
+
         merge_options
       end
 
       def xvfb?
-        !!options[:xvfb]
+        !!options.xvfb
       end
 
       def to_a
@@ -45,12 +47,8 @@ module Ferrum
 
       def merge_options
         @flags = defaults.merge_required(@flags, options, @user_data_dir)
-
-        unless options[:ignore_default_browser_options]
-          @flags = defaults.merge_default(@flags, options)
-        end
-
-        @flags.merge!(options.fetch(:browser_options, {}))
+        @flags = defaults.merge_default(@flags, options) unless options.ignore_default_browser_options
+        @flags.merge!(options.browser_options)
       end
     end
   end

data/lib/ferrum/browser/options/base.rb

@@ -4,11 +4,8 @@ require "singleton"
 
 module Ferrum
   class Browser
-    module Options
+    class Options
       class Base
-        BROWSER_HOST = "127.0.0.1"
-        BROWSER_PORT = "0"
-
         include Singleton
 
         def self.options
@@ -24,13 +21,7 @@ module Ferrum
         end
 
         def detect_path
-          if Ferrum.mac?
-            self.class::MAC_BIN_PATH.find { |n| File.exist?(n) }
-          else
-            self.class::LINUX_BIN_PATH.find do |name|
-              path = Cliver.detect(name) and break(path)
-            end
-          end
+          Binary.find(self.class::PLATFORM_PATH[Utils::Platform.name])
         end
 
         def merge_required(flags, options, user_data_dir)

data/lib/ferrum/browser/options/chrome.rb

@@ -2,7 +2,7 @@
 
 module Ferrum
   class Browser
-    module Options
+    class Options
       class Chrome < Base
         DEFAULT_OPTIONS = {
           "headless" => nil,
@@ -36,34 +36,45 @@ module Ferrum
           "metrics-recording-only" => nil,
           "safebrowsing-disable-auto-update" => nil,
           "password-store" => "basic",
-          "no-startup-window" => nil,
-          # Note: --no-sandbox is not needed if you properly setup a user in the container.
+          "no-startup-window" => nil
+          # NOTE: --no-sandbox is not needed if you properly setup a user in the container.
           # https://github.com/ebidel/lighthouse-ci/blob/master/builder/Dockerfile#L35-L40
           # "no-sandbox" => nil,
         }.freeze
 
         MAC_BIN_PATH = [
-          "/Applications/Chromium.app/Contents/MacOS/Chromium",
-          "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+          "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+          "/Applications/Chromium.app/Contents/MacOS/Chromium"
         ].freeze
-        LINUX_BIN_PATH = %w[chromium google-chrome-unstable google-chrome-beta
-                            google-chrome chrome chromium-browser
-                            google-chrome-stable].freeze
+        LINUX_BIN_PATH = %w[chrome google-chrome google-chrome-stable google-chrome-beta
+                            chromium chromium-browser google-chrome-unstable].freeze
+        WINDOWS_BIN_PATH = [
+          "C:/Program Files/Google/Chrome/Application/chrome.exe",
+          "C:/Program Files/Google/Chrome Dev/Application/chrome.exe"
+        ].freeze
+        PLATFORM_PATH = {
+          mac: MAC_BIN_PATH,
+          windows: WINDOWS_BIN_PATH,
+          linux: LINUX_BIN_PATH
+        }.freeze
 
         def merge_required(flags, options, user_data_dir)
-          port = options.fetch(:port, BROWSER_PORT)
-          host = options.fetch(:host, BROWSER_HOST)
-          flags.merge("remote-debugging-port" => port,
-                      "remote-debugging-address" => host,
-                      # Doesn't work on MacOS, so we need to set it by CDP
-                      "window-size" => options[:window_size].join(","),
-                      "user-data-dir" => user_data_dir)
+          flags = flags.merge("remote-debugging-port" => options.port,
+                              "remote-debugging-address" => options.host,
+                              # Doesn't work on MacOS, so we need to set it by CDP
+                              "window-size" => options.window_size&.join(","),
+                              "user-data-dir" => user_data_dir)
+
+          if options.proxy
+            flags.merge!("proxy-server" => "#{options.proxy[:host]}:#{options.proxy[:port]}")
+            flags.merge!("proxy-bypass-list" => options.proxy[:bypass]) if options.proxy[:bypass]
+          end
+
+          flags
         end
 
         def merge_default(flags, options)
-          unless options.fetch(:headless, true)
-            defaults = except("headless", "disable-gpu")
-          end
+          defaults = except("headless", "disable-gpu") unless options.headless
 
           defaults ||= DEFAULT_OPTIONS
           defaults.merge(flags)