Use base::TimeDelta in SafeBrowsingProtocolManager.

chrome/browser/safe_browsing/protocol_manager.h

 // Copyright (c) 2012 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 CHROME_BROWSER_SAFE_BROWSING_PROTOCOL_MANAGER_H_
 #define CHROME_BROWSER_SAFE_BROWSING_PROTOCOL_MANAGER_H_
 
 // A class that implements Chrome's interface with the SafeBrowsing protocol.
 // The SafeBrowsingProtocolManager handles formatting and making requests of,
 // and handling responses from, Google's SafeBrowsing servers. This class uses
@@ skipping 71 matching lines @@
   virtual void Initialize();
 
   // net::URLFetcherDelegate interface.
   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 
   // API used by the SafeBrowsingService for issuing queries. When the results
   // are available, SafeBrowsingService::HandleGetHashResults is called.
   virtual void GetFullHash(SafeBrowsingService::SafeBrowsingCheck* check,
                            const std::vector<SBPrefix>& prefixes);
 
-  // Forces the start of next update after |next_update_msec| in msec.
-  void ForceScheduleNextUpdate(int next_update_msec);
+  // Forces the start of next update after |interval| time.
+  void ForceScheduleNextUpdate(base::TimeDelta interval);
 
   // Scheduled update callback.
   void GetNextUpdate();
 
   // Called by the SafeBrowsingService when our request for a list of all chunks
   // for each list is done.  If database_error is true, that means the protocol
   // manager shouldn't fetch updates since they can't be written to disk.  It
   // should try again later to open the database.
   void OnGetChunksComplete(const std::vector<SBListChunkRanges>& list,
                            bool database_error);
@@ skipping 115 matching lines @@
   GURL SafeBrowsingHitUrl(
       const GURL& malicious_url, const GURL& page_url, const GURL& referrer_url,
       bool is_subresource,
       SafeBrowsingService::UrlCheckResult threat_type) const;
   // Generates URL for reporting malware details for users who opt-in.
   GURL MalwareDetailsUrl() const;
 
   // Composes a ChunkUrl based on input string.
   GURL NextChunkUrl(const std::string& input) const;
 
-  // Returns the time (in milliseconds) for the next update request. If
-  // 'back_off' is true, the time returned will increment an error count and
-  // return the appriate next time (see ScheduleNextUpdate below).
-  int GetNextUpdateTime(bool back_off);
+  // Returns the time for the next update request. If |back_off| is true,
+  // the time returned will increment an error count and return the appriate
+  // next time (see ScheduleNextUpdate below).
+  base::TimeDelta GetNextUpdateInterval(bool back_off);
 
   // Worker function for calculating GetHash and Update backoff times (in
-  // seconds). 'Multiplier' is doubled for each consecutive error between the
-  // 2nd and 5th, and 'error_count' is incremented with each call.
-  int GetNextBackOffTime(int* error_count, int* multiplier);
+  // seconds). |multiplier| is doubled for each consecutive error between the
+  // 2nd and 5th, and |error_count| is incremented with each call.
+  base::TimeDelta GetNextBackOffInterval(int* error_count,
+                                         int* multiplier) const;
 
   // Manages our update with the next allowable update time. If 'back_off_' is
   // true, we must decrease the frequency of requests of the SafeBrowsing
   // service according to section 5 of the protocol specification.
   // When disable_auto_update_ is set, ScheduleNextUpdate will do nothing.
   // ForceScheduleNextUpdate has to be called to trigger the update.
   void ScheduleNextUpdate(bool back_off);
 
   // Sends a request for a list of chunks we should download to the SafeBrowsing
   // servers. In order to format this request, we need to send all the chunk
@@ skipping 50 matching lines @@
   int gethash_back_off_mult_;
 
   // Multiplier between 0 and 1 to spread clients over an interval.
   float back_off_fuzz_;
 
   // The list for which we are make a request.
   std::string list_name_;
 
   // For managing the next earliest time to query the SafeBrowsing servers for
   // updates.
-  int next_update_sec_;
+  base::TimeDelta next_update_interval_;
   base::OneShotTimer<SafeBrowsingProtocolManager> update_timer_;
 
   // All chunk requests that need to be made.
   std::deque<ChunkUrl> chunk_request_urls_;
 
   // Map of GetHash requests.
   typedef base::hash_map<const net::URLFetcher*,
                          SafeBrowsingService::SafeBrowsingCheck*> HashRequests;
   HashRequests hash_requests_;
 
@@ skipping 44 matching lines @@
   std::string url_prefix_;
 
   // When true, protocol manager will not start an update unless
   // ForceScheduleNextUpdate() is called. This is set for testing purpose.
   bool disable_auto_update_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingProtocolManager);
 };
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_PROTOCOL_MANAGER_H_