Refactor MediaStreamImpl and PeerConnection glue implementation after WebKit changes.

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/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "base/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
 #include "content/renderer/media/capture_video_decoder.h"
+#include "content/renderer/media/media_stream_extra_data.h"
 #include "content/renderer/media/media_stream_dependency_factory.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/peer_connection_handler.h"
 #include "content/renderer/media/peer_connection_handler_jsep.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/media/video_capture_module_impl.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/p2p/ipc_network_manager.h"
 #include "content/renderer/p2p/ipc_socket_factory.h"
 #include "content/renderer/p2p/socket_dispatcher.h"
@@ skipping 23 matching lines @@
 
 // Helper method used to collect information about the number of times
 // different WebRTC API:s are called from JavaScript.
 // The histogram can be viewed at chrome://histograms/WebRTC.webkitApiCount.
 static void UpdateWebRTCMethodCount(JavaScriptAPIName api_name) {
   UMA_HISTOGRAM_ENUMERATION("WebRTC.webkitApiCount", api_name, kInvalidName);
 }
 
 static int g_next_request_id  = 0;
 
-// The MediaStreamMananger label for a stream is globally unique. The track
-// session id is globally unique for the set of audio tracks and video tracks
-// respectively. An audio track and a video track can have the same session id
-// (without being related). Hence we create a unique track label from the stream
-// label, track type and track session id:
-// <MediaStreamManager-label>#{audio,video}-<session-ID>.
-static std::string CreateTrackLabel(
-    const std::string& manager_label,
-    int session_id,
-    bool is_video) {
-  std::string track_label = manager_label;
-  if (is_video) {
-    track_label += "#video-";
-  } else {
-    track_label += "#audio-";
-  }
-  track_label += session_id;
-  return track_label;
-}
-
-// Extracting the MediaStreamManager stream label will only work for track
-// labels created by CreateTrackLabel. If is wasn't, the contents of the
-// returned string is undefined.
-static std::string ExtractManagerStreamLabel(
-    const std::string& track_label) {
-  std::string manager_label = track_label;
-  size_t pos = manager_label.rfind("#");
-  // If # isn't found, the string is left intact.
-  manager_label = manager_label.substr(0, pos);
-  return manager_label;
-}
-
 static void CreateWebKitSourceVector(
     const std::string& label,
     const media_stream::StreamDeviceInfoArray& devices,
     WebKit::WebMediaStreamSource::Type type,
     WebKit::WebVector<WebKit::WebMediaStreamSource>& webkit_sources) {
   ASSERT(devices.size() == webkit_sources.size());
-
   for (size_t i = 0; i < devices.size(); ++i) {
-    std::string track_label = CreateTrackLabel(
-        label, devices[i].session_id,
-        type == WebKit::WebMediaStreamSource::TypeVideo);
+    std::string source_id = label + base::UintToString(
+        static_cast<unsigned int>(i));
     webkit_sources[i].initialize(
-          UTF8ToUTF16(track_label),
+          UTF8ToUTF16(source_id),
           type,
           UTF8ToUTF16(devices[i].name));
   }
 }
 
 MediaStreamImpl::MediaStreamImpl(
     content::RenderView* render_view,
     MediaStreamDispatcher* media_stream_dispatcher,
     content::P2PSocketDispatcher* p2p_socket_dispatcher,
     VideoCaptureImplManager* vc_manager,
     MediaStreamDependencyFactory* dependency_factory)
     : content::RenderViewObserver(render_view),
       dependency_factory_(dependency_factory),
       media_stream_dispatcher_(media_stream_dispatcher),
       p2p_socket_dispatcher_(p2p_socket_dispatcher),
       network_manager_(NULL),
       vc_manager_(vc_manager),
       signaling_thread_(NULL),
       worker_thread_(NULL),
       chrome_worker_thread_("Chrome_libJingle_WorkerThread") {
 }
 
 MediaStreamImpl::~MediaStreamImpl() {
-  DCHECK(peer_connection_handlers_.empty());
   DCHECK(local_media_streams_.empty());
   if (dependency_factory_.get())
     dependency_factory_->ReleasePeerConnectionFactory();
   if (network_manager_) {
     // The network manager needs to free its resources on the thread they were
     // created, which is the worked thread.
     if (chrome_worker_thread_.IsRunning()) {
       chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
           &MediaStreamImpl::DeleteIpcNetworkManager,
           base::Unretained(this)));
@@ skipping 12 matching lines @@
   // Save histogram data so we can see how much PeerConnetion is used.
   // The histogram counts the number of calls to the JS API
   // webKitDeprecatedPeerConnection.
   UpdateWebRTCMethodCount(kWebkitDeprecatedPeerConnection);
   DCHECK(CalledOnValidThread());
   if (!EnsurePeerConnectionFactory())
     return NULL;
 
   PeerConnectionHandler* pc_handler = new PeerConnectionHandler(
       client,
-      this,
       dependency_factory_.get());
-  peer_connection_handlers_.push_back(pc_handler);
-
   return pc_handler;
 }
 
 WebKit::WebPeerConnection00Handler*
 MediaStreamImpl::CreatePeerConnectionHandlerJsep(
     WebKit::WebPeerConnection00HandlerClient* client) {
   // Save histogram data so we can see how much PeerConnetion is used.
   // The histogram counts the number of calls to the JS API
   // webKitPeerConnection00.
   UpdateWebRTCMethodCount(kWebkitPeerConnection);
   DCHECK(CalledOnValidThread());
   if (!EnsurePeerConnectionFactory())
     return NULL;
 
   PeerConnectionHandlerJsep* pc_handler = new PeerConnectionHandlerJsep(
       client,
-      this,
       dependency_factory_.get());
-  peer_connection_handlers_.push_back(pc_handler);
-
   return pc_handler;
 }
 
