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 9cb2cbecef8b2969c06f0e9e6302e0cd5b85cf09..3f32a8077d9d954f3bb48d49322181a44f669a27 100644
--- a/content/browser/service_worker/service_worker_context_core.cc
+++ b/content/browser/service_worker/service_worker_context_core.cc
@@ -6,24 +6,28 @@
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
+#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/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_); }
+
+void ServiceWorkerContextCore::Shutdown() {

[kinuko, 2013/11/25 08:17:10]

When this is expected to be called? If this is always called right before
context_core_.reset() we can simply do these in dtor (until we find we want to
call Shutdown() earlier than it's actually destructed)

[alecflett, 2013/11/26 00:19:14]

So here the pattern is that the refcounted objects (registration, version) can
exist in a "shutdown" state - separating out the memory allocation from the
"liveness" of the object. In general I'm hoping to propagate shutdown to various
objects which eventually result in the release of those objects, which delete
them entirely. In this case, ServiceWorkerContextCore is not refcounted, so
perhaps shutdown isn't necessary here. This is a bit of a collision with the
separation of ServiceWorkerContext (which was refcounted) into *Core/*Wrapper.
Perhaps it isn't necessary now. I'll revisit it.

In particular, I wanted to be able to handle the case where events are finishing
inside ServiceWorkerVersions 

+  storage_->Shutdown();
+  storage_.reset();
+  is_shutdown_ = true;
 }
 
 bool ServiceWorkerContextCore::IsEnabled() {
@@ -31,7 +35,31 @@ bool ServiceWorkerContextCore::IsEnabled() {
       switches::kEnableServiceWorker);
 }
 
-ServiceWorkerContextCore::~ServiceWorkerContextCore() {
+void ServiceWorkerContextCore::RegistrationComplete(

[kinuko, 2013/11/25 08:17:10]

nit: method order. (I'm so accustomed to the style where we have public methods
and then private methods in .cc too..)

[alecflett, 2013/11/26 00:19:14]

Sorry, I'll try to be consistent there.

+    const ServiceWorkerContextCore::ResponseCallback& callback,
+    const scoped_refptr<ServiceWorkerRegistration>& registration) {
+  callback.Run(registration->id());

[kinuko, 2013/11/25 08:17:10]

nit: until we need registration reference in this class Storage class can
directly return the new registered id rather than returning a ref?

[alecflett, 2013/11/26 00:19:14]

Well I'm trying to shield the Storage objects from knowing much about the
registration itself (i.e. there's no reason for it to know that the id is
special, nor should it have to maintain a map of id to object, or anything like
that). I'll see how this looks in the Storage class and possibly change it.

+}
+
+void ServiceWorkerContextCore::RegisterServiceWorker(
+    const GURL& pattern,
+    const GURL& script_url,
+    const ResponseCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  storage_->Register(pattern,
+                     script_url,
+                     base::Bind(&ServiceWorkerContextCore::RegistrationComplete,
+                                AsWeakPtr(),
+                                callback));
+}
+
+void ServiceWorkerContextCore::UnregisterServiceWorker(
+    const GURL& pattern,
+    const base::Closure& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  storage_->Unregister(pattern, callback);
 }
 
 }  // namespace content