More explicit thread checking in SafeBrowsingDatabase.

chrome/browser/safe_browsing/safe_browsing_store_file.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_store_file.h"
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/md5.h"
 #include "base/metrics/histogram.h"
@@ skipping 540 matching lines @@
 
   return static_cast<int64>(ftell(file.get())) == size;
 }
 
 }  // namespace
 
 SafeBrowsingStoreFile::SafeBrowsingStoreFile()
     : chunks_written_(0), empty_(false), corruption_seen_(false) {}
 
 SafeBrowsingStoreFile::~SafeBrowsingStoreFile() {
+  // Thread-checking is disabled in the destructor due to crbug.com/338486.
+  DetachFromThread();
+
   Close();
 }
 
 bool SafeBrowsingStoreFile::Delete() {
+  DCHECK(CalledOnValidThread());
+
   // The database should not be open at this point.  But, just in
   // case, close everything before deleting.
   if (!Close()) {
     NOTREACHED();
     return false;
   }
 
   return DeleteStore(filename_);
 }
 
 bool SafeBrowsingStoreFile::CheckValidity() {
+  DCHECK(CalledOnValidThread());
+
   // The file was either empty or never opened.  The empty case is
   // presumed not to be invalid.  The never-opened case can happen if
   // BeginUpdate() fails for any databases, and should already have
   // caused the corruption callback to fire.
   if (!file_.get())
     return true;
 
   if (!FileRewind(file_.get()))
     return OnCorruptDatabase();
 
@@ skipping 27 matching lines @@
   if (!ReadAndVerifyChecksum(file_.get(), &context)) {
     RecordFormatEvent(FORMAT_EVENT_VALIDITY_CHECKSUM_FAILURE);
     return OnCorruptDatabase();
   }
 
   return true;
 }
 
 void SafeBrowsingStoreFile::Init(const base::FilePath& filename,
                                  const base::Closure& corruption_callback) {
+  DCHECK(CalledOnValidThread());
   filename_ = filename;
   corruption_callback_ = corruption_callback;
 }
 
 bool SafeBrowsingStoreFile::BeginChunk() {
+  DCHECK(CalledOnValidThread());
   return ClearChunkBuffers();
 }
 
 bool SafeBrowsingStoreFile::WriteAddPrefix(int32 chunk_id, SBPrefix prefix) {
+  DCHECK(CalledOnValidThread());
   add_prefixes_.push_back(SBAddPrefix(chunk_id, prefix));
   return true;
 }
 
 bool SafeBrowsingStoreFile::GetAddPrefixes(SBAddPrefixes* add_prefixes) {
+  DCHECK(CalledOnValidThread());
+
   add_prefixes->clear();
   if (!base::PathExists(filename_))
     return true;
 
   StateInternal db_state;
   if (!ReadDbStateHelper(filename_, &db_state))
     return OnCorruptDatabase();
 
   add_prefixes->swap(db_state.add_prefixes_);
   return true;
 }
 
 bool SafeBrowsingStoreFile::GetAddFullHashes(
     std::vector<SBAddFullHash>* add_full_hashes) {
+  DCHECK(CalledOnValidThread());
+
   add_full_hashes->clear();
   if (!base::PathExists(filename_))
     return true;
 
   StateInternal db_state;
   if (!ReadDbStateHelper(filename_, &db_state))
     return OnCorruptDatabase();
 
   add_full_hashes->swap(db_state.add_full_hashes_);
   return true;
 }
 
 bool SafeBrowsingStoreFile::WriteAddHash(int32 chunk_id,
                                          const SBFullHash& full_hash) {
+  DCHECK(CalledOnValidThread());
   add_hashes_.push_back(SBAddFullHash(chunk_id, full_hash));
   return true;
 }
 
 bool SafeBrowsingStoreFile::WriteSubPrefix(int32 chunk_id,
                                            int32 add_chunk_id,
                                            SBPrefix prefix) {
+  DCHECK(CalledOnValidThread());
   sub_prefixes_.push_back(SBSubPrefix(chunk_id, add_chunk_id, prefix));
   return true;
 }
 
 bool SafeBrowsingStoreFile::WriteSubHash(int32 chunk_id, int32 add_chunk_id,
                                          const SBFullHash& full_hash) {
+  DCHECK(CalledOnValidThread());
   sub_hashes_.push_back(SBSubFullHash(chunk_id, add_chunk_id, full_hash));
   return true;
 }
 
 bool SafeBrowsingStoreFile::OnCorruptDatabase() {
+  DCHECK(CalledOnValidThread());
+
   if (!corruption_seen_)
     RecordFormatEvent(FORMAT_EVENT_FILE_CORRUPT);
   corruption_seen_ = true;
 
   corruption_callback_.Run();
 
   // Return false as a convenience to callers.
   return false;
 }
 
 bool SafeBrowsingStoreFile::Close() {
+  DCHECK(CalledOnValidThread());
+
   ClearUpdateBuffers();
 
   // Make sure the files are closed.
   file_.reset();
   new_file_.reset();
   return true;
 }
 
 bool SafeBrowsingStoreFile::BeginUpdate() {
+  DCHECK(CalledOnValidThread());
   DCHECK(!file_.get() && !new_file_.get());
 
   // Structures should all be clear unless something bad happened.
   DCHECK(add_chunks_cache_.empty());
   DCHECK(sub_chunks_cache_.empty());
   DCHECK(add_del_cache_.empty());
   DCHECK(sub_del_cache_.empty());
   DCHECK(add_prefixes_.empty());
   DCHECK(sub_prefixes_.empty());
   DCHECK(add_hashes_.empty());
@@ skipping 41 matching lines @@
 
     return OnCorruptDatabase();
   }
 
   file_.swap(file);
   new_file_.swap(new_file);
   return true;
 }
 
 bool SafeBrowsingStoreFile::FinishChunk() {
+  DCHECK(CalledOnValidThread());
+
   if (!add_prefixes_.size() && !sub_prefixes_.size() &&
       !add_hashes_.size() && !sub_hashes_.size())
     return true;
 
   ChunkHeader header;
   header.add_prefix_count = add_prefixes_.size();
   header.sub_prefix_count = sub_prefixes_.size();
   header.add_hash_count = add_hashes_.size();
   header.sub_hash_count = sub_hashes_.size();
   if (!WriteItem(header, new_file_.get(), NULL))
     return false;
 
   if (!WriteContainer(add_prefixes_, new_file_.get(), NULL) ||
       !WriteContainer(sub_prefixes_, new_file_.get(), NULL) ||
       !WriteContainer(add_hashes_, new_file_.get(), NULL) ||
       !WriteContainer(sub_hashes_, new_file_.get(), NULL))
     return false;
 
   ++chunks_written_;
 
   // Clear everything to save memory.
   return ClearChunkBuffers();
 }
 
 bool SafeBrowsingStoreFile::DoUpdate(
     safe_browsing::PrefixSetBuilder* builder,
     std::vector<SBAddFullHash>* add_full_hashes_result) {
+  DCHECK(CalledOnValidThread());
   DCHECK(file_.get() || empty_);
   DCHECK(new_file_.get());
   CHECK(builder);
   CHECK(add_full_hashes_result);
 
   // Rewind the temporary storage.
   if (!FileRewind(new_file_.get()))
     return false;
 
   // Get chunk file's size for validating counts.
@@ skipping 227 matching lines @@
   // Record counts before swapping to caller.
   UMA_HISTOGRAM_COUNTS("SB2.AddPrefixes", add_prefix_count);
   UMA_HISTOGRAM_COUNTS("SB2.SubPrefixes", sub_prefix_count);
 
   return true;
 }
 
 bool SafeBrowsingStoreFile::FinishUpdate(
     safe_browsing::PrefixSetBuilder* builder,
     std::vector<SBAddFullHash>* add_full_hashes_result) {
+  DCHECK(CalledOnValidThread());
   DCHECK(builder);
   DCHECK(add_full_hashes_result);
 
   if (!DoUpdate(builder, add_full_hashes_result)) {
     CancelUpdate();
     return false;
   }
 
   DCHECK(!new_file_.get());
   DCHECK(!file_.get());
 
   return Close();
 }
 
 bool SafeBrowsingStoreFile::CancelUpdate() {
+  DCHECK(CalledOnValidThread());
   bool ret = Close();
 
   // Delete stale staging file.
   const base::FilePath new_filename = TemporaryFileForFilename(filename_);
   base::DeleteFile(new_filename, false);
 
   return ret;
 }
 
 void SafeBrowsingStoreFile::SetAddChunk(int32 chunk_id) {
+  DCHECK(CalledOnValidThread());
   add_chunks_cache_.insert(chunk_id);
 }
 
 bool SafeBrowsingStoreFile::CheckAddChunk(int32 chunk_id) {
+  DCHECK(CalledOnValidThread());
   return add_chunks_cache_.count(chunk_id) > 0;
 }
 
 void SafeBrowsingStoreFile::GetAddChunks(std::vector<int32>* out) {
+  DCHECK(CalledOnValidThread());
   out->clear();
   out->insert(out->end(), add_chunks_cache_.begin(), add_chunks_cache_.end());
 }
 
 void SafeBrowsingStoreFile::SetSubChunk(int32 chunk_id) {
+  DCHECK(CalledOnValidThread());
   sub_chunks_cache_.insert(chunk_id);
 }
 
 bool SafeBrowsingStoreFile::CheckSubChunk(int32 chunk_id) {
+  DCHECK(CalledOnValidThread());
   return sub_chunks_cache_.count(chunk_id) > 0;
 }
 
 void SafeBrowsingStoreFile::GetSubChunks(std::vector<int32>* out) {
+  DCHECK(CalledOnValidThread());
   out->clear();
   out->insert(out->end(), sub_chunks_cache_.begin(), sub_chunks_cache_.end());
 }
 
 void SafeBrowsingStoreFile::DeleteAddChunk(int32 chunk_id) {
+  DCHECK(CalledOnValidThread());
   add_del_cache_.insert(chunk_id);
 }
 
 void SafeBrowsingStoreFile::DeleteSubChunk(int32 chunk_id) {
+  DCHECK(CalledOnValidThread());
   sub_del_cache_.insert(chunk_id);
 }
 
 // static
 bool SafeBrowsingStoreFile::DeleteStore(const base::FilePath& basename) {
   if (!base::DeleteFile(basename, false) &&
       base::PathExists(basename)) {
     NOTREACHED();
     return false;
   }
 
   const base::FilePath new_filename = TemporaryFileForFilename(basename);
   if (!base::DeleteFile(new_filename, false) &&
       base::PathExists(new_filename)) {
     NOTREACHED();
     return false;
   }
 
   // With SQLite support gone, one way to get to this code is if the
   // existing file is a SQLite file.  Make sure the journal file is
   // also removed.
   const base::FilePath journal_filename(
       basename.value() + FILE_PATH_LITERAL("-journal"));
   if (base::PathExists(journal_filename))
     base::DeleteFile(journal_filename, false);
 
   return true;
 }