Strip IP addresses in NDEBUG (release) builds.

webrtc/base/ipaddress.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 23 matching lines @@
 namespace rtc {
 
 // Prefixes used for categorizing IPv6 addresses.
 static const in6_addr kV4MappedPrefix = {{{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                            0xFF, 0xFF, 0}}};
 static const in6_addr k6To4Prefix = {{{0x20, 0x02, 0}}};
 static const in6_addr kTeredoPrefix = {{{0x20, 0x01, 0x00, 0x00}}};
 static const in6_addr kV4CompatibilityPrefix = {{{0}}};
 static const in6_addr k6BonePrefix = {{{0x3f, 0xfe, 0}}};
 
-bool IPAddress::strip_sensitive_ = false;
-
 static bool IsPrivateV4(uint32_t ip);
 static in_addr ExtractMappedAddress(const in6_addr& addr);
 
 uint32_t IPAddress::v4AddressAsHostOrderInteger() const {
   if (family_ == AF_INET) {
     return NetworkToHost32(u_.ip4.s_addr);
   } else {
     return 0;
   }
 }
@@ skipping 81 matching lines @@
   if (family_ == AF_INET6) {
     src = &u_.ip6;
   }
   if (!rtc::inet_ntop(family_, src, buf, sizeof(buf))) {
     return std::string();
   }
   return std::string(buf);
 }
 
 std::string IPAddress::ToSensitiveString() const {
-  if (!strip_sensitive_)
-    return ToString();
-
+#if !defined(NDEBUG)
+  // Return non-stripped in debug.
+  return ToString();
+#else
   switch (family_) {
     case AF_INET: {
       std::string address = ToString();
       size_t find_pos = address.rfind('.');
       if (find_pos == std::string::npos)
         return std::string();
       address.resize(find_pos);
       address += ".x";
       return address;
     }
     case AF_INET6: {
       // TODO(grunell): Return a string of format 1:2:3:x:x:x:x:x or such
       // instead of zeroing out.
       return TruncateIP(*this, 128 - 80).ToString();
     }
   }
   return std::string();
+#endif
 }
 
 IPAddress IPAddress::Normalized() const {
   if (family_ != AF_INET6) {
     return *this;
   }
   if (!IPIsV4Mapped(*this)) {
     return *this;
   }
   in_addr addr = ExtractMappedAddress(u_.ip6);
   return IPAddress(addr);
 }
 
 IPAddress IPAddress::AsIPv6Address() const {
   if (family_ != AF_INET) {
     return *this;
   }
   in6_addr v6addr = kV4MappedPrefix;
   ::memcpy(&v6addr.s6_addr[12], &u_.ip4.s_addr, sizeof(u_.ip4.s_addr));
   return IPAddress(v6addr);
 }
 
-void IPAddress::set_strip_sensitive(bool enable) {
-  strip_sensitive_ = enable;
-}
-
 bool InterfaceAddress::operator==(const InterfaceAddress &other) const {
   return ipv6_flags_ == other.ipv6_flags() &&
     static_cast<const IPAddress&>(*this) == other;
 }
 
 bool InterfaceAddress::operator!=(const InterfaceAddress &other) const {
   return !((*this) == other);
 }
 
 const InterfaceAddress& InterfaceAddress::operator=(
@@ skipping 308 matching lines @@
   if (family == AF_INET) {
     return rtc::IPAddress(INADDR_ANY);
   }
   if (family == AF_INET6) {
     return rtc::IPAddress(in6addr_any);
   }
   return rtc::IPAddress();
 }
 
 }  // Namespace rtc