Reland "media/track: Replace wtf/Assertions.h macros in favor of base/logging.h macros"

third_party/WebKit/Source/core/html/track/vtt/VTTCue.cpp

 /*
  * 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
@@ skipping 105 matching lines @@
 }
 
 static const String& verticalGrowingRightKeyword()
 {
     DEFINE_STATIC_LOCAL(const String, verticallr, ("lr"));
     return verticallr;
 }
 
 static bool isInvalidPercentage(double value)
 {
-    ASSERT(std::isfinite(value));
+    DCHECK(std::isfinite(value));
     return value < 0 || value > 100;
 }
 
 static bool isInvalidPercentage(double value, ExceptionState& exceptionState)
 {
     if (isInvalidPercentage(value)) {
         exceptionState.throwDOMException(IndexSizeError, ExceptionMessages::indexOutsideRange<double>("value", value, 0, ExceptionMessages::InclusiveBound, 100, ExceptionMessages::InclusiveBound));
         return true;
     }
     return false;
@@ skipping 128 matching lines @@
 const String& VTTCue::vertical() const
 {
     switch (m_writingDirection) {
     case Horizontal:
         return horizontalKeyword();
     case VerticalGrowingLeft:
         return verticalGrowingLeftKeyword();
     case VerticalGrowingRight:
         return verticalGrowingRightKeyword();
     default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return emptyString();
     }
 }
 
 void VTTCue::setVertical(const String& value)
 {
     WritingDirection direction = m_writingDirection;
     if (value == horizontalKeyword())
         direction = Horizontal;
     else if (value == verticalGrowingLeftKeyword())
         direction = VerticalGrowingLeft;
     else if (value == verticalGrowingRightKeyword())
         direction = VerticalGrowingRight;
     else
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
 
     if (direction == m_writingDirection)
         return;
 
     cueWillChange();
     m_writingDirection = direction;
     cueDidChange();
 }
 
 void VTTCue::setSnapToLines(bool value)
@@ skipping 24 matching lines @@
     // 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.)
     float floatPosition;
     if (position.isAutoKeyword()) {
         if (lineIsAuto())
             return;
         floatPosition = std::numeric_limits<float>::quiet_NaN();
     } else {
-        ASSERT(position.isDouble());
+        DCHECK(position.isDouble());
         floatPosition = narrowPrecisionToFloat(position.getAsDouble());
         if (m_linePosition == floatPosition)
             return;
     }
 
     cueWillChange();
     m_linePosition = floatPosition;
     cueDidChange();
 }
 
@@ skipping 16 matching lines @@
     // 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.
     float floatPosition;
     if (position.isAutoKeyword()) {
         if (textPositionIsAuto())
             return;
         floatPosition = std::numeric_limits<float>::quiet_NaN();
     } else {
-        ASSERT(position.isDouble());
+        DCHECK(position.isDouble());
         if (isInvalidPercentage(position.getAsDouble(), exceptionState))
             return;
         floatPosition = narrowPrecisionToFloat(position.getAsDouble());
         if (m_textPosition == floatPosition)
             return;
     }
 
     cueWillChange();
     m_textPosition = floatPosition;
     cueDidChange();
@@ skipping 24 matching lines @@
         return startKeyword();
     case Middle:
         return middleKeyword();
     case End:
         return endKeyword();
     case Left:
         return leftKeyword();
     case Right:
         return rightKeyword();
     default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return emptyString();
     }
 }
 
 void VTTCue::setAlign(const String& value)
 {
     CueAlignment alignment = m_cueAlignment;
     if (value == startKeyword())
         alignment = Start;
     else if (value == middleKeyword())
         alignment = Middle;
     else if (value == endKeyword())
         alignment = End;
     else if (value == leftKeyword())
         alignment = Left;
     else if (value == rightKeyword())
         alignment = Right;
     else
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
 
     if (alignment == m_cueAlignment)
         return;
 
     cueWillChange();
     m_cueAlignment = alignment;
     cueDidChange();
 }
 
 void VTTCue::setText(const String& text)
@@ skipping 111 matching lines @@
 {
     TextRun run(value);
     BidiResolver<VTTTextRunIterator, BidiCharacterRun> bidiResolver;
     bidiResolver.setStatus(BidiStatus(LTR, false));
     bidiResolver.setPositionIgnoringNestedIsolates(VTTTextRunIterator(&run, 0));
     return bidiResolver.determineDirectionality(&hasStrongDirectionality);
 }
 
 static CSSValueID determineTextDirection(DocumentFragment* vttRoot)
 {
-    ASSERT(vttRoot);
+    DCHECK(vttRoot);
 
     // 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 textDirection = LTR;
     Node* node = NodeTraversal::next(*vttRoot);
     while (node) {
-        ASSERT(node->isDescendantOf(vttRoot));
+        DCHECK(node->isDescendantOf(vttRoot));
 
         if (node->isTextNode()) {
             bool hasStrongDirectionality;
             textDirection = determineDirectionality(node->nodeValue(), hasStrongDirectionality);
             if (hasStrongDirectionality)
                 break;
         } else if (node->isVTTElement()) {
             if (toVTTElement(node)->webVTTNodeType() == VTTNodeTypeRubyText) {
                 node = NodeTraversal::nextSkippingChildren(*node);
                 continue;
@@ skipping 20 matching lines @@
     case Left:
         return 0;
     // 3. If the cue text alignment is end or right, return 100 and abort these steps.
     case End:
     case Right:
         return 100;
     // 4. If the cue text alignment is middle, return 50 and abort these steps.
     case Middle:
         return 50;
     default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return 0;
     }
 }
 
 VTTCue::CueAlignment VTTCue::calculateComputedCueAlignment() const
 {
     switch (m_cueAlignment) {
     case VTTCue::Left:
         return VTTCue::Start;
     case VTTCue::Right:
@@ skipping 40 matching lines @@
     float computedTextPosition = calculateComputedTextPosition();
     float maximumSize = computedTextPosition;
     if (computedCueAlignment == Start) {
         maximumSize = 100 - computedTextPosition;
     } else if (computedCueAlignment == End) {
         maximumSize = computedTextPosition;
     } else if (computedCueAlignment == Middle) {
         maximumSize = computedTextPosition <= 50 ? computedTextPosition : (100 - computedTextPosition);
         maximumSize = maximumSize * 2;
     } else {
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
 
     // 5. If the cue size is less than maximum size, then let size
     // be cue size. Otherwise, let size be maximum size.
     displayParameters.size = std::min(m_cueSize, maximumSize);
 
     // 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 (m_writingDirection == Horizontal) {
         switch (computedCueAlignment) {
         case Start:
             displayParameters.position.setX(computedTextPosition);
             break;
         case End:
             displayParameters.position.setX(computedTextPosition - displayParameters.size);
             break;
         case Middle:
             displayParameters.position.setX(computedTextPosition - displayParameters.size / 2);
             break;
         default:
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
         }
     } else {
         // Cases for m_writingDirection being VerticalGrowing{Left|Right}
         switch (computedCueAlignment) {
         case Start:
             displayParameters.position.setY(computedTextPosition);
             break;
         case End:
             displayParameters.position.setY(computedTextPosition - displayParameters.size);
             break;
         case Middle:
             displayParameters.position.setY(computedTextPosition - displayParameters.size / 2);
             break;
         default:
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
         }
     }
 
     // A cue has a computed line whose value is defined in terms of
     // the other aspects of the cue.
     float computedLinePosition = 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 (!m_snapToLines) {
         if (m_writingDirection == Horizontal)
             displayParameters.position.setY(computedLinePosition);
         else
             displayParameters.position.setX(computedLinePosition);
     } else {
         if (m_writingDirection == Horizontal)
             displayParameters.position.setY(0);
         else
             displayParameters.position.setX(0);
     }
 
     // Step 9 not implemented (margin == 0).
 
     // The snap-to-lines position is propagated to LayoutVTTCue.
     displayParameters.snapToLinesPosition = m_snapToLines
         ? computedLinePosition
         : std::numeric_limits<float>::quiet_NaN();
 
-    ASSERT(std::isfinite(displayParameters.size));
-    ASSERT(displayParameters.direction != CSSValueNone);
-    ASSERT(displayParameters.writingMode != CSSValueNone);
+    DCHECK(std::isfinite(displayParameters.size));
+    DCHECK_NE(displayParameters.direction, CSSValueNone);
+    DCHECK_NE(displayParameters.writingMode, CSSValueNone);
     return displayParameters;
 }
 
 void VTTCue::updatePastAndFutureNodes(double movieTime)
 {
     DEFINE_STATIC_LOCAL(const String, timestampTag, ("timestamp"));
 
-    ASSERT(isActive());
+    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 (!m_displayTree)
         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 isPastNode = true;
     double currentTimestamp = startTime();
     if (currentTimestamp > movieTime)
         isPastNode = false;
 
     for (Node& child : NodeTraversal::descendantsOf(*m_displayTree)) {
         if (child.nodeName() == timestampTag) {
             double currentTimestamp;
             bool check = VTTParser::collectTimeStamp(child.nodeValue(), currentTimestamp);
-            ASSERT_UNUSED(check, check);
+            DCHECK(check);

[fs, 2016/05/21 16:04:52]

Ditto.

[Srirama, 2016/05/23 05:44:34]

Done.

+            ALLOW_UNUSED_LOCAL(check);
 
             if (currentTimestamp > movieTime)
                 isPastNode = false;
         }
 
         if (child.isVTTElement()) {
             toVTTElement(child).setIsPastNode(isPastNode);
             // Make an elemenet id match a cue id for style matching purposes.
             if (!id().isEmpty())
                 toElement(child).setIdAttribute(id());
         }
     }
 }
 
 VTTCueBox* VTTCue::getDisplayTree()
 {
-    ASSERT(track() && track()->isRendered() && isActive());
+    DCHECK(track() && track()->isRendered() && isActive());
 
     if (!m_displayTree) {
         m_displayTree = VTTCueBox::create(document());
         m_displayTree->appendChild(m_cueBackgroundBox);
     }
 
-    ASSERT(m_displayTree->firstChild() == m_cueBackgroundBox);
+    DCHECK_EQ(m_displayTree->firstChild(), m_cueBackgroundBox);
 
     if (!m_displayTreeShouldChange) {
         // 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 m_displayTree;
     }
 
     createVTTNodeTree();
@@ skipping 27 matching lines @@
         if (region)
             region->willRemoveVTTCueBox(m_displayTree.get());
     }
 
     if (m_displayTree)
         m_displayTree->remove(ASSERT_NO_EXCEPTION);
 }
 
 void VTTCue::updateDisplay(HTMLDivElement& container)
 {
-    ASSERT(track() && track()->isRendered() && isActive());
+    DCHECK(track() && track()->isRendered() && isActive());
 
     UseCounter::count(document(), UseCounter::VTTCueRender);
 
     if (m_writingDirection != Horizontal)
         UseCounter::count(document(), UseCounter::VTTCueRenderVertical);
 
     if (!m_snapToLines)
         UseCounter::count(document(), UseCounter::VTTCueRenderSnapToLinesFalse);
 
     if (!lineIsAuto())
@@ skipping 255 matching lines @@
     setInlineStylePropertyIfNotEmpty(*m_cueBackgroundBox,
         CSSPropertyColor, settings->textTrackTextColor());
     setInlineStylePropertyIfNotEmpty(*m_cueBackgroundBox,
         CSSPropertyTextShadow, settings->textTrackTextShadow());
     setInlineStylePropertyIfNotEmpty(*m_cueBackgroundBox,
         CSSPropertyFontSize, settings->textTrackTextSize());
 }
 
 ExecutionContext* VTTCue::getExecutionContext() const
 {
-    ASSERT(m_cueBackgroundBox);
+    DCHECK(m_cueBackgroundBox);
     return m_cueBackgroundBox->getExecutionContext();
 }
 
 Document& VTTCue::document() const
 {
-    ASSERT(m_cueBackgroundBox);
+    DCHECK(m_cueBackgroundBox);
     return m_cueBackgroundBox->document();
 }
 
 DEFINE_TRACE(VTTCue)
 {
     visitor->trace(m_vttNodeTree);
     visitor->trace(m_cueBackgroundBox);
     visitor->trace(m_displayTree);
     TextTrackCue::trace(visitor);
 }
 
 } // namespace blink