puppeteer-ruby 0.0.22 → 0.28.1

data/lib/puppeteer/geolocation.rb

@@ -0,0 +1,24 @@
+class Puppeteer::Geolocation
+  # @param latitude [Fixnum]
+  # @param longitude [Fixnum]
+  # @param accuracy [Fixnum]
+  def initialize(latitude:, longitude:, accuracy: 0)
+    unless (-180..180).include?(longitude)
+      raise ArgumentError.new("Invalid longitude \"#{longitude}\": precondition -180 <= LONGITUDE <= 180 failed.")
+    end
+    unless (-90..90).include?(latitude)
+      raise ArgumentError.new("Invalid latitude \"#{latitude}\": precondition -90 <= LATITUDE <= 90 failed.")
+    end
+    if accuracy < 0
+      raise ArgumentError.new("Invalid accuracy \"#{longitude}\": precondition 0 <= ACCURACY failed.")
+    end
+
+    @latitude = latitude
+    @longitude = longitude
+    @accuracy = accuracy
+  end
+
+  def to_h
+    { latitude: @latitude, longitude: @longitude, accuracy: @accuracy }
+  end
+end

data/lib/puppeteer/launcher/chrome.rb

@@ -92,7 +92,7 @@ module Puppeteer::Launcher
           '--disable-default-apps',
           '--disable-dev-shm-usage',
           '--disable-extensions',
-          '--disable-features=TranslateUI',
+          '--disable-features=Translate',
           '--disable-hang-monitor',
           '--disable-ipc-flooding-protection',
           '--disable-popup-blocking',
@@ -105,6 +105,9 @@ module Puppeteer::Launcher
           '--enable-automation',
           '--password-store=basic',
           '--use-mock-keychain',
+          # TODO(sadym): remove '--enable-blink-features=IdleDetection'
+          # once IdleDetection is turned on by default.
+          '--enable-blink-features=IdleDetection',
         ]
 
         if chrome_arg_options.user_data_dir

data/lib/puppeteer/lifecycle_watcher.rb

@@ -69,17 +69,17 @@ class Puppeteer::LifecycleWatcher
     @timeout = timeout
 
     @listener_ids = {}
-    @listener_ids['client'] = @frame_manager.client.add_event_listener('Events.CDPSession.Disconnected') do
+    @listener_ids['client'] = @frame_manager.client.add_event_listener(CDPSessionEmittedEvents::Disconnected) do
       terminate(TerminatedError.new('Navigation failed because browser has disconnected!'))
     end
     @listener_ids['frame_manager'] = [
-      @frame_manager.add_event_listener('Events.FrameManager.LifecycleEvent') do |_|
+      @frame_manager.add_event_listener(FrameManagerEmittedEvents::LifecycleEvent) do |_|
         check_lifecycle_complete
       end,
-      @frame_manager.add_event_listener('Events.FrameManager.FrameNavigatedWithinDocument', &method(:navigated_within_document)),
-      @frame_manager.add_event_listener('Events.FrameManager.FrameDetached', &method(:handle_frame_detached)),
+      @frame_manager.add_event_listener(FrameManagerEmittedEvents::FrameNavigatedWithinDocument, &method(:navigated_within_document)),
+      @frame_manager.add_event_listener(FrameManagerEmittedEvents::FrameDetached, &method(:handle_frame_detached)),
     ]
-    @listener_ids['network_manager'] = @frame_manager.network_manager.add_event_listener('Events.NetworkManager.Request', &method(:handle_request))
+    @listener_ids['network_manager'] = @frame_manager.network_manager.add_event_listener(NetworkManagerEmittedEvents::Request, &method(:handle_request))
 
     @same_document_navigation_promise = resolvable_future
     @lifecycle_promise = resolvable_future
@@ -128,7 +128,7 @@ class Puppeteer::LifecycleWatcher
           @termination_promise.value!
         end
       rescue Timeout::Error
