1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "content/browser/renderer_host/media/media_stream_dispatcher_host.h"
6
7#include "content/browser/browser_main_loop.h"
8#include "content/browser/renderer_host/media/web_contents_capture_util.h"
9#include "content/common/media/media_stream_messages.h"
10#include "content/common/media/media_stream_options.h"
11#include "url/gurl.h"
12
13namespace content {
14
15MediaStreamDispatcherHost::MediaStreamDispatcherHost(
16    int render_process_id,
17    const ResourceContext::SaltCallback& salt_callback,
18    MediaStreamManager* media_stream_manager)
19    : render_process_id_(render_process_id),
20      salt_callback_(salt_callback),
21      media_stream_manager_(media_stream_manager) {
22}
23
24void MediaStreamDispatcherHost::StreamGenerated(
25    int render_view_id,
26    int page_request_id,
27    const std::string& label,
28    const StreamDeviceInfoArray& audio_devices,
29    const StreamDeviceInfoArray& video_devices) {
30  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
31  DVLOG(1) << "MediaStreamDispatcherHost::StreamGenerated("
32           << ", {label = " << label <<  "})";
33
34  Send(new MediaStreamMsg_StreamGenerated(
35      render_view_id, page_request_id, label, audio_devices,
36      video_devices));
37}
38
39void MediaStreamDispatcherHost::StreamGenerationFailed(int render_view_id,
40                                                       int page_request_id) {
41  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
42  DVLOG(1) << "MediaStreamDispatcherHost::StreamGenerationFailed("
43           << ", {page_request_id = " << page_request_id <<  "})";
44
45
46  Send(new MediaStreamMsg_StreamGenerationFailed(render_view_id,
47                                                 page_request_id));
48}
49
50void MediaStreamDispatcherHost::DeviceStopped(int render_view_id,
51                                              const std::string& label,
52                                              const StreamDeviceInfo& device) {
53  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
54  DVLOG(1) << "MediaStreamDispatcherHost::DeviceStopped("
55           << "{label = " << label << "}, "
56           << "{type = " << device.device.type << "}, "
57           << "{device_id = " << device.device.id << "})";
58
59  Send(new MediaStreamMsg_DeviceStopped(render_view_id, label, device));
60}
61
62void MediaStreamDispatcherHost::DevicesEnumerated(
63    int render_view_id,
64    int page_request_id,
65    const std::string& label,
66    const StreamDeviceInfoArray& devices) {
67  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
68  DVLOG(1) << "MediaStreamDispatcherHost::DevicesEnumerated("
69           << ", {page_request_id = " << page_request_id <<  "})";
70
71  Send(new MediaStreamMsg_DevicesEnumerated(render_view_id, page_request_id,
72                                            devices));
73}
74
75void MediaStreamDispatcherHost::DeviceOpened(
76    int render_view_id,
77    int page_request_id,
78    const std::string& label,
79    const StreamDeviceInfo& video_device) {
80  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
81  DVLOG(1) << "MediaStreamDispatcherHost::DeviceOpened("
82           << ", {page_request_id = " << page_request_id <<  "})";
83
84  Send(new MediaStreamMsg_DeviceOpened(
85      render_view_id, page_request_id, label, video_device));
86}
87
88bool MediaStreamDispatcherHost::OnMessageReceived(
89    const IPC::Message& message, bool* message_was_ok) {
90  bool handled = true;
91  IPC_BEGIN_MESSAGE_MAP_EX(MediaStreamDispatcherHost, message, *message_was_ok)
92    IPC_MESSAGE_HANDLER(MediaStreamHostMsg_GenerateStream, OnGenerateStream)
93    IPC_MESSAGE_HANDLER(MediaStreamHostMsg_CancelGenerateStream,
94                        OnCancelGenerateStream)
95    IPC_MESSAGE_HANDLER(MediaStreamHostMsg_StopStreamDevice,
96                        OnStopStreamDevice)
97    IPC_MESSAGE_HANDLER(MediaStreamHostMsg_EnumerateDevices,
98                        OnEnumerateDevices)
99    IPC_MESSAGE_HANDLER(MediaStreamHostMsg_CancelEnumerateDevices,
100                        OnCancelEnumerateDevices)
101    IPC_MESSAGE_HANDLER(MediaStreamHostMsg_OpenDevice,
102                        OnOpenDevice)
103    IPC_MESSAGE_HANDLER(MediaStreamHostMsg_CloseDevice,
104                        OnCloseDevice)
105    IPC_MESSAGE_UNHANDLED(handled = false)
106  IPC_END_MESSAGE_MAP_EX()
107  return handled;
108}
109
110void MediaStreamDispatcherHost::OnChannelClosing() {
111  DVLOG(1) << "MediaStreamDispatcherHost::OnChannelClosing";
112
113  // Since the IPC channel is gone, close all requesting/requested streams.
114  media_stream_manager_->CancelAllRequests(render_process_id_);
115}
116
117MediaStreamDispatcherHost::~MediaStreamDispatcherHost() {
118}
119
120void MediaStreamDispatcherHost::OnGenerateStream(
121    int render_view_id,
122    int page_request_id,
123    const StreamOptions& components,
124    const GURL& security_origin) {
125  DVLOG(1) << "MediaStreamDispatcherHost::OnGenerateStream("
126           << render_view_id << ", "
127           << page_request_id << ", ["
128           << " audio:" << components.audio_requested
129           << " video:" << components.video_requested
130           << " ], "
131           << security_origin.spec() << ")";
132
133  media_stream_manager_->GenerateStream(
134      this, render_process_id_, render_view_id, salt_callback_,
135      page_request_id, components, security_origin);
136}
137
138void MediaStreamDispatcherHost::OnCancelGenerateStream(int render_view_id,
139                                                       int page_request_id) {
140  DVLOG(1) << "MediaStreamDispatcherHost::OnCancelGenerateStream("
141           << render_view_id << ", "
142           << page_request_id << ")";
143  media_stream_manager_->CancelRequest(render_process_id_, render_view_id,
144                                       page_request_id);
145}
146
147void MediaStreamDispatcherHost::OnStopStreamDevice(
148    int render_view_id,
149    const std::string& device_id) {
150  DVLOG(1) << "MediaStreamDispatcherHost::OnStopStreamDevice("
151           << render_view_id << ", "
152           << device_id << ")";
153  media_stream_manager_->StopStreamDevice(render_process_id_, render_view_id,
154                                          device_id);
155}
156
157void MediaStreamDispatcherHost::OnEnumerateDevices(
158    int render_view_id,
159    int page_request_id,
160    MediaStreamType type,
161    const GURL& security_origin) {
162  DVLOG(1) << "MediaStreamDispatcherHost::OnEnumerateDevices("
163           << render_view_id << ", "
164           << page_request_id << ", "
165           << type << ", "
166           << security_origin.spec() << ")";
167
168  media_stream_manager_->EnumerateDevices(
169      this, render_process_id_, render_view_id, salt_callback_,
170      page_request_id, type, security_origin);
171}
172
173void MediaStreamDispatcherHost::OnCancelEnumerateDevices(
174    int render_view_id,
175    int page_request_id) {
176  DVLOG(1) << "MediaStreamDispatcherHost::OnCancelEnumerateDevices("
177           << render_view_id << ", "
178           << page_request_id << ")";
179  media_stream_manager_->CancelRequest(render_process_id_, render_view_id,
180                                       page_request_id);
181}
182
183void MediaStreamDispatcherHost::OnOpenDevice(
184    int render_view_id,
185    int page_request_id,
186    const std::string& device_id,
187    MediaStreamType type,
188    const GURL& security_origin) {
189  DVLOG(1) << "MediaStreamDispatcherHost::OnOpenDevice("
190           << render_view_id << ", "
191           << page_request_id << ", device_id: "
192           << device_id.c_str() << ", type: "
193           << type << ", "
194           << security_origin.spec() << ")";
195
196  media_stream_manager_->OpenDevice(
197      this, render_process_id_, render_view_id, salt_callback_,
198      page_request_id, device_id, type, security_origin);
199
200}
201
202void MediaStreamDispatcherHost::OnCloseDevice(
203    int render_view_id,
204    const std::string& label) {
205  DVLOG(1) << "MediaStreamDispatcherHost::OnCloseDevice("
206           << render_view_id << ", "
207           << label << ")";
208
209  media_stream_manager_->CancelRequest(label);
210}
211
212}  // namespace content
213