Attachment #101679 for bug #62883

View Details Raw Unified Return to Bug 62883

| Differences between



2011-07-21  Anna Cavender  <annacc@chromium.org>

        Storage of TextTrackCues for efficient retrieval during playback.
        https://bugs.webkit.org/show_bug.cgi?id=62883

        Reviewed by NOBODY (OOPS!).

        No new tests because feature is hidden behind VIDEO_TRACK feature
        define, which is turned off.

        * html/CueIndex.cpp:
        * html/CueIndex.h:
        * html/HTMLMediaElement.cpp:
        * html/HTMLMediaElement.h:
        * html/HTMLTrackElement.cpp:
        * html/HTMLTrackElement.h:
        * html/LoadableTextTrack.cpp:
        * html/LoadableTextTrack.h:
        * html/TextTrack.h:
        * html/TextTrackCueList.cpp:
        * html/TextTrackCueList.h:
        * platform/track/CueParser.cpp:
        * platform/track/CueParser.h:
        * platform/track/CueParserPrivate.h:

2011-07-21  Pavel Feldman  <pfeldman@google.com>

        Not reviewed: one liner typo fix in Inspector.json.




namespace WebCore {

CueSet CueSet::difference(const CueSet& other) const
{
    CueSet newSet;
    for (CueSet::Iterator it = other.m_set.begin(); it != other.m_set.end(); ++it) {
        TextTrackCue* cue = *it;
        if (!m_set.contains(cue))
            newSet.add(*cue);
    }
    return newSet;
}

CueSet CueSet::unionSet(const CueSet& other) const
{
    CueSet newSet;
    for (CueSet::Iterator it = other.m_set.begin(); it != other.m_set.end(); ++it) {
        TextTrackCue* cue = *it;
        newSet.add(*cue);
    }
    for (CueSet::Iterator it = m_set.begin(); it != m_set.end(); ++it) {
        TextTrackCue* cue = *it;
        newSet.add(*cue);
    }
    return newSet;
}

void CueSet::add(const TextTrackCue& cue)
{
    m_set.add(const_cast<TextTrackCue*>(&cue));
}

bool CueSet::contains(const TextTrackCue& cue) const
{
    return m_set.contains(const_cast<TextTrackCue*>(&cue));
    return false;
}

void CueSet::remove(const TextTrackCue& cue)
{
    m_set.remove(const_cast<TextTrackCue*>(&cue));
}

void CueSet::clear()
{
    m_set.clear();
}

bool CueSet::isEmpty() const
{
    return m_set.isEmpty();
    return false;
}

int CueSet::size() const
{
    return m_set.size();
}

CueSet::Iterator CueSet::begin() const
{
    return m_set.begin();
}

CueSet::Iterator CueSet::end() const
{
    return m_set.end();
}

void CueIndex::fetchNewCuesFromLoader(CueLoader* loader)
{
    Vector<TextTrackCue*> newCues;
    loader->fetchNewestCues(newCues);
    for (size_t i = 0; i < newCues.size(); ++i)
        add(newCues[i]);
}

void CueIndex::removeCuesFromIndex(const TextTrackCueList* cueList)
{
    for (size_t i = 0; i < cueList->length(); ++i)
        remove(cueList->item(i));
}

CueSet CueIndex::visibleCuesAtTime(double) const

    return CueSet();
}

void CueIndex::add(TextTrackCue* cue)
{
    add(cue, 0, m_cuesByStartTime.size());
}

void CueIndex::add(TextTrackCue* cue, size_t start, size_t end)
{
    if (start == end) {
       m_cuesByStartTime.insert(start, cue);
       return;
    }

    size_t index = (start + end) / 2;
    if (cue->startTime() < m_cuesByStartTime[index]->startTime()
        || (cue->startTime() == m_cuesByStartTime[index]->startTime()
        && cue->endTime() < m_cuesByStartTime[index]->endTime()))
        add(cue, start, index);
    else
        add(cue, index + 1, end);
}

void CueIndex::remove(TextTrackCue* cue)
{
    size_t index = m_cuesByStartTime.find(cue);
    if (index != notFound)
        m_cuesByStartTime.remove(index);
}

} // namespace WebCore

Lines 29-34 a/Source/WebCore/html/CueIndex.h_sec1
- a/Source/WebCore/html/CueIndex.h +11 lines
29	#if ENABLE(VIDEO_TRACK)	29	#if ENABLE(VIDEO_TRACK)
30		30
31	#include "CueLoader.h"	31	#include "CueLoader.h"
		32	#include "TextTrackCue.h"
