Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/graphics

third_party/WebKit/Source/platform/graphics/ContiguousContainer.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/graphics/ContiguousContainer.h"
 
 #include <algorithm>
 #include <memory>
 #include "platform/wtf/Allocator.h"
 #include "platform/wtf/ContainerAnnotations.h"
@@ skipping 22 matching lines @@
     ANNOTATE_DELETE_BUFFER(begin_, capacity_, UsedCapacity());
     WTF::Partitions::BufferFree(begin_);
   }
 
   size_t Capacity() const { return capacity_; }
   size_t UsedCapacity() const { return end_ - begin_; }
   size_t UnusedCapacity() const { return Capacity() - UsedCapacity(); }
   bool IsEmpty() const { return UsedCapacity() == 0; }
 
   void* Allocate(size_t object_size) {
-    ASSERT(UnusedCapacity() >= object_size);
+    DCHECK_GE(UnusedCapacity(), object_size);
     ANNOTATE_CHANGE_SIZE(begin_, capacity_, UsedCapacity(),
                          UsedCapacity() + object_size);
     void* result = end_;
     end_ += object_size;
     return result;
   }
 
   void DeallocateLastObject(void* object) {
-    RELEASE_ASSERT(begin_ <= object && object < end_);
+    CHECK_LE(begin_, object);
+    CHECK_LT(object, end_);
     ANNOTATE_CHANGE_SIZE(begin_, capacity_, UsedCapacity(),
                          static_cast<char*>(object) - begin_);
     end_ = static_cast<char*>(object);
   }
 
  private:
   // m_begin <= m_end <= m_begin + m_capacity
   char* begin_;
   char* end_;
   size_t capacity_;
@@ skipping 35 matching lines @@
          elements_.Capacity() * sizeof(elements_[0]);
 }
 
 void ContiguousContainerBase::ReserveInitialCapacity(size_t buffer_size,
                                                      const char* type_name) {
   AllocateNewBufferForNextAllocation(buffer_size, type_name);
 }
 
 void* ContiguousContainerBase::Allocate(size_t object_size,
                                         const char* type_name) {
-  ASSERT(object_size <= max_object_size_);
+  DCHECK_LE(object_size, max_object_size_);
 
   Buffer* buffer_for_alloc = nullptr;
   if (!buffers_.IsEmpty()) {
     Buffer* end_buffer = buffers_[end_index_].get();
     if (end_buffer->UnusedCapacity() >= object_size)
       buffer_for_alloc = end_buffer;
     else if (end_index_ + 1 < buffers_.size())
       buffer_for_alloc = buffers_[++end_index_].get();
   }
 
@@ skipping 42 matching lines @@
   while (end_index_ < buffers_.size() - 1) {
     DCHECK(buffers_.back()->IsEmpty());
     buffers_.pop_back();
   }
 }
 
 ContiguousContainerBase::Buffer*
 ContiguousContainerBase::AllocateNewBufferForNextAllocation(
     size_t buffer_size,
     const char* type_name) {
-  ASSERT(buffers_.IsEmpty() || end_index_ == buffers_.size() - 1);
+  DCHECK(buffers_.IsEmpty() || end_index_ == buffers_.size() - 1);
   std::unique_ptr<Buffer> new_buffer =
       WTF::MakeUnique<Buffer>(buffer_size, type_name);
   Buffer* buffer_to_return = new_buffer.get();
   buffers_.push_back(std::move(new_buffer));
   end_index_ = buffers_.size() - 1;
   return buffer_to_return;
 }
 
 }  // namespace blink