cronet_url_request.cc 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426
  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. #include "components/cronet/cronet_url_request.h"
  5. #include <limits>
  6. #include <utility>
  7. #include "base/bind.h"
  8. #include "base/location.h"
  9. #include "base/logging.h"
  10. #include "build/build_config.h"
  11. #include "components/cronet/cronet_context.h"
  12. #include "net/base/idempotency.h"
  13. #include "net/base/io_buffer.h"
  14. #include "net/base/load_flags.h"
  15. #include "net/base/load_states.h"
  16. #include "net/base/net_errors.h"
  17. #include "net/base/proxy_server.h"
  18. #include "net/base/request_priority.h"
  19. #include "net/base/upload_data_stream.h"
  20. #include "net/cert/cert_status_flags.h"
  21. #include "net/cert/x509_certificate.h"
  22. #include "net/http/http_response_headers.h"
  23. #include "net/http/http_status_code.h"
  24. #include "net/http/http_util.h"
  25. #include "net/ssl/ssl_info.h"
  26. #include "net/ssl/ssl_private_key.h"
  27. #include "net/third_party/quiche/src/quiche/quic/core/quic_packets.h"
  28. #include "net/traffic_annotation/network_traffic_annotation.h"
  29. #include "net/url_request/redirect_info.h"
  30. #include "net/url_request/url_request_context.h"
  31. namespace cronet {
  32. namespace {
  33. // Returns the string representation of the HostPortPair of the proxy server
  34. // that was used to fetch the response.
  35. std::string GetProxy(const net::HttpResponseInfo& info) {
  36. if (!info.proxy_server.is_valid() || info.proxy_server.is_direct())
  37. return net::HostPortPair().ToString();
  38. return info.proxy_server.host_port_pair().ToString();
  39. }
  40. int CalculateLoadFlags(int load_flags,
  41. bool disable_cache,
  42. bool disable_connection_migration) {
  43. if (disable_cache)
  44. load_flags |= net::LOAD_DISABLE_CACHE;
  45. if (disable_connection_migration)
  46. load_flags |= net::LOAD_DISABLE_CONNECTION_MIGRATION_TO_CELLULAR;
  47. return load_flags;
  48. }
  49. } // namespace
  50. CronetURLRequest::CronetURLRequest(CronetContext* context,
  51. std::unique_ptr<Callback> callback,
  52. const GURL& url,
  53. net::RequestPriority priority,
  54. bool disable_cache,
  55. bool disable_connection_migration,
  56. bool traffic_stats_tag_set,
  57. int32_t traffic_stats_tag,
  58. bool traffic_stats_uid_set,
  59. int32_t traffic_stats_uid,
  60. net::Idempotency idempotency,
  61. net::handles::NetworkHandle network)
  62. : context_(context),
  63. network_tasks_(std::move(callback),
  64. url,
  65. priority,
  66. CalculateLoadFlags(context->default_load_flags(),
  67. disable_cache,
  68. disable_connection_migration),
  69. traffic_stats_tag_set,
  70. traffic_stats_tag,
  71. traffic_stats_uid_set,
  72. traffic_stats_uid,
  73. idempotency,
  74. network),
  75. initial_method_("GET"),
  76. initial_request_headers_(std::make_unique<net::HttpRequestHeaders>()) {
  77. DCHECK(!context_->IsOnNetworkThread());
  78. }
  79. CronetURLRequest::~CronetURLRequest() {
  80. DCHECK(context_->IsOnNetworkThread());
  81. }
  82. bool CronetURLRequest::SetHttpMethod(const std::string& method) {
  83. DCHECK(!context_->IsOnNetworkThread());
  84. // Http method is a token, just as header name.
  85. if (!net::HttpUtil::IsValidHeaderName(method))
  86. return false;
  87. initial_method_ = method;
  88. return true;
  89. }
  90. bool CronetURLRequest::AddRequestHeader(const std::string& name,
  91. const std::string& value) {
  92. DCHECK(!context_->IsOnNetworkThread());
  93. DCHECK(initial_request_headers_);
  94. if (!net::HttpUtil::IsValidHeaderName(name) ||
  95. !net::HttpUtil::IsValidHeaderValue(value)) {
  96. return false;
  97. }
  98. initial_request_headers_->SetHeader(name, value);
  99. return true;
  100. }
  101. void CronetURLRequest::SetUpload(
  102. std::unique_ptr<net::UploadDataStream> upload) {
  103. DCHECK(!context_->IsOnNetworkThread());
  104. DCHECK(!upload_);
  105. upload_ = std::move(upload);
  106. }
  107. void CronetURLRequest::Start() {
  108. DCHECK(!context_->IsOnNetworkThread());
  109. context_->PostTaskToNetworkThread(
  110. FROM_HERE,
  111. base::BindOnce(&CronetURLRequest::NetworkTasks::Start,
  112. base::Unretained(&network_tasks_),
  113. base::Unretained(context_), initial_method_,
  114. std::move(initial_request_headers_), std::move(upload_)));
  115. }
  116. void CronetURLRequest::GetStatus(OnStatusCallback callback) const {
  117. context_->PostTaskToNetworkThread(
  118. FROM_HERE,
  119. base::BindOnce(&CronetURLRequest::NetworkTasks::GetStatus,
  120. base::Unretained(&network_tasks_), std::move(callback)));
  121. }
  122. void CronetURLRequest::FollowDeferredRedirect() {
  123. context_->PostTaskToNetworkThread(
  124. FROM_HERE,
  125. base::BindOnce(&CronetURLRequest::NetworkTasks::FollowDeferredRedirect,
  126. base::Unretained(&network_tasks_)));
  127. }
  128. bool CronetURLRequest::ReadData(net::IOBuffer* raw_read_buffer, int max_size) {
  129. scoped_refptr<net::IOBuffer> read_buffer(raw_read_buffer);
  130. context_->PostTaskToNetworkThread(
  131. FROM_HERE,
  132. base::BindOnce(&CronetURLRequest::NetworkTasks::ReadData,
  133. base::Unretained(&network_tasks_), read_buffer, max_size));
  134. return true;
  135. }
  136. void CronetURLRequest::Destroy(bool send_on_canceled) {
  137. // Destroy could be called from any thread, including network thread (if
  138. // posting task to executor throws an exception), but is posted, so |this|
  139. // is valid until calling task is complete. Destroy() must be called from
  140. // within a synchronized block that guarantees no future posts to the
  141. // network thread with the request pointer.
  142. context_->PostTaskToNetworkThread(
  143. FROM_HERE, base::BindOnce(&CronetURLRequest::NetworkTasks::Destroy,
  144. base::Unretained(&network_tasks_),
  145. base::Unretained(this), send_on_canceled));
  146. }
  147. void CronetURLRequest::MaybeReportMetricsAndRunCallback(
  148. base::OnceClosure callback) {
  149. context_->PostTaskToNetworkThread(
  150. FROM_HERE,
  151. base::BindOnce(
  152. &CronetURLRequest::NetworkTasks::MaybeReportMetricsAndRunCallback,
  153. base::Unretained(&network_tasks_), std::move(callback)));
  154. }
  155. CronetURLRequest::NetworkTasks::NetworkTasks(
  156. std::unique_ptr<Callback> callback,
  157. const GURL& url,
  158. net::RequestPriority priority,
  159. int load_flags,
  160. bool traffic_stats_tag_set,
  161. int32_t traffic_stats_tag,
  162. bool traffic_stats_uid_set,
  163. int32_t traffic_stats_uid,
  164. net::Idempotency idempotency,
  165. net::handles::NetworkHandle network)
  166. : callback_(std::move(callback)),
  167. initial_url_(url),
  168. initial_priority_(priority),
  169. initial_load_flags_(load_flags),
  170. received_byte_count_from_redirects_(0l),
  171. error_reported_(false),
  172. metrics_reported_(false),
  173. traffic_stats_tag_set_(traffic_stats_tag_set),
  174. traffic_stats_tag_(traffic_stats_tag),
  175. traffic_stats_uid_set_(traffic_stats_uid_set),
  176. traffic_stats_uid_(traffic_stats_uid),
  177. idempotency_(idempotency),
  178. network_(network) {
  179. DETACH_FROM_THREAD(network_thread_checker_);
  180. }
  181. CronetURLRequest::NetworkTasks::~NetworkTasks() {
  182. DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
  183. }
  184. void CronetURLRequest::NetworkTasks::OnReceivedRedirect(
  185. net::URLRequest* request,
  186. const net::RedirectInfo& redirect_info,
  187. bool* defer_redirect) {
  188. DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
  189. received_byte_count_from_redirects_ += request->GetTotalReceivedBytes();
  190. callback_->OnReceivedRedirect(
  191. redirect_info.new_url.spec(), redirect_info.status_code,
  192. request->response_headers()->GetStatusText(), request->response_headers(),
  193. request->response_info().was_cached,
  194. request->response_info().alpn_negotiated_protocol,
  195. GetProxy(request->response_info()), received_byte_count_from_redirects_);
  196. *defer_redirect = true;
  197. }
  198. void CronetURLRequest::NetworkTasks::OnCertificateRequested(
  199. net::URLRequest* request,
  200. net::SSLCertRequestInfo* cert_request_info) {
  201. DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
  202. // Cronet does not support client certificates.
  203. request->ContinueWithCertificate(nullptr, nullptr);
  204. }
  205. void CronetURLRequest::NetworkTasks::OnSSLCertificateError(
  206. net::URLRequest* request,
  207. int net_error,
  208. const net::SSLInfo& ssl_info,
  209. bool fatal) {
  210. DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
  211. ReportError(request, net_error);
  212. request->Cancel();
  213. }
  214. void CronetURLRequest::NetworkTasks::OnResponseStarted(net::URLRequest* request,
  215. int net_error) {
  216. DCHECK_NE(net::ERR_IO_PENDING, net_error);
  217. DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
  218. if (net_error != net::OK) {
  219. ReportError(request, net_error);
  220. return;
  221. }
  222. callback_->OnResponseStarted(
  223. request->GetResponseCode(), request->response_headers()->GetStatusText(),
  224. request->response_headers(), request->response_info().was_cached,
  225. request->response_info().alpn_negotiated_protocol,
  226. GetProxy(request->response_info()),
  227. received_byte_count_from_redirects_ + request->GetTotalReceivedBytes());
  228. }
  229. void CronetURLRequest::NetworkTasks::OnReadCompleted(net::URLRequest* request,
  230. int bytes_read) {
  231. DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
  232. if (bytes_read < 0) {
  233. ReportError(request, bytes_read);
  234. return;
  235. }
  236. if (bytes_read == 0) {
  237. DCHECK(!error_reported_);
  238. MaybeReportMetrics();
  239. callback_->OnSucceeded(received_byte_count_from_redirects_ +
  240. request->GetTotalReceivedBytes());
  241. } else {
  242. callback_->OnReadCompleted(
  243. read_buffer_, bytes_read,
  244. received_byte_count_from_redirects_ + request->GetTotalReceivedBytes());
  245. }
  246. // Free the read buffer.
  247. read_buffer_ = nullptr;
  248. }
  249. void CronetURLRequest::NetworkTasks::Start(
  250. CronetContext* context,
  251. const std::string& method,
  252. std::unique_ptr<net::HttpRequestHeaders> request_headers,
  253. std::unique_ptr<net::UploadDataStream> upload) {
  254. DCHECK(context->IsOnNetworkThread());
  255. DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
  256. VLOG(1) << "Starting chromium request: "
  257. << initial_url_.possibly_invalid_spec().c_str()
  258. << " priority: " << RequestPriorityToString(initial_priority_);
  259. url_request_ = context->GetURLRequestContext(network_)->CreateRequest(
  260. initial_url_, net::DEFAULT_PRIORITY, this, MISSING_TRAFFIC_ANNOTATION);
  261. url_request_->SetLoadFlags(initial_load_flags_);
  262. url_request_->set_method(method);
  263. url_request_->SetExtraRequestHeaders(*request_headers);
  264. url_request_->SetPriority(initial_priority_);
  265. url_request_->SetIdempotency(idempotency_);
  266. std::string referer;
  267. if (request_headers->GetHeader(net::HttpRequestHeaders::kReferer, &referer)) {
  268. url_request_->SetReferrer(referer);
  269. }
  270. if (upload)
  271. url_request_->set_upload(std::move(upload));
  272. if (traffic_stats_tag_set_ || traffic_stats_uid_set_) {
  273. #if BUILDFLAG(IS_ANDROID)
  274. url_request_->set_socket_tag(net::SocketTag(
  275. traffic_stats_uid_set_ ? traffic_stats_uid_ : net::SocketTag::UNSET_UID,
  276. traffic_stats_tag_set_ ? traffic_stats_tag_
  277. : net::SocketTag::UNSET_TAG));
  278. #else
  279. CHECK(false);
  280. #endif
  281. }
  282. url_request_->Start();
  283. }
  284. void CronetURLRequest::NetworkTasks::GetStatus(
  285. OnStatusCallback callback) const {
  286. DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
  287. net::LoadState status = net::LOAD_STATE_IDLE;
  288. // |url_request_| is initialized in StartOnNetworkThread, and it is
  289. // never nulled. If it is null, it must be that StartOnNetworkThread
  290. // has not been called, pretend that we are in LOAD_STATE_IDLE.
  291. // See https://crbug.com/606872.
  292. if (url_request_)
  293. status = url_request_->GetLoadState().state;
  294. std::move(callback).Run(status);
  295. }
  296. void CronetURLRequest::NetworkTasks::FollowDeferredRedirect() {
  297. DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
  298. url_request_->FollowDeferredRedirect(
  299. absl::nullopt /* removed_request_headers */,
  300. absl::nullopt /* modified_request_headers */);
  301. }
  302. void CronetURLRequest::NetworkTasks::ReadData(
  303. scoped_refptr<net::IOBuffer> read_buffer,
  304. int buffer_size) {
  305. DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
  306. DCHECK(read_buffer);
  307. DCHECK(!read_buffer_);
  308. read_buffer_ = read_buffer;
  309. int result = url_request_->Read(read_buffer_.get(), buffer_size);
  310. // If IO is pending, wait for the URLRequest to call OnReadCompleted.
  311. if (result == net::ERR_IO_PENDING)
  312. return;
  313. OnReadCompleted(url_request_.get(), result);
  314. }
  315. void CronetURLRequest::NetworkTasks::Destroy(CronetURLRequest* request,
  316. bool send_on_canceled) {
  317. DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
  318. MaybeReportMetrics();
  319. if (send_on_canceled)
  320. callback_->OnCanceled();
  321. callback_->OnDestroyed();
  322. // Check if the URLRequestContext associated to `network_` has become eligible
  323. // for destruction. To simplify MaybeDestroyURLRequestContext's logic: destroy
  324. // the underlying URLRequest in advance, so that it has already deregistered
  325. // from its URLRequestContext by the time MaybeDestroyURLRequestContext is
  326. // called.
  327. url_request_.reset();
  328. request->context_->MaybeDestroyURLRequestContext(network_);
  329. // Deleting owner request also deletes `this`.
  330. delete request;
  331. }
  332. void CronetURLRequest::NetworkTasks::ReportError(net::URLRequest* request,
  333. int net_error) {
  334. DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
  335. DCHECK_NE(net::ERR_IO_PENDING, net_error);
  336. DCHECK_LT(net_error, 0);
  337. DCHECK_EQ(request, url_request_.get());
  338. // Error may have already been reported.
  339. if (error_reported_)
  340. return;
  341. error_reported_ = true;
  342. net::NetErrorDetails net_error_details;
  343. url_request_->PopulateNetErrorDetails(&net_error_details);
  344. VLOG(1) << "Error " << net::ErrorToString(net_error)
  345. << " on chromium request: " << initial_url_.possibly_invalid_spec();
  346. MaybeReportMetrics();
  347. callback_->OnError(
  348. net_error, net_error_details.quic_connection_error,
  349. net::ErrorToString(net_error),
  350. received_byte_count_from_redirects_ + request->GetTotalReceivedBytes());
  351. }
  352. void CronetURLRequest::NetworkTasks::MaybeReportMetrics() {
  353. DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
  354. // If there was an exception while starting the CronetUrlRequest, there won't
  355. // be a native URLRequest. In this case, the caller gets the exception
  356. // immediately, and the onFailed callback isn't called, so don't report
  357. // metrics either.
  358. if (metrics_reported_ || !url_request_) {
  359. return;
  360. }
  361. metrics_reported_ = true;
  362. net::LoadTimingInfo metrics;
  363. url_request_->GetLoadTimingInfo(&metrics);
  364. net::NetErrorDetails net_error_details;
  365. url_request_->PopulateNetErrorDetails(&net_error_details);
  366. callback_->OnMetricsCollected(
  367. metrics.request_start_time, metrics.request_start,
  368. metrics.connect_timing.dns_start, metrics.connect_timing.dns_end,
  369. metrics.connect_timing.connect_start, metrics.connect_timing.connect_end,
  370. metrics.connect_timing.ssl_start, metrics.connect_timing.ssl_end,
  371. metrics.send_start, metrics.send_end, metrics.push_start,
  372. metrics.push_end, metrics.receive_headers_end, base::TimeTicks::Now(),
  373. metrics.socket_reused, url_request_->GetTotalSentBytes(),
  374. received_byte_count_from_redirects_ +
  375. url_request_->GetTotalReceivedBytes(),
  376. net_error_details.quic_connection_migration_attempted,
  377. net_error_details.quic_connection_migration_successful);
  378. }
  379. void CronetURLRequest::NetworkTasks::MaybeReportMetricsAndRunCallback(
  380. base::OnceClosure callback) {
  381. DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
  382. MaybeReportMetrics();
  383. std::move(callback).Run();
  384. }
  385. } // namespace cronet