Add an API to Pause and Resume background offlining requests.

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 59 matching lines @@
   const char kSql[] = "DELETE FROM " REQUEST_QUEUE_TABLE_NAME
                       " WHERE client_namespace=? AND client_id=?";
   sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindString(0, client_id.name_space);
   statement.BindString(1, client_id.id);
   DVLOG(2) << kSql << " client_namespace " << client_id.name_space
            << " client_id " << client_id.id;
   return statement.Run();
 }
 
+bool PauseRequest(sql::Connection* db, const int64_t request_id) {
+  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<long>(SavePageRequest::RequestState::PAUSED));
+  statement.BindInt64(1, request_id);
+  return statement.Run();
+}
+
+bool ResumeRequest(sql::Connection* db, const int64_t request_id) {
+  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<long>(SavePageRequest::RequestState::AVAILABLE));
+  statement.BindInt64(1, request_id);
+  return statement.Run();
+}
+
 bool DeleteRequestsByIds(sql::Connection* db,
                          const std::vector<int64_t>& request_ids,
                          int* count) {
   DCHECK(count);
   // 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())
     return false;
 
@@ skipping 26 matching lines @@
       return false;
     *count += db->GetLastChangeCount();
   }
 
   if (!transaction.Commit())
     return false;
 
   return true;
 }
 
+RequestQueueStore::UpdateStatus PauseRequests(
+    sql::Connection* db, const std::vector<int64_t>& request_ids) {
+  // 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())
+    return RequestQueueStore::UpdateStatus::FAILED;
+  for (const auto& request_id : request_ids) {
+    if (!PauseRequest(db, request_id))
+      return RequestQueueStore::UpdateStatus::FAILED;
+  }
+
+  if (!transaction.Commit())
+    return RequestQueueStore::UpdateStatus::FAILED;
+
+  return RequestQueueStore::UpdateStatus::UPDATED;
+}
+
+RequestQueueStore::UpdateStatus ResumeRequests(
+    sql::Connection* db, const std::vector<int64_t>& request_ids) {
+  // 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())
+    return RequestQueueStore::UpdateStatus::FAILED;
+
+  for (const auto& request_id : request_ids) {
+    if (!ResumeRequest(db, request_id))
+      return RequestQueueStore::UpdateStatus::FAILED;
+  }
+
+  if (!transaction.Commit())
+    return RequestQueueStore::UpdateStatus::FAILED;
+
+  return RequestQueueStore::UpdateStatus::UPDATED;
+}
+
 // 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.
 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 =
@@ skipping 147 matching lines @@
     const RemoveCallback& callback) {
   // TODO(fgorski): add UMA metrics here.
   int count = 0;
   if (DeleteRequestsByClientIds(db, client_ids, &count))
     runner->PostTask(FROM_HERE, base::Bind(callback, true, count));
   else
     runner->PostTask(FROM_HERE, base::Bind(callback, false, 0));
 }
 
 // static
+void RequestQueueStoreSQL::PauseRequestsSync(
+    sql::Connection* db,
+    scoped_refptr<base::SingleThreadTaskRunner> runner,
+    const std::vector<int64_t>& request_ids,
+    const UpdateCallback& callback) {
+  // TODO(fgorski): add UMA metrics here.
+  RequestQueueStore::UpdateStatus status =
+      offline_pages::PauseRequests(db, request_ids);
+  runner->PostTask(FROM_HERE, base::Bind(callback, status));
+}
+
+// static
+void RequestQueueStoreSQL::ResumeRequestsSync(
+    sql::Connection* db,
+    scoped_refptr<base::SingleThreadTaskRunner> runner,
+    const std::vector<int64_t>& request_ids,
+    const UpdateCallback& callback) {
+  // TODO(fgorski): add UMA metrics here.
+  RequestQueueStore::UpdateStatus status =
+      offline_pages::ResumeRequests(db, request_ids);
+  runner->PostTask(FROM_HERE, base::Bind(callback, status));
+}
+
+// static
 void RequestQueueStoreSQL::ResetSync(
     sql::Connection* db,
     const base::FilePath& db_file_path,
     scoped_refptr<base::SingleThreadTaskRunner> runner,
     const 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);
@@ skipping 25 matching lines @@
         FROM_HERE, base::Bind(callback, UpdateStatus::FAILED));
     return;
   }
 
   background_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RequestQueueStoreSQL::AddOrUpdateRequestSync, db_.get(),
                  base::ThreadTaskRunnerHandle::Get(), request, callback));
 }
 
-// TODO(petewil): This is unused, since request_coordinator doesn't keep
-// request_ids, and neither do clients.  Plan is to remove this API in a future
-// changelist.  If we do discover a need to keep it, name it
-// RemoveRequestsByRequestId to be more parallell with RemoveRequestsByClientId.
 void RequestQueueStoreSQL::RemoveRequests(
     const std::vector<int64_t>& request_ids,
     const RemoveCallback& 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, false, 0));
     return;
@@ skipping 16 matching lines @@
         FROM_HERE, base::Bind(callback, false, 0));
     return;
   }
 
   background_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RequestQueueStoreSQL::RemoveRequestsByClientIdSync, db_.get(),
                  base::ThreadTaskRunnerHandle::Get(), client_ids, callback));
 }
 
+
+void RequestQueueStoreSQL::PauseRequests(
+    const std::vector<int64_t>& request_ids,
+    const UpdateCallback& callback) {
+  DCHECK(db_.get());
+  if (!db_.get()) {

[Dmitry Titov, 2016/08/09 21:01:43]

Could you pull all these identical blocks into something like 

if (!checkDb(callback))
  return;

with checkDb having the code to post task etc? and change to it in whole file.

[Pete Williamson, 2016/08/09 22:53:24]

Done.  Unfortunately, the callbacks have different types and take different
parameter sets, so we ended up with 4 CheckDb functions instead of one.

I skipped RemoveRequestByClientId since it is being deleted in a different
changelist (to reduce merge problems later).

+    // 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, UpdateStatus::FAILED));
+    return;
+  }
+
+  background_task_runner_->PostTask(

[Dmitry Titov, 2016/08/09 21:01:43]

Is there a reason we don't use PostTaskAndReply in all these methods?

[Pete Williamson, 2016/08/09 22:53:24]

I'm following the model in the rest of the file.  I can convert the whole file
in another changelist if you like.

+      FROM_HERE,
+      base::Bind(&RequestQueueStoreSQL::PauseRequestsSync, db_.get(),
+                 base::ThreadTaskRunnerHandle::Get(), request_ids, callback));
+}
+
+void RequestQueueStoreSQL::ResumeRequests(
+    const std::vector<int64_t>& request_ids,
+    const UpdateCallback& 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, UpdateStatus::FAILED));
+    return;
+  }
+
+  background_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&RequestQueueStoreSQL::ResumeRequestsSync, db_.get(),
+                 base::ThreadTaskRunnerHandle::Get(), request_ids, callback));
+}
+
+
 void RequestQueueStoreSQL::Reset(const ResetCallback& 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, false));
     return;
   }
 
@@ skipping 25 matching lines @@
 }
 
 void RequestQueueStoreSQL::OnResetDone(const ResetCallback& callback,
                                        bool success) {
   // Complete connection initialization post reset.
   OnOpenConnectionDone(success);
   callback.Run(success);
 }
 
 }  // namespace offline_pages