[Offline pages] Add MarkAttemptAbortedTask to Request Queue

components/offline_pages/background/request_coordinator.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_coordinator.h"
 
 #include <limits>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 229 matching lines @@
                                        active_request_->request_id())) {
       StopPrerendering(Offliner::RequestStatus::REQUEST_COORDINATOR_CANCELED);
       return true;
     }
   }
 
   return false;
 }
 
 void RequestCoordinator::AbortRequestAttempt(SavePageRequest* request) {
-  request->MarkAttemptAborted();
   if (request->started_attempt_count() >= policy_->GetMaxStartedTries()) {
     const BackgroundSavePageResult result(
         BackgroundSavePageResult::START_COUNT_EXCEEDED);
     event_logger_.RecordDroppedSavePageRequest(request->client_id().name_space,
                                                result, request->request_id());
     RemoveAttemptedRequest(*request, result);
   } else {
-    queue_->UpdateRequest(
-        *request,
-        base::Bind(&RequestCoordinator::UpdateRequestCallback,
-                   weak_ptr_factory_.GetWeakPtr(), request->client_id()));
+    queue_->MarkAttemptAborted(
+        request->request_id(),
+        base::Bind(&RequestCoordinator::MarkAttemptAbortedDone,
+                   weak_ptr_factory_.GetWeakPtr(), request->request_id(),
+                   request->client_id()));
   }
 }
 
 void RequestCoordinator::RemoveAttemptedRequest(
     const SavePageRequest& request,
     BackgroundSavePageResult result) {
   std::vector<int64_t> remove_requests;
   remove_requests.push_back(request.request_id());
   queue_->RemoveRequests(remove_requests,
                          base::Bind(&RequestCoordinator::HandleRemovedRequests,
                                     weak_ptr_factory_.GetWeakPtr(), result));
   RecordAttemptCount(request, result);
 }
 
+void RequestCoordinator::MarkAttemptAbortedDone(
+    int64_t request_id,
+    const ClientId& client_id,
+    std::unique_ptr<UpdateRequestsResult> result) {
+  // If the request succeeded, nothing to do.  If it failed, we can't really do
+  // much, so just log it.
+  if (result->store_state != StoreState::LOADED ||
+      result->item_statuses.size() != 1 ||
+      result->item_statuses.at(0).first != request_id ||
+      result->item_statuses.at(0).second != ItemActionStatus::SUCCESS) {
+    DVLOG(1) << "Failed to mark request aborted: " << request_id;
+    event_logger_.RecordUpdateRequestFailed(
+        client_id.name_space,
+        result->store_state != StoreState::LOADED
+            ? RequestQueue::UpdateRequestResult::STORE_FAILURE
+            : RequestQueue::UpdateRequestResult::REQUEST_DOES_NOT_EXIST);
+  }
+}
+
 void RequestCoordinator::RemoveRequests(
     const std::vector<int64_t>& request_ids,
     const RemoveRequestsCallback& callback) {
   bool canceled = CancelActiveRequestIfItMatches(request_ids);
   queue_->RemoveRequests(
       request_ids,
       base::Bind(&RequestCoordinator::HandleRemovedRequestsAndCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback,
                  BackgroundSavePageResult::REMOVED));
   if (canceled)
@@ skipping 464 matching lines @@
 
 ClientPolicyController* RequestCoordinator::GetPolicyController() {
   return policy_controller_.get();
 }
 
 void RequestCoordinator::Shutdown() {
   network_quality_estimator_ = nullptr;
 }
 
 }  // namespace offline_pages