Add WebSocket unittests.

Source/modules/websockets/WebSocket.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 43 matching lines @@
 #include "wtf/ArrayBuffer.h"
 #include "wtf/ArrayBufferView.h"
 #include "wtf/Assertions.h"
 #include "wtf/HashSet.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 
-using namespace std;
-
 namespace WebCore {
 
 WebSocket::EventQueue::EventQueue(EventTarget* target)
     : m_state(Active)
     , m_target(target)
     , m_resumeTimer(this, &EventQueue::resumeTimerFired) { }
 
 WebSocket::EventQueue::~EventQueue() { stop(); }
 
 void WebSocket::EventQueue::dispatch(PassRefPtrWillBeRawPtr<Event> event)
@@ skipping 89 matching lines @@
     const UChar maximumProtocolCharacter = '~'; // U+007E.
     // Set to true if character does not matches "separators" ABNF defined in
     // RFC2616. SP and HT are excluded since the range check excludes them.
     bool isNotSeparator = character != '"' && character != '(' && character != ')' && character != ',' && character != '/'
         && !(character >= ':' && character <= '@') // U+003A - U+0040 (':', ';', '<', '=', '>', '?', '@').
         && !(character >= '[' && character <= ']') // U+005B - U+005D ('[', '\\', ']').
         && character != '{' && character != '}';
     return character >= minimumProtocolCharacter && character <= maximumProtocolCharacter && isNotSeparator;
 }
 
-static bool isValidSubprotocolString(const String& protocol)
+bool WebSocket::isValidSubprotocolString(const String& protocol)
 {
     if (protocol.isEmpty())
         return false;
     for (size_t i = 0; i < protocol.length(); ++i) {
         if (!isValidSubprotocolCharacter(protocol[i]))
             return false;
     }
     return true;
 }
 
@@ skipping 17 matching lines @@
     for (size_t i = 0; i < strings.size(); ++i) {
         if (i)
             builder.append(separator);
         builder.append(strings[i]);
     }
     return builder.toString();
 }
 
 static unsigned long saturateAdd(unsigned long a, unsigned long b)
 {
-    if (numeric_limits<unsigned long>::max() - a < b)
-        return numeric_limits<unsigned long>::max();
+    if (std::numeric_limits<unsigned long>::max() - a < b)
+        return std::numeric_limits<unsigned long>::max();
     return a + b;
 }
 
 static void setInvalidStateErrorForSendMethod(ExceptionState& exceptionState)
 {
     exceptionState.throwDOMException(InvalidStateError, "Still in CONNECTING state.");
 }
 
-const char* WebSocket::subProtocolSeperator()
+const char* WebSocket::subprotocolSeperator()
 {
     return ", ";
 }
 
 WebSocket::WebSocket(ExecutionContext* context)
     : ActiveDOMObject(context)
     , m_state(CONNECTING)
     , m_bufferedAmount(0)
     , m_bufferedAmountAfterClose(0)
     , m_binaryType(BinaryTypeBlob)
@@ skipping 77 matching lines @@
         Document* document = toDocument(executionContext());
         shouldBypassMainWorldContentSecurityPolicy = document->frame()->script().shouldBypassMainWorldContentSecurityPolicy();
     }
     if (!shouldBypassMainWorldContentSecurityPolicy && !executionContext()->contentSecurityPolicy()->allowConnectToSource(m_url)) {
         m_state = CLOSED;
         // 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;
     }
 
-    m_channel = WebSocketChannel::create(executionContext(), this);
+    m_channel = createChannel(executionContext(), this);
 
     for (size_t i = 0; i < protocols.size(); ++i) {
         if (!isValidSubprotocolString(protocols[i])) {
             m_state = CLOSED;
             exceptionState.throwDOMException(SyntaxError, "The subprotocol '" + encodeSubprotocolString(protocols[i]) + "' is invalid.");
             releaseChannel();
             return;
         }
     }
     HashSet<String> visited;
     for (size_t i = 0; i < protocols.size(); ++i) {
         if (!visited.add(protocols[i]).isNewEntry) {
             m_state = CLOSED;
             exceptionState.throwDOMException(SyntaxError, "The subprotocol '" + encodeSubprotocolString(protocols[i]) + "' is duplicated.");
             releaseChannel();
             return;
         }
     }
 
     String protocolString;
     if (!protocols.isEmpty())
-        protocolString = joinStrings(protocols, subProtocolSeperator());
+        protocolString = joinStrings(protocols, subprotocolSeperator());
 
     if (!m_channel->connect(m_url, protocolString)) {
         m_state = CLOSED;
         exceptionState.throwSecurityError("An insecure WebSocket connection may not be initiated from a page loaded over HTTPS.");
         releaseChannel();
         return;
     }
 }
 
 void WebSocket::handleSendResult(WebSocketChannel::SendResult result, ExceptionState& exceptionState, WebSocketSendType dataType)
@@ skipping 329 matching lines @@
 }
 
 void WebSocket::trace(Visitor* visitor)
 {
     visitor->trace(m_channel);
     visitor->trace(m_eventQueue);
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace WebCore