Implement memory-persistent registration

content/browser/service_worker/service_worker_context.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_context.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
+#include "base/strings/string_piece.h"
+#include "content/browser/service_worker/service_worker_version.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
+#include "url/gurl.h"
 #include "webkit/browser/quota/quota_manager.h"
 
+using base::StringPiece;
+
+namespace {
+
+static int64 NextRegistrationId() {

[kinuko, 2013/11/08 09:08:21]

nit: no need of static in anonymous namespace

[alecflett, 2013/11/08 22:50:54]

Done.

+  static int64 worker_id = 0;
+  return worker_id++;
+}
+}
+
 namespace content {
 
 const base::FilePath::CharType kServiceWorkerDirectory[] =
     FILE_PATH_LITERAL("ServiceWorker");
 
 ServiceWorkerContext::ServiceWorkerContext(
     const base::FilePath& path,
     quota::QuotaManagerProxy* quota_manager_proxy)
     : quota_manager_proxy_(quota_manager_proxy) {
   if (!path.empty())
     path_ = path.Append(kServiceWorkerDirectory);
 }
 
 bool ServiceWorkerContext::IsEnabled() {
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableServiceWorker);
 }
 
 ServiceWorkerContext::~ServiceWorkerContext() {}
 

[kinuko, 2013/11/08 09:08:21]

Please match the method order same as in header.

[alecflett, 2013/11/08 22:50:54]

Done.

+scoped_refptr<ServiceWorkerRegistration>
+ServiceWorkerContext::RegistrationForDocument(const GURL& document_url) {
+  for (PatternToRegistrationMap::const_iterator iter =
+           registration_by_pattern_.begin();
+       iter != registration_by_pattern_.end();
+       ++iter) {
+    if (PatternMatches(iter->first, document_url))
+      return iter->second;
+  }
+  return NULL;
+}
+
+ServiceWorkerRegistration* ServiceWorkerContext::Register(
+    const GURL& pattern,
+    const GURL& script_url) {
+  scoped_refptr<ServiceWorkerRegistration> registration(
+      new ServiceWorkerRegistration(pattern, script_url, NextRegistrationId()));
+
+  scoped_refptr<ServiceWorkerRegistration> previous_registration(
+      RegistrationForPattern(pattern));
+  if (previous_registration) {

[kinuko, 2013/11/08 09:08:21]

We first unregister in the RegisterServiceWorker code path below so we shouldn't
come this path?

[alecflett, 2013/11/08 22:50:54]

Done. (oops, leftover from early versions of this)

+    previous_registration->Shutdown();
+    previous_registration = NULL;
+  }
+  // This gets much more complicated if there is already a service
+  // worker here, especially if it is also running. For now we just
+  // clobber the one that is there, if any.
+  // TODO(alecflett): version upgrade path.
+  registration_by_pattern_[pattern] = registration;
+
+  return registration;
+}
+
+void ServiceWorkerContext::RegisterServiceWorker(
+    const GURL& pattern,
+    const GURL& script_url,
+    const ResponseCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  Unregister(pattern);
+  ServiceWorkerRegistration* registration = Register(pattern, script_url);

[kinuko, 2013/11/08 09:08:21]

Do we always unregister and register a new one?

[alecflett, 2013/11/08 22:50:54]

Yes. unregister is a no-op if there was no previous script.

This ensures that if there *was* a previous registration, that it is shutdown.
And actually, if the script_url is unchanged, this should be a no-op.

I'll add a test.

+  DCHECK(registration);
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE, base::Bind(callback, registration->id()));
+}
+
+void ServiceWorkerContext::UnregisterServiceWorker(
+    const GURL& pattern,
+    const base::Closure& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  Unregister(pattern);
+
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, callback);
+}
+
+void ServiceWorkerContext::Unregister(const GURL& pattern) {
+  scoped_refptr<ServiceWorkerRegistration> registration =
+      RegistrationForPattern(pattern);
+  if (registration) {
+    registration_by_pattern_.erase(pattern);
+    registration->Shutdown();
+  }
+}
+
+scoped_refptr<ServiceWorkerRegistration>
+ServiceWorkerContext::RegistrationForPattern(const GURL& pattern) {
+  PatternToRegistrationMap::const_iterator match =
+      registration_by_pattern_.find(pattern);
+  if (match == registration_by_pattern_.end())
+    return NULL;
+  return match->second;
+}
+
+bool ServiceWorkerContext::PatternMatches(const GURL& pattern,
+                                          const GURL& url) {
+  DCHECK(pattern.spec().length() > 0 && *pattern.spec().rbegin() == '*');
+  StringPiece pattern_prefix(pattern.spec().begin(), pattern.spec().end());
+  pattern_prefix.remove_suffix(1);
+
+  return StringPiece(url.spec()).starts_with(pattern_prefix);
+}
+
 }  // namespace content