OLD | NEW |
(Empty) | |
| 1 // Copyright 2009 Google Inc. All Rights Reserved. |
| 2 // Author: ukai@google.com (Fumitoshi Ukai) |
| 3 |
| 4 #include "chrome/renderer/socket_stream_dispatcher.h" |
| 5 |
| 6 #include <vector> |
| 7 |
| 8 #include "base/id_map.h" |
| 9 #include "base/ref_counted.h" |
| 10 #include "chrome/common/render_messages.h" |
| 11 #include "chrome/common/net/socket_stream.h" |
| 12 #include "chrome/renderer/render_thread.h" |
| 13 #include "googleurl/src/gurl.h" |
| 14 #include "webkit/glue/websocketstreamhandle_bridge.h" |
| 15 #include "webkit/glue/websocketstreamhandle_delegate.h" |
| 16 |
| 17 // IPCWebSocketStreamHandleBridge is owned by each SocketStreamHandle. |
| 18 // It communites with the main browser process via SocketStreamDispatcher. |
| 19 class IPCWebSocketStreamHandleBridge |
| 20 : public base::RefCounted<IPCWebSocketStreamHandleBridge>, |
| 21 public webkit_glue::WebSocketStreamHandleBridge { |
| 22 public: |
| 23 IPCWebSocketStreamHandleBridge( |
| 24 IPC::Message::Sender* sender, |
| 25 WebKit::WebSocketStreamHandle* handle, |
| 26 webkit_glue::WebSocketStreamHandleDelegate* delegate) |
| 27 : socket_id_(chrome_common_net::kNoSocketId), |
| 28 sender_(sender), |
| 29 handle_(handle), |
| 30 delegate_(delegate) {} |
| 31 virtual ~IPCWebSocketStreamHandleBridge(); |
| 32 |
| 33 // Returns the handle having given id or NULL if there is no such handle. |
| 34 static IPCWebSocketStreamHandleBridge* FromSocketId(int id); |
| 35 |
| 36 // webkit_glue::WebSocketStreamHandleBridge methods. |
| 37 virtual void Connect(const GURL& url); |
| 38 virtual bool Send(const std::vector<char>& data); |
| 39 virtual void Close(); |
| 40 |
| 41 // Called by SocketStreamDispatcher. |
| 42 void OnConnected(int max_amount_send_allowed); |
| 43 void OnSentData(int amount_sent); |
| 44 void OnReceivedData(const std::vector<char>& data); |
| 45 void OnClosed(); |
| 46 |
| 47 private: |
| 48 void DoConnect(const GURL& url); |
| 49 int socket_id_; |
| 50 |
| 51 IPC::Message::Sender* sender_; |
| 52 WebKit::WebSocketStreamHandle* handle_; |
| 53 webkit_glue::WebSocketStreamHandleDelegate* delegate_; |
| 54 |
| 55 static IDMap<IPCWebSocketStreamHandleBridge> all_bridges; |
| 56 }; |
| 57 |
| 58 IDMap<IPCWebSocketStreamHandleBridge> |
| 59 IPCWebSocketStreamHandleBridge::all_bridges; |
| 60 |
| 61 /* static */ |
| 62 IPCWebSocketStreamHandleBridge* IPCWebSocketStreamHandleBridge::FromSocketId( |
| 63 int id) { |
| 64 return all_bridges.Lookup(id); |
| 65 } |
| 66 |
| 67 IPCWebSocketStreamHandleBridge::~IPCWebSocketStreamHandleBridge() { |
| 68 LOG(INFO) << "IPCWebSocketStreamHandleBridge destructor socket_id=" |
| 69 << socket_id_; |
| 70 if (socket_id_ != chrome_common_net::kNoSocketId) { |
| 71 sender_->Send(new ViewHostMsg_Close(socket_id_)); |
| 72 socket_id_ = chrome_common_net::kNoSocketId; |
| 73 } |
| 74 } |
| 75 |
| 76 void IPCWebSocketStreamHandleBridge::Connect(const GURL& url) { |
| 77 DCHECK(sender_); |
| 78 LOG(INFO) << "Connect url=" << url; |
| 79 MessageLoop::current()->PostTask( |
| 80 FROM_HERE, |
| 81 NewRunnableMethod(this, &IPCWebSocketStreamHandleBridge::DoConnect, |
| 82 url)); |
| 83 } |
| 84 |
| 85 bool IPCWebSocketStreamHandleBridge::Send( |
| 86 const std::vector<char>& data) { |
| 87 LOG(INFO) << "Send data.size=" << data.size(); |
| 88 if (sender_->Send(new ViewHostMsg_SocketStream_SendData(socket_id_, data))) { |
| 89 if (delegate_) |
| 90 delegate_->WillSendData(handle_, &data[0], data.size()); |
| 91 return true; |
| 92 } |
| 93 return false; |
| 94 } |
| 95 |
| 96 void IPCWebSocketStreamHandleBridge::Close() { |
| 97 LOG(INFO) << "Close socket_id" << socket_id_; |
| 98 sender_->Send(new ViewHostMsg_SocketStream_Close(socket_id_)); |
| 99 } |
| 100 |
| 101 void IPCWebSocketStreamHandleBridge::OnConnected(int max_pending_send_allowed) { |
| 102 LOG(INFO) << "IPCWebSocketStreamHandleBridge::OnConnected socket_id=" |
| 103 << socket_id_; |
| 104 if (delegate_) |
| 105 delegate_->DidOpenStream(handle_, max_pending_send_allowed); |
| 106 } |
| 107 |
| 108 void IPCWebSocketStreamHandleBridge::OnSentData(int amount_sent) { |
| 109 if (delegate_) |
| 110 delegate_->DidSendData(handle_, amount_sent); |
| 111 } |
| 112 |
| 113 void IPCWebSocketStreamHandleBridge::OnReceivedData( |
| 114 const std::vector<char>& data) { |
| 115 if (delegate_) |
| 116 delegate_->DidReceiveData(handle_, &data[0], data.size()); |
| 117 } |
| 118 |
| 119 void IPCWebSocketStreamHandleBridge::OnClosed() { |
| 120 LOG(INFO) << "IPCWebSocketStreamHandleBridge::OnClosed"; |
| 121 if (socket_id_ != chrome_common_net::kNoSocketId) { |
| 122 all_bridges.Remove(socket_id_); |
| 123 socket_id_ = chrome_common_net::kNoSocketId; |
| 124 } |
| 125 if (delegate_) { |
| 126 delegate_->DidClose(handle_); |
| 127 } |
| 128 delegate_ = NULL; |
| 129 Release(); |
| 130 } |
| 131 |
| 132 void IPCWebSocketStreamHandleBridge::DoConnect(const GURL& url) { |
| 133 DCHECK(sender_); |
| 134 DCHECK_EQ(socket_id_, chrome_common_net::kNoSocketId); |
| 135 if (delegate_) |
| 136 delegate_->WillOpenStream(handle_, url); |
| 137 |
| 138 socket_id_ = all_bridges.Add(this); |
| 139 DCHECK_NE(socket_id_, chrome_common_net::kNoSocketId); |
| 140 if (sender_->Send(new ViewHostMsg_SocketStream_Connect(url, socket_id_))) { |
| 141 LOG(INFO) << "Connect socket_id=" << socket_id_; |
| 142 AddRef(); // Released in OnClosed(). |
| 143 // TODO(ukai): timeout to OnConnected. |
| 144 } else { |
| 145 LOG(INFO) << "Connect failed?"; |
| 146 DCHECK_EQ(socket_id_, chrome_common_net::kNoSocketId); |
| 147 OnClosed(); |
| 148 } |
| 149 } |
| 150 |
| 151 SocketStreamDispatcher::SocketStreamDispatcher() { |
| 152 } |
| 153 |
| 154 /* static */ |
| 155 webkit_glue::WebSocketStreamHandleBridge* |
| 156 SocketStreamDispatcher::CreateBridge( |
| 157 WebKit::WebSocketStreamHandle* handle, |
| 158 webkit_glue::WebSocketStreamHandleDelegate* delegate) { |
| 159 return new IPCWebSocketStreamHandleBridge( |
| 160 ChildThread::current(), handle, delegate); |
| 161 } |
| 162 |
| 163 bool SocketStreamDispatcher::OnMessageReceived(const IPC::Message& msg) { |
| 164 LOG(INFO) << "SocketStreamDispatcher::OnMessageReceived"; |
| 165 bool handled = true; |
| 166 IPC_BEGIN_MESSAGE_MAP(SocketStreamDispatcher, msg) |
| 167 IPC_MESSAGE_HANDLER(ViewMsg_SocketStream_Connected, OnConnected) |
| 168 IPC_MESSAGE_HANDLER(ViewMsg_SocketStream_SentData, OnSentData) |
| 169 IPC_MESSAGE_HANDLER(ViewMsg_SocketStream_ReceivedData, OnReceivedData) |
| 170 IPC_MESSAGE_HANDLER(ViewMsg_SocketStream_Closed, OnClosed) |
| 171 IPC_MESSAGE_UNHANDLED(handled = false) |
| 172 IPC_END_MESSAGE_MAP() |
| 173 return handled; |
| 174 } |
| 175 |
| 176 void SocketStreamDispatcher::OnConnected(int socket_id, |
| 177 int max_pending_send_allowed) { |
| 178 LOG(INFO) << "SocketStreamDispatcher::OnConnected socket_id=" << socket_id |
| 179 << " max_pending_send_allowed=" << max_pending_send_allowed; |
| 180 IPCWebSocketStreamHandleBridge* bridge = |
| 181 IPCWebSocketStreamHandleBridge::FromSocketId(socket_id); |
| 182 if (bridge) |
| 183 bridge->OnConnected(max_pending_send_allowed); |
| 184 } |
| 185 |
| 186 void SocketStreamDispatcher::OnSentData(int socket_id, int amount_sent) { |
| 187 IPCWebSocketStreamHandleBridge* bridge = |
| 188 IPCWebSocketStreamHandleBridge::FromSocketId(socket_id); |
| 189 if (bridge) |
| 190 bridge->OnSentData(amount_sent); |
| 191 } |
| 192 |
| 193 void SocketStreamDispatcher::OnReceivedData( |
| 194 int socket_id, const std::vector<char>& data) { |
| 195 IPCWebSocketStreamHandleBridge* bridge = |
| 196 IPCWebSocketStreamHandleBridge::FromSocketId(socket_id); |
| 197 if (bridge) |
| 198 bridge->OnReceivedData(data); |
| 199 } |
| 200 |
| 201 void SocketStreamDispatcher::OnClosed(int socket_id) { |
| 202 IPCWebSocketStreamHandleBridge* bridge = |
| 203 IPCWebSocketStreamHandleBridge::FromSocketId(socket_id); |
| 204 if (bridge) |
| 205 bridge->OnClosed(); |
| 206 } |
OLD | NEW |