Moving SwitchOutputDevice out of OutputDevice interface, eliminating OutputDevice

content/renderer/media/audio_device_factory.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/renderer/media/audio_device_factory.h"
 
 #include "base/logging.h"
 #include "content/renderer/media/audio_input_message_filter.h"
 #include "content/renderer/media/audio_message_filter.h"
 #include "content/renderer/media/audio_renderer_mixer_manager.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_input_device.h"
 #include "media/audio/audio_output_device.h"
 #include "media/base/audio_renderer_mixer_input.h"
 #include "url/origin.h"
 
 namespace content {
 
 // static
 AudioDeviceFactory* AudioDeviceFactory::factory_ = NULL;
 
 namespace {
 
+media::AudioOutputDevice* NewOutputDevice(int render_frame_id,

[Guido Urdaneta, 2016/03/21 11:09:20]

This should be scoped_refptr

+                                          int session_id,
+                                          const std::string& device_id,
+                                          const url::Origin& security_origin) {
+  AudioMessageFilter* const filter = AudioMessageFilter::Get();
+  media::AudioOutputDevice* device = new media::AudioOutputDevice(

[Guido Urdaneta, 2016/03/21 11:09:20]

This one too.

[o1ka, 2016/03/21 11:50:31]

Yes, exactly, I've already found this :)

[Guido Urdaneta, 2016/03/21 13:01:45]

Yes. After out talk, I just wanted to make sure you changed it in all places
where it could lead to a problem.:)

+      filter->CreateAudioOutputIPC(render_frame_id), filter->io_task_runner(),
+      session_id, device_id, security_origin);
+  device->RequestDeviceAuthorization();
+  return device;
+}
+
 // This is where we decide which audio will go to mixers and which one to
 // AudioOutpuDevice directly.
 bool IsMixable(AudioDeviceFactory::SourceType source_type) {
   if (source_type == AudioDeviceFactory::kSourceMediaElement)
     return true;  // Must ALWAYS go through mixer.
 
   // TODO(olka): make a decision for the rest of the sources basing on OS
   // type and configuration parameters.
   return false;
 }
 
-scoped_refptr<media::RestartableAudioRendererSink> NewMixableSink(
+scoped_refptr<media::SwitchableAudioRendererSink> NewMixableSink(
     int render_frame_id,
     const std::string& device_id,
     const url::Origin& security_origin) {
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   return scoped_refptr<media::AudioRendererMixerInput>(
       render_thread->GetAudioRendererMixerManager()->CreateInput(
           render_frame_id, device_id, security_origin));
 }
 
 scoped_refptr<media::AudioRendererSink> NewUnmixableSink(
     int render_frame_id,
     int session_id,
     const std::string& device_id,
     const url::Origin& security_origin) {
-  return AudioDeviceFactory::NewOutputDevice(render_frame_id, session_id,
-                                             device_id, security_origin);
+  return NewOutputDevice(render_frame_id, session_id, device_id,
+                         security_origin);
 }
 
 }  // namespace
 
-// static
-scoped_refptr<media::AudioOutputDevice> AudioDeviceFactory::NewOutputDevice(
+scoped_refptr<media::AudioRendererSink>
+AudioDeviceFactory::NewAudioRendererMixerSink(
     int render_frame_id,
     int session_id,
     const std::string& device_id,
     const url::Origin& security_origin) {
   if (factory_) {
-    media::AudioOutputDevice* const device = factory_->CreateOutputDevice(
-        render_frame_id, session_id, device_id, security_origin);
-    if (device)
-      return device;
+    media::AudioRendererSink* const sink =
+        factory_->CreateAudioRendererMixerSink(render_frame_id, session_id,
+                                               device_id, security_origin);
+    if (sink)
+      return sink;
   }
-
-  AudioMessageFilter* const filter = AudioMessageFilter::Get();
-  scoped_refptr<media::AudioOutputDevice> device = new media::AudioOutputDevice(
-      filter->CreateAudioOutputIPC(render_frame_id), filter->io_task_runner(),
-      session_id, device_id, security_origin);
-  device->RequestDeviceAuthorization();
-  return device;
+  return NewOutputDevice(render_frame_id, session_id, device_id,
+                         security_origin);
 }
 
 // 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) {
   if (factory_) {
     media::AudioRendererSink* const device = factory_->CreateAudioRendererSink(
         source_type, render_frame_id, session_id, device_id, security_origin);
     if (device)
       return device;
   }
 
   if (IsMixable(source_type))
     return NewMixableSink(render_frame_id, device_id, security_origin);
 
   return NewUnmixableSink(render_frame_id, session_id, device_id,
                           security_origin);
 }
 
 // static
-scoped_refptr<media::RestartableAudioRendererSink>
-AudioDeviceFactory::NewRestartableAudioRendererSink(
+scoped_refptr<media::SwitchableAudioRendererSink>
+AudioDeviceFactory::NewSwitchableAudioRendererSink(
     SourceType source_type,
     int render_frame_id,
     int session_id,
     const std::string& device_id,
     const url::Origin& security_origin) {
   if (factory_) {
-    media::RestartableAudioRendererSink* const device =
-        factory_->CreateRestartableAudioRendererSink(
-            source_type, render_frame_id, session_id, device_id,
-            security_origin);
-    if (device)
-      return device;
+    media::SwitchableAudioRendererSink* const sink =
+        factory_->CreateSwitchableAudioRendererSink(source_type,
+                                                    render_frame_id, session_id,
+                                                    device_id, security_origin);
+    if (sink)
+      return sink;
   }
 
   if (IsMixable(source_type))
     return NewMixableSink(render_frame_id, device_id, security_origin);
 
   // AudioOutputDevice is not RestartableAudioRendererSink, so we can't return
   // anything for those who wants to create an unmixable sink.
   NOTIMPLEMENTED();
   return nullptr;
 }
@@ skipping 32 matching lines @@
 AudioDeviceFactory::AudioDeviceFactory() {
   DCHECK(!factory_) << "Can't register two factories at once.";
   factory_ = this;
 }
 
 AudioDeviceFactory::~AudioDeviceFactory() {
   factory_ = NULL;
 }
 
 }  // namespace content