Refactor TextTrackCue to use more traditional design patterns
authordarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 25 Feb 2020 07:25:11 +0000 (07:25 +0000)
committerdarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 25 Feb 2020 07:25:11 +0000 (07:25 +0000)
https://bugs.webkit.org/show_bug.cgi?id=208114

Reviewed by Alex Christensen.

- Fixed is<VTTCue> to accurately match the class hierarchy. Before, TextTrackCueGeneric
  derived from VTTCue, but is<VTTCue> would return false. Normalizing this lets us use
  is<VTTCue> and downcast<VTTCue> in the conventional way.
- Made the TextTrackCue::isEqual function a non-virtual function that calls a virtual
  function TextTrackCue::cueContentsMatch. Before there was a mix of overridding both
  functions in derived classes, achieving the same thing in multiple ways with
  unneccessary additional virtual function call overhead.
- Made the TextTrackCue::toJSONString function a non-virtual function that calls a
  virtual funtion TextTrackCue::toJSON. Before there were two virtual functions and
  inconsistent patterns for which one was overridden.

* html/HTMLMediaElement.cpp:
(WebCore::HTMLMediaElement::textTrackRemoveCue): Use downcast instead of toVTTCue.

* html/HTMLMediaElement.h: Removed some unneeded includes.

* html/shadow/MediaControlElements.cpp:
(WebCore::MediaControlTextTrackContainerElement::updateDisplay): Use downcast
instead of toVTTCue.
(WebCore::MediaControlTextTrackContainerElement::processActiveVTTCue): Removed
an assertion that no longer makes sense; guaranteed at runtime.

* html/shadow/MediaControls.h: Removed an unneeded include.

* html/track/DataCue.cpp:
(WebCore::toDataCue): Deleted. No need for this function since we can use
downcast<DataCue> instead.
(WebCore::DataCue::cueContentsMatch const): Removed unnecessary check of cueType.
The isEqual function checks cueType and only calls this function if it matches.
Use downcast instead of toDataCue.
(WebCore::DataCue::isEqual const): Deleted. Base class now handles this.
(WebCore::DataCue::doesExtendCue const): Deleted. Was never being called.
(WebCore::DataCue::toJSONString const): Deleted. Override toJSON instead.
(WebCore::DataCue::toJSON const): Moved the code here that used to be in toJSONString.

* html/track/DataCue.h: Reduced includes. Made overridden functions private
and final. Removed functions as mmentioned above. Changed WTF::LogArgument implementation
to just forward to TextTrackCue instead of reimplementing here.

* html/track/InbandDataTextTrack.cpp:
(WebCore::InbandDataTextTrack::removeCue): Use downcast instead of toDataCue.

* html/track/InbandGenericTextTrack.cpp: Removed an unneeded include.

* html/track/LoadableTextTrack.cpp:
(WebCore::LoadableTextTrack::LoadableTextTrack): Removed unneeded initialization of
m_isDefault, which is initialized in the class definition.
(WebCore::LoadableTextTrack::newCuesAvailable): Removed unneeded call to toVTTCue,
taking advantage of the better interface of getNewCues, which now returns
Vector<Ref<VTTCue>>, making the type explicit.

* html/track/TextTrack.cpp:
(WebCore::TextTrack::addCue): Use is<DataCue> instead of checking cueType.

* html/track/TextTrackCue.cpp:
(WebCore::TextTrackCue::create): Fixed confusing naming that called the fragment the
cue is contained in "cueDocument"; call it cueFragment instead. This constructor
already required that the ScriptExecutionContext be a Document. Did the type cast
for that up front. In the future would be good to change the argument type to Document.
Also fixed how the newly-created fragment is passed to the constructor. The old code
tried to use DocumentFragment&& to pass ownership, but since this is a reference-counted
object it needs to be Ref<DocumentFragment>&&.
(WebCore::TextTrackCue::TextTrackCue):
(WebCore::TextTrackCue::scriptExecutionContext const): Moved this here from the header
file so we can compile without TextTrackCue.h including Document.h.
(WebCore::TextTrackCue::cueContentsMatch const): Removed the code that checks cueType.
It's now isEqual that is responsible for checking that the cueType matches, and
cueContentsMatch is only called when the types are the same.
(WebCore::TextTrackCue::isEqual const): Reordered the boolean checks a bit so it's
easier to see the logic; no need for a cascade of if statements.
(WebCore::TextTrackCue::doesExtendCue const): Deleted. Was never being called.
(WebCore::operator<<): Use downcast instead of toVTTCue.

* html/track/TextTrackCue.h: Made isEqual no longer virtual. The per-class behavior
is now all in the virtual cueContentsMatch function, only called by isEqual.
Removed uncalled doesExtendCue function. Added some argument names in cases where
the type alone did not make their purpose clear. Made some things more private.
Replaced m_scriptExecutionContext with m_document.

* html/track/TextTrackCueGeneric.cpp:
(WebCore::TextTrackCueGeneric::create): Moved this function here from the header.
(WebCore::TextTrackCueGeneric::TextTrackCueGeneric): Initialized data members in the
class definition so they don't also need to be initialized here.
(WebCore::TextTrackCueGeneric::cueContentsMatch const): Rewrote using && rather than
castcading if statements, making the function shorter andd easier to read.
(WebCore::TextTrackCueGeneric::isEqual const): Deleted. Base class now handes this.
The old version had confusing logic to deal with checking cue type; can now do this
in a more straightforward way.
(WebCore::TextTrackCueGeneric::doesExtendCue const): Deleted. Was never called.
(WebCore::TextTrackCueGeneric::isOrderedBefore const): Use is<TextTrackCueGeneric>
and downcast<TextTrackCueGeneric>.
(WebCore::TextTrackCueGeneric::isPositionedAbove const): Ditto. Also merged two
if statements so there is less repeated logic.
(WebCore::TextTrackCueGeneric::toJSONString const): Deleted.
(WebCore::TextTrackCueGeneric::toJSON const): Moved code here that was in toJSONString.

* html/track/TextTrackCueGeneric.h: Made things more private. Changed WTF::LogArgument
implementation to just forward to TextTrackCue instead of reimplementing here.

* html/track/TextTrackCueList.cpp:
(WebCore::TextTrackCueList::create): Moved here from header.
* html/track/TextTrackCueList.h: Ditto.

* html/track/VTTCue.cpp: Moved undefinedPosition to be a private static constexpr
data member so it can be used in initialization.
(WebCore::VTTCueBox::applyCSSProperties): Use is<VTTCue> and downcast<VTTCue>.
(WebCore::VTTCue::create): Moved more overloads of this function here from the
header file.
(WebCore::VTTCue::VTTCue): Take Document instead of ScriptExecutionContext.
Also took the ScriptExecutionContext argument away from the initialize function.
(WebCore::VTTCue::initialize): Do less initialization here. This function is
only called in constructors, so it doesn't need to initialize anything that
is initialized in all constructors or initialized in the class definition.
What remains are things that require a little code to initialize and the
bitfields, which can't be initialized in the class definition.
(WebCore::VTTCue::setPosition): Rearranged the code a tiny bit.
(WebCore::copyWebVTTNodeToDOMTree): Made this a non-member function. Also changed
the argument types to use references.
(WebCore::VTTCue::getCueAsHTML): Updated for changes to copyWebVTTNodeToDOMTree.
(WebCore::VTTCue::removeDisplayTree): Check m_displayTree directly instead
of calling a hasDisplayTree function, since that's more a more straightforward
way to guard a subsequent line of code that then uses m_displayTree.
(WebCore::VTTCue::setCueSettings): Merged two if statements into one.
(WebCore::VTTCue::cueContentsMatch const): Rewrote using && rather than
castcading if statements, making the function shorter andd easier to read.
(WebCore::VTTCue::isEqual const): Deleted. Base class now handles this.
(WebCore::VTTCue::doesExtendCue const): Deleted. Was never called.
(WebCore::toVTTCue): Deleted.
(WebCore::VTTCue::toJSONString const): Deleted. Base class now handles this.
(WebCore::VTTCue::toJSON const): Added a comment.

* html/track/VTTCue.h: Moved create functions out of header, made some things
more private and final, initialized more data members in the class definition.
Removed toVTTCue. Changed WTF::LogArgument implementation to just forward to
TextTrackCue instead of reimplementing here. Corrected the isType function so
it knows about both cue types that result in a VTTCue object. This allows us
to use is<VTTCue> and downcast<VTTCue> in the normal way. Removed the FIXME
saying we should do that.

* loader/TextTrackLoader.cpp:
(WebCore::TextTrackLoader::getNewCues): Changed to return a Vector<Ref<VTTCue>>.
In modern C++ return value is better than an out argument for a function like
this, and the more-specific type helps us at the call sites.

* loader/TextTrackLoader.h: Updated for the above.

* page/CaptionUserPreferencesMediaAF.cpp: Removed unneeded include.

* platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h:
Use #pragma once and removed some unneded includes and forward declarations.

* rendering/RenderVTTCue.cpp:
(WebCore::RenderVTTCue::RenderVTTCue): Use downcast<VTTCue>.
(WebCore::RenderVTTCue::layout): Removed unneeded call to toVTTCue.
(WebCore::RenderVTTCue::repositionGenericCue): Use downcast instead of
static_cast for TextTrackCueGeneric.

* style/RuleSet.cpp: Removed unneeded include.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@257296 268f45cc-cd09-0410-ab3c-d52691b4dbfc

