Replace deprecated base::NonThreadSafe in extensions in favor of SequenceChecker.

extensions/browser/quota_service.cc

 // Copyright 2013 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 "extensions/browser/quota_service.h"
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "extensions/browser/extension_function.h"
 #include "extensions/common/error_utils.h"
 
@@ skipping 15 matching lines @@
 QuotaService::QuotaService() {
   if (!g_purge_disabled_for_testing && base::ThreadTaskRunnerHandle::IsSet()) {
     purge_timer_.Start(FROM_HERE,
                        base::TimeDelta::FromDays(kPurgeIntervalInDays),
                        this,
                        &QuotaService::Purge);
   }
 }
 
 QuotaService::~QuotaService() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   purge_timer_.Stop();
   Purge();
 }
 
 std::string QuotaService::Assess(const std::string& extension_id,
                                  ExtensionFunction* function,
                                  const base::ListValue* args,
                                  const base::TimeTicks& event_time) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (function->ShouldSkipQuotaLimiting())
     return std::string();
 
   // Lookup function list for extension.
   FunctionHeuristicsMap& functions = function_heuristics_[extension_id];
 
   // Lookup heuristics for function, create if necessary.
   QuotaLimitHeuristics& heuristics = functions[function->name()];
   if (heuristics.empty())
@@ skipping 23 matching lines @@
   DCHECK(!g_purge_disabled_for_testing);
   g_purge_disabled_for_testing = true;
 }
 
 QuotaService::ScopedDisablePurgeForTesting::~ScopedDisablePurgeForTesting() {
   DCHECK(g_purge_disabled_for_testing);
   g_purge_disabled_for_testing = false;
 }
 
 void QuotaService::Purge() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   for (auto it = function_heuristics_.begin(); it != function_heuristics_.end();
        function_heuristics_.erase(it++)) {
     it->second.clear();
   }
 }
 
 void QuotaLimitHeuristic::Bucket::Reset(const Config& config,
                                         const base::TimeTicks& start) {
   num_tokens_ = config.refill_token_count;
   expiration_ = start + config.refill_interval;
@@ skipping 31 matching lines @@
 
 bool QuotaService::TimedLimit::Apply(Bucket* bucket,
                                      const base::TimeTicks& event_time) {
   if (event_time > bucket->expiration())
     bucket->Reset(config(), event_time);
 
   return bucket->DeductToken();
 }
 
 }  // namespace extensions