Allow AudioOutputDevice objects to be initialized with a specific hardware output device and store …

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
@@ skipping 43 matching lines @@
                                                 bool is_playing,
                                                 int render_view_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (render_view_id == MSG_ROUTING_NONE || !ResourceDispatcherHostImpl::Get())
     return;
 
   ResourceDispatcherHostImpl::Get()->OnAudioRenderHostStreamStateChanged(
       render_process_id, render_view_id, is_playing);
 }
 
+media::AudioParameters DummyParams() {
+  return media::AudioParameters(media::AudioParameters::AUDIO_PCM_LINEAR,
+                                media::CHANNEL_LAYOUT_STEREO,
+                                media::limits::kMinSampleRate, 1, 1);
+}
+
+std::pair<int, std::pair<bool, std::string>> MakeAuthorizationData(
+    int stream_id,
+    bool authorized,
+    const std::string& device_unique_id) {
+  return std::make_pair(stream_id,
+                        std::make_pair(authorized, device_unique_id));
+}
+
 }  // namespace
 
 class AudioRendererHost::AudioEntry
     : public media::AudioOutputController::EventHandler {
  public:
   AudioEntry(AudioRendererHost* host,
              int stream_id,
              int render_frame_id,
              const media::AudioParameters& params,
              const std::string& output_device_id,
@@ skipping 103 matching lines @@
       BrowserThread::IO, FROM_HERE,
       base::Bind(&AudioRendererHost::DoGetOutputControllers, this), callback);
 }
 
 void AudioRendererHost::OnChannelClosing() {
   // Since the IPC sender is gone, close all requested audio streams.
   while (!audio_entries_.empty()) {
     // Note: OnCloseStream() removes the entries from audio_entries_.
     OnCloseStream(audio_entries_.begin()->first);
   }
+
+  // Remove any authorizations for streams that were not yet created
+  authorizations_.clear();
 }
 
 void AudioRendererHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
 void AudioRendererHost::AudioEntry::OnCreated() {
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
@@ skipping 108 matching lines @@
   }
 
   return controllers;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // IPC Messages handler
 bool AudioRendererHost::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AudioRendererHost, message)
+    IPC_MESSAGE_HANDLER(AudioHostMsg_RequestDeviceAuthorization,
+                        OnRequestDeviceAuthorization)
     IPC_MESSAGE_HANDLER(AudioHostMsg_CreateStream, OnCreateStream)
     IPC_MESSAGE_HANDLER(AudioHostMsg_PlayStream, OnPlayStream)
     IPC_MESSAGE_HANDLER(AudioHostMsg_PauseStream, OnPauseStream)
     IPC_MESSAGE_HANDLER(AudioHostMsg_CloseStream, OnCloseStream)
     IPC_MESSAGE_HANDLER(AudioHostMsg_SetVolume, OnSetVolume)
     IPC_MESSAGE_HANDLER(AudioHostMsg_SwitchOutputDevice, OnSwitchOutputDevice)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
