puppeteer-ruby 0.37.4 → 0.40.1

data/lib/puppeteer/network_event_manager.rb

@@ -0,0 +1,122 @@
+# Helper class to track network events by request ID
+class Puppeteer::NetworkEventManager
+  def initialize
+    #
+    # There are four possible orders of events:
+    #  A. `_onRequestWillBeSent`
+    #  B. `_onRequestWillBeSent`, `_onRequestPaused`
+    #  C. `_onRequestPaused`, `_onRequestWillBeSent`
+    #  D. `_onRequestPaused`, `_onRequestWillBeSent`, `_onRequestPaused`,
+    #     `_onRequestWillBeSent`, `_onRequestPaused`, `_onRequestPaused`
+    #     (see crbug.com/1196004)
+    #
+    # For `_onRequest` we need the event from `_onRequestWillBeSent` and
+    # optionally the `interceptionId` from `_onRequestPaused`.
+    #
+    # If request interception is disabled, call `_onRequest` once per call to
+    # `_onRequestWillBeSent`.
+    # If request interception is enabled, call `_onRequest` once per call to
+    # `_onRequestPaused` (once per `interceptionId`).
+    #
+    # Events are stored to allow for subsequent events to call `_onRequest`.
+    #
+    # Note that (chains of) redirect requests have the same `requestId` (!) as
+    # the original request. We have to anticipate series of events like these:
+    #  A. `_onRequestWillBeSent`,
+    #     `_onRequestWillBeSent`, ...
+    #  B. `_onRequestWillBeSent`, `_onRequestPaused`,
+    #     `_onRequestWillBeSent`, `_onRequestPaused`, ...
+    #  C. `_onRequestWillBeSent`, `_onRequestPaused`,
+    #     `_onRequestPaused`, `_onRequestWillBeSent`, ...
+    #  D. `_onRequestPaused`, `_onRequestWillBeSent`,
+    #     `_onRequestPaused`, `_onRequestWillBeSent`, `_onRequestPaused`,
+    #     `_onRequestWillBeSent`, `_onRequestPaused`, `_onRequestPaused`, ...
+    #     (see crbug.com/1196004)
+    @request_will_be_sent_map = {}
+    @request_paused_map = {}
+    @http_requests_map = {}
+    #
+    # The below maps are used to reconcile Network.responseReceivedExtraInfo
+    # events with their corresponding request. Each response and redirect
+    # response gets an ExtraInfo event, and we don't know which will come first.
+    # This means that we have to store a Response or an ExtraInfo for each
+    # response, and emit the event when we get both of them. In addition, to
+    # handle redirects, we have to make them Arrays to represent the chain of
+    # events.
+    @response_received_extra_info_map = {}
+    @queued_redirect_info_map = {}
+    @queued_event_group_map = {}
+  end
+
+  def forget(network_request_id)
+    @request_will_be_sent_map.delete(network_request_id)
+    @request_paused_map.delete(network_request_id)
+    @queued_event_group_map.delete(network_request_id)
+    @queued_redirect_info_map.delete(network_request_id)
+    @response_received_extra_info_map.delete(network_request_id)
+  end
+
+  def response_extra_info(network_request_id)
+    @response_received_extra_info_map[network_request_id] ||= []
+  end
+
+  private def queued_redirect_info(fetch_request_id)
+    @queued_redirect_info_map[fetch_request_id] ||= []
+  end
+
+  def enqueue_redirect_info(fetch_request_id, redirect_info)
+    queued_redirect_info(fetch_request_id) << redirect_info
+  end
+
+  def take_queued_redirect_info(fetch_request_id)
+    queued_redirect_info(fetch_request_id).shift
+  end
+
+  def num_requests_in_progress
+    @http_requests_map.count { |_, request| !request.response }
+  end
+
+  def store_request_will_be_sent(network_request_id, event)
+    @request_will_be_sent_map[network_request_id] = event
+  end
+
+  def get_request_will_be_sent(network_request_id)
+    @request_will_be_sent_map[network_request_id]
+  end
+
+  def forget_request_will_be_sent(network_request_id)
+    @request_will_be_sent_map.delete(network_request_id)
+  end
+
+  def store_request_paused(network_request_id, event)
+    @request_paused_map[network_request_id] = event
+  end
+
+  def get_request_paused(network_request_id)
+    @request_paused_map[network_request_id]
+  end
+
+  def fotget_request_paused(network_request_id)
+    @request_paused_map.delete(network_request_id)
+  end
+
+  def store_request(network_request_id, request)
+    @http_requests_map[network_request_id] = request
+  end
+
+  def get_request(network_request_id)
+    @http_requests_map[network_request_id]
+  end
+
+  def forget_request(network_request_id)
+    @http_requests_map.delete(network_request_id)
+  end
+
+  def enqueue_event_group(network_request_id, queued_event_group)
+    @queued_event_group_map[network_request_id] = queued_event_group
+  end
+
+  def get_queued_event_group(network_request_id)
+    @queued_event_group_map[network_request_id]
+  end
+end

