Oilpan: Move MediaStreamSource, MediaStreamComponent and MediaStreamDescriptor

to oilpan's heap

- MediaStreamSource, MediaStreamComponent and MediaStreamDescriptor must be moved
to oilpan's heap in one go because their lifetime are tightly coupled.

- Removed m_descriptor->setClient(0) from MediaStream's destructor. This is OK
because MediaStreamDescriptor has a strong Member back to the Client
(i.e., MediaStream).

- Removed m_component->source()->removeObserver(this) from MediaStreamTrack's
destructor. This is OK because this CL made the observers weak
(i.e., MediaStreamSource::m_observers is a hash set of weak members to
MediaStreamTrack objects).

- Removed WebMediaStreamTrack::ExtraData::m_owner because it's unused.

- Introduced MediaStreamComponentDisposer to delay the destruction of
MediaStreamComponent::m_extraData. The ExtraData is exposed to the web
and some Chromium objects inherit from the ExtraData. If we clear the
m_extraData in the MediaStreamComponent's destructor, those Chromium-side
objects are also destructed in the MediaStreamComponent's destructor.
This is problematic because the destructors of the Chromium-side classes
can touch other on-heap objects in the Blink side. To avoid the issue,
we need to delay the destruction of the ExtraData to thread-specific
weak processing. The disposer pattern actually makes the deletion of
the extra data happen earlier and not later. The disposer makes sure
that the extra data is destructed in weak processing which is run before
sweeping and therefore all the objects are still alive and can be touched.


- The same problem arises for MediaStreamDescriptor and MediaStreamSource.
This CL adds MediaStreamDescriptorDisposer and MediaStreamSourceDisposer.

- This CL depends on https://codereview.chromium.org/543603003/ and https://codereview.chromium.org/549153002.

BUG=340522

Review URL: https://codereview.chromium.org/552653005

git-svn-id: svn://svn.chromium.org/blink/trunk@181702 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/modules/mediastream/MediaStream.cpp

@@ -89,12 +89,12 @@ MediaStream* MediaStream::create(ExecutionContext* context, const MediaStreamTra
     return adoptRefCountedGarbageCollectedWillBeNoop(new MediaStream(context, audioTracks, videoTracks));
 }
 
-MediaStream* MediaStream::create(ExecutionContext* context, PassRefPtr<MediaStreamDescriptor> streamDescriptor)
+MediaStream* MediaStream::create(ExecutionContext* context, MediaStreamDescriptor* streamDescriptor)
 {
     return adoptRefCountedGarbageCollectedWillBeNoop(new MediaStream(context, streamDescriptor));
 }
 
-MediaStream::MediaStream(ExecutionContext* context, PassRefPtr<MediaStreamDescriptor> streamDescriptor)
+MediaStream::MediaStream(ExecutionContext* context, MediaStreamDescriptor* streamDescriptor)
     : ContextLifecycleObserver(context)
     , m_stopped(false)
     , m_descriptor(streamDescriptor)
@@ -147,7 +147,6 @@ MediaStream::MediaStream(ExecutionContext* context, const MediaStreamTrackVector
 
 MediaStream::~MediaStream()
 {
-    m_descriptor->setClient(0);
 }
 
 bool MediaStream::ended() const
@@ -392,7 +391,9 @@ void MediaStream::trace(Visitor* visitor)
     visitor->trace(m_audioTracks);
     visitor->trace(m_videoTracks);
     visitor->trace(m_scheduledEvents);
+    visitor->trace(m_descriptor);
     EventTargetWithInlineData::trace(visitor);
+    MediaStreamDescriptorClient::trace(visitor);
 }
 
 } // namespace blink

third_party/WebKit/Source/modules/mediastream/MediaStream.h

@@ -45,12 +45,12 @@ class MediaStream FINAL
     , public ContextLifecycleObserver {
     DEFINE_EVENT_TARGET_REFCOUNTING_WILL_BE_REMOVED(RefCountedGarbageCollectedWillBeGarbageCollectedFinalized<MediaStream>);
     DEFINE_WRAPPERTYPEINFO();
-    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(MediaStream);
+    USING_GARBAGE_COLLECTED_MIXIN(MediaStream);
 public:
     static MediaStream* create(ExecutionContext*);
     static MediaStream* create(ExecutionContext*, MediaStream*);
     static MediaStream* create(ExecutionContext*, const MediaStreamTrackVector&);
-    static MediaStream* create(ExecutionContext*, PassRefPtr<MediaStreamDescriptor>);
+    static MediaStream* create(ExecutionContext*, MediaStreamDescriptor*);
     virtual ~MediaStream();
 
     // DEPRECATED
@@ -91,7 +91,7 @@ public:
     virtual void trace(Visitor*) OVERRIDE;
 
 private:
-    MediaStream(ExecutionContext*, PassRefPtr<MediaStreamDescriptor>);
+    MediaStream(ExecutionContext*, MediaStreamDescriptor*);
     MediaStream(ExecutionContext*, const MediaStreamTrackVector& audioTracks, const MediaStreamTrackVector& videoTracks);
 
     // ContextLifecycleObserver
@@ -108,7 +108,7 @@ private:
 
     MediaStreamTrackVector m_audioTracks;
     MediaStreamTrackVector m_videoTracks;
-    RefPtr<MediaStreamDescriptor> m_descriptor;
+    Member<MediaStreamDescriptor> m_descriptor;
 
     Timer<MediaStream> m_scheduledEventTimer;
     WillBeHeapVector<RefPtrWillBeMember<Event> > m_scheduledEvents;

third_party/WebKit/Source/modules/mediastream/MediaStreamRegistry.h

@@ -26,6 +26,7 @@
 #define MediaStreamRegistry_h
 
 #include "core/html/URLRegistry.h"
+#include "platform/heap/Handle.h"
 #include "wtf/HashMap.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/text/StringHash.h"
@@ -50,7 +51,7 @@ public:
 
 private:
     MediaStreamRegistry();
-    HashMap<String, RefPtr<MediaStreamDescriptor> > m_streamDescriptors;
+    PersistentHeapHashMap<String, Member<MediaStreamDescriptor> > m_streamDescriptors;
 };
 
 } // namespace blink

