Rename Blink constants generated from IDL files.

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 204 matching lines @@
 }
 
 const char* DOMWebSocket::subprotocolSeperator()
 {
     return ", ";
 }
 
 DOMWebSocket::DOMWebSocket(ExecutionContext* context)
     : ActiveScriptWrappable(this)
     , ActiveDOMObject(context)
-    , m_state(CONNECTING)
+    , m_state(kConnecting)
     , m_bufferedAmount(0)
     , m_consumedBufferedAmount(0)
     , m_bufferedAmountAfterClose(0)
     , m_binaryType(BinaryTypeBlob)
     , m_subprotocol("")
     , m_extensions("")
     , m_eventQueue(EventQueue::create(this))
     , m_bufferedAmountConsumeTimer(this, &DOMWebSocket::reflectBufferedAmountConsumption)
 {
 }
@@ skipping 50 matching lines @@
     m_url = KURL(KURL(), url);
 
     if (getExecutionContext()->securityContext().getInsecureRequestPolicy() & kUpgradeInsecureRequests && m_url.protocol() == "ws") {
         UseCounter::count(getExecutionContext(), UseCounter::UpgradeInsecureRequestsUpgradedRequest);
         m_url.setProtocol("wss");
         if (m_url.port() == 80)
             m_url.setPort(443);
     }
 
     if (!m_url.isValid()) {
-        m_state = CLOSED;
+        m_state = kClosed;
         exceptionState.throwDOMException(SyntaxError, "The URL '" + url + "' is invalid.");
         return;
     }
     if (!m_url.protocolIs("ws") && !m_url.protocolIs("wss")) {
-        m_state = CLOSED;
+        m_state = kClosed;
         exceptionState.throwDOMException(SyntaxError, "The URL's scheme must be either 'ws' or 'wss'. '" + m_url.protocol() + "' is not allowed.");
         return;
     }
 
     if (m_url.hasFragmentIdentifier()) {
-        m_state = CLOSED;
+        m_state = kClosed;
         exceptionState.throwDOMException(SyntaxError, "The URL contains a fragment identifier ('" + m_url.fragmentIdentifier() + "'). Fragment identifiers are not allowed in WebSocket URLs.");
         return;
     }
 
     if (!isPortAllowedForScheme(m_url)) {
-        m_state = CLOSED;
+        m_state = kClosed;
         exceptionState.throwSecurityError("The port " + String::number(m_url.port()) + " is not allowed.");
         return;
     }
 
     // FIXME: Convert this to check the isolated world's Content Security Policy once webkit.org/b/104520 is solved.
     if (!ContentSecurityPolicy::shouldBypassMainWorld(getExecutionContext()) && !getExecutionContext()->contentSecurityPolicy()->allowConnectToSource(m_url)) {
-        m_state = CLOSED;
+        m_state = kClosed;
         // The URL is safe to expose to JavaScript, as this check happens synchronously before redirection.
         exceptionState.throwSecurityError("Refused to connect to '" + m_url.elidedString() + "' because it violates the document's Content Security Policy.");
         return;
     }
 
     // Fail if not all elements in |protocols| are valid.
     for (size_t i = 0; i < protocols.size(); ++i) {
         if (!isValidSubprotocolString(protocols[i])) {
-            m_state = CLOSED;
+            m_state = kClosed;
             exceptionState.throwDOMException(SyntaxError, "The subprotocol '" + encodeSubprotocolString(protocols[i]) + "' is invalid.");
             return;
         }
     }
 
     // Fail if there're duplicated elements in |protocols|.
     HashSet<String> visited;
     for (size_t i = 0; i < protocols.size(); ++i) {
         if (!visited.add(protocols[i]).isNewEntry) {
-            m_state = CLOSED;
+            m_state = kClosed;
             exceptionState.throwDOMException(SyntaxError, "The subprotocol '" + encodeSubprotocolString(protocols[i]) + "' is duplicated.");
             return;
         }
     }
 
     String protocolString;
     if (!protocols.isEmpty())
         protocolString = joinStrings(protocols, subprotocolSeperator());
 
     m_channel = createChannel(getExecutionContext(), this);
 
     if (!m_channel->connect(m_url, protocolString)) {
-        m_state = CLOSED;
+        m_state = kClosed;
         exceptionState.throwSecurityError("An insecure WebSocket connection may not be initiated from a page loaded over HTTPS.");
         releaseChannel();
         return;
     }
 }
 
 void DOMWebSocket::updateBufferedAmountAfterClose(uint64_t payloadSize)
 {
     m_bufferedAmountAfterClose += payloadSize;
 
@@ skipping 16 matching lines @@
     ASSERT(m_channel);
     m_channel->disconnect();
     m_channel = nullptr;
 }
 
 void DOMWebSocket::send(const String& message, ExceptionState& exceptionState)
 {
     CString encodedMessage = message.utf8();
 
     WTF_LOG(Network, "WebSocket %p send() Sending String '%s'", this, encodedMessage.data());
-    if (m_state == CONNECTING) {
+    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 == CLOSING || m_state == CLOSED) {
+    if (m_state == kClosing || m_state == kClosed) {
         updateBufferedAmountAfterClose(encodedMessage.length());
         return;
     }
 
     recordSendTypeHistogram(WebSocketSendTypeString);
 
     ASSERT(m_channel);
     m_bufferedAmount += encodedMessage.length();
     m_channel->send(encodedMessage);
 }
 
 void DOMWebSocket::send(DOMArrayBuffer* binaryData, ExceptionState& exceptionState)
 {
     WTF_LOG(Network, "WebSocket %p send() Sending ArrayBuffer %p", this, binaryData);
     ASSERT(binaryData && binaryData->buffer());
-    if (m_state == CONNECTING) {
+    if (m_state == kConnecting) {
         setInvalidStateErrorForSendMethod(exceptionState);
         return;
     }
-    if (m_state == CLOSING || m_state == CLOSED) {
+    if (m_state == kClosing || m_state == kClosed) {
         updateBufferedAmountAfterClose(binaryData->byteLength());
         return;
     }
     recordSendTypeHistogram(WebSocketSendTypeArrayBuffer);
 
     ASSERT(m_channel);
     m_bufferedAmount += binaryData->byteLength();
     m_channel->send(*binaryData, 0, binaryData->byteLength());
 }
 
 void DOMWebSocket::send(DOMArrayBufferView* arrayBufferView, ExceptionState& exceptionState)
 {
     WTF_LOG(Network, "WebSocket %p send() Sending ArrayBufferView %p", this, arrayBufferView);
     ASSERT(arrayBufferView);
-    if (m_state == CONNECTING) {
+    if (m_state == kConnecting) {
         setInvalidStateErrorForSendMethod(exceptionState);
         return;
     }
-    if (m_state == CLOSING || m_state == CLOSED) {
+    if (m_state == kClosing || m_state == kClosed) {
         updateBufferedAmountAfterClose(arrayBufferView->byteLength());
         return;
     }
     recordSendTypeHistogram(WebSocketSendTypeArrayBufferView);
 
     ASSERT(m_channel);
     m_bufferedAmount += arrayBufferView->byteLength();
     m_channel->send(*arrayBufferView->buffer(), arrayBufferView->byteOffset(), arrayBufferView->byteLength());
 }
 
 void DOMWebSocket::send(Blob* binaryData, ExceptionState& exceptionState)
 {
     WTF_LOG(Network, "WebSocket %p send() Sending Blob '%s'", this, binaryData->uuid().utf8().data());
     ASSERT(binaryData);
-    if (m_state == CONNECTING) {
+    if (m_state == kConnecting) {
         setInvalidStateErrorForSendMethod(exceptionState);
         return;
     }
-    if (m_state == CLOSING || m_state == CLOSED) {
+    if (m_state == kClosing || m_state == kClosed) {
         updateBufferedAmountAfterClose(binaryData->size());
         return;
     }
     recordSendTypeHistogram(WebSocketSendTypeBlob);
 
     unsigned long long size = binaryData->size();
     m_bufferedAmount += size;
     ASSERT(m_channel);
 
     // When the runtime type of |binaryData| is File,
@@ skipping 38 matching lines @@
             return;
         }
         if (!reason.isEmpty() && !reason.is8Bit()) {
             ASSERT(utf8.length() > 0);
             // reason might contain unpaired surrogates. Reconstruct it from
             // utf8.
             cleansedReason = String::fromUTF8(utf8.data(), utf8.length());
         }
     }
 
-    if (m_state == CLOSING || m_state == CLOSED)
+    if (m_state == kClosing || m_state == kClosed)
         return;
-    if (m_state == CONNECTING) {
-        m_state = CLOSING;
+    if (m_state == kConnecting) {
+        m_state = kClosing;
         m_channel->fail("WebSocket is closed before the connection is established.", WarningMessageLevel, SourceLocation::create(String(), 0, 0, nullptr));
         return;
     }
-    m_state = CLOSING;
+    m_state = kClosing;
     if (m_channel)
         m_channel->close(code, cleansedReason);
 }
 
 const KURL& DOMWebSocket::url() const
 {
     return m_url;
 }
 
 DOMWebSocket::State DOMWebSocket::readyState() const
@@ skipping 51 matching lines @@
 }
 
 ExecutionContext* DOMWebSocket::getExecutionContext() const
 {
     return ActiveDOMObject::getExecutionContext();
 }
 
 void DOMWebSocket::contextDestroyed()
 {
     WTF_LOG(Network, "WebSocket %p contextDestroyed()", this);
-    ASSERT(!m_channel);
-    ASSERT(m_state == CLOSED);
+    DCHECK(!m_channel);
+    DCHECK_EQ(kClosed, m_state);
     ActiveDOMObject::contextDestroyed();
 }
 
 bool DOMWebSocket::hasPendingActivity() const
 {
     return m_channel || !m_eventQueue->isEmpty();
 }
 
 void DOMWebSocket::suspend()
 {
     m_eventQueue->suspend();
 }
 
 void DOMWebSocket::resume()
 {
     m_eventQueue->resume();
 }
 
 void DOMWebSocket::stop()
 {
     m_eventQueue->stop();
     if (m_channel) {
         m_channel->close(WebSocketChannel::CloseEventCodeGoingAway, String());
         releaseChannel();
     }
-    m_state = CLOSED;
+    m_state = kClosed;
 }
 
 void DOMWebSocket::didConnect(const String& subprotocol, const String& extensions)
 {
     WTF_LOG(Network, "WebSocket %p didConnect()", this);
-    if (m_state != CONNECTING)
+    if (m_state != kConnecting)
         return;
-    m_state = OPEN;
+    m_state = kOpen;
     m_subprotocol = subprotocol;
     m_extensions = extensions;
     m_eventQueue->dispatch(Event::create(EventTypeNames::open));
 }
 
 void DOMWebSocket::didReceiveTextMessage(const String& msg)
 {
     WTF_LOG(Network, "WebSocket %p didReceiveTextMessage() Text message '%s'", this, msg.utf8().data());
-    if (m_state != OPEN)
+    if (m_state != kOpen)
         return;
     recordReceiveTypeHistogram(WebSocketReceiveTypeString);
 
     m_eventQueue->dispatch(MessageEvent::create(msg, SecurityOrigin::create(m_url)->toString()));
 }
 
 void DOMWebSocket::didReceiveBinaryMessage(std::unique_ptr<Vector<char>> binaryData)
 {
     WTF_LOG(Network, "WebSocket %p didReceiveBinaryMessage() %lu byte binary message", this, static_cast<unsigned long>(binaryData->size()));
     switch (m_binaryType) {
@@ skipping 13 matching lines @@
         DOMArrayBuffer* arrayBuffer = DOMArrayBuffer::create(binaryData->data(), binaryData->size());
         recordReceiveTypeHistogram(WebSocketReceiveTypeArrayBuffer);
         m_eventQueue->dispatch(MessageEvent::create(arrayBuffer, SecurityOrigin::create(m_url)->toString()));
         break;
     }
 }
 
 void DOMWebSocket::didError()
 {
     WTF_LOG(Network, "WebSocket %p didError()", this);
-    m_state = CLOSED;
+    m_state = kClosed;
     m_eventQueue->dispatch(Event::create(EventTypeNames::error));
 }
 
 void DOMWebSocket::didConsumeBufferedAmount(uint64_t consumed)
 {
     ASSERT(m_bufferedAmount >= consumed + m_consumedBufferedAmount);
     // Cast to unsigned long long is required since clang doesn't accept
     // combination of %llu and uint64_t (known as unsigned long).
     WTF_LOG(Network, "WebSocket %p didConsumeBufferedAmount(%llu)", this, static_cast<unsigned long long>(consumed));
-    if (m_state == CLOSED)
+    if (m_state == kClosed)
         return;
     m_consumedBufferedAmount += consumed;
     if (!m_bufferedAmountConsumeTimer.isActive())
         m_bufferedAmountConsumeTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void DOMWebSocket::didStartClosingHandshake()
 {
     WTF_LOG(Network, "WebSocket %p didStartClosingHandshake()", this);
-    m_state = CLOSING;
+    m_state = kClosing;
 }
 
 void DOMWebSocket::didClose(ClosingHandshakeCompletionStatus closingHandshakeCompletion, unsigned short code, const String& reason)
 {
     WTF_LOG(Network, "WebSocket %p didClose()", this);
     if (!m_channel)
         return;
     bool allDataHasBeenConsumed = m_bufferedAmount == m_consumedBufferedAmount;
-    bool wasClean = m_state == CLOSING && allDataHasBeenConsumed && closingHandshakeCompletion == ClosingHandshakeComplete && code != WebSocketChannel::CloseEventCodeAbnormalClosure;
-    m_state = CLOSED;
+    bool wasClean = m_state == kClosing && allDataHasBeenConsumed && closingHandshakeCompletion == ClosingHandshakeComplete && code != WebSocketChannel::CloseEventCodeAbnormalClosure;
+    m_state = kClosed;
 
     m_eventQueue->dispatch(CloseEvent::create(wasClean, code, reason));
     releaseChannel();
 }
 
 void DOMWebSocket::recordSendTypeHistogram(WebSocketSendType type)
 {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(EnumerationHistogram, sendTypeHistogram, new EnumerationHistogram("WebCore.WebSocket.SendType", WebSocketSendTypeMax));
     sendTypeHistogram.count(type);
 }
 
 void DOMWebSocket::recordReceiveTypeHistogram(WebSocketReceiveType type)
 {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(EnumerationHistogram, receiveTypeHistogram, new EnumerationHistogram("WebCore.WebSocket.ReceiveType", WebSocketReceiveTypeMax));
     receiveTypeHistogram.count(type);
 }
 
 DEFINE_TRACE(DOMWebSocket)
 {
     visitor->trace(m_channel);
     visitor->trace(m_eventQueue);
     WebSocketChannelClient::trace(visitor);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink