Make Service Worker DB UserData methods accept multiple keys at once

content/browser/service_worker/service_worker_database.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 <utility>
 
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
@@ skipping 785 matching lines @@
         return status;
       break;
     }
   }
 
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadUserData(
     int64_t registration_id,
-    const std::string& user_data_name,
-    std::string* user_data) {
+    const std::vector<std::string>& user_data_names,
+    std::vector<std::string>* user_data_values) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK_NE(kInvalidServiceWorkerRegistrationId, registration_id);
-  DCHECK(!user_data_name.empty());
-  DCHECK(user_data);
+  DCHECK(!user_data_names.empty());
+  DCHECK(user_data_values);
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_ERROR_NOT_FOUND;
   if (status != STATUS_OK)
     return status;
 
-  const std::string key = CreateUserDataKey(registration_id, user_data_name);
-  status = LevelDBStatusToStatus(
-      db_->Get(leveldb::ReadOptions(), key, user_data));
+  user_data_values->resize(user_data_names.size());
+  for (size_t i = 0; i < user_data_names.size(); i++) {
+    const std::string key =
+        CreateUserDataKey(registration_id, user_data_names[i]);
+    status = LevelDBStatusToStatus(
+        db_->Get(leveldb::ReadOptions(), key, &(*user_data_values)[i]));
+    if (status != STATUS_OK) {
+      user_data_values->clear();
+      break;
+    }
+  }
   HandleReadResult(FROM_HERE,
                    status == STATUS_ERROR_NOT_FOUND ? STATUS_OK : status);
   return status;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteUserData(
     int64_t registration_id,
     const GURL& origin,
-    const std::string& user_data_name,
-    const std::string& user_data) {
+    const std::vector<std::pair<std::string, std::string>>& name_value_pairs) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK_NE(kInvalidServiceWorkerRegistrationId, registration_id);
-  DCHECK(!user_data_name.empty());
+  DCHECK(!name_value_pairs.empty());
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_ERROR_NOT_FOUND;
   if (status != STATUS_OK)
     return status;
 
   // There should be the registration specified by |registration_id|.
   RegistrationData registration;
   status = ReadRegistrationData(registration_id, origin, &registration);
   if (status != STATUS_OK)
     return status;
 
   leveldb::WriteBatch batch;
-  batch.Put(CreateUserDataKey(registration_id, user_data_name), user_data);
-  batch.Put(CreateHasUserDataKey(registration_id, user_data_name), "");
+  for (const auto& pair : name_value_pairs) {
+    DCHECK(!pair.first.empty());
+    batch.Put(CreateUserDataKey(registration_id, pair.first), pair.second);
+    batch.Put(CreateHasUserDataKey(registration_id, pair.first), "");
+  }
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteUserData(
     int64_t registration_id,
-    const std::string& user_data_name) {
+    const std::vector<std::string>& user_data_names) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK_NE(kInvalidServiceWorkerRegistrationId, registration_id);
-  DCHECK(!user_data_name.empty());
+  DCHECK(!user_data_names.empty());
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   leveldb::WriteBatch batch;
-  batch.Delete(CreateUserDataKey(registration_id, user_data_name));
-  batch.Delete(CreateHasUserDataKey(registration_id, user_data_name));
+  for (const std::string& name : user_data_names) {
+    DCHECK(!name.empty());
+    batch.Delete(CreateUserDataKey(registration_id, name));
+    batch.Delete(CreateHasUserDataKey(registration_id, name));
+  }
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status
 ServiceWorkerDatabase::ReadUserDataForAllRegistrations(
     const std::string& user_data_name,
     std::vector<std::pair<int64_t, std::string>>* user_data) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(user_data->empty());
 
@@ skipping 729 matching lines @@
   if (status != STATUS_OK)
     Disable(from_here, status);
   ServiceWorkerMetrics::CountWriteDatabaseResult(status);
 }
 
 bool ServiceWorkerDatabase::IsDatabaseInMemory() const {
   return path_.empty();
 }
 
 }  // namespace content