Make Service Worker DB UserData methods accept multiple keys at once

content/browser/service_worker/service_worker_database_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <string>
@@ skipping 976 matching lines @@
   data.resources_total_size_bytes = 100;
   std::vector<Resource> resources;
   resources.push_back(CreateResource(1, data.script, 100));
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64_t> newly_purgeable_resources;
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(
                 data, resources, &deleted_version, &newly_purgeable_resources));
 
   // Write user data associated with the stored registration.
-  std::string user_data_out;
+  std::vector<std::string> user_data_out;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->WriteUserData(
-                data.registration_id, kOrigin, "key1", "data"));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->ReadUserData(
-                data.registration_id, "key1", &user_data_out));
-  EXPECT_EQ("data", user_data_out);
+            database->WriteUserData(data.registration_id, kOrigin,
+                                    {{"key1", "data"}}));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data.registration_id, {"key1"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  EXPECT_EQ("data", user_data_out[0]);
 
   // Writing user data not associated with the stored registration should be
   // failed.
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->WriteUserData(300, kOrigin, "key1", "data"));
+            database->WriteUserData(300, kOrigin, {{"key1", "data"}}));
 
   // Write empty user data for a different key.
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->WriteUserData(
-                data.registration_id, kOrigin, "key2", std::string()));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->ReadUserData(
-                data.registration_id, "key2", &user_data_out));
-  EXPECT_EQ(std::string(), user_data_out);
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->ReadUserData(
-                data.registration_id, "key1", &user_data_out));
-  EXPECT_EQ("data", user_data_out);
+            database->WriteUserData(data.registration_id, kOrigin,
+                                    {{"key2", std::string()}}));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data.registration_id, {"key2"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  EXPECT_EQ(std::string(), user_data_out[0]);
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data.registration_id, {"key1"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  EXPECT_EQ("data", user_data_out[0]);
 
   // Overwrite the existing user data.
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->WriteUserData(
-                data.registration_id, kOrigin, "key1", "overwrite"));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->ReadUserData(
-                data.registration_id, "key1", &user_data_out));
-  EXPECT_EQ("overwrite", user_data_out);
+            database->WriteUserData(data.registration_id, kOrigin,
+                                    {{"key1", "overwrite"}}));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data.registration_id, {"key1"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  EXPECT_EQ("overwrite", user_data_out[0]);
 
   // Delete the user data.
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->DeleteUserData(data.registration_id, "key1"));
+            database->DeleteUserData(data.registration_id, {"key1"}));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+      database->ReadUserData(data.registration_id, {"key1"}, &user_data_out));
+  EXPECT_TRUE(user_data_out.empty());
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data.registration_id, {"key2"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  EXPECT_EQ(std::string(), user_data_out[0]);
+
+  // Write/overwrite multiple user data keys.
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->WriteUserData(
+          data.registration_id, kOrigin,
+          {{"key2", "overwrite2"}, {"key3", "data3"}, {"key4", "data4"}}));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+      database->ReadUserData(data.registration_id, {"key1"}, &user_data_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->ReadUserData(data.registration_id,
+                                   {"key2", "key3", "key4"}, &user_data_out));
+  ASSERT_EQ(3u, user_data_out.size());
+  EXPECT_EQ("overwrite2", user_data_out[0]);
+  EXPECT_EQ("data3", user_data_out[1]);
+  EXPECT_EQ("data4", user_data_out[2]);
+  // Multiple reads fail if one is not found.
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->ReadUserData(
-                data.registration_id, "key1", &user_data_out));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->ReadUserData(
-                data.registration_id, "key2", &user_data_out));
-  EXPECT_EQ(std::string(), user_data_out);
+            database->ReadUserData(data.registration_id, {"key2", "key1"},
+                                   &user_data_out));
+  EXPECT_TRUE(user_data_out.empty());
+
+  // Delete multiple user data keys, even if some are not found.
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->DeleteUserData(data.registration_id, {"key1", "key2", "key3"}));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+      database->ReadUserData(data.registration_id, {"key1"}, &user_data_out));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+      database->ReadUserData(data.registration_id, {"key2"}, &user_data_out));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+      database->ReadUserData(data.registration_id, {"key3"}, &user_data_out));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data.registration_id, {"key4"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  EXPECT_EQ("data4", user_data_out[0]);
 }
 
 TEST(ServiceWorkerDatabaseTest, UserData_DataIsolation) {
   std::unique_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
   const GURL kOrigin("http://example.com");
 
   // Add registration 1.
   RegistrationData data1;
   data1.registration_id = 100;
   data1.scope = URL(kOrigin, "/foo");
@@ skipping 16 matching lines @@
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64_t> newly_purgeable_resources;
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data1, resources1, &deleted_version,
                                         &newly_purgeable_resources));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data2, resources2, &deleted_version,
                                         &newly_purgeable_resources));
 
   // Write user data associated with the registration1.
