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 112 matching lines @@
   // current time is |now|.
   void HandleGetHashError(const base::Time& now);
 
   // Helper function for update completion.
   void UpdateFinished(bool success);
 
   // 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 99 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_