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
|
// 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_RENDERER_MEDIA_MEDIA_STREAM_DISPATCHER_H_
#define CONTENT_RENDERER_MEDIA_MEDIA_STREAM_DISPATCHER_H_
#include <list>
#include <map>
#include <string>
#include "base/basictypes.h"
#include "base/gtest_prod_util.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "content/common/content_export.h"
#include "content/common/media/media_stream_options.h"
#include "content/public/renderer/render_view_observer.h"
#include "content/renderer/media/media_stream_dispatcher_eventhandler.h"
namespace base {
class MessageLoopProxy;
}
namespace content {
class RenderViewImpl;
// MediaStreamDispatcher is a delegate for the Media Stream API messages.
// MediaStreams are used by WebKit to open media devices such as Video Capture
// and Audio input devices.
// It's the complement of MediaStreamDispatcherHost (owned by
// BrowserRenderProcessHost).
class CONTENT_EXPORT MediaStreamDispatcher
: public RenderViewObserver,
public base::SupportsWeakPtr<MediaStreamDispatcher> {
public:
explicit MediaStreamDispatcher(RenderViewImpl* render_view);
virtual ~MediaStreamDispatcher();
// Request a new media stream to be created.
// This can be used either by WebKit or a plugin.
// Note: The event_handler must be valid for as long as the stream exists.
virtual void GenerateStream(
int request_id,
const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
const StreamOptions& components,
const GURL& security_origin);
// Cancel the request for a new media stream to be created.
virtual void CancelGenerateStream(
int request_id,
const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler);
// Stop a started device that has been requested by calling GenerateStream.
virtual void StopStreamDevice(const StreamDeviceInfo& device_info);
// Request to enumerate devices.
void EnumerateDevices(
int request_id,
const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
MediaStreamType type,
const GURL& security_origin);
// Request to stop enumerating devices.
void StopEnumerateDevices(
int request_id,
const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler);
// Request to open a device.
void OpenDevice(
int request_id,
const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
const std::string& device_id,
MediaStreamType type,
const GURL& security_origin);
// Cancel the request to open a device.
virtual void CancelOpenDevice(
int request_id,
const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler);
// Close a started device. |label| is provided in OnDeviceOpened.
void CloseDevice(const std::string& label);
// Check if the label is a valid stream.
virtual bool IsStream(const std::string& label);
// Get the video session_id given a label. The label identifies a stream.
// index is the index in the video_device_array of the stream.
virtual int video_session_id(const std::string& label, int index);
// Returns an audio session_id given a label and an index.
virtual int audio_session_id(const std::string& label, int index);
protected:
int GetNextIpcIdForTest() { return next_ipc_id_; }
private:
FRIEND_TEST_ALL_PREFIXES(MediaStreamDispatcherTest, BasicVideoDevice);
FRIEND_TEST_ALL_PREFIXES(MediaStreamDispatcherTest, TestFailure);
FRIEND_TEST_ALL_PREFIXES(MediaStreamDispatcherTest, CancelGenerateStream);
// A request is identified by pair (request_id, handler), or ipc_request.
// There could be multiple clients making requests and each has its own
// request_id sequence.
// The ipc_request is garanteed to be unique when it's created in
// MediaStreamDispatcher.
struct Request {
Request(const base::WeakPtr<MediaStreamDispatcherEventHandler>& handler,
int request_id,
int ipc_request)
: handler(handler),
request_id(request_id),
ipc_request(ipc_request) {
}
bool IsThisRequest(
int request_id1,
const base::WeakPtr<MediaStreamDispatcherEventHandler>& handler1) {
return (request_id1 == request_id && handler1.get() == handler.get());
}
base::WeakPtr<MediaStreamDispatcherEventHandler> handler;
int request_id;
int ipc_request;
};
// Private class for keeping track of opened devices and who have
// opened it.
struct Stream {
Stream() {}
~Stream() {}
base::WeakPtr<MediaStreamDispatcherEventHandler> handler;
StreamDeviceInfoArray audio_array;
StreamDeviceInfoArray video_array;
};
// RenderViewObserver OVERRIDE.
virtual bool Send(IPC::Message* message) OVERRIDE;
// Messages from the browser.
virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
void OnStreamGenerated(
int request_id,
const std::string& label,
const StreamDeviceInfoArray& audio_array,
const StreamDeviceInfoArray& video_array);
void OnStreamGenerationFailed(int request_id);
void OnDeviceStopped(const std::string& label,
const StreamDeviceInfo& device_info);
void OnDevicesEnumerated(
int request_id,
const StreamDeviceInfoArray& device_array);
void OnDevicesEnumerationFailed(int request_id);
void OnDeviceOpened(
int request_id,
const std::string& label,
const StreamDeviceInfo& device_info);
void OnDeviceOpenFailed(int request_id);
// Used for DCHECKs so methods calls won't execute in the wrong thread.
scoped_refptr<base::MessageLoopProxy> main_loop_;
int next_ipc_id_;
typedef std::map<std::string, Stream> LabelStreamMap;
LabelStreamMap label_stream_map_;
// List of calls made to the browser process that have not yet completed or
// been canceled.
typedef std::list<Request> RequestList;
RequestList requests_;
DISALLOW_COPY_AND_ASSIGN(MediaStreamDispatcher);
};
} // namespace content
#endif // CONTENT_RENDERER_MEDIA_MEDIA_STREAM_DISPATCHER_H_
|
