Finalize thread-safety design for SafeBrowsingDatabase.

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 652 matching lines @@
     SafeBrowsingStore* browse_store,
     SafeBrowsingStore* download_store,
     SafeBrowsingStore* csd_whitelist_store,
     SafeBrowsingStore* download_whitelist_store,
     SafeBrowsingStore* inclusion_whitelist_store,
     SafeBrowsingStore* extension_blacklist_store,
     SafeBrowsingStore* side_effect_free_whitelist_store,
     SafeBrowsingStore* ip_blacklist_store,
     SafeBrowsingStore* unwanted_software_store)
     : state_manager_(thread_checker_),
+      db_state_manager_(thread_checker_),
       browse_store_(browse_store),
       download_store_(download_store),
       csd_whitelist_store_(csd_whitelist_store),
       download_whitelist_store_(download_whitelist_store),
       inclusion_whitelist_store_(inclusion_whitelist_store),
       extension_blacklist_store_(extension_blacklist_store),
       side_effect_free_whitelist_store_(side_effect_free_whitelist_store),
       ip_blacklist_store_(ip_blacklist_store),
       unwanted_software_store_(unwanted_software_store),
-      corruption_detected_(false),
-      change_detected_(false),
       reset_factory_(this) {
   DCHECK(browse_store_.get());
 }
 
 SafeBrowsingDatabaseNew::~SafeBrowsingDatabaseNew() {
   // The DCHECK is disabled due to crbug.com/338486 .
   // DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void SafeBrowsingDatabaseNew::Init(const base::FilePath& filename_base) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // This should not be run multiple times.
-  DCHECK(filename_base_.empty());
-
-  filename_base_ = filename_base;
+  db_state_manager_.init_filename_base(filename_base);
 
   // TODO(shess): The various stores are really only necessary while doing
   // updates (see |UpdateFinished()|) or when querying a store directly (see
   // |ContainsDownloadUrl()|).
   // The store variables are also tested to see if a list is enabled.  Perhaps
   // the stores could be refactored into an update object so that they are only
   // live in memory while being actively used.  The sense of enabled probably
   // belongs in protocol_manager or database_manager.
 
   {
     // NOTE: A transaction here is overkill as there are no pointers to this
     // class on other threads until this function returns, but it's also
     // harmless as that also means there is no possibility of contention on the
     // lock.
     scoped_ptr<WriteTransaction> txn = state_manager_.BeginWriteTransaction();
 
     txn->clear_prefix_gethash_cache();
 
     browse_store_->Init(
-        BrowseDBFilename(filename_base_),
+        BrowseDBFilename(db_state_manager_.filename_base()),
         base::Bind(&SafeBrowsingDatabaseNew::HandleCorruptDatabase,
                    base::Unretained(this)));
 
     if (unwanted_software_store_.get()) {
       unwanted_software_store_->Init(
-          UnwantedSoftwareDBFilename(filename_base_),
+          UnwantedSoftwareDBFilename(db_state_manager_.filename_base()),
           base::Bind(&SafeBrowsingDatabaseNew::HandleCorruptDatabase,
                      base::Unretained(this)));
     }
-    LoadPrefixSet(BrowseDBFilename(filename_base_), txn.get(),
-                  PrefixSetId::BROWSE, FAILURE_BROWSE_PREFIX_SET_READ);
+    LoadPrefixSet(BrowseDBFilename(db_state_manager_.filename_base()),
+                  txn.get(), PrefixSetId::BROWSE,
+                  FAILURE_BROWSE_PREFIX_SET_READ);
     if (unwanted_software_store_.get()) {
-      LoadPrefixSet(UnwantedSoftwareDBFilename(filename_base_), txn.get(),
-                    PrefixSetId::UNWANTED_SOFTWARE,
-                    FAILURE_UNWANTED_SOFTWARE_PREFIX_SET_READ);
+      LoadPrefixSet(
+          UnwantedSoftwareDBFilename(db_state_manager_.filename_base()),
+          txn.get(), PrefixSetId::UNWANTED_SOFTWARE,
+          FAILURE_UNWANTED_SOFTWARE_PREFIX_SET_READ);
     }
 
     if (side_effect_free_whitelist_store_.get()) {
       const base::FilePath side_effect_free_whitelist_filename =
-          SideEffectFreeWhitelistDBFilename(filename_base_);
+          SideEffectFreeWhitelistDBFilename(db_state_manager_.filename_base());
       side_effect_free_whitelist_store_->Init(
           side_effect_free_whitelist_filename,
           base::Bind(&SafeBrowsingDatabaseNew::HandleCorruptDatabase,
                      base::Unretained(this)));
 
       LoadPrefixSet(side_effect_free_whitelist_filename, txn.get(),
                     PrefixSetId::SIDE_EFFECT_FREE_WHITELIST,
                     FAILURE_SIDE_EFFECT_FREE_WHITELIST_PREFIX_SET_READ);
     } else {
       // Delete any files of the side-effect free sidelist that may be around
       // from when it was previously enabled.
       SafeBrowsingStoreFile::DeleteStore(
-          SideEffectFreeWhitelistDBFilename(filename_base_));
-      base::DeleteFile(PrefixSetForFilename(
-                           SideEffectFreeWhitelistDBFilename(filename_base_)),
+          SideEffectFreeWhitelistDBFilename(db_state_manager_.filename_base()));
+      base::DeleteFile(PrefixSetForFilename(SideEffectFreeWhitelistDBFilename(
+                           db_state_manager_.filename_base())),
                        false);
     }
   }
   // Note: End the transaction early because LoadWhiteList() and
   // WhitelistEverything() manage their own transactions.
 
   if (download_store_.get()) {
     download_store_->Init(
-        DownloadDBFilename(filename_base_),
+        DownloadDBFilename(db_state_manager_.filename_base()),
         base::Bind(&SafeBrowsingDatabaseNew::HandleCorruptDatabase,
                    base::Unretained(this)));
   }
 
   if (csd_whitelist_store_.get()) {
     csd_whitelist_store_->Init(
-        CsdWhitelistDBFilename(filename_base_),
+        CsdWhitelistDBFilename(db_state_manager_.filename_base()),
         base::Bind(&SafeBrowsingDatabaseNew::HandleCorruptDatabase,
                    base::Unretained(this)));
 
     std::vector<SBAddFullHash> full_hashes;
     if (csd_whitelist_store_->GetAddFullHashes(&full_hashes)) {
       LoadWhitelist(full_hashes, SBWhitelistId::CSD);
     } else {
       state_manager_.BeginWriteTransaction()->WhitelistEverything(
           SBWhitelistId::CSD);
     }
   } else {
     state_manager_.BeginWriteTransaction()->WhitelistEverything(
         SBWhitelistId::CSD);  // Just to be safe.
   }
 
   if (download_whitelist_store_.get()) {
     download_whitelist_store_->Init(
-        DownloadWhitelistDBFilename(filename_base_),
+        DownloadWhitelistDBFilename(db_state_manager_.filename_base()),
         base::Bind(&SafeBrowsingDatabaseNew::HandleCorruptDatabase,
                    base::Unretained(this)));
 
     std::vector<SBAddFullHash> full_hashes;
     if (download_whitelist_store_->GetAddFullHashes(&full_hashes)) {
       LoadWhitelist(full_hashes, SBWhitelistId::DOWNLOAD);
     } else {
       state_manager_.BeginWriteTransaction()->WhitelistEverything(
           SBWhitelistId::DOWNLOAD);
     }
   } else {
     state_manager_.BeginWriteTransaction()->WhitelistEverything(
         SBWhitelistId::DOWNLOAD);  // Just to be safe.
   }
 
   if (inclusion_whitelist_store_.get()) {
     inclusion_whitelist_store_->Init(
-        InclusionWhitelistDBFilename(filename_base_),
+        InclusionWhitelistDBFilename(db_state_manager_.filename_base()),
         base::Bind(&SafeBrowsingDatabaseNew::HandleCorruptDatabase,
                    base::Unretained(this)));
 
     std::vector<SBAddFullHash> full_hashes;
     if (inclusion_whitelist_store_->GetAddFullHashes(&full_hashes)) {
       LoadWhitelist(full_hashes, SBWhitelistId::INCLUSION);
     } else {
       state_manager_.BeginWriteTransaction()->WhitelistEverything(
           SBWhitelistId::INCLUSION);
     }
   } else {
     state_manager_.BeginWriteTransaction()->WhitelistEverything(
         SBWhitelistId::INCLUSION);  // Just to be safe.
   }
 
   if (extension_blacklist_store_.get()) {
     extension_blacklist_store_->Init(
-        ExtensionBlacklistDBFilename(filename_base_),
+        ExtensionBlacklistDBFilename(db_state_manager_.filename_base()),
         base::Bind(&SafeBrowsingDatabaseNew::HandleCorruptDatabase,
                    base::Unretained(this)));
   }
 
   if (ip_blacklist_store_.get()) {
     ip_blacklist_store_->Init(
-        IpBlacklistDBFilename(filename_base_),
+        IpBlacklistDBFilename(db_state_manager_.filename_base()),
         base::Bind(&SafeBrowsingDatabaseNew::HandleCorruptDatabase,
                    base::Unretained(this)));
 
     std::vector<SBAddFullHash> full_hashes;
     if (ip_blacklist_store_->GetAddFullHashes(&full_hashes)) {
       LoadIpBlacklist(full_hashes);
     } else {
       LoadIpBlacklist(std::vector<SBAddFullHash>());  // Clear the list.
     }
   }
@@ skipping 289 matching lines @@
                           chunk_data.FullHashAt(i));
     }
   }
 }
 
 void SafeBrowsingDatabaseNew::InsertChunks(
     const std::string& list_name,
     const std::vector<SBChunkData*>& chunks) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (corruption_detected_ || chunks.empty())
