HostResolver supports optional CNAME lookups.

net/base/address_list.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// 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/address_list.h"
 
 #include <stdlib.h>
 
 #include "base/logging.h"
 #include "net/base/sys_addrinfo.h"
 
@@ skipping 86 matching lines @@
 
 void AddressList::Adopt(struct addrinfo* head) {
   data_ = new Data(head, true /*is_system_created*/);
 }
 
 void AddressList::Copy(const struct addrinfo* head, bool recursive) {
   data_ = new Data(CreateCopyOfAddrinfo(head, recursive),
                    false /*is_system_created*/);
 }
 
 void AddressList::Append(const struct addrinfo* head) {

[wtc, 2010/04/08 15:09:40]

Since we assume ai_cannonname is in the first element
of the linked list, if the head of the current list
doesn't have ai_cannonname but the |head| argument does,
should we move its ai_cannonname to the head of the
current list?

Alternatively, we can consider modifying GetCanonicalName
to walk the linked list until it finds an element with
ai_cannonname.

[eroman, 2010/04/08 19:10:50]

Append() was only exposed for use by a unittest
(http://codereview.chromium.org/1593015) in constructing fake lists.

We could add DCHECKs for this situation since we don't expect it to happen.

Additionally we could make Append() private, and only exposed through #ifdef
UNITTESTS.

[wtc, 2010/04/08 20:11:12]

This sounds good.

   struct addrinfo* new_head;
   if (data_->is_system_created) {
     new_head = CreateCopyOfAddrinfo(data_->head, true);
     data_ = new Data(new_head, false /*is_system_created*/);
   } else {
     new_head = data_->head;
   }
 
   // Find the end of current linked list and append new data there.
   struct addrinfo* copy_ptr = new_head;
   while (copy_ptr->ai_next)
     copy_ptr = copy_ptr->ai_next;
   copy_ptr->ai_next = CreateCopyOfAddrinfo(head, true);
 }
 
 void AddressList::SetPort(int port) {
   SetPortRecursive(data_->head, port);
 }
 
 int AddressList::GetPort() const {
   uint16* port_field = GetPortField(data_->head);
   if (!port_field)
     return -1;
 
   return ntohs(*port_field);
 }
 
+bool AddressList::GetCanonicalName(std::string* canonical_name) const {
+  DCHECK(canonical_name);
+  if (!data_->head || !data_->head->ai_canonname)
+    return false;
+  canonical_name->assign(data_->head->ai_canonname);
+  return true;
+}
+
 void AddressList::SetFrom(const AddressList& src, int port) {
   if (src.GetPort() == port) {
     // We can reference the data from |src| directly.
     *this = src;
   } else {
     // Otherwise we need to make a copy in order to change the port number.
     Copy(src.head(), true);
     SetPort(port);
   }
 }
@@ skipping 25 matching lines @@
 AddressList::Data::~Data() {
   // Call either freeaddrinfo(head), or FreeMyAddrinfo(head), depending who
   // created the data.
   if (is_system_created)
     freeaddrinfo(head);
   else
     FreeMyAddrinfo(head);
 }
 
 }  // namespace net