blob: 485dd7a604bffd5cfc17c99e10d153f1bb21fd47 [file] [log] [blame]
Avi Drissman64595482022-09-14 20:52:291// Copyright 2012 The Chromium Authors
[email protected]9b9ae9552010-07-01 22:20:502// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
[email protected]677c90572008-12-10 09:03:154
Lily Houghton582d4622018-01-22 22:43:405#include "net/proxy_resolution/pac_file_fetcher_impl.h"
[email protected]677c90572008-12-10 09:03:156
7#include "base/compiler_specific.h"
Avi Drissman41c4a412023-01-11 22:45:378#include "base/functional/bind.h"
skyostil4891b25b2015-06-11 11:43:459#include "base/location.h"
[email protected]13a279e2009-04-13 17:32:3710#include "base/logging.h"
Gabriel Charette9f60dd12020-03-06 20:48:0411#include "base/memory/ptr_util.h"
asvitkine30330812016-08-30 04:01:0812#include "base/metrics/histogram_macros.h"
Dan McArdlee7ff5d92022-05-27 21:46:5013#include "base/ranges/algorithm.h"
14#include "base/strings/string_piece.h"
[email protected]fc9be5802013-06-11 10:56:5115#include "base/strings/string_util.h"
Patrick Monette643cdf62021-10-15 19:13:4216#include "base/task/single_thread_task_runner.h"
[email protected]d9d71e082011-02-16 11:44:2817#include "net/base/data_url.h"
[email protected]9dea9e1f2009-01-29 00:30:4718#include "net/base/io_buffer.h"
[email protected]677c90572008-12-10 09:03:1519#include "net/base/load_flags.h"
[email protected]597cf6e2009-05-29 09:43:2620#include "net/base/net_errors.h"
[email protected]de362402014-05-10 18:32:4721#include "net/base/net_string_util.h"
[email protected]2ca01e52013-10-31 22:05:1922#include "net/base/request_priority.h"
[email protected]6e7845ae2013-03-29 21:48:1123#include "net/cert/cert_status_flags.h"
[email protected]e0ef2c22009-06-03 23:54:4424#include "net/http/http_response_headers.h"
Eric Romanab9fc652018-05-08 01:59:5325#include "net/url_request/redirect_info.h"
[email protected]86933612010-10-16 23:10:3326#include "net/url_request/url_request_context.h"
[email protected]677c90572008-12-10 09:03:1527
[email protected]f0a51fb52009-03-05 12:46:3828// TODO(eroman):
[email protected]33abb682011-03-29 03:58:4229// - Support auth-prompts (http://crbug.com/77366)
[email protected]677c90572008-12-10 09:03:1530
31namespace net {
32
33namespace {
34
35// The maximum size (in bytes) allowed for a PAC script. Responses exceeding
36// this will fail with ERR_FILE_TOO_BIG.
[email protected]86933612010-10-16 23:10:3337const int kDefaultMaxResponseBytes = 1048576; // 1 megabyte
[email protected]677c90572008-12-10 09:03:1538
39// The maximum duration (in milliseconds) allowed for fetching the PAC script.
40// Responses exceeding this will fail with ERR_TIMED_OUT.
Eric Romancdb1d1c2018-01-03 21:17:0841//
42// This timeout applies to both scripts fetched in the course of WPAD, as well
43// as explicitly configured ones.
44//
45// If the default timeout is too high, auto-detect can stall for a long time,
46// and if it is too low then slow loading scripts may be skipped.
47//
48// 30 seconds is a compromise between those competing goals. This value also
49// appears to match Microsoft Edge (based on testing).
Peter Kastinge5a38ed2021-10-02 03:06:3550constexpr base::TimeDelta kDefaultMaxDuration = base::Seconds(30);
[email protected]677c90572008-12-10 09:03:1551
[email protected]13a279e2009-04-13 17:32:3752// Returns true if |mime_type| is one of the known PAC mime type.
Dan McArdlee7ff5d92022-05-27 21:46:5053constexpr bool IsPacMimeType(base::StringPiece mime_type) {
54 constexpr base::StringPiece kSupportedPacMimeTypes[] = {
55 "application/x-ns-proxy-autoconfig",
56 "application/x-javascript-config",
[email protected]13a279e2009-04-13 17:32:3757 };
Dan McArdlee7ff5d92022-05-27 21:46:5058 return base::ranges::any_of(kSupportedPacMimeTypes, [&](auto pac_mime_type) {
59 return base::EqualsCaseInsensitiveASCII(pac_mime_type, mime_type);
60 });
[email protected]13a279e2009-04-13 17:32:3761}
62
Eric Roman598760f2018-10-12 01:30:4163struct BomMapping {
64 base::StringPiece prefix;
65 const char* charset;
66};
67
68const BomMapping kBomMappings[] = {
69 {"\xFE\xFF", "utf-16be"},
70 {"\xFF\xFE", "utf-16le"},
71 {"\xEF\xBB\xBF", "utf-8"},
72};
73
[email protected]9b9ae9552010-07-01 22:20:5074// Converts |bytes| (which is encoded by |charset|) to UTF16, saving the resul
75// to |*utf16|.
[email protected]8f3c96342009-09-22 03:06:5476// If |charset| is empty, then we don't know what it was and guess.
[email protected]9b9ae9552010-07-01 22:20:5077void ConvertResponseToUTF16(const std::string& charset,
78 const std::string& bytes,
Jan Wilken Dörrie739ccc212021-03-11 18:13:0579 std::u16string* utf16) {
[email protected]8f3c96342009-09-22 03:06:5480 if (charset.empty()) {
Eric Roman598760f2018-10-12 01:30:4181 // Guess the charset by looking at the BOM.
82 base::StringPiece bytes_str(bytes);
83 for (const auto& bom : kBomMappings) {
Jan Wilken Dörrief05bb102020-08-18 19:35:5684 if (base::StartsWith(bytes_str, bom.prefix)) {
Eric Roman598760f2018-10-12 01:30:4185 return ConvertResponseToUTF16(
86 bom.charset,
87 // Strip the BOM in the converted response.
88 bytes.substr(bom.prefix.size()), utf16);
89 }
90 }
91
92 // Otherwise assume ISO-8859-1 if no charset was specified.
93 return ConvertResponseToUTF16(kCharsetLatin1, bytes, utf16);
[email protected]8f3c96342009-09-22 03:06:5494 }
95
Eric Roman598760f2018-10-12 01:30:4196 DCHECK(!charset.empty());
97
[email protected]de362402014-05-10 18:32:4798 // Be generous in the conversion -- if any characters lie outside of |charset|
99 // (i.e. invalid), then substitute them with U+FFFD rather than failing.
Eric Roman598760f2018-10-12 01:30:41100 ConvertToUTF16WithSubstitutions(bytes, charset.c_str(), utf16);
[email protected]8f3c96342009-09-22 03:06:54101}
102
[email protected]677c90572008-12-10 09:03:15103} // namespace
104
Eric Romanab9fc652018-05-08 01:59:53105std::unique_ptr<PacFileFetcherImpl> PacFileFetcherImpl::Create(
106 URLRequestContext* url_request_context) {
Matt Menke27e91ae42019-09-10 16:10:48107 return base::WrapUnique(new PacFileFetcherImpl(url_request_context));
[email protected]677c90572008-12-10 09:03:15108}
109
Lily Houghton99597862018-03-07 16:40:42110PacFileFetcherImpl::~PacFileFetcherImpl() {
[email protected]da968bc2011-01-19 11:48:19111 // The URLRequest's destructor will cancel the outstanding request, and
[email protected]677c90572008-12-10 09:03:15112 // ensure that the delegate (this) is not called again.
113}
114
Lily Houghton99597862018-03-07 16:40:42115base::TimeDelta PacFileFetcherImpl::SetTimeoutConstraint(
[email protected]7aefb152011-01-21 23:46:49116 base::TimeDelta timeout) {
117 base::TimeDelta prev = max_duration_;
118 max_duration_ = timeout;
119 return prev;
120}
121
Lily Houghton99597862018-03-07 16:40:42122size_t PacFileFetcherImpl::SetSizeConstraint(size_t size_bytes) {
[email protected]7aefb152011-01-21 23:46:49123 size_t prev = max_response_bytes_;
124 max_response_bytes_ = size_bytes;
125 return prev;
126}
127
Lily Houghton99597862018-03-07 16:40:42128void PacFileFetcherImpl::OnResponseCompleted(URLRequest* request,
129 int net_error) {
[email protected]7aefb152011-01-21 23:46:49130 DCHECK_EQ(request, cur_request_.get());
131
132 // Use |result_code_| as the request's error if we have already set it to
133 // something specific.
maksim.sisovbf794e22016-09-13 09:20:34134 if (result_code_ == OK && net_error != OK)
135 result_code_ = net_error;
[email protected]7aefb152011-01-21 23:46:49136
137 FetchCompleted();
138}
139
Ramin Halavatibb8c4d82018-03-16 08:04:31140int PacFileFetcherImpl::Fetch(
141 const GURL& url,
Jan Wilken Dörrie739ccc212021-03-11 18:13:05142 std::u16string* text,
Bence Békycc5b88a2018-05-25 20:24:17143 CompletionOnceCallback callback,
Ramin Halavatibb8c4d82018-03-16 08:04:31144 const NetworkTrafficAnnotationTag traffic_annotation) {
[email protected]677c90572008-12-10 09:03:15145 // It is invalid to call Fetch() while a request is already in progress.
146 DCHECK(!cur_request_.get());
[email protected]235786812011-12-20 02:15:31147 DCHECK(!callback.is_null());
[email protected]9b9ae9552010-07-01 22:20:50148 DCHECK(text);
[email protected]677c90572008-12-10 09:03:15149
mmenkeed8d7e432017-05-03 16:48:33150 if (!url_request_context_)
151 return ERR_CONTEXT_SHUT_DOWN;
152
Eric Romanab9fc652018-05-08 01:59:53153 if (!IsUrlSchemeAllowed(url))
154 return ERR_DISALLOWED_URL_SCHEME;
155
[email protected]d9d71e082011-02-16 11:44:28156 // Handle base-64 encoded data-urls that contain custom PAC scripts.
157 if (url.SchemeIs("data")) {
158 std::string mime_type;
159 std::string charset;
160 std::string data;
161 if (!DataURL::Parse(url, &mime_type, &charset, &data))
162 return ERR_FAILED;
163
164 ConvertResponseToUTF16(charset, data, text);
165 return OK;
166 }
167
cbentzel27d2e5e52015-07-10 17:39:56168 DCHECK(fetch_start_time_.is_null());
cbentzele45ccba2015-08-21 18:23:14169 fetch_start_time_ = base::TimeTicks::Now();
cbentzel27d2e5e52015-07-10 17:39:56170
mmenkeed8d7e432017-05-03 16:48:33171 // Use highest priority, so if socket pools are being used for other types of
172 // requests, PAC requests are aren't blocked on them.
rhalavatide8bf4e2017-05-16 06:09:11173 cur_request_ = url_request_context_->CreateRequest(url, MAXIMUM_PRIORITY,
174 this, traffic_annotation);
[email protected]677c90572008-12-10 09:03:15175
Matt Menke467dd7892021-08-10 20:19:23176 cur_request_->set_isolation_info(isolation_info());
Matt Menke794ce1962020-05-26 18:37:43177
[email protected]677c90572008-12-10 09:03:15178 // Make sure that the PAC script is downloaded using a direct connection,
179 // to avoid circular dependencies (fetching is a part of proxy resolution).
[email protected]e0ef2c22009-06-03 23:54:44180 // Also disable the use of the disk cache. The cache is disabled so that if
181 // the user switches networks we don't potentially use the cached response
182 // from old network when we should in fact be re-fetching on the new network.
[email protected]6fbac162011-06-20 00:29:04183 // If the PAC script is hosted on an HTTPS server we bypass revocation
184 // checking in order to avoid a circular dependency when attempting to fetch
185 // the OCSP response or CRL. We could make the revocation check go direct but
mmenkeed8d7e432017-05-03 16:48:33186 // the proxy might be the only way to the outside world. IGNORE_LIMITS is
187 // used to avoid blocking proxy resolution on other network requests.
[email protected]bb1c4662013-11-14 00:00:07188 cur_request_->SetLoadFlags(LOAD_BYPASS_PROXY | LOAD_DISABLE_CACHE |
Ryan Sleevi24fe2682018-08-16 21:33:46189 LOAD_DISABLE_CERT_NETWORK_FETCHES |
mmenkeed8d7e432017-05-03 16:48:33190 LOAD_IGNORE_LIMITS);
[email protected]677c90572008-12-10 09:03:15191
192 // Save the caller's info for notification on completion.
Bence Békycc5b88a2018-05-25 20:24:17193 callback_ = std::move(callback);
[email protected]9b9ae9552010-07-01 22:20:50194 result_text_ = text;
195
196 bytes_read_so_far_.clear();
[email protected]677c90572008-12-10 09:03:15197
198 // Post a task to timeout this request if it takes too long.
199 cur_request_id_ = ++next_id_;
eromane1867242015-04-23 23:07:44200
Sean Maher5b9af51f2022-11-21 15:32:47201 base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
Lily Houghton9844d322018-01-20 05:44:01202 FROM_HERE,
kylecharf4fe5172019-02-15 18:53:49203 base::BindOnce(&PacFileFetcherImpl::OnTimeout, weak_factory_.GetWeakPtr(),
204 cur_request_id_),
[email protected]26b9973962012-01-28 00:57:00205 max_duration_);
[email protected]677c90572008-12-10 09:03:15206
207 // Start the request.
208 cur_request_->Start();
[email protected]620f5712009-08-04 22:43:12209 return ERR_IO_PENDING;
[email protected]677c90572008-12-10 09:03:15210}
211
Lily Houghton99597862018-03-07 16:40:42212void PacFileFetcherImpl::Cancel() {
[email protected]da968bc2011-01-19 11:48:19213 // ResetCurRequestState will free the URLRequest, which will cause
[email protected]677c90572008-12-10 09:03:15214 // cancellation.
215 ResetCurRequestState();
216}
217
Lily Houghton99597862018-03-07 16:40:42218URLRequestContext* PacFileFetcherImpl::GetRequestContext() const {
[email protected]20d296ddc2009-11-18 23:07:08219 return url_request_context_;
220}
221
Lily Houghton99597862018-03-07 16:40:42222void PacFileFetcherImpl::OnShutdown() {
mmenkeed8d7e432017-05-03 16:48:33223 url_request_context_ = nullptr;
224
225 if (cur_request_) {
226 result_code_ = ERR_CONTEXT_SHUT_DOWN;
227 FetchCompleted();
228 }
229}
230
Eric Romanab9fc652018-05-08 01:59:53231void PacFileFetcherImpl::OnReceivedRedirect(URLRequest* request,
232 const RedirectInfo& redirect_info,
233 bool* defer_redirect) {
234 int error = OK;
235
236 // Redirection to file:// is never OK. Ordinarily this is handled lower in the
237 // stack (|FileProtocolHandler::IsSafeRedirectTarget|), but this is reachable
238 // when built without file:// suppport. Return the same error for consistency.
239 if (redirect_info.new_url.SchemeIsFile()) {
240 error = ERR_UNSAFE_REDIRECT;
241 } else if (!IsUrlSchemeAllowed(redirect_info.new_url)) {
242 error = ERR_DISALLOWED_URL_SCHEME;
243 }
244
245 if (error != OK) {
246 // Fail the redirect.
247 request->CancelWithError(error);
248 OnResponseCompleted(request, error);
249 }
250}
251
Lily Houghton99597862018-03-07 16:40:42252void PacFileFetcherImpl::OnAuthRequired(URLRequest* request,
Emily Starkf2c9bbd2019-04-09 17:08:58253 const AuthChallengeInfo& auth_info) {
[email protected]0967249162010-11-20 00:13:32254 DCHECK_EQ(request, cur_request_.get());
[email protected]33abb682011-03-29 03:58:42255 // TODO(eroman): http://crbug.com/77366
[email protected]13a279e2009-04-13 17:32:37256 LOG(WARNING) << "Auth required to fetch PAC script, aborting.";
[email protected]677c90572008-12-10 09:03:15257 result_code_ = ERR_NOT_IMPLEMENTED;
258 request->CancelAuth();
259}
260
Lily Houghton99597862018-03-07 16:40:42261void PacFileFetcherImpl::OnSSLCertificateError(URLRequest* request,
Emily Stark79fba5842019-04-25 04:59:36262 int net_error,
Lily Houghton99597862018-03-07 16:40:42263 const SSLInfo& ssl_info,
264 bool fatal) {
[email protected]0967249162010-11-20 00:13:32265 DCHECK_EQ(request, cur_request_.get());
[email protected]13a279e2009-04-13 17:32:37266 LOG(WARNING) << "SSL certificate error when fetching PAC script, aborting.";
[email protected]677c90572008-12-10 09:03:15267 // Certificate errors are in same space as net errors.
Emily Stark79fba5842019-04-25 04:59:36268 result_code_ = net_error;
[email protected]677c90572008-12-10 09:03:15269 request->Cancel();
270}
271
Lily Houghton99597862018-03-07 16:40:42272void PacFileFetcherImpl::OnResponseStarted(URLRequest* request, int net_error) {
[email protected]0967249162010-11-20 00:13:32273 DCHECK_EQ(request, cur_request_.get());
maksim.sisovbf794e22016-09-13 09:20:34274 DCHECK_NE(ERR_IO_PENDING, net_error);
[email protected]677c90572008-12-10 09:03:15275
maksim.sisovbf794e22016-09-13 09:20:34276 if (net_error != OK) {
277 OnResponseCompleted(request, net_error);
[email protected]677c90572008-12-10 09:03:15278 return;
279 }
280
281 // Require HTTP responses to have a success status code.
[email protected]91f5689032013-08-22 01:43:33282 if (request->url().SchemeIsHTTPOrHTTPS()) {
[email protected]f0a51fb52009-03-05 12:46:38283 // NOTE about status codes: We are like Firefox 3 in this respect.
[email protected]677c90572008-12-10 09:03:15284 // {IE 7, Safari 3, Opera 9.5} do not care about the status code.
285 if (request->GetResponseCode() != 200) {
[email protected]b30a3f52010-10-16 01:05:46286 VLOG(1) << "Fetched PAC script had (bad) status line: "
287 << request->response_headers()->GetStatusLine();
Eric Romana22b1f72019-09-05 19:35:04288 result_code_ = ERR_HTTP_RESPONSE_CODE_FAILURE;
[email protected]677c90572008-12-10 09:03:15289 request->Cancel();
290 return;
291 }
[email protected]13a279e2009-04-13 17:32:37292
293 // NOTE about mime types: We do not enforce mime types on PAC files.
294 // This is for compatibility with {IE 7, Firefox 3, Opera 9.5}. We will
295 // however log mismatches to help with debugging.
[email protected]e0ef2c22009-06-03 23:54:44296 std::string mime_type;
297 cur_request_->GetMimeType(&mime_type);
298 if (!IsPacMimeType(mime_type)) {
[email protected]b30a3f52010-10-16 01:05:46299 VLOG(1) << "Fetched PAC script does not have a proper mime type: "
300 << mime_type;
[email protected]13a279e2009-04-13 17:32:37301 }
[email protected]677c90572008-12-10 09:03:15302 }
303
304 ReadBody(request);
305}
306
Lily Houghton99597862018-03-07 16:40:42307void PacFileFetcherImpl::OnReadCompleted(URLRequest* request, int num_bytes) {
maksim.sisovbf794e22016-09-13 09:20:34308 DCHECK_NE(ERR_IO_PENDING, num_bytes);
309
[email protected]0967249162010-11-20 00:13:32310 DCHECK_EQ(request, cur_request_.get());
311 if (ConsumeBytesRead(request, num_bytes)) {
312 // Keep reading.
[email protected]677c90572008-12-10 09:03:15313 ReadBody(request);
[email protected]677c90572008-12-10 09:03:15314 }
315}
316
Matt Menke27e91ae42019-09-10 16:10:48317PacFileFetcherImpl::PacFileFetcherImpl(URLRequestContext* url_request_context)
Eric Romanab9fc652018-05-08 01:59:53318 : url_request_context_(url_request_context),
Victor Costan9c7302b2018-08-27 16:39:44319 buf_(base::MakeRefCounted<IOBuffer>(kBufSize)),
Eric Romanab9fc652018-05-08 01:59:53320 max_response_bytes_(kDefaultMaxResponseBytes),
Matt Menke27e91ae42019-09-10 16:10:48321 max_duration_(kDefaultMaxDuration) {
Eric Romanab9fc652018-05-08 01:59:53322 DCHECK(url_request_context);
323}
324
325bool PacFileFetcherImpl::IsUrlSchemeAllowed(const GURL& url) const {
Matt Menke9870be72021-08-26 00:36:37326 // Always allow http://, https://, and data:.
327 if (url.SchemeIsHTTPOrHTTPS() || url.SchemeIs("data"))
Eric Romanab9fc652018-05-08 01:59:53328 return true;
329
Eric Romanab9fc652018-05-08 01:59:53330 // Disallow any other URL scheme.
331 return false;
332}
333
Lily Houghton99597862018-03-07 16:40:42334void PacFileFetcherImpl::ReadBody(URLRequest* request) {
[email protected]0967249162010-11-20 00:13:32335 // Read as many bytes as are available synchronously.
336 while (true) {
maksim.sisovbf794e22016-09-13 09:20:34337 int num_bytes = request->Read(buf_.get(), kBufSize);
338 if (num_bytes == ERR_IO_PENDING)
339 return;
340
341 if (num_bytes < 0) {
342 OnResponseCompleted(request, num_bytes);
[email protected]0967249162010-11-20 00:13:32343 return;
344 }
maksim.sisovbf794e22016-09-13 09:20:34345
[email protected]0967249162010-11-20 00:13:32346 if (!ConsumeBytesRead(request, num_bytes))
347 return;
[email protected]677c90572008-12-10 09:03:15348 }
349}
350
Lily Houghton99597862018-03-07 16:40:42351bool PacFileFetcherImpl::ConsumeBytesRead(URLRequest* request, int num_bytes) {
Eric Romanf4174852018-02-16 22:47:13352 if (fetch_time_to_first_byte_.is_null())
353 fetch_time_to_first_byte_ = base::TimeTicks::Now();
354
[email protected]0967249162010-11-20 00:13:32355 if (num_bytes <= 0) {
356 // Error while reading, or EOF.
maksim.sisovbf794e22016-09-13 09:20:34357 OnResponseCompleted(request, num_bytes);
[email protected]0967249162010-11-20 00:13:32358 return false;
359 }
360
361 // Enforce maximum size bound.
362 if (num_bytes + bytes_read_so_far_.size() >
363 static_cast<size_t>(max_response_bytes_)) {
364 result_code_ = ERR_FILE_TOO_BIG;
365 request->Cancel();
366 return false;
367 }
368
369 bytes_read_so_far_.append(buf_->data(), num_bytes);
370 return true;
371}
372
Lily Houghton99597862018-03-07 16:40:42373void PacFileFetcherImpl::FetchCompleted() {
[email protected]8f3c96342009-09-22 03:06:54374 if (result_code_ == OK) {
Lily Houghton99597862018-03-07 16:40:42375 // Calculate duration of time for PAC file fetch to complete.
cbentzel27d2e5e52015-07-10 17:39:56376 DCHECK(!fetch_start_time_.is_null());
cbentzele45ccba2015-08-21 18:23:14377 DCHECK(!fetch_time_to_first_byte_.is_null());
378 UMA_HISTOGRAM_MEDIUM_TIMES("Net.ProxyScriptFetcher.SuccessDuration",
379 base::TimeTicks::Now() - fetch_start_time_);
380 UMA_HISTOGRAM_MEDIUM_TIMES("Net.ProxyScriptFetcher.FirstByteDuration",
381 fetch_time_to_first_byte_ - fetch_start_time_);
cbentzel27d2e5e52015-07-10 17:39:56382
[email protected]9b9ae9552010-07-01 22:20:50383 // The caller expects the response to be encoded as UTF16.
[email protected]8f3c96342009-09-22 03:06:54384 std::string charset;
385 cur_request_->GetCharset(&charset);
[email protected]9b9ae9552010-07-01 22:20:50386 ConvertResponseToUTF16(charset, bytes_read_so_far_, result_text_);
[email protected]8f3c96342009-09-22 03:06:54387 } else {
388 // On error, the caller expects empty string for bytes.
[email protected]9b9ae9552010-07-01 22:20:50389 result_text_->clear();
[email protected]8f3c96342009-09-22 03:06:54390 }
[email protected]677c90572008-12-10 09:03:15391
392 int result_code = result_code_;
Bence Békycc5b88a2018-05-25 20:24:17393 CompletionOnceCallback callback = std::move(callback_);
[email protected]677c90572008-12-10 09:03:15394
395 ResetCurRequestState();
396
Bence Békycc5b88a2018-05-25 20:24:17397 std::move(callback).Run(result_code);
[email protected]677c90572008-12-10 09:03:15398}
399
Lily Houghton99597862018-03-07 16:40:42400void PacFileFetcherImpl::ResetCurRequestState() {
[email protected]677c90572008-12-10 09:03:15401 cur_request_.reset();
402 cur_request_id_ = 0;
[email protected]235786812011-12-20 02:15:31403 callback_.Reset();
[email protected]677c90572008-12-10 09:03:15404 result_code_ = OK;
Raul Tambre94493c652019-03-11 17:18:35405 result_text_ = nullptr;
cbentzele45ccba2015-08-21 18:23:14406 fetch_start_time_ = base::TimeTicks();
407 fetch_time_to_first_byte_ = base::TimeTicks();
[email protected]677c90572008-12-10 09:03:15408}
409
Lily Houghton99597862018-03-07 16:40:42410void PacFileFetcherImpl::OnTimeout(int id) {
[email protected]da968bc2011-01-19 11:48:19411 // Timeout tasks may outlive the URLRequest they reference. Make sure it
[email protected]677c90572008-12-10 09:03:15412 // is still applicable.
413 if (cur_request_id_ != id)
414 return;
415
416 DCHECK(cur_request_.get());
417 result_code_ = ERR_TIMED_OUT;
mmenkeed8d7e432017-05-03 16:48:33418 FetchCompleted();
[email protected]677c90572008-12-10 09:03:15419}
420
[email protected]677c90572008-12-10 09:03:15421} // namespace net