third_party/WebKit/Source/modules/mediastream/MediaStreamTrack.cpp

@@ -58,7 +58,6 @@ MediaStreamTrack::MediaStreamTrack(ExecutionContext* context, MediaStreamCompone
 
 MediaStreamTrack::~MediaStreamTrack()
 {
-    m_component->source()->removeObserver(this);
 }
 
 String MediaStreamTrack::kind() const
@@ -146,9 +145,9 @@ void MediaStreamTrack::stopTrack(ExceptionState& exceptionState)
 
 MediaStreamTrack* MediaStreamTrack::clone(ExecutionContext* context)
 {
-    RefPtr<MediaStreamComponent> clonedComponent = MediaStreamComponent::create(component()->source());
-    MediaStreamTrack* clonedTrack = MediaStreamTrack::create(context, clonedComponent.get());
-    MediaStreamCenter::instance().didCreateMediaStreamTrack(clonedComponent.get());
+    MediaStreamComponent* clonedComponent = MediaStreamComponent::create(component()->source());
+    MediaStreamTrack* clonedTrack = MediaStreamTrack::create(context, clonedComponent);
+    MediaStreamCenter::instance().didCreateMediaStreamTrack(clonedComponent);
     return clonedTrack;
 }
 
@@ -229,7 +228,9 @@ ExecutionContext* MediaStreamTrack::executionContext() const
 void MediaStreamTrack::trace(Visitor* visitor)
 {
     visitor->trace(m_registeredMediaStreams);
+    visitor->trace(m_component);
     EventTargetWithInlineData::trace(visitor);
+    MediaStreamSource::Observer::trace(visitor);
 }
 
 } // namespace blink

third_party/WebKit/Source/modules/mediastream/MediaStreamTrack.h

@@ -47,7 +47,7 @@ class MediaStreamTrack FINAL
     , public MediaStreamSource::Observer {
     DEFINE_EVENT_TARGET_REFCOUNTING_WILL_BE_REMOVED(RefCountedGarbageCollectedWillBeGarbageCollectedFinalized<MediaStreamTrack>);
     DEFINE_WRAPPERTYPEINFO();
-    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(MediaStreamTrack);
+    USING_GARBAGE_COLLECTED_MIXIN(MediaStreamTrack);
 public:
     static MediaStreamTrack* create(ExecutionContext*, MediaStreamComponent*);
     virtual ~MediaStreamTrack();
@@ -100,7 +100,7 @@ private:
     HeapHashSet<Member<MediaStream> > m_registeredMediaStreams;
     bool m_isIteratingRegisteredMediaStreams;
     bool m_stopped;
-    RefPtr<MediaStreamComponent> m_component;
+    Member<MediaStreamComponent> m_component;
 };
 
 typedef HeapVector<Member<MediaStreamTrack> > MediaStreamTrackVector;

third_party/WebKit/Source/modules/mediastream/RTCStatsRequestImpl.cpp

@@ -88,6 +88,7 @@ void RTCStatsRequestImpl::clear()
 void RTCStatsRequestImpl::trace(Visitor* visitor)
 {
     visitor->trace(m_successCallback);
+    visitor->trace(m_component);
     visitor->trace(m_requester);
     RTCStatsRequest::trace(visitor);
 }

third_party/WebKit/Source/modules/mediastream/RTCStatsRequestImpl.h

@@ -60,7 +60,7 @@ private:
     void clear();
 
     OwnPtrWillBeMember<RTCStatsCallback> m_successCallback;
-    RefPtr<MediaStreamComponent> m_component;
+    Member<MediaStreamComponent> m_component;
     Member<RTCPeerConnection> m_requester;
 };
 

third_party/WebKit/Source/modules/mediastream/UserMediaRequest.cpp

@@ -132,7 +132,7 @@ void UserMediaRequest::start()
         m_controller->requestUserMedia(this);
 }
 
