Service Worker: Respect the "clear on exit" content setting

content/browser/service_worker/service_worker_storage.cc

Index: content/browser/service_worker/service_worker_storage.cc
diff --git a/content/browser/service_worker/service_worker_storage.cc b/content/browser/service_worker/service_worker_storage.cc
index 54eacd657f51bf4593d953a1f8bdf61a97cf6656..2c0d4a3169ad41c45f05671da0a039abf4697b3e 100644
--- a/content/browser/service_worker/service_worker_storage.cc
+++ b/content/browser/service_worker/service_worker_storage.cc
@@ -27,6 +27,7 @@
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
+#include "storage/browser/quota/special_storage_policy.h"
 
 namespace content {
 
@@ -218,6 +219,7 @@ DidDeleteRegistrationParams::~DidDeleteRegistrationParams() {
 }
 
 ServiceWorkerStorage::~ServiceWorkerStorage() {
+  ClearSessionOnlyOrigins();
   weak_factory_.InvalidateWeakPtrs();
   database_task_runner_->DeleteSoon(FROM_HERE, database_.release());
 }
@@ -228,12 +230,14 @@ scoped_ptr<ServiceWorkerStorage> ServiceWorkerStorage::Create(
     base::WeakPtr<ServiceWorkerContextCore> context,
     const scoped_refptr<base::SequencedTaskRunner>& database_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& disk_cache_thread,
-    storage::QuotaManagerProxy* quota_manager_proxy) {
+    storage::QuotaManagerProxy* quota_manager_proxy,
+    storage::SpecialStoragePolicy* special_storage_policy) {
   return make_scoped_ptr(new ServiceWorkerStorage(path,
                                                   context,
                                                   database_task_runner,
                                                   disk_cache_thread,
-                                                  quota_manager_proxy));
+                                                  quota_manager_proxy,
+                                                  special_storage_policy));
 }
 
 // static
@@ -245,7 +249,8 @@ scoped_ptr<ServiceWorkerStorage> ServiceWorkerStorage::Create(
                                context,
                                old_storage->database_task_runner_,
                                old_storage->disk_cache_thread_,
-                               old_storage->quota_manager_proxy_.get()));
+                               old_storage->quota_manager_proxy_.get(),
+                               old_storage->special_storage_policy_.get()));
 }
 
 void ServiceWorkerStorage::FindRegistrationForDocument(
@@ -682,7 +687,8 @@ ServiceWorkerStorage::ServiceWorkerStorage(
     base::WeakPtr<ServiceWorkerContextCore> context,
     const scoped_refptr<base::SequencedTaskRunner>& database_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& disk_cache_thread,
-    storage::QuotaManagerProxy* quota_manager_proxy)
+    storage::QuotaManagerProxy* quota_manager_proxy,
+    storage::SpecialStoragePolicy* special_storage_policy)
     : next_registration_id_(kInvalidServiceWorkerRegistrationId),
       next_version_id_(kInvalidServiceWorkerVersionId),
       next_resource_id_(kInvalidServiceWorkerResourceId),
@@ -692,6 +698,7 @@ ServiceWorkerStorage::ServiceWorkerStorage(
       database_task_runner_(database_task_runner),
       disk_cache_thread_(disk_cache_thread),
       quota_manager_proxy_(quota_manager_proxy),
+      special_storage_policy_(special_storage_policy),
       is_purge_pending_(false),
       has_checked_for_stale_resources_(false),
       weak_factory_(this) {
@@ -1167,6 +1174,27 @@ void ServiceWorkerStorage::DidCollectStaleResources(
   StartPurgingResources(stale_resource_ids);
 }
 
+void ServiceWorkerStorage::ClearSessionOnlyOrigins() {
+  // Can be null in unittests.
+  if (!special_storage_policy_.get())
+    return;
+
+  if (!special_storage_policy_->HasSessionOnlyOrigins())
+    return;
+
+  std::set<GURL> session_only_origins;
+  for (auto origin : registered_origins_) {

[michaeln, 2014/10/08 01:22:27]

ditto const GURL&

[falken, 2014/10/08 02:36:44]

Done.

+    if (special_storage_policy_->IsStorageSessionOnly(origin))
+      session_only_origins.insert(origin);
+  }
+  database_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &DeleteAllDataForOriginsFromDB,
+          database_.get(),
+          session_only_origins));
+}
+
 void ServiceWorkerStorage::CollectStaleResourcesFromDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
@@ -1373,6 +1401,15 @@ void ServiceWorkerStorage::FindForIdInDB(
       FROM_HERE, base::Bind(callback, data, resources, status));
 }
 
+void ServiceWorkerStorage::DeleteAllDataForOriginsFromDB(
+    ServiceWorkerDatabase* database,
+    const std::set<GURL>& origins) {
+  DCHECK(database);
+
+  std::vector<int64> newly_purgeable_resources;
+  database->DeleteAllDataForOrigins(origins, &newly_purgeable_resources);
+}
+
 // TODO(nhiroki): The corruption recovery should not be scheduled if the error
 // is transient and it can get healed soon (e.g. IO error). To do that, the
 // database should not disable itself when an error occurs and the storage