Remove use of RtpHeaderExtension and clean up

webrtc/media/base/fakemediaengine.h

 /*
  *  Copyright (c) 2004 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 10 matching lines @@
 #include "webrtc/audio_sink.h"
 #include "webrtc/base/copyonwritebuffer.h"
 #include "webrtc/base/networkroute.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/media/base/audiosource.h"
 #include "webrtc/media/base/mediaengine.h"
 #include "webrtc/media/base/rtputils.h"
 #include "webrtc/media/base/streamparams.h"
 #include "webrtc/p2p/base/sessiondescription.h"
 
+using webrtc::RtpExtension;
+
 namespace cricket {
 
 class FakeMediaEngine;
 class FakeVideoEngine;
 class FakeVoiceEngine;
 
 // A common helper class that handles sending and receiving RTP/RTCP packets.
 template <class Base> class RtpHelper : public Base {
  public:
   RtpHelper()
       : sending_(false),
         playout_(false),
         fail_set_send_codecs_(false),
         fail_set_recv_codecs_(false),
         send_ssrc_(0),
         ready_to_send_(false) {}
-  const std::vector<RtpHeaderExtension>& recv_extensions() {
+  const std::vector<RtpExtension>& recv_extensions() {
     return recv_extensions_;
   }
-  const std::vector<RtpHeaderExtension>& send_extensions() {
+  const std::vector<RtpExtension>& send_extensions() {
     return send_extensions_;
   }
   bool sending() const { return sending_; }
   bool playout() const { return playout_; }
   const std::list<std::string>& rtp_packets() const { return rtp_packets_; }
   const std::list<std::string>& rtcp_packets() const { return rtcp_packets_; }
 
   bool SendRtp(const void* data,
                size_t len,
                const rtc::PacketOptions& options) {
@@ skipping 163 matching lines @@
     } else {
       muted_streams_.erase(ssrc);
     }
     return true;
   }
   bool set_sending(bool send) {
     sending_ = send;
     return true;
   }
   void set_playout(bool playout) { playout_ = playout; }
-  bool SetRecvRtpHeaderExtensions(
-      const std::vector<RtpHeaderExtension>& extensions) {
+  bool SetRecvRtpHeaderExtensions(const std::vector<RtpExtension>& extensions) {
     recv_extensions_ = extensions;
     return true;
   }
-  bool SetSendRtpHeaderExtensions(
-      const std::vector<RtpHeaderExtension>& extensions) {
+  bool SetSendRtpHeaderExtensions(const std::vector<RtpExtension>& extensions) {
     send_extensions_ = extensions;
     return true;
   }
   virtual void OnPacketReceived(rtc::CopyOnWriteBuffer* packet,
                                 const rtc::PacketTime& packet_time) {
     rtp_packets_.push_back(std::string(packet->data<char>(), packet->size()));
   }
   virtual void OnRtcpReceived(rtc::CopyOnWriteBuffer* packet,
                               const rtc::PacketTime& packet_time) {
     rtcp_packets_.push_back(std::string(packet->data<char>(), packet->size()));
   }
   virtual void OnReadyToSend(bool ready) {
     ready_to_send_ = ready;
   }
   virtual void OnNetworkRouteChanged(const std::string& transport_name,
                                      const rtc::NetworkRoute& network_route) {
     last_network_route_ = network_route;
     ++num_network_route_changes_;
   }
   bool fail_set_send_codecs() const { return fail_set_send_codecs_; }
   bool fail_set_recv_codecs() const { return fail_set_recv_codecs_; }
 
  private:
   bool sending_;
   bool playout_;
-  std::vector<RtpHeaderExtension> recv_extensions_;
-  std::vector<RtpHeaderExtension> send_extensions_;
+  std::vector<RtpExtension> recv_extensions_;
+  std::vector<RtpExtension> send_extensions_;
   std::list<std::string> rtp_packets_;
   std::list<std::string> rtcp_packets_;
   std::vector<StreamParams> send_streams_;
   std::vector<StreamParams> receive_streams_;
   std::set<uint32_t> muted_streams_;
   std::map<uint32_t, webrtc::RtpParameters> rtp_send_parameters_;
   std::map<uint32_t, webrtc::RtpParameters> rtp_receive_parameters_;
   bool fail_set_send_codecs_;
   bool fail_set_recv_codecs_;
   uint32_t send_ssrc_;
@@ skipping 427 matching lines @@
 // A base class for all of the shared parts between FakeVoiceEngine
 // and FakeVideoEngine.
 class FakeBaseEngine {
  public:
   FakeBaseEngine()
       : options_changed_(false),
         fail_create_channel_(false) {}
   void set_fail_create_channel(bool fail) { fail_create_channel_ = fail; }
 
   RtpCapabilities GetCapabilities() const { return capabilities_; }
-  void set_rtp_header_extensions(
-      const std::vector<RtpHeaderExtension>& extensions) {
+  void set_rtp_header_extensions(const std::vector<RtpExtension>& extensions) {
     capabilities_.header_extensions = extensions;
   }
 
  protected:
   // Flag used by optionsmessagehandler_unittest for checking whether any
   // relevant setting has been updated.
   // TODO(thaloun): Replace with explicit checks of before & after values.
   bool options_changed_;
   bool fail_create_channel_;
   RtpCapabilities capabilities_;
@@ skipping 120 matching lines @@
   virtual ~FakeMediaEngine() {}
 
   void SetAudioCodecs(const std::vector<AudioCodec>& codecs) {
     voice_.SetCodecs(codecs);
   }
   void SetVideoCodecs(const std::vector<VideoCodec>& codecs) {
     video_.SetCodecs(codecs);
   }
 
   void SetAudioRtpHeaderExtensions(
-      const std::vector<RtpHeaderExtension>& extensions) {
+      const std::vector<RtpExtension>& extensions) {
     voice_.set_rtp_header_extensions(extensions);
   }
   void SetVideoRtpHeaderExtensions(
-      const std::vector<RtpHeaderExtension>& extensions) {
+      const std::vector<RtpExtension>& extensions) {
     video_.set_rtp_header_extensions(extensions);
   }
 
   FakeVoiceMediaChannel* GetVoiceChannel(size_t index) {
     return voice_.GetChannel(index);
   }
   FakeVideoMediaChannel* GetVideoChannel(size_t index) {
     return video_.GetChannel(index);
   }
 
@@ skipping 67 matching lines @@
 
  private:
   std::vector<FakeDataMediaChannel*> channels_;
   std::vector<DataCodec> data_codecs_;
   DataChannelType last_channel_type_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_BASE_FAKEMEDIAENGINE_H_