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();
+  // Schedule the next update without backoff for the stores in
+  // |store_state_map|.
+  void ScheduleNextUpdate(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.
   void ResetUpdateErrors();
 
   // Updates internal update and backoff state for each update response error,
   // assuming that the current time is |now|.
   void HandleUpdateError(const base::Time& now);
 
   // Generates the URL for the update request and issues the request for the
   // lists passed to the constructor.
   void IssueUpdateRequest();
 
   // Returns whether another update is currently scheduled.
   bool IsUpdateScheduled() const;
 
   // Schedule the next update with backoff specified.
   void ScheduleNextUpdateWithBackoff(bool back_off);
 
   // Schedule the next update, after the given interval.
   void ScheduleNextUpdateAfterInterval(base::TimeDelta interval);
 
+  void set_store_state_map(const StoreStateMap* store_state_map) {
+    store_state_map_ = store_state_map;
+  }
+
   // 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_;

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

Q: Does this need to be stored here, or can it just be passed when an update is
scheduled?  The fewer copies the better. 

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

As discussed offline, the reason it is stored here is that when an update
request to the PVer4 service fails, the update manager needs to know the last
state of the stores.
It could either get a pointer to the V4Database, which is probably an overkill,
or a pointer to the state map.

I've updated the code so that once the v4LocalDbManager sets up the database, it
passes a reference to the db's state map to the V4UpdateManager. This is done
once for an instance of the V4UpdateManager (only one or zero of which exist at
any time).

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