content/browser/renderer_host/media/media_stream_dispatcher_host.cc

   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/child_process_security_policy_impl.h"
   9 #include "content/common/media/media_stream_messages.h"
  10 #include "content/common/media/media_stream_options.h"
  11 #include "content/public/browser/render_process_host.h"
  12 #include "url/gurl.h"
  13
  14 namespace content {
  15
  16 MediaStreamDispatcherHost::MediaStreamDispatcherHost(
  17     int render_process_id,
  18     const ResourceContext::SaltCallback& salt_callback,
  19     MediaStreamManager* media_stream_manager,
  20     ResourceContext* resource_context)
  21     : BrowserMessageFilter(MediaStreamMsgStart),
  22       render_process_id_(render_process_id),
  23       salt_callback_(salt_callback),
  24       media_stream_manager_(media_stream_manager),
  25       resource_context_(resource_context) {
  26 }
  27
  28 void MediaStreamDispatcherHost::StreamGenerated(
  29     int render_view_id,
  30     int page_request_id,
  31     const std::string& label,
  32     const StreamDeviceInfoArray& audio_devices,
  33     const StreamDeviceInfoArray& video_devices) {
  34   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  35   DVLOG(1) << "MediaStreamDispatcherHost::StreamGenerated("
  36            << ", {label = " << label <<  "})";
  37
  38   Send(new MediaStreamMsg_StreamGenerated(
  39       render_view_id, page_request_id, label, audio_devices,
  40       video_devices));
  41 }
  42
  43 void MediaStreamDispatcherHost::StreamGenerationFailed(
  44     int render_view_id,
  45     int page_request_id,
  46     content::MediaStreamRequestResult result) {
  47   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  48   DVLOG(1) << "MediaStreamDispatcherHost::StreamGenerationFailed("
  49            << ", {page_request_id = " << page_request_id <<  "}"
  50            << ", { result= " << result << "})";
  51
  52
  53   Send(new MediaStreamMsg_StreamGenerationFailed(render_view_id,
  54                                                  page_request_id,
  55                                                  result));
  56 }
  57
  58 void MediaStreamDispatcherHost::DeviceStopped(int render_view_id,
  59                                               const std::string& label,
  60                                               const StreamDeviceInfo& device) {
  61   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  62   DVLOG(1) << "MediaStreamDispatcherHost::DeviceStopped("
  63            << "{label = " << label << "}, "
  64            << "{type = " << device.device.type << "}, "
  65            << "{device_id = " << device.device.id << "})";
  66
  67   Send(new MediaStreamMsg_DeviceStopped(render_view_id, label, device));
  68 }
  69
  70 void MediaStreamDispatcherHost::DevicesEnumerated(
  71     int render_view_id,
  72     int page_request_id,
  73     const std::string& label,
  74     const StreamDeviceInfoArray& devices) {
  75   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  76   DVLOG(1) << "MediaStreamDispatcherHost::DevicesEnumerated("
  77            << ", {page_request_id = " << page_request_id <<  "})";
  78
  79   Send(new MediaStreamMsg_DevicesEnumerated(render_view_id, page_request_id,
  80                                             devices));
  81 }
  82
  83 void MediaStreamDispatcherHost::DeviceOpened(
  84     int render_view_id,
  85     int page_request_id,
  86     const std::string& label,
  87     const StreamDeviceInfo& video_device) {
  88   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  89   DVLOG(1) << "MediaStreamDispatcherHost::DeviceOpened("
  90            << ", {page_request_id = " << page_request_id <<  "})";
  91
  92   Send(new MediaStreamMsg_DeviceOpened(
  93       render_view_id, page_request_id, label, video_device));
  94 }
  95
  96 bool MediaStreamDispatcherHost::OnMessageReceived(const IPC::Message& message) {
  97   bool handled = true;
  98   IPC_BEGIN_MESSAGE_MAP(MediaStreamDispatcherHost, message)
  99     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_GenerateStream, OnGenerateStream)
 100     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_CancelGenerateStream,
 101                         OnCancelGenerateStream)
 102     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_StopStreamDevice,
 103                         OnStopStreamDevice)
 104     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_EnumerateDevices,
 105                         OnEnumerateDevices)
 106     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_CancelEnumerateDevices,
 107                         OnCancelEnumerateDevices)
 108     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_OpenDevice,
 109                         OnOpenDevice)
 110     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_CloseDevice,
 111                         OnCloseDevice)
 112     IPC_MESSAGE_UNHANDLED(handled = false)
 113   IPC_END_MESSAGE_MAP()
 114   return handled;
 115 }
 116
 117 void MediaStreamDispatcherHost::OnChannelClosing() {
 118   DVLOG(1) << "MediaStreamDispatcherHost::OnChannelClosing";
 119
 120   // Since the IPC sender is gone, close all requesting/requested streams.
 121   media_stream_manager_->CancelAllRequests(render_process_id_);
 122 }
 123
 124 MediaStreamDispatcherHost::~MediaStreamDispatcherHost() {
 125 }
 126
 127 void MediaStreamDispatcherHost::OnGenerateStream(
 128     int render_view_id,
 129     int page_request_id,
 130     const StreamOptions& components,
 131     const GURL& security_origin,
 132     bool user_gesture) {
 133   DVLOG(1) << "MediaStreamDispatcherHost::OnGenerateStream("
 134            << render_view_id << ", "
 135            << page_request_id << ", ["
 136            << " audio:" << components.audio_requested
 137            << " video:" << components.video_requested
 138            << " ], "
 139            << security_origin.spec()
 140            << ", " << user_gesture << ")";
 141
 142   if (!IsURLAllowed(security_origin))
 143     return;
 144
 145   media_stream_manager_->GenerateStream(
 146       this, render_process_id_, render_view_id, salt_callback_,
 147       page_request_id, components, security_origin, user_gesture);
 148 }
 149
 150 void MediaStreamDispatcherHost::OnCancelGenerateStream(int render_view_id,
 151                                                        int page_request_id) {
 152   DVLOG(1) << "MediaStreamDispatcherHost::OnCancelGenerateStream("
 153            << render_view_id << ", "
 154            << page_request_id << ")";
 155   media_stream_manager_->CancelRequest(render_process_id_, render_view_id,
 156                                        page_request_id);
 157 }
 158
 159 void MediaStreamDispatcherHost::OnStopStreamDevice(
 160     int render_view_id,
 161     const std::string& device_id) {
 162   DVLOG(1) << "MediaStreamDispatcherHost::OnStopStreamDevice("
 163            << render_view_id << ", "
 164            << device_id << ")";
 165   media_stream_manager_->StopStreamDevice(render_process_id_, render_view_id,
 166                                           device_id);
 167 }
 168
 169 void MediaStreamDispatcherHost::OnEnumerateDevices(
 170     int render_view_id,
 171     int page_request_id,
 172     MediaStreamType type,
 173     const GURL& security_origin,
 174     bool hide_labels_if_no_access) {
 175   DVLOG(1) << "MediaStreamDispatcherHost::OnEnumerateDevices("
 176            << render_view_id << ", "
 177            << page_request_id << ", "
 178            << type << ", "
 179            << security_origin.spec() << ")";
 180
 181   if (!IsURLAllowed(security_origin))
 182     return;
 183
 184   DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
 185          type == MEDIA_DEVICE_VIDEO_CAPTURE ||
 186          type == MEDIA_DEVICE_AUDIO_OUTPUT);
 187   bool have_permission = true;
 188   if (hide_labels_if_no_access) {
 189     bool audio_type = type == MEDIA_DEVICE_AUDIO_CAPTURE ||
 190                       type == MEDIA_DEVICE_AUDIO_OUTPUT;
 191     have_permission = audio_type ?
 192         resource_context_->AllowMicAccess(security_origin) :
 193         resource_context_->AllowCameraAccess(security_origin);
 194   }
 195
 196   media_stream_manager_->EnumerateDevices(
 197       this, render_process_id_, render_view_id, salt_callback_,
 198       page_request_id, type, security_origin, have_permission);
 199 }
 200
 201 void MediaStreamDispatcherHost::OnCancelEnumerateDevices(
 202     int render_view_id,
 203     int page_request_id) {
 204   DVLOG(1) << "MediaStreamDispatcherHost::OnCancelEnumerateDevices("
 205            << render_view_id << ", "
 206            << page_request_id << ")";
 207   media_stream_manager_->CancelRequest(render_process_id_, render_view_id,
 208                                        page_request_id);
 209 }
 210
 211 void MediaStreamDispatcherHost::OnOpenDevice(
 212     int render_view_id,
 213     int page_request_id,
 214     const std::string& device_id,
 215     MediaStreamType type,
 216     const GURL& security_origin) {
 217   DVLOG(1) << "MediaStreamDispatcherHost::OnOpenDevice("
 218            << render_view_id << ", "
 219            << page_request_id << ", device_id: "
 220            << device_id.c_str() << ", type: "
 221            << type << ", "
 222            << security_origin.spec() << ")";
 223
 224   if (!IsURLAllowed(security_origin))
 225     return;
 226
 227   media_stream_manager_->OpenDevice(
 228       this, render_process_id_, render_view_id, salt_callback_,
 229       page_request_id, device_id, type, security_origin);
 230 }
 231
 232 void MediaStreamDispatcherHost::OnCloseDevice(
 233     int render_view_id,
 234     const std::string& label) {
 235   DVLOG(1) << "MediaStreamDispatcherHost::OnCloseDevice("
 236            << render_view_id << ", "
 237            << label << ")";
 238
 239   media_stream_manager_->CancelRequest(label);
 240 }
 241
 242 bool MediaStreamDispatcherHost::IsURLAllowed(const GURL& url) {
 243   if (!ChildProcessSecurityPolicyImpl::GetInstance()->CanRequestURL(
 244           render_process_id_, url)) {
 245     LOG(ERROR) << "MSDH: Renderer requested a URL it's not allowed to use.";
 246     return false;
 247   }
 248
 249   return true;
 250 }
 251
 252 }  // namespace content