Introduce SafeBrowsingDatabase::ThreadSafeStateManager.

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 "chrome/browser/safe_browsing/safe_browsing_database.h"
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/time/time.h"
 #include "chrome/browser/safe_browsing/chunk.pb.h"
 #include "chrome/browser/safe_browsing/safe_browsing_store_file.h"
-#include "content/public/test/test_browser_thread_bundle.h"
 #include "crypto/sha2.h"
 #include "net/base/net_util.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 #include "url/gurl.h"
 
 using base::Time;
 using base::TimeDelta;
@@ skipping 293 matching lines @@
   void SubDelChunk(const std::string& list, int chunk_id) {
     DelChunk(list, chunk_id, true);
   }
 
   // Utility function for setting up the database for the caching test.
   void PopulateDatabaseForCacheTest();
 
   scoped_ptr<SafeBrowsingDatabaseNew> database_;
   base::FilePath database_filename_;
   base::ScopedTempDir temp_dir_;
-
-  // We expect most checks made on |database_| to be made from the IO thread.
-  // Use this ThreadBundle to fake the IO thread in the main message loop in
-  // these tests.
-  content::TestBrowserThreadBundle thread_bundle_;
 };
 
 // Tests retrieving list name information.
 TEST_F(SafeBrowsingDatabaseTest, ListNameForBrowse) {
   std::vector<SBListChunkRanges> lists;
   ScopedVector<SBChunkData> chunks;
 
   chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html"));
   chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html"));
   chunks.push_back(AddChunkPrefixValue(3, "www.whatever.com/malware.html"));
@@ skipping 480 matching lines @@
   chunks.push_back(AddChunkPrefix2Value(1,
                                         "www.evil.com/phishing.html",
                                         "www.evil.com/malware.html"));
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   // Cache should be cleared after updating.
-  EXPECT_TRUE(database_->prefix_gethash_cache_.empty());
+  EXPECT_TRUE(
+      database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty());
 
   SBFullHashResult full_hash;
   full_hash.list_id = safe_browsing_util::MALWARE;
 
   std::vector<SBFullHashResult> results;
   std::vector<SBPrefix> prefixes;
 
   // Add a fullhash result for each prefix.
   full_hash.hash = SBFullHashForString("www.evil.com/phishing.html");
   results.push_back(full_hash);
   prefixes.push_back(full_hash.hash.prefix);
 
   full_hash.hash = SBFullHashForString("www.evil.com/malware.html");
   results.push_back(full_hash);
   prefixes.push_back(full_hash.hash.prefix);
 
   database_->CacheHashResults(prefixes, results, kCacheLifetime);
 }
 
 TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
   PopulateDatabaseForCacheTest();
 
   // We should have both full hashes in the cache.
-  EXPECT_EQ(2U, database_->prefix_gethash_cache_.size());
+  EXPECT_EQ(2U,
+            database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->size());
 
   // Test the cache lookup for the first prefix.
   std::vector<SBPrefix> prefix_hits;
   std::vector<SBFullHashResult> cache_hits;
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits));
   EXPECT_TRUE(prefix_hits.empty());
   ASSERT_EQ(1U, cache_hits.size());
   EXPECT_TRUE(SBFullHashEqual(
       cache_hits[0].hash, SBFullHashForString("www.evil.com/phishing.html")));
@@ skipping 35 matching lines @@
       GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits));
   prefix_hits.clear();
   cache_hits.clear();
 
   // Test that an AddDel for the original chunk removes the last cached entry.
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 1);
   database_->UpdateFinished(true);
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
-  EXPECT_TRUE(database_->prefix_gethash_cache_.empty());
+  EXPECT_TRUE(
+      database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty());
   prefix_hits.clear();
   cache_hits.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::map<SBPrefix, SBCachedFullHashResult>* hash_cache =
-      &database_->prefix_gethash_cache_;
+  SafeBrowsingDatabaseNew::PrefixGetHashCache* hash_cache =
+      database_->GetUnsynchronizedPrefixGetHashCacheForTesting();
   EXPECT_EQ(2U, hash_cache->size());
 
   // Now adjust one of the entries times to be in the past.
   const SBPrefix key = SBPrefixForString("www.evil.com/malware.html");
-  std::map<SBPrefix, SBCachedFullHashResult>::iterator iter =
+  SafeBrowsingDatabaseNew::PrefixGetHashCache::iterator iter =
       hash_cache->find(key);
   ASSERT_TRUE(iter != hash_cache->end());
   iter->second.expire_after = Time::Now() - TimeDelta::FromMinutes(1);
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
   EXPECT_EQ(1U, prefix_hits.size());
   EXPECT_TRUE(cache_hits.empty());
   // Expired entry should have been removed from cache.
   EXPECT_EQ(1U, hash_cache->size());
@@ skipping 939 matching lines @@
 
   // Remove kFullHash1_1 from the database.
   chunks.clear();
   chunks.push_back(SubChunkFullHash(11, kFullHash1_1, 1));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   // Cache should be cleared after updating.
-  EXPECT_TRUE(database_->prefix_gethash_cache_.empty());
+  EXPECT_TRUE(
+      database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty());
 
   {
     // Now the database doesn't contain kFullHash1_1.
     std::vector<SBFullHash> full_hashes(1, kFullHash1_1);
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
     EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
         full_hashes, &prefix_hits, &cache_hits));
 
     // Nor kFullHash1_3.
@@ skipping 16 matching lines @@
 
   // Remove kFullHash1_2 from the database.
   chunks.clear();
   chunks.push_back(SubChunkFullHash(12, kFullHash1_2, 2));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   // Cache should be cleared after updating.
-  EXPECT_TRUE(database_->prefix_gethash_cache_.empty());
+  EXPECT_TRUE(
+      database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty());
 
   {
     // None are present.
     std::vector<SBFullHash> full_hashes;
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
     full_hashes.push_back(kFullHash1_1);
     full_hashes.push_back(kFullHash1_2);
     full_hashes.push_back(kFullHash1_3);
     EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
@@ skipping 194 matching lines @@
       GURL(std::string("http://") + kExampleCollision),
       &prefix_hits, &cache_hits));
   ASSERT_EQ(1U, prefix_hits.size());
   EXPECT_EQ(SBPrefixForString(kExampleCollision), prefix_hits[0]);
   EXPECT_TRUE(cache_hits.empty());
 
   // This prefix collides, but no full hash match.
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits));
 }