Switching WebRtc private API from AudioManager to AudioSystem

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 17 matching lines @@
 #include "chrome/common/features.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/media_device_id.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
 #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 "media/audio/audio_system.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 using base::JSONWriter;
 using content::RenderProcessHost;
 using content::WebContents;
 using media::AudioDeviceDescriptions;
-using media::AudioManager;
 
 namespace extensions {
 
 using extension_function_test_utils::RunFunctionAndReturnError;
 using extension_function_test_utils::RunFunctionAndReturnSingleResult;
 
+namespace {
+
+// Synchronously (from the calling thread's point of view) runs the
+// given enumeration function on the device thread. On return,
+// |device_descriptions| has been filled with the device descriptions
+// resulting from that call.
+void GetAudioDeviceDescriptions(bool for_input,
+                                AudioDeviceDescriptions* device_descriptions) {
+  base::RunLoop run_loop;
+  media::AudioSystem::Get()->GetDeviceDescriptions(
+      base::Bind(
+          [](base::Closure finished_callback, AudioDeviceDescriptions* result,
+             AudioDeviceDescriptions received) {
+            *result = std::move(received);
+            finished_callback.Run();
+          },
+          base::Passed(run_loop.QuitClosure()), device_descriptions),
+      for_input);
+  run_loop.Run();
+}
+
+}  // namespace
+
 class AudioWaitingExtensionTest : public ExtensionApiTest {
  protected:
   void WaitUntilAudioIsPlaying(WebContents* tab) {
     // Wait for audio to start playing.
     bool audio_playing = false;
     for (size_t remaining_tries = 50; remaining_tries > 0; --remaining_tries) {
       audio_playing = tab->WasRecentlyAudible();
       base::RunLoop().RunUntilIdle();
       if (audio_playing)
         break;
-
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
     }
-
     if (!audio_playing)
       FAIL() << "Audio did not start playing within ~5 seconds.";
   }
 };
 
 class WebrtcAudioPrivateTest : public AudioWaitingExtensionTest {
  public:
-  WebrtcAudioPrivateTest()
-      : enumeration_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
-                           base::WaitableEvent::InitialState::NOT_SIGNALED) {}
+  WebrtcAudioPrivateTest() {}
 
   void SetUpOnMainThread() override {
     AudioWaitingExtensionTest::SetUpOnMainThread();
     // Needs to happen after chrome's schemes are added.
     source_url_ = GURL("chrome-extension://fakeid012345678/fakepage.html");
   }
 
  protected:
   void AppendTabIdToRequestInfo(base::ListValue* params, int tab_id) {
     std::unique_ptr<base::DictionaryValue> request_info(
         new base::DictionaryValue());
     request_info->SetInteger("tabId", tab_id);
     params->Append(std::move(request_info));
   }
 
   std::unique_ptr<base::Value> InvokeGetSinks(base::ListValue** sink_list) {
     scoped_refptr<WebrtcAudioPrivateGetSinksFunction> function =
         new WebrtcAudioPrivateGetSinksFunction();
     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_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::BindOnce(&WebrtcAudioPrivateTest::GetAudioDeviceDescriptions,
-                         base::Unretained(this), EnumerationFunc,
-                         device_descriptions));
-      enumeration_event_.Wait();
-    } else {
-      (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,
-                     const std::string& raw_device_id,
-                     std::string* id_in_origin) {
-    if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
-      content::BrowserThread::PostTask(
-          content::BrowserThread::UI, FROM_HERE,
-          base::BindOnce(&WebrtcAudioPrivateTest::GetIDInOrigin,
-                         base::Unretained(this), resource_context, origin,
-                         raw_device_id, id_in_origin));
-      enumeration_event_.Wait();
-    } else {
-      *id_in_origin = content::GetHMACForMediaDeviceID(
-          resource_context->GetMediaDeviceIDSalt(), url::Origin(origin),
-          raw_device_id);
-      enumeration_event_.Signal();
-    }
-  }
-
-  // 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) {
   AudioDeviceDescriptions devices;
-  GetAudioDeviceDescriptions(&AudioManager::GetAudioOutputDeviceDescriptions,
-                             &devices);
+  GetAudioDeviceDescriptions(false, &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;
   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;
-    } else {
-      GetIDInOrigin(profile()->GetResourceContext(),
-                    source_url_.GetOrigin(),
-                    it->unique_id,
-                    &expected_id);
-    }
+    std::string expected_id =
+        media::AudioDeviceDescription::IsDefaultDevice(it->unique_id)
+            ? media::AudioDeviceDescription::kDefaultDeviceId
+            : content::GetHMACForMediaDeviceID(
+                  profile()->GetResourceContext()->GetMediaDeviceIDSalt(),
+                  url::Origin(source_url_.GetOrigin()), it->unique_id);
 
     EXPECT_EQ(expected_id, sink_id);
     std::string sink_label;
     dict->GetString("sinkLabel", &sink_label);
     EXPECT_EQ(it->device_name, sink_label);
 
     // TODO(joi): Verify the contents of these once we start actually
     // filling them in.
     EXPECT_TRUE(dict->HasKey("isDefault"));
     EXPECT_TRUE(dict->HasKey("isReady"));
     EXPECT_TRUE(dict->HasKey("sampleRate"));
   }
 }
 #endif  // OS_MACOSX
 
 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.
   AudioDeviceDescriptions devices;
-  GetAudioDeviceDescriptions(&AudioManager::GetAudioInputDeviceDescriptions,
-                             &devices);
+  GetAudioDeviceDescriptions(true, &devices);
 
   // Try to get an associated sink for each source.
   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;
     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);
+    std::string source_id_in_origin = content::GetHMACForMediaDeviceID(
+        profile()->GetResourceContext()->GetMediaDeviceIDSalt(),
+        url::Origin(origin), raw_device_id);
 
     base::ListValue parameters;
     parameters.AppendString(origin.spec());
     parameters.AppendString(source_id_in_origin);
     std::string parameter_string;
     JSONWriter::Write(parameters, &parameter_string);
 
     std::unique_ptr<base::Value> result(RunFunctionAndReturnSingleResult(
         function.get(), parameter_string, browser()));
     std::string result_string;
@@ skipping 62 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