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

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

 /*
  * Copyright (C) 2011 Google Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 22 matching lines @@
 #include "core/xml/parser/MarkupTokenizerInlines.h"
 #include "wtf/text/CharacterNames.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 #define WEBVTT_BEGIN_STATE(stateName) case stateName: stateName:
 #define WEBVTT_ADVANCE_TO(stateName)                               \
     do {                                                           \
         state = stateName;                                         \
-        ASSERT(!m_input.isEmpty());                                \
+        DCHECK(!m_input.isEmpty());                                \
         m_inputStreamPreprocessor.advance(m_input);                \
         cc = m_inputStreamPreprocessor.nextInputCharacter();       \
         goto stateName;                                            \
     } while (false)
 
 template<unsigned charactersCount>
 ALWAYS_INLINE bool equalLiteral(const StringBuilder& s, const char (&characters)[charactersCount])
 {
     return WTF::equal(s, reinterpret_cast<const LChar*>(characters), charactersCount - 1);
 }
@@ skipping 15 matching lines @@
 {
     source.advanceAndUpdateLineNumber();
     return emitToken(resultToken, token);
 }
 
 VTTTokenizer::VTTTokenizer(const String& input)
     : m_input(input)
     , m_inputStreamPreprocessor(this)
 {
     // Append a EOF marker and close the input "stream".
-    ASSERT(!m_input.isClosed());
+    DCHECK(!m_input.isClosed());
     m_input.append(SegmentedString(String(&kEndOfFileMarker, 1)));
     m_input.close();
 }
 
 bool VTTTokenizer::nextToken(VTTToken& token)
 {
     if (m_input.isEmpty() || !m_inputStreamPreprocessor.peek(m_input))
         return false;
 
     UChar cc = m_inputStreamPreprocessor.nextInputCharacter();
@@ skipping 77 matching lines @@
                     WEBVTT_ADVANCE_TO(EscapeState);
                 }
                 result.append(cc);
                 WEBVTT_ADVANCE_TO(DataState);
             }
         }
         END_STATE()
 
         WEBVTT_BEGIN_STATE(TagState) {
             if (isTokenizerWhitespace(cc)) {
-                ASSERT(result.isEmpty());
+                DCHECK(result.isEmpty());
                 WEBVTT_ADVANCE_TO(StartTagAnnotationState);
             } else if (cc == '.') {
-                ASSERT(result.isEmpty());
+                DCHECK(result.isEmpty());
                 WEBVTT_ADVANCE_TO(StartTagClassState);
             } else if (cc == '/') {
                 WEBVTT_ADVANCE_TO(EndTagState);
             } else if (WTF::isASCIIDigit(cc)) {
                 result.append(cc);
                 WEBVTT_ADVANCE_TO(TimestampTagState);
             } else if (cc == '>' || cc == kEndOfFileMarker) {
-                ASSERT(result.isEmpty());
+                DCHECK(result.isEmpty());
                 return advanceAndEmitToken(m_input, token, VTTToken::StartTag(result.toString()));
             } else {
                 result.append(cc);
                 WEBVTT_ADVANCE_TO(StartTagState);
             }
         }
         END_STATE()
 
         WEBVTT_BEGIN_STATE(StartTagState) {
             if (isTokenizerWhitespace(cc)) {
@@ skipping 49 matching lines @@
         WEBVTT_BEGIN_STATE(TimestampTagState) {
             if (cc == '>' || cc == kEndOfFileMarker)
                 return advanceAndEmitToken(m_input, token, VTTToken::TimestampTag(result.toString()));
             result.append(cc);
             WEBVTT_ADVANCE_TO(TimestampTagState);
         }
         END_STATE()
 
     }
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return false;
 }
 
 } // namespace blink