Fetch incremental updates. Store new state in V4Store.

components/safe_browsing_db/v4_protocol_manager_util.h

 // 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.
 
 #ifndef COMPONENTS_SAFE_BROWSING_DB_V4_PROTOCOL_MANAGER_UTIL_H_
 #define COMPONENTS_SAFE_BROWSING_DB_V4_PROTOCOL_MANAGER_UTIL_H_
 
 // A class that implements the stateless methods used by the GetHashUpdate and
 // GetFullHash stubby calls made by Chrome using the SafeBrowsing V4 protocol.
 
+#include <ostream>
 #include <string>
 
 #include "base/gtest_prod_util.h"
 #include "base/hash.h"
 #include "components/safe_browsing_db/safebrowsing.pb.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 namespace net {
 class HttpRequestHeaders;
 }  // namespace net
 
 namespace safe_browsing {
+
+typedef FetchThreatListUpdatesRequest::ListUpdateRequest ListUpdateRequest;
+typedef FetchThreatListUpdatesResponse::ListUpdateResponse ListUpdateResponse;
+
 // Config passed to the constructor of a V4 protocol manager.
 struct V4ProtocolConfig {
   // The safe browsing client name sent in each request.
   std::string client_name;
 
   // Current product version sent in each request.
   std::string version;
 
   // The Google API key.
   std::string key_param;
@@ skipping 10 matching lines @@
 // interested in maintaining and downloading from the SafeBrowsing servers.
 // For example, for digests of Malware binaries on Windows:
 // platform_type = WINDOWS,
 // threat_entry_type = EXECUTABLE,
 // threat_type = MALWARE
 struct UpdateListIdentifier {
   PlatformType platform_type;
   ThreatEntryType threat_entry_type;
   ThreatType threat_type;
 
+  UpdateListIdentifier();
+  UpdateListIdentifier(PlatformType, ThreatEntryType, ThreatType);
+  UpdateListIdentifier(const ListUpdateResponse&);
+
   bool operator==(const UpdateListIdentifier& other) const;
   bool operator!=(const UpdateListIdentifier& other) const;
   size_t hash() const;
 };
 
+std::ostream& operator<<(std::ostream& os, const UpdateListIdentifier& id);
+
+// This defines a hash_map that is used to create the backing files for the
+// stores that contain the hash-prefixes. The map key identifies the list that
+// we're interested in and the value represents the ASCII file-name that'll be
+// created on-disk to store the hash-prefixes for that list. This file is
+// created inside the user's profile directory.

[Nathan Parker, 2016/06/15 21:24:19]

s/profile/data

The'll be one set of files shared across profiles.

[vakh (use Gerrit instead), 2016/06/16 01:07:35]

Done.

+// For instance, the UpdateListIdentifier could be for URL expressions for UwS

[Nathan Parker, 2016/06/15 21:24:19]

How about just referencing the place that defines them?  That could list the
naming semantics.

[vakh (use Gerrit instead), 2016/06/16 01:07:35]

There's no such place right now. The only place where we define these has a TODO
for finding a better way to do this. Once there's a definitive place, I'll point
this comment to that place. Added a TODO for that.

+// on Windows platform, and the corresponding file on disk could be named:
+// "uws_win_url.store"
+typedef base::hash_map<UpdateListIdentifier, std::string> StoreFileNameMap;
+
+// Used to represent the state of each store.
+typedef base::hash_map<UpdateListIdentifier, std::string> StoreStateMap;
+
 // Enumerate failures for histogramming purposes.  DO NOT CHANGE THE
 // ORDERING OF THESE VALUES.
 enum V4OperationResult {
   // 200 response code means that the server recognized the request.
   STATUS_200 = 0,
 
   // Subset of successful responses where the response body wasn't parsable.
   PARSE_ERROR = 1,
 
   // Operation request failed (network error).
@@ skipping 29 matching lines @@
                                             int response_code);
 
   // Generates a Pver4 request URL and sets the appropriate header values.
   // |request_base64| is the serialized request protocol buffer encoded in
   // base 64.
   // |method_name| is the name of the method to call, as specified in the proto,
   // |config| is an instance of V4ProtocolConfig that stores the client config,
   // |gurl| is set to the value of the PVer4 request URL,
   // |headers| is populated with the appropriate header values.
   static void GetRequestUrlAndHeaders(const std::string& request_base64,
-                                            const std::string& method_name,
-                                            const V4ProtocolConfig& config,
-                                            GURL* gurl,
-                                            net::HttpRequestHeaders* headers);
+                                      const std::string& method_name,
+                                      const V4ProtocolConfig& config,
+                                      GURL* gurl,
+                                      net::HttpRequestHeaders* headers);
 
   // Worker function for calculating the backoff times.
   // |multiplier| is doubled for each consecutive error after the
   // first, and |error_count| is incremented with each call.
   static base::TimeDelta GetNextBackOffInterval(size_t* error_count,
                                                 size_t* multiplier);
 
  private:
   V4ProtocolManagerUtil(){};
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingV4ProtocolManagerUtilTest,
@@ skipping 20 matching lines @@
 namespace std {
 template <>
 struct hash<safe_browsing::UpdateListIdentifier> {
   std::size_t operator()(const safe_browsing::UpdateListIdentifier& s) const {
     return s.hash();
   }
 };
 }
 
 #endif  // COMPONENTS_SAFE_BROWSING_DB_V4_PROTOCOL_MANAGER_UTIL_H_