Index: content/browser/renderer_host/media/render_frame_audio_output_stream_factory.cc |
diff --git a/content/browser/renderer_host/media/render_frame_audio_output_stream_factory.cc b/content/browser/renderer_host/media/render_frame_audio_output_stream_factory.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..0ce5c98cb02bdde751002e52d988df62b2aa11b0 |
--- /dev/null |
+++ b/content/browser/renderer_host/media/render_frame_audio_output_stream_factory.cc |
@@ -0,0 +1,124 @@ |
+// 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/browser/renderer_host/media/render_frame_audio_output_stream_factory.h" |
+ |
+#include <utility> |
+ |
+#include "base/metrics/histogram_macros.h" |
+#include "base/threading/thread_checker.h" |
+#include "content/browser/bad_message.h" |
+#include "content/browser/media/capture/audio_mirroring_manager.h" |
+#include "content/browser/renderer_host/media/audio_output_stream_factory_context.h" |
+#include "content/browser/renderer_host/media/media_stream_manager.h" |
+#include "media/audio/audio_manager.h" |
+#include "media/base/audio_parameters.h" |
+#include "media/mojo/services/mojo_audio_output_stream_provider.h" |
+#include "mojo/public/cpp/bindings/binding.h" |
+ |
+namespace content { |
+ |
+namespace { |
+ |
+void UMALogDeviceAuthorizationTime(base::TimeTicks auth_start_time) { |
+ UMA_HISTOGRAM_CUSTOM_TIMES("Media.Audio.OutputDeviceAuthorizationTime", |
+ base::TimeTicks::Now() - auth_start_time, |
+ base::TimeDelta::FromMilliseconds(1), |
+ base::TimeDelta::FromMilliseconds(5000), 50); |
+} |
+ |
+} // namespace |
+ |
+RenderFrameAudioOutputStreamFactory::RenderFrameAudioOutputStreamFactory( |
+ AudioOutputStreamFactoryContext* context, |
+ int render_frame_id, |
+ mojom::RendererAudioOutputStreamFactoryRequest request) |
+ : binding_(this, std::move(request)), |
+ context_(context), |
+ render_frame_id_(render_frame_id) { |
+ DCHECK(thread_checker_.CalledOnValidThread()); |
+ DCHECK(context_); |
+ binding_.set_connection_error_handler( |
+ base::Bind(&AudioOutputStreamFactoryContext::OnFactoryFinished, |
+ base::Unretained(context), base::Unretained(this))); |
+} |
+ |
+RenderFrameAudioOutputStreamFactory::~RenderFrameAudioOutputStreamFactory() { |
+ DCHECK(thread_checker_.CalledOnValidThread()); |
+} |
+ |
+void RenderFrameAudioOutputStreamFactory::RequestDeviceAuthorization( |
+ media::mojom::AudioOutputStreamProviderRequest stream_provider_request, |
+ int64_t session_id, |
+ const std::string& device_id, |
+ const url::Origin& origin, |
+ const RequestDeviceAuthorizationCallback& callback) { |
+ DCHECK(thread_checker_.CalledOnValidThread()); |
+ const base::TimeTicks auth_start_time = base::TimeTicks::Now(); |
+ |
+ if (!base::IsValueInRangeForNumericType<int>(session_id)) { |
+ UMALogDeviceAuthorizationTime(auth_start_time); |
+ binding_.Close(); |
+ bad_message::ReceivedBadMessage(context_->GetRenderProcessId(), |
+ bad_message::RFAOF_OUT_OF_RANGE_INTEGER); |
+ context_->OnFactoryFinished(this); // deletes |this|. |
+ return; |
o1ka
2017/03/21 16:20:17
Could we substitute this pattern with a strong bin
Max Morin
2017/03/22 13:18:29
Done.
|
+ } |
+ |
+ context_->RequestDeviceAuthorization( |
+ render_frame_id_, static_cast<int>(session_id), device_id, origin, |
+ base::Bind(&RenderFrameAudioOutputStreamFactory::AuthorizationCompleted, |
+ base::Unretained(this), origin, auth_start_time, |
+ base::Passed(std::move(stream_provider_request)), callback)); |
+} |
+ |
+void RenderFrameAudioOutputStreamFactory::AuthorizationCompleted( |
+ const url::Origin& origin, |
+ base::TimeTicks auth_start_time, |
+ media::mojom::AudioOutputStreamProviderRequest request, |
+ const RequestDeviceAuthorizationCallback& callback, |
+ media::OutputDeviceStatus status, |
+ bool should_send_id, |
+ const media::AudioParameters& params, |
+ const std::string& raw_device_id) { |
+ DCHECK(thread_checker_.CalledOnValidThread()); |
+ UMALogDeviceAuthorizationTime(auth_start_time); |
+ |
+ if (status != media::OUTPUT_DEVICE_STATUS_OK) { |
+ callback.Run(media::OutputDeviceStatus(status), |
+ media::AudioParameters::UnavailableDeviceParams(), |
+ std::string()); |
+ return; |
+ } |
+ |
+ if (request.is_pending()) { |
+ streams_.push_back( |
+ base::WrapUnique<media::mojom::AudioOutputStreamProvider>( |
+ new media::MojoAudioOutputStreamProvider( |
+ std::move(request), |
+ base::BindOnce(&AudioOutputStreamFactoryContext::CreateDelegate, |
+ base::Unretained(context_), raw_device_id, |
+ render_frame_id_), |
+ base::Bind(&RenderFrameAudioOutputStreamFactory::RemoveStream, |
+ base::Unretained(this))))); |
+ } |
+ |
+ callback.Run(media::OutputDeviceStatus(status), params, |
+ should_send_id ? MediaStreamManager::GetHMACForMediaDeviceID( |
+ context_->GetSalt(), origin, raw_device_id) |
+ : std::string()); |
+} |
+ |
+void RenderFrameAudioOutputStreamFactory::RemoveStream( |
+ media::mojom::AudioOutputStreamProvider* stream_provider) { |
+ auto it = std::find_if( |
+ streams_.begin(), streams_.end(), |
+ [stream_provider]( |
+ const std::unique_ptr<media::mojom::AudioOutputStreamProvider>& |
+ other) { return other.get() == stream_provider; }); |
+ std::swap(*it, streams_.back()); |
+ streams_.pop_back(); |
+} |
+ |
+} // namespace content |