Oilpan: Use weak processing to stop a closed RTCPeerConnection

Source/modules/mediastream/RTCPeerConnection.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 202 matching lines @@
         return;
     }
 }
 
 RTCPeerConnection::~RTCPeerConnection()
 {
     // This checks that close() or stop() is called before the destructor.
     // We are assuming that a wrapper is always created when RTCPeerConnection is created.
     ASSERT(m_closed || m_stopped);
 
-    // FIXME: Oilpan: We can't call stop here since it touches m_dataChannels.
-    // Another way to ensure that data channels are stopped at RTCPeerConnection
-    // destruction is needed.
+#if !ENABLE(OILPAN)
     stop();
+#endif
 }
 
 void RTCPeerConnection::createOffer(PassOwnPtr<RTCSessionDescriptionCallback> successCallback, PassOwnPtr<RTCErrorCallback> errorCallback, const Dictionary& mediaConstraints, ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return;
 
     ASSERT(successCallback);
 
     blink::WebMediaConstraints constraints = MediaConstraintsImpl::create(mediaConstraints, exceptionState);
@@ skipping 245 matching lines @@
     for (MediaStreamVector::iterator iter = m_remoteStreams.begin(); iter != m_remoteStreams.end(); ++iter) {
         if ((*iter)->id() == streamId)
             return iter->get();
     }
 
     return 0;
 }
 
 void RTCPeerConnection::getStats(PassOwnPtr<RTCStatsCallback> successCallback, PassRefPtr<MediaStreamTrack> selector)
 {
+    ASSERT(m_peerHandler);

[haraken, 2014/06/18 09:17:09]

What is this ASSERT for?

[keishi, 2014/06/18 10:48:00]

Removed.

     RefPtr<RTCStatsRequest> statsRequest = RTCStatsRequestImpl::create(executionContext(), this, successCallback, selector);
     // FIXME: Add passing selector as part of the statsRequest.
     m_peerHandler->getStats(statsRequest.release());
 }
 
 PassRefPtrWillBeRawPtr<RTCDataChannel> RTCPeerConnection::createDataChannel(String label, const Dictionary& options, ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return nullptr;
 
     blink::WebRTCDataChannelInit init;
     options.get("ordered", init.ordered);
     options.get("negotiated", init.negotiated);
 
     unsigned short value = 0;
     if (options.get("id", value))
         init.id = value;
     if (options.get("maxRetransmits", value))
         init.maxRetransmits = value;
     if (options.get("maxRetransmitTime", value))
         init.maxRetransmitTime = value;
 
     String protocolString;
     options.get("protocol", protocolString);
     init.protocol = protocolString;
 
-    RefPtrWillBeRawPtr<RTCDataChannel> channel = RTCDataChannel::create(executionContext(), m_peerHandler.get(), label, init, exceptionState);
+    RefPtrWillBeRawPtr<RTCDataChannel> channel = RTCDataChannel::create(executionContext(), this, m_peerHandler.get(), label, init, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
     m_dataChannels.append(channel);
     return channel.release();
 }
 
 bool RTCPeerConnection::hasLocalStreamWithTrackId(const String& trackId)
 {
     for (MediaStreamVector::iterator iter = m_localStreams.begin(); iter != m_localStreams.end(); ++iter) {
         if ((*iter)->getTrackById(trackId))
@@ skipping 113 matching lines @@
 }
 
 void RTCPeerConnection::didAddRemoteDataChannel(blink::WebRTCDataChannelHandler* handler)
 {
     ASSERT(!m_closed);
     ASSERT(executionContext()->isContextThread());
 
     if (m_signalingState == SignalingStateClosed)
         return;
 
-    RefPtrWillBeRawPtr<RTCDataChannel> channel = RTCDataChannel::create(executionContext(), adoptPtr(handler));
+    RefPtrWillBeRawPtr<RTCDataChannel> channel = RTCDataChannel::create(executionContext(), this, adoptPtr(handler));
     m_dataChannels.append(channel);
 
     scheduleDispatchEvent(RTCDataChannelEvent::create(EventTypeNames::datachannel, false, false, channel.release()));
 }
 
 void RTCPeerConnection::releasePeerConnectionHandler()
 {
     stop();
 }
 
@@ skipping 82 matching lines @@
 void RTCPeerConnection::trace(Visitor* visitor)
 {
     visitor->trace(m_localStreams);
     visitor->trace(m_remoteStreams);
     visitor->trace(m_dataChannels);
     visitor->trace(m_scheduledEvents);
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace WebCore