1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
// Copyright (c) 2012 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.
#ifndef NET_QUIC_QUIC_STREAM_FACTORY_H_
#define NET_QUIC_QUIC_STREAM_FACTORY_H_
#include <map>
#include <string>
#include "base/memory/weak_ptr.h"
#include "net/base/address_list.h"
#include "net/base/completion_callback.h"
#include "net/base/host_port_pair.h"
#include "net/base/net_log.h"
#include "net/base/network_change_notifier.h"
#include "net/proxy/proxy_server.h"
#include "net/quic/quic_config.h"
#include "net/quic/quic_crypto_stream.h"
#include "net/quic/quic_http_stream.h"
#include "net/quic/quic_protocol.h"
namespace net {
class HostResolver;
class ClientSocketFactory;
class QuicClock;
class QuicClientSession;
class QuicCryptoClientStreamFactory;
class QuicRandom;
class QuicStreamFactory;
// Encapsulates a pending request for a QuicHttpStream.
// If the request is still pending when it is destroyed, it will
// cancel the request with the factory.
class NET_EXPORT_PRIVATE QuicStreamRequest {
public:
explicit QuicStreamRequest(QuicStreamFactory* factory);
~QuicStreamRequest();
int Request(const HostPortProxyPair& host_port_proxy_pair,
const BoundNetLog& net_log,
const CompletionCallback& callback);
void OnRequestComplete(int rv);
scoped_ptr<QuicHttpStream> ReleaseStream();
void set_stream(scoped_ptr<QuicHttpStream> stream);
const BoundNetLog& net_log() const{
return net_log_;
}
private:
QuicStreamFactory* factory_;
HostPortProxyPair host_port_proxy_pair_;
BoundNetLog net_log_;
CompletionCallback callback_;
scoped_ptr<QuicHttpStream> stream_;
DISALLOW_COPY_AND_ASSIGN(QuicStreamRequest);
};
// A factory for creating new QuicHttpStreams on top of a pool of
// QuicClientSessions.
class NET_EXPORT_PRIVATE QuicStreamFactory
: public NetworkChangeNotifier::IPAddressObserver {
public:
QuicStreamFactory(
HostResolver* host_resolver,
ClientSocketFactory* client_socket_factory,
QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory,
QuicRandom* random_generator,
QuicClock* clock);
virtual ~QuicStreamFactory();
// Creates a new QuicHttpStream to |host_port_proxy_pair| which will be
// owned by |request|. If a matching session already exists, this
// method will return OK. If no matching session exists, this will
// return ERR_IO_PENDING and will invoke OnRequestComplete asynchronously.
int Create(const HostPortProxyPair& host_port_proxy_pair,
const BoundNetLog& net_log,
QuicStreamRequest* request);
// Returns a newly created QuicHttpStream owned by the caller, if a
// matching session already exists. Returns NULL otherwise.
scoped_ptr<QuicHttpStream> CreateIfSessionExists(
const HostPortProxyPair& host_port_proxy_pair,
const BoundNetLog& net_log);
// Called by a session when it becomes idle.
void OnIdleSession(QuicClientSession* session);
// Called by a session after it shuts down.
void OnSessionClose(QuicClientSession* session);
// Cancels a pending request.
void CancelRequest(QuicStreamRequest* request);
// Closes all current sessions.
void CloseAllSessions(int error);
base::Value* QuicStreamFactoryInfoToValue() const;
// NetworkChangeNotifier::IPAddressObserver methods:
// Until the servers support roaming, close all connections when the local
// IP address changes.
virtual void OnIPAddressChanged() OVERRIDE;
private:
class Job;
typedef std::map<HostPortProxyPair, QuicClientSession*> SessionMap;
typedef std::set<HostPortProxyPair> AliasSet;
typedef std::map<QuicClientSession*, AliasSet> SessionAliasMap;
typedef std::set<QuicClientSession*> SessionSet;
typedef std::map<HostPortProxyPair, QuicCryptoClientConfig*> CryptoConfigMap;
typedef std::map<HostPortProxyPair, Job*> JobMap;
typedef std::map<QuicStreamRequest*, Job*> RequestMap;
typedef std::set<QuicStreamRequest*> RequestSet;
typedef std::map<Job*, RequestSet> JobRequestsMap;
void OnJobComplete(Job* job, int rv);
bool HasActiveSession(const HostPortProxyPair& host_port_proxy_pair);
bool HasActiveJob(const HostPortProxyPair& host_port_proxy_pair);
QuicClientSession* CreateSession(
const HostPortProxyPair& host_port_proxy_pair,
const AddressList& address_list,
const BoundNetLog& net_log);
void ActivateSession(const HostPortProxyPair& host_port_proxy_pair,
QuicClientSession* session);
QuicCryptoClientConfig* GetOrCreateCryptoConfig(
const HostPortProxyPair& host_port_proxy_pair);
HostResolver* host_resolver_;
ClientSocketFactory* client_socket_factory_;
QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory_;
QuicRandom* random_generator_;
scoped_ptr<QuicClock> clock_;
// Contains owning pointers to all sessions that currently exist.
SessionSet all_sessions_;
// Contains non-owning pointers to currently active session
// (not going away session, once they're implemented).
SessionMap active_sessions_;
SessionAliasMap session_aliases_;
// Contains owning pointers to QuicCryptoClientConfig. QuicCryptoClientConfig
// contains configuration and cached state about servers.
// TODO(rtenneti): Persist all_crypto_configs_ to disk and decide when to
// clear the data in the map.
CryptoConfigMap all_crypto_configs_;
QuicConfig config_;
JobMap active_jobs_;
JobRequestsMap job_requests_map_;
RequestMap active_requests_;
base::WeakPtrFactory<QuicStreamFactory> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(QuicStreamFactory);
};
} // namespace net
#endif // NET_QUIC_QUIC_STREAM_FACTORY_H_
|
