Delete Timing class, timing.h, and update all users.

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.
  */
 
 #include "webrtc/api/statscollector.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "webrtc/api/peerconnection.h"
 #include "webrtc/base/base64.h"
 #include "webrtc/base/checks.h"
-#include "webrtc/base/timing.h"
 #include "webrtc/pc/channel.h"
 
 namespace webrtc {
 namespace {
 
 // The following is the enum RTCStatsIceCandidateType from
 // http://w3c.github.io/webrtc-stats/#rtcstatsicecandidatetype-enum such that
 // our stats report for ice candidate type could conform to that.
 const char STATSREPORT_LOCAL_PORT_TYPE[] = "host";
 const char STATSREPORT_STUN_PORT_TYPE[] = "serverreflexive";
@@ skipping 338 matching lines @@
 StatsCollector::StatsCollector(PeerConnection* pc)
     : pc_(pc), stats_gathering_started_(0) {
   RTC_DCHECK(pc_);
 }
 
 StatsCollector::~StatsCollector() {
   RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
 }
 
 double StatsCollector::GetTimeNow() {
-  return rtc::Timing::WallTimeNow() * rtc::kNumMillisecsPerSec;
+  return rtc::WallClockSeconds();
 }
 
 // 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(stream != NULL);
 
   CreateTrackReports<AudioTrackVector>(stream->GetAudioTracks(),
                                        &reports_, track_ids_);
@@ skipping 69 matching lines @@
     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());
   double time_now = GetTimeNow();

[nisse-webrtc, 2016/08/31 06:34:41]

hbos: This is the only call to GetTimeNow. 

For testing, would it work to move everything but this call to a helper method
that takes the time as an input argument (and hence doesn't depend on any global
state), and test that helper method? Then we wouldn't need any hacks in
statscollector_unittests to fake this clock, and we wouldn't need the GetTimeNow
virtual method.

[pthatcher1, 2016/08/31 18:19:46]

I think using a ScopedFakeClock is easy.  Why not just use that, like in the
RtpDataEngine unittest?

[nisse-webrtc, 2016/09/01 09:05:37]

We'd need a separate hook to fake utc time. I don't think it worth it,  because
it's only a single use, and this code should be obsoleted by the new code under
webrtc/stats (with tests which don't try to mock the UTC clock).

   // 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(pthatcher): Merge PeerConnection and WebRtcSession so there is no
@@ skipping 481 matching lines @@
     StatsReport* report = entry.second;
     report->set_timestamp(stats_gathering_started_);
   }
 }
 
 void StatsCollector::ClearUpdateStatsCacheForTest() {
   stats_gathering_started_ = 0;
 }
 
 }  // namespace webrtc