content/browser/renderer_host/media/render_frame_audio_input_stream_factory.cc

   1 // Copyright 2017 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/renderer_host/media/render_frame_audio_input_stream_factory.h"
   6
   7 #include <utility>
   8
   9 #include "base/feature_list.h"
  10 #include "base/task_runner_util.h"
  11 #include "content/browser/media/media_internals.h"
  12 #include "content/browser/renderer_host/media/media_stream_manager.h"
  13 #include "content/public/common/content_features.h"
  14 #include "media/base/audio_parameters.h"
  15
  16 namespace content {
  17
  18 // static
  19 std::unique_ptr<RenderFrameAudioInputStreamFactoryHandle,
  20                 BrowserThread::DeleteOnIOThread>
  21 RenderFrameAudioInputStreamFactoryHandle::CreateFactory(
  22     RenderFrameAudioInputStreamFactory::CreateDelegateCallback
  23         create_delegate_callback,
  24     content::MediaStreamManager* media_stream_manager,
  25     int render_process_id,
  26     int render_frame_id,
  27     mojom::RendererAudioInputStreamFactoryRequest request) {
  28   std::unique_ptr<RenderFrameAudioInputStreamFactoryHandle,
  29                   BrowserThread::DeleteOnIOThread>
  30       handle(new RenderFrameAudioInputStreamFactoryHandle(
  31           std::move(create_delegate_callback), media_stream_manager,
  32           render_process_id, render_frame_id));
  33   // Unretained is safe since |*handle| must be posted to the IO thread prior to
  34   // deletion.
  35   BrowserThread::PostTask(
  36       BrowserThread::IO, FROM_HERE,
  37       base::BindOnce(&RenderFrameAudioInputStreamFactoryHandle::Init,
  38                      base::Unretained(handle.get()), std::move(request)));
  39   return handle;
  40 }
  41
  42 RenderFrameAudioInputStreamFactoryHandle::
  43     ~RenderFrameAudioInputStreamFactoryHandle() {
  44   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  45 }
  46
  47 RenderFrameAudioInputStreamFactoryHandle::
  48     RenderFrameAudioInputStreamFactoryHandle(
  49         RenderFrameAudioInputStreamFactory::CreateDelegateCallback
  50             create_delegate_callback,
  51         MediaStreamManager* media_stream_manager,
  52         int render_process_id,
  53         int render_frame_id)
  54     : impl_(std::move(create_delegate_callback),
  55             media_stream_manager,
  56             render_process_id,
  57             render_frame_id),
  58       binding_(&impl_) {}
  59
  60 void RenderFrameAudioInputStreamFactoryHandle::Init(
  61     mojom::RendererAudioInputStreamFactoryRequest request) {
  62   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  63   binding_.Bind(std::move(request));
  64 }
  65
  66 RenderFrameAudioInputStreamFactory::RenderFrameAudioInputStreamFactory(
  67     CreateDelegateCallback create_delegate_callback,
  68     MediaStreamManager* media_stream_manager,
  69     int render_process_id,
  70     int render_frame_id)
  71     : create_delegate_callback_(std::move(create_delegate_callback)),
  72       media_stream_manager_(media_stream_manager),
  73       render_process_id_(render_process_id),
  74       render_frame_id_(render_frame_id),
  75       weak_ptr_factory_(this) {
  76   DCHECK(create_delegate_callback_);
  77   // No thread-hostile state has been initialized yet, so we don't have to bind
  78   // to this specific thread.
  79 }
  80
  81 RenderFrameAudioInputStreamFactory::~RenderFrameAudioInputStreamFactory() {
  82   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  83 }
  84
  85 // static
  86 bool RenderFrameAudioInputStreamFactory::UseMojoFactories() {
  87   return base::FeatureList::IsEnabled(
  88       features::kUseMojoAudioInputStreamFactory);
  89 }
  90
  91 void RenderFrameAudioInputStreamFactory::CreateStream(
  92     mojom::RendererAudioInputStreamFactoryClientPtr client,
  93     int32_t session_id,
  94     const media::AudioParameters& audio_params,
  95     bool automatic_gain_control,
  96     uint32_t shared_memory_count) {
  97   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  98
  99 #if defined(OS_CHROMEOS)
 100   if (audio_params.channel_layout() ==
 101       media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC) {
 102     media_stream_manager_->audio_input_device_manager()
 103         ->RegisterKeyboardMicStream(base::BindOnce(
 104             &RenderFrameAudioInputStreamFactory::DoCreateStream,
 105             weak_ptr_factory_.GetWeakPtr(), std::move(client), session_id,
 106             audio_params, automatic_gain_control, shared_memory_count));
 107     return;
 108   }
 109 #endif
 110   DoCreateStream(std::move(client), session_id, audio_params,
 111                  automatic_gain_control, shared_memory_count,
 112                  AudioInputDeviceManager::KeyboardMicRegistration());
 113 }
 114
 115 void RenderFrameAudioInputStreamFactory::DoCreateStream(
 116     mojom::RendererAudioInputStreamFactoryClientPtr client,
 117     int session_id,
 118     const media::AudioParameters& audio_params,
 119     bool automatic_gain_control,
 120     uint32_t shared_memory_count,
 121     AudioInputDeviceManager::KeyboardMicRegistration
 122         keyboard_mic_registration) {
 123   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 124   int stream_id = ++next_stream_id_;
 125
 126   media::mojom::AudioLogPtr audio_log_ptr =
 127       MediaInternals::GetInstance()->CreateMojoAudioLog(
 128           media::AudioLogFactory::AUDIO_INPUT_CONTROLLER, stream_id,
 129           render_process_id_, render_frame_id_);
 130
 131   // Unretained is safe since |this| owns |streams_|.
 132   streams_.insert(std::make_unique<AudioInputStreamHandle>(
 133       std::move(client),
 134       base::BindOnce(
 135           create_delegate_callback_,
 136           base::Unretained(media_stream_manager_->audio_input_device_manager()),
 137           std::move(audio_log_ptr), std::move(keyboard_mic_registration),
 138           shared_memory_count, stream_id, session_id, automatic_gain_control,
 139           audio_params),
 140       base::BindOnce(&RenderFrameAudioInputStreamFactory::RemoveStream,
 141                      weak_ptr_factory_.GetWeakPtr())));
 142 }
 143
 144 void RenderFrameAudioInputStreamFactory::RemoveStream(
 145     AudioInputStreamHandle* stream) {
 146   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 147
 148   streams_.erase(stream);
 149 }
 150
 151 }  // namespace content