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..cb19ab4d45970663f5260998791287c3edf329c7
--- /dev/null
+++ b/Source/core/html/track/TrackListBase.h
@@ -0,0 +1,136 @@
+// 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 {

[haraken, 2014/06/12 01:22:07]

Now that EventTarget is on-heap, this can be
RefCountedwillBeGarbageCollectedFinalized.

+    REFCOUNTED_EVENT_TARGET(TrackListBase);

[haraken, 2014/06/12 01:22:07]

Then you need to change this to
DEFINE_EVENT_TARGET_REFCOUNTING(GarbageCollectedFinalized<TrackListBase>).

+    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(TrackListBase);
+public:
+    explicit TrackListBase(HTMLMediaElement* mediaElement)
+        : m_mediaElement(mediaElement)
+    {
+    }
+
+    virtual ~TrackListBase()
+    {
+#if !ENABLE(OILPAN)
+        ASSERT(m_tracks.isEmpty());
+        ASSERT(!m_mediaElement);
+#endif
+    }
+
+    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();
+        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()

[haraken, 2014/06/12 01:22:07]

Can we add #if !ENABLE(OILPAN) to this method?

[philipj_slow, 2014/06/12 13:22:47]

Actually no, because it's called from
HTMLMediaElement::forgetResourceSpecificTracks() regardless of oilpan.

+    {
+        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);
+        EventTargetWithInlineData::trace(visitor);
+    }
+
+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