Modify MainThreadWebSocketChannel to use enumeration for denotating its current state

Source/modules/websockets/MainThreadWebSocketChannel.cpp

 /*
  * Copyright (C) 2011, 2012 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 58 matching lines @@
 
 namespace WebCore {
 
 const double TCPMaximumSegmentLifetime = 2 * 60.0;
 
 MainThreadWebSocketChannel::MainThreadWebSocketChannel(Document* document, WebSocketChannelClient* client, const String& sourceURL, unsigned lineNumber)
     : m_document(document)
     , m_client(client)
     , m_resumeTimer(this, &MainThreadWebSocketChannel::resumeTimerFired)
     , m_suspended(false)
-    , m_closing(false)
     , m_didFailOfClientAlreadyRun(false)
     , m_receivedClosingHandshake(false)
     , m_closingTimer(this, &MainThreadWebSocketChannel::closingTimerFired)
-    , m_closed(false)
+    , m_state(ChannelIdle)
     , m_shouldDiscardReceivedData(false)
     , m_unhandledBufferedAmount(0)
     , m_identifier(0)
     , m_hasContinuousFrame(false)
     , m_closeEventCode(CloseEventCodeAbnormalClosure)
     , m_outgoingFrameQueueStatus(OutgoingFrameQueueOpen)
     , m_blobLoaderStatus(BlobLoaderNotStarted)
     , m_sourceURLAtConnection(sourceURL)
     , m_lineNumberAtConnection(lineNumber)
 {
@@ skipping 96 matching lines @@
     return m_handle->bufferedAmount();
 }
 
 void MainThreadWebSocketChannel::close(int code, const String& reason)
 {
     LOG(Network, "MainThreadWebSocketChannel %p close() code=%d reason='%s'", this, code, reason.utf8().data());
     ASSERT(!m_suspended);
     if (!m_handle)
         return;
     startClosingHandshake(code, reason);
-    if (m_closing && !m_closingTimer.isActive())
+    if ((m_state == ChannelClosing || m_state == ChannelClosed) && !m_closingTimer.isActive())
         m_closingTimer.startOneShot(2 * TCPMaximumSegmentLifetime);
 }
 
 void MainThreadWebSocketChannel::fail(const String& reason, MessageLevel level, const String& sourceURL, unsigned lineNumber)
 {
     LOG(Network, "MainThreadWebSocketChannel %p fail() reason='%s'", this, reason.utf8().data());
     ASSERT(!m_suspended);
     if (m_document) {
         InspectorInstrumentation::didReceiveWebSocketFrameError(m_document, m_identifier, reason);
         const String message = "WebSocket connection to '" + m_handshake->url().elidedString() + "' failed: " + reason;
         static_cast<ScriptExecutionContext*>(m_document)->addConsoleMessage(JSMessageSource, level, message, sourceURL, lineNumber);
     }
     // Hybi-10 specification explicitly states we must not continue to handle incoming data
     // once the WebSocket connection is failed (section 7.1.7).
     RefPtr<MainThreadWebSocketChannel> protect(this); // The client can close the channel, potentially removing the last reference.
     m_shouldDiscardReceivedData = true;
     if (!m_buffer.isEmpty())
         skipBuffer(m_buffer.size()); // Save memory.
     m_deflateFramer.didFail();
     m_perMessageDeflate.didFail();
     m_hasContinuousFrame = false;
     m_continuousFrameData.clear();
     if (!m_didFailOfClientAlreadyRun) {
         m_didFailOfClientAlreadyRun = true;
         if (m_client)
             m_client->didReceiveMessageError();
     }
-    if (m_handle && !m_closed)
+    if (m_handle && (m_state != ChannelClosed))
         m_handle->disconnect(); // Will call didCloseSocketStream().
 }
 
 void MainThreadWebSocketChannel::disconnect()
 {
     LOG(Network, "MainThreadWebSocketChannel %p disconnect()", this);
     if (m_identifier && m_document)
         InspectorInstrumentation::didCloseWebSocket(m_document, m_identifier);
     if (m_handshake)
         m_handshake->clearScriptExecutionContext();
     m_client = 0;
     m_document = 0;
     if (m_handle)
         m_handle->disconnect();
 }
 
 void MainThreadWebSocketChannel::suspend()
 {
     m_suspended = true;
 }
 
 void MainThreadWebSocketChannel::resume()
 {
     m_suspended = false;
-    if ((!m_buffer.isEmpty() || m_closed) && m_client && !m_resumeTimer.isActive())
+    if ((!m_buffer.isEmpty() || (m_state == ChannelClosed)) && m_client && !m_resumeTimer.isActive())
         m_resumeTimer.startOneShot(0);
 }
 
 void MainThreadWebSocketChannel::willOpenSocketStream(SocketStreamHandle* handle)
 {
     LOG(Network, "MainThreadWebSocketChannel %p willOpenSocketStream()", this);
     ASSERT(handle);
     if (m_document->frame())
         m_document->frame()->loader()->client()->dispatchWillOpenSocketStream(handle);
 }
@@ skipping 10 matching lines @@
     if (!handle->send(handshakeMessage.data(), handshakeMessage.length()))
         failAsError("Failed to send WebSocket handshake.");
 }
 
 void MainThreadWebSocketChannel::didCloseSocketStream(SocketStreamHandle* handle)
 {
     LOG(Network, "MainThreadWebSocketChannel %p didCloseSocketStream()", this);
     if (m_identifier && m_document)
         InspectorInstrumentation::didCloseWebSocket(m_document, m_identifier);
     ASSERT_UNUSED(handle, handle == m_handle || !m_handle);
-    m_closed = true;
+    m_state = ChannelClosed;
     if (m_closingTimer.isActive())
         m_closingTimer.stop();
     if (m_outgoingFrameQueueStatus != OutgoingFrameQueueClosed)
         abortOutgoingFrameQueue();
     if (m_handle) {
         m_unhandledBufferedAmount = m_handle->bufferedAmount();
         if (m_suspended)
             return;
         WebSocketChannelClient* client = m_client;
         m_client = 0;
@@ skipping 50 matching lines @@
     else if (error.localizedDescription().isNull())
         message = "WebSocket network error: error code " + String::number(error.errorCode());
     else
         message = "WebSocket network error: error code " + String::number(error.errorCode()) + ", " + error.localizedDescription();
     String failingURL = error.failingURL();
     ASSERT(failingURL.isNull() || m_handshake->url().string() == failingURL);
     if (failingURL.isNull())
         failingURL = m_handshake->url().string();
     LOG(Network, "Error Message: '%s', FailURL: '%s'", message.utf8().data(), failingURL.utf8().data());
     RefPtr<WebSocketChannel> protect(this);
-    if (m_client && !m_closing && !m_didFailOfClientAlreadyRun) {
+    if (m_client && (m_state != ChannelClosing && m_state != ChannelClosed) && !m_didFailOfClientAlreadyRun) {
         m_didFailOfClientAlreadyRun = true;
         m_client->didReceiveMessageError();
     }
-    if (m_handle && !m_closed)
+    if (m_handle && (m_state != ChannelClosed))
         m_handle->disconnect();
 }
 
 void MainThreadWebSocketChannel::didStartLoading()
 {
     LOG(Network, "MainThreadWebSocketChannel %p didStartLoading()", this);
     ASSERT(m_blobLoader);
     ASSERT(m_blobLoaderStatus == BlobLoaderStarted);
 }
 
@@ skipping 94 matching lines @@
 }
 
 void MainThreadWebSocketChannel::resumeTimerFired(Timer<MainThreadWebSocketChannel>* timer)
 {
     ASSERT_UNUSED(timer, timer == &m_resumeTimer);
 
     RefPtr<MainThreadWebSocketChannel> protect(this); // The client can close the channel, potentially removing the last reference.
     while (!m_suspended && m_client && !m_buffer.isEmpty())
         if (!processBuffer())
             break;
-    if (!m_suspended && m_client && m_closed && m_handle)
+    if (!m_suspended && m_client && (m_state == ChannelClosed) && m_handle)
         didCloseSocketStream(m_handle.get());
 }
 
 void MainThreadWebSocketChannel::startClosingHandshake(int code, const String& reason)
 {
-    LOG(Network, "MainThreadWebSocketChannel %p startClosingHandshake() code=%d m_receivedClosingHandshake=%d", this, m_closing, m_receivedClosingHandshake);
-    if (m_closing)
+    LOG(Network, "MainThreadWebSocketChannel %p startClosingHandshake() code=%d m_receivedClosingHandshake=%d", this, (m_state == ChannelClosing), m_receivedClosingHandshake);
+    if (m_state == ChannelClosing || m_state == ChannelClosed)
         return;
     ASSERT(m_handle);
 
     Vector<char> buf;
     if (!m_receivedClosingHandshake && code != CloseEventCodeNotSpecified) {
         unsigned char highByte = code >> 8;
         unsigned char lowByte = code;
         buf.append(static_cast<char>(highByte));
         buf.append(static_cast<char>(lowByte));
         buf.append(reason.utf8().data(), reason.utf8().length());
     }
     enqueueRawFrame(WebSocketFrame::OpCodeClose, buf.data(), buf.size());
     processOutgoingFrameQueue();
 
-    m_closing = true;
+    m_state = ChannelClosing;
     if (m_client)
         m_client->didStartClosingHandshake();
 }
 
 void MainThreadWebSocketChannel::closingTimerFired(Timer<MainThreadWebSocketChannel>* timer)
 {
     LOG(Network, "MainThreadWebSocketChannel %p closingTimerFired()", this);
     ASSERT_UNUSED(timer, &m_closingTimer == timer);
     if (m_handle)
         m_handle->disconnect();
@@ skipping 152 matching lines @@
                 return false;
             }
         }
         if (frame.payloadLength >= 3)
             m_closeEventReason = String::fromUTF8(&frame.payload[2], frame.payloadLength - 2);
         else
             m_closeEventReason = "";
         skipBuffer(frameEnd - m_buffer.data());
         m_receivedClosingHandshake = true;
         startClosingHandshake(m_closeEventCode, m_closeEventReason);
-        if (m_closing) {
+        if (m_state == ChannelClosing || m_state == ChannelClosed) {
             m_outgoingFrameQueueStatus = OutgoingFrameQueueClosing;
             processOutgoingFrameQueue();
         }
         break;
 
     case WebSocketFrame::OpCodePing:
         enqueueRawFrame(WebSocketFrame::OpCodePong, frame.payload, frame.payloadLength);
         skipBuffer(frameEnd - m_buffer.data());
         processOutgoingFrameQueue();
         break;
@@ skipping 136 matching lines @@
     }
 
     Vector<char> frameData;
     frame.makeFrameData(frameData);
 
     m_perMessageDeflate.resetDeflateBuffer();
     return m_handle->send(frameData.data(), frameData.size());
 }
 
 } // namespace WebCore