Extended the ProtoDatabase to provide LoadKeys() functionality.

components/leveldb_proto/testing/fake_db.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_TESTING_FAKE_DB_H_
 #define COMPONENTS_LEVELDB_PROTO_TESTING_FAKE_DB_H_
 
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 21 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<std::vector<std::string>> 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;
 
   base::FilePath& GetDirectory();
 
   void InitCallback(bool success);
 
   void LoadCallback(bool success);
 
+  void LoadKeysCallback(bool success);
+
   void GetCallback(bool success);
 
   void UpdateCallback(bool success);
 
   static base::FilePath DirectoryForTestDB();
 
  private:
   static void RunLoadCallback(
       const typename ProtoDatabase<T>::LoadCallback& callback,
       std::unique_ptr<typename std::vector<T>> entries,
       bool success);
 
+  static void RunLoadKeysCallback(
+      const typename ProtoDatabase<T>::LoadKeysCallback& callback,
+      std::unique_ptr<std::vector<std::string>> keys,
+      bool success);
+
   static void RunGetCallback(
       const typename ProtoDatabase<T>::GetCallback& callback,
       std::unique_ptr<T> entry,
       bool success);
 
   base::FilePath dir_;
   EntryMap* db_;
 
   Callback init_callback_;
   Callback load_callback_;
+  Callback load_keys_callback_;
   Callback get_callback_;
   Callback update_callback_;
 };
 
 template <typename T>
 FakeDB<T>::FakeDB(EntryMap* db)
     : db_(db) {}
 
 template <typename T>
 FakeDB<T>::~FakeDB() {}
@@ skipping 25 matching lines @@
     const typename ProtoDatabase<T>::LoadCallback& callback) {
   std::unique_ptr<std::vector<T>> entries(new std::vector<T>());
   for (const auto& pair : *db_)
     entries->push_back(pair.second);
 
   load_callback_ =
       base::Bind(RunLoadCallback, callback, base::Passed(&entries));
 }
 
 template <typename T>
+void FakeDB<T>::LoadKeys(
+    const typename ProtoDatabase<T>::LoadKeysCallback& callback) {
+  std::unique_ptr<std::vector<std::string>> keys(
+      new std::vector<std::string>());
+  for (const auto& pair : *db_)
+    keys->push_back(pair.first);
+
+  load_keys_callback_ =
+      base::Bind(RunLoadKeysCallback, callback, base::Passed(&keys));
+}
+
+template <typename T>
 void FakeDB<T>::GetEntry(
     const std::string& key,
     const typename ProtoDatabase<T>::GetCallback& callback) {
   std::unique_ptr<T> entry;
   auto it = db_->find(key);
   if (it != db_->end())
     entry.reset(new T(it->second));
 
   get_callback_ = base::Bind(RunGetCallback, callback, base::Passed(&entry));
 }
@@ skipping 14 matching lines @@
   init_callback_.Reset();
 }
 
 template <typename T>
 void FakeDB<T>::LoadCallback(bool success) {
   load_callback_.Run(success);
   load_callback_.Reset();
 }
 
 template <typename T>
+void FakeDB<T>::LoadKeysCallback(bool success) {
+  load_keys_callback_.Run(success);
+  load_keys_callback_.Reset();
+}
+
+template <typename T>
 void FakeDB<T>::GetCallback(bool success) {
   get_callback_.Run(success);
   get_callback_.Reset();
 }
 
 template <typename T>
 void FakeDB<T>::UpdateCallback(bool success) {
   update_callback_.Run(success);
   update_callback_.Reset();
 }
 
 // static
 template <typename T>
 void FakeDB<T>::RunLoadCallback(
     const typename ProtoDatabase<T>::LoadCallback& callback,
     std::unique_ptr<typename std::vector<T>> entries,
     bool success) {
   callback.Run(success, std::move(entries));
 }
 
 // static
 template <typename T>
+void FakeDB<T>::RunLoadKeysCallback(
+    const typename ProtoDatabase<T>::LoadKeysCallback& callback,
+    std::unique_ptr<std::vector<std::string>> keys,
+    bool success) {
+  callback.Run(success, std::move(keys));
+}
+
+// static
+template <typename T>
 void FakeDB<T>::RunGetCallback(
     const typename ProtoDatabase<T>::GetCallback& callback,
     std::unique_ptr<T> entry,
     bool success) {
   callback.Run(success, std::move(entry));
 }
 
 // static
 template <typename T>
 base::FilePath FakeDB<T>::DirectoryForTestDB() {
   return base::FilePath(FILE_PATH_LITERAL("/fake/path"));
 }
 
 }  // namespace test
 }  // namespace leveldb_proto
 
 #endif  // COMPONENTS_LEVELDB_PROTO_TESTING_FAKE_DB_H_