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

webrtc/p2p/base/p2ptransportchannel.h

Index: webrtc/p2p/base/p2ptransportchannel.h
diff --git a/webrtc/p2p/base/p2ptransportchannel.h b/webrtc/p2p/base/p2ptransportchannel.h
index 92c0534e7c4edba195586ecd412a49a7b2298850..6efd19b8bb5c780f27c2a02a121d151bda51b9e0 100644
--- a/webrtc/p2p/base/p2ptransportchannel.h
+++ b/webrtc/p2p/base/p2ptransportchannel.h
@@ -178,6 +178,11 @@ class P2PTransportChannel : public TransportChannelImpl,
     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(); }
@@ -247,6 +252,11 @@ class P2PTransportChannel : public TransportChannelImpl,
     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() {