| // Copyright 2023 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "content/browser/media/cdm_storage_manager.h" |
| |
| #include <string> |
| |
| #include "base/test/task_environment.h" |
| #include "base/test/test_file_util.h" |
| #include "base/test/test_future.h" |
| #include "media/mojo/mojom/cdm_storage.mojom.h" |
| #include "mojo/public/cpp/bindings/associated_remote.h" |
| #include "mojo/public/cpp/bindings/remote.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| using media::mojom::CdmFile; |
| using media::mojom::CdmStorage; |
| |
| namespace content { |
| |
| namespace { |
| |
| const media::CdmType kCdmType{1234, 5678}; |
| |
| const char kFileName[] = "file.txt"; |
| const char kFileNameTwo[] = "file2.txt"; |
| |
| const std::vector<uint8_t> kPopulatedFileValue = {1, 2, 3}; |
| const std::vector<uint8_t> kPopulatedFileValueTwo = {1, 2, 3, 4}; |
| |
| std::vector<uint8_t> kEmptyFileValue; |
| |
| } // namespace |
| |
| // TODO(crbug.com/40272342): Add a DeleteFile test once there is a way to check |
| // that the db is actually deleted. |
| |
| class CdmStorageManagerTest : public testing::Test { |
| public: |
| CdmStorageManagerTest() = default; |
| ~CdmStorageManagerTest() override = default; |
| |
| protected: |
| void SetUpManager(const base::FilePath file_path) { |
| cdm_storage_manager_ = std::make_unique<CdmStorageManager>(file_path); |
| } |
| |
| void SetUpManagerTwo(const base::FilePath file_path) { |
| cdm_storage_manager_two_ = std::make_unique<CdmStorageManager>(file_path); |
| } |
| |
| mojo::AssociatedRemote<media::mojom::CdmFile> OpenCdmFile( |
| const mojo::Remote<media::mojom::CdmStorage>& storage, |
| const std::string& file_name) { |
| base::test::TestFuture<media::mojom::CdmStorage::Status, |
| mojo::PendingAssociatedRemote<media::mojom::CdmFile>> |
| open_future; |
| storage->Open(file_name, open_future.GetCallback()); |
| |
| auto [status, pending_remote] = open_future.Take(); |
| EXPECT_EQ(status, media::mojom::CdmStorage::Status::kSuccess); |
| |
| mojo::AssociatedRemote<media::mojom::CdmFile> cdm_file; |
| cdm_file.Bind(std::move(pending_remote)); |
| return cdm_file; |
| } |
| |
| void Write(const mojo::AssociatedRemote<media::mojom::CdmFile>& cdm_file, |
| const std::vector<uint8_t> data) { |
| base::test::TestFuture<media::mojom::CdmFile::Status> write_future; |
| cdm_file->Write(data, write_future.GetCallback()); |
| EXPECT_EQ(write_future.Get(), media::mojom::CdmFile::Status::kSuccess); |
| } |
| |
| // Reads the previously opened `cdm_file` and check that its contents match |
| // `expected_data`. |
| void ExpectFileContents( |
| const mojo::AssociatedRemote<media::mojom::CdmFile>& cdm_file, |
| const std::vector<uint8_t> expected_data) { |
| base::test::TestFuture<media::mojom::CdmFile::Status, std::vector<uint8_t>> |
| future; |
| cdm_file->Read(future.GetCallback<media::mojom::CdmFile::Status, |
| const std::vector<uint8_t>&>()); |
| |
| auto [status, data] = future.Take(); |
| EXPECT_EQ(status, media::mojom::CdmFile::Status::kSuccess); |
| EXPECT_EQ(data, expected_data); |
| } |
| |
| const blink::StorageKey kTestStorageKey = |
| blink::StorageKey::CreateFromStringForTesting("https://example.com/"); |
| const blink::StorageKey kTestStorageKeyTwo = |
| blink::StorageKey::CreateFromStringForTesting("https://exampletwo.com/"); |
| |
| std::unique_ptr<CdmStorageManager> cdm_storage_manager_; |
| std::unique_ptr<CdmStorageManager> cdm_storage_manager_two_; |
| |
| mojo::Remote<CdmStorage> cdm_storage_; |
| mojo::Remote<CdmStorage> cdm_storage_two_; |
| |
| base::test::TaskEnvironment task_environment_; |
| }; |
| |
| class CdmStorageManagerSingularTest : public CdmStorageManagerTest, |
| public testing::WithParamInterface<bool> { |
| public: |
| void SetUp() override { |
| bool is_incognito = GetParam(); |
| if (is_incognito) { |
| SetUpManager(base::FilePath()); |
| } else { |
| SetUpManager(base::CreateUniqueTempDirectoryScopedToTest().Append( |
| kCdmStorageDatabaseFileName)); |
| } |
| } |
| |
| void TearDown() override { |
| cdm_storage_manager_->DeleteData(base::NullCallback(), blink::StorageKey(), |
| base::Time::Min(), base::Time::Max(), |
| base::DoNothing()); |
| |
| // To prevent a memory leak, reset the manager. This may post |
| // destruction of other objects, so RunUntilIdle(). |
| cdm_storage_manager_.reset(); |
| task_environment_.RunUntilIdle(); |
| } |
| }; |
| |
| class CdmStorageManagerMultipleTest |
| : public CdmStorageManagerTest, |
| public testing::WithParamInterface<std::tuple<bool, bool>> { |
| public: |
| void SetUp() override { |
| if (std::get<0>(GetParam())) { |
| SetUpManager(base::FilePath()); |
| } else { |
| SetUpManager(base::CreateUniqueTempDirectoryScopedToTest().Append( |
| kCdmStorageDatabaseFileName)); |
| } |
| |
| if (std::get<1>(GetParam())) { |
| SetUpManagerTwo(base::FilePath()); |
| } else { |
| SetUpManagerTwo(base::CreateUniqueTempDirectoryScopedToTest().Append( |
| kCdmStorageDatabaseFileName)); |
| } |
| } |
| |
| void TearDown() override { |
| cdm_storage_manager_->DeleteData(base::NullCallback(), blink::StorageKey(), |
| base::Time::Min(), base::Time::Max(), |
| base::DoNothing()); |
| cdm_storage_manager_two_->DeleteData(base::NullCallback(), |
| blink::StorageKey(), base::Time::Min(), |
| base::Time::Max(), base::DoNothing()); |
| |
| // To prevent a memory leak, reset the manager. This may post |
| // destruction of other objects, so RunUntilIdle(). |
| cdm_storage_manager_.reset(); |
| cdm_storage_manager_two_.reset(); |
| task_environment_.RunUntilIdle(); |
| } |
| }; |
| |
| // This test case tests deletion of a file. |
| TEST_P(CdmStorageManagerSingularTest, DeleteFile) { |
| cdm_storage_manager_->OpenCdmStorage( |
| CdmStorageBindingContext(kTestStorageKey, kCdmType), |
| cdm_storage_.BindNewPipeAndPassReceiver()); |
| auto cdm_file = OpenCdmFile(cdm_storage_, kFileName); |
| ASSERT_TRUE(cdm_file.is_bound()); |
| |
| Write(cdm_file, kPopulatedFileValue); |
| |
| ExpectFileContents(cdm_file, kPopulatedFileValue); |
| |
| cdm_storage_manager_->DeleteFile(kTestStorageKey, kCdmType, kFileName, |
| base::DoNothing()); |
| |
| ExpectFileContents(cdm_file, kEmptyFileValue); |
| } |
| |
| // This test case tests deletion of a non existent file to make sure it doesn't |
| // affect any other files in the database. |
| TEST_P(CdmStorageManagerSingularTest, DeleteNonExistentFile) { |
| cdm_storage_manager_->OpenCdmStorage( |
| CdmStorageBindingContext(kTestStorageKey, kCdmType), |
| cdm_storage_.BindNewPipeAndPassReceiver()); |
| auto cdm_file = OpenCdmFile(cdm_storage_, kFileName); |
| ASSERT_TRUE(cdm_file.is_bound()); |
| |
| Write(cdm_file, kPopulatedFileValue); |
| |
| ExpectFileContents(cdm_file, kPopulatedFileValue); |
| |
| cdm_storage_manager_->DeleteFile(kTestStorageKey, kCdmType, kFileNameTwo, |
| base::DoNothing()); |
| |
| ExpectFileContents(cdm_file, kPopulatedFileValue); |
| } |
| |
| // This test cases tests that we accurately delete data for a storage key |
| // without touching other data in the database. |
| TEST_P(CdmStorageManagerSingularTest, DeleteDataForStorageKey) { |
| cdm_storage_manager_->OpenCdmStorage( |
| CdmStorageBindingContext(kTestStorageKey, kCdmType), |
| cdm_storage_.BindNewPipeAndPassReceiver()); |
| |
| auto cdm_file_for_remote_one = OpenCdmFile(cdm_storage_, kFileName); |
| Write(cdm_file_for_remote_one, kPopulatedFileValue); |
| ASSERT_TRUE(cdm_file_for_remote_one.is_bound()); |
| |
| auto cdm_file_two_for_remote_one = OpenCdmFile(cdm_storage_, kFileNameTwo); |
| Write(cdm_file_two_for_remote_one, kPopulatedFileValue); |
| ASSERT_TRUE(cdm_file_two_for_remote_one.is_bound()); |
| |
| cdm_storage_manager_->OpenCdmStorage( |
| CdmStorageBindingContext(kTestStorageKeyTwo, kCdmType), |
| cdm_storage_two_.BindNewPipeAndPassReceiver()); |
| |
| auto cdm_file_for_remote_two = OpenCdmFile(cdm_storage_two_, kFileNameTwo); |
| Write(cdm_file_for_remote_two, kPopulatedFileValue); |
| ASSERT_TRUE(cdm_file_for_remote_two.is_bound()); |
| |
| cdm_storage_manager_->DeleteData(base::NullCallback(), kTestStorageKey, |
| base::Time::Min(), base::Time::Max(), |
| base::DoNothing()); |
| |
| ExpectFileContents(cdm_file_for_remote_one, kEmptyFileValue); |
| ExpectFileContents(cdm_file_two_for_remote_one, kEmptyFileValue); |
| |
| ExpectFileContents(cdm_file_for_remote_two, kPopulatedFileValue); |
| } |
| |
| TEST_P(CdmStorageManagerSingularTest, DeleteFileNoDatabase) { |
| cdm_storage_manager_->DeleteFile(kTestStorageKey, kCdmType, kFileNameTwo, |
| base::DoNothing()); |
| } |
| |
| // This test case tests when there is a file written to the CdmStorageDatabase |
| // from two different profiles with the same file name, cdm type, and storage |
| // key. We want to make sure that although they share the same qualities, |
| // deleting the file from one of the profiles does not affect the other profile. |
| TEST_P(CdmStorageManagerMultipleTest, DeleteFile) { |
| cdm_storage_manager_->OpenCdmStorage( |
| CdmStorageBindingContext(kTestStorageKey, kCdmType), |
| cdm_storage_.BindNewPipeAndPassReceiver()); |
| auto cdm_file = OpenCdmFile(cdm_storage_, kFileName); |
| ASSERT_TRUE(cdm_file.is_bound()); |
| |
| Write(cdm_file, kPopulatedFileValue); |
| |
| ExpectFileContents(cdm_file, kPopulatedFileValue); |
| |
| cdm_storage_manager_two_->OpenCdmStorage( |
| CdmStorageBindingContext(kTestStorageKey, kCdmType), |
| cdm_storage_two_.BindNewPipeAndPassReceiver()); |
| auto cdm_file_two = OpenCdmFile(cdm_storage_two_, kFileName); |
| ASSERT_TRUE(cdm_file_two.is_bound()); |
| |
| Write(cdm_file_two, kPopulatedFileValue); |
| |
| ExpectFileContents(cdm_file_two, kPopulatedFileValue); |
| |
| cdm_storage_manager_->DeleteFile(kTestStorageKey, kCdmType, kFileName, |
| base::DoNothing()); |
| |
| ExpectFileContents(cdm_file, kEmptyFileValue); |
| ExpectFileContents(cdm_file_two, kPopulatedFileValue); |
| } |
| |
| // This tests deletion of multiple files under the same storage key. Since the |
| // files are written from multiple profiles with the same storage key, we verify |
| // that deletion from one profile does not affect the files written to the same |
| // storage key from another profile. |
| TEST_P(CdmStorageManagerMultipleTest, DeleteDataForStorageKey) { |
| auto time_test_started = base::Time::Now(); |
| |
| cdm_storage_manager_->OpenCdmStorage( |
| CdmStorageBindingContext(kTestStorageKey, kCdmType), |
| cdm_storage_.BindNewPipeAndPassReceiver()); |
| |
| auto cdm_file_for_remote_one = OpenCdmFile(cdm_storage_, kFileName); |
| Write(cdm_file_for_remote_one, kPopulatedFileValue); |
| ASSERT_TRUE(cdm_file_for_remote_one.is_bound()); |
| |
| auto cdm_file_two_for_remote_one = OpenCdmFile(cdm_storage_, kFileNameTwo); |
| Write(cdm_file_two_for_remote_one, kPopulatedFileValue); |
| ASSERT_TRUE(cdm_file_two_for_remote_one.is_bound()); |
| |
| cdm_storage_manager_two_->OpenCdmStorage( |
| CdmStorageBindingContext(kTestStorageKey, kCdmType), |
| cdm_storage_two_.BindNewPipeAndPassReceiver()); |
| |
| auto cdm_file_for_remote_two = OpenCdmFile(cdm_storage_two_, kFileNameTwo); |
| Write(cdm_file_for_remote_two, kPopulatedFileValue); |
| ASSERT_TRUE(cdm_file_for_remote_two.is_bound()); |
| |
| cdm_storage_manager_->DeleteData(base::NullCallback(), kTestStorageKey, |
| base::Time::Min(), time_test_started, |
| base::DoNothing()); |
| |
| ExpectFileContents(cdm_file_for_remote_one, kPopulatedFileValue); |
| ExpectFileContents(cdm_file_two_for_remote_one, kPopulatedFileValue); |
| |
| ExpectFileContents(cdm_file_for_remote_two, kPopulatedFileValue); |
| |
| cdm_storage_manager_->DeleteData(base::NullCallback(), kTestStorageKey, |
| base::Time::Min(), base::Time::Max(), |
| base::DoNothing()); |
| |
| ExpectFileContents(cdm_file_for_remote_one, kEmptyFileValue); |
| ExpectFileContents(cdm_file_two_for_remote_one, kEmptyFileValue); |
| |
| ExpectFileContents(cdm_file_for_remote_two, kPopulatedFileValue); |
| } |
| |
| TEST_P(CdmStorageManagerMultipleTest, DeleteDataForStorageKeyTimeSpecified) { |
| cdm_storage_manager_->OpenCdmStorage( |
| CdmStorageBindingContext(kTestStorageKey, kCdmType), |
| cdm_storage_.BindNewPipeAndPassReceiver()); |
| |
| auto cdm_file_for_remote_one = OpenCdmFile(cdm_storage_, kFileName); |
| Write(cdm_file_for_remote_one, kPopulatedFileValue); |
| ASSERT_TRUE(cdm_file_for_remote_one.is_bound()); |
| |
| auto cdm_file_two_for_remote_one = OpenCdmFile(cdm_storage_, kFileNameTwo); |
| Write(cdm_file_two_for_remote_one, kPopulatedFileValue); |
| ASSERT_TRUE(cdm_file_two_for_remote_one.is_bound()); |
| |
| cdm_storage_manager_two_->OpenCdmStorage( |
| CdmStorageBindingContext(kTestStorageKey, kCdmType), |
| cdm_storage_two_.BindNewPipeAndPassReceiver()); |
| |
| auto cdm_file_for_remote_two = OpenCdmFile(cdm_storage_two_, kFileNameTwo); |
| Write(cdm_file_for_remote_two, kPopulatedFileValue); |
| ASSERT_TRUE(cdm_file_for_remote_two.is_bound()); |
| |
| cdm_storage_manager_->DeleteData(base::NullCallback(), kTestStorageKey, |
| base::Time::Min(), base::Time::Max(), |
| base::DoNothing()); |
| ExpectFileContents(cdm_file_for_remote_one, kEmptyFileValue); |
| ExpectFileContents(cdm_file_two_for_remote_one, kEmptyFileValue); |
| |
| ExpectFileContents(cdm_file_for_remote_two, kPopulatedFileValue); |
| } |
| |
| TEST_P(CdmStorageManagerMultipleTest, DeleteFileNoDatabase) { |
| cdm_storage_manager_->DeleteFile(kTestStorageKey, kCdmType, kFileNameTwo, |
| base::DoNothing()); |
| cdm_storage_manager_two_->DeleteFile(kTestStorageKey, kCdmType, kFileNameTwo, |
| base::DoNothing()); |
| } |
| |
| TEST_P(CdmStorageManagerMultipleTest, GetSizeForFileNoDatabase) { |
| base::test::TestFuture<uint64_t> get_size_future; |
| cdm_storage_manager_->GetSizeForFile(kTestStorageKey, kCdmType, kFileNameTwo, |
| get_size_future.GetCallback()); |
| EXPECT_EQ(get_size_future.Get(), 0u); |
| |
| base::test::TestFuture<uint64_t> get_size_future_two; |
| cdm_storage_manager_two_->GetSizeForFile(kTestStorageKey, kCdmType, |
| kFileNameTwo, |
| get_size_future_two.GetCallback()); |
| EXPECT_EQ(get_size_future_two.Get(), 0u); |
| } |
| |
| TEST_P(CdmStorageManagerMultipleTest, GetSizeForTests) { |
| auto time_test_started = base::Time::Now(); |
| cdm_storage_manager_->OpenCdmStorage( |
| CdmStorageBindingContext(kTestStorageKey, kCdmType), |
| cdm_storage_.BindNewPipeAndPassReceiver()); |
| |
| auto cdm_file_for_remote_one = OpenCdmFile(cdm_storage_, kFileName); |
| Write(cdm_file_for_remote_one, kPopulatedFileValue); |
| ASSERT_TRUE(cdm_file_for_remote_one.is_bound()); |
| |
| auto cdm_file_two_for_remote_one = OpenCdmFile(cdm_storage_, kFileNameTwo); |
| Write(cdm_file_two_for_remote_one, kPopulatedFileValueTwo); |
| ASSERT_TRUE(cdm_file_two_for_remote_one.is_bound()); |
| |
| cdm_storage_manager_two_->OpenCdmStorage( |
| CdmStorageBindingContext(kTestStorageKey, kCdmType), |
| cdm_storage_two_.BindNewPipeAndPassReceiver()); |
| |
| auto cdm_file_for_remote_two = OpenCdmFile(cdm_storage_two_, kFileNameTwo); |
| Write(cdm_file_for_remote_two, kPopulatedFileValue); |
| ASSERT_TRUE(cdm_file_for_remote_two.is_bound()); |
| |
| base::test::TestFuture<uint64_t> get_size_time_frame_future; |
| cdm_storage_manager_->GetSizeForTimeFrame( |
| base::Time::Min(), base::Time::Max(), |
| get_size_time_frame_future.GetCallback()); |
| EXPECT_EQ(get_size_time_frame_future.Get(), |
| kPopulatedFileValue.size() + kPopulatedFileValueTwo.size()); |
| |
| base::test::TestFuture<uint64_t> get_size_time_frame_future_two; |
| cdm_storage_manager_two_->GetSizeForTimeFrame( |
| time_test_started, base::Time::Max(), |
| get_size_time_frame_future_two.GetCallback()); |
| EXPECT_EQ(get_size_time_frame_future_two.Get(), kPopulatedFileValue.size()); |
| |
| base::test::TestFuture<uint64_t> get_size_storage_key; |
| cdm_storage_manager_->GetSizeForStorageKey( |
| kTestStorageKey, time_test_started, base::Time::Max(), |
| get_size_storage_key.GetCallback()); |
| EXPECT_EQ(get_size_storage_key.Get(), |
| kPopulatedFileValue.size() + kPopulatedFileValueTwo.size()); |
| |
| base::test::TestFuture<uint64_t> get_size_file; |
| cdm_storage_manager_->GetSizeForFile(kTestStorageKey, kCdmType, kFileName, |
| get_size_file.GetCallback()); |
| EXPECT_EQ(get_size_file.Get(), kPopulatedFileValue.size()); |
| } |
| |
| // `testing::Bool()` represents either incognito, or a non incognito profile, so |
| // that we test on both. |
| INSTANTIATE_TEST_SUITE_P(, |
| CdmStorageManagerSingularTest, |
| /*is_profile_incognito=*/testing::Bool()); |
| |
| // The pairs represent different combinations of the types of profiles that |
| // can exist on Chrome together. |
| INSTANTIATE_TEST_SUITE_P( |
| , |
| CdmStorageManagerMultipleTest, |
| testing::Combine(/*is_profile_one_incognito=*/testing::Bool(), |
| /*is_profile_two_incognito=*/testing::Bool())); |
| |
| } // namespace content |