-  std::string user_data_out;
+  std::vector<std::string> user_data_out;
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->WriteUserData(
-                data1.registration_id, kOrigin, "key", "data1"));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->ReadUserData(
-                data1.registration_id, "key", &user_data_out));
-  EXPECT_EQ("data1", user_data_out);
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->ReadUserData(
-                data2.registration_id, "key", &user_data_out));
+            database->WriteUserData(data1.registration_id, kOrigin,
+                                    {{"key", "data1"}}));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data1.registration_id, {"key"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  EXPECT_EQ("data1", user_data_out[0]);
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+      database->ReadUserData(data2.registration_id, {"key"}, &user_data_out));
 
   // Write user data associated with the registration2. This shouldn't overwrite
   // the data associated with registration1.
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->WriteUserData(
-                data2.registration_id, kOrigin, "key", "data2"));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->ReadUserData(
-                data1.registration_id, "key", &user_data_out));
-  EXPECT_EQ("data1", user_data_out);
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->ReadUserData(
-                data2.registration_id, "key", &user_data_out));
-  EXPECT_EQ("data2", user_data_out);
+            database->WriteUserData(data2.registration_id, kOrigin,
+                                    {{"key", "data2"}}));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data1.registration_id, {"key"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  EXPECT_EQ("data1", user_data_out[0]);
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data2.registration_id, {"key"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  EXPECT_EQ("data2", user_data_out[0]);
 
   // Get all registrations with user data.
   std::vector<std::pair<int64_t, std::string>> user_data_list;
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->ReadUserDataForAllRegistrations("key", &user_data_list));
   EXPECT_EQ(2u, user_data_list.size());
   EXPECT_EQ(data1.registration_id, user_data_list[0].first);
   EXPECT_EQ("data1", user_data_list[0].second);
   EXPECT_EQ(data2.registration_id, user_data_list[1].first);
   EXPECT_EQ("data2", user_data_list[1].second);
 
   // Delete the data associated with the registration2. This shouldn't delete
   // the data associated with registration1.
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->DeleteUserData(data2.registration_id, "key"));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->ReadUserData(
-                data1.registration_id, "key", &user_data_out));
-  EXPECT_EQ("data1", user_data_out);
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->ReadUserData(
-                data2.registration_id, "key", &user_data_out));
+            database->DeleteUserData(data2.registration_id, {"key"}));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data1.registration_id, {"key"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  EXPECT_EQ("data1", user_data_out[0]);
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+      database->ReadUserData(data2.registration_id, {"key"}, &user_data_out));
 
   // And again get all registrations with user data.
   user_data_list.clear();
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->ReadUserDataForAllRegistrations("key", &user_data_list));
   EXPECT_EQ(1u, user_data_list.size());
   EXPECT_EQ(data1.registration_id, user_data_list[0].first);
   EXPECT_EQ("data1", user_data_list[0].second);
 }
 
@@ skipping 24 matching lines @@
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64_t> newly_purgeable_resources;
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data1, resources1, &deleted_version,
                                         &newly_purgeable_resources));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data2, resources2, &deleted_version,
                                         &newly_purgeable_resources));
 
   // Write user data associated with the registration1.