+void AudioRendererHost::OnRequestDeviceAuthorization(
+    int stream_id,
+    int render_frame_id,
+    int session_id,
+    const std::string& device_id,
+    const GURL& security_origin) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DVLOG(1) << "AudioRendererHost@" << this << "::OnRequestDeviceAuthorization"
+           << "(stream_id=" << stream_id
+           << ", render_frame_id=" << render_frame_id
+           << ", session_id=" << session_id << ", device_id=" << device_id
+           << ", security_origin=" << security_origin << ")";
+
+  if (LookupById(stream_id) || IsAuthorizationStarted(stream_id))
+    return;
+
+  // If attempting to use the output device associated to an opened input
+  // device and the output device is found, reuse the input device
+  // permissions.
+  if (session_id != 0) {
+    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);
+      output_params.set_effects(info->device.matched_output.effects);
+      authorizations_.insert(MakeAuthorizationData(
+          stream_id, true, info->device.matched_output_device_id));
+      Send(new AudioMsg_NotifyDeviceAuthorized(stream_id, true, output_params));
+      return;
+    }
+  }
+
+  authorizations_.insert(
+      MakeAuthorizationData(stream_id, false, std::string()));
+  CheckOutputDeviceAccess(
+      render_frame_id, device_id, security_origin,
+      base::Bind(&AudioRendererHost::RequestDeviceAuthorizationAccessChecked,
+                 this, stream_id, device_id, security_origin));
+}
+
+void AudioRendererHost::RequestDeviceAuthorizationAccessChecked(

[DaleCurtis, 2015/09/12 01:17:19]

OnDeviceAuthorized?

[Guido Urdaneta, 2015/09/14 11:35:48]

Done.

+    int stream_id,
+    const std::string& device_id,
+    const GURL& security_origin,
+    bool have_access) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  const auto& auth_data = authorizations_.find(stream_id);
+
+  // A close request was received while access check was in progress.
+  if (auth_data == authorizations_.end())
+    return;
+
+  if (!have_access) {
+    authorizations_.erase(auth_data);
+    Send(new AudioMsg_NotifyDeviceAuthorized(stream_id, false, DummyParams()));
+    return;
+  }
+
+  TranslateDeviceID(
+      device_id, security_origin,
+      base::Bind(&AudioRendererHost::RequestDeviceAuthorizationTranslated, this,
+                 stream_id));
+}
+
+void AudioRendererHost::RequestDeviceAuthorizationTranslated(

[DaleCurtis, 2015/09/12 01:17:19]

OnDeviceIDTranslated?

[Guido Urdaneta, 2015/09/14 11:35:48]

Done.

+    int stream_id,
+    bool device_found,
+    const AudioOutputDeviceInfo& device_info) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  const auto& auth_data = authorizations_.find(stream_id);
+
+  // A close request was received while translation was in progress
+  if (auth_data == authorizations_.end())
+    return;
+
+  if (!device_found) {
+    authorizations_.erase(auth_data);
+    Send(new AudioMsg_NotifyDeviceAuthorized(stream_id, false, DummyParams()));
+    return;
+  }
+
+  auth_data->second.first = true;
+  auth_data->second.second = device_info.unique_id;
+  Send(new AudioMsg_NotifyDeviceAuthorized(stream_id, true,
+                                           device_info.output_params));
+}
+
 void AudioRendererHost::OnCreateStream(int stream_id,
                                        int render_frame_id,
-                                       int session_id,
                                        const media::AudioParameters& params) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DVLOG(1) << "AudioRendererHost@" << this << "::OnCreateStream"
+           << "(stream_id=" << stream_id << ")";
 
-  DVLOG(1) << "AudioRendererHost@" << this
-           << "::OnCreateStream(stream_id=" << stream_id
-           << ", render_frame_id=" << render_frame_id
-           << ", session_id=" << session_id << ")";
-  DCHECK_GT(render_frame_id, 0);
+  const auto& auth_data = authorizations_.find(stream_id);
+
+  // If no previous authorization requested, assume default device
+  if (auth_data == authorizations_.end()) {
+    DoCreateStream(stream_id, render_frame_id, params, std::string());
+    return;
+  }
+
+  // If authorization is not finished, ignore this request, as it is invalid.

[DaleCurtis, 2015/09/12 01:17:19]

Can we CHECK this?

[Guido Urdaneta, 2015/09/14 11:35:48]

Done.

