Replace AudioManager::GetAudio*DeviceNames with AudioManager::GetAudio*DeviceDescriptions

chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.cc

 // Copyright 2013 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 "chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/lazy_instance.h"
@@ skipping 11 matching lines @@
 #include "extensions/common/permissions/permissions_data.h"
 #include "media/audio/audio_device_description.h"
 #include "media/audio/audio_output_controller.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 namespace extensions {
 
 using content::BrowserThread;
 using content::RenderProcessHost;
-using media::AudioDeviceNames;
+using media::AudioDeviceDescriptions;
 using media::AudioManager;
 
 namespace wap = api::webrtc_audio_private;
 
 using api::webrtc_audio_private::RequestInfo;
 
 static base::LazyInstance<
     BrowserContextKeyedAPIFactory<WebrtcAudioPrivateEventService> > g_factory =
     LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 59 matching lines @@
       router->DispatchEventToExtension(extension_id, std::move(event));
     }
   }
 }
 
 WebrtcAudioPrivateFunction::WebrtcAudioPrivateFunction() {}
 
 WebrtcAudioPrivateFunction::~WebrtcAudioPrivateFunction() {
 }
 
-void WebrtcAudioPrivateFunction::GetOutputDeviceNames() {
+void WebrtcAudioPrivateFunction::GetOutputDeviceDescriptions() {
   scoped_refptr<base::SingleThreadTaskRunner> audio_manager_runner =
       AudioManager::Get()->GetTaskRunner();
   if (!audio_manager_runner->BelongsToCurrentThread()) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     audio_manager_runner->PostTask(
         FROM_HERE,
-        base::Bind(&WebrtcAudioPrivateFunction::GetOutputDeviceNames, this));
+        base::Bind(&WebrtcAudioPrivateFunction::GetOutputDeviceDescriptions,
+                   this));
     return;
   }
 
-  std::unique_ptr<AudioDeviceNames> device_names(new AudioDeviceNames);
-  AudioManager::Get()->GetAudioOutputDeviceNames(device_names.get());
+  std::unique_ptr<AudioDeviceDescriptions> device_descriptions =
+      base::MakeUnique<AudioDeviceDescriptions>();
+  AudioManager::Get()->GetAudioOutputDeviceDescriptions(
+      device_descriptions.get());
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&WebrtcAudioPrivateFunction::OnOutputDeviceNames, this,
-                 base::Passed(&device_names)));
+      base::Bind(&WebrtcAudioPrivateFunction::OnOutputDeviceDescriptions, this,
+                 base::Passed(&device_descriptions)));
 }
 
