Index: media/remoting/rpc/rpc.cc |
diff --git a/media/remoting/rpc/rpc.cc b/media/remoting/rpc/rpc.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..ae860aec89eab99cd2dcc28d6c4fa7f655b1d39e |
--- /dev/null |
+++ b/media/remoting/rpc/rpc.cc |
@@ -0,0 +1,1417 @@ |
+// Copyright 2016 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#include "media/remoting/rpc/rpc.h" |
+ |
+#include <algorithm> |
+ |
+#include "base/logging.h" |
+#include "base/time/time.h" |
+#include "base/values.h" |
+#include "media/base/encryption_scheme.h" |
+ |
+#define REQUIRED_IMPL(x, ret) \ |
+ do { \ |
+ if (!(x)) { \ |
+ LOG(ERROR) << "failed l" << __LINE__ << ": " << #x; \ |
+ return (ret); \ |
+ } \ |
+ } while (0) |
+ |
+namespace media { |
+namespace remoting { |
+ |
+namespace { |
+ |
+#define RPC(x) pb::x |
+ |
+#define REQUIRED(x) REQUIRED_IMPL(x, false) |
+ |
+bool DeserializeEncryptionScheme(const pb::EncryptionScheme& message, |
+ ::media::EncryptionScheme* encryption_scheme) { |
+ ::media::EncryptionScheme::CipherMode mode = |
+ ::media::EncryptionScheme::CIPHER_MODE_UNENCRYPTED; |
+ ::media::EncryptionScheme::Pattern pattern; |
+ uint32_t encrypt_blocks = 0; |
+ uint32_t skip_blocks = 0; |
+ |
+ if (message.has_mode()) |
+ mode = static_cast<::media::EncryptionScheme::CipherMode>(message.mode()); |
+ if (message.has_encrypt_blocks()) |
+ encrypt_blocks = message.encrypt_blocks(); |
+ if (message.has_skip_blocks()) |
+ skip_blocks = message.skip_blocks(); |
+ REQUIRED(encrypt_blocks >= 0 && skip_blocks >= 0); |
+ |
+ pattern = ::media::EncryptionScheme::Pattern(encrypt_blocks, skip_blocks); |
+ *encryption_scheme = ::media::EncryptionScheme(mode, pattern); |
+ return true; |
+} |
+ |
+bool DeserializeSize(const pb::Size& message, gfx::Size* size) { |
+ DCHECK(size); |
+ size->SetSize(message.width(), message.height()); |
+ return true; |
+} |
+ |
+bool DeserializeRect(const pb::Rect& message, gfx::Rect* rect) { |
+ DCHECK(rect); |
+ rect->set_x(message.x()); |
+ rect->set_x(message.y()); |
+ rect->set_width(message.width()); |
+ rect->set_height(message.height()); |
+ return true; |
+} |
+ |
+bool DeserializeAudioConfig(const pb::AudioDecoderConfig& audio_message, |
+ ::media::AudioDecoderConfig* audio_config) { |
+ DCHECK(audio_config); |
+ |
+ ::media::AudioCodec codec = ::media::kUnknownAudioCodec; |
+ ::media::SampleFormat sample_format = ::media::kUnknownSampleFormat; |
+ ::media::ChannelLayout channel_layout = ::media::CHANNEL_LAYOUT_NONE; |
+ int samples_per_second = 0; |
+ base::TimeDelta seek_preroll = base::TimeDelta(); |
+ int codec_delay = 0; |
+ ::media::EncryptionScheme encryption_scheme; |
+ std::vector<uint8_t> extra_data; |
+ |
+ codec = static_cast<::media::AudioCodec>(audio_message.codec()); |
+ sample_format = |
+ static_cast<::media::SampleFormat>(audio_message.sample_format()); |
+ channel_layout = |
+ static_cast<::media::ChannelLayout>(audio_message.channel_layout()); |
+ samples_per_second = audio_message.samples_per_second(); |
+ seek_preroll = |
+ base::TimeDelta::FromMicroseconds(audio_message.seek_preroll_usec()); |
+ codec_delay = audio_message.codec_delay(); |
+ |
+ if (audio_message.has_extra_data()) { |
+ extra_data.assign(audio_message.extra_data().begin(), |
+ audio_message.extra_data().end()); |
+ } |
+ |
+ const pb::EncryptionScheme encryption_scheme_message = |
+ audio_message.encryption_scheme(); |
+ DeserializeEncryptionScheme(encryption_scheme_message, &encryption_scheme); |
+ |
+ audio_config->Initialize(codec, sample_format, channel_layout, |
+ samples_per_second, extra_data, encryption_scheme, |
+ seek_preroll, codec_delay); |
+ return true; |
+} |
+ |
+bool DeserializeVideoConfig(const pb::VideoDecoderConfig& video_message, |
+ ::media::VideoDecoderConfig* video_config) { |
+ ::media::VideoCodec codec = ::media::kUnknownVideoCodec; |
+ ::media::VideoCodecProfile profile = ::media::VIDEO_CODEC_PROFILE_UNKNOWN; |
+ ::media::VideoPixelFormat format = ::media::PIXEL_FORMAT_UNKNOWN; |
+ ::media::ColorSpace color_space = ::media::COLOR_SPACE_UNSPECIFIED; |
+ gfx::Size coded_size(1920, 1080); |
+ gfx::Rect visible_rect(0, 0, 1920, 1080); |
+ gfx::Size natural_size(1920, 1080); |
+ ::media::EncryptionScheme encryption_scheme; |
+ std::vector<uint8_t> extra_data; |
+ |
+ codec = static_cast<::media::VideoCodec>(video_message.codec()); |
+ profile = static_cast<::media::VideoCodecProfile>(video_message.profile()); |
+ format = static_cast<::media::VideoPixelFormat>(video_message.format()); |
+ color_space = static_cast<::media::ColorSpace>(video_message.color_space()); |
+ |
+ if (video_message.has_extra_data()) { |
+ extra_data.assign(video_message.extra_data().begin(), |
+ video_message.extra_data().end()); |
+ } |
+ |
+ // DCHECK(video_message.has_coded_size()); |
+ DeserializeSize(video_message.coded_size(), &coded_size); |
+ |
+ // DCHECK(video_message.has_visible_rect()); |
+ DeserializeRect(video_message.visible_rect(), &visible_rect); |
+ |
+ // DCHECK(video_message.has_natural_size()); |
+ DeserializeSize(video_message.natural_size(), &coded_size); |
+ |
+ const pb::EncryptionScheme& encryption_scheme_message = |
+ video_message.encryption_scheme(); |
+ DeserializeEncryptionScheme(encryption_scheme_message, &encryption_scheme); |
+ |
+ video_config->Initialize(codec, profile, format, color_space, coded_size, |
+ visible_rect, natural_size, extra_data, |
+ encryption_scheme); |
+ return true; |
+} |
+ |
+bool DeserializeCdmPromiseResult(const pb::CdmPromise& promise_message, |
+ CdmPromiseResult* result) { |
+ REQUIRED(promise_message.has_success()); |
+ bool success = promise_message.success(); |
+ if (success) { |
+ *result = CdmPromiseResult::SuccessResult(); |
+ return true; |
+ } |
+ |
+ ::media::MediaKeys::Exception exception = ::media::MediaKeys::UNKNOWN_ERROR; |
+ uint32_t system_code = 0; |
+ std::string error_message; |
+ |
+ exception = |
+ static_cast<::media::MediaKeys::Exception>(promise_message.exception()); |
+ system_code = promise_message.system_code(); |
+ error_message = promise_message.error_message(); |
+ *result = CdmPromiseResult(exception, system_code, error_message); |
+ return true; |
+} |
+ |
+bool DeserializeCdmKeyInformation( |
+ const pb::CdmClientOnSessionKeysChange keychange_message, |
+ std::vector<::media::CdmKeyInformation>* key_information) { |
+ std::vector<::media::CdmKeyInformation> info; |
+ |
+ for (int i = 0; i < keychange_message.key_information_size(); ++i) { |
+ const pb::CdmKeyInformation key = keychange_message.key_information(i); |
+ |
+ ::media::CdmKeyInformation::KeyStatus status = |
+ ::media::CdmKeyInformation::USABLE; |
+ uint32_t system_code = 0; |
+ |
+ status = static_cast<::media::CdmKeyInformation::KeyStatus>(key.status()); |
+ system_code = key.system_code(); |
+ |
+ info.push_back( |
+ ::media::CdmKeyInformation(key.key_id(), status, system_code)); |
+ } |
+ |
+ *key_information = std::move(info); |
+ return true; |
+} |
+ |
+#undef REQUIRED |
+ |
+void SerializeEncryptionScheme( |
+ pb::EncryptionScheme* message, |
+ const ::media::EncryptionScheme& encryption_scheme) { |
+ message->set_mode( |
+ static_cast<pb::EncryptionScheme::CipherMode>(encryption_scheme.mode())); |
+ message->set_encrypt_blocks(encryption_scheme.pattern().encrypt_blocks()); |
+ message->set_skip_blocks(encryption_scheme.pattern().skip_blocks()); |
+} |
+ |
+void SerializeSize(const gfx::Size& size, pb::Size* message) { |
+ DCHECK(message); |
+ message->set_width(size.width()); |
+ message->set_height(size.height()); |
+} |
+ |
+void SerializeRect(pb::Rect* message, const gfx::Rect& rect) { |
+ message->set_x(rect.x()); |
+ message->set_y(rect.y()); |
+ message->set_width(rect.width()); |
+ message->set_height(rect.height()); |
+} |
+ |
+template <class DecoderConfig, class DecoderConfigMessage> |
+void SerializeExtraData(const DecoderConfig& config, |
+ DecoderConfigMessage* decoder_config_message) { |
+ if (config.extra_data().empty()) |
+ return; |
+ |
+ decoder_config_message->set_extra_data(&config.extra_data()[0], |
+ config.extra_data().size()); |
+} |
+ |
+void SerializeAudioConfig(const ::media::AudioDecoderConfig& audio_config, |
+ pb::AudioDecoderConfig* audio_message) { |
+ if (!audio_config.IsValidConfig()) |
+ return; |
+ |
+ audio_message->set_codec( |
+ static_cast<pb::AudioDecoderConfig_Codec>(audio_config.codec())); |
+ audio_message->set_sample_format( |
+ static_cast<pb::AudioDecoderConfig_SampleFormat>( |
+ audio_config.sample_format())); |
+ audio_message->set_channel_layout( |
+ static_cast<pb::AudioDecoderConfig_ChannelLayout>( |
+ audio_config.channel_layout())); |
+ audio_message->set_samples_per_second(audio_config.samples_per_second()); |
+ audio_message->set_seek_preroll_usec( |
+ audio_config.seek_preroll().InMicroseconds()); |
+ audio_message->set_codec_delay(audio_config.codec_delay()); |
+ |
+ SerializeExtraData(audio_config, audio_message); |
+ |
+ if (audio_config.is_encrypted()) { |
+ pb::EncryptionScheme* encryption_scheme_message = |
+ audio_message->mutable_encryption_scheme(); |
+ SerializeEncryptionScheme(encryption_scheme_message, |
+ audio_config.encryption_scheme()); |
+ } |
+} |
+ |
+void SerializeVideoConfig(const ::media::VideoDecoderConfig& video_config, |
+ pb::VideoDecoderConfig* video_message) { |
+ if (!video_config.IsValidConfig()) |
+ return; |
+ |
+ video_message->set_codec( |
+ static_cast<pb::VideoDecoderConfig_Codec>(video_config.codec())); |
+ video_message->set_profile( |
+ static_cast<pb::VideoDecoderConfig_Profile>(video_config.profile())); |
+ video_message->set_format( |
+ static_cast<pb::VideoDecoderConfig_Format>(video_config.format())); |
+ video_message->set_color_space(static_cast<pb::VideoDecoderConfig_ColorSpace>( |
+ video_config.color_space())); |
+ |
+ pb::Size* coded_size_message = video_message->mutable_coded_size(); |
+ SerializeSize(video_config.coded_size(), coded_size_message); |
+ |
+ pb::Rect* visible_rect_message = video_message->mutable_visible_rect(); |
+ SerializeRect(visible_rect_message, video_config.visible_rect()); |
+ |
+ pb::Size* natural_size_message = video_message->mutable_natural_size(); |
+ SerializeSize(video_config.natural_size(), natural_size_message); |
+ |
+ SerializeExtraData(video_config, video_message); |
+ |
+ if (video_config.is_encrypted()) { |
+ pb::EncryptionScheme* encryption_scheme_message = |
+ video_message->mutable_encryption_scheme(); |
+ SerializeEncryptionScheme(encryption_scheme_message, |
+ video_config.encryption_scheme()); |
+ } |
+} |
+ |
+void SerializeCdmConfig(const ::media::CdmConfig& cdm_config, |
+ pb::CdmInitialize* message) { |
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue()); |
+ |
+ message->set_allow_distinctive_identifier( |
+ cdm_config.allow_distinctive_identifier); |
+ message->set_allow_persistent_state(cdm_config.allow_persistent_state); |
+ message->set_use_hw_secure_codecs(cdm_config.use_hw_secure_codecs); |
+} |
+ |
+void SerializeCdmPromiseResult(pb::CdmPromise* promise_message, |
+ const CdmPromiseResult& result) { |
+ promise_message->set_success(result.success()); |
+ if (!result.success()) { |
+ promise_message->set_exception( |
+ static_cast<pb::MediaKeysException>(result.exception())); |
+ promise_message->set_system_code(result.system_code()); |
+ promise_message->set_error_message(result.error_message()); |
+ } |
+} |
+ |
+void SerializeCdmKeyInformation( |
+ pb::CdmClientOnSessionKeysChange* key_change_message, |
+ const std::vector<::media::CdmKeyInformation>& key_information) { |
+ for (const auto& info : key_information) { |
+ pb::CdmKeyInformation* key = key_change_message->add_key_information(); |
+ key->set_key_id(&(info.key_id[0]), info.key_id.size()); |
+ key->set_status(static_cast<pb::CdmKeyInformation::KeyStatus>(info.status)); |
+ key->set_system_code(info.system_code); |
+ } |
+} |
+ |
+} // namespace |
+ |
+namespace internal { |
+ |
+#define REQUIRED(x) REQUIRED_IMPL(x, false) |
+bool CdmPromiseFromMessage(const pb::CdmPromise& promise_message, |
+ CdmPromiseResult* result, |
+ std::string* session_id) { |
+ REQUIRED(DeserializeCdmPromiseResult(promise_message, result)); |
+ |
+ if (session_id) |
+ *session_id = promise_message.session_id(); |
+ |
+ return true; |
+} |
+#undef REQUIRED |
+ |
+void CdmPromiseToMessage(pb::CdmPromise* promise_message, |
+ const CdmPromiseResult& result, |
+ const std::string& session_id) { |
+ SerializeCdmPromiseResult(promise_message, result); |
+ if (!session_id.empty()) |
+ promise_message->set_session_id(session_id); |
+} |
+ |
+} // namespace internal |
+ |
+Rpc::Rpc(int handle) : handle_(handle) {} |
+ |
+Rpc::~Rpc() = default; |
+ |
+scoped_refptr<Rpc> Rpc::FromMessage(const std::string& proto_message) { |
+ DCHECK(!proto_message.empty()); |
+ |
+ pb::RpcMessage rpc; |
+ if (!rpc.ParseFromString(proto_message)) { |
+ LOG(ERROR) << "Bad proto buffer"; |
+ return nullptr; |
+ } |
+ |
+#define CASE(proc, cls) \ |
+ case proc: \ |
+ return cls::FromRpcMessage(&rpc) |
+ switch (rpc.proc()) { |
+ CASE(RPC(RPC_ACQUIRE_RENDERER), AcquireRendererRpc); |
+ CASE(RPC(RPC_ACQUIRE_RENDERER_DONE), AcquireRendererDoneRpc); |
+ CASE(RPC(RPC_ACQUIRE_CDM), AcquireCdmRpc); |
+ CASE(RPC(RPC_ACQUIRE_CDM_DONE), AcquireCdmDoneRpc); |
+ CASE(RPC(RPC_R_INITIALIZE), RendererInitializeRpc); |
+ CASE(RPC(RPC_R_FLUSH), RendererFlushRpc); |
+ CASE(RPC(RPC_R_STARTPLAYINGFROM), RendererStartPlayingFromRpc); |
+ CASE(RPC(RPC_R_SETPLAYBACKRATE), RendererSetPlaybackRateRpc); |
+ CASE(RPC(RPC_R_SETVOLUME), RendererSetVolumeRpc); |
+ CASE(RPC(RPC_R_SETCDM), RendererSetCdmRpc); |
+ CASE(RPC(RPC_R_INITIALIZE_CALLBACK), RendererInitializeCallbackRpc); |
+ CASE(RPC(RPC_R_FLUSH_CALLBACK), RendererFlushCallbackRpc); |
+ CASE(RPC(RPC_R_SETCDM_CALLBACK), RendererSetCdmCallbackRpc); |
+ CASE(RPC(RPC_RC_ONTIMEUPDATE), RendererClientOnTimeUpdateRpc); |
+ CASE(RPC(RPC_RC_ONBUFFERINGSTATECHANGE), |
+ RendererClientOnBufferingStateChangeRpc); |
+ CASE(RPC(RPC_RC_ONENDED), RendererClientOnEndedRpc); |
+ CASE(RPC(RPC_RC_ONERROR), RendererClientOnErrorRpc); |
+ CASE(RPC(RPC_RC_ONVIDEONATURALSIZECHANGE), |
+ RendererClientOnVideoNaturalSizeChangeRpc); |
+ CASE(RPC(RPC_RC_ONVIDEOOPACITYCHANGE), |
+ RendererClientOnVideoOpacityChangeRpc); |
+ CASE(RPC(RPC_DS_INITIALIZE), DemuxerStreamInitializeRpc); |
+ CASE(RPC(RPC_DS_ENABLEBITSTREAMCONVERTER), |
+ DemuxerStreamEnableBitstreamConverterRpc); |
+ CASE(RPC(RPC_DS_READUNTIL), DemuxerStreamReadUntilRpc); |
+ CASE(RPC(RPC_DS_INITIALIZE_CALLBACK), DemuxerStreamInitializeCallbackRpc); |
+ CASE(RPC(RPC_DS_READUNTIL_CALLBACK), DemuxerStreamReadUntilCallbackRpc); |
+ CASE(RPC(RPC_CDM_SETCLIENT), CdmSetClientRpc); |
+ CASE(RPC(RPC_CDM_INITIALIZE), CdmInitializeRpc); |
+ CASE(RPC(RPC_CDM_SETSERVERCERTIFICATE), CdmSetServerCertificateRpc); |
+ CASE(RPC(RPC_CDM_CREATESESSIONANDGENERATEREQUEST), |
+ CdmCreateSessionAndGenerateRequestRpc); |
+ CASE(RPC(RPC_CDM_LOADSESSION), CdmLoadSessionRpc); |
+ CASE(RPC(RPC_CDM_UPDATESESSION), CdmUpdateSessionRpc); |
+ CASE(RPC(RPC_CDM_CLOSESESSION), CdmCloseSessionRpc); |
+ CASE(RPC(RPC_CDM_REMOVESESSION), CdmRemoveSessionRpc); |
+ CASE(RPC(RPC_CDM_INITIALIZE_CALLBACK), CdmInitializeCallbackRpc); |
+ CASE(RPC(RPC_CDM_SETSERVERCERTIFICATE_CALLBACK), |
+ CdmSetServerCertificateCallbackRpc); |
+ CASE(RPC(RPC_CDM_CREATESESSIONANDGENERATEREQUEST_CALLBACK), |
+ CdmCreateSessionAndGenerateRequestCallbackRpc); |
+ CASE(RPC(RPC_CDM_UPDATESESSION_CALLBACK), CdmUpdateSessionCallbackRpc); |
+ CASE(RPC(RPC_CDM_CLOSESESSION_CALLBACK), CdmCloseSessionCallbackRpc); |
+ CASE(RPC(RPC_CDM_REMOVESESSION_CALLBACK), CdmRemoveSessionCallbackRpc); |
+ CASE(RPC(RPC_CDMC_ONSESSIONMESSAGE), CdmClientOnSessionMessageRpc); |
+ CASE(RPC(RPC_CDMC_ONSESSIONCLOSED), CdmClientOnSessionClosedRpc); |
+ CASE(RPC(RPC_CDMC_ONLEGACYSESSIONERROR), CdmClientOnLegacySessionErrorRpc); |
+ CASE(RPC(RPC_CDMC_ONSESSIONKEYSCHANGE), CdmClientOnSessionKeysChangeRpc); |
+ CASE(RPC(RPC_CDMC_ONSESSIONEXPIRATIONUPDATE), |
+ CdmClientOnSessionExpirationUpdateRpc); |
+ default: |
+ LOG(ERROR) << "Unknown Rpc: " << rpc.proc(); |
+ return nullptr; |
+ } |
+#undef CASE |
+} |
+ |
+#define REQUIRED(x) REQUIRED_IMPL(x, nullptr) |
+ |
+std::string Rpc::ToMessage() const { |
+ pb::RpcMessage rpc; |
+ ToMessageInternal(&rpc); |
+ rpc.set_handle(handle_); |
+ rpc.set_proc(GetProc()); |
+ std::string proto_msg; |
+ bool valid = rpc.ByteSize() > 0 && rpc.SerializeToString(&proto_msg); |
+ DCHECK(valid); |
+ return proto_msg; |
+} |
+ |
+//============================================================================== |
+RendererInitializeRpc::RendererInitializeRpc(int handle, |
+ int client_handle, |
+ int audio_demuxer_handle, |
+ int video_demuxer_handle, |
+ int callback_handle) |
+ : Rpc(handle), |
+ client_handle_(client_handle), |
+ audio_demuxer_handle_(audio_demuxer_handle), |
+ video_demuxer_handle_(video_demuxer_handle), |
+ callback_handle_(callback_handle) {} |
+ |
+RendererInitializeRpc::~RendererInitializeRpc() = default; |
+ |
+scoped_refptr<RendererInitializeRpc> RendererInitializeRpc::FromRpcMessage( |
+ const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_R_INITIALIZE), rpc->proc()); |
+ |
+ int client_handle = kInvalidHandle; |
+ int audio_demuxer_handle = kInvalidHandle; |
+ int video_demuxer_handle = kInvalidHandle; |
+ int callback_handle = kInvalidHandle; |
+ |
+ DCHECK(rpc->has_renderer_initialize_rpc()); |
+ const pb::RendererInitialize rpc_message = rpc->renderer_initialize_rpc(); |
+ client_handle = rpc_message.client_handle(); |
+ audio_demuxer_handle = rpc_message.audio_demuxer_handle(); |
+ video_demuxer_handle = rpc_message.video_demuxer_handle(); |
+ callback_handle = rpc_message.callback_handle(); |
+ |
+ VLOG(2) << "client_handle:" << client_handle |
+ << " audio_demuxer_handle:" << audio_demuxer_handle |
+ << " video_demuxer_handle:" << video_demuxer_handle |
+ << " callback_handle:" << callback_handle; |
+ return new RendererInitializeRpc(rpc->handle(), client_handle, |
+ audio_demuxer_handle, video_demuxer_handle, |
+ callback_handle); |
+} |
+ |
+pb::RpcProc RendererInitializeRpc::GetProc() const { |
+ return RPC(RPC_R_INITIALIZE); |
+} |
+ |
+void RendererInitializeRpc::ToMessageInternal(pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << "client_handle:" << client_handle_ |
+ << " audio_demuxer_handle:" << audio_demuxer_handle_ |
+ << " video_demuxer_handle:" << video_demuxer_handle_ |
+ << " callback_handle:" << callback_handle_; |
+ pb::RendererInitialize* message = rpc->mutable_renderer_initialize_rpc(); |
+ message->set_client_handle(client_handle_); |
+ message->set_audio_demuxer_handle(audio_demuxer_handle_); |
+ message->set_video_demuxer_handle(video_demuxer_handle_); |
+ message->set_callback_handle(callback_handle_); |
+} |
+ |
+//============================================================================== |
+RendererStartPlayingFromRpc::RendererStartPlayingFromRpc( |
+ int handle, |
+ int64_t time_delta_usec) |
+ : Rpc(handle), time_delta_usec_(time_delta_usec) {} |
+ |
+RendererStartPlayingFromRpc::~RendererStartPlayingFromRpc() = default; |
+ |
+// static |
+scoped_refptr<RendererStartPlayingFromRpc> |
+RendererStartPlayingFromRpc::FromRpcMessage(const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_R_STARTPLAYINGFROM), rpc->proc()); |
+ |
+ int64_t time_delta_usec = 0; |
+ |
+ DCHECK(rpc->has_renderer_startplayingfrom_rpc()); |
+ const pb::RendererStartPlayingFrom rpc_message = |
+ rpc->renderer_startplayingfrom_rpc(); |
+ time_delta_usec = rpc_message.time_delta_usec(); |
+ |
+ VLOG(2) << "time_delta_usec:" << time_delta_usec; |
+ return new RendererStartPlayingFromRpc(rpc->handle(), time_delta_usec); |
+} |
+ |
+pb::RpcProc RendererStartPlayingFromRpc::GetProc() const { |
+ return RPC(RPC_R_STARTPLAYINGFROM); |
+} |
+ |
+void RendererStartPlayingFromRpc::ToMessageInternal(pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << "time_delta_usec:" << time_delta_usec_; |
+ pb::RendererStartPlayingFrom* message = |
+ rpc->mutable_renderer_startplayingfrom_rpc(); |
+ message->set_time_delta_usec(time_delta_usec_); |
+} |
+ |
+//============================================================================== |
+RendererSetCdmRpc::RendererSetCdmRpc(int handle, |
+ int cdm_id, |
+ int callback_handle) |
+ : Rpc(handle), cdm_id_(cdm_id), callback_handle_(callback_handle) {} |
+ |
+RendererSetCdmRpc::~RendererSetCdmRpc() = default; |
+ |
+scoped_refptr<RendererSetCdmRpc> RendererSetCdmRpc::FromRpcMessage( |
+ const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_R_SETCDM), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_renderer_set_cdm_rpc()); |
+ const pb::RendererSetCdm rpc_message = rpc->renderer_set_cdm_rpc(); |
+ int cdm_id = rpc_message.cdm_id(); |
+ int callback_handle = rpc_message.callback_handle(); |
+ |
+ VLOG(2) << "cdm_id:" << cdm_id << " callback_handle:" << callback_handle; |
+ return new RendererSetCdmRpc(rpc->handle(), cdm_id, callback_handle); |
+} |
+ |
+pb::RpcProc RendererSetCdmRpc::GetProc() const { |
+ return RPC(RPC_R_SETCDM); |
+} |
+ |
+void RendererSetCdmRpc::ToMessageInternal(pb::RpcMessage* rpc) const { |
+ pb::RendererSetCdm* message = rpc->mutable_renderer_set_cdm_rpc(); |
+ VLOG(2) << __FUNCTION__ << " cdm_id:" << cdm_id_ |
+ << " callback_handle:" << callback_handle_; |
+ message->set_cdm_id(cdm_id_); |
+ message->set_callback_handle(callback_handle_); |
+} |
+ |
+//============================================================================== |
+RendererClientOnTimeUpdateRpc::RendererClientOnTimeUpdateRpc( |
+ int handle, |
+ int64_t time_usec, |
+ int64_t max_time_usec) |
+ : Rpc(handle), time_usec_(time_usec), max_time_usec_(max_time_usec) {} |
+ |
+RendererClientOnTimeUpdateRpc::~RendererClientOnTimeUpdateRpc() = default; |
+ |
+scoped_refptr<RendererClientOnTimeUpdateRpc> |
+RendererClientOnTimeUpdateRpc::FromRpcMessage(const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_RC_ONTIMEUPDATE), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_rendererclient_ontimeupdate_rpc()); |
+ const pb::RendererClientOnTimeUpdate rpc_message = |
+ rpc->rendererclient_ontimeupdate_rpc(); |
+ int64_t time_usec = rpc_message.time_usec(); |
+ int64_t max_time_usec = rpc_message.max_time_usec(); |
+ |
+ VLOG(2) << __FUNCTION__ << " time_usec:" << time_usec |
+ << " max_time_usec:" << max_time_usec; |
+ return new RendererClientOnTimeUpdateRpc(rpc->handle(), time_usec, |
+ max_time_usec); |
+} |
+ |
+pb::RpcProc RendererClientOnTimeUpdateRpc::GetProc() const { |
+ return RPC(RPC_RC_ONTIMEUPDATE); |
+} |
+ |
+void RendererClientOnTimeUpdateRpc::ToMessageInternal( |
+ pb::RpcMessage* rpc) const { |
+ pb::RendererClientOnTimeUpdate* message = |
+ rpc->mutable_rendererclient_ontimeupdate_rpc(); |
+ VLOG(2) << __FUNCTION__ << " time_usec:" << time_usec_ |
+ << " max_time_usec:" << time_usec_; |
+ message->set_time_usec(time_usec_); |
+ message->set_max_time_usec(max_time_usec_); |
+} |
+ |
+//============================================================================== |
+RendererClientOnVideoNaturalSizeChangeRpc:: |
+ RendererClientOnVideoNaturalSizeChangeRpc(int handle, const gfx::Size& size) |
+ : Rpc(handle), size_(size) {} |
+ |
+RendererClientOnVideoNaturalSizeChangeRpc:: |
+ ~RendererClientOnVideoNaturalSizeChangeRpc() = default; |
+ |
+scoped_refptr<RendererClientOnVideoNaturalSizeChangeRpc> |
+RendererClientOnVideoNaturalSizeChangeRpc::FromRpcMessage( |
+ const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_RC_ONVIDEONATURALSIZECHANGE), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_rendererclient_onvideonatualsizechange_rpc()); |
+ const pb::Size rpc_message = |
+ rpc->rendererclient_onvideonatualsizechange_rpc(); |
+ gfx::Size size; |
+ DeserializeSize(rpc_message, &size); |
+ |
+ VLOG(2) << "size:" << size.ToString(); |
+ return new RendererClientOnVideoNaturalSizeChangeRpc(rpc->handle(), size); |
+} |
+ |
+pb::RpcProc RendererClientOnVideoNaturalSizeChangeRpc::GetProc() const { |
+ return RPC(RPC_RC_ONVIDEONATURALSIZECHANGE); |
+} |
+ |
+void RendererClientOnVideoNaturalSizeChangeRpc::ToMessageInternal( |
+ pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << "size:" << size_.ToString(); |
+ pb::Size* message = rpc->mutable_rendererclient_onvideonatualsizechange_rpc(); |
+ SerializeSize(size_, message); |
+} |
+ |
+//============================================================================== |
+DemuxerStreamReadUntilRpc::DemuxerStreamReadUntilRpc(int handle, |
+ uint32_t frame_id, |
+ int callback_handle) |
+ : Rpc(handle), frame_id_(frame_id), callback_handle_(callback_handle) {} |
+ |
+DemuxerStreamReadUntilRpc::~DemuxerStreamReadUntilRpc() = default; |
+ |
+scoped_refptr<DemuxerStreamReadUntilRpc> |
+DemuxerStreamReadUntilRpc::FromRpcMessage(const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_DS_READUNTIL), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_demuxerstream_readuntil_rpc()); |
+ const pb::DemuxerStreamReadUntil rpc_message = |
+ rpc->demuxerstream_readuntil_rpc(); |
+ int frame_id = rpc_message.frame_id(); |
+ int callback_handle = rpc_message.callback_handle(); |
+ |
+ VLOG(2) << "frame_id:" << frame_id << " callback_handle:" << callback_handle; |
+ return new DemuxerStreamReadUntilRpc(rpc->handle(), frame_id, |
+ callback_handle); |
+} |
+ |
+pb::RpcProc DemuxerStreamReadUntilRpc::GetProc() const { |
+ return RPC(RPC_DS_READUNTIL); |
+} |
+ |
+void DemuxerStreamReadUntilRpc::ToMessageInternal(pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << " frame_id:" << frame_id_ |
+ << " callback_handle:" << callback_handle_; |
+ pb::DemuxerStreamReadUntil* message = |
+ rpc->mutable_demuxerstream_readuntil_rpc(); |
+ message->set_callback_handle(callback_handle_); |
+ message->set_frame_id(frame_id_); |
+} |
+ |
+//============================================================================== |
+DemuxerStreamInitializeCallbackRpc::DemuxerStreamInitializeCallbackRpc( |
+ int handle, |
+ ::media::DemuxerStream::Type type, |
+ const ::media::AudioDecoderConfig& audio_config, |
+ const ::media::VideoDecoderConfig& video_config) |
+ : Rpc(handle), |
+ type_(type), |
+ audio_config_(audio_config), |
+ video_config_(video_config) {} |
+ |
+DemuxerStreamInitializeCallbackRpc::~DemuxerStreamInitializeCallbackRpc() = |
+ default; |
+ |
+scoped_refptr<DemuxerStreamInitializeCallbackRpc> |
+DemuxerStreamInitializeCallbackRpc::FromRpcMessage(const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_DS_INITIALIZE_CALLBACK), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_demuxerstream_initializecb_rpc()); |
+ const pb::DemuxerStreamInitializeCallback rpc_message = |
+ rpc->demuxerstream_initializecb_rpc(); |
+ ::media::DemuxerStream::Type type = |
+ static_cast<::media::DemuxerStream::Type>(rpc_message.type()); |
+ ::media::AudioDecoderConfig audio_config; |
+ ::media::VideoDecoderConfig video_config; |
+ switch (type) { |
+ case ::media::DemuxerStream::Type::AUDIO: { |
+ const pb::AudioDecoderConfig& audio_message = |
+ rpc_message.audio_decoder_config(); |
+ REQUIRED(DeserializeAudioConfig(audio_message, &audio_config)); |
+ break; |
+ } |
+ case ::media::DemuxerStream::Type::VIDEO: { |
+ const pb::VideoDecoderConfig& video_message = |
+ rpc_message.video_decoder_config(); |
+ REQUIRED(DeserializeVideoConfig(video_message, &video_config)); |
+ break; |
+ } |
+ default: |
+ LOG(ERROR) << "stream type unsupported"; |
+ return nullptr; |
+ } |
+ |
+ VLOG(2) << "type:" << type |
+ << " audio_config:" << audio_config.AsHumanReadableString() |
+ << " video_config:" << video_config.AsHumanReadableString(); |
+ return new DemuxerStreamInitializeCallbackRpc(rpc->handle(), type, |
+ audio_config, video_config); |
+} |
+ |
+pb::RpcProc DemuxerStreamInitializeCallbackRpc::GetProc() const { |
+ return RPC(RPC_DS_INITIALIZE_CALLBACK); |
+} |
+ |
+void DemuxerStreamInitializeCallbackRpc::ToMessageInternal( |
+ pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << " type:" << type_ |
+ << " audio_config:" << audio_config_.AsHumanReadableString() |
+ << " video_config:" << video_config_.AsHumanReadableString(); |
+ DCHECK(type_ == ::media::DemuxerStream::Type::AUDIO || |
+ type_ == ::media::DemuxerStream::Type::VIDEO); |
+ |
+ pb::DemuxerStreamInitializeCallback* message = |
+ rpc->mutable_demuxerstream_initializecb_rpc(); |
+ message->set_type(type_); |
+ |
+ switch (type_) { |
+ case ::media::DemuxerStream::Type::AUDIO: { |
+ pb::AudioDecoderConfig* audio_message = |
+ message->mutable_audio_decoder_config(); |
+ SerializeAudioConfig(audio_config_, audio_message); |
+ break; |
+ } |
+ case ::media::DemuxerStream::Type::VIDEO: { |
+ pb::VideoDecoderConfig* video_message = |
+ message->mutable_video_decoder_config(); |
+ SerializeVideoConfig(video_config_, video_message); |
+ break; |
+ } |
+ default: |
+ NOTREACHED(); |
+ } |
+} |
+ |
+//============================================================================== |
+DemuxerStreamReadUntilCallbackRpc::DemuxerStreamReadUntilCallbackRpc( |
+ int handle, |
+ uint32_t frame_id, |
+ ::media::DemuxerStream::Status status, |
+ const ::media::AudioDecoderConfig& audio_config, |
+ const ::media::VideoDecoderConfig& video_config) |
+ : Rpc(handle), |
+ frame_id_(frame_id), |
+ status_(status), |
+ audio_config_(audio_config), |
+ video_config_(video_config) {} |
+ |
+DemuxerStreamReadUntilCallbackRpc::~DemuxerStreamReadUntilCallbackRpc() = |
+ default; |
+ |
+scoped_refptr<DemuxerStreamReadUntilCallbackRpc> |
+DemuxerStreamReadUntilCallbackRpc::FromRpcMessage(const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_DS_READUNTIL_CALLBACK), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_demuxerstream_readuntilcb_rpc()); |
+ const pb::DemuxerStreamReadUntilCallback rpc_message = |
+ rpc->demuxerstream_readuntilcb_rpc(); |
+ int frame_id = rpc_message.frame_id(); |
+ ::media::DemuxerStream::Status status = |
+ static_cast<::media::DemuxerStream::Status>(rpc_message.status()); |
+ |
+ ::media::AudioDecoderConfig audio_config; |
+ ::media::VideoDecoderConfig video_config; |
+ if (status == ::media::DemuxerStream::kConfigChanged) { |
+ if (rpc_message.has_audio_decoder_config()) { |
+ REQUIRED(DeserializeAudioConfig(rpc_message.audio_decoder_config(), |
+ &audio_config)); |
+ } else if (rpc_message.has_video_decoder_config()) { |
+ REQUIRED(DeserializeVideoConfig(rpc_message.video_decoder_config(), |
+ &video_config)); |
+ } else { |
+ LOG(ERROR) << "packet has neither 'audio_config' nor 'video_config'"; |
+ return nullptr; |
+ } |
+ } |
+ |
+ VLOG(2) << "status:" << status << " frame_id:" << frame_id; |
+ return new DemuxerStreamReadUntilCallbackRpc(rpc->handle(), frame_id, status, |
+ audio_config, video_config); |
+} |
+ |
+pb::RpcProc DemuxerStreamReadUntilCallbackRpc::GetProc() const { |
+ return RPC(RPC_DS_READUNTIL_CALLBACK); |
+} |
+ |
+void DemuxerStreamReadUntilCallbackRpc::ToMessageInternal( |
+ pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << " frame_id:" << frame_id_ << " status:" << status_; |
+ |
+ pb::DemuxerStreamReadUntilCallback* message = |
+ rpc->mutable_demuxerstream_readuntilcb_rpc(); |
+ message->set_frame_id(frame_id_); |
+ message->set_status(status_); |
+ |
+ if (status_ == ::media::DemuxerStream::kConfigChanged) { |
+ if (audio_config_.IsValidConfig()) { |
+ pb::AudioDecoderConfig* audio_message = |
+ message->mutable_audio_decoder_config(); |
+ SerializeAudioConfig(audio_config_, audio_message); |
+ } else if (video_config_.IsValidConfig()) { |
+ pb::VideoDecoderConfig* video_message = |
+ message->mutable_video_decoder_config(); |
+ SerializeVideoConfig(video_config_, video_message); |
+ } else { |
+ NOTREACHED(); |
+ } |
+ } |
+} |
+ |
+//============================================================================== |
+CdmInitializeRpc::CdmInitializeRpc(int handle, |
+ const std::string& key_system, |
+ const std::string& security_origin, |
+ const ::media::CdmConfig& cdm_config, |
+ int callback_handle) |
+ : Rpc(handle), |
+ key_system_(key_system), |
+ security_origin_(security_origin), |
+ cdm_config_(cdm_config), |
+ callback_handle_(callback_handle) {} |
+ |
+CdmInitializeRpc::~CdmInitializeRpc() = default; |
+ |
+scoped_refptr<CdmInitializeRpc> CdmInitializeRpc::FromRpcMessage( |
+ const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_CDM_INITIALIZE), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_cdm_initialize_rpc()); |
+ const pb::CdmInitialize rpc_message = rpc->cdm_initialize_rpc(); |
+ std::string key_system = rpc_message.key_system(); |
+ std::string security_origin = rpc_message.security_origin(); |
+ ::media::CdmConfig cdm_config; |
+ cdm_config.allow_distinctive_identifier = |
+ rpc_message.allow_distinctive_identifier(); |
+ cdm_config.allow_persistent_state = rpc_message.allow_persistent_state(); |
+ cdm_config.use_hw_secure_codecs = rpc_message.use_hw_secure_codecs(); |
+ int callback_handle = rpc_message.callback_handle(); |
+ |
+ VLOG(2) << "key_system:" << key_system |
+ << " security_origin:" << security_origin |
+ << " allow_distinctive_identifier:" |
+ << cdm_config.allow_distinctive_identifier |
+ << " allow_persistent_state:" << cdm_config.allow_persistent_state |
+ << " use_hw_secure_codecs:" << cdm_config.use_hw_secure_codecs |
+ << " callback_handle:" << callback_handle; |
+ return new CdmInitializeRpc(rpc->handle(), key_system, security_origin, |
+ cdm_config, callback_handle); |
+} |
+ |
+pb::RpcProc CdmInitializeRpc::GetProc() const { |
+ return RPC(RPC_CDM_INITIALIZE); |
+} |
+ |
+void CdmInitializeRpc::ToMessageInternal(pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << " key_system:" << key_system_ |
+ << " security_origin:" << security_origin_ |
+ << " allow_distinctive_identifier:" |
+ << cdm_config_.allow_distinctive_identifier |
+ << " allow_persistent_state:" << cdm_config_.allow_persistent_state |
+ << " use_hw_secure_codecs:" << cdm_config_.use_hw_secure_codecs |
+ << " callback_handle:" << callback_handle_; |
+ |
+ pb::CdmInitialize* message = rpc->mutable_cdm_initialize_rpc(); |
+ message->set_key_system(key_system_); |
+ message->set_security_origin(security_origin_); |
+ SerializeCdmConfig(cdm_config_, message); |
+ message->set_callback_handle(callback_handle_); |
+} |
+ |
+//============================================================================== |
+CdmSetServerCertificateRpc::CdmSetServerCertificateRpc( |
+ int handle, |
+ const uint8_t* certificate_data, |
+ size_t certificate_data_size, |
+ int callback_handle) |
+ : Rpc(handle), |
+ certificate_data_(certificate_data, |
+ certificate_data + certificate_data_size), |
+ callback_handle_(callback_handle) {} |
+ |
+CdmSetServerCertificateRpc::~CdmSetServerCertificateRpc() = default; |
+ |
+scoped_refptr<CdmSetServerCertificateRpc> |
+CdmSetServerCertificateRpc::FromRpcMessage(const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_CDM_SETSERVERCERTIFICATE), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_cdm_setservercertificate_rpc()); |
+ const pb::CdmSetServerCertificate rpc_message = |
+ rpc->cdm_setservercertificate_rpc(); |
+ int callback_handle = rpc_message.callback_handle(); |
+ |
+ std::vector<uint8_t> certificate; |
+ certificate.assign(rpc_message.certificate_data().begin(), |
+ rpc_message.certificate_data().end()); |
+ |
+ VLOG(2) << "callback_handle:" << callback_handle |
+ << " certificate size:" << certificate.size(); |
+ return new CdmSetServerCertificateRpc(rpc->handle(), &certificate[0], |
+ certificate.size(), callback_handle); |
+} |
+ |
+pb::RpcProc CdmSetServerCertificateRpc::GetProc() const { |
+ return RPC(RPC_CDM_SETSERVERCERTIFICATE); |
+} |
+ |
+void CdmSetServerCertificateRpc::ToMessageInternal(pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << " callback_handle:" << callback_handle_ |
+ << " certificate size:" << certificate_data_.size(); |
+ pb::CdmSetServerCertificate* message = |
+ rpc->mutable_cdm_setservercertificate_rpc(); |
+ message->set_callback_handle(callback_handle_); |
+ message->set_certificate_data(&certificate_data_[0], |
+ certificate_data_.size()); |
+} |
+ |
+//============================================================================== |
+CdmCreateSessionAndGenerateRequestRpc::CdmCreateSessionAndGenerateRequestRpc( |
+ int handle, |
+ ::media::MediaKeys::SessionType session_type, |
+ ::media::EmeInitDataType init_data_type, |
+ const uint8_t* init_data, |
+ size_t init_data_size, |
+ int callback_handle) |
+ : Rpc(handle), |
+ session_type_(session_type), |
+ init_data_type_(init_data_type), |
+ init_data_(init_data, init_data + init_data_size), |
+ callback_handle_(callback_handle) {} |
+ |
+CdmCreateSessionAndGenerateRequestRpc:: |
+ ~CdmCreateSessionAndGenerateRequestRpc() = default; |
+ |
+scoped_refptr<CdmCreateSessionAndGenerateRequestRpc> |
+CdmCreateSessionAndGenerateRequestRpc::FromRpcMessage( |
+ const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_CDM_CREATESESSIONANDGENERATEREQUEST), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_cdm_createsessionandgeneraterequest_rpc()); |
+ const pb::CdmCreateSessionAndGenerateRequest rpc_message = |
+ rpc->cdm_createsessionandgeneraterequest_rpc(); |
+ ::media::MediaKeys::SessionType session_type = |
+ static_cast<::media::MediaKeys::SessionType>(rpc_message.session_type()); |
+ ::media::EmeInitDataType init_data_type = |
+ static_cast<::media::EmeInitDataType>(rpc_message.init_data_type()); |
+ int callback_handle = rpc_message.callback_handle(); |
+ std::vector<uint8_t> init_data; |
+ init_data.assign(rpc_message.init_data().begin(), |
+ rpc_message.init_data().end()); |
+ |
+ VLOG(2) << "session_type:" << session_type |
+ << " init_data_type:" << static_cast<int>(init_data_type) |
+ << " callback_handle:" << callback_handle |
+ << " init_data size:" << init_data.size(); |
+ return new CdmCreateSessionAndGenerateRequestRpc( |
+ rpc->handle(), session_type, init_data_type, &init_data[0], |
+ init_data.size(), callback_handle); |
+} |
+ |
+pb::RpcProc CdmCreateSessionAndGenerateRequestRpc::GetProc() const { |
+ return RPC(RPC_CDM_CREATESESSIONANDGENERATEREQUEST); |
+} |
+ |
+void CdmCreateSessionAndGenerateRequestRpc::ToMessageInternal( |
+ pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << " session_type:" << session_type_ |
+ << " init_data_type:" << static_cast<int>(init_data_type_) |
+ << " callback_handle:" << callback_handle_ |
+ << " init_data size:" << init_data_.size(); |
+ |
+ pb::CdmCreateSessionAndGenerateRequest* message = |
+ rpc->mutable_cdm_createsessionandgeneraterequest_rpc(); |
+ message->set_session_type(session_type_); |
+ message->set_init_data_type(static_cast<int>(init_data_type_)); |
+ message->set_callback_handle(callback_handle_); |
+ message->set_init_data(&init_data_[0], init_data_.size()); |
+} |
+ |
+//============================================================================== |
+CdmLoadSessionRpc::CdmLoadSessionRpc( |
+ int handle, |
+ ::media::MediaKeys::SessionType session_type, |
+ const std::string& session_id, |
+ int callback_handle) |
+ : Rpc(handle), |
+ session_type_(session_type), |
+ session_id_(session_id), |
+ callback_handle_(callback_handle) {} |
+ |
+CdmLoadSessionRpc::~CdmLoadSessionRpc() = default; |
+ |
+scoped_refptr<CdmLoadSessionRpc> CdmLoadSessionRpc::FromRpcMessage( |
+ const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_CDM_LOADSESSION), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_cdm_loadsession_rpc()); |
+ const pb::CdmLoadSession rpc_message = rpc->cdm_loadsession_rpc(); |
+ ::media::MediaKeys::SessionType session_type = |
+ static_cast<::media::MediaKeys::SessionType>(rpc_message.session_type()); |
+ std::string session_id = rpc_message.session_id(); |
+ int callback_handle = rpc_message.callback_handle(); |
+ |
+ VLOG(2) << "session_type:" << session_type << " session_id:" << session_id |
+ << " callback_handle:" << callback_handle; |
+ return new CdmLoadSessionRpc(rpc->handle(), session_type, session_id, |
+ callback_handle); |
+} |
+ |
+pb::RpcProc CdmLoadSessionRpc::GetProc() const { |
+ return RPC(RPC_CDM_LOADSESSION); |
+} |
+ |
+void CdmLoadSessionRpc::ToMessageInternal(pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << " session_type:" << session_type_ |
+ << " session_id:" << session_id_ |
+ << " callback_handle:" << callback_handle_; |
+ |
+ pb::CdmLoadSession* message = rpc->mutable_cdm_loadsession_rpc(); |
+ message->set_session_type(session_type_); |
+ message->set_session_id(session_id_); |
+ message->set_callback_handle(callback_handle_); |
+} |
+ |
+//============================================================================== |
+CdmUpdateSessionRpc::CdmUpdateSessionRpc(int handle, |
+ const std::string& session_id, |
+ const uint8_t* response, |
+ size_t response_size, |
+ int callback_handle) |
+ : Rpc(handle), |
+ session_id_(session_id), |
+ response_(response, response + response_size), |
+ callback_handle_(callback_handle) {} |
+CdmUpdateSessionRpc::~CdmUpdateSessionRpc() = default; |
+ |
+scoped_refptr<CdmUpdateSessionRpc> CdmUpdateSessionRpc::FromRpcMessage( |
+ const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_CDM_UPDATESESSION), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_cdm_updatesession_rpc()); |
+ const pb::CdmUpdateSession rpc_message = rpc->cdm_updatesession_rpc(); |
+ std::string session_id = rpc_message.session_id(); |
+ int callback_handle = rpc_message.callback_handle(); |
+ std::vector<uint8_t> response; |
+ response.assign(rpc_message.response().begin(), rpc_message.response().end()); |
+ VLOG(2) << " session_id:" << session_id |
+ << " callback_handle:" << callback_handle |
+ << " response size:" << response.size(); |
+ |
+ return new CdmUpdateSessionRpc(rpc->handle(), session_id, &response[0], |
+ response.size(), callback_handle); |
+} |
+ |
+pb::RpcProc CdmUpdateSessionRpc::GetProc() const { |
+ return RPC(RPC_CDM_UPDATESESSION); |
+} |
+ |
+void CdmUpdateSessionRpc::ToMessageInternal(pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << " session_id:" << session_id_ |
+ << " callback_handle:" << callback_handle_ |
+ << " response size:" << response_.size(); |
+ |
+ pb::CdmUpdateSession* message = rpc->mutable_cdm_updatesession_rpc(); |
+ message->set_session_id(session_id_); |
+ message->set_callback_handle(callback_handle_); |
+ message->set_response(&response_[0], response_.size()); |
+} |
+ |
+//============================================================================== |
+CdmCloseSessionRpc::CdmCloseSessionRpc(int handle, |
+ const std::string& session_id, |
+ int callback_handle) |
+ : Rpc(handle), session_id_(session_id), callback_handle_(callback_handle) {} |
+ |
+CdmCloseSessionRpc::~CdmCloseSessionRpc() = default; |
+ |
+scoped_refptr<CdmCloseSessionRpc> CdmCloseSessionRpc::FromRpcMessage( |
+ const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_CDM_CLOSESESSION), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_cdm_closesession_rpc()); |
+ const pb::CdmCloseSession rpc_message = rpc->cdm_closesession_rpc(); |
+ std::string session_id = rpc_message.session_id(); |
+ int callback_handle = rpc_message.callback_handle(); |
+ |
+ VLOG(2) << " session_id:" << session_id |
+ << " callback_handle:" << callback_handle; |
+ return new CdmCloseSessionRpc(rpc->handle(), session_id, callback_handle); |
+} |
+ |
+pb::RpcProc CdmCloseSessionRpc::GetProc() const { |
+ return RPC(RPC_CDM_CLOSESESSION); |
+} |
+ |
+void CdmCloseSessionRpc::ToMessageInternal(pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << " session_id:" << session_id_ |
+ << " callback_handle:" << callback_handle_; |
+ |
+ pb::CdmCloseSession* message = rpc->mutable_cdm_closesession_rpc(); |
+ message->set_session_id(session_id_); |
+ message->set_callback_handle(callback_handle_); |
+} |
+ |
+//============================================================================== |
+CdmRemoveSessionRpc::CdmRemoveSessionRpc(int handle, |
+ const std::string& session_id, |
+ int callback_handle) |
+ : Rpc(handle), session_id_(session_id), callback_handle_(callback_handle) {} |
+ |
+CdmRemoveSessionRpc::~CdmRemoveSessionRpc() = default; |
+ |
+scoped_refptr<CdmRemoveSessionRpc> CdmRemoveSessionRpc::FromRpcMessage( |
+ const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_CDM_REMOVESESSION), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_cdm_removesession_rpc()); |
+ const pb::CdmRemoveSession rpc_message = rpc->cdm_removesession_rpc(); |
+ std::string session_id = rpc_message.session_id(); |
+ int callback_handle = rpc_message.callback_handle(); |
+ |
+ VLOG(2) << " session_id:" << session_id |
+ << " callback_handle:" << callback_handle; |
+ return new CdmRemoveSessionRpc(rpc->handle(), session_id, callback_handle); |
+} |
+ |
+pb::RpcProc CdmRemoveSessionRpc::GetProc() const { |
+ return RPC(RPC_CDM_REMOVESESSION); |
+} |
+ |
+void CdmRemoveSessionRpc::ToMessageInternal(pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << " session_id:" << session_id_ |
+ << " callback_handle:" << callback_handle_; |
+ |
+ pb::CdmRemoveSession* message = rpc->mutable_cdm_removesession_rpc(); |
+ message->set_session_id(session_id_); |
+ message->set_callback_handle(callback_handle_); |
+} |
+ |
+//============================================================================== |
+CdmPromiseResult::CdmPromiseResult() |
+ : CdmPromiseResult(::media::MediaKeys::UNKNOWN_ERROR, 0, "") {} |
+ |
+CdmPromiseResult::CdmPromiseResult(::media::MediaKeys::Exception exception, |
+ uint32_t system_code, |
+ std::string error_message) |
+ : success_(false), |
+ exception_(exception), |
+ system_code_(system_code), |
+ error_message_(error_message) {} |
+ |
+CdmPromiseResult::CdmPromiseResult(const CdmPromiseResult& other) = default; |
+ |
+CdmPromiseResult::~CdmPromiseResult() = default; |
+ |
+CdmPromiseResult CdmPromiseResult::SuccessResult() { |
+ CdmPromiseResult result(static_cast<::media::MediaKeys::Exception>(0), 0, ""); |
+ result.success_ = true; |
+ return result; |
+} |
+ |
+//============================================================================== |
+CdmInitializeCallbackRpc::CdmInitializeCallbackRpc( |
+ int handle, |
+ const CdmPromiseResult& result, |
+ int cdm_id, |
+ int decryptor_handle) |
+ : CdmPromiseCallbackRpc(handle, result), |
+ cdm_id_(cdm_id), |
+ decryptor_handle_(decryptor_handle) {} |
+ |
+CdmInitializeCallbackRpc::~CdmInitializeCallbackRpc() = default; |
+ |
+scoped_refptr<CdmInitializeCallbackRpc> |
+CdmInitializeCallbackRpc::FromRpcMessage(const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_CDM_INITIALIZE_CALLBACK), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_cdm_promise_rpc()); |
+ const pb::CdmPromise promise_message = rpc->cdm_promise_rpc(); |
+ CdmPromiseResult result; |
+ REQUIRED(internal::CdmPromiseFromMessage(promise_message, &result, nullptr)); |
+ int cdm_id = promise_message.cdm_id(); |
+ int decryptor_handle = promise_message.decryptor_handle(); |
+ |
+ VLOG(2) << "cdm_id:" << cdm_id << " decryptor_handle:" << decryptor_handle; |
+ return new CdmInitializeCallbackRpc(rpc->handle(), result, cdm_id, |
+ decryptor_handle); |
+} |
+ |
+void CdmInitializeCallbackRpc::ToMessageInternal(pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << " cdm_id:" << cdm_id_ |
+ << " decryptor_handle:" << decryptor_handle_; |
+ |
+ CdmPromiseCallbackRpc<RPC(RPC_CDM_INITIALIZE_CALLBACK)>::ToMessageInternal( |
+ rpc); |
+ pb::CdmPromise* message = rpc->mutable_cdm_promise_rpc(); |
+ message->set_cdm_id(cdm_id_); |
+ message->set_decryptor_handle(decryptor_handle_); |
+} |
+ |
+//============================================================================== |
+CdmClientOnSessionMessageRpc::CdmClientOnSessionMessageRpc( |
+ int handle, |
+ const std::string& session_id, |
+ ::media::MediaKeys::MessageType message_type, |
+ const uint8_t* message, |
+ size_t message_size, |
+ const std::string& legacy_destination_url) |
+ : Rpc(handle), |
+ session_id_(session_id), |
+ message_type_(message_type), |
+ message_(message, message + message_size), |
+ legacy_destination_url_(legacy_destination_url) {} |
+ |
+CdmClientOnSessionMessageRpc::~CdmClientOnSessionMessageRpc() = default; |
+ |
+scoped_refptr<CdmClientOnSessionMessageRpc> |
+CdmClientOnSessionMessageRpc::FromRpcMessage(const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_CDMC_ONSESSIONMESSAGE), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_cdm_onsessionmessage_rpc()); |
+ const pb::CdmClientOnSessionMessage onsession_message = |
+ rpc->cdm_onsessionmessage_rpc(); |
+ std::string session_id = onsession_message.session_id(); |
+ ::media::MediaKeys::MessageType message_type = |
+ static_cast<::media::MediaKeys::MessageType>( |
+ onsession_message.message_type()); |
+ std::string legacy_destination_url = |
+ onsession_message.legacy_destination_url(); |
+ std::vector<uint8_t> message_data; |
+ message_data.assign(onsession_message.message().begin(), |
+ onsession_message.message().end()); |
+ |
+ return new CdmClientOnSessionMessageRpc( |
+ rpc->handle(), session_id, message_type, &message_data[0], |
+ message_data.size(), legacy_destination_url); |
+} |
+ |
+pb::RpcProc CdmClientOnSessionMessageRpc::GetProc() const { |
+ return RPC(RPC_CDMC_ONSESSIONMESSAGE); |
+} |
+ |
+void CdmClientOnSessionMessageRpc::ToMessageInternal( |
+ pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << " session_id:" << session_id_ |
+ << " message_type:" << message_type_ |
+ << " legacy_destination_url:" << legacy_destination_url_; |
+ |
+ pb::CdmClientOnSessionMessage* message = |
+ rpc->mutable_cdm_onsessionmessage_rpc(); |
+ message->set_session_id(session_id_); |
+ message->set_message_type( |
+ static_cast<pb::MediaKeysMessageType>(message_type_)); |
+ message->set_legacy_destination_url(legacy_destination_url_); |
+ message->set_message(&message_[0], message_.size()); |
+} |
+ |
+//============================================================================== |
+CdmClientOnLegacySessionErrorRpc::CdmClientOnLegacySessionErrorRpc( |
+ int handle, |
+ const std::string& session_id, |
+ ::media::MediaKeys::Exception exception, |
+ uint32_t system_code, |
+ const std::string& error_message) |
+ : Rpc(handle), |
+ session_id_(session_id), |
+ exception_(exception), |
+ system_code_(system_code), |
+ error_message_(error_message) {} |
+ |
+CdmClientOnLegacySessionErrorRpc::~CdmClientOnLegacySessionErrorRpc() = default; |
+ |
+scoped_refptr<CdmClientOnLegacySessionErrorRpc> |
+CdmClientOnLegacySessionErrorRpc::FromRpcMessage(const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_CDMC_ONLEGACYSESSIONERROR), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_cdm_onlegacysessionerror_rpc()); |
+ const pb::CdmClientOnLegacySessionError legacyerror_message = |
+ rpc->cdm_onlegacysessionerror_rpc(); |
+ std::string session_id = legacyerror_message.session_id(); |
+ ::media::MediaKeys::Exception exception = |
+ static_cast<::media::MediaKeys::Exception>( |
+ legacyerror_message.exception()); |
+ uint32_t system_code = legacyerror_message.system_code(); |
+ std::string error_message = legacyerror_message.error_message(); |
+ |
+ return new CdmClientOnLegacySessionErrorRpc( |
+ rpc->handle(), session_id, exception, system_code, error_message); |
+} |
+ |
+pb::RpcProc CdmClientOnLegacySessionErrorRpc::GetProc() const { |
+ return RPC(RPC_CDMC_ONLEGACYSESSIONERROR); |
+} |
+ |
+void CdmClientOnLegacySessionErrorRpc::ToMessageInternal( |
+ pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << " session_id:" << session_id_ |
+ << " exception:" << exception_ << " system_code:" << system_code_ |
+ << " error_message:" << error_message_; |
+ |
+ pb::CdmClientOnLegacySessionError* message = |
+ rpc->mutable_cdm_onlegacysessionerror_rpc(); |
+ message->set_session_id(session_id_); |
+ message->set_exception(static_cast<pb::MediaKeysException>(exception_)); |
+ message->set_system_code(system_code_); |
+ message->set_error_message(error_message_); |
+} |
+ |
+//============================================================================== |
+CdmClientOnSessionKeysChangeRpc::CdmClientOnSessionKeysChangeRpc( |
+ int handle, |
+ const std::string& session_id, |
+ bool has_additional_usable_key, |
+ const ::media::CdmKeyInformation* key_information, |
+ size_t key_information_size) |
+ : Rpc(handle), |
+ session_id_(session_id), |
+ has_additional_usable_key_(has_additional_usable_key), |
+ key_information_(key_information, |
+ key_information + key_information_size) {} |
+ |
+CdmClientOnSessionKeysChangeRpc::~CdmClientOnSessionKeysChangeRpc() = default; |
+ |
+scoped_refptr<CdmClientOnSessionKeysChangeRpc> |
+CdmClientOnSessionKeysChangeRpc::FromRpcMessage(const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_CDMC_ONSESSIONKEYSCHANGE), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_cdm_onsessionkeychange_rpc()); |
+ const pb::CdmClientOnSessionKeysChange keychange_message = |
+ rpc->cdm_onsessionkeychange_rpc(); |
+ std::string session_id = keychange_message.session_id(); |
+ bool has_additional_usable_key = |
+ keychange_message.has_additional_usable_key(); |
+ std::vector<::media::CdmKeyInformation> key_information; |
+ if (has_additional_usable_key) { |
+ REQUIRED(keychange_message.key_information_size()); |
+ REQUIRED(DeserializeCdmKeyInformation(keychange_message, &key_information)); |
+ } |
+ |
+ return new CdmClientOnSessionKeysChangeRpc( |
+ rpc->handle(), session_id, has_additional_usable_key, |
+ key_information.data(), key_information.size()); |
+} |
+ |
+pb::RpcProc CdmClientOnSessionKeysChangeRpc::GetProc() const { |
+ return RPC(RPC_CDMC_ONSESSIONKEYSCHANGE); |
+} |
+ |
+void CdmClientOnSessionKeysChangeRpc::ToMessageInternal( |
+ pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << " session_id:" << session_id_ |
+ << " has_additional_usable_key:" << has_additional_usable_key_; |
+ |
+ pb::CdmClientOnSessionKeysChange* message = |
+ rpc->mutable_cdm_onsessionkeychange_rpc(); |
+ message->set_session_id(session_id_); |
+ message->set_has_additional_usable_key(has_additional_usable_key_); |
+ SerializeCdmKeyInformation(message, key_information_); |
+} |
+ |
+//============================================================================== |
+CdmClientOnSessionExpirationUpdateRpc::CdmClientOnSessionExpirationUpdateRpc( |
+ int handle, |
+ const std::string& session_id, |
+ double new_expiry_time_sec) |
+ : Rpc(handle), |
+ session_id_(session_id), |
+ new_expiry_time_sec_(new_expiry_time_sec) {} |
+ |
+CdmClientOnSessionExpirationUpdateRpc:: |
+ ~CdmClientOnSessionExpirationUpdateRpc() = default; |
+ |
+scoped_refptr<CdmClientOnSessionExpirationUpdateRpc> |
+CdmClientOnSessionExpirationUpdateRpc::FromRpcMessage( |
+ const pb::RpcMessage* rpc) { |
+ DCHECK_EQ(RPC(RPC_CDMC_ONSESSIONEXPIRATIONUPDATE), rpc->proc()); |
+ |
+ REQUIRED(rpc->has_cdm_onsessionexpirationupdate_rpc()); |
+ const pb::CdmClientOnSessionExpirationUpdate expire_message = |
+ rpc->cdm_onsessionexpirationupdate_rpc(); |
+ std::string session_id = expire_message.session_id(); |
+ double new_expiry_time_sec = expire_message.new_expiry_time_sec(); |
+ |
+ return new CdmClientOnSessionExpirationUpdateRpc(rpc->handle(), session_id, |
+ new_expiry_time_sec); |
+} |
+ |
+pb::RpcProc CdmClientOnSessionExpirationUpdateRpc::GetProc() const { |
+ return RPC(RPC_CDMC_ONSESSIONEXPIRATIONUPDATE); |
+} |
+ |
+void CdmClientOnSessionExpirationUpdateRpc::ToMessageInternal( |
+ pb::RpcMessage* rpc) const { |
+ VLOG(2) << __FUNCTION__ << " session_id:" << session_id_ |
+ << " new_expiry_time_sec_:" << new_expiry_time_sec_; |
+ |
+ pb::CdmClientOnSessionExpirationUpdate* message = |
+ rpc->mutable_cdm_onsessionexpirationupdate_rpc(); |
+ message->set_session_id(session_id_); |
+ message->set_new_expiry_time_sec(new_expiry_time_sec_); |
+} |
+ |
+#undef REQUIRED |
+ |
+} // namespace remoting |
+} // namespace media |