Rename WebKit namespace to blink

Source/core/dom/MessagePortChannel.cpp

 /*
  * Copyright (C) 2009 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 21 matching lines @@
 #include "core/dom/MessagePortChannel.h"
 
 #include "core/dom/MessagePort.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebMessagePortChannel.h"
 #include "public/platform/WebString.h"
 #include "wtf/PassRefPtr.h"
 
 namespace WebCore {
 
-PassOwnPtr<MessagePortChannel> MessagePortChannel::create(WebKit::WebMessagePortChannel* channel)
+PassOwnPtr<MessagePortChannel> MessagePortChannel::create(blink::WebMessagePortChannel* channel)
 {
     return adoptPtr(new MessagePortChannel(channel));
 }
 
 void MessagePortChannel::createChannel(MessagePort* port1, MessagePort* port2)
 {
     // Create proxies for each endpoint.
-    OwnPtr<MessagePortChannel> channel1 = create(WebKit::Platform::current()->createMessagePortChannel());
-    OwnPtr<MessagePortChannel> channel2 = create(WebKit::Platform::current()->createMessagePortChannel());
+    OwnPtr<MessagePortChannel> channel1 = create(blink::Platform::current()->createMessagePortChannel());
+    OwnPtr<MessagePortChannel> channel2 = create(blink::Platform::current()->createMessagePortChannel());
 
     // Entangle the two endpoints.
     channel1->m_webChannel->entangle(channel2->m_webChannel);
     channel2->m_webChannel->entangle(channel1->m_webChannel);
 
     // Now entangle the proxies with the appropriate local ports.
     port1->entangle(channel2.release());
     port2->entangle(channel1.release());
 }
 
-MessagePortChannel::MessagePortChannel(WebKit::WebMessagePortChannel* channel)
+MessagePortChannel::MessagePortChannel(blink::WebMessagePortChannel* channel)
     : m_localPort(0)
     , m_webChannel(channel)
 {
     ASSERT(m_webChannel);
     m_webChannel->setClient(this);
 }
 
 MessagePortChannel::~MessagePortChannel()
 {
     if (m_webChannel)
@@ skipping 10 matching lines @@
 {
     MutexLocker lock(m_mutex);
     m_localPort = 0;
 }
 
 void MessagePortChannel::postMessageToRemote(PassRefPtr<SerializedScriptValue> message, PassOwnPtr<MessagePortChannelArray> channels)
 {
     if (!m_localPort || !m_webChannel)
         return;
 
-    WebKit::WebString messageString = message->toWireString();
-    WebKit::WebMessagePortChannelArray* webChannels = 0;
+    blink::WebString messageString = message->toWireString();
+    blink::WebMessagePortChannelArray* webChannels = 0;
     if (channels && channels->size()) {
-        webChannels = new WebKit::WebMessagePortChannelArray(channels->size());
+        webChannels = new blink::WebMessagePortChannelArray(channels->size());
         for (size_t i = 0; i < channels->size(); ++i)
             (*webChannels)[i] = (*channels)[i]->webChannelRelease();
     }
     m_webChannel->postMessage(messageString, webChannels);
 }
 
 bool MessagePortChannel::tryGetMessageFromRemote(RefPtr<SerializedScriptValue>& serializedMessage, OwnPtr<MessagePortChannelArray>& channels)
 {
     if (!m_webChannel)
         return false;
 
-    WebKit::WebString message;
-    WebKit::WebMessagePortChannelArray webChannels;
+    blink::WebString message;
+    blink::WebMessagePortChannelArray webChannels;
     bool rv = m_webChannel->tryGetMessage(&message, webChannels);
     if (rv) {
         if (webChannels.size()) {
             channels = adoptPtr(new MessagePortChannelArray(webChannels.size()));
             for (size_t i = 0; i < webChannels.size(); ++i)
                 (*channels)[i] = MessagePortChannel::create(webChannels[i]);
         }
         serializedMessage = SerializedScriptValue::createFromWire(message);
     }
 
@@ skipping 14 matching lines @@
     return m_localPort;
 }
 
 void MessagePortChannel::messageAvailable()
 {
     MutexLocker lock(m_mutex);
     if (m_localPort)
         m_localPort->messageAvailable();
 }
 
-WebKit::WebMessagePortChannel* MessagePortChannel::webChannelRelease()
+blink::WebMessagePortChannel* MessagePortChannel::webChannelRelease()
 {
     ASSERT(m_webChannel);
-    WebKit::WebMessagePortChannel* webChannel = m_webChannel;
+    blink::WebMessagePortChannel* webChannel = m_webChannel;
     m_webChannel = 0;
     webChannel->setClient(0);
     return webChannel;
 }
 
 } // namespace WebCore