Make Service Worker DB UserData methods accept multiple keys at once

content/browser/service_worker/service_worker_storage_unittest.cc

 // 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.
 
 #include "content/browser/service_worker/service_worker_storage.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 
@@ skipping 99 matching lines @@
 }
 
 ServiceWorkerStorage::GetRegistrationsInfosCallback
 MakeGetRegistrationsInfosCallback(
     bool* was_called,
     ServiceWorkerStatusCode* status,
     std::vector<ServiceWorkerRegistrationInfo>* all) {
   return base::Bind(&GetAllInfosCallback, was_called, status, all);
 }
 
-void GetUserDataCallback(
-    bool* was_called,
-    std::string* data_out,
-    ServiceWorkerStatusCode* status_out,
-    const std::string& data,
-    ServiceWorkerStatusCode status) {
+void GetUserDataCallback(bool* was_called,
+                         std::vector<std::string>* data_out,
+                         ServiceWorkerStatusCode* status_out,
+                         const std::vector<std::string>& data,
+                         ServiceWorkerStatusCode status) {
   *was_called = true;
   *data_out = data;
   *status_out = status;
 }
 
 void GetUserDataForAllRegistrationsCallback(
     bool* was_called,
     std::vector<std::pair<int64_t, std::string>>* data_out,
     ServiceWorkerStatusCode* status_out,
     const std::vector<std::pair<int64_t, std::string>>& data,
@@ skipping 238 matching lines @@
     storage()->GetRegistrationsForOrigin(
         origin,
         MakeGetRegistrationsCallback(&was_called, &result, registrations));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
   ServiceWorkerStatusCode GetUserData(int64_t registration_id,
-                                      const std::string& key,
-                                      std::string* data) {
+                                      const std::vector<std::string>& keys,
+                                      std::vector<std::string>* data) {
     bool was_called = false;
     ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
     storage()->GetUserData(
-        registration_id, key,
+        registration_id, keys,
         base::Bind(&GetUserDataCallback, &was_called, data, &result));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
-  ServiceWorkerStatusCode StoreUserData(int64_t registration_id,
-                                        const GURL& origin,
-                                        const std::string& key,
-                                        const std::string& data) {
+  ServiceWorkerStatusCode StoreUserData(
+      int64_t registration_id,
+      const GURL& origin,
+      const std::vector<std::pair<std::string, std::string>>& key_value_pairs) {
     bool was_called = false;
     ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
-    storage()->StoreUserData(
-        registration_id, origin, key, data,
-        MakeStatusCallback(&was_called, &result));
+    storage()->StoreUserData(registration_id, origin, key_value_pairs,
+                             MakeStatusCallback(&was_called, &result));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
   ServiceWorkerStatusCode ClearUserData(int64_t registration_id,
-                                        const std::string& key) {
+                                        const std::vector<std::string>& keys) {
     bool was_called = false;
     ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
-    storage()->ClearUserData(
-        registration_id, key, MakeStatusCallback(&was_called, &result));
+    storage()->ClearUserData(registration_id, keys,
+                             MakeStatusCallback(&was_called, &result));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
   ServiceWorkerStatusCode GetUserDataForAllRegistrations(
       const std::string& key,
       std::vector<std::pair<int64_t, std::string>>* data) {
     bool was_called = false;
@@ skipping 131 matching lines @@
   // access the disk cache.
   scoped_refptr<HttpResponseInfoIOBuffer> info_buffer =
       new HttpResponseInfoIOBuffer();
   EXPECT_EQ(net::ERR_CACHE_MISS,
             ReadResponseInfo(storage(), kResourceId, info_buffer.get()));
   EXPECT_EQ(net::ERR_FAILED, WriteBasicResponse(storage(), kResourceId));
   EXPECT_EQ(net::ERR_FAILED,
             WriteResponseMetadata(storage(), kResourceId, "foo"));
 
   const std::string kUserDataKey = "key";
-  std::string user_data_out;
+  std::vector<std::string> user_data_out;
   EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT,
-            GetUserData(kRegistrationId, kUserDataKey, &user_data_out));
-  EXPECT_EQ(
-      SERVICE_WORKER_ERROR_ABORT,
-      StoreUserData(kRegistrationId, kScope.GetOrigin(), kUserDataKey, "foo"));
+            GetUserData(kRegistrationId, {kUserDataKey}, &user_data_out));
   EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT,
-            ClearUserData(kRegistrationId, kUserDataKey));
+            StoreUserData(kRegistrationId, kScope.GetOrigin(),
+                          {{kUserDataKey, "foo"}}));
+  EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT,
+            ClearUserData(kRegistrationId, {kUserDataKey}));
   std::vector<std::pair<int64_t, std::string>> data_list_out;
   EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT,
             GetUserDataForAllRegistrations(kUserDataKey, &data_list_out));
 
   EXPECT_FALSE(
       storage()->OriginHasForeignFetchRegistrations(kScope.GetOrigin()));
 
   // Next available ids should be invalid.
   EXPECT_EQ(kInvalidServiceWorkerRegistrationId,
             storage()->NewRegistrationId());
@@ skipping 348 matching lines @@
   std::vector<ServiceWorkerDatabase::ResourceRecord> records;
   records.push_back(ServiceWorkerDatabase::ResourceRecord(
       1, live_version->script_url(), 100));
   live_version->script_cache_map()->SetResources(records);
   live_version->SetStatus(ServiceWorkerVersion::INSTALLED);
   live_registration->SetWaitingVersion(live_version);
   EXPECT_EQ(SERVICE_WORKER_OK,
             StoreRegistration(live_registration, live_version));
 
   // Store user data associated with the registration.
-  std::string data_out;
+  std::vector<std::string> data_out;
+  EXPECT_EQ(
+      SERVICE_WORKER_OK,
+      StoreUserData(kRegistrationId, kScope.GetOrigin(), {{"key", "data"}}));
   EXPECT_EQ(SERVICE_WORKER_OK,
-            StoreUserData(kRegistrationId, kScope.GetOrigin(), "key", "data"));
-  EXPECT_EQ(SERVICE_WORKER_OK, GetUserData(kRegistrationId, "key", &data_out));
-  EXPECT_EQ("data", data_out);
+            GetUserData(kRegistrationId, {"key"}, &data_out));
+  ASSERT_EQ(1u, data_out.size());
+  EXPECT_EQ("data", data_out[0]);
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
-            GetUserData(kRegistrationId, "unknown_key", &data_out));
+            GetUserData(kRegistrationId, {"unknown_key"}, &data_out));
   std::vector<std::pair<int64_t, std::string>> data_list_out;
   EXPECT_EQ(SERVICE_WORKER_OK,
             GetUserDataForAllRegistrations("key", &data_list_out));
   ASSERT_EQ(1u, data_list_out.size());
   EXPECT_EQ(kRegistrationId, data_list_out[0].first);
   EXPECT_EQ("data", data_list_out[0].second);
   data_list_out.clear();
   EXPECT_EQ(SERVICE_WORKER_OK,
             GetUserDataForAllRegistrations("unknown_key", &data_list_out));
   EXPECT_EQ(0u, data_list_out.size());
