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

media/audio/android/audio_android_unittest.cc

 // Copyright 2013 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 <stdint.h>
 
 #include <memory>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
@@ skipping 140 matching lines @@
      << "bytes per frame: " << params.GetBytesPerFrame() << endl
      << "chunk size in ms: " << ExpectedTimeBetweenCallbacks(params) << endl
      << "echo_canceller: "
      << (params.effects() & AudioParameters::ECHO_CANCELLER);
   return os;
 }
 
 // Gmock implementation of AudioInputStream::AudioInputCallback.
 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));
 };
 
 // Implements AudioOutputStream::AudioSourceCallback and provides audio data
 // by reading from a data file.
 class FileAudioSource : public AudioOutputStream::AudioSourceCallback {
  public:
   explicit FileAudioSource(base::WaitableEvent* event, const std::string& name)
       : event_(event), pos_(0) {
@@ skipping 93 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 {
     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.
     const int size = bytes_per_sample * num_samples;
@@ skipping 27 matching lines @@
     // dynamically during the test if required.
     fifo_.reset(new media::SeekableBuffer(0, 2 * params.GetBytesPerBuffer()));
     buffer_.reset(new uint8_t[params_.GetBytesPerBuffer()]);
   }
 
   ~FullDuplexAudioSinkSource() override {}
 
   // 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 {
     const base::TimeTicks now_time = base::TimeTicks::Now();
     const int diff = (now_time - previous_time_).InMilliseconds();
 
     EXPECT_EQ(params_.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());
     const int size = bytes_per_sample * num_samples;
@@ skipping 313 matching lines @@
         ExpectedTimeBetweenCallbacks(params);
     const int num_callbacks =
         (kCallbackTestTimeMs / expected_time_between_callbacks_ms);
 
     MakeAudioInputStreamOnAudioThread(params);
 
     int count = 0;
     MockAudioInputCallback sink;
 
     base::RunLoop run_loop;
-    EXPECT_CALL(sink, OnData(audio_input_stream_, NotNull(), _, _))
+    EXPECT_CALL(sink, OnData(audio_input_stream_, NotNull(), _, _, _))
         .Times(AtLeast(num_callbacks))
         .WillRepeatedly(CheckCountAndPostQuitTask(
             &count, num_callbacks, base::ThreadTaskRunnerHandle::Get(),
             run_loop.QuitWhenIdleClosure()));
     EXPECT_CALL(sink, OnError(audio_input_stream_)).Times(0);
 
     OpenAndStartAudioInputStreamOnAudioThread(&sink);
 
     start_time_ = base::TimeTicks::Now();
     run_loop.Run();
@@ skipping 292 matching lines @@
   printf("\n");
   StopAndCloseAudioOutputStreamOnAudioThread();
   StopAndCloseAudioInputStreamOnAudioThread();
 }
 
 INSTANTIATE_TEST_CASE_P(AudioAndroidInputTest,
                         AudioAndroidInputTest,
                         testing::Bool());
 
 }  // namespace media