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/user_media_client_impl.h"
      6 
      7 #include <utility>
      8 
      9 #include "base/hash.h"
     10 #include "base/logging.h"
     11 #include "base/strings/string_number_conversions.h"
     12 #include "base/strings/string_util.h"
     13 #include "base/strings/stringprintf.h"
     14 #include "base/strings/utf_string_conversions.h"
     15 #include "content/public/renderer/render_frame.h"
     16 #include "content/renderer/media/media_stream.h"
     17 #include "content/renderer/media/media_stream_audio_source.h"
     18 #include "content/renderer/media/media_stream_dispatcher.h"
     19 #include "content/renderer/media/media_stream_video_capturer_source.h"
     20 #include "content/renderer/media/media_stream_video_track.h"
     21 #include "content/renderer/media/peer_connection_tracker.h"
     22 #include "content/renderer/media/webrtc/webrtc_video_capturer_adapter.h"
     23 #include "content/renderer/media/webrtc_audio_capturer.h"
     24 #include "content/renderer/media/webrtc_logging.h"
     25 #include "content/renderer/media/webrtc_uma_histograms.h"
     26 #include "content/renderer/render_thread_impl.h"
     27 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
     28 #include "third_party/WebKit/public/platform/WebMediaDeviceInfo.h"
     29 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
     30 #include "third_party/WebKit/public/platform/WebMediaStreamTrackSourcesRequest.h"
     31 #include "third_party/WebKit/public/web/WebDocument.h"
     32 #include "third_party/WebKit/public/web/WebLocalFrame.h"
     33 
     34 namespace content {
     35 namespace {
     36 
     37 void CopyStreamConstraints(const blink::WebMediaConstraints& constraints,
     38                            StreamOptions::Constraints* mandatory,
     39                            StreamOptions::Constraints* optional) {
     40   blink::WebVector<blink::WebMediaConstraint> mandatory_constraints;
     41   constraints.getMandatoryConstraints(mandatory_constraints);
     42   for (size_t i = 0; i < mandatory_constraints.size(); i++) {
     43     mandatory->push_back(StreamOptions::Constraint(
     44         mandatory_constraints[i].m_name.utf8(),
     45         mandatory_constraints[i].m_value.utf8()));
     46   }
     47 
     48   blink::WebVector<blink::WebMediaConstraint> optional_constraints;
     49   constraints.getOptionalConstraints(optional_constraints);
     50   for (size_t i = 0; i < optional_constraints.size(); i++) {
     51     optional->push_back(StreamOptions::Constraint(
     52         optional_constraints[i].m_name.utf8(),
     53         optional_constraints[i].m_value.utf8()));
     54   }
     55 }
     56 
     57 static int g_next_request_id  = 0;
     58 
     59 }  // namespace
     60 
     61 struct UserMediaClientImpl::MediaDevicesRequestInfo {
     62   MediaDevicesRequestInfo(const blink::WebMediaDevicesRequest& request,
     63                           int audio_input_request_id,
     64                           int video_input_request_id,
     65                           int audio_output_request_id)
     66       : media_devices_request(request),
     67         audio_input_request_id(audio_input_request_id),
     68         video_input_request_id(video_input_request_id),
     69         audio_output_request_id(audio_output_request_id),
     70         has_audio_input_returned(false),
     71         has_video_input_returned(false),
     72         has_audio_output_returned(false) {}
     73 
     74   MediaDevicesRequestInfo(
     75       const blink::WebMediaStreamTrackSourcesRequest& request,
     76       int audio_input_request_id,
     77       int video_input_request_id)
     78       : sources_request(request),
     79         audio_input_request_id(audio_input_request_id),
     80         video_input_request_id(video_input_request_id),
     81         audio_output_request_id(-1),
     82         has_audio_input_returned(false),
     83         has_video_input_returned(false),
     84         has_audio_output_returned(false) {}
     85 
     86   bool IsSourcesRequest() {
     87     // We can't check isNull() on |media_devices_request| and |sources_request|,
     88     // because in unit tests they will always be null.
     89     return audio_output_request_id == -1;
     90   }
     91 
     92   blink::WebMediaDevicesRequest media_devices_request;
     93   blink::WebMediaStreamTrackSourcesRequest sources_request;
     94   int audio_input_request_id;
     95   int video_input_request_id;
     96   int audio_output_request_id;
     97   bool has_audio_input_returned;
     98   bool has_video_input_returned;
     99   bool has_audio_output_returned;
    100   StreamDeviceInfoArray audio_input_devices;
    101   StreamDeviceInfoArray video_input_devices;
    102   StreamDeviceInfoArray audio_output_devices;
    103 };
    104 
    105 UserMediaClientImpl::UserMediaClientImpl(
    106     RenderFrame* render_frame,
    107     PeerConnectionDependencyFactory* dependency_factory,
    108     scoped_ptr<MediaStreamDispatcher> media_stream_dispatcher)
    109     : RenderFrameObserver(render_frame),
    110       dependency_factory_(dependency_factory),
    111       media_stream_dispatcher_(media_stream_dispatcher.Pass()),
    112       weak_factory_(this) {
    113   DCHECK(dependency_factory_);
    114   DCHECK(media_stream_dispatcher_.get());
    115 }
    116 
    117 UserMediaClientImpl::~UserMediaClientImpl() {
    118   // Force-close all outstanding user media requests and local sources here,
    119   // before the outstanding WeakPtrs are invalidated, to ensure a clean
    120   // shutdown.
    121   FrameWillClose();
    122 }
    123 
    124 void UserMediaClientImpl::requestUserMedia(
    125     const blink::WebUserMediaRequest& user_media_request) {
    126   // Save histogram data so we can see how much GetUserMedia is used.
    127   // The histogram counts the number of calls to the JS API
    128   // webGetUserMedia.
    129   UpdateWebRTCMethodCount(WEBKIT_GET_USER_MEDIA);
    130   DCHECK(CalledOnValidThread());
    131 
    132   if (RenderThreadImpl::current()) {
    133     RenderThreadImpl::current()->peer_connection_tracker()->TrackGetUserMedia(
    134         user_media_request);
    135   }
    136 
    137   int request_id = g_next_request_id++;
    138   StreamOptions options;
    139   GURL security_origin;
    140   bool enable_automatic_output_device_selection = false;
    141 
    142   // |user_media_request| can't be mocked. So in order to test at all we check
    143   // if it isNull.
    144   if (user_media_request.isNull()) {
    145     // We are in a test.
    146     options.audio_requested = true;
    147     options.video_requested = true;
    148   } else {
    149     if (user_media_request.audio()) {
    150       options.audio_requested = true;
    151       CopyStreamConstraints(user_media_request.audioConstraints(),
    152                             &options.mandatory_audio,
    153                             &options.optional_audio);
    154 
    155       // Check if this input device should be used to select a matching output
    156       // device for audio rendering.
    157       std::string enable;
    158       if (options.GetFirstAudioConstraintByName(
    159               kMediaStreamRenderToAssociatedSink, &enable, NULL) &&
    160           LowerCaseEqualsASCII(enable, "true")) {
    161         enable_automatic_output_device_selection = true;
    162       }
    163     }
    164     if (user_media_request.video()) {
    165       options.video_requested = true;
    166       CopyStreamConstraints(user_media_request.videoConstraints(),
    167                             &options.mandatory_video,
    168                             &options.optional_video);
    169     }
    170 
    171     security_origin = GURL(user_media_request.securityOrigin().toString());
    172     DCHECK(render_frame()->GetWebFrame() ==
    173                static_cast<blink::WebFrame*>(
    174                    user_media_request.ownerDocument().frame()));
    175   }
    176 
    177   DVLOG(1) << "UserMediaClientImpl::requestUserMedia(" << request_id << ", [ "
    178            << "audio=" << (options.audio_requested)
    179            << " select associated sink: "
    180            << enable_automatic_output_device_selection
    181            << ", video=" << (options.video_requested) << " ], "
    182            << security_origin.spec() << ")";
    183 
    184   std::string audio_device_id;
    185   bool mandatory_audio;
    186   options.GetFirstAudioConstraintByName(kMediaStreamSourceInfoId,
    187                                         &audio_device_id, &mandatory_audio);
    188   std::string video_device_id;
    189   bool mandatory_video;
    190   options.GetFirstVideoConstraintByName(kMediaStreamSourceInfoId,
    191                                         &video_device_id, &mandatory_video);
    192 
    193   WebRtcLogMessage(base::StringPrintf(
    194       "MSI::requestUserMedia. request_id=%d"
    195       ", audio source id=%s mandatory= %s "
    196       ", video source id=%s mandatory= %s",
    197       request_id,
    198       audio_device_id.c_str(),
    199       mandatory_audio ? "true":"false",
    200       video_device_id.c_str(),
    201       mandatory_video ? "true":"false"));
    202 
    203   user_media_requests_.push_back(
    204       new UserMediaRequestInfo(request_id, user_media_request,
    205                                enable_automatic_output_device_selection));
    206 
    207   media_stream_dispatcher_->GenerateStream(
    208       request_id,
    209       weak_factory_.GetWeakPtr(),
    210       options,
    211       security_origin);
    212 }
    213 
    214 void UserMediaClientImpl::cancelUserMediaRequest(
    215     const blink::WebUserMediaRequest& user_media_request) {
    216   DCHECK(CalledOnValidThread());
    217   UserMediaRequestInfo* request = FindUserMediaRequestInfo(user_media_request);
    218   if (request) {
    219     // We can't abort the stream generation process.
    220     // Instead, erase the request. Once the stream is generated we will stop the
    221     // stream if the request does not exist.
    222     LogUserMediaRequestWithNoResult(MEDIA_STREAM_REQUEST_EXPLICITLY_CANCELLED);
    223     DeleteUserMediaRequestInfo(request);
    224   }
    225 }
    226 
    227 void UserMediaClientImpl::requestMediaDevices(
    228     const blink::WebMediaDevicesRequest& media_devices_request) {
    229   UpdateWebRTCMethodCount(WEBKIT_GET_MEDIA_DEVICES);
    230   DCHECK(CalledOnValidThread());
    231 
    232   int audio_input_request_id = g_next_request_id++;
    233   int video_input_request_id = g_next_request_id++;
    234   int audio_output_request_id = g_next_request_id++;
    235 
    236   // |media_devices_request| can't be mocked, so in tests it will be empty (the
    237   // underlying pointer is null). In order to use this function in a test we
    238   // need to check if it isNull.
    239   GURL security_origin;
    240   if (!media_devices_request.isNull())
    241     security_origin = GURL(media_devices_request.securityOrigin().toString());
    242 
    243   DVLOG(1) << "UserMediaClientImpl::requestMediaDevices("
    244            << audio_input_request_id
    245            << ", " << video_input_request_id << ", " << audio_output_request_id
    246            << ", " << security_origin.spec() << ")";
    247 
    248   media_devices_requests_.push_back(new MediaDevicesRequestInfo(
    249       media_devices_request,
    250       audio_input_request_id,
    251       video_input_request_id,
    252       audio_output_request_id));
    253 
    254   media_stream_dispatcher_->EnumerateDevices(
    255       audio_input_request_id,
    256       weak_factory_.GetWeakPtr(),
    257       MEDIA_DEVICE_AUDIO_CAPTURE,
    258       security_origin);
    259 
    260   media_stream_dispatcher_->EnumerateDevices(
    261       video_input_request_id,
    262       weak_factory_.GetWeakPtr(),
    263       MEDIA_DEVICE_VIDEO_CAPTURE,
    264       security_origin);
    265 
    266   media_stream_dispatcher_->EnumerateDevices(
    267       audio_output_request_id,
    268       weak_factory_.GetWeakPtr(),
    269       MEDIA_DEVICE_AUDIO_OUTPUT,
    270       security_origin);
    271 }
    272 
    273 void UserMediaClientImpl::cancelMediaDevicesRequest(
    274     const blink::WebMediaDevicesRequest& media_devices_request) {
    275   DCHECK(CalledOnValidThread());
    276   MediaDevicesRequestInfo* request =
    277       FindMediaDevicesRequestInfo(media_devices_request);
    278   if (!request)
    279     return;
    280   CancelAndDeleteMediaDevicesRequest(request);
    281 }
    282 
    283 void UserMediaClientImpl::requestSources(
    284     const blink::WebMediaStreamTrackSourcesRequest& sources_request) {
    285   // We don't call UpdateWebRTCMethodCount() here to track the API count in UMA
    286   // stats. This is instead counted in MediaStreamTrack::getSources in blink.
    287   DCHECK(CalledOnValidThread());
    288 
    289   int audio_input_request_id = g_next_request_id++;
    290   int video_input_request_id = g_next_request_id++;
    291 
    292   // |sources_request| can't be mocked, so in tests it will be empty (the
    293   // underlying pointer is null). In order to use this function in a test we
    294   // need to check if it isNull.
    295   GURL security_origin;
    296   if (!sources_request.isNull())
    297     security_origin = GURL(sources_request.origin().utf8());
    298 
    299   DVLOG(1) << "UserMediaClientImpl::requestSources("
    300            << audio_input_request_id
    301            << ", " << video_input_request_id
    302            << ", " << security_origin.spec() << ")";
    303 
    304   media_devices_requests_.push_back(new MediaDevicesRequestInfo(
    305       sources_request,
    306       audio_input_request_id,
    307       video_input_request_id));
    308 
    309   media_stream_dispatcher_->EnumerateDevices(
    310       audio_input_request_id,
    311       weak_factory_.GetWeakPtr(),
    312       MEDIA_DEVICE_AUDIO_CAPTURE,
    313       security_origin);
    314 
    315   media_stream_dispatcher_->EnumerateDevices(
    316       video_input_request_id,
    317       weak_factory_.GetWeakPtr(),
    318       MEDIA_DEVICE_VIDEO_CAPTURE,
    319       security_origin);
    320 }
    321 
    322 // Callback from MediaStreamDispatcher.
    323 // The requested stream have been generated by the MediaStreamDispatcher.
    324 void UserMediaClientImpl::OnStreamGenerated(
    325     int request_id,
    326     const std::string& label,
    327     const StreamDeviceInfoArray& audio_array,
    328     const StreamDeviceInfoArray& video_array) {
    329   DCHECK(CalledOnValidThread());
    330   DVLOG(1) << "UserMediaClientImpl::OnStreamGenerated stream:" << label;
    331 
    332   UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(request_id);
    333   if (!request_info) {
    334     // This can happen if the request is canceled or the frame reloads while
    335     // MediaStreamDispatcher is processing the request.
    336     DVLOG(1) << "Request ID not found";
    337     OnStreamGeneratedForCancelledRequest(audio_array, video_array);
    338     return;
    339   }
    340   request_info->generated = true;
    341 
    342   // WebUserMediaRequest don't have an implementation in unit tests.
    343   // Therefore we need to check for isNull here and initialize the
    344   // constraints.
    345   blink::WebUserMediaRequest* request = &(request_info->request);
    346   blink::WebMediaConstraints audio_constraints;
    347   blink::WebMediaConstraints video_constraints;
    348   if (request->isNull()) {
    349     audio_constraints.initialize();
    350     video_constraints.initialize();
    351   } else {
    352     audio_constraints = request->audioConstraints();
    353     video_constraints = request->videoConstraints();
    354   }
    355 
    356   blink::WebVector<blink::WebMediaStreamTrack> audio_track_vector(
    357       audio_array.size());
    358   CreateAudioTracks(audio_array, audio_constraints, &audio_track_vector,
    359                     request_info);
    360 
    361   blink::WebVector<blink::WebMediaStreamTrack> video_track_vector(
    362       video_array.size());
    363   CreateVideoTracks(video_array, video_constraints, &video_track_vector,
    364                     request_info);
    365 
    366   blink::WebString webkit_id = base::UTF8ToUTF16(label);
    367   blink::WebMediaStream* web_stream = &(request_info->web_stream);
    368 
    369   web_stream->initialize(webkit_id, audio_track_vector,
    370                          video_track_vector);
    371   web_stream->setExtraData(
    372       new MediaStream(
    373           *web_stream));
    374 
    375   // Wait for the tracks to be started successfully or to fail.
    376   request_info->CallbackOnTracksStarted(
    377       base::Bind(&UserMediaClientImpl::OnCreateNativeTracksCompleted,
    378                  weak_factory_.GetWeakPtr()));
    379 }
    380 
    381 void UserMediaClientImpl::OnStreamGeneratedForCancelledRequest(
    382     const StreamDeviceInfoArray& audio_array,
    383     const StreamDeviceInfoArray& video_array) {
    384   // Only stop the device if the device is not used in another MediaStream.
    385   for (StreamDeviceInfoArray::const_iterator device_it = audio_array.begin();
    386        device_it != audio_array.end(); ++device_it) {
    387     if (!FindLocalSource(*device_it))
    388       media_stream_dispatcher_->StopStreamDevice(*device_it);
    389   }
    390 
    391   for (StreamDeviceInfoArray::const_iterator device_it = video_array.begin();
    392        device_it != video_array.end(); ++device_it) {
    393     if (!FindLocalSource(*device_it))
    394       media_stream_dispatcher_->StopStreamDevice(*device_it);
    395   }
    396 }
    397 
    398 void UserMediaClientImpl::FinalizeEnumerateDevices(
    399     MediaDevicesRequestInfo* request) {
    400   // All devices are ready for copying. We use a hashed audio output device id
    401   // as the group id for input and output audio devices. If an input device
    402   // doesn't have an associated output device, we use the input device's own id.
    403   // We don't support group id for video devices, that's left empty.
    404   blink::WebVector<blink::WebMediaDeviceInfo>
    405       devices(request->audio_input_devices.size() +
    406               request->video_input_devices.size() +
    407               request->audio_output_devices.size());
    408   for (size_t i = 0; i  < request->audio_input_devices.size(); ++i) {
    409     const MediaStreamDevice& device = request->audio_input_devices[i].device;
    410     DCHECK_EQ(device.type, MEDIA_DEVICE_AUDIO_CAPTURE);
    411     std::string group_id = base::UintToString(base::Hash(
    412         !device.matched_output_device_id.empty() ?
    413             device.matched_output_device_id :
    414             device.id));
    415     devices[i].initialize(
    416         blink::WebString::fromUTF8(device.id),
    417         blink::WebMediaDeviceInfo::MediaDeviceKindAudioInput,
    418         blink::WebString::fromUTF8(device.name),
    419         blink::WebString::fromUTF8(group_id));
    420   }
    421   size_t offset = request->audio_input_devices.size();
    422   for (size_t i = 0; i  < request->video_input_devices.size(); ++i) {
    423     const MediaStreamDevice& device = request->video_input_devices[i].device;
    424     DCHECK_EQ(device.type, MEDIA_DEVICE_VIDEO_CAPTURE);
    425     devices[offset + i].initialize(
    426         blink::WebString::fromUTF8(device.id),
    427         blink::WebMediaDeviceInfo::MediaDeviceKindVideoInput,
    428         blink::WebString::fromUTF8(device.name),
    429         blink::WebString());
    430   }
    431   offset += request->video_input_devices.size();
    432   for (size_t i = 0; i  < request->audio_output_devices.size(); ++i) {
    433     const MediaStreamDevice& device = request->audio_output_devices[i].device;
    434     DCHECK_EQ(device.type, MEDIA_DEVICE_AUDIO_OUTPUT);
    435     devices[offset + i].initialize(
    436         blink::WebString::fromUTF8(device.id),
    437         blink::WebMediaDeviceInfo::MediaDeviceKindAudioOutput,
    438         blink::WebString::fromUTF8(device.name),
    439         blink::WebString::fromUTF8(base::UintToString(base::Hash(device.id))));
    440   }
    441 
    442   EnumerateDevicesSucceded(&request->media_devices_request, devices);
    443 }
    444 
    445 void UserMediaClientImpl::FinalizeEnumerateSources(
    446     MediaDevicesRequestInfo* request) {
    447   blink::WebVector<blink::WebSourceInfo>
    448       sources(request->audio_input_devices.size() +
    449               request->video_input_devices.size());
    450   for (size_t i = 0; i  < request->audio_input_devices.size(); ++i) {
    451     const MediaStreamDevice& device = request->audio_input_devices[i].device;
    452     DCHECK_EQ(device.type, MEDIA_DEVICE_AUDIO_CAPTURE);
    453     std::string group_id = base::UintToString(base::Hash(
    454         !device.matched_output_device_id.empty() ?
    455             device.matched_output_device_id :
    456             device.id));
    457     sources[i].initialize(blink::WebString::fromUTF8(device.id),
    458                           blink::WebSourceInfo::SourceKindAudio,
    459                           blink::WebString::fromUTF8(device.name),
    460                           blink::WebSourceInfo::VideoFacingModeNone);
    461   }
    462   size_t offset = request->audio_input_devices.size();
    463   for (size_t i = 0; i  < request->video_input_devices.size(); ++i) {
    464     const MediaStreamDevice& device = request->video_input_devices[i].device;
    465     DCHECK_EQ(device.type, MEDIA_DEVICE_VIDEO_CAPTURE);
    466     blink::WebSourceInfo::VideoFacingMode video_facing;
    467     switch (device.video_facing) {
    468       case MEDIA_VIDEO_FACING_USER:
    469         video_facing = blink::WebSourceInfo::VideoFacingModeUser;
    470         break;
    471       case MEDIA_VIDEO_FACING_ENVIRONMENT:
    472         video_facing = blink::WebSourceInfo::VideoFacingModeEnvironment;
    473         break;
    474       default:
    475         video_facing = blink::WebSourceInfo::VideoFacingModeNone;
    476     }
    477     sources[offset + i].initialize(blink::WebString::fromUTF8(device.id),
    478                                    blink::WebSourceInfo::SourceKindVideo,
    479                                    blink::WebString::fromUTF8(device.name),
    480                                    video_facing);
    481   }
    482 
    483   EnumerateSourcesSucceded(&request->sources_request, sources);
    484 }
    485 
    486 // Callback from MediaStreamDispatcher.
    487 // The requested stream failed to be generated.
    488 void UserMediaClientImpl::OnStreamGenerationFailed(
    489     int request_id,
    490     MediaStreamRequestResult result) {
    491   DCHECK(CalledOnValidThread());
    492   DVLOG(1) << "UserMediaClientImpl::OnStreamGenerationFailed("
    493            << request_id << ")";
    494   UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(request_id);
    495   if (!request_info) {
    496     // This can happen if the request is canceled or the frame reloads while
    497     // MediaStreamDispatcher is processing the request.
    498     DVLOG(1) << "Request ID not found";
    499     return;
    500   }
    501 
    502   GetUserMediaRequestFailed(&request_info->request, result);
    503   DeleteUserMediaRequestInfo(request_info);
    504 }
    505 
    506 // Callback from MediaStreamDispatcher.
    507 // The browser process has stopped a device used by a MediaStream.
    508 void UserMediaClientImpl::OnDeviceStopped(
    509     const std::string& label,
    510     const StreamDeviceInfo& device_info) {
    511   DCHECK(CalledOnValidThread());
    512   DVLOG(1) << "UserMediaClientImpl::OnDeviceStopped("
    513            << "{device_id = " << device_info.device.id << "})";
    514 
    515   const blink::WebMediaStreamSource* source_ptr = FindLocalSource(device_info);
    516   if (!source_ptr) {
    517     // This happens if the same device is used in several guM requests or
    518     // if a user happen stop a track from JS at the same time
    519     // as the underlying media device is unplugged from the system.
    520     return;
    521   }
    522   // By creating |source| it is guaranteed that the blink::WebMediaStreamSource
    523   // object is valid during the cleanup.
    524   blink::WebMediaStreamSource source(*source_ptr);
    525   StopLocalSource(source, false);
    526 
    527   for (LocalStreamSources::iterator device_it = local_sources_.begin();
    528        device_it != local_sources_.end(); ++device_it) {
    529     if (device_it->id() == source.id()) {
    530       local_sources_.erase(device_it);
    531       break;
    532     }
    533   }
    534 }
    535 
    536 void UserMediaClientImpl::InitializeSourceObject(
    537     const StreamDeviceInfo& device,
    538     blink::WebMediaStreamSource::Type type,
    539     const blink::WebMediaConstraints& constraints,
    540     blink::WebMediaStreamSource* webkit_source) {
    541   const blink::WebMediaStreamSource* existing_source =
    542       FindLocalSource(device);
    543   if (existing_source) {
    544     *webkit_source = *existing_source;
    545     DVLOG(1) << "Source already exist. Reusing source with id "
    546              << webkit_source->id().utf8();
    547     return;
    548   }
    549 
    550   webkit_source->initialize(
    551       base::UTF8ToUTF16(device.device.id),
    552       type,
    553       base::UTF8ToUTF16(device.device.name));
    554 
    555   DVLOG(1) << "Initialize source object :"
    556            << "id = " << webkit_source->id().utf8()
    557            << ", name = " << webkit_source->name().utf8();
    558 
    559   if (type == blink::WebMediaStreamSource::TypeVideo) {
    560     webkit_source->setExtraData(
    561         CreateVideoSource(
    562             device,
    563             base::Bind(&UserMediaClientImpl::OnLocalSourceStopped,
    564                        weak_factory_.GetWeakPtr())));
    565   } else {
    566     DCHECK_EQ(blink::WebMediaStreamSource::TypeAudio, type);
    567     MediaStreamAudioSource* audio_source(
    568         new MediaStreamAudioSource(
    569             RenderFrameObserver::routing_id(),
    570             device,
    571             base::Bind(&UserMediaClientImpl::OnLocalSourceStopped,
    572                        weak_factory_.GetWeakPtr()),
    573             dependency_factory_));
    574     webkit_source->setExtraData(audio_source);
    575   }
    576   local_sources_.push_back(*webkit_source);
    577 }
    578 
    579 MediaStreamVideoSource* UserMediaClientImpl::CreateVideoSource(
    580     const StreamDeviceInfo& device,
    581     const MediaStreamSource::SourceStoppedCallback& stop_callback) {
    582   return new content::MediaStreamVideoCapturerSource(
    583       device,
    584       stop_callback,
    585       new VideoCapturerDelegate(device));
    586 }
    587 
    588 void UserMediaClientImpl::CreateVideoTracks(
    589     const StreamDeviceInfoArray& devices,
    590     const blink::WebMediaConstraints& constraints,
    591     blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks,
    592     UserMediaRequestInfo* request) {
    593   DCHECK_EQ(devices.size(), webkit_tracks->size());
    594 
    595   for (size_t i = 0; i < devices.size(); ++i) {
    596     blink::WebMediaStreamSource webkit_source;
    597     InitializeSourceObject(devices[i],
    598                            blink::WebMediaStreamSource::TypeVideo,
    599                            constraints,
    600                            &webkit_source);
    601     (*webkit_tracks)[i] =
    602         request->CreateAndStartVideoTrack(webkit_source, constraints);
    603   }
    604 }
    605 
    606 void UserMediaClientImpl::CreateAudioTracks(
    607     const StreamDeviceInfoArray& devices,
    608     const blink::WebMediaConstraints& constraints,
    609     blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks,
    610     UserMediaRequestInfo* request) {
    611   DCHECK_EQ(devices.size(), webkit_tracks->size());
    612 
    613   // Log the device names for this request.
    614   for (StreamDeviceInfoArray::const_iterator it = devices.begin();
    615        it != devices.end(); ++it) {
    616     WebRtcLogMessage(base::StringPrintf(
    617         "Generated media stream for request id %d contains audio device name"
    618         " \"%s\"",
    619         request->request_id,
    620         it->device.name.c_str()));
    621   }
    622 
    623   StreamDeviceInfoArray overridden_audio_array = devices;
    624   if (!request->enable_automatic_output_device_selection) {
    625     // If the GetUserMedia request did not explicitly set the constraint
    626     // kMediaStreamRenderToAssociatedSink, the output device parameters must
    627     // be removed.
    628     for (StreamDeviceInfoArray::iterator it = overridden_audio_array.begin();
    629          it != overridden_audio_array.end(); ++it) {
    630       it->device.matched_output_device_id = "";
    631       it->device.matched_output = MediaStreamDevice::AudioDeviceParameters();
    632     }
    633   }
    634 
    635   for (size_t i = 0; i < overridden_audio_array.size(); ++i) {
    636     blink::WebMediaStreamSource webkit_source;
    637     InitializeSourceObject(overridden_audio_array[i],
    638                            blink::WebMediaStreamSource::TypeAudio,
    639                            constraints,
    640                            &webkit_source);
    641     (*webkit_tracks)[i].initialize(webkit_source);
    642     request->StartAudioTrack((*webkit_tracks)[i], constraints);
    643   }
    644 }
    645 
    646 void UserMediaClientImpl::OnCreateNativeTracksCompleted(
    647     UserMediaRequestInfo* request,
    648     MediaStreamRequestResult result,
    649     const blink::WebString& result_name) {
    650   DVLOG(1) << "UserMediaClientImpl::OnCreateNativeTracksComplete("
    651            << "{request_id = " << request->request_id << "} "
    652            << "{result = " << result << "})";
    653   if (result == content::MEDIA_DEVICE_OK)
    654     GetUserMediaRequestSucceeded(request->web_stream, &request->request);
    655   else
    656     GetUserMediaRequestTrackStartedFailed(&request->request,
    657                                           result,
    658                                           result_name);
    659 
    660   DeleteUserMediaRequestInfo(request);
    661 }
    662 
    663 void UserMediaClientImpl::OnDevicesEnumerated(
    664     int request_id,
    665     const StreamDeviceInfoArray& device_array) {
    666   DVLOG(1) << "UserMediaClientImpl::OnDevicesEnumerated(" << request_id << ")";
    667 
    668   MediaDevicesRequestInfo* request = FindMediaDevicesRequestInfo(request_id);
    669   DCHECK(request);
    670 
    671   if (request_id == request->audio_input_request_id) {
    672     request->has_audio_input_returned = true;
    673     DCHECK(request->audio_input_devices.empty());
    674     request->audio_input_devices = device_array;
    675   } else if (request_id == request->video_input_request_id) {
    676     request->has_video_input_returned = true;
    677     DCHECK(request->video_input_devices.empty());
    678     request->video_input_devices = device_array;
    679   } else {
    680     DCHECK_EQ(request->audio_output_request_id, request_id);
    681     request->has_audio_output_returned = true;
    682     DCHECK(request->audio_output_devices.empty());
    683     request->audio_output_devices = device_array;
    684   }
    685 
    686   if (!request->has_audio_input_returned ||
    687       !request->has_video_input_returned ||
    688       (!request->IsSourcesRequest() && !request->has_audio_output_returned)) {
    689     // Wait for the rest of the devices to complete.
    690     return;
    691   }
    692 
    693   if (request->IsSourcesRequest())
    694     FinalizeEnumerateSources(request);
    695   else
    696     FinalizeEnumerateDevices(request);
    697 
    698   CancelAndDeleteMediaDevicesRequest(request);
    699 }
    700 
    701 void UserMediaClientImpl::OnDeviceOpened(
    702     int request_id,
    703     const std::string& label,
    704     const StreamDeviceInfo& video_device) {
    705   DVLOG(1) << "UserMediaClientImpl::OnDeviceOpened("
    706            << request_id << ", " << label << ")";
    707   NOTIMPLEMENTED();
    708 }
    709 
    710 void UserMediaClientImpl::OnDeviceOpenFailed(int request_id) {
    711   DVLOG(1) << "UserMediaClientImpl::VideoDeviceOpenFailed("
    712            << request_id << ")";
    713   NOTIMPLEMENTED();
    714 }
    715 
    716 void UserMediaClientImpl::GetUserMediaRequestSucceeded(
    717     const blink::WebMediaStream& stream,
    718     blink::WebUserMediaRequest* request_info) {
    719   DVLOG(1) << "UserMediaClientImpl::GetUserMediaRequestSucceeded";
    720   LogUserMediaRequestResult(MEDIA_DEVICE_OK);
    721   request_info->requestSucceeded(stream);
    722 }
    723 
    724 void UserMediaClientImpl::GetUserMediaRequestFailed(
    725     blink::WebUserMediaRequest* request_info,
    726     MediaStreamRequestResult result) {
    727   LogUserMediaRequestResult(result);
    728   switch (result) {
    729     case MEDIA_DEVICE_OK:
    730       NOTREACHED();
    731       break;
    732     case MEDIA_DEVICE_PERMISSION_DENIED:
    733       request_info->requestDenied();
    734       break;
    735     case MEDIA_DEVICE_PERMISSION_DISMISSED:
    736       request_info->requestFailedUASpecific("PermissionDismissedError");
    737       break;
    738     case MEDIA_DEVICE_INVALID_STATE:
    739       request_info->requestFailedUASpecific("InvalidStateError");
    740       break;
    741     case MEDIA_DEVICE_NO_HARDWARE:
    742       request_info->requestFailedUASpecific("DevicesNotFoundError");
    743       break;
    744     case MEDIA_DEVICE_INVALID_SECURITY_ORIGIN:
    745       request_info->requestFailedUASpecific("InvalidSecurityOriginError");
    746       break;
    747     case MEDIA_DEVICE_TAB_CAPTURE_FAILURE:
    748       request_info->requestFailedUASpecific("TabCaptureError");
    749       break;
    750     case MEDIA_DEVICE_SCREEN_CAPTURE_FAILURE:
    751       request_info->requestFailedUASpecific("ScreenCaptureError");
    752       break;
    753     case MEDIA_DEVICE_CAPTURE_FAILURE:
    754       request_info->requestFailedUASpecific("DeviceCaptureError");
    755       break;
    756     default:
    757       NOTREACHED();
    758       request_info->requestFailed();
    759       break;
    760   }
    761 }
    762 
    763 void UserMediaClientImpl::GetUserMediaRequestTrackStartedFailed(
    764     blink::WebUserMediaRequest* request_info,
    765     MediaStreamRequestResult result,
    766     const blink::WebString& result_name) {
    767   switch (result) {
    768     case MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED:
    769       request_info->requestFailedConstraint(result_name);
    770       break;
    771     case MEDIA_DEVICE_TRACK_START_FAILURE:
    772       request_info->requestFailedUASpecific("TrackStartError");
    773       break;
    774     default:
    775       NOTREACHED();
    776       request_info->requestFailed();
    777       break;
    778   }
    779 }
    780 
    781 void UserMediaClientImpl::EnumerateDevicesSucceded(
    782     blink::WebMediaDevicesRequest* request,
    783     blink::WebVector<blink::WebMediaDeviceInfo>& devices) {
    784   request->requestSucceeded(devices);
    785 }
    786 
    787 void UserMediaClientImpl::EnumerateSourcesSucceded(
    788     blink::WebMediaStreamTrackSourcesRequest* request,
    789     blink::WebVector<blink::WebSourceInfo>& sources) {
    790   request->requestSucceeded(sources);
    791 }
    792 
    793 const blink::WebMediaStreamSource* UserMediaClientImpl::FindLocalSource(
    794     const StreamDeviceInfo& device) const {
    795   for (LocalStreamSources::const_iterator it = local_sources_.begin();
    796        it != local_sources_.end(); ++it) {
    797     MediaStreamSource* const source =
    798         static_cast<MediaStreamSource*>(it->extraData());
    799     const StreamDeviceInfo& active_device = source->device_info();
    800     if (active_device.device.id == device.device.id &&
    801         active_device.device.type == device.device.type &&
    802         active_device.session_id == device.session_id) {
    803       return &(*it);
    804     }
    805   }
    806   return NULL;
    807 }
    808 
    809 UserMediaClientImpl::UserMediaRequestInfo*
    810 UserMediaClientImpl::FindUserMediaRequestInfo(int request_id) {
    811   UserMediaRequests::iterator it = user_media_requests_.begin();
    812   for (; it != user_media_requests_.end(); ++it) {
    813     if ((*it)->request_id == request_id)
    814       return (*it);
    815   }
    816   return NULL;
    817 }
    818 
    819 UserMediaClientImpl::UserMediaRequestInfo*
    820 UserMediaClientImpl::FindUserMediaRequestInfo(
    821     const blink::WebUserMediaRequest& request) {
    822   UserMediaRequests::iterator it = user_media_requests_.begin();
    823   for (; it != user_media_requests_.end(); ++it) {
    824     if ((*it)->request == request)
    825       return (*it);
    826   }
    827   return NULL;
    828 }
    829 
    830 void UserMediaClientImpl::DeleteUserMediaRequestInfo(
    831     UserMediaRequestInfo* request) {
    832   UserMediaRequests::iterator it = user_media_requests_.begin();
    833   for (; it != user_media_requests_.end(); ++it) {
    834     if ((*it) == request) {
    835       user_media_requests_.erase(it);
    836       return;
    837     }
    838   }
    839   NOTREACHED();
    840 }
    841 
    842 void UserMediaClientImpl::DeleteAllUserMediaRequests() {
    843   UserMediaRequests::iterator request_it = user_media_requests_.begin();
    844   while (request_it != user_media_requests_.end()) {
    845     DVLOG(1) << "UserMediaClientImpl@" << this
    846              << "::DeleteAllUserMediaRequests: "
    847              << "Cancel user media request " << (*request_it)->request_id;
    848     // If the request is not generated, it means that a request
    849     // has been sent to the MediaStreamDispatcher to generate a stream
    850     // but MediaStreamDispatcher has not yet responded and we need to cancel
    851     // the request.
    852     if (!(*request_it)->generated) {
    853       DCHECK(!(*request_it)->HasPendingSources());
    854       media_stream_dispatcher_->CancelGenerateStream(
    855           (*request_it)->request_id, weak_factory_.GetWeakPtr());
    856       LogUserMediaRequestWithNoResult(MEDIA_STREAM_REQUEST_NOT_GENERATED);
    857     } else {
    858       DCHECK((*request_it)->HasPendingSources());
    859       LogUserMediaRequestWithNoResult(
    860           MEDIA_STREAM_REQUEST_PENDING_MEDIA_TRACKS);
    861     }
    862     request_it = user_media_requests_.erase(request_it);
    863   }
    864 }
    865 
    866 UserMediaClientImpl::MediaDevicesRequestInfo*
    867 UserMediaClientImpl::FindMediaDevicesRequestInfo(
    868     int request_id) {
    869   MediaDevicesRequests::iterator it = media_devices_requests_.begin();
    870   for (; it != media_devices_requests_.end(); ++it) {
    871     if ((*it)->audio_input_request_id == request_id ||
    872         (*it)->video_input_request_id == request_id ||
    873         (*it)->audio_output_request_id == request_id) {
    874       return (*it);
    875     }
    876   }
    877   return NULL;
    878 }
    879 
    880 UserMediaClientImpl::MediaDevicesRequestInfo*
    881 UserMediaClientImpl::FindMediaDevicesRequestInfo(
    882     const blink::WebMediaDevicesRequest& request) {
    883   MediaDevicesRequests::iterator it = media_devices_requests_.begin();
    884   for (; it != media_devices_requests_.end(); ++it) {
    885     if ((*it)->media_devices_request == request)
    886       return (*it);
    887   }
    888   return NULL;
    889 }
    890 
    891 void UserMediaClientImpl::CancelAndDeleteMediaDevicesRequest(
    892     MediaDevicesRequestInfo* request) {
    893   MediaDevicesRequests::iterator it = media_devices_requests_.begin();
    894   for (; it != media_devices_requests_.end(); ++it) {
    895     if ((*it) == request) {
    896       // Cancel device enumeration.
    897       media_stream_dispatcher_->StopEnumerateDevices(
    898           request->audio_input_request_id, weak_factory_.GetWeakPtr());
    899       media_stream_dispatcher_->StopEnumerateDevices(
    900           request->video_input_request_id, weak_factory_.GetWeakPtr());
    901       media_stream_dispatcher_->StopEnumerateDevices(
    902           request->audio_output_request_id, weak_factory_.GetWeakPtr());
    903 
    904       media_devices_requests_.erase(it);
    905       return;
    906     }
    907   }
    908   NOTREACHED();
    909 }
    910 
    911 void UserMediaClientImpl::FrameWillClose() {
    912   // Cancel all outstanding UserMediaRequests.
    913   DeleteAllUserMediaRequests();
    914 
    915   // Loop through all current local sources and stop the sources.
    916   LocalStreamSources::iterator sources_it = local_sources_.begin();
    917   while (sources_it != local_sources_.end()) {
    918     StopLocalSource(*sources_it, true);
    919     sources_it = local_sources_.erase(sources_it);
    920   }
    921 }
    922 
    923 void UserMediaClientImpl::OnLocalSourceStopped(
    924     const blink::WebMediaStreamSource& source) {
    925   DCHECK(CalledOnValidThread());
    926   DVLOG(1) << "UserMediaClientImpl::OnLocalSourceStopped";
    927 
    928   bool device_found = false;
    929   for (LocalStreamSources::iterator device_it = local_sources_.begin();
    930        device_it != local_sources_.end(); ++device_it) {
    931     if (device_it->id()  == source.id()) {
    932       device_found = true;
    933       local_sources_.erase(device_it);
    934       break;
    935     }
    936   }
    937   CHECK(device_found);
    938 
    939   MediaStreamSource* source_impl =
    940       static_cast<MediaStreamSource*>(source.extraData());
    941   media_stream_dispatcher_->StopStreamDevice(source_impl->device_info());
    942 }
    943 
    944 void UserMediaClientImpl::StopLocalSource(
    945     const blink::WebMediaStreamSource& source,
    946     bool notify_dispatcher) {
    947   MediaStreamSource* source_impl =
    948       static_cast<MediaStreamSource*>(source.extraData());
    949   DVLOG(1) << "UserMediaClientImpl::StopLocalSource("
    950            << "{device_id = " << source_impl->device_info().device.id << "})";
    951 
    952   if (notify_dispatcher)
    953     media_stream_dispatcher_->StopStreamDevice(source_impl->device_info());
    954 
    955   source_impl->ResetSourceStoppedCallback();
    956   source_impl->StopSource();
    957 }
    958 
    959 UserMediaClientImpl::UserMediaRequestInfo::UserMediaRequestInfo(
    960     int request_id,
    961     const blink::WebUserMediaRequest& request,
    962     bool enable_automatic_output_device_selection)
    963     : request_id(request_id),
    964       generated(false),
    965       enable_automatic_output_device_selection(
    966           enable_automatic_output_device_selection),
    967       request(request),
    968       request_result_(MEDIA_DEVICE_OK),
    969       request_result_name_("") {
    970 }
    971 
    972 UserMediaClientImpl::UserMediaRequestInfo::~UserMediaRequestInfo() {
    973   DVLOG(1) << "~UserMediaRequestInfo";
    974 }
    975 
    976 void UserMediaClientImpl::UserMediaRequestInfo::StartAudioTrack(
    977     const blink::WebMediaStreamTrack& track,
    978     const blink::WebMediaConstraints& constraints) {
    979   DCHECK(track.source().type() == blink::WebMediaStreamSource::TypeAudio);
    980   MediaStreamAudioSource* native_source =
    981       static_cast <MediaStreamAudioSource*>(track.source().extraData());
    982   DCHECK(native_source);
    983 
    984   sources_.push_back(track.source());
    985   sources_waiting_for_callback_.push_back(native_source);
    986   native_source->AddTrack(
    987       track, constraints, base::Bind(
    988           &UserMediaClientImpl::UserMediaRequestInfo::OnTrackStarted,
    989           AsWeakPtr()));
    990 }
    991 
    992 blink::WebMediaStreamTrack
    993 UserMediaClientImpl::UserMediaRequestInfo::CreateAndStartVideoTrack(
    994     const blink::WebMediaStreamSource& source,
    995     const blink::WebMediaConstraints& constraints) {
    996   DCHECK(source.type() == blink::WebMediaStreamSource::TypeVideo);
    997   MediaStreamVideoSource* native_source =
    998       MediaStreamVideoSource::GetVideoSource(source);
    999   DCHECK(native_source);
   1000   sources_.push_back(source);
   1001   sources_waiting_for_callback_.push_back(native_source);
   1002   return MediaStreamVideoTrack::CreateVideoTrack(
   1003       native_source, constraints, base::Bind(
   1004           &UserMediaClientImpl::UserMediaRequestInfo::OnTrackStarted,
   1005           AsWeakPtr()),
   1006       true);
   1007 }
   1008 
   1009 void UserMediaClientImpl::UserMediaRequestInfo::CallbackOnTracksStarted(
   1010     const ResourcesReady& callback) {
   1011   DCHECK(ready_callback_.is_null());
   1012   ready_callback_ = callback;
   1013   CheckAllTracksStarted();
   1014 }
   1015 
   1016 void UserMediaClientImpl::UserMediaRequestInfo::OnTrackStarted(
   1017     MediaStreamSource* source,
   1018     MediaStreamRequestResult result,
   1019     const blink::WebString& result_name) {
   1020   DVLOG(1) << "OnTrackStarted result " << result;
   1021   std::vector<MediaStreamSource*>::iterator it =
   1022       std::find(sources_waiting_for_callback_.begin(),
   1023                 sources_waiting_for_callback_.end(),
   1024                 source);
   1025   DCHECK(it != sources_waiting_for_callback_.end());
   1026   sources_waiting_for_callback_.erase(it);
   1027   // All tracks must be started successfully. Otherwise the request is a
   1028   // failure.
   1029   if (result != MEDIA_DEVICE_OK) {
   1030     request_result_ = result;
   1031     request_result_name_ = result_name;
   1032   }
   1033 
   1034   CheckAllTracksStarted();
   1035 }
   1036 
   1037 void UserMediaClientImpl::UserMediaRequestInfo::CheckAllTracksStarted() {
   1038   if (!ready_callback_.is_null() && sources_waiting_for_callback_.empty()) {
   1039     ready_callback_.Run(this, request_result_, request_result_name_);
   1040   }
   1041 }
   1042 
   1043 bool UserMediaClientImpl::UserMediaRequestInfo::IsSourceUsed(
   1044     const blink::WebMediaStreamSource& source) const {
   1045   for (std::vector<blink::WebMediaStreamSource>::const_iterator source_it =
   1046            sources_.begin();
   1047        source_it != sources_.end(); ++source_it) {
   1048     if (source_it->id() == source.id())
   1049       return true;
   1050   }
   1051   return false;
   1052 }
   1053 
   1054 void UserMediaClientImpl::UserMediaRequestInfo::RemoveSource(
   1055     const blink::WebMediaStreamSource& source) {
   1056   for (std::vector<blink::WebMediaStreamSource>::iterator it =
   1057            sources_.begin();
   1058        it != sources_.end(); ++it) {
   1059     if (source.id() == it->id()) {
   1060       sources_.erase(it);
   1061       return;
   1062     }
   1063   }
   1064 }
   1065 
   1066 bool UserMediaClientImpl::UserMediaRequestInfo::HasPendingSources() const {
   1067   return !sources_waiting_for_callback_.empty();
   1068 }
   1069 
   1070 }  // namespace content
   1071