net/dns/host_resolver_impl_unittest.cc

   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
  30 namespace net {
  31
  32 namespace {
  33
  34 const size_t kMaxJobs = 10u;
  35 const size_t kMaxRetryAttempts = 4u;
  36
  37 HostResolver::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
  45 HostResolverImpl::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.
  54 class 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
 183 bool 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.
 194 class 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.
 318 class 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
 420 class 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
 542 TEST_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
 555 TEST_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
 566 TEST_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
 581 TEST_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
 611 TEST_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
 625 TEST_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
 640 TEST_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
 654 TEST_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
 669 TEST_F(HostResolverImplTest, MAYBE_LongHost) {
 670   Request* req = CreateRequest(std::string(4097, 'a'), 5555);
 671   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve());
 672 }
 673
 674 TEST_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
 690 TEST_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
 708 TEST_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
 733 TEST_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
 762 TEST_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
 788 TEST_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
 828 TEST_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
 859 TEST_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.
 894 TEST_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.
 916 TEST_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.
 931 TEST_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.
 957 TEST_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.
1003 TEST_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.
1046 TEST_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.
1089 TEST_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.
1147 TEST_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.
1194 TEST_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.
1241 TEST_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
1266 TEST_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.
1286 TEST_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
1324 DnsConfig 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.
1336 class 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.
1419 TEST_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.
1453 TEST_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.
1500 TEST_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
1525 TEST_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
1552 TEST_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
1607 TEST_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
1628 TEST_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
1646 TEST_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
1685 TEST_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.
1715 TEST_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.
1776 TEST_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.
1788 TEST_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.
1801 TEST_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.
1813 TEST_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.
1837 TEST_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.
1853 TEST_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.
1869 TEST_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.
1906 TEST_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.
1925 TEST_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.
1955 TEST_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.
1968 TEST_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.
1980 TEST_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.
2018 TEST_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.
2068 TEST_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