Implement memory-persistent registration

content/browser/service_worker/service_worker_context_core.cc

Index: content/browser/service_worker/service_worker_context_core.cc
diff --git a/content/browser/service_worker/service_worker_context_core.cc b/content/browser/service_worker/service_worker_context_core.cc
index 22ae50070557838d6d3f29d6b7a80abf9bb36805..c24a72a21229f24fa39628cffb1f5cfa2490cc6a 100644
--- a/content/browser/service_worker/service_worker_context_core.cc
+++ b/content/browser/service_worker/service_worker_context_core.cc
@@ -6,28 +6,29 @@
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
+#include "base/strings/string_util.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
+#include "content/browser/service_worker/service_worker_register_job.h"
+#include "content/browser/service_worker/service_worker_registration.h"
+#include "content/browser/service_worker/service_worker_storage.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
-#include "webkit/browser/quota/quota_manager.h"
+#include "url/gurl.h"
 
 namespace content {
 
-namespace {
-
-const base::FilePath::CharType kServiceWorkerDirectory[] =
-    FILE_PATH_LITERAL("ServiceWorker");
-
-}  // namespace
-
 ServiceWorkerContextCore::ServiceWorkerContextCore(
-    const base::FilePath& user_data_directory,
+    const base::FilePath& path,
     quota::QuotaManagerProxy* quota_manager_proxy)
-    : quota_manager_proxy_(quota_manager_proxy) {
-  if (!user_data_directory.empty())
-    path_ = user_data_directory.Append(kServiceWorkerDirectory);
-}
+    : storage_(new ServiceWorkerStorage(path, quota_manager_proxy)),
+      is_shutdown_(false) {}
+
+ServiceWorkerContextCore::~ServiceWorkerContextCore() { DCHECK(is_shutdown_); }
 
-ServiceWorkerContextCore::~ServiceWorkerContextCore() {
+void ServiceWorkerContextCore::Shutdown() {
+  storage_->Shutdown();
+  storage_.reset();
+  is_shutdown_ = true;

[kinuko, 2013/12/04 13:04:29]

I still don't really see how having this separately could help things (after we
have Wrapper).  If we're not yet sure we can just add this later?

If we have situations where we want to do 2-phase termination, e.g. call
Shutdown path first and then delete things, then this is totally reasonable, but
otherwise always require calling additional method before shutdown usually just
increases coding burden-- that's my concern.

[alecflett, 2013/12/06 05:43:33]

Yeah, perhaps I've taken this pattern too far. I'll remove this and the storage
one.

 }
 
 ServiceWorkerProviderHost* ServiceWorkerContextCore::GetProviderHost(
@@ -67,4 +68,51 @@ bool ServiceWorkerContextCore::IsEnabled() {
       switches::kEnableServiceWorker);
 }
 
+void ServiceWorkerContextCore::RegisterServiceWorker(
+    const GURL& pattern,
+    const GURL& script_url,
+    const RegistrationCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  storage_->Register(pattern,
+                     script_url,
+                     base::Bind(&ServiceWorkerContextCore::RegistrationComplete,
+                                AsWeakPtr(),
+                                callback));
+}
+
+void ServiceWorkerContextCore::UnregisterServiceWorker(
+    const GURL& pattern,
+    const UnregistrationCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  storage_->Unregister(
+      pattern,
+      base::Bind(&ServiceWorkerContextCore::UnregistrationComplete,
+                 AsWeakPtr(),
+                 callback));
+}
+
+void ServiceWorkerContextCore::RegistrationComplete(
+    const ServiceWorkerContextCore::RegistrationCallback& callback,
+    ServiceWorkerRegistrationStatus status,
+    const scoped_refptr<ServiceWorkerRegistration>& registration) {
+  if (status != REGISTRATION_OK) {
+    DCHECK(!registration);
+    callback.Run(status, -1L);
+  }
+
+  callback.Run(status, registration->id());
+}
+
+void ServiceWorkerContextCore::UnregistrationComplete(
+    const UnregistrationCallback& callback,
+    ServiceWorkerRegistrationStatus status) {
+  // Unregistering a non-existent registration is a no-op.
+  if (status == REGISTRATION_OK || status == REGISTRATION_NOT_FOUND)
+    callback.Run(status);

[kinuko, 2013/12/04 13:04:29]

You meant callback.Run(REGISTRATION_OK) ?

Otherwise we can remove this if/else and just call Callback.run(status);

[alecflett, 2013/12/06 05:43:33]

oops, yes! Done.

+  else
+    callback.Run(status);
+}
+
 }  // namespace content