Make Service Worker DB UserData methods accept multiple keys at once

content/browser/service_worker/service_worker_context_wrapper.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_CONTEXT_WRAPPER_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_WRAPPER_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 136 matching lines @@
   //    activated.
   //
   // Must be called from the IO thread.
   void FindReadyRegistrationForId(int64_t registration_id,
                                   const GURL& origin,
                                   const FindRegistrationCallback& callback);
 
   // All these methods must be called from the IO thread.
   void GetAllRegistrations(const GetRegistrationsInfosCallback& callback);
   void GetRegistrationUserData(int64_t registration_id,
-                               const std::string& key,
+                               const std::vector<std::string>& keys,

[Michael van Ouwerkerk, 2016/05/04 09:08:52]

nit: why not std::set<std::string>?

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

Because the order of the results is based on the order of these keys (and having
the result order depend on the lexicographic order of the keys would be hella
confusing).

It could be a std::set for Clear, but consistency seemed nice.

                                const GetUserDataCallback& callback);
-  void StoreRegistrationUserData(int64_t registration_id,
-                                 const GURL& origin,
-                                 const std::string& key,
-                                 const std::string& data,
-                                 const StatusCallback& callback);
+  void StoreRegistrationUserData(
+      int64_t registration_id,
+      const GURL& origin,
+      const std::vector<std::pair<std::string, std::string>>& key_value_pairs,

[Michael van Ouwerkerk, 2016/05/04 09:08:52]

nit: why not std::map<std::string, std::string>?

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

I considered this, as both std::map and std::unordered_map would have the same
initializer_lists, but they perform slightly worse (especially since this gets
copied during the thread-hop, which would cause a 2nd n log n, or a re-hashing
of all the keys), and it seems slightly cleaner for the order of writes to be as
specified, rather than alphabetical by key or arbitrary (for example this makes
the tests deterministic). But I could go either way on this.

+      const StatusCallback& callback);
   void ClearRegistrationUserData(int64_t registration_id,
-                                 const std::string& key,
+                                 const std::vector<std::string>& keys,
                                  const StatusCallback& callback);
   void GetUserDataForAllRegistrations(
       const std::string& key,
       const GetUserDataForAllRegistrationsCallback& callback);
 
   // This function can be called from any thread, but the callback will always
   // be called on the UI thread.
   void StartServiceWorker(const GURL& pattern, const StatusCallback& callback);
 
   // These methods can be called from any thread.
@@ skipping 73 matching lines @@
   ResourceContext* resource_context_;
 
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerContextWrapper);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_WRAPPER_H_