Changeset 126233 in webkit


Ignore:
Timestamp:
Aug 21, 2012 5:19:48 PM (12 years ago)
Author:
victor@rosedu.org
Message:

Display a TextTrackCue when snap-to-lines flag is set
​https://bugs.webkit.org/show_bug.cgi?id=79751

Reviewed by Tony Chang.

Source/WebCore:

This patch implements rendering functionality for a given text track,
following closer the exact WebVTT specification. There are two new classes
which have been added in order to succesfully cover rendering when of a text
track cue.

RenderTextTrackCue handles the specific rendering algorithm required,
by checking for overlaps with other boxes that are in the same
container (these can be any other boxes, not necessarily other cues,
the video controls, for example).

TextTrackCueBox extends HTMLDivElement and is an intermediate layer
between the renderer class and the actual cue object. Its purpose is
to instantiate the particular renderer and cover all the default CSS
styling that needs to be applied to the cue.

The layout is done in two steps:

  • Step 1: Layout the TextTrackCue with default CSS properties set (this is

the TextTrackCueBox decorated with the respective CSS elements)

  • Step 2: RenderTextTrackCue adjusts the box position depending on the

parameters of the TextTrackCue object and the overlaps that may occur with
previously positioned cues.

Tests: media/track/track-cue-rendering-horizontal.html

media/track/track-cue-rendering-vertical.html

  • CMakeLists.txt: Updated to include RenderTextTrackCue.
  • GNUmakefile.list.am: Updated to include RenderTextTrackCue.
  • Target.pri: Updated to include RenderTextTrackCue.
  • WebCore.gypi: Updated to include RenderTextTrackCue.
  • WebCore.vcproj/WebCore.vcproj: Updated to include RenderTextTrackCue.
  • WebCore.xcodeproj/project.pbxproj: Updated to include RenderTextTrackCue.
  • css/mediaControls.css: Removed unreliable CSS.

(video::-webkit-media-text-track-display): Removed properties.

  • html/shadow/MediaControlElements.cpp: Updated to not use the new class.

(RenderTextTrackContainerElement):
(WebCore::MediaControlTextTrackContainerElement::updateDisplay): Simplified
the function by moving the check if track is rendered in TextTrack and used
the TextTrackCueBox for cues.

  • html/track/TextTrack.cpp: Added a new method.

(WebCore::TextTrack::isRendered): Method that returns whether the track should
be rendered or not.
(WebCore):

  • html/track/TextTrack.h: Added the isRendered method.

(TextTrack):

  • html/track/TextTrackCue.cpp: Added several helper methods and