32	#include <wtf/HashSet.h>	33	#include <wtf/HashSet.h>
33		34
34	namespace WebCore {	35	namespace WebCore {
Lines 38-43 class TextTrackCueList; a/Source/WebCore/html/CueIndex.h_sec2
38		39
39	class CueSet {	40	class CueSet {
40	public:	41	public:
		42	typedef HashSet<TextTrackCue*>::iterator Iterator;
41	CueSet() { }	43	CueSet() { }
42	~CueSet() { }	44	~CueSet() { }
43	CueSet difference(const CueSet&) const;	45	CueSet difference(const CueSet&) const;
Lines 45-52 public: a/Source/WebCore/html/CueIndex.h_sec3
45	void add(const TextTrackCue&);	47	void add(const TextTrackCue&);
46	bool contains(const TextTrackCue&) const;	48	bool contains(const TextTrackCue&) const;
47	void remove(const TextTrackCue&);	49	void remove(const TextTrackCue&);
		50	void clear();
48	bool isEmpty() const;	51	bool isEmpty() const;
49	int size() const;	52	int size() const;
		53	Iterator begin() const;
		54	Iterator end() const;
		55
50	private:	56	private:
51	HashSet<TextTrackCue*> m_set;	57	HashSet<TextTrackCue*> m_set;
52	};	58	};
Lines 61-66 public: a/Source/WebCore/html/CueIndex.h_sec4
61	CueSet visibleCuesAtTime(double) const;	67	CueSet visibleCuesAtTime(double) const;
62	void add(TextTrackCue*);	68	void add(TextTrackCue*);
63	void remove(TextTrackCue*);	69	void remove(TextTrackCue*);
		70
		71	private:
		72	void add(TextTrackCue*, size_t start, size_t end);
		73
		74	Vector<TextTrackCue*> m_cuesByStartTime;
64	};	75	};
65		76
66	} // namespace WebCore	77	} // namespace WebCore

Lines 793-799 void HTMLMediaElement::loadTextTracks() a/Source/WebCore/html/HTMLMediaElement.cpp_sec1
- a/Source/WebCore/html/HTMLMediaElement.cpp -1 / +1 lines
793	for (Node* node = firstChild(); node; node = node->nextSibling()) {	793	for (Node* node = firstChild(); node; node = node->nextSibling()) {
794	if (node->hasTagName(trackTag)) {	794	if (node->hasTagName(trackTag)) {
795	HTMLTrackElement* track = static_cast<HTMLTrackElement*>(node);	795	HTMLTrackElement* track = static_cast<HTMLTrackElement*>(node);
796	track->load(ActiveDOMObject::scriptExecutionContext());	796	track->load(ActiveDOMObject::scriptExecutionContext(), &m_cueIndex);
797	}	797	}
798	}	798	}
799	}	799	}

Lines 37-42 a/Source/WebCore/html/HTMLMediaElement.h_sec1
- a/Source/WebCore/html/HTMLMediaElement.h +8 lines
37	#include "MediaPlayerProxy.h"	37	#include "MediaPlayerProxy.h"
38	#endif	38	#endif
39		39
		40	#if ENABLE(VIDEO_TRACK)
		41	#include "CueIndex.h"
		42	#endif
		43
40	namespace WebCore {	44	namespace WebCore {
41		45
42	class Event;	46	class Event;
Lines 430-435 private: a/Source/WebCore/html/HTMLMediaElement.h_sec2
430	bool m_loadInitiatedByUserGesture : 1;	434	bool m_loadInitiatedByUserGesture : 1;
431	bool m_completelyLoaded : 1;	435	bool m_completelyLoaded : 1;
432	bool m_havePreparedToPlay : 1;	436	bool m_havePreparedToPlay : 1;
		437
		438	#if ENABLE(VIDEO_TRACK)
		439	CueIndex m_cueIndex;
		440	#endif
433	};	441	};
434		442
435	} //namespace	443	} //namespace

