Implement ProtoDatabase::GetEntry

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 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,
       const typename ProtoDatabase<T>::InitCallback& callback);
 
  private:
@@ skipping 24 matching lines @@
 }
 
 template <typename T>
 void RunLoadCallback(const typename ProtoDatabase<T>::LoadCallback& callback,
                      const bool* success,
                      std::unique_ptr<std::vector<T>> entries) {
   callback.Run(*success, std::move(entries));
 }
 
 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,
     const bool* success) {
   callback.Run(*success);
 }
 
 inline void InitFromTaskRunner(LevelDB* database,
                                const base::FilePath& database_dir,
                                bool* success) {
   DCHECK(success);
@@ skipping 43 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);
   }
 }
 
+template <typename T>
+void GetEntryFromTaskRunner(LevelDB* database,
+                            const std::string& key,
+                            T* entry,
+                            bool* found,
+                            bool* success) {
+  DCHECK(success);
+  DCHECK(found);
+  DCHECK(entry);
+
+  std::string serialized_entry;
+  *success = database->Get(key, found, &serialized_entry);
+
+  if (success && !entry->ParseFromString(serialized_entry)) {
+    *found = false;
+    DLOG(WARNING) << "Unable to parse leveldb_proto entry";
+    // TODO(cjhopman): Decide what to do about un-parseable entries.
+  }
+}
+
 }  // namespace
 
 template <typename T>
 ProtoDatabaseImpl<T>::ProtoDatabaseImpl(
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
     : task_runner_(task_runner) {}
 
 template <typename T>
 ProtoDatabaseImpl<T>::~ProtoDatabaseImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 74 matching lines @@
   // Get this pointer before entries is base::Passed() so we can use it below.
   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>::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_