[safe_browsing] Remove unused ContainsBrowseUrl() parameter.

chrome/browser/safe_browsing/safe_browsing_database_unittest.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.
 //
 // Unit tests for the SafeBrowsing storage system.
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 513 matching lines @@
 
   // Make sure they were added correctly.
   GetListsInfo(&lists);
   EXPECT_TRUE(lists[0].name == safe_browsing_util::kMalwareList);
   EXPECT_EQ(lists[0].adds, "1-3");
   EXPECT_TRUE(lists[0].subs.empty());
 
   const Time now = Time::Now();
   std::vector<SBFullHashResult> full_hashes;
   std::vector<SBPrefix> prefix_hits;
-  std::string matching_list;
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/phishing.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
   EXPECT_EQ(prefix_hits[0], SBPrefixForString("www.evil.com/phishing.html"));
   EXPECT_EQ(prefix_hits.size(), 1U);
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/notevil1.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/notevil2.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.good.com/good1.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.good.com/good2.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://192.168.0.1/malware.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
   EXPECT_TRUE(prefix_hits.empty());
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/robots.txt"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   // Attempt to re-add the first chunk (should be a no-op).
   // see bug: http://code.google.com/p/chromium/issues/detail?id=4522
   chunk.hosts.clear();
   InsertAddChunkHost2PrefixUrls(&chunk, 1, "www.evil.com/",
                                 "www.evil.com/phishing.html",
                                 "www.evil.com/malware.html");
   chunks.clear();
   chunks.push_back(chunk);
   EXPECT_TRUE(database_->UpdateStarted(&lists));
@@ skipping 11 matching lines @@
                               "www.evil.com/notevil1.html");
   chunks.clear();
   chunks.push_back(chunk);
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
 
   database_->UpdateFinished(true);
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/phishing.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
   EXPECT_EQ(prefix_hits[0], SBPrefixForString("www.evil.com/phishing.html"));
   EXPECT_EQ(prefix_hits.size(), 1U);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/notevil1.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
   EXPECT_TRUE(prefix_hits.empty());
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/notevil2.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.good.com/good1.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.good.com/good2.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   GetListsInfo(&lists);
   EXPECT_TRUE(lists[0].name == safe_browsing_util::kMalwareList);
   EXPECT_EQ(lists[0].subs, "4");
 
   // Test the same sub chunk again.  This should be a no-op.
   // see bug: http://code.google.com/p/chromium/issues/detail?id=4522
   chunk.hosts.clear();
   InsertSubChunkHostPrefixUrl(&chunk, 4, 2, "www.evil.com/",
                               "www.evil.com/notevil1.html");
   chunks.clear();
   chunks.push_back(chunk);
 
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   EXPECT_TRUE(lists[0].name == safe_browsing_util::kMalwareList);
   EXPECT_EQ(lists[0].subs, "4");
 
   // Test removing all the prefixes from an add chunk.
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 2);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/notevil2.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.good.com/good1.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.good.com/good2.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   GetListsInfo(&lists);
   EXPECT_TRUE(lists[0].name == safe_browsing_util::kMalwareList);
   EXPECT_EQ(lists[0].adds, "1,3");
   EXPECT_EQ(lists[0].subs, "4");
 
   // The adddel command exposed a bug in the transaction code where any
   // transaction after it would fail.  Add a dummy entry and remove it to
   // make sure the transcation works fine.
   chunk.hosts.clear();
@@ skipping 24 matching lines @@
                                 "www.notevilanymore.com/index.html",
                                 "www.notevilanymore.com/good.html");
   chunks.clear();
   chunks.push_back(chunk);
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.notevilanymore.com/index.html"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   // Now insert the tardy add chunk and we don't expect them to appear
   // in database because of the previous sub chunk.
   chunk.hosts.clear();
   InsertAddChunkHost2PrefixUrls(&chunk, 10, "www.notevilanymore.com/",
                                 "www.notevilanymore.com/index.html",
                                 "www.notevilanymore.com/good.html");
   chunks.clear();
   chunks.push_back(chunk);
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.notevilanymore.com/index.html"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.notevilanymore.com/good.html"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 }
 
 
 // Test adding zero length chunks to the database.
 TEST_F(SafeBrowsingDatabaseTest, ZeroSizeChunk) {
   SBChunkList chunks;
   SBChunk chunk;
 
   // Populate with a couple of normal chunks.
   InsertAddChunkHost2PrefixUrls(&chunk, 1, "www.test.com/",
@@ skipping 53 matching lines @@
                               "www.notempty.com/full2.html");
   chunks.push_back(empty_chunk);
 
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   const Time now = Time::Now();
   std::vector<SBFullHashResult> full_hashes;
   std::vector<SBPrefix> prefix_hits;
-  std::string matching_list;
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.notempty.com/full1.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.notempty.com/full2.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   GetListsInfo(&lists);
   EXPECT_EQ(lists[0].adds, "1,10,19-22");
   EXPECT_EQ(lists[0].subs, "7");
 
   // Handle AddDel and SubDel commands for empty chunks.
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 21);
   database_->UpdateFinished(true);
 
