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

webrtc/modules/audio_device/android/audio_device_unittest.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/scoped_ref_ptr.h"
+#include "webrtc/base/timeutils.h"
 #include "webrtc/modules/audio_device/android/audio_common.h"
 #include "webrtc/modules/audio_device/android/audio_manager.h"
 #include "webrtc/modules/audio_device/android/build_info.h"
 #include "webrtc/modules/audio_device/android/ensure_initialized.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/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 204 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;
       }
     }
   }
 
@@ skipping 10 matching lines @@
     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 34 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 static_cast<int>(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
@@ skipping 622 matching lines @@
 
 // Measures loopback latency and reports the min, max and average values for
 // a full duplex audio session.
 // The latency is measured like so:
 // - Insert impulses periodically on the output side.
 // - Detect the impulses on the input side.
 // - Measure the time difference between the transmit time and receive time.
 // - Store time differences in a vector and calculate min, max and average.
 // This test requires a special hardware called Audio Loopback Dongle.
 // See http://source.android.com/devices/audio/loopback.html for details.
-TEST_F(AudioDeviceTest, DISABLED_MeasureLoopbackLatency) {
+TEST_F(AudioDeviceTest, MeasureLoopbackLatency) {

[nisse-webrtc, 2016/11/15 08:12:33]

Nice it the test can now be enabled, but it's unclear why this change makes that
possible?

   EXPECT_EQ(record_channels(), playout_channels());
   EXPECT_EQ(record_sample_rate(), playout_sample_rate());
   NiceMock<MockAudioTransportAndroid> mock(kPlayout | kRecording);
   std::unique_ptr<LatencyMeasuringAudioStream> latency_audio_stream(
       new LatencyMeasuringAudioStream(playout_frames_per_10ms_buffer()));
   mock.HandleCallbacks(test_is_done_.get(),
                        latency_audio_stream.get(),
                        kMeasureLatencyTimeInSec * kNumCallbacksPerSecond);
   EXPECT_EQ(0, audio_device()->RegisterAudioCallback(&mock));
   SetMaxPlayoutVolume();
   DisableBuiltInAECIfAvailable();
   StartRecording();
   StartPlayout();
   test_is_done_->Wait(std::max(kTestTimeOutInMilliseconds,
                                1000 * kMeasureLatencyTimeInSec));
   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