Reserve space before building potentially large vectors in safe-browsing.

chrome/browser/safe_browsing/safe_browsing_database.cc

 // 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.
 
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/file_util.h"
@@ skipping 251 matching lines @@
 // that the resulting prefix set is valid, so that the
 // PREFIX_SET_EVENT_BLOOM_MISS_PREFIX_HIT_INVALID histogram in
 // ContainsBrowseUrl() can be trustworthy.
 safe_browsing::PrefixSet* PrefixSetFromAddPrefixes(
     const std::vector<SBAddPrefix>& add_prefixes) {
   // TODO(shess): If |add_prefixes| were sorted by the prefix, it
   // could be passed directly to |PrefixSet()|, removing the need for
   // |prefixes|.  For now, |prefixes| is useful while debugging
   // things.
   std::vector<SBPrefix> prefixes;
+  prefixes.reserve(add_prefixes.size());
   for (size_t i = 0; i < add_prefixes.size(); ++i) {
     prefixes.push_back(add_prefixes[i].prefix);
   }
 
   std::sort(prefixes.begin(), prefixes.end());
   prefixes.erase(std::unique(prefixes.begin(), prefixes.end()),
                  prefixes.end());
 
   scoped_ptr<safe_browsing::PrefixSet>
       prefix_set(new safe_browsing::PrefixSet(prefixes));
@@ skipping 896 matching lines @@
   }
 
 #if defined(OS_MACOSX)
   base::mac::SetFileBackupExclusion(download_filename_);
 #endif
 }
 
 void SafeBrowsingDatabaseNew::UpdateBrowseStore() {
   // Copy out the pending add hashes.  Copy rather than swapping in
   // case |ContainsBrowseURL()| is called before the new filter is complete.
   std::vector<SBAddFullHash> pending_add_hashes;

[noelutz, 2011/09/22 21:14:09]

What about this vector?  Were you thinking that this one was always pretty
small?

[Scott Hess - ex-Googler, 2011/09/22 21:23:09]

Yeah, I looked at that one and figured that since it's unlikely to ever have
thousands of entries, it was probably not justified.

Looking at it again, it also seems reasonable to me to assume that
std::vector::insert() has enough information to set the size directly.

   {
     base::AutoLock locked(lookup_lock_);
     pending_add_hashes.insert(pending_add_hashes.end(),
                               pending_browse_hashes_.begin(),
                               pending_browse_hashes_.end());
   }
 
   // Measure the amount of IO during the bloom filter build.
   base::IoCounters io_before, io_after;
   base::ProcessHandle handle = base::Process::Current().handle();
@@ skipping 200 matching lines @@
 void SafeBrowsingDatabaseNew::LoadWhitelist(
     const std::vector<SBAddFullHash>& full_hashes,
     SBWhitelist* whitelist) {
   DCHECK_EQ(creation_loop_, MessageLoop::current());
   if (full_hashes.size() > kMaxWhitelistSize) {
     WhitelistEverything(whitelist);
     return;
   }
 
   std::vector<SBFullHash> new_whitelist;
+  new_whitelist.reserve(full_hashes.size());
   for (std::vector<SBAddFullHash>::const_iterator it = full_hashes.begin();
        it != full_hashes.end(); ++it) {
     new_whitelist.push_back(it->full_hash);
   }
   std::sort(new_whitelist.begin(), new_whitelist.end());
 
   SBFullHash kill_switch;
   crypto::SHA256HashString(kWhitelistKillSwitchUrl, &kill_switch,
                            sizeof(kill_switch));
   if (std::binary_search(new_whitelist.begin(), new_whitelist.end(),
                          kill_switch)) {
     // The kill switch is whitelisted hence we whitelist all URLs.
     WhitelistEverything(whitelist);
   } else {
     base::AutoLock locked(lookup_lock_);
     whitelist->second = false;
     whitelist->first.swap(new_whitelist);
   }
 }