Makes V4UpdateProtocolManager auto-schedule update fetching

components/safe_browsing_db/v4_protocol_manager_util.cc

 // 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.
 
 #include "components/safe_browsing_db/v4_protocol_manager_util.h"
 
 #include "base/base64.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 19 matching lines @@
 
 size_t UpdateListIdentifier::hash() const {
   std::size_t first = std::hash<unsigned int>()(platform_type);
   std::size_t second = std::hash<unsigned int>()(threat_entry_type);
   std::size_t third = std::hash<unsigned int>()(threat_type);
 
   std::size_t interim = base::HashInts(first, second);
   return base::HashInts(interim, third);
 }
 
+V4ProtocolConfig::V4ProtocolConfig() : disable_auto_update(false) {}
+
+V4ProtocolConfig::~V4ProtocolConfig() {}
+
 // static
 // Backoff interval is MIN(((2^(n-1))*15 minutes) * (RAND + 1), 24 hours) where
 // n is the number of consecutive errors.
 base::TimeDelta V4ProtocolManagerUtil::GetNextBackOffInterval(
     size_t* error_count,
     size_t* multiplier) {
   DCHECK(multiplier && error_count);
   (*error_count)++;
   if (*error_count > 1 && *error_count < 9) {
     // With error count 9 and above we will hit the 24 hour max interval.
@@ skipping 15 matching lines @@
 void V4ProtocolManagerUtil::RecordHttpResponseOrErrorCode(
     const char* metric_name,
     const net::URLRequestStatus& status,
     int response_code) {
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       metric_name, status.is_success() ? response_code : status.error());
 }
 
 // static
 // The API hash call uses the pver4 Safe Browsing server.
-GURL V4ProtocolManagerUtil::GetRequestUrl(
-    const std::string& request_base64, const std::string& method_name,
-    const V4ProtocolConfig& config) {
+GURL V4ProtocolManagerUtil::GetRequestUrl(const std::string& request_base64,
+                                          const std::string& method_name,
+                                          const V4ProtocolConfig& config) {
   std::string url =
       ComposeUrl(kSbV4UrlPrefix, method_name, request_base64,
                  config.client_name, config.version, config.key_param);
   return GURL(url);
 }
 
 // static
-std::string V4ProtocolManagerUtil::ComposeUrl(
-    const std::string& prefix,
-    const std::string& method,
-    const std::string& request_base64,
-    const std::string& client_id,
-    const std::string& version,
-    const std::string& key_param) {
+std::string V4ProtocolManagerUtil::ComposeUrl(const std::string& prefix,
+                                              const std::string& method,
+                                              const std::string& request_base64,
+                                              const std::string& client_id,
+                                              const std::string& version,
+                                              const std::string& key_param) {
   DCHECK(!prefix.empty() && !method.empty() && !client_id.empty() &&
          !version.empty());
   std::string url =
       base::StringPrintf("%s/%s/%s?alt=proto&client_id=%s&client_version=%s",
                          prefix.c_str(), method.c_str(), request_base64.c_str(),
                          client_id.c_str(), version.c_str());
   if (!key_param.empty()) {
     base::StringAppendF(&url, "&key=%s",
                         net::EscapeQueryParamValue(key_param, true).c_str());
   }
   return url;
 }
 
 }  // namespace safe_browsing