Remove use of RtpHeaderExtension and clean up

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.
  */
 
 #include "webrtc/api/webrtcsdp.h"
 
 #include <ctype.h>
 #include <limits.h>
 #include <stdio.h>
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "webrtc/api/jsepicecandidate.h"
 #include "webrtc/api/jsepsessiondescription.h"
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagedigest.h"
 #include "webrtc/base/stringutils.h"
+// for RtpExtension
+#include "webrtc/config.h"
 #include "webrtc/media/base/codec.h"
 #include "webrtc/media/base/cryptoparams.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/rtputils.h"
 #include "webrtc/media/sctp/sctpdataengine.h"
 #include "webrtc/p2p/base/candidate.h"
 #include "webrtc/p2p/base/p2pconstants.h"
 #include "webrtc/p2p/base/port.h"
 #include "webrtc/pc/mediasession.h"
 
@@ skipping 17 matching lines @@
 using cricket::kCodecParamStereo;
 using cricket::kCodecParamUseInbandFec;
 using cricket::kCodecParamUseDtx;
 using cricket::kCodecParamSctpProtocol;
 using cricket::kCodecParamSctpStreams;
 using cricket::kCodecParamMaxAverageBitrate;
 using cricket::kCodecParamMaxPlaybackRate;
 using cricket::kCodecParamAssociatedPayloadType;
 using cricket::MediaContentDescription;
 using cricket::MediaType;
-using cricket::RtpHeaderExtension;
+using cricket::RtpHeaderExtensions;
 using cricket::SsrcGroup;
 using cricket::StreamParams;
 using cricket::StreamParamsVec;
 using cricket::TransportDescription;
 using cricket::TransportInfo;
 using cricket::VideoContentDescription;
 using rtc::SocketAddress;
 
-typedef std::vector<RtpHeaderExtension> RtpHeaderExtensions;
-
 namespace cricket {
 class SessionDescription;
 }
 
 namespace webrtc {
 
 // Line type
 // RFC 4566
 // An SDP session description consists of a number of lines of text of
 // the form:
@@ skipping 214 matching lines @@
 static bool ParseCandidate(const std::string& message, Candidate* candidate,
                            SdpParseError* error, bool is_raw);
 static bool ParseRtcpFbAttribute(const std::string& line,
                                  const MediaType media_type,
                                  MediaContentDescription* media_desc,
                                  SdpParseError* error);
 static bool ParseIceOptions(const std::string& line,
                             std::vector<std::string>* transport_options,
                             SdpParseError* error);
 static bool ParseExtmap(const std::string& line,
-                        RtpHeaderExtension* extmap,
+                        RtpExtension* extmap,
                         SdpParseError* error);
 static bool ParseFingerprintAttribute(const std::string& line,
                                       rtc::SSLFingerprint** fingerprint,
                                       SdpParseError* error);
 static bool ParseDtlsSetup(const std::string& line,
                            cricket::ConnectionRole* role,
                            SdpParseError* error);
 static bool ParseMsidAttribute(const std::string& line,
                                std::string* stream_id,
                                std::string* track_id,
@@ skipping 838 matching lines @@
   }
   if (fields.size() < expected_min_fields) {
     return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
   }
   if (!rtc::FromString(fields[1], sctp_port)) {
     return ParseFailed(line, "Invalid sctp port value.", error);
   }
   return true;
 }
 
-bool ParseExtmap(const std::string& line, RtpHeaderExtension* extmap,
+bool ParseExtmap(const std::string& line,
+                 RtpExtension* extmap,
                  SdpParseError* error) {
   // RFC 5285
   // a=extmap:<value>["/"<direction>] <URI> <extensionattributes>
   std::vector<std::string> fields;
   rtc::split(line.substr(kLinePrefixLength),
                    kSdpDelimiterSpace, &fields);
   const size_t expected_min_fields = 2;
   if (fields.size() < expected_min_fields) {
     return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
   }
   std::string uri = fields[1];
 
   std::string value_direction;
   if (!GetValue(fields[0], kAttributeExtmap, &value_direction, error)) {
     return false;
   }
   std::vector<std::string> sub_fields;
   rtc::split(value_direction, kSdpDelimiterSlash, &sub_fields);
   int value = 0;
   if (!GetValueFromString(line, sub_fields[0], &value, error)) {
     return false;
   }
 
-  *extmap = RtpHeaderExtension(uri, value);
+  *extmap = RtpExtension(uri, value);
   return true;
 }
 
 void BuildMediaDescription(const ContentInfo* content_info,
                            const TransportInfo* transport_info,
                            const MediaType media_type,
                            const std::vector<Candidate>& candidates,
                            bool unified_plan_sdp,
                            std::string* message) {
   ASSERT(message != NULL);
@@ skipping 802 matching lines @@
         return false;
       }
     } else if (HasAttribute(line, kAttributeMsidSemantics)) {
       std::string semantics;
       if (!GetValue(line, kAttributeMsidSemantics, &semantics, error)) {
         return false;
       }
       desc->set_msid_supported(
           CaseInsensitiveFind(semantics, kMediaStreamSemantic));
     } else if (HasAttribute(line, kAttributeExtmap)) {
-      RtpHeaderExtension extmap;
+      RtpExtension extmap;
       if (!ParseExtmap(line, &extmap, error)) {
         return false;
       }
       session_extmaps->push_back(extmap);
     }
   }
 
   return true;
 }
 
@@ skipping 667 matching lines @@
         }
       } else if (HasAttribute(line, kAttributeSendOnly)) {
         media_desc->set_direction(cricket::MD_SENDONLY);
       } else if (HasAttribute(line, kAttributeRecvOnly)) {
         media_desc->set_direction(cricket::MD_RECVONLY);
       } else if (HasAttribute(line, kAttributeInactive)) {
         media_desc->set_direction(cricket::MD_INACTIVE);
       } else if (HasAttribute(line, kAttributeSendRecv)) {
         media_desc->set_direction(cricket::MD_SENDRECV);
       } else if (HasAttribute(line, kAttributeExtmap)) {
-        RtpHeaderExtension extmap;
+        RtpExtension extmap;
         if (!ParseExtmap(line, &extmap, error)) {
           return false;
         }
         media_desc->AddRtpHeaderExtension(extmap);
       } else if (HasAttribute(line, kAttributeXGoogleFlag)) {
         // Experimental attribute.  Conference mode activates more aggressive
         // AEC and NS settings.
         // TODO: expose API to set these directly.
         std::string flag_value;
         if (!GetValue(line, kAttributeXGoogleFlag, &flag_value, error)) {
@@ skipping 458 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