-        raise Puppeteer::FrameManager::NavigationError.new("Navigation timeout of #{@timeout}ms exceeded")
+        raise Puppeteer::TimeoutError.new("Navigation timeout of #{@timeout}ms exceeded")
       end
     else
       @termination_promise

data/lib/puppeteer/network_manager.rb

@@ -212,7 +212,7 @@ class Puppeteer::NetworkManager
     frame = if_present(event['frameId']) { |frame_id| @frame_manager.frame(frame_id) }
     request = Puppeteer::Request.new(@client, frame, interception_id, @user_request_interception_enabled, event, redirect_chain)
     @request_id_to_request[event['requestId']] = request
-    emit_event 'Events.NetworkManager.Request', request
+    emit_event(NetworkManagerEmittedEvents::Request, request)
   end
 
   private def handle_request_served_from_cache(event)
@@ -230,8 +230,8 @@ class Puppeteer::NetworkManager
     response.internal.body_loaded_promise.reject(Puppeteer::Response::Redirected.new)
     @request_id_to_request.delete(request.internal.request_id)
     @attempted_authentications.delete(request.internal.interception_id)
-    emit_event 'Events.NetworkManager.Response', response
-    emit_event 'Events.NetworkManager.RequestFinished', request
+    emit_event(NetworkManagerEmittedEvents::Response, response)
+    emit_event(NetworkManagerEmittedEvents::RequestFinished, request)
   end
 
   # @param event [Hash]
@@ -242,7 +242,7 @@ class Puppeteer::NetworkManager
 
     response = Puppeteer::Response.new(@client, request, event['response'])
     request.internal.response = response
-    emit_event 'Events.NetworkManager.Response', response
+    emit_event(NetworkManagerEmittedEvents::Response, response)
   end
 
   private def handle_loading_finished(event)
@@ -260,7 +260,7 @@ class Puppeteer::NetworkManager
 
     @request_id_to_request.delete(request.internal.request_id)
     @attempted_authentications.delete(request.internal.interception_id)
-    emit_event 'Events.NetworkManager.RequestFinished', request
+    emit_event(NetworkManagerEmittedEvents::RequestFinished, request)
   end
 
   private def handle_loading_failed(event)
@@ -275,6 +275,6 @@ class Puppeteer::NetworkManager
     end
     @request_id_to_request.delete(request.internal.request_id)
     @attempted_authentications.delete(request.internal.interception_id)
-    emit_event 'Events.NetworkManager.RequestFailed', request
+    emit_event(NetworkManagerEmittedEvents::RequestFailed, request)
   end
 end

data/lib/puppeteer/page.rb

@@ -3,6 +3,7 @@ require "stringio"
 
 require_relative './page/pdf_options'
 require_relative './page/screenshot_options'
+require_relative './page/screenshot_task_queue'
 
 class Puppeteer::Page
   include Puppeteer::EventCallbackable
@@ -13,10 +14,9 @@ class Puppeteer::Page
   # @param {!Puppeteer.Target} target
   # @param {boolean} ignoreHTTPSErrors
   # @param {?Puppeteer.Viewport} defaultViewport
-  # @param {!Puppeteer.TaskQueue} screenshotTaskQueue
   # @return {!Promise<!Page>}
-  def self.create(client, target, ignore_https_errors, default_viewport, screenshot_task_queue)
-    page = Puppeteer::Page.new(client, target, ignore_https_errors, screenshot_task_queue)
+  def self.create(client, target, ignore_https_errors, default_viewport)
+    page = Puppeteer::Page.new(client, target, ignore_https_errors)
     page.init
     if default_viewport
       page.viewport = default_viewport
@@ -27,8 +27,7 @@ class Puppeteer::Page
   # @param {!Puppeteer.CDPSession} client
   # @param {!Puppeteer.Target} target
   # @param {boolean} ignoreHTTPSErrors