@@ skipping 40 matching lines @@
   database_->CacheHashResults(prefixes, results);
 }
 
 TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
   PopulateDatabaseForCacheTest();
 
   // We should have both full hashes in the cache.
   EXPECT_EQ(2U, database_->cached_browse_hashes_.size());
 
   // Test the cache lookup for the first prefix.
-  std::string listname;
   std::vector<SBPrefix> prefixes;
   std::vector<SBFullHashResult> full_hashes;
   database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/phishing.html"),
-      &listname, &prefixes, &full_hashes, Time::Now());
+      &prefixes, &full_hashes, Time::Now());
   ASSERT_EQ(1U, full_hashes.size());
   EXPECT_TRUE(
       SBFullHashEqual(full_hashes[0].hash,
                       SBFullHashForString("www.evil.com/phishing.html")));
 
   prefixes.clear();
   full_hashes.clear();
 
   // Test the cache lookup for the second prefix.
   database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"),
-      &listname, &prefixes, &full_hashes, Time::Now());
+      &prefixes, &full_hashes, Time::Now());
   ASSERT_EQ(1U, full_hashes.size());
   EXPECT_TRUE(
       SBFullHashEqual(full_hashes[0].hash,
                       SBFullHashForString("www.evil.com/malware.html")));
 
   prefixes.clear();
   full_hashes.clear();
 
   // Test removing a prefix via a sub chunk.
   SBChunk chunk;
   SBChunkList chunks;
   InsertSubChunkHostPrefixUrl(&chunk, 2, 1, "www.evil.com/",
                               "www.evil.com/phishing.html");
   chunks.push_back(chunk);
 
   std::vector<SBListChunkRanges> lists;
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   // This prefix should still be there, but the fullhash is gone.
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"),
-      &listname, &prefixes, &full_hashes, Time::Now()));
+      &prefixes, &full_hashes, Time::Now()));
   ASSERT_EQ(1U, prefixes.size());
   EXPECT_EQ(SBPrefixForString("www.evil.com/malware.html"), prefixes[0]);
   EXPECT_TRUE(full_hashes.empty());
   prefixes.clear();
   full_hashes.clear();
 
   // This prefix should be gone.
   database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/phishing.html"),
-      &listname, &prefixes, &full_hashes, Time::Now());
+      &prefixes, &full_hashes, Time::Now());
   EXPECT_TRUE(full_hashes.empty());
 
   prefixes.clear();
   full_hashes.clear();
 
   // Test that an AddDel for the original chunk removes the last cached entry.
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 1);
   database_->UpdateFinished(true);
   database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"),
-      &listname, &prefixes, &full_hashes, Time::Now());
+      &prefixes, &full_hashes, Time::Now());
   EXPECT_TRUE(full_hashes.empty());
   EXPECT_TRUE(database_->full_browse_hashes_.empty());
   EXPECT_TRUE(database_->cached_browse_hashes_.empty());
 
   prefixes.clear();
   full_hashes.clear();
 
   // Test that the cache won't return expired values. First we have to adjust
   // the cached entries' received time to make them older, since the database
   // cache insert uses Time::Now(). First, store some entries.
   PopulateDatabaseForCacheTest();
 
   std::vector<SBFullHashCached>* hash_cache = &database_->cached_browse_hashes_;
   EXPECT_EQ(2U, hash_cache->size());
 
   // Now adjust one of the entries times to be in the past.
   base::Time expired = base::Time::Now() - base::TimeDelta::FromMinutes(60);
   const SBPrefix key = SBPrefixForString("www.evil.com/malware.html");
   std::vector<SBFullHashCached>::iterator iter;
   for (iter = hash_cache->begin(); iter != hash_cache->end(); ++iter) {
     if (iter->hash.prefix == key) {
       iter->received = static_cast<int32>(expired.ToTimeT());
       break;
     }
   }
   EXPECT_TRUE(iter != hash_cache->end());
 
   database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"),
-      &listname, &prefixes, &full_hashes, expired);
+      &prefixes, &full_hashes, expired);
   EXPECT_TRUE(full_hashes.empty());
 
   // This entry should still exist.
   database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/phishing.html"),
