Adds LogDnsClient::NotifyWhenNotThrottled

components/certificate_transparency/log_dns_client.cc

 // Copyright 2016 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 "components/certificate_transparency/log_dns_client.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 336 matching lines @@
 }
 
 void LogDnsClient::OnDNSChanged() {
   UpdateDnsConfig();
 }
 
 void LogDnsClient::OnInitialDNSConfigRead() {
   UpdateDnsConfig();
 }
 
+void LogDnsClient::NotifyWhenNotThrottled(
+    const NotThrottledCallback& callback) {
+  DCHECK(HasMaxConcurrentQueriesInProgress());
+  not_throttled_callbacks_.push_back(callback);
+}
+
 net::Error LogDnsClient::QueryAuditProof(base::StringPiece domain_for_log,
                                          base::StringPiece leaf_hash,
                                          uint64_t tree_size,
                                          const AuditProofCallback& callback) {
   if (domain_for_log.empty() || leaf_hash.size() != crypto::kSHA256Length) {
     return net::ERR_INVALID_ARGUMENT;
   }
 
   if (HasMaxConcurrentQueriesInProgress()) {
     return net::ERR_TEMPORARILY_THROTTLED;
@@ skipping 27 matching lines @@
   auto query_iterator =
       std::find_if(audit_proof_queries_.begin(), audit_proof_queries_.end(),
                    [query](const std::unique_ptr<AuditProofQuery>& p) {
                      return p.get() == query;
                    });
   DCHECK(query_iterator != audit_proof_queries_.end());
   audit_proof_queries_.erase(query_iterator);
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, result, base::Passed(&proof)));
+
+  for (const NotThrottledCallback& callback : not_throttled_callbacks_) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, weak_ptr_factory_.GetWeakPtr()));

[Ryan Sleevi, 2016/10/03 23:56:04]

From a design perspective: Why asynchronously? Why not synchronously?

[Rob Percival, 2016/10/04 18:53:03]

An abundance of caution, but actually this can be done synchronously without
issue.

+  }
+  not_throttled_callbacks_.clear();
 }
 
 bool LogDnsClient::HasMaxConcurrentQueriesInProgress() const {
   return max_concurrent_queries_ != 0 &&
          audit_proof_queries_.size() >= max_concurrent_queries_;
 }
 
 void LogDnsClient::UpdateDnsConfig() {
   net::DnsConfig config;
   net::NetworkChangeNotifier::GetDnsConfig(&config);
   if (config.IsValid())
     dns_client_->SetConfig(config);
 }
 
 }  // namespace certificate_transparency