OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/renderer/media/crypto/ppapi_decryptor.h" | 5 #include "content/renderer/media/crypto/ppapi_decryptor.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/callback_helpers.h" | 10 #include "base/callback_helpers.h" |
11 #include "base/location.h" | 11 #include "base/location.h" |
12 #include "base/logging.h" | 12 #include "base/logging.h" |
13 #include "base/message_loop/message_loop.h" | 13 #include "base/message_loop/message_loop.h" |
14 #include "base/message_loop/message_loop_proxy.h" | 14 #include "base/message_loop/message_loop_proxy.h" |
15 #include "content/renderer/media/crypto/key_systems.h" | 15 #include "content/renderer/media/crypto/key_systems.h" |
16 #include "content/renderer/pepper/content_decryptor_delegate.h" | 16 #include "content/renderer/pepper/content_decryptor_delegate.h" |
17 #include "content/renderer/pepper/pepper_plugin_instance_impl.h" | 17 #include "content/renderer/pepper/pepper_plugin_instance_impl.h" |
18 #include "media/base/audio_decoder_config.h" | 18 #include "media/base/audio_decoder_config.h" |
19 #include "media/base/data_buffer.h" | 19 #include "media/base/data_buffer.h" |
20 #include "media/base/decoder_buffer.h" | 20 #include "media/base/decoder_buffer.h" |
| 21 #include "media/base/media_keys_session_promise.h" |
21 #include "media/base/video_decoder_config.h" | 22 #include "media/base/video_decoder_config.h" |
22 #include "media/base/video_frame.h" | 23 #include "media/base/video_frame.h" |
23 | 24 |
24 namespace content { | 25 namespace content { |
25 | 26 |
| 27 // This class is need so that resolving an Update() promise triggers playback |
| 28 // of the stream. |
| 29 class SessionUpdatedPromise : public media::MediaKeysSessionPromise { |
| 30 public: |
| 31 SessionUpdatedPromise( |
| 32 scoped_ptr<media::MediaKeysSessionPromise> caller_promise, |
| 33 media::PromiseResolvedCB resolve_cb); |
| 34 virtual ~SessionUpdatedPromise(); |
| 35 virtual void resolve() OVERRIDE; |
| 36 virtual void resolve(const std::string& web_session_id) OVERRIDE; |
| 37 virtual void reject(const std::string& error_name, |
| 38 uint32 system_code, |
| 39 const std::string& error_message) OVERRIDE; |
| 40 |
| 41 protected: |
| 42 scoped_ptr<media::MediaKeysSessionPromise> caller_promise_; |
| 43 media::PromiseResolvedCB resolve_cb_; |
| 44 }; |
| 45 |
| 46 SessionUpdatedPromise::SessionUpdatedPromise( |
| 47 scoped_ptr<media::MediaKeysSessionPromise> caller_promise, |
| 48 media::PromiseResolvedCB resolve_cb) |
| 49 : caller_promise_(caller_promise.Pass()), |
| 50 resolve_cb_(resolve_cb) { |
| 51 } |
| 52 |
| 53 SessionUpdatedPromise::~SessionUpdatedPromise() { |
| 54 } |
| 55 |
| 56 void SessionUpdatedPromise::resolve() { |
| 57 resolve_cb_.Run(); |
| 58 caller_promise_->resolve(); |
| 59 caller_promise_.reset(); |
| 60 } |
| 61 |
| 62 void SessionUpdatedPromise::resolve(const std::string& web_session_id) { |
| 63 NOTREACHED(); |
| 64 caller_promise_->resolve(web_session_id); |
| 65 caller_promise_.reset(); |
| 66 } |
| 67 void SessionUpdatedPromise::reject(const std::string& error_name, |
| 68 uint32 system_code, |
| 69 const std::string& error_message) { |
| 70 caller_promise_->reject(error_name, system_code, error_message); |
| 71 caller_promise_.reset(); |
| 72 } |
| 73 |
26 scoped_ptr<PpapiDecryptor> PpapiDecryptor::Create( | 74 scoped_ptr<PpapiDecryptor> PpapiDecryptor::Create( |
27 const std::string& key_system, | 75 const std::string& key_system, |
28 const GURL& security_origin, | 76 const GURL& security_origin, |
29 const CreatePepperCdmCB& create_pepper_cdm_cb, | 77 const CreatePepperCdmCB& create_pepper_cdm_cb, |
30 const media::SessionCreatedCB& session_created_cb, | |
31 const media::SessionMessageCB& session_message_cb, | 78 const media::SessionMessageCB& session_message_cb, |
32 const media::SessionReadyCB& session_ready_cb, | 79 const media::SessionReadyCB& session_ready_cb, |
33 const media::SessionClosedCB& session_closed_cb, | 80 const media::SessionClosedCB& session_closed_cb, |
34 const media::SessionErrorCB& session_error_cb) { | 81 const media::SessionErrorCB& session_error_cb) { |
35 std::string plugin_type = GetPepperType(key_system); | 82 std::string plugin_type = GetPepperType(key_system); |
36 DCHECK(!plugin_type.empty()); | 83 DCHECK(!plugin_type.empty()); |
37 scoped_ptr<PepperCdmWrapper> pepper_cdm_wrapper = | 84 scoped_ptr<PepperCdmWrapper> pepper_cdm_wrapper = |
38 create_pepper_cdm_cb.Run(plugin_type, security_origin); | 85 create_pepper_cdm_cb.Run(plugin_type, security_origin); |
39 if (!pepper_cdm_wrapper) { | 86 if (!pepper_cdm_wrapper) { |
40 DLOG(ERROR) << "Plugin instance creation failed."; | 87 DLOG(ERROR) << "Plugin instance creation failed."; |
41 return scoped_ptr<PpapiDecryptor>(); | 88 return scoped_ptr<PpapiDecryptor>(); |
42 } | 89 } |
43 | 90 |
44 return scoped_ptr<PpapiDecryptor>( | 91 return scoped_ptr<PpapiDecryptor>( |
45 new PpapiDecryptor(key_system, | 92 new PpapiDecryptor(key_system, |
46 pepper_cdm_wrapper.Pass(), | 93 pepper_cdm_wrapper.Pass(), |
47 session_created_cb, | |
48 session_message_cb, | 94 session_message_cb, |
49 session_ready_cb, | 95 session_ready_cb, |
50 session_closed_cb, | 96 session_closed_cb, |
51 session_error_cb)); | 97 session_error_cb)); |
52 } | 98 } |
53 | 99 |
54 PpapiDecryptor::PpapiDecryptor( | 100 PpapiDecryptor::PpapiDecryptor( |
55 const std::string& key_system, | 101 const std::string& key_system, |
56 scoped_ptr<PepperCdmWrapper> pepper_cdm_wrapper, | 102 scoped_ptr<PepperCdmWrapper> pepper_cdm_wrapper, |
57 const media::SessionCreatedCB& session_created_cb, | |
58 const media::SessionMessageCB& session_message_cb, | 103 const media::SessionMessageCB& session_message_cb, |
59 const media::SessionReadyCB& session_ready_cb, | 104 const media::SessionReadyCB& session_ready_cb, |
60 const media::SessionClosedCB& session_closed_cb, | 105 const media::SessionClosedCB& session_closed_cb, |
61 const media::SessionErrorCB& session_error_cb) | 106 const media::SessionErrorCB& session_error_cb) |
62 : pepper_cdm_wrapper_(pepper_cdm_wrapper.Pass()), | 107 : pepper_cdm_wrapper_(pepper_cdm_wrapper.Pass()), |
63 session_created_cb_(session_created_cb), | |
64 session_message_cb_(session_message_cb), | 108 session_message_cb_(session_message_cb), |
65 session_ready_cb_(session_ready_cb), | 109 session_ready_cb_(session_ready_cb), |
66 session_closed_cb_(session_closed_cb), | 110 session_closed_cb_(session_closed_cb), |
67 session_error_cb_(session_error_cb), | 111 session_error_cb_(session_error_cb), |
68 render_loop_proxy_(base::MessageLoopProxy::current()), | 112 render_loop_proxy_(base::MessageLoopProxy::current()), |
69 weak_ptr_factory_(this) { | 113 weak_ptr_factory_(this) { |
70 DCHECK(pepper_cdm_wrapper_.get()); | 114 DCHECK(pepper_cdm_wrapper_.get()); |
71 DCHECK(!session_created_cb_.is_null()); | |
72 DCHECK(!session_message_cb_.is_null()); | 115 DCHECK(!session_message_cb_.is_null()); |
73 DCHECK(!session_ready_cb_.is_null()); | 116 DCHECK(!session_ready_cb_.is_null()); |
74 DCHECK(!session_closed_cb_.is_null()); | 117 DCHECK(!session_closed_cb_.is_null()); |
75 DCHECK(!session_error_cb_.is_null()); | 118 DCHECK(!session_error_cb_.is_null()); |
76 | 119 |
77 base::WeakPtr<PpapiDecryptor> weak_this = weak_ptr_factory_.GetWeakPtr(); | 120 base::WeakPtr<PpapiDecryptor> weak_this = weak_ptr_factory_.GetWeakPtr(); |
78 CdmDelegate()->Initialize( | 121 CdmDelegate()->Initialize( |
79 key_system, | 122 key_system, |
80 base::Bind(&PpapiDecryptor::OnSessionCreated, weak_this), | |
81 base::Bind(&PpapiDecryptor::OnSessionMessage, weak_this), | 123 base::Bind(&PpapiDecryptor::OnSessionMessage, weak_this), |
82 base::Bind(&PpapiDecryptor::OnSessionReady, weak_this), | 124 base::Bind(&PpapiDecryptor::OnSessionReady, weak_this), |
83 base::Bind(&PpapiDecryptor::OnSessionClosed, weak_this), | 125 base::Bind(&PpapiDecryptor::OnSessionClosed, weak_this), |
84 base::Bind(&PpapiDecryptor::OnSessionError, weak_this), | 126 base::Bind(&PpapiDecryptor::OnSessionError, weak_this), |
85 base::Bind(&PpapiDecryptor::OnFatalPluginError, weak_this)); | 127 base::Bind(&PpapiDecryptor::OnFatalPluginError, weak_this)); |
86 } | 128 } |
87 | 129 |
88 PpapiDecryptor::~PpapiDecryptor() { | 130 PpapiDecryptor::~PpapiDecryptor() { |
89 pepper_cdm_wrapper_.reset(); | 131 pepper_cdm_wrapper_.reset(); |
90 } | 132 } |
91 | 133 |
92 bool PpapiDecryptor::CreateSession(uint32 session_id, | 134 void PpapiDecryptor::CreateSession( |
93 const std::string& content_type, | 135 const std::string& init_data_type, |
94 const uint8* init_data, | 136 const uint8* init_data, |
95 int init_data_length) { | 137 int init_data_length, |
96 DVLOG(2) << __FUNCTION__; | 138 SessionType session_type, |
97 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); | 139 scoped_ptr<media::MediaKeysSessionPromise> promise) { |
98 | |
99 if (!CdmDelegate() || | |
100 !CdmDelegate()->CreateSession( | |
101 session_id, content_type, init_data, init_data_length)) { | |
102 ReportFailureToCallPlugin(session_id); | |
103 return false; | |
104 } | |
105 | |
106 return true; | |
107 } | |
108 | |
109 void PpapiDecryptor::LoadSession(uint32 session_id, | |
110 const std::string& web_session_id) { | |
111 DVLOG(2) << __FUNCTION__; | 140 DVLOG(2) << __FUNCTION__; |
112 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); | 141 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); |
113 | 142 |
114 if (!CdmDelegate()) { | 143 if (!CdmDelegate()) { |
115 ReportFailureToCallPlugin(session_id); | 144 promise->reject("InvalidStateError", 0, "CdmDelegate() does not exist."); |
| 145 promise.reset(); |
116 return; | 146 return; |
117 } | 147 } |
118 | 148 |
119 CdmDelegate()->LoadSession(session_id, web_session_id); | 149 CdmDelegate()->CreateSession(init_data_type, |
| 150 init_data, |
| 151 init_data_length, |
| 152 session_type, |
| 153 promise.Pass()); |
120 } | 154 } |
121 | 155 |
122 void PpapiDecryptor::UpdateSession(uint32 session_id, | 156 void PpapiDecryptor::LoadSession( |
123 const uint8* response, | 157 const std::string& web_session_id, |
124 int response_length) { | 158 scoped_ptr<media::MediaKeysSessionPromise> promise) { |
125 DVLOG(2) << __FUNCTION__; | 159 DVLOG(2) << __FUNCTION__; |
126 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); | 160 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); |
127 | 161 |
128 if (!CdmDelegate() || | 162 if (!CdmDelegate()) { |
129 !CdmDelegate()->UpdateSession(session_id, response, response_length)) { | 163 promise->reject("InvalidStateError", 0, "CdmDelegate() does not exist."); |
130 ReportFailureToCallPlugin(session_id); | 164 promise.reset(); |
131 return; | 165 return; |
132 } | 166 } |
| 167 |
| 168 CdmDelegate()->LoadSession(web_session_id, promise.Pass()); |
133 } | 169 } |
134 | 170 |
135 void PpapiDecryptor::ReleaseSession(uint32 session_id) { | 171 void PpapiDecryptor::UpdateSession( |
136 DVLOG(2) << __FUNCTION__; | 172 const std::string& web_session_id, |
| 173 const uint8* response, |
| 174 int response_length, |
| 175 scoped_ptr<media::MediaKeysSessionPromise> promise) { |
137 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); | 176 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); |
138 | 177 |
139 if (!CdmDelegate() || !CdmDelegate()->ReleaseSession(session_id)) { | 178 if (!CdmDelegate()) { |
140 ReportFailureToCallPlugin(session_id); | 179 promise->reject("InvalidStateError", 0, "CdmDelegate() does not exist."); |
| 180 promise.reset(); |
141 return; | 181 return; |
142 } | 182 } |
| 183 |
| 184 scoped_ptr<SessionUpdatedPromise> update_promise( |
| 185 new SessionUpdatedPromise(promise.Pass(), |
| 186 base::Bind(&PpapiDecryptor::ResumePlayback, |
| 187 weak_ptr_factory_.GetWeakPtr()))); |
| 188 CdmDelegate()->UpdateSession( |
| 189 web_session_id, |
| 190 response, |
| 191 response_length, |
| 192 update_promise.PassAs<media::MediaKeysSessionPromise>()); |
| 193 } |
| 194 |
| 195 void PpapiDecryptor::ReleaseSession( |
| 196 const std::string& web_session_id, |
| 197 scoped_ptr<media::MediaKeysSessionPromise> promise) { |
| 198 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); |
| 199 |
| 200 if (!CdmDelegate()) { |
| 201 promise->reject("InvalidStateError", 0, "CdmDelegate() does not exist."); |
| 202 promise.reset(); |
| 203 return; |
| 204 } |
| 205 |
| 206 CdmDelegate()->ReleaseSession(web_session_id, promise.Pass()); |
143 } | 207 } |
144 | 208 |
145 media::Decryptor* PpapiDecryptor::GetDecryptor() { | 209 media::Decryptor* PpapiDecryptor::GetDecryptor() { |
146 return this; | 210 return this; |
147 } | 211 } |
148 | 212 |
149 void PpapiDecryptor::RegisterNewKeyCB(StreamType stream_type, | 213 void PpapiDecryptor::RegisterNewKeyCB(StreamType stream_type, |
150 const NewKeyCB& new_key_cb) { | 214 const NewKeyCB& new_key_cb) { |
151 if (!render_loop_proxy_->BelongsToCurrentThread()) { | 215 if (!render_loop_proxy_->BelongsToCurrentThread()) { |
152 render_loop_proxy_->PostTask(FROM_HERE, | 216 render_loop_proxy_->PostTask(FROM_HERE, |
(...skipping 170 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
323 weak_ptr_factory_.GetWeakPtr(), | 387 weak_ptr_factory_.GetWeakPtr(), |
324 stream_type)); | 388 stream_type)); |
325 return; | 389 return; |
326 } | 390 } |
327 | 391 |
328 DVLOG(2) << __FUNCTION__ << " - stream_type: " << stream_type; | 392 DVLOG(2) << __FUNCTION__ << " - stream_type: " << stream_type; |
329 if (CdmDelegate()) | 393 if (CdmDelegate()) |
330 CdmDelegate()->DeinitializeDecoder(stream_type); | 394 CdmDelegate()->DeinitializeDecoder(stream_type); |
331 } | 395 } |
332 | 396 |
333 void PpapiDecryptor::ReportFailureToCallPlugin(uint32 session_id) { | |
334 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); | |
335 DVLOG(1) << "Failed to call plugin."; | |
336 session_error_cb_.Run(session_id, kUnknownError, 0); | |
337 } | |
338 | |
339 void PpapiDecryptor::OnDecoderInitialized(StreamType stream_type, | 397 void PpapiDecryptor::OnDecoderInitialized(StreamType stream_type, |
340 bool success) { | 398 bool success) { |
341 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); | 399 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); |
342 switch (stream_type) { | 400 switch (stream_type) { |
343 case kAudio: | 401 case kAudio: |
344 DCHECK(!audio_decoder_init_cb_.is_null()); | 402 DCHECK(!audio_decoder_init_cb_.is_null()); |
345 base::ResetAndReturn(&audio_decoder_init_cb_).Run(success); | 403 base::ResetAndReturn(&audio_decoder_init_cb_).Run(success); |
346 break; | 404 break; |
347 case kVideo: | 405 case kVideo: |
348 DCHECK(!video_decoder_init_cb_.is_null()); | 406 DCHECK(!video_decoder_init_cb_.is_null()); |
349 base::ResetAndReturn(&video_decoder_init_cb_).Run(success); | 407 base::ResetAndReturn(&video_decoder_init_cb_).Run(success); |
350 break; | 408 break; |
351 default: | 409 default: |
352 NOTREACHED(); | 410 NOTREACHED(); |
353 } | 411 } |
354 } | 412 } |
355 | 413 |
356 void PpapiDecryptor::OnSessionCreated(uint32 session_id, | 414 void PpapiDecryptor::OnSessionMessage(const std::string& web_session_id, |
357 const std::string& web_session_id) { | |
358 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); | |
359 session_created_cb_.Run(session_id, web_session_id); | |
360 } | |
361 | |
362 void PpapiDecryptor::OnSessionMessage(uint32 session_id, | |
363 const std::vector<uint8>& message, | 415 const std::vector<uint8>& message, |
364 const std::string& destination_url) { | 416 const std::string& destination_url) { |
365 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); | 417 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); |
366 session_message_cb_.Run(session_id, message, destination_url); | 418 session_message_cb_.Run(web_session_id, message, destination_url); |
367 } | 419 } |
368 | 420 |
369 void PpapiDecryptor::OnSessionReady(uint32 session_id) { | 421 void PpapiDecryptor::OnSessionReady(const std::string& web_session_id) { |
370 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); | 422 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); |
371 | 423 |
| 424 ResumePlayback(); |
| 425 session_ready_cb_.Run(web_session_id); |
| 426 } |
| 427 |
| 428 void PpapiDecryptor::OnSessionClosed(const std::string& web_session_id) { |
| 429 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); |
| 430 session_closed_cb_.Run(web_session_id); |
| 431 } |
| 432 |
| 433 void PpapiDecryptor::OnSessionError(const std::string& web_session_id, |
| 434 const std::string& error_name, |
| 435 uint32 system_code, |
| 436 const std::string& error_description) { |
| 437 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); |
| 438 session_error_cb_.Run( |
| 439 web_session_id, error_name, system_code, error_description); |
| 440 } |
| 441 |
| 442 void PpapiDecryptor::ResumePlayback() { |
372 // Based on the spec, we need to resume playback when update() completes | 443 // Based on the spec, we need to resume playback when update() completes |
373 // successfully, or when a session is successfully loaded. In both cases, | 444 // successfully, or when a session is successfully loaded (triggered by |
374 // the CDM fires OnSessionReady() event. So we choose to call the NewKeyCBs | 445 // OnSessionReady()). So we choose to call the NewKeyCBs here. |
375 // here. | |
376 // TODO(xhwang): Rename OnSessionReady to indicate that the playback may | |
377 // resume successfully (e.g. a new key is available or available again). | |
378 if (!new_audio_key_cb_.is_null()) | 446 if (!new_audio_key_cb_.is_null()) |
379 new_audio_key_cb_.Run(); | 447 new_audio_key_cb_.Run(); |
380 | 448 |
381 if (!new_video_key_cb_.is_null()) | 449 if (!new_video_key_cb_.is_null()) |
382 new_video_key_cb_.Run(); | 450 new_video_key_cb_.Run(); |
383 | |
384 session_ready_cb_.Run(session_id); | |
385 } | |
386 | |
387 void PpapiDecryptor::OnSessionClosed(uint32 session_id) { | |
388 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); | |
389 session_closed_cb_.Run(session_id); | |
390 } | |
391 | |
392 void PpapiDecryptor::OnSessionError(uint32 session_id, | |
393 media::MediaKeys::KeyError error_code, | |
394 uint32 system_code) { | |
395 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); | |
396 session_error_cb_.Run(session_id, error_code, system_code); | |
397 } | 451 } |
398 | 452 |
399 void PpapiDecryptor::OnFatalPluginError() { | 453 void PpapiDecryptor::OnFatalPluginError() { |
400 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); | 454 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); |
401 pepper_cdm_wrapper_.reset(); | 455 pepper_cdm_wrapper_.reset(); |
402 } | 456 } |
403 | 457 |
404 ContentDecryptorDelegate* PpapiDecryptor::CdmDelegate() { | 458 ContentDecryptorDelegate* PpapiDecryptor::CdmDelegate() { |
405 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); | 459 DCHECK(render_loop_proxy_->BelongsToCurrentThread()); |
406 return (pepper_cdm_wrapper_) ? pepper_cdm_wrapper_->GetCdmDelegate() : NULL; | 460 return (pepper_cdm_wrapper_) ? pepper_cdm_wrapper_->GetCdmDelegate() : NULL; |
407 } | 461 } |
408 | 462 |
409 } // namespace content | 463 } // namespace content |
OLD | NEW |