[NTP Snippets] Shut down the service on database failure

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 32 matching lines @@
 
   base::FilePath image_dir = database_dir.AppendASCII(kImageDatabaseFolder);
   image_database_->Init(kImageDatabaseUMAClientName, image_dir,
                         base::Bind(&NTPSnippetsDatabase::OnImageDatabaseInited,
                                    weak_ptr_factory_.GetWeakPtr()));
 }
 
 NTPSnippetsDatabase::~NTPSnippetsDatabase() {}
 
 bool NTPSnippetsDatabase::IsInitialized() const {
-  return database_ && database_initialized_ && image_database_ &&
+  return !IsErrorState() && database_initialized_ &&
       image_database_initialized_;
 }
 
+bool NTPSnippetsDatabase::IsErrorState() const {
+  return !database_ || !image_database_;
+}
+
+void NTPSnippetsDatabase::SetErrorCallback(
+    const base::Closure& error_callback) {
+  error_callback_ = error_callback;
+}
+
 void NTPSnippetsDatabase::LoadSnippets(const SnippetsCallback& callback) {
   if (IsInitialized())
     LoadSnippetsImpl(callback);
   else
     pending_snippets_callbacks_.emplace_back(callback);
 }
 
 void NTPSnippetsDatabase::SaveSnippet(const NTPSnippet& snippet) {
   std::unique_ptr<KeyEntryVector> entries_to_save(new KeyEntryVector());
   entries_to_save->emplace_back(snippet.id(), snippet.ToProto());
@@ skipping 24 matching lines @@
 void NTPSnippetsDatabase::LoadImage(const std::string& snippet_id,
                                     const SnippetImageCallback& callback) {
   if (IsInitialized())
     LoadImageImpl(snippet_id, callback);
   else
     pending_image_callbacks_.emplace_back(snippet_id, callback);
 }
 
 void NTPSnippetsDatabase::SaveImage(const std::string& snippet_id,
                                     const std::string& image_data) {
-  // TODO(treib): After we pass errors to the client, DCHECK(IsInitialized()).
-  if (!IsInitialized())
-    return;
+  DCHECK(IsInitialized());
 
   SnippetImageProto image_proto;
   image_proto.set_data(image_data);
 
   std::unique_ptr<ImageKeyEntryVector> entries_to_save(
       new ImageKeyEntryVector());
   entries_to_save->emplace_back(snippet_id, std::move(image_proto));
 
   image_database_->UpdateEntries(
       std::move(entries_to_save),
       base::WrapUnique(new std::vector<std::string>()),
       base::Bind(&NTPSnippetsDatabase::OnImageDatabaseSaved,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void NTPSnippetsDatabase::DeleteImage(const std::string& snippet_id) {
   DeleteImagesImpl(
       base::WrapUnique(new std::vector<std::string>(1, snippet_id)));
 }
 
 void NTPSnippetsDatabase::OnDatabaseInited(bool success) {
   DCHECK(!database_initialized_);
   if (!success) {
     DVLOG(1) << "NTPSnippetsDatabase init failed.";
-    ResetDatabases();
+    OnDatabaseError();
     return;
   }
   database_initialized_ = true;
   if (IsInitialized())
     ProcessPendingLoads();
 }
 
 void NTPSnippetsDatabase::OnDatabaseLoaded(
     const SnippetsCallback& callback,
     bool success,
     std::unique_ptr<std::vector<SnippetProto>> entries) {
   if (!success) {
     DVLOG(1) << "NTPSnippetsDatabase load failed.";
-    ResetDatabases();
+    OnDatabaseError();
     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());
     }
   }
 
   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())
     DeleteSnippetsImpl(std::move(keys_to_remove));
 }
 
 void NTPSnippetsDatabase::OnDatabaseSaved(bool success) {
   if (!success) {
     DVLOG(1) << "NTPSnippetsDatabase save failed.";
-    ResetDatabases();
+    OnDatabaseError();
   }
 }
 
 void NTPSnippetsDatabase::OnImageDatabaseInited(bool success) {
   DCHECK(!image_database_initialized_);
   if (!success) {
     DVLOG(1) << "NTPSnippetsDatabase init failed.";
-    ResetDatabases();
+    OnDatabaseError();
     return;
   }
   image_database_initialized_ = true;
   if (IsInitialized())
     ProcessPendingLoads();
 }
 
 void NTPSnippetsDatabase::OnImageDatabaseLoaded(
     const SnippetImageCallback& callback,
     bool success,
     std::unique_ptr<SnippetImageProto> entry) {
   if (!success) {
     DVLOG(1) << "NTPSnippetsDatabase load failed.";
-    ResetDatabases();
+    OnDatabaseError();
     return;
   }
 
   if (!entry) {
     callback.Run(std::string());
     return;
   }
 
   std::unique_ptr<std::string> data(entry->release_data());
   callback.Run(std::move(*data));
 }
 
 void NTPSnippetsDatabase::OnImageDatabaseSaved(bool success) {
   if (!success) {
     DVLOG(1) << "NTPSnippetsDatabase save failed.";
-    ResetDatabases();
+    OnDatabaseError();
   }
 }
 
+void NTPSnippetsDatabase::OnDatabaseError() {
+  database_.reset();
+  image_database_.reset();
+  if (!error_callback_.is_null())
+    error_callback_.Run();
+}
+
 void NTPSnippetsDatabase::ProcessPendingLoads() {
   DCHECK(IsInitialized());
 
   for (const auto& callback : pending_snippets_callbacks_)
     LoadSnippetsImpl(callback);
   pending_snippets_callbacks_.clear();
 
   for (const auto& id_callback : pending_image_callbacks_)
     LoadImageImpl(id_callback.first, id_callback.second);
   pending_image_callbacks_.clear();
 }
 
 void NTPSnippetsDatabase::LoadSnippetsImpl(const SnippetsCallback& callback) {
   DCHECK(IsInitialized());
   database_->LoadEntries(base::Bind(&NTPSnippetsDatabase::OnDatabaseLoaded,
                                     weak_ptr_factory_.GetWeakPtr(),
                                     callback));
 }
 
 void NTPSnippetsDatabase::SaveSnippetsImpl(
     std::unique_ptr<KeyEntryVector> entries_to_save) {
-  // TODO(treib): After we pass errors to the client, DCHECK(IsInitialized()).
-  if (!IsInitialized())
-    return;
+  DCHECK(IsInitialized());
 
   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::DeleteSnippetsImpl(
     std::unique_ptr<std::vector<std::string>> keys_to_remove) {
-  // TODO(treib): After we pass errors to the client, DCHECK(IsInitialized()).
-  if (!IsInitialized())
-    return;
+  DCHECK(IsInitialized());
 
   DeleteImagesImpl(
       base::WrapUnique(new std::vector<std::string>(*keys_to_remove)));
 
   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()));
 }
 
 void NTPSnippetsDatabase::LoadImageImpl(const std::string& snippet_id,
                                         const SnippetImageCallback& callback) {
   DCHECK(IsInitialized());
   image_database_->GetEntry(
       snippet_id,
       base::Bind(&NTPSnippetsDatabase::OnImageDatabaseLoaded,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void NTPSnippetsDatabase::DeleteImagesImpl(
     std::unique_ptr<std::vector<std::string>> keys_to_remove) {
-  // TODO(treib): After we pass errors to the client, DCHECK(IsInitialized()).
-  if (!IsInitialized())
-    return;
+  DCHECK(IsInitialized());
 
   image_database_->UpdateEntries(
       base::WrapUnique(new ImageKeyEntryVector()),
       std::move(keys_to_remove),
       base::Bind(&NTPSnippetsDatabase::OnImageDatabaseSaved,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void NTPSnippetsDatabase::ResetDatabases() {
-  database_.reset();
-  image_database_.reset();
-}
-
 }  // namespace ntp_snippets