Move mediastream module to oilpan transition types

Source/modules/mediastream/MediaStreamTrack.h

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  * Copyright (C) 2011 Ericsson AB. 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 27 matching lines @@
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 
 namespace WebCore {
 
 class AudioSourceProvider;
 class ExceptionState;
 class MediaStreamComponent;
 class MediaStreamTrackSourcesCallback;
 
-class MediaStreamTrack FINAL : public RefCounted<MediaStreamTrack>, public ScriptWrappable, public ActiveDOMObject, public EventTargetWithInlineData, public MediaStreamSource::Observer {
-    REFCOUNTED_EVENT_TARGET(MediaStreamTrack);
+class MediaStreamTrack FINAL : public RefCountedWillBeRefCountedGarbageCollected<MediaStreamTrack>, public ScriptWrappable, public ActiveDOMObject, public EventTargetWithInlineData, public MediaStreamSource::Observer {
+    DEFINE_EVENT_TARGET_REFCOUNTING(RefCountedWillBeRefCountedGarbageCollected<MediaStreamTrack>);
 public:
-    class Observer {
-    public:
-        virtual ~Observer() { }
-        virtual void trackEnded() = 0;
-    };
-
-    static PassRefPtr<MediaStreamTrack> create(ExecutionContext*, MediaStreamComponent*);
+    static PassRefPtrWillBeRawPtr<MediaStreamTrack> create(ExecutionContext*, MediaStreamComponent*);
     virtual ~MediaStreamTrack();
 
     String kind() const;
     String id() const;
     String label() const;
 
     bool enabled() const;
     void setEnabled(bool);
 
     String readyState() const;
 
     static void getSources(ExecutionContext*, PassOwnPtr<MediaStreamTrackSourcesCallback>, ExceptionState&);
     void stopTrack(ExceptionState&);
-    PassRefPtr<MediaStreamTrack> clone(ExecutionContext*);
+    PassRefPtrWillBeRawPtr<MediaStreamTrack> clone(ExecutionContext*);
 
     DEFINE_ATTRIBUTE_EVENT_LISTENER(mute);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(unmute);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(ended);
 
     MediaStreamComponent* component();
     bool ended() const;
 
-    void addObserver(Observer*);
-    void removeObserver(Observer*);
+    void registerMediaStream(MediaStream*);
+    void unregisterMediaStream(MediaStream*);
 
     // EventTarget
     virtual const AtomicString& interfaceName() const OVERRIDE;
     virtual ExecutionContext* executionContext() const OVERRIDE;
 
     // ActiveDOMObject
     virtual void stop() OVERRIDE;
 
     PassOwnPtr<AudioSourceProvider> createWebAudioSource();
 
+    void trace(Visitor*) { }
+
 private:
     MediaStreamTrack(ExecutionContext*, MediaStreamComponent*);
 
     MediaStreamSource::ReadyState m_readyState;
 
     // MediaStreamSourceObserver
     virtual void sourceChangedState() OVERRIDE;
 
     void propagateTrackEnded();
-    Vector<Observer*> m_observers;
-    bool m_isIteratingObservers;
+    Vector<RawPtrWillBeWeakMember<MediaStream> > m_registeredMediaStreams;

[haraken, 2014/04/14 04:42:43]

This should be WillBeHeapVector. And trace it.

[keishi, 2014/04/14 05:56:17]

I'm getting build errors because there is a compile assert
WeDontSupportWeaknessInHeapVectorsOrDeques. How should this be handled?

[haraken, 2014/04/14 06:05:49]

Yes, we intentionally don't support weakness in vectors, because just clearing
out weakened entries in a vector won't give you expected behavior.

Can you use a WillBeHashSet<RawPtrWillBeWeakMember<MediaStream>> ?

[Erik Corry, 2014/04/14 09:10:35]

It depends rather on what you want to happen when the weak pointers are deleted.
 Does the rest of the vector just move down, or are there null entries in the
vector. We don't know the answer, and both could give null pointer crashes if
the weak processing happens at an unexpected time, so we don't support weakness
in vectors at the moment.  If a consensus arises about how we want vectors to
behave with weakness we might introduce support.

I haven't landed HeapLinkedHashSet yet, but that provides a hashset that
preserves order and can handle weakness. That may be what you need.

[haraken, 2014/04/14 09:27:57]

Does the order matters for m_registeredMediaStreams? If the order doesn't
matter, I guess you can simply use HeapHashSet<WeakMember>.

[keishi, 2014/04/21 07:14:40]

I've looked into the usage and it seams like this can be HeapHashSet<WeakMember>

+    bool m_isIteratingRegisteredMediaStreams;
 
     bool m_stopped;
     RefPtr<MediaStreamComponent> m_component;
 };
 
-typedef Vector<RefPtr<MediaStreamTrack> > MediaStreamTrackVector;
+typedef WillBeHeapVector<RefPtrWillBeMember<MediaStreamTrack> > MediaStreamTrackVector;
 
 } // namespace WebCore
 
 #endif // MediaStreamTrack_h