Implement AudioTrack, AudioTrackList, VideoTrack, and VideoTrackList

Source/core/html/track/TrackListBase.h

Index: Source/core/html/track/TrackListBase.h
diff --git a/Source/core/html/track/TrackListBase.h b/Source/core/html/track/TrackListBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..6dd13757976f9f2002c0f9872947ff920f445b6b
--- /dev/null
+++ b/Source/core/html/track/TrackListBase.h
@@ -0,0 +1,133 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef TrackListBase_h
+#define TrackListBase_h
+
+#include "core/events/EventTarget.h"
+
+#include "core/html/HTMLMediaElement.h"
+#include "core/html/track/TrackEvent.h"
+
+namespace WebCore {
+
+template<class T>
+class TrackListBase : public RefCountedWillBeRefCountedGarbageCollected<TrackListBase<T> >, public EventTargetWithInlineData {
+    DEFINE_EVENT_TARGET_REFCOUNTING(RefCountedWillBeRefCountedGarbageCollected<TrackListBase<T> >);

[haraken, 2014/06/03 05:48:29]

You can use REFCOUNTED_EVENT_TARGET(TrackListBase).

I guess you also need to specify
WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(TrackListBase) (because
EventTargetWithInlineData is a GarbageCollectedMixin and thus needs to be
traced).

class A : public RefCountedWillBeGarbageCollected<A>, public B {
WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(B); // You need this if B is a
GarbageCollectedMixin.
};

[philipj_slow, 2014/06/11 10:03:48]

Done.

+
+public:
+    explicit TrackListBase(HTMLMediaElement* mediaElement)
+        : m_mediaElement(mediaElement)
+    {
+    }
+
+    virtual ~TrackListBase()
+    {
+        ASSERT(m_tracks.isEmpty());

[haraken, 2014/06/03 05:48:29]

I don't think this holds in oilpan builds, because you don't call removeAll() in
oilpan builds.

[philipj_slow, 2014/06/11 10:03:48]

Done.

+        ASSERT(!m_mediaElement);

[haraken, 2014/06/03 05:48:29]

Ditto. This won't hold in oilpan builds, because you don't call shutdown() in
oilpan builds.

+    }
+
+    unsigned length() const { return m_tracks.size(); }
+    T* anonymousIndexedGetter(unsigned index) const
+    {
+        if (index >= m_tracks.size())
+            return 0;
+        return m_tracks[index].get();
+    }
+
+    T* getTrackById(const String& id) const
+    {
+        for (unsigned i = 0; i < m_tracks.size(); ++i) {
+            if (m_tracks[i]->id() == id)
+                return m_tracks[i].get();
+        }
+
+        return 0;
+    }
+
+    DEFINE_ATTRIBUTE_EVENT_LISTENER(change);
+    DEFINE_ATTRIBUTE_EVENT_LISTENER(addtrack);
+    DEFINE_ATTRIBUTE_EVENT_LISTENER(removetrack);
+
+    // EventTarget interface
+    virtual ExecutionContext* executionContext() const OVERRIDE
+    {
+        if (m_mediaElement)
+            return m_mediaElement->executionContext();
+        return 0;
+    }
+
+#if !ENABLE(OILPAN)
+    void shutdown()
+    {
+        removeAll();

[acolwell GONE FROM CHROMIUM, 2014/06/02 20:28:14]

I believe you should be able to assert m_tracks.isEmpty() here and can remove
the removeAll() call. If not, then there is likely a bug somewhere because
OILPAN & non-OILPAN builds will act differently if JS is holding a reference to
the list when this gets called.

[philipj_slow, 2014/06/11 12:48:15]

shutdown() is called from ~HTMLMediaElement() and I think that there will be
tracks here in the normal case. Am I misunderstanding something? I think there
are GC-related bugs in here just as with TextTrack and TextTrackList, and I've
been meaning to add the test cases to expose them.

+        m_mediaElement = nullptr;
+    }
+#endif
+
+    void add(PassRefPtrWillBeRawPtr<T> prpTrack)
+    {
+        RefPtrWillBeRawPtr<T> track = prpTrack;
+
+        track->setMediaElement(m_mediaElement);
+        m_tracks.append(track);
+        scheduleTrackEvent(EventTypeNames::addtrack, track.release());
+    }
+
+    void remove(blink::WebMediaPlayer::TrackId trackId)
+    {
+        for (unsigned i = 0; i < m_tracks.size(); ++i) {
+            if (m_tracks[i]->trackId() != trackId)
+                continue;
+
+            m_tracks[i]->setMediaElement(0);
+            scheduleTrackEvent(EventTypeNames::removetrack, m_tracks[i]);
+            m_tracks.remove(i);
+            return;
+        }
+    }
+
+    void removeAll()
+    {
+        for (unsigned i = 0; i < m_tracks.size(); ++i)
+            m_tracks[i]->setMediaElement(0);
+
+        m_tracks.clear();
+    }
+
+    void scheduleChangeEvent()
+    {
+        EventInit initializer;
+        initializer.bubbles = false;
+        initializer.cancelable = false;
+        RefPtrWillBeRawPtr<Event> event = Event::create(EventTypeNames::change, initializer);
+        event->setTarget(this);
+        m_mediaElement->scheduleEvent(event);
+    }
+
+    void trace(Visitor* visitor)
+    {
+        visitor->trace(m_tracks);
+        visitor->trace(m_mediaElement);
+    }
+
+private:
+    void scheduleTrackEvent(const AtomicString& eventName, PassRefPtrWillBeRawPtr<T> track)
+    {
+        TrackEventInit initializer;
+        initializer.track = track;
+        initializer.bubbles = false;
+        initializer.cancelable = false;
+        RefPtrWillBeRawPtr<Event> event = TrackEvent::create(eventName, initializer);
+        event->setTarget(this);
+        m_mediaElement->scheduleEvent(event);
+    }
+
+    WillBeHeapVector<RefPtrWillBeMember<T> > m_tracks;
+    RawPtrWillBeMember<HTMLMediaElement> m_mediaElement;
+};
+
+}
+
+#endif