Reland the CL to remove candidates when doing continual gathering

webrtc/api/webrtcsdp.cc

 /*
  *  Copyright 2011 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 136 matching lines @@
 // a=sctp-port
 static const char kAttributeSctpPort[] = "sctp-port";
 
 // Experimental flags
 static const char kAttributeXGoogleFlag[] = "x-google-flag";
 static const char kValueConference[] = "conference";
 
 // Candidate
 static const char kCandidateHost[] = "host";
 static const char kCandidateSrflx[] = "srflx";
-// TODO: How to map the prflx with circket candidate type
-// static const char kCandidatePrflx[] = "prflx";
+static const char kCandidatePrflx[] = "prflx";
 static const char kCandidateRelay[] = "relay";
 static const char kTcpCandidateType[] = "tcptype";
 
 static const char kSdpDelimiterEqual = '=';
 static const char kSdpDelimiterSpace = ' ';
 static const char kSdpDelimiterColon = ':';
 static const char kSdpDelimiterSemicolon = ';';
 static const char kSdpDelimiterSlash = '/';
 static const char kNewLine = '\n';
 static const char kReturn = '\r';
@@ skipping 695 matching lines @@
     GetCandidatesByMindex(jdesc, ++mline_index, &candidates);
     BuildMediaDescription(&*it, desc->GetTransportInfoByName(it->name),
                           mdesc->type(), candidates, unified_plan_sdp,
                           &message);
   }
   return message;
 }
 
 // Serializes the passed in IceCandidateInterface to a SDP string.
 // candidate - The candidate to be serialized.
-std::string SdpSerializeCandidate(
-    const IceCandidateInterface& candidate) {
+std::string SdpSerializeCandidate(const IceCandidateInterface& candidate) {
+  return SdpSerializeCandidate(candidate.candidate());
+}
+
+// Serializes a cricket Candidate.
+std::string SdpSerializeCandidate(const cricket::Candidate& candidate) {
   std::string message;
-  std::vector<cricket::Candidate> candidates;
-  candidates.push_back(candidate.candidate());
+  std::vector<cricket::Candidate> candidates(1, candidate);
   BuildCandidate(candidates, true, &message);
   // From WebRTC draft section 4.8.1.1 candidate-attribute will be
   // just candidate:<candidate> not a=candidate:<blah>CRLF
   ASSERT(message.find("a=") == 0);
   message.erase(0, 2);
   ASSERT(message.find(kLineBreak) == message.size() - 2);
   message.resize(message.size() - 2);
   return message;
 }
 
@@ skipping 42 matching lines @@
                              SdpParseError* error) {
   ASSERT(jcandidate != NULL);
   Candidate candidate;
   if (!ParseCandidate(message, &candidate, error, true)) {
     return false;
   }
   jcandidate->SetCandidate(candidate);
   return true;
 }
 
+bool SdpDeserializeCandidate(const std::string& transport_name,
+                             const std::string& message,
+                             cricket::Candidate* candidate,
+                             SdpParseError* error) {
+  ASSERT(candidate != nullptr);
+  if (!ParseCandidate(message, candidate, error, true)) {
+    return false;
+  }
+  candidate->set_transport_name(transport_name);
+  return true;
+}
+
 bool ParseCandidate(const std::string& message, Candidate* candidate,
                     SdpParseError* error, bool is_raw) {
   ASSERT(candidate != NULL);
 
   // Get the first line from |message|.
   std::string first_line = message;
   size_t pos = 0;
   GetLine(message, &pos, &first_line);
 
   // Makes sure |message| contains only one line.
@@ skipping 68 matching lines @@
   }
 
   std::string candidate_type;
   const std::string& type = fields[7];
   if (type == kCandidateHost) {
     candidate_type = cricket::LOCAL_PORT_TYPE;
   } else if (type == kCandidateSrflx) {
     candidate_type = cricket::STUN_PORT_TYPE;
   } else if (type == kCandidateRelay) {
     candidate_type = cricket::RELAY_PORT_TYPE;
+  } else if (type == kCandidatePrflx) {
+    candidate_type = cricket::PRFLX_PORT_TYPE;
   } else {
     return ParseFailed(first_line, "Unsupported candidate type.", error);
   }
 
   size_t current_position = expected_min_fields;
   SocketAddress related_address;
   // The 2 optional fields for related address
   // [raddr <connection-address>] [rport <port>]
   if (fields.size() >= (current_position + 2) &&
       fields[current_position] == kAttributeCandidateRaddr) {
@@ skipping 715 matching lines @@
     // [raddr <connection-address>] [rport <port>]
     // *(SP extension-att-name SP extension-att-value)
     std::string type;
     // Map the cricket candidate type to "host" / "srflx" / "prflx" / "relay"
     if (it->type() == cricket::LOCAL_PORT_TYPE) {
       type = kCandidateHost;
     } else if (it->type() == cricket::STUN_PORT_TYPE) {
       type = kCandidateSrflx;
     } else if (it->type() == cricket::RELAY_PORT_TYPE) {
       type = kCandidateRelay;
+    } else if (it->type() == cricket::PRFLX_PORT_TYPE) {
+      type = kCandidatePrflx;
+      // Peer reflexive candidate may be signaled for being removed.
     } else {
       ASSERT(false);
       // Never write out candidates if we don't know the type.
       continue;
     }
 
     InitAttrLine(kAttributeCandidate, &os);
     os << kSdpDelimiterColon
        << it->foundation() << " "
        << it->component() << " "
@@ skipping 1354 matching lines @@
     UpdateCodec<AudioContentDescription, cricket::AudioCodec>(
         media_desc, payload_type, feedback_param);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     UpdateCodec<VideoContentDescription, cricket::VideoCodec>(
         media_desc, payload_type, feedback_param);
   }
   return true;
 }
 
 }  // namespace webrtc