Store the service worker script and its imports on first load... really

content/browser/service_worker/service_worker_database.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 "content/browser/service_worker/service_worker_database.h"
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/location.h"
@@ skipping 394 matching lines @@
   status = ReadResourceRecords(value.version_id, resources);
   if (status != STATUS_OK)
     return status;
 
   *registration = value;
   return STATUS_OK;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteRegistration(
     const RegistrationData& registration,
-    const std::vector<ResourceRecord>& resources) {
+    const std::vector<ResourceRecord>& resources,
+    std::vector<int64>* newly_purgeable_resources) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   Status status = LazyOpen(true);
   if (status != STATUS_OK)
     return status;
 
   leveldb::WriteBatch batch;
   BumpNextRegistrationIdIfNeeded(registration.registration_id, &batch);
   BumpNextVersionIdIfNeeded(registration.version_id, &batch);
 
   // TODO(nhiroki): Skip to add the origin into the unique origin list if it
   // has already been added.
   PutUniqueOriginToBatch(registration.scope.GetOrigin(), &batch);
 
   PutRegistrationDataToBatch(registration, &batch);
 
   // Retrieve a previous version to sweep purgeable resources.
   RegistrationData old_registration;
   status = ReadRegistrationData(registration.registration_id,
                                 registration.scope.GetOrigin(),
                                 &old_registration);
   if (status != STATUS_OK && status != STATUS_ERROR_NOT_FOUND)
     return status;
   if (status == STATUS_OK) {
     DCHECK_LT(old_registration.version_id, registration.version_id);
     // Currently resource sharing across versions and registrations is not
     // suppported, so resource ids should not be overlapped between
     // |registration| and |old_registration|.
     // TODO(nhiroki): Add DCHECK to make sure the overlap does not exist.
-    status = DeleteResourceRecords(old_registration.version_id, &batch);
+    status = DeleteResourceRecords(
+        old_registration.version_id, newly_purgeable_resources, &batch);
     if (status != STATUS_OK)
       return status;
   }
 
   // Used for avoiding multiple writes for the same resource id or url.
   std::set<int64> pushed_resources;
   std::set<GURL> pushed_urls;
   for (std::vector<ResourceRecord>::const_iterator itr = resources.begin();
        itr != resources.end(); ++itr) {
     if (!itr->url.is_valid())
@@ skipping 57 matching lines @@
 
   registration.last_update_check = time;
 
   leveldb::WriteBatch batch;
   PutRegistrationDataToBatch(registration, &batch);
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteRegistration(
     int64 registration_id,
-    const GURL& origin) {
+    const GURL& origin,
+    std::vector<int64>* newly_purgeable_resources) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
   if (!origin.is_valid())
     return STATUS_ERROR_FAILED;
 
   leveldb::WriteBatch batch;
@@ skipping 11 matching lines @@
     batch.Delete(CreateUniqueOriginKey(origin));
   }
 
   // Delete a registration specified by |registration_id|.
   batch.Delete(CreateRegistrationKey(registration_id, origin));
 
   // Delete resource records associated with the registration.
   for (std::vector<RegistrationData>::const_iterator itr =
            registrations.begin(); itr != registrations.end(); ++itr) {
     if (itr->registration_id == registration_id) {
-      status = DeleteResourceRecords(itr->version_id, &batch);
+      status = DeleteResourceRecords(
+          itr->version_id, newly_purgeable_resources, &batch);
       if (status != STATUS_OK)
         return status;
       break;
     }
   }
 
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status
@@ skipping 20 matching lines @@
 ServiceWorkerDatabase::WritePurgeableResourceIds(const std::set<int64>& ids) {
   return WriteResourceIds(kPurgeableResIdKeyPrefix, ids);
 }
 
 ServiceWorkerDatabase::Status
 ServiceWorkerDatabase::ClearPurgeableResourceIds(const std::set<int64>& ids) {
   return DeleteResourceIds(kPurgeableResIdKeyPrefix, ids);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteAllDataForOrigin(
-    const GURL& origin) {
+    const GURL& origin,
+    std::vector<int64>* newly_purgeable_resources) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     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));
 
   std::vector<RegistrationData> registrations;
   status = GetRegistrationsForOrigin(origin, &registrations);
   if (status != STATUS_OK)
     return status;
 
   // 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, &batch);
+    status = DeleteResourceRecords(
+        itr->version_id, newly_purgeable_resources, &batch);
     if (status != STATUS_OK)
       return status;
   }
 
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::LazyOpen(
     bool create_if_missing) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
@@ skipping 131 matching lines @@
       resources->clear();
       return STATUS_ERROR_CORRUPTED;
     }
     resources->push_back(resource);
   }
   return STATUS_OK;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteResourceRecords(
     int64 version_id,
+    std::vector<int64>* newly_purgeable_resources,
     leveldb::WriteBatch* batch) {
   DCHECK(batch);
 
   std::string prefix = CreateResourceRecordKeyPrefix(version_id);
   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
   for (itr->Seek(prefix); itr->Valid(); itr->Next()) {
     if (!itr->status().ok()) {
       HandleError(FROM_HERE, itr->status());
       return LevelDBStatusToStatus(itr->status());
     }
 
     std::string key = itr->key().ToString();
     std::string unprefixed;
     if (!RemovePrefix(key, prefix, &unprefixed))
       break;
 
     int64 resource_id;
     if (!base::StringToInt64(unprefixed, &resource_id)) {
       HandleError(FROM_HERE, leveldb::Status::Corruption("failed to parse"));
       return STATUS_ERROR_CORRUPTED;
     }
 
     // Remove a resource record.
     batch->Delete(key);
 
     // Currently resource sharing across versions and registrations is not
     // supported, so we can purge this without caring about it.
     PutPurgeableResourceIdToBatch(resource_id, batch);
+    newly_purgeable_resources->push_back(resource_id);
   }
   return STATUS_OK;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadResourceIds(
     const char* id_key_prefix,
     std::set<int64>* ids) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(id_key_prefix);
   DCHECK(ids->empty());
@@ skipping 148 matching lines @@
   // TODO(nhiroki): Add an UMA histogram.
   DLOG(ERROR) << "Failed at: " << from_here.ToString()
               << " with error: " << status.ToString();
   is_disabled_ = true;
   if (status.IsCorruption())
     was_corruption_detected_ = true;
   db_.reset();
 }
 
 }  // namespace content