Media Remoting Clean-up: Less-redundant naming, style consistency, etc.

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/rpc/proto_utils.h"
+#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/video_decoder_config.h"
-#include "media/remoting/remoting_rpc_message.pb.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 {
 
 class ProtoUtilsTest : public testing::Test {
  protected:
   void SetUp() override {}
 };
 
 TEST_F(ProtoUtilsTest, PassEOSDecoderBuffer) {
   // 1. To DecoderBuffer
-  scoped_refptr<::media::DecoderBuffer> input_buffer =
-      ::media::DecoderBuffer::CreateEOSBuffer();
+  scoped_refptr<DecoderBuffer> input_buffer = DecoderBuffer::CreateEOSBuffer();
 
   // 2. To Byte Array
-  std::vector<uint8_t> data = DecoderBufferToByteArray(input_buffer);
+  std::vector<uint8_t> data = DecoderBufferToByteArray(*input_buffer);
 
   // 3. To DecoderBuffer
-  scoped_refptr<::media::DecoderBuffer> output_buffer =
+  scoped_refptr<DecoderBuffer> output_buffer =
       ByteArrayToDecoderBuffer(data.data(), data.size());
   DCHECK(output_buffer);
 
   ASSERT_TRUE(output_buffer->end_of_stream());
 }
 
 TEST_F(ProtoUtilsTest, PassValidDecoderBuffer) {
   const uint8_t buffer[] = {
       0,   0,   0,   1,   9,   224, 0,   0,   0,   1,   103, 77,  64,  21,  217,
       1,   177, 254, 78,  16,  0,   0,   62,  144, 0,   11,  184, 0,   241, 98,
       228, 128, 0,   0,   0,   1,   104, 235, 143, 32,  0,   0,   0,   1,   103,
       77,  64,  21,  217, 1,   177, 254, 78,  16,  0,   0,   62,  144, 0,   11,
       184, 0,   241, 98,  228, 128, 0,   0,   0,   1,   104, 235, 143, 32,  0,
       0,   0,   1,   101, 136, 132, 25,  255, 0,   191, 98,  0,   6,   29,  63,
       252, 65,  246, 207, 255, 235, 63,  172, 35,  112, 198, 115, 222, 243, 159,
       232, 208, 32,  0,   0,   3,   0,   0,   203, 255, 149, 20,  71,  203, 213,
       40,  0,   0,   139, 0,   24,  117, 166, 249, 227, 68,  230, 177, 134, 161,
       162, 1,   22,  105, 78,  66,  183, 130, 158, 108, 252, 112, 113, 58,  159,
       72,  116, 78,  141, 133, 76,  225, 209, 13,  221, 49,  187, 83,  123, 193,
       112, 123, 112, 74,  121, 133};
   size_t buffer_size = sizeof(buffer) / sizeof(uint8_t);
   const uint8_t side_buffer[] = "XX";
   size_t side_buffer_size = sizeof(side_buffer) / sizeof(uint8_t);
   base::TimeDelta pts = base::TimeDelta::FromMilliseconds(5);
 
   // 1. To DecoderBuffer
-  scoped_refptr<::media::DecoderBuffer> input_buffer =
-      ::media::DecoderBuffer::CopyFrom(buffer, buffer_size, side_buffer,
-                                       side_buffer_size);
+  scoped_refptr<DecoderBuffer> input_buffer = DecoderBuffer::CopyFrom(
+      buffer, buffer_size, side_buffer, side_buffer_size);
   input_buffer->set_timestamp(pts);
   input_buffer->set_is_key_frame(true);
 
   // 2. To Byte Array
-  std::vector<uint8_t> data = DecoderBufferToByteArray(input_buffer);
+  std::vector<uint8_t> data = DecoderBufferToByteArray(*input_buffer);
 
   // 3. To DecoderBuffer
-  scoped_refptr<::media::DecoderBuffer> output_buffer =
+  scoped_refptr<DecoderBuffer> output_buffer =
       ByteArrayToDecoderBuffer(data.data(), data.size());
   DCHECK(output_buffer);
 
   ASSERT_FALSE(output_buffer->end_of_stream());
   ASSERT_TRUE(output_buffer->is_key_frame());
   ASSERT_EQ(output_buffer->timestamp(), pts);
   ASSERT_EQ(output_buffer->data_size(), buffer_size);
   const uint8_t* output_data = output_buffer->data();
   for (size_t i = 0; i < buffer_size; i++) {
     ASSERT_EQ(output_data[i], buffer[i]);
@@ skipping 18 matching lines @@
   pb::AudioDecoderConfig audio_message;
   ConvertAudioDecoderConfigToProto(audio_config, &audio_message);
 
   AudioDecoderConfig audio_output_config;
   ASSERT_TRUE(
       ConvertProtoToAudioDecoderConfig(audio_message, &audio_output_config));
 
   ASSERT_TRUE(audio_config.Matches(audio_output_config));
 }
 
+TEST_F(ProtoUtilsTest, PipelineStatisticsConversion) {
+  PipelineStatistics original;
+  // Note: Fill the structure with non-zero bytes to ensure this test is
+  // initializing *all* fields.
+  memset(&original, 0xcd, sizeof(original));
+  original.audio_bytes_decoded = 123;
+  original.video_bytes_decoded = 456;
+  original.video_frames_decoded = 789;
+  original.video_frames_dropped = 21;
+  original.audio_memory_usage = 32;
+  original.video_memory_usage = 43;
+  original.video_keyframe_distance_average = base::TimeDelta::Max();
+
+  // There is no convert-to-proto function, so just do that here.
+  pb::PipelineStatistics pb_stats;
+  pb_stats.set_audio_bytes_decoded(original.audio_bytes_decoded);
+  pb_stats.set_video_bytes_decoded(original.video_bytes_decoded);
+  pb_stats.set_video_frames_decoded(original.video_frames_decoded);
+  pb_stats.set_video_frames_dropped(original.video_frames_dropped);
+  pb_stats.set_audio_memory_usage(original.audio_memory_usage);
+  pb_stats.set_video_memory_usage(original.video_memory_usage);
+
+  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, 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());
@@ skipping 24 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