[WIP] Service worker support

lib/ferrum/context.rb

@@ -58,11 +58,12 @@ def create_target
 
     def add_target(params)
       target = Target.new(@browser, params)
-      if target.window?
+      if target.window? || target.worker?
         @targets.put_if_absent(target.id, target)
       else
         @pendings.put(target, @browser.timeout)
       end
+      target
     end
 
     def update_target(target_id, params)

lib/ferrum/contexts.rb

@@ -50,19 +50,30 @@ def size
 
     private
 
+    TARGET_TYPES = %w[page worker].freeze
+
     def subscribe
       @browser.client.on("Target.targetCreated") do |params|
         info = params["targetInfo"]
-        next unless info["type"] == "page"
+        type = info["type"]
+        next unless TARGET_TYPES.include?(type)
+
+        target_id = info["targetId"]
+        @browser.command(
+          "Target.autoAttachRelated",
+          targetId: target_id,
+          waitForDebuggerOnStart: true, # Needed to capture all network requests
+          filter: [{type: "worker"}])
 
         context_id = info["browserContextId"]
-        @contexts[context_id]&.add_target(info)
+        target = @contexts[context_id]&.add_target(info)
+        target.build if type == "worker"
       end
 
       @browser.client.on("Target.targetInfoChanged") do |params|
         info = params["targetInfo"]
-        next unless info["type"] == "page"
-
+        next unless TARGET_TYPES.include?(info["type"])
+q
         context_id, target_id = info.values_at("browserContextId", "targetId")
         @contexts[context_id]&.update_target(target_id, info)
       end

lib/ferrum/page.rb

@@ -71,11 +71,12 @@ def reset
     # @return [Cookies]
     attr_reader :cookies
 
-    def initialize(target_id, browser, proxy: nil)
+    def initialize(target_id, browser, proxy: nil, type: "page")
       @frames = Concurrent::Map.new
       @main_frame = Frame.new(nil, self)
       @browser = browser
       @target_id = target_id
+      @type = type
       @timeout = @browser.timeout
       @event = Event.new.tap(&:set)
       self.proxy = proxy
@@ -355,13 +356,21 @@ def subscribe
     end
 
     def prepare_page
-      command("Page.enable")
-      command("Runtime.enable")
-      command("DOM.enable")
-      command("CSS.enable")
-      command("Log.enable")
+      if @type == "page"
+        command("Page.enable")
+        command("DOM.enable")
+        command("CSS.enable")
+        command("Runtime.enable")
+        command("Log.enable")
+        command("ServiceWorker.enable")
+      end
+
       command("Network.enable")
 
+      if @type == "worker"
+        command("Runtime.runIfWaitingForDebugger")
+      end
+
       if use_authorized_proxy?
         network.authorize(user: @proxy_user,
                           password: @proxy_password,
@@ -387,6 +396,8 @@ def prepare_page
 
       inject_extensions
 
+      return if @type == "worker"
+
       width, height = @browser.window_size
       resize(width: width, height: height)
 

lib/ferrum/target.rb

@@ -7,6 +7,7 @@ class Target
     # You can create page yourself and assign it to target, used in cuprite
     # where we enhance page class and build page ourselves.
     attr_writer :page
+    attr_reader :connection
 
     def initialize(browser, params = nil)
       @page = nil
@@ -23,12 +24,19 @@ def attached?
     end
 
     def page
-      @page ||= build_page
+      connection if page?
+    end
+
+    def network
+      connection.network
+    end
+
+    def build(**options)
+      connection(**options)
     end
 
     def build_page(**options)
-      maybe_sleep_if_new_window
-      Page.new(id, @browser, **options)
+      connection(**options)
     end
 
     def id
@@ -59,9 +67,27 @@ def window?
       !!opener_id
     end
 
+    def page?
+      @params["type"] == "page"
+    end
+
+    def worker?
+      @params["type"] == "worker"
+    end
+
     def maybe_sleep_if_new_window
       # Dirty hack because new window doesn't have events at all
       sleep(NEW_WINDOW_WAIT) if window?
     end
+
+    def connection(**options)
+      @connection ||= begin
+        maybe_sleep_if_new_window if page?
+
+        options.merge!(type: @params["type"])
+
+        Page.new(id, @browser, **options)
+      end
+    end
   end
 end

spec/network_spec.rb

@@ -30,6 +30,19 @@
       browser.go_to("/ferrum/with_js")
       expect(browser.network.traffic.length).to eq(4)
     end
+
+    it "keeps track of service workers" do
+      page.go_to("/ferrum/service_worker")
+
+      browser.network.wait_for_idle
+      traffic = browser.targets.values.map { _1.network.traffic }.flatten
+      urls = traffic.map { |e| e.request.url }
+
+      expect(urls.size).to eq(3)
+      expect(urls.grep(%r{/ferrum/service_worker$}).size).to eq(1)
+      expect(urls.grep(%r{/ferrum/one.png$}).size).to eq(1)
+      expect(urls.grep(%r{^blob:}).size).to eq(1)
+    end
   end
 
   it "#wait_for_idle" do

spec/support/application.rb

@@ -270,6 +270,11 @@ def authorized?(login, password)
       File.read("#{FERRUM_PUBLIC}/jquery-ui-1.11.4.min.js")
     end
 
+    get "/ferrum/one.png" do
+      content_type :png
+      File.read("#{FERRUM_PUBLIC}/one.png")
+    end
+
     get "/ferrum/unexist.png" do
       halt 404
     end

spec/support/views/service_worker.erb

@@ -0,0 +1,48 @@
+<html>
+  <body>
+    <script>
+      let code = `
+      async function imageFromUrl(url) {
+          const response = await fetch(url);
+
+          if (!response.ok) {
+              throw new Error(\`Failed to fetch \${url}: \${response.status} \${response.statusText}\`);
+          }
+
+          const blobResult = await response.blob();
+          const imageBitmap = await createImageBitmap(blobResult);
+          return imageBitmap;
+      }
+      self.onmessage = async (event) => {
+          try {
+              const image = await imageFromUrl(event.data.url);
+
+              self.postMessage({
+                  data: image
+              }, [image]);
+          }
+          catch(e)
+          {
+              self.postMessage({
+                  error: e
+              });
+          }
+      };
+      `;
+      let objectUrl = URL.createObjectURL(new Blob([code],{ type: "application/javascript"}))
+      let worker = new Worker(objectUrl);
+
+      worker.addEventListener("message", function(event) {
+        let canvas = document.getElementById('canvas');
+        let context = canvas.getContext('2d');
+        let imageBitmap = event.data.data;
+        context.drawImage(imageBitmap, 0, 0);
+      });
+
+      let path = "one.png"
+      let url = new URL(path, document.baseURI).href;
+      worker.postMessage({ url: url });
+    </script>
+    <canvas width="400" height="400" id="canvas"></canvas>
+  </body>
+</html>