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

net/http/transport_security_state.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/transport_security_state.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 #include <vector>
@@ skipping 731 matching lines @@
       enable_static_expect_ct_(true),
       enable_static_expect_staple_(true),
       enable_pkp_bypass_for_local_trust_anchors_(true),
       sent_reports_cache_(kMaxHPKPReportCacheEntries) {
 // Static pinning is only enabled for official builds to make sure that
 // others don't end up with pins that cannot be easily updated.
 #if !defined(GOOGLE_CHROME_BUILD) || defined(OS_ANDROID) || defined(OS_IOS)
   enable_static_pins_ = false;
   enable_static_expect_ct_ = false;
 #endif
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 // Both HSTS and HPKP cause fatal SSL errors, so return true if a
 // host has either.
 bool TransportSecurityState::ShouldSSLErrorsBeFatal(const std::string& host) {
   STSState sts_state;
   PKPState pkp_state;
   if (GetStaticDomainState(host, &sts_state, &pkp_state))
     return true;
   if (GetDynamicSTSState(host, &sts_state))
@@ skipping 41 matching lines @@
 
   UMA_HISTOGRAM_BOOLEAN("Net.PublicKeyPinSuccess",
                         pin_validity == PKPStatus::OK);
   return pin_validity;
 }
 
 void TransportSecurityState::CheckExpectStaple(
     const HostPortPair& host_port_pair,
     const SSLInfo& ssl_info,
     base::StringPiece ocsp_response) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!enable_static_expect_staple_ || !report_sender_ ||
       !ssl_info.is_issued_by_known_root) {
     return;
   }
 
   // Determine if the host is on the Expect-Staple preload list. If the build is
   // not timely (i.e. the preload list is not fresh), this will fail and return
   // false.
   ExpectStapleState expect_staple_state;
   if (!GetStaticExpectStapleState(host_port_pair.host(), &expect_staple_state))
