Reland "service worker: Use mojo version of GetUserDataForAllRegistrations"

This is a reland of 853e0dd9

This is the third attempt to land. The second attempt was reverted
due to a flaky test. A speculative fix was landed in
crrev.com/c/2352268.

Original change's description:
> service worker: Use mojo version of GetUserDataForAllRegistrations
>
> This CL starts using mojo version of
> GetUserDataForAllRegistrations{,ByKeyPrefix}().
>
> The type of the return value of these methods is also changed from
> map<registration_id, value> to array<ServiceWorkerUserData>,
> and ServiceWorkerUserData now has registration_id.
> These changes are required to handle a situation where a
> registration_id is associated with multiple values. Some features like
> payments could associate multiple values for a registration_id.
>
> Bug: 1055677
> Change-Id: I29e9ae7c1722316b2ac2f163cfc5b50fe7590d54
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2331376
> Commit-Queue: Kenichi Ishibashi <bashi@chromium.org>
> Reviewed-by: Hiroki Nakagawa <nhiroki@chromium.org>
> Reviewed-by: Matt Falkenhagen <falken@chromium.org>
> Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#794447}

Bug: 1055677
Change-Id: I5bcaef59bfe96715684a11b41a728505c828f315
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2365732Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Reviewed-by: Hiroki Nakagawa <nhiroki@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Commit-Queue: Kenichi Ishibashi <bashi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#799992}

components/services/storage/public/mojom/service_worker_storage_control.mojom

@@ -93,6 +93,7 @@ interface ServiceWorkerResourceMetadataWriter {
 // lifetime of user data is tied up with the registration.
 // It will be deleted when the corresponding registration is deleted.
 struct ServiceWorkerUserData {
+  int64 registration_id;
   string key;
   string value;
 };
@@ -251,14 +252,14 @@ interface ServiceWorkerStorageControl {
       (ServiceWorkerDatabaseStatus status);
 
   // Gets the user data from all registrations that have user data for |key|.
-  // Returns a map from registration IDs to their values.
   GetUserDataForAllRegistrations(string key) =>
-      (ServiceWorkerDatabaseStatus status, map<int64, string> values);
+      (ServiceWorkerDatabaseStatus status,
+       array<ServiceWorkerUserData> values);
   // Gets the user data from all registrations that have user data for
-  // |key_prefix| where |key_prefix| is a prefix of keys. Returns a map from
-  // registration IDs to their values.
+  // |key_prefix| where |key_prefix| is a prefix of keys.
   GetUserDataForAllRegistrationsByKeyPrefix(string key_prefix) =>
-      (ServiceWorkerDatabaseStatus status, map<int64, string> values);
+      (ServiceWorkerDatabaseStatus status,
+       array<ServiceWorkerUserData> values);
   // Clears the user data from all registrations using |key_prefix| as a prefix
   // of keys.
   ClearUserDataForAllRegistrationsByKeyPrefix(string key_prefix) =>

content/browser/service_worker/service_worker_database.cc

@@ -1111,7 +1111,7 @@ ServiceWorkerDatabase::Status ServiceWorkerDatabase::RewriteDB() {
 ServiceWorkerDatabase::Status
 ServiceWorkerDatabase::ReadUserDataForAllRegistrations(
     const std::string& user_data_name,
-    std::vector<std::pair<int64_t, std::string>>* user_data) {
+    std::vector<storage::mojom::ServiceWorkerUserDataPtr>* user_data) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(user_data->empty());
 
@@ -1153,7 +1153,8 @@ ServiceWorkerDatabase::ReadUserDataForAllRegistrations(
         user_data->clear();
         break;
       }
-      user_data->push_back(std::make_pair(registration_id, value));
+      user_data->emplace_back(storage::mojom::ServiceWorkerUserData::New(
+          registration_id, user_data_name, value));
     }
   }
 
@@ -1164,7 +1165,7 @@ ServiceWorkerDatabase::ReadUserDataForAllRegistrations(
 ServiceWorkerDatabase::Status
 ServiceWorkerDatabase::ReadUserDataForAllRegistrationsByKeyPrefix(
     const std::string& user_data_name_prefix,
-    std::vector<std::pair<int64_t, std::string>>* user_data) {
+    std::vector<storage::mojom::ServiceWorkerUserDataPtr>* user_data) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(user_data->empty());
 
@@ -1221,7 +1222,8 @@ ServiceWorkerDatabase::ReadUserDataForAllRegistrationsByKeyPrefix(
         user_data->clear();
         break;
       }
-      user_data->push_back(std::make_pair(registration_id, value));
+      user_data->push_back(storage::mojom::ServiceWorkerUserData::New(
+          registration_id, parts[0], value));
     }
   }
 

content/browser/service_worker/service_worker_database.h

@@ -217,14 +217,14 @@ class CONTENT_EXPORT ServiceWorkerDatabase {
   // from the database. Returns OK if they are successfully read or not found.
   Status ReadUserDataForAllRegistrations(
       const std::string& user_data_name,
-      std::vector<std::pair<int64_t, std::string>>* user_data);
+      std::vector<storage::mojom::ServiceWorkerUserDataPtr>* user_data);
 
   // Reads user data for all registrations that have data with
   // |user_data_name_prefix| from the database. Returns OK if they are
   // successfully read or not found.
   Status ReadUserDataForAllRegistrationsByKeyPrefix(
       const std::string& user_data_name_prefix,
-      std::vector<std::pair<int64_t, std::string>>* user_data);
+      std::vector<storage::mojom::ServiceWorkerUserDataPtr>* user_data);
 
   // Deletes user data for all registrations that have data with
   // |user_data_name_prefix| from the database. Returns OK if all are

content/browser/service_worker/service_worker_database_unittest.cc

@@ -106,11 +106,12 @@ network::CrossOriginEmbedderPolicy CrossOriginEmbedderPolicyRequireCorp() {
 }
 
 std::vector<storage::mojom::ServiceWorkerUserDataPtr> CreateUserData(
+    int64_t registration_id,
     const std::vector<std::pair<std::string, std::string>>& key_value_pairs) {
   std::vector<storage::mojom::ServiceWorkerUserDataPtr> out;
   for (auto& kv : key_value_pairs) {
-    out.push_back(
-        storage::mojom::ServiceWorkerUserData::New(kv.first, kv.second));
+    out.push_back(storage::mojom::ServiceWorkerUserData::New(
+        registration_id, kv.first, kv.second));
   }
   return out;
 }