-void MediaStreamImpl::ClosePeerConnection(
-    PeerConnectionHandlerBase* pc_handler) {
-  DCHECK(CalledOnValidThread());
-  peer_connection_handlers_.remove(pc_handler);
+void MediaStreamImpl::StopLocalMediaStream(
+    const WebKit::WebMediaStreamDescriptor& stream) {
+  DVLOG(1) << "MediaStreamImpl::StopLocalMediaStream";
+
+  MediaStreamExtraData* extra_data =
+      static_cast<MediaStreamExtraData*>(stream.extraData());
+  if (extra_data && extra_data->local_stream()) {
+    media_stream_dispatcher_->StopStream(extra_data->local_stream()->label());
+    local_media_streams_.erase(extra_data->local_stream()->label());
+  } else {
+    NOTREACHED();
+  }
 }
 
-webrtc::LocalMediaStreamInterface* MediaStreamImpl::GetLocalMediaStream(
-    const WebKit::WebMediaStreamDescriptor& stream) {
-  // TODO(perkj): Change the mapping between a native local media stream and
-  // WebMediaStreamDescriptor once there is a common id.
-  // For now, we are forced to lookup the sources within a MediaStream.
-  WebKit::WebVector<WebKit::WebMediaStreamComponent> video_components;
-  stream.videoSources(video_components);
-
-  std::string msm_label;
-  if (!video_components.isEmpty()) {
-    std::string source_id = UTF16ToUTF8(video_components[0].source().id());
-    msm_label = ExtractManagerStreamLabel(source_id);
-  }
-  // If no local video source was found, check if there is an audio source.
-  if (msm_label.empty()) {
-    WebKit::WebVector<WebKit::WebMediaStreamComponent> audio_components;
-    stream.audioSources(audio_components);
-    if (!audio_components.isEmpty()) {
-        std::string source_id = UTF16ToUTF8(audio_components[0].source().id());
-        msm_label = ExtractManagerStreamLabel(source_id);
-      }
-  }
-  LocalNativeStreamMap::iterator it = local_media_streams_.find(msm_label);
-  if (it == local_media_streams_.end())
-    return NULL;
-  return it->second.stream_.get();
-}
-
-bool MediaStreamImpl::StopLocalMediaStream(
-    const WebKit::WebMediaStreamDescriptor& stream) {
-  DVLOG(1) << "MediaStreamImpl::StopLocalMediaStream";
-  webrtc::LocalMediaStreamInterface* native_stream = GetLocalMediaStream(
-      stream);
-  if (native_stream) {
-    media_stream_dispatcher_->StopStream(native_stream->label());
-    local_media_streams_.erase(native_stream->label());
-    return true;
-  } else {
-    return false;
-  }
+void MediaStreamImpl::CreateMediaStream(
+    WebKit::WebFrame* frame,
+    WebKit::WebMediaStreamDescriptor* stream) {
+  DVLOG(1) << "MediaStreamImpl::CreateMediaStream";
+  // TODO(perkj): Need to find the source from all existing local and
+  // remote MediaStreams.
+  NOTIMPLEMENTED();
 }
 
 void MediaStreamImpl::requestUserMedia(
     const WebKit::WebUserMediaRequest& user_media_request,
     const WebKit::WebVector<WebKit::WebMediaStreamSource>& audio_sources,
     const WebKit::WebVector<WebKit::WebMediaStreamSource>& video_sources) {
   // 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(kWebkitGetUserMedia);
@@ skipping 44 matching lines @@
   for (; it != user_media_requests_.end(); ++it) {
     if (it->second.request_ == user_media_request)
       break;
   }
   if (it != user_media_requests_.end()) {
     media_stream_dispatcher_->CancelGenerateStream(it->first);
     user_media_requests_.erase(it);
   }
 }
 
+WebKit::WebMediaStreamDescriptor MediaStreamImpl::GetMediaStream(
+    const GURL& url) {
+  return WebKit::WebMediaStreamRegistry::lookupMediaStreamDescriptor(url);
+}
+
 scoped_refptr<media::VideoDecoder> MediaStreamImpl::GetVideoDecoder(
     const GURL& url,
     media::MessageLoopFactory* message_loop_factory) {
   DCHECK(CalledOnValidThread());
-  WebKit::WebMediaStreamDescriptor descriptor(
-      WebKit::WebMediaStreamRegistry::lookupMediaStreamDescriptor(url));
-  if (descriptor.isNull())
+  WebKit::WebMediaStreamDescriptor descriptor(GetMediaStream(url));
+
+  if (descriptor.isNull() || !descriptor.extraData())
     return NULL;  // This is not a valid stream.
 
-  webrtc::LocalMediaStreamInterface* local_stream =
-      GetLocalMediaStream(descriptor);
-  if (local_stream)
-    return CreateLocalVideoDecoder(local_stream, message_loop_factory);
+  DVLOG(1) << "MediaStreamImpl::GetVideoDecoder stream:"
+           << UTF16ToUTF8(descriptor.label());
 
-  PeerConnectionHandlerBase* pc_handler =
-      FindPeerConnectionByStream(descriptor);
-  if (pc_handler != NULL) {
-    return CreateRemoteVideoDecoder(descriptor,
-                                    pc_handler,
-                                    url,
+  MediaStreamExtraData* extra_data =
+      static_cast<MediaStreamExtraData*>(descriptor.extraData());

[tommi (sloooow) - chröme, 2012/05/14 14:33:52]

reinterpret_cast?

[perkj_chrome, 2012/05/14 15:14:33]

They are related through inheritance.

+  if (extra_data->local_stream())
+    return CreateLocalVideoDecoder(extra_data->local_stream(),
+                                   message_loop_factory);
+  if (extra_data->remote_stream())
+    return CreateRemoteVideoDecoder(extra_data->remote_stream(), url,
                                     message_loop_factory);
-  }
+  NOTREACHED();
   return NULL;
 }
 
 // Callback from MediaStreamDispatcher.
 // The requested stream have been generated.
 void MediaStreamImpl::OnStreamGenerated(
     int request_id,
     const std::string& label,
     const media_stream::StreamDeviceInfoArray& audio_array,
     const media_stream::StreamDeviceInfoArray& video_array) {
   DCHECK(CalledOnValidThread());
 
   WebKit::WebVector<WebKit::WebMediaStreamSource> audio_source_vector(
       audio_array.size());
   CreateWebKitSourceVector(label, audio_array,
                            WebKit::WebMediaStreamSource::TypeAudio,
                            audio_source_vector);
   WebKit::WebVector<WebKit::WebMediaStreamSource> video_source_vector(
       video_array.size());
   CreateWebKitSourceVector(label, video_array,
                            WebKit::WebMediaStreamSource::TypeVideo,
                            video_source_vector);
 
   MediaRequestMap::iterator it = user_media_requests_.find(request_id);
   if (it == user_media_requests_.end()) {
     DVLOG(1) << "Request ID not found";
     return;
   }
 
-  CreateNativeLocalMediaStream(label, it->second.frame_,
-                               audio_source_vector, video_source_vector);
+  LocalNativeStreamPtr native_stream(CreateNativeLocalMediaStream(
+      label, it->second.frame_, audio_source_vector, video_source_vector));
 
-  WebKit::WebUserMediaRequest user_media_request(it->second.request_);
+  WebKit::WebString webkit_label = UTF8ToUTF16(label);
+  WebKit::WebMediaStreamDescriptor description;
+  description.initialize(webkit_label, audio_source_vector,
+                         video_source_vector);
+  description.setExtraData(new MediaStreamExtraData(native_stream));
+
+  CompleteGetUserMediaRequest(description, &it->second.request_);
   user_media_requests_.erase(it);
+}
 
-  // |user_media_request| can't be mocked. So in order to test at all we check
-  // if it isNull.
-  if (!user_media_request.isNull())
-    user_media_request.requestSucceeded(audio_source_vector,
-                                        video_source_vector);
+void MediaStreamImpl::CompleteGetUserMediaRequest(
+      const WebKit::WebMediaStreamDescriptor& stream,
+      WebKit::WebUserMediaRequest* request) {
+  request->requestSucceeded(stream);
 }
 
 void MediaStreamImpl::OnStreamGenerationFailed(int request_id) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "MediaStreamImpl::OnStreamGenerationFailed("
            << request_id << ")";
   MediaRequestMap::iterator it = user_media_requests_.find(request_id);
   if (it == user_media_requests_.end()) {
     DVLOG(1) << "Request ID not found";
     return;
@@ skipping 47 matching lines @@
 
 void MediaStreamImpl::OnDeviceOpenFailed(int request_id) {
   DVLOG(1) << "MediaStreamImpl::VideoDeviceOpenFailed("
            << request_id << ")";
   NOTIMPLEMENTED();
 }
 
 void MediaStreamImpl::FrameWillClose(WebKit::WebFrame* frame) {
   LocalNativeStreamMap::iterator it = local_media_streams_.begin();
   while (it != local_media_streams_.end()) {
-    if (it->second.frame_ == frame) {
+    if (it->second == frame) {
       DVLOG(1) << "MediaStreamImpl::FrameWillClose: "
                << "Stopping stream " << it->first;
       media_stream_dispatcher_->StopStream(it->first);
       local_media_streams_.erase(it);
       it = local_media_streams_.begin();
     } else {
       ++it;
     }
   }
 }
@@ skipping 68 matching lines @@
             socket_factory_.get())) {
       LOG(ERROR) << "Could not create PeerConnection factory";
       return false;
     }
   }
 
   return true;
 }
 
 scoped_refptr<media::VideoDecoder> MediaStreamImpl::CreateLocalVideoDecoder(
-    webrtc::LocalMediaStreamInterface* stream,
+    webrtc::MediaStreamInterface* stream,
     media::MessageLoopFactory* message_loop_factory) {
   if (!stream->video_tracks() || stream->video_tracks()->count() == 0)
     return NULL;
 
   int video_session_id =
       media_stream_dispatcher_->video_session_id(stream->label(), 0);
   media::VideoCaptureCapability capability;
   capability.width = kVideoCaptureWidth;
   capability.height = kVideoCaptureHeight;
   capability.frame_rate = kVideoCaptureFramePerSecond;
   capability.color = media::VideoCaptureCapability::kI420;
   capability.expected_capture_delay = 0;
   capability.interlaced = false;
+
+  DVLOG(1) << "MediaStreamImpl::CreateLocalVideoDecoder video_session_id:"
+           << video_session_id;
+
   return new CaptureVideoDecoder(
       message_loop_factory->GetMessageLoopProxy("CaptureVideoDecoderThread"),
       video_session_id,
       vc_manager_.get(),
       capability);
 }
 
-PeerConnectionHandlerBase* MediaStreamImpl::FindPeerConnectionByStream(
-    const WebKit::WebMediaStreamDescriptor& stream) {
-  std::list<PeerConnectionHandlerBase*>::iterator it;
-  for (it = peer_connection_handlers_.begin();
-       it != peer_connection_handlers_.end(); ++it) {
-    if ((*it)->GetRemoteMediaStream(stream) != NULL) {
-      return *it;
-    }
-  }
-  return NULL;
-}
-
 scoped_refptr<media::VideoDecoder> MediaStreamImpl::CreateRemoteVideoDecoder(
-    const WebKit::WebMediaStreamDescriptor& stream,
-    PeerConnectionHandlerBase* pc_handler,
+    webrtc::MediaStreamInterface* stream,
     const GURL& url,
     media::MessageLoopFactory* message_loop_factory) {
-  WebKit::WebVector<WebKit::WebMediaStreamComponent> video_sources;
-  stream.videoSources(video_sources);
-  if (video_sources.isEmpty())
+  if (!stream->video_tracks() || stream->video_tracks()->count() == 0)
     return NULL;
 
-  std::string source_id = UTF16ToUTF8(video_sources[0].source().id());
+  DVLOG(1) << "MediaStreamImpl::CreateRemoteVideoDecoder label:"
+           << stream->label();
+
   RTCVideoDecoder* rtc_video_decoder = new RTCVideoDecoder(
       message_loop_factory->GetMessageLoop("RtcVideoDecoderThread"),
       url.spec());
   talk_base::scoped_refptr<webrtc::VideoRendererWrapperInterface> renderer(
       new talk_base::RefCountedObject<VideoRendererWrapper>(rtc_video_decoder));
-
-  pc_handler->SetRemoteVideoRenderer(source_id, renderer);
+  stream->video_tracks()->at(0)->SetRenderer(renderer);
   return rtc_video_decoder;
 }
 
-void MediaStreamImpl::CreateNativeLocalMediaStream(
+talk_base::scoped_refptr<webrtc::LocalMediaStreamInterface>
+MediaStreamImpl::CreateNativeLocalMediaStream(
     const std::string& label,
     WebKit::WebFrame* frame,
     const WebKit::WebVector<WebKit::WebMediaStreamSource>& audio_sources,
     const WebKit::WebVector<WebKit::WebMediaStreamSource>& video_sources) {
   // Creating the peer connection factory can fail if for example the audio
   // (input or output) or video device cannot be opened. Handling such cases
   // better is a higher level design discussion which involves the media
   // manager, webrtc and libjingle. We cannot create any native
   // track objects however, so we'll just have to skip that. Furthermore,
   // creating a peer connection later on will fail if we don't have a factory.
   if (!EnsurePeerConnectionFactory()) {
-    return;
+    return NULL;
   }
 
-  LocalMediaStreamPtr native_stream =
+  LocalNativeStreamPtr native_stream =
       dependency_factory_->CreateLocalMediaStream(label);
 
   // Add audio tracks.
   for (size_t i = 0; i < audio_sources.size(); ++i) {
     talk_base::scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
         dependency_factory_->CreateLocalAudioTrack(
-            UTF16ToUTF8(audio_sources[i].name()), NULL));
+            UTF16ToUTF8(audio_sources[i].id()), NULL));
     native_stream->AddTrack(audio_track);
   }
 
   // Add video tracks.
   for (size_t i = 0; i < video_sources.size(); ++i) {
-    std::string msm_label = ExtractManagerStreamLabel(
-        UTF16ToUTF8(video_sources[i].id()));
-    if (!media_stream_dispatcher_->IsStream(msm_label)) {
+    if (!media_stream_dispatcher_->IsStream(label)) {
       continue;
     }
     int video_session_id =
-        media_stream_dispatcher_->video_session_id(msm_label, 0);
+        media_stream_dispatcher_->video_session_id(label, 0);
     talk_base::scoped_refptr<webrtc::LocalVideoTrackInterface> video_track(
         dependency_factory_->CreateLocalVideoTrack(
-            UTF16ToUTF8(video_sources[i].name()), video_session_id));
+            UTF16ToUTF8(video_sources[i].id()), video_session_id));
     native_stream->AddTrack(video_track);
   }
-  local_media_streams_[label] = LocalMediaStreamInfo(frame, native_stream);
+  local_media_streams_[label] = frame;
+  return native_stream;
 }
 
 MediaStreamImpl::VideoRendererWrapper::VideoRendererWrapper(
     RTCVideoDecoder* decoder)
     : rtc_video_decoder_(decoder) {
 }
 
 MediaStreamImpl::VideoRendererWrapper::~VideoRendererWrapper() {
 }
 
-MediaStreamImpl::LocalMediaStreamInfo::~LocalMediaStreamInfo() {
+MediaStreamExtraData::MediaStreamExtraData(
+    webrtc::MediaStreamInterface* remote_stream)
+    : remote_stream_(remote_stream) {
 }
+MediaStreamExtraData::MediaStreamExtraData(
+    webrtc::LocalMediaStreamInterface* local_stream)
+    : local_stream_(local_stream) {
+}
+MediaStreamExtraData::~MediaStreamExtraData() {
+}