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 <utility>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
@@ skipping 37 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);
+}
+
 }  // 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 62 matching lines @@
                                                        this,
                                                        params,
                                                        output_device_id,
                                                        reader_.get())),
       playing_(false) {
   DCHECK(controller_.get());
 }
 
 AudioRendererHost::AudioEntry::~AudioEntry() {}
 
+class AudioRendererHost::AuthorizationData {

[DaleCurtis, 2015/09/09 01:31:57]

Hmm, this is a lot of data and complexity added to the ARH class. I think we can
at least remove all the AudioParameters from this structure by restricting what
the renderer is allowed to call.

If we can't simplify this further, I think this functionality should be moved
into a helper class that AudioRendererHost uses to manage authorizations -- as
otherwise this is too much complexity to add into the main AudioRendererHost
class.

[Guido Urdaneta, 2015/09/09 16:22:23]

I removed this class altogether and replaced it with a pair.
A lot of the complexity was to support multiple Start()/Stop().
I moved the complexity to AOD by having an extra AUTHORIZED state and delaying
CreateStream until after that state.

+ public:
+  explicit AuthorizationData(int render_frame_id);
+  AuthorizationData(int render_frame_id,
+                    const std::string& unique_id,
+                    const media::AudioParameters& output_params);
+  ~AuthorizationData() = default;
+  bool is_authorized() const { return is_authorized_; }
+  int render_frame_id() const { return render_frame_id_; }
+  bool is_creation_requested() const { return is_creation_requested_; }
+  media::AudioParameters creation_params() const { return creation_params_; }
+  std::string device_unique_id() const { return device_unique_id_; }
+  media::AudioParameters device_output_params() const {
+    return device_output_params_;
+  }
+
+  void Authorize(const std::string& unique_id,
+                 const media::AudioParameters& output_params);
+  void RequestCreation(const media::AudioParameters& params);
+
+ private:
+  bool is_authorized_;
+  int render_frame_id_;
+  bool is_creation_requested_;
+  media::AudioParameters creation_params_;
+  std::string device_unique_id_;
+  media::AudioParameters device_output_params_;
+};
+
+AudioRendererHost::AuthorizationData::AuthorizationData(int render_frame_id)
+    : is_authorized_(false),
+      render_frame_id_(render_frame_id),
+      is_creation_requested_(false) {}
+
+AudioRendererHost::AuthorizationData::AuthorizationData(
+    int render_frame_id,
+    const std::string& device_unique_id,
+    const media::AudioParameters& device_output_params)
+    : is_authorized_(true),
+      render_frame_id_(render_frame_id),
+      is_creation_requested_(false),
+      device_unique_id_(device_unique_id),
+      device_output_params_(device_output_params) {}
+
+void AudioRendererHost::AuthorizationData::Authorize(
+    const std::string& device_unique_id,
+    const media::AudioParameters& device_output_params) {
+  is_authorized_ = true;
+  device_unique_id_ = device_unique_id;
+  device_output_params_ = device_output_params;
+}
+
+void AudioRendererHost::AuthorizationData::RequestCreation(
+    const media::AudioParameters& params) {
+  is_creation_requested_ = true;
+  creation_params_ = params;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // AudioRendererHost implementations.
 
 AudioRendererHost::AudioRendererHost(
     int render_process_id,
     media::AudioManager* audio_manager,
     AudioMirroringManager* mirroring_manager,
     MediaInternals* media_internals,
     MediaStreamManager* media_stream_manager,
     const ResourceContext::SaltCallback& salt_callback)
@@ skipping 21 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,
+          info->device.matched_output.effects);
+      authorizations_.insert(std::pair<int, AuthorizationData>(
+          stream_id, AuthorizationData(render_frame_id,
+                                       info->device.matched_output_device_id,
+                                       output_params)));
+      Send(new AudioMsg_NotifyDeviceAuthorized(stream_id, true, output_params));
+      return;
+    }
+  }
+
+  authorizations_.insert(std::pair<int, AuthorizationData>(
+      stream_id, AuthorizationData(render_frame_id)));
+  CheckOutputDeviceAccess(
+      render_frame_id, device_id, security_origin,
+      base::Bind(&AudioRendererHost::RequestDeviceAuthorizationAccessChecked,
+                 this, stream_id, device_id, security_origin));
+}
+
+void AudioRendererHost::RequestDeviceAuthorizationAccessChecked(
+    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(
+    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 access check was in progress

[DaleCurtis, 2015/09/09 01:31:57]

translate was in progress?

[Guido Urdaneta, 2015/09/09 16:22:23]

Done.

+  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.Authorize(device_info.unique_id, device_info.output_params);
+  Send(new AudioMsg_NotifyDeviceAuthorized(stream_id, true,
+                                           device_info.output_params));
+
+  if (auth_data->second.is_creation_requested()) {
+    DoCreateStream(stream_id, auth_data->second.render_frame_id(),
+                   auth_data->second.creation_params(), device_info.unique_id);
+    authorizations_.erase(auth_data);
+  }
+}
+
 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
-           << ", render_frame_id=" << render_frame_id
-           << ", session_id=" << session_id << ")";
-  DCHECK_GT(render_frame_id, 0);
+  DVLOG(1) << "AudioRendererHost@" << this << "::OnCreateStream"
+           << "(stream_id=" << stream_id << ")";
+
+  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;
+  }
+
+  DCHECK_EQ(render_frame_id, auth_data->second.render_frame_id());
+  // If authorization is ongoing, defer creation.

