Google Git
Sign in
chromium / chromium / src.git / 41c4a4142135f3710054556a7081ba018c26fd9f / . / net / http / http_transaction_test_util.cc
blob: f8c8460ea6388a532852e90f0f926f0eda73031e [file] [log] [blame]
Avi Drissman64595482022-09-14 20:52:29[diff] [blame]1// Copyright 2014 The Chromium Authors
license.botbf09a502008-08-24 00:55:55[diff] [blame]2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]4
[email protected]c41737d2014-05-14 07:47:19[diff] [blame]5#include "net/http/http_transaction_test_util.h"
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]6
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]7#include <algorithm>
davidben1e912ea2016-04-20 19:17:07[diff] [blame]8#include <unordered_map>
dchengc7eeda422015-12-26 03:56:48[diff] [blame]9#include <utility>
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]10
Avi Drissman41c4a412023-01-11 22:45:37[diff] [blame^]11#include "base/functional/bind.h"
12#include "base/functional/callback_helpers.h"
skyostil4891b25b2015-06-11 11:43:45[diff] [blame]13#include "base/location.h"
bnceb9aa7112017-01-05 01:03:46[diff] [blame]14#include "base/run_loop.h"
[email protected]125ef482013-06-11 18:32:47[diff] [blame]15#include "base/strings/stringprintf.h"
Patrick Monette643cdf62021-10-15 19:13:42[diff] [blame]16#include "base/task/single_thread_task_runner.h"
jkarlinfb1d5172015-01-12 14:10:29[diff] [blame]17#include "base/time/clock.h"
eroman72673782016-11-17 05:59:50[diff] [blame]18#include "base/time/time.h"
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]19#include "net/base/ip_address.h"
20#include "net/base/ip_endpoint.h"
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]21#include "net/base/load_flags.h"
[email protected]3b23a222013-05-15 21:33:25[diff] [blame]22#include "net/base/load_timing_info.h"
[email protected]125ef482013-06-11 18:32:47[diff] [blame]23#include "net/base/net_errors.h"
Shivani Sharma7ef36b82019-10-23 18:33:56[diff] [blame]24#include "net/base/network_isolation_key.h"
Matt Menke4807a9a2020-11-21 00:14:41[diff] [blame]25#include "net/base/schemeful_site.h"
davidben2ec0ed342015-06-08 21:17:28[diff] [blame]26#include "net/cert/x509_certificate.h"
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]27#include "net/disk_cache/disk_cache.h"
28#include "net/http/http_cache.h"
29#include "net/http/http_request_info.h"
30#include "net/http/http_response_info.h"
31#include "net/http/http_transaction.h"
mikecironef22f9812016-10-04 03:40:19[diff] [blame]32#include "net/log/net_log.h"
33#include "net/log/net_log_source.h"
Matt Menkece5d765372021-08-17 18:24:12[diff] [blame]34#include "net/ssl/ssl_private_key.h"
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]35#include "testing/gtest/include/gtest/gtest.h"
Matt Menke4807a9a2020-11-21 00:14:41[diff] [blame]36#include "url/gurl.h"
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]37
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]38namespace net {
39
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]40namespace {
davidben1e912ea2016-04-20 19:17:07[diff] [blame]41using MockTransactionMap =
42 std::unordered_map<std::string, const MockTransaction*>;
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]43static MockTransactionMap mock_transactions;
44} // namespace
45
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]46TransportInfo DefaultTransportInfo() {
47 return TransportInfo(TransportType::kDirect,
Aaron Tagliaboschi603540d22021-04-05 00:37:14[diff] [blame]48 IPEndPoint(IPAddress::IPv4Localhost(), 80), "");
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]49}
50
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]51//-----------------------------------------------------------------------------
52// mock transaction data
53
54const MockTransaction kSimpleGET_Transaction = {
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]55 "http://www.google.com/",
56 "GET",
57 base::Time(),
58 "",
59 LOAD_NORMAL,
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]60 DefaultTransportInfo(),
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]61 "HTTP/1.1 200 OK",
62 "Cache-Control: max-age=10000\n",
63 base::Time(),
64 "<html><body>Google Blah Blah</body></html>",
Cammie Smith Barnesbf91e2a2020-12-23 20:49:04[diff] [blame]65 {},
Shuran Huang6c73e33dc2022-09-27 22:28:41[diff] [blame]66 absl::nullopt,
67 absl::nullopt,
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]68 TEST_MODE_NORMAL,
davidben2ec0ed342015-06-08 21:17:28[diff] [blame]69 nullptr,
70 nullptr,
asankab5fb4b42016-06-29 11:06:08[diff] [blame]71 nullptr,
davidben2ec0ed342015-06-08 21:17:28[diff] [blame]72 0,
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]73 0,
shivanishac6582e12017-07-14 22:18:19[diff] [blame]74 OK,
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]75 OK,
76};
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]77
78const MockTransaction kSimplePOST_Transaction = {
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]79 "http://bugdatabase.com/edit",
80 "POST",
81 base::Time(),
82 "",
83 LOAD_NORMAL,
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]84 DefaultTransportInfo(),
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]85 "HTTP/1.1 200 OK",
86 "",
87 base::Time(),
88 "<html><body>Google Blah Blah</body></html>",
Cammie Smith Barnesbf91e2a2020-12-23 20:49:04[diff] [blame]89 {},
Shuran Huang6c73e33dc2022-09-27 22:28:41[diff] [blame]90 absl::nullopt,
91 absl::nullopt,
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]92 TEST_MODE_NORMAL,
davidben2ec0ed342015-06-08 21:17:28[diff] [blame]93 nullptr,
94 nullptr,
asankab5fb4b42016-06-29 11:06:08[diff] [blame]95 nullptr,
davidben2ec0ed342015-06-08 21:17:28[diff] [blame]96 0,
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]97 0,
shivanishac6582e12017-07-14 22:18:19[diff] [blame]98 OK,
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]99 OK,
100};
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]101
102const MockTransaction kTypicalGET_Transaction = {
shivanishac6582e12017-07-14 22:18:19[diff] [blame]103 "http://www.example.com/~foo/bar.html",
104 "GET",
105 base::Time(),
106 "",
107 LOAD_NORMAL,
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]108 DefaultTransportInfo(),
shivanishac6582e12017-07-14 22:18:19[diff] [blame]109 "HTTP/1.1 200 OK",
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]110 "Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
111 "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n",
shivanishac6582e12017-07-14 22:18:19[diff] [blame]112 base::Time(),
113 "<html><body>Google Blah Blah</body></html>",
Cammie Smith Barnesbf91e2a2020-12-23 20:49:04[diff] [blame]114 {},
Shuran Huang6c73e33dc2022-09-27 22:28:41[diff] [blame]115 absl::nullopt,
116 absl::nullopt,
shivanishac6582e12017-07-14 22:18:19[diff] [blame]117 TEST_MODE_NORMAL,
118 nullptr,
119 nullptr,
120 nullptr,
121 0,
122 0,
123 OK,
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]124 OK,
125};
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]126
127const MockTransaction kETagGET_Transaction = {
shivanishac6582e12017-07-14 22:18:19[diff] [blame]128 "http://www.google.com/foopy",
129 "GET",
130 base::Time(),
131 "",
132 LOAD_NORMAL,
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]133 DefaultTransportInfo(),
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]134 "HTTP/1.1 200 OK",
135 "Cache-Control: max-age=10000\n"
136 "Etag: \"foopy\"\n",
shivanishac6582e12017-07-14 22:18:19[diff] [blame]137 base::Time(),
138 "<html><body>Google Blah Blah</body></html>",
Cammie Smith Barnesbf91e2a2020-12-23 20:49:04[diff] [blame]139 {},
Shuran Huang6c73e33dc2022-09-27 22:28:41[diff] [blame]140 absl::nullopt,
141 absl::nullopt,
shivanishac6582e12017-07-14 22:18:19[diff] [blame]142 TEST_MODE_NORMAL,
143 nullptr,
144 nullptr,
145 nullptr,
146 0,
147 0,
148 OK,
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]149 OK,
150};
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]151
152const MockTransaction kRangeGET_Transaction = {
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]153 "http://www.google.com/",
154 "GET",
155 base::Time(),
156 "Range: 0-100\r\n",
157 LOAD_NORMAL,
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]158 DefaultTransportInfo(),
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]159 "HTTP/1.1 200 OK",
160 "Cache-Control: max-age=10000\n",
161 base::Time(),
162 "<html><body>Google Blah Blah</body></html>",
Cammie Smith Barnesbf91e2a2020-12-23 20:49:04[diff] [blame]163 {},
Shuran Huang6c73e33dc2022-09-27 22:28:41[diff] [blame]164 absl::nullopt,
165 absl::nullopt,
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]166 TEST_MODE_NORMAL,
davidben2ec0ed342015-06-08 21:17:28[diff] [blame]167 nullptr,
168 nullptr,
asankab5fb4b42016-06-29 11:06:08[diff] [blame]169 nullptr,
davidben2ec0ed342015-06-08 21:17:28[diff] [blame]170 0,
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]171 0,
shivanishac6582e12017-07-14 22:18:19[diff] [blame]172 OK,
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]173 OK,
174};
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]175
176static const MockTransaction* const kBuiltinMockTransactions[] = {
177 &kSimpleGET_Transaction,
178 &kSimplePOST_Transaction,
179 &kTypicalGET_Transaction,
180 &kETagGET_Transaction,
181 &kRangeGET_Transaction
182};
183
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]184const MockTransaction* FindMockTransaction(const GURL& url) {
185 // look for overrides:
186 MockTransactionMap::const_iterator it = mock_transactions.find(url.spec());
187 if (it != mock_transactions.end())
188 return it->second;
189
190 // look for builtins:
Tsuyoshi Horo17ef47d02022-06-30 10:58:27[diff] [blame]191 for (const auto* transaction : kBuiltinMockTransactions) {
192 if (url == GURL(transaction->url))
193 return transaction;
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]194 }
asankab5fb4b42016-06-29 11:06:08[diff] [blame]195 return nullptr;
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]196}
197
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]198void AddMockTransaction(const MockTransaction* trans) {
199 mock_transactions[GURL(trans->url).spec()] = trans;
200}
201
202void RemoveMockTransaction(const MockTransaction* trans) {
203 mock_transactions.erase(GURL(trans->url).spec());
204}
205
206MockHttpRequest::MockHttpRequest(const MockTransaction& t) {
207 url = GURL(t.url);
208 method = t.method;
209 extra_headers.AddHeadersFromString(t.request_headers);
210 load_flags = t.load_flags;
Matt Menke4807a9a2020-11-21 00:14:41[diff] [blame]211 SchemefulSite site(url);
212 network_isolation_key = NetworkIsolationKey(site, site);
Brianna Goldstein314ddf722022-09-24 02:00:52[diff] [blame]213 network_anonymization_key = NetworkAnonymizationKey(site, site);
Shuran Huang6c73e33dc2022-09-27 22:28:41[diff] [blame]214 fps_cache_filter = t.fps_cache_filter;
215 browser_run_id = t.browser_run_id;
Shivani Sharma7ef36b82019-10-23 18:33:56[diff] [blame]216}
217
218std::string MockHttpRequest::CacheKey() {
Matt Menke11ffd532022-07-22 00:49:33[diff] [blame]219 return *HttpCache::GenerateCacheKeyForRequest(this);
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]220}
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]221
222//-----------------------------------------------------------------------------
223
224// static
225int TestTransactionConsumer::quit_counter_ = 0;
226
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]227TestTransactionConsumer::TestTransactionConsumer(
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]228 RequestPriority priority,
Tsuyoshi Horoca07e3a2022-06-07 07:37:56[diff] [blame]229 HttpTransactionFactory* factory) {
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]230 // Disregard the error code.
[email protected]027bd85a2013-12-27 22:39:10[diff] [blame]231 factory->CreateTransaction(priority, &trans_);
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]232 ++quit_counter_;
233}
234
Chris Watkins7a41d3552017-12-01 02:13:27[diff] [blame]235TestTransactionConsumer::~TestTransactionConsumer() = default;
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]236
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]237void TestTransactionConsumer::Start(const HttpRequestInfo* request,
tfarina42834112016-09-22 13:38:20[diff] [blame]238 const NetLogWithSource& net_log) {
Peter Kastingd039b772021-08-18 00:06:20[diff] [blame]239 state_ = State::kStarting;
Yannic Bonenbergercc716d42019-09-04 17:05:36[diff] [blame]240 int result =
241 trans_->Start(request,
242 base::BindOnce(&TestTransactionConsumer::OnIOComplete,
243 base::Unretained(this)),
244 net_log);
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]245 if (result != ERR_IO_PENDING)
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]246 DidStart(result);
247}
248
249void TestTransactionConsumer::DidStart(int result) {
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]250 if (result != OK) {
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]251 DidFinish(result);
252 } else {
253 Read();
254 }
255}
256
257void TestTransactionConsumer::DidRead(int result) {
258 if (result <= 0) {
259 DidFinish(result);
260 } else {
261 content_.append(read_buf_->data(), result);
262 Read();
263 }
264}
265
266void TestTransactionConsumer::DidFinish(int result) {
Peter Kastingd039b772021-08-18 00:06:20[diff] [blame]267 state_ = State::kDone;
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]268 error_ = result;
269 if (--quit_counter_ == 0)
Gabriel Charette53a9ef812017-07-26 12:36:23[diff] [blame]270 base::RunLoop::QuitCurrentWhenIdleDeprecated();
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]271}
272
273void TestTransactionConsumer::Read() {
Peter Kastingd039b772021-08-18 00:06:20[diff] [blame]274 state_ = State::kReading;
Victor Costan9c7302b2018-08-27 16:39:44[diff] [blame]275 read_buf_ = base::MakeRefCounted<IOBuffer>(1024);
Yannic Bonenbergercc716d42019-09-04 17:05:36[diff] [blame]276 int result =
277 trans_->Read(read_buf_.get(), 1024,
278 base::BindOnce(&TestTransactionConsumer::OnIOComplete,
279 base::Unretained(this)));
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]280 if (result != ERR_IO_PENDING)
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]281 DidRead(result);
282}
283
[email protected]b35f629f2011-12-23 02:53:32[diff] [blame]284void TestTransactionConsumer::OnIOComplete(int result) {
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]285 switch (state_) {
Peter Kastingd039b772021-08-18 00:06:20[diff] [blame]286 case State::kStarting:
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]287 DidStart(result);
288 break;
Peter Kastingd039b772021-08-18 00:06:20[diff] [blame]289 case State::kReading:
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]290 DidRead(result);
291 break;
292 default:
293 NOTREACHED();
294 }
295}
296
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]297MockNetworkTransaction::MockNetworkTransaction(RequestPriority priority,
298 MockNetworkLayer* factory)
Tsuyoshi Horo432981d52022-06-09 09:50:13[diff] [blame]299 : priority_(priority), transaction_factory_(factory->AsWeakPtr()) {}
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]300
shivanishaa71773ef2017-06-16 23:35:01[diff] [blame]301MockNetworkTransaction::~MockNetworkTransaction() {
302 // Use request_ as in ~HttpNetworkTransaction to make sure its valid and not
Shivani Sharma864513b42017-10-25 21:14:55[diff] [blame]303 // already freed by the consumer. Only check till Read is invoked since
304 // HttpNetworkTransaction sets request_ to nullptr when Read is invoked.
305 // See crbug.com/734037.
306 if (request_ && !reading_)
shivanishaa71773ef2017-06-16 23:35:01[diff] [blame]307 DCHECK(request_->load_flags >= 0);
308}
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]309
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]310int MockNetworkTransaction::Start(const HttpRequestInfo* request,
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]311 CompletionOnceCallback callback,
tfarina42834112016-09-22 13:38:20[diff] [blame]312 const NetLogWithSource& net_log) {
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]313 if (request_)
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]314 return ERR_FAILED;
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]315
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]316 request_ = request;
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]317 return StartInternal(request, std::move(callback), net_log);
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]318}
319
320int MockNetworkTransaction::RestartIgnoringLastError(
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]321 CompletionOnceCallback callback) {
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]322 return ERR_FAILED;
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]323}
324
325int MockNetworkTransaction::RestartWithCertificate(
mattm436ccfe2017-06-19 20:24:08[diff] [blame]326 scoped_refptr<X509Certificate> client_cert,
327 scoped_refptr<SSLPrivateKey> client_private_key,
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]328 CompletionOnceCallback callback) {
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]329 return ERR_FAILED;
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]330}
331
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]332int MockNetworkTransaction::RestartWithAuth(const AuthCredentials& credentials,
333 CompletionOnceCallback callback) {
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]334 if (!IsReadyToRestartForAuth())
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]335 return ERR_FAILED;
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]336
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]337 HttpRequestInfo auth_request_info = *request_;
ricea9965adea2016-09-13 03:41:37[diff] [blame]338 auth_request_info.extra_headers.SetHeader("Authorization", "Bar");
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]339
340 // Let the MockTransactionHandler worry about this: the only way for this
341 // test to succeed is by using an explicit handler for the transaction so
342 // that server behavior can be simulated.
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]343 return StartInternal(&auth_request_info, std::move(callback),
344 NetLogWithSource());
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]345}
346
zhongyi48704c182015-12-07 07:52:02[diff] [blame]347void MockNetworkTransaction::PopulateNetErrorDetails(
zhongyica364fbb2015-12-12 03:39:12[diff] [blame]348 NetErrorDetails* /*details*/) const {
zhongyi48704c182015-12-07 07:52:02[diff] [blame]349 NOTIMPLEMENTED();
350}
351
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]352bool MockNetworkTransaction::IsReadyToRestartForAuth() {
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]353 if (!request_)
354 return false;
355
ricea64c07d792014-10-08 03:37:00[diff] [blame]356 if (!request_->extra_headers.HasHeader("X-Require-Mock-Auth"))
357 return false;
358
359 // Allow the mock server to decide whether authentication is required or not.
360 std::string status_line = response_.headers->GetStatusLine();
361 return status_line.find(" 401 ") != std::string::npos ||
362 status_line.find(" 407 ") != std::string::npos;
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]363}
364
asankab5fb4b42016-06-29 11:06:08[diff] [blame]365int MockNetworkTransaction::Read(net::IOBuffer* buf,
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]366 int buf_len,
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]367 CompletionOnceCallback callback) {
shivanishac6582e12017-07-14 22:18:19[diff] [blame]368 const MockTransaction* t = FindMockTransaction(request_->url);
369 DCHECK(t);
370
xunjieli26ede962015-11-23 19:39:13[diff] [blame]371 CHECK(!done_reading_called_);
Shivani Sharma864513b42017-10-25 21:14:55[diff] [blame]372 reading_ = true;
shivanishac6582e12017-07-14 22:18:19[diff] [blame]373
374 int num = t->read_return_code;
375
376 if (OK == num) {
377 if (read_handler_) {
378 num = (*read_handler_)(content_length_, data_cursor_, buf, buf_len);
asankab5fb4b42016-06-29 11:06:08[diff] [blame]379 data_cursor_ += num;
shivanishac6582e12017-07-14 22:18:19[diff] [blame]380 } else {
381 int data_len = static_cast<int>(data_.size());
382 num = std::min(static_cast<int64_t>(buf_len), data_len - data_cursor_);
383 if (test_mode_ & TEST_MODE_SLOW_READ)
384 num = std::min(num, 1);
385 if (num) {
386 memcpy(buf->data(), data_.data() + data_cursor_, num);
387 data_cursor_ += num;
388 }
asankab5fb4b42016-06-29 11:06:08[diff] [blame]389 }
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]390 }
shivanishac6582e12017-07-14 22:18:19[diff] [blame]391
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]392 if (test_mode_ & TEST_MODE_SYNC_NET_READ)
393 return num;
394
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]395 CallbackLater(std::move(callback), num);
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]396 return ERR_IO_PENDING;
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]397}
398
[email protected]e50efea2014-03-24 18:41:00[diff] [blame]399void MockNetworkTransaction::StopCaching() {
400 if (transaction_factory_.get())
401 transaction_factory_->TransactionStopCaching();
402}
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]403
sclittle4de1bab92015-09-22 21:28:24[diff] [blame]404int64_t MockNetworkTransaction::GetTotalReceivedBytes() const {
[email protected]b8015c42013-12-24 15:18:19[diff] [blame]405 return received_bytes_;
406}
407
sclittlefb249892015-09-10 21:33:22[diff] [blame]408int64_t MockNetworkTransaction::GetTotalSentBytes() const {
409 return sent_bytes_;
410}
411
[email protected]5c04f722011-08-12 17:52:47[diff] [blame]412void MockNetworkTransaction::DoneReading() {
xunjieli26ede962015-11-23 19:39:13[diff] [blame]413 CHECK(!done_reading_called_);
414 done_reading_called_ = true;
[email protected]11fbca0b2013-06-02 23:37:21[diff] [blame]415 if (transaction_factory_.get())
[email protected]5c04f722011-08-12 17:52:47[diff] [blame]416 transaction_factory_->TransactionDoneReading();
417}
418
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]419const HttpResponseInfo* MockNetworkTransaction::GetResponseInfo() const {
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]420 return &response_;
421}
422
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]423LoadState MockNetworkTransaction::GetLoadState() const {
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]424 if (data_cursor_)
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]425 return LOAD_STATE_READING_RESPONSE;
426 return LOAD_STATE_IDLE;
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]427}
428
[email protected]8cd06c02014-01-25 07:50:14[diff] [blame]429void MockNetworkTransaction::SetQuicServerInfo(
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]430 QuicServerInfo* quic_server_info) {
431}
[email protected]8cd06c02014-01-25 07:50:14[diff] [blame]432
[email protected]58e32bb2013-01-21 18:23:25[diff] [blame]433bool MockNetworkTransaction::GetLoadTimingInfo(
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]434 LoadTimingInfo* load_timing_info) const {
mikecironef22f9812016-10-04 03:40:19[diff] [blame]435 if (socket_log_id_ != NetLogSource::kInvalidId) {
[email protected]3b23a222013-05-15 21:33:25[diff] [blame]436 // The minimal set of times for a request that gets a response, assuming it
437 // gets a new socket.
438 load_timing_info->socket_reused = false;
439 load_timing_info->socket_log_id = socket_log_id_;
eroman72673782016-11-17 05:59:50[diff] [blame]440 load_timing_info->connect_timing.connect_start = base::TimeTicks::Now();
441 load_timing_info->connect_timing.connect_end = base::TimeTicks::Now();
442 load_timing_info->send_start = base::TimeTicks::Now();
443 load_timing_info->send_end = base::TimeTicks::Now();
[email protected]3b23a222013-05-15 21:33:25[diff] [blame]444 } else {
445 // If there's no valid socket ID, just use the generic socket reused values.
446 // No tests currently depend on this, just should not match the values set
447 // by a cache hit.
448 load_timing_info->socket_reused = true;
eroman72673782016-11-17 05:59:50[diff] [blame]449 load_timing_info->send_start = base::TimeTicks::Now();
450 load_timing_info->send_end = base::TimeTicks::Now();
[email protected]3b23a222013-05-15 21:33:25[diff] [blame]451 }
452 return true;
[email protected]58e32bb2013-01-21 18:23:25[diff] [blame]453}
454
ttuttled9dbc652015-09-29 20:00:59[diff] [blame]455bool MockNetworkTransaction::GetRemoteEndpoint(IPEndPoint* endpoint) const {
tfarinaa3dd7aa2016-02-25 08:15:44[diff] [blame]456 *endpoint = IPEndPoint(IPAddress(127, 0, 0, 1), 80);
ttuttled9dbc652015-09-29 20:00:59[diff] [blame]457 return true;
458}
459
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]460void MockNetworkTransaction::SetPriority(RequestPriority priority) {
[email protected]5033ab82013-03-22 20:17:46[diff] [blame]461 priority_ = priority;
462}
463
[email protected]831e4a32013-11-14 02:14:44[diff] [blame]464void MockNetworkTransaction::SetWebSocketHandshakeStreamCreateHelper(
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]465 WebSocketHandshakeStreamBase::CreateHelper* create_helper) {
[email protected]831e4a32013-11-14 02:14:44[diff] [blame]466 websocket_handshake_stream_create_helper_ = create_helper;
467}
468
sclittlefb249892015-09-10 21:33:22[diff] [blame]469// static
470const int64_t MockNetworkTransaction::kTotalReceivedBytes = 1000;
471
472// static
473const int64_t MockNetworkTransaction::kTotalSentBytes = 100;
474
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]475int MockNetworkTransaction::StartInternal(const HttpRequestInfo* request,
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]476 CompletionOnceCallback callback,
tfarina42834112016-09-22 13:38:20[diff] [blame]477 const NetLogWithSource& net_log) {
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]478 const MockTransaction* t = FindMockTransaction(request->url);
479 if (!t)
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]480 return ERR_FAILED;
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]481
482 test_mode_ = t->test_mode;
483
484 // Return immediately if we're returning an error.
shivanishac6582e12017-07-14 22:18:19[diff] [blame]485 if (OK != t->start_return_code) {
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]486 if (test_mode_ & TEST_MODE_SYNC_NET_START)
shivanishac6582e12017-07-14 22:18:19[diff] [blame]487 return t->start_return_code;
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]488 CallbackLater(std::move(callback), t->start_return_code);
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]489 return ERR_IO_PENDING;
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]490 }
491
sclittlefb249892015-09-10 21:33:22[diff] [blame]492 sent_bytes_ = kTotalSentBytes;
493 received_bytes_ = kTotalReceivedBytes;
494
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]495 std::string resp_status = t->status;
496 std::string resp_headers = t->response_headers;
497 std::string resp_data = t->data;
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]498 if (t->handler)
499 (t->handler)(request, &resp_status, &resp_headers, &resp_data);
asankab5fb4b42016-06-29 11:06:08[diff] [blame]500 if (t->read_handler)
501 read_handler_ = t->read_handler;
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]502
503 std::string header_data = base::StringPrintf(
504 "%s\n%s\n", resp_status.c_str(), resp_headers.c_str());
505 std::replace(header_data.begin(), header_data.end(), '\n', '\0');
506
jkarlinfb1d5172015-01-12 14:10:29[diff] [blame]507 response_.request_time = transaction_factory_->Now();
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]508 if (!t->request_time.is_null())
509 response_.request_time = t->request_time;
510
511 response_.was_cached = false;
512 response_.network_accessed = true;
Titouan Rigoudy52a55082022-04-11 20:06:34[diff] [blame]513 response_.remote_endpoint = t->transport_info.endpoint;
Titouan Rigoudy4ba5aa22022-06-08 19:14:28[diff] [blame]514 response_.was_fetched_via_proxy =
515 t->transport_info.type == TransportType::kProxied;
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]516
jkarlinfb1d5172015-01-12 14:10:29[diff] [blame]517 response_.response_time = transaction_factory_->Now();
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]518 if (!t->response_time.is_null())
519 response_.response_time = t->response_time;
520
Tsuyoshi Horo2c0a5042022-07-06 05:53:07[diff] [blame]521 response_.headers = base::MakeRefCounted<HttpResponseHeaders>(header_data);
davidben2ec0ed342015-06-08 21:17:28[diff] [blame]522 response_.ssl_info.cert = t->cert;
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]523 response_.ssl_info.cert_status = t->cert_status;
davidben2ec0ed342015-06-08 21:17:28[diff] [blame]524 response_.ssl_info.connection_status = t->ssl_connection_status;
Cammie Smith Barnesbf91e2a2020-12-23 20:49:04[diff] [blame]525 response_.dns_aliases = t->dns_aliases;
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]526 data_ = resp_data;
asankab5fb4b42016-06-29 11:06:08[diff] [blame]527 content_length_ = response_.headers->GetContentLength();
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]528
529 if (net_log.net_log())
530 socket_log_id_ = net_log.net_log()->NextID();
531
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]532 if (request_->load_flags & LOAD_PREFETCH)
jkarlinfb1d5172015-01-12 14:10:29[diff] [blame]533 response_.unused_since_prefetch = true;
534
Dominic Farolino4ecaf0a2019-08-16 06:40:09[diff] [blame]535 if (request_->load_flags & LOAD_RESTRICTED_PREFETCH) {
536 DCHECK(response_.unused_since_prefetch);
537 response_.restricted_prefetch = true;
538 }
539
shivanisha8061c4202017-06-13 23:35:52[diff] [blame]540 // Pause and resume.
541 if (!before_network_start_callback_.is_null()) {
542 bool defer = false;
Will Cassella61125f92020-07-25 09:11:37[diff] [blame]543 std::move(before_network_start_callback_).Run(&defer);
shivanisha8061c4202017-06-13 23:35:52[diff] [blame]544 if (defer) {
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]545 resume_start_callback_ = std::move(callback);
shivanisha8061c4202017-06-13 23:35:52[diff] [blame]546 return net::ERR_IO_PENDING;
547 }
548 }
549
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]550 if (test_mode_ & TEST_MODE_SYNC_NET_START)
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]551 return OK;
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]552
Titouan Rigoudyed46e0c2020-07-09 14:42:44[diff] [blame]553 int result = OK;
554 if (!connected_callback_.is_null()) {
Daniel Chenge0fc4632021-10-01 00:37:41[diff] [blame]555 result = connected_callback_.Run(t->transport_info, base::DoNothing());
Titouan Rigoudyed46e0c2020-07-09 14:42:44[diff] [blame]556 }
557
558 CallbackLater(std::move(callback), result);
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]559 return ERR_IO_PENDING;
[email protected]d7358ba2014-01-04 01:39:49[diff] [blame]560}
561
[email protected]1826a402014-01-08 15:40:48[diff] [blame]562void MockNetworkTransaction::SetBeforeNetworkStartCallback(
Will Cassella61125f92020-07-25 09:11:37[diff] [blame]563 BeforeNetworkStartCallback callback) {
564 before_network_start_callback_ = std::move(callback);
[email protected]1826a402014-01-08 15:40:48[diff] [blame]565}
566
Titouan Rigoudy78af7da2020-07-07 14:30:12[diff] [blame]567void MockNetworkTransaction::SetConnectedCallback(
Titouan Rigoudyed46e0c2020-07-09 14:42:44[diff] [blame]568 const ConnectedCallback& callback) {
569 connected_callback_ = callback;
570}
Titouan Rigoudy78af7da2020-07-07 14:30:12[diff] [blame]571
[email protected]1826a402014-01-08 15:40:48[diff] [blame]572int MockNetworkTransaction::ResumeNetworkStart() {
shivanisha8061c4202017-06-13 23:35:52[diff] [blame]573 DCHECK(!resume_start_callback_.is_null());
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]574 CallbackLater(std::move(resume_start_callback_), OK);
shivanisha8061c4202017-06-13 23:35:52[diff] [blame]575 return ERR_IO_PENDING;
[email protected]1826a402014-01-08 15:40:48[diff] [blame]576}
577
David Benjamin3c19a2ed2022-04-09 21:58:27[diff] [blame]578ConnectionAttempts MockNetworkTransaction::GetConnectionAttempts() const {
Adam Rice4b6fb1132022-05-21 08:05:01[diff] [blame]579 // TODO(ricea): Replace this with a proper implementation if needed.
David Benjamin3c19a2ed2022-04-09 21:58:27[diff] [blame]580 return {};
ttuttle1f2d7e92015-04-28 16:17:47[diff] [blame]581}
582
Matt Menke2451c8b2020-12-08 22:42:51[diff] [blame]583void MockNetworkTransaction::CloseConnectionOnDestruction() {
584 NOTIMPLEMENTED();
585}
586
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]587void MockNetworkTransaction::CallbackLater(CompletionOnceCallback callback,
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]588 int result) {
Sean Maher5b9af51f2022-11-21 15:32:47[diff] [blame]589 base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]590 FROM_HERE,
591 base::BindOnce(&MockNetworkTransaction::RunCallback,
592 weak_factory_.GetWeakPtr(), std::move(callback), result));
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]593}
594
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]595void MockNetworkTransaction::RunCallback(CompletionOnceCallback callback,
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]596 int result) {
Bence Béky046f8c82018-06-12 02:26:04[diff] [blame]597 std::move(callback).Run(result);
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]598}
599
Tsuyoshi Horoca07e3a2022-06-07 07:37:56[diff] [blame]600MockNetworkLayer::MockNetworkLayer() = default;
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]601
Chris Watkins7a41d3552017-12-01 02:13:27[diff] [blame]602MockNetworkLayer::~MockNetworkLayer() = default;
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]603
[email protected]5c04f722011-08-12 17:52:47[diff] [blame]604void MockNetworkLayer::TransactionDoneReading() {
xunjieli26ede962015-11-23 19:39:13[diff] [blame]605 CHECK(!done_reading_called_);
[email protected]5c04f722011-08-12 17:52:47[diff] [blame]606 done_reading_called_ = true;
607}
608
[email protected]e50efea2014-03-24 18:41:00[diff] [blame]609void MockNetworkLayer::TransactionStopCaching() {
610 stop_caching_called_ = true;
611}
612
asankab5fb4b42016-06-29 11:06:08[diff] [blame]613void MockNetworkLayer::ResetTransactionCount() {
614 transaction_count_ = 0;
615}
616
danakj1fd259a02016-04-16 03:17:09[diff] [blame]617int MockNetworkLayer::CreateTransaction(
618 RequestPriority priority,
619 std::unique_ptr<HttpTransaction>* trans) {
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]620 transaction_count_++;
[email protected]5033ab82013-03-22 20:17:46[diff] [blame]621 last_create_transaction_priority_ = priority;
Tsuyoshi Horof8861cb2022-07-05 23:50:20[diff] [blame]622 auto mock_transaction =
623 std::make_unique<MockNetworkTransaction>(priority, this);
[email protected]5033ab82013-03-22 20:17:46[diff] [blame]624 last_transaction_ = mock_transaction->AsWeakPtr();
dchengc7eeda422015-12-26 03:56:48[diff] [blame]625 *trans = std::move(mock_transaction);
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]626 return OK;
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]627}
628
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]629HttpCache* MockNetworkLayer::GetCache() {
Raul Tambre94493c652019-03-11 17:18:35[diff] [blame]630 return nullptr;
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]631}
632
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]633HttpNetworkSession* MockNetworkLayer::GetSession() {
Raul Tambre94493c652019-03-11 17:18:35[diff] [blame]634 return nullptr;
[email protected]d2db0292011-01-26 20:23:44[diff] [blame]635}
636
jkarlinfb1d5172015-01-12 14:10:29[diff] [blame]637void MockNetworkLayer::SetClock(base::Clock* clock) {
638 DCHECK(!clock_);
639 clock_ = clock;
640}
641
642base::Time MockNetworkLayer::Now() {
643 if (clock_)
644 return clock_->Now();
645 return base::Time::Now();
646}
647
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]648//-----------------------------------------------------------------------------
649// helpers
650
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]651int ReadTransaction(HttpTransaction* trans, std::string* result) {
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]652 int rv;
653
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]654 std::string content;
655 do {
Mario Sanchez Prada21c85a32019-03-27 19:23:58[diff] [blame]656 TestCompletionCallback callback;
Victor Costan9c7302b2018-08-27 16:39:44[diff] [blame]657 scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(256);
[email protected]90499482013-06-01 00:39:50[diff] [blame]658 rv = trans->Read(buf.get(), 256, callback.callback());
bnceb9aa7112017-01-05 01:03:46[diff] [blame]659 if (rv == ERR_IO_PENDING) {
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]660 rv = callback.WaitForResult();
bnceb9aa7112017-01-05 01:03:46[diff] [blame]661 base::RunLoop().RunUntilIdle();
662 }
[email protected]49639fa2011-12-20 23:22:41[diff] [blame]663
664 if (rv > 0)
[email protected]9dea9e1f2009-01-29 00:30:47[diff] [blame]665 content.append(buf->data(), rv);
[email protected]49639fa2011-12-20 23:22:41[diff] [blame]666 else if (rv < 0)
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]667 return rv;
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]668 } while (rv > 0);
669
670 result->swap(content);
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]671 return OK;
initial.commit586acc5fe2008-07-26 22:42:52[diff] [blame]672}
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]673
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]674//-----------------------------------------------------------------------------
675// connected callback handler
676
677ConnectedHandler::ConnectedHandler() = default;
678ConnectedHandler::~ConnectedHandler() = default;
679
680ConnectedHandler::ConnectedHandler(const ConnectedHandler&) = default;
681ConnectedHandler& ConnectedHandler::operator=(const ConnectedHandler&) =
682 default;
683ConnectedHandler::ConnectedHandler(ConnectedHandler&&) = default;
684ConnectedHandler& ConnectedHandler::operator=(ConnectedHandler&&) = default;
685
Aaron Tagliaboschib35cc402021-03-10 22:23:32[diff] [blame]686int ConnectedHandler::OnConnected(const TransportInfo& info,
687 CompletionOnceCallback callback) {
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]688 transports_.push_back(info);
Aaron Tagliaboschib35cc402021-03-10 22:23:32[diff] [blame]689 if (run_callback_) {
Sean Maher5b9af51f2022-11-21 15:32:47[diff] [blame]690 base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
Aaron Tagliaboschib35cc402021-03-10 22:23:32[diff] [blame]691 FROM_HERE, base::BindOnce(std::move(callback), result_));
692 return net::ERR_IO_PENDING;
693 }
Titouan Rigoudyba507a882020-07-31 12:15:15[diff] [blame]694 return result_;
695}
696
ttuttle859dc7a2015-04-23 19:42:29[diff] [blame]697} // namespace net