puppeteer-ruby 0.37.1 → 0.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56a2cd3d9440bce6f77f2a072e8c8e7ea83fdd3d65a7e85e1887f7f7dd4481ce
-  data.tar.gz: 337c5cd7e4c23bd5e3c154bbaaae229d4285c8ba491ca427197ee7449c1f1849
+  metadata.gz: d18f0aae5e331fee42f66c8140bdc3cced9c0514a03ab65460c4036a94bc6eb2
+  data.tar.gz: babeb261ac3661a6738eb3d02dddeef22685590791fbd579483edd2da7800606
 SHA512:
-  metadata.gz: '005883b864a160d29a8879a8d54945edbce02f6d1b80a0f8816d84244b46c62d11417e2bcf2bc67e8b7f7a4486dc201ecb2961070fe875fc948be0483be8bcee'
-  data.tar.gz: 1a7cd9d0c2aacde091d0f6d0738c61e4a28a96830f2b65dae8e6e84fd3c190ea69bf8e964748d61020f264bfcbc25901e4e1895289b1a98a7d5452c03e2647de
+  metadata.gz: 0d70da4b6dc257f39d020286672180d93a4fe2aa321828035eeba80aeff92e7b1f28ff07acd15396d03aad33ab84b4f3474f1c75b587cb833d90f17dde4b024f
+  data.tar.gz: ccb8a58f1ffff28d1498c560c8f17671064ca00ce4b98af9dbc5e844ab1c77d9c28fc503c021ae019d9e799a287976fe01a88bbce3f87979d163f7d384336c0e

data/CHANGELOG.md

@@ -1,7 +1,37 @@
-### master [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.37.1...master)]
+### main [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.38.0...main)]
 
 - xxx
 
+### 0.38.0 [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.37.4...0.38.0)]
+
+New features:
+
+- Puppeteer 11.0 functionalities
+    * OOP iframe support
+    * Customize debugging port
+    * HTTPRequest#initiator
+    * Customize temp directory for user data
+    * Add webp to screenshot quality option allow list
+
+
+### 0.37.4 [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.37.3...0.37.4)]
+
+Bugfix:
+
+- Fix ElementHandle#screenshot to work.
+
+### 0.37.3 [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.37.2...0.37.3)]
+
+Improvement:
+
+- Improve the logic of detection of Chrome/Firefox executable path on Linux.
+
+### 0.37.2 [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.37.1...0.37.2)]
+
+Bugfix:
+
+- `timeout: 0` did set the timeout value to zero. Now it disables the timeout as expected.
+
 ### 0.37.1 [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.37.0...0.37.1)]
 
 Bugfix:

data/README.md

@@ -41,7 +41,7 @@ NOTE: `require 'puppeteer-ruby'` is not necessary in Rails.
 ```ruby
 require 'puppeteer-ruby'
 
-Puppeteer.launch(headless: false, slow_mo: 50, args: ['--guest', '--window-size=1280,800']) do |browser|
+Puppeteer.launch(headless: false, slow_mo: 50, args: ['--window-size=1280,800']) do |browser|
   page = browser.new_page
   page.viewport = Puppeteer::Viewport.new(width: 1280, height: 800)
   page.goto("https://github.com/", wait_until: 'domcontentloaded')

data/docs/api_coverage.md

@@ -1,6 +1,6 @@
 # API coverages
-- Puppeteer version: v10.4.0
-- puppeteer-ruby version: 0.37.1
+- Puppeteer version: v12.0.0
+- puppeteer-ruby version: 0.38.0
 
 ## Puppeteer
 
@@ -134,6 +134,7 @@
 * viewport
 * ~~waitFor~~
 * waitForFileChooser => `#wait_for_file_chooser`
+* waitForFrame => `#wait_for_frame`
 * waitForFunction => `#wait_for_function`
 * waitForNavigation => `#wait_for_navigation`
 * ~~waitForNetworkIdle~~
@@ -226,6 +227,7 @@
 * goto
 * hover
 * isDetached => `#detached?`
+* isOOPFrame => `#oop_frame?`
 * name
 * parentFrame => `#parent_frame`
 * select
@@ -295,43 +297,44 @@
 * type => `#type_text`
 * uploadFile => `#upload_file`
 
