MediaStream audio: Refactor 3 separate "glue" implementations into one.

content/renderer/media/external_media_stream_audio_source.cc

 // Copyright 2016 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/media_interface_provider.h"
-
-#include "base/bind.h"
-#include "media/mojo/interfaces/content_decryption_module.mojom.h"
-#include "media/mojo/interfaces/renderer.mojom.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
-#include "mojo/shell/public/cpp/connect.h"
+#include "content/renderer/media/external_media_stream_audio_source.h"
 
 namespace content {
 
-MediaInterfaceProvider::MediaInterfaceProvider(
-    const ConnectToApplicationCB& connect_to_app_cb)
-    : connect_to_app_cb_(connect_to_app_cb) {
-  DCHECK(!connect_to_app_cb_.is_null());
+ExternalMediaStreamAudioSource::ExternalMediaStreamAudioSource(
+    scoped_refptr<media::AudioCapturerSource> source,
+    int sample_rate,
+    media::ChannelLayout channel_layout,
+    int frames_per_buffer,
+    bool is_remote)
+    : MediaStreamAudioSource(!is_remote), source_(std::move(source)),
+      was_started_(false) {
+  DVLOG(1)
+      << "ExternalMediaStreamAudioSource::ExternalMediaStreamAudioSource()";
+  DCHECK(source_.get());
+  MediaStreamAudioSource::SetFormat(media::AudioParameters(
+      media::AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
+      sample_rate,
+      16,  // Legacy parameter (data is always in 32-bit float format).
+      frames_per_buffer));
 }
 
-MediaInterfaceProvider::~MediaInterfaceProvider() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+ExternalMediaStreamAudioSource::~ExternalMediaStreamAudioSource() {
+  DVLOG(1)
+      << "ExternalMediaStreamAudioSource::~ExternalMediaStreamAudioSource()";
+  EnsureSourceIsStopped();
 }
 
-void MediaInterfaceProvider::GetInterface(const mojo::String& interface_name,
-                                          mojo::ScopedMessagePipeHandle pipe) {
-  DVLOG(1) << __FUNCTION__;
+bool ExternalMediaStreamAudioSource::EnsureSourceIsStarted() {
   DCHECK(thread_checker_.CalledOnValidThread());
-
-  if (interface_name == media::interfaces::ContentDecryptionModule::Name_) {
-    GetMediaServiceFactory()->CreateCdm(
-        mojo::MakeRequest<media::interfaces::ContentDecryptionModule>(
-            std::move(pipe)));
-  } else if (interface_name == media::interfaces::Renderer::Name_) {
-    GetMediaServiceFactory()->CreateRenderer(
-        mojo::MakeRequest<media::interfaces::Renderer>(std::move(pipe)));
-  } else if (interface_name == media::interfaces::AudioDecoder::Name_) {
-    GetMediaServiceFactory()->CreateAudioDecoder(
-        mojo::MakeRequest<media::interfaces::AudioDecoder>(std::move(pipe)));
-  } else {
-    NOTREACHED();
-  }
+  if (was_started_)
+    return true;
+  VLOG(1) << "Starting externally-provided "
+          << (is_local_source() ? "local" : "remote")
+          << " source with audio parameters={"
+          << GetAudioParameters().AsHumanReadableString() << "}.";
+  source_->Initialize(GetAudioParameters(), this, -1);
+  source_->Start();
+  was_started_ = true;
+  return true;
 }
 
-media::interfaces::ServiceFactory*
-MediaInterfaceProvider::GetMediaServiceFactory() {
-  DVLOG(1) << __FUNCTION__;
+void ExternalMediaStreamAudioSource::EnsureSourceIsStopped() {
   DCHECK(thread_checker_.CalledOnValidThread());
-
-  if (!media_service_factory_) {
-    mojo::shell::mojom::InterfaceProviderPtr interface_provider =
-        connect_to_app_cb_.Run(GURL("mojo:media"));
-    mojo::GetInterface(interface_provider.get(), &media_service_factory_);
-    media_service_factory_.set_connection_error_handler(base::Bind(
-        &MediaInterfaceProvider::OnConnectionError, base::Unretained(this)));
-  }
-
-  return media_service_factory_.get();
+  if (!source_)
+    return;
+  if (was_started_)
+    source_->Stop();
+  source_ = nullptr;
+  VLOG(1) << "Stopped externally-provided "
+          << (is_local_source() ? "local" : "remote")
+          << " source with audio parameters={"
+          << GetAudioParameters().AsHumanReadableString() << "}.";
 }
 
-void MediaInterfaceProvider::OnConnectionError() {
-  DVLOG(1) << __FUNCTION__;
-  DCHECK(thread_checker_.CalledOnValidThread());
+void ExternalMediaStreamAudioSource::Capture(const media::AudioBus* audio_bus,
+                                             int audio_delay_milliseconds,
+                                             double volume,
+                                             bool key_pressed) {
+  DCHECK(audio_bus);
+  // TODO(miu): Plumbing is needed to determine the actual capture timestamp
+  // of the audio, instead of just snapshotting TimeTicks::Now(), for proper
+  // audio/video sync.  http://crbug.com/335335
+  MediaStreamAudioSource::DeliverDataToTracks(
+      *audio_bus, base::TimeTicks::Now() - base::TimeDelta::FromMilliseconds(
+                                               audio_delay_milliseconds));

[perkj_chrome, 2016/04/08 14:05:41]

nit: indentation looks weird. git cl format? 

[miu, 2016/04/19 00:40:22]

Done.  Yeah, `git cl format` did that.

+}
 
-  media_service_factory_.reset();
+void ExternalMediaStreamAudioSource::OnCaptureError(const std::string& why) {
+  // As of this writing, this method doesn't get called for anything useful,
+  // and all other implementors just log the message, but don't disconnect sinks
+  // or take any other action.  So, just log the error.
+  LOG(ERROR) << why;
 }
 
 }  // namespace content