Adds custom ttl argument to HostCache::Set.

net/base/mock_host_resolver.cc

 // Copyright (c) 2011 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/base/mock_host_resolver.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/threading/platform_thread.h"
 #include "net/base/host_cache.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 
 namespace net {
 
 namespace {
 
+// Cache size for the MockCachingHostResolver.
+const unsigned kMaxCacheEntries = 100;
+// TTL for the successful resolutions. Failures are not cached.
+const base::TimeDelta kCacheEntryTTL = base::TimeDelta::FromMinutes(1);
+
 char* do_strdup(const char* src) {
 #if defined(OS_WIN)
   return _strdup(src);
 #else
   return strdup(src);
 #endif
 }
 
 }  // namespace
 
@@ skipping 88 matching lines @@
   return cache_.get();
 }
 
 // start id from 1 to distinguish from NULL RequestHandle
 MockHostResolverBase::MockHostResolverBase(bool use_caching)
     : synchronous_mode_(false), next_request_id_(1) {
   rules_ = CreateCatchAllHostResolverProc();
   proc_ = rules_;
 
   if (use_caching) {
-    cache_.reset(new HostCache(
-        100,  // max entries.
-        base::TimeDelta::FromMinutes(1),
-        base::TimeDelta::FromSeconds(0)));
+    cache_.reset(new HostCache(kMaxCacheEntries));
   }
 }
 
 int MockHostResolverBase::ResolveFromIPLiteralOrCache(const RequestInfo& info,
                                                       AddressList* addresses) {
   IPAddressNumber ip;
   if (ParseIPLiteralToNumber(info.hostname(), &ip)) {
     *addresses = AddressList::CreateFromIPAddressWithCname(
         ip, info.port(), info.host_resolver_flags() & HOST_RESOLVER_CANONNAME);
     return OK;
@@ skipping 19 matching lines @@
   AddressList addr;
   int rv = proc_->Resolve(info.hostname(),
                           info.address_family(),
                           info.host_resolver_flags(),
                           &addr,
                           NULL);
   if (cache_.get()) {
     HostCache::Key key(info.hostname(),
                        info.address_family(),
                        info.host_resolver_flags());
-    cache_->Set(key, rv, addr, base::TimeTicks::Now());
+    // Storing a failure with TTL 0 so that it overwrites previous value.
+    cache_->Set(key, rv, addr,
+                base::TimeTicks::Now(),
+                (rv == OK) ? kCacheEntryTTL : base::TimeDelta());
   }
   if (rv == OK)
     *addresses = CreateAddressListUsingPort(addr, info.port());
   return rv;
 }
 
 void MockHostResolverBase::ResolveNow(size_t id) {
   RequestMap::iterator it = requests_.find(id);
   if (it == requests_.end())
     return;  // was canceled
@@ skipping 204 matching lines @@
   CHECK_EQ(old_proc, current_proc_);
 }
 
 void ScopedDefaultHostResolverProc::Init(HostResolverProc* proc) {
   current_proc_ = proc;
   previous_proc_ = HostResolverProc::SetDefault(current_proc_);
   current_proc_->SetLastProc(previous_proc_);
 }
 
 }  // namespace net