If MHTML saving is cancelled, delete the page afterwards.

chrome/browser/android/offline_pages/background_loader_offliner.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 "chrome/browser/android/offline_pages/background_loader_offliner.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sys_info.h"
@@ skipping 63 matching lines @@
                          "OfflinePages.Background.BackgroundLoadingFailedCode"),
       std::abs(error_code));
 }
 
 void HandleApplicationStateChangeCancel(
     const Offliner::CompletionCallback& completion_callback,
     const SavePageRequest& canceled_request) {
   completion_callback.Run(canceled_request,
                           Offliner::RequestStatus::FOREGROUND_CANCELED);
 }
+
 }  // namespace
 
 BackgroundLoaderOffliner::BackgroundLoaderOffliner(
     content::BrowserContext* browser_context,
     const OfflinerPolicy* policy,
     OfflinePageModel* offline_page_model)
     : browser_context_(browser_context),
       offline_page_model_(offline_page_model),
       policy_(policy),
       is_low_end_device_(base::SysInfo::IsLowEndDevice()),
@@ skipping 313 matching lines @@
 void BackgroundLoaderOffliner::OnPageSaved(SavePageResult save_result,
                                            int64_t offline_id) {
   if (!pending_request_)
     return;
 
   SavePageRequest request(*pending_request_.get());
   bool did_snapshot_on_last_retry = did_snapshot_on_last_retry_;
   ResetState();
 
   if (save_state_ == DELETE_AFTER_SAVE) {
+    // Delete the saved page off disk and from the OPM.
+    std::vector<int64_t> offline_ids;
+    offline_ids.push_back(offline_id);
+    offline_page_model_->DeletePagesByOfflineId(
+        offline_ids,
+        base::Bind(&BackgroundLoaderOffliner::DeleteOfflinePageCallback,
+                   weak_ptr_factory_.GetWeakPtr(), request));
     save_state_ = NONE;
-    cancel_callback_.Run(request);
+    // We don't return to the caller until the page has been removed from the

[Dmitry Titov, 2017/05/01 23:00:38]

I think this comment is not needed, we do this kind of async chains all the time
and reader would naturally jump from here to the DeleteOfflinePageCallback which
invokes the cacncel_callback_, so no readability issue.

+    // OfflinePageModel to prevent retrying a page while we are deleting it.
     return;
   }
 
   save_state_ = NONE;
 
   Offliner::RequestStatus save_status;
   if (save_result == SavePageResult::ALREADY_EXISTS) {
     save_status = RequestStatus::SAVED;
   } else if (save_result == SavePageResult::SUCCESS) {
     if (did_snapshot_on_last_retry)
       save_status = RequestStatus::SAVED_ON_LAST_RETRY;
     else
       save_status = RequestStatus::SAVED;
   } else {
     save_status = RequestStatus::SAVE_FAILED;
   }
 
   completion_callback_.Run(request, save_status);
 }
 
+void BackgroundLoaderOffliner::DeleteOfflinePageCallback(
+    const SavePageRequest& request,
+    DeletePageResult result) {
+  cancel_callback_.Run(request);
+}
+
 void BackgroundLoaderOffliner::ResetState() {
   pending_request_.reset();
   snapshot_controller_.reset();
   page_load_state_ = SUCCESS;
   network_bytes_ = 0LL;
   is_low_bar_met_ = false;
   did_snapshot_on_last_retry_ = false;
   // TODO(chili): Remove after RequestCoordinator can handle multiple offliners.
   // We reset the loader and observer after completion so loaders
   // will not be re-used across different requests/tries. This is a temporary
@@ skipping 27 matching lines @@
   // Given the choice between int and double, we choose to implicitly convert to
   // a double since it maintains more precision (we can get a longer time in
   // milliseconds than we can with a 2 bit int, 53 bits vs 32).
   double delay = delay_so_far.InMilliseconds();
   signal_data_.SetDouble(signal_name, delay);
 }
 
 }  // namespace offline_pages
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(offline_pages::OfflinerData);