Use DCHECK instead of ASSERT in DataConsumerHandle-related stuff

third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.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 "modules/fetch/DataConsumerHandleTestUtil.h"
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
@@ skipping 74 matching lines @@
 
 void DataConsumerHandleTestUtil::ReplayingHandle::Context::add(const Command& command)
 {
     MutexLocker locker(m_mutex);
     m_commands.append(command);
 }
 
 void DataConsumerHandleTestUtil::ReplayingHandle::Context::attachReader(WebDataConsumerHandle::Client* client)
 {
     MutexLocker locker(m_mutex);
-    ASSERT(!m_readerThread);
-    ASSERT(!m_client);
+    DCHECK(!m_readerThread);
+    DCHECK(!m_client);
     m_readerThread = Platform::current()->currentThread();
     m_client = client;
 
     if (m_client && !(isEmpty() && m_result == ShouldWait))
         notify();
 }
 
 void DataConsumerHandleTestUtil::ReplayingHandle::Context::detachReader()
 {
     MutexLocker locker(m_mutex);
-    ASSERT(m_readerThread && m_readerThread->isCurrentThread());
+    DCHECK(m_readerThread && m_readerThread->isCurrentThread());
     m_readerThread = nullptr;
     m_client = nullptr;
     if (!m_isHandleAttached)
         m_detached->signal();
 }
 
 void DataConsumerHandleTestUtil::ReplayingHandle::Context::detachHandle()
 {
     MutexLocker locker(m_mutex);
     m_isHandleAttached = false;
@@ skipping 48 matching lines @@
     , m_readerThread(nullptr)
     , m_client(nullptr)
     , m_result(ShouldWait)
     , m_isHandleAttached(true)
     , m_detached(wrapUnique(new WaitableEvent()))
 {
 }
 
 const DataConsumerHandleTestUtil::Command& DataConsumerHandleTestUtil::ReplayingHandle::Context::top()
 {
-    ASSERT(!isEmpty());
+    DCHECK(!isEmpty());
     return m_commands.first();
 }
 
 void DataConsumerHandleTestUtil::ReplayingHandle::Context::consume(size_t size)
 {
-    ASSERT(!isEmpty());
-    ASSERT(size + m_offset <= top().body().size());
+    DCHECK(!isEmpty());
+    DCHECK(size + m_offset <= top().body().size());
     bool fullyConsumed = (size + m_offset >= top().body().size());
     if (fullyConsumed) {
         m_offset = 0;
         m_commands.removeFirst();
     } else {
         m_offset += size;
     }
 }
 
 void DataConsumerHandleTestUtil::ReplayingHandle::Context::notify()
 {
     if (!m_client)
         return;
-    ASSERT(m_readerThread);
+    DCHECK(m_readerThread);
     m_readerThread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, crossThreadBind(&Context::notifyInternal, wrapPassRefPtr(this)));
 }
 
 void DataConsumerHandleTestUtil::ReplayingHandle::Context::notifyInternal()
 {
     {
         MutexLocker locker(m_mutex);
         if (!m_client || !m_readerThread->isCurrentThread()) {
             // There is no client, or a new reader is attached.
             return;
@@ skipping 43 matching lines @@
         m_data.append(buffer, size);
     }
     std::unique_ptr<HandleReadResult> result = wrapUnique(new HandleReadResult(r, m_data));
     m_data.clear();
     Platform::current()->currentThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, WTF::bind(&HandleReader::runOnFinishedReading, WTF::unretained(this), passed(std::move(result))));
     m_reader = nullptr;
 }
 
 void DataConsumerHandleTestUtil::HandleReader::runOnFinishedReading(std::unique_ptr<HandleReadResult> result)
 {
-    ASSERT(m_onFinishedReading);
+    DCHECK(m_onFinishedReading);
     std::unique_ptr<OnFinishedReading> onFinishedReading(std::move(m_onFinishedReading));
     (*onFinishedReading)(std::move(result));
 }
 
 DataConsumerHandleTestUtil::HandleTwoPhaseReader::HandleTwoPhaseReader(std::unique_ptr<WebDataConsumerHandle> handle, std::unique_ptr<OnFinishedReading> onFinishedReading)
     : m_reader(handle->obtainReader(this))
     , m_onFinishedReading(std::move(onFinishedReading))
 {
 }
 
@@ skipping 14 matching lines @@
         m_reader->endRead(readSize);
     }
     std::unique_ptr<HandleReadResult> result = wrapUnique(new HandleReadResult(r, m_data));
     m_data.clear();
     Platform::current()->currentThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, WTF::bind(&HandleTwoPhaseReader::runOnFinishedReading, WTF::unretained(this), passed(std::move(result))));
     m_reader = nullptr;
 }
 
 void DataConsumerHandleTestUtil::HandleTwoPhaseReader::runOnFinishedReading(std::unique_ptr<HandleReadResult> result)
 {
-    ASSERT(m_onFinishedReading);
+    DCHECK(m_onFinishedReading);
     std::unique_ptr<OnFinishedReading> onFinishedReading(std::move(m_onFinishedReading));
     (*onFinishedReading)(std::move(result));
 }
 
 } // namespace blink