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

media/remoting/proto_utils.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 <algorithm>
 
 #include "base/big_endian.h"
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "media/base/encryption_scheme.h"
-#include "media/remoting/rpc/proto_enum_utils.h"
+#include "media/remoting/proto_enum_utils.h"
 
 namespace media {
 namespace remoting {
 
 namespace {
 
 constexpr size_t kPayloadVersionFieldSize = sizeof(uint8_t);
 constexpr size_t kProtoBufferHeaderSize = sizeof(uint16_t);
 constexpr size_t kDataBufferHeaderSize = sizeof(uint32_t);
 
-std::unique_ptr<::media::DecryptConfig> ConvertProtoToDecryptConfig(
+std::unique_ptr<DecryptConfig> ConvertProtoToDecryptConfig(
     const pb::DecryptConfig& config_message) {
   if (!config_message.has_key_id())
     return nullptr;
   if (!config_message.has_iv())
     return nullptr;
 
-  std::vector<::media::SubsampleEntry> entries(
-      config_message.sub_samples_size());
+  std::vector<SubsampleEntry> entries(config_message.sub_samples_size());
   for (int i = 0; i < config_message.sub_samples_size(); ++i) {
     entries.push_back(
-        ::media::SubsampleEntry(config_message.sub_samples(i).clear_bytes(),
-                                config_message.sub_samples(i).cypher_bytes()));
+        SubsampleEntry(config_message.sub_samples(i).clear_bytes(),
+                       config_message.sub_samples(i).cypher_bytes()));
   }
 
-  std::unique_ptr<::media::DecryptConfig> decrypt_config(
-      new ::media::DecryptConfig(config_message.key_id(), config_message.iv(),
-                                 entries));
+  std::unique_ptr<DecryptConfig> decrypt_config(
+      new DecryptConfig(config_message.key_id(), config_message.iv(), entries));
   return decrypt_config;
 }
 
-scoped_refptr<::media::DecoderBuffer> ConvertProtoToDecoderBuffer(
+scoped_refptr<DecoderBuffer> ConvertProtoToDecoderBuffer(
     const pb::DecoderBuffer& buffer_message,
-    scoped_refptr<::media::DecoderBuffer> buffer) {
+    scoped_refptr<DecoderBuffer> buffer) {
   if (buffer_message.is_eos()) {
     VLOG(1) << "EOS data";
-    return ::media::DecoderBuffer::CreateEOSBuffer();
+    return DecoderBuffer::CreateEOSBuffer();
   }
 
   if (buffer_message.has_timestamp_usec()) {
     buffer->set_timestamp(
         base::TimeDelta::FromMicroseconds(buffer_message.timestamp_usec()));
   }
 
   if (buffer_message.has_duration_usec()) {
     buffer->set_duration(
         base::TimeDelta::FromMicroseconds(buffer_message.duration_usec()));
@@ skipping 18 matching lines @@
   }
   base::TimeDelta back_discard;
   if (buffer_message.has_back_discard_usec()) {
     has_discard = true;
     back_discard =
         base::TimeDelta::FromMicroseconds(buffer_message.back_discard_usec());
   }
 
   if (has_discard) {
     buffer->set_discard_padding(
-        ::media::DecoderBuffer::DiscardPadding(front_discard, back_discard));
+        DecoderBuffer::DiscardPadding(front_discard, back_discard));
   }
 
   if (buffer_message.has_splice_timestamp_usec()) {
     buffer->set_splice_timestamp(base::TimeDelta::FromMicroseconds(
         buffer_message.splice_timestamp_usec()));
   }
 
   if (buffer_message.has_side_data()) {
     buffer->CopySideDataFrom(
         reinterpret_cast<const uint8_t*>(buffer_message.side_data().data()),
         buffer_message.side_data().size());
   }
 
   return buffer;
 }
 
-void ConvertDecryptConfigToProto(const ::media::DecryptConfig& decrypt_config,
+void ConvertDecryptConfigToProto(const DecryptConfig& decrypt_config,
                                  pb::DecryptConfig* config_message) {
   DCHECK(config_message);
 
   config_message->set_key_id(decrypt_config.key_id());
   config_message->set_iv(decrypt_config.iv());
 
   for (const auto& entry : decrypt_config.subsamples()) {
     pb::DecryptConfig::SubSample* sub_sample =
         config_message->add_sub_samples();
     sub_sample->set_clear_bytes(entry.clear_bytes);
     sub_sample->set_cypher_bytes(entry.cypher_bytes);
   }
 }
 
-void ConvertDecoderBufferToProto(
-    const scoped_refptr<::media::DecoderBuffer>& decoder_buffer,

[miu, 2017/01/20 23:14:41]

Changed 1st arg to be just a plain const-ref.

[xjz, 2017/01/21 06:12:33]

Acknowledged.

-    pb::DecoderBuffer* buffer_message) {
-  if (decoder_buffer->end_of_stream()) {
+void ConvertDecoderBufferToProto(const DecoderBuffer& decoder_buffer,
+                                 pb::DecoderBuffer* buffer_message) {
+  if (decoder_buffer.end_of_stream()) {
     buffer_message->set_is_eos(true);
     return;
   }
 
-  VLOG(3) << "timestamp:" << decoder_buffer->timestamp().InMicroseconds()
-          << " duration:" << decoder_buffer->duration().InMicroseconds();
+  VLOG(3) << "timestamp:" << decoder_buffer.timestamp().InMicroseconds()
+          << " duration:" << decoder_buffer.duration().InMicroseconds();
   buffer_message->set_timestamp_usec(
-      decoder_buffer->timestamp().InMicroseconds());
-  buffer_message->set_duration_usec(
-      decoder_buffer->duration().InMicroseconds());
-  buffer_message->set_is_key_frame(decoder_buffer->is_key_frame());
+      decoder_buffer.timestamp().InMicroseconds());
+  buffer_message->set_duration_usec(decoder_buffer.duration().InMicroseconds());
+  buffer_message->set_is_key_frame(decoder_buffer.is_key_frame());
 
-  if (decoder_buffer->decrypt_config()) {
-    ConvertDecryptConfigToProto(*decoder_buffer->decrypt_config(),
+  if (decoder_buffer.decrypt_config()) {
+    ConvertDecryptConfigToProto(*decoder_buffer.decrypt_config(),
                                 buffer_message->mutable_decrypt_config());
   }
 
   buffer_message->set_front_discard_usec(
-      decoder_buffer->discard_padding().first.InMicroseconds());
+      decoder_buffer.discard_padding().first.InMicroseconds());
   buffer_message->set_back_discard_usec(
-      decoder_buffer->discard_padding().second.InMicroseconds());
+      decoder_buffer.discard_padding().second.InMicroseconds());
   buffer_message->set_splice_timestamp_usec(
-      decoder_buffer->splice_timestamp().InMicroseconds());
+      decoder_buffer.splice_timestamp().InMicroseconds());
 
-  if (decoder_buffer->side_data_size()) {
-    buffer_message->set_side_data(decoder_buffer->side_data(),
-                                  decoder_buffer->side_data_size());
+  if (decoder_buffer.side_data_size()) {
+    buffer_message->set_side_data(decoder_buffer.side_data(),
+                                  decoder_buffer.side_data_size());
   }
 }
 
 }  // namespace
 
-scoped_refptr<::media::DecoderBuffer> ByteArrayToDecoderBuffer(
-    const uint8_t* data,
-    uint32_t size) {
+scoped_refptr<DecoderBuffer> ByteArrayToDecoderBuffer(const uint8_t* data,
+                                                      uint32_t size) {
   base::BigEndianReader reader(reinterpret_cast<const char*>(data), size);
   uint8_t payload_version = 0;
   uint16_t proto_size = 0;
   pb::DecoderBuffer segment;
   uint32_t buffer_size = 0;
   if (reader.ReadU8(&payload_version) && payload_version == 0 &&
       reader.ReadU16(&proto_size) &&
       static_cast<int>(proto_size) < reader.remaining() &&
       segment.ParseFromArray(reader.ptr(), proto_size) &&
       reader.Skip(proto_size) && reader.ReadU32(&buffer_size) &&
       static_cast<int64_t>(buffer_size) <= reader.remaining()) {
     // Deserialize proto buffer. It passes the pre allocated DecoderBuffer into
     // the function because the proto buffer may overwrite DecoderBuffer since
     // it may be EOS buffer.
-    scoped_refptr<media::DecoderBuffer> decoder_buffer =
-        ConvertProtoToDecoderBuffer(
-            segment,
-            DecoderBuffer::CopyFrom(
-                reinterpret_cast<const uint8_t*>(reader.ptr()), buffer_size));
+    scoped_refptr<DecoderBuffer> decoder_buffer = ConvertProtoToDecoderBuffer(
+        segment,
+        DecoderBuffer::CopyFrom(reinterpret_cast<const uint8_t*>(reader.ptr()),
+                                buffer_size));
     return decoder_buffer;
   }
 
-  LOG(ERROR) << "Not able to convert byte array to ::media::DecoderBuffer";
   return nullptr;
 }
 
 std::vector<uint8_t> DecoderBufferToByteArray(
-    const scoped_refptr<::media::DecoderBuffer>& decoder_buffer) {
+    const DecoderBuffer& decoder_buffer) {
   pb::DecoderBuffer decoder_buffer_message;
   ConvertDecoderBufferToProto(decoder_buffer, &decoder_buffer_message);
 
   size_t decoder_buffer_size =
-      decoder_buffer->end_of_stream() ? 0 : decoder_buffer->data_size();
+      decoder_buffer.end_of_stream() ? 0 : decoder_buffer.data_size();
   size_t size = kPayloadVersionFieldSize + kProtoBufferHeaderSize +
                 decoder_buffer_message.ByteSize() + kDataBufferHeaderSize +
                 decoder_buffer_size;
   std::vector<uint8_t> buffer(size);
   base::BigEndianWriter writer(reinterpret_cast<char*>(buffer.data()),
                                buffer.size());
   if (writer.WriteU8(0) &&
       writer.WriteU16(
           static_cast<uint16_t>(decoder_buffer_message.GetCachedSize())) &&
       decoder_buffer_message.SerializeToArray(
           writer.ptr(), decoder_buffer_message.GetCachedSize()) &&
       writer.Skip(decoder_buffer_message.GetCachedSize()) &&
       writer.WriteU32(decoder_buffer_size)) {
     if (decoder_buffer_size) {
       // DecoderBuffer frame data.
-      writer.WriteBytes(reinterpret_cast<const void*>(decoder_buffer->data()),
-                        decoder_buffer->data_size());
+      writer.WriteBytes(reinterpret_cast<const void*>(decoder_buffer.data()),
+                        decoder_buffer.data_size());
     }
     return buffer;
   }
 
+  NOTREACHED();
   // Reset buffer since serialization of the data failed.
-  LOG(ERROR) << "Not able to convert ::media::DecoderBuffer to byte array";
   buffer.clear();
   return buffer;
 }
 
-void ConvertEncryptionSchemeToProto(
-    const ::media::EncryptionScheme& encryption_scheme,
-    pb::EncryptionScheme* message) {
+void ConvertEncryptionSchemeToProto(const EncryptionScheme& encryption_scheme,
+                                    pb::EncryptionScheme* message) {
   DCHECK(message);
   message->set_mode(
       ToProtoEncryptionSchemeCipherMode(encryption_scheme.mode()).value());
   message->set_encrypt_blocks(encryption_scheme.pattern().encrypt_blocks());
   message->set_skip_blocks(encryption_scheme.pattern().skip_blocks());
 }
 
-::media::EncryptionScheme ConvertProtoToEncryptionScheme(
+EncryptionScheme ConvertProtoToEncryptionScheme(
     const pb::EncryptionScheme& message) {
-  return ::media::EncryptionScheme(
+  return EncryptionScheme(
       ToMediaEncryptionSchemeCipherMode(message.mode()).value(),
-      ::media::EncryptionScheme::Pattern(message.encrypt_blocks(),
-                                         message.skip_blocks()));
+      EncryptionScheme::Pattern(message.encrypt_blocks(),
+                                message.skip_blocks()));
 }
 
-void ConvertAudioDecoderConfigToProto(
-    const ::media::AudioDecoderConfig& audio_config,
-    pb::AudioDecoderConfig* audio_message) {
+void ConvertAudioDecoderConfigToProto(const AudioDecoderConfig& audio_config,
+                                      pb::AudioDecoderConfig* audio_message) {
   DCHECK(audio_config.IsValidConfig());
   DCHECK(audio_message);
 
   audio_message->set_codec(
       ToProtoAudioDecoderConfigCodec(audio_config.codec()).value());
   audio_message->set_sample_format(
       ToProtoAudioDecoderConfigSampleFormat(audio_config.sample_format())
           .value());
   audio_message->set_channel_layout(
       ToProtoAudioDecoderConfigChannelLayout(audio_config.channel_layout())
@@ skipping 11 matching lines @@
   if (audio_config.is_encrypted()) {
     pb::EncryptionScheme* encryption_scheme_message =
         audio_message->mutable_encryption_scheme();
     ConvertEncryptionSchemeToProto(audio_config.encryption_scheme(),
                                    encryption_scheme_message);
   }
 }
 
 bool ConvertProtoToAudioDecoderConfig(
     const pb::AudioDecoderConfig& audio_message,
-    ::media::AudioDecoderConfig* audio_config) {
+    AudioDecoderConfig* audio_config) {
   DCHECK(audio_config);
   audio_config->Initialize(
       ToMediaAudioCodec(audio_message.codec()).value(),
       ToMediaSampleFormat(audio_message.sample_format()).value(),
       ToMediaChannelLayout(audio_message.channel_layout()).value(),
       audio_message.samples_per_second(),
       std::vector<uint8_t>(audio_message.extra_data().begin(),
                            audio_message.extra_data().end()),
       ConvertProtoToEncryptionScheme(audio_message.encryption_scheme()),
       base::TimeDelta::FromMicroseconds(audio_message.seek_preroll_usec()),
       audio_message.codec_delay());
   return audio_config->IsValidConfig();
 }
 
-void ConvertVideoDecoderConfigToProto(
-    const ::media::VideoDecoderConfig& video_config,
-    pb::VideoDecoderConfig* video_message) {
+void ConvertVideoDecoderConfigToProto(const VideoDecoderConfig& video_config,
+                                      pb::VideoDecoderConfig* video_message) {
   DCHECK(video_config.IsValidConfig());
   DCHECK(video_message);
 
   video_message->set_codec(
       ToProtoVideoDecoderConfigCodec(video_config.codec()).value());
   video_message->set_profile(
       ToProtoVideoDecoderConfigProfile(video_config.profile()).value());
   video_message->set_format(
       ToProtoVideoDecoderConfigFormat(video_config.format()).value());
   video_message->set_color_space(
@@ skipping 21 matching lines @@
   if (video_config.is_encrypted()) {
     pb::EncryptionScheme* encryption_scheme_message =
         video_message->mutable_encryption_scheme();
     ConvertEncryptionSchemeToProto(video_config.encryption_scheme(),
                                    encryption_scheme_message);
   }
 }
 
 bool ConvertProtoToVideoDecoderConfig(
     const pb::VideoDecoderConfig& video_message,
-    ::media::VideoDecoderConfig* video_config) {
+    VideoDecoderConfig* video_config) {
   DCHECK(video_config);
-  ::media::EncryptionScheme encryption_scheme;
+  EncryptionScheme encryption_scheme;
   video_config->Initialize(
       ToMediaVideoCodec(video_message.codec()).value(),
       ToMediaVideoCodecProfile(video_message.profile()).value(),
       ToMediaVideoPixelFormat(video_message.format()).value(),
       ToMediaColorSpace(video_message.color_space()).value(),
       gfx::Size(video_message.coded_size().width(),
                 video_message.coded_size().height()),
       gfx::Rect(video_message.visible_rect().x(),
                 video_message.visible_rect().y(),
                 video_message.visible_rect().width(),
                 video_message.visible_rect().height()),
       gfx::Size(video_message.natural_size().width(),
                 video_message.natural_size().height()),
       std::vector<uint8_t>(video_message.extra_data().begin(),
                            video_message.extra_data().end()),
       ConvertProtoToEncryptionScheme(video_message.encryption_scheme()));
   return video_config->IsValidConfig();
 }
 
+void ConvertProtoToPipelineStatistics(
+    const pb::PipelineStatistics& stats_message,
+    PipelineStatistics* stats) {
+  stats->audio_bytes_decoded = stats_message.audio_bytes_decoded();
+  stats->video_bytes_decoded = stats_message.video_bytes_decoded();
+  stats->video_frames_decoded = stats_message.video_frames_decoded();
+  stats->video_frames_dropped = stats_message.video_frames_dropped();
+  stats->audio_memory_usage = stats_message.audio_memory_usage();
+  stats->video_memory_usage = stats_message.video_memory_usage();
+  // HACK: Set the following to prevent "disable video when hidden" logic in
+  // media::blink::WebMediaPlayerImpl.
+  stats->video_keyframe_distance_average = base::TimeDelta::Max();

[miu, 2017/01/20 23:14:41]

This new "video_keyframe_distance" field was added recently, but not accounted
for in the media/remoting code. My added unit test will catch any future
new/changed fields so this doesn't happen again.

[xjz, 2017/01/21 06:12:33]

Good!

+}
+
 void ConvertCdmKeyInfoToProto(
-    const ::media::CdmKeysInfo& keys_information,
+    const CdmKeysInfo& keys_information,
     pb::CdmClientOnSessionKeysChange* key_change_message) {
   for (const auto& info : keys_information) {
     pb::CdmKeyInformation* key = key_change_message->add_key_information();
     key->set_key_id(info->key_id.data(), info->key_id.size());
     key->set_status(ToProtoCdmKeyInformation(info->status).value());
     key->set_system_code(info->system_code);
   }
 }
 
 void ConvertProtoToCdmKeyInfo(
     const pb::CdmClientOnSessionKeysChange keychange_message,
     CdmKeysInfo* key_information) {
   DCHECK(key_information);
   key_information->reserve(keychange_message.key_information_size());
   for (int i = 0; i < keychange_message.key_information_size(); ++i) {
     const pb::CdmKeyInformation key_info_msg =
         keychange_message.key_information(i);
 
-    std::unique_ptr<::media::CdmKeyInformation> key(
-        new ::media::CdmKeyInformation(
-            key_info_msg.key_id(),
-            ToMediaCdmKeyInformationKeyStatus(key_info_msg.status()).value(),
-            key_info_msg.system_code()));
+    std::unique_ptr<CdmKeyInformation> key(new CdmKeyInformation(
+        key_info_msg.key_id(),
+        ToMediaCdmKeyInformationKeyStatus(key_info_msg.status()).value(),
+        key_info_msg.system_code()));
     key_information->push_back(std::move(key));
   }
 }
 
 void ConvertCdmPromiseToProto(const CdmPromiseResult& result,
                               pb::CdmPromise* promise_message) {
   promise_message->set_success(result.success());
   if (!result.success()) {
     promise_message->set_exception(
         ToProtoCdmException(result.exception()).value());
@@ skipping 20 matching lines @@
                               CdmPromiseResult* result) {
   if (!promise_message.has_success())
     return false;
 
   bool success = promise_message.success();
   if (success) {
     *result = CdmPromiseResult::SuccessResult();
     return true;
   }
 
-  ::media::CdmPromise::Exception exception = ::media::CdmPromise::UNKNOWN_ERROR;
+  CdmPromise::Exception exception = CdmPromise::UNKNOWN_ERROR;
   uint32_t system_code = 0;
   std::string error_message;
 
   exception = ToCdmPromiseException(promise_message.exception()).value();
   system_code = promise_message.system_code();
   error_message = promise_message.error_message();
   *result = CdmPromiseResult(exception, system_code, error_message);
   return true;
 }
 
@@ skipping 11 matching lines @@
   if (cdm_id)
     *cdm_id = promise_message.cdm_id();
   if (session_id)
     *session_id = promise_message.session_id();
 
   return true;
 }
 
 //==============================================================================
 CdmPromiseResult::CdmPromiseResult()
-    : CdmPromiseResult(::media::CdmPromise::UNKNOWN_ERROR, 0, "") {}
+    : CdmPromiseResult(CdmPromise::UNKNOWN_ERROR, 0, "") {}
 
-CdmPromiseResult::CdmPromiseResult(::media::CdmPromise::Exception exception,
+CdmPromiseResult::CdmPromiseResult(CdmPromise::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::CdmPromise::Exception>(0), 0,
-                          "");
+  CdmPromiseResult result(static_cast<CdmPromise::Exception>(0), 0, "");
   result.success_ = true;
   return result;
 }
 
 }  // namespace remoting
 }  // namespace media