Replace ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/wtf

third_party/WebKit/Source/platform/wtf/Deque.h

 /*
  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 91 matching lines @@
     DCHECK_NE(start_, end_);
     return *(--end());
   }
   const T& back() const {
     DCHECK_NE(start_, end_);
     return *(--end());
   }
   T TakeLast();
 
   T& at(size_t i) {
-    RELEASE_ASSERT(i < size());
+    CHECK_LT(i, size());
     size_t right = buffer_.capacity() - start_;
     return i < right ? buffer_.Buffer()[start_ + i]
                      : buffer_.Buffer()[i - right];
   }
   const T& at(size_t i) const {
-    RELEASE_ASSERT(i < size());
+    CHECK_LT(i, size());
     size_t right = buffer_.capacity() - start_;
     return i < right ? buffer_.Buffer()[start_ + i]
                      : buffer_.Buffer()[i - right];
   }
 
   T& operator[](size_t i) { return at(i); }
   const T& operator[](size_t i) const { return at(i); }
 
   template <typename U>
   void push_front(U&&);
@@ skipping 511 matching lines @@
   DCHECK_NE(index_, deque_->start_);
   DCHECK(deque_->buffer_.capacity());
   if (!index_)
     index_ = deque_->buffer_.capacity() - 1;
   else
     --index_;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline T* DequeIteratorBase<T, inlineCapacity, Allocator>::After() const {
-  RELEASE_ASSERT(index_ != deque_->end_);
+  CHECK_NE(index_, deque_->end_);
   return &deque_->buffer_.Buffer()[index_];
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline T* DequeIteratorBase<T, inlineCapacity, Allocator>::Before() const {
-  RELEASE_ASSERT(index_ != deque_->start_);
+  CHECK_NE(index_, deque_->start_);
   if (!index_)
     return &deque_->buffer_.buffer()[deque_->buffer_.capacity() - 1];
   return &deque_->buffer_.buffer()[index_ - 1];
 }
 
 // This is only called if the allocator is a HeapAllocator. It is used when
 // visiting during a tracing GC.
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename VisitorDispatcher>
 void Deque<T, inlineCapacity, Allocator>::Trace(VisitorDispatcher visitor) {
@@ skipping 29 matching lines @@
 inline void swap(Deque<T, inlineCapacity, Allocator>& a,
                  Deque<T, inlineCapacity, Allocator>& b) {
   a.Swap(b);
 }
 
 }  // namespace WTF
 
 using WTF::Deque;
 
 #endif  // WTF_Deque_h