Clang format slam.

net/dns/host_resolver_impl_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/dns/host_resolver_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 38 matching lines @@
 // waiting for a specific number of requests. Unlike RuleBasedHostResolverProc
 // it never calls SystemHostResolverCall. By default resolves all hostnames to
 // "127.0.0.1". After AddRule(), it resolves only names explicitly specified.
 class MockHostResolverProc : public HostResolverProc {
  public:
   struct ResolveKey {
     ResolveKey(const std::string& hostname, AddressFamily address_family)
         : hostname(hostname), address_family(address_family) {}
     bool operator<(const ResolveKey& other) const {
       return address_family < other.address_family ||
-          (address_family == other.address_family && hostname < other.hostname);
+             (address_family == other.address_family &&
+              hostname < other.hostname);
     }
     std::string hostname;
     AddressFamily address_family;
   };
 
   typedef std::vector<ResolveKey> CaptureList;
 
   MockHostResolverProc()
       : HostResolverProc(NULL),
         num_requests_waiting_(0),
         num_slots_available_(0),
         requests_waiting_(&lock_),
-        slots_available_(&lock_) {
-  }
+        slots_available_(&lock_) {}
 
   // Waits until |count| calls to |Resolve| are blocked. Returns false when
   // timed out.
   bool WaitFor(unsigned count) {
     base::AutoLock lock(lock_);
     base::Time start_time = base::Time::Now();
     while (num_requests_waiting_ < count) {
       requests_waiting_.TimedWait(TestTimeouts::action_timeout());
       if (base::Time::Now() > start_time + TestTimeouts::action_timeout())
         return false;
     }
     return true;
   }
 
   // Signals |count| waiting calls to |Resolve|. First come first served.
   void SignalMultiple(unsigned count) {
     base::AutoLock lock(lock_);
     num_slots_available_ += count;
     slots_available_.Broadcast();
   }
 
   // Signals all waiting calls to |Resolve|. Beware of races.
   void SignalAll() {
     base::AutoLock lock(lock_);
     num_slots_available_ = num_requests_waiting_;
     slots_available_.Broadcast();
   }
 
-  void AddRule(const std::string& hostname, AddressFamily family,
+  void AddRule(const std::string& hostname,
+               AddressFamily family,
                const AddressList& result) {
     base::AutoLock lock(lock_);
     rules_[ResolveKey(hostname, family)] = result;
   }
 
-  void AddRule(const std::string& hostname, AddressFamily family,
+  void AddRule(const std::string& hostname,
+               AddressFamily family,
                const std::string& ip_list) {
     AddressList result;
     int rv = ParseAddressList(ip_list, std::string(), &result);
     DCHECK_EQ(OK, rv);
     AddRule(hostname, family, result);
   }
 
   void AddRuleForAllFamilies(const std::string& hostname,
                              const std::string& ip_list) {
     AddressList result;
@@ skipping 52 matching lines @@
   std::map<ResolveKey, AddressList> rules_;
   CaptureList capture_list_;
   unsigned num_requests_waiting_;
   unsigned num_slots_available_;
   base::ConditionVariable requests_waiting_;
   base::ConditionVariable slots_available_;
 
   DISALLOW_COPY_AND_ASSIGN(MockHostResolverProc);
 };
 
-bool AddressListContains(const AddressList& list, const std::string& address,
+bool AddressListContains(const AddressList& list,
+                         const std::string& address,
                          int port) {
   IPAddressNumber ip;
   bool rv = ParseIPLiteralToNumber(address, &ip);
   DCHECK(rv);
-  return std::find(list.begin(),
-                   list.end(),
-                   IPEndPoint(ip, port)) != list.end();
+  return std::find(list.begin(), list.end(), IPEndPoint(ip, port)) !=
+         list.end();
 }
 
 // A wrapper for requests to a HostResolver.
 class Request {
  public:
   // Base class of handlers to be executed on completion of requests.
   struct Handler {
     virtual ~Handler() {}
     virtual void Handle(Request* request) = 0;
   };
@@ skipping 46 matching lines @@
   const AddressList& list() const { return list_; }
   int result() const { return result_; }
   bool completed() const { return result_ != ERR_IO_PENDING; }
   bool pending() const { return handle_ != NULL; }
 
   bool HasAddress(const std::string& address, int port) const {
     return AddressListContains(list_, address, port);
   }
 
   // Returns the number of addresses in |list_|.
-  unsigned NumberOfAddresses() const {
-    return list_.size();
-  }
+  unsigned NumberOfAddresses() const { return list_.size(); }
 
   bool HasOneAddress(const std::string& address, int port) const {
     return HasAddress(address, port) && (NumberOfAddresses() == 1u);
   }
 
   // Returns ERR_UNEXPECTED if timed out.
   int WaitForResult() {
     if (completed())
       return result_;
     base::CancelableClosure closure(base::MessageLoop::QuitClosure());
@@ skipping 49 matching lines @@
  public:
   LookupAttemptHostResolverProc(HostResolverProc* previous,
                                 int attempt_number_to_resolve,
                                 int total_attempts)
       : HostResolverProc(previous),
         attempt_number_to_resolve_(attempt_number_to_resolve),
         current_attempt_number_(0),
         total_attempts_(total_attempts),
         total_attempts_resolved_(0),
         resolved_attempt_number_(0),
-        all_done_(&lock_) {
-  }
+        all_done_(&lock_) {}
 
   // Test harness will wait for all attempts to finish before checking the
   // results.
   void WaitForAllAttemptsToFinish(const base::TimeDelta& wait_time) {
     base::TimeTicks end_time = base::TimeTicks::Now() + wait_time;
     {
       base::AutoLock auto_lock(lock_);
       while (total_attempts_resolved_ != total_attempts_ &&
-          base::TimeTicks::Now() < end_time) {
+             base::TimeTicks::Now() < end_time) {
         all_done_.TimedWait(end_time - base::TimeTicks::Now());
       }
     }
   }
 
   // All attempts will wait for an attempt to resolve the host.
   void WaitForAnAttemptToComplete() {
     base::TimeDelta wait_time = base::TimeDelta::FromSeconds(60);
     base::TimeTicks end_time = base::TimeTicks::Now() + wait_time;
     {
@@ skipping 23 matching lines @@
       if (current_attempt_number_ == attempt_number_to_resolve_) {
         resolved_attempt_number_ = current_attempt_number_;
         wait_for_right_attempt_to_complete = false;
       }
     }
 
     if (wait_for_right_attempt_to_complete)
       // Wait for the attempt_number_to_resolve_ attempt to resolve.
       WaitForAnAttemptToComplete();
 
-    int result = ResolveUsingPrevious(host, address_family, host_resolver_flags,
-                                      addrlist, os_error);
+    int result = ResolveUsingPrevious(
+        host, address_family, host_resolver_flags, addrlist, os_error);
 
     {
       base::AutoLock auto_lock(lock_);
       ++total_attempts_resolved_;
     }
 
     all_done_.Broadcast();  // Tell all attempts to proceed.
 
     // Since any negative number is considered a network error, with -1 having
     // special meaning (ERR_IO_PENDING). We could return the attempt that has
@@ skipping 59 matching lines @@
       return test->CreateRequest(hostname);
     }
     ScopedVector<Request>& requests() { return test->requests_; }
 
     void DeleteResolver() { test->resolver_.reset(); }
 
     HostResolverImplTest* test;
   };
 
   // testing::Test implementation:
-  virtual void SetUp() OVERRIDE {
-    CreateResolver();
-  }
+  virtual void SetUp() OVERRIDE { CreateResolver(); }
 
   virtual void TearDown() OVERRIDE {
     if (resolver_.get())
       EXPECT_EQ(0u, resolver_->num_running_dispatcher_jobs_for_tests());
     EXPECT_FALSE(proc_->HasBlockedRequests());
   }
 
   virtual void CreateResolverWithLimitsAndParams(
       const PrioritizedDispatcher::Limits& limits,
       const HostResolverImpl::ProcTaskParams& params) {
-    resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
-                                         limits, params, NULL));
+    resolver_.reset(new HostResolverImpl(
+        HostCache::CreateDefaultCache(), limits, params, NULL));
   }
 
   // The Request will not be made until a call to |Resolve()|, and the Job will
   // not start until released by |proc_->SignalXXX|.
   Request* CreateRequest(const HostResolver::RequestInfo& info,
                          RequestPriority priority) {
     Request* req = new Request(
         info, priority, requests_.size(), resolver_.get(), handler_.get());
     requests_.push_back(req);
     return req;
@@ skipping 778 matching lines @@
       new LookupAttemptHostResolverProc(
           NULL, kAttemptNumberToResolve, kTotalAttempts));
 
   HostResolverImpl::ProcTaskParams params = DefaultParams(resolver_proc.get());
 
   // Specify smaller interval for unresponsive_delay_ for HostResolverImpl so
   // that unit test runs faster. For example, this test finishes in 1.5 secs
   // (500ms * 3).
   params.unresponsive_delay = base::TimeDelta::FromMilliseconds(500);
 
-  resolver_.reset(
-      new HostResolverImpl(HostCache::CreateDefaultCache(),
-                           DefaultLimits(),
-                           params,
-                           NULL));
+  resolver_.reset(new HostResolverImpl(
+      HostCache::CreateDefaultCache(), DefaultLimits(), params, NULL));
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
   Request* req = CreateRequest(info, DEFAULT_PRIORITY);
   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
 
   // Resolve returns -4 to indicate that 3rd attempt has resolved the host.
   EXPECT_EQ(-4, req->WaitForResult());
 
   resolver_proc->WaitForAllAttemptsToFinish(
@@ skipping 27 matching lines @@
     AddDnsRule("nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL, false);
     AddDnsRule("ok", dns_protocol::kTypeA, MockDnsClientRule::OK, false);
     AddDnsRule("ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK, false);
     AddDnsRule("4ok", dns_protocol::kTypeA, MockDnsClientRule::OK, false);
     AddDnsRule("4ok", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY, false);
     AddDnsRule("6ok", dns_protocol::kTypeA, MockDnsClientRule::EMPTY, false);
     AddDnsRule("6ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK, false);
     AddDnsRule("4nx", dns_protocol::kTypeA, MockDnsClientRule::OK, false);
     AddDnsRule("4nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL, false);
     AddDnsRule("empty", dns_protocol::kTypeA, MockDnsClientRule::EMPTY, false);
-    AddDnsRule("empty", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY,
-               false);
+    AddDnsRule(
+        "empty", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY, false);
 
     AddDnsRule("slow_nx", dns_protocol::kTypeA, MockDnsClientRule::FAIL, true);
-    AddDnsRule("slow_nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL,
-               true);
+    AddDnsRule(
+        "slow_nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL, true);
 
     AddDnsRule("4slow_ok", dns_protocol::kTypeA, MockDnsClientRule::OK, true);
-    AddDnsRule("4slow_ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK,
+    AddDnsRule(
+        "4slow_ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK, false);
+    AddDnsRule("6slow_ok", dns_protocol::kTypeA, MockDnsClientRule::OK, false);
+    AddDnsRule(
+        "6slow_ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK, true);
+    AddDnsRule("4slow_4ok", dns_protocol::kTypeA, MockDnsClientRule::OK, true);
+    AddDnsRule(
+        "4slow_4ok", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY, false);
+    AddDnsRule("4slow_4timeout",
+               dns_protocol::kTypeA,
+               MockDnsClientRule::TIMEOUT,
+               true);
+    AddDnsRule("4slow_4timeout",
+               dns_protocol::kTypeAAAA,
+               MockDnsClientRule::OK,
                false);
-    AddDnsRule("6slow_ok", dns_protocol::kTypeA, MockDnsClientRule::OK, false);
-    AddDnsRule("6slow_ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK,
-               true);
-    AddDnsRule("4slow_4ok", dns_protocol::kTypeA, MockDnsClientRule::OK, true);
-    AddDnsRule("4slow_4ok", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY,
+    AddDnsRule(
+        "4slow_6timeout", dns_protocol::kTypeA, MockDnsClientRule::OK, true);
+    AddDnsRule("4slow_6timeout",
+               dns_protocol::kTypeAAAA,
+               MockDnsClientRule::TIMEOUT,
                false);
-    AddDnsRule("4slow_4timeout", dns_protocol::kTypeA,
-               MockDnsClientRule::TIMEOUT, true);
-    AddDnsRule("4slow_4timeout", dns_protocol::kTypeAAAA, MockDnsClientRule::OK,
-               false);
-    AddDnsRule("4slow_6timeout", dns_protocol::kTypeA,
-               MockDnsClientRule::OK, true);
-    AddDnsRule("4slow_6timeout", dns_protocol::kTypeAAAA,
-               MockDnsClientRule::TIMEOUT, false);
     CreateResolver();
   }
 
   // HostResolverImplTest implementation:
   virtual void CreateResolverWithLimitsAndParams(
       const PrioritizedDispatcher::Limits& limits,
       const HostResolverImpl::ProcTaskParams& params) OVERRIDE {
-    resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
-                                         limits,
-                                         params,
-                                         NULL));
+    resolver_.reset(new HostResolverImpl(
+        HostCache::CreateDefaultCache(), limits, params, NULL));
     // Disable IPv6 support probing.
     resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
     dns_client_ = new MockDnsClient(DnsConfig(), dns_rules_);
     resolver_->SetDnsClient(scoped_ptr<DnsClient>(dns_client_));
   }
 
   // Adds a rule to |dns_rules_|. Must be followed by |CreateResolver| to apply.
   void AddDnsRule(const std::string& prefix,
                   uint16 qtype,
                   MockDnsClientRule::Result result,
@@ skipping 180 matching lines @@
   Request* req1 = CreateRequest("nx_ipv4", 80);
   EXPECT_EQ(OK, req1->Resolve());
   EXPECT_TRUE(req1->HasOneAddress("127.0.0.1", 80));
 
   Request* req2 = CreateRequest("nx_ipv6", 80);
   EXPECT_EQ(OK, req2->Resolve());
   EXPECT_TRUE(req2->HasOneAddress("::1", 80));
 
   Request* req3 = CreateRequest("nx_both", 80);
   EXPECT_EQ(OK, req3->Resolve());
-  EXPECT_TRUE(req3->HasAddress("127.0.0.1", 80) &&
-              req3->HasAddress("::1", 80));
+  EXPECT_TRUE(req3->HasAddress("127.0.0.1", 80) && req3->HasAddress("::1", 80));
 
   // Requests with specified AddressFamily.
   Request* req4 = CreateRequest("nx_ipv4", 80, MEDIUM, ADDRESS_FAMILY_IPV4);
   EXPECT_EQ(OK, req4->Resolve());
   EXPECT_TRUE(req4->HasOneAddress("127.0.0.1", 80));
 
   Request* req5 = CreateRequest("nx_ipv6", 80, MEDIUM, ADDRESS_FAMILY_IPV6);
   EXPECT_EQ(OK, req5->Resolve());
   EXPECT_TRUE(req5->HasOneAddress("::1", 80));
 
@@ skipping 117 matching lines @@
   resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
                                        DefaultLimits(),
                                        DefaultParams(proc.get()),
                                        NULL));
   resolver_->SetDnsClient(
       scoped_ptr<DnsClient>(new MockDnsClient(DnsConfig(), dns_rules_)));
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
 
   // Get the expected output.
   AddressList addrlist;
-  int rv = proc->Resolve("localhost", ADDRESS_FAMILY_UNSPECIFIED, 0, &addrlist,
-                         NULL);
+  int rv = proc->Resolve(
+      "localhost", ADDRESS_FAMILY_UNSPECIFIED, 0, &addrlist, NULL);
   if (rv != OK)
     return;
 
   for (unsigned i = 0; i < addrlist.size(); ++i)
     LOG(WARNING) << addrlist[i].ToString();
 
   bool saw_ipv4 = AddressListContains(addrlist, "127.0.0.1", 0);
   bool saw_ipv6 = AddressListContains(addrlist, "::1", 0);
   if (!saw_ipv4 && !saw_ipv6)
     return;
@@ skipping 74 matching lines @@
 TEST_F(HostResolverImplDnsTest, DeleteWithActiveTransactions) {
   // At most 10 Jobs active at once.
   CreateResolverWithLimitsAndParams(
       PrioritizedDispatcher::Limits(NUM_PRIORITIES, 10u),
       DefaultParams(proc_.get()));
 
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
 
   // First active job is an IPv4 request.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80, MEDIUM,
-                                          ADDRESS_FAMILY_IPV4)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING,
+            CreateRequest("ok", 80, MEDIUM, ADDRESS_FAMILY_IPV4)->Resolve());
 
   // Add 10 more DNS lookups for different hostnames.  First 4 should have two
   // active jobs, next one has a single active job, and one pending.  Others
   // should all be queued.
   for (int i = 0; i < 10; ++i) {
-    EXPECT_EQ(ERR_IO_PENDING, CreateRequest(
-        base::StringPrintf("ok%i", i))->Resolve());
+    EXPECT_EQ(ERR_IO_PENDING,
+              CreateRequest(base::StringPrintf("ok%i", i))->Resolve());
   }
   EXPECT_EQ(10u, num_running_dispatcher_jobs());
 
   resolver_.reset();
 }
 
 // Cancel a request with only the IPv6 transaction active.
 TEST_F(HostResolverImplDnsTest, CancelWithIPv6TransactionActive) {
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
@@ skipping 83 matching lines @@
 // Test the case where the AAAA query is started when another transaction
 // completes.
 TEST_F(HostResolverImplDnsTest, AAAAStartsAfterOtherJobFinishes) {
   CreateResolverWithLimitsAndParams(
       PrioritizedDispatcher::Limits(NUM_PRIORITIES, 2),
       DefaultParams(proc_.get()));
   set_fallback_to_proctask(false);
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80, MEDIUM,
-                                          ADDRESS_FAMILY_IPV4)->Resolve());
   EXPECT_EQ(ERR_IO_PENDING,
-            CreateRequest("4slow_ok", 80, MEDIUM)->Resolve());
+            CreateRequest("ok", 80, MEDIUM, ADDRESS_FAMILY_IPV4)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_ok", 80, MEDIUM)->Resolve());
   // An IPv4 request should have been started pending for each job.
   EXPECT_EQ(2u, num_running_dispatcher_jobs());
 
   // Request 0's IPv4 request should complete, starting Request 1's IPv6
   // request, which should also complete.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, num_running_dispatcher_jobs());
   EXPECT_TRUE(requests_[0]->completed());
   EXPECT_FALSE(requests_[1]->completed());
 
   dns_client_->CompleteDelayedTransactions();
   EXPECT_TRUE(requests_[1]->completed());
   EXPECT_EQ(OK, requests_[1]->result());
   EXPECT_EQ(2u, requests_[1]->NumberOfAddresses());
   EXPECT_TRUE(requests_[1]->HasAddress("127.0.0.1", 80));
   EXPECT_TRUE(requests_[1]->HasAddress("::1", 80));
 }
 
 // Tests the case that a Job with a single transaction receives an empty address
 // list, triggering fallback to ProcTask.
 TEST_F(HostResolverImplDnsTest, IPv4EmptyFallback) {
   ChangeDnsConfig(CreateValidDnsConfig());
   proc_->AddRuleForAllFamilies("empty_fallback", "192.168.0.1");
   proc_->SignalMultiple(1u);
   EXPECT_EQ(ERR_IO_PENDING,
-            CreateRequest("empty_fallback", 80, MEDIUM,
-                          ADDRESS_FAMILY_IPV4)->Resolve());
+            CreateRequest("empty_fallback", 80, MEDIUM, ADDRESS_FAMILY_IPV4)
+                ->Resolve());
   EXPECT_EQ(OK, requests_[0]->WaitForResult());
   EXPECT_TRUE(requests_[0]->HasOneAddress("192.168.0.1", 80));
 }
 
 // Tests the case that a Job with two transactions receives two empty address
 // lists, triggering fallback to ProcTask.
 TEST_F(HostResolverImplDnsTest, UnspecEmptyFallback) {
   ChangeDnsConfig(CreateValidDnsConfig());
   proc_->AddRuleForAllFamilies("empty_fallback", "192.168.0.1");
   proc_->SignalMultiple(1u);
-  EXPECT_EQ(ERR_IO_PENDING,
-            CreateRequest("empty_fallback", 80, MEDIUM,
-                          ADDRESS_FAMILY_UNSPECIFIED)->Resolve());
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      CreateRequest("empty_fallback", 80, MEDIUM, ADDRESS_FAMILY_UNSPECIFIED)
+          ->Resolve());
   EXPECT_EQ(OK, requests_[0]->WaitForResult());
   EXPECT_TRUE(requests_[0]->HasOneAddress("192.168.0.1", 80));
 }
 
 // Tests getting a new invalid DnsConfig while there are active DnsTasks.
 TEST_F(HostResolverImplDnsTest, InvalidDnsConfigWithPendingRequests) {
   // At most 3 jobs active at once.  This number is important, since we want to
   // make sure that aborting the first HostResolverImpl::Job does not trigger
   // another DnsTransaction on the second Job when it releases its second
   // prioritized dispatcher slot.
@@ skipping 64 matching lines @@
     proc_->AddRuleForAllFamilies("slow_ok3", "192.168.0.4");
     EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_ok3")->Resolve());
     proc_->SignalMultiple(maximum_dns_failures() + 3);
 
     for (size_t i = 0u; i < maximum_dns_failures(); ++i) {
       EXPECT_EQ(OK, requests_[i]->WaitForResult());
       EXPECT_TRUE(requests_[i]->HasOneAddress("192.168.0.1", 80));
     }
 
     EXPECT_EQ(OK, requests_[maximum_dns_failures()]->WaitForResult());
-    EXPECT_TRUE(requests_[maximum_dns_failures()]->HasOneAddress(
-                    "192.168.0.2", 80));
+    EXPECT_TRUE(
+        requests_[maximum_dns_failures()]->HasOneAddress("192.168.0.2", 80));
     EXPECT_EQ(OK, requests_[maximum_dns_failures() + 1]->WaitForResult());
     EXPECT_TRUE(requests_[maximum_dns_failures() + 1]->HasOneAddress(
-                    "192.168.0.3", 80));
+        "192.168.0.3", 80));
     EXPECT_EQ(OK, requests_[maximum_dns_failures() + 2]->WaitForResult());
     EXPECT_TRUE(requests_[maximum_dns_failures() + 2]->HasOneAddress(
-                    "192.168.0.4", 80));
+        "192.168.0.4", 80));
     requests_.clear();
   }
 }
 
 // Tests a call to SetDnsClient while there are active DnsTasks.
 TEST_F(HostResolverImplDnsTest, ManuallyDisableDnsClientWithPendingRequests) {
   // At most 3 jobs active at once.  This number is important, since we want to
   // make sure that aborting the first HostResolverImpl::Job does not trigger
   // another DnsTransaction on the second Job when it releases its second
   // prioritized dispatcher slot.
@@ skipping 27 matching lines @@
 
   EXPECT_EQ(OK, requests_[0]->WaitForResult());
   EXPECT_TRUE(requests_[0]->HasOneAddress("192.168.0.1", 80));
   EXPECT_EQ(OK, requests_[1]->WaitForResult());
   EXPECT_TRUE(requests_[1]->HasOneAddress("192.168.0.2", 80));
   EXPECT_EQ(OK, requests_[2]->WaitForResult());
   EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.0.3", 80));
 }
 
 }  // namespace net