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

talk/session/media/channel.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 58 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:
-  BaseChannel(rtc::Thread* thread, MediaEngineInterface* media_engine,
-              MediaChannel* channel, BaseSession* session,
+  BaseChannel(rtc::Thread* thread, MediaChannel* channel, BaseSession* session,
               const std::string& content_name, bool rtcp);
   virtual ~BaseChannel();
   bool Init();
   // Deinit may be called multiple times and is simply ignored if it's alreay
   // done.
   void Deinit();
 
   rtc::Thread* worker_thread() const { return worker_thread_; }
   BaseSession* session() const { return session_; }
   const std::string& content_name() { return content_name_; }
@@ skipping 76 matching lines @@
   // Used to alert UI when the muted status changes, perhaps autonomously.
   sigslot::repeater2<BaseChannel*, bool> SignalAutoMuted;
 
   // Made public for easier testing.
   void SetReadyToSend(TransportChannel* channel, bool ready);
 
   // Only public for unit tests.  Otherwise, consider protected.
   virtual int SetOption(SocketType type, rtc::Socket::Option o, int val);
 
  protected:
-  MediaEngineInterface* media_engine() const { return media_engine_; }
   virtual MediaChannel* media_channel() const { return media_channel_; }
   // Sets the transport_channel_ and rtcp_transport_channel_.  If
   // |rtcp| is false, set rtcp_transport_channel_ is set to NULL.  Get
   // the transport channels from |session|.
   // TODO(pthatcher): Pass in a Transport instead of a BaseSession.
   bool SetTransportChannels(BaseSession* session, bool rtcp);
   bool SetTransportChannels_w(BaseSession* session, bool rtcp);
   void set_transport_channel(TransportChannel* transport);
   void set_rtcp_transport_channel(TransportChannel* transport);
   bool was_ever_writable() const { return was_ever_writable_; }
@@ skipping 117 matching lines @@
       const std::vector<ConnectionInfo>& infos) = 0;
 
   // Helper function for invoking bool-returning methods on the worker thread.
   template <class FunctorT>
   bool InvokeOnWorker(const FunctorT& functor) {
     return worker_thread_->Invoke<bool>(functor);
   }
 
  private:
   rtc::Thread* worker_thread_;
-  MediaEngineInterface* media_engine_;
   BaseSession* session_;
   MediaChannel* media_channel_;
   std::vector<StreamParams> local_streams_;
   std::vector<StreamParams> remote_streams_;
 
   const std::string content_name_;
   bool rtcp_;
   TransportChannel* transport_channel_;
   TransportChannel* rtcp_transport_channel_;
   SrtpFilter srtp_filter_;
@@ skipping 111 matching lines @@
   virtual void OnConnectionMonitorUpdate(
       ConnectionMonitor* monitor, const std::vector<ConnectionInfo>& infos);
   virtual void OnMediaMonitorUpdate(
       VoiceMediaChannel* media_channel, const VoiceMediaInfo& info);
   void OnAudioMonitorUpdate(AudioMonitor* monitor, const AudioInfo& info);
   void OnVoiceChannelError(uint32 ssrc, VoiceMediaChannel::Error error);
   void SendLastMediaError();
   void OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode, SrtpFilter::Error error);
 
   static const int kEarlyMediaTimeout = 1000;
+  MediaEngineInterface* media_engine_;
   bool received_media_;
   rtc::scoped_ptr<VoiceMediaMonitor> media_monitor_;
   rtc::scoped_ptr<AudioMonitor> audio_monitor_;
   rtc::scoped_ptr<TypingMonitor> typing_monitor_;
 };
 
 // VideoChannel is a specialization for video.
 class VideoChannel : public BaseChannel {
  public:
-  VideoChannel(rtc::Thread* thread, MediaEngineInterface* media_engine,
-               VideoMediaChannel* channel, BaseSession* session,
-               const std::string& content_name, bool rtcp);
+  VideoChannel(rtc::Thread* thread, VideoMediaChannel* channel,
+               BaseSession* session, const std::string& content_name,
+               bool rtcp);
   ~VideoChannel();
   bool Init();
 
   // downcasts a MediaChannel
   virtual VideoMediaChannel* media_channel() const {
     return static_cast<VideoMediaChannel*>(BaseChannel::media_channel());
   }
 
   bool SetRenderer(uint32 ssrc, VideoRenderer* renderer);
   bool ApplyViewRequest(const ViewRequest& request);
@@ skipping 185 matching lines @@
   rtc::scoped_ptr<DataMediaMonitor> media_monitor_;
   // TODO(pthatcher): Make a separate SctpDataChannel and
   // RtpDataChannel instead of using this.
   DataChannelType data_channel_type_;
   bool ready_to_send_data_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_SESSION_MEDIA_CHANNEL_H_