ServiceWorker: Support longest-prefix-match for registration scope

content/browser/service_worker/service_worker_utils.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/service_worker/service_worker_utils.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "content/public/common/content_switches.h"
 
@@ skipping 12 matching lines @@
   DCHECK(!url.has_ref());
   const std::string& scope_spec = scope.spec();
   const std::string& url_spec = url.spec();
 
   size_t len = scope_spec.size();
   if (len > 0 && scope_spec[len - 1] == '*')
     return scope_spec.compare(0, len - 1, url_spec, 0, len - 1) == 0;
   return scope_spec == url_spec;
 }
 
+bool ServiceWorkerUtils::FindLongestScopeMatch(
+    const std::vector<GURL>& scopes, const GURL& url, size_t* pos) {
+  DCHECK(!url.has_ref());
+  DCHECK(pos);
+
+  bool found = false;
+  for (size_t i = 0; i < scopes.size(); ++i) {
+    if (!ScopeMatches(scopes[i], url))
+      continue;
+    if (!found || scopes.at(*pos) < scopes.at(i)) {

[jsbell, 2014/06/02 18:33:41]

This use of < here is weird. Do you mean to be comparing lengths? If so, you
want > so longest match wins.

If you're comparing the string contents, it would fail with this:

url: "foo/bar"
scope1: "foo/ba*"
scope2: "foo/b*"

Both match, scope2 < scope1, but scope1 is longer so should win.

[jsbell, 2014/06/02 18:36:54]

Uh, ignore this. My brain is on backwards today.

[jsbell, 2014/06/02 19:31:22]

Ah, I did find a counterexample:

url......: "foo/b(1)"
scope@pos: "foo/b*"
scope@i..: "foo/b(*"

The longest match is scope@i. But scope@pos > scope@i, so scope@i will not be
used.

You should probably compare lengths.

[nhiroki, 2014/06/03 18:05:03]

You're right!
I changed this to compare lengths.

Btw, there seems to be another 'wildcard-match' vs. 'exact-match' problem in
this way. How should we prioritize scopes which have the same length like this?

url:    "/foo"
scope1: "/fo*"
scope2: "/foo"

I'm not sure how we should prioritize them. I think there are some options:

a) Prioritizing "exact-match" (i.e. scope2 wins).
b) Picking up a latest one.
c) Comparing them in other way (e.g. dictionary order).

Wdyt? I mean to file a new issue or comment on the exist one[1] for spec
conformance.

[1] https://github.com/slightlyoff/ServiceWorker/issues/287

+      *pos = i;
+      found = true;
+    }
+  }
+  return found;
+}
+
 }  // namespace content