data/lib/puppeteer/network_manager.rb

@@ -53,6 +53,22 @@ class Puppeteer::NetworkManager
     end
   end
 
+  class RedirectInfo
+    def initialize(event:, fetch_request_id:)
+      @event = event
+      @fetch_request_id = fetch_request_id
+    end
+    attr_reader :event, :fetch_request_id
+  end
+
+  class QueuedEventGroup
+    def initialize(response_received_event:)
+      @response_received_event = response_received_event
+    end
+    attr_reader :response_received_event
+    attr_accessor :loading_finished_event, :loading_failed_event
+  end
+
   # @param {!Puppeteer.CDPSession} client
   # @param {boolean} ignoreHTTPSErrors
   # @param {!Puppeteer.FrameManager} frameManager
@@ -60,12 +76,7 @@ class Puppeteer::NetworkManager
     @client = client
     @ignore_https_errors = ignore_https_errors
     @frame_manager = frame_manager
-
-    # @type {!Map<string, !Request>}
-    @request_id_to_request = {}
-
-    # @type {!Map<string, !Protocol.Network.requestWillBeSentPayload>}
-    @request_id_to_request_with_be_sent_event = {}
+    @network_event_manager = Puppeteer::NetworkEventManager.new
 
     @extra_http_headers = {}
 
@@ -73,7 +84,6 @@ class Puppeteer::NetworkManager
     @user_request_interception_enabled = false
     @protocol_request_interception_enabled = false
     @user_cache_disabled = false
-    @request_id_to_interception_id = {}
     @internal_network_condition = InternalNetworkCondition.new(@client)
 
     @client.on_event('Fetch.requestPaused') do |event|
@@ -97,6 +107,9 @@ class Puppeteer::NetworkManager
     @client.on_event('Network.loadingFailed') do |event|
       handle_loading_failed(event)
     end
+    @client.on_event('Network.responseReceivedExtraInfo') do |event|
+      handle_response_received_extra_info(event)
+    end
   end
 
   def init
@@ -106,6 +119,14 @@ class Puppeteer::NetworkManager
     end
   end
 
+  def inspect
+    values = %i[network_event_manager].map do |sym|
+      value = instance_variable_get(:"@#{sym}")
+      "@#{sym}=#{value}"
+    end
+    "#<Puppeteer::HTTPRequest #{values.join(' ')}>"
+  end
+
   # @param username [String|NilClass]
   # @param password [String|NilClass]
   def authenticate(username:, password:)
@@ -131,6 +152,10 @@ class Puppeteer::NetworkManager
     @extra_http_headers.dup
   end
 
+  def num_requests_in_progress
+    @network_event_manager.num_requests_in_progress
+  end
+
   # @param value [TrueClass|FalseClass]
   def offline_mode=(value)
     @internal_network_condition.offline_mode=(value)
