HostResolver supports optional CNAME lookups.

chrome/browser/net/view_net_internals_job_factory.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 "chrome/browser/net/view_net_internals_job_factory.h"
 
 #include <sstream>
 
 #include "base/format_macros.h"
 #include "base/stl_util-inl.h"
@@ skipping 331 matching lines @@
         host_cache->size(),
         host_cache->max_entries(),
         host_cache->success_entry_ttl().InMilliseconds(),
         host_cache->failure_entry_ttl().InMilliseconds());
 
     out->append("<table border=1>"
                 "<tr>"
                 "<th>Host</th>"
                 "<th>Address family</th>"
                 "<th>Address list</th>"
+                "<th>Canonical name</th>"
                 "<th>Time to live (ms)</th>"
                 "</tr>");
 
     for (net::HostCache::EntryMap::const_iterator it =
              host_cache->entries().begin();
          it != host_cache->entries().end();
          ++it) {
       const net::HostCache::Key& key = it->first;
       const net::HostCache::Entry* entry = it->second.get();
 
       std::string address_family_str =
           AddressFamilyToString(key.address_family);
 
       // Note that ttl_ms may be negative, for the cases where entries have
       // expired but not been garbage collected yet.
       int ttl_ms = static_cast<int>(
           (entry->expiration - base::TimeTicks::Now()).InMilliseconds());
 
       // Color expired entries blue.
       if (ttl_ms > 0) {
         out->append("<tr>");
       } else {
         out->append("<tr style='color:blue'>");
       }
 
       // Stringify all of the addresses in the address list, separated
       // by newlines (br).
       std::string address_list_html;
+      std::string canonical_name_html;
 
       if (entry->error != net::OK) {
         address_list_html = "<span style='font-weight: bold; color:red'>" +
                             EscapeForHTML(net::ErrorToString(entry->error)) +
                             "</span>";
       } else {
         const struct addrinfo* current_address = entry->addrlist.head();
         while (current_address) {
           if (!address_list_html.empty())
             address_list_html += "<br>";
           address_list_html += EscapeForHTML(
               net::NetAddressToString(current_address));
           current_address = current_address->ai_next;
         }
+        std::string canonical_name;
+        if (entry->addrlist.GetCanonicalName(&canonical_name))
+          canonical_name_html = EscapeForHTML(canonical_name);
       }
 
       StringAppendF(out,
                     "<td>%s</td><td>%s</td><td>%s</td>"
-                    "<td>%d</td></tr>",
+                    "<td>%s</td><td>%d</td></tr>",
                     EscapeForHTML(key.hostname).c_str(),
                     EscapeForHTML(address_family_str).c_str(),
                     address_list_html.c_str(),
+                    canonical_name_html.c_str(),
                     ttl_ms);
     }
 
     out->append("</table>");
   }
 
   static std::string AddressFamilyToString(net::AddressFamily address_family) {
     switch (address_family) {
       case net::ADDRESS_FAMILY_IPV4:
         return "IPV4";
@@ skipping 422 matching lines @@
   return StartsWithASCII(url.spec(),
                          chrome::kNetworkViewInternalsURL,
                          true /*case_sensitive*/);
 }
 
 // static
 URLRequestJob* ViewNetInternalsJobFactory::CreateJobForRequest(
     URLRequest* request) {
   return new ViewNetInternalsJob(request);
 }