-  std::string user_data_out;
+  std::vector<std::string> user_data_out;
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->WriteUserData(
-                data1.registration_id, kOrigin, "key1", "data1"));
+            database->WriteUserData(data1.registration_id, kOrigin,
+                                    {{"key1", "data1"}}));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->WriteUserData(
-                data1.registration_id, kOrigin, "key2", "data2"));
-  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->ReadUserData(
-                data1.registration_id, "key1", &user_data_out));
-  ASSERT_EQ("data1", user_data_out);
-  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->ReadUserData(
-                data1.registration_id, "key2", &user_data_out));
-  ASSERT_EQ("data2", user_data_out);
+            database->WriteUserData(data1.registration_id, kOrigin,
+                                    {{"key2", "data2"}}));
+  ASSERT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data1.registration_id, {"key1"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  ASSERT_EQ("data1", user_data_out[0]);
+  ASSERT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data1.registration_id, {"key2"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  ASSERT_EQ("data2", user_data_out[0]);
 
   // Write user data associated with the registration2.
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->WriteUserData(
-                data2.registration_id, kOrigin, "key3", "data3"));
-  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->ReadUserData(
-                data2.registration_id, "key3", &user_data_out));
-  ASSERT_EQ("data3", user_data_out);
+            database->WriteUserData(data2.registration_id, kOrigin,
+                                    {{"key3", "data3"}}));
+  ASSERT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data2.registration_id, {"key3"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  ASSERT_EQ("data3", user_data_out[0]);
 
   // Delete all data associated with the registration1. This shouldn't delete
   // the data associated with registration2.
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->DeleteRegistration(
                 data1.registration_id, kOrigin,
                 &deleted_version, &newly_purgeable_resources));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->ReadUserData(
-                data1.registration_id, "key1", &user_data_out));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->ReadUserData(
-                data1.registration_id, "key2", &user_data_out));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->ReadUserData(
-                data2.registration_id, "key3", &user_data_out));
-  EXPECT_EQ("data3", user_data_out);
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+      database->ReadUserData(data1.registration_id, {"key1"}, &user_data_out));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+      database->ReadUserData(data1.registration_id, {"key2"}, &user_data_out));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data2.registration_id, {"key3"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  EXPECT_EQ("data3", user_data_out[0]);
 }
 
 TEST(ServiceWorkerDatabaseTest, UserData_UninitializedDatabase) {
   std::unique_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
   const GURL kOrigin("http://example.com");
 
   // Should be failed because the database does not exist.
-  std::string user_data_out;
+  std::vector<std::string> user_data_out;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->ReadUserData(100, "key", &user_data_out));
+            database->ReadUserData(100, {"key"}, &user_data_out));
 
   // Should be failed because the associated registration does not exist.
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->WriteUserData(100, kOrigin, "key", "data"));
+            database->WriteUserData(100, kOrigin, {{"key", "data"}}));
 
   // Deleting non-existent entry should succeed.
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->DeleteUserData(100, "key"));
+            database->DeleteUserData(100, {"key"}));
 
   // Actually create a new database, but not initialized yet.
   database->LazyOpen(true);
 
   // Should be failed because the database is not initialized.
   ASSERT_EQ(ServiceWorkerDatabase::UNINITIALIZED, database->state_);
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->ReadUserData(100, "key", &user_data_out));
+            database->ReadUserData(100, {"key"}, &user_data_out));
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->WriteUserData(100, kOrigin, "key", "data"));
+            database->WriteUserData(100, kOrigin, {{"key", "data"}}));
 
   // Deleting non-existent entry should succeed.
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->DeleteUserData(100, "key"));
+            database->DeleteUserData(100, {"key"}));
 }
 
 TEST(ServiceWorkerDatabaseTest, UpdateVersionToActive) {
   std::unique_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
   GURL origin("http://example.com");
 
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64_t> newly_purgeable_resources;
 
   // Should be false because a registration does not exist.
@@ skipping 184 matching lines @@
   data1.resources_total_size_bytes = 2013 + 512;
   data1.foreign_fetch_scopes.push_back(URL(origin1, "/foo/ff"));
 
   std::vector<Resource> resources1;
   resources1.push_back(CreateResource(1, URL(origin1, "/resource1"), 2013));
   resources1.push_back(CreateResource(2, URL(origin1, "/resource2"), 512));
   ASSERT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
       database->WriteRegistration(
           data1, resources1, &deleted_version, &newly_purgeable_resources));
-  ASSERT_EQ(
-      ServiceWorkerDatabase::STATUS_OK,
-      database->WriteUserData(
-          data1.registration_id, origin1, "key1", "data1"));
-  ASSERT_EQ(
-      ServiceWorkerDatabase::STATUS_OK,
-      database->WriteUserData(
-          data1.registration_id, origin1, "key2", "data2"));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteUserData(data1.registration_id, origin1,
+                                    {{"key1", "data1"}}));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteUserData(data1.registration_id, origin1,
+                                    {{"key2", "data2"}}));
 
   RegistrationData data2;
   data2.registration_id = 11;
   data2.scope = URL(origin1, "/bar");
   data2.script = URL(origin1, "/script2.js");
   data2.version_id = 101;
   data2.resources_total_size_bytes = 4 + 5;
 
   std::vector<Resource> resources2;
   resources2.push_back(CreateResource(3, URL(origin1, "/resource3"), 4));
   resources2.push_back(CreateResource(4, URL(origin1, "/resource4"), 5));
   ASSERT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
       database->WriteRegistration(
           data2, resources2, &deleted_version, &newly_purgeable_resources));
