Improve performance of proxy resolver by tracing DNS dependencies.

net/base/mock_host_resolver.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/base/mock_host_resolver.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 53 matching lines @@
 MockHostResolverBase::~MockHostResolverBase() {
   STLDeleteValues(&requests_);
 }
 
 int MockHostResolverBase::Resolve(const RequestInfo& info,
                                   AddressList* addresses,
                                   const CompletionCallback& callback,
                                   RequestHandle* handle,
                                   const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
+  num_resolve_++;
   size_t id = next_request_id_++;
   int rv = ResolveFromIPLiteralOrCache(info, addresses);
   if (rv != ERR_DNS_CACHE_MISS) {
     return rv;
   }
   if (synchronous_mode_) {
     return ResolveProc(id, info, addresses);
   }
   // Store the request for asynchronous resolution
   Request* req = new Request(info, addresses, callback);
   requests_[id] = req;
   if (handle)
     *handle = reinterpret_cast<RequestHandle>(id);
 
   if (!ondemand_mode_) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&MockHostResolverBase::ResolveNow, AsWeakPtr(), id));
   }
 
   return ERR_IO_PENDING;
 }
 
 int MockHostResolverBase::ResolveFromCache(const RequestInfo& info,
                                            AddressList* addresses,
                                            const BoundNetLog& net_log) {
+  num_resolve_from_cache_++;
   DCHECK(CalledOnValidThread());
   next_request_id_++;
   int rv = ResolveFromIPLiteralOrCache(info, addresses);
   return rv;
 }
 
 void MockHostResolverBase::CancelRequest(RequestHandle handle) {
   DCHECK(CalledOnValidThread());
   size_t id = reinterpret_cast<size_t>(handle);
   RequestMap::iterator it = requests_.find(id);
@@ skipping 17 matching lines @@
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&MockHostResolverBase::ResolveNow, AsWeakPtr(), i->first));
   }
 }
 
 // start id from 1 to distinguish from NULL RequestHandle
 MockHostResolverBase::MockHostResolverBase(bool use_caching)
     : synchronous_mode_(false),
       ondemand_mode_(false),
-      next_request_id_(1) {
+      next_request_id_(1),
+      num_resolve_(0),
+      num_resolve_from_cache_(0) {
   rules_ = CreateCatchAllHostResolverProc();
 
   if (use_caching) {
     cache_.reset(new HostCache(kMaxCacheEntries));
   }
 }
 
 int MockHostResolverBase::ResolveFromIPLiteralOrCache(const RequestInfo& info,
                                                       AddressList* addresses) {
   IPAddressNumber ip;
@@ skipping 150 matching lines @@
 
 void RuleBasedHostResolverProc::AddSimulatedFailure(
     const std::string& host_pattern) {
   HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY |
       HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
   Rule rule(Rule::kResolverTypeFail, host_pattern, ADDRESS_FAMILY_UNSPECIFIED,
             flags, "", "", 0);
   rules_.push_back(rule);
 }
 
+void RuleBasedHostResolverProc::ClearRules() {
+  rules_.clear();
+}
+
 int RuleBasedHostResolverProc::Resolve(const std::string& host,
                                        AddressFamily address_family,
                                        HostResolverFlags host_resolver_flags,
                                        AddressList* addrlist,
                                        int* os_error) {
   RuleList::iterator r;
   for (r = rules_.begin(); r != rules_.end(); ++r) {
     bool matches_address_family =
         r->address_family == ADDRESS_FAMILY_UNSPECIFIED ||
         r->address_family == address_family;
@@ skipping 82 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