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/rpc/rpc.h" | |
6 | |
7 #include <algorithm> | |
8 | |
9 #include "base/logging.h" | |
10 #include "base/time/time.h" | |
11 #include "base/values.h" | |
12 #include "media/base/encryption_scheme.h" | |
13 | |
14 #define REQUIRED_IMPL(x, ret) \ | |
15 do { \ | |
16 if (!(x)) { \ | |
17 LOG(ERROR) << "failed l" << __LINE__ << ": " << #x; \ | |
18 return (ret); \ | |
19 } \ | |
20 } while (0) | |
21 | |
22 namespace media { | |
23 namespace remoting { | |
24 | |
25 namespace { | |
26 | |
27 #define RPC(x) pb::x | |
miu
2016/09/08 01:07:35
IMHO, you shouldn't do this. I was not able to imm
erickung1
2016/09/15 02:13:32
Done.
| |
28 | |
29 #define REQUIRED(x) REQUIRED_IMPL(x, false) | |
30 | |
31 bool DeserializeEncryptionScheme(const pb::EncryptionScheme& message, | |
32 ::media::EncryptionScheme* encryption_scheme) { | |
33 ::media::EncryptionScheme::CipherMode mode = | |
34 ::media::EncryptionScheme::CIPHER_MODE_UNENCRYPTED; | |
35 ::media::EncryptionScheme::Pattern pattern; | |
36 uint32_t encrypt_blocks = 0; | |
37 uint32_t skip_blocks = 0; | |
38 | |
39 if (message.has_mode()) | |
40 mode = static_cast<::media::EncryptionScheme::CipherMode>(message.mode()); | |
41 if (message.has_encrypt_blocks()) | |
miu
2016/09/08 01:07:35
Throughout this file: The default value for intege
erickung1
2016/09/15 02:13:32
Done.
| |
42 encrypt_blocks = message.encrypt_blocks(); | |
43 if (message.has_skip_blocks()) | |
44 skip_blocks = message.skip_blocks(); | |
45 REQUIRED(encrypt_blocks >= 0 && skip_blocks >= 0); | |
46 | |
47 pattern = ::media::EncryptionScheme::Pattern(encrypt_blocks, skip_blocks); | |
48 *encryption_scheme = ::media::EncryptionScheme(mode, pattern); | |
49 return true; | |
50 } | |
51 | |
52 bool DeserializeSize(const pb::Size& message, gfx::Size* size) { | |
53 DCHECK(size); | |
54 size->SetSize(message.width(), message.height()); | |
55 return true; | |
56 } | |
57 | |
58 bool DeserializeRect(const pb::Rect& message, gfx::Rect* rect) { | |
59 DCHECK(rect); | |
60 rect->set_x(message.x()); | |
61 rect->set_x(message.y()); | |
62 rect->set_width(message.width()); | |
63 rect->set_height(message.height()); | |
64 return true; | |
65 } | |
66 | |
67 bool DeserializeAudioConfig(const pb::AudioDecoderConfig& audio_message, | |
68 ::media::AudioDecoderConfig* audio_config) { | |
69 DCHECK(audio_config); | |
70 | |
71 ::media::AudioCodec codec = ::media::kUnknownAudioCodec; | |
miu
2016/09/08 01:07:34
General comment: Seems like a lot of these "conver
erickung1
2016/09/15 02:13:32
Done.
| |
72 ::media::SampleFormat sample_format = ::media::kUnknownSampleFormat; | |
73 ::media::ChannelLayout channel_layout = ::media::CHANNEL_LAYOUT_NONE; | |
74 int samples_per_second = 0; | |
75 base::TimeDelta seek_preroll = base::TimeDelta(); | |
76 int codec_delay = 0; | |
77 ::media::EncryptionScheme encryption_scheme; | |
78 std::vector<uint8_t> extra_data; | |
79 | |
80 codec = static_cast<::media::AudioCodec>(audio_message.codec()); | |
81 sample_format = | |
82 static_cast<::media::SampleFormat>(audio_message.sample_format()); | |
83 channel_layout = | |
84 static_cast<::media::ChannelLayout>(audio_message.channel_layout()); | |
85 samples_per_second = audio_message.samples_per_second(); | |
86 seek_preroll = | |
87 base::TimeDelta::FromMicroseconds(audio_message.seek_preroll_usec()); | |
88 codec_delay = audio_message.codec_delay(); | |
89 | |
90 if (audio_message.has_extra_data()) { | |
91 extra_data.assign(audio_message.extra_data().begin(), | |
92 audio_message.extra_data().end()); | |
93 } | |
94 | |
95 const pb::EncryptionScheme encryption_scheme_message = | |
96 audio_message.encryption_scheme(); | |
97 DeserializeEncryptionScheme(encryption_scheme_message, &encryption_scheme); | |
98 | |
99 audio_config->Initialize(codec, sample_format, channel_layout, | |
100 samples_per_second, extra_data, encryption_scheme, | |
101 seek_preroll, codec_delay); | |
102 return true; | |
miu
2016/09/08 01:07:34
Suggest returning audio_config->IsValidConfig() he
erickung1
2016/09/15 02:13:32
Done.
| |
103 } | |
104 | |
105 bool DeserializeVideoConfig(const pb::VideoDecoderConfig& video_message, | |
106 ::media::VideoDecoderConfig* video_config) { | |
107 ::media::VideoCodec codec = ::media::kUnknownVideoCodec; | |
108 ::media::VideoCodecProfile profile = ::media::VIDEO_CODEC_PROFILE_UNKNOWN; | |
109 ::media::VideoPixelFormat format = ::media::PIXEL_FORMAT_UNKNOWN; | |
110 ::media::ColorSpace color_space = ::media::COLOR_SPACE_UNSPECIFIED; | |
111 gfx::Size coded_size(1920, 1080); | |
112 gfx::Rect visible_rect(0, 0, 1920, 1080); | |
113 gfx::Size natural_size(1920, 1080); | |
114 ::media::EncryptionScheme encryption_scheme; | |
115 std::vector<uint8_t> extra_data; | |
116 | |
117 codec = static_cast<::media::VideoCodec>(video_message.codec()); | |
118 profile = static_cast<::media::VideoCodecProfile>(video_message.profile()); | |
119 format = static_cast<::media::VideoPixelFormat>(video_message.format()); | |
120 color_space = static_cast<::media::ColorSpace>(video_message.color_space()); | |
121 | |
122 if (video_message.has_extra_data()) { | |
123 extra_data.assign(video_message.extra_data().begin(), | |
124 video_message.extra_data().end()); | |
125 } | |
126 | |
127 // DCHECK(video_message.has_coded_size()); | |
128 DeserializeSize(video_message.coded_size(), &coded_size); | |
129 | |
130 // DCHECK(video_message.has_visible_rect()); | |
131 DeserializeRect(video_message.visible_rect(), &visible_rect); | |
132 | |
133 // DCHECK(video_message.has_natural_size()); | |
134 DeserializeSize(video_message.natural_size(), &coded_size); | |
135 | |
136 const pb::EncryptionScheme& encryption_scheme_message = | |
137 video_message.encryption_scheme(); | |
138 DeserializeEncryptionScheme(encryption_scheme_message, &encryption_scheme); | |
139 | |
140 video_config->Initialize(codec, profile, format, color_space, coded_size, | |
141 visible_rect, natural_size, extra_data, | |
142 encryption_scheme); | |
143 return true; | |
144 } | |
145 | |
146 bool DeserializeCdmPromiseResult(const pb::CdmPromise& promise_message, | |
miu
2016/09/08 01:07:35
General comment: Please make sure you validate the
erickung1
2016/09/15 02:13:32
Done.
| |
147 CdmPromiseResult* result) { | |
148 REQUIRED(promise_message.has_success()); | |
149 bool success = promise_message.success(); | |
150 if (success) { | |
151 *result = CdmPromiseResult::SuccessResult(); | |
152 return true; | |
153 } | |
154 | |
155 ::media::MediaKeys::Exception exception = ::media::MediaKeys::UNKNOWN_ERROR; | |
156 uint32_t system_code = 0; | |
157 std::string error_message; | |
158 | |
159 exception = | |
160 static_cast<::media::MediaKeys::Exception>(promise_message.exception()); | |
161 system_code = promise_message.system_code(); | |
162 error_message = promise_message.error_message(); | |
163 *result = CdmPromiseResult(exception, system_code, error_message); | |
164 return true; | |
165 } | |
166 | |
167 bool DeserializeCdmKeyInformation( | |
168 const pb::CdmClientOnSessionKeysChange keychange_message, | |
169 std::vector<::media::CdmKeyInformation>* key_information) { | |
170 std::vector<::media::CdmKeyInformation> info; | |
miu
2016/09/08 01:07:35
nit: When populating vectors where you know their
erickung1
2016/09/15 02:13:32
Done. the latest CL doesn't have such usage after
| |
171 | |
172 for (int i = 0; i < keychange_message.key_information_size(); ++i) { | |
173 const pb::CdmKeyInformation key = keychange_message.key_information(i); | |
174 | |
175 ::media::CdmKeyInformation::KeyStatus status = | |
176 ::media::CdmKeyInformation::USABLE; | |
177 uint32_t system_code = 0; | |
178 | |
179 status = static_cast<::media::CdmKeyInformation::KeyStatus>(key.status()); | |
180 system_code = key.system_code(); | |
181 | |
182 info.push_back( | |
183 ::media::CdmKeyInformation(key.key_id(), status, system_code)); | |
184 } | |
185 | |
186 *key_information = std::move(info); | |
187 return true; | |
188 } | |
189 | |
190 #undef REQUIRED | |
191 | |
192 void SerializeEncryptionScheme( | |
193 pb::EncryptionScheme* message, | |
miu
2016/09/08 01:07:35
style: Input arguments, then output arguments.
miu
2016/09/13 05:40:57
Doesn't look like this was addressed in the latest
erickung1
2016/09/15 02:13:32
Done.
erickung1
2016/09/15 02:13:32
Done.
| |
194 const ::media::EncryptionScheme& encryption_scheme) { | |
195 message->set_mode( | |
196 static_cast<pb::EncryptionScheme::CipherMode>(encryption_scheme.mode())); | |
197 message->set_encrypt_blocks(encryption_scheme.pattern().encrypt_blocks()); | |
198 message->set_skip_blocks(encryption_scheme.pattern().skip_blocks()); | |
199 } | |
200 | |
201 void SerializeSize(const gfx::Size& size, pb::Size* message) { | |
202 DCHECK(message); | |
203 message->set_width(size.width()); | |
204 message->set_height(size.height()); | |
205 } | |
206 | |
207 void SerializeRect(pb::Rect* message, const gfx::Rect& rect) { | |
miu
2016/09/08 01:07:35
here too: Input arguments, then output arguments.
erickung1
2016/09/15 02:13:32
Done.
| |
208 message->set_x(rect.x()); | |
209 message->set_y(rect.y()); | |
210 message->set_width(rect.width()); | |
211 message->set_height(rect.height()); | |
212 } | |
213 | |
214 template <class DecoderConfig, class DecoderConfigMessage> | |
215 void SerializeExtraData(const DecoderConfig& config, | |
216 DecoderConfigMessage* decoder_config_message) { | |
217 if (config.extra_data().empty()) | |
218 return; | |
219 | |
220 decoder_config_message->set_extra_data(&config.extra_data()[0], | |
miu
2016/09/08 01:07:35
nit: In C++11 code, you can now use config.extra_d
erickung1
2016/09/15 02:13:32
Done.
| |
221 config.extra_data().size()); | |
222 } | |
223 | |
224 void SerializeAudioConfig(const ::media::AudioDecoderConfig& audio_config, | |
225 pb::AudioDecoderConfig* audio_message) { | |
226 if (!audio_config.IsValidConfig()) | |
227 return; | |
228 | |
229 audio_message->set_codec( | |
230 static_cast<pb::AudioDecoderConfig_Codec>(audio_config.codec())); | |
231 audio_message->set_sample_format( | |
232 static_cast<pb::AudioDecoderConfig_SampleFormat>( | |
233 audio_config.sample_format())); | |
234 audio_message->set_channel_layout( | |
235 static_cast<pb::AudioDecoderConfig_ChannelLayout>( | |
236 audio_config.channel_layout())); | |
237 audio_message->set_samples_per_second(audio_config.samples_per_second()); | |
238 audio_message->set_seek_preroll_usec( | |
239 audio_config.seek_preroll().InMicroseconds()); | |
240 audio_message->set_codec_delay(audio_config.codec_delay()); | |
241 | |
242 SerializeExtraData(audio_config, audio_message); | |
243 | |
244 if (audio_config.is_encrypted()) { | |
245 pb::EncryptionScheme* encryption_scheme_message = | |
246 audio_message->mutable_encryption_scheme(); | |
247 SerializeEncryptionScheme(encryption_scheme_message, | |
248 audio_config.encryption_scheme()); | |
249 } | |
250 } | |
251 | |
252 void SerializeVideoConfig(const ::media::VideoDecoderConfig& video_config, | |
253 pb::VideoDecoderConfig* video_message) { | |
254 if (!video_config.IsValidConfig()) | |
255 return; | |
256 | |
257 video_message->set_codec( | |
258 static_cast<pb::VideoDecoderConfig_Codec>(video_config.codec())); | |
259 video_message->set_profile( | |
260 static_cast<pb::VideoDecoderConfig_Profile>(video_config.profile())); | |
261 video_message->set_format( | |
262 static_cast<pb::VideoDecoderConfig_Format>(video_config.format())); | |
263 video_message->set_color_space(static_cast<pb::VideoDecoderConfig_ColorSpace>( | |
264 video_config.color_space())); | |
265 | |
266 pb::Size* coded_size_message = video_message->mutable_coded_size(); | |
267 SerializeSize(video_config.coded_size(), coded_size_message); | |
268 | |
269 pb::Rect* visible_rect_message = video_message->mutable_visible_rect(); | |
270 SerializeRect(visible_rect_message, video_config.visible_rect()); | |
271 | |
272 pb::Size* natural_size_message = video_message->mutable_natural_size(); | |
273 SerializeSize(video_config.natural_size(), natural_size_message); | |
274 | |
275 SerializeExtraData(video_config, video_message); | |
276 | |
277 if (video_config.is_encrypted()) { | |
278 pb::EncryptionScheme* encryption_scheme_message = | |
279 video_message->mutable_encryption_scheme(); | |
280 SerializeEncryptionScheme(encryption_scheme_message, | |
281 video_config.encryption_scheme()); | |
282 } | |
283 } | |
284 | |
285 void SerializeCdmConfig(const ::media::CdmConfig& cdm_config, | |
286 pb::CdmInitialize* message) { | |
287 std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue()); | |
miu
2016/09/08 01:07:35
Looks like this DictionaryValue is unused. Can you
erickung1
2016/09/15 02:13:32
Done.
| |
288 | |
289 message->set_allow_distinctive_identifier( | |
290 cdm_config.allow_distinctive_identifier); | |
291 message->set_allow_persistent_state(cdm_config.allow_persistent_state); | |
292 message->set_use_hw_secure_codecs(cdm_config.use_hw_secure_codecs); | |
293 } | |
294 | |
295 void SerializeCdmPromiseResult(pb::CdmPromise* promise_message, | |
296 const CdmPromiseResult& result) { | |
297 promise_message->set_success(result.success()); | |
298 if (!result.success()) { | |
299 promise_message->set_exception( | |
300 static_cast<pb::MediaKeysException>(result.exception())); | |
301 promise_message->set_system_code(result.system_code()); | |
302 promise_message->set_error_message(result.error_message()); | |
303 } | |
304 } | |
305 | |
306 void SerializeCdmKeyInformation( | |
307 pb::CdmClientOnSessionKeysChange* key_change_message, | |
308 const std::vector<::media::CdmKeyInformation>& key_information) { | |
309 for (const auto& info : key_information) { | |
310 pb::CdmKeyInformation* key = key_change_message->add_key_information(); | |
311 key->set_key_id(&(info.key_id[0]), info.key_id.size()); | |
312 key->set_status(static_cast<pb::CdmKeyInformation::KeyStatus>(info.status)); | |
313 key->set_system_code(info.system_code); | |
314 } | |
315 } | |
316 | |
317 } // namespace | |
318 | |
319 namespace internal { | |
320 | |
321 #define REQUIRED(x) REQUIRED_IMPL(x, false) | |
322 bool CdmPromiseFromMessage(const pb::CdmPromise& promise_message, | |
323 CdmPromiseResult* result, | |
324 std::string* session_id) { | |
325 REQUIRED(DeserializeCdmPromiseResult(promise_message, result)); | |
326 | |
327 if (session_id) | |
328 *session_id = promise_message.session_id(); | |
329 | |
330 return true; | |
331 } | |
332 #undef REQUIRED | |
333 | |
334 void CdmPromiseToMessage(pb::CdmPromise* promise_message, | |
335 const CdmPromiseResult& result, | |
336 const std::string& session_id) { | |
337 SerializeCdmPromiseResult(promise_message, result); | |
338 if (!session_id.empty()) | |
339 promise_message->set_session_id(session_id); | |
340 } | |
341 | |
342 } // namespace internal | |
343 | |
344 Rpc::Rpc(int handle) : handle_(handle) {} | |
345 | |
346 Rpc::~Rpc() = default; | |
347 | |
348 scoped_refptr<Rpc> Rpc::FromMessage(const std::string& proto_message) { | |
349 DCHECK(!proto_message.empty()); | |
350 | |
351 pb::RpcMessage rpc; | |
352 if (!rpc.ParseFromString(proto_message)) { | |
353 LOG(ERROR) << "Bad proto buffer"; | |
354 return nullptr; | |
355 } | |
356 | |
357 #define CASE(proc, cls) \ | |
358 case proc: \ | |
359 return cls::FromRpcMessage(&rpc) | |
360 switch (rpc.proc()) { | |
361 CASE(RPC(RPC_ACQUIRE_RENDERER), AcquireRendererRpc); | |
362 CASE(RPC(RPC_ACQUIRE_RENDERER_DONE), AcquireRendererDoneRpc); | |
363 CASE(RPC(RPC_ACQUIRE_CDM), AcquireCdmRpc); | |
364 CASE(RPC(RPC_ACQUIRE_CDM_DONE), AcquireCdmDoneRpc); | |
365 CASE(RPC(RPC_R_INITIALIZE), RendererInitializeRpc); | |
366 CASE(RPC(RPC_R_FLUSHUNTIL), RendererFlushUntilRpc); | |
367 CASE(RPC(RPC_R_STARTPLAYINGFROM), RendererStartPlayingFromRpc); | |
368 CASE(RPC(RPC_R_SETPLAYBACKRATE), RendererSetPlaybackRateRpc); | |
369 CASE(RPC(RPC_R_SETVOLUME), RendererSetVolumeRpc); | |
370 CASE(RPC(RPC_R_SETCDM), RendererSetCdmRpc); | |
371 CASE(RPC(RPC_R_INITIALIZE_CALLBACK), RendererInitializeCallbackRpc); | |
372 CASE(RPC(RPC_R_FLUSHUNTIL_CALLBACK), RendererFlushUntilCallbackRpc); | |
373 CASE(RPC(RPC_R_SETCDM_CALLBACK), RendererSetCdmCallbackRpc); | |
374 CASE(RPC(RPC_RC_ONTIMEUPDATE), RendererClientOnTimeUpdateRpc); | |
375 CASE(RPC(RPC_RC_ONBUFFERINGSTATECHANGE), | |
376 RendererClientOnBufferingStateChangeRpc); | |
377 CASE(RPC(RPC_RC_ONENDED), RendererClientOnEndedRpc); | |
378 CASE(RPC(RPC_RC_ONERROR), RendererClientOnErrorRpc); | |
379 CASE(RPC(RPC_RC_ONVIDEONATURALSIZECHANGE), | |
380 RendererClientOnVideoNaturalSizeChangeRpc); | |
381 CASE(RPC(RPC_RC_ONVIDEOOPACITYCHANGE), | |
382 RendererClientOnVideoOpacityChangeRpc); | |
383 CASE(RPC(RPC_RC_ONSTATISTICSUPDATE), RendererClientOnStatisticsUpdateRpc); | |
384 CASE(RPC(RPC_RC_ONWAITINGFORDECRYPTIONKEY), | |
385 RendererClientOnWaitingForDecryptionKeyRpc); | |
386 CASE(RPC(RPC_RC_ONDURATIONCHANGE), RendererClientOnDurationChangeRpc); | |
387 CASE(RPC(RPC_DS_INITIALIZE), DemuxerStreamInitializeRpc); | |
388 CASE(RPC(RPC_DS_ENABLEBITSTREAMCONVERTER), | |
389 DemuxerStreamEnableBitstreamConverterRpc); | |
390 CASE(RPC(RPC_DS_READUNTIL), DemuxerStreamReadUntilRpc); | |
391 CASE(RPC(RPC_DS_INITIALIZE_CALLBACK), DemuxerStreamInitializeCallbackRpc); | |
392 CASE(RPC(RPC_DS_READUNTIL_CALLBACK), DemuxerStreamReadUntilCallbackRpc); | |
393 CASE(RPC(RPC_CDM_SETCLIENT), CdmSetClientRpc); | |
394 CASE(RPC(RPC_CDM_INITIALIZE), CdmInitializeRpc); | |
395 CASE(RPC(RPC_CDM_SETSERVERCERTIFICATE), CdmSetServerCertificateRpc); | |
396 CASE(RPC(RPC_CDM_CREATESESSIONANDGENERATEREQUEST), | |
397 CdmCreateSessionAndGenerateRequestRpc); | |
398 CASE(RPC(RPC_CDM_LOADSESSION), CdmLoadSessionRpc); | |
399 CASE(RPC(RPC_CDM_UPDATESESSION), CdmUpdateSessionRpc); | |
400 CASE(RPC(RPC_CDM_CLOSESESSION), CdmCloseSessionRpc); | |
401 CASE(RPC(RPC_CDM_REMOVESESSION), CdmRemoveSessionRpc); | |
402 CASE(RPC(RPC_CDM_INITIALIZE_CALLBACK), CdmInitializeCallbackRpc); | |
403 CASE(RPC(RPC_CDM_SETSERVERCERTIFICATE_CALLBACK), | |
404 CdmSetServerCertificateCallbackRpc); | |
405 CASE(RPC(RPC_CDM_CREATESESSIONANDGENERATEREQUEST_CALLBACK), | |
406 CdmCreateSessionAndGenerateRequestCallbackRpc); | |
407 CASE(RPC(RPC_CDM_UPDATESESSION_CALLBACK), CdmUpdateSessionCallbackRpc); | |
408 CASE(RPC(RPC_CDM_CLOSESESSION_CALLBACK), CdmCloseSessionCallbackRpc); | |
409 CASE(RPC(RPC_CDM_REMOVESESSION_CALLBACK), CdmRemoveSessionCallbackRpc); | |
410 CASE(RPC(RPC_CDMC_ONSESSIONMESSAGE), CdmClientOnSessionMessageRpc); | |
411 CASE(RPC(RPC_CDMC_ONSESSIONCLOSED), CdmClientOnSessionClosedRpc); | |
412 CASE(RPC(RPC_CDMC_ONSESSIONKEYSCHANGE), CdmClientOnSessionKeysChangeRpc); | |
413 CASE(RPC(RPC_CDMC_ONSESSIONEXPIRATIONUPDATE), | |
414 CdmClientOnSessionExpirationUpdateRpc); | |
415 default: | |
416 LOG(ERROR) << "Unknown Rpc: " << rpc.proc(); | |
417 return nullptr; | |
418 } | |
419 #undef CASE | |
420 } | |
421 | |
422 #define REQUIRED(x) REQUIRED_IMPL(x, nullptr) | |
423 | |
424 std::string Rpc::ToMessage() const { | |
425 pb::RpcMessage rpc; | |
426 ToMessageInternal(&rpc); | |
427 rpc.set_handle(handle_); | |
428 rpc.set_proc(GetProc()); | |
429 std::string proto_msg; | |
430 bool valid = rpc.ByteSize() > 0 && rpc.SerializeToString(&proto_msg); | |
431 DCHECK(valid); | |
432 return proto_msg; | |
433 } | |
434 | |
435 //============================================================================== | |
436 RendererInitializeRpc::RendererInitializeRpc(int handle, | |
437 int client_handle, | |
438 int audio_demuxer_handle, | |
439 int video_demuxer_handle, | |
440 int callback_handle) | |
441 : Rpc(handle), | |
442 client_handle_(client_handle), | |
443 audio_demuxer_handle_(audio_demuxer_handle), | |
444 video_demuxer_handle_(video_demuxer_handle), | |
445 callback_handle_(callback_handle) {} | |
446 | |
447 RendererInitializeRpc::~RendererInitializeRpc() = default; | |
448 | |
449 scoped_refptr<RendererInitializeRpc> RendererInitializeRpc::FromRpcMessage( | |
450 const pb::RpcMessage* rpc) { | |
451 DCHECK_EQ(RPC(RPC_R_INITIALIZE), rpc->proc()); | |
452 | |
453 int client_handle = kInvalidHandle; | |
454 int audio_demuxer_handle = kInvalidHandle; | |
455 int video_demuxer_handle = kInvalidHandle; | |
456 int callback_handle = kInvalidHandle; | |
457 | |
458 DCHECK(rpc->has_renderer_initialize_rpc()); | |
459 const pb::RendererInitialize rpc_message = rpc->renderer_initialize_rpc(); | |
460 client_handle = rpc_message.client_handle(); | |
461 audio_demuxer_handle = rpc_message.audio_demuxer_handle(); | |
462 video_demuxer_handle = rpc_message.video_demuxer_handle(); | |
463 callback_handle = rpc_message.callback_handle(); | |
464 | |
465 VLOG(2) << "client_handle:" << client_handle | |
466 << " audio_demuxer_handle:" << audio_demuxer_handle | |
467 << " video_demuxer_handle:" << video_demuxer_handle | |
468 << " callback_handle:" << callback_handle; | |
469 return new RendererInitializeRpc(rpc->handle(), client_handle, | |
470 audio_demuxer_handle, video_demuxer_handle, | |
471 callback_handle); | |
472 } | |
473 | |
474 pb::RpcProc RendererInitializeRpc::GetProc() const { | |
475 return RPC(RPC_R_INITIALIZE); | |
476 } | |
477 | |
478 void RendererInitializeRpc::ToMessageInternal(pb::RpcMessage* rpc) const { | |
479 VLOG(2) << __FUNCTION__ << "client_handle:" << client_handle_ | |
480 << " audio_demuxer_handle:" << audio_demuxer_handle_ | |
481 << " video_demuxer_handle:" << video_demuxer_handle_ | |
482 << " callback_handle:" << callback_handle_; | |
483 pb::RendererInitialize* message = rpc->mutable_renderer_initialize_rpc(); | |
484 message->set_client_handle(client_handle_); | |
485 message->set_audio_demuxer_handle(audio_demuxer_handle_); | |
486 message->set_video_demuxer_handle(video_demuxer_handle_); | |
487 message->set_callback_handle(callback_handle_); | |
488 } | |
489 | |
490 //============================================================================== | |
491 RendererFlushUntilRpc::RendererFlushUntilRpc(int handle, | |
492 uint32_t audio_frame_id, | |
493 uint32_t video_frame_id, | |
494 int callback_handle) | |
495 : Rpc(handle), | |
496 audio_frame_id_(audio_frame_id), | |
497 video_frame_id_(video_frame_id), | |
498 callback_handle_(callback_handle) {} | |
499 | |
500 RendererFlushUntilRpc::~RendererFlushUntilRpc() = default; | |
501 | |
502 scoped_refptr<RendererFlushUntilRpc> RendererFlushUntilRpc::FromRpcMessage( | |
503 const pb::RpcMessage* rpc) { | |
504 DCHECK_EQ(RPC(RPC_R_FLUSHUNTIL), rpc->proc()); | |
505 | |
506 uint32_t audio_frame_id = 0; | |
507 uint32_t video_frame_id = 0; | |
508 int callback_handle = kInvalidHandle; | |
509 | |
510 DCHECK(rpc->has_renderer_flushuntil_rpc()); | |
511 audio_frame_id = rpc->renderer_flushuntil_rpc().audio_frame_id(); | |
512 video_frame_id = rpc->renderer_flushuntil_rpc().video_frame_id(); | |
513 callback_handle = rpc->renderer_flushuntil_rpc().callback_handle(); | |
514 | |
515 VLOG(2) << "audio_frame_id:" << audio_frame_id | |
516 << " video_frame_id:" << video_frame_id | |
517 << " callback_handle:" << callback_handle; | |
518 return new RendererFlushUntilRpc(rpc->handle(), audio_frame_id, | |
519 video_frame_id, callback_handle); | |
520 } | |
521 | |
522 pb::RpcProc RendererFlushUntilRpc::GetProc() const { | |
523 return RPC(RPC_R_FLUSHUNTIL); | |
524 } | |
525 | |
526 void RendererFlushUntilRpc::ToMessageInternal(pb::RpcMessage* rpc) const { | |
527 VLOG(2) << __FUNCTION__ << "audio_frame_id:" << audio_frame_id_ | |
528 << " video_frame_id:" << video_frame_id_ | |
529 << " callback_handle:" << callback_handle_; | |
530 pb::RendererFlushUntil* message = rpc->mutable_renderer_flushuntil_rpc(); | |
531 message->set_audio_frame_id(audio_frame_id_); | |
532 message->set_video_frame_id(video_frame_id_); | |
533 message->set_callback_handle(callback_handle_); | |
534 } | |
535 | |
536 //============================================================================== | |
537 RendererSetCdmRpc::RendererSetCdmRpc(int handle, | |
538 int cdm_id, | |
539 int callback_handle) | |
540 : Rpc(handle), cdm_id_(cdm_id), callback_handle_(callback_handle) {} | |
541 | |
542 RendererSetCdmRpc::~RendererSetCdmRpc() = default; | |
543 | |
544 scoped_refptr<RendererSetCdmRpc> RendererSetCdmRpc::FromRpcMessage( | |
545 const pb::RpcMessage* rpc) { | |
546 DCHECK_EQ(RPC(RPC_R_SETCDM), rpc->proc()); | |
547 | |
548 REQUIRED(rpc->has_renderer_set_cdm_rpc()); | |
549 const pb::RendererSetCdm rpc_message = rpc->renderer_set_cdm_rpc(); | |
550 int cdm_id = rpc_message.cdm_id(); | |
551 int callback_handle = rpc_message.callback_handle(); | |
552 | |
553 VLOG(2) << "cdm_id:" << cdm_id << " callback_handle:" << callback_handle; | |
554 return new RendererSetCdmRpc(rpc->handle(), cdm_id, callback_handle); | |
555 } | |
556 | |
557 pb::RpcProc RendererSetCdmRpc::GetProc() const { | |
558 return RPC(RPC_R_SETCDM); | |
559 } | |
560 | |
561 void RendererSetCdmRpc::ToMessageInternal(pb::RpcMessage* rpc) const { | |
562 pb::RendererSetCdm* message = rpc->mutable_renderer_set_cdm_rpc(); | |
563 VLOG(2) << __FUNCTION__ << " cdm_id:" << cdm_id_ | |
564 << " callback_handle:" << callback_handle_; | |
565 message->set_cdm_id(cdm_id_); | |
566 message->set_callback_handle(callback_handle_); | |
567 } | |
568 | |
569 //============================================================================== | |
570 RendererClientOnTimeUpdateRpc::RendererClientOnTimeUpdateRpc( | |
571 int handle, | |
572 int64_t time_usec, | |
573 int64_t max_time_usec) | |
574 : Rpc(handle), time_usec_(time_usec), max_time_usec_(max_time_usec) {} | |
575 | |
576 RendererClientOnTimeUpdateRpc::~RendererClientOnTimeUpdateRpc() = default; | |
577 | |
578 scoped_refptr<RendererClientOnTimeUpdateRpc> | |
579 RendererClientOnTimeUpdateRpc::FromRpcMessage(const pb::RpcMessage* rpc) { | |
580 DCHECK_EQ(RPC(RPC_RC_ONTIMEUPDATE), rpc->proc()); | |
581 | |
582 REQUIRED(rpc->has_rendererclient_ontimeupdate_rpc()); | |
583 const pb::RendererClientOnTimeUpdate rpc_message = | |
584 rpc->rendererclient_ontimeupdate_rpc(); | |
585 int64_t time_usec = rpc_message.time_usec(); | |
586 int64_t max_time_usec = rpc_message.max_time_usec(); | |
587 | |
588 VLOG(2) << __FUNCTION__ << " time_usec:" << time_usec | |
589 << " max_time_usec:" << max_time_usec; | |
590 return new RendererClientOnTimeUpdateRpc(rpc->handle(), time_usec, | |
591 max_time_usec); | |
592 } | |
593 | |
594 pb::RpcProc RendererClientOnTimeUpdateRpc::GetProc() const { | |
595 return RPC(RPC_RC_ONTIMEUPDATE); | |
596 } | |
597 | |
598 void RendererClientOnTimeUpdateRpc::ToMessageInternal( | |
599 pb::RpcMessage* rpc) const { | |
600 pb::RendererClientOnTimeUpdate* message = | |
601 rpc->mutable_rendererclient_ontimeupdate_rpc(); | |
602 VLOG(2) << __FUNCTION__ << " time_usec:" << time_usec_ | |
603 << " max_time_usec:" << time_usec_; | |
604 message->set_time_usec(time_usec_); | |
605 message->set_max_time_usec(max_time_usec_); | |
606 } | |
607 | |
608 //============================================================================== | |
609 RendererClientOnVideoNaturalSizeChangeRpc:: | |
610 RendererClientOnVideoNaturalSizeChangeRpc(int handle, const gfx::Size& size) | |
611 : Rpc(handle), size_(size) {} | |
612 | |
613 RendererClientOnVideoNaturalSizeChangeRpc:: | |
614 ~RendererClientOnVideoNaturalSizeChangeRpc() = default; | |
615 | |
616 scoped_refptr<RendererClientOnVideoNaturalSizeChangeRpc> | |
617 RendererClientOnVideoNaturalSizeChangeRpc::FromRpcMessage( | |
618 const pb::RpcMessage* rpc) { | |
619 DCHECK_EQ(RPC(RPC_RC_ONVIDEONATURALSIZECHANGE), rpc->proc()); | |
620 | |
621 REQUIRED(rpc->has_rendererclient_onvideonatualsizechange_rpc()); | |
622 const pb::Size rpc_message = | |
623 rpc->rendererclient_onvideonatualsizechange_rpc(); | |
624 gfx::Size size; | |
625 DeserializeSize(rpc_message, &size); | |
626 | |
627 VLOG(2) << "size:" << size.ToString(); | |
628 return new RendererClientOnVideoNaturalSizeChangeRpc(rpc->handle(), size); | |
629 } | |
630 | |
631 pb::RpcProc RendererClientOnVideoNaturalSizeChangeRpc::GetProc() const { | |
632 return RPC(RPC_RC_ONVIDEONATURALSIZECHANGE); | |
633 } | |
634 | |
635 void RendererClientOnVideoNaturalSizeChangeRpc::ToMessageInternal( | |
636 pb::RpcMessage* rpc) const { | |
637 VLOG(2) << __FUNCTION__ << "size:" << size_.ToString(); | |
638 pb::Size* message = rpc->mutable_rendererclient_onvideonatualsizechange_rpc(); | |
639 SerializeSize(size_, message); | |
640 } | |
641 | |
642 //============================================================================== | |
643 RendererClientOnStatisticsUpdateRpc::RendererClientOnStatisticsUpdateRpc( | |
644 int handle, | |
645 const ::media::PipelineStatistics& stats) | |
646 : Rpc(handle), stats_(stats) {} | |
647 | |
648 RendererClientOnStatisticsUpdateRpc::~RendererClientOnStatisticsUpdateRpc() = | |
649 default; | |
650 | |
651 scoped_refptr<RendererClientOnStatisticsUpdateRpc> | |
652 RendererClientOnStatisticsUpdateRpc::FromRpcMessage(const pb::RpcMessage* rpc) { | |
653 DCHECK_EQ(RPC(RPC_RC_ONSTATISTICSUPDATE), rpc->proc()); | |
654 | |
655 REQUIRED(rpc->has_rendererclient_onstatisticsupdate_rpc()); | |
656 const pb::PipelineStatistics& rpc_message = | |
657 rpc->rendererclient_onstatisticsupdate_rpc(); | |
658 ::media::PipelineStatistics stats; | |
659 stats.audio_bytes_decoded = rpc_message.audio_bytes_decoded(); | |
660 stats.video_bytes_decoded = rpc_message.video_bytes_decoded(); | |
661 stats.video_frames_decoded = rpc_message.video_frames_decoded(); | |
662 stats.video_frames_dropped = rpc_message.video_frames_dropped(); | |
663 stats.audio_memory_usage = rpc_message.audio_memory_usage(); | |
664 stats.video_memory_usage = rpc_message.video_memory_usage(); | |
665 | |
666 VLOG(2) << "audio_bytes_decoded:" << stats.audio_bytes_decoded | |
667 << " video_bytes_decoded:" << stats.video_bytes_decoded | |
668 << " video_frames_decoded:" << stats.video_frames_decoded | |
669 << " video_frames_dropped:" << stats.video_frames_dropped | |
670 << " audio_memory_usage:" << stats.audio_memory_usage | |
671 << " video_memory_usage:" << stats.video_memory_usage; | |
672 return new RendererClientOnStatisticsUpdateRpc(rpc->handle(), stats); | |
673 } | |
674 | |
675 pb::RpcProc RendererClientOnStatisticsUpdateRpc::GetProc() const { | |
676 return RPC(RPC_RC_ONSTATISTICSUPDATE); | |
677 } | |
678 | |
679 void RendererClientOnStatisticsUpdateRpc::ToMessageInternal( | |
680 pb::RpcMessage* rpc) const { | |
681 VLOG(2) << __FUNCTION__ | |
682 << " audio_bytes_decoded:" << stats_.audio_bytes_decoded | |
683 << " video_bytes_decoded:" << stats_.video_bytes_decoded | |
684 << " video_frames_decoded:" << stats_.video_frames_decoded | |
685 << " video_frames_dropped:" << stats_.video_frames_dropped | |
686 << " audio_memory_usage:" << stats_.audio_memory_usage | |
687 << " video_memory_usage:" << stats_.video_memory_usage; | |
688 pb::PipelineStatistics* message = | |
689 rpc->mutable_rendererclient_onstatisticsupdate_rpc(); | |
690 message->set_audio_bytes_decoded(stats_.audio_bytes_decoded); | |
691 message->set_video_bytes_decoded(stats_.video_bytes_decoded); | |
692 message->set_video_frames_decoded(stats_.video_frames_decoded); | |
693 message->set_video_frames_dropped(stats_.video_frames_dropped); | |
694 message->set_audio_memory_usage(stats_.audio_memory_usage); | |
695 message->set_video_memory_usage(stats_.video_memory_usage); | |
696 } | |
697 | |
698 //============================================================================== | |
699 //============================================================================== | |
700 DemuxerStreamReadUntilRpc::DemuxerStreamReadUntilRpc(int handle, | |
701 uint32_t frame_id, | |
702 int callback_handle) | |
703 : Rpc(handle), frame_id_(frame_id), callback_handle_(callback_handle) {} | |
704 | |
705 DemuxerStreamReadUntilRpc::~DemuxerStreamReadUntilRpc() = default; | |
706 | |
707 scoped_refptr<DemuxerStreamReadUntilRpc> | |
708 DemuxerStreamReadUntilRpc::FromRpcMessage(const pb::RpcMessage* rpc) { | |
709 DCHECK_EQ(RPC(RPC_DS_READUNTIL), rpc->proc()); | |
710 | |
711 REQUIRED(rpc->has_demuxerstream_readuntil_rpc()); | |
712 const pb::DemuxerStreamReadUntil rpc_message = | |
713 rpc->demuxerstream_readuntil_rpc(); | |
714 int frame_id = rpc_message.frame_id(); | |
715 int callback_handle = rpc_message.callback_handle(); | |
716 | |
717 VLOG(2) << "frame_id:" << frame_id << " callback_handle:" << callback_handle; | |
718 return new DemuxerStreamReadUntilRpc(rpc->handle(), frame_id, | |
719 callback_handle); | |
720 } | |
721 | |
722 pb::RpcProc DemuxerStreamReadUntilRpc::GetProc() const { | |
723 return RPC(RPC_DS_READUNTIL); | |
724 } | |
725 | |
726 void DemuxerStreamReadUntilRpc::ToMessageInternal(pb::RpcMessage* rpc) const { | |
727 VLOG(2) << __FUNCTION__ << " frame_id:" << frame_id_ | |
728 << " callback_handle:" << callback_handle_; | |
729 pb::DemuxerStreamReadUntil* message = | |
730 rpc->mutable_demuxerstream_readuntil_rpc(); | |
731 message->set_callback_handle(callback_handle_); | |
732 message->set_frame_id(frame_id_); | |
733 } | |
734 | |
735 //============================================================================== | |
736 DemuxerStreamInitializeCallbackRpc::DemuxerStreamInitializeCallbackRpc( | |
737 int handle, | |
738 ::media::DemuxerStream::Type type, | |
739 const ::media::AudioDecoderConfig& audio_config, | |
740 const ::media::VideoDecoderConfig& video_config) | |
741 : Rpc(handle), | |
742 type_(type), | |
743 audio_config_(audio_config), | |
744 video_config_(video_config) {} | |
745 | |
746 DemuxerStreamInitializeCallbackRpc::~DemuxerStreamInitializeCallbackRpc() = | |
747 default; | |
748 | |
749 scoped_refptr<DemuxerStreamInitializeCallbackRpc> | |
750 DemuxerStreamInitializeCallbackRpc::FromRpcMessage(const pb::RpcMessage* rpc) { | |
751 DCHECK_EQ(RPC(RPC_DS_INITIALIZE_CALLBACK), rpc->proc()); | |
752 | |
753 REQUIRED(rpc->has_demuxerstream_initializecb_rpc()); | |
754 const pb::DemuxerStreamInitializeCallback rpc_message = | |
755 rpc->demuxerstream_initializecb_rpc(); | |
756 ::media::DemuxerStream::Type type = | |
757 static_cast<::media::DemuxerStream::Type>(rpc_message.type()); | |
758 ::media::AudioDecoderConfig audio_config; | |
759 ::media::VideoDecoderConfig video_config; | |
760 switch (type) { | |
761 case ::media::DemuxerStream::Type::AUDIO: { | |
762 const pb::AudioDecoderConfig& audio_message = | |
763 rpc_message.audio_decoder_config(); | |
764 REQUIRED(DeserializeAudioConfig(audio_message, &audio_config)); | |
765 break; | |
766 } | |
767 case ::media::DemuxerStream::Type::VIDEO: { | |
768 const pb::VideoDecoderConfig& video_message = | |
769 rpc_message.video_decoder_config(); | |
770 REQUIRED(DeserializeVideoConfig(video_message, &video_config)); | |
771 break; | |
772 } | |
773 default: | |
774 LOG(ERROR) << "stream type unsupported"; | |
775 return nullptr; | |
776 } | |
777 | |
778 VLOG(2) << "type:" << type | |
779 << " audio_config:" << audio_config.AsHumanReadableString() | |
780 << " video_config:" << video_config.AsHumanReadableString(); | |
781 return new DemuxerStreamInitializeCallbackRpc(rpc->handle(), type, | |
782 audio_config, video_config); | |
783 } | |
784 | |
785 pb::RpcProc DemuxerStreamInitializeCallbackRpc::GetProc() const { | |
786 return RPC(RPC_DS_INITIALIZE_CALLBACK); | |
787 } | |
788 | |
789 void DemuxerStreamInitializeCallbackRpc::ToMessageInternal( | |
790 pb::RpcMessage* rpc) const { | |
791 VLOG(2) << __FUNCTION__ << " type:" << type_ | |
792 << " audio_config:" << audio_config_.AsHumanReadableString() | |
793 << " video_config:" << video_config_.AsHumanReadableString(); | |
794 DCHECK(type_ == ::media::DemuxerStream::Type::AUDIO || | |
795 type_ == ::media::DemuxerStream::Type::VIDEO); | |
796 | |
797 pb::DemuxerStreamInitializeCallback* message = | |
798 rpc->mutable_demuxerstream_initializecb_rpc(); | |
799 message->set_type(type_); | |
800 | |
801 switch (type_) { | |
802 case ::media::DemuxerStream::Type::AUDIO: { | |
803 pb::AudioDecoderConfig* audio_message = | |
804 message->mutable_audio_decoder_config(); | |
805 SerializeAudioConfig(audio_config_, audio_message); | |
806 break; | |
807 } | |
808 case ::media::DemuxerStream::Type::VIDEO: { | |
809 pb::VideoDecoderConfig* video_message = | |
810 message->mutable_video_decoder_config(); | |
811 SerializeVideoConfig(video_config_, video_message); | |
812 break; | |
813 } | |
814 default: | |
815 NOTREACHED(); | |
816 } | |
817 } | |
818 | |
819 //============================================================================== | |
820 DemuxerStreamReadUntilCallbackRpc::DemuxerStreamReadUntilCallbackRpc( | |
821 int handle, | |
822 uint32_t frame_id, | |
823 ::media::DemuxerStream::Status status, | |
824 const ::media::AudioDecoderConfig& audio_config, | |
825 const ::media::VideoDecoderConfig& video_config) | |
826 : Rpc(handle), | |
827 frame_id_(frame_id), | |
828 status_(status), | |
829 audio_config_(audio_config), | |
830 video_config_(video_config) {} | |
831 | |
832 DemuxerStreamReadUntilCallbackRpc::~DemuxerStreamReadUntilCallbackRpc() = | |
833 default; | |
834 | |
835 scoped_refptr<DemuxerStreamReadUntilCallbackRpc> | |
836 DemuxerStreamReadUntilCallbackRpc::FromRpcMessage(const pb::RpcMessage* rpc) { | |
837 DCHECK_EQ(RPC(RPC_DS_READUNTIL_CALLBACK), rpc->proc()); | |
838 | |
839 REQUIRED(rpc->has_demuxerstream_readuntilcb_rpc()); | |
840 const pb::DemuxerStreamReadUntilCallback rpc_message = | |
841 rpc->demuxerstream_readuntilcb_rpc(); | |
842 int frame_id = rpc_message.frame_id(); | |
843 ::media::DemuxerStream::Status status = | |
844 static_cast<::media::DemuxerStream::Status>(rpc_message.status()); | |
845 | |
846 ::media::AudioDecoderConfig audio_config; | |
847 ::media::VideoDecoderConfig video_config; | |
848 if (status == ::media::DemuxerStream::kConfigChanged) { | |
849 if (rpc_message.has_audio_decoder_config()) { | |
850 REQUIRED(DeserializeAudioConfig(rpc_message.audio_decoder_config(), | |
851 &audio_config)); | |
852 } else if (rpc_message.has_video_decoder_config()) { | |
853 REQUIRED(DeserializeVideoConfig(rpc_message.video_decoder_config(), | |
854 &video_config)); | |
855 } else { | |
856 LOG(ERROR) << "packet has neither 'audio_config' nor 'video_config'"; | |
857 return nullptr; | |
858 } | |
859 } | |
860 | |
861 VLOG(2) << "status:" << status << " frame_id:" << frame_id; | |
862 return new DemuxerStreamReadUntilCallbackRpc(rpc->handle(), frame_id, status, | |
863 audio_config, video_config); | |
864 } | |
865 | |
866 pb::RpcProc DemuxerStreamReadUntilCallbackRpc::GetProc() const { | |
867 return RPC(RPC_DS_READUNTIL_CALLBACK); | |
868 } | |
869 | |
870 void DemuxerStreamReadUntilCallbackRpc::ToMessageInternal( | |
871 pb::RpcMessage* rpc) const { | |
872 VLOG(2) << __FUNCTION__ << " frame_id:" << frame_id_ << " status:" << status_; | |
873 | |
874 pb::DemuxerStreamReadUntilCallback* message = | |
875 rpc->mutable_demuxerstream_readuntilcb_rpc(); | |
876 message->set_frame_id(frame_id_); | |
877 message->set_status(status_); | |
878 | |
879 if (status_ == ::media::DemuxerStream::kConfigChanged) { | |
880 if (audio_config_.IsValidConfig()) { | |
881 pb::AudioDecoderConfig* audio_message = | |
882 message->mutable_audio_decoder_config(); | |
883 SerializeAudioConfig(audio_config_, audio_message); | |
884 } else if (video_config_.IsValidConfig()) { | |
885 pb::VideoDecoderConfig* video_message = | |
886 message->mutable_video_decoder_config(); | |
887 SerializeVideoConfig(video_config_, video_message); | |
888 } else { | |
889 NOTREACHED(); | |
890 } | |
891 } | |
892 } | |
893 | |
894 //============================================================================== | |
895 CdmInitializeRpc::CdmInitializeRpc(int handle, | |
896 const std::string& key_system, | |
897 const std::string& security_origin, | |
898 const ::media::CdmConfig& cdm_config, | |
899 int callback_handle) | |
900 : Rpc(handle), | |
901 key_system_(key_system), | |
902 security_origin_(security_origin), | |
903 cdm_config_(cdm_config), | |
904 callback_handle_(callback_handle) {} | |
905 | |
906 CdmInitializeRpc::~CdmInitializeRpc() = default; | |
907 | |
908 scoped_refptr<CdmInitializeRpc> CdmInitializeRpc::FromRpcMessage( | |
909 const pb::RpcMessage* rpc) { | |
910 DCHECK_EQ(RPC(RPC_CDM_INITIALIZE), rpc->proc()); | |
911 | |
912 REQUIRED(rpc->has_cdm_initialize_rpc()); | |
913 const pb::CdmInitialize rpc_message = rpc->cdm_initialize_rpc(); | |
914 std::string key_system = rpc_message.key_system(); | |
915 std::string security_origin = rpc_message.security_origin(); | |
916 ::media::CdmConfig cdm_config; | |
917 cdm_config.allow_distinctive_identifier = | |
918 rpc_message.allow_distinctive_identifier(); | |
919 cdm_config.allow_persistent_state = rpc_message.allow_persistent_state(); | |
920 cdm_config.use_hw_secure_codecs = rpc_message.use_hw_secure_codecs(); | |
921 int callback_handle = rpc_message.callback_handle(); | |
922 | |
923 VLOG(2) << "key_system:" << key_system | |
924 << " security_origin:" << security_origin | |
925 << " allow_distinctive_identifier:" | |
926 << cdm_config.allow_distinctive_identifier | |
927 << " allow_persistent_state:" << cdm_config.allow_persistent_state | |
928 << " use_hw_secure_codecs:" << cdm_config.use_hw_secure_codecs | |
929 << " callback_handle:" << callback_handle; | |
930 return new CdmInitializeRpc(rpc->handle(), key_system, security_origin, | |
931 cdm_config, callback_handle); | |
932 } | |
933 | |
934 pb::RpcProc CdmInitializeRpc::GetProc() const { | |
935 return RPC(RPC_CDM_INITIALIZE); | |
936 } | |
937 | |
938 void CdmInitializeRpc::ToMessageInternal(pb::RpcMessage* rpc) const { | |
939 VLOG(2) << __FUNCTION__ << " key_system:" << key_system_ | |
940 << " security_origin:" << security_origin_ | |
941 << " allow_distinctive_identifier:" | |
942 << cdm_config_.allow_distinctive_identifier | |
943 << " allow_persistent_state:" << cdm_config_.allow_persistent_state | |
944 << " use_hw_secure_codecs:" << cdm_config_.use_hw_secure_codecs | |
945 << " callback_handle:" << callback_handle_; | |
946 | |
947 pb::CdmInitialize* message = rpc->mutable_cdm_initialize_rpc(); | |
948 message->set_key_system(key_system_); | |
949 message->set_security_origin(security_origin_); | |
950 SerializeCdmConfig(cdm_config_, message); | |
951 message->set_callback_handle(callback_handle_); | |
952 } | |
953 | |
954 //============================================================================== | |
955 CdmSetServerCertificateRpc::CdmSetServerCertificateRpc( | |
956 int handle, | |
957 const uint8_t* certificate_data, | |
958 size_t certificate_data_size, | |
959 int callback_handle) | |
960 : Rpc(handle), | |
961 certificate_data_(certificate_data, | |
962 certificate_data + certificate_data_size), | |
963 callback_handle_(callback_handle) {} | |
964 | |
965 CdmSetServerCertificateRpc::~CdmSetServerCertificateRpc() = default; | |
966 | |
967 scoped_refptr<CdmSetServerCertificateRpc> | |
968 CdmSetServerCertificateRpc::FromRpcMessage(const pb::RpcMessage* rpc) { | |
969 DCHECK_EQ(RPC(RPC_CDM_SETSERVERCERTIFICATE), rpc->proc()); | |
970 | |
971 REQUIRED(rpc->has_cdm_setservercertificate_rpc()); | |
972 const pb::CdmSetServerCertificate rpc_message = | |
973 rpc->cdm_setservercertificate_rpc(); | |
974 int callback_handle = rpc_message.callback_handle(); | |
975 | |
976 std::vector<uint8_t> certificate; | |
977 certificate.assign(rpc_message.certificate_data().begin(), | |
978 rpc_message.certificate_data().end()); | |
979 | |
980 VLOG(2) << "callback_handle:" << callback_handle | |
981 << " certificate size:" << certificate.size(); | |
982 return new CdmSetServerCertificateRpc(rpc->handle(), &certificate[0], | |
983 certificate.size(), callback_handle); | |
984 } | |
985 | |
986 pb::RpcProc CdmSetServerCertificateRpc::GetProc() const { | |
987 return RPC(RPC_CDM_SETSERVERCERTIFICATE); | |
988 } | |
989 | |
990 void CdmSetServerCertificateRpc::ToMessageInternal(pb::RpcMessage* rpc) const { | |
991 VLOG(2) << __FUNCTION__ << " callback_handle:" << callback_handle_ | |
992 << " certificate size:" << certificate_data_.size(); | |
993 pb::CdmSetServerCertificate* message = | |
994 rpc->mutable_cdm_setservercertificate_rpc(); | |
995 message->set_callback_handle(callback_handle_); | |
996 message->set_certificate_data(&certificate_data_[0], | |
997 certificate_data_.size()); | |
998 } | |
999 | |
1000 //============================================================================== | |
1001 CdmCreateSessionAndGenerateRequestRpc::CdmCreateSessionAndGenerateRequestRpc( | |
1002 int handle, | |
1003 ::media::MediaKeys::SessionType session_type, | |
1004 ::media::EmeInitDataType init_data_type, | |
1005 const uint8_t* init_data, | |
1006 size_t init_data_size, | |
1007 int callback_handle) | |
1008 : Rpc(handle), | |
1009 session_type_(session_type), | |
1010 init_data_type_(init_data_type), | |
1011 init_data_(init_data, init_data + init_data_size), | |
1012 callback_handle_(callback_handle) {} | |
1013 | |
1014 CdmCreateSessionAndGenerateRequestRpc:: | |
1015 ~CdmCreateSessionAndGenerateRequestRpc() = default; | |
1016 | |
1017 scoped_refptr<CdmCreateSessionAndGenerateRequestRpc> | |
1018 CdmCreateSessionAndGenerateRequestRpc::FromRpcMessage( | |
1019 const pb::RpcMessage* rpc) { | |
1020 DCHECK_EQ(RPC(RPC_CDM_CREATESESSIONANDGENERATEREQUEST), rpc->proc()); | |
1021 | |
1022 REQUIRED(rpc->has_cdm_createsessionandgeneraterequest_rpc()); | |
1023 const pb::CdmCreateSessionAndGenerateRequest rpc_message = | |
1024 rpc->cdm_createsessionandgeneraterequest_rpc(); | |
1025 ::media::MediaKeys::SessionType session_type = | |
1026 static_cast<::media::MediaKeys::SessionType>(rpc_message.session_type()); | |
1027 ::media::EmeInitDataType init_data_type = | |
1028 static_cast<::media::EmeInitDataType>(rpc_message.init_data_type()); | |
1029 int callback_handle = rpc_message.callback_handle(); | |
1030 std::vector<uint8_t> init_data; | |
1031 init_data.assign(rpc_message.init_data().begin(), | |
1032 rpc_message.init_data().end()); | |
1033 | |
1034 VLOG(2) << "session_type:" << session_type | |
1035 << " init_data_type:" << static_cast<int>(init_data_type) | |
1036 << " callback_handle:" << callback_handle | |
1037 << " init_data size:" << init_data.size(); | |
1038 return new CdmCreateSessionAndGenerateRequestRpc( | |
1039 rpc->handle(), session_type, init_data_type, &init_data[0], | |
1040 init_data.size(), callback_handle); | |
1041 } | |
1042 | |
1043 pb::RpcProc CdmCreateSessionAndGenerateRequestRpc::GetProc() const { | |
1044 return RPC(RPC_CDM_CREATESESSIONANDGENERATEREQUEST); | |
1045 } | |
1046 | |
1047 void CdmCreateSessionAndGenerateRequestRpc::ToMessageInternal( | |
1048 pb::RpcMessage* rpc) const { | |
1049 VLOG(2) << __FUNCTION__ << " session_type:" << session_type_ | |
1050 << " init_data_type:" << static_cast<int>(init_data_type_) | |
1051 << " callback_handle:" << callback_handle_ | |
1052 << " init_data size:" << init_data_.size(); | |
1053 | |
1054 pb::CdmCreateSessionAndGenerateRequest* message = | |
1055 rpc->mutable_cdm_createsessionandgeneraterequest_rpc(); | |
1056 message->set_session_type(session_type_); | |
1057 message->set_init_data_type(static_cast<int>(init_data_type_)); | |
1058 message->set_callback_handle(callback_handle_); | |
1059 message->set_init_data(&init_data_[0], init_data_.size()); | |
1060 } | |
1061 | |
1062 //============================================================================== | |
1063 CdmLoadSessionRpc::CdmLoadSessionRpc( | |
1064 int handle, | |
1065 ::media::MediaKeys::SessionType session_type, | |
1066 const std::string& session_id, | |
1067 int callback_handle) | |
1068 : Rpc(handle), | |
1069 session_type_(session_type), | |
1070 session_id_(session_id), | |
1071 callback_handle_(callback_handle) {} | |
1072 | |
1073 CdmLoadSessionRpc::~CdmLoadSessionRpc() = default; | |
1074 | |
1075 scoped_refptr<CdmLoadSessionRpc> CdmLoadSessionRpc::FromRpcMessage( | |
1076 const pb::RpcMessage* rpc) { | |
1077 DCHECK_EQ(RPC(RPC_CDM_LOADSESSION), rpc->proc()); | |
1078 | |
1079 REQUIRED(rpc->has_cdm_loadsession_rpc()); | |
1080 const pb::CdmLoadSession rpc_message = rpc->cdm_loadsession_rpc(); | |
1081 ::media::MediaKeys::SessionType session_type = | |
1082 static_cast<::media::MediaKeys::SessionType>(rpc_message.session_type()); | |
1083 std::string session_id = rpc_message.session_id(); | |
1084 int callback_handle = rpc_message.callback_handle(); | |
1085 | |
1086 VLOG(2) << "session_type:" << session_type << " session_id:" << session_id | |
1087 << " callback_handle:" << callback_handle; | |
1088 return new CdmLoadSessionRpc(rpc->handle(), session_type, session_id, | |
1089 callback_handle); | |
1090 } | |
1091 | |
1092 pb::RpcProc CdmLoadSessionRpc::GetProc() const { | |
1093 return RPC(RPC_CDM_LOADSESSION); | |
1094 } | |
1095 | |
1096 void CdmLoadSessionRpc::ToMessageInternal(pb::RpcMessage* rpc) const { | |
1097 VLOG(2) << __FUNCTION__ << " session_type:" << session_type_ | |
1098 << " session_id:" << session_id_ | |
1099 << " callback_handle:" << callback_handle_; | |
1100 | |
1101 pb::CdmLoadSession* message = rpc->mutable_cdm_loadsession_rpc(); | |
1102 message->set_session_type(session_type_); | |
1103 message->set_session_id(session_id_); | |
1104 message->set_callback_handle(callback_handle_); | |
1105 } | |
1106 | |
1107 //============================================================================== | |
1108 CdmUpdateSessionRpc::CdmUpdateSessionRpc(int handle, | |
1109 const std::string& session_id, | |
1110 const uint8_t* response, | |
1111 size_t response_size, | |
1112 int callback_handle) | |
1113 : Rpc(handle), | |
1114 session_id_(session_id), | |
1115 response_(response, response + response_size), | |
1116 callback_handle_(callback_handle) {} | |
1117 CdmUpdateSessionRpc::~CdmUpdateSessionRpc() = default; | |
1118 | |
1119 scoped_refptr<CdmUpdateSessionRpc> CdmUpdateSessionRpc::FromRpcMessage( | |
1120 const pb::RpcMessage* rpc) { | |
1121 DCHECK_EQ(RPC(RPC_CDM_UPDATESESSION), rpc->proc()); | |
1122 | |
1123 REQUIRED(rpc->has_cdm_updatesession_rpc()); | |
1124 const pb::CdmUpdateSession rpc_message = rpc->cdm_updatesession_rpc(); | |
1125 std::string session_id = rpc_message.session_id(); | |
1126 int callback_handle = rpc_message.callback_handle(); | |
1127 std::vector<uint8_t> response; | |
1128 response.assign(rpc_message.response().begin(), rpc_message.response().end()); | |
1129 VLOG(2) << " session_id:" << session_id | |
1130 << " callback_handle:" << callback_handle | |
1131 << " response size:" << response.size(); | |
1132 | |
1133 return new CdmUpdateSessionRpc(rpc->handle(), session_id, &response[0], | |
1134 response.size(), callback_handle); | |
1135 } | |
1136 | |
1137 pb::RpcProc CdmUpdateSessionRpc::GetProc() const { | |
1138 return RPC(RPC_CDM_UPDATESESSION); | |
1139 } | |
1140 | |
1141 void CdmUpdateSessionRpc::ToMessageInternal(pb::RpcMessage* rpc) const { | |
1142 VLOG(2) << __FUNCTION__ << " session_id:" << session_id_ | |
1143 << " callback_handle:" << callback_handle_ | |
1144 << " response size:" << response_.size(); | |
1145 | |
1146 pb::CdmUpdateSession* message = rpc->mutable_cdm_updatesession_rpc(); | |
1147 message->set_session_id(session_id_); | |
1148 message->set_callback_handle(callback_handle_); | |
1149 message->set_response(&response_[0], response_.size()); | |
1150 } | |
1151 | |
1152 //============================================================================== | |
1153 CdmCloseSessionRpc::CdmCloseSessionRpc(int handle, | |
1154 const std::string& session_id, | |
1155 int callback_handle) | |
1156 : Rpc(handle), session_id_(session_id), callback_handle_(callback_handle) {} | |
1157 | |
1158 CdmCloseSessionRpc::~CdmCloseSessionRpc() = default; | |
1159 | |
1160 scoped_refptr<CdmCloseSessionRpc> CdmCloseSessionRpc::FromRpcMessage( | |
1161 const pb::RpcMessage* rpc) { | |
1162 DCHECK_EQ(RPC(RPC_CDM_CLOSESESSION), rpc->proc()); | |
1163 | |
1164 REQUIRED(rpc->has_cdm_closesession_rpc()); | |
1165 const pb::CdmCloseSession rpc_message = rpc->cdm_closesession_rpc(); | |
1166 std::string session_id = rpc_message.session_id(); | |
1167 int callback_handle = rpc_message.callback_handle(); | |
1168 | |
1169 VLOG(2) << " session_id:" << session_id | |
1170 << " callback_handle:" << callback_handle; | |
1171 return new CdmCloseSessionRpc(rpc->handle(), session_id, callback_handle); | |
1172 } | |
1173 | |
1174 pb::RpcProc CdmCloseSessionRpc::GetProc() const { | |
1175 return RPC(RPC_CDM_CLOSESESSION); | |
1176 } | |
1177 | |
1178 void CdmCloseSessionRpc::ToMessageInternal(pb::RpcMessage* rpc) const { | |
1179 VLOG(2) << __FUNCTION__ << " session_id:" << session_id_ | |
1180 << " callback_handle:" << callback_handle_; | |
1181 | |
1182 pb::CdmCloseSession* message = rpc->mutable_cdm_closesession_rpc(); | |
1183 message->set_session_id(session_id_); | |
1184 message->set_callback_handle(callback_handle_); | |
1185 } | |
1186 | |
1187 //============================================================================== | |
1188 CdmRemoveSessionRpc::CdmRemoveSessionRpc(int handle, | |
1189 const std::string& session_id, | |
1190 int callback_handle) | |
1191 : Rpc(handle), session_id_(session_id), callback_handle_(callback_handle) {} | |
1192 | |
1193 CdmRemoveSessionRpc::~CdmRemoveSessionRpc() = default; | |
1194 | |
1195 scoped_refptr<CdmRemoveSessionRpc> CdmRemoveSessionRpc::FromRpcMessage( | |
1196 const pb::RpcMessage* rpc) { | |
1197 DCHECK_EQ(RPC(RPC_CDM_REMOVESESSION), rpc->proc()); | |
1198 | |
1199 REQUIRED(rpc->has_cdm_removesession_rpc()); | |
1200 const pb::CdmRemoveSession rpc_message = rpc->cdm_removesession_rpc(); | |
1201 std::string session_id = rpc_message.session_id(); | |
1202 int callback_handle = rpc_message.callback_handle(); | |
1203 | |
1204 VLOG(2) << " session_id:" << session_id | |
1205 << " callback_handle:" << callback_handle; | |
1206 return new CdmRemoveSessionRpc(rpc->handle(), session_id, callback_handle); | |
1207 } | |
1208 | |
1209 pb::RpcProc CdmRemoveSessionRpc::GetProc() const { | |
1210 return RPC(RPC_CDM_REMOVESESSION); | |
1211 } | |
1212 | |
1213 void CdmRemoveSessionRpc::ToMessageInternal(pb::RpcMessage* rpc) const { | |
1214 VLOG(2) << __FUNCTION__ << " session_id:" << session_id_ | |
1215 << " callback_handle:" << callback_handle_; | |
1216 | |
1217 pb::CdmRemoveSession* message = rpc->mutable_cdm_removesession_rpc(); | |
1218 message->set_session_id(session_id_); | |
1219 message->set_callback_handle(callback_handle_); | |
1220 } | |
1221 | |
1222 //============================================================================== | |
1223 CdmPromiseResult::CdmPromiseResult() | |
1224 : CdmPromiseResult(::media::MediaKeys::UNKNOWN_ERROR, 0, "") {} | |
1225 | |
1226 CdmPromiseResult::CdmPromiseResult(::media::MediaKeys::Exception exception, | |
1227 uint32_t system_code, | |
1228 std::string error_message) | |
1229 : success_(false), | |
1230 exception_(exception), | |
1231 system_code_(system_code), | |
1232 error_message_(error_message) {} | |
1233 | |
1234 CdmPromiseResult::CdmPromiseResult(const CdmPromiseResult& other) = default; | |
1235 | |
1236 CdmPromiseResult::~CdmPromiseResult() = default; | |
1237 | |
1238 CdmPromiseResult CdmPromiseResult::SuccessResult() { | |
1239 CdmPromiseResult result(static_cast<::media::MediaKeys::Exception>(0), 0, ""); | |
1240 result.success_ = true; | |
1241 return result; | |
1242 } | |
1243 | |
1244 //============================================================================== | |
1245 CdmInitializeCallbackRpc::CdmInitializeCallbackRpc( | |
1246 int handle, | |
1247 const CdmPromiseResult& result, | |
1248 int cdm_id, | |
1249 int decryptor_handle) | |
1250 : CdmPromiseCallbackRpc(handle, result), | |
1251 cdm_id_(cdm_id), | |
1252 decryptor_handle_(decryptor_handle) {} | |
1253 | |
1254 CdmInitializeCallbackRpc::~CdmInitializeCallbackRpc() = default; | |
1255 | |
1256 scoped_refptr<CdmInitializeCallbackRpc> | |
1257 CdmInitializeCallbackRpc::FromRpcMessage(const pb::RpcMessage* rpc) { | |
1258 DCHECK_EQ(RPC(RPC_CDM_INITIALIZE_CALLBACK), rpc->proc()); | |
1259 | |
1260 REQUIRED(rpc->has_cdm_promise_rpc()); | |
1261 const pb::CdmPromise promise_message = rpc->cdm_promise_rpc(); | |
1262 CdmPromiseResult result; | |
1263 REQUIRED(internal::CdmPromiseFromMessage(promise_message, &result, nullptr)); | |
1264 int cdm_id = promise_message.cdm_id(); | |
1265 int decryptor_handle = promise_message.decryptor_handle(); | |
1266 | |
1267 VLOG(2) << "cdm_id:" << cdm_id << " decryptor_handle:" << decryptor_handle; | |
1268 return new CdmInitializeCallbackRpc(rpc->handle(), result, cdm_id, | |
1269 decryptor_handle); | |
1270 } | |
1271 | |
1272 void CdmInitializeCallbackRpc::ToMessageInternal(pb::RpcMessage* rpc) const { | |
1273 VLOG(2) << __FUNCTION__ << " cdm_id:" << cdm_id_ | |
1274 << " decryptor_handle:" << decryptor_handle_; | |
1275 | |
1276 CdmPromiseCallbackRpc<RPC(RPC_CDM_INITIALIZE_CALLBACK)>::ToMessageInternal( | |
1277 rpc); | |
1278 pb::CdmPromise* message = rpc->mutable_cdm_promise_rpc(); | |
1279 message->set_cdm_id(cdm_id_); | |
1280 message->set_decryptor_handle(decryptor_handle_); | |
1281 } | |
1282 | |
1283 //============================================================================== | |
1284 CdmClientOnSessionMessageRpc::CdmClientOnSessionMessageRpc( | |
1285 int handle, | |
1286 const std::string& session_id, | |
1287 ::media::MediaKeys::MessageType message_type, | |
1288 const uint8_t* message, | |
1289 size_t message_size) | |
1290 : Rpc(handle), | |
1291 session_id_(session_id), | |
1292 message_type_(message_type), | |
1293 message_(message, message + message_size) {} | |
1294 | |
1295 CdmClientOnSessionMessageRpc::~CdmClientOnSessionMessageRpc() = default; | |
1296 | |
1297 scoped_refptr<CdmClientOnSessionMessageRpc> | |
1298 CdmClientOnSessionMessageRpc::FromRpcMessage(const pb::RpcMessage* rpc) { | |
1299 DCHECK_EQ(RPC(RPC_CDMC_ONSESSIONMESSAGE), rpc->proc()); | |
1300 | |
1301 REQUIRED(rpc->has_cdmclient_onsessionmessage_rpc()); | |
1302 const pb::CdmClientOnSessionMessage onsession_message = | |
1303 rpc->cdmclient_onsessionmessage_rpc(); | |
1304 std::string session_id = onsession_message.session_id(); | |
1305 ::media::MediaKeys::MessageType message_type = | |
1306 static_cast<::media::MediaKeys::MessageType>( | |
1307 onsession_message.message_type()); | |
1308 std::vector<uint8_t> message_data; | |
1309 message_data.assign(onsession_message.message().begin(), | |
1310 onsession_message.message().end()); | |
1311 | |
1312 return new CdmClientOnSessionMessageRpc(rpc->handle(), session_id, | |
1313 message_type, &message_data[0], | |
1314 message_data.size()); | |
1315 } | |
1316 | |
1317 pb::RpcProc CdmClientOnSessionMessageRpc::GetProc() const { | |
1318 return RPC(RPC_CDMC_ONSESSIONMESSAGE); | |
1319 } | |
1320 | |
1321 void CdmClientOnSessionMessageRpc::ToMessageInternal( | |
1322 pb::RpcMessage* rpc) const { | |
1323 VLOG(2) << __FUNCTION__ << " session_id:" << session_id_ | |
1324 << " message_type:" << message_type_; | |
1325 | |
1326 pb::CdmClientOnSessionMessage* message = | |
1327 rpc->mutable_cdmclient_onsessionmessage_rpc(); | |
1328 message->set_session_id(session_id_); | |
1329 message->set_message_type( | |
1330 static_cast<pb::MediaKeysMessageType>(message_type_)); | |
1331 message->set_message(&message_[0], message_.size()); | |
1332 } | |
1333 | |
1334 //============================================================================== | |
1335 CdmClientOnSessionKeysChangeRpc::CdmClientOnSessionKeysChangeRpc( | |
1336 int handle, | |
1337 const std::string& session_id, | |
1338 bool has_additional_usable_key, | |
1339 const ::media::CdmKeyInformation* key_information, | |
1340 size_t key_information_size) | |
1341 : Rpc(handle), | |
1342 session_id_(session_id), | |
1343 has_additional_usable_key_(has_additional_usable_key), | |
1344 key_information_(key_information, | |
1345 key_information + key_information_size) {} | |
1346 | |
1347 CdmClientOnSessionKeysChangeRpc::~CdmClientOnSessionKeysChangeRpc() = default; | |
1348 | |
1349 scoped_refptr<CdmClientOnSessionKeysChangeRpc> | |
1350 CdmClientOnSessionKeysChangeRpc::FromRpcMessage(const pb::RpcMessage* rpc) { | |
1351 DCHECK_EQ(RPC(RPC_CDMC_ONSESSIONKEYSCHANGE), rpc->proc()); | |
1352 | |
1353 REQUIRED(rpc->has_cdmclient_onsessionkeychange_rpc()); | |
1354 const pb::CdmClientOnSessionKeysChange keychange_message = | |
1355 rpc->cdmclient_onsessionkeychange_rpc(); | |
1356 std::string session_id = keychange_message.session_id(); | |
1357 bool has_additional_usable_key = | |
1358 keychange_message.has_additional_usable_key(); | |
1359 std::vector<::media::CdmKeyInformation> key_information; | |
1360 if (has_additional_usable_key) { | |
1361 REQUIRED(keychange_message.key_information_size()); | |
1362 REQUIRED(DeserializeCdmKeyInformation(keychange_message, &key_information)); | |
1363 } | |
1364 | |
1365 return new CdmClientOnSessionKeysChangeRpc( | |
1366 rpc->handle(), session_id, has_additional_usable_key, | |
1367 key_information.data(), key_information.size()); | |
1368 } | |
1369 | |
1370 pb::RpcProc CdmClientOnSessionKeysChangeRpc::GetProc() const { | |
1371 return RPC(RPC_CDMC_ONSESSIONKEYSCHANGE); | |
1372 } | |
1373 | |
1374 void CdmClientOnSessionKeysChangeRpc::ToMessageInternal( | |
1375 pb::RpcMessage* rpc) const { | |
1376 VLOG(2) << __FUNCTION__ << " session_id:" << session_id_ | |
1377 << " has_additional_usable_key:" << has_additional_usable_key_; | |
1378 | |
1379 pb::CdmClientOnSessionKeysChange* message = | |
1380 rpc->mutable_cdmclient_onsessionkeychange_rpc(); | |
1381 message->set_session_id(session_id_); | |
1382 message->set_has_additional_usable_key(has_additional_usable_key_); | |
1383 SerializeCdmKeyInformation(message, key_information_); | |
1384 } | |
1385 | |
1386 //============================================================================== | |
1387 CdmClientOnSessionExpirationUpdateRpc::CdmClientOnSessionExpirationUpdateRpc( | |
1388 int handle, | |
1389 const std::string& session_id, | |
1390 double new_expiry_time_sec) | |
1391 : Rpc(handle), | |
1392 session_id_(session_id), | |
1393 new_expiry_time_sec_(new_expiry_time_sec) {} | |
1394 | |
1395 CdmClientOnSessionExpirationUpdateRpc:: | |
1396 ~CdmClientOnSessionExpirationUpdateRpc() = default; | |
1397 | |
1398 scoped_refptr<CdmClientOnSessionExpirationUpdateRpc> | |
1399 CdmClientOnSessionExpirationUpdateRpc::FromRpcMessage( | |
1400 const pb::RpcMessage* rpc) { | |
1401 DCHECK_EQ(RPC(RPC_CDMC_ONSESSIONEXPIRATIONUPDATE), rpc->proc()); | |
1402 | |
1403 REQUIRED(rpc->has_cdmclient_onsessionexpirationupdate_rpc()); | |
1404 const pb::CdmClientOnSessionExpirationUpdate expire_message = | |
1405 rpc->cdmclient_onsessionexpirationupdate_rpc(); | |
1406 std::string session_id = expire_message.session_id(); | |
1407 double new_expiry_time_sec = expire_message.new_expiry_time_sec(); | |
1408 | |
1409 return new CdmClientOnSessionExpirationUpdateRpc(rpc->handle(), session_id, | |
1410 new_expiry_time_sec); | |
1411 } | |
1412 | |
1413 pb::RpcProc CdmClientOnSessionExpirationUpdateRpc::GetProc() const { | |
1414 return RPC(RPC_CDMC_ONSESSIONEXPIRATIONUPDATE); | |
1415 } | |
1416 | |
1417 void CdmClientOnSessionExpirationUpdateRpc::ToMessageInternal( | |
1418 pb::RpcMessage* rpc) const { | |
1419 VLOG(2) << __FUNCTION__ << " session_id:" << session_id_ | |
1420 << " new_expiry_time_sec_:" << new_expiry_time_sec_; | |
1421 | |
1422 pb::CdmClientOnSessionExpirationUpdate* message = | |
1423 rpc->mutable_cdmclient_onsessionexpirationupdate_rpc(); | |
1424 message->set_session_id(session_id_); | |
1425 message->set_new_expiry_time_sec(new_expiry_time_sec_); | |
1426 } | |
1427 | |
1428 #undef REQUIRED | |
1429 | |
1430 } // namespace remoting | |
1431 } // namespace media | |
OLD | NEW |