Lines 127-138 bool HTMLTrackElement::isURLAttribute(Attribute* attribute) const a/Source/WebCore/html/HTMLTrackElement.cpp_sec1
- a/Source/WebCore/html/HTMLTrackElement.cpp -5 / +7 lines
127	return attribute->name() == srcAttr;	127	return attribute->name() == srcAttr;
128	}	128	}
129		129
130	void HTMLTrackElement::load(ScriptExecutionContext* context)	130	void HTMLTrackElement::load(ScriptExecutionContext* context, CueLoaderClient* cueClient)
131	{	131	{
132	m_track = LoadableTextTrack::create(kind(), label(), srclang(), isDefault());	132	if (!m_track) {
133		133	if (hasAttribute(srcAttr)) {
134	if (hasAttribute(srcAttr))	134	m_track = LoadableTextTrack::create(kind(), label(), srclang(), isDefault());
135	m_track->load(getNonEmptyURLAttribute(srcAttr), context);	135	m_track->load(getNonEmptyURLAttribute(srcAttr), context, cueClient);
		136	}
		137	}
136	}	138	}
137		139
138	}	140	}

Lines 33-38 a/Source/WebCore/html/HTMLTrackElement.h_sec1
- a/Source/WebCore/html/HTMLTrackElement.h -1 / +3 lines
33		33
34	namespace WebCore {	34	namespace WebCore {
35		35
		36	class CueLoaderClient;
		37
36	class HTMLTrackElement : public HTMLElement {	38	class HTMLTrackElement : public HTMLElement {
37	public:	39	public:
38	static PassRefPtr<HTMLTrackElement> create(const QualifiedName&, Document*);	40	static PassRefPtr<HTMLTrackElement> create(const QualifiedName&, Document*);
Lines 49-55 public: a/Source/WebCore/html/HTMLTrackElement.h_sec2
49	void setLabel(const String&);	51	void setLabel(const String&);
50	void setIsDefault(bool);	52	void setIsDefault(bool);
51		53
52	void load(ScriptExecutionContext*);	54	void load(ScriptExecutionContext, CueLoaderClient);
53		55
54	private:	56	private:
55	HTMLTrackElement(const QualifiedName&, Document*);	57	HTMLTrackElement(const QualifiedName&, Document*);



    : TextTrack(kind, label, language)
    , m_isDefault(isDefault)
{
    m_cues = TextTrackCueList::create();
}

LoadableTextTrack::~LoadableTextTrack()
{
    if (m_client)
        m_client->removeCuesFromIndex(m_cues.get());
}

void LoadableTextTrack::load(const String& url, ScriptExecutionContext* context, CueLoaderClient* client)
{
    setCueLoaderClient(client);
    return m_parser.load(url, context, this);
}

bool LoadableTextTrack::supportsType(const String& url)
{
    return m_parser.supportsType(url);
}

void LoadableTextTrack::newCuesParsed()
{
    // Fetch new cues from parser and temporarily store to give to CueLoaderClient when fetchNewCuesFromLoader is called.
    Vector<RefPtr<TextTrackCue> > newCues;
    m_parser.fetchParsedCues(newCues);
    for (Vector<RefPtr<TextTrackCue> >::iterator it = newCues.begin(); it < newCues.end(); it++) {
        RefPtr<TextTrackCue> cue = *it;
        cue->setTrack(this);
        m_newestCues.append(cue.get());
    }
    m_cues->add(newCues);
    newCuesLoaded();
}

void LoadableTextTrack::trackLoadStarted()


void LoadableTextTrack::newCuesLoaded()
{
    m_client->fetchNewCuesFromLoader(this);
}

void LoadableTextTrack::fetchNewestCues(Vector<TextTrackCue*>& output)
{
    for (Vector<TextTrackCue*>::iterator it = m_newestCues.begin(); it < m_newestCues.end(); it++)
        output.append(*it);
    m_newestCues.clear();
}

} // namespace WebCore

Lines 49-55 public: a/Source/WebCore/html/LoadableTextTrack.h_sec1
- a/Source/WebCore/html/LoadableTextTrack.h -1 / +1 lines
49	}	49	}
50	virtual ~LoadableTextTrack();	50	virtual ~LoadableTextTrack();
51		51
52	void load(const String&, ScriptExecutionContext*);	52	void load(const String&, ScriptExecutionContext, CueLoaderClient);
53	bool supportsType(const String&);	53	bool supportsType(const String&);
54		54
55	virtual void newCuesParsed();	55	virtual void newCuesParsed();



namespace WebCore {

class TextTrack;
class TextTrackCue;
class TextTrackCueList;

class TextTrackClient {

    void setReadyState(ReadyState);

    RefPtr<TextTrackCueList> m_cues;
    Vector<TextTrackCue*> m_newestCues;

private:
    String m_kind;




TextTrackCueList::TextTrackCueList()
{
    // FIXME(62883): Implement.
}

unsigned long TextTrackCueList::length() const
{
    return m_list.size();
}

TextTrackCue* TextTrackCueList::getCueById(const String& id) const
{
    for (Vector<RefPtr<TextTrackCue> >::const_iterator it = m_list.begin(); it != m_list.end(); it++) {
        TextTrackCue* cue = it->get();
        if (cue->id() == id)
            return cue;
    }
    return 0;
}

TextTrackCue* TextTrackCueList::item(unsigned index) const
{
    return m_list[index].get();
}

void TextTrackCueList::add(const Vector<RefPtr<TextTrackCue> >& newCues)
{
    for (Vector<RefPtr<TextTrackCue> >::const_iterator it = newCues.begin(); it != newCues.end(); it++)
        add(*it);
}

void TextTrackCueList::add(const PassRefPtr<TextTrackCue> cue)
{
    RefPtr<TextTrackCue> newCue = cue;
    add(newCue, 0, m_list.size());
}

void TextTrackCueList::add(const PassRefPtr<TextTrackCue> cue, size_t start, size_t end)
{
    RefPtr<TextTrackCue> newCue = cue;
    if (start == end) {
       m_list.insert(start, newCue);
       return;
    }

    size_t index = (start + end) / 2;
    if (newCue->startTime() < m_list[index]->startTime()
        || (newCue->startTime() == m_list[index]->startTime()
        && newCue->endTime() < m_list[index]->endTime()))
        add(newCue, start, index);
    else
        add(newCue, index + 1, end);
}

void TextTrackCueList::remove(const PassRefPtr<TextTrackCue> cue)
{
    RefPtr<TextTrackCue> removeCue = cue;
    removeCue->setIsActive(false);
    m_list.remove(m_list.find(removeCue));
}

TextTrackCueList::Iterator TextTrackCueList::begin()
{
    return m_list.begin();
}

TextTrackCueList::Iterator TextTrackCueList::end()
{
    return m_list.end();
}

} // namespace WebCore

Lines 37-57 namespace WebCore { a/Source/WebCore/html/TextTrackCueList.h_sec1
- a/Source/WebCore/html/TextTrackCueList.h -3 / +13 lines
37		37
38	class TextTrackCueList : public RefCounted<TextTrackCueList> {	38	class TextTrackCueList : public RefCounted<TextTrackCueList> {
39	public:	39	public:
		40	typedef Vector<RefPtr<TextTrackCue> >::iterator Iterator;
		41
40	static PassRefPtr<TextTrackCueList> create()	42	static PassRefPtr<TextTrackCueList> create()
41	{	43	{
42	return adoptRef(new TextTrackCueList);	44	return adoptRef(new TextTrackCueList);
43	}	45	}
		46
		47	~TextTrackCueList() { }
44		48
45	unsigned long length() const;	49	unsigned long length() const;
		50	TextTrackCue* item(unsigned index) const;
46	TextTrackCue* getCueById(const String&) const;	51	TextTrackCue* getCueById(const String&) const;
47	PassRefPtr<TextTrackCueList> activeCues();	52	PassRefPtr<TextTrackCueList> activeCues();
48		53
49	void append(const PassRefPtr<TextTrackCue>&);	54	void add(const PassRefPtr<TextTrackCue>);
50	void append(Vector<PassRefPtr<TextTrackCue> >&);	55	void add(const Vector<RefPtr<TextTrackCue> >&);
51	void remove(const PassRefPtr<TextTrackCue>&);	56	void remove(const PassRefPtr<TextTrackCue>);
		57
		58	virtual Iterator begin();
		59	virtual Iterator end();
52		60
53	private:	61	private:
54	TextTrackCueList();	62	TextTrackCueList();
		63	void add(const PassRefPtr<TextTrackCue>, size_t, size_t);
		64	Vector <RefPtr<TextTrackCue> > m_list;
55	};	65	};
56		66
57	} // namespace WebCore	67	} // namespace WebCore



    m_loader = ThreadableLoader::create(context, this, request, options);
}

bool CueParser::supportsType(const String& url)
{
    // FIXME(62893): check against a list of supported types
    return false;
}

void CueParser::didReceiveResponse(unsigned long /*identifier*/, const ResourceResponse&)
{
    // FIXME(62893): Create m_private based on MIME type.

    m_client->trackLoadError();
}

void CueParser::fetchParsedCues(Vector<RefPtr<TextTrackCue> >& outputCues)
{
    m_private->fetchParsedCues(outputCues);
}

} // namespace WebCore

