Upstream version 7.36.149.0

[platform/framework/web/crosswalk.git] / src / components / domain_reliability / config.cc

diff --git a/src/components/domain_reliability/config.cc b/src/components/domain_reliability/config.cc
index 03d4597..c8e9793 100644 (file)
--- a/src/components/domain_reliability/config.cc
+++ b/src/components/domain_reliability/config.cc
@@ -2,8 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+// Make sure stdint.h includes SIZE_MAX. (See C89, p259, footnote 221.)
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
 #include "components/domain_reliability/config.h"
 
+#include <stdint.h>
+
 #include "base/json/json_reader.h"
 #include "base/json/json_value_converter.h"
 #include "base/rand_util.h"
@@ -16,21 +23,27 @@ bool ConvertURL(const base::StringPiece& string_piece, GURL* url) {
   return url->is_valid();
 }
 
+bool IsValidSampleRate(double p) { return p >= 0.0 && p <= 1.0; }
+
 }  // namespace
 
 namespace domain_reliability {
 
-DomainReliabilityConfig::Resource::Resource() {}
+// static
+const size_t DomainReliabilityConfig::kInvalidResourceIndex = SIZE_MAX;
 
+DomainReliabilityConfig::Resource::Resource() {
+}
 DomainReliabilityConfig::Resource::~Resource() {}
 
-bool DomainReliabilityConfig::Resource::MatchesUrlString(
-    const std::string& url_string) const {
-  ScopedVector<std::string>::const_iterator it;
+bool DomainReliabilityConfig::Resource::MatchesUrl(const GURL& url) const {
+  const std::string& spec = url.spec();
 
-  for (it = url_patterns.begin(); it != url_patterns.end(); it++)
-    if (MatchPattern(url_string, **it))
+  ScopedVector<std::string>::const_iterator it;
+  for (it = url_patterns.begin(); it != url_patterns.end(); it++) {
+    if (MatchPattern(spec, **it))
       return true;
+  }
 
   return false;
 }
@@ -38,6 +51,7 @@ bool DomainReliabilityConfig::Resource::MatchesUrlString(
 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;
 }
 
@@ -52,8 +66,13 @@ void DomainReliabilityConfig::Resource::RegisterJSONConverter(
                                  &Resource::failure_sample_rate);
 }
 
-DomainReliabilityConfig::Collector::Collector() {}
+bool DomainReliabilityConfig::Resource::IsValid() const {
+  return !name.empty() && !url_patterns.empty() &&
+      IsValidSampleRate(success_sample_rate) &&
+      IsValidSampleRate(failure_sample_rate);
+}
 
+DomainReliabilityConfig::Collector::Collector() {}
 DomainReliabilityConfig::Collector::~Collector() {}
 
 // static
@@ -63,42 +82,71 @@ void DomainReliabilityConfig::Collector::RegisterJSONConverter(
                                        &ConvertURL);
 }
 
-DomainReliabilityConfig::DomainReliabilityConfig() {}
+bool DomainReliabilityConfig::Collector::IsValid() const {
+  return upload_url.is_valid();
+}
 
+DomainReliabilityConfig::DomainReliabilityConfig() : valid_until(0.0) {}
 DomainReliabilityConfig::~DomainReliabilityConfig() {}
 
 // static
 scoped_ptr<const DomainReliabilityConfig> DomainReliabilityConfig::FromJSON(
     const base::StringPiece& json) {
-  base::Value* value = base::JSONReader::Read(json);
-  if (!value)
-    return scoped_ptr<const DomainReliabilityConfig>();
-
-  DomainReliabilityConfig* config = new DomainReliabilityConfig();
+  scoped_ptr<base::Value> value(base::JSONReader::Read(json));
   base::JSONValueConverter<DomainReliabilityConfig> converter;
-  if (!converter.Convert(*value, config)) {
+  DomainReliabilityConfig* config = new DomainReliabilityConfig();
+
+  // If we can parse and convert the JSON into a valid config, return that.
+  if (value && converter.Convert(*value, config) && config->IsValid())
+    return scoped_ptr<const DomainReliabilityConfig>(config);
+  else
     return scoped_ptr<const DomainReliabilityConfig>();
+}
+
+bool DomainReliabilityConfig::IsValid() const {
+  if (valid_until == 0.0 || domain.empty() || version.empty() ||
+      resources.empty() || collectors.empty()) {
+    return false;
   }
 
-  return scoped_ptr<const DomainReliabilityConfig>(config);
+  for (size_t i = 0; i < resources.size(); ++i) {
+    if (!resources[i]->IsValid())
+      return false;
+  }
+
+  for (size_t i = 0; i < collectors.size(); ++i) {
+    if (!collectors[i]->IsValid())
+      return false;
+  }
+
+  return true;
+}
+
+bool DomainReliabilityConfig::IsExpired(base::Time now) const {
+  DCHECK_NE(0.0, valid_until);
+  base::Time valid_until_time = base::Time::FromDoubleT(valid_until);
+  return now > valid_until_time;
 }
 
-int DomainReliabilityConfig::GetResourceIndexForUrl(const GURL& url) const {
-  const std::string& url_string = url.spec();
+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]->MatchesUrlString(url_string))
-      return static_cast<int>(i);
+    if (resources[i]->MatchesUrl(sanitized_url))
+      return i;
   }
 
-  return -1;
+  return kInvalidResourceIndex;
 }
 
 // static
 void DomainReliabilityConfig::RegisterJSONConverter(
     base::JSONValueConverter<DomainReliabilityConfig>* converter) {
   converter->RegisterStringField("config_version",
-                                 &DomainReliabilityConfig::config_version);
+                                 &DomainReliabilityConfig::version);
+  converter->RegisterDoubleField("config_valid_until",
+                                 &DomainReliabilityConfig::valid_until);
   converter->RegisterStringField("monitored_domain",
                                  &DomainReliabilityConfig::domain);
   converter->RegisterRepeatedMessage("monitored_resources",