RTCStatsIntegrationTest added.

webrtc/api/rtcstatscollector_unittest.cc

 /*
  *  Copyright 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/api/rtcstatscollector.h"
 
 #include <memory>
 #include <ostream>
 #include <string>
 #include <vector>
 
 #include "webrtc/api/mediastream.h"
 #include "webrtc/api/mediastreamtrack.h"
 #include "webrtc/api/jsepsessiondescription.h"
 #include "webrtc/api/stats/rtcstats_objects.h"
 #include "webrtc/api/stats/rtcstatsreport.h"
 #include "webrtc/api/test/mock_datachannel.h"
 #include "webrtc/api/test/mock_peerconnection.h"
 #include "webrtc/api/test/mock_webrtcsession.h"
+#include "webrtc/api/test/rtcstatsobtainer.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/fakeclock.h"
 #include "webrtc/base/fakesslidentity.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/socketaddress.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/base/timedelta.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
@@ skipping 424 matching lines @@
   rtc::Thread* const worker_thread_;
   rtc::Thread* const network_thread_;
 
   rtc::CriticalSection lock_;
   rtc::scoped_refptr<const RTCStatsReport> delivered_report_;
   int produced_on_signaling_thread_ = 0;
   int produced_on_worker_thread_ = 0;
   int produced_on_network_thread_ = 0;
 };
 
-class StatsCallback : public RTCStatsCollectorCallback {
- public:
-  static rtc::scoped_refptr<StatsCallback> Create(
-      rtc::scoped_refptr<const RTCStatsReport>* report_ptr = nullptr) {
-    return rtc::scoped_refptr<StatsCallback>(
-        new rtc::RefCountedObject<StatsCallback>(report_ptr));
-  }
-
-  void OnStatsDelivered(
-      const rtc::scoped_refptr<const RTCStatsReport>& report) override {
-    EXPECT_TRUE(thread_checker_.CalledOnValidThread());
-    report_ = report;
-    if (report_ptr_)
-      *report_ptr_ = report_;
-  }
-
-  rtc::scoped_refptr<const RTCStatsReport> report() const {
-    EXPECT_TRUE(thread_checker_.CalledOnValidThread());
-    return report_;
-  }
-
- protected:
-  explicit StatsCallback(rtc::scoped_refptr<const RTCStatsReport>* report_ptr)
-      : report_ptr_(report_ptr) {}
-
- private:
-  rtc::ThreadChecker thread_checker_;
-  rtc::scoped_refptr<const RTCStatsReport> report_;
-  rtc::scoped_refptr<const RTCStatsReport>* report_ptr_;
-};
-
 class RTCStatsCollectorTest : public testing::Test {
  public:
   RTCStatsCollectorTest()
     : test_(new rtc::RefCountedObject<RTCStatsCollectorTestHelper>()),
       collector_(RTCStatsCollector::Create(
           &test_->pc(), 50 * rtc::kNumMicrosecsPerMillisec)) {
   }
 
   rtc::scoped_refptr<const RTCStatsReport> GetStatsReport() {
-    rtc::scoped_refptr<StatsCallback> callback = StatsCallback::Create();
+    rtc::scoped_refptr<RTCStatsObtainer> callback = RTCStatsObtainer::Create();
     collector_->GetStatsReport(callback);
     EXPECT_TRUE_WAIT(callback->report(), kGetStatsReportTimeoutMs);
     int64_t after = rtc::TimeUTCMicros();
     for (const RTCStats& stats : *callback->report()) {
       EXPECT_LE(stats.timestamp_us(), after);
     }
     return callback->report();
   }
 
   const RTCIceCandidateStats* ExpectReportContainsCandidate(
@@ skipping 190 matching lines @@
               data_channel.bytes_received());
   }
 
  protected:
   rtc::scoped_refptr<RTCStatsCollectorTestHelper> test_;
   rtc::scoped_refptr<RTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTest, SingleCallback) {
   rtc::scoped_refptr<const RTCStatsReport> result;
-  collector_->GetStatsReport(StatsCallback::Create(&result));
+  collector_->GetStatsReport(RTCStatsObtainer::Create(&result));
   EXPECT_TRUE_WAIT(result, kGetStatsReportTimeoutMs);
 }
 
 TEST_F(RTCStatsCollectorTest, MultipleCallbacks) {
   rtc::scoped_refptr<const RTCStatsReport> a;
   rtc::scoped_refptr<const RTCStatsReport> b;
   rtc::scoped_refptr<const RTCStatsReport> c;
-  collector_->GetStatsReport(StatsCallback::Create(&a));
-  collector_->GetStatsReport(StatsCallback::Create(&b));
-  collector_->GetStatsReport(StatsCallback::Create(&c));
+  collector_->GetStatsReport(RTCStatsObtainer::Create(&a));
+  collector_->GetStatsReport(RTCStatsObtainer::Create(&b));
+  collector_->GetStatsReport(RTCStatsObtainer::Create(&c));
   EXPECT_TRUE_WAIT(a, kGetStatsReportTimeoutMs);
   EXPECT_TRUE_WAIT(b, kGetStatsReportTimeoutMs);
   EXPECT_TRUE_WAIT(c, kGetStatsReportTimeoutMs);
   EXPECT_EQ(a.get(), b.get());
   EXPECT_EQ(b.get(), c.get());
 }
 
 TEST_F(RTCStatsCollectorTest, CachedStatsReports) {
   // Caching should ensure |a| and |b| are the same report.
   rtc::scoped_refptr<const RTCStatsReport> a = GetStatsReport();
   rtc::scoped_refptr<const RTCStatsReport> b = GetStatsReport();
   EXPECT_EQ(a.get(), b.get());
   // Invalidate cache by clearing it.
   collector_->ClearCachedStatsReport();
   rtc::scoped_refptr<const RTCStatsReport> c = GetStatsReport();
   EXPECT_NE(b.get(), c.get());
   // Invalidate cache by advancing time.
   test_->fake_clock().AdvanceTime(rtc::TimeDelta::FromMilliseconds(51));
   rtc::scoped_refptr<const RTCStatsReport> d = GetStatsReport();
   EXPECT_TRUE(d);
   EXPECT_NE(c.get(), d.get());
 }
 
 TEST_F(RTCStatsCollectorTest, MultipleCallbacksWithInvalidatedCacheInBetween) {
   rtc::scoped_refptr<const RTCStatsReport> a;
   rtc::scoped_refptr<const RTCStatsReport> b;
   rtc::scoped_refptr<const RTCStatsReport> c;
-  collector_->GetStatsReport(StatsCallback::Create(&a));
-  collector_->GetStatsReport(StatsCallback::Create(&b));
+  collector_->GetStatsReport(RTCStatsObtainer::Create(&a));
+  collector_->GetStatsReport(RTCStatsObtainer::Create(&b));
   // Cache is invalidated after 50 ms.
   test_->fake_clock().AdvanceTime(rtc::TimeDelta::FromMilliseconds(51));
-  collector_->GetStatsReport(StatsCallback::Create(&c));
+  collector_->GetStatsReport(RTCStatsObtainer::Create(&c));
   EXPECT_TRUE_WAIT(a, kGetStatsReportTimeoutMs);
   EXPECT_TRUE_WAIT(b, kGetStatsReportTimeoutMs);
   EXPECT_TRUE_WAIT(c, kGetStatsReportTimeoutMs);
   EXPECT_EQ(a.get(), b.get());
   // The act of doing |AdvanceTime| processes all messages. If this was not the
   // case we might not require |c| to be fresher than |b|.
   EXPECT_NE(c.get(), b.get());
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCCertificateStatsSingle) {
@@ skipping 879 matching lines @@
   rtc::scoped_refptr<FakeRTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
   collector_->VerifyThreadUsageAndResultsMerging();
 }
 
 }  // namespace
 
 }  // namespace webrtc