Service Worker: Delay stale resource cleanup

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/file_util.h"
@@ skipping 111 matching lines @@
   DCHECK(!document_url.has_ref());
   if (!LazyInitialize(base::Bind(
           &ServiceWorkerStorage::FindRegistrationForDocument,
           weak_factory_.GetWeakPtr(), document_url, callback))) {
     if (state_ != INITIALIZING || !context_) {
       CompleteFindNow(scoped_refptr<ServiceWorkerRegistration>(),
                       SERVICE_WORKER_ERROR_FAILED, callback);
     }
     return;
   }
-  DCHECK_EQ(INITIALIZED, state_);
+  DCHECK(IsReady()) << state_;
 
   // See if there are any stored registrations for the origin.
   if (!ContainsKey(registered_origins_, document_url.GetOrigin())) {
     // Look for something currently being installed.
     scoped_refptr<ServiceWorkerRegistration> installing_registration =
         FindInstallingRegistrationForDocument(document_url);
     CompleteFindNow(
         installing_registration,
         installing_registration ?
             SERVICE_WORKER_OK : SERVICE_WORKER_ERROR_NOT_FOUND,
@@ skipping 17 matching lines @@
     const FindRegistrationCallback& callback) {
   if (!LazyInitialize(base::Bind(
           &ServiceWorkerStorage::FindRegistrationForPattern,
           weak_factory_.GetWeakPtr(), scope, callback))) {
     if (state_ != INITIALIZING || !context_) {
       CompleteFindSoon(FROM_HERE, scoped_refptr<ServiceWorkerRegistration>(),
                        SERVICE_WORKER_ERROR_FAILED, callback);
     }
     return;
   }
-  DCHECK_EQ(INITIALIZED, state_);
+  DCHECK(IsReady()) << state_;
 
   // See if there are any stored registrations for the origin.
   if (!ContainsKey(registered_origins_, scope.GetOrigin())) {
     // Look for something currently being installed.
     scoped_refptr<ServiceWorkerRegistration> installing_registration =
         FindInstallingRegistrationForPattern(scope);
     CompleteFindSoon(
         FROM_HERE, installing_registration,
         installing_registration ?
             SERVICE_WORKER_OK : SERVICE_WORKER_ERROR_NOT_FOUND,
@@ skipping 18 matching lines @@
     const FindRegistrationCallback& callback) {
   if (!LazyInitialize(base::Bind(
           &ServiceWorkerStorage::FindRegistrationForId,
           weak_factory_.GetWeakPtr(), registration_id, origin, callback))) {
     if (state_ != INITIALIZING || !context_) {
       CompleteFindNow(scoped_refptr<ServiceWorkerRegistration>(),
                       SERVICE_WORKER_ERROR_FAILED, callback);
     }
     return;
   }
-  DCHECK_EQ(INITIALIZED, state_);
+  DCHECK(IsReady()) << state_;
 
   // See if there are any stored registrations for the origin.
   if (!ContainsKey(registered_origins_, origin)) {
     // Look for something currently being installed.
     scoped_refptr<ServiceWorkerRegistration> installing_registration =
         FindInstallingRegistrationForId(registration_id);
     CompleteFindNow(
         installing_registration,
         installing_registration ?
             SERVICE_WORKER_OK : SERVICE_WORKER_ERROR_NOT_FOUND,
@@ skipping 22 matching lines @@
     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_);
+  DCHECK(IsReady()) << state_;
 
   RegistrationList* registrations = new RegistrationList;
   PostTaskAndReplyWithResult(
       database_task_runner_,
       FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::GetAllRegistrations,
                  base::Unretained(database_.get()),
                  base::Unretained(registrations)),
       base::Bind(&ServiceWorkerStorage::DidGetAllRegistrations,
                  weak_factory_.GetWeakPtr(),
                  callback,
                  base::Owned(registrations)));
 }
 
 void ServiceWorkerStorage::StoreRegistration(
     ServiceWorkerRegistration* registration,
     ServiceWorkerVersion* version,
     const StatusCallback& callback) {
   DCHECK(registration);
   DCHECK(version);
 
-  DCHECK(state_ == INITIALIZED || state_ == DISABLED);
-  if (state_ != INITIALIZED || !context_) {
+  DCHECK(IsReady() || IsDisabled()) << state_;
+  if (IsDisabled() || !context_) {
     RunSoon(FROM_HERE, base::Bind(callback, SERVICE_WORKER_ERROR_FAILED));
     return;
   }
 
   ServiceWorkerDatabase::RegistrationData data;
   data.registration_id = registration->id();
   data.scope = registration->pattern();
   data.script = registration->script_url();
   data.has_fetch_handler = true;
   data.version_id = version->version_id();
   data.last_update_check = base::Time::Now();
   data.is_active = false;  // initially stored in the waiting state
 
   ResourceList resources;
   version->script_cache_map()->GetResources(&resources);
 
+  if (state_ == HAS_STALE_RESOURCES)
+    DeleteStaleResources();
+
   database_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WriteRegistrationInDB,
                  database_.get(),
                  base::MessageLoopProxy::current(),
                  data, resources,
                  base::Bind(&ServiceWorkerStorage::DidStoreRegistration,
                             weak_factory_.GetWeakPtr(),
                             callback)));
 }
 
 void ServiceWorkerStorage::UpdateToActiveState(
     ServiceWorkerRegistration* registration,
     const StatusCallback& callback) {
   DCHECK(registration);
 
-  DCHECK(state_ == INITIALIZED || state_ == DISABLED);
-  if (state_ != INITIALIZED || !context_) {
+  DCHECK(IsReady() || IsDisabled()) << state_;
+  if (IsDisabled() || !context_) {
     RunSoon(FROM_HERE, base::Bind(callback, SERVICE_WORKER_ERROR_FAILED));
     return;
   }
 
   PostTaskAndReplyWithResult(
       database_task_runner_,
       FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::UpdateVersionToActive,
                  base::Unretained(database_.get()),
                  registration->id(),
                  registration->script_url().GetOrigin()),
       base::Bind(&ServiceWorkerStorage::DidUpdateToActiveState,
                  weak_factory_.GetWeakPtr(),
                  callback));
 }
 
 void ServiceWorkerStorage::DeleteRegistration(
     int64 registration_id,
     const GURL& origin,
     const StatusCallback& callback) {
-  DCHECK(state_ == INITIALIZED || state_ == DISABLED);
-  if (state_ != INITIALIZED || !context_) {
+  DCHECK(IsReady() || IsDisabled());
+  if (IsDisabled() || !context_) {
     RunSoon(FROM_HERE, base::Bind(callback, SERVICE_WORKER_ERROR_FAILED));
     return;
   }
 
+  if (state_ == HAS_STALE_RESOURCES)
+    DeleteStaleResources();
+
   database_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DeleteRegistrationFromDB,
                  database_.get(),
                  base::MessageLoopProxy::current(),
                  registration_id, origin,
                  base::Bind(&ServiceWorkerStorage::DidDeleteRegistration,
                             weak_factory_.GetWeakPtr(), origin, callback)));
 
   // TODO(michaeln): Either its instance should also be
   // removed from liveregistrations map or the live object
   // should marked as deleted in some way and not 'findable'
   // thereafter.
 }
 
-scoped_ptr<ServiceWorkerResponseReader>
-ServiceWorkerStorage::CreateResponseReader(int64 response_id) {
-  return make_scoped_ptr(
-      new ServiceWorkerResponseReader(response_id, disk_cache()));
-}
-
 scoped_ptr<ServiceWorkerResponseWriter>
 ServiceWorkerStorage::CreateResponseWriter(int64 response_id) {
   return make_scoped_ptr(
       new ServiceWorkerResponseWriter(response_id, disk_cache()));
 }
 
-void ServiceWorkerStorage::StoreUncommittedReponseId(int64 id) {
+void ServiceWorkerStorage::StoreUncommittedResponseId(int64 id) {
   DCHECK_NE(kInvalidServiceWorkerResponseId, id);
+  DCHECK(IsReady()) << state_;
+
+  if (state_ == HAS_STALE_RESOURCES)
+    DeleteStaleResources();
+
   database_task_runner_->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);
@@ skipping 15 matching lines @@
       FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::DestroyDatabase,
                  base::Unretained(database_.get())),
       base::Bind(&ServiceWorkerStorage::DidDeleteDatabase,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 int64 ServiceWorkerStorage::NewRegistrationId() {
   if (state_ == DISABLED)
     return kInvalidServiceWorkerRegistrationId;
-  DCHECK_EQ(INITIALIZED, state_);
+  DCHECK(IsReady()) << state_;
   return next_registration_id_++;
 }
 
 int64 ServiceWorkerStorage::NewVersionId() {
   if (state_ == DISABLED)
     return kInvalidServiceWorkerVersionId;
-  DCHECK_EQ(INITIALIZED, state_);
+  DCHECK(IsReady()) << state_;
   return next_version_id_++;
 }
 
 int64 ServiceWorkerStorage::NewResourceId() {
   if (state_ == DISABLED)
     return kInvalidServiceWorkerResourceId;
-  DCHECK_EQ(INITIALIZED, state_);
+  DCHECK(IsReady()) << state_;
   return next_resource_id_++;
 }
 
 void ServiceWorkerStorage::NotifyInstallingRegistration(
       ServiceWorkerRegistration* registration) {
   installing_registrations_[registration->id()] = registration;
 }
 
 void ServiceWorkerStorage::NotifyDoneInstallingRegistration(
       ServiceWorkerRegistration* registration,
@@ skipping 54 matching lines @@
     return base::FilePath();
   return path_.Append(kServiceWorkerDirectory).Append(kDatabaseName);
 }
 
 base::FilePath ServiceWorkerStorage::GetDiskCachePath() {
   if (path_.empty())
     return base::FilePath();
   return path_.Append(kServiceWorkerDirectory).Append(kDiskCacheName);
 }
 
+bool ServiceWorkerStorage::IsReady() {
+  return state_ == HAS_STALE_RESOURCES || state_ == INITIALIZED;
+}
+
 bool ServiceWorkerStorage::LazyInitialize(const base::Closure& callback) {
   if (!context_)
     return false;
 
   switch (state_) {
+    case HAS_STALE_RESOURCES:
+      return true;
     case INITIALIZED:
       return true;
     case DISABLED:
       return false;
     case INITIALIZING:
       pending_tasks_.push_back(callback);
       return false;
     case UNINITIALIZED:
       pending_tasks_.push_back(callback);
       // Fall-through.
@@ skipping 14 matching lines @@
     InitialData* data,
     ServiceWorkerDatabase::Status status) {
   DCHECK(data);
   DCHECK_EQ(INITIALIZING, state_);
 
   if (status == ServiceWorkerDatabase::STATUS_OK) {
     next_registration_id_ = data->next_registration_id;
     next_version_id_ = data->next_version_id;
     next_resource_id_ = data->next_resource_id;
     registered_origins_.swap(data->origins);
-    state_ = INITIALIZED;
-    StartPurgingResources(
-        std::vector<int64>(data->purgeable_resource_ids.begin(),
-                           data->purgeable_resource_ids.end()));
+    state_ = HAS_STALE_RESOURCES;

[michaeln, 2014/07/09 02:36:11]

we don't really know if we have stale resources yet, we know we have to check,
is that right?

[falken, 2014/07/09 04:31:14]

correct, not the best name

   } else {
     // TODO(nhiroki): Stringify |status| using StatusToString() defined in
     // service_worker_database.cc.
     DVLOG(2) << "Failed to initialize: " << status;
     ScheduleDeleteAndStartOver();
   }
 
   for (std::vector<base::Closure>::const_iterator it = pending_tasks_.begin();
        it != pending_tasks_.end(); ++it) {
     RunSoon(FROM_HERE, *it);
@@ skipping 314 matching lines @@
   if (version && version->HasControllee()) {
     deleted_version_resource_ids_[version_id] = resources;
     version->AddListener(this);
   } else {
     StartPurgingResources(resources);
   }
 }
 
 void ServiceWorkerStorage::StartPurgingResources(
     const std::vector<int64>& ids) {
+  DCHECK_EQ(INITIALIZED, state_);
   for (size_t i = 0; i < ids.size(); ++i)
     purgeable_resource_ids_.push_back(ids[i]);
   ContinuePurgingResources();
 }
 
 void ServiceWorkerStorage::StartPurgingResources(
     const ResourceList& resources) {
   for (size_t i = 0; i < resources.size(); ++i)
     purgeable_resource_ids_.push_back(resources[i].resource_id);
   ContinuePurgingResources();
@@ skipping 29 matching lines @@
   database_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(
           &ServiceWorkerDatabase::ClearPurgeableResourceIds),
           base::Unretained(database_.get()),
           std::set<int64>(&id, &id + 1)));
 
   ContinuePurgingResources();
 }
 
+void ServiceWorkerStorage::DeleteStaleResources() {
+  DCHECK_EQ(HAS_STALE_RESOURCES, state_);
+  state_ = INITIALIZED;
+  database_task_runner_->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::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,
+        base::Bind(
+            callback, std::vector<int64>(ids.begin(), ids.end()), status));
+    return;
+  }
+
+  status = database->PurgeUncommittedResourceIds(ids);
+  if (status != ServiceWorkerDatabase::STATUS_OK) {
+    original_task_runner->PostTask(
+        FROM_HERE,
+        base::Bind(
+            callback, std::vector<int64>(ids.begin(), ids.end()), status));
+    return;
+  }
+
+  ids.clear();
+  status = database->GetPurgeableResourceIds(&ids);
+  original_task_runner->PostTask(
+      FROM_HERE,
+      base::Bind(callback, std::vector<int64>(ids.begin(), ids.end()), status));
+}
+
+scoped_ptr<ServiceWorkerResponseReader>
+ServiceWorkerStorage::CreateResponseReader(int64 response_id) {

[michaeln, 2014/07/09 02:36:11]

i think this accidentally got move far away from its sibling
CreateResponseWriter method?

[falken, 2014/07/09 04:31:14]

oops yes, done

+  return make_scoped_ptr(
+      new ServiceWorkerResponseReader(response_id, disk_cache()));
+}
+
 void ServiceWorkerStorage::ReadInitialDataFromDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     const InitializeCallback& callback) {
   DCHECK(database);
   scoped_ptr<ServiceWorkerStorage::InitialData> data(
       new ServiceWorkerStorage::InitialData());
 
   ServiceWorkerDatabase::Status status =
       database->GetNextAvailableIds(&data->next_registration_id,
                                     &data->next_version_id,
                                     &data->next_resource_id);
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     original_task_runner->PostTask(
         FROM_HERE, base::Bind(callback, base::Owned(data.release()), status));
     return;
   }
 
   status = database->GetOriginsWithRegistrations(&data->origins);
-  if (status != ServiceWorkerDatabase::STATUS_OK) {
-    original_task_runner->PostTask(
-        FROM_HERE, base::Bind(callback, base::Owned(data.release()), status));
-    return;
-  }
-
-  // TODO: Also purge uncommitted resources.
-  status = database->GetPurgeableResourceIds(&data->purgeable_resource_ids);
   original_task_runner->PostTask(
       FROM_HERE, base::Bind(callback, base::Owned(data.release()), status));
 }
 
 void ServiceWorkerStorage::DeleteRegistrationFromDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     int64 registration_id,
     const GURL& origin,
     const DeleteRegistrationCallback& callback) {
@@ skipping 189 matching lines @@
     // 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