src/content/child/socket_stream_dispatcher.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/child/socket_stream_dispatcher.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/id_map.h"
  12 #include "base/lazy_instance.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/message_loop/message_loop.h"
  15 #include "base/strings/string16.h"
  16 #include "base/strings/utf_string_conversions.h"
  17 #include "content/child/child_thread.h"
  18 #include "content/child/web_socket_stream_handle_bridge.h"
  19 #include "content/child/web_socket_stream_handle_delegate.h"
  20 #include "content/child/web_socket_stream_handle_impl.h"
  21 #include "content/common/socket_stream.h"
  22 #include "content/common/socket_stream_handle_data.h"
  23 #include "content/common/socket_stream_messages.h"
  24 #include "net/base/net_errors.h"
  25 #include "url/gurl.h"
  26
  27 namespace content {
  28
  29 // IPCWebSocketStreamHandleBridge is owned by each SocketStreamHandle.
  30 // It communicates with the main browser process via SocketStreamDispatcher.
  31 class IPCWebSocketStreamHandleBridge : public WebSocketStreamHandleBridge {
  32  public:
  33   IPCWebSocketStreamHandleBridge(blink::WebSocketStreamHandle* handle,
  34                                  WebSocketStreamHandleDelegate* delegate)
  35       : socket_id_(kNoSocketId), handle_(handle), delegate_(delegate) {}
  36
  37   // Returns the handle having given id or NULL if there is no such handle.
  38   static IPCWebSocketStreamHandleBridge* FromSocketId(int id);
  39
  40   // WebSocketStreamHandleBridge methods.
  41   virtual void Connect(const GURL& url) OVERRIDE;
  42   virtual bool Send(const std::vector<char>& data) OVERRIDE;
  43   virtual void Close() OVERRIDE;
  44
  45   // Called by SocketStreamDispatcher.
  46   void OnConnected(int max_amount_send_allowed);
  47   void OnSentData(int amount_sent);
  48   void OnReceivedData(const std::vector<char>& data);
  49   void OnClosed();
  50   void OnFailed(int error_code, const std::string& error_msg);
  51
  52  private:
  53   virtual ~IPCWebSocketStreamHandleBridge();
  54
  55   // The ID for this bridge and corresponding SocketStream instance in the
  56   // browser process.
  57   int socket_id_;
  58
  59   blink::WebSocketStreamHandle* handle_;
  60   WebSocketStreamHandleDelegate* delegate_;
  61
  62   // Map from ID to bridge instance.
  63   static base::LazyInstance<IDMap<IPCWebSocketStreamHandleBridge> >::Leaky
  64       all_bridges;
  65 };
  66
  67 // static
  68 base::LazyInstance<IDMap<IPCWebSocketStreamHandleBridge> >::Leaky
  69     IPCWebSocketStreamHandleBridge::all_bridges = LAZY_INSTANCE_INITIALIZER;
  70
  71 /* static */
  72 IPCWebSocketStreamHandleBridge* IPCWebSocketStreamHandleBridge::FromSocketId(
  73     int id) {
  74   return all_bridges.Get().Lookup(id);
  75 }
  76
  77 IPCWebSocketStreamHandleBridge::~IPCWebSocketStreamHandleBridge() {
  78   DVLOG(1) << "Bridge (" << this << ", socket_id_=" << socket_id_
  79            << ") Destructor";
  80
  81   if (socket_id_ == kNoSocketId)
  82     return;
  83
  84   ChildThread::current()->Send(new SocketStreamHostMsg_Close(socket_id_));
  85   socket_id_ = kNoSocketId;
  86 }
  87
  88 void IPCWebSocketStreamHandleBridge::Connect(const GURL& url) {
  89   DVLOG(1) << "Bridge (" << this << ") Connect (url=" << url << ")";
  90
  91   DCHECK_EQ(socket_id_, kNoSocketId);
  92   if (delegate_)
  93     delegate_->WillOpenStream(handle_, url);
  94
  95   socket_id_ = all_bridges.Get().Add(this);
  96   DCHECK_NE(socket_id_, kNoSocketId);
  97   int render_frame_id = MSG_ROUTING_NONE;
  98   WebSocketStreamHandleImpl* impl =
  99       static_cast<WebSocketStreamHandleImpl*>(handle_);
 100   const SocketStreamHandleData* data =
 101       static_cast<SocketStreamHandleData*>(impl->GetUserData(handle_));
 102   if (data)
 103     render_frame_id = data->render_frame_id();
 104   AddRef();  // Released in OnClosed().
 105   ChildThread::current()->Send(
 106       new SocketStreamHostMsg_Connect(render_frame_id, url, socket_id_));
 107   DVLOG(1) << "Bridge #" << socket_id_ << " sent IPC Connect";
 108   // TODO(ukai): timeout to OnConnected.
 109 }
 110
 111 bool IPCWebSocketStreamHandleBridge::Send(const std::vector<char>& data) {
 112   DVLOG(1) << "Bridge #" << socket_id_ << " Send (" << data.size()
 113            << " bytes)";
 114
 115   ChildThread::current()->Send(
 116       new SocketStreamHostMsg_SendData(socket_id_, data));
 117   if (delegate_)
 118     delegate_->WillSendData(handle_, &data[0], data.size());
 119   return true;
 120 }
 121
 122 void IPCWebSocketStreamHandleBridge::Close() {
 123   DVLOG(1) << "Bridge #" << socket_id_ << " Close";
 124
 125   ChildThread::current()->Send(new SocketStreamHostMsg_Close(socket_id_));
 126 }
 127
 128 void IPCWebSocketStreamHandleBridge::OnConnected(int max_pending_send_allowed) {
 129   DVLOG(1) << "Bridge #" << socket_id_
 130            << " OnConnected (max_pending_send_allowed="
 131            << max_pending_send_allowed << ")";
 132
 133   if (delegate_)
 134     delegate_->DidOpenStream(handle_, max_pending_send_allowed);
 135 }
 136
 137 void IPCWebSocketStreamHandleBridge::OnSentData(int amount_sent) {
 138   DVLOG(1) << "Bridge #" << socket_id_ << " OnSentData (" << amount_sent
 139            << " bytes)";
 140
 141   if (delegate_)
 142     delegate_->DidSendData(handle_, amount_sent);
 143 }
 144
 145 void IPCWebSocketStreamHandleBridge::OnReceivedData(
 146     const std::vector<char>& data) {
 147   DVLOG(1) << "Bridge #" << socket_id_ << " OnReceiveData (" << data.size()
 148            << " bytes)";
 149   if (delegate_)
 150     delegate_->DidReceiveData(handle_, &data[0], data.size());
 151 }
 152
 153 void IPCWebSocketStreamHandleBridge::OnClosed() {
 154   DVLOG(1) << "Bridge #" << socket_id_ << " OnClosed";
 155
 156   if (socket_id_ != kNoSocketId) {
 157     all_bridges.Get().Remove(socket_id_);
 158     socket_id_ = kNoSocketId;
 159   }
 160   if (delegate_)
 161     delegate_->DidClose(handle_);
 162   delegate_ = NULL;
 163   Release();
 164 }
 165
 166 void IPCWebSocketStreamHandleBridge::OnFailed(int error_code,
 167                                               const std::string& error_msg) {
 168   DVLOG(1) << "Bridge #" << socket_id_ << " OnFailed (error_code=" << error_code
 169            << ")";
 170   if (delegate_)
 171     delegate_->DidFail(handle_, error_code, base::ASCIIToUTF16(error_msg));
 172 }
 173
 174 SocketStreamDispatcher::SocketStreamDispatcher() {
 175 }
 176
 177 // static
 178 WebSocketStreamHandleBridge* SocketStreamDispatcher::CreateBridge(
 179     blink::WebSocketStreamHandle* handle,
 180     WebSocketStreamHandleDelegate* delegate) {
 181   return new IPCWebSocketStreamHandleBridge(handle, delegate);
 182 }
 183
 184 bool SocketStreamDispatcher::OnMessageReceived(const IPC::Message& msg) {
 185   bool handled = true;
 186   IPC_BEGIN_MESSAGE_MAP(SocketStreamDispatcher, msg)
 187     IPC_MESSAGE_HANDLER(SocketStreamMsg_Connected, OnConnected)
 188     IPC_MESSAGE_HANDLER(SocketStreamMsg_SentData, OnSentData)
 189     IPC_MESSAGE_HANDLER(SocketStreamMsg_ReceivedData, OnReceivedData)
 190     IPC_MESSAGE_HANDLER(SocketStreamMsg_Closed, OnClosed)
 191     IPC_MESSAGE_HANDLER(SocketStreamMsg_Failed, OnFailed)
 192     IPC_MESSAGE_UNHANDLED(handled = false)
 193   IPC_END_MESSAGE_MAP()
 194   return handled;
 195 }
 196
 197 void SocketStreamDispatcher::OnConnected(int socket_id,
 198                                          int max_pending_send_allowed) {
 199   DVLOG(1) << "SocketStreamDispatcher::OnConnected (max_pending_send_allowed="
 200            << max_pending_send_allowed << ") to socket_id=" << socket_id;
 201
 202   IPCWebSocketStreamHandleBridge* bridge =
 203       IPCWebSocketStreamHandleBridge::FromSocketId(socket_id);
 204   if (bridge)
 205     bridge->OnConnected(max_pending_send_allowed);
 206   else
 207     DLOG(ERROR) << "No bridge for socket_id=" << socket_id;
 208 }
 209
 210 void SocketStreamDispatcher::OnSentData(int socket_id, int amount_sent) {
 211   DVLOG(1) << "SocketStreamDispatcher::OnSentData (" << amount_sent
 212            << " bytes) to socket_id=" << socket_id;
 213
 214   IPCWebSocketStreamHandleBridge* bridge =
 215       IPCWebSocketStreamHandleBridge::FromSocketId(socket_id);
 216   if (bridge)
 217     bridge->OnSentData(amount_sent);
 218   else
 219     DLOG(ERROR) << "No bridge for socket_id=" << socket_id;
 220 }
 221
 222 void SocketStreamDispatcher::OnReceivedData(
 223     int socket_id, const std::vector<char>& data) {
 224   DVLOG(1) << "SocketStreamDispatcher::OnReceivedData (" << data.size()
 225            << " bytes) to socket_id=" << socket_id;
 226
 227   IPCWebSocketStreamHandleBridge* bridge =
 228       IPCWebSocketStreamHandleBridge::FromSocketId(socket_id);
 229   if (bridge)
 230     bridge->OnReceivedData(data);
 231   else
 232     DLOG(ERROR) << "No bridge for socket_id=" << socket_id;
 233 }
 234
 235 void SocketStreamDispatcher::OnClosed(int socket_id) {
 236   DVLOG(1) << "SocketStreamDispatcher::OnClosed to socket_id=" << socket_id;
 237
 238   IPCWebSocketStreamHandleBridge* bridge =
 239       IPCWebSocketStreamHandleBridge::FromSocketId(socket_id);
 240   if (bridge)
 241     bridge->OnClosed();
 242   else
 243     DLOG(ERROR) << "No bridge for socket_id=" << socket_id;
 244 }
 245
 246 void SocketStreamDispatcher::OnFailed(int socket_id, int error_code) {
 247   IPCWebSocketStreamHandleBridge* bridge =
 248       IPCWebSocketStreamHandleBridge::FromSocketId(socket_id);
 249   if (bridge)
 250     bridge->OnFailed(error_code, net::ErrorToString(error_code));
 251   else
 252     DLOG(ERROR) << "No bridge for socket_id=" << socket_id;
 253 }
 254
 255 }  // namespace content