Rename WebKit namespace to blink

Source/modules/websockets/NewWebSocketChannelImpl.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 37 matching lines @@
 #include "public/platform/Platform.h"
 #include "public/platform/WebSocketHandle.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebVector.h"
 #include "weborigin/SecurityOrigin.h"
 #include "wtf/ArrayBuffer.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 
-using WebKit::WebSocketHandle;
+using blink::WebSocketHandle;
 
 namespace WebCore {
 
 namespace {
 
 bool isClean(int code)
 {
     return code == WebSocketChannel::CloseEventCodeNormalClosure
         || (WebSocketChannel::CloseEventCodeMinimumUserDefined <= code
         && code <= WebSocketChannel::CloseEventCodeMaximumUserDefined);
@@ skipping 40 matching lines @@
 }
 
 void NewWebSocketChannelImpl::BlobLoader::didFail(FileError::ErrorCode errorCode)
 {
     m_channel->didFailLoadingBlob(errorCode);
     // |this| is deleted here.
 }
 
 NewWebSocketChannelImpl::NewWebSocketChannelImpl(ExecutionContext* context, WebSocketChannelClient* client, const String& sourceURL, unsigned lineNumber)
     : ContextLifecycleObserver(context)
-    , m_handle(adoptPtr(WebKit::Platform::current()->createWebSocketHandle()))
+    , m_handle(adoptPtr(blink::Platform::current()->createWebSocketHandle()))
     , m_client(client)
     , m_identifier(0)
     , m_sendingQuota(0)
     , m_receivedDataSizeForFlowControl(receivedDataSizeForFlowControlHighWaterMark * 2) // initial quota
     , m_bufferedAmount(0)
     , m_sentSizeOfTopMessage(0)
     , m_sourceURLAtConnection(sourceURL)
     , m_lineNumberAtConnection(lineNumber)
 {
     if (context->isDocument() && toDocument(context)->page())
@@ skipping 12 matching lines @@
         return;
     m_url = url;
     Vector<String> protocols;
     // Avoid placing an empty token in the Vector when the protocol string is
     // empty.
     if (!protocol.isEmpty()) {
         // Since protocol is already verified and escaped, we can simply split
         // it.
         protocol.split(", ", true, protocols);
     }
-    WebKit::WebVector<WebKit::WebString> webProtocols(protocols.size());
+    blink::WebVector<blink::WebString> webProtocols(protocols.size());
     for (size_t i = 0; i < protocols.size(); ++i) {
         webProtocols[i] = protocols[i];
     }
     String origin = executionContext()->securityOrigin()->toString();
     m_handle->connect(url, webProtocols, origin, this);
     flowControlIfNecessary();
     if (m_identifier)
         InspectorInstrumentation::didCreateWebSocket(document(), m_identifier, url, protocol);
     RefPtr<ScriptCallStack> callStack = createScriptCallStack(1, true);
     if (callStack && callStack->size()) {
@@ skipping 201 matching lines @@
 }
 
 Document* NewWebSocketChannelImpl::document()
 {
     ASSERT(m_identifier);
     ExecutionContext* context = executionContext();
     ASSERT(context->isDocument());
     return toDocument(context);
 }
 
-void NewWebSocketChannelImpl::didConnect(WebSocketHandle* handle, bool fail, const WebKit::WebString& selectedProtocol, const WebKit::WebString& extensions)
+void NewWebSocketChannelImpl::didConnect(WebSocketHandle* handle, bool fail, const blink::WebString& selectedProtocol, const blink::WebString& extensions)
 {
     LOG(Network, "NewWebSocketChannelImpl %p didConnect(%p, %d, %s, %s)", this, handle, fail, selectedProtocol.utf8().data(), extensions.utf8().data());
     ASSERT(m_handle);
     ASSERT(handle == m_handle);
     ASSERT(m_client);
     if (fail) {
         failAsError("Cannot connect to " + m_url.string() + ".");
         // failAsError may delete this object.
         return;
     }
     // FIXME: We should have Request / Response information to be output.
     // InspectorInstrumentation::willSendWebSocketHandshakeRequest(document(), m_identifier, "");
     // InspectorInstrumentation::didReceiveWebSocketHandshakeResponse(document(), m_identifier, "");
 
     m_subprotocol = selectedProtocol;
     m_extensions = extensions;
     m_client->didConnect();
 }
 
-void NewWebSocketChannelImpl::didFail(WebSocketHandle* handle, const WebKit::WebString& message)
+void NewWebSocketChannelImpl::didFail(WebSocketHandle* handle, const blink::WebString& message)
 {
     LOG(Network, "NewWebSocketChannelImpl %p didFail(%p, %s)", this, handle, message.utf8().data());
     // FIXME: Hande the failure correctly.
     // CloseEventCodeAbnormalClosure is the closing code for the closure
     // without sending or receiving a Close control frame.
-    didClose(handle, false, CloseEventCodeAbnormalClosure, WebKit::WebString());
+    didClose(handle, false, CloseEventCodeAbnormalClosure, blink::WebString());
     // |this| may be deleted.
 }
 
 void NewWebSocketChannelImpl::didReceiveData(WebSocketHandle* handle, bool fin, WebSocketHandle::MessageType type, const char* data, size_t size)
 {
     LOG(Network, "NewWebSocketChannelImpl %p didReceiveData(%p, %d, %d, (%p, %zu))", this, handle, fin, type, data, size);
     ASSERT(m_handle);
     ASSERT(handle == m_handle);
     ASSERT(m_client);
     // Non-final frames cannot be empty.
@@ skipping 34 matching lines @@
         } else {
             m_client->didReceiveMessage(message);
         }
     } else {
         OwnPtr<Vector<char> > binaryData = adoptPtr(new Vector<char>);
         binaryData->swap(m_receivingMessageData);
         m_client->didReceiveBinaryData(binaryData.release());
     }
 }
 
-void NewWebSocketChannelImpl::didClose(WebSocketHandle* handle, bool wasClean, unsigned short code, const WebKit::WebString& reason)
+void NewWebSocketChannelImpl::didClose(WebSocketHandle* handle, bool wasClean, unsigned short code, const blink::WebString& reason)
 {
     // FIXME: Use |wasClean| appropriately.
     LOG(Network, "NewWebSocketChannelImpl %p didClose(%p, %d, %u, %s)", this, handle, wasClean, code, String(reason).utf8().data());
     ASSERT(m_handle);
     m_handle.clear();
     if (m_identifier) {
         InspectorInstrumentation::didCloseWebSocket(document(), m_identifier);
         m_identifier = 0;
     }
 
@@ skipping 27 matching lines @@
     if (errorCode == FileError::ABORT_ERR) {
         // The error is caused by cancel().
         return;
     }
     // FIXME: Generate human-friendly reason message.
     failAsError("Failed to load Blob: error code = " + String::number(errorCode));
     // |this| can be deleted here.
 }
 
 } // namespace WebCore