media_devices_dispatcher_host.cc | Explore in Territory

// Copyright 2016 The Chromium Authors
// 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/media_devices_dispatcher_host.h"

#include <stddef.h>

#include <algorithm>
#include <utility>

#include "base/command_line.h"
#include "base/feature_list.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/run_loop.h"
#include "base/task/bind_post_task.h"
#include "base/task/sequenced_task_runner.h"
#include "build/build_config.h"
#include "content/browser/media/media_devices_permission_checker.h"
#include "content/browser/renderer_host/back_forward_cache_disable.h"
#include "content/browser/renderer_host/back_forward_cache_impl.h"
#include "content/browser/renderer_host/media/media_stream_manager.h"
#include "content/browser/renderer_host/media/video_capture_manager.h"
#include "content/browser/renderer_host/render_frame_host_delegate.h"
#include "content/browser/renderer_host/render_frame_host_impl.h"
#include "content/public/browser/browser_context.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "media/audio/audio_system.h"
#include "media/base/media_switches.h"
#include "media/base/video_facing.h"
#include "media/capture/mojom/video_capture_types.mojom.h"
#include "mojo/public/cpp/bindings/self_owned_receiver.h"
#include "services/service_manager/public/cpp/interface_provider.h"
#include "third_party/blink/public/common/features.h"
#include "third_party/blink/public/common/mediastream/media_devices.h"
#include "third_party/blink/public/common/mediastream/media_stream_request.h"
#include "url/origin.h"

#if !BUILDFLAG(IS_ANDROID)
#include "content/browser/media/capture/sub_capture_target_id_web_contents_helper.h"
#endif

MediaDeviceType;

namespace content {

namespace {

std::vector<blink::mojom::AudioInputDeviceCapabilitiesPtr>
ToVectorAudioInputDeviceCapabilitiesPtr(
    const std::vector<blink::mojom::AudioInputDeviceCapabilities>&
        capabilities_vector,
    const MediaDeviceSaltAndOrigin& salt_and_origin) { … }

}  // namespace

struct MediaDevicesDispatcherHost::AudioInputCapabilitiesRequest { … };

// static
void MediaDevicesDispatcherHost::Create(
    GlobalRenderFrameHostId render_frame_host_id,
    MediaStreamManager* media_stream_manager,
    mojo::PendingReceiver<blink::mojom::MediaDevicesDispatcherHost> receiver) { … }

MediaDevicesDispatcherHost::MediaDevicesDispatcherHost(
    GlobalRenderFrameHostId render_frame_host_id,
    MediaStreamManager* media_stream_manager)
    : … { … }

MediaDevicesDispatcherHost::~MediaDevicesDispatcherHost() { … }

void MediaDevicesDispatcherHost::EnumerateDevices(
    bool request_audio_input,
    bool request_video_input,
    bool request_audio_output,
    bool request_video_input_capabilities,
    bool request_audio_input_capabilities,
    EnumerateDevicesCallback client_callback) { … }

void MediaDevicesDispatcherHost::GetVideoInputCapabilities(
    GetVideoInputCapabilitiesCallback client_callback) { … }

void MediaDevicesDispatcherHost::GetAllVideoInputDeviceFormats(
    const std::string& hashed_device_id,
    GetAllVideoInputDeviceFormatsCallback client_callback) { … }

void MediaDevicesDispatcherHost::GetAvailableVideoInputDeviceFormats(
    const std::string& hashed_device_id,
    GetAvailableVideoInputDeviceFormatsCallback client_callback) { … }

void MediaDevicesDispatcherHost::GetAudioInputCapabilities(
    GetAudioInputCapabilitiesCallback client_callback) { … }

void MediaDevicesDispatcherHost::AddMediaDevicesListener(
    bool subscribe_audio_input,
    bool subscribe_video_input,
    bool subscribe_audio_output,
    mojo::PendingRemote<blink::mojom::MediaDevicesListener> listener) { … }

void MediaDevicesDispatcherHost::SetCaptureHandleConfig(
    blink::mojom::CaptureHandleConfigPtr config) { … }

#if !BUILDFLAG(IS_ANDROID) && !BUILDFLAG(IS_IOS)
void MediaDevicesDispatcherHost::CloseFocusWindowOfOpportunity(
    const std::string& label) { … }

void MediaDevicesDispatcherHost::ProduceSubCaptureTargetId(
    media::mojom::SubCaptureTargetType type,
    ProduceSubCaptureTargetIdCallback callback) { … }
#endif

void MediaDevicesDispatcherHost::OnVideoGotSaltAndOrigin(
    GetVideoInputCapabilitiesCallback client_callback,
    const MediaDeviceSaltAndOrigin& salt_and_origin) { … }

void MediaDevicesDispatcherHost::FinalizeGetVideoInputCapabilities(
    GetVideoInputCapabilitiesCallback client_callback,
    const MediaDeviceSaltAndOrigin& salt_and_origin,
    const MediaDeviceEnumeration& enumeration) { … }

void MediaDevicesDispatcherHost::GetVideoInputDeviceFormats(
    const std::string& hashed_device_id,
    bool try_in_use_first,
    GetVideoInputDeviceFormatsCallback client_callback,
    std::unique_ptr<ScopedMediaStreamTrace> scoped_trace,
    const MediaDeviceSaltAndOrigin& salt_and_origin) { … }

void MediaDevicesDispatcherHost::GetVideoInputDeviceFormatsWithRawId(
    const std::string& hashed_device_id,
    bool try_in_use_first,
    GetVideoInputDeviceFormatsCallback client_callback,
    std::unique_ptr<ScopedMediaStreamTrace> scoped_trace,
    const std::optional<std::string>& raw_id) { … }

void MediaDevicesDispatcherHost::OnAudioGotSaltAndOrigin(
    GetAudioInputCapabilitiesCallback client_callback,
    const MediaDeviceSaltAndOrigin& salt_and_origin) { … }

void MediaDevicesDispatcherHost::GotAudioInputEnumeration(
    const MediaDeviceEnumeration& enumeration) { … }

void MediaDevicesDispatcherHost::GotAudioInputParameters(
    size_t index,
    const std::optional<media::AudioParameters>& parameters) { … }

void MediaDevicesDispatcherHost::FinalizeGetAudioInputCapabilities() { … }

void MediaDevicesDispatcherHost::ReceivedBadMessage(
    int render_process_id,
    bad_message::BadMessageReason reason) { … }

void MediaDevicesDispatcherHost::SetBadMessageCallbackForTesting(
    base::RepeatingCallback<void(int, bad_message::BadMessageReason)>
        callback) { … }

void MediaDevicesDispatcherHost::SetCaptureHandleConfigCallbackForTesting(
    base::RepeatingCallback<
        void(int, int, blink::mojom::CaptureHandleConfigPtr)> callback) { … }

}  // namespace content
chromium/content/browser/renderer_host/media/media_devices_dispatcher_host.cc
