[Offline pages] Applying StoreState to track RequestQueueStore state

components/offline_pages/background/request_queue_store_sql.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/offline_pages/background/request_queue_store_sql.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/offline_pages/background/save_page_request.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 
 namespace offline_pages {
 
 template class StoreUpdateResult<SavePageRequest>;
 
 namespace {
 
 using UpdateStatus = RequestQueueStore::UpdateStatus;
+using StoreStateCallback = base::Callback<void(StoreState)>;
 
 // This is a macro instead of a const so that
 // it can be used inline in other SQL statements below.
 #define REQUEST_QUEUE_TABLE_NAME "request_queue_v1"
 const bool kUserRequested = true;
 
 bool CreateRequestQueueTable(sql::Connection* db) {
   const char kSql[] = "CREATE TABLE IF NOT EXISTS " REQUEST_QUEUE_TABLE_NAME
                       " (request_id INTEGER PRIMARY KEY NOT NULL,"
                       " creation_time INTEGER NOT NULL,"
@@ skipping 359 matching lines @@
   // TODO(fgorski): add UMA metrics here.
   offline_pages::ChangeRequestsState(db, request_ids, new_state, results,
                                      requests);
   runner->PostTask(FROM_HERE,
                    base::Bind(callback, results, base::Passed(&requests)));
 }
 
 void OpenConnectionSync(sql::Connection* db,
                         scoped_refptr<base::SingleThreadTaskRunner> runner,
                         const base::FilePath& path,
-                        const base::Callback<void(bool)>& callback) {
-  bool success = InitDatabase(db, path);
-  runner->PostTask(FROM_HERE, base::Bind(callback, success));
+                        const StoreStateCallback& callback) {
+  StoreState state =
+      InitDatabase(db, path) ? StoreState::LOADED : StoreState::FAILED_LOADING;
+  runner->PostTask(FROM_HERE, base::Bind(callback, state));
 }
 
 void ResetSync(sql::Connection* db,
                const base::FilePath& db_file_path,
                scoped_refptr<base::SingleThreadTaskRunner> runner,
-               const RequestQueueStore::ResetCallback& callback) {
+               const StoreStateCallback& callback) {
   // This method deletes the content of the whole store and reinitializes it.
   bool success = db->Raze();
   db->Close();
-  if (success)
-    success = InitDatabase(db, db_file_path);
-  runner->PostTask(FROM_HERE, base::Bind(callback, success));
+  StoreState state;
+  if (!success)
+    state = StoreState::FAILED_RESET;
+  if (InitDatabase(db, db_file_path))
+    state = StoreState::LOADED;
+  else
+    state = StoreState::FAILED_LOADING;
+
+  runner->PostTask(FROM_HERE, base::Bind(callback, state));
 }
 
 }  // anonymous namespace
 
 RequestQueueStoreSQL::RequestQueueStoreSQL(
     scoped_refptr<base::SequencedTaskRunner> background_task_runner,
     const base::FilePath& path)
     : background_task_runner_(std::move(background_task_runner)),
       db_file_path_(path.AppendASCII("RequestQueue.db")),
       weak_ptr_factory_(this) {
@@ skipping 108 matching lines @@
   DCHECK(!db_);
   db_.reset(new sql::Connection());
   background_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&OpenConnectionSync, db_.get(),
                  base::ThreadTaskRunnerHandle::Get(), db_file_path_,
                  base::Bind(&RequestQueueStoreSQL::OnOpenConnectionDone,
                             weak_ptr_factory_.GetWeakPtr())));
 }
 
-void RequestQueueStoreSQL::OnOpenConnectionDone(bool success) {
+void RequestQueueStoreSQL::OnOpenConnectionDone(StoreState state) {
   DCHECK(db_.get());
 
+  state_ = state;
+
   // Unfortunately we were not able to open DB connection.
-  if (!success)
+  if (state_ != StoreState::LOADED)
     db_.reset();
 }
 
 void RequestQueueStoreSQL::OnResetDone(const ResetCallback& callback,
-                                       bool success) {
+                                       StoreState state) {
   // Complete connection initialization post reset.
-  OnOpenConnectionDone(success);
-  callback.Run(success);
+  OnOpenConnectionDone(state);
+  callback.Run(state == StoreState::LOADED);
+}
+
+StoreState RequestQueueStoreSQL::state() const {
+  return state_;
 }
 
 }  // namespace offline_pages