puppeteer-ruby 0.37.4 → 0.40.1

data/lib/puppeteer/frame_manager.rb

@@ -27,50 +27,67 @@ class Puppeteer::FrameManager
     # @type {!Set<string>}
     @isolated_worlds = Set.new
 
-    @client.on_event('Page.frameAttached') do |event|
-      handle_frame_attached(event['frameId'], event['parentFrameId'])
+    setup_listeners(@client)
+  end
+
+  private def setup_listeners(client)
+    client.on_event('Page.frameAttached') do |event|
+      handle_frame_attached(client, event['frameId'], event['parentFrameId'])
     end
-    @client.on_event('Page.frameNavigated') do |event|
+    client.on_event('Page.frameNavigated') do |event|
       handle_frame_navigated(event['frame'])
     end
-    @client.on_event('Page.navigatedWithinDocument') do |event|
+    client.on_event('Page.navigatedWithinDocument') do |event|
       handle_frame_navigated_within_document(event['frameId'], event['url'])
     end
-    @client.on_event('Page.frameDetached') do |event|
-      handle_frame_detached(event['frameId'])
+    client.on_event('Page.frameDetached') do |event|
+      handle_frame_detached(event['frameId'], event['reason'])
     end
-    @client.on_event('Page.frameStoppedLoading') do |event|
+    client.on_event('Page.frameStoppedLoading') do |event|
       handle_frame_stopped_loading(event['frameId'])
     end
-    @client.on_event('Runtime.executionContextCreated') do |event|
-      handle_execution_context_created(event['context'])
+    client.on_event('Runtime.executionContextCreated') do |event|
+      handle_execution_context_created(event['context'], client)
     end
-    @client.on_event('Runtime.executionContextDestroyed') do |event|
-      handle_execution_context_destroyed(event['executionContextId'])
+    client.on_event('Runtime.executionContextDestroyed') do |event|
+      handle_execution_context_destroyed(event['executionContextId'], client)
     end
-    @client.on_event('Runtime.executionContextsCleared') do |event|
-      handle_execution_contexts_cleared
+    client.on_event('Runtime.executionContextsCleared') do |event|
+      handle_execution_contexts_cleared(client)
     end
-    @client.on_event('Page.lifecycleEvent') do |event|
+    client.on_event('Page.lifecycleEvent') do |event|
       handle_lifecycle_event(event)
     end
+    client.on_event('Target.attachedToTarget') do |event|
+      handle_attached_to_target(event)
+    end
+    client.on_event('Target.detachedFromTarget') do |event|
+      handle_detached_from_target(event)
+    end
   end
 
   attr_reader :client, :timeout_settings
 
-  private def init
+  private def init(cdp_session = nil)
+    client = cdp_session || @client
+
     results = await_all(
-      @client.async_send_message('Page.enable'),
-      @client.async_send_message('Page.getFrameTree'),
+      client.async_send_message('Page.enable'),
+      client.async_send_message('Page.getFrameTree'),
     )
     frame_tree = results.last['frameTree']
-    handle_frame_tree(frame_tree)
+    handle_frame_tree(client, frame_tree)
     await_all(
-      @client.async_send_message('Page.setLifecycleEventsEnabled', enabled: true),
-      @client.async_send_message('Runtime.enable'),
+      client.async_send_message('Page.setLifecycleEventsEnabled', enabled: true),
+      client.async_send_message('Runtime.enable'),
     )
-    ensure_isolated_world(UTILITY_WORLD_NAME)
-    @network_manager.init
+    ensure_isolated_world(client, UTILITY_WORLD_NAME)
+    @network_manager.init unless cdp_session
+  rescue => err
+    # The target might have been closed before the initialization finished.
+    return if err.message.include?('Target closed') || err.message.include?('Session closed')
+
+    raise
   end
 
   define_async_method :async_init
@@ -154,6 +171,28 @@ class Puppeteer::FrameManager
     watcher.navigation_response
   end
 
