Track how often we successfully resolve non-'compliant' domain names.

net/dns/dns_util.cc

 // Copyright (c) 2011 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/dns_util.h"
 
 #include <errno.h>
 #include <limits.h>
 
 #include <cstring>
@@ skipping 27 matching lines @@
 #endif  // !defined(OS_NACL)
 #endif  // defined(OS_POSIX)
 
 #if defined(OS_ANDROID)
 #include "net/android/network_library.h"
 #endif
 
 namespace net {
 
 // Based on DJB's public domain code.
-bool DNSDomainFromDot(const base::StringPiece& dotted, std::string* out) {
+bool DNSDomainFromDotWithValidityCheck(const base::StringPiece& dotted,
+                                       std::string* out,
+                                       bool* valid_name) {
   const char* buf = dotted.data();
   size_t n = dotted.size();
   char label[kMaxLabelLength];
   size_t labellen = 0; /* <= sizeof label */
   char name[dns_protocol::kMaxNameLength];
   size_t namelen = 0; /* <= sizeof name */
   char ch;
-  bool valid_name = true;
+  *valid_name = true;
 
   for (;;) {
     if (!n)
       break;
     ch = *buf++;
     --n;
     if (ch == '.') {
       // Don't allow empty labels per http://crbug.com/456391.
       if (!labellen)
         return false;
       if (namelen + labellen + 1 > sizeof name)
         return false;
       name[namelen++] = static_cast<char>(labellen);
       memcpy(name + namelen, label, labellen);
       namelen += labellen;
       labellen = 0;
       continue;
     }
     if (labellen >= sizeof label)
       return false;
     if (!IsValidHostLabelCharacter(ch, labellen == 0)) {
-      // TODO(palmer): In the future, when we can remove support for invalid
-      // names, return false here instead (and remove the Net.Valid*DNSName UMA
-      // counters).
-      valid_name = false;
+      // TODO(crbug.com/695474): In the future, when we can remove support for
+      // invalid names, return false here instead (and remove the UMA counter).
+      // And remove the |valid_name| parameter, rename this function back to
+      // |DNSDomainFromDot|, and remove the helper function by that name
+      // (below).
+      *valid_name = false;
     }
     label[labellen++] = ch;
   }
 
-  UMA_HISTOGRAM_BOOLEAN("Net.ValidDNSName", valid_name);
-  if (valid_name) {
+  UMA_HISTOGRAM_BOOLEAN("Net.ValidDNSName", *valid_name);
+  if (*valid_name) {
     url::CanonHostInfo info;
     UMA_HISTOGRAM_BOOLEAN("Net.DNSNameCompliantIfValid",
                           net::IsCanonicalizedHostCompliant(
                               net::CanonicalizeHost(dotted, &info)));
   }
 
   // Allow empty label at end of name to disable suffix search.
   if (labellen) {
     if (namelen + labellen + 1 > sizeof name)
       return false;
     name[namelen++] = static_cast<char>(labellen);
     memcpy(name + namelen, label, labellen);
     namelen += labellen;
     labellen = 0;
   }
 
   if (namelen + 1 > sizeof name)
     return false;
   if (namelen == 0) // Empty names e.g. "", "." are not valid.
     return false;
   name[namelen++] = 0;  // This is the root label (of length 0).
 
   *out = std::string(name, namelen);
   return true;
 }
 
+bool DNSDomainFromDot(const base::StringPiece& dotted, std::string* out) {
+  bool ignored;
+  return DNSDomainFromDotWithValidityCheck(dotted, out, &ignored);
+}
+
 bool IsValidDNSDomain(const base::StringPiece& dotted) {
   std::string dns_formatted;
   return DNSDomainFromDot(dotted, &dns_formatted);
 }
 
 bool IsValidHostLabelCharacter(char c, bool is_first_char) {
   return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
          (c >= '0' && c <= '9') || (!is_first_char && c == '-') || c == '_';
 }
 
@@ skipping 81 matching lines @@
     return DELTA_IDENTICAL;
   else if (same_size && !any_missing)
     return DELTA_REORDERED;
   else if (any_match)
     return DELTA_OVERLAP;
   else
     return DELTA_DISJOINT;
 }
 
 }  // namespace net