Fetch incremental updates. Store new state in V4Store.

components/safe_browsing_db/v4_update_protocol_manager.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_UPDATE_PROTOCOL_MANAGER_H_
 #define COMPONENTS_SAFE_BROWSING_DB_V4_UPDATE_PROTOCOL_MANAGER_H_
 
 // A class that implements Chrome's interface with the SafeBrowsing V4 update
 // protocol.
 //
@@ skipping 19 matching lines @@
 
 namespace net {
 class URLFetcher;
 class URLRequestContextGetter;
 }  // namespace net
 
 namespace safe_browsing {
 
 class V4UpdateProtocolManagerFactory;
 
-typedef FetchThreatListUpdatesRequest::ListUpdateRequest ListUpdateRequest;
-typedef FetchThreatListUpdatesResponse::ListUpdateResponse ListUpdateResponse;
-
 // V4UpdateCallback is invoked when a scheduled update completes.
 // Parameters:
 //   - The vector of update response protobufs received from the server for
 //     each list type.
 typedef base::Callback<void(const std::vector<ListUpdateResponse>&)>
     V4UpdateCallback;
 
 class V4UpdateProtocolManager : public net::URLFetcherDelegate,
                                 public base::NonThreadSafe {
  public:
   ~V4UpdateProtocolManager() override;
 
   // Makes the passed |factory| the factory used to instantiate
   // a V4UpdateProtocolManager. Useful for tests.
   static void RegisterFactory(V4UpdateProtocolManagerFactory* factory) {
     factory_ = factory;
   }
 
   // Create an instance of the safe browsing v4 protocol manager.
   static std::unique_ptr<V4UpdateProtocolManager> Create(
       net::URLRequestContextGetter* request_context_getter,
       const V4ProtocolConfig& config,
-      const base::hash_map<UpdateListIdentifier, std::string>&
-          current_list_states,
       V4UpdateCallback callback);
 
   // net::URLFetcherDelegate interface.
   void OnURLFetchComplete(const net::URLFetcher* source) override;
 
   // Schedule the next update without backoff.
   void ScheduleNextUpdate();
 
+  // Tell the update manager where to get the latest state of the stores.
+  void SetStoreStateMap(const StoreStateMap* store_state_map);
+
  protected:
   // Constructs a V4UpdateProtocolManager that issues network requests using
-  // |request_context_getter|.
-  // Schedules an update to get the hash prefixes for the lists in
-  // |current_list_states|, and invoke |callback| when the results
-  // are retrieved. The callback may be invoked synchronously.
+  // |request_context_getter|. It schedules updates to get the hash prefixes for
+  // SafeBrowsing lists, and invoke |callback| when the results are retrieved.
+  // The callback may be invoked synchronously.
   V4UpdateProtocolManager(
       net::URLRequestContextGetter* request_context_getter,
       const V4ProtocolConfig& config,
-      const base::hash_map<UpdateListIdentifier, std::string>&
-          current_list_states,
       V4UpdateCallback callback);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(V4UpdateProtocolManagerTest,
                            TestGetUpdatesErrorHandlingNetwork);
   FRIEND_TEST_ALL_PREFIXES(V4UpdateProtocolManagerTest,
                            TestGetUpdatesErrorHandlingResponseCode);
   FRIEND_TEST_ALL_PREFIXES(V4UpdateProtocolManagerTest, TestGetUpdatesNoError);
   FRIEND_TEST_ALL_PREFIXES(V4UpdateProtocolManagerTest,
                            TestGetUpdatesWithOneBackoff);
   friend class V4UpdateProtocolManagerFactoryImpl;
 
   // The method to populate |gurl| with the URL to be sent to the server.
   // |request_base64| is the base64 encoded form of an instance of the protobuf
   // FetchThreatListUpdatesRequest. Also sets the appropriate header values for
   // sending PVer4 requests in |headers|.
   void GetUpdateUrlAndHeaders(const std::string& request_base64,
                               GURL* gurl,
                               net::HttpRequestHeaders* headers) const;
 
   // Fills a FetchThreatListUpdatesRequest protocol buffer for a request.
   // Returns the serialized and base 64 encoded request as a string.
-  std::string GetBase64SerializedUpdateRequestProto(
-      const base::hash_map<UpdateListIdentifier, std::string>&
-          current_list_states);
+  static std::string GetBase64SerializedUpdateRequestProto(
+      const StoreStateMap* store_state_map);
 
   // Parses the base64 encoded response received from the server as a
   // FetchThreatListUpdatesResponse protobuf and returns each of the
   // ListUpdateResponse protobufs contained in it as a vector.
   // Returns true if parsing is successful, false otherwise.
   bool ParseUpdateResponse(
       const std::string& data_base64,
       std::vector<ListUpdateResponse>* list_update_responses);
 
   // Resets the update error counter and multiplier.
@@ skipping 17 matching lines @@
   void ScheduleNextUpdateAfterInterval(base::TimeDelta interval);
 
   // Get the next update interval, considering whether we are in backoff.
   base::TimeDelta GetNextUpdateInterval(bool back_off);
 
   // The factory that controls the creation of V4UpdateProtocolManager.
   // This is used by tests.
   static V4UpdateProtocolManagerFactory* factory_;
 
   // The last known state of the lists.
-  // At init, this is read from the disk or is empty for no prior state.
-  // Each successful update from the server contains a new state for each
-  // requested list.
-  base::hash_map<UpdateListIdentifier, std::string> current_list_states_;
+  // Updated after every successful update of the database.
+  const StoreStateMap* store_state_map_;

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

Having the instance retain a pointer to a map owned by another object seems like
a recipe for use-after-free errors.  Is there any way to have a single reference
to this, which others access via accessor?  Or, better yet, which only one
object needs to look at?

[vakh (use Gerrit instead), 2016/06/21 00:29:36]

Done.

 
   // The number of HTTP response errors since the the last successful HTTP
   // response, used for request backoff timing.
   size_t update_error_count_;
 
   // Multiplier for the backoff error after the second.
   size_t update_back_off_mult_;
 
   // The time delta after which the next update request may be sent.
   // It is set to a random interval between 60 and 300 seconds at start.
@@ skipping 25 matching lines @@
 };
 
 // Interface of a factory to create V4UpdateProtocolManager.  Useful for tests.
 class V4UpdateProtocolManagerFactory {
  public:
   V4UpdateProtocolManagerFactory() {}
   virtual ~V4UpdateProtocolManagerFactory() {}
   virtual std::unique_ptr<V4UpdateProtocolManager> CreateProtocolManager(
       net::URLRequestContextGetter* request_context_getter,
       const V4ProtocolConfig& config,
-      const base::hash_map<UpdateListIdentifier, std::string>&
-          current_list_states,
       V4UpdateCallback callback) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(V4UpdateProtocolManagerFactory);
 };
 
 }  // namespace safe_browsing
 
 #endif  // COMPONENTS_SAFE_BROWSING_DB_V4_UPDATE_PROTOCOL_MANAGER_H_