+  # @param event [Hash]
+  def handle_attached_to_target(event)
+    return if event['targetInfo']['type'] != 'iframe'
+
+    frame = @frames[event['targetInfo']['targetId']]
+    session = Puppeteer::Connection.from_session(@client).session(event['sessionId'])
+
+    frame.send(:update_client, session)
+    setup_listeners(session)
+    async_init(session)
+  end
+
+  # @param event [Hash]
+  def handle_detached_from_target(event)
+    frame = @frames[event['targetId']]
+    if frame && frame.oop_frame?
+      # When an OOP iframe is removed from the page, it
+      # will only get a Target.detachedFromTarget event.
+      remove_frame_recursively(frame)
+    end
+  end
+
   # @param event [Hash]
   def handle_lifecycle_event(event)
     frame = @frames[event['frameId']]
@@ -170,16 +209,17 @@ class Puppeteer::FrameManager
     emit_event(FrameManagerEmittedEvents::LifecycleEvent, frame)
   end
 
+  # @param session [Puppeteer::CDPSession]
   # @param frame_tree [Hash]
-  def handle_frame_tree(frame_tree)
+  def handle_frame_tree(session, frame_tree)
     if frame_tree['frame']['parentId']
-      handle_frame_attached(frame_tree['frame']['id'], frame_tree['frame']['parentId'])
+      handle_frame_attached(session, frame_tree['frame']['id'], frame_tree['frame']['parentId'])
     end
     handle_frame_navigated(frame_tree['frame'])
     return if !frame_tree['childFrames']
 
     frame_tree['childFrames'].each do |child|
-      handle_frame_tree(child)
+      handle_frame_tree(session, child)
     end
   end
 
@@ -204,15 +244,25 @@ class Puppeteer::FrameManager
     @frames[frame_id]
   end
 
-  # @param {string} frameId
-  # @param {?string} parentFrameId
-  def handle_frame_attached(frame_id, parent_frame_id)
-    return if @frames.has_key?(frame_id)
+  # @param session [Puppeteer::CDPSession]
+  # @param frameId [String]
+  # @param parentFrameId [String|nil]
+  def handle_frame_attached(session, frame_id, parent_frame_id)
+    if @frames.has_key?(frame_id)
+      frame = @frames[frame_id]
+      if session && frame.oop_frame?
+        # If an OOP iframes becomes a normal iframe again
+        # it is first attached to the parent page before
+        # the target is removed.
+        frame.send(:update_client, session)
+      end
+      return
+    end
     if !parent_frame_id
       raise ArgymentError.new('parent_frame_id must not be nil')
     end
     parent_frame = @frames[parent_frame_id]
-    frame = Puppeteer::Frame.new(self, @client, parent_frame, frame_id)
+    frame = Puppeteer::Frame.new(self, parent_frame, frame_id, session)
     @frames[frame_id] = frame
 
     emit_event(FrameManagerEmittedEvents::FrameAttached, frame)
@@ -247,7 +297,7 @@ class Puppeteer::FrameManager
         frame.id = frame_payload['id']
       else
         # Initial main frame navigation.
-        frame = Puppeteer::Frame.new(self, @client, nil, frame_payload['id'])
+        frame = Puppeteer::Frame.new(self, nil, frame_payload['id'], @client)
       end
       @frames[frame_payload['id']] = frame
       @main_frame = frame
@@ -259,22 +309,26 @@ class Puppeteer::FrameManager
     emit_event(FrameManagerEmittedEvents::FrameNavigated, frame)
   end
 
+  # @param session [Puppeteer::CDPSession]
   # @param name [String]
-  def ensure_isolated_world(name)
-    return if @isolated_worlds.include?(name)
-    @isolated_worlds << name
+  private def ensure_isolated_world(session, name)
+    key = "#{session.id}:#{name}"
+    return if @isolated_worlds.include?(key)
+    @isolated_worlds << key
 