-  EXPECT_EQ(SERVICE_WORKER_OK, ClearUserData(kRegistrationId, "key"));
+  EXPECT_EQ(SERVICE_WORKER_OK, ClearUserData(kRegistrationId, {"key"}));
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
-            GetUserData(kRegistrationId, "key", &data_out));
+            GetUserData(kRegistrationId, {"key"}, &data_out));
+
+  // Write/overwrite multiple user data keys.
+  EXPECT_EQ(SERVICE_WORKER_OK,
+            StoreUserData(
+                kRegistrationId, kScope.GetOrigin(),
+                {{"key", "overwrite"}, {"key3", "data3"}, {"key4", "data4"}}));
+  EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
+            GetUserData(kRegistrationId, {"key2"}, &data_out));

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

also expect NOT_FOUND and empty data for GetUserData(..., {key, key2},...) 

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

I already check that below (see "Multiple gets fail if one is not found.").

+  EXPECT_EQ(SERVICE_WORKER_OK,
+            GetUserData(kRegistrationId, {"key", "key3", "key4"}, &data_out));
+  ASSERT_EQ(3u, data_out.size());
+  EXPECT_EQ("overwrite", data_out[0]);
+  EXPECT_EQ("data3", data_out[1]);
+  EXPECT_EQ("data4", data_out[2]);
+  // Multiple gets fail if one is not found.
+  EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
+            GetUserData(kRegistrationId, {"key", "key2"}, &data_out));
+  EXPECT_TRUE(data_out.empty());
+
+  // Delete multiple user data keys, even if some are not found.
+  EXPECT_EQ(SERVICE_WORKER_OK,
+            ClearUserData(kRegistrationId, {"key", "key2", "key3"}));
+  EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
+            GetUserData(kRegistrationId, {"key"}, &data_out));
+  EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
+            GetUserData(kRegistrationId, {"key2"}, &data_out));
+  EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
+            GetUserData(kRegistrationId, {"key3"}, &data_out));
+  EXPECT_EQ(SERVICE_WORKER_OK,
+            GetUserData(kRegistrationId, {"key4"}, &data_out));
+  ASSERT_EQ(1u, data_out.size());
+  EXPECT_EQ("data4", data_out[0]);
 
   // User data should be deleted when the associated registration is deleted.
