Add response code to the success callback of ReportSender

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 36 matching lines @@
   EXPECT_EQ(1u, expect_reports->erase(upload_data));
 }
 
 // Provides an error callback for report sending that sets |called| to
 // true.
 void ErrorCallback(bool* called, const GURL& report_uri, int net_error) {
   EXPECT_NE(OK, net_error);
   *called = true;
 }
 
-void SuccessCallback(bool* called) {
+void SuccessCallback(bool* called, int response_code) {
   *called = true;
 }
 
 // A network delegate that lets tests check that a report
 // was sent. It counts the number of requests and lets tests register a
 // callback to run when the request is destroyed. It also checks that
 // the uploaded data is as expected.
 class TestReportSenderNetworkDelegate : public NetworkDelegateImpl {
  public:
   TestReportSenderNetworkDelegate()
@@ skipping 89 matching lines @@
   void TearDown() override { URLRequestFilter::GetInstance()->ClearHandlers(); }
 
   TestURLRequestContext* context() { return &context_; }
 
  protected:
   void SendReport(
       ReportSender* reporter,
       const std::string& report,
       const GURL& url,
       size_t request_sequence_number,
-      const base::Callback<void()>& success_callback,
+      const base::Callback<void(int)>& success_callback,
       const base::Callback<void(const GURL&, int)>& error_callback) {
     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, "application/foobar", report, success_callback,
                    error_callback);
 
     // 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());
   }
 
   void SendReport(ReportSender* reporter,
                   const std::string& report,
                   const GURL& url,
                   size_t request_sequence_number) {
-    SendReport(reporter, report, url, request_sequence_number, base::Closure(),
+    SendReport(reporter, report, url, request_sequence_number,
+               base::Callback<void(int)>(),
                base::Callback<void(const GURL&, int)>());
   }
 
   TestReportSenderNetworkDelegate network_delegate_;
 
  private:
   TestURLRequestContext context_;
 };
 
 // Test that ReportSender::Send creates a URLRequest for the
@@ skipping 19 matching lines @@
   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, "application/foobar", kDummyReport, base::Closure(),
+  reporter.Send(url, "application/foobar", kDummyReport,
+                base::Callback<void(int)>(),
                 base::Callback<void(const GURL&, int)>());
-  reporter.Send(url, "application/foobar", kSecondDummyReport, base::Closure(),
+  reporter.Send(url, "application/foobar", kSecondDummyReport,
+                base::Callback<void(int)>(),
                 base::Callback<void(const GURL&, int)>());
 
   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, "application/foobar", kDummyReport, base::Closure(),
+  reporter->Send(url, "application/foobar", kDummyReport,
+                 base::Callback<void(int)>(),
                  base::Callback<void(const GURL&, int)>());
   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);
@@ skipping 45 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