25 files changed:
Source/WebCore/ChangeLog
Source/WebCore/html/HTMLMediaElement.cpp
Source/WebCore/html/HTMLMediaElement.h
Source/WebCore/html/shadow/MediaControlElements.cpp
Source/WebCore/html/shadow/MediaControls.h
Source/WebCore/html/track/DataCue.cpp
Source/WebCore/html/track/DataCue.h
Source/WebCore/html/track/InbandDataTextTrack.cpp
Source/WebCore/html/track/InbandGenericTextTrack.cpp
Source/WebCore/html/track/LoadableTextTrack.cpp
Source/WebCore/html/track/TextTrack.cpp
Source/WebCore/html/track/TextTrackCue.cpp
Source/WebCore/html/track/TextTrackCue.h
Source/WebCore/html/track/TextTrackCueGeneric.cpp
Source/WebCore/html/track/TextTrackCueGeneric.h
Source/WebCore/html/track/TextTrackCueList.cpp
Source/WebCore/html/track/TextTrackCueList.h
Source/WebCore/html/track/VTTCue.cpp
Source/WebCore/html/track/VTTCue.h
Source/WebCore/loader/TextTrackLoader.cpp
Source/WebCore/loader/TextTrackLoader.h
Source/WebCore/page/CaptionUserPreferencesMediaAF.cpp
Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h
Source/WebCore/rendering/RenderVTTCue.cpp
Source/WebCore/style/RuleSet.cpp

index a80d7cb..848e2a1 100644 (file)
@@ -1,3 +1,169 @@
+2020-02-23  Darin Adler  <darin@apple.com>
+
+        Refactor TextTrackCue to use more traditional design patterns
+        https://bugs.webkit.org/show_bug.cgi?id=208114
+
+        Reviewed by Alex Christensen.
+
+        - Fixed is<VTTCue> to accurately match the class hierarchy. Before, TextTrackCueGeneric
+          derived from VTTCue, but is<VTTCue> would return false. Normalizing this lets us use
+          is<VTTCue> and downcast<VTTCue> in the conventional way.
+        - Made the TextTrackCue::isEqual function a non-virtual function that calls a virtual
+          function TextTrackCue::cueContentsMatch. Before there was a mix of overridding both
+          functions in derived classes, achieving the same thing in multiple ways with
+          unneccessary additional virtual function call overhead.
+        - Made the TextTrackCue::toJSONString function a non-virtual function that calls a
+          virtual funtion TextTrackCue::toJSON. Before there were two virtual functions and
+          inconsistent patterns for which one was overridden.
+
+        * html/HTMLMediaElement.cpp:
+        (WebCore::HTMLMediaElement::textTrackRemoveCue): Use downcast instead of toVTTCue.
+
+        * html/HTMLMediaElement.h: Removed some unneeded includes.
+
+        * html/shadow/MediaControlElements.cpp:
+        (WebCore::MediaControlTextTrackContainerElement::updateDisplay): Use downcast
+        instead of toVTTCue.
+        (WebCore::MediaControlTextTrackContainerElement::processActiveVTTCue): Removed
+        an assertion that no longer makes sense; guaranteed at runtime.
+
+        * html/shadow/MediaControls.h: Removed an unneeded include.
+
+        * html/track/DataCue.cpp:
+        (WebCore::toDataCue): Deleted. No need for this function since we can use
+        downcast<DataCue> instead.
+        (WebCore::DataCue::cueContentsMatch const): Removed unnecessary check of cueType.
+        The isEqual function checks cueType and only calls this function if it matches.
+        Use downcast instead of toDataCue.
+        (WebCore::DataCue::isEqual const): Deleted. Base class now handles this.
+        (WebCore::DataCue::doesExtendCue const): Deleted. Was never being called.
+        (WebCore::DataCue::toJSONString const): Deleted. Override toJSON instead.
+        (WebCore::DataCue::toJSON const): Moved the code here that used to be in toJSONString.
+
+        * html/track/DataCue.h: Reduced includes. Made overridden functions private
+        and final. Removed functions as mmentioned above. Changed WTF::LogArgument implementation
+        to just forward to TextTrackCue instead of reimplementing here.
+
+        * html/track/InbandDataTextTrack.cpp:
+        (WebCore::InbandDataTextTrack::removeCue): Use downcast instead of toDataCue.
+
+        * html/track/InbandGenericTextTrack.cpp: Removed an unneeded include.
+
+        * html/track/LoadableTextTrack.cpp:
+        (WebCore::LoadableTextTrack::LoadableTextTrack): Removed unneeded initialization of
+        m_isDefault, which is initialized in the class definition.
+        (WebCore::LoadableTextTrack::newCuesAvailable): Removed unneeded call to toVTTCue,
+        taking advantage of the better interface of getNewCues, which now returns
+        Vector<Ref<VTTCue>>, making the type explicit.
+
+        * html/track/TextTrack.cpp:
+        (WebCore::TextTrack::addCue): Use is<DataCue> instead of checking cueType.
+
+        * html/track/TextTrackCue.cpp:
+        (WebCore::TextTrackCue::create): Fixed confusing naming that called the fragment the
+        cue is contained in "cueDocument"; call it cueFragment instead. This constructor
+        already required that the ScriptExecutionContext be a Document. Did the type cast
+        for that up front. In the future would be good to change the argument type to Document.
+        Also fixed how the newly-created fragment is passed to the constructor. The old code
+        tried to use DocumentFragment&& to pass ownership, but since this is a reference-counted
+        object it needs to be Ref<DocumentFragment>&&.
+        (WebCore::TextTrackCue::TextTrackCue):
+        (WebCore::TextTrackCue::scriptExecutionContext const): Moved this here from the header
+        file so we can compile without TextTrackCue.h including Document.h.
+        (WebCore::TextTrackCue::cueContentsMatch const): Removed the code that checks cueType.
+        It's now isEqual that is responsible for checking that the cueType matches, and
+        cueContentsMatch is only called when the types are the same.
+        (WebCore::TextTrackCue::isEqual const): Reordered the boolean checks a bit so it's
+        easier to see the logic; no need for a cascade of if statements.
+        (WebCore::TextTrackCue::doesExtendCue const): Deleted. Was never being called.
+        (WebCore::operator<<): Use downcast instead of toVTTCue.
+
+        * html/track/TextTrackCue.h: Made isEqual no longer virtual. The per-class behavior
+        is now all in the virtual cueContentsMatch function, only called by isEqual.
+        Removed uncalled doesExtendCue function. Added some argument names in cases where
+        the type alone did not make their purpose clear. Made some things more private.
+        Replaced m_scriptExecutionContext with m_document.
+
+        * html/track/TextTrackCueGeneric.cpp:
+        (WebCore::TextTrackCueGeneric::create): Moved this function here from the header.
+        (WebCore::TextTrackCueGeneric::TextTrackCueGeneric): Initialized data members in the
+        class definition so they don't also need to be initialized here.
+        (WebCore::TextTrackCueGeneric::cueContentsMatch const): Rewrote using && rather than
+        castcading if statements, making the function shorter andd easier to read.
+        (WebCore::TextTrackCueGeneric::isEqual const): Deleted. Base class now handes this.
+        The old version had confusing logic to deal with checking cue type; can now do this
+        in a more straightforward way.
+        (WebCore::TextTrackCueGeneric::doesExtendCue const): Deleted. Was never called.
+        (WebCore::TextTrackCueGeneric::isOrderedBefore const): Use is<TextTrackCueGeneric>
+        and downcast<TextTrackCueGeneric>.
+        (WebCore::TextTrackCueGeneric::isPositionedAbove const): Ditto. Also merged two
+        if statements so there is less repeated logic.
+        (WebCore::TextTrackCueGeneric::toJSONString const): Deleted.
+        (WebCore::TextTrackCueGeneric::toJSON const): Moved code here that was in toJSONString.
+
+        * html/track/TextTrackCueGeneric.h: Made things more private. Changed WTF::LogArgument
+        implementation to just forward to TextTrackCue instead of reimplementing here.
+
+        * html/track/TextTrackCueList.cpp:
+        (WebCore::TextTrackCueList::create): Moved here from header.
+        * html/track/TextTrackCueList.h: Ditto.
+
+        * html/track/VTTCue.cpp: Moved undefinedPosition to be a private static constexpr
+        data member so it can be used in initialization.
+        (WebCore::VTTCueBox::applyCSSProperties): Use is<VTTCue> and downcast<VTTCue>.
+        (WebCore::VTTCue::create): Moved more overloads of this function here from the
+        header file.
+        (WebCore::VTTCue::VTTCue): Take Document instead of ScriptExecutionContext.
+        Also took the ScriptExecutionContext argument away from the initialize function.
+        (WebCore::VTTCue::initialize): Do less initialization here. This function is
+        only called in constructors, so it doesn't need to initialize anything that
+        is initialized in all constructors or initialized in the class definition.
+        What remains are things that require a little code to initialize and the
+        bitfields, which can't be initialized in the class definition.
+        (WebCore::VTTCue::setPosition): Rearranged the code a tiny bit.
+        (WebCore::copyWebVTTNodeToDOMTree): Made this a non-member function. Also changed
+        the argument types to use references.
+        (WebCore::VTTCue::getCueAsHTML): Updated for changes to copyWebVTTNodeToDOMTree.
+        (WebCore::VTTCue::removeDisplayTree): Check m_displayTree directly instead
+        of calling a hasDisplayTree function, since that's more a more straightforward
+        way to guard a subsequent line of code that then uses m_displayTree.
+        (WebCore::VTTCue::setCueSettings): Merged two if statements into one.
+        (WebCore::VTTCue::cueContentsMatch const): Rewrote using && rather than
+        castcading if statements, making the function shorter andd easier to read.
+        (WebCore::VTTCue::isEqual const): Deleted. Base class now handles this.
+        (WebCore::VTTCue::doesExtendCue const): Deleted. Was never called.
+        (WebCore::toVTTCue): Deleted.
+        (WebCore::VTTCue::toJSONString const): Deleted. Base class now handles this.
+        (WebCore::VTTCue::toJSON const): Added a comment.
+
+        * html/track/VTTCue.h: Moved create functions out of header, made some things
+        more private and final, initialized more data members in the class definition.
+        Removed toVTTCue. Changed WTF::LogArgument implementation to just forward to
+        TextTrackCue instead of reimplementing here. Corrected the isType function so
+        it knows about both cue types that result in a VTTCue object. This allows us
+        to use is<VTTCue> and downcast<VTTCue> in the normal way. Removed the FIXME
+        saying we should do that.
+
+        * loader/TextTrackLoader.cpp:
+        (WebCore::TextTrackLoader::getNewCues): Changed to return a Vector<Ref<VTTCue>>.
+        In modern C++ return value is better than an out argument for a function like
+        this, and the more-specific type helps us at the call sites.
+
+        * loader/TextTrackLoader.h: Updated for the above.
+
+        * page/CaptionUserPreferencesMediaAF.cpp: Removed unneeded include.
+
+        * platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h:
+        Use #pragma once and removed some unneded includes and forward declarations.
+
+        * rendering/RenderVTTCue.cpp:
+        (WebCore::RenderVTTCue::RenderVTTCue): Use downcast<VTTCue>.
+        (WebCore::RenderVTTCue::layout): Removed unneeded call to toVTTCue.
+        (WebCore::RenderVTTCue::repositionGenericCue): Use downcast instead of
+        static_cast for TextTrackCueGeneric.
+
+        * style/RuleSet.cpp: Removed unneeded include.
+
 2020-02-24  Chris Fleizach  <cfleizach@apple.com>
 
         AX: Support relative frames for isolated trees correctly