@@ -1083,8 +1084,9 @@ TEST(ServiceWorkerDatabaseTest, UserData_Basic) {
   // Write user data associated with the stored registration.
   std::vector<std::string> user_data_out;
   EXPECT_EQ(ServiceWorkerDatabase::Status::kOk,
-            database->WriteUserData(data.registration_id, kOrigin,
-                                    CreateUserData({{"key1", "data"}})));
+            database->WriteUserData(
+                data.registration_id, kOrigin,
+                CreateUserData(data.registration_id, {{"key1", "data"}})));
   EXPECT_EQ(
       ServiceWorkerDatabase::Status::kOk,
       database->ReadUserData(data.registration_id, {"key1"}, &user_data_out));
@@ -1094,13 +1096,15 @@ TEST(ServiceWorkerDatabaseTest, UserData_Basic) {
   // Writing user data not associated with the stored registration should be
   // failed.
   EXPECT_EQ(ServiceWorkerDatabase::Status::kErrorNotFound,
-            database->WriteUserData(300, kOrigin,
-                                    CreateUserData({{"key1", "data"}})));
+            database->WriteUserData(
+                300, kOrigin,
+                CreateUserData(data.registration_id, {{"key1", "data"}})));
 
   // Write empty user data for a different key.
   EXPECT_EQ(ServiceWorkerDatabase::Status::kOk,
             database->WriteUserData(data.registration_id, kOrigin,
-                                    CreateUserData({{"key2", std::string()}})));
+                                    CreateUserData(data.registration_id,
+                                                   {{"key2", std::string()}})));
   EXPECT_EQ(
       ServiceWorkerDatabase::Status::kOk,
       database->ReadUserData(data.registration_id, {"key2"}, &user_data_out));
@@ -1114,8 +1118,9 @@ TEST(ServiceWorkerDatabaseTest, UserData_Basic) {
 
   // Overwrite the existing user data.
   EXPECT_EQ(ServiceWorkerDatabase::Status::kOk,
-            database->WriteUserData(data.registration_id, kOrigin,
-                                    CreateUserData({{"key1", "overwrite"}})));
+            database->WriteUserData(
+                data.registration_id, kOrigin,
+                CreateUserData(data.registration_id, {{"key1", "overwrite"}})));
   EXPECT_EQ(
       ServiceWorkerDatabase::Status::kOk,
       database->ReadUserData(data.registration_id, {"key1"}, &user_data_out));
@@ -1137,10 +1142,11 @@ TEST(ServiceWorkerDatabaseTest, UserData_Basic) {
 
   // Write/overwrite multiple user data keys.
   EXPECT_EQ(ServiceWorkerDatabase::Status::kOk,
-            database->WriteUserData(data.registration_id, kOrigin,
-                                    CreateUserData({{"key2", "overwrite2"},
-                                                    {"key3", "data3"},
-                                                    {"key4", "data4"}})));
+            database->WriteUserData(
+                data.registration_id, kOrigin,
+                CreateUserData(data.registration_id, {{"key2", "overwrite2"},
+                                                      {"key3", "data3"},
+                                                      {"key4", "data4"}})));
   EXPECT_EQ(
       ServiceWorkerDatabase::Status::kErrorNotFound,
       database->ReadUserData(data.registration_id, {"key1"}, &user_data_out));
@@ -1212,51 +1218,63 @@ TEST(ServiceWorkerDatabaseTest,
   ASSERT_EQ(
       ServiceWorkerDatabase::Status::kOk,
       database->WriteUserData(data1.registration_id, kOrigin,
-                              CreateUserData({{"key_prefix:key1", "value1"}})));
+                              CreateUserData(data1.registration_id,
+                                             {{"key_prefix:key1", "value1"}})));
   ASSERT_EQ(
       ServiceWorkerDatabase::Status::kOk,
       database->WriteUserData(data1.registration_id, kOrigin,
-                              CreateUserData({{"key_prefix:key2", "value2"}})));
+                              CreateUserData(data1.registration_id,
+                                             {{"key_prefix:key2", "value2"}})));
   ASSERT_EQ(
       ServiceWorkerDatabase::Status::kOk,
       database->WriteUserData(data1.registration_id, kOrigin,
-                              CreateUserData({{"key_prefix:key3", "value3"}})));
+                              CreateUserData(data1.registration_id,
+                                             {{"key_prefix:key3", "value3"}})));
 
   // Write user data associated with the registration2.
   ASSERT_EQ(
       ServiceWorkerDatabase::Status::kOk,
       database->WriteUserData(data2.registration_id, kOrigin,
-                              CreateUserData({{"key_prefix:key1", "value1"}})));
+                              CreateUserData(data2.registration_id,
+                                             {{"key_prefix:key1", "value1"}})));
   ASSERT_EQ(
       ServiceWorkerDatabase::Status::kOk,
       database->WriteUserData(data2.registration_id, kOrigin,
-                              CreateUserData({{"key_prefix:key2", "value2"}})));
+                              CreateUserData(data2.registration_id,
+                                             {{"key_prefix:key2", "value2"}})));
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             database->WriteUserData(
                 data2.registration_id, kOrigin,
-                CreateUserData({{"another_key_prefix:key1", "value1"}})));
+                CreateUserData(data2.registration_id,
+                               {{"another_key_prefix:key1", "value1"}})));
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             database->WriteUserData(
                 data2.registration_id, kOrigin,
-                CreateUserData({{"another_key_prefix:key2", "value2"}})));
+                CreateUserData(data2.registration_id,
+                               {{"another_key_prefix:key2", "value2"}})));
 
   // Get all registrations with user data by key prefix.
-  std::vector<std::pair<int64_t, std::string>> user_data_list;
+  std::vector<storage::mojom::ServiceWorkerUserDataPtr> user_data_list;
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             database->ReadUserDataForAllRegistrationsByKeyPrefix(
                 "key_prefix:", &user_data_list));
   ASSERT_EQ(5u, user_data_list.size());
 
