Add instrumentation to track the IceEndpointType.

talk/app/webrtc/webrtcsession.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 39 matching lines @@
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/p2p/base/portallocator.h"
 
 using cricket::ContentInfo;
 using cricket::ContentInfos;
 using cricket::MediaContentDescription;
 using cricket::SessionDescription;
 using cricket::TransportInfo;
 
+using cricket::LOCAL_PORT_TYPE;
+using cricket::STUN_PORT_TYPE;
+using cricket::RELAY_PORT_TYPE;
+using cricket::PRFLX_PORT_TYPE;
+
 namespace webrtc {
 
 // Error messages
 const char kBundleWithoutRtcpMux[] = "RTCP-MUX must be enabled when BUNDLE "
                                      "is enabled.";
 const char kCreateChannelFailed[] = "Failed to create channels.";
 const char kInvalidCandidates[] = "Description contains invalid candidates.";
 const char kInvalidSdp[] = "Invalid session description.";
 const char kMlineMismatch[] =
     "Offer and answer descriptions m-lines are not matching. Rejecting answer.";
 const char kPushDownTDFailed[] =
     "Failed to push down transport description:";
 const char kSdpWithoutDtlsFingerprint[] =
     "Called with SDP without DTLS fingerprint.";
 const char kSdpWithoutSdesCrypto[] =
     "Called with SDP without SDES crypto.";
 const char kSdpWithoutIceUfragPwd[] =
     "Called with SDP without ice-ufrag and ice-pwd.";
 const char kSessionError[] = "Session error code: ";
 const char kSessionErrorDesc[] = "Session error description: ";
 const char kDtlsSetupFailureRtp[] =
     "Couldn't set up DTLS-SRTP on RTP channel.";
 const char kDtlsSetupFailureRtcp[] =
     "Couldn't set up DTLS-SRTP on RTCP channel.";
 const int kMaxUnsignalledRecvStreams = 20;
 
+#define CANDIDATE_PAIR_TYPE_ENTRY(local_type, remote_type, endpoint_type) \
+  if (local.type() == local_type##_PORT_TYPE &&                           \
+      remote.type() == remote_type##_PORT_TYPE) {                         \
+    return endpoint_type;                                                 \
+  }
+
+IceCandidatePairType GetIceCandidatePairCounter(
+    const cricket::Candidate& local,
+    const cricket::Candidate& remote) {
+  CANDIDATE_PAIR_TYPE_ENTRY(LOCAL, LOCAL, kIceCandidatePairHostHost);

[pthatcher1, 2015/08/19 02:47:53]

I still think this would be better than the macro:

const auto& l = local.type();
const auto& r = remote.type();
const auto& host = LOCAL_PORT_TYPE;
const auto& srflx = STUN_PORT_TYPE;
const auto& relay = RELAY_PORT_TYPE;
const auto& prflx = PRFLX_PORT_TYPE; 

if (l == host && r == host) return kIceCandidatePair_Host_Host;
if (l == host && r == relay) return kIceCandidatePair_Host_Relay;
...
return kIceCandidatePairMax;

[guoweis_webrtc, 2015/08/19 18:25:52]

Done.

+  CANDIDATE_PAIR_TYPE_ENTRY(LOCAL, STUN, kIceCandidatePairHostSrflx);
+  CANDIDATE_PAIR_TYPE_ENTRY(LOCAL, RELAY, kIceCandidatePairHostRelay);
+  CANDIDATE_PAIR_TYPE_ENTRY(LOCAL, PRFLX, kIceCandidatePairHostPrflx);
+  CANDIDATE_PAIR_TYPE_ENTRY(STUN, LOCAL, kIceCandidatePairSrflxHost);
+  CANDIDATE_PAIR_TYPE_ENTRY(STUN, STUN, kIceCandidatePairSrflxSrflx);
+  CANDIDATE_PAIR_TYPE_ENTRY(STUN, RELAY, kIceCandidatePairSrflxRelay);
+  CANDIDATE_PAIR_TYPE_ENTRY(STUN, PRFLX, kIceCandidatePairSrflxPrflx);
+  CANDIDATE_PAIR_TYPE_ENTRY(RELAY, LOCAL, kIceCandidatePairRelayHost);
+  CANDIDATE_PAIR_TYPE_ENTRY(RELAY, STUN, kIceCandidatePairRelaySrflx);
+  CANDIDATE_PAIR_TYPE_ENTRY(RELAY, RELAY, kIceCandidatePairRelayRelay);
+  CANDIDATE_PAIR_TYPE_ENTRY(RELAY, PRFLX, kIceCandidatePairRelayPrflx);
+  CANDIDATE_PAIR_TYPE_ENTRY(PRFLX, LOCAL, kIceCandidatePairPrflxHost);
+  CANDIDATE_PAIR_TYPE_ENTRY(PRFLX, STUN, kIceCandidatePairPrflxSrflx);
+  CANDIDATE_PAIR_TYPE_ENTRY(PRFLX, RELAY, kIceCandidatePairPrflxRelay);
+  return kIceCandidatePairMax;
+}
+
 // Compares |answer| against |offer|. Comparision is done
 // for number of m-lines in answer against offer. If matches true will be
 // returned otherwise false.
 static bool VerifyMediaDescriptions(
     const SessionDescription* answer, const SessionDescription* offer) {
   if (offer->contents().size() != answer->contents().size())
     return false;
 
   for (size_t i = 0; i < offer->contents().size(); ++i) {
     if ((offer->contents()[i].name) != answer->contents()[i].name) {
@@ skipping 1813 matching lines @@
   DCHECK(metrics_observer_ != NULL);
   for (cricket::TransportChannelStatsList::const_iterator it =
          stats.channel_stats.begin();
        it != stats.channel_stats.end(); ++it) {
     for (cricket::ConnectionInfos::const_iterator it_info =
            it->connection_infos.begin();
          it_info != it->connection_infos.end(); ++it_info) {
       if (!it_info->best_connection) {
         continue;
       }
-      if (it_info->local_candidate.address().family() == AF_INET) {
+
+      PeerConnectionEnumCounterType type = kPeerConnectionEnumCounter_Max;
+      const cricket::Candidate& local = it_info->local_candidate;
+      const cricket::Candidate& remote = it_info->remote_candidate;
+
+      // Increment the counter for IceCandidatePairType.
+      if (local.protocol() == cricket::TCP_PROTOCOL_NAME ||
+          (local.type() == RELAY_PORT_TYPE &&
+           local.relay_protocol() == cricket::TCP_PROTOCOL_NAME)) {
+        type = kEnumCounterIceCandidatePairTypeTcp;
+      } else if (local.protocol() == cricket::UDP_PROTOCOL_NAME) {
+        type = kEnumCounterIceCandidatePairTypeUdp;
+      } else {
+        DCHECK(0);
+      }
+      metrics_observer_->IncrementEnumCounter(
+          type, GetIceCandidatePairCounter(local, remote),
+          kIceCandidatePairMax);
+
+      // Increment the counter for IP type.
+      if (local.address().family() == AF_INET) {
+        // TODO(guoweis): Remove this next line once IncrementEnumCounter
+        // implemented for PeerConnectionMetrics.
         metrics_observer_->IncrementCounter(kBestConnections_IPv4);
-      } else if (it_info->local_candidate.address().family() ==
-                 AF_INET6) {
+
+        metrics_observer_->IncrementEnumCounter(
+            kEnumCounterAddressFamily, kBestConnections_IPv4,
+            kPeerConnectionAddressFamilyCounter_Max);
+
+      } else if (local.address().family() == AF_INET6) {
+        // TODO(guoweis): Remove this next line.
         metrics_observer_->IncrementCounter(kBestConnections_IPv6);
+
+        metrics_observer_->IncrementEnumCounter(
+            kEnumCounterAddressFamily, kBestConnections_IPv6,
+            kPeerConnectionAddressFamilyCounter_Max);
       } else {
         RTC_NOTREACHED();
       }
+
       return;
     }
   }
 }
 
 void WebRtcSession::ReportNegotiatedCiphers(
     const cricket::TransportStats& stats) {
   DCHECK(metrics_observer_ != NULL);
   if (!dtls_enabled_ || stats.channel_stats.empty()) {
     return;
@@ skipping 23 matching lines @@
 
   if (!srtp_cipher.empty()) {
     metrics_observer_->AddHistogramSample(srtp_name, srtp_cipher);
   }
   if (!ssl_cipher.empty()) {
     metrics_observer_->AddHistogramSample(ssl_name, ssl_cipher);
   }
 }
 
 }  // namespace webrtc