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

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/bind_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/files/file_util.h"
 #include "base/hash.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_disk_cache.h"
 #include "content/browser/service_worker/service_worker_info.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/completion_callback.h"
 #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 {
 
 namespace {
 
 void RunSoon(const tracked_objects::Location& from_here,
              const base::Closure& closure) {
   base::MessageLoop::current()->PostTask(from_here, closure);
 }
 
@@ skipping 171 matching lines @@
 ServiceWorkerStorage::
 DidDeleteRegistrationParams::DidDeleteRegistrationParams()
     : registration_id(kInvalidServiceWorkerRegistrationId) {
 }
 
 ServiceWorkerStorage::
 DidDeleteRegistrationParams::~DidDeleteRegistrationParams() {
 }
 
 ServiceWorkerStorage::~ServiceWorkerStorage() {
+  ClearSessionOnlyOrigins();
   weak_factory_.InvalidateWeakPtrs();
-  database_task_runner_->DeleteSoon(FROM_HERE, database_.release());
+  database_task_manager_->GetTaskRunner()->DeleteSoon(FROM_HERE,
+                                                      database_.release());
 }
 
 // static
 scoped_ptr<ServiceWorkerStorage> 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) {
   return make_scoped_ptr(new ServiceWorkerStorage(path,
                                                   context,
-                                                  database_task_runner,
+                                                  database_task_manager.Pass(),
                                                   disk_cache_thread,
-                                                  quota_manager_proxy));
+                                                  quota_manager_proxy,
+                                                  special_storage_policy));
 }
 
 // static
 scoped_ptr<ServiceWorkerStorage> ServiceWorkerStorage::Create(
     base::WeakPtr<ServiceWorkerContextCore> context,
     ServiceWorkerStorage* old_storage) {
   return make_scoped_ptr(
       new ServiceWorkerStorage(old_storage->path_,
                                context,
-                               old_storage->database_task_runner_,
+                               old_storage->database_task_manager_->Clone(),
                                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(
     const GURL& document_url,
     const FindRegistrationCallback& callback) {
   DCHECK(!document_url.has_ref());
   if (!LazyInitialize(base::Bind(
           &ServiceWorkerStorage::FindRegistrationForDocument,
           weak_factory_.GetWeakPtr(), document_url, callback))) {
     if (state_ != INITIALIZING || !context_) {
@@ skipping 29 matching lines @@
   }
 
   // To connect this TRACE_EVENT with the callback, TimeTicks is used for
   // callback id.
   int64 callback_id = base::TimeTicks::Now().ToInternalValue();
   TRACE_EVENT_ASYNC_BEGIN1(
       "ServiceWorker",
       "ServiceWorkerStorage::FindRegistrationForDocument",
       callback_id,
       "URL", document_url.spec());
-  database_task_runner_->PostTask(
+  database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           &FindForDocumentInDB,
           database_.get(),
           base::MessageLoopProxy::current(),
           document_url,
           base::Bind(&ServiceWorkerStorage::DidFindRegistrationForDocument,
                      weak_factory_.GetWeakPtr(),
                      document_url,
                      callback,
@@ skipping 21 matching lines @@
         FindInstallingRegistrationForPattern(scope);
     CompleteFindSoon(FROM_HERE,
                      installing_registration,
                      installing_registration.get()
                          ? SERVICE_WORKER_OK
                          : SERVICE_WORKER_ERROR_NOT_FOUND,
                      callback);
     return;
   }
 
-  database_task_runner_->PostTask(
+  database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           &FindForPatternInDB,
           database_.get(),
           base::MessageLoopProxy::current(),
           scope,
           base::Bind(&ServiceWorkerStorage::DidFindRegistrationForPattern,
                      weak_factory_.GetWeakPtr(), scope, callback)));
 }
 
@@ skipping 41 matching lines @@
     return;
   }
 
   scoped_refptr<ServiceWorkerRegistration> registration =
       context_->GetLiveRegistration(registration_id);
   if (registration.get()) {
     CompleteFindNow(registration, SERVICE_WORKER_OK, callback);
     return;
   }
 
-  database_task_runner_->PostTask(
+  database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&FindForIdInDB,
                  database_.get(),
                  base::MessageLoopProxy::current(),
                  registration_id, origin,
                  base::Bind(&ServiceWorkerStorage::DidFindRegistrationForId,
                             weak_factory_.GetWeakPtr(), callback)));
 }
 
 void ServiceWorkerStorage::GetAllRegistrations(
     const GetAllRegistrationInfosCallback& callback) {
   if (!LazyInitialize(base::Bind(
           &ServiceWorkerStorage::GetAllRegistrations,
           weak_factory_.GetWeakPtr(), callback))) {
     if (state_ != INITIALIZING || !context_) {
       RunSoon(FROM_HERE, base::Bind(
           callback, std::vector<ServiceWorkerRegistrationInfo>()));
     }
     return;
   }
   DCHECK_EQ(INITIALIZED, state_);
 
   RegistrationList* registrations = new RegistrationList;
   PostTaskAndReplyWithResult(
-      database_task_runner_.get(),
+      database_task_manager_->GetTaskRunner(),
       FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::GetAllRegistrations,
                  base::Unretained(database_.get()),
                  base::Unretained(registrations)),
       base::Bind(&ServiceWorkerStorage::DidGetAllRegistrations,
                  weak_factory_.GetWeakPtr(),
                  callback,
                  base::Owned(registrations)));
 }
 
