[Offline pages] Splitting Add and Update methods in OPMStore

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 257 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,
+void AddOfflinePageSync(sql::Connection* db,
+                        scoped_refptr<base::SingleThreadTaskRunner> runner,
+                        const OfflinePageItem& offline_page,
+                        const OfflinePageMetadataStore::AddCallback& callback) {
+  // TODO(fgorski): Only insert should happen here.
+  InsertOrReplace(db, offline_page);
+  runner->PostTask(FROM_HERE,
+                   base::Bind(callback, OfflinePageMetadataStore::SUCCESS));
+}
+
+void UpdateOfflinePagesSync(
     sql::Connection* db,
     scoped_refptr<base::SingleThreadTaskRunner> runner,
+    const std::vector<OfflinePageItem>& pages,
     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));
+  // TODO(fgorski): Update the callback to provide information about all items
+  // and not just a high level boolean.
+  sql::Transaction transaction(db);
+  if (!transaction.Begin()) {
+    runner->PostTask(FROM_HERE, base::Bind(callback, false));
+    return;
+  }
+
+  // TODO(fgorski): Switch to only accept updates and not create new items.
+  for (auto& page : pages)
+    InsertOrReplace(db, page);
+
+  bool result = transaction.Commit();
+  runner->PostTask(FROM_HERE, base::Bind(callback, result));
 }
 
 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
@@ skipping 52 matching lines @@
   }
 }
 
 void OfflinePageMetadataStoreSQL::GetOfflinePages(
     const LoadCallback& callback) {
   background_task_runner_->PostTask(
       FROM_HERE, base::Bind(&GetOfflinePagesSync, db_.get(),
                             base::ThreadTaskRunnerHandle::Get(), callback));
 }
 
-void OfflinePageMetadataStoreSQL::AddOrUpdateOfflinePage(
+void OfflinePageMetadataStoreSQL::AddOfflinePage(
     const OfflinePageItem& offline_page,
-    const UpdateCallback& callback) {
-  DCHECK(db_.get());
+    const AddCallback& callback) {
+  if (!CheckDb(base::Bind(callback, STORE_ERROR)))
+    return;
+
   background_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&AddOrUpdateOfflinePageSync, offline_page, db_.get(),
-                 base::ThreadTaskRunnerHandle::Get(), callback));
+      base::Bind(&AddOfflinePageSync, db_.get(),
+                 base::ThreadTaskRunnerHandle::Get(), offline_page, callback));
+}
+
+void OfflinePageMetadataStoreSQL::UpdateOfflinePages(
+    const std::vector<OfflinePageItem>& pages,
+    const UpdateCallback& callback) {
+  if (!CheckDb(base::Bind(callback, false)))
+    return;
+
+  background_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&UpdateOfflinePagesSync, db_.get(),
+                 base::ThreadTaskRunnerHandle::Get(), pages, 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.
@@ skipping 57 matching lines @@
   DCHECK(db_.get());
   if (!db_.get()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback));
     return false;
   }
   return true;
 }
 
 }  // namespace offline_pages