-void UserMediaRequest::succeed(PassRefPtr<MediaStreamDescriptor> streamDescriptor)
+void UserMediaRequest::succeed(MediaStreamDescriptor* streamDescriptor)
 {
     if (!executionContext())
         return;

third_party/WebKit/Source/modules/mediastream/UserMediaRequest.h

@@ -58,7 +58,7 @@ public:
 
     void start();
 
-    void succeed(PassRefPtr<MediaStreamDescriptor>);
+    void succeed(MediaStreamDescriptor*);
     void failPermissionDenied(const String& message);
     void failConstraint(const String& constraintName, const String& message);
     void failUASpecific(const String& name, const String& message, const String& constraintName);

third_party/WebKit/Source/modules/webaudio/MediaStreamAudioDestinationNode.cpp

@@ -71,6 +71,7 @@ void MediaStreamAudioDestinationNode::dispose()
 
 void MediaStreamAudioDestinationNode::trace(Visitor* visitor)
 {
+    visitor->trace(m_source);
     visitor->trace(m_stream);
     AudioBasicInspectorNode::trace(visitor);
 }

third_party/WebKit/Source/modules/webaudio/MediaStreamAudioDestinationNode.h

@@ -60,7 +60,7 @@ private:
     virtual bool propagatesSilence() const OVERRIDE { return false; }
 
     Member<MediaStream> m_stream;
-    RefPtr<MediaStreamSource> m_source;
+    Member<MediaStreamSource> m_source;
     RefPtr<AudioBus> m_mixBus;
 };
 

third_party/WebKit/Source/platform/exported/WebMediaStream.cpp

@@ -53,11 +53,6 @@ private:
 
 } // namespace
 
-WebMediaStream::WebMediaStream(const PassRefPtr<MediaStreamDescriptor>& mediaStreamDescriptor)
-    : m_private(mediaStreamDescriptor)
-{
-}
-
 WebMediaStream::WebMediaStream(MediaStreamDescriptor* mediaStreamDescriptor)
     : m_private(mediaStreamDescriptor)
 {
@@ -116,17 +111,12 @@ void WebMediaStream::removeTrack(const WebMediaStreamTrack& track)
     m_private->removeRemoteTrack(track);
 }
 
-WebMediaStream& WebMediaStream::operator=(const PassRefPtr<MediaStreamDescriptor>& mediaStreamDescriptor)
+WebMediaStream& WebMediaStream::operator=(MediaStreamDescriptor* mediaStreamDescriptor)
 {
     m_private = mediaStreamDescriptor;
     return *this;
 }
 
-WebMediaStream::operator PassRefPtr<MediaStreamDescriptor>() const
-{
-    return m_private.get();
-}
-
 WebMediaStream::operator MediaStreamDescriptor*() const
 {
     return m_private.get();

third_party/WebKit/Source/platform/exported/WebMediaStreamSource.cpp

@@ -69,7 +69,7 @@ void WebMediaStreamSource::ExtraData::setOwner(MediaStreamSource* owner)
     m_owner = owner;
 }
 
-WebMediaStreamSource::WebMediaStreamSource(const PassRefPtr<MediaStreamSource>& mediaStreamSource)
+WebMediaStreamSource::WebMediaStreamSource(MediaStreamSource* mediaStreamSource)
     : m_private(mediaStreamSource)
 {
 }
@@ -90,11 +90,6 @@ void WebMediaStreamSource::reset()
     m_private.reset();
 }
 
-WebMediaStreamSource::operator PassRefPtr<MediaStreamSource>() const
-{
-    return m_private.get();
-}
-
 WebMediaStreamSource::operator MediaStreamSource*() const
 {
     return m_private.get();

third_party/WebKit/Source/platform/exported/WebMediaStreamTrack.cpp

@@ -49,23 +49,6 @@ private:
 
 } // namespace
 
-WebMediaStreamTrack WebMediaStreamTrack::ExtraData::owner()
-{
-    ASSERT(m_owner);
-    return WebMediaStreamTrack(m_owner);
-}
-
-void WebMediaStreamTrack::ExtraData::setOwner(MediaStreamComponent* owner)
-{
-    ASSERT(!m_owner);
-    m_owner = owner;
-}
-
-WebMediaStreamTrack::WebMediaStreamTrack(PassRefPtr<MediaStreamComponent> mediaStreamComponent)
-    : m_private(mediaStreamComponent)
-{
-}
-
 WebMediaStreamTrack::WebMediaStreamTrack(MediaStreamComponent* mediaStreamComponent)
     : m_private(mediaStreamComponent)
 {
@@ -92,11 +75,6 @@ void WebMediaStreamTrack::reset()
     m_private.reset();
 }
 
