Revert "Reland "Remove GICE (gone forever!) and PORTALLOCATOR_ENABLE_SHARED_UFRAG (enabled forever)…

webrtc/p2p/base/transport.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 123 matching lines @@
                            const std::string& old_pwd,
                            const std::string& new_ufrag,
                            const std::string& new_pwd);
 
 class Transport : public rtc::MessageHandler,
                   public sigslot::has_slots<> {
  public:
   Transport(rtc::Thread* signaling_thread,
             rtc::Thread* worker_thread,
             const std::string& content_name,
+            const std::string& type,
             PortAllocator* allocator);
   virtual ~Transport();
 
   // Returns the signaling thread. The app talks to Transport on this thread.
   rtc::Thread* signaling_thread() { return signaling_thread_; }
   // Returns the worker thread. The actual networking is done on this thread.
   rtc::Thread* worker_thread() { return worker_thread_; }
 
   // Returns the content_name of this transport.
   const std::string& content_name() const { return content_name_; }
+  // Returns the type of this transport.
+  const std::string& type() const { return type_; }
 
   // Returns the port allocator object for this transport.
   PortAllocator* port_allocator() { return allocator_; }
 
   // Returns the readable and states of this manager.  These bits are the ORs
   // of the corresponding bits on the managed channels.  Each time one of these
   // states changes, a signal is raised.
   // TODO: Replace uses of readable() and writable() with
   // any_channels_readable() and any_channels_writable().
   bool readable() const { return any_channels_readable(); }
@@ skipping 37 matching lines @@
 
   // Must be called before applying local session description.
   void SetIdentity(rtc::SSLIdentity* identity);
 
   // Get a copy of the local identity provided by SetIdentity.
   bool GetIdentity(rtc::SSLIdentity** identity);
 
   // Get a copy of the remote certificate in use by the specified channel.
   bool GetRemoteCertificate(rtc::SSLCertificate** cert);
 
+  TransportProtocol protocol() const { return protocol_; }
+
   // Create, destroy, and lookup the channels of this type by their components.
   TransportChannelImpl* CreateChannel(int component);
   // Note: GetChannel may lead to race conditions, since the mutex is not held
   // after the pointer is returned.
   TransportChannelImpl* GetChannel(int component);
   // Note: HasChannel does not lead to race conditions, unlike GetChannel.
   bool HasChannel(int component) {
     return (NULL != GetChannel(component));
   }
   bool HasChannels();
@@ skipping 89 matching lines @@
   // Derived classes can override, but must call the base as well.
   virtual bool ApplyLocalTransportDescription_w(TransportChannelImpl* channel,
                                                 std::string* error_desc);
 
   // Pushes down remote ice credentials from the remote description to the
   // transport channel.
   virtual bool ApplyRemoteTransportDescription_w(TransportChannelImpl* ch,
                                                  std::string* error_desc);
 
   // Negotiates the transport parameters based on the current local and remote
-  // transport description, such as the ICE role to use, and whether DTLS
+  // transport description, such at the version of ICE to use, and whether DTLS
   // should be activated.
   // Derived classes can negotiate their specific parameters here, but must call
   // the base as well.
   virtual bool NegotiateTransportDescription_w(ContentAction local_role,
                                                std::string* error_desc);
 
   // Pushes down the transport parameters obtained via negotiation.
   // Derived classes can set their specific parameters here, but must call the
   // base as well.
   virtual bool ApplyNegotiatedTransportDescription_w(
@@ skipping 105 matching lines @@
   bool GetRemoteCertificate_w(rtc::SSLCertificate** cert);
 
   void SetChannelReceivingTimeout_w(int timeout_ms);
 
   // Sends SignalCompleted if we are now in that state.
   void MaybeCompleted_w();
 
   rtc::Thread* const signaling_thread_;
   rtc::Thread* const worker_thread_;
   const std::string content_name_;
+  const std::string type_;
   PortAllocator* const allocator_;
   bool destroyed_;
   TransportState readable_;
   TransportState writable_;
   TransportState receiving_;
   bool was_writable_;
   bool connect_requested_;
   IceRole ice_role_;
   uint64 tiebreaker_;
+  TransportProtocol protocol_;
   IceMode remote_ice_mode_;
   int channel_receiving_timeout_;
   rtc::scoped_ptr<TransportDescription> local_description_;
   rtc::scoped_ptr<TransportDescription> remote_description_;
 
   // TODO(tommi): Make sure we only use this on the worker thread.
   ChannelMap channels_;
   // Buffers the ready_candidates so that SignalCanidatesReady can
   // provide them in multiples.
   std::vector<Candidate> ready_candidates_;
   // Protects changes to channels and messages
   rtc::CriticalSection crit_;
 
   DISALLOW_COPY_AND_ASSIGN(Transport);
 };
 
+// Extract a TransportProtocol from a TransportDescription.
+TransportProtocol TransportProtocolFromDescription(
+    const TransportDescription* desc);
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_TRANSPORT_H_