@@ skipping 18 matching lines @@
   data.version_id = version->version_id();
   data.last_update_check = registration->last_update_check();
   data.is_active = (version == registration->active_version());
 
   ResourceList resources;
   version->script_cache_map()->GetResources(&resources);
 
   if (!has_checked_for_stale_resources_)
     DeleteStaleResources();
 
-  database_task_runner_->PostTask(
+  database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&WriteRegistrationInDB,
                  database_.get(),
                  base::MessageLoopProxy::current(),
                  data, resources,
                  base::Bind(&ServiceWorkerStorage::DidStoreRegistration,
                             weak_factory_.GetWeakPtr(),
                             callback)));
 
   registration->set_is_deleted(false);
 }
 
 void ServiceWorkerStorage::UpdateToActiveState(
     ServiceWorkerRegistration* registration,
     const StatusCallback& callback) {
   DCHECK(registration);
 
   DCHECK(state_ == INITIALIZED || state_ == DISABLED) << state_;
   if (IsDisabled() || !context_) {
     RunSoon(FROM_HERE, base::Bind(callback, SERVICE_WORKER_ERROR_FAILED));
     return;
   }
 
   PostTaskAndReplyWithResult(
-      database_task_runner_.get(),
+      database_task_manager_->GetTaskRunner(),
       FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::UpdateVersionToActive,
                  base::Unretained(database_.get()),
                  registration->id(),
                  registration->pattern().GetOrigin()),
       base::Bind(&ServiceWorkerStorage::DidUpdateToActiveState,
                  weak_factory_.GetWeakPtr(),
                  callback));
 }
 
 void ServiceWorkerStorage::UpdateLastUpdateCheckTime(
     ServiceWorkerRegistration* registration) {
   DCHECK(registration);
 
   DCHECK(state_ == INITIALIZED || state_ == DISABLED) << state_;
   if (IsDisabled() || !context_)
     return;
 
-  database_task_runner_->PostTask(
+  database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           base::IgnoreResult(&ServiceWorkerDatabase::UpdateLastCheckTime),
           base::Unretained(database_.get()),
           registration->id(),
           registration->pattern().GetOrigin(),
           registration->last_update_check()));
 }
 
 void ServiceWorkerStorage::DeleteRegistration(
     int64 registration_id,
     const GURL& origin,
     const StatusCallback& callback) {
   DCHECK(state_ == INITIALIZED || state_ == DISABLED) << state_;
   if (IsDisabled() || !context_) {
     RunSoon(FROM_HERE, base::Bind(callback, SERVICE_WORKER_ERROR_FAILED));
     return;
   }
 
   if (!has_checked_for_stale_resources_)
     DeleteStaleResources();
 
   DidDeleteRegistrationParams params;
   params.registration_id = registration_id;
   params.origin = origin;
   params.callback = callback;
 
-  database_task_runner_->PostTask(
+  database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&DeleteRegistrationFromDB,
                  database_.get(),
                  base::MessageLoopProxy::current(),
                  registration_id, origin,
                  base::Bind(&ServiceWorkerStorage::DidDeleteRegistration,
                             weak_factory_.GetWeakPtr(), params)));
 
   // The registration should no longer be findable.
   pending_deletions_.insert(registration_id);
