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

Now Service Worker registrations and data get deleted as per
SpecialStoragePolicy.

BUG=419280

Review URL: https://codereview.chromium.org/633873002

Cr-Commit-Position: refs/heads/master@{#299842}

content/browser/service_worker/embedded_worker_test_helper.cc

@@ -23,10 +23,14 @@ EmbeddedWorkerTestHelper::EmbeddedWorkerTestHelper(int mock_render_process_id)
       next_thread_id_(0),
       mock_render_process_id_(mock_render_process_id),
       weak_factory_(this) {
+  scoped_ptr<MockServiceWorkerDatabaseTaskManager> database_task_manager(
+      new MockServiceWorkerDatabaseTaskManager(
+          base::MessageLoopProxy::current()));
   wrapper_->InitInternal(base::FilePath(),
                          base::MessageLoopProxy::current(),
+                         database_task_manager.Pass(),
                          base::MessageLoopProxy::current(),
-                         base::MessageLoopProxy::current(),
+                         NULL,
                          NULL);
   wrapper_->process_manager()->SetProcessIdForTest(mock_render_process_id);
   registry()->AddChildProcessSender(mock_render_process_id, this);

content/browser/service_worker/service_worker_context_core.cc

@@ -11,6 +11,7 @@
 #include "content/browser/service_worker/service_worker_cache_storage_manager.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
+#include "content/browser/service_worker/service_worker_database_task_manager.h"
 #include "content/browser/service_worker/service_worker_info.h"
 #include "content/browser/service_worker/service_worker_job_coordinator.h"
 #include "content/browser/service_worker/service_worker_process_manager.h"
@@ -84,9 +85,10 @@ void ServiceWorkerContextCore::ProviderHostIterator::Initialize() {
 ServiceWorkerContextCore::ServiceWorkerContextCore(
     const base::FilePath& path,
     const scoped_refptr<base::SequencedTaskRunner>& cache_task_runner,
-    const scoped_refptr<base::SequencedTaskRunner>& database_task_runner,
+    scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager,
     const scoped_refptr<base::SingleThreadTaskRunner>& disk_cache_thread,
     storage::QuotaManagerProxy* quota_manager_proxy,
+    storage::SpecialStoragePolicy* special_storage_policy,
     ObserverListThreadSafe<ServiceWorkerContextObserver>* observer_list,
     ServiceWorkerContextWrapper* wrapper)
     : weak_factory_(this),
@@ -94,9 +96,10 @@ ServiceWorkerContextCore::ServiceWorkerContextCore(
       providers_(new ProcessToProviderMap),
       storage_(ServiceWorkerStorage::Create(path,
                                             AsWeakPtr(),
-                                            database_task_runner,
+                                            database_task_manager.Pass(),
                                             disk_cache_thread,
-                                            quota_manager_proxy)),
+                                            quota_manager_proxy,
+                                            special_storage_policy)),
       cache_manager_(
           ServiceWorkerCacheStorageManager::Create(path,
                                                    cache_task_runner.get())),

content/browser/service_worker/service_worker_context_core.h

@@ -35,6 +35,7 @@ class URLRequestContext;
 
 namespace storage {
 class QuotaManagerProxy;
+class SpecialStoragePolicy;
 }
 
 namespace content {
@@ -43,6 +44,7 @@ class EmbeddedWorkerRegistry;
 class ServiceWorkerCacheStorageManager;
 class ServiceWorkerContextObserver;
 class ServiceWorkerContextWrapper;
+class ServiceWorkerDatabaseTaskManager;
 class ServiceWorkerHandle;
 class ServiceWorkerJobCoordinator;
 class ServiceWorkerProviderHost;
@@ -97,9 +99,10 @@ class CONTENT_EXPORT ServiceWorkerContextCore
   ServiceWorkerContextCore(
       const base::FilePath& user_data_directory,
       const scoped_refptr<base::SequencedTaskRunner>& cache_task_runner,
-      const scoped_refptr<base::SequencedTaskRunner>& database_task_runner,
+      scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_runner_manager,
       const scoped_refptr<base::SingleThreadTaskRunner>& disk_cache_thread,
       storage::QuotaManagerProxy* quota_manager_proxy,
+      storage::SpecialStoragePolicy* special_storage_policy,
       ObserverListThreadSafe<ServiceWorkerContextObserver>* observer_list,
       ServiceWorkerContextWrapper* wrapper);
   ServiceWorkerContextCore(

content/browser/service_worker/service_worker_context_wrapper.cc

@@ -18,6 +18,7 @@
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
+#include "storage/browser/quota/special_storage_policy.h"
 
 namespace content {
 
@@ -34,25 +35,24 @@ ServiceWorkerContextWrapper::~ServiceWorkerContextWrapper() {
 
 void ServiceWorkerContextWrapper::Init(
     const base::FilePath& user_data_directory,
-    storage::QuotaManagerProxy* quota_manager_proxy) {
+    storage::QuotaManagerProxy* quota_manager_proxy,
+    storage::SpecialStoragePolicy* special_storage_policy) {
   is_incognito_ = user_data_directory.empty();
-  scoped_refptr<base::SequencedTaskRunner> database_task_runner =
-      BrowserThread::GetBlockingPool()->
-          GetSequencedTaskRunnerWithShutdownBehavior(
-              BrowserThread::GetBlockingPool()->GetSequenceToken(),
-              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
+  scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager(
+      new ServiceWorkerDatabaseTaskManagerImpl(pool));
   scoped_refptr<base::SingleThreadTaskRunner> disk_cache_thread =
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE);
   scoped_refptr<base::SequencedTaskRunner> cache_task_runner =
-      BrowserThread::GetBlockingPool()
-          ->GetSequencedTaskRunnerWithShutdownBehavior(
-              BrowserThread::GetBlockingPool()->GetSequenceToken(),
-              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+      pool->GetSequencedTaskRunnerWithShutdownBehavior(
+          BrowserThread::GetBlockingPool()->GetSequenceToken(),
+          base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
   InitInternal(user_data_directory,
                cache_task_runner,
-               database_task_runner,
+               database_task_manager.Pass(),
                disk_cache_thread,
-               quota_manager_proxy);
+               quota_manager_proxy,
+               special_storage_policy);
 }
 
 void ServiceWorkerContextWrapper::Shutdown() {
@@ -239,9 +239,10 @@ void ServiceWorkerContextWrapper::SetBlobParametersForCache(
 void ServiceWorkerContextWrapper::InitInternal(
     const base::FilePath& user_data_directory,
     const scoped_refptr<base::SequencedTaskRunner>& stores_task_runner,
-    const scoped_refptr<base::SequencedTaskRunner>& database_task_runner,
+    scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager,
     const scoped_refptr<base::SingleThreadTaskRunner>& disk_cache_thread,
-    storage::QuotaManagerProxy* quota_manager_proxy) {
+    storage::QuotaManagerProxy* quota_manager_proxy,
+    storage::SpecialStoragePolicy* special_storage_policy) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
@@ -250,17 +251,19 @@ void ServiceWorkerContextWrapper::InitInternal(
                    this,
                    user_data_directory,
                    stores_task_runner,
-                   database_task_runner,
+                   base::Passed(&database_task_manager),
                    disk_cache_thread,
-                   make_scoped_refptr(quota_manager_proxy)));
+                   make_scoped_refptr(quota_manager_proxy),
+                   make_scoped_refptr(special_storage_policy)));
     return;
   }
   DCHECK(!context_core_);
   context_core_.reset(new ServiceWorkerContextCore(user_data_directory,
                                                    stores_task_runner,
-                                                   database_task_runner,
+                                                   database_task_manager.Pass(),
                                                    disk_cache_thread,
                                                    quota_manager_proxy,
+                                                   special_storage_policy,
                                                    observer_list_.get(),
                                                    this));
 }

content/browser/service_worker/service_worker_context_wrapper.h

@@ -26,6 +26,7 @@ class URLRequestContextGetter;
 
 namespace storage {
 class QuotaManagerProxy;
+class SpecialStoragePolicy;
 }
 
 namespace content {
@@ -48,7 +49,8 @@ class CONTENT_EXPORT ServiceWorkerContextWrapper
   // Init and Shutdown are for use on the UI thread when the profile,
   // storagepartition is being setup and torn down.
   void Init(const base::FilePath& user_data_directory,
-            storage::QuotaManagerProxy* quota_manager_proxy);
+            storage::QuotaManagerProxy* quota_manager_proxy,
+            storage::SpecialStoragePolicy* special_storage_policy);
   void Shutdown();
 
   // Deletes all files on disk and restarts the system asynchronously. This
@@ -100,9 +102,10 @@ class CONTENT_EXPORT ServiceWorkerContextWrapper
   void InitInternal(
       const base::FilePath& user_data_directory,
       const scoped_refptr<base::SequencedTaskRunner>& stores_task_runner,
-      const scoped_refptr<base::SequencedTaskRunner>& database_task_runner,
+      scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager,
       const scoped_refptr<base::SingleThreadTaskRunner>& disk_cache_thread,
-      storage::QuotaManagerProxy* quota_manager_proxy);
+      storage::QuotaManagerProxy* quota_manager_proxy,
+      storage::SpecialStoragePolicy* special_storage_policy);
   void ShutdownOnIO();
 
   void DidDeleteAndStartOver(ServiceWorkerStatusCode status);
@@ -120,7 +123,7 @@ class CONTENT_EXPORT ServiceWorkerContextWrapper
   // Cleared in Shutdown():
   scoped_ptr<ServiceWorkerContextCore> context_core_;
 
-  // Initialized in Init(); true of the user data directory is empty.
+  // Initialized in Init(); true if the user data directory is empty.
   bool is_incognito_;
 };
 

content/browser/service_worker/service_worker_database.cc

@@ -687,8 +687,8 @@ ServiceWorkerDatabase::PurgeUncommittedResourceIds(
   return WriteBatch(&batch);
 }
 
-ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteAllDataForOrigin(
-    const GURL& origin,
+ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteAllDataForOrigins(
+    const std::set<GURL>& origins,
     std::vector<int64>* newly_purgeable_resources) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   Status status = LazyOpen(false);
@@ -696,27 +696,28 @@ ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteAllDataForOrigin(
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
-  if (!origin.is_valid())
-    return STATUS_ERROR_FAILED;
-
   leveldb::WriteBatch batch;
 
-  // Delete from the unique origin list.
-  batch.Delete(CreateUniqueOriginKey(origin));
+  for (const GURL& origin : origins) {
+    if (!origin.is_valid())
+      return STATUS_ERROR_FAILED;
 
-  std::vector<RegistrationData> registrations;
-  status = GetRegistrationsForOrigin(origin, &registrations);
-  if (status != STATUS_OK)
-    return status;
+    // Delete from the unique origin list.
+    batch.Delete(CreateUniqueOriginKey(origin));
 
-  // Delete registrations and resource records.
-  for (std::vector<RegistrationData>::const_iterator itr =
-           registrations.begin(); itr != registrations.end(); ++itr) {
-    batch.Delete(CreateRegistrationKey(itr->registration_id, origin));
-    status = DeleteResourceRecords(
-        itr->version_id, newly_purgeable_resources, &batch);
+    std::vector<RegistrationData> registrations;
+    status = GetRegistrationsForOrigin(origin, &registrations);
     if (status != STATUS_OK)
       return status;
+
+    // Delete registrations and resource records.
+    for (const RegistrationData& data : registrations) {
+      batch.Delete(CreateRegistrationKey(data.registration_id, origin));
+      status = DeleteResourceRecords(
+          data.version_id, newly_purgeable_resources, &batch);
+      if (status != STATUS_OK)
+        return status;
+    }
   }
 
   return WriteBatch(&batch);

content/browser/service_worker/service_worker_database.h

@@ -185,13 +185,12 @@ class CONTENT_EXPORT ServiceWorkerDatabase {
   // Returns OK on success. Otherwise deletes nothing and returns an error.
   Status PurgeUncommittedResourceIds(const std::set<int64>& ids);
 
-  // Deletes all data for |origin|, namely, unique origin, registrations and
+  // Deletes all data for |origins|, namely, unique origin, registrations and
   // resource records. Resources are moved to the purgeable list. Returns OK if
   // they are successfully deleted or not found in the database. Otherwise,
   // returns an error.
-  Status DeleteAllDataForOrigin(
-      const GURL& origin,
-      std::vector<int64>* newly_purgeable_resources);
+  Status DeleteAllDataForOrigins(const std::set<GURL>& origins,
+                                 std::vector<int64>* newly_purgeable_resources);
 
   // Completely deletes the contents of the database.
   // Be careful using this function.

content/browser/service_worker/service_worker_database_task_manager.cc

+// Copyright 2014 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 "base/sequenced_task_runner.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "content/browser/service_worker/service_worker_database_task_manager.h"
+
+namespace content {
+
+ServiceWorkerDatabaseTaskManagerImpl::ServiceWorkerDatabaseTaskManagerImpl(
+    base::SequencedWorkerPool* pool) {
+  base::SequencedWorkerPool::SequenceToken token = pool->GetSequenceToken();
+  task_runner_ = pool->GetSequencedTaskRunner(token);
+  shutdown_blocking_task_runner_ =
+      pool->GetSequencedTaskRunnerWithShutdownBehavior(
+          token, base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+}
+
+ServiceWorkerDatabaseTaskManagerImpl::~ServiceWorkerDatabaseTaskManagerImpl() {
+}
+
+scoped_ptr<ServiceWorkerDatabaseTaskManager>
+ServiceWorkerDatabaseTaskManagerImpl::Clone() {
+  return make_scoped_ptr(new ServiceWorkerDatabaseTaskManagerImpl(
+      task_runner_, shutdown_blocking_task_runner_));
+}
+
+base::SequencedTaskRunner*
+ServiceWorkerDatabaseTaskManagerImpl::GetTaskRunner() {
+  return task_runner_.get();
+}
+
+base::SequencedTaskRunner*
+ServiceWorkerDatabaseTaskManagerImpl::GetShutdownBlockingTaskRunner() {
+  return shutdown_blocking_task_runner_.get();
+}
+
+ServiceWorkerDatabaseTaskManagerImpl::ServiceWorkerDatabaseTaskManagerImpl(
+    const scoped_refptr<base::SequencedTaskRunner>& task_runner,
+    const scoped_refptr<base::SequencedTaskRunner>&
+        shutdown_blocking_task_runner)
+    : task_runner_(task_runner),
+      shutdown_blocking_task_runner_(shutdown_blocking_task_runner) {
+}
+
+MockServiceWorkerDatabaseTaskManager::MockServiceWorkerDatabaseTaskManager(
+    const scoped_refptr<base::SequencedTaskRunner>& task_runner)
+    : task_runner_(task_runner) {
+}
+
+MockServiceWorkerDatabaseTaskManager::~MockServiceWorkerDatabaseTaskManager() {
+}
+
+scoped_ptr<ServiceWorkerDatabaseTaskManager>
+MockServiceWorkerDatabaseTaskManager::Clone() {
+  return make_scoped_ptr(
+      new MockServiceWorkerDatabaseTaskManager(task_runner_));
+}
+
+base::SequencedTaskRunner*
+MockServiceWorkerDatabaseTaskManager::GetTaskRunner() {
+  return task_runner_.get();
+}
+
+base::SequencedTaskRunner*
+MockServiceWorkerDatabaseTaskManager::GetShutdownBlockingTaskRunner() {
+  return task_runner_.get();
+}
+
+}  // namespace content

content/browser/service_worker/service_worker_database_task_manager.h

+// Copyright 2014 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.
+
+#ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DATABASE_TASK_RUNNER_MANAGER_
+#define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DATABASE_TASK_RUNNER_MANAGER_
+
+#include "base/memory/ref_counted.h"
+#include "content/common/content_export.h"
+
+namespace base {
+class SequencedTaskRunner;
+}
+
+namespace content {
+
+// Used to sequence ServiceWorkerDatabase tasks. Vends two task runners: one
+// that blocks shutdown and one that doesn't. The task runners use the same
+// sequence token, so no matter which runner you post to, the tasks run in the
+// order they are posted. This lets you post sequenced tasks with mixed shutdown
+// behaviors.
+class ServiceWorkerDatabaseTaskManager {
+ public:
+  virtual ~ServiceWorkerDatabaseTaskManager(){};
+  virtual scoped_ptr<ServiceWorkerDatabaseTaskManager> Clone() = 0;
+  virtual base::SequencedTaskRunner* GetTaskRunner() = 0;
+  virtual base::SequencedTaskRunner* GetShutdownBlockingTaskRunner() = 0;
+};
+
+class ServiceWorkerDatabaseTaskManagerImpl
+    : public ServiceWorkerDatabaseTaskManager {
+ public:
+  explicit ServiceWorkerDatabaseTaskManagerImpl(
+      base::SequencedWorkerPool* pool);
+  virtual ~ServiceWorkerDatabaseTaskManagerImpl();
+
+ protected:
+  virtual scoped_ptr<ServiceWorkerDatabaseTaskManager> Clone() override;
+  virtual base::SequencedTaskRunner* GetTaskRunner() override;
+  virtual base::SequencedTaskRunner* GetShutdownBlockingTaskRunner() override;
+
+ private:
+  ServiceWorkerDatabaseTaskManagerImpl(
+      const scoped_refptr<base::SequencedTaskRunner>& task_runner,
+      const scoped_refptr<base::SequencedTaskRunner>&
+          shutdown_blocking_task_runner);
+
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> shutdown_blocking_task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(ServiceWorkerDatabaseTaskManagerImpl);
+};
+
+// Dummy implementation for testing. It vends whatever you give it in the ctor.
+class CONTENT_EXPORT MockServiceWorkerDatabaseTaskManager
+    : public NON_EXPORTED_BASE(ServiceWorkerDatabaseTaskManager) {
+ public:
+  explicit MockServiceWorkerDatabaseTaskManager(
+      const scoped_refptr<base::SequencedTaskRunner>& task_runner);
+  virtual ~MockServiceWorkerDatabaseTaskManager();
+
+ protected:
+  virtual scoped_ptr<ServiceWorkerDatabaseTaskManager> Clone() override;
+  virtual base::SequencedTaskRunner* GetTaskRunner() override;
+  virtual base::SequencedTaskRunner* GetShutdownBlockingTaskRunner() override;
+
+ private:
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockServiceWorkerDatabaseTaskManager);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DATABASE_TASK_RUNNER_MANAGER_

content/browser/service_worker/service_worker_database_unittest.cc

@@ -995,9 +995,11 @@ TEST(ServiceWorkerDatabaseTest, DeleteAllDataForOrigin) {
       database->WriteRegistration(
           data3, resources3, &deleted_version_id, &newly_purgeable_resources));
 
+  std::set<GURL> origins_to_delete;
+  origins_to_delete.insert(origin1);
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->DeleteAllDataForOrigin(origin1,
-                                             &newly_purgeable_resources));
+            database->DeleteAllDataForOrigins(origins_to_delete,
+                                              &newly_purgeable_resources));
 
   // |origin1| should be removed from the unique origin list.
   std::set<GURL> unique_origins;

content/browser/service_worker/service_worker_registration_unittest.cc

@@ -23,11 +23,15 @@ class ServiceWorkerRegistrationTest : public testing::Test {
       : io_thread_(BrowserThread::IO, &message_loop_) {}
 
   virtual void SetUp() override {
+    scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager(
+        new MockServiceWorkerDatabaseTaskManager(
+            base::ThreadTaskRunnerHandle::Get()));
     context_.reset(
         new ServiceWorkerContextCore(base::FilePath(),
                                      base::ThreadTaskRunnerHandle::Get(),
+                                     database_task_manager.Pass(),
                                      base::ThreadTaskRunnerHandle::Get(),
-                                     base::ThreadTaskRunnerHandle::Get(),
+                                     NULL,
                                      NULL,
                                      NULL,
                                      NULL));

content/browser/service_worker/service_worker_storage.h

@@ -16,6 +16,7 @@
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/service_worker/service_worker_database.h"
+#include "content/browser/service_worker/service_worker_database_task_manager.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/content_export.h"
 #include "content/common/service_worker/service_worker_status_code.h"
@@ -28,6 +29,7 @@ class SingleThreadTaskRunner;
 
 namespace storage {
 class QuotaManagerProxy;
+class SpecialStoragePolicy;
 }
 
 namespace content {
@@ -61,9 +63,10 @@ class CONTENT_EXPORT ServiceWorkerStorage
   static scoped_ptr<ServiceWorkerStorage> Create(
       const base::FilePath& path,
       base::WeakPtr<ServiceWorkerContextCore> context,
-      const scoped_refptr<base::SequencedTaskRunner>& database_task_runner,
+      scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager,
       const scoped_refptr<base::SingleThreadTaskRunner>& disk_cache_thread,
-      storage::QuotaManagerProxy* quota_manager_proxy);
+      storage::QuotaManagerProxy* quota_manager_proxy,
+      storage::SpecialStoragePolicy* special_storage_policy);
 
   // Used for DeleteAndStartOver. Creates new storage based on |old_storage|.
   static scoped_ptr<ServiceWorkerStorage> Create(
@@ -175,6 +178,8 @@ class CONTENT_EXPORT ServiceWorkerStorage
                            UpdateRegistration);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerResourceStorageDiskTest,
                            CleanupOnRestart);
+  FRIEND_TEST_ALL_PREFIXES(ServiceWorkerResourceStorageDiskTest,
+                           ClearOnExit);
 
   struct InitialData {
     int64 next_registration_id;
@@ -223,9 +228,10 @@ class CONTENT_EXPORT ServiceWorkerStorage
   ServiceWorkerStorage(
       const base::FilePath& path,
       base::WeakPtr<ServiceWorkerContextCore> context,
-      const scoped_refptr<base::SequencedTaskRunner>& database_task_runner,
+      scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager,
       const scoped_refptr<base::SingleThreadTaskRunner>& disk_cache_thread,
-      storage::QuotaManagerProxy* quota_manager_proxy);
+      storage::QuotaManagerProxy* quota_manager_proxy,
+      storage::SpecialStoragePolicy* special_storage_policy);
 
   base::FilePath GetDatabasePath();
   base::FilePath GetDiskCachePath();
@@ -303,6 +309,8 @@ class CONTENT_EXPORT ServiceWorkerStorage
   void DidCollectStaleResources(const std::vector<int64>& stale_resource_ids,
                                 ServiceWorkerDatabase::Status status);
 
+  void ClearSessionOnlyOrigins();
+
   // Static cross-thread helpers.
   static void CollectStaleResourcesFromDB(
       ServiceWorkerDatabase* database,
@@ -340,6 +348,9 @@ class CONTENT_EXPORT ServiceWorkerStorage
       int64 registration_id,
       const GURL& origin,
       const FindInDBCallback& callback);
+  static void DeleteAllDataForOriginsFromDB(
+      ServiceWorkerDatabase* database,
+      const std::set<GURL>& origins);
 
   void ScheduleDeleteAndStartOver();
   void DidDeleteDatabase(
@@ -374,12 +385,13 @@ class CONTENT_EXPORT ServiceWorkerStorage
   base::FilePath path_;
   base::WeakPtr<ServiceWorkerContextCore> context_;
 
-  // Only accessed on |database_task_runner_|.
+  // Only accessed using |database_task_manager_|.
   scoped_ptr<ServiceWorkerDatabase> database_;
 
-  scoped_refptr<base::SequencedTaskRunner> database_task_runner_;
+  scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager_;
   scoped_refptr<base::SingleThreadTaskRunner> disk_cache_thread_;
   scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy_;
+  scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy_;
   scoped_ptr<ServiceWorkerDiskCache> disk_cache_;
   std::deque<int64> purgeable_resource_ids_;
   bool is_purge_pending_;

content/browser/service_worker/service_worker_storage_unittest.cc

@@ -192,11 +192,15 @@ class ServiceWorkerStorageTest : public testing::Test {
   }
 
   virtual void SetUp() override {
+    scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager(
+        new MockServiceWorkerDatabaseTaskManager(
+            base::ThreadTaskRunnerHandle::Get()));
     context_.reset(
         new ServiceWorkerContextCore(GetUserDataDirectory(),
                                      base::ThreadTaskRunnerHandle::Get(),
+                                     database_task_manager.Pass(),
                                      base::ThreadTaskRunnerHandle::Get(),
-                                     base::ThreadTaskRunnerHandle::Get(),
+                                     NULL,
                                      NULL,
                                      NULL,
                                      NULL));
@@ -810,11 +814,15 @@ TEST_F(ServiceWorkerResourceStorageDiskTest, MAYBE_CleanupOnRestart) {
   // Simulate browser shutdown. The purgeable and uncommitted resources are now
   // stale.
   context_.reset();
+  scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager(
+      new MockServiceWorkerDatabaseTaskManager(
+          base::ThreadTaskRunnerHandle::Get()));
   context_.reset(
       new ServiceWorkerContextCore(GetUserDataDirectory(),
                                    base::ThreadTaskRunnerHandle::Get(),
+                                   database_task_manager.Pass(),
                                    base::ThreadTaskRunnerHandle::Get(),
-                                   base::ThreadTaskRunnerHandle::Get(),
+                                   NULL,
                                    NULL,
                                    NULL,
                                    NULL));

content/browser/storage_partition_impl.cc

@@ -452,7 +452,8 @@ StoragePartitionImpl* StoragePartitionImpl::Create(
 
   scoped_refptr<ServiceWorkerContextWrapper> service_worker_context =
       new ServiceWorkerContextWrapper(context);
-  service_worker_context->Init(path, quota_manager->proxy());
+  service_worker_context->Init(
+      path, quota_manager->proxy(), context->GetSpecialStoragePolicy());
 
   scoped_refptr<ChromeAppCacheService> appcache_service =
       new ChromeAppCacheService(quota_manager->proxy());

content/content_browser.gypi

@@ -1179,6 +1179,8 @@
       'browser/service_worker/service_worker_controllee_request_handler.h',
       'browser/service_worker/service_worker_database.cc',
       'browser/service_worker/service_worker_database.h',
+      'browser/service_worker/service_worker_database_task_manager.cc',
+      'browser/service_worker/service_worker_database_task_manager.h',
       'browser/service_worker/service_worker_disk_cache.cc',
       'browser/service_worker/service_worker_disk_cache.h',
       'browser/service_worker/service_worker_dispatcher_host.cc',