Re-land: Add localized default audio device names.

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/bind.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 17 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::NotNull;
 using ::testing::Return;
 
 namespace media {
+namespace {
 
 ACTION_P3(CheckCountAndPostQuitTask, count, limit, loop) {
   if (++*count >= limit) {
     loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
   }
 }
 
-static const char kSpeechFile_16b_s_48k[] = "speech_16b_stereo_48kHz.raw";
-static const char kSpeechFile_16b_m_48k[] = "speech_16b_mono_48kHz.raw";
-static const char kSpeechFile_16b_s_44k[] = "speech_16b_stereo_44kHz.raw";
-static const char kSpeechFile_16b_m_44k[] = "speech_16b_mono_44kHz.raw";
+const char kSpeechFile_16b_s_48k[] = "speech_16b_stereo_48kHz.raw";
+const char kSpeechFile_16b_m_48k[] = "speech_16b_mono_48kHz.raw";
+const char kSpeechFile_16b_s_44k[] = "speech_16b_stereo_44kHz.raw";
+const char kSpeechFile_16b_m_44k[] = "speech_16b_mono_44kHz.raw";
 
-static const float kCallbackTestTimeMs = 2000.0;
-static const int kBitsPerSample = 16;
-static const int kBytesPerSample = kBitsPerSample / 8;
+const float kCallbackTestTimeMs = 2000.0;
+const int kBitsPerSample = 16;
+const int kBytesPerSample = kBitsPerSample / 8;
 
 // Converts AudioParameters::Format enumerator to readable string.
-static std::string FormatToString(AudioParameters::Format format) {
+std::string FormatToString(AudioParameters::Format format) {
   switch (format) {
     case AudioParameters::AUDIO_PCM_LINEAR:
       return std::string("AUDIO_PCM_LINEAR");
     case AudioParameters::AUDIO_PCM_LOW_LATENCY:
       return std::string("AUDIO_PCM_LOW_LATENCY");
     case AudioParameters::AUDIO_FAKE:
       return std::string("AUDIO_FAKE");
     default:
       return std::string();
   }
 }
 
 // Converts ChannelLayout enumerator to readable string. Does not include
 // multi-channel cases since these layouts are not supported on Android.
-static std::string LayoutToString(ChannelLayout channel_layout) {
+std::string LayoutToString(ChannelLayout channel_layout) {
   switch (channel_layout) {
     case CHANNEL_LAYOUT_NONE:
       return std::string("CHANNEL_LAYOUT_NONE");
     case CHANNEL_LAYOUT_MONO:
       return std::string("CHANNEL_LAYOUT_MONO");
     case CHANNEL_LAYOUT_STEREO:
       return std::string("CHANNEL_LAYOUT_STEREO");
     case CHANNEL_LAYOUT_UNSUPPORTED:
     default:
       return std::string("CHANNEL_LAYOUT_UNSUPPORTED");
   }
 }
 
-static double ExpectedTimeBetweenCallbacks(AudioParameters params) {
+double ExpectedTimeBetweenCallbacks(AudioParameters params) {
   return (base::TimeDelta::FromMicroseconds(
               params.frames_per_buffer() * base::Time::kMicrosecondsPerSecond /
               static_cast<double>(params.sample_rate()))).InMillisecondsF();
 }
 
 // Helper method which verifies that the device list starts with a valid
 // default device name followed by non-default device names.
-static void CheckDeviceNames(const AudioDeviceNames& device_names) {
+void CheckDeviceNames(const AudioDeviceNames& device_names) {
   DVLOG(2) << "Got " << device_names.size() << " audio devices.";
   if (device_names.empty()) {
     // Log a warning so we can see the status on the build bots.  No need to
     // break the test though since this does successfully test the code and
     // some failure cases.
     LOG(WARNING) << "No input devices detected";
     return;
   }
 
   AudioDeviceNames::const_iterator it = device_names.begin();
 
   // The first device in the list should always be the default device.
-  EXPECT_EQ(std::string(AudioManagerBase::kDefaultDeviceName),
-            it->device_name);
+  EXPECT_EQ(AudioManager::GetDefaultDeviceName(), it->device_name);
   EXPECT_EQ(std::string(AudioManagerBase::kDefaultDeviceId), it->unique_id);
   ++it;
 
   // Other devices should have non-empty name and id and should not contain
   // default name or id.
   while (it != device_names.end()) {
     EXPECT_FALSE(it->device_name.empty());
     EXPECT_FALSE(it->unique_id.empty());
     DVLOG(2) << "Device ID(" << it->unique_id
              << "), label: " << it->device_name;
-    EXPECT_NE(std::string(AudioManagerBase::kDefaultDeviceName),
-              it->device_name);
-    EXPECT_NE(std::string(AudioManagerBase::kDefaultDeviceId),
-              it->unique_id);
+    EXPECT_NE(AudioManager::GetDefaultDeviceName(), it->device_name);
+    EXPECT_NE(std::string(AudioManagerBase::kDefaultDeviceId), it->unique_id);
     ++it;
   }
 }
 
 // We clear the data bus to ensure that the test does not cause noise.
-static int RealOnMoreData(AudioBus* dest, uint32 total_bytes_delay) {
+int RealOnMoreData(AudioBus* dest, uint32 total_bytes_delay) {
   dest->Zero();
   return dest->frames();
 }
 
+}  // namespace
+
 std::ostream& operator<<(std::ostream& os, const AudioParameters& params) {
   using namespace std;
   os << endl << "format: " << FormatToString(params.format()) << endl
      << "channel layout: " << LayoutToString(params.channel_layout()) << endl
      << "sample rate: " << params.sample_rate() << endl
      << "bits per sample: " << params.bits_per_sample() << endl
      << "frames per buffer: " << params.frames_per_buffer() << endl
      << "channels: " << params.channels() << endl
      << "bytes per buffer: " << params.GetBytesPerBuffer() << endl
      << "bytes per second: " << params.GetBytesPerSecond() << endl
@@ skipping 805 matching lines @@
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(20));
   printf("\n");
   StopAndCloseAudioOutputStreamOnAudioThread();
   StopAndCloseAudioInputStreamOnAudioThread();
 }
 
 INSTANTIATE_TEST_CASE_P(AudioAndroidInputTest, AudioAndroidInputTest,
     testing::ValuesIn(RunAudioRecordInputPathTests()));
 
 }  // namespace media