Set / verify stats report timestamps.

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 62 matching lines @@
                                         const std::string& proxy) {
   DCHECK(!proxy.empty());
   cricket::ProxyTransportMap::const_iterator found = map.find(proxy);
   if (found == map.end())
     return StatsReport::Id();
 
   return StatsReport::NewComponentId(
       found->second, cricket::ICE_CANDIDATE_COMPONENT_RTP);
 }
 
-void AddTrackReport(StatsCollection* reports, const std::string& track_id) {
+StatsReport* AddTrackReport(StatsCollection* reports,
+                            const std::string& track_id) {
   // Adds an empty track report.
   StatsReport::Id id(
       StatsReport::NewTypedId(StatsReport::kStatsReportTypeTrack, track_id));
   StatsReport* report = reports->ReplaceOrAddNew(id);
   report->AddString(StatsReport::kStatsValueNameTrackId, track_id);
+  return report;
 }
 
 template <class TrackVector>
-void CreateTrackReports(const TrackVector& tracks, StatsCollection* reports) {
-  for (const auto& track : tracks)
-    AddTrackReport(reports, track->id());
+void CreateTrackReports(const TrackVector& tracks, StatsCollection* reports,
+                        TrackIdMap& track_ids) {
+  for (const auto& track : tracks) {
+    const std::string& track_id = track->id();
+    StatsReport* report = AddTrackReport(reports, track_id);
+    DCHECK(report != nullptr);
+    track_ids[track_id] = report;
+  }
 }
 
 void ExtractCommonSendProperties(const cricket::MediaSenderInfo& info,
                                  StatsReport* report) {
   report->AddString(StatsReport::kStatsValueNameCodecName, info.codec_name);
   report->AddInt64(StatsReport::kStatsValueNameBytesSent, info.bytes_sent);
   report->AddInt64(StatsReport::kStatsValueNameRtt, info.rtt_ms);
 }
 
 void SetAudioProcessingStats(StatsReport* report, int signal_level,
@@ skipping 253 matching lines @@
   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) {
   DCHECK(session_->signaling_thread()->IsCurrent());
   DCHECK(stream != NULL);
 
   CreateTrackReports<AudioTrackVector>(stream->GetAudioTracks(),
-                                       &reports_);
+                                       &reports_, track_ids_);
   CreateTrackReports<VideoTrackVector>(stream->GetVideoTracks(),
-                                       &reports_);
+                                       &reports_, track_ids_);
 }
 
 void StatsCollector::AddLocalAudioTrack(AudioTrackInterface* audio_track,
                                         uint32 ssrc) {
   DCHECK(session_->signaling_thread()->IsCurrent());
   DCHECK(audio_track != NULL);
 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON))
   for (const auto& track : local_audio_tracks_)
     DCHECK(track.first != audio_track || track.second != ssrc);
 #endif
@@ skipping 78 matching lines @@
     // 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 ssrc,
     const StatsReport::Id& transport_id,
     StatsReport::Direction direction) {
   DCHECK(session_->signaling_thread()->IsCurrent());
   StatsReport::Id id(StatsReport::NewIdWithDirection(
@@ skipping 383 matching lines @@
       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) {
   DCHECK(session_->signaling_thread()->IsCurrent());
   DCHECK(track != NULL);
 
   int signal_level = 0;
@@ skipping 27 matching lines @@
     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() {
+  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