@@ skipping 142 matching lines @@
       // No exception found. This certificate must conform to the CT policy.
       return CT_REQUIREMENTS_NOT_MET;
     }
   }
 
   return default_response;
 }
 
 void TransportSecurityState::SetDelegate(
     TransportSecurityState::Delegate* delegate) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   delegate_ = delegate;
 }
 
 void TransportSecurityState::SetReportSender(
     TransportSecurityState::ReportSenderInterface* report_sender) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   report_sender_ = report_sender;
 }
 
 void TransportSecurityState::SetExpectCTReporter(
     ExpectCTReporter* expect_ct_reporter) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   expect_ct_reporter_ = expect_ct_reporter;
 }
 
 void TransportSecurityState::SetRequireCTDelegate(RequireCTDelegate* delegate) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   require_ct_delegate_ = delegate;
 }
 
 void TransportSecurityState::AddHSTSInternal(
     const std::string& host,
     TransportSecurityState::STSState::UpgradeMode upgrade_mode,
     const base::Time& expiry,
     bool include_subdomains) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   STSState sts_state;
   sts_state.last_observed = base::Time::Now();
   sts_state.include_subdomains = include_subdomains;
   sts_state.expiry = expiry;
   sts_state.upgrade_mode = upgrade_mode;
 
   EnableSTSHost(host, sts_state);
 }
 
 void TransportSecurityState::AddHPKPInternal(const std::string& host,
                                              const base::Time& last_observed,
                                              const base::Time& expiry,
                                              bool include_subdomains,
                                              const HashValueVector& hashes,
                                              const GURL& report_uri) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   PKPState pkp_state;
   pkp_state.last_observed = last_observed;
   pkp_state.expiry = expiry;
   pkp_state.include_subdomains = include_subdomains;
   pkp_state.spki_hashes = hashes;
   pkp_state.report_uri = report_uri;
 
   EnablePKPHost(host, pkp_state);
 }
 
 void TransportSecurityState::AddExpectCTInternal(
     const std::string& host,
     const base::Time& last_observed,
     const base::Time& expiry,
     bool enforce,
     const GURL& report_uri) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   ExpectCTState expect_ct_state;
   expect_ct_state.last_observed = last_observed;
   expect_ct_state.expiry = expiry;
   expect_ct_state.enforce = enforce;
   expect_ct_state.report_uri = report_uri;
 
   EnableExpectCTHost(host, expect_ct_state);
 }
 
 void TransportSecurityState::
     SetEnablePublicKeyPinningBypassForLocalTrustAnchors(bool value) {
   enable_pkp_bypass_for_local_trust_anchors_ = value;
 }
 
 void TransportSecurityState::EnableSTSHost(const std::string& host,
                                            const STSState& state) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   const std::string canonicalized_host = CanonicalizeHost(host);
   if (canonicalized_host.empty())
     return;
 
   // Only store new state when HSTS is explicitly enabled. If it is
   // disabled, remove the state from the enabled hosts.
   if (state.ShouldUpgradeToSSL()) {
     STSState sts_state(state);
     // No need to store this value since it is redundant. (|canonicalized_host|
     // is the map key.)
     sts_state.domain.clear();
 
     enabled_sts_hosts_[HashHost(canonicalized_host)] = sts_state;
   } else {
     const std::string hashed_host = HashHost(canonicalized_host);
     enabled_sts_hosts_.erase(hashed_host);
   }
 
   DirtyNotify();
 }
 
 void TransportSecurityState::EnablePKPHost(const std::string& host,
                                            const PKPState& state) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   const std::string canonicalized_host = CanonicalizeHost(host);
   if (canonicalized_host.empty())
     return;
 
   // Only store new state when HPKP is explicitly enabled. If it is
   // disabled, remove the state from the enabled hosts.
   if (state.HasPublicKeyPins()) {
     PKPState pkp_state(state);
     // No need to store this value since it is redundant. (|canonicalized_host|
     // is the map key.)
     pkp_state.domain.clear();
 
     enabled_pkp_hosts_[HashHost(canonicalized_host)] = pkp_state;
   } else {
     const std::string hashed_host = HashHost(canonicalized_host);
     enabled_pkp_hosts_.erase(hashed_host);
   }
 
   DirtyNotify();
 }
 
 void TransportSecurityState::EnableExpectCTHost(const std::string& host,
                                                 const ExpectCTState& state) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!IsDynamicExpectCTEnabled())
     return;
 
   const std::string canonicalized_host = CanonicalizeHost(host);
   if (canonicalized_host.empty())
     return;
 
   // Only store new state when Expect-CT is explicitly enabled. If it is
   // disabled, remove the state from the enabled hosts.
   if (state.enforce || !state.report_uri.is_empty()) {
@@ skipping 62 matching lines @@
 
   report_sender_->Send(pkp_state.report_uri, "application/json; charset=utf-8",
                        serialized_report, base::Callback<void()>(),
                        base::Bind(RecordUMAForHPKPReportFailure));
   return PKPStatus::VIOLATED;
 }
 
 bool TransportSecurityState::GetStaticExpectCTState(
     const std::string& host,
     ExpectCTState* expect_ct_state) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (!IsBuildTimely())
     return false;
 
   PreloadResult result;
   if (!DecodeHSTSPreload(host, &result))
     return false;
 
   if (!enable_static_expect_ct_ || !result.expect_ct)
     return false;
 
   expect_ct_state->domain = host.substr(result.hostname_offset);
   expect_ct_state->report_uri = GURL(
       g_hsts_source->expect_ct_report_uris[result.expect_ct_report_uri_id]);
   return true;
 }
 
 bool TransportSecurityState::GetStaticExpectStapleState(
     const std::string& host,
     ExpectStapleState* expect_staple_state) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (!IsBuildTimely())
     return false;
 
   PreloadResult result;
   if (!DecodeHSTSPreload(host, &result))
     return false;
 
   if (!enable_static_expect_staple_ || !result.expect_staple)
     return false;
 
   expect_staple_state->domain = host.substr(result.hostname_offset);
   expect_staple_state->include_subdomains =
       result.expect_staple_include_subdomains;
   expect_staple_state->report_uri =
       GURL(g_hsts_source
                ->expect_staple_report_uris[result.expect_staple_report_uri_id]);
   return true;
 }
 
 bool TransportSecurityState::DeleteDynamicDataForHost(const std::string& host) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   const std::string canonicalized_host = CanonicalizeHost(host);
   if (canonicalized_host.empty())
     return false;
 
   const std::string hashed_host = HashHost(canonicalized_host);
   bool deleted = false;
   STSStateMap::iterator sts_interator = enabled_sts_hosts_.find(hashed_host);
   if (sts_interator != enabled_sts_hosts_.end()) {
     enabled_sts_hosts_.erase(sts_interator);
@@ skipping 12 matching lines @@
     enabled_expect_ct_hosts_.erase(expect_ct_iterator);
     deleted = true;
   }
 
   if (deleted)
     DirtyNotify();
   return deleted;
 }
 
 void TransportSecurityState::ClearDynamicData() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   enabled_sts_hosts_.clear();
   enabled_pkp_hosts_.clear();
   enabled_expect_ct_hosts_.clear();
 }
 
 void TransportSecurityState::DeleteAllDynamicDataSince(const base::Time& time) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   bool dirtied = false;
   STSStateMap::iterator sts_iterator = enabled_sts_hosts_.begin();
   while (sts_iterator != enabled_sts_hosts_.end()) {
     if (sts_iterator->second.last_observed >= time) {
       dirtied = true;
       enabled_sts_hosts_.erase(sts_iterator++);
       continue;
     }
 
@@ skipping 21 matching lines @@
     }
 
     ++expect_ct_iterator;
   }
 
   if (dirtied)
     DirtyNotify();
 }
 
 TransportSecurityState::~TransportSecurityState() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 void TransportSecurityState::DirtyNotify() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (delegate_)
     delegate_->StateIsDirty(this);
 }
 
 bool TransportSecurityState::AddHSTSHeader(const std::string& host,
                                            const std::string& value) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   base::Time now = base::Time::Now();
   base::TimeDelta max_age;
   bool include_subdomains;
   if (!ParseHSTSHeader(value, &max_age, &include_subdomains)) {
     return false;
   }
 
   // Handle max-age == 0.
   STSState::UpgradeMode upgrade_mode;
   if (max_age.InSeconds() == 0) {
     upgrade_mode = STSState::MODE_DEFAULT;
   } else {
     upgrade_mode = STSState::MODE_FORCE_HTTPS;
   }
 
   AddHSTSInternal(host, upgrade_mode, now + max_age, include_subdomains);
   return true;
 }
 
 bool TransportSecurityState::AddHPKPHeader(const std::string& host,
                                            const std::string& value,
                                            const SSLInfo& ssl_info) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   base::Time now = base::Time::Now();
   base::TimeDelta max_age;
   bool include_subdomains;
   HashValueVector spki_hashes;
   GURL report_uri;
 
   if (!ParseHPKPHeader(value, ssl_info.public_key_hashes, &max_age,
                        &include_subdomains, &spki_hashes, &report_uri)) {
     return false;
   }
   // Handle max-age == 0.
   if (max_age.InSeconds() == 0)
     spki_hashes.clear();
   AddHPKPInternal(host, now, now + max_age, include_subdomains, spki_hashes,
                   report_uri);
   return true;
 }
 
 void TransportSecurityState::AddHSTS(const std::string& host,
                                      const base::Time& expiry,
                                      bool include_subdomains) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   AddHSTSInternal(host, STSState::MODE_FORCE_HTTPS, expiry, include_subdomains);
 }
 
 void TransportSecurityState::AddHPKP(const std::string& host,
                                      const base::Time& expiry,
                                      bool include_subdomains,
                                      const HashValueVector& hashes,
                                      const GURL& report_uri) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   AddHPKPInternal(host, base::Time::Now(), expiry, include_subdomains, hashes,
                   report_uri);
 }
 
 void TransportSecurityState::AddExpectCT(const std::string& host,
                                          const base::Time& expiry,
                                          bool enforce,
                                          const GURL& report_uri) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   AddExpectCTInternal(host, base::Time::Now(), expiry, enforce, report_uri);
 }
 
 bool TransportSecurityState::ProcessHPKPReportOnlyHeader(
     const std::string& value,
     const HostPortPair& host_port_pair,
     const SSLInfo& ssl_info) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   base::Time now = base::Time::Now();
   bool include_subdomains;
   HashValueVector spki_hashes;
   GURL report_uri;
   std::string unused_failure_log;
 
   if (!ParseHPKPReportOnlyHeader(value, &include_subdomains, &spki_hashes,
                                  &report_uri) ||
       !report_uri.is_valid() || report_uri.is_empty()) {
@@ skipping 12 matching lines @@
       host_port_pair, ssl_info.is_issued_by_known_root, pkp_state,
       ssl_info.public_key_hashes, ssl_info.unverified_cert.get(),
       ssl_info.cert.get(), ENABLE_PIN_REPORTS, &unused_failure_log);
   return true;
 }
 
 void TransportSecurityState::ProcessExpectCTHeader(
     const std::string& value,
     const HostPortPair& host_port_pair,
     const SSLInfo& ssl_info) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // If a site sends `Expect-CT: preload` and appears on the preload list, they
   // are in the experimental preload-list-only, report-only version of
   // Expect-CT.
   if (value == "preload") {
     if (!expect_ct_reporter_)
       return;
     if (!IsBuildTimely())
       return;
     if (!ssl_info.is_issued_by_known_root)
@@ skipping 89 matching lines @@
   DCHECK(found_state);
   return CheckPinsAndMaybeSendReport(
       host_port_pair, is_issued_by_known_root, pkp_state, hashes,
       served_certificate_chain, validated_certificate_chain, report_status,
       failure_log);
 }
 
 bool TransportSecurityState::GetStaticDomainState(const std::string& host,
                                                   STSState* sts_state,
                                                   PKPState* pkp_state) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   sts_state->upgrade_mode = STSState::MODE_FORCE_HTTPS;
   sts_state->include_subdomains = false;
   pkp_state->include_subdomains = false;
 
   if (!IsBuildTimely())
     return false;
 
   PreloadResult result;
   if (!DecodeHSTSPreload(host, &result))
