Makes V4UpdateProtocolManager auto-schedule update fetching

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 18 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:
-  typedef FetchThreatListUpdatesRequest::ListUpdateRequest ListUpdateRequest;
-  typedef FetchThreatListUpdatesResponse::ListUpdateResponse ListUpdateResponse;
-
-  // UpdateCallback is invoked when GetUpdates completes.
-  // Parameters:
-  //   - The vector of update response protobufs received from the server for
-  //     each list type.
-  //  The caller can then use this vector to re-build the current_list_states.
-  typedef base::Callback<void(const std::vector<ListUpdateResponse>&)>
-      UpdateCallback;
-
   ~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 V4UpdateProtocolManager* Create(
+  static scoped_ptr<V4UpdateProtocolManager> Create(
       net::URLRequestContextGetter* request_context_getter,
-      const V4ProtocolConfig& config);
+      const V4ProtocolConfig& config,
+      const base::hash_map<UpdateListIdentifier, std::string>&
+          current_list_states,
+      V4UpdateCallback callback,
+      bool is_headless);
 
   // net::URLFetcherDelegate interface.
   void OnURLFetchComplete(const net::URLFetcher* source) override;
 
-  // Retrieve the hash prefix update, and invoke the callback argument when the
-  // results are retrieved. The callback may be invoked synchronously.
-  // Parameters:
-  //   - The set of lists to fetch the updates for.
-  //   - The last known state for each of the known lists.
-  // It is valid to have one or more lists in lists_to_update set that have no
-  // corresponding value in the current_list_states map. This corresponds to the
-  // initial state for those lists.
-  virtual void GetUpdates(
-      const base::hash_set<UpdateListIdentifier>& lists_to_update,
-      const base::hash_map<UpdateListIdentifier, std::string>&
-          current_list_states,
-      UpdateCallback callback);
-
  protected:
   // Constructs a V4UpdateProtocolManager that issues network requests using
   // |request_context_getter|.
-  V4UpdateProtocolManager(net::URLRequestContextGetter* request_context_getter,
-                          const V4ProtocolConfig& config);
+  // 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.
+  V4UpdateProtocolManager(
+      net::URLRequestContextGetter* request_context_getter,
+      const V4ProtocolConfig& config,
+      const base::hash_map<UpdateListIdentifier, std::string>&
+          current_list_states,
+      V4UpdateCallback callback,
+      bool is_headless);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(V4UpdateProtocolManagerTest,
                            TestGetUpdatesErrorHandlingNetwork);
   FRIEND_TEST_ALL_PREFIXES(V4UpdateProtocolManagerTest,
                            TestGetUpdatesErrorHandlingResponseCode);
   FRIEND_TEST_ALL_PREFIXES(V4UpdateProtocolManagerTest, TestGetUpdatesNoError);
   friend class V4UpdateProtocolManagerFactoryImpl;
 
   // The method to generate the URL for the request to be sent to the server.
   // |request_base64| is the base64 encoded form of an instance of the protobuf
   // FetchThreatListUpdatesRequest.
   GURL GetUpdateUrl(const std::string& request_base64) const;
 
   // Fills a FetchThreatListUpdatesRequest protocol buffer for a request.
   // Returns the serialized and base 64 encoded request as a string.
   std::string GetUpdateRequest(
-      const base::hash_set<UpdateListIdentifier>& lists_to_update,
       const base::hash_map<UpdateListIdentifier, std::string>&
           current_list_states);
 
   // 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);
 
+  // Schedules update callback, if one isn't in progress already.
+  void GetNextUpdate();

[Nathan Parker, 2016/04/01 01:04:52]

ScheduleNextUpdate?

[vakh (use Gerrit instead), 2016/04/01 02:23:02]

Removed it entirely and scheduling IssueUpdateRequest on the timer directly.

+
+  // 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, considering whether we are in backoff.
+  void ScheduleNextUpdate(bool back_off);
+
+  // Schedule the next update, after the given interval.
+  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_;
+
   // 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 before which the next update request may not be sent.
-  // It is set to:
-  // the backoff time, if the last response was an error, or
-  // the minimum wait time, if the last response was successful.
-  base::Time next_update_time_;
+  // 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.
+  // The server can set it by setting the minimum_wait_duration.
+  base::TimeDelta next_update_interval_;

[Nathan Parker, 2016/04/01 01:04:52]

Is this the time after the _next_ update?  

[vakh (use Gerrit instead), 2016/04/01 02:23:02]

The minimum time between the current update request and next.

 
   // The config of the client making Pver4 requests.
   const V4ProtocolConfig config_;
 
   // The context we use to issue network requests.
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
 
   // ID for URLFetchers for testing.
   int url_fetcher_id_;
 
-  // True if there's a request pending.
-  bool update_request_pending_;
-
   // The callback that's called when GetUpdates completes.
-  UpdateCallback callback_;
+  V4UpdateCallback callback_;
 
   // The pending update request. The request must be canceled when the object is
   // destroyed.
   scoped_ptr<net::URLFetcher> request_;
 
+  // Timer to setup the next update request.
+  base::OneShotTimer update_timer_;
+
   DISALLOW_COPY_AND_ASSIGN(V4UpdateProtocolManager);
 };
 
 // Interface of a factory to create V4UpdateProtocolManager.  Useful for tests.
 class V4UpdateProtocolManagerFactory {
  public:
   V4UpdateProtocolManagerFactory() {}
   virtual ~V4UpdateProtocolManagerFactory() {}
-  virtual V4UpdateProtocolManager* CreateProtocolManager(
+  virtual scoped_ptr<V4UpdateProtocolManager> CreateProtocolManager(
       net::URLRequestContextGetter* request_context_getter,
-      const V4ProtocolConfig& config) = 0;
+      const V4ProtocolConfig& config,
+      const base::hash_map<UpdateListIdentifier, std::string>&
+          current_list_states,
+      V4UpdateCallback callback,
+      bool is_headless) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(V4UpdateProtocolManagerFactory);
 };
 
 }  // namespace safe_browsing
 
 #endif  // COMPONENTS_SAFE_BROWSING_DB_V4_UPDATE_PROTOCOL_MANAGER_H_