Rename ASSERT* to DCHECK*.

src/string-search.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.
 
 #ifndef V8_STRING_SEARCH_H_
 #define V8_STRING_SEARCH_H_
 
 namespace v8 {
 namespace internal {
 
@@ skipping 66 matching lines @@
 
   int Search(Vector<const SubjectChar> subject, int index) {
     return strategy_(this, subject, index);
   }
 
   static inline int AlphabetSize() {
     if (sizeof(PatternChar) == 1) {
       // ASCII needle.
       return kAsciiAlphabetSize;
     } else {
-      ASSERT(sizeof(PatternChar) == 2);
+      DCHECK(sizeof(PatternChar) == 2);
       // UC16 needle.
       return kUC16AlphabetSize;
     }
   }
 
  private:
   typedef int (*SearchFunction)(  // NOLINT - it's not a cast!
       StringSearch<PatternChar, SubjectChar>*,
       Vector<const SubjectChar>,
       int);
@@ skipping 91 matching lines @@
 
 //---------------------------------------------------------------------
 // Single Character Pattern Search Strategy
 //---------------------------------------------------------------------
 
 template <typename PatternChar, typename SubjectChar>
 int StringSearch<PatternChar, SubjectChar>::SingleCharSearch(
     StringSearch<PatternChar, SubjectChar>* search,
     Vector<const SubjectChar> subject,
     int index) {
-  ASSERT_EQ(1, search->pattern_.length());
+  DCHECK_EQ(1, search->pattern_.length());
   PatternChar pattern_first_char = search->pattern_[0];
   int i = index;
   if (sizeof(SubjectChar) == 1 && sizeof(PatternChar) == 1) {
     const SubjectChar* pos = reinterpret_cast<const SubjectChar*>(
         memchr(subject.start() + i,
                pattern_first_char,
                subject.length() - i));
     if (pos == NULL) return -1;
     return static_cast<int>(pos - subject.start());
   } else {
@@ skipping 13 matching lines @@
 
 //---------------------------------------------------------------------
 // Linear Search Strategy
 //---------------------------------------------------------------------
 
 
 template <typename PatternChar, typename SubjectChar>
 inline bool CharCompare(const PatternChar* pattern,
                         const SubjectChar* subject,
                         int length) {
-  ASSERT(length > 0);
+  DCHECK(length > 0);
   int pos = 0;
   do {
     if (pattern[pos] != subject[pos]) {
       return false;
     }
     pos++;
   } while (pos < length);
   return true;
 }
 
 
 // Simple linear search for short patterns. Never bails out.
 template <typename PatternChar, typename SubjectChar>
 int StringSearch<PatternChar, SubjectChar>::LinearSearch(
     StringSearch<PatternChar, SubjectChar>* search,
     Vector<const SubjectChar> subject,
     int index) {
   Vector<const PatternChar> pattern = search->pattern_;
-  ASSERT(pattern.length() > 1);
+  DCHECK(pattern.length() > 1);
   int pattern_length = pattern.length();
   PatternChar pattern_first_char = pattern[0];
   int i = index;
   int n = subject.length() - pattern_length;
   while (i <= n) {
     if (sizeof(SubjectChar) == 1 && sizeof(PatternChar) == 1) {
       const SubjectChar* pos = reinterpret_cast<const SubjectChar*>(
           memchr(subject.start() + i,
                  pattern_first_char,
                  n - i + 1));
@@ skipping 285 matching lines @@
                  Vector<const SubjectChar> subject,
                  Vector<const PatternChar> pattern,
                  int start_index) {
   StringSearch<PatternChar, SubjectChar> search(isolate, pattern);
   return search.Search(subject, start_index);
 }
 
 }}  // namespace v8::internal
 
 #endif  // V8_STRING_SEARCH_H_