Treat IPv4-mapped IPv6 addresses as IPv4 addresses.

net/quic/quic_connection_logger.cc

 // Copyright (c) 2013 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/quic/quic_connection_logger.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 233 matching lines @@
 
 void UpdatePublicResetAddressMismatchHistogram(
     const IPEndPoint& server_hello_address,
     const IPEndPoint& public_reset_address) {
   int sample = GetAddressMismatch(server_hello_address, public_reset_address);
   // We are seemingly talking to an older server that does not support the
   // feature, so we can't report the results in the histogram.
   if (sample < 0) {
     return;
   }
-  UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.PublicResetAddressMismatch",
+  UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.PublicResetAddressMismatch2",
                             sample, QUIC_ADDRESS_MISMATCH_MAX);
 }
 
 const char* GetConnectionDescriptionString() {
   NetworkChangeNotifier::ConnectionType type =
       NetworkChangeNotifier::GetConnectionType();
   const char* description = NetworkChangeNotifier::ConnectionTypeToString(type);
   // Most platforms don't distingish Wifi vs Etherenet, and call everything
   // CONNECTION_UNKNOWN :-(.  We'll tease out some details when we are on WiFi,
   // and hopefully leave only ethernet (with no WiFi available) in the
@@ skipping 28 matching lines @@
         description = "CONNECTION_WIFI_802.11n";
         break;
       case WIFI_PHY_LAYER_PROTOCOL_UNKNOWN:
         // Unclassified mode or failure to identify.
         break;
     }
   }
   return description;
 }
 
+// If |address| is an IPv4-mapped IPv6 address, returns ADDRESS_FAMILY_IPV4
+// instead of ADDRESS_FAMILY_IPV6. Othewise, behaves like GetAddressFamily().
+AddressFamily GetRealAddressFamily(const IPAddressNumber& address) {
+  return IsIPv4Mapped(address) ? ADDRESS_FAMILY_IPV4 :
+      GetAddressFamily(address);
+}
 
 }  // namespace
 
 QuicConnectionLogger::QuicConnectionLogger(const BoundNetLog& net_log)
     : net_log_(net_log),
       last_received_packet_sequence_number_(0),
       last_received_packet_size_(0),
       largest_received_packet_sequence_number_(0),
       largest_received_missing_packet_sequence_number_(0),
       num_out_of_order_received_packets_(0),
@@ skipping 110 matching lines @@
       NetLog::TYPE_QUIC_SESSION_PACKET_RETRANSMITTED,
       base::Bind(&NetLogQuicPacketRetransmittedCallback,
                  old_sequence_number, new_sequence_number));
 }
 
 void QuicConnectionLogger::OnPacketReceived(const IPEndPoint& self_address,
                                             const IPEndPoint& peer_address,
                                             const QuicEncryptedPacket& packet) {
   if (local_address_from_self_.GetFamily() == ADDRESS_FAMILY_UNSPECIFIED) {
     local_address_from_self_ = self_address;
     UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.ConnectionTypeFromSelf",

[wtc, 2014/05/19 23:24:12]

Ryan: on your suggestion, I didn't rename your two
Net.QuicSession.ConnectionTypeFrom* histograms.

-                              self_address.GetFamily(),
+                              GetRealAddressFamily(self_address.address()),

[Ryan Hamilton, 2014/05/20 00:26:35]

I believe we don't need to do the canonicalizing here, but I'm happy to leave it
in, just to be safe.

                               ADDRESS_FAMILY_LAST);
   }
 
   last_received_packet_size_ = packet.length();
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_PACKET_RECEIVED,
       base::Bind(&NetLogQuicPacketCallback, &self_address, &peer_address,
                  packet.length()));
 }
 
@@ skipping 142 matching lines @@
       NetLog::TYPE_QUIC_SESSION_CRYPTO_HANDSHAKE_MESSAGE_RECEIVED,
       base::Bind(&NetLogQuicCryptoHandshakeMessageCallback, &message));
 
   if (message.tag() == kSHLO) {
     StringPiece address;
     QuicSocketAddressCoder decoder;
     if (message.GetStringPiece(kCADR, &address) &&
         decoder.Decode(address.data(), address.size())) {
       local_address_from_shlo_ = IPEndPoint(decoder.ip(), decoder.port());
       UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.ConnectionTypeFromPeer",
-                                local_address_from_shlo_.GetFamily(),
+                                GetRealAddressFamily(
+                                    local_address_from_shlo_.address()),
                                 ADDRESS_FAMILY_LAST);
     }
   }
 }
 
 void QuicConnectionLogger::OnCryptoHandshakeMessageSent(
     const CryptoHandshakeMessage& message) {
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_CRYPTO_HANDSHAKE_MESSAGE_SENT,
       base::Bind(&NetLogQuicCryptoHandshakeMessageCallback, &message));
@@ skipping 175 matching lines @@
       continue;
     }
     // Record some overlapping patterns, to get a better picture, since this is
     // not very expensive.
     if (i % 3 == 0)
       six_packet_histogram->Add(recent_6_mask);
   }
 }
 
 }  // namespace net