Store foreign fetch scopes in database with other SW information.

content/browser/service_worker/service_worker_storage.h

 // 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.
 
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_STORAGE_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_STORAGE_H_
 
 #include <deque>
 #include <map>
 #include <set>
@@ skipping 159 matching lines @@
                      const StatusCallback& callback);
   void ClearUserData(int64 registration_id,
                      const std::string& key,
                      const StatusCallback& callback);
   // Returns all registrations that have user data with a particular key, as
   // well as that user data.
   void GetUserDataForAllRegistrations(
       const std::string& key,
       const GetUserDataForAllRegistrationsCallback& callback);
 
+  // Returns true if any service workers at |origin| have registered for foreign
+  // fetch.
+  bool OriginHasForeignFetchRegistrations(const GURL& origin);
+
   // Deletes the storage and starts over.
   void DeleteAndStartOver(const StatusCallback& callback);
 
   // Returns new IDs which are guaranteed to be unique in the storage.
   int64 NewRegistrationId();
   int64 NewVersionId();
   int64 NewResourceId();
 
   // Intended for use only by ServiceWorkerRegisterJob and
   // ServiceWorkerRegistration.
@@ skipping 52 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerResourceStorageDiskTest,
                            DeleteAndStartOver_OpenedFileExists);
 
   struct InitialData {
     int64 next_registration_id;
     int64 next_version_id;
     int64 next_resource_id;
     std::set<GURL> origins;
     bool disk_cache_migration_needed;
     bool old_disk_cache_deletion_needed;
+    std::set<GURL> foreign_fetch_origins;
 
     InitialData();
     ~InitialData();
   };
 
   // Because there are too many params for base::Bind to wrap a closure around.
   struct DidDeleteRegistrationParams {
     int64 registration_id;
     GURL origin;
     StatusCallback callback;
 
     DidDeleteRegistrationParams();
     ~DidDeleteRegistrationParams();
   };
 
+  enum class OriginState {
+    // Other registrations with foreign fetch scopes exist for the origin.
+    KEEP_ALL,
+    // Other registrations exist at this origin, but none of them have foreign
+    // fetch scopes.
+    DELETE_FROM_FOREIGN_FETCH,
+    // No other registrations exist at this origin.
+    DELETE_FROM_ALL
+  };
+
   typedef std::vector<ServiceWorkerDatabase::RegistrationData> RegistrationList;
   typedef std::map<int64, scoped_refptr<ServiceWorkerRegistration> >
       RegistrationRefsById;
   typedef base::Callback<void(scoped_ptr<InitialData> data,
                               ServiceWorkerDatabase::Status status)>
       InitializeCallback;
   typedef base::Callback<void(ServiceWorkerDatabase::Status status)>
       DatabaseStatusCallback;
   typedef base::Callback<void(
       const GURL& origin,
       const ServiceWorkerDatabase::RegistrationData& deleted_version_data,
       const std::vector<int64>& newly_purgeable_resources,
       ServiceWorkerDatabase::Status status)> WriteRegistrationCallback;
   typedef base::Callback<void(
-      bool origin_is_deletable,
+      OriginState origin_state,
       const ServiceWorkerDatabase::RegistrationData& deleted_version_data,
       const std::vector<int64>& newly_purgeable_resources,
       ServiceWorkerDatabase::Status status)> DeleteRegistrationCallback;
   typedef base::Callback<void(
       const ServiceWorkerDatabase::RegistrationData& data,
       const ResourceList& resources,
       ServiceWorkerDatabase::Status status)> FindInDBCallback;
   typedef base::Callback<void(
       const std::string& data,
       ServiceWorkerDatabase::Status)> GetUserDataInDBCallback;
@@ skipping 58 matching lines @@
       const ServiceWorkerDatabase::RegistrationData& new_version,
       const GURL& origin,
       const ServiceWorkerDatabase::RegistrationData& deleted_version,
       const std::vector<int64>& newly_purgeable_resources,
       ServiceWorkerDatabase::Status status);
   void DidUpdateToActiveState(
       const StatusCallback& callback,
       ServiceWorkerDatabase::Status status);
   void DidDeleteRegistration(
       const DidDeleteRegistrationParams& params,
-      bool origin_is_deletable,
+      OriginState origin_state,
       const ServiceWorkerDatabase::RegistrationData& deleted_version,
       const std::vector<int64>& newly_purgeable_resources,
       ServiceWorkerDatabase::Status status);
   void DidWriteUncommittedResourceIds(ServiceWorkerDatabase::Status status);
   void DidPurgeUncommittedResourceIds(const std::set<int64>& resource_ids,
                                       ServiceWorkerDatabase::Status status);
   void DidStoreUserData(
       const StatusCallback& callback,
       ServiceWorkerDatabase::Status status);
   void DidGetUserData(
@@ skipping 116 matching lines @@
   void DidDeleteDiskCache(
       const StatusCallback& callback,
       bool result);
 
   // For finding registrations being installed or uninstalled.
   RegistrationRefsById installing_registrations_;
   RegistrationRefsById uninstalling_registrations_;
 
   // Origins having registations.
   std::set<GURL> registered_origins_;
+  std::set<GURL> foreign_fetch_origins_;
 
   // Pending database tasks waiting for initialization.
   std::vector<base::Closure> pending_tasks_;
 
   int64 next_registration_id_;
   int64 next_version_id_;
   int64 next_resource_id_;
 
   enum State {
     UNINITIALIZED,
@@ skipping 27 matching lines @@
   std::set<int64> pending_deletions_;
 
   base::WeakPtrFactory<ServiceWorkerStorage> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerStorage);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_STORAGE_H_