| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "media/remoting/remoting_renderer_controller.h" |
| 6 |
| 7 #include "base/callback.h" |
| 8 #include "base/message_loop/message_loop.h" |
| 9 #include "base/run_loop.h" |
| 10 #include "media/base/audio_decoder_config.h" |
| 11 #include "media/base/cdm_config.h" |
| 12 #include "media/base/limits.h" |
| 13 #include "media/base/media_util.h" |
| 14 #include "media/base/test_helpers.h" |
| 15 #include "media/base/video_decoder_config.h" |
| 16 #include "media/remoting/fake_remoting_controller.h" |
| 17 #include "media/remoting/remoting_cdm.h" |
| 18 #include "mojo/public/cpp/bindings/strong_binding.h" |
| 19 #include "testing/gtest/include/gtest/gtest.h" |
| 20 |
| 21 namespace media { |
| 22 namespace { |
| 23 |
| 24 PipelineMetadata DefaultMetadata() { |
| 25 PipelineMetadata data; |
| 26 data.has_audio = true; |
| 27 data.has_video = true; |
| 28 data.video_decoder_config = TestVideoConfig::Normal(); |
| 29 return data; |
| 30 } |
| 31 |
| 32 PipelineMetadata EncryptedMetadata() { |
| 33 PipelineMetadata data; |
| 34 data.has_audio = true; |
| 35 data.has_video = true; |
| 36 data.video_decoder_config = TestVideoConfig::NormalEncrypted(); |
| 37 return data; |
| 38 } |
| 39 |
| 40 } // namespace |
| 41 |
| 42 class RemotingRendererControllerTest : public ::testing::Test { |
| 43 public: |
| 44 RemotingRendererControllerTest() {} |
| 45 ~RemotingRendererControllerTest() override {} |
| 46 |
| 47 void TearDown() final { RunUntilIdle(); } |
| 48 |
| 49 static void RunUntilIdle() { base::RunLoop().RunUntilIdle(); } |
| 50 |
| 51 void ToggleRenderer() { |
| 52 is_rendering_remotely_ = |
| 53 remoting_renderer_controller_->remote_rendering_started(); |
| 54 } |
| 55 |
| 56 void CreateCdm(bool is_remoting) { is_remoting_cdm_ = is_remoting; } |
| 57 |
| 58 base::MessageLoop message_loop_; |
| 59 |
| 60 protected: |
| 61 std::unique_ptr<RemotingRendererController> remoting_renderer_controller_; |
| 62 bool is_rendering_remotely_ = false; |
| 63 bool is_remoting_cdm_ = false; |
| 64 |
| 65 private: |
| 66 DISALLOW_COPY_AND_ASSIGN(RemotingRendererControllerTest); |
| 67 }; |
| 68 |
| 69 TEST_F(RemotingRendererControllerTest, ToggleRenderer) { |
| 70 EXPECT_FALSE(is_rendering_remotely_); |
| 71 scoped_refptr<RemotingSourceImpl> remoting_source_impl = |
| 72 CreateRemotingSourceImpl(false); |
| 73 remoting_renderer_controller_ = |
| 74 base::MakeUnique<RemotingRendererController>(remoting_source_impl); |
| 75 remoting_renderer_controller_->SetSwitchRendererCallback(base::Bind( |
| 76 &RemotingRendererControllerTest::ToggleRenderer, base::Unretained(this))); |
| 77 RunUntilIdle(); |
| 78 EXPECT_FALSE(is_rendering_remotely_); |
| 79 remoting_source_impl->OnSinkAvailable(); |
| 80 RunUntilIdle(); |
| 81 EXPECT_FALSE(is_rendering_remotely_); |
| 82 remoting_renderer_controller_->OnEnteredFullscreen(); |
| 83 RunUntilIdle(); |
| 84 EXPECT_FALSE(is_rendering_remotely_); |
| 85 remoting_renderer_controller_->OnMetadataChanged(DefaultMetadata()); |
| 86 RunUntilIdle(); |
| 87 EXPECT_TRUE(is_rendering_remotely_); |
| 88 remoting_renderer_controller_->OnExitedFullscreen(); |
| 89 RunUntilIdle(); |
| 90 EXPECT_FALSE(is_rendering_remotely_); |
| 91 } |
| 92 |
| 93 TEST_F(RemotingRendererControllerTest, StartFailed) { |
| 94 EXPECT_FALSE(is_rendering_remotely_); |
| 95 scoped_refptr<RemotingSourceImpl> remoting_source_impl = |
| 96 CreateRemotingSourceImpl(true); |
| 97 remoting_renderer_controller_ = |
| 98 base::MakeUnique<RemotingRendererController>(remoting_source_impl); |
| 99 remoting_renderer_controller_->SetSwitchRendererCallback(base::Bind( |
| 100 &RemotingRendererControllerTest::ToggleRenderer, base::Unretained(this))); |
| 101 RunUntilIdle(); |
| 102 EXPECT_FALSE(is_rendering_remotely_); |
| 103 remoting_source_impl->OnSinkAvailable(); |
| 104 RunUntilIdle(); |
| 105 EXPECT_FALSE(is_rendering_remotely_); |
| 106 remoting_renderer_controller_->OnEnteredFullscreen(); |
| 107 RunUntilIdle(); |
| 108 EXPECT_FALSE(is_rendering_remotely_); |
| 109 remoting_renderer_controller_->OnMetadataChanged(DefaultMetadata()); |
| 110 RunUntilIdle(); |
| 111 EXPECT_FALSE(is_rendering_remotely_); |
| 112 } |
| 113 |
| 114 TEST_F(RemotingRendererControllerTest, EncryptedWithRemotingCdm) { |
| 115 EXPECT_FALSE(is_rendering_remotely_); |
| 116 remoting_renderer_controller_ = base::MakeUnique<RemotingRendererController>( |
| 117 CreateRemotingSourceImpl(false)); |
| 118 remoting_renderer_controller_->SetSwitchRendererCallback(base::Bind( |
| 119 &RemotingRendererControllerTest::ToggleRenderer, base::Unretained(this))); |
| 120 RunUntilIdle(); |
| 121 EXPECT_FALSE(is_rendering_remotely_); |
| 122 remoting_renderer_controller_->OnMetadataChanged(EncryptedMetadata()); |
| 123 RunUntilIdle(); |
| 124 EXPECT_FALSE(is_rendering_remotely_); |
| 125 scoped_refptr<RemotingSourceImpl> cdm_remoting_source_impl = |
| 126 CreateRemotingSourceImpl(false); |
| 127 std::unique_ptr<RemotingCdmController> remoting_cdm_controller = |
| 128 base::MakeUnique<RemotingCdmController>(cdm_remoting_source_impl); |
| 129 cdm_remoting_source_impl->OnSinkAvailable(); |
| 130 remoting_cdm_controller->ShouldCreateRemotingCdm(base::Bind( |
| 131 &RemotingRendererControllerTest::CreateCdm, base::Unretained(this))); |
| 132 RunUntilIdle(); |
| 133 EXPECT_FALSE(is_rendering_remotely_); |
| 134 EXPECT_TRUE(is_remoting_cdm_); |
| 135 |
| 136 // Create a RemotingCdm with |remoting_cdm_controller|. |
| 137 scoped_refptr<RemotingCdm> remoting_cdm = new RemotingCdm( |
| 138 std::string(), GURL(), CdmConfig(), SessionMessageCB(), SessionClosedCB(), |
| 139 SessionKeysChangeCB(), SessionExpirationUpdateCB(), CdmCreatedCB(), |
| 140 std::move(remoting_cdm_controller)); |
| 141 std::unique_ptr<RemotingCdmContext> remoting_cdm_context = |
| 142 base::MakeUnique<RemotingCdmContext>(remoting_cdm.get()); |
| 143 remoting_renderer_controller_->OnSetCdm(remoting_cdm_context.get()); |
| 144 RunUntilIdle(); |
| 145 EXPECT_TRUE(is_rendering_remotely_); |
| 146 |
| 147 // For encrypted contents, entering/exiting full screen has no effect. |
| 148 remoting_renderer_controller_->OnEnteredFullscreen(); |
| 149 RunUntilIdle(); |
| 150 EXPECT_TRUE(is_rendering_remotely_); |
| 151 remoting_renderer_controller_->OnExitedFullscreen(); |
| 152 RunUntilIdle(); |
| 153 EXPECT_TRUE(is_rendering_remotely_); |
| 154 |
| 155 EXPECT_NE(RemotingSessionState::SESSION_PERMANENTLY_STOPPED, |
| 156 remoting_renderer_controller_->remoting_source()->state()); |
| 157 cdm_remoting_source_impl->OnSinkGone(); |
| 158 RunUntilIdle(); |
| 159 EXPECT_EQ(RemotingSessionState::SESSION_PERMANENTLY_STOPPED, |
| 160 remoting_renderer_controller_->remoting_source()->state()); |
| 161 // Don't switch renderer in this case. Still in remoting. |
| 162 EXPECT_TRUE(is_rendering_remotely_); |
| 163 } |
| 164 |
| 165 TEST_F(RemotingRendererControllerTest, EncryptedWithLocalCdm) { |
| 166 EXPECT_FALSE(is_rendering_remotely_); |
| 167 scoped_refptr<RemotingSourceImpl> renderer_remoting_source_impl = |
| 168 CreateRemotingSourceImpl(false); |
| 169 remoting_renderer_controller_ = base::MakeUnique<RemotingRendererController>( |
| 170 renderer_remoting_source_impl); |
| 171 remoting_renderer_controller_->SetSwitchRendererCallback(base::Bind( |
| 172 &RemotingRendererControllerTest::ToggleRenderer, base::Unretained(this))); |
| 173 RunUntilIdle(); |
| 174 EXPECT_FALSE(is_rendering_remotely_); |
| 175 renderer_remoting_source_impl->OnSinkAvailable(); |
| 176 RunUntilIdle(); |
| 177 EXPECT_FALSE(is_rendering_remotely_); |
| 178 remoting_renderer_controller_->OnEnteredFullscreen(); |
| 179 RunUntilIdle(); |
| 180 EXPECT_FALSE(is_rendering_remotely_); |
| 181 remoting_renderer_controller_->OnMetadataChanged(EncryptedMetadata()); |
| 182 RunUntilIdle(); |
| 183 EXPECT_FALSE(is_rendering_remotely_); |
| 184 |
| 185 scoped_refptr<RemotingSourceImpl> cdm_remoting_source_impl = |
| 186 CreateRemotingSourceImpl(true); |
| 187 std::unique_ptr<RemotingCdmController> remoting_cdm_controller = |
| 188 base::MakeUnique<RemotingCdmController>(cdm_remoting_source_impl); |
| 189 cdm_remoting_source_impl->OnSinkAvailable(); |
| 190 remoting_cdm_controller->ShouldCreateRemotingCdm(base::Bind( |
| 191 &RemotingRendererControllerTest::CreateCdm, base::Unretained(this))); |
| 192 RunUntilIdle(); |
| 193 EXPECT_FALSE(is_rendering_remotely_); |
| 194 EXPECT_FALSE(is_remoting_cdm_); |
| 195 } |
| 196 |
| 197 TEST_F(RemotingRendererControllerTest, EncryptedWithFailedRemotingCdm) { |
| 198 EXPECT_FALSE(is_rendering_remotely_); |
| 199 remoting_renderer_controller_ = base::MakeUnique<RemotingRendererController>( |
| 200 CreateRemotingSourceImpl(false)); |
| 201 remoting_renderer_controller_->SetSwitchRendererCallback(base::Bind( |
| 202 &RemotingRendererControllerTest::ToggleRenderer, base::Unretained(this))); |
| 203 RunUntilIdle(); |
| 204 EXPECT_FALSE(is_rendering_remotely_); |
| 205 remoting_renderer_controller_->OnEnteredFullscreen(); |
| 206 RunUntilIdle(); |
| 207 EXPECT_FALSE(is_rendering_remotely_); |
| 208 remoting_renderer_controller_->OnMetadataChanged(EncryptedMetadata()); |
| 209 RunUntilIdle(); |
| 210 EXPECT_FALSE(is_rendering_remotely_); |
| 211 |
| 212 scoped_refptr<RemotingSourceImpl> cdm_remoting_source_impl = |
| 213 CreateRemotingSourceImpl(false); |
| 214 std::unique_ptr<RemotingCdmController> remoting_cdm_controller = |
| 215 base::MakeUnique<RemotingCdmController>(cdm_remoting_source_impl); |
| 216 cdm_remoting_source_impl->OnSinkAvailable(); |
| 217 remoting_cdm_controller->ShouldCreateRemotingCdm(base::Bind( |
| 218 &RemotingRendererControllerTest::CreateCdm, base::Unretained(this))); |
| 219 RunUntilIdle(); |
| 220 EXPECT_FALSE(is_rendering_remotely_); |
| 221 EXPECT_TRUE(is_remoting_cdm_); |
| 222 |
| 223 cdm_remoting_source_impl->OnSinkGone(); |
| 224 RunUntilIdle(); |
| 225 EXPECT_FALSE(is_rendering_remotely_); |
| 226 EXPECT_NE(RemotingSessionState::SESSION_PERMANENTLY_STOPPED, |
| 227 remoting_renderer_controller_->remoting_source()->state()); |
| 228 |
| 229 scoped_refptr<RemotingCdm> remoting_cdm = new RemotingCdm( |
| 230 std::string(), GURL(), CdmConfig(), SessionMessageCB(), SessionClosedCB(), |
| 231 SessionKeysChangeCB(), SessionExpirationUpdateCB(), CdmCreatedCB(), |
| 232 std::move(remoting_cdm_controller)); |
| 233 std::unique_ptr<RemotingCdmContext> remoting_cdm_context = |
| 234 base::MakeUnique<RemotingCdmContext>(remoting_cdm.get()); |
| 235 remoting_renderer_controller_->OnSetCdm(remoting_cdm_context.get()); |
| 236 RunUntilIdle(); |
| 237 // Switch to remoting renderer even when the remoting CDM session was already |
| 238 // terminated. |
| 239 EXPECT_TRUE(is_rendering_remotely_); |
| 240 EXPECT_EQ(RemotingSessionState::SESSION_PERMANENTLY_STOPPED, |
| 241 remoting_renderer_controller_->remoting_source()->state()); |
| 242 } |
| 243 |
| 244 } // namespace media |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2457563002:
Media Remoting: Add remoting control logic for encrypted contents. (Closed)
