Domain Reliability: Simplify configs and reports

components/domain_reliability/util.cc

 // Copyright 2014 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/domain_reliability/util.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
@@ skipping 49 matching lines @@
   { net::ERR_REQUEST_RANGE_NOT_SATISFIABLE,
         "http.request.range_not_satisfiable" },
   { net::ERR_INVALID_RESPONSE, "http.response.invalid" },
   { net::ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION,
         "http.response.headers.multiple_content_disposition" },
   { net::ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH,
         "http.response.headers.multiple_content_length" },
   { net::ERR_SSL_UNRECOGNIZED_NAME_ALERT, "ssl.unrecognized_name_alert" }
 };
 
+bool CanReportFullBeaconURLToCollector(const GURL& beacon_url,
+                                       const GURL& collector_url) {
+  return beacon_url.GetOrigin() == collector_url.GetOrigin();
+}
+
 }  // namespace
 
 // static
 bool GetDomainReliabilityBeaconStatus(
     int net_error,
     int http_response_code,
     std::string* beacon_status_out) {
   if (net_error == net::OK) {
     if (http_response_code >= 400 && http_response_code < 600)
       *beacon_status_out = "http.error";
@@ skipping 67 matching lines @@
       retry_after != base::TimeDelta()) {
     result->status = DomainReliabilityUploader::UploadResult::RETRY_AFTER;
     result->retry_after = retry_after;
     return;
   }
 
   result->status = DomainReliabilityUploader::UploadResult::FAILURE;
   return;
 }
 
+// N.B. This uses a ScopedVector because that's what JSONValueConverter uses
+// for repeated fields of any type, and Config uses JSONValueConverter to parse
+// JSON configs.
+GURL SanitizeURLForReport(const GURL& beacon_url,
+                          const GURL& collector_url,
+                          const ScopedVector<std::string>& path_prefixes) {
+  if (CanReportFullBeaconURLToCollector(beacon_url, collector_url))
+    return beacon_url.GetAsReferrer();
+
+  std::string path = beacon_url.path();
+  const std::string empty_path;
+  const std::string* longest_path_prefix = &empty_path;
+  for (const std::string* path_prefix : path_prefixes) {
+    if (path.substr(0, path_prefix->length()) == *path_prefix &&
+        path_prefix->length() > longest_path_prefix->length()) {
+      longest_path_prefix = path_prefix;
+    }
+  }
+
+  GURL::Replacements replacements;
+  replacements.ClearUsername();
+  replacements.ClearPassword();
+  replacements.SetPathStr(*longest_path_prefix);
+  replacements.ClearQuery();
+  replacements.ClearRef();
+  return beacon_url.ReplaceComponents(replacements);
+}
+
 namespace {
 
 class ActualTimer : public MockableTime::Timer {
  public:
   // Initialize base timer with retain_user_info and is_repeating false.
   ActualTimer() : base_timer_(false, false) {}
 
   ~ActualTimer() override {}
 
   // MockableTime::Timer implementation:
@@ skipping 23 matching lines @@
 ActualTime::~ActualTime() {}
 
 base::Time ActualTime::Now() { return base::Time::Now(); }
 base::TimeTicks ActualTime::NowTicks() { return base::TimeTicks::Now(); }
 
 scoped_ptr<MockableTime::Timer> ActualTime::CreateTimer() {
   return scoped_ptr<MockableTime::Timer>(new ActualTimer());
 }
 
 }  // namespace domain_reliability