Modifies AudioInputCallback::OnData and use media::AudioBus instead of plain byte vector

media/audio/audio_low_latency_input_output_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 "base/basictypes.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/synchronization/lock.h"
 #include "base/test/test_timeouts.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "media/base/seekable_buffer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(USE_ALSA)
 #include "media/audio/alsa/audio_manager_alsa.h"
+#elif defined(USE_PULSEAUDIO)
+#include "media/audio/pulse/audio_manager_pulse.h"
 #elif defined(OS_MACOSX)
 #include "media/audio/mac/audio_manager_mac.h"
 #elif defined(OS_WIN)
 #include "media/audio/win/audio_manager_win.h"
 #include "media/audio/win/core_audio_util_win.h"
 #elif defined(OS_ANDROID)
 #include "media/audio/android/audio_manager_android.h"
 #else
 #include "media/audio/fake_audio_manager.h"
 #endif
@@ skipping 42 matching lines @@
   // Reported capture/input delay. Typical value is ~10 [ms].
   int input_delay_ms;
 
   // Reported render/output delay. Typical value is ~40 [ms].
   int output_delay_ms;
 };
 
 // This class mocks the platform specific audio manager and overrides
 // the GetMessageLoop() method to ensure that we can run our tests on
 // the main thread instead of the audio thread.
+/*

[henrika (OOO until Aug 14), 2014/06/10 15:14:06]

This complete test is actually disabled. I only use it for testing here but my
goal is to fix it in this CL as well.

 class MockAudioManager : public AudioManagerAnyPlatform {
  public:
   MockAudioManager() : AudioManagerAnyPlatform(&fake_audio_log_factory_) {}
   virtual ~MockAudioManager() {}
 
   virtual scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() OVERRIDE {
     return base::MessageLoop::current()->message_loop_proxy();
   }
 
  private:
   FakeAudioLogFactory fake_audio_log_factory_;
   DISALLOW_COPY_AND_ASSIGN(MockAudioManager);
 };
+*/
 
 // Test fixture class.
 class AudioLowLatencyInputOutputTest : public testing::Test {
  protected:
-  AudioLowLatencyInputOutputTest() {}
+  AudioLowLatencyInputOutputTest()
+      : audio_manager_(AudioManager::CreateForTesting()) {}
 
   virtual ~AudioLowLatencyInputOutputTest() {}
 
-  AudioManager* audio_manager() { return &mock_audio_manager_; }
+  AudioManager* audio_manager() { return audio_manager_.get(); }
   base::MessageLoopForUI* message_loop() { return &message_loop_; }
 
   // Convenience method which ensures that we are not running on the build
   // bots and that at least one valid input and output device can be found.
   bool CanRunAudioTests() {
     bool input = audio_manager()->HasAudioInputDevices();
     bool output = audio_manager()->HasAudioOutputDevices();
     LOG_IF(WARNING, !input) << "No input device detected.";
     LOG_IF(WARNING, !output) << "No output device detected.";
     return input && output;
   }
 
  private:
   base::MessageLoopForUI message_loop_;
-  MockAudioManager mock_audio_manager_;
+  // MockAudioManager mock_audio_manager_;
+  scoped_ptr<AudioManager> audio_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioLowLatencyInputOutputTest);
 };
 
 // This audio source/sink implementation should be used for manual tests
 // only since delay measurements are stored on an output text file.
 // All incoming/recorded audio packets are stored in an intermediate media
 // buffer which the renderer reads from when it needs audio for playout.
 // The total effect is that recorded audio is played out in loop back using
 // a sync buffer as temporary storage.
@@ skipping 45 matching lines @@
               state.input_delay_ms,
               state.output_delay_ms);
       ++elements_written;
     }
 
     base::CloseFile(text_file);
   }
 
   // AudioInputStream::AudioInputCallback.
   virtual void OnData(AudioInputStream* stream,
-                      const uint8* src, uint32 size,
+                      const AudioBus* source,
                       uint32 hardware_delay_bytes,
                       double volume) OVERRIDE {
     base::AutoLock lock(lock_);
 
     // Update three components in the AudioDelayState for this recorded
     // audio packet.
     const base::TimeTicks now_time = base::TimeTicks::Now();
     const int diff = (now_time - previous_write_time_).InMilliseconds();
     previous_write_time_ = now_time;
     if (input_elements_to_write_ < kMaxDelayMeasurements) {
       delay_states_[input_elements_to_write_].delta_time_ms = diff;
       delay_states_[input_elements_to_write_].buffer_delay_ms =
           BytesToMilliseconds(buffer_->forward_bytes());
       delay_states_[input_elements_to_write_].input_delay_ms =
           BytesToMilliseconds(hardware_delay_bytes);
       ++input_elements_to_write_;
     }
 
+    /*
     // Store the captured audio packet in a seekable media buffer.
     if (!buffer_->Append(src, size)) {
       // An attempt to write outside the buffer limits has been made.
       // Double the buffer capacity to ensure that we have a buffer large
       // enough to handle the current sample test scenario.
       buffer_->set_forward_capacity(2 * buffer_->forward_capacity());
       buffer_->Clear();
     }
+    */
   }
 
   virtual void OnError(AudioInputStream* stream) OVERRIDE {}
 
   // AudioOutputStream::AudioSourceCallback.
   virtual int OnMoreData(AudioBus* audio_bus,
                          AudioBuffersState buffers_state) OVERRIDE {
     base::AutoLock lock(lock_);
 
     // Update one component in the AudioDelayState for the packet
@@ skipping 175 matching lines @@
   // This test only supports identical parameters in both directions.
   // TODO(henrika): it is possible to cut delay here by using different
   // buffer sizes for input and output.
   if (aisw.sample_rate() != aosw.sample_rate() ||
       aisw.samples_per_packet() != aosw.samples_per_packet() ||
       aisw.channels()!= aosw.channels() ||
       aisw.bits_per_sample() != aosw.bits_per_sample()) {
     LOG(ERROR) << "This test requires symmetric input and output parameters. "
         "Ensure that sample rate and number of channels are identical in "
         "both directions";
+    DVLOG(1) << aisw.sample_rate() << " " << aosw.sample_rate();
+    DVLOG(1) << aisw.samples_per_packet() << " " << aosw.samples_per_packet();
     aos->Close();
     ais->Close();
     return;
   }
 
   EXPECT_TRUE(ais->Open());
   EXPECT_TRUE(aos->Open());
 
   FullDuplexAudioSinkSource full_duplex(
       aisw.sample_rate(), aisw.samples_per_packet(), aisw.channels());
@@ skipping 18 matching lines @@
 
   // All Close() operations that run on the mocked audio thread,
   // should be synchronous and not post additional close tasks to
   // mocked the audio thread. Hence, there is no need to call
   // message_loop()->RunUntilIdle() after the Close() methods.
   aos->Close();
   ais->Close();
 }
 
 }  // namespace media