Fill the remote pwd in ice candidates when an ICE credential is received.

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 160 matching lines @@
   Connection* FindNextPingableConnection();
 
   // Public for unit tests.
   const std::vector<Connection*>& connections() const { return connections_; }
 
   // Public for unit tests.
   PortAllocatorSession* allocator_session() {
     return allocator_sessions_.back();
   }
 
+  // Public for unit tests.
+  const std::vector<RemoteCandidate>& remote_candidates() const {
+    return remote_candidates_;
+  }
+
  private:
   rtc::Thread* thread() { return worker_thread_; }
   bool IsGettingPorts() { return allocator_session()->IsGettingPorts(); }
 
   // A transport channel is weak if the current best connection is either
   // not receiving or not writable, or if there is no best connection at all.
   bool weak() const;
   void UpdateConnectionStates();
   void RequestSort();
   void SortConnections();
@@ skipping 49 matching lines @@
   void PruneConnections();
   Connection* best_nominated_connection() const;
   bool IsBackupConnection(Connection* conn) const;
 
   // Returns the latest remote ICE parameters or nullptr if there are no remote
   // ICE parameters yet.
   IceParameters* remote_ice() {
     return remote_ice_parameters_.empty() ? nullptr
                                           : &remote_ice_parameters_.back();
   }
+  // Returns the IceParameters that match the ufrag, also fill the generation

[pthatcher1, 2015/12/28 21:33:59]

Might read better as: "Returns the remote IceParameters and generation that
match |ufrag| if found, and returns nullptr if not found."

Actually, for consistency, can you make it have both return values be out
pointers, and have the return value be a bool?

bool FindRemoteIceParametersByUfrag(
  const std::string& ufrag,
  IceParameters* params,
  uint32_t* generation);
  

[honghaiz3, 2015/12/30 18:59:33]

If we use IceParameters* as the argument, we will have to copy IceParameters
unnecessarily. If we use IceParameters** as the argument, the double pointer
looks more confusing to me (although it is pretty subjective). It will be
something like this.
bool P2PTransportChannel::FindRemoteIce(
    const std::string& ufrag,
    IceParameters** ice_params,
    uint32_t* generation) {
  const auto& params = remote_ice_parameters_;
  auto it = std::find_if(
      params.rbegin(), params.rend(),
      [ufrag](const IceParameters& param) { return param.ufrag == ufrag; });
  if (it == params.rend()) {
    // Not found.
    return false;
  }
  *ice_params = &(*it);
  *generation = params.rend() - it - 1;
  return true;
}
Plus, it will more cumbersome to call this. You have to define two variables
before calling this. 
Let me know if you really want this. 

[pthatcher1, 2015/12/30 19:15:44]

Good point about the double pointer.  I don't think it's a big issue, though. 
We do similar things other places in the code base and it's fine.

I also don't think putting two variables on the stack is a big deal, especially
since we need one for the generation anyway.

So, I prefer what you have written there with the double pointer.  But I don't
feel that strongly about it.  I'll let you decide.

+  // based on the found index. If not found, return nullptr and assume the next
+  // (future) generation.
+  const IceParameters* FindRemoteIce(const std::string& ufrag,
+                                     uint32_t* generation);
   // Returns the index of the latest remote ICE parameters, or 0 if no remote
   // ICE parameters have been received.
   uint32_t remote_ice_generation() {
     return remote_ice_parameters_.empty()
                ? 0
                : static_cast<uint32_t>(remote_ice_parameters_.size() - 1);
   }
 
   P2PTransport* transport_;
   PortAllocator* allocator_;
@@ skipping 27 matching lines @@
   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_