-    @client.send_message('Page.addScriptToEvaluateOnNewDocument',
+    session.send_message('Page.addScriptToEvaluateOnNewDocument',
       source: "//# sourceURL=#{Puppeteer::ExecutionContext::EVALUATION_SCRIPT_URL}",
       worldName: name,
     )
-    create_isolated_worlds_promises = frames.map do |frame|
-      @client.async_send_message('Page.createIsolatedWorld',
-        frameId: frame.id,
-        grantUniveralAccess: true,
-        worldName: name,
-      )
-    end
+    create_isolated_worlds_promises = frames.
+      select { |frame| frame._client == session }.
+      map do |frame|
+        session.async_send_message('Page.createIsolatedWorld',
+          frameId: frame.id,
+          grantUniveralAccess: true,
+          worldName: name,
+        )
+      end
     await_all(*create_isolated_worlds_promises)
   end
 
@@ -289,19 +343,31 @@ class Puppeteer::FrameManager
   end
 
   # @param frame_id [String]
-  def handle_frame_detached(frame_id)
+  # @param reason [String]
+  def handle_frame_detached(frame_id, reason)
     frame = @frames[frame_id]
-    if frame
-      remove_frame_recursively(frame)
+    if reason == 'remove'
+      # Only remove the frame if the reason for the detached event is
+      # an actual removement of the frame.
+      # For frames that become OOP iframes, the reason would be 'swap'.
+      if frame
+        remove_frame_recursively(frame)
+      end
     end
   end
 
   # @param context_payload [Hash]
-  def handle_execution_context_created(context_payload)
+  # @pram session [Puppeteer::CDPSession]
+  def handle_execution_context_created(context_payload, session)
     frame = if_present(context_payload.dig('auxData', 'frameId')) { |frame_id| @frames[frame_id] }
 
     world = nil
     if frame
+      # commented out the original implementation for allowing us to use Frame#evaluate on OOP iframe.
+      #
+      # # Only care about execution contexts created for the current session.
+      # return if @client != session
+
       if context_payload.dig('auxData', 'isDefault')
         world = frame.main_world
       elsif context_payload['name'] == UTILITY_WORLD_NAME && !frame.secondary_world.has_context?
@@ -316,34 +382,45 @@ class Puppeteer::FrameManager
       @isolated_worlds << context_payload['name']
     end
 
-    context = Puppeteer::ExecutionContext.new(@client, context_payload, world)
+    context = Puppeteer::ExecutionContext.new(frame&._client || @client, context_payload, world)
     if world
       world.context = context
     end
-    @context_id_to_context[context_payload['id']] = context
+    key = "#{session.id}:#{context_payload['id']}"
+    @context_id_to_context[key] = context
   end
 
-  # @param {number} executionContextId
-  def handle_execution_context_destroyed(execution_context_id)
-    context = @context_id_to_context[execution_context_id]
+  # @param execution_context_id [Integer]
+  # @param session [Puppeteer::CDPSEssion]
+  def handle_execution_context_destroyed(execution_context_id, session)
+    key = "#{session.id}:#{execution_context_id}"
+    context = @context_id_to_context[key]
     return unless context
-    @context_id_to_context.delete(execution_context_id)
+    @context_id_to_context.delete(key)
     if context.world
       context.world.delete_context(execution_context_id)
     end
   end
 
-  def handle_execution_contexts_cleared
-    @context_id_to_context.each do |execution_context_id, context|
-      if context.world
-        context.world.delete_context(execution_context_id)
+  # @param session [Puppeteer::CDPSession]
+  def handle_execution_contexts_cleared(session)
+    @context_id_to_context.select! do |execution_context_id, context|
+      # Make sure to only clear execution contexts that belong
+      # to the current session.
+      if context.client != session
+        true # keep
+      else
+        if context.world
+          context.world.delete_context(execution_context_id)
+        end
+        false # remove
       end
     end
-    @context_id_to_context.clear
   end
 
-  def execution_context_by_id(context_id)
-    @context_id_to_context[context_id] or raise "INTERNAL ERROR: missing context with id = #{context_id}"
+  def execution_context_by_id(context_id, session)
+    key = "#{session.id}:#{context_id}"
+    @context_id_to_context[key] or raise "INTERNAL ERROR: missing context with id = #{context_id}"
   end
 
   # @param {!Frame} frame

data/lib/puppeteer/http_request.rb

@@ -72,7 +72,15 @@ class Puppeteer::HTTPRequest
   end
 
   attr_reader :internal
-  attr_reader :url, :resource_type, :method, :post_data, :headers, :response, :frame
+  attr_reader :url, :resource_type, :method, :post_data, :headers, :response, :frame, :initiator
+
+  def inspect
+    values = %i[request_id method url].map do |sym|
+      value = instance_variable_get(:"@#{sym}")
+      "@#{sym}=#{value}"
+    end
+    "#<Puppeteer::HTTPRequest #{values.join(' ')}>"
+  end
 
   private def assert_interception_allowed
     unless @allow_interception

data/lib/puppeteer/http_response.rb

@@ -31,7 +31,8 @@ class Puppeteer::HTTPResponse
   # @param client [Puppeteer::CDPSession]
   # @param request [Puppeteer::HTTPRequest]
   # @param response_payload [Hash]
-  def initialize(client, request, response_payload)
+  # @param extra_info [Hash|nil]
+  def initialize(client, request, response_payload, extra_info)
     @client = client
     @request = request
 
@@ -41,14 +42,15 @@ class Puppeteer::HTTPResponse
       port: response_payload['remotePort'],
     )
 