-WebMediaStreamTrack::operator PassRefPtr<MediaStreamComponent>() const
-{
-    return m_private.get();
-}
-
 WebMediaStreamTrack::operator MediaStreamComponent*() const
 {
     return m_private.get();
@@ -131,10 +109,6 @@ WebMediaStreamTrack::ExtraData* WebMediaStreamTrack::extraData() const
 void WebMediaStreamTrack::setExtraData(ExtraData* extraData)
 {
     ASSERT(!m_private.isNull());
-
-    if (extraData)
-        extraData->setOwner(m_private.get());
-
     m_private->setExtraData(adoptPtr(new ExtraDataContainer(adoptPtr(extraData))));
 }
 

third_party/WebKit/Source/platform/mediastream/MediaStreamComponent.cpp

@@ -40,23 +40,56 @@
 
 namespace blink {
 
-PassRefPtr<MediaStreamComponent> MediaStreamComponent::create(PassRefPtr<MediaStreamSource> source)
+MediaStreamComponent* MediaStreamComponent::create(MediaStreamSource* source)
 {
-    return adoptRef(new MediaStreamComponent(createCanonicalUUIDString(), source));
+    return new MediaStreamComponent(createCanonicalUUIDString(), source);
 }
 
-PassRefPtr<MediaStreamComponent> MediaStreamComponent::create(const String& id, PassRefPtr<MediaStreamSource> source)
+MediaStreamComponent* MediaStreamComponent::create(const String& id, MediaStreamSource* source)
 {
-    return adoptRef(new MediaStreamComponent(id, source));
+    return new MediaStreamComponent(id, source);
 }
 
-MediaStreamComponent::MediaStreamComponent(const String& id, PassRefPtr<MediaStreamSource> source)
+// The disposer pattern actually makes the deletion of the extra data happen
+// earlier and not later. The disposer makes sure that the extra data is
+// destructed in weak processing which is run before sweeping and therefore
+// all the objects are still alive and can be touched.
+//
+// FIXME: Oilpan: This disposer pattern is duplicated in a lot of places.
+// We should create a good abstraction class for this and remove the code duplication.
+class MediaStreamComponentDisposer {
+public:
+    explicit MediaStreamComponentDisposer(MediaStreamComponent& component) : m_component(component) { }
+    ~MediaStreamComponentDisposer()
+    {
+        m_component.dispose();
+    }
+
+private:
+    MediaStreamComponent& m_component;
+};
+
+typedef HeapHashMap<WeakMember<MediaStreamComponent>, OwnPtr<MediaStreamComponentDisposer> > ComponentDisposers;
+
+static ComponentDisposers& componentDisposers()
+{
+    DEFINE_STATIC_LOCAL(Persistent<ComponentDisposers>, disposers, (new ComponentDisposers));
+    return *disposers;
+}
+
+MediaStreamComponent::MediaStreamComponent(const String& id, MediaStreamSource* source)
     : m_source(source)
     , m_id(id)
     , m_enabled(true)
     , m_muted(false)
 {
     ASSERT(m_id.length());
+    componentDisposers().add(this, adoptPtr(new MediaStreamComponentDisposer(*this)));
+}
+
+void MediaStreamComponent::dispose()
+{
+    m_extraData = nullptr;
 }
 
 #if ENABLE(WEB_AUDIO)
@@ -88,5 +121,10 @@ void MediaStreamComponent::AudioSourceProviderImpl::provideInput(AudioBus* bus,
 }
 #endif // #if ENABLE(WEB_AUDIO)
 
+void MediaStreamComponent::trace(Visitor* visitor)
+{
+    visitor->trace(m_source);
+}
+
 } // namespace blink
 

third_party/WebKit/Source/platform/mediastream/MediaStreamComponent.h

@@ -33,9 +33,9 @@
 #define MediaStreamComponent_h
 
 #include "platform/audio/AudioSourceProvider.h"
+#include "platform/heap/Handle.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
-#include "wtf/RefCounted.h"
 #include "wtf/ThreadingPrimitives.h"
 #include "wtf/text/WTFString.h"
 
@@ -44,15 +44,15 @@ namespace blink {
 class MediaStreamSource;
 class WebAudioSourceProvider;
 
-class PLATFORM_EXPORT MediaStreamComponent : public RefCounted<MediaStreamComponent> {
+class PLATFORM_EXPORT MediaStreamComponent FINAL : public GarbageCollectedFinalized<MediaStreamComponent> {
 public:
     class ExtraData {
     public:
         virtual ~ExtraData() { }
     };
 
-    static PassRefPtr<MediaStreamComponent> create(PassRefPtr<MediaStreamSource>);
-    static PassRefPtr<MediaStreamComponent> create(const String& id, PassRefPtr<MediaStreamSource>);
+    static MediaStreamComponent* create(MediaStreamSource*);
+    static MediaStreamComponent* create(const String& id, MediaStreamSource*);
 
     MediaStreamSource* source() const { return m_source.get(); }
 
@@ -69,8 +69,11 @@ public:
     ExtraData* extraData() const { return m_extraData.get(); }
     void setExtraData(PassOwnPtr<ExtraData> extraData) { m_extraData = extraData; }
 
+    void trace(Visitor*);
+    void dispose();
+
 private:
-    MediaStreamComponent(const String& id, PassRefPtr<MediaStreamSource>);
+    MediaStreamComponent(const String& id, MediaStreamSource*);
 
 #if ENABLE(WEB_AUDIO)
     // AudioSourceProviderImpl wraps a WebAudioSourceProvider::provideInput()
@@ -99,14 +102,14 @@ private:
     AudioSourceProviderImpl m_sourceProvider;
 #endif // ENABLE(WEB_AUDIO)
 
-    RefPtr<MediaStreamSource> m_source;
+    Member<MediaStreamSource> m_source;
     String m_id;
     bool m_enabled;
     bool m_muted;
     OwnPtr<ExtraData> m_extraData;
 };
 
-typedef Vector<RefPtr<MediaStreamComponent> > MediaStreamComponentVector;
+typedef HeapVector<Member<MediaStreamComponent> > MediaStreamComponentVector;
 
 } // namespace blink
 

third_party/WebKit/Source/platform/mediastream/MediaStreamDescriptor.cpp

@@ -37,22 +37,22 @@
 
 namespace blink {
 
-PassRefPtr<MediaStreamDescriptor> MediaStreamDescriptor::create(const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources)
+MediaStreamDescriptor* MediaStreamDescriptor::create(const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources)
 {
-    return adoptRef(new MediaStreamDescriptor(createCanonicalUUIDString(), audioSources, videoSources));
+    return new MediaStreamDescriptor(createCanonicalUUIDString(), audioSources, videoSources);
 }
 
-PassRefPtr<MediaStreamDescriptor> MediaStreamDescriptor::create(const MediaStreamComponentVector& audioComponents, const MediaStreamComponentVector& videoComponents)
+MediaStreamDescriptor* MediaStreamDescriptor::create(const MediaStreamComponentVector& audioComponents, const MediaStreamComponentVector& videoComponents)
 {
-    return adoptRef(new MediaStreamDescriptor(createCanonicalUUIDString(), audioComponents, videoComponents));
+    return new MediaStreamDescriptor(createCanonicalUUIDString(), audioComponents, videoComponents);
 }
 
-PassRefPtr<MediaStreamDescriptor> MediaStreamDescriptor::create(const String& id, const MediaStreamComponentVector& audioComponents, const MediaStreamComponentVector& videoComponents)
+MediaStreamDescriptor* MediaStreamDescriptor::create(const String& id, const MediaStreamComponentVector& audioComponents, const MediaStreamComponentVector& videoComponents)
 {
-    return adoptRef(new MediaStreamDescriptor(id, audioComponents, videoComponents));
+    return new MediaStreamDescriptor(id, audioComponents, videoComponents);
 }
 
-void MediaStreamDescriptor::addComponent(PassRefPtr<MediaStreamComponent> component)
+void MediaStreamDescriptor::addComponent(MediaStreamComponent* component)
 {
     switch (component->source()->type()) {
     case MediaStreamSource::TypeAudio:
@@ -66,7 +66,7 @@ void MediaStreamDescriptor::addComponent(PassRefPtr<MediaStreamComponent> compon
     }
 }
 
-void MediaStreamDescriptor::removeComponent(PassRefPtr<MediaStreamComponent> component)
+void MediaStreamDescriptor::removeComponent(MediaStreamComponent* component)
 {
     size_t pos = kNotFound;
     switch (component->source()->type()) {
@@ -100,7 +100,7 @@ void MediaStreamDescriptor::removeRemoteTrack(MediaStreamComponent* component)
 }
 
 MediaStreamDescriptor::MediaStreamDescriptor(const String& id, const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources)
-    : m_client(0)
+    : m_client(nullptr)
     , m_id(id)
     , m_ended(false)
 {
@@ -112,8 +112,35 @@ MediaStreamDescriptor::MediaStreamDescriptor(const String& id, const MediaStream
         m_videoComponents.append(MediaStreamComponent::create(videoSources[i]));
 }
 
+// The disposer pattern actually makes the deletion of the extra data happen
+// earlier and not later. The disposer makes sure that the extra data is
+// destructed in weak processing which is run before sweeping and therefore
+// all the objects are still alive and can be touched.
+//
+// FIXME: Oilpan: This disposer pattern is duplicated in a lot of places.
+// We should create a good abstraction class for this and remove the code duplication.
+class MediaStreamDescriptorDisposer {
+public:
+    explicit MediaStreamDescriptorDisposer(MediaStreamDescriptor& descriptor) : m_descriptor(descriptor) { }
+    ~MediaStreamDescriptorDisposer()
+    {
+        m_descriptor.dispose();
+    }
+
+private:
+    MediaStreamDescriptor& m_descriptor;
+};
+
+typedef HeapHashMap<WeakMember<MediaStreamDescriptor>, OwnPtr<MediaStreamDescriptorDisposer> > DescriptorDisposers;
+
+static DescriptorDisposers& descriptorDisposers()
+{
+    DEFINE_STATIC_LOCAL(Persistent<DescriptorDisposers>, disposers, (new DescriptorDisposers));
+    return *disposers;
+}
+
 MediaStreamDescriptor::MediaStreamDescriptor(const String& id, const MediaStreamComponentVector& audioComponents, const MediaStreamComponentVector& videoComponents)
-    : m_client(0)
+    : m_client(nullptr)
     , m_id(id)
     , m_ended(false)
 {
@@ -122,6 +149,19 @@ MediaStreamDescriptor::MediaStreamDescriptor(const String& id, const MediaStream
         m_audioComponents.append((*iter));
     for (MediaStreamComponentVector::const_iterator iter = videoComponents.begin(); iter != videoComponents.end(); ++iter)
         m_videoComponents.append((*iter));
+    descriptorDisposers().add(this, adoptPtr(new MediaStreamDescriptorDisposer(*this)));
+}
+
+void MediaStreamDescriptor::dispose()
+{
+    m_extraData = nullptr;
+}
+
+void MediaStreamDescriptor::trace(Visitor* visitor)
+{
+    visitor->trace(m_audioComponents);
+    visitor->trace(m_videoComponents);
+    visitor->trace(m_client);
 }
 
 } // namespace blink

third_party/WebKit/Source/platform/mediastream/MediaStreamDescriptor.h

@@ -32,24 +32,25 @@
 #ifndef MediaStreamDescriptor_h
 #define MediaStreamDescriptor_h
 
+#include "platform/heap/Handle.h"
 #include "platform/mediastream/MediaStreamComponent.h"
 #include "platform/mediastream/MediaStreamSource.h"
 #include "wtf/PassOwnPtr.h"
-#include "wtf/RefCounted.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
-class MediaStreamDescriptorClient {
+class MediaStreamDescriptorClient : public GarbageCollectedMixin {
 public:
     virtual ~MediaStreamDescriptorClient() { }
 
     virtual void streamEnded() = 0;
     virtual void addRemoteTrack(MediaStreamComponent*) = 0;
     virtual void removeRemoteTrack(MediaStreamComponent*) = 0;
+    virtual void trace(Visitor*) { }
 };
 
-class PLATFORM_EXPORT MediaStreamDescriptor FINAL : public RefCounted<MediaStreamDescriptor> {
+class PLATFORM_EXPORT MediaStreamDescriptor FINAL : public GarbageCollectedFinalized<MediaStreamDescriptor> {
 public:
     class ExtraData {
     public:
@@ -57,11 +58,11 @@ public:
     };
 
     // Only used for AudioDestinationNode.
-    static PassRefPtr<MediaStreamDescriptor> create(const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources);
+    static MediaStreamDescriptor* create(const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources);
 
-    static PassRefPtr<MediaStreamDescriptor> create(const MediaStreamComponentVector& audioComponents, const MediaStreamComponentVector& videoComponents);
+    static MediaStreamDescriptor* create(const MediaStreamComponentVector& audioComponents, const MediaStreamComponentVector& videoComponents);
 
-    static PassRefPtr<MediaStreamDescriptor> create(const String& id, const MediaStreamComponentVector& audioComponents, const MediaStreamComponentVector& videoComponents);
+    static MediaStreamDescriptor* create(const String& id, const MediaStreamComponentVector& audioComponents, const MediaStreamComponentVector& videoComponents);
 
     MediaStreamDescriptorClient* client() const { return m_client; }
     void setClient(MediaStreamDescriptorClient* client) { m_client = client; }
@@ -74,8 +75,8 @@ public:
     unsigned numberOfVideoComponents() const { return m_videoComponents.size(); }
     MediaStreamComponent* videoComponent(unsigned index) const { return m_videoComponents[index].get(); }
 
-    void addComponent(PassRefPtr<MediaStreamComponent>);
-    void removeComponent(PassRefPtr<MediaStreamComponent>);
+    void addComponent(MediaStreamComponent*);
+    void removeComponent(MediaStreamComponent*);
 
     void addRemoteTrack(MediaStreamComponent*);
     void removeRemoteTrack(MediaStreamComponent*);
@@ -86,21 +87,22 @@ public:
     ExtraData* extraData() const { return m_extraData.get(); }
     void setExtraData(PassOwnPtr<ExtraData> extraData) { m_extraData = extraData; }
 
+    void trace(Visitor*);
+    void dispose();
+
 private:
     MediaStreamDescriptor(const String& id, const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources);
     MediaStreamDescriptor(const String& id, const MediaStreamComponentVector& audioComponents, const MediaStreamComponentVector& videoComponents);
 
-    MediaStreamDescriptorClient* m_client;
+    Member<MediaStreamDescriptorClient> m_client;
     String m_id;
-    Vector<RefPtr<MediaStreamComponent> > m_audioComponents;
-    Vector<RefPtr<MediaStreamComponent> > m_videoComponents;
+    MediaStreamComponentVector m_audioComponents;
+    MediaStreamComponentVector m_videoComponents;
     bool m_ended;
 
     OwnPtr<ExtraData> m_extraData;
 };
 
-typedef Vector<RefPtr<MediaStreamDescriptor> > MediaStreamDescriptorVector;
-
 } // namespace blink
 
 #endif // MediaStreamDescriptor_h

third_party/WebKit/Source/platform/mediastream/MediaStreamSource.cpp

@@ -34,9 +34,36 @@
 
 namespace blink {
 
-PassRefPtr<MediaStreamSource> MediaStreamSource::create(const String& id, Type type, const String& name, ReadyState readyState, bool requiresConsumer)
+// The disposer pattern actually makes the deletion of the extra data happen
+// earlier and not later. The disposer makes sure that the extra data is
+// destructed in weak processing which is run before sweeping and therefore
+// all the objects are still alive and can be touched.
+//
+// FIXME: Oilpan: This disposer pattern is duplicated in a lot of places.
+// We should create a good abstraction class for this and remove the code duplication.
+class MediaStreamSourceDisposer {
+public:
+    explicit MediaStreamSourceDisposer(MediaStreamSource& source) : m_source(source) { }
+    ~MediaStreamSourceDisposer()
+    {
+        m_source.dispose();
+    }
+
+private:
+    MediaStreamSource& m_source;
+};
+
+typedef HeapHashMap<WeakMember<MediaStreamSource>, OwnPtr<MediaStreamSourceDisposer> > SourceDisposers;
+
+static SourceDisposers& sourceDisposers()
 {
-    return adoptRef(new MediaStreamSource(id, type, name, readyState, requiresConsumer));
+    DEFINE_STATIC_LOCAL(Persistent<SourceDisposers>, disposers, (new SourceDisposers));
+    return *disposers;
+}
+
+MediaStreamSource* MediaStreamSource::create(const String& id, Type type, const String& name, ReadyState readyState, bool requiresConsumer)
+{
+    return new MediaStreamSource(id, type, name, readyState, requiresConsumer);
 }
 
 MediaStreamSource::MediaStreamSource(const String& id, Type type, const String& name, ReadyState readyState, bool requiresConsumer)
@@ -46,27 +73,27 @@ MediaStreamSource::MediaStreamSource(const String& id, Type type, const String&
     , m_readyState(readyState)
     , m_requiresConsumer(requiresConsumer)
 {
+    sourceDisposers().add(this, adoptPtr(new MediaStreamSourceDisposer(*this)));
+}
+
+void MediaStreamSource::dispose()
+{
+    m_extraData = nullptr;
 }
 
 void MediaStreamSource::setReadyState(ReadyState readyState)
 {
     if (m_readyState != ReadyStateEnded && m_readyState != readyState) {
         m_readyState = readyState;
-        for (Vector<Observer*>::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
+        for (HeapHashSet<WeakMember<Observer> >::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
             (*i)->sourceChangedState();
     }
 }
 
 void MediaStreamSource::addObserver(MediaStreamSource::Observer* observer)
 {
-    m_observers.append(observer);
-}
-
-void MediaStreamSource::removeObserver(MediaStreamSource::Observer* observer)
-{
-    size_t pos = m_observers.find(observer);
-    if (pos != kNotFound)
-        m_observers.remove(pos);
+    ASSERT(!m_observers.contains(observer));
+    m_observers.add(observer);
 }
 
 void MediaStreamSource::addAudioConsumer(AudioDestinationConsumer* consumer)
@@ -103,4 +130,11 @@ void MediaStreamSource::consumeAudio(AudioBus* bus, size_t numberOfFrames)
         (*it)->consumeAudio(bus, numberOfFrames);
 }
 
+void MediaStreamSource::trace(Visitor* visitor)
+{
+    visitor->trace(m_observers);
+    visitor->trace(m_audioConsumers);
+}
+
 } // namespace blink
+

third_party/WebKit/Source/platform/mediastream/MediaStreamSource.h

@@ -34,22 +34,23 @@
 
 #include "platform/PlatformExport.h"
 #include "platform/audio/AudioDestinationConsumer.h"
+#include "platform/heap/Handle.h"
 #include "public/platform/WebMediaConstraints.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
-#include "wtf/RefCounted.h"
 #include "wtf/ThreadingPrimitives.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
-class PLATFORM_EXPORT MediaStreamSource FINAL : public RefCounted<MediaStreamSource> {
+class PLATFORM_EXPORT MediaStreamSource FINAL : public GarbageCollectedFinalized<MediaStreamSource> {
 public:
-    class Observer {
+    class Observer : public GarbageCollectedMixin {
     public:
         virtual ~Observer() { }
         virtual void sourceChangedState() = 0;
+        virtual void trace(Visitor*) { }
     };
 
     class ExtraData {
@@ -68,7 +69,7 @@ public:
         ReadyStateEnded = 2
     };
 
-    static PassRefPtr<MediaStreamSource> create(const String& id, Type, const String& name, ReadyState = ReadyStateLive, bool requiresConsumer = false);
+    static MediaStreamSource* create(const String& id, Type, const String& name, ReadyState = ReadyStateLive, bool requiresConsumer = false);
 
     const String& id() const { return m_id; }
     Type type() const { return m_type; }
@@ -94,6 +95,9 @@ public:
     bool removeAudioConsumer(AudioDestinationConsumer*);
     const HeapHashSet<Member<AudioDestinationConsumer> >& audioConsumers() { return m_audioConsumers; }
 
+    void trace(Visitor*);
+    void dispose();
+
 private:
     MediaStreamSource(const String& id, Type, const String& name, ReadyState, bool requiresConsumer);
 
@@ -102,14 +106,14 @@ private:
     String m_name;
     ReadyState m_readyState;
     bool m_requiresConsumer;
-    Vector<Observer*> m_observers;
+    HeapHashSet<WeakMember<Observer> > m_observers;
     Mutex m_audioConsumersLock;
-    PersistentHeapHashSet<Member<AudioDestinationConsumer> > m_audioConsumers;
+    HeapHashSet<Member<AudioDestinationConsumer> > m_audioConsumers;
     OwnPtr<ExtraData> m_extraData;
     blink::WebMediaConstraints m_constraints;
 };
 
-typedef Vector<RefPtr<MediaStreamSource> > MediaStreamSourceVector;
+typedef HeapVector<Member<MediaStreamSource> > MediaStreamSourceVector;
 
 } // namespace blink
 

third_party/WebKit/public/platform/WebMediaStream.h

@@ -79,10 +79,8 @@ public:
 
 #if INSIDE_BLINK
     BLINK_PLATFORM_EXPORT WebMediaStream(MediaStreamDescriptor*);
-    BLINK_PLATFORM_EXPORT WebMediaStream(const WTF::PassRefPtr<MediaStreamDescriptor>&);
-    BLINK_PLATFORM_EXPORT operator WTF::PassRefPtr<MediaStreamDescriptor>() const;
     BLINK_PLATFORM_EXPORT operator MediaStreamDescriptor*() const;
-    BLINK_PLATFORM_EXPORT WebMediaStream& operator=(const WTF::PassRefPtr<MediaStreamDescriptor>&);
+    BLINK_PLATFORM_EXPORT WebMediaStream& operator=(MediaStreamDescriptor*);
 #endif
 
 private:

third_party/WebKit/public/platform/WebMediaStreamSource.h

@@ -35,6 +35,9 @@
 #include "WebNonCopyable.h"
 #include "WebPrivatePtr.h"
 #include "WebVector.h"
+#if INSIDE_BLINK
+#include "platform/heap/Handle.h"
+#endif
 
 namespace blink {
 
@@ -57,6 +60,9 @@ public:
 #endif
 
     private:
+#if INSIDE_BLINK
+        GC_PLUGIN_IGNORE("http://crbug.com/409526")
+#endif
         MediaStreamSource* m_owner;
     };
 
@@ -111,9 +117,8 @@ public:
     BLINK_PLATFORM_EXPORT bool removeAudioConsumer(WebAudioDestinationConsumer*);
 
 #if INSIDE_BLINK
-    BLINK_PLATFORM_EXPORT WebMediaStreamSource(const WTF::PassRefPtr<MediaStreamSource>&);
+    BLINK_PLATFORM_EXPORT WebMediaStreamSource(MediaStreamSource*);
     BLINK_PLATFORM_EXPORT WebMediaStreamSource& operator=(MediaStreamSource*);
-    BLINK_PLATFORM_EXPORT operator WTF::PassRefPtr<MediaStreamSource>() const;
     BLINK_PLATFORM_EXPORT operator MediaStreamSource*() const;
 #endif
 

third_party/WebKit/public/platform/WebMediaStreamTrack.h

@@ -41,17 +41,8 @@ class WebMediaStreamTrack {
 public:
     class ExtraData {
     public:
-        ExtraData() : m_owner(0) { }
+        ExtraData() { }
         virtual ~ExtraData() { }
-
-        BLINK_PLATFORM_EXPORT WebMediaStreamTrack owner();
-
-#if INSIDE_BLINK
-        BLINK_PLATFORM_EXPORT void setOwner(MediaStreamComponent*);
-#endif
-
-    private:
-        MediaStreamComponent* m_owner;
     };
 
     WebMediaStreamTrack() { }
@@ -89,10 +80,8 @@ public:
     BLINK_PLATFORM_EXPORT void setSourceProvider(WebAudioSourceProvider*);
 
 #if INSIDE_BLINK
-    BLINK_PLATFORM_EXPORT WebMediaStreamTrack(PassRefPtr<MediaStreamComponent>);
     BLINK_PLATFORM_EXPORT WebMediaStreamTrack(MediaStreamComponent*);
     BLINK_PLATFORM_EXPORT WebMediaStreamTrack& operator=(MediaStreamComponent*);
-    BLINK_PLATFORM_EXPORT operator WTF::PassRefPtr<MediaStreamComponent>() const;
     BLINK_PLATFORM_EXPORT operator MediaStreamComponent*() const;
 #endif