Some cleanup in BaseChannel RTCP mux code.

webrtc/pc/channel.h

 /*
  *  Copyright 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 52 matching lines @@
 // WARNING! SUBCLASSES MUST CALL Deinit() IN THEIR DESTRUCTORS!
 // This is required to avoid a data race between the destructor modifying the
 // vtable, and the media channel's thread using BaseChannel as the
 // NetworkInterface.
 
 class BaseChannel
     : public rtc::MessageHandler, public sigslot::has_slots<>,
       public MediaChannel::NetworkInterface,
       public ConnectionStatsGetter {
  public:
+  // |rtcp| represents whether or not this channel uses RTCP.
   BaseChannel(rtc::Thread* worker_thread,
               rtc::Thread* network_thread,
               MediaChannel* channel,
               TransportController* transport_controller,
               const std::string& content_name,
               bool rtcp);
   virtual ~BaseChannel();
   bool Init_w(const std::string* bundle_transport_name);
   // Deinit may be called multiple times and is simply ignored if it's already
   // done.
@@ skipping 107 matching lines @@
     remote_content_direction_ = direction;
   }
   void set_secure_required(bool secure_required) {
     secure_required_ = secure_required;
   }
   bool IsReadyToReceive_w() const;
   bool IsReadyToSend_w() const;
   rtc::Thread* signaling_thread() {
     return transport_controller_->signaling_thread();
   }
-  bool rtcp_transport_enabled() const { return rtcp_transport_enabled_; }
 
   void ConnectToTransportChannel(TransportChannel* tc);
   void DisconnectFromTransportChannel(TransportChannel* tc);
 
   void FlushRtcpMessages_n();
 
   // NetworkInterface implementation, called by MediaEngine
   bool SendPacket(rtc::CopyOnWriteBuffer* packet,
                   const rtc::PacketOptions& options) override;
   bool SendRtcp(rtc::CopyOnWriteBuffer* packet,
@@ skipping 124 matching lines @@
   rtc::Thread* const worker_thread_;
   rtc::Thread* const network_thread_;
   rtc::AsyncInvoker invoker_;
 
   const std::string content_name_;
   std::unique_ptr<ConnectionMonitor> connection_monitor_;
 
   // Transport related members that should be accessed from network thread.
   TransportController* const transport_controller_;
   std::string transport_name_;
-  bool rtcp_transport_enabled_;
-  TransportChannel* transport_channel_;
+  // Is RTCP used at all by this type of channel?
+  // Expected to be true (as of typing this) for everything except data
+  // channels.
+  const bool rtcp_enabled_;
+  TransportChannel* transport_channel_ = nullptr;
   std::vector<std::pair<rtc::Socket::Option, int> > socket_options_;
-  TransportChannel* rtcp_transport_channel_;
+  TransportChannel* rtcp_transport_channel_ = nullptr;
   std::vector<std::pair<rtc::Socket::Option, int> > rtcp_socket_options_;
   SrtpFilter srtp_filter_;
   RtcpMuxFilter rtcp_mux_filter_;
   BundleFilter bundle_filter_;
-  bool rtp_ready_to_send_;
-  bool rtcp_ready_to_send_;
-  bool writable_;
-  bool was_ever_writable_;
-  bool has_received_packet_;
-  bool dtls_keyed_;
-  bool secure_required_;
+  bool rtp_ready_to_send_ = false;
+  bool rtcp_ready_to_send_ = false;
+  bool writable_ = false;
+  bool was_ever_writable_ = false;
+  bool has_received_packet_ = false;
+  bool dtls_keyed_ = false;
+  bool secure_required_ = false;
   rtc::CryptoOptions crypto_options_;
-  int rtp_abs_sendtime_extn_id_;
+  int rtp_abs_sendtime_extn_id_ = -1;
 
   // MediaChannel related members that should be access from worker thread.
   MediaChannel* const media_channel_;
   // Currently enabled_ flag accessed from signaling thread too, but it can
   // be changed only when signaling thread does sunchronious call to worker
   // thread, so it should be safe.
-  bool enabled_;
+  bool enabled_ = false;
   std::vector<StreamParams> local_streams_;
   std::vector<StreamParams> remote_streams_;
-  MediaContentDirection local_content_direction_;
-  MediaContentDirection remote_content_direction_;
+  MediaContentDirection local_content_direction_ = MD_INACTIVE;
+  MediaContentDirection remote_content_direction_ = MD_INACTIVE;
 };
 
 // VoiceChannel is a specialization that adds support for early media, DTMF,
 // and input/output level monitoring.
 class VoiceChannel : public BaseChannel {
  public:
   VoiceChannel(rtc::Thread* worker_thread,
                rtc::Thread* network_thread,
                MediaEngineInterface* media_engine,
                VoiceMediaChannel* channel,
@@ skipping 304 matching lines @@
   // SetSendParameters.
   DataSendParameters last_send_params_;
   // Last DataRecvParameters sent down to the media_channel() via
   // SetRecvParameters.
   DataRecvParameters last_recv_params_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_PC_CHANNEL_H_