-  ASSERT_EQ(
-      ServiceWorkerDatabase::STATUS_OK,
-      database->WriteUserData(
-          data2.registration_id, origin1, "key3", "data3"));
-  ASSERT_EQ(
-      ServiceWorkerDatabase::STATUS_OK,
-      database->WriteUserData(
-          data2.registration_id, origin1, "key4", "data4"));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteUserData(data2.registration_id, origin1,
+                                    {{"key3", "data3"}}));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteUserData(data2.registration_id, origin1,
+                                    {{"key4", "data4"}}));
 
   // |origin2| has one registration (registration3).
   RegistrationData data3;
   data3.registration_id = 12;
   data3.scope = URL(origin2, "/hoge");
   data3.script = URL(origin2, "/script3.js");
   data3.version_id = 102;
   data3.resources_total_size_bytes = 6 + 7;
   data3.foreign_fetch_scopes.push_back(URL(origin2, "/hoge/ff"));
 
   std::vector<Resource> resources3;
   resources3.push_back(CreateResource(5, URL(origin2, "/resource5"), 6));
   resources3.push_back(CreateResource(6, URL(origin2, "/resource6"), 7));
   ASSERT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
       database->WriteRegistration(
           data3, resources3, &deleted_version, &newly_purgeable_resources));
-  ASSERT_EQ(
-      ServiceWorkerDatabase::STATUS_OK,
-      database->WriteUserData(
-          data3.registration_id, origin2, "key5", "data5"));
-  ASSERT_EQ(
-      ServiceWorkerDatabase::STATUS_OK,
-      database->WriteUserData(
-          data3.registration_id, origin2, "key6", "data6"));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteUserData(data3.registration_id, origin2,
+                                    {{"key5", "data5"}}));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteUserData(data3.registration_id, origin2,
+                                    {{"key6", "data6"}}));
 
   std::set<GURL> origins_to_delete;
   origins_to_delete.insert(origin1);
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->DeleteAllDataForOrigins(origins_to_delete,
                                               &newly_purgeable_resources));
 
   // |origin1| should be removed from the unique origin list.
   std::set<GURL> unique_origins;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
@@ skipping 35 matching lines @@
   std::set<int64_t> purgeable_ids_out;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetPurgeableResourceIds(&purgeable_ids_out));
   EXPECT_EQ(4u, purgeable_ids_out.size());
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 1));
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 2));
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 3));
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 4));
 
   // The user data associated with |origin1| should be removed.
-  std::string user_data_out;
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->ReadUserData(
-                data1.registration_id, "key1", &user_data_out));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->ReadUserData(
-                data1.registration_id, "key2", &user_data_out));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->ReadUserData(
-                data2.registration_id, "key3", &user_data_out));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->ReadUserData(
-                data2.registration_id, "key4", &user_data_out));
+  std::vector<std::string> user_data_out;
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+      database->ReadUserData(data1.registration_id, {"key1"}, &user_data_out));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+      database->ReadUserData(data1.registration_id, {"key2"}, &user_data_out));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+      database->ReadUserData(data2.registration_id, {"key3"}, &user_data_out));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+      database->ReadUserData(data2.registration_id, {"key4"}, &user_data_out));
 
   // The user data associated with |origin2| should not be removed.
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->ReadUserData(
-                data3.registration_id, "key5", &user_data_out));
-  EXPECT_EQ("data5", user_data_out);
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->ReadUserData(
-                data3.registration_id, "key6", &user_data_out));
-  EXPECT_EQ("data6", user_data_out);
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data3.registration_id, {"key5"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  EXPECT_EQ("data5", user_data_out[0]);
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->ReadUserData(data3.registration_id, {"key6"}, &user_data_out));
+  ASSERT_EQ(1u, user_data_out.size());
+  EXPECT_EQ("data6", user_data_out[0]);
 }
 
 TEST(ServiceWorkerDatabaseTest, DestroyDatabase) {
   base::ScopedTempDir database_dir;
   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
   std::unique_ptr<ServiceWorkerDatabase> database(
       CreateDatabase(database_dir.path()));
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true));
   ASSERT_TRUE(base::DirectoryExists(database_dir.path()));
@@ skipping 132 matching lines @@
                                         &deleted_version,
                                         &newly_purgeable_resources));
 
   origins.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetOriginsWithForeignFetchRegistrations(&origins));
   EXPECT_EQ(0U, origins.size());
 }
 
 }  // namespace content