Remove plumbing of Origin to AudioOutputDevice.

The Origin is now looked up in the browser, so passing the origin is unnecessary. This is a followup to https://chromium-review.googlesource.com/c/chromium/src/+/1010424. Also fix some lint. Bug: 653871,721732 Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel Change-Id: I681dd754d71e1fe87e94f514428e1b3bea7aa736 Reviewed-on: https://chromium-review.googlesource.com/1012114 Commit-Queue: Max Morin <maxmorin@chromium.org> Reviewed-by: Dale Curtis <dalecurtis@chromium.org> Reviewed-by: Jochen Eisinger <jochen@chromium.org> Reviewed-by: Guido Urdaneta <guidou@chromium.org> Cr-Commit-Position: refs/heads/master@{#551301}
marcosholgado · Apr 17, 2018 · f506af5 · f506af5
1 parent a1cabeb
commit f506af5
Show file tree

Hide file tree

Showing 75 changed files with 391 additions and 668 deletions.
diff --git a/content/public/renderer/media_stream_audio_renderer.h b/content/public/renderer/media_stream_audio_renderer.h
@@ -11,7 +11,6 @@
 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
 #include "media/base/output_device_info.h"
-#include "url/origin.h"
 
 namespace content {
 
@@ -50,7 +49,6 @@ class MediaStreamAudioRenderer
   // update clients accordingly and fix the comment.
   virtual void SwitchOutputDevice(
       const std::string& device_id,
-      const url::Origin& security_origin,
       const media::OutputDeviceStatusCB& callback) = 0;
 
   // Time stamp that reflects the current render time. Should not be updated

diff --git a/content/public/renderer/media_stream_renderer_factory.h b/content/public/renderer/media_stream_renderer_factory.h
@@ -11,7 +11,6 @@
 #include "base/memory/ref_counted.h"
 #include "content/public/renderer/media_stream_audio_renderer.h"
 #include "content/public/renderer/media_stream_video_renderer.h"
-#include "url/origin.h"
 
 namespace base {
 class SingleThreadTaskRunner;
@@ -42,8 +41,7 @@ class MediaStreamRendererFactory {
   virtual scoped_refptr<MediaStreamAudioRenderer> GetAudioRenderer(
       const blink::WebMediaStream& web_stream,
       int render_frame_id,
-      const std::string& device_id,
-      const url::Origin& security_origin) = 0;
+      const std::string& device_id) = 0;
 };
 
 }  // namespace content

diff --git a/content/renderer/media/audio_device_factory.cc b/content/renderer/media/audio_device_factory.cc
@@ -21,7 +21,6 @@
 #include "media/audio/audio_output_device.h"
 #include "media/base/audio_renderer_mixer_input.h"
 #include "media/base/media_switches.h"
