Add ufrag to the ICE candidate signaling.

webrtc/p2p/base/p2ptransportchannel.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 18 matching lines @@
 #include "webrtc/p2p/base/portinterface.h"
 #include "webrtc/p2p/base/transport.h"
 #include "webrtc/p2p/base/transportchannelimpl.h"
 #include "webrtc/base/asyncpacketsocket.h"
 #include "webrtc/base/sigslot.h"
 
 namespace cricket {
 
 extern const uint32_t WEAK_PING_DELAY;
 
+struct IceGeneration {

[pthatcher1, 2015/12/10 22:08:06]

Now that I see the code, I see that it gets confusing that "generation"
sometimes means "generation index" and other times means "generation
credentials".  So perhaps we should just keep generation as "index" and instead
call this "IceParameters"

[honghaiz3, 2015/12/11 04:47:29]

Done.

+  std::string ufrag;
+  std::string pwd;
+  IceGeneration(const std::string& ice_ufrag, const std::string& ice_pwd) {

[pthatcher1, 2015/12/10 22:08:06]

Could be:

IceGenration(const std::string& ufrag, const std::string& pwd) : ufrag(ufrag),
pwd(pwd) {}

[honghaiz3, 2015/12/11 04:47:29]

Done.

+    ufrag = ice_ufrag;
+    pwd = ice_pwd;
+  }
+};
+
 // Adds the port on which the candidate originated.
 class RemoteCandidate : public Candidate {
  public:
   RemoteCandidate(const Candidate& c, PortInterface* origin_port)
       : Candidate(c), origin_port_(origin_port) {}
 
   PortInterface* origin_port() { return origin_port_; }
 
  private:
   PortInterface* origin_port_;
@@ skipping 173 matching lines @@
   void OnNominated(Connection* conn);
 
   void OnMessage(rtc::Message* pmsg) override;
   void OnSort();
   void OnCheckAndPing();
 
   void PruneConnections();
   Connection* best_nominated_connection() const;
   bool IsBackupConnection(Connection* conn) const;
 
+  // Makes sure |remote_ice_generations_| is not empty before calling this.
+  std::string& remote_ice_ufrag() {
+    ASSERT(!remote_ice_generations_.empty());
+    return remote_ice_generations_.back().ufrag;
+  }
+  // Makes sure |remote_ice_generations_| is not empty before calling this.
+  std::string& remote_ice_pwd() {
+    ASSERT(!remote_ice_generations_.empty());
+    return remote_ice_generations_.back().pwd;
+  }

[pthatcher1, 2015/12/10 22:08:06]

I think it would be better to have a remote_ice() getter that returns an
Optional<IceParameters>.  See how it could be used in the next file.

[honghaiz3, 2015/12/11 04:47:29]

Done.

+  int remote_ice_generation() {
+    // When |remote_ice_generations_| has one element, it is generation 0.
+    return remote_ice_generations_.size() - 1;
+  }
+
   P2PTransport* transport_;
   PortAllocator* allocator_;
   rtc::Thread* worker_thread_;
   bool incoming_only_;
   int error_;
   std::vector<PortAllocatorSession*> allocator_sessions_;
   std::vector<PortInterface *> ports_;
   std::vector<Connection *> connections_;
   Connection* best_connection_;
   // Connection selected by the controlling agent. This should be used only
   // at controlled side when protocol type is RFC5245.
   Connection* pending_best_connection_;
   std::vector<RemoteCandidate> remote_candidates_;
   bool sort_dirty_;  // indicates whether another sort is needed right now
   bool had_connection_ = false;  // if connections_ has ever been nonempty
   typedef std::map<rtc::Socket::Option, int> OptionMap;
   OptionMap options_;
   std::string ice_ufrag_;
   std::string ice_pwd_;
-  std::string remote_ice_ufrag_;
-  std::string remote_ice_pwd_;
+  std::vector<IceGeneration> remote_ice_generations_;

[pthatcher1, 2015/12/10 22:08:06]

And remote_ice_parameters_ might make sense here.

[honghaiz3, 2015/12/11 04:47:29]

Done.

   IceMode remote_ice_mode_;
   IceRole ice_role_;
   uint64_t tiebreaker_;
-  uint32_t remote_candidate_generation_;
   IceGatheringState gathering_state_;
 
   int check_receiving_delay_;
   int receiving_timeout_;
   int backup_connection_ping_interval_;
   uint32_t last_ping_sent_ms_ = 0;
   bool gather_continually_ = false;
   int weak_ping_delay_ = WEAK_PING_DELAY;
   TransportChannelState state_ = TransportChannelState::STATE_INIT;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(P2PTransportChannel);
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_P2PTRANSPORTCHANNEL_H_