| // Copyright 2022 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "base/feature_list.h" |
| #include "base/files/file_util.h" |
| #include "base/files/scoped_temp_dir.h" |
| #include "base/path_service.h" |
| #include "base/test/bind.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "base/threading/thread_restrictions.h" |
| #include "build/build_config.h" |
| #include "content/browser/network/http_cache_backend_file_operations_factory.h" |
| #include "content/public/browser/browser_thread.h" |
| #include "content/public/browser/network_service_instance.h" |
| #include "content/public/browser/network_service_util.h" |
| #include "content/public/browser/page.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/common/content_features.h" |
| #include "content/public/common/content_paths.h" |
| #include "content/public/test/browser_test.h" |
| #include "content/public/test/browser_test_utils.h" |
| #include "content/public/test/content_browser_test.h" |
| #include "content/public/test/content_browser_test_utils.h" |
| #include "content/public/test/network_service_test_helper.h" |
| #include "content/shell/browser/shell.h" |
| #include "mojo/public/cpp/bindings/remote.h" |
| #include "mojo/public/cpp/bindings/self_owned_receiver.h" |
| #include "net/base/features.h" |
| #include "sandbox/policy/features.h" |
| #include "services/network/public/cpp/features.h" |
| #include "services/network/public/mojom/network_service_test.mojom.h" |
| |
| #if BUILDFLAG(IS_ANDROID) |
| #include "base/android/android_info.h" |
| #endif |
| |
| namespace content { |
| namespace { |
| |
| using network::mojom::SimpleCache; |
| using network::mojom::SimpleCacheEntry; |
| using network::mojom::SimpleCacheEntryEnumerator; |
| using network::mojom::SimpleCacheOpenEntryResult; |
| using network::mojom::SimpleCacheOpenEntryResultPtr; |
| |
| using FileEnumerationEntry = |
| disk_cache::BackendFileOperations::FileEnumerationEntry; |
| |
| // On Mac and Fuchsia, sandboxing is always enabled, so we don't need to test |
| // the non-sandboxing configuration. |
| #if !BUILDFLAG(IS_MAC) && !BUILDFLAG(IS_FUCHSIA) |
| |
| class NonSandboxedNetworkServiceBrowserTest : public ContentBrowserTest { |
| public: |
| NonSandboxedNetworkServiceBrowserTest() { |
| std::vector<base::test::FeatureRef> kDisabledFeatures = { |
| sandbox::policy::features::kNetworkServiceSandbox, |
| }; |
| scoped_feature_list_.InitWithFeatures( |
| /*enabled_features=*/{}, |
| /*disabled_features=*/kDisabledFeatures); |
| ForceOutOfProcessNetworkService(); |
| } |
| |
| void SetUpOnMainThread() override { |
| ASSERT_TRUE(IsOutOfProcessNetworkService()); |
| } |
| |
| private: |
| base::test::ScopedFeatureList scoped_feature_list_; |
| }; |
| |
| IN_PROC_BROWSER_TEST_F(NonSandboxedNetworkServiceBrowserTest, |
| OpeningFileIsAllowed) { |
| base::ScopedAllowBlockingForTesting allow_blocking; |
| base::ScopedTempDir temp_dir; |
| ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| base::RunLoop run_loop; |
| |
| std::optional<bool> result; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| const base::FilePath path = |
| temp_dir.GetPath().Append(FILE_PATH_LITERAL("blank.jpg")); |
| network_service_test()->OpenFile(path, |
| base::BindLambdaForTesting([&](bool ok) { |
| result = ok; |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| |
| EXPECT_EQ(result, std::make_optional(true)); |
| } |
| |
| #endif |
| |
| class SandboxedHttpCacheBrowserTest : public ContentBrowserTest { |
| public: |
| SandboxedHttpCacheBrowserTest() { |
| std::vector<base::test::FeatureRef> enabled_features = { |
| features::kBrokerFileOperationsOnDiskCacheInNetworkService, |
| #if !BUILDFLAG(IS_MAC) && !BUILDFLAG(IS_FUCHSIA) |
| // Network Service Sandboxing is unconditionally enabled on these |
| // platforms. |
| sandbox::policy::features::kNetworkServiceSandbox, |
| #endif |
| }; |
| scoped_feature_list_.InitWithFeatures(enabled_features, {}); |
| ForceOutOfProcessNetworkService(); |
| } |
| |
| void SetUp() override { |
| #if BUILDFLAG(IS_WIN) |
| if (!sandbox::policy::features::IsNetworkSandboxSupported()) { |
| // On *some* Windows, sandboxing cannot be enabled. We skip all the tests |
| // on such platforms. |
| GTEST_SKIP(); |
| } |
| #endif |
| |
| #if BUILDFLAG(IS_ANDROID) |
| { |
| // On older android, we cannot use ftruncate in the network process. |
| // See https://crbug.com/1315933 and https://crrev.com/c/3581676. |
| // Let's skip the tests. |
| const int sdk_version = base::android::android_info::sdk_int(); |
| if (sdk_version <= |
| base::android::android_info::SdkVersion::SDK_VERSION_MARSHMALLOW) { |
| DVLOG(0) << "Android is too old: " << sdk_version; |
| GTEST_SKIP(); |
| } |
| } |
| #endif |
| |
| // These assertions need to precede ContentBrowserTest::SetUp to prevent the |
| // test body from running when one of the assertions fails. |
| ASSERT_TRUE(IsOutOfProcessNetworkService()); |
| ASSERT_TRUE(sandbox::policy::features::IsNetworkSandboxEnabled()); |
| |
| ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); |
| |
| ContentBrowserTest::SetUp(); |
| } |
| |
| void SetUpOnMainThread() override { |
| ASSERT_TRUE(IsOutOfProcessNetworkService()); |
| } |
| |
| mojo::Remote<SimpleCache> CreateSimpleCache() { |
| base::RunLoop run_loop; |
| |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| const base::FilePath root_path = GetTempDirPath(); |
| const base::FilePath path = root_path.AppendASCII("foobar"); |
| mojo::Remote<SimpleCache> simple_cache; |
| mojo::PendingRemote<network::mojom::HttpCacheBackendFileOperationsFactory> |
| factory_remote; |
| mojo::MakeSelfOwnedReceiver( |
| std::make_unique<HttpCacheBackendFileOperationsFactory>(root_path), |
| factory_remote.InitWithNewPipeAndPassReceiver()); |
| |
| network_service_test()->CreateSimpleCache( |
| std::move(factory_remote), path, /*reset=*/false, |
| base::BindLambdaForTesting([&](mojo::PendingRemote<SimpleCache> cache) { |
| if (cache) { |
| simple_cache.Bind(std::move(cache)); |
| } |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| |
| return simple_cache; |
| } |
| |
| mojo::Remote<SimpleCacheEntry> CreateEntry(SimpleCache* cache, |
| const std::string& key) { |
| mojo::Remote<SimpleCacheEntry> entry; |
| base::RunLoop run_loop; |
| cache->CreateEntry( |
| key, base::BindLambdaForTesting( |
| [&](mojo::PendingRemote<SimpleCacheEntry> pending_entry, |
| int net_error) { |
| if (pending_entry) { |
| entry.Bind(std::move(pending_entry)); |
| } |
| run_loop.Quit(); |
| })); |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| run_loop.Run(); |
| return entry; |
| } |
| |
| mojo::Remote<SimpleCacheEntry> OpenEntry(SimpleCache* cache, |
| const std::string& key) { |
| mojo::Remote<SimpleCacheEntry> entry; |
| base::RunLoop run_loop; |
| cache->OpenEntry( |
| key, base::BindLambdaForTesting( |
| [&](mojo::PendingRemote<SimpleCacheEntry> pending_entry, |
| int net_error) { |
| if (pending_entry) { |
| entry.Bind(std::move(pending_entry)); |
| } |
| run_loop.Quit(); |
| })); |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| run_loop.Run(); |
| return entry; |
| } |
| |
| void Close(mojo::Remote<SimpleCacheEntry> entry) { |
| base::RunLoop run_loop; |
| entry->Close(run_loop.QuitClosure()); |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| run_loop.Run(); |
| } |
| |
| void Detach(mojo::Remote<SimpleCache> cache) { |
| base::RunLoop run_loop; |
| cache->Detach(run_loop.QuitClosure()); |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| run_loop.Run(); |
| } |
| |
| SimpleCacheOpenEntryResultPtr OpenNextEntry( |
| SimpleCacheEntryEnumerator* enumerator) { |
| base::RunLoop run_loop; |
| |
| SimpleCacheOpenEntryResultPtr result_to_pass; |
| std::pair<mojo::Remote<SimpleCacheEntry>, int> result; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| enumerator->GetNext( |
| base::BindLambdaForTesting([&](SimpleCacheOpenEntryResultPtr result) { |
| DCHECK(result); |
| result_to_pass = std::move(result); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| |
| return result_to_pass; |
| } |
| |
| const base::FilePath& GetTempDirPath() const { return temp_dir_.GetPath(); } |
| |
| private: |
| base::test::ScopedFeatureList scoped_feature_list_; |
| base::ScopedTempDir temp_dir_; |
| }; |
| |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, OpeningFileIsProhibited) { |
| base::RunLoop run_loop; |
| |
| std::optional<bool> result; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| const base::FilePath path = |
| GetTestDataFilePath().Append(FILE_PATH_LITERAL("blank.jpg")); |
| network_service_test()->OpenFile(path, |
| base::BindLambdaForTesting([&](bool b) { |
| result = b; |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| |
| EXPECT_EQ(result, std::make_optional(false)); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, |
| EnumerateFilesOnNonExistingDirectory) { |
| base::ScopedAllowBlockingForTesting allow_blocking; |
| base::RunLoop run_loop; |
| |
| base::FilePath root; |
| base::PathService::Get(content::DIR_TEST_DATA, &root); |
| root = |
| root.Append(FILE_PATH_LITERAL("net")).Append(FILE_PATH_LITERAL("cache")); |
| mojo::PendingRemote<network::mojom::HttpCacheBackendFileOperationsFactory> |
| factory_remote; |
| mojo::MakeSelfOwnedReceiver( |
| std::make_unique<HttpCacheBackendFileOperationsFactory>(root), |
| factory_remote.InitWithNewPipeAndPassReceiver()); |
| |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| const base::FilePath path = root.Append(FILE_PATH_LITERAL("not-found")); |
| std::vector<FileEnumerationEntry> entries; |
| bool has_error = false; |
| |
| network_service_test()->EnumerateFiles( |
| path, std::move(factory_remote), |
| base::BindLambdaForTesting( |
| [&](const std::vector<FileEnumerationEntry>& in_entries, |
| bool in_has_error) { |
| entries = in_entries; |
| has_error = in_has_error; |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| EXPECT_TRUE(entries.empty()); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, EnumerateFiles) { |
| base::ScopedAllowBlockingForTesting allow_blocking; |
| base::RunLoop run_loop; |
| |
| base::FilePath root; |
| base::PathService::Get(content::DIR_TEST_DATA, &root); |
| root = |
| root.Append(FILE_PATH_LITERAL("net")).Append(FILE_PATH_LITERAL("cache")); |
| mojo::PendingRemote<network::mojom::HttpCacheBackendFileOperationsFactory> |
| factory_remote; |
| mojo::MakeSelfOwnedReceiver( |
| std::make_unique<HttpCacheBackendFileOperationsFactory>(root), |
| factory_remote.InitWithNewPipeAndPassReceiver()); |
| |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| const base::FilePath path = root.Append(FILE_PATH_LITERAL("file_enumerator")); |
| std::vector<FileEnumerationEntry> entries; |
| bool has_error = false; |
| |
| network_service_test()->EnumerateFiles( |
| path, std::move(factory_remote), |
| base::BindLambdaForTesting( |
| [&](const std::vector<FileEnumerationEntry>& in_entries, |
| bool in_has_error) { |
| entries = in_entries; |
| has_error = in_has_error; |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| ASSERT_EQ(1u, entries.size()); |
| EXPECT_FALSE(has_error); |
| const FileEnumerationEntry entry = entries[0]; |
| EXPECT_EQ(entry.path, path.Append(FILE_PATH_LITERAL("test.txt"))); |
| EXPECT_EQ(entry.size, 13); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, CreateSimpleCache) { |
| base::RunLoop run_loop; |
| |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| const base::FilePath root_path = GetTempDirPath(); |
| mojo::Remote<SimpleCache> simple_cache; |
| mojo::PendingRemote<network::mojom::HttpCacheBackendFileOperationsFactory> |
| factory_remote; |
| mojo::MakeSelfOwnedReceiver( |
| std::make_unique<HttpCacheBackendFileOperationsFactory>(root_path), |
| factory_remote.InitWithNewPipeAndPassReceiver()); |
| |
| network_service_test()->CreateSimpleCache( |
| std::move(factory_remote), root_path, /*reset=*/false, |
| base::BindLambdaForTesting([&](mojo::PendingRemote<SimpleCache> cache) { |
| if (cache) { |
| simple_cache.Bind(std::move(cache)); |
| } |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| |
| ASSERT_TRUE(simple_cache.is_bound()); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, |
| CreateSimpleCacheOnParentDirectory) { |
| base::RunLoop run_loop; |
| |
| const base::FilePath path = GetTempDirPath(); |
| const base::FilePath root_path = path.AppendASCII("foobar"); |
| mojo::PendingRemote<network::mojom::HttpCacheBackendFileOperationsFactory> |
| factory_remote; |
| mojo::MakeSelfOwnedReceiver( |
| std::make_unique<HttpCacheBackendFileOperationsFactory>(root_path), |
| factory_remote.InitWithNewPipeAndPassReceiver()); |
| |
| // We expect the network service to crash due to a bad mojo message. |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| network_service_test()->CreateSimpleCache( |
| std::move(factory_remote), path, /*reset=*/false, |
| base::BindOnce([](mojo::PendingRemote<SimpleCache> cache) { |
| EXPECT_FALSE(cache.is_valid()); |
| })); |
| run_loop.Run(); |
| IgnoreNetworkServiceCrashes(); |
| } |
| |
| // TODO(crbug.com/40919503): Flaky on at least Mac11. |
| #if BUILDFLAG(IS_MAC) |
| #define MAYBE_CreateSimpleCacheWithParentDirectoryTraversal \ |
| DISABLED_CreateSimpleCacheWithParentDirectoryTraversal |
| #else |
| #define MAYBE_CreateSimpleCacheWithParentDirectoryTraversal \ |
| CreateSimpleCacheWithParentDirectoryTraversal |
| #endif |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, |
| MAYBE_CreateSimpleCacheWithParentDirectoryTraversal) { |
| base::RunLoop run_loop; |
| |
| const base::FilePath root_path = GetTempDirPath(); |
| const base::FilePath path = root_path.AppendASCII("foo") |
| .Append(base::FilePath::kParentDirectory) |
| .AppendASCII("bar"); |
| mojo::PendingRemote<network::mojom::HttpCacheBackendFileOperationsFactory> |
| factory_remote; |
| mojo::MakeSelfOwnedReceiver( |
| std::make_unique<HttpCacheBackendFileOperationsFactory>(root_path), |
| factory_remote.InitWithNewPipeAndPassReceiver()); |
| |
| // We expect the network service to crash due to a bad mojo message. |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| network_service_test()->CreateSimpleCache( |
| std::move(factory_remote), path, /*reset=*/false, |
| base::BindOnce([](mojo::PendingRemote<SimpleCache> cache) { |
| EXPECT_FALSE(cache.is_valid()); |
| })); |
| run_loop.Run(); |
| IgnoreNetworkServiceCrashes(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, |
| CreateSimpleCacheWithReset) { |
| base::RunLoop run_loop; |
| |
| const base::FilePath root_path = GetTempDirPath(); |
| const base::FilePath path = root_path.Append(FILE_PATH_LITERAL("cache-dir")); |
| const base::FilePath child_path = path.Append(FILE_PATH_LITERAL("child")); |
| mojo::Remote<SimpleCache> simple_cache; |
| mojo::PendingRemote<network::mojom::HttpCacheBackendFileOperationsFactory> |
| factory_remote; |
| mojo::MakeSelfOwnedReceiver( |
| std::make_unique<HttpCacheBackendFileOperationsFactory>(root_path), |
| factory_remote.InitWithNewPipeAndPassReceiver()); |
| |
| { |
| base::ScopedAllowBlockingForTesting allow_blocking; |
| ASSERT_TRUE(base::CreateDirectory(path)); |
| ASSERT_TRUE(base::CreateDirectory(child_path)); |
| ASSERT_TRUE(base::PathExists(child_path)); |
| } |
| |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| network_service_test()->CreateSimpleCache( |
| std::move(factory_remote), path, /*reset=*/true, |
| base::BindLambdaForTesting([&](mojo::PendingRemote<SimpleCache> cache) { |
| if (cache) { |
| simple_cache.Bind(std::move(cache)); |
| } |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| ASSERT_TRUE(simple_cache.is_bound()); |
| |
| { |
| base::ScopedAllowBlockingForTesting allow_blocking; |
| EXPECT_TRUE(base::PathExists(path)); |
| EXPECT_FALSE(base::PathExists(child_path)); |
| } |
| } |
| |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, CreateEntry) { |
| mojo::Remote<SimpleCache> simple_cache = CreateSimpleCache(); |
| |
| ASSERT_TRUE(simple_cache.is_bound()); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| mojo::Remote<SimpleCacheEntry> entry = CreateEntry(simple_cache.get(), "abc"); |
| ASSERT_TRUE(entry.is_bound()); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, OpenNonExistingEntry) { |
| mojo::Remote<SimpleCache> simple_cache = CreateSimpleCache(); |
| |
| ASSERT_TRUE(simple_cache.is_bound()); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| mojo::Remote<SimpleCacheEntry> entry = OpenEntry(simple_cache.get(), "abc"); |
| ASSERT_FALSE(entry.is_bound()); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, CreateAndOpenEntry) { |
| mojo::Remote<SimpleCache> simple_cache = CreateSimpleCache(); |
| |
| ASSERT_TRUE(simple_cache.is_bound()); |
| mojo::Remote<SimpleCacheEntry> entry = CreateEntry(simple_cache.get(), "abc"); |
| |
| ASSERT_TRUE(entry.is_bound()); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| Close(std::move(entry)); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| ASSERT_TRUE(simple_cache.is_bound()); |
| entry = OpenEntry(simple_cache.get(), "abc"); |
| |
| ASSERT_TRUE(entry.is_bound()); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, WriteAndReadData) { |
| mojo::Remote<SimpleCache> simple_cache = CreateSimpleCache(); |
| const std::vector<uint8_t> kData = {'A', 'B', 'C', 'D', 'E'}; |
| const std::string kKey = "key"; |
| constexpr int kOffset = 4; |
| constexpr int kIndex = 1; |
| |
| ASSERT_TRUE(simple_cache.is_bound()); |
| mojo::Remote<SimpleCacheEntry> entry = CreateEntry(simple_cache.get(), kKey); |
| ASSERT_TRUE(entry.is_bound()); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| { |
| base::RunLoop run_loop; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| entry->WriteData(kIndex, kOffset, kData, /*truncate=*/false, |
| base::BindLambdaForTesting([&](int result) { |
| EXPECT_EQ(result, static_cast<int>(kData.size())); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| } |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| Close(std::move(entry)); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| Detach(std::move(simple_cache)); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| simple_cache = CreateSimpleCache(); |
| ASSERT_TRUE(simple_cache.is_bound()); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| entry = OpenEntry(simple_cache.get(), kKey); |
| ASSERT_TRUE(entry); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| { |
| base::RunLoop run_loop; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| entry->ReadData(kIndex, 0, kOffset + kData.size() + 5, |
| base::BindLambdaForTesting( |
| [&](const std::vector<uint8_t>& data, int result) { |
| std::vector<uint8_t> expected_data(kOffset, 0); |
| expected_data.insert(expected_data.end(), |
| kData.cbegin(), kData.cend()); |
| EXPECT_EQ(result, |
| static_cast<int>(expected_data.size())); |
| EXPECT_EQ(data, expected_data); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| } |
| } |
| |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, |
| WriteTruncateAndReadData) { |
| mojo::Remote<SimpleCache> simple_cache = CreateSimpleCache(); |
| const std::vector<uint8_t> kData = {'A', 'B', 'C', 'D', 'E'}; |
| const std::string kKey = "key"; |
| constexpr int kOffset = 4; |
| constexpr int kIndex = 1; |
| |
| ASSERT_TRUE(simple_cache.is_bound()); |
| mojo::Remote<SimpleCacheEntry> entry = CreateEntry(simple_cache.get(), kKey); |
| ASSERT_TRUE(entry.is_bound()); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| { |
| base::RunLoop run_loop; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| entry->WriteData(kIndex, kOffset, kData, /*truncate=*/false, |
| base::BindLambdaForTesting([&](int result) { |
| EXPECT_EQ(result, static_cast<int>(kData.size())); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| } |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| { |
| base::RunLoop run_loop; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| entry->WriteData(kIndex, /*offset=*/0, kData, /*truncate=*/true, |
| base::BindLambdaForTesting([&](int result) { |
| EXPECT_EQ(result, static_cast<int>(kData.size())); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| } |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| { |
| base::RunLoop run_loop; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| entry->Close(run_loop.QuitClosure()); |
| entry.reset(); |
| } |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| Detach(std::move(simple_cache)); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| simple_cache = CreateSimpleCache(); |
| ASSERT_TRUE(simple_cache.is_bound()); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| entry = OpenEntry(simple_cache.get(), kKey); |
| ASSERT_TRUE(entry); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| { |
| base::RunLoop run_loop; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| entry->ReadData(kIndex, 0, kOffset + kData.size() + 5, |
| base::BindLambdaForTesting( |
| [&](const std::vector<uint8_t>& data, int result) { |
| EXPECT_EQ(result, static_cast<int>(kData.size())); |
| EXPECT_EQ(data, kData); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| } |
| } |
| |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, WriteAndReadSparseData) { |
| const std::string kKey = "key"; |
| constexpr int kOffset = 1024; |
| std::vector<uint8_t> original_data; |
| for (int i = 0; i < 2048; ++i) { |
| original_data.push_back(static_cast<uint8_t>(i % 26 + 'A')); |
| } |
| |
| mojo::Remote<SimpleCache> simple_cache = CreateSimpleCache(); |
| ASSERT_TRUE(simple_cache.is_bound()); |
| mojo::Remote<SimpleCacheEntry> entry = CreateEntry(simple_cache.get(), kKey); |
| ASSERT_TRUE(entry.is_bound()); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| { |
| base::RunLoop run_loop; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| entry->WriteSparseData( |
| kOffset, original_data, base::BindLambdaForTesting([&](int result) { |
| EXPECT_EQ(result, static_cast<int>(original_data.size())); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| } |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| { |
| base::RunLoop run_loop; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| entry->Close(run_loop.QuitClosure()); |
| entry.reset(); |
| } |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| Detach(std::move(simple_cache)); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| simple_cache = CreateSimpleCache(); |
| ASSERT_TRUE(simple_cache.is_bound()); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| entry = OpenEntry(simple_cache.get(), kKey); |
| ASSERT_TRUE(entry); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| { |
| base::RunLoop run_loop; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| entry->ReadSparseData( |
| kOffset, original_data.size() + 1024, |
| base::BindLambdaForTesting( |
| [&](const std::vector<uint8_t>& data, int result) { |
| EXPECT_EQ(result, static_cast<int>(original_data.size())); |
| EXPECT_EQ(data, original_data); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| } |
| } |
| |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, DoomEntry) { |
| const std::vector<uint8_t> kData = {'A', 'B', 'C'}; |
| const std::vector<uint8_t> kSparseData(1024, 'A'); |
| mojo::Remote<SimpleCache> simple_cache = CreateSimpleCache(); |
| |
| ASSERT_TRUE(simple_cache.is_bound()); |
| mojo::Remote<SimpleCacheEntry> entry = CreateEntry(simple_cache.get(), "abc"); |
| |
| ASSERT_TRUE(entry.is_bound()); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| { |
| // Write something, to open files. |
| base::RunLoop run_loop; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| entry->WriteData(/*index=*/0, /*offset=*/0, kData, /*truncate=*/false, |
| base::BindLambdaForTesting([&](int result) { |
| EXPECT_EQ(result, static_cast<int>(kData.size())); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| } |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| { |
| // Write something, to open files. |
| base::RunLoop run_loop; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| entry->WriteSparseData( |
| /*offset=*/0, kSparseData, base::BindLambdaForTesting([&](int result) { |
| EXPECT_EQ(result, static_cast<int>(kSparseData.size())); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| } |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| { |
| base::RunLoop run_loop; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| simple_cache->DoomEntry("abc", |
| base::BindLambdaForTesting([&](int32_t result) { |
| EXPECT_EQ(result, net::OK); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| } |
| entry.reset(); |
| Detach(std::move(simple_cache)); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| simple_cache = CreateSimpleCache(); |
| ASSERT_TRUE(simple_cache.is_bound()); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| ASSERT_TRUE(simple_cache.is_bound()); |
| entry = OpenEntry(simple_cache.get(), "abc"); |
| |
| ASSERT_FALSE(entry.is_bound()); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, DoomEntryWithoutOpening) { |
| mojo::Remote<SimpleCache> simple_cache = CreateSimpleCache(); |
| |
| ASSERT_TRUE(simple_cache.is_bound()); |
| { |
| base::RunLoop run_loop; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| simple_cache->DoomEntry("abc", |
| base::BindLambdaForTesting([&](int32_t result) { |
| EXPECT_EQ(result, net::OK); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| } |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| Detach(std::move(simple_cache)); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| } |
| |
| // TODO(crbug.com/40881636): Re-enable this test |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, |
| DISABLED_EnumerateEntries) { |
| const std::string kKey1 = "abc"; |
| const std::string kKey2 = "def"; |
| const std::string kKey3 = "ghi"; |
| |
| mojo::Remote<SimpleCache> simple_cache = CreateSimpleCache(); |
| ASSERT_TRUE(simple_cache.is_bound()); |
| |
| { |
| mojo::Remote<SimpleCacheEntryEnumerator> enumerator; |
| simple_cache->EnumerateEntries(enumerator.BindNewPipeAndPassReceiver()); |
| |
| auto result = OpenNextEntry(enumerator.get()); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| DCHECK(result); |
| |
| ASSERT_EQ(result->error, net::ERR_FAILED); |
| ASSERT_FALSE(result->entry); |
| } |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| mojo::Remote<SimpleCacheEntry> entry1 = |
| CreateEntry(simple_cache.get(), kKey1); |
| ASSERT_TRUE(entry1.is_bound()); |
| |
| mojo::Remote<SimpleCacheEntry> entry2 = |
| CreateEntry(simple_cache.get(), kKey2); |
| ASSERT_TRUE(entry2.is_bound()); |
| |
| mojo::Remote<SimpleCacheEntry> entry3 = |
| CreateEntry(simple_cache.get(), kKey3); |
| ASSERT_TRUE(entry3.is_bound()); |
| |
| Close(std::move(entry1)); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| Close(std::move(entry2)); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| Close(std::move(entry3)); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| Detach(std::move(simple_cache)); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| simple_cache = CreateSimpleCache(); |
| ASSERT_TRUE(simple_cache.is_bound()); |
| |
| { |
| mojo::Remote<SimpleCacheEntryEnumerator> enumerator; |
| simple_cache->EnumerateEntries(enumerator.BindNewPipeAndPassReceiver()); |
| |
| std::vector<std::string> keys; |
| while (true) { |
| auto result = OpenNextEntry(enumerator.get()); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| DCHECK(result); |
| |
| if (result->error == net::ERR_FAILED) { |
| EXPECT_FALSE(result->entry); |
| break; |
| } |
| ASSERT_EQ(result->error, net::OK); |
| ASSERT_TRUE(result->entry); |
| keys.push_back(result->key); |
| } |
| std::sort(keys.begin(), keys.end()); |
| EXPECT_EQ(keys, (std::vector<std::string>{kKey1, kKey2, kKey3})); |
| } |
| } |
| |
| IN_PROC_BROWSER_TEST_F(SandboxedHttpCacheBrowserTest, DoomAllEntries) { |
| const std::string kKey1 = "abc"; |
| const std::string kKey2 = "def"; |
| const std::string kKey3 = "ghi"; |
| |
| mojo::Remote<SimpleCache> simple_cache = CreateSimpleCache(); |
| ASSERT_TRUE(simple_cache.is_bound()); |
| |
| { |
| mojo::Remote<SimpleCacheEntryEnumerator> enumerator; |
| simple_cache->EnumerateEntries(enumerator.BindNewPipeAndPassReceiver()); |
| |
| auto result = OpenNextEntry(enumerator.get()); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| ASSERT_TRUE(result); |
| |
| ASSERT_EQ(result->error, net::ERR_FAILED); |
| ASSERT_FALSE(result->entry); |
| } |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| mojo::Remote<SimpleCacheEntry> entry1 = |
| CreateEntry(simple_cache.get(), kKey1); |
| ASSERT_TRUE(entry1.is_bound()); |
| |
| mojo::Remote<SimpleCacheEntry> entry2 = |
| CreateEntry(simple_cache.get(), kKey2); |
| ASSERT_TRUE(entry2.is_bound()); |
| |
| mojo::Remote<SimpleCacheEntry> entry3 = |
| CreateEntry(simple_cache.get(), kKey3); |
| ASSERT_TRUE(entry3.is_bound()); |
| |
| { |
| base::RunLoop run_loop; |
| network_service_test().set_disconnect_handler(run_loop.QuitClosure()); |
| simple_cache->DoomAllEntries( |
| base::BindLambdaForTesting([&](int32_t result) { |
| EXPECT_EQ(result, net::OK); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| } |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| entry1.reset(); |
| entry2.reset(); |
| entry3.reset(); |
| |
| Detach(std::move(simple_cache)); |
| ASSERT_TRUE(network_service_test().is_connected()); |
| |
| simple_cache = CreateSimpleCache(); |
| ASSERT_TRUE(simple_cache.is_bound()); |
| |
| { |
| mojo::Remote<SimpleCacheEntryEnumerator> enumerator; |
| simple_cache->EnumerateEntries(enumerator.BindNewPipeAndPassReceiver()); |
| |
| std::vector<std::string> keys; |
| auto result = OpenNextEntry(enumerator.get()); |
| EXPECT_EQ(result->error, net::ERR_FAILED); |
| EXPECT_FALSE(result->entry); |
| } |
| } |
| |
| } // namespace |
| } // namespace content |