-      &listname, &prefixes, &full_hashes, expired);
+      &prefixes, &full_hashes, expired);
   EXPECT_EQ(1U, full_hashes.size());
 
   // Testing prefix miss caching. First, we clear out the existing database,
   // Since PopulateDatabaseForCacheTest() doesn't handle adding duplicate
   // chunks.
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 1);
   database_->UpdateFinished(true);
 
   std::vector<SBPrefix> prefix_misses;
@@ skipping 16 matching lines @@
   // in the database, it is flagged as a miss so looking up the associated URL
   // will not succeed.
   prefixes.clear();
   full_hashes.clear();
   prefix_misses.clear();
   empty_full_hash.clear();
   prefix_misses.push_back(SBPrefixForString("www.evil.com/phishing.html"));
   database_->CacheHashResults(prefix_misses, empty_full_hash);
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/phishing.html"),
-      &listname, &prefixes,
-      &full_hashes, Time::Now()));
+      &prefixes, &full_hashes, Time::Now()));
 
   prefixes.clear();
   full_hashes.clear();
 
   // Test receiving a full add chunk.
   chunk.hosts.clear();
   InsertAddChunkHost2FullHashes(&chunk, 20, "www.fullevil.com/",
                                 "www.fullevil.com/bad1.html",
                                 "www.fullevil.com/bad2.html");
   chunks.clear();
   chunks.push_back(chunk);
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.fullevil.com/bad1.html"),
-      &listname, &prefixes, &full_hashes,
-      Time::Now()));
+      &prefixes, &full_hashes, Time::Now()));
   ASSERT_EQ(1U, full_hashes.size());
   EXPECT_TRUE(
       SBFullHashEqual(full_hashes[0].hash,
                       SBFullHashForString("www.fullevil.com/bad1.html")));
   prefixes.clear();
   full_hashes.clear();
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.fullevil.com/bad2.html"),
-      &listname, &prefixes, &full_hashes,
-      Time::Now()));
+      &prefixes, &full_hashes, Time::Now()));
   ASSERT_EQ(1U, full_hashes.size());
   EXPECT_TRUE(
       SBFullHashEqual(full_hashes[0].hash,
                       SBFullHashForString("www.fullevil.com/bad2.html")));
   prefixes.clear();
   full_hashes.clear();
 
   // Test receiving a full sub chunk, which will remove one of the full adds.
   chunk.hosts.clear();
   InsertSubChunkHostFullHash(&chunk, 200, 20,
                              "www.fullevil.com/",
                              "www.fullevil.com/bad1.html");
   chunks.clear();
   chunks.push_back(chunk);
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.fullevil.com/bad1.html"),
-      &listname, &prefixes, &full_hashes,
-      Time::Now()));
+      &prefixes, &full_hashes, Time::Now()));
   EXPECT_TRUE(full_hashes.empty());
 
   // There should be one remaining full add.
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.fullevil.com/bad2.html"),
-      &listname, &prefixes, &full_hashes,
-      Time::Now()));
+      &prefixes, &full_hashes, Time::Now()));
   ASSERT_EQ(1U, full_hashes.size());
   EXPECT_TRUE(
       SBFullHashEqual(full_hashes[0].hash,
                       SBFullHashForString("www.fullevil.com/bad2.html")));
   prefixes.clear();
   full_hashes.clear();
 
   // Now test an AddDel for the remaining full add.
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 20);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.fullevil.com/bad1.html"),
-      &listname, &prefixes, &full_hashes,
-      Time::Now()));
+      &prefixes, &full_hashes, Time::Now()));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.fullevil.com/bad2.html"),
-      &listname, &prefixes, &full_hashes,
-      Time::Now()));
+      &prefixes, &full_hashes, Time::Now()));
 }
 
 // Test that corrupt databases are appropriately handled, even if the
 // corruption is detected in the midst of the update.
 // TODO(shess): Disabled until ScopedLogMessageIgnorer resolved.
 // http://crbug.com/56448
 TEST_F(SafeBrowsingDatabaseTest, DISABLED_FileCorruptionHandling) {
   // Re-create the database in a captive message loop so that we can
   // influence task-posting.  Database specifically needs to the
   // file-backed.
@@ skipping 429 matching lines @@
   GetListsInfo(&lists);
   EXPECT_EQ(std::string(safe_browsing_util::kMalwareList), lists[0].name);
   EXPECT_EQ("1", lists[0].adds);
   EXPECT_EQ(std::string(safe_browsing_util::kPhishingList), lists[1].name);
   EXPECT_EQ("47", lists[1].adds);
 
   const Time now = Time::Now();
   std::vector<SBPrefix> prefixes;
   std::vector<SBFullHashResult> full_hashes;
   std::vector<SBPrefix> prefix_hits;
-  std::string matching_list;
-  std::string listname;
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware1.html"),
-      &listname, &prefixes, &full_hashes, now));
+      &prefixes, &full_hashes, now));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware2.html"),
-      &listname, &prefixes, &full_hashes, now));
+      &prefixes, &full_hashes, now));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/phishing1.html"),
-      &listname, &prefixes, &full_hashes, now));
+      &prefixes, &full_hashes, now));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/phishing2.html"),
-      &listname, &prefixes, &full_hashes, now));
+      &prefixes, &full_hashes, now));
 
   // Test removing a single prefix from the add chunk.
   // Remove the prefix that added first.
   chunk.hosts.clear();
   InsertSubChunkHostPrefixUrl(&chunk, 4, 1, "www.evil.com/",
                               "www.evil.com/malware1.html");
   chunks.clear();
   chunks.push_back(chunk);
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   // Remove the prefix that added last.
   chunk.hosts.clear();
   InsertSubChunkHostPrefixUrl(&chunk, 5, 47, "www.evil.com/",
                               "www.evil.com/phishing2.html");
   chunks.clear();
   chunks.push_back(chunk);
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kPhishingList, chunks);
   database_->UpdateFinished(true);
 
   // Verify that the database contains urls expected.
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware1.html"),
-      &listname, &prefixes, &full_hashes, now));
+      &prefixes, &full_hashes, now));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware2.html"),
-      &listname, &prefixes, &full_hashes, now));
+      &prefixes, &full_hashes, now));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/phishing1.html"),
-      &listname, &prefixes, &full_hashes, now));
+      &prefixes, &full_hashes, now));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/phishing2.html"),
-      &listname, &prefixes, &full_hashes, now));
+      &prefixes, &full_hashes, now));
 }
 
 // Test that an empty update doesn't actually update the database.
 // This isn't a functionality requirement, but it is a useful
 // optimization.
 TEST_F(SafeBrowsingDatabaseTest, EmptyUpdate) {
   SBChunkList chunks;
   SBChunk chunk;
 
   base::FilePath filename = database_->BrowseDBFilename(database_filename_);
@@ skipping 68 matching lines @@
     chunks.clear();
     chunks.push_back(chunk);
     database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
     database_->UpdateFinished(true);
   }
 
   // Find the malware url in the database, don't find a good url.
   const Time now = Time::Now();
   std::vector<SBFullHashResult> full_hashes;
   std::vector<SBPrefix> prefix_hits;
