ServiceWorker: Make ServiceWorkerStorage more self-defensive

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 <stddef.h>
 #include <utility>
 
 #include "base/bind_helpers.h"
@@ skipping 320 matching lines @@
 
 void ServiceWorkerStorage::GetRegistrationsForOrigin(
     const GURL& origin,
     const GetRegistrationsCallback& callback) {
   if (!LazyInitialize(base::Bind(
           &ServiceWorkerStorage::GetRegistrationsForOrigin,
           weak_factory_.GetWeakPtr(), origin, callback))) {
     if (state_ != INITIALIZING) {
       RunSoon(
           FROM_HERE,
-          base::Bind(callback,
+          base::Bind(callback, SERVICE_WORKER_ERROR_ABORT,
                      std::vector<scoped_refptr<ServiceWorkerRegistration>>()));
     }
     return;
   }
   DCHECK_EQ(INITIALIZED, state_);
 
   RegistrationList* registrations = new RegistrationList;
   std::vector<ResourceList>* resource_lists = new std::vector<ResourceList>;
   PostTaskAndReplyWithResult(
       database_task_manager_->GetTaskRunner(), FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::GetRegistrationsForOrigin,
                  base::Unretained(database_.get()), origin, registrations,
                  resource_lists),
       base::Bind(&ServiceWorkerStorage::DidGetRegistrations,
                  weak_factory_.GetWeakPtr(), callback,
                  base::Owned(registrations), base::Owned(resource_lists),
                  origin));
 }
 
 void ServiceWorkerStorage::GetAllRegistrationsInfos(
     const GetRegistrationsInfosCallback& callback) {
   if (!LazyInitialize(
           base::Bind(&ServiceWorkerStorage::GetAllRegistrationsInfos,
                      weak_factory_.GetWeakPtr(), callback))) {
     if (state_ != INITIALIZING) {
-      RunSoon(FROM_HERE, base::Bind(
-          callback, std::vector<ServiceWorkerRegistrationInfo>()));
+      RunSoon(FROM_HERE,
+              base::Bind(callback, SERVICE_WORKER_ERROR_ABORT,
+                         std::vector<ServiceWorkerRegistrationInfo>()));
     }
     return;
   }
   DCHECK_EQ(INITIALIZED, state_);
 
   RegistrationList* registrations = new RegistrationList;
   PostTaskAndReplyWithResult(
       database_task_manager_->GetTaskRunner(), FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::GetAllRegistrations,
                  base::Unretained(database_.get()), registrations),
@@ skipping 76 matching lines @@
                  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())
     return;
 
   database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           base::IgnoreResult(&ServiceWorkerDatabase::UpdateLastCheckTime),
           base::Unretained(database_.get()),
           registration->id(),
