Replace ASSERT*() with DCHECK*() in modules/websockets

third_party/WebKit/Source/modules/websockets/DOMWebSocket.cpp

 /*
  * Copyright (C) 2011 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 60 matching lines @@
     : m_state(Active)
     , m_target(target)
     , m_resumeTimer(this, &EventQueue::resumeTimerFired) { }
 
 DOMWebSocket::EventQueue::~EventQueue() { stop(); }
 
 void DOMWebSocket::EventQueue::dispatch(Event* event)
 {
     switch (m_state) {
     case Active:
-        ASSERT(m_events.isEmpty());
-        ASSERT(m_target->getExecutionContext());
+        DCHECK(m_events.isEmpty());
+        DCHECK(m_target->getExecutionContext());
         m_target->dispatchEvent(event);
         break;
     case Suspended:
         m_events.append(event);
         break;
     case Stopped:
-        ASSERT(m_events.isEmpty());
+        DCHECK(m_events.isEmpty());
         // Do nothing.
         break;
     }
 }
 
 bool DOMWebSocket::EventQueue::isEmpty() const
 {
     return m_events.isEmpty();
 }
 
@@ skipping 27 matching lines @@
 void DOMWebSocket::EventQueue::dispatchQueuedEvents()
 {
     if (m_state != Active)
         return;
 
     HeapDeque<Member<Event>> events;
     events.swap(m_events);
     while (!events.isEmpty()) {
         if (m_state == Stopped || m_state == Suspended)
             break;
-        ASSERT(m_state == Active);
-        ASSERT(m_target->getExecutionContext());
+        DCHECK_EQ(m_state, Active);
+        DCHECK(m_target->getExecutionContext());
         m_target->dispatchEvent(events.takeFirst());
         // |this| can be stopped here.
     }
     if (m_state == Suspended) {
         while (!m_events.isEmpty())
             events.append(m_events.takeFirst());
         events.swap(m_events);
     }
 }
 
 void DOMWebSocket::EventQueue::resumeTimerFired(TimerBase*)
 {
-    ASSERT(m_state == Suspended);
+    DCHECK_EQ(m_state, Suspended);
     m_state = Active;
     dispatchQueuedEvents();
 }
 
 DEFINE_TRACE(DOMWebSocket::EventQueue)
 {
     visitor->trace(m_target);
     visitor->trace(m_events);
 }
 
@@ skipping 69 matching lines @@
     , m_binaryTypeChangesAfterOpen(0)
     , m_subprotocol("")
     , m_extensions("")
     , m_eventQueue(EventQueue::create(this))
     , m_bufferedAmountConsumeTimer(this, &DOMWebSocket::reflectBufferedAmountConsumption)
 {
 }
 
 DOMWebSocket::~DOMWebSocket()
 {
-    ASSERT(!m_channel);
+    DCHECK(!m_channel);
 }
 
 void DOMWebSocket::logError(const String& message)
 {
     if (getExecutionContext())
         getExecutionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message));
 }
 
 DOMWebSocket* DOMWebSocket::create(ExecutionContext* context, const String& url, ExceptionState& exceptionState)
 {
@@ skipping 12 matching lines @@
     webSocket->suspendIfNeeded();
 
     if (protocols.isNull()) {
         Vector<String> protocolsVector;
         webSocket->connect(url, protocolsVector, exceptionState);
     } else if (protocols.isString()) {
         Vector<String> protocolsVector;
         protocolsVector.append(protocols.getAsString());
         webSocket->connect(url, protocolsVector, exceptionState);
     } else {
-        ASSERT(protocols.isStringSequence());
+        DCHECK(protocols.isStringSequence());
         webSocket->connect(url, protocols.getAsStringSequence(), exceptionState);
     }
 
     if (exceptionState.hadException())
         return nullptr;
 
     return webSocket;
 }
 
 void DOMWebSocket::connect(const String& url, const Vector<String>& protocols, ExceptionState& exceptionState)
@@ skipping 82 matching lines @@
 
 void DOMWebSocket::updateBufferedAmountAfterClose(uint64_t payloadSize)
 {
     m_bufferedAmountAfterClose += payloadSize;
 
     logError("WebSocket is already in CLOSING or CLOSED state.");
 }
 
 void DOMWebSocket::reflectBufferedAmountConsumption(TimerBase*)
 {
-    ASSERT(m_bufferedAmount >= m_consumedBufferedAmount);
+    DCHECK_GE(m_bufferedAmount, m_consumedBufferedAmount);
     // Cast to unsigned long long is required since clang doesn't accept
     // combination of %llu and uint64_t (known as unsigned long).
     NETWORK_DVLOG(1) << "WebSocket " << this << " reflectBufferedAmountConsumption() " << m_bufferedAmount << " => " << (m_bufferedAmount - m_consumedBufferedAmount);
 
     m_bufferedAmount -= m_consumedBufferedAmount;
     m_consumedBufferedAmount = 0;
 }
 
 void DOMWebSocket::releaseChannel()
 {
-    ASSERT(m_channel);
+    DCHECK(m_channel);
     m_channel->disconnect();
     m_channel = nullptr;
 }
 
 void DOMWebSocket::logBinaryTypeChangesAfterOpen()
 {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, binaryTypeChangesHistogram, new CustomCountHistogram("WebCore.WebSocket.BinaryTypeChangesAfterOpen", 1, 1024, 10));
     DVLOG(3) << "WebSocket " << static_cast<void*>(this) << " logBinaryTypeChangesAfterOpen() logging " << m_binaryTypeChangesAfterOpen;
     binaryTypeChangesHistogram.count(m_binaryTypeChangesAfterOpen);
 }
 
 void DOMWebSocket::send(const String& message, ExceptionState& exceptionState)
 {
     CString encodedMessage = message.utf8();
 
     NETWORK_DVLOG(1) << "WebSocket " << this << " send() Sending String " << message;
     if (m_state == kConnecting) {
         setInvalidStateErrorForSendMethod(exceptionState);
         return;
     }
     // No exception is raised if the connection was once established but has subsequently been closed.
     if (m_state == kClosing || m_state == kClosed) {
         updateBufferedAmountAfterClose(encodedMessage.length());
         return;
     }
 
     recordSendTypeHistogram(WebSocketSendTypeString);
 
-    ASSERT(m_channel);
+    DCHECK(m_channel);
     m_bufferedAmount += encodedMessage.length();
     m_channel->send(encodedMessage);
 }
 
 void DOMWebSocket::send(DOMArrayBuffer* binaryData, ExceptionState& exceptionState)
 {
     NETWORK_DVLOG(1) << "WebSocket " << this << " send() Sending ArrayBuffer " << binaryData;
-    ASSERT(binaryData && binaryData->buffer());
+    DCHECK(binaryData);
+    DCHECK(binaryData->buffer());
     if (m_state == kConnecting) {
         setInvalidStateErrorForSendMethod(exceptionState);
         return;
     }
     if (m_state == kClosing || m_state == kClosed) {
         updateBufferedAmountAfterClose(binaryData->byteLength());
         return;
     }
     recordSendTypeHistogram(WebSocketSendTypeArrayBuffer);
     recordSendMessageSizeHistogram(WebSocketSendTypeArrayBuffer, binaryData->byteLength());
-    ASSERT(m_channel);
+    DCHECK(m_channel);
     m_bufferedAmount += binaryData->byteLength();
     m_channel->send(*binaryData, 0, binaryData->byteLength());
 }
 
 void DOMWebSocket::send(DOMArrayBufferView* arrayBufferView, ExceptionState& exceptionState)
 {
     NETWORK_DVLOG(1) << "WebSocket " << this << " send() Sending ArrayBufferView " << arrayBufferView;
-    ASSERT(arrayBufferView);
+    DCHECK(arrayBufferView);
     if (m_state == kConnecting) {
         setInvalidStateErrorForSendMethod(exceptionState);
         return;
     }
     if (m_state == kClosing || m_state == kClosed) {
         updateBufferedAmountAfterClose(arrayBufferView->byteLength());
         return;
     }
     recordSendTypeHistogram(WebSocketSendTypeArrayBufferView);
     recordSendMessageSizeHistogram(WebSocketSendTypeArrayBufferView, arrayBufferView->byteLength());
-    ASSERT(m_channel);
+    DCHECK(m_channel);
     m_bufferedAmount += arrayBufferView->byteLength();
     m_channel->send(*arrayBufferView->buffer(), arrayBufferView->byteOffset(), arrayBufferView->byteLength());
 }
 
 void DOMWebSocket::send(Blob* binaryData, ExceptionState& exceptionState)
 {
     NETWORK_DVLOG(1) << "WebSocket " << this << " send() Sending Blob " << binaryData->uuid();
-    ASSERT(binaryData);
+    DCHECK(binaryData);
     if (m_state == kConnecting) {
         setInvalidStateErrorForSendMethod(exceptionState);
         return;
     }
     if (m_state == kClosing || m_state == kClosed) {
         updateBufferedAmountAfterClose(binaryData->size());
         return;
     }
     unsigned long long size = binaryData->size();
     recordSendTypeHistogram(WebSocketSendTypeBlob);
     recordSendMessageSizeHistogram(WebSocketSendTypeBlob, clampTo<size_t>(size, 0, kMaxByteSizeForHistogram));
     m_bufferedAmount += size;
-    ASSERT(m_channel);
+    DCHECK(m_channel);
 
     // When the runtime type of |binaryData| is File,
     // binaryData->blobDataHandle()->size() returns -1. However, in order to
     // maintain the value of |m_bufferedAmount| correctly, the WebSocket code
     // needs to fix the size of the File at this point. For this reason,
     // construct a new BlobDataHandle here with the size that this method
     // observed.
     m_channel->send(BlobDataHandle::create(binaryData->uuid(), binaryData->type(), size));
 }
 
@@ skipping 23 matching lines @@
             exceptionState.throwDOMException(InvalidAccessError, "The code must be either 1000, or between 3000 and 4999. " + String::number(code) + " is neither.");
             return;
         }
         // Bindings specify USVString, so unpaired surrogates are already replaced with U+FFFD.
         CString utf8 = reason.utf8();
         if (utf8.length() > maxReasonSizeInBytes) {
             exceptionState.throwDOMException(SyntaxError, "The message must not be greater than " + String::number(maxReasonSizeInBytes) + " bytes.");
             return;
         }
         if (!reason.isEmpty() && !reason.is8Bit()) {
-            ASSERT(utf8.length() > 0);
+            DCHECK_GT(utf8.length(), 0u);
             // reason might contain unpaired surrogates. Reconstruct it from
             // utf8.
             cleansedReason = String::fromUTF8(utf8.data(), utf8.length());
         }
     }
 
     if (m_state == kClosing || m_state == kClosed)
         return;
     if (m_state == kConnecting) {
         m_state = kClosing;
@@ skipping 35 matching lines @@
 }
 
 String DOMWebSocket::binaryType() const
 {
     switch (m_binaryType) {
     case BinaryTypeBlob:
         return "blob";
     case BinaryTypeArrayBuffer:
         return "arraybuffer";
     }
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return String();
 }
 
 void DOMWebSocket::setBinaryType(const String& binaryType)
 {
     if (binaryType == "blob") {
         setBinaryTypeInternal(BinaryTypeBlob);
         return;
     }
     if (binaryType == "arraybuffer") {
         setBinaryTypeInternal(BinaryTypeArrayBuffer);
         return;
     }
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
 }
 
 void DOMWebSocket::setBinaryTypeInternal(BinaryType binaryType)
 {
     if (m_binaryType == binaryType)
         return;
     m_binaryType = binaryType;
     if (m_state == kOpen || m_state == kClosing)
         ++m_binaryTypeChangesAfterOpen;
 }
@@ skipping 94 matching lines @@
 void DOMWebSocket::didError()
 {
     NETWORK_DVLOG(1) << "WebSocket " << this << " didError()";
     m_state = kClosed;
     logBinaryTypeChangesAfterOpen();
     m_eventQueue->dispatch(Event::create(EventTypeNames::error));
 }
 
 void DOMWebSocket::didConsumeBufferedAmount(uint64_t consumed)
 {
-    ASSERT(m_bufferedAmount >= consumed + m_consumedBufferedAmount);
+    DCHECK_GE(m_bufferedAmount, consumed + m_consumedBufferedAmount);
     NETWORK_DVLOG(1) << "WebSocket " << this << " didConsumeBufferedAmount(" << consumed << ")";
     if (m_state == kClosed)
         return;
     m_consumedBufferedAmount += consumed;
     if (!m_bufferedAmountConsumeTimer.isActive())
         m_bufferedAmountConsumeTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void DOMWebSocket::didStartClosingHandshake()
 {
@@ skipping 79 matching lines @@
 DEFINE_TRACE(DOMWebSocket)
 {
     visitor->trace(m_channel);
     visitor->trace(m_eventQueue);
     WebSocketChannelClient::trace(visitor);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink