Add instrumentation to track the IceEndpointType.

webrtc/p2p/base/candidate.h

 /*
  *  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 52 matching lines @@
 
   const std::string & id() const { return id_; }
   void set_id(const std::string & id) { id_ = id; }
 
   int component() const { return component_; }
   void set_component(int component) { component_ = component; }
 
   const std::string & protocol() const { return protocol_; }
   void set_protocol(const std::string & protocol) { protocol_ = protocol; }
 
+  // The protocol used by the first hop. Mainly interesting for TURN/TCP
+  // candidate as it's actually TCP although the candidate is udp itself.
+  const std::string& first_hop_protocol() const {

[juberti1, 2015/08/14 21:04:59]

Rather than duplicating the protocol value in cases where there is only one hop
(e.g. host, srflx), I suggest making this relay_protocol(), and leaving it empty
for non-relay candidates. (Similar to how tcptype is left empty for non-tcp
candidates.)

+    if (first_hop_protocol_.empty()) {
+      return protocol_;
+    }
+    return first_hop_protocol_;
+  }
+  void set_first_hop_protocol(const std::string& protocol) {
+    first_hop_protocol_ = protocol;
+  }
+
   const rtc::SocketAddress & address() const { return address_; }
   void set_address(const rtc::SocketAddress & address) {
     address_ = address;
   }
 
   uint32 priority() const { return priority_; }
   void set_priority(const uint32 priority) { priority_ = priority; }
 
 //  void set_type_preference(uint32 type_preference) {
 //    priority_ = GetPriority(type_preference);
@@ skipping 124 matching lines @@
     ost << "Cand[" << foundation_ << ":" << component_ << ":"
         << protocol_ << ":" << priority_ << ":"
         << address << ":" << type_ << ":" << related_address_ << ":"
         << username_ << ":" << password_ << "]";
     return ost.str();
   }
 
   std::string id_;
   int component_;
   std::string protocol_;
+  std::string first_hop_protocol_;
   rtc::SocketAddress address_;
   uint32 priority_;
   std::string username_;
   std::string password_;
   std::string type_;
   std::string network_name_;
   rtc::AdapterType network_type_;
   uint32 generation_;
   std::string foundation_;
   rtc::SocketAddress related_address_;
   std::string tcptype_;
 };
 
 // Used during parsing and writing to map component to channel name
 // and back.  This is primarily for converting old G-ICE candidate
 // signalling to new ICE candidate classes.
 class CandidateTranslator {
  public:
   virtual ~CandidateTranslator() {}
   virtual bool GetChannelNameFromComponent(
       int component, std::string* channel_name) const = 0;
   virtual bool GetComponentFromChannelName(
       const std::string& channel_name, int* component) const = 0;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_CANDIDATE_H_