Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(56)

Side by Side Diff: content/renderer/media/crypto/ppapi_decryptor.cc

Issue 265993002: Add Promises for EME (Chromium side) (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 6 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698