Lines 64-70 public: a/Source/WebCore/platform/track/CueParser.h_sec1
- a/Source/WebCore/platform/track/CueParser.h -1 lines
64	void didFail(const ResourceError&);	64	void didFail(const ResourceError&);
65		65
66	void load(const String&, ScriptExecutionContext, CueParserClient);	66	void load(const String&, ScriptExecutionContext, CueParserClient);
67	bool supportsType(const String&);
68		67
69	void fetchParsedCues(Vector<RefPtr<TextTrackCue> >&);	68	void fetchParsedCues(Vector<RefPtr<TextTrackCue> >&);
70		69

Lines 54-60 public: a/Source/WebCore/platform/track/CueParserPrivate.h_sec1
- a/Source/WebCore/platform/track/CueParserPrivate.h -1 / +1 lines
54	virtual void parseBytes(const char*, int) = 0;	54	virtual void parseBytes(const char*, int) = 0;
55		55
56	// Transfers ownership of last parsed cues to caller.	56	// Transfers ownership of last parsed cues to caller.
57	virtual void fetchParsedCues(Vector<PassRefPtr<TextTrackCue> >&) = 0;	57	virtual void fetchParsedCues(Vector<RefPtr<TextTrackCue> >&) = 0;
58		58
59	protected:	59	protected:
60	CueParserPrivateInterface() { }	60	CueParserPrivateInterface() { }

