chrome/browser/offline_pages/offline_page_tab_helper_unittest.cc - chromium/src.git - Git at Google

 // Copyright 2017 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/offline_pages/offline_page_tab_helper.h"

 #include <memory>

 #include "base/bind.h"
 #include "base/metrics/histogram_functions.h"
 #include "base/test/metrics/histogram_tester.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/offline_pages/prefetch/prefetch_service_factory.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/offline_pages/core/model/offline_page_model_utils.h"
 #include "components/offline_pages/core/offline_page_item.h"
 #include "components/offline_pages/core/prefetch/offline_metrics_collector.h"
 #include "components/offline_pages/core/prefetch/prefetch_service.h"
 #include "components/offline_pages/core/prefetch/prefetch_service_test_taco.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/navigation_simulator.h"
 #include "content/public/test/test_renderer_host.h"
 #include "content/public/test/web_contents_tester.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace {
 const GURL kTestPageUrl("http://mystery.site/foo.html");
 const GURL kTestFileUrl("file://foo");
 const base::Time kTestMhtmlCreationTime =
     base::Time::FromJsTime(1522339419011L);
 const char kLoadResultUmaNameAsync[] =
     "OfflinePages.MhtmlLoadResult.async_loading";

 #if defined(OS_ANDROID)
 const GURL kTestContentUrl("content://foo");
 #endif

 const char kTestHeader[] = "reason=download";
 }  // namespace

 namespace offline_pages {
 namespace {

 using blink::mojom::MHTMLLoadResult;

 class TestMetricsCollector : public OfflineMetricsCollector {
  public:
   TestMetricsCollector() = default;
   ~TestMetricsCollector() override = default;

   // OfflineMetricsCollector implementation
   void OnAppStartupOrResume() override { app_startup_count_++; }
   void OnSuccessfulNavigationOnline() override {
     successful_online_navigations_count_++;
   }
   void OnSuccessfulNavigationOffline() override {
     successful_offline_navigations_count_++;
   }
   void OnPrefetchEnabled() override {}
   void OnSuccessfulPagePrefetch() override {}
   void OnPrefetchedPageOpened() override {}
   void ReportAccumulatedStats() override { report_stats_count_++; }

   int app_startup_count_ = 0;
   int successful_offline_navigations_count_ = 0;
   int successful_online_navigations_count_ = 0;
   int report_stats_count_ = 0;
 };

 // This is used by KeyedServiceFactory::SetTestingFactoryAndUse.
 std::unique_ptr<KeyedService> BuildTestPrefetchService(
     content::BrowserContext*) {
   auto taco = std::make_unique<PrefetchServiceTestTaco>();
   taco->SetOfflineMetricsCollector(std::make_unique<TestMetricsCollector>());
   return taco->CreateAndReturnPrefetchService();
 }

 class OfflinePageTabHelperTest : public content::RenderViewHostTestHarness {
  public:
   OfflinePageTabHelperTest();
   ~OfflinePageTabHelperTest() override {}

   void SetUp() override;
   void TearDown() override;
   content::BrowserContext* CreateBrowserContext() override;

   void CreateNavigationSimulator(const GURL& url);

   void SimulateOfflinePageLoad(const GURL& mhtml_url,
                                base::Time mhtml_creation_time,
                                MHTMLLoadResult load_result);

   OfflinePageTabHelper* tab_helper() const { return tab_helper_; }
   PrefetchService* prefetch_service() const { return prefetch_service_; }
   content::NavigationSimulator* navigation_simulator() {
     return navigation_simulator_.get();
   }
   TestMetricsCollector* metrics() const {
     return static_cast<TestMetricsCollector*>(
         prefetch_service_->GetOfflineMetricsCollector());
   }

  private:
   OfflinePageTabHelper* tab_helper_;   // Owned by WebContents.
   PrefetchService* prefetch_service_;  // Keyed Service.
   std::unique_ptr<content::NavigationSimulator> navigation_simulator_;

   base::WeakPtrFactory<OfflinePageTabHelperTest> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(OfflinePageTabHelperTest);
 };

 OfflinePageTabHelperTest::OfflinePageTabHelperTest()
     : tab_helper_(nullptr), weak_ptr_factory_(this) {}

 void OfflinePageTabHelperTest::SetUp() {
   content::RenderViewHostTestHarness::SetUp();

   PrefetchServiceFactory::GetInstance()->SetTestingFactoryAndUse(
       browser_context(), base::BindRepeating(&BuildTestPrefetchService));
   prefetch_service_ =
       PrefetchServiceFactory::GetForBrowserContext(browser_context());

   OfflinePageTabHelper::CreateForWebContents(web_contents());
   tab_helper_ = OfflinePageTabHelper::FromWebContents(web_contents());
 }

 void OfflinePageTabHelperTest::TearDown() {
   content::RenderViewHostTestHarness::TearDown();
 }

 content::BrowserContext* OfflinePageTabHelperTest::CreateBrowserContext() {
   TestingProfile::Builder builder;
   return builder.Build().release();
 }

 void OfflinePageTabHelperTest::CreateNavigationSimulator(const GURL& url) {
   navigation_simulator_ =
       content::NavigationSimulator::CreateBrowserInitiated(url, web_contents());
   navigation_simulator_->SetTransition(ui::PAGE_TRANSITION_LINK);
 }

 void OfflinePageTabHelperTest::SimulateOfflinePageLoad(
     const GURL& mhtml_url,
     base::Time mhtml_creation_time,
     MHTMLLoadResult load_result) {
   tab_helper()->SetCurrentTargetFrameForTest(web_contents()->GetMainFrame());

   // Simulate navigation
   CreateNavigationSimulator(kTestFileUrl);
   navigation_simulator()->Start();

   OfflinePageItem offlinePage(mhtml_url, 0, ClientId("async_loading", "1234"),
                               base::FilePath(), 0, mhtml_creation_time);
   OfflinePageHeader offlineHeader(kTestHeader);
   tab_helper()->SetOfflinePage(
       offlinePage, offlineHeader,
       OfflinePageTrustedState::TRUSTED_AS_IN_INTERNAL_DIR, false);

   navigation_simulator()->SetContentsMimeType("multipart/related");

   tab_helper()->NotifyMhtmlPageLoadAttempted(load_result, mhtml_url,
                                              mhtml_creation_time);
   navigation_simulator()->Commit();
 }

 // Checks the test setup.
 TEST_F(OfflinePageTabHelperTest, InitialSetup) {
   CreateNavigationSimulator(kTestPageUrl);
   EXPECT_NE(nullptr, tab_helper());
   EXPECT_NE(nullptr, prefetch_service());
   EXPECT_NE(nullptr, prefetch_service()->GetOfflineMetricsCollector());
   EXPECT_EQ(metrics(), prefetch_service()->GetOfflineMetricsCollector());
   EXPECT_EQ(0, metrics()->app_startup_count_);
   EXPECT_EQ(0, metrics()->successful_online_navigations_count_);
   EXPECT_EQ(0, metrics()->successful_offline_navigations_count_);
   EXPECT_EQ(0, metrics()->report_stats_count_);
 }

 TEST_F(OfflinePageTabHelperTest, MetricsStartNavigation) {
   CreateNavigationSimulator(kTestPageUrl);
   // This causes WCO::DidStartNavigation()
   navigation_simulator()->Start();

   EXPECT_EQ(1, metrics()->app_startup_count_);
   EXPECT_EQ(0, metrics()->successful_online_navigations_count_);
   EXPECT_EQ(0, metrics()->successful_offline_navigations_count_);
   EXPECT_EQ(0, metrics()->report_stats_count_);
 }

 TEST_F(OfflinePageTabHelperTest, MetricsOnlineNavigation) {
   CreateNavigationSimulator(kTestPageUrl);
   navigation_simulator()->Start();
   navigation_simulator()->Commit();

   EXPECT_EQ(1, metrics()->app_startup_count_);
   EXPECT_EQ(1, metrics()->successful_online_navigations_count_);
   EXPECT_EQ(0, metrics()->successful_offline_navigations_count_);
   // Since this is online navigation, request to send data should be made.
   EXPECT_EQ(1, metrics()->report_stats_count_);
 }

 TEST_F(OfflinePageTabHelperTest, MetricsOfflineNavigation) {
   CreateNavigationSimulator(kTestPageUrl);
   navigation_simulator()->Start();

   // Simulate offline interceptor loading an offline page instead.
   OfflinePageItem offlinePage(kTestPageUrl, 0, ClientId(), base::FilePath(), 0);
   OfflinePageHeader offlineHeader;
   tab_helper()->SetOfflinePage(
       offlinePage, offlineHeader,
       OfflinePageTrustedState::TRUSTED_AS_IN_INTERNAL_DIR, false);
   navigation_simulator()->SetContentsMimeType("multipart/related");

   navigation_simulator()->Commit();

   EXPECT_EQ(1, metrics()->app_startup_count_);
   EXPECT_EQ(0, metrics()->successful_online_navigations_count_);
   EXPECT_EQ(1, metrics()->successful_offline_navigations_count_);
   // During offline navigation, request to send data should not be made.
   EXPECT_EQ(0, metrics()->report_stats_count_);
 }

 TEST_F(OfflinePageTabHelperTest, TrustedInternalOfflinePage) {
   CreateNavigationSimulator(kTestPageUrl);
   navigation_simulator()->Start();

   OfflinePageItem offlinePage(kTestPageUrl, 0, ClientId(), base::FilePath(), 0);
   OfflinePageHeader offlineHeader(kTestHeader);
   tab_helper()->SetOfflinePage(
       offlinePage, offlineHeader,
       OfflinePageTrustedState::TRUSTED_AS_IN_INTERNAL_DIR, false);
   navigation_simulator()->SetContentsMimeType("multipart/related");
   navigation_simulator()->Commit();

   ASSERT_NE(nullptr, tab_helper()->offline_page());
   EXPECT_EQ(kTestPageUrl, tab_helper()->offline_page()->url);
   EXPECT_EQ(OfflinePageTrustedState::TRUSTED_AS_IN_INTERNAL_DIR,
             tab_helper()->trusted_state());
   EXPECT_TRUE(tab_helper()->IsShowingTrustedOfflinePage());
   EXPECT_EQ(OfflinePageHeader::Reason::DOWNLOAD,
             tab_helper()->offline_header().reason);
 }

 TEST_F(OfflinePageTabHelperTest, TrustedPublicOfflinePage) {
   CreateNavigationSimulator(kTestPageUrl);
   navigation_simulator()->Start();

   OfflinePageItem offlinePage(kTestPageUrl, 0, ClientId(), base::FilePath(), 0);
   OfflinePageHeader offlineHeader(kTestHeader);
   tab_helper()->SetOfflinePage(
       offlinePage, offlineHeader,
       OfflinePageTrustedState::TRUSTED_AS_UNMODIFIED_AND_IN_PUBLIC_DIR, false);
   navigation_simulator()->SetContentsMimeType("multipart/related");
   navigation_simulator()->Commit();

   ASSERT_NE(nullptr, tab_helper()->offline_page());
   EXPECT_EQ(kTestPageUrl, tab_helper()->offline_page()->url);
   EXPECT_EQ(OfflinePageTrustedState::TRUSTED_AS_UNMODIFIED_AND_IN_PUBLIC_DIR,
             tab_helper()->trusted_state());
   EXPECT_TRUE(tab_helper()->IsShowingTrustedOfflinePage());
   EXPECT_EQ(OfflinePageHeader::Reason::DOWNLOAD,
             tab_helper()->offline_header().reason);
 }

 TEST_F(OfflinePageTabHelperTest, UntrustedOfflinePageForFileUrl) {
   CreateNavigationSimulator(kTestFileUrl);
   navigation_simulator()->Start();
   navigation_simulator()->SetContentsMimeType("multipart/related");
   navigation_simulator()->Commit();

   ASSERT_NE(nullptr, tab_helper()->offline_page());
   EXPECT_EQ(OfflinePageTrustedState::UNTRUSTED, tab_helper()->trusted_state());
   EXPECT_FALSE(tab_helper()->IsShowingTrustedOfflinePage());
   EXPECT_EQ(OfflinePageHeader::Reason::NONE,
             tab_helper()->offline_header().reason);
 }

 #if defined(OS_ANDROID)
 TEST_F(OfflinePageTabHelperTest,
        UntrustedOfflinePageForContentUrlWithMultipartRelatedType) {
   CreateNavigationSimulator(kTestContentUrl);
   navigation_simulator()->Start();
   navigation_simulator()->SetContentsMimeType("multipart/related");
   navigation_simulator()->Commit();

   ASSERT_NE(nullptr, tab_helper()->offline_page());
   EXPECT_EQ(OfflinePageTrustedState::UNTRUSTED, tab_helper()->trusted_state());
   EXPECT_FALSE(tab_helper()->IsShowingTrustedOfflinePage());
   EXPECT_EQ(OfflinePageHeader::Reason::NONE,
             tab_helper()->offline_header().reason);
 }

 TEST_F(OfflinePageTabHelperTest,
        UntrustedOfflinePageForContentUrlWithMessageRfc822Type) {
   CreateNavigationSimulator(kTestContentUrl);
   navigation_simulator()->Start();
   navigation_simulator()->SetContentsMimeType("message/rfc822");
   navigation_simulator()->Commit();

   ASSERT_NE(nullptr, tab_helper()->offline_page());
   EXPECT_EQ(OfflinePageTrustedState::UNTRUSTED, tab_helper()->trusted_state());
   EXPECT_FALSE(tab_helper()->IsShowingTrustedOfflinePage());
   EXPECT_EQ(OfflinePageHeader::Reason::NONE,
             tab_helper()->offline_header().reason);
 }
 #endif

 TEST_F(OfflinePageTabHelperTest, TestNotifyMhtmlPageLoadAttempted_Success) {
   GURL mhtml_url("https://www.example.com");

   // Simulate navigation and check UMA reporting.
   base::HistogramTester histogram_tester;
   SimulateOfflinePageLoad(mhtml_url, kTestMhtmlCreationTime,
                           MHTMLLoadResult::kSuccess);
   histogram_tester.ExpectUniqueSample(kLoadResultUmaNameAsync,
                                       MHTMLLoadResult::kSuccess, 1);

   EXPECT_EQ(OfflinePageTrustedState::TRUSTED_AS_IN_INTERNAL_DIR,
             tab_helper()->trusted_state());
   EXPECT_TRUE(tab_helper()->IsShowingTrustedOfflinePage());
   EXPECT_EQ(OfflinePageHeader::Reason::DOWNLOAD,
             tab_helper()->offline_header().reason);

   const OfflinePageItem* offline_page = tab_helper()->offline_page();
   ASSERT_NE(nullptr, offline_page);
   EXPECT_EQ(mhtml_url, offline_page->url);
   EXPECT_EQ(kTestMhtmlCreationTime, offline_page->creation_time);
 }

 TEST_F(OfflinePageTabHelperTest,
        TestNotifyMhtmlPageLoadAttempted_BadUrlScheme) {
   GURL mhtml_url("sftp://www.example.com");

   base::HistogramTester histogram_tester;
   SimulateOfflinePageLoad(mhtml_url, kTestMhtmlCreationTime,
                           MHTMLLoadResult::kUrlSchemeNotAllowed);
   histogram_tester.ExpectUniqueSample(kLoadResultUmaNameAsync,
                                       MHTMLLoadResult::kUrlSchemeNotAllowed, 1);

   EXPECT_EQ(OfflinePageTrustedState::TRUSTED_AS_IN_INTERNAL_DIR,
             tab_helper()->trusted_state());
   EXPECT_TRUE(tab_helper()->IsShowingTrustedOfflinePage());
   EXPECT_EQ(OfflinePageHeader::Reason::DOWNLOAD,
             tab_helper()->offline_header().reason);

   const OfflinePageItem* offline_page = tab_helper()->offline_page();
   EXPECT_EQ(mhtml_url, offline_page->url);
   EXPECT_EQ(kTestMhtmlCreationTime, offline_page->creation_time);
 }

 TEST_F(OfflinePageTabHelperTest,
        TestNotifyMhtmlPageLoadAttempted_MhtmlEmptyFile) {
   // Test empty file. For now, there's no need to actually load an empty file
   // since we're calling NotifyMhtmlPageLoadAttempted directly with
   // MHTMLLoadResult::kEmptyFile.
   GURL mhtml_url("https://www.example.com");

   base::HistogramTester histogram_tester;
   SimulateOfflinePageLoad(mhtml_url, kTestMhtmlCreationTime,
                           MHTMLLoadResult::kEmptyFile);
   histogram_tester.ExpectUniqueSample(kLoadResultUmaNameAsync,
                                       MHTMLLoadResult::kEmptyFile, 1);
 }

 TEST_F(OfflinePageTabHelperTest,
        TestNotifyMhtmlPageLoadAttempted_MhtmlInvalidArchive) {
   GURL mhtml_url("https://www.example.com");

   base::HistogramTester histogram_tester;
   SimulateOfflinePageLoad(mhtml_url, kTestMhtmlCreationTime,
                           MHTMLLoadResult::kInvalidArchive);
   histogram_tester.ExpectUniqueSample(kLoadResultUmaNameAsync,
                                       MHTMLLoadResult::kInvalidArchive, 1);
 }

 TEST_F(OfflinePageTabHelperTest,
        TestNotifyMhtmlPageLoadAttempted_MhtmlMissingMainResource) {
   GURL mhtml_url("https://www.example.com");

   base::HistogramTester histogram_tester;
   SimulateOfflinePageLoad(mhtml_url, kTestMhtmlCreationTime,
                           MHTMLLoadResult::kMissingMainResource);
   histogram_tester.ExpectUniqueSample(kLoadResultUmaNameAsync,
                                       MHTMLLoadResult::kMissingMainResource, 1);
 }

 TEST_F(OfflinePageTabHelperTest, TestNotifyMhtmlPageLoadAttempted_Untrusted) {
   GURL mhtml_url("https://www.example.com");
   base::HistogramTester histogram_tester;

   tab_helper()->SetCurrentTargetFrameForTest(web_contents()->GetMainFrame());

   // Simulate navigation
   CreateNavigationSimulator(kTestFileUrl);
   navigation_simulator()->Start();

   // We force use of the untrusted page histogram by using an empty namespace.
   OfflinePageItem offlinePage(mhtml_url, 0, ClientId("", "1234"),
                               base::FilePath(), 0, kTestMhtmlCreationTime);
   OfflinePageHeader offlineHeader(kTestHeader);
   tab_helper()->SetOfflinePage(offlinePage, offlineHeader,
                                OfflinePageTrustedState::UNTRUSTED, false);

   navigation_simulator()->SetContentsMimeType("multipart/related");

   tab_helper()->NotifyMhtmlPageLoadAttempted(MHTMLLoadResult::kSuccess,
                                              mhtml_url, kTestMhtmlCreationTime);
   navigation_simulator()->Commit();

   // Check histogram
   histogram_tester.ExpectUniqueSample("OfflinePages.MhtmlLoadResultUntrusted",
                                       MHTMLLoadResult::kSuccess, 1);
 }

 }  // namespace
 }  // namespace offline_pages
	// Copyright 2017 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/offline_pages/offline_page_tab_helper.h"

	#include <memory>

	#include "base/bind.h"
	#include "base/metrics/histogram_functions.h"
	#include "base/test/metrics/histogram_tester.h"
	#include "base/threading/thread_task_runner_handle.h"
	#include "build/build_config.h"
	#include "chrome/browser/offline_pages/prefetch/prefetch_service_factory.h"
	#include "chrome/test/base/testing_profile.h"
	#include "components/offline_pages/core/model/offline_page_model_utils.h"
	#include "components/offline_pages/core/offline_page_item.h"
	#include "components/offline_pages/core/prefetch/offline_metrics_collector.h"
	#include "components/offline_pages/core/prefetch/prefetch_service.h"
	#include "components/offline_pages/core/prefetch/prefetch_service_test_taco.h"
	#include "content/public/browser/web_contents.h"
	#include "content/public/test/navigation_simulator.h"
	#include "content/public/test/test_renderer_host.h"
	#include "content/public/test/web_contents_tester.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace {
	const GURL kTestPageUrl("http://mystery.site/foo.html");
	const GURL kTestFileUrl("file://foo");
	const base::Time kTestMhtmlCreationTime =
	base::Time::FromJsTime(1522339419011L);
	const char kLoadResultUmaNameAsync[] =
	"OfflinePages.MhtmlLoadResult.async_loading";

	#if defined(OS_ANDROID)
	const GURL kTestContentUrl("content://foo");
	#endif

	const char kTestHeader[] = "reason=download";
	} // namespace

	namespace offline_pages {
	namespace {

	using blink::mojom::MHTMLLoadResult;

	class TestMetricsCollector : public OfflineMetricsCollector {
	public:
	TestMetricsCollector() = default;
	~TestMetricsCollector() override = default;

	// OfflineMetricsCollector implementation
	void OnAppStartupOrResume() override { app_startup_count_++; }
	void OnSuccessfulNavigationOnline() override {
	successful_online_navigations_count_++;
	}
	void OnSuccessfulNavigationOffline() override {
	successful_offline_navigations_count_++;
	}
	void OnPrefetchEnabled() override {}
	void OnSuccessfulPagePrefetch() override {}
	void OnPrefetchedPageOpened() override {}
	void ReportAccumulatedStats() override { report_stats_count_++; }

	int app_startup_count_ = 0;
	int successful_offline_navigations_count_ = 0;
	int successful_online_navigations_count_ = 0;
	int report_stats_count_ = 0;
	};

	// This is used by KeyedServiceFactory::SetTestingFactoryAndUse.
	std::unique_ptr<KeyedService> BuildTestPrefetchService(
	content::BrowserContext*) {
	auto taco = std::make_unique<PrefetchServiceTestTaco>();
	taco->SetOfflineMetricsCollector(std::make_unique<TestMetricsCollector>());
	return taco->CreateAndReturnPrefetchService();
	}

	class OfflinePageTabHelperTest : public content::RenderViewHostTestHarness {
	public:
	OfflinePageTabHelperTest();
	~OfflinePageTabHelperTest() override {}

	void SetUp() override;
	void TearDown() override;
	content::BrowserContext* CreateBrowserContext() override;

	void CreateNavigationSimulator(const GURL& url);

	void SimulateOfflinePageLoad(const GURL& mhtml_url,
	base::Time mhtml_creation_time,
	MHTMLLoadResult load_result);

	OfflinePageTabHelper* tab_helper() const { return tab_helper_; }
	PrefetchService* prefetch_service() const { return prefetch_service_; }
	content::NavigationSimulator* navigation_simulator() {
	return navigation_simulator_.get();
	}
	TestMetricsCollector* metrics() const {
	return static_cast<TestMetricsCollector*>(
	prefetch_service_->GetOfflineMetricsCollector());
	}

	private:
	OfflinePageTabHelper* tab_helper_; // Owned by WebContents.
	PrefetchService* prefetch_service_; // Keyed Service.
	std::unique_ptr<content::NavigationSimulator> navigation_simulator_;

	base::WeakPtrFactory<OfflinePageTabHelperTest> weak_ptr_factory_;
	DISALLOW_COPY_AND_ASSIGN(OfflinePageTabHelperTest);
	};

	OfflinePageTabHelperTest::OfflinePageTabHelperTest()
	: tab_helper_(nullptr), weak_ptr_factory_(this) {}

	void OfflinePageTabHelperTest::SetUp() {
	content::RenderViewHostTestHarness::SetUp();

	PrefetchServiceFactory::GetInstance()->SetTestingFactoryAndUse(
	browser_context(), base::BindRepeating(&BuildTestPrefetchService));
	prefetch_service_ =
	PrefetchServiceFactory::GetForBrowserContext(browser_context());

	OfflinePageTabHelper::CreateForWebContents(web_contents());
	tab_helper_ = OfflinePageTabHelper::FromWebContents(web_contents());
	}

	void OfflinePageTabHelperTest::TearDown() {
	content::RenderViewHostTestHarness::TearDown();
	}

	content::BrowserContext* OfflinePageTabHelperTest::CreateBrowserContext() {
	TestingProfile::Builder builder;
	return builder.Build().release();
	}

	void OfflinePageTabHelperTest::CreateNavigationSimulator(const GURL& url) {
	navigation_simulator_ =
	content::NavigationSimulator::CreateBrowserInitiated(url, web_contents());
	navigation_simulator_->SetTransition(ui::PAGE_TRANSITION_LINK);
	}

	void OfflinePageTabHelperTest::SimulateOfflinePageLoad(
	const GURL& mhtml_url,
	base::Time mhtml_creation_time,
	MHTMLLoadResult load_result) {
	tab_helper()->SetCurrentTargetFrameForTest(web_contents()->GetMainFrame());

	// Simulate navigation
	CreateNavigationSimulator(kTestFileUrl);
	navigation_simulator()->Start();

	OfflinePageItem offlinePage(mhtml_url, 0, ClientId("async_loading", "1234"),
	base::FilePath(), 0, mhtml_creation_time);
	OfflinePageHeader offlineHeader(kTestHeader);
	tab_helper()->SetOfflinePage(
	offlinePage, offlineHeader,
	OfflinePageTrustedState::TRUSTED_AS_IN_INTERNAL_DIR, false);

	navigation_simulator()->SetContentsMimeType("multipart/related");

	tab_helper()->NotifyMhtmlPageLoadAttempted(load_result, mhtml_url,
	mhtml_creation_time);
	navigation_simulator()->Commit();
	}

	// Checks the test setup.
	TEST_F(OfflinePageTabHelperTest, InitialSetup) {
	CreateNavigationSimulator(kTestPageUrl);
	EXPECT_NE(nullptr, tab_helper());
	EXPECT_NE(nullptr, prefetch_service());
	EXPECT_NE(nullptr, prefetch_service()->GetOfflineMetricsCollector());
	EXPECT_EQ(metrics(), prefetch_service()->GetOfflineMetricsCollector());
	EXPECT_EQ(0, metrics()->app_startup_count_);
	EXPECT_EQ(0, metrics()->successful_online_navigations_count_);
	EXPECT_EQ(0, metrics()->successful_offline_navigations_count_);
	EXPECT_EQ(0, metrics()->report_stats_count_);
	}

	TEST_F(OfflinePageTabHelperTest, MetricsStartNavigation) {
	CreateNavigationSimulator(kTestPageUrl);
	// This causes WCO::DidStartNavigation()
	navigation_simulator()->Start();

	EXPECT_EQ(1, metrics()->app_startup_count_);
	EXPECT_EQ(0, metrics()->successful_online_navigations_count_);
	EXPECT_EQ(0, metrics()->successful_offline_navigations_count_);
	EXPECT_EQ(0, metrics()->report_stats_count_);
	}

	TEST_F(OfflinePageTabHelperTest, MetricsOnlineNavigation) {
	CreateNavigationSimulator(kTestPageUrl);
	navigation_simulator()->Start();
	navigation_simulator()->Commit();

	EXPECT_EQ(1, metrics()->app_startup_count_);
	EXPECT_EQ(1, metrics()->successful_online_navigations_count_);
	EXPECT_EQ(0, metrics()->successful_offline_navigations_count_);
	// Since this is online navigation, request to send data should be made.
	EXPECT_EQ(1, metrics()->report_stats_count_);
	}

	TEST_F(OfflinePageTabHelperTest, MetricsOfflineNavigation) {
	CreateNavigationSimulator(kTestPageUrl);
	navigation_simulator()->Start();

	// Simulate offline interceptor loading an offline page instead.
	OfflinePageItem offlinePage(kTestPageUrl, 0, ClientId(), base::FilePath(), 0);
	OfflinePageHeader offlineHeader;
	tab_helper()->SetOfflinePage(
	offlinePage, offlineHeader,
	OfflinePageTrustedState::TRUSTED_AS_IN_INTERNAL_DIR, false);
	navigation_simulator()->SetContentsMimeType("multipart/related");

	navigation_simulator()->Commit();

	EXPECT_EQ(1, metrics()->app_startup_count_);
	EXPECT_EQ(0, metrics()->successful_online_navigations_count_);
	EXPECT_EQ(1, metrics()->successful_offline_navigations_count_);
	// During offline navigation, request to send data should not be made.
	EXPECT_EQ(0, metrics()->report_stats_count_);
	}

	TEST_F(OfflinePageTabHelperTest, TrustedInternalOfflinePage) {
	CreateNavigationSimulator(kTestPageUrl);
	navigation_simulator()->Start();

	OfflinePageItem offlinePage(kTestPageUrl, 0, ClientId(), base::FilePath(), 0);
	OfflinePageHeader offlineHeader(kTestHeader);
	tab_helper()->SetOfflinePage(
	offlinePage, offlineHeader,
	OfflinePageTrustedState::TRUSTED_AS_IN_INTERNAL_DIR, false);
	navigation_simulator()->SetContentsMimeType("multipart/related");
	navigation_simulator()->Commit();

	ASSERT_NE(nullptr, tab_helper()->offline_page());
	EXPECT_EQ(kTestPageUrl, tab_helper()->offline_page()->url);
	EXPECT_EQ(OfflinePageTrustedState::TRUSTED_AS_IN_INTERNAL_DIR,
	tab_helper()->trusted_state());
	EXPECT_TRUE(tab_helper()->IsShowingTrustedOfflinePage());
	EXPECT_EQ(OfflinePageHeader::Reason::DOWNLOAD,
	tab_helper()->offline_header().reason);
	}

	TEST_F(OfflinePageTabHelperTest, TrustedPublicOfflinePage) {
	CreateNavigationSimulator(kTestPageUrl);
	navigation_simulator()->Start();

	OfflinePageItem offlinePage(kTestPageUrl, 0, ClientId(), base::FilePath(), 0);
	OfflinePageHeader offlineHeader(kTestHeader);
	tab_helper()->SetOfflinePage(
	offlinePage, offlineHeader,
	OfflinePageTrustedState::TRUSTED_AS_UNMODIFIED_AND_IN_PUBLIC_DIR, false);
	navigation_simulator()->SetContentsMimeType("multipart/related");
	navigation_simulator()->Commit();

	ASSERT_NE(nullptr, tab_helper()->offline_page());
	EXPECT_EQ(kTestPageUrl, tab_helper()->offline_page()->url);
	EXPECT_EQ(OfflinePageTrustedState::TRUSTED_AS_UNMODIFIED_AND_IN_PUBLIC_DIR,
	tab_helper()->trusted_state());
	EXPECT_TRUE(tab_helper()->IsShowingTrustedOfflinePage());
	EXPECT_EQ(OfflinePageHeader::Reason::DOWNLOAD,
	tab_helper()->offline_header().reason);
	}

	TEST_F(OfflinePageTabHelperTest, UntrustedOfflinePageForFileUrl) {
	CreateNavigationSimulator(kTestFileUrl);
	navigation_simulator()->Start();
	navigation_simulator()->SetContentsMimeType("multipart/related");
	navigation_simulator()->Commit();

	ASSERT_NE(nullptr, tab_helper()->offline_page());
	EXPECT_EQ(OfflinePageTrustedState::UNTRUSTED, tab_helper()->trusted_state());
	EXPECT_FALSE(tab_helper()->IsShowingTrustedOfflinePage());
	EXPECT_EQ(OfflinePageHeader::Reason::NONE,
	tab_helper()->offline_header().reason);
	}

	#if defined(OS_ANDROID)
	TEST_F(OfflinePageTabHelperTest,
	UntrustedOfflinePageForContentUrlWithMultipartRelatedType) {
	CreateNavigationSimulator(kTestContentUrl);
	navigation_simulator()->Start();
	navigation_simulator()->SetContentsMimeType("multipart/related");
	navigation_simulator()->Commit();

	ASSERT_NE(nullptr, tab_helper()->offline_page());
	EXPECT_EQ(OfflinePageTrustedState::UNTRUSTED, tab_helper()->trusted_state());
	EXPECT_FALSE(tab_helper()->IsShowingTrustedOfflinePage());
	EXPECT_EQ(OfflinePageHeader::Reason::NONE,
	tab_helper()->offline_header().reason);
	}

	TEST_F(OfflinePageTabHelperTest,
	UntrustedOfflinePageForContentUrlWithMessageRfc822Type) {
	CreateNavigationSimulator(kTestContentUrl);
	navigation_simulator()->Start();
	navigation_simulator()->SetContentsMimeType("message/rfc822");
	navigation_simulator()->Commit();

	ASSERT_NE(nullptr, tab_helper()->offline_page());
	EXPECT_EQ(OfflinePageTrustedState::UNTRUSTED, tab_helper()->trusted_state());
	EXPECT_FALSE(tab_helper()->IsShowingTrustedOfflinePage());
	EXPECT_EQ(OfflinePageHeader::Reason::NONE,
	tab_helper()->offline_header().reason);
	}
	#endif

	TEST_F(OfflinePageTabHelperTest, TestNotifyMhtmlPageLoadAttempted_Success) {
	GURL mhtml_url("https://www.example.com");

	// Simulate navigation and check UMA reporting.
	base::HistogramTester histogram_tester;
	SimulateOfflinePageLoad(mhtml_url, kTestMhtmlCreationTime,
	MHTMLLoadResult::kSuccess);
	histogram_tester.ExpectUniqueSample(kLoadResultUmaNameAsync,
	MHTMLLoadResult::kSuccess, 1);

	EXPECT_EQ(OfflinePageTrustedState::TRUSTED_AS_IN_INTERNAL_DIR,
	tab_helper()->trusted_state());
	EXPECT_TRUE(tab_helper()->IsShowingTrustedOfflinePage());
	EXPECT_EQ(OfflinePageHeader::Reason::DOWNLOAD,
	tab_helper()->offline_header().reason);

	const OfflinePageItem* offline_page = tab_helper()->offline_page();
	ASSERT_NE(nullptr, offline_page);
	EXPECT_EQ(mhtml_url, offline_page->url);
	EXPECT_EQ(kTestMhtmlCreationTime, offline_page->creation_time);
	}

	TEST_F(OfflinePageTabHelperTest,
	TestNotifyMhtmlPageLoadAttempted_BadUrlScheme) {
	GURL mhtml_url("sftp://www.example.com");

	base::HistogramTester histogram_tester;
	SimulateOfflinePageLoad(mhtml_url, kTestMhtmlCreationTime,
	MHTMLLoadResult::kUrlSchemeNotAllowed);
	histogram_tester.ExpectUniqueSample(kLoadResultUmaNameAsync,
	MHTMLLoadResult::kUrlSchemeNotAllowed, 1);

	EXPECT_EQ(OfflinePageTrustedState::TRUSTED_AS_IN_INTERNAL_DIR,
	tab_helper()->trusted_state());
	EXPECT_TRUE(tab_helper()->IsShowingTrustedOfflinePage());
	EXPECT_EQ(OfflinePageHeader::Reason::DOWNLOAD,
	tab_helper()->offline_header().reason);

	const OfflinePageItem* offline_page = tab_helper()->offline_page();
	EXPECT_EQ(mhtml_url, offline_page->url);
	EXPECT_EQ(kTestMhtmlCreationTime, offline_page->creation_time);
	}

	TEST_F(OfflinePageTabHelperTest,
	TestNotifyMhtmlPageLoadAttempted_MhtmlEmptyFile) {
	// Test empty file. For now, there's no need to actually load an empty file
	// since we're calling NotifyMhtmlPageLoadAttempted directly with
	// MHTMLLoadResult::kEmptyFile.
	GURL mhtml_url("https://www.example.com");

	base::HistogramTester histogram_tester;
	SimulateOfflinePageLoad(mhtml_url, kTestMhtmlCreationTime,
	MHTMLLoadResult::kEmptyFile);
	histogram_tester.ExpectUniqueSample(kLoadResultUmaNameAsync,
	MHTMLLoadResult::kEmptyFile, 1);
	}

	TEST_F(OfflinePageTabHelperTest,
	TestNotifyMhtmlPageLoadAttempted_MhtmlInvalidArchive) {
	GURL mhtml_url("https://www.example.com");

	base::HistogramTester histogram_tester;
	SimulateOfflinePageLoad(mhtml_url, kTestMhtmlCreationTime,
	MHTMLLoadResult::kInvalidArchive);
	histogram_tester.ExpectUniqueSample(kLoadResultUmaNameAsync,
	MHTMLLoadResult::kInvalidArchive, 1);
	}

	TEST_F(OfflinePageTabHelperTest,
	TestNotifyMhtmlPageLoadAttempted_MhtmlMissingMainResource) {
	GURL mhtml_url("https://www.example.com");

	base::HistogramTester histogram_tester;
	SimulateOfflinePageLoad(mhtml_url, kTestMhtmlCreationTime,
	MHTMLLoadResult::kMissingMainResource);
	histogram_tester.ExpectUniqueSample(kLoadResultUmaNameAsync,
	MHTMLLoadResult::kMissingMainResource, 1);
	}

	TEST_F(OfflinePageTabHelperTest, TestNotifyMhtmlPageLoadAttempted_Untrusted) {
	GURL mhtml_url("https://www.example.com");
	base::HistogramTester histogram_tester;

	tab_helper()->SetCurrentTargetFrameForTest(web_contents()->GetMainFrame());

	// Simulate navigation
	CreateNavigationSimulator(kTestFileUrl);
	navigation_simulator()->Start();

	// We force use of the untrusted page histogram by using an empty namespace.
	OfflinePageItem offlinePage(mhtml_url, 0, ClientId("", "1234"),
	base::FilePath(), 0, kTestMhtmlCreationTime);
	OfflinePageHeader offlineHeader(kTestHeader);
	tab_helper()->SetOfflinePage(offlinePage, offlineHeader,
	OfflinePageTrustedState::UNTRUSTED, false);

	navigation_simulator()->SetContentsMimeType("multipart/related");

	tab_helper()->NotifyMhtmlPageLoadAttempted(MHTMLLoadResult::kSuccess,
	mhtml_url, kTestMhtmlCreationTime);
	navigation_simulator()->Commit();

	// Check histogram
	histogram_tester.ExpectUniqueSample("OfflinePages.MhtmlLoadResultUntrusted",
	MHTMLLoadResult::kSuccess, 1);
	}

	} // namespace
	} // namespace offline_pages