Adding JSEP PeerConnection glue.

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/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
 #include "content/renderer/media/capture_video_decoder.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"
 #include "jingle/glue/thread_wrapper.h"
 #include "media/base/message_loop_factory.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebMediaStreamDescriptor.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaStreamRegistry.h"
@@ skipping 46 matching lines @@
 MediaStreamImpl::MediaStreamImpl(
     MediaStreamDispatcher* media_stream_dispatcher,
     content::P2PSocketDispatcher* p2p_socket_dispatcher,
     VideoCaptureImplManager* vc_manager,
     MediaStreamDependencyFactory* dependency_factory)
     : dependency_factory_(dependency_factory),
       media_stream_dispatcher_(media_stream_dispatcher),
       p2p_socket_dispatcher_(p2p_socket_dispatcher),
       network_manager_(NULL),
       vc_manager_(vc_manager),
-      peer_connection_handler_(NULL),
-      message_loop_proxy_(base::MessageLoopProxy::current()),
       signaling_thread_(NULL),
       worker_thread_(NULL),
       chrome_worker_thread_("Chrome_libJingle_WorkerThread") {
 }
 
 MediaStreamImpl::~MediaStreamImpl() {
-  DCHECK(!peer_connection_handler_);
+  DCHECK(peer_connection_handlers_.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)));
       // Stopping the thread will wait until all tasks have been
       // processed before returning. We wait for the above task to finish before
       // letting the destructor continue to avoid any potential race issues.
       chrome_worker_thread_.Stop();
     } else {
       NOTREACHED() << "Worker thread not running.";
     }
   }
 }
 
 WebKit::WebPeerConnectionHandler* MediaStreamImpl::CreatePeerConnectionHandler(
     WebKit::WebPeerConnectionHandlerClient* client) {
   DCHECK(CalledOnValidThread());
-  if (peer_connection_handler_) {
-    DVLOG(1) << "A PeerConnection already exists";
-    return NULL;
-  }
   if (!EnsurePeerConnectionFactory())
     return NULL;
 
-  peer_connection_handler_ = new PeerConnectionHandler(
+  PeerConnectionHandler* pc_handler = new PeerConnectionHandler(
       client,
       this,
       dependency_factory_.get());
+  if (pc_handler) {
+    peer_connection_handlers_.push_back(pc_handler);
+  } else {
+    LOG(ERROR) << "Could not create PeerConnection handler";

[tommi (sloooow) - chröme, 2012/03/26 12:34:45]

if this is an oom situation, we more commonly just do:

Foo* foo = new Foo();
CHECK(foo);

[scherkus (not reviewing), 2012/03/26 22:04:37]

actually chrome's OOM handler will take care of the situation by crashing so
there's little reason to code for OOM situations (i.e., don't bother with a
CHECK())

[Henrik Grunell, 2012/03/27 07:22:05]

OK, I'll remove the if-else and logging, just put it in the list and return.

+  }
 
-  return peer_connection_handler_;
+  return pc_handler;
 }
 
