blob: 31c352cf039851a43235f1afebdfa567900ecd92 [file] [log] [blame]
/*
* Copyright (c) 2013, Opera Software ASA. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of Opera Software ASA nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "core/html/track/vtt/VTTCue.h"
#include "bindings/core/v8/ExceptionMessages.h"
#include "bindings/core/v8/ExceptionState.h"
#include "bindings/core/v8/double_or_auto_keyword.h"
#include "core/CSSPropertyNames.h"
#include "core/CSSValueKeywords.h"
#include "core/dom/DocumentFragment.h"
#include "core/dom/NodeTraversal.h"
#include "core/dom/events/Event.h"
#include "core/frame/Settings.h"
#include "core/frame/UseCounter.h"
#include "core/html/HTMLDivElement.h"
#include "core/html/track/TextTrack.h"
#include "core/html/track/TextTrackCueList.h"
#include "core/html/track/vtt/VTTElement.h"
#include "core/html/track/vtt/VTTParser.h"
#include "core/html/track/vtt/VTTRegion.h"
#include "core/html/track/vtt/VTTScanner.h"
#include "core/layout/LayoutVTTCue.h"
#include "platform/runtime_enabled_features.h"
#include "platform/text/BidiResolver.h"
#include "platform/text/TextRunIterator.h"
#include "platform/wtf/MathExtras.h"
#include "platform/wtf/text/StringBuilder.h"
namespace blink {
static const CSSValueID kDisplayWritingModeMap[] = {
CSSValueHorizontalTb, CSSValueVerticalRl, CSSValueVerticalLr};
static_assert(WTF_ARRAY_LENGTH(kDisplayWritingModeMap) ==
VTTCue::kNumberOfWritingDirections,
"displayWritingModeMap should have the same number of elements "
"as VTTCue::NumberOfWritingDirections");
static const CSSValueID kDisplayAlignmentMap[] = {
CSSValueStart, CSSValueCenter, CSSValueEnd, CSSValueLeft, CSSValueRight};
static_assert(WTF_ARRAY_LENGTH(kDisplayAlignmentMap) ==
VTTCue::kNumberOfAlignments,
"displayAlignmentMap should have the same number of elements as "
"VTTCue::NumberOfAlignments");
static const String& AutoKeyword() {
DEFINE_STATIC_LOCAL(const String, auto_string, ("auto"));
return auto_string;
}
static const String& StartKeyword() {
DEFINE_STATIC_LOCAL(const String, start, ("start"));
return start;
}
static const String& CenterKeyword() {
DEFINE_STATIC_LOCAL(const String, center, ("center"));
return center;
}
static const String& EndKeyword() {
DEFINE_STATIC_LOCAL(const String, end, ("end"));
return end;
}
static const String& LeftKeyword() {
DEFINE_STATIC_LOCAL(const String, left, ("left"));
return left;
}
static const String& RightKeyword() {
DEFINE_STATIC_LOCAL(const String, right, ("right"));
return right;
}
static const String& HorizontalKeyword() {
return g_empty_string;
}
static const String& VerticalGrowingLeftKeyword() {
DEFINE_STATIC_LOCAL(const String, verticalrl, ("rl"));
return verticalrl;
}
static const String& VerticalGrowingRightKeyword() {
DEFINE_STATIC_LOCAL(const String, verticallr, ("lr"));
return verticallr;
}
static bool IsInvalidPercentage(double value) {
DCHECK(std::isfinite(value));
return value < 0 || value > 100;
}
static bool IsInvalidPercentage(double value, ExceptionState& exception_state) {
if (IsInvalidPercentage(value)) {
exception_state.ThrowDOMException(
kIndexSizeError,
ExceptionMessages::IndexOutsideRange<double>(
"value", value, 0, ExceptionMessages::kInclusiveBound, 100,
ExceptionMessages::kInclusiveBound));
return true;
}
return false;
}
// Sets inline CSS properties on passed in element if value is not an empty
// string.
static void SetInlineStylePropertyIfNotEmpty(Element& element,
CSSPropertyID property_id,
const String& value) {
if (!value.IsEmpty())
element.SetInlineStyleProperty(property_id, value);
}
VTTCueBox::VTTCueBox(Document& document)
: HTMLDivElement(document),
snap_to_lines_position_(std::numeric_limits<float>::quiet_NaN()) {
SetShadowPseudoId(AtomicString("-webkit-media-text-track-display"));
}
void VTTCueBox::ApplyCSSProperties(
const VTTDisplayParameters& display_parameters) {
// http://dev.w3.org/html5/webvtt/#applying-css-properties-to-webvtt-node-objects
// Initialize the (root) list of WebVTT Node Objects with the following CSS
// settings:
// the 'position' property must be set to 'absolute'
SetInlineStyleProperty(CSSPropertyPosition, CSSValueAbsolute);
// the 'unicode-bidi' property must be set to 'plaintext'
SetInlineStyleProperty(CSSPropertyUnicodeBidi, CSSValueWebkitPlaintext);
// the 'direction' property must be set to direction
SetInlineStyleProperty(CSSPropertyDirection, display_parameters.direction);
// the 'writing-mode' property must be set to writing-mode
SetInlineStyleProperty(CSSPropertyWebkitWritingMode,
display_parameters.writing_mode);
const FloatPoint& position = display_parameters.position;
// the 'top' property must be set to top,
SetInlineStyleProperty(CSSPropertyTop, position.Y(),
CSSPrimitiveValue::UnitType::kPercentage);
// the 'left' property must be set to left
SetInlineStyleProperty(CSSPropertyLeft, position.X(),
CSSPrimitiveValue::UnitType::kPercentage);
// the 'width' property must be set to width, and the 'height' property must
// be set to height
if (display_parameters.writing_mode == CSSValueHorizontalTb) {
SetInlineStyleProperty(CSSPropertyWidth, display_parameters.size,
CSSPrimitiveValue::UnitType::kPercentage);
SetInlineStyleProperty(CSSPropertyHeight, CSSValueAuto);
} else {
SetInlineStyleProperty(CSSPropertyWidth, CSSValueAuto);
SetInlineStyleProperty(CSSPropertyHeight, display_parameters.size,
CSSPrimitiveValue::UnitType::kPercentage);
}
// The 'text-align' property on the (root) List of WebVTT Node Objects must
// be set to the value in the second cell of the row of the table below
// whose first cell is the value of the corresponding cue's WebVTT cue
// text alignment:
SetInlineStyleProperty(CSSPropertyTextAlign, display_parameters.text_align);
// The snap-to-lines position is propagated to LayoutVTTCue.
snap_to_lines_position_ = display_parameters.snap_to_lines_position;
}
LayoutObject* VTTCueBox::CreateLayoutObject(const ComputedStyle& style) {
// If WebVTT Regions are used, the regular WebVTT layout algorithm is no
// longer necessary, since cues having the region parameter set do not have
// any positioning parameters. Also, in this case, the regions themselves
// have positioning information.
if (style.GetPosition() == EPosition::kRelative)
return HTMLDivElement::CreateLayoutObject(style);
return new LayoutVTTCue(this, snap_to_lines_position_);
}
VTTCue::VTTCue(Document& document,
double start_time,
double end_time,
const String& text)
: TextTrackCue(start_time, end_time),
text_(text),
line_position_(std::numeric_limits<double>::quiet_NaN()),
text_position_(std::numeric_limits<double>::quiet_NaN()),
cue_size_(100),
writing_direction_(kHorizontal),
cue_alignment_(kCenter),
vtt_node_tree_(nullptr),
cue_background_box_(HTMLDivElement::Create(document)),
snap_to_lines_(true),
display_tree_should_change_(true) {
UseCounter::Count(document, WebFeature::kVTTCue);
cue_background_box_->SetShadowPseudoId(CueShadowPseudoId());
}
VTTCue::~VTTCue() = default;
#ifndef NDEBUG
String VTTCue::ToString() const {
return String::Format("%p id=%s interval=%f-->%f cue=%s)", this,
id().Utf8().data(), startTime(), endTime(),
text().Utf8().data());
}
#endif
void VTTCue::CueDidChange(CueMutationAffectsOrder affects_order) {
TextTrackCue::CueDidChange(affects_order);
display_tree_should_change_ = true;
}
const String& VTTCue::vertical() const {
switch (writing_direction_) {
case kHorizontal:
return HorizontalKeyword();
case kVerticalGrowingLeft:
return VerticalGrowingLeftKeyword();
case kVerticalGrowingRight:
return VerticalGrowingRightKeyword();
default:
NOTREACHED();
return g_empty_string;
}
}
void VTTCue::setVertical(const String& value) {
WritingDirection direction = writing_direction_;
if (value == HorizontalKeyword())
direction = kHorizontal;
else if (value == VerticalGrowingLeftKeyword())
direction = kVerticalGrowingLeft;
else if (value == VerticalGrowingRightKeyword())
direction = kVerticalGrowingRight;
else
NOTREACHED();
if (direction == writing_direction_)
return;
CueWillChange();
writing_direction_ = direction;
CueDidChange();
}
void VTTCue::setSnapToLines(bool value) {
if (snap_to_lines_ == value)
return;
CueWillChange();
snap_to_lines_ = value;
CueDidChange();
}
bool VTTCue::LineIsAuto() const {
return std::isnan(line_position_);
}
void VTTCue::line(DoubleOrAutoKeyword& result) const {
if (LineIsAuto())
result.SetAutoKeyword(AutoKeyword());
else
result.SetDouble(line_position_);
}
void VTTCue::setLine(const DoubleOrAutoKeyword& position) {
// http://dev.w3.org/html5/webvtt/#dfn-vttcue-line
// On setting, the WebVTT cue line must be set to the new value; if the new
// value is the string "auto", then it must be interpreted as the special
// value auto. ("auto" is translated to NaN.)
double line_position;
if (position.IsAutoKeyword()) {
if (LineIsAuto())
return;
line_position = std::numeric_limits<double>::quiet_NaN();
} else {
DCHECK(position.IsDouble());
line_position = position.GetAsDouble();
if (line_position_ == line_position)
return;
}
CueWillChange();
line_position_ = line_position;
CueDidChange();
}
bool VTTCue::TextPositionIsAuto() const {
return std::isnan(text_position_);
}
void VTTCue::position(DoubleOrAutoKeyword& result) const {
if (TextPositionIsAuto())
result.SetAutoKeyword(AutoKeyword());
else
result.SetDouble(text_position_);
}
void VTTCue::setPosition(const DoubleOrAutoKeyword& position,
ExceptionState& exception_state) {
// http://dev.w3.org/html5/webvtt/#dfn-vttcue-position
// On setting, if the new value is negative or greater than 100, then an
// IndexSizeError exception must be thrown. Otherwise, the WebVTT cue
// position must be set to the new value; if the new value is the string
// "auto", then it must be interpreted as the special value auto.
double text_position;
if (position.IsAutoKeyword()) {
if (TextPositionIsAuto())
return;
text_position = std::numeric_limits<double>::quiet_NaN();
} else {
DCHECK(position.IsDouble());
if (IsInvalidPercentage(position.GetAsDouble(), exception_state))
return;
text_position = position.GetAsDouble();
if (text_position_ == text_position)
return;
}
CueWillChange();
text_position_ = text_position;
CueDidChange();
}
void VTTCue::setSize(double size, ExceptionState& exception_state) {
// http://dev.w3.org/html5/webvtt/#dfn-vttcue-size
// On setting, if the new value is negative or greater than 100, then throw
// an IndexSizeError exception.
if (IsInvalidPercentage(size, exception_state))
return;
// Otherwise, set the WebVTT cue size to the new value.
if (cue_size_ == size)
return;
CueWillChange();
cue_size_ = size;
CueDidChange();
}
const String& VTTCue::align() const {
switch (cue_alignment_) {
case kStart:
return StartKeyword();
case kCenter:
return CenterKeyword();
case kEnd:
return EndKeyword();
case kLeft:
return LeftKeyword();
case kRight:
return RightKeyword();
default:
NOTREACHED();
return g_empty_string;
}
}
void VTTCue::setAlign(const String& value) {
CueAlignment alignment = cue_alignment_;
if (value == StartKeyword())
alignment = kStart;
else if (value == CenterKeyword())
alignment = kCenter;
else if (value == EndKeyword())
alignment = kEnd;
else if (value == LeftKeyword())
alignment = kLeft;
else if (value == RightKeyword())
alignment = kRight;
else
NOTREACHED();
if (alignment == cue_alignment_)
return;
CueWillChange();
cue_alignment_ = alignment;
CueDidChange();
}
void VTTCue::setText(const String& text) {
if (text_ == text)
return;
CueWillChange();
// Clear the document fragment but don't bother to create it again just yet as
// we can do that when it is requested.
vtt_node_tree_ = nullptr;
text_ = text;
CueDidChange();
}
void VTTCue::CreateVTTNodeTree() {
if (!vtt_node_tree_)
vtt_node_tree_ =
VTTParser::CreateDocumentFragmentFromCueText(GetDocument(), text_);
}
void VTTCue::CopyVTTNodeToDOMTree(ContainerNode* vtt_node,
ContainerNode* parent) {
for (Node* node = vtt_node->firstChild(); node; node = node->nextSibling()) {
Node* cloned_node;
if (node->IsVTTElement())
cloned_node =
ToVTTElement(node)->CreateEquivalentHTMLElement(GetDocument());
else
cloned_node = node->cloneNode(false);
parent->AppendChild(cloned_node);
if (node->IsContainerNode())
CopyVTTNodeToDOMTree(ToContainerNode(node), ToContainerNode(cloned_node));
}
}
DocumentFragment* VTTCue::getCueAsHTML() {
CreateVTTNodeTree();
DocumentFragment* cloned_fragment = DocumentFragment::Create(GetDocument());
CopyVTTNodeToDOMTree(vtt_node_tree_.Get(), cloned_fragment);
return cloned_fragment;
}
void VTTCue::setRegion(VTTRegion* region) {
if (region_ == region)
return;
CueWillChange();
region_ = region;
CueDidChange();
}
double VTTCue::CalculateComputedLinePosition() const {
// http://dev.w3.org/html5/webvtt/#dfn-cue-computed-line
// A WebVTT cue has a computed line whose value is that returned by the
// following algorithm, which is defined in terms of the other aspects of
// the cue:
// 1. If the line is numeric, the WebVTT cue snap-to-lines flag of the
// WebVTT cue is not set, and the line is negative or greater than 100,
// then return 100 and abort these steps.
if (!LineIsAuto() && !snap_to_lines_ && IsInvalidPercentage(line_position_))
return 100;
// 2. If the line is numeric, return the value of the WebVTT cue line and
// abort these steps. (Either the WebVTT cue snap-to-lines flag is set,
// so any value, not just those in the range 0..100, is valid, or the
// value is in the range 0..100 and is thus valid regardless of the
// value of that flag.)
if (!LineIsAuto())
return line_position_;
// 3. If the WebVTT cue snap-to-lines flag of the WebVTT cue is not set,
// return the value 100 and abort these steps. (The WebVTT cue line is
// the special value auto.)
if (!snap_to_lines_)
return 100;
// 4. Let cue be the WebVTT cue.
// 5. If cue is not in a list of cues of a text track, or if that text
// track is not in the list of text tracks of a media element, return -1
// and abort these steps.
if (!track())
return -1;
// 6. Let track be the text track whose list of cues the cue is in.
// 7. Let n be the number of text tracks whose text track mode is showing
// and that are in the media element's list of text tracks before track.
int n = track()->TrackIndexRelativeToRenderedTracks();
// 8. Increment n by one. / 9. Negate n. / 10. Return n.
n++;
n = -n;
return n;
}
class VTTTextRunIterator : public TextRunIterator {
public:
VTTTextRunIterator() = default;
VTTTextRunIterator(const TextRun* text_run, unsigned offset)
: TextRunIterator(text_run, offset) {}
bool AtParagraphSeparator() const {
// Within a cue, paragraph boundaries are only denoted by Type B characters,
// such as U+000A LINE FEED (LF), U+0085 NEXT LINE (NEL),
// and U+2029 PARAGRAPH SEPARATOR.
return WTF::Unicode::Category(Current()) &
WTF::Unicode::kSeparator_Paragraph;
}
};
// Almost the same as determineDirectionality in core/html/HTMLElement.cpp, but
// that one uses a "plain" TextRunIterator (which only checks for '\n').
static TextDirection DetermineDirectionality(const String& value,
bool& has_strong_directionality) {
TextRun run(value);
BidiResolver<VTTTextRunIterator, BidiCharacterRun> bidi_resolver;
bidi_resolver.SetStatus(BidiStatus(TextDirection::kLtr, false));
bidi_resolver.SetPositionIgnoringNestedIsolates(VTTTextRunIterator(&run, 0));
return bidi_resolver.DetermineDirectionality(&has_strong_directionality);
}
static CSSValueID DetermineTextDirection(DocumentFragment* vtt_root) {
DCHECK(vtt_root);
// 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.
TextDirection text_direction = TextDirection::kLtr;
Node* node = NodeTraversal::Next(*vtt_root);
while (node) {
DCHECK(node->IsDescendantOf(vtt_root));
if (node->IsTextNode()) {
bool has_strong_directionality;
text_direction =
DetermineDirectionality(node->nodeValue(), has_strong_directionality);
if (has_strong_directionality)
break;
} else if (node->IsVTTElement()) {
if (ToVTTElement(node)->WebVTTNodeType() == kVTTNodeTypeRubyText) {
node = NodeTraversal::NextSkippingChildren(*node);
continue;
}
}
node = NodeTraversal::Next(*node);
}
return IsLtr(text_direction) ? CSSValueLtr : CSSValueRtl;
}
double VTTCue::CalculateComputedTextPosition() const {
// http://dev.w3.org/html5/webvtt/#dfn-cue-computed-position
// 1. If the position is numeric, then return the value of the position and
// abort these steps. (Otherwise, the position is the special value auto.)
if (!TextPositionIsAuto())
return text_position_;
switch (cue_alignment_) {
// 2. If the cue text alignment is start or left, return 0 and abort these
// steps.
case kStart:
case kLeft:
return 0;
// 3. If the cue text alignment is end or right, return 100 and abort these
// steps.
case kEnd:
case kRight:
return 100;
// 4. If the cue text alignment is center, return 50 and abort these steps.
case kCenter:
return 50;
default:
NOTREACHED();
return 0;
}
}
VTTCue::CueAlignment VTTCue::CalculateComputedCueAlignment() const {
switch (cue_alignment_) {
case VTTCue::kLeft:
return VTTCue::kStart;
case VTTCue::kRight:
return VTTCue::kEnd;
default:
return cue_alignment_;
}
}
VTTDisplayParameters::VTTDisplayParameters()
: size(std::numeric_limits<float>::quiet_NaN()),
direction(CSSValueNone),
text_align(CSSValueNone),
writing_mode(CSSValueNone),
snap_to_lines_position(std::numeric_limits<float>::quiet_NaN()) {}
VTTDisplayParameters VTTCue::CalculateDisplayParameters() const {
// http://dev.w3.org/html5/webvtt/#dfn-apply-webvtt-cue-settings
VTTDisplayParameters display_parameters;
// Steps 1 and 2.
display_parameters.direction = DetermineTextDirection(vtt_node_tree_.Get());
if (display_parameters.direction == CSSValueRtl)
UseCounter::Count(GetDocument(), WebFeature::kVTTCueRenderRtl);
// Note: The 'text-align' property is also determined here so that
// VTTCueBox::applyCSSProperties need not have access to a VTTCue.
display_parameters.text_align = kDisplayAlignmentMap[GetCueAlignment()];
// 3. If the cue writing direction is horizontal, then let block-flow be
// 'tb'. Otherwise, if the cue writing direction is vertical growing left,
// then let block-flow be 'lr'. Otherwise, the cue writing direction is
// vertical growing right; let block-flow be 'rl'.
display_parameters.writing_mode = kDisplayWritingModeMap[writing_direction_];
// Resolve the cue alignment to one of the values {start, end, center}.
CueAlignment computed_cue_alignment = CalculateComputedCueAlignment();
// 4. Determine the value of maximum size for cue as per the appropriate
// rules from the following list:
double computed_text_position = CalculateComputedTextPosition();
double maximum_size = computed_text_position;
if (computed_cue_alignment == kStart) {
maximum_size = 100 - computed_text_position;
} else if (computed_cue_alignment == kEnd) {
maximum_size = computed_text_position;
} else if (computed_cue_alignment == kCenter) {
maximum_size = computed_text_position <= 50
? computed_text_position
: (100 - computed_text_position);
maximum_size = maximum_size * 2;
} else {
NOTREACHED();
}
// 5. If the cue size is less than maximum size, then let size
// be cue size. Otherwise, let size be maximum size.
display_parameters.size = std::min(cue_size_, maximum_size);
// 6. If the cue writing direction is horizontal, then let width
// be 'size vw' and height be 'auto'. Otherwise, let width be 'auto' and
// height be 'size vh'. (These are CSS values used by the next section to
// set CSS properties for the rendering; 'vw' and 'vh' are CSS units.)
// (Emulated in VTTCueBox::applyCSSProperties.)
// 7. Determine the value of x-position or y-position for cue as per the
// appropriate rules from the following list:
if (writing_direction_ == kHorizontal) {
switch (computed_cue_alignment) {
case kStart:
display_parameters.position.SetX(computed_text_position);
break;
case kEnd:
display_parameters.position.SetX(computed_text_position -
display_parameters.size);
break;
case kCenter:
display_parameters.position.SetX(computed_text_position -
display_parameters.size / 2);
break;
default:
NOTREACHED();
}
} else {
// Cases for m_writingDirection being VerticalGrowing{Left|Right}
switch (computed_cue_alignment) {
case kStart:
display_parameters.position.SetY(computed_text_position);
break;
case kEnd:
display_parameters.position.SetY(computed_text_position -
display_parameters.size);
break;
case kCenter:
display_parameters.position.SetY(computed_text_position -
display_parameters.size / 2);
break;
default:
NOTREACHED();
}
}
// A cue has a computed line whose value is defined in terms of
// the other aspects of the cue.
double computed_line_position = CalculateComputedLinePosition();
// 8. Determine the value of whichever of x-position or y-position is not
// yet calculated for cue as per the appropriate rules from the following
// list:
if (!snap_to_lines_) {
if (writing_direction_ == kHorizontal)
display_parameters.position.SetY(computed_line_position);
else
display_parameters.position.SetX(computed_line_position);
} else {
if (writing_direction_ == kHorizontal)
display_parameters.position.SetY(0);
else
display_parameters.position.SetX(0);
}
// Step 9 not implemented (margin == 0).
// The snap-to-lines position is propagated to LayoutVTTCue.
display_parameters.snap_to_lines_position =
snap_to_lines_ ? computed_line_position
: std::numeric_limits<float>::quiet_NaN();
DCHECK(std::isfinite(display_parameters.size));
DCHECK_NE(display_parameters.direction, CSSValueNone);
DCHECK_NE(display_parameters.writing_mode, CSSValueNone);
return display_parameters;
}
void VTTCue::UpdatePastAndFutureNodes(double movie_time) {
DEFINE_STATIC_LOCAL(const String, timestamp_tag, ("timestamp"));
DCHECK(IsActive());
// An active cue may still not have a display tree, e.g. if its track is
// hidden or if the track belongs to an audio element.
if (!display_tree_)
return;
// FIXME: Per spec it's possible for neither :past nor :future to match, but
// as implemented here and in SelectorChecker they are simply each others
// negations. For a cue with no internal timestamps, :past will match but
// should not per spec. :future is correct, however. See the spec bug to
// determine what the correct behavior should be:
// https://www.w3.org/Bugs/Public/show_bug.cgi?id=28237
bool is_past_node = true;
double current_timestamp = startTime();
if (current_timestamp > movie_time)
is_past_node = false;
for (Node& child : NodeTraversal::DescendantsOf(*display_tree_)) {
if (child.nodeName() == timestamp_tag) {
double current_timestamp;
bool check =
VTTParser::CollectTimeStamp(child.nodeValue(), current_timestamp);
DCHECK(check);
if (current_timestamp > movie_time)
is_past_node = false;
}
if (child.IsVTTElement()) {
ToVTTElement(child).SetIsPastNode(is_past_node);
// Make an elemenet id match a cue id for style matching purposes.
if (!id().IsEmpty())
ToElement(child).SetIdAttribute(id());
}
}
}
VTTCueBox* VTTCue::GetDisplayTree() {
DCHECK(track() && track()->IsRendered() && IsActive());
if (!display_tree_) {
display_tree_ = VTTCueBox::Create(GetDocument());
display_tree_->AppendChild(cue_background_box_);
}
DCHECK_EQ(display_tree_->firstChild(), cue_background_box_);
if (!display_tree_should_change_) {
// Apply updated user style overrides for text tracks when display tree
// doesn't change. This ensures that the track settings are refreshed when
// the video is replayed or when the user slides back to an already rendered
// track.
ApplyUserOverrideCSSProperties();
return display_tree_;
}
CreateVTTNodeTree();
cue_background_box_->RemoveChildren();
vtt_node_tree_->CloneChildNodes(cue_background_box_.Get());
if (!region()) {
VTTDisplayParameters display_parameters = CalculateDisplayParameters();
display_tree_->ApplyCSSProperties(display_parameters);
} else {
display_tree_->SetInlineStyleProperty(CSSPropertyPosition,
CSSValueRelative);
}
// Apply user override settings for text tracks
ApplyUserOverrideCSSProperties();
display_tree_should_change_ = false;
return display_tree_;
}
void VTTCue::RemoveDisplayTree(RemovalNotification removal_notification) {
if (!display_tree_)
return;
if (removal_notification == kNotifyRegion) {
// The region needs to be informed about the cue removal.
if (region())
region()->WillRemoveVTTCueBox(display_tree_);
}
display_tree_->remove(ASSERT_NO_EXCEPTION);
}
void VTTCue::UpdateDisplay(HTMLDivElement& container) {
DCHECK(track() && track()->IsRendered() && IsActive());
UseCounter::Count(GetDocument(), WebFeature::kVTTCueRender);
if (writing_direction_ != kHorizontal)
UseCounter::Count(GetDocument(), WebFeature::kVTTCueRenderVertical);
if (!snap_to_lines_)
UseCounter::Count(GetDocument(), WebFeature::kVTTCueRenderSnapToLinesFalse);
if (!LineIsAuto())
UseCounter::Count(GetDocument(), WebFeature::kVTTCueRenderLineNotAuto);
if (TextPositionIsAuto())
UseCounter::Count(GetDocument(), WebFeature::kVTTCueRenderPositionNot50);
if (cue_size_ != 100)
UseCounter::Count(GetDocument(), WebFeature::kVTTCueRenderSizeNot100);
if (cue_alignment_ != kCenter)
UseCounter::Count(GetDocument(), WebFeature::kVTTCueRenderAlignNotCenter);
VTTCueBox* display_box = GetDisplayTree();
if (!region()) {
if (display_box->HasChildren() && !container.contains(display_box)) {
// Note: the display tree of a cue is removed when the active flag of the
// cue is unset.
container.AppendChild(display_box);
}
} else {
HTMLDivElement* region_node = region()->GetDisplayTree(GetDocument());
// Append the region to the viewport, if it was not already.
if (!container.contains(region_node))
container.AppendChild(region_node);
region()->AppendVTTCueBox(display_box);
}
}
VTTCue::CueSetting VTTCue::SettingName(VTTScanner& input) const {
CueSetting parsed_setting = kNone;
if (input.Scan("vertical"))
parsed_setting = kVertical;
else if (input.Scan("line"))
parsed_setting = kLine;
else if (input.Scan("position"))
parsed_setting = kPosition;
else if (input.Scan("size"))
parsed_setting = kSize;
else if (input.Scan("align"))
parsed_setting = kAlign;
else if (RuntimeEnabledFeatures::WebVTTRegionsEnabled() &&
input.Scan("region"))
parsed_setting = kRegionId;
// Verify that a ':' follows.
if (parsed_setting != kNone && input.Scan(':'))
return parsed_setting;
return kNone;
}
static bool ScanPercentage(VTTScanner& input, double& number) {
// http://dev.w3.org/html5/webvtt/#dfn-parse-a-percentage-string
// 1. Let input be the string being parsed.
// 2. If input contains any characters other than U+0025 PERCENT SIGN
// characters (%), U+002E DOT characters (.) and ASCII digits, then
// fail.
// 3. If input does not contain at least one ASCII digit, then fail.
// 4. If input contains more than one U+002E DOT character (.), then fail.
// 5. If any character in input other than the last character is a U+0025
// PERCENT SIGN character (%), then fail.
// 6. If the last character in input is not a U+0025 PERCENT SIGN character
// (%), then fail.
// 7. Ignoring the trailing percent sign, interpret input as a real
// number. Let that number be the percentage.
// 8. If percentage is outside the range 0..100, then fail.
// 9. Return percentage.
return input.ScanPercentage(number) && !IsInvalidPercentage(number);
}
void VTTCue::ParseSettings(const VTTRegionMap* region_map,
const String& input_string) {
VTTScanner input(input_string);
while (!input.IsAtEnd()) {
// The WebVTT cue settings part of a WebVTT cue consists of zero or more of
// the following components, in any order, separated from each other by one
// or more U+0020 SPACE characters or U+0009 CHARACTER TABULATION (tab)
// characters.
input.SkipWhile<VTTParser::IsValidSettingDelimiter>();
if (input.IsAtEnd())
break;
// When the user agent is to parse the WebVTT settings given by a string
// input for a text track cue cue,
// the user agent must run the following steps:
// 1. Let settings be the result of splitting input on spaces.
// 2. For each token setting in the list settings, run the following
// substeps:
// 1. If setting does not contain a U+003A COLON character (:), or if the
// first U+003A COLON character (:) in setting is either the first or
// last character of setting, then jump to the step labeled next
// setting.
// 2. Let name be the leading substring of setting up to and excluding
// the first U+003A COLON character (:) in that string.
CueSetting name = SettingName(input);
// 3. Let value be the trailing substring of setting starting from the
// character immediately after the first U+003A COLON character (:) in
// that string.
VTTScanner::Run value_run =
input.CollectUntil<VTTParser::IsValidSettingDelimiter>();
// 4. Run the appropriate substeps that apply for the value of name, as
// follows:
switch (name) {
case kVertical: {
// If name is a case-sensitive match for "vertical"
// 1. If value is a case-sensitive match for the string "rl", then
// let cue's WebVTT cue writing direction be vertical
// growing left.
if (input.ScanRun(value_run, VerticalGrowingLeftKeyword()))
writing_direction_ = kVerticalGrowingLeft;
// 2. Otherwise, if value is a case-sensitive match for the string
// "lr", then let cue's WebVTT cue writing direction be
// vertical growing right.
else if (input.ScanRun(value_run, VerticalGrowingRightKeyword()))
writing_direction_ = kVerticalGrowingRight;
break;
}
case kLine: {
// If name is a case-sensitive match for "line"
// Steps 1 - 2 skipped.
double number;
// 3. If linepos does not contain at least one ASCII digit, then
// jump to the step labeled next setting.
// 4. If the last character in linepos is a U+0025 PERCENT SIGN
// character (%)
//
// If parse a percentage string from linepos doesn't fail, let
// number be the returned percentage, otherwise jump to the step
// labeled next setting.
bool is_percentage = input.ScanPercentage(number);
if (is_percentage) {
if (IsInvalidPercentage(number))
break;
} else {
// Otherwise
//
// 1. If linepos contains any characters other than U+002D
// HYPHEN-MINUS characters (-), ASCII digits, and U+002E DOT
// character (.), then jump to the step labeled next setting.
//
// 2. If any character in linepos other than the first character is a
// U+002D HYPHEN-MINUS character (-), then jump to the step
// labeled next setting.
//
// 3. If there are more than one U+002E DOT characters (.), then jump
// to the step labeled next setting.
//
// 4. If there is a U+002E DOT character (.) and the character before
// or the character after is not an ASCII digit, or if the U+002E
// DOT character (.) is the first or the last character, then jump
// to the step labeled next setting.
//
// 5. Interpret linepos as a (potentially signed) real number, and
// let number be that number.
bool is_negative = input.Scan('-');
if (!input.ScanDouble(number))
break;
// Negate number if it was preceded by a hyphen-minus - unless it's
// zero.
if (is_negative && number)
number = -number;
}
if (!input.IsAt(value_run.end()))
break;
// 5. Let cue's WebVTT cue line be number.
line_position_ = number;
// 6. If the last character in linepos is a U+0025 PERCENT SIGN
// character (%), then let cue's WebVTT cue snap-to-lines
// flag be false. Otherwise, let it be true.
snap_to_lines_ = !is_percentage;
// Steps 7 - 9 skipped.
break;
}
case kPosition: {
// If name is a case-sensitive match for "position".
double number;
// Steps 1 - 2 skipped.
// 3. If parse a percentage string from colpos doesn't fail, let
// number be the returned percentage, otherwise jump to the step
// labeled next setting (text track cue text position's value
// remains the special value auto).
if (!ScanPercentage(input, number))
break;
if (!input.IsAt(value_run.end()))
break;
// 4. Let cue's cue position be number.
text_position_ = number;
// Steps 5 - 7 skipped.
break;
}
case kSize: {
// If name is a case-sensitive match for "size"
double number;
// 1. If parse a percentage string from value doesn't fail, let
// number be the returned percentage, otherwise jump to the step
// labeled next setting.
if (!ScanPercentage(input, number))
break;
if (!input.IsAt(value_run.end()))
break;
// 2. Let cue's WebVTT cue size be number.
cue_size_ = number;
break;
}
case kAlign: {
// If name is a case-sensitive match for "align"
// 1. If value is a case-sensitive match for the string "start",
// then let cue's WebVTT cue text alignment be start alignment.
if (input.ScanRun(value_run, StartKeyword()))
cue_alignment_ = kStart;
// 2. If value is a case-sensitive match for the string "center",
// then let cue's WebVTT cue text alignment be center alignment.
else if (input.ScanRun(value_run, CenterKeyword()))
cue_alignment_ = kCenter;
// 3. If value is a case-sensitive match for the string "end", then
// let cue's WebVTT cue text alignment be end alignment.
else if (input.ScanRun(value_run, EndKeyword()))
cue_alignment_ = kEnd;
// 4. If value is a case-sensitive match for the string "left",
// then let cue's WebVTT cue text alignment be left alignment.
else if (input.ScanRun(value_run, LeftKeyword()))
cue_alignment_ = kLeft;
// 5. If value is a case-sensitive match for the string "right",
// then let cue's WebVTT cue text alignment be right alignment.
else if (input.ScanRun(value_run, RightKeyword()))
cue_alignment_ = kRight;
break;
}
case kRegionId:
if (region_map)
region_ = region_map->at(input.ExtractString(value_run));
break;
case kNone:
break;
}
// Make sure the entire run is consumed.
input.SkipRun(value_run);
}
}
void VTTCue::ApplyUserOverrideCSSProperties() {
Settings* settings = GetDocument().GetSettings();
if (!settings)
return;
SetInlineStylePropertyIfNotEmpty(*cue_background_box_,
CSSPropertyBackgroundColor,
settings->GetTextTrackBackgroundColor());
SetInlineStylePropertyIfNotEmpty(*cue_background_box_, CSSPropertyFontFamily,
settings->GetTextTrackFontFamily());
SetInlineStylePropertyIfNotEmpty(*cue_background_box_, CSSPropertyFontStyle,
settings->GetTextTrackFontStyle());
SetInlineStylePropertyIfNotEmpty(*cue_background_box_, CSSPropertyFontVariant,
settings->GetTextTrackFontVariant());
SetInlineStylePropertyIfNotEmpty(*cue_background_box_, CSSPropertyColor,
settings->GetTextTrackTextColor());
SetInlineStylePropertyIfNotEmpty(*cue_background_box_, CSSPropertyTextShadow,
settings->GetTextTrackTextShadow());
SetInlineStylePropertyIfNotEmpty(*cue_background_box_, CSSPropertyFontSize,
settings->GetTextTrackTextSize());
}
ExecutionContext* VTTCue::GetExecutionContext() const {
DCHECK(cue_background_box_);
return cue_background_box_->GetExecutionContext();
}
Document& VTTCue::GetDocument() const {
DCHECK(cue_background_box_);
return cue_background_box_->GetDocument();
}
void VTTCue::Trace(blink::Visitor* visitor) {
visitor->Trace(region_);
visitor->Trace(vtt_node_tree_);
visitor->Trace(cue_background_box_);
visitor->Trace(display_tree_);
TextTrackCue::Trace(visitor);
}
} // namespace blink