Make Service Worker DB UserData methods accept multiple keys at once

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 <stdint.h>
 
 #include <deque>
 #include <map>
 #include <set>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/service_worker/service_worker_database.h"
 #include "content/browser/service_worker/service_worker_database_task_manager.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
@@ skipping 37 matching lines @@
                                   registration)> FindRegistrationCallback;
   typedef base::Callback<void(
       ServiceWorkerStatusCode status,
       const std::vector<scoped_refptr<ServiceWorkerRegistration>>&
           registrations)>
       GetRegistrationsCallback;
   typedef base::Callback<void(
       ServiceWorkerStatusCode status,
       const std::vector<ServiceWorkerRegistrationInfo>& registrations)>
       GetRegistrationsInfosCallback;
-  typedef base::Callback<
-      void(const std::string& data, ServiceWorkerStatusCode status)>
-          GetUserDataCallback;
+  using GetUserDataCallback =
+      base::Callback<void(const std::vector<std::string>& data,
+                          ServiceWorkerStatusCode status)>;
   typedef base::Callback<void(
       const std::vector<std::pair<int64_t, std::string>>& user_data,
       ServiceWorkerStatusCode status)> GetUserDataForAllRegistrationsCallback;
 
   ~ServiceWorkerStorage() override;
 
   static std::unique_ptr<ServiceWorkerStorage> Create(
       const base::FilePath& path,
       const base::WeakPtr<ServiceWorkerContextCore>& context,
       std::unique_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager,
@@ skipping 77 matching lines @@
   // but not yet stored with a registration.
   void StoreUncommittedResourceId(int64_t resource_id);
 
   // Removes resource ids from uncommitted list, adds them to the purgeable list
   // and purges them.
   void DoomUncommittedResource(int64_t resource_id);
   void DoomUncommittedResources(const std::set<int64_t>& resource_ids);
 
   // Provide a storage mechanism to read/write arbitrary data associated with
   // a registration. Each registration has its own key namespace. Stored data
   // is deleted when the associated registraton is deleted.

[michaeln, 2016/05/03 19:38:06]

Can you document what happens when some keys are found and others are not.

[johnme, 2016/05/05 10:54:04]

Done.

   void GetUserData(int64_t registration_id,
-                   const std::string& key,
+                   const std::vector<std::string>& keys,
                    const GetUserDataCallback& callback);
-  void StoreUserData(int64_t registration_id,
-                     const GURL& origin,
-                     const std::string& key,
-                     const std::string& data,
-                     const StatusCallback& callback);
+  void StoreUserData(
+      int64_t registration_id,
+      const GURL& origin,
+      const std::vector<std::pair<std::string, std::string>>& key_value_pairs,
+      const StatusCallback& callback);
   void ClearUserData(int64_t registration_id,
-                     const std::string& key,
+                     const std::vector<std::string>& keys,
                      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);
@@ skipping 112 matching lines @@
       ServiceWorkerDatabase::Status status)> WriteRegistrationCallback;
   typedef base::Callback<void(
       OriginState origin_state,
       const ServiceWorkerDatabase::RegistrationData& deleted_version_data,
       const std::vector<int64_t>& 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;
+  typedef base::Callback<void(const std::vector<std::string>& data,
+                              ServiceWorkerDatabase::Status)>
+      GetUserDataInDBCallback;
   typedef base::Callback<void(
       const std::vector<std::pair<int64_t, std::string>>& user_data,
       ServiceWorkerDatabase::Status)>
       GetUserDataForAllRegistrationsInDBCallback;
   typedef base::Callback<void(const std::vector<int64_t>& resource_ids,
                               ServiceWorkerDatabase::Status status)>
       GetResourcesCallback;
 
   ServiceWorkerStorage(
       const base::FilePath& path,
@@ skipping 52 matching lines @@
       OriginState origin_state,
       const ServiceWorkerDatabase::RegistrationData& deleted_version,
       const std::vector<int64_t>& newly_purgeable_resources,
       ServiceWorkerDatabase::Status status);
   void DidWriteUncommittedResourceIds(ServiceWorkerDatabase::Status status);
   void DidPurgeUncommittedResourceIds(const std::set<int64_t>& resource_ids,
                                       ServiceWorkerDatabase::Status status);
   void DidStoreUserData(
       const StatusCallback& callback,
       ServiceWorkerDatabase::Status status);
-  void DidGetUserData(
-      const GetUserDataCallback& callback,
-      const std::string& data,
-      ServiceWorkerDatabase::Status status);
+  void DidGetUserData(const GetUserDataCallback& callback,
+                      const std::vector<std::string>& data,
+                      ServiceWorkerDatabase::Status status);
   void DidDeleteUserData(
       const StatusCallback& callback,
       ServiceWorkerDatabase::Status status);
   void DidGetUserDataForAllRegistrations(
       const GetUserDataForAllRegistrationsCallback& callback,
       const std::vector<std::pair<int64_t, std::string>>& user_data,
       ServiceWorkerDatabase::Status status);
   void ReturnFoundRegistration(
       const FindRegistrationCallback& callback,
       const ServiceWorkerDatabase::RegistrationData& data,
@@ skipping 69 matching lines @@
       const FindInDBCallback& callback);
   static void FindForIdOnlyInDB(
       ServiceWorkerDatabase* database,
       scoped_refptr<base::SequencedTaskRunner> original_task_runner,
       int64_t registration_id,
       const FindInDBCallback& callback);
   static void GetUserDataInDB(
       ServiceWorkerDatabase* database,
       scoped_refptr<base::SequencedTaskRunner> original_task_runner,
       int64_t registration_id,
-      const std::string& key,
+      const std::vector<std::string>& keys,
       const GetUserDataInDBCallback& callback);
   static void GetUserDataForAllRegistrationsInDB(
       ServiceWorkerDatabase* database,
       scoped_refptr<base::SequencedTaskRunner> original_task_runner,
       const std::string& key,
       const GetUserDataForAllRegistrationsInDBCallback& callback);
   static void DeleteAllDataForOriginsFromDB(
       ServiceWorkerDatabase* database,
       const std::set<GURL>& origins);
 
@@ skipping 50 matching lines @@
   std::set<int64_t> pending_deletions_;
 
   base::WeakPtrFactory<ServiceWorkerStorage> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerStorage);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_STORAGE_H_