Implement memory-persistent registration

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/strings/string_util.h"
+#include "content/browser/service_worker/service_worker_register_job.h"
+#include "content/browser/service_worker/service_worker_registration.h"
+#include "content/public/browser/browser_thread.h"
+#include "webkit/browser/quota/quota_manager.h"
+
+namespace {
+// This is temporary until we figure out how registration ids will be
+// calculated.
+int64 NextRegistrationId() {
+  static int64 worker_id = 0;
+  return worker_id++;
+}
+}  // namespace
+
+namespace content {
+
+const base::FilePath::CharType kServiceWorkerDirectory[] =
+    FILE_PATH_LITERAL("ServiceWorker");
+
+ServiceWorkerStorage::ServiceWorkerStorage(
+    const base::FilePath& path,
+    quota::QuotaManagerProxy* quota_manager_proxy)
+    : quota_manager_proxy_(quota_manager_proxy), weak_factory_(this) {
+  if (!path.empty())
+    path_ = path.Append(kServiceWorkerDirectory);
+}
+
+ServiceWorkerStorage::~ServiceWorkerStorage() {
+  for (PatternToRegistrationMap::const_iterator iter =
+           registration_by_pattern_.begin();
+       iter != registration_by_pattern_.end();
+       ++iter) {
+    iter->second->Shutdown();
+  }
+  registration_by_pattern_.clear();
+}
+
+void ServiceWorkerStorage::FindRegistrationForPattern(
+    const GURL& pattern,
+    const RegistrationCallback& callback) {
+  PatternToRegistrationMap::const_iterator match =
+      registration_by_pattern_.find(pattern);
+  if (match == registration_by_pattern_.end()) {
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(callback,
+                   REGISTRATION_NOT_FOUND,
+                   scoped_refptr<ServiceWorkerRegistration>()));
+    return;
+  }
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(callback, REGISTRATION_OK, match->second));
+}
+
+void ServiceWorkerStorage::FindRegistrationForDocument(
+    const GURL& document_url,
+    const RegistrationCallback& callback) {
+  // TODO(alecflett): This needs to be synchronous in the fast path,
+  // but asynchronous in the slow path (when the patterns have to be
+  // loaded from disk). For now it is always pessimistically async.
+  for (PatternToRegistrationMap::const_iterator it =
+           registration_by_pattern_.begin();
+       it != registration_by_pattern_.end();
+       ++it) {
+    if (PatternMatches(it->first, document_url)) {
+      BrowserThread::PostTask(
+          BrowserThread::IO,
+          FROM_HERE,
+          base::Bind(callback,
+                     REGISTRATION_OK,
+                     scoped_refptr<ServiceWorkerRegistration>(it->second)));
+      return;
+    }
+  }
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(callback,
+                 REGISTRATION_NOT_FOUND,
+                 scoped_refptr<ServiceWorkerRegistration>()));
+}
+
+void ServiceWorkerStorage::Register(const GURL& pattern,
+                                    const GURL& script_url,
+                                    const RegistrationCallback& callback) {
+  scoped_ptr<ServiceWorkerRegisterJob> job(new ServiceWorkerRegisterJob(
+      weak_factory_.GetWeakPtr(),
+      base::Bind(&ServiceWorkerStorage::RegisterComplete,
+                 weak_factory_.GetWeakPtr(),
+                 callback)));
+  job->StartRegister(pattern, script_url);
+  registration_jobs_.push_back(job.release());
+}
+
+void ServiceWorkerStorage::Unregister(const GURL& pattern,
+                                      const UnregistrationCallback& callback) {
+  scoped_ptr<ServiceWorkerRegisterJob> job(new ServiceWorkerRegisterJob(
+      weak_factory_.GetWeakPtr(),
+      base::Bind(&ServiceWorkerStorage::UnregisterComplete,
+                 weak_factory_.GetWeakPtr(),
+                 callback)));
+  job->StartUnregister(pattern);
+  registration_jobs_.push_back(job.release());
+}
+
+scoped_refptr<ServiceWorkerRegistration> ServiceWorkerStorage::RegisterInternal(
+    const GURL& pattern,
+    const GURL& script_url) {
+
+  PatternToRegistrationMap::const_iterator current(
+      registration_by_pattern_.find(pattern));
+  DCHECK(current == registration_by_pattern_.end() ||
+         current->second->script_url() == script_url);
+
+  if (current == registration_by_pattern_.end()) {
+    scoped_refptr<ServiceWorkerRegistration> registration(
+        new ServiceWorkerRegistration(
+            pattern, script_url, NextRegistrationId()));
+    // TODO(alecflett): version upgrade path.
+    registration_by_pattern_[pattern] = registration;
+    return registration;
+  }
+
+  return current->second;
+}
+
+void ServiceWorkerStorage::UnregisterInternal(const GURL& pattern) {
+  PatternToRegistrationMap::const_iterator match =
+      registration_by_pattern_.find(pattern);
+  if (match != registration_by_pattern_.end()) {
+    match->second->Shutdown();
+    registration_by_pattern_.erase(match);
+  }
+}
+
+bool ServiceWorkerStorage::PatternMatches(const GURL& pattern,
+                                          const GURL& url) {
+  // This is a really basic, naive
+  // TODO(alecflett): Formalize what pattern matches mean.
+  // Temporarily borrowed directly from appcache::Namespace::IsMatch().
+  // We have to escape '?' characters since MatchPattern also treats those
+  // as wildcards which we don't want here, we only do '*'s.
+  std::string pattern_spec(pattern.spec());
+  if (pattern.has_query())
+    ReplaceSubstringsAfterOffset(&pattern_spec, 0, "?", "\\?");
+  return MatchPattern(url.spec(), pattern_spec);
+}
+
+void ServiceWorkerStorage::EraseJob(ServiceWorkerRegisterJob* job) {
+  ScopedVector<ServiceWorkerRegisterJob>::iterator job_position =
+      registration_jobs_.begin();
+  bool found = false;
+  for (; job_position != registration_jobs_.end(); ++job_position) {
+    if (*job_position == job) {
+      found = true;
+      registration_jobs_.erase(job_position);
+      return;
+    }
+  }
+  NOTREACHED() << "Deleting non-existent job. ";
+}
+
+void ServiceWorkerStorage::UnregisterComplete(
+    const UnregistrationCallback& callback,
+    ServiceWorkerRegisterJob* job,
+    ServiceWorkerRegistrationStatus status,
+    ServiceWorkerRegistration* previous_registration) {
+  callback.Run(status);
+  EraseJob(job);
+}
+
+void ServiceWorkerStorage::RegisterComplete(
+    const RegistrationCallback& callback,
+    ServiceWorkerRegisterJob* job,
+    ServiceWorkerRegistrationStatus status,
+    ServiceWorkerRegistration* registration) {
+  callback.Run(status, registration);
+  EraseJob(job);
+}
+
+}  // namespace content