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 498 matching lines @@
     WillBeHeapVector<RefPtrWillBeMember<Event> > events;
     events.swap(m_scheduledEvents);
 
     WillBeHeapVector<RefPtrWillBeMember<Event> >::iterator it = events.begin();
     for (; it != events.end(); ++it)
         dispatchEvent((*it).release());
 
     events.clear();
 }
 
+void RTCPeerConnection::clearWeakMembers(Visitor* visitor)
+{
+    if (!visitor->isAlive(this) && m_closed)

[Mads Ager (chromium), 2014/06/18 08:19:50]

This will not work because weak processing only happens when the trace method is
called. The trace method is only called when the object is alive and therefore
this condition will always be false because we will only get here when
visitor->isAlive(this).

When the RTCPeerConnection dies, what we need to make sure is that the
RTCDataChannels are stopped (that is the only thing that RTCPeerConnection::stop
does that matters when RTCPeerConnection is dead).

So, we should add a weak pointer from RTCDataChannel to RTCPeerConnection and
add custom weak processing for that one to make sure that we call stop on the
DataChannel when it outlives the PeerConnection.

[keishi, 2014/06/18 08:56:58]

Done.

+        stop();
+}
+
 void RTCPeerConnection::trace(Visitor* visitor)
 {
     visitor->trace(m_localStreams);
     visitor->trace(m_remoteStreams);
     visitor->trace(m_dataChannels);
     visitor->trace(m_scheduledEvents);
+    visitor->registerWeakMembers<RTCPeerConnection, &RTCPeerConnection::clearWeakMembers>(this);
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace WebCore