[Cross-Site Isolation] Migrate entire MediaStream verticals to be per-RenderFrame.

content/renderer/media/media_stream_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/media_stream_impl.h"
 
 #include <utility>
 
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "content/public/renderer/render_frame.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_audio_source.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/media_stream_video_capturer_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/peer_connection_tracker.h"
 #include "content/renderer/media/webrtc/webrtc_video_capturer_adapter.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_logging.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
@@ skipping 50 matching lines @@
   int audio_output_request_id;
   bool has_audio_input_returned;
   bool has_video_input_returned;
   bool has_audio_output_returned;
   StreamDeviceInfoArray audio_input_devices;
   StreamDeviceInfoArray video_input_devices;
   StreamDeviceInfoArray audio_output_devices;
 };
 
 MediaStreamImpl::MediaStreamImpl(
-    RenderView* render_view,
-    MediaStreamDispatcher* media_stream_dispatcher,
-    PeerConnectionDependencyFactory* dependency_factory)
-    : RenderViewObserver(render_view),
+    RenderFrame* render_frame,
+    PeerConnectionDependencyFactory* dependency_factory,
+    scoped_ptr<MediaStreamDispatcher> media_stream_dispatcher)
+    : RenderFrameObserver(render_frame),
       dependency_factory_(dependency_factory),
