diff --git a/talk/media/base/videoengine_unittest.h b/talk/media/base/videoengine_unittest.h
index 502cf47..40881eb 100644
--- a/talk/media/base/videoengine_unittest.h
+++ b/talk/media/base/videoengine_unittest.h
@@ -1720,7 +1720,6 @@
     EXPECT_FALSE(channel_->RemoveSendStream(kSsrcs4[kSsrcsSize - 1]));
   }
 
-
   // Two streams one channel tests.
 
   // Tests that we can send and receive frames.
@@ -1742,18 +1741,18 @@
   void TwoStreamsReUseFirstStream(const cricket::VideoCodec& codec) {
     SetUpSecondStream();
     // Default channel used by the first stream.
-    EXPECT_EQ(kSsrc, channel_->GetDefaultChannelSsrc());
+    EXPECT_EQ(kSsrc, channel_->GetDefaultSendChannelSsrc());
     EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc));
     EXPECT_FALSE(channel_->RemoveRecvStream(kSsrc));
     EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
     EXPECT_FALSE(channel_->RemoveSendStream(kSsrc));
     // Default channel is no longer used by a stream.
-    EXPECT_EQ(0u, channel_->GetDefaultChannelSsrc());
+    EXPECT_EQ(0u, channel_->GetDefaultSendChannelSsrc());
     uint32 new_ssrc = kSsrc + 100;
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(new_ssrc)));
     // Re-use default channel.
-    EXPECT_EQ(new_ssrc, channel_->GetDefaultChannelSsrc());
+    EXPECT_EQ(new_ssrc, channel_->GetDefaultSendChannelSsrc());
     EXPECT_FALSE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(new_ssrc)));
     EXPECT_TRUE(channel_->AddRecvStream(
@@ -1766,7 +1765,7 @@
 
     SendAndReceive(codec);
     EXPECT_TRUE(channel_->RemoveSendStream(new_ssrc));
-    EXPECT_EQ(0u, channel_->GetDefaultChannelSsrc());
+    EXPECT_EQ(0u, channel_->GetDefaultSendChannelSsrc());
   }
 
   // Tests that we can send and receive frames with early receive.
diff --git a/talk/media/webrtc/fakewebrtcvideoengine.h b/talk/media/webrtc/fakewebrtcvideoengine.h
index 3a619bd..da5cd89 100644
--- a/talk/media/webrtc/fakewebrtcvideoengine.h
+++ b/talk/media/webrtc/fakewebrtcvideoengine.h
@@ -548,13 +548,21 @@
     WEBRTC_ASSERT_CHANNEL(channel);
     return channels_.find(channel)->second->overuse_options_;
   }
