Moving device description utils from AudioManager[Base] into AudioDeviceDescription; to be shared b…

media/audio/cras/cras_input_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 <stdint.h>
 
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_message_loop.h"
 #include "base/test/test_timeouts.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "media/audio/audio_device_description.h"
 #include "media/audio/cras/audio_manager_cras.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // cras_util.h defines custom min/max macros which break compilation, so ensure
 // it's not included until last.  #if avoids presubmit errors.
 #if defined(USE_CRAS)
 #include "media/audio/cras/cras_input.h"
 #endif
@@ skipping 42 matching lines @@
 
   ~CrasInputStreamTest() override {}
 
   CrasInputStream* CreateStream(ChannelLayout layout) {
     return CreateStream(layout, kTestFramesPerPacket);
   }
 
   CrasInputStream* CreateStream(ChannelLayout layout,
                                 int32_t samples_per_packet) {
     return CreateStream(layout, samples_per_packet,
-                        AudioManagerBase::kDefaultDeviceId);
+                        AudioDeviceDescription::kDefaultDeviceId);
   }
 
   CrasInputStream* CreateStream(ChannelLayout layout,
                                 int32_t samples_per_packet,
                                 const std::string& device_id) {
     AudioParameters params(kTestFormat,
                            layout,
                            kTestSampleRate,
                            kTestBitsPerSample,
                            samples_per_packet);
     return new CrasInputStream(params, mock_manager_.get(), device_id);
   }
 
   void CaptureSomeFrames(const AudioParameters &params,
                          unsigned int duration_ms) {
     CrasInputStream* test_stream = new CrasInputStream(
-        params, mock_manager_.get(), AudioManagerBase::kDefaultDeviceId);
+        params, mock_manager_.get(), AudioDeviceDescription::kDefaultDeviceId);
 
     ASSERT_TRUE(test_stream->Open());
 
     // Allow 8 frames variance for SRC in the callback.  Different numbers of
     // samples can be provided when doing non-integer SRC.  For example
     // converting from 192k to 44.1k is a ratio of 4.35 to 1.
     MockAudioInputCallback mock_callback;
     base::WaitableEvent event(false, false);
 
     EXPECT_CALL(mock_callback, OnData(test_stream, _, _, _))
@@ skipping 43 matching lines @@
   EXPECT_TRUE(test_stream->Open());
   test_stream->Close();
 }
 
 TEST_F(CrasInputStreamTest, BadBitsPerSample) {
   AudioParameters bad_bps_params(kTestFormat,
                                  kTestChannelLayout,
                                  kTestSampleRate,
                                  kTestBitsPerSample - 1,
                                  kTestFramesPerPacket);
-  CrasInputStream* test_stream = new CrasInputStream(
-      bad_bps_params, mock_manager_.get(), AudioManagerBase::kDefaultDeviceId);
+  CrasInputStream* test_stream =
+      new CrasInputStream(bad_bps_params, mock_manager_.get(),
+                          AudioDeviceDescription::kDefaultDeviceId);
   EXPECT_FALSE(test_stream->Open());
   test_stream->Close();
 }
 
 TEST_F(CrasInputStreamTest, BadSampleRate) {
   AudioParameters bad_rate_params(kTestFormat,
                                   kTestChannelLayout,
                                   0,
                                   kTestBitsPerSample,
                                   kTestFramesPerPacket);
-  CrasInputStream* test_stream = new CrasInputStream(
-      bad_rate_params, mock_manager_.get(), AudioManagerBase::kDefaultDeviceId);
+  CrasInputStream* test_stream =
+      new CrasInputStream(bad_rate_params, mock_manager_.get(),
+                          AudioDeviceDescription::kDefaultDeviceId);
   EXPECT_FALSE(test_stream->Open());
   test_stream->Close();
 }
 
 TEST_F(CrasInputStreamTest, SetGetVolume) {
   CrasInputStream* test_stream = CreateStream(CHANNEL_LAYOUT_MONO);
   EXPECT_TRUE(test_stream->Open());
 
   double max_volume = test_stream->GetMaxVolume();
   EXPECT_GE(max_volume, 1.0);
@@ skipping 27 matching lines @@
     AudioParameters params_stereo(kTestFormat,
                                   CHANNEL_LAYOUT_STEREO,
                                   rates[i],
                                   kTestBitsPerSample,
                                   kTestFramesPerPacket);
     CaptureSomeFrames(params_stereo, kTestCaptureDurationMs);
   }
 }
 
 TEST_F(CrasInputStreamTest, CaptureLoopback) {
-  CrasInputStream* test_stream = CreateStream(
-      CHANNEL_LAYOUT_STEREO,
-      kTestFramesPerPacket,
-      AudioManagerBase::kLoopbackInputDeviceId);
+  CrasInputStream* test_stream =
+      CreateStream(CHANNEL_LAYOUT_STEREO, kTestFramesPerPacket,
+                   AudioDeviceDescription::kLoopbackInputDeviceId);
   EXPECT_TRUE(test_stream->Open());
   test_stream->Close();
 }
 
 }  // namespace media