-      media_stream_dispatcher_(media_stream_dispatcher) {
+      media_stream_dispatcher_(media_stream_dispatcher.Pass()),
+      weak_factory_(this) {
+  DCHECK(dependency_factory_);
+  DCHECK(media_stream_dispatcher_.get());
 }
 
 MediaStreamImpl::~MediaStreamImpl() {
+  // Force-close all outstanding user media requests and local sources here,
+  // before the outstanding WeakPtrs are invalidated, to ensure a clean
+  // shutdown.
+  FrameWillClose();
 }
 
 void MediaStreamImpl::requestUserMedia(
     const blink::WebUserMediaRequest& user_media_request) {
   // Save histogram data so we can see how much GetUserMedia is used.
   // The histogram counts the number of calls to the JS API
   // webGetUserMedia.
   UpdateWebRTCMethodCount(WEBKIT_GET_USER_MEDIA);
   DCHECK(CalledOnValidThread());
 
   if (RenderThreadImpl::current()) {
     RenderThreadImpl::current()->peer_connection_tracker()->TrackGetUserMedia(
         user_media_request);
   }
 
   int request_id = g_next_request_id++;
   StreamOptions options;
-  blink::WebLocalFrame* frame = NULL;
   GURL security_origin;
   bool enable_automatic_output_device_selection = false;
 
   // |user_media_request| can't be mocked. So in order to test at all we check
   // if it isNull.
   if (user_media_request.isNull()) {
     // We are in a test.
     options.audio_requested = true;
     options.video_requested = true;
   } else {
@@ skipping 13 matching lines @@
       }
     }
     if (user_media_request.video()) {
       options.video_requested = true;
       CopyStreamConstraints(user_media_request.videoConstraints(),
                             &options.mandatory_video,
                             &options.optional_video);
     }
 
     security_origin = GURL(user_media_request.securityOrigin().toString());
-    // Get the WebFrame that requested a MediaStream.
-    // The frame is needed to tell the MediaStreamDispatcher when a stream goes
-    // out of scope.
-    frame = user_media_request.ownerDocument().frame();
-    DCHECK(frame);
+    DCHECK(render_frame()->GetWebFrame() ==
+               static_cast<blink::WebFrame*>(
+                   user_media_request.ownerDocument().frame()));
   }
 
   DVLOG(1) << "MediaStreamImpl::requestUserMedia(" << request_id << ", [ "
            << "audio=" << (options.audio_requested)
            << " select associated sink: "
            << enable_automatic_output_device_selection
            << ", video=" << (options.video_requested) << " ], "
            << security_origin.spec() << ")";
 
   std::string audio_device_id;
   bool mandatory_audio;
   options.GetFirstAudioConstraintByName(kMediaStreamSourceInfoId,
                                         &audio_device_id, &mandatory_audio);
   std::string video_device_id;
   bool mandatory_video;
   options.GetFirstVideoConstraintByName(kMediaStreamSourceInfoId,
                                         &video_device_id, &mandatory_video);
 
   WebRtcLogMessage(base::StringPrintf(
       "MSI::requestUserMedia. request_id=%d"
       ", audio source id=%s mandatory= %s "
       ", video source id=%s mandatory= %s",
       request_id,
       audio_device_id.c_str(),
       mandatory_audio ? "true":"false",
       video_device_id.c_str(),
       mandatory_video ? "true":"false"));
 
   user_media_requests_.push_back(
-      new UserMediaRequestInfo(request_id, frame, user_media_request,
-          enable_automatic_output_device_selection));
+      new UserMediaRequestInfo(request_id, user_media_request,
+                               enable_automatic_output_device_selection));
 
   media_stream_dispatcher_->GenerateStream(
       request_id,
-      AsWeakPtr(),
+      weak_factory_.GetWeakPtr(),
       options,
       security_origin);
 }
 
 void MediaStreamImpl::cancelUserMediaRequest(
     const blink::WebUserMediaRequest& user_media_request) {
   DCHECK(CalledOnValidThread());
   UserMediaRequestInfo* request = FindUserMediaRequestInfo(user_media_request);
   if (request) {
     // We can't abort the stream generation process.
@@ skipping 24 matching lines @@
            << ", " << security_origin.spec() << ")";
 
   media_devices_requests_.push_back(new MediaDevicesRequestInfo(
       media_devices_request,
       audio_input_request_id,
       video_input_request_id,
       audio_output_request_id));
 
   media_stream_dispatcher_->EnumerateDevices(
       audio_input_request_id,
-      AsWeakPtr(),
+      weak_factory_.GetWeakPtr(),
       MEDIA_DEVICE_AUDIO_CAPTURE,
       security_origin,
       true);
 
   media_stream_dispatcher_->EnumerateDevices(
       video_input_request_id,
-      AsWeakPtr(),
+      weak_factory_.GetWeakPtr(),
       MEDIA_DEVICE_VIDEO_CAPTURE,
       security_origin,
       true);
 
   media_stream_dispatcher_->EnumerateDevices(
       audio_output_request_id,
-      AsWeakPtr(),
+      weak_factory_.GetWeakPtr(),
       MEDIA_DEVICE_AUDIO_OUTPUT,
       security_origin,
       true);
 }
 
 void MediaStreamImpl::cancelMediaDevicesRequest(
     const blink::WebMediaDevicesRequest& media_devices_request) {
   DCHECK(CalledOnValidThread());
   MediaDevicesRequestInfo* request =
       FindMediaDevicesRequestInfo(media_devices_request);
   if (!request)
     return;
-
-  // Cancel device enumeration.
-  media_stream_dispatcher_->StopEnumerateDevices(
-      request->audio_input_request_id,
-      AsWeakPtr());
-  media_stream_dispatcher_->StopEnumerateDevices(
-      request->video_input_request_id,
-      AsWeakPtr());
-  media_stream_dispatcher_->StopEnumerateDevices(
-      request->audio_output_request_id,
-      AsWeakPtr());
-  DeleteMediaDevicesRequestInfo(request);
+  CancelAndDeleteMediaDevicesRequest(request);
 }
 
 // Callback from MediaStreamDispatcher.
 // The requested stream have been generated by the MediaStreamDispatcher.
 void MediaStreamImpl::OnStreamGenerated(
     int request_id,
     const std::string& label,
     const StreamDeviceInfoArray& audio_array,
     const StreamDeviceInfoArray& video_array) {
   DCHECK(CalledOnValidThread());
@@ skipping 49 matching lines @@
   blink::WebMediaStream* web_stream = &(request_info->web_stream);
 
   web_stream->initialize(webkit_id, audio_track_vector,
                          video_track_vector);
   web_stream->setExtraData(
       new MediaStream(
           *web_stream));
 
   // Wait for the tracks to be started successfully or to fail.
   request_info->CallbackOnTracksStarted(
-      base::Bind(&MediaStreamImpl::OnCreateNativeTracksCompleted, AsWeakPtr()));
+      base::Bind(&MediaStreamImpl::OnCreateNativeTracksCompleted,
+                 weak_factory_.GetWeakPtr()));
 }
 
 // Callback from MediaStreamDispatcher.
 // The requested stream failed to be generated.
 void MediaStreamImpl::OnStreamGenerationFailed(
     int request_id,
     content::MediaStreamRequestResult result) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "MediaStreamImpl::OnStreamGenerationFailed("
            << request_id << ")";