+  if (db_state_manager_.corruption_detected() || chunks.empty())
     return;
 
   const base::TimeTicks before = base::TimeTicks::Now();
 
   // TODO(shess): The caller should just pass list_id.
   const safe_browsing_util::ListType list_id =
       safe_browsing_util::GetListId(list_name);
 
   SafeBrowsingStore* store = GetStore(list_id);
   if (!store) return;
 
-  change_detected_ = true;
+  db_state_manager_.set_change_detected();
 
   // TODO(shess): I believe that the list is always add or sub.  Can this use
   // that productively?
   store->BeginChunk();
   for (size_t i = 0; i < chunks.size(); ++i) {
     if (chunks[i]->IsAdd()) {
       InsertAddChunk(store, list_id, *chunks[i]);
     } else if (chunks[i]->IsSub()) {
       InsertSubChunk(store, list_id, *chunks[i]);
     } else {
       NOTREACHED();
     }
   }
   store->FinishChunk();
 
   UMA_HISTOGRAM_TIMES("SB2.ChunkInsert", base::TimeTicks::Now() - before);
 }
 
 void SafeBrowsingDatabaseNew::DeleteChunks(
     const std::vector<SBChunkDelete>& chunk_deletes) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (corruption_detected_ || chunk_deletes.empty())
