ServiceWorker: Support longest-prefix-match for registration scope

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 666 matching lines @@
     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) {
   DCHECK(!document_url.has_ref());
-  // TODO(michaeln): if there are multiple matches the one with
-  // the longest scope should win.
+
+  LongestScopeMatcher matcher(document_url);
+  ServiceWorkerRegistration* match = NULL;
+
+  // TODO(nhiroki): This searches over installing registrations linearly and it
+  // couldn't be scalable. Maybe the regs should be partitioned by origin.
   for (RegistrationRefsById::const_iterator it =
            installing_registrations_.begin();
        it != installing_registrations_.end(); ++it) {
-    if (ServiceWorkerUtils::ScopeMatches(
-            it->second->pattern(), document_url)) {
-      return it->second;
-    }
+    if (matcher.MatchLongest(it->second->pattern()))
+      match = it->second;
   }
-  return NULL;
+  return match;
 }
 
 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 183 matching lines @@
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     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.
+
+  // Find one with a pattern match.
+  LongestScopeMatcher matcher(document_url);
+  int64 match = kInvalidServiceWorkerRegistrationId;
+  for (size_t i = 0; i < registrations.size(); ++i) {
+    if (matcher.MatchLongest(registrations[i].scope))
+      match = registrations[i].registration_id;
   }
 
+  if (match != kInvalidServiceWorkerRegistrationId)
+    status = database->ReadRegistration(match, 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,
     const GURL& scope,
     const FindInDBCallback& callback) {
@@ skipping 37 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