Add tests for redirect responses from 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.
+// See https://developers.google.com/safe-browsing/developers_guide_v2 for
+// protocol details.
+//
 // The SafeBrowsingProtocolManager handles formatting and making requests of,
 // and handling responses from, Google's SafeBrowsing servers. This class uses
 // The SafeBrowsingProtocolParser class to do the actual parsing.
 
 #include <deque>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
@@ skipping 76 matching lines @@
   // 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);
 
-  // Called after the chunks that were parsed were inserted in the database.
-  void OnChunkInserted();
-
   // The last time we received an update.
   base::Time last_update() const { return last_update_; }
 
   // Setter for additional_query_. To make sure the additional_query_ won't
   // be changed in the middle of an update, caller (e.g.: SafeBrowsingService)
   // should call this after callbacks triggered in UpdateFinished() or before
   // IssueUpdateRequest().
   void set_additional_query(const std::string& query) {
     additional_query_ = query;
   }
@@ skipping 27 matching lines @@
     // Memory space for histograms is determined by the max.  ALWAYS
     // ADD NEW VALUES BEFORE THIS ONE.
     GET_HASH_RESULT_MAX
   };
 
   // Record a GetHash result. |is_download| indicates if the get
   // hash is triggered by download related lookup.
   static void RecordGetHashResult(bool is_download,
                                   ResultType result_type);
 
+  // Returns whether another update is currently scheduled.
+  bool IsUpdateScheduled() const;
+
  protected:
   // Constructs a SafeBrowsingProtocolManager for |delegate| that issues
   // network requests using |request_context_getter|.
   SafeBrowsingProtocolManager(
       SafeBrowsingProtocolManagerDelegate* delegate,
       net::URLRequestContextGetter* request_context_getter,
       const SafeBrowsingProtocolConfig& config);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest, TestBackOffTimes);
@@ skipping 60 matching lines @@
   // SafeBrowsingService with the new content. Returns 'true' on successful
   // parse, 'false' on error.
   bool HandleServiceResponse(const GURL& url, const char* data, int length);
 
   // Updates internal state for each GetHash response error, assuming that the
   // current time is |now|.
   void HandleGetHashError(const base::Time& now);
 
   // Helper function for update completion.
   void UpdateFinished(bool success);
+  void UpdateFinished(bool success, bool back_off);
 
   // A callback that runs if we timeout waiting for a response to an update
   // request. We use this to properly set our update state.
   void UpdateResponseTimeout();
 
+  // Called after the chunks are added to the database.
+  void OnAddChunksComplete();
+
  private:
   // Map of GetHash requests to parameters which created it.
   struct FullHashDetails {
     FullHashDetails();
     FullHashDetails(FullHashCallback callback, bool is_download);
     ~FullHashDetails();
 
     FullHashCallback callback;
     bool is_download;
   };
@@ skipping 26 matching lines @@
   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.
   base::TimeDelta next_update_interval_;
   base::OneShotTimer<SafeBrowsingProtocolManager> update_timer_;
 
+  // update_timeout_timer_ is used to prevent update requests from taking too

[mattm, 2012/12/05 23:58:10]

Comment doesn't match variable name.

+  // long.
+  base::OneShotTimer<SafeBrowsingProtocolManager> timeout_timer_;
+
   // All chunk requests that need to be made.
   std::deque<ChunkUrl> chunk_request_urls_;
 
   HashRequests hash_requests_;
 
   // The next scheduled update has special behavior for the first 2 requests.
   enum UpdateRequestState {
     FIRST_REQUEST = 0,
     SECOND_REQUEST,
     NORMAL_REQUEST
@@ skipping 53 matching lines @@
       const SafeBrowsingProtocolConfig& config) = 0;
  private:
   DISALLOW_COPY_AND_ASSIGN(SBProtocolManagerFactory);
 };
 
 // Delegate interface for the SafeBrowsingProtocolManager.
 class SafeBrowsingProtocolManagerDelegate {
  public:
   typedef base::Callback<void(const std::vector<SBListChunkRanges>&, bool)>
       GetChunksCallback;
+  typedef base::Callback<void(void)> AddChunksCallback;
 
   virtual ~SafeBrowsingProtocolManagerDelegate();
 
   // |UpdateStarted()| is called just before the SafeBrowsing update protocol
   // has begun.
   virtual void UpdateStarted() = 0;
 
   // |UpdateFinished()| is called just after the SafeBrowsing update protocol
   // has completed.
   virtual void UpdateFinished(bool success) = 0;
 
   // Wipe out the local database. The SafeBrowsing server can request this.
   virtual void ResetDatabase() = 0;
 
   // Retrieve all the local database chunks, and invoke |callback| with the
   // results. The SafeBrowsingProtocolManagerDelegate must only invoke the
   // callback if the SafeBrowsingProtocolManager is still alive. Only one call
   // may be made to GetChunks at a time.
   virtual void GetChunks(GetChunksCallback callback) = 0;
 
-  // Add new chunks to the database.
-  virtual void AddChunks(const std::string& list, SBChunkList* chunks) = 0;
+  // Add new chunks to the database. Invokes |callback| when complete, but must
+  // call at a later time.
+  virtual void AddChunks(const std::string& list, SBChunkList* chunks,
+                         AddChunksCallback callback) = 0;
 
   // Delete chunks from the database.
   virtual void DeleteChunks(
       std::vector<SBChunkDelete>* delete_chunks) = 0;
 };
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_PROTOCOL_MANAGER_H_