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

[miu, 2016/09/08 01:07:35]

IMHO, you shouldn't do this. I was not able to immediately understand what this
macro was doing in the code later in the file. It would have been much more
obvious to understand pb::RPC_FOO_BAR_BAZ instead of RPC(RPC_FOO_BAR_BAZ).

[erickung1, 2016/09/15 02:13:32]

Done.

+
+#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())

[miu, 2016/09/08 01:07:35]

Throughout this file: The default value for integer-typed optional fields is
zero, and optional string-typed fields are empty strings. So, a lot of these
has_xxx() checks are just extra code that does nothing.

Also, IIRC, the "getters" for protobuf messages are simple and in-lined, so
there's no need to copy them into local variables first.

Putting it all together, for example, the code here could be more simply:

  REQUIRED(message.encrypt_blocks() >= 0);
  REQUIRED(message.skip_blocks() >= 0);

  pattern = EncryptionScheme::Pattern(message.encrypt_blocks(),
message.skip_blocks());

[erickung1, 2016/09/15 02:13:32]

Done.

+    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;

[miu, 2016/09/08 01:07:34]

General comment: Seems like a lot of these "converter" functions could be
simplified by eliminating all the local variables and just passing the
mapped/type-casted values directly to the media::XXXConfig::Initialize() method.
 For example, this whole function could be:

... {
  DCHECK(audio_config);

  audio_config->Initialize(
      static_cast<::media::AudioCodec>(audio_message.codec()),
      static_cast<::media::SampleFormat>(audio_message.sample_format()),
      static_cast<::media::ChannelLayout>(audio_message.channel_layout()),
      audio_message.samples_per_second(),
      audio_message.extra_data(),
      DeserializeEncryptionScheme(audio_message.encryption_scheme()),
      base::TimeDelta::FromMicroseconds(audio_message.seek_preroll_usec()),
      audio_message.codec_delay());
  return audio_config->IsValidConfig();
}

[erickung1, 2016/09/15 02:13:32]

Done.

+  ::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;

[miu, 2016/09/08 01:07:34]

Suggest returning audio_config->IsValidConfig() here instead, and in
DeserializeVideoConfig().

[erickung1, 2016/09/15 02:13:32]

Done.

+}
+
+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,

[miu, 2016/09/08 01:07:35]

General comment: Please make sure you validate the values that have been parsed,
and return false when they are illegal in these converter functions. For
example, this function always returns true (or if all possible field values are
legal, maybe it should have a void return type instead?).

[erickung1, 2016/09/15 02:13:32]

Done.

+                                 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;

[miu, 2016/09/08 01:07:35]

nit: When populating vectors where you know their final size beforehand, please
call std::vector::reserve(). (Please check that you are doing this throughout
your change.)

[erickung1, 2016/09/15 02:13:32]

Done. the latest CL doesn't have such usage after the refactoring.

+
+  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,

[miu, 2016/09/08 01:07:35]

style: Input arguments, then output arguments.

[miu, 2016/09/13 05:40:57]

Doesn't look like this was addressed in the latest patch set.

[erickung1, 2016/09/15 02:13:32]

Done.

[erickung1, 2016/09/15 02:13:32]

Done.

+    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) {

[miu, 2016/09/08 01:07:35]

here too: Input arguments, then output arguments.

[erickung1, 2016/09/15 02:13:32]

Done.

+  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],

[miu, 2016/09/08 01:07:35]

nit: In C++11 code, you can now use config.extra_data().data() instead of
&config.extra_data()[0]. This seems to appear in a lot of places in this change,
so please search-and-replace throughout all the files.

[erickung1, 2016/09/15 02:13:32]

Done.

+                                         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());

[miu, 2016/09/08 01:07:35]

Looks like this DictionaryValue is unused. Can you remove it?

[erickung1, 2016/09/15 02:13:32]

Done.

+
+  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_RC_ONSTATISTICSUPDATE), RendererClientOnStatisticsUpdateRpc);
+    CASE(RPC(RPC_RC_ONWAITINGFORDECRYPTIONKEY),
+         RendererClientOnWaitingForDecryptionKeyRpc);
+    CASE(RPC(RPC_RC_ONDURATIONCHANGE), RendererClientOnDurationChangeRpc);
+    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_);
+}
+
+//==============================================================================
+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);
+}
+
+//==============================================================================
+RendererClientOnStatisticsUpdateRpc::RendererClientOnStatisticsUpdateRpc(
+    int handle,
+    const ::media::PipelineStatistics& stats)
+    : Rpc(handle), stats_(stats) {}
+
+RendererClientOnStatisticsUpdateRpc::~RendererClientOnStatisticsUpdateRpc() =
+    default;
+
+scoped_refptr<RendererClientOnStatisticsUpdateRpc>
+RendererClientOnStatisticsUpdateRpc::FromRpcMessage(const pb::RpcMessage* rpc) {
+  DCHECK_EQ(RPC(RPC_RC_ONSTATISTICSUPDATE), rpc->proc());
+
+  REQUIRED(rpc->has_rendererclient_onstatisticsupdate_rpc());
+  const pb::PipelineStatistics& rpc_message =
+      rpc->rendererclient_onstatisticsupdate_rpc();
+  ::media::PipelineStatistics stats;
+  stats.audio_bytes_decoded = rpc_message.audio_bytes_decoded();
+  stats.video_bytes_decoded = rpc_message.video_bytes_decoded();
+  stats.video_frames_decoded = rpc_message.video_frames_decoded();
+  stats.video_frames_dropped = rpc_message.video_frames_dropped();
+  stats.audio_memory_usage = rpc_message.audio_memory_usage();
+  stats.video_memory_usage = rpc_message.video_memory_usage();
+
+  VLOG(2) << "audio_bytes_decoded:" << stats.audio_bytes_decoded
+          << " video_bytes_decoded:" << stats.video_bytes_decoded
+          << " video_frames_decoded:" << stats.video_frames_decoded
+          << " video_frames_dropped:" << stats.video_frames_dropped
+          << " audio_memory_usage:" << stats.audio_memory_usage
+          << " video_memory_usage:" << stats.video_memory_usage;
+  return new RendererClientOnStatisticsUpdateRpc(rpc->handle(), stats);
+}
+
+pb::RpcProc RendererClientOnStatisticsUpdateRpc::GetProc() const {
+  return RPC(RPC_RC_ONSTATISTICSUPDATE);
+}
+
+void RendererClientOnStatisticsUpdateRpc::ToMessageInternal(
+    pb::RpcMessage* rpc) const {
+  VLOG(2) << __FUNCTION__
+          << " audio_bytes_decoded:" << stats_.audio_bytes_decoded
+          << " video_bytes_decoded:" << stats_.video_bytes_decoded
+          << " video_frames_decoded:" << stats_.video_frames_decoded
+          << " video_frames_dropped:" << stats_.video_frames_dropped
+          << " audio_memory_usage:" << stats_.audio_memory_usage
+          << " video_memory_usage:" << stats_.video_memory_usage;
+  pb::PipelineStatistics* message =
+      rpc->mutable_rendererclient_onstatisticsupdate_rpc();
+  message->set_audio_bytes_decoded(stats_.audio_bytes_decoded);
+  message->set_video_bytes_decoded(stats_.video_bytes_decoded);
+  message->set_video_frames_decoded(stats_.video_frames_decoded);
+  message->set_video_frames_dropped(stats_.video_frames_dropped);
+  message->set_audio_memory_usage(stats_.audio_memory_usage);
+  message->set_video_memory_usage(stats_.video_memory_usage);
+}
+
+//==============================================================================
+//==============================================================================
+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