Safe-browsing SBAddPrefix from vector to deque.

chrome/browser/safe_browsing/safe_browsing_store.h

 // Copyright (c) 2011 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_SAFE_BROWSING_STORE_H_
 #define CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_STORE_H_
 #pragma once
 
 #include <set>
 #include <vector>
@@ skipping 33 matching lines @@
   int32 chunk_id;
   SBPrefix prefix;
 
   SBAddPrefix(int32 id, SBPrefix p) : chunk_id(id), prefix(p) {}
   SBAddPrefix() : chunk_id(), prefix() {}
 
   int32 GetAddChunkId() const { return chunk_id; }
   SBPrefix GetAddPrefix() const { return prefix; }
 };
 
+typedef std::deque<SBAddPrefix> SBAddPrefixContainer;
+
 struct SBSubPrefix {
   int32 chunk_id;
   int32 add_chunk_id;
   SBPrefix add_prefix;
 
   SBSubPrefix(int32 id, int32 add_id, int prefix)
       : chunk_id(id), add_chunk_id(add_id), add_prefix(prefix) {}
   SBSubPrefix() : chunk_id(), add_chunk_id(), add_prefix() {}
 
   int32 GetAddChunkId() const { return add_chunk_id; }
@@ skipping 67 matching lines @@
 // TODO(shess): Since the prefixes are uniformly-distributed hashes,
 // there aren't many ways to organize the inputs for efficient
 // processing.  For this reason, the vectors are sorted and processed
 // in parallel.  At this time this code does the sorting internally,
 // but it might make sense to make sorting an API requirement so that
 // the storage can optimize for it.
 //
 // TODO(shess): The original code did not process |sub_full_hashes|
 // for matches in |add_full_hashes|, so this code doesn't, either.  I
 // think this is probably a bug.
-void SBProcessSubs(std::vector<SBAddPrefix>* add_prefixes,
+void SBProcessSubs(SBAddPrefixContainer* add_prefixes,
                    std::vector<SBSubPrefix>* sub_prefixes,
                    std::vector<SBAddFullHash>* add_full_hashes,
                    std::vector<SBSubFullHash>* sub_full_hashes,
                    const base::hash_set<int32>& add_chunks_deleted,
                    const base::hash_set<int32>& sub_chunks_deleted);
 
 // Records a histogram of the number of items in |prefix_misses| which
 // are not in |add_prefixes|.
-void SBCheckPrefixMisses(const std::vector<SBAddPrefix>& add_prefixes,
+void SBCheckPrefixMisses(const SBAddPrefixContainer& add_prefixes,
                          const std::set<SBPrefix>& prefix_misses);
 
 // TODO(shess): This uses int32 rather than int because it's writing
 // specifically-sized items to files.  SBPrefix should likewise be
 // explicitly sized.
 
 // Abstract interface for storing data.
 class SafeBrowsingStore {
  public:
   SafeBrowsingStore() {}
   virtual ~SafeBrowsingStore() {}
 
   // Sets up the information for later use, but does not necessarily
   // check whether the underlying file exists, or is valid.  If
   // |curruption_callback| is non-NULL it will be called if corruption
   // is detected, which could happen as part of any call other than
   // Delete().  The appropriate action is to use Delete() to clear the
   // store.
   virtual void Init(const FilePath& filename,
                     const base::Closure& corruption_callback) = 0;
 
   // Deletes the files which back the store, returning true if
   // successful.
   virtual bool Delete() = 0;
 
   // Get all Add prefixes out from the store.
-  virtual bool GetAddPrefixes(std::vector<SBAddPrefix>* add_prefixes) = 0;
+  virtual bool GetAddPrefixes(SBAddPrefixContainer* add_prefixes) = 0;
 
   // Get all add full-length hashes.
   virtual bool GetAddFullHashes(
       std::vector<SBAddFullHash>* add_full_hashes) = 0;
 
   // Start an update.  None of the following methods should be called
   // unless this returns true.  If this returns true, the update
   // should be terminated by FinishUpdate() or CancelUpdate().
   virtual bool BeginUpdate() = 0;
 
@@ skipping 35 matching lines @@
   // stored in |add_prefixes_result| and |add_full_hashes_result|.
   // |pending_adds| is the set of full hashes which have been received
   // since the previous update, and is provided as a convenience
   // (could be written via WriteAddHash(), but that would flush the
   // chunk to disk).  |prefix_misses| is the set of prefixes where the
   // |GetHash()| request returned no full hashes, used for diagnostic
   // purposes.
   virtual bool FinishUpdate(
       const std::vector<SBAddFullHash>& pending_adds,
       const std::set<SBPrefix>& prefix_misses,
-      std::vector<SBAddPrefix>* add_prefixes_result,
+      SBAddPrefixContainer* add_prefixes_result,
       std::vector<SBAddFullHash>* add_full_hashes_result) = 0;
 
   // Cancel the update in process and remove any temporary disk
   // storage, leaving the original data unmodified.
   virtual bool CancelUpdate() = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingStore);
 };
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_STORE_H_