Reland of Adding PeerConnectionInterface::SetConfiguration method.

talk/app/webrtc/peerconnection.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 662 matching lines @@
 }
 
 void PeerConnection::PostSetSessionDescriptionFailure(
     SetSessionDescriptionObserver* observer,
     const std::string& error) {
   SetSessionDescriptionMsg* msg  = new SetSessionDescriptionMsg(observer);
   msg->error = error;
   signaling_thread()->Post(this, MSG_SET_SESSIONDESCRIPTION_FAILED, msg);
 }
 
-bool PeerConnection::UpdateIce(const IceServers& configuration,
-                               const MediaConstraintsInterface* constraints) {
-  return false;
-}
-
-bool PeerConnection::UpdateIce(const RTCConfiguration& config) {
+bool PeerConnection::SetConfiguration(const RTCConfiguration& config) {
   if (port_allocator_) {
     std::vector<PortAllocatorFactoryInterface::StunConfiguration> stuns;
     std::vector<PortAllocatorFactoryInterface::TurnConfiguration> turns;
     if (!ParseIceServers(config.servers, &stuns, &turns)) {
       return false;
     }
 
     std::vector<rtc::SocketAddress> stun_hosts;
     typedef std::vector<StunConfiguration>::const_iterator StunIt;
     for (StunIt stun_it = stuns.begin(); stun_it != stuns.end(); ++stun_it) {
       stun_hosts.push_back(stun_it->server);
     }
 
     rtc::SocketAddress stun_addr;
     if (!stun_hosts.empty()) {
       stun_addr = stun_hosts.front();
-      LOG(LS_INFO) << "UpdateIce: StunServer Address: " << stun_addr.ToString();
+      LOG(LS_INFO) << "SetConfiguration: StunServer Address: "
+                   << stun_addr.ToString();
     }
 
     for (size_t i = 0; i < turns.size(); ++i) {
       cricket::RelayCredentials credentials(turns[i].username,
                                             turns[i].password);
       cricket::RelayServerConfig relay_server(cricket::RELAY_TURN);
       cricket::ProtocolType protocol;
       if (cricket::StringToProto(turns[i].transport_type.c_str(), &protocol)) {
         relay_server.ports.push_back(cricket::ProtocolAddress(
             turns[i].server, protocol, turns[i].secure));
         relay_server.credentials = credentials;
-        LOG(LS_INFO) << "UpdateIce: TurnServer Address: "
+        LOG(LS_INFO) << "SetConfiguration: TurnServer Address: "
                      << turns[i].server.ToString();
       } else {
         LOG(LS_WARNING) << "Ignoring TURN server " << turns[i].server << ". "
                         << "Reason= Incorrect " << turns[i].transport_type
                         << " transport parameter.";
       }
     }
   }
   session_->SetIceConfig(session_->ParseIceConfig(config));
   return session_->SetIceTransports(config.type);
@@ skipping 265 matching lines @@
 std::vector<rtc::scoped_refptr<RtpReceiverInterface>>::iterator
 PeerConnection::FindReceiverForTrack(MediaStreamTrackInterface* track) {
   return std::find_if(
       receivers_.begin(), receivers_.end(),
       [track](const rtc::scoped_refptr<RtpReceiverInterface>& receiver) {
         return receiver->track() == track;
       });
 }
 
 }  // namespace webrtc