Return to Bug 62883

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +25 lines
		1	2011-07-21 Anna Cavender <annacc@chromium.org>
		2
		3	Storage of TextTrackCues for efficient retrieval during playback.
		4	https://bugs.webkit.org/show_bug.cgi?id=62883
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	No new tests because feature is hidden behind VIDEO_TRACK feature
		9	define, which is turned off.
		10
		11	* html/CueIndex.cpp:
		12	* html/CueIndex.h:
		13	* html/HTMLMediaElement.cpp:
		14	* html/HTMLMediaElement.h:
		15	* html/HTMLTrackElement.cpp:
		16	* html/HTMLTrackElement.h:
		17	* html/LoadableTextTrack.cpp:
		18	* html/LoadableTextTrack.h:
		19	* html/TextTrack.h:
		20	* html/TextTrackCueList.cpp:
		21	* html/TextTrackCueList.h:
		22	* platform/track/CueParser.cpp:
		23	* platform/track/CueParser.h:
		24	* platform/track/CueParserPrivate.h:
		25
1	2011-07-21 Pavel Feldman <pfeldman@google.com>	26	2011-07-21 Pavel Feldman <pfeldman@google.com>
2		27
3	Not reviewed: one liner typo fix in Inspector.json.	28	Not reviewed: one liner typo fix in Inspector.json.

