1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
// Copyright (c) 2012 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.
#ifndef CHROME_BROWSER_MEDIA_MEDIA_CAPTURE_DEVICES_DISPATCHER_H_
#define CHROME_BROWSER_MEDIA_MEDIA_CAPTURE_DEVICES_DISPATCHER_H_
#include <deque>
#include <list>
#include <map>
#include "base/callback.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/scoped_vector.h"
#include "base/memory/singleton.h"
#include "base/observer_list.h"
#include "content/public/browser/media_observer.h"
#include "content/public/browser/web_contents_delegate.h"
#include "content/public/common/media_stream_request.h"
class DesktopStreamsRegistry;
class MediaAccessHandler;
class MediaStreamCaptureIndicator;
class Profile;
namespace extensions {
class Extension;
}
namespace user_prefs {
class PrefRegistrySyncable;
}
// This singleton is used to receive updates about media events from the content
// layer.
class MediaCaptureDevicesDispatcher : public content::MediaObserver {
public:
class Observer {
public:
// Handle an information update consisting of a up-to-date audio capture
// device lists. This happens when a microphone is plugged in or unplugged.
virtual void OnUpdateAudioDevices(
const content::MediaStreamDevices& devices) {}
// Handle an information update consisting of a up-to-date video capture
// device lists. This happens when a camera is plugged in or unplugged.
virtual void OnUpdateVideoDevices(
const content::MediaStreamDevices& devices) {}
// Handle an information update related to a media stream request.
virtual void OnRequestUpdate(
int render_process_id,
int render_frame_id,
content::MediaStreamType stream_type,
const content::MediaRequestState state) {}
// Handle an information update that a new stream is being created.
virtual void OnCreatingAudioStream(int render_process_id,
int render_frame_id) {}
virtual ~Observer() {}
};
static MediaCaptureDevicesDispatcher* GetInstance();
// Registers the preferences related to Media Stream default devices.
static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
// Returns true if the security origin is associated with casting.
static bool IsOriginForCasting(const GURL& origin);
// Methods for observers. Called on UI thread.
// Observers should add themselves on construction and remove themselves
// on destruction.
void AddObserver(Observer* observer);
void RemoveObserver(Observer* observer);
const content::MediaStreamDevices& GetAudioCaptureDevices();
const content::MediaStreamDevices& GetVideoCaptureDevices();
// Method called from WebCapturerDelegate implementations to process access
// requests. |extension| is set to NULL if request was made from a drive-by
// page.
void ProcessMediaAccessRequest(
content::WebContents* web_contents,
const content::MediaStreamRequest& request,
const content::MediaResponseCallback& callback,
const extensions::Extension* extension);
// Method called from WebCapturerDelegate implementations to check media
// access permission. Note that this does not query the user.
bool CheckMediaAccessPermission(content::WebContents* web_contents,
const GURL& security_origin,
content::MediaStreamType type);
// Same as above but for an |extension|, which may not be NULL.
bool CheckMediaAccessPermission(content::WebContents* web_contents,
const GURL& security_origin,
content::MediaStreamType type,
const extensions::Extension* extension);
// Helper to get the default devices which can be used by the media request.
// Uses the first available devices if the default devices are not available.
// If the return list is empty, it means there is no available device on the
// OS.
// Called on the UI thread.
void GetDefaultDevicesForProfile(Profile* profile,
bool audio,
bool video,
content::MediaStreamDevices* devices);
// Helpers for picking particular requested devices, identified by raw id.
// If the device requested is not available it will return NULL.
const content::MediaStreamDevice*
GetRequestedAudioDevice(const std::string& requested_audio_device_id);
const content::MediaStreamDevice*
GetRequestedVideoDevice(const std::string& requested_video_device_id);
// Returns the first available audio or video device, or NULL if no devices
// are available.
const content::MediaStreamDevice* GetFirstAvailableAudioDevice();
const content::MediaStreamDevice* GetFirstAvailableVideoDevice();
// Unittests that do not require actual device enumeration should call this
// API on the singleton. It is safe to call this multiple times on the
// signleton.
void DisableDeviceEnumerationForTesting();
// Overridden from content::MediaObserver:
void OnAudioCaptureDevicesChanged() override;
void OnVideoCaptureDevicesChanged() override;
void OnMediaRequestStateChanged(int render_process_id,
int render_frame_id,
int page_request_id,
const GURL& security_origin,
content::MediaStreamType stream_type,
content::MediaRequestState state) override;
void OnCreatingAudioStream(int render_process_id,
int render_frame_id) override;
scoped_refptr<MediaStreamCaptureIndicator> GetMediaStreamCaptureIndicator();
DesktopStreamsRegistry* GetDesktopStreamsRegistry();
bool IsDesktopCaptureInProgress();
// Only for testing.
void SetTestAudioCaptureDevices(const content::MediaStreamDevices& devices);
void SetTestVideoCaptureDevices(const content::MediaStreamDevices& devices);
private:
friend struct DefaultSingletonTraits<MediaCaptureDevicesDispatcher>;
MediaCaptureDevicesDispatcher();
~MediaCaptureDevicesDispatcher() override;
// Called by the MediaObserver() functions, executed on UI thread.
void NotifyAudioDevicesChangedOnUIThread();
void NotifyVideoDevicesChangedOnUIThread();
void UpdateMediaRequestStateOnUIThread(
int render_process_id,
int render_frame_id,
int page_request_id,
const GURL& security_origin,
content::MediaStreamType stream_type,
content::MediaRequestState state);
void OnCreatingAudioStreamOnUIThread(int render_process_id,
int render_frame_id);
// Only for testing, a list of cached audio capture devices.
content::MediaStreamDevices test_audio_devices_;
// Only for testing, a list of cached video capture devices.
content::MediaStreamDevices test_video_devices_;
// A list of observers for the device update notifications.
base::ObserverList<Observer> observers_;
// Flag used by unittests to disable device enumeration.
bool is_device_enumeration_disabled_;
scoped_refptr<MediaStreamCaptureIndicator> media_stream_capture_indicator_;
scoped_ptr<DesktopStreamsRegistry> desktop_streams_registry_;
// Handlers for processing media access requests.
ScopedVector<MediaAccessHandler> media_access_handlers_;
DISALLOW_COPY_AND_ASSIGN(MediaCaptureDevicesDispatcher);
};
#endif // CHROME_BROWSER_MEDIA_MEDIA_CAPTURE_DEVICES_DISPATCHER_H_
|
