[Offline pages] Removing static sync methods from Metadata SQL store's interface

components/offline_pages/offline_page_metadata_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/offline_page_metadata_store_sql.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
@@ skipping 281 matching lines @@
   if (statement.Succeeded()) {
     NotifyLoadResult(runner, callback, OfflinePageMetadataStore::LOAD_SUCCEEDED,
                      result);
   } else {
     result.clear();
     NotifyLoadResult(runner, callback,
                      OfflinePageMetadataStore::STORE_LOAD_FAILED, result);
   }
 }
 
+void AddOrUpdateOfflinePageSync(
+    const OfflinePageItem& offline_page,
+    sql::Connection* db,
+    scoped_refptr<base::SingleThreadTaskRunner> runner,
+    const OfflinePageMetadataStore::UpdateCallback& callback) {
+  // TODO(bburns): add UMA metrics here (and for levelDB).
+  bool ok = InsertOrReplace(db, offline_page);
+  runner->PostTask(FROM_HERE, base::Bind(callback, ok));
+}
+
+void RemoveOfflinePagesSync(
+    const std::vector<int64_t>& offline_ids,
+    sql::Connection* db,
+    scoped_refptr<base::SingleThreadTaskRunner> runner,
+    const OfflinePageMetadataStore::UpdateCallback& callback) {
+  // TODO(bburns): add UMA metrics here (and for levelDB).
+
+  // If you create a transaction but don't Commit() it is automatically
+  // rolled back by its destructor when it falls out of scope.
+  sql::Transaction transaction(db);
+  if (!transaction.Begin()) {
+    runner->PostTask(FROM_HERE, base::Bind(callback, false));
+    return;
+  }
+
+  for (auto offline_id : offline_ids) {
+    if (!DeleteByOfflineId(db, offline_id)) {
+      runner->PostTask(FROM_HERE, base::Bind(callback, false));
+      return;
+    }
+  }
+
+  bool success = transaction.Commit();
+  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 base::Callback<void(StoreState)>& callback) {
   // This method deletes the content of the whole store and reinitializes it.
   bool success = db->Raze();
   db->Close();
   StoreState state;
   if (success) {
     state = InitDatabase(db, db_file_path)
@@ skipping 17 matching lines @@
   OpenConnection();
 }
 
 OfflinePageMetadataStoreSQL::~OfflinePageMetadataStoreSQL() {
   if (db_.get() &&
       !background_task_runner_->DeleteSoon(FROM_HERE, db_.release())) {
     DLOG(WARNING) << "SQL database will not be deleted.";
   }
 }
 
-void OfflinePageMetadataStoreSQL::AddOrUpdateOfflinePageSync(
-    const OfflinePageItem& offline_page,
-    sql::Connection* db,
-    scoped_refptr<base::SingleThreadTaskRunner> runner,
-    const UpdateCallback& callback) {
-  // TODO(bburns): add UMA metrics here (and for levelDB).
-  bool ok = InsertOrReplace(db, offline_page);
-  runner->PostTask(FROM_HERE, base::Bind(callback, ok));
-}
-
-void OfflinePageMetadataStoreSQL::RemoveOfflinePagesSync(
-    const std::vector<int64_t>& offline_ids,
-    sql::Connection* db,
-    scoped_refptr<base::SingleThreadTaskRunner> runner,
-    const UpdateCallback& callback) {
-  // TODO(bburns): add UMA metrics here (and for levelDB).
-
-  // If you create a transaction but don't Commit() it is automatically
-  // rolled back by its destructor when it falls out of scope.
-  sql::Transaction transaction(db);
-  if (!transaction.Begin()) {
-    runner->PostTask(FROM_HERE, base::Bind(callback, false));
-    return;
-  }
-  for (auto offline_id : offline_ids) {
-    if (!DeleteByOfflineId(db, offline_id)) {
-      runner->PostTask(FROM_HERE, base::Bind(callback, false));
-      return;
-    }
-  }
-
-  bool success = transaction.Commit();
-  runner->PostTask(FROM_HERE, base::Bind(callback, success));
-}
-
 void OfflinePageMetadataStoreSQL::GetOfflinePages(
     const LoadCallback& callback) {
   background_task_runner_->PostTask(
       FROM_HERE, base::Bind(&GetOfflinePagesSync, db_.get(),
                             base::ThreadTaskRunnerHandle::Get(), callback));
 }
 
 void OfflinePageMetadataStoreSQL::AddOrUpdateOfflinePage(
     const OfflinePageItem& offline_page,
     const UpdateCallback& callback) {
   DCHECK(db_.get());
   background_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&OfflinePageMetadataStoreSQL::AddOrUpdateOfflinePageSync,
-                 offline_page, db_.get(), base::ThreadTaskRunnerHandle::Get(),
-                 callback));
+      base::Bind(&AddOrUpdateOfflinePageSync, offline_page, db_.get(),
+                 base::ThreadTaskRunnerHandle::Get(), callback));
 }
 
 void OfflinePageMetadataStoreSQL::RemoveOfflinePages(
     const std::vector<int64_t>& offline_ids,
     const UpdateCallback& callback) {
   DCHECK(db_.get());
 
   if (offline_ids.empty()) {
     // 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, true));
     return;
   }
 
   background_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&OfflinePageMetadataStoreSQL::RemoveOfflinePagesSync,
-                 offline_ids, db_.get(), base::ThreadTaskRunnerHandle::Get(),
-                 callback));
+      FROM_HERE, base::Bind(&RemoveOfflinePagesSync, offline_ids, db_.get(),
+                            base::ThreadTaskRunnerHandle::Get(), callback));
 }
 
 void OfflinePageMetadataStoreSQL::Reset(const ResetCallback& callback) {
   if (!CheckDb(base::Bind(callback, false)))
     return;
 
   background_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ResetSync, db_.get(), db_file_path_,
                  base::ThreadTaskRunnerHandle::Get(),
@@ skipping 39 matching lines @@
   DCHECK(db_.get());
   if (!db_.get()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback));
     return false;
   }
   return true;
 }
 
 }  // namespace offline_pages