WebRTCPeerConnectionHandler::getStats for the new stats collector API

content/renderer/media/rtc_peer_connection_handler_unittest.cc

Index: content/renderer/media/rtc_peer_connection_handler_unittest.cc
diff --git a/content/renderer/media/rtc_peer_connection_handler_unittest.cc b/content/renderer/media/rtc_peer_connection_handler_unittest.cc
index ac55922d2ca8c90e12d41119b5857dfc76bd5fac..985774c6696dc360d26cca314546333eb96925f9 100644
--- a/content/renderer/media/rtc_peer_connection_handler_unittest.cc
+++ b/content/renderer/media/rtc_peer_connection_handler_unittest.cc
@@ -50,6 +50,7 @@
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebHeap.h"
 #include "third_party/webrtc/api/peerconnectioninterface.h"
+#include "third_party/webrtc/stats/test/rtcteststats.h"
 
 static const char kDummySdp[] = "dummy sdp";
 static const char kDummySdpType[] = "dummy type";
@@ -188,6 +189,39 @@ class MockPeerConnectionTracker : public PeerConnectionTracker {
                      const blink::WebMediaStreamTrack& track));
 };
 
+class MockRTCStatsReportCallback : public blink::WebRTCStatsReportCallback {
+ public:
+  MockRTCStatsReportCallback(std::unique_ptr<blink::WebRTCStatsReport>* result)
+      : main_thread_(base::ThreadTaskRunnerHandle::Get()),
+        result_(result) {
+    DCHECK(result_);
+  }
+
+  void OnStatsDelivered(
+      std::unique_ptr<blink::WebRTCStatsReport> report) override {
+    EXPECT_TRUE(main_thread_->BelongsToCurrentThread());
+    EXPECT_TRUE(report);
+    result_->reset(report.release());
+  }
+
+ private:
+  scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
+  std::unique_ptr<blink::WebRTCStatsReport>* result_;
+};
+
+template<typename T>
+std::vector<T> ToSequence(T value) {
+  std::vector<T> vec;
+  vec.push_back(value);
+  return vec;
+}
+
+template<typename T>
+void ExpectSequenceEquals(const blink::WebVector<T>& sequence, T value) {
+  EXPECT_EQ(sequence.size(), static_cast<size_t>(1));
+  EXPECT_EQ(sequence[0], value);
+}
+
 class RTCPeerConnectionHandlerUnderTest : public RTCPeerConnectionHandler {
  public:
   RTCPeerConnectionHandlerUnderTest(
@@ -636,6 +670,123 @@ TEST_F(RTCPeerConnectionHandlerTest, GetStatsWithBadSelector) {
   StopAllTracks(local_stream);
 }
 
+TEST_F(RTCPeerConnectionHandlerTest, GetRTCStats) {
+  rtc::scoped_refptr<webrtc::RTCStatsReport> report =
+      webrtc::RTCStatsReport::Create();
+
+  report->AddStats(std::unique_ptr<const webrtc::RTCStats>(
+      new webrtc::RTCTestStats("RTCUndefinedStats", 1000)));
+
+  std::unique_ptr<webrtc::RTCTestStats> stats_defined_members(
+      new webrtc::RTCTestStats("RTCDefinedStats", 2000));
+  stats_defined_members->m_int32 = 42;
+  stats_defined_members->m_uint32 = 42;
+  stats_defined_members->m_int64 = 42;
+  stats_defined_members->m_uint64 = 42;
+  stats_defined_members->m_double = 42.0;
+  stats_defined_members->m_string = "42";
+  stats_defined_members->m_sequence_int32 = ToSequence<int32_t>(42);
+  stats_defined_members->m_sequence_uint32 = ToSequence<uint32_t>(42);
+  stats_defined_members->m_sequence_int64 = ToSequence<int64_t>(42);
+  stats_defined_members->m_sequence_uint64 = ToSequence<uint64_t>(42);
+  stats_defined_members->m_sequence_double = ToSequence<double>(42);
+  stats_defined_members->m_sequence_string = ToSequence<std::string>("42");
+  report->AddStats(std::unique_ptr<const webrtc::RTCStats>(
+      stats_defined_members.release()));
+
+  pc_handler_->native_peer_connection()->SetGetStatsReport(report);
+  std::unique_ptr<blink::WebRTCStatsReport> result;
+  pc_handler_->getStats(std::unique_ptr<blink::WebRTCStatsReportCallback>(
+      new MockRTCStatsReportCallback(&result)));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(result);
+
+  int undefined_stats_count = 0;
+  int defined_stats_count = 0;
+  for (std::unique_ptr<blink::WebRTCStats> stats = result->next(); stats;
+       stats.reset(result->next().release())) {
+    EXPECT_EQ(stats->type().utf8(), webrtc::RTCTestStats::kType);
+    if (stats->id().utf8() == "RTCUndefinedStats") {
+      ++undefined_stats_count;
+      EXPECT_EQ(stats->timestamp(), 1.0);
+      for (size_t i = 0; i < stats->membersCount(); ++i) {
+        EXPECT_FALSE(stats->getMember(i)->isDefined());
+      }
+    } else if (stats->id().utf8() == "RTCDefinedStats") {
+      ++defined_stats_count;
+      EXPECT_EQ(stats->timestamp(), 2.0);
+      uint32_t members_bitmap = 0x0;

[hta - Chromium, 2016/09/20 16:26:46]

This is a test, so readability is more important than speed.

I suggest you use a std::set<int> instead.
Perhaps even std::set<blink::WebRTCStatsMemberType> would work, in which case
you can set the set member outside of the switch, making the whole thing shorter
by 12 lines?

[hbos_chromium, 2016/09/20 20:18:39]

Good idea! Done.

+      for (size_t i = 0; i < stats->membersCount(); ++i) {
+        std::unique_ptr<blink::WebRTCStatsMember> member =
+            stats->getMember(i);
+        EXPECT_TRUE(member->isDefined());
+        switch (member->type()) {
+          case blink::WebRTCStatsMemberTypeInt32:
+            EXPECT_EQ(member->valueInt32(), static_cast<int32_t>(42));
+            members_bitmap |= (1 << 0);
+            break;
+          case blink::WebRTCStatsMemberTypeUint32:
+            EXPECT_EQ(member->valueUint32(), static_cast<uint32_t>(42));
+            members_bitmap |= (1 << 1);
+            break;
+          case blink::WebRTCStatsMemberTypeInt64:
+            EXPECT_EQ(member->valueInt64(), static_cast<int64_t>(42));
+            members_bitmap |= (1 << 2);
+            break;
+          case blink::WebRTCStatsMemberTypeUint64:
+            EXPECT_EQ(member->valueUint64(), static_cast<uint64_t>(42));
+            members_bitmap |= (1 << 3);
+            break;
+          case blink::WebRTCStatsMemberTypeDouble:
+            EXPECT_EQ(member->valueDouble(), 42.0);
+            members_bitmap |= (1 << 4);
+            break;
+          case blink::WebRTCStatsMemberTypeString:
+            EXPECT_EQ(member->valueString(), blink::WebString::fromUTF8("42"));
+            members_bitmap |= (1 << 5);
+            break;
+          case blink::WebRTCStatsMemberTypeSequenceInt32:
+            ExpectSequenceEquals(member->valueSequenceInt32(),
+                                 static_cast<int32_t>(42));
+            members_bitmap |= (1 << 6);
+            break;
+          case blink::WebRTCStatsMemberTypeSequenceUint32:
+            ExpectSequenceEquals(member->valueSequenceUint32(),
+                                 static_cast<uint32_t>(42));
+            members_bitmap |= (1 << 7);
+            break;
+          case blink::WebRTCStatsMemberTypeSequenceInt64:
+            ExpectSequenceEquals(member->valueSequenceInt64(),
+                                 static_cast<int64_t>(42));
+            members_bitmap |= (1 << 8);
+            break;
+          case blink::WebRTCStatsMemberTypeSequenceUint64:
+            ExpectSequenceEquals(member->valueSequenceUint64(),
+                                 static_cast<uint64_t>(42));
+            members_bitmap |= (1 << 9);
+            break;
+          case blink::WebRTCStatsMemberTypeSequenceDouble:
+            ExpectSequenceEquals(member->valueSequenceDouble(), 42.0);
+            members_bitmap |= (1 << 10);
+            break;
+          case blink::WebRTCStatsMemberTypeSequenceString:
+            ExpectSequenceEquals(member->valueSequenceString(),
+                                 blink::WebString::fromUTF8("42"));
+            members_bitmap |= (1 << 11);
+            break;
+          default:
+            NOTREACHED();
+        }
+      }
+      EXPECT_EQ(members_bitmap, static_cast<uint32_t>(0xFFF));

[hta - Chromium, 2016/09/20 16:26:45]

With a set, you can just expect the number of members of the set to be 12.

[hbos_chromium, 2016/09/20 20:18:39]

Done.

+    } else {
+      NOTREACHED();
+    }
+  }
+  EXPECT_EQ(undefined_stats_count, 1);
+  EXPECT_EQ(defined_stats_count, 1);
+}
+
 TEST_F(RTCPeerConnectionHandlerTest, OnSignalingChange) {
   testing::InSequence sequence;