1 // Copyright 2015 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/url_request/report_sender.h"
6
7 #include <utility>
8
9 #include "net/base/elements_upload_data_stream.h"
10 #include "net/base/isolation_info.h"
11 #include "net/base/load_flags.h"
12 #include "net/base/request_priority.h"
13 #include "net/base/upload_bytes_element_reader.h"
14 #include "net/http/http_status_code.h"
15 #include "net/url_request/url_request_context.h"
16 #include "url/gurl.h"
17
18 namespace {
19 const void* const kUserDataKey = &kUserDataKey;
20
21 class CallbackInfo : public base::SupportsUserData::Data {
22 public:
CallbackInfo(net::ReportSender::SuccessCallback success_callback,net::ReportSender::ErrorCallback error_callback)23 CallbackInfo(net::ReportSender::SuccessCallback success_callback,
24 net::ReportSender::ErrorCallback error_callback)
25 : success_callback_(std::move(success_callback)),
26 error_callback_(std::move(error_callback)) {}
27
28 ~CallbackInfo() override = default;
29
RunSuccessCallback()30 void RunSuccessCallback() {
31 if (!success_callback_.is_null())
32 std::move(success_callback_).Run();
33 }
34
RunErrorCallback(const GURL & url,int net_error,int http_response_code)35 void RunErrorCallback(const GURL& url,
36 int net_error,
37 int http_response_code) {
38 if (!error_callback_.is_null())
39 std::move(error_callback_).Run(url, net_error, http_response_code);
40 }
41
42 private:
43 net::ReportSender::SuccessCallback success_callback_;
44 net::ReportSender::ErrorCallback error_callback_;
45 };
46 } // namespace
47
48 namespace net {
49
50 const int ReportSender::kLoadFlags = LOAD_BYPASS_CACHE | LOAD_DISABLE_CACHE;
51
ReportSender(URLRequestContext * request_context,net::NetworkTrafficAnnotationTag traffic_annotation)52 ReportSender::ReportSender(URLRequestContext* request_context,
53 net::NetworkTrafficAnnotationTag traffic_annotation)
54 : request_context_(request_context),
55 traffic_annotation_(traffic_annotation) {}
56
57 ReportSender::~ReportSender() = default;
58
Send(const GURL & report_uri,base::StringPiece content_type,base::StringPiece report,const NetworkAnonymizationKey & network_anonymization_key,SuccessCallback success_callback,ErrorCallback error_callback)59 void ReportSender::Send(
60 const GURL& report_uri,
61 base::StringPiece content_type,
62 base::StringPiece report,
63 const NetworkAnonymizationKey& network_anonymization_key,
64 SuccessCallback success_callback,
65 ErrorCallback error_callback) {
66 DCHECK(!content_type.empty());
67 std::unique_ptr<URLRequest> url_request = request_context_->CreateRequest(
68 report_uri, DEFAULT_PRIORITY, this, traffic_annotation_);
69 url_request->SetUserData(
70 &kUserDataKey, std::make_unique<CallbackInfo>(std::move(success_callback),
71 std::move(error_callback)));
72 url_request->SetLoadFlags(kLoadFlags);
73 url_request->set_allow_credentials(false);
74 url_request->set_isolation_info_from_network_anonymization_key(
75 network_anonymization_key);
76
77 HttpRequestHeaders extra_headers;
78 extra_headers.SetHeader(HttpRequestHeaders::kContentType, content_type);
79 url_request->SetExtraRequestHeaders(extra_headers);
80
81 url_request->set_method("POST");
82
83 std::vector<char> report_data(report.begin(), report.end());
84 auto reader = std::make_unique<UploadOwnedBytesElementReader>(&report_data);
85 url_request->set_upload(
86 ElementsUploadDataStream::CreateWithReader(std::move(reader), 0));
87
88 URLRequest* raw_url_request = url_request.get();
89 inflight_requests_[raw_url_request] = std::move(url_request);
90 raw_url_request->Start();
91 }
92
OnResponseStarted(URLRequest * request,int net_error)93 void ReportSender::OnResponseStarted(URLRequest* request, int net_error) {
94 DCHECK_NE(ERR_IO_PENDING, net_error);
95
96 CallbackInfo* callback_info =
97 static_cast<CallbackInfo*>(request->GetUserData(&kUserDataKey));
98 DCHECK(callback_info);
99 if (net_error != OK) {
100 DVLOG(1) << "Failed to send report for " << request->url().host();
101 callback_info->RunErrorCallback(request->url(), net_error, -1);
102 } else if (request->GetResponseCode() != net::HTTP_OK) {
103 callback_info->RunErrorCallback(request->url(), OK,
104 request->GetResponseCode());
105 } else {
106 callback_info->RunSuccessCallback();
107 }
108 CHECK_GT(inflight_requests_.erase(request), 0u);
109 }
110
OnReadCompleted(URLRequest * request,int bytes_read)111 void ReportSender::OnReadCompleted(URLRequest* request, int bytes_read) {
112 NOTREACHED();
113 }
114
115 } // namespace net
116