@@ skipping 15 matching lines @@
       new ServiceWorkerResponseWriter(response_id, disk_cache()));
 }
 
 void ServiceWorkerStorage::StoreUncommittedResponseId(int64 id) {
   DCHECK_NE(kInvalidServiceWorkerResponseId, id);
   DCHECK_EQ(INITIALIZED, state_);
 
   if (!has_checked_for_stale_resources_)
     DeleteStaleResources();
 
-  database_task_runner_->PostTask(
+  database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(
           &ServiceWorkerDatabase::WriteUncommittedResourceIds),
           base::Unretained(database_.get()),
           std::set<int64>(&id, &id + 1)));
 }
 
 void ServiceWorkerStorage::DoomUncommittedResponse(int64 id) {
   DCHECK_NE(kInvalidServiceWorkerResponseId, id);
-  database_task_runner_->PostTask(
+  database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(
           &ServiceWorkerDatabase::PurgeUncommittedResourceIds),
           base::Unretained(database_.get()),
           std::set<int64>(&id, &id + 1)));
   StartPurgingResources(std::vector<int64>(1, id));
 }
 
 void ServiceWorkerStorage::CompareScriptResources(
     int64 lhs_id, int64 rhs_id,
     const CompareCallback& callback) {
   DCHECK(!callback.is_null());
   scoped_refptr<ResponseComparer> comparer =
       new ResponseComparer(weak_factory_.GetWeakPtr(),
                            CreateResponseReader(lhs_id),
                            CreateResponseReader(rhs_id),
                            callback);
   comparer->Start();  // It deletes itself when done.
 }
 
 void ServiceWorkerStorage::DeleteAndStartOver(const StatusCallback& callback) {
   Disable();
 
   // Delete the database on the database thread.
   PostTaskAndReplyWithResult(
-      database_task_runner_.get(),
+      database_task_manager_->GetTaskRunner(),
       FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::DestroyDatabase,
                  base::Unretained(database_.get())),
       base::Bind(&ServiceWorkerStorage::DidDeleteDatabase,
                  weak_factory_.GetWeakPtr(),
                  callback));
 }
 
 int64 ServiceWorkerStorage::NewRegistrationId() {
   if (state_ == DISABLED)
@@ skipping 29 matching lines @@
       ServiceWorkerStatusCode status) {
   installing_registrations_.erase(registration->id());
   if (status != SERVICE_WORKER_OK && version) {
     ResourceList resources;
     version->script_cache_map()->GetResources(&resources);
 
     std::set<int64> ids;
     for (size_t i = 0; i < resources.size(); ++i)
       ids.insert(resources[i].resource_id);
 
-    database_task_runner_->PostTask(
+    database_task_manager_->GetTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(
             &ServiceWorkerDatabase::PurgeUncommittedResourceIds),
             base::Unretained(database_.get()),
             ids));
   }
 }
 
 void ServiceWorkerStorage::NotifyUninstallingRegistration(
     ServiceWorkerRegistration* registration) {
@@ skipping 19 matching lines @@
 
 void ServiceWorkerStorage::PurgeResources(const ResourceList& resources) {
   if (!has_checked_for_stale_resources_)
     DeleteStaleResources();
   StartPurgingResources(resources);
 }
 
 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)
     : next_registration_id_(kInvalidServiceWorkerRegistrationId),
       next_version_id_(kInvalidServiceWorkerVersionId),
       next_resource_id_(kInvalidServiceWorkerResourceId),
       state_(UNINITIALIZED),
       path_(path),
       context_(context),
-      database_task_runner_(database_task_runner),
+      database_task_manager_(database_task_manager.Pass()),
       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) {
   database_.reset(new ServiceWorkerDatabase(GetDatabasePath()));
 }
 
 base::FilePath ServiceWorkerStorage::GetDatabasePath() {
   if (path_.empty())
     return base::FilePath();
   return path_.Append(ServiceWorkerContextCore::kServiceWorkerDirectory)
@@ skipping 18 matching lines @@
       return false;
     case INITIALIZING:
       pending_tasks_.push_back(callback);
       return false;
     case UNINITIALIZED:
       pending_tasks_.push_back(callback);
       // Fall-through.
   }
 
   state_ = INITIALIZING;