-## ~~HTTPRequest~~
-
-* ~~abort~~
-* ~~abortErrorReason~~
-* ~~continue~~
-* ~~continueRequestOverrides~~
-* ~~enqueueInterceptAction~~
-* ~~failure~~
-* ~~finalizeInterceptions~~
-* ~~frame~~
-* ~~headers~~
-* ~~isNavigationRequest~~
-* ~~method~~
-* ~~postData~~
-* ~~redirectChain~~
-* ~~resourceType~~
-* ~~respond~~
-* ~~response~~
-* ~~responseForRequest~~
-* ~~url~~
+## HTTPRequest
+
+* abort
+* abortErrorReason => `#abort_error_reason`
+* continue
+* continueRequestOverrides => `#continue_request_overrides`
+* enqueueInterceptAction => `#enqueue_intercept_action`
+* failure
+* finalizeInterceptions => `#finalize_interceptions`
+* frame
+* headers
+* initiator
+* isNavigationRequest => `#navigation_request?`
+* method
+* postData => `#post_data`
+* redirectChain => `#redirect_chain`
+* resourceType => `#resource_type`
+* respond
+* response
+* responseForRequest => `#response_for_request`
+* url
 
-## ~~HTTPResponse~~
+## HTTPResponse
 
-* ~~buffer~~
-* ~~frame~~
+* buffer
+* frame
 * ~~fromCache~~
 * ~~fromServiceWorker~~
-* ~~headers~~
-* ~~json~~
+* headers
+* json
 * ~~ok~~
-* ~~remoteAddress~~
-* ~~request~~
-* ~~securityDetails~~
-* ~~status~~
-* ~~statusText~~
-* ~~text~~
-* ~~url~~
+* remoteAddress => `#remote_address`
+* request
+* securityDetails => `#security_details`
+* status
+* statusText => `#status_text`
+* text
+* url
 
 ## ~~SecurityDetails~~
 
@@ -357,6 +360,7 @@
 
 * connection
 * detach
+* id
 * send
 
 ## Coverage

data/lib/puppeteer/cdp_session.rb

@@ -15,6 +15,11 @@ class Puppeteer::CDPSession
     @session_id = session_id
   end
 
+  # @internal
+  def id
+    @session_id
+  end
+
   attr_reader :connection
 
   # @param method [String]

data/lib/puppeteer/dom_world.rb

@@ -45,10 +45,14 @@ class Puppeteer::DOMWorld
     end
   end
 
-  # @param {!Puppeteer.FrameManager} frameManager
-  # @param {!Puppeteer.Frame} frame
-  # @param {!Puppeteer.TimeoutSettings} timeoutSettings
-  def initialize(frame_manager, frame, timeout_settings)
+  # @param client [Puppeteer::CDPSession]
+  # @param frame_manager [Puppeteer::FrameManager]
+  # @param frame [Puppeteer::Frame]
+  # @param timeout_settings [Puppeteer::TimeoutSettings]
+  def initialize(client, frame_manager, frame, timeout_settings)
+    # Keep own reference to client because it might differ from the FrameManager's
+    # client for OOP iframes.
+    @client = client
     @frame_manager = frame_manager
     @frame = frame
     @timeout_settings = timeout_settings
@@ -58,7 +62,7 @@ class Puppeteer::DOMWorld
     @ctx_bindings = Set.new
     @detached = false
 
-    frame_manager.client.on_event('Runtime.bindingCalled', &method(:handle_binding_called))
+    @client.on_event('Runtime.bindingCalled', &method(:handle_binding_called))
   end
 
   attr_reader :frame

data/lib/puppeteer/element_handle.rb

@@ -323,7 +323,7 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
     end
   end
 
-  def screenshot(options = {})
+  def screenshot(type: nil, path: nil, full_page: nil, clip: nil, quality: nil, omit_background: nil, encoding: nil)
     needs_viewport_reset = false
 
     box = bounding_box
@@ -358,14 +358,16 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
     page_x = layout_metrics["layoutViewport"]["pageX"]
     page_y = layout_metrics["layoutViewport"]["pageY"]
 
-    clip = {
-      x: page_x + box.x,
-      y: page_y + box.y,
-      width: box.width,
-      height: box.height,
-    }
+    if clip.nil?
+      clip = {
+        x: page_x + box.x,
+        y: page_y + box.y,
+        width: box.width,
+        height: box.height,
+      }
+    end
 
-    @page.screenshot({ clip: clip }.merge(options))
+    @page.screenshot(type: type, path: path, full_page: full_page, clip: clip, quality: quality, omit_background: omit_background, encoding: encoding)
   ensure
     if needs_viewport_reset
       @page.viewport = viewport