-  # @param {!Puppeteer.TaskQueue} screenshotTaskQueue
-  def initialize(client, target, ignore_https_errors, screenshot_task_queue)
+  def initialize(client, target, ignore_https_errors)
     @closed = false
     @client = client
     @target = target
@@ -43,10 +42,10 @@ class Puppeteer::Page
     @page_bindings = {}
     # @coverage = Coverage.new(client)
     @javascript_enabled = true
-    @screenshot_task_queue = screenshot_task_queue
+    @screenshot_task_queue = ScreenshotTaskQueue.new
 
     @workers = {}
-    @client.on_event 'Target.attachedToTarget' do |event|
+    @client.on_event('Target.attachedToTarget') do |event|
       if event['targetInfo']['type'] != 'worker'
         # If we don't detach from service workers, they will never die.
         await @client.send_message('Target.detachFromTarget', sessionId: event['sessionId'])
@@ -56,65 +55,69 @@ class Puppeteer::Page
       session = Puppeteer::Connection.from_session(@client).session(event['sessionId']) # rubocop:disable Lint/UselessAssignment
       #   const worker = new Worker(session, event.targetInfo.url, this._addConsoleMessage.bind(this), this._handleException.bind(this));
       #   this._workers.set(event.sessionId, worker);
-      #   this.emit(Events.Page.WorkerCreated, worker);
+      #   this.emit(PageEmittedEvents::WorkerCreated, worker);
     end
-    @client.on_event 'Target.detachedFromTarget' do |event|
+    @client.on_event('Target.detachedFromTarget') do |event|
       session_id = event['sessionId']
       worker = @workers[session_id]
       next unless worker
 
-      emit_event('Events.Page.WorkerDestroyed', worker)
+      emit_event(PageEmittedEvents::WorkerDestroyed, worker)
       @workers.delete(session_id)
     end
 
-    @frame_manager.on_event 'Events.FrameManager.FrameAttached' do |event|
-      emit_event 'Events.Page.FrameAttached', event
+    @frame_manager.on_event(FrameManagerEmittedEvents::FrameAttached) do |event|
+      emit_event(PageEmittedEvents::FrameAttached, event)
     end
-    @frame_manager.on_event 'Events.FrameManager.FrameDetached' do |event|
-      emit_event 'Events.Page.FrameDetached', event
+    @frame_manager.on_event(FrameManagerEmittedEvents::FrameDetached) do |event|
+      emit_event(PageEmittedEvents::FrameDetached, event)
     end
-    @frame_manager.on_event 'Events.FrameManager.FrameNavigated' do |event|
-      emit_event 'Events.Page.FrameNavigated', event
+    @frame_manager.on_event(FrameManagerEmittedEvents::FrameNavigated) do |event|
+      emit_event(PageEmittedEvents::FrameNavigated, event)
     end
 
     network_manager = @frame_manager.network_manager
-    network_manager.on_event 'Events.NetworkManager.Request' do |event|
-      emit_event 'Events.Page.Request', event
+    network_manager.on_event(NetworkManagerEmittedEvents::Request) do |event|
+      emit_event(PageEmittedEvents::Request, event)
     end
-    network_manager.on_event 'Events.NetworkManager.Response' do |event|
-      emit_event 'Events.Page.Response', event
+    network_manager.on_event(NetworkManagerEmittedEvents::Response) do |event|
+      emit_event(PageEmittedEvents::Response, event)
     end
-    network_manager.on_event 'Events.NetworkManager.RequestFailed' do |event|
-      emit_event 'Events.Page.RequestFailed', event
+    network_manager.on_event(NetworkManagerEmittedEvents::RequestFailed) do |event|
+      emit_event(PageEmittedEvents::RequestFailed, event)
     end