@@ skipping 25 matching lines @@
     // as the underlying media device is unplugged from the system.
     return;
   }
   // By creating |source| it is guaranteed that the blink::WebMediaStreamSource
   // object is valid during the cleanup.
   blink::WebMediaStreamSource source(*source_ptr);
   StopLocalSource(source, false);
 
   for (LocalStreamSources::iterator device_it = local_sources_.begin();
        device_it != local_sources_.end(); ++device_it) {
-    if (device_it->source.id() == source.id()) {
+    if (device_it->id() == source.id()) {
       local_sources_.erase(device_it);
       break;
     }
   }
 }
 
 void MediaStreamImpl::InitializeSourceObject(
     const StreamDeviceInfo& device,
     blink::WebMediaStreamSource::Type type,
     const blink::WebMediaConstraints& constraints,
-    blink::WebFrame* frame,
     blink::WebMediaStreamSource* webkit_source) {
   const blink::WebMediaStreamSource* existing_source =
       FindLocalSource(device);
   if (existing_source) {
     *webkit_source = *existing_source;
     DVLOG(1) << "Source already exist. Reusing source with id "
              << webkit_source->id().utf8();
     return;
   }
 
   webkit_source->initialize(
       base::UTF8ToUTF16(device.device.id),
       type,
       base::UTF8ToUTF16(device.device.name));
 
   DVLOG(1) << "Initialize source object :"
            << "id = " << webkit_source->id().utf8()
            << ", name = " << webkit_source->name().utf8();
 
   if (type == blink::WebMediaStreamSource::TypeVideo) {
     webkit_source->setExtraData(
         CreateVideoSource(
             device,
-            base::Bind(&MediaStreamImpl::OnLocalSourceStopped, AsWeakPtr())));
+            base::Bind(&MediaStreamImpl::OnLocalSourceStopped,
+                       weak_factory_.GetWeakPtr())));
   } else {
     DCHECK_EQ(blink::WebMediaStreamSource::TypeAudio, type);
     MediaStreamAudioSource* audio_source(
         new MediaStreamAudioSource(
-            RenderViewObserver::routing_id(),
+            RenderFrameObserver::routing_id(),
             device,
-            base::Bind(&MediaStreamImpl::OnLocalSourceStopped, AsWeakPtr()),
+            base::Bind(&MediaStreamImpl::OnLocalSourceStopped,
+                       weak_factory_.GetWeakPtr()),
             dependency_factory_));
     webkit_source->setExtraData(audio_source);
   }
-  local_sources_.push_back(LocalStreamSource(frame, *webkit_source));
+  local_sources_.push_back(*webkit_source);
 }
 
 MediaStreamVideoSource* MediaStreamImpl::CreateVideoSource(
     const StreamDeviceInfo& device,
     const MediaStreamSource::SourceStoppedCallback& stop_callback) {
   return new content::MediaStreamVideoCapturerSource(
       device,
       stop_callback,
       new VideoCapturerDelegate(device));
 }
 
 void MediaStreamImpl::CreateVideoTracks(
     const StreamDeviceInfoArray& devices,
     const blink::WebMediaConstraints& constraints,
     blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks,
     UserMediaRequestInfo* request) {
   DCHECK_EQ(devices.size(), webkit_tracks->size());
 
   for (size_t i = 0; i < devices.size(); ++i) {
     blink::WebMediaStreamSource webkit_source;
     InitializeSourceObject(devices[i],
                            blink::WebMediaStreamSource::TypeVideo,
                            constraints,
-                           request->frame,
                            &webkit_source);
     (*webkit_tracks)[i] =
         request->CreateAndStartVideoTrack(webkit_source, constraints);
   }
 }
 
 void MediaStreamImpl::CreateAudioTracks(
     const StreamDeviceInfoArray& devices,
     const blink::WebMediaConstraints& constraints,
     blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks,
@@ skipping 20 matching lines @@
       it->device.matched_output_device_id = "";
       it->device.matched_output = MediaStreamDevice::AudioDeviceParameters();
     }
   }
 
   for (size_t i = 0; i < overridden_audio_array.size(); ++i) {
     blink::WebMediaStreamSource webkit_source;
     InitializeSourceObject(overridden_audio_array[i],
                            blink::WebMediaStreamSource::TypeAudio,
                            constraints,
-                           request->frame,
                            &webkit_source);
     (*webkit_tracks)[i].initialize(webkit_source);
     request->StartAudioTrack((*webkit_tracks)[i], constraints);
   }
 }
 
 void MediaStreamImpl::OnCreateNativeTracksCompleted(
     UserMediaRequestInfo* request,
     content::MediaStreamRequestResult result) {
   DVLOG(1) << "MediaStreamImpl::OnCreateNativeTracksComplete("
@@ skipping 73 matching lines @@
     const MediaStreamDevice& device = request->audio_output_devices[i].device;
     DCHECK_EQ(device.type, MEDIA_DEVICE_AUDIO_OUTPUT);
     devices[offset + i].initialize(
         blink::WebString::fromUTF8(device.id),
         blink::WebMediaDeviceInfo::MediaDeviceKindAudioOutput,
         blink::WebString::fromUTF8(device.name),
         blink::WebString::fromUTF8(base::UintToString(base::Hash(device.id))));
   }
 
   EnumerateDevicesSucceded(&request->request, devices);
