Ignore GetHash results for lists that we don't support.

chrome/browser/safe_browsing/safe_browsing_database_bloom.cc

 // Copyright (c) 2006-2008 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_bloom.h"
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 343 matching lines @@
   return true;
 }
 
 void SafeBrowsingDatabaseBloom::InsertChunks(const std::string& list_name,
                                              std::deque<SBChunk>* chunks) {
   if (chunks->empty())
     return;
 
   base::Time insert_start = base::Time::Now();
 
-  int list_id = GetListId(list_name);
+  int list_id = safe_browsing_util::GetListId(list_name);
   ChunkType chunk_type = chunks->front().is_add ? ADD_CHUNK : SUB_CHUNK;
 
   while (!chunks->empty()) {
     SBChunk& chunk = chunks->front();
     chunk.list_id = list_id;
     int chunk_id = chunk.chunk_number;
 
     // The server can give us a chunk that we already have because it's part of
     // a range.  Don't add it again.
     if (!ChunkExists(list_id, chunk_type, chunk_id)) {
@@ skipping 255 matching lines @@
     HandleCorruptDatabase();
 
   return add_count;
 }
 
 void SafeBrowsingDatabaseBloom::DeleteChunks(
     std::vector<SBChunkDelete>* chunk_deletes) {
   if (chunk_deletes->empty())
     return;
 
-  int list_id = GetListId(chunk_deletes->front().list_name);
+  int list_id = safe_browsing_util::GetListId(chunk_deletes->front().list_name);
 
   for (size_t i = 0; i < chunk_deletes->size(); ++i) {
     const SBChunkDelete& chunk = (*chunk_deletes)[i];
     std::vector<int> chunk_numbers;
     RangesToChunks(chunk.chunk_del, &chunk_numbers);
     for (size_t del = 0; del < chunk_numbers.size(); ++del) {
       int encoded_chunk = EncodeChunkId(chunk_numbers[del], list_id);
       if (chunk.is_sub_del)
         sub_del_cache_.insert(encoded_chunk);
       else
@@ skipping 45 matching lines @@
 }
 
 void SafeBrowsingDatabaseBloom::GetListsInfo(
     std::vector<SBListChunkRanges>* lists) {
   DCHECK(lists);
   lists->clear();
 
   ReadChunkNumbers();
 
   lists->push_back(SBListChunkRanges(safe_browsing_util::kMalwareList));
-  GetChunkIds(MALWARE, ADD_CHUNK, &lists->back().adds);
-  GetChunkIds(MALWARE, SUB_CHUNK, &lists->back().subs);
+  GetChunkIds(safe_browsing_util::MALWARE, ADD_CHUNK, &lists->back().adds);
+  GetChunkIds(safe_browsing_util::MALWARE, SUB_CHUNK, &lists->back().subs);
 
   lists->push_back(SBListChunkRanges(safe_browsing_util::kPhishingList));
-  GetChunkIds(PHISH, ADD_CHUNK, &lists->back().adds);
-  GetChunkIds(PHISH, SUB_CHUNK, &lists->back().subs);
+  GetChunkIds(safe_browsing_util::PHISH, ADD_CHUNK, &lists->back().adds);
+  GetChunkIds(safe_browsing_util::PHISH, SUB_CHUNK, &lists->back().subs);
 
   return;
 }
 
-/* static */
-int SafeBrowsingDatabaseBloom::GetListId(const std::string& name) {
-  if (name == safe_browsing_util::kMalwareList)
-    return MALWARE;
-  else if (name == safe_browsing_util::kPhishingList)
-    return PHISH;
-
-  NOTREACHED();
-  return -1;
-}
-
-/* static */
-std::string SafeBrowsingDatabaseBloom::GetListName(int list_id) {
-  switch (list_id) {
-    case MALWARE:
-      return safe_browsing_util::kMalwareList;
-    case PHISH:
-      return safe_browsing_util::kPhishingList;
-    default:
-      NOTREACHED();
-      return "";
-  }
-}
-
 void SafeBrowsingDatabaseBloom::ReadChunkNumbers() {
   add_chunk_cache_.clear();
   sub_chunk_cache_.clear();
 
   // Read in the add chunk numbers.
   SQLITE_UNIQUE_STATEMENT(read_adds, *statement_cache_,
                           "SELECT chunk FROM add_chunks");
   if (!read_adds.is_valid()) {
     NOTREACHED();
     return;
@@ skipping 656 matching lines @@
         // or if this particular GetHash was received in the past 45 minutes.
         // If an entry is does not meet the time criteria above, we are not
         // allowed to use it since it might have become stale. We keep it
         // around, though, and may be able to use it in the future once we
         // receive the next update (that doesn't sub it).
         if (max_age < last_update || eit->received > max_age) {
           SBFullHashResult full_hash;
           memcpy(&full_hash.hash.full_hash,
                  &eit->full_hash.full_hash,
                  sizeof(SBFullHash));
-          full_hash.list_name = GetListName(eit->list_id);
+          full_hash.list_name = safe_browsing_util::GetListName(eit->list_id);
           full_hash.add_chunk_id = eit->add_chunk_id;
           full_hits->push_back(full_hash);
         }
         ++eit;
       }
 
       if (entries.empty())
         hash_cache_->erase(hit);
     }
   }
@@ skipping 15 matching lines @@
   }
 
   const Time now = Time::Now();
   for (std::vector<SBFullHashResult>::const_iterator it = full_hits.begin();
        it != full_hits.end(); ++it) {
     SBPrefix prefix;
     memcpy(&prefix, &it->hash.full_hash, sizeof(SBPrefix));
     HashList& entries = (*hash_cache_)[prefix];
     HashCacheEntry entry;
     entry.received = now;
-    entry.list_id = GetListId(it->list_name);
+    entry.list_id = safe_browsing_util::GetListId(it->list_name);
     entry.add_chunk_id = EncodeChunkId(it->add_chunk_id, entry.list_id);
     memcpy(&entry.full_hash, &it->hash.full_hash, sizeof(SBFullHash));
     entries.push_back(entry);
 
     // Also push a copy to the pending write queue.
     pending_full_hashes_.push_back(entry);
   }
 }
 
 bool SafeBrowsingDatabaseBloom::ClearCachedEntry(SBPrefix prefix,
@@ skipping 50 matching lines @@
   if (did_resume_) {
     PlatformThread::Sleep(kOnResumeHoldupMs);
     did_resume_ = false;
   }
 }
 
 // This database is always synchronous since we don't need to worry about
 // blocking any incoming reads.
 void SafeBrowsingDatabaseBloom::SetSynchronous() {
 }