Add metadata to media::VideoFrame and plumb it through IPC/MediaStream.

media/base/video_frame_metadata.cc

+// Copyright 2015 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 "base/logging.h"
+#include "media/base/video_frame_metadata.h"
+
+namespace media {
+
+namespace {
+
+// Map enum key to internal std::string key used by base::DictionaryValue.
+inline std::string ToInternalKey(VideoFrameMetadata::Key key) {
+  DCHECK_LT(key, VideoFrameMetadata::NUM_KEYS);
+  return std::string(reinterpret_cast<char*>(&key), sizeof(key));

[DaleCurtis, 2015/03/02 23:23:28]

Hmm, this creates an std::string() with 0x00 and 0x01, etc bytes in it; which
seems fine, but given that base::DictionaryValue keys have special characters
(".") may be risky. It also means the dictionary can't easily be dumped to
string.

[miu, 2015/03/03 04:31:05]

I accounted for that by using the Get/SetXXXWithoutPathExpansion() family of
getters and setters which don't apply the special "." semantics.

I thought about this a bit more, and I don't think it would be much of a
performance overhead to use ASCII decimal digits for keys.  Actually, it turns
out to be more space-efficient (1 byte instead of 4).  So, I've made that
change.

+}
+
+}  // namespace
+
+VideoFrameMetadata::VideoFrameMetadata() {}
+
+VideoFrameMetadata::~VideoFrameMetadata() {}
+
+bool VideoFrameMetadata::HasKey(Key key) const {
+  return dictionary_.HasKey(ToInternalKey(key));
+}
+
+void VideoFrameMetadata::SetBoolean(Key key, bool value) {
+  dictionary_.SetBooleanWithoutPathExpansion(ToInternalKey(key), value);
+}
+
+void VideoFrameMetadata::SetInteger(Key key, int value) {
+  dictionary_.SetIntegerWithoutPathExpansion(ToInternalKey(key), value);
+}
+
+void VideoFrameMetadata::SetDouble(Key key, double value) {
+  dictionary_.SetDoubleWithoutPathExpansion(ToInternalKey(key), value);
+}
+
+void VideoFrameMetadata::SetString(Key key, const std::string& value) {
+  dictionary_.SetWithoutPathExpansion(
+      ToInternalKey(key),
+      // Using BinaryValue since we don't want the |value| interpreted as having
+      // any particular character encoding (e.g., UTF-8) by
+      // base::DictionaryValue.
+      base::BinaryValue::CreateWithCopiedBuffer(value.data(), value.size()));
+}
+
+void VideoFrameMetadata::SetTimeTicks(Key key, const base::TimeTicks& value) {
+  const int64 internal_value = value.ToInternalValue();
+  dictionary_.SetWithoutPathExpansion(
+      ToInternalKey(key),
+      base::BinaryValue::CreateWithCopiedBuffer(
+          reinterpret_cast<const char*>(&internal_value),
+          sizeof(internal_value)));
+}
+
+void VideoFrameMetadata::SetValue(Key key, scoped_ptr<base::Value> value) {
+  dictionary_.SetWithoutPathExpansion(ToInternalKey(key), value.Pass());
+}
+
+bool VideoFrameMetadata::GetBoolean(Key key, bool* value) const {
+  DCHECK(value);
+  return dictionary_.GetBooleanWithoutPathExpansion(ToInternalKey(key), value);
+}
+
+bool VideoFrameMetadata::GetInteger(Key key, int* value) const {
+  DCHECK(value);
+  return dictionary_.GetIntegerWithoutPathExpansion(ToInternalKey(key), value);
+}
+
+bool VideoFrameMetadata::GetDouble(Key key, double* value) const {
+  DCHECK(value);
+  return dictionary_.GetDoubleWithoutPathExpansion(ToInternalKey(key), value);
+}
+
+bool VideoFrameMetadata::GetString(Key key, std::string* value) const {
+  DCHECK(value);
+  const base::BinaryValue* const binary_value = GetBinaryValue(key);
+  if (binary_value)
+    value->assign(binary_value->GetBuffer(), binary_value->GetSize());
+  return !!binary_value;
+}
+
+bool VideoFrameMetadata::GetTimeTicks(Key key, base::TimeTicks* value) const {
+  DCHECK(value);
+  const base::BinaryValue* const binary_value = GetBinaryValue(key);
+  if (binary_value && binary_value->GetSize() == sizeof(int64)) {
+    int64 internal_value;
+    memcpy(&internal_value, binary_value->GetBuffer(), sizeof(internal_value));
+    *value = base::TimeTicks::FromInternalValue(internal_value);
+    return true;
+  }
+  return false;
+}
+
+const base::Value* VideoFrameMetadata::GetValue(Key key) const {
+  const base::Value* result = nullptr;
+  if (!dictionary_.GetWithoutPathExpansion(ToInternalKey(key), &result))
+    return nullptr;
+  return result;
+}
+
+void VideoFrameMetadata::MergeInternalValuesInto(
+    base::DictionaryValue* out) const {
+  out->MergeDictionary(&dictionary_);
+}
+
+void VideoFrameMetadata::MergeInternalValuesFrom(
+    const base::DictionaryValue& in) {
+  dictionary_.MergeDictionary(&in);
+}
+
+const base::BinaryValue* VideoFrameMetadata::GetBinaryValue(Key key) const {
+  const base::Value* internal_value = nullptr;
+  if (dictionary_.GetWithoutPathExpansion(ToInternalKey(key),
+                                          &internal_value) &&
+      internal_value->GetType() == base::Value::TYPE_BINARY) {
+    return static_cast<const base::BinaryValue*>(internal_value);
+  }
+  return nullptr;
+}
+
+}  // namespace media