-  EXPECT_EQ(data1.registration_id, user_data_list[0].first);
-  EXPECT_EQ("value1", user_data_list[0].second);
-  EXPECT_EQ(data2.registration_id, user_data_list[1].first);
-  EXPECT_EQ("value1", user_data_list[1].second);
-  EXPECT_EQ(data1.registration_id, user_data_list[2].first);
-  EXPECT_EQ("value2", user_data_list[2].second);
-  EXPECT_EQ(data2.registration_id, user_data_list[3].first);
-  EXPECT_EQ("value2", user_data_list[3].second);
-  EXPECT_EQ(data1.registration_id, user_data_list[4].first);
-  EXPECT_EQ("value3", user_data_list[4].second);
+  EXPECT_EQ(data1.registration_id, user_data_list[0]->registration_id);
+  EXPECT_EQ("key_prefix:key1", user_data_list[0]->key);
+  EXPECT_EQ("value1", user_data_list[0]->value);
+  EXPECT_EQ(data2.registration_id, user_data_list[1]->registration_id);
+  EXPECT_EQ("key_prefix:key1", user_data_list[1]->key);
+  EXPECT_EQ("value1", user_data_list[1]->value);
+  EXPECT_EQ(data1.registration_id, user_data_list[2]->registration_id);
+  EXPECT_EQ("key_prefix:key2", user_data_list[2]->key);
+  EXPECT_EQ("value2", user_data_list[2]->value);
+  EXPECT_EQ(data2.registration_id, user_data_list[3]->registration_id);
+  EXPECT_EQ("key_prefix:key2", user_data_list[3]->key);
+  EXPECT_EQ("value2", user_data_list[3]->value);
+  EXPECT_EQ(data1.registration_id, user_data_list[4]->registration_id);
+  EXPECT_EQ("key_prefix:key3", user_data_list[4]->key);
+  EXPECT_EQ("value3", user_data_list[4]->value);
 }
 
 TEST(ServiceWorkerDatabaseTest, ReadUserDataByKeyPrefix) {
@@ -1280,7 +1298,8 @@ TEST(ServiceWorkerDatabaseTest, ReadUserDataByKeyPrefix) {
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             database->WriteUserData(
                 data.registration_id, kOrigin,
-                CreateUserData({{"key_prefix:key1", "value_c1"},
+                CreateUserData(data.registration_id,
+                               {{"key_prefix:key1", "value_c1"},
                                 {"key_prefix:key2", "value_c2"},
                                 {"other_key_prefix:k1", "value_d1"},
                                 {"other_key_prefix:k2", "value_d2"}})));
@@ -1325,7 +1344,8 @@ TEST(ServiceWorkerDatabaseTest, ReadUserKeysAndDataByKeyPrefix) {
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             database->WriteUserData(
                 data.registration_id, kOrigin,
-                CreateUserData({{"key_prefix:key1", "value_c1"},
+                CreateUserData(data.registration_id,
+                               {{"key_prefix:key1", "value_c1"},
                                 {"key_prefix:key2", "value_c2"},
                                 {"other_key_prefix:k1", "value_d1"},
                                 {"other_key_prefix:k2", "value_d2"}})));
@@ -1387,7 +1407,8 @@ TEST(ServiceWorkerDatabaseTest, UserData_DeleteUserDataByKeyPrefixes) {
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             database->WriteUserData(
                 data1.registration_id, kOrigin,
-                CreateUserData({{"key_prefix:key1", "value_a1"},
+                CreateUserData(data1.registration_id,
+                               {{"key_prefix:key1", "value_a1"},
                                 {"key_prefix:key2", "value_a2"},
                                 {"key_prefix:key3", "value_a3"},
                                 {"kept_key_prefix:key1", "value_b1"}})));
@@ -1396,7 +1417,8 @@ TEST(ServiceWorkerDatabaseTest, UserData_DeleteUserDataByKeyPrefixes) {
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             database->WriteUserData(
                 data2.registration_id, kOrigin,
-                CreateUserData({{"key_prefix:key1", "value_c1"},
+                CreateUserData(data2.registration_id,
+                               {{"key_prefix:key1", "value_c1"},
                                 {"key_prefix:key2", "value_c2"},
                                 {"other_key_prefix:key1", "value_d1"},
                                 {"other_key_prefix:key2", "value_d2"},
@@ -1418,17 +1440,20 @@ TEST(ServiceWorkerDatabaseTest, UserData_DeleteUserDataByKeyPrefixes) {
                 {"key_prefix:", "other_key_prefix:", "not_found_key_prefix:"}));
 
   // User data with deleted "key_prefix:" should only remain for registration 1.
-  std::vector<std::pair<int64_t, std::string>> user_data_list;
+  std::vector<storage::mojom::ServiceWorkerUserDataPtr> user_data_list;
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             database->ReadUserDataForAllRegistrationsByKeyPrefix(
                 "key_prefix:", &user_data_list));
   ASSERT_EQ(3u, user_data_list.size());
-  EXPECT_EQ(data1.registration_id, user_data_list[0].first);
-  EXPECT_EQ("value_a1", user_data_list[0].second);
-  EXPECT_EQ(data1.registration_id, user_data_list[1].first);
-  EXPECT_EQ("value_a2", user_data_list[1].second);
-  EXPECT_EQ(data1.registration_id, user_data_list[2].first);
-  EXPECT_EQ("value_a3", user_data_list[2].second);
+  EXPECT_EQ(data1.registration_id, user_data_list[0]->registration_id);
+  EXPECT_EQ("key_prefix:key1", user_data_list[0]->key);
+  EXPECT_EQ("value_a1", user_data_list[0]->value);
+  EXPECT_EQ(data1.registration_id, user_data_list[1]->registration_id);
+  EXPECT_EQ("key_prefix:key2", user_data_list[1]->key);
+  EXPECT_EQ("value_a2", user_data_list[1]->value);
+  EXPECT_EQ(data1.registration_id, user_data_list[2]->registration_id);
+  EXPECT_EQ("key_prefix:key3", user_data_list[2]->key);
+  EXPECT_EQ("value_a3", user_data_list[2]->value);
 
   // User data for second deleted key prefix should also have been deleted.
   user_data_list.clear();
@@ -1444,12 +1469,15 @@ TEST(ServiceWorkerDatabaseTest, UserData_DeleteUserDataByKeyPrefixes) {
             database->ReadUserDataForAllRegistrationsByKeyPrefix(
                 "kept_key_prefix:", &user_data_list));
   ASSERT_EQ(3u, user_data_list.size());
-  EXPECT_EQ(data1.registration_id, user_data_list[0].first);
-  EXPECT_EQ("value_b1", user_data_list[0].second);
-  EXPECT_EQ(data2.registration_id, user_data_list[1].first);
-  EXPECT_EQ("value_e1", user_data_list[1].second);
-  EXPECT_EQ(data2.registration_id, user_data_list[2].first);
-  EXPECT_EQ("value_e2", user_data_list[2].second);
+  EXPECT_EQ(data1.registration_id, user_data_list[0]->registration_id);
+  EXPECT_EQ("kept_key_prefix:key1", user_data_list[0]->key);
+  EXPECT_EQ("value_b1", user_data_list[0]->value);
+  EXPECT_EQ(data2.registration_id, user_data_list[1]->registration_id);
+  EXPECT_EQ("kept_key_prefix:key1", user_data_list[1]->key);
+  EXPECT_EQ("value_e1", user_data_list[1]->value);
+  EXPECT_EQ(data2.registration_id, user_data_list[2]->registration_id);
+  EXPECT_EQ("kept_key_prefix:key2", user_data_list[2]->key);
+  EXPECT_EQ("value_e2", user_data_list[2]->value);
 }
 
 TEST(ServiceWorkerDatabaseTest,
@@ -1487,7 +1515,8 @@ TEST(ServiceWorkerDatabaseTest,
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             database->WriteUserData(
                 data1.registration_id, kOrigin,
-                CreateUserData({{"key_prefix:key1", "value_a1"},
+                CreateUserData(data1.registration_id,
+                               {{"key_prefix:key1", "value_a1"},
                                 {"key_prefix:key2", "value_a2"},
                                 {"key_prefix:key3", "value_a3"},
                                 {"kept_key_prefix:key1", "value_b1"}})));
@@ -1496,7 +1525,8 @@ TEST(ServiceWorkerDatabaseTest,
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             database->WriteUserData(
                 data2.registration_id, kOrigin,
-                CreateUserData({{"key_prefix:key1", "value_c1"},
+                CreateUserData(data2.registration_id,
+                               {{"key_prefix:key1", "value_c1"},
                                 {"key_prefix:key2", "value_c2"},
                                 {"kept_key_prefix:key1", "value_d1"},
                                 {"kept_key_prefix:key2", "value_d2"}})));
@@ -1514,7 +1544,7 @@ TEST(ServiceWorkerDatabaseTest,
       database->DeleteUserDataForAllRegistrationsByKeyPrefix("key_prefix:"));
 
   // User data with deleted "key_prefix:" should be deleted.
-  std::vector<std::pair<int64_t, std::string>> user_data_list;
+  std::vector<storage::mojom::ServiceWorkerUserDataPtr> user_data_list;
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             database->ReadUserDataForAllRegistrationsByKeyPrefix(
                 "key_prefix:", &user_data_list));
@@ -1527,12 +1557,15 @@ TEST(ServiceWorkerDatabaseTest,
                 "kept_key_prefix:", &user_data_list));
   ASSERT_EQ(3u, user_data_list.size());
 
-  EXPECT_EQ(data1.registration_id, user_data_list[0].first);
-  EXPECT_EQ("value_b1", user_data_list[0].second);
-  EXPECT_EQ(data2.registration_id, user_data_list[1].first);
-  EXPECT_EQ("value_d1", user_data_list[1].second);
-  EXPECT_EQ(data2.registration_id, user_data_list[2].first);
-  EXPECT_EQ("value_d2", user_data_list[2].second);
+  EXPECT_EQ(data1.registration_id, user_data_list[0]->registration_id);
+  EXPECT_EQ("kept_key_prefix:key1", user_data_list[0]->key);
+  EXPECT_EQ("value_b1", user_data_list[0]->value);
+  EXPECT_EQ(data2.registration_id, user_data_list[1]->registration_id);
+  EXPECT_EQ("kept_key_prefix:key1", user_data_list[1]->key);
+  EXPECT_EQ("value_d1", user_data_list[1]->value);
+  EXPECT_EQ(data2.registration_id, user_data_list[2]->registration_id);
+  EXPECT_EQ("kept_key_prefix:key2", user_data_list[2]->key);
+  EXPECT_EQ("value_d2", user_data_list[2]->value);
 }
 
 TEST(ServiceWorkerDatabaseTest, UserData_DataIsolation) {
@@ -1569,13 +1602,14 @@ TEST(ServiceWorkerDatabaseTest, UserData_DataIsolation) {
   // Write user data associated with the registration1.
   std::vector<std::string> user_data_out;
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
-            database->WriteUserData(data1.registration_id, kOrigin,
-                                    CreateUserData({{"key", "data1"}})));
+            database->WriteUserData(
+                data1.registration_id, kOrigin,
+                CreateUserData(data1.registration_id, {{"key", "value1"}})));
   EXPECT_EQ(
       ServiceWorkerDatabase::Status::kOk,
       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("value1", user_data_out[0]);
   EXPECT_EQ(
       ServiceWorkerDatabase::Status::kErrorNotFound,
       database->ReadUserData(data2.registration_id, {"key"}, &user_data_out));
@@ -1583,28 +1617,31 @@ TEST(ServiceWorkerDatabaseTest, UserData_DataIsolation) {
   // Write user data associated with the registration2. This shouldn't overwrite
   // the data associated with registration1.
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
-            database->WriteUserData(data2.registration_id, kOrigin,
-                                    CreateUserData({{"key", "data2"}})));
+            database->WriteUserData(
+                data2.registration_id, kOrigin,
+                CreateUserData(data2.registration_id, {{"key", "value2"}})));
   EXPECT_EQ(
       ServiceWorkerDatabase::Status::kOk,
       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("value1", user_data_out[0]);
   EXPECT_EQ(
       ServiceWorkerDatabase::Status::kOk,
       database->ReadUserData(data2.registration_id, {"key"}, &user_data_out));
   ASSERT_EQ(1u, user_data_out.size());
-  EXPECT_EQ("data2", user_data_out[0]);
+  EXPECT_EQ("value2", user_data_out[0]);
 
   // Get all registrations with user data.
-  std::vector<std::pair<int64_t, std::string>> user_data_list;
+  std::vector<storage::mojom::ServiceWorkerUserDataPtr> user_data_list;
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             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);
+  EXPECT_EQ(data1.registration_id, user_data_list[0]->registration_id);
+  EXPECT_EQ("key", user_data_list[0]->key);
+  EXPECT_EQ("value1", user_data_list[0]->value);
+  EXPECT_EQ(data2.registration_id, user_data_list[1]->registration_id);
+  EXPECT_EQ("key", user_data_list[1]->key);
+  EXPECT_EQ("value2", user_data_list[1]->value);
 
   // Delete the data associated with the registration2. This shouldn't delete
   // the data associated with registration1.
@@ -1614,7 +1651,7 @@ TEST(ServiceWorkerDatabaseTest, UserData_DataIsolation) {
       ServiceWorkerDatabase::Status::kOk,
       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("value1", user_data_out[0]);
   EXPECT_EQ(
       ServiceWorkerDatabase::Status::kErrorNotFound,
       database->ReadUserData(data2.registration_id, {"key"}, &user_data_out));
@@ -1624,8 +1661,9 @@ TEST(ServiceWorkerDatabaseTest, UserData_DataIsolation) {
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             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);
+  EXPECT_EQ(data1.registration_id, user_data_list[0]->registration_id);
+  EXPECT_EQ("key", user_data_list[0]->key);
+  EXPECT_EQ("value1", user_data_list[0]->value);
 }
 
 TEST(ServiceWorkerDatabaseTest, UserData_DeleteRegistration) {
@@ -1661,31 +1699,34 @@ TEST(ServiceWorkerDatabaseTest, UserData_DeleteRegistration) {
   // Write user data associated with the registration1.
   std::vector<std::string> user_data_out;
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
-            database->WriteUserData(data1.registration_id, kOrigin,
-                                    CreateUserData({{"key1", "data1"}})));
+            database->WriteUserData(
+                data1.registration_id, kOrigin,
+                CreateUserData(data1.registration_id, {{"key1", "value1"}})));
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
-            database->WriteUserData(data1.registration_id, kOrigin,
-                                    CreateUserData({{"key2", "data2"}})));
+            database->WriteUserData(
+                data1.registration_id, kOrigin,
+                CreateUserData(data1.registration_id, {{"key2", "value2"}})));
   ASSERT_EQ(
       ServiceWorkerDatabase::Status::kOk,
       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("value1", user_data_out[0]);
   ASSERT_EQ(
       ServiceWorkerDatabase::Status::kOk,
       database->ReadUserData(data1.registration_id, {"key2"}, &user_data_out));
   ASSERT_EQ(1u, user_data_out.size());
-  ASSERT_EQ("data2", user_data_out[0]);
+  ASSERT_EQ("value2", user_data_out[0]);
 
   // Write user data associated with the registration2.
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
-            database->WriteUserData(data2.registration_id, kOrigin,
-                                    CreateUserData({{"key3", "data3"}})));
+            database->WriteUserData(
+                data2.registration_id, kOrigin,
+                CreateUserData(data2.registration_id, {{"key3", "value3"}})));
   ASSERT_EQ(
       ServiceWorkerDatabase::Status::kOk,
       database->ReadUserData(data2.registration_id, {"key3"}, &user_data_out));
   ASSERT_EQ(1u, user_data_out.size());
-  ASSERT_EQ("data3", user_data_out[0]);
+  ASSERT_EQ("value3", user_data_out[0]);
 
   // Delete all data associated with the registration1. This shouldn't delete
   // the data associated with registration2.
@@ -1702,7 +1743,7 @@ TEST(ServiceWorkerDatabaseTest, UserData_DeleteRegistration) {
       ServiceWorkerDatabase::Status::kOk,
       database->ReadUserData(data2.registration_id, {"key3"}, &user_data_out));
   ASSERT_EQ(1u, user_data_out.size());
-  EXPECT_EQ("data3", user_data_out[0]);
+  EXPECT_EQ("value3", user_data_out[0]);
 }
 
 TEST(ServiceWorkerDatabaseTest, UserData_UninitializedDatabase) {
@@ -1715,9 +1756,9 @@ TEST(ServiceWorkerDatabaseTest, UserData_UninitializedDatabase) {
             database->ReadUserData(100, {"key"}, &user_data_out));
 
   // Should be failed because the associated registration does not exist.
-  EXPECT_EQ(
-      ServiceWorkerDatabase::Status::kErrorNotFound,
-      database->WriteUserData(100, kOrigin, CreateUserData({{"key", "data"}})));
+  EXPECT_EQ(ServiceWorkerDatabase::Status::kErrorNotFound,
+            database->WriteUserData(100, kOrigin,
+                                    CreateUserData(100, {{"key", "value"}})));
 
   // Deleting non-existent entry should succeed.
   EXPECT_EQ(ServiceWorkerDatabase::Status::kOk,
@@ -1731,9 +1772,9 @@ TEST(ServiceWorkerDatabaseTest, UserData_UninitializedDatabase) {
             database->state_);
   EXPECT_EQ(ServiceWorkerDatabase::Status::kErrorNotFound,
             database->ReadUserData(100, {"key"}, &user_data_out));
-  EXPECT_EQ(
-      ServiceWorkerDatabase::Status::kErrorNotFound,
-      database->WriteUserData(100, kOrigin, CreateUserData({{"key", "data"}})));
+  EXPECT_EQ(ServiceWorkerDatabase::Status::kErrorNotFound,
+            database->WriteUserData(100, kOrigin,
+                                    CreateUserData(100, {{"key", "value"}})));
 
   // Deleting non-existent entry should succeed.
   EXPECT_EQ(ServiceWorkerDatabase::Status::kOk,
@@ -1926,11 +1967,13 @@ TEST(ServiceWorkerDatabaseTest, DeleteAllDataForOrigin) {
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             database->WriteRegistration(data1, resources1, &deleted_version));
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
-            database->WriteUserData(data1.registration_id, origin1,
-                                    CreateUserData({{"key1", "data1"}})));
+            database->WriteUserData(
+                data1.registration_id, origin1,
+                CreateUserData(data1.registration_id, {{"key1", "value1"}})));
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
-            database->WriteUserData(data1.registration_id, origin1,
-                                    CreateUserData({{"key2", "data2"}})));
+            database->WriteUserData(
+                data1.registration_id, origin1,
+                CreateUserData(data1.registration_id, {{"key2", "value2"}})));
 
   RegistrationData data2;
   data2.registration_id = 11;
@@ -1945,11 +1988,13 @@ TEST(ServiceWorkerDatabaseTest, DeleteAllDataForOrigin) {
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             database->WriteRegistration(data2, resources2, &deleted_version));
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
-            database->WriteUserData(data2.registration_id, origin1,
-                                    CreateUserData({{"key3", "data3"}})));
+            database->WriteUserData(
+                data2.registration_id, origin1,
+                CreateUserData(data2.registration_id, {{"key3", "value3"}})));
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
-            database->WriteUserData(data2.registration_id, origin1,
-                                    CreateUserData({{"key4", "data4"}})));
+            database->WriteUserData(
+                data2.registration_id, origin1,
+                CreateUserData(data2.registration_id, {{"key4", "value4"}})));
 
   // |origin2| has one registration (registration3).
   RegistrationData data3;
@@ -1965,11 +2010,13 @@ TEST(ServiceWorkerDatabaseTest, DeleteAllDataForOrigin) {
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
             database->WriteRegistration(data3, resources3, &deleted_version));
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
-            database->WriteUserData(data3.registration_id, origin2,
-                                    CreateUserData({{"key5", "data5"}})));
+            database->WriteUserData(
+                data3.registration_id, origin2,
+                CreateUserData(data3.registration_id, {{"key5", "value5"}})));
   ASSERT_EQ(ServiceWorkerDatabase::Status::kOk,
-            database->WriteUserData(data3.registration_id, origin2,
-                                    CreateUserData({{"key6", "data6"}})));
+            database->WriteUserData(
+                data3.registration_id, origin2,
+                CreateUserData(data3.registration_id, {{"key6", "value6"}})));
 
   std::set<GURL> origins_to_delete;
   std::vector<int64_t> newly_purgeable_resources;