-    network_manager.on_event 'Events.NetworkManager.RequestFinished' do |event|
-      emit_event 'Events.Page.RequestFinished', event
+    network_manager.on_event(NetworkManagerEmittedEvents::RequestFinished) do |event|
+      emit_event(PageEmittedEvents::RequestFinished, event)
     end
     @file_chooser_interception_is_disabled = false
     @file_chooser_interceptors = Set.new
 
-    @client.on_event 'Page.domContentEventFired' do |event|
-      emit_event 'Events.Page.DOMContentLoaded'
+    @client.on_event('Page.domContentEventFired') do |event|
+      emit_event(PageEmittedEvents::DOMContentLoaded)
     end
-    @client.on_event 'Page.loadEventFired' do |event|
-      emit_event 'Events.Page.Load'
+    @client.on_event('Page.loadEventFired') do |event|
+      emit_event(PageEmittedEvents::Load)
     end
     # client.on('Runtime.consoleAPICalled', event => this._onConsoleAPI(event));
     # client.on('Runtime.bindingCalled', event => this._onBindingCalled(event));
-    @client.on_event 'Page.javascriptDialogOpening' do |event|
+    @client.on_event('Page.javascriptDialogOpening') do |event|
       handle_dialog_opening(event)
     end
-    # client.on('Runtime.exceptionThrown', exception => this._handleException(exception.exceptionDetails));
-    # client.on('Inspector.targetCrashed', event => this._onTargetCrashed());
+    @client.on_event('Runtime.exceptionThrown') do |exception|
+      handle_exception(exception['exceptionDetails'])
+    end
+    @client.on_event('Inspector.targetCrashed') do |event|
+      handle_target_crashed
+    end
     # client.on('Performance.metrics', event => this._emitMetrics(event));
-    @client.on_event 'Log.entryAdded' do |event|
+    @client.on_event('Log.entryAdded') do |event|
       handle_log_entry_added(event)
     end
-    @client.on_event 'Page.fileChooserOpened' do |event|
+    @client.on_event('Page.fileChooserOpened') do |event|
       handle_file_chooser(event)
     end
     @target.is_closed_promise.then do
-      emit_event 'Events.Page.Close'
+      emit_event(PageEmittedEvents::Close)
       @closed = true
     end
   end
@@ -128,43 +131,22 @@ class Puppeteer::Page
     )
   end
 
-  EVENT_MAPPINGS = {
-    close: 'Events.Page.Close',
-    # console: 'Events.Page.Console',
-    dialog: 'Events.Page.Dialog',
-    domcontentloaded: 'Events.Page.DOMContentLoaded',
-    # error:
-    frameattached: 'Events.Page.FrameAttached',
-    framedetached: 'Events.Page.FrameDetached',
-    framenavigated: 'Events.Page.FrameNavigated',
-    load: 'Events.Page.Load',
-    # metrics: 'Events.Page.Metrics',
-    # pageerror: 'Events.Page.PageError',
-    popup: 'Events.Page.Popup',
-    request: 'Events.Page.Request',
-    requestfailed: 'Events.Page.RequestFailed',
-    requestfinished: 'Events.Page.RequestFinished',
-    response: 'Events.Page.Response',
-    # workercreated: 'Events.Page.WorkerCreated',
-    # workerdestroyed: 'Events.Page.WorkerDestroyed',
-  }
-
   # @param event_name [Symbol]
   def on(event_name, &block)
-    unless EVENT_MAPPINGS.has_key?(event_name.to_sym)
-      raise ArgumentError.new("Unknown event name: #{event_name}. Known events are #{EVENT_MAPPINGS.keys.join(", ")}")
+    unless PageEmittedEvents.values.include?(event_name.to_s)
+      raise ArgumentError.new("Unknown event name: #{event_name}. Known events are #{PageEmittedEvents.values.to_a.join(", ")}")
     end
 
-    add_event_listener(EVENT_MAPPINGS[event_name.to_sym], &block)
+    super(event_name.to_s, &block)
   end
 
   # @param event_name [Symbol]
   def once(event_name, &block)
