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
|
// 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 CONTENT_PUBLIC_COMMON_MEDIA_STREAM_REQUEST_H_
#define CONTENT_PUBLIC_COMMON_MEDIA_STREAM_REQUEST_H_
#include <map>
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/callback_forward.h"
#include "base/memory/scoped_ptr.h"
#include "content/common/content_export.h"
#include "url/gurl.h"
namespace content {
// Types of media streams.
enum MediaStreamType {
MEDIA_NO_SERVICE = 0,
// A device provided by the operating system (e.g., webcam input).
MEDIA_DEVICE_AUDIO_CAPTURE,
MEDIA_DEVICE_VIDEO_CAPTURE,
// Mirroring of a browser tab.
//
// TODO(serygeu): Remove these values and use MEDIA_DESKTOP_VIDEO_CAPTURE and
// MEDIA_DESKTOP_AUDIO_CAPTURE.
MEDIA_TAB_AUDIO_CAPTURE,
MEDIA_TAB_VIDEO_CAPTURE,
// Desktop media sources.
MEDIA_DESKTOP_VIDEO_CAPTURE,
// Capture system audio (post-mix loopback stream).
//
// TODO(sergeyu): Replace with MEDIA_DESKTOP_AUDIO_CAPTURE.
MEDIA_SYSTEM_AUDIO_CAPTURE,
NUM_MEDIA_TYPES
};
// Types of media stream requests that can be made to the media controller.
enum MediaStreamRequestType {
MEDIA_DEVICE_ACCESS = 0,
MEDIA_GENERATE_STREAM,
MEDIA_ENUMERATE_DEVICES,
MEDIA_OPEN_DEVICE
};
// Convenience predicates to determine whether the given type represents some
// audio or some video device.
CONTENT_EXPORT bool IsAudioMediaType(MediaStreamType type);
CONTENT_EXPORT bool IsVideoMediaType(MediaStreamType type);
// TODO(xians): Change the structs to classes.
// Represents one device in a request for media stream(s).
struct CONTENT_EXPORT MediaStreamDevice {
MediaStreamDevice();
MediaStreamDevice(
MediaStreamType type,
const std::string& id,
const std::string& name);
MediaStreamDevice(
MediaStreamType type,
const std::string& id,
const std::string& name,
int sample_rate,
int channel_layout);
~MediaStreamDevice();
// The device's type.
MediaStreamType type;
// The device's unique ID.
std::string id;
// The device's "friendly" name. Not guaranteed to be unique.
std::string name;
// Preferred sample rate in samples per second for the device.
// Only utilized for audio devices. Will be set to 0 if the constructor
// with three parameters (intended for video) is used.
int sample_rate;
// Preferred channel configuration for the device.
// Only utilized for audio devices. Will be set to 0 if the constructor
// with three parameters (intended for video) is used.
// TODO(henrika): ideally, we would like to use media::ChannelLayout here
// but including media/base/channel_layout.h violates checkdeps rules.
int channel_layout;
};
typedef std::vector<MediaStreamDevice> MediaStreamDevices;
typedef std::map<MediaStreamType, MediaStreamDevices> MediaStreamDeviceMap;
// Represents a request for media streams (audio/video).
// It looks like the last 4 parameters should use StreamOptions instead, but
// StreamOption depends on media_stream_request.h because it needs
// MediaStreamDevice.
// TODO(vrk): Decouple MediaStreamDevice from this header file so that
// media_stream_options.h no longer depends on this file.
// TODO(vrk,justinlin,wjia): Figure out a way to share this code cleanly between
// vanilla WebRTC, Tab Capture, and Pepper Video Capture. Right now there is
// Tab-only stuff and Pepper-only stuff being passed around to all clients,
// which is icky.
struct CONTENT_EXPORT MediaStreamRequest {
MediaStreamRequest(
int render_process_id,
int render_view_id,
int page_request_id,
const std::string& tab_capture_device_id,
const GURL& security_origin,
MediaStreamRequestType request_type,
const std::string& requested_audio_device_id,
const std::string& requested_video_device_id,
MediaStreamType audio_type,
MediaStreamType video_type);
~MediaStreamRequest();
// The render process id generating this request.
int render_process_id;
// The render view id generating this request.
int render_view_id;
// The unique id combined with render_process_id and render_view_id for
// identifying this request. This is used for cancelling request.
int page_request_id;
// Used by tab capture.
std::string tab_capture_device_id;
// The WebKit security origin for the current request (e.g. "html5rocks.com").
GURL security_origin;
// Stores the type of request that was made to the media controller. Right now
// this is only used to distinguish between WebRTC and Pepper requests, as the
// latter should not be subject to user approval but only to policy check.
// Pepper requests are signified by the |MEDIA_OPEN_DEVICE| value.
MediaStreamRequestType request_type;
// Stores the requested raw device id for physical audio or video devices.
std::string requested_audio_device_id;
std::string requested_video_device_id;
// Flag to indicate if the request contains audio.
MediaStreamType audio_type;
// Flag to indicate if the request contains video.
MediaStreamType video_type;
};
// Interface used by the content layer to notify chrome about changes in the
// state of a media stream. Instances of this class are passed to content layer
// when MediaStream access is approved using MediaResponseCallback.
class MediaStreamUI {
public:
virtual ~MediaStreamUI() {}
// Called when MediaStream capturing is started. Chrome layer can call |stop|
// to stop the stream.
virtual void OnStarted(const base::Closure& stop) = 0;
};
// Callback used return results of media access requests.
typedef base::Callback<void(
const MediaStreamDevices& devices,
scoped_ptr<MediaStreamUI> ui)> MediaResponseCallback;
} // namespace content
#endif // CONTENT_PUBLIC_COMMON_MEDIA_STREAM_REQUEST_H_
|