@@ -185,14 +210,17 @@ class Puppeteer::NetworkManager
 
   private def handle_request_will_be_sent(event)
     # Request interception doesn't happen for data URLs with Network Service.
-    if @protocol_request_interception_enabled && !event['request']['url'].start_with?('data:')
-      request_id = event['requestId']
-      interception_id = @request_id_to_interception_id.delete(request_id)
-      if interception_id
-        handle_request(event, interception_id)
-      else
-        @request_id_to_request_with_be_sent_event[request_id] = event
+    if @user_request_interception_enabled && !event['request']['url'].start_with?('data:')
+      network_request_id = event['requestId']
+      @network_event_manager.store_request_will_be_sent(network_request_id, event)
+
+      # CDP may have sent a Fetch.requestPaused event already. Check for it.
+      if_present(@network_event_manager.get_request_paused(network_request_id)) do |request_paused_event|
+        fetch_request_id = request_paused_event['requestId']
+        handle_request(event, fetch_request_id)
+        @network_event_manager.forget_request_paused(network_request_id)
       end
+
       return
     end
     handle_request(event, nil)
@@ -233,26 +261,61 @@ class Puppeteer::NetworkManager
       end
     end
 
-    request_id = event['networkId']
-    interception_id = event['requestId']
-    if request_id && (request_will_be_sent_event = @request_id_to_request_with_be_sent_event.delete(request_id))
-      handle_request(request_will_be_sent_event, interception_id)
+    network_request_id = event['networkId']
+    fetch_request_id = event['requestId']
+    return unless network_request_id
+
+    request_will_be_sent_event = @network_event_manager.get_request_will_be_sent(network_request_id)
+
+    # redirect requests have the same `requestId`
+    if request_will_be_sent_event &&
+       (request_will_be_sent_event['request']['url'] != event['request']['url'] ||
+        request_will_be_sent_event['request']['method'] != event['request']['method'])
+
+      @network_event_manager.forget_request_will_be_sent(network_request_id)
+      request_will_be_sent_event = nil
+    end
+
+    if request_will_be_sent_event
+      handle_request(request_will_be_sent_event, fetch_request_id)
     else
-      @request_id_to_interception_id[request_id] = interception_id
+      @network_event_manager.store_request_paused(network_request_id, event)
     end
   end
 
-  private def handle_request(event, interception_id)
+  private def handle_request(event, fetch_request_id)
     redirect_chain = []
     if event['redirectResponse']
-      if_present(@request_id_to_request[event['requestId']]) do |request|
-        handle_request_redirect(request, event['redirectResponse'])
+      # We want to emit a response and requestfinished for the
+      # redirectResponse, but we can't do so unless we have a
+      # responseExtraInfo ready to pair it up with. If we don't have any
+      # responseExtraInfos saved in our queue, they we have to wait until
+      # the next one to emit response and requestfinished, *and* we should
+      # also wait to emit this Request too because it should come after the
+      # response/requestfinished.
+      redirect_response_extra_info = nil
+      if event['redirectHasExtraInfo']
+        redirect_response_extra_info = @network_event_manager.response_extra_info(event['requestId']).shift
+        unless redirect_response_extra_info
+          redirect_info = RedirectInfo.new(
+            event: event,
+            fetch_request_id: fetch_request_id,
+          )
+          @network_event_manager.enqueue_redirect_info(event['requestId'], redirect_info)
+          return
+        end
+      end
+
+      # If we connect late to the target, we could have missed the
+      # requestWillBeSent event.
+      if_present(@network_event_manager.get_request(event['requestId'])) do |request|
+        handle_request_redirect(request, event['redirectResponse'], redirect_response_extra_info)
         redirect_chain = request.internal.redirect_chain
       end
     end
     frame = if_present(event['frameId']) { |frame_id| @frame_manager.frame(frame_id) }
