chrome: Use base::MessageLoop. (Part 3)

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 420 matching lines @@
   return NULL;
 }
 
 // static
 void SafeBrowsingDatabase::RecordFailure(FailureType failure_type) {
   UMA_HISTOGRAM_ENUMERATION("SB2.DatabaseFailure", failure_type,
                             FAILURE_DATABASE_MAX);
 }
 
 SafeBrowsingDatabaseNew::SafeBrowsingDatabaseNew()
-    : creation_loop_(MessageLoop::current()),
+    : creation_loop_(base::MessageLoop::current()),
       browse_store_(new SafeBrowsingStoreFile),
       download_store_(NULL),
       csd_whitelist_store_(NULL),
       download_whitelist_store_(NULL),
       reset_factory_(this),
       corruption_detected_(false),
       change_detected_(false) {
   DCHECK(browse_store_.get());
   DCHECK(!download_store_.get());
   DCHECK(!csd_whitelist_store_.get());
   DCHECK(!download_whitelist_store_.get());
   DCHECK(!extension_blacklist_store_.get());
   DCHECK(!side_effect_free_whitelist_store_.get());
 }
 
 SafeBrowsingDatabaseNew::SafeBrowsingDatabaseNew(
     SafeBrowsingStore* browse_store,
     SafeBrowsingStore* download_store,
     SafeBrowsingStore* csd_whitelist_store,
     SafeBrowsingStore* download_whitelist_store,
     SafeBrowsingStore* extension_blacklist_store,
     SafeBrowsingStore* side_effect_free_whitelist_store)
