Store foreign fetch scopes in database with other SW information.

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 "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "content/browser/service_worker/service_worker_database.pb.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/common/service_worker/service_worker_types.h"
+#include "content/common/service_worker/service_worker_utils.h"
 #include "third_party/leveldatabase/env_chromium.h"
 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
 // LevelDB database schema
 // =======================
 //
 // NOTE
@@ skipping 46 matching lines @@
 //
 //   key: "INITDATA_DISKCACHE_MIGRATION_NOT_NEEDED"
 //   value: <empty>
 //     - This entry represents that the diskcache uses the Simple backend and
 //       does not have to do diskcache migration (http://crbug.com/487482).
 //
 //   key: "INITDATA_OLD_DISKCACHE_DELETION_NOT_NEEDED"
 //   value: <empty>
 //     - This entry represents that the old BlockFile diskcache was deleted
 //       after diskcache migration (http://crbug.com/487482).
+//
+//   key: "INITDATA_FOREIGN_FETCH_ORIGIN:" + <GURL 'origin'>
+//   value: <empty>
 namespace content {
 
 namespace {
 
 const char kDatabaseVersionKey[] = "INITDATA_DB_VERSION";
 const char kNextRegIdKey[] = "INITDATA_NEXT_REGISTRATION_ID";
 const char kNextResIdKey[] = "INITDATA_NEXT_RESOURCE_ID";
 const char kNextVerIdKey[] = "INITDATA_NEXT_VERSION_ID";
 const char kUniqueOriginKey[] = "INITDATA_UNIQUE_ORIGIN:";
 const char kDiskCacheMigrationNotNeededKey[] =
     "INITDATA_DISKCACHE_MIGRATION_NOT_NEEDED";
 const char kOldDiskCacheDeletionNotNeededKey[] =
     "INITDATA_OLD_DISKCACHE_DELETION_NOT_NEEDED";
+const char kForeignFetchOriginKey[] = "INITDATA_FOREIGN_FETCH_ORIGIN:";
 
 const char kRegKeyPrefix[] = "REG:";
 const char kRegUserDataKeyPrefix[] = "REG_USER_DATA:";
 const char kRegHasUserDataKeyPrefix[] = "REG_HAS_USER_DATA:";
 const char kRegIdToOriginKeyPrefix[] = "REGID_TO_ORIGIN:";
 const char kResKeyPrefix[] = "RES:";
 const char kKeySeparator = '\x00';
 const char kEmptyValue[] = "";
 
 const char kUncommittedResIdKeyPrefix[] = "URES:";
@@ skipping 42 matching lines @@
                                     int64 resource_id) {
   return CreateResourceRecordKeyPrefix(version_id).append(
       base::Int64ToString(resource_id));
 }
 
 std::string CreateUniqueOriginKey(const GURL& origin) {
   return base::StringPrintf("%s%s", kUniqueOriginKey,
                             origin.GetOrigin().spec().c_str());
 }
 
+std::string CreateForeignFetchOriginKey(const GURL& origin) {
+  return base::StringPrintf("%s%s", kForeignFetchOriginKey,
+                            origin.GetOrigin().spec().c_str());
+}
+
 std::string CreateResourceIdKey(const char* key_prefix, int64 resource_id) {
   return base::StringPrintf(
       "%s%s", key_prefix, base::Int64ToString(resource_id).c_str());
 }
 
 std::string CreateUserDataKeyPrefix(int64 registration_id) {
   return base::StringPrintf("%s%s%c",
                             kRegUserDataKeyPrefix,
                             base::Int64ToString(registration_id).c_str(),
                             kKeySeparator);
@@ skipping 28 matching lines @@
   // Convert RegistrationData to ServiceWorkerRegistrationData.
   ServiceWorkerRegistrationData data;
   data.set_registration_id(input.registration_id);
   data.set_scope_url(input.scope.spec());
   data.set_script_url(input.script.spec());
   data.set_version_id(input.version_id);
   data.set_is_active(input.is_active);
   data.set_has_fetch_handler(input.has_fetch_handler);
   data.set_last_update_check_time(input.last_update_check.ToInternalValue());
   data.set_resources_total_size_bytes(input.resources_total_size_bytes);
+  for (const GURL& url : input.foreign_fetch_scopes) {
+    DCHECK(ServiceWorkerUtils::ScopeMatches(input.scope, url))
+        << "Foreign fetch scope '" << url
+        << "' does not match service worker scope '" << input.scope << "'.";
+    data.add_foreign_fetch_scope(url.spec());
+  }
 
   std::string value;
   bool success = data.SerializeToString(&value);
   DCHECK(success);
   GURL origin = input.scope.GetOrigin();
   batch->Put(CreateRegistrationKey(data.registration_id(), origin), value);
 }
 
 void PutResourceRecordToBatch(
     const ServiceWorkerDatabase::ResourceRecord& input,
@@ skipping 19 matching lines @@
   // Value should be empty.
   batch->Put(CreateUniqueOriginKey(origin), "");
 }
 
 void PutPurgeableResourceIdToBatch(int64 resource_id,
                                    leveldb::WriteBatch* batch) {
   // Value should be empty.
   batch->Put(CreateResourceIdKey(kPurgeableResIdKeyPrefix, resource_id), "");
 }
 
+void PutForeignFetchOriginToBatch(const GURL& origin,
+                                  leveldb::WriteBatch* batch) {
+  // Value should be empty.
+  batch->Put(CreateForeignFetchOriginKey(origin), "");
+}
+
 ServiceWorkerDatabase::Status ParseId(
     const std::string& serialized,
     int64* out) {
   DCHECK(out);
   int64 id;
   if (!base::StringToInt64(serialized, &id) || id < 0)
     return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
   *out = id;
   return ServiceWorkerDatabase::STATUS_OK;
 }
@@ skipping 40 matching lines @@
   // Convert ServiceWorkerRegistrationData to RegistrationData.
   out->registration_id = data.registration_id();
   out->scope = scope_url;
   out->script = script_url;
   out->version_id = data.version_id();
   out->is_active = data.is_active();
   out->has_fetch_handler = data.has_fetch_handler();
   out->last_update_check =
       base::Time::FromInternalValue(data.last_update_check_time());
   out->resources_total_size_bytes = data.resources_total_size_bytes();
+  for (int i = 0; i < data.foreign_fetch_scope_size(); ++i) {
+    GURL sub_scope_url(data.foreign_fetch_scope(i));
+    if (!sub_scope_url.is_valid() ||
+        !ServiceWorkerUtils::ScopeMatches(scope_url, sub_scope_url)) {
+      DLOG(ERROR) << "Foreign fetch scope '" << data.foreign_fetch_scope(i)
+                  << "' is not valid or does not match Scope URL '" << scope_url
+                  << "'.";
+      return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
+    }
+    out->foreign_fetch_scopes.push_back(sub_scope_url);
+  }
 
   return ServiceWorkerDatabase::STATUS_OK;
 }
 
 ServiceWorkerDatabase::Status ParseResourceRecord(
     const std::string& serialized,
     ServiceWorkerDatabase::ResourceRecord* out) {
   DCHECK(out);
   ServiceWorkerResourceRecord record;
   if (!record.ParseFromString(serialized))
@@ skipping 234 matching lines @@
       return status;
     }
 
     origins->insert(origin);
   }
 
   HandleReadResult(FROM_HERE, status);
   return status;
 }
 
+ServiceWorkerDatabase::Status
+ServiceWorkerDatabase::GetOriginsWithForeignFetchRegistrations(
+    std::set<GURL>* origins) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(origins->empty());
+
+  Status status = LazyOpen(false);
+  if (IsNewOrNonexistentDatabase(status))
+    return STATUS_OK;
+  if (status != STATUS_OK)
+    return status;
+
+  scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
+  for (itr->Seek(kForeignFetchOriginKey); itr->Valid(); itr->Next()) {
+    status = LevelDBStatusToStatus(itr->status());
+    if (status != STATUS_OK) {
+      HandleReadResult(FROM_HERE, status);
+      origins->clear();
+      return status;
+    }
+
+    std::string origin_str;
+    if (!RemovePrefix(itr->key().ToString(), kForeignFetchOriginKey,
+                      &origin_str))
+      break;
+
+    GURL origin(origin_str);
+    if (!origin.is_valid()) {
+      status = STATUS_ERROR_CORRUPTED;
+      HandleReadResult(FROM_HERE, status);
+      origins->clear();
+      return status;
+    }
+
+    origins->insert(origin);
+  }
+
+  HandleReadResult(FROM_HERE, status);
+  return status;
+}
+
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::GetRegistrationsForOrigin(
     const GURL& origin,
     std::vector<RegistrationData>* registrations,
     std::vector<std::vector<ResourceRecord>>* opt_resources_list) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(registrations->empty());
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
@@ skipping 158 matching lines @@
   old_registration->version_id = kInvalidServiceWorkerVersionId;
   if (status != STATUS_OK)
     return status;
 
   leveldb::WriteBatch batch;
   BumpNextRegistrationIdIfNeeded(registration.registration_id, &batch);
   BumpNextVersionIdIfNeeded(registration.version_id, &batch);
 
   PutUniqueOriginToBatch(registration.scope.GetOrigin(), &batch);
 
