Switch browser side audio capture path to use base time primitives.

media/audio/win/audio_low_latency_input_win_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/win/audio_low_latency_input_win.h"
 
 #include <windows.h>
 #include <mmsystem.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 26 matching lines @@
 
 namespace media {
 
 ACTION_P4(CheckCountAndPostQuitTask, count, limit, task_runner, quit_closure) {
   if (++*count >= limit)
     task_runner->PostTask(FROM_HERE, quit_closure);
 }
 
 class MockAudioInputCallback : public AudioInputStream::AudioInputCallback {
  public:
-  MOCK_METHOD4(OnData,
+  MOCK_METHOD5(OnData,
                void(AudioInputStream* stream,
                     const AudioBus* src,
-                    uint32_t hardware_delay_bytes,
+                    base::TimeDelta delay,
+                    base::TimeTicks delay_timestamp,
                     double volume));
   MOCK_METHOD1(OnError, void(AudioInputStream* stream));
 };
 
 class FakeAudioInputCallback : public AudioInputStream::AudioInputCallback {
  public:
   FakeAudioInputCallback()
       : num_received_audio_frames_(0),
         data_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                     base::WaitableEvent::InitialState::NOT_SIGNALED),
         error_(false) {}
 
   bool error() const { return error_; }
   int num_received_audio_frames() const { return num_received_audio_frames_; }
 
   // Waits until OnData() is called on another thread.
   void WaitForData() {
     data_event_.Wait();
   }
 
   void OnData(AudioInputStream* stream,
               const AudioBus* src,
-              uint32_t hardware_delay_bytes,
+              base::TimeDelta delay,
+              base::TimeTicks delay_timestamp,
               double volume) override {
-    EXPECT_GE(hardware_delay_bytes, 0u);
-    EXPECT_LT(hardware_delay_bytes, 0xFFFFu);  // Arbitrarily picked.
+    EXPECT_GE(delay, base::TimeDelta());
     num_received_audio_frames_ += src->frames();
     data_event_.Signal();
   }
 
   void OnError(AudioInputStream* stream) override {
     error_ = true;
   }
 
  private:
   int num_received_audio_frames_;
@@ skipping 38 matching lines @@
       fwrite(chunk, 1, chunk_size, binary_file_);
       buffer_.Seek(chunk_size);
       bytes_written += chunk_size;
     }
     base::CloseFile(binary_file_);
   }
 
   // AudioInputStream::AudioInputCallback implementation.
   void OnData(AudioInputStream* stream,
               const AudioBus* src,
-              uint32_t hardware_delay_bytes,
+              base::TimeDelta delay,
+              base::TimeTicks delay_timestamp,
               double volume) override {
     EXPECT_EQ(bits_per_sample_, 16);
     const int num_samples = src->frames() * src->channels();
     std::unique_ptr<int16_t> interleaved(new int16_t[num_samples]);
     const int bytes_per_sample = sizeof(*interleaved);
     src->ToInterleaved(src->frames(), bytes_per_sample, interleaved.get());
 
     // Store data data in a temporary buffer to avoid making blocking
     // fwrite() calls in the audio callback. The complete buffer will be
     // written to file in the destructor.
@@ skipping 231 matching lines @@
 
   // Derive the expected size in bytes of each recorded packet.
   uint32_t bytes_per_packet =
       aisw.channels() * aisw.frames_per_buffer() * (aisw.bits_per_sample() / 8);
 
   {
     // We use 10ms packets and will run the test until ten packets are received.
     // All should contain valid packets of the same size and a valid delay
     // estimate.
     base::RunLoop run_loop;
-    EXPECT_CALL(sink, OnData(ais.get(), NotNull(), _, _))
+    EXPECT_CALL(sink, OnData(ais.get(), NotNull(), _, _, _))
         .Times(AtLeast(10))
         .WillRepeatedly(
             CheckCountAndPostQuitTask(&count, 10, message_loop_.task_runner(),
                                       run_loop.QuitWhenIdleClosure()));
     ais->Start(&sink);
     run_loop.Run();
     ais->Stop();
   }
 
   // Store current packet size (to be used in the subsequent tests).
   int frames_per_buffer_10ms = aisw.frames_per_buffer();
 
   ais.Close();
 
   // 20 ms packet size.
 
   count = 0;
   ais.Reset(aisw.Create(2 * frames_per_buffer_10ms));
   EXPECT_TRUE(ais->Open());
   bytes_per_packet = aisw.channels() * aisw.frames_per_buffer() *
       (aisw.bits_per_sample() / 8);
 
   {
     base::RunLoop run_loop;
-    EXPECT_CALL(sink, OnData(ais.get(), NotNull(), _, _))
+    EXPECT_CALL(sink, OnData(ais.get(), NotNull(), _, _, _))
         .Times(AtLeast(10))
         .WillRepeatedly(
             CheckCountAndPostQuitTask(&count, 10, message_loop_.task_runner(),
                                       run_loop.QuitWhenIdleClosure()));
     ais->Start(&sink);
     run_loop.Run();
     ais->Stop();
     ais.Close();
   }
 
   // 5 ms packet size.
 
   count = 0;
   ais.Reset(aisw.Create(frames_per_buffer_10ms / 2));
   EXPECT_TRUE(ais->Open());
   bytes_per_packet = aisw.channels() * aisw.frames_per_buffer() *
     (aisw.bits_per_sample() / 8);
 
   {
     base::RunLoop run_loop;
-    EXPECT_CALL(sink, OnData(ais.get(), NotNull(), _, _))
+    EXPECT_CALL(sink, OnData(ais.get(), NotNull(), _, _, _))
         .Times(AtLeast(10))
         .WillRepeatedly(
             CheckCountAndPostQuitTask(&count, 10, message_loop_.task_runner(),
                                       run_loop.QuitWhenIdleClosure()));
     ais->Start(&sink);
     run_loop.Run();
     ais->Stop();
     ais.Close();
   }
 }
@@ skipping 49 matching lines @@
   WriteToFileAudioSink file_sink(file_name, aisw.bits_per_sample());
   VLOG(0) << ">> Speak into the default microphone while recording.";
   ais->Start(&file_sink);
   base::PlatformThread::Sleep(TestTimeouts::action_timeout());
   ais->Stop();
   VLOG(0) << ">> Recording has stopped.";
   ais.Close();
 }
 
 }  // namespace media