data/lib/puppeteer/executable_path_finder.rb

@@ -0,0 +1,28 @@
+class Puppeteer::ExecutablePathFinder
+  # @param executable_names [Array<String>] executable file names to find.
+  def initialize(*executable_names)
+    @executable_names = executable_names
+  end
+
+  def find_executables_in_path
+    Enumerator.new do |result|
+      @executable_names.each do |name|
+        # Find the first existing path.
+        paths.each do |path|
+          candidate = File.join(path, name)
+          next unless File.exist?(candidate)
+          result << candidate
+          break
+        end
+      end
+    end
+  end
+
+  def find_first
+    find_executables_in_path.first
+  end
+
+  private def paths
+    ENV['PATH'].split(File::PATH_SEPARATOR)
+  end
+end

data/lib/puppeteer/frame.rb

@@ -1,25 +1,47 @@
 class Puppeteer::Frame
   using Puppeteer::DefineAsyncMethod
 
-  # @param {!FrameManager} frameManager
-  # @param {!Puppeteer.CDPSession} client
-  # @param {?Frame} parentFrame
-  # @param {string} frameId
-  def initialize(frame_manager, client, parent_frame, frame_id)
+  # @param frame_manager [Puppeteer::FrameManager]
+  # @param parent_frame [Puppeteer::Frame|nil]
+  # @param frame_id [String]
+  # @param client [Puppeteer::CDPSession]
+  def initialize(frame_manager, parent_frame, frame_id, client)
     @frame_manager = frame_manager
-    @client = client
     @parent_frame = parent_frame
     @id = frame_id
     @detached = false
 
     @loader_id = ''
     @lifecycle_events = Set.new
-    @main_world = Puppeteer::DOMWorld.new(frame_manager, self, frame_manager.timeout_settings)
-    @secondary_world = Puppeteer::DOMWorld.new(frame_manager, self, frame_manager.timeout_settings)
     @child_frames = Set.new
     if parent_frame
       parent_frame._child_frames << self
     end
+
+    update_client(client)
+  end
+
+  def inspect
+    values = %i[id parent_frame detached loader_id lifecycle_events child_frames].map do |sym|
+      value = instance_variable_get(:"@#{sym}")
+      "@#{sym}=#{value}"
+    end
+    "#<Puppeteer::Frame #{values.join(' ')}>"
+  end
+
+  def _client
+    @client
+  end
+
+  # @param client [Puppeteer::CDPSession]
+  private def update_client(client)
+    @client = client
+    @main_world = Puppeteer::DOMWorld.new(@client, @frame_manager, self, @frame_manager.timeout_settings)
+    @secondary_world = Puppeteer::DOMWorld.new(@client, @frame_manager, self, @frame_manager.timeout_settings)
+  end
+
+  def oop_frame?
+    @client != @frame_manager.client
   end
 
   attr_accessor :frame_manager, :id, :loader_id, :lifecycle_events, :main_world, :secondary_world
@@ -28,7 +50,7 @@ class Puppeteer::Frame
   # @param rederer [String]
   # @param timeout [number|nil]
   # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
-  # @return [Puppeteer::Response]
+  # @return [Puppeteer::HTTPResponse]
   def goto(url, referer: nil, timeout: nil, wait_until: nil)
     @frame_manager.navigate_frame(self, url, referer: referer, timeout: timeout, wait_until: wait_until)
   end

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
@@ -82,7 +99,7 @@ class Puppeteer::FrameManager
   # @param frame [Puppeteer::Frame]
   # @param url [String]
   # @param {!{referer?: string, timeout?: number, waitUntil?: string|!Array<string>}=} options
-  # @return [Puppeteer::Response]
+  # @return [Puppeteer::HTTPResponse]
   def navigate_frame(frame, url, referer: nil, timeout: nil, wait_until: nil)
     assert_no_legacy_navigation_options(wait_until: wait_until)
 
@@ -132,7 +149,7 @@ class Puppeteer::FrameManager
 
   # @param timeout [number|nil]
   # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
-  # @return [Puppeteer::Response]
+  # @return [Puppeteer::HTTPResponse]
   def wait_for_frame_navigation(frame, timeout: nil, wait_until: nil)
     assert_no_legacy_navigation_options(wait_until: wait_until)
 
@@ -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