-void WebrtcAudioPrivateFunction::OnOutputDeviceNames(
-    std::unique_ptr<AudioDeviceNames> device_names) {
+void WebrtcAudioPrivateFunction::OnOutputDeviceDescriptions(
+    std::unique_ptr<AudioDeviceDescriptions> device_descriptions) {
   NOTREACHED();
 }
 
 bool WebrtcAudioPrivateFunction::GetControllerList(const RequestInfo& request) {
   content::RenderProcessHost* rph = nullptr;
 
   // If |guest_process_id| is defined, directly use this id to find the
   // corresponding RenderProcessHost.
   if (request.guest_process_id.get()) {
     rph = content::RenderProcessHost::FromID(*request.guest_process_id);
@@ skipping 42 matching lines @@
 }
 
 void WebrtcAudioPrivateFunction::OnHMACCalculated(const std::string& hmac) {
   NOTREACHED();
 }
 
 std::string WebrtcAudioPrivateFunction::CalculateHMACImpl(
     const std::string& raw_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  // We don't hash the default device name, and we always return
+  // We don't hash the default device description, and we always return
   // "default" for the default device. There is code in SetActiveSink
   // that transforms "default" to the empty string, and code in
   // GetActiveSink that ensures we return "default" if we get the
   // empty string as the current device ID.
   if (media::AudioDeviceDescription::IsDefaultDevice(raw_id))
     return media::AudioDeviceDescription::kDefaultDeviceId;
 
   url::Origin security_origin(source_url().GetOrigin());
   return content::GetHMACForMediaDeviceID(device_id_salt(), security_origin,
                                           raw_id);
 }
 
 void WebrtcAudioPrivateFunction::InitDeviceIDSalt() {
   device_id_salt_ = GetProfile()->GetResourceContext()->GetMediaDeviceIDSalt();
 }
 
 std::string WebrtcAudioPrivateFunction::device_id_salt() const {
   return device_id_salt_;
 }
 
 bool WebrtcAudioPrivateGetSinksFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   InitDeviceIDSalt();
-  GetOutputDeviceNames();
+  GetOutputDeviceDescriptions();
 
   return true;
 }
 
-void WebrtcAudioPrivateGetSinksFunction::OnOutputDeviceNames(
-    std::unique_ptr<AudioDeviceNames> raw_ids) {
+void WebrtcAudioPrivateGetSinksFunction::OnOutputDeviceDescriptions(
+    std::unique_ptr<AudioDeviceDescriptions> raw_ids) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   std::vector<wap::SinkInfo> results;
-  for (const media::AudioDeviceName& name : *raw_ids) {
+  for (const media::AudioDeviceDescription& description : *raw_ids) {
     wap::SinkInfo info;
-    info.sink_id = CalculateHMACImpl(name.unique_id);
-    info.sink_label = name.device_name;
+    info.sink_id = CalculateHMACImpl(description.unique_id);
+    info.sink_label = description.device_name;
     // TODO(joi): Add other parameters.
     results.push_back(std::move(info));
   }
 
   // It's safe to directly set the results here (from a thread other
   // than the UI thread, on which an AsyncExtensionFunction otherwise
   // normally runs) because there is one instance of this object per
   // function call, no actor outside of this object is modifying the
   // results_ member, and the different method invocations on this
   // object run strictly in sequence; first RunAsync on the UI thread,
@@ skipping 105 matching lines @@
   }
 
   controllers_ = controllers;
   num_remaining_sink_ids_ = controllers_.size();
   if (num_remaining_sink_ids_ == 0) {
     error_ = extensions::ErrorUtils::FormatErrorMessage(
         "No active stream for " + requested_process_type + " *",
         base::IntToString(requested_process_id));
     SendResponse(false);
   } else {
-    // We need to get the output device names, and calculate the HMAC
+    // We need to get the output device IDs, and calculate the HMAC
     // for each, to find the raw ID for the ID provided to this API
     // function call.
-    GetOutputDeviceNames();
+    GetOutputDeviceDescriptions();
   }
 }
 
-void WebrtcAudioPrivateSetActiveSinkFunction::OnOutputDeviceNames(
-    std::unique_ptr<AudioDeviceNames> device_names) {
+void WebrtcAudioPrivateSetActiveSinkFunction::OnOutputDeviceDescriptions(
+    std::unique_ptr<AudioDeviceDescriptions> device_descriptions) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   std::string raw_sink_id;
   if (sink_id_ == media::AudioDeviceDescription::kDefaultDeviceId) {
     DVLOG(2) << "Received default ID, replacing with empty ID.";
     raw_sink_id = "";
   } else {
-    for (AudioDeviceNames::const_iterator it = device_names->begin();
-         it != device_names->end();
-         ++it) {
+    for (AudioDeviceDescriptions::const_iterator it =
+             device_descriptions->begin();
+         it != device_descriptions->end(); ++it) {
       if (sink_id_ == CalculateHMACImpl(it->unique_id)) {
         raw_sink_id = it->unique_id;
         break;
       }
     }
 
     if (raw_sink_id.empty())
       DVLOG(2) << "Found no matching raw sink ID for HMAC " << sink_id_;
   }
 
@@ skipping 37 matching lines @@
   AudioManager::Get()->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&WebrtcAudioPrivateGetAssociatedSinkFunction::
                  GetDevicesOnDeviceThread, this));
 
   return true;
 }
 
 void WebrtcAudioPrivateGetAssociatedSinkFunction::GetDevicesOnDeviceThread() {
   DCHECK(AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
-  AudioManager::Get()->GetAudioInputDeviceNames(&source_devices_);
+  AudioManager::Get()->GetAudioInputDeviceDescriptions(&source_devices_);
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&WebrtcAudioPrivateGetAssociatedSinkFunction::
                  GetRawSourceIDOnIOThread,
                  this));
 }
 
 void
 WebrtcAudioPrivateGetAssociatedSinkFunction::GetRawSourceIDOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   url::Origin security_origin(GURL(params_->security_origin));
   std::string source_id_in_origin(params_->source_id_in_origin);
 
   // Find the raw source ID for source_id_in_origin.
   std::string raw_source_id;
-  for (AudioDeviceNames::const_iterator it = source_devices_.begin();
-       it != source_devices_.end();
-       ++it) {
+  for (AudioDeviceDescriptions::const_iterator it = source_devices_.begin();
+       it != source_devices_.end(); ++it) {
     const std::string& id = it->unique_id;
     if (content::DoesMediaDeviceIDMatchHMAC(device_id_salt(), security_origin,
                                             source_id_in_origin, id)) {
       raw_source_id = id;
       DVLOG(2) << "Found raw ID " << raw_source_id
                << " for source ID in origin " << source_id_in_origin;
       break;
     }
   }
 
@@ skipping 28 matching lines @@
     DVLOG(2) << "Got default ID, replacing with empty ID.";
     results_ = wap::GetAssociatedSink::Results::Create("");
   } else {
     results_ = wap::GetAssociatedSink::Results::Create(associated_sink_id);
   }
 
   SendResponse(true);
 }
 
 }  // namespace extensions