ChangeLog

2013-01-23  Victor Carbune  <vcarbune@chromium.org>

        Determine text direction for rendering a TextTrackCue

        https://bugs.webkit.org/show_bug.cgi?id=79749

        Reviewed by NOBODY (OOPS!).

        Test: media/track/track-cue-rendering-rtl.html

        * html/track/TextTrackCue.cpp:

        (WebCore::TextTrackCueBox::applyCSSProperties): Updated to

        retrieve apply the direction determined.

        (WebCore::TextTrackCue::TextTrackCue): Set default value

        for the display direction.

        (WebCore::TextTrackCue::determineTextDirection): Determined

        direction using the Unicode Bidirectional Algorithm.

        (WebCore):

        (WebCore::TextTrackCue::calculateDisplayParameters): Updated.

        (WebCore::TextTrackCue::getCSSWritingDirection): Added to

        return the writing direction of the cue.

        * html/track/TextTrackCue.h:

        (TextTrackCue):

        * platform/graphics/GraphicsContext.cpp: Extracted TextRunIterator.

        * platform/graphics/TextRun.h: Added TextRunIterator.

        (TextRunIterator): Moved the TextRunIterator class to TextRun,

        so it can be used anywhere the unicode bidirectional algorithm

        needs to be run.

        (WebCore::TextRunIterator::TextRunIterator):

        (WebCore::TextRunIterator::offset):

        (WebCore::TextRunIterator::increment):

        (WebCore::TextRunIterator::atEnd):

        (WebCore::TextRunIterator::current):

        (WebCore::TextRunIterator::direction):

        (WebCore::TextRunIterator::operator==):

        (WebCore::TextRunIterator::operator!=):

        (WebCore):

2013-01-23  Tony Chang  <tony@chromium.org>

        Incorrect scrollable height during simplified layout

Source/WebCore/html/track/TextTrackCue.cpp

#include "TextTrackCue.h"

38#include "BidiResolver.h"

#include "CSSPropertyNames.h"

#include "CSSValueKeywords.h"

#include "DocumentFragment.h"

#include "NodeTraversal.h"

#include "RenderTextTrackCue.h"

#include "Text.h"

49#include "TextRun.h"

#include "TextTrack.h"

#include "TextTrackCueList.h"

#include "WebVTTElement.h"

@@void TextTrackCueBox::applyCSSProperties(const IntSize&)

    //  the 'unicode-bidi' property must be set to 'plaintext'

    setInlineStyleProperty(CSSPropertyUnicodeBidi, CSSValueWebkitPlaintext);

122 // FIXME: Determine the text direction using the BIDI algorithm. http://wkb.ug/79749

123124 // the 'direction' property must be set to direction

124 setInlineStyleProperty(CSSPropertyDirection, CSS~~Valu~~eLtr);

125 setInlineStyleProperty(CSSPropertyDirection, m_cue->getCSSWritingDirection());

    // the 'writing-mode' property must be set to writing-mode

    setInlineStyleProperty(CSSPropertyWebkitWritingMode, m_cue->getCSSWritingMode(), false);