-#include "url/origin.h"
 
 namespace content {
 
@@ -44,12 +43,10 @@ const int64_t kMaxAuthorizationTimeoutMs = 0;  // No timeout.
 scoped_refptr<media::AudioOutputDevice> NewOutputDevice(
     int render_frame_id,
     int session_id,
-    const std::string& device_id,
-    const url::Origin& security_origin) {
+    const std::string& device_id) {
   auto device = base::MakeRefCounted<media::AudioOutputDevice>(
       AudioOutputIPCFactory::get()->CreateAudioOutputIPC(render_frame_id),
       AudioOutputIPCFactory::get()->io_task_runner(), session_id, device_id,
-      security_origin,
       // Set authorization request timeout at 80% of renderer hung timeout,
       // but no more than kMaxAuthorizationTimeout.
       base::TimeDelta::FromMilliseconds(
@@ -72,14 +69,13 @@ scoped_refptr<media::SwitchableAudioRendererSink> NewMixableSink(
     AudioDeviceFactory::SourceType source_type,
     int render_frame_id,
     int session_id,
-    const std::string& device_id,
-    const url::Origin& security_origin) {
+    const std::string& device_id) {
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   DCHECK(render_thread) << "RenderThreadImpl is not instantiated, or "
                         << "GetOutputDeviceInfo() is called on a wrong thread ";
   return scoped_refptr<media::AudioRendererMixerInput>(
       render_thread->GetAudioRendererMixerManager()->CreateInput(
-          render_frame_id, session_id, device_id, security_origin,
+          render_frame_id, session_id, device_id,
           AudioDeviceFactory::GetSourceLatencyType(source_type)));
 }
 
@@ -106,39 +102,32 @@ media::AudioLatency::LatencyType AudioDeviceFactory::GetSourceLatencyType(
 }
 
 scoped_refptr<media::AudioRendererSink>
-AudioDeviceFactory::NewAudioRendererMixerSink(
-    int render_frame_id,
-    int session_id,
-    const std::string& device_id,
-    const url::Origin& security_origin) {
-  return NewFinalAudioRendererSink(render_frame_id, session_id, device_id,
-                                   security_origin);
+AudioDeviceFactory::NewAudioRendererMixerSink(int render_frame_id,
+                                              int session_id,
+                                              const std::string& device_id) {
+  return NewFinalAudioRendererSink(render_frame_id, session_id, device_id);
 }
 
 // static
 scoped_refptr<media::AudioRendererSink>
 AudioDeviceFactory::NewAudioRendererSink(SourceType source_type,
                                          int render_frame_id,
                                          int session_id,
-                                         const std::string& device_id,
-                                         const url::Origin& security_origin) {
+                                         const std::string& device_id) {
   if (factory_) {
     scoped_refptr<media::AudioRendererSink> device =
         factory_->CreateAudioRendererSink(source_type, render_frame_id,
-                                          session_id, device_id,
-                                          security_origin);
+                                          session_id, device_id);
     if (device)
       return device;
   }
 
   if (IsMixable(source_type))
-    return NewMixableSink(source_type, render_frame_id, session_id, device_id,
-                          security_origin);
+    return NewMixableSink(source_type, render_frame_id, session_id, device_id);
 
   UMA_HISTOGRAM_BOOLEAN("Media.Audio.Render.SinkCache.UsedForSinkCreation",
                         false);
-  return NewFinalAudioRendererSink(render_frame_id, session_id, device_id,
-                                   security_origin);
+  return NewFinalAudioRendererSink(render_frame_id, session_id, device_id);
 }
 
 // static
@@ -147,20 +136,17 @@ AudioDeviceFactory::NewSwitchableAudioRendererSink(
     SourceType source_type,
     int render_frame_id,
     int session_id,
-    const std::string& device_id,
-    const url::Origin& security_origin) {
+    const std::string& device_id) {
   if (factory_) {
     scoped_refptr<media::SwitchableAudioRendererSink> sink =
-        factory_->CreateSwitchableAudioRendererSink(source_type,
-                                                    render_frame_id, session_id,
-                                                    device_id, security_origin);
+        factory_->CreateSwitchableAudioRendererSink(
+            source_type, render_frame_id, session_id, device_id);
     if (sink)
       return sink;
   }
 
   if (IsMixable(source_type))
-    return NewMixableSink(source_type, render_frame_id, session_id, device_id,
-                          security_origin);
+    return NewMixableSink(source_type, render_frame_id, session_id, device_id);
 
   // AudioOutputDevice is not RestartableAudioRendererSink, so we can't return
   // anything for those who wants to create an unmixable sink.
@@ -187,13 +173,12 @@ AudioDeviceFactory::NewAudioCapturerSource(int render_frame_id) {
 media::OutputDeviceInfo AudioDeviceFactory::GetOutputDeviceInfo(
     int render_frame_id,
     int session_id,
-    const std::string& device_id,
-    const url::Origin& security_origin) {
+    const std::string& device_id) {
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   DCHECK(render_thread) << "RenderThreadImpl is not instantiated, or "
                         << "GetOutputDeviceInfo() is called on a wrong thread ";
   return render_thread->GetAudioRendererMixerManager()->GetOutputDeviceInfo(
-      render_frame_id, session_id, device_id, security_origin);
+      render_frame_id, session_id, device_id);
 }
 
 AudioDeviceFactory::AudioDeviceFactory() {
@@ -207,21 +192,18 @@ AudioDeviceFactory::~AudioDeviceFactory() {
 
 // static
 scoped_refptr<media::AudioRendererSink>
-AudioDeviceFactory::NewFinalAudioRendererSink(
-    int render_frame_id,
-    int session_id,
-    const std::string& device_id,
-    const url::Origin& security_origin) {
+AudioDeviceFactory::NewFinalAudioRendererSink(int render_frame_id,
+                                              int session_id,
+                                              const std::string& device_id) {
   if (factory_) {
     scoped_refptr<media::AudioRendererSink> sink =
         factory_->CreateFinalAudioRendererSink(render_frame_id, session_id,
-                                               device_id, security_origin);
+                                               device_id);
     if (sink)
       return sink;
   }
 
-  return NewOutputDevice(render_frame_id, session_id, device_id,
-                         security_origin);
+  return NewOutputDevice(render_frame_id, session_id, device_id);
 }
 
 }  // namespace content
diff --git a/content/renderer/media/audio_device_factory.h b/content/renderer/media/audio_device_factory.h
@@ -20,10 +20,6 @@ class SwitchableAudioRendererSink;
 class AudioCapturerSource;
 }
 
-namespace url {
-class Origin;
-}
-
 namespace content {
 
 // A factory for creating AudioRendererSinks and AudioCapturerSources. There is
@@ -57,15 +53,14 @@ class CONTENT_EXPORT AudioDeviceFactory {
   // |render_frame_id| refers to the RenderFrame containing the entity
   // producing the audio. If |session_id| is nonzero, it is used by the browser
   // to select the correct input device ID and its associated output device, if
-  // it exists. If |session_id| is zero, |device_id| and |security_origin|
-  // identify the output device to use.
-  // If |session_id| is zero and |device_id| and |security_origin| are empty,
-  // the default output device will be selected.
+  // it exists. If |session_id| is zero, |device_id| identify the output device
+  // to use.
+  // If |session_id| is zero and |device_id| is empty, the default output
+  // device will be selected.
   static scoped_refptr<media::AudioRendererSink> NewAudioRendererMixerSink(
       int render_frame_id,
       int session_id,
-      const std::string& device_id,
-      const url::Origin& security_origin);
+      const std::string& device_id);
 
   // Creates an AudioRendererSink bound to an AudioOutputDevice.
   // Basing on |source_type| and build configuration, audio played out through
@@ -76,8 +71,7 @@ class CONTENT_EXPORT AudioDeviceFactory {
       SourceType source_type,
       int render_frame_id,
       int session_id,
-      const std::string& device_id,
-      const url::Origin& security_origin);
+      const std::string& device_id);
 
   // Creates a SwitchableAudioRendererSink bound to an AudioOutputDevice
   // Basing on |source_type| and build configuration, audio played out through
@@ -86,16 +80,14 @@ class CONTENT_EXPORT AudioDeviceFactory {
   NewSwitchableAudioRendererSink(SourceType source_type,
                                  int render_frame_id,
                                  int session_id,
-                                 const std::string& device_id,
-                                 const url::Origin& security_origin);
+                                 const std::string& device_id);
 
   // A helper to get device info in the absence of AudioOutputDevice.
   // Must be called on renderer thread only.
   static media::OutputDeviceInfo GetOutputDeviceInfo(
       int render_frame_id,
       int session_id,
-      const std::string& device_id,
-      const url::Origin& security_origin);
+      const std::string& device_id);
 
   // Creates an AudioCapturerSource using the currently registered factory.
   // |render_frame_id| refers to the RenderFrame containing the entity
@@ -117,22 +109,19 @@ class CONTENT_EXPORT AudioDeviceFactory {
   virtual scoped_refptr<media::AudioRendererSink> CreateFinalAudioRendererSink(
       int render_frame_id,
       int sesssion_id,
-      const std::string& device_id,
-      const url::Origin& security_origin) = 0;
+      const std::string& device_id) = 0;
 
   virtual scoped_refptr<media::AudioRendererSink> CreateAudioRendererSink(
       SourceType source_type,
       int render_frame_id,
       int sesssion_id,
-      const std::string& device_id,
-      const url::Origin& security_origin) = 0;
+      const std::string& device_id) = 0;
 
   virtual scoped_refptr<media::SwitchableAudioRendererSink>
   CreateSwitchableAudioRendererSink(SourceType source_type,
                                     int render_frame_id,
                                     int sesssion_id,
-                                    const std::string& device_id,
-                                    const url::Origin& security_origin) = 0;
+                                    const std::string& device_id) = 0;
 
   virtual scoped_refptr<media::AudioCapturerSource> CreateAudioCapturerSource(
       int render_frame_id) = 0;
@@ -145,8 +134,7 @@ class CONTENT_EXPORT AudioDeviceFactory {
   static scoped_refptr<media::AudioRendererSink> NewFinalAudioRendererSink(
       int render_frame_id,
       int session_id,
-      const std::string& device_id,
-      const url::Origin& security_origin);
+      const std::string& device_id);
 
   DISALLOW_COPY_AND_ASSIGN(AudioDeviceFactory);
 };

diff --git a/content/renderer/media/audio_output_ipc_factory_unittest.cc b/content/renderer/media/audio_output_ipc_factory_unittest.cc
@@ -86,8 +86,7 @@ class AudioOutputIPCFactoryTest : public testing::Test {
 
   void RequestAuthorizationOnIOThread(
       std::unique_ptr<media::AudioOutputIPC> output_ipc) {
-    output_ipc->RequestDeviceAuthorization(&fake_delegate, 0, "",
-                                           url::Origin());
+    output_ipc->RequestDeviceAuthorization(&fake_delegate, 0, "");
 
     output_ipc->CloseStream();
   }

diff --git a/content/renderer/media/audio_renderer_mixer_manager.cc b/content/renderer/media/audio_renderer_mixer_manager.cc
@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ -149,7 +150,6 @@ media::AudioRendererMixerInput* AudioRendererMixerManager::CreateInput(
     int source_render_frame_id,
     int session_id,
     const std::string& device_id,
-    const url::Origin& security_origin,
     media::AudioLatency::LatencyType latency) {
   // AudioRendererMixerManager lives on the renderer thread and is destroyed on
   // renderer thread destruction, so it's safe to pass its pointer to a mixer
@@ -158,25 +158,22 @@ media::AudioRendererMixerInput* AudioRendererMixerManager::CreateInput(
       this, source_render_frame_id,
       media::AudioDeviceDescription::UseSessionIdToSelectDevice(session_id,
                                                                 device_id)
-          ? GetOutputDeviceInfo(source_render_frame_id, session_id, device_id,
-                                security_origin)
+          ? GetOutputDeviceInfo(source_render_frame_id, session_id, device_id)
                 .device_id()
           : device_id,
-      security_origin, latency);
+      latency);
 }
 
 media::AudioRendererMixer* AudioRendererMixerManager::GetMixer(
     int source_render_frame_id,
     const media::AudioParameters& input_params,
     media::AudioLatency::LatencyType latency,
     const std::string& device_id,
-    const url::Origin& security_origin,
     media::OutputDeviceStatus* device_status) {
   // Effects are not passed through to output creation, so ensure none are set.
   DCHECK_EQ(input_params.effects(), media::AudioParameters::NO_EFFECTS);
 
-  const MixerKey key(source_render_frame_id, input_params, latency, device_id,
-                     security_origin);
+  const MixerKey key(source_render_frame_id, input_params, latency, device_id);
   base::AutoLock auto_lock(mixers_lock_);
 
   // Update latency map when the mixer is requested, i.e. there is an attempt to
@@ -203,7 +200,7 @@ media::AudioRendererMixer* AudioRendererMixerManager::GetMixer(
   }
 
   scoped_refptr<media::AudioRendererSink> sink =
-      sink_cache_->GetSink(source_render_frame_id, device_id, security_origin);
+      sink_cache_->GetSink(source_render_frame_id, device_id);
 
   const media::OutputDeviceInfo& device_info = sink->GetOutputDeviceInfo();
   if (device_status)
@@ -248,23 +245,20 @@ void AudioRendererMixerManager::ReturnMixer(media::AudioRendererMixer* mixer) {
 media::OutputDeviceInfo AudioRendererMixerManager::GetOutputDeviceInfo(
     int source_render_frame_id,
     int session_id,
-    const std::string& device_id,
-    const url::Origin& security_origin) {
-  return sink_cache_->GetSinkInfo(source_render_frame_id, session_id, device_id,
-                                  security_origin);
+    const std::string& device_id) {
+  return sink_cache_->GetSinkInfo(source_render_frame_id, session_id,
+                                  device_id);
 }
 
 AudioRendererMixerManager::MixerKey::MixerKey(
     int source_render_frame_id,
     const media::AudioParameters& params,
     media::AudioLatency::LatencyType latency,
-    const std::string& device_id,
-    const url::Origin& security_origin)
+    const std::string& device_id)
     : source_render_frame_id(source_render_frame_id),
       params(params),
       latency(latency),
-      device_id(device_id),
-      security_origin(security_origin) {}
+      device_id(device_id) {}
 
 AudioRendererMixerManager::MixerKey::MixerKey(const MixerKey& other) = default;