-    @status = response_payload['status']
-    @status_text = response_payload['statusText']
+    @status_text = parse_štatus_text_from_extra_info(extra_info) || response_payload['statusText']
     @url = request.url
     @from_disk_cache = !!response_payload['fromDiskCache']
     @from_service_worker = !!response_payload['fromServiceWorker']
 
+    @status = extra_info ? extra_info['statusCode'] : response_payload['status']
     @headers = {}
-    response_payload['headers'].each do |key, value|
+    headers = extra_info ? extra_info['headers'] : response_payload['headers']
+    headers.each do |key, value|
       @headers[key.downcase] = value
     end
     @security_details = if_present(response_payload['securityDetails']) do |security_payload|
@@ -62,6 +64,25 @@ class Puppeteer::HTTPResponse
 
   attr_reader :remote_address, :url, :status, :status_text, :headers, :security_details, :request
 
+  def inspect
+    values = %i[remote_address url status status_text headers security_details request].map do |sym|
+      value = instance_variable_get(:"@#{sym}")
+      "@#{sym}=#{value}"
+    end
+    "#<Puppeteer::HTTPRequest #{values.join(' ')}>"
+  end
+
+  private def parse_štatus_text_from_extra_info(extra_info)
+    return nil if !extra_info || !extra_info['headersText']
+    first_line = extra_info['headersText'].split("\r").first
+    return nil unless first_line
+    /[^ ]* [^ ]* (.*)/.match(first_line) do |m|
+      return m[1]
+    end
+
+    nil
+  end
+
   # @return [Boolean]
   def ok?
     @status == 0 || (@status >= 200 && @status <= 299)

data/lib/puppeteer/js_handle.rb

@@ -36,6 +36,14 @@ class Puppeteer::JSHandle
 
   attr_reader :context, :remote_object
 
+  def inspect
+    values = %i[context remote_object disposed].map do |sym|
+      value = instance_variable_get(:"@#{sym}")
+      "@#{sym}=#{value}"
+    end
+    "#<Puppeteer::JSHandle #{values.join(' ')}>"
+  end
+
   # @return [Puppeteer::ExecutionContext]
   def execution_context
     @context

data/lib/puppeteer/launcher/chrome.rb

@@ -27,21 +27,25 @@ module Puppeteer::Launcher
           @chrome_arg_options.args.dup
         end
 
-      #
-      # let temporaryUserDataDir = null;
-
       if chrome_arguments.none? { |arg| arg.start_with?('--remote-debugging-') }
         if @launch_options.pipe?
           chrome_arguments << '--remote-debugging-pipe'
         else
-          chrome_arguments << '--remote-debugging-port=0'
+          chrome_arguments << "--remote-debugging-port=#{@chrome_arg_options.debugging_port}"
         end
       end
 