-    unless EVENT_MAPPINGS.has_key?(event_name.to_sym)
-      raise ArgumentError.new("Unknown event name: #{event_name}. Known events are #{EVENT_MAPPINGS.keys.join(", ")}")
+    unless PageEmittedEvents.values.include?(event_name.to_s)
+      raise ArgumentError.new("Unknown event name: #{event_name}. Known events are #{PageEmittedEvents.values.to_a.join(", ")}")
     end
 
-    observe_first(EVENT_MAPPINGS[event_name.to_sym], &block)
+    super(event_name.to_s, &block)
   end
 
   def handle_file_chooser(event)
@@ -211,19 +193,10 @@ class Puppeteer::Page
 
   define_async_method :async_wait_for_file_chooser
 
-  # /**
-  #  * @param {!{longitude: number, latitude: number, accuracy: (number|undefined)}} options
-  #  */
-  # async setGeolocation(options) {
-  #   const { longitude, latitude, accuracy = 0} = options;
-  #   if (longitude < -180 || longitude > 180)
-  #     throw new Error(`Invalid longitude "${longitude}": precondition -180 <= LONGITUDE <= 180 failed.`);
-  #   if (latitude < -90 || latitude > 90)
-  #     throw new Error(`Invalid latitude "${latitude}": precondition -90 <= LATITUDE <= 90 failed.`);
-  #   if (accuracy < 0)
-  #     throw new Error(`Invalid accuracy "${accuracy}": precondition 0 <= ACCURACY failed.`);
-  #   await this._client.send('Emulation.setGeolocationOverride', {longitude, latitude, accuracy});
-  # }
+  # @param [Puppeteer::Geolocation]
+  def geolocation=(geolocation)
+    @client.send_message('Emulation.setGeolocationOverride', geolocation.to_h)
+  end
 
   attr_reader :javascript_enabled, :target
 
@@ -238,7 +211,7 @@ class Puppeteer::Page
   class TargetCrashedError < StandardError; end
 
   private def handle_target_crashed
-    emit_event 'error', TargetCrashedError.new('Page crashed!')
+    emit_event(PageEmittedEvents::Error, TargetCrashedError.new('Page crashed!'))
   end
 
   private def handle_log_entry_added(event)
@@ -259,7 +232,7 @@ class Puppeteer::Page
         url: url,
         line_number: line_number,
       )
