[Offline pages] Removing RequestQueueStore::UpdateMultipleRequestsCallback

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 117 matching lines @@
   sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, request_id);
   if (!statement.Run())
     return RequestQueue::UpdateRequestResult::STORE_FAILURE;
   else if (db->GetLastChangeCount() == 0)
     return RequestQueue::UpdateRequestResult::REQUEST_DOES_NOT_EXIST;
   else
     return RequestQueue::UpdateRequestResult::SUCCESS;
 }
 
-bool ChangeRequestState(sql::Connection* db,
-                        const int64_t request_id,
-                        const SavePageRequest::RequestState new_state) {
+ItemActionStatus ChangeRequestState(
+    sql::Connection* db,
+    const int64_t request_id,
+    const SavePageRequest::RequestState new_state) {
   const char kSql[] = "UPDATE " REQUEST_QUEUE_TABLE_NAME
                       " SET state=?"
                       " WHERE request_id=?";
   sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, static_cast<int64_t>(new_state));
   statement.BindInt64(1, request_id);
-  return statement.Run();
+
+  if (!statement.Run())
+    return ItemActionStatus::STORE_ERROR;
+  if (db->GetLastChangeCount() == 0)
+    return ItemActionStatus::NOT_FOUND;
+  return ItemActionStatus::SUCCESS;
 }
 
 // Helper function to delete requests corresponding to passed in requestIds,
 // and fill an outparam with the removed requests.
 bool DeleteRequestsByIds(
     sql::Connection* db,
     const std::vector<int64_t>& request_ids,
     RequestQueue::UpdateMultipleRequestResults& results,
     std::vector<std::unique_ptr<SavePageRequest>>* requests) {
   // If you create a transaction but don't Commit() it is automatically
@@ skipping 17 matching lines @@
 
   if (!transaction.Commit()) {
     requests->clear();
     BuildFailedResultList(request_ids, results);
     return false;
   }
 
   return true;
 }
 
-bool ChangeRequestsState(
-    sql::Connection* db,
-    const std::vector<int64_t>& request_ids,
-    SavePageRequest::RequestState new_state,
-    RequestQueue::UpdateMultipleRequestResults& results,
-    std::vector<std::unique_ptr<SavePageRequest>>& requests) {
-  // 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()) {
-    BuildFailedResultList(request_ids, results);
-    return false;
-  }
-
-  // Update a request, then get it, and put the item we got on the output list.
-  for (const auto& request_id : request_ids) {
-    RequestQueue::UpdateRequestResult status;
-    if (!ChangeRequestState(db, request_id, new_state))
-      status = RequestQueue::UpdateRequestResult::REQUEST_DOES_NOT_EXIST;
-    else
-      status = RequestQueue::UpdateRequestResult::SUCCESS;
-
-    // Make output request_id/status pair, and put a copy of the updated request
-    // on output list.
-    results.push_back(std::make_pair(request_id, status));
-    requests.push_back(GetOneRequest(db, request_id));
-  }
-
-  if (!transaction.Commit()) {
-    requests.clear();
-    BuildFailedResultList(request_ids, results);
-    return false;
-  }
-
-  return true;
-}
-
 ItemActionStatus Insert(sql::Connection* db, const SavePageRequest& request) {
   const char kSql[] =
       "INSERT OR IGNORE INTO " REQUEST_QUEUE_TABLE_NAME
       " (request_id, creation_time, activation_time,"
       " last_attempt_time, started_attempt_count, completed_attempt_count,"
       " state, url, client_namespace, client_id)"
       " VALUES "
       " (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
 
   sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql));
@@ skipping 59 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> runner,
     const std::vector<SavePageRequest>& items,
     const RequestQueueStore::UpdateCallback& callback) {
   std::vector<int64_t> item_ids;
   for (const auto& item : items)
     item_ids.push_back(item.request_id());
   PostStoreUpdateResultForIds(runner, StoreState::LOADED, item_ids,
                               ItemActionStatus::STORE_ERROR, callback);
 }
 