-      temporary_user_data_dir = nil
-      if chrome_arguments.none? { |arg| arg.start_with?('--user-data-dir') }
-        temporary_user_data_dir = Dir.mktmpdir('puppeteer_dev_chrome_profile-')
-        chrome_arguments << "--user-data-dir=#{temporary_user_data_dir}"
+      user_data_dir = chrome_arguments.find { |arg| arg.start_with?('--user-data-dir') }
+      if user_data_dir
+        user_data_dir = user_data_dir.split('=').last
+        unless File.exist?(user_data_dir)
+          raise ArgumentError.new("Chrome user data dir not found at '#{user_data_dir}'")
+        end
+        using_temp_user_data_dir = false
+      else
+        user_data_dir = Dir.mktmpdir('puppeteer_dev_chrome_profile-', ENV['PUPPETEER_TMP_DIR'])
+        chrome_arguments << "--user-data-dir=#{user_data_dir}"
+        using_temp_user_data_dir = true
       end
 
       chrome_executable =
@@ -51,7 +55,13 @@ module Puppeteer::Launcher
           @launch_options.executable_path || fallback_executable_path
         end
       use_pipe = chrome_arguments.include?('--remote-debugging-pipe')
-      runner = Puppeteer::BrowserRunner.new(chrome_executable, chrome_arguments, temporary_user_data_dir)
+      runner = Puppeteer::BrowserRunner.new(
+        false,
+        chrome_executable,
+        chrome_arguments,
+        user_data_dir,
+        using_temp_user_data_dir,
+      )
       runner.start(
         handle_SIGHUP: @launch_options.handle_SIGHUP?,
         handle_SIGTERM: @launch_options.handle_SIGTERM?,
@@ -61,30 +71,39 @@ module Puppeteer::Launcher
         pipe: use_pipe,
       )
 
+      browser =
+        begin
+          connection = runner.setup_connection(
+            use_pipe: use_pipe,
+            timeout: @launch_options.timeout,
+            slow_mo: @browser_options.slow_mo,
+            preferred_revision: @preferred_revision,
+          )
+
+          Puppeteer::Browser.create(
+            connection: connection,
+            context_ids: [],
+            ignore_https_errors: @browser_options.ignore_https_errors?,
+            default_viewport: @browser_options.default_viewport,
+            process: runner.proc,
+            close_callback: -> { runner.close },
+          )
+        rescue
+          runner.kill
+          raise
+        end
+
       begin
-        connection = runner.setup_connection(
-          use_pipe: use_pipe,
+        browser.wait_for_target(
+          predicate: ->(target) { target.type == 'page' },
           timeout: @launch_options.timeout,
-          slow_mo: @browser_options.slow_mo,
-          preferred_revision: @preferred_revision,
-        )
-
-        browser = Puppeteer::Browser.create(
-          connection: connection,
-          context_ids: [],
-          ignore_https_errors: @browser_options.ignore_https_errors?,
-          default_viewport: @browser_options.default_viewport,
-          process: runner.proc,
-          close_callback: -> { runner.close },
         )
-
-        browser.wait_for_target(predicate: ->(target) { target.type == 'page' })
-
-        browser
       rescue
-        runner.kill
+        browser.close
         raise
       end
+
+      browser
     end
 
     class DefaultArgs
@@ -267,15 +286,15 @@ module Puppeteer::Launcher
         end
 
       chrome_path = chrome_path_map[channel]
-      if chrome_path.is_a?(Proc)
-        chrome_path = chrome_path.call
-      end
-
       unless chrome_path
         raise ArgumentError.new("Invalid channel: '#{channel}'. Allowed channel is #{chrome_path_map.keys}")
       end
 
-      unless File.exist?(chrome_path)
+      if chrome_path.is_a?(Proc)
+        chrome_path = chrome_path.call
+      end
+
+      if !chrome_path || !File.exist?(chrome_path)
         raise "#{channel} is not installed on this system.\nExpected path: #{chrome_path}"
       end
 

data/lib/puppeteer/launcher/chrome_arg_options.rb

@@ -34,9 +34,10 @@ module Puppeteer::Launcher
       if @headless.nil?
         @headless = !@devtools
       end
+      @debugging_port = options[:debugging_port] || 0
     end
 
-    attr_reader :args, :user_data_dir
+    attr_reader :args, :user_data_dir, :debugging_port
 
     def headless?
       @headless