Late initialize MediaController, for less resource i.e. ProcessThread, usage by PeerConnection.

webrtc/api/statscollector.cc

 /*
  *  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 340 matching lines @@
       return "";
   }
 }
 
 StatsCollector::StatsCollector(PeerConnection* pc)
     : pc_(pc), stats_gathering_started_(0) {
   RTC_DCHECK(pc_);
 }
 
 StatsCollector::~StatsCollector() {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
 }
 
 double StatsCollector::GetTimeNow() {
+  RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
   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(signal_thread_checker_.CalledOnValidThread());
   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(signal_thread_checker_.CalledOnValidThread());
   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.
   StatsReport::Id id(StatsReport::NewTypedId(StatsReport::kStatsReportTypeTrack,
                                              audio_track->id()));
   StatsReport* report = reports_.Find(id);
   if (!report) {
     report = reports_.InsertNew(id);
     report->AddString(StatsReport::kStatsValueNameTrackId, audio_track->id());
   }
 }
 
 void StatsCollector::RemoveLocalAudioTrack(AudioTrackInterface* audio_track,
                                            uint32_t ssrc) {
+  RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
   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(signal_thread_checker_.CalledOnValidThread());
   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;
   }
 
+  // TODO(solenberg): Need to pull out session id so we have that even when
+  // there is no session.
   StatsReport* report = reports_.Find(StatsReport::NewTypedId(
       StatsReport::kStatsReportTypeSession, pc_->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(signal_thread_checker_.CalledOnValidThread());
   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;
 
+  // TODO(solenberg): Need to use a call which won't auto-create the session!
+  // Likely, this condition needs to go (PC always used to have a WebRtcSession)
+  // and some of the info at the beginning of ExtractSessionInfo is added even
+  // when there isn't a session.

[pthatcher1, 2016/02/26 21:51:20]

I think we can just make this:

TODO(pthatcher): Merge PeerConnection and WebRtcSession so there is no
pc_->session().  

[the sun, 2016/02/29 15:58:22]

Done.

   if (pc_->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());
+  RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
   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(signal_thread_checker_.CalledOnValidThread());
 
   // 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(signal_thread_checker_.CalledOnValidThread());
   // 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())) {
     // This loop runs in reverse, i.e. from root to leaf, so that each
     // certificate's issuer's report ID is known before the child certificate's
     // report is generated.  The root certificate does not have an issuer ID
     // value.
     for (ptrdiff_t i = chain->GetSize() - 1; i >= 0; --i) {
       const rtc::SSLCertificate& cert_i = chain->Get(i);
       issuer = AddOneCertificateReport(&cert_i, issuer);
     }
   }
   // Add the leaf certificate.
   return AddOneCertificateReport(cert, issuer);
 }
 
 StatsReport* StatsCollector::AddConnectionInfoReport(
     const std::string& content_name, int component, int connection_id,
     const StatsReport::Id& channel_report_id,
     const cricket::ConnectionInfo& info) {
+  RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
   StatsReport::Id id(StatsReport::NewCandidatePairId(content_name, component,
                                                      connection_id));
   StatsReport* report = reports_.ReplaceOrAddNew(id);
   report->set_timestamp(stats_gathering_started_);
 
   const BoolForAdd bools[] = {
     {StatsReport::kStatsValueNameActiveConnection, info.best_connection},
     {StatsReport::kStatsValueNameReceiving, info.receiving},
     {StatsReport::kStatsValueNameWritable, info.writable},
   };
@@ skipping 27 matching lines @@
                     info.remote_candidate.type());
   report->AddString(StatsReport::kStatsValueNameTransportType,
                     info.local_candidate.protocol());
 
   return report;
 }
 
 StatsReport* StatsCollector::AddCandidateReport(
     const cricket::Candidate& candidate,
     bool local) {
+  RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
   StatsReport::Id id(StatsReport::NewCandidateId(local, candidate.id()));
   StatsReport* report = reports_.Find(id);
   if (!report) {
     report = reports_.InsertNew(id);
     report->set_timestamp(stats_gathering_started_);
     if (local) {
       report->AddString(StatsReport::kStatsValueNameCandidateNetworkType,
                         AdapterTypeToStatsType(candidate.network_type()));
     }
     report->AddString(StatsReport::kStatsValueNameCandidateIPAddress,
                       candidate.address().ipaddr().ToString());
     report->AddString(StatsReport::kStatsValueNameCandidatePortNumber,
                       candidate.address().PortAsString());
     report->AddInt(StatsReport::kStatsValueNameCandidatePriority,
                    candidate.priority());
     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(signal_thread_checker_.CalledOnValidThread());
 
   // Extract information from the base session.
   StatsReport::Id id(StatsReport::NewTypedId(
       StatsReport::kStatsReportTypeSession, pc_->session()->id()));
   StatsReport* report = reports_.ReplaceOrAddNew(id);
   report->set_timestamp(stats_gathering_started_);
   report->AddBoolean(StatsReport::kStatsValueNameInitiator,
                      pc_->session()->initial_offerer());
 
   SessionStats stats;
@@ skipping 72 matching lines @@
           channel_report->AddId(
               StatsReport::kStatsValueNameSelectedCandidatePairId,
               connection_report->id());
         }
       }
     }
   }
 }
 
 void StatsCollector::ExtractVoiceInfo() {
-  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+  RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
 
   if (!pc_->session()->voice_channel()) {
     return;
   }
   cricket::VoiceMediaInfo voice_info;
   if (!pc_->session()->voice_channel()->GetStats(&voice_info)) {
     LOG(LS_ERROR) << "Failed to get voice channel stats.";
     return;
   }
 
@@ skipping 12 matching lines @@
   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(signal_thread_checker_.CalledOnValidThread());
 
   if (!pc_->session()->video_channel())
     return;
 
   cricket::VideoMediaInfo video_info;
   if (!pc_->session()->video_channel()->GetStats(&video_info)) {
     LOG(LS_ERROR) << "Failed to get video channel stats.";
     return;
   }
 
@@ skipping 16 matching lines @@
     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(signal_thread_checker_.CalledOnValidThread());
 
   rtc::Thread::ScopedDisallowBlockingCalls no_blocking_calls;
 
   for (const auto& dc : pc_->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(signal_thread_checker_.CalledOnValidThread());
   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(signal_thread_checker_.CalledOnValidThread());
   // 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(signal_thread_checker_.CalledOnValidThread());
   RTC_DCHECK(track != NULL);
 
   // Don't overwrite report values if they're not available.
   int signal_level;
   if (track->GetSignalLevel(&signal_level)) {
     RTC_DCHECK_GE(signal_level, 0);
     report->AddInt(StatsReport::kStatsValueNameAudioInputLevel, signal_level);
   }
 
   auto audio_processor(track->GetAudioProcessor());
 
   if (audio_processor.get()) {
     AudioProcessorInterface::AudioProcessorStats stats;
     audio_processor->GetStats(&stats);
 
     SetAudioProcessingStats(
         report, 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(signal_thread_checker_.CalledOnValidThread());
   if (direction == StatsReport::kSend) {
     if (!pc_->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)) {
       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(signal_thread_checker_.CalledOnValidThread());
 
   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() {
+  RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
   stats_gathering_started_ = 0;
 }
 
 }  // namespace webrtc