Define remote playback proto buffer

media/remoting/rpc/rpc.cc

+// 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_FLUSHUNTIL), RendererFlushUntilRpc);
+    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_FLUSHUNTIL_CALLBACK), RendererFlushUntilCallbackRpc);
+    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_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_);
+}
+
+//==============================================================================
+RendererFlushUntilRpc::RendererFlushUntilRpc(int handle,
+                                             uint32_t audio_frame_id,
+                                             uint32_t video_frame_id,
+                                             int callback_handle)
+    : Rpc(handle),
+      audio_frame_id_(audio_frame_id),
+      video_frame_id_(video_frame_id),
+      callback_handle_(callback_handle) {}
+
+RendererFlushUntilRpc::~RendererFlushUntilRpc() = default;
+
+scoped_refptr<RendererFlushUntilRpc> RendererFlushUntilRpc::FromRpcMessage(
+    const pb::RpcMessage* rpc) {
+  DCHECK_EQ(RPC(RPC_R_FLUSHUNTIL), rpc->proc());
+
+  uint32_t audio_frame_id = 0;
+  uint32_t video_frame_id = 0;
+  int callback_handle = kInvalidHandle;
+
+  DCHECK(rpc->has_renderer_flushuntil_rpc());
+  audio_frame_id = rpc->renderer_flushuntil_rpc().audio_frame_id();
+  video_frame_id = rpc->renderer_flushuntil_rpc().video_frame_id();
+  callback_handle = rpc->renderer_flushuntil_rpc().callback_handle();
+
+  VLOG(2) << "audio_frame_id:" << audio_frame_id
+          << " video_frame_id:" << video_frame_id
+          << " callback_handle:" << callback_handle;
+  return new RendererFlushUntilRpc(rpc->handle(), audio_frame_id,
+                                   video_frame_id, callback_handle);
+}
+
+pb::RpcProc RendererFlushUntilRpc::GetProc() const {
+  return RPC(RPC_R_FLUSHUNTIL);
+}
+
+void RendererFlushUntilRpc::ToMessageInternal(pb::RpcMessage* rpc) const {
+  VLOG(2) << __FUNCTION__ << "audio_frame_id:" << audio_frame_id_
+          << " video_frame_id:" << video_frame_id_
+          << " callback_handle:" << callback_handle_;
+  pb::RendererFlushUntil* message = rpc->mutable_renderer_flushuntil_rpc();
+  message->set_audio_frame_id(audio_frame_id_);
+  message->set_video_frame_id(video_frame_id_);
+  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)
+    : Rpc(handle),
+      session_id_(session_id),
+      message_type_(message_type),
+      message_(message, message + message_size) {}
+
+CdmClientOnSessionMessageRpc::~CdmClientOnSessionMessageRpc() = default;
+
+scoped_refptr<CdmClientOnSessionMessageRpc>
+CdmClientOnSessionMessageRpc::FromRpcMessage(const pb::RpcMessage* rpc) {
+  DCHECK_EQ(RPC(RPC_CDMC_ONSESSIONMESSAGE), rpc->proc());
+
+  REQUIRED(rpc->has_cdmclient_onsessionmessage_rpc());
+  const pb::CdmClientOnSessionMessage onsession_message =
+      rpc->cdmclient_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::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());
+}
+
+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_;
+
+  pb::CdmClientOnSessionMessage* message =
+      rpc->mutable_cdmclient_onsessionmessage_rpc();
+  message->set_session_id(session_id_);
+  message->set_message_type(
+      static_cast<pb::MediaKeysMessageType>(message_type_));
+  message->set_message(&message_[0], message_.size());
+}
+
+//==============================================================================
+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_cdmclient_onsessionkeychange_rpc());
+  const pb::CdmClientOnSessionKeysChange keychange_message =
+      rpc->cdmclient_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_cdmclient_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_cdmclient_onsessionexpirationupdate_rpc());
+  const pb::CdmClientOnSessionExpirationUpdate expire_message =
+      rpc->cdmclient_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_cdmclient_onsessionexpirationupdate_rpc();
+  message->set_session_id(session_id_);
+  message->set_new_expiry_time_sec(new_expiry_time_sec_);
+}
+
+#undef REQUIRED
+
+}  // namespace remoting
+}  // namespace media