@@ skipping 50 matching lines @@
 }
 
 scoped_ptr<ServiceWorkerResponseMetadataWriter>
 ServiceWorkerStorage::CreateResponseMetadataWriter(int64_t resource_id) {
   return make_scoped_ptr(
       new ServiceWorkerResponseMetadataWriter(resource_id, disk_cache()));
 }
 
 void ServiceWorkerStorage::StoreUncommittedResourceId(int64_t resource_id) {
   DCHECK_NE(kInvalidServiceWorkerResourceId, resource_id);
-  DCHECK_EQ(INITIALIZED, state_);
+  DCHECK(INITIALIZED == state_ || DISABLED == state_) << state_;
+  if (IsDisabled())
+    return;
 
   if (!has_checked_for_stale_resources_)
     DeleteStaleResources();
 
   PostTaskAndReplyWithResult(
       database_task_manager_->GetTaskRunner(), FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::WriteUncommittedResourceIds,
                  base::Unretained(database_.get()),
                  std::set<int64_t>(&resource_id, &resource_id + 1)),
       base::Bind(&ServiceWorkerStorage::DidWriteUncommittedResourceIds,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerStorage::DoomUncommittedResource(int64_t resource_id) {
   DCHECK_NE(kInvalidServiceWorkerResourceId, resource_id);
+  DCHECK(INITIALIZED == state_ || DISABLED == state_) << state_;
+  if (IsDisabled())
+    return;
   DoomUncommittedResources(std::set<int64_t>(&resource_id, &resource_id + 1));
 }
 
 void ServiceWorkerStorage::DoomUncommittedResources(
     const std::set<int64_t>& resource_ids) {
+  DCHECK(INITIALIZED == state_ || DISABLED == state_) << state_;
+  if (IsDisabled())
+    return;
+
   PostTaskAndReplyWithResult(
       database_task_manager_->GetTaskRunner(), FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::PurgeUncommittedResourceIds,
                  base::Unretained(database_.get()), resource_ids),
       base::Bind(&ServiceWorkerStorage::DidPurgeUncommittedResourceIds,
                  weak_factory_.GetWeakPtr(), resource_ids));
 }
 
 void ServiceWorkerStorage::StoreUserData(int64_t registration_id,
                                          const GURL& origin,
@@ skipping 184 matching lines @@
     ServiceWorkerRegistration* registration) {
   uninstalling_registrations_.erase(registration->id());
 }
 
 void ServiceWorkerStorage::Disable() {
   state_ = DISABLED;
   if (disk_cache_)
     disk_cache_->Disable();
 }
 
-bool ServiceWorkerStorage::IsDisabled() const {
-  return state_ == DISABLED;
-}
-
 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,
     scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager,
@@ skipping 189 matching lines @@
     RegistrationList* registration_data_list,
     std::vector<ResourceList>* resources_list,
     const GURL& origin_filter,
     ServiceWorkerDatabase::Status status) {
   DCHECK(registration_data_list);
   DCHECK(resources_list);
 
   if (status != ServiceWorkerDatabase::STATUS_OK &&
       status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
     ScheduleDeleteAndStartOver();
-    callback.Run(std::vector<scoped_refptr<ServiceWorkerRegistration>>());
+    callback.Run(DatabaseStatusToStatusCode(status),
+                 std::vector<scoped_refptr<ServiceWorkerRegistration>>());
     return;
   }
 
   // Add all stored registrations.
   std::set<int64_t> registration_ids;
   std::vector<scoped_refptr<ServiceWorkerRegistration>> registrations;
   size_t index = 0;
   for (const auto& registration_data : *registration_data_list) {
     registration_ids.insert(registration_data.registration_id);
     registrations.push_back(GetOrCreateRegistration(
         registration_data, resources_list->at(index++)));
   }
 
   // Add unstored registrations that are being installed.
   for (const auto& registration : installing_registrations_) {
     if ((!origin_filter.is_valid() ||
          registration.second->pattern().GetOrigin() == origin_filter) &&
         registration_ids.insert(registration.first).second) {
       registrations.push_back(registration.second);
     }
   }
 
-  callback.Run(registrations);
+  callback.Run(SERVICE_WORKER_OK, registrations);
 }
 
 void ServiceWorkerStorage::DidGetRegistrationsInfos(
     const GetRegistrationsInfosCallback& callback,
     RegistrationList* registration_data_list,
     const GURL& origin_filter,
     ServiceWorkerDatabase::Status status) {
   DCHECK(registration_data_list);
   if (status != ServiceWorkerDatabase::STATUS_OK &&
       status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
     ScheduleDeleteAndStartOver();
-    callback.Run(std::vector<ServiceWorkerRegistrationInfo>());
+    callback.Run(DatabaseStatusToStatusCode(status),
+                 std::vector<ServiceWorkerRegistrationInfo>());
     return;
   }
 
   // Add all stored registrations.
   std::set<int64_t> pushed_registrations;
   std::vector<ServiceWorkerRegistrationInfo> infos;
   for (const auto& registration_data : *registration_data_list) {
     const bool inserted =
         pushed_registrations.insert(registration_data.registration_id).second;
     DCHECK(inserted);
@@ skipping 36 matching lines @@
 
   // Add unstored registrations that are being installed.
   for (const auto& registration : installing_registrations_) {
     if ((!origin_filter.is_valid() ||
          registration.second->pattern().GetOrigin() == origin_filter) &&
         pushed_registrations.insert(registration.first).second) {
       infos.push_back(registration.second->GetInfo());
     }
   }
 
-  callback.Run(infos);
+  callback.Run(SERVICE_WORKER_OK, infos);
 }
 
 void ServiceWorkerStorage::DidStoreRegistration(
     const StatusCallback& callback,
     const ServiceWorkerDatabase::RegistrationData& new_version,
     const GURL& origin,
     const ServiceWorkerDatabase::RegistrationData& deleted_version,
     const std::vector<int64_t>& newly_purgeable_resources,
     ServiceWorkerDatabase::Status status) {
   if (status != ServiceWorkerDatabase::STATUS_OK) {
@@ skipping 190 matching lines @@
 ServiceWorkerRegistration*
 ServiceWorkerStorage::FindInstallingRegistrationForId(int64_t registration_id) {
   RegistrationRefsById::const_iterator found =
       installing_registrations_.find(registration_id);
   if (found == installing_registrations_.end())
     return nullptr;
   return found->second.get();
 }
 
 ServiceWorkerDiskCache* ServiceWorkerStorage::disk_cache() {
-  DCHECK_EQ(INITIALIZED, state_);
+  DCHECK(INITIALIZED == state_ || DISABLED == state_) << state_;
   if (disk_cache_)
     return disk_cache_.get();
+  disk_cache_.reset(new ServiceWorkerDiskCache);
 
-  disk_cache_.reset(new ServiceWorkerDiskCache);
+  if (IsDisabled()) {
+    disk_cache_->Disable();

[falken, 2016/02/16 09:16:50]

Ah, nice bug.

+    return disk_cache_.get();
+  }
 
   base::FilePath path = GetDiskCachePath();
   if (path.empty()) {
     int rv = disk_cache_->InitWithMemBackend(kMaxMemDiskCacheSize,
                                              net::CompletionCallback());
     DCHECK_EQ(net::OK, rv);
     return disk_cache_.get();
   }
 
   InitializeDiskCache();
@@ skipping 388 matching lines @@
 
 void ServiceWorkerStorage::DeleteAllDataForOriginsFromDB(
     ServiceWorkerDatabase* database,
     const std::set<GURL>& origins) {
   DCHECK(database);
 
   std::vector<int64_t> newly_purgeable_resources;
   database->DeleteAllDataForOrigins(origins, &newly_purgeable_resources);
 }
 
+bool ServiceWorkerStorage::IsDisabled() const {
+  return state_ == DISABLED;
+}
+
 // 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() {
   // TODO(dmurph): Notify the quota manager somehow that all of our data is now
   // removed.
   if (state_ == DISABLED) {
     // Recovery process has already been scheduled.
     return;
@@ skipping 41 matching lines @@
     callback.Run(SERVICE_WORKER_ERROR_FAILED);
     return;
   }
   DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully.";
   ServiceWorkerMetrics::RecordDeleteAndStartOverResult(
       ServiceWorkerMetrics::DELETE_OK);
   callback.Run(SERVICE_WORKER_OK);
 }
 
 }  // namespace content