Extended the ProtoDatabase to provide LoadKeys() functionality.

components/leveldb_proto/proto_database_impl.h

 // 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.
 
 #ifndef COMPONENTS_LEVELDB_PROTO_PROTO_DATABASE_IMPL_H_
 #define COMPONENTS_LEVELDB_PROTO_PROTO_DATABASE_IMPL_H_
 
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 35 matching lines @@
   void Init(const char* client_name,
             const base::FilePath& database_dir,
             const typename ProtoDatabase<T>::InitCallback& callback) override;
   void UpdateEntries(
       std::unique_ptr<typename ProtoDatabase<T>::KeyEntryVector>
           entries_to_save,
       std::unique_ptr<KeyVector> keys_to_remove,
       const typename ProtoDatabase<T>::UpdateCallback& callback) override;
   void LoadEntries(
       const typename ProtoDatabase<T>::LoadCallback& callback) override;
+  void LoadKeys(
+      const typename ProtoDatabase<T>::LoadKeysCallback& callback) override;
   void GetEntry(
       const std::string& key,
       const typename ProtoDatabase<T>::GetCallback& callback) override;
   void Destroy(
       const typename ProtoDatabase<T>::DestroyCallback& callback) override;
 
   // Allow callers to provide their own Database implementation.
   void InitWithDatabase(
       std::unique_ptr<LevelDB> database,
       const base::FilePath& database_dir,
@@ skipping 21 matching lines @@
 
 template <typename T>
 void RunUpdateCallback(
     const typename ProtoDatabase<T>::UpdateCallback& callback,
     const bool* success) {
   callback.Run(*success);
 }
 
 template <typename T>
 void RunLoadCallback(const typename ProtoDatabase<T>::LoadCallback& callback,
-                     const bool* success,
+                     bool* success,
                      std::unique_ptr<std::vector<T>> entries) {
   callback.Run(*success, std::move(entries));
 }
 
 template <typename T>
+void RunLoadKeysCallback(
+    const typename ProtoDatabase<T>::LoadKeysCallback& callback,
+    std::unique_ptr<bool> success,
+    std::unique_ptr<std::vector<std::string>> keys) {
+  callback.Run(*success, std::move(keys));
+}
+
+template <typename T>
 void RunGetCallback(const typename ProtoDatabase<T>::GetCallback& callback,
                     const bool* success,
                     const bool* found,
                     std::unique_ptr<T> entry) {
   callback.Run(*success, *found ? std::move(entry) : nullptr);
 }
 
 template <typename T>
 void RunDestroyCallback(
     const typename ProtoDatabase<T>::DestroyCallback& callback,
@@ skipping 51 matching lines @@
     T entry;
     if (!entry.ParseFromString(serialized_entry)) {
       DLOG(WARNING) << "Unable to parse leveldb_proto entry";
       // TODO(cjhopman): Decide what to do about un-parseable entries.
     }
 
     entries->push_back(entry);
   }
 }
 
+void LoadKeysFromTaskRunner(LevelDB* database,
+                            std::vector<std::string>* keys,
+                            bool* success) {
+  DCHECK(success);
+  DCHECK(keys);
+  keys->clear();
+  *success = database->LoadKeys(keys);
+}
+
 template <typename T>
 void GetEntryFromTaskRunner(LevelDB* database,
                             const std::string& key,
                             T* entry,
                             bool* found,
                             bool* success) {
   DCHECK(success);
   DCHECK(found);
   DCHECK(entry);
 
@@ skipping 95 matching lines @@
   std::vector<T>* entries_ptr = entries.get();
 
   task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(LoadEntriesFromTaskRunner<T>,
                             base::Unretained(db_.get()), entries_ptr, success),
       base::Bind(RunLoadCallback<T>, callback, base::Owned(success),
                  base::Passed(&entries)));
 }
 
 template <typename T>
+void ProtoDatabaseImpl<T>::LoadKeys(
+    const typename ProtoDatabase<T>::LoadKeysCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  std::unique_ptr<bool> success(new bool(false));
+  std::unique_ptr<std::vector<std::string>> keys(
+      new std::vector<std::string>());

[nyquist, 2016/10/03 21:46:42]

Nit: Can these not use MakeUnique?

[tschumann, 2016/10/04 09:41:38]

Changed to not repeat the types anymore. I think it's cleaner now :-)

[nyquist, 2016/10/04 14:22:45]

Agreed. I think this looks very clean.

+  auto load_task =
+      base::Bind(LoadKeysFromTaskRunner, base::Unretained(db_.get()),
+                 keys.get(), success.get());
+  task_runner_->PostTaskAndReply(
+      FROM_HERE, load_task,
+      base::Bind(RunLoadKeysCallback<T>, callback, base::Passed(&success),
+                 base::Passed(&keys)));
+}
+
+template <typename T>
 void ProtoDatabaseImpl<T>::GetEntry(
     const std::string& key,
     const typename ProtoDatabase<T>::GetCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   bool* success = new bool(false);
   bool* found = new bool(false);
 
   std::unique_ptr<T> entry(new T());
   // Get this pointer before entry is base::Passed() so we can use it below.
   T* entry_ptr = entry.get();
 
   task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(GetEntryFromTaskRunner<T>, base::Unretained(db_.get()), key,
                  entry_ptr, found, success),
       base::Bind(RunGetCallback<T>, callback, base::Owned(success),
                  base::Owned(found), base::Passed(&entry)));
 }
 
 }  // namespace leveldb_proto
 
 #endif  // COMPONENTS_LEVELDB_PROTO_PROTO_DATABASE_IMPL_H_