Reimplements net::AddressList without struct addrinfo.

net/base/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/base/host_resolver_impl.h"
 
+#include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/test/test_timeouts.h"
 #include "base/time.h"
 #include "net/base/address_list.h"
 #include "net/base/host_cache.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/dns/dns_client.h"
 #include "net/dns/dns_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 const size_t kMaxJobs = 10u;
 const size_t kMaxRetryAttempts = 4u;
@@ skipping 198 matching lines @@
         result_(ERR_UNEXPECTED),
         handle_(NULL) {}
 
   int Resolve() {
     DCHECK(resolver_);
     DCHECK(!handle_);
     list_ = AddressList();
     result_ = resolver_->Resolve(
         info_, &list_, base::Bind(&Request::OnComplete, base::Unretained(this)),
         &handle_, BoundNetLog());
-    if (list_.head())
+    if (!list_.empty())
       EXPECT_EQ(OK, result_);
     return result_;
   }
 
   int ResolveFromCache() {
     DCHECK(resolver_);
     DCHECK(!handle_);
     return resolver_->ResolveFromCache(info_, &list_, BoundNetLog());
   }
 
   void Cancel() {
     DCHECK(resolver_);
     DCHECK(handle_);
     resolver_->CancelRequest(handle_);
     handle_ = NULL;
   }
 
   const HostResolver::RequestInfo& info() const { return info_; }
   size_t index() const { return index_; }
   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 {
     IPAddressNumber ip;
     bool rv = ParseIPLiteralToNumber(address, &ip);
     DCHECK(rv);
-    IPEndPoint target(ip, port);
-    for (const struct addrinfo* ai = list_.head();
-         ai != NULL;
-         ai = ai->ai_next) {
-      IPEndPoint ipe;
-      rv = ipe.FromSockAddr(ai->ai_addr, ai->ai_addrlen);
-      DCHECK(rv);
-      if (target == ipe)
-        return true;
-    }
-    return false;
+    return std::find(list_.begin(),
+                     list_.end(),
+                     IPEndPoint(ip, port)) != list_.end();
   }
 
   // Returns the number of addresses in |list_|.
   unsigned NumberOfAddresses() const {
-    unsigned count = 0;
-    for (const struct addrinfo* ai = list_.head();
-         ai != NULL;
-         ai = ai->ai_next) {
-      ++count;
-    }
-    return count;
+    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_;
@@ skipping 12 matching lines @@
       return ERR_UNEXPECTED;
   }
 
  private:
   void OnComplete(int rv) {
     EXPECT_TRUE(pending());
     EXPECT_EQ(ERR_IO_PENDING, result_);
     EXPECT_NE(ERR_IO_PENDING, rv);
     result_ = rv;
     handle_ = NULL;
-    if (list_.head())
+    if (!list_.empty()) {
       EXPECT_EQ(OK, result_);
-    if (OK == rv)
-      EXPECT_EQ(info_.port(), list_.GetPort());
+      EXPECT_EQ(info_.port(), list_.front().port());
+    }
     if (handler_)
       handler_->Handle(this);
     if (quit_on_complete_) {
       MessageLoop::current()->Quit();
       quit_on_complete_ = false;
     }
   }
 
   HostResolver::RequestInfo info_;
   size_t index_;
@@ skipping 1017 matching lines @@
   EXPECT_EQ(OK, req5->Resolve());
   EXPECT_TRUE(req5->HasOneAddress("::1", 80));
 
   // Request with upper case.
   Request* req6 = CreateRequest("er_IPV4", 80);
   EXPECT_EQ(OK, req6->Resolve());
   EXPECT_TRUE(req6->HasOneAddress("127.0.0.1", 80));
 }
 
 }  // namespace net