Home | History | Annotate | Download | only in dns 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/dns/host_resolver_impl.h"
      6 
      7 #include <algorithm>
      8 #include <string>
      9 
     10 #include "base/bind.h"
     11 #include "base/bind_helpers.h"
     12 #include "base/memory/ref_counted.h"
     13 #include "base/memory/scoped_vector.h"
     14 #include "base/message_loop/message_loop.h"
     15 #include "base/strings/string_util.h"
     16 #include "base/strings/stringprintf.h"
     17 #include "base/synchronization/condition_variable.h"
     18 #include "base/synchronization/lock.h"
     19 #include "base/test/test_timeouts.h"
     20 #include "base/time/time.h"
     21 #include "net/base/address_list.h"
     22 #include "net/base/net_errors.h"
     23 #include "net/base/net_util.h"
     24 #include "net/dns/dns_client.h"
     25 #include "net/dns/dns_test_util.h"
     26 #include "net/dns/host_cache.h"
     27 #include "net/dns/mock_host_resolver.h"
     28 #include "testing/gtest/include/gtest/gtest.h"
     29 
     30 namespace net {
     31 
     32 namespace {
     33 
     34 const size_t kMaxJobs = 10u;
     35 const size_t kMaxRetryAttempts = 4u;
     36 
     37 PrioritizedDispatcher::Limits DefaultLimits() {
     38   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, kMaxJobs);
     39   return limits;
     40 }
     41 
     42 HostResolverImpl::ProcTaskParams DefaultParams(
     43     HostResolverProc* resolver_proc) {
     44   return HostResolverImpl::ProcTaskParams(resolver_proc, kMaxRetryAttempts);
     45 }
     46 
     47 // A HostResolverProc that pushes each host mapped into a list and allows
     48 // waiting for a specific number of requests. Unlike RuleBasedHostResolverProc
     49 // it never calls SystemHostResolverCall. By default resolves all hostnames to
     50 // "127.0.0.1". After AddRule(), it resolves only names explicitly specified.
     51 class MockHostResolverProc : public HostResolverProc {
     52  public:
     53   struct ResolveKey {
     54     ResolveKey(const std::string& hostname, AddressFamily address_family)
     55         : hostname(hostname), address_family(address_family) {}
     56     bool operator<(const ResolveKey& other) const {
     57       return address_family < other.address_family ||
     58           (address_family == other.address_family && hostname < other.hostname);
     59     }
     60     std::string hostname;
     61     AddressFamily address_family;
     62   };
     63 
     64   typedef std::vector<ResolveKey> CaptureList;
     65 
     66   MockHostResolverProc()
     67       : HostResolverProc(NULL),
     68         num_requests_waiting_(0),
     69         num_slots_available_(0),
     70         requests_waiting_(&lock_),
     71         slots_available_(&lock_) {
     72   }
     73 
     74   // Waits until |count| calls to |Resolve| are blocked. Returns false when
     75   // timed out.
     76   bool WaitFor(unsigned count) {
     77     base::AutoLock lock(lock_);
     78     base::Time start_time = base::Time::Now();
     79     while (num_requests_waiting_ < count) {
     80       requests_waiting_.TimedWait(TestTimeouts::action_timeout());
     81       if (base::Time::Now() > start_time + TestTimeouts::action_timeout())
     82         return false;
     83     }
     84     return true;
     85   }
     86 
     87   // Signals |count| waiting calls to |Resolve|. First come first served.
     88   void SignalMultiple(unsigned count) {
     89     base::AutoLock lock(lock_);
     90     num_slots_available_ += count;
     91     slots_available_.Broadcast();
     92   }
     93 
     94   // Signals all waiting calls to |Resolve|. Beware of races.
     95   void SignalAll() {
     96     base::AutoLock lock(lock_);
     97     num_slots_available_ = num_requests_waiting_;
     98     slots_available_.Broadcast();
     99   }
    100 
    101   void AddRule(const std::string& hostname, AddressFamily family,
    102                const AddressList& result) {
    103     base::AutoLock lock(lock_);
    104     rules_[ResolveKey(hostname, family)] = result;
    105   }
    106 
    107   void AddRule(const std::string& hostname, AddressFamily family,
    108                const std::string& ip_list) {
    109     AddressList result;
    110     int rv = ParseAddressList(ip_list, std::string(), &result);
    111     DCHECK_EQ(OK, rv);
    112     AddRule(hostname, family, result);
    113   }
    114 
    115   void AddRuleForAllFamilies(const std::string& hostname,
    116                              const std::string& ip_list) {
    117     AddressList result;
    118     int rv = ParseAddressList(ip_list, std::string(), &result);
    119     DCHECK_EQ(OK, rv);
    120     AddRule(hostname, ADDRESS_FAMILY_UNSPECIFIED, result);
    121     AddRule(hostname, ADDRESS_FAMILY_IPV4, result);
    122     AddRule(hostname, ADDRESS_FAMILY_IPV6, result);
    123   }
    124 
    125   virtual int Resolve(const std::string& hostname,
    126                       AddressFamily address_family,
    127                       HostResolverFlags host_resolver_flags,
    128                       AddressList* addrlist,
    129                       int* os_error) OVERRIDE {
    130     base::AutoLock lock(lock_);
    131     capture_list_.push_back(ResolveKey(hostname, address_family));
    132     ++num_requests_waiting_;
    133     requests_waiting_.Broadcast();
    134     while (!num_slots_available_)
    135       slots_available_.Wait();
    136     DCHECK_GT(num_requests_waiting_, 0u);
    137     --num_slots_available_;
    138     --num_requests_waiting_;
    139     if (rules_.empty()) {
    140       int rv = ParseAddressList("127.0.0.1", std::string(), addrlist);
    141       DCHECK_EQ(OK, rv);
    142       return OK;
    143     }
    144     ResolveKey key(hostname, address_family);
    145     if (rules_.count(key) == 0)
    146       return ERR_NAME_NOT_RESOLVED;
    147     *addrlist = rules_[key];
    148     return OK;
    149   }
    150 
    151   CaptureList GetCaptureList() const {
    152     CaptureList copy;
    153     {
    154       base::AutoLock lock(lock_);
    155       copy = capture_list_;
    156     }
    157     return copy;
    158   }
    159 
    160   bool HasBlockedRequests() const {
    161     base::AutoLock lock(lock_);
    162     return num_requests_waiting_ > num_slots_available_;
    163   }
    164 
    165  protected:
    166   virtual ~MockHostResolverProc() {}
    167 
    168  private:
    169   mutable base::Lock lock_;
    170   std::map<ResolveKey, AddressList> rules_;
    171   CaptureList capture_list_;
    172   unsigned num_requests_waiting_;
    173   unsigned num_slots_available_;
    174   base::ConditionVariable requests_waiting_;
    175   base::ConditionVariable slots_available_;
    176 
    177   DISALLOW_COPY_AND_ASSIGN(MockHostResolverProc);
    178 };
    179 
    180 bool AddressListContains(const AddressList& list, const std::string& address,
    181                          int port) {
    182   IPAddressNumber ip;
    183   bool rv = ParseIPLiteralToNumber(address, &ip);
    184   DCHECK(rv);
    185   return std::find(list.begin(),
    186                    list.end(),
    187                    IPEndPoint(ip, port)) != list.end();
    188 }
    189 
    190 // A wrapper for requests to a HostResolver.
    191 class Request {
    192  public:
    193   // Base class of handlers to be executed on completion of requests.
    194   struct Handler {
    195     virtual ~Handler() {}
    196     virtual void Handle(Request* request) = 0;
    197   };
    198 
    199   Request(const HostResolver::RequestInfo& info,
    200           size_t index,
    201           HostResolver* resolver,
    202           Handler* handler)
    203       : info_(info),
    204         index_(index),
    205         resolver_(resolver),
    206         handler_(handler),
    207         quit_on_complete_(false),
    208         result_(ERR_UNEXPECTED),
    209         handle_(NULL) {}
    210 
    211   int Resolve() {
    212     DCHECK(resolver_);
    213     DCHECK(!handle_);
    214     list_ = AddressList();
    215     result_ = resolver_->Resolve(
    216         info_, &list_, base::Bind(&Request::OnComplete, base::Unretained(this)),
    217         &handle_, BoundNetLog());
    218     if (!list_.empty())
    219       EXPECT_EQ(OK, result_);
    220     return result_;
    221   }
    222 
    223   int ResolveFromCache() {
    224     DCHECK(resolver_);
    225     DCHECK(!handle_);
    226     return resolver_->ResolveFromCache(info_, &list_, BoundNetLog());
    227   }
    228 
    229   void Cancel() {
    230     DCHECK(resolver_);
    231     DCHECK(handle_);
    232     resolver_->CancelRequest(handle_);
    233     handle_ = NULL;
    234   }
    235 
    236   const HostResolver::RequestInfo& info() const { return info_; }
    237   size_t index() const { return index_; }
    238   const AddressList& list() const { return list_; }
    239   int result() const { return result_; }
    240   bool completed() const { return result_ != ERR_IO_PENDING; }
    241   bool pending() const { return handle_ != NULL; }
    242 
    243   bool HasAddress(const std::string& address, int port) const {
    244     return AddressListContains(list_, address, port);
    245   }
    246 
    247   // Returns the number of addresses in |list_|.
    248   unsigned NumberOfAddresses() const {
    249     return list_.size();
    250   }
    251 
    252   bool HasOneAddress(const std::string& address, int port) const {
    253     return HasAddress(address, port) && (NumberOfAddresses() == 1u);
    254   }
    255 
    256   // Returns ERR_UNEXPECTED if timed out.
    257   int WaitForResult() {
    258     if (completed())
    259       return result_;
    260     base::CancelableClosure closure(base::MessageLoop::QuitClosure());
    261     base::MessageLoop::current()->PostDelayedTask(
    262         FROM_HERE, closure.callback(), TestTimeouts::action_max_timeout());
    263     quit_on_complete_ = true;
    264     base::MessageLoop::current()->Run();
    265     bool did_quit = !quit_on_complete_;
    266     quit_on_complete_ = false;
    267     closure.Cancel();
    268     if (did_quit)
    269       return result_;
    270     else
    271       return ERR_UNEXPECTED;
    272   }
    273 
    274  private:
    275   void OnComplete(int rv) {
    276     EXPECT_TRUE(pending());
    277     EXPECT_EQ(ERR_IO_PENDING, result_);
    278     EXPECT_NE(ERR_IO_PENDING, rv);
    279     result_ = rv;
    280     handle_ = NULL;
    281     if (!list_.empty()) {
    282       EXPECT_EQ(OK, result_);
    283       EXPECT_EQ(info_.port(), list_.front().port());
    284     }
    285     if (handler_)
    286       handler_->Handle(this);
    287     if (quit_on_complete_) {
    288       base::MessageLoop::current()->Quit();
    289       quit_on_complete_ = false;
    290     }
    291   }
    292 
    293   HostResolver::RequestInfo info_;
    294   size_t index_;
    295   HostResolver* resolver_;
    296   Handler* handler_;
    297   bool quit_on_complete_;
    298 
    299   AddressList list_;
    300   int result_;
    301   HostResolver::RequestHandle handle_;
    302 
    303   DISALLOW_COPY_AND_ASSIGN(Request);
    304 };
    305 
    306 // Using LookupAttemptHostResolverProc simulate very long lookups, and control
    307 // which attempt resolves the host.
    308 class LookupAttemptHostResolverProc : public HostResolverProc {
    309  public:
    310   LookupAttemptHostResolverProc(HostResolverProc* previous,
    311                                 int attempt_number_to_resolve,
    312                                 int total_attempts)
    313       : HostResolverProc(previous),
    314         attempt_number_to_resolve_(attempt_number_to_resolve),
    315         current_attempt_number_(0),
    316         total_attempts_(total_attempts),
    317         total_attempts_resolved_(0),
    318         resolved_attempt_number_(0),
    319         all_done_(&lock_) {
    320   }
    321 
    322   // Test harness will wait for all attempts to finish before checking the
    323   // results.
    324   void WaitForAllAttemptsToFinish(const base::TimeDelta& wait_time) {
    325     base::TimeTicks end_time = base::TimeTicks::Now() + wait_time;
    326     {
    327       base::AutoLock auto_lock(lock_);
    328       while (total_attempts_resolved_ != total_attempts_ &&
    329           base::TimeTicks::Now() < end_time) {
    330         all_done_.TimedWait(end_time - base::TimeTicks::Now());
    331       }
    332     }
    333   }
    334 
    335   // All attempts will wait for an attempt to resolve the host.
    336   void WaitForAnAttemptToComplete() {
    337     base::TimeDelta wait_time = base::TimeDelta::FromSeconds(60);
    338     base::TimeTicks end_time = base::TimeTicks::Now() + wait_time;
    339     {
    340       base::AutoLock auto_lock(lock_);
    341       while (resolved_attempt_number_ == 0 && base::TimeTicks::Now() < end_time)
    342         all_done_.TimedWait(end_time - base::TimeTicks::Now());
    343     }
    344     all_done_.Broadcast();  // Tell all waiting attempts to proceed.
    345   }
    346 
    347   // Returns the number of attempts that have finished the Resolve() method.
    348   int total_attempts_resolved() { return total_attempts_resolved_; }
    349 
    350   // Returns the first attempt that that has resolved the host.
    351   int resolved_attempt_number() { return resolved_attempt_number_; }
    352 
    353   // HostResolverProc methods.
    354   virtual int Resolve(const std::string& host,
    355                       AddressFamily address_family,
    356                       HostResolverFlags host_resolver_flags,
    357                       AddressList* addrlist,
    358                       int* os_error) OVERRIDE {
    359     bool wait_for_right_attempt_to_complete = true;
    360     {
    361       base::AutoLock auto_lock(lock_);
    362       ++current_attempt_number_;
    363       if (current_attempt_number_ == attempt_number_to_resolve_) {
    364         resolved_attempt_number_ = current_attempt_number_;
    365         wait_for_right_attempt_to_complete = false;
    366       }
    367     }
    368 
    369     if (wait_for_right_attempt_to_complete)
    370       // Wait for the attempt_number_to_resolve_ attempt to resolve.
    371       WaitForAnAttemptToComplete();
    372 
    373     int result = ResolveUsingPrevious(host, address_family, host_resolver_flags,
    374                                       addrlist, os_error);
    375 
    376     {
    377       base::AutoLock auto_lock(lock_);
    378       ++total_attempts_resolved_;
    379     }
    380 
    381     all_done_.Broadcast();  // Tell all attempts to proceed.
    382 
    383     // Since any negative number is considered a network error, with -1 having
    384     // special meaning (ERR_IO_PENDING). We could return the attempt that has
    385     // resolved the host as a negative number. For example, if attempt number 3
    386     // resolves the host, then this method returns -4.
    387     if (result == OK)
    388       return -1 - resolved_attempt_number_;
    389     else
    390       return result;
    391   }
    392 
    393  protected:
    394   virtual ~LookupAttemptHostResolverProc() {}
    395 
    396  private:
    397   int attempt_number_to_resolve_;
    398   int current_attempt_number_;  // Incremented whenever Resolve is called.
    399   int total_attempts_;
    400   int total_attempts_resolved_;
    401   int resolved_attempt_number_;
    402 
    403   // All attempts wait for right attempt to be resolve.
    404   base::Lock lock_;
    405   base::ConditionVariable all_done_;
    406 };
    407 
    408 }  // namespace
    409 
    410 class HostResolverImplTest : public testing::Test {
    411  public:
    412   static const int kDefaultPort = 80;
    413 
    414   HostResolverImplTest() : proc_(new MockHostResolverProc()) {}
    415 
    416  protected:
    417   // A Request::Handler which is a proxy to the HostResolverImplTest fixture.
    418   struct Handler : public Request::Handler {
    419     virtual ~Handler() {}
    420 
    421     // Proxy functions so that classes derived from Handler can access them.
    422     Request* CreateRequest(const HostResolver::RequestInfo& info) {
    423       return test->CreateRequest(info);
    424     }
    425     Request* CreateRequest(const std::string& hostname, int port) {
    426       return test->CreateRequest(hostname, port);
    427     }
    428     Request* CreateRequest(const std::string& hostname) {
    429       return test->CreateRequest(hostname);
    430     }
    431     ScopedVector<Request>& requests() { return test->requests_; }
    432 
    433     void DeleteResolver() { test->resolver_.reset(); }
    434 
    435     HostResolverImplTest* test;
    436   };
    437 
    438   void CreateResolver() {
    439     resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
    440                                          DefaultLimits(),
    441                                          DefaultParams(proc_.get()),
    442                                          NULL));
    443   }
    444 
    445   // This HostResolverImpl will only allow 1 outstanding resolve at a time and
    446   // perform no retries.
    447   void CreateSerialResolver() {
    448     HostResolverImpl::ProcTaskParams params = DefaultParams(proc_.get());
    449     params.max_retry_attempts = 0u;
    450     PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
    451     resolver_.reset(new HostResolverImpl(
    452         HostCache::CreateDefaultCache(),
    453         limits,
    454         params,
    455         NULL));
    456   }
    457 
    458   // The Request will not be made until a call to |Resolve()|, and the Job will
    459   // not start until released by |proc_->SignalXXX|.
    460   Request* CreateRequest(const HostResolver::RequestInfo& info) {
    461     Request* req = new Request(info, requests_.size(), resolver_.get(),
    462                                handler_.get());
    463     requests_.push_back(req);
    464     return req;
    465   }
    466 
    467   Request* CreateRequest(const std::string& hostname,
    468                          int port,
    469                          RequestPriority priority,
    470                          AddressFamily family) {
    471     HostResolver::RequestInfo info(HostPortPair(hostname, port));
    472     info.set_priority(priority);
    473     info.set_address_family(family);
    474     return CreateRequest(info);
    475   }
    476 
    477   Request* CreateRequest(const std::string& hostname,
    478                          int port,
    479                          RequestPriority priority) {
    480     return CreateRequest(hostname, port, priority, ADDRESS_FAMILY_UNSPECIFIED);
    481   }
    482 
    483   Request* CreateRequest(const std::string& hostname, int port) {
    484     return CreateRequest(hostname, port, MEDIUM);
    485   }
    486 
    487   Request* CreateRequest(const std::string& hostname) {
    488     return CreateRequest(hostname, kDefaultPort);
    489   }
    490 
    491   virtual void SetUp() OVERRIDE {
    492     CreateResolver();
    493   }
    494 
    495   virtual void TearDown() OVERRIDE {
    496     if (resolver_.get())
    497       EXPECT_EQ(0u, resolver_->num_running_jobs_for_tests());
    498     EXPECT_FALSE(proc_->HasBlockedRequests());
    499   }
    500 
    501   void set_handler(Handler* handler) {
    502     handler_.reset(handler);
    503     handler_->test = this;
    504   }
    505 
    506   // Friendship is not inherited, so use proxies to access those.
    507   size_t num_running_jobs() const {
    508     DCHECK(resolver_.get());
    509     return resolver_->num_running_jobs_for_tests();
    510   }
    511 
    512   void set_fallback_to_proctask(bool fallback_to_proctask) {
    513     DCHECK(resolver_.get());
    514     resolver_->fallback_to_proctask_ = fallback_to_proctask;
    515   }
    516 
    517   scoped_refptr<MockHostResolverProc> proc_;
    518   scoped_ptr<HostResolverImpl> resolver_;
    519   ScopedVector<Request> requests_;
    520 
    521   scoped_ptr<Handler> handler_;
    522 };
    523 
    524 TEST_F(HostResolverImplTest, AsynchronousLookup) {
    525   proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
    526   proc_->SignalMultiple(1u);
    527 
    528   Request* req = CreateRequest("just.testing", 80);
    529   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
    530   EXPECT_EQ(OK, req->WaitForResult());
    531 
    532   EXPECT_TRUE(req->HasOneAddress("192.168.1.42", 80));
    533 
    534   EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);
    535 }
    536 
    537 TEST_F(HostResolverImplTest, EmptyListMeansNameNotResolved) {
    538   proc_->AddRuleForAllFamilies("just.testing", "");
    539   proc_->SignalMultiple(1u);
    540 
    541   Request* req = CreateRequest("just.testing", 80);
    542   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
    543   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult());
    544   EXPECT_EQ(0u, req->NumberOfAddresses());
    545   EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);
    546 }
    547 
    548 TEST_F(HostResolverImplTest, FailedAsynchronousLookup) {
    549   proc_->AddRuleForAllFamilies(std::string(),
    550                                "0.0.0.0");  // Default to failures.
    551   proc_->SignalMultiple(1u);
    552 
    553   Request* req = CreateRequest("just.testing", 80);
    554   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
    555   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult());
    556 
    557   EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);
    558 
    559   // Also test that the error is not cached.
    560   EXPECT_EQ(ERR_DNS_CACHE_MISS, req->ResolveFromCache());
    561 }
    562 
    563 TEST_F(HostResolverImplTest, AbortedAsynchronousLookup) {
    564   Request* req0 = CreateRequest("just.testing", 80);
    565   EXPECT_EQ(ERR_IO_PENDING, req0->Resolve());
    566 
    567   EXPECT_TRUE(proc_->WaitFor(1u));
    568 
    569   // Resolver is destroyed while job is running on WorkerPool.
    570   resolver_.reset();
    571 
    572   proc_->SignalAll();
    573 
    574   // To ensure there was no spurious callback, complete with a new resolver.
    575   CreateResolver();
    576   Request* req1 = CreateRequest("just.testing", 80);
    577   EXPECT_EQ(ERR_IO_PENDING, req1->Resolve());
    578 
    579   proc_->SignalMultiple(2u);
    580 
    581   EXPECT_EQ(OK, req1->WaitForResult());
    582 
    583   // This request was canceled.
    584   EXPECT_FALSE(req0->completed());
    585 }
    586 
    587 TEST_F(HostResolverImplTest, NumericIPv4Address) {
    588   // Stevens says dotted quads with AI_UNSPEC resolve to a single sockaddr_in.
    589   Request* req = CreateRequest("127.1.2.3", 5555);
    590   EXPECT_EQ(OK, req->Resolve());
    591 
    592   EXPECT_TRUE(req->HasOneAddress("127.1.2.3", 5555));
    593 }
    594 
    595 TEST_F(HostResolverImplTest, NumericIPv6Address) {
    596   // Resolve a plain IPv6 address.  Don't worry about [brackets], because
    597   // the caller should have removed them.
    598   Request* req = CreateRequest("2001:db8::1", 5555);
    599   EXPECT_EQ(OK, req->Resolve());
    600 
    601   EXPECT_TRUE(req->HasOneAddress("2001:db8::1", 5555));
    602 }
    603 
    604 TEST_F(HostResolverImplTest, EmptyHost) {
    605   Request* req = CreateRequest(std::string(), 5555);
    606   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve());
    607 }
    608 
    609 TEST_F(HostResolverImplTest, EmptyDotsHost) {
    610   for (int i = 0; i < 16; ++i) {
    611     Request* req = CreateRequest(std::string(i, '.'), 5555);
    612     EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve());
    613   }
    614 }
    615 
    616 TEST_F(HostResolverImplTest, LongHost) {
    617   Request* req = CreateRequest(std::string(4097, 'a'), 5555);
    618   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve());
    619 }
    620 
    621 TEST_F(HostResolverImplTest, DeDupeRequests) {
    622   // Start 5 requests, duplicating hosts "a" and "b". Since the resolver_proc is
    623   // blocked, these should all pile up until we signal it.
    624   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve());
    625   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 80)->Resolve());
    626   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 81)->Resolve());
    627   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 82)->Resolve());
    628   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 83)->Resolve());
    629 
    630   proc_->SignalMultiple(2u);  // One for "a", one for "b".
    631 
    632   for (size_t i = 0; i < requests_.size(); ++i) {
    633     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
    634   }
    635 }
    636 
    637 TEST_F(HostResolverImplTest, CancelMultipleRequests) {
    638   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve());
    639   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 80)->Resolve());
    640   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 81)->Resolve());
    641   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 82)->Resolve());
    642   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 83)->Resolve());
    643 
    644   // Cancel everything except request for ("a", 82).
    645   requests_[0]->Cancel();
    646   requests_[1]->Cancel();
    647   requests_[2]->Cancel();
    648   requests_[4]->Cancel();
    649 
    650   proc_->SignalMultiple(2u);  // One for "a", one for "b".
    651 
    652   EXPECT_EQ(OK, requests_[3]->WaitForResult());
    653 }
    654 
    655 TEST_F(HostResolverImplTest, CanceledRequestsReleaseJobSlots) {
    656   // Fill up the dispatcher and queue.
    657   for (unsigned i = 0; i < kMaxJobs + 1; ++i) {
    658     std::string hostname = "a_";
    659     hostname[1] = 'a' + i;
    660     EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 80)->Resolve());
    661     EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 81)->Resolve());
    662   }
    663 
    664   EXPECT_TRUE(proc_->WaitFor(kMaxJobs));
    665 
    666   // Cancel all but last two.
    667   for (unsigned i = 0; i < requests_.size() - 2; ++i) {
    668     requests_[i]->Cancel();
    669   }
    670 
    671   EXPECT_TRUE(proc_->WaitFor(kMaxJobs + 1));
    672 
    673   proc_->SignalAll();
    674 
    675   size_t num_requests = requests_.size();
    676   EXPECT_EQ(OK, requests_[num_requests - 1]->WaitForResult());
    677   EXPECT_EQ(OK, requests_[num_requests - 2]->result());
    678 }
    679 
    680 TEST_F(HostResolverImplTest, CancelWithinCallback) {
    681   struct MyHandler : public Handler {
    682     virtual void Handle(Request* req) OVERRIDE {
    683       // Port 80 is the first request that the callback will be invoked for.
    684       // While we are executing within that callback, cancel the other requests
    685       // in the job and start another request.
    686       if (req->index() == 0) {
    687         // Once "a:80" completes, it will cancel "a:81" and "a:82".
    688         requests()[1]->Cancel();
    689         requests()[2]->Cancel();
    690       }
    691     }
    692   };
    693   set_handler(new MyHandler());
    694 
    695   for (size_t i = 0; i < 4; ++i) {
    696     EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
    697   }
    698 
    699   proc_->SignalMultiple(2u);  // One for "a". One for "finalrequest".
    700 
    701   EXPECT_EQ(OK, requests_[0]->WaitForResult());
    702 
    703   Request* final_request = CreateRequest("finalrequest", 70);
    704   EXPECT_EQ(ERR_IO_PENDING, final_request->Resolve());
    705   EXPECT_EQ(OK, final_request->WaitForResult());
    706   EXPECT_TRUE(requests_[3]->completed());
    707 }
    708 
    709 TEST_F(HostResolverImplTest, DeleteWithinCallback) {
    710   struct MyHandler : public Handler {
    711     virtual void Handle(Request* req) OVERRIDE {
    712       EXPECT_EQ("a", req->info().hostname());
    713       EXPECT_EQ(80, req->info().port());
    714 
    715       DeleteResolver();
    716 
    717       // Quit after returning from OnCompleted (to give it a chance at
    718       // incorrectly running the cancelled tasks).
    719       base::MessageLoop::current()->PostTask(FROM_HERE,
    720                                              base::MessageLoop::QuitClosure());
    721     }
    722   };
    723   set_handler(new MyHandler());
    724 
    725   for (size_t i = 0; i < 4; ++i) {
    726     EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
    727   }
    728 
    729   proc_->SignalMultiple(1u);  // One for "a".
    730 
    731   // |MyHandler| will send quit message once all the requests have finished.
    732   base::MessageLoop::current()->Run();
    733 }
    734 
    735 TEST_F(HostResolverImplTest, DeleteWithinAbortedCallback) {
    736   struct MyHandler : public Handler {
    737     virtual void Handle(Request* req) OVERRIDE {
    738       EXPECT_EQ("a", req->info().hostname());
    739       EXPECT_EQ(80, req->info().port());
    740 
    741       DeleteResolver();
    742 
    743       // Quit after returning from OnCompleted (to give it a chance at
    744       // incorrectly running the cancelled tasks).
    745       base::MessageLoop::current()->PostTask(FROM_HERE,
    746                                              base::MessageLoop::QuitClosure());
    747     }
    748   };
    749   set_handler(new MyHandler());
    750 
    751   // This test assumes that the Jobs will be Aborted in order ["a", "b"]
    752   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve());
    753   // HostResolverImpl will be deleted before later Requests can complete.
    754   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 81)->Resolve());
    755   // Job for 'b' will be aborted before it can complete.
    756   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 82)->Resolve());
    757   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 83)->Resolve());
    758 
    759   EXPECT_TRUE(proc_->WaitFor(1u));
    760 
    761   // Triggering an IP address change.
    762   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
    763 
    764   // |MyHandler| will send quit message once all the requests have finished.
    765   base::MessageLoop::current()->Run();
    766 
    767   EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->result());
    768   EXPECT_EQ(ERR_IO_PENDING, requests_[1]->result());
    769   EXPECT_EQ(ERR_IO_PENDING, requests_[2]->result());
    770   EXPECT_EQ(ERR_IO_PENDING, requests_[3]->result());
    771   // Clean up.
    772   proc_->SignalMultiple(requests_.size());
    773 }
    774 
    775 TEST_F(HostResolverImplTest, StartWithinCallback) {
    776   struct MyHandler : public Handler {
    777     virtual void Handle(Request* req) OVERRIDE {
    778       if (req->index() == 0) {
    779         // On completing the first request, start another request for "a".
    780         // Since caching is disabled, this will result in another async request.
    781         EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 70)->Resolve());
    782       }
    783     }
    784   };
    785   set_handler(new MyHandler());
    786 
    787   // Turn off caching for this host resolver.
    788   resolver_.reset(new HostResolverImpl(scoped_ptr<HostCache>(),
    789                                        DefaultLimits(),
    790                                        DefaultParams(proc_.get()),
    791                                        NULL));
    792 
    793   for (size_t i = 0; i < 4; ++i) {
    794     EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
    795   }
    796 
    797   proc_->SignalMultiple(2u);  // One for "a". One for the second "a".
    798 
    799   EXPECT_EQ(OK, requests_[0]->WaitForResult());
    800   ASSERT_EQ(5u, requests_.size());
    801   EXPECT_EQ(OK, requests_.back()->WaitForResult());
    802 
    803   EXPECT_EQ(2u, proc_->GetCaptureList().size());
    804 }
    805 
    806 TEST_F(HostResolverImplTest, BypassCache) {
    807   struct MyHandler : public Handler {
    808     virtual void Handle(Request* req) OVERRIDE {
    809       if (req->index() == 0) {
    810         // On completing the first request, start another request for "a".
    811         // Since caching is enabled, this should complete synchronously.
    812         std::string hostname = req->info().hostname();
    813         EXPECT_EQ(OK, CreateRequest(hostname, 70)->Resolve());
    814         EXPECT_EQ(OK, CreateRequest(hostname, 75)->ResolveFromCache());
    815 
    816         // Ok good. Now make sure that if we ask to bypass the cache, it can no
    817         // longer service the request synchronously.
    818         HostResolver::RequestInfo info(HostPortPair(hostname, 71));
    819         info.set_allow_cached_response(false);
    820         EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info)->Resolve());
    821       } else if (71 == req->info().port()) {
    822         // Test is done.
    823         base::MessageLoop::current()->Quit();
    824       } else {
    825         FAIL() << "Unexpected request";
    826       }
    827     }
    828   };
    829   set_handler(new MyHandler());
    830 
    831   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve());
    832   proc_->SignalMultiple(3u);  // Only need two, but be generous.
    833 
    834   // |verifier| will send quit message once all the requests have finished.
    835   base::MessageLoop::current()->Run();
    836   EXPECT_EQ(2u, proc_->GetCaptureList().size());
    837 }
    838 
    839 // Test that IP address changes flush the cache.
    840 TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange) {
    841   proc_->SignalMultiple(2u);  // One before the flush, one after.
    842 
    843   Request* req = CreateRequest("host1", 70);
    844   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
    845   EXPECT_EQ(OK, req->WaitForResult());
    846 
    847   req = CreateRequest("host1", 75);
    848   EXPECT_EQ(OK, req->Resolve());  // Should complete synchronously.
    849 
    850   // Flush cache by triggering an IP address change.
    851   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
    852   base::MessageLoop::current()->RunUntilIdle();  // Notification happens async.
    853 
    854   // Resolve "host1" again -- this time it won't be served from cache, so it
    855   // will complete asynchronously.
    856   req = CreateRequest("host1", 80);
    857   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
    858   EXPECT_EQ(OK, req->WaitForResult());
    859 }
    860 
    861 // Test that IP address changes send ERR_NETWORK_CHANGED to pending requests.
    862 TEST_F(HostResolverImplTest, AbortOnIPAddressChanged) {
    863   Request* req = CreateRequest("host1", 70);
    864   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
    865 
    866   EXPECT_TRUE(proc_->WaitFor(1u));
    867   // Triggering an IP address change.
    868   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
    869   base::MessageLoop::current()->RunUntilIdle();  // Notification happens async.
    870   proc_->SignalAll();
    871 
    872   EXPECT_EQ(ERR_NETWORK_CHANGED, req->WaitForResult());
    873   EXPECT_EQ(0u, resolver_->GetHostCache()->size());
    874 }
    875 
    876 // Obey pool constraints after IP address has changed.
    877 TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) {
    878   // Runs at most one job at a time.
    879   CreateSerialResolver();
    880   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a")->Resolve());
    881   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b")->Resolve());
    882   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("c")->Resolve());
    883 
    884   EXPECT_TRUE(proc_->WaitFor(1u));
    885   // Triggering an IP address change.
    886   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
    887   base::MessageLoop::current()->RunUntilIdle();  // Notification happens async.
    888   proc_->SignalMultiple(3u);  // Let the false-start go so that we can catch it.
    889 
    890   EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->WaitForResult());
    891 
    892   EXPECT_EQ(1u, num_running_jobs());
    893 
    894   EXPECT_FALSE(requests_[1]->completed());
    895   EXPECT_FALSE(requests_[2]->completed());
    896 
    897   EXPECT_EQ(OK, requests_[2]->WaitForResult());
    898   EXPECT_EQ(OK, requests_[1]->result());
    899 }
    900 
    901 // Tests that a new Request made from the callback of a previously aborted one
    902 // will not be aborted.
    903 TEST_F(HostResolverImplTest, AbortOnlyExistingRequestsOnIPAddressChange) {
    904   struct MyHandler : public Handler {
    905     virtual void Handle(Request* req) OVERRIDE {
    906       // Start new request for a different hostname to ensure that the order
    907       // of jobs in HostResolverImpl is not stable.
    908       std::string hostname;
    909       if (req->index() == 0)
    910         hostname = "zzz";
    911       else if (req->index() == 1)
    912         hostname = "aaa";
    913       else if (req->index() == 2)
    914         hostname = "eee";
    915       else
    916         return;  // A request started from within MyHandler.
    917       EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname)->Resolve()) << hostname;
    918     }
    919   };
    920   set_handler(new MyHandler());
    921 
    922   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("bbb")->Resolve());
    923   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("eee")->Resolve());
    924   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ccc")->Resolve());
    925 
    926   // Wait until all are blocked;
    927   EXPECT_TRUE(proc_->WaitFor(3u));
    928   // Trigger an IP address change.
    929   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
    930   // This should abort all running jobs.
    931   base::MessageLoop::current()->RunUntilIdle();
    932   EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->result());
    933   EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[1]->result());
    934   EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[2]->result());
    935   ASSERT_EQ(6u, requests_.size());
    936   // Unblock all calls to proc.
    937   proc_->SignalMultiple(requests_.size());
    938   // Run until the re-started requests finish.
    939   EXPECT_EQ(OK, requests_[3]->WaitForResult());
    940   EXPECT_EQ(OK, requests_[4]->WaitForResult());
    941   EXPECT_EQ(OK, requests_[5]->WaitForResult());
    942   // Verify that results of aborted Jobs were not cached.
    943   EXPECT_EQ(6u, proc_->GetCaptureList().size());
    944   EXPECT_EQ(3u, resolver_->GetHostCache()->size());
    945 }
    946 
    947 // Tests that when the maximum threads is set to 1, requests are dequeued
    948 // in order of priority.
    949 TEST_F(HostResolverImplTest, HigherPriorityRequestsStartedFirst) {
    950   CreateSerialResolver();
    951 
    952   // Note that at this point the MockHostResolverProc is blocked, so any
    953   // requests we make will not complete.
    954   CreateRequest("req0", 80, LOW);
    955   CreateRequest("req1", 80, MEDIUM);
    956   CreateRequest("req2", 80, MEDIUM);
    957   CreateRequest("req3", 80, LOW);
    958   CreateRequest("req4", 80, HIGHEST);
    959   CreateRequest("req5", 80, LOW);
    960   CreateRequest("req6", 80, LOW);
    961   CreateRequest("req5", 80, HIGHEST);
    962 
    963   for (size_t i = 0; i < requests_.size(); ++i) {
    964     EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i;
    965   }
    966 
    967   // Unblock the resolver thread so the requests can run.
    968   proc_->SignalMultiple(requests_.size());  // More than needed.
    969 
    970   // Wait for all the requests to complete succesfully.
    971   for (size_t i = 0; i < requests_.size(); ++i) {
    972     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
    973   }
    974 
    975   // Since we have restricted to a single concurrent thread in the jobpool,
    976   // the requests should complete in order of priority (with the exception
    977   // of the first request, which gets started right away, since there is
    978   // nothing outstanding).
    979   MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
    980   ASSERT_EQ(7u, capture_list.size());
    981 
    982   EXPECT_EQ("req0", capture_list[0].hostname);
    983   EXPECT_EQ("req4", capture_list[1].hostname);
    984   EXPECT_EQ("req5", capture_list[2].hostname);
    985   EXPECT_EQ("req1", capture_list[3].hostname);
    986   EXPECT_EQ("req2", capture_list[4].hostname);
    987   EXPECT_EQ("req3", capture_list[5].hostname);
    988   EXPECT_EQ("req6", capture_list[6].hostname);
    989 }
    990 
    991 // Try cancelling a job which has not started yet.
    992 TEST_F(HostResolverImplTest, CancelPendingRequest) {
    993   CreateSerialResolver();
    994 
    995   CreateRequest("req0", 80, LOWEST);
    996   CreateRequest("req1", 80, HIGHEST);  // Will cancel.
    997   CreateRequest("req2", 80, MEDIUM);
    998   CreateRequest("req3", 80, LOW);
    999   CreateRequest("req4", 80, HIGHEST);  // Will cancel.
   1000   CreateRequest("req5", 80, LOWEST);   // Will cancel.
   1001   CreateRequest("req6", 80, MEDIUM);
   1002 
   1003   // Start all of the requests.
   1004   for (size_t i = 0; i < requests_.size(); ++i) {
   1005     EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i;
   1006   }
   1007 
   1008   // Cancel some requests
   1009   requests_[1]->Cancel();
   1010   requests_[4]->Cancel();
   1011   requests_[5]->Cancel();
   1012 
   1013   // Unblock the resolver thread so the requests can run.
   1014   proc_->SignalMultiple(requests_.size());  // More than needed.
   1015 
   1016   // Wait for all the requests to complete succesfully.
   1017   for (size_t i = 0; i < requests_.size(); ++i) {
   1018     if (!requests_[i]->pending())
   1019       continue;  // Don't wait for the requests we cancelled.
   1020     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
   1021   }
   1022 
   1023   // Verify that they called out the the resolver proc (which runs on the
   1024   // resolver thread) in the expected order.
   1025   MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
   1026   ASSERT_EQ(4u, capture_list.size());
   1027 
   1028   EXPECT_EQ("req0", capture_list[0].hostname);
   1029   EXPECT_EQ("req2", capture_list[1].hostname);
   1030   EXPECT_EQ("req6", capture_list[2].hostname);
   1031   EXPECT_EQ("req3", capture_list[3].hostname);
   1032 }
   1033 
   1034 // Test that when too many requests are enqueued, old ones start to be aborted.
   1035 TEST_F(HostResolverImplTest, QueueOverflow) {
   1036   CreateSerialResolver();
   1037 
   1038   // Allow only 3 queued jobs.
   1039   const size_t kMaxPendingJobs = 3u;
   1040   resolver_->SetMaxQueuedJobs(kMaxPendingJobs);
   1041 
   1042   // Note that at this point the MockHostResolverProc is blocked, so any
   1043   // requests we make will not complete.
   1044 
   1045   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req0", 80, LOWEST)->Resolve());
   1046   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req1", 80, HIGHEST)->Resolve());
   1047   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req2", 80, MEDIUM)->Resolve());
   1048   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req3", 80, MEDIUM)->Resolve());
   1049 
   1050   // At this point, there are 3 enqueued jobs.
   1051   // Insertion of subsequent requests will cause evictions
   1052   // based on priority.
   1053 
   1054   EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE,
   1055             CreateRequest("req4", 80, LOW)->Resolve());  // Evicts itself!
   1056 
   1057   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req5", 80, MEDIUM)->Resolve());
   1058   EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, requests_[2]->result());
   1059   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req6", 80, HIGHEST)->Resolve());
   1060   EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, requests_[3]->result());
   1061   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req7", 80, MEDIUM)->Resolve());
   1062   EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, requests_[5]->result());
   1063 
   1064   // Unblock the resolver thread so the requests can run.
   1065   proc_->SignalMultiple(4u);
   1066 
   1067   // The rest should succeed.
   1068   EXPECT_EQ(OK, requests_[7]->WaitForResult());
   1069   EXPECT_EQ(OK, requests_[0]->result());
   1070   EXPECT_EQ(OK, requests_[1]->result());
   1071   EXPECT_EQ(OK, requests_[6]->result());
   1072 
   1073   // Verify that they called out the the resolver proc (which runs on the
   1074   // resolver thread) in the expected order.
   1075   MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
   1076   ASSERT_EQ(4u, capture_list.size());
   1077 
   1078   EXPECT_EQ("req0", capture_list[0].hostname);
   1079   EXPECT_EQ("req1", capture_list[1].hostname);
   1080   EXPECT_EQ("req6", capture_list[2].hostname);
   1081   EXPECT_EQ("req7", capture_list[3].hostname);
   1082 
   1083   // Verify that the evicted (incomplete) requests were not cached.
   1084   EXPECT_EQ(4u, resolver_->GetHostCache()->size());
   1085 
   1086   for (size_t i = 0; i < requests_.size(); ++i) {
   1087     EXPECT_TRUE(requests_[i]->completed()) << i;
   1088   }
   1089 }
   1090 
   1091 // Tests that after changing the default AddressFamily to IPV4, requests
   1092 // with UNSPECIFIED address family map to IPV4.
   1093 TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv4) {
   1094   CreateSerialResolver();  // To guarantee order of resolutions.
   1095 
   1096   proc_->AddRule("h1", ADDRESS_FAMILY_IPV4, "1.0.0.1");
   1097   proc_->AddRule("h1", ADDRESS_FAMILY_IPV6, "::2");
   1098 
   1099   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
   1100 
   1101   CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_UNSPECIFIED);
   1102   CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV4);
   1103   CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV6);
   1104 
   1105   // Start all of the requests.
   1106   for (size_t i = 0; i < requests_.size(); ++i) {
   1107     EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i;
   1108   }
   1109 
   1110   proc_->SignalMultiple(requests_.size());
   1111 
   1112   // Wait for all the requests to complete.
   1113   for (size_t i = 0u; i < requests_.size(); ++i) {
   1114     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
   1115   }
   1116 
   1117   // Since the requests all had the same priority and we limited the thread
   1118   // count to 1, they should have completed in the same order as they were
   1119   // requested. Moreover, request0 and request1 will have been serviced by
   1120   // the same job.
   1121 
   1122   MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
   1123   ASSERT_EQ(2u, capture_list.size());
   1124 
   1125   EXPECT_EQ("h1", capture_list[0].hostname);
   1126   EXPECT_EQ(ADDRESS_FAMILY_IPV4, capture_list[0].address_family);
   1127 
   1128   EXPECT_EQ("h1", capture_list[1].hostname);
   1129   EXPECT_EQ(ADDRESS_FAMILY_IPV6, capture_list[1].address_family);
   1130 
   1131   // Now check that the correct resolved IP addresses were returned.
   1132   EXPECT_TRUE(requests_[0]->HasOneAddress("1.0.0.1", 80));
   1133   EXPECT_TRUE(requests_[1]->HasOneAddress("1.0.0.1", 80));
   1134   EXPECT_TRUE(requests_[2]->HasOneAddress("::2", 80));
   1135 }
   1136 
   1137 // This is the exact same test as SetDefaultAddressFamily_IPv4, except the
   1138 // default family is set to IPv6 and the family of requests is flipped where
   1139 // specified.
   1140 TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv6) {
   1141   CreateSerialResolver();  // To guarantee order of resolutions.
   1142 
   1143   // Don't use IPv6 replacements here since some systems don't support it.
   1144   proc_->AddRule("h1", ADDRESS_FAMILY_IPV4, "1.0.0.1");
   1145   proc_->AddRule("h1", ADDRESS_FAMILY_IPV6, "::2");
   1146 
   1147   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV6);
   1148 
   1149   CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_UNSPECIFIED);
   1150   CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV6);
   1151   CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV4);
   1152 
   1153   // Start all of the requests.
   1154   for (size_t i = 0; i < requests_.size(); ++i) {
   1155     EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i;
   1156   }
   1157 
   1158   proc_->SignalMultiple(requests_.size());
   1159 
   1160   // Wait for all the requests to complete.
   1161   for (size_t i = 0u; i < requests_.size(); ++i) {
   1162     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
   1163   }
   1164 
   1165   // Since the requests all had the same priority and we limited the thread
   1166   // count to 1, they should have completed in the same order as they were
   1167   // requested. Moreover, request0 and request1 will have been serviced by
   1168   // the same job.
   1169 
   1170   MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
   1171   ASSERT_EQ(2u, capture_list.size());
   1172 
   1173   EXPECT_EQ("h1", capture_list[0].hostname);
   1174   EXPECT_EQ(ADDRESS_FAMILY_IPV6, capture_list[0].address_family);
   1175 
   1176   EXPECT_EQ("h1", capture_list[1].hostname);
   1177   EXPECT_EQ(ADDRESS_FAMILY_IPV4, capture_list[1].address_family);
   1178 
   1179   // Now check that the correct resolved IP addresses were returned.
   1180   EXPECT_TRUE(requests_[0]->HasOneAddress("::2", 80));
   1181   EXPECT_TRUE(requests_[1]->HasOneAddress("::2", 80));
   1182   EXPECT_TRUE(requests_[2]->HasOneAddress("1.0.0.1", 80));
   1183 }
   1184 
   1185 TEST_F(HostResolverImplTest, ResolveFromCache) {
   1186   proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
   1187   proc_->SignalMultiple(1u);  // Need only one.
   1188 
   1189   HostResolver::RequestInfo info(HostPortPair("just.testing", 80));
   1190 
   1191   // First hit will miss the cache.
   1192   EXPECT_EQ(ERR_DNS_CACHE_MISS, CreateRequest(info)->ResolveFromCache());
   1193 
   1194   // This time, we fetch normally.
   1195   EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info)->Resolve());
   1196   EXPECT_EQ(OK, requests_[1]->WaitForResult());
   1197 
   1198   // Now we should be able to fetch from the cache.
   1199   EXPECT_EQ(OK, CreateRequest(info)->ResolveFromCache());
   1200   EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.1.42", 80));
   1201 }
   1202 
   1203 // Test the retry attempts simulating host resolver proc that takes too long.
   1204 TEST_F(HostResolverImplTest, MultipleAttempts) {
   1205   // Total number of attempts would be 3 and we want the 3rd attempt to resolve
   1206   // the host. First and second attempt will be forced to sleep until they get
   1207   // word that a resolution has completed. The 3rd resolution attempt will try
   1208   // to get done ASAP, and won't sleep..
   1209   int kAttemptNumberToResolve = 3;
   1210   int kTotalAttempts = 3;
   1211 
   1212   scoped_refptr<LookupAttemptHostResolverProc> resolver_proc(
   1213       new LookupAttemptHostResolverProc(
   1214           NULL, kAttemptNumberToResolve, kTotalAttempts));
   1215 
   1216   HostResolverImpl::ProcTaskParams params = DefaultParams(resolver_proc.get());
   1217 
   1218   // Specify smaller interval for unresponsive_delay_ for HostResolverImpl so
   1219   // that unit test runs faster. For example, this test finishes in 1.5 secs
   1220   // (500ms * 3).
   1221   params.unresponsive_delay = base::TimeDelta::FromMilliseconds(500);
   1222 
   1223   resolver_.reset(
   1224       new HostResolverImpl(HostCache::CreateDefaultCache(),
   1225                            DefaultLimits(),
   1226                            params,
   1227                            NULL));
   1228 
   1229   // Resolve "host1".
   1230   HostResolver::RequestInfo info(HostPortPair("host1", 70));
   1231   Request* req = CreateRequest(info);
   1232   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
   1233 
   1234   // Resolve returns -4 to indicate that 3rd attempt has resolved the host.
   1235   EXPECT_EQ(-4, req->WaitForResult());
   1236 
   1237   resolver_proc->WaitForAllAttemptsToFinish(
   1238       base::TimeDelta::FromMilliseconds(60000));
   1239   base::MessageLoop::current()->RunUntilIdle();
   1240 
   1241   EXPECT_EQ(resolver_proc->total_attempts_resolved(), kTotalAttempts);
   1242   EXPECT_EQ(resolver_proc->resolved_attempt_number(), kAttemptNumberToResolve);
   1243 }
   1244 
   1245 DnsConfig CreateValidDnsConfig() {
   1246   IPAddressNumber dns_ip;
   1247   bool rv = ParseIPLiteralToNumber("192.168.1.0", &dns_ip);
   1248   EXPECT_TRUE(rv);
   1249 
   1250   DnsConfig config;
   1251   config.nameservers.push_back(IPEndPoint(dns_ip, dns_protocol::kDefaultPort));
   1252   EXPECT_TRUE(config.IsValid());
   1253   return config;
   1254 }
   1255 
   1256 // Specialized fixture for tests of DnsTask.
   1257 class HostResolverImplDnsTest : public HostResolverImplTest {
   1258  protected:
   1259   virtual void SetUp() OVERRIDE {
   1260     AddDnsRule("nx", dns_protocol::kTypeA, MockDnsClientRule::FAIL);
   1261     AddDnsRule("nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL);
   1262     AddDnsRule("ok", dns_protocol::kTypeA, MockDnsClientRule::OK);
   1263     AddDnsRule("ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK);
   1264     AddDnsRule("4ok", dns_protocol::kTypeA, MockDnsClientRule::OK);
   1265     AddDnsRule("4ok", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY);
   1266     AddDnsRule("6ok", dns_protocol::kTypeA, MockDnsClientRule::EMPTY);
   1267     AddDnsRule("6ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK);
   1268     AddDnsRule("4nx", dns_protocol::kTypeA, MockDnsClientRule::OK);
   1269     AddDnsRule("4nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL);
   1270     CreateResolver();
   1271   }
   1272 
   1273   void CreateResolver() {
   1274     resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
   1275                                          DefaultLimits(),
   1276                                          DefaultParams(proc_.get()),
   1277                                          NULL));
   1278     // Disable IPv6 support probing.
   1279     resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   1280     resolver_->SetDnsClient(CreateMockDnsClient(DnsConfig(), dns_rules_));
   1281   }
   1282 
   1283   // Adds a rule to |dns_rules_|. Must be followed by |CreateResolver| to apply.
   1284   void AddDnsRule(const std::string& prefix,
   1285                   uint16 qtype,
   1286                   MockDnsClientRule::Result result) {
   1287     dns_rules_.push_back(MockDnsClientRule(prefix, qtype, result));
   1288   }
   1289 
   1290   void ChangeDnsConfig(const DnsConfig& config) {
   1291     NetworkChangeNotifier::SetDnsConfig(config);
   1292     // Notification is delivered asynchronously.
   1293     base::MessageLoop::current()->RunUntilIdle();
   1294   }
   1295 
   1296   MockDnsClientRuleList dns_rules_;
   1297 };
   1298 
   1299 // TODO(szym): Test AbortAllInProgressJobs due to DnsConfig change.
   1300 
   1301 // TODO(cbentzel): Test a mix of requests with different HostResolverFlags.
   1302 
   1303 // Test successful and fallback resolutions in HostResolverImpl::DnsTask.
   1304 TEST_F(HostResolverImplDnsTest, DnsTask) {
   1305   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
   1306 
   1307   proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102");
   1308   // All other hostnames will fail in proc_.
   1309 
   1310   // Initially there is no config, so client should not be invoked.
   1311   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());
   1312   proc_->SignalMultiple(requests_.size());
   1313 
   1314   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[0]->WaitForResult());
   1315 
   1316   ChangeDnsConfig(CreateValidDnsConfig());
   1317 
   1318   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());
   1319   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_fail", 80)->Resolve());
   1320   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_succeed", 80)->Resolve());
   1321 
   1322   proc_->SignalMultiple(requests_.size());
   1323 
   1324   for (size_t i = 1; i < requests_.size(); ++i)
   1325     EXPECT_NE(ERR_UNEXPECTED, requests_[i]->WaitForResult()) << i;
   1326 
   1327   EXPECT_EQ(OK, requests_[1]->result());
   1328   // Resolved by MockDnsClient.
   1329   EXPECT_TRUE(requests_[1]->HasOneAddress("127.0.0.1", 80));
   1330   // Fallback to ProcTask.
   1331   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[2]->result());
   1332   EXPECT_EQ(OK, requests_[3]->result());
   1333   EXPECT_TRUE(requests_[3]->HasOneAddress("192.168.1.102", 80));
   1334 }
   1335 
   1336 // Test successful and failing resolutions in HostResolverImpl::DnsTask when
   1337 // fallback to ProcTask is disabled.
   1338 TEST_F(HostResolverImplDnsTest, NoFallbackToProcTask) {
   1339   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
   1340   set_fallback_to_proctask(false);
   1341 
   1342   proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102");
   1343   // All other hostnames will fail in proc_.
   1344 
   1345   // Set empty DnsConfig.
   1346   ChangeDnsConfig(DnsConfig());
   1347   // Initially there is no config, so client should not be invoked.
   1348   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());
   1349   // There is no config, so fallback to ProcTask must work.
   1350   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_succeed", 80)->Resolve());
   1351   proc_->SignalMultiple(requests_.size());
   1352 
   1353   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[0]->WaitForResult());
   1354   EXPECT_EQ(OK, requests_[1]->WaitForResult());
   1355   EXPECT_TRUE(requests_[1]->HasOneAddress("192.168.1.102", 80));
   1356 
   1357   ChangeDnsConfig(CreateValidDnsConfig());
   1358 
   1359   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_abort", 80)->Resolve());
   1360   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80)->Resolve());
   1361 
   1362   // Simulate the case when the preference or policy has disabled the DNS client
   1363   // causing AbortDnsTasks.
   1364   resolver_->SetDnsClient(CreateMockDnsClient(DnsConfig(), dns_rules_));
   1365   ChangeDnsConfig(CreateValidDnsConfig());
   1366 
   1367   // First request is resolved by MockDnsClient, others should fail due to
   1368   // disabled fallback to ProcTask.
   1369   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());
   1370   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_fail", 80)->Resolve());
   1371   proc_->SignalMultiple(requests_.size());
   1372 
   1373   // Aborted due to Network Change.
   1374   EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[2]->WaitForResult());
   1375   EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[3]->WaitForResult());
   1376   // Resolved by MockDnsClient.
   1377   EXPECT_EQ(OK, requests_[4]->WaitForResult());
   1378   EXPECT_TRUE(requests_[4]->HasOneAddress("127.0.0.1", 80));
   1379   // Fallback to ProcTask is disabled.
   1380   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[5]->WaitForResult());
   1381 }
   1382 
   1383 // Test behavior of OnDnsTaskFailure when Job is aborted.
   1384 TEST_F(HostResolverImplDnsTest, OnDnsTaskFailureAbortedJob) {
   1385   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
   1386   ChangeDnsConfig(CreateValidDnsConfig());
   1387   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80)->Resolve());
   1388   // Abort all jobs here.
   1389   CreateResolver();
   1390   proc_->SignalMultiple(requests_.size());
   1391   // Run to completion.
   1392   base::MessageLoop::current()->RunUntilIdle();  // Notification happens async.
   1393   // It shouldn't crash during OnDnsTaskFailure callbacks.
   1394   EXPECT_EQ(ERR_IO_PENDING, requests_[0]->result());
   1395 
   1396   // Repeat test with Fallback to ProcTask disabled
   1397   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
   1398   set_fallback_to_proctask(false);
   1399   ChangeDnsConfig(CreateValidDnsConfig());
   1400   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80)->Resolve());
   1401   // Abort all jobs here.
   1402   CreateResolver();
   1403   // Run to completion.
   1404   base::MessageLoop::current()->RunUntilIdle();  // Notification happens async.
   1405   // It shouldn't crash during OnDnsTaskFailure callbacks.
   1406   EXPECT_EQ(ERR_IO_PENDING, requests_[1]->result());
   1407 }
   1408 
   1409 TEST_F(HostResolverImplDnsTest, DnsTaskUnspec) {
   1410   ChangeDnsConfig(CreateValidDnsConfig());
   1411 
   1412   proc_->AddRuleForAllFamilies("4nx", "192.168.1.101");
   1413   // All other hostnames will fail in proc_.
   1414 
   1415   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
   1416   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4ok", 80)->Resolve());
   1417   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("6ok", 80)->Resolve());
   1418   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4nx", 80)->Resolve());
   1419 
   1420   proc_->SignalMultiple(requests_.size());
   1421 
   1422   for (size_t i = 0; i < requests_.size(); ++i)
   1423     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
   1424 
   1425   EXPECT_EQ(2u, requests_[0]->NumberOfAddresses());
   1426   EXPECT_TRUE(requests_[0]->HasAddress("127.0.0.1", 80));
   1427   EXPECT_TRUE(requests_[0]->HasAddress("::1", 80));
   1428   EXPECT_EQ(1u, requests_[1]->NumberOfAddresses());
   1429   EXPECT_TRUE(requests_[1]->HasAddress("127.0.0.1", 80));
   1430   EXPECT_EQ(1u, requests_[2]->NumberOfAddresses());
   1431   EXPECT_TRUE(requests_[2]->HasAddress("::1", 80));
   1432   EXPECT_EQ(1u, requests_[3]->NumberOfAddresses());
   1433   EXPECT_TRUE(requests_[3]->HasAddress("192.168.1.101", 80));
   1434 }
   1435 
   1436 TEST_F(HostResolverImplDnsTest, ServeFromHosts) {
   1437   // Initially, use empty HOSTS file.
   1438   DnsConfig config = CreateValidDnsConfig();
   1439   ChangeDnsConfig(config);
   1440 
   1441   proc_->AddRuleForAllFamilies(std::string(),
   1442                                std::string());  // Default to failures.
   1443   proc_->SignalMultiple(1u);  // For the first request which misses.
   1444 
   1445   Request* req0 = CreateRequest("nx_ipv4", 80);
   1446   EXPECT_EQ(ERR_IO_PENDING, req0->Resolve());
   1447   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req0->WaitForResult());
   1448 
   1449   IPAddressNumber local_ipv4, local_ipv6;
   1450   ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &local_ipv4));
   1451   ASSERT_TRUE(ParseIPLiteralToNumber("::1", &local_ipv6));
   1452 
   1453   DnsHosts hosts;
   1454   hosts[DnsHostsKey("nx_ipv4", ADDRESS_FAMILY_IPV4)] = local_ipv4;
   1455   hosts[DnsHostsKey("nx_ipv6", ADDRESS_FAMILY_IPV6)] = local_ipv6;
   1456   hosts[DnsHostsKey("nx_both", ADDRESS_FAMILY_IPV4)] = local_ipv4;
   1457   hosts[DnsHostsKey("nx_both", ADDRESS_FAMILY_IPV6)] = local_ipv6;
   1458 
   1459   // Update HOSTS file.
   1460   config.hosts = hosts;
   1461   ChangeDnsConfig(config);
   1462 
   1463   Request* req1 = CreateRequest("nx_ipv4", 80);
   1464   EXPECT_EQ(OK, req1->Resolve());
   1465   EXPECT_TRUE(req1->HasOneAddress("127.0.0.1", 80));
   1466 
   1467   Request* req2 = CreateRequest("nx_ipv6", 80);
   1468   EXPECT_EQ(OK, req2->Resolve());
   1469   EXPECT_TRUE(req2->HasOneAddress("::1", 80));
   1470 
   1471   Request* req3 = CreateRequest("nx_both", 80);
   1472   EXPECT_EQ(OK, req3->Resolve());
   1473   EXPECT_TRUE(req3->HasAddress("127.0.0.1", 80) &&
   1474               req3->HasAddress("::1", 80));
   1475 
   1476   // Requests with specified AddressFamily.
   1477   Request* req4 = CreateRequest("nx_ipv4", 80, MEDIUM, ADDRESS_FAMILY_IPV4);
   1478   EXPECT_EQ(OK, req4->Resolve());
   1479   EXPECT_TRUE(req4->HasOneAddress("127.0.0.1", 80));
   1480 
   1481   Request* req5 = CreateRequest("nx_ipv6", 80, MEDIUM, ADDRESS_FAMILY_IPV6);
   1482   EXPECT_EQ(OK, req5->Resolve());
   1483   EXPECT_TRUE(req5->HasOneAddress("::1", 80));
   1484 
   1485   // Request with upper case.
   1486   Request* req6 = CreateRequest("nx_IPV4", 80);
   1487   EXPECT_EQ(OK, req6->Resolve());
   1488   EXPECT_TRUE(req6->HasOneAddress("127.0.0.1", 80));
   1489 }
   1490 
   1491 TEST_F(HostResolverImplDnsTest, BypassDnsTask) {
   1492   ChangeDnsConfig(CreateValidDnsConfig());
   1493 
   1494   proc_->AddRuleForAllFamilies(std::string(),
   1495                                std::string());  // Default to failures.
   1496 
   1497   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok.local", 80)->Resolve());
   1498   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok.local.", 80)->Resolve());
   1499   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("oklocal", 80)->Resolve());
   1500   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("oklocal.", 80)->Resolve());
   1501   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
   1502 
   1503   proc_->SignalMultiple(requests_.size());
   1504 
   1505   for (size_t i = 0; i < 2; ++i)
   1506     EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[i]->WaitForResult()) << i;
   1507 
   1508   for (size_t i = 2; i < requests_.size(); ++i)
   1509     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
   1510 }
   1511 
   1512 TEST_F(HostResolverImplDnsTest, DisableDnsClientOnPersistentFailure) {
   1513   ChangeDnsConfig(CreateValidDnsConfig());
   1514 
   1515   proc_->AddRuleForAllFamilies(std::string(),
   1516                                std::string());  // Default to failures.
   1517 
   1518   // Check that DnsTask works.
   1519   Request* req = CreateRequest("ok_1", 80);
   1520   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
   1521   EXPECT_EQ(OK, req->WaitForResult());
   1522 
   1523   for (unsigned i = 0; i < 20; ++i) {
   1524     // Use custom names to require separate Jobs.
   1525     std::string hostname = base::StringPrintf("nx_%u", i);
   1526     // Ensure fallback to ProcTask succeeds.
   1527     proc_->AddRuleForAllFamilies(hostname, "192.168.1.101");
   1528     EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 80)->Resolve()) << i;
   1529   }
   1530 
   1531   proc_->SignalMultiple(requests_.size());
   1532 
   1533   for (size_t i = 0; i < requests_.size(); ++i)
   1534     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
   1535 
   1536   ASSERT_FALSE(proc_->HasBlockedRequests());
   1537 
   1538   // DnsTask should be disabled by now.
   1539   req = CreateRequest("ok_2", 80);
   1540   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
   1541   proc_->SignalMultiple(1u);
   1542   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult());
   1543 
   1544   // Check that it is re-enabled after DNS change.
   1545   ChangeDnsConfig(CreateValidDnsConfig());
   1546   req = CreateRequest("ok_3", 80);
   1547   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
   1548   EXPECT_EQ(OK, req->WaitForResult());
   1549 }
   1550 
   1551 TEST_F(HostResolverImplDnsTest, DontDisableDnsClientOnSporadicFailure) {
   1552   ChangeDnsConfig(CreateValidDnsConfig());
   1553 
   1554   // |proc_| defaults to successes.
   1555 
   1556   // 20 failures interleaved with 20 successes.
   1557   for (unsigned i = 0; i < 40; ++i) {
   1558     // Use custom names to require separate Jobs.
   1559     std::string hostname = (i % 2) == 0 ? base::StringPrintf("nx_%u", i)
   1560                                         : base::StringPrintf("ok_%u", i);
   1561     EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 80)->Resolve()) << i;
   1562   }
   1563 
   1564   proc_->SignalMultiple(requests_.size());
   1565 
   1566   for (size_t i = 0; i < requests_.size(); ++i)
   1567     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
   1568 
   1569   // Make |proc_| default to failures.
   1570   proc_->AddRuleForAllFamilies(std::string(), std::string());
   1571 
   1572   // DnsTask should still be enabled.
   1573   Request* req = CreateRequest("ok_last", 80);
   1574   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
   1575   EXPECT_EQ(OK, req->WaitForResult());
   1576 }
   1577 
   1578 // Confirm that resolving "localhost" is unrestricted even if there are no
   1579 // global IPv6 address. See SystemHostResolverCall for rationale.
   1580 // Test both the DnsClient and system host resolver paths.
   1581 TEST_F(HostResolverImplDnsTest, DualFamilyLocalhost) {
   1582   // Use regular SystemHostResolverCall!
   1583   scoped_refptr<HostResolverProc> proc(new SystemHostResolverProc());
   1584   resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
   1585                                        DefaultLimits(),
   1586                                        DefaultParams(proc.get()),
   1587                                        NULL));
   1588   resolver_->SetDnsClient(CreateMockDnsClient(DnsConfig(), dns_rules_));
   1589   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
   1590 
   1591   // Get the expected output.
   1592   AddressList addrlist;
   1593   int rv = proc->Resolve("localhost", ADDRESS_FAMILY_UNSPECIFIED, 0, &addrlist,
   1594                          NULL);
   1595   if (rv != OK)
   1596     return;
   1597 
   1598   for (unsigned i = 0; i < addrlist.size(); ++i)
   1599     LOG(WARNING) << addrlist[i].ToString();
   1600 
   1601   bool saw_ipv4 = AddressListContains(addrlist, "127.0.0.1", 0);
   1602   bool saw_ipv6 = AddressListContains(addrlist, "::1", 0);
   1603   if (!saw_ipv4 && !saw_ipv6)
   1604     return;
   1605 
   1606   HostResolver::RequestInfo info(HostPortPair("localhost", 80));
   1607   info.set_address_family(ADDRESS_FAMILY_UNSPECIFIED);
   1608   info.set_host_resolver_flags(HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6);
   1609 
   1610   // Try without DnsClient.
   1611   ChangeDnsConfig(DnsConfig());
   1612   Request* req = CreateRequest(info);
   1613   // It is resolved via getaddrinfo, so expect asynchronous result.
   1614   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
   1615   EXPECT_EQ(OK, req->WaitForResult());
   1616 
   1617   EXPECT_EQ(saw_ipv4, req->HasAddress("127.0.0.1", 80));
   1618   EXPECT_EQ(saw_ipv6, req->HasAddress("::1", 80));
   1619 
   1620   // Configure DnsClient with dual-host HOSTS file.
   1621   DnsConfig config = CreateValidDnsConfig();
   1622   DnsHosts hosts;
   1623   IPAddressNumber local_ipv4, local_ipv6;
   1624   ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &local_ipv4));
   1625   ASSERT_TRUE(ParseIPLiteralToNumber("::1", &local_ipv6));
   1626   if (saw_ipv4)
   1627     hosts[DnsHostsKey("localhost", ADDRESS_FAMILY_IPV4)] = local_ipv4;
   1628   if (saw_ipv6)
   1629     hosts[DnsHostsKey("localhost", ADDRESS_FAMILY_IPV6)] = local_ipv6;
   1630   config.hosts = hosts;
   1631 
   1632   ChangeDnsConfig(config);
   1633   req = CreateRequest(info);
   1634   // Expect synchronous resolution from DnsHosts.
   1635   EXPECT_EQ(OK, req->Resolve());
   1636 
   1637   EXPECT_EQ(saw_ipv4, req->HasAddress("127.0.0.1", 80));
   1638   EXPECT_EQ(saw_ipv6, req->HasAddress("::1", 80));
   1639 }
   1640 
   1641 }  // namespace net
   1642