Adding JSEP PeerConnection glue.

content/renderer/media/media_stream_impl.cc

Index: content/renderer/media/media_stream_impl.cc
diff --git a/content/renderer/media/media_stream_impl.cc b/content/renderer/media/media_stream_impl.cc
index 0e3858420b895ea1cc792a1153bdd7ed1c9796dd..587e68a1439ce329aab8882e0a120093badb90b8 100644
--- a/content/renderer/media/media_stream_impl.cc
+++ b/content/renderer/media/media_stream_impl.cc
@@ -14,6 +14,7 @@
 #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"
@@ -80,15 +81,13 @@ MediaStreamImpl::MediaStreamImpl(
       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_) {
@@ -111,30 +110,54 @@ MediaStreamImpl::~MediaStreamImpl() {
 WebKit::WebPeerConnectionHandler* MediaStreamImpl::CreatePeerConnectionHandler(
     WebKit::WebPeerConnectionHandlerClient* client) {
   DCHECK(CalledOnValidThread());
-  if (peer_connection_handler_) {
-    DVLOG(1) << "A PeerConnection already exists";
+  if (!EnsurePeerConnectionFactory())
     return NULL;
+
+  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 pc_handler;
+}
+
+WebKit::WebPeerConnection00Handler*
+MediaStreamImpl::CreatePeerConnectionHandlerJsep(
+    WebKit::WebPeerConnection00HandlerClient* client) {
+  DCHECK(CalledOnValidThread());
   if (!EnsurePeerConnectionFactory())
     return NULL;
 
-  peer_connection_handler_ = new PeerConnectionHandler(
+  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 peer_connection_handler_;
+  return pc_handler;
 }
 
-void MediaStreamImpl::ClosePeerConnection() {
+void MediaStreamImpl::ClosePeerConnection(
+    PeerConnectionHandlerBase* pc_handler) {
   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);
+  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(
@@ -246,27 +269,34 @@ scoped_refptr<media::VideoDecoder> MediaStreamImpl::GetVideoDecoder(
         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;
 }