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"
@@ skipping 812 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));
 }