@@TextTrackCue::TextTrackCue(ScriptExecutionContext* context, double start, double

    , m_snapToLines(true)

    , m_allDocumentNodes(HTMLDivElement::create(static_cast<Document*>(context)))

    , m_displayTreeShouldChange(true)

214 , m_displayDirection(CSSValueLtr)

{

    ASSERT(m_scriptExecutionContext->isDocument());

@@int TextTrackCue::calculateComputedLinePosition()

    return n;

}

void TextTrackCue::determineTextDirection()

{

    DEFINE_STATIC_LOCAL(const String, rtTag, (ASCIILiteral("rt")));

    createWebVTTNodeTree();

    // Apply the Unicode Bidirectional Algorithm's Paragraph Level steps to the

    // concatenation of the values of each WebVTT Text Object in nodes, in a

    // pre-order, depth-first traversal, excluding WebVTT Ruby Text Objects and

    // their descendants...

    StringBuilder paragraphBuilder;

    for (Node* node = m_webVTTNodeTree->firstChild(); node; node = NodeTraversal::next(node, m_webVTTNodeTree.get())) {

        if (!node->isTextNode() || node->localName() == rtTag)

            continue;

        paragraphBuilder.append(node->nodeValue());

    }

    String paragraph = paragraphBuilder.toString();

    if (!paragraph.length())

        return;

    TextRun textRun(paragraph, paragraph.length());

    BidiResolver<TextRunIterator, BidiCharacterRun> bidiResolver;

    bidiResolver.setStatus(BidiStatus(textRun.direction(), textRun.directionalOverride()));

    bidiResolver.setPositionIgnoringNestedIsolates(TextRunIterator(&textRun, 0));

    BidiRunList<BidiCharacterRun>& bidiRuns = bidiResolver.runs();

    bidiResolver.createBidiRunsForLine(TextRunIterator(&textRun, textRun.length()));

    ASSERT(bidiRuns.runCount());

    // ... to determine the paragraph embedding level of the first Unicode paragraph of the cue.

    // If the paragraph embedding level determined in the previous step is even

    // (the paragraph direction is left-to-right), let direction be 'ltr', otherwise, let it be 'rtl'.

    m_displayDirection = bidiRuns.firstRun()->level() % 2 ? CSSValueRtl : CSSValueLtr;

}

598639void TextTrackCue::calculateDisplayParameters()

599640{

600 // FIXME(BUG 79749): Determine the text direction using the BIDI algorithm.

601641 // Steps 10.2, 10.3

602 ~~m_display~~Direction ~~= CSSValueLtr~~;

642 determineTextDirection();

    // 10.4 If the text track cue writing direction is horizontal, then let

    // block-flow be 'tb'. Otherwise, if the text track cue writing direction is

@@NextSetting:

    }

}

int TextTrackCue::getCSSWritingDirection() const

{

    return m_displayDirection;

}

int TextTrackCue::getCSSWritingMode() const