-
-  // Cancel device enumeration.
-  media_stream_dispatcher_->StopEnumerateDevices(
-      request->audio_input_request_id,
-      AsWeakPtr());
-  media_stream_dispatcher_->StopEnumerateDevices(
-      request->video_input_request_id,
-      AsWeakPtr());
-  media_stream_dispatcher_->StopEnumerateDevices(
-      request->audio_output_request_id,
-      AsWeakPtr());
-
-  DeleteMediaDevicesRequestInfo(request);
+  CancelAndDeleteMediaDevicesRequest(request);
 }
 
 void MediaStreamImpl::OnDeviceOpened(
     int request_id,
     const std::string& label,
     const StreamDeviceInfo& video_device) {
   DVLOG(1) << "MediaStreamImpl::OnDeviceOpened("
            << request_id << ", " << label << ")";
   NOTIMPLEMENTED();
 }
@@ skipping 54 matching lines @@
 void MediaStreamImpl::EnumerateDevicesSucceded(
     blink::WebMediaDevicesRequest* request,
     blink::WebVector<blink::WebMediaDeviceInfo>& devices) {
   request->requestSucceeded(devices);
 }
 
 const blink::WebMediaStreamSource* MediaStreamImpl::FindLocalSource(
     const StreamDeviceInfo& device) const {
   for (LocalStreamSources::const_iterator it = local_sources_.begin();
        it != local_sources_.end(); ++it) {
-    MediaStreamSource* source =
-        static_cast<MediaStreamSource*>(it->source.extraData());
+    MediaStreamSource* const source =
+        static_cast<MediaStreamSource*>(it->extraData());
     const StreamDeviceInfo& active_device = source->device_info();
     if (active_device.device.id == device.device.id &&
         active_device.device.type == device.device.type &&
         active_device.session_id == device.session_id) {
-      return &it->source;
+      return &(*it);
     }
   }
   return NULL;
 }
 
 MediaStreamImpl::UserMediaRequestInfo*
 MediaStreamImpl::FindUserMediaRequestInfo(int request_id) {
   UserMediaRequests::iterator it = user_media_requests_.begin();
   for (; it != user_media_requests_.end(); ++it) {
     if ((*it)->request_id == request_id)
@@ skipping 43 matching lines @@
 MediaStreamImpl::FindMediaDevicesRequestInfo(
     const blink::WebMediaDevicesRequest& request) {
   MediaDevicesRequests::iterator it = media_devices_requests_.begin();
   for (; it != media_devices_requests_.end(); ++it) {
     if ((*it)->request == request)
       return (*it);
   }
   return NULL;
 }
 
-void MediaStreamImpl::DeleteMediaDevicesRequestInfo(
+void MediaStreamImpl::CancelAndDeleteMediaDevicesRequest(
     MediaDevicesRequestInfo* request) {
   MediaDevicesRequests::iterator it = media_devices_requests_.begin();
   for (; it != media_devices_requests_.end(); ++it) {
     if ((*it) == request) {
+      // Cancel device enumeration.
+      media_stream_dispatcher_->StopEnumerateDevices(
+          request->audio_input_request_id, weak_factory_.GetWeakPtr());
+      media_stream_dispatcher_->StopEnumerateDevices(
+          request->video_input_request_id, weak_factory_.GetWeakPtr());
+      media_stream_dispatcher_->StopEnumerateDevices(
+          request->audio_output_request_id, weak_factory_.GetWeakPtr());
+
       media_devices_requests_.erase(it);
       return;
     }
   }
   NOTREACHED();
 }
 
-void MediaStreamImpl::FrameDetached(blink::WebFrame* frame) {
-  // Do same thing as FrameWillClose.
-  FrameWillClose(frame);
-}
-
-void MediaStreamImpl::FrameWillClose(blink::WebFrame* frame) {
-  // Loop through all UserMediaRequests and find the requests that belong to the
-  // frame that is being closed.
+void MediaStreamImpl::FrameWillClose() {
+  // Cancel all outstanding UserMediaRequests.
   UserMediaRequests::iterator request_it = user_media_requests_.begin();
   while (request_it != user_media_requests_.end()) {
-    if ((*request_it)->frame == frame) {
-      DVLOG(1) << "MediaStreamImpl::FrameWillClose: "
-               << "Cancel user media request " << (*request_it)->request_id;
-      // If the request is not generated, it means that a request
-      // has been sent to the MediaStreamDispatcher to generate a stream
-      // but MediaStreamDispatcher has not yet responded and we need to cancel
-      // the request.
-      if (!(*request_it)->generated) {
-        media_stream_dispatcher_->CancelGenerateStream(
-            (*request_it)->request_id, AsWeakPtr());
-      }
-      request_it = user_media_requests_.erase(request_it);
-    } else {
-      ++request_it;
+    DVLOG(1) << "MediaStreamImpl@" << this << "::FrameWillClose: "
+             << "Cancel user media request " << (*request_it)->request_id;
+    // If the request is not generated, it means that a request
+    // has been sent to the MediaStreamDispatcher to generate a stream
+    // but MediaStreamDispatcher has not yet responded and we need to cancel
+    // the request.
+    if (!(*request_it)->generated) {
+      media_stream_dispatcher_->CancelGenerateStream(
+          (*request_it)->request_id, weak_factory_.GetWeakPtr());
     }
+    request_it = user_media_requests_.erase(request_it);
   }
 
-  // Loop through all current local sources and stop the sources that were
-  // created by the frame that will be closed.
+  // Loop through all current local sources and stop the sources.
   LocalStreamSources::iterator sources_it = local_sources_.begin();
   while (sources_it != local_sources_.end()) {
-    if (sources_it->frame == frame) {
-      StopLocalSource(sources_it->source, true);
-      sources_it = local_sources_.erase(sources_it);
-    } else {
-      ++sources_it;
-    }
+    StopLocalSource(*sources_it, true);
+    sources_it = local_sources_.erase(sources_it);
   }
 }
 
 void MediaStreamImpl::OnLocalSourceStopped(
     const blink::WebMediaStreamSource& source) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "MediaStreamImpl::OnLocalSourceStopped";
 
   bool device_found = false;
   for (LocalStreamSources::iterator device_it = local_sources_.begin();
        device_it != local_sources_.end(); ++device_it) {
-    if (device_it->source.id()  == source.id()) {
+    if (device_it->id()  == source.id()) {
       device_found = true;
       local_sources_.erase(device_it);
       break;
     }
   }
   CHECK(device_found);
 
   MediaStreamSource* source_impl =
-      static_cast<MediaStreamSource*> (source.extraData());
+      static_cast<MediaStreamSource*>(source.extraData());
   media_stream_dispatcher_->StopStreamDevice(source_impl->device_info());
 }
 
 void MediaStreamImpl::StopLocalSource(
     const blink::WebMediaStreamSource& source,
     bool notify_dispatcher) {
   MediaStreamSource* source_impl =
-      static_cast<MediaStreamSource*> (source.extraData());
+      static_cast<MediaStreamSource*>(source.extraData());
   DVLOG(1) << "MediaStreamImpl::StopLocalSource("
            << "{device_id = " << source_impl->device_info().device.id << "})";
 
   if (notify_dispatcher)
     media_stream_dispatcher_->StopStreamDevice(source_impl->device_info());
 
   source_impl->ResetSourceStoppedCallback();
   source_impl->StopSource();
 }
 
 MediaStreamImpl::UserMediaRequestInfo::UserMediaRequestInfo(
     int request_id,
-    blink::WebFrame* frame,
     const blink::WebUserMediaRequest& request,
     bool enable_automatic_output_device_selection)
     : request_id(request_id),
       generated(false),
       enable_automatic_output_device_selection(
           enable_automatic_output_device_selection),
-      frame(frame),
       request(request),
       request_failed_(false) {
 }
 
 MediaStreamImpl::UserMediaRequestInfo::~UserMediaRequestInfo() {
   DVLOG(1) << "~UserMediaRequestInfo";
 }
 
 void MediaStreamImpl::UserMediaRequestInfo::StartAudioTrack(
     const blink::WebMediaStreamTrack& track,
@@ skipping 76 matching lines @@
            sources_.begin();
        it != sources_.end(); ++it) {
     if (source.id() == it->id()) {
       sources_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace content