Add Content-Type header to net::ReportSender reports

net/url_request/report_sender_unittest.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
@@ skipping 69 matching lines @@
 
   void set_expect_url(const GURL& expect_url) { expect_url_ = expect_url; }
 
   size_t num_requests() const { return num_requests_; }
 
   // Sets whether cookies are expected to be sent on requests.
   void set_expect_cookies(bool expect_cookies) {
     expect_cookies_ = expect_cookies;
   }
 
+  void set_expected_content_type(const std::string& content_type) {
+    expected_content_type_ = content_type;
+  }
+
   // NetworkDelegateImpl implementation.
   int OnBeforeURLRequest(URLRequest* request,
                          const CompletionCallback& callback,
                          GURL* new_url) override {
     num_requests_++;
     EXPECT_EQ(expect_url_, request->url());
     EXPECT_STRCASEEQ("POST", request->method().data());
 
     if (expect_cookies_) {
       EXPECT_FALSE(request->load_flags() & LOAD_DO_NOT_SEND_COOKIES);
       EXPECT_FALSE(request->load_flags() & LOAD_DO_NOT_SAVE_COOKIES);
     } else {
       EXPECT_TRUE(request->load_flags() & LOAD_DO_NOT_SEND_COOKIES);
       EXPECT_TRUE(request->load_flags() & LOAD_DO_NOT_SAVE_COOKIES);
     }
 
+    const HttpRequestHeaders& extra_headers = request->extra_request_headers();
+    std::string content_type;
+    EXPECT_TRUE(extra_headers.GetHeader(HttpRequestHeaders::kContentType,
+                                        &content_type));
+    EXPECT_EQ(expected_content_type_, content_type);
+
     CheckUploadData(*request, &expect_reports_);
 
     // Unconditionally return OK, since the sender ignores the results
     // anyway.
     return OK;
   }
 
   void OnURLRequestDestroyed(URLRequest* request) override {
     url_request_destroyed_callback_.Run();
     if (expect_reports_.empty())
       all_url_requests_destroyed_callback_.Run();
   }
 
  private:
   base::Closure url_request_destroyed_callback_;
   base::Closure all_url_requests_destroyed_callback_;
   size_t num_requests_;
   GURL expect_url_;
   std::set<std::string> expect_reports_;
   bool expect_cookies_;
+  std::string expected_content_type_;
 
   DISALLOW_COPY_AND_ASSIGN(TestReportSenderNetworkDelegate);
 };
 
 class ReportSenderTest : public ::testing::Test {
  public:
   ReportSenderTest() : context_(true) {
     context_.set_network_delegate(&network_delegate_);
     context_.Init();
   }
@@ skipping 11 matching lines @@
   void SendReport(ReportSender* reporter,
                   const std::string& report,
                   const GURL& url,
                   size_t request_sequence_number) {
     base::RunLoop run_loop;
     network_delegate_.set_url_request_destroyed_callback(
         run_loop.QuitClosure());
 
     network_delegate_.set_expect_url(url);
     network_delegate_.ExpectReport(report);
+    network_delegate_.set_expected_content_type("application/foobar");
 
     EXPECT_EQ(request_sequence_number, network_delegate_.num_requests());
 
-    reporter->Send(url, report);
+    reporter->Send(url, "application/foobar", report);
 
     // The report is sent asynchronously, so wait for the report's
     // URLRequest to be destroyed before checking that the report was
     // sent.
     run_loop.Run();
 
     EXPECT_EQ(request_sequence_number + 1, network_delegate_.num_requests());
   }
 
   TestReportSenderNetworkDelegate network_delegate_;
@@ skipping 19 matching lines @@
 
 TEST_F(ReportSenderTest, SendMultipleReportsSimultaneously) {
   base::RunLoop run_loop;
   network_delegate_.set_all_url_requests_destroyed_callback(
       run_loop.QuitClosure());
 
   GURL url = URLRequestMockDataJob::GetMockHttpsUrl("dummy data", 1);
   network_delegate_.set_expect_url(url);
   network_delegate_.ExpectReport(kDummyReport);
   network_delegate_.ExpectReport(kSecondDummyReport);
+  network_delegate_.set_expected_content_type("application/foobar");
 
   ReportSender reporter(context(), ReportSender::DO_NOT_SEND_COOKIES);
 
   EXPECT_EQ(0u, network_delegate_.num_requests());
 
-  reporter.Send(url, kDummyReport);
-  reporter.Send(url, kSecondDummyReport);
+  reporter.Send(url, "application/foobar", kDummyReport);
+  reporter.Send(url, "application/foobar", kSecondDummyReport);
 
   run_loop.Run();
 
   EXPECT_EQ(2u, network_delegate_.num_requests());
 }
 
 // Test that pending URLRequests get cleaned up when the report sender
 // is deleted.
 TEST_F(ReportSenderTest, PendingRequestGetsDeleted) {
   bool url_request_destroyed = false;
   network_delegate_.set_url_request_destroyed_callback(base::Bind(
       &MarkURLRequestDestroyed, base::Unretained(&url_request_destroyed)));
 
   GURL url = URLRequestFailedJob::GetMockHttpUrlWithFailurePhase(
       URLRequestFailedJob::START, ERR_IO_PENDING);
   network_delegate_.set_expect_url(url);
   network_delegate_.ExpectReport(kDummyReport);
+  network_delegate_.set_expected_content_type("application/foobar");
 
   EXPECT_EQ(0u, network_delegate_.num_requests());
 
   std::unique_ptr<ReportSender> reporter(
       new ReportSender(context(), ReportSender::DO_NOT_SEND_COOKIES));
-  reporter->Send(url, kDummyReport);
+  reporter->Send(url, "application/foobar", kDummyReport);
   reporter.reset();
 
   EXPECT_EQ(1u, network_delegate_.num_requests());
   EXPECT_TRUE(url_request_destroyed);
 }
 
 // Test that a request that returns an error gets cleaned up.
 TEST_F(ReportSenderTest, ErroredRequestGetsDeleted) {
   GURL url = URLRequestFailedJob::GetMockHttpsUrl(ERR_FAILED);
   ReportSender reporter(context(), ReportSender::DO_NOT_SEND_COOKIES);
@@ skipping 38 matching lines @@
 TEST_F(ReportSenderTest, DoNotSendCookiesPreference) {
   GURL url = URLRequestMockDataJob::GetMockHttpsUrl("dummy data", 1);
   ReportSender reporter(context(), ReportSender::DO_NOT_SEND_COOKIES);
 
   network_delegate_.set_expect_cookies(false);
   SendReport(&reporter, kDummyReport, url, 0);
 }
 
 }  // namespace
 }  // namespace net