-  database_task_runner_->PostTask(
+  database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ReadInitialDataFromDB,
                  database_.get(),
                  base::MessageLoopProxy::current(),
                  base::Bind(&ServiceWorkerStorage::DidReadInitialData,
                             weak_factory_.GetWeakPtr())));
   return false;
 }
 
 void ServiceWorkerStorage::DidReadInitialData(
@@ skipping 386 matching lines @@
       id, base::Bind(&ServiceWorkerStorage::OnResourcePurged,
                      weak_factory_.GetWeakPtr(), id));
   if (rv != net::ERR_IO_PENDING)
     OnResourcePurged(id, rv);
 }
 
 void ServiceWorkerStorage::OnResourcePurged(int64 id, int rv) {
   DCHECK(is_purge_pending_);
   is_purge_pending_ = false;
 
-  database_task_runner_->PostTask(
+  database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(
           &ServiceWorkerDatabase::ClearPurgeableResourceIds),
           base::Unretained(database_.get()),
           std::set<int64>(&id, &id + 1)));
 
   ContinuePurgingResources();
 }
 
 void ServiceWorkerStorage::DeleteStaleResources() {
   DCHECK(!has_checked_for_stale_resources_);
   has_checked_for_stale_resources_ = true;
-  database_task_runner_->PostTask(
+  database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ServiceWorkerStorage::CollectStaleResourcesFromDB,
                  database_.get(),
                  base::MessageLoopProxy::current(),
                  base::Bind(&ServiceWorkerStorage::DidCollectStaleResources,
                             weak_factory_.GetWeakPtr())));
 }
 
 void ServiceWorkerStorage::DidCollectStaleResources(
     const std::vector<int64>& stale_resource_ids,
     ServiceWorkerDatabase::Status status) {
   DCHECK_EQ(ServiceWorkerDatabase::STATUS_OK, status);
   if (status != ServiceWorkerDatabase::STATUS_OK)
     return;
   StartPurgingResources(stale_resource_ids);
 }
 
+void ServiceWorkerStorage::ClearSessionOnlyOrigins() {
+  // Can be null in tests.
+  if (!special_storage_policy_.get())
+    return;
+
+  if (!special_storage_policy_->HasSessionOnlyOrigins())
+    return;
+
+  std::set<GURL> session_only_origins;
+  for (const GURL& origin : registered_origins_) {
+    if (special_storage_policy_->IsStorageSessionOnly(origin))
+      session_only_origins.insert(origin);
+  }
+
+  database_task_manager_->GetShutdownBlockingTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&DeleteAllDataForOriginsFromDB,
+                 database_.get(),
+                 session_only_origins));
+}
+
 void ServiceWorkerStorage::CollectStaleResourcesFromDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     const GetResourcesCallback& callback) {
   std::set<int64> ids;
   ServiceWorkerDatabase::Status status =
       database->GetUncommittedResourceIds(&ids);
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     original_task_runner->PostTask(
         FROM_HERE,
@@ skipping 186 matching lines @@
     const GURL& origin,
     const FindInDBCallback& callback) {
   ServiceWorkerDatabase::RegistrationData data;
   ResourceList resources;
   ServiceWorkerDatabase::Status status =
       database->ReadRegistration(registration_id, origin, &data, &resources);
   original_task_runner->PostTask(
       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
 // controls it instead.
 void ServiceWorkerStorage::ScheduleDeleteAndStartOver() {
   if (state_ == DISABLED) {
     // Recovery process has already been scheduled.
     return;
   }
   Disable();
@@ skipping 12 matching lines @@
     callback.Run(DatabaseStatusToStatusCode(status));
     return;
   }
   DVLOG(1) << "Deleted ServiceWorkerDatabase successfully.";
 
   // Delete the disk cache on the cache thread.
   // TODO(nhiroki): What if there is a bunch of files in the cache directory?
   // Deleting the directory could take a long time and restart could be delayed.
   // We should probably rename the directory and delete it later.
   PostTaskAndReplyWithResult(
-      database_task_runner_.get(),
+      database_task_manager_->GetTaskRunner(),
       FROM_HERE,
       base::Bind(&base::DeleteFile, GetDiskCachePath(), true),
       base::Bind(&ServiceWorkerStorage::DidDeleteDiskCache,
                  weak_factory_.GetWeakPtr(),
                  callback));
 }
 
 void ServiceWorkerStorage::DidDeleteDiskCache(
     const StatusCallback& callback, bool result) {
   DCHECK_EQ(DISABLED, state_);
   if (!result) {
     // Give up the corruption recovery until the browser restarts.
     LOG(ERROR) << "Failed to delete the diskcache.";
     callback.Run(SERVICE_WORKER_ERROR_FAILED);
     return;
   }
   DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully.";
   callback.Run(SERVICE_WORKER_OK);
 }
 
 }  // namespace content