Implement support for link type serviceworker in link elements.

third_party/WebKit/LayoutTests/http/tests/serviceworker/resources/registration-tests.js

Index: third_party/WebKit/LayoutTests/http/tests/serviceworker/resources/registration-tests.js
diff --git a/third_party/WebKit/LayoutTests/http/tests/serviceworker/resources/registration-tests.js b/third_party/WebKit/LayoutTests/http/tests/serviceworker/resources/registration-tests.js
new file mode 100644
index 0000000000000000000000000000000000000000..053635646f869af9b4ff4a3442a7adf771e5b096
--- /dev/null
+++ b/third_party/WebKit/LayoutTests/http/tests/serviceworker/resources/registration-tests.js
@@ -0,0 +1,391 @@
+function registration_tests(register_method, check_error_types) {
+  function get_newest_worker(registration) {

[falken, 2016/03/18 01:11:43]

Many of our tests use registration.installing in the then() for register, which
I think is guaranteed by the spec (otherwise, we should convert them all to
get_newest_worker). Can you add a comment similar to your codereview comment
about why get_newest_worker is needed?

[Marijn Kruisselbrink, 2016/03/18 21:20:06]

Done

+    if (registration.installing)
+      return registration.installing;
+    if (registration.waiting)
+      return registration.waiting;
+    if (registration.active)
+      return registration.active;
+  }
+
+  promise_test(function(t) {
+      var script = 'resources/registration-worker.js';
+      var scope = 'resources/registration/normal';
+      return register_method(script, {scope: scope})
+        .then(function(registration) {
+            assert_equals(registration.constructor.name,
+                          'ServiceWorkerRegistration',
+                          'Successfully registered.');
+            service_worker_unregister_and_done(t, scope);
+          })
+    }, 'Registering normal scope');
+
+  promise_test(function(t) {
+      var script = 'resources/registration-worker.js';
+      var scope = 'resources/registration/scope-with-fragment#ref';
+      return register_method(script, {scope: scope})
+        .then(function(registration) {
+            assert_equals(registration.constructor.name,
+                          'ServiceWorkerRegistration',
+                          'Successfully registered.');
+            assert_equals(
+              registration.scope,
+              normalizeURL('resources/registration/scope-with-fragment'),
+              'A fragment should be removed from scope')
+            service_worker_unregister_and_done(t, scope);
+          })
+    }, 'Registering scope with fragment');
+
+  promise_test(function(t) {
+      var script = 'resources/registration-worker.js';
+      var scope = 'resources/';
+      return register_method(script, {scope: scope})
+        .then(function(registration) {
+            assert_equals(registration.constructor.name,
+                          'ServiceWorkerRegistration',
+                          'Successfully registered.');
+            service_worker_unregister_and_done(t, scope);
+          })
+    }, 'Registering same scope as the script directory');
+
+  promise_test(function(t) {
+      var script = 'resources/registration-worker.js';
+      var scope = 'resources';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'SecurityError' : null,
+          'Registering same scope as the script directory without the last ' +
+              'slash should fail with SecurityError.');
+    }, 'Registering same scope as the script directory without the last slash');
+
+  promise_test(function(t) {
+      var script = 'resources/registration-worker.js';
+      var scope = 'different-directory/';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'SecurityError' : null,
+          'Registration scope outside the script directory should fail ' +
+              'with SecurityError.');
+    }, 'Registration scope outside the script directory');
+
+  promise_test(function(t) {
+      var script = 'resources/registration-worker.js';
+      var scope = 'http://example.com/';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'SecurityError' : null,
+          'Registration scope outside domain should fail with SecurityError.');
+    }, 'Registering scope outside domain');
+
+  promise_test(function(t) {
+      var script = 'http://example.com/worker.js';
+      var scope = 'http://example.com/scope/';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'SecurityError' : null,
+          'Registration script outside domain should fail with SecurityError.');
+    }, 'Registering script outside domain');
+
+  promise_test(function(t) {
+      var script = 'resources/no-such-worker.js';
+      var scope = 'resources/scope/no-such-worker';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'NetworkError' : null,
+          navigator.serviceWorker.register(script, {scope: scope}),
+          'Registration of non-existent script should fail.');
+    }, 'Registering non-existent script');
+
+  promise_test(function(t) {
+      var script = 'resources/invalid-chunked-encoding.php';
+      var scope = 'resources/scope/invalid-chunked-encoding/';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'NetworkError' : null,
+          'Registration of invalid chunked encoding script should fail.');
+    }, 'Registering invalid chunked encoding script');
+
+  promise_test(function(t) {
+      var script = 'resources/invalid-chunked-encoding-with-flush.php';
+      var scope = 'resources/scope/invalid-chunked-encoding-with-flush/';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'NetworkError' : null,
+          'Registration of invalid chunked encoding script should fail.');
+    }, 'Registering invalid chunked encoding script with flush');
+
+  promise_test(function(t) {
+      var script = 'resources/mime-type-worker.php';
+      var scope = 'resources/scope/no-mime-type-worker/';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'SecurityError' : null,
+          'Registration of no MIME type script should fail.');
+    }, 'Registering script with no MIME type');
+
+  promise_test(function(t) {
+      var script = 'resources/mime-type-worker.php?mime=text/plain';
+      var scope = 'resources/scope/bad-mime-type-worker/';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'SecurityError' : null,
+          'Registration of plain text script should fail.');
+    }, 'Registering script with bad MIME type');
+
+  promise_test(function(t) {
+      var script = 'resources/redirect.php?Redirect=' +
+                    encodeURIComponent('/resources/registration-worker.js');
+      var scope = 'resources/scope/redirect/';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'SecurityError' : null,
+          'Registration of redirected script should fail.');
+    }, 'Registering redirected script');
+
+  promise_test(function(t) {
+      var script = 'resources/malformed-worker.php?parse-error';
+      var scope = 'resources/scope/parse-error';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'AbortError' : null,
+          'Registration of script including parse error should fail.');
+    }, 'Registering script including parse error');
+
+  promise_test(function(t) {
+      var script = 'resources/malformed-worker.php?undefined-error';
+      var scope = 'resources/scope/undefined-error';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'AbortError' : null,
+          'Registration of script including undefined error should fail.');
+    }, 'Registering script including undefined error');
+
+  promise_test(function(t) {
+      var script = 'resources/malformed-worker.php?uncaught-exception';
+      var scope = 'resources/scope/uncaught-exception';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'AbortError' : null,
+          'Registration of script including uncaught exception should fail.');
+    }, 'Registering script including uncaught exception');
+
+  promise_test(function(t) {
+      var script = 'resources/malformed-worker.php?caught-exception';
+      var scope = 'resources/scope/caught-exception';
+      return register_method(script, {scope: scope})
+          .then(function(registration) {
+              assert_equals(registration.constructor.name,
+                            'ServiceWorkerRegistration',
+                            'Successfully registered.');
+              service_worker_unregister_and_done(t, scope);
+            })
+    }, 'Registering script including caught exception');
+
+  promise_test(function(t) {
+      var script = 'resources/malformed-worker.php?import-malformed-script';
+      var scope = 'resources/scope/import-malformed-script';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'AbortError' : null,
+          'Registration of script importing malformed script should fail.');
+    }, 'Registering script importing malformed script');
+
+  promise_test(function(t) {
+      var script = 'resources/malformed-worker.php?import-no-such-script';
+      var scope = 'resources/scope/import-no-such-script';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'AbortError' : null,
+          'Registration of script importing non-existent script should fail.');
+    }, 'Registering script importing non-existent script');
+
+  promise_test(function(t) {
+      // URL-encoded full-width 'scope'.
+      var name = '%ef%bd%93%ef%bd%83%ef%bd%8f%ef%bd%90%ef%bd%85';
+      var script = 'resources/empty-worker.js';
+      var scope = 'resources/' + name + '/escaped-multibyte-character-scope';
+      return register_method(script, {scope: scope})
+        .then(function(registration) {
+            assert_equals(
+              registration.scope,
+              normalizeURL(scope),
+              'URL-encoded multibyte characters should be available.');
+            service_worker_unregister_and_done(t, scope);
+          });
+    }, 'Scope including URL-encoded multibyte characters');
+
+  promise_test(function(t) {
+      // Non-URL-encoded full-width "scope".
+      var name = String.fromCodePoint(0xff53, 0xff43, 0xff4f, 0xff50, 0xff45);
+      var script = 'resources/empty-worker.js';
+      var scope = 'resources/' + name  + '/non-escaped-multibyte-character-scope';
+      return register_method(script, {scope: scope})
+        .then(function(registration) {
+            assert_equals(
+              registration.scope,
+              normalizeURL(scope),
+              'Non-URL-encoded multibyte characters should be available.');
+            service_worker_unregister_and_done(t, scope);
+          });
+    }, 'Scope including non-escaped multibyte characters');
+
+  promise_test(function(t) {
+      var script = 'resources%2fempty-worker.js';
+      var scope = 'resources/scope/encoded-slash-in-script-url';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? new TypeError : null,
+          'URL-encoded slash in the script URL should be rejected.');
+    }, 'Script URL including URL-encoded slash');
+
+  promise_test(function(t) {
+      var script = 'resources%2Fempty-worker.js';
+      var scope = 'resources/scope/encoded-slash-in-script-url';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? new TypeError : null,
+          'URL-encoded slash in the script URL should be rejected.');
+    }, 'Script URL including uppercase URL-encoded slash');
+
+  promise_test(function(t) {
+      var script = 'resources/empty-worker.js';
+      var scope = 'resources/scope%2fencoded-slash-in-scope';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? new TypeError : null,
+          'URL-encoded slash in the scope should be rejected.');
+    }, 'Scope including URL-encoded slash');
+
+  promise_test(function(t) {
+      var script = 'resources%5cempty-worker.js';
+      var scope = 'resources/scope/encoded-slash-in-script-url';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? new TypeError : null,
+          'URL-encoded backslash in the script URL should be rejected.');
+    }, 'Script URL including URL-encoded backslash');
+
+  promise_test(function(t) {
+      var script = 'resources%5Cempty-worker.js';
+      var scope = 'resources/scope/encoded-slash-in-script-url';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? new TypeError : null,
+          'URL-encoded backslash in the script URL should be rejected.');
+    }, 'Script URL including uppercase URL-encoded backslash');
+
+  promise_test(function(t) {
+      var script = 'resources/empty-worker.js';
+      var scope = 'resources/scope%5cencoded-slash-in-scope';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? new TypeError : null,
+          'URL-encoded backslash in the scope should be rejected.');
+    }, 'Scope including URL-encoded backslash');
+
+  promise_test(function(t) {
+      var script = 'resources/././empty-worker.js';
+      var scope = 'resources/scope/parent-reference-in-script-url';
+      return register_method(script, {scope: scope})
+        .then(function(registration) {
+            assert_equals(
+              get_newest_worker(registration).scriptURL,
+              normalizeURL('resources/empty-worker.js'),
+              'Script URL including self-reference should be normalized.');
+            service_worker_unregister_and_done(t, scope);
+          });
+    }, 'Script URL including self-reference');
+
+  promise_test(function(t) {
+      var script = 'resources/empty-worker.js';
+      var scope = 'resources/././scope/self-reference-in-scope';
+      return register_method(script, {scope: scope})
+        .then(function(registration) {
+            assert_equals(
+              registration.scope,
+              normalizeURL('resources/scope/self-reference-in-scope'),
+              'Scope including self-reference should be normalized.');
+            service_worker_unregister_and_done(t, scope);
+          });
+    }, 'Scope including self-reference');
+
+  promise_test(function(t) {
+      var script = 'resources/../resources/empty-worker.js';
+      var scope = 'resources/scope/parent-reference-in-script-url';
+      return register_method(script, {scope: scope})
+        .then(function(registration) {
+            assert_equals(
+              get_newest_worker(registration).scriptURL,
+              normalizeURL('resources/empty-worker.js'),
+              'Script URL including parent-reference should be normalized.');
+            service_worker_unregister_and_done(t, scope);
+          });
+    }, 'Script URL including parent-reference');
+
+  promise_test(function(t) {
+      var script = 'resources/empty-worker.js';
+      var scope = 'resources/../resources/scope/parent-reference-in-scope';
+      return register_method(script, {scope: scope})
+        .then(function(registration) {
+            assert_equals(
+              registration.scope,
+              normalizeURL('resources/scope/parent-reference-in-scope'),
+              'Scope including parent-reference should be normalized.');
+            service_worker_unregister_and_done(t, scope);
+          });
+    }, 'Scope including parent-reference');
+
+  promise_test(function(t) {
+      var script = 'resources/empty-worker.js';
+      var scope = 'resources/../scope/parent-reference-in-scope';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'SecurityError' : null,
+          'Scope not under the script directory should be rejected.');
+    }, 'Scope including parent-reference and not under the script directory');
+
+  promise_test(function(t) {
+      var script = 'resources////empty-worker.js';
+      var scope = 'resources/scope/consecutive-slashes-in-script-url';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'SecurityError' : null,
+          'Consecutive slashes in the script url should not be unified.');
+    }, 'Script URL including consecutive slashes');
+
+  promise_test(function(t) {
+      var script = 'resources/empty-worker.js';
+      var scope = 'resources/scope////consecutive-slashes-in-scope';
+      return register_method(script, {scope: scope})
+        .then(function(registration) {
+            // Although consecutive slashes in the scope are not unified, the
+            // scope is under the script directory and registration should
+            // succeed.
+            assert_equals(
+              registration.scope,
+              normalizeURL(scope),
+              'Should successfully be registered.');
+            service_worker_unregister_and_done(t, scope);
+          })
+    }, 'Scope including consecutive slashes');
+
+  promise_test(function(t) {
+      var script = 'filesystem:' + normalizeURL('resources/empty-worker.js');
+      var scope = 'resources/scope/filesystem-script-url';
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'SecurityError' : null,
+          'Registering a script which has same-origin filesystem: URL should ' +
+              'fail with SecurityError.');
+    }, 'Script URL is same-origin filesystem: URL');
+
+  promise_test(function(t) {
+      var script = 'resources/empty-worker.js';
+      var scope = 'filesystem:' + normalizeURL('resources/scope/filesystem-scope-url');
+      return assert_promise_rejects(
+          register_method(script, {scope: scope}),
+          check_error_types ? 'SecurityError' : null,
+          'Registering with the scope that has same-origin filesystem: URL ' +
+              'should fail with SecurityError.');
+    }, 'Scope URL is same-origin filesystem: URL');
+}