Do not snapshot error pages

chrome/browser/android/offline_pages/recent_tab_helper_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/recent_tab_helper.h"
 
 #include "base/run_loop.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
 #include "chrome/browser/android/offline_pages/test_offline_page_model_builder.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "components/offline_pages/offline_page_item.h"
 #include "components/offline_pages/offline_page_model.h"
 #include "components/offline_pages/offline_page_test_archiver.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/web_contents.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
+namespace {
+const GURL kTestPageUrl("http://mystery.site/foo.html");
+}
+
 class TestArchiveFactoryImpl : public RecentTabHelper::TestArchiveFactory {
  public:
   explicit TestArchiveFactoryImpl(OfflinePageTestArchiver::Observer* observer);
   ~TestArchiveFactoryImpl() override {}
 
   std::unique_ptr<OfflinePageArchiver> CreateArchiver(
         content::WebContents* web_contents) override;
  private:
   OfflinePageTestArchiver::Observer* observer_;  // observer owns this.
 };
 
 class RecentTabHelperTest
     : public ChromeRenderViewHostTestHarness,
       public OfflinePageModel::Observer,
       public OfflinePageTestArchiver::Observer {
  public:
   RecentTabHelperTest();
   ~RecentTabHelperTest() override {}
 
   void SetUp() override;
   void SetUpTestArchiver(const GURL& url);
   void SetUpMockTaskRunner();
   const std::vector<OfflinePageItem>& GetAllPages();
 
+  void FailLoad(const GURL& url);
+
   // Runs default thread.
   void RunUntilIdle();
   // Moves forward the snapshot controller's task runner.
   void FastForwardSnapshotController();
 
   RecentTabHelper* recent_tab_helper() const { return recent_tab_helper_; }
   OfflinePageModel* model() const { return model_; }
   const std::vector<OfflinePageItem>& all_pages() { return all_pages_; }
   size_t model_changed_count() { return model_changed_count_; }
   size_t model_removed_count() { return model_removed_count_; }
@@ skipping 65 matching lines @@
 
   std::unique_ptr<RecentTabHelper::TestArchiveFactory> test_archive_factory(
       new TestArchiveFactoryImpl(this));
   recent_tab_helper_->SetArchiveFactoryForTest(std::move(test_archive_factory));
 
 
   model_ = OfflinePageModelFactory::GetForBrowserContext(browser_context());
   model_->AddObserver(this);
 }
 
+void RecentTabHelperTest::FailLoad(const GURL& url) {
+  controller().LoadURL(url, content::Referrer(), ui::PAGE_TRANSITION_TYPED,
+                       std::string());
+  content::RenderFrameHostTester::For(main_rfh())->SimulateNavigationStart(url);
+  content::RenderFrameHostTester::For(main_rfh())->
+      SimulateNavigationError(url, net::ERR_INTERNET_DISCONNECTED);
+  content::RenderFrameHostTester::For(main_rfh())->
+      SimulateNavigationErrorPageCommit();
+}
+
 const std::vector<OfflinePageItem>& RecentTabHelperTest::GetAllPages() {
   model()->GetAllPages(
       base::Bind(&RecentTabHelperTest::OnGetAllPagesDone,
                  weak_ptr_factory_.GetWeakPtr()));
   RunUntilIdle();
   return all_pages_;
 }
 
 void RecentTabHelperTest::OnGetAllPagesDone(
     const std::vector<OfflinePageItem>& result) {
   all_pages_ = result;
 }
 
 void RecentTabHelperTest::RunUntilIdle() {
   base::RunLoop().RunUntilIdle();
 }
 
 void RecentTabHelperTest::FastForwardSnapshotController() {
   const size_t kLongDelayMs = 100*1000;
   task_runner_->FastForwardBy(base::TimeDelta::FromMilliseconds(kLongDelayMs));
 }
 
 TEST_F(RecentTabHelperTest, Basic) {
   EXPECT_NE(nullptr, recent_tab_helper());
 }
 
 TEST_F(RecentTabHelperTest, SimpleCapture) {
-  const GURL url("http://mystery.site/foo.html");
-  NavigateAndCommit(url);
+  NavigateAndCommit(kTestPageUrl);
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
   GetAllPages();
   EXPECT_EQ(1U, all_pages().size());
-  EXPECT_EQ(url, all_pages()[0].url);
+  EXPECT_EQ(kTestPageUrl, all_pages()[0].url);
 }
 
 TEST_F(RecentTabHelperTest, TwoCaptures) {
-  const GURL url("http://mystery.site/foo.html");
-  NavigateAndCommit(url);
+  NavigateAndCommit(kTestPageUrl);
   // Triggers snapshot after a time delay.
   recent_tab_helper()->DocumentAvailableInMainFrame();
   RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
   EXPECT_EQ(0U, model_changed_count());
   // Move the snapshot controller's time forward so it gets past timeouts.
   FastForwardSnapshotController();
   RunUntilIdle();
   EXPECT_EQ(1U, model_changed_count());
   EXPECT_EQ(0U, model_removed_count());
   GetAllPages();
   EXPECT_EQ(1U, all_pages().size());
-  EXPECT_EQ(url, all_pages()[0].url);
+  EXPECT_EQ(kTestPageUrl, all_pages()[0].url);
 
   // Triggers snapshot immediately;
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   RunUntilIdle();
   EXPECT_EQ(2U, model_changed_count());
   EXPECT_EQ(1U, model_removed_count());
   // the same page should be simply overridden.
   GetAllPages();
   EXPECT_EQ(1U, all_pages().size());
-  EXPECT_EQ(url, all_pages()[0].url);
+  EXPECT_EQ(kTestPageUrl, all_pages()[0].url);
+}
+
+TEST_F(RecentTabHelperTest, NoCaptureOnErrorPage) {
+  FailLoad(kTestPageUrl);
+  recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
+  RunUntilIdle();
+  EXPECT_TRUE(model()->is_loaded());
+  GetAllPages();
+  EXPECT_EQ(0U, all_pages().size());
 }
 
 }  // namespace offline_pages