src/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/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
  13 namespace content {
  14
  15 MediaStreamDispatcherHost::MediaStreamDispatcherHost(
  16     int render_process_id,
  17     MediaStreamManager* media_stream_manager)
  18     : render_process_id_(render_process_id),
  19       media_stream_manager_(media_stream_manager) {
  20 }
  21
  22 void MediaStreamDispatcherHost::StreamGenerated(
  23     const std::string& label,
  24     const StreamDeviceInfoArray& audio_devices,
  25     const StreamDeviceInfoArray& video_devices) {
  26   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  27   DVLOG(1) << "MediaStreamDispatcherHost::StreamGenerated("
  28            << ", {label = " << label <<  "})";
  29
  30   StreamRequest request = PopRequest(label);
  31
  32   Send(new MediaStreamMsg_StreamGenerated(
  33       request.render_view_id, request.page_request_id, label, audio_devices,
  34       video_devices));
  35 }
  36
  37 void MediaStreamDispatcherHost::StreamGenerationFailed(
  38     const std::string& label) {
  39   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  40   DVLOG(1) << "MediaStreamDispatcherHost::StreamGenerationFailed("
  41            << ", {label = " << label <<  "})";
  42
  43   StreamRequest request = PopRequest(label);
  44
  45   Send(new MediaStreamMsg_StreamGenerationFailed(request.render_view_id,
  46                                                  request.page_request_id));
  47 }
  48
  49 void MediaStreamDispatcherHost::StopGeneratedStream(
  50     int render_view_id,
  51     const std::string& label) {
  52   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  53   DVLOG(1) << "MediaStreamDispatcherHost::StopGeneratedStream("
  54            << ", {label = " << label <<  "})";
  55
  56   Send(new MediaStreamMsg_StopGeneratedStream(render_view_id, label));
  57 }
  58
  59 void MediaStreamDispatcherHost::DevicesEnumerated(
  60     const std::string& label,
  61     const StreamDeviceInfoArray& devices) {
  62   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  63   DVLOG(1) << "MediaStreamDispatcherHost::DevicesEnumerated("
  64            << ", {label = " << label <<  "})";
  65
  66   StreamMap::iterator it = streams_.find(label);
  67   DCHECK(it != streams_.end());
  68   StreamRequest request = it->second;
  69
  70   Send(new MediaStreamMsg_DevicesEnumerated(
  71       request.render_view_id, request.page_request_id, label, devices));
  72 }
  73
  74 void MediaStreamDispatcherHost::DeviceOpened(
  75     const std::string& label,
  76     const StreamDeviceInfo& video_device) {
  77   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  78   DVLOG(1) << "MediaStreamDispatcherHost::DeviceOpened("
  79            << ", {label = " << label <<  "})";
  80
  81   StreamRequest request = PopRequest(label);
  82
  83   Send(new MediaStreamMsg_DeviceOpened(
  84       request.render_view_id, request.page_request_id, label, video_device));
  85 }
  86
  87 bool MediaStreamDispatcherHost::OnMessageReceived(
  88     const IPC::Message& message, bool* message_was_ok) {
  89   bool handled = true;
  90   IPC_BEGIN_MESSAGE_MAP_EX(MediaStreamDispatcherHost, message, *message_was_ok)
  91     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_GenerateStream, OnGenerateStream)
  92     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_CancelGenerateStream,
  93                         OnCancelGenerateStream)
  94     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_StopStreamDevice,
  95                         OnStopStreamDevice)
  96     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_EnumerateDevices,
  97                         OnEnumerateDevices)
  98     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_OpenDevice,
  99                         OnOpenDevice)
 100     IPC_MESSAGE_HANDLER(MediaStreamHostMsg_CloseDevice,
 101                         OnCloseDevice)
 102     IPC_MESSAGE_UNHANDLED(handled = false)
 103   IPC_END_MESSAGE_MAP_EX()
 104   return handled;
 105 }
 106
 107 void MediaStreamDispatcherHost::OnChannelClosing() {
 108   DVLOG(1) << "MediaStreamDispatcherHost::OnChannelClosing";
 109
 110   // Since the IPC channel is gone, close all requesting/requested streams.
 111   media_stream_manager_->CancelAllRequests(render_process_id_);
 112   // Clear the map after we have stopped all the streams.
 113   streams_.clear();
 114 }
 115
 116 MediaStreamDispatcherHost::~MediaStreamDispatcherHost() {
 117   DCHECK(streams_.empty());
 118 }
 119
 120 void 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_type
 129            << " video:" << components.video_type
 130            << " ], "
 131            << security_origin.spec() << ")";
 132
 133   const std::string& label = media_stream_manager_->GenerateStream(
 134       this, render_process_id_, render_view_id, page_request_id,
 135       components, security_origin);
 136   if (label.empty()) {
 137     Send(new MediaStreamMsg_StreamGenerationFailed(render_view_id,
 138                                                    page_request_id));
 139   } else {
 140     StoreRequest(render_view_id, page_request_id, label);
 141   }
 142 }
 143
 144 void MediaStreamDispatcherHost::OnCancelGenerateStream(int render_view_id,
 145                                                        int page_request_id) {
 146   DVLOG(1) << "MediaStreamDispatcherHost::OnCancelGenerateStream("
 147            << render_view_id << ", "
 148            << page_request_id << ")";
 149
 150   for (StreamMap::iterator it = streams_.begin(); it != streams_.end(); ++it) {
 151     if (it->second.render_view_id == render_view_id &&
 152         it->second.page_request_id == page_request_id) {
 153       const std::string& label = it->first;
 154       media_stream_manager_->CancelRequest(label);
 155       PopRequest(label);
 156       break;
 157     }
 158   }
 159 }
 160
 161 void MediaStreamDispatcherHost::OnStopStreamDevice(
 162     int render_view_id,
 163     const std::string& device_id) {
 164   DVLOG(1) << "MediaStreamDispatcherHost::OnStopStreamDevice("
 165            << render_view_id << ", "
 166            << device_id << ")";
 167   media_stream_manager_->StopStreamDevice(render_process_id_, render_view_id,
 168                                           device_id);
 169 }
 170
 171 void MediaStreamDispatcherHost::OnEnumerateDevices(
 172     int render_view_id,
 173     int page_request_id,
 174     MediaStreamType type,
 175     const GURL& security_origin) {
 176   DVLOG(1) << "MediaStreamDispatcherHost::OnEnumerateDevices("
 177            << render_view_id << ", "
 178            << page_request_id << ", "
 179            << type << ", "
 180            << security_origin.spec() << ")";
 181
 182   const std::string& label = media_stream_manager_->EnumerateDevices(
 183       this, render_process_id_, render_view_id, page_request_id,
 184       type, security_origin);
 185   StoreRequest(render_view_id, page_request_id, label);
 186 }
 187
 188 void MediaStreamDispatcherHost::OnCancelEnumerateDevices(
 189     int render_view_id,
 190     const std::string& label) {
 191   DVLOG(1) << "MediaStreamDispatcherHost::OnCancelEnumerateDevices("
 192            << render_view_id << ", "
 193            << label << ")";
 194
 195   media_stream_manager_->CancelRequest(label);
 196   PopRequest(label);
 197 }
 198
 199 void MediaStreamDispatcherHost::OnOpenDevice(
 200     int render_view_id,
 201     int page_request_id,
 202     const std::string& device_id,
 203     MediaStreamType type,
 204     const GURL& security_origin) {
 205   DVLOG(1) << "MediaStreamDispatcherHost::OnOpenDevice("
 206            << render_view_id << ", "
 207            << page_request_id << ", device_id: "
 208            << device_id.c_str() << ", type: "
 209            << type << ", "
 210            << security_origin.spec() << ")";
 211
 212   const std::string& label = media_stream_manager_->OpenDevice(
 213       this, render_process_id_, render_view_id, page_request_id,
 214       device_id, type, security_origin);
 215   StoreRequest(render_view_id, page_request_id, label);
 216 }
 217
 218 void MediaStreamDispatcherHost::OnCloseDevice(
 219     int render_view_id,
 220     const std::string& label) {
 221   DVLOG(1) << "MediaStreamDispatcherHost::OnCloseDevice("
 222            << render_view_id << ", "
 223            << label << ")";
 224
 225   media_stream_manager_->CancelRequest(label);
 226 }
 227
 228 void MediaStreamDispatcherHost::StoreRequest(int render_view_id,
 229                                              int page_request_id,
 230                                              const std::string& label) {
 231   DCHECK(!label.empty());
 232   DCHECK(streams_.find(label) == streams_.end());
 233
 234   streams_[label] = StreamRequest(render_view_id, page_request_id);
 235 }
 236
 237 MediaStreamDispatcherHost::StreamRequest
 238 MediaStreamDispatcherHost::PopRequest(const std::string& label) {
 239   StreamMap::iterator it = streams_.find(label);
 240   CHECK(it != streams_.end());
 241   StreamRequest request = it->second;
 242   streams_.erase(it);
 243   return request;
 244 }
 245
 246 }  // namespace content