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
|
// 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.
#include "net/http/http_basic_stream.h"
#include <utility>
#include "net/http/http_raw_request_headers.h"
#include "net/http/http_request_info.h"
#include "net/http/http_response_body_drainer.h"
#include "net/http/http_stream_parser.h"
#include "net/socket/client_socket_handle.h"
#include "net/traffic_annotation/network_traffic_annotation.h"
namespace net {
HttpBasicStream::HttpBasicStream(std::unique_ptr<ClientSocketHandle> connection,
bool using_proxy,
bool http_09_on_non_default_ports_enabled)
: state_(std::move(connection),
using_proxy,
http_09_on_non_default_ports_enabled) {}
HttpBasicStream::~HttpBasicStream() = default;
int HttpBasicStream::InitializeStream(const HttpRequestInfo* request_info,
bool can_send_early,
RequestPriority priority,
const NetLogWithSource& net_log,
const CompletionCallback& callback) {
state_.Initialize(request_info, can_send_early, priority, net_log, callback);
return OK;
}
int HttpBasicStream::SendRequest(const HttpRequestHeaders& headers,
HttpResponseInfo* response,
const CompletionCallback& callback) {
DCHECK(parser());
if (request_headers_callback_) {
HttpRawRequestHeaders raw_headers;
raw_headers.set_request_line(state_.GenerateRequestLine());
for (net::HttpRequestHeaders::Iterator it(headers); it.GetNext();)
raw_headers.Add(it.name(), it.value());
request_headers_callback_.Run(std::move(raw_headers));
}
// TODO(crbug.com/656607): Add propoer annotation.
return parser()->SendRequest(state_.GenerateRequestLine(), headers,
NO_TRAFFIC_ANNOTATION_BUG_656607, response,
callback);
}
int HttpBasicStream::ReadResponseHeaders(const CompletionCallback& callback) {
return parser()->ReadResponseHeaders(callback);
}
int HttpBasicStream::ReadResponseBody(IOBuffer* buf,
int buf_len,
const CompletionCallback& callback) {
return parser()->ReadResponseBody(buf, buf_len, callback);
}
void HttpBasicStream::Close(bool not_reusable) {
// parser() is null if |this| is created by an orphaned
// HttpStreamFactoryImpl::Job in which case InitializeStream() will not have
// been called.
if (parser())
parser()->Close(not_reusable);
}
HttpStream* HttpBasicStream::RenewStreamForAuth() {
DCHECK(IsResponseBodyComplete());
DCHECK(!parser()->IsMoreDataBuffered());
// The HttpStreamParser object still has a pointer to the connection. Just to
// be extra-sure it doesn't touch the connection again, delete it here rather
// than leaving it until the destructor is called.
state_.DeleteParser();
return new HttpBasicStream(state_.ReleaseConnection(), state_.using_proxy(),
state_.http_09_on_non_default_ports_enabled());
}
bool HttpBasicStream::IsResponseBodyComplete() const {
return parser()->IsResponseBodyComplete();
}
bool HttpBasicStream::IsConnectionReused() const {
return parser()->IsConnectionReused();
}
void HttpBasicStream::SetConnectionReused() { parser()->SetConnectionReused(); }
bool HttpBasicStream::CanReuseConnection() const {
return parser()->CanReuseConnection();
}
int64_t HttpBasicStream::GetTotalReceivedBytes() const {
if (parser())
return parser()->received_bytes();
return 0;
}
int64_t HttpBasicStream::GetTotalSentBytes() const {
if (parser())
return parser()->sent_bytes();
return 0;
}
bool HttpBasicStream::GetLoadTimingInfo(
LoadTimingInfo* load_timing_info) const {
return state_.connection()->GetLoadTimingInfo(IsConnectionReused(),
load_timing_info);
}
bool HttpBasicStream::GetAlternativeService(
AlternativeService* alternative_service) const {
return false;
}
void HttpBasicStream::GetSSLInfo(SSLInfo* ssl_info) {
parser()->GetSSLInfo(ssl_info);
}
void HttpBasicStream::GetSSLCertRequestInfo(
SSLCertRequestInfo* cert_request_info) {
parser()->GetSSLCertRequestInfo(cert_request_info);
}
bool HttpBasicStream::GetRemoteEndpoint(IPEndPoint* endpoint) {
if (!state_.connection() || !state_.connection()->socket())
return false;
return state_.connection()->socket()->GetPeerAddress(endpoint) == OK;
}
Error HttpBasicStream::GetTokenBindingSignature(crypto::ECPrivateKey* key,
TokenBindingType tb_type,
std::vector<uint8_t>* out) {
return parser()->GetTokenBindingSignature(key, tb_type, out);
}
void HttpBasicStream::Drain(HttpNetworkSession* session) {
HttpResponseBodyDrainer* drainer = new HttpResponseBodyDrainer(this);
drainer->Start(session);
// |drainer| will delete itself.
}
void HttpBasicStream::PopulateNetErrorDetails(NetErrorDetails* details) {
// TODO(mmenke): Consumers don't actually care about HTTP version, but seems
// like the right version should be reported, if headers were received.
details->connection_info = HttpResponseInfo::CONNECTION_INFO_HTTP1_1;
return;
}
void HttpBasicStream::SetPriority(RequestPriority priority) {
// TODO(akalin): Plumb this through to |connection_|.
}
void HttpBasicStream::SetRequestHeadersCallback(
RequestHeadersCallback callback) {
request_headers_callback_ = std::move(callback);
}
} // namespace net
|