+  ASSERT_EQ(
+      SERVICE_WORKER_OK,
+      StoreUserData(kRegistrationId, kScope.GetOrigin(), {{"key", "data"}}));
   ASSERT_EQ(SERVICE_WORKER_OK,
-            StoreUserData(kRegistrationId, kScope.GetOrigin(), "key", "data"));
-  ASSERT_EQ(SERVICE_WORKER_OK,
-            GetUserData(kRegistrationId, "key", &data_out));
-  ASSERT_EQ("data", data_out);
+            GetUserData(kRegistrationId, {"key"}, &data_out));
+  ASSERT_EQ(1u, data_out.size());
+  ASSERT_EQ("data", data_out[0]);
 
   EXPECT_EQ(SERVICE_WORKER_OK,
             DeleteRegistration(kRegistrationId, kScope.GetOrigin()));
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
-            GetUserData(kRegistrationId, "key", &data_out));
+            GetUserData(kRegistrationId, {"key"}, &data_out));
   data_list_out.clear();
   EXPECT_EQ(SERVICE_WORKER_OK,
             GetUserDataForAllRegistrations("key", &data_list_out));
   EXPECT_EQ(0u, data_list_out.size());
 
   // Data access with an invalid registration id should be failed.
   EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED,
             StoreUserData(kInvalidServiceWorkerRegistrationId,
-                          kScope.GetOrigin(), "key", "data"));
+                          kScope.GetOrigin(), {{"key", "data"}}));
+  EXPECT_EQ(
+      SERVICE_WORKER_ERROR_FAILED,
+      GetUserData(kInvalidServiceWorkerRegistrationId, {"key"}, &data_out));
   EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED,
-            GetUserData(kInvalidServiceWorkerRegistrationId, "key", &data_out));
-  EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED,
-            ClearUserData(kInvalidServiceWorkerRegistrationId, "key"));
+            ClearUserData(kInvalidServiceWorkerRegistrationId, {"key"}));
 
   // Data access with an empty key should be failed.
   EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED,
-            StoreUserData(
-                kRegistrationId, kScope.GetOrigin(), std::string(), "data"));
+            StoreUserData(kRegistrationId, kScope.GetOrigin(),
+                          std::vector<std::pair<std::string, std::string>>()));
   EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED,
-            GetUserData(kRegistrationId, std::string(), &data_out));
+            StoreUserData(kRegistrationId, kScope.GetOrigin(),
+                          {{std::string(), "data"}}));
   EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED,
-            ClearUserData(kRegistrationId, std::string()));
+            StoreUserData(kRegistrationId, kScope.GetOrigin(),
+                          {{std::string(), "data"}, {"key", "data"}}));
+  EXPECT_EQ(
+      SERVICE_WORKER_ERROR_FAILED,
+      GetUserData(kRegistrationId, std::vector<std::string>(), &data_out));
+  EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED,
+            GetUserData(kRegistrationId, {std::string()}, &data_out));
+  EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED,
+            GetUserData(kRegistrationId, {std::string(), "key"}, &data_out));
+  EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED,
+            ClearUserData(kRegistrationId, std::vector<std::string>()));
+  EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED,
+            ClearUserData(kRegistrationId, {std::string()}));
+  EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED,
+            ClearUserData(kRegistrationId, {std::string(), "key"}));
   data_list_out.clear();
   EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED,
             GetUserDataForAllRegistrations(std::string(), &data_list_out));
 }
 
 class ServiceWorkerResourceStorageTest : public ServiceWorkerStorageTest {
  public:
   void SetUp() override {
     ServiceWorkerStorageTest::SetUp();
     LazyInitialize();
@@ skipping 674 matching lines @@
   // Remove other registration at first origin.
   EXPECT_EQ(SERVICE_WORKER_OK,
             DeleteRegistration(kRegistrationId2, kScope2.GetOrigin()));
 
   // No foreign fetch registrations remain.
   EXPECT_FALSE(storage()->OriginHasForeignFetchRegistrations(kOrigin1));
   EXPECT_FALSE(storage()->OriginHasForeignFetchRegistrations(kOrigin2));
 }
 
 }  // namespace content