Get rid of media_engine_ from BaseChannel; only VoiceChannel needs it.

talk/session/media/channel.cc

 /*
  * 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 133 matching lines @@
 }
 
 static const MediaContentDescription* GetContentDescription(
     const ContentInfo* cinfo) {
   if (cinfo == NULL)
     return NULL;
   return static_cast<const MediaContentDescription*>(cinfo->description);
 }
 
 BaseChannel::BaseChannel(rtc::Thread* thread,
-                         MediaEngineInterface* media_engine,
                          MediaChannel* media_channel, BaseSession* session,
                          const std::string& content_name, bool rtcp)
     : worker_thread_(thread),
-      media_engine_(media_engine),
       session_(session),
       media_channel_(media_channel),
       content_name_(content_name),
       rtcp_(rtcp),
       transport_channel_(NULL),
       rtcp_transport_channel_(NULL),
       enabled_(false),
       writable_(false),
       rtp_ready_to_send_(false),
       rtcp_ready_to_send_(false),
@@ skipping 1119 matching lines @@
     worker_thread_->Send(this, MSG_RTCPPACKET, it->pdata);
   }
 }
 
 VoiceChannel::VoiceChannel(rtc::Thread* thread,
                            MediaEngineInterface* media_engine,
                            VoiceMediaChannel* media_channel,
                            BaseSession* session,
                            const std::string& content_name,
                            bool rtcp)
-    : BaseChannel(thread, media_engine, media_channel, session, content_name,
+    : BaseChannel(thread, media_channel, session, content_name,
                   rtcp),
+      media_engine_(media_engine),
       received_media_(false) {
 }
 
 VoiceChannel::~VoiceChannel() {
   StopAudioMonitor();
   StopMediaMonitor();
   // this can't be done in the base class, since it calls a virtual
   DisableMedia_w();
   Deinit();
 }
@@ skipping 122 matching lines @@
 }
 
 bool VoiceChannel::MuteStream_w(uint32 ssrc, bool mute) {
   bool ret = BaseChannel::MuteStream_w(ssrc, mute);
   if (typing_monitor_ && mute)
     typing_monitor_->OnChannelMuted();
   return ret;
 }
 
 int VoiceChannel::GetInputLevel_w() {
-  return media_engine()->GetInputLevel();
+  return media_engine_->GetInputLevel();
 }
 
 int VoiceChannel::GetOutputLevel_w() {
   return media_channel()->GetOutputLevel();
 }
 
 void VoiceChannel::GetActiveStreams_w(AudioInfo::StreamList* actives) {
   media_channel()->GetActiveStreams(actives);
 }
 
@@ skipping 225 matching lines @@
     default:
       break;
   }
 }
 
 void VoiceChannel::GetSrtpCiphers(std::vector<std::string>* ciphers) const {
   GetSupportedAudioCryptoSuites(ciphers);
 }
 
 VideoChannel::VideoChannel(rtc::Thread* thread,
-                           MediaEngineInterface* media_engine,
                            VideoMediaChannel* media_channel,
                            BaseSession* session,
                            const std::string& content_name,
                            bool rtcp)
-    : BaseChannel(thread, media_engine, media_channel, session, content_name,
+    : BaseChannel(thread, media_channel, session, content_name,
                   rtcp),
       renderer_(NULL),
       previous_we_(rtc::WE_CLOSE) {
 }
 
 bool VideoChannel::Init() {
   if (!BaseChannel::Init()) {
     return false;
   }
   media_channel()->SignalMediaError.connect(
@@ skipping 417 matching lines @@
 
 void VideoChannel::GetSrtpCiphers(std::vector<std::string>* ciphers) const {
   GetSupportedVideoCryptoSuites(ciphers);
 }
 
 DataChannel::DataChannel(rtc::Thread* thread,
                          DataMediaChannel* media_channel,
                          BaseSession* session,
                          const std::string& content_name,
                          bool rtcp)
-    // MediaEngine is NULL
-    : BaseChannel(thread, NULL, media_channel, session, content_name, rtcp),
+    : BaseChannel(thread, media_channel, session, content_name, rtcp),
       data_channel_type_(cricket::DCT_NONE),
       ready_to_send_data_(false) {
 }
 
 DataChannel::~DataChannel() {
   StopMediaMonitor();
   // this can't be done in the base class, since it calls a virtual
   DisableMedia_w();
 
   Deinit();
@@ skipping 333 matching lines @@
   return (data_channel_type_ == DCT_RTP);
 }
 
 void DataChannel::OnStreamClosedRemotely(uint32 sid) {
   rtc::TypedMessageData<uint32>* message =
       new rtc::TypedMessageData<uint32>(sid);
   signaling_thread()->Post(this, MSG_STREAMCLOSEDREMOTELY, message);
 }
 
 }  // namespace cricket