Oilpan: have MediaController weakly refer to its media elements.

Source/core/html/MediaController.h

 /*
  * Copyright (C) 2011 Apple 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 11 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef MediaController_h
 #define MediaController_h
 
 #include "bindings/v8/ScriptWrappable.h"
 #include "core/events/EventTarget.h"
 #include "core/html/HTMLMediaElement.h"
+#include "wtf/LinkedHashSet.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
-#include "wtf/Vector.h"
 
 namespace WebCore {
 
 class Clock;
 class ExceptionState;
 class ExecutionContext;
 class GenericEventQueue;
 
 class MediaController FINAL : public RefCountedWillBeRefCountedGarbageCollected<MediaController>, public ScriptWrappable, public EventTargetWithInlineData {
     REFCOUNTED_EVENT_TARGET(MediaController);
@@ skipping 34 matching lines @@
     ReadyState readyState() const { return m_readyState; }
 
     enum PlaybackState { WAITING, PLAYING, ENDED };
     const AtomicString& playbackState() const;
 
     bool isRestrained() const;
     bool isBlocked() const;
 
     void clearExecutionContext() { m_executionContext = 0; }
 
+    virtual void trace(Visitor*) OVERRIDE;
+
 private:
     MediaController(ExecutionContext*);
     void reportControllerState();
     void updateReadyState();
     void updatePlaybackState();
     void updateMediaElements();
     void bringElementUpToSpeed(HTMLMediaElement*);
     void scheduleEvent(const AtomicString& eventName);
     void clearPositionTimerFired(Timer<MediaController>*);
     bool hasEnded() const;
     void scheduleTimeupdateEvent();
     void timeupdateTimerFired(Timer<MediaController>*);
     void startTimeupdateTimer();
 
     // EventTarget
     virtual const AtomicString& interfaceName() const OVERRIDE;
     virtual ExecutionContext* executionContext() const OVERRIDE { return m_executionContext; }
 
     friend class HTMLMediaElement;
     friend class MediaControllerEventListener;
-    Vector<HTMLMediaElement*> m_mediaElements;
+    typedef WillBeHeapLinkedHashSet<RawPtrWillBeWeakMember<HTMLMediaElement> > MediaElementSequence;

[acolwell GONE FROM CHROMIUM, 2014/06/07 00:04:50]

I'm a little fuzzy on these Oilpan types. If you use this, does this mean that
media elements can disappear from this list if the JavaScript application
doesn't have any references to the elements and they aren't in the document, but
JavaScript DOES have a reference to this controller? If so, then I think that
might be bad. 

Say I have several audio elements I want to control with the same controller,
but don't really need them in the document. Conceptually I should be able to
just hold onto the controller and still control the media elements eventhough
they have gone out of scope. I think the web developer might be surprised if
these elements disappear.

[haraken, 2014/06/07 03:59:00]

Your understanding is correct.

If you want to keep the media elements alive while the controller is alive, we
can use HeapLinkedHashSet<Member<HTMLMediaElement>>. In fact, we _do_ want to do
that because we don't want to use weak members as much as possible. However, as
far as I understand the current code, the media elements are not kept alive
while the controller is alive, so we used
HeapLinkedHashSet<WeakMember<HTMLMediaElement>> to keep the current behavior.

In short, if you're happy with keeping the media elements alive while the
controller is alive, we're very happy to make the change :)

[sof, 2014/06/07 05:33:30]

Comments #5 and #6 touch on what the spec promises to be the behavior -- we're
not able to locate much on a slaved element's guaranteed lifetime (other than
the lifetime of such an audio element is mentioned elsewhere as needing to stay
around when detached from the document, if still playing.)

Might it be better to wait with doing this change until/if Oilpan is the
default? Otherwise you have behavioral differences across the setting of
enable_oilpan.

+    MediaElementSequence m_mediaElements;
     bool m_paused;
     double m_defaultPlaybackRate;
     double m_volume;
     mutable double m_position;
     bool m_muted;
     ReadyState m_readyState;
     PlaybackState m_playbackState;
     OwnPtr<GenericEventQueue> m_pendingEventsQueue;
     mutable Timer<MediaController> m_clearPositionTimer;
     OwnPtr<Clock> m_clock;
     ExecutionContext* m_executionContext;
     Timer<MediaController> m_timeupdateTimer;
     double m_previousTimeupdateTime;
 };
 
 } // namespace WebCore
 
 #endif