Home | History | Annotate | Download | only in media 
      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/renderer/media/media_stream_dispatcher.h"
      6 
      7 #include "base/logging.h"
      8 #include "content/common/media/media_stream_messages.h"
      9 #include "content/renderer/media/media_stream_dispatcher_eventhandler.h"
     10 #include "content/renderer/render_thread_impl.h"
     11 #include "media/audio/audio_parameters.h"
     12 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
     13 #include "url/gurl.h"
     14 
     15 namespace content {
     16 
     17 namespace {
     18 
     19 bool RemoveStreamDeviceFromArray(const StreamDeviceInfo device_info,
     20                                  StreamDeviceInfoArray* array) {
     21   for (StreamDeviceInfoArray::iterator device_it = array->begin();
     22        device_it != array->end(); ++device_it) {
     23     if (StreamDeviceInfo::IsEqual(*device_it, device_info)) {
     24       array->erase(device_it);
     25       return true;
     26     }
     27   }
     28   return false;
     29 }
     30 
     31 }  // namespace
     32 
     33 // A request is identified by pair (request_id, handler), or ipc_request.
     34 // There could be multiple clients making requests and each has its own
     35 // request_id sequence.
     36 // The ipc_request is garanteed to be unique when it's created in
     37 // MediaStreamDispatcher.
     38 struct MediaStreamDispatcher::Request {
     39   Request(const base::WeakPtr<MediaStreamDispatcherEventHandler>& handler,
     40           int request_id,
     41           int ipc_request)
     42       : handler(handler),
     43         request_id(request_id),
     44         ipc_request(ipc_request) {
     45   }
     46   bool IsThisRequest(
     47       int request_id1,
     48       const base::WeakPtr<MediaStreamDispatcherEventHandler>& handler1) {
     49     return (request_id1 == request_id && handler1.get() == handler.get());
     50   }
     51   base::WeakPtr<MediaStreamDispatcherEventHandler> handler;
     52   int request_id;
     53   int ipc_request;
     54 };
     55 
     56 struct MediaStreamDispatcher::Stream {
     57   Stream() {}
     58   ~Stream() {}
     59   base::WeakPtr<MediaStreamDispatcherEventHandler> handler;
     60   StreamDeviceInfoArray audio_array;
     61   StreamDeviceInfoArray video_array;
     62 };
     63 
     64 MediaStreamDispatcher::MediaStreamDispatcher(RenderFrame* render_frame)
     65     : RenderFrameObserver(render_frame),
     66       next_ipc_id_(0) {
     67 }
     68 
     69 MediaStreamDispatcher::~MediaStreamDispatcher() {}
     70 
     71 void MediaStreamDispatcher::GenerateStream(
     72     int request_id,
     73     const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
     74     const StreamOptions& components,
     75     const GURL& security_origin) {
     76   DCHECK(thread_checker_.CalledOnValidThread());
     77   DVLOG(1) << "MediaStreamDispatcher::GenerateStream(" << request_id << ")";
     78 
     79   requests_.push_back(Request(event_handler, request_id, next_ipc_id_));
     80   Send(new MediaStreamHostMsg_GenerateStream(
     81       routing_id(), next_ipc_id_++, components, security_origin,
     82       blink::WebUserGestureIndicator::isProcessingUserGesture()));
     83 }
     84 
     85 void MediaStreamDispatcher::CancelGenerateStream(
     86     int request_id,
     87     const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler) {
     88   DCHECK(thread_checker_.CalledOnValidThread());
     89   DVLOG(1) << "MediaStreamDispatcher::CancelGenerateStream"
     90            << ", {request_id = " << request_id << "}";
     91 
     92   RequestList::iterator it = requests_.begin();
     93   for (; it != requests_.end(); ++it) {
     94     if (it->IsThisRequest(request_id, event_handler)) {
     95       int ipc_request = it->ipc_request;
     96       requests_.erase(it);
     97       Send(new MediaStreamHostMsg_CancelGenerateStream(routing_id(),
     98                                                        ipc_request));
     99       break;
    100     }
    101   }
    102 }
    103 
    104 void MediaStreamDispatcher::StopStreamDevice(
    105     const StreamDeviceInfo& device_info) {
    106   DCHECK(thread_checker_.CalledOnValidThread());
    107   DVLOG(1) << "MediaStreamDispatcher::StopStreamDevice"
    108            << ", {device_id = " << device_info.device.id << "}";
    109   // Remove |device_info| from all streams in |label_stream_map_|.
    110   bool device_found = false;
    111   LabelStreamMap::iterator stream_it = label_stream_map_.begin();
    112   while (stream_it != label_stream_map_.end()) {
    113     StreamDeviceInfoArray& audio_array = stream_it->second.audio_array;
    114     StreamDeviceInfoArray& video_array = stream_it->second.video_array;
    115 
    116     if (RemoveStreamDeviceFromArray(device_info, &audio_array) ||
    117         RemoveStreamDeviceFromArray(device_info, &video_array)) {
    118       device_found = true;
    119       if (audio_array.empty() && video_array.empty()) {
    120         label_stream_map_.erase(stream_it++);
    121         continue;
    122       }
    123     }
    124     ++stream_it;
    125   }
    126   DCHECK(device_found);
    127 
    128   Send(new MediaStreamHostMsg_StopStreamDevice(routing_id(),
    129                                                device_info.device.id));
    130 }
    131 
    132 void MediaStreamDispatcher::EnumerateDevices(
    133     int request_id,
    134     const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
    135     MediaStreamType type,
    136     const GURL& security_origin) {
    137   DCHECK(thread_checker_.CalledOnValidThread());
    138   DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
    139          type == MEDIA_DEVICE_VIDEO_CAPTURE ||
    140          type == MEDIA_DEVICE_AUDIO_OUTPUT);
    141   DVLOG(1) << "MediaStreamDispatcher::EnumerateDevices("
    142            << request_id << ")";
    143 
    144   for (RequestList::iterator it = requests_.begin(); it != requests_.end();
    145        ++it) {
    146     DCHECK(!it->IsThisRequest(request_id, event_handler));
    147   }
    148 
    149   requests_.push_back(Request(event_handler, request_id, next_ipc_id_));
    150   Send(new MediaStreamHostMsg_EnumerateDevices(routing_id(),
    151                                                next_ipc_id_++,
    152                                                type,
    153                                                security_origin));
    154 }
    155 
    156 void MediaStreamDispatcher::StopEnumerateDevices(
    157     int request_id,
    158     const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler) {
    159   DCHECK(thread_checker_.CalledOnValidThread());
    160   DVLOG(1) << "MediaStreamDispatcher::StopEnumerateDevices("
    161            << request_id << ")";
    162   for (RequestList::iterator it = requests_.begin(); it != requests_.end();
    163        ++it) {
    164     if (it->IsThisRequest(request_id, event_handler)) {
    165       Send(new MediaStreamHostMsg_CancelEnumerateDevices(routing_id(),
    166                                                          it->ipc_request));
    167       requests_.erase(it);
    168       break;
    169     }
    170   }
    171 }
    172 
    173 void MediaStreamDispatcher::OpenDevice(
    174     int request_id,
    175     const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
    176     const std::string& device_id,
    177     MediaStreamType type,
    178     const GURL& security_origin) {
    179   DCHECK(thread_checker_.CalledOnValidThread());
    180   DVLOG(1) << "MediaStreamDispatcher::OpenDevice(" << request_id << ")";
    181 
    182   requests_.push_back(Request(event_handler, request_id, next_ipc_id_));
    183   Send(new MediaStreamHostMsg_OpenDevice(routing_id(),
    184                                          next_ipc_id_++,
    185                                          device_id,
    186                                          type,
    187                                          security_origin));
    188 }
    189 
    190 void MediaStreamDispatcher::CancelOpenDevice(
    191     int request_id,
    192     const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler) {
    193   CancelGenerateStream(request_id, event_handler);
    194 }
    195 
    196 void MediaStreamDispatcher::CloseDevice(const std::string& label) {
    197   DCHECK(thread_checker_.CalledOnValidThread());
    198   DCHECK(!label.empty());
    199   DVLOG(1) << "MediaStreamDispatcher::CloseDevice"
    200            << ", {label = " << label << "}";
    201 
    202   LabelStreamMap::iterator it = label_stream_map_.find(label);
    203   if (it == label_stream_map_.end())
    204     return;
    205   label_stream_map_.erase(it);
    206 
    207   Send(new MediaStreamHostMsg_CloseDevice(routing_id(), label));
    208 }
    209 
    210 void MediaStreamDispatcher::OnDestruct() {
    211   // Do not self-destruct. UserMediaClientImpl owns |this|.
    212 }
    213 
    214 bool MediaStreamDispatcher::Send(IPC::Message* message) {
    215   if (!RenderThread::Get()) {
    216     delete message;
    217     return false;
    218   }
    219 
    220   return RenderThread::Get()->Send(message);
    221 }
    222 
    223 bool MediaStreamDispatcher::OnMessageReceived(const IPC::Message& message) {
    224   bool handled = true;
    225   IPC_BEGIN_MESSAGE_MAP(MediaStreamDispatcher, message)
    226     IPC_MESSAGE_HANDLER(MediaStreamMsg_StreamGenerated,
    227                         OnStreamGenerated)
    228     IPC_MESSAGE_HANDLER(MediaStreamMsg_StreamGenerationFailed,
    229                         OnStreamGenerationFailed)
    230     IPC_MESSAGE_HANDLER(MediaStreamMsg_DeviceStopped,
    231                         OnDeviceStopped)
    232     IPC_MESSAGE_HANDLER(MediaStreamMsg_DevicesEnumerated,
    233                         OnDevicesEnumerated)
    234     IPC_MESSAGE_HANDLER(MediaStreamMsg_DeviceOpened,
    235                         OnDeviceOpened)
    236     IPC_MESSAGE_HANDLER(MediaStreamMsg_DeviceOpenFailed,
    237                         OnDeviceOpenFailed)
    238     IPC_MESSAGE_UNHANDLED(handled = false)
    239   IPC_END_MESSAGE_MAP()
    240   return handled;
    241 }
    242 
    243 void MediaStreamDispatcher::OnStreamGenerated(
    244     int request_id,
    245     const std::string& label,
    246     const StreamDeviceInfoArray& audio_array,
    247     const StreamDeviceInfoArray& video_array) {
    248   DCHECK(thread_checker_.CalledOnValidThread());
    249 
    250   for (RequestList::iterator it = requests_.begin();
    251        it != requests_.end(); ++it) {
    252     Request& request = *it;
    253     if (request.ipc_request == request_id) {
    254       Stream new_stream;
    255       new_stream.handler = request.handler;
    256       new_stream.audio_array = audio_array;
    257       new_stream.video_array = video_array;
    258       label_stream_map_[label] = new_stream;
    259       if (request.handler.get()) {
    260         request.handler->OnStreamGenerated(
    261             request.request_id, label, audio_array, video_array);
    262         DVLOG(1) << "MediaStreamDispatcher::OnStreamGenerated("
    263                  << request.request_id << ", " << label << ")";
    264       }
    265       requests_.erase(it);
    266       break;
    267     }
    268   }
    269 }
    270 
    271 void MediaStreamDispatcher::OnStreamGenerationFailed(
    272     int request_id,
    273     content::MediaStreamRequestResult result) {
    274   DCHECK(thread_checker_.CalledOnValidThread());
    275   for (RequestList::iterator it = requests_.begin();
    276        it != requests_.end(); ++it) {
    277     Request& request = *it;
    278     if (request.ipc_request == request_id) {
    279       if (request.handler.get()) {
    280         request.handler->OnStreamGenerationFailed(request.request_id, result);
    281         DVLOG(1) << "MediaStreamDispatcher::OnStreamGenerationFailed("
    282                  << request.request_id << ")\n";
    283       }
    284       requests_.erase(it);
    285       break;
    286     }
    287   }
    288 }
    289 
    290 void MediaStreamDispatcher::OnDeviceStopped(
    291     const std::string& label,
    292     const StreamDeviceInfo& device_info) {
    293   DCHECK(thread_checker_.CalledOnValidThread());
    294   DVLOG(1) << "MediaStreamDispatcher::OnDeviceStopped("
    295            << "{label = " << label << "})"
    296            << ", {device_id = " << device_info.device.id << "})";
    297 
    298   LabelStreamMap::iterator it = label_stream_map_.find(label);
    299   if (it == label_stream_map_.end()) {
    300     // This can happen if a user happen stop a the device from JS at the same
    301     // time as the underlying media device is unplugged from the system.
    302     return;
    303   }
    304   Stream* stream = &it->second;
    305   if (IsAudioInputMediaType(device_info.device.type))
    306     RemoveStreamDeviceFromArray(device_info, &stream->audio_array);
    307   else
    308     RemoveStreamDeviceFromArray(device_info, &stream->video_array);
    309 
    310   if (stream->handler.get())
    311     stream->handler->OnDeviceStopped(label, device_info);
    312 
    313   if (stream->audio_array.empty() && stream->video_array.empty())
    314     label_stream_map_.erase(it);
    315 }
    316 
    317 void MediaStreamDispatcher::OnDevicesEnumerated(
    318     int request_id,
    319     const StreamDeviceInfoArray& device_array) {
    320   DCHECK(thread_checker_.CalledOnValidThread());
    321   DCHECK_GE(request_id, 0);
    322 
    323   for (RequestList::iterator it = requests_.begin(); it != requests_.end();
    324        ++it) {
    325     if (it->ipc_request == request_id && it->handler.get()) {
    326       it->handler->OnDevicesEnumerated(it->request_id, device_array);
    327       break;
    328     }
    329   }
    330 }
    331 
    332 void MediaStreamDispatcher::OnDeviceOpened(
    333     int request_id,
    334     const std::string& label,
    335     const StreamDeviceInfo& device_info) {
    336   DCHECK(thread_checker_.CalledOnValidThread());
    337   for (RequestList::iterator it = requests_.begin();
    338        it != requests_.end(); ++it) {
    339     Request& request = *it;
    340     if (request.ipc_request == request_id) {
    341       Stream new_stream;
    342       new_stream.handler = request.handler;
    343       if (IsAudioInputMediaType(device_info.device.type)) {
    344         new_stream.audio_array.push_back(device_info);
    345       } else if (IsVideoMediaType(device_info.device.type)) {
    346         new_stream.video_array.push_back(device_info);
    347       } else {
    348         NOTREACHED();
    349       }
    350       label_stream_map_[label] = new_stream;
    351       if (request.handler.get()) {
    352         request.handler->OnDeviceOpened(request.request_id, label, device_info);
    353         DVLOG(1) << "MediaStreamDispatcher::OnDeviceOpened("
    354                  << request.request_id << ", " << label << ")";
    355       }
    356       requests_.erase(it);
    357       break;
    358     }
    359   }
    360 }
    361 
    362 void MediaStreamDispatcher::OnDeviceOpenFailed(int request_id) {
    363   DCHECK(thread_checker_.CalledOnValidThread());
    364   for (RequestList::iterator it = requests_.begin();
    365        it != requests_.end(); ++it) {
    366     Request& request = *it;
    367     if (request.ipc_request == request_id) {
    368       if (request.handler.get()) {
    369         request.handler->OnDeviceOpenFailed(request.request_id);
    370         DVLOG(1) << "MediaStreamDispatcher::OnDeviceOpenFailed("
    371                  << request.request_id << ")\n";
    372       }
    373       requests_.erase(it);
    374       break;
    375     }
    376   }
    377 }
    378 
    379 int MediaStreamDispatcher::audio_session_id(const std::string& label,
    380                                             int index) {
    381   DCHECK(thread_checker_.CalledOnValidThread());
    382   LabelStreamMap::iterator it = label_stream_map_.find(label);
    383   if (it == label_stream_map_.end() ||
    384       it->second.audio_array.size() <= static_cast<size_t>(index)) {
    385     return StreamDeviceInfo::kNoId;
    386   }
    387   return it->second.audio_array[index].session_id;
    388 }
    389 
    390 bool MediaStreamDispatcher::IsStream(const std::string& label) {
    391   DCHECK(thread_checker_.CalledOnValidThread());
    392   return label_stream_map_.find(label) != label_stream_map_.end();
    393 }
    394 
    395 int MediaStreamDispatcher::video_session_id(const std::string& label,
    396                                             int index) {
    397   DCHECK(thread_checker_.CalledOnValidThread());
    398   LabelStreamMap::iterator it = label_stream_map_.find(label);
    399   if (it == label_stream_map_.end() ||
    400       it->second.video_array.size() <= static_cast<size_t>(index)) {
    401     return StreamDeviceInfo::kNoId;
    402   }
    403   return it->second.video_array[index].session_id;
    404 }
    405 
    406 bool MediaStreamDispatcher::IsAudioDuckingActive() const {
    407   DCHECK(thread_checker_.CalledOnValidThread());
    408   LabelStreamMap::const_iterator stream_it = label_stream_map_.begin();
    409   while (stream_it != label_stream_map_.end()) {
    410     const StreamDeviceInfoArray& audio_array = stream_it->second.audio_array;
    411     for (StreamDeviceInfoArray::const_iterator device_it = audio_array.begin();
    412          device_it != audio_array.end(); ++device_it) {
    413       if (device_it->device.input.effects & media::AudioParameters::DUCKING)
    414         return true;
    415     }
    416     ++stream_it;
    417   }
    418   return false;
    419 }
    420 
    421 }  // namespace content
    422