Merge 84251, 85083, 85188, 85375, 77501.

src/net/base/mock_host_resolver.cc

 // Copyright (c) 2010 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/mock_host_resolver.h"
 
+#include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/ref_counted.h"
 #include "base/threading/platform_thread.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/sys_addrinfo.h"
 
 namespace net {
 
 namespace {
 
 char* do_strdup(const char* src) {
 #if defined(OS_WIN)
   return _strdup(src);
 #else
   return strdup(src);
 #endif
 }
 
-// Fills |*addrlist| with a socket address for |host| which should be an
-// IPv4 or IPv6 literal without enclosing brackets. If |canonical_name| is
-// non-empty it is used as the DNS canonical name for the host. Returns OK on
-// success, ERR_UNEXPECTED otherwise.
-int CreateIPAddress(const std::string& host,
-                    const std::string& canonical_name,
-                    AddressList* addrlist) {
-  IPAddressNumber ip_number;
-  if (!ParseIPLiteralToNumber(host, &ip_number)) {
-    LOG(WARNING) << "Not a supported IP literal: " << host;
-    return ERR_UNEXPECTED;
+// Fills |*addrlist| with a socket address for |host_list| which should be a
+// comma-separated list of IPv4 or IPv6 literal(s) without enclosing brackets.
+// If |canonical_name| is non-empty it is used as the DNS canonical name for
+// the host. Returns OK on success, ERR_UNEXPECTED otherwise.
+int CreateIPAddressList(const std::string& host_list,
+                        const std::string& canonical_name,
+                        AddressList* addrlist) {
+  *addrlist = AddressList();
+  std::vector<std::string> addresses;
+  base::SplitString(host_list, ',', &addresses);
+  for (size_t index = 0; index < addresses.size(); ++index) {
+    IPAddressNumber ip_number;
+    if (!ParseIPLiteralToNumber(addresses[index], &ip_number)) {
+      LOG(WARNING) << "Not a supported IP literal: " << addresses[index];
+      return ERR_UNEXPECTED;
+    }
+
+    AddressList result(ip_number, -1, false);
+    struct addrinfo* ai = const_cast<struct addrinfo*>(result.head());
+    if (index == 0)
+      ai->ai_canonname = do_strdup(canonical_name.c_str());
+    if (!addrlist->head())
+      addrlist->Copy(result.head(), false);
+    else
+      addrlist->Append(result.head());
   }
-
-  AddressList result(ip_number, -1, false);
-  struct addrinfo* ai = const_cast<struct addrinfo*>(result.head());
-  ai->ai_canonname = do_strdup(canonical_name.c_str());
-  *addrlist = result;
   return OK;
 }
 
 }  // namespace
 
 MockHostResolverBase::~MockHostResolverBase() {}
 
 void MockHostResolverBase::Reset(HostResolverProc* interceptor) {
   synchronous_mode_ = false;
 
@@ skipping 115 matching lines @@
     const std::string& canonical_name) {
   // Literals are always resolved to themselves by HostResolverImpl,
   // consequently we do not support remapping them.
   IPAddressNumber ip_number;
   DCHECK(!ParseIPLiteralToNumber(host_pattern, &ip_number));
   HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY |
       HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
   if (!canonical_name.empty())
     flags |= HOST_RESOLVER_CANONNAME;
   Rule rule(Rule::kResolverTypeIPLiteral, host_pattern,
-            ADDRESS_FAMILY_UNSPECIFIED, flags, ip_literal, canonical_name, 0);
+            ADDRESS_FAMILY_UNSPECIFIED, flags, ip_literal, canonical_name,
+            0);
   rules_.push_back(rule);
 }
 
 void RuleBasedHostResolverProc::AddRuleWithLatency(
     const std::string& host_pattern,
     const std::string& replacement,
     int latency_ms) {
   DCHECK(!replacement.empty());
   HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY |
       HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
@@ skipping 48 matching lines @@
       // Apply the resolving function to the remapped hostname.
       switch (r->resolver_type) {
         case Rule::kResolverTypeFail:
           return ERR_NAME_NOT_RESOLVED;
         case Rule::kResolverTypeSystem:
           return SystemHostResolverProc(effective_host,
                                         address_family,
                                         host_resolver_flags,
                                         addrlist, os_error);
         case Rule::kResolverTypeIPLiteral:
-          return CreateIPAddress(effective_host, r->canonical_name, addrlist);
+          return CreateIPAddressList(effective_host,
+                                     r->canonical_name,
+                                     addrlist);
         default:
           NOTREACHED();
           return ERR_UNEXPECTED;
       }
     }
   }
   return ResolveUsingPrevious(host, address_family,
                               host_resolver_flags, addrlist, os_error);
 }
 
@@ skipping 36 matching lines @@
   CHECK_EQ(old_proc, current_proc_);
 }
 
 void ScopedDefaultHostResolverProc::Init(HostResolverProc* proc) {
   current_proc_ = proc;
   previous_proc_ = HostResolverProc::SetDefault(current_proc_);
   current_proc_->SetLastProc(previous_proc_);
 }
 
 }  // namespace net