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/run_loop.h"
16#include "base/strings/string_util.h"
17#include "base/strings/stringprintf.h"
18#include "base/synchronization/condition_variable.h"
19#include "base/synchronization/lock.h"
20#include "base/test/test_timeouts.h"
21#include "base/time/time.h"
22#include "net/base/address_list.h"
23#include "net/base/net_errors.h"
24#include "net/base/net_util.h"
25#include "net/dns/dns_client.h"
26#include "net/dns/dns_test_util.h"
27#include "net/dns/mock_host_resolver.h"
28#include "testing/gtest/include/gtest/gtest.h"
29
30namespace net {
31
32namespace {
33
34const size_t kMaxJobs = 10u;
35const size_t kMaxRetryAttempts = 4u;
36
37HostResolver::Options DefaultOptions() {
38  HostResolver::Options options;
39  options.max_concurrent_resolves = kMaxJobs;
40  options.max_retry_attempts = kMaxRetryAttempts;
41  options.enable_caching = true;
42  return options;
43}
44
45HostResolverImpl::ProcTaskParams DefaultParams(
46    HostResolverProc* resolver_proc) {
47  return HostResolverImpl::ProcTaskParams(resolver_proc, kMaxRetryAttempts);
48}
49
50// A HostResolverProc that pushes each host mapped into a list and allows
51// waiting for a specific number of requests. Unlike RuleBasedHostResolverProc
52// it never calls SystemHostResolverCall. By default resolves all hostnames to
53// "127.0.0.1". After AddRule(), it resolves only names explicitly specified.
54class MockHostResolverProc : public HostResolverProc {
55 public:
56  struct ResolveKey {
57    ResolveKey(const std::string& hostname, AddressFamily address_family)
58        : hostname(hostname), address_family(address_family) {}
59    bool operator<(const ResolveKey& other) const {
60      return address_family < other.address_family ||
61          (address_family == other.address_family && hostname < other.hostname);
62    }
63    std::string hostname;
64    AddressFamily address_family;
65  };
66
67  typedef std::vector<ResolveKey> CaptureList;
68
69  MockHostResolverProc()
70      : HostResolverProc(NULL),
71        num_requests_waiting_(0),
72        num_slots_available_(0),
73        requests_waiting_(&lock_),
74        slots_available_(&lock_) {
75  }
76
77  // Waits until |count| calls to |Resolve| are blocked. Returns false when
78  // timed out.
79  bool WaitFor(unsigned count) {
80    base::AutoLock lock(lock_);
81    base::Time start_time = base::Time::Now();
82    while (num_requests_waiting_ < count) {
83      requests_waiting_.TimedWait(TestTimeouts::action_timeout());
84      if (base::Time::Now() > start_time + TestTimeouts::action_timeout())
85        return false;
86    }
87    return true;
88  }
89
90  // Signals |count| waiting calls to |Resolve|. First come first served.
91  void SignalMultiple(unsigned count) {
92    base::AutoLock lock(lock_);
93    num_slots_available_ += count;
94    slots_available_.Broadcast();
95  }
96
97  // Signals all waiting calls to |Resolve|. Beware of races.
98  void SignalAll() {
99    base::AutoLock lock(lock_);
100    num_slots_available_ = num_requests_waiting_;
101    slots_available_.Broadcast();
102  }
103
104  void AddRule(const std::string& hostname, AddressFamily family,
105               const AddressList& result) {
106    base::AutoLock lock(lock_);
107    rules_[ResolveKey(hostname, family)] = result;
108  }
109
110  void AddRule(const std::string& hostname, AddressFamily family,
111               const std::string& ip_list) {
112    AddressList result;
113    int rv = ParseAddressList(ip_list, std::string(), &result);
114    DCHECK_EQ(OK, rv);
115    AddRule(hostname, family, result);
116  }
117
118  void AddRuleForAllFamilies(const std::string& hostname,
119                             const std::string& ip_list) {
120    AddressList result;
121    int rv = ParseAddressList(ip_list, std::string(), &result);
122    DCHECK_EQ(OK, rv);
123    AddRule(hostname, ADDRESS_FAMILY_UNSPECIFIED, result);
124    AddRule(hostname, ADDRESS_FAMILY_IPV4, result);
125    AddRule(hostname, ADDRESS_FAMILY_IPV6, result);
126  }
127
128  virtual int Resolve(const std::string& hostname,
129                      AddressFamily address_family,
130                      HostResolverFlags host_resolver_flags,
131                      AddressList* addrlist,
132                      int* os_error) OVERRIDE {
133    base::AutoLock lock(lock_);
134    capture_list_.push_back(ResolveKey(hostname, address_family));
135    ++num_requests_waiting_;
136    requests_waiting_.Broadcast();
137    while (!num_slots_available_)
138      slots_available_.Wait();
139    DCHECK_GT(num_requests_waiting_, 0u);
140    --num_slots_available_;
141    --num_requests_waiting_;
142    if (rules_.empty()) {
143      int rv = ParseAddressList("127.0.0.1", std::string(), addrlist);
144      DCHECK_EQ(OK, rv);
145      return OK;
146    }
147    ResolveKey key(hostname, address_family);
148    if (rules_.count(key) == 0)
149      return ERR_NAME_NOT_RESOLVED;
150    *addrlist = rules_[key];
151    return OK;
152  }
153
154  CaptureList GetCaptureList() const {
155    CaptureList copy;
156    {
157      base::AutoLock lock(lock_);
158      copy = capture_list_;
159    }
160    return copy;
161  }
162
163  bool HasBlockedRequests() const {
164    base::AutoLock lock(lock_);
165    return num_requests_waiting_ > num_slots_available_;
166  }
167
168 protected:
169  virtual ~MockHostResolverProc() {}
170
171 private:
172  mutable base::Lock lock_;
173  std::map<ResolveKey, AddressList> rules_;
174  CaptureList capture_list_;
175  unsigned num_requests_waiting_;
176  unsigned num_slots_available_;
177  base::ConditionVariable requests_waiting_;
178  base::ConditionVariable slots_available_;
179
180  DISALLOW_COPY_AND_ASSIGN(MockHostResolverProc);
181};
182
183bool AddressListContains(const AddressList& list, const std::string& address,
184                         int port) {
185  IPAddressNumber ip;
186  bool rv = ParseIPLiteralToNumber(address, &ip);
187  DCHECK(rv);
188  return std::find(list.begin(),
189                   list.end(),
190                   IPEndPoint(ip, port)) != list.end();
191}
192
193// A wrapper for requests to a HostResolver.
194class Request {
195 public:
196  // Base class of handlers to be executed on completion of requests.
197  struct Handler {
198    virtual ~Handler() {}
199    virtual void Handle(Request* request) = 0;
200  };
201
202  Request(const HostResolver::RequestInfo& info,
203          RequestPriority priority,
204          size_t index,
205          HostResolver* resolver,
206          Handler* handler)
207      : info_(info),
208        priority_(priority),
209        index_(index),
210        resolver_(resolver),
211        handler_(handler),
212        quit_on_complete_(false),
213        result_(ERR_UNEXPECTED),
214        handle_(NULL) {}
215
216  int Resolve() {
217    DCHECK(resolver_);
218    DCHECK(!handle_);
219    list_ = AddressList();
220    result_ = resolver_->Resolve(
221        info_,
222        priority_,
223        &list_,
224        base::Bind(&Request::OnComplete, base::Unretained(this)),
225        &handle_,
226        BoundNetLog());
227    if (!list_.empty())
228      EXPECT_EQ(OK, result_);
229    return result_;
230  }
231
232  int ResolveFromCache() {
233    DCHECK(resolver_);
234    DCHECK(!handle_);
235    return resolver_->ResolveFromCache(info_, &list_, BoundNetLog());
236  }
237
238  void Cancel() {
239    DCHECK(resolver_);
240    DCHECK(handle_);
241    resolver_->CancelRequest(handle_);
242    handle_ = NULL;
243  }
244
245  const HostResolver::RequestInfo& info() const { return info_; }
246  size_t index() const { return index_; }
247  const AddressList& list() const { return list_; }
248  int result() const { return result_; }
249  bool completed() const { return result_ != ERR_IO_PENDING; }
250  bool pending() const { return handle_ != NULL; }
251
252  bool HasAddress(const std::string& address, int port) const {
253    return AddressListContains(list_, address, port);
254  }
255
256  // Returns the number of addresses in |list_|.
257  unsigned NumberOfAddresses() const {
258    return list_.size();
259  }
260
261  bool HasOneAddress(const std::string& address, int port) const {
262    return HasAddress(address, port) && (NumberOfAddresses() == 1u);
263  }
264
265  // Returns ERR_UNEXPECTED if timed out.
266  int WaitForResult() {
267    if (completed())
268      return result_;
269    base::CancelableClosure closure(base::MessageLoop::QuitClosure());
270    base::MessageLoop::current()->PostDelayedTask(
271        FROM_HERE, closure.callback(), TestTimeouts::action_max_timeout());
272    quit_on_complete_ = true;
273    base::MessageLoop::current()->Run();
274    bool did_quit = !quit_on_complete_;
275    quit_on_complete_ = false;
276    closure.Cancel();
277    if (did_quit)
278      return result_;
279    else
280      return ERR_UNEXPECTED;
281  }
282
283 private:
284  void OnComplete(int rv) {
285    EXPECT_TRUE(pending());
286    EXPECT_EQ(ERR_IO_PENDING, result_);
287    EXPECT_NE(ERR_IO_PENDING, rv);
288    result_ = rv;
289    handle_ = NULL;
290    if (!list_.empty()) {
291      EXPECT_EQ(OK, result_);
292      EXPECT_EQ(info_.port(), list_.front().port());
293    }
294    if (handler_)
295      handler_->Handle(this);
296    if (quit_on_complete_) {
297      base::MessageLoop::current()->Quit();
298      quit_on_complete_ = false;
299    }
300  }
301
302  HostResolver::RequestInfo info_;
303  RequestPriority priority_;
304  size_t index_;
305  HostResolver* resolver_;
306  Handler* handler_;
307  bool quit_on_complete_;
308
309  AddressList list_;
310  int result_;
311  HostResolver::RequestHandle handle_;
312
313  DISALLOW_COPY_AND_ASSIGN(Request);
314};
315
316// Using LookupAttemptHostResolverProc simulate very long lookups, and control
317// which attempt resolves the host.
318class LookupAttemptHostResolverProc : public HostResolverProc {
319 public:
320  LookupAttemptHostResolverProc(HostResolverProc* previous,
321                                int attempt_number_to_resolve,
322                                int total_attempts)
323      : HostResolverProc(previous),
324        attempt_number_to_resolve_(attempt_number_to_resolve),
325        current_attempt_number_(0),
326        total_attempts_(total_attempts),
327        total_attempts_resolved_(0),
328        resolved_attempt_number_(0),
329        all_done_(&lock_) {
330  }
331
332  // Test harness will wait for all attempts to finish before checking the
333  // results.
334  void WaitForAllAttemptsToFinish(const base::TimeDelta& wait_time) {
335    base::TimeTicks end_time = base::TimeTicks::Now() + wait_time;
336    {
337      base::AutoLock auto_lock(lock_);
338      while (total_attempts_resolved_ != total_attempts_ &&
339          base::TimeTicks::Now() < end_time) {
340        all_done_.TimedWait(end_time - base::TimeTicks::Now());
341      }
342    }
343  }
344
345  // All attempts will wait for an attempt to resolve the host.
346  void WaitForAnAttemptToComplete() {
347    base::TimeDelta wait_time = base::TimeDelta::FromSeconds(60);
348    base::TimeTicks end_time = base::TimeTicks::Now() + wait_time;
349    {
350      base::AutoLock auto_lock(lock_);
351      while (resolved_attempt_number_ == 0 && base::TimeTicks::Now() < end_time)
352        all_done_.TimedWait(end_time - base::TimeTicks::Now());
353    }
354    all_done_.Broadcast();  // Tell all waiting attempts to proceed.
355  }
356
357  // Returns the number of attempts that have finished the Resolve() method.
358  int total_attempts_resolved() { return total_attempts_resolved_; }
359
360  // Returns the first attempt that that has resolved the host.
361  int resolved_attempt_number() { return resolved_attempt_number_; }
362
363  // HostResolverProc methods.
364  virtual int Resolve(const std::string& host,
365                      AddressFamily address_family,
366                      HostResolverFlags host_resolver_flags,
367                      AddressList* addrlist,
368                      int* os_error) OVERRIDE {
369    bool wait_for_right_attempt_to_complete = true;
370    {
371      base::AutoLock auto_lock(lock_);
372      ++current_attempt_number_;
373      if (current_attempt_number_ == attempt_number_to_resolve_) {
374        resolved_attempt_number_ = current_attempt_number_;
375        wait_for_right_attempt_to_complete = false;
376      }
377    }
378
379    if (wait_for_right_attempt_to_complete)
380      // Wait for the attempt_number_to_resolve_ attempt to resolve.
381      WaitForAnAttemptToComplete();
382
383    int result = ResolveUsingPrevious(host, address_family, host_resolver_flags,
384                                      addrlist, os_error);
385
386    {
387      base::AutoLock auto_lock(lock_);
388      ++total_attempts_resolved_;
389    }
390
391    all_done_.Broadcast();  // Tell all attempts to proceed.
392
393    // Since any negative number is considered a network error, with -1 having
394    // special meaning (ERR_IO_PENDING). We could return the attempt that has
395    // resolved the host as a negative number. For example, if attempt number 3
396    // resolves the host, then this method returns -4.
397    if (result == OK)
398      return -1 - resolved_attempt_number_;
399    else
400      return result;
401  }
402
403 protected:
404  virtual ~LookupAttemptHostResolverProc() {}
405
406 private:
407  int attempt_number_to_resolve_;
408  int current_attempt_number_;  // Incremented whenever Resolve is called.
409  int total_attempts_;
410  int total_attempts_resolved_;
411  int resolved_attempt_number_;
412
413  // All attempts wait for right attempt to be resolve.
414  base::Lock lock_;
415  base::ConditionVariable all_done_;
416};
417
418}  // namespace
419
420class HostResolverImplTest : public testing::Test {
421 public:
422  static const int kDefaultPort = 80;
423
424  HostResolverImplTest() : proc_(new MockHostResolverProc()) {}
425
426  void CreateResolver() {
427    CreateResolverWithLimitsAndParams(kMaxJobs,
428                                      DefaultParams(proc_.get()));
429  }
430
431  // This HostResolverImpl will only allow 1 outstanding resolve at a time and
432  // perform no retries.
433  void CreateSerialResolver() {
434    HostResolverImpl::ProcTaskParams params = DefaultParams(proc_.get());
435    params.max_retry_attempts = 0u;
436    CreateResolverWithLimitsAndParams(1u, params);
437  }
438
439 protected:
440  // A Request::Handler which is a proxy to the HostResolverImplTest fixture.
441  struct Handler : public Request::Handler {
442    virtual ~Handler() {}
443
444    // Proxy functions so that classes derived from Handler can access them.
445    Request* CreateRequest(const HostResolver::RequestInfo& info,
446                           RequestPriority priority) {
447      return test->CreateRequest(info, priority);
448    }
449    Request* CreateRequest(const std::string& hostname, int port) {
450      return test->CreateRequest(hostname, port);
451    }
452    Request* CreateRequest(const std::string& hostname) {
453      return test->CreateRequest(hostname);
454    }
455    ScopedVector<Request>& requests() { return test->requests_; }
456
457    void DeleteResolver() { test->resolver_.reset(); }
458
459    HostResolverImplTest* test;
460  };
461
462  // testing::Test implementation:
463  virtual void SetUp() OVERRIDE {
464    CreateResolver();
465  }
466
467  virtual void TearDown() OVERRIDE {
468    if (resolver_.get())
469      EXPECT_EQ(0u, resolver_->num_running_dispatcher_jobs_for_tests());
470    EXPECT_FALSE(proc_->HasBlockedRequests());
471  }
472
473  virtual void CreateResolverWithLimitsAndParams(
474      size_t max_concurrent_resolves,
475      const HostResolverImpl::ProcTaskParams& params) {
476    HostResolverImpl::Options options = DefaultOptions();
477    options.max_concurrent_resolves = max_concurrent_resolves;
478    resolver_.reset(new HostResolverImpl(options, NULL));
479    resolver_->set_proc_params_for_test(params);
480  }
481
482  // The Request will not be made until a call to |Resolve()|, and the Job will
483  // not start until released by |proc_->SignalXXX|.
484  Request* CreateRequest(const HostResolver::RequestInfo& info,
485                         RequestPriority priority) {
486    Request* req = new Request(
487        info, priority, requests_.size(), resolver_.get(), handler_.get());
488    requests_.push_back(req);
489    return req;
490  }
491
492  Request* CreateRequest(const std::string& hostname,
493                         int port,
494                         RequestPriority priority,
495                         AddressFamily family) {
496    HostResolver::RequestInfo info(HostPortPair(hostname, port));
497    info.set_address_family(family);
498    return CreateRequest(info, priority);
499  }
500
501  Request* CreateRequest(const std::string& hostname,
502                         int port,
503                         RequestPriority priority) {
504    return CreateRequest(hostname, port, priority, ADDRESS_FAMILY_UNSPECIFIED);
505  }
506
507  Request* CreateRequest(const std::string& hostname, int port) {
508    return CreateRequest(hostname, port, MEDIUM);
509  }
510
511  Request* CreateRequest(const std::string& hostname) {
512    return CreateRequest(hostname, kDefaultPort);
513  }
514
515  void set_handler(Handler* handler) {
516    handler_.reset(handler);
517    handler_->test = this;
518  }
519
520  // Friendship is not inherited, so use proxies to access those.
521  size_t num_running_dispatcher_jobs() const {
522    DCHECK(resolver_.get());
523    return resolver_->num_running_dispatcher_jobs_for_tests();
524  }
525
526  void set_fallback_to_proctask(bool fallback_to_proctask) {
527    DCHECK(resolver_.get());
528    resolver_->fallback_to_proctask_ = fallback_to_proctask;
529  }
530
531  static unsigned maximum_dns_failures() {
532    return HostResolverImpl::kMaximumDnsFailures;
533  }
534
535  scoped_refptr<MockHostResolverProc> proc_;
536  scoped_ptr<HostResolverImpl> resolver_;
537  ScopedVector<Request> requests_;
538
539  scoped_ptr<Handler> handler_;
540};
541
542TEST_F(HostResolverImplTest, AsynchronousLookup) {
543  proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
544  proc_->SignalMultiple(1u);
545
546  Request* req = CreateRequest("just.testing", 80);
547  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
548  EXPECT_EQ(OK, req->WaitForResult());
549
550  EXPECT_TRUE(req->HasOneAddress("192.168.1.42", 80));
551
552  EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);
553}
554
555TEST_F(HostResolverImplTest, EmptyListMeansNameNotResolved) {
556  proc_->AddRuleForAllFamilies("just.testing", "");
557  proc_->SignalMultiple(1u);
558
559  Request* req = CreateRequest("just.testing", 80);
560  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
561  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult());
562  EXPECT_EQ(0u, req->NumberOfAddresses());
563  EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);
564}
565
566TEST_F(HostResolverImplTest, FailedAsynchronousLookup) {
567  proc_->AddRuleForAllFamilies(std::string(),
568                               "0.0.0.0");  // Default to failures.
569  proc_->SignalMultiple(1u);
570
571  Request* req = CreateRequest("just.testing", 80);
572  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
573  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult());
574
575  EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);
576
577  // Also test that the error is not cached.
578  EXPECT_EQ(ERR_DNS_CACHE_MISS, req->ResolveFromCache());
579}
580
581TEST_F(HostResolverImplTest, AbortedAsynchronousLookup) {
582  Request* req0 = CreateRequest("just.testing", 80);
583  EXPECT_EQ(ERR_IO_PENDING, req0->Resolve());
584
585  EXPECT_TRUE(proc_->WaitFor(1u));
586
587  // Resolver is destroyed while job is running on WorkerPool.
588  resolver_.reset();
589
590  proc_->SignalAll();
591
592  // To ensure there was no spurious callback, complete with a new resolver.
593  CreateResolver();
594  Request* req1 = CreateRequest("just.testing", 80);
595  EXPECT_EQ(ERR_IO_PENDING, req1->Resolve());
596
597  proc_->SignalMultiple(2u);
598
599  EXPECT_EQ(OK, req1->WaitForResult());
600
601  // This request was canceled.
602  EXPECT_FALSE(req0->completed());
603}
604
605#if defined(THREAD_SANITIZER)
606// Use of WorkerPool in HostResolverImpl causes a data race. crbug.com/334140
607#define MAYBE_NumericIPv4Address DISABLED_NumericIPv4Address
608#else
609#define MAYBE_NumericIPv4Address NumericIPv4Address
610#endif
611TEST_F(HostResolverImplTest, MAYBE_NumericIPv4Address) {
612  // Stevens says dotted quads with AI_UNSPEC resolve to a single sockaddr_in.
613  Request* req = CreateRequest("127.1.2.3", 5555);
614  EXPECT_EQ(OK, req->Resolve());
615
616  EXPECT_TRUE(req->HasOneAddress("127.1.2.3", 5555));
617}
618
619#if defined(THREAD_SANITIZER)
620// Use of WorkerPool in HostResolverImpl causes a data race. crbug.com/334140
621#define MAYBE_NumericIPv6Address DISABLED_NumericIPv6Address
622#else
623#define MAYBE_NumericIPv6Address NumericIPv6Address
624#endif
625TEST_F(HostResolverImplTest, MAYBE_NumericIPv6Address) {
626  // Resolve a plain IPv6 address.  Don't worry about [brackets], because
627  // the caller should have removed them.
628  Request* req = CreateRequest("2001:db8::1", 5555);
629  EXPECT_EQ(OK, req->Resolve());
630
631  EXPECT_TRUE(req->HasOneAddress("2001:db8::1", 5555));
632}
633
634#if defined(THREAD_SANITIZER)
635// Use of WorkerPool in HostResolverImpl causes a data race. crbug.com/334140
636#define MAYBE_EmptyHost DISABLED_EmptyHost
637#else
638#define MAYBE_EmptyHost EmptyHost
639#endif
640TEST_F(HostResolverImplTest, MAYBE_EmptyHost) {
641  Request* req = CreateRequest(std::string(), 5555);
642  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve());
643}
644
645#if defined(THREAD_SANITIZER)
646// There's a data race in this test that may lead to use-after-free.
647// If the test starts to crash without ThreadSanitizer it needs to be disabled
648// globally. See http://crbug.com/268946 (stacks for this test in
649// crbug.com/333567).
650#define MAYBE_EmptyDotsHost DISABLED_EmptyDotsHost
651#else
652#define MAYBE_EmptyDotsHost EmptyDotsHost
653#endif
654TEST_F(HostResolverImplTest, MAYBE_EmptyDotsHost) {
655  for (int i = 0; i < 16; ++i) {
656    Request* req = CreateRequest(std::string(i, '.'), 5555);
657    EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve());
658  }
659}
660
661#if defined(THREAD_SANITIZER)
662// There's a data race in this test that may lead to use-after-free.
663// If the test starts to crash without ThreadSanitizer it needs to be disabled
664// globally. See http://crbug.com/268946.
665#define MAYBE_LongHost DISABLED_LongHost
666#else
667#define MAYBE_LongHost LongHost
668#endif
669TEST_F(HostResolverImplTest, MAYBE_LongHost) {
670  Request* req = CreateRequest(std::string(4097, 'a'), 5555);
671  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve());
672}
673
674TEST_F(HostResolverImplTest, DeDupeRequests) {
675  // Start 5 requests, duplicating hosts "a" and "b". Since the resolver_proc is
676  // blocked, these should all pile up until we signal it.
677  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve());
678  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 80)->Resolve());
679  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 81)->Resolve());
680  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 82)->Resolve());
681  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 83)->Resolve());
682
683  proc_->SignalMultiple(2u);  // One for "a", one for "b".
684
685  for (size_t i = 0; i < requests_.size(); ++i) {
686    EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
687  }
688}
689
690TEST_F(HostResolverImplTest, CancelMultipleRequests) {
691  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve());
692  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 80)->Resolve());
693  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 81)->Resolve());
694  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 82)->Resolve());
695  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 83)->Resolve());
696
697  // Cancel everything except request for ("a", 82).
698  requests_[0]->Cancel();
699  requests_[1]->Cancel();
700  requests_[2]->Cancel();
701  requests_[4]->Cancel();
702
703  proc_->SignalMultiple(2u);  // One for "a", one for "b".
704
705  EXPECT_EQ(OK, requests_[3]->WaitForResult());
706}
707
708TEST_F(HostResolverImplTest, CanceledRequestsReleaseJobSlots) {
709  // Fill up the dispatcher and queue.
710  for (unsigned i = 0; i < kMaxJobs + 1; ++i) {
711    std::string hostname = "a_";
712    hostname[1] = 'a' + i;
713    EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 80)->Resolve());
714    EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 81)->Resolve());
715  }
716
717  EXPECT_TRUE(proc_->WaitFor(kMaxJobs));
718
719  // Cancel all but last two.
720  for (unsigned i = 0; i < requests_.size() - 2; ++i) {
721    requests_[i]->Cancel();
722  }
723
724  EXPECT_TRUE(proc_->WaitFor(kMaxJobs + 1));
725
726  proc_->SignalAll();
727
728  size_t num_requests = requests_.size();
729  EXPECT_EQ(OK, requests_[num_requests - 1]->WaitForResult());
730  EXPECT_EQ(OK, requests_[num_requests - 2]->result());
731}
732
733TEST_F(HostResolverImplTest, CancelWithinCallback) {
734  struct MyHandler : public Handler {
735    virtual void Handle(Request* req) OVERRIDE {
736      // Port 80 is the first request that the callback will be invoked for.
737      // While we are executing within that callback, cancel the other requests
738      // in the job and start another request.
739      if (req->index() == 0) {
740        // Once "a:80" completes, it will cancel "a:81" and "a:82".
741        requests()[1]->Cancel();
742        requests()[2]->Cancel();
743      }
744    }
745  };
746  set_handler(new MyHandler());
747
748  for (size_t i = 0; i < 4; ++i) {
749    EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
750  }
751
752  proc_->SignalMultiple(2u);  // One for "a". One for "finalrequest".
753
754  EXPECT_EQ(OK, requests_[0]->WaitForResult());
755
756  Request* final_request = CreateRequest("finalrequest", 70);
757  EXPECT_EQ(ERR_IO_PENDING, final_request->Resolve());
758  EXPECT_EQ(OK, final_request->WaitForResult());
759  EXPECT_TRUE(requests_[3]->completed());
760}
761
762TEST_F(HostResolverImplTest, DeleteWithinCallback) {
763  struct MyHandler : public Handler {
764    virtual void Handle(Request* req) OVERRIDE {
765      EXPECT_EQ("a", req->info().hostname());
766      EXPECT_EQ(80, req->info().port());
767
768      DeleteResolver();
769
770      // Quit after returning from OnCompleted (to give it a chance at
771      // incorrectly running the cancelled tasks).
772      base::MessageLoop::current()->PostTask(FROM_HERE,
773                                             base::MessageLoop::QuitClosure());
774    }
775  };
776  set_handler(new MyHandler());
777
778  for (size_t i = 0; i < 4; ++i) {
779    EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
780  }
781
782  proc_->SignalMultiple(1u);  // One for "a".
783
784  // |MyHandler| will send quit message once all the requests have finished.
785  base::MessageLoop::current()->Run();
786}
787
788TEST_F(HostResolverImplTest, DeleteWithinAbortedCallback) {
789  struct MyHandler : public Handler {
790    virtual void Handle(Request* req) OVERRIDE {
791      EXPECT_EQ("a", req->info().hostname());
792      EXPECT_EQ(80, req->info().port());
793
794      DeleteResolver();
795
796      // Quit after returning from OnCompleted (to give it a chance at
797      // incorrectly running the cancelled tasks).
798      base::MessageLoop::current()->PostTask(FROM_HERE,
799                                             base::MessageLoop::QuitClosure());
800    }
801  };
802  set_handler(new MyHandler());
803
804  // This test assumes that the Jobs will be Aborted in order ["a", "b"]
805  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve());
806  // HostResolverImpl will be deleted before later Requests can complete.
807  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 81)->Resolve());
808  // Job for 'b' will be aborted before it can complete.
809  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 82)->Resolve());
810  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 83)->Resolve());
811
812  EXPECT_TRUE(proc_->WaitFor(1u));
813
814  // Triggering an IP address change.
815  NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
816
817  // |MyHandler| will send quit message once all the requests have finished.
818  base::MessageLoop::current()->Run();
819
820  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->result());
821  EXPECT_EQ(ERR_IO_PENDING, requests_[1]->result());
822  EXPECT_EQ(ERR_IO_PENDING, requests_[2]->result());
823  EXPECT_EQ(ERR_IO_PENDING, requests_[3]->result());
824  // Clean up.
825  proc_->SignalMultiple(requests_.size());
826}
827
828TEST_F(HostResolverImplTest, StartWithinCallback) {
829  struct MyHandler : public Handler {
830    virtual void Handle(Request* req) OVERRIDE {
831      if (req->index() == 0) {
832        // On completing the first request, start another request for "a".
833        // Since caching is disabled, this will result in another async request.
834        EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 70)->Resolve());
835      }
836    }
837  };
838  set_handler(new MyHandler());
839
840  // Turn off caching for this host resolver.
841  HostResolver::Options options = DefaultOptions();
842  options.enable_caching = false;
843  resolver_.reset(new HostResolverImpl(options, NULL));
844  resolver_->set_proc_params_for_test(DefaultParams(proc_.get()));
845
846  for (size_t i = 0; i < 4; ++i) {
847    EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
848  }
849
850  proc_->SignalMultiple(2u);  // One for "a". One for the second "a".
851
852  EXPECT_EQ(OK, requests_[0]->WaitForResult());
853  ASSERT_EQ(5u, requests_.size());
854  EXPECT_EQ(OK, requests_.back()->WaitForResult());
855
856  EXPECT_EQ(2u, proc_->GetCaptureList().size());
857}
858
859TEST_F(HostResolverImplTest, BypassCache) {
860  struct MyHandler : public Handler {
861    virtual void Handle(Request* req) OVERRIDE {
862      if (req->index() == 0) {
863        // On completing the first request, start another request for "a".
864        // Since caching is enabled, this should complete synchronously.
865        std::string hostname = req->info().hostname();
866        EXPECT_EQ(OK, CreateRequest(hostname, 70)->Resolve());
867        EXPECT_EQ(OK, CreateRequest(hostname, 75)->ResolveFromCache());
868
869        // Ok good. Now make sure that if we ask to bypass the cache, it can no
870        // longer service the request synchronously.
871        HostResolver::RequestInfo info(HostPortPair(hostname, 71));
872        info.set_allow_cached_response(false);
873        EXPECT_EQ(ERR_IO_PENDING,
874                  CreateRequest(info, DEFAULT_PRIORITY)->Resolve());
875      } else if (71 == req->info().port()) {
876        // Test is done.
877        base::MessageLoop::current()->Quit();
878      } else {
879        FAIL() << "Unexpected request";
880      }
881    }
882  };
883  set_handler(new MyHandler());
884
885  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve());
886  proc_->SignalMultiple(3u);  // Only need two, but be generous.
887
888  // |verifier| will send quit message once all the requests have finished.
889  base::MessageLoop::current()->Run();
890  EXPECT_EQ(2u, proc_->GetCaptureList().size());
891}
892
893// Test that IP address changes flush the cache.
894TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange) {
895  proc_->SignalMultiple(2u);  // One before the flush, one after.
896
897  Request* req = CreateRequest("host1", 70);
898  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
899  EXPECT_EQ(OK, req->WaitForResult());
900
901  req = CreateRequest("host1", 75);
902  EXPECT_EQ(OK, req->Resolve());  // Should complete synchronously.
903
904  // Flush cache by triggering an IP address change.
905  NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
906  base::MessageLoop::current()->RunUntilIdle();  // Notification happens async.
907
908  // Resolve "host1" again -- this time it won't be served from cache, so it
909  // will complete asynchronously.
910  req = CreateRequest("host1", 80);
911  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
912  EXPECT_EQ(OK, req->WaitForResult());
913}
914
915// Test that IP address changes send ERR_NETWORK_CHANGED to pending requests.
916TEST_F(HostResolverImplTest, AbortOnIPAddressChanged) {
917  Request* req = CreateRequest("host1", 70);
918  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
919
920  EXPECT_TRUE(proc_->WaitFor(1u));
921  // Triggering an IP address change.
922  NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
923  base::MessageLoop::current()->RunUntilIdle();  // Notification happens async.
924  proc_->SignalAll();
925
926  EXPECT_EQ(ERR_NETWORK_CHANGED, req->WaitForResult());
927  EXPECT_EQ(0u, resolver_->GetHostCache()->size());
928}
929
930// Obey pool constraints after IP address has changed.
931TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) {
932  // Runs at most one job at a time.
933  CreateSerialResolver();
934  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a")->Resolve());
935  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b")->Resolve());
936  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("c")->Resolve());
937
938  EXPECT_TRUE(proc_->WaitFor(1u));
939  // Triggering an IP address change.
940  NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
941  base::MessageLoop::current()->RunUntilIdle();  // Notification happens async.
942  proc_->SignalMultiple(3u);  // Let the false-start go so that we can catch it.
943
944  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->WaitForResult());
945
946  EXPECT_EQ(1u, num_running_dispatcher_jobs());
947
948  EXPECT_FALSE(requests_[1]->completed());
949  EXPECT_FALSE(requests_[2]->completed());
950
951  EXPECT_EQ(OK, requests_[2]->WaitForResult());
952  EXPECT_EQ(OK, requests_[1]->result());
953}
954
955// Tests that a new Request made from the callback of a previously aborted one
956// will not be aborted.
957TEST_F(HostResolverImplTest, AbortOnlyExistingRequestsOnIPAddressChange) {
958  struct MyHandler : public Handler {
959    virtual void Handle(Request* req) OVERRIDE {
960      // Start new request for a different hostname to ensure that the order
961      // of jobs in HostResolverImpl is not stable.
962      std::string hostname;
963      if (req->index() == 0)
964        hostname = "zzz";
965      else if (req->index() == 1)
966        hostname = "aaa";
967      else if (req->index() == 2)
968        hostname = "eee";
969      else
970        return;  // A request started from within MyHandler.
971      EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname)->Resolve()) << hostname;
972    }
973  };
974  set_handler(new MyHandler());
975
976  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("bbb")->Resolve());
977  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("eee")->Resolve());
978  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ccc")->Resolve());
979
980  // Wait until all are blocked;
981  EXPECT_TRUE(proc_->WaitFor(3u));
982  // Trigger an IP address change.
983  NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
984  // This should abort all running jobs.
985  base::MessageLoop::current()->RunUntilIdle();
986  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->result());
987  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[1]->result());
988  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[2]->result());
989  ASSERT_EQ(6u, requests_.size());
990  // Unblock all calls to proc.
991  proc_->SignalMultiple(requests_.size());
992  // Run until the re-started requests finish.
993  EXPECT_EQ(OK, requests_[3]->WaitForResult());
994  EXPECT_EQ(OK, requests_[4]->WaitForResult());
995  EXPECT_EQ(OK, requests_[5]->WaitForResult());
996  // Verify that results of aborted Jobs were not cached.
997  EXPECT_EQ(6u, proc_->GetCaptureList().size());
998  EXPECT_EQ(3u, resolver_->GetHostCache()->size());
999}
1000
1001// Tests that when the maximum threads is set to 1, requests are dequeued
1002// in order of priority.
1003TEST_F(HostResolverImplTest, HigherPriorityRequestsStartedFirst) {
1004  CreateSerialResolver();
1005
1006  // Note that at this point the MockHostResolverProc is blocked, so any
1007  // requests we make will not complete.
1008  CreateRequest("req0", 80, LOW);
1009  CreateRequest("req1", 80, MEDIUM);
1010  CreateRequest("req2", 80, MEDIUM);
1011  CreateRequest("req3", 80, LOW);
1012  CreateRequest("req4", 80, HIGHEST);
1013  CreateRequest("req5", 80, LOW);
1014  CreateRequest("req6", 80, LOW);
1015  CreateRequest("req5", 80, HIGHEST);
1016
1017  for (size_t i = 0; i < requests_.size(); ++i) {
1018    EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i;
1019  }
1020
1021  // Unblock the resolver thread so the requests can run.
1022  proc_->SignalMultiple(requests_.size());  // More than needed.
1023
1024  // Wait for all the requests to complete succesfully.
1025  for (size_t i = 0; i < requests_.size(); ++i) {
1026    EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
1027  }
1028
1029  // Since we have restricted to a single concurrent thread in the jobpool,
1030  // the requests should complete in order of priority (with the exception
1031  // of the first request, which gets started right away, since there is
1032  // nothing outstanding).
1033  MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
1034  ASSERT_EQ(7u, capture_list.size());
1035
1036  EXPECT_EQ("req0", capture_list[0].hostname);
1037  EXPECT_EQ("req4", capture_list[1].hostname);
1038  EXPECT_EQ("req5", capture_list[2].hostname);
1039  EXPECT_EQ("req1", capture_list[3].hostname);
1040  EXPECT_EQ("req2", capture_list[4].hostname);
1041  EXPECT_EQ("req3", capture_list[5].hostname);
1042  EXPECT_EQ("req6", capture_list[6].hostname);
1043}
1044
1045// Try cancelling a job which has not started yet.
1046TEST_F(HostResolverImplTest, CancelPendingRequest) {
1047  CreateSerialResolver();
1048
1049  CreateRequest("req0", 80, LOWEST);
1050  CreateRequest("req1", 80, HIGHEST);  // Will cancel.
1051  CreateRequest("req2", 80, MEDIUM);
1052  CreateRequest("req3", 80, LOW);
1053  CreateRequest("req4", 80, HIGHEST);  // Will cancel.
1054  CreateRequest("req5", 80, LOWEST);   // Will cancel.
1055  CreateRequest("req6", 80, MEDIUM);
1056
1057  // Start all of the requests.
1058  for (size_t i = 0; i < requests_.size(); ++i) {
1059    EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i;
1060  }
1061
1062  // Cancel some requests
1063  requests_[1]->Cancel();
1064  requests_[4]->Cancel();
1065  requests_[5]->Cancel();
1066
1067  // Unblock the resolver thread so the requests can run.
1068  proc_->SignalMultiple(requests_.size());  // More than needed.
1069
1070  // Wait for all the requests to complete succesfully.
1071  for (size_t i = 0; i < requests_.size(); ++i) {
1072    if (!requests_[i]->pending())
1073      continue;  // Don't wait for the requests we cancelled.
1074    EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
1075  }
1076
1077  // Verify that they called out the the resolver proc (which runs on the
1078  // resolver thread) in the expected order.
1079  MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
1080  ASSERT_EQ(4u, capture_list.size());
1081
1082  EXPECT_EQ("req0", capture_list[0].hostname);
1083  EXPECT_EQ("req2", capture_list[1].hostname);
1084  EXPECT_EQ("req6", capture_list[2].hostname);
1085  EXPECT_EQ("req3", capture_list[3].hostname);
1086}
1087
1088// Test that when too many requests are enqueued, old ones start to be aborted.
1089TEST_F(HostResolverImplTest, QueueOverflow) {
1090  CreateSerialResolver();
1091
1092  // Allow only 3 queued jobs.
1093  const size_t kMaxPendingJobs = 3u;
1094  resolver_->SetMaxQueuedJobs(kMaxPendingJobs);
1095
1096  // Note that at this point the MockHostResolverProc is blocked, so any
1097  // requests we make will not complete.
1098
1099  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req0", 80, LOWEST)->Resolve());
1100  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req1", 80, HIGHEST)->Resolve());
1101  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req2", 80, MEDIUM)->Resolve());
1102  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req3", 80, MEDIUM)->Resolve());
1103
1104  // At this point, there are 3 enqueued jobs.
1105  // Insertion of subsequent requests will cause evictions
1106  // based on priority.
1107
1108  EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE,
1109            CreateRequest("req4", 80, LOW)->Resolve());  // Evicts itself!
1110
1111  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req5", 80, MEDIUM)->Resolve());
1112  EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, requests_[2]->result());
1113  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req6", 80, HIGHEST)->Resolve());
1114  EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, requests_[3]->result());
1115  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req7", 80, MEDIUM)->Resolve());
1116  EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, requests_[5]->result());
1117
1118  // Unblock the resolver thread so the requests can run.
1119  proc_->SignalMultiple(4u);
1120
1121  // The rest should succeed.
1122  EXPECT_EQ(OK, requests_[7]->WaitForResult());
1123  EXPECT_EQ(OK, requests_[0]->result());
1124  EXPECT_EQ(OK, requests_[1]->result());
1125  EXPECT_EQ(OK, requests_[6]->result());
1126
1127  // Verify that they called out the the resolver proc (which runs on the
1128  // resolver thread) in the expected order.
1129  MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
1130  ASSERT_EQ(4u, capture_list.size());
1131
1132  EXPECT_EQ("req0", capture_list[0].hostname);
1133  EXPECT_EQ("req1", capture_list[1].hostname);
1134  EXPECT_EQ("req6", capture_list[2].hostname);
1135  EXPECT_EQ("req7", capture_list[3].hostname);
1136
1137  // Verify that the evicted (incomplete) requests were not cached.
1138  EXPECT_EQ(4u, resolver_->GetHostCache()->size());
1139
1140  for (size_t i = 0; i < requests_.size(); ++i) {
1141    EXPECT_TRUE(requests_[i]->completed()) << i;
1142  }
1143}
1144
1145// Tests that after changing the default AddressFamily to IPV4, requests
1146// with UNSPECIFIED address family map to IPV4.
1147TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv4) {
1148  CreateSerialResolver();  // To guarantee order of resolutions.
1149
1150  proc_->AddRule("h1", ADDRESS_FAMILY_IPV4, "1.0.0.1");
1151  proc_->AddRule("h1", ADDRESS_FAMILY_IPV6, "::2");
1152
1153  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
1154
1155  CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_UNSPECIFIED);
1156  CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV4);
1157  CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV6);
1158
1159  // Start all of the requests.
1160  for (size_t i = 0; i < requests_.size(); ++i) {
1161    EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i;
1162  }
1163
1164  proc_->SignalMultiple(requests_.size());
1165
1166  // Wait for all the requests to complete.
1167  for (size_t i = 0u; i < requests_.size(); ++i) {
1168    EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
1169  }
1170
1171  // Since the requests all had the same priority and we limited the thread
1172  // count to 1, they should have completed in the same order as they were
1173  // requested. Moreover, request0 and request1 will have been serviced by
1174  // the same job.
1175
1176  MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
1177  ASSERT_EQ(2u, capture_list.size());
1178
1179  EXPECT_EQ("h1", capture_list[0].hostname);
1180  EXPECT_EQ(ADDRESS_FAMILY_IPV4, capture_list[0].address_family);
1181
1182  EXPECT_EQ("h1", capture_list[1].hostname);
1183  EXPECT_EQ(ADDRESS_FAMILY_IPV6, capture_list[1].address_family);
1184
1185  // Now check that the correct resolved IP addresses were returned.
1186  EXPECT_TRUE(requests_[0]->HasOneAddress("1.0.0.1", 80));
1187  EXPECT_TRUE(requests_[1]->HasOneAddress("1.0.0.1", 80));
1188  EXPECT_TRUE(requests_[2]->HasOneAddress("::2", 80));
1189}
1190
1191// This is the exact same test as SetDefaultAddressFamily_IPv4, except the
1192// default family is set to IPv6 and the family of requests is flipped where
1193// specified.
1194TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv6) {
1195  CreateSerialResolver();  // To guarantee order of resolutions.
1196
1197  // Don't use IPv6 replacements here since some systems don't support it.
1198  proc_->AddRule("h1", ADDRESS_FAMILY_IPV4, "1.0.0.1");
1199  proc_->AddRule("h1", ADDRESS_FAMILY_IPV6, "::2");
1200
1201  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV6);
1202
1203  CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_UNSPECIFIED);
1204  CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV6);
1205  CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV4);
1206
1207  // Start all of the requests.
1208  for (size_t i = 0; i < requests_.size(); ++i) {
1209    EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i;
1210  }
1211
1212  proc_->SignalMultiple(requests_.size());
1213
1214  // Wait for all the requests to complete.
1215  for (size_t i = 0u; i < requests_.size(); ++i) {
1216    EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
1217  }
1218
1219  // Since the requests all had the same priority and we limited the thread
1220  // count to 1, they should have completed in the same order as they were
1221  // requested. Moreover, request0 and request1 will have been serviced by
1222  // the same job.
1223
1224  MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
1225  ASSERT_EQ(2u, capture_list.size());
1226
1227  EXPECT_EQ("h1", capture_list[0].hostname);
1228  EXPECT_EQ(ADDRESS_FAMILY_IPV6, capture_list[0].address_family);
1229
1230  EXPECT_EQ("h1", capture_list[1].hostname);
1231  EXPECT_EQ(ADDRESS_FAMILY_IPV4, capture_list[1].address_family);
1232
1233  // Now check that the correct resolved IP addresses were returned.
1234  EXPECT_TRUE(requests_[0]->HasOneAddress("::2", 80));
1235  EXPECT_TRUE(requests_[1]->HasOneAddress("::2", 80));
1236  EXPECT_TRUE(requests_[2]->HasOneAddress("1.0.0.1", 80));
1237}
1238
1239// Make sure that the address family parameter is respected when raw IPs are
1240// passed in.
1241TEST_F(HostResolverImplTest, AddressFamilyWithRawIPs) {
1242  Request* request =
1243      CreateRequest("127.0.0.1", 80,  MEDIUM, ADDRESS_FAMILY_IPV4);
1244  EXPECT_EQ(OK, request->Resolve());
1245  EXPECT_TRUE(request->HasOneAddress("127.0.0.1", 80));
1246
1247  request = CreateRequest("127.0.0.1", 80,  MEDIUM, ADDRESS_FAMILY_IPV6);
1248  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, request->Resolve());
1249
1250  request = CreateRequest("127.0.0.1", 80,  MEDIUM, ADDRESS_FAMILY_UNSPECIFIED);
1251  EXPECT_EQ(OK, request->Resolve());
1252  EXPECT_TRUE(request->HasOneAddress("127.0.0.1", 80));
1253
1254  request = CreateRequest("::1", 80,  MEDIUM, ADDRESS_FAMILY_IPV4);
1255  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, request->Resolve());
1256
1257  request = CreateRequest("::1", 80,  MEDIUM, ADDRESS_FAMILY_IPV6);
1258  EXPECT_EQ(OK, request->Resolve());
1259  EXPECT_TRUE(request->HasOneAddress("::1", 80));
1260
1261  request = CreateRequest("::1", 80,  MEDIUM, ADDRESS_FAMILY_UNSPECIFIED);
1262  EXPECT_EQ(OK, request->Resolve());
1263  EXPECT_TRUE(request->HasOneAddress("::1", 80));
1264}
1265
1266TEST_F(HostResolverImplTest, ResolveFromCache) {
1267  proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
1268  proc_->SignalMultiple(1u);  // Need only one.
1269
1270  HostResolver::RequestInfo info(HostPortPair("just.testing", 80));
1271
1272  // First hit will miss the cache.
1273  EXPECT_EQ(ERR_DNS_CACHE_MISS,
1274            CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache());
1275
1276  // This time, we fetch normally.
1277  EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info, DEFAULT_PRIORITY)->Resolve());
1278  EXPECT_EQ(OK, requests_[1]->WaitForResult());
1279
1280  // Now we should be able to fetch from the cache.
1281  EXPECT_EQ(OK, CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache());
1282  EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.1.42", 80));
1283}
1284
1285// Test the retry attempts simulating host resolver proc that takes too long.
1286TEST_F(HostResolverImplTest, MultipleAttempts) {
1287  // Total number of attempts would be 3 and we want the 3rd attempt to resolve
1288  // the host. First and second attempt will be forced to sleep until they get
1289  // word that a resolution has completed. The 3rd resolution attempt will try
1290  // to get done ASAP, and won't sleep..
1291  int kAttemptNumberToResolve = 3;
1292  int kTotalAttempts = 3;
1293
1294  scoped_refptr<LookupAttemptHostResolverProc> resolver_proc(
1295      new LookupAttemptHostResolverProc(
1296          NULL, kAttemptNumberToResolve, kTotalAttempts));
1297
1298  HostResolverImpl::ProcTaskParams params = DefaultParams(resolver_proc.get());
1299
1300  // Specify smaller interval for unresponsive_delay_ for HostResolverImpl so
1301  // that unit test runs faster. For example, this test finishes in 1.5 secs
1302  // (500ms * 3).
1303  params.unresponsive_delay = base::TimeDelta::FromMilliseconds(500);
1304
1305  resolver_.reset(new HostResolverImpl(DefaultOptions(), NULL));
1306  resolver_->set_proc_params_for_test(params);
1307
1308  // Resolve "host1".
1309  HostResolver::RequestInfo info(HostPortPair("host1", 70));
1310  Request* req = CreateRequest(info, DEFAULT_PRIORITY);
1311  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
1312
1313  // Resolve returns -4 to indicate that 3rd attempt has resolved the host.
1314  EXPECT_EQ(-4, req->WaitForResult());
1315
1316  resolver_proc->WaitForAllAttemptsToFinish(
1317      base::TimeDelta::FromMilliseconds(60000));
1318  base::MessageLoop::current()->RunUntilIdle();
1319
1320  EXPECT_EQ(resolver_proc->total_attempts_resolved(), kTotalAttempts);
1321  EXPECT_EQ(resolver_proc->resolved_attempt_number(), kAttemptNumberToResolve);
1322}
1323
1324DnsConfig CreateValidDnsConfig() {
1325  IPAddressNumber dns_ip;
1326  bool rv = ParseIPLiteralToNumber("192.168.1.0", &dns_ip);
1327  EXPECT_TRUE(rv);
1328
1329  DnsConfig config;
1330  config.nameservers.push_back(IPEndPoint(dns_ip, dns_protocol::kDefaultPort));
1331  EXPECT_TRUE(config.IsValid());
1332  return config;
1333}
1334
1335// Specialized fixture for tests of DnsTask.
1336class HostResolverImplDnsTest : public HostResolverImplTest {
1337 public:
1338  HostResolverImplDnsTest() : dns_client_(NULL) {}
1339
1340 protected:
1341  // testing::Test implementation:
1342  virtual void SetUp() OVERRIDE {
1343    AddDnsRule("nx", dns_protocol::kTypeA, MockDnsClientRule::FAIL, false);
1344    AddDnsRule("nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL, false);
1345    AddDnsRule("ok", dns_protocol::kTypeA, MockDnsClientRule::OK, false);
1346    AddDnsRule("ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK, false);
1347    AddDnsRule("4ok", dns_protocol::kTypeA, MockDnsClientRule::OK, false);
1348    AddDnsRule("4ok", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY, false);
1349    AddDnsRule("6ok", dns_protocol::kTypeA, MockDnsClientRule::EMPTY, false);
1350    AddDnsRule("6ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK, false);
1351    AddDnsRule("4nx", dns_protocol::kTypeA, MockDnsClientRule::OK, false);
1352    AddDnsRule("4nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL, false);
1353    AddDnsRule("empty", dns_protocol::kTypeA, MockDnsClientRule::EMPTY, false);
1354    AddDnsRule("empty", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY,
1355               false);
1356
1357    AddDnsRule("slow_nx", dns_protocol::kTypeA, MockDnsClientRule::FAIL, true);
1358    AddDnsRule("slow_nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL,
1359               true);
1360
1361    AddDnsRule("4slow_ok", dns_protocol::kTypeA, MockDnsClientRule::OK, true);
1362    AddDnsRule("4slow_ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK,
1363               false);
1364    AddDnsRule("6slow_ok", dns_protocol::kTypeA, MockDnsClientRule::OK, false);
1365    AddDnsRule("6slow_ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK,
1366               true);
1367    AddDnsRule("4slow_4ok", dns_protocol::kTypeA, MockDnsClientRule::OK, true);
1368    AddDnsRule("4slow_4ok", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY,
1369               false);
1370    AddDnsRule("4slow_4timeout", dns_protocol::kTypeA,
1371               MockDnsClientRule::TIMEOUT, true);
1372    AddDnsRule("4slow_4timeout", dns_protocol::kTypeAAAA, MockDnsClientRule::OK,
1373               false);
1374    AddDnsRule("4slow_6timeout", dns_protocol::kTypeA,
1375               MockDnsClientRule::OK, true);
1376    AddDnsRule("4slow_6timeout", dns_protocol::kTypeAAAA,
1377               MockDnsClientRule::TIMEOUT, false);
1378    CreateResolver();
1379  }
1380
1381  // HostResolverImplTest implementation:
1382  virtual void CreateResolverWithLimitsAndParams(
1383      size_t max_concurrent_resolves,
1384      const HostResolverImpl::ProcTaskParams& params) OVERRIDE {
1385    HostResolverImpl::Options options = DefaultOptions();
1386    options.max_concurrent_resolves = max_concurrent_resolves;
1387    resolver_.reset(new HostResolverImpl(options, NULL));
1388    resolver_->set_proc_params_for_test(params);
1389    // Disable IPv6 support probing.
1390    resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
1391    dns_client_ = new MockDnsClient(DnsConfig(), dns_rules_);
1392    resolver_->SetDnsClient(scoped_ptr<DnsClient>(dns_client_));
1393  }
1394
1395  // Adds a rule to |dns_rules_|. Must be followed by |CreateResolver| to apply.
1396  void AddDnsRule(const std::string& prefix,
1397                  uint16 qtype,
1398                  MockDnsClientRule::Result result,
1399                  bool delay) {
1400    dns_rules_.push_back(MockDnsClientRule(prefix, qtype, result, delay));
1401  }
1402
1403  void ChangeDnsConfig(const DnsConfig& config) {
1404    NetworkChangeNotifier::SetDnsConfig(config);
1405    // Notification is delivered asynchronously.
1406    base::MessageLoop::current()->RunUntilIdle();
1407  }
1408
1409  MockDnsClientRuleList dns_rules_;
1410  // Owned by |resolver_|.
1411  MockDnsClient* dns_client_;
1412};
1413
1414// TODO(szym): Test AbortAllInProgressJobs due to DnsConfig change.
1415
1416// TODO(cbentzel): Test a mix of requests with different HostResolverFlags.
1417
1418// Test successful and fallback resolutions in HostResolverImpl::DnsTask.
1419TEST_F(HostResolverImplDnsTest, DnsTask) {
1420  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
1421
1422  proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102");
1423  // All other hostnames will fail in proc_.
1424
1425  // Initially there is no config, so client should not be invoked.
1426  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());
1427  proc_->SignalMultiple(requests_.size());
1428
1429  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[0]->WaitForResult());
1430
1431  ChangeDnsConfig(CreateValidDnsConfig());
1432
1433  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());
1434  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_fail", 80)->Resolve());
1435  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_succeed", 80)->Resolve());
1436
1437  proc_->SignalMultiple(requests_.size());
1438
1439  for (size_t i = 1; i < requests_.size(); ++i)
1440    EXPECT_NE(ERR_UNEXPECTED, requests_[i]->WaitForResult()) << i;
1441
1442  EXPECT_EQ(OK, requests_[1]->result());
1443  // Resolved by MockDnsClient.
1444  EXPECT_TRUE(requests_[1]->HasOneAddress("127.0.0.1", 80));
1445  // Fallback to ProcTask.
1446  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[2]->result());
1447  EXPECT_EQ(OK, requests_[3]->result());
1448  EXPECT_TRUE(requests_[3]->HasOneAddress("192.168.1.102", 80));
1449}
1450
1451// Test successful and failing resolutions in HostResolverImpl::DnsTask when
1452// fallback to ProcTask is disabled.
1453TEST_F(HostResolverImplDnsTest, NoFallbackToProcTask) {
1454  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
1455  set_fallback_to_proctask(false);
1456
1457  proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102");
1458  // All other hostnames will fail in proc_.
1459
1460  // Set empty DnsConfig.
1461  ChangeDnsConfig(DnsConfig());
1462  // Initially there is no config, so client should not be invoked.
1463  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());
1464  // There is no config, so fallback to ProcTask must work.
1465  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_succeed", 80)->Resolve());
1466  proc_->SignalMultiple(requests_.size());
1467
1468  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[0]->WaitForResult());
1469  EXPECT_EQ(OK, requests_[1]->WaitForResult());
1470  EXPECT_TRUE(requests_[1]->HasOneAddress("192.168.1.102", 80));
1471
1472  ChangeDnsConfig(CreateValidDnsConfig());
1473
1474  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_abort", 80)->Resolve());
1475  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80)->Resolve());
1476
1477  // Simulate the case when the preference or policy has disabled the DNS client
1478  // causing AbortDnsTasks.
1479  resolver_->SetDnsClient(
1480      scoped_ptr<DnsClient>(new MockDnsClient(DnsConfig(), dns_rules_)));
1481  ChangeDnsConfig(CreateValidDnsConfig());
1482
1483  // First request is resolved by MockDnsClient, others should fail due to
1484  // disabled fallback to ProcTask.
1485  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());
1486  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_fail", 80)->Resolve());
1487  proc_->SignalMultiple(requests_.size());
1488
1489  // Aborted due to Network Change.
1490  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[2]->WaitForResult());
1491  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[3]->WaitForResult());
1492  // Resolved by MockDnsClient.
1493  EXPECT_EQ(OK, requests_[4]->WaitForResult());
1494  EXPECT_TRUE(requests_[4]->HasOneAddress("127.0.0.1", 80));
1495  // Fallback to ProcTask is disabled.
1496  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[5]->WaitForResult());
1497}
1498
1499// Test behavior of OnDnsTaskFailure when Job is aborted.
1500TEST_F(HostResolverImplDnsTest, OnDnsTaskFailureAbortedJob) {
1501  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
1502  ChangeDnsConfig(CreateValidDnsConfig());
1503  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80)->Resolve());
1504  // Abort all jobs here.
1505  CreateResolver();
1506  proc_->SignalMultiple(requests_.size());
1507  // Run to completion.
1508  base::MessageLoop::current()->RunUntilIdle();  // Notification happens async.
1509  // It shouldn't crash during OnDnsTaskFailure callbacks.
1510  EXPECT_EQ(ERR_IO_PENDING, requests_[0]->result());
1511
1512  // Repeat test with Fallback to ProcTask disabled
1513  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
1514  set_fallback_to_proctask(false);
1515  ChangeDnsConfig(CreateValidDnsConfig());
1516  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80)->Resolve());
1517  // Abort all jobs here.
1518  CreateResolver();
1519  // Run to completion.
1520  base::MessageLoop::current()->RunUntilIdle();  // Notification happens async.
1521  // It shouldn't crash during OnDnsTaskFailure callbacks.
1522  EXPECT_EQ(ERR_IO_PENDING, requests_[1]->result());
1523}
1524
1525TEST_F(HostResolverImplDnsTest, DnsTaskUnspec) {
1526  ChangeDnsConfig(CreateValidDnsConfig());
1527
1528  proc_->AddRuleForAllFamilies("4nx", "192.168.1.101");
1529  // All other hostnames will fail in proc_.
1530
1531  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
1532  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4ok", 80)->Resolve());
1533  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("6ok", 80)->Resolve());
1534  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4nx", 80)->Resolve());
1535
1536  proc_->SignalMultiple(requests_.size());
1537
1538  for (size_t i = 0; i < requests_.size(); ++i)
1539    EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
1540
1541  EXPECT_EQ(2u, requests_[0]->NumberOfAddresses());
1542  EXPECT_TRUE(requests_[0]->HasAddress("127.0.0.1", 80));
1543  EXPECT_TRUE(requests_[0]->HasAddress("::1", 80));
1544  EXPECT_EQ(1u, requests_[1]->NumberOfAddresses());
1545  EXPECT_TRUE(requests_[1]->HasAddress("127.0.0.1", 80));
1546  EXPECT_EQ(1u, requests_[2]->NumberOfAddresses());
1547  EXPECT_TRUE(requests_[2]->HasAddress("::1", 80));
1548  EXPECT_EQ(1u, requests_[3]->NumberOfAddresses());
1549  EXPECT_TRUE(requests_[3]->HasAddress("192.168.1.101", 80));
1550}
1551
1552TEST_F(HostResolverImplDnsTest, ServeFromHosts) {
1553  // Initially, use empty HOSTS file.
1554  DnsConfig config = CreateValidDnsConfig();
1555  ChangeDnsConfig(config);
1556
1557  proc_->AddRuleForAllFamilies(std::string(),
1558                               std::string());  // Default to failures.
1559  proc_->SignalMultiple(1u);  // For the first request which misses.
1560
1561  Request* req0 = CreateRequest("nx_ipv4", 80);
1562  EXPECT_EQ(ERR_IO_PENDING, req0->Resolve());
1563  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req0->WaitForResult());
1564
1565  IPAddressNumber local_ipv4, local_ipv6;
1566  ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &local_ipv4));
1567  ASSERT_TRUE(ParseIPLiteralToNumber("::1", &local_ipv6));
1568
1569  DnsHosts hosts;
1570  hosts[DnsHostsKey("nx_ipv4", ADDRESS_FAMILY_IPV4)] = local_ipv4;
1571  hosts[DnsHostsKey("nx_ipv6", ADDRESS_FAMILY_IPV6)] = local_ipv6;
1572  hosts[DnsHostsKey("nx_both", ADDRESS_FAMILY_IPV4)] = local_ipv4;
1573  hosts[DnsHostsKey("nx_both", ADDRESS_FAMILY_IPV6)] = local_ipv6;
1574
1575  // Update HOSTS file.
1576  config.hosts = hosts;
1577  ChangeDnsConfig(config);
1578
1579  Request* req1 = CreateRequest("nx_ipv4", 80);
1580  EXPECT_EQ(OK, req1->Resolve());
1581  EXPECT_TRUE(req1->HasOneAddress("127.0.0.1", 80));
1582
1583  Request* req2 = CreateRequest("nx_ipv6", 80);
1584  EXPECT_EQ(OK, req2->Resolve());
1585  EXPECT_TRUE(req2->HasOneAddress("::1", 80));
1586
1587  Request* req3 = CreateRequest("nx_both", 80);
1588  EXPECT_EQ(OK, req3->Resolve());
1589  EXPECT_TRUE(req3->HasAddress("127.0.0.1", 80) &&
1590              req3->HasAddress("::1", 80));
1591
1592  // Requests with specified AddressFamily.
1593  Request* req4 = CreateRequest("nx_ipv4", 80, MEDIUM, ADDRESS_FAMILY_IPV4);
1594  EXPECT_EQ(OK, req4->Resolve());
1595  EXPECT_TRUE(req4->HasOneAddress("127.0.0.1", 80));
1596
1597  Request* req5 = CreateRequest("nx_ipv6", 80, MEDIUM, ADDRESS_FAMILY_IPV6);
1598  EXPECT_EQ(OK, req5->Resolve());
1599  EXPECT_TRUE(req5->HasOneAddress("::1", 80));
1600
1601  // Request with upper case.
1602  Request* req6 = CreateRequest("nx_IPV4", 80);
1603  EXPECT_EQ(OK, req6->Resolve());
1604  EXPECT_TRUE(req6->HasOneAddress("127.0.0.1", 80));
1605}
1606
1607TEST_F(HostResolverImplDnsTest, BypassDnsTask) {
1608  ChangeDnsConfig(CreateValidDnsConfig());
1609
1610  proc_->AddRuleForAllFamilies(std::string(),
1611                               std::string());  // Default to failures.
1612
1613  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok.local", 80)->Resolve());
1614  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok.local.", 80)->Resolve());
1615  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("oklocal", 80)->Resolve());
1616  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("oklocal.", 80)->Resolve());
1617  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
1618
1619  proc_->SignalMultiple(requests_.size());
1620
1621  for (size_t i = 0; i < 2; ++i)
1622    EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[i]->WaitForResult()) << i;
1623
1624  for (size_t i = 2; i < requests_.size(); ++i)
1625    EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
1626}
1627
1628TEST_F(HostResolverImplDnsTest, SystemOnlyBypassesDnsTask) {
1629  ChangeDnsConfig(CreateValidDnsConfig());
1630
1631  proc_->AddRuleForAllFamilies(std::string(), std::string());
1632
1633  HostResolver::RequestInfo info_bypass(HostPortPair("ok", 80));
1634  info_bypass.set_host_resolver_flags(HOST_RESOLVER_SYSTEM_ONLY);
1635  EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info_bypass, MEDIUM)->Resolve());
1636
1637  HostResolver::RequestInfo info(HostPortPair("ok", 80));
1638  EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info, MEDIUM)->Resolve());
1639
1640  proc_->SignalMultiple(requests_.size());
1641
1642  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[0]->WaitForResult());
1643  EXPECT_EQ(OK, requests_[1]->WaitForResult());
1644}
1645
1646TEST_F(HostResolverImplDnsTest, DisableDnsClientOnPersistentFailure) {
1647  ChangeDnsConfig(CreateValidDnsConfig());
1648
1649  proc_->AddRuleForAllFamilies(std::string(),
1650                               std::string());  // Default to failures.
1651
1652  // Check that DnsTask works.
1653  Request* req = CreateRequest("ok_1", 80);
1654  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
1655  EXPECT_EQ(OK, req->WaitForResult());
1656
1657  for (unsigned i = 0; i < maximum_dns_failures(); ++i) {
1658    // Use custom names to require separate Jobs.
1659    std::string hostname = base::StringPrintf("nx_%u", i);
1660    // Ensure fallback to ProcTask succeeds.
1661    proc_->AddRuleForAllFamilies(hostname, "192.168.1.101");
1662    EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 80)->Resolve()) << i;
1663  }
1664
1665  proc_->SignalMultiple(requests_.size());
1666
1667  for (size_t i = 0; i < requests_.size(); ++i)
1668    EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
1669
1670  ASSERT_FALSE(proc_->HasBlockedRequests());
1671
1672  // DnsTask should be disabled by now.
1673  req = CreateRequest("ok_2", 80);
1674  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
1675  proc_->SignalMultiple(1u);
1676  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult());
1677
1678  // Check that it is re-enabled after DNS change.
1679  ChangeDnsConfig(CreateValidDnsConfig());
1680  req = CreateRequest("ok_3", 80);
1681  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
1682  EXPECT_EQ(OK, req->WaitForResult());
1683}
1684
1685TEST_F(HostResolverImplDnsTest, DontDisableDnsClientOnSporadicFailure) {
1686  ChangeDnsConfig(CreateValidDnsConfig());
1687
1688  // |proc_| defaults to successes.
1689
1690  // 20 failures interleaved with 20 successes.
1691  for (unsigned i = 0; i < 40; ++i) {
1692    // Use custom names to require separate Jobs.
1693    std::string hostname = (i % 2) == 0 ? base::StringPrintf("nx_%u", i)
1694                                        : base::StringPrintf("ok_%u", i);
1695    EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 80)->Resolve()) << i;
1696  }
1697
1698  proc_->SignalMultiple(requests_.size());
1699
1700  for (size_t i = 0; i < requests_.size(); ++i)
1701    EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
1702
1703  // Make |proc_| default to failures.
1704  proc_->AddRuleForAllFamilies(std::string(), std::string());
1705
1706  // DnsTask should still be enabled.
1707  Request* req = CreateRequest("ok_last", 80);
1708  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
1709  EXPECT_EQ(OK, req->WaitForResult());
1710}
1711
1712// Confirm that resolving "localhost" is unrestricted even if there are no
1713// global IPv6 address. See SystemHostResolverCall for rationale.
1714// Test both the DnsClient and system host resolver paths.
1715TEST_F(HostResolverImplDnsTest, DualFamilyLocalhost) {
1716  // Use regular SystemHostResolverCall!
1717  scoped_refptr<HostResolverProc> proc(new SystemHostResolverProc());
1718  resolver_.reset(new HostResolverImpl(DefaultOptions(), NULL));
1719  resolver_->set_proc_params_for_test(DefaultParams(proc.get()));
1720
1721  resolver_->SetDnsClient(
1722      scoped_ptr<DnsClient>(new MockDnsClient(DnsConfig(), dns_rules_)));
1723  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
1724
1725  // Get the expected output.
1726  AddressList addrlist;
1727  int rv = proc->Resolve("localhost", ADDRESS_FAMILY_UNSPECIFIED, 0, &addrlist,
1728                         NULL);
1729  if (rv != OK)
1730    return;
1731
1732  for (unsigned i = 0; i < addrlist.size(); ++i)
1733    LOG(WARNING) << addrlist[i].ToString();
1734
1735  bool saw_ipv4 = AddressListContains(addrlist, "127.0.0.1", 0);
1736  bool saw_ipv6 = AddressListContains(addrlist, "::1", 0);
1737  if (!saw_ipv4 && !saw_ipv6)
1738    return;
1739
1740  HostResolver::RequestInfo info(HostPortPair("localhost", 80));
1741  info.set_address_family(ADDRESS_FAMILY_UNSPECIFIED);
1742  info.set_host_resolver_flags(HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6);
1743
1744  // Try without DnsClient.
1745  ChangeDnsConfig(DnsConfig());
1746  Request* req = CreateRequest(info, DEFAULT_PRIORITY);
1747  // It is resolved via getaddrinfo, so expect asynchronous result.
1748  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
1749  EXPECT_EQ(OK, req->WaitForResult());
1750
1751  EXPECT_EQ(saw_ipv4, req->HasAddress("127.0.0.1", 80));
1752  EXPECT_EQ(saw_ipv6, req->HasAddress("::1", 80));
1753
1754  // Configure DnsClient with dual-host HOSTS file.
1755  DnsConfig config = CreateValidDnsConfig();
1756  DnsHosts hosts;
1757  IPAddressNumber local_ipv4, local_ipv6;
1758  ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &local_ipv4));
1759  ASSERT_TRUE(ParseIPLiteralToNumber("::1", &local_ipv6));
1760  if (saw_ipv4)
1761    hosts[DnsHostsKey("localhost", ADDRESS_FAMILY_IPV4)] = local_ipv4;
1762  if (saw_ipv6)
1763    hosts[DnsHostsKey("localhost", ADDRESS_FAMILY_IPV6)] = local_ipv6;
1764  config.hosts = hosts;
1765
1766  ChangeDnsConfig(config);
1767  req = CreateRequest(info, DEFAULT_PRIORITY);
1768  // Expect synchronous resolution from DnsHosts.
1769  EXPECT_EQ(OK, req->Resolve());
1770
1771  EXPECT_EQ(saw_ipv4, req->HasAddress("127.0.0.1", 80));
1772  EXPECT_EQ(saw_ipv6, req->HasAddress("::1", 80));
1773}
1774
1775// Cancel a request with a single DNS transaction active.
1776TEST_F(HostResolverImplDnsTest, CancelWithOneTransactionActive) {
1777  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
1778  ChangeDnsConfig(CreateValidDnsConfig());
1779
1780  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
1781  EXPECT_EQ(1u, num_running_dispatcher_jobs());
1782  requests_[0]->Cancel();
1783
1784  // Dispatcher state checked in TearDown.
1785}
1786
1787// Cancel a request with a single DNS transaction active and another pending.
1788TEST_F(HostResolverImplDnsTest, CancelWithOneTransactionActiveOnePending) {
1789  CreateSerialResolver();
1790  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
1791  ChangeDnsConfig(CreateValidDnsConfig());
1792
1793  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
1794  EXPECT_EQ(1u, num_running_dispatcher_jobs());
1795  requests_[0]->Cancel();
1796
1797  // Dispatcher state checked in TearDown.
1798}
1799
1800// Cancel a request with two DNS transactions active.
1801TEST_F(HostResolverImplDnsTest, CancelWithTwoTransactionsActive) {
1802  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
1803  ChangeDnsConfig(CreateValidDnsConfig());
1804
1805  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
1806  EXPECT_EQ(2u, num_running_dispatcher_jobs());
1807  requests_[0]->Cancel();
1808
1809  // Dispatcher state checked in TearDown.
1810}
1811
1812// Delete a resolver with some active requests and some queued requests.
1813TEST_F(HostResolverImplDnsTest, DeleteWithActiveTransactions) {
1814  // At most 10 Jobs active at once.
1815  CreateResolverWithLimitsAndParams(10u, DefaultParams(proc_.get()));
1816
1817  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
1818  ChangeDnsConfig(CreateValidDnsConfig());
1819
1820  // First active job is an IPv4 request.
1821  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80, MEDIUM,
1822                                          ADDRESS_FAMILY_IPV4)->Resolve());
1823
1824  // Add 10 more DNS lookups for different hostnames.  First 4 should have two
1825  // active jobs, next one has a single active job, and one pending.  Others
1826  // should all be queued.
1827  for (int i = 0; i < 10; ++i) {
1828    EXPECT_EQ(ERR_IO_PENDING, CreateRequest(
1829        base::StringPrintf("ok%i", i))->Resolve());
1830  }
1831  EXPECT_EQ(10u, num_running_dispatcher_jobs());
1832
1833  resolver_.reset();
1834}
1835
1836// Cancel a request with only the IPv6 transaction active.
1837TEST_F(HostResolverImplDnsTest, CancelWithIPv6TransactionActive) {
1838  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
1839  ChangeDnsConfig(CreateValidDnsConfig());
1840
1841  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("6slow_ok", 80)->Resolve());
1842  EXPECT_EQ(2u, num_running_dispatcher_jobs());
1843
1844  // The IPv4 request should complete, the IPv6 request is still pending.
1845  base::RunLoop().RunUntilIdle();
1846  EXPECT_EQ(1u, num_running_dispatcher_jobs());
1847  requests_[0]->Cancel();
1848
1849  // Dispatcher state checked in TearDown.
1850}
1851
1852// Cancel a request with only the IPv4 transaction pending.
1853TEST_F(HostResolverImplDnsTest, CancelWithIPv4TransactionPending) {
1854  set_fallback_to_proctask(false);
1855  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
1856  ChangeDnsConfig(CreateValidDnsConfig());
1857
1858  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_ok", 80)->Resolve());
1859  EXPECT_EQ(2u, num_running_dispatcher_jobs());
1860
1861  // The IPv6 request should complete, the IPv4 request is still pending.
1862  base::RunLoop().RunUntilIdle();
1863  EXPECT_EQ(1u, num_running_dispatcher_jobs());
1864
1865  requests_[0]->Cancel();
1866}
1867
1868// Test cases where AAAA completes first.
1869TEST_F(HostResolverImplDnsTest, AAAACompletesFirst) {
1870  set_fallback_to_proctask(false);
1871  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
1872  ChangeDnsConfig(CreateValidDnsConfig());
1873
1874  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_ok", 80)->Resolve());
1875  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_4ok", 80)->Resolve());
1876  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_4timeout", 80)->Resolve());
1877  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_6timeout", 80)->Resolve());
1878
1879  base::RunLoop().RunUntilIdle();
1880  EXPECT_FALSE(requests_[0]->completed());
1881  EXPECT_FALSE(requests_[1]->completed());
1882  EXPECT_FALSE(requests_[2]->completed());
1883  // The IPv6 of the third request should have failed and resulted in cancelling
1884  // the IPv4 request.
1885  EXPECT_TRUE(requests_[3]->completed());
1886  EXPECT_EQ(ERR_DNS_TIMED_OUT, requests_[3]->result());
1887  EXPECT_EQ(3u, num_running_dispatcher_jobs());
1888
1889  dns_client_->CompleteDelayedTransactions();
1890  EXPECT_TRUE(requests_[0]->completed());
1891  EXPECT_EQ(OK, requests_[0]->result());
1892  EXPECT_EQ(2u, requests_[0]->NumberOfAddresses());
1893  EXPECT_TRUE(requests_[0]->HasAddress("127.0.0.1", 80));
1894  EXPECT_TRUE(requests_[0]->HasAddress("::1", 80));
1895
1896  EXPECT_TRUE(requests_[1]->completed());
1897  EXPECT_EQ(OK, requests_[1]->result());
1898  EXPECT_EQ(1u, requests_[1]->NumberOfAddresses());
1899  EXPECT_TRUE(requests_[1]->HasAddress("127.0.0.1", 80));
1900
1901  EXPECT_TRUE(requests_[2]->completed());
1902  EXPECT_EQ(ERR_DNS_TIMED_OUT, requests_[2]->result());
1903}
1904
1905// Test the case where only a single transaction slot is available.
1906TEST_F(HostResolverImplDnsTest, SerialResolver) {
1907  CreateSerialResolver();
1908  set_fallback_to_proctask(false);
1909  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
1910  ChangeDnsConfig(CreateValidDnsConfig());
1911
1912  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
1913  EXPECT_EQ(1u, num_running_dispatcher_jobs());
1914
1915  base::RunLoop().RunUntilIdle();
1916  EXPECT_TRUE(requests_[0]->completed());
1917  EXPECT_EQ(OK, requests_[0]->result());
1918  EXPECT_EQ(2u, requests_[0]->NumberOfAddresses());
1919  EXPECT_TRUE(requests_[0]->HasAddress("127.0.0.1", 80));
1920  EXPECT_TRUE(requests_[0]->HasAddress("::1", 80));
1921}
1922
1923// Test the case where the AAAA query is started when another transaction
1924// completes.
1925TEST_F(HostResolverImplDnsTest, AAAAStartsAfterOtherJobFinishes) {
1926  CreateResolverWithLimitsAndParams(2u, DefaultParams(proc_.get()));
1927  set_fallback_to_proctask(false);
1928  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
1929  ChangeDnsConfig(CreateValidDnsConfig());
1930
1931  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80, MEDIUM,
1932                                          ADDRESS_FAMILY_IPV4)->Resolve());
1933  EXPECT_EQ(ERR_IO_PENDING,
1934            CreateRequest("4slow_ok", 80, MEDIUM)->Resolve());
1935  // An IPv4 request should have been started pending for each job.
1936  EXPECT_EQ(2u, num_running_dispatcher_jobs());
1937
1938  // Request 0's IPv4 request should complete, starting Request 1's IPv6
1939  // request, which should also complete.
1940  base::RunLoop().RunUntilIdle();
1941  EXPECT_EQ(1u, num_running_dispatcher_jobs());
1942  EXPECT_TRUE(requests_[0]->completed());
1943  EXPECT_FALSE(requests_[1]->completed());
1944
1945  dns_client_->CompleteDelayedTransactions();
1946  EXPECT_TRUE(requests_[1]->completed());
1947  EXPECT_EQ(OK, requests_[1]->result());
1948  EXPECT_EQ(2u, requests_[1]->NumberOfAddresses());
1949  EXPECT_TRUE(requests_[1]->HasAddress("127.0.0.1", 80));
1950  EXPECT_TRUE(requests_[1]->HasAddress("::1", 80));
1951}
1952
1953// Tests the case that a Job with a single transaction receives an empty address
1954// list, triggering fallback to ProcTask.
1955TEST_F(HostResolverImplDnsTest, IPv4EmptyFallback) {
1956  ChangeDnsConfig(CreateValidDnsConfig());
1957  proc_->AddRuleForAllFamilies("empty_fallback", "192.168.0.1");
1958  proc_->SignalMultiple(1u);
1959  EXPECT_EQ(ERR_IO_PENDING,
1960            CreateRequest("empty_fallback", 80, MEDIUM,
1961                          ADDRESS_FAMILY_IPV4)->Resolve());
1962  EXPECT_EQ(OK, requests_[0]->WaitForResult());
1963  EXPECT_TRUE(requests_[0]->HasOneAddress("192.168.0.1", 80));
1964}
1965
1966// Tests the case that a Job with two transactions receives two empty address
1967// lists, triggering fallback to ProcTask.
1968TEST_F(HostResolverImplDnsTest, UnspecEmptyFallback) {
1969  ChangeDnsConfig(CreateValidDnsConfig());
1970  proc_->AddRuleForAllFamilies("empty_fallback", "192.168.0.1");
1971  proc_->SignalMultiple(1u);
1972  EXPECT_EQ(ERR_IO_PENDING,
1973            CreateRequest("empty_fallback", 80, MEDIUM,
1974                          ADDRESS_FAMILY_UNSPECIFIED)->Resolve());
1975  EXPECT_EQ(OK, requests_[0]->WaitForResult());
1976  EXPECT_TRUE(requests_[0]->HasOneAddress("192.168.0.1", 80));
1977}
1978
1979// Tests getting a new invalid DnsConfig while there are active DnsTasks.
1980TEST_F(HostResolverImplDnsTest, InvalidDnsConfigWithPendingRequests) {
1981  // At most 3 jobs active at once.  This number is important, since we want to
1982  // make sure that aborting the first HostResolverImpl::Job does not trigger
1983  // another DnsTransaction on the second Job when it releases its second
1984  // prioritized dispatcher slot.
1985  CreateResolverWithLimitsAndParams(3u, DefaultParams(proc_.get()));
1986
1987  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
1988  ChangeDnsConfig(CreateValidDnsConfig());
1989
1990  proc_->AddRuleForAllFamilies("slow_nx1", "192.168.0.1");
1991  proc_->AddRuleForAllFamilies("slow_nx2", "192.168.0.2");
1992  proc_->AddRuleForAllFamilies("ok", "192.168.0.3");
1993
1994  // First active job gets two slots.
1995  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_nx1")->Resolve());
1996  // Next job gets one slot, and waits on another.
1997  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_nx2")->Resolve());
1998  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok")->Resolve());
1999
2000  EXPECT_EQ(3u, num_running_dispatcher_jobs());
2001
2002  // Clear DNS config.  Two in-progress jobs should be aborted, and the next one
2003  // should use a ProcTask.
2004  ChangeDnsConfig(DnsConfig());
2005  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->WaitForResult());
2006  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[1]->WaitForResult());
2007
2008  // Finish up the third job.  Should bypass the DnsClient, and get its results
2009  // from MockHostResolverProc.
2010  EXPECT_FALSE(requests_[2]->completed());
2011  proc_->SignalMultiple(1u);
2012  EXPECT_EQ(OK, requests_[2]->WaitForResult());
2013  EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.0.3", 80));
2014}
2015
2016// Tests the case that DnsClient is automatically disabled due to failures
2017// while there are active DnsTasks.
2018TEST_F(HostResolverImplDnsTest,
2019       AutomaticallyDisableDnsClientWithPendingRequests) {
2020  // Trying different limits is important for this test:  Different limits
2021  // result in different behavior when aborting in-progress DnsTasks.  Having
2022  // a DnsTask that has one job active and one in the queue when another job
2023  // occupying two slots has its DnsTask aborted is the case most likely to run
2024  // into problems.
2025  for (size_t limit = 1u; limit < 6u; ++limit) {
2026    CreateResolverWithLimitsAndParams(limit, DefaultParams(proc_.get()));
2027
2028    resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
2029    ChangeDnsConfig(CreateValidDnsConfig());
2030
2031    // Queue up enough failures to disable DnsTasks.  These will all fall back
2032    // to ProcTasks, and succeed there.
2033    for (unsigned i = 0u; i < maximum_dns_failures(); ++i) {
2034      std::string host = base::StringPrintf("nx%u", i);
2035      proc_->AddRuleForAllFamilies(host, "192.168.0.1");
2036      EXPECT_EQ(ERR_IO_PENDING, CreateRequest(host)->Resolve());
2037    }
2038
2039    // These requests should all bypass DnsTasks, due to the above failures,
2040    // so should end up using ProcTasks.
2041    proc_->AddRuleForAllFamilies("slow_ok1", "192.168.0.2");
2042    EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_ok1")->Resolve());
2043    proc_->AddRuleForAllFamilies("slow_ok2", "192.168.0.3");
2044    EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_ok2")->Resolve());
2045    proc_->AddRuleForAllFamilies("slow_ok3", "192.168.0.4");
2046    EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_ok3")->Resolve());
2047    proc_->SignalMultiple(maximum_dns_failures() + 3);
2048
2049    for (size_t i = 0u; i < maximum_dns_failures(); ++i) {
2050      EXPECT_EQ(OK, requests_[i]->WaitForResult());
2051      EXPECT_TRUE(requests_[i]->HasOneAddress("192.168.0.1", 80));
2052    }
2053
2054    EXPECT_EQ(OK, requests_[maximum_dns_failures()]->WaitForResult());
2055    EXPECT_TRUE(requests_[maximum_dns_failures()]->HasOneAddress(
2056                    "192.168.0.2", 80));
2057    EXPECT_EQ(OK, requests_[maximum_dns_failures() + 1]->WaitForResult());
2058    EXPECT_TRUE(requests_[maximum_dns_failures() + 1]->HasOneAddress(
2059                    "192.168.0.3", 80));
2060    EXPECT_EQ(OK, requests_[maximum_dns_failures() + 2]->WaitForResult());
2061    EXPECT_TRUE(requests_[maximum_dns_failures() + 2]->HasOneAddress(
2062                    "192.168.0.4", 80));
2063    requests_.clear();
2064  }
2065}
2066
2067// Tests a call to SetDnsClient while there are active DnsTasks.
2068TEST_F(HostResolverImplDnsTest, ManuallyDisableDnsClientWithPendingRequests) {
2069  // At most 3 jobs active at once.  This number is important, since we want to
2070  // make sure that aborting the first HostResolverImpl::Job does not trigger
2071  // another DnsTransaction on the second Job when it releases its second
2072  // prioritized dispatcher slot.
2073  CreateResolverWithLimitsAndParams(3u, DefaultParams(proc_.get()));
2074
2075  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
2076  ChangeDnsConfig(CreateValidDnsConfig());
2077
2078  proc_->AddRuleForAllFamilies("slow_ok1", "192.168.0.1");
2079  proc_->AddRuleForAllFamilies("slow_ok2", "192.168.0.2");
2080  proc_->AddRuleForAllFamilies("ok", "192.168.0.3");
2081
2082  // First active job gets two slots.
2083  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_ok1")->Resolve());
2084  // Next job gets one slot, and waits on another.
2085  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_ok2")->Resolve());
2086  // Next one is queued.
2087  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok")->Resolve());
2088
2089  EXPECT_EQ(3u, num_running_dispatcher_jobs());
2090
2091  // Clear DnsClient.  The two in-progress jobs should fall back to a ProcTask,
2092  // and the next one should be started with a ProcTask.
2093  resolver_->SetDnsClient(scoped_ptr<DnsClient>());
2094
2095  // All three in-progress requests should now be running a ProcTask.
2096  EXPECT_EQ(3u, num_running_dispatcher_jobs());
2097  proc_->SignalMultiple(3u);
2098
2099  EXPECT_EQ(OK, requests_[0]->WaitForResult());
2100  EXPECT_TRUE(requests_[0]->HasOneAddress("192.168.0.1", 80));
2101  EXPECT_EQ(OK, requests_[1]->WaitForResult());
2102  EXPECT_TRUE(requests_[1]->HasOneAddress("192.168.0.2", 80));
2103  EXPECT_EQ(OK, requests_[2]->WaitForResult());
2104  EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.0.3", 80));
2105}
2106
2107}  // namespace net
2108