diff --git a/media/base/BUILD.gn b/media/base/BUILD.gn index 6886ed6b5c7dd8cea6ea430c36239ad83403d41d..11128a20ac4599e63ed35d7670fa58cbe0e62478 100644 --- a/media/base/BUILD.gn +++ b/media/base/BUILD.gn @@ -693,6 +693,13 @@ source_set("unit_tests") { "ohos/ohos_media_player_bridge_unittest.cc", "ohos/ohos_media_player_callback_unittest.cc", "ohos/ohos_media_player_listener_unittest.cc", + "ohos/ohos_media_crypto_context_impl_unittest.cc", + "ohos/ohos_media_drm_bridge_client_unittest.cc", + "ohos/ohos_media_drm_bridge_delegate_unittest.cc", + "ohos/ohos_cdm_factory_unittests.cc", + "ohos/ohos_media_drm_bridge_factory_unittest.cc", + "ohos/ohos_media_drm_storage_bridge_unittest.cc", + "ohos/ohos_media_drm_bridge_unittest.cc", ] } diff --git a/media/base/ohos/ohos_cdm_factory_unittests.cc b/media/base/ohos/ohos_cdm_factory_unittests.cc new file mode 100644 index 0000000000000000000000000000000000000000..565dda0bd30770cec7d4960811bcecd48cfc2f61 --- /dev/null +++ b/media/base/ohos/ohos_cdm_factory_unittests.cc @@ -0,0 +1,128 @@ +#include "base/test/test_simple_task_runner.h" +#include "media/base/cdm_config.h" +#include "media/base/content_decryption_module.h" +#include "media/base/ohos/ohos_media_drm_bridge.h" +#include "media/base/provision_fetcher.h" +#include "media/cdm/aes_decryptor.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" +#define private public +#include "media/base/ohos/ohos_cdm_factory.h" +#undef private +using ::testing::_; + +namespace media { +class MockContentDecryptionModule : public ContentDecryptionModule { + public: + MOCK_METHOD(void, + SetServerCertificate, + (const std::vector& certificate, + std::unique_ptr promise), + (override)); + + MOCK_METHOD(void, + GetStatusForPolicy, + (HdcpVersion min_hdcp_version, + std::unique_ptr promise), + ()); + + MOCK_METHOD(void, + CreateSessionAndGenerateRequest, + (CdmSessionType session_type, + EmeInitDataType init_data_type, + const std::vector& init_data, + std::unique_ptr promise), + (override)); + + MOCK_METHOD(void, + LoadSession, + (CdmSessionType session_type, + const std::string& session_id, + std::unique_ptr promise), + (override)); + + MOCK_METHOD(void, + UpdateSession, + (const std::string& session_id, + const std::vector& response, + std::unique_ptr promise), + (override)); + + MOCK_METHOD(void, + CloseSession, + (const std::string& session_id, + std::unique_ptr promise), + (override)); + + MOCK_METHOD(void, + RemoveSession, + (const std::string& session_id, + std::unique_ptr promise), + (override)); + + MOCK_METHOD(CdmContext*, GetCdmContext, (), (override)); +}; + +class OHOSCdmFactoryTest : public ::testing::Test { + protected: + OHOSCdmFactoryTest() = default; + ~OHOSCdmFactoryTest() override = default; + + void SetUp() override { + CreateFetcherCB create_fetcher_cb_; + CreateStorageCB create_storage_cb_; + cdm_factory = std::make_unique(create_fetcher_cb_, + create_storage_cb_); + } + + void TearDown() override { cdm_factory.reset(); } + std::unique_ptr cdm_factory; +}; + +TEST_F(OHOSCdmFactoryTest, Create) { + CdmConfig cdm_config; + SessionMessageCB session_message_cb; + SessionClosedCB session_closed_cb; + SessionKeysChangeCB session_keys_change_cb; + SessionExpirationUpdateCB session_expiration_update_cb; + scoped_refptr created_cdm; + std::string error_message; + CdmCreatedCB cdm_created_cb = base::BindOnce( + [](scoped_refptr* out_cdm, + std::string* out_error_message, + const scoped_refptr& cdm, + const std::string& error_message) { + *out_cdm = cdm; + *out_error_message = error_message; + }, + &created_cdm, &error_message); + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd1(task_runner); + + cdm_factory->Create(cdm_config, session_message_cb, session_closed_cb, + session_keys_change_cb, session_expiration_update_cb, + std::move(cdm_created_cb)); + EXPECT_TRUE(cdm_factory->pending_creations_.empty()); +} + +TEST_F(OHOSCdmFactoryTest, OnCdmCreated) { + const uint32_t creation_id = 1; + scoped_refptr cdm( + new MockContentDecryptionModule()); + EXPECT_CALL(*cdm, CreateSessionAndGenerateRequest(_, _, _, _)).Times(0); + EXPECT_TRUE(cdm.get() != nullptr); + std::string error_message = "Success"; + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd1(task_runner); + auto cdm_created_cb_ = [](const scoped_refptr& cdm, + const std::string& error_message) {}; + CdmCreatedCB cdm_created_cb = base::BindOnce(cdm_created_cb_); + cdm_factory->pending_creations_.emplace( + creation_id, std::make_pair(nullptr, std::move(cdm_created_cb))); + cdm_factory->OnCdmCreated(creation_id, cdm, error_message); + ASSERT_NE(cdm_factory, nullptr); + EXPECT_TRUE(cdm_factory->pending_creations_.empty()); +} +} // namespace media diff --git a/media/base/ohos/ohos_media_codec_util_unittest.cc b/media/base/ohos/ohos_media_codec_util_unittest.cc index a3a753dc8a5c341d66bc7dcd354bd8de647e46cd..76ded00979b27cd6c00fa1a6e02c20ca828e9336 100755 --- a/media/base/ohos/ohos_media_codec_util_unittest.cc +++ b/media/base/ohos/ohos_media_codec_util_unittest.cc @@ -14,106 +14,203 @@ */ #include "ohos_media_codec_util.h" -#include "ohos_adapter_helper.h" -#include -#include "testing/gtest/include/gtest/gtest.h" #include #include "base/logging.h" +#include "base/task/single_thread_task_executor.h" #include "base/task/task_runner.h" #include "base/trace_event/trace_event.h" -#include "base/task/single_thread_task_executor.h" +#include "media/base/audio_codecs.h" #include "media/base/ohos/decoder_format_adapter_impl.h" +#include "media/base/video_codecs.h" +#include "ohos_adapter_helper.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" #include "third_party/ohos_ndk/includes/ohos_adapter/adapter_base.h" using ::testing::_; +using ::testing::AtLeast; using ::testing::Eq; -using ::testing::Ref; -using ::testing::Return; using ::testing::Invoke; -using ::testing::AtLeast; -using ::testing::NiceMock; using ::testing::MockFunction; +using ::testing::NiceMock; +using ::testing::Ref; +using ::testing::Return; -namespace media{ +namespace media { class MockMediaCodecListAdapter : public OHOS::NWeb::MediaCodecListAdapter { -public: - MOCK_METHOD(std::shared_ptr, GetCodecCapability, - (const std::string&, bool), (override)); + public: + MOCK_METHOD(std::shared_ptr, + GetCodecCapability, + (const std::string&, bool), + (override)); }; class MockOhosAdapterHelper : public OHOS::NWeb::OhosAdapterHelper { -public: - MOCK_METHOD(std::unique_ptr, CreateAafwkAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreatePowerMgrClientAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateDisplayMgrAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateBatteryClientAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateNetConnectAdapter, (), (override)); - MOCK_METHOD(OhosWebDataBaseAdapter&, GetOhosWebDataBaseAdapterInstance, (), (override)); + public: + MOCK_METHOD(std::unique_ptr, + CreateAafwkAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreatePowerMgrClientAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateDisplayMgrAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateBatteryClientAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateNetConnectAdapter, + (), + (override)); + MOCK_METHOD(OhosWebDataBaseAdapter&, + GetOhosWebDataBaseAdapterInstance, + (), + (override)); MOCK_METHOD(PasteBoardClientAdapter&, GetPasteBoard, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateAudioRendererAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateAudioCapturerAdapter, (), (override)); - MOCK_METHOD(AudioSystemManagerAdapter&, GetAudioSystemManager, (), (override)); - MOCK_METHOD(OhosWebPermissionDataBaseAdapter&, GetWebPermissionDataBaseInstance, (), (override)); + MOCK_METHOD(std::unique_ptr, + CreateAudioRendererAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateAudioCapturerAdapter, + (), + (override)); + MOCK_METHOD(AudioSystemManagerAdapter&, + GetAudioSystemManager, + (), + (override)); + MOCK_METHOD(OhosWebPermissionDataBaseAdapter&, + GetWebPermissionDataBaseInstance, + (), + (override)); MOCK_METHOD(std::unique_ptr, CreateMMIAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateSocPerfClientAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, GetResourceAdapter, (const std::string&), (override)); - MOCK_METHOD(SystemPropertiesAdapter&, GetSystemPropertiesInstance, (), (override)); + MOCK_METHOD(std::unique_ptr, + CreateSocPerfClientAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + GetResourceAdapter, + (const std::string&), + (override)); + MOCK_METHOD(SystemPropertiesAdapter&, + GetSystemPropertiesInstance, + (), + (override)); MOCK_METHOD(VSyncAdapter&, GetVSyncAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, GetInitWebAdapter, (), (override)); + MOCK_METHOD(std::unique_ptr, + GetInitWebAdapter, + (), + (override)); MOCK_METHOD(KeystoreAdapter&, GetKeystoreAdapterInstance, (), (override)); - MOCK_METHOD(EnterpriseDeviceManagementAdapter&, GetEnterpriseDeviceManagementInstance, (), (override)); + MOCK_METHOD(EnterpriseDeviceManagementAdapter&, + GetEnterpriseDeviceManagementInstance, + (), + (override)); MOCK_METHOD(DatashareAdapter&, GetDatashareInstance, (), (override)); MOCK_METHOD(std::unique_ptr, CreateIMFAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, GetRootCertDataAdapter, (), (override)); - MOCK_METHOD(AccessTokenAdapter&, GetAccessTokenAdapterInstance, (), (override)); - MOCK_METHOD(std::unique_ptr, GetEventHandlerAdapter, (), (override)); + MOCK_METHOD(std::unique_ptr, + GetRootCertDataAdapter, + (), + (override)); + MOCK_METHOD(AccessTokenAdapter&, + GetAccessTokenAdapterInstance, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + GetEventHandlerAdapter, + (), + (override)); MOCK_METHOD(PrintManagerAdapter&, GetPrintManagerInstance, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateConsumerSurfaceAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreatePlayerAdapter, (), (override)); + MOCK_METHOD(std::unique_ptr, + CreateConsumerSurfaceAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreatePlayerAdapter, + (), + (override)); MOCK_METHOD(WindowAdapter&, GetWindowAdapterInstance, (), (override)); MOCK_METHOD(HiSysEventAdapter&, GetHiSysEventAdapterInstance, (), (override)); MOCK_METHOD(HiTraceAdapter&, GetHiTraceAdapterInstance, (), (override)); MOCK_METHOD(NetProxyAdapter&, GetNetProxyInstance, (), (override)); MOCK_METHOD(CameraManagerAdapter&, GetCameraManagerAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateScreenCaptureAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateDateTimeFormatAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateMediaCodecDecoderAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateNativeImageAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateMediaCodecEncoderAdapter, (), (override)); + MOCK_METHOD(std::unique_ptr, + CreateScreenCaptureAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateDateTimeFormatAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateMediaCodecDecoderAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateNativeImageAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateMediaCodecEncoderAdapter, + (), + (override)); MOCK_METHOD(MediaCodecListAdapter&, GetMediaCodecListAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateFlowbufferAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateMediaAVSessionAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateOhosImageDecoderAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateSensorAdapter, (), (override)); - MOCK_METHOD(void, SetArkWebCoreHapPathOverride, (const std::string&), (override)); - + MOCK_METHOD(std::unique_ptr, + CreateFlowbufferAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateMediaAVSessionAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateOhosImageDecoderAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateSensorAdapter, + (), + (override)); + MOCK_METHOD(void, + SetArkWebCoreHapPathOverride, + (const std::string&), + (override)); + MOCK_METHOD(OhosNativeBufferAdapter&, + GetOhosNativeBufferAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, CreateDrmAdapter, (), (override)); static MockOhosAdapterHelper& GetInstance() { static MockOhosAdapterHelper instance; return instance; - } + } }; class MockCapabilityDataAdapter : public CapabilityDataAdapter { -public: + public: MOCK_METHOD(int32_t, GetMaxWidth, (), (override)); MOCK_METHOD(int32_t, GetMaxHeight, (), (override)); MOCK_METHOD(int32_t, GetMaxframeRate, (), (override)); }; class OHOSMediaCodecUtilTest : public ::testing::Test { -protected: + protected: void SetUp() override { mock_adapter_helper_ = new testing::NiceMock; ON_CALL(*mock_adapter_helper_, GetMediaCodecListAdapter()) - .WillByDefault(testing::ReturnRef(mock_media_codec_list_adapter_)); + .WillByDefault(testing::ReturnRef(mock_media_codec_list_adapter_)); } - void TearDown() override { - delete mock_adapter_helper_; - } + void TearDown() override { delete mock_adapter_helper_; } - std::shared_ptr mock_capability_data_adapter_; + std::shared_ptr + mock_capability_data_adapter_; media::MockOhosAdapterHelper* mock_adapter_helper_; media::MockMediaCodecListAdapter mock_media_codec_list_adapter_; }; @@ -131,4 +228,98 @@ TEST_F(OHOSMediaCodecUtilTest, GetCodecCapabilityReturnsCorrectValues) { ASSERT_NE(capability.maxHeight, 0); ASSERT_NE(capability.maxframeRate, 0); } + +TEST_F(OHOSMediaCodecUtilTest, CodecToOHOSMimeType) { + auto result = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kMP3); + EXPECT_EQ(result, "audio/mpeg"); +} + +TEST_F(OHOSMediaCodecUtilTest, CodecToOHOSMimeType_Audio) { + auto result1 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kMP3, + kSampleFormatAc3); + EXPECT_EQ(result1, "audio/raw"); + + auto result2 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kVorbis, + kUnknownSampleFormat); + EXPECT_EQ(result2, "audio/vorbis"); + + auto result3 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kMP3, + kUnknownSampleFormat); + EXPECT_EQ(result3, "audio/mpeg"); + + auto result4 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kFLAC, + kUnknownSampleFormat); + EXPECT_EQ(result4, "audio/flac"); + + auto result5 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kOpus, + kUnknownSampleFormat); + EXPECT_EQ(result5, "audio/opus"); + + auto result6 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kOpus, + kUnknownSampleFormat); + EXPECT_EQ(result6, "audio/opus"); + + auto result7 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kAAC, + kUnknownSampleFormat); + EXPECT_EQ(result7, "audio/mp4a-latm"); + + auto result8 = OHOSMediaCodecUtil::CodecToOHOSMimeType( + AudioCodec::kAC3, kSampleFormatPlanarS32); + EXPECT_EQ(result8, "audio/raw"); + + auto result9 = OHOSMediaCodecUtil::CodecToOHOSMimeType( + AudioCodec::kDTS, kSampleFormatPlanarS32); + EXPECT_EQ(result9, "audio/raw"); + + auto result10 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kDTSE, + kUnknownSampleFormat); + EXPECT_EQ(result10, "audio/vnd.dts;profile=lbr"); + + auto result11 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kDTSXP2, + kUnknownSampleFormat); + EXPECT_EQ(result11, "audio/raw"); +} + +TEST_F(OHOSMediaCodecUtilTest, CodecToOHOSMimeType_Video) { + auto result1 = OHOSMediaCodecUtil::CodecToOHOSMimeType(VideoCodec::kH264); + EXPECT_EQ(result1, "video/avc"); + + auto result2 = OHOSMediaCodecUtil::CodecToOHOSMimeType(VideoCodec::kHEVC); + EXPECT_EQ(result1, "video/avc"); + + auto result3 = OHOSMediaCodecUtil::CodecToOHOSMimeType(VideoCodec::kVP8); + EXPECT_EQ(result3, "video/x-vnd.on2.vp8"); + + auto result4 = OHOSMediaCodecUtil::CodecToOHOSMimeType(VideoCodec::kVP9); + EXPECT_EQ(result4, "video/x-vnd.on2.vp9"); + + auto result5 = + OHOSMediaCodecUtil::CodecToOHOSMimeType(VideoCodec::kDolbyVision); + EXPECT_EQ(result5, "video/dolby-vision"); + + auto result6 = OHOSMediaCodecUtil::CodecToOHOSMimeType(VideoCodec::kAV1); + EXPECT_EQ(result6, "video/av01"); +} + +TEST_F(OHOSMediaCodecUtilTest, IsPassthroughAudioFormat) { + auto result_true = + OHOSMediaCodecUtil::IsPassthroughAudioFormat(AudioCodec::kAC3); + EXPECT_EQ(result_true, true); + + auto result_false = + OHOSMediaCodecUtil::IsPassthroughAudioFormat(AudioCodec::kMP3); + EXPECT_EQ(result_false, false); +} + +TEST_F(OHOSMediaCodecUtilTest, CanDecode_Video) { + VideoCodec codec = VideoCodec::kDolbyVision; + bool result_true = OHOSMediaCodecUtil::CanDecode(codec, false); + EXPECT_TRUE(result_true); +} + +TEST_F(OHOSMediaCodecUtilTest, CanDecode_Audio) { + AudioCodec codec = AudioCodec::kAC3; + bool result_true = OHOSMediaCodecUtil::CanDecode(codec); + EXPECT_TRUE(result_true); +} } // namespace media \ No newline at end of file diff --git a/media/base/ohos/ohos_media_crypto_context_impl_unittest.cc b/media/base/ohos/ohos_media_crypto_context_impl_unittest.cc new file mode 100644 index 0000000000000000000000000000000000000000..d42217118edeb203d06e1bd3ad26c20458aef1a2 --- /dev/null +++ b/media/base/ohos/ohos_media_crypto_context_impl_unittest.cc @@ -0,0 +1,71 @@ +#include "media/base/ohos/ohos_media_crypto_context_impl.h" +#include "base/test/test_simple_task_runner.h" +#include "media/base/cdm_context.h" +#include "media/base/ohos/ohos_media_crypto_context.h" +#define private public +#include "base/task/single_thread_task_runner.h" +#include "media/base/ohos/ohos_media_drm_bridge.h" +#undef private +#include "media/base/content_decryption_module.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" +using ::testing::_; + +namespace media { +class MockOHOSMediaCryptoContext : public OHOSMediaCryptoContext { + public: + MOCK_METHOD(void, + SetOHOSMediaCryptoReadyCB, + (OHOSMediaCryptoReadyCB media_crypto_ready_cb), + (override)); +}; + +class OHOSMediaCryptoContextImplTest : public ::testing::Test { + protected: + OHOSMediaCryptoContextImplTest() = default; + ~OHOSMediaCryptoContextImplTest() override = default; + + void SetUp() override { + media_crypto_ready_cb_ = std::make_unique(); + } + + void TearDown() override { + media_crypto_ready_cb_.reset(); + media_crypto_ready.reset(); + storage.reset(); + } + std::unique_ptr media_crypto_ready_cb_; + std::unique_ptr media_crypto_ready; + std::unique_ptr storage; +}; + +TEST_F(OHOSMediaCryptoContextImplTest, SetOHOSMediaCryptoReadyCB) { + EXPECT_CALL(*media_crypto_ready_cb_, SetOHOSMediaCryptoReadyCB(_)).Times(0); + MockOHOSMediaCryptoContext::OHOSMediaCryptoReadyCB callback = + base::BindOnce([](void* session, bool requires_secure_video_codec) {}); + std::vector scheme_uuid_ = {0x10, 0x31}; + std::string origin_id_ = "example_origin_id"; + OHOSMediaDrmBridge::SecurityLevel security_level_ = + OHOSMediaDrmBridge::SECURITY_LEVEL_DEFAULT; + bool requires_media_crypto_ = true; + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + auto storage = std::make_unique(); + CreateFetcherCB create_fetcher_cb_; + SessionMessageCB session_message_cb_; + SessionClosedCB session_closed_cb_; + SessionKeysChangeCB session_keys_change_cb_; + SessionExpirationUpdateCB session_expiration_update_cb_; + OHOSMediaDrmBridge* media_drm_bridge = new OHOSMediaDrmBridge( + scheme_uuid_, origin_id_, security_level_, requires_media_crypto_, + std::move(storage), create_fetcher_cb_, session_message_cb_, + session_closed_cb_, session_keys_change_cb_, + session_expiration_update_cb_); + ASSERT_NE(media_drm_bridge, nullptr); + media_crypto_ready = + std::make_unique(media_drm_bridge); + media_crypto_ready->SetOHOSMediaCryptoReadyCB(std::move(callback)); + ASSERT_NE(media_crypto_ready, nullptr); +} +} // namespace media diff --git a/media/base/ohos/ohos_media_drm_bridge_client_unittest.cc b/media/base/ohos/ohos_media_drm_bridge_client_unittest.cc new file mode 100644 index 0000000000000000000000000000000000000000..21347fc3e02f40f5d6122e3e64cf3e5dc9ca6f0a --- /dev/null +++ b/media/base/ohos/ohos_media_drm_bridge_client_unittest.cc @@ -0,0 +1,37 @@ +#include "media/base/ohos/ohos_media_drm_bridge_client.h" +#include "media/base/ohos/ohos_media_drm_bridge_delegate.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace media { +class SetMediaDrmBridgeClientTest : public ::testing::Test { + protected: + SetMediaDrmBridgeClientTest() = default; + ~SetMediaDrmBridgeClientTest() override = default; + + void SetUp() override { + media_drm_bridge_client_ = std::make_unique(); + } + + void TearDown() override { media_drm_bridge_client_.reset(); } + std::unique_ptr media_drm_bridge_client_; +}; + +TEST_F(SetMediaDrmBridgeClientTest, SetMediaDrmBridgeClient) { + SetMediaDrmBridgeClient(media_drm_bridge_client_.get()); + EXPECT_NE(media_drm_bridge_client_.get(), nullptr); +} + +TEST_F(SetMediaDrmBridgeClientTest, GetMediaDrmBridgeDelegate) { + std::vector scheme_uuid; + UUID test_scheme_uuid(scheme_uuid); + OHOSMediaDrmBridgeDelegate* result = + media_drm_bridge_client_->GetMediaDrmBridgeDelegate(test_scheme_uuid); + EXPECT_EQ(result, nullptr); +} + +TEST_F(SetMediaDrmBridgeClientTest, AddKeySystemUUIDMappings) { + OHOSMediaDrmBridgeClient::KeySystemUuidMap key_system_uuid_map; + media_drm_bridge_client_->AddKeySystemUUIDMappings(&key_system_uuid_map); + EXPECT_TRUE(key_system_uuid_map.empty()); +} +} // namespace media diff --git a/media/base/ohos/ohos_media_drm_bridge_delegate_unittest.cc b/media/base/ohos/ohos_media_drm_bridge_delegate_unittest.cc new file mode 100644 index 0000000000000000000000000000000000000000..1f20c15f9622e418dadf057b67fb46832d9bedda --- /dev/null +++ b/media/base/ohos/ohos_media_drm_bridge_delegate_unittest.cc @@ -0,0 +1,39 @@ +#include "media/base/ohos/ohos_media_drm_bridge_delegate.h" +#include "media/base/ohos/ohos_media_drm_bridge_client.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace media { +class MockOHOSMediaDrmBridgeDelegate : public OHOSMediaDrmBridgeDelegate { + public: + MOCK_METHOD(const UUID, GetUUID, (), (const override)); +}; + +class OHOSMediaDrmBridgeDelegateTest : public ::testing::Test { + protected: + OHOSMediaDrmBridgeDelegateTest() = default; + ~OHOSMediaDrmBridgeDelegateTest() override = default; + void SetUp() override { + mock_delegate_ = std::make_unique(); + } + + void TearDown() override { + mock_delegate_.reset(); + delegate_.reset(); + } + std::unique_ptr delegate_; + std::unique_ptr mock_delegate_; +}; + +TEST_F(OHOSMediaDrmBridgeDelegateTest, OnCreateSession) { + delegate_ = std::move(mock_delegate_); + EmeInitDataType init_data_type = EmeInitDataType::WEBM; + std::vector init_data = {0x01, 0x02, 0x03}; + std::vector init_data_out; + std::vector optional_parameters_out; + bool result = false; + result = delegate_->OnCreateSession(init_data_type, init_data, &init_data_out, + &optional_parameters_out); + EXPECT_TRUE(result); +} +} // namespace media diff --git a/media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc b/media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc new file mode 100644 index 0000000000000000000000000000000000000000..fcb278e64cc6b73e251142cfd663bdbb7640b0ea --- /dev/null +++ b/media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc @@ -0,0 +1,141 @@ +#define private public +#include "media/base/ohos/ohos_media_drm_bridge_factory.h" +#undef private +#include "base/functional/callback_helpers.h" +#include "base/test/test_simple_task_runner.h" +#include "media/base/cdm_config.h" +#include "media/base/content_decryption_module.h" +#include "media/base/media_drm_storage.h" +#include "media/base/ohos/ohos_media_drm_bridge.h" +#include "media/base/provision_fetcher.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "third_party/widevine/cdm/widevine_cdm_common.h" +using ::testing::_; + +namespace media { +class MockMediaDrmStorage : public MediaDrmStorage { + public: + MOCK_METHOD(void, Initialize, (InitCB init_cb), (override)); + MOCK_METHOD(void, OnProvisioned, (ResultCB result_cb), (override)); + MOCK_METHOD(void, + SavePersistentSession, + (const std::string& session_id, + const SessionData& session_data, + ResultCB result_cb), + (override)); + MOCK_METHOD(void, + LoadPersistentSession, + (const std::string& session_id, + LoadPersistentSessionCB load_persistent_session_cb), + (override)); + MOCK_METHOD(void, + RemovePersistentSession, + (const std::string& session_id, ResultCB result_cb), + (override)); +}; + +class MockProvisionFetcher : public ProvisionFetcher { + public: + MOCK_METHOD(void, + Retrieve, + (const GURL&, const std::string&, ResponseCB), + (override)); +}; + +class OHOSMediaDrmBridgeFactoryTest : public ::testing::Test { + protected: + OHOSMediaDrmBridgeFactoryTest() = default; + ~OHOSMediaDrmBridgeFactoryTest() override = default; + + void SetUp() override { + create_fetcher_cb_ = + base::BindRepeating([]() -> std::unique_ptr { + return std::make_unique(); + }); + create_storage_cb_ = + base::BindRepeating([]() -> std::unique_ptr { + return std::make_unique(); + }); + + factory = std::make_unique(create_fetcher_cb_, + create_storage_cb_); + } + + void TearDown() override { + factory.reset(); + create_storage_cb_.Reset(); + create_fetcher_cb_.Reset(); + } + + CdmConfig cdm_config_; + CreateFetcherCB create_fetcher_cb_; + CreateStorageCB create_storage_cb_; + std::unique_ptr factory; + CdmCreatedCB cdm_created_cb_; +}; + +TEST_F(OHOSMediaDrmBridgeFactoryTest, Create) { + cdm_config_.key_system = "nullptr"; + cdm_config_.use_hw_secure_codecs = true; + SessionMessageCB session_message_cb; + SessionClosedCB session_closed_cb; + SessionKeysChangeCB session_keys_change_cb; + SessionExpirationUpdateCB session_expiration_update_cb; + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + auto cdm_created_cb = [](const scoped_refptr& cdm, + const std::string& error_message) {}; + factory->create_storage_cb_ = + base::BindRepeating([]() -> std::unique_ptr { + auto storage = std::make_unique(); + EXPECT_CALL(*storage, Initialize(_)).Times(testing::AtLeast(0)); + return storage; + }); + factory->cdm_created_cb_ = base::BindOnce(cdm_created_cb); + factory->Create(cdm_config_, session_message_cb, session_closed_cb, + session_keys_change_cb, session_expiration_update_cb, + std::move(cdm_created_cb_)); + ASSERT_NE(factory->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeFactoryTest, CreateMediaDrmBridge) { + std::vector scheme_uuid_ = {0x10, 0x31}; + std::string origin_id_ = "origin_id"; + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + auto cdm_created_cb = [](const scoped_refptr& cdm, + const std::string& error_message) {}; + factory->cdm_created_cb_ = base::BindOnce(cdm_created_cb); + factory->CreateMediaDrmBridge(origin_id_); + ASSERT_NE(factory->ohos_media_drm_bridge_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeFactoryTest, OnStorageInitialized) { + bool requires_secure_video_codec = true; + std::vector scheme_uuid_ = {0x10, 0x31}; + std::string origin_id_ = "origin_id"; + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + auto cdm_created_cb = [](const scoped_refptr& cdm, + const std::string& error_message) {}; + factory->cdm_created_cb_ = base::BindOnce(cdm_created_cb); + factory->OnStorageInitialized(requires_secure_video_codec); + ASSERT_EQ(factory->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeFactoryTest, OnOHOSMediaCryptoReady) { + cdm_config_.key_system = "nullptr"; + cdm_config_.use_hw_secure_codecs = true; + void* session = nullptr; + bool requires_secure_video_codec = true; + auto cdm_created_cb = [](const scoped_refptr& cdm, + const std::string& error_message) {}; + factory->cdm_created_cb_ = base::BindOnce(cdm_created_cb); + factory->OnOHOSMediaCryptoReady(session, requires_secure_video_codec); + ASSERT_EQ(factory->ohos_media_drm_bridge_, nullptr); +} +} // namespace media diff --git a/media/base/ohos/ohos_media_drm_bridge_unittest.cc b/media/base/ohos/ohos_media_drm_bridge_unittest.cc new file mode 100644 index 0000000000000000000000000000000000000000..053273ec4c2b62d4f7c316eab9ffc6ffc76066a0 --- /dev/null +++ b/media/base/ohos/ohos_media_drm_bridge_unittest.cc @@ -0,0 +1,977 @@ +#include "base/test/bind.h" +#define private public +#include "media/base/ohos/ohos_media_drm_bridge.h" +#undef private +#include "base/functional/bind.h" +#include "base/test/test_simple_task_runner.h" +#include "media/base/cdm_promise.h" +#include "media/base/content_decryption_module.h" +#include "media/base/ohos/ohos_media_crypto_context_impl.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "third_party/ohos_ndk/includes/ohos_adapter/drm_adapter.h" + +namespace media { +class MockSimpleCdmPromise : public SimpleCdmPromise { + public: + MOCK_METHOD(void, resolve, (), (override)); + MOCK_METHOD(void, + reject, + (Exception exception_code, + uint32_t system_code, + const std::string& error_message), + (override)); +}; + +class MockNewSessionCdmPromise : public media::CdmPromiseTemplate { + public: + MOCK_METHOD(void, resolve, (const std::string& result), (override)); + MOCK_METHOD(void, + reject, + (Exception exception_code, + uint32_t system_code, + const std::string& error_message), + (override)); +}; + +class MockOHOSMediaCryptoContext : public OHOSMediaCryptoContext { + public: + MOCK_METHOD(void, + SetOHOSMediaCryptoReadyCB, + (OHOSMediaCryptoReadyCB media_crypto_ready_cb), + (override)); +}; + +class MockDrmAdapter : public OHOS::NWeb::DrmAdapter { + public: + MOCK_METHOD(bool, IsSupported, (const std::string name), (override)); + MOCK_METHOD(bool, + IsSupported2, + (const std::string name, const std::string mimeType), + (override)); + MOCK_METHOD(bool, + IsSupported3, + (const std::string name, + const std::string mimeType, + int32_t level), + (override)); + MOCK_METHOD(std::vector, GetUUID, (std::string name), (override)); + MOCK_METHOD(void, StorageProvisionedResult, (bool result), (override)); + MOCK_METHOD(void, + StorageSaveInfoResult, + (bool result, int32_t type), + (override)); + MOCK_METHOD(void, + StorageLoadInfoResult, + (std::string sessionId, + std::vector keySetId, + std::string mimeType, + uint32_t keyType), + (override)); + MOCK_METHOD(void, + StorageClearInfoResult, + (bool result, int32_t type), + (override)); + MOCK_METHOD(int32_t, ReleaseMediaKeySystem, (), (override)); + MOCK_METHOD(int32_t, ReleaseMediaKeySession, (), (override)); + MOCK_METHOD(int32_t, + CreateKeySystem, + (const std::string name, int32_t securityLevel), + (override)); + MOCK_METHOD(int32_t, CreateMediaKeySession, (int32_t & level), (override)); + MOCK_METHOD(int32_t, + GenerateKeySystemRequest, + (uint8_t * request, + int32_t* requestLen, + char* defaultUrl, + int32_t defaultUrlLen), + (override)); + MOCK_METHOD(int32_t, + SetConfigurationString, + (const std::string configName, const std::string value), + (override)); + MOCK_METHOD(int32_t, + GetConfigurationString, + (const std::string configName, char* value, int32_t valueLen), + (override)); + MOCK_METHOD(int32_t, + SetConfigurationByteArray, + (const std::string configName, uint8_t* value, int32_t valueLen), + (override)); + MOCK_METHOD(int32_t, + GetConfigurationByteArray, + (const std::string configName, uint8_t* value, int32_t* valueLen), + (override)); + MOCK_METHOD(int32_t, + GetStatistics, + (std::shared_ptr statistics), + (override)); + MOCK_METHOD(int32_t, + GetMaxContentProtectionLevel, + (int32_t & level), + (override)); + MOCK_METHOD(int32_t, + ProcessKeySystemResponse, + (std::string response, bool isResponseReceived), + (override)); + MOCK_METHOD(int32_t, + GetCertificateStatus, + (int32_t & certStatus), + (override)); + MOCK_METHOD(int32_t, + RegistDrmCallback, + (std::shared_ptr callbackAdapter), + (override)); + MOCK_METHOD(int32_t, + SetMediaKeySystemCallback, + (int32_t eventType, uint8_t* info, int32_t infoLen, char* extra), + (override)); + MOCK_METHOD(int32_t, + SetSystemCallback, + (int32_t eventType, uint8_t* info, int32_t infoLen, char* extra), + (override)); + MOCK_METHOD(int32_t, + UpdateSession, + (uint32_t promiseId, + std::string sessionId, + std::vector response), + (override)); + MOCK_METHOD(int32_t, + CloseSession, + (uint32_t promiseId, std::string sessionId), + (override)); + MOCK_METHOD(int32_t, + RemoveSession, + (uint32_t promiseId, std::string sessionId), + (override)); + MOCK_METHOD(int32_t, + LoadSession, + (uint32_t promiseId, std::string sessionId), + (override)); + MOCK_METHOD(int32_t, ClearMediaKeys, (), (override)); + MOCK_METHOD(int32_t, + GenerateOfflineReleaseRequest, + (uint8_t * offlineMediaKeyId, + int32_t offlineMediaKeyIdLen, + uint8_t* releaseRequest, + int32_t* releaseRequestLen), + (override)); + MOCK_METHOD(int32_t, + ProcessOfflineReleaseResponse, + (uint8_t * offlineMediaKeyId, + int32_t offlineMediaKeyIdLen, + uint8_t* releaseRequest, + int32_t releaseRequestLen), + (override)); + MOCK_METHOD(int32_t, + RestoreOfflineMediaKeys, + (uint8_t * offlineMediaKeyId, int32_t offlineMediaKeyIdLen), + (override)); + MOCK_METHOD(int32_t, GetSecurityLevel, (), (override)); + MOCK_METHOD(int32_t, + RequireSecureDecoderModule, + (std::string mimeType, bool& status), + (override)); + MOCK_METHOD(int32_t, + GenerateMediaKeyRequest, + (std::string sessionId, + int32_t type, + int32_t initDataLen, + std::vector initData, + std::string mimeType, + uint32_t promiseId), + (override)); + MOCK_METHOD(int32_t, CheckMediaKeyStatus, (), (override)); +}; + +class MockProvisionFetcher : public ProvisionFetcher { + public: + MOCK_METHOD(void, + Retrieve, + (const GURL&, const std::string&, ResponseCB), + (override)); +}; + +class OHOSMediaDrmBridgeTest : public testing::Test { + protected: + OHOSMediaDrmBridgeTest() = default; + ~OHOSMediaDrmBridgeTest() override = default; + + void SetUp() override { + std::vector scheme_uuid = {0x10, 0x31}; + std::string origin_id = "example_origin_id"; + OHOSMediaDrmBridge::SecurityLevel security_level = + OHOSMediaDrmBridge::SECURITY_LEVEL_DEFAULT; + bool requires_media_crypto = true; + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + std::unique_ptr storage = + std::make_unique(); + media_drm_bridge_ = std::make_unique( + scheme_uuid, origin_id, security_level, requires_media_crypto, + std::move(storage), create_fetcher_cb, session_message_cb, + session_closed_cb, session_keys_change_cb, + session_expiration_update_cb); + cdm_promise_adapter_ = std::make_unique(); + media_crypto_ready_cb_ = std::make_unique(); + ohos_media_drm_storage_bridge_ = + std::make_unique(); + ohos_drm_callback_ = + std::make_unique(media_drm_bridge_.get()); + } + + void TearDown() override { + media_drm_bridge_.release(); + cdm_promise_adapter_.reset(); + media_crypto_ready_cb_.reset(); + ohos_media_drm_storage_bridge_.reset(); + ohos_drm_callback_.reset(); + } + std::unique_ptr media_drm_bridge_; + std::unique_ptr cdm_promise_adapter_; + std::unique_ptr media_crypto_ready_cb_; + std::unique_ptr ohos_media_drm_storage_bridge_; + CreateFetcherCB create_fetcher_cb; + std::unique_ptr ohos_drm_callback_; + SessionMessageCB session_message_cb; + SessionClosedCB session_closed_cb; + SessionKeysChangeCB session_keys_change_cb; + SessionExpirationUpdateCB session_expiration_update_cb; +}; + +TEST_F(OHOSMediaDrmBridgeTest, IsKeySystemSupported) { + const std::string key_system = "key_system_"; + media_drm_bridge_->IsKeySystemSupported(key_system); + EXPECT_FALSE(media_drm_bridge_->IsKeySystemSupported(key_system)); +} + +TEST_F(OHOSMediaDrmBridgeTest, IsPersistentLicenseTypeSupported) { + const std::string key_system = "key_system"; + auto result = media_drm_bridge_->IsPersistentLicenseTypeSupported(key_system); + EXPECT_TRUE(result); +} + +TEST_F(OHOSMediaDrmBridgeTest, IsKeySystemSupportedWithType) { + const std::string key_system = "key_system"; + const std::string container_mime_type = "container_mime_type_"; + auto result = media_drm_bridge_->IsKeySystemSupportedWithType( + key_system, container_mime_type); + EXPECT_FALSE(result); +} + +TEST_F(OHOSMediaDrmBridgeTest, GetPlatformKeySystemNames) { + auto result = media_drm_bridge_->GetPlatformKeySystemNames(); + EXPECT_TRUE(result.empty()); +} + +TEST_F(OHOSMediaDrmBridgeTest, GetUUID) { + const std::string key_system = "key_system"; + auto result = media_drm_bridge_->GetUUID(key_system); + EXPECT_TRUE(result.empty()); +} + +TEST_F(OHOSMediaDrmBridgeTest, CreateInternal) { + std::vector scheme_uuid_ = {0x10, 0x31}; + std::string origin_id_ = "example_origin_id"; + OHOSMediaDrmBridge::SecurityLevel security_level_ = + OHOSMediaDrmBridge::SECURITY_LEVEL_DEFAULT; + bool requires_media_crypto_ = true; + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + std::unique_ptr storage = + std::make_unique(); + CreateFetcherCB create_fetcher_cb_; + SessionMessageCB session_message_cb_; + SessionClosedCB session_closed_cb_; + SessionKeysChangeCB session_keys_change_cb_; + SessionExpirationUpdateCB session_expiration_update_cb_; + media_drm_bridge_->CreateInternal(scheme_uuid_, origin_id_, security_level_, + requires_media_crypto_, std::move(storage), + create_fetcher_cb_, session_message_cb_, + session_closed_cb_, session_keys_change_cb_, + session_expiration_update_cb_); + ASSERT_NE(media_drm_bridge_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, SetServerCertificate) { + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + std::vector certificate = {0x00, 0x01, 0x02, 0x03}; + media_drm_bridge_->SetServerCertificate(certificate, std::move(mock_promise)); + ASSERT_EQ(mock_promise, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, CreateSessionAndGenerateRequest001) { + media::EmeInitDataType init_data_type = media::EmeInitDataType::WEBM; + std::vector init_data = {0x00, 0x01, 0x02, 0x03}; + CdmSessionType session_type = CdmSessionType::kTemporary; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + media_drm_bridge_->CreateSessionAndGenerateRequest( + session_type, init_data_type, init_data, std::move(mock_promise)); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, CreateSessionAndGenerateRequest002) { + media::EmeInitDataType init_data_type = media::EmeInitDataType::WEBM; + std::vector init_data = {0x00, 0x01, 0x02, 0x03}; + CdmSessionType session_type = CdmSessionType::kTemporary; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, + GenerateMediaKeyRequest(testing::_, testing::_, testing::_, + testing::_, testing::_, testing::_)) + .Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->CreateSessionAndGenerateRequest( + session_type, init_data_type, init_data, std::move(mock_promise)); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, LoadSession001) { + const std::string session_id = "session_id"; + CdmSessionType session_type = CdmSessionType::kTemporary; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + media_drm_bridge_->LoadSession(session_type, session_id, + std::move(mock_promise)); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, LoadSession002) { + const std::string session_id = "session_id"; + CdmSessionType session_type = CdmSessionType::kPersistentLicense; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + media_drm_bridge_->LoadSession(session_type, session_id, + std::move(mock_promise)); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, LoadSession003) { + const std::string session_id = "session_id"; + CdmSessionType session_type = CdmSessionType::kPersistentLicense; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, LoadSession(testing::_, testing::_)) + .Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->LoadSession(session_type, session_id, + std::move(mock_promise)); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, UpdateSession001) { + const std::string session_id = "session_id"; + const std::vector response = {1}; + std::unique_ptr mock_promise = + std::make_unique(); + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, + UpdateSession(testing::_, testing::_, testing::_)) + .Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->UpdateSession(session_id, response, + std::move(mock_promise)); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, UpdateSession002) { + const std::string session_id = "session_id"; + const std::vector response = {1}; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + media_drm_bridge_->UpdateSession(session_id, response, + std::move(mock_promise)); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, CloseSession001) { + const std::string session_id = "session_id"; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + media_drm_bridge_->CloseSession(session_id, std::move(mock_promise)); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, CloseSession002) { + const std::string session_id = "session_id"; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, CloseSession(testing::_, testing::_)) + .Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->CloseSession(session_id, std::move(mock_promise)); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, RemoveSession001) { + const std::string session_id = "session_id"; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + media_drm_bridge_->RemoveSession(session_id, std::move(mock_promise)); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, RemoveSession002) { + const std::string session_id = "session_id"; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, RemoveSession(testing::_, testing::_)) + .Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->RemoveSession(session_id, std::move(mock_promise)); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, GetCdmContext) { + auto result = media_drm_bridge_->GetCdmContext(); + ASSERT_NE(result, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, DeleteOnCorrectThread) { + media_drm_bridge_->DeleteOnCorrectThread(); + ASSERT_NE(media_drm_bridge_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, RegisterEventCB) { + base::RepeatingCallback event_cb = + base::BindRepeating([](const media::CdmContext::Event event) -> void {}); + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + auto result = media_drm_bridge_->RegisterEventCB(event_cb); + ASSERT_NE(result, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, GetOHOSMediaCryptoContext) { + auto result = media_drm_bridge_->GetOHOSMediaCryptoContext(); + ASSERT_NE(result, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, IsSecureCodecRequired) { + auto result = media_drm_bridge_->IsSecureCodecRequired(); + ASSERT_EQ(result, false); +} + +TEST_F(OHOSMediaDrmBridgeTest, ResolvePromise) { + uint32_t promise_id = 1; + media_drm_bridge_->ResolvePromise(promise_id); + ASSERT_NE(cdm_promise_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, ResolvePromiseWithSession) { + uint32_t promise_id = 1; + const std::string session_id = "session_id"; + media_drm_bridge_->ResolvePromiseWithSession(promise_id, session_id); + ASSERT_NE(cdm_promise_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, RejectPromise) { + uint32_t promise_id = 1; + CdmPromise::Exception exception_code = { + CdmPromise::Exception::NOT_SUPPORTED_ERROR}; + std::string error_message = "error_message"; + media_drm_bridge_->RejectPromise(promise_id, exception_code, error_message); + ASSERT_NE(cdm_promise_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, SetOHOSMediaCryptoReadyCB) { + MockOHOSMediaCryptoContext::OHOSMediaCryptoReadyCB media_crypto_ready_cb = + base::BindOnce([](void* session, bool requires_secure_video_codec) {}); + media_drm_bridge_->SetOHOSMediaCryptoReadyCB( + std::move(media_crypto_ready_cb)); + ASSERT_NE(media_crypto_ready_cb_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnOHOSMediaCryptoReady) { + media_drm_bridge_->OnOHOSMediaCryptoReady(nullptr); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnProvisionRequest) { + std::string defaultUrl = "defaultUrl"; + std::string requestData = "requestData"; + media_drm_bridge_->OnProvisionRequest(defaultUrl, requestData); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnProvisioningComplete) { + bool success = true; + media_drm_bridge_->provisioning_complete_cb_ = + base::BindOnce([](bool success) {}); + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd1(task_runner); + media_drm_bridge_->OnProvisioningComplete(success); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnPromiseResolved) { + uint32_t promise_id = 1; + media_drm_bridge_->OnPromiseResolved(promise_id); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnPromiseResolvedWithSession) { + uint32_t promise_id = 1; + std::string session_id = "session_id"; + media_drm_bridge_->OnPromiseResolvedWithSession(promise_id, session_id); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnPromiseRejected) { + uint32_t promise_id = 1; + std::string error_message = "error_message"; + media_drm_bridge_->OnPromiseRejected(promise_id, error_message); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageProvisionedResult001) { + bool result = true; + media_drm_bridge_->OnStorageProvisionedResult(result); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageProvisionedResult002) { + bool result = true; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, StorageProvisionedResult(testing::_)) + .Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->OnStorageProvisionedResult(result); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageSaveInfoUpdateResult001) { + bool result = true; + media_drm_bridge_->OnStorageSaveInfoUpdateResult(result); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageSaveInfoUpdateResult002) { + bool result = true; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, + StorageSaveInfoResult(testing::_, testing::_)) + .Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->OnStorageSaveInfoUpdateResult(result); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageSaveInfoRemoveResult001) { + bool result = true; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->OnStorageSaveInfoRemoveResult(result); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageSaveInfoRemoveResult) { + bool result = true; + media_drm_bridge_->OnStorageSaveInfoRemoveResult(result); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageLoadInfoResult001) { + std::vector ket_set_id = {1}; + std::string mime = "mime_type"; + std::string session_id = "session_id"; + uint32_t key_type = 1; + media_drm_bridge_->OnStorageLoadInfoResult(session_id, ket_set_id, mime, + key_type); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageLoadInfoResult002) { + std::vector ket_set_id = {1}; + std::string mime = "mime_type"; + std::string session_id = "session_id"; + uint32_t key_type = 1; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + EXPECT_CALL( + *mock_ohos_drm_adapter, + StorageLoadInfoResult(testing::_, testing::_, testing::_, testing::_)) + .Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->OnStorageLoadInfoResult(session_id, ket_set_id, mime, + key_type); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForKeyReleaseResult001) { + bool result = true; + media_drm_bridge_->OnStorageClearInfoForKeyReleaseResult(result); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForKeyReleaseResult002) { + bool result = true; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, + StorageClearInfoResult(testing::_, testing::_)) + .Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->OnStorageClearInfoForKeyReleaseResult(result); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForLoadFailResult001) { + bool result = true; + media_drm_bridge_->OnStorageClearInfoForLoadFailResult(result); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForLoadFailResult002) { + bool result = true; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, + StorageClearInfoResult(testing::_, testing::_)) + .Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->OnStorageClearInfoForLoadFailResult(result); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageProvisioned) { + media_drm_bridge_->storage_ = nullptr; + media_drm_bridge_->OnStorageProvisioned(); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageSaveInfo) { + std::vector ket_set_id = {1}; + std::string mime_type = "mime_type"; + std::string session_id = "session_id"; + int32_t key_type = 1; + media_drm_bridge_->storage_ = nullptr; + media_drm_bridge_->OnStorageSaveInfo(ket_set_id, mime_type, session_id, + key_type); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForKeyRelease) { + std::string session_id = "session_id"; + media_drm_bridge_->storage_ = nullptr; + media_drm_bridge_->OnStorageClearInfoForKeyRelease(session_id); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageLoadInfo) { + std::string session_id = "session_id"; + media_drm_bridge_->storage_ = nullptr; + media_drm_bridge_->OnStorageLoadInfo(session_id); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForLoadFail) { + std::string session_id = "session_id"; + media_drm_bridge_->storage_ = nullptr; + media_drm_bridge_->OnStorageClearInfoForLoadFail(session_id); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnSessionClosed) { + std::string session_id = "session_id"; + media_drm_bridge_->session_closed_cb_ = base::BindRepeating( + [](const std::string& session_id, CdmSessionClosedReason reason) {}); + media_drm_bridge_->OnSessionClosed(session_id); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnSessionKeysChange) { + std::string session_id = "session_id"; + std::vector keyIdArray = {}; + std::vector statusArray = {}; + bool has_additional_usable_key = false; + SessionKeysChangeCB session_keys_change_cb; + CdmKeysInfo cdm_keys_info; + bool is_key_release = true; + media_drm_bridge_->session_keys_change_cb_ = base::BindRepeating( + [](const std::string& session_id, bool has_additional_usable_key, + CdmKeysInfo keys_info) {}); + media_drm_bridge_->OnSessionKeysChange(session_id, keyIdArray, statusArray, + has_additional_usable_key, + is_key_release); + ASSERT_EQ(keyIdArray.size(), statusArray.size()); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnSessionExpirationUpdate) { + std::string session_id = "session_id"; + uint64_t expiry_time_ms = 1; + media_drm_bridge_->session_expiration_update_cb_ = base::BindRepeating( + [](const std::string& session_id, base::Time new_expiry_time) {}); + media_drm_bridge_->OnSessionExpirationUpdate(session_id, expiry_time_ms); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, GetSecurityLevel001) { + media_drm_bridge_->GetSecurityLevel(); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, GetSecurityLevel002) { + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, GetSecurityLevel()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->GetSecurityLevel(); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, NotifyMediaCryptoReady) { + void* session = nullptr; + media_drm_bridge_->NotifyMediaCryptoReady(session); + ASSERT_NE(media_crypto_ready_cb_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, ProcessProvisionResponse001) { + bool success = false; + const std::string response = "response"; + media_drm_bridge_->ProcessProvisionResponse(success, response); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, ProcessProvisionResponse002) { + bool success = false; + const std::string response = "response"; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, + ProcessKeySystemResponse(testing::_, testing::_)) + .Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->ProcessProvisionResponse(success, response); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnHasAdditionalUsableKey) { + media_drm_bridge_->OnHasAdditionalUsableKey(); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnSessionMessage) { + std::string sessionId = "sessionId"; + int32_t type = 1; + std::vector message = {0x01, 0x02, 0x03, 0x04, 0x05}; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->session_message_cb_ = base::BindRepeating( + [](const std::string& session_id, CdmMessageType message_type, + const std::vector& message) {}); + ohos_drm_callback_->OnSessionMessage(sessionId, type, message); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnProvisionRequest001) { + std::string defaultUrl = "defaultUrl"; + std::string requestData = "requestData"; + ohos_drm_callback_->OnProvisionRequest(defaultUrl, requestData); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnProvisionRequest002) { + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + std::string defaultUrl = "defaultUrl"; + std::string requestData = "requestData"; + ohos_drm_callback_->OnProvisionRequest(defaultUrl, requestData); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnProvisioningCompleteCallback) { + bool success = true; + media_drm_bridge_->provisioning_complete_cb_ = + base::BindOnce([](bool success) {}); + ohos_drm_callback_->OnProvisioningComplete(success); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnMediaKeySessionReady) { + void* session = nullptr; + ohos_drm_callback_->OnMediaKeySessionReady(session); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnPromiseRejectedCallback) { + uint32_t promiseId = 0; + std::string errorMessage = "errorMessage"; + ohos_drm_callback_->OnPromiseRejected(promiseId, errorMessage); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnPromiseResolvedCallback) { + uint32_t promiseId = 0; + ohos_drm_callback_->OnPromiseResolved(promiseId); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnPromiseResolvedWithSessionCallback) { + uint32_t promiseId = 0; + std::string sessionId = "sessionId"; + ohos_drm_callback_->OnPromiseResolvedWithSession(promiseId, sessionId); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnSessionClosedCallback) { + std::string sessionId = "sessionId"; + media_drm_bridge_->session_closed_cb_ = base::BindRepeating( + [](const std::string& session_id, CdmSessionClosedReason reason) {}); + ohos_drm_callback_->OnSessionClosed(sessionId); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnSessionExpirationUpdateCallback) { + std::string sessionId = "sessionId"; + uint64_t expiration_time = 1; + media_drm_bridge_->session_expiration_update_cb_ = base::BindRepeating( + [](const std::string& session_id, base::Time new_expiry_time) {}); + ohos_drm_callback_->OnSessionExpirationUpdate(sessionId, expiration_time); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnSessionKeysChangeCallback) { + std::string sessionId = "sessionId"; + std::vector keyIdArray = {}; + std::vector statusArray = {}; + bool has_additional_usable_key = true; + bool is_key_release = true; + media_drm_bridge_->session_keys_change_cb_ = base::BindRepeating( + [](const std::string& session_id, bool has_additional_usable_key, + CdmKeysInfo keys_info) {}); + ohos_drm_callback_->OnSessionKeysChange(sessionId, keyIdArray, statusArray, + has_additional_usable_key, + is_key_release); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForKeyReleaseCallback) { + std::string session_id = "session_id"; + media_drm_bridge_->storage_ = nullptr; + ohos_drm_callback_->OnStorageClearInfoForKeyRelease(session_id); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageProvisionedCallback) { + media_drm_bridge_->storage_ = nullptr; + ohos_drm_callback_->OnStorageProvisioned(); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageSaveInfoCallback) { + std::vector ket_set_id = {1}; + std::string mime_type = "mime_type"; + std::string session_id = "session_id"; + int32_t key_type = 1; + media_drm_bridge_->storage_ = nullptr; + ohos_drm_callback_->OnStorageSaveInfo(ket_set_id, mime_type, session_id, + key_type); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageLoadInfoCallback) { + std::string session_id = "session_id"; + media_drm_bridge_->storage_ = nullptr; + ohos_drm_callback_->OnStorageLoadInfo(session_id); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, SendProvisioningRequest) { + const GURL default_url("default_url"); + const std::string request_data = "request_data"; + std::unique_ptr mock_provision_fetcher = + std::make_unique(); + EXPECT_CALL(*mock_provision_fetcher, + Retrieve(testing::_, testing::_, testing::_)) + .Times(testing::AnyNumber()); + media_drm_bridge_->create_fetcher_cb_ = + base::BindLambdaForTesting([&]() -> std::unique_ptr { + return std::move(mock_provision_fetcher); + }); + media_drm_bridge_->SendProvisioningRequest(default_url, request_data); + ASSERT_NE(media_drm_bridge_->provision_fetcher_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForLoadFailCallback) { + std::string session_id = "session_id"; + media_drm_bridge_->storage_ = nullptr; + ohos_drm_callback_->OnStorageClearInfoForLoadFail(session_id); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} +} // namespace media diff --git a/media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc b/media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc new file mode 100644 index 0000000000000000000000000000000000000000..acaf34d62245dbe8fc28a7688f188951c9f1b13a --- /dev/null +++ b/media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc @@ -0,0 +1,155 @@ +#include "base/test/bind.h" +#include "base/test/test_simple_task_runner.h" +#define private public +#include "media/base/ohos/ohos_media_drm_storage_bridge.h" +#include "ohos_media_drm_bridge_factory.h" +#undef private +#include "media/base/ohos/ohos_media_drm_bridge.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace media { +class MockMediaDrmStorage : public MediaDrmStorage { + public: + MOCK_METHOD(void, Initialize, (InitCB init_cb), (override)); + MOCK_METHOD(void, OnProvisioned, (ResultCB result_cb), (override)); + MOCK_METHOD(void, + SavePersistentSession, + (const std::string& session_id, + const SessionData& session_data, + ResultCB result_cb), + (override)); + MOCK_METHOD(void, + LoadPersistentSession, + (const std::string& session_id, + LoadPersistentSessionCB load_persistent_session_cb), + (override)); + MOCK_METHOD(void, + RemovePersistentSession, + (const std::string& session_id, ResultCB result_cb), + (override)); +}; + +class MockProvisionFetcher : public ProvisionFetcher { + public: + MOCK_METHOD(void, + Retrieve, + (const GURL&, const std::string&, ResponseCB), + (override)); +}; + +class OHOSMediaDrmStorageBridgeTest : public ::testing::Test { + protected: + OHOSMediaDrmStorageBridgeTest() = default; + ~OHOSMediaDrmStorageBridgeTest() override = default; + void SetUp() override { + create_fetcher_cb_ = + base::BindRepeating([]() -> std::unique_ptr { + return std::make_unique(); + }); + create_storage_cb_ = + base::BindRepeating([]() -> std::unique_ptr { + return std::make_unique(); + }); + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + factory = std::make_unique(); + factory_ = std::make_unique(create_fetcher_cb_, + create_storage_cb_); + } + + void TearDown() override { + factory.reset(); + factory_.reset(); + create_storage_cb_.Reset(); + create_fetcher_cb_.Reset(); + } + CreateStorageCB create_storage_cb_; + CreateFetcherCB create_fetcher_cb_; + std::unique_ptr factory; + std::unique_ptr factory_; +}; + +TEST_F(OHOSMediaDrmStorageBridgeTest, Initialize) { + bool init_cb_ = false; + auto init_cb = base::BindLambdaForTesting( + [&init_cb_](bool result) { init_cb_ = result; }); + factory_->create_storage_cb_ = + base::BindRepeating([]() -> std::unique_ptr { + std::unique_ptr storage = std::make_unique(); + EXPECT_CALL(*storage, Initialize(testing::_)) + .Times(testing::AtLeast(0)); + return storage; + }); + factory->Initialize(factory_->create_storage_cb_, std::move(init_cb)); + ASSERT_NE(factory->impl_, nullptr); +} + +TEST_F(OHOSMediaDrmStorageBridgeTest, OnProvisioned) { + bool result_cb = false; + auto result_cb_ = base::BindLambdaForTesting( + [&result_cb](bool result) { result_cb = result; }); + factory->impl_ = std::make_unique(); + factory->OnProvisioned(std::move(result_cb_)); + ASSERT_NE(factory->impl_, nullptr); +} + +TEST_F(OHOSMediaDrmStorageBridgeTest, OnLoadInfo) { + std::string session_id = "session_id"; + auto result_cb_ = + base::BindOnce([](std::string id, std::vector key, + std::string init_data_type, uint32_t session_id) {}); + factory->impl_ = std::make_unique(); + factory->OnLoadInfo(session_id, std::move(result_cb_)); + ASSERT_NE(factory->impl_, nullptr); +} + +TEST_F(OHOSMediaDrmStorageBridgeTest, OnSaveInfo) { + std::string session_id = "session_id"; + int32_t key_type = 1; + std::vector key_set_id = {1}; + std::string mime = "mime"; + bool result_cb = false; + auto result_cb_ = base::BindLambdaForTesting( + [&result_cb](bool result) { result_cb = result; }); + factory->impl_ = std::make_unique(); + factory->OnSaveInfo(key_set_id, mime, session_id, key_type, result_cb_); + ASSERT_NE(factory->impl_, nullptr); +} + +TEST_F(OHOSMediaDrmStorageBridgeTest, OnClearInfo) { + std::string session_id = "session_id"; + bool result_cb = false; + auto result_cb_ = base::BindLambdaForTesting( + [&result_cb](bool result) { result_cb = result; }); + factory->impl_ = std::make_unique(); + factory->OnClearInfo(session_id, result_cb_); + ASSERT_NE(factory->impl_, nullptr); +} + +TEST_F(OHOSMediaDrmStorageBridgeTest, OnInitialized) { + bool success = true; + auto init_cb = + base::BindLambdaForTesting([&success](bool result) { success = result; }); + MediaDrmStorage::MediaDrmOriginId origin_id(base::UnguessableToken::Create()); + factory->OnInitialized(init_cb, success, origin_id); + ASSERT_TRUE(init_cb); +} + +TEST_F(OHOSMediaDrmStorageBridgeTest, OnSessionDataLoaded) { + std::vector key_set_id = {1}; + std::string mime_type = "mime-type"; + MediaDrmKeyType key_type = MediaDrmKeyType::OFFLINE; + std::unique_ptr session_data_ = + std::make_unique(key_set_id, mime_type, + key_type); + std::string session_id = "session-id"; + auto load_result_cb = + base::BindOnce([](std::string sid, std::vector key_set_id, + std::string mime_type, uint32_t key_type) {}); + factory->OnSessionDataLoaded(std::move(load_result_cb), session_id, + std::move(session_data_)); + ASSERT_EQ(session_data_.get(), nullptr); +} +} // namespace media diff --git a/media/mojo/services/BUILD.gn b/media/mojo/services/BUILD.gn index 1c022dff17ca90bcfdf0dfac683140a1a42ac37a..4406f7ede1560479dac0378e47b4736d53731993 100644 --- a/media/mojo/services/BUILD.gn +++ b/media/mojo/services/BUILD.gn @@ -248,6 +248,8 @@ source_set("unit_tests") { "watch_time_recorder_unittest.cc", "webrtc_video_perf_history_unittest.cc", "webrtc_video_perf_recorder_unittest.cc", + "ohos_mojo_media_client_unittests.cc", + "ohos_mojo_util_unittests.cc", ] if (enable_playback_events_recorder) { diff --git a/media/mojo/services/ohos_mojo_media_client_unittests.cc b/media/mojo/services/ohos_mojo_media_client_unittests.cc new file mode 100644 index 0000000000000000000000000000000000000000..74ed7ef844f57bda9a982f75dabf673cbaae49e3 --- /dev/null +++ b/media/mojo/services/ohos_mojo_media_client_unittests.cc @@ -0,0 +1,66 @@ +#include "media/base/audio_decoder.h" +#include "media/base/media_log.h" +#include "media/base/ohos/ohos_cdm_factory.h" +#include "media/mojo/mojom/frame_interface_factory.mojom.h" +#include "media/mojo/services/ohos_mojo_media_client.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace media { +class MockFrameInterfaceFactory : public mojom::FrameInterfaceFactory { + public: + MOCK_METHOD( + void, + CreateProvisionFetcher, + (mojo::PendingReceiver provision_fetcher), + (override)); + + MOCK_METHOD(void, + CreateCdmStorage, + (mojo::PendingReceiver cdm_storage), + (override)); + + MOCK_METHOD(bool, GetCdmOrigin, (::url::Origin * out_cdm_origin), (override)); + + MOCK_METHOD(void, GetCdmOrigin, (GetCdmOriginCallback callback), (override)); + + MOCK_METHOD(void, + BindEmbedderReceiver, + (mojo::GenericPendingReceiver receiver), + (override)); +}; + +class OHOSMojoMediaClientTest : public ::testing::Test { + protected: + OHOSMojoMediaClientTest() = default; + ~OHOSMojoMediaClientTest() override = default; + + void SetUp() override { + client = std::make_unique(); + Mock_frame_interfaces = std::make_unique(); + } + + void TearDown() override { + client.reset(); + frame_interfaces.reset(); + Mock_frame_interfaces.reset(); + } + std::unique_ptr frame_interfaces; + std::unique_ptr client; + std::unique_ptr Mock_frame_interfaces; +}; + +TEST_F(OHOSMojoMediaClientTest, CreateAudioDecoder) { + scoped_refptr task_runner = nullptr; + std::unique_ptr media_log = nullptr; + auto audio_decoder = + client->CreateAudioDecoder(task_runner, std::move(media_log)); + ASSERT_EQ(audio_decoder, nullptr); +} + +TEST_F(OHOSMojoMediaClientTest, CreateCdmFactory) { + frame_interfaces = std::move(Mock_frame_interfaces); + auto cdm_factory = client->CreateCdmFactory(frame_interfaces.get()); + ASSERT_NE(cdm_factory, nullptr); +} +} // namespace media diff --git a/media/mojo/services/ohos_mojo_util_unittests.cc b/media/mojo/services/ohos_mojo_util_unittests.cc new file mode 100644 index 0000000000000000000000000000000000000000..d2cb562d6dc281152da6d9ae8e9802a6b9b50043 --- /dev/null +++ b/media/mojo/services/ohos_mojo_util_unittests.cc @@ -0,0 +1,80 @@ +#include "base/test/test_simple_task_runner.h" +#include "media/base/media_drm_storage.h" +#include "media/mojo/mojom/frame_interface_factory.mojom.h" +#include "media/mojo/services/mojo_media_drm_storage.h" +#include "media/mojo/services/ohos_mojo_util.h" +#include "mojo/public/cpp/bindings/pending_remote.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" +using ::testing::_; +using ::testing::Invoke; + +namespace media { +namespace ohos_mojo_util { +class MockFrameInterfaceFactory : public mojom::FrameInterfaceFactory { + public: + MOCK_METHOD( + void, + CreateProvisionFetcher, + (mojo::PendingReceiver provision_fetcher), + (override)); + + MOCK_METHOD(void, + CreateCdmStorage, + (mojo::PendingReceiver cdm_storage), + (override)); + + MOCK_METHOD(bool, GetCdmOrigin, (::url::Origin * out_cdm_origin), (override)); + + MOCK_METHOD(void, GetCdmOrigin, (GetCdmOriginCallback callback), (override)); + + MOCK_METHOD(void, + BindEmbedderReceiver, + (mojo::GenericPendingReceiver receiver), + (override)); +}; + +class OHOSMojoUtilTest : public ::testing::Test { + protected: + OHOSMojoUtilTest() = default; + ~OHOSMojoUtilTest() override = default; + + void SetUp() override { + Mock_frame_interfaces = std::make_unique(); + } + + void TearDown() override {} + std::unique_ptr Mock_frame_interfaces; + std::unique_ptr frame_interfaces; +}; + +TEST_F(OHOSMojoUtilTest, CreateProvisionFetcher) { + mojo::PendingRemote provision_fetcher; + EXPECT_CALL(*Mock_frame_interfaces, CreateProvisionFetcher(_)) + .WillOnce(Invoke([&]() { + auto receiver = provision_fetcher.InitWithNewPipeAndPassReceiver(); + })); + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + frame_interfaces = std::move(Mock_frame_interfaces); + auto result = ohos_mojo_util::CreateProvisionFetcher(frame_interfaces.get()); + ASSERT_TRUE(provision_fetcher.is_valid()); +} + +TEST_F(OHOSMojoUtilTest, CreateMediaDrmStorage) { + mojo::PendingRemote media_drm_storage; + EXPECT_CALL(*Mock_frame_interfaces, BindEmbedderReceiver(_)) + .WillOnce(Invoke([&](mojo::GenericPendingReceiver receiver) { + auto receiver_ = media_drm_storage.InitWithNewPipeAndPassReceiver(); + })); + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + frame_interfaces = std::move(Mock_frame_interfaces); + auto result = ohos_mojo_util::CreateMediaDrmStorage(frame_interfaces.get()); + EXPECT_NE(result, nullptr); + ASSERT_TRUE(media_drm_storage.is_valid()); +} +} // namespace ohos_mojo_util +} // namespace media