Initial switch to Chromium-style CHECK_* and DCHECK_* macros.

src/scanner.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Features shared by parsing and pre-parsing scanners.
 
 #ifndef V8_SCANNER_H_
 #define V8_SCANNER_H_
 
 #include "src/allocation.h"
@@ skipping 372 matching lines @@
   bool literal_contains_escapes() const {
     Location location = current_.location;
     int source_length = (location.end_pos - location.beg_pos);
     if (current_.token == Token::STRING) {
       // Subtract delimiters.
       source_length -= 2;
     }
     return current_.literal_chars->length() != source_length;
   }
   bool is_literal_contextual_keyword(Vector<const char> keyword) {
-    DCHECK_NOT_NULL(current_.literal_chars);
+    DCHECK(current_.literal_chars);
     return current_.literal_chars->is_contextual_keyword(keyword);
   }
   bool is_next_contextual_keyword(Vector<const char> keyword) {
-    DCHECK_NOT_NULL(next_.literal_chars);
+    DCHECK(next_.literal_chars);
     return next_.literal_chars->is_contextual_keyword(keyword);
   }
 
   const AstRawString* CurrentSymbol(AstValueFactory* ast_value_factory);
   const AstRawString* NextSymbol(AstValueFactory* ast_value_factory);
   const AstRawString* CurrentRawSymbol(AstValueFactory* ast_value_factory);
 
   double DoubleValue();
   bool LiteralMatches(const char* data, int length, bool allow_escapes = true) {
     if (is_literal_one_byte() &&
@@ skipping 121 matching lines @@
     free_buffer->Reset();
     next_.literal_chars = free_buffer;
   }
 
   inline void StartRawLiteral() {
     raw_literal_buffer_.Reset();
     next_.raw_literal_chars = &raw_literal_buffer_;
   }
 
   INLINE(void AddLiteralChar(uc32 c)) {
-    DCHECK_NOT_NULL(next_.literal_chars);
+    DCHECK(next_.literal_chars);
     next_.literal_chars->AddChar(c);
   }
 
   INLINE(void AddRawLiteralChar(uc32 c)) {
-    DCHECK_NOT_NULL(next_.raw_literal_chars);
+    DCHECK(next_.raw_literal_chars);
     next_.raw_literal_chars->AddChar(c);
   }
 
   INLINE(void ReduceRawLiteralLength(int delta)) {
-    DCHECK_NOT_NULL(next_.raw_literal_chars);
+    DCHECK(next_.raw_literal_chars);
     next_.raw_literal_chars->ReduceLength(delta);
   }
 
   // Stops scanning of a literal and drop the collected characters,
   // e.g., due to an encountered error.
   inline void DropLiteral() {
     next_.literal_chars = NULL;
     next_.raw_literal_chars = NULL;
   }
 
@@ skipping 45 matching lines @@
   }
 
   // Returns the literal string, if any, for the current token (the
   // token last returned by Next()). The string is 0-terminated.
   // Literal strings are collected for identifiers, strings, numbers as well
   // as for template literals. For template literals we also collect the raw
   // form.
   // These functions only give the correct result if the literal was scanned
   // when a LiteralScope object is alive.
   Vector<const uint8_t> literal_one_byte_string() {
-    DCHECK_NOT_NULL(current_.literal_chars);
+    DCHECK(current_.literal_chars);
     return current_.literal_chars->one_byte_literal();
   }
   Vector<const uint16_t> literal_two_byte_string() {
-    DCHECK_NOT_NULL(current_.literal_chars);
+    DCHECK(current_.literal_chars);
     return current_.literal_chars->two_byte_literal();
   }
   bool is_literal_one_byte() {
-    DCHECK_NOT_NULL(current_.literal_chars);
+    DCHECK(current_.literal_chars);
     return current_.literal_chars->is_one_byte();
   }
   int literal_length() const {
-    DCHECK_NOT_NULL(current_.literal_chars);
+    DCHECK(current_.literal_chars);
     return current_.literal_chars->length();
   }
   // Returns the literal string for the next token (the token that
   // would be returned if Next() were called).
   Vector<const uint8_t> next_literal_one_byte_string() {
-    DCHECK_NOT_NULL(next_.literal_chars);
+    DCHECK(next_.literal_chars);
     return next_.literal_chars->one_byte_literal();
   }
   Vector<const uint16_t> next_literal_two_byte_string() {
-    DCHECK_NOT_NULL(next_.literal_chars);
+    DCHECK(next_.literal_chars);
     return next_.literal_chars->two_byte_literal();
   }
   bool is_next_literal_one_byte() {
-    DCHECK_NOT_NULL(next_.literal_chars);
+    DCHECK(next_.literal_chars);
     return next_.literal_chars->is_one_byte();
   }
   Vector<const uint8_t> raw_literal_one_byte_string() {
-    DCHECK_NOT_NULL(current_.raw_literal_chars);
+    DCHECK(current_.raw_literal_chars);
     return current_.raw_literal_chars->one_byte_literal();
   }
   Vector<const uint16_t> raw_literal_two_byte_string() {
-    DCHECK_NOT_NULL(current_.raw_literal_chars);
+    DCHECK(current_.raw_literal_chars);
     return current_.raw_literal_chars->two_byte_literal();
   }
   bool is_raw_literal_one_byte() {
-    DCHECK_NOT_NULL(current_.raw_literal_chars);
+    DCHECK(current_.raw_literal_chars);
     return current_.raw_literal_chars->is_one_byte();
   }
 
   template <bool capture_raw>
   uc32 ScanHexNumber(int expected_length);
   // Scan a number of any length but not bigger than max_value. For example, the
   // number can be 000000001, so it's very long in characters but its value is
   // small.
   template <bool capture_raw>
   uc32 ScanUnlimitedLengthHexNumber(int max_value);
@@ skipping 79 matching lines @@
   bool harmony_classes_;
   // Whether we scan TEMPLATE_SPAN and TEMPLATE_TAIL
   bool harmony_templates_;
   // Whether we allow \u{xxxxx}.
   bool harmony_unicode_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCANNER_H_