Add response code to the success callback of ReportSender

components/certificate_reporting/error_reporter_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 "components/certificate_reporting/error_reporter.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "components/certificate_reporting/encrypted_cert_logger.pb.h"
+#include "net/http/http_status_code.h"
 #include "net/test/url_request/url_request_failed_job.h"
 #include "net/test/url_request/url_request_mock_data_job.h"
 #include "net/url_request/report_sender.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/boringssl/src/include/openssl/curve25519.h"
 
 namespace certificate_reporting {
 
 namespace {
 
 const char kDummyHttpReportUri[] = "http://example.test";
 const char kDummyHttpsReportUri[] = "https://example.test";
 const char kDummyReport[] = "a dummy report";
 const uint32_t kServerPublicKeyTestVersion = 16;
 
-void ErrorCallback(bool* called, const GURL& report_uri, int net_error) {
-  EXPECT_NE(net::OK, net_error);
+void ErrorCallback(bool* called,
+                   const GURL& report_uri,
+                   int net_error,
+                   int http_response_code) {
+  if (net_error == net::OK) {
+    EXPECT_NE(net::HTTP_OK, http_response_code);

[estark, 2017/04/27 00:35:57]

Is there a test that exercises this?

[meacer, 2017/04/27 00:56:42]

I reverted this change as this test will always get net error because of
MockCertificateReportSender. I think the non net-error case is sufficiently
tested in net/url_request/report_sender_unittest.cc and doing the same here
would duplicate the code there. WDYT?

+  }
   *called = true;
 }
 
 void SuccessCallback(bool* called) {
   *called = true;
 }
 
 // A mock ReportSender that keeps track of the last report
 // sent.
 class MockCertificateReportSender : public net::ReportSender {
  public:
   MockCertificateReportSender()
       : net::ReportSender(nullptr, DO_NOT_SEND_COOKIES) {}
   ~MockCertificateReportSender() override {}
 
-  void Send(
-      const GURL& report_uri,
-      base::StringPiece content_type,
-      base::StringPiece report,
-      const base::Callback<void()>& success_callback,
-      const base::Callback<void(const GURL&, int)>& error_callback) override {
+  void Send(const GURL& report_uri,
+            base::StringPiece content_type,
+            base::StringPiece report,
+            const base::Callback<void()>& success_callback,
+            const base::Callback<void(const GURL&, int, int)>& error_callback)
+      override {
     latest_report_uri_ = report_uri;
     report.CopyToString(&latest_report_);
     content_type.CopyToString(&latest_content_type_);
   }
 
   const GURL& latest_report_uri() const { return latest_report_uri_; }
 
   const std::string& latest_report() const { return latest_report_; }
 
   const std::string& latest_content_type() const {
@@ skipping 51 matching lines @@
 // an encrypted or plaintext extended reporting report as appropriate.
 TEST_F(ErrorReporterTest, ExtendedReportingSendReport) {
   // Data should not be encrypted when sent to an HTTPS URL.
   MockCertificateReportSender* mock_report_sender =
       new MockCertificateReportSender();
   GURL https_url(kDummyHttpsReportUri);
   ErrorReporter https_reporter(https_url, server_public_key_,
                                kServerPublicKeyTestVersion,
                                base::WrapUnique(mock_report_sender));
   https_reporter.SendExtendedReportingReport(
-      kDummyReport, base::Closure(), base::Callback<void(const GURL&, int)>());
+      kDummyReport, base::Callback<void()>(),
+      base::Callback<void(const GURL&, int, int)>());
   EXPECT_EQ(mock_report_sender->latest_report_uri(), https_url);
   EXPECT_EQ(mock_report_sender->latest_report(), kDummyReport);
 
   // Data should be encrypted when sent to an HTTP URL.
   MockCertificateReportSender* http_mock_report_sender =
       new MockCertificateReportSender();
-  GURL http_url(kDummyHttpReportUri);
+  const GURL http_url(kDummyHttpReportUri);
   ErrorReporter http_reporter(http_url, server_public_key_,
                               kServerPublicKeyTestVersion,
                               base::WrapUnique(http_mock_report_sender));
   http_reporter.SendExtendedReportingReport(
-      kDummyReport, base::Closure(), base::Callback<void(const GURL&, int)>());
+      kDummyReport, base::Callback<void()>(),
+      base::Callback<void(const GURL&, int, int)>());
 
   EXPECT_EQ(http_mock_report_sender->latest_report_uri(), http_url);
   EXPECT_EQ("application/octet-stream",
             http_mock_report_sender->latest_content_type());
 
   std::string uploaded_report;
   EncryptedCertLoggerRequest encrypted_request;
   ASSERT_TRUE(encrypted_request.ParseFromString(
       http_mock_report_sender->latest_report()));
   EXPECT_EQ(kServerPublicKeyTestVersion,
@@ skipping 10 matching lines @@
 TEST_F(ErrorReporterTest, ErroredRequestCallsCallback) {
   net::URLRequestFailedJob::AddUrlHandler();
 
   base::RunLoop run_loop;
   net::TestURLRequestContext context(true);
   TestCertificateReporterNetworkDelegate test_delegate;
   test_delegate.set_url_request_destroyed_callback(run_loop.QuitClosure());
   context.set_network_delegate(&test_delegate);
   context.Init();
 
-  GURL report_uri(
+  const GURL report_uri(
       net::URLRequestFailedJob::GetMockHttpUrl(net::ERR_CONNECTION_FAILED));
   ErrorReporter reporter(&context, report_uri,
                          net::ReportSender::DO_NOT_SEND_COOKIES);
 
   bool error_callback_called = false;
   bool success_callback_called = false;
   reporter.SendExtendedReportingReport(
       kDummyReport, base::Bind(&SuccessCallback, &success_callback_called),
       base::Bind(&ErrorCallback, &error_callback_called));
   run_loop.Run();
 
   EXPECT_TRUE(error_callback_called);
   EXPECT_FALSE(success_callback_called);
 }
 
-// Tests that an UMA histogram is recorded if a report fails to send.
+// Tests that an UMA histogram is recorded if a report is successfully sent.

[estark, 2017/04/27 00:35:57]

oof, copy/paste fail, thanks for fixing

 TEST_F(ErrorReporterTest, SuccessfulRequestCallsCallback) {
   net::URLRequestMockDataJob::AddUrlHandler();
 
   base::RunLoop run_loop;
   net::TestURLRequestContext context(true);
   TestCertificateReporterNetworkDelegate test_delegate;
   test_delegate.set_url_request_destroyed_callback(run_loop.QuitClosure());
   context.set_network_delegate(&test_delegate);
   context.Init();
 
-  GURL report_uri(net::URLRequestMockDataJob::GetMockHttpUrl("some data", 1));
+  const GURL report_uri(
+      net::URLRequestMockDataJob::GetMockHttpUrl("some data", 1));
   ErrorReporter reporter(&context, report_uri,
                          net::ReportSender::DO_NOT_SEND_COOKIES);
 
   bool error_callback_called = false;
   bool success_callback_called = false;
   reporter.SendExtendedReportingReport(
       kDummyReport, base::Bind(&SuccessCallback, &success_callback_called),
       base::Bind(&ErrorCallback, &error_callback_called));
   run_loop.Run();
 
@@ skipping 157 matching lines @@
   ASSERT_TRUE(encrypted_request.ParseFromString(
       std::string(reinterpret_cast<const char*>(kSerializedEncryptedReport),
                   sizeof(kSerializedEncryptedReport))));
   ASSERT_TRUE(ErrorReporter::DecryptErrorReport(
       server_private_key_, encrypted_request, &decrypted_serialized_report));
 }
 
 }  // namespace
 
 }  // namespace certificate_reporting