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

media/audio/audio_manager_base.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 "media/audio/audio_manager_base.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
+#include "media/audio/audio_device_description.h"
 #include "media/audio/audio_output_dispatcher_impl.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_output_resampler.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/audio/fake_audio_output_stream.h"
 #include "media/base/media_switches.h"
 
 namespace media {
 namespace {
 
 const int kStreamCloseDelaySeconds = 5;
 
 // Default maximum number of output streams that can be open simultaneously
 // for all platforms.
 const int kDefaultMaxOutputStreams = 16;
 
 // Default maximum number of input streams that can be open simultaneously
 // for all platforms.
 const int kDefaultMaxInputStreams = 16;
 
 const int kMaxInputChannels = 3;
 
 }  // namespace
 
-const char AudioManagerBase::kDefaultDeviceId[] = "default";
-const char AudioManagerBase::kCommunicationsDeviceId[] = "communications";
-const char AudioManagerBase::kLoopbackInputDeviceId[] = "loopback";
-
 struct AudioManagerBase::DispatcherParams {
   DispatcherParams(const AudioParameters& input,
                    const AudioParameters& output,
                    const std::string& output_device_id)
       : input_params(input),
         output_params(output),
         output_device_id(output_device_id) {}
   ~DispatcherParams() {}
 
   const AudioParameters input_params;
@@ skipping 17 matching lines @@
     //    dispatcher are the same as the request dispatcher.
     return (dispatcher_->input_params.Equals(dispatcher_in->input_params) &&
             dispatcher_->output_params.Equals(dispatcher_in->output_params) &&
             dispatcher_->output_device_id == dispatcher_in->output_device_id);
   }
 
  private:
   const DispatcherParams* dispatcher_;
 };
 
-// static
-bool AudioManagerBase::IsDefaultDeviceId(const std::string& device_id) {
-  return device_id.empty() || device_id == AudioManagerBase::kDefaultDeviceId;
-}
-
-// static
-bool AudioManagerBase::UseSessionIdToSelectDevice(
-    int session_id,
-    const std::string& device_id) {
-  return session_id && device_id.empty();
-}
-
 AudioManagerBase::AudioManagerBase(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
     AudioLogFactory* audio_log_factory)
     : AudioManager(std::move(task_runner), std::move(worker_task_runner)),
       max_num_output_streams_(kDefaultMaxOutputStreams),
       max_num_input_streams_(kDefaultMaxInputStreams),
       num_output_streams_(0),
       num_input_streams_(0),
       // TODO(dalecurtis): Switch this to an base::ObserverListThreadSafe, so we
@@ skipping 36 matching lines @@
     DLOG(ERROR) << "Number of opened output audio streams "
                 << num_output_streams_
                 << " exceed the max allowed number "
                 << max_num_output_streams_;
     return NULL;
   }
 
   AudioOutputStream* stream;
   switch (params.format()) {
     case AudioParameters::AUDIO_PCM_LINEAR:
-      DCHECK(IsDefaultDeviceId(device_id))
+      DCHECK(AudioDeviceDescription::IsDefaultDevice(device_id))
           << "AUDIO_PCM_LINEAR supports only the default device.";
       stream = MakeLinearOutputStream(params);
       break;
     case AudioParameters::AUDIO_PCM_LOW_LATENCY:
       stream = MakeLowLatencyOutputStream(params, device_id);
       break;
     case AudioParameters::AUDIO_FAKE:
       stream = FakeAudioOutputStream::MakeFakeStream(this, params);
       break;
     default:
@@ skipping 59 matching lines @@
     const std::string& device_id) {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
 
   // If the caller supplied an empty device id to select the default device,
   // we fetch the actual device id of the default device so that the lookup
   // will find the correct device regardless of whether it was opened as
   // "default" or via the specific id.
   // NOTE: Implementations that don't yet support opening non-default output
   // devices may return an empty string from GetDefaultOutputDeviceID().
   std::string output_device_id =
-      IsDefaultDeviceId(device_id) ? GetDefaultOutputDeviceID() : device_id;
+      AudioDeviceDescription::IsDefaultDevice(device_id)
+          ? GetDefaultOutputDeviceID()
+          : device_id;
 
   // If we're not using AudioOutputResampler our output parameters are the same
   // as our input parameters.
   AudioParameters output_params = params;
   if (params.format() == AudioParameters::AUDIO_PCM_LOW_LATENCY) {
     output_params =
         GetPreferredOutputStreamParameters(output_device_id, params);
 
     // Ensure we only pass on valid output parameters.
     if (!output_params.IsValid()) {
@@ skipping 135 matching lines @@
 
   return 0;
 }
 
 std::unique_ptr<AudioLog> AudioManagerBase::CreateAudioLog(
     AudioLogFactory::AudioComponent component) {
   return audio_log_factory_->CreateAudioLog(component);
 }
 
 }  // namespace media