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 <vector>
   8
   9 #include "base/bind.h"
  10 #include "base/id_map.h"
  11 #include "base/lazy_instance.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "base/strings/string16.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "content/child/child_thread.h"
  17 #include "content/common/socket_stream.h"
  18 #include "content/common/socket_stream_handle_data.h"
  19 #include "content/common/socket_stream_messages.h"
  20 #include "net/base/net_errors.h"
  21 #include "url/gurl.h"
  22 #include "webkit/child/websocketstreamhandle_bridge.h"
  23 #include "webkit/child/websocketstreamhandle_delegate.h"
  24
  25 namespace content {
  26
  27 // IPCWebSocketStreamHandleBridge is owned by each SocketStreamHandle.
  28 // It communicates with the main browser process via SocketStreamDispatcher.
  29 class IPCWebSocketStreamHandleBridge
  30     : public webkit_glue::WebSocketStreamHandleBridge {
  31  public:
  32   IPCWebSocketStreamHandleBridge(
  33       WebKit::WebSocketStreamHandle* handle,
  34       webkit_glue::WebSocketStreamHandleDelegate* delegate)
  35       : socket_id_(kNoSocketId),
  36         handle_(handle),
  37         delegate_(delegate) {}
  38
  39   // Returns the handle having given id or NULL if there is no such handle.
  40   static IPCWebSocketStreamHandleBridge* FromSocketId(int id);
  41
  42   // webkit_glue::WebSocketStreamHandleBridge methods.
  43   virtual void Connect(const GURL& url) OVERRIDE;
  44   virtual bool Send(const std::vector<char>& data) OVERRIDE;
  45   virtual void Close() OVERRIDE;
  46
  47   // Called by SocketStreamDispatcher.
  48   void OnConnected(int max_amount_send_allowed);
  49   void OnSentData(int amount_sent);
  50   void OnReceivedData(const std::vector<char>& data);
  51   void OnClosed();
  52   void OnFailed(int error_code, const char* error_msg);
  53
  54  private:
  55   virtual ~IPCWebSocketStreamHandleBridge();
  56
  57   // The ID for this bridge and corresponding SocketStream instance in the
  58   // browser process.
  59   int socket_id_;
  60
  61   WebKit::WebSocketStreamHandle* handle_;
  62   webkit_glue::WebSocketStreamHandleDelegate* delegate_;
  63
  64   // Map from ID to bridge instance.
  65   static base::LazyInstance<IDMap<IPCWebSocketStreamHandleBridge> >::Leaky
  66       all_bridges;
  67 };
  68
  69 // static
  70 base::LazyInstance<IDMap<IPCWebSocketStreamHandleBridge> >::Leaky
  71     IPCWebSocketStreamHandleBridge::all_bridges = LAZY_INSTANCE_INITIALIZER;
  72
  73 /* static */
  74 IPCWebSocketStreamHandleBridge* IPCWebSocketStreamHandleBridge::FromSocketId(
  75     int id) {
  76   return all_bridges.Get().Lookup(id);
  77 }
  78
  79 IPCWebSocketStreamHandleBridge::~IPCWebSocketStreamHandleBridge() {
  80   DVLOG(1) << "Bridge (" << this << ", socket_id_=" << socket_id_
  81            << ") Destructor";
  82
  83   if (socket_id_ == kNoSocketId)
  84     return;
  85
  86   ChildThread::current()->Send(new SocketStreamHostMsg_Close(socket_id_));
  87   socket_id_ = kNoSocketId;
  88 }
  89
  90 void IPCWebSocketStreamHandleBridge::Connect(const GURL& url) {
  91   DVLOG(1) << "Bridge (" << this << ") Connect (url=" << url << ")";
  92
  93   DCHECK_EQ(socket_id_, kNoSocketId);
  94   if (delegate_)
  95     delegate_->WillOpenStream(handle_, url);
  96
  97   socket_id_ = all_bridges.Get().Add(this);
  98   DCHECK_NE(socket_id_, kNoSocketId);
  99   int render_view_id = MSG_ROUTING_NONE;
 100   const SocketStreamHandleData* data =
 101       SocketStreamHandleData::ForHandle(handle_);
 102   if (data)
 103     render_view_id = data->render_view_id();
 104   AddRef();  // Released in OnClosed().
 105   ChildThread::current()->Send(
 106       new SocketStreamHostMsg_Connect(render_view_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 char* error_msg) {
 168   DVLOG(1) << "Bridge #" << socket_id_ << " OnFailed (error_code=" << error_code
 169            << ")";
 170   if (delegate_)
 171     delegate_->DidFail(handle_, error_code, ASCIIToUTF16(error_msg));
 172 }
 173
 174 SocketStreamDispatcher::SocketStreamDispatcher() {
 175 }
 176
 177 /* static */
 178 webkit_glue::WebSocketStreamHandleBridge*
 179 SocketStreamDispatcher::CreateBridge(
 180     WebKit::WebSocketStreamHandle* handle,
 181     webkit_glue::WebSocketStreamHandleDelegate* delegate) {
 182   return new IPCWebSocketStreamHandleBridge(handle, delegate);
 183 }
 184
 185 bool SocketStreamDispatcher::OnMessageReceived(const IPC::Message& msg) {
 186   bool handled = true;
 187   IPC_BEGIN_MESSAGE_MAP(SocketStreamDispatcher, msg)
 188     IPC_MESSAGE_HANDLER(SocketStreamMsg_Connected, OnConnected)
 189     IPC_MESSAGE_HANDLER(SocketStreamMsg_SentData, OnSentData)
 190     IPC_MESSAGE_HANDLER(SocketStreamMsg_ReceivedData, OnReceivedData)
 191     IPC_MESSAGE_HANDLER(SocketStreamMsg_Closed, OnClosed)
 192     IPC_MESSAGE_HANDLER(SocketStreamMsg_Failed, OnFailed)
 193     IPC_MESSAGE_UNHANDLED(handled = false)
 194   IPC_END_MESSAGE_MAP()
 195   return handled;
 196 }
 197
 198 void SocketStreamDispatcher::OnConnected(int socket_id,
 199                                          int max_pending_send_allowed) {
 200   DVLOG(1) << "SocketStreamDispatcher::OnConnected (max_pending_send_allowed="
 201            << max_pending_send_allowed << ") to socket_id=" << socket_id;
 202
 203   IPCWebSocketStreamHandleBridge* bridge =
 204       IPCWebSocketStreamHandleBridge::FromSocketId(socket_id);
 205   if (bridge)
 206     bridge->OnConnected(max_pending_send_allowed);
 207   else
 208     DLOG(ERROR) << "No bridge for socket_id=" << socket_id;
 209 }
 210
 211 void SocketStreamDispatcher::OnSentData(int socket_id, int amount_sent) {
 212   DVLOG(1) << "SocketStreamDispatcher::OnSentData (" << amount_sent
 213            << " bytes) to socket_id=" << socket_id;
 214
 215   IPCWebSocketStreamHandleBridge* bridge =
 216       IPCWebSocketStreamHandleBridge::FromSocketId(socket_id);
 217   if (bridge)
 218     bridge->OnSentData(amount_sent);
 219   else
 220     DLOG(ERROR) << "No bridge for socket_id=" << socket_id;
 221 }
 222
 223 void SocketStreamDispatcher::OnReceivedData(
 224     int socket_id, const std::vector<char>& data) {
 225   DVLOG(1) << "SocketStreamDispatcher::OnReceivedData (" << data.size()
 226            << " bytes) to socket_id=" << socket_id;
 227
 228   IPCWebSocketStreamHandleBridge* bridge =
 229       IPCWebSocketStreamHandleBridge::FromSocketId(socket_id);
 230   if (bridge)
 231     bridge->OnReceivedData(data);
 232   else
 233     DLOG(ERROR) << "No bridge for socket_id=" << socket_id;
 234 }
 235
 236 void SocketStreamDispatcher::OnClosed(int socket_id) {
 237   DVLOG(1) << "SocketStreamDispatcher::OnClosed to socket_id=" << socket_id;
 238
 239   IPCWebSocketStreamHandleBridge* bridge =
 240       IPCWebSocketStreamHandleBridge::FromSocketId(socket_id);
 241   if (bridge)
 242     bridge->OnClosed();
 243   else
 244     DLOG(ERROR) << "No bridge for socket_id=" << socket_id;
 245 }
 246
 247 void SocketStreamDispatcher::OnFailed(int socket_id, int error_code) {
 248   IPCWebSocketStreamHandleBridge* bridge =
 249       IPCWebSocketStreamHandleBridge::FromSocketId(socket_id);
 250   if (bridge)
 251     bridge->OnFailed(error_code, net::ErrorToString(error_code));
 252   else
 253     DLOG(ERROR) << "No bridge for socket_id=" << socket_id;
 254 }
 255
 256 }  // namespace content