+  if (!auth_data->second.first)
+    return;
+
+  DoCreateStream(stream_id, render_frame_id, params, auth_data->second.second);
+  authorizations_.erase(auth_data);
+}
+
+void AudioRendererHost::DoCreateStream(int stream_id,
+                                       int render_frame_id,
+                                       const media::AudioParameters& params,
+                                       const std::string& device_unique_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // media::AudioParameters is validated in the deserializer.
   if (LookupById(stream_id) != NULL) {
     SendErrorMessage(stream_id);
     return;
   }
 
-  // Initialize the |output_device_id| to an empty string which indicates that
-  // the default device should be used. If a StreamDeviceInfo instance was found
-  // though, then we use the matched output device.
-  std::string output_device_id;
-  const StreamDeviceInfo* info = media_stream_manager_->
-      audio_input_device_manager()->GetOpenedDeviceInfoById(session_id);
-  if (info)
-    output_device_id = info->device.matched_output_device_id;
-
   // Create the shared memory and share with the renderer process.
   uint32 shared_memory_size = AudioBus::CalculateMemorySize(params);
   scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
   if (!shared_memory->CreateAndMapAnonymous(shared_memory_size)) {
     SendErrorMessage(stream_id);
     return;
   }
 
   scoped_ptr<AudioSyncReader> reader(
       new AudioSyncReader(shared_memory.get(), params));
   if (!reader->Init()) {
     SendErrorMessage(stream_id);
     return;
   }
 
   MediaObserver* const media_observer =
       GetContentClient()->browser()->GetMediaObserver();
   if (media_observer)
     media_observer->OnCreatingAudioStream(render_process_id_, render_frame_id);
 
-  scoped_ptr<AudioEntry> entry(new AudioEntry(this,
-                                              stream_id,
-                                              render_frame_id,
-                                              params,
-                                              output_device_id,
-                                              shared_memory.Pass(),
-                                              reader.Pass()));
+  scoped_ptr<AudioEntry> entry(
+      new AudioEntry(this, stream_id, render_frame_id, params, device_unique_id,
+                     shared_memory.Pass(), reader.Pass()));
   if (mirroring_manager_) {
     mirroring_manager_->AddDiverter(
         render_process_id_, entry->render_frame_id(), entry->controller());
   }
   audio_entries_.insert(std::make_pair(stream_id, entry.release()));
-  audio_log_->OnCreated(stream_id, params, output_device_id);
+
+  audio_log_->OnCreated(stream_id, params, device_unique_id);
   MediaInternals::GetInstance()->SetWebContentsTitleForAudioLogEntry(
       stream_id, render_process_id_, render_frame_id, audio_log_.get());
 }
 
 void AudioRendererHost::OnPlayStream(int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   AudioEntry* entry = LookupById(stream_id);
   if (!entry) {
     SendErrorMessage(stream_id);
@@ skipping 29 matching lines @@
   // Make sure the volume is valid.
   if (volume < 0 || volume > 1.0)
     return;
   entry->controller()->SetVolume(volume);
   audio_log_->OnSetVolume(stream_id, volume);
 }
 
 void AudioRendererHost::OnSwitchOutputDevice(int stream_id,
                                              int render_frame_id,
                                              const std::string& device_id,
-                                             const GURL& security_origin,
-                                             int request_id) {
+                                             const GURL& security_origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "AudioRendererHost@" << this
            << "::OnSwitchOutputDevice(stream_id=" << stream_id
            << ", render_frame_id=" << render_frame_id
            << ", device_id=" << device_id
-           << ", security_origin=" << security_origin
-           << ", request_id=" << request_id << ")";
-  if (!ChildProcessSecurityPolicyImpl::GetInstance()->CanRequestURL(
-          render_process_id_, security_origin)) {
-    content::bad_message::ReceivedBadMessage(this,
-                                             bad_message::ARH_UNAUTHORIZED_URL);
+           << ", security_origin=" << security_origin << ")";
+  CheckOutputDeviceAccess(
+      render_frame_id, device_id, security_origin,
+      base::Bind(&AudioRendererHost::SwitchOutputDeviceAccessChecked, this,
+                 stream_id, device_id, security_origin));
+}
+
+void AudioRendererHost::SwitchOutputDeviceAccessChecked(
+    int stream_id,
+    const std::string& device_id,
+    const GURL& security_origin,
+    bool have_access) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!have_access) {
+    Send(new AudioMsg_NotifyOutputDeviceSwitched(
+        stream_id, media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_NOT_AUTHORIZED,
+        DummyParams()));
     return;
   }
 
-  if (device_id.empty()) {
-    DVLOG(1) << __FUNCTION__ << ": default output device requested. "
-             << "No permissions check or device translation/validation needed.";
-    DoSwitchOutputDevice(stream_id, device_id, request_id);
-  } else {
-    // Check that MediaStream device permissions have been granted,
-    // hence the use of a MediaStreamUIProxy.
-    scoped_ptr<MediaStreamUIProxy> ui_proxy = MediaStreamUIProxy::Create();
-
-    // Use MEDIA_DEVICE_AUDIO_CAPTURE instead of MEDIA_DEVICE_AUDIO_OUTPUT
-    // because MediaStreamUIProxy::CheckAccess does not currently support
-    // MEDIA_DEVICE_AUDIO_OUTPUT.
-    // TODO(guidou): Change to MEDIA_DEVICE_AUDIO_OUTPUT when support becomes
-    // available. http://crbug.com/498675
-    ui_proxy->CheckAccess(
-        security_origin, MEDIA_DEVICE_AUDIO_CAPTURE,
-        render_process_id_, render_frame_id,
-        base::Bind(&AudioRendererHost::OutputDeviceAccessChecked, this,
-                   base::Passed(&ui_proxy), stream_id, device_id,
-                   security_origin, render_frame_id, request_id));
-  }
+  // TODO(guidou): Ensure that output parameters of the new device match the
+  // output parameters of the current device to avoid shared-memory sizing
+  // issues. http://crbug.com/526657
+  TranslateDeviceID(device_id, security_origin,
+                    base::Bind(&AudioRendererHost::SwitchOutputDeviceTranslated,
+                               this, stream_id));
 }
 
