[Offline pages] Add new Error page failure status inside the MHTML archiver and update correspondin…

chrome/browser/android/offline_pages/offline_page_mhtml_archiver_unittest.cc

 // Copyright 2015 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/offline_page_mhtml_archiver.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 19 matching lines @@
 const int64_t kTestFileSize = 123456LL;
 const base::string16 kTestTitle = base::UTF8ToUTF16("a title");
 
 class TestMHTMLArchiver : public OfflinePageMHTMLArchiver {
  public:
   enum class TestScenario {
     SUCCESS,
     NOT_ABLE_TO_ARCHIVE,
     WEB_CONTENTS_MISSING,
     CONNECTION_SECURITY_ERROR,
+    ERROR_PAGE,
+    INTERSTITIAL_PAGE,
   };
 
   TestMHTMLArchiver(const GURL& url, const TestScenario test_scenario);
   ~TestMHTMLArchiver() override;
 
  private:
   void GenerateMHTML(const base::FilePath& archives_dir,
                      const CreateArchiveParams& create_archive_params) override;
   bool HasConnectionSecurityError() override;
+  content::PageType GetPageType() override;
 
   const GURL url_;
   const TestScenario test_scenario_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMHTMLArchiver);
 };
 
 TestMHTMLArchiver::TestMHTMLArchiver(const GURL& url,
                                      const TestScenario test_scenario)
     : url_(url),
@@ skipping 20 matching lines @@
       FROM_HERE,
       base::Bind(&TestMHTMLArchiver::OnGenerateMHTMLDone,
                  base::Unretained(this), url_, base::FilePath(kTestFilePath),
                  kTestTitle, kTestFileSize));
 }
 
 bool TestMHTMLArchiver::HasConnectionSecurityError() {
   return test_scenario_ == TestScenario::CONNECTION_SECURITY_ERROR;
 }
 
+content::PageType TestMHTMLArchiver::GetPageType() {
+  if (test_scenario_ == TestScenario::ERROR_PAGE)
+    return content::PageType::PAGE_TYPE_ERROR;
+  if (test_scenario_ == TestScenario::INTERSTITIAL_PAGE)
+    return content::PageType::PAGE_TYPE_INTERSTITIAL;
+  return content::PageType::PAGE_TYPE_NORMAL;
+}
+
 }  // namespace
 
 class OfflinePageMHTMLArchiverTest : public testing::Test {
  public:
   OfflinePageMHTMLArchiverTest();
   ~OfflinePageMHTMLArchiverTest() override;
 
   // Creates an archiver for testing scenario and uses it to create an archive.
   std::unique_ptr<TestMHTMLArchiver> CreateArchive(
       const GURL& url,
@@ skipping 111 matching lines @@
   std::unique_ptr<TestMHTMLArchiver> archiver(CreateArchive(
       page_url, TestMHTMLArchiver::TestScenario::CONNECTION_SECURITY_ERROR));
 
   EXPECT_EQ(archiver.get(), last_archiver());
   EXPECT_EQ(OfflinePageArchiver::ArchiverResult::ERROR_SECURITY_CERTIFICATE,
             last_result());
   EXPECT_EQ(base::FilePath(), last_file_path());
   EXPECT_EQ(0LL, last_file_size());
 }
 
+// Tests for archiver handling of an error page.
+TEST_F(OfflinePageMHTMLArchiverTest, PageError) {
+  GURL page_url = GURL(kTestURL);
+  std::unique_ptr<TestMHTMLArchiver> archiver(
+      CreateArchive(page_url, TestMHTMLArchiver::TestScenario::ERROR_PAGE));
+
+  EXPECT_EQ(archiver.get(), last_archiver());
+  EXPECT_EQ(OfflinePageArchiver::ArchiverResult::ERROR_ERROR_PAGE,
+            last_result());
+  EXPECT_EQ(base::FilePath(), last_file_path());
+  EXPECT_EQ(0LL, last_file_size());
+}
+
+// Tests for archiver handling of an interstitial page.
+TEST_F(OfflinePageMHTMLArchiverTest, InterstitialPage) {
+  GURL page_url = GURL(kTestURL);
+  std::unique_ptr<TestMHTMLArchiver> archiver(CreateArchive(
+      page_url, TestMHTMLArchiver::TestScenario::INTERSTITIAL_PAGE));
+  EXPECT_EQ(archiver.get(), last_archiver());
+  EXPECT_EQ(OfflinePageArchiver::ArchiverResult::ERROR_INTERSTITIAL_PAGE,
+            last_result());
+  EXPECT_EQ(base::FilePath(), last_file_path());
+  EXPECT_EQ(0LL, last_file_size());
+}
+
 // Tests for successful creation of the offline page archive.
 TEST_F(OfflinePageMHTMLArchiverTest, SuccessfullyCreateOfflineArchive) {
   GURL page_url = GURL(kTestURL);
   std::unique_ptr<TestMHTMLArchiver> archiver(
       CreateArchive(page_url, TestMHTMLArchiver::TestScenario::SUCCESS));
   PumpLoop();
 
   EXPECT_EQ(archiver.get(), last_archiver());
   EXPECT_EQ(OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED,
             last_result());
   EXPECT_EQ(GetTestFilePath(), last_file_path());
   EXPECT_EQ(kTestFileSize, last_file_size());
 }
 
 }  // namespace offline_pages