{

    return m_displayWritingMode;

Source/WebCore/html/track/TextTrackCue.h

@@public:

    virtual ScriptExecutionContext* scriptExecutionContext() const;

    std::pair<double, double> getCSSPosition() const;

172

172173 int getCSSSize() const;

174 int getCSSWritingDirection() const;

    int getCSSWritingMode() const;

    enum WritingDirection {

@@private:

    std::pair<double, double> getPositionCoordinates() const;

    void parseSettings(const String&);

225 void determineTextDirection();

    void calculateDisplayParameters();

    void cueWillChange();

Source/WebCore/platform/graphics/GraphicsContext.cpp

@@using namespace std;

namespace WebCore {

class TextRunIterator {

public:

    TextRunIterator()

        : m_textRun(0)

        , m_offset(0)

    {

    }

    TextRunIterator(const TextRun* textRun, unsigned offset)

        : m_textRun(textRun)

        , m_offset(offset)

    {

    }

    TextRunIterator(const TextRunIterator& other)

        : m_textRun(other.m_textRun)

        , m_offset(other.m_offset)

    {

    }

    unsigned offset() const { return m_offset; }

    void increment() { m_offset++; }

    bool atEnd() const { return !m_textRun || m_offset >= m_textRun->length(); }

    UChar current() const { return (*m_textRun)[m_offset]; }

    WTF::Unicode::Direction direction() const { return atEnd() ? WTF::Unicode::OtherNeutral : WTF::Unicode::direction(current()); }

    bool operator==(const TextRunIterator& other)

    {

        return m_offset == other.m_offset && m_textRun == other.m_textRun;

    }

    bool operator!=(const TextRunIterator& other) { return !operator==(other); }

private:

    const TextRun* m_textRun;

    int m_offset;

};

GraphicsContext::GraphicsContext(PlatformGraphicsContext* platformGraphicsContext)

    : m_updatingControlTints(false)

    , m_transparencyCount(0)

Source/WebCore/platform/graphics/TextRun.h

@@inline void TextRun::setTabSize(bool allow, unsigned size)

    m_tabSize = size;

}

class TextRunIterator {

public:

    TextRunIterator()

        : m_textRun(0)

        , m_offset(0)

    {

    }

    TextRunIterator(const TextRun* textRun, unsigned offset)

        : m_textRun(textRun)

        , m_offset(offset)

    {

    }

    TextRunIterator(const TextRunIterator& other)

        : m_textRun(other.m_textRun)

        , m_offset(other.m_offset)

    {

    }

    unsigned offset() const { return m_offset; }

    void increment() { m_offset++; }

    bool atEnd() const { return !m_textRun || m_offset >= m_textRun->length(); }

    UChar current() const { return (*m_textRun)[m_offset]; }

    WTF::Unicode::Direction direction() const { return atEnd() ? WTF::Unicode::OtherNeutral : WTF::Unicode::direction(current()); }

    bool operator==(const TextRunIterator& other)

    {

        return m_offset == other.m_offset && m_textRun == other.m_textRun;

    }

    bool operator!=(const TextRunIterator& other) { return !operator==(other); }

private:

    const TextRun* m_textRun;

    int m_offset;

};

}

#endif

LayoutTests/ChangeLog

2013-01-23  Victor Carbune  <vcarbune@chromium.org>

        Determine text direction for rendering a TextTrackCue

        https://bugs.webkit.org/show_bug.cgi?id=79749

        Reviewed by NOBODY (OOPS!).

        * media/track/captions-webvtt/captions-rtl.vtt: Added.

        * media/track/track-cue-rendering-rtl-expected.txt: Added.

        * media/track/track-cue-rendering-rtl.html: Added.

2013-01-23  Tony Chang  <tony@chromium.org>

        Incorrect scrollable height during simplified layout

LayoutTests/media/track/captions-webvtt/captions-rtl.vtt

﻿WEBVTT

1

00:00:00.000 --> 00:00:01.000

تجربة

LayoutTests/media/track/track-cue-rendering-rtl-expected.txt

Test that TextTrack RTL cues are rendered correctly.

EVENT(canplaythrough)

EVENT(seeked)

** The cue should contain arabic text **

EXPECTED (video.currentTime == '0.5') OK

EXPECTED (testTrack.track.activeCues.length == '1') OK

EXPECTED (testTrack.track.activeCues[0].text == 'تجربة') OK

EXPECTED (testCueDisplayBox.innerText == 'تجربة') OK

** The position should be default and CSS direction set to RTL **

EXPECTED (2 * testCueDisplayBox.offsetLeft == video.videoWidth - testCueDisplayBox.offsetWidth == 'true') OK

EXPECTED (getComputedStyle(testCueDisplayBox).direction == 'rtl') OK

END OF TEST

LayoutTests/media/track/track-cue-rendering-rtl.html

<!DOCTYPE html>

<html>

    <head>

        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

        <script src=../media-file.js></script>

        <script src=../video-test.js></script>

        <script src=../media-controls.js></script>

        <script>

        var testTrack;

        var testCueDisplayBox;

        var seekedCount = 0;

        var info = [ "تجربة" ];

        function testCueStyle()

        {

            endTest();

        }

        function seeked()

        {

            testCueDisplayBox = textTrackDisplayElement(video, 'display');

            consoleWrite("");

            consoleWrite("** The cue should contain arabic text **");

            testExpected("video.currentTime", seekedCount + .5);

            testExpected("testTrack.track.activeCues.length", 1);

            testExpected("testTrack.track.activeCues[0].text", info[seekedCount]);

            testExpected("testCueDisplayBox.innerText", info[seekedCount]);

            consoleWrite("");

            consoleWrite("** The position should be default and CSS direction set to RTL **");

            testExpected("2 * testCueDisplayBox.offsetLeft == video.videoWidth - testCueDisplayBox.offsetWidth", true)

            testExpected("getComputedStyle(testCueDisplayBox).direction", "rtl");

            if (++seekedCount == info.length)

                endTest();

            else {

                consoleWrite("");

                run("video.currentTime = " + (video.currentTime + 1));

                return;

            }

        }

        function loaded()

        {

            consoleWrite("Test that TextTrack RTL cues are rendered correctly.");

            testTrack = document.querySelector('track');

            findMediaElement();

            video.src = findMediaFile('video', '../content/test');

            consoleWrite("");

            waitForEvent('seeked', seeked);

            waitForEvent('canplaythrough', function() { video.currentTime = .5; });

        }

        </script>

    </head>

    <body onload="loaded()">

        <video controls >

            <track src="captions-webvtt/captions-rtl.vtt" kind="captions" default>

        </video>

    </body>

</html>