Define remote playback proto buffer

media/remoting/rpc/proto_utils.cc

Index: media/remoting/rpc/proto_utils.cc
diff --git a/media/remoting/rpc/proto_utils.cc b/media/remoting/rpc/proto_utils.cc
new file mode 100644
index 0000000000000000000000000000000000000000..740570f4b9cf2a14be0e2356f20404f44c94d9f7
--- /dev/null
+++ b/media/remoting/rpc/proto_utils.cc
@@ -0,0 +1,475 @@
+// 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 <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"
+
+namespace media {
+namespace remoting {
+
+const int kInvalidHandle = -1;
+const int kReceiverHandle = 0;
+
+namespace {
+
+const int kPayloadVersionFieldSize = 1;

[miu, 2016/09/16 18:14:13]

For these three constants:

1. s/const/constexpr/
2. s/int/size_t/
3. Use self-documenting values on the RHS. Meaning: sizeof(uint8_t) instead of
1, sizeof(uint16_t) instead of 2, etc.

[erickung1, 2016/09/19 17:04:35]

Done.

+const int kProtoBufferHeaderSize = 2;
+const int kDataBufferHeaderSize = 4;
+
+std::unique_ptr<::media::DecryptConfig> ConvertProtoToDecryptConfig(
+    const pb::DecryptConfig& config_message) {
+  std::vector<::media::SubsampleEntry> entries;

[miu, 2016/09/16 18:14:13]

nit: Please move declaration down to where this is first used. Also, call
entries.reserve(config_message.sub_samples_size()) since the final size of the
vector is known ahead of time.

[erickung1, 2016/09/19 17:04:34]

Done.

+
+  if (!config_message.has_key_id())
+    return nullptr;
+  if (!config_message.has_iv())
+    return nullptr;
+
+  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()));
+  }
+
+  std::unique_ptr<::media::DecryptConfig> decrypt_config(
+      new ::media::DecryptConfig(config_message.key_id(), config_message.iv(),
+                                 entries));
+  return decrypt_config;
+}
+
+scoped_refptr<::media::DecoderBuffer> ConvertProtoToDecoderBuffer(
+    const pb::DecoderBuffer& buffer_message,
+    scoped_refptr<::media::DecoderBuffer> buffer) {
+  if (buffer_message.is_eos()) {
+    VLOG(1) << "EOS data";
+    return ::media::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()));
+  }
+  VLOG(2) << "timestamp:" << buffer_message.timestamp_usec()
+          << " duration:" << buffer_message.duration_usec();
+
+  if (buffer_message.has_is_key_frame())
+    buffer->set_is_key_frame(buffer_message.is_key_frame());
+
+  if (buffer_message.has_decrypt_config()) {
+    buffer->set_decrypt_config(
+        ConvertProtoToDecryptConfig(buffer_message.decrypt_config()));
+  }
+
+  bool has_discard = false;
+  base::TimeDelta front_discard;
+  if (buffer_message.has_front_discard_usec()) {
+    has_discard = true;
+    front_discard =
+        base::TimeDelta::FromMicroseconds(buffer_message.front_discard_usec());
+  }
+  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));
+  }
+
+  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,
+                                 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,
+    pb::DecoderBuffer* buffer_message) {
+  if (decoder_buffer->end_of_stream()) {
+    buffer_message->set_is_eos(true);
+    return;
+  }
+
+  VLOG(2) << "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());
+
+  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());
+  buffer_message->set_back_discard_usec(
+      decoder_buffer->discard_padding().second.InMicroseconds());
+  buffer_message->set_splice_timestamp_usec(
+      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());
+  }
+}
+
+}  // namespace
+
+scoped_refptr<::media::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));
+    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) {
+  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();
+  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());
+    }
+    return buffer;
+  }
+
+  // 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) {
+  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(
+    const pb::EncryptionScheme& message) {
+  return ::media::EncryptionScheme(
+      ToMediaEncryptionSchemeCipherMode(message.mode()).value(),
+      ::media::EncryptionScheme::Pattern(message.encrypt_blocks(),
+                                         message.skip_blocks()));
+}
+
+void ConvertAudioDecoderConfigToProto(
+    const ::media::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())
+          .value());
+  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());
+
+  if (!audio_config.extra_data().empty()) {
+    audio_message->set_extra_data(audio_config.extra_data().data(),
+                                  audio_config.extra_data().size());
+  }
+
+  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) {
+  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) {
+  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(
+      ToProtoVideoDecoderConfigColorSpace(video_config.color_space()).value());
+
+  pb::Size* coded_size_message = video_message->mutable_coded_size();
+  coded_size_message->set_width(video_config.coded_size().width());
+  coded_size_message->set_height(video_config.coded_size().height());
+
+  pb::Rect* visible_rect_message = video_message->mutable_visible_rect();
+  visible_rect_message->set_x(video_config.visible_rect().x());
+  visible_rect_message->set_y(video_config.visible_rect().y());
+  visible_rect_message->set_width(video_config.visible_rect().width());
+  visible_rect_message->set_height(video_config.visible_rect().height());
+
+  pb::Size* natural_size_message = video_message->mutable_natural_size();
+  natural_size_message->set_width(video_config.natural_size().width());
+  natural_size_message->set_height(video_config.natural_size().height());
+
+  if (!video_config.extra_data().empty()) {
+    video_message->set_extra_data(video_config.extra_data().data(),
+                                  video_config.extra_data().size());
+  }
+
+  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) {
+  DCHECK(video_config);
+  ::media::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 ConvertCdmKeyInfoToProto(
+    const ::media::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);
+  for (int i = 0; i < keychange_message.key_information_size(); ++i) {

[miu, 2016/09/16 18:14:13]

nit: Please add:
key_information->reserve(keychange_message.key_information_size());

[erickung1, 2016/09/19 17:04:35]

Done.

+    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()));
+    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(
+        ToProtoMediaKeysException(result.exception()).value());
+    promise_message->set_system_code(result.system_code());
+    promise_message->set_error_message(result.error_message());
+  }
+}
+
+void ConvertCdmPromiseWithSessionIdToProto(const CdmPromiseResult& result,
+                                           const std::string& session_id,
+                                           pb::CdmPromise* promise_message) {
+  ConvertCdmPromiseToProto(result, promise_message);
+  if (!session_id.empty())

[miu, 2016/09/16 18:14:13]

Is an empty |session_id| valid? If that would indicate a bug in Chrome code,
please use DCHECK(!session_id.empty()) instead.

[erickung1, 2016/09/19 17:04:35]

Done. I decided to remove the if condition, since it is still OK to set empty
string session id

The reason is because there are two types of promise, NewSessionCdmPromise and
SimpleCdmPromise

from the proto design's perspective, we create a promise proto structure and add
"session_id" field as optional. That's the reason some RPC message is required
to set it and some ore not.

https://cs.chromium.org/chromium/src/media/base/media_keys.h?q=media_keys.h&s...

Only when LoadSession() and CreateSessionAndGenerateRequest() would require
using Promise with session id

+    promise_message->set_session_id(session_id);
+}
+
+void ConvertCdmPromiseWithCdmIdToProto(const CdmPromiseResult& result,
+                                       int cdm_id,
+                                       pb::CdmPromise* promise_message) {
+  ConvertCdmPromiseToProto(result, promise_message);
+  promise_message->set_cdm_id(cdm_id);
+}
+
+bool ConvertProtoToCdmPromise(const pb::CdmPromise& promise_message,
+                              CdmPromiseResult* result) {
+  if (!promise_message.has_success())
+    return false;
+
+  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 = ToMediaMediaKeysException(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;
+}
+
+bool ConvertProtoToCdmPromiseWithCdmIdSessionId(const pb::RpcMessage& message,
+                                                CdmPromiseResult* result,
+                                                int* cdm_id,
+                                                std::string* session_id) {
+  if (!message.has_cdm_promise_rpc())
+    return false;
+
+  const auto& promise_message = message.cdm_promise_rpc();
+  if (!ConvertProtoToCdmPromise(promise_message, result))
+    return false;
+
+  if (cdm_id)
+    *cdm_id = promise_message.cdm_id();
+  if (session_id)
+    *session_id = promise_message.session_id();
+
+  return true;
+}
+
+//==============================================================================
+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;
+}
+
+}  // namespace remoting
+}  // namespace media