| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 #ifndef NET_SOCKET_WEBSOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_ | |
| 6 #define NET_SOCKET_WEBSOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_ | |
| 7 | |
| 8 #include <list> | |
| 9 #include <map> | |
| 10 #include <set> | |
| 11 #include <string> | |
| 12 | |
| 13 #include "base/basictypes.h" | |
| 14 #include "base/memory/ref_counted.h" | |
| 15 #include "base/memory/scoped_ptr.h" | |
| 16 #include "base/memory/weak_ptr.h" | |
| 17 #include "base/time/time.h" | |
| 18 #include "base/timer/timer.h" | |
| 19 #include "net/base/net_export.h" | |
| 20 #include "net/base/net_log.h" | |
| 21 #include "net/socket/client_socket_pool.h" | |
| 22 #include "net/socket/client_socket_pool_base.h" | |
| 23 #include "net/socket/transport_client_socket_pool.h" | |
| 24 | |
| 25 namespace net { | |
| 26 | |
| 27 class ClientSocketFactory; | |
| 28 class ClientSocketPoolHistograms; | |
| 29 class HostResolver; | |
| 30 class NetLog; | |
| 31 class WebSocketEndpointLockManager; | |
| 32 class WebSocketTransportConnectSubJob; | |
| 33 | |
| 34 // WebSocketTransportConnectJob handles the host resolution necessary for socket | |
| 35 // creation and the TCP connect. WebSocketTransportConnectJob also has fallback | |
| 36 // logic for IPv6 connect() timeouts (which may happen due to networks / routers | |
| 37 // with broken IPv6 support). Those timeouts take 20s, so rather than make the | |
| 38 // user wait 20s for the timeout to fire, we use a fallback timer | |
| 39 // (kIPv6FallbackTimerInMs) and start a connect() to an IPv4 address if the | |
| 40 // timer fires. Then we race the IPv4 connect(s) against the IPv6 connect(s) and | |
| 41 // use the socket that completes successfully first or fails last. | |
| 42 class NET_EXPORT_PRIVATE WebSocketTransportConnectJob : public ConnectJob { | |
| 43 public: | |
| 44 WebSocketTransportConnectJob( | |
| 45 const std::string& group_name, | |
| 46 RequestPriority priority, | |
| 47 const scoped_refptr<TransportSocketParams>& params, | |
| 48 base::TimeDelta timeout_duration, | |
| 49 const CompletionCallback& callback, | |
| 50 ClientSocketFactory* client_socket_factory, | |
| 51 HostResolver* host_resolver, | |
| 52 ClientSocketHandle* handle, | |
| 53 Delegate* delegate, | |
| 54 NetLog* pool_net_log, | |
| 55 const BoundNetLog& request_net_log); | |
| 56 ~WebSocketTransportConnectJob() override; | |
| 57 | |
| 58 // Unlike normal socket pools, the WebSocketTransportClientPool uses | |
| 59 // early-binding of sockets. | |
| 60 ClientSocketHandle* handle() const { return handle_; } | |
| 61 | |
| 62 // Stash the callback from RequestSocket() here for convenience. | |
| 63 const CompletionCallback& callback() const { return callback_; } | |
| 64 | |
| 65 const BoundNetLog& request_net_log() const { return request_net_log_; } | |
| 66 | |
| 67 // ConnectJob methods. | |
| 68 LoadState GetLoadState() const override; | |
| 69 | |
| 70 private: | |
| 71 friend class WebSocketTransportConnectSubJob; | |
| 72 friend class TransportConnectJobHelper; | |
| 73 friend class WebSocketEndpointLockManager; | |
| 74 | |
| 75 // Although it is not strictly necessary, it makes the code simpler if each | |
| 76 // subjob knows what type it is. | |
| 77 enum SubJobType { SUB_JOB_IPV4, SUB_JOB_IPV6 }; | |
| 78 | |
| 79 int DoResolveHost(); | |
| 80 int DoResolveHostComplete(int result); | |
| 81 int DoTransportConnect(); | |
| 82 int DoTransportConnectComplete(int result); | |
| 83 | |
| 84 // Called back from a SubJob when it completes. | |
| 85 void OnSubJobComplete(int result, WebSocketTransportConnectSubJob* job); | |
| 86 | |
| 87 // Called from |fallback_timer_|. | |
| 88 void StartIPv4JobAsync(); | |
| 89 | |
| 90 // Begins the host resolution and the TCP connect. Returns OK on success | |
| 91 // and ERR_IO_PENDING if it cannot immediately service the request. | |
| 92 // Otherwise, it returns a net error code. | |
| 93 int ConnectInternal() override; | |
| 94 | |
| 95 TransportConnectJobHelper helper_; | |
| 96 | |
| 97 // The addresses are divided into IPv4 and IPv6, which are performed partially | |
| 98 // in parallel. If the list of IPv6 addresses is non-empty, then the IPv6 jobs | |
| 99 // go first, followed after |kIPv6FallbackTimerInMs| by the IPv4 | |
| 100 // addresses. First sub-job to establish a connection wins. | |
| 101 scoped_ptr<WebSocketTransportConnectSubJob> ipv4_job_; | |
| 102 scoped_ptr<WebSocketTransportConnectSubJob> ipv6_job_; | |
| 103 | |
| 104 base::OneShotTimer<WebSocketTransportConnectJob> fallback_timer_; | |
| 105 TransportConnectJobHelper::ConnectionLatencyHistogram race_result_; | |
| 106 ClientSocketHandle* const handle_; | |
| 107 CompletionCallback callback_; | |
| 108 BoundNetLog request_net_log_; | |
| 109 | |
| 110 bool had_ipv4_; | |
| 111 bool had_ipv6_; | |
| 112 | |
| 113 DISALLOW_COPY_AND_ASSIGN(WebSocketTransportConnectJob); | |
| 114 }; | |
| 115 | |
| 116 class NET_EXPORT_PRIVATE WebSocketTransportClientSocketPool | |
| 117 : public TransportClientSocketPool { | |
| 118 public: | |
| 119 WebSocketTransportClientSocketPool(int max_sockets, | |
| 120 int max_sockets_per_group, | |
| 121 ClientSocketPoolHistograms* histograms, | |
| 122 HostResolver* host_resolver, | |
| 123 ClientSocketFactory* client_socket_factory, | |
| 124 NetLog* net_log); | |
| 125 | |
| 126 ~WebSocketTransportClientSocketPool() override; | |
| 127 | |
| 128 // Allow another connection to be started to the IPEndPoint that this |handle| | |
| 129 // is connected to. Used when the WebSocket handshake completes successfully. | |
| 130 // This only works if the socket is connected, however the caller does not | |
| 131 // need to explicitly check for this. Instead, ensure that dead sockets are | |
| 132 // returned to ReleaseSocket() in a timely fashion. | |
| 133 static void UnlockEndpoint(ClientSocketHandle* handle); | |
| 134 | |
| 135 // ClientSocketPool implementation. | |
| 136 int RequestSocket(const std::string& group_name, | |
| 137 const void* resolve_info, | |
| 138 RequestPriority priority, | |
| 139 ClientSocketHandle* handle, | |
| 140 const CompletionCallback& callback, | |
| 141 const BoundNetLog& net_log) override; | |
| 142 void RequestSockets(const std::string& group_name, | |
| 143 const void* params, | |
| 144 int num_sockets, | |
| 145 const BoundNetLog& net_log) override; | |
| 146 void CancelRequest(const std::string& group_name, | |
| 147 ClientSocketHandle* handle) override; | |
| 148 void ReleaseSocket(const std::string& group_name, | |
| 149 scoped_ptr<StreamSocket> socket, | |
| 150 int id) override; | |
| 151 void FlushWithError(int error) override; | |
| 152 void CloseIdleSockets() override; | |
| 153 int IdleSocketCount() const override; | |
| 154 int IdleSocketCountInGroup(const std::string& group_name) const override; | |
| 155 LoadState GetLoadState(const std::string& group_name, | |
| 156 const ClientSocketHandle* handle) const override; | |
| 157 base::DictionaryValue* GetInfoAsValue( | |
| 158 const std::string& name, | |
| 159 const std::string& type, | |
| 160 bool include_nested_pools) const override; | |
| 161 base::TimeDelta ConnectionTimeout() const override; | |
| 162 ClientSocketPoolHistograms* histograms() const override; | |
| 163 | |
| 164 // HigherLayeredPool implementation. | |
| 165 bool IsStalled() const override; | |
| 166 | |
| 167 private: | |
| 168 class ConnectJobDelegate : public ConnectJob::Delegate { | |
| 169 public: | |
| 170 explicit ConnectJobDelegate(WebSocketTransportClientSocketPool* owner); | |
| 171 ~ConnectJobDelegate() override; | |
| 172 | |
| 173 void OnConnectJobComplete(int result, ConnectJob* job) override; | |
| 174 | |
| 175 private: | |
| 176 WebSocketTransportClientSocketPool* owner_; | |
| 177 | |
| 178 DISALLOW_COPY_AND_ASSIGN(ConnectJobDelegate); | |
| 179 }; | |
| 180 | |
| 181 // Store the arguments from a call to RequestSocket() that has stalled so we | |
| 182 // can replay it when there are available socket slots. | |
| 183 struct StalledRequest { | |
| 184 StalledRequest(const scoped_refptr<TransportSocketParams>& params, | |
| 185 RequestPriority priority, | |
| 186 ClientSocketHandle* handle, | |
| 187 const CompletionCallback& callback, | |
| 188 const BoundNetLog& net_log); | |
| 189 ~StalledRequest(); | |
| 190 const scoped_refptr<TransportSocketParams> params; | |
| 191 const RequestPriority priority; | |
| 192 ClientSocketHandle* const handle; | |
| 193 const CompletionCallback callback; | |
| 194 const BoundNetLog net_log; | |
| 195 }; | |
| 196 friend class ConnectJobDelegate; | |
| 197 typedef std::map<const ClientSocketHandle*, WebSocketTransportConnectJob*> | |
| 198 PendingConnectsMap; | |
| 199 // This is a list so that we can remove requests from the middle, and also | |
| 200 // so that iterators are not invalidated unless the corresponding request is | |
| 201 // removed. | |
| 202 typedef std::list<StalledRequest> StalledRequestQueue; | |
| 203 typedef std::map<const ClientSocketHandle*, StalledRequestQueue::iterator> | |
| 204 StalledRequestMap; | |
| 205 | |
| 206 void OnConnectJobComplete(int result, WebSocketTransportConnectJob* job); | |
| 207 void InvokeUserCallbackLater(ClientSocketHandle* handle, | |
| 208 const CompletionCallback& callback, | |
| 209 int rv); | |
| 210 void InvokeUserCallback(ClientSocketHandle* handle, | |
| 211 const CompletionCallback& callback, | |
| 212 int rv); | |
| 213 bool ReachedMaxSocketsLimit() const; | |
| 214 void HandOutSocket(scoped_ptr<StreamSocket> socket, | |
| 215 const LoadTimingInfo::ConnectTiming& connect_timing, | |
| 216 ClientSocketHandle* handle, | |
| 217 const BoundNetLog& net_log); | |
| 218 void AddJob(ClientSocketHandle* handle, | |
| 219 scoped_ptr<WebSocketTransportConnectJob> connect_job); | |
| 220 bool DeleteJob(ClientSocketHandle* handle); | |
| 221 const WebSocketTransportConnectJob* LookupConnectJob( | |
| 222 const ClientSocketHandle* handle) const; | |
| 223 void ActivateStalledRequest(); | |
| 224 bool DeleteStalledRequest(ClientSocketHandle* handle); | |
| 225 | |
| 226 ConnectJobDelegate connect_job_delegate_; | |
| 227 std::set<const ClientSocketHandle*> pending_callbacks_; | |
| 228 PendingConnectsMap pending_connects_; | |
| 229 StalledRequestQueue stalled_request_queue_; | |
| 230 StalledRequestMap stalled_request_map_; | |
| 231 ClientSocketPoolHistograms* const histograms_; | |
| 232 NetLog* const pool_net_log_; | |
| 233 ClientSocketFactory* const client_socket_factory_; | |
| 234 HostResolver* const host_resolver_; | |
| 235 const int max_sockets_; | |
| 236 int handed_out_socket_count_; | |
| 237 bool flushing_; | |
| 238 | |
| 239 base::WeakPtrFactory<WebSocketTransportClientSocketPool> weak_factory_; | |
| 240 | |
| 241 DISALLOW_COPY_AND_ASSIGN(WebSocketTransportClientSocketPool); | |
| 242 }; | |
| 243 | |
| 244 } // namespace net | |
| 245 | |
| 246 #endif // NET_SOCKET_WEBSOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master