-void MediaStreamImpl::ClosePeerConnection() {
+WebKit::WebPeerConnection00Handler*
+MediaStreamImpl::CreatePeerConnectionHandlerJsep(
+    WebKit::WebPeerConnection00HandlerClient* client) {
   DCHECK(CalledOnValidThread());
-  video_renderer_ = NULL;
-  peer_connection_handler_ = NULL;
-  // TODO(grunell): This is a temporary workaround for an error in native
-  // PeerConnection where added live tracks are not seen on the remote side.
-  MediaStreamTrackPtrMap::const_iterator it = local_tracks_.begin();
-  for (; it != local_tracks_.end(); ++it)
-    it->second->set_state(webrtc::MediaStreamTrackInterface::kEnded);
+  if (!EnsurePeerConnectionFactory())
+    return NULL;
+
+  PeerConnectionHandlerJsep* pc_handler = new PeerConnectionHandlerJsep(
+      client,
+      this,
+      dependency_factory_.get());
+  if (pc_handler) {

[tommi (sloooow) - chröme, 2012/03/26 12:34:45]

same here

[Henrik Grunell, 2012/03/27 07:22:05]

Same as above.

+    peer_connection_handlers_.push_back(pc_handler);
+  } else {
+    LOG(ERROR) << "Could not create PeerConnection handler";
+  }
+
+  return pc_handler;
+}
+
+void MediaStreamImpl::ClosePeerConnection(
+    PeerConnectionHandlerBase* pc_handler) {
+  DCHECK(CalledOnValidThread());
+  VideoRendererMap::iterator vr_it = video_renderers_.begin();
+  while (vr_it != video_renderers_.end()) {
+    if (vr_it->second.second == pc_handler) {
+      video_renderers_.erase(vr_it++);

[tommi (sloooow) - chröme, 2012/03/26 12:34:45]

ah, I see now that you're using the temporary from the postfix ++ operator to
pass the 'previous' element to erase.

but what about doing this instead:

vr_it = video_renderers_.erase(vr_it);

This is why erase() has a return value.

[Henrik Grunell, 2012/03/27 07:22:05]

It's a map, it doesn't have an iterator return value. This is afaik the cleanest
way to do the thing here. Keep the ideas coming! :-)

+    } else {
+      ++vr_it;
+    }
+  }
+  peer_connection_handlers_.remove(pc_handler);
 }
 
 webrtc::MediaStreamTrackInterface* MediaStreamImpl::GetLocalMediaStreamTrack(
     const std::string& label) {
   DCHECK(CalledOnValidThread());
   MediaStreamTrackPtrMap::iterator it = local_tracks_.find(label);
   if (it == local_tracks_.end())
     return NULL;
   MediaStreamTrackPtr stream = it->second;
   return stream.get();
@@ skipping 91 matching lines @@
     capability.expected_capture_delay = 0;
     capability.raw_type = media::VideoFrame::I420;
     capability.interlaced = false;
     decoder = new CaptureVideoDecoder(
         message_loop_factory->GetMessageLoopProxy("CaptureVideoDecoderThread"),
         video_session_id,
         vc_manager_.get(),
         capability);
   } else {
     // It's a remote stream.
-    if (!video_renderer_.get())
-      video_renderer_ = new talk_base::RefCountedObject<VideoRendererWrapper>();
-    if (video_renderer_->renderer()) {
-      // The renderer is used by PeerConnection, release it first.
-      if (peer_connection_handler_) {
-        peer_connection_handler_->SetVideoRenderer(
-            UTF16ToUTF8(descriptor.label()),
-            NULL);
+    std::string desc_label = UTF16ToUTF8(descriptor.label());
+    PeerConnectionHandlerBase* pc_handler = NULL;
+    std::list<PeerConnectionHandlerBase*>::iterator it;
+    for (it = peer_connection_handlers_.begin();
+         it != peer_connection_handlers_.end(); ++it) {
+      if ((*it)->HasStream(desc_label)) {
+        pc_handler = *it;
+        break;
       }
-      video_renderer_->SetVideoDecoder(NULL);
     }
+    DCHECK(it != peer_connection_handlers_.end());
+    // TODO(grunell): We are not informed when a renderer should be deleted.
+    // When this has been fixed, ensure we delete it. For now, we hold on
+    // to all renderers until a PeerConnectionHandler is closed or we are
+    // deleted (then all renderers are deleted), so it sort of leaks.
+    // TODO(grunell): There is no support for multiple decoders per stream, this
+    // code will need to be updated when that is supported.
+    talk_base::scoped_refptr<VideoRendererWrapper> video_renderer =
+        new talk_base::RefCountedObject<VideoRendererWrapper>();
     RTCVideoDecoder* rtc_video_decoder = new RTCVideoDecoder(
         message_loop_factory->GetMessageLoop("RtcVideoDecoderThread"),
         url.spec());
     decoder = rtc_video_decoder;
-    video_renderer_->SetVideoDecoder(rtc_video_decoder);
-    if (peer_connection_handler_) {
-      peer_connection_handler_->SetVideoRenderer(
-          UTF16ToUTF8(descriptor.label()),
-          video_renderer_);
-    }
+    video_renderer->SetVideoDecoder(rtc_video_decoder);
+    pc_handler->SetVideoRenderer(desc_label, video_renderer);
+    video_renderers_.erase(desc_label);  // Remove old renderer if exists.
+    video_renderers_.insert(
+        std::make_pair(desc_label, std::make_pair(video_renderer, pc_handler)));
   }
   return decoder;
 }
 
 void MediaStreamImpl::OnStreamGenerated(
     int request_id,
     const std::string& label,
     const media_stream::StreamDeviceInfoArray& audio_array,
     const media_stream::StreamDeviceInfoArray& video_array) {
   DCHECK(CalledOnValidThread());
@@ skipping 204 matching lines @@
 }
 
 MediaStreamImpl::VideoRendererWrapper::VideoRendererWrapper() {}
 
 MediaStreamImpl::VideoRendererWrapper::~VideoRendererWrapper() {}
 
 void MediaStreamImpl::VideoRendererWrapper::SetVideoDecoder(
     RTCVideoDecoder* decoder) {
   rtc_video_decoder_ = decoder;
 }