O Chromium / Chrome não armazena em cache solicitações de DNS por mais de um minuto.
Curiosamente, de bugs-cromo - edição 164026 - DNS TTL não homenageado a partir de 21 de abril de 2011
The only DNS cache in the system is in chrome and it does not honor TTL. We need to either fix chrome and/or add an intermediate cache that does handle TTL correctly.
Responder no bilhete de 4 de dezembro de 2012:
The HostCache currently assumes TTL=60s for all positive results. With asynchronous DNS resolver, we plan to use TTL=max(60s, server_reported_ttl), i.e., at least 60s. The rationale is to improve the cache performance. (When a CDN NS provides TTL=10-20s, and it takes 30s+ to fetch all subresources, we often have to re-query for the same hostname during one page load.)
O ticket foi fechado em 10 de outubro de 2013 como:
Chrome on CrOS uses asynchronous DNS resolver which honors TTL = max(60s, > server_reported_ttl)
I'm closing this as WontFix (obsolete/works as intended).
Este tem sido um problema conhecido há anos; seu resolvedor de DNS interno ignora o TTL de registros DNS e armazena em cache as solicitações de DNS por 1 minuto.
Os usuários solicitam há anos um recurso para alterar esse comportamento padrão, e o Google nunca criou um.
No passado, você poderia desabilitar o resolvedor de DNS interno em chrome://flags , hoje em dia isso não é mais exposto funcionalmente.
Então, resumindo, é um recurso, por exemplo faz isso por design.
(Eu inicialmente escrevi que nunca poderia ser alterado, o que obviamente não é verdade. Uma pessoa realmente determinada pode recompilar o Chromium ou hackear binários do Google Chrome.).
Portanto, como adenda: há muitas evidências documentadas de que os engenheiros do Google não pretendem respeitar o TTL padrão nas respostas de DNS recebidas no Chrome / ium.
De Cache negativo de consultas DNS (DNS NCACHE)
As with caching positive responses it is sensible for a resolver to limit for how long it will cache a negative response...
Embora esteja implícito que um resolvedor pode / deve impor um limite máximo ao armazenamento em cache da resposta do DNS, o limite de 1 min no Google Chrome pode ser muito baixo.
P.S. Na verdade, descobri a resposta para algo que vinha me incomodando há anos ao recuperar as estatísticas do Chrome para responder a essa pergunta: Chrome: solicitações de DNS com nomes DNS aleatórios: malware?
PS2 A partir do código abaixo, é evidente que as respostas negativas não estão armazenadas em cache (TTL = 0).
De link
99 // Default TTL for successful resolutions with ProcTask.
100 const unsigned kCacheEntryTTLSeconds = 60;
101
102 // Default TTL for unsuccessful resolutions with ProcTask.
103 const unsigned kNegativeCacheEntryTTLSeconds = 0;
104
105 // Minimum TTL for successful resolutions with DnsTask.
106 const unsigned kMinimumTTLSeconds = kCacheEntryTTLSeconds;
1518 // Called by ProcTask when it completes.
1519 void OnProcTaskComplete(base::TimeTicks start_time,
1520 int net_error,
1521 const AddressList& addr_list) {
1522 DCHECK(is_proc_running());
1523
1524 if (dns_task_error_ != OK) {
1525 base::TimeDelta duration = base::TimeTicks::Now() - start_time;
1526 if (net_error == OK) {
1527 UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.FallbackSuccess", duration);
1528 if ((dns_task_error_ == ERR_NAME_NOT_RESOLVED) &&
1529 ResemblesNetBIOSName(key_.hostname)) {
1530 UmaAsyncDnsResolveStatus(RESOLVE_STATUS_SUSPECT_NETBIOS);
1531 } else {
1532 UmaAsyncDnsResolveStatus(RESOLVE_STATUS_PROC_SUCCESS);
1533 }
1534 base::UmaHistogramSparse("Net.DNS.DnsTask.Errors",
1535 std::abs(dns_task_error_));
1536 resolver_->OnDnsTaskResolve(dns_task_error_);
1537 } else {
1538 UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.FallbackFail", duration);
1539 UmaAsyncDnsResolveStatus(RESOLVE_STATUS_FAIL);
1540 }
1541 }
1542
1543 if (ContainsIcannNameCollisionIp(addr_list))
1544 net_error = ERR_ICANN_NAME_COLLISION;
1545
1546 base::TimeDelta ttl =
# always 0 seconds
1547 base::TimeDelta::FromSeconds(kNegativeCacheEntryTTLSeconds);
1548 if (net_error == OK)
# always 60 seconds
1549 ttl = base::TimeDelta::FromSeconds(kCacheEntryTTLSeconds);
1550
1551 // Source unknown because the system resolver could have gotten it from a
1552 // hosts file, its own cache, a DNS lookup or somewhere else.
1553 // Don't store the |ttl| in cache since it's not obtained from the server.
1554 CompleteRequests(
1555 MakeCacheEntry(net_error, addr_list, HostCache::Entry::SOURCE_UNKNOWN),
1556 ttl);
1557 }