WebRTCStats added for surfacing RTCStats from WebRTC to Blink.

webrtc::RTCStats lives in the WebRTC repo and can't be directly
accessed from Blink. In content we implement blink::WebRTCStats and
friends to bridge this gap.

Work split up in smaller CLs. In a follow-up CL we will gather stats
in content's rtc_peer_connection_handler.cc using
webrtc::RTCStatsCollector and return the resulting stats to Blink
using [Web]RTCStats, this will include unittests.

BUG=chromium:627816

Review-Url: https://codereview.chromium.org/2319543002
Cr-Commit-Position: refs/heads/master@{#417553}

content/renderer/BUILD.gn

@@ -613,6 +613,8 @@ target(link_target_type, "renderer") {
       "media/webrtc/peer_connection_remote_audio_source.h",
       "media/webrtc/processed_local_audio_source.cc",
       "media/webrtc/processed_local_audio_source.h",
+      "media/webrtc/rtc_stats.cc",
+      "media/webrtc/rtc_stats.h",
       "media/webrtc/stun_field_trial.cc",
       "media/webrtc/stun_field_trial.h",
       "media/webrtc/track_observer.cc",
@@ -691,6 +693,7 @@ target(link_target_type, "renderer") {
       "//third_party/webrtc/p2p:libstunprober",
       "//third_party/webrtc/p2p:rtc_p2p",
       "//third_party/webrtc/pc:rtc_pc",
+      "//third_party/webrtc/stats",
       "//third_party/webrtc/system_wrappers",
     ]
     if (rtc_use_h264) {

content/renderer/media/webrtc/rtc_stats.cc

+// 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/webrtc/rtc_stats.h"
+
+#include "base/logging.h"
+#include "base/time/time.h"
+#include "third_party/webrtc/api/rtcstats.h"
+
+namespace content {
+
+RTCStatsReport::RTCStatsReport(
+    const scoped_refptr<const webrtc::RTCStatsReport>& stats_report)
+    : stats_report_(stats_report),
+      it_(stats_report_->begin()),
+      end_(stats_report_->end()) {
+  DCHECK(stats_report_);
+}
+
+RTCStatsReport::~RTCStatsReport() {
+}
+
+std::unique_ptr<blink::WebRTCStats> RTCStatsReport::next() {
+  if (it_ == end_)
+    return std::unique_ptr<blink::WebRTCStats>();
+  const webrtc::RTCStats& next = *it_;
+  ++it_;
+  return std::unique_ptr<blink::WebRTCStats>(
+      new RTCStats(stats_report_, &next));
+}
+
+RTCStats::RTCStats(
+    const scoped_refptr<const webrtc::RTCStatsReport>& stats_owner,
+    const webrtc::RTCStats* stats)
+    : stats_owner_(stats_owner),
+      stats_(stats),
+      stats_members_(stats->Members()) {
+  DCHECK(stats_owner_);
+  DCHECK(stats_);
+  DCHECK(stats_owner_->Get(stats_->id()));
+}
+
+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() / static_cast<double>(
+      base::Time::kMicrosecondsPerMillisecond);
+}
+
+size_t RTCStats::membersCount() const {
+  return stats_members_.size();
+}
+
+std::unique_ptr<blink::WebRTCStatsMember> RTCStats::getMember(size_t i) const {
+  DCHECK_LT(i, stats_members_.size());
+  return std::unique_ptr<blink::WebRTCStatsMember>(
+      new RTCStatsMember(stats_owner_, stats_members_[i]));
+}
+
+RTCStatsMember::RTCStatsMember(
+    const scoped_refptr<const webrtc::RTCStatsReport>& stats_owner,
+    const webrtc::RTCStatsMemberInterface* member)
+    : stats_owner_(stats_owner),
+      member_(member) {
+  DCHECK(stats_owner_);
+  DCHECK(member_);
+}
+
+RTCStatsMember::~RTCStatsMember() {
+}
+
+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:
+    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:
+    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>>();
+}
+
+blink::WebString RTCStatsMember::valueString() const {
+  switch (member_->type()) {
+    case webrtc::RTCStatsMemberInterface::kStaticString:
+      return blink::WebString::fromUTF8(
+          *member_->cast_to<webrtc::RTCStatsMember<const char*>>());
+    case webrtc::RTCStatsMemberInterface::kString:
+      return blink::WebString::fromUTF8(
+          *member_->cast_to<webrtc::RTCStatsMember<std::string>>());
+    default:
+      NOTREACHED();
+      return blink::WebString();
+  }
+}
+
+blink::WebVector<int32_t> RTCStatsMember::valueSequenceInt32() const {
+  return blink::WebVector<int32_t>(
+      *member_->cast_to<webrtc::RTCStatsMember<std::vector<int32_t>>>());
+}
+
+blink::WebVector<uint32_t> RTCStatsMember::valueSequenceUint32() const {
+  return blink::WebVector<uint32_t>(
+      *member_->cast_to<webrtc::RTCStatsMember<std::vector<uint32_t>>>());
+}
+
+blink::WebVector<int64_t> RTCStatsMember::valueSequenceInt64() const {
+  return blink::WebVector<int64_t>(
+      *member_->cast_to<webrtc::RTCStatsMember<std::vector<int64_t>>>());
+}
+
+blink::WebVector<uint64_t> RTCStatsMember::valueSequenceUint64() const {
+  return blink::WebVector<uint64_t>(
+      *member_->cast_to<webrtc::RTCStatsMember<std::vector<uint64_t>>>());
+}
+
+blink::WebVector<double> RTCStatsMember::valueSequenceDouble() const {
+  return blink::WebVector<double>(
+      *member_->cast_to<webrtc::RTCStatsMember<std::vector<double>>>());
+}
+
+blink::WebVector<blink::WebString> RTCStatsMember::valueSequenceString() const {
+  switch (member_->type()) {
+    case webrtc::RTCStatsMemberInterface::kStaticString:
+      {
+        const std::vector<const char*>& sequence =
+            *member_->cast_to<
+                webrtc::RTCStatsMember<std::vector<const char*>>>();
+        blink::WebVector<blink::WebString> web_sequence(sequence.size());
+        for (size_t i = 0; i < sequence.size(); ++i)
+          web_sequence[i] = blink::WebString::fromUTF8(sequence[i]);
+        return web_sequence;
+      }
+    case webrtc::RTCStatsMemberInterface::kString:
+      {
+        const std::vector<std::string>& sequence =
+            *member_->cast_to<
+                webrtc::RTCStatsMember<std::vector<std::string>>>();
+        blink::WebVector<blink::WebString> web_sequence(sequence.size());
+        for (size_t i = 0; i < sequence.size(); ++i)
+          web_sequence[i] = blink::WebString::fromUTF8(sequence[i]);
+        return web_sequence;
+      }
+    default:
+      NOTREACHED();
+      return blink::WebVector<blink::WebString>();
+  }
+}
+
+}  // namespace content

content/renderer/media/webrtc/rtc_stats.h

+// 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.
+
+#ifndef CONTENT_RENDERER_MEDIA_WEBRTC_RTC_STATS_H_
+#define CONTENT_RENDERER_MEDIA_WEBRTC_RTC_STATS_H_
+
+#include "base/memory/ref_counted.h"
+#include "third_party/WebKit/public/platform/WebRTCStats.h"
+#include "third_party/webrtc/api/rtcstats.h"
+#include "third_party/webrtc/api/rtcstatsreport.h"
+
+namespace content {
+
+class RTCStatsReport : public blink::WebRTCStatsReport {
+ public:
+  RTCStatsReport(
+      const scoped_refptr<const webrtc::RTCStatsReport>& stats_report);
+  ~RTCStatsReport() override;
+
+  std::unique_ptr<blink::WebRTCStats> next() override;
+
+ private:
+  const scoped_refptr<const webrtc::RTCStatsReport> stats_report_;
+  webrtc::RTCStatsReport::ConstIterator it_;
+  const webrtc::RTCStatsReport::ConstIterator end_;
+};
+
+class RTCStats : public blink::WebRTCStats {
+ public:
+  RTCStats(const scoped_refptr<const webrtc::RTCStatsReport>& stats_owner,
+           const webrtc::RTCStats* stats);
+  ~RTCStats() override;
+
+  blink::WebString id() const override;
+  blink::WebString type() const override;
+  double timestamp() const override;
+
+  size_t membersCount() const override;
+  std::unique_ptr<blink::WebRTCStatsMember> getMember(size_t i) const override;
+
+ private:
+  // Reference to keep the report that owns |stats_| alive.
+  const scoped_refptr<const webrtc::RTCStatsReport> stats_owner_;
+  // Pointer to a stats object that is owned by |stats_owner_|.
+  const webrtc::RTCStats* const stats_;
+  // Members of the |stats_| object, equivalent to |stats_->Members()|.
+  const std::vector<const webrtc::RTCStatsMemberInterface*> stats_members_;
+};
+
+class RTCStatsMember : public blink::WebRTCStatsMember {
+ public:
+  RTCStatsMember(const scoped_refptr<const webrtc::RTCStatsReport>& stats_owner,
+                 const webrtc::RTCStatsMemberInterface* member);
+  ~RTCStatsMember() override;
+
+  blink::WebString name() const override;
+  blink::WebRTCStatsMemberType type() const override;
+
+  int32_t valueInt32() const override;
+  uint32_t valueUint32() const override;
+  int64_t valueInt64() const override;
+  uint64_t valueUint64() const override;
+  double valueDouble() const override;
+  blink::WebString valueString() const override;
+  blink::WebVector<int32_t> valueSequenceInt32() const override;
+  blink::WebVector<uint32_t> valueSequenceUint32() const override;
+  blink::WebVector<int64_t> valueSequenceInt64() const override;
+  blink::WebVector<uint64_t> valueSequenceUint64() const override;
+  blink::WebVector<double> valueSequenceDouble() const override;
+  blink::WebVector<blink::WebString> valueSequenceString() const override;
+
+ private:
+  // Reference to keep the report that owns |member_|'s stats object alive.
+  const scoped_refptr<const webrtc::RTCStatsReport> stats_owner_;
+  // Pointer to member of a stats object that is owned by |stats_owner_|.
+  const webrtc::RTCStatsMemberInterface* const member_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_MEDIA_WEBRTC_RTC_STATS_H_

third_party/WebKit/public/BUILD.gn

@@ -266,6 +266,7 @@ source_set("blink_headers") {
     "platform/WebRTCPeerConnectionHandlerClient.h",
     "platform/WebRTCSessionDescription.h",
     "platform/WebRTCSessionDescriptionRequest.h",
+    "platform/WebRTCStats.h",
     "platform/WebRTCStatsRequest.h",
     "platform/WebRTCStatsResponse.h",
     "platform/WebRTCVoidRequest.h",

third_party/WebKit/public/platform/WebRTCStats.h

+// 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.
+
+#ifndef WebRTCStats_h
+#define WebRTCStats_h
+
+#include "WebCommon.h"
+#include "WebString.h"
+#include "WebVector.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace blink {
+
+class WebRTCStats;
+class WebRTCStatsMember;
+
+enum WebRTCStatsMemberType {
+    WebRTCStatsMemberTypeInt32, // int32_t
+    WebRTCStatsMemberTypeUint32, // uint32_t
+    WebRTCStatsMemberTypeInt64, // int64_t
+    WebRTCStatsMemberTypeUint64, // uint64_t
+    WebRTCStatsMemberTypeDouble, // double
+    WebRTCStatsMemberTypeString, // WebString
+
+    WebRTCStatsMemberTypeSequenceInt32, // WebVector<int32_t>
+    WebRTCStatsMemberTypeSequenceUint32, // WebVector<uint32_t>
+    WebRTCStatsMemberTypeSequenceInt64, // WebVector<int64_t>
+    WebRTCStatsMemberTypeSequenceUint64, // WebVector<uint64_t>
+    WebRTCStatsMemberTypeSequenceDouble, // WebVector<double>
+    WebRTCStatsMemberTypeSequenceString, // WebVector<WebString>
+};
+
+class WebRTCStatsReport {
+public:
+    virtual ~WebRTCStatsReport() {}
+
+    // The next stats object, or null if the end has been reached.
+    virtual std::unique_ptr<WebRTCStats> next() = 0;
+};
+
+class WebRTCStats {
+public:
+    virtual ~WebRTCStats() {}
+
+    virtual WebString id() const = 0;
+    virtual WebString type() const = 0;
+    virtual double timestamp() const = 0;
+
+    virtual size_t membersCount() const = 0;
+    virtual std::unique_ptr<WebRTCStatsMember> getMember(size_t) const = 0;
+};
+
+class WebRTCStatsMember {
+public:
+    virtual ~WebRTCStatsMember() {}
+
+    virtual WebString name() const = 0;
+    virtual WebRTCStatsMemberType type() const = 0;
+
+    // Value getters. No conversion is performed; the function must match the member's |type|.
+    virtual int32_t valueInt32() const = 0;
+    virtual uint32_t valueUint32() const = 0;
+    virtual int64_t valueInt64() const = 0;
+    virtual uint64_t valueUint64() const = 0;
+    virtual double valueDouble() const = 0;
+    virtual WebString valueString() const = 0;
+    virtual WebVector<int32_t> valueSequenceInt32() const = 0;
+    virtual WebVector<uint32_t> valueSequenceUint32() const = 0;
+    virtual WebVector<int64_t> valueSequenceInt64() const = 0;
+    virtual WebVector<uint64_t> valueSequenceUint64() const = 0;
+    virtual WebVector<double> valueSequenceDouble() const = 0;
+    virtual WebVector<WebString> valueSequenceString() const = 0;
+};
+
+} // namespace blink
+
+#endif // WebRTCStats_h