If MHTML saving is cancelled, delete the page afterwards.

chrome/browser/android/offline_pages/background_loader_offliner_unittest.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/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/scoped_feature_list.h"
@@ skipping 25 matching lines @@
 
 const int64_t kRequestId = 7;
 const GURL kHttpUrl("http://www.tunafish.com");
 const GURL kFileUrl("file://salmon.png");
 const ClientId kClientId("async_loading", "88");
 const bool kUserRequested = true;
 
 // Mock OfflinePageModel for testing the SavePage calls
 class MockOfflinePageModel : public StubOfflinePageModel {
  public:
-  MockOfflinePageModel() : mock_saving_(false) {}
+  MockOfflinePageModel() : mock_saving_(false), mock_deleting_(false) {}
   ~MockOfflinePageModel() override {}
 
   void SavePage(const SavePageParams& save_page_params,
                 std::unique_ptr<OfflinePageArchiver> archiver,
                 const SavePageCallback& callback) override {
     mock_saving_ = true;
     save_page_callback_ = callback;
   }
 
   void CompleteSavingAsArchiveCreationFailed() {
@@ skipping 13 matching lines @@
   }
 
   void CompleteSavingAsAlreadyExists() {
     DCHECK(mock_saving_);
     mock_saving_ = false;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(save_page_callback_,
                               SavePageResult::ALREADY_EXISTS, 123456));
   }
 
+  void DeletePagesByOfflineId(const std::vector<int64_t>& offline_ids,
+                              const DeletePageCallback& callback) override {
+    mock_deleting_ = true;
+    callback.Run(DeletePageResult::SUCCESS);
+  }
+
   bool mock_saving() const { return mock_saving_; }
+  bool mock_deleting() const { return mock_deleting_; }
 
  private:
   bool mock_saving_;
+  bool mock_deleting_;
   SavePageCallback save_page_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(MockOfflinePageModel);
 };
 
 }  // namespace
 
 // A BackgroundLoader that we can run tests on.
 // Overrides the ResetState so we don't actually try to create any web contents.
 // This is a temporary solution to test core BackgroundLoaderOffliner
@@ skipping 54 matching lines @@
   }
   Offliner::CancelCallback const cancel_callback() {
     return base::Bind(&BackgroundLoaderOfflinerTest::OnCancel,
                       base::Unretained(this));
   }
   Profile* profile() { return &profile_; }
   bool completion_callback_called() { return completion_callback_called_; }
   Offliner::RequestStatus request_status() { return request_status_; }
   bool cancel_callback_called() { return cancel_callback_called_; }
   bool SaveInProgress() const { return model_->mock_saving(); }
+  bool DeleteCalled() const { return model_->mock_deleting(); }
   MockOfflinePageModel* model() const { return model_; }
   const base::HistogramTester& histograms() const { return histogram_tester_; }
   int64_t progress() { return progress_; }
   OfflinerPolicy* policy() const { return policy_.get(); }
 
   void PumpLoop() { base::RunLoop().RunUntilIdle(); }
 
   void CompleteLoading() {
     offliner()->DocumentOnLoadCompletedInMainFrame();
     PumpLoop();
@@ skipping 155 matching lines @@
                                       progress_callback()));
   CompleteLoading();
   PumpLoop();
   offliner()->Cancel(cancel_callback());
   PumpLoop();
 
   // Subsequent save callback cause no crash.
   model()->CompleteSavingAsArchiveCreationFailed();
   PumpLoop();
   EXPECT_TRUE(cancel_callback_called());
+  EXPECT_TRUE(DeleteCalled());
   EXPECT_FALSE(completion_callback_called());
   EXPECT_FALSE(SaveInProgress());
   EXPECT_FALSE(offliner()->is_loading());  // Offliner reset.
 }
 
 TEST_F(BackgroundLoaderOfflinerTest, LoadedButSaveFails) {
   base::Time creation_time = base::Time::Now();
   SavePageRequest request(kRequestId, kHttpUrl, kClientId, creation_time,
                           kUserRequested);
   EXPECT_TRUE(offliner()->LoadAndSave(request, completion_callback(),
@@ skipping 281 matching lines @@
   CompleteLoading();
   PumpLoop();
 
   // One extra part should be added if the flag is on.
   content::MHTMLExtraParts* extra_parts =
       content::MHTMLExtraParts::FromWebContents(offliner()->web_contents());
   EXPECT_EQ(extra_parts->size(), 1);
 }
 
 }  // namespace offline_pages