Request Picker task

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"
@@ skipping 170 matching lines @@
     return ItemActionStatus::NOT_FOUND;
   return ItemActionStatus::SUCCESS;
 }
 
 void PostStoreUpdateResultForIds(
     scoped_refptr<base::SingleThreadTaskRunner> runner,
     StoreState store_state,
     const std::vector<int64_t>& item_ids,
     ItemActionStatus action_status,
     const RequestQueueStore::UpdateCallback& callback) {
-  std::unique_ptr<UpdateRequestsResult> result(
-      new UpdateRequestsResult(store_state));
+  std::unique_ptr<QueueResults::UpdateRequestsResult> result(
+      new QueueResults::UpdateRequestsResult(store_state));
   for (const auto& item_id : item_ids)
     result->item_statuses.push_back(std::make_pair(item_id, action_status));
   runner->PostTask(FROM_HERE, base::Bind(callback, base::Passed(&result)));
 }
 
 void PostStoreErrorForAllRequests(
     scoped_refptr<base::SingleThreadTaskRunner> runner,
     const std::vector<SavePageRequest>& items,
     const RequestQueueStore::UpdateCallback& callback) {
   std::vector<int64_t> item_ids;
@@ skipping 44 matching lines @@
 
   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));
+  std::unique_ptr<QueueResults::UpdateRequestsResult> result(
+      new QueueResults::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
@@ skipping 25 matching lines @@
   // TODO(fgorski): add UMA metrics here.
   ItemActionStatus status = Insert(db, request);
   runner->PostTask(FROM_HERE, base::Bind(callback, status));
 }
 
 void UpdateRequestsSync(sql::Connection* db,
                         scoped_refptr<base::SingleThreadTaskRunner> runner,
                         const std::vector<SavePageRequest>& requests,
                         const RequestQueueStore::UpdateCallback& callback) {
   // TODO(fgorski): add UMA metrics here.
-  std::unique_ptr<UpdateRequestsResult> result(
-      new UpdateRequestsResult(StoreState::LOADED));
+  std::unique_ptr<QueueResults::UpdateRequestsResult> result(
+      new QueueResults::UpdateRequestsResult(StoreState::LOADED));
 
   sql::Transaction transaction(db);
   if (!transaction.Begin()) {
     PostStoreErrorForAllRequests(runner, requests, callback);
     return;
   }
 
   for (const auto& request : requests) {
     ItemActionStatus status = Update(db, request);
     result->item_statuses.push_back(
         std::make_pair(request.request_id(), status));
     if (status == ItemActionStatus::SUCCESS)
       result->updated_items.push_back(request);
   }
 
   if (!transaction.Commit()) {
     PostStoreErrorForAllRequests(runner, requests, callback);
     return;
   }
 
   runner->PostTask(FROM_HERE, base::Bind(callback, base::Passed(&result)));
 }
 
 void RemoveRequestsSync(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));
+  std::unique_ptr<QueueResults::UpdateRequestsResult> result(
+      new QueueResults::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;
   }
 
   // Read the request before we delete it, and if the delete worked, put it on
@@ skipping 174 matching lines @@
   // Complete connection initialization post reset.
   OnOpenConnectionDone(state);
   callback.Run(state == StoreState::LOADED);
 }
 
 StoreState RequestQueueStoreSQL::state() const {
   return state_;
 }
 
 }  // namespace offline_pages