-    request = Puppeteer::HTTPRequest.new(@client, frame, interception_id, @user_request_interception_enabled, event, redirect_chain)
-    @request_id_to_request[event['requestId']] = request
+    request = Puppeteer::HTTPRequest.new(@client, frame, fetch_request_id, @user_request_interception_enabled, event, redirect_chain)
+    @network_event_manager.store_request(event['requestId'], request)
     emit_event(NetworkManagerEmittedEvents::Request, request)
     begin
       request.finalize_interceptions
@@ -262,55 +325,133 @@ class Puppeteer::NetworkManager
   end
 
   private def handle_request_served_from_cache(event)
-    if_present(@request_id_to_request[event['requestId']]) do |request|
+    request = @network_event_manager.get_request(event['requestId'])
+    if request
       request.internal.from_memory_cache = true
     end
+    emit_event(NetworkManagerEmittedEvents::RequestServedFromCache, request)
   end
 
   # @param request [Puppeteer::HTTPRequest]
   # @param response_payload [Hash]
-  private def handle_request_redirect(request, response_payload)
-    response = Puppeteer::HTTPResponse.new(@client, request, response_payload)
+  private def handle_request_redirect(request, response_payload, extra_info)
+    response = Puppeteer::HTTPResponse.new(@client, request, response_payload, extra_info)
     request.internal.response = response
     request.internal.redirect_chain << request
     response.internal.body_loaded_promise.reject(Puppeteer::HTTPResponse::Redirected.new)
-    @request_id_to_request.delete(request.internal.request_id)
-    @attempted_authentications.delete(request.internal.interception_id)
+    forget_request(request, false)
     emit_event(NetworkManagerEmittedEvents::Response, response)
     emit_event(NetworkManagerEmittedEvents::RequestFinished, request)
   end
 
-  # @param event [Hash]
-  private def handle_response_received(event)
-    request = @request_id_to_request[event['requestId']]
+  private def emit_response_event(response_received_event, extra_info)
+    request = @network_event_manager.get_request(response_received_event['requestId'])
     # FileUpload sends a response without a matching request.
     return unless request
 
-    response = Puppeteer::HTTPResponse.new(@client, request, event['response'])
+    unless @network_event_manager.response_extra_info(response_received_event['requestId']).empty?
+      debug_puts("Unexpected extraInfo events for request #{response_received_event['requestId']}")
+    end
+
+    response = Puppeteer::HTTPResponse.new(@client, request, response_received_event['response'], extra_info)
     request.internal.response = response
     emit_event(NetworkManagerEmittedEvents::Response, response)
   end
 
+  # @param event [Hash]
+  private def handle_response_received(event)
+    request = @network_event_manager.get_request(event['requestId'])
+    extra_info = nil
+    if request && !request.internal.from_memory_cache? && event['hasExtraInfo']
+      extra_info = @network_event_manager.response_extra_info(event['requestId']).shift
+
+      unless extra_info
+        # Wait until we get the corresponding ExtraInfo event.
+        @network_event_manager.enqueue_event_group(event['requestId'], QueuedEventGroup.new(response_received_event: event))
+        return
+      end
+    end
+    emit_response_event(event, extra_info)
+  end
+
+  private def handle_response_received_extra_info(event)
+    # We may have skipped a redirect response/request pair due to waiting for
+    # this ExtraInfo event. If so, continue that work now that we have the
+    # request.
+    if_present(@network_event_manager.take_queued_redirect_info(event['requestId'])) do |redirect_info|
+      @network_event_manager.response_extra_info(event['requestId']) << event
+      handle_request(redirect_info.event, redirect_info)
+      return
+    end
+
+    # We may have skipped response and loading events because we didn't have
+    # this ExtraInfo event yet. If so, emit those events now.
+    if_present(@network_event_manager.get_queued_event_group(event['requestId'])) do |queued_events|
+      emit_response_event(queued_events.response_received_event, event)
+      if_present(queued_events.loading_finished_event) do |loading_finished_event|
+        emit_loading_finished(loading_finished_event)
+      end
+      if_present(queued_events.loading_failed_event) do |loading_failed_event|
+        emit_loading_failed(loading_failed_event)
+      end
+      return
+    end
+
+    # Wait until we get another event that can use this ExtraInfo event.
+    @network_event_manager.response_extra_info(event['requestId']) << event
+  end
+
+  private def forget_request(request, forget_events)
+    request_id = request.internal.request_id
+    interception_id = request.internal.interception_id
+
+    @network_event_manager.forget_request(request_id)
+    @attempted_authentications.delete(interception_id)
+    if forget_events
+      @network_event_manager.forget(request_id)
+    end
+  end
+
   private def handle_loading_finished(event)
