// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/offline_pages/recent_tab_helper.h"

#include <memory>
#include <string>

#include "base/functional/bind.h"
#include "base/memory/raw_ptr.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/single_thread_task_runner.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_mock_time_message_loop_task_runner.h"
#include "chrome/browser/offline_pages/offline_page_model_factory.h"
#include "chrome/browser/offline_pages/request_coordinator_factory.h"
#include "chrome/browser/offline_pages/test_offline_page_model_builder.h"
#include "chrome/browser/offline_pages/test_request_coordinator_builder.h"
#include "chrome/browser/profiles/profile_key.h"
#include "chrome/test/base/chrome_render_view_host_test_harness.h"
#include "chrome/test/base/testing_profile.h"
#include "components/offline_pages/core/client_namespace_constants.h"
#include "components/offline_pages/core/offline_page_feature.h"
#include "components/offline_pages/core/offline_page_item.h"
#include "components/offline_pages/core/offline_page_model.h"
#include "components/offline_pages/core/offline_page_test_archiver.h"
#include "content/public/browser/web_contents.h"
#include "content/public/test/navigation_simulator.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/features.h"

namespace offline_pages {

namespace {

const int kTabId = 153;

}  // namespace

class TestDelegate: public RecentTabHelper::Delegate {
 public:
  const size_t kArchiveSizeToReport = 1234;

  explicit TestDelegate(
      OfflinePageTestArchiver::Observer* observer,
      int tab_id,
      bool tab_id_result);
  ~TestDelegate() override = default;

  std::unique_ptr<OfflinePageArchiver> CreatePageArchiver(
        content::WebContents* web_contents) override;
    // There is no expectations that tab_id is always present.
  bool GetTabId(content::WebContents* web_contents, int* tab_id) override;
  bool IsLowEndDevice() override { return is_low_end_device_; }
  bool IsCustomTab(content::WebContents* web_contents) override {
    return is_custom_tab_;
  }

  void set_archive_result(
      offline_pages::OfflinePageArchiver::ArchiverResult result) {
    archive_result_ = result;
  }

  void set_archive_size(int64_t size) { archive_size_ = size; }

  void SetAsLowEndDevice() { is_low_end_device_ = true; }

  void set_is_custom_tab(bool is_custom_tab) { is_custom_tab_ = is_custom_tab; }

 private:
  raw_ptr<OfflinePageTestArchiver::Observer> observer_;  // observer owns this.
  int tab_id_;
  bool tab_id_result_;

