Rename public/web/WebSocket things to WebPepperSocket.

content/renderer/pepper/pepper_websocket_host.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/pepper/pepper_websocket_host.h"
 
 #include <string>
 
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "net/base/port_util.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_websocket.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/host_message_context.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebArrayBuffer.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
+#include "third_party/WebKit/public/web/WebPepperSocket.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
-#include "third_party/WebKit/public/web/WebSocket.h"
 
 using blink::WebArrayBuffer;
 using blink::WebDocument;
 using blink::WebString;
-using blink::WebSocket;
+using blink::WebPepperSocket;
 using blink::WebURL;
 
 namespace content {
 
-#define COMPILE_ASSERT_MATCHING_ENUM(webkit_name, np_name)                   \
-  static_assert(                                                             \
-      static_cast<int>(WebSocket::webkit_name) == static_cast<int>(np_name), \
-      "WebSocket enums must match PPAPI's")
+#define COMPILE_ASSERT_MATCHING_ENUM(webkit_name, np_name)        \
+  static_assert(static_cast<int>(WebPepperSocket::webkit_name) == \
+                    static_cast<int>(np_name),                    \
+                "WebSocket enums must match PPAPI's")
 
 COMPILE_ASSERT_MATCHING_ENUM(CloseEventCodeNormalClosure,
                              PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE);
 COMPILE_ASSERT_MATCHING_ENUM(CloseEventCodeGoingAway,
                              PP_WEBSOCKETSTATUSCODE_GOING_AWAY);
 COMPILE_ASSERT_MATCHING_ENUM(CloseEventCodeProtocolError,
                              PP_WEBSOCKETSTATUSCODE_PROTOCOL_ERROR);
 COMPILE_ASSERT_MATCHING_ENUM(CloseEventCodeUnsupportedData,
                              PP_WEBSOCKETSTATUSCODE_UNSUPPORTED_DATA);
 COMPILE_ASSERT_MATCHING_ENUM(CloseEventCodeNoStatusRcvd,
@@ skipping 122 matching lines @@
     connecting_ = false;
     connect_reply_.params.set_result(PP_ERROR_FAILED);
     host()->SendReply(
         connect_reply_,
         PpapiPluginMsg_WebSocket_ConnectReply(url_, std::string()));
   }
 
   // Set close_was_clean_.
   bool was_clean = (initiating_close_ || accepting_close_) &&
                    !unhandled_buffered_amount &&
-                   status == WebSocketClient::ClosingHandshakeComplete;
+                   status == WebPepperSocketClient::ClosingHandshakeComplete;
 
   if (initiating_close_) {
     initiating_close_ = false;
     close_reply_.params.set_result(PP_OK);
     host()->SendReply(
         close_reply_,
         PpapiPluginMsg_WebSocket_CloseReply(
             unhandled_buffered_amount, was_clean, code, reason.utf8()));
   } else {
     accepting_close_ = false;
@@ skipping 62 matching lines @@
   // Convert protocols to WebString.
   WebString web_protocols = WebString::fromUTF8(protocol_string);
 
   // Create blink::WebSocket object and connect.
   blink::WebPluginContainer* container =
       renderer_ppapi_host_->GetContainerForInstance(pp_instance());
   if (!container)
     return PP_ERROR_BADARGUMENT;
   // TODO(toyoshim) Remove following WebDocument object copy.
   WebDocument document = container->element().document();
-  websocket_.reset(WebSocket::create(document, this));
+  websocket_.reset(WebPepperSocket::create(document, this));
   DCHECK(websocket_.get());
   if (!websocket_)
     return PP_ERROR_NOTSUPPORTED;
 
   // Set receiving binary object type.
-  websocket_->setBinaryType(WebSocket::BinaryTypeArrayBuffer);
+  websocket_->setBinaryType(WebPepperSocket::BinaryTypeArrayBuffer);
   websocket_->connect(web_url, web_protocols);
 
   connect_reply_ = context->MakeReplyMessageContext();
   connecting_ = true;
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperWebSocketHost::OnHostMsgClose(
     ppapi::host::HostMessageContext* context,
     int32_t code,
     const std::string& reason) {
   if (!websocket_)
     return PP_ERROR_FAILED;
   close_reply_ = context->MakeReplyMessageContext();
   initiating_close_ = true;
 
-  blink::WebSocket::CloseEventCode event_code =
-      static_cast<blink::WebSocket::CloseEventCode>(code);
+  blink::WebPepperSocket::CloseEventCode event_code =
+      static_cast<blink::WebPepperSocket::CloseEventCode>(code);
   if (code == PP_WEBSOCKETSTATUSCODE_NOT_SPECIFIED) {
     // PP_WEBSOCKETSTATUSCODE_NOT_SPECIFIED and CloseEventCodeNotSpecified are
     // assigned to different values. A conversion is needed if
     // PP_WEBSOCKETSTATUSCODE_NOT_SPECIFIED is specified.
-    event_code = blink::WebSocket::CloseEventCodeNotSpecified;
+    event_code = blink::WebPepperSocket::CloseEventCodeNotSpecified;
   }
 
   WebString web_reason = WebString::fromUTF8(reason);
   websocket_->close(event_code, web_reason);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperWebSocketHost::OnHostMsgSendText(
     ppapi::host::HostMessageContext* context,
     const std::string& message) {
@@ skipping 17 matching lines @@
 
 int32_t PepperWebSocketHost::OnHostMsgFail(
     ppapi::host::HostMessageContext* context,
     const std::string& message) {
   if (websocket_)
     websocket_->fail(WebString::fromUTF8(message));
   return PP_OK;
 }
 
 }  // namespace content