-      emit_event('Events.Page.Console',
+      emit_event(PageEmittedEvents::Console,
         Puppeteer::ConsoleMessage.new(level, text, [], console_message_location))
     end
   end
@@ -367,47 +340,34 @@ class Puppeteer::Page
 
   define_async_method :async_Sx
 
-  # /**
-  #  * @param {!Array<string>} urls
-  #  * @return {!Promise<!Array<Network.Cookie>>}
-  #  */
-  # async cookies(...urls) {
-  #   return (await this._client.send('Network.getCookies', {
-  #     urls: urls.length ? urls : [this.url()]
-  #   })).cookies;
-  # }
+  # @return [Array<Hash>]
+  def cookies(*urls)
+    @client.send_message('Network.getCookies', urls: (urls.empty? ? [url] : urls))['cookies']
+  end
 
-  # /**
-  #  * @param {Array<Protocol.Network.deleteCookiesParameters>} cookies
-  #  */
-  # async deleteCookie(...cookies) {
-  #   const pageURL = this.url();
-  #   for (const cookie of cookies) {
-  #     const item = Object.assign({}, cookie);
-  #     if (!cookie.url && pageURL.startsWith('http'))
-  #       item.url = pageURL;
-  #     await this._client.send('Network.deleteCookies', item);
-  #   }
-  # }
+  def delete_cookie(*cookies)
+    page_url = url
+    starts_with_http = page_url.start_with?("http")
+    cookies.each do |cookie|
+      item = (starts_with_http ? { url: page_url } : {}).merge(cookie)
+      @client.send_message("Network.deleteCookies", item)
+    end
+  end
 
-  # /**
-  #  * @param {Array<Network.CookieParam>} cookies
-  #  */
-  # async setCookie(...cookies) {
-  #   const pageURL = this.url();
-  #   const startsWithHTTP = pageURL.startsWith('http');
-  #   const items = cookies.map(cookie => {
-  #     const item = Object.assign({}, cookie);
-  #     if (!item.url && startsWithHTTP)
-  #       item.url = pageURL;
-  #     assert(item.url !== 'about:blank', `Blank page can not have cookie "${item.name}"`);
-  #     assert(!String.prototype.startsWith.call(item.url || '', 'data:'), `Data URL page can not have cookie "${item.name}"`);
-  #     return item;
-  #   });
-  #   await this.deleteCookie(...items);
-  #   if (items.length)
-  #     await this._client.send('Network.setCookies', { cookies: items });
-  # }
+  def set_cookie(*cookies)
+    page_url = url
+    starts_with_http = page_url.start_with?("http")
+    items = cookies.map do |cookie|
+      (starts_with_http ? { url: page_url } : {}).merge(cookie).tap do |item|
+        raise ArgumentError.new("Blank page can not have cookie \"#{item[:name]}\"") if item[:url] == "about:blank"
+        raise ArgumetnError.new("Data URL page can not have cookie \"#{item[:name]}\"") if item[:url]&.start_with?("data:")
+      end
+    end
+    delete_cookie(*items)
+    unless items.empty?
+      @client.send_message("Network.setCookies", cookies: items)
+    end
+  end
 
   class ScriptTag
     # @param {!{content?: string, path?: string, type?: string, url?: string}} options
@@ -502,7 +462,7 @@ class Puppeteer::Page
   #  * @param {!Protocol.Performance.metricsPayload} event
   #  */
   # _emitMetrics(event) {
-  #   this.emit(Events.Page.Metrics, {
+  #   this.emit(PageEmittedEvents::Metrics, {
   #     title: event.title,
   #     metrics: this._buildMetricsObject(event.metrics)
   #   });
@@ -521,15 +481,14 @@ class Puppeteer::Page
   #   return result;
   # }
 
-  # /**
-  #  * @param {!Protocol.Runtime.ExceptionDetails} exceptionDetails
-  #  */
-  # _handleException(exceptionDetails) {
-  #   const message = helper.getExceptionMessage(exceptionDetails);
-  #   const err = new Error(message);
-  #   err.stack = ''; // Don't report clientside error with a node stack attached
-  #   this.emit(Events.Page.PageError, err);
-  # }
+  class PageError < StandardError ; end
+
+  private def handle_exception(exception_details)
+    message = Puppeteer::ExceptionDetails.new(exception_details).message
+    err = PageError.new(message)
+    #   err.stack = ''; // Don't report clientside error with a node stack attached
+    emit_event(PageEmittedEvents::PageError, err)
+  end
 
   # /**
   #  * @param {!Protocol.Runtime.consoleAPICalledPayload} event
@@ -613,7 +572,7 @@ class Puppeteer::Page
   #  * @param {Protocol.Runtime.StackTrace=} stackTrace
   #  */
   # _addConsoleMessage(type, args, stackTrace) {
-  #   if (!this.listenerCount(Events.Page.Console)) {
+  #   if (!this.listenerCount(PageEmittedEvents::Console)) {
   #     args.forEach(arg => arg.dispose());
   #     return;
   #   }
@@ -631,7 +590,7 @@ class Puppeteer::Page
   #     columnNumber: stackTrace.callFrames[0].columnNumber,
   #   } : {};
   #   const message = new ConsoleMessage(type, textTokens.join(' '), args, location);
-  #   this.emit(Events.Page.Console, message);
+  #   this.emit(PageEmittedEvents::Console, message);
   # }
 
   private def handle_dialog_opening(event)
@@ -643,7 +602,7 @@ class Puppeteer::Page
               type: dialog_type,
               message: event['message'],
               default_value: event['defaultPrompt'])
