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 data directory.

[Scott Hess - ex-Googler, 2016/06/17 22:53:43]

This comment replicates a lot of specifics from the declaration.  It's a
typedef, so it defines things, the typedef already says hash_map, and the key
and value are pretty clear.  Maybe something more like "The set of interesting
lists and ASCII filenames for their hash-prefix stores.  The stores are created
inside the user-data directory."

Note that most of the hyphenated words in here don't really need to be
hyphenated.  "hash prefixes" should be fine, "filename" should be fine, "on
disk" should be fine.  Hyphenate when you need to tie the modifiers together,
like "on-disk data" or "user-data directory".

[vakh (use Gerrit instead), 2016/06/20 22:28:43]

Done.

+// For instance, the UpdateListIdentifier could be for URL expressions for UwS
+// on Windows platform, and the corresponding file on disk could be named:
+// "uws_win_url.store"
+// TODO(vakh): Find the canonical place where these are defined and update the
+// comment to point to that place.
+typedef base::hash_map<UpdateListIdentifier, std::string> StoreFileNameMap;
+
+// Used to represent the state of each store.

[Scott Hess - ex-Googler, 2016/06/17 22:53:43]

Similar here, language could be less passive.  "Represents the state of each
store" or "Represents state of stores".

[vakh (use Gerrit instead), 2016/06/20 22:28:43]

Done.

+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_