[Offline pages] Adding capability to query a subset of requests based on IDs

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 <unordered_set>
+
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/offline_pages/background/save_page_request.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 
 namespace offline_pages {
 
 template class StoreUpdateResult<SavePageRequest>;
 
 namespace {
 
-using UpdateStatus = RequestQueueStore::UpdateStatus;
 using StoreStateCallback = base::Callback<void(StoreState)>;
 
 // This is a macro instead of a const so that
 // it can be used inline in other SQL statements below.
 #define REQUEST_QUEUE_TABLE_NAME "request_queue_v1"
 const bool kUserRequested = true;
 
 bool CreateRequestQueueTable(sql::Connection* db) {
   const char kSql[] = "CREATE TABLE IF NOT EXISTS " REQUEST_QUEUE_TABLE_NAME
                       " (request_id INTEGER PRIMARY KEY NOT NULL,"
@@ skipping 66 matching lines @@
                                                const int64_t request_id) {
   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 " WHERE request_id=?";
 
   sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, request_id);
 
-  statement.Run();
-  return MakeSavePageRequest(statement);
+  if (statement.Step())
+    return MakeSavePageRequest(statement);
+  return std::unique_ptr<SavePageRequest>(nullptr);
 }
 
 ItemActionStatus DeleteRequestById(sql::Connection* db, int64_t request_id) {
   const char kSql[] =
       "DELETE FROM " REQUEST_QUEUE_TABLE_NAME " WHERE request_id=?";
   sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, request_id);
   if (!statement.Run())
     return ItemActionStatus::STORE_ERROR;
   else if (db->GetLastChangeCount() == 0)
@@ skipping 116 matching lines @@
   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)));
 }
 
+void GetRequestsByIdsSync(sql::Connection* db,
+                          scoped_refptr<base::SingleThreadTaskRunner> runner,
+                          const std::vector<int64_t>& request_ids,
+                          const RequestQueueStore::UpdateCallback& callback) {
+  // TODO(fgorski): Perhaps add metrics here.
+  std::unique_ptr<UpdateRequestsResult> result(
+      new UpdateRequestsResult(StoreState::LOADED));
+
+  // 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()) {
+    PostStoreErrorForAllIds(runner, request_ids, callback);
+    return;
+  }
+
+  // Make sure not to include the same request multiple times, preserving the
+  // order of non-duplicated IDs in the result.
+  std::unordered_set<int64_t> processed_ids;
+  for (int64_t request_id : request_ids) {
+    if (!processed_ids.insert(request_id).second)
+      continue;
+    std::unique_ptr<SavePageRequest> request = GetOneRequest(db, request_id);
+    if (request.get())
+      result->updated_items.push_back(*request);
+    ItemActionStatus status =
+        request.get() ? ItemActionStatus::SUCCESS : ItemActionStatus::NOT_FOUND;
+    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 AddRequestSync(sql::Connection* db,
                     scoped_refptr<base::SingleThreadTaskRunner> runner,
                     const SavePageRequest& request,
                     const RequestQueueStore::AddCallback& callback) {
   // TODO(fgorski): add UMA metrics here.
   ItemActionStatus status = Insert(db, request);
   runner->PostTask(FROM_HERE, base::Bind(callback, status));
 }
 
 void UpdateRequestsSync(sql::Connection* db,
@@ skipping 118 matching lines @@
   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(&GetRequestsSync, db_.get(),
                             base::ThreadTaskRunnerHandle::Get(), callback));
 }
 
+void RequestQueueStoreSQL::GetRequestsByIds(
+    const std::vector<int64_t>& request_ids,
+    const UpdateCallback& callback) {
+  if (!db_.get()) {
+    PostStoreErrorForAllIds(base::ThreadTaskRunnerHandle::Get(), request_ids,
+                            callback);
+    return;
+  }
+
+  background_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&GetRequestsByIdsSync, db_.get(),
+                 base::ThreadTaskRunnerHandle::Get(), request_ids, callback));
+}
+
 void RequestQueueStoreSQL::AddRequest(const SavePageRequest& request,
                                       const AddCallback& callback) {
   if (!CheckDb(base::Bind(callback, ItemActionStatus::STORE_ERROR)))
     return;
 
   background_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AddRequestSync, db_.get(),
                  base::ThreadTaskRunnerHandle::Get(), request, callback));
 }
@@ skipping 67 matching lines @@
   // Complete connection initialization post reset.
   OnOpenConnectionDone(state);
   callback.Run(state == StoreState::LOADED);
 }
 
 StoreState RequestQueueStoreSQL::state() const {
   return state_;
 }
 
 }  // namespace offline_pages