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

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

 /*
  * Copyright (C) 2013 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 125 matching lines @@
     , m_identifier(createUniqueIdentifier())
     , m_sendingQuota(0)
     , m_receivedDataSizeForFlowControl(receivedDataSizeForFlowControlHighWaterMark * 2) // initial quota
     , m_sentSizeOfTopMessage(0)
     , m_locationAtConstruction(std::move(location))
 {
 }
 
 DocumentWebSocketChannel::~DocumentWebSocketChannel()
 {
-    ASSERT(!m_blobLoader);
+    DCHECK(!m_blobLoader);
 }
 
 bool DocumentWebSocketChannel::connect(const KURL& url, const String& protocol)
 {
     NETWORK_DVLOG(1) << this << " connect()";
     if (!m_handle)
         return false;
 
     if (document()->frame()) {
         if (MixedContentChecker::shouldBlockWebSocket(document()->frame(), url))
@@ skipping 83 matching lines @@
     // FIXME: Change the inspector API to show the entire message instead
     // of individual frames.
     InspectorInstrumentation::didSendWebSocketFrame(document(), m_identifier, WebSocketFrame::OpCodeBinary, true, data->data(), data->size());
     m_messages.append(new Message(std::move(data), MessageTypeBinaryAsCharVector));
     processSendQueue();
 }
 
 void DocumentWebSocketChannel::close(int code, const String& reason)
 {
     NETWORK_DVLOG(1) << this << " close(" << code << ", " << reason << ")";
-    ASSERT(m_handle);
+    DCHECK(m_handle);
     unsigned short codeToSend = static_cast<unsigned short>(code == CloseEventCodeNotSpecified ? CloseEventCodeNoStatusRcvd : code);
     m_messages.append(new Message(codeToSend, reason));
     processSendQueue();
 }
 
 void DocumentWebSocketChannel::fail(const String& reason, MessageLevel level, std::unique_ptr<SourceLocation> location)
 {
     NETWORK_DVLOG(1) << this << " fail(" << reason << ")";
     // m_handle and m_client can be null here.
 
@@ skipping 31 matching lines @@
     , blobDataHandle(blobDataHandle) { }
 
 DocumentWebSocketChannel::Message::Message(DOMArrayBuffer* arrayBuffer)
     : type(MessageTypeArrayBuffer)
     , arrayBuffer(arrayBuffer) { }
 
 DocumentWebSocketChannel::Message::Message(std::unique_ptr<Vector<char>> vectorData, MessageType type)
     : type(type)
     , vectorData(std::move(vectorData))
 {
-    ASSERT(type == MessageTypeTextAsCharVector || type == MessageTypeBinaryAsCharVector);
+    DCHECK(type == MessageTypeTextAsCharVector || type == MessageTypeBinaryAsCharVector);
 }
 
 DocumentWebSocketChannel::Message::Message(unsigned short code, const String& reason)
     : type(MessageTypeClose)
     , code(code)
     , reason(reason) { }
 
 void DocumentWebSocketChannel::sendInternal(WebSocketHandle::MessageType messageType, const char* data, size_t totalSize, uint64_t* consumedBufferedAmount)
 {
     WebSocketHandle::MessageType frameType =
         m_sentSizeOfTopMessage ? WebSocketHandle::MessageTypeContinuation : messageType;
-    ASSERT(totalSize >= m_sentSizeOfTopMessage);
+    DCHECK_GE(totalSize, m_sentSizeOfTopMessage);
     // The first cast is safe since the result of min() never exceeds
     // the range of size_t. The second cast is necessary to compile
     // min() on ILP32.
     size_t size = static_cast<size_t>(std::min(m_sendingQuota, static_cast<uint64_t>(totalSize - m_sentSizeOfTopMessage)));
     bool final = (m_sentSizeOfTopMessage + size == totalSize);
 
     m_handle->send(final, frameType, data + m_sentSizeOfTopMessage, size);
 
     m_sentSizeOfTopMessage += size;
     m_sendingQuota -= size;
     *consumedBufferedAmount += size;
 
     if (final) {
         m_messages.removeFirst();
         m_sentSizeOfTopMessage = 0;
     }
 }
 
 void DocumentWebSocketChannel::processSendQueue()
 {
-    ASSERT(m_handle);
+    DCHECK(m_handle);
     uint64_t consumedBufferedAmount = 0;
     while (!m_messages.isEmpty() && !m_blobLoader) {
         Message* message = m_messages.first().get();
         if (m_sendingQuota == 0 && message->type != MessageTypeClose)
             break;
         switch (message->type) {
         case MessageTypeText:
             sendInternal(WebSocketHandle::MessageTypeText, message->text.data(), message->text.length(), &consumedBufferedAmount);
             break;
         case MessageTypeBlob:
-            ASSERT(!m_blobLoader);
+            DCHECK(!m_blobLoader);
             m_blobLoader = new BlobLoader(message->blobDataHandle, this);
             break;
         case MessageTypeArrayBuffer:
             sendInternal(WebSocketHandle::MessageTypeBinary, static_cast<const char*>(message->arrayBuffer->data()), message->arrayBuffer->byteLength(), &consumedBufferedAmount);
             break;
         case MessageTypeTextAsCharVector:
             sendInternal(WebSocketHandle::MessageTypeText, message->vectorData->data(), message->vectorData->size(), &consumedBufferedAmount);
             break;
         case MessageTypeBinaryAsCharVector:
             sendInternal(WebSocketHandle::MessageTypeBinary, message->vectorData->data(), message->vectorData->size(), &consumedBufferedAmount);
             break;
         case MessageTypeClose: {
             // No message should be sent from now on.
-            ASSERT(m_messages.size() == 1);
-            ASSERT(m_sentSizeOfTopMessage == 0);
+            DCHECK_EQ(m_messages.size(), 1u);
+            DCHECK_EQ(m_sentSizeOfTopMessage, 0u);
             m_handle->close(message->code, message->reason);
             m_messages.removeFirst();
             break;
         }
         }
     }
     if (m_client && consumedBufferedAmount > 0)
         m_client->didConsumeBufferedAmount(consumedBufferedAmount);
 }
 
@@ skipping 26 matching lines @@
     WebSocketChannelClient::ClosingHandshakeCompletionStatus status =
         wasClean ? WebSocketChannelClient::ClosingHandshakeComplete : WebSocketChannelClient::ClosingHandshakeIncomplete;
     client->didClose(status, code, reason);
     // client->didClose may delete this object.
 }
 
 Document* DocumentWebSocketChannel::document()
 {
     // This context is always a Document. See the constructor.
     ExecutionContext* context = getExecutionContext();
-    ASSERT(context->isDocument());
+    DCHECK(context->isDocument());
     return toDocument(context);
 }
 
 void DocumentWebSocketChannel::didConnect(WebSocketHandle* handle, const String& selectedProtocol, const String& extensions)
 {
     NETWORK_DVLOG(1) << this << " didConnect(" << handle << ", " << String(selectedProtocol) << ", " << String(extensions) << ")";
 
-    ASSERT(m_handle);
-    ASSERT(handle == m_handle.get());
-    ASSERT(m_client);
+    DCHECK(m_handle);
+    DCHECK_EQ(handle, m_handle.get());
+    DCHECK(m_client);
 
     m_client->didConnect(selectedProtocol, extensions);
 }
 
 void DocumentWebSocketChannel::didStartOpeningHandshake(WebSocketHandle* handle, PassRefPtr<WebSocketHandshakeRequest> request)
 {
     NETWORK_DVLOG(1) << this << " didStartOpeningHandshake(" << handle << ")";
 
-    ASSERT(m_handle);
-    ASSERT(handle == m_handle.get());
+    DCHECK(m_handle);
+    DCHECK_EQ(handle, m_handle.get());
 
     TRACE_EVENT_INSTANT1("devtools.timeline", "WebSocketSendHandshakeRequest", TRACE_EVENT_SCOPE_THREAD, "data", InspectorWebSocketEvent::data(document(), m_identifier));
     InspectorInstrumentation::willSendWebSocketHandshakeRequest(document(), m_identifier, request.get());
     m_handshakeRequest = request;
 }
 
 void DocumentWebSocketChannel::didFinishOpeningHandshake(WebSocketHandle* handle, const WebSocketHandshakeResponse* response)
 {
     NETWORK_DVLOG(1) << this << " didFinishOpeningHandshake(" << handle << ")";
 
-    ASSERT(m_handle);
-    ASSERT(handle == m_handle.get());
+    DCHECK(m_handle);
+    DCHECK_EQ(handle, m_handle.get());
 
     TRACE_EVENT_INSTANT1("devtools.timeline", "WebSocketReceiveHandshakeResponse", TRACE_EVENT_SCOPE_THREAD, "data", InspectorWebSocketEvent::data(document(), m_identifier));
     InspectorInstrumentation::didReceiveWebSocketHandshakeResponse(document(), m_identifier, m_handshakeRequest.get(), response);
     m_handshakeRequest.clear();
 }
 
 void DocumentWebSocketChannel::didFail(WebSocketHandle* handle, const String& message)
 {
     NETWORK_DVLOG(1) << this << " didFail(" << handle << ", " << String(message) << ")";
 
-    ASSERT(m_handle);
-    ASSERT(handle == m_handle.get());
+    DCHECK(m_handle);
+    DCHECK_EQ(handle, m_handle.get());
 
     // This function is called when the browser is required to fail the
     // WebSocketConnection. Hence we fail this channel by calling
     // |this->failAsError| function.
     failAsError(message);
     // |this| may be deleted.
 }
 
 void DocumentWebSocketChannel::didReceiveData(WebSocketHandle* handle, bool fin, WebSocketHandle::MessageType type, const char* data, size_t size)
 {
     NETWORK_DVLOG(1) << this << " didReceiveData(" << handle << ", " << fin << ", " << type << ", (" << static_cast<const void*>(data) << ", " << size << "))";
 
-    ASSERT(m_handle);
-    ASSERT(handle == m_handle.get());
-    ASSERT(m_client);
+    DCHECK(m_handle);
+    DCHECK_EQ(handle, m_handle.get());
+    DCHECK(m_client);
     // Non-final frames cannot be empty.
-    ASSERT(fin || size);
+    DCHECK(fin || size);
 
     switch (type) {
     case WebSocketHandle::MessageTypeText:
-        ASSERT(m_receivingMessageData.isEmpty());
+        DCHECK(m_receivingMessageData.isEmpty());
         m_receivingMessageTypeIsText = true;
         break;
     case WebSocketHandle::MessageTypeBinary:
-        ASSERT(m_receivingMessageData.isEmpty());
+        DCHECK(m_receivingMessageData.isEmpty());
         m_receivingMessageTypeIsText = false;
         break;
     case WebSocketHandle::MessageTypeContinuation:
-        ASSERT(!m_receivingMessageData.isEmpty());
+        DCHECK(!m_receivingMessageData.isEmpty());
         break;
     }
 
     m_receivingMessageData.append(data, size);
     m_receivedDataSizeForFlowControl += size;
     flowControlIfNecessary();
     if (!fin) {
         return;
     }
     // FIXME: Change the inspector API to show the entire message instead
@@ skipping 14 matching lines @@
         std::unique_ptr<Vector<char>> binaryData = wrapUnique(new Vector<char>);
         binaryData->swap(m_receivingMessageData);
         m_client->didReceiveBinaryMessage(std::move(binaryData));
     }
 }
 
 void DocumentWebSocketChannel::didClose(WebSocketHandle* handle, bool wasClean, unsigned short code, const String& reason)
 {
     NETWORK_DVLOG(1) << this << " didClose(" << handle << ", " << wasClean << ", " << code << ", " << String(reason) << ")";
 
-    ASSERT(m_handle);
-    ASSERT(handle == m_handle.get());
+    DCHECK(m_handle);
+    DCHECK_EQ(handle, m_handle.get());
 
     m_handle.reset();
 
     if (m_identifier) {
         TRACE_EVENT_INSTANT1("devtools.timeline", "WebSocketDestroy", TRACE_EVENT_SCOPE_THREAD, "data", InspectorWebSocketEvent::data(document(), m_identifier));
         InspectorInstrumentation::didCloseWebSocket(document(), m_identifier);
         m_identifier = 0;
     }
 
     handleDidClose(wasClean, code, reason);
     // handleDidClose may delete this object.
 }
 
 void DocumentWebSocketChannel::didReceiveFlowControl(WebSocketHandle* handle, int64_t quota)
 {
     NETWORK_DVLOG(1) << this << " didReceiveFlowControl(" << handle << ", " << quota << ")";
 
-    ASSERT(m_handle);
-    ASSERT(handle == m_handle.get());
-    ASSERT(quota >= 0);
+    DCHECK(m_handle);
+    DCHECK_EQ(handle, m_handle.get());
+    DCHECK_GE(quota, 0);
 
     m_sendingQuota += quota;
     processSendQueue();
 }
 
 void DocumentWebSocketChannel::didStartClosingHandshake(WebSocketHandle* handle)
 {
     NETWORK_DVLOG(1) << this << " didStartClosingHandshake(" << handle << ")";
 
-    ASSERT(m_handle);
-    ASSERT(handle == m_handle.get());
+    DCHECK(m_handle);
+    DCHECK_EQ(handle, m_handle.get());
 
     if (m_client)
         m_client->didStartClosingHandshake();
 }
 
 void DocumentWebSocketChannel::didFinishLoadingBlob(DOMArrayBuffer* buffer)
 {
     m_blobLoader.clear();
-    ASSERT(m_handle);
+    DCHECK(m_handle);
     // The loaded blob is always placed on m_messages[0].
-    ASSERT(m_messages.size() > 0 && m_messages.first()->type == MessageTypeBlob);
+    DCHECK_GT(m_messages.size(), 0u);
+    DCHECK_EQ(m_messages.first()->type, MessageTypeBlob);
     // We replace it with the loaded blob.
     m_messages.first() = new Message(buffer);
     processSendQueue();
 }
 
 void DocumentWebSocketChannel::didFailLoadingBlob(FileError::ErrorCode errorCode)
 {
     m_blobLoader.clear();
     if (errorCode == FileError::kAbortErr) {
         // The error is caused by cancel().
@@ skipping 12 matching lines @@
     WebSocketChannel::trace(visitor);
     ContextLifecycleObserver::trace(visitor);
 }
 
 std::ostream& operator<<(std::ostream& ostream, const DocumentWebSocketChannel* channel)
 {
     return ostream << "DocumentWebSocketChannel " << static_cast<const void*>(channel);
 }
 
 } // namespace blink