WebRTCStats added for surfacing RTCStats from WebRTC to Blink.

content/renderer/media/rtc_stats.cc

Index: content/renderer/media/rtc_stats.cc
diff --git a/content/renderer/media/rtc_stats.cc b/content/renderer/media/rtc_stats.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d9049b46eea591b862e80e4e72792e472570f2ad
--- /dev/null
+++ b/content/renderer/media/rtc_stats.cc
@@ -0,0 +1,151 @@
+// Copyright (c) 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 "content/renderer/media/rtc_stats.h"
+
+#include "base/logging.h"
+#include "third_party/webrtc/api/rtcstats.h"
+
+namespace content {
+
+namespace {
+
+double kMillisecondsPerMicrosecond = 0.001;

[perkj_chrome, 2016/09/07 14:34:36]

I am sure this const exist in a number of places. use the one in chrome. 

Here is one in webrtc..
https://cs.chromium.org/chromium/src/third_party/webrtc/base/timeutils.h?rcl=...

[hbos_chromium, 2016/09/08 08:38:31]

Done.

+
+}  // namespace
+
+RTCStats::RTCStats(const webrtc::RTCStats* stats)
+    : stats_(stats),
+      members_(stats->Members()) {
+  DCHECK(stats_);
+}
+
+RTCStats::~RTCStats() {
+}
+
+blink::WebString RTCStats::id() const {
+  return blink::WebString::fromUTF8(stats_->id());
+}
+
+blink::WebString RTCStats::type() const {
+  return blink::WebString::fromUTF8(stats_->type());
+}
+
+double RTCStats::timestamp() const {
+  return stats_->timestamp_us() * kMillisecondsPerMicrosecond;
+}
+
+size_t RTCStats::membersCount() const {
+  return members_.size();
+}
+
+std::unique_ptr<blink::WebRTCStatsMember> RTCStats::getMember(size_t i) const {
+  DCHECK_LT(i, members_.size());
+  return std::unique_ptr<blink::WebRTCStatsMember>(
+      new RTCStatsMember(members_[i]));
+}
+
+RTCStatsMember::RTCStatsMember(const webrtc::RTCStatsMemberInterface* member)
+    : member_(member) {
+  DCHECK(member_);
+}
+
+blink::WebString RTCStatsMember::name() const {
+  return blink::WebString::fromUTF8(member_->name());
+}
+
+blink::WebRTCStatsMemberType RTCStatsMember::type() const {
+  switch (member_->type()) {
+    case webrtc::RTCStatsMemberInterface::kInt32:
+      return blink::WebRTCStatsMemberTypeInt32;
+    case webrtc::RTCStatsMemberInterface::kUint32:
+      return blink::WebRTCStatsMemberTypeUint32;
+    case webrtc::RTCStatsMemberInterface::kInt64:
+      return blink::WebRTCStatsMemberTypeInt64;
+    case webrtc::RTCStatsMemberInterface::kUint64:
+      return blink::WebRTCStatsMemberTypeUint64;
+    case webrtc::RTCStatsMemberInterface::kDouble:
+      return blink::WebRTCStatsMemberTypeDouble;
+    case webrtc::RTCStatsMemberInterface::kStaticString:
+      return blink::WebRTCStatsMemberTypeStaticString;
+    case webrtc::RTCStatsMemberInterface::kString:
+      return blink::WebRTCStatsMemberTypeString;
+    case webrtc::RTCStatsMemberInterface::kSequenceInt32:
+      return blink::WebRTCStatsMemberTypeSequenceInt32;
+    case webrtc::RTCStatsMemberInterface::kSequenceUint32:
+      return blink::WebRTCStatsMemberTypeSequenceUint32;
+    case webrtc::RTCStatsMemberInterface::kSequenceInt64:
+      return blink::WebRTCStatsMemberTypeSequenceInt64;
+    case webrtc::RTCStatsMemberInterface::kSequenceUint64:
+      return blink::WebRTCStatsMemberTypeSequenceUint64;
+    case webrtc::RTCStatsMemberInterface::kSequenceDouble:
+      return blink::WebRTCStatsMemberTypeSequenceDouble;
+    case webrtc::RTCStatsMemberInterface::kSequenceStaticString:
+      return blink::WebRTCStatsMemberTypeSequenceStaticString;
+    case webrtc::RTCStatsMemberInterface::kSequenceString:
+      return blink::WebRTCStatsMemberTypeSequenceString;
+    default:
+      NOTREACHED();
+      return blink::WebRTCStatsMemberTypeSequenceInt32;
+  }
+}
+
+int32_t RTCStatsMember::valueInt32() const {
+  return *member_->cast_to<webrtc::RTCStatsMember<int32_t>>();
+}
+
+uint32_t RTCStatsMember::valueUint32() const {
+  return *member_->cast_to<webrtc::RTCStatsMember<uint32_t>>();
+}
+
+int64_t RTCStatsMember::valueInt64() const {
+  return *member_->cast_to<webrtc::RTCStatsMember<int64_t>>();
+}
+
+uint64_t RTCStatsMember::valueUint64() const {
+  return *member_->cast_to<webrtc::RTCStatsMember<uint64_t>>();
+}
+
+double RTCStatsMember::valueDouble() const {
+  return *member_->cast_to<webrtc::RTCStatsMember<double>>();
+}
+
+const char* RTCStatsMember::valueStaticString() const {
+  return *member_->cast_to<webrtc::RTCStatsMember<const char*>>();
+}
+
+const std::string& RTCStatsMember::valueString() const {
+  return *member_->cast_to<webrtc::RTCStatsMember<std::string>>();
+}
+
+const std::vector<int32_t>& RTCStatsMember::valueSequenceInt32() const {
+  return *member_->cast_to<webrtc::RTCStatsMember<std::vector<int32_t>>>();
+}
+
+const std::vector<uint32_t>& RTCStatsMember::valueSequenceUint32() const {
+  return *member_->cast_to<webrtc::RTCStatsMember<std::vector<uint32_t>>>();
+}
+
+const std::vector<int64_t>& RTCStatsMember::valueSequenceInt64() const {
+  return *member_->cast_to<webrtc::RTCStatsMember<std::vector<int64_t>>>();
+}
+
+const std::vector<uint64_t>& RTCStatsMember::valueSequenceUint64() const {
+  return *member_->cast_to<webrtc::RTCStatsMember<std::vector<uint64_t>>>();
+}
+
+const std::vector<double>& RTCStatsMember::valueSequenceDouble() const {
+  return *member_->cast_to<webrtc::RTCStatsMember<std::vector<double>>>();
+}
+
+const std::vector<const char*>& RTCStatsMember::valueSequenceStaticString()
+    const {
+  return *member_->cast_to<webrtc::RTCStatsMember<std::vector<const char*>>>();
+}
+
+const std::vector<std::string>& RTCStatsMember::valueSequenceString() const {
+  return *member_->cast_to<webrtc::RTCStatsMember<std::vector<std::string>>>();
+}
+
+}  // namespace content