-void AudioRendererHost::OutputDeviceAccessChecked(
-    scoped_ptr<MediaStreamUIProxy> ui_proxy,
+void AudioRendererHost::SwitchOutputDeviceTranslated(
     int stream_id,
-    const std::string& device_id,
-    const GURL& security_origin,
-    int render_frame_id,
-    int request_id,
-    bool have_access) {
+    bool device_found,
+    const AudioOutputDeviceInfo& device_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DVLOG(1) << __FUNCTION__;
-  if (!have_access) {
-    DVLOG(0) << __FUNCTION__
-             << ": Have no access to media devices. Not switching device.";
+  if (!device_found) {
     Send(new AudioMsg_NotifyOutputDeviceSwitched(
-        stream_id, request_id,
-        media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_NOT_AUTHORIZED));
+        stream_id, media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_NOT_FOUND,
+        DummyParams()));
     return;
   }
 
-  scoped_refptr<base::SingleThreadTaskRunner> audio_worker_runner =
-      AudioManager::Get()->GetWorkerTaskRunner();
-  audio_worker_runner->PostTask(
-      FROM_HERE,
-      base::Bind(&AudioRendererHost::StartTranslateOutputDeviceName, this,
-                 stream_id, device_id, security_origin, request_id));
-}
-
-void AudioRendererHost::StartTranslateOutputDeviceName(
-    int stream_id,
-    const std::string& device_id,
-    const GURL& security_origin,
-    int request_id) {
-  DCHECK(AudioManager::Get()->GetWorkerTaskRunner()->BelongsToCurrentThread());
-  DCHECK(!device_id.empty());
-  DVLOG(1) << __FUNCTION__;
-
-  media::AudioDeviceNames* device_names(new media::AudioDeviceNames);
-  AudioManager::Get()->GetAudioOutputDeviceNames(device_names);
-
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&AudioRendererHost::FinishTranslateOutputDeviceName, this,
-                 stream_id, device_id, security_origin, request_id,
-                 base::Owned(device_names)));
-}
-
-void AudioRendererHost::FinishTranslateOutputDeviceName(
-    int stream_id,
-    const std::string& device_id,
-    const GURL& security_origin,
-    int request_id,
-    media::AudioDeviceNames* device_names) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(!device_id.empty());
-  DVLOG(1) << __FUNCTION__;
-
-  std::string raw_device_id;
-  // Process the enumeration here because |salt_callback_| can run
-  // only on the IO thread
-  for (const auto& device_name : *device_names) {
-    const std::string candidate_device_id = content::GetHMACForMediaDeviceID(
-        salt_callback_, security_origin, device_name.unique_id);
-    if (candidate_device_id == device_id) {
-      DVLOG(1) << "Requested device " << device_name.unique_id << " - "
-               << device_name.device_name;
-      raw_device_id = device_name.unique_id;
-    }
-  }
-
-  if (raw_device_id.empty()) {
-    DVLOG(1) << "Requested device " << device_id << " could not be found.";
-    Send(new AudioMsg_NotifyOutputDeviceSwitched(
-        stream_id, request_id,
-        media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_NOT_FOUND));
-    return;
-  }
-
-  DoSwitchOutputDevice(stream_id, raw_device_id, request_id);
-}
-
-void AudioRendererHost::DoSwitchOutputDevice(int stream_id,
-                                             const std::string& raw_device_id,
-                                             int request_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DVLOG(1) << __FUNCTION__ << "(" << stream_id << ", " << raw_device_id << ", "
-           << request_id << ")";
   AudioEntry* entry = LookupById(stream_id);
   if (!entry) {
     Send(new AudioMsg_NotifyOutputDeviceSwitched(
-        stream_id, request_id,
-        media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_OBSOLETE));
+        stream_id, media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_INTERNAL,
+        DummyParams()));
     return;
   }
 
   entry->controller()->SwitchOutputDevice(
-      raw_device_id, base::Bind(&AudioRendererHost::DoOutputDeviceSwitched,
-                                this, stream_id, request_id));
-  audio_log_->OnSwitchOutputDevice(entry->stream_id(), raw_device_id);
+      device_info.unique_id,
+      base::Bind(&AudioRendererHost::OutputDeviceSwitched, this, stream_id,
+                 device_info.output_params));
+  audio_log_->OnSwitchOutputDevice(entry->stream_id(), device_info.unique_id);
 }
 