+  if (!registration.foreign_fetch_scopes.empty())
+    PutForeignFetchOriginToBatch(registration.scope.GetOrigin(), &batch);
+
   DCHECK_EQ(AccumulateResourceSizeInBytes(resources),
             registration.resources_total_size_bytes)
       << "The total size in the registration must match the cumulative "
       << "sizes of the resources.";
 
   PutRegistrationDataToBatch(registration, &batch);
   batch.Put(CreateRegistrationIdToOriginKey(registration.registration_id),
             registration.scope.GetOrigin().spec());
 
   // Used for avoiding multiple writes for the same resource id or url.
@@ skipping 31 matching lines @@
     if (status != STATUS_OK)
       return status;
 
     // Currently resource sharing across versions and registrations is not
     // supported, so resource ids should not be overlapped between
     // |registration| and |old_registration|.
     std::set<int64> deleted_resources(newly_purgeable_resources->begin(),
                                       newly_purgeable_resources->end());
     DCHECK(base::STLSetIntersection<std::set<int64> >(
         pushed_resources, deleted_resources).empty());
+
+    // If old registration had foreign fetch scopes, but new registration
+    // doesn't, the origin might have to be removed from the list of origins
+    // with foreign fetch scopes.
+    // TODO(mek): Like the similar check in DeleteRegistration, ideally this
+    // could be done more efficiently.
+    if (!old_registration->foreign_fetch_scopes.empty() &&
+        registration.foreign_fetch_scopes.empty()) {
+      std::vector<RegistrationData> registrations;
+      status = GetRegistrationsForOrigin(registration.scope.GetOrigin(),
+                                         &registrations, nullptr);
+      if (status != STATUS_OK)
+        return status;
+      bool remaining_ff_scopes = false;
+      for (const auto& existing_reg : registrations) {
+        if (existing_reg.registration_id != registration.registration_id &&
+            !existing_reg.foreign_fetch_scopes.empty()) {
+          remaining_ff_scopes = true;
+          break;
+        }
+      }
+      if (!remaining_ff_scopes)
+        batch.Delete(
+            CreateForeignFetchOriginKey(registration.scope.GetOrigin()));
+    }
   }
 
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::UpdateVersionToActive(
     int64 registration_id,
     const GURL& origin) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   Status status = LazyOpen(false);
@@ skipping 65 matching lines @@
   std::vector<RegistrationData> registrations;
   status = GetRegistrationsForOrigin(origin, &registrations, nullptr);
   if (status != STATUS_OK)
     return status;
 
   if (registrations.size() == 1 &&
       registrations[0].registration_id == registration_id) {
     batch.Delete(CreateUniqueOriginKey(origin));
   }
 
+  // Remove |origin| from foreign fetch origins if a registration specified by
+  // |registration_id| is the only one with foreign fetch scopes for |origin|.
+  bool remaining_ff_scopes = false;
+  for (const auto& registration : registrations) {
+    if (registration.registration_id != registration_id &&
+        !registration.foreign_fetch_scopes.empty()) {
+      remaining_ff_scopes = true;
+      break;
+    }
+  }
+  if (!remaining_ff_scopes)
+    batch.Delete(CreateForeignFetchOriginKey(origin));
+
   // Delete a registration specified by |registration_id|.
   batch.Delete(CreateRegistrationKey(registration_id, origin));
   batch.Delete(CreateRegistrationIdToOriginKey(registration_id));
 
   // Delete resource records and user data associated with the registration.
   for (const auto& registration : registrations) {
     if (registration.registration_id == registration_id) {
       *deleted_version = registration;
       status = DeleteResourceRecords(
           registration.version_id, newly_purgeable_resources, &batch);
@@ skipping 187 matching lines @@
     return status;
   leveldb::WriteBatch batch;
 
   for (const GURL& origin : origins) {
     if (!origin.is_valid())
       return STATUS_ERROR_FAILED;
 
     // Delete from the unique origin list.
     batch.Delete(CreateUniqueOriginKey(origin));
 
+    // Delete from the foreign fetch origin list.
+    batch.Delete(CreateForeignFetchOriginKey(origin));
+
     std::vector<RegistrationData> registrations;
     status = GetRegistrationsForOrigin(origin, &registrations, nullptr);
     if (status != STATUS_OK)
       return status;
 
     // Delete registrations, resource records and user data.
     for (const RegistrationData& data : registrations) {
       batch.Delete(CreateRegistrationKey(data.registration_id, origin));
       batch.Delete(CreateRegistrationIdToOriginKey(data.registration_id));
 
@@ skipping 486 matching lines @@
   if (status != STATUS_OK)
     Disable(from_here, status);
   ServiceWorkerMetrics::CountWriteDatabaseResult(status);
 }
 
 bool ServiceWorkerDatabase::IsDatabaseInMemory() const {
   return path_.empty();
 }
 
 }  // namespace content