-    request = @request_id_to_request[event['requestId']]
+    # If the response event for this request is still waiting on a
+    # corresponding ExtraInfo event, then wait to emit this event too.
+    queued_events = @network_event_manager.get_queued_event_group(event['requestId'])
+    if queued_events
+      queued_events.loading_finished_event = event
+    else
+      emit_loading_finished(event)
+    end
+  end
+
+  private def emit_loading_finished(event)
+    request = @network_event_manager.get_request(event['requestId'])
     # For certain requestIds we never receive requestWillBeSent event.
     # @see https://crbug.com/750469
     return unless request
 
-
     # Under certain conditions we never get the Network.responseReceived
     # event from protocol. @see https://crbug.com/883475
     if_present(request.response) do |response|
       response.internal.body_loaded_promise.fulfill(nil)
     end
 
-    @request_id_to_request.delete(request.internal.request_id)
-    @attempted_authentications.delete(request.internal.interception_id)
+    forget_request(request, true)
     emit_event(NetworkManagerEmittedEvents::RequestFinished, request)
   end
 
   private def handle_loading_failed(event)
-    request = @request_id_to_request[event['requestId']]
+    # If the response event for this request is still waiting on a
+    # corresponding ExtraInfo event, then wait to emit this event too.
+    queued_events = @network_event_manager.get_queued_event_group(event['requestId'])
+    if queued_events
+      queued_events.loading_failed_event = event
+    else
+      emit_loading_failed(event)
+    end
+  end
+
+  private def emit_loading_failed(event)
+    request = @network_event_manager.get_request(event['requestId'])
     # For certain requestIds we never receive requestWillBeSent event.
     # @see https://crbug.com/750469
     return unless request
@@ -319,8 +460,7 @@ class Puppeteer::NetworkManager
     if_present(request.response) do |response|
       response.internal.body_loaded_promise.fulfill(nil)
     end
-    @request_id_to_request.delete(request.internal.request_id)
-    @attempted_authentications.delete(request.internal.interception_id)
+    forget_request(request, true)
     emit_event(NetworkManagerEmittedEvents::RequestFailed, request)
   end
 end

data/lib/puppeteer/page/screenshot_options.rb

@@ -34,7 +34,7 @@ class Puppeteer::Page
       @type ||= 'png'
 
       if options[:quality]
-        unless @type == 'jpeg'
+        if @type != 'jpeg' && @type != 'webp'
           raise ArgumentError.new("options.quality is unsupported for the #{@type} screenshots")
         end
         unless options[:quality].is_a?(Numeric)

data/lib/puppeteer/page.rb

@@ -50,19 +50,26 @@ class Puppeteer::Page
     @workers = {}
     @user_drag_interception_enabled = false
 
-    @client.on_event('Target.attachedToTarget') do |event|
-      if event['targetInfo']['type'] != 'worker'
+    @client.add_event_listener('Target.attachedToTarget') do |event|
+      if event['targetInfo']['type'] != 'worker' && event['targetInfo']['type'] != 'iframe'
         # If we don't detach from service workers, they will never die.