-void AudioRendererHost::DoOutputDeviceSwitched(int stream_id, int request_id) {
+void AudioRendererHost::OutputDeviceSwitched(

[DaleCurtis, 2015/09/12 01:17:19]

OnDeviceSwitched?

[Guido Urdaneta, 2015/09/14 11:35:48]

Done.

+    int stream_id,
+    const media::AudioParameters& output_params) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DVLOG(1) << __FUNCTION__ << "(" << stream_id << ", " << request_id << ")";
   Send(new AudioMsg_NotifyOutputDeviceSwitched(
-      stream_id, request_id, media::SWITCH_OUTPUT_DEVICE_RESULT_SUCCESS));
+      stream_id, media::SWITCH_OUTPUT_DEVICE_RESULT_SUCCESS, output_params));
 }
 
 void AudioRendererHost::SendErrorMessage(int stream_id) {
   Send(new AudioMsg_NotifyStreamStateChanged(
       stream_id, media::AUDIO_OUTPUT_IPC_DELEGATE_STATE_ERROR));
 }
 
 void AudioRendererHost::OnCloseStream(int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  authorizations_.erase(stream_id);
 
   // Prevent oustanding callbacks from attempting to close/delete the same
   // AudioEntry twice.
   AudioEntryMap::iterator i = audio_entries_.find(stream_id);
   if (i == audio_entries_.end())
     return;
   scoped_ptr<AudioEntry> entry(i->second);
   audio_entries_.erase(i);
 
   media::AudioOutputController* const controller = entry->controller();
@@ skipping 77 matching lines @@
   for (AudioEntryMap::const_iterator it = audio_entries_.begin();
        it != audio_entries_.end();
        ++it) {
     AudioEntry* entry = it->second;
     if (entry->render_frame_id() == render_frame_id && entry->playing())
       return true;
   }
   return false;
 }
 
