Remove default receive channel from WVoE; baby step 3.

talk/media/webrtc/webrtcvoiceengine.h

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 241 matching lines @@
   bool SetLocalRenderer(uint32_t ssrc, AudioRenderer* renderer);
   bool MuteStream(uint32_t ssrc, bool mute);
 
   WebRtcVoiceEngine* engine() { return engine_; }
   int GetLastEngineError() { return engine()->GetLastEngineError(); }
   int GetOutputLevel(int channel);
   bool GetRedSendCodec(const AudioCodec& red_codec,
                        const std::vector<AudioCodec>& all_codecs,
                        webrtc::CodecInst* send_codec);
   bool EnableRtcp(int channel);
-  bool ResetRecvCodecs(int channel);
   bool SetPlayout(int channel, bool playout);
-  static uint32_t ParseSsrc(const void* data, size_t len, bool rtcp);
   static Error WebRtcErrorToChannelError(int err_code);
 
   class WebRtcVoiceChannelRenderer;
   // Map of ssrc to WebRtcVoiceChannelRenderer object.  A new object of
   // WebRtcVoiceChannelRenderer will be created for every new stream and
   // will be destroyed when the stream goes away.
   typedef std::map<uint32_t, WebRtcVoiceChannelRenderer*> ChannelMap;
   typedef int (webrtc::VoERTP_RTCP::* ExtensionSetterFunction)(int, bool,
       unsigned char);
 
   void SetNack(int channel, bool nack_enabled);
   void SetNack(const ChannelMap& channels, bool nack_enabled);
   bool SetSendCodec(const webrtc::CodecInst& send_codec);
   bool SetSendCodec(int channel, const webrtc::CodecInst& send_codec);
   bool ChangePlayout(bool playout);
   bool ChangeSend(SendFlags send);
   bool ChangeSend(int channel, SendFlags send);
   void ConfigureSendChannel(int channel);
   bool ConfigureRecvChannel(int channel);
   bool DeleteChannel(int channel);
-  bool InConferenceMode() const {
-    return options_.conference_mode.GetWithDefaultIfUnset(false);
-  }
   bool IsDefaultChannel(int channel_id) const {
     return channel_id == default_send_channel_id_;
   }
+  bool IsDefaultRecvStream(uint32_t ssrc) {
+    return default_recv_ssrc_ == static_cast<int64_t>(ssrc);
+  }
   bool SetSendCodecs(int channel, const std::vector<AudioCodec>& codecs);
   bool SetSendBitrateInternal(int bps);
 
   bool SetHeaderExtension(ExtensionSetterFunction setter, int channel_id,
                           const RtpHeaderExtension* extension);
   void RecreateAudioReceiveStreams();
   void AddAudioReceiveStream(uint32_t ssrc);
   void RemoveAudioReceiveStream(uint32_t ssrc);
   bool SetRecvCodecsInternal(const std::vector<AudioCodec>& new_codecs);
 
@@ skipping 16 matching lines @@
   AudioOptions options_;
   bool dtmf_allowed_;
   bool desired_playout_;
   bool nack_enabled_;
   bool playout_;
   bool typing_noise_detected_;
   SendFlags desired_send_;
   SendFlags send_;
   webrtc::Call* const call_;
 
+  // SSRC of unsignalled receive stream, or -1 if there isn't one.
+  int64_t default_recv_ssrc_ = -1;
+  // Volume for unsignalled stream, which may be set before the stream exists.
+  double default_recv_volume_ = 1.0;
+
   // send_channels_ contains the channels which are being used for sending.
   // When the default channel (default_send_channel_id) is used for sending, it
   // is contained in send_channels_, otherwise not.
   ChannelMap send_channels_;
   std::vector<RtpHeaderExtension> send_extensions_;
-  uint32_t default_receive_ssrc_;
-  // Note the default channel (default_send_channel_id()) can reside in both
-  // receive_channels_ and send_channels_ in non-conference mode and in that
-  // case it will only be there if a non-zero default_receive_ssrc_ is set.
-  ChannelMap receive_channels_;  // for multiple sources
+  ChannelMap receive_channels_;
   std::map<uint32_t, webrtc::AudioReceiveStream*> receive_streams_;
   std::map<uint32_t, StreamParams> receive_stream_params_;
   // receive_channels_ can be read from WebRtc callback thread.  Access from
   // the WebRtc thread must be synchronized with edits on the worker thread.
   // Reads on the worker thread are ok.
   std::vector<RtpHeaderExtension> receive_extensions_;
   std::vector<webrtc::RtpExtension> recv_rtp_extensions_;
-
-  // Do not lock this on the VoE media processor thread; potential for deadlock
-  // exists.
-  mutable rtc::CriticalSection receive_channels_cs_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_WEBRTCVOICEENGINE_H_