Replace voe_conference_test.

webrtc/pc/test/mockpeerconnectionobservers.h

 /*
  *  Copyright 2012 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.
  */
 
@@ skipping 107 matching lines @@
       if (r->type() == StatsReport::kStatsReportTypeSsrc) {
         stats_.timestamp = r->timestamp();
         GetIntValue(r, StatsReport::kStatsValueNameAudioOutputLevel,
             &stats_.audio_output_level);
         GetIntValue(r, StatsReport::kStatsValueNameAudioInputLevel,
             &stats_.audio_input_level);
         GetIntValue(r, StatsReport::kStatsValueNameBytesReceived,
             &stats_.bytes_received);
         GetIntValue(r, StatsReport::kStatsValueNameBytesSent,
             &stats_.bytes_sent);
+        GetInt64Value(r, StatsReport::kStatsValueNameCaptureStartNtpTimeMs,
+            &stats_.capture_start_ntp_time);
       } else if (r->type() == StatsReport::kStatsReportTypeBwe) {
         stats_.timestamp = r->timestamp();
         GetIntValue(r, StatsReport::kStatsValueNameAvailableReceiveBandwidth,
             &stats_.available_receive_bandwidth);
       } else if (r->type() == StatsReport::kStatsReportTypeComponent) {
         stats_.timestamp = r->timestamp();
         GetStringValue(r, StatsReport::kStatsValueNameDtlsCipher,
             &stats_.dtls_cipher);
         GetStringValue(r, StatsReport::kStatsValueNameSrtpCipher,
             &stats_.srtp_cipher);
@@ skipping 18 matching lines @@
   int BytesReceived() const {
     RTC_CHECK(called_);
     return stats_.bytes_received;
   }
 
   int BytesSent() const {
     RTC_CHECK(called_);
     return stats_.bytes_sent;
   }
 
+  int64_t CaptureStartNtpTime() const {
+    RTC_CHECK(called_);
+    return stats_.capture_start_ntp_time;
+  }
+
   int AvailableReceiveBandwidth() const {
     RTC_CHECK(called_);
     return stats_.available_receive_bandwidth;
   }
 
   std::string DtlsCipher() const {
     RTC_CHECK(called_);
     return stats_.dtls_cipher;
   }
 
   std::string SrtpCipher() const {
     RTC_CHECK(called_);
     return stats_.srtp_cipher;
   }
 
  private:
   bool GetIntValue(const StatsReport* report,
                    StatsReport::StatsValueName name,
                    int* value) {
     const StatsReport::Value* v = report->FindValue(name);
     if (v) {
       // TODO(tommi): We should really just be using an int here :-/
       *value = rtc::FromString<int>(v->ToString());
     }
     return v != nullptr;
   }
 
+  bool GetInt64Value(const StatsReport* report,
+                   StatsReport::StatsValueName name,
+                   int64_t* value) {
+    const StatsReport::Value* v = report->FindValue(name);
+    if (v) {
+      // TODO(tommi): We should really just be using an int here :-/
+      *value = rtc::FromString<int64_t>(v->ToString());
+    }
+    return v != nullptr;
+  }
+
   bool GetStringValue(const StatsReport* report,
                       StatsReport::StatsValueName name,
                       std::string* value) {
     const StatsReport::Value* v = report->FindValue(name);
     if (v)
       *value = v->ToString();
     return v != nullptr;
   }
 
   bool called_;
   struct {
     void Clear() {
       number_of_reports = 0;
       timestamp = 0;
       audio_output_level = 0;
       audio_input_level = 0;
       bytes_received = 0;
       bytes_sent = 0;
+      capture_start_ntp_time = 0;
       available_receive_bandwidth = 0;
       dtls_cipher.clear();
       srtp_cipher.clear();
     }
 
     size_t number_of_reports;
     double timestamp;
     int audio_output_level;
     int audio_input_level;
     int bytes_received;
     int bytes_sent;
+    int64_t capture_start_ntp_time;
     int available_receive_bandwidth;
     std::string dtls_cipher;
     std::string srtp_cipher;
   } stats_;
 };
 
 // Helper class that just stores the report from the callback.
 class MockRTCStatsCollectorCallback : public webrtc::RTCStatsCollectorCallback {
  public:
   rtc::scoped_refptr<const RTCStatsReport> report() { return report_; }
 
   bool called() const { return called_; }
 
  protected:
   void OnStatsDelivered(
       const rtc::scoped_refptr<const RTCStatsReport>& report) override {
     report_ = report;
     called_ = true;
   }
 
  private:
   bool called_ = false;
   rtc::scoped_refptr<const RTCStatsReport> report_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_PC_TEST_MOCKPEERCONNECTIONOBSERVERS_H_