Rename TaskRunner::RunsTasksOnCurrentThread() in //components

components/safe_browsing_db/v4_store.cc

 // Copyright 2016 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 "base/base64.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 190 matching lines @@
 
 V4Store::V4Store(const scoped_refptr<base::SequencedTaskRunner>& task_runner,
                  const base::FilePath& store_path,
                  const int64_t old_file_size)
     : file_size_(old_file_size),
       has_valid_data_(false),
       store_path_(store_path),
       task_runner_(task_runner) {}
 
 V4Store::~V4Store() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 }
 
 std::string V4Store::DebugString() const {
   std::string state_base64;
   base::Base64Encode(state_, &state_base64);
 
   return base::StringPrintf("path: %" PRIsFP "; state: %s",
                             store_path_.value().c_str(), state_base64.c_str());
 }
 
@@ skipping 304 matching lines @@
 
     (*prefix_map_to_update)[prefix_size].reserve(existing_capacity +
                                                  prefix_length_to_add);
   }
 }
 
 ApplyUpdateResult V4Store::MergeUpdate(const HashPrefixMap& old_prefixes_map,
                                        const HashPrefixMap& additions_map,
                                        const RepeatedField<int32>* raw_removals,
                                        const std::string& expected_checksum) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(hash_prefix_map_.empty());
 
   bool calculate_checksum = !expected_checksum.empty();
   if (calculate_checksum &&
       (expected_checksum.size() != crypto::kSHA256Length)) {
     return CHECKSUM_MISMATCH_FAILURE;
   }
 
   hash_prefix_map_.clear();
   ReserveSpaceInPrefixMap(old_prefixes_map, &hash_prefix_map_);
@@ skipping 111 matching lines @@
 #endif
         return CHECKSUM_MISMATCH_FAILURE;
       }
     }
   }
 
   return APPLY_UPDATE_SUCCESS;
 }
 
 StoreReadResult V4Store::ReadFromDisk() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   V4StoreFileFormat file_format;
   int64_t file_size;
   TimeTicks before = TimeTicks::Now();
   {
     // A temporary scope to make sure that |contents| get destroyed as soon as
     // we are doing using it.
     std::string contents;
     bool read_success = base::ReadFileToString(store_path_, &contents);
     if (!read_success) {
@@ skipping 115 matching lines @@
   if (result == 0) {
     return true;
   } else if (result < 0) {
     return HashPrefixMatches(hash_prefix, begin, mid);
   } else {
     return HashPrefixMatches(hash_prefix, mid + prefix_size, end);
   }
 }
 
 bool V4Store::VerifyChecksum() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   if (expected_checksum_.empty()) {
     // Nothing to check here folks!
     // TODO(vakh): Do not allow empty checksums.
     return true;
   }
 
   IteratorMap iterator_map;
   HashPrefix next_smallest_prefix;
   InitializeIteratorMap(hash_prefix_map_, &iterator_map);
@@ skipping 46 matching lines @@
       base_metric + suffix, 1, 1000000, 50,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   if (histogram) {
     const int64_t file_size_kilobytes = file_size_ / 1024;
     histogram->Add(file_size_kilobytes);
   }
   return file_size_;
 }
 
 }  // namespace safe_browsing