-  int GetRtxSsrc(int channel, int simulcast_idx) const {
+  int GetSsrc(int channel, int idx) const {
     WEBRTC_ASSERT_CHANNEL(channel);
-    if (channels_.find(channel)->second->rtx_ssrcs_.find(simulcast_idx) ==
+    if (channels_.find(channel)->second->ssrcs_.find(idx) ==
+        channels_.find(channel)->second->ssrcs_.end()) {
+      return -1;
+    }
+    return channels_.find(channel)->second->ssrcs_[idx];
+  }
+  int GetRtxSsrc(int channel, int idx) const {
+    WEBRTC_ASSERT_CHANNEL(channel);
+    if (channels_.find(channel)->second->rtx_ssrcs_.find(idx) ==
         channels_.find(channel)->second->rtx_ssrcs_.end()) {
       return -1;
     }
-    return channels_.find(channel)->second->rtx_ssrcs_[simulcast_idx];
+    return channels_.find(channel)->second->rtx_ssrcs_[idx];
   }
   bool ReceiveCodecRegistered(int channel,
                               const webrtc::VideoCodec& codec) const {
diff --git a/talk/media/webrtc/webrtcvideoengine.cc b/talk/media/webrtc/webrtcvideoengine.cc
index 7afe5de..3e42b7c 100644
--- a/talk/media/webrtc/webrtcvideoengine.cc
+++ b/talk/media/webrtc/webrtcvideoengine.cc
@@ -88,6 +88,10 @@
 
 static const int kExternalVideoPayloadTypeBase = 120;
 
+static const int kChannelIdUnset = -1;
+static const uint32 kDefaultChannelSsrcKey = 0;
+static const uint32 kSsrcUnset = 0;
+
 static bool BitrateIsSet(int value) {
   return value > kAutoBandwidth;
 }
@@ -177,7 +181,7 @@
     // TODO(ronghuawu): Add unit test for this case. Didn't do it now
     // because the WebRtcRenderAdapter is currently hiding in cc file. No
     // good way to get access to it from the unit test.
-    if (width_ > 0 && height_ > 0 && renderer_ != NULL) {
+    if (width_ > 0 && height_ > 0 && renderer_) {
       if (!renderer_->SetSize(width_, height_, 0)) {
         LOG(LS_ERROR)
             << "WebRtcRenderAdapter (channel " << channel_id_
@@ -196,7 +200,7 @@
     LOG(LS_INFO) << "WebRtcRenderAdapter (channel " << channel_id_
                  << ") frame size changed to: "
                  << width << "x" << height;
-    if (renderer_ == NULL) {
+    if (!renderer_) {
       LOG(LS_VERBOSE) << "WebRtcRenderAdapter (channel " << channel_id_
                       << ") the renderer has not been set. "
                       << "SetSize will be called later in SetRenderer.";
@@ -225,7 +229,7 @@
       capture_start_ntp_time_ms_ = ntp_time_ms - elapsed_time_ms;
     }
     frame_rate_tracker_.Update(1);
-    if (renderer_ == NULL) {
+    if (!renderer_) {
       return 0;
     }
     // Convert elapsed_time_ms to ns timestamp.
@@ -237,7 +241,7 @@
     // Note that here we send the |elapsed_time_ns| to renderer as the
     // cricket::VideoFrame's elapsed_time_ and the |render_time_ns| as the
     // cricket::VideoFrame's time_stamp_.
-    if (handle == NULL) {
+    if (!handle) {
       return DeliverBufferFrame(buffer, buffer_size, render_time_ns,
                                 elapsed_time_ns);
     } else {
@@ -311,8 +315,8 @@
 
 class WebRtcDecoderObserver : public webrtc::ViEDecoderObserver {
  public:
-  explicit WebRtcDecoderObserver(int video_channel)
-       : video_channel_(video_channel),
+  explicit WebRtcDecoderObserver(int video_channel_id)
+       : video_channel_id_(video_channel_id),
          framerate_(0),
          bitrate_(0),
          decode_ms_(0),
@@ -325,13 +329,13 @@
   }
 
   // virtual functions from VieDecoderObserver.
-  virtual void IncomingCodecChanged(const int videoChannel,
+  virtual void IncomingCodecChanged(const int video_channel_id,
                                     const webrtc::VideoCodec& videoCodec) {}
-  virtual void IncomingRate(const int videoChannel,
+  virtual void IncomingRate(const int video_channel_id,
                             const unsigned int framerate,
                             const unsigned int bitrate) {
     rtc::CritScope cs(&crit_);
-    ASSERT(video_channel_ == videoChannel);
+    ASSERT(video_channel_id_ == video_channel_id);
     framerate_ = framerate;
     bitrate_ = bitrate;
   }
@@ -353,7 +357,7 @@
     render_delay_ms_ = render_delay_ms;
   }
 
-  virtual void RequestNewKeyFrame(const int videoChannel) {}
+  virtual void RequestNewKeyFrame(const int video_channel_id) {}
 
   // Populate |rinfo| based on previously-set data in |*this|.
   void ExportTo(VideoReceiverInfo* rinfo) {
@@ -370,7 +374,7 @@
 
  private:
   mutable rtc::CriticalSection crit_;
-  int video_channel_;
+  int video_channel_id_;
   int framerate_;
   int bitrate_;
   int decode_ms_;
@@ -384,26 +388,26 @@
 
 class WebRtcEncoderObserver : public webrtc::ViEEncoderObserver {
  public:
-  explicit WebRtcEncoderObserver(int video_channel)
-      : video_channel_(video_channel),
+  explicit WebRtcEncoderObserver(int video_channel_id)
+      : video_channel_id_(video_channel_id),
         framerate_(0),
         bitrate_(0),
         suspended_(false) {
   }
 
   // virtual functions from VieEncoderObserver.
-  virtual void OutgoingRate(const int videoChannel,
+  virtual void OutgoingRate(const int video_channel_id,
                             const unsigned int framerate,
                             const unsigned int bitrate) {
     rtc::CritScope cs(&crit_);
-    ASSERT(video_channel_ == videoChannel);
+    ASSERT(video_channel_id_ == video_channel_id);
     framerate_ = framerate;
     bitrate_ = bitrate;
   }
 
-  virtual void SuspendChange(int video_channel, bool is_suspended) {
+  virtual void SuspendChange(int video_channel_id, bool is_suspended) {
     rtc::CritScope cs(&crit_);
-    ASSERT(video_channel_ == video_channel);
+    ASSERT(video_channel_id_ == video_channel_id);
     suspended_ = is_suspended;
   }
 
@@ -422,7 +426,7 @@
 
  private:
   mutable rtc::CriticalSection crit_;
-  int video_channel_;
+  int video_channel_id_;
   int framerate_;
   int bitrate_;
   bool suspended_;
@@ -840,7 +844,7 @@
 
 static void UpdateVideoCodec(const cricket::VideoFormat& video_format,
                              webrtc::VideoCodec* target_codec) {
-  if ((target_codec == NULL) || (video_format == cricket::VideoFormat())) {
+  if ((!target_codec) || (video_format == cricket::VideoFormat())) {
     return;
   }
   target_codec->width = video_format.width;
@@ -1473,7 +1477,7 @@
 
 webrtc::VideoDecoder* WebRtcVideoEngine::CreateExternalDecoder(
     webrtc::VideoCodecType type) {
-  if (decoder_factory_ == NULL) {
+  if (!decoder_factory_) {
     return NULL;
   }
   return decoder_factory_->CreateVideoDecoder(type);
@@ -1481,14 +1485,14 @@
 
 void WebRtcVideoEngine::DestroyExternalDecoder(webrtc::VideoDecoder* decoder) {
   ASSERT(decoder_factory_ != NULL);
-  if (decoder_factory_ == NULL)
+  if (!decoder_factory_)
     return;
   decoder_factory_->DestroyVideoDecoder(decoder);
 }
 
 webrtc::VideoEncoder* WebRtcVideoEngine::CreateExternalEncoder(
     webrtc::VideoCodecType type) {
-  if (encoder_factory_ == NULL) {
+  if (!encoder_factory_) {
     return NULL;
   }
   return encoder_factory_->CreateVideoEncoder(type);
@@ -1496,7 +1500,7 @@
 
 void WebRtcVideoEngine::DestroyExternalEncoder(webrtc::VideoEncoder* encoder) {
   ASSERT(encoder_factory_ != NULL);
-  if (encoder_factory_ == NULL)
+  if (!encoder_factory_)
     return;
   encoder_factory_->DestroyVideoEncoder(encoder);
 }
@@ -1559,11 +1563,11 @@
     VoiceMediaChannel* channel)
     : engine_(engine),
       voice_channel_(channel),
-      vie_channel_(-1),
+      default_channel_id_(kChannelIdUnset),
       nack_enabled_(true),
       remb_enabled_(false),
       render_started_(false),
-      first_receive_ssrc_(0),
+      first_receive_ssrc_(kSsrcUnset),
       num_unsignalled_recv_channels_(0),
       send_rtx_type_(-1),
       send_red_type_(-1),
@@ -1576,7 +1580,7 @@
 
 bool WebRtcVideoMediaChannel::Init() {
   const uint32 ssrc_key = 0;
-  return CreateChannel(ssrc_key, MD_SENDRECV, &vie_channel_);
+  return CreateChannel(ssrc_key, MD_SENDRECV, &default_channel_id_);
 }
 
 WebRtcVideoMediaChannel::~WebRtcVideoMediaChannel() {
@@ -1758,7 +1762,7 @@
 
 bool WebRtcVideoMediaChannel::SetSendStreamFormat(uint32 ssrc,
                                                   const VideoFormat& format) {
-  WebRtcVideoChannelSendInfo* send_channel = GetSendChannel(ssrc);
+  WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrc(ssrc);
   if (!send_channel) {
     LOG(LS_ERROR) << "The specified ssrc " << ssrc << " is not in use.";
     return false;
@@ -1840,22 +1844,23 @@
   }
 
   uint32 ssrc_key;
-  if (!CreateSendChannelKey(sp.first_ssrc(), &ssrc_key)) {
+  if (!CreateSendChannelSsrcKey(sp.first_ssrc(), &ssrc_key)) {
     LOG(LS_ERROR) << "Trying to register duplicate ssrc: " << sp.first_ssrc();
     return false;
   }
   // If the default channel is already used for sending create a new channel
   // otherwise use the default channel for sending.
-  int channel_id = -1;
-  if (send_channels_[0]->stream_params() == NULL) {
-    channel_id = vie_channel_;
+  int channel_id = kChannelIdUnset;
+  if (!DefaultSendChannelInUse()) {
+    channel_id = default_channel_id_;
   } else {
     if (!CreateChannel(ssrc_key, MD_SEND, &channel_id)) {
       LOG(LS_ERROR) << "AddSendStream: unable to create channel";
       return false;
     }
   }
-  WebRtcVideoChannelSendInfo* send_channel = send_channels_[ssrc_key];
+
+  WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrcKey(ssrc_key);
   // Set the send (local) SSRC.
   // If there are multiple send SSRCs, we can only set the first one here, and
   // the rest of the SSRC(s) need to be set after SetSendCodec has been called
@@ -1882,7 +1887,7 @@
   // the default channel make sure that all the receive channels are updated as
   // well. Receive channels have to have the same SSRC as the default channel in
   // order to send receiver reports with this SSRC.
-  if (IsDefaultChannel(channel_id)) {
+  if (IsDefaultChannelId(channel_id)) {
     for (RecvChannelMap::const_iterator it = recv_channels_.begin();
          it != recv_channels_.end(); ++it) {
       WebRtcVideoChannelRecvInfo* info = it->second;
@@ -1918,14 +1923,14 @@
   }
 
   uint32 ssrc_key;
-  if (!GetSendChannelKey(ssrc, &ssrc_key)) {
+  if (!GetSendChannelSsrcKey(ssrc, &ssrc_key)) {
     LOG(LS_WARNING) << "Try to remove stream with ssrc " << ssrc
                     << " which doesn't exist.";
     return false;
   }
-  WebRtcVideoChannelSendInfo* send_channel = send_channels_[ssrc_key];
+  WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrcKey(ssrc_key);
   int channel_id = send_channel->channel_id();
-  if (IsDefaultChannel(channel_id) && (send_channel->stream_params() == NULL)) {
+  if (IsDefaultChannelId(channel_id) && !send_channel->stream_params()) {
     // Default channel will still exist. However, if stream_params() is NULL
     // there is no stream to remove.
     return false;
@@ -1947,8 +1952,8 @@
   send_channel->ClearRegisteredEncoders();
 
   // The receive channels depend on the default channel, recycle it instead.
-  if (IsDefaultChannel(channel_id)) {
-    SetCapturer(GetDefaultChannelSsrc(), NULL);
+  if (IsDefaultChannelId(channel_id)) {
+    SetCapturer(GetDefaultSendChannelSsrc(), NULL);
     send_channel->ClearStreamParams();
   } else {
     return DeleteSendChannel(ssrc_key);
@@ -1965,27 +1970,26 @@
   // TODO(zhurunz) Remove this once BWE works properly across different send
   // and receive channels.
   // Reuse default channel for recv stream in 1:1 call.
-  if (!InConferenceMode() && first_receive_ssrc_ == 0) {
+  if (!InConferenceMode() && first_receive_ssrc_ == kSsrcUnset) {
     LOG(LS_INFO) << "Recv stream " << sp.first_ssrc()
                  << " reuse default channel #"
-                 << vie_channel_;
+                 << default_channel_id_;
     first_receive_ssrc_ = sp.first_ssrc();
-    if (!MaybeSetRtxSsrc(sp, vie_channel_)) {
+    if (!MaybeSetRtxSsrc(sp, default_channel_id_)) {
       return false;
     }
     if (render_started_) {
-      if (engine()->vie()->render()->StartRender(vie_channel_) !=0) {
-        LOG_RTCERR1(StartRender, vie_channel_);
+      if (engine()->vie()->render()->StartRender(default_channel_id_) !=0) {
+        LOG_RTCERR1(StartRender, default_channel_id_);
       }
     }
     return true;
   }
 
-  int channel_id = -1;
-  RecvChannelMap::iterator channel_iterator =
-      recv_channels_.find(sp.first_ssrc());
-  if (channel_iterator == recv_channels_.end() &&
-      first_receive_ssrc_ != sp.first_ssrc()) {
+  int channel_id = kChannelIdUnset;
+  uint32 ssrc = sp.first_ssrc();
+  WebRtcVideoChannelRecvInfo* recv_channel = GetRecvChannelBySsrc(ssrc);
+  if (!recv_channel && first_receive_ssrc_ != ssrc) {
     // TODO(perkj): Implement recv media from multiple media SSRCs per stream.
     // NOTE: We have two SSRCs per stream when RTX is enabled.
     if (!IsOneSsrcStream(sp)) {
@@ -2003,13 +2007,12 @@
     }
   } else {
     // Already exists.
-    if (first_receive_ssrc_ == sp.first_ssrc()) {
+    if (first_receive_ssrc_ == ssrc) {
       return false;
     }
     // Early receive added channel.
-    channel_id = (*channel_iterator).second->channel_id();
+    channel_id = recv_channel->channel_id();
   }
-  channel_iterator = recv_channels_.find(sp.first_ssrc());
 
   if (!MaybeSetRtxSsrc(sp, channel_id)) {
     return false;
@@ -2018,13 +2021,13 @@
   // Get the default renderer.
   VideoRenderer* default_renderer = NULL;
   if (InConferenceMode()) {
-    // The recv_channels_ size start out being 1, so if it is two here this
-    // is the first receive channel created (vie_channel_ is not used for
-    // receiving in a conference call). This means that the renderer stored
-    // inside vie_channel_ should be used for the just created channel.
-    if (recv_channels_.size() == 2 &&
-        recv_channels_.find(0) != recv_channels_.end()) {
-      GetRenderer(0, &default_renderer);
+    // The recv_channels_ size start out being 1, so if it is two here
+    // this is the first receive channel created (default_channel_id_
+    // is not used for receiving in a conference call). This means
+    // that the renderer stored inside default_channel_id_ should be
+    // used for the just created channel.
+    if (recv_channels_.size() == 2 && GetDefaultRecvChannel()) {
+      GetDefaultRenderer(&default_renderer);
     }
   }
 
@@ -2036,8 +2039,8 @@
 
   LOG(LS_INFO) << "New video stream " << sp.first_ssrc()
                << " registered to VideoEngine channel #"
-               << channel_id << " and connected to channel #" << vie_channel_;
-
+               << channel_id << " and connected to channel #"
+               << default_channel_id_;
   return true;
 }
 
@@ -2068,26 +2071,25 @@
 }
 
 bool WebRtcVideoMediaChannel::RemoveRecvStreamInternal(uint32 ssrc) {
-  RecvChannelMap::iterator it = recv_channels_.find(ssrc);
-  if (it == recv_channels_.end()) {
+  WebRtcVideoChannelRecvInfo* recv_channel = GetRecvChannelBySsrc(ssrc);
+  if (!recv_channel) {
     // TODO(perkj): Remove this once BWE works properly across different send
     // and receive channels.
     // The default channel is reused for recv stream in 1:1 call.
     if (first_receive_ssrc_ == ssrc) {
-      first_receive_ssrc_ = 0;
+      first_receive_ssrc_ = kSsrcUnset;
       // Need to stop the renderer and remove it since the render window can be
       // deleted after this.
       if (render_started_) {
-        if (engine()->vie()->render()->StopRender(vie_channel_) !=0) {
-          LOG_RTCERR1(StopRender, it->second->channel_id());
+        if (engine()->vie()->render()->StopRender(default_channel_id_) !=0) {
+          LOG_RTCERR1(StopRender, recv_channel->channel_id());
         }
       }
-      recv_channels_[0]->SetRenderer(NULL);
+      GetDefaultRecvChannel()->SetRenderer(NULL);
       return true;
     }
     return false;
   }
-  WebRtcVideoChannelRecvInfo* info = it->second;
 
   // Remove any RTX SSRC mappings to this stream.
   SsrcMap::iterator rtx_it = rtx_to_primary_ssrc_.begin();
@@ -2099,7 +2101,7 @@
     }
   }
 
-  int channel_id = info->channel_id();
+  int channel_id = recv_channel->channel_id();
   if (engine()->vie()->render()->RemoveRenderer(channel_id) != 0) {
     LOG_RTCERR1(RemoveRenderer, channel_id);
   }
@@ -2114,7 +2116,7 @@
   }
 
   const WebRtcVideoChannelRecvInfo::DecoderMap& decoder_map =
-      info->registered_decoders();
+      recv_channel->registered_decoders();
   for (WebRtcVideoChannelRecvInfo::DecoderMap::const_iterator it =
        decoder_map.begin(); it != decoder_map.end(); ++it) {
     if (engine()->vie()->ext_codec()->DeRegisterExternalReceiveCodec(
@@ -2123,7 +2125,7 @@
     }
     engine()->DestroyExternalDecoder(it->second);
   }
-  info->ClearRegisteredDecoders();
+  recv_channel->ClearRegisteredDecoders();
 
   LOG(LS_INFO) << "Removing video stream " << ssrc
                << " with VideoEngine channel #"
@@ -2134,8 +2136,8 @@
     ret = false;
   }
   // Delete the WebRtcVideoChannelRecvInfo pointed to by it->second.
-  delete info;
-  recv_channels_.erase(it);
+  delete recv_channel;
+  recv_channels_.erase(ssrc);
   return ret;
 }
 
@@ -2203,67 +2205,86 @@
 
 bool WebRtcVideoMediaChannel::HasReadySendChannels() {
   return !send_channels_.empty() &&
-      ((send_channels_.size() > 1) ||
-       (send_channels_[0]->stream_params() != NULL));
+      ((send_channels_.size() > 1) || DefaultSendChannelInUse());
 }
 
-bool WebRtcVideoMediaChannel::GetSendChannelKey(uint32 local_ssrc,
-                                                uint32* key) {
-  *key = 0;
+bool WebRtcVideoMediaChannel::DefaultSendChannelInUse() {
+  return GetDefaultSendChannel() && GetDefaultSendChannel()->stream_params();
+}
+
+bool WebRtcVideoMediaChannel::GetSendChannelSsrcKey(uint32 local_ssrc,
+                                                    uint32* ssrc_key) {
+  *ssrc_key = kDefaultChannelSsrcKey;
   // If a send channel is not ready to send it will not have local_ssrc
   // registered to it.
   if (!HasReadySendChannels()) {
     return false;
   }
-  // The default channel is stored with key 0. The key therefore does not match
-  // the SSRC associated with the default channel. Check if the SSRC provided
-  // corresponds to the default channel's SSRC.
-  if (local_ssrc == GetDefaultChannelSsrc()) {
+  // The default channel is stored with ssrc key
+  // kDefaultChannelSsrcKey. The ssrc key therefore does not match the
+  // SSRC associated with the default channel. Check if the SSRC
+  // provided corresponds to the default channel's SSRC.
+  if (local_ssrc == GetDefaultSendChannelSsrc()) {
     return true;
   }
-  if (send_channels_.find(local_ssrc) == send_channels_.end()) {
+  if (!GetSendChannelBySsrcKey(local_ssrc)) {
     for (SendChannelMap::iterator iter = send_channels_.begin();
          iter != send_channels_.end(); ++iter) {
       WebRtcVideoChannelSendInfo* send_channel = iter->second;
       if (send_channel->has_ssrc(local_ssrc)) {
-        *key = iter->first;
+        *ssrc_key = iter->first;
         return true;
       }
     }
     return false;
   }
-  // The key was found in the above std::map::find call. This means that the
-  // ssrc is the key.
-  *key = local_ssrc;
+  // The ssrc key was found in the above std::map::find call. This
+  // means that the ssrc is the ssrc key.
+  *ssrc_key = local_ssrc;
   return true;
 }
 
-WebRtcVideoChannelSendInfo* WebRtcVideoMediaChannel::GetSendChannel(
-    uint32 local_ssrc) {
-  uint32 key;
-  if (!GetSendChannelKey(local_ssrc, &key)) {
-    return NULL;
-  }
-  return send_channels_[key];
+WebRtcVideoChannelSendInfo* WebRtcVideoMediaChannel::GetDefaultSendChannel() {
+  return GetSendChannelBySsrcKey(kDefaultChannelSsrcKey);
 }
 
-bool WebRtcVideoMediaChannel::CreateSendChannelKey(uint32 local_ssrc,
-                                                   uint32* key) {
-  if (GetSendChannelKey(local_ssrc, key)) {
-    // If there is a key corresponding to |local_ssrc|, the SSRC is already in
-    // use. SSRCs need to be unique in a session and at this point a duplicate
-    // SSRC has been detected.
+WebRtcVideoChannelSendInfo* WebRtcVideoMediaChannel::GetSendChannelBySsrcKey(
+    uint32 ssrc_key) {
+  std::map<uint32, WebRtcVideoChannelSendInfo *>::iterator iter =
+      send_channels_.find(ssrc_key);
+  if (iter == send_channels_.end()) {
+    return NULL;
+  }
+  return iter->second;
+}
+
+WebRtcVideoChannelSendInfo* WebRtcVideoMediaChannel::GetSendChannelBySsrc(
+    uint32 local_ssrc) {
+  uint32 ssrc_key;
+  if (!GetSendChannelSsrcKey(local_ssrc, &ssrc_key)) {
+    return NULL;
+  }
+  return send_channels_[ssrc_key];
+}
+
+bool WebRtcVideoMediaChannel::CreateSendChannelSsrcKey(uint32 local_ssrc,
+                                                       uint32* ssrc_key) {
+  if (GetSendChannelSsrcKey(local_ssrc, ssrc_key)) {
+    // If there is an ssrc key corresponding to |local_ssrc|, the SSRC
+    // is already in use. SSRCs need to be unique in a session and at
+    // this point a duplicate SSRC has been detected.
     return false;
   }
-  if (send_channels_[0]->stream_params() == NULL) {
-    // key should be 0 here as the default channel should be re-used whenever it
-    // is not used.
-    *key = 0;
+  if (!DefaultSendChannelInUse()) {
+    // |ssrc_key| should be kDefaultChannelSsrcKey here as the default
+    // channel should be re-used whenever it is not used.
+    *ssrc_key = kDefaultChannelSsrcKey;
     return true;
   }
-  // SSRC is currently not in use and the default channel is already in use. Use
-  // the SSRC as key since it is supposed to be unique in a session.
-  *key = local_ssrc;
+  // SSRC is currently not in use and the default channel is already
+  // in use. Use the SSRC as ssrc_key since it is supposed to be
+  // unique in a session.
+  *ssrc_key = local_ssrc;
   return true;
 }
 
@@ -2279,21 +2300,18 @@
   return num;
 }
 
-uint32 WebRtcVideoMediaChannel::GetDefaultChannelSsrc() {
-  WebRtcVideoChannelSendInfo* send_channel = send_channels_[0];
-  const StreamParams* sp = send_channel->stream_params();
-  if (sp == NULL) {
-    // This happens if no send stream is currently registered.
+uint32 WebRtcVideoMediaChannel::GetDefaultSendChannelSsrc() {
+  if (!DefaultSendChannelInUse()) {
     return 0;
   }
-  return sp->first_ssrc();
+  return GetDefaultSendChannel()->stream_params()->first_ssrc();
 }
 
 bool WebRtcVideoMediaChannel::DeleteSendChannel(uint32 ssrc_key) {
-  if (send_channels_.find(ssrc_key) == send_channels_.end()) {
+  WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrcKey(ssrc_key);
+  if (!send_channel) {
     return false;
   }
-  WebRtcVideoChannelSendInfo* send_channel = send_channels_[ssrc_key];
   MaybeDisconnectCapturer(send_channel->video_capturer());
   send_channel->set_video_capturer(NULL, engine()->vie());
 
@@ -2317,7 +2335,7 @@
   // The default channel is stored in both |send_channels_| and
   // |recv_channels_|. To make sure it is only deleted once from vie let the
   // delete call happen when tearing down |recv_channels_| and not here.
-  if (!IsDefaultChannel(channel_id)) {
+  if (!IsDefaultChannelId(channel_id)) {
     engine_->vie()->base()->DeleteChannel(channel_id);
   }
   delete send_channel;
@@ -2325,13 +2343,25 @@
   return true;
 }
 
+WebRtcVideoChannelRecvInfo* WebRtcVideoMediaChannel::GetDefaultRecvChannel() {
+  return GetRecvChannelBySsrc(kDefaultChannelSsrcKey);
+}
+
+WebRtcVideoChannelRecvInfo* WebRtcVideoMediaChannel::GetRecvChannelBySsrc(
+    uint32 ssrc) {
+  if (recv_channels_.find(ssrc) == recv_channels_.end()) {
+    return NULL;
+  }
+  return recv_channels_[ssrc];
+}
+
 bool WebRtcVideoMediaChannel::RemoveCapturer(uint32 ssrc) {
-  WebRtcVideoChannelSendInfo* send_channel = GetSendChannel(ssrc);
+  WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrc(ssrc);
   if (!send_channel) {
     return false;
   }
   VideoCapturer* capturer = send_channel->video_capturer();
-  if (capturer == NULL) {
+  if (!capturer) {
     return false;
   }
   MaybeDisconnectCapturer(capturer);
@@ -2345,22 +2375,22 @@
 
 bool WebRtcVideoMediaChannel::SetRenderer(uint32 ssrc,
                                           VideoRenderer* renderer) {
-  if (recv_channels_.find(ssrc) == recv_channels_.end()) {
+  WebRtcVideoChannelRecvInfo* recv_channel = GetRecvChannelBySsrc(ssrc);
+  if (!recv_channel) {
     // TODO(perkj): Remove this once BWE works properly across different send
     // and receive channels.
     // The default channel is reused for recv stream in 1:1 call.
-    if (first_receive_ssrc_ == ssrc &&
-        recv_channels_.find(0) != recv_channels_.end()) {
+    if (first_receive_ssrc_ == ssrc && GetDefaultRecvChannel()) {
       LOG(LS_INFO) << "SetRenderer " << ssrc
                    << " reuse default channel #"
-                   << vie_channel_;
-      recv_channels_[0]->SetRenderer(renderer);
+                   << default_channel_id_;
+      GetDefaultRecvChannel()->SetRenderer(renderer);
       return true;
     }
     return false;
   }
 
-  recv_channels_[ssrc]->SetRenderer(renderer);
+  recv_channel->SetRenderer(renderer);
   return true;
 }
 
@@ -2380,21 +2410,21 @@
       const int channel_id = send_channel->channel_id();
       VideoSenderInfo sinfo;
       const StreamParams* send_params = send_channel->stream_params();
-      if (send_params == NULL) {
+      if (!send_params) {
         // This should only happen if the default vie channel is not in use.
         // This can happen if no streams have ever been added or the stream
         // corresponding to the default channel has been removed. Note that
         // there may be non-default vie channels in use when this happen so
         // asserting send_channels_.size() == 1 is not correct and neither is
         // breaking out of the loop.
-        ASSERT(channel_id == vie_channel_);
+        ASSERT(channel_id == default_channel_id_);
         continue;
       }
       unsigned int bytes_sent, packets_sent, bytes_recv, packets_recv;
       if (engine_->vie()->rtp()->GetRTPStatistics(channel_id, bytes_sent,
                                                   packets_sent, bytes_recv,
                                                   packets_recv) != 0) {
-        LOG_RTCERR1(GetRTPStatistics, vie_channel_);
+        LOG_RTCERR1(GetRTPStatistics, default_channel_id_);
         continue;
       }
       WebRtcLocalStreamInfo* channel_stream_info =
@@ -2638,7 +2668,7 @@
     // Only call for the default channel because the returned stats are
     // collected for all the channels using the same estimator.
     if (engine_->vie()->rtp()->GetReceiveBandwidthEstimatorStats(
-        recv_channels_[0]->channel_id(), &additional_stats) == 0) {
+        GetDefaultRecvChannel()->channel_id(), &additional_stats) == 0) {
       bwe.total_received_propagation_delta_ms =
           additional_stats.total_propagation_time_delta_ms;
       bwe.recent_received_propagation_delta_ms.swap(
@@ -2649,7 +2679,7 @@
   }
 
   engine_->vie()->rtp()->GetPacerQueuingDelayMs(
-      recv_channels_[0]->channel_id(), &bwe.bucket_delay);
+      GetDefaultRecvChannel()->channel_id(), &bwe.bucket_delay);
 
   // Calculations done above per send/receive stream.
   bwe.actual_enc_bitrate = video_bitrate_sent;
@@ -2670,7 +2700,7 @@
   if (!capturer) {
     return RemoveCapturer(ssrc);
   }
-  WebRtcVideoChannelSendInfo* send_channel = GetSendChannel(ssrc);
+  WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrc(ssrc);
   if (!send_channel) {
     return false;
   }
@@ -2703,13 +2733,13 @@
   uint32 ssrc = 0;
   if (!GetRtpSsrc(packet->data(), packet->length(), &ssrc))
     return;
-  int processing_channel = GetRecvChannelNum(ssrc);
-  if (processing_channel == -1) {
+  int processing_channel_id = GetRecvChannelId(ssrc);
+  if (processing_channel_id == kChannelIdUnset) {
     // Allocate an unsignalled recv channel for processing in conference mode.
     if (!InConferenceMode()) {
       // If we can't find or allocate one, use the default.
-      processing_channel = video_channel();
-    } else if (!CreateUnsignalledRecvChannel(ssrc, &processing_channel)) {
+      processing_channel_id = default_channel_id_;
+    } else if (!CreateUnsignalledRecvChannel(ssrc, &processing_channel_id)) {
       // If we can't create an unsignalled recv channel, drop the packet in
       // conference mode.
       return;
@@ -2717,7 +2747,7 @@
   }
 
   engine()->vie()->network()->ReceivedRTPPacket(
-      processing_channel,
+      processing_channel_id,
       packet->data(),
       static_cast<int>(packet->length()),
       webrtc::PacketTime(packet_time.timestamp, packet_time.not_before));
@@ -2743,10 +2773,10 @@
 
   // If it is a sender report, find the channel that is listening.
   if (type == kRtcpTypeSR) {
-    int which_channel = GetRecvChannelNum(ssrc);
-    if (which_channel != -1 && !IsDefaultChannel(which_channel)) {
+    int recv_channel_id = GetRecvChannelId(ssrc);
+    if (recv_channel_id != kChannelIdUnset && !IsDefaultChannelId(recv_channel_id)) {
       engine_->vie()->network()->ReceivedRTCPPacket(
-          which_channel,
+          recv_channel_id,
           packet->data(),
           static_cast<int>(packet->length()));
     }
@@ -2770,7 +2800,7 @@
 }
 
 bool WebRtcVideoMediaChannel::MuteStream(uint32 ssrc, bool muted) {
-  WebRtcVideoChannelSendInfo* send_channel = GetSendChannel(ssrc);
+  WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrc(ssrc);
   if (!send_channel) {
     LOG(LS_ERROR) << "The specified ssrc " << ssrc << " is not in use.";
     return false;
@@ -3110,30 +3140,33 @@
 
 bool WebRtcVideoMediaChannel::GetRenderer(uint32 ssrc,
                                           VideoRenderer** renderer) {
-  RecvChannelMap::const_iterator it = recv_channels_.find(ssrc);
-  if (it == recv_channels_.end()) {
-    if (first_receive_ssrc_ == ssrc &&
-        recv_channels_.find(0) != recv_channels_.end()) {
+  WebRtcVideoChannelRecvInfo* recv_channel = GetRecvChannelBySsrc(ssrc);
+  if (!recv_channel) {
+    if (first_receive_ssrc_ == ssrc && GetDefaultRecvChannel()) {
       LOG(LS_INFO) << " GetRenderer " << ssrc
                    << " reuse default renderer #"
-                   << vie_channel_;
-      *renderer = recv_channels_[0]->render_adapter()->renderer();
+                   << default_channel_id_;
+      *renderer = GetDefaultRecvChannel()->render_adapter()->renderer();
       return true;
     }
     return false;
   }
 
-  *renderer = it->second->render_adapter()->renderer();
+  *renderer = recv_channel->render_adapter()->renderer();
   return true;
 }
 
+bool WebRtcVideoMediaChannel::GetDefaultRenderer(VideoRenderer** renderer) {
+  return GetRenderer(kDefaultChannelSsrcKey, renderer);
+}
+
 bool WebRtcVideoMediaChannel::GetVideoAdapter(
     uint32 ssrc, CoordinatedVideoAdapter** video_adapter) {
-  SendChannelMap::iterator it = send_channels_.find(ssrc);
-  if (it == send_channels_.end()) {
+  WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrc(ssrc);
+  if (!send_channel) {
     return false;
   }
-  *video_adapter = it->second->video_adapter();
+  *video_adapter = send_channel->video_adapter();
   return true;
 }
 
@@ -3159,7 +3192,7 @@
   for (SendChannelMap::iterator iter = send_channels_.begin();
        iter != send_channels_.end(); ++iter) {
     WebRtcVideoChannelSendInfo* send_channel = iter->second;
-    if (send_channel->video_capturer() == NULL) {
+    if (!send_channel->video_capturer()) {
       SendFrame(send_channel, frame, capturer->IsScreencast());
     }
   }
@@ -3244,32 +3277,33 @@
                                             int* channel_id) {
   // There are 3 types of channels. Sending only, receiving only and
   // sending and receiving. The sending and receiving channel is the
-  // default channel and there is only one. All other channels that are created
-  // are associated with the default channel which must exist. The default
-  // channel id is stored in |vie_channel_|. All channels need to know about
-  // the default channel to properly handle remb which is why there are
-  // different ViE create channel calls.
-  // For this channel the local and remote ssrc key is 0. However, it may
-  // have a non-zero local and/or remote ssrc depending on if it is currently
-  // sending and/or receiving.
-  if ((vie_channel_ == -1 || direction == MD_SENDRECV) &&
+  // default channel and there is only one. All other channels that
+  // are created are associated with the default channel which must
+  // exist. The default channel id is stored in
+  // |default_channel_id_|. All channels need to know about the
+  // default channel to properly handle remb which is why there are
+  // different ViE create channel calls.  For this channel the local
+  // and remote ssrc_key is kDefaultChannelSsrcKey. However, it may
+  // have a non-zero local and/or remote ssrc depending on if it is
+  // currently sending and/or receiving.
+  if ((default_channel_id_ == kChannelIdUnset || direction == MD_SENDRECV) &&
       (!send_channels_.empty() || !recv_channels_.empty())) {
     ASSERT(false);
     return false;
   }
 
-  *channel_id = -1;
+  *channel_id = kChannelIdUnset;
   if (direction == MD_RECV) {
-    // All rec channels are associated with the default channel |vie_channel_|
+    // All rec channels are associated with default_channel_id_.
     if (engine_->vie()->base()->CreateReceiveChannel(*channel_id,
-                                                     vie_channel_) != 0) {
-      LOG_RTCERR2(CreateReceiveChannel, *channel_id, vie_channel_);
+                                                     default_channel_id_) != 0) {
+      LOG_RTCERR2(CreateReceiveChannel, *channel_id, default_channel_id_);
       return false;
     }
   } else if (direction == MD_SEND) {
     if (engine_->vie()->base()->CreateChannel(*channel_id,
-                                              vie_channel_) != 0) {
-      LOG_RTCERR2(CreateChannel, *channel_id, vie_channel_);
+                                              default_channel_id_) != 0) {
+      LOG_RTCERR2(CreateChannel, *channel_id, default_channel_id_);
       return false;
     }
   } else {
@@ -3281,7 +3315,7 @@
   }
   if (!ConfigureChannel(*channel_id, direction, ssrc_key)) {
     engine_->vie()->base()->DeleteChannel(*channel_id);
-    *channel_id = -1;
+    *channel_id = kChannelIdUnset;
     return false;
   }
 
@@ -3363,9 +3397,9 @@
 }
 
 bool WebRtcVideoMediaChannel::ConfigureReceiving(int channel_id,
-                                                 uint32 remote_ssrc_key) {
-  // Make sure that an SSRC/key isn't registered more than once.
-  if (recv_channels_.find(remote_ssrc_key) != recv_channels_.end()) {
+                                                 uint32 remote_ssrc) {
+  // Make sure that an SSRC isn't registered more than once.
+  if (GetRecvChannelBySsrc(remote_ssrc)) {
     return false;
   }
   // Connect the voice channel, if there is one.
@@ -3373,11 +3407,11 @@
   // know the SSRC of the remote audio channel in order to fetch the correct
   // webrtc VoiceEngine channel. For now- only sync the default channel used
   // in 1-1 calls.
-  if (remote_ssrc_key == 0 && voice_channel_) {
+  if (remote_ssrc == kDefaultChannelSsrcKey && voice_channel_) {
     WebRtcVoiceMediaChannel* voice_channel =
         static_cast<WebRtcVoiceMediaChannel*>(voice_channel_);
     if (engine_->vie()->base()->ConnectAudioChannel(
-        vie_channel_, voice_channel->voe_channel()) != 0) {
+        default_channel_id_, voice_channel->voe_channel()) != 0) {
       LOG_RTCERR2(ConnectAudioChannel, channel_id,
                   voice_channel->voe_channel());
       LOG(LS_WARNING) << "A/V not synchronized";
@@ -3414,13 +3448,13 @@
     return false;
   }
 
-  if (remote_ssrc_key != 0) {
+  if (remote_ssrc != kDefaultChannelSsrcKey) {
     // Use the same SSRC as our default channel
     // (so the RTCP reports are correct).
     unsigned int send_ssrc = 0;
     webrtc::ViERTP_RTCP* rtp = engine()->vie()->rtp();
-    if (rtp->GetLocalSSRC(vie_channel_, send_ssrc) == -1) {
-      LOG_RTCERR2(GetLocalSSRC, vie_channel_, send_ssrc);
+    if (rtp->GetLocalSSRC(default_channel_id_, send_ssrc) == -1) {
+      LOG_RTCERR2(GetLocalSSRC, default_channel_id_, send_ssrc);
       return false;
     }
     if (rtp->SetLocalSSRC(channel_id, send_ssrc) == -1) {
@@ -3464,7 +3498,7 @@
     return false;
   }
 
-  recv_channels_[remote_ssrc_key] = channel_info.release();
+  recv_channels_[remote_ssrc] = channel_info.release();
   return true;
 }
 
@@ -3472,12 +3506,12 @@
                                                uint32 local_ssrc_key) {
   // The ssrc key can be zero or correspond to an SSRC.
   // Make sure the default channel isn't configured more than once.
-  if (local_ssrc_key == 0 && send_channels_.find(0) != send_channels_.end()) {
+  if (local_ssrc_key == kDefaultChannelSsrcKey && GetDefaultSendChannel()) {
     return false;
   }
   // Make sure that the SSRC is not already in use.
   uint32 dummy_key;
-  if (GetSendChannelKey(local_ssrc_key, &dummy_key)) {
+  if (GetSendChannelSsrcKey(local_ssrc_key, &dummy_key)) {
     return false;
   }
   int vie_capture = 0;
@@ -3731,8 +3765,8 @@
 
 void WebRtcVideoMediaChannel::LogSendCodecChange(const std::string& reason) {
   webrtc::VideoCodec vie_codec;
-  if (engine()->vie()->codec()->GetSendCodec(vie_channel_, vie_codec) != 0) {
-    LOG_RTCERR1(GetSendCodec, vie_channel_);
+  if (engine()->vie()->codec()->GetSendCodec(default_channel_id_, vie_codec) != 0) {
+    LOG_RTCERR1(GetSendCodec, default_channel_id_);
     return;
   }
 
@@ -3846,28 +3880,28 @@
   return true;
 }
 
-int WebRtcVideoMediaChannel::GetRecvChannelNum(uint32 ssrc) {
+int WebRtcVideoMediaChannel::GetRecvChannelId(uint32 ssrc) {
   if (ssrc == first_receive_ssrc_) {
-    return vie_channel_;
+    return default_channel_id_;
   }
-  int recv_channel = -1;
-  RecvChannelMap::iterator it = recv_channels_.find(ssrc);
-  if (it == recv_channels_.end()) {
+  int recv_channel_id = kChannelIdUnset;
+  WebRtcVideoChannelRecvInfo* recv_channel = GetRecvChannelBySsrc(ssrc);
+  if (!recv_channel) {
     // Check if we have an RTX stream registered on this SSRC.
     SsrcMap::iterator rtx_it = rtx_to_primary_ssrc_.find(ssrc);
     if (rtx_it != rtx_to_primary_ssrc_.end()) {
       if (rtx_it->second == first_receive_ssrc_) {
-        recv_channel = vie_channel_;
+        recv_channel_id = default_channel_id_;
       } else {
-        it = recv_channels_.find(rtx_it->second);
-        assert(it != recv_channels_.end());
-        recv_channel = it->second->channel_id();
+        recv_channel = GetRecvChannelBySsrc(rtx_it->second);
+        ASSERT(recv_channel != NULL);
+        recv_channel_id = recv_channel->channel_id();
       }
     }
   } else {
-    recv_channel = it->second->channel_id();
+    recv_channel_id = recv_channel->channel_id();
   }
-  return recv_channel;
+  return recv_channel_id;
 }
 
 // If the new frame size is different from the send codec size we set on vie,
@@ -4057,7 +4091,7 @@
 }
 
 void WebRtcVideoMediaChannel::FlushBlackFrame(uint32 ssrc, int64 timestamp) {
-  WebRtcVideoChannelSendInfo* send_channel = GetSendChannel(ssrc);
+  WebRtcVideoChannelSendInfo* send_channel = GetSendChannelBySsrc(ssrc);
   if (!send_channel) {
     return;
   }
@@ -4145,14 +4179,14 @@
 }
 
 void WebRtcVideoMediaChannel::MaybeConnectCapturer(VideoCapturer* capturer) {
-  if (capturer != NULL && GetSendChannelNum(capturer) == 1) {
+  if (capturer && GetSendChannelNum(capturer) == 1) {
     capturer->SignalVideoFrame.connect(this,
                                        &WebRtcVideoMediaChannel::SendFrame);
   }
 }
 
 void WebRtcVideoMediaChannel::MaybeDisconnectCapturer(VideoCapturer* capturer) {
-  if (capturer != NULL && GetSendChannelNum(capturer) == 1) {
+  if (capturer && GetSendChannelNum(capturer) == 1) {
     capturer->SignalVideoFrame.disconnect(this);
   }
 }
diff --git a/talk/media/webrtc/webrtcvideoengine.h b/talk/media/webrtc/webrtcvideoengine.h
index f467b97..90f8d0c 100644
--- a/talk/media/webrtc/webrtcvideoengine.h
+++ b/talk/media/webrtc/webrtcvideoengine.h
@@ -243,11 +243,11 @@
 
   WebRtcVideoEngine* engine() { return engine_; }
   VoiceMediaChannel* voice_channel() { return voice_channel_; }
-  int video_channel() const { return vie_channel_; }
   bool sending() const { return sending_; }
 
   // Public for testing purpose.
-  uint32 GetDefaultChannelSsrc();
+  uint32 GetDefaultSendChannelSsrc();
+  int GetDefaultChannelId() const { return default_channel_id_; }
 
   // VideoMediaChannel implementation
   virtual bool SetRecvCodecs(const std::vector<VideoCodec> &codecs);
@@ -318,14 +318,15 @@
 
   enum MediaDirection { MD_RECV, MD_SEND, MD_SENDRECV };
 
-  // Creates and initializes a ViE channel. When successful |channel_id| will
-  // contain the new channel's ID. If |receiving| is true |ssrc| is the
-  // remote ssrc. If |sending| is true the ssrc is local ssrc. If both
-  // |receiving| and |sending| is true the ssrc must be 0 and the channel will
-  // be created as a default channel. The ssrc must be different for receive
-  // channels and it must be different for send channels. If the same SSRC is
-  // being used for creating channel more than once, this function will fail
-  // returning false.
+  // Creates and initializes a ViE channel. When successful
+  // |channel_id| will contain the new channel's ID. If |receiving| is
+  // true |ssrc| is the remote ssrc. If |sending| is true the ssrc is
+  // local ssrc. If both |receiving| and |sending| is true the ssrc
+  // must be kDefaultChannelSsrcKey and the channel will be created as
+  // a default channel. The ssrc must be different for receive
+  // channels and it must be different for send channels. If the same
+  // SSRC is being used for creating channel more than once, this
+  // function will fail returning false.
   bool CreateChannel(uint32 ssrc_key, MediaDirection direction,
                      int* channel_id);
   bool CreateUnsignalledRecvChannel(uint32 ssrc_key, int* channel_id);
@@ -342,8 +343,8 @@
   // Prepares the channel with channel id |info->channel_id()| to receive all
   // codecs in |receive_codecs_| and start receive packets.
   bool SetReceiveCodecs(WebRtcVideoChannelRecvInfo* info);
-  // Returns the channel number that receives the stream with SSRC |ssrc|.
-  int GetRecvChannelNum(uint32 ssrc);
+  // Returns the channel ID that receives the stream with SSRC |ssrc|.
+  int GetRecvChannelId(uint32 ssrc);
   bool MaybeSetRtxSsrc(const StreamParams& sp, int channel_id);
   // Given captured video frame size, checks if we need to reset vie send codec.
   // |reset| is set to whether resetting has happened on vie or not.
@@ -365,25 +366,34 @@
   bool SendIntraFrame(int channel_id);
 
   bool HasReadySendChannels();
+  bool DefaultSendChannelInUse();
 
-  // Send channel key returns the key corresponding to the provided local SSRC
-  // in |key|. The return value is true upon success.
-  // If the local ssrc correspond to that of the default channel the key is 0.
-  // For all other channels the returned key will be the same as the local ssrc.
-  bool GetSendChannelKey(uint32 local_ssrc, uint32* key);
-  WebRtcVideoChannelSendInfo* GetSendChannel(uint32 local_ssrc);
-  // Creates a new unique key that can be used for inserting a new send channel
-  // into |send_channels_|
-  bool CreateSendChannelKey(uint32 local_ssrc, uint32* key);
+  // Returns the ssrc key corresponding to the provided local SSRC in
+  // |ssrc_key|. The return value is true upon success.  If the local
+  // ssrc correspond to that of the default channel the key is
+  // kDefaultChannelSsrcKey.
+  // For all other channels the returned ssrc key will be the same as
+  // the local ssrc.
+  bool GetSendChannelSsrcKey(uint32 local_ssrc, uint32* ssrc_key);
+  WebRtcVideoChannelSendInfo* GetDefaultSendChannel();
+  WebRtcVideoChannelSendInfo* GetSendChannelBySsrcKey(uint32 ssrc_key);
+  WebRtcVideoChannelSendInfo* GetSendChannelBySsrc(uint32 local_ssrc);
+  // Creates a new unique ssrc key that can be used for inserting a
+  // new send channel into |send_channels_|
+  bool CreateSendChannelSsrcKey(uint32 local_ssrc, uint32* ssrc_key);
   // Get the number of the send channels |capturer| registered with.
   int GetSendChannelNum(VideoCapturer* capturer);
 
-  bool IsDefaultChannel(int channel_id) const {
-    return channel_id == vie_channel_;
+  bool IsDefaultChannelId(int channel_id) const {
+    return channel_id == default_channel_id_;
   }
+  bool GetDefaultRenderer(VideoRenderer** renderer);
 
   bool DeleteSendChannel(uint32 ssrc_key);
 
+  WebRtcVideoChannelRecvInfo* GetDefaultRecvChannel();
+  WebRtcVideoChannelRecvInfo* GetRecvChannelBySsrc(uint32 ssrc);
+
   bool InConferenceMode() const {
     return options_.conference_mode.GetWithDefaultIfUnset(false);
   }
@@ -420,17 +430,17 @@
   // Global state.
   WebRtcVideoEngine* engine_;
   VoiceMediaChannel* voice_channel_;
-  int vie_channel_;
+  int default_channel_id_;
   bool nack_enabled_;
   // Receiver Estimated Max Bitrate
   bool remb_enabled_;
   VideoOptions options_;
 
   // Global recv side state.
-  // Note the default channel (vie_channel_), i.e. the send channel
+  // Note the default channel (default_channel_id_), i.e. the send channel
   // corresponding to all the receive channels (this must be done for REMB to
   // work properly), resides in both recv_channels_ and send_channels_ with the
-  // ssrc key 0.
+  // ssrc key kDefaultChannelSsrcKey.
   RecvChannelMap recv_channels_;  // Contains all receive channels.
   // A map from the SSRCs on which RTX packets are received to the media SSRCs
   // the RTX packets are associated with. RTX packets will be delivered to the