Deprecate NonThreadSafe in storage/browser/quota in favor of SequenceChecker.

storage/browser/quota/quota_temporary_storage_evictor.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 "storage/browser/quota/quota_temporary_storage_evictor.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
@@ skipping 38 matching lines @@
     QuotaEvictionHandler* quota_eviction_handler,
     int64_t interval_ms)
     : quota_eviction_handler_(quota_eviction_handler),
       interval_ms_(interval_ms),
       timer_disabled_for_testing_(false),
       weak_factory_(this) {
   DCHECK(quota_eviction_handler);
 }
 
 QuotaTemporaryStorageEvictor::~QuotaTemporaryStorageEvictor() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 void QuotaTemporaryStorageEvictor::GetStatistics(
     std::map<std::string, int64_t>* statistics) {
   DCHECK(statistics);
 
   (*statistics)["errors-on-evicting-origin"] =
       statistics_.num_errors_on_evicting_origin;
   (*statistics)["errors-on-getting-usage-and-quota"] =
       statistics_.num_errors_on_getting_usage_and_quota;
@@ skipping 59 matching lines @@
     ReportPerRoundHistogram();
     time_of_end_of_last_nonskipped_round_ = base::Time::Now();
   } else {
     ++statistics_.num_skipped_eviction_rounds;
   }
   // Reset stats for next round.
   round_statistics_ = EvictionRoundStatistics();
 }
 
 void QuotaTemporaryStorageEvictor::Start() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   base::AutoReset<bool> auto_reset(&timer_disabled_for_testing_, false);
   StartEvictionTimerWithDelay(0);
 
   if (histogram_timer_.IsRunning())
     return;
 
   histogram_timer_.Start(
       FROM_HERE, base::TimeDelta::FromMinutes(kHistogramReportIntervalMinutes),
       this, &QuotaTemporaryStorageEvictor::ReportPerHourHistogram);
@@ skipping 72 matching lines @@
   } else {
     // TODO(dmikurube): Add error handling for the case status is not OK.
     // TODO(dmikurube): Try restarting eviction after a while.
     LOG(WARNING) << "Stopped eviction of temporary storage due to errors";
   }
 
   OnEvictionRoundFinished();
 }
 
 void QuotaTemporaryStorageEvictor::OnGotEvictionOrigin(const GURL& origin) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (origin.is_empty()) {
     StartEvictionTimerWithDelay(interval_ms_);
     OnEvictionRoundFinished();
     return;
   }
 
   in_progress_eviction_origins_.insert(origin);
 
   quota_eviction_handler_->EvictOriginData(origin, kStorageTypeTemporary,
       base::Bind(
           &QuotaTemporaryStorageEvictor::OnEvictionComplete,
           weak_factory_.GetWeakPtr()));
 }
 
 void QuotaTemporaryStorageEvictor::OnEvictionComplete(
     QuotaStatusCode status) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Just calling ConsiderEviction() or StartEvictionTimerWithDelay() here is
   // ok.  No need to deal with the case that all of the Delete operations fail
   // for a certain origin.  It doesn't result in trying to evict the same
   // origin permanently.  The evictor skips origins which had deletion errors
   // a few times.
 
   if (status == kQuotaStatusOk) {
     ++statistics_.num_evicted_origins;
     ++round_statistics_.num_evicted_origins_in_round;
     // We many need to get rid of more space so reconsider immediately.
     ConsiderEviction();
   } else {
     ++statistics_.num_errors_on_evicting_origin;
     // Sleep for a while and retry again until we see too many errors.
     StartEvictionTimerWithDelay(interval_ms_);
     OnEvictionRoundFinished();
   }
 }
 
 }  // namespace storage