[Offline pages] Moving static private methods from RQStoreSQL interface

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"
@@ skipping 42 matching lines @@
 
   if (!CreateRequestQueueTable(db))
     return false;
 
   // TODO(fgorski): Add indices here.
   return true;
 }
 
 // Create a save page request from a SQL result.  Expects complete rows with
 // all columns present.  Columns are in order they are defined in select query
-// in |RequestQueueStore::RequestSync| method.
+// in |GetOneRequest| method.
 std::unique_ptr<SavePageRequest> MakeSavePageRequest(
     const sql::Statement& statement) {
   const int64_t id = statement.ColumnInt64(0);
   const base::Time creation_time =
       base::Time::FromInternalValue(statement.ColumnInt64(1));
   const base::Time activation_time =
       base::Time::FromInternalValue(statement.ColumnInt64(2));
   const base::Time last_attempt_time =
       base::Time::FromInternalValue(statement.ColumnInt64(3));
   const int64_t started_attempt_count = statement.ColumnInt64(4);
@@ skipping 181 matching lines @@
   base::File::Error err;
   if (!base::CreateDirectoryAndGetError(path.DirName(), &err))
     return false;
   if (!db->Open(path))
     return false;
   db->Preload();
 
   return CreateSchema(db);
 }
 
-}  // 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) {
-  OpenConnection();
-}
-
-RequestQueueStoreSQL::~RequestQueueStoreSQL() {
-  if (db_.get())
-    background_task_runner_->DeleteSoon(FROM_HERE, db_.release());
-}
-
-// static
-void RequestQueueStoreSQL::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));
-}
-
-// static
-void RequestQueueStoreSQL::GetRequestsSync(
-    sql::Connection* db,
-    scoped_refptr<base::SingleThreadTaskRunner> runner,
-    const GetRequestsCallback& callback) {
+void GetRequestsSync(sql::Connection* db,
+                     scoped_refptr<base::SingleThreadTaskRunner> runner,
+                     const RequestQueueStore::GetRequestsCallback& callback) {
   const char kSql[] =
       "SELECT request_id, creation_time, activation_time,"
       " last_attempt_time, started_attempt_count, completed_attempt_count,"
       " state, url, client_namespace, client_id"
       " FROM " REQUEST_QUEUE_TABLE_NAME;
 
   sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql));
 
   std::vector<std::unique_ptr<SavePageRequest>> requests;
   while (statement.Step())
     requests.push_back(MakeSavePageRequest(statement));
 
   runner->PostTask(FROM_HERE, base::Bind(callback, statement.Succeeded(),
                                          base::Passed(&requests)));
 }
 
-// static
-void RequestQueueStoreSQL::AddOrUpdateRequestSync(
-    sql::Connection* db,
-    scoped_refptr<base::SingleThreadTaskRunner> runner,
-    const SavePageRequest& request,
-    const UpdateCallback& callback) {
+void AddOrUpdateRequestSync(sql::Connection* db,
+                            scoped_refptr<base::SingleThreadTaskRunner> runner,
+                            const SavePageRequest& request,
+                            const RequestQueueStore::UpdateCallback& callback) {
   // TODO(fgorski): add UMA metrics here.
   RequestQueueStore::UpdateStatus status = InsertOrReplace(db, request);
   runner->PostTask(FROM_HERE, base::Bind(callback, status));
 }
 
-// static
-void RequestQueueStoreSQL::RemoveRequestsSync(
-    sql::Connection* db,
-    scoped_refptr<base::SingleThreadTaskRunner> runner,
-    const std::vector<int64_t>& request_ids,
-    const RemoveCallback& callback) {
+void RemoveRequestsSync(sql::Connection* db,
+                        scoped_refptr<base::SingleThreadTaskRunner> runner,
+                        const std::vector<int64_t>& request_ids,
+                        const RequestQueueStore::RemoveCallback& callback) {
   RequestQueue::UpdateMultipleRequestResults results;
   std::vector<std::unique_ptr<SavePageRequest>> requests;
   // TODO(fgorski): add UMA metrics here.
   DeleteRequestsByIds(db, request_ids, results, &requests);
   runner->PostTask(FROM_HERE,
                    base::Bind(callback, results, base::Passed(&requests)));
 }
 
-// static
-void RequestQueueStoreSQL::ChangeRequestsStateSync(
+void ChangeRequestsStateSync(
     sql::Connection* db,
     scoped_refptr<base::SingleThreadTaskRunner> runner,
     const std::vector<int64_t>& request_ids,
     const SavePageRequest::RequestState new_state,
-    const UpdateMultipleRequestsCallback& callback) {
+    const RequestQueue::UpdateMultipleRequestsCallback& callback) {
   RequestQueue::UpdateMultipleRequestResults results;
   std::vector<std::unique_ptr<SavePageRequest>> requests;
   // 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)));
 }
 
-// static
-void RequestQueueStoreSQL::ResetSync(
-    sql::Connection* db,
-    const base::FilePath& db_file_path,
-    scoped_refptr<base::SingleThreadTaskRunner> runner,
-    const ResetCallback& callback) {
+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));
+}
+
+void ResetSync(sql::Connection* db,
+               const base::FilePath& db_file_path,
+               scoped_refptr<base::SingleThreadTaskRunner> runner,
+               const RequestQueueStore::ResetCallback& 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));
 }
 