@@ skipping 33 matching lines @@
         AddHash(*sha256_hash, &pkp_state->bad_spki_hashes);
         sha256_hash++;
       }
     }
   }
 
   return true;
 }
 
 bool TransportSecurityState::IsGooglePinnedHost(const std::string& host) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (!IsBuildTimely())
     return false;
 
   PreloadResult result;
   if (!DecodeHSTSPreload(host, &result))
     return false;
 
   if (!result.has_pins)
     return false;
 
   if (result.pinset_id >= arraysize(kPinsets))
     return false;
 
   return kPinsets[result.pinset_id].accepted_pins == kGoogleAcceptableCerts;
 }
 
 bool TransportSecurityState::GetDynamicSTSState(const std::string& host,
                                                 STSState* result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   const std::string canonicalized_host = CanonicalizeHost(host);
   if (canonicalized_host.empty())
     return false;
 
   base::Time current_time(base::Time::Now());
 
   for (size_t i = 0; canonicalized_host[i]; i += canonicalized_host[i] + 1) {
     std::string host_sub_chunk(&canonicalized_host[i],
                                canonicalized_host.size() - i);
@@ skipping 20 matching lines @@
 
       break;
     }
   }
 
   return false;
 }
 
 bool TransportSecurityState::GetDynamicPKPState(const std::string& host,
                                                 PKPState* result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   const std::string canonicalized_host = CanonicalizeHost(host);
   if (canonicalized_host.empty())
     return false;
 
   base::Time current_time(base::Time::Now());
 
   for (size_t i = 0; canonicalized_host[i]; i += canonicalized_host[i] + 1) {
     std::string host_sub_chunk(&canonicalized_host[i],
                                canonicalized_host.size() - i);
@@ skipping 20 matching lines @@
 
       break;
     }
   }
 
   return false;
 }
 
 bool TransportSecurityState::GetDynamicExpectCTState(const std::string& host,
                                                      ExpectCTState* result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   const std::string canonicalized_host = CanonicalizeHost(host);
   if (canonicalized_host.empty())
     return false;
 
   base::Time current_time(base::Time::Now());
   ExpectCTStateMap::iterator j =
       enabled_expect_ct_hosts_.find(HashHost(canonicalized_host));
   if (j == enabled_expect_ct_hosts_.end())
     return false;
   // If the entry is invalid, drop it.
   if (current_time > j->second.expiry) {
     enabled_expect_ct_hosts_.erase(j);
     DirtyNotify();
     return false;
   }
 
   *result = j->second;
   return true;
 }
 
 void TransportSecurityState::AddOrUpdateEnabledSTSHosts(
     const std::string& hashed_host,
     const STSState& state) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(state.ShouldUpgradeToSSL());
   enabled_sts_hosts_[hashed_host] = state;
 }
 
 void TransportSecurityState::AddOrUpdateEnabledPKPHosts(
     const std::string& hashed_host,
     const PKPState& state) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(state.HasPublicKeyPins());
   enabled_pkp_hosts_[hashed_host] = state;
 }
 
 void TransportSecurityState::AddOrUpdateEnabledExpectCTHosts(
     const std::string& hashed_host,
     const ExpectCTState& state) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(state.enforce || !state.report_uri.is_empty());
   enabled_expect_ct_hosts_[hashed_host] = state;
 }
 
 TransportSecurityState::STSState::STSState()
     : upgrade_mode(MODE_DEFAULT), include_subdomains(false) {
 }
 
 TransportSecurityState::STSState::~STSState() {
 }
