Add two UMA counters for IPv4 and IPv6 local candidates gathered in WebRTC PeerConnection.

content/renderer/media/rtc_peer_connection_handler.cc

 // Copyright (c) 2012 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 "content/renderer/media/rtc_peer_connection_handler.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 372 matching lines @@
 
 }  // namespace
 
 RTCPeerConnectionHandler::RTCPeerConnectionHandler(
     blink::WebRTCPeerConnectionHandlerClient* client,
     PeerConnectionDependencyFactory* dependency_factory)
     : client_(client),
       dependency_factory_(dependency_factory),
       frame_(NULL),
       peer_connection_tracker_(NULL),
-      num_data_channels_created_(0) {
+      num_data_channels_created_(0),
+      num_local_candidates_ipv4_(0),
+      num_local_candidates_ipv6_(0) {
   g_peer_connection_handlers.Get().insert(this);
 }
 
 RTCPeerConnectionHandler::~RTCPeerConnectionHandler() {
   g_peer_connection_handlers.Get().erase(this);
   if (peer_connection_tracker_)
     peer_connection_tracker_->UnregisterPeerConnection(this);
   STLDeleteValues(&remote_streams_);
 
   UMA_HISTOGRAM_COUNTS_10000(
@@ skipping 483 matching lines @@
 }
 
 // Called any time the IceGatheringState changes
 void RTCPeerConnectionHandler::OnIceGatheringChange(
     webrtc::PeerConnectionInterface::IceGatheringState new_state) {
   if (new_state == webrtc::PeerConnectionInterface::kIceGatheringComplete) {
     // If ICE gathering is completed, generate a NULL ICE candidate,
     // to signal end of candidates.
     blink::WebRTCICECandidate null_candidate;
     client_->didGenerateICECandidate(null_candidate);
+
+    UMA_HISTOGRAM_COUNTS_100("WebRTC.PeerConnection.IPv4LocalCandidates",
+                             num_local_candidates_ipv4_);
+
+    UMA_HISTOGRAM_COUNTS_100("WebRTC.PeerConnection.IPv6LocalCandidates",
+                             num_local_candidates_ipv6_);
+  } else if (ice_gathering_current_state_ ==

[juberti2, 2014/09/26 01:45:37]

wouldn't it be simpler to do this if new_state == kIceGatheringStarted (or
whatever the name is?)

+                 webrtc::PeerConnectionInterface::kIceGatheringComplete &&
+             new_state != ice_gathering_current_state_) {
+    // ICE restarts will change gathering state back to "gathering",
+    // reset the counter.
+    num_local_candidates_ipv6_ = 0;
+    num_local_candidates_ipv4_ = 0;
   }
 
   blink::WebRTCPeerConnectionHandlerClient::ICEGatheringState state =
       GetWebKitIceGatheringState(new_state);
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackIceGatheringStateChange(this, state);
   client_->didChangeICEGatheringState(state);
+  ice_gathering_current_state_ = new_state;
 }
 
 void RTCPeerConnectionHandler::OnAddStream(
     webrtc::MediaStreamInterface* stream_interface) {
   DCHECK(stream_interface);
   DCHECK(remote_streams_.find(stream_interface) == remote_streams_.end());
 
   RemoteMediaStreamImpl* remote_stream =
       new RemoteMediaStreamImpl(stream_interface);
   remote_streams_.insert(
@@ skipping 47 matching lines @@
     return;
   }
   blink::WebRTCICECandidate web_candidate;
   web_candidate.initialize(base::UTF8ToUTF16(sdp),
                            base::UTF8ToUTF16(candidate->sdp_mid()),
                            candidate->sdp_mline_index());
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackAddIceCandidate(
         this, web_candidate, PeerConnectionTracker::SOURCE_LOCAL, true);
 
+  // Only the first m line's first component is tracked to avoid
+  // miscounting when doing BUNDLE or rtcp mux.
+  if (candidate->sdp_mline_index() == 0 &&
+      candidate->candidate().component() == 1) {
+    if (candidate->candidate().address().family() == AF_INET) {
+      num_local_candidates_ipv4_++;
+    } else if (candidate->candidate().address().family() == AF_INET6) {
+      num_local_candidates_ipv6_++;
+    } else {
+      NOTREACHED();
+    }
+  }
   client_->didGenerateICECandidate(web_candidate);
 }
 
 void RTCPeerConnectionHandler::OnDataChannel(
     webrtc::DataChannelInterface* data_channel) {
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackCreateDataChannel(
         this, data_channel, PeerConnectionTracker::SOURCE_REMOTE);
 
   DVLOG(1) << "RTCPeerConnectionHandler::OnDataChannel "
@@ skipping 20 matching lines @@
   webrtc::SessionDescriptionInterface* native_desc =
       dependency_factory_->CreateSessionDescription(type, sdp, error);
 
   LOG_IF(ERROR, !native_desc) << "Failed to create native session description."
                               << " Type: " << type << " SDP: " << sdp;
 
   return native_desc;
 }
 
 }  // namespace content