index 3f75784..969c50d 100644 (file)
@@ -2031,11 +2031,11 @@ void HTMLMediaElement::textTrackRemoveCue(TextTrack&, TextTrackCue& cue)
     m_cueData->cueTree.remove(interval);
 
     // Since the cue will be removed from the media element and likely the
-    // TextTrack might also be destructed, notifying the region of the cue
+    // TextTrack might also be destroyed, notifying the region of the cue
     // removal shouldn't be done.
     auto isVTT = is<VTTCue>(cue);
     if (isVTT)
-        toVTTCue(&cue)->notifyRegionWhenRemovingDisplayTree(false);
+        downcast<VTTCue>(cue).notifyRegionWhenRemovingDisplayTree(false);
 
     size_t index = m_cueData->currentlyActiveCues.find(interval);
     if (index != notFound) {
@@ -2047,7 +2047,7 @@ void HTMLMediaElement::textTrackRemoveCue(TextTrack&, TextTrackCue& cue)
     updateActiveTextTrackCues(currentMediaTime());
 
     if (isVTT)
-        toVTTCue(&cue)->notifyRegionWhenRemovingDisplayTree(true);
+        downcast<VTTCue>(cue).notifyRegionWhenRemovingDisplayTree(true);
 }
 
 CueList HTMLMediaElement::currentlyActiveCues() const
index e71563c..5de0d11 100644 (file)
@@ -47,8 +47,6 @@
 #include "AudioTrack.h"
 #include "CaptionUserPreferences.h"
 #include "TextTrack.h"
-#include "TextTrackCue.h"
-#include "VTTCue.h"
 #include "VideoTrack.h"
 #endif
 
index 733376c..eeba894 100644 (file)
@@ -1190,8 +1190,8 @@ void MediaControlTextTrackContainerElement::updateDisplay()
         for (auto& interval : activeCues) {
             auto cue = interval.data();
             cue->setFontSize(m_fontSize, m_videoDisplaySize.size(), m_fontSizeIsImportant);
-            if (is<VTTCue>(cue) || is<TextTrackCueGeneric>(cue))
-                processActiveVTTCue(*toVTTCue(cue));
+            if (is<VTTCue>(*cue))
+                processActiveVTTCue(downcast<VTTCue>(*cue));
             else {
                 auto displayBox = cue->getDisplayTree(m_videoDisplaySize.size(), m_fontSize);
                 if (displayBox->hasChildNodes() && !contains(displayBox.get()))
@@ -1212,8 +1212,6 @@ void MediaControlTextTrackContainerElement::updateDisplay()
 
 void MediaControlTextTrackContainerElement::processActiveVTTCue(VTTCue& cue)
 {
-    ASSERT(is<VTTCue>(cue) || is<TextTrackCueGeneric>(cue));
-
     DEBUG_LOG(LOGIDENTIFIER, "adding and positioning cue: \"", cue.text(), "\", start=", cue.startTime(), ", end=", cue.endTime(), ", line=", cue.line());
     Ref<TextTrackCueBox> displayBox = *cue.getDisplayTree(m_videoDisplaySize.size(), m_fontSize);
 
index 4766b34..f4f0d1c 100644 (file)
 #include "MediaControlElements.h"
 #include <wtf/RefPtr.h>
 
-#if ENABLE(VIDEO_TRACK)
-#include "TextTrackCue.h"
-#endif
-
 namespace WebCore {
 
 class Document;
 class Event;
 class MediaPlayer;
-
 class RenderBox;
 class RenderMedia;
 
index 5d5e3f3..3b032f1 100644 (file)
@@ -27,6 +27,7 @@
 #include "config.h"
 
 #if ENABLE(VIDEO_TRACK)
+
 #include "DataCue.h"
 
 #include "Logging.h"
@@ -90,24 +91,9 @@ void DataCue::setData(ArrayBuffer& data)
     m_data = ArrayBuffer::create(data);
 }
 
-DataCue* toDataCue(TextTrackCue* cue)
-{
-    ASSERT_WITH_SECURITY_IMPLICATION(cue->cueType() == TextTrackCue::Data);
-    return static_cast<DataCue*>(cue);
-}
-
-const DataCue* toDataCue(const TextTrackCue* cue)
-{
-    ASSERT_WITH_SECURITY_IMPLICATION(cue->cueType() == TextTrackCue::Data);
-    return static_cast<const DataCue*>(cue);
-}
-
 bool DataCue::cueContentsMatch(const TextTrackCue& cue) const
 {
-    if (cue.cueType() != TextTrackCue::Data)
-        return false;
-
-    const DataCue* dataCue = toDataCue(&cue);
+    const DataCue* dataCue = downcast<DataCue>(&cue);
     RefPtr<ArrayBuffer> otherData = dataCue->data();
     if ((otherData && !m_data) || (!otherData && m_data))
         return false;
@@ -132,25 +118,6 @@ bool DataCue::cueContentsMatch(const TextTrackCue& cue) const
     return true;
 }
 
-bool DataCue::isEqual(const TextTrackCue& cue, TextTrackCue::CueMatchRules match) const
-{
-    if (!TextTrackCue::isEqual(cue, match))
-        return false;
-
-    if (cue.cueType() != TextTrackCue::Data)
-        return false;
-
-    return cueContentsMatch(cue);
-}
-
-bool DataCue::doesExtendCue(const TextTrackCue& cue) const
-{
-    if (!cueContentsMatch(cue))
-        return false;
-
-    return TextTrackCue::doesExtendCue(cue);
-}
-
 JSC::JSValue DataCue::value(JSC::JSGlobalObject& state) const
 {
     if (m_platformValue)
@@ -178,16 +145,12 @@ JSValue DataCue::valueOrNull() const
     return jsNull();
 }
 
-String DataCue::toJSONString() const
+void DataCue::toJSON(JSON::Object& object) const
 {
-    auto object = JSON::Object::create();
-
-    TextTrackCue::toJSON(object.get());
+    TextTrackCue::toJSON(object);
 
     if (!m_type.isEmpty())
-        object->setString("type"_s, m_type);
-
-    return object->toJSONString();
+        object.setString("type"_s, m_type);
 }
 
 } // namespace WebCore
index 63a67c0..57e9ae9 100644 (file)
 
 #include "SerializedPlatformDataCue.h"
 #include "TextTrackCue.h"
-#include <JavaScriptCore/ArrayBuffer.h>
-#include <JavaScriptCore/JSCJSValue.h>
 #include <wtf/MediaTime.h>
 #include <wtf/TypeCasts.h>
 
+namespace JSC {
+class ArrayBuffer;
+class JSValue;
+}
+
 namespace WebCore {
 
 class ScriptExecutionContext;
@@ -72,7 +75,6 @@ public:
     }
 
     virtual ~DataCue();
-    CueType cueType() const override { return Data; }
 
     RefPtr<JSC::ArrayBuffer> data() const;
     void setData(JSC::ArrayBuffer&);
@@ -85,12 +87,6 @@ public:
     String type() const { return m_type; }
     void setType(const String& type) { m_type = type; }
 
-    bool isEqual(const TextTrackCue&, CueMatchRules) const override;
-    bool cueContentsMatch(const TextTrackCue&) const override;
-    bool doesExtendCue(const TextTrackCue&) const override;
-
-    String toJSONString() const;
-
 private:
     DataCue(ScriptExecutionContext&, const MediaTime& start, const MediaTime& end, ArrayBuffer&, const String&);
     DataCue(ScriptExecutionContext&, const MediaTime& start, const MediaTime& end, const void*, unsigned);
@@ -98,6 +94,9 @@ private:
     DataCue(ScriptExecutionContext&, const MediaTime& start, const MediaTime& end, JSC::JSValue, const String&);
 
     JSC::JSValue valueOrNull() const;
+    CueType cueType() const final { return Data; }
+    bool cueContentsMatch(const TextTrackCue&) const final;
+    void toJSON(JSON::Object&) const final;
 
     RefPtr<ArrayBuffer> m_data;
     String m_type;
@@ -108,23 +107,11 @@ private:
     JSC::Strong<JSC::Unknown> m_value;
 };
 
-DataCue* toDataCue(TextTrackCue*);
-const DataCue* toDataCue(const TextTrackCue*);
-
 } // namespace WebCore
 
 namespace WTF {
 
-template<typename Type>
-struct LogArgument;
-
-template <>
-struct LogArgument<WebCore::DataCue> {
-    static String toString(const WebCore::DataCue& cue)
-    {
-        return cue.toJSONString();
-    }
-};
+template<> struct LogArgument<WebCore::DataCue> : LogArgument<WebCore::TextTrackCue> { };
 
 }
 
