Domain Reliability: Simplify configs and reports

components/domain_reliability/config.cc

Index: components/domain_reliability/config.cc
diff --git a/components/domain_reliability/config.cc b/components/domain_reliability/config.cc
index 021c6a7281faf31efa3c5d60e5afa88a00bf4997..46fa53aa069e9dd5a696f816a9b3d2136c87f236 100644
--- a/components/domain_reliability/config.cc
+++ b/components/domain_reliability/config.cc
@@ -20,74 +20,33 @@
 
 namespace {
 
-bool ConvertURL(const base::StringPiece& string_piece, GURL* url) {
-  *url = GURL(string_piece.as_string());
+bool ConvertURL(const base::Value* value, GURL* url) {
+  std::string url_string;
+  if (!value->GetAsString(&url_string))
+    return false;
+  *url = GURL(url_string);
   return url->is_valid();
 }
 
-bool IsValidSampleRate(double p) { return p >= 0.0 && p <= 1.0; }
-
-}  // namespace
-
-namespace domain_reliability {
-
-// static
-const size_t DomainReliabilityConfig::kInvalidResourceIndex = SIZE_MAX;
-
-DomainReliabilityConfig::Resource::Resource() {
-}
-DomainReliabilityConfig::Resource::~Resource() {}
-
-bool DomainReliabilityConfig::Resource::MatchesUrl(const GURL& url) const {
-  const std::string& spec = url.spec();
-
-  for (const auto& url_pattern : url_patterns) {
-    if (base::MatchPattern(spec, *url_pattern))
-      return true;
-  }
-
-  return false;
-}
-
-bool DomainReliabilityConfig::Resource::DecideIfShouldReportRequest(
-    bool success) const {
-  double sample_rate = success ? success_sample_rate : failure_sample_rate;
-  DCHECK(IsValidSampleRate(sample_rate));
-  return base::RandDouble() < sample_rate;
-}
-
-// static
-void DomainReliabilityConfig::Resource::RegisterJSONConverter(
-    base::JSONValueConverter<DomainReliabilityConfig::Resource>* converter) {
-  converter->RegisterStringField("resource_name", &Resource::name);
-  converter->RegisterRepeatedString("url_patterns", &Resource::url_patterns);
-  converter->RegisterDoubleField("success_sample_rate",
-                                 &Resource::success_sample_rate);
-  converter->RegisterDoubleField("failure_sample_rate",
-                                 &Resource::failure_sample_rate);
+bool ConvertOrigin(const base::Value* value, GURL* url) {
+  return ConvertURL(value, url) && !url->has_username() &&
+         !url->has_password() && url->SchemeIs("https") &&
+         url->path_piece() == "/" && !url->has_query() && !url->has_ref();
 }
 
-bool DomainReliabilityConfig::Resource::IsValid() const {
-  return !name.empty() && !url_patterns.empty() &&
-      IsValidSampleRate(success_sample_rate) &&
-      IsValidSampleRate(failure_sample_rate);
+bool IsValidSampleRate(double p) {
+  return p >= 0.0 && p <= 1.0;
 }
 
-DomainReliabilityConfig::Collector::Collector() {}
-DomainReliabilityConfig::Collector::~Collector() {}
+}  // namespace
 
-// static
-void DomainReliabilityConfig::Collector::RegisterJSONConverter(
-    base::JSONValueConverter<DomainReliabilityConfig::Collector>* converter) {
-  converter->RegisterCustomField<GURL>("upload_url", &Collector::upload_url,
-                                       &ConvertURL);
-}
+namespace domain_reliability {
 
-bool DomainReliabilityConfig::Collector::IsValid() const {
-  return upload_url.is_valid();
+DomainReliabilityConfig::DomainReliabilityConfig()
+    : include_subdomains(false),
+      success_sample_rate(-1.0),
+      failure_sample_rate(-1.0) {
 }
-
-DomainReliabilityConfig::DomainReliabilityConfig() {}
 DomainReliabilityConfig::~DomainReliabilityConfig() {}
 
 // static
@@ -104,45 +63,40 @@ scoped_ptr<const DomainReliabilityConfig> DomainReliabilityConfig::FromJSON(
 }
 
 bool DomainReliabilityConfig::IsValid() const {
-  if (domain.empty() || resources.empty() || collectors.empty())
+  if (!origin.is_valid() || collectors.empty() ||
+      !IsValidSampleRate(success_sample_rate) ||
+      !IsValidSampleRate(failure_sample_rate)) {
     return false;
-
-  for (auto& resource : resources) {
-    if (!resource->IsValid())
-      return false;
   }
 
-  for (auto& collector : collectors) {
-    if (!collector->IsValid())
+  for (const auto& url : collectors) {
+    if (!url->is_valid())
       return false;
   }
 
   return true;
 }
 
-size_t DomainReliabilityConfig::GetResourceIndexForUrl(const GURL& url) const {
-  // Removes username, password, and fragment.
-  GURL sanitized_url = url.GetAsReferrer();
-
-  for (size_t i = 0; i < resources.size(); ++i) {
-    if (resources[i]->MatchesUrl(sanitized_url))
-      return i;
-  }
-
-  return kInvalidResourceIndex;
+bool DomainReliabilityConfig::DecideIfShouldReportRequest(bool success) const {
+  double sample_rate = success ? success_sample_rate : failure_sample_rate;
+  return base::RandDouble() < sample_rate;
 }
 
 // static
 void DomainReliabilityConfig::RegisterJSONConverter(
     base::JSONValueConverter<DomainReliabilityConfig>* converter) {
-  converter->RegisterStringField("config_version",
-                                 &DomainReliabilityConfig::version);
-  converter->RegisterStringField("monitored_domain",
-                                 &DomainReliabilityConfig::domain);
-  converter->RegisterRepeatedMessage("monitored_resources",
-                                     &DomainReliabilityConfig::resources);
-  converter->RegisterRepeatedMessage("collectors",
-                                     &DomainReliabilityConfig::collectors);
+  converter->RegisterCustomValueField<GURL>(
+      "origin", &DomainReliabilityConfig::origin, &ConvertOrigin);
+  converter->RegisterBoolField("include_subdomains",
+                               &DomainReliabilityConfig::include_subdomains);
+  converter->RegisterRepeatedCustomValue(
+      "collectors", &DomainReliabilityConfig::collectors, &ConvertURL);
+  converter->RegisterRepeatedString("path_prefixes",
+                                    &DomainReliabilityConfig::path_prefixes);
+  converter->RegisterDoubleField("success_sample_rate",
+                                 &DomainReliabilityConfig::success_sample_rate);
+  converter->RegisterDoubleField("failure_sample_rate",
+                                 &DomainReliabilityConfig::failure_sample_rate);
 }
 
 }  // namespace domain_reliability