Define remote playback proto buffer

media/remoting/rpc/rpc_unittest.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 <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "media/base/audio_decoder_config.h"
+#include "media/base/cdm_config.h"
+#include "media/base/cdm_key_information.h"
+#include "media/base/demuxer_stream.h"
+#include "media/base/eme_constants.h"
+#include "media/base/media_keys.h"
+#include "media/base/video_decoder_config.h"
+#include "media/remoting/remoting_rpc_message.pb.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::_;
+using testing::Invoke;
+using testing::Return;
+
+namespace media {
+namespace remoting {
+
+class RemotingRpcTest : public testing::Test {
+ protected:
+  void SetUp() override {}
+};
+
+TEST_F(RemotingRpcTest, GarbageInput) {
+  std::string proto_buffer_string("$%@#$@$%$&%^&^%*^&^&....");
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(!to_rpc);
+}
+
+// Test RPC message which has single integer message.
+TEST_F(RemotingRpcTest, AcquireRendererRpc) {
+  int rpc_handle = 3;
+
+  // Convert RPC data structure into proto buffer string
+  int value = 0;
+  scoped_refptr<Rpc> from_rpc(new AcquireRendererRpc(rpc_handle, value));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  AcquireRendererRpc* actual_to_rpc =
+      static_cast<AcquireRendererRpc*>(to_rpc.get());
+  ASSERT_EQ(value, actual_to_rpc->value());
+}
+
+// Test RPC message which has single double message.
+TEST_F(RemotingRpcTest, RendererSetPlaybackRateRpc) {
+  int rpc_handle = 3;
+
+  // Convert RPC data structure into proto buffer string
+  double value = 1.1;
+  scoped_refptr<Rpc> from_rpc(
+      new RendererSetPlaybackRateRpc(rpc_handle, value));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  RendererSetPlaybackRateRpc* actual_to_rpc =
+      static_cast<RendererSetPlaybackRateRpc*>(to_rpc.get());
+  ASSERT_EQ(value, actual_to_rpc->value());
+}
+
+// Test RPC message which has single boolean message.
+TEST_F(RemotingRpcTest, RendererInitializeCallbackRpc) {
+  int rpc_handle = 3;
+
+  // Convert RPC data structure into proto buffer string
+  bool value = true;
+  scoped_refptr<Rpc> from_rpc(
+      new RendererInitializeCallbackRpc(rpc_handle, value));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  RendererInitializeCallbackRpc* actual_to_rpc =
+      static_cast<RendererInitializeCallbackRpc*>(to_rpc.get());
+  ASSERT_EQ(value, actual_to_rpc->value());
+}
+
+// Test RPC message which has no additional message.
+TEST_F(RemotingRpcTest, RendererFlushCallbackRpc) {
+  int rpc_handle = 3;
+
+  // Convert RPC data structure into proto buffer string
+  scoped_refptr<Rpc> from_rpc(new RendererFlushCallbackRpc(rpc_handle));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+}
+
+// Following are the RPC message which have various data structure.
+TEST_F(RemotingRpcTest, RendererInitializeRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  int client_handle = 4;
+  int audio_demuxer_handle = 5;
+  int video_demuxer_handle = 6;
+  int callback_handle = 7;
+  scoped_refptr<Rpc> from_rpc(
+      new RendererInitializeRpc(rpc_handle, client_handle, audio_demuxer_handle,
+                                video_demuxer_handle, callback_handle));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  RendererInitializeRpc* actual_to_rpc =
+      static_cast<RendererInitializeRpc*>(to_rpc.get());
+  ASSERT_EQ(client_handle, actual_to_rpc->client_handle());
+  ASSERT_EQ(audio_demuxer_handle, actual_to_rpc->audio_demuxer_handle());
+  ASSERT_EQ(video_demuxer_handle, actual_to_rpc->video_demuxer_handle());
+  ASSERT_EQ(callback_handle, actual_to_rpc->callback_handle());
+}
+
+TEST_F(RemotingRpcTest, RendererSetCdmRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  int cdm_id = 2;
+  int callback_handle = 1;
+  scoped_refptr<Rpc> from_rpc(
+      new RendererSetCdmRpc(rpc_handle, cdm_id, callback_handle));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  RendererSetCdmRpc* actual_to_rpc =
+      static_cast<RendererSetCdmRpc*>(to_rpc.get());
+  ASSERT_EQ(cdm_id, actual_to_rpc->cdm_id());
+  ASSERT_EQ(callback_handle, actual_to_rpc->callback_handle());
+}
+
+TEST_F(RemotingRpcTest, RendererClientOnTimeUpdateRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  int time_usec = 2;
+  int max_time_usec = 1;
+  scoped_refptr<Rpc> from_rpc(
+      new RendererClientOnTimeUpdateRpc(rpc_handle, time_usec, max_time_usec));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  RendererClientOnTimeUpdateRpc* actual_to_rpc =
+      static_cast<RendererClientOnTimeUpdateRpc*>(to_rpc.get());
+  ASSERT_EQ(time_usec, actual_to_rpc->time_usec());
+  ASSERT_EQ(max_time_usec, actual_to_rpc->max_time_usec());
+}
+
+TEST_F(RemotingRpcTest, RendererClientOnVideoNaturalSizeChangeRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  gfx::Size size(640, 480);
+  scoped_refptr<Rpc> from_rpc(
+      new RendererClientOnVideoNaturalSizeChangeRpc(rpc_handle, size));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  RendererClientOnVideoNaturalSizeChangeRpc* actual_to_rpc =
+      static_cast<RendererClientOnVideoNaturalSizeChangeRpc*>(to_rpc.get());
+  ASSERT_EQ(size, actual_to_rpc->size());
+}
+
+TEST_F(RemotingRpcTest, DemuxerStreamReadUntilRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  uint32_t frame_id = 2;
+  int callback_handle = 1;
+  scoped_refptr<Rpc> from_rpc(
+      new DemuxerStreamReadUntilRpc(rpc_handle, frame_id, callback_handle));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  DemuxerStreamReadUntilRpc* actual_to_rpc =
+      static_cast<DemuxerStreamReadUntilRpc*>(to_rpc.get());
+  ASSERT_EQ(frame_id, actual_to_rpc->frame_id());
+  ASSERT_EQ(callback_handle, actual_to_rpc->callback_handle());
+}
+
+TEST_F(RemotingRpcTest, DemuxerStreamInitializeCallbackRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  ::media::DemuxerStream::Type type = ::media::DemuxerStream::VIDEO;
+  ::media::AudioDecoderConfig audio_config;
+  ::media::VideoDecoderConfig video_config;
+  scoped_refptr<Rpc> from_rpc(new DemuxerStreamInitializeCallbackRpc(
+      rpc_handle, type, audio_config, video_config));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  DemuxerStreamInitializeCallbackRpc* actual_to_rpc =
+      static_cast<DemuxerStreamInitializeCallbackRpc*>(to_rpc.get());
+  ASSERT_EQ(type, actual_to_rpc->type());
+  // TODO(erickung) compare |audio_config| and |video_config|;
+}
+
+TEST_F(RemotingRpcTest, DemuxerStreamReadUntilCallbackRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  uint32_t frame_id = 100;
+  ::media::DemuxerStream::Status status = ::media::DemuxerStream::kOk;
+  ::media::AudioDecoderConfig audio_config;
+  ::media::VideoDecoderConfig video_config;
+  scoped_refptr<Rpc> from_rpc(new DemuxerStreamReadUntilCallbackRpc(
+      rpc_handle, frame_id, status, audio_config, video_config));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  DemuxerStreamReadUntilCallbackRpc* actual_to_rpc =
+      static_cast<DemuxerStreamReadUntilCallbackRpc*>(to_rpc.get());
+  ASSERT_EQ(frame_id, actual_to_rpc->frame_id());
+  ASSERT_EQ(status, actual_to_rpc->status());
+  // TODO(erickung) compare |audio_config| and |video_config|;
+}
+
+TEST_F(RemotingRpcTest, CdmInitializeRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  std::string key_system;
+  std::string security_origin;
+  ::media::CdmConfig cdm_config;
+  cdm_config.allow_distinctive_identifier = true;
+  cdm_config.allow_persistent_state = false;
+  cdm_config.use_hw_secure_codecs = true;
+  int callback_handle = 4;
+  scoped_refptr<Rpc> from_rpc(new CdmInitializeRpc(
+      rpc_handle, key_system, security_origin, cdm_config, callback_handle));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  CdmInitializeRpc* actual_to_rpc =
+      static_cast<CdmInitializeRpc*>(to_rpc.get());
+  ASSERT_EQ(key_system, actual_to_rpc->key_system());
+  ASSERT_EQ(security_origin, actual_to_rpc->security_origin());
+  ::media::CdmConfig cdm_config_out = actual_to_rpc->cdm_config();
+  ASSERT_EQ(cdm_config.allow_distinctive_identifier,
+            cdm_config_out.allow_distinctive_identifier);
+  ASSERT_EQ(cdm_config.allow_persistent_state,
+            cdm_config_out.allow_persistent_state);
+  ASSERT_EQ(cdm_config.use_hw_secure_codecs,
+            cdm_config_out.use_hw_secure_codecs);
+  ASSERT_EQ(callback_handle, actual_to_rpc->callback_handle());
+}
+
+TEST_F(RemotingRpcTest, CdmSetServerCertificateRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  std::string data_blob("HereIsTestBlob");
+  std::vector<uint8_t> certificate_data(data_blob.begin(), data_blob.end());
+  int callback_handle = 4;
+  scoped_refptr<Rpc> from_rpc(
+      new CdmSetServerCertificateRpc(rpc_handle, &certificate_data[0],
+                                     certificate_data.size(), callback_handle));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  CdmSetServerCertificateRpc* actual_to_rpc =
+      static_cast<CdmSetServerCertificateRpc*>(to_rpc.get());
+  ASSERT_EQ(certificate_data.size(), actual_to_rpc->certificate_data_size());
+  std::string data_out_blob(actual_to_rpc->certificate_data(),
+                            actual_to_rpc->certificate_data() +
+                                actual_to_rpc->certificate_data_size());
+  ASSERT_EQ(data_blob, data_out_blob);
+  ASSERT_EQ(callback_handle, actual_to_rpc->callback_handle());
+}
+
+TEST_F(RemotingRpcTest, CdmCreateSessionAndGenerateRequestRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  ::media::MediaKeys::SessionType session_type =
+      ::media::MediaKeys::TEMPORARY_SESSION;
+  ::media::EmeInitDataType init_data_type = ::media::EmeInitDataType::CENC;
+  std::string data_blob("Arbitrary##Data@@@");
+  std::vector<uint8_t> init_data(data_blob.begin(), data_blob.end());
+  int callback_handle = 4;
+  scoped_refptr<Rpc> from_rpc(new CdmCreateSessionAndGenerateRequestRpc(
+      rpc_handle, session_type, init_data_type, &init_data[0], init_data.size(),
+      callback_handle));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  CdmCreateSessionAndGenerateRequestRpc* actual_to_rpc =
+      static_cast<CdmCreateSessionAndGenerateRequestRpc*>(to_rpc.get());
+  ASSERT_EQ(session_type, actual_to_rpc->session_type());
+  ASSERT_EQ(init_data_type, actual_to_rpc->init_data_type());
+  ASSERT_EQ(init_data.size(), actual_to_rpc->init_data_size());
+  std::string data_out_blob(
+      actual_to_rpc->init_data(),
+      actual_to_rpc->init_data() + actual_to_rpc->init_data_size());
+  ASSERT_EQ(data_blob, data_out_blob);
+  ASSERT_EQ(callback_handle, actual_to_rpc->callback_handle());
+}
+
+TEST_F(RemotingRpcTest, CdmUpdateSessionRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  std::string session_id;
+  std::string data_blob("___!!AS#HGSTU");
+  std::vector<uint8_t> response(data_blob.begin(), data_blob.end());
+  int callback_handle = 4;
+  scoped_refptr<Rpc> from_rpc(new CdmUpdateSessionRpc(
+      rpc_handle, session_id, &response[0], response.size(), callback_handle));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  CdmUpdateSessionRpc* actual_to_rpc =
+      static_cast<CdmUpdateSessionRpc*>(to_rpc.get());
+  ASSERT_EQ(session_id, actual_to_rpc->session_id());
+  ASSERT_EQ(response.size(), actual_to_rpc->response_size());
+  std::string data_out_blob(
+      actual_to_rpc->response(),
+      actual_to_rpc->response() + actual_to_rpc->response_size());
+  ASSERT_EQ(data_blob, data_out_blob);
+  ASSERT_EQ(callback_handle, actual_to_rpc->callback_handle());
+}
+
+TEST_F(RemotingRpcTest, CdmSetServerCertificateCallbackRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  bool success = false;
+  CdmPromiseResult result(::media::MediaKeys::UNKNOWN_ERROR, 3, "");
+  scoped_refptr<Rpc> from_rpc(
+      new CdmSetServerCertificateCallbackRpc(rpc_handle, result));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  CdmSetServerCertificateCallbackRpc* actual_to_rpc =
+      static_cast<CdmSetServerCertificateCallbackRpc*>(to_rpc.get());
+  const CdmPromiseResult result_out = actual_to_rpc->result();
+  ASSERT_EQ(success, result_out.success());
+  ASSERT_EQ(result.exception(), result_out.exception());
+  ASSERT_EQ(result.system_code(), result_out.system_code());
+  ASSERT_EQ(result.error_message(), result_out.error_message());
+}
+
+TEST_F(RemotingRpcTest, CdmCreateSessionAndGenerateRequestCallbackRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  bool success = true;
+  std::string session_id;
+  CdmPromiseResult result(CdmPromiseResult::SuccessResult());
+  scoped_refptr<Rpc> from_rpc(new CdmCreateSessionAndGenerateRequestCallbackRpc(
+      rpc_handle, result, session_id));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  CdmCreateSessionAndGenerateRequestCallbackRpc* actual_to_rpc =
+      static_cast<CdmCreateSessionAndGenerateRequestCallbackRpc*>(to_rpc.get());
+  const CdmPromiseResult result_out = actual_to_rpc->result();
+  ASSERT_EQ(success, result_out.success());
+  ASSERT_EQ(session_id, actual_to_rpc->session_id());
+}
+
+TEST_F(RemotingRpcTest, CdmInitializeCallbackRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  bool success = true;
+  CdmPromiseResult result(CdmPromiseResult::SuccessResult());
+  int cdm_id = 4;
+  int decryptor_handle = 5;
+  scoped_refptr<Rpc> from_rpc(new CdmInitializeCallbackRpc(
+      rpc_handle, result, cdm_id, decryptor_handle));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  CdmInitializeCallbackRpc* actual_to_rpc =
+      static_cast<CdmInitializeCallbackRpc*>(to_rpc.get());
+  const CdmPromiseResult result_out = actual_to_rpc->result();
+  ASSERT_EQ(success, result_out.success());
+  ASSERT_EQ(cdm_id, actual_to_rpc->cdm_id());
+  ASSERT_EQ(decryptor_handle, actual_to_rpc->decryptor_handle());
+}
+
+TEST_F(RemotingRpcTest, CdmClientOnSessionMessageRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  std::string session_id;
+  ::media::MediaKeys::MessageType message_type =
+      ::media::MediaKeys::LICENSE_RELEASE;
+  std::string legacy_destination_url;
+  uint8_t message[1] = {0xAB};
+  scoped_refptr<Rpc> from_rpc(new CdmClientOnSessionMessageRpc(
+      rpc_handle, session_id, message_type, message, sizeof(message),
+      legacy_destination_url));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  CdmClientOnSessionMessageRpc* actual_to_rpc =
+      static_cast<CdmClientOnSessionMessageRpc*>(to_rpc.get());
+  ASSERT_EQ(session_id, actual_to_rpc->session_id());
+  ASSERT_EQ(message_type, actual_to_rpc->message_type());
+  ASSERT_EQ(message[0], actual_to_rpc->message()[0]);
+  ASSERT_EQ(size_t(1), actual_to_rpc->message_size());
+  ASSERT_EQ(legacy_destination_url, actual_to_rpc->legacy_destination_url());
+}
+
+TEST_F(RemotingRpcTest, CdmClientOnLegacySessionErrorRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  std::string session_id;
+  ::media::MediaKeys::Exception exception = ::media::MediaKeys::UNKNOWN_ERROR;
+  uint32_t system_code = 23;
+  std::string error_message;
+  scoped_refptr<Rpc> from_rpc(new CdmClientOnLegacySessionErrorRpc(
+      rpc_handle, session_id, exception, system_code, error_message));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  CdmClientOnLegacySessionErrorRpc* actual_to_rpc =
+      static_cast<CdmClientOnLegacySessionErrorRpc*>(to_rpc.get());
+  ASSERT_EQ(session_id, actual_to_rpc->session_id());
+  ASSERT_EQ(exception, actual_to_rpc->exception());
+  ASSERT_EQ(system_code, actual_to_rpc->system_code());
+  ASSERT_EQ(error_message, actual_to_rpc->error_message());
+}
+
+TEST_F(RemotingRpcTest, CdmClientOnSessionKeysChangeRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  std::string session_id;
+  bool has_additional_usable_key = false;
+  scoped_refptr<Rpc> from_rpc(new CdmClientOnSessionKeysChangeRpc(
+      rpc_handle, session_id, has_additional_usable_key, nullptr, 0));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  CdmClientOnSessionKeysChangeRpc* actual_to_rpc =
+      static_cast<CdmClientOnSessionKeysChangeRpc*>(to_rpc.get());
+  ASSERT_EQ(session_id, actual_to_rpc->session_id());
+  ASSERT_EQ(has_additional_usable_key,
+            actual_to_rpc->has_additional_usable_key());
+  ASSERT_EQ(nullptr, actual_to_rpc->key_information());
+  ASSERT_EQ(static_cast<size_t>(0), actual_to_rpc->key_information_size());
+}
+
+TEST_F(RemotingRpcTest, CdmClientOnSessionExpirationUpdateRpc) {
+  // Convert RPC data structure into proto buffer string
+  int rpc_handle = 3;
+  std::string session_id;
+  double new_expiry_time_sec = 3600.2;
+  scoped_refptr<Rpc> from_rpc(new CdmClientOnSessionExpirationUpdateRpc(
+      rpc_handle, session_id, new_expiry_time_sec));
+  ASSERT_EQ(rpc_handle, from_rpc->handle());
+  int proc = from_rpc->GetProc();
+  std::string proto_buffer_string = from_rpc->ToMessage();
+
+  // Convert proto buffer string back to RPC data structure.
+  scoped_refptr<remoting::Rpc> to_rpc = Rpc::FromMessage(proto_buffer_string);
+  DCHECK(to_rpc);
+  ASSERT_EQ(proc, to_rpc->GetProc());
+  ASSERT_EQ(rpc_handle, to_rpc->handle());
+
+  CdmClientOnSessionExpirationUpdateRpc* actual_to_rpc =
+      static_cast<CdmClientOnSessionExpirationUpdateRpc*>(to_rpc.get());
+  ASSERT_EQ(session_id, actual_to_rpc->session_id());
+  ASSERT_EQ(new_expiry_time_sec, actual_to_rpc->new_expiry_time_sec());
+}
+
+}  // namespace remoting
+}  // namespace media