Revert change which removes GICE

webrtc/p2p/base/fakesession.h

 /*
  *  Copyright 2009 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 35 matching lines @@
                                 const std::string& content_name,
                                 int component)
       : TransportChannelImpl(content_name, component),
         transport_(transport),
         dest_(nullptr),
         state_(STATE_INIT),
         async_(false),
         do_dtls_(false),
         role_(ICEROLE_UNKNOWN),
         tiebreaker_(0),
+        ice_proto_(ICEPROTO_HYBRID),
         remote_ice_mode_(ICEMODE_FULL),
         dtls_fingerprint_("", nullptr, 0),
         ssl_role_(rtc::SSL_CLIENT),
         connection_count_(0) {
   }
   ~FakeTransportChannel() {
     Reset();
   }
 
   uint64 IceTiebreaker() const { return tiebreaker_; }
+  TransportProtocol protocol() const { return ice_proto_; }
   IceMode remote_ice_mode() const { return remote_ice_mode_; }
   const std::string& ice_ufrag() const { return ice_ufrag_; }
   const std::string& ice_pwd() const { return ice_pwd_; }
   const std::string& remote_ice_ufrag() const { return remote_ice_ufrag_; }
   const std::string& remote_ice_pwd() const { return remote_ice_pwd_; }
   const rtc::SSLFingerprint& dtls_fingerprint() const {
     return dtls_fingerprint_;
   }
 
   void SetAsync(bool async) {
@@ skipping 19 matching lines @@
   void SetIceRole(IceRole role) override { role_ = role; }
   IceRole GetIceRole() const override { return role_; }
   void SetIceTiebreaker(uint64 tiebreaker) override {
     tiebreaker_ = tiebreaker;
   }
   void SetIceCredentials(const std::string& ice_ufrag,
                          const std::string& ice_pwd) override {
     ice_ufrag_ = ice_ufrag;
     ice_pwd_ = ice_pwd;
   }
+  bool GetIceProtocolType(IceProtocolType* type) const override {
+    *type = ice_proto_;
+    return true;
+  }
+  void SetIceProtocolType(IceProtocolType type) override { ice_proto_ = type; }
   void SetRemoteIceCredentials(const std::string& ice_ufrag,
                                const std::string& ice_pwd) override {
     remote_ice_ufrag_ = ice_ufrag;
     remote_ice_pwd_ = ice_pwd;
   }
 
   void SetRemoteIceMode(IceMode mode) override { remote_ice_mode_ = mode; }
   bool SetRemoteFingerprint(const std::string& alg, const uint8* digest,
                             size_t digest_len) override {
     dtls_fingerprint_ = rtc::SSLFingerprint(alg, digest, digest_len);
@@ skipping 190 matching lines @@
   FakeTransportChannel* dest_;
   State state_;
   bool async_;
   rtc::scoped_refptr<rtc::RTCCertificate> certificate_;
   rtc::FakeSSLCertificate* remote_cert_;
   bool do_dtls_;
   std::vector<std::string> srtp_ciphers_;
   std::string chosen_srtp_cipher_;
   IceRole role_;
   uint64 tiebreaker_;
+  IceProtocolType ice_proto_;
   std::string ice_ufrag_;
   std::string ice_pwd_;
   std::string remote_ice_ufrag_;
   std::string remote_ice_pwd_;
   IceMode remote_ice_mode_;
   rtc::SSLFingerprint dtls_fingerprint_;
   rtc::SSLRole ssl_role_;
   size_t connection_count_;
 };
 
 // Fake transport class, which can be passed to anything that needs a Transport.
 // Can be informed of another FakeTransport via SetDestination (low-tech way
 // of doing candidates)
 class FakeTransport : public Transport {
  public:
   typedef std::map<int, FakeTransportChannel*> ChannelMap;
   FakeTransport(rtc::Thread* signaling_thread,
                 rtc::Thread* worker_thread,
                 const std::string& content_name,
                 PortAllocator* alllocator = nullptr)
       : Transport(signaling_thread, worker_thread,
-                  content_name, nullptr),
+                  content_name, "test_type", nullptr),
         dest_(nullptr),
         async_(false) {
   }
   ~FakeTransport() {
     DestroyAllChannels();
   }
 
   const ChannelMap& channels() const { return channels_; }
 
   void SetAsync(bool async) { async_ = async; }
@@ skipping 150 matching lines @@
     }
   }
 
  private:
   bool fail_create_channel_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_FAKESESSION_H_