Lines 34-87 a/Source/WebCore/html/CueIndex.cpp_sec1
- a/Source/WebCore/html/CueIndex.cpp -25 / +72 lines
34		34
35	namespace WebCore {	35	namespace WebCore {
36		36
37	CueSet CueSet::difference(const CueSet&) const	37	CueSet CueSet::difference(const CueSet& other) const
38	{	38	{
39	// FIXME(62883): Implement.	39	CueSet newSet;
40	return CueSet();	40	for (CueSet::Iterator it = other.m_set.begin(); it != other.m_set.end(); ++it) {
		41	TextTrackCue* cue = *it;
		42	if (!m_set.contains(cue))
		43	newSet.add(*cue);
		44	}
		45	return newSet;
41	}	46	}
42		47
43	CueSet CueSet::unionSet(const CueSet&) const	48	CueSet CueSet::unionSet(const CueSet& other) const
44	{	49	{
45	// FIXME(62883): Implement.	50	CueSet newSet;
46	return CueSet();	51	for (CueSet::Iterator it = other.m_set.begin(); it != other.m_set.end(); ++it) {
		52	TextTrackCue* cue = *it;
		53	newSet.add(*cue);
		54	}
		55	for (CueSet::Iterator it = m_set.begin(); it != m_set.end(); ++it) {
		56	TextTrackCue* cue = *it;
		57	newSet.add(*cue);
		58	}
		59	return newSet;
47	}	60	}
48		61
49	void CueSet::add(const TextTrackCue&)	62	void CueSet::add(const TextTrackCue& cue)
50	{	63	{
51	// FIXME(62883): Implement.	64	m_set.add(const_cast<TextTrackCue*>(&cue));
52	}	65	}
53		66
54	bool CueSet::contains(const TextTrackCue&) const	67	bool CueSet::contains(const TextTrackCue& cue) const
55	{	68	{
56	// FIXME(62883): Implement.	69	return m_set.contains(const_cast<TextTrackCue*>(&cue));
57	return false;
58	}	70	}
59		71
60	void CueSet::remove(const TextTrackCue&)	72	void CueSet::remove(const TextTrackCue& cue)
61	{	73	{
62	// FIXME(62883): Implement.	74	m_set.remove(const_cast<TextTrackCue*>(&cue));
		75	}
		76
		77	void CueSet::clear()
		78	{
		79	m_set.clear();
63	}	80	}
64		81
65	bool CueSet::isEmpty() const	82	bool CueSet::isEmpty() const
66	{	83	{
67	// FIXME(62883): Implement.	84	return m_set.isEmpty();
68	return false;
69	}	85	}
70		86
71	int CueSet::size() const	87	int CueSet::size() const
72	{	88	{
73	// FIXME(62883): Implement.	89	return m_set.size();
74	return 0;	90	}
		91
		92	CueSet::Iterator CueSet::begin() const
		93	{
		94	return m_set.begin();
		95	}
		96
		97	CueSet::Iterator CueSet::end() const
		98	{
		99	return m_set.end();
75	}	100	}
76		101
77	void CueIndex::fetchNewCuesFromLoader(CueLoader*)	102	void CueIndex::fetchNewCuesFromLoader(CueLoader* loader)
78	{	103	{
79	// FIXME(62883): Implement.	104	Vector<TextTrackCue*> newCues;
		105	loader->fetchNewestCues(newCues);
		106	for (size_t i = 0; i < newCues.size(); ++i)
		107	add(newCues[i]);
80	}	108	}
81		109
82	void CueIndex::removeCuesFromIndex(const TextTrackCueList*)	110	void CueIndex::removeCuesFromIndex(const TextTrackCueList* cueList)
83	{	111	{
84	// FIXME(62883): Implement.	112	for (size_t i = 0; i < cueList->length(); ++i)
		113	remove(cueList->item(i));
85	}	114	}
86		115
87	CueSet CueIndex::visibleCuesAtTime(double) const	116	CueSet CueIndex::visibleCuesAtTime(double) const
Lines 90-103 CueSet CueIndex::visibleCuesAtTime(double) const a/Source/WebCore/html/CueIndex.cpp_sec2
90	return CueSet();	119	return CueSet();
91	}	120	}
92		121
93	void CueIndex::add(TextTrackCue*)	122	void CueIndex::add(TextTrackCue* cue)
		123	{
		124	add(cue, 0, m_cuesByStartTime.size());
		125	}
		126
		127	void CueIndex::add(TextTrackCue* cue, size_t start, size_t end)
94	{	128	{
95	// FIXME(62890): Implement.	129	if (start == end) {
		130	m_cuesByStartTime.insert(start, cue);
		131	return;
		132	}
		133
		134	size_t index = (start + end) / 2;
		135	if (cue->startTime() < m_cuesByStartTime[index]->startTime()
		136	\|\| (cue->startTime() == m_cuesByStartTime[index]->startTime()
		137	&& cue->endTime() < m_cuesByStartTime[index]->endTime()))
		138	add(cue, start, index);
		139	else
		140	add(cue, index + 1, end);
96	}	141	}
97		142
98	void CueIndex::remove(TextTrackCue*)	143	void CueIndex::remove(TextTrackCue* cue)
99	{	144	{
100	// FIXME(62890): Implement.	145	size_t index = m_cuesByStartTime.find(cue);
		146	if (index != notFound)
		147	m_cuesByStartTime.remove(index);
101	}	148	}
102		149
103	} // namespace WebCore	150	} // namespace WebCore

