Use DCHECK instead of ASSERT in DataConsumerHandle-related stuff

third_party/WebKit/Source/modules/fetch/CompositeDataConsumerHandle.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/CompositeDataConsumerHandle.h"
 
 #include "platform/CrossThreadFunctional.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTaskRunner.h"
 #include "public/platform/WebThread.h"
@@ skipping 19 matching lines @@
 private:
     RefPtr<Context> m_context;
 };
 
 class CompositeDataConsumerHandle::Context final : public ThreadSafeRefCounted<Context> {
 public:
     using Token = unsigned;
     static PassRefPtr<Context> create(std::unique_ptr<WebDataConsumerHandle> handle) { return adoptRef(new Context(std::move(handle))); }
     ~Context()
     {
-        ASSERT(!m_readerThread);
-        ASSERT(!m_reader);
-        ASSERT(!m_client);
+        DCHECK(!m_readerThread);
+        DCHECK(!m_reader);
+        DCHECK(!m_client);
     }
     std::unique_ptr<ReaderImpl> obtainReader(Client* client)
     {
         MutexLocker locker(m_mutex);
-        ASSERT(!m_readerThread);
-        ASSERT(!m_reader);
-        ASSERT(!m_client);
+        DCHECK(!m_readerThread);
+        DCHECK(!m_reader);
+        DCHECK(!m_client);
         ++m_token;
         m_client = client;
         m_readerThread = Platform::current()->currentThread();
         m_reader = m_handle->obtainReader(m_client);
         return wrapUnique(new ReaderImpl(this));
     }
     void detachReader()
     {
         MutexLocker locker(m_mutex);
-        ASSERT(m_readerThread);
-        ASSERT(m_readerThread->isCurrentThread());
-        ASSERT(m_reader);
-        ASSERT(!m_isInTwoPhaseRead);
-        ASSERT(!m_isUpdateWaitingForEndRead);
+        DCHECK(m_readerThread);
+        DCHECK(m_readerThread->isCurrentThread());
+        DCHECK(m_reader);
+        DCHECK(!m_isInTwoPhaseRead);
+        DCHECK(!m_isUpdateWaitingForEndRead);
         ++m_token;
         m_reader = nullptr;
         m_readerThread = nullptr;
         m_client = nullptr;
     }
     void update(std::unique_ptr<WebDataConsumerHandle> handle)
     {
         MutexLocker locker(m_mutex);
         m_handle = std::move(handle);
         if (!m_readerThread) {
             // There is no reader.
             return;
         }
         ++m_token;
         updateReaderNoLock(m_token);
     }
 
     Result read(void* data, size_t size, Flags flags, size_t* readSize)
     {
-        ASSERT(m_readerThread && m_readerThread->isCurrentThread());
+        DCHECK(m_readerThread && m_readerThread->isCurrentThread());
         return m_reader->read(data, size, flags, readSize);
     }
     Result beginRead(const void** buffer, Flags flags, size_t* available)
     {
-        ASSERT(m_readerThread && m_readerThread->isCurrentThread());
-        ASSERT(!m_isInTwoPhaseRead);
+        DCHECK(m_readerThread && m_readerThread->isCurrentThread());
+        DCHECK(!m_isInTwoPhaseRead);
         Result r = m_reader->beginRead(buffer, flags, available);
         m_isInTwoPhaseRead = (r == Ok);
         return r;
     }
     Result endRead(size_t readSize)
     {
-        ASSERT(m_readerThread && m_readerThread->isCurrentThread());
-        ASSERT(m_isInTwoPhaseRead);
+        DCHECK(m_readerThread && m_readerThread->isCurrentThread());
+        DCHECK(m_isInTwoPhaseRead);
         Result r = m_reader->endRead(readSize);
         m_isInTwoPhaseRead = false;
         if (m_isUpdateWaitingForEndRead) {
             // We need this lock to access |m_handle|.
             MutexLocker locker(m_mutex);
             m_reader = nullptr;
             m_reader = m_handle->obtainReader(m_client);
             m_isUpdateWaitingForEndRead = false;
         }
         return r;
@@ skipping 13 matching lines @@
     {
         MutexLocker locker(m_mutex);
         updateReaderNoLock(token);
     }
     void updateReaderNoLock(Token token)
     {
         if (token != m_token) {
             // This request is not fresh. Ignore it.
             return;
         }
-        ASSERT(m_readerThread);
-        ASSERT(m_reader);
+        DCHECK(m_readerThread);
+        DCHECK(m_reader);
         if (m_readerThread->isCurrentThread()) {
             if (m_isInTwoPhaseRead) {
                 // We are waiting for the two-phase read completion.
                 m_isUpdateWaitingForEndRead = true;
                 return;
             }
             // Unregister the old one, then register the new one.
             m_reader = nullptr;
             m_reader = m_handle->obtainReader(m_client);
             return;
@@ skipping 36 matching lines @@
     return m_context->beginRead(buffer, flags, available);
 }
 
 Result CompositeDataConsumerHandle::ReaderImpl::endRead(size_t readSize)
 {
     return m_context->endRead(readSize);
 }
 
 CompositeDataConsumerHandle::Updater::Updater(PassRefPtr<Context> context)
     : m_context(context)
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     , m_thread(Platform::current()->currentThread())
 #endif
 {
 }
 
 CompositeDataConsumerHandle::Updater::~Updater() {}
 
 void CompositeDataConsumerHandle::Updater::update(std::unique_ptr<WebDataConsumerHandle> handle)
 {
-    ASSERT(handle);
-    ASSERT(m_thread->isCurrentThread());
+    DCHECK(handle);
+#if DCHECK_IS_ON()
+    DCHECK(m_thread->isCurrentThread());
+#endif
     m_context->update(std::move(handle));
 }
 
 CompositeDataConsumerHandle::CompositeDataConsumerHandle(std::unique_ptr<WebDataConsumerHandle> handle, Updater** updater)
     : m_context(Context::create(std::move(handle)))
 {
     *updater = new Updater(m_context);
 }
 
 CompositeDataConsumerHandle::~CompositeDataConsumerHandle() { }
 
 WebDataConsumerHandle::Reader* CompositeDataConsumerHandle::obtainReaderInternal(Client* client)
 {
     return m_context->obtainReader(client).release();
 }
 
 } // namespace blink