Parse the connection data in SDP (c= line).

webrtc/pc/jsepsessiondescription.cc

 /*
  *  Copyright 2012 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 20 matching lines @@
   bool type_supported = false;
   for (size_t i = 0; i < arraysize(kSupportedTypes); ++i) {
     if (kSupportedTypes[i] == type) {
       type_supported = true;
       break;
     }
   }
   return type_supported;
 }
 
+// RFC 5245
+// It is RECOMMENDED that default candidates be chosen based on the
+// likelihood of those candidates to work with the peer that is being
+// contacted.  It is RECOMMENDED that relayed > reflexive > host.
+static const int kPreferenceUnknown = 0;
+static const int kPreferenceHost = 1;
+static const int kPreferenceReflexive = 2;
+static const int kPreferenceRelayed = 3;
+
+static const char kDummyAddress[] = "0.0.0.0";
+static const int kDummyPort = 9;
+
+static int GetCandidatePreferenceFromType(const std::string& type) {
+  int preference = kPreferenceUnknown;
+  if (type == cricket::LOCAL_PORT_TYPE) {
+    preference = kPreferenceHost;
+  } else if (type == cricket::STUN_PORT_TYPE) {
+    preference = kPreferenceReflexive;
+  } else if (type == cricket::RELAY_PORT_TYPE) {
+    preference = kPreferenceRelayed;
+  } else {
+    RTC_NOTREACHED();
+  }
+  return preference;
+}
+
+// Update the connection address for the MediaContentDescription based on the
+// candidates.
+static void UpdateConnectionAddress(
+    cricket::SessionDescription* description,
+    const std::vector<JsepCandidateCollection>& candidate_collections,

[Taylor Brandstetter, 2017/03/20 18:29:58]

nit: I believe this method could take a single JsepCandidateCollection and
MediaContentDescription.

[Zhi Huang, 2017/03/21 03:43:12]

I'll change it to take a single JsepCandidateCollection and a ContentDescription
so that we don't have to downcast it whenever the method is called.

+    size_t mediasection_index) {
+  int port = kDummyPort;
+  std::string ip = kDummyAddress;
+  int current_preference = kPreferenceUnknown;
+  int current_family = AF_UNSPEC;
+  for (size_t i = 0; i < candidate_collections[mediasection_index].count();
+       ++i) {
+    const IceCandidateInterface* jsep_candidate =
+        candidate_collections[mediasection_index].at(i);
+    if (jsep_candidate->candidate().component() !=
+        cricket::ICE_CANDIDATE_COMPONENT_RTP) {
+      continue;
+    }
+    // Default destination should be UDP only.
+    if (jsep_candidate->candidate().protocol() != cricket::UDP_PROTOCOL_NAME) {
+      continue;
+    }
+    const int preference =
+        GetCandidatePreferenceFromType(jsep_candidate->candidate().type());
+    const int family = jsep_candidate->candidate().address().ipaddr().family();
+    // See if this candidate is more preferable then the current one if it's the
+    // same family. Or if the current family is IPv4 already so we could safely
+    // ignore all IPv6 ones. WebRTC bug 4269.
+    // http://code.google.com/p/webrtc/issues/detail?id=4269
+    if ((preference <= current_preference && current_family == family) ||
+        (current_family == AF_INET && family == AF_INET6)) {
+      continue;
+    }
+    current_preference = preference;
+    current_family = family;
+    port = jsep_candidate->candidate().address().port();
+    ip = jsep_candidate->candidate().address().ipaddr().ToString();
+  }
+  rtc::SocketAddress connection_addr;
+  connection_addr.SetIP(ip);
+  connection_addr.SetPort(port);
+  auto content_description = static_cast<cricket::MediaContentDescription*>(
+      description->contents()[mediasection_index].description);
+  content_description->set_connection_address(connection_addr);
+}
+
 const char SessionDescriptionInterface::kOffer[] = "offer";
 const char SessionDescriptionInterface::kPrAnswer[] = "pranswer";
 const char SessionDescriptionInterface::kAnswer[] = "answer";
 
 const int JsepSessionDescription::kDefaultVideoCodecId = 100;
 const char JsepSessionDescription::kDefaultVideoCodecName[] = "VP8";
 
 SessionDescriptionInterface* CreateSessionDescription(const std::string& type,
                                                       const std::string& sdp,
                                                       SdpParseError* error) {
@@ skipping 58 matching lines @@
   }
   if (updated_candidate.password().empty()) {
     updated_candidate.set_password(transport_info->description.ice_pwd);
   }
 
   std::unique_ptr<JsepIceCandidate> updated_candidate_wrapper(
       new JsepIceCandidate(candidate->sdp_mid(),
                            static_cast<int>(mediasection_index),
                            updated_candidate));
   if (!candidate_collection_[mediasection_index].HasCandidate(
-          updated_candidate_wrapper.get()))
+          updated_candidate_wrapper.get())) {
     candidate_collection_[mediasection_index].add(
         updated_candidate_wrapper.release());
+    UpdateConnectionAddress(description_.get(), candidate_collection_,
+                            mediasection_index);
+  }
 
   return true;
 }
 
 size_t JsepSessionDescription::RemoveCandidates(
     const std::vector<cricket::Candidate>& candidates) {
   size_t num_removed = 0;
   for (auto& candidate : candidates) {
     int mediasection_index = GetMediasectionIndex(candidate);
     if (mediasection_index < 0) {
       // Not found.
       continue;
     }
     num_removed += candidate_collection_[mediasection_index].remove(candidate);
+    UpdateConnectionAddress(description_.get(), candidate_collection_,
+                            mediasection_index);
   }
   return num_removed;
 }
 
 size_t JsepSessionDescription::number_of_mediasections() const {
   if (!description_)
     return 0;
   return description_->contents().size();
 }
 
@@ skipping 44 matching lines @@
   const std::string& transport_name = candidate.transport_name();
   for (size_t i = 0; i < description_->contents().size(); ++i) {
     if (transport_name == description_->contents().at(i).name) {
       return static_cast<int>(i);
     }
   }
   return -1;
 }
 
 }  // namespace webrtc