-  std::string matching_list;
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.good.com/goodware.html"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   base::FilePath filter_file = database_->PrefixSetForFilename(
       database_->BrowseDBFilename(database_filename_));
 
   // After re-creating the database, it should have a filter read from
   // a file, so it should find the same results.
   ASSERT_TRUE(base::PathExists(filter_file));
   database_.reset(new SafeBrowsingDatabaseNew);
   database_->Init(database_filename_);
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.good.com/goodware.html"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 
   // If there is no filter file, the database cannot find malware urls.
   base::DeleteFile(filter_file, false);
   ASSERT_FALSE(base::PathExists(filter_file));
   database_.reset(new SafeBrowsingDatabaseNew);
   database_->Init(database_filename_);
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.good.com/goodware.html"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      &prefix_hits, &full_hashes, now));
 }
 
 TEST_F(SafeBrowsingDatabaseTest, MalwareIpBlacklist) {
   database_.reset();
   SafeBrowsingStoreFile* browse_store = new SafeBrowsingStoreFile();
   SafeBrowsingStoreFile* ip_blacklist_store = new SafeBrowsingStoreFile();
   database_.reset(new SafeBrowsingDatabaseNew(browse_store,
                                               NULL,
                                               NULL,
                                               NULL,
@@ skipping 79 matching lines @@
   EXPECT_FALSE(database_->ContainsMalwareIP("192.1.124.0"));
 
   EXPECT_FALSE(database_->ContainsMalwareIP("192.1.127.255"));
   EXPECT_TRUE(database_->ContainsMalwareIP("192.1.128.0"));
   EXPECT_TRUE(database_->ContainsMalwareIP("::ffff:192.1.128.1"));
   EXPECT_TRUE(database_->ContainsMalwareIP("192.1.128.255"));
   EXPECT_TRUE(database_->ContainsMalwareIP("192.1.255.0"));
   EXPECT_TRUE(database_->ContainsMalwareIP("192.1.255.255"));
   EXPECT_FALSE(database_->ContainsMalwareIP("192.2.0.0"));
 }