the TextTrackCueBox.
(WebCore):
(WebCore::TextTrackCueBox::TextTrackCueBox): The TextTrackCueBox extends
the HTMLDivElement and represents a bridge class between RenderTextTrackCue
and TextTrackCue. This is required as the layout is done in two steps, as
explained on top of the ChangeLog entry.
(WebCore::TextTrackCueBox::getCue): Returns the associated TextTrackCue object.
(WebCore::TextTrackCueBox::applyCSSProperties): Applies a part of the default CSS
properties, as defined by section 3.5.1 of the WebVTT specification.
(WebCore::TextTrackCueBox::shadowPseudoId): Moved the shadow pseudo id.
(WebCore::TextTrackCueBox::createRenderer): Creates the particular renderer.
(WebCore::TextTrackCue::TextTrackCue): Corrected the internal writing mode map.
(WebCore::TextTrackCue::calculateComputedLinePosition): Updated the compute line
position algorithm. This requires, however, a method to consider only rendered
tracks (and therefore will be addressed completely in subsequent changeset).
(WebCore::TextTrackCue::calculateDisplayParameters): Updated and corrected the
computed display parameters to match the current specification.
(WebCore::TextTrackCue::getDisplayTree): Update to use the TextTrackCueBox class
and moved CSS application to the respective class.
(WebCore::TextTrackCue::getPositionCoordinates): Added comment to specify in which
situation this method is used and change visibility to private.
(WebCore::TextTrackCue::getCSSWritingMode): Returns the CSS writing mode corresponding
to the cue writing mode.
(WebCore::TextTrackCue::getCSSSize): Returns the cue width / height (depending on the
writing direction.
(WebCore::TextTrackCue::getCSSPosition): Returns the default display position, that is
used in the first layout step.

  • html/track/TextTrackCue.h:

(WebCore):
(TextTrackCueBox):
(WebCore::TextTrackCueBox::create): Initialization method.
(TextTrackCue):
(WebCore::TextTrackCue::getWritingDirection): Helper method to return the internal
values used to represent the writing direction.

  • rendering/RenderTextTrackCue.cpp: Added.

(WebCore):
(WebCore::RenderTextTrackCue::RenderTextTrackCue):
(WebCore::RenderTextTrackCue::layout): The rendering steps, as mentioned in
the WebVTT rendering rules. Currently, this treats only the snap-to-lines set
case. It is implemented following closely the spec, and might be subject to
change as discussions on various bugs evolve.
(WebCore::RenderTextTrackCue::initializeLayoutParameters): Steps 1 - 7.
(WebCore::RenderTextTrackCue::placeBoxInDefaultPosition): Steps 8 - 10.
(WebCore::RenderTextTrackCue::isOutside): Inline method to check if the cue is outside.
(WebCore::RenderTextTrackCue::isOverlapping): Inline method to check if the cue overlaps other boxes.
(WebCore::RenderTextTrackCue::shouldSwitchDirection): Step 12.
(WebCore::RenderTextTrackCue::moveBoxesByStep): Step 13.
(WebCore::RenderTextTrackCue::switchDirection): Steps 15 - 18.
(WebCore::RenderTextTrackCue::repositionCueSnapToLinesSet): Cue repositioning
for text track cue when the snap to lines flag is set.
(WebCore::RenderTextTrackCue::repositionCueSnapToLinesNotSet): Cue repositioning
for text track cue when the snap to lines flag is not set. Not implemented yet.

  • rendering/RenderTextTrackCue.h: Added.

(WebCore):
(RenderTextTrackCue): Rendering class, handling the display of cues.

LayoutTests:

Test cases covering snap-to-lines horizontal and vertical positioning of cues.

  • media/track/captions-webvtt/captions-snap-to-lines-set.vtt: Added.
  • media/track/track-cue-rendering-horizontal.html: Added.
  • media/track/track-cue-rendering-snap-to-lines-not-set-expected.txt: Updated.
  • media/track/track-cue-rendering-vertical.html: Added.
  • media/video-test.js: Updated to support pixel test dumps.
  • platform/chromium-linux/media/track/track-cue-rendering-horizontal-expected.png: Added.
  • platform/chromium-linux/media/track/track-cue-rendering-horizontal-expected.txt: Added.
  • platform/chromium-linux/media/track/track-cue-rendering-vertical-expected.png: Added.
  • platform/chromium-linux/media/track/track-cue-rendering-vertical-expected.txt: Added.
  • platform/chromium/TestExpectations: Marking these temporarily as IMAGE fail, as they will

anyway require new baselines.

  • platform/mac/media/track/track-cue-rendering-horizontal-expected.png: Added.
  • platform/mac/media/track/track-cue-rendering-horizontal-expected.txt: Added.
  • platform/mac/media/track/track-cue-rendering-vertical-expected.png: Added.
  • platform/mac/media/track/track-cue-rendering-vertical-expected.txt: Added.
Location:
trunk
Files:
15 added
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r126229 r126233  
     12012-08-21  Victor Carbune  <victor@rosedu.org>
     2
     3        Display a TextTrackCue when snap-to-lines flag is set
     4        https://bugs.webkit.org/show_bug.cgi?id=79751
     5
     6        Reviewed by Tony Chang.
     7
     8        Test cases covering snap-to-lines horizontal and vertical positioning of cues.
     9
     10        * media/track/captions-webvtt/captions-snap-to-lines-set.vtt: Added.
     11        * media/track/track-cue-rendering-horizontal.html: Added.
     12        * media/track/track-cue-rendering-snap-to-lines-not-set-expected.txt: Updated.
     13        * media/track/track-cue-rendering-vertical.html: Added.
     14        * media/video-test.js: Updated to support pixel test dumps.
     15        * platform/chromium-linux/media/track/track-cue-rendering-horizontal-expected.png: Added.
     16        * platform/chromium-linux/media/track/track-cue-rendering-horizontal-expected.txt: Added.
     17        * platform/chromium-linux/media/track/track-cue-rendering-vertical-expected.png: Added.
     18        * platform/chromium-linux/media/track/track-cue-rendering-vertical-expected.txt: Added.
     19        * platform/chromium/TestExpectations: Marking these temporarily as IMAGE fail, as they will
     20        anyway require new baselines.
     21        * platform/mac/media/track/track-cue-rendering-horizontal-expected.png: Added.
     22        * platform/mac/media/track/track-cue-rendering-horizontal-expected.txt: Added.
     23        * platform/mac/media/track/track-cue-rendering-vertical-expected.png: Added.
     24        * platform/mac/media/track/track-cue-rendering-vertical-expected.txt: Added.
     25
    1262012-08-21  Zan Dobersek  <zandobersek@gmail.com>
    227

  • trunk/LayoutTests/media/track/track-cue-rendering-snap-to-lines-not-set-expected.txt

    r114640 r126233  
    1313EXPECTED (cueDisplayElement.innerText == 'This is a demo track to illustrate positioning features of cues.') OK
    1414Cue left position (percentage): 0
    15 Cue top position (percentage): 100
     15Cue top position (percentage): 81
    1616
    1717** Center **

  • trunk/LayoutTests/media/video-test.js

    r120416 r126233  
    1515
    1616if (window.testRunner) {
    17     testRunner.dumpAsText();
     17    // Some track element rendering tests require text pixel dump.
     18    if (typeof requirePixelDump == "undefined")
     19        testRunner.dumpAsText();
     20
    1821    testRunner.waitUntilDone();
    1922}

  • trunk/LayoutTests/platform/chromium/TestExpectations

    r126192 r126233  
    34533453BUGWK93488 SKIP : fast/notifications/notifications-permission.html = TEXT
    34543454
     3455BUGWK79751 : media/track/track-cue-rendering-horizontal.html = IMAGE
     3456BUGWK79751 : media/track/track-cue-rendering-vertical.html = IMAGE
     3457
    34553458// Flaky
    34563459BUGWK93799 MAC : fast/dom/HTMLMeterElement/meter-element-repaint-on-update-value.html = PASS IMAGE

  • trunk/Source/WebCore/CMakeLists.txt

    r125866 r126233  
    20832083    rendering/RenderTextControlSingleLine.cpp
    20842084    rendering/RenderTextFragment.cpp
     2085    rendering/RenderTextTrackCue.cpp
    20852086    rendering/RenderTheme.cpp
    20862087    rendering/RenderTreeAsText.cpp

  • trunk/Source/WebCore/ChangeLog

    r126230 r126233  
     12012-08-21  Victor Carbune  <victor@rosedu.org>
     2
     3        Display a TextTrackCue when snap-to-lines flag is set
     4        https://bugs.webkit.org/show_bug.cgi?id=79751
     5
     6        Reviewed by Tony Chang.
     7
     8        This patch implements rendering functionality for a given text track,
     9        following closer the exact WebVTT specification. There are two new classes
     10        which have been added in order to succesfully cover rendering when of a text
     11        track cue.
     12
     13        RenderTextTrackCue handles the specific rendering algorithm required,
     14        by checking for overlaps with other boxes that are in the same
     15        container (these can be any other boxes, not necessarily other cues,
     16        the video controls, for example).
     17
     18        TextTrackCueBox extends HTMLDivElement and is an intermediate layer
     19        between the renderer class and the actual cue object. Its purpose is
     20        to instantiate the particular renderer and cover all the default CSS
     21        styling that needs to be applied to the cue.
     22
     23        The layout is done in two steps:
     24          - Step 1: Layout the TextTrackCue with default CSS properties set (this is
     25        the TextTrackCueBox decorated with the respective CSS elements)
     26          - Step 2: RenderTextTrackCue adjusts the box position depending on the
     27        parameters of the TextTrackCue object and the overlaps that may occur with
     28        previously positioned cues.
     29
     30        Tests: media/track/track-cue-rendering-horizontal.html
     31               media/track/track-cue-rendering-vertical.html
     32
     33        * CMakeLists.txt: Updated to include RenderTextTrackCue.
     34        * GNUmakefile.list.am: Updated to include RenderTextTrackCue.
     35        * Target.pri: Updated to include RenderTextTrackCue.
     36        * WebCore.gypi: Updated to include RenderTextTrackCue.
     37        * WebCore.vcproj/WebCore.vcproj: Updated to include RenderTextTrackCue.
     38        * WebCore.xcodeproj/project.pbxproj: Updated to include RenderTextTrackCue.
     39        * css/mediaControls.css: Removed unreliable CSS.
     40        (video::-webkit-media-text-track-display): Removed properties.
     41        * html/shadow/MediaControlElements.cpp: Updated to not use the new class.
     42        (RenderTextTrackContainerElement):
     43        (WebCore::MediaControlTextTrackContainerElement::updateDisplay): Simplified
     44        the function by moving the check if track is rendered in TextTrack and used
     45        the TextTrackCueBox for cues.
     46        * html/track/TextTrack.cpp: Added a new method.
     47        (WebCore::TextTrack::isRendered): Method that returns whether the track should
     48        be rendered or not.
     49        (WebCore):
     50        * html/track/TextTrack.h: Added the isRendered method.
     51        (TextTrack):
     52        * html/track/TextTrackCue.cpp: Added several helper methods and
     53        the TextTrackCueBox.
     54        (WebCore):
     55        (WebCore::TextTrackCueBox::TextTrackCueBox): The TextTrackCueBox extends
     56        the HTMLDivElement and represents a bridge class between RenderTextTrackCue
     57        and TextTrackCue. This is required as the layout is done in two steps, as
     58        explained on top of the ChangeLog entry.
     59        (WebCore::TextTrackCueBox::getCue): Returns the associated TextTrackCue object.
     60        (WebCore::TextTrackCueBox::applyCSSProperties): Applies a part of the default CSS
     61        properties, as defined by section 3.5.1 of the WebVTT specification.
     62        (WebCore::TextTrackCueBox::shadowPseudoId): Moved the shadow pseudo id.
     63        (WebCore::TextTrackCueBox::createRenderer): Creates the particular renderer.
     64        (WebCore::TextTrackCue::TextTrackCue): Corrected the internal writing mode map.
     65        (WebCore::TextTrackCue::calculateComputedLinePosition): Updated the compute line
     66        position algorithm. This requires, however, a method to consider only rendered
     67        tracks (and therefore will be addressed completely in subsequent changeset).
     68        (WebCore::TextTrackCue::calculateDisplayParameters): Updated and corrected the
     69        computed display parameters to match the current specification.
     70        (WebCore::TextTrackCue::getDisplayTree): Update to use the TextTrackCueBox class
     71        and moved CSS application to the respective class.
     72        (WebCore::TextTrackCue::getPositionCoordinates): Added comment to specify in which
     73        situation this method is used and change visibility to private.
     74        (WebCore::TextTrackCue::getCSSWritingMode): Returns the CSS writing mode corresponding
     75        to the cue writing mode.
     76        (WebCore::TextTrackCue::getCSSSize): Returns the cue width / height (depending on the
     77        writing direction.
     78        (WebCore::TextTrackCue::getCSSPosition): Returns the default display position, that is
     79        used in the first layout step.
     80        * html/track/TextTrackCue.h:
     81        (WebCore):
     82        (TextTrackCueBox):
     83        (WebCore::TextTrackCueBox::create): Initialization method.
     84        (TextTrackCue):
     85        (WebCore::TextTrackCue::getWritingDirection): Helper method to return the internal
     86        values used to represent the writing direction.
     87        * rendering/RenderTextTrackCue.cpp: Added.
     88        (WebCore):
     89        (WebCore::RenderTextTrackCue::RenderTextTrackCue):
     90        (WebCore::RenderTextTrackCue::layout): The rendering steps, as mentioned in
     91        the WebVTT rendering rules. Currently, this treats only the snap-to-lines set
     92        case. It is implemented following closely the spec, and might be subject to
     93        change as discussions on various bugs evolve.
     94        (WebCore::RenderTextTrackCue::initializeLayoutParameters): Steps 1 - 7.
     95        (WebCore::RenderTextTrackCue::placeBoxInDefaultPosition): Steps 8 - 10.
     96        (WebCore::RenderTextTrackCue::isOutside): Inline method to check if the cue is outside.
     97        (WebCore::RenderTextTrackCue::isOverlapping): Inline method to check if the cue overlaps other boxes.
     98        (WebCore::RenderTextTrackCue::shouldSwitchDirection): Step 12.
     99        (WebCore::RenderTextTrackCue::moveBoxesByStep): Step 13.
     100        (WebCore::RenderTextTrackCue::switchDirection): Steps 15 - 18.
     101        (WebCore::RenderTextTrackCue::repositionCueSnapToLinesSet): Cue repositioning
     102        for text track cue when the snap to lines flag is set.
     103        (WebCore::RenderTextTrackCue::repositionCueSnapToLinesNotSet): Cue repositioning
     104        for text track cue when the snap to lines flag is not set. Not implemented yet.
     105        * rendering/RenderTextTrackCue.h: Added.
     106        (WebCore):
     107        (RenderTextTrackCue): Rendering class, handling the display of cues.
     108
    11092012-08-21  Lianghui Chen  <liachen@rim.com>
    2110

  • trunk/Source/WebCore/GNUmakefile.list.am

    r126182 r126233  
    49824982        Source/WebCore/rendering/RenderTextControlSingleLine.h \
    49834983        Source/WebCore/rendering/RenderText.cpp \
     4984        Source/WebCore/rendering/RenderTextTrackCue.cpp \
     4985        Source/WebCore/rendering/RenderTextTrackCue.h \
    49844986        Source/WebCore/rendering/RenderTextFragment.cpp \
    49854987        Source/WebCore/rendering/RenderTextFragment.h \

  • trunk/Source/WebCore/Target.pri

    r125894 r126233  
    11741174    rendering/RenderTextControlSingleLine.cpp \
    11751175    rendering/RenderTextFragment.cpp \
     1176    rendering/RenderTextTrackCue.cpp \
    11761177    rendering/RenderTheme.cpp \
    11771178    rendering/RenderTreeAsText.cpp \

  • trunk/Source/WebCore/WebCore.gypi

    r126222 r126233  
    48184818            'rendering/RenderTextFragment.cpp',
    48194819            'rendering/RenderTextFragment.h',
     4820            'rendering/RenderTextTrackCue.cpp',
     4821            'rendering/RenderTextTrackCue.h',
    48204822            'rendering/RenderTheme.cpp',
    48214823            'rendering/RenderTheme.h',

  • trunk/Source/WebCore/WebCore.vcproj/WebCore.vcproj

    r126193 r126233  
    4376443764                        </File>
    4376543765                        <File
     43766                                RelativePath="..\rendering\RenderTextTrackCue.cpp"
     43767                                >
     43768                                <FileConfiguration
     43769                                        Name="Debug|Win32"
     43770                                        ExcludedFromBuild="true"
     43771                                        >
     43772                                        <Tool
     43773                                                Name="VCCLCompilerTool"
     43774                                        />
     43775                                </FileConfiguration>
     43776                                <FileConfiguration
     43777                                        Name="Release|Win32"
     43778                                        ExcludedFromBuild="true"
     43779                                        >
     43780                                        <Tool
     43781                                                Name="VCCLCompilerTool"
     43782                                        />
     43783                                </FileConfiguration>
     43784                                <FileConfiguration
     43785                                        Name="Debug_Cairo_CFLite|Win32"
     43786                                        ExcludedFromBuild="true"
     43787                                        >
     43788                                        <Tool
     43789                                                Name="VCCLCompilerTool"
     43790                                        />
     43791                                </FileConfiguration>
     43792                                <FileConfiguration
     43793                                        Name="Release_Cairo_CFLite|Win32"
     43794                                        ExcludedFromBuild="true"
     43795                                        >
     43796                                        <Tool
     43797                                                Name="VCCLCompilerTool"
     43798                                        />
     43799                                </FileConfiguration>
     43800                                <FileConfiguration
     43801                                        Name="Debug_All|Win32"
     43802                                        ExcludedFromBuild="true"
     43803                                        >
     43804                                        <Tool
     43805                                                Name="VCCLCompilerTool"
     43806                                        />
     43807                                </FileConfiguration>
     43808                                <FileConfiguration
     43809                                        Name="Production|Win32"
     43810                                        ExcludedFromBuild="true"
     43811                                        >
     43812                                        <Tool
     43813                                                Name="VCCLCompilerTool"
     43814                                        />
     43815                                </FileConfiguration>
     43816                        </File>
     43817                        <File
     43818                                RelativePath="..\rendering\RenderTextTrackCue.h"
     43819                                >
     43820                        </File>
     43821                        <File
    4376643822                                RelativePath="..\rendering\RenderTheme.cpp"
    4376743823                                >

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r126012 r126233  
    29432943                86BE340415058CB200CE0FD8 /* PerformanceEntryList.h in Headers */ = {isa = PBXBuildFile; fileRef = 86BE33FE15058CB200CE0FD8 /* PerformanceEntryList.h */; };
    29442944                86D982F7125C154000AD9E3D /* DocumentTiming.h in Headers */ = {isa = PBXBuildFile; fileRef = 86D982F6125C154000AD9E3D /* DocumentTiming.h */; settings = {ATTRIBUTES = (Private, ); }; };
     2945                86FF886115DE3D0700BD6B28 /* RenderTextTrackCue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 86FF885E15DE3B8200BD6B28 /* RenderTextTrackCue.cpp */; };
     2946                86FF886215DE3D0700BD6B28 /* RenderTextTrackCue.h in Headers */ = {isa = PBXBuildFile; fileRef = 86FF885F15DE3B8200BD6B28 /* RenderTextTrackCue.h */; };
    29452947                890AE0E11256A07900F5968C /* DirectoryReaderBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 890AE0E01256A07900F5968C /* DirectoryReaderBase.h */; };
    29462948                8931DE5B14C44C44000DC9D2 /* JSBlobCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8931DE5A14C44C44000DC9D2 /* JSBlobCustom.cpp */; };
    … …  
    1007710079                86BE33FF15058CB200CE0FD8 /* PerformanceEntryList.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = PerformanceEntryList.idl; sourceTree = "<group>"; };
    1007810080                86D982F6125C154000AD9E3D /* DocumentTiming.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DocumentTiming.h; sourceTree = "<group>"; };
     10081                86FF885E15DE3B8200BD6B28 /* RenderTextTrackCue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderTextTrackCue.cpp; sourceTree = "<group>"; };
     10082                86FF885F15DE3B8200BD6B28 /* RenderTextTrackCue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderTextTrackCue.h; sourceTree = "<group>"; };
    1007910083                890AE0E01256A07900F5968C /* DirectoryReaderBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DirectoryReaderBase.h; path = Modules/filesystem/DirectoryReaderBase.h; sourceTree = "<group>"; };
    1008010084                8931DE5A14C44C44000DC9D2 /* JSBlobCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSBlobCustom.cpp; sourceTree = "<group>"; };
    … …  
    2141721421                                BCEA484E097D93020094C9E4 /* RenderTextFragment.cpp */,
    2141821422                                BCEA484F097D93020094C9E4 /* RenderTextFragment.h */,
     21423                                86FF885E15DE3B8200BD6B28 /* RenderTextTrackCue.cpp */,
     21424                                86FF885F15DE3B8200BD6B28 /* RenderTextTrackCue.h */,
    2141921425                                BCEA484A097D93020094C9E4 /* RenderTheme.cpp */,
    2142021426                                BCEA484B097D93020094C9E4 /* RenderTheme.h */,
    … …  
    2465924665                                083DAEA90F01A7FB00342754 /* RenderTextControlSingleLine.h in Headers */,
    2466024666                                BCEA488E097D93020094C9E4 /* RenderTextFragment.h in Headers */,
     24667                                86FF886215DE3D0700BD6B28 /* RenderTextTrackCue.h in Headers */,
    2466124668                                BCEA488A097D93020094C9E4 /* RenderTheme.h in Headers */,
    2466224669                                BCEA4887097D93020094C9E4 /* RenderThemeMac.h in Headers */,
    … …  
    2786127868                                083DAEA80F01A7FB00342754 /* RenderTextControlSingleLine.cpp in Sources */,
    2786227869                                BCEA488D097D93020094C9E4 /* RenderTextFragment.cpp in Sources */,
     27870                                86FF886115DE3D0700BD6B28 /* RenderTextTrackCue.cpp in Sources */,
    2786327871                                BCEA4889097D93020094C9E4 /* RenderTheme.cpp in Sources */,
    2786427872                                BCEA4888097D93020094C9E4 /* RenderThemeMac.mm in Sources */,

  • trunk/Source/WebCore/css/mediaControls.css

    r123969 r126233  
    254254    position: absolute;
    255255    color: rgba(255, 255, 255, 1);
    256 
    257     top: 100%;
    258     -webkit-transform: translate(0%, -100%);
    259 }
     256}

  • trunk/Source/WebCore/html/shadow/MediaControlElements.cpp

    r124022 r126233  
    3333#include "MediaControlElements.h"
    3434
     35#include "CSSStyleDeclaration.h"
    3536#include "CSSValueKeywords.h"
    3637#include "DOMTokenList.h"
    3738#include "EventNames.h"
    3839#include "FloatConversion.h"
     40#include "FloatPoint.h"
    3941#include "Frame.h"
     42#include "HTMLDivElement.h"
    4043#include "HTMLMediaElement.h"
    4144#include "HTMLNames.h"
    4245#include "HTMLVideoElement.h"
     46#include "LayoutRepainter.h"
    4347#include "LocalizedStrings.h"
    4448#include "MediaControls.h"
    … …  
    4650#include "Page.h"
    4751#include "RenderDeprecatedFlexibleBox.h"
     52#include "RenderInline.h"
    4853#include "RenderMedia.h"
    4954#include "RenderSlider.h"
     55#include "RenderText.h"
    5056#include "RenderTheme.h"
    5157#include "RenderVideo.h"
    … …  
    12591265public:
    12601266    RenderTextTrackContainerElement(Node*);
    1261    
     1267
    12621268private:
    12631269    virtual void layout();
    … …  
    13531359    // corresponding CSS boxes added to output, in text track cue order, run the
    13541360    // following substeps:
    1355 
    1356     // Simple renderer for now.
    13571361    for (size_t i = 0; i < activeCues.size(); ++i) {
    13581362        TextTrackCue* cue = activeCues[i].data();
    13591363
    13601364        ASSERT(cue->isActive());
    1361         if (cue->track()->kind() != TextTrack::captionsKeyword() && cue->track()->kind() != TextTrack::subtitlesKeyword())
     1365        if (!cue->track() || !cue->track()->isRendered())
    13621366            continue;
    13631367
    1364         if (!cue->track() || cue->track()->mode() != TextTrack::SHOWING)
    1365             continue;
    1366 
    1367         RefPtr<HTMLDivElement> displayTree = cue->getDisplayTree();
    1368 
    1369         // Append only new display trees.
    1370         if (displayTree->hasChildNodes() && !contains(displayTree.get()))
    1371             appendChild(displayTree, ASSERT_NO_EXCEPTION, true);
    1372 
    1373         // Note: the display tree of a cue is removed when the active flag of the cue is unset.
    1374 
    1375         // FIXME(BUG 79751): Render the TextTrackCue when snap-to-lines is set.
    1376 
    1377         // FIXME(BUG 84296): Implement overlapping detection for cue boxes when snap-to-lines is not set.
     1368        RefPtr<TextTrackCueBox> displayBox = cue->getDisplayTree();
     1369
     1370        if (displayBox->hasChildNodes() && !contains(static_cast<Node*>(displayBox.get())))
     1371            // Note: the display tree of a cue is removed when the active flag of the cue is unset.
     1372            appendChild(displayBox, ASSERT_NO_EXCEPTION, false);
    13781373    }
    13791374

  • trunk/Source/WebCore/html/track/TextTrack.cpp

    r124645 r126233  
    295295}
    296296
     297bool TextTrack::isRendered()
     298{
     299    if (m_kind != captionsKeyword() && m_kind != subtitlesKeyword())
     300        return false;
     301
     302    if (m_mode != SHOWING && !m_showingByDefault)
     303        return false;
     304
     305    return true;
     306}
     307
    297308TextTrackCueList* TextTrack::ensureTextTrackCueList()
    298309{

  • trunk/Source/WebCore/html/track/TextTrack.h

    r114171 r126233  
    111111    void invalidateTrackIndex();
    112112
     113    bool isRendered();
     114
    113115protected:
    114116    TextTrack(ScriptExecutionContext*, TextTrackClient*, const String& kind, const String& label, const String& language, TextTrackType);

  • trunk/Source/WebCore/html/track/TextTrackCue.cpp

    r124645 r126233  
    4242#include "HTMLDivElement.h"
    4343#include "HTMLMediaElement.h"
     44#include "RenderTextTrackCue.h"
    4445#include "Text.h"
    4546#include "TextTrack.h"
    … …  
    8889    return verticallr;
    8990}
     91
     92// ----------------------------
     93
     94TextTrackCueBox::TextTrackCueBox(Document* document, TextTrackCue* cue)
     95    : HTMLElement(divTag, document)
     96    , m_cue(cue)
     97{
     98}
     99
     100TextTrackCue* TextTrackCueBox::getCue() const
     101{
     102    return m_cue;
     103}
     104
     105void TextTrackCueBox::applyCSSProperties()
     106{
     107    // FIXME: Apply all the initial CSS positioning properties. http://wkb.ug/79916
     108
     109    // 3.5.1 On the (root) List of WebVTT Node Objects:
     110
     111    // the 'position' property must be set to 'absolute'
     112    setInlineStyleProperty(CSSPropertyPosition, CSSValueAbsolute);
     113
     114    //  the 'unicode-bidi' property must be set to 'plaintext'
     115    setInlineStyleProperty(CSSPropertyUnicodeBidi, CSSValueWebkitPlaintext);
     116
     117    // FIXME: Determine the text direction using the BIDI algorithm. http://wkb.ug/79749
     118    // the 'direction' property must be set to direction
     119    setInlineStyleProperty(CSSPropertyDirection, CSSValueLtr);
     120
     121    // the 'writing-mode' property must be set to writing-mode
     122    setInlineStyleProperty(CSSPropertyWebkitWritingMode, m_cue->getCSSWritingMode(), false);
     123
     124    std::pair<float, float> position = m_cue->getCSSPosition();
     125
     126    // the 'top' property must be set to top,
     127    setInlineStyleProperty(CSSPropertyTop, static_cast<double>(position.second), CSSPrimitiveValue::CSS_PERCENTAGE);
     128
     129    // the 'left' property must be set to left
     130    setInlineStyleProperty(CSSPropertyLeft, static_cast<double>(position.first), CSSPrimitiveValue::CSS_PERCENTAGE);
     131
     132    // the 'width' property must be set to width, and the 'height' property  must be set to height
     133    if (m_cue->vertical() == horizontalKeyword()) {
     134        setInlineStyleProperty(CSSPropertyWidth, static_cast<double>(m_cue->getCSSSize()), CSSPrimitiveValue::CSS_PERCENTAGE);
     135        setInlineStyleProperty(CSSPropertyHeight, CSSValueAuto);
     136    } else {
     137        setInlineStyleProperty(CSSPropertyWidth, CSSValueAuto);
     138        setInlineStyleProperty(CSSPropertyHeight, static_cast<double>(m_cue->getCSSSize()),  CSSPrimitiveValue::CSS_PERCENTAGE);
     139    }
     140
     141    // The 'text-align' property on the (root) List of WebVTT Node Objects must
     142    // be set to the value in the second cell of the row of the table below
     143    // whose first cell is the value of the corresponding cue's text track cue
     144    // alignment:
     145    if (m_cue->align() == startKeyword())
     146        setInlineStyleProperty(CSSPropertyTextAlign, CSSValueStart);
     147    else if (m_cue->align() == endKeyword())
     148        setInlineStyleProperty(CSSPropertyTextAlign, CSSValueEnd);
     149    else
     150        setInlineStyleProperty(CSSPropertyTextAlign, CSSValueCenter);
     151
     152    if (!m_cue->snapToLines()) {
     153        // 10.13.1 Set up x and y:
     154        // Note: x and y are set through the CSS left and top above.
     155
     156        // 10.13.2 Position the boxes in boxes such that the point x% along the
     157        // width of the bounding box of the boxes in boxes is x% of the way
     158        // across the width of the video's rendering area, and the point y%
     159        // along the height of the bounding box of the boxes in boxes is y%
     160        // of the way across the height of the video's rendering area, while
     161        // maintaining the relative positions of the boxes in boxes to each
     162        // other.
     163        setInlineStyleProperty(CSSPropertyWebkitTransform,
     164                String::format("translate(-%.2f%%, -%.2f%%)", position.first, position.second));
     165
     166        setInlineStyleProperty(CSSPropertyWhiteSpace, CSSValuePre);
     167    }
     168}
     169
     170const AtomicString& TextTrackCueBox::shadowPseudoId() const
     171{
     172    DEFINE_STATIC_LOCAL(const AtomicString, trackDisplayBoxShadowPseudoId, ("-webkit-media-text-track-display"));
     173    return trackDisplayBoxShadowPseudoId;
     174}
     175
     176RenderObject* TextTrackCueBox::createRenderer(RenderArena* arena, RenderStyle*)
     177{
     178    return new (arena) RenderTextTrackCue(this);
     179}
     180
     181// ----------------------------
    90182
    91183TextTrackCue::TextTrackCue(ScriptExecutionContext* context, const String& id, double start, double end, const String& content, const String& settings, bool pauseOnExit)
    … …  
    110202    , m_futureDocumentNodes(HTMLDivElement::create(static_cast<Document*>(context)))
    111203    , m_displayTreeShouldChange(true)
    112     , m_displayTree(HTMLDivElement::create(static_cast<Document*>(context)))
    113     , m_displayXPosition(undefinedPosition)
    114     , m_displayYPosition(undefinedPosition)
     204    , m_displayTree(TextTrackCueBox::create(static_cast<Document*>(m_scriptExecutionContext), this))
    115205{
    116206    ASSERT(m_scriptExecutionContext->isDocument());
    117207
    118     // The text track cue writing directions are directly relatd to the
    119     // block-flow element, which can be set through the CSS writing modes.
     208    // 4. If the text track cue writing direction is horizontal, then let
     209    // writing-mode be 'horizontal-tb'. Otherwise, if the text track cue writing
     210    // direction is vertical growing left, then let writing-mode be
     211    // 'vertical-rl'. Otherwise, the text track cue writing direction is
     212    // vertical growing right; let writing-mode be 'vertical-lr'.
    120213    m_displayWritingModeMap[Horizontal] = CSSValueHorizontalTb;
    121     m_displayWritingModeMap[VerticalGrowingLeft] = CSSValueVerticalLr;
    122     m_displayWritingModeMap[VerticalGrowingRight] = CSSValueVerticalRl;
     214    m_displayWritingModeMap[VerticalGrowingLeft] = CSSValueVerticalRl;
     215    m_displayWritingModeMap[VerticalGrowingRight] = CSSValueVerticalLr;
    123216
    124217    parseSettings(settings);
    … …  
    444537    // Otherwise, it is the value returned by the following algorithm:
    445538
    446     // FIXME(BUG 79751): Complete determination algorithm when it is actually
    447     // used - when displaying a TextTrackCue having snap-to-lines flag set.
    448 
    449     return 100;
     539    // If cue is not associated with a text track, return -1 and abort these
     540    // steps.
     541    if (!track())
     542        return -1;
     543
     544    // Let n be the number of text tracks whose text track mode is showing or
     545    // showing by default and that are in the media element's list of text
     546    // tracks before track.
     547
     548    // FIXME: Add a method to cache the track index considering only
     549    // rendered tracks (that have showing or showing by default mode set).
     550    // http://wkb.ug/93779
     551    int n = track()->trackIndex();
     552
     553    // Increment n by one.
     554    n++;
     555
     556    // Negate n.
     557    n = -n;
     558
     559    return n;
    450560}
    451561
    … …  
    461571    // track cue writing direction is vertical growing right; let block-flow be
    462572    // 'rl'.
    463 
    464573    m_displayWritingMode = m_displayWritingModeMap[m_writingDirection];
    465574
    … …  
    470579            || (m_writingDirection == Horizontal && m_cueAlignment == End && m_displayDirection == CSSValueRtl)
    471580            || (m_writingDirection == VerticalGrowingLeft && m_cueAlignment == Start)
    472             || (m_writingDirection == VerticalGrowingRight && m_cueAlignment == End)) {
     581            || (m_writingDirection == VerticalGrowingRight && m_cueAlignment == Start)) {
    473582        maximumSize = 100 - m_textPosition;
    474583    } else if ((m_writingDirection == Horizontal && m_cueAlignment == End && m_displayDirection == CSSValueLtr)
    … …  
    486595    m_displaySize = std::min(m_cueSize, maximumSize);
    487596
    488     // 10.7 If the text track cue writing direction is horizontal, then let
    489     // width be 'size vw' and height be 'auto'. Otherwise, let width be 'auto'
    490     // and height be 'size vh'. (These are CSS values used by the next section
    491     // to set CSS properties for the rendering; 'vw' and 'vh' are CSS units.)
    492     m_displayWidth = m_writingDirection == Horizontal ? m_displaySize : autoSize;
    493     m_displayHeight = m_writingDirection == Horizontal ? autoSize : m_displaySize;
    494 
    495597    // 10.8 Determine the value of x-position or y-position for cue as per the
    496598    // appropriate rules from the following list:
    497     if ((m_writingDirection == Horizontal && m_cueAlignment == Start && m_displayDirection == CSSValueLtr)
    498             || (m_writingDirection == Horizontal && m_cueAlignment == End && m_displayDirection == CSSValueRtl)) {
    499         m_displayXPosition = m_textPosition;
    500     } else if ((m_writingDirection == Horizontal && m_cueAlignment == End && m_displayDirection == CSSValueLtr)
    501             || (m_writingDirection == Horizontal && m_cueAlignment == Start && m_displayDirection == CSSValueRtl)) {
    502         m_displayXPosition = 100 - m_textPosition;
     599    if (m_writingDirection == Horizontal) {
     600        if (m_cueAlignment == Start) {
     601            if (m_displayDirection == CSSValueLtr)
     602                m_displayPosition.first = m_textPosition;
     603            else
     604                m_displayPosition.first = 100 - m_textPosition - m_displaySize;
     605        } else if (m_cueAlignment == End) {
     606            if (m_displayDirection == CSSValueRtl)
     607                m_displayPosition.first = 100 - m_textPosition;
     608            else
     609                m_displayPosition.first = m_textPosition - m_displaySize;
     610        }
    503611    }
    504612
    505613    if ((m_writingDirection == VerticalGrowingLeft && m_cueAlignment == Start)
    506614            || (m_writingDirection == VerticalGrowingRight && m_cueAlignment == Start)) {
    507         m_displayYPosition = m_textPosition;
     615        m_displayPosition.second = m_textPosition;
    508616    } else if ((m_writingDirection == VerticalGrowingLeft && m_cueAlignment == End)
    509617            || (m_writingDirection == VerticalGrowingRight && m_cueAlignment == End)) {
    510         m_displayYPosition = 100 - m_textPosition;
     618        m_displayPosition.second = 100 - m_textPosition;
    511619    }
    512620
    513621    if (m_writingDirection == Horizontal && m_cueAlignment == Middle) {
    514         m_displayXPosition = m_textPosition - m_displaySize / 2;
    515 
    516         if (m_displayDirection == CSSValueRtl)
    517            m_displayXPosition = 100 - m_displayXPosition;
     622        if (m_displayDirection == CSSValueLtr)
     623            m_displayPosition.first = m_textPosition - m_displaySize / 2;
     624        else
     625           m_displayPosition.first = 100 - m_textPosition - m_displaySize / 2;
    518626    }
    519627
    520628    if ((m_writingDirection == VerticalGrowingLeft && m_cueAlignment == Middle)
    521629        || (m_writingDirection == VerticalGrowingRight && m_cueAlignment == Middle))
    522         m_displayYPosition = m_textPosition - m_displaySize / 2;
     630        m_displayPosition.second = m_textPosition - m_displaySize / 2;
    523631
    524632    // 10.9 Determine the value of whichever of x-position or y-position is not
    525633    // yet calculated for cue as per the appropriate rules from the following
    526634    // list:
    527     if (m_snapToLines && m_displayYPosition == undefinedPosition && m_writingDirection == Horizontal)
    528         m_displayYPosition = 0;
    529 
    530     if (!m_snapToLines && m_writingDirection == Horizontal)
    531         m_displayYPosition = m_computedLinePosition;
    532 
    533     if (m_snapToLines && m_displayXPosition == undefinedPosition
     635    if (m_snapToLines && m_displayPosition.second == undefinedPosition && m_writingDirection == Horizontal)
     636        m_displayPosition.second = 0;
     637
     638    if (!m_snapToLines && m_displayPosition.second == undefinedPosition && m_writingDirection == Horizontal)
     639        m_displayPosition.second = m_computedLinePosition;
     640
     641    if (m_snapToLines && m_displayPosition.first == undefinedPosition
    534642            && (m_writingDirection == VerticalGrowingLeft || m_writingDirection == VerticalGrowingRight))
    535         m_displayXPosition = 0;
     643        m_displayPosition.first = 0;
    536644
    537645    if (!m_snapToLines && (m_writingDirection == VerticalGrowingLeft || m_writingDirection == VerticalGrowingRight))
    538         m_displayXPosition = m_computedLinePosition;
    539 
    540     // 10.10 Let left be 'x-position vw' and top be 'y-position vh'.
    541 
    542     // FIXME(Bug 79916): CSS top and left properties need to be applied.
     646        m_displayPosition.first = m_computedLinePosition;
    543647}
    544648
    … …  
    588692}
    589693
    590 PassRefPtr<HTMLDivElement> TextTrackCue::getDisplayTree()
    591 {
    592     DEFINE_STATIC_LOCAL(const AtomicString, trackDisplayBoxShadowPseudoId, ("-webkit-media-text-track-display"));
    593 
     694PassRefPtr<TextTrackCueBox> TextTrackCue::getDisplayTree()
     695{
    594696    if (!m_displayTreeShouldChange)
    595697        return m_displayTree;
    … …  
    601703    // following constraints, thus obtaining a set of CSS boxes positioned
    602704    // relative to an initial containing block:
    603     m_displayTree->setShadowPseudoId(trackDisplayBoxShadowPseudoId, ASSERT_NO_EXCEPTION);
    604705    m_displayTree->removeChildren();
    605706
    … …  
    625726    // but if there is a particularly long word, it does not overflow as it
    626727    // normally would in CSS, it is instead forcibly wrapped at the box's edge.)
    627 
    628     // FIXME(BUG 79916): CSS width property should be set to 'size vw', when the
    629     // maximum cue size computation is corrected in the specification.
    630     if (m_snapToLines)
    631         m_displayTree->setInlineStyleProperty(CSSPropertyWidth, (double) m_cueSize, CSSPrimitiveValue::CSS_PERCENTAGE);
    632 
    633     // FIXME(BUG 79750, 79751): Steps 10.12 - 10.14
    634 
    635     if (!m_snapToLines) {
    636         std::pair<double, double> position = getPositionCoordinates();
    637 
    638         // 10.13.1 Set up x and y:
    639         m_displayTree->setInlineStyleProperty(CSSPropertyLeft, position.first, CSSPrimitiveValue::CSS_PERCENTAGE);
    640         m_displayTree->setInlineStyleProperty(CSSPropertyTop, position.second, CSSPrimitiveValue::CSS_PERCENTAGE);
    641 
    642         // 10.13.2 Position the boxes in boxes such that the point x% along the
    643         // width of the bounding box of the boxes in boxes is x% of the way
    644         // across the width of the video's rendering area, and the point y%
    645         // along the height of the bounding box of the boxes in boxes is y%
    646         // of the way across the height of the video's rendering area, while
    647         // maintaining the relative positions of the boxes in boxes to each
    648         // other.
    649         String translateX = "-" + String::number(position.first) + "%";
    650         String translateY = "-" + String::number(position.second) + "%";
    651         String webkitTransformTranslateValue = "translate(" + translateX + "," + translateY + ")";
    652 
    653         m_displayTree->setInlineStyleProperty(CSSPropertyWebkitTransform,
    654                                               webkitTransformTranslateValue);
    655 
    656         m_displayTree->setInlineStyleProperty(CSSPropertyWhiteSpace,
    657                                               CSSValuePre);
    658     }
     728    m_displayTree->applyCSSProperties();
    659729
    660730    if (m_hasInnerTimestamps)
    … …  
    674744}
    675745
    676 std::pair<double, double> TextTrackCue::getPositionCoordinates()
    677 {
     746std::pair<double, double> TextTrackCue::getPositionCoordinates() const
     747{
     748    // This method is used for setting x and y when snap to lines is not set.
    678749    std::pair<double, double> coordinates;
    679750
    … …  
    9301001}
    9311002
     1003int TextTrackCue::getCSSWritingMode() const
     1004{
     1005    return m_displayWritingMode;
     1006}
     1007
     1008int TextTrackCue::getCSSSize() const
     1009{
     1010    return m_displaySize;
     1011}
     1012
     1013std::pair<double, double> TextTrackCue::getCSSPosition() const
     1014{
     1015    if (!m_snapToLines)
     1016        return getPositionCoordinates();
     1017
     1018    return m_displayPosition;
     1019}
     1020
    9321021const AtomicString& TextTrackCue::interfaceName() const
    9331022{

  • trunk/Source/WebCore/html/track/TextTrackCue.h

    r119907 r126233  
    3535
    3636#include "EventTarget.h"
     37#include "HTMLElement.h"
    3738#include "TextTrack.h"
    3839#include <wtf/PassOwnPtr.h>
    … …  
    4243
    4344class DocumentFragment;
     45class HTMLDivElement;
    4446class ScriptExecutionContext;
    4547class TextTrack;
    46 class HTMLDivElement;
     48class TextTrackCue;
     49
     50// ----------------------------
     51
     52class TextTrackCueBox : public HTMLElement {
     53public:
     54    static PassRefPtr<TextTrackCueBox> create(Document* document, TextTrackCue* cue)
     55    {
     56        return adoptRef(new TextTrackCueBox(document, cue));
     57    }
     58
     59    TextTrackCue* getCue() const;
     60    void applyCSSProperties();
     61
     62    virtual const AtomicString& shadowPseudoId() const OVERRIDE;
     63
     64private:
     65    TextTrackCueBox(Document*, TextTrackCue*);
     66
     67    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*) OVERRIDE;
     68
     69    TextTrackCue* m_cue;
     70};
     71
     72// ----------------------------
    4773
    4874class TextTrackCue : public RefCounted<TextTrackCue>, public EventTarget {
    … …  
    102128    void setIsActive(bool);
    103129
    104     PassRefPtr<HTMLDivElement> getDisplayTree();
     130    PassRefPtr<TextTrackCueBox> getDisplayTree();
    105131    void updateDisplayTree(float);
    106132    void removeDisplayTree();
    107133
     134    int calculateComputedLinePosition();
     135
    108136    virtual const AtomicString& interfaceName() const;
    109137    virtual ScriptExecutionContext* scriptExecutionContext() const;
     138
     139    std::pair<double, double> getCSSPosition() const;
     140    int getCSSSize() const;
     141    int getCSSWritingMode() const;
     142
     143    enum WritingDirection {
     144        Horizontal,
     145        VerticalGrowingLeft,
     146        VerticalGrowingRight,
     147        NumberOfWritingDirections
     148    };
     149    WritingDirection getWritingDirection() const { return m_writingDirection; }
    110150
    111151    DEFINE_ATTRIBUTE_EVENT_LISTENER(enter);
    … …  
    122162    TextTrackCue(ScriptExecutionContext*, const String& id, double start, double end, const String& content, const String& settings, bool pauseOnExit);
    123163
     164    std::pair<double, double> getPositionCoordinates() const;
    124165    void parseSettings(const String&);
    125166
    126     int calculateComputedLinePosition();
    127167    void calculateDisplayParameters();
    128 
    129     std::pair<double, double> getPositionCoordinates();
    130168
    131169    void cueWillChange();
    … …  
    148186    int m_cueIndex;
    149187
    150     enum WritingDirection {
    151         Horizontal,
    152         VerticalGrowingLeft,
    153         VerticalGrowingRight,
    154         NumberOfWritingDirections
    155     };
    156188    WritingDirection m_writingDirection;
    157189
    … …  
    174206
    175207    bool m_displayTreeShouldChange;
    176     RefPtr<HTMLDivElement> m_displayTree;
     208    RefPtr<TextTrackCueBox> m_displayTree;
    177209
    178210    int m_displayDirection;
    … …  
    185217    int m_displayWidth;
    186218
    187     double m_displayXPosition;
    188     double m_displayYPosition;
     219    std::pair<float, float> m_displayPosition;
    189220};
    190221
Note: See TracChangeset for help on using the changeset viewer.