@@ skipping 20 matching lines @@
 }
 
 TransportSecurityState::ExpectCTState::ExpectCTState() : enforce(false) {}
 
 TransportSecurityState::ExpectCTState::~ExpectCTState() {}
 
 TransportSecurityState::ExpectCTStateIterator::ExpectCTStateIterator(
     const TransportSecurityState& state)
     : iterator_(state.enabled_expect_ct_hosts_.begin()),
       end_(state.enabled_expect_ct_hosts_.end()) {
-  DCHECK(state.CalledOnValidThread());
+  state.AssertCalledOnValidSequence();
 }
 
 TransportSecurityState::ExpectCTStateIterator::~ExpectCTStateIterator() {}
 
 TransportSecurityState::ExpectStapleState::ExpectStapleState()
     : include_subdomains(false) {}
 
 TransportSecurityState::ExpectStapleState::~ExpectStapleState() {}
 
 bool TransportSecurityState::PKPState::CheckPublicKeyPins(
@@ skipping 38 matching lines @@
 TransportSecurityState::PKPStateIterator::PKPStateIterator(
     const TransportSecurityState& state)
     : iterator_(state.enabled_pkp_hosts_.begin()),
       end_(state.enabled_pkp_hosts_.end()) {
 }
 
 TransportSecurityState::PKPStateIterator::~PKPStateIterator() {
 }
 
 }  // namespace net