// Copyright 2015 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/offline_page_utils.h"
#include <stdint.h>
#include <optional>
#include <string>
#include <utility>
#include "base/command_line.h"
#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/location.h"
#include "base/run_loop.h"
#include "base/task/single_thread_task_runner.h"
#include "base/test/bind.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/simple_test_clock.h"
#include "base/time/time.h"
#include "build/build_config.h"
#include "chrome/browser/offline_pages/offline_page_model_factory.h"
#include "chrome/browser/offline_pages/offline_page_tab_helper.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/common/chrome_constants.h"
#include "chrome/test/base/testing_profile.h"
#include "components/offline_pages/core/background/request_coordinator.h"
#include "components/offline_pages/core/client_namespace_constants.h"
#include "components/offline_pages/core/model/offline_page_model_taskified.h"
#include "components/offline_pages/core/offline_clock.h"
#include "components/offline_pages/core/offline_page_feature.h"
#include "components/offline_pages/core/offline_page_model.h"
#include "components/offline_pages/core/offline_page_test_archiver.h"
#include "components/offline_pages/core/offline_page_types.h"
#include "components/offline_pages/core/test_scoped_offline_clock.h"
#include "content/public/browser/navigation_entry.h"
#include "content/public/browser/web_contents.h"
#include "content/public/test/browser_task_environment.h"
#include "net/base/filename_util.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"
#if BUILDFLAG(IS_ANDROID)
#include "base/test/test_timeouts.h"
#include "chrome/browser/download/android/mock_download_controller.h"
#include "components/gcm_driver/instance_id/instance_id_android.h"
#include "components/gcm_driver/instance_id/scoped_use_fake_instance_id_android.h"
#endif
namespace offline_pages {
namespace {
const int64_t kTestFileSize = 876543LL;
const char* kTestPage1ClientId = "1234";
const char* kTestPage2ClientId = "5678";
const char* kTestPage3ClientId = "7890";
const char* kTestPage4ClientId = "42";
void RunTasksForDuration(base::TimeDelta delta) {
base::RunLoop run_loop;
base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
FROM_HERE, run_loop.QuitClosure(), delta);
run_loop.Run();
}
} // namespace
class OfflinePageUtilsTest : public testing::Test,
public OfflinePageTestArchiver::Observer {
public:
OfflinePageUtilsTest();
~OfflinePageUtilsTest() override;
void SetUp() override;
void TearDown() override;
void SavePage(const GURL& url,
const ClientId& client_id,
std::unique_ptr<OfflinePageArchiver> archiver);
// Return number of matches found.
int FindRequestByNamespaceAndURL(const std::string& name_space,
const GURL& url);
size_t GetRequestCount() { return GetAllRequests().size(); }
// Wait until there are at least |min_request_count| requests.
void WaitForRequestMinCount(size_t min_request_count) {
for (;;) {
if (min_request_count <= GetRequestCount()) {
break;
}
RunTasksForDuration(base::Milliseconds(100));
}
}
RequestCoordinator* GetRequestCoordinator() {
return RequestCoordinatorFactory::GetForBrowserContext(profile());
}
OfflinePageUtils::DuplicateCheckResult CheckDuplicateDownloads(GURL url) {
OfflinePageUtils::DuplicateCheckResult result;
base::RunLoop run_loop;
auto quit = run_loop.QuitClosure();
auto on_done = [&](OfflinePageUtils::DuplicateCheckResult check_result) {
result = check_result;
quit.Run();
};
OfflinePageUtils::CheckDuplicateDownloads(
profile(), url, base::BindLambdaForTesting(on_done));
run_loop.Run();
return result;
}
std::optional<int64_t> GetCachedOfflinePageSizeBetween(
const base::Time& begin_time,
const base::Time& end_time) {
int64_t result;
base::RunLoop run_loop;
auto quit = run_loop.QuitClosure();
auto on_done = [&](int64_t size) {
result = size;
quit.Run();
};
if (!OfflinePageUtils::GetCachedOfflinePageSizeBetween(
profile(), base::BindLambdaForTesting(on_done), begin_time,
end_time)) {
return std::nullopt;
}
run_loop.Run();
return result;
}
// OfflinePageTestArchiver::Observer implementation:
void SetLastPathCreatedByArchiver(const base::FilePath& file_path) override {}
TestScopedOfflineClock* clock() { return &clock_; }
TestingProfile* profile() { return &profile_; }
content::WebContents* web_contents() const { return web_contents_.get(); }
void CreateCachedOfflinePages();
std::vector<std::unique_ptr<SavePageRequest>> GetAllRequests() {
base::RunLoop run_loop;
auto quit = run_loop.QuitClosure();
std::vector<std::unique_ptr<SavePageRequest>> result;
auto on_done = [&](std::vector<std::unique_ptr<SavePageRequest>> requests) {
result = std::move(requests);
quit.Run();
};
GetRequestCoordinator()->GetAllRequests(
base::BindLambdaForTesting(on_done));
run_loop.Run();
return result;
}
protected:
const GURL kTestPage1Url{"http://test.org/page1"};
const GURL kTestPage2Url{"http://test.org/page2"};
const GURL kTestPage3Url{"http://test.org/page3"};
const GURL kTestPage4Url{"http://test.org/page4"};
private:
void CreateOfflinePages();
void CreateRequests();
std::unique_ptr<OfflinePageTestArchiver> BuildArchiver(
const GURL& url,
const base::FilePath& file_name);
TestScopedOfflineClock clock_;
content::BrowserTaskEnvironment task_environment_;
TestingProfile profile_;
std::unique_ptr<content::WebContents> web_contents_;
base::test::ScopedFeatureList scoped_feature_list_;
#if BUILDFLAG(IS_ANDROID)
android::MockDownloadController download_controller_;
// OfflinePageTabHelper instantiates PrefetchService which in turn requests a
// fresh GCM token automatically. This causes the request to be done
// synchronously instead of with a posted task.
instance_id::InstanceIDAndroid::ScopedBlockOnAsyncTasksForTesting
block_async_;
#endif
};
OfflinePageUtilsTest::OfflinePageUtilsTest() = default;
OfflinePageUtilsTest::~OfflinePageUtilsTest() {}
void OfflinePageUtilsTest::SetUp() {
// Create a test web contents.
web_contents_ = content::WebContents::Create(
content::WebContents::CreateParams(profile()));
OfflinePageTabHelper::CreateForWebContents(web_contents_.get());
// Reset the value of the test clock.
clock_.SetNow(base::Time::Now());
// Set up the factory for testing.
OfflinePageModelFactory::GetInstance()->SetTestingFactoryAndUse(
profile_.GetProfileKey(),
base::BindRepeating(&BuildTestOfflinePageModel));
RequestCoordinatorFactory::GetInstance()->SetTestingFactoryAndUse(
&profile_, base::BindRepeating(&BuildTestRequestCoordinator));
// Make sure to create offline pages and requests.
CreateOfflinePages();
// TODO(harringtond): I was surprised this test creates requests in Setup(),
// we should avoid this to be less surprising.
CreateRequests();
// This is needed in order to skip the logic to request storage permission.
#if BUILDFLAG(IS_ANDROID)
DownloadControllerBase::SetDownloadControllerBase(&download_controller_);
#endif
}
void OfflinePageUtilsTest::TearDown() {
#if BUILDFLAG(IS_ANDROID)
DownloadControllerBase::SetDownloadControllerBase(nullptr);
#endif
}
void OfflinePageUtilsTest::SavePage(
const GURL& url,
const ClientId& client_id,
std::unique_ptr<OfflinePageArchiver> archiver) {
OfflinePageModel::SavePageParams save_page_params;
save_page_params.url = url;
save_page_params.client_id = client_id;
base::RunLoop run_loop;
auto save_page_done = [&](SavePageResult result, int64_t offline_id) {
run_loop.QuitClosure().Run();
};
OfflinePageModelFactory::GetForBrowserContext(profile())->SavePage(
save_page_params, std::move(archiver), web_contents_.get(),
base::BindLambdaForTesting(save_page_done));
run_loop.Run();
}
void OfflinePageUtilsTest::CreateOfflinePages() {
// Create page 1.
std::unique_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
kTestPage1Url, base::FilePath(FILE_PATH_LITERAL("page1.mhtml"))));
offline_pages::ClientId client_id;
client_id.name_space = kDownloadNamespace;
client_id.id = kTestPage1ClientId;
SavePage(kTestPage1Url, client_id, std::move(archiver));
// Create page 2.
archiver = BuildArchiver(kTestPage2Url,
base::FilePath(FILE_PATH_LITERAL("page2.mhtml")));
client_id.id = kTestPage2ClientId;
SavePage(kTestPage2Url, client_id, std::move(archiver));
}
void OfflinePageUtilsTest::CreateRequests() {
RequestCoordinator::SavePageLaterParams params;
params.url = kTestPage3Url;
params.client_id =
offline_pages::ClientId(kDownloadNamespace, kTestPage3ClientId);
base::RunLoop run_loop;
auto quit = run_loop.QuitClosure();
auto page_saved = [&](AddRequestResult ignored) { quit.Run(); };
GetRequestCoordinator()->SavePageLater(
params, base::BindLambdaForTesting(page_saved));
run_loop.Run();
}
void OfflinePageUtilsTest::CreateCachedOfflinePages() {
// Add 4 temporary pages to the model used for test cases. And setting current
// time as the 00:00:00 time anchor.
offline_pages::ClientId client_id;
client_id.name_space = kBookmarkNamespace;
clock()->SetNow(base::Time::Now());
// Time 01:00:00.
clock()->Advance(base::Hours(1));
std::unique_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
kTestPage1Url, base::FilePath(FILE_PATH_LITERAL("page1.mhtml"))));
client_id.id = kTestPage1ClientId;
SavePage(kTestPage1Url, client_id, std::move(archiver));
// time 02:00:00.
clock()->Advance(base::Hours(1));
archiver = BuildArchiver(kTestPage2Url,
base::FilePath(FILE_PATH_LITERAL("page2.mhtml")));
client_id.id = kTestPage2ClientId;
SavePage(kTestPage2Url, client_id, std::move(archiver));
// time 03:00:00.
clock()->Advance(base::Hours(1));
archiver = BuildArchiver(kTestPage3Url,
base::FilePath(FILE_PATH_LITERAL("page3.mhtml")));
client_id.id = kTestPage3ClientId;
SavePage(kTestPage3Url, client_id, std::move(archiver));
// Add a temporary page to test boundary at 10:00:00.
clock()->Advance(base::Hours(7));
archiver = BuildArchiver(kTestPage4Url,
base::FilePath(FILE_PATH_LITERAL("page4.mhtml")));
client_id.id = kTestPage4ClientId;
SavePage(kTestPage4Url, client_id, std::move(archiver));
// Reset clock->to 03:00:00.
clock()->Advance(base::Hours(-7));
}
std::unique_ptr<OfflinePageTestArchiver> OfflinePageUtilsTest::BuildArchiver(
const GURL& url,
const base::FilePath& file_name) {
std::unique_ptr<OfflinePageTestArchiver> archiver(new OfflinePageTestArchiver(
this, url, OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED,
std::u16string(), kTestFileSize, std::string(),
base::SingleThreadTaskRunner::GetCurrentDefault()));
archiver->set_filename(file_name);
return archiver;
}
int OfflinePageUtilsTest::FindRequestByNamespaceAndURL(
const std::string& name_space,
const GURL& url) {
std::vector<std::unique_ptr<SavePageRequest>> requests = GetAllRequests();
int matches = 0;
for (auto& request : requests) {
if (request->url() == url &&
request->client_id().name_space == name_space) {
matches++;
}
}
return matches;
}
TEST_F(OfflinePageUtilsTest, CheckDuplicateDownloads) {
// The duplicate page should be found for this.
EXPECT_EQ(OfflinePageUtils::DuplicateCheckResult::DUPLICATE_PAGE_FOUND,
CheckDuplicateDownloads(kTestPage1Url));
// The duplicate request should be found for this.
EXPECT_EQ(OfflinePageUtils::DuplicateCheckResult::DUPLICATE_REQUEST_FOUND,
CheckDuplicateDownloads(kTestPage3Url));
// No duplicate should be found for this.
EXPECT_EQ(OfflinePageUtils::DuplicateCheckResult::NOT_FOUND,
CheckDuplicateDownloads(kTestPage4Url));
}
TEST_F(OfflinePageUtilsTest, ScheduleDownload) {
// Pre-check.
ASSERT_EQ(0, FindRequestByNamespaceAndURL(kDownloadNamespace, kTestPage1Url));
ASSERT_EQ(1, FindRequestByNamespaceAndURL(kDownloadNamespace, kTestPage3Url));
ASSERT_EQ(0, FindRequestByNamespaceAndURL(kDownloadNamespace, kTestPage4Url));
// TODO(harringtond): Remove request creation in Setup().
size_t request_count_wait = 1;
// Re-downloading a page with duplicate page found.
OfflinePageUtils::ScheduleDownload(
web_contents(), kDownloadNamespace, kTestPage1Url,
OfflinePageUtils::DownloadUIActionFlags::NONE);
WaitForRequestMinCount(++request_count_wait);
EXPECT_EQ(1, FindRequestByNamespaceAndURL(kDownloadNamespace, kTestPage1Url));
// Re-downloading a page with duplicate request found.
OfflinePageUtils::ScheduleDownload(
web_contents(), kDownloadNamespace, kTestPage3Url,
OfflinePageUtils::DownloadUIActionFlags::NONE);
WaitForRequestMinCount(++request_count_wait);
EXPECT_EQ(2, FindRequestByNamespaceAndURL(kDownloadNamespace, kTestPage3Url));
// Downloading a page with no duplicate found.
OfflinePageUtils::ScheduleDownload(
web_contents(), kDownloadNamespace, kTestPage4Url,
OfflinePageUtils::DownloadUIActionFlags::NONE);
WaitForRequestMinCount(++request_count_wait);
EXPECT_EQ(1, FindRequestByNamespaceAndURL(kDownloadNamespace, kTestPage4Url));
}
#if BUILDFLAG(IS_ANDROID)
TEST_F(OfflinePageUtilsTest, ScheduleDownloadWithFailedFileAcecssRequest) {
DownloadControllerBase::Get()->SetApproveFileAccessRequestForTesting(false);
OfflinePageUtils::ScheduleDownload(
web_contents(), kDownloadNamespace, kTestPage4Url,
OfflinePageUtils::DownloadUIActionFlags::NONE);
// Here, we're waiting to make sure a request is not created. We can't use
// QuitClosure, since there's no callback threaded through ScheduleDownload.
// Instead, just wait a bit and assume ScheduleDownload is complete.
RunTasksForDuration(base::Seconds(1));
EXPECT_EQ(0, FindRequestByNamespaceAndURL(kDownloadNamespace, kTestPage4Url));
}
#endif
TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeBetween) {
// The clock will be at 03:00:00 after adding pages.
CreateCachedOfflinePages();
// Advance the clock so that we don't hit the time check boundary.
clock()->Advance(base::Minutes(5));
// Get the size of cached offline pages between 01:05:00 and 03:05:00.
EXPECT_EQ(kTestFileSize * 2,
GetCachedOfflinePageSizeBetween(clock()->Now() - base::Hours(2),
clock()->Now()));
}
TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeNoPageInModel) {
#if BUILDFLAG(IS_ANDROID)
// TODO(crbug.com/40646823): Fix this test to run in < action_timeout()
// on the Android bots.
const base::test::ScopedRunLoopTimeout increased_run_timeout(
FROM_HERE, TestTimeouts::action_max_timeout());
#endif // BUILDFLAG(IS_ANDROID)
clock()->Advance(base::Hours(3));
// Get the size of cached offline pages between 01:00:00 and 03:00:00.
// Since no temporary pages were added to the model, the cache size should be
// 0.
EXPECT_EQ(0, GetCachedOfflinePageSizeBetween(clock()->Now() - base::Hours(2),
clock()->Now()));
}
TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeNoPageInRange) {
// The clock will be at 03:00:00 after adding pages.
CreateCachedOfflinePages();
// Advance the clock so that we don't hit the time check boundary.
clock()->Advance(base::Minutes(5));
// Get the size of cached offline pages between 03:04:00 and 03:05:00.
EXPECT_EQ(0, GetCachedOfflinePageSizeBetween(
clock()->Now() - base::Minutes(1), clock()->Now()));
}
TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeAllPagesInRange) {
// The clock will be at 03:00:00 after adding pages.
CreateCachedOfflinePages();
// Advance the clock to 23:00:00.
clock()->Advance(base::Hours(20));
// Get the size of cached offline pages between -01:00:00 and 23:00:00.
EXPECT_EQ(kTestFileSize * 4,
GetCachedOfflinePageSizeBetween(clock()->Now() - base::Hours(24),
clock()->Now()));
}
TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeAllPagesInvalidRange) {
// The clock will be at 03:00:00 after adding pages.
CreateCachedOfflinePages();
// Advance the clock to 23:00:00.
clock()->Advance(base::Hours(20));
// Get the size of cached offline pages between 23:00:00 and -01:00:00, which
// is an invalid range, the return value will be false and there will be no
// callback.
EXPECT_FALSE(GetCachedOfflinePageSizeBetween(
clock()->Now(), clock()->Now() - base::Hours(24)));
}
TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeEdgeCase) {
// The clock will be at 03:00:00 after adding pages.
CreateCachedOfflinePages();
// Get the size of cached offline pages between 02:00:00 and 03:00:00, since
// we are using a [begin_time, end_time) range so there will be only 1 page
// when query for this time range.
EXPECT_EQ(kTestFileSize * 1,
GetCachedOfflinePageSizeBetween(clock()->Now() - base::Hours(1),
clock()->Now()));
}
// Timeout on Android. http://crbug.com/981972
#if BUILDFLAG(IS_ANDROID)
#define MAYBE_TestExtractOfflineHeaderValueFromNavigationEntry \
DISABLED_TestExtractOfflineHeaderValueFromNavigationEntry
#else
#define MAYBE_TestExtractOfflineHeaderValueFromNavigationEntry \
TestExtractOfflineHeaderValueFromNavigationEntry
#endif
TEST_F(OfflinePageUtilsTest,
MAYBE_TestExtractOfflineHeaderValueFromNavigationEntry) {
std::unique_ptr<content::NavigationEntry> entry(
content::NavigationEntry::Create());
std::string header_value;
// Expect empty string if no header is present.
header_value = OfflinePageUtils::ExtractOfflineHeaderValueFromNavigationEntry(
entry.get());
EXPECT_EQ("", header_value);
// Expect correct header value for correct header format.
entry->AddExtraHeaders("X-Chrome-offline: foo");
header_value = OfflinePageUtils::ExtractOfflineHeaderValueFromNavigationEntry(
entry.get());
EXPECT_EQ("foo", header_value);
// Expect empty string if multiple headers are set.
entry->AddExtraHeaders("Another-Header: bar");
header_value = OfflinePageUtils::ExtractOfflineHeaderValueFromNavigationEntry(
entry.get());
EXPECT_EQ("", header_value);
// Expect empty string for incorrect header format.
entry = content::NavigationEntry::Create();
entry->AddExtraHeaders("Random value");
header_value = OfflinePageUtils::ExtractOfflineHeaderValueFromNavigationEntry(
entry.get());
EXPECT_EQ("", header_value);
}
} // namespace offline_pages
Codebase Browser
chromium