index 0c04f3c..4d60d6b 100644 (file)
@@ -125,7 +125,7 @@ ExceptionOr<void> InbandDataTextTrack::removeCue(TextTrackCue& cue)
 {
     ASSERT(cue.cueType() == TextTrackCue::Data);
 
-    if (auto platformValue = const_cast<SerializedPlatformDataCue*>(toDataCue(&cue)->platformValue()))
+    if (auto platformValue = const_cast<SerializedPlatformDataCue*>(downcast<DataCue>(cue).platformValue()))
         removeDataCue({ }, { }, *platformValue);
 
     return InbandTextTrack::removeCue(cue);
index 262894f..651bbc1 100644 (file)
@@ -28,7 +28,6 @@
 
 #if ENABLE(VIDEO_TRACK)
 
-#include "DataCue.h"
 #include "HTMLMediaElement.h"
 #include "InbandTextTrackPrivate.h"
 #include "Logging.h"
index 7a1e1bc..ceb02cf 100644 (file)
@@ -43,7 +43,6 @@ LoadableTextTrack::LoadableTextTrack(HTMLTrackElement& track, const String& kind
     : TextTrack(&track.document(), &track, kind, emptyString(), label, language, TrackElement)
     , m_trackElement(&track)
     , m_loadTimer(*this, &LoadableTextTrack::loadTimerFired)
-    , m_isDefault(false)
 {
 }
 
@@ -93,16 +92,13 @@ void LoadableTextTrack::newCuesAvailable(TextTrackLoader& loader)
 {
     ASSERT_UNUSED(loader, m_loader.get() == &loader);
 
-    Vector<RefPtr<TextTrackCue>> newCues;
-    m_loader->getNewCues(newCues);
-
     if (!m_cues)
         m_cues = TextTrackCueList::create();    
 
-    for (auto& newCue : newCues) {
+    for (auto& newCue : m_loader->getNewCues()) {
         newCue->setTrack(this);
-        INFO_LOG(LOGIDENTIFIER, *toVTTCue(newCue.get()));
-        m_cues->add(newCue.releaseNonNull());
+        INFO_LOG(LOGIDENTIFIER, newCue.get());
+        m_cues->add(WTFMove(newCue));
     }
 
     if (client())
index ff6ec8b..3fe0540 100644 (file)
@@ -34,6 +34,7 @@
 
 #if ENABLE(VIDEO_TRACK)
 
+#include "DataCue.h"
 #include "Document.h"
 #include "Event.h"
 #include "HTMLMediaElement.h"
@@ -301,7 +302,7 @@ ExceptionOr<void> TextTrack::addCue(Ref<TextTrackCue>&& cue)
     // If a DataCue is added to a TextTrack via the addCue() method but the text track does not have its text
     // track kind set to metadata, throw a InvalidNodeTypeError exception and don't add the cue to the TextTrackList
     // of the TextTrack.
-    if (cue->cueType() == TextTrackCue::Data && m_kind != Kind::Metadata)
+    if (is<DataCue>(cue.get()) && m_kind != Kind::Metadata)
         return Exception { InvalidNodeTypeError };
 
     INFO_LOG(LOGIDENTIFIER, cue.get());
index 9f92e88..fa37db8 100644 (file)
@@ -183,27 +183,26 @@ static void removePseudoAttributes(Node& node)
         removePseudoAttributes(*child);
 }
 
-ExceptionOr<Ref<TextTrackCue>> TextTrackCue::create(ScriptExecutionContext& context, double start, double end, DocumentFragment& cueDocument)
+ExceptionOr<Ref<TextTrackCue>> TextTrackCue::create(ScriptExecutionContext& context, double start, double end, DocumentFragment& cueFragment)
 {
-    ASSERT(context.isDocument());
-    ASSERT(is<DocumentFragment>(cueDocument));
+    auto& document = downcast<Document>(context);
 
-    if (!cueDocument.firstChild())
+    if (!cueFragment.firstChild())
         return Exception { InvalidNodeTypeError, "Empty cue fragment" };
 
-    for (Node* node = cueDocument.firstChild(); node; node = node->nextSibling()) {
+    for (Node* node = cueFragment.firstChild(); node; node = node->nextSibling()) {
         auto result = checkForInvalidNodeTypes(*node);
         if (result.hasException())
             return result.releaseException();
     }
 
-    auto fragment = DocumentFragment::create(downcast<Document>(context));
-    for (Node* node = cueDocument.firstChild(); node; node = node->nextSibling()) {
+    auto fragment = DocumentFragment::create(document);
+    for (Node* node = cueFragment.firstChild(); node; node = node->nextSibling()) {
         auto result = fragment->ensurePreInsertionValidity(*node, nullptr);
         if (result.hasException())
             return result.releaseException();
     }
-    cueDocument.cloneChildNodes(fragment);
+    cueFragment.cloneChildNodes(fragment);
 
     OptionSet<RequiredNodes> nodeTypes = { };
     for (Node* node = fragment->firstChild(); node; node = node->nextSibling())
@@ -214,21 +213,27 @@ ExceptionOr<Ref<TextTrackCue>> TextTrackCue::create(ScriptExecutionContext& cont
     if (!nodeTypes.contains(RequiredNodes::CueBackground))
         return Exception { InvalidStateError, makeString("Missing required attribute: ", cueBackgroundAttributName().toString()) };
 
-    return adoptRef(*new TextTrackCue(context, MediaTime::createWithDouble(start), MediaTime::createWithDouble(end), WTFMove(fragment.get())));
+    return adoptRef(*new TextTrackCue(document, MediaTime::createWithDouble(start), MediaTime::createWithDouble(end), WTFMove(fragment)));
 }
 
-TextTrackCue::TextTrackCue(ScriptExecutionContext& context, const MediaTime& start, const MediaTime& end, DocumentFragment&& cueFragment)
-    : TextTrackCue(context, start, end)
+TextTrackCue::TextTrackCue(Document& document, const MediaTime& start, const MediaTime& end, Ref<DocumentFragment>&& cueFragment)
+    : m_startTime(start)
+    , m_endTime(end)
+    , m_document(document)
+    , m_cueNode(WTFMove(cueFragment))
 {
-    m_cueNode = &cueFragment;
 }
 
 TextTrackCue::TextTrackCue(ScriptExecutionContext& context, const MediaTime& start, const MediaTime& end)
     : m_startTime(start)
     , m_endTime(end)
-    , m_scriptExecutionContext(context)
+    , m_document(downcast<Document>(context))
+{
+}
+
+ScriptExecutionContext* TextTrackCue::scriptExecutionContext() const
 {
-    ASSERT(m_scriptExecutionContext.isDocument());
+    return &m_document;
 }
 
 void TextTrackCue::willChange()
@@ -363,30 +368,16 @@ bool TextTrackCue::isOrderedBefore(const TextTrackCue* other) const
     return cueIndex() < other->cueIndex();
 }
 
-bool TextTrackCue::cueContentsMatch(const TextTrackCue& cue) const
+bool TextTrackCue::cueContentsMatch(const TextTrackCue& other) const
 {
-    if (cueType() != cue.cueType())
-        return false;
-
-    if (id() != cue.id())
-        return false;
-
-    return true;
+    return m_id == other.m_id;
 }
 
-bool TextTrackCue::isEqual(const TextTrackCue& cue, TextTrackCue::CueMatchRules match) const
+bool TextTrackCue::isEqual(const TextTrackCue& other, TextTrackCue::CueMatchRules match) const
 {
-    if (cueType() != cue.cueType())
-        return false;
-
-    if (match != IgnoreDuration && endMediaTime() != cue.endMediaTime())
-        return false;
-    if (!hasEquivalentStartTime(cue))
+    if (match != IgnoreDuration && endMediaTime() != other.endMediaTime())
         return false;
-    if (!cueContentsMatch(cue))
-        return false;
-
-    return true;
+    return cueType() == other.cueType() && hasEquivalentStartTime(other) && cueContentsMatch(other);
 }
 
 bool TextTrackCue::hasEquivalentStartTime(const TextTrackCue& cue) const
@@ -400,17 +391,6 @@ bool TextTrackCue::hasEquivalentStartTime(const TextTrackCue& cue) const
     return abs(abs(startMediaTime()) - abs(cue.startMediaTime())) <= startTimeVariance;
 }
 
-bool TextTrackCue::doesExtendCue(const TextTrackCue& cue) const
-{
-    if (!cueContentsMatch(cue))
-        return false;
-
-    if (endMediaTime() != cue.startMediaTime())
-        return false;
-    
-    return true;
-}
-
 void TextTrackCue::toJSON(JSON::Object& value) const
 {
     ASCIILiteral type = "Generic"_s;
@@ -437,9 +417,7 @@ void TextTrackCue::toJSON(JSON::Object& value) const
 String TextTrackCue::toJSONString() const
 {
     auto object = JSON::Object::create();
-
     toJSON(object.get());
-
     return object->toJSONString();
 }
 
@@ -449,7 +427,7 @@ TextStream& operator<<(TextStream& stream, const TextTrackCue& cue)
 {
     String text;
     if (is<VTTCue>(cue))
-        text = toVTTCue(&cue)->text();
+        text = downcast<VTTCue>(cue).text();
     return stream << &cue << " id=" << cue.id() << " interval=" << cue.startTime() << "-->" << cue.endTime() << " cue=" << text << ')';
 }
 
index 6f3eeab..c6e738b 100644 (file)
@@ -33,7 +33,6 @@
 
 #if ENABLE(VIDEO_TRACK)
 
-#include "Document.h"
 #include "DocumentFragment.h"
 #include "HTMLElement.h"
 #include <wtf/JSONValues.h>
@@ -107,13 +106,12 @@ public:
     virtual bool isRenderable() const;
 
     enum CueMatchRules { MatchAllFields, IgnoreDuration };
-    virtual bool isEqual(const TextTrackCue&, CueMatchRules) const;
-    virtual bool doesExtendCue(const TextTrackCue&) const;
+    bool isEqual(const TextTrackCue&, CueMatchRules) const;
 
     void willChange();
     virtual void didChange();
 
-    virtual RefPtr<TextTrackCueBox> getDisplayTree(const IntSize&, int);
+    virtual RefPtr<TextTrackCueBox> getDisplayTree(const IntSize& videoSize, int fontSize);
     virtual void removeDisplayTree();
 
     virtual RefPtr<DocumentFragment> getCueAsHTML();
@@ -124,20 +122,22 @@ public:
     using RefCounted::deref;
 
     virtual void recalculateStyles() { m_displayTreeNeedsUpdate = true; }
-    virtual void setFontSize(int, const IntSize&, bool important);
-    virtual void updateDisplayTree(const MediaTime&) { };
+    virtual void setFontSize(int fontSize, const IntSize& videoSize, bool important);
+    virtual void updateDisplayTree(const MediaTime&) { }
 
     unsigned cueIndex() const;
 
 protected:
-    TextTrackCue(ScriptExecutionContext&, const MediaTime& start, const MediaTime& end, DocumentFragment&&);
     TextTrackCue(ScriptExecutionContext&, const MediaTime& start, const MediaTime& end);
 
-    Document& ownerDocument() { return downcast<Document>(m_scriptExecutionContext); }
+    Document& ownerDocument() { return m_document; }
 
+    virtual bool cueContentsMatch(const TextTrackCue&) const;
     virtual void toJSON(JSON::Object&) const;
 
 private:
+    TextTrackCue(Document&, const MediaTime& start, const MediaTime& end, Ref<DocumentFragment>&&);
+
     void refEventTarget() final { ref(); }
     void derefEventTarget() final { deref(); }
 
@@ -145,9 +145,7 @@ private:
     void dispatchEvent(Event&) final;
 
     EventTargetInterface eventTargetInterface() const final { return TextTrackCueEventTargetInterfaceType; }
-    ScriptExecutionContext* scriptExecutionContext() const final { return &m_scriptExecutionContext; }
-
-    virtual bool cueContentsMatch(const TextTrackCue&) const;
+    ScriptExecutionContext* scriptExecutionContext() const final;
 
     void rebuildDisplayTree();
 
@@ -158,7 +156,7 @@ private:
 
     TextTrack* m_track { nullptr };
 
-    ScriptExecutionContext& m_scriptExecutionContext;
+    Document& m_document;
 
     RefPtr<DocumentFragment> m_cueNode;
     RefPtr<TextTrackCueBox> m_displayTree;
index 982f286..eefecaa 100644 (file)
@@ -38,7 +38,6 @@
 #include "RenderObject.h"
 #include "ScriptExecutionContext.h"
 #include "StyleProperties.h"
-#include "TextTrackCue.h"
 #include <wtf/IsoMallocInlines.h>
 #include <wtf/MathExtras.h>
 
@@ -155,10 +154,13 @@ void TextTrackCueGenericBoxElement::applyCSSProperties(const IntSize& videoSize)
     cueElement->setInlineStyleProperty(CSSPropertyOverflow, CSSValueVisible);
 }
 
-TextTrackCueGeneric::TextTrackCueGeneric(ScriptExecutionContext& context, const MediaTime& start, const MediaTime& end, const String& content)
-    : VTTCue(context, start, end, content)
-    , m_baseFontSizeRelativeToVideoHeight(0)
-    , m_fontSizeMultiplier(0)
+Ref<TextTrackCueGeneric> TextTrackCueGeneric::create(ScriptExecutionContext& context, const MediaTime& start, const MediaTime& end, const String& content)
+{
+    return adoptRef(*new TextTrackCueGeneric(downcast<Document>(context), start, end, content));
+}
+
+TextTrackCueGeneric::TextTrackCueGeneric(Document& document, const MediaTime& start, const MediaTime& end, const String& content)
+    : VTTCue(document, start, end, content)
 {
 }
 
@@ -199,49 +201,15 @@ void TextTrackCueGeneric::setFontSize(int fontSize, const IntSize& videoSize, bo
     displayTreeInternal().setInlineStyleProperty(CSSPropertyFontSize, lround(size), CSSUnitType::CSS_PX);
 }
 
-bool TextTrackCueGeneric::cueContentsMatch(const TextTrackCue& cue) const
-{
-    // Do call the parent class cueContentsMatch here, because we want to confirm
-    // the content of the two cues are identical (even though the types are not the same).
-    if (!VTTCue::cueContentsMatch(cue))
-        return false;
-    
-    const TextTrackCueGeneric* other = static_cast<const TextTrackCueGeneric*>(&cue);
-
-    if (m_baseFontSizeRelativeToVideoHeight != other->baseFontSizeRelativeToVideoHeight())
-        return false;
-    if (m_fontSizeMultiplier != other->fontSizeMultiplier())
-        return false;
-    if (m_fontName != other->fontName())
-        return false;
-    if (m_foregroundColor != other->foregroundColor())
-        return false;
-    if (m_backgroundColor != other->backgroundColor())
-        return false;
-
-    return true;
-}
-
-bool TextTrackCueGeneric::isEqual(const TextTrackCue& cue, TextTrackCue::CueMatchRules match) const
-{
-    // Do not call the parent class isEqual here, because we are not cueType() == VTTCue,
-    // and will fail that equality test.
-    if (!TextTrackCue::isEqual(cue, match))
-        return false;
-
-    if (cue.cueType() != TextTrackCue::ConvertedToWebVTT)
-        return false;
-
-    return cueContentsMatch(cue);
-}
-
-    
-bool TextTrackCueGeneric::doesExtendCue(const TextTrackCue& cue) const
+bool TextTrackCueGeneric::cueContentsMatch(const TextTrackCue& otherTextTrackCue) const
 {
-    if (!cueContentsMatch(cue))
-        return false;
-    
-    return VTTCue::doesExtendCue(cue);
+    auto& other = downcast<TextTrackCueGeneric>(otherTextTrackCue);
+    return VTTCue::cueContentsMatch(other)
+        && m_baseFontSizeRelativeToVideoHeight == other.m_baseFontSizeRelativeToVideoHeight
+        && m_fontSizeMultiplier == other.m_fontSizeMultiplier
+        && m_fontName == other.m_fontName
+        && m_foregroundColor == other.m_foregroundColor
+        && m_backgroundColor == other.m_backgroundColor;
 }
 
 bool TextTrackCueGeneric::isOrderedBefore(const TextTrackCue* that) const
@@ -249,10 +217,10 @@ bool TextTrackCueGeneric::isOrderedBefore(const TextTrackCue* that) const
     if (VTTCue::isOrderedBefore(that))
         return true;
 
-    if (that->cueType() == ConvertedToWebVTT && startTime() == that->startTime() && endTime() == that->endTime()) {
+    if (is<TextTrackCueGeneric>(*that) && startTime() == that->startTime() && endTime() == that->endTime()) {
         // Further order generic cues by their calculated line value.
         std::pair<double, double> thisPosition = getPositionCoordinates();
-        std::pair<double, double> thatPosition = toVTTCue(that)->getPositionCoordinates();
+        std::pair<double, double> thatPosition = downcast<TextTrackCueGeneric>(*that).getPositionCoordinates();
         return thisPosition.second > thatPosition.second || (thisPosition.second == thatPosition.second && thisPosition.first < thatPosition.first);
     }
 
@@ -261,39 +229,33 @@ bool TextTrackCueGeneric::isOrderedBefore(const TextTrackCue* that) const
 
 bool TextTrackCueGeneric::isPositionedAbove(const TextTrackCue* that) const
 {
-    if (that->cueType() == ConvertedToWebVTT && startTime() == that->startTime() && endTime() == that->endTime()) {
-        // Further order generic cues by their calculated line value.
-        std::pair<double, double> thisPosition = getPositionCoordinates();
-        std::pair<double, double> thatPosition = toVTTCue(that)->getPositionCoordinates();
-        return thisPosition.second > thatPosition.second || (thisPosition.second == thatPosition.second && thisPosition.first < thatPosition.first);
-    }
-    
-    if (that->cueType() == ConvertedToWebVTT)
+    if (is<TextTrackCueGeneric>(*that)) {
+        if (startTime() == that->startTime() && endTime() == that->endTime()) {
+            // Further order generic cues by their calculated line value.
+            std::pair<double, double> thisPosition = getPositionCoordinates();
+            std::pair<double, double> thatPosition = downcast<TextTrackCueGeneric>(*that).getPositionCoordinates();
+            return thisPosition.second > thatPosition.second || (thisPosition.second == thatPosition.second && thisPosition.first < thatPosition.first);
+        }
         return startTime() > that->startTime();
-    
+    }
+
     return VTTCue::isOrderedBefore(that);
 }
 
-String TextTrackCueGeneric::toJSONString() const
+void TextTrackCueGeneric::toJSON(JSON::Object& object) const
 {
-    auto object = JSON::Object::create();
-
-    toJSON(object.get());
-
     if (m_foregroundColor.isValid())
-        object->setString("foregroundColor"_s, m_foregroundColor.serialized());
+        object.setString("foregroundColor"_s, m_foregroundColor.serialized());
     if (m_backgroundColor.isValid())
-        object->setString("backgroundColor"_s, m_backgroundColor.serialized());
+        object.setString("backgroundColor"_s, m_backgroundColor.serialized());
     if (m_highlightColor.isValid())
-        object->setString("highlightColor"_s, m_highlightColor.serialized());
+        object.setString("highlightColor"_s, m_highlightColor.serialized());
     if (m_baseFontSizeRelativeToVideoHeight)
-        object->setDouble("relativeFontSize"_s, m_baseFontSizeRelativeToVideoHeight);
+        object.setDouble("relativeFontSize"_s, m_baseFontSizeRelativeToVideoHeight);
     if (m_fontSizeMultiplier)
-        object->setDouble("fontSizeMultiplier"_s, m_fontSizeMultiplier);
+        object.setDouble("fontSizeMultiplier"_s, m_fontSizeMultiplier);
     if (!m_fontName.isEmpty())
-        object->setString("font"_s, m_fontName);
-
-    return object->toJSONString();
+        object.setString("font"_s, m_fontName);
 }
 
 } // namespace WebCore
index fd0cb3e..1fcd419 100644 (file)
 
 namespace WebCore {
 
-class GenericCueData;
-
 // A "generic" cue is a non-WebVTT cue, so it is not positioned/sized with the WebVTT logic.
 class TextTrackCueGeneric final : public VTTCue {
     WTF_MAKE_ISO_ALLOCATED_EXPORT(TextTrackCueGeneric, WEBCORE_EXPORT);
 public:
-    static Ref<TextTrackCueGeneric> create(ScriptExecutionContext& context, const MediaTime& start, const MediaTime& end, const String& content)
-    {
-        return adoptRef(*new TextTrackCueGeneric(context, start, end, content));
-    }
+    WEBCORE_EXPORT static Ref<TextTrackCueGeneric> create(ScriptExecutionContext&, const MediaTime& start, const MediaTime& end, const String& content);
 
     ExceptionOr<void> setLine(double) final;
     ExceptionOr<void> setPosition(const LineAndPositionSetting&) final;
@@ -68,22 +63,20 @@ public:
 
     void setFontSize(int, const IntSize&, bool important) final;
 
-    String toJSONString() const;
-
 private:
-    WEBCORE_EXPORT TextTrackCueGeneric(ScriptExecutionContext&, const MediaTime& start, const MediaTime& end, const String&);
-    
+    TextTrackCueGeneric(Document&, const MediaTime& start, const MediaTime& end, const String&);
+
     bool isOrderedBefore(const TextTrackCue*) const final;
     bool isPositionedAbove(const TextTrackCue*) const final;
 
     Ref<VTTCueBox> createDisplayTree() final;
 
-    bool isEqual(const TextTrackCue&, CueMatchRules) const final;
     bool cueContentsMatch(const TextTrackCue&) const final;
-    bool doesExtendCue(const TextTrackCue&) const final;
 
     CueType cueType() const final { return ConvertedToWebVTT; }
 
+    void toJSON(JSON::Object&) const final;
+
     Color m_foregroundColor;
     Color m_backgroundColor;
     Color m_highlightColor;
@@ -97,16 +90,7 @@ private:
 
 namespace WTF {
 
-template<typename Type>
-struct LogArgument;
-
-template <>
-struct LogArgument<WebCore::TextTrackCueGeneric> {
-    static String toString(const WebCore::TextTrackCueGeneric& cue)
-    {
-        return cue.toJSONString();
-    }
-};
+template<> struct LogArgument<WebCore::TextTrackCueGeneric> : LogArgument<WebCore::TextTrackCue> { };
 
 }
 
index 8a0fd0b..43db8fe 100644 (file)
@@ -49,6 +49,11 @@ static inline bool cueSortsBefore(const RefPtr<TextTrackCue>& a, const RefPtr<Te
     return a->startMediaTime() == b->startMediaTime() && a->endMediaTime() > b->endMediaTime();
 }
 
+Ref<TextTrackCueList> TextTrackCueList::create()
+{
+    return adoptRef(*new TextTrackCueList);
+}
+
 unsigned TextTrackCueList::cueIndex(const TextTrackCue& cue) const
 {
     ASSERT(m_vector.contains(&cue));
index c4f786b..66ff08e 100644 (file)
@@ -57,11 +57,6 @@ private:
     RefPtr<TextTrackCueList> m_activeCues;
 };
 
-inline Ref<TextTrackCueList> TextTrackCueList::create()
-{
-    return adoptRef(*new TextTrackCueList);
-}
-
 inline unsigned TextTrackCueList::length() const
 {
     return m_vector.size();
index ec4984e..d48f329 100644 (file)
@@ -64,9 +64,7 @@ WTF_MAKE_ISO_ALLOCATED_IMPL(VTTCue);
 WTF_MAKE_ISO_ALLOCATED_IMPL(VTTCueBox);
 
 // This constant should correspond with the percentage returned by CaptionUserPreferences::captionFontSizeScaleAndImportance.
-static constexpr double DEFAULTCAPTIONFONTSIZEPERCENTAGE = 5;
-
-static constexpr int undefinedPosition = -1;
+constexpr double DEFAULTCAPTIONFONTSIZEPERCENTAGE = 5;
 
 static const CSSValueID displayWritingModeMap[] = {
     CSSValueHorizontalTb, CSSValueVerticalRl, CSSValueVerticalLr
@@ -135,11 +133,11 @@ VTTCueBox::VTTCueBox(Document& document, VTTCue& cue)
 void VTTCueBox::applyCSSProperties(const IntSize& videoSize)
 {
     auto textTrackCue = getCue();
-    if (!textTrackCue)
+    ASSERT(!textTrackCue || is<VTTCue>(textTrackCue));
+    if (!is<VTTCue>(textTrackCue))
         return;
 
-    ASSERT(is<VTTCue>(textTrackCue) || is<TextTrackCueGeneric>(textTrackCue));
-    auto cue = makeRef(*toVTTCue(textTrackCue));
+    auto cue = makeRef(downcast<VTTCue>(*textTrackCue));
 
     // FIXME: Apply all the initial CSS positioning properties. http://wkb.ug/79916
     if (!cue->regionId().isEmpty()) {
@@ -239,51 +237,52 @@ RenderPtr<RenderElement> VTTCueBox::createElementRenderer(RenderStyle&& style, c
 
 // ----------------------------
 
+Ref<VTTCue> VTTCue::create(ScriptExecutionContext& context, double start, double end, const String& content)
+{
+    return adoptRef(*new VTTCue(downcast<Document>(context), MediaTime::createWithDouble(start), MediaTime::createWithDouble(end), content));
+}
+
+Ref<VTTCue> VTTCue::create(ScriptExecutionContext& context, const MediaTime& start, const MediaTime& end, const String& content)
+{
+    return adoptRef(*new VTTCue(downcast<Document>(context), start, end, content));
+}
+
 Ref<VTTCue> VTTCue::create(ScriptExecutionContext& context, const WebVTTCueData& data)
 {
-    return adoptRef(*new VTTCue(context, data));
+    return adoptRef(*new VTTCue(downcast<Document>(context), data));
 }
 
-VTTCue::VTTCue(ScriptExecutionContext& context, const MediaTime& start, const MediaTime& end, const String& content)
-    : TextTrackCue(context, start, end)
+VTTCue::VTTCue(Document& document, const MediaTime& start, const MediaTime& end, const String& content)
+    : TextTrackCue(document, start, end)
     , m_content(content)
+    , m_originalStartTime(MediaTime::zeroTime())
 {
-    initialize(context);
+    initialize();
 }
 
-VTTCue::VTTCue(ScriptExecutionContext& context, const WebVTTCueData& cueData)
-    : TextTrackCue(context, MediaTime::zeroTime(), MediaTime::zeroTime())
+VTTCue::VTTCue(Document& document, const WebVTTCueData& cueData)
+    : TextTrackCue(document, MediaTime::zeroTime(), MediaTime::zeroTime())
+    , m_originalStartTime(cueData.originalStartTime())
 {
-    initialize(context);
+    initialize();
     setText(cueData.content());
     setStartTime(cueData.startTime());
     setEndTime(cueData.endTime());
     setId(cueData.id());
     setCueSettings(cueData.settings());
-    m_originalStartTime = cueData.originalStartTime();
 }
 
 VTTCue::~VTTCue()
 {
 }
 
-void VTTCue::initialize(ScriptExecutionContext& context)
+void VTTCue::initialize()
 {
-    m_linePosition = undefinedPosition;
-    m_computedLinePosition = undefinedPosition;
-    m_textPosition = std::numeric_limits<double>::quiet_NaN();
-    m_cueSize = 100;
-    m_writingDirection = Horizontal;
-    m_cueAlignment = Center;
-    m_webVTTNodeTree = nullptr;
-    m_cueBackdropBox = HTMLDivElement::create(downcast<Document>(context));
-    m_cueHighlightBox = HTMLSpanElement::create(spanTag, downcast<Document>(context));
-    m_displayDirection = CSSValueLtr;
-    m_displaySize = 0;
+    m_cueBackdropBox = HTMLDivElement::create(ownerDocument());
+    m_cueHighlightBox = HTMLSpanElement::create(spanTag, ownerDocument());
     m_snapToLines = true;
     m_displayTreeShouldChange = true;
     m_notifyRegion = true;
-    m_originalStartTime = MediaTime::zeroTime();
 }
 
 Ref<VTTCueBox> VTTCue::createDisplayTree()
@@ -397,11 +396,11 @@ ExceptionOr<void> VTTCue::setPosition(const LineAndPositionSetting& position)
             return { };
         textPosition = std::numeric_limits<double>::quiet_NaN();
     } else {
-        if (!(WTF::get<double>(position) >= 0 && WTF::get<double>(position) <= 100))
+        textPosition = WTF::get<double>(position);
+        if (!(textPosition >= 0 && textPosition <= 100))
             return Exception { IndexSizeError };
 
         // Otherwise, set the text track cue line position to the new value.
-        textPosition = WTF::get<double>(position);
         if (m_textPosition == textPosition)
             return { };
     }
@@ -502,17 +501,17 @@ void VTTCue::createWebVTTNodeTree()
         m_webVTTNodeTree = WebVTTParser::createDocumentFragmentFromCueText(ownerDocument(), m_content);
 }
 
-void VTTCue::copyWebVTTNodeToDOMTree(ContainerNode* webVTTNode, ContainerNode* parent)
+static void copyWebVTTNodeToDOMTree(ContainerNode& webVTTNode, Node& parent)
 {
-    for (RefPtr<Node> node = webVTTNode->firstChild(); node; node = node->nextSibling()) {
+    for (RefPtr<Node> node = webVTTNode.firstChild(); node; node = node->nextSibling()) {
         RefPtr<Node> clonedNode;
         if (is<WebVTTElement>(*node))
-            clonedNode = downcast<WebVTTElement>(*node).createEquivalentHTMLElement(ownerDocument());
+            clonedNode = downcast<WebVTTElement>(*node).createEquivalentHTMLElement(parent.document());
         else
             clonedNode = node->cloneNode(false);
-        parent->appendChild(*clonedNode);
+        parent.appendChild(*clonedNode);
         if (is<ContainerNode>(*node))
-            copyWebVTTNodeToDOMTree(downcast<ContainerNode>(node.get()), downcast<ContainerNode>(clonedNode.get()));
+            copyWebVTTNodeToDOMTree(downcast<ContainerNode>(*node), *clonedNode);
     }
 }
 
@@ -523,7 +522,7 @@ RefPtr<DocumentFragment> VTTCue::getCueAsHTML()
         return nullptr;
 
     auto clonedFragment = DocumentFragment::create(ownerDocument());
-    copyWebVTTNodeToDOMTree(m_webVTTNodeTree.get(), clonedFragment.ptr());
+    copyWebVTTNodeToDOMTree(*m_webVTTNodeTree, clonedFragment);
     return clonedFragment;
 }
 
@@ -921,7 +920,7 @@ void VTTCue::removeDisplayTree()
     if (m_notifyRegion && track()) {
         if (VTTRegionList* regions = track()->regions()) {
             if (RefPtr<VTTRegion> region = regions->getRegionById(m_regionId)) {
-                if (hasDisplayTree())
+                if (m_displayTree)
                     region->willRemoveTextTrackCueBox(m_displayTree.get());
             }
         }
@@ -1161,10 +1160,7 @@ void VTTCue::setCueSettings(const String& inputString)
     // If cue's line position is not auto or cue's size is not 100 or cue's
     // writing direction is not horizontal, but cue's region identifier is not
     // the empty string, let cue's region identifier be the empty string.
-    if (m_regionId.isEmpty())
-        return;
-
-    if (m_linePosition != undefinedPosition || m_cueSize != 100 || m_writingDirection != Horizontal)
+    if (!m_regionId.isEmpty() && (m_linePosition != undefinedPosition || m_cueSize != 100 || m_writingDirection != Horizontal))
         m_regionId = emptyString();
 }
 
@@ -1196,44 +1192,18 @@ std::pair<double, double> VTTCue::getCSSPosition() const
     return m_displayPosition;
 }
 
-bool VTTCue::cueContentsMatch(const TextTrackCue& cue) const
+bool VTTCue::cueContentsMatch(const TextTrackCue& otherTextTrackCue) const
 {
-    RefPtr<const VTTCue> vttCue = toVTTCue(&cue);
-    if (text() != vttCue->text())
-        return false;
-    if (cueSettings() != vttCue->cueSettings())
-        return false;
-    if (position() != vttCue->position())
-        return false;
-    if (line() != vttCue->line())
-        return false;
-    if (size() != vttCue->size())
-        return false;
-    if (align() != vttCue->align())
-        return false;
-    
-    return true;
+    auto& other = downcast<VTTCue>(otherTextTrackCue);
+    return TextTrackCue::cueContentsMatch(other)
+        && text() == other.text()
+        && cueSettings() == other.cueSettings()
+        && position() == other.position()
+        && line() == other.line()
+        && size() == other.size()
+        && align() == other.align();
 }
 
-bool VTTCue::isEqual(const TextTrackCue& cue, TextTrackCue::CueMatchRules match) const
-{
-    if (!TextTrackCue::isEqual(cue, match))
-        return false;
-
-    if (cue.cueType() != WebVTT)
-        return false;
-
-    return cueContentsMatch(cue);
-}
-
-bool VTTCue::doesExtendCue(const TextTrackCue& cue) const
-{
-    if (!cueContentsMatch(cue))
-        return false;
-    
-    return TextTrackCue::doesExtendCue(cue);
-}
-    
 void VTTCue::setFontSize(int fontSize, const IntSize&, bool important)
 {
     if (fontSize == m_fontSize && important == m_fontSizeIsImportant)
@@ -1244,37 +1214,20 @@ void VTTCue::setFontSize(int fontSize, const IntSize&, bool important)
     m_fontSize = fontSize;
 }
 
-VTTCue* toVTTCue(TextTrackCue* cue)
-{
-    return const_cast<VTTCue*>(toVTTCue(const_cast<const TextTrackCue*>(cue)));
-}
-
-const VTTCue* toVTTCue(const TextTrackCue* cue)
-{
-    RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(is<VTTCue>(cue) || is<TextTrackCueGeneric>(cue));
-    return static_cast<const VTTCue*>(cue);
-}
-
-String VTTCue::toJSONString() const
-{
-    auto object = JSON::Object::create();
-    toJSON(object.get());
-
-    return object->toJSONString();
-}
-
 void VTTCue::toJSON(JSON::Object& object) const
 {
     TextTrackCue::toJSON(object);
 
+    // FIXME: Seems dangerous to include this based on LOG_DISABLED. Can we just include it unconditionally?
 #if !LOG_DISABLED
     object.setString("text"_s, text());
 #endif
+
     object.setString("vertical"_s, vertical());
     object.setBoolean("snapToLines"_s, snapToLines());
     object.setDouble("line"_s, m_linePosition);
     if (textPositionIsAuto())
-        object.setString("position"_s, "auto");
+        object.setString("position"_s, "auto"_s);
     else
         object.setDouble("position"_s, m_textPosition);
     object.setInteger("size"_s, m_cueSize);
index e3ce992..aeac8df 100644 (file)
@@ -78,24 +78,13 @@ private:
 class VTTCue : public TextTrackCue {
     WTF_MAKE_ISO_ALLOCATED(VTTCue);
 public:
-    static Ref<VTTCue> create(ScriptExecutionContext& context, double start, double end, const String& content)
-    {
-        return create(context, MediaTime::createWithDouble(start), MediaTime::createWithDouble(end), content);
-    }
-
-    static Ref<VTTCue> create(ScriptExecutionContext& context, const MediaTime& start, const MediaTime& end, const String& content)
-    {
-        return adoptRef(*new VTTCue(context, start, end, content));
-    }
-
+    static Ref<VTTCue> create(ScriptExecutionContext&, double start, double end, const String& content);
+    static Ref<VTTCue> create(ScriptExecutionContext&, const MediaTime& start, const MediaTime& end, const String& content);
     static Ref<VTTCue> create(ScriptExecutionContext&, const WebVTTCueData&);
 
     virtual ~VTTCue();
 
-    enum AutoKeyword {
-        Auto
-    };
-    
+    enum AutoKeyword { Auto };
     using LineAndPositionSetting = Variant<double, AutoKeyword>;
 
     const String& vertical() const;
@@ -132,7 +121,7 @@ public:
     void setIsActive(bool) override;
 
     bool hasDisplayTree() const { return m_displayTree; }
-    RefPtr<TextTrackCueBox> getDisplayTree(const IntSize&, int) final;
+    RefPtr<TextTrackCueBox> getDisplayTree(const IntSize& videoSize, int fontSize) final;
     HTMLSpanElement& element() const { return *m_cueHighlightBox; }
 
     void updateDisplayTree(const MediaTime&) final;
@@ -150,7 +139,7 @@ public:
     CSSValueID getCSSWritingMode() const;
 
     enum WritingDirection {
-        Horizontal = 0,
+        Horizontal,
         VerticalGrowingLeft,
         VerticalGrowingRight,
         NumberOfWritingDirections
@@ -158,7 +147,7 @@ public:
     WritingDirection getWritingDirection() const { return m_writingDirection; }
 
     enum CueAlignment {
-        Start = 0,
+        Start,
         Center,
         End,
         Left,
@@ -170,32 +159,28 @@ public:
     void recalculateStyles() final { m_displayTreeShouldChange = true; }
     void setFontSize(int, const IntSize&, bool important) override;
 
-    bool isEqual(const TextTrackCue&, CueMatchRules) const override;
-    bool cueContentsMatch(const TextTrackCue&) const override;
-    bool doesExtendCue(const TextTrackCue&) const override;
-
     CueType cueType() const override { return WebVTT; }
     bool isRenderable() const final { return !m_content.isEmpty(); }
 
-    void didChange() override;
-
-    String toJSONString() const;
+    void didChange() final;
 
     double calculateComputedTextPosition() const;
 
 protected:
-    VTTCue(ScriptExecutionContext&, const MediaTime& start, const MediaTime& end, const String& content);
-    VTTCue(ScriptExecutionContext&, const WebVTTCueData&);
+    VTTCue(Document&, const MediaTime& start, const MediaTime& end, const String& content);
+
+    bool cueContentsMatch(const TextTrackCue&) const override;
 
     virtual Ref<VTTCueBox> createDisplayTree();
     VTTCueBox& displayTreeInternal();
 
-    void toJSON(JSON::Object&) const final;
+    void toJSON(JSON::Object&) const override;
 
 private:
-    void initialize(ScriptExecutionContext&);
+    VTTCue(Document&, const WebVTTCueData&);
+
+    void initialize();
     void createWebVTTNodeTree();
-    void copyWebVTTNodeToDOMTree(ContainerNode* WebVTTNode, ContainerNode* root);
 
     void parseSettings(const String&);
 
@@ -215,15 +200,17 @@ private:
     };
     CueSetting settingName(VTTScanner&);
 
+    static constexpr double undefinedPosition = -1;
+
     String m_content;
     String m_settings;
-    double m_linePosition;
-    double m_computedLinePosition;
-    double m_textPosition;
-    int m_cueSize;
+    double m_linePosition { undefinedPosition };
+    double m_computedLinePosition { undefinedPosition };
+    double m_textPosition { std::numeric_limits<double>::quiet_NaN() };
+    int m_cueSize { 100 };
 
-    WritingDirection m_writingDirection;
-    CueAlignment m_cueAlignment;
+    WritingDirection m_writingDirection { Horizontal };
+    CueAlignment m_cueAlignment { Center };
     String m_regionId;
 
     RefPtr<DocumentFragment> m_webVTTNodeTree;
@@ -231,8 +218,8 @@ private:
     RefPtr<HTMLDivElement> m_cueBackdropBox;
     RefPtr<VTTCueBox> m_displayTree;
 
-    CSSValueID m_displayDirection;
-    int m_displaySize;
+    CSSValueID m_displayDirection { CSSValueLtr };
+    int m_displaySize { 0 };
     std::pair<float, float> m_displayPosition;
 
     MediaTime m_originalStartTime;
@@ -245,27 +232,16 @@ private:
     bool m_notifyRegion : 1;
 };
 
-VTTCue* toVTTCue(TextTrackCue*);
-const VTTCue* toVTTCue(const TextTrackCue*);
-
 } // namespace WebCore
 
 namespace WTF {
 
-template<typename> struct LogArgument;
-
-template<> struct LogArgument<WebCore::VTTCue> {
-    static String toString(const WebCore::VTTCue& cue) { return cue.toJSONString(); }
-};
-
-} // namespace WTF
+template<> struct LogArgument<WebCore::VTTCue> : LogArgument<WebCore::TextTrackCue> { };
 
-// FIXME: The following isType function is incorrect, since it returns true for TextTrackCueGeneric.
-// Should fix this so that is<VTTCue> and downcast<VTTCue> will work correctly and eliminate toVTTCue
-// since it's just another name for downcast<VTTCue>.
+}
 
 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::VTTCue)
-static bool isType(const WebCore::TextTrackCue& cue) { return cue.cueType() == WebCore::TextTrackCue::WebVTT; }
+static bool isType(const WebCore::TextTrackCue& cue) { return cue.cueType() == WebCore::TextTrackCue::WebVTT || cue.cueType() == WebCore::TextTrackCue::ConvertedToWebVTT; }
 SPECIALIZE_TYPE_TRAITS_END()
 
 #endif
index ecd264e..874f9e5 100644 (file)
@@ -199,16 +199,20 @@ void TextTrackLoader::fileFailedToParse()
     cancelLoad();
 }
 
-void TextTrackLoader::getNewCues(Vector<RefPtr<TextTrackCue>>& outputCues)
+Vector<Ref<VTTCue>> TextTrackLoader::getNewCues()
 {
     ASSERT(m_cueParser);
-    if (m_cueParser) {
-        Vector<RefPtr<WebVTTCueData>> newCues;
-        m_cueParser->getNewCues(newCues);
+    if (!m_cueParser)
+        return { };
 
-        for (auto& cueData : newCues)
-            outputCues.append(VTTCue::create(*m_scriptExecutionContext, *cueData));
-    }
+    Vector<RefPtr<WebVTTCueData>> newCues;
+    m_cueParser->getNewCues(newCues);
+
+    Vector<Ref<VTTCue>> result;
+    result.reserveInitialCapacity(newCues.size());
+    for (auto& cueData : newCues)
+        result.uncheckedAppend(VTTCue::create(*m_scriptExecutionContext, *cueData));
+    return result;
 }
 
 void TextTrackLoader::getNewRegions(Vector<RefPtr<VTTRegion>>& outputRegions)
index c7a4ba3..c0e7829 100644 (file)
@@ -40,6 +40,7 @@ class Document;
 class HTMLTrackElement;
 class TextTrackLoader;
 class ScriptExecutionContext;
+class VTTCue;
 
 class TextTrackLoaderClient {
 public:
@@ -60,9 +61,11 @@ public:
 
     bool load(const URL&, HTMLTrackElement&);
     void cancelLoad();
-    void getNewCues(Vector<RefPtr<TextTrackCue>>& outputCues);
+
+    Vector<Ref<VTTCue>> getNewCues();
     void getNewRegions(Vector<RefPtr<VTTRegion>>& outputRegions);
     Vector<String> getNewStyleSheets();
+
 private:
 
     // CachedResourceClient
index e060e9d..a383a89 100644 (file)
@@ -39,7 +39,6 @@
 #include "MediaControlElements.h"
 #include "TextTrackList.h"
 #include "UserStyleSheetTypes.h"
-#include "VTTCue.h"
 #include <algorithm>
 #include <wtf/Language.h>
 #include <wtf/NeverDestroyed.h>
index 39da558..1a20c05 100644 (file)
@@ -23,8 +23,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef MediaPlayerPrivateAVFoundation_h
-#define MediaPlayerPrivateAVFoundation_h
+#pragma once
 
 #if ENABLE(VIDEO) && USE(AVFOUNDATION)
 
 #include "Timer.h"
 #include <wtf/Deque.h>
 #include <wtf/Function.h>
-#include <wtf/HashSet.h>
 #include <wtf/Lock.h>
 #include <wtf/LoggerHelper.h>
-#include <wtf/RetainPtr.h>
 #include <wtf/WeakPtr.h>
 
 namespace WebCore {
 
 class InbandMetadataTextTrackPrivateAVF;
 class InbandTextTrackPrivateAVF;
-class GenericCueData;
 
 // Use eager initialization for the WeakPtrFactory since we call makeWeakPtr() from another thread.
 class MediaPlayerPrivateAVFoundation : public CanMakeWeakPtr<MediaPlayerPrivateAVFoundation, WeakPtrFactoryInitialization::Eager>, public MediaPlayerPrivateInterface, public AVFInbandTrackParent
@@ -376,5 +372,3 @@ private:
 } // namespace WebCore
 
 #endif // ENABLE(VIDEO) && USE(AVFOUNDATION)
-
-#endif // MediaPlayerPrivateAVFoundation_h
index 4cf8fa3..d1262c0 100644 (file)
@@ -43,10 +43,9 @@ WTF_MAKE_ISO_ALLOCATED_IMPL(RenderVTTCue);
 
 RenderVTTCue::RenderVTTCue(VTTCueBox& element, RenderStyle&& style)
     : RenderBlockFlow(element, WTFMove(style))
-    , m_cue(toVTTCue(element.getCue()))
+    , m_cue(downcast<VTTCue>(element.getCue()))
 {
     ASSERT(m_cue);
-    ASSERT(is<VTTCue>(m_cue));
 }
 
 void RenderVTTCue::layout()
@@ -62,9 +61,9 @@ void RenderVTTCue::layout()
         return;
 
     LayoutStateMaintainer statePusher(*this, locationOffset(), hasTransform() || hasReflection() || style().isFlippedBlocksWritingMode());
-    
+
     if (m_cue->cueType()== TextTrackCue::WebVTT) {
-        if (toVTTCue(m_cue)->snapToLines())
+        if (m_cue->snapToLines())
             repositionCueSnapToLinesSet();
         else
             repositionCueSnapToLinesNotSet();
@@ -352,7 +351,7 @@ void RenderVTTCue::repositionGenericCue()
     RenderElement& backdropElement = downcast<RenderElement>(firstChild);
     
     InlineFlowBox* firstLineBox = downcast<RenderInline>(*backdropElement.firstChild()).firstLineBox();
-    if (static_cast<TextTrackCueGeneric*>(m_cue)->useDefaultPosition() && firstLineBox) {
+    if (downcast<TextTrackCueGeneric>(*m_cue).useDefaultPosition() && firstLineBox) {
         LayoutUnit parentWidth = containingBlock()->logicalWidth();
         LayoutUnit width { firstLineBox->width() };
         LayoutUnit right = (parentWidth / 2) - (width / 2);
index e27e53f..abb3346 100644 (file)
 #include "StyleRuleImport.h"
 #include "StyleSheetContents.h"
 
-#if ENABLE(VIDEO_TRACK)
-#include "TextTrackCue.h"
-#endif
-
 namespace WebCore {
 namespace Style {