+void PostStoreErrorForAllIds(
+    scoped_refptr<base::SingleThreadTaskRunner> runner,
+    const std::vector<int64_t>& item_ids,
+    const RequestQueueStore::UpdateCallback& callback) {
+  PostStoreUpdateResultForIds(runner, StoreState::LOADED, item_ids,
+                              ItemActionStatus::STORE_ERROR, callback);
+}
+
 bool InitDatabase(sql::Connection* db, const base::FilePath& path) {
   db->set_page_size(4096);
   db->set_cache_size(500);
   db->set_histogram_tag("BackgroundRequestQueue");
   db->set_exclusive_locking();
 
   base::File::Error err;
   if (!base::CreateDirectoryAndGetError(path.DirName(), &err))
     return false;
   if (!db->Open(path))
     return false;
   db->Preload();
 
   return CreateSchema(db);
 }
 
+std::unique_ptr<SavePageRequest> GetRequestByIdSync(sql::Connection* db,
+                                                    int64_t item_id) {
+  const char kSql[] =
+      "SELECT * FROM " REQUEST_QUEUE_TABLE_NAME " WHERE request_id = ?";
+  sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, item_id);
+
+  if (statement.Step()) {
+    return MakeSavePageRequest(statement);
+  }
+
+  return std::unique_ptr<SavePageRequest>(nullptr);
+}
+
 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));
@@ skipping 50 matching lines @@
                         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)));
 }
 
+// TODO(fgorski): This method is to be completely removed by petewil's patch.
 void ChangeRequestsStateSync(
     sql::Connection* db,
     scoped_refptr<base::SingleThreadTaskRunner> runner,
     const std::vector<int64_t>& request_ids,
     const SavePageRequest::RequestState new_state,
-    const RequestQueue::UpdateMultipleRequestsCallback& callback) {
-  RequestQueue::UpdateMultipleRequestResults results;
-  std::vector<std::unique_ptr<SavePageRequest>> requests;
+    const RequestQueueStore::UpdateCallback& callback) {
   // 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)));
+  std::unique_ptr<UpdateRequestsResult> result(
+      new UpdateRequestsResult(StoreState::LOADED));
+
+  sql::Transaction transaction(db);
+  if (!transaction.Begin()) {
+    PostStoreErrorForAllIds(runner, request_ids, callback);
+    return;
+  }
+
+  // Update a request, then get it, and put the item we got on the output list.
+  for (const auto& request_id : request_ids) {
+    ItemActionStatus status = ChangeRequestState(db, request_id, new_state);
+    if (status == ItemActionStatus::SUCCESS) {
+      std::unique_ptr<SavePageRequest> request =
+          GetRequestByIdSync(db, request_id);
+      if (request.get())
+        result->updated_items.push_back(*request);
+      else
+        status = ItemActionStatus::STORE_ERROR;
+    }
+
+    result->item_statuses.push_back(std::make_pair(request_id, status));
+  }
+
+  if (!transaction.Commit()) {
+    PostStoreErrorForAllIds(runner, request_ids, callback);
+    return;
+  }
+
+  runner->PostTask(FROM_HERE, base::Bind(callback, base::Passed(&result)));
 }
 
 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));
 }
 
@@ skipping 92 matching lines @@
 
   background_task_runner_->PostTask(
       FROM_HERE,
       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)))) {
+    const UpdateCallback& callback) {
+  if (!db_.get()) {
+    PostStoreErrorForAllIds(base::ThreadTaskRunnerHandle::Get(), request_ids,
+                            callback);
     return;
   }
 
   background_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ChangeRequestsStateSync, db_.get(),
                             base::ThreadTaskRunnerHandle::Get(), request_ids,
                             new_state, callback));
 }
 
 void RequestQueueStoreSQL::Reset(const ResetCallback& callback) {
@@ skipping 29 matching lines @@
 }
 
 void RequestQueueStoreSQL::OnResetDone(const ResetCallback& callback,
                                        bool success) {
   // Complete connection initialization post reset.
   OnOpenConnectionDone(success);
   callback.Run(success);
 }
 
 }  // namespace offline_pages