Unify the three places that patch font loading for PDFium on Windows.

content/child/websocket_bridge.cc

 // Copyright 2013 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/child/websocket_bridge.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
-#include "content/child/child_thread.h"
+#include "content/child/child_thread_impl.h"
 #include "content/child/websocket_dispatcher.h"
 #include "content/common/websocket.h"
 #include "content/common/websocket_messages.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "third_party/WebKit/public/platform/WebSerializedOrigin.h"
 #include "third_party/WebKit/public/platform/WebSocketHandle.h"
 #include "third_party/WebKit/public/platform/WebSocketHandleClient.h"
 #include "third_party/WebKit/public/platform/WebSocketHandshakeRequestInfo.h"
 #include "third_party/WebKit/public/platform/WebSocketHandshakeResponseInfo.h"
@@ skipping 20 matching lines @@
 
 WebSocketBridge::WebSocketBridge()
     : channel_id_(kInvalidChannelId),
       render_frame_id_(MSG_ROUTING_NONE),
       client_(NULL) {}
 
 WebSocketBridge::~WebSocketBridge() {
   if (channel_id_ != kInvalidChannelId) {
     // The connection is abruptly disconnected by the renderer without
     // closing handshake.
-    ChildThread::current()->Send(
+    ChildThreadImpl::current()->Send(
         new WebSocketMsg_DropChannel(channel_id_,
                                      false,
                                      kAbnormalShutdownOpCode,
                                      std::string()));
   }
   Disconnect();
 }
 
 bool WebSocketBridge::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
@@ skipping 141 matching lines @@
   // |this| can be deleted here.
 }
 
 void WebSocketBridge::connect(
     const WebURL& url,
     const WebVector<WebString>& protocols,
     const WebSerializedOrigin& origin,
     WebSocketHandleClient* client) {
   DCHECK_EQ(kInvalidChannelId, channel_id_);
   WebSocketDispatcher* dispatcher =
-      ChildThread::current()->websocket_dispatcher();
+      ChildThreadImpl::current()->websocket_dispatcher();
   channel_id_ = dispatcher->AddBridge(this);
   client_ = client;
 
   std::vector<std::string> protocols_to_pass;
   for (size_t i = 0; i < protocols.size(); ++i)
     protocols_to_pass.push_back(protocols[i].utf8());
   url::Origin origin_to_pass(origin);
 
   DVLOG(1) << "Bridge#" << channel_id_ << " Connect(" << url << ", ("
            << JoinString(protocols_to_pass, ", ") << "), "
            << origin_to_pass.string() << ")";
 
-  ChildThread::current()->Send(new WebSocketHostMsg_AddChannelRequest(
+  ChildThreadImpl::current()->Send(new WebSocketHostMsg_AddChannelRequest(
       channel_id_, url, protocols_to_pass, origin_to_pass, render_frame_id_));
 }
 
 void WebSocketBridge::send(bool fin,
                            WebSocketHandle::MessageType type,
                            const char* data,
                            size_t size) {
   if (channel_id_ == kInvalidChannelId)
     return;
 
   WebSocketMessageType type_to_pass = WEB_SOCKET_MESSAGE_TYPE_CONTINUATION;
   switch (type) {
     case WebSocketHandle::MessageTypeContinuation:
       type_to_pass = WEB_SOCKET_MESSAGE_TYPE_CONTINUATION;
       break;
     case WebSocketHandle::MessageTypeText:
       type_to_pass = WEB_SOCKET_MESSAGE_TYPE_TEXT;
       break;
     case WebSocketHandle::MessageTypeBinary:
       type_to_pass = WEB_SOCKET_MESSAGE_TYPE_BINARY;
       break;
   }
 
   DVLOG(1) << "Bridge #" << channel_id_ << " Send("
            << fin << ", " << type_to_pass << ", "
            << "(data size = "  << size << "))";
 
-  ChildThread::current()->Send(
+  ChildThreadImpl::current()->Send(
       new WebSocketMsg_SendFrame(channel_id_,
                                  fin,
                                  type_to_pass,
                                  std::vector<char>(data, data + size)));
 }
 
 void WebSocketBridge::flowControl(int64_t quota) {
   if (channel_id_ == kInvalidChannelId)
     return;
 
   DVLOG(1) << "Bridge #" << channel_id_ << " FlowControl(" << quota << ")";
 
-  ChildThread::current()->Send(
+  ChildThreadImpl::current()->Send(
       new WebSocketMsg_FlowControl(channel_id_, quota));
 }
 
 void WebSocketBridge::close(unsigned short code,
                             const WebString& reason) {
   if (channel_id_ == kInvalidChannelId)
     return;
 
   std::string reason_to_pass = reason.utf8();
   DVLOG(1) << "Bridge #" << channel_id_ << " Close("
            << code << ", " << reason_to_pass << ")";
   // This method is for closing handshake and hence |was_clean| shall be true.
-  ChildThread::current()->Send(
+  ChildThreadImpl::current()->Send(
       new WebSocketMsg_DropChannel(channel_id_, true, code, reason_to_pass));
 }
 
 void WebSocketBridge::Disconnect() {
   if (channel_id_ == kInvalidChannelId)
     return;
   WebSocketDispatcher* dispatcher =
-      ChildThread::current()->websocket_dispatcher();
+      ChildThreadImpl::current()->websocket_dispatcher();
   dispatcher->RemoveBridge(channel_id_);
 
   channel_id_ = kInvalidChannelId;
   client_ = NULL;
 }
 
 }  // namespace content