Implement AudioTrack, AudioTrackList, VideoTrack, and VideoTrackList

Source/core/html/track/TrackListBase.h

+// 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 RefCounted<TrackListBase<T> >, public EventTargetWithInlineData {
+    REFCOUNTED_EVENT_TARGET(TrackListBase<T>);
+
+public:
+    explicit TrackListBase(HTMLMediaElement* mediaElement)
+        : m_mediaElement(mediaElement)
+    {
+    }
+
+    virtual ~TrackListBase()
+    {
+        ASSERT(m_tracks.isEmpty());
+        ASSERT(!m_mediaElement);
+    }
+
+    unsigned length() const { return m_tracks.size(); }
+    PassRefPtr<T> anonymousIndexedGetter(unsigned index) const
+    {
+        if (index >= m_tracks.size())
+            return nullptr;
+        return m_tracks[index];
+    }
+
+    PassRefPtr<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];
+        }
+
+        return nullptr;
+    }
+
+    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;
+    }
+
+    void shutdown()
+    {
+        removeAll();
+        m_mediaElement = 0;
+    }
+
+    void add(PassRefPtr<T> track)
+    {
+        ASSERT(track);
+        m_tracks.append(track.get());
+        scheduleTrackEvent(EventTypeNames::addtrack, track);
+    }
+
+    void remove(const String& id)
+    {
+        for (unsigned i = 0; i < m_tracks.size(); ++i) {
+            if (m_tracks[i]->id() != id)
+                continue;
+
+            m_tracks[i]->setMediaElement(0);

[acolwell GONE FROM CHROMIUM, 2014/05/12 18:23:11]

Any reason not to make add() symmetrical with this? The idea being that the
track is associated with the mediaElement, when it is added to the list. If you
did this, I think you could add ASSERT(!m_mediaElement) to the xxxTrack
destructor to verify that whatever set the attribute also cleared it.

[philipj_slow, 2014/05/15 14:55:53]

Yeah, that sounds like a good idea. ~TrackBase() does ASSERT(!m_mediaElement),
so the assumption is already there.

+            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;
+        RefPtr<Event> event = Event::create(EventTypeNames::change, initializer);
+        event->setTarget(this);
+        m_mediaElement->scheduleEvent(event);
+    }
+
+private:
+    void scheduleTrackEvent(const AtomicString& eventName, PassRefPtr<T> track)
+    {
+        TrackEventInit initializer;
+        initializer.track = track;
+        initializer.bubbles = false;
+        initializer.cancelable = false;
+        RefPtr<Event> event = TrackEvent::create(eventName, initializer);
+        event->setTarget(this);
+        m_mediaElement->scheduleEvent(event);
+    }
+
+    Vector<RefPtr<T> > m_tracks;
+    HTMLMediaElement* m_mediaElement;
+};
+
+}
+
+#endif