Switching audio clients to using RestartableAudioRendererSink interface as a sink.

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 {
+
+// This is where we decide which audio will go to mixers and wich one to

[Henrik Grunell, 2016/02/11 12:01:26]

Nit: wich -> which

[o1ka, 2016/02/11 17:18:23]

Done.

+// AudioOutpuDevice directly.
+bool IsMixable(AudioDeviceFactory::SourceType source_type) {
+  if (source_type == AudioDeviceFactory::kSourceHighLatency)
+    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(
+    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);
+}
+
+}  // namespace
+
 // static
 scoped_refptr<media::AudioOutputDevice> AudioDeviceFactory::NewOutputDevice(
     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;
   }
 
   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;
 }
 
 // static
+scoped_refptr<media::AudioRendererSink> AudioDeviceFactory::NewOutputDevice(
+    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_->CreateOutputDevice(
+        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::NewRestartableOutputDevice(
+    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_->CreateRestartableOutputDevice(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);
+
+  // AudioOutputDevice is not RestartableAudioRendererSink, so we can't return
+  // anything for those who wants to create an unmixable sink.
+  NOTIMPLEMENTED();

[Henrik Grunell, 2016/02/11 12:01:26]

What should be implemented here?

[o1ka, 2016/02/11 17:18:23]

We'll add AOD creation here as soon as it's restartable.

+  return nullptr;
+}
+
+// static
 scoped_refptr<media::AudioInputDevice> AudioDeviceFactory::NewInputDevice(
     int render_frame_id) {
   if (factory_) {
     media::AudioInputDevice* const device =
         factory_->CreateInputDevice(render_frame_id);
     if (device)
       return device;
   }
 
   AudioInputMessageFilter* const filter = AudioInputMessageFilter::Get();
   return new media::AudioInputDevice(
       filter->CreateAudioInputIPC(render_frame_id), filter->io_task_runner());
 }
 
+// static
+media::OutputDeviceStatus AudioDeviceFactory::GetOutputDeviceStatus(
+    int render_frame_id,
+    int session_id,
+    const std::string& device_id,
+    const url::Origin& security_origin) {
+  scoped_refptr<media::AudioOutputDevice> device =

[DaleCurtis, 2016/02/10 23:25:33]

Hmm, why do we need to make up a device status if no device exists? Seems this
should just return an error if a device hasn't been created.

[o1ka, 2016/02/11 17:18:23]

This method is the code I moved from
RenderFrameImpl::checkIfAudioSinkExistsAndIsAuthorized to keep an eye on it.

However, the question: here
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/m...
If we switch to mixer inputs, there is no mixer/AOD available until we start
playing it out, but the sink(mixer input) is fine. 
Now if there is no mixer, we return OK if the mixer input is not started yet,
and error if the input is started. Is it ok? What about the case when device is
not authorized, for example, but we are returning OK until we get the mixer?

What the problem might be if we get a mixer reference from the beginning, and
just add a mixer input on Play? It could eliminate the need for caching (i.e.
we'll have caching out of the box) Is it about opening several IPC channels and
not using them when a page is loaded but media element play out is not started?

[DaleCurtis, 2016/02/11 17:37:03]

As soon as AudioRendererMixer is created it will auto start the stream, so we
don't want to blindly request one unless we're about to use it. I haven't
checked the call sites but it seems like it'd be fine to return OKAY when no
device is connected. An error will still be generated later if the sink can't be
used. You might check with guidou@ though, I don't remember all the details
here.

Another option is similar to what I think we should do for requesting the
parameters, try to find an existing one, but if not lazily create one that will
be used by the mixer in the future or killed after some timeout.

[DaleCurtis, 2016/02/16 21:39:12]

Can you add a comment w/ a bug link here that we should find a more efficient
way to handle this?

[o1ka, 2016/02/17 17:40:44]

Done.

+      NewOutputDevice(render_frame_id, session_id, device_id, security_origin);
+  media::OutputDeviceStatus status = device->GetDeviceStatus();
+
+  device->Stop();  // Must be stopped.
+  return status;
+}
+
 AudioDeviceFactory::AudioDeviceFactory() {
   DCHECK(!factory_) << "Can't register two factories at once.";
   factory_ = this;
 }
 
 AudioDeviceFactory::~AudioDeviceFactory() {
   factory_ = NULL;
 }
 
 }  // namespace content