ServiceWorker: Scope should match url in longest-prefix-match way (won't commit)

content/browser/service_worker/service_worker_storage.cc

 // Copyright 2013 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_storage.h"
 
 #include <string>
 
 #include "base/bind_helpers.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 654 matching lines @@
   else
     NOTREACHED();
   // TODO(michaeln): Hmmm, what if DeleteReg was invoked after
   // the Find result we're returning here? NOTREACHED condition?
   return registration;
 }
 
 ServiceWorkerRegistration*
 ServiceWorkerStorage::FindInstallingRegistrationForDocument(
     const GURL& document_url) {
-  // TODO(michaeln): if there are multiple matches the one with
-  // the longest scope should win.
+  std::vector<GURL> scopes;
+  scopes.reserve(installing_registrations_.size());
   for (RegistrationRefsById::const_iterator it =
            installing_registrations_.begin();
        it != installing_registrations_.end(); ++it) {
-    if (ServiceWorkerUtils::ScopeMatches(
-            it->second->pattern(), document_url)) {
-      return it->second;
-    }
+    scopes.push_back(it->second->pattern());
   }
-  return NULL;
+
+  size_t pos = 0;
+  if (!ServiceWorkerUtils::FindLongestScopeMatch(scopes, document_url, &pos))
+    return NULL;
+  RegistrationRefsById::const_iterator it = installing_registrations_.begin();
+  std::advance(it, pos);
+  return it->second;
 }
 
 ServiceWorkerRegistration*
 ServiceWorkerStorage::FindInstallingRegistrationForPattern(
     const GURL& scope) {
   for (RegistrationRefsById::const_iterator it =
            installing_registrations_.begin();
        it != installing_registrations_.end(); ++it) {
     if (it->second->pattern() == scope)
       return it->second;
@@ skipping 184 matching lines @@
     original_task_runner->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    ServiceWorkerDatabase::RegistrationData(),
                    ResourceList(),
                    status));
     return;
   }
 
   // Find one with a pattern match.
-  // TODO(michaeln): if there are multiple matches the one with
-  // the longest scope should win.
   ServiceWorkerDatabase::RegistrationData data;
   ResourceList resources;
   status = ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND;
-  for (RegistrationList::const_iterator it = registrations.begin();
-       it != registrations.end(); ++it) {
-    if (!ServiceWorkerUtils::ScopeMatches(it->scope, document_url))
-      continue;
-    status = database->ReadRegistration(it->registration_id, origin,
-                                        &data, &resources);
-    break;  // We're done looping.
+
+  std::vector<GURL> scopes;
+  scopes.reserve(registrations.size());
+  for (size_t i = 0; i < registrations.size(); ++i)
+    scopes.push_back(registrations[i].scope);
+  size_t pos = 0;
+  if (ServiceWorkerUtils::FindLongestScopeMatch(scopes, document_url, &pos)) {
+    status = database->ReadRegistration(registrations[pos].registration_id,
+                                        origin, &data, &resources);
   }
 
   original_task_runner->PostTask(
       FROM_HERE,
       base::Bind(callback, data, resources, status));
 }
 
 void ServiceWorkerStorage::FindForPatternInDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
@@ skipping 39 matching lines @@
     const FindInDBCallback& callback) {
   ServiceWorkerDatabase::RegistrationData data;
   ResourceList resources;
   ServiceWorkerDatabase::Status status =
       database->ReadRegistration(registration_id, origin, &data, &resources);
   original_task_runner->PostTask(
       FROM_HERE, base::Bind(callback, data, resources, status));
 }
 
 }  // namespace content