-// Copyright 2018 The Chromium Authors. All rights reserved.
+// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <string>
#include <utility>
-#include "base/bind.h"
-#include "base/callback.h"
#include "base/check_op.h"
+#include "base/functional/bind.h"
+#include "base/functional/callback.h"
+#include "base/functional/callback_helpers.h"
#include "base/location.h"
+#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/trace_event/trace_event.h"
#include "base/unguessable_token.h"
-#include "content/browser/media/audio_stream_broker.h"
#include "content/browser/media/capture/desktop_capture_device_uma_types.h"
#include "content/browser/media/forwarding_audio_stream_factory.h"
#include "content/browser/media/media_devices_permission_checker.h"
#include "content/browser/renderer_host/media/audio_input_device_manager.h"
#include "content/browser/renderer_host/media/media_devices_manager.h"
#include "content/browser/renderer_host/media/media_stream_manager.h"
+#include "content/public/browser/audio_stream_broker.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/global_routing_id.h"
#include "content/public/browser/media_device_id.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
#include "third_party/blink/public/common/mediastream/media_stream_request.h"
#include "url/origin.h"
+#if BUILDFLAG(IS_TIZEN_TV)
+#include "content/browser/browser_main_loop.h"
+#endif
+
+using blink::mojom::MediaDeviceType;
+
namespace content {
namespace {
MediaDevicesManager::EnumerationCallback cb) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
MediaDevicesManager::BoolDeviceTypes device_types;
- device_types[blink::MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = true;
+ device_types[static_cast<size_t>(MediaDeviceType::kMediaAudioOuput)] = true;
media_stream_manager->media_devices_manager()->EnumerateDevices(
device_types, std::move(cb));
}
const MediaDeviceEnumeration& device_array) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
for (const auto& device_info :
- device_array[blink::MEDIA_DEVICE_TYPE_AUDIO_OUTPUT]) {
- if (MediaStreamManager::DoesMediaDeviceIDMatchHMAC(
- salt_and_origin.device_id_salt, salt_and_origin.origin, device_id,
- device_info.device_id)) {
+ device_array[static_cast<size_t>(MediaDeviceType::kMediaAudioOuput)]) {
+ if (DoesRawMediaDeviceIDMatchHMAC(salt_and_origin, device_id,
+ device_info.device_id)) {
cb.Run(device_info.device_id);
break;
}
// If we're unable to translate the device id, |cb| will not be run.
}
-void GetSaltOriginAndPermissionsOnUIThread(
+void GotSaltAndOrigin(
int process_id,
int frame_id,
- base::OnceCallback<void(MediaDeviceSaltAndOrigin salt_and_origin,
- bool has_access)> cb) {
- auto salt_and_origin = GetMediaDeviceSaltAndOrigin(process_id, frame_id);
+ base::OnceCallback<void(const MediaDeviceSaltAndOrigin& salt_and_origin,
+ bool has_access)> cb,
+ const MediaDeviceSaltAndOrigin& salt_and_origin) {
bool access = MediaDevicesPermissionChecker().CheckPermissionOnUIThread(
- blink::MEDIA_DEVICE_TYPE_AUDIO_OUTPUT, process_id, frame_id);
+ MediaDeviceType::kMediaAudioOuput, process_id, frame_id);
GetIOThreadTaskRunner({})->PostTask(
- FROM_HERE,
- base::BindOnce(std::move(cb), std::move(salt_and_origin), access));
+ FROM_HERE, base::BindOnce(std::move(cb), salt_and_origin, access));
+}
+
+void GetSaltOriginAndPermissionsOnUIThread(
+ int process_id,
+ int frame_id,
+ base::OnceCallback<void(const MediaDeviceSaltAndOrigin& salt_and_origin,
+ bool has_access)> cb) {
+ GetMediaDeviceSaltAndOrigin(
+ GlobalRenderFrameHostId(process_id, frame_id),
+ base::BindOnce(&GotSaltAndOrigin, process_id, frame_id, std::move(cb)));
}
} // namespace
class RenderFrameAudioInputStreamFactory::Core final
- : public mojom::RendererAudioInputStreamFactory {
+ : public blink::mojom::RendererAudioInputStreamFactory {
public:
- Core(mojo::PendingReceiver<mojom::RendererAudioInputStreamFactory> receiver,
+ Core(mojo::PendingReceiver<blink::mojom::RendererAudioInputStreamFactory>
+ receiver,
MediaStreamManager* media_stream_manager,
RenderFrameHost* render_frame_host);
+ Core(const Core&) = delete;
+ Core& operator=(const Core&) = delete;
+
~Core() final;
- void Init(
- mojo::PendingReceiver<mojom::RendererAudioInputStreamFactory> receiver);
+ void Init(mojo::PendingReceiver<blink::mojom::RendererAudioInputStreamFactory>
+ receiver);
// mojom::RendererAudioInputStreamFactory implementation.
void CreateStream(
- mojo::PendingRemote<mojom::RendererAudioInputStreamFactoryClient> client,
+ mojo::PendingRemote<blink::mojom::RendererAudioInputStreamFactoryClient>
+ client,
const base::UnguessableToken& session_id,
const media::AudioParameters& audio_params,
bool automatic_gain_control,
- uint32_t shared_memory_count) final;
+ uint32_t shared_memory_count,
+ media::mojom::AudioProcessingConfigPtr processing_config) final;
void AssociateInputAndOutputForAec(
const base::UnguessableToken& input_stream_id,
const std::string& output_device_id) final;
void CreateLoopbackStream(
- mojo::PendingRemote<mojom::RendererAudioInputStreamFactoryClient> client,
+ mojo::PendingRemote<blink::mojom::RendererAudioInputStreamFactoryClient>
+ client,
const media::AudioParameters& audio_params,
uint32_t shared_memory_count,
bool disable_local_echo,
void AssociateInputAndOutputForAecAfterCheckingAccess(
const base::UnguessableToken& input_stream_id,
const std::string& output_device_id,
- MediaDeviceSaltAndOrigin salt_and_origin,
+ const MediaDeviceSaltAndOrigin& salt_and_origin,
bool access_granted);
void AssociateTranslatedOutputDeviceForAec(
const base::UnguessableToken& input_stream_id,
const std::string& raw_output_device_id);
- MediaStreamManager* const media_stream_manager_;
+#if BUILDFLAG(IS_TIZEN_TV)
+ void OnMediaStateChanged(uint32_t previous, uint32_t current) final;
+ void NotifyMediaStateChanged(uint32_t previous, uint32_t current);
+#endif
+
+ const raw_ptr<MediaStreamManager> media_stream_manager_;
const int process_id_;
const int frame_id_;
- const url::Origin origin_;
mojo::Receiver<RendererAudioInputStreamFactory> receiver_{this};
// Always null-check this weak pointer before dereferencing it.
base::WeakPtr<ForwardingAudioStreamFactory::Core> forwarding_factory_;
base::WeakPtrFactory<Core> weak_ptr_factory_{this};
-
- DISALLOW_COPY_AND_ASSIGN(Core);
};
RenderFrameAudioInputStreamFactory::RenderFrameAudioInputStreamFactory(
- mojo::PendingReceiver<mojom::RendererAudioInputStreamFactory> receiver,
+ mojo::PendingReceiver<blink::mojom::RendererAudioInputStreamFactory>
+ receiver,
MediaStreamManager* media_stream_manager,
RenderFrameHost* render_frame_host)
: core_(new Core(std::move(receiver),
// causes issues in unit tests where the UI thread and the IO thread are the
// same.
GetIOThreadTaskRunner({})->PostTask(
- FROM_HERE,
- base::BindOnce([](std::unique_ptr<Core>) {}, std::move(core_)));
+ FROM_HERE, base::DoNothingWithBoundArgs(std::move(core_)));
}
RenderFrameAudioInputStreamFactory::Core::Core(
- mojo::PendingReceiver<mojom::RendererAudioInputStreamFactory> receiver,
+ mojo::PendingReceiver<blink::mojom::RendererAudioInputStreamFactory>
+ receiver,
MediaStreamManager* media_stream_manager,
RenderFrameHost* render_frame_host)
: media_stream_manager_(media_stream_manager),
process_id_(render_frame_host->GetProcess()->GetID()),
- frame_id_(render_frame_host->GetRoutingID()),
- origin_(render_frame_host->GetLastCommittedOrigin()) {
+ frame_id_(render_frame_host->GetRoutingID()) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
ForwardingAudioStreamFactory::Core* tmp_factory =
}
void RenderFrameAudioInputStreamFactory::Core::Init(
- mojo::PendingReceiver<mojom::RendererAudioInputStreamFactory> receiver) {
+ mojo::PendingReceiver<blink::mojom::RendererAudioInputStreamFactory>
+ receiver) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
receiver_.Bind(std::move(receiver));
}
void RenderFrameAudioInputStreamFactory::Core::CreateStream(
- mojo::PendingRemote<mojom::RendererAudioInputStreamFactoryClient> client,
+ mojo::PendingRemote<blink::mojom::RendererAudioInputStreamFactoryClient>
+ client,
const base::UnguessableToken& session_id,
const media::AudioParameters& audio_params,
bool automatic_gain_control,
- uint32_t shared_memory_count) {
+ uint32_t shared_memory_count,
+ media::mojom::AudioProcessingConfigPtr processing_config) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
TRACE_EVENT1("audio", "RenderFrameAudioInputStreamFactory::CreateStream",
"session id", session_id.ToString());
} else {
forwarding_factory_->CreateInputStream(
process_id_, frame_id_, device->id, audio_params, shared_memory_count,
- automatic_gain_control, std::move(client));
+ automatic_gain_control, std::move(processing_config),
+ std::move(client));
// Only count for captures from desktop media picker dialog and system loop
// back audio.
}
void RenderFrameAudioInputStreamFactory::Core::CreateLoopbackStream(
- mojo::PendingRemote<mojom::RendererAudioInputStreamFactoryClient> client,
+ mojo::PendingRemote<blink::mojom::RendererAudioInputStreamFactoryClient>
+ client,
const media::AudioParameters& audio_params,
uint32_t shared_memory_count,
bool disable_local_echo,
AssociateInputAndOutputForAecAfterCheckingAccess(
const base::UnguessableToken& input_stream_id,
const std::string& output_device_id,
- MediaDeviceSaltAndOrigin salt_and_origin,
+ const MediaDeviceSaltAndOrigin& salt_and_origin,
bool access_granted) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
raw_output_device_id);
}
+#if BUILDFLAG(IS_TIZEN_TV)
+void RenderFrameAudioInputStreamFactory::Core::OnMediaStateChanged(
+ uint32_t previous,
+ uint32_t current) {
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
+ GetUIThreadTaskRunner({})->PostTask(
+ FROM_HERE,
+ base::BindOnce(&Core::NotifyMediaStateChanged,
+ weak_ptr_factory_.GetWeakPtr(), previous, current));
+}
+
+void RenderFrameAudioInputStreamFactory::Core::NotifyMediaStateChanged(
+ uint32_t previous,
+ uint32_t current) {
+ content::BrowserMainLoop* browser_main_loop =
+ content::BrowserMainLoop::GetInstance();
+ if (!browser_main_loop) {
+ LOG(ERROR) << "browser_main_loop is null";
+ return;
+ }
+ content::MediaStreamManager* msm = browser_main_loop->media_stream_manager();
+ if (!msm) {
+ LOG(ERROR) << "MediaStreamManager is null";
+ return;
+ }
+ msm->NotifyMediaStateChanged(content::MediaInputStreamType::AUDIO_CAPTURE,
+ previous, current);
+}
+#endif
} // namespace content
projects / platform / framework / web / chromium-efl.git / blobdiff