+void AudioRendererHost::CheckOutputDeviceAccess(
+    int render_frame_id,
+    const std::string& device_id,
+    const GURL& security_origin,
+    const OutputDeviceAccessCB& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  // Skip origin check in requests for the default device with an empty
+  // security origin.
+  bool skip_origin_check = security_origin.is_empty() && device_id.empty();
+  if (!skip_origin_check &&
+      !ChildProcessSecurityPolicyImpl::GetInstance()->CanRequestURL(
+          render_process_id_, security_origin)) {
+    content::bad_message::ReceivedBadMessage(this,
+                                             bad_message::ARH_UNAUTHORIZED_URL);
+    return;
+  }
+
+  if (device_id.empty()) {
+    callback.Run(true);
+  } else {
+    // Check that MediaStream device permissions have been granted,
+    // hence the use of a MediaStreamUIProxy.
+    scoped_ptr<MediaStreamUIProxy> ui_proxy = MediaStreamUIProxy::Create();
+
+    // Use MEDIA_DEVICE_AUDIO_CAPTURE instead of MEDIA_DEVICE_AUDIO_OUTPUT
+    // because MediaStreamUIProxy::CheckAccess does not currently support
+    // MEDIA_DEVICE_AUDIO_OUTPUT.
+    // TODO(guidou): Change to MEDIA_DEVICE_AUDIO_OUTPUT when support becomes
+    // available. http://crbug.com/498675
+    ui_proxy->CheckAccess(security_origin, MEDIA_DEVICE_AUDIO_CAPTURE,
+                          render_process_id_, render_frame_id,
+                          base::Bind(&AudioRendererHost::AccessChecked, this,
+                                     base::Passed(&ui_proxy), callback));
+  }
+}
+
+void AudioRendererHost::AccessChecked(scoped_ptr<MediaStreamUIProxy> ui_proxy,
+                                      const OutputDeviceAccessCB& callback,
+                                      bool have_access) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  callback.Run(have_access);
+}
+
+void AudioRendererHost::TranslateDeviceID(const std::string& device_id,
+                                          const GURL& security_origin,
+                                          const OutputDeviceInfoCB& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  AudioOutputDeviceEnumerator* enumerator =
+      media_stream_manager_->audio_output_device_enumerator();
+  enumerator->Enumerate(base::Bind(&AudioRendererHost::FinishTranslateDeviceID,
+                                   this, device_id, security_origin, callback));
+}
+
+void AudioRendererHost::FinishTranslateDeviceID(
+    const std::string& device_id,
+    const GURL& security_origin,
+    const OutputDeviceInfoCB& callback,
+    const AudioOutputDeviceEnumeration& device_infos) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  bool use_default_device = device_id.empty();
+  for (const AudioOutputDeviceInfo& device_info : device_infos) {
+    if (use_default_device) {
+      if (device_info.unique_id == media::AudioManagerBase::kDefaultDeviceId) {
+        callback.Run(true, device_info);
+        return;
+      }
+    } else {
+      const std::string candidate_device_id = content::GetHMACForMediaDeviceID(
+          salt_callback_, security_origin, device_info.unique_id);
+      if (candidate_device_id == device_id) {
+        callback.Run(true, device_info);
+        return;
+      }
+    }
+  }
+  DCHECK(!use_default_device);  // Default device must always be found
+  AudioOutputDeviceInfo device_info = {std::string(), std::string(),
+                                       DummyParams()};
+  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