Lines 35-59 LoadableTextTrack::LoadableTextTrack(const String& kind, const String& label, co a/Source/WebCore/html/LoadableTextTrack.cpp_sec1
- a/Source/WebCore/html/LoadableTextTrack.cpp -10 / +20 lines
35	: TextTrack(kind, label, language)	35	: TextTrack(kind, label, language)
36	, m_isDefault(isDefault)	36	, m_isDefault(isDefault)
37	{	37	{
		38	m_cues = TextTrackCueList::create();
38	}	39	}
39		40
40	LoadableTextTrack::~LoadableTextTrack()	41	LoadableTextTrack::~LoadableTextTrack()
41	{	42	{
		43	if (m_client)
		44	m_client->removeCuesFromIndex(m_cues.get());
42	}	45	}
43		46
44	void LoadableTextTrack::load(const String& url, ScriptExecutionContext* context)	47	void LoadableTextTrack::load(const String& url, ScriptExecutionContext* context, CueLoaderClient* client)
45	{	48	{
		49	setCueLoaderClient(client);
46	return m_parser.load(url, context, this);	50	return m_parser.load(url, context, this);
47	}	51	}
48		52
49	bool LoadableTextTrack::supportsType(const String& url)
50	{
51	return m_parser.supportsType(url);
52	}
53
54	void LoadableTextTrack::newCuesParsed()	53	void LoadableTextTrack::newCuesParsed()
55	{	54	{
56	// FIXME(62883): Fetch new cues from parser and temporarily store to give to CueLoaderClient when fetchNewCuesFromLoader is called.	55	// Fetch new cues from parser and temporarily store to give to CueLoaderClient when fetchNewCuesFromLoader is called.
		56	Vector<RefPtr<TextTrackCue> > newCues;
		57	m_parser.fetchParsedCues(newCues);
		58	for (Vector<RefPtr<TextTrackCue> >::iterator it = newCues.begin(); it < newCues.end(); it++) {
		59	RefPtr<TextTrackCue> cue = *it;
		60	cue->setTrack(this);
		61	m_newestCues.append(cue.get());
		62	}
		63	m_cues->add(newCues);
		64	newCuesLoaded();
57	}	65	}
58		66
59	void LoadableTextTrack::trackLoadStarted()	67	void LoadableTextTrack::trackLoadStarted()
Lines 73-84 void LoadableTextTrack::trackLoadCompleted() a/Source/WebCore/html/LoadableTextTrack.cpp_sec2
73		81
74	void LoadableTextTrack::newCuesLoaded()	82	void LoadableTextTrack::newCuesLoaded()
75	{	83	{
76	// FIXME(62885): Tell the client to fetch the latest cues.	84	m_client->fetchNewCuesFromLoader(this);
77	}	85	}
78		86
79	void LoadableTextTrack::fetchNewestCues(Vector<TextTrackCue*>&)	87	void LoadableTextTrack::fetchNewestCues(Vector<TextTrackCue*>& output)
80	{	88	{
81	// FIXME(62885): Implement.	89	for (Vector<TextTrackCue*>::iterator it = m_newestCues.begin(); it < m_newestCues.end(); it++)
		90	output.append(*it);
		91	m_newestCues.clear();
82	}	92	}
83		93
84	} // namespace WebCore	94	} // namespace WebCore

Lines 36-41 a/Source/WebCore/html/TextTrack.h_sec1
- a/Source/WebCore/html/TextTrack.h +2 lines
36	namespace WebCore {	36	namespace WebCore {
37		37
38	class TextTrack;	38	class TextTrack;
		39	class TextTrackCue;
39	class TextTrackCueList;	40	class TextTrackCueList;
40		41
41	class TextTrackClient {	42	class TextTrackClient {
Lines 77-82 protected: a/Source/WebCore/html/TextTrack.h_sec2
77	void setReadyState(ReadyState);	78	void setReadyState(ReadyState);
78		79
79	RefPtr<TextTrackCueList> m_cues;	80	RefPtr<TextTrackCueList> m_cues;
		81	Vector<TextTrackCue*> m_newestCues;
80		82
81	private:	83	private:
82	String m_kind;	84	String m_kind;

Lines 33-60 namespace WebCore { a/Source/WebCore/html/TextTrackCueList.cpp_sec1
- a/Source/WebCore/html/TextTrackCueList.cpp -9 / +53 lines
33		33
34	TextTrackCueList::TextTrackCueList()	34	TextTrackCueList::TextTrackCueList()
35	{	35	{
36	// FIXME(62883): Implement.
37	}	36	}
38		37
39	TextTrackCue* TextTrackCueList::getCueById(const String&) const	38	unsigned long TextTrackCueList::length() const
40	{	39	{
41	// FIXME(62883): Implement.	40	return m_list.size();
		41	}
		42
		43	TextTrackCue* TextTrackCueList::getCueById(const String& id) const
		44	{
		45	for (Vector<RefPtr<TextTrackCue> >::const_iterator it = m_list.begin(); it != m_list.end(); it++) {
		46	TextTrackCue* cue = it->get();
		47	if (cue->id() == id)
		48	return cue;
		49	}
42	return 0;	50	return 0;
43	}	51	}
44		52
45	void TextTrackCueList::append(Vector<PassRefPtr<TextTrackCue> >&)	53	TextTrackCue* TextTrackCueList::item(unsigned index) const
		54	{
		55	return m_list[index].get();
		56	}
		57
		58	void TextTrackCueList::add(const Vector<RefPtr<TextTrackCue> >& newCues)
		59	{
		60	for (Vector<RefPtr<TextTrackCue> >::const_iterator it = newCues.begin(); it != newCues.end(); it++)
		61	add(*it);
		62	}
		63
		64	void TextTrackCueList::add(const PassRefPtr<TextTrackCue> cue)
		65	{
		66	RefPtr<TextTrackCue> newCue = cue;
		67	add(newCue, 0, m_list.size());
		68	}
		69
		70	void TextTrackCueList::add(const PassRefPtr<TextTrackCue> cue, size_t start, size_t end)
		71	{
		72	RefPtr<TextTrackCue> newCue = cue;
		73	if (start == end) {
		74	m_list.insert(start, newCue);
		75	return;
		76	}
		77
		78	size_t index = (start + end) / 2;
		79	if (newCue->startTime() < m_list[index]->startTime()
		80	\|\| (newCue->startTime() == m_list[index]->startTime()
		81	&& newCue->endTime() < m_list[index]->endTime()))
		82	add(newCue, start, index);
		83	else
		84	add(newCue, index + 1, end);
		85	}
		86
		87	void TextTrackCueList::remove(const PassRefPtr<TextTrackCue> cue)
46	{	88	{
47	// FIXME(62883): Implement.	89	RefPtr<TextTrackCue> removeCue = cue;
		90	removeCue->setIsActive(false);
		91	m_list.remove(m_list.find(removeCue));
48	}	92	}
49		93
50	void TextTrackCueList::append(const PassRefPtr<TextTrackCue>&)	94	TextTrackCueList::Iterator TextTrackCueList::begin()
51	{	95	{
52	// FIXME(62883): Implement.	96	return m_list.begin();
53	}	97	}
54		98
55	void TextTrackCueList::remove(const PassRefPtr<TextTrackCue>&)	99	TextTrackCueList::Iterator TextTrackCueList::end()
56	{	100	{
57	// FIXME(62883): Implement.	101	return m_list.end();
58	}	102	}
59		103
60	} // namespace WebCore	104	} // namespace WebCore

Lines 64-75 void CueParser::load(const String& url, ScriptExecutionContext* context, CuePars a/Source/WebCore/platform/track/CueParser.cpp_sec1
- a/Source/WebCore/platform/track/CueParser.cpp -8 / +2 lines
64	m_loader = ThreadableLoader::create(context, this, request, options);	64	m_loader = ThreadableLoader::create(context, this, request, options);
65	}	65	}
66		66
67	bool CueParser::supportsType(const String& url)
68	{
69	// FIXME(62893): check against a list of supported types
70	return false;
71	}
72
73	void CueParser::didReceiveResponse(unsigned long /identifier/, const ResourceResponse&)	67	void CueParser::didReceiveResponse(unsigned long /identifier/, const ResourceResponse&)
74	{	68	{
75	// FIXME(62893): Create m_private based on MIME type.	69	// FIXME(62893): Create m_private based on MIME type.
Lines 91-99 void CueParser::didFail(const ResourceError&) a/Source/WebCore/platform/track/CueParser.cpp_sec2
91	m_client->trackLoadError();	85	m_client->trackLoadError();
92	}	86	}
93		87
94	void CueParser::fetchParsedCues(Vector<RefPtr<TextTrackCue> >&)	88	void CueParser::fetchParsedCues(Vector<RefPtr<TextTrackCue> >& outputCues)
95	{	89	{
96	// FIXME(62893): Implement.	90	m_private->fetchParsedCues(outputCues);
97	}	91	}
98		92
99	} // namespace WebCore	93	} // namespace WebCore