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

content/browser/renderer_host/media/audio_renderer_host.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 "content/browser/renderer_host/media/audio_renderer_host.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 #include "content/browser/renderer_host/media/audio_sync_reader.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/media/audio_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/media_device_id.h"
 #include "content/public/browser/media_observer.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/common/content_switches.h"
-#include "media/audio/audio_device_name.h"
-#include "media/audio/audio_manager_base.h"
+#include "media/audio/audio_device_description.h"
 #include "media/audio/audio_streams_tracker.h"
 #include "media/base/audio_bus.h"
 #include "media/base/limits.h"
 
 using media::AudioBus;
 using media::AudioManager;
 
 namespace content {
 
 namespace {
@@ skipping 12 matching lines @@
 }
 
 GURL ConvertToGURL(const url::Origin& origin) {
   return origin.unique() ? GURL() : GURL(origin.Serialize());
 }
 
 bool IsValidDeviceId(const std::string& device_id) {
   static const std::string::size_type kValidLength = 64;
 
   if (device_id.empty() ||
-      device_id == media::AudioManagerBase::kDefaultDeviceId ||
-      device_id == media::AudioManagerBase::kCommunicationsDeviceId) {
+      device_id == media::AudioDeviceDescription::kDefaultDeviceId ||
+      device_id == media::AudioDeviceDescription::kCommunicationsDeviceId) {
     return true;
   }
 
   if (device_id.length() != kValidLength)
     return false;
 
   for (const char& c : device_id) {
     if ((c < 'a' || c > 'f') && (c < '0' || c > '9'))
       return false;
   }
 
   return true;
 }
 
 AudioOutputDeviceInfo GetDefaultDeviceInfoOnDeviceThread(
     media::AudioManager* audio_manager) {
   DCHECK(audio_manager->GetTaskRunner()->BelongsToCurrentThread());
   AudioOutputDeviceInfo default_device_info = {
-      media::AudioManagerBase::kDefaultDeviceId,
-      audio_manager->GetDefaultDeviceName(),
+      media::AudioDeviceDescription::kDefaultDeviceId,
+      media::AudioDeviceDescription::GetDefaultDeviceName(),
       audio_manager->GetDefaultOutputStreamParameters()};
 
   return default_device_info;
 }
 
 void NotifyRenderProcessHostThatAudioStateChanged(int render_process_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   RenderProcessHost* render_process_host =
       RenderProcessHost::FromID(render_process_id);
@@ skipping 315 matching lines @@
 
   if (!IsValidDeviceId(device_id)) {
     Send(new AudioMsg_NotifyDeviceAuthorized(
         stream_id, media::OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND,
         media::AudioParameters::UnavailableDeviceParams(), std::string()));
     return;
   }
 
   // If |session_id should be used for output device selection and such output
   // device is found, reuse the input device permissions.
-  if (media::AudioManagerBase::UseSessionIdToSelectDevice(session_id,
-                                                          device_id)) {
+  if (media::AudioDeviceDescription::UseSessionIdToSelectDevice(session_id,
+                                                                device_id)) {
     const StreamDeviceInfo* info =
         media_stream_manager_->audio_input_device_manager()
             ->GetOpenedDeviceInfoById(session_id);
     if (info) {
       media::AudioParameters output_params(
           media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
           static_cast<media::ChannelLayout>(
               info->device.matched_output.channel_layout),
           info->device.matched_output.sample_rate, 16,
           info->device.matched_output.frames_per_buffer);
@@ skipping 36 matching lines @@
     Send(new AudioMsg_NotifyDeviceAuthorized(
         stream_id, media::OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED,
         media::AudioParameters::UnavailableDeviceParams(), std::string()));
     return;
   }
 
   // If enumerator caching is disabled, avoid the enumeration if the default
   // device is requested, since no device ID translation is needed.
   // If enumerator caching is enabled, it is better to use its cache, even
   // for the default device.
-  if (media::AudioManagerBase::IsDefaultDeviceId(device_id) &&
+  if (media::AudioDeviceDescription::IsDefaultDevice(device_id) &&
       !media_stream_manager_->audio_output_device_enumerator()
            ->IsCacheEnabled()) {
     base::PostTaskAndReplyWithResult(
         audio_manager_->GetTaskRunner(), FROM_HERE,
         base::Bind(&GetDefaultDeviceInfoOnDeviceThread, audio_manager_),
         base::Bind(&AudioRendererHost::OnDeviceIDTranslated, this, stream_id,
                    true));
   } else {
     media_stream_manager_->audio_output_device_enumerator()->Enumerate(
         base::Bind(&AudioRendererHost::TranslateDeviceID, this, device_id,
@@ skipping 253 matching lines @@
 
 void AudioRendererHost::CheckOutputDeviceAccess(
     int render_frame_id,
     const std::string& device_id,
     const GURL& gurl_security_origin,
     const OutputDeviceAccessCB& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Check security origin if nondefault device is requested.
   // Ignore check for default device, which is always authorized.
-  if (!media::AudioManagerBase::IsDefaultDeviceId(device_id) &&
+  if (!media::AudioDeviceDescription::IsDefaultDevice(device_id) &&
       !ChildProcessSecurityPolicyImpl::GetInstance()->CanRequestURL(
           render_process_id_, gurl_security_origin)) {
     content::bad_message::ReceivedBadMessage(this,
                                              bad_message::ARH_UNAUTHORIZED_URL);
     return;
   }
 
   if (device_id.empty()) {
     callback.Run(true);
   } else {
@@ skipping 22 matching lines @@
 }
 
 void AudioRendererHost::TranslateDeviceID(
     const std::string& device_id,
     const GURL& security_origin,
     const OutputDeviceInfoCB& callback,
     const AudioOutputDeviceEnumeration& enumeration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (const AudioOutputDeviceInfo& device_info : enumeration.devices) {
     if (device_id.empty()) {
-      if (device_info.unique_id == media::AudioManagerBase::kDefaultDeviceId) {
+      if (device_info.unique_id ==
+          media::AudioDeviceDescription::kDefaultDeviceId) {
         callback.Run(true, device_info);
         return;
       }
     } else if (content::DoesMediaDeviceIDMatchHMAC(salt_callback_,
                                                    security_origin, device_id,
                                                    device_info.unique_id)) {
       callback.Run(true, device_info);
       return;
     }
   }
   DCHECK(!device_id.empty());  // Default device must always be found
   AudioOutputDeviceInfo device_info = {
       std::string(), std::string(),
       media::AudioParameters::UnavailableDeviceParams()};
   callback.Run(false, device_info);
 }
 
 bool AudioRendererHost::IsAuthorizationStarted(int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const auto& i = authorizations_.find(stream_id);
   return i != authorizations_.end();
 }
 
 }  // namespace content