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

storage/browser/quota/client_usage_tracker.cc

 // Copyright 2014 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/client_usage_tracker.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/stl_util.h"
@@ skipping 58 matching lines @@
       global_unlimited_usage_(0),
       global_usage_retrieved_(false),
       special_storage_policy_(special_storage_policy) {
   DCHECK(tracker_);
   DCHECK(client_);
   if (special_storage_policy_.get())
     special_storage_policy_->AddObserver(this);
 }
 
 ClientUsageTracker::~ClientUsageTracker() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (special_storage_policy_.get())
     special_storage_policy_->RemoveObserver(this);
 }
 
 void ClientUsageTracker::GetGlobalLimitedUsage(const UsageCallback& callback) {
   if (!global_usage_retrieved_) {
     GetGlobalUsage(base::Bind(&DidGetGlobalUsageForLimitedGlobalUsage,
                               callback));
     return;
   }
@@ skipping 327 matching lines @@
     const GURL& origin) const {
   std::string host = net::GetHostOrSpecFromURL(origin);
   return !OriginSetContainsOrigin(non_cached_limited_origins_by_host_,
                                   host, origin) &&
       !OriginSetContainsOrigin(non_cached_unlimited_origins_by_host_,
                                host, origin);
 }
 
 void ClientUsageTracker::OnGranted(const GURL& origin,
                                    int change_flags) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (change_flags & SpecialStoragePolicy::STORAGE_UNLIMITED) {
     int64_t usage = 0;
     if (GetCachedOriginUsage(origin, &usage)) {
       global_unlimited_usage_ += usage;
       global_limited_usage_ -= usage;
     }
 
     std::string host = net::GetHostOrSpecFromURL(origin);
     if (EraseOriginFromOriginSet(&non_cached_limited_origins_by_host_,
                                  host, origin))
       non_cached_unlimited_origins_by_host_[host].insert(origin);
   }
 }
 
 void ClientUsageTracker::OnRevoked(const GURL& origin,
                                    int change_flags) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (change_flags & SpecialStoragePolicy::STORAGE_UNLIMITED) {
     int64_t usage = 0;
     if (GetCachedOriginUsage(origin, &usage)) {
       global_unlimited_usage_ -= usage;
       global_limited_usage_ += usage;
     }
 
     std::string host = net::GetHostOrSpecFromURL(origin);
     if (EraseOriginFromOriginSet(&non_cached_unlimited_origins_by_host_,
                                  host, origin))
       non_cached_limited_origins_by_host_[host].insert(origin);
   }
 }
 
 void ClientUsageTracker::OnCleared() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   global_limited_usage_ += global_unlimited_usage_;
   global_unlimited_usage_ = 0;
 
   for (const auto& host_and_origins : non_cached_unlimited_origins_by_host_) {
     const auto& host = host_and_origins.first;
     for (const auto& origin : host_and_origins.second)
       non_cached_limited_origins_by_host_[host].insert(origin);
   }
   non_cached_unlimited_origins_by_host_.clear();
 }
 
 bool ClientUsageTracker::IsStorageUnlimited(const GURL& origin) const {
   if (type_ == kStorageTypeSyncable)
     return false;
   return special_storage_policy_.get() &&
          special_storage_policy_->IsStorageUnlimited(origin);
 }
 
 }  // namespace storage