-    emit_event('Events.Page.Dialog', dialog)
+    emit_event(PageEmittedEvents::Dialog, dialog)
   end
 
   # @return [String]
@@ -726,7 +685,7 @@ class Puppeteer::Page
 
   private def session_close_promise
     @disconnect_promise ||= resolvable_future do |future|
-      @client.observe_first('Events.CDPSession.Disconnected') do
+      @client.observe_first(CDPSessionEmittedEvents::Disconnected) do
         future.reject(Puppeteer::CDPSession::Error.new('Target Closed'))
       end
     end
@@ -746,7 +705,7 @@ class Puppeteer::Page
         -> (request) { predicate.call(request) }
       end
 
-    wait_for_network_manager_event('Events.NetworkManager.Request',
+    wait_for_network_manager_event(NetworkManagerEmittedEvents::Request,
       predicate: request_predicate,
       timeout: timeout,
     )
@@ -780,7 +739,7 @@ class Puppeteer::Page
         -> (response) { predicate.call(response) }
       end
 
-    wait_for_network_manager_event('Events.NetworkManager.Response',
+    wait_for_network_manager_event(NetworkManagerEmittedEvents::Response,
       predicate: response_predicate,
       timeout: timeout,
     )
@@ -870,6 +829,21 @@ class Puppeteer::Page
     end
   end
 
+  # @param is_user_active [Boolean]
+  # @param is_screen_unlocked [Boolean]
+  def emulate_idle_state(is_user_active: nil, is_screen_unlocked: nil)
+    overrides = {
+      isUserActive: is_user_active,
+      isScreenUnlocked: is_screen_unlocked,
+    }.compact
+
+    if overrides.empty?
+      @client.send_message('Emulation.clearIdleOverride')
+    else
+      @client.send_message('Emulation.setIdleOverride', overrides)
+    end
+  end
+
   # @param viewport [Viewport]
   def viewport=(viewport)
     needs_reload = @emulation_manager.emulate_viewport(viewport)
@@ -907,15 +881,28 @@ class Puppeteer::Page
     main_frame.title
   end
 
-  # /**
-  #  * @param {!ScreenshotOptions=} options
-  #  * @return {!Promise<!Buffer|!String>}
-  #  */
-  def screenshot(options = {})
+  # @param type [String] "png"|"jpeg"
+  # @param path [String]
+  # @param full_page [Boolean]
+  # @param clip [Hash]
+  # @param quality [Integer]
+  # @param omit_background [Boolean]
+  # @param encoding [String]
+  def screenshot(type: nil, path: nil, full_page: nil, clip: nil, quality: nil, omit_background: nil, encoding: nil)
+    options = {
+      type: type,
+      path: path,
+      full_page: full_page,
+      clip: clip,
+      quality:  quality,
+      omit_background: omit_background,
+      encoding: encoding,
+    }.compact
     screenshot_options = ScreenshotOptions.new(options)
 
-    # @screenshot_task_queue.post_task(-> { screenshot_task(screenshot_options.type, screenshot_options) })
-    screenshot_task(screenshot_options.type, screenshot_options)
+    @screenshot_task_queue.post_task do
+      screenshot_task(screenshot_options.type, screenshot_options)
+    end
   end
 
   # @param {"png"|"jpeg"} format
@@ -1043,6 +1030,12 @@ class Puppeteer::Page
     else
       @client.connection.send_message('Target.closeTarget', targetId: @target.target_id)
       await @target.is_closed_promise
+
+      # @closed sometimes remains false, so wait for @closed = true with 100ms timeout.
+      25.times do
+        break if @closed
+        sleep 0.004
+      end
     end
   end