Use WeakPtr for RTCPeerConnectionHandler and RTCPeerConnectionTracker.

content/renderer/media/rtc_peer_connection_handler.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/rtc_peer_connection_handler.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 153 matching lines @@
   case blink::WebRTCIceTransportsAll:
     config->type = webrtc::PeerConnectionInterface::kAll;
     break;
   default:
     NOTREACHED();
   }
 }
 
 class SessionDescriptionRequestTracker {
  public:
-  SessionDescriptionRequestTracker(RTCPeerConnectionHandler* handler,
-                                   PeerConnectionTracker::Action action)
-      : handler_(handler), action_(action) {}
+  SessionDescriptionRequestTracker(
+      const base::WeakPtr<RTCPeerConnectionHandler>& handler,
+      const base::WeakPtr<PeerConnectionTracker>& tracker,
+      PeerConnectionTracker::Action action)
+      : handler_(handler), tracker_(tracker), action_(action) {}
 
   void TrackOnSuccess(const webrtc::SessionDescriptionInterface* desc) {
     DCHECK(thread_checker_.CalledOnValidThread());
-    std::string value;
-    if (desc) {
-      desc->ToString(&value);
-      value = "type: " + desc->type() + ", sdp: " + value;
-    }
-    if (handler_->peer_connection_tracker()) {
-      handler_->peer_connection_tracker()->TrackSessionDescriptionCallback(
-          handler_, action_, "OnSuccess", value);
+    if (tracker_ && handler_) {
+      std::string value;
+      if (desc) {
+        desc->ToString(&value);
+        value = "type: " + desc->type() + ", sdp: " + value;
+      }
+      tracker_->TrackSessionDescriptionCallback(
+          handler_.get(), action_, "OnSuccess", value);
     }
   }
 
   void TrackOnFailure(const std::string& error) {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (handler_->peer_connection_tracker()) {
-      handler_->peer_connection_tracker()->TrackSessionDescriptionCallback(
-          handler_, action_, "OnFailure", error);
+    if (handler_ && tracker_) {
+      tracker_->TrackSessionDescriptionCallback(
+          handler_.get(), action_, "OnFailure", error);
     }
   }
 
  private:
-  RTCPeerConnectionHandler* handler_;
+  const base::WeakPtr<RTCPeerConnectionHandler> handler_;
+  const base::WeakPtr<PeerConnectionTracker> tracker_;
   PeerConnectionTracker::Action action_;
   base::ThreadChecker thread_checker_;
 };
 
 // Class mapping responses from calls to libjingle CreateOffer/Answer and
 // the blink::WebRTCSessionDescriptionRequest.
 class CreateSessionDescriptionRequest
     : public webrtc::CreateSessionDescriptionObserver {
  public:
   explicit CreateSessionDescriptionRequest(
       const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
       const blink::WebRTCSessionDescriptionRequest& request,
-      RTCPeerConnectionHandler* handler,
+      const base::WeakPtr<RTCPeerConnectionHandler>& handler,
+      const base::WeakPtr<PeerConnectionTracker>& tracker,
       PeerConnectionTracker::Action action)
       : main_thread_(main_thread),
         webkit_request_(request),
-        tracker_(handler, action) {
+        tracker_(handler, tracker, action) {
   }
 
   void OnSuccess(webrtc::SessionDescriptionInterface* desc) override {
     if (!main_thread_->BelongsToCurrentThread()) {
       main_thread_->PostTask(FROM_HERE,
           base::Bind(&CreateSessionDescriptionRequest::OnSuccess, this, desc));
       return;
     }
 
     tracker_.TrackOnSuccess(desc);
@@ skipping 20 matching lines @@
 };
 
 // Class mapping responses from calls to libjingle
 // SetLocalDescription/SetRemoteDescription and a blink::WebRTCVoidRequest.
 class SetSessionDescriptionRequest
     : public webrtc::SetSessionDescriptionObserver {
  public:
   explicit SetSessionDescriptionRequest(
       const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
       const blink::WebRTCVoidRequest& request,
-      RTCPeerConnectionHandler* handler,
+      const base::WeakPtr<RTCPeerConnectionHandler>& handler,
+      const base::WeakPtr<PeerConnectionTracker>& tracker,
       PeerConnectionTracker::Action action)
       : main_thread_(main_thread),
         webkit_request_(request),
-        tracker_(handler, action) {
+        tracker_(handler, tracker, action) {
   }
 
   void OnSuccess() override {
     if (!main_thread_->BelongsToCurrentThread()) {
       main_thread_->PostTask(FROM_HERE,
           base::Bind(&SetSessionDescriptionRequest::OnSuccess, this));
       return;
     }
     tracker_.TrackOnSuccess(NULL);
     webkit_request_.requestSucceeded();
@@ skipping 338 matching lines @@
 };
 
 RTCPeerConnectionHandler::RTCPeerConnectionHandler(
     blink::WebRTCPeerConnectionHandlerClient* client,
     PeerConnectionDependencyFactory* dependency_factory,
     const scoped_refptr<base::SingleThreadTaskRunner>& signaling_thread)
     : client_(client),
       dependency_factory_(dependency_factory),
       frame_(NULL),
       signaling_thread_(signaling_thread),
-      peer_connection_tracker_(NULL),
       num_data_channels_created_(0),
       num_local_candidates_ipv4_(0),
       num_local_candidates_ipv6_(0),
       weak_factory_(this) {
   g_peer_connection_handlers.Get().insert(this);
 }
 
 RTCPeerConnectionHandler::~RTCPeerConnectionHandler() {
   DCHECK(thread_checker_.CalledOnValidThread());
   g_peer_connection_handlers.Get().erase(this);
@@ skipping 49 matching lines @@
   frame_ = frame;
 }
 
 bool RTCPeerConnectionHandler::initialize(
     const blink::WebRTCConfiguration& server_configuration,
     const blink::WebMediaConstraints& options) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(frame_);
 
   peer_connection_tracker_ =
-      RenderThreadImpl::current()->peer_connection_tracker();
+      RenderThreadImpl::current()->peer_connection_tracker()->AsWeakPtr();
 
   webrtc::PeerConnectionInterface::RTCConfiguration config;
   GetNativeRtcConfiguration(server_configuration, &config);
 
   RTCMediaConstraints constraints(options);
 
   peer_connection_observer_ = new Observer(weak_factory_.GetWeakPtr());
   native_peer_connection_ = dependency_factory_->CreatePeerConnection(
       config, &constraints, frame_, peer_connection_observer_.get());
 
   if (!native_peer_connection_.get()) {
     LOG(ERROR) << "Failed to initialize native PeerConnection.";
     return false;
   }
 
   if (peer_connection_tracker_) {
     peer_connection_tracker_->RegisterPeerConnection(
         this, config, constraints, frame_);
   }
 
   uma_observer_ = new rtc::RefCountedObject<PeerConnectionUMAObserver>();
   native_peer_connection_->RegisterUMAObserver(uma_observer_.get());
   return true;
 }
 
 bool RTCPeerConnectionHandler::InitializeForTest(
     const blink::WebRTCConfiguration& server_configuration,
     const blink::WebMediaConstraints& options,
-    PeerConnectionTracker* peer_connection_tracker) {
+    const base::WeakPtr<PeerConnectionTracker>& peer_connection_tracker) {
   DCHECK(thread_checker_.CalledOnValidThread());
   webrtc::PeerConnectionInterface::RTCConfiguration config;
   GetNativeRtcConfiguration(server_configuration, &config);
 
   peer_connection_observer_ = new Observer(weak_factory_.GetWeakPtr());
   RTCMediaConstraints constraints(options);
   native_peer_connection_ = dependency_factory_->CreatePeerConnection(
       config, &constraints, NULL, peer_connection_observer_.get());
   if (!native_peer_connection_.get()) {
     LOG(ERROR) << "Failed to initialize native PeerConnection.";
     return false;
   }
   peer_connection_tracker_ = peer_connection_tracker;
   return true;
 }
 
 void RTCPeerConnectionHandler::createOffer(
     const blink::WebRTCSessionDescriptionRequest& request,
     const blink::WebMediaConstraints& options) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::createOffer");
 
   scoped_refptr<CreateSessionDescriptionRequest> description_request(
       new rtc::RefCountedObject<CreateSessionDescriptionRequest>(
-          base::ThreadTaskRunnerHandle::Get(), request, this,
+          base::ThreadTaskRunnerHandle::Get(), request,
+          weak_factory_.GetWeakPtr(), peer_connection_tracker_,
           PeerConnectionTracker::ACTION_CREATE_OFFER));
 
   RTCMediaConstraints constraints(options);
   native_peer_connection_->CreateOffer(description_request.get(), &constraints);
 
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackCreateOffer(this, constraints);
 }
 
 void RTCPeerConnectionHandler::createOffer(
     const blink::WebRTCSessionDescriptionRequest& request,
     const blink::WebRTCOfferOptions& options) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::createOffer");
 
   scoped_refptr<CreateSessionDescriptionRequest> description_request(
       new rtc::RefCountedObject<CreateSessionDescriptionRequest>(
-          base::ThreadTaskRunnerHandle::Get(), request, this,
+          base::ThreadTaskRunnerHandle::Get(), request,
+          weak_factory_.GetWeakPtr(), peer_connection_tracker_,
           PeerConnectionTracker::ACTION_CREATE_OFFER));
 
   RTCMediaConstraints constraints;
   ConvertOfferOptionsToConstraints(options, &constraints);
   native_peer_connection_->CreateOffer(description_request.get(), &constraints);
 
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackCreateOffer(this, constraints);
 }
 
 void RTCPeerConnectionHandler::createAnswer(
     const blink::WebRTCSessionDescriptionRequest& request,
     const blink::WebMediaConstraints& options) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::createAnswer");
   scoped_refptr<CreateSessionDescriptionRequest> description_request(
       new rtc::RefCountedObject<CreateSessionDescriptionRequest>(
-          base::ThreadTaskRunnerHandle::Get(), request, this,
+          base::ThreadTaskRunnerHandle::Get(), request,
+          weak_factory_.GetWeakPtr(), peer_connection_tracker_,
           PeerConnectionTracker::ACTION_CREATE_ANSWER));
   RTCMediaConstraints constraints(options);
   native_peer_connection_->CreateAnswer(description_request.get(),
                                         &constraints);
 
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackCreateAnswer(this, constraints);
 }
 
 void RTCPeerConnectionHandler::setLocalDescription(
@@ skipping 20 matching lines @@
     return;
   }
 
   if (peer_connection_tracker_) {
     peer_connection_tracker_->TrackSetSessionDescription(
         this, sdp, type, PeerConnectionTracker::SOURCE_LOCAL);
   }
 
   scoped_refptr<SetSessionDescriptionRequest> set_request(
       new rtc::RefCountedObject<SetSessionDescriptionRequest>(
-          base::ThreadTaskRunnerHandle::Get(), request, this,
+          base::ThreadTaskRunnerHandle::Get(), request,
+          weak_factory_.GetWeakPtr(), peer_connection_tracker_,
           PeerConnectionTracker::ACTION_SET_LOCAL_DESCRIPTION));
 
   // TODO(tommi): Run this on the signaling thread.
   native_peer_connection_->SetLocalDescription(set_request.get(), native_desc);
 }
 
 void RTCPeerConnectionHandler::setRemoteDescription(
     const blink::WebRTCVoidRequest& request,
     const blink::WebRTCSessionDescription& description) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 16 matching lines @@
     return;
   }
 
   if (peer_connection_tracker_) {
     peer_connection_tracker_->TrackSetSessionDescription(
         this, sdp, type, PeerConnectionTracker::SOURCE_REMOTE);
   }
 
   scoped_refptr<SetSessionDescriptionRequest> set_request(
       new rtc::RefCountedObject<SetSessionDescriptionRequest>(
-          base::ThreadTaskRunnerHandle::Get(), request, this,
+          base::ThreadTaskRunnerHandle::Get(), request,
+          weak_factory_.GetWeakPtr(), peer_connection_tracker_,
           PeerConnectionTracker::ACTION_SET_REMOTE_DESCRIPTION));
   // TODO(tommi): Run this on the signaling thread.
   native_peer_connection_->SetRemoteDescription(set_request.get(), native_desc);
 }
 
 blink::WebRTCSessionDescription
 RTCPeerConnectionHandler::localDescription() {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::localDescription");
   const webrtc::SessionDescriptionInterface* native_desc =
@@ skipping 342 matching lines @@
 
 void RTCPeerConnectionHandler::OnRenegotiationNeeded() {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::OnRenegotiationNeeded");
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackOnRenegotiationNeeded(this);
   if (client_)
     client_->negotiationNeeded();
 }
 
-PeerConnectionTracker* RTCPeerConnectionHandler::peer_connection_tracker() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  return peer_connection_tracker_;
-}
-
 void RTCPeerConnectionHandler::OnAddStream(
     scoped_ptr<RemoteMediaStreamImpl> stream) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(remote_streams_.find(stream->webrtc_stream().get()) ==
          remote_streams_.end());
   DCHECK(stream->webkit_stream().extraData()) << "Initialization not done";
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::OnAddStreamImpl");
 
   // Ownership is with remote_streams_ now.
   RemoteMediaStreamImpl* s = stream.release();
@@ skipping 92 matching lines @@
   webrtc::SessionDescriptionInterface* native_desc =
       dependency_factory_->CreateSessionDescription(type, sdp, error);
 
   LOG_IF(ERROR, !native_desc) << "Failed to create native session description."
                               << " Type: " << type << " SDP: " << sdp;
 
   return native_desc;
 }
 
 }  // namespace content