Add retry information to certificate reports.

chrome/browser/safe_browsing/certificate_reporting_service_test_utils.h

 // Copyright 2016 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.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_CERTIFICATE_REPORTING_SERVICE_TEST_UTILS_H_
 #define CHROME_BROWSER_SAFE_BROWSING_CERTIFICATE_REPORTING_SERVICE_TEST_UTILS_H_
 
-#include <set>
+#include <unordered_set>

[estark, 2017/01/13 23:26:22]

looks like you're using normal <set> below; did you mean to change this?

[meacer, 2017/01/17 22:24:27]

Changed to unordered_map.

 
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/threading/non_thread_safe.h"
 #include "chrome/browser/safe_browsing/certificate_reporting_service.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_job.h"
 
 namespace net {
 class NetworkDelegate;
 }
 
 namespace certificate_reporting_test_utils {
 
+// Struct that wraps information about observed reports.
+struct ObservedReport {
+  std::string hostname;
+  bool is_retried;
+
+  ObservedReport(const std::string& hostname, bool is_retried);
+
+  // For std::set:
+  bool operator<(const ObservedReport& other) const;
+  bool operator==(const ObservedReport& other) const;
+
+  static ObservedReport Retried(const std::string& hostname);
+  static ObservedReport NotRetried(const std::string& hostname);
+};
+
 // Syntactic sugar for wrapping report expectations in a more readable way.
 // Passed to WaitForRequestDeletions() as input.
 // Example:
 // The following expects report0 and report1 to be successfully sent and their
 // URL requests to be deleted:
 // WaitForRequestsDestroyed(
 //     ReportExpectation::Successful("report0, report1"));
 struct ReportExpectation {
   ReportExpectation();
   ReportExpectation(const ReportExpectation& other);
   ~ReportExpectation();
   // Returns an expectation where all reports in |reports| succeed.
-  static ReportExpectation Successful(const std::set<std::string>& reports);
+  static ReportExpectation Successful(const std::set<ObservedReport>& reports);
   // Returns an expectation where all reports in |reports| fail.
-  static ReportExpectation Failed(const std::set<std::string>& reports);
+  static ReportExpectation Failed(const std::set<ObservedReport>& reports);
   // Returns an expectation where all reports in |reports| are delayed.
-  static ReportExpectation Delayed(const std::set<std::string>& reports);
+  static ReportExpectation Delayed(const std::set<ObservedReport>& reports);
   // Total number of reports expected.
   int num_reports() const;
-  std::set<std::string> successful_reports;
-  std::set<std::string> failed_reports;
-  std::set<std::string> delayed_reports;
+  std::set<ObservedReport> successful_reports;
+  std::set<ObservedReport> failed_reports;
+  std::set<ObservedReport> delayed_reports;
 };
 
 // Failure mode of the report sending attempts.
 enum ReportSendingResult {
   // Report send attempts should be successful.
   REPORTS_SUCCESSFUL,
   // Report send attempts should fail.
   REPORTS_FAIL,
   // Report send attempts should hang until explicitly resumed.
   REPORTS_DELAY,
 };
 
 // Helper class to wait for a number of events (e.g. request destroyed, report
 // observed).
 class RequestObserver {
  public:
   RequestObserver();
   ~RequestObserver();
 
   // Waits for |num_request| requests to be created or destroyed, depending on
   // whichever one this class observes.
   void Wait(unsigned int num_events_to_wait_for);
 
   // Called when a request created or destroyed, depending on whichever one this
   // class observes.
-  void OnRequest(const std::string& serialized_report,
+  void OnRequest(const ObservedReport& observed_report,
                  ReportSendingResult report_type);
 
   // These must be called on the UI thread.
-  const std::set<std::string>& successful_reports() const;
-  const std::set<std::string>& failed_reports() const;
-  const std::set<std::string>& delayed_reports() const;
+  const std::set<ObservedReport>& successful_reports() const;
+  const std::set<ObservedReport>& failed_reports() const;
+  const std::set<ObservedReport>& delayed_reports() const;
   void ClearObservedReports();
 
  private:
   unsigned int num_events_to_wait_for_;
   unsigned int num_received_events_;
   std::unique_ptr<base::RunLoop> run_loop_;
 
-  std::set<std::string> successful_reports_;
-  std::set<std::string> failed_reports_;
-  std::set<std::string> delayed_reports_;
+  std::set<ObservedReport> successful_reports_;
+  std::set<ObservedReport> failed_reports_;
+  std::set<ObservedReport> delayed_reports_;
 };
 
 // A URLRequestJob that can be delayed until Resume() is called. Returns an
 // empty response. If Resume() is called before a request is made, then the
 // request will not be delayed. If not delayed, it can return a failed or a
 // successful URL request job.
 class DelayableCertReportURLRequestJob : public net::URLRequestJob,
                                          public base::NonThreadSafe {
  public:
   DelayableCertReportURLRequestJob(
@@ skipping 45 matching lines @@
   // Resumes any hanging URL request and runs callback when the request
   // is resumed (i.e. response starts). Must be called on the UI thread.
   void Resume();
 
   RequestObserver* request_created_observer() const;
   RequestObserver* request_destroyed_observer() const;
 
  private:
   void SetFailureModeOnIOThread(ReportSendingResult expected_report_result);
   void ResumeOnIOThread();
-  void RequestCreated(const std::string& uploaded_report,
+  void RequestCreated(const std::string& serialized_report,
                       ReportSendingResult expected_report_result) const;
-  void RequestDestructed(const std::string& uploaded_report,
+  void RequestDestructed(const std::string& serialized_report,
                          ReportSendingResult expected_report_result) const;
 
   mutable std::set<std::string> successful_reports_;
   mutable std::set<std::string> failed_reports_;
   mutable std::set<std::string> delayed_reports_;
 
   ReportSendingResult expected_report_result_;
 
   // Private key to decrypt certificate reports.
   const uint8_t* server_private_key_;
@@ skipping 62 matching lines @@
 
   uint8_t server_public_key_[32];
   uint8_t server_private_key_[32];
 
   DISALLOW_COPY_AND_ASSIGN(CertificateReportingServiceTestHelper);
 };
 
 }  // namespace certificate_reporting_test_utils
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_CERTIFICATE_REPORTING_SERVICE_TEST_UTILS_H_