Revert 131949 (multiple memory leaks) - 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/WebMediaStreamRegistry.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
@@ skipping 47 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_handlers_.empty());
+  DCHECK(!peer_connection_handler_);
   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;
 
-  PeerConnectionHandler* pc_handler = new PeerConnectionHandler(
+  peer_connection_handler_ = new PeerConnectionHandler(
       client,
       this,
       dependency_factory_.get());
-  peer_connection_handlers_.push_back(pc_handler);
 
-  return pc_handler;
+  return peer_connection_handler_;
 }
 
-WebKit::WebPeerConnection00Handler*
-MediaStreamImpl::CreatePeerConnectionHandlerJsep(
-    WebKit::WebPeerConnection00HandlerClient* client) {
+void MediaStreamImpl::ClosePeerConnection() {
   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());
-  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++);
-    } else {
-      ++vr_it;
-    }
-  }
-  peer_connection_handlers_.remove(pc_handler);
+  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);
 }
 
 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 track = it->second;
-  return track.get();
+  MediaStreamTrackPtr stream = it->second;
+  return stream.get();
 }
 
 void MediaStreamImpl::requestUserMedia(
     const WebKit::WebUserMediaRequest& user_media_request,
     const WebKit::WebVector<WebKit::WebMediaStreamSource>& audio_sources,
     const WebKit::WebVector<WebKit::WebMediaStreamSource>& video_sources) {
   DCHECK(CalledOnValidThread());
   DCHECK(!user_media_request.isNull());
 
   int request_id = next_request_id_++;
@@ skipping 70 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.
-    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;
+    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);
       }
+      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);
-    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)));
+    video_renderer_->SetVideoDecoder(rtc_video_decoder);
+    if (peer_connection_handler_) {
+      peer_connection_handler_->SetVideoRenderer(
+          UTF16ToUTF8(descriptor.label()),
+          video_renderer_);
+    }
   }
   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 205 matching lines @@
 }
 
 MediaStreamImpl::VideoRendererWrapper::VideoRendererWrapper() {}
 
 MediaStreamImpl::VideoRendererWrapper::~VideoRendererWrapper() {}
 
 void MediaStreamImpl::VideoRendererWrapper::SetVideoDecoder(
     RTCVideoDecoder* decoder) {
   rtc_video_decoder_ = decoder;
 }