tor-browser

fetch_event_worker.js (12395B)

---

// eslint-disable-next-line complexity
onfetch = function (ev) {
 if (ev.request.url.includes("ignore")) {
   return;
 }

 if (ev.request.url.includes("bare-synthesized.txt")) {
   ev.respondWith(
     Promise.resolve(new Response("synthesized response body", {}))
   );
 } else if (ev.request.url.includes("file_CrossSiteXHR_server.sjs")) {
   // N.B. this response would break the rules of CORS if it were allowed, but
   //      this test relies upon the preflight request not being intercepted and
   //      thus this response should not be used.
   if (ev.request.method == "OPTIONS") {
     ev.respondWith(
       new Response("", {
         headers: {
           "Access-Control-Allow-Origin": "*",
           "Access-Control-Allow-Headers": "X-Unsafe",
         },
       })
     );
   } else if (ev.request.url.includes("example.org")) {
     ev.respondWith(fetch(ev.request));
   }
 } else if (ev.request.url.includes("synthesized-404.txt")) {
   ev.respondWith(
     Promise.resolve(
       new Response("synthesized response body", { status: 404 })
     )
   );
 } else if (ev.request.url.includes("synthesized-headers.txt")) {
   ev.respondWith(
     Promise.resolve(
       new Response("synthesized response body", {
         headers: {
           "X-Custom-Greeting": "Hello",
         },
       })
     )
   );
 } else if (ev.request.url.includes("test-respondwith-response.txt")) {
   ev.respondWith(new Response("test-respondwith-response response body", {}));
 } else if (ev.request.url.includes("synthesized-redirect-real-file.txt")) {
   ev.respondWith(Promise.resolve(Response.redirect("fetch/real-file.txt")));
 } else if (
   ev.request.url.includes("synthesized-redirect-twice-real-file.txt")
 ) {
   ev.respondWith(
     Promise.resolve(Response.redirect("synthesized-redirect-real-file.txt"))
   );
 } else if (ev.request.url.includes("synthesized-redirect-synthesized.txt")) {
   ev.respondWith(Promise.resolve(Response.redirect("bare-synthesized.txt")));
 } else if (
   ev.request.url.includes("synthesized-redirect-twice-synthesized.txt")
 ) {
   ev.respondWith(
     Promise.resolve(Response.redirect("synthesized-redirect-synthesized.txt"))
   );
 } else if (ev.request.url.includes("rejected.txt")) {
   ev.respondWith(Promise.reject());
 } else if (ev.request.url.includes("nonresponse.txt")) {
   ev.respondWith(Promise.resolve(5));
 } else if (ev.request.url.includes("nonresponse2.txt")) {
   ev.respondWith(Promise.resolve({}));
 } else if (ev.request.url.includes("nonpromise.txt")) {
   try {
     // This should coerce to Promise(5) instead of throwing
     ev.respondWith(5);
   } catch (e) {
     // test is expecting failure, so return a success if we get a thrown
     // exception
     ev.respondWith(new Response("respondWith(5) threw " + e));
   }
 } else if (ev.request.url.includes("headers.txt")) {
   var ok = true;
   ok &= ev.request.headers.get("X-Test1") == "header1";
   ok &= ev.request.headers.get("X-Test2") == "header2";
   ev.respondWith(Promise.resolve(new Response(ok.toString(), {})));
 } else if (ev.request.url.includes("readable-stream.txt")) {
   ev.respondWith(
     new Response(
       new ReadableStream({
         start(controller) {
           controller.enqueue(
             new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21])
           );
           controller.close();
         },
       })
     )
   );
 } else if (ev.request.url.includes("readable-stream-locked.txt")) {
   let stream = new ReadableStream({
     start(controller) {
       controller.enqueue(
         new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21])
       );
       controller.close();
     },
   });

   ev.respondWith(new Response(stream));

   // This locks the stream.
   stream.getReader();
 } else if (ev.request.url.includes("readable-stream-with-exception.txt")) {
   ev.respondWith(
     new Response(
       new ReadableStream({
         start(controller) {},
         pull() {
           throw "EXCEPTION!";
         },
       })
     )
   );
 } else if (ev.request.url.includes("readable-stream-with-exception2.txt")) {
   ev.respondWith(
     new Response(
       new ReadableStream({
         _controller: null,
         _count: 0,

         start(controller) {
           this._controller = controller;
         },
         pull() {
           if (++this._count == 5) {
             throw "EXCEPTION 2!";
           }
           this._controller.enqueue(new Uint8Array([this._count]));
         },
       })
     )
   );
 } else if (ev.request.url.includes("readable-stream-already-consumed.txt")) {
   let r = new Response(
     new ReadableStream({
       start(controller) {
         controller.enqueue(
           new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21])
         );
         controller.close();
       },
     })
   );

   r.blob();

   ev.respondWith(r);
 } else if (ev.request.url.includes("user-pass")) {
   ev.respondWith(new Response(ev.request.url));
 } else if (ev.request.url.includes("nonexistent_image.gif")) {
   var imageAsBinaryString = atob(
     "R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs"
   );
   var imageLength = imageAsBinaryString.length;

   // If we just pass |imageAsBinaryString| to the Response constructor, an
   // encoding conversion occurs that corrupts the image. Instead, we need to
   // convert it to a typed array.
   // typed array.
   var imageAsArray = new Uint8Array(imageLength);
   for (var i = 0; i < imageLength; ++i) {
     imageAsArray[i] = imageAsBinaryString.charCodeAt(i);
   }

   ev.respondWith(
     Promise.resolve(
       new Response(imageAsArray, { headers: { "Content-Type": "image/gif" } })
     )
   );
 } else if (ev.request.url.includes("nonexistent_script.js")) {
   ev.respondWith(
     Promise.resolve(new Response("check_intercepted_script();", {}))
   );
 } else if (ev.request.url.includes("nonexistent_stylesheet.css")) {
   ev.respondWith(
     Promise.resolve(
       new Response("#style-test { background-color: black !important; }", {
         headers: {
           "Content-Type": "text/css",
         },
       })
     )
   );
 } else if (ev.request.url.includes("nonexistent_page.html")) {
   ev.respondWith(
     Promise.resolve(
       new Response(
         "<script>window.frameElement.test_result = true;</script>",
         {
           headers: {
             "Content-Type": "text/html",
           },
         }
       )
     )
   );
 } else if (ev.request.url.includes("navigate.html")) {
   var requests = [
     // should not throw
     new Request(ev.request),
     new Request(ev.request, undefined),
     new Request(ev.request, null),
     new Request(ev.request, {}),
     new Request(ev.request, { someUnrelatedProperty: 42 }),
     new Request(ev.request, { method: "GET" }),
   ];
   ev.respondWith(
     Promise.resolve(
       new Response(
         "<script>window.frameElement.test_result = true;</script>",
         {
           headers: {
             "Content-Type": "text/html",
           },
         }
       )
     )
   );
 } else if (ev.request.url.includes("nonexistent_worker_script.js")) {
   ev.respondWith(
     Promise.resolve(
       new Response("postMessage('worker-intercept-success')", {
         headers: { "Content-Type": "text/javascript" },
       })
     )
   );
 } else if (ev.request.url.includes("nonexistent_imported_script.js")) {
   ev.respondWith(
     Promise.resolve(
       new Response("check_intercepted_script();", {
         headers: { "Content-Type": "text/javascript" },
       })
     )
   );
 } else if (ev.request.url.includes("deliver-gzip")) {
   // Don't handle the request, this will make Necko perform a network request, at
   // which point SetApplyConversion must be re-enabled, otherwise the request
   // will fail.
   // eslint-disable-next-line no-useless-return
   return;
 } else if (ev.request.url.includes("hello.gz")) {
   ev.respondWith(fetch("fetch/deliver-gzip.sjs"));
 } else if (ev.request.url.includes("hello-after-extracting.gz")) {
   ev.respondWith(
     fetch("fetch/deliver-gzip.sjs").then(function (res) {
       return res.text().then(function (body) {
         return new Response(body, {
           status: res.status,
           statusText: res.statusText,
           headers: res.headers,
         });
       });
     })
   );
 } else if (ev.request.url.includes("opaque-on-same-origin")) {
   var url =
     "http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200";
   ev.respondWith(fetch(url, { mode: "no-cors" }));
 } else if (ev.request.url.includes("opaque-no-cors")) {
   if (ev.request.mode != "no-cors") {
     ev.respondWith(Promise.reject());
     return;
   }

   var url =
     "http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200";
   ev.respondWith(fetch(url, { mode: ev.request.mode }));
 } else if (ev.request.url.includes("cors-for-no-cors")) {
   if (ev.request.mode != "no-cors") {
     ev.respondWith(Promise.reject());
     return;
   }

   var url =
     "http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200&allowOrigin=*";
   ev.respondWith(fetch(url));
 } else if (ev.request.url.includes("example.com")) {
   ev.respondWith(fetch(ev.request));
 } else if (ev.request.url.includes("body-")) {
   ev.respondWith(
     ev.request.text().then(function (body) {
       return new Response(body + body);
     })
   );
 } else if (ev.request.url.includes("something.txt")) {
   ev.respondWith(Response.redirect("fetch/somethingelse.txt"));
 } else if (ev.request.url.includes("somethingelse.txt")) {
   ev.respondWith(new Response("something else response body", {}));
 } else if (ev.request.url.includes("redirect_serviceworker.sjs")) {
   // The redirect_serviceworker.sjs server-side JavaScript file redirects to
   // 'http://mochi.test:8888/tests/dom/serviceworkers/test/worker.js'
   // The redirected fetch should not go through the SW since the original
   // fetch was initiated from a SW.
   ev.respondWith(fetch("redirect_serviceworker.sjs"));
 } else if (
   ev.request.url.includes("load_cross_origin_xml_document_synthetic.xml")
 ) {
   ev.respondWith(
     Promise.resolve(
       new Response("<response>body</response>", {
         headers: { "Content-Type": "text/xtml" },
       })
     )
   );
 } else if (
   ev.request.url.includes("load_cross_origin_xml_document_cors.xml")
 ) {
   if (ev.request.mode != "same-origin") {
     ev.respondWith(Promise.reject());
     return;
   }

   var url =
     "http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200&allowOrigin=*";
   ev.respondWith(fetch(url, { mode: "cors" }));
 } else if (
   ev.request.url.includes("load_cross_origin_xml_document_opaque.xml")
 ) {
   if (ev.request.mode != "same-origin") {
     Promise.resolve(
       new Response("<error>Invalid Request mode</error>", {
         headers: { "Content-Type": "text/xtml" },
       })
     );
     return;
   }

   var url =
     "http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200";
   ev.respondWith(fetch(url, { mode: "no-cors" }));
 } else if (ev.request.url.includes("xhr-method-test.txt")) {
   ev.respondWith(new Response("intercepted " + ev.request.method));
 } else if (ev.request.url.includes("empty-header")) {
   if (
     !ev.request.headers.has("emptyheader") ||
     ev.request.headers.get("emptyheader") !== ""
   ) {
     ev.respondWith(Promise.reject());
     return;
   }
   ev.respondWith(new Response("emptyheader"));
 } else if (ev.request.url.includes("fetchevent-extendable")) {
   if (ev instanceof ExtendableEvent) {
     ev.respondWith(new Response("extendable"));
   } else {
     ev.respondWith(Promise.reject());
   }
 } else if (ev.request.url.includes("fetchevent-request")) {
   var threw = false;
   try {
     new FetchEvent("foo");
   } catch (e) {
     if (e.name == "TypeError") {
       threw = true;
     }
   } finally {
     ev.respondWith(new Response(threw ? "non-nullable" : "nullable"));
   }
 }
};