Remove channel ids from various interfaces.

webrtc/video_engine/vie_channel.h

 /*
  *  Copyright (c) 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 47 matching lines @@
 class ViEChannel : public VCMFrameTypeCallback,
                    public VCMReceiveCallback,
                    public VCMReceiveStatisticsCallback,
                    public VCMDecoderTimingCallback,
                    public VCMPacketRequestCallback,
                    public RtpFeedback {
  public:
   friend class ChannelStatsObserver;
   friend class ViEChannelProtectionCallback;
 
-  ViEChannel(int32_t channel_id,
-             int32_t engine_id,
-             uint32_t number_of_cores,
+  ViEChannel(uint32_t number_of_cores,
              Transport* transport,
              ProcessThread* module_process_thread,
              RtcpIntraFrameObserver* intra_frame_observer,
              RtcpBandwidthObserver* bandwidth_observer,
              TransportFeedbackObserver* transport_feedback_observer,
              RemoteBitrateEstimator* remote_bitrate_estimator,
              RtcpRttStats* rtt_stats,
              PacedSender* paced_sender,
              PacketRouter* packet_router,
              size_t max_rtp_streams,
@@ skipping 104 matching lines @@
 
   void GetReceiveRtcpPacketTypeCounter(
       RtcpPacketTypeCounter* packet_counter) const;
 
   void RegisterSendSideDelayObserver(SendSideDelayObserver* observer);
 
   // Called on any new send bitrate estimate.
   void RegisterSendBitrateObserver(BitrateStatisticsObserver* observer);
 
   // Implements RtpFeedback.
-  virtual int32_t OnInitializeDecoder(
-      const int32_t id,
-      const int8_t payload_type,
-      const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-      const int frequency,
-      const uint8_t channels,
-      const uint32_t rate);
-  virtual void OnIncomingSSRCChanged(const int32_t id,
-                                     const uint32_t ssrc);
-  virtual void OnIncomingCSRCChanged(const int32_t id,
-                                     const uint32_t CSRC,
-                                     const bool added);
+  int32_t OnInitializeDecoder(const int8_t payload_type,
+                              const char payload_name[RTP_PAYLOAD_NAME_SIZE],
+                              const int frequency,
+                              const uint8_t channels,
+                              const uint32_t rate) override;
+  void OnIncomingSSRCChanged(const uint32_t ssrc) override;
+  void OnIncomingCSRCChanged(const uint32_t CSRC, const bool added) override;
 
   int32_t SetRemoteSSRCType(const StreamType usage, const uint32_t SSRC);
 
   int32_t StartSend();
   int32_t StopSend();
   bool Sending();
   void StartReceive();
   void StopReceive();
 
   int32_t ReceivedRTPPacket(const void* rtp_packet,
@@ skipping 72 matching lines @@
   void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms);
 
   int ProtectionRequest(const FecProtectionParams* delta_fec_params,
                         const FecProtectionParams* key_fec_params,
                         uint32_t* sent_video_rate_bps,
                         uint32_t* sent_nack_rate_bps,
                         uint32_t* sent_fec_rate_bps);
 
  private:
   static std::vector<RtpRtcp*> CreateRtpRtcpModules(
-      int32_t id,
       bool receiver_only,
       ReceiveStatistics* receive_statistics,
       Transport* outgoing_transport,
       RtcpIntraFrameObserver* intra_frame_callback,
       RtcpBandwidthObserver* bandwidth_callback,
       TransportFeedbackObserver* transport_feedback_callback,
       RtcpRttStats* rtt_stats,
       RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
       RemoteBitrateEstimator* remote_bitrate_estimator,
       PacedSender* paced_sender,
@@ skipping 93 matching lines @@
         const {
       CriticalSectionScoped cs(critsect_.get());
       return counter_map_;
     }
 
    private:
     std::map<uint32_t, RtcpPacketTypeCounter> counter_map_
         GUARDED_BY(critsect_);
   } rtcp_packet_type_counter_observer_;
 
-  const int32_t channel_id_;
-  const int32_t engine_id_;
   const uint32_t number_of_cores_;
   const bool sender_;
 
   ProcessThread* const module_process_thread_;
 
   // Used for all registered callbacks except rendering.
   rtc::scoped_ptr<CriticalSectionWrapper> crit_;
 
   // Owned modules/classes.
   rtc::scoped_refptr<PayloadRouter> send_payload_router_;
@@ skipping 31 matching lines @@
   size_t num_rtts_ GUARDED_BY(crit_);
 
   // RtpRtcp modules, declared last as they use other members on construction.
   const std::vector<RtpRtcp*> rtp_rtcp_modules_;
   size_t num_active_rtp_rtcp_modules_ GUARDED_BY(crit_);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_