NTPSnippetsDatabase: support multiple concurrent loads

components/ntp_snippets/ntp_snippets_database.cc

 // Copyright 2016 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 "components/ntp_snippets/ntp_snippets_database.h"
 
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "components/leveldb_proto/proto_database_impl.h"
@@ skipping 19 matching lines @@
       database_initialized_(false),
       weak_ptr_factory_(this) {
   database_->Init(kDatabaseUMAClientName, database_dir,
                   base::Bind(&NTPSnippetsDatabase::OnDatabaseInited,
                              weak_ptr_factory_.GetWeakPtr()));
 }
 
 NTPSnippetsDatabase::~NTPSnippetsDatabase() {}
 
 void NTPSnippetsDatabase::Load(const SnippetsLoadedCallback& callback) {
-  DCHECK(callback_.is_null());
-  DCHECK(!callback.is_null());
-  callback_ = callback;
   if (database_ && database_initialized_)
-    LoadImpl();
+    LoadImpl(callback);
+  else
+    pending_load_callbacks_.emplace_back(callback);
 }
 
 void NTPSnippetsDatabase::Save(const NTPSnippet& snippet) {
   std::unique_ptr<KeyEntryVector> entries_to_save(new KeyEntryVector());
   entries_to_save->emplace_back(snippet.id(), snippet.ToProto());
   SaveImpl(std::move(entries_to_save));
 }
 
 void NTPSnippetsDatabase::Save(const NTPSnippet::PtrVector& snippets) {
   std::unique_ptr<KeyEntryVector> entries_to_save(new KeyEntryVector());
@@ skipping 15 matching lines @@
 }
 
 void NTPSnippetsDatabase::OnDatabaseInited(bool success) {
   DCHECK(!database_initialized_);
   if (!success) {
     DVLOG(1) << "NTPSnippetsDatabase init failed.";
     database_.reset();
     return;
   }
   database_initialized_ = true;
-  if (!callback_.is_null())
-    LoadImpl();
+  for (const SnippetsLoadedCallback& callback : pending_load_callbacks_)
+    LoadImpl(callback);
 }
 
 void NTPSnippetsDatabase::OnDatabaseLoaded(
+    const SnippetsLoadedCallback& callback,
     bool success,
     std::unique_ptr<std::vector<SnippetProto>> entries) {
   if (!success) {
     DVLOG(1) << "NTPSnippetsDatabase load failed.";
     database_.reset();
     return;
   }
 
   std::unique_ptr<std::vector<std::string>> keys_to_remove(
       new std::vector<std::string>());
 
   NTPSnippet::PtrVector snippets;
   for (const SnippetProto& proto : *entries) {
     std::unique_ptr<NTPSnippet> snippet = NTPSnippet::CreateFromProto(proto);
     if (snippet) {
       snippets.emplace_back(std::move(snippet));
     } else {
       LOG(WARNING) << "Invalid proto from DB " << proto.id();
       keys_to_remove->emplace_back(proto.id());
     }
   }
 
-  // We only start loading if we have a non-null callback, but it's possible
-  // that it's been cleared in the meantime.
-  DCHECK(!callback_.is_null());
-  callback_.Run(std::move(snippets));
-  callback_.Reset();
+  callback.Run(std::move(snippets));
 
   // If any of the snippet protos couldn't be converted to actual snippets,
   // clean them up now.
   if (!keys_to_remove->empty())
     DeleteImpl(std::move(keys_to_remove));
 }
 
 void NTPSnippetsDatabase::OnDatabaseSaved(bool success) {
   if (!success) {
     DVLOG(1) << "NTPSnippetsDatabase save failed.";
     database_.reset();
   }
 }
 
-void NTPSnippetsDatabase::LoadImpl() {
+void NTPSnippetsDatabase::LoadImpl(const SnippetsLoadedCallback& callback) {
   DCHECK(database_);
   DCHECK(database_initialized_);
   database_->LoadEntries(base::Bind(&NTPSnippetsDatabase::OnDatabaseLoaded,
-                                    weak_ptr_factory_.GetWeakPtr()));
+                                    weak_ptr_factory_.GetWeakPtr(),
+                                    callback));
 }
 
 void NTPSnippetsDatabase::SaveImpl(
     std::unique_ptr<KeyEntryVector> entries_to_save) {
   if (!database_ || !database_initialized_)
     return;
 
   std::unique_ptr<std::vector<std::string>> keys_to_remove(
       new std::vector<std::string>());
   database_->UpdateEntries(std::move(entries_to_save),
                            std::move(keys_to_remove),
                            base::Bind(&NTPSnippetsDatabase::OnDatabaseSaved,
                                       weak_ptr_factory_.GetWeakPtr()));
 }
 
 void NTPSnippetsDatabase::DeleteImpl(
     std::unique_ptr<std::vector<std::string>> keys_to_remove) {
   if (!database_ || !database_initialized_)
     return;
 
   std::unique_ptr<KeyEntryVector> entries_to_save(new KeyEntryVector());
   database_->UpdateEntries(std::move(entries_to_save),
                            std::move(keys_to_remove),
                            base::Bind(&NTPSnippetsDatabase::OnDatabaseSaved,
                                       weak_ptr_factory_.GetWeakPtr()));
 }
 
 }  // namespace ntp_snippets