Reland 153623004: Remove the unified IO code on the browser

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 "base/android/build_info.h"
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
@@ skipping 420 matching lines @@
     return ((end_time_ - start_time_) / static_cast<double>(num_callbacks - 1))
         .InMillisecondsF();
   }
 
   void StartOutputStreamCallbacks(const AudioParameters& params) {
     double expected_time_between_callbacks_ms =
         ExpectedTimeBetweenCallbacks(params);
     const int num_callbacks =
         (kCallbackTestTimeMs / expected_time_between_callbacks_ms);
     AudioOutputStream* stream = audio_manager()->MakeAudioOutputStream(
-        params, std::string(), std::string());
+        params, std::string());
     EXPECT_TRUE(stream);
 
     int count = 0;
     MockAudioSourceCallback source;
 
     EXPECT_CALL(source, OnMoreData(NotNull(), _))
         .Times(AtLeast(num_callbacks))
         .WillRepeatedly(
              DoAll(CheckCountAndPostQuitTask(&count, num_callbacks, loop()),
                    Invoke(RealOnMoreData)));
@@ skipping 162 matching lines @@
   ais->Close();
 }
 
 // Ensure that a default output stream can be created and closed.
 // TODO(henrika): should we also verify that this API changes the audio mode
 // to communication mode, and calls RegisterHeadsetReceiver, the first time
 // it is called?
 TEST_F(AudioAndroidOutputTest, CreateAndCloseOutputStream) {
   AudioParameters params = GetDefaultOutputStreamParameters();
   AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
-      params, std::string(), std::string());
+      params, std::string());
   EXPECT_TRUE(aos);
   aos->Close();
 }
 
 // Ensure that a default input stream can be opened and closed.
 TEST_P(AudioAndroidInputTest, OpenAndCloseInputStream) {
   AudioParameters params = GetInputStreamParameters();
   AudioInputStream* ais = audio_manager()->MakeAudioInputStream(
       params, AudioManagerBase::kDefaultDeviceId);
   EXPECT_TRUE(ais);
   EXPECT_TRUE(ais->Open());
   ais->Close();
 }
 
 // Ensure that a default output stream can be opened and closed.
 TEST_F(AudioAndroidOutputTest, OpenAndCloseOutputStream) {
   AudioParameters params = GetDefaultOutputStreamParameters();
   AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
-      params, std::string(), std::string());
+      params, std::string());
   EXPECT_TRUE(aos);
   EXPECT_TRUE(aos->Open());
   aos->Close();
 }
 
 // Start input streaming using default input parameters and ensure that the
 // callback sequence is sane.
 // Disabled per crbug/337867
 TEST_P(AudioAndroidInputTest, DISABLED_StartInputStreamCallbacks) {
   AudioParameters params = GetInputStreamParameters();
@@ skipping 40 matching lines @@
 }
 
 // Play out a PCM file segment in real time and allow the user to verify that
 // the rendered audio sounds OK.
 // NOTE: this test requires user interaction and is not designed to run as an
 // automatized test on bots.
 TEST_F(AudioAndroidOutputTest, DISABLED_RunOutputStreamWithFileAsSource) {
   AudioParameters params = GetDefaultOutputStreamParameters();
   VLOG(1) << params;
   AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
-      params, std::string(), std::string());
+      params, std::string());
   EXPECT_TRUE(aos);
 
   std::string file_name;
   if (params.sample_rate() == 48000 && params.channels() == 2) {
     file_name = kSpeechFile_16b_s_48k;
   } else if (params.sample_rate() == 48000 && params.channels() == 1) {
     file_name = kSpeechFile_16b_m_48k;
   } else if (params.sample_rate() == 44100 && params.channels() == 2) {
     file_name = kSpeechFile_16b_s_44k;
   } else if (params.sample_rate() == 44100 && params.channels() == 1) {
@@ skipping 48 matching lines @@
 // automatized test on bots.
 TEST_P(AudioAndroidInputTest, DISABLED_RunDuplexInputStreamWithFileAsSink) {
   AudioParameters in_params = GetInputStreamParameters();
   AudioInputStream* ais = audio_manager()->MakeAudioInputStream(
       in_params, AudioManagerBase::kDefaultDeviceId);
   EXPECT_TRUE(ais);
 
   AudioParameters out_params =
       audio_manager()->GetDefaultOutputStreamParameters();
   AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
-      out_params, std::string(), std::string());
+      out_params, std::string());
   EXPECT_TRUE(aos);
 
   std::string file_name = base::StringPrintf("out_duplex_%d_%d_%d.pcm",
                                              in_params.sample_rate(),
                                              in_params.frames_per_buffer(),
                                              in_params.channels());
 
   base::WaitableEvent event(false, false);
   FileAudioSink sink(&event, in_params, file_name);
   MockAudioSourceCallback source;
@@ skipping 38 matching lines @@
                             default_input_params.bits_per_sample(),
                             default_input_params.sample_rate() / 100,
                             default_input_params.effects());
   VLOG(1) << io_params;
 
   // Create input and output streams using the common audio parameters.
   AudioInputStream* ais = audio_manager()->MakeAudioInputStream(
       io_params, AudioManagerBase::kDefaultDeviceId);
   EXPECT_TRUE(ais);
   AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
-      io_params, std::string(), std::string());
+      io_params, std::string());
   EXPECT_TRUE(aos);
 
   FullDuplexAudioSinkSource full_duplex(io_params);
 
   // Start a full duplex audio session and print out estimates of the extra
   // delay we should expect from the FIFO. If real-time delay measurements are
   // performed, the result should be reduced by this extra delay since it is
   // something that has been added by the test.
   EXPECT_TRUE(ais->Open());
   EXPECT_TRUE(aos->Open());
   ais->Start(&full_duplex);
   aos->Start(&full_duplex);
   VLOG(1) << "HINT: an estimate of the extra FIFO delay will be updated "
           << "once per second during this test.";
   VLOG(0) << ">> Speak into the mic and listen to the audio in loopback...";
   fflush(stdout);
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(20));
   printf("\n");
   aos->Stop();
   ais->Stop();
   aos->Close();
   ais->Close();
 }
 
 INSTANTIATE_TEST_CASE_P(AudioAndroidInputTest, AudioAndroidInputTest,
     testing::ValuesIn(RunAudioRecordInputPathTests()));
 
 }  // namespace media