+}  // 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) {
+  OpenConnection();
+}
+
+RequestQueueStoreSQL::~RequestQueueStoreSQL() {
+  if (db_.get())
+    background_task_runner_->DeleteSoon(FROM_HERE, db_.release());
+}
+
 bool RequestQueueStoreSQL::CheckDb(const base::Closure& callback) {
   DCHECK(db_.get());
   if (!db_.get()) {
     // Nothing to do, but post a callback instead of calling directly
     // to preserve the async style behavior to prevent bugs.
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback));
     return false;
   }
   return true;
 }
 
 void RequestQueueStoreSQL::GetRequests(const GetRequestsCallback& callback) {
   DCHECK(db_.get());
   std::vector<std::unique_ptr<SavePageRequest>> requests;
   if (!CheckDb(base::Bind(callback, false, base::Passed(&requests))))
     return;
 
   background_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&RequestQueueStoreSQL::GetRequestsSync, db_.get(),
+      FROM_HERE, base::Bind(&GetRequestsSync, db_.get(),
                             base::ThreadTaskRunnerHandle::Get(), callback));
 }
 
 void RequestQueueStoreSQL::AddOrUpdateRequest(const SavePageRequest& request,
                                               const UpdateCallback& callback) {
   DCHECK(db_.get());
   if (!CheckDb(base::Bind(callback, UpdateStatus::FAILED)))
     return;
 
   background_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RequestQueueStoreSQL::AddOrUpdateRequestSync, db_.get(),
+      base::Bind(&AddOrUpdateRequestSync, db_.get(),
                  base::ThreadTaskRunnerHandle::Get(), request, callback));
 }
 
 // RemoveRequestsByRequestId to be more parallell with RemoveRequestsByClientId.
 void RequestQueueStoreSQL::RemoveRequests(
     const std::vector<int64_t>& request_ids,
     const RemoveCallback& callback) {
   // Set up a failed set of results in case we fail the DB check.
   RequestQueue::UpdateMultipleRequestResults results;
   for (int64_t request_id : request_ids) {
     results.push_back(std::make_pair(
         request_id, RequestQueue::UpdateRequestResult::STORE_FAILURE));
   }
 
   if (!CheckDb(base::Bind(
           callback, results,
           base::Passed(std::vector<std::unique_ptr<SavePageRequest>>())))) {
     return;
   }
 
   background_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RequestQueueStoreSQL::RemoveRequestsSync, db_.get(),
+      base::Bind(&RemoveRequestsSync, db_.get(),
                  base::ThreadTaskRunnerHandle::Get(), request_ids, callback));
 }
 
 void RequestQueueStoreSQL::ChangeRequestsState(
     const std::vector<int64_t>& request_ids,
     const SavePageRequest::RequestState new_state,
     const UpdateMultipleRequestsCallback& callback) {
   RequestQueue::UpdateMultipleRequestResults results;
   std::vector<std::unique_ptr<SavePageRequest>> requests;
   if (!CheckDb(base::Bind(callback, results, base::Passed(&requests)))) {
     return;
   }
 
   background_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&RequestQueueStoreSQL::ChangeRequestsStateSync,
-                            db_.get(), base::ThreadTaskRunnerHandle::Get(),
-                            request_ids, new_state, callback));
+      FROM_HERE, base::Bind(&ChangeRequestsStateSync, db_.get(),
+                            base::ThreadTaskRunnerHandle::Get(), request_ids,
+                            new_state, callback));
 }
 
 void RequestQueueStoreSQL::Reset(const ResetCallback& callback) {
   DCHECK(db_.get());
   if (!CheckDb(base::Bind(callback, false)))
     return;
 
   background_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RequestQueueStoreSQL::ResetSync, db_.get(), db_file_path_,
+      base::Bind(&ResetSync, db_.get(), db_file_path_,
                  base::ThreadTaskRunnerHandle::Get(),
                  base::Bind(&RequestQueueStoreSQL::OnResetDone,
                             weak_ptr_factory_.GetWeakPtr(), callback)));
 }
 
 void RequestQueueStoreSQL::OpenConnection() {
   DCHECK(!db_);
   db_.reset(new sql::Connection());
   background_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RequestQueueStoreSQL::OpenConnectionSync, db_.get(),
+      base::Bind(&OpenConnectionSync, db_.get(),
                  base::ThreadTaskRunnerHandle::Get(), db_file_path_,
                  base::Bind(&RequestQueueStoreSQL::OnOpenConnectionDone,
                             weak_ptr_factory_.GetWeakPtr())));
 }
 
 void RequestQueueStoreSQL::OnOpenConnectionDone(bool success) {
   DCHECK(db_.get());
 
   // Unfortunately we were not able to open DB connection.
   if (!success)
     db_.reset();
 }
 
 void RequestQueueStoreSQL::OnResetDone(const ResetCallback& callback,
                                        bool success) {
   // Complete connection initialization post reset.
   OnOpenConnectionDone(success);
   callback.Run(success);
 }
 
 }  // namespace offline_pages