  // These values can be updated so that new OfflinePageTestArchiver instances
  // will return different results.
  offline_pages::OfflinePageArchiver::ArchiverResult archive_result_ =
      offline_pages::OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED;
  int64_t archive_size_ = kArchiveSizeToReport;
  bool is_low_end_device_ = false;
  bool is_custom_tab_ = false;
};

class RecentTabHelperTest
    : public ChromeRenderViewHostTestHarness,
      public OfflinePageModel::Observer,
      public OfflinePageTestArchiver::Observer {
 public:
  RecentTabHelperTest();

  RecentTabHelperTest(const RecentTabHelperTest&) = delete;
  RecentTabHelperTest& operator=(const RecentTabHelperTest&) = delete;

  ~RecentTabHelperTest() override = default;

  void SetUp() override;
  void TearDown() override;
  const std::vector<OfflinePageItem>& GetAllPages();

  void FailLoad(const GURL& url);

  // Runs main thread.
  void RunUntilIdle();
  // Advances main thread time to trigger the snapshot controller's timeouts.
  void FastForwardSnapshotController();

  void NavigateAndCommit(const GURL& url);
  void Reload();

  // Navigates to the URL and commit as if it has been typed in the address bar.
  // Note: we need this to simulate navigations to the same URL that more like a
  // reload and not same page. NavigateAndCommit simulates a click on a link
  // and when reusing the same URL that will be considered a same page
  // navigation.
  void NavigateAndCommitTyped(const GURL& url);

  // Navigates to the URL and commit as if a form had been submitted.
  void NavigateAndCommitPost(const GURL& url);

  ClientId NewDownloadClientId();

  RecentTabHelper* recent_tab_helper() const { return recent_tab_helper_; }

  OfflinePageModel* model() const { return model_; }

  TestDelegate* default_test_delegate() { return default_test_delegate_; }

  base::HistogramTester* histogram_tester() { return histogram_tester_.get(); }

  // Returns a OfflinePageItem pointer from |all_pages| that matches the
  // provided |offline_id|. If a match is not found returns nullptr.
  const OfflinePageItem* FindPageForOfflineId(int64_t offline_id) {
    for (const OfflinePageItem& page : GetAllPages()) {
      if (page.offline_id == offline_id)
        return &page;
    }
    return nullptr;
  }

  size_t page_added_count() { return page_added_count_; }
  size_t model_removed_count() { return model_removed_count_; }

  // OfflinePageModel::Observer
  void OfflinePageModelLoaded(OfflinePageModel* model) override {
    all_pages_needs_updating_ = true;
  }
  void OfflinePageAdded(OfflinePageModel* model,
                        const OfflinePageItem& added_page) override {
    page_added_count_++;
    all_pages_needs_updating_ = true;
  }
  void OfflinePageDeleted(const OfflinePageItem& item) override {
    model_removed_count_++;
    all_pages_needs_updating_ = true;
  }

  // OfflinePageTestArchiver::Observer
  void SetLastPathCreatedByArchiver(const base::FilePath& file_path) override {}

 private:
  void StartAndCommitNavigation(
      std::unique_ptr<content::NavigationSimulator> simulator);

  void OnGetAllPagesDone(const std::vector<OfflinePageItem>& result);

  raw_ptr<RecentTabHelper> recent_tab_helper_;   // Owned by WebContents.
  raw_ptr<OfflinePageModel> model_;              // Keyed service.
  raw_ptr<TestDelegate> default_test_delegate_;  // Created at SetUp.
  size_t page_added_count_;
  size_t model_removed_count_;
  std::vector<OfflinePageItem> all_pages_;
  bool all_pages_needs_updating_;
  std::unique_ptr<base::HistogramTester> histogram_tester_;

  // Mocks the RenderViewHostTestHarness' main thread runner. Needs to be delay
  // initialized in SetUp() -- can't be a simple member -- since
  // RenderViewHostTestHarness only initializes its main thread environment in
  // its SetUp() :(.
  std::unique_ptr<base::ScopedMockTimeMessageLoopTaskRunner>
      mocked_main_runner_;

  base::WeakPtrFactory<RecentTabHelperTest> weak_ptr_factory_{this};
};

TestDelegate::TestDelegate(
    OfflinePageTestArchiver::Observer* observer,
    int tab_id,
    bool tab_id_result)
    : observer_(observer),
      tab_id_(tab_id),
      tab_id_result_(tab_id_result) {
}

std::unique_ptr<OfflinePageArchiver> TestDelegate::CreatePageArchiver(
    content::WebContents* web_contents) {
  std::unique_ptr<OfflinePageTestArchiver> archiver(new OfflinePageTestArchiver(
      observer_, web_contents->GetLastCommittedURL(), archive_result_,
      std::u16string(), kArchiveSizeToReport, std::string(),
      base::SingleThreadTaskRunner::GetCurrentDefault()));
  return std::move(archiver);
}

// There is no expectations that tab_id is always present.
bool TestDelegate::GetTabId(content::WebContents* web_contents, int* tab_id) {
  *tab_id = tab_id_;
  return tab_id_result_;
}

RecentTabHelperTest::RecentTabHelperTest()
    : recent_tab_helper_(nullptr),
      model_(nullptr),
      default_test_delegate_(nullptr),
      page_added_count_(0),
      model_removed_count_(0),
      all_pages_needs_updating_(true) {}

void RecentTabHelperTest::SetUp() {
  ChromeRenderViewHostTestHarness::SetUp();

  mocked_main_runner_ =
      std::make_unique<base::ScopedMockTimeMessageLoopTaskRunner>();

  // Sets up the factories for testing.
  OfflinePageModelFactory::GetInstance()->SetTestingFactoryAndUse(
      profile()->GetProfileKey(),
      base::BindRepeating(&BuildTestOfflinePageModel));
  RunUntilIdle();
  RequestCoordinatorFactory::GetInstance()->SetTestingFactoryAndUse(
      profile(), base::BindRepeating(&BuildTestRequestCoordinator));
  RunUntilIdle();

  RecentTabHelper::CreateForWebContents(web_contents());
  recent_tab_helper_ = RecentTabHelper::FromWebContents(web_contents());

  std::unique_ptr<TestDelegate> test_delegate(
      new TestDelegate(this, kTabId, true));
  default_test_delegate_ = test_delegate.get();
  recent_tab_helper_->SetDelegate(std::move(test_delegate));

  model_ = OfflinePageModelFactory::GetForBrowserContext(browser_context());
  model_->AddObserver(this);

  histogram_tester_ = std::make_unique<base::HistogramTester>();
}

void RecentTabHelperTest::TearDown() {
  mocked_main_runner_.reset();
  ChromeRenderViewHostTestHarness::TearDown();
}

void RecentTabHelperTest::FailLoad(const GURL& url) {
  content::NavigationSimulator::NavigateAndFailFromBrowser(
      web_contents(), url, net::ERR_INTERNET_DISCONNECTED);
}

const std::vector<OfflinePageItem>& RecentTabHelperTest::GetAllPages() {
  if (all_pages_needs_updating_) {
    model()->GetAllPages(base::BindOnce(&RecentTabHelperTest::OnGetAllPagesDone,
                                        weak_ptr_factory_.GetWeakPtr()));
    RunUntilIdle();
    all_pages_needs_updating_ = false;
  }
  return all_pages_;
}

void RecentTabHelperTest::OnGetAllPagesDone(
    const std::vector<OfflinePageItem>& result) {
  all_pages_ = result;
}

void RecentTabHelperTest::RunUntilIdle() {
  (*mocked_main_runner_)->RunUntilIdle();
}

void RecentTabHelperTest::FastForwardSnapshotController() {
  constexpr base::TimeDelta kLongDelay = base::Seconds(100);
  (*mocked_main_runner_)->FastForwardBy(kLongDelay);
}

void RecentTabHelperTest::StartAndCommitNavigation(
    std::unique_ptr<content::NavigationSimulator> simulator) {
  simulator->SetAutoAdvance(false);
  simulator->SetKeepLoading(true);
  simulator->Start();

  // Need to flush the task queue manually since there may be async tasks
  // spawned by navigation start that must finish before commit. Since this test
  // harness swaps out the main thread, NavigationSimulator cannot pump the task
  // queue itself to finish navigations.
  //
  // TODO(csharrison): This can probably be removed and replaced with either the
  // NavigationSimulator controlling the mock task runner, or by the snapshot
  // controller using a (mock) timer instead of PostDelayedTask.
  RunUntilIdle();
  simulator->Commit();
}

void RecentTabHelperTest::NavigateAndCommit(const GURL& url) {
  StartAndCommitNavigation(content::NavigationSimulator::CreateBrowserInitiated(
      url, web_contents()));
}

void RecentTabHelperTest::Reload() {
  auto simulator = content::NavigationSimulator::CreateBrowserInitiated(
      web_contents()->GetLastCommittedURL(), web_contents());
  simulator->SetReloadType(content::ReloadType::NORMAL);
  StartAndCommitNavigation(std::move(simulator));
}

void RecentTabHelperTest::NavigateAndCommitTyped(const GURL& url) {
  auto simulator =
      content::NavigationSimulator::CreateBrowserInitiated(url, web_contents());
  simulator->SetTransition(ui::PAGE_TRANSITION_TYPED);
  StartAndCommitNavigation(std::move(simulator));
}

void RecentTabHelperTest::NavigateAndCommitPost(const GURL& url) {
  auto simulator =
      content::NavigationSimulator::CreateRendererInitiated(url, main_rfh());
  simulator->SetMethod("POST");
  simulator->SetTransition(ui::PAGE_TRANSITION_FORM_SUBMIT);
  StartAndCommitNavigation(std::move(simulator));
}

ClientId RecentTabHelperTest::NewDownloadClientId() {
  static int counter = 0;
  return ClientId(kDownloadNamespace,
                  std::string("id") + base::NumberToString(++counter));
}

// Checks the test setup.
TEST_F(RecentTabHelperTest, RecentTabHelperInstanceExists) {
  EXPECT_NE(nullptr, recent_tab_helper());
}

// Fully loads a page then simulates the tab being hidden. Verifies that a
// snapshot is created only when the latter happens.
TEST_F(RecentTabHelperTest, LastNCaptureAfterLoad) {
  // Navigate and finish loading. Nothing should be saved.
  const GURL kTestUrl("http://mystery.site/foo.html");
  NavigateAndCommit(kTestUrl);

  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  // Move the snapshot controller's time forward so it gets past timeouts.
  FastForwardSnapshotController();
  EXPECT_EQ(0U, page_added_count());
  ASSERT_EQ(0U, GetAllPages().size());

  // Tab is hidden with a fully loaded page. A snapshot save should happen.
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(1U, page_added_count());
  ASSERT_EQ(1U, GetAllPages().size());
  EXPECT_EQ(kTestUrl, GetAllPages()[0].url);
  EXPECT_EQ(kLastNNamespace, GetAllPages()[0].client_id.name_space);
}

// Simulates the tab being hidden too early in the page loading so that a
// snapshot should not be created.
TEST_F(RecentTabHelperTest, NoLastNCaptureIfTabHiddenTooEarlyInPageLoad) {
  // Commit the navigation and hide the tab. Nothing should be saved.
  NavigateAndCommit(GURL("http://mystery.site/foo.html"));
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(0U, page_added_count());
  ASSERT_EQ(0U, GetAllPages().size());

  // Then allow the page to fully load. Nothing should be saved.
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  // Move the snapshot controller's time forward so it gets past timeouts.
  FastForwardSnapshotController();
  EXPECT_EQ(0U, page_added_count());
  ASSERT_EQ(0U, GetAllPages().size());
}

// Checks that WebContents with no tab IDs have snapshot requests properly
// ignored from both last_n and downloads.
TEST_F(RecentTabHelperTest, NoTabIdNoCapture) {
  // Create delegate that returns 'false' as TabId retrieval result.
  recent_tab_helper()->SetDelegate(
      std::make_unique<TestDelegate>(this, kTabId, false));

  NavigateAndCommit(GURL("http://mystery.site/foo.html"));
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  recent_tab_helper()->ObserveAndDownloadCurrentPage(NewDownloadClientId(),
                                                     123L, "");
  RunUntilIdle();
  // No page should be captured.
  EXPECT_EQ(0U, page_added_count());
  ASSERT_EQ(0U, GetAllPages().size());
}

// Checks that last_n is disabled if the device is low-end (aka svelte) but that
// download requests still work.
TEST_F(RecentTabHelperTest, LastNDisabledOnSvelte) {
  // Simulates a low end device.
  default_test_delegate()->SetAsLowEndDevice();

  // Navigate and finish loading then hide the tab. Nothing should be saved.
  NavigateAndCommit(GURL("http://mystery.site/foo.html"));

  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(0U, page_added_count());
  ASSERT_EQ(0U, GetAllPages().size());

  // But the following download request should work normally
  recent_tab_helper()->ObserveAndDownloadCurrentPage(NewDownloadClientId(),
                                                     123L, "");
  RunUntilIdle();
  EXPECT_EQ(1U, page_added_count());
  ASSERT_EQ(1U, GetAllPages().size());
}

// Checks that last_n will not save a snapshot while the tab is being presented
// as a custom tab. Download requests should be unaffected though.
TEST_F(RecentTabHelperTest, LastNWontSaveCustomTab) {
  // Simulates the tab running as a custom tab.
  default_test_delegate()->set_is_custom_tab(true);

  // Navigate and finish loading then hide the tab. Nothing should be saved.
  NavigateAndCommit(GURL("http://mystery.site/foo.html"));
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(0U, page_added_count());
  ASSERT_EQ(0U, GetAllPages().size());

  // But the following download request should work normally
  recent_tab_helper()->ObserveAndDownloadCurrentPage(NewDownloadClientId(),
                                                     123L, "");
  RunUntilIdle();
  EXPECT_EQ(1U, page_added_count());
  ASSERT_EQ(1U, GetAllPages().size());

  // Simulates the tab being transfered from the CustomTabActivity back to a
  // ChromeActivity.
  default_test_delegate()->set_is_custom_tab(false);

  // Upon the next hide a last_n snapshot should be saved.
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(2U, page_added_count());
  ASSERT_EQ(2U, GetAllPages().size());
}

// Triggers two last_n snapshot captures during a single page load. Should end
// up with one snapshot, the 1st being replaced by the 2nd.
TEST_F(RecentTabHelperTest, TwoCapturesSamePageLoad) {
  const GURL kTestUrl("http://mystery.site/foo.html");
  NavigateAndCommit(kTestUrl);

  // Set page loading state to the 1st snapshot-able stage. No capture so far.
  recent_tab_helper()->PrimaryMainDocumentElementAvailable();
  FastForwardSnapshotController();
  EXPECT_EQ(0U, page_added_count());

  // Tab is hidden and a snapshot should be saved.
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(1U, page_added_count());
  EXPECT_EQ(0U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
  EXPECT_EQ(kTestUrl, GetAllPages()[0].url);
  int64_t first_offline_id = GetAllPages()[0].offline_id;

  // Set page loading state to the 2nd and last snapshot-able stage. No new
  // capture should happen.
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  EXPECT_EQ(1U, page_added_count());
  EXPECT_EQ(0U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());

  // Tab is hidden again. At this point a higher quality snapshot is expected so
  // a new one should be captured and replace the previous one.
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(2U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
  EXPECT_EQ(kTestUrl, GetAllPages()[0].url);
  EXPECT_NE(first_offline_id, GetAllPages()[0].offline_id);
}

// Triggers two last_n captures during a single page load, where the 2nd capture
// fails. Should end up with one offline page (the 1st, successful snapshot
// should be kept).
// TODO(carlosk): re-enable once https://crbug.com/705079 is fixed.
TEST_F(RecentTabHelperTest, DISABLED_TwoCapturesWhere2ndFailsSamePageLoad) {
  // Navigate and load until the 1st stage. Tab hidden should trigger a capture.
  const GURL kTestUrl("http://mystery.site/foo.html");
  NavigateAndCommit(kTestUrl);
  recent_tab_helper()->PrimaryMainDocumentElementAvailable();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(1U, page_added_count());
  EXPECT_EQ(0U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
  EXPECT_EQ(kTestUrl, GetAllPages()[0].url);
  int64_t first_offline_id = GetAllPages()[0].offline_id;

  // Updates the delegate so that will make the second snapshot fail.
  default_test_delegate()->set_archive_size(-1);
  default_test_delegate()->set_archive_result(
      offline_pages::OfflinePageArchiver::ArchiverResult::
          ERROR_ARCHIVE_CREATION_FAILED);

  // Advance loading to the 2nd and final stage and then hide the tab. A new
  // capture is requested but its creation will fail. The exact same snapshot
  // from before should still be available.
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(1U, page_added_count());
  EXPECT_EQ(0U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
  EXPECT_EQ(kTestUrl, GetAllPages()[0].url);
  EXPECT_EQ(first_offline_id, GetAllPages()[0].offline_id);
}

// Triggers two last_n captures for two different loads of the same URL (aka
// reload). Should end up with a single snapshot (from the 2nd load).
TEST_F(RecentTabHelperTest, TwoCapturesDifferentPageLoadsSameUrl) {
  // Fully load the page. Hide the tab and check for a snapshot.
  const GURL kTestUrl("http://mystery.site/foo.html");
  NavigateAndCommit(kTestUrl);
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(1U, page_added_count());
  EXPECT_EQ(0U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
  EXPECT_EQ(kTestUrl, GetAllPages()[0].url);
  int64_t first_offline_id = GetAllPages()[0].offline_id;

  // Reload the same URL until the page is minimally loaded. The previous
  // snapshot should have been removed.
  NavigateAndCommitTyped(kTestUrl);
  recent_tab_helper()->PrimaryMainDocumentElementAvailable();
  FastForwardSnapshotController();
  EXPECT_EQ(1U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(0U, GetAllPages().size());

  // Hide the tab and a new snapshot should be taken.
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(2U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
  EXPECT_EQ(kTestUrl, GetAllPages()[0].url);
  EXPECT_NE(first_offline_id, GetAllPages()[0].offline_id);
}

// Triggers two last_n captures for two different page loads of the same URL
// (aka reload), where the 2nd capture fails. Should end up with no offline
// pages (a privacy driven decision).
TEST_F(RecentTabHelperTest, TwoCapturesWhere2ndFailsDifferentPageLoadsSameUrl) {
  // Fully load the page then hide the tab. A capture is expected.
  const GURL kTestUrl("http://mystery.site/foo.html");
  NavigateAndCommit(kTestUrl);
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(1U, page_added_count());
  EXPECT_EQ(0U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
  EXPECT_EQ(kTestUrl, GetAllPages()[0].url);

  // Updates the delegate so that will make the second snapshot fail.
  default_test_delegate()->set_archive_size(-1);
  default_test_delegate()->set_archive_result(
      offline_pages::OfflinePageArchiver::ArchiverResult::
          ERROR_ARCHIVE_CREATION_FAILED);

  // Fully load the page once more then hide the tab again. A capture happens
  // and fails but no snapshot should remain.
  NavigateAndCommitTyped(kTestUrl);
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(1U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(0U, GetAllPages().size());
}

// Triggers two last_n captures for two different page loads of different URLs.
// Should end up with a single snapshot of the last page.
TEST_F(RecentTabHelperTest, TwoCapturesDifferentPageLoadsDifferentUrls) {
  // Fully load the first URL then hide the tab and check for a snapshot.
  const GURL kTestUrl("http://mystery.site/foo.html");
  NavigateAndCommit(kTestUrl);

  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(1U, page_added_count());
  EXPECT_EQ(0U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
  EXPECT_EQ(kTestUrl, GetAllPages()[0].url);

  // Fully load the second URL. The previous snapshot should have been deleted.0
  const GURL kOtherUrl("http://crazy.site/foo_other.html");
  NavigateAndCommitTyped(kOtherUrl);

  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  EXPECT_EQ(1U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(0U, GetAllPages().size());

  // Then hide the tab and check for a single snapshot of the new page.
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(2U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
  EXPECT_EQ(kOtherUrl, GetAllPages()[0].url);
}

// Fully loads a page where last_n captures two snapshots. Then triggers two
// snapshot requests by downloads. Should end up with three offline pages: one
// from last_n (2nd replaces the 1st) and two from downloads (which shouldn't
// replace each other).
TEST_F(RecentTabHelperTest, TwoLastNAndTwoDownloadCapturesSamePage) {
  // Fully loads the page with intermediary steps where the tab is hidden. Then
  // check that two last_n snapshots were created but only one was kept.
  const GURL kTestUrl("http://mystery.site/foo.html");
  NavigateAndCommit(kTestUrl);
  recent_tab_helper()->PrimaryMainDocumentElementAvailable();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(2U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
  EXPECT_EQ(kTestUrl, GetAllPages()[0].url);
  int64_t first_offline_id = GetAllPages()[0].offline_id;

  // First snapshot request by downloads. Two offline pages are expected.
  const int64_t second_offline_id = first_offline_id + 1;
  const ClientId second_client_id = NewDownloadClientId();
  recent_tab_helper()->ObserveAndDownloadCurrentPage(second_client_id,
                                                     second_offline_id, "");
  RunUntilIdle();
  EXPECT_EQ(3U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(2U, GetAllPages().size());
  EXPECT_NE(nullptr, FindPageForOfflineId(first_offline_id));
  const OfflinePageItem* second_page = FindPageForOfflineId(second_offline_id);
  ASSERT_NE(nullptr, second_page);
  EXPECT_EQ(kTestUrl, second_page->url);
  EXPECT_EQ(second_client_id, second_page->client_id);

  // Second snapshot request by downloads. Three offline pages are expected.
  const int64_t third_offline_id = first_offline_id + 2;
  const ClientId third_client_id = NewDownloadClientId();
  recent_tab_helper()->ObserveAndDownloadCurrentPage(third_client_id,
                                                     third_offline_id, "");
  RunUntilIdle();
  EXPECT_EQ(4U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(3U, GetAllPages().size());
  EXPECT_NE(nullptr, FindPageForOfflineId(first_offline_id));
  EXPECT_NE(nullptr, FindPageForOfflineId(second_offline_id));
  const OfflinePageItem* third_page = FindPageForOfflineId(third_offline_id);
  ASSERT_NE(nullptr, third_page);
  EXPECT_EQ(kTestUrl, third_page->url);
  EXPECT_EQ(third_client_id, third_page->client_id);
}

// Simulates an error (disconnection) during the load of a page. Should end up
// with no offline pages for any requester.
TEST_F(RecentTabHelperTest, NoCaptureOnErrorPage) {
  FailLoad(GURL("http://mystery.site/foo.html"));
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  recent_tab_helper()->ObserveAndDownloadCurrentPage(NewDownloadClientId(),
                                                     123L, "");
  RunUntilIdle();
  ASSERT_EQ(0U, GetAllPages().size());
}

// Simulates a download request to offline the current page made early during
// loading. Should execute two captures but only the final one is kept.
TEST_F(RecentTabHelperTest, DownloadRequestEarlyInLoad) {
  // Commit the navigation and request the snapshot from downloads. No captures
  // so far.
  const GURL kTestUrl("http://mystery.site/foo.html");
  NavigateAndCommit(kTestUrl);
  const ClientId client_id = NewDownloadClientId();
  recent_tab_helper()->ObserveAndDownloadCurrentPage(client_id, 153L, "");
  FastForwardSnapshotController();
  ASSERT_EQ(0U, GetAllPages().size());

  // Minimally load the page. First capture should occur.
  recent_tab_helper()->PrimaryMainDocumentElementAvailable();
  FastForwardSnapshotController();
  ASSERT_EQ(1U, GetAllPages().size());
  const OfflinePageItem& early_page = GetAllPages()[0];
  EXPECT_EQ(kTestUrl, early_page.url);
  EXPECT_EQ(client_id, early_page.client_id);
  EXPECT_EQ(153L, early_page.offline_id);

  // Fully load the page. A second capture should replace the first one.
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  EXPECT_EQ(2U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
  const OfflinePageItem& later_page = GetAllPages()[0];
  EXPECT_EQ(kTestUrl, later_page.url);
  EXPECT_EQ(client_id, later_page.client_id);
  EXPECT_EQ(153L, later_page.offline_id);
}

// Simulates a download request to offline the current page made when the page
// is minimally loaded. Should execute two captures but only the final one is
// kept.
TEST_F(RecentTabHelperTest, DownloadRequestLaterInLoad) {
  const GURL kTestUrl("http://mystery.site/foo.html");
  NavigateAndCommit(kTestUrl);
  recent_tab_helper()->PrimaryMainDocumentElementAvailable();
  FastForwardSnapshotController();
  ASSERT_EQ(0U, GetAllPages().size());

  const ClientId client_id = NewDownloadClientId();
  recent_tab_helper()->ObserveAndDownloadCurrentPage(client_id, 153L, "");
  RunUntilIdle();
  ASSERT_EQ(1U, GetAllPages().size());
  const OfflinePageItem& page = GetAllPages()[0];
  EXPECT_EQ(kTestUrl, page.url);
  EXPECT_EQ(client_id, page.client_id);
  EXPECT_EQ(153L, page.offline_id);

  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  EXPECT_EQ(2U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
}

// Simulates a download request to offline the current page made after loading
// is completed. Should end up with one offline page.
TEST_F(RecentTabHelperTest, DownloadRequestAfterFullyLoad) {
  const GURL kTestUrl("http://mystery.site/foo.html");
  NavigateAndCommit(kTestUrl);
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  ASSERT_EQ(0U, GetAllPages().size());

  const ClientId client_id = NewDownloadClientId();
  recent_tab_helper()->ObserveAndDownloadCurrentPage(client_id, 153L, "");
  RunUntilIdle();
  ASSERT_EQ(1U, GetAllPages().size());
  const OfflinePageItem& page = GetAllPages()[0];
  EXPECT_EQ(kTestUrl, page.url);
  EXPECT_EQ(client_id, page.client_id);
  EXPECT_EQ(153L, page.offline_id);
  EXPECT_EQ("", page.request_origin);
}

// Simulates a download request to offline the current page made after loading
// is completed. Should end up with one offline page.
TEST_F(RecentTabHelperTest, DownloadRequestAfterFullyLoadWithOrigin) {
  const GURL kTestUrl("http://mystery.site/foo.html");
  NavigateAndCommit(kTestUrl);
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  ASSERT_EQ(0U, GetAllPages().size());

  const ClientId client_id = NewDownloadClientId();
  recent_tab_helper()->ObserveAndDownloadCurrentPage(client_id, 153L, "abc");
  RunUntilIdle();
  ASSERT_EQ(1U, GetAllPages().size());
  const OfflinePageItem& page = GetAllPages()[0];
  EXPECT_EQ(kTestUrl, page.url);
  EXPECT_EQ(client_id, page.client_id);
  EXPECT_EQ(153L, page.offline_id);
  EXPECT_EQ("abc", page.request_origin);
}

// Simulates requests coming from last_n and downloads at the same time for a
// fully loaded page.
TEST_F(RecentTabHelperTest, SimultaneousCapturesFromLastNAndDownloads) {
  const GURL kTestUrl("http://mystery.site/foo.html");
  NavigateAndCommit(kTestUrl);
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  const int64_t download_offline_id = 153L;
  const ClientId download_client_id = NewDownloadClientId();
  recent_tab_helper()->ObserveAndDownloadCurrentPage(download_client_id,
                                                     download_offline_id, "");
  RunUntilIdle();
  ASSERT_EQ(2U, GetAllPages().size());

  const OfflinePageItem* downloads_page =
      FindPageForOfflineId(download_offline_id);
  ASSERT_TRUE(downloads_page);
  EXPECT_EQ(kTestUrl, downloads_page->url);
  EXPECT_EQ(download_client_id, downloads_page->client_id);

  const OfflinePageItem& last_n_page =
      GetAllPages()[0].offline_id != download_offline_id ? GetAllPages()[0]
                                                         : GetAllPages()[1];
  EXPECT_EQ(kTestUrl, last_n_page.url);
  EXPECT_EQ(kLastNNamespace, last_n_page.client_id.name_space);
}

// Simulates multiple tab hidden events -- triggers for last_n snapshots --
// happening at the same loading stages. The duplicate events should create new
// snapshots (so that dynamic pages are properly persisted; navigation/loading
// signals are poor signals for those).
TEST_F(RecentTabHelperTest, DuplicateTabHiddenEventsShouldTriggerNewSnapshots) {
  NavigateAndCommit(GURL("http://mystery.site/foo.html"));
  recent_tab_helper()->PrimaryMainDocumentElementAvailable();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(1U, page_added_count());
  EXPECT_EQ(0U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());

  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(2U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());

  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(3U, page_added_count());
  EXPECT_EQ(2U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());

  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(4U, page_added_count());
  EXPECT_EQ(3U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
}

// Simulates multiple download requests and verifies that overlapping requests
// are ignored.
TEST_F(RecentTabHelperTest, OverlappingDownloadRequestsAreIgnored) {
  // Navigates and commits then make two download snapshot requests.
  NavigateAndCommit(GURL("http://mystery.site/foo.html"));
  const ClientId client_id_1 = NewDownloadClientId();
  const int64_t offline_id_1 = 153L;
  recent_tab_helper()->ObserveAndDownloadCurrentPage(client_id_1, offline_id_1,
                                                     "");
  recent_tab_helper()->ObserveAndDownloadCurrentPage(NewDownloadClientId(),
                                                     351L, "");

  // Finish loading the page. Only the first request should be executed.
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  EXPECT_EQ(1U, page_added_count());
  EXPECT_EQ(0U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
  const OfflinePageItem& fist_page = GetAllPages()[0];
  EXPECT_EQ(client_id_1, fist_page.client_id);
  EXPECT_EQ(offline_id_1, fist_page.offline_id);

  // Make two additional download snapshot requests. Again only the first should
  // generate a snapshot.
  const ClientId client_id_3 = NewDownloadClientId();
  const int64_t offline_id_3 = 789L;
  recent_tab_helper()->ObserveAndDownloadCurrentPage(client_id_3, offline_id_3,
                                                     "");
  recent_tab_helper()->ObserveAndDownloadCurrentPage(NewDownloadClientId(),
                                                     987L, "");
  RunUntilIdle();
  EXPECT_EQ(2U, page_added_count());
  EXPECT_EQ(0U, model_removed_count());
  ASSERT_EQ(2U, GetAllPages().size());
  const OfflinePageItem* second_page = FindPageForOfflineId(offline_id_3);
  ASSERT_TRUE(second_page);
  EXPECT_EQ(client_id_3, second_page->client_id);
  EXPECT_EQ(offline_id_3, second_page->offline_id);
}

// Simulates a same document navigation and checks we snapshot correctly with
// last_n and downloads.
TEST_F(RecentTabHelperTest, SaveSameDocumentNavigationSnapshots) {
  // Navigates and load fully then hide the tab so that a snapshot is created.
  const GURL kTestUrl("http://mystery.site/foo.html");
  NavigateAndCommit(kTestUrl);
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(1U, page_added_count());
  EXPECT_EQ(0U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());

  // Now navigates same page and check the results of hiding the tab again.
  // Another snapshot should be created to the updated URL.
  const GURL kTestPageUrlWithFragment(kTestUrl.spec() + "#aaa");
  NavigateAndCommit(kTestPageUrlWithFragment);
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(2U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
  EXPECT_EQ(kTestPageUrlWithFragment, GetAllPages()[0].url);

  // Now create a download request and check the snapshot is properly created.
  const ClientId client_id = NewDownloadClientId();
  const int64_t offline_id = 153L;
  recent_tab_helper()->ObserveAndDownloadCurrentPage(client_id, offline_id, "");
  RunUntilIdle();
  EXPECT_EQ(3U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(2U, GetAllPages().size());
  const OfflinePageItem* downloads_page = FindPageForOfflineId(offline_id);
  EXPECT_EQ(kTestPageUrlWithFragment, downloads_page->url);
  EXPECT_EQ(client_id, downloads_page->client_id);
  EXPECT_EQ(offline_id, downloads_page->offline_id);
}

// Tests that a page reloaded is tracked as an actual load and properly saved.
TEST_F(RecentTabHelperTest, ReloadIsTrackedAsNavigationAndSavedOnlyUponLoad) {
  // Navigates and load fully then hide the tab so that a snapshot is created.
  NavigateAndCommit(GURL("http://mystery.site/foo.html"));
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  ASSERT_EQ(1U, GetAllPages().size());

  // Starts a reload and hides the tab before it minimally load. The previous
  // snapshot should be removed.
  Reload();

  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(1U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(0U, GetAllPages().size());

  // Finish loading and hide the tab. A new snapshot should be created.
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(2U, page_added_count());
  EXPECT_EQ(1U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
}

// Checks that a closing tab doesn't trigger the creation of a snapshot. And
// also that if the closure is reverted, a snapshot is saved upon the next hide
// event.
TEST_F(RecentTabHelperTest, NoSaveIfTabIsClosing) {
  // Navigates and fully load then close and hide the tab. No snapshots are
  // expected.
  NavigateAndCommit(GURL("http://mystery.site/foo.html"));
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  // Note: These two next calls are always expected to happen in this order.
  recent_tab_helper()->WillCloseTab();
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(0U, page_added_count());
  EXPECT_EQ(0U, model_removed_count());
  ASSERT_EQ(0U, GetAllPages().size());

  // Simulates the page being restored and shown again, then hidden. At this
  // moment a snapshot should be created.
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::VISIBLE);
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(1U, page_added_count());
  EXPECT_EQ(0U, model_removed_count());
  ASSERT_EQ(1U, GetAllPages().size());
}

TEST_F(RecentTabHelperTest, NoSaveOfflinePageCacheForPost) {
  // Navigate and finish loading, then move the snapshot controller's time
  // forward so it gets past timeouts. Nothing should be saved.
  NavigateAndCommitPost(GURL("http://mystery.site/foo.html"));
  recent_tab_helper()->DocumentOnLoadCompletedInPrimaryMainFrame();
  FastForwardSnapshotController();
  ASSERT_EQ(0U, GetAllPages().size());

  // Tab is hidden with a fully loaded page. A snapshot save should not happen
  // due to the POST method - OfflinePageCache is disabled.
  recent_tab_helper()->OnVisibilityChanged(content::Visibility::HIDDEN);
  RunUntilIdle();
  EXPECT_EQ(0U, page_added_count());
  ASSERT_EQ(0U, GetAllPages().size());

  // A manual download should succeed despite being ineligible for OPC.
  recent_tab_helper()->ObserveAndDownloadCurrentPage(NewDownloadClientId(),
                                                     123L, "");
  RunUntilIdle();
  EXPECT_EQ(1U, page_added_count());
  ASSERT_EQ(1U, GetAllPages().size());
}

class RecentTabHelperFencedFrameTest : public RecentTabHelperTest {
 public:
  RecentTabHelperFencedFrameTest() {
    scoped_feature_list_.InitAndEnableFeatureWithParameters(
        blink::features::kFencedFrames, {{"implementation_type", "mparch"}});
  }
  ~RecentTabHelperFencedFrameTest() override = default;

  content::RenderFrameHost* CreateFencedFrame(
      content::RenderFrameHost* parent) {
    content::RenderFrameHost* fenced_frame =
        content::RenderFrameHostTester::For(parent)->AppendFencedFrame();
    return fenced_frame;
  }

 private:
  base::test::ScopedFeatureList scoped_feature_list_;
};

// Tests that FencedFrame does not change the current page quality via resetting
// the snapshot controller.
TEST_F(RecentTabHelperFencedFrameTest, FencedFrameDoesNotChangePageQuality) {
  // Navigate and finish loading, then move the snapshot controller's time
  // forward so it sets the current page quality to FAIR_AND_IMPROVING.
  NavigateAndCommitPost(GURL("http://mystery.site/foo.html"));

  recent_tab_helper()->PrimaryMainDocumentElementAvailable();
  FastForwardSnapshotController();

  EXPECT_EQ(recent_tab_helper()->snapshot_controller_->current_page_quality(),
            SnapshotController::PageQuality::FAIR_AND_IMPROVING);

  // Create a fenced frame.
  content::RenderFrameHostTester::For(main_rfh())
      ->InitializeRenderFrameIfNeeded();
  content::RenderFrameHost* fenced_frame_rfh = CreateFencedFrame(main_rfh());
  GURL kFencedFrameUrl("https://fencedframe.com");
  std::unique_ptr<content::NavigationSimulator> navigation_simulator =
      content::NavigationSimulator::CreateRendererInitiated(kFencedFrameUrl,
                                                            fenced_frame_rfh);
  navigation_simulator->Commit();
  EXPECT_TRUE(
      navigation_simulator->GetFinalRenderFrameHost()->IsFencedFrameRoot());

  // Navigating the fenced frame to the fenced frame url should not change the
  // current page quality to POOR.
  EXPECT_EQ(recent_tab_helper()->snapshot_controller_->current_page_quality(),
            SnapshotController::PageQuality::FAIR_AND_IMPROVING);
}

}  // namespace offline_pages