-    : creation_loop_(MessageLoop::current()),
+    : creation_loop_(base::MessageLoop::current()),
       browse_store_(browse_store),
       download_store_(download_store),
       csd_whitelist_store_(csd_whitelist_store),
       download_whitelist_store_(download_whitelist_store),
       extension_blacklist_store_(extension_blacklist_store),
       side_effect_free_whitelist_store_(side_effect_free_whitelist_store),
       reset_factory_(this),
       corruption_detected_(false) {
   DCHECK(browse_store_.get());
 }
 
 SafeBrowsingDatabaseNew::~SafeBrowsingDatabaseNew() {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
 }
 
 void SafeBrowsingDatabaseNew::Init(const base::FilePath& filename_base) {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
   // Ensure we haven't been run before.
   DCHECK(browse_filename_.empty());
   DCHECK(download_filename_.empty());
   DCHECK(csd_whitelist_filename_.empty());
   DCHECK(download_whitelist_filename_.empty());
   DCHECK(extension_blacklist_filename_.empty());
   DCHECK(side_effect_free_whitelist_filename_.empty());
 
   browse_filename_ = BrowseDBFilename(filename_base);
   browse_prefix_set_filename_ = PrefixSetForFilename(browse_filename_);
@@ skipping 99 matching lines @@
     }
   } 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));
   }
 }
 
 bool SafeBrowsingDatabaseNew::ResetDatabase() {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
 
   // Delete files on disk.
   // TODO(shess): Hard to see where one might want to delete without a
   // reset.  Perhaps inline |Delete()|?
   if (!Delete())
     return false;
 
   // Reset objects in memory.
   {
     base::AutoLock locked(lookup_lock_);
@@ skipping 59 matching lines @@
   GetCachedFullHashesForBrowse(*prefix_hits, full_browse_hashes_,
                                full_hits, last_update);
   GetCachedFullHashesForBrowse(*prefix_hits, pending_browse_hashes_,
                                full_hits, last_update);
   return true;
 }
 
 bool SafeBrowsingDatabaseNew::ContainsDownloadUrl(
     const std::vector<GURL>& urls,
     std::vector<SBPrefix>* prefix_hits) {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
 
   // Ignore this check when download checking is not enabled.
   if (!download_store_.get())
     return false;
 
   std::vector<SBPrefix> prefixes;
   GetDownloadUrlPrefixes(urls, &prefixes);
   return MatchAddPrefixes(download_store_.get(),
                           safe_browsing_util::BINURL % 2,
                           prefixes,
                           prefix_hits);
 }
 
 bool SafeBrowsingDatabaseNew::ContainsDownloadHashPrefix(
     const SBPrefix& prefix) {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
 
   // Ignore this check when download store is not available.
   if (!download_store_.get())
     return false;
 
   std::vector<SBPrefix> prefix_hits;
   return MatchAddPrefixes(download_store_.get(),
                           safe_browsing_util::BINHASH % 2,
                           std::vector<SBPrefix>(1, prefix),
                           &prefix_hits);
@@ skipping 10 matching lines @@
 
 bool SafeBrowsingDatabaseNew::ContainsDownloadWhitelistedUrl(const GURL& url) {
   std::vector<SBFullHash> full_hashes;
   BrowseFullHashesToCheck(url, true, &full_hashes);
   return ContainsWhitelistedHashes(download_whitelist_, full_hashes);
 }
 
 bool SafeBrowsingDatabaseNew::ContainsExtensionPrefixes(
     const std::vector<SBPrefix>& prefixes,
     std::vector<SBPrefix>* prefix_hits) {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
   if (!extension_blacklist_store_)
     return false;
 
   return MatchAddPrefixes(extension_blacklist_store_.get(),
                           safe_browsing_util::EXTENSIONBLACKLIST % 2,
                           prefixes,
                           prefix_hits);
 }
 
 bool SafeBrowsingDatabaseNew::ContainsSideEffectFreeWhitelistUrl(
@@ skipping 40 matching lines @@
     if (std::binary_search(whitelist.first.begin(), whitelist.first.end(), *it))
       return true;
   }
   return false;
 }
 
 // Helper to insert entries for all of the prefixes or full hashes in
 // |entry| into the store.
 void SafeBrowsingDatabaseNew::InsertAdd(int chunk_id, SBPrefix host,
                                         const SBEntry* entry, int list_id) {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
 
   SafeBrowsingStore* store = GetStore(list_id);
   if (!store) return;
 
   STATS_COUNTER("SB.HostInsert", 1);
   const int encoded_chunk_id = EncodeChunkId(chunk_id, list_id);
   const int count = entry->prefix_count();
 
   DCHECK(!entry->IsSub());
   if (!count) {
@@ skipping 21 matching lines @@
       store->WriteAddHash(encoded_chunk_id, receive_time, full_hash);
     }
   }
 }
 
 // Helper to iterate over all the entries in the hosts in |chunks| and
 // add them to the store.
 void SafeBrowsingDatabaseNew::InsertAddChunks(
     const safe_browsing_util::ListType list_id,
     const SBChunkList& chunks) {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
 
   SafeBrowsingStore* store = GetStore(list_id);
   if (!store) return;
 
   for (SBChunkList::const_iterator citer = chunks.begin();
        citer != chunks.end(); ++citer) {
     const int chunk_id = citer->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.
     const int encoded_chunk_id = EncodeChunkId(chunk_id, list_id);
     if (store->CheckAddChunk(encoded_chunk_id))
       continue;
 
     store->SetAddChunk(encoded_chunk_id);
     for (std::deque<SBChunkHost>::const_iterator hiter = citer->hosts.begin();
          hiter != citer->hosts.end(); ++hiter) {
       // NOTE: Could pass |encoded_chunk_id|, but then inserting add
       // chunks would look different from inserting sub chunks.
       InsertAdd(chunk_id, hiter->host, hiter->entry, list_id);
     }
   }
 }
 
 // Helper to insert entries for all of the prefixes or full hashes in
 // |entry| into the store.
 void SafeBrowsingDatabaseNew::InsertSub(int chunk_id, SBPrefix host,
                                         const SBEntry* entry, int list_id) {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
 
   SafeBrowsingStore* store = GetStore(list_id);
   if (!store) return;
 
   STATS_COUNTER("SB.HostDelete", 1);
   const int encoded_chunk_id = EncodeChunkId(chunk_id, list_id);
   const int count = entry->prefix_count();
 
   DCHECK(entry->IsSub());
   if (!count) {
@@ skipping 25 matching lines @@
       store->WriteSubHash(encoded_chunk_id, add_chunk_id, full_hash);
     }
   }
 }
 
 // Helper to iterate over all the entries in the hosts in |chunks| and
 // add them to the store.
 void SafeBrowsingDatabaseNew::InsertSubChunks(
     safe_browsing_util::ListType list_id,
     const SBChunkList& chunks) {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
 
   SafeBrowsingStore* store = GetStore(list_id);
   if (!store) return;
 
   for (SBChunkList::const_iterator citer = chunks.begin();
        citer != chunks.end(); ++citer) {
     const int chunk_id = citer->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.
     const int encoded_chunk_id = EncodeChunkId(chunk_id, list_id);
     if (store->CheckSubChunk(encoded_chunk_id))
       continue;
 
     store->SetSubChunk(encoded_chunk_id);
     for (std::deque<SBChunkHost>::const_iterator hiter = citer->hosts.begin();
          hiter != citer->hosts.end(); ++hiter) {
       InsertSub(chunk_id, hiter->host, hiter->entry, list_id);
     }
   }
 }
 
 void SafeBrowsingDatabaseNew::InsertChunks(const std::string& list_name,
                                            const SBChunkList& chunks) {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
 
   if (corruption_detected_ || chunks.empty())
     return;
 
   const base::TimeTicks before = base::TimeTicks::Now();
 
   const safe_browsing_util::ListType list_id =
       safe_browsing_util::GetListId(list_name);
   DVLOG(2) << list_name << ": " << list_id;
 
   SafeBrowsingStore* store = GetStore(list_id);
   if (!store) return;
 
   change_detected_ = true;
 
   store->BeginChunk();
   if (chunks.front().is_add) {
     InsertAddChunks(list_id, chunks);
   } else {
     InsertSubChunks(list_id, chunks);
   }
   store->FinishChunk();
 
   UMA_HISTOGRAM_TIMES("SB2.ChunkInsert", base::TimeTicks::Now() - before);
 }
 
 void SafeBrowsingDatabaseNew::DeleteChunks(
     const std::vector<SBChunkDelete>& chunk_deletes) {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
 
   if (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;
@@ skipping 43 matching lines @@
   std::vector<SBAddFullHash>::iterator
       orig_end = pending_browse_hashes_.begin() + orig_size;
   std::sort(orig_end, pending_browse_hashes_.end(), SBAddFullHashPrefixLess);
   std::inplace_merge(pending_browse_hashes_.begin(),
                      orig_end, pending_browse_hashes_.end(),
                      SBAddFullHashPrefixLess);
 }
 
 bool SafeBrowsingDatabaseNew::UpdateStarted(
     std::vector<SBListChunkRanges>* lists) {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
   DCHECK(lists);
 
   // If |BeginUpdate()| fails, reset the database.
   if (!browse_store_->BeginUpdate()) {
     RecordFailure(FAILURE_BROWSE_DATABASE_UPDATE_BEGIN);
     HandleCorruptDatabase();
     return false;
   }
 
   if (download_store_.get() && !download_store_->BeginUpdate()) {
@@ skipping 91 matching lines @@
             1, safe_browsing_util::kSideEffectFreeWhitelist),
         lists);
   }
 
   corruption_detected_ = false;
   change_detected_ = false;
   return true;
 }
 
 void SafeBrowsingDatabaseNew::UpdateFinished(bool update_succeeded) {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
 
   // 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
   // sections would allow throwing a corruption error in
   // UpdateStarted().
   if (!update_succeeded) {
     if (!browse_store_->CheckValidity())
       DLOG(ERROR) << "Safe-browsing browse database corrupt.";
@@ skipping 307 matching lines @@
   base::mac::SetFileBackupExclusion(
       side_effect_free_whitelist_prefix_set_filename_);
 #endif
 }
 
 void SafeBrowsingDatabaseNew::HandleCorruptDatabase() {
   // 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);
-    MessageLoop::current()->PostTask(FROM_HERE,
+    base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&SafeBrowsingDatabaseNew::OnHandleCorruptDatabase,
                    reset_factory_.GetWeakPtr()));
   }
 }
 
 void SafeBrowsingDatabaseNew::OnHandleCorruptDatabase() {
   RecordFailure(FAILURE_DATABASE_CORRUPT_HANDLER);
   corruption_detected_ = true;  // Stop updating the database.
   ResetDatabase();
   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() {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
   DCHECK(!browse_prefix_set_filename_.empty());
 
   // If there is no database, the filter cannot be used.
   base::PlatformFileInfo db_info;
   if (!file_util::GetFileInfo(browse_filename_, &db_info) || db_info.size == 0)
     return;
 
   // Cleanup any stale bloom filter (no longer used).
   // TODO(shess): Track failure to delete?
   base::FilePath bloom_filter_filename =
       BloomFilterForFilename(browse_filename_);
   file_util::Delete(bloom_filter_filename, false);
 
   const base::TimeTicks before = base::TimeTicks::Now();
   browse_prefix_set_.reset(safe_browsing::PrefixSet::LoadFile(
       browse_prefix_set_filename_));
   DVLOG(1) << "SafeBrowsingDatabaseNew read prefix set in "
            << (base::TimeTicks::Now() - before).InMilliseconds() << " ms";
   UMA_HISTOGRAM_TIMES("SB2.PrefixSetLoad", base::TimeTicks::Now() - before);
 
   if (!browse_prefix_set_.get())
     RecordFailure(FAILURE_BROWSE_PREFIX_SET_READ);
 }
 
 bool SafeBrowsingDatabaseNew::Delete() {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
 
   const bool r1 = browse_store_->Delete();
   if (!r1)
     RecordFailure(FAILURE_DATABASE_STORE_DELETE);
 
   const bool r2 = download_store_.get() ? download_store_->Delete() : true;
   if (!r2)
     RecordFailure(FAILURE_DATABASE_STORE_DELETE);
 
   const bool r3 = csd_whitelist_store_.get() ?
@@ skipping 28 matching lines @@
   const bool r9 = file_util::Delete(
       side_effect_free_whitelist_prefix_set_filename_,
       false);
   if (!r9)
     RecordFailure(FAILURE_SIDE_EFFECT_FREE_WHITELIST_PREFIX_SET_DELETE);
 
   return r1 && r2 && r3 && r4 && r5 && r6 && r7 && r8 && r9;
 }
 
 void SafeBrowsingDatabaseNew::WritePrefixSet() {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
 
   if (!browse_prefix_set_.get())
     return;
 
   const base::TimeTicks before = base::TimeTicks::Now();
   const bool write_ok = browse_prefix_set_->WriteFile(
       browse_prefix_set_filename_);
   DVLOG(1) << "SafeBrowsingDatabaseNew wrote prefix set in "
            << (base::TimeTicks::Now() - before).InMilliseconds() << " ms";
   UMA_HISTOGRAM_TIMES("SB2.PrefixSetWrite", base::TimeTicks::Now() - before);
 
   if (!write_ok)
     RecordFailure(FAILURE_BROWSE_PREFIX_SET_WRITE);
 
 #if defined(OS_MACOSX)
   base::mac::SetFileBackupExclusion(browse_prefix_set_filename_);
 #endif
 }
 
 void SafeBrowsingDatabaseNew::WhitelistEverything(SBWhitelist* whitelist) {
   base::AutoLock locked(lookup_lock_);
   whitelist->second = true;
   whitelist->first.clear();
 }
 
 void SafeBrowsingDatabaseNew::LoadWhitelist(
     const std::vector<SBAddFullHash>& full_hashes,
     SBWhitelist* whitelist) {
-  DCHECK_EQ(creation_loop_, MessageLoop::current());
+  DCHECK_EQ(creation_loop_, base::MessageLoop::current());
   if (full_hashes.size() > kMaxWhitelistSize) {
     WhitelistEverything(whitelist);
     return;
   }
 
   std::vector<SBFullHash> new_whitelist;
   new_whitelist.reserve(full_hashes.size());
   for (std::vector<SBAddFullHash>::const_iterator it = full_hashes.begin();
        it != full_hashes.end(); ++it) {
     new_whitelist.push_back(it->full_hash);
   }
   std::sort(new_whitelist.begin(), new_whitelist.end());
 
   SBFullHash kill_switch;
   crypto::SHA256HashString(kWhitelistKillSwitchUrl, &kill_switch,
                            sizeof(kill_switch));
   if (std::binary_search(new_whitelist.begin(), new_whitelist.end(),
                          kill_switch)) {
     // The kill switch is whitelisted hence we whitelist all URLs.
     WhitelistEverything(whitelist);
   } else {
     base::AutoLock locked(lookup_lock_);
     whitelist->second = false;
     whitelist->first.swap(new_whitelist);
   }
 }