Fetch incremental updates. Store new state in V4Store.

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"
 #include "net/base/escape.h"
 #include "net/http/http_request_headers.h"
 
 using base::Time;
 using base::TimeDelta;
 
 namespace safe_browsing {
 
+std::ostream& operator<<(std::ostream& os, const UpdateListIdentifier& id) {
+  os << "{hash: " << id.hash() << "; platform_type: " << id.platform_type
+     << "; threat_entry_type: " << id.threat_entry_type
+     << "; threat_type: " << id.threat_type << "}";
+  return os;
+}
+
 // The Safe Browsing V4 server URL prefix.
 const char kSbV4UrlPrefix[] = "https://safebrowsing.googleapis.com/v4";
 
 bool UpdateListIdentifier::operator==(const UpdateListIdentifier& other) const {
   return platform_type == other.platform_type &&
          threat_entry_type == other.threat_entry_type &&
          threat_type == other.threat_type;
 }
 
 bool UpdateListIdentifier::operator!=(const UpdateListIdentifier& other) const {
   return !operator==(other);
 }
 
 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);
 }
 
+UpdateListIdentifier::UpdateListIdentifier() {}
+
+UpdateListIdentifier::UpdateListIdentifier(PlatformType platform_type,
+                                           ThreatEntryType threat_entry_type,
+                                           ThreatType threat_type)
+    : platform_type(platform_type),
+      threat_entry_type(threat_entry_type),
+      threat_type(threat_type) {
+  DCHECK(PlatformType_IsValid(platform_type));
+  DCHECK(ThreatEntryType_IsValid(threat_entry_type));
+  DCHECK(ThreatType_IsValid(threat_type));
+}
+
+UpdateListIdentifier::UpdateListIdentifier(const ListUpdateResponse& response)
+    : UpdateListIdentifier(response.platform_type(),
+                           response.threat_entry_type(),
+                           response.threat_type()) {}
+
 V4ProtocolConfig::V4ProtocolConfig() : disable_auto_update(false) {}
 
 V4ProtocolConfig::V4ProtocolConfig(const V4ProtocolConfig& other) = default;
 
 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(
@@ skipping 56 matching lines @@
 
 // static
 void V4ProtocolManagerUtil::UpdateHeaders(net::HttpRequestHeaders* headers) {
   // NOTE(vakh): The following header informs the envelope server (which sits in
   // front of Google's stubby server) that the received GET request should be
   // interpreted as a POST.
   headers->SetHeaderIfMissing("X-HTTP-Method-Override", "POST");
 }
 
 }  // namespace safe_browsing