Media Remoting: Add unittests for RPC converters.

media/remoting/proto_utils_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/proto_utils.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/content_decryption_module.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/eme_constants.h"
+#include "media/base/test_helpers.h"
 #include "media/base/video_decoder_config.h"
 #include "media/remoting/rpc.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 {
+namespace {
+
+void VerifyCdmPromiseResultsEqual(const CdmPromiseResult& cdm1,
+                                  const CdmPromiseResult& cdm2) {
+  ASSERT_EQ(cdm1.success(), cdm2.success());
+  ASSERT_EQ(cdm1.exception(), cdm2.exception());
+  ASSERT_EQ(cdm1.system_code(), cdm2.system_code());
+  ASSERT_EQ(cdm1.error_message(), cdm2.error_message());
+}
+
+}  // namespace
 
 class ProtoUtilsTest : public testing::Test {
  protected:
   void SetUp() override {}
 };
 
 TEST_F(ProtoUtilsTest, PassEOSDecoderBuffer) {
   // 1. To DecoderBuffer
   scoped_refptr<DecoderBuffer> input_buffer = DecoderBuffer::CreateEOSBuffer();
 
@@ skipping 100 matching lines @@
 
   PipelineStatistics converted;
   memset(&converted, ~0xcd, sizeof(converted));  // See note above.
   ConvertProtoToPipelineStatistics(pb_stats, &converted);
 
   // If this fails, did media::PipelineStatistics add/change fields that are not
   // being set by media::remoting::ConvertProtoToPipelineStatistics()?
   EXPECT_EQ(0, memcmp(&original, &converted, sizeof(converted)));
 }
 
-// TODO(miu): Tests for all other conversion functions.
+TEST_F(ProtoUtilsTest, VideoDecoderConfigConversionTest) {
+  const VideoDecoderConfig video_config = TestVideoConfig::Normal();
+  ASSERT_TRUE(video_config.IsValidConfig());
+  pb::VideoDecoderConfig message;
+  ConvertVideoDecoderConfigToProto(video_config, &message);
+  VideoDecoderConfig converted;
+  ASSERT_TRUE(ConvertProtoToVideoDecoderConfig(message, &converted));
+  ASSERT_TRUE(converted.Matches(video_config));
+}
 
 TEST_F(ProtoUtilsTest, CdmPromiseResultConversion) {
   CdmPromiseResult success_result = CdmPromiseResult::SuccessResult();
 
   pb::CdmPromise promise_message;
   ConvertCdmPromiseToProto(success_result, &promise_message);
 
   CdmPromiseResult output_result;
   ASSERT_TRUE(ConvertProtoToCdmPromise(promise_message, &output_result));
 
-  ASSERT_EQ(success_result.success(), output_result.success());
-  ASSERT_EQ(success_result.exception(), output_result.exception());
-  ASSERT_EQ(success_result.system_code(), output_result.system_code());
-  ASSERT_EQ(success_result.error_message(), output_result.error_message());
+  VerifyCdmPromiseResultsEqual(success_result, output_result);
+}
+
+TEST_F(ProtoUtilsTest, CdmPromiseResultWithCdmIdSessionIdConversion) {
+  const int kCdmId = 5;
+  const std::string kSessionId = "session3";
+  CdmPromiseResult success_result = CdmPromiseResult::SuccessResult();
+
+  pb::RpcMessage rpc;
+  rpc.set_handle(1);
+  pb::CdmPromise* promise_message = rpc.mutable_cdm_promise_rpc();
+
+  ConvertCdmPromiseWithSessionIdToProto(success_result, kSessionId,
+                                        promise_message);
+  CdmPromiseResult output_result;
+  std::string converted_session_id;
+  ASSERT_TRUE(ConvertProtoToCdmPromiseWithCdmIdSessionId(
+      rpc, &output_result, nullptr, &converted_session_id));
+  VerifyCdmPromiseResultsEqual(success_result, output_result);
+  ASSERT_EQ(converted_session_id, kSessionId);
+
+  ConvertCdmPromiseWithCdmIdToProto(success_result, kCdmId, promise_message);

[miu, 2017/01/25 23:53:34]

Before calling the second converter, reset the |output_result|:

  output_result = CdmPromiseResult();

That way, if there are some fields the second converter function doesn't
populate, we will detect that.

[xjz, 2017/01/26 00:03:31]

Done.

+  int converted_cdm_id;
+  ASSERT_TRUE(ConvertProtoToCdmPromiseWithCdmIdSessionId(
+      rpc, &output_result, &converted_cdm_id, nullptr));
+  VerifyCdmPromiseResultsEqual(success_result, output_result);
+  ASSERT_EQ(converted_cdm_id, kCdmId);
 }
 
 TEST_F(ProtoUtilsTest, CdmKeyInformationConversion) {
   std::unique_ptr<CdmKeyInformation> cdm_key_info_1(new CdmKeyInformation(
       "key_1", CdmKeyInformation::OUTPUT_RESTRICTED, 100));
   std::unique_ptr<CdmKeyInformation> cdm_key_info_2(
       new CdmKeyInformation("key_2", CdmKeyInformation::EXPIRED, 11));
   std::unique_ptr<CdmKeyInformation> cdm_key_info_3(
       new CdmKeyInformation("key_3", CdmKeyInformation::RELEASED, 22));
   CdmKeysInfo keys_information;
@@ skipping 11 matching lines @@
   for (uint32_t i = 0; i < 3; i++) {
     ASSERT_EQ(keys_information[i]->key_id, key_output_information[i]->key_id);
     ASSERT_EQ(keys_information[i]->status, key_output_information[i]->status);
     ASSERT_EQ(keys_information[i]->system_code,
               key_output_information[i]->system_code);
   }
 }
 
 }  // namespace remoting
 }  // namespace media