Revert of Moving MediaStreamSignaling logic into PeerConnection.

talk/app/webrtc/statscollector.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 12 matching lines @@
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "talk/app/webrtc/statscollector.h"
 
 #include <utility>
 #include <vector>
 
-#include "talk/app/webrtc/peerconnection.h"
 #include "talk/session/media/channel.h"
 #include "webrtc/base/base64.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/timing.h"
 
 using rtc::scoped_ptr;
 
 namespace webrtc {
 namespace {
@@ skipping 306 matching lines @@
     case rtc::ADAPTER_TYPE_VPN:
       return STATSREPORT_ADAPTER_TYPE_VPN;
     case rtc::ADAPTER_TYPE_LOOPBACK:
       return STATSREPORT_ADAPTER_TYPE_LOOPBACK;
     default:
       RTC_DCHECK(false);
       return "";
   }
 }
 
-StatsCollector::StatsCollector(PeerConnection* pc)
-    : pc_(pc), stats_gathering_started_(0) {
-  RTC_DCHECK(pc_);
+StatsCollector::StatsCollector(WebRtcSession* session)
+    : session_(session),
+      stats_gathering_started_(0) {
+  RTC_DCHECK(session_);
 }
 
 StatsCollector::~StatsCollector() {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
 }
 
 double StatsCollector::GetTimeNow() {
   return rtc::Timing::WallTimeNow() * rtc::kNumMillisecsPerSec;
 }
 
 // Adds a MediaStream with tracks that can be used as a |selector| in a call
 // to GetStats.
 void StatsCollector::AddStream(MediaStreamInterface* stream) {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
   RTC_DCHECK(stream != NULL);
 
   CreateTrackReports<AudioTrackVector>(stream->GetAudioTracks(),
                                        &reports_, track_ids_);
   CreateTrackReports<VideoTrackVector>(stream->GetVideoTracks(),
                                        &reports_, track_ids_);
 }
 
 void StatsCollector::AddLocalAudioTrack(AudioTrackInterface* audio_track,
                                         uint32_t ssrc) {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
   RTC_DCHECK(audio_track != NULL);
 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON))
   for (const auto& track : local_audio_tracks_)
     RTC_DCHECK(track.first != audio_track || track.second != ssrc);
 #endif
 
   local_audio_tracks_.push_back(std::make_pair(audio_track, ssrc));
 
   // Create the kStatsReportTypeTrack report for the new track if there is no
   // report yet.