[DaleCurtis, 2015/09/09 01:31:57]

This ends up adding substantial complexity. Can we drop this from the renderer
side and remove the creation params and such? I.e. never allow an AOD which has
started an authorization request to call create while it's in progress?

It looks like removing that would allow you to get rid of needing to track
AudioParameters in the data.

[Guido Urdaneta, 2015/09/09 16:22:23]

Done. See comment above.

+  if (!auth_data->second.is_authorized()) {
+    auth_data->second.RequestCreation(params);
+    return;
+  }
+
+  // If already authorized, create stream and remove authorization
+  DoCreateStream(stream_id, render_frame_id, params,
+                 auth_data->second.device_unique_id());
+  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 26 matching lines @@
     return;
   }
 
   // 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,

[DaleCurtis, 2015/09/09 01:31:57]

As mentioned in the AOD class, after this CL lands, I think we should remove the
browser side SwitchOutputDevice functionality and require that AOD be recreated
every time. It would allow us to remove this extra state here in favor of a
self-contained helper class on the renderer side which can manage the switch
callbacks and AOD instances.

I.e. you could create something like a SwitchOutputDeviceHelper class which both
WebRTC and AudioRendererMixerInput could construct and use when a
switchOutputDevice() call comes in from JavaScript. That class would handle the
complexities of creating a new AudioOutputDevice for the new device, return
errors via callback if authorization/creation fails, and return the new
AudioOutputDevice if authorization succeeds.

As a separate class it could be well tested and modular w/o having to be weighed
down by internal state details of the AudioOutputDevice.

[Guido Urdaneta, 2015/09/09 16:22:23]

That is the goal. 

A possible road map after this CL is:
1. Allow ARMI to switch device by using a new AOD (I have a working version of
this already).
2. Allow the WebRTC renderers to switch device by using a new AOD.
3. Remove SwitchOutputDevice() functionality from ARH and AOD.

I haven't studied yet how big the change is for 2. If it's nontrivial, I will
first send a CL to reject SwitchOutputDevice() to devices with different
parameters before working on 2.
At this time, I think the solution would be specific for each case. ARMI doesn't
use AOD directly, but through a mixer created by ARMM, while WebRTC uses AOD
directly. I haven't looked at the WebRTC case in detail yet, but let's  talk
more about this in the next CL.

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

sgtm!

                                              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));
-  }
+  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(
+    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
+  callback.Run(false, {std::string(), std::string(), DummyParams()});

[DaleCurtis, 2015/09/09 01:31:57]

Is this initialization syntax allowed? http://chromium-cpp.appspot.com/

[Guido Urdaneta, 2015/09/09 16:22:23]

Structs are allowed to be initialized this way, but now I'm not sure if it's
allowed to initialize a function argument.
Using a temp variable now to be sure. 

+}
+
+bool AudioRendererHost::IsAuthorizationStarted(int stream_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  const auto& i = authorizations_.find(stream_id);
+  return i != authorizations_.end();
+}
+
 }  // namespace content