Small modifications to safebrowsing code to make it simpler to add the extension

chrome/browser/safe_browsing/safe_browsing_database.cc

 // 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.
 
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/bind.h"
@@ skipping 116 matching lines @@
 void GetDownloadUrlPrefixes(const std::vector<GURL>& urls,
                             std::vector<SBPrefix>* prefixes) {
   std::vector<SBFullHash> full_hashes;
   for (size_t i = 0; i < urls.size(); ++i)
     BrowseFullHashesToCheck(urls[i], false, &full_hashes);
 
   for (size_t i = 0; i < full_hashes.size(); ++i)
     prefixes->push_back(full_hashes[i].prefix);
 }
 
+// Helper function to compare addprefixes in |store| with |prefixes|.
+// The |list_bit| indicates which list (url or hash) to compare.
+//
+// Returns true if there is a match, |*prefix_hits| (if non-NULL) will contain
+// the actual matching prefixes.
+bool MatchAddPrefixes(SafeBrowsingStore* store,
+                      int list_bit,
+                      const std::vector<SBPrefix>& prefixes,
+                      std::vector<SBPrefix>* prefix_hits) {
+  if (prefix_hits)
+    prefix_hits->clear();

[Scott Hess - ex-Googler, 2013/01/11 23:44:05]

I don't think having to test prefix_hits and having to track found_match is a
material improvement over having the caller make a fake prefix_hits.

[not at google - send to devlin, 2013/01/14 23:00:55]

Done.

+  bool found_match = false;
+
+  SBAddPrefixes add_prefixes;
+  store->GetAddPrefixes(&add_prefixes);
+  for (SBAddPrefixes::const_iterator iter = add_prefixes.begin();
+       iter != add_prefixes.end(); ++iter) {
+    for (size_t j = 0; j < prefixes.size(); ++j) {
+      const SBPrefix& prefix = prefixes[j];
+      if (prefix == iter->prefix &&
+          GetListIdBit(iter->chunk_id) == list_bit) {
+        if (prefix_hits)
+          prefix_hits->push_back(prefix);
+        found_match = true;
+      }
+    }
+  }
+  return found_match;
+}
+
 // Find the entries in |full_hashes| with prefix in |prefix_hits|, and
 // add them to |full_hits| if not expired.  "Not expired" is when
 // either |last_update| was recent enough, or the item has been
 // received recently enough.  Expired items are not deleted because a
 // future update may make them acceptable again.
 //
 // For efficiency reasons the code walks |prefix_hits| and
 // |full_hashes| in parallel, so they must be sorted by prefix.
 void GetCachedFullHashesForBrowse(const std::vector<SBPrefix>& prefix_hits,
                                   const std::vector<SBAddFullHash>& full_hashes,
@@ skipping 10 matching lines @@
       ++piter;
     } else if (hiter->full_hash.prefix < *piter) {
       ++hiter;
     } else {
       if (expire_time < last_update ||
           expire_time.ToTimeT() < hiter->received) {
         SBFullHashResult result;
         const int list_bit = GetListIdBit(hiter->chunk_id);
         DCHECK(list_bit == safe_browsing_util::MALWARE ||
                list_bit == safe_browsing_util::PHISH);
-        if (!safe_browsing_util::GetListName(list_bit, &result.list_name))
+        const safe_browsing_util::ListType list_id =
+            static_cast<safe_browsing_util::ListType>(list_bit);
+        if (!safe_browsing_util::GetListName(list_id, &result.list_name))
           continue;
         result.add_chunk_id = DecodeChunkId(hiter->chunk_id);
         result.hash = hiter->full_hash;
         full_hits->push_back(result);
       }
 
       // Only increment |hiter|, |piter| might have multiple hits.
       ++hiter;
     }
   }
@@ skipping 370 matching lines @@
   // updates.
   std::sort(prefix_hits->begin(), prefix_hits->end());
 
   GetCachedFullHashesForBrowse(*prefix_hits, full_browse_hashes_,
                                full_hits, last_update);
   GetCachedFullHashesForBrowse(*prefix_hits, pending_browse_hashes_,
                                full_hits, last_update);
   return true;
 }
 
