Removes usage of system_wrappers/include/clock.h in audio_device/

webrtc/modules/audio_device/ios/audio_device_unittest_ios.cc

 /*
  *  Copyright (c) 2015 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 <algorithm>
 #include <limits>
 #include <list>
 #include <memory>
 #include <numeric>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/scoped_ref_ptr.h"
+#include "webrtc/base/timeutils.h"
 #include "webrtc/modules/audio_device/audio_device_impl.h"
 #include "webrtc/modules/audio_device/include/audio_device.h"
 #include "webrtc/modules/audio_device/include/mock_audio_transport.h"
 #include "webrtc/modules/audio_device/ios/audio_device_ios.h"
-#include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/event_wrapper.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 using std::cout;
 using std::endl;
 using ::testing::_;
 using ::testing::AtLeast;
@@ skipping 201 matching lines @@
   size_t write_count_;
 };
 
 // Inserts periodic impulses and measures the latency between the time of
 // transmission and time of receiving the same impulse.
 // Usage requires a special hardware called Audio Loopback Dongle.
 // See http://source.android.com/devices/audio/loopback.html for details.
 class LatencyMeasuringAudioStream : public AudioStreamInterface {
  public:
   explicit LatencyMeasuringAudioStream(size_t frames_per_buffer)
-      : clock_(Clock::GetRealTimeClock()),
-        frames_per_buffer_(frames_per_buffer),
+      : frames_per_buffer_(frames_per_buffer),
         bytes_per_buffer_(frames_per_buffer_ * sizeof(int16_t)),
         play_count_(0),
         rec_count_(0),
         pulse_time_(0) {}
 
   // Insert periodic impulses in first two samples of |destination|.
   void Read(void* destination, size_t num_frames) override {
     ASSERT_EQ(num_frames, frames_per_buffer_);
     if (play_count_ == 0) {
       PRINT("[");
     }
     play_count_++;
     memset(destination, 0, bytes_per_buffer_);
     if (play_count_ % (kNumCallbacksPerSecond / kImpulseFrequencyInHz) == 0) {
       if (pulse_time_ == 0) {
-        pulse_time_ = clock_->TimeInMilliseconds();
+        pulse_time_ = rtc::TimeMillis();
       }
       PRINT(".");
       const int16_t impulse = std::numeric_limits<int16_t>::max();
       int16_t* ptr16 = static_cast<int16_t*>(destination);
       for (size_t i = 0; i < 2; ++i) {
         ptr16[i] = impulse;
       }
     }
   }
 
   // Detect received impulses in |source|, derive time between transmission and
   // detection and add the calculated delay to list of latencies.
   void Write(const void* source, size_t num_frames) override {
     ASSERT_EQ(num_frames, frames_per_buffer_);
     rec_count_++;
     if (pulse_time_ == 0) {
       // Avoid detection of new impulse response until a new impulse has
       // been transmitted (sets |pulse_time_| to value larger than zero).
       return;
     }
     const int16_t* ptr16 = static_cast<const int16_t*>(source);
     std::vector<int16_t> vec(ptr16, ptr16 + num_frames);
     // Find max value in the audio buffer.
     int max = *std::max_element(vec.begin(), vec.end());
     // Find index (element position in vector) of the max element.
     int index_of_max =
         std::distance(vec.begin(), std::find(vec.begin(), vec.end(), max));
     if (max > kImpulseThreshold) {
       PRINTD("(%d,%d)", max, index_of_max);
-      int64_t now_time = clock_->TimeInMilliseconds();
+      int64_t now_time = rtc::TimeMillis();
       int extra_delay = IndexToMilliseconds(static_cast<double>(index_of_max));
       PRINTD("[%d]", static_cast<int>(now_time - pulse_time_));
       PRINTD("[%d]", extra_delay);
       // Total latency is the difference between transmit time and detection
       // tome plus the extra delay within the buffer in which we detected the
       // received impulse. It is transmitted at sample 0 but can be received
       // at sample N where N > 0. The term |extra_delay| accounts for N and it
       // is a value between 0 and 10ms.
       latencies_.push_back(now_time - pulse_time_ + extra_delay);
       pulse_time_ = 0;
@@ skipping 33 matching lines @@
     PRINT("\n");
     PRINT("%s[min, max, avg]=[%d, %d, %d] ms\n", kTag, min_latency(),
           max_latency(), average_latency());
   }
 
   int IndexToMilliseconds(double index) const {
     return 10.0 * (index / frames_per_buffer_) + 0.5;
   }
 
  private:
-  Clock* clock_;
   const size_t frames_per_buffer_;
   const size_t bytes_per_buffer_;
   size_t play_count_;
   size_t rec_count_;
   int64_t pulse_time_;
   std::vector<int> latencies_;
 };
 // Mocks the AudioTransport object and proxies actions for the two callbacks
 // (RecordedDataIsAvailable and NeedMorePlayData) to different implementations
 // of AudioStreamInterface.
@@ skipping 453 matching lines @@
   StopPlayout();
   StopRecording();
   // Verify that the correct number of transmitted impulses are detected.
   EXPECT_EQ(latency_audio_stream->num_latency_values(),
             static_cast<size_t>(
                 kImpulseFrequencyInHz * kMeasureLatencyTimeInSec - 1));
   latency_audio_stream->PrintResults();
 }
 
 }  // namespace webrtc