@@ -2039,12 +2086,12 @@ TEST(ServiceWorkerDatabaseTest, DeleteAllDataForOrigin) {
       ServiceWorkerDatabase::Status::kOk,
       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("value5", user_data_out[0]);
   EXPECT_EQ(
       ServiceWorkerDatabase::Status::kOk,
       database->ReadUserData(data3.registration_id, {"key6"}, &user_data_out));
   ASSERT_EQ(1u, user_data_out.size());
-  EXPECT_EQ("data6", user_data_out[0]);
+  EXPECT_EQ("value6", user_data_out[0]);
 }
 
 TEST(ServiceWorkerDatabaseTest, DestroyDatabase) {

content/browser/service_worker/service_worker_registry.cc

@@ -616,8 +616,8 @@ void ServiceWorkerRegistry::StoreUserData(
                              blink::ServiceWorkerStatusCode::kErrorFailed));
       return;
     }
-    user_data.push_back(
-        storage::mojom::ServiceWorkerUserData::New(kv.first, kv.second));
+    user_data.push_back(storage::mojom::ServiceWorkerUserData::New(
+        registration_id, kv.first, kv.second));
   }
 
   GetRemoteStorageControl()->StoreUserData(
@@ -708,7 +708,7 @@ void ServiceWorkerRegistry::GetUserDataForAllRegistrations(
     return;
   }
 
-  storage()->GetUserDataForAllRegistrations(
+  GetRemoteStorageControl()->GetUserDataForAllRegistrations(
       key,
       base::BindOnce(&ServiceWorkerRegistry::DidGetUserDataForAllRegistrations,
                      weak_factory_.GetWeakPtr(), std::move(callback)));
@@ -726,7 +726,7 @@ void ServiceWorkerRegistry::GetUserDataForAllRegistrationsByKeyPrefix(
     return;
   }
 
-  storage()->GetUserDataForAllRegistrationsByKeyPrefix(
+  GetRemoteStorageControl()->GetUserDataForAllRegistrationsByKeyPrefix(
       key_prefix,
       base::BindOnce(&ServiceWorkerRegistry::DidGetUserDataForAllRegistrations,
                      weak_factory_.GetWeakPtr(), std::move(callback)));
@@ -1287,11 +1287,18 @@ void ServiceWorkerRegistry::DidClearUserData(
 
 void ServiceWorkerRegistry::DidGetUserDataForAllRegistrations(
     GetUserDataForAllRegistrationsCallback callback,
-    const std::vector<std::pair<int64_t, std::string>>& user_data,
-    storage::mojom::ServiceWorkerDatabaseStatus status) {
+    storage::mojom::ServiceWorkerDatabaseStatus status,
+    std::vector<storage::mojom::ServiceWorkerUserDataPtr> entries) {
   DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
+  // TODO(crbug.com/1055677): Update call sites of
+  // GetUserDataForAllRegistrations so that we can avoid converting mojo struct
+  // to a pair.
+  std::vector<std::pair<int64_t, std::string>> user_data;
   if (status != storage::mojom::ServiceWorkerDatabaseStatus::kOk)
     ScheduleDeleteAndStartOver();
+  for (auto& entry : entries) {
+    user_data.emplace_back(entry->registration_id, entry->value);
+  }
   std::move(callback).Run(user_data, DatabaseStatusToStatusCode(status));
 }
 

content/browser/service_worker/service_worker_registry.h

@@ -337,8 +337,8 @@ class CONTENT_EXPORT ServiceWorkerRegistry {
                         storage::mojom::ServiceWorkerDatabaseStatus status);
   void DidGetUserDataForAllRegistrations(
       GetUserDataForAllRegistrationsCallback callback,
-      const std::vector<std::pair<int64_t, std::string>>& user_data,
-      storage::mojom::ServiceWorkerDatabaseStatus status);
+      storage::mojom::ServiceWorkerDatabaseStatus status,
+      std::vector<storage::mojom::ServiceWorkerUserDataPtr> entries);
 
   void DidGetNewRegistrationId(
       blink::mojom::ServiceWorkerRegistrationOptions options,

content/browser/service_worker/service_worker_storage.cc

@@ -786,9 +786,10 @@ void ServiceWorkerStorage::GetUserDataForAllRegistrations(
   switch (state_) {
     case STORAGE_STATE_DISABLED:
       RunSoon(FROM_HERE,
-              base::BindOnce(std::move(callback),
-                             std::vector<std::pair<int64_t, std::string>>(),
-                             ServiceWorkerDatabase::Status::kErrorDisabled));
+              base::BindOnce(
+                  std::move(callback),
+                  ServiceWorkerDatabase::Status::kErrorDisabled,
+                  std::vector<storage::mojom::ServiceWorkerUserDataPtr>()));
       return;
     case STORAGE_STATE_INITIALIZING:  // Fall-through.
     case STORAGE_STATE_UNINITIALIZED:
@@ -817,9 +818,10 @@ void ServiceWorkerStorage::GetUserDataForAllRegistrationsByKeyPrefix(
   switch (state_) {
     case STORAGE_STATE_DISABLED:
       RunSoon(FROM_HERE,
-              base::BindOnce(std::move(callback),
-                             std::vector<std::pair<int64_t, std::string>>(),
-                             ServiceWorkerDatabase::Status::kErrorDisabled));
+              base::BindOnce(
+                  std::move(callback),
+                  ServiceWorkerDatabase::Status::kErrorDisabled,
+                  std::vector<storage::mojom::ServiceWorkerUserDataPtr>()));
       return;
     case STORAGE_STATE_INITIALIZING:  // Fall-through.
     case STORAGE_STATE_UNINITIALIZED:
@@ -1607,11 +1609,12 @@ void ServiceWorkerStorage::GetUserDataForAllRegistrationsInDB(
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     const std::string& key,
     GetUserDataForAllRegistrationsInDBCallback callback) {
-  std::vector<std::pair<int64_t, std::string>> user_data;
+  std::vector<storage::mojom::ServiceWorkerUserDataPtr> user_data;
   ServiceWorkerDatabase::Status status =
       database->ReadUserDataForAllRegistrations(key, &user_data);
   original_task_runner->PostTask(
-      FROM_HERE, base::BindOnce(std::move(callback), user_data, status));
+      FROM_HERE,
+      base::BindOnce(std::move(callback), status, std::move(user_data)));
 }
 
 void ServiceWorkerStorage::GetUserDataForAllRegistrationsByKeyPrefixInDB(
@@ -1619,12 +1622,13 @@ void ServiceWorkerStorage::GetUserDataForAllRegistrationsByKeyPrefixInDB(
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     const std::string& key_prefix,
     GetUserDataForAllRegistrationsInDBCallback callback) {
-  std::vector<std::pair<int64_t, std::string>> user_data;
+  std::vector<storage::mojom::ServiceWorkerUserDataPtr> user_data;
   ServiceWorkerDatabase::Status status =
       database->ReadUserDataForAllRegistrationsByKeyPrefix(key_prefix,
                                                            &user_data);
   original_task_runner->PostTask(
-      FROM_HERE, base::BindOnce(std::move(callback), user_data, status));
+      FROM_HERE,
+      base::BindOnce(std::move(callback), status, std::move(user_data)));
 }
 
 void ServiceWorkerStorage::DeleteAllDataForOriginsFromDB(

content/browser/service_worker/service_worker_storage.h

@@ -107,8 +107,8 @@ class CONTENT_EXPORT ServiceWorkerStorage {
   using GetUserKeysAndDataInDBCallback = storage::mojom::
       ServiceWorkerStorageControl::GetUserKeysAndDataByKeyPrefixCallback;
   using GetUserDataForAllRegistrationsInDBCallback = base::OnceCallback<void(
-      const std::vector<std::pair<int64_t, std::string>>& user_data,
-      ServiceWorkerDatabase::Status)>;
+      ServiceWorkerDatabase::Status,
+      std::vector<storage::mojom::ServiceWorkerUserDataPtr>)>;
 
   ~ServiceWorkerStorage();
 

content/browser/service_worker/service_worker_storage_control_impl.cc

@@ -13,20 +13,6 @@ namespace content {
 
 namespace {
 
-void DidGetUserDataForAllRegistrations(
-    ServiceWorkerStorageControlImpl::GetUserDataForAllRegistrationsCallback
-        callback,
-    const std::vector<std::pair<int64_t, std::string>>& user_data,
-    storage::mojom::ServiceWorkerDatabaseStatus status) {
-  // TODO(bashi): Change ServiceWorkerStorage::GetUserDataForAllRegistrations()
-  // to return base::flat_map.
-  base::flat_map<int64_t, std::string> values;
-  for (auto& entry : user_data) {
-    values[entry.first] = entry.second;
-  }
-  std::move(callback).Run(status, std::move(values));
-}
-
 void DidGetAllRegistrations(
     ServiceWorkerStorageControlImpl::GetAllRegistrationsDeprecatedCallback
         callback,
@@ -357,17 +343,14 @@ void ServiceWorkerStorageControlImpl::ClearUserDataByKeyPrefixes(
 void ServiceWorkerStorageControlImpl::GetUserDataForAllRegistrations(
     const std::string& key,
     GetUserDataForAllRegistrationsCallback callback) {
-  storage_->GetUserDataForAllRegistrations(
-      key,
-      base::BindOnce(&DidGetUserDataForAllRegistrations, std::move(callback)));
+  storage_->GetUserDataForAllRegistrations(key, std::move(callback));
 }
 
 void ServiceWorkerStorageControlImpl::GetUserDataForAllRegistrationsByKeyPrefix(
     const std::string& key_prefix,
     GetUserDataForAllRegistrationsByKeyPrefixCallback callback) {
-  storage_->GetUserDataForAllRegistrationsByKeyPrefix(
-      key_prefix,
-      base::BindOnce(&DidGetUserDataForAllRegistrations, std::move(callback)));
+  storage_->GetUserDataForAllRegistrationsByKeyPrefix(key_prefix,
+                                                      std::move(callback));
 }
 
 void ServiceWorkerStorageControlImpl::

content/browser/service_worker/service_worker_storage_control_impl_unittest.cc

@@ -84,7 +84,7 @@ struct GetUserKeysAndDataByKeyPrefixResult {
 
 struct GetUserDataForAllRegistrationsResult {
   DatabaseStatus status;
-  base::flat_map<int64_t, std::string> values;
+  std::vector<storage::mojom::ServiceWorkerUserDataPtr> values;
 };
 
 ReadResponseHeadResult ReadResponseHead(
@@ -536,13 +536,14 @@ class ServiceWorkerStorageControlImplTest : public testing::Test {
     GetUserDataForAllRegistrationsResult result;
     base::RunLoop loop;
     storage()->GetUserDataForAllRegistrations(
-        key, base::BindLambdaForTesting(
-                 [&](DatabaseStatus status,
-                     const base::flat_map<int64_t, std::string>& values) {
-                   result.status = status;
-                   result.values = values;
-                   loop.Quit();
-                 }));
+        key,
+        base::BindLambdaForTesting(
+            [&](DatabaseStatus status,
+                std::vector<storage::mojom::ServiceWorkerUserDataPtr> values) {
+              result.status = status;
+              result.values = std::move(values);
+              loop.Quit();
+            }));
     loop.Run();
     return result;
   }
@@ -555,9 +556,9 @@ class ServiceWorkerStorageControlImplTest : public testing::Test {
         key_prefix,
         base::BindLambdaForTesting(
             [&](DatabaseStatus status,
-                const base::flat_map<int64_t, std::string>& values) {
+                std::vector<storage::mojom::ServiceWorkerUserDataPtr> values) {
               result.status = status;
-              result.values = values;
+              result.values = std::move(values);
               loop.Quit();
             }));
     loop.Run();
@@ -1162,10 +1163,10 @@ TEST_F(ServiceWorkerStorageControlImplTest, StoreAndGetUserData) {
   // Store user data with two entries.
   {
     std::vector<storage::mojom::ServiceWorkerUserDataPtr> user_data;
-    user_data.push_back(
-        storage::mojom::ServiceWorkerUserData::New("key1", "value1"));
-    user_data.push_back(
-        storage::mojom::ServiceWorkerUserData::New("key2", "value2"));
+    user_data.push_back(storage::mojom::ServiceWorkerUserData::New(
+        registration_id, "key1", "value1"));
+    user_data.push_back(storage::mojom::ServiceWorkerUserData::New(
+        registration_id, "key2", "value2"));
 
     status = StoreUserData(registration_id, kScope.GetOrigin(),
                            std::move(user_data));
@@ -1252,14 +1253,14 @@ TEST_F(ServiceWorkerStorageControlImplTest, StoreAndGetUserDataByKeyPrefix) {
 
   // Store some user data with prefixes.
   std::vector<storage::mojom::ServiceWorkerUserDataPtr> user_data;
-  user_data.push_back(
-      storage::mojom::ServiceWorkerUserData::New("prefixA", "value1"));
-  user_data.push_back(
-      storage::mojom::ServiceWorkerUserData::New("prefixA2", "value2"));
-  user_data.push_back(
-      storage::mojom::ServiceWorkerUserData::New("prefixB", "value3"));
-  user_data.push_back(
-      storage::mojom::ServiceWorkerUserData::New("prefixC", "value4"));
+  user_data.push_back(storage::mojom::ServiceWorkerUserData::New(
+      registration_id, "prefixA", "value1"));
+  user_data.push_back(storage::mojom::ServiceWorkerUserData::New(
+      registration_id, "prefixA2", "value2"));
+  user_data.push_back(storage::mojom::ServiceWorkerUserData::New(
+      registration_id, "prefixB", "value3"));
+  user_data.push_back(storage::mojom::ServiceWorkerUserData::New(
+      registration_id, "prefixC", "value4"));
   status =
       StoreUserData(registration_id, kScope.GetOrigin(), std::move(user_data));
   ASSERT_EQ(status, DatabaseStatus::kOk);
@@ -1340,11 +1341,11 @@ TEST_F(ServiceWorkerStorageControlImplTest,
   {
     std::vector<storage::mojom::ServiceWorkerUserDataPtr> user_data;
     user_data.push_back(storage::mojom::ServiceWorkerUserData::New(
-        "key1", "registration1_value1"));
+        registration_id1, "key1", "registration1_value1"));
     user_data.push_back(storage::mojom::ServiceWorkerUserData::New(
-        "key2", "registration1_value2"));
+        registration_id1, "key2", "registration1_value2"));
     user_data.push_back(storage::mojom::ServiceWorkerUserData::New(
-        "prefix1", "registration1_prefix_value1"));
+        registration_id1, "prefix1", "registration1_prefix_value1"));
     status = StoreUserData(registration_id1, kScope1.GetOrigin(),
                            std::move(user_data));
     ASSERT_EQ(status, DatabaseStatus::kOk);
@@ -1352,11 +1353,11 @@ TEST_F(ServiceWorkerStorageControlImplTest,
   {
     std::vector<storage::mojom::ServiceWorkerUserDataPtr> user_data;
     user_data.push_back(storage::mojom::ServiceWorkerUserData::New(
-        "key1", "registration2_value1"));
+        registration_id1, "key1", "registration2_value1"));
     user_data.push_back(storage::mojom::ServiceWorkerUserData::New(
-        "key3", "registration2_value3"));
+        registration_id1, "key3", "registration2_value3"));
     user_data.push_back(storage::mojom::ServiceWorkerUserData::New(
-        "prefix2", "registration2_prefix_value2"));
+        registration_id1, "prefix2", "registration2_prefix_value2"));
     status = StoreUserData(registration_id2, kScope2.GetOrigin(),
                            std::move(user_data));
     ASSERT_EQ(status, DatabaseStatus::kOk);
@@ -1367,19 +1368,23 @@ TEST_F(ServiceWorkerStorageControlImplTest,
   result = GetUserDataForAllRegistrations("key1");
   ASSERT_EQ(result.status, DatabaseStatus::kOk);
   ASSERT_EQ(result.values.size(), 2UL);
-  EXPECT_EQ(result.values[registration_id1], "registration1_value1");
-  EXPECT_EQ(result.values[registration_id2], "registration2_value1");
+  EXPECT_EQ(result.values[0]->registration_id, registration_id1);
+  EXPECT_EQ(result.values[0]->value, "registration1_value1");
+  EXPECT_EQ(result.values[1]->registration_id, registration_id2);
+  EXPECT_EQ(result.values[1]->value, "registration2_value1");
 
   // Get uncommon user data.
   result = GetUserDataForAllRegistrations("key2");
   ASSERT_EQ(result.status, DatabaseStatus::kOk);
   ASSERT_EQ(result.values.size(), 1UL);
-  EXPECT_EQ(result.values[registration_id1], "registration1_value2");
+  EXPECT_EQ(result.values[0]->registration_id, registration_id1);
+  EXPECT_EQ(result.values[0]->value, "registration1_value2");
 
   result = GetUserDataForAllRegistrations("key3");
   ASSERT_EQ(result.status, DatabaseStatus::kOk);
   ASSERT_EQ(result.values.size(), 1UL);
-  EXPECT_EQ(result.values[registration_id2], "registration2_value3");
+  EXPECT_EQ(result.values[0]->registration_id, registration_id2);
+  EXPECT_EQ(result.values[0]->value, "registration2_value3");
 
   // Getting unknown key succeeds but returns an empty value.
   // TODO(bashi): Make sure this is an intentional behavior. The existing
@@ -1395,14 +1400,17 @@ TEST_F(ServiceWorkerStorageControlImplTest,
   result = GetUserDataForAllRegistrations("key1");
   ASSERT_EQ(result.status, DatabaseStatus::kOk);
   ASSERT_EQ(result.values.size(), 1UL);
-  EXPECT_EQ(result.values[registration_id2], "registration2_value1");
+  EXPECT_EQ(result.values[0]->registration_id, registration_id2);
+  EXPECT_EQ(result.values[0]->value, "registration2_value1");
 
   // Get prefixed user data.
   result = GetUserDataForAllRegistrationsByKeyPrefix("prefix");
   ASSERT_EQ(result.status, DatabaseStatus::kOk);
   ASSERT_EQ(result.values.size(), 2UL);
-  EXPECT_EQ(result.values[registration_id1], "registration1_prefix_value1");
-  EXPECT_EQ(result.values[registration_id2], "registration2_prefix_value2");
+  EXPECT_EQ(result.values[0]->registration_id, registration_id1);
+  EXPECT_EQ(result.values[0]->value, "registration1_prefix_value1");
+  EXPECT_EQ(result.values[1]->registration_id, registration_id2);
+  EXPECT_EQ(result.values[1]->value, "registration2_prefix_value2");
 
   // Clear prefixed user data.
   status = ClearUserDataForAllRegistrationsByKeyPrefix("prefix");