WebRTCPeerConnectionHandler::getStats for the new stats collector API

content/renderer/media/rtc_peer_connection_handler_unittest.cc

 // Copyright (c) 2012 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_peer_connection_handler.h"
 
 #include <stddef.h>
 
 #include <memory>
+#include <set>
 #include <string>
 #include <vector>
 
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "content/child/child_process.h"
@@ skipping 23 matching lines @@
 #include "third_party/WebKit/public/platform/WebRTCDataChannelInit.h"
 #include "third_party/WebKit/public/platform/WebRTCICECandidate.h"
 #include "third_party/WebKit/public/platform/WebRTCPeerConnectionHandlerClient.h"
 #include "third_party/WebKit/public/platform/WebRTCSessionDescription.h"
 #include "third_party/WebKit/public/platform/WebRTCSessionDescriptionRequest.h"
 #include "third_party/WebKit/public/platform/WebRTCStatsRequest.h"
 #include "third_party/WebKit/public/platform/WebRTCVoidRequest.h"
 #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";
 
 using blink::WebRTCPeerConnectionHandlerClient;
 using testing::NiceMock;
 using testing::_;
 using testing::Ref;
 using testing::SaveArg;
 
@@ skipping 118 matching lines @@
       TrackIceGatheringStateChange,
       void(RTCPeerConnectionHandler* pc_handler,
            WebRTCPeerConnectionHandlerClient::ICEGatheringState state));
   MOCK_METHOD1(TrackOnRenegotiationNeeded,
                void(RTCPeerConnectionHandler* pc_handler));
   MOCK_METHOD2(TrackCreateDTMFSender,
                void(RTCPeerConnectionHandler* pc_handler,
                      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(
       WebRTCPeerConnectionHandlerClient* client,
       PeerConnectionDependencyFactory* dependency_factory)
       : RTCPeerConnectionHandler(client, dependency_factory) {
   }
 
   MockPeerConnectionImpl* native_peer_connection() {
     return static_cast<MockPeerConnectionImpl*>(
@@ skipping 428 matching lines @@
   scoped_refptr<MockRTCStatsRequest> request(
       new rtc::RefCountedObject<MockRTCStatsRequest>());
   request->setSelector(component);
   pc_handler_->getStats(request.get());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, request->result()->report_count());
 
   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);
+      std::set<blink::WebRTCStatsMemberType> members;
+      for (size_t i = 0; i < stats->membersCount(); ++i) {
+        std::unique_ptr<blink::WebRTCStatsMember> member =
+            stats->getMember(i);
+        EXPECT_TRUE(member->isDefined());
+        members.insert(member->type());
+        switch (member->type()) {
+          case blink::WebRTCStatsMemberTypeInt32:
+            EXPECT_EQ(member->valueInt32(), static_cast<int32_t>(42));
+            break;
+          case blink::WebRTCStatsMemberTypeUint32:
+            EXPECT_EQ(member->valueUint32(), static_cast<uint32_t>(42));
+            break;
+          case blink::WebRTCStatsMemberTypeInt64:
+            EXPECT_EQ(member->valueInt64(), static_cast<int64_t>(42));
+            break;
+          case blink::WebRTCStatsMemberTypeUint64:
+            EXPECT_EQ(member->valueUint64(), static_cast<uint64_t>(42));
+            break;
+          case blink::WebRTCStatsMemberTypeDouble:
+            EXPECT_EQ(member->valueDouble(), 42.0);
+            break;
+          case blink::WebRTCStatsMemberTypeString:
+            EXPECT_EQ(member->valueString(), blink::WebString::fromUTF8("42"));
+            break;
+          case blink::WebRTCStatsMemberTypeSequenceInt32:
+            ExpectSequenceEquals(member->valueSequenceInt32(),
+                                 static_cast<int32_t>(42));
+            break;
+          case blink::WebRTCStatsMemberTypeSequenceUint32:
+            ExpectSequenceEquals(member->valueSequenceUint32(),
+                                 static_cast<uint32_t>(42));
+            break;
+          case blink::WebRTCStatsMemberTypeSequenceInt64:
+            ExpectSequenceEquals(member->valueSequenceInt64(),
+                                 static_cast<int64_t>(42));
+            break;
+          case blink::WebRTCStatsMemberTypeSequenceUint64:
+            ExpectSequenceEquals(member->valueSequenceUint64(),
+                                 static_cast<uint64_t>(42));
+            break;
+          case blink::WebRTCStatsMemberTypeSequenceDouble:
+            ExpectSequenceEquals(member->valueSequenceDouble(), 42.0);
+            break;
+          case blink::WebRTCStatsMemberTypeSequenceString:
+            ExpectSequenceEquals(member->valueSequenceString(),
+                                 blink::WebString::fromUTF8("42"));
+            break;
+          default:
+            NOTREACHED();
+        }
+      }
+      EXPECT_EQ(members.size(), static_cast<size_t>(12));
+    } else {
+      NOTREACHED();
+    }
+  }
+  EXPECT_EQ(undefined_stats_count, 1);
+  EXPECT_EQ(defined_stats_count, 1);
+}
+
 TEST_F(RTCPeerConnectionHandlerTest, OnSignalingChange) {
   testing::InSequence sequence;
 
   webrtc::PeerConnectionInterface::SignalingState new_state =
       webrtc::PeerConnectionInterface::kHaveRemoteOffer;
   EXPECT_CALL(*mock_tracker_.get(), TrackSignalingStateChange(
       pc_handler_.get(),
       WebRTCPeerConnectionHandlerClient::SignalingStateHaveRemoteOffer));
   EXPECT_CALL(*mock_client_.get(), didChangeSignalingState(
       WebRTCPeerConnectionHandlerClient::SignalingStateHaveRemoteOffer));
@@ skipping 409 matching lines @@
                                     testing::Ref(tracks[0])));
 
   std::unique_ptr<blink::WebRTCDTMFSenderHandler> sender(
       pc_handler_->createDTMFSender(tracks[0]));
   EXPECT_TRUE(sender.get());
 
   StopAllTracks(local_stream);
 }
 
 }  // namespace content