+        # We still want to attach to workers for emitting events.
+        # We still want to attach to iframes so sessions may interact with them.
+        # We detach from all other types out of an abundance of caution.
+        # See https://source.chromium.org/chromium/chromium/src/+/main:content/browser/devtools/devtools_agent_host_impl.cc?ss=chromium&q=f:devtools%20-f:out%20%22::kTypePage%5B%5D%22
+        # for the complete list of available types.
         @client.async_send_message('Target.detachFromTarget', sessionId: event['sessionId'])
         next
       end
 
-      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(PageEmittedEvents::WorkerCreated, worker);
+      if event['targetInfo']['type'] == 'worker'
+        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(PageEmittedEvents::WorkerCreated, worker);
+      end
     end
-    @client.on_event('Target.detachedFromTarget') do |event|
+    @client.add_event_listener('Target.detachedFromTarget') do |event|
       session_id = event['sessionId']
       worker = @workers[session_id]
       next unless worker
@@ -103,10 +110,10 @@ class Puppeteer::Page
     @client.on_event('Page.loadEventFired') do |event|
       emit_event(PageEmittedEvents::Load)
     end
-    @client.on('Runtime.consoleAPICalled') do |event|
+    @client.add_event_listener('Runtime.consoleAPICalled') do |event|
       handle_console_api(event)
     end
-    @client.on('Runtime.bindingCalled') do |event|
+    @client.add_event_listener('Runtime.bindingCalled') do |event|
       handle_binding_called(event)
     end
     @client.on_event('Page.javascriptDialogOpening') do |event|
@@ -518,7 +525,7 @@ class Puppeteer::Page
       return
     end
 
-    context = @frame_manager.execution_context_by_id(event['executionContextId'])
+    context = @frame_manager.execution_context_by_id(event['executionContextId'], @client)
     values = event['args'].map do |arg|
       remote_object = Puppeteer::RemoteObject.new(arg)
       Puppeteer::JSHandle.create(context: context, remote_object: remote_object)
@@ -664,19 +671,38 @@ class Puppeteer::Page
   private def wait_for_network_manager_event(event_name, predicate:, timeout:)
     option_timeout = timeout || @timeout_settings.timeout
 
-    @wait_for_network_manager_event_listener_ids ||= {}
-    if_present(@wait_for_network_manager_event_listener_ids[event_name]) do |listener_id|
+    promise = resolvable_future
+
+    listener_id = @frame_manager.network_manager.add_event_listener(event_name) do |event_target|
+      if predicate.call(event_target)
+        promise.fulfill(event_target)
+      end
+    end
+
+    begin
+      # Timeout.timeout(0) means "no limit" for timeout.
+      Timeout.timeout(option_timeout / 1000.0) do
+        await_any(promise, session_close_promise)
+      end
+    rescue Timeout::Error
+      raise Puppeteer::TimeoutError.new("waiting for #{event_name} failed: timeout #{option_timeout}ms exceeded")
+    ensure
       @frame_manager.network_manager.remove_event_listener(listener_id)
     end
+  end
+
+  private def wait_for_frame_manager_event(*event_names, predicate:, timeout:)
+    option_timeout = timeout || @timeout_settings.timeout
 
     promise = resolvable_future
 
-    @wait_for_network_manager_event_listener_ids[event_name] =
-      @frame_manager.network_manager.add_event_listener(event_name) do |event_target|
+    listener_ids = event_names.map do |event_name|
+      @frame_manager.add_event_listener(event_name) do |event_target|
         if predicate.call(event_target)
-          promise.fulfill(event_target)
+          promise.fulfill(event_target) unless promise.resolved?
         end
       end
+    end
 
     begin
       # Timeout.timeout(0) means "no limit" for timeout.
@@ -684,9 +710,11 @@ class Puppeteer::Page
         await_any(promise, session_close_promise)
       end
     rescue Timeout::Error
