Index: media/remoting/rpc/rpc.h |
diff --git a/media/remoting/rpc/rpc.h b/media/remoting/rpc/rpc.h |
new file mode 100644 |
index 0000000000000000000000000000000000000000..efc4c59371761144bbfe550873104002ba43e95a |
--- /dev/null |
+++ b/media/remoting/rpc/rpc.h |
@@ -0,0 +1,858 @@ |
+// 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. |
+ |
+#ifndef MEDIA_REMOTING_RPC_RPC_H_ |
+#define MEDIA_REMOTING_RPC_RPC_H_ |
+ |
+#include <cstdint> |
+#include <string> |
+#include <vector> |
+ |
+#include "base/macros.h" |
+#include "base/memory/ref_counted.h" |
+#include "media/base/audio_decoder_config.h" |
+#include "media/base/cdm_config.h" |
+#include "media/base/cdm_key_information.h" |
+#include "media/base/demuxer_stream.h" |
+#include "media/base/eme_constants.h" |
+#include "media/base/media_keys.h" |
+#include "media/base/video_decoder_config.h" |
+#include "media/remoting/remoting_rpc_message.pb.h" |
+ |
+namespace media { |
+namespace remoting { |
+ |
+class CdmPromiseResult; |
+ |
+namespace internal { |
+ |
+template <class T> |
+inline bool ProtoMessageGet(const pb::RpcMessage& message, T* value); |
+ |
+template <class T> |
+inline void ProtoMessageSet(pb::RpcMessage* message, const T& value); |
+ |
+template <> |
+inline bool ProtoMessageGet<bool>(const pb::RpcMessage& message, bool* value) { |
+ if (!message.has_boolean_value()) |
+ return false; |
+ *value = message.boolean_value(); |
+ return true; |
+} |
+ |
+template <> |
+inline bool ProtoMessageGet<int>(const pb::RpcMessage& message, int* value) { |
+ if (!message.has_integer_value()) |
+ return false; |
+ *value = message.integer_value(); |
+ return true; |
+} |
+ |
+template <> |
+inline bool ProtoMessageGet<double>(const pb::RpcMessage& message, |
+ double* value) { |
+ if (!message.has_double_value()) |
+ return false; |
+ *value = message.double_value(); |
+ return true; |
+} |
+ |
+template <> |
+inline bool ProtoMessageGet<std::string>(const pb::RpcMessage& message, |
+ std::string* value) { |
+ if (!message.has_string_value()) |
+ return false; |
+ *value = message.string_value(); |
+ return true; |
+} |
+ |
+template <> |
+inline void ProtoMessageSet<bool>(pb::RpcMessage* message, const bool& value) { |
+ message->set_boolean_value(value); |
+} |
+ |
+template <> |
+inline void ProtoMessageSet<int>(pb::RpcMessage* message, const int& value) { |
+ message->set_integer_value(value); |
+} |
+ |
+template <> |
+inline void ProtoMessageSet<double>(pb::RpcMessage* message, |
+ const double& value) { |
+ message->set_double_value(value); |
+} |
+ |
+template <> |
+inline void ProtoMessageSet<std::string>(pb::RpcMessage* message, |
+ const std::string& value) { |
+ message->set_string_value(value); |
+} |
+ |
+bool CdmPromiseFromMessage(const pb::CdmPromise& promise_message, |
+ CdmPromiseResult* result, |
+ std::string* session_id); |
+ |
+void CdmPromiseToMessage(pb::CdmPromise* promise_message, |
+ const CdmPromiseResult& result, |
+ const std::string& session_id); |
+ |
+} // namespace internal |
+ |
+class Rpc : public base::RefCountedThreadSafe<Rpc> { |
+ public: |
+ static const int kInvalidHandle = -1; |
+ static const int kReceiverHandle = 0; |
+ |
+ static scoped_refptr<Rpc> FromMessage(const std::string& proto); |
+ |
+ int handle() const { return handle_; } |
+ |
+ std::string ToMessage() const; |
+ |
+ virtual pb::RpcProc GetProc() const = 0; |
+ |
+ protected: |
+ friend class base::RefCountedThreadSafe<Rpc>; |
+ explicit Rpc(int handle); |
+ virtual ~Rpc(); |
+ |
+ virtual void ToMessageInternal(pb::RpcMessage* rpc) const = 0; |
+ |
+ private: |
+ int handle_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(Rpc); |
+}; |
+ |
+template <typename T, pb::RpcProc Proc> |
+class SimpleRpc : public Rpc { |
+ public: |
+ SimpleRpc(int handle, T value) : Rpc(handle), value_(value) {} |
+ |
+ static scoped_refptr<SimpleRpc> FromRpcMessage(const pb::RpcMessage* rpc) { |
+ T value; |
+ if (!internal::ProtoMessageGet(*rpc, &value)) { |
+ LOG(ERROR) << "Not valid proto buffer message"; |
+ return nullptr; |
+ } |
+ |
+ return new SimpleRpc(rpc->handle(), value); |
+ } |
+ |
+ const T& value() const { return value_; } |
+ |
+ pb::RpcProc GetProc() const override { return Proc; } |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override { |
+ internal::ProtoMessageSet(rpc, value_); |
+ } |
+ |
+ private: |
+ ~SimpleRpc() override = default; |
+ T value_; |
+}; |
+ |
+template <pb::RpcProc Proc> |
+class NullRpc : public Rpc { |
+ public: |
+ explicit NullRpc(int handle) : Rpc(handle) {} |
+ |
+ static scoped_refptr<NullRpc> FromRpcMessage(const pb::RpcMessage* rpc) { |
+ return new NullRpc(rpc->handle()); |
+ } |
+ |
+ pb::RpcProc GetProc() const override { return Proc; } |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override {} |
+ |
+ private: |
+ ~NullRpc() override = default; |
+}; |
+ |
+//============================================================================== |
+using AcquireRendererRpc = SimpleRpc<int, pb::RPC_ACQUIRE_RENDERER>; |
+using AcquireRendererDoneRpc = SimpleRpc<int, pb::RPC_ACQUIRE_RENDERER_DONE>; |
+using AcquireCdmRpc = SimpleRpc<int, pb::RPC_ACQUIRE_CDM>; |
+using AcquireCdmDoneRpc = SimpleRpc<int, pb::RPC_ACQUIRE_CDM>; |
+ |
+//============================================================================== |
+class RendererInitializeRpc : public Rpc { |
+ public: |
+ RendererInitializeRpc(int handle, |
+ int client_handle, |
+ int audio_demuxer_handle, |
+ int video_demuxer_handle, |
+ int callback_handle); |
+ |
+ static scoped_refptr<RendererInitializeRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ int client_handle() const { return client_handle_; } |
+ int audio_demuxer_handle() const { return audio_demuxer_handle_; } |
+ int video_demuxer_handle() const { return video_demuxer_handle_; } |
+ int callback_handle() const { return callback_handle_; } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~RendererInitializeRpc() override; |
+ int client_handle_; |
+ int audio_demuxer_handle_; |
+ int video_demuxer_handle_; |
+ int callback_handle_; |
+}; |
+ |
+//============================================================================== |
+using RendererFlushRpc = SimpleRpc<int, pb::RPC_R_FLUSH>; |
+ |
+//============================================================================== |
+class RendererStartPlayingFromRpc : public Rpc { |
+ public: |
+ RendererStartPlayingFromRpc(int handle, int64_t time_delta_usec); |
+ |
+ static scoped_refptr<RendererStartPlayingFromRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ int64_t time_delta_usec() const { return time_delta_usec_; } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~RendererStartPlayingFromRpc() override; |
+ int64_t time_delta_usec_; |
+}; |
+ |
+//============================================================================== |
+using RendererSetPlaybackRateRpc = SimpleRpc<double, pb::RPC_R_SETPLAYBACKRATE>; |
+using RendererSetVolumeRpc = SimpleRpc<double, pb::RPC_R_SETVOLUME>; |
+ |
+//============================================================================== |
+class RendererSetCdmRpc : public Rpc { |
+ public: |
+ RendererSetCdmRpc(int handle, int cdm_id, int callback_handle); |
+ |
+ static scoped_refptr<RendererSetCdmRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ int cdm_id() const { return cdm_id_; } |
+ int callback_handle() const { return callback_handle_; } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~RendererSetCdmRpc() override; |
+ int cdm_id_; |
+ int callback_handle_; |
+}; |
+ |
+//============================================================================== |
+using RendererInitializeCallbackRpc = |
+ SimpleRpc<bool, pb::RPC_R_INITIALIZE_CALLBACK>; |
+using RendererFlushCallbackRpc = NullRpc<pb::RPC_R_FLUSH_CALLBACK>; |
+using RendererSetCdmCallbackRpc = SimpleRpc<bool, pb::RPC_R_SETCDM_CALLBACK>; |
+ |
+//============================================================================== |
+class RendererClientOnTimeUpdateRpc : public Rpc { |
+ public: |
+ RendererClientOnTimeUpdateRpc(int handle, |
+ int64_t time_usec, |
+ int64_t max_time_usec); |
+ |
+ static scoped_refptr<RendererClientOnTimeUpdateRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ int64_t time_usec() const { return time_usec_; } |
+ int64_t max_time_usec() const { return max_time_usec_; } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~RendererClientOnTimeUpdateRpc() override; |
+ int64_t time_usec_; |
+ int64_t max_time_usec_; |
+}; |
+ |
+//============================================================================== |
+using RendererClientOnBufferingStateChangeRpc = |
+ SimpleRpc<int, pb::RPC_RC_ONBUFFERINGSTATECHANGE>; |
+using RendererClientOnEndedRpc = NullRpc<pb::RPC_RC_ONENDED>; |
+using RendererClientOnErrorRpc = NullRpc<pb::RPC_RC_ONERROR>; |
+ |
+//============================================================================== |
+class RendererClientOnVideoNaturalSizeChangeRpc : public Rpc { |
+ public: |
+ RendererClientOnVideoNaturalSizeChangeRpc(int handle, const gfx::Size& size); |
+ |
+ static scoped_refptr<RendererClientOnVideoNaturalSizeChangeRpc> |
+ FromRpcMessage(const pb::RpcMessage* rpc); |
+ |
+ const gfx::Size& size() const { return size_; } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~RendererClientOnVideoNaturalSizeChangeRpc() override; |
+ gfx::Size size_; |
+}; |
+ |
+//============================================================================== |
+using RendererClientOnVideoOpacityChangeRpc = |
+ SimpleRpc<bool, pb::RPC_RC_ONVIDEOOPACITYCHANGE>; |
+using DemuxerStreamInitializeRpc = SimpleRpc<int, pb::RPC_DS_INITIALIZE>; |
+using DemuxerStreamEnableBitstreamConverterRpc = |
+ NullRpc<pb::RPC_DS_ENABLEBITSTREAMCONVERTER>; |
+ |
+//============================================================================== |
+class DemuxerStreamReadUntilRpc : public Rpc { |
+ public: |
+ DemuxerStreamReadUntilRpc(int handle, uint32_t frame_id, int callback_handle); |
+ |
+ static scoped_refptr<DemuxerStreamReadUntilRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ uint32_t frame_id() const { return frame_id_; } |
+ int callback_handle() const { return callback_handle_; } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~DemuxerStreamReadUntilRpc() override; |
+ uint32_t frame_id_; |
+ int callback_handle_; |
+}; |
+ |
+class DemuxerStreamInitializeCallbackRpc : public Rpc { |
+ public: |
+ DemuxerStreamInitializeCallbackRpc( |
+ int handle, |
+ ::media::DemuxerStream::Type type, |
+ const ::media::AudioDecoderConfig& audio_config, |
+ const ::media::VideoDecoderConfig& video_config); |
+ |
+ static scoped_refptr<DemuxerStreamInitializeCallbackRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ ::media::DemuxerStream::Type type() const { return type_; } |
+ const ::media::AudioDecoderConfig& audio_config() const { |
+ return audio_config_; |
+ } |
+ const ::media::VideoDecoderConfig& video_config() const { |
+ return video_config_; |
+ } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~DemuxerStreamInitializeCallbackRpc() override; |
+ ::media::DemuxerStream::Type type_; |
+ ::media::AudioDecoderConfig audio_config_; |
+ ::media::VideoDecoderConfig video_config_; |
+}; |
+ |
+class DemuxerStreamReadUntilCallbackRpc : public Rpc { |
+ public: |
+ DemuxerStreamReadUntilCallbackRpc( |
+ int handle, |
+ uint32_t frame_id, |
+ ::media::DemuxerStream::Status status, |
+ const ::media::AudioDecoderConfig& audio_config, |
+ const ::media::VideoDecoderConfig& video_config); |
+ |
+ static scoped_refptr<DemuxerStreamReadUntilCallbackRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ uint32_t frame_id() const { return frame_id_; } |
+ ::media::DemuxerStream::Status status() const { return status_; } |
+ |
+ const ::media::AudioDecoderConfig& audio_config() const { |
+ return audio_config_; |
+ } |
+ const ::media::VideoDecoderConfig& video_config() const { |
+ return video_config_; |
+ } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~DemuxerStreamReadUntilCallbackRpc() override; |
+ uint32_t frame_id_; |
+ ::media::DemuxerStream::Status status_; |
+ ::media::AudioDecoderConfig audio_config_; |
+ ::media::VideoDecoderConfig video_config_; |
+}; |
+ |
+typedef SimpleRpc<int, pb::RPC_CDM_SETCLIENT> CdmSetClientRpc; |
+ |
+class CdmInitializeRpc : public Rpc { |
+ public: |
+ CdmInitializeRpc(int handle, |
+ const std::string& key_system, |
+ const std::string& security_origin, |
+ const ::media::CdmConfig& cdm_config, |
+ int callback_handle); |
+ |
+ static scoped_refptr<CdmInitializeRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ const std::string& key_system() const { return key_system_; } |
+ const std::string& security_origin() const { return security_origin_; } |
+ const ::media::CdmConfig& cdm_config() const { return cdm_config_; } |
+ int callback_handle() const { return callback_handle_; } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~CdmInitializeRpc() override; |
+ std::string key_system_; |
+ std::string security_origin_; |
+ ::media::CdmConfig cdm_config_; |
+ int callback_handle_; |
+}; |
+ |
+class CdmSetServerCertificateRpc : public Rpc { |
+ public: |
+ CdmSetServerCertificateRpc(int handle, |
+ const uint8_t* certificate_data, |
+ size_t certificate_data_size, |
+ int callback_handle); |
+ |
+ static scoped_refptr<CdmSetServerCertificateRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ const uint8_t* certificate_data() const { |
+ return certificate_data_.empty() ? nullptr : certificate_data_.data(); |
+ } |
+ size_t certificate_data_size() const { return certificate_data_.size(); } |
+ int callback_handle() const { return callback_handle_; } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~CdmSetServerCertificateRpc() override; |
+ std::vector<uint8_t> certificate_data_; |
+ int callback_handle_; |
+}; |
+ |
+class CdmCreateSessionAndGenerateRequestRpc : public Rpc { |
+ public: |
+ 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); |
+ |
+ static scoped_refptr<CdmCreateSessionAndGenerateRequestRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ ::media::MediaKeys::SessionType session_type() const { return session_type_; } |
+ ::media::EmeInitDataType init_data_type() const { return init_data_type_; } |
+ const uint8_t* init_data() const { |
+ return init_data_.empty() ? nullptr : init_data_.data(); |
+ } |
+ size_t init_data_size() const { return init_data_.size(); } |
+ int callback_handle() const { return callback_handle_; } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~CdmCreateSessionAndGenerateRequestRpc() override; |
+ ::media::MediaKeys::SessionType session_type_; |
+ ::media::EmeInitDataType init_data_type_; |
+ std::vector<uint8_t> init_data_; |
+ int callback_handle_; |
+}; |
+ |
+class CdmLoadSessionRpc : public Rpc { |
+ public: |
+ CdmLoadSessionRpc(int handle, |
+ ::media::MediaKeys::SessionType session_type, |
+ const std::string& session_id, |
+ int callback_handle); |
+ |
+ static scoped_refptr<CdmLoadSessionRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ ::media::MediaKeys::SessionType session_type() const { return session_type_; } |
+ const std::string& session_id() const { return session_id_; } |
+ int callback_handle() const { return callback_handle_; } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~CdmLoadSessionRpc() override; |
+ ::media::MediaKeys::SessionType session_type_; |
+ std::string session_id_; |
+ int callback_handle_; |
+}; |
+ |
+class CdmUpdateSessionRpc : public Rpc { |
+ public: |
+ CdmUpdateSessionRpc(int handle, |
+ const std::string& session_id, |
+ const uint8_t* response, |
+ size_t response_size, |
+ int callback_handle); |
+ |
+ static scoped_refptr<CdmUpdateSessionRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ const std::string& session_id() const { return session_id_; } |
+ const uint8_t* response() const { |
+ return response_.empty() ? nullptr : response_.data(); |
+ } |
+ size_t response_size() const { return response_.size(); } |
+ int callback_handle() const { return callback_handle_; } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~CdmUpdateSessionRpc() override; |
+ std::string session_id_; |
+ std::vector<uint8_t> response_; |
+ int callback_handle_; |
+}; |
+ |
+class CdmCloseSessionRpc : public Rpc { |
+ public: |
+ CdmCloseSessionRpc(int handle, |
+ const std::string& session_id, |
+ int callback_handle); |
+ |
+ static scoped_refptr<CdmCloseSessionRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ const std::string& session_id() const { return session_id_; } |
+ int callback_handle() const { return callback_handle_; } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~CdmCloseSessionRpc() override; |
+ std::string session_id_; |
+ int callback_handle_; |
+}; |
+ |
+class CdmRemoveSessionRpc : public Rpc { |
+ public: |
+ CdmRemoveSessionRpc(int handle, |
+ const std::string& session_id, |
+ int callback_handle); |
+ |
+ static scoped_refptr<CdmRemoveSessionRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ const std::string& session_id() const { return session_id_; } |
+ int callback_handle() const { return callback_handle_; } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~CdmRemoveSessionRpc() override; |
+ std::string session_id_; |
+ int callback_handle_; |
+}; |
+ |
+class CdmPromiseResult { |
+ public: |
+ CdmPromiseResult(); |
+ CdmPromiseResult(::media::MediaKeys::Exception exception, |
+ uint32_t system_code, |
+ std::string error_message); |
+ CdmPromiseResult(const CdmPromiseResult& other); |
+ ~CdmPromiseResult(); |
+ |
+ static CdmPromiseResult SuccessResult(); |
+ |
+ bool success() const { return success_; } |
+ ::media::MediaKeys::Exception exception() const { return exception_; } |
+ uint32_t system_code() const { return system_code_; } |
+ const std::string& error_message() const { return error_message_; } |
+ |
+ private: |
+ bool success_; |
+ ::media::MediaKeys::Exception exception_; |
+ uint32_t system_code_; |
+ std::string error_message_; |
+}; |
+ |
+template <pb::RpcProc Proc> |
+class CdmPromiseCallbackRpc : public Rpc { |
+ public: |
+ CdmPromiseCallbackRpc(int handle, const CdmPromiseResult& result) |
+ : Rpc(handle), result_(result) {} |
+ |
+ static scoped_refptr<CdmPromiseCallbackRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc) { |
+ CdmPromiseResult result; |
+ DCHECK(rpc->has_cdm_promise_rpc()); |
+ const pb::CdmPromise promise_message = rpc->cdm_promise_rpc(); |
+ if (!internal::CdmPromiseFromMessage(promise_message, &result, nullptr)) |
+ return nullptr; |
+ return new CdmPromiseCallbackRpc(rpc->handle(), result); |
+ } |
+ |
+ const CdmPromiseResult& result() const { return result_; } |
+ |
+ pb::RpcProc GetProc() const override { return Proc; } |
+ |
+ protected: |
+ ~CdmPromiseCallbackRpc() = default; |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override { |
+ pb::CdmPromise* promise_message = rpc->mutable_cdm_promise_rpc(); |
+ internal::CdmPromiseToMessage(promise_message, result_, ""); |
+ } |
+ |
+ private: |
+ CdmPromiseResult result_; |
+}; |
+ |
+template <pb::RpcProc Proc> |
+class CdmPromiseWithSessionIdCallbackRpc : public CdmPromiseCallbackRpc<Proc> { |
+ public: |
+ CdmPromiseWithSessionIdCallbackRpc(int handle, |
+ const CdmPromiseResult& result, |
+ const std::string& session_id) |
+ : CdmPromiseCallbackRpc<Proc>(handle, result), session_id_(session_id) {} |
+ |
+ static scoped_refptr<CdmPromiseWithSessionIdCallbackRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc) { |
+ CdmPromiseResult result; |
+ std::string session_id; |
+ DCHECK(rpc->has_cdm_promise_rpc()); |
+ const pb::CdmPromise promise_message = rpc->cdm_promise_rpc(); |
+ if (!internal::CdmPromiseFromMessage(promise_message, &result, &session_id)) |
+ return nullptr; |
+ return new CdmPromiseWithSessionIdCallbackRpc(rpc->handle(), result, |
+ session_id); |
+ } |
+ |
+ const std::string& session_id() const { return session_id_; } |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override { |
+ pb::CdmPromise* promise_message = rpc->mutable_cdm_promise_rpc(); |
+ internal::CdmPromiseToMessage( |
+ promise_message, CdmPromiseCallbackRpc<Proc>::result(), session_id_); |
+ } |
+ |
+ private: |
+ ~CdmPromiseWithSessionIdCallbackRpc() = default; |
+ std::string session_id_; |
+}; |
+ |
+//============================================================================== |
+using CdmSetServerCertificateCallbackRpc = |
+ CdmPromiseCallbackRpc<pb::RPC_CDM_SETSERVERCERTIFICATE_CALLBACK>; |
+using CdmCreateSessionAndGenerateRequestCallbackRpc = |
+ CdmPromiseWithSessionIdCallbackRpc< |
+ pb::RPC_CDM_CREATESESSIONANDGENERATEREQUEST_CALLBACK>; |
+using CdmLoadSessionCallbackRpc = |
+ CdmPromiseWithSessionIdCallbackRpc<pb::RPC_CDM_LOADSESSION_CALLBACK>; |
+using CdmUpdateSessionCallbackRpc = |
+ CdmPromiseCallbackRpc<pb::RPC_CDM_UPDATESESSION_CALLBACK>; |
+using CdmCloseSessionCallbackRpc = |
+ CdmPromiseCallbackRpc<pb::RPC_CDM_CLOSESESSION_CALLBACK>; |
+using CdmRemoveSessionCallbackRpc = |
+ CdmPromiseCallbackRpc<pb::RPC_CDM_REMOVESESSION_CALLBACK>; |
+ |
+//============================================================================== |
+class CdmInitializeCallbackRpc |
+ : public CdmPromiseCallbackRpc<pb::RPC_CDM_INITIALIZE_CALLBACK> { |
+ public: |
+ CdmInitializeCallbackRpc(int handle, |
+ const CdmPromiseResult& result, |
+ int cdm_id, |
+ int decryptor_handle); |
+ |
+ static scoped_refptr<CdmInitializeCallbackRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ int cdm_id() const { return cdm_id_; } |
+ int decryptor_handle() const { return decryptor_handle_; } |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~CdmInitializeCallbackRpc() override; |
+ int cdm_id_; |
+ int decryptor_handle_; |
+}; |
+ |
+class CdmClientOnSessionMessageRpc : public Rpc { |
+ public: |
+ 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); |
+ |
+ static scoped_refptr<CdmClientOnSessionMessageRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ const std::string& session_id() const { return session_id_; } |
+ ::media::MediaKeys::MessageType message_type() const { return message_type_; } |
+ const uint8_t* message() const { |
+ return message_.empty() ? nullptr : message_.data(); |
+ } |
+ size_t message_size() const { return message_.size(); } |
+ const std::string& legacy_destination_url() const { |
+ return legacy_destination_url_; |
+ } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~CdmClientOnSessionMessageRpc() override; |
+ std::string session_id_; |
+ ::media::MediaKeys::MessageType message_type_; |
+ std::vector<uint8_t> message_; |
+ std::string legacy_destination_url_; |
+}; |
+ |
+//============================================================================== |
+using CdmClientOnSessionClosedRpc = |
+ SimpleRpc<std::string, pb::RPC_CDMC_ONSESSIONCLOSED>; |
+ |
+//============================================================================== |
+class CdmClientOnLegacySessionErrorRpc : public Rpc { |
+ public: |
+ CdmClientOnLegacySessionErrorRpc(int handle, |
+ const std::string& session_id, |
+ ::media::MediaKeys::Exception exception, |
+ uint32_t system_code, |
+ const std::string& error_message); |
+ |
+ static scoped_refptr<CdmClientOnLegacySessionErrorRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ const std::string& session_id() const { return session_id_; } |
+ ::media::MediaKeys::Exception exception() const { return exception_; } |
+ uint32_t system_code() const { return system_code_; } |
+ const std::string& error_message() const { return error_message_; } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~CdmClientOnLegacySessionErrorRpc() override; |
+ std::string session_id_; |
+ ::media::MediaKeys::Exception exception_; |
+ uint32_t system_code_; |
+ std::string error_message_; |
+}; |
+ |
+class CdmClientOnSessionKeysChangeRpc : public Rpc { |
+ public: |
+ CdmClientOnSessionKeysChangeRpc( |
+ int handle, |
+ const std::string& session_id, |
+ bool has_additional_usable_key, |
+ const ::media::CdmKeyInformation* key_information, |
+ size_t key_information_size); |
+ |
+ static scoped_refptr<CdmClientOnSessionKeysChangeRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ const std::string& session_id() const { return session_id_; } |
+ bool has_additional_usable_key() const { return has_additional_usable_key_; } |
+ const ::media::CdmKeyInformation* key_information() const { |
+ return key_information_.empty() ? nullptr : key_information_.data(); |
+ } |
+ size_t key_information_size() const { return key_information_.size(); } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~CdmClientOnSessionKeysChangeRpc() override; |
+ std::string session_id_; |
+ bool has_additional_usable_key_; |
+ std::vector<::media::CdmKeyInformation> key_information_; |
+}; |
+ |
+class CdmClientOnSessionExpirationUpdateRpc : public Rpc { |
+ public: |
+ CdmClientOnSessionExpirationUpdateRpc(int handle, |
+ const std::string& session_id, |
+ double new_expiry_time_sec); |
+ |
+ static scoped_refptr<CdmClientOnSessionExpirationUpdateRpc> FromRpcMessage( |
+ const pb::RpcMessage* rpc); |
+ |
+ const std::string& session_id() const { return session_id_; } |
+ double new_expiry_time_sec() const { return new_expiry_time_sec_; } |
+ |
+ pb::RpcProc GetProc() const override; |
+ |
+ protected: |
+ void ToMessageInternal(pb::RpcMessage* rpc) const override; |
+ |
+ private: |
+ ~CdmClientOnSessionExpirationUpdateRpc() override; |
+ std::string session_id_; |
+ double new_expiry_time_sec_; |
+}; |
+ |
+} // namespace remoting |
+} // namespace media |
+ |
+#endif // MEDIA_REMOTING_RPC_RPC_H_ |