-bool SafeBrowsingDatabaseNew::MatchDownloadAddPrefixes(
-    int list_bit,
-    const std::vector<SBPrefix>& prefixes,
-    std::vector<SBPrefix>* prefix_hits) {
-  prefix_hits->clear();
-
-  SBAddPrefixes add_prefixes;
-  download_store_->GetAddPrefixes(&add_prefixes);
-  for (SBAddPrefixes::const_iterator iter = add_prefixes.begin();
-       iter != add_prefixes.end(); ++iter) {
-    for (size_t j = 0; j < prefixes.size(); ++j) {
-      const SBPrefix& prefix = prefixes[j];
-      if (prefix == iter->prefix &&
-          GetListIdBit(iter->chunk_id) == list_bit) {
-        prefix_hits->push_back(prefix);
-      }
-    }
-  }
-  return !prefix_hits->empty();
-}
-
 bool SafeBrowsingDatabaseNew::ContainsDownloadUrl(
     const std::vector<GURL>& urls,
     std::vector<SBPrefix>* prefix_hits) {
   DCHECK_EQ(creation_loop_, MessageLoop::current());
 
   // Ignore this check when download checking is not enabled.
   if (!download_store_.get())
     return false;
 
   std::vector<SBPrefix> prefixes;
   GetDownloadUrlPrefixes(urls, &prefixes);
-  return MatchDownloadAddPrefixes(safe_browsing_util::BINURL % 2,
-                                  prefixes,
-                                  prefix_hits);
+  return MatchAddPrefixes(download_store_.get(),
+                          safe_browsing_util::BINURL % 2,
+                          prefixes,
+                          prefix_hits);
 }
 
 bool SafeBrowsingDatabaseNew::ContainsDownloadHashPrefix(
     const SBPrefix& prefix) {
   DCHECK_EQ(creation_loop_, MessageLoop::current());
 
   // Ignore this check when download store is not available.
   if (!download_store_.get())
     return false;
 
-  std::vector<SBPrefix> prefixes(1, prefix);
-  std::vector<SBPrefix> prefix_hits;
-  return MatchDownloadAddPrefixes(safe_browsing_util::BINHASH % 2,
-                                  prefixes,
-                                  &prefix_hits);
+  return MatchAddPrefixes(download_store_.get(),
+                          safe_browsing_util::BINHASH % 2,
+                          std::vector<SBPrefix>(1, prefix),
+                          NULL);
 }
 
 bool SafeBrowsingDatabaseNew::ContainsCsdWhitelistedUrl(const GURL& url) {
   // This method is theoretically thread-safe but we expect all calls to
   // originate from the IO thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   std::vector<SBFullHash> full_hashes;
   BrowseFullHashesToCheck(url, true, &full_hashes);
   return ContainsWhitelistedHashes(csd_whitelist_, full_hashes);
 }
@@ skipping 63 matching lines @@
       store->WriteAddPrefix(encoded_chunk_id, prefix);
 
       STATS_COUNTER("SB.PrefixAddFull", 1);
       store->WriteAddHash(encoded_chunk_id, receive_time, full_hash);
     }
   }
 }
 
 // Helper to iterate over all the entries in the hosts in |chunks| and
 // add them to the store.
-void SafeBrowsingDatabaseNew::InsertAddChunks(const int list_id,
-                                              const SBChunkList& chunks) {
+void SafeBrowsingDatabaseNew::InsertAddChunks(
+    const safe_browsing_util::ListType list_id,
+    const SBChunkList& chunks) {
   DCHECK_EQ(creation_loop_, MessageLoop::current());
 
   SafeBrowsingStore* store = GetStore(list_id);
   if (!store) return;
 
   for (SBChunkList::const_iterator citer = chunks.begin();
        citer != chunks.end(); ++citer) {
     const int chunk_id = citer->chunk_number;
 
     // The server can give us a chunk that we already have because
@@ skipping 52 matching lines @@
       store->WriteSubPrefix(encoded_chunk_id, add_chunk_id, full_hash.prefix);
 
       STATS_COUNTER("SB.PrefixSubFull", 1);
       store->WriteSubHash(encoded_chunk_id, add_chunk_id, full_hash);
     }
   }
 }
 
 // Helper to iterate over all the entries in the hosts in |chunks| and
 // add them to the store.