-      raise Puppeteer::TimeoutError.new("waiting for #{event_name} failed: timeout #{timeout}ms exceeded")
+      raise Puppeteer::TimeoutError.new("waiting for #{event_names.join(" or ")} failed: timeout #{option_timeout}ms exceeded")
     ensure
-      @frame_manager.network_manager.remove_event_listener(@wait_for_network_manager_event_listener_ids[event_name])
+      listener_ids.each do |listener_id|
+        @frame_manager.remove_event_listener(listener_id)
+      end
     end
   end
 
@@ -709,7 +737,7 @@ class Puppeteer::Page
       if url
         -> (request) { request.url == url }
       else
-        -> (request) { predicate.call(request) }
+        predicate
       end
 
     wait_for_network_manager_event(NetworkManagerEmittedEvents::Request,
@@ -743,7 +771,7 @@ class Puppeteer::Page
       if url
         -> (response) { response.url == url }
       else
-        -> (response) { predicate.call(response) }
+        predicate
       end
 
     wait_for_network_manager_event(NetworkManagerEmittedEvents::Response,
@@ -758,6 +786,34 @@ class Puppeteer::Page
   # @param predicate [Proc(Puppeteer::HTTPRequest -> Boolean)]
   define_async_method :async_wait_for_response
 
+  def wait_for_frame(url: nil, predicate: nil, timeout: nil)
+    if !url && !predicate
+      raise ArgumentError.new('url or predicate must be specified')
+    end
+    if predicate && !predicate.is_a?(Proc)
+      raise ArgumentError.new('predicate must be a proc.')
+    end
+    frame_predicate =
+      if url
+        -> (frame) { frame.url == url }
+      else
+        predicate
+      end
+
+    wait_for_frame_manager_event(
+      FrameManagerEmittedEvents::FrameAttached,
+      FrameManagerEmittedEvents::FrameNavigated,
+      predicate: frame_predicate,
+      timeout: timeout,
+    )
+  end
+
+  # @!method async_wait_for_frame(url: nil, predicate: nil, timeout: nil)
+  #
+  # @param url [String]
+  # @param predicate [Proc(Puppeteer::Frame -> Boolean)]
+  define_async_method :async_wait_for_frame
+
   # @param timeout [number|nil]
   # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
   def go_back(timeout: nil, wait_until: nil)

data/lib/puppeteer/puppeteer.rb

@@ -44,6 +44,7 @@ class Puppeteer::Puppeteer
     args: nil,
     user_data_dir: nil,
     devtools: nil,
+    debugging_port: nil,
     headless: nil,
     ignore_https_errors: nil,
     default_viewport: NoViewport.new,
@@ -63,6 +64,7 @@ class Puppeteer::Puppeteer
       args: args,
       user_data_dir: user_data_dir,
       devtools: devtools,
+      debugging_port: debugging_port,
       headless: headless,
       ignore_https_errors: ignore_https_errors,
       default_viewport: default_viewport,

data/lib/puppeteer/query_handler_manager.rb

@@ -26,8 +26,8 @@ class Puppeteer::QueryHandlerManager
       @query_handler.query_one(element_handle, @selector)
     end
 
-    def wait_for(dom_world, visible:, hidden:, timeout:)
-      @query_handler.wait_for(dom_world, @selector, visible: visible, hidden: hidden, timeout: timeout)
+    def wait_for(dom_world, visible:, hidden:, timeout:, root:)
+      @query_handler.wait_for(dom_world, @selector, visible: visible, hidden: hidden, timeout: timeout, root: root)
     end
 
     def query_all(element_handle)

data/lib/puppeteer/target.rb

@@ -119,6 +119,11 @@ class Puppeteer::Target
     end
   end
 
+  # @internal
+  def raw_type
+    @target_info.type
+  end
+
   # @return {!Puppeteer.Browser}
   def browser
     @browser_context.browser

data/lib/puppeteer/version.rb

@@ -1,3 +1,3 @@
 module Puppeteer
-  VERSION = '0.37.4'
+  VERSION = '0.40.1'
 end