@@ skipping 11 matching lines @@
   RTC_DCHECK(audio_track != NULL);
   local_audio_tracks_.erase(std::remove_if(local_audio_tracks_.begin(),
       local_audio_tracks_.end(),
       [audio_track, ssrc](const LocalAudioTrackVector::value_type& track) {
         return track.first == audio_track && track.second == ssrc;
       }));
 }
 
 void StatsCollector::GetStats(MediaStreamTrackInterface* track,
                               StatsReports* reports) {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
   RTC_DCHECK(reports != NULL);
   RTC_DCHECK(reports->empty());
 
   rtc::Thread::ScopedDisallowBlockingCalls no_blocking_calls;
 
   if (!track) {
     reports->reserve(reports_.size());
     for (auto* r : reports_)
       reports->push_back(r);
     return;
   }
 
   StatsReport* report = reports_.Find(StatsReport::NewTypedId(
-      StatsReport::kStatsReportTypeSession, pc_->session()->id()));
+      StatsReport::kStatsReportTypeSession, session_->id()));
   if (report)
     reports->push_back(report);
 
   report = reports_.Find(StatsReport::NewTypedId(
       StatsReport::kStatsReportTypeTrack, track->id()));
 
   if (!report)
     return;
 
   reports->push_back(report);
 
   std::string track_id;
   for (const auto* r : reports_) {
     if (r->type() != StatsReport::kStatsReportTypeSsrc)
       continue;
 
     const StatsReport::Value* v =
         r->FindValue(StatsReport::kStatsValueNameTrackId);
     if (v && v->string_val() == track->id())
       reports->push_back(r);
   }
 }
 
 void
 StatsCollector::UpdateStats(PeerConnectionInterface::StatsOutputLevel level) {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
   double time_now = GetTimeNow();
   // Calls to UpdateStats() that occur less than kMinGatherStatsPeriod number of
   // ms apart will be ignored.
   const double kMinGatherStatsPeriod = 50;
   if (stats_gathering_started_ != 0 &&
       stats_gathering_started_ + kMinGatherStatsPeriod > time_now) {
     return;
   }
   stats_gathering_started_ = time_now;
 
-  if (pc_->session()) {
+  if (session_) {
     // TODO(tommi): All of these hop over to the worker thread to fetch
     // information.  We could use an AsyncInvoker to run all of these and post
     // the information back to the signaling thread where we can create and
     // update stats reports.  That would also clean up the threading story a bit
     // since we'd be creating/updating the stats report objects consistently on
     // the same thread (this class has no locks right now).
     ExtractSessionInfo();
     ExtractVoiceInfo();
     ExtractVideoInfo(level);
     ExtractDataInfo();
     UpdateTrackReports();
   }
 }
 
-StatsReport* StatsCollector::PrepareReport(
-    bool local,
-    uint32_t ssrc,
-    const StatsReport::Id& transport_id,
-    StatsReport::Direction direction) {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+StatsReport* StatsCollector::PrepareReport(bool local,
+                                           uint32_t ssrc,
+                                           const StatsReport::Id& transport_id,
+                                           StatsReport::Direction direction) {
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
   StatsReport::Id id(StatsReport::NewIdWithDirection(
       local ? StatsReport::kStatsReportTypeSsrc
             : StatsReport::kStatsReportTypeRemoteSsrc,
       rtc::ToString<uint32_t>(ssrc), direction));
   StatsReport* report = reports_.Find(id);
 
   // Use the ID of the track that is currently mapped to the SSRC, if any.
   std::string track_id;
   if (!GetTrackIdBySsrc(ssrc, &track_id, direction)) {
     if (!report) {
@@ skipping 18 matching lines @@
 
   report->AddInt64(StatsReport::kStatsValueNameSsrc, ssrc);
   report->AddString(StatsReport::kStatsValueNameTrackId, track_id);
   // Add the mapping of SSRC to transport.
   report->AddId(StatsReport::kStatsValueNameTransportId, transport_id);
   return report;
 }
 
 StatsReport* StatsCollector::AddOneCertificateReport(
     const rtc::SSLCertificate* cert, const StatsReport* issuer) {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
 
   // TODO(bemasc): Move this computation to a helper class that caches these
   // values to reduce CPU use in GetStats.  This will require adding a fast
   // SSLCertificate::Equals() method to detect certificate changes.
 
   std::string digest_algorithm;
   if (!cert->GetSignatureDigestAlgorithm(&digest_algorithm))
     return nullptr;
 
   rtc::scoped_ptr<rtc::SSLFingerprint> ssl_fingerprint(
@@ skipping 22 matching lines @@
   report->AddString(StatsReport::kStatsValueNameFingerprintAlgorithm,
                     digest_algorithm);
   report->AddString(StatsReport::kStatsValueNameDer, der_base64);
   if (issuer)
     report->AddId(StatsReport::kStatsValueNameIssuerId, issuer->id());
   return report;
 }
 
 StatsReport* StatsCollector::AddCertificateReports(
     const rtc::SSLCertificate* cert) {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
   // Produces a chain of StatsReports representing this certificate and the rest
   // of its chain, and adds those reports to |reports_|.  The return value is
   // the id of the leaf report.  The provided cert must be non-null, so at least
   // one report will always be provided and the returned string will never be
   // empty.
   RTC_DCHECK(cert != NULL);
 
   StatsReport* issuer = nullptr;
   rtc::scoped_ptr<rtc::SSLCertChain> chain;
   if (cert->GetChain(chain.accept())) {
@@ skipping 79 matching lines @@
     report->AddString(StatsReport::kStatsValueNameCandidateType,
                       IceCandidateTypeToStatsType(candidate.type()));
     report->AddString(StatsReport::kStatsValueNameCandidateTransportType,
                       candidate.protocol());
   }
 
   return report;
 }
 
 void StatsCollector::ExtractSessionInfo() {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
 
   // Extract information from the base session.
   StatsReport::Id id(StatsReport::NewTypedId(
-      StatsReport::kStatsReportTypeSession, pc_->session()->id()));
+      StatsReport::kStatsReportTypeSession, session_->id()));
   StatsReport* report = reports_.ReplaceOrAddNew(id);
   report->set_timestamp(stats_gathering_started_);
   report->AddBoolean(StatsReport::kStatsValueNameInitiator,
-                     pc_->session()->initiator());
+                     session_->initiator());
 
   cricket::SessionStats stats;
-  if (!pc_->session()->GetTransportStats(&stats)) {
+  if (!session_->GetTransportStats(&stats)) {
     return;
   }
 
   // Store the proxy map away for use in SSRC reporting.
   // TODO(tommi): This shouldn't be necessary if we post the stats back to the
   // signaling thread after fetching them on the worker thread, then just use
   // the proxy map directly from the session stats.
   // As is, if GetStats() failed, we could be using old (incorrect?) proxy
   // data.
   proxy_to_transport_ = stats.proxy_to_transport;
 
   for (const auto& transport_iter : stats.transport_stats) {
     // Attempt to get a copy of the certificates from the transport and
     // expose them in stats reports.  All channels in a transport share the
     // same local and remote certificates.
     //
     StatsReport::Id local_cert_report_id, remote_cert_report_id;
     rtc::scoped_refptr<rtc::RTCCertificate> certificate;
-    if (pc_->session()->GetLocalCertificate(
-            transport_iter.second.transport_name, &certificate)) {
+    if (session_->GetLocalCertificate(transport_iter.second.transport_name,
+                                      &certificate)) {
       StatsReport* r = AddCertificateReports(&(certificate->ssl_certificate()));
       if (r)
         local_cert_report_id = r->id();
     }
 
     rtc::scoped_ptr<rtc::SSLCertificate> cert;
-    if (pc_->session()->GetRemoteSSLCertificate(
-            transport_iter.second.transport_name, cert.accept())) {
+    if (session_->GetRemoteSSLCertificate(transport_iter.second.transport_name,
+                                          cert.accept())) {
       StatsReport* r = AddCertificateReports(cert.get());
       if (r)
         remote_cert_report_id = r->id();
     }
 
     for (const auto& channel_iter : transport_iter.second.channel_stats) {
       StatsReport::Id id(StatsReport::NewComponentId(
           transport_iter.second.transport_name, channel_iter.component));
       StatsReport* channel_report = reports_.ReplaceOrAddNew(id);
       channel_report->set_timestamp(stats_gathering_started_);
@@ skipping 30 matching lines @@
           channel_report->AddId(
               StatsReport::kStatsValueNameSelectedCandidatePairId,
               connection_report->id());
         }
       }
     }
   }
 }
 
 void StatsCollector::ExtractVoiceInfo() {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
 
-  if (!pc_->session()->voice_channel()) {
+  if (!session_->voice_channel()) {
     return;
   }
   cricket::VoiceMediaInfo voice_info;
-  if (!pc_->session()->voice_channel()->GetStats(&voice_info)) {
+  if (!session_->voice_channel()->GetStats(&voice_info)) {
     LOG(LS_ERROR) << "Failed to get voice channel stats.";
     return;
   }
 
   // TODO(tommi): The above code should run on the worker thread and post the
   // results back to the signaling thread, where we can add data to the reports.
   rtc::Thread::ScopedDisallowBlockingCalls no_blocking_calls;
 
-  StatsReport::Id transport_id(GetTransportIdFromProxy(
-      proxy_to_transport_, pc_->session()->voice_channel()->content_name()));
+  StatsReport::Id transport_id(GetTransportIdFromProxy(proxy_to_transport_,
+      session_->voice_channel()->content_name()));
   if (!transport_id.get()) {
     LOG(LS_ERROR) << "Failed to get transport name for proxy "
-                  << pc_->session()->voice_channel()->content_name();
+                  << session_->voice_channel()->content_name();
     return;
   }
 
   ExtractStatsFromList(voice_info.receivers, transport_id, this,
       StatsReport::kReceive);
   ExtractStatsFromList(voice_info.senders, transport_id, this,
       StatsReport::kSend);
 
   UpdateStatsFromExistingLocalAudioTracks();
 }
 
 void StatsCollector::ExtractVideoInfo(
     PeerConnectionInterface::StatsOutputLevel level) {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
 
-  if (!pc_->session()->video_channel())
+  if (!session_->video_channel())
     return;
 
   cricket::VideoMediaInfo video_info;
-  if (!pc_->session()->video_channel()->GetStats(&video_info)) {
+  if (!session_->video_channel()->GetStats(&video_info)) {
     LOG(LS_ERROR) << "Failed to get video channel stats.";
     return;
   }
 
   // TODO(tommi): The above code should run on the worker thread and post the
   // results back to the signaling thread, where we can add data to the reports.
   rtc::Thread::ScopedDisallowBlockingCalls no_blocking_calls;
 
-  StatsReport::Id transport_id(GetTransportIdFromProxy(
-      proxy_to_transport_, pc_->session()->video_channel()->content_name()));
+  StatsReport::Id transport_id(GetTransportIdFromProxy(proxy_to_transport_,
+      session_->video_channel()->content_name()));
   if (!transport_id.get()) {
     LOG(LS_ERROR) << "Failed to get transport name for proxy "
-                  << pc_->session()->video_channel()->content_name();
+                  << session_->video_channel()->content_name();
     return;
   }
   ExtractStatsFromList(video_info.receivers, transport_id, this,
       StatsReport::kReceive);
   ExtractStatsFromList(video_info.senders, transport_id, this,
       StatsReport::kSend);
   if (video_info.bw_estimations.size() != 1) {
     LOG(LS_ERROR) << "BWEs count: " << video_info.bw_estimations.size();
   } else {
     StatsReport::Id report_id(StatsReport::NewBandwidthEstimationId());
     StatsReport* report = reports_.FindOrAddNew(report_id);
     ExtractStats(
         video_info.bw_estimations[0], stats_gathering_started_, level, report);
   }
 }
 
 void StatsCollector::ExtractDataInfo() {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
 
   rtc::Thread::ScopedDisallowBlockingCalls no_blocking_calls;
 
-  for (const auto& dc : pc_->sctp_data_channels()) {
+  for (const auto& dc :
+           session_->mediastream_signaling()->sctp_data_channels()) {
     StatsReport::Id id(StatsReport::NewTypedIntId(
         StatsReport::kStatsReportTypeDataChannel, dc->id()));
     StatsReport* report = reports_.ReplaceOrAddNew(id);
     report->set_timestamp(stats_gathering_started_);
     report->AddString(StatsReport::kStatsValueNameLabel, dc->label());
     report->AddInt(StatsReport::kStatsValueNameDataChannelId, dc->id());
     report->AddString(StatsReport::kStatsValueNameProtocol, dc->protocol());
     report->AddString(StatsReport::kStatsValueNameState,
                       DataChannelInterface::DataStateString(dc->state()));
   }
 }
 
 StatsReport* StatsCollector::GetReport(const StatsReport::StatsType& type,
                                        const std::string& id,
                                        StatsReport::Direction direction) {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
   RTC_DCHECK(type == StatsReport::kStatsReportTypeSsrc ||
              type == StatsReport::kStatsReportTypeRemoteSsrc);
   return reports_.Find(StatsReport::NewIdWithDirection(type, id, direction));
 }
 
 void StatsCollector::UpdateStatsFromExistingLocalAudioTracks() {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
   // Loop through the existing local audio tracks.
   for (const auto& it : local_audio_tracks_) {
     AudioTrackInterface* track = it.first;
     uint32_t ssrc = it.second;
     StatsReport* report =
         GetReport(StatsReport::kStatsReportTypeSsrc,
                   rtc::ToString<uint32_t>(ssrc), StatsReport::kSend);
     if (report == NULL) {
       // This can happen if a local audio track is added to a stream on the
       // fly and the report has not been set up yet. Do nothing in this case.
       LOG(LS_ERROR) << "Stats report does not exist for ssrc " << ssrc;
       continue;
     }
 
     // The same ssrc can be used by both local and remote audio tracks.
     const StatsReport::Value* v =
         report->FindValue(StatsReport::kStatsValueNameTrackId);
     if (!v || v->string_val() != track->id())
       continue;
 
     report->set_timestamp(stats_gathering_started_);
     UpdateReportFromAudioTrack(track, report);
   }
 }
 
 void StatsCollector::UpdateReportFromAudioTrack(AudioTrackInterface* track,
                                                 StatsReport* report) {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
   RTC_DCHECK(track != NULL);
 
   int signal_level = 0;
   if (!track->GetSignalLevel(&signal_level))
     signal_level = -1;
 
   rtc::scoped_refptr<AudioProcessorInterface> audio_processor(
       track->GetAudioProcessor());
 
   AudioProcessorInterface::AudioProcessorStats stats;
   if (audio_processor.get())
     audio_processor->GetStats(&stats);
 
   SetAudioProcessingStats(report, signal_level, stats.typing_noise_detected,
       stats.echo_return_loss, stats.echo_return_loss_enhancement,
       stats.echo_delay_median_ms, stats.aec_quality_min,
       stats.echo_delay_std_ms);
 }
 
 bool StatsCollector::GetTrackIdBySsrc(uint32_t ssrc,
                                       std::string* track_id,
                                       StatsReport::Direction direction) {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
   if (direction == StatsReport::kSend) {
-    if (!pc_->session()->GetLocalTrackIdBySsrc(ssrc, track_id)) {
+    if (!session_->GetLocalTrackIdBySsrc(ssrc, track_id)) {
       LOG(LS_WARNING) << "The SSRC " << ssrc
                       << " is not associated with a sending track";
       return false;
     }
   } else {
     RTC_DCHECK(direction == StatsReport::kReceive);
-    if (!pc_->session()->GetRemoteTrackIdBySsrc(ssrc, track_id)) {
+    if (!session_->GetRemoteTrackIdBySsrc(ssrc, track_id)) {
       LOG(LS_WARNING) << "The SSRC " << ssrc
                       << " is not associated with a receiving track";
       return false;
     }
   }
 
   return true;
 }
 
 void StatsCollector::UpdateTrackReports() {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
 
   rtc::Thread::ScopedDisallowBlockingCalls no_blocking_calls;
 
   for (const auto& entry : track_ids_) {
     StatsReport* report = entry.second;
     report->set_timestamp(stats_gathering_started_);
   }
 }
 
 void StatsCollector::ClearUpdateStatsCacheForTest() {
   stats_gathering_started_ = 0;
 }
 
 }  // namespace webrtc