Deprecate NonThreadSafe in net/ in favor of SequenceChecker/ThreadChecker.

net/http/http_server_properties_impl.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 "net/http/http_server_properties_impl.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 28 matching lines @@
       quic_server_info_map_(QuicServerInfoMap::NO_AUTO_EVICT),
       max_server_configs_stored_in_properties_(kMaxQuicServersToPersist),
       weak_ptr_factory_(this) {
   canonical_suffixes_.push_back(".ggpht.com");
   canonical_suffixes_.push_back(".c.youtube.com");
   canonical_suffixes_.push_back(".googlevideo.com");
   canonical_suffixes_.push_back(".googleusercontent.com");
 }
 
 HttpServerPropertiesImpl::~HttpServerPropertiesImpl() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 void HttpServerPropertiesImpl::SetSpdyServers(
     std::vector<std::string>* spdy_servers,
     bool support_spdy) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!spdy_servers)
     return;
 
   // Add the entries from persisted data.
   SpdyServersMap spdy_servers_map(SpdyServersMap::NO_AUTO_EVICT);
   for (std::vector<std::string>::reverse_iterator it = spdy_servers->rbegin();
        it != spdy_servers->rend(); ++it) {
     spdy_servers_map.Put(*it, support_spdy);
   }
 
@@ skipping 117 matching lines @@
        it != temp_map.rend(); ++it) {
     if (quic_server_info_map_.Get(it->first) == quic_server_info_map_.end()) {
       quic_server_info_map_.Put(it->first, it->second);
     }
   }
 }
 
 void HttpServerPropertiesImpl::GetSpdyServerList(
     base::ListValue* spdy_server_list,
     size_t max_size) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(spdy_server_list);
   spdy_server_list->Clear();
   size_t count = 0;
   // Get the list of servers (scheme/host/port) that support SPDY.
   for (SpdyServersMap::const_iterator it = spdy_servers_map_.begin();
        it != spdy_servers_map_.end() && count < max_size; ++it) {
     const std::string spdy_server = it->first;
     if (it->second) {
       spdy_server_list->AppendString(spdy_server);
       ++count;
     }
   }
 }
 
 void HttpServerPropertiesImpl::Clear() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   spdy_servers_map_.Clear();
   alternative_service_map_.Clear();
   canonical_host_to_origin_map_.clear();
   last_quic_address_ = IPAddress();
   server_network_stats_map_.Clear();
   quic_server_info_map_.Clear();
 }
 
 bool HttpServerPropertiesImpl::SupportsRequestPriority(
     const url::SchemeHostPort& server) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (server.host().empty())
     return false;
 
   if (GetSupportsSpdy(server))
     return true;
   const AlternativeServiceInfoVector alternative_service_info_vector =
       GetAlternativeServiceInfos(server);
   for (const AlternativeServiceInfo& alternative_service_info :
        alternative_service_info_vector) {
     if (alternative_service_info.alternative_service.protocol == kProtoQUIC) {
       return true;
     }
   }
   return false;
 }
 
 bool HttpServerPropertiesImpl::GetSupportsSpdy(
     const url::SchemeHostPort& server) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (server.host().empty())
     return false;
 
   SpdyServersMap::iterator spdy_server =
       spdy_servers_map_.Get(server.Serialize());
   return spdy_server != spdy_servers_map_.end() && spdy_server->second;
 }
 
 void HttpServerPropertiesImpl::SetSupportsSpdy(
     const url::SchemeHostPort& server,
     bool support_spdy) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (server.host().empty())
     return;
 
   SpdyServersMap::iterator spdy_server =
       spdy_servers_map_.Get(server.Serialize());
   if ((spdy_server != spdy_servers_map_.end()) &&
       (spdy_server->second == support_spdy)) {
     return;
   }
   // Cache the data.
   spdy_servers_map_.Put(server.Serialize(), support_spdy);
 }
 
 bool HttpServerPropertiesImpl::RequiresHTTP11(
     const HostPortPair& host_port_pair) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (host_port_pair.host().empty())
     return false;
 
   return (http11_servers_.find(host_port_pair) != http11_servers_.end());
 }
 
 void HttpServerPropertiesImpl::SetHTTP11Required(
     const HostPortPair& host_port_pair) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (host_port_pair.host().empty())
     return;
 
   http11_servers_.insert(host_port_pair);
 }
 
 void HttpServerPropertiesImpl::MaybeForceHTTP11(const HostPortPair& server,
                                                 SSLConfig* ssl_config) {
   if (RequiresHTTP11(server)) {
     ForceHTTP11(ssl_config);
@@ skipping 481 matching lines @@
   base::TimeDelta delay = when > now ? when - now : base::TimeDelta();
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesImpl::ExpireBrokenAlternateProtocolMappings,
           weak_ptr_factory_.GetWeakPtr()),
       delay);
 }
 
 }  // namespace net