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

chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_browsertest.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 <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/json/json_writer.h"
@@ skipping 25 matching lines @@
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "media/audio/audio_device_description.h"
 #include "media/audio/audio_manager.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::JSONWriter;
 using content::RenderProcessHost;
 using content::WebContents;
-using media::AudioDeviceNames;
+using media::AudioDeviceDescriptions;
 using media::AudioManager;
 
 namespace extensions {
 
 using extension_function_test_utils::RunFunctionAndReturnError;
 using extension_function_test_utils::RunFunctionAndReturnSingleResult;
 
 class AudioWaitingExtensionTest : public ExtensionApiTest {
  protected:
   void WaitUntilAudioIsPlaying(WebContents* tab) {
@@ skipping 65 matching lines @@
     function->set_source_url(source_url_);
 
     std::unique_ptr<base::Value> result(
         RunFunctionAndReturnSingleResult(function.get(), "[]", browser()));
     result->GetAsList(sink_list);
     return result;
   }
 
   // Synchronously (from the calling thread's point of view) runs the
   // given enumeration function on the device thread. On return,
-  // |device_names| has been filled with the device names resulting
-  // from that call.
-  void GetAudioDeviceNames(
-      void (AudioManager::*EnumerationFunc)(AudioDeviceNames*),
-      AudioDeviceNames* device_names) {
+  // |device_descriptions| has been filled with the device descriptions
+  // resulting from that call.
+  void GetAudioDeviceDescriptions(
+      void (AudioManager::*EnumerationFunc)(AudioDeviceDescriptions*),
+      AudioDeviceDescriptions* device_descriptions) {
     AudioManager* audio_manager = AudioManager::Get();
 
     if (!audio_manager->GetTaskRunner()->BelongsToCurrentThread()) {
       audio_manager->GetTaskRunner()->PostTask(
           FROM_HERE,
-          base::Bind(&WebrtcAudioPrivateTest::GetAudioDeviceNames,
-                     base::Unretained(this),
-                     EnumerationFunc, device_names));
+          base::Bind(&WebrtcAudioPrivateTest::GetAudioDeviceDescriptions,
+                     base::Unretained(this), EnumerationFunc,
+                     device_descriptions));
       enumeration_event_.Wait();
     } else {
-      (audio_manager->*EnumerationFunc)(device_names);
+      (audio_manager->*EnumerationFunc)(device_descriptions);
       enumeration_event_.Signal();
     }
   }
 
   // Synchronously (from the calling thread's point of view) retrieve the
   // device id in the |origin| on the IO thread. On return,
   // |id_in_origin| contains the id |raw_device_id| is known by in
   // the origin.
   void GetIDInOrigin(content::ResourceContext* resource_context,
                      GURL origin,
@@ skipping 16 matching lines @@
 
   // Event used to signal completion of enumeration.
   base::WaitableEvent enumeration_event_;
 
   GURL source_url_;
 };
 
 #if !defined(OS_MACOSX)
 // http://crbug.com/334579
 IN_PROC_BROWSER_TEST_F(WebrtcAudioPrivateTest, GetSinks) {
-  AudioDeviceNames devices;
-  GetAudioDeviceNames(&AudioManager::GetAudioOutputDeviceNames, &devices);
+  AudioDeviceDescriptions devices;
+  GetAudioDeviceDescriptions(&AudioManager::GetAudioOutputDeviceDescriptions,
+                             &devices);
 
   base::ListValue* sink_list = NULL;
   std::unique_ptr<base::Value> result = InvokeGetSinks(&sink_list);
 
   std::string result_string;
   JSONWriter::Write(*result, &result_string);
   VLOG(2) << result_string;
 
   EXPECT_EQ(devices.size(), sink_list->GetSize());
 
   // Iterate through both lists in lockstep and compare. The order
   // should be identical.
   size_t ix = 0;
-  AudioDeviceNames::const_iterator it = devices.begin();
+  AudioDeviceDescriptions::const_iterator it = devices.begin();
   for (; ix < sink_list->GetSize() && it != devices.end();
        ++ix, ++it) {
     base::DictionaryValue* dict = NULL;
     sink_list->GetDictionary(ix, &dict);
     std::string sink_id;
     dict->GetString("sinkId", &sink_id);
 
     std::string expected_id;
     if (media::AudioDeviceDescription::IsDefaultDevice(it->unique_id)) {
       expected_id = media::AudioDeviceDescription::kDefaultDeviceId;
@@ skipping 115 matching lines @@
     VLOG(2) << "After setting to " << target_device
             << ", current device is " << current_device;
     EXPECT_EQ(target_device, current_device);
   }
 }
 
 IN_PROC_BROWSER_TEST_F(WebrtcAudioPrivateTest, GetAssociatedSink) {
   // Get the list of input devices. We can cheat in the unit test and
   // run this on the main thread since nobody else will be running at
   // the same time.
-  AudioDeviceNames devices;
-  GetAudioDeviceNames(&AudioManager::GetAudioInputDeviceNames, &devices);
+  AudioDeviceDescriptions devices;
+  GetAudioDeviceDescriptions(&AudioManager::GetAudioInputDeviceDescriptions,
+                             &devices);
 
   // Try to get an associated sink for each source.
-  for (AudioDeviceNames::const_iterator device = devices.begin();
-       device != devices.end();
-       ++device) {
+  for (const auto& device : devices) {
     scoped_refptr<WebrtcAudioPrivateGetAssociatedSinkFunction> function =
         new WebrtcAudioPrivateGetAssociatedSinkFunction();
     function->set_source_url(source_url_);
 
-    std::string raw_device_id = device->unique_id;
+    std::string raw_device_id = device.unique_id;
     VLOG(2) << "Trying to find associated sink for device " << raw_device_id;
     std::string source_id_in_origin;
     GURL origin(GURL("http://www.google.com/").GetOrigin());
     GetIDInOrigin(profile()->GetResourceContext(),
                   origin,
                   raw_device_id,
                   &source_id_in_origin);
 
     base::ListValue parameters;
     parameters.AppendString(origin.spec());
@@ skipping 76 matching lines @@
   title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("failure"));
   base::string16 result = title_watcher.WaitAndGetTitle();
   EXPECT_EQ(base::ASCIIToUTF16("success"), result);
 
   g_browser_process->webrtc_log_uploader()->OverrideUploadWithBufferForTesting(
       NULL);
 }
 #endif  // BUILDFLAG(ENABLE_HANGOUT_SERVICES_EXTENSION)
 
 }  // namespace extensions