-void SafeBrowsingDatabaseNew::InsertSubChunks(int list_id,
-                                              const SBChunkList& chunks) {
+void SafeBrowsingDatabaseNew::InsertSubChunks(
+    safe_browsing_util::ListType list_id,
+    const SBChunkList& chunks) {
   DCHECK_EQ(creation_loop_, MessageLoop::current());
 
   SafeBrowsingStore* store = GetStore(list_id);
   if (!store) return;
 
   for (SBChunkList::const_iterator citer = chunks.begin();
        citer != chunks.end(); ++citer) {
     const int chunk_id = citer->chunk_number;
 
     // The server can give us a chunk that we already have because
@@ skipping 12 matching lines @@
 
 void SafeBrowsingDatabaseNew::InsertChunks(const std::string& list_name,
                                            const SBChunkList& chunks) {
   DCHECK_EQ(creation_loop_, MessageLoop::current());
 
   if (corruption_detected_ || chunks.empty())
     return;
 
   const base::TimeTicks before = base::TimeTicks::Now();
 
-  const int list_id = safe_browsing_util::GetListId(list_name);
+  const safe_browsing_util::ListType list_id =
+      safe_browsing_util::GetListId(list_name);
   DVLOG(2) << list_name << ": " << list_id;
 
   SafeBrowsingStore* store = GetStore(list_id);
   if (!store) return;
 
-  change_detected_ = true;
+  changes_detected_.insert(list_id);
 
   store->BeginChunk();
   if (chunks.front().is_add) {
     InsertAddChunks(list_id, chunks);
   } else {
     InsertSubChunks(list_id, chunks);
   }
   store->FinishChunk();
 
   UMA_HISTOGRAM_TIMES("SB2.ChunkInsert", base::TimeTicks::Now() - before);
 }
 
 void SafeBrowsingDatabaseNew::DeleteChunks(
     const std::vector<SBChunkDelete>& chunk_deletes) {
   DCHECK_EQ(creation_loop_, MessageLoop::current());
 
   if (corruption_detected_ || chunk_deletes.empty())
     return;
 
   const std::string& list_name = chunk_deletes.front().list_name;
-  const int list_id = safe_browsing_util::GetListId(list_name);
+  const safe_browsing_util::ListType list_id =
+      safe_browsing_util::GetListId(list_name);
 
   SafeBrowsingStore* store = GetStore(list_id);
   if (!store) return;
 
-  change_detected_ = true;
+  changes_detected_.insert(list_id);
 
   for (size_t i = 0; i < chunk_deletes.size(); ++i) {
     std::vector<int> chunk_numbers;
     RangesToChunks(chunk_deletes[i].chunk_del, &chunk_numbers);
     for (size_t j = 0; j < chunk_numbers.size(); ++j) {
       const int encoded_chunk_id = EncodeChunkId(chunk_numbers[j], list_id);
       if (chunk_deletes[i].is_sub_del)
         store->DeleteSubChunk(encoded_chunk_id);
       else
         store->DeleteAddChunk(encoded_chunk_id);
@@ skipping 109 matching lines @@
 
   if (download_whitelist_store_.get()) {
     std::vector<std::string> download_whitelist_listnames;
     download_whitelist_listnames.push_back(
         safe_browsing_util::kDownloadWhiteList);
     UpdateChunkRanges(download_whitelist_store_.get(),
                       download_whitelist_listnames, lists);
   }
 
   corruption_detected_ = false;
-  change_detected_ = false;
+  changes_detected_.clear();
   return true;
 }
 
 void SafeBrowsingDatabaseNew::UpdateFinished(bool update_succeeded) {
   DCHECK_EQ(creation_loop_, MessageLoop::current());
 
   // The update may have failed due to corrupt storage (for instance,
   // an excessive number of invalid add_chunks and sub_chunks).
   // Double-check that the databases are valid.
   // TODO(shess): Providing a checksum for the add_chunk and sub_chunk
@@ skipping 14 matching lines @@
       DLOG(ERROR) << "Safe-browsing download whitelist database corrupt.";
     }
   }
 
   if (corruption_detected_)
     return;
 
   // Unroll the transaction if there was a protocol error or if the
   // transaction was empty.  This will leave the prefix set, the
   // pending hashes, and the prefix miss cache in place.
-  if (!update_succeeded || !change_detected_) {
+  if (!update_succeeded || changes_detected_.empty()) {
     // Track empty updates to answer questions at http://crbug.com/72216 .
-    if (update_succeeded && !change_detected_)
+    if (update_succeeded && changes_detected_.empty())
       UMA_HISTOGRAM_COUNTS("SB2.DatabaseUpdateKilobytes", 0);
     browse_store_->CancelUpdate();
     if (download_store_.get())
       download_store_->CancelUpdate();
     if (csd_whitelist_store_.get())
       csd_whitelist_store_->CancelUpdate();
     if (download_whitelist_store_.get())
       download_whitelist_store_->CancelUpdate();
     return;
   }
 
-  // for download
   UpdateDownloadStore();
-  // for browsing
   UpdateBrowseStore();
-  // for csd and download whitelists.
   UpdateWhitelistStore(csd_whitelist_filename_,
                        csd_whitelist_store_.get(),
                        &csd_whitelist_);
   UpdateWhitelistStore(download_whitelist_filename_,
                        download_whitelist_store_.get(),
                        &download_whitelist_);
 }
 
 void SafeBrowsingDatabaseNew::UpdateWhitelistStore(
     const FilePath& store_filename,
@@ skipping 232 matching lines @@
     RecordFailure(FAILURE_DATABASE_STORE_DELETE);
 
   FilePath bloom_filter_filename = BloomFilterForFilename(browse_filename_);
   const bool r5 = file_util::Delete(bloom_filter_filename, false);
   if (!r5)
     RecordFailure(FAILURE_DATABASE_FILTER_DELETE);
 
   const bool r6 = file_util::Delete(prefix_set_filename_, false);
   if (!r6)
     RecordFailure(FAILURE_DATABASE_PREFIX_SET_DELETE);
+
   return r1 && r2 && r3 && r4 && r5 && r6;
 }
 
 void SafeBrowsingDatabaseNew::WritePrefixSet() {
   DCHECK_EQ(creation_loop_, MessageLoop::current());
 
   if (!prefix_set_.get())
     return;
 
   const base::TimeTicks before = base::TimeTicks::Now();
@@ skipping 39 matching lines @@
   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);
   }
 }