+  if (db_state_manager_.corruption_detected() || chunk_deletes.empty())
     return;
 
   const std::string& list_name = chunk_deletes.front().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;
+  db_state_manager_.set_change_detected();
 
   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 118 matching lines @@
   UpdateChunkRangesForList(side_effect_free_whitelist_store_.get(),
                            safe_browsing_util::kSideEffectFreeWhitelist, lists);
 
   UpdateChunkRangesForList(ip_blacklist_store_.get(),
                            safe_browsing_util::kIPBlacklist, lists);
 
   UpdateChunkRangesForList(unwanted_software_store_.get(),
                            safe_browsing_util::kUnwantedUrlList,
                            lists);
 
-  corruption_detected_ = false;
-  change_detected_ = false;
+  db_state_manager_.reset_corruption_detected();
+  db_state_manager_.reset_change_detected();
   return true;
 }
 
 void SafeBrowsingDatabaseNew::UpdateFinished(bool update_succeeded) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // 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 33 matching lines @@
     if (ip_blacklist_store_ && !ip_blacklist_store_->CheckValidity()) {
       DLOG(ERROR) << "Safe-browsing IP blacklist database corrupt.";
     }
 
     if (unwanted_software_store_ &&
         !unwanted_software_store_->CheckValidity()) {
       DLOG(ERROR) << "Unwanted software url list database corrupt.";
     }
   }
 
-  if (corruption_detected_)
+  if (db_state_manager_.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 || !db_state_manager_.change_detected()) {
     // Track empty updates to answer questions at http://crbug.com/72216 .
-    if (update_succeeded && !change_detected_)
+    if (update_succeeded && !db_state_manager_.change_detected())
       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();
     if (inclusion_whitelist_store_.get())
       inclusion_whitelist_store_->CancelUpdate();
     if (extension_blacklist_store_)
       extension_blacklist_store_->CancelUpdate();
     if (side_effect_free_whitelist_store_)
       side_effect_free_whitelist_store_->CancelUpdate();
     if (ip_blacklist_store_)
       ip_blacklist_store_->CancelUpdate();
     if (unwanted_software_store_)
       unwanted_software_store_->CancelUpdate();
     return;
   }
 
   if (download_store_) {
-    UpdateHashPrefixStore(DownloadDBFilename(filename_base_),
+    UpdateHashPrefixStore(DownloadDBFilename(db_state_manager_.filename_base()),
                           download_store_.get(),
                           FAILURE_DOWNLOAD_DATABASE_UPDATE_FINISH);
   }
 
-  UpdatePrefixSetUrlStore(BrowseDBFilename(filename_base_),
-                          browse_store_.get(),
-                          PrefixSetId::BROWSE,
+  UpdatePrefixSetUrlStore(BrowseDBFilename(db_state_manager_.filename_base()),
+                          browse_store_.get(), PrefixSetId::BROWSE,
                           FAILURE_BROWSE_DATABASE_UPDATE_FINISH,
-                          FAILURE_BROWSE_PREFIX_SET_WRITE,
-                          true);
+                          FAILURE_BROWSE_PREFIX_SET_WRITE, true);
 
-  UpdateWhitelistStore(CsdWhitelistDBFilename(filename_base_),
-                       csd_whitelist_store_.get(),
-                       SBWhitelistId::CSD);
-  UpdateWhitelistStore(DownloadWhitelistDBFilename(filename_base_),
-                       download_whitelist_store_.get(),
-                       SBWhitelistId::DOWNLOAD);
-  UpdateWhitelistStore(InclusionWhitelistDBFilename(filename_base_),
-                       inclusion_whitelist_store_.get(),
-                       SBWhitelistId::INCLUSION);
+  UpdateWhitelistStore(
+      CsdWhitelistDBFilename(db_state_manager_.filename_base()),
+      csd_whitelist_store_.get(), SBWhitelistId::CSD);
+  UpdateWhitelistStore(
+      DownloadWhitelistDBFilename(db_state_manager_.filename_base()),
+      download_whitelist_store_.get(), SBWhitelistId::DOWNLOAD);
+  UpdateWhitelistStore(
+      InclusionWhitelistDBFilename(db_state_manager_.filename_base()),
+      inclusion_whitelist_store_.get(), SBWhitelistId::INCLUSION);
 
   if (extension_blacklist_store_) {
-    UpdateHashPrefixStore(ExtensionBlacklistDBFilename(filename_base_),
-                          extension_blacklist_store_.get(),
-                          FAILURE_EXTENSION_BLACKLIST_UPDATE_FINISH);
+    UpdateHashPrefixStore(
+        ExtensionBlacklistDBFilename(db_state_manager_.filename_base()),
+        extension_blacklist_store_.get(),
+        FAILURE_EXTENSION_BLACKLIST_UPDATE_FINISH);
   }
 
   if (side_effect_free_whitelist_store_) {
-    UpdatePrefixSetUrlStore(SideEffectFreeWhitelistDBFilename(filename_base_),
-                            side_effect_free_whitelist_store_.get(),
-                            PrefixSetId::SIDE_EFFECT_FREE_WHITELIST,
-                            FAILURE_SIDE_EFFECT_FREE_WHITELIST_UPDATE_FINISH,
-                            FAILURE_SIDE_EFFECT_FREE_WHITELIST_PREFIX_SET_WRITE,
-                            false);
+    UpdatePrefixSetUrlStore(
+        SideEffectFreeWhitelistDBFilename(db_state_manager_.filename_base()),
+        side_effect_free_whitelist_store_.get(),
+        PrefixSetId::SIDE_EFFECT_FREE_WHITELIST,
+        FAILURE_SIDE_EFFECT_FREE_WHITELIST_UPDATE_FINISH,
+        FAILURE_SIDE_EFFECT_FREE_WHITELIST_PREFIX_SET_WRITE, false);
   }
 
   if (ip_blacklist_store_)
     UpdateIpBlacklistStore();
 
   if (unwanted_software_store_) {
-    UpdatePrefixSetUrlStore(UnwantedSoftwareDBFilename(filename_base_),
-                            unwanted_software_store_.get(),
-                            PrefixSetId::UNWANTED_SOFTWARE,
-                            FAILURE_UNWANTED_SOFTWARE_DATABASE_UPDATE_FINISH,
-                            FAILURE_UNWANTED_SOFTWARE_PREFIX_SET_WRITE,
-                            true);
+    UpdatePrefixSetUrlStore(
+        UnwantedSoftwareDBFilename(db_state_manager_.filename_base()),
+        unwanted_software_store_.get(), PrefixSetId::UNWANTED_SOFTWARE,
+        FAILURE_UNWANTED_SOFTWARE_DATABASE_UPDATE_FINISH,
+        FAILURE_UNWANTED_SOFTWARE_PREFIX_SET_WRITE, true);
   }
 }
 
 void SafeBrowsingDatabaseNew::UpdateWhitelistStore(
     const base::FilePath& store_filename,
     SafeBrowsingStore* store,
     SBWhitelistId whitelist_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!store)
@@ skipping 132 matching lines @@
   // stores all full-length hashes as both full and prefix hashes.
   PrefixSetBuilder builder;
   std::vector<SBAddFullHash> full_hashes;
   if (!ip_blacklist_store_->FinishUpdate(&builder, &full_hashes)) {
     RecordFailure(FAILURE_IP_BLACKLIST_UPDATE_FINISH);
     LoadIpBlacklist(std::vector<SBAddFullHash>());  // Clear the list.
     return;
   }
 
   const base::FilePath ip_blacklist_filename =
-      IpBlacklistDBFilename(filename_base_);
+      IpBlacklistDBFilename(db_state_manager_.filename_base());
 
   RecordFileSizeHistogram(ip_blacklist_filename);
 
 #if defined(OS_MACOSX)
   base::mac::SetFileBackupExclusion(ip_blacklist_filename);
 #endif
 
   LoadIpBlacklist(full_hashes);
 }
 
 void SafeBrowsingDatabaseNew::HandleCorruptDatabase() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Reset the database after the current task has unwound (but only
   // reset once within the scope of a given task).
   if (!reset_factory_.HasWeakPtrs()) {
     RecordFailure(FAILURE_DATABASE_CORRUPT);
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&SafeBrowsingDatabaseNew::OnHandleCorruptDatabase,
                    reset_factory_.GetWeakPtr()));
   }
 }
 
 void SafeBrowsingDatabaseNew::OnHandleCorruptDatabase() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   RecordFailure(FAILURE_DATABASE_CORRUPT_HANDLER);
-  corruption_detected_ = true;  // Stop updating the database.
+  db_state_manager_.set_corruption_detected();  // Stop updating the database.
   ResetDatabase();
 
   // NOTE(shess): ResetDatabase() should remove the corruption, so this should
   // only happen once.  If you are here because you are hitting this after a
   // restart, then I would be very interested in working with you to figure out
   // what is happening, since it may affect real users.
   DLOG(FATAL) << "SafeBrowsing database was corrupt and reset";
 }
 
 // TODO(shess): I'm not clear why this code doesn't have any
 // real error-handling.
 void SafeBrowsingDatabaseNew::LoadPrefixSet(const base::FilePath& db_filename,
                                             WriteTransaction* txn,
                                             PrefixSetId prefix_set_id,
                                             FailureType read_failure_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(txn);
-  DCHECK(!filename_base_.empty());
+  DCHECK(!db_state_manager_.filename_base().empty());
 
   // Only use the prefix set if database is present and non-empty.
   if (!GetFileSizeOrZero(db_filename))
     return;
 
   // Cleanup any stale bloom filter (no longer used).
   // TODO(shess): Track existence to drive removal of this code?
   const base::FilePath bloom_filter_filename =
       BloomFilterForFilename(db_filename);
   base::DeleteFile(bloom_filter_filename, false);
 
   const base::TimeTicks before = base::TimeTicks::Now();
   scoped_ptr<const PrefixSet> new_prefix_set =
       PrefixSet::LoadFile(PrefixSetForFilename(db_filename));
   if (!new_prefix_set.get())
     RecordFailure(read_failure_type);
   txn->SwapPrefixSet(prefix_set_id, new_prefix_set.Pass());
   UMA_HISTOGRAM_TIMES("SB2.PrefixSetLoad", base::TimeTicks::Now() - before);
 }
 
 bool SafeBrowsingDatabaseNew::Delete() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!filename_base_.empty());
+  DCHECK(!db_state_manager_.filename_base().empty());
 
   // TODO(shess): This is a mess.  SafeBrowsingFileStore::Delete() closes the
   // store before calling DeleteStore().  DeleteStore() deletes transient files
   // in addition to the main file.  Probably all of these should be converted to
   // a helper which calls Delete() if the store exists, else DeleteStore() on
   // the generated filename.
 
   // TODO(shess): Determine if the histograms are useful in any way.  I cannot
   // recall any action taken as a result of their values, in which case it might
   // make more sense to histogram an overall thumbs-up/-down and just dig deeper
@@ skipping 15 matching lines @@
   const bool r4 = download_whitelist_store_.get() ?
       download_whitelist_store_->Delete() : true;
   if (!r4)
     RecordFailure(FAILURE_DATABASE_STORE_DELETE);
 
   const bool r5 = inclusion_whitelist_store_.get() ?
       inclusion_whitelist_store_->Delete() : true;
   if (!r5)
     RecordFailure(FAILURE_DATABASE_STORE_DELETE);
 
-  const base::FilePath browse_filename = BrowseDBFilename(filename_base_);
+  const base::FilePath browse_filename =
+      BrowseDBFilename(db_state_manager_.filename_base());
   const base::FilePath bloom_filter_filename =
       BloomFilterForFilename(browse_filename);
   const bool r6 = base::DeleteFile(bloom_filter_filename, false);
   if (!r6)
     RecordFailure(FAILURE_DATABASE_FILTER_DELETE);
 
   const base::FilePath browse_prefix_set_filename =
       PrefixSetForFilename(browse_filename);
   const bool r7 = base::DeleteFile(browse_prefix_set_filename, false);
   if (!r7)
     RecordFailure(FAILURE_BROWSE_PREFIX_SET_DELETE);
 
   const base::FilePath extension_blacklist_filename =
-      ExtensionBlacklistDBFilename(filename_base_);
+      ExtensionBlacklistDBFilename(db_state_manager_.filename_base());
   const bool r8 = base::DeleteFile(extension_blacklist_filename, false);
   if (!r8)
     RecordFailure(FAILURE_EXTENSION_BLACKLIST_DELETE);
 
   const base::FilePath side_effect_free_whitelist_filename =
-      SideEffectFreeWhitelistDBFilename(filename_base_);
+      SideEffectFreeWhitelistDBFilename(db_state_manager_.filename_base());
   const bool r9 = base::DeleteFile(side_effect_free_whitelist_filename,
                                    false);
   if (!r9)
     RecordFailure(FAILURE_SIDE_EFFECT_FREE_WHITELIST_DELETE);
 
   const base::FilePath side_effect_free_whitelist_prefix_set_filename =
       PrefixSetForFilename(side_effect_free_whitelist_filename);
   const bool r10 = base::DeleteFile(
       side_effect_free_whitelist_prefix_set_filename,
       false);
   if (!r10)
     RecordFailure(FAILURE_SIDE_EFFECT_FREE_WHITELIST_PREFIX_SET_DELETE);
 
-  const bool r11 = base::DeleteFile(IpBlacklistDBFilename(filename_base_),
-                                    false);
+  const bool r11 = base::DeleteFile(
+      IpBlacklistDBFilename(db_state_manager_.filename_base()), false);
   if (!r11)
     RecordFailure(FAILURE_IP_BLACKLIST_DELETE);
 
-  const bool r12 =
-      base::DeleteFile(UnwantedSoftwareDBFilename(filename_base_), false);
+  const bool r12 = base::DeleteFile(
+      UnwantedSoftwareDBFilename(db_state_manager_.filename_base()), false);
   if (!r12)
     RecordFailure(FAILURE_UNWANTED_SOFTWARE_PREFIX_SET_DELETE);
 
   return r1 && r2 && r3 && r4 && r5 && r6 && r7 && r8 && r9 && r10 && r11 &&
          r12;
 }
 
 void SafeBrowsingDatabaseNew::WritePrefixSet(const base::FilePath& db_filename,
                                              PrefixSetId prefix_set_id,
                                              FailureType write_failure_type) {
@@ skipping 155 matching lines @@
   else
     NOTREACHED();  // Add support for new lists above.
 
   // Histogram properties as in UMA_HISTOGRAM_COUNTS macro.
   base::HistogramBase* histogram_pointer = base::Histogram::FactoryGet(
       histogram_name, 1, 1000000, 50,
       base::HistogramBase::kUmaTargetedHistogramFlag);
 
   histogram_pointer->Add(file_size_kilobytes);
 }