Stop using DEFINE_STATIC_LOCAL with RefPtr
[WebKit-https.git] / Source / WebCore / html / track / TextTrack.cpp
1 /*
2  * Copyright (C) 2011 Google Inc.  All rights reserved.
3  * Copyright (C) 2011, 2012, 2013 Apple Inc.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include "config.h"
33
34 #if ENABLE(VIDEO_TRACK)
35
36 #include "TextTrack.h"
37
38 #include "Event.h"
39 #include "ExceptionCode.h"
40 #include "HTMLMediaElement.h"
41 #include "TextTrackCueList.h"
42 #include "TextTrackList.h"
43 #include "TextTrackRegionList.h"
44 #include "TrackBase.h"
45
46 namespace WebCore {
47
48 static const int invalidTrackIndex = -1;
49
50 const AtomicString& TextTrack::subtitlesKeyword()
51 {
52     DEFINE_STATIC_LOCAL(const AtomicString, subtitles, ("subtitles", AtomicString::ConstructFromLiteral));
53     return subtitles;
54 }
55
56 const AtomicString& TextTrack::captionsKeyword()
57 {
58     DEFINE_STATIC_LOCAL(const AtomicString, captions, ("captions", AtomicString::ConstructFromLiteral));
59     return captions;
60 }
61
62 const AtomicString& TextTrack::descriptionsKeyword()
63 {
64     DEFINE_STATIC_LOCAL(const AtomicString, descriptions, ("descriptions", AtomicString::ConstructFromLiteral));
65     return descriptions;
66 }
67
68 const AtomicString& TextTrack::chaptersKeyword()
69 {
70     DEFINE_STATIC_LOCAL(const AtomicString, chapters, ("chapters", AtomicString::ConstructFromLiteral));
71     return chapters;
72 }
73
74 const AtomicString& TextTrack::metadataKeyword()
75 {
76     DEFINE_STATIC_LOCAL(const AtomicString, metadata, ("metadata", AtomicString::ConstructFromLiteral));
77     return metadata;
78 }
79     
80 const AtomicString& TextTrack::forcedKeyword()
81 {
82     DEFINE_STATIC_LOCAL(const AtomicString, forced, ("forced", AtomicString::ConstructFromLiteral));
83     return forced;
84 }
85
86 const AtomicString& TextTrack::disabledKeyword()
87 {
88     DEFINE_STATIC_LOCAL(const AtomicString, open, ("disabled", AtomicString::ConstructFromLiteral));
89     return open;
90 }
91
92 const AtomicString& TextTrack::hiddenKeyword()
93 {
94     DEFINE_STATIC_LOCAL(const AtomicString, closed, ("hidden", AtomicString::ConstructFromLiteral));
95     return closed;
96 }
97
98 const AtomicString& TextTrack::showingKeyword()
99 {
100     DEFINE_STATIC_LOCAL(const AtomicString, ended, ("showing", AtomicString::ConstructFromLiteral));
101     return ended;
102 }
103
104 TextTrack* TextTrack::captionMenuOffItem()
105 {
106     static TextTrack* off = TextTrack::create(0, 0, "off menu item", "", "").leakRef();
107     return off;
108 }
109
110 TextTrack* TextTrack::captionMenuAutomaticItem()
111 {
112     static TextTrack* automatic = TextTrack::create(0, 0, "automatic menu item", "", "").leakRef();
113     return automatic;
114 }
115
116 TextTrack::TextTrack(ScriptExecutionContext* context, TextTrackClient* client, const AtomicString& kind, const AtomicString& label, const AtomicString& language, TextTrackType type)
117     : TrackBase(TrackBase::TextTrack, label, language)
118     , m_cues(0)
119     , m_scriptExecutionContext(context)
120 #if ENABLE(WEBVTT_REGIONS)
121     , m_regions(0)
122 #endif
123     , m_mode(disabledKeyword().string())
124     , m_client(client)
125     , m_trackType(type)
126     , m_readinessState(NotLoaded)
127     , m_trackIndex(invalidTrackIndex)
128     , m_renderedTrackIndex(invalidTrackIndex)
129     , m_hasBeenConfigured(false)
130 {
131     setKind(kind);
132 }
133
134 TextTrack::~TextTrack()
135 {
136     if (m_cues) {
137         if (m_client)
138             m_client->textTrackRemoveCues(this, m_cues.get());
139
140         for (size_t i = 0; i < m_cues->length(); ++i)
141             m_cues->item(i)->setTrack(0);
142 #if ENABLE(WEBVTT_REGIONS)
143         for (size_t i = 0; i < m_regions->length(); ++i)
144             m_regions->item(i)->setTrack(0);
145 #endif
146     }
147     clearClient();
148 }
149
150 const AtomicString& TextTrack::interfaceName() const
151 {
152     return eventNames().interfaceForTextTrack;
153 }
154
155 ScriptExecutionContext* TextTrack::scriptExecutionContext() const
156 {
157     return m_scriptExecutionContext;
158 }
159
160 EventTargetData* TextTrack::eventTargetData()
161 {
162     return &m_eventTargetData;
163 }
164
165 EventTargetData& TextTrack::ensureEventTargetData()
166 {
167     return m_eventTargetData;
168 }
169
170 bool TextTrack::isValidKind(const AtomicString& value) const
171 {
172     return TextTrack::isValidKindKeyword(value);
173 }
174
175 bool TextTrack::isValidKindKeyword(const AtomicString& value)
176 {
177     if (value == subtitlesKeyword())
178         return true;
179     if (value == captionsKeyword())
180         return true;
181     if (value == descriptionsKeyword())
182         return true;
183     if (value == chaptersKeyword())
184         return true;
185     if (value == metadataKeyword())
186         return true;
187     if (value == forcedKeyword())
188         return true;
189
190     return false;
191 }
192
193 void TextTrack::setKind(const AtomicString& newKind)
194 {
195     String oldKind = kind();
196
197     TrackBase::setKind(newKind);
198
199     if (m_client && oldKind != kind())
200         m_client->textTrackKindChanged(this);
201 }
202
203 void TextTrack::setMode(const AtomicString& mode)
204 {
205     // On setting, if the new value isn't equal to what the attribute would currently
206     // return, the new value must be processed as follows ...
207     if (mode != disabledKeyword() && mode != hiddenKeyword() && mode != showingKeyword())
208         return;
209
210     if (m_mode == mode)
211         return;
212
213     // If mode changes to disabled, remove this track's cues from the client
214     // because they will no longer be accessible from the cues() function.
215     if (mode == disabledKeyword() && m_client && m_cues)
216         m_client->textTrackRemoveCues(this, m_cues.get());
217          
218     if (mode != showingKeyword() && m_cues)
219         for (size_t i = 0; i < m_cues->length(); ++i)
220             m_cues->item(i)->removeDisplayTree();
221
222     m_mode = mode;
223
224     if (m_client)
225         m_client->textTrackModeChanged(this);
226 }
227
228 TextTrackCueList* TextTrack::cues()
229 {
230     // 4.8.10.12.5 If the text track mode ... is not the text track disabled mode,
231     // then the cues attribute must return a live TextTrackCueList object ...
232     // Otherwise, it must return null. When an object is returned, the
233     // same object must be returned each time.
234     // http://www.whatwg.org/specs/web-apps/current-work/#dom-texttrack-cues
235     if (m_mode != disabledKeyword())
236         return ensureTextTrackCueList();
237     return 0;
238 }
239
240 void TextTrack::removeAllCues()
241 {
242     if (!m_cues)
243         return;
244
245     if (m_client)
246         m_client->textTrackRemoveCues(this, m_cues.get());
247     
248     for (size_t i = 0; i < m_cues->length(); ++i)
249         m_cues->item(i)->setTrack(0);
250     
251     m_cues = 0;
252 }
253
254 TextTrackCueList* TextTrack::activeCues() const
255 {
256     // 4.8.10.12.5 If the text track mode ... is not the text track disabled mode,
257     // then the activeCues attribute must return a live TextTrackCueList object ...
258     // ... whose active flag was set when the script started, in text track cue
259     // order. Otherwise, it must return null. When an object is returned, the
260     // same object must be returned each time.
261     // http://www.whatwg.org/specs/web-apps/current-work/#dom-texttrack-activecues
262     if (m_cues && m_mode != disabledKeyword())
263         return m_cues->activeCues();
264     return 0;
265 }
266
267 void TextTrack::addCue(PassRefPtr<TextTrackCue> prpCue)
268 {
269     if (!prpCue)
270         return;
271
272     RefPtr<TextTrackCue> cue = prpCue;
273
274     // TODO(93143): Add spec-compliant behavior for negative time values.
275     if (std::isnan(cue->startTime()) || std::isnan(cue->endTime()) || cue->startTime() < 0 || cue->endTime() < 0)
276         return;
277
278     // 4.8.10.12.5 Text track API
279
280     // The addCue(cue) method of TextTrack objects, when invoked, must run the following steps:
281
282     // 1. If the given cue is in a text track list of cues, then remove cue from that text track
283     // list of cues.
284     TextTrack* cueTrack = cue->track();
285     if (cueTrack && cueTrack != this)
286         cueTrack->removeCue(cue.get(), ASSERT_NO_EXCEPTION);
287
288     // 2. Add cue to the method's TextTrack object's text track's text track list of cues.
289     cue->setTrack(this);
290     ensureTextTrackCueList()->add(cue);
291     
292     if (m_client)
293         m_client->textTrackAddCue(this, cue.get());
294 }
295
296 void TextTrack::removeCue(TextTrackCue* cue, ExceptionCode& ec)
297 {
298     if (!cue)
299         return;
300
301     // 4.8.10.12.5 Text track API
302
303     // The removeCue(cue) method of TextTrack objects, when invoked, must run the following steps:
304
305     // 1. If the given cue is not currently listed in the method's TextTrack 
306     // object's text track's text track list of cues, then throw a NotFoundError exception.
307     if (cue->track() != this) {
308         ec = NOT_FOUND_ERR;
309         return;
310     }
311
312     // 2. Remove cue from the method's TextTrack object's text track's text track list of cues.
313     if (!m_cues || !m_cues->remove(cue)) {
314         ec = INVALID_STATE_ERR;
315         return;
316     }
317
318     cue->setTrack(0);
319     if (m_client)
320         m_client->textTrackRemoveCue(this, cue);
321 }
322
323 #if ENABLE(VIDEO_TRACK) && ENABLE(WEBVTT_REGIONS)
324 TextTrackRegionList* TextTrack::regionList()
325 {
326     return ensureTextTrackRegionList();
327 }
328
329 TextTrackRegionList* TextTrack::ensureTextTrackRegionList()
330 {
331     if (!m_regions)
332         m_regions = TextTrackRegionList::create();
333
334     return m_regions.get();
335 }
336
337 TextTrackRegionList* TextTrack::regions()
338 {
339     // If the text track mode of the text track that the TextTrack object
340     // represents is not the text track disabled mode, then the regions
341     // attribute must return a live TextTrackRegionList object that represents
342     // the text track list of regions of the text track. Otherwise, it must
343     // return null. When an object is returned, the same object must be returned
344     // each time.
345     if (m_mode != disabledKeyword())
346         return ensureTextTrackRegionList();
347
348     return 0;
349 }
350
351 void TextTrack::addRegion(PassRefPtr<TextTrackRegion> prpRegion)
352 {
353     if (!prpRegion)
354         return;
355
356     RefPtr<TextTrackRegion> region = prpRegion;
357     TextTrackRegionList* regionList = ensureTextTrackRegionList();
358
359     // 1. If the given region is in a text track list of regions, then remove
360     // region from that text track list of regions.
361     TextTrack* regionTrack = region->track();
362     if (regionTrack && regionTrack != this)
363         regionTrack->removeRegion(region.get(), ASSERT_NO_EXCEPTION);
364
365     // 2. If the method's TextTrack object's text track list of regions contains
366     // a region with the same identifier as region replace the values of that
367     // region's width, height, anchor point, viewport anchor point and scroll
368     // attributes with those of region.
369     TextTrackRegion* existingRegion = regionList->getRegionById(region->id());
370     if (existingRegion) {
371         existingRegion->updateParametersFromRegion(region.get());
372         return;
373     }
374
375     // Otherwise: add region to the method's TextTrack object's text track
376     // list of regions.
377     region->setTrack(this);
378     regionList->add(region);
379 }
380
381 void TextTrack::removeRegion(TextTrackRegion* region, ExceptionCode &ec)
382 {
383     if (!region)
384         return;
385
386     // 1. If the given region is not currently listed in the method's TextTrack
387     // object's text track list of regions, then throw a NotFoundError exception.
388     if (region->track() != this) {
389         ec = NOT_FOUND_ERR;
390         return;
391     }
392
393     if (!m_regions || !m_regions->remove(region)) {
394         ec = INVALID_STATE_ERR;
395         return;
396     }
397
398     region->setTrack(0);
399 }
400 #endif
401
402 void TextTrack::cueWillChange(TextTrackCue* cue)
403 {
404     if (!m_client)
405         return;
406
407     // The cue may need to be repositioned in the media element's interval tree, may need to
408     // be re-rendered, etc, so remove it before the modification...
409     m_client->textTrackRemoveCue(this, cue);
410 }
411
412 void TextTrack::cueDidChange(TextTrackCue* cue)
413 {
414     if (!m_client)
415         return;
416
417     // Make sure the TextTrackCueList order is up-to-date.
418     ensureTextTrackCueList()->updateCueIndex(cue);
419
420     // ... and add it back again.
421     m_client->textTrackAddCue(this, cue);
422 }
423
424 int TextTrack::trackIndex()
425 {
426     ASSERT(m_mediaElement);
427
428     if (m_trackIndex == invalidTrackIndex)
429         m_trackIndex = m_mediaElement->textTracks()->getTrackIndex(this);
430
431     return m_trackIndex;
432 }
433
434 void TextTrack::invalidateTrackIndex()
435 {
436     m_trackIndex = invalidTrackIndex;
437     m_renderedTrackIndex = invalidTrackIndex;
438 }
439
440 bool TextTrack::isRendered()
441 {
442     if (kind() != captionsKeyword() && kind() != subtitlesKeyword() && kind() != forcedKeyword())
443         return false;
444
445     if (m_mode != showingKeyword())
446         return false;
447
448     return true;
449 }
450
451 TextTrackCueList* TextTrack::ensureTextTrackCueList()
452 {
453     if (!m_cues)
454         m_cues = TextTrackCueList::create();
455
456     return m_cues.get();
457 }
458
459 int TextTrack::trackIndexRelativeToRenderedTracks()
460 {
461     ASSERT(m_mediaElement);
462     
463     if (m_renderedTrackIndex == invalidTrackIndex)
464         m_renderedTrackIndex = m_mediaElement->textTracks()->getTrackIndexRelativeToRenderedTracks(this);
465     
466     return m_renderedTrackIndex;
467 }
468
469 bool TextTrack::hasCue(TextTrackCue* cue, TextTrackCue::CueMatchRules match)
470 {
471     if (cue->startTime() < 0 || cue->endTime() < 0)
472         return false;
473     
474     if (!m_cues || !m_cues->length())
475         return false;
476     
477     size_t searchStart = 0;
478     size_t searchEnd = m_cues->length();
479     
480     while (1) {
481         ASSERT(searchStart <= m_cues->length());
482         ASSERT(searchEnd <= m_cues->length());
483         
484         TextTrackCue* existingCue;
485         
486         // Cues in the TextTrackCueList are maintained in start time order.
487         if (searchStart == searchEnd) {
488             if (!searchStart)
489                 return false;
490
491             // If there is more than one cue with the same start time, back up to first one so we
492             // consider all of them.
493             while (searchStart >= 2 && cue->startTime() == m_cues->item(searchStart - 2)->startTime())
494                 --searchStart;
495             
496             bool firstCompare = true;
497             while (1) {
498                 if (!firstCompare)
499                     ++searchStart;
500                 firstCompare = false;
501                 if (searchStart > m_cues->length())
502                     return false;
503
504                 existingCue = m_cues->item(searchStart - 1);
505                 if (!existingCue || cue->startTime() > existingCue->startTime())
506                     return false;
507
508                 if (!existingCue->isEqual(*cue, match))
509                     continue;
510                 
511                 return true;
512             }
513         }
514         
515         size_t index = (searchStart + searchEnd) / 2;
516         existingCue = m_cues->item(index);
517         if (cue->startTime() < existingCue->startTime() || (match != TextTrackCue::IgnoreDuration && cue->startTime() == existingCue->startTime() && cue->endTime() > existingCue->endTime()))
518             searchEnd = index;
519         else
520             searchStart = index + 1;
521     }
522     
523     ASSERT_NOT_REACHED();
524     return false;
525 }
526
527 #if USE(PLATFORM_TEXT_TRACK_MENU)
528 PassRefPtr<PlatformTextTrack> TextTrack::platformTextTrack()
529 {
530     static int uniqueId = 0;
531
532     if (m_platformTextTrack)
533         return m_platformTextTrack;
534
535     PlatformTextTrack::TrackKind platformKind = PlatformTextTrack::Caption;
536     if (kind() == subtitlesKeyword())
537         platformKind = PlatformTextTrack::Subtitle;
538     else if (kind() == captionsKeyword())
539         platformKind = PlatformTextTrack::Caption;
540     else if (kind() == descriptionsKeyword())
541         platformKind = PlatformTextTrack::Description;
542     else if (kind() == chaptersKeyword())
543         platformKind = PlatformTextTrack::Chapter;
544     else if (kind() == metadataKeyword())
545         platformKind = PlatformTextTrack::MetaData;
546     else if (kind() == forcedKeyword())
547         platformKind = PlatformTextTrack::Forced;
548
549     PlatformTextTrack::TrackType type = PlatformTextTrack::OutOfBand;
550     if (m_trackType == TrackElement)
551         type = PlatformTextTrack::OutOfBand;
552     else if (m_trackType == AddTrack)
553         type = PlatformTextTrack::Script;
554     else if (m_trackType == InBand)
555         type = PlatformTextTrack::InBand;
556
557     m_platformTextTrack = PlatformTextTrack::create(this, label(), language(), platformKind, type, ++uniqueId);
558
559     return m_platformTextTrack;
560 }
561 #endif
562
563 bool TextTrack::isMainProgramContent() const
564 {
565     // "Main program" content is intrinsic to the presentation of the media file, regardless of locale. Content such as
566     // directors commentary is not "main program" because it is not essential for the presentation. HTML5 doesn't have
567     // a way to express this in a machine-reable form, it is typically done with the track label, so we assume that caption
568     // tracks are main content and all other track types are not.
569     return kind() == captionsKeyword();
570 }
571
572 } // namespace WebCore
573
574 #endif