Add Content-Type header to net::ReportSender reports

net/url_request/report_sender.cc

 // Copyright 2015 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/url_request/report_sender.h"
 
 #include <utility>
 
 #include "base/stl_util.h"
 #include "net/base/elements_upload_data_stream.h"
@@ skipping 14 matching lines @@
                            const ErrorCallback& error_callback)
     : request_context_(request_context),
       cookies_preference_(cookies_preference),
       error_callback_(error_callback) {}
 
 ReportSender::~ReportSender() {
   // Cancel all of the uncompleted requests.
   base::STLDeleteElements(&inflight_requests_);
 }
 
-void ReportSender::Send(const GURL& report_uri, const std::string& report) {
+void ReportSender::Send(const GURL& report_uri,
+                        base::StringPiece content_type,
+                        base::StringPiece report) {
+  DCHECK(!content_type.empty());

[Nathan Parker, 2016/09/26 23:53:25]

Can you DCHECK that content_type is a probably-valid content type?  I'm not sure
how you'd do that, but it would catch the case where the caller accidentally
swaps the two StringPieces (since the compiler won't catch that).

[eroman, 2016/09/27 00:03:34]

Or if JSON and application/octet-stream are going to be the only supported types
in practice, could make this an enum

[estark, 2016/09/27 04:05:20]

I like the enum idea, but I can't figure out how to do it in a non-weird way.
That is, if I define the enum in net::TransportSecurityState, that means that
things like components/certificate_reporting that otherwise know nothing about
net::TransportSecurityState would be using the net::TransportSecurityState enum
to call ReportSender::Send(). That seems weird and probably indicates that
there's something weird about the way these classes are set up...

   std::unique_ptr<URLRequest> url_request =
       request_context_->CreateRequest(report_uri, DEFAULT_PRIORITY, this);
 
   int load_flags =
       LOAD_BYPASS_CACHE | LOAD_DISABLE_CACHE | LOAD_DO_NOT_SEND_AUTH_DATA;
   if (cookies_preference_ != SEND_COOKIES) {
     load_flags |= LOAD_DO_NOT_SEND_COOKIES | LOAD_DO_NOT_SAVE_COOKIES;
   }
   url_request->SetLoadFlags(load_flags);
 
+  HttpRequestHeaders extra_headers;
+  extra_headers.SetHeader(HttpRequestHeaders::kContentType, content_type);
+  url_request->SetExtraRequestHeaders(extra_headers);
+
   url_request->set_method("POST");
 
-  std::unique_ptr<UploadElementReader> reader(
-      UploadOwnedBytesElementReader::CreateWithString(report));
+  std::unique_ptr<UploadElementReader> reader(new UploadOwnedBytesElementReader(
+      new std::vector<char>(report.data(), report.data() + report.length())));

[eroman, 2016/09/26 23:40:55]

nit: For terser code: (report.begin(), report.end())

[estark, 2016/09/27 04:05:20]

Done.

   url_request->set_upload(
       ElementsUploadDataStream::CreateWithReader(std::move(reader), 0));
 
   URLRequest* raw_url_request = url_request.get();
   inflight_requests_.insert(url_request.release());
   raw_url_request->Start();
 }
 
 void ReportSender::SetErrorCallback(const ErrorCallback& error_callback) {
   error_callback_ = error_callback;
@@ skipping 11 matching lines @@
   CHECK_GT(inflight_requests_.erase(request), 0u);
   // Clean up the request, which cancels it.
   delete request;
 }
 
 void ReportSender::OnReadCompleted(URLRequest* request, int bytes_read) {
   NOTREACHED();
 }
 
 }  // namespace net