diff --git a/third_party_mods/libjingle/libjingle.gyp b/third_party_mods/libjingle/libjingle.gyp
index c1516e9fde..a1f3010931 100644
--- a/third_party_mods/libjingle/libjingle.gyp
+++ b/third_party_mods/libjingle/libjingle.gyp
@@ -706,6 +706,7 @@
             '<(libjingle_mods)/source/talk/app/webrtc_dev/mediastreamtrackproxy.cc',
             '<(libjingle_mods)/source/talk/app/webrtc_dev/mediastreamproxy.h',
             '<(libjingle_mods)/source/talk/app/webrtc_dev/mediastreamproxy.cc',            
+            '<(libjingle_mods)/source/talk/app/webrtc_dev/mediatrackimpl.h',
             '<(libjingle_mods)/source/talk/app/webrtc_dev/peerconnection.h',
             '<(libjingle_mods)/source/talk/app/webrtc_dev/peerconnectionimpl.cc',
             '<(libjingle_mods)/source/talk/app/webrtc_dev/peerconnectionimpl.h',
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/audiotrackimpl.cc b/third_party_mods/libjingle/source/talk/app/webrtc_dev/audiotrackimpl.cc
index a611402faa..f9eca6d07d 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/audiotrackimpl.cc
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/audiotrackimpl.cc
@@ -33,19 +33,13 @@ namespace webrtc {
 static const char kAudioTrackKind[] = "audio";
 
 AudioTrack::AudioTrack(const std::string& label, uint32 ssrc)
-    : enabled_(true),
-      label_(label),
-      ssrc_(ssrc),
-      state_(kInitializing),
+    : MediaTrack<LocalAudioTrackInterface>(label, ssrc),
       audio_device_(NULL) {
 }
 
 AudioTrack::AudioTrack(const std::string& label,
                        AudioDeviceModule* audio_device)
-    : enabled_(true),
-      label_(label),
-      ssrc_(0),
-      state_(kInitializing),
+    : MediaTrack<LocalAudioTrackInterface>(label, 0),
       audio_device_(audio_device) {
 }
 
@@ -59,31 +53,6 @@ const char* AudioTrack::kind() const {
   return kAudioTrackKind;
 }
 
-bool AudioTrack::set_enabled(bool enable) {
-  bool fire_on_change = (enable != enabled_);
-  enabled_ = enable;
-  if (fire_on_change)
-    NotifierImpl<LocalAudioTrackInterface>::FireOnChanged();
-}
-
-bool AudioTrack::set_ssrc(uint32 ssrc) {
-  ASSERT(ssrc_ == 0);
-  ASSERT(ssrc != 0);
-  if (ssrc_ != 0)
-    return false;
-  ssrc_ = ssrc;
-  NotifierImpl<LocalAudioTrackInterface>::FireOnChanged();
-  return true;
-}
-
-bool AudioTrack::set_state(TrackState new_state) {
-  bool fire_on_change = (state_ != new_state);
-  state_ = new_state;
-  if (fire_on_change)
-    NotifierImpl<LocalAudioTrackInterface>::FireOnChanged();
-  return true;
-}
-
 scoped_refptr<AudioTrack> AudioTrack::CreateRemote(const std::string& label,
                                                    uint32 ssrc) {
   talk_base::RefCountImpl<AudioTrack>* track =
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/audiotrackimpl.h b/third_party_mods/libjingle/source/talk/app/webrtc_dev/audiotrackimpl.h
index 3426e87bcb..4e80bfad25 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/audiotrackimpl.h
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/audiotrackimpl.h
@@ -28,11 +28,11 @@
 #ifndef TALK_APP_WEBRTC_AUDIOTRACKIMPL_H_
 #define TALK_APP_WEBRTC_AUDIOTRACKIMPL_H_
 
-#include <string>
-
+#include "talk/app/webrtc_dev/mediastream.h"
+#include "talk/app/webrtc_dev/mediatrackimpl.h"
 #include "talk/app/webrtc_dev/notifierimpl.h"
 #include "talk/app/webrtc_dev/scoped_refptr.h"
-#include "talk/app/webrtc_dev/mediastream.h"
+
 #ifdef WEBRTC_RELATIVE_PATH
 #include "modules/audio_device/main/interface/audio_device.h"
 #else
@@ -41,7 +41,7 @@
 
 namespace webrtc {
 
-class AudioTrack : public NotifierImpl<LocalAudioTrackInterface> {
+class AudioTrack : public MediaTrack<LocalAudioTrackInterface> {
  public:
   // Creates a remote audio track.
   static scoped_refptr<AudioTrack> CreateRemote(const std::string& label,
@@ -55,24 +55,12 @@ class AudioTrack : public NotifierImpl<LocalAudioTrackInterface> {
 
   // Implement MediaStreamTrack
   virtual const char* kind() const;
-  virtual std::string label() const { return label_; }
-  virtual TrackType type() const { return kAudio; }
-  virtual uint32 ssrc() const { return ssrc_; }
-  virtual TrackState state() const { return state_; }
-  virtual bool enabled() const { return enabled_; }
-  virtual bool set_enabled(bool enable);
-  virtual bool set_ssrc(uint32 ssrc);
-  virtual bool set_state(TrackState new_state);
 
  protected:
   AudioTrack(const std::string& label, uint32 ssrc);
   AudioTrack(const std::string& label, AudioDeviceModule* audio_device);
 
  private:
-  bool enabled_;
-  std::string label_;
-  uint32 ssrc_;
-  TrackState state_;
   scoped_refptr<AudioDeviceModule> audio_device_;
 };
 
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastream.h b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastream.h
index 68fb3808d2..22e78365e3 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastream.h
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastream.h
@@ -70,14 +70,8 @@ class MediaStreamTrackInterface : public talk_base::RefCount,
     kFailed = 3,  // Track negotiation failed.
   };
 
-  enum TrackType {
-    kAudio = 0,
-    kVideo = 1,
-  };
-
   virtual const char* kind() const = 0;
-  virtual std::string label()  const = 0;
-  virtual TrackType type() const = 0;
+  virtual std::string label() const = 0;
   virtual uint32 ssrc() const = 0;
   virtual bool enabled() const = 0;
   virtual TrackState state() const = 0;
@@ -88,27 +82,28 @@ class MediaStreamTrackInterface : public talk_base::RefCount,
 };
 
 // Reference counted wrapper for a VideoRenderer.
-class VideoRendererInterface : public talk_base::RefCount {
+class VideoRendererWrapperInterface : public talk_base::RefCount {
  public:
   virtual cricket::VideoRenderer* renderer() = 0;
 
  protected:
-  virtual ~VideoRendererInterface() {}
+  virtual ~VideoRendererWrapperInterface() {}
 };
 
 // Creates a reference counted object of type webrtc::VideoRenderer.
-// webrtc::VideoRendererInterface take ownership of cricket::VideoRenderer.
-scoped_refptr<VideoRendererInterface> CreateVideoRenderer(
+// webrtc::VideoRendererWrapperInterface take ownership of
+// cricket::VideoRenderer.
+scoped_refptr<VideoRendererWrapperInterface> CreateVideoRenderer(
     cricket::VideoRenderer* renderer);
 
 class VideoTrackInterface : public MediaStreamTrackInterface {
  public:
   // Set the video renderer for a local or remote stream.
   // This call will start decoding the received video stream and render it.
-  virtual void SetRenderer(VideoRendererInterface* renderer) = 0;
+  virtual void SetRenderer(VideoRendererWrapperInterface* renderer) = 0;
 
   // Get the VideoRenderer associated with this track.
-  virtual VideoRendererInterface* GetRenderer() = 0;
+  virtual VideoRendererWrapperInterface* GetRenderer() = 0;
 
  protected:
   virtual ~VideoTrackInterface() {}
@@ -117,6 +112,8 @@ class VideoTrackInterface : public MediaStreamTrackInterface {
 class LocalVideoTrackInterface : public VideoTrackInterface {
  public:
   // Get the VideoCapture device associated with this track.
+  // TODO(mallinath) - Update with VideoCapturerWrapper to support both
+  // cricket and webrtc capture interface.
   virtual VideoCaptureModule* GetVideoCapture() = 0;
 
  protected:
@@ -138,21 +135,25 @@ class LocalAudioTrackInterface : public AudioTrackInterface {
 };
 
 // List of of tracks.
-class MediaStreamTrackListInterface : public talk_base::RefCount,
-                                      public Notifier {
+template <class TrackType>
+class MediaStreamTrackListInterface : public talk_base::RefCount {
  public:
   virtual size_t count() = 0;
-  virtual MediaStreamTrackInterface* at(size_t index) = 0;
+  virtual TrackType* at(size_t index) = 0;
 
  protected:
   virtual ~MediaStreamTrackListInterface() {}
 };
 
+typedef MediaStreamTrackListInterface<AudioTrackInterface> AudioTracks;
+typedef MediaStreamTrackListInterface<VideoTrackInterface> VideoTracks;
+
 class MediaStreamInterface : public talk_base::RefCount,
                              public Notifier {
  public:
   virtual std::string label() const = 0;
-  virtual MediaStreamTrackListInterface* tracks() = 0;
+  virtual AudioTracks* audio_tracks() = 0;
+  virtual VideoTracks* video_tracks() = 0;
 
   enum ReadyState {
     kInitializing,
@@ -171,7 +172,8 @@ class MediaStreamInterface : public talk_base::RefCount,
 
 class LocalMediaStreamInterface : public MediaStreamInterface {
  public:
-  virtual bool AddTrack(MediaStreamTrackInterface* track) = 0;
+  virtual bool AddTrack(AudioTrackInterface* track) = 0;
+  virtual bool AddTrack(VideoTrackInterface* track) = 0;
 };
 
 }  // namespace webrtc
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamhandler.cc b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamhandler.cc
index 0df33fd510..7280f9fd32 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamhandler.cc
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamhandler.cc
@@ -110,7 +110,7 @@ LocalVideoTrackHandler::LocalVideoTrackHandler(
 }
 
 void LocalVideoTrackHandler::OnRendererChanged() {
-  VideoRendererInterface* renderer(video_track_->GetRenderer());
+  VideoRendererWrapperInterface* renderer(video_track_->GetRenderer());
   if (renderer)
     provider_->SetLocalRenderer(video_track_->ssrc(), renderer->renderer());
   else
@@ -122,7 +122,7 @@ void LocalVideoTrackHandler::OnStateChanged(
   if (state == VideoTrackInterface::kLive) {
     provider_->SetCaptureDevice(local_video_track_->ssrc(),
                                 local_video_track_->GetVideoCapture());
-    VideoRendererInterface* renderer(video_track_->GetRenderer());
+    VideoRendererWrapperInterface* renderer(video_track_->GetRenderer());
     if (renderer)
       provider_->SetLocalRenderer(video_track_->ssrc(), renderer->renderer());
     else
@@ -142,7 +142,7 @@ RemoteVideoTrackHandler::RemoteVideoTrackHandler(
 }
 
 void RemoteVideoTrackHandler::OnRendererChanged() {
-  VideoRendererInterface* renderer(video_track_->GetRenderer());
+  VideoRendererWrapperInterface* renderer(video_track_->GetRenderer());
   if (renderer)
     provider_->SetRemoteRenderer(video_track_->ssrc(), renderer->renderer());
   else
@@ -183,17 +183,13 @@ LocalMediaStreamHandler::LocalMediaStreamHandler(
     MediaStreamInterface* stream,
     MediaProviderInterface* provider)
     : MediaStreamHandler(stream, provider) {
-  MediaStreamTrackListInterface* tracklist(stream->tracks());
+  VideoTracks* tracklist(stream->video_tracks());
 
   for (size_t j = 0; j < tracklist->count(); ++j) {
-    MediaStreamTrackInterface* track = tracklist->at(j);
-    if (track->type() == MediaStreamTrackInterface::kVideo) {
-      LocalVideoTrackInterface* video_track =
-          static_cast<LocalVideoTrackInterface*>(track);
-      VideoTrackHandler* handler(new LocalVideoTrackHandler(video_track,
-                                                            provider));
-      video_handlers_.push_back(handler);
-    }
+    LocalVideoTrackInterface* track =
+        static_cast<LocalVideoTrackInterface*>(tracklist->at(j));
+    VideoTrackHandler* handler(new LocalVideoTrackHandler(track, provider));
+    video_handlers_.push_back(handler);
   }
 }
 
@@ -201,17 +197,13 @@ RemoteMediaStreamHandler::RemoteMediaStreamHandler(
     MediaStreamInterface* stream,
     MediaProviderInterface* provider)
     : MediaStreamHandler(stream, provider) {
-  MediaStreamTrackListInterface* tracklist(stream->tracks());
+  VideoTracks* tracklist(stream->video_tracks());
 
   for (size_t j = 0; j < tracklist->count(); ++j) {
-    MediaStreamTrackInterface* track = tracklist->at(j);
-    if (track->type() == MediaStreamTrackInterface::kVideo) {
-      VideoTrackInterface* video_track =
-          static_cast<VideoTrackInterface*>(track);
-      VideoTrackHandler* handler(new RemoteVideoTrackHandler(video_track,
-                                                             provider));
-      video_handlers_.push_back(handler);
-    }
+    VideoTrackInterface* track =
+        static_cast<VideoTrackInterface*>(tracklist->at(j));
+    VideoTrackHandler* handler(new RemoteVideoTrackHandler(track, provider));
+    video_handlers_.push_back(handler);
   }
 }
 
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamhandler.h b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamhandler.h
index 49d1258463..d3551a2cbe 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamhandler.h
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamhandler.h
@@ -66,7 +66,7 @@ class VideoTrackHandler : public Observer,
  private:
   MediaStreamTrackInterface::TrackState state_;
   bool enabled_;
-  scoped_refptr<VideoRendererInterface> renderer_;
+  scoped_refptr<VideoRendererWrapperInterface> renderer_;
   talk_base::Thread* signaling_thread_;
 };
 
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamhandler_unittest.cc b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamhandler_unittest.cc
index 0f38c0788b..ee925bf280 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamhandler_unittest.cc
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamhandler_unittest.cc
@@ -69,12 +69,13 @@ TEST(MediaStreamHandlerTest, LocalStreams) {
   // Create a local stream.
   std::string label(kStreamLabel1);
   scoped_refptr<LocalMediaStreamInterface> stream(
-      MediaStreamImpl::Create(label));
+      MediaStream::Create(label));
   scoped_refptr<LocalVideoTrackInterface> video_track(VideoTrack::CreateLocal(
       kVideoDeviceName, NULL));
   video_track->set_ssrc(kVideoSsrc);
   EXPECT_TRUE(stream->AddTrack(video_track));
-  scoped_refptr<VideoRendererInterface> renderer(CreateVideoRenderer(NULL));
+  scoped_refptr<VideoRendererWrapperInterface> renderer(
+      CreateVideoRenderer(NULL));
   video_track->SetRenderer(renderer);
 
   MockMediaProvier provider;
@@ -108,7 +109,7 @@ TEST(MediaStreamHandlerTest, RemoteStreams) {
   // LocalMediaStreams inherit from MediaStreams.
   std::string label(kStreamLabel1);
   scoped_refptr<LocalMediaStreamInterface> stream(
-      MediaStreamImpl::Create(label));
+      MediaStream::Create(label));
   scoped_refptr<LocalVideoTrackInterface> video_track(VideoTrack::CreateLocal(
       kVideoDeviceName, NULL));
   video_track->set_ssrc(kVideoSsrc);
@@ -123,7 +124,8 @@ TEST(MediaStreamHandlerTest, RemoteStreams) {
       .Times(Exactly(2));
 
   // Set the renderer once.
-  scoped_refptr<VideoRendererInterface> renderer(CreateVideoRenderer(NULL));
+  scoped_refptr<VideoRendererWrapperInterface> renderer(
+      CreateVideoRenderer(NULL));
     video_track->SetRenderer(renderer);
   talk_base::Thread::Current()->ProcessMessages(1);
 
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamimpl.cc b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamimpl.cc
index cecf60a4ca..00e5a5dafa 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamimpl.cc
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamimpl.cc
@@ -24,29 +24,36 @@
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 #include "talk/app/webrtc_dev/mediastreamimpl.h"
+#include "talk/base/logging.h"
 
 namespace webrtc {
 
 scoped_refptr<LocalMediaStreamInterface> CreateLocalMediaStream(
     const std::string& label) {
-  return MediaStreamImpl::Create(label);
+  return MediaStream::Create(label);
 }
 
-scoped_refptr<MediaStreamImpl> MediaStreamImpl::Create(
+scoped_refptr<MediaStream> MediaStream::Create(
     const std::string& label) {
-  talk_base::RefCountImpl<MediaStreamImpl>* stream =
-      new talk_base::RefCountImpl<MediaStreamImpl>(label);
+  talk_base::RefCountImpl<MediaStream>* stream =
+      new talk_base::RefCountImpl<MediaStream>(label);
   return stream;
 }
 
-MediaStreamImpl::MediaStreamImpl(const std::string& label)
+MediaStream::MediaStream(const std::string& label)
     : label_(label),
       ready_state_(MediaStreamInterface::kInitializing),
-      track_list_(new talk_base::RefCountImpl<MediaStreamTrackListImpl>()) {
+      audio_track_list_(
+          new talk_base::RefCountImpl<
+          MediaStreamTrackList<AudioTrackInterface> >()),
+      video_track_list_(
+          new talk_base::RefCountImpl<
+          MediaStreamTrackList<VideoTrackInterface> >()) {
 }
 
-void MediaStreamImpl::set_ready_state(
+void MediaStream::set_ready_state(
     MediaStreamInterface::ReadyState new_state) {
   if (ready_state_ != new_state) {
     ready_state_ = new_state;
@@ -54,18 +61,18 @@ void MediaStreamImpl::set_ready_state(
   }
 }
 
-bool MediaStreamImpl::AddTrack(MediaStreamTrackInterface* track) {
+bool MediaStream::AddTrack(AudioTrackInterface* track) {
   if (ready_state() != kInitializing)
     return false;
-
-  track_list_->AddTrack(track);
+  audio_track_list_->AddTrack(track);
   return true;
 }
 
-void MediaStreamImpl::MediaStreamTrackListImpl::AddTrack(
-    MediaStreamTrackInterface* track) {
-  tracks_.push_back(track);
-  NotifierImpl<MediaStreamTrackListInterface>::FireOnChanged();
+bool MediaStream::AddTrack(VideoTrackInterface* track) {
+  if (ready_state() != kInitializing)
+    return false;
+  video_track_list_->AddTrack(track);
+  return true;
 }
 
 }  // namespace webrtc
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamimpl.h b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamimpl.h
index 2b32697584..6aa274b950 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamimpl.h
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamimpl.h
@@ -35,41 +35,54 @@
 #include "talk/app/webrtc_dev/notifierimpl.h"
 
 namespace webrtc {
+class AudioTrack;
+class VideoTrack;
 
-class MediaStreamImpl
+class MediaStream
     : public NotifierImpl<LocalMediaStreamInterface> {
  public:
-  class MediaStreamTrackListImpl :
-    public NotifierImpl<MediaStreamTrackListInterface> {
+  template<class T>
+  class MediaStreamTrackList :
+    public MediaStreamTrackListInterface<T> {
    public:
-    void AddTrack(MediaStreamTrackInterface* track);
+    void AddTrack(T* track) {
+      tracks_.push_back(track);
+    }
     virtual size_t count() { return tracks_.size(); }
-    virtual MediaStreamTrackInterface* at(size_t index) {
+    virtual T* at(size_t index) {
       return tracks_.at(index);
     }
 
    private:
-    std::vector<scoped_refptr<MediaStreamTrackInterface> > tracks_;
+    std::vector<scoped_refptr<T> > tracks_;
   };
 
-  static scoped_refptr<MediaStreamImpl> Create(const std::string& label);
+  static scoped_refptr<MediaStream> Create(const std::string& label);
 
-  // Implement LocalStream.
-  virtual bool AddTrack(MediaStreamTrackInterface* track);
-
-  // Implement MediaStream.
+  // Implement LocalMediaStreamInterface.
+  virtual bool AddTrack(AudioTrackInterface* track);
+  virtual bool AddTrack(VideoTrackInterface* track);
+  // Implement MediaStreamInterface.
   virtual std::string label() const { return label_; }
-  virtual MediaStreamTrackListInterface* tracks() { return track_list_; }
+  virtual MediaStreamTrackListInterface<AudioTrackInterface>* audio_tracks() {
+    return audio_track_list_;
+  }
+  virtual MediaStreamTrackListInterface<VideoTrackInterface>* video_tracks() {
+    return video_track_list_;
+  }
   virtual ReadyState ready_state() { return ready_state_; }
   virtual void set_ready_state(ReadyState new_state);
   void set_state(ReadyState new_state);
 
  protected:
-  explicit MediaStreamImpl(const std::string& label);
+  explicit MediaStream(const std::string& label);
 
   std::string label_;
   MediaStreamInterface::ReadyState ready_state_;
-  scoped_refptr<MediaStreamTrackListImpl> track_list_;
+  scoped_refptr<MediaStreamTrackList<AudioTrackInterface> >
+      audio_track_list_;
+  scoped_refptr<MediaStreamTrackList<VideoTrackInterface> >
+      video_track_list_;
 };
 
 }  // namespace webrtc
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamimpl_unittest.cc b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamimpl_unittest.cc
index 27b4da473b..cbd42371f6 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamimpl_unittest.cc
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamimpl_unittest.cc
@@ -58,7 +58,7 @@ TEST(LocalStreamTest, Create) {
   // Create a local stream.
   std::string label(kStreamLabel1);
   scoped_refptr<LocalMediaStreamInterface> stream(
-      MediaStreamImpl::Create(label));
+      MediaStream::Create(label));
 
   EXPECT_EQ(label, stream->label());
   //  Check state.
@@ -69,19 +69,15 @@ TEST(LocalStreamTest, Create) {
   scoped_refptr<LocalVideoTrackInterface> video_track(VideoTrack::CreateLocal(
                           kVideoDeviceName, NULL));
   // Add an observer to the track list.
-  scoped_refptr<MediaStreamTrackListInterface> track_list(stream->tracks());
-  stream->tracks()->RegisterObserver(&tracklist_observer);
+  scoped_refptr<MediaStreamTrackListInterface<VideoTrackInterface> > track_list(
+      stream->video_tracks());
   // Add the track to the local stream.
   EXPECT_TRUE(stream->AddTrack(video_track));
-  // Verify that the track list observer have been notified
-  // that the track have been added.
-  EXPECT_EQ(1u, tracklist_observer.NumChanges());
-  EXPECT_EQ(1u, stream->tracks()->count());
+  EXPECT_EQ(1u, stream->video_tracks()->count());
 
   // Verify the track.
   scoped_refptr<webrtc::MediaStreamTrackInterface> track(
-      stream->tracks()->at(0));
-  EXPECT_EQ(MediaStreamTrackInterface::kVideo, track->type());
+      stream->video_tracks()->at(0));
   EXPECT_EQ(0, track->label().compare(kVideoDeviceName));
   EXPECT_TRUE(track->enabled());
 
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamproxy.cc b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamproxy.cc
index 8df91957e6..ecafa8bef5 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamproxy.cc
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamproxy.cc
@@ -35,7 +35,8 @@ enum {
   MSG_REGISTER_OBSERVER = 1,
   MSG_UNREGISTER_OBSERVER,
   MSG_LABEL,
-  MSG_ADD_TRACK,
+  MSG_ADD_AUDIO_TRACK,
+  MSG_ADD_VIDEO_TRACK,
   MSG_READY_STATE,
   MSG_SET_READY_STATE,
   MSG_COUNT,
@@ -48,19 +49,24 @@ typedef talk_base::TypedMessageData<webrtc::Observer*> ObserverMessageData;
 typedef talk_base::TypedMessageData<webrtc::MediaStreamInterface::ReadyState>
     ReadyStateMessageData;
 
-
+template<typename T>
 class MediaStreamTrackMessageData : public talk_base::MessageData {
  public:
-  explicit MediaStreamTrackMessageData(
-      webrtc::MediaStreamTrackInterface* track)
+  explicit MediaStreamTrackMessageData(T* track)
       : track_(track),
         result_(false) {
   }
 
-  scoped_refptr<webrtc::MediaStreamTrackInterface> track_;
+  scoped_refptr<T> track_;
   bool result_;
 };
 
+typedef MediaStreamTrackMessageData<webrtc::AudioTrackInterface>
+    AudioTrackMsgData;
+typedef MediaStreamTrackMessageData<webrtc::VideoTrackInterface>
+    VideoTrackMsgData;
+
+template <class TrackType>
 class MediaStreamTrackAtMessageData : public talk_base::MessageData {
  public:
   explicit MediaStreamTrackAtMessageData(size_t index)
@@ -68,7 +74,7 @@ class MediaStreamTrackAtMessageData : public talk_base::MessageData {
   }
 
   size_t index_;
-  scoped_refptr<webrtc::MediaStreamTrackInterface> track_;
+  scoped_refptr<TrackType> track_;
 };
 
 }  // namespace anonymous
@@ -87,10 +93,15 @@ scoped_refptr<MediaStreamProxy> MediaStreamProxy::Create(
 MediaStreamProxy::MediaStreamProxy(const std::string& label,
                                    talk_base::Thread* signaling_thread)
     : signaling_thread_(signaling_thread),
-      media_stream_impl_(MediaStreamImpl::Create(label)),
-      track_list_(new talk_base::RefCountImpl<MediaStreamTrackListProxy>(
-          media_stream_impl_->tracks(),
-          signaling_thread_)) {
+      media_stream_impl_(MediaStream::Create(label)),
+      audio_tracks_(new talk_base::RefCountImpl<
+                    MediaStreamTrackListProxy<AudioTrackInterface> >(
+                    media_stream_impl_->audio_tracks(),
+                    signaling_thread_)),
+      video_tracks_(new talk_base::RefCountImpl<
+                    MediaStreamTrackListProxy<VideoTrackInterface> >(
+                    media_stream_impl_->video_tracks(),
+                    signaling_thread_)) {
 }
 
 std::string MediaStreamProxy::label() const {
@@ -103,10 +114,6 @@ std::string MediaStreamProxy::label() const {
   return media_stream_impl_->label();
 }
 
-MediaStreamTrackListInterface* MediaStreamProxy::tracks() {
-  return track_list_;
-}
-
 MediaStreamInterface::ReadyState MediaStreamProxy::ready_state() {
   if (!signaling_thread_->IsCurrent()) {
     ReadyStateMessageData msg(MediaStreamInterface::kInitializing);
@@ -126,10 +133,19 @@ void MediaStreamProxy::set_ready_state(
   media_stream_impl_->set_ready_state(new_state);
 }
 
-bool MediaStreamProxy::AddTrack(MediaStreamTrackInterface* track) {
+bool MediaStreamProxy::AddTrack(AudioTrackInterface* track) {
   if (!signaling_thread_->IsCurrent()) {
-    MediaStreamTrackMessageData msg(track);
-    Send(MSG_ADD_TRACK, &msg);
+    AudioTrackMsgData msg(track);
+    Send(MSG_ADD_AUDIO_TRACK, &msg);
+    return msg.result_;
+  }
+  return media_stream_impl_->AddTrack(track);
+}
+
+bool MediaStreamProxy::AddTrack(VideoTrackInterface* track) {
+  if (!signaling_thread_->IsCurrent()) {
+    VideoTrackMsgData msg(track);
+    Send(MSG_ADD_VIDEO_TRACK, &msg);
     return msg.result_;
   }
   return media_stream_impl_->AddTrack(track);
@@ -177,9 +193,15 @@ void MediaStreamProxy::OnMessage(talk_base::Message* msg) {
       *(label->data()) = media_stream_impl_->label();
       break;
     }
-    case MSG_ADD_TRACK: {
-      MediaStreamTrackMessageData * track =
-          static_cast<MediaStreamTrackMessageData*>(data);
+    case MSG_ADD_AUDIO_TRACK: {
+      AudioTrackMsgData * track =
+          static_cast<AudioTrackMsgData *>(data);
+      track->result_ = media_stream_impl_->AddTrack(track->track_.get());
+      break;
+    }
+    case MSG_ADD_VIDEO_TRACK: {
+      VideoTrackMsgData * track =
+          static_cast<VideoTrackMsgData *>(data);
       track->result_ = media_stream_impl_->AddTrack(track->track_.get());
       break;
     }
@@ -199,14 +221,16 @@ void MediaStreamProxy::OnMessage(talk_base::Message* msg) {
   }
 }
 
-MediaStreamProxy::MediaStreamTrackListProxy::MediaStreamTrackListProxy(
-    MediaStreamTrackListInterface* track_list,
+template <class T>
+MediaStreamProxy::MediaStreamTrackListProxy<T>::MediaStreamTrackListProxy(
+    MediaStreamTrackListInterface<T>* track_list,
     talk_base::Thread* signaling_thread)
     :  track_list_(track_list),
        signaling_thread_(signaling_thread) {
 }
 
-size_t MediaStreamProxy::MediaStreamTrackListProxy::count() {
+template <class T>
+size_t MediaStreamProxy::MediaStreamTrackListProxy<T>::count() {
   if (!signaling_thread_->IsCurrent()) {
     SizeTMessageData msg(0u);
     Send(MSG_COUNT, &msg);
@@ -215,65 +239,39 @@ size_t MediaStreamProxy::MediaStreamTrackListProxy::count() {
   return track_list_->count();
 }
 
-MediaStreamTrackInterface* MediaStreamProxy::MediaStreamTrackListProxy::at(
+template <class T>
+T* MediaStreamProxy::MediaStreamTrackListProxy<T>::at(
     size_t index) {
   if (!signaling_thread_->IsCurrent()) {
-    MediaStreamTrackAtMessageData msg(index);
+    MediaStreamTrackAtMessageData<T> msg(index);
     Send(MSG_AT, &msg);
     return msg.track_;
   }
   return track_list_->at(index);
 }
 
-void MediaStreamProxy::MediaStreamTrackListProxy::RegisterObserver(
-    Observer* observer) {
-  if (!signaling_thread_->IsCurrent()) {
-    ObserverMessageData msg(observer);
-    Send(MSG_REGISTER_OBSERVER, &msg);
-    return;
-  }
-  track_list_->RegisterObserver(observer);
-}
-
-void MediaStreamProxy::MediaStreamTrackListProxy::UnregisterObserver(
-    Observer* observer) {
-  if (!signaling_thread_->IsCurrent()) {
-    ObserverMessageData msg(observer);
-    Send(MSG_UNREGISTER_OBSERVER, &msg);
-    return;
-  }
-  track_list_->UnregisterObserver(observer);
-}
-
-void MediaStreamProxy::MediaStreamTrackListProxy::Send(
+template <class T>
+void MediaStreamProxy::MediaStreamTrackListProxy<T>::Send(
     uint32 id, talk_base::MessageData* data) const {
   signaling_thread_->Send(
-      const_cast<MediaStreamProxy::MediaStreamTrackListProxy*>(this), id, data);
+      const_cast<MediaStreamProxy::MediaStreamTrackListProxy<T>*>(
+          this), id, data);
 }
 
 // Implement MessageHandler
-void MediaStreamProxy::MediaStreamTrackListProxy::OnMessage(
+template <class T>
+void MediaStreamProxy::MediaStreamTrackListProxy<T>::OnMessage(
     talk_base::Message* msg) {
   talk_base::MessageData* data = msg->pdata;
   switch (msg->message_id) {
-    case MSG_REGISTER_OBSERVER: {
-      ObserverMessageData* observer = static_cast<ObserverMessageData*>(data);
-      track_list_->RegisterObserver(observer->data());
-      break;
-    }
-    case MSG_UNREGISTER_OBSERVER: {
-      ObserverMessageData* observer = static_cast<ObserverMessageData*>(data);
-      track_list_->UnregisterObserver(observer->data());
-      break;
-    }
     case MSG_COUNT: {
       SizeTMessageData* count = static_cast<SizeTMessageData*>(data);
       count->data() = track_list_->count();
       break;
     }
     case MSG_AT: {
-      MediaStreamTrackAtMessageData* track =
-          static_cast<MediaStreamTrackAtMessageData*>(data);
+      MediaStreamTrackAtMessageData<T>* track =
+          static_cast<MediaStreamTrackAtMessageData<T>*>(data);
       track->track_ = track_list_->at(track->index_);
       break;
     }
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamproxy.h b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamproxy.h
index 50a03f0132..6ceea13237 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamproxy.h
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamproxy.h
@@ -42,22 +42,20 @@ namespace webrtc {
 class MediaStreamProxy : public LocalMediaStreamInterface,
                          public talk_base::MessageHandler {
  public:
-  class MediaStreamTrackListProxy : public MediaStreamTrackListInterface,
+  template <class T>
+  class MediaStreamTrackListProxy : public MediaStreamTrackListInterface<T>,
                                     public talk_base::MessageHandler {
    public:
-    MediaStreamTrackListProxy(MediaStreamTrackListInterface* track_list,
+    MediaStreamTrackListProxy(MediaStreamTrackListInterface<T>* track_list,
                               talk_base::Thread* signaling_thread);
     virtual size_t count();
-    virtual MediaStreamTrackInterface* at(size_t index);
+    virtual T* at(size_t index);
 
-    // Implement Notifier
-    virtual void RegisterObserver(Observer* observer);
-    virtual void UnregisterObserver(Observer* observer);
    private:
     void Send(uint32 id, talk_base::MessageData* data) const;
     void OnMessage(talk_base::Message* msg);
 
-    scoped_refptr<MediaStreamTrackListInterface> track_list_;
+    scoped_refptr<MediaStreamTrackListInterface<T> > track_list_;
     mutable talk_base::Thread* signaling_thread_;
   };
 
@@ -66,11 +64,20 @@ class MediaStreamProxy : public LocalMediaStreamInterface,
       talk_base::Thread* signaling_thread);
 
   // Implement LocalStream.
-  virtual bool AddTrack(MediaStreamTrackInterface* track);
+  virtual bool AddTrack(AudioTrackInterface* track);
+  virtual bool AddTrack(VideoTrackInterface* track);
+
+  // This will be used when Tracks are created internally.
+  bool AddTrack(MediaStreamTrackInterface* track);
 
   // Implement MediaStream.
   virtual std::string label() const;
-  virtual MediaStreamTrackListInterface* tracks();
+  virtual MediaStreamTrackListProxy<AudioTrackInterface>* audio_tracks() {
+    return audio_tracks_;
+  }
+  virtual MediaStreamTrackListProxy<VideoTrackInterface>* video_tracks() {
+    return video_tracks_;
+  }
   virtual ReadyState ready_state();
   virtual void set_ready_state(ReadyState new_state);
 
@@ -87,8 +94,9 @@ class MediaStreamProxy : public LocalMediaStreamInterface,
   virtual void OnMessage(talk_base::Message* msg);
 
   mutable talk_base::Thread* signaling_thread_;
-  scoped_refptr<MediaStreamImpl> media_stream_impl_;
-  scoped_refptr<MediaStreamTrackListProxy> track_list_;
+  scoped_refptr<MediaStream> media_stream_impl_;
+  scoped_refptr<MediaStreamTrackListProxy<AudioTrackInterface> > audio_tracks_;
+  scoped_refptr<MediaStreamTrackListProxy<VideoTrackInterface> > video_tracks_;
 };
 
 }  // namespace webrtc
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamtrackproxy.cc b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamtrackproxy.cc
index 3f02578dd2..32d87901a0 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamtrackproxy.cc
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamtrackproxy.cc
@@ -64,7 +64,7 @@ class VideoDeviceMessageData : public talk_base::MessageData {
 
 class VideoRendererMessageData : public talk_base::MessageData {
  public:
-  scoped_refptr<webrtc::VideoRendererInterface> video_renderer_;
+  scoped_refptr<webrtc::VideoRendererWrapperInterface> video_renderer_;
 };
 
 }  // namespace anonymous
@@ -87,12 +87,6 @@ const char* MediaStreamTrackProxy<T>::kind() const {
   return track_->kind();
 }
 
-template <class T>
-MediaStreamTrackInterface::TrackType
-    MediaStreamTrackProxy<T>::type() const {
-  return track_->type();
-}
-
 template <class T>
 std::string MediaStreamTrackProxy<T>::label() const {
   if (!signaling_thread_->IsCurrent()) {
@@ -353,7 +347,7 @@ VideoCaptureModule* VideoTrackProxy::GetVideoCapture() {
   return video_track_->GetVideoCapture();
 }
 
-void VideoTrackProxy::SetRenderer(VideoRendererInterface* renderer) {
+void VideoTrackProxy::SetRenderer(VideoRendererWrapperInterface* renderer) {
   if (!signaling_thread_->IsCurrent()) {
     VideoRendererMessageData msg;
     msg.video_renderer_ = renderer;
@@ -363,7 +357,7 @@ void VideoTrackProxy::SetRenderer(VideoRendererInterface* renderer) {
   return video_track_->SetRenderer(renderer);
 }
 
-VideoRendererInterface* VideoTrackProxy::GetRenderer() {
+VideoRendererWrapperInterface* VideoTrackProxy::GetRenderer() {
   if (!signaling_thread_->IsCurrent()) {
     VideoRendererMessageData msg;
     Send(MSG_GET_VIDEORENDERER, &msg);
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamtrackproxy.h b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamtrackproxy.h
index cd2c67cf91..fb64548e0f 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamtrackproxy.h
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamtrackproxy.h
@@ -49,7 +49,6 @@ class MediaStreamTrackProxy : public T,
   // Implement MediaStreamTrack.
 
   virtual const char* kind() const;
-  virtual MediaStreamTrackInterface::TrackType type() const;
   virtual std::string label() const;
   virtual uint32 ssrc() const;
   virtual bool enabled() const;
@@ -118,8 +117,8 @@ class VideoTrackProxy : public MediaStreamTrackProxy<LocalVideoTrackInterface> {
       talk_base::Thread* signaling_thread);
 
   virtual VideoCaptureModule* GetVideoCapture();
-  virtual void SetRenderer(VideoRendererInterface* renderer);
-  VideoRendererInterface* GetRenderer();
+  virtual void SetRenderer(VideoRendererWrapperInterface* renderer);
+  VideoRendererWrapperInterface* GetRenderer();
 
  protected:
   VideoTrackProxy(const std::string& label,
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediatrackimpl.h b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediatrackimpl.h
new file mode 100644
index 0000000000..96263d9af9
--- /dev/null
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediatrackimpl.h
@@ -0,0 +1,90 @@
+/*
+ * libjingle
+ * Copyright 2011, 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,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TALK_APP_WEBRTC_MEDIATRACKIMPL_H_
+#define TALK_APP_WEBRTC_MEDIATRACKIMPL_H_
+
+#include <string>
+
+#include "talk/app/webrtc_dev/mediastream.h"
+#include "talk/app/webrtc_dev/notifierimpl.h"
+
+namespace webrtc {
+
+template <typename T>
+class MediaTrack : public NotifierImpl<T> {
+ public:
+  typedef typename T::TrackState TypedTrackState;
+
+  virtual std::string label() const { return label_; }
+  virtual uint32 ssrc() const { return ssrc_; }
+  virtual TypedTrackState state() const { return state_; }
+  virtual bool enabled() const { return enabled_; }
+  virtual bool set_enabled(bool enable) {
+    bool fire_on_change = (enable != enabled_);
+    enabled_ = enable;
+    if (fire_on_change) {
+      NotifierImpl<T>::FireOnChanged();
+    }
+  }
+
+  virtual bool set_ssrc(uint32 ssrc) {
+    ASSERT(ssrc_ == 0);
+    ASSERT(ssrc != 0);
+    if (ssrc_ != 0)
+      return false;
+    ssrc_ = ssrc;
+    NotifierImpl<T>::FireOnChanged();
+    return true;
+  }
+
+  virtual bool set_state(TypedTrackState new_state) {
+    bool fire_on_change = (state_ != new_state);
+    state_ = new_state;
+    if (fire_on_change)
+      NotifierImpl<T>::FireOnChanged();
+    return true;
+  }
+
+ protected:
+  MediaTrack(const std::string& label, uint32 ssrc)
+      : enabled_(true),
+        label_(label),
+        ssrc_(ssrc),
+        state_(T::kInitializing) {
+  }
+
+ private:
+  bool enabled_;
+  std::string label_;
+  uint32 ssrc_;
+  TypedTrackState state_;
+};
+
+}  // namespace webrtc
+
+#endif  // TALK_APP_WEBRTC_MEDIATRACKIMPL_H_
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/peerconnectionsignaling.cc b/third_party_mods/libjingle/source/talk/app/webrtc_dev/peerconnectionsignaling.cc
index ba23134c69..b0a23c99f2 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/peerconnectionsignaling.cc
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/peerconnectionsignaling.cc
@@ -297,27 +297,29 @@ void PeerConnectionSignaling::InitMediaSessionOptions(
   options->is_video = true;
   for (size_t i = 0; i < local_streams->count(); ++i) {
     MediaStreamInterface* stream = local_streams->at(i);
-    scoped_refptr<MediaStreamTrackListInterface> tracks = stream->tracks();
 
-    // For each track in the stream, add it to the MediaSessionOptions.
-    for (size_t j = 0; j < tracks->count(); ++j) {
-      scoped_refptr<MediaStreamTrackInterface> track = tracks->at(j);
-      if (MediaStreamTrackInterface::kAudio == track->type()) {
-        // TODO(perkj): Better ssrc?
-        // Does talk_base::CreateRandomNonZeroId() generate unique id?
-        if (track->ssrc() == 0)
-          track->set_ssrc(++ssrc_counter_);
-        options->audio_sources.push_back(cricket::SourceParam(track->ssrc(),
-                                                              track->label(),
-                                                              stream->label()));
-      }
-      if (MediaStreamTrackInterface::kVideo == track->type()) {
-        if (track->ssrc() == 0)
-          track->set_ssrc(++ssrc_counter_);  // TODO(perkj): Better ssrc?
-        options->video_sources.push_back(cricket::SourceParam(track->ssrc(),
-                                                              track->label(),
-                                                              stream->label()));
-      }
+    scoped_refptr<MediaStreamTrackListInterface<AudioTrackInterface> >
+        audio_tracks = stream->audio_tracks();
+    // For each audio track in the stream, add it to the MediaSessionOptions.
+    for (size_t j = 0; j < audio_tracks->count(); ++j) {
+      scoped_refptr<MediaStreamTrackInterface> track = audio_tracks->at(j);
+      if (track->ssrc() == 0)
+        track->set_ssrc(++ssrc_counter_);
+      options->audio_sources.push_back(cricket::SourceParam(track->ssrc(),
+                                                            track->label(),
+                                                            stream->label()));
+    }
+
+    scoped_refptr<MediaStreamTrackListInterface<VideoTrackInterface> >
+        video_tracks = stream->video_tracks();
+    // For each video track in the stream, add it to the MediaSessionOptions.
+    for (size_t j = 0; j <  video_tracks->count(); ++j) {
+      scoped_refptr<MediaStreamTrackInterface> track = video_tracks->at(j);
+      if (track->ssrc() == 0)
+        track->set_ssrc(++ssrc_counter_);
+      options->video_sources.push_back(cricket::SourceParam(track->ssrc(),
+                                                            track->label(),
+                                                            stream->label()));
     }
   }
 }
@@ -428,10 +430,15 @@ void PeerConnectionSignaling::UpdateRemoteStreams(
         current_streams.find(old_stream->label());
     if (new_streams_it == current_streams.end()) {
       old_stream->set_ready_state(MediaStreamInterface::kEnded);
-      scoped_refptr<MediaStreamTrackListInterface> tracklist(
-          old_stream->tracks());
-      for (size_t j = 0; j < tracklist->count(); ++j) {
-        tracklist->at(j)->set_state(MediaStreamTrackInterface::kEnded);
+      scoped_refptr<MediaStreamTrackListInterface<AudioTrackInterface> >
+      audio_tracklist(old_stream->audio_tracks());
+      for (size_t j = 0; j < audio_tracklist->count(); ++j) {
+        audio_tracklist->at(j)->set_state(MediaStreamTrackInterface::kEnded);
+      }
+      scoped_refptr<MediaStreamTrackListInterface<VideoTrackInterface> >
+      video_tracklist(old_stream->video_tracks());
+      for (size_t j = 0; j < video_tracklist->count(); ++j) {
+        video_tracklist->at(j)->set_state(MediaStreamTrackInterface::kEnded);
       }
       SignalRemoteStreamRemoved(old_stream);
     }
@@ -453,51 +460,55 @@ void PeerConnectionSignaling::UpdateSendingLocalStreams(
 
   for (size_t i = 0; i < negotiated_streams->count(); ++i) {
     scoped_refptr<MediaStreamInterface> stream = negotiated_streams->at(i);
-    scoped_refptr<MediaStreamTrackListInterface> tracklist(stream->tracks());
+    scoped_refptr<MediaStreamTrackListInterface<AudioTrackInterface> >
+        audiotracklist(stream->audio_tracks());
+    scoped_refptr<MediaStreamTrackListInterface<VideoTrackInterface> >
+        videotracklist(stream->video_tracks());
 
     bool stream_ok = false;  // A stream is ok if at least one track succeed.
-
-    for (size_t j = 0; j < tracklist->count(); ++j) {
-      scoped_refptr<MediaStreamTrackInterface> track = tracklist->at(j);
-      if (MediaStreamTrackInterface::kAudio == track->type()) {
-        const cricket::ContentInfo* audio_content =
-            GetFirstAudioContent(answer_desc);
-
-        if (!audio_content) {  // The remote does not accept audio.
-          track->set_state(MediaStreamTrackInterface::kFailed);
-          continue;
-        }
-        const cricket::AudioContentDescription* audio_desc =
-              static_cast<const cricket::AudioContentDescription*>(
-                  audio_content->description);
-        // TODO(perkj): Do we need to store the codec in the track?
-        if (audio_desc->codecs().size() <= 0) {
-          // No common codec.
-          track->set_state(MediaStreamTrackInterface::kFailed);
-        }
-        track->set_state(MediaStreamTrackInterface::kLive);
-        stream_ok = true;
+    // Update tracks based on its type.
+    for (size_t j = 0; j < audiotracklist->count(); ++j) {
+      scoped_refptr<MediaStreamTrackInterface> track = audiotracklist->at(j);
+      const cricket::ContentInfo* audio_content =
+          GetFirstAudioContent(answer_desc);
+      if (!audio_content) {  // The remote does not accept audio.
+        track->set_state(MediaStreamTrackInterface::kFailed);
+        continue;
       }
-      if (MediaStreamTrackInterface::kVideo == track->type()) {
-        const cricket::ContentInfo* video_content =
-            GetFirstVideoContent(answer_desc);
 
-        if (!video_content) {  // The remote does not accept video.
-          track->set_state(MediaStreamTrackInterface::kFailed);
-          continue;
-        }
-        const cricket::VideoContentDescription* video_desc =
-            static_cast<const cricket::VideoContentDescription*>(
-                video_content->description);
-        // TODO(perkj): Do we need to store the codec in the track?
-        if (video_desc->codecs().size() <= 0) {
-          // No common codec.
-          track->set_state(MediaStreamTrackInterface::kFailed);
-        }
-        track->set_state(MediaStreamTrackInterface::kLive);
-        stream_ok = true;
+      const cricket::AudioContentDescription* audio_desc =
+          static_cast<const cricket::AudioContentDescription*>(
+              audio_content->description);
+      // TODO(perkj): Do we need to store the codec in the track?
+      if (audio_desc->codecs().size() <= 0) {
+        // No common codec.
+        track->set_state(MediaStreamTrackInterface::kFailed);
       }
+      track->set_state(MediaStreamTrackInterface::kLive);
+      stream_ok = true;
     }
+
+    for (size_t j = 0; j < videotracklist->count(); ++j) {
+      scoped_refptr<MediaStreamTrackInterface> track = videotracklist->at(j);
+      const cricket::ContentInfo* video_content =
+          GetFirstVideoContent(answer_desc);
+      if (!video_content) {  // The remote does not accept video.
+        track->set_state(MediaStreamTrackInterface::kFailed);
+        continue;
+      }
+
+      const cricket::VideoContentDescription* video_desc =
+          static_cast<const cricket::VideoContentDescription*>(
+              video_content->description);
+      // TODO(perkj): Do we need to store the codec in the track?
+      if (video_desc->codecs().size() <= 0) {
+        // No common codec.
+        track->set_state(MediaStreamTrackInterface::kFailed);
+      }
+      track->set_state(MediaStreamTrackInterface::kLive);
+      stream_ok = true;
+    }
+
     if (stream_ok) {
       // We have successfully negotiated to send this stream.
       // Change the stream and store it as successfully negotiated.
@@ -519,10 +530,15 @@ void PeerConnectionSignaling::UpdateSendingLocalStreams(
         negotiated_streams->find(old_stream->label());
     if (new_streams == NULL) {
       old_stream->set_ready_state(MediaStreamInterface::kEnded);
-      scoped_refptr<MediaStreamTrackListInterface> tracklist(
-          old_stream->tracks());
-      for (size_t j = 0; j < tracklist->count(); ++j) {
-        tracklist->at(j)->set_state(MediaStreamTrackInterface::kEnded);
+      scoped_refptr<MediaStreamTrackListInterface<AudioTrackInterface> >
+          audio_tracklist(old_stream->audio_tracks());
+      for (size_t j = 0; j < audio_tracklist->count(); ++j) {
+        audio_tracklist->at(j)->set_state(MediaStreamTrackInterface::kEnded);
+      }
+      scoped_refptr<MediaStreamTrackListInterface<VideoTrackInterface> >
+          video_tracklist(old_stream->video_tracks());
+      for (size_t j = 0; j < video_tracklist->count(); ++j) {
+        video_tracklist->at(j)->set_state(MediaStreamTrackInterface::kEnded);
       }
     }
   }
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/peerconnectionsignaling_unittest.cc b/third_party_mods/libjingle/source/talk/app/webrtc_dev/peerconnectionsignaling_unittest.cc
index e0cb75c41a..3a44b78e2f 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/peerconnectionsignaling_unittest.cc
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/peerconnectionsignaling_unittest.cc
@@ -240,7 +240,7 @@ TEST_F(PeerConnectionSignalingTest, SimpleOneWayCall) {
   // Create a local stream.
   std::string label(kStreamLabel1);
   scoped_refptr<LocalMediaStreamInterface> stream(
-      MediaStreamImpl::Create(label));
+      MediaStream::Create(label));
   MockMediaStreamObserver stream_observer1(stream);
 
   // Add a local audio track.
@@ -315,7 +315,7 @@ TEST_F(PeerConnectionSignalingTest, Glare) {
   // Create a local stream.
   std::string label(kStreamLabel1);
   scoped_refptr<LocalMediaStreamInterface> stream(
-      MediaStreamImpl::Create(label));
+      MediaStream::Create(label));
 
   // Add a local audio track.
   scoped_refptr<LocalAudioTrackInterface> audio_track(AudioTrack::CreateLocal(
@@ -379,7 +379,7 @@ TEST_F(PeerConnectionSignalingTest, AddRemoveStream) {
   // Create a local stream.
   std::string label(kStreamLabel1);
   scoped_refptr<LocalMediaStreamInterface> stream(
-      MediaStreamImpl::Create(label));
+      MediaStream::Create(label));
   MockMediaStreamObserver stream_observer1(stream);
 
   // Add a local audio track.
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/videorendererimpl.cc b/third_party_mods/libjingle/source/talk/app/webrtc_dev/videorendererimpl.cc
index baa14aca95..18d6a64f3d 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/videorendererimpl.cc
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/videorendererimpl.cc
@@ -32,7 +32,7 @@
 namespace webrtc {
 
 // VideoRendererImpl take ownership of cricket::VideoRenderer.
-class VideoRendererImpl : public VideoRendererInterface {
+class VideoRendererImpl : public VideoRendererWrapperInterface {
  public:
   explicit VideoRendererImpl(cricket::VideoRenderer* renderer)
       : renderer_(renderer) {
@@ -48,7 +48,7 @@ class VideoRendererImpl : public VideoRendererInterface {
   cricket::VideoRenderer* renderer_;
 };
 
-scoped_refptr<VideoRendererInterface> CreateVideoRenderer(
+scoped_refptr<VideoRendererWrapperInterface> CreateVideoRenderer(
     cricket::VideoRenderer* renderer) {
   talk_base::RefCountImpl<VideoRendererImpl>* r =
       new talk_base::RefCountImpl<VideoRendererImpl>(renderer);
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/videotrackimpl.cc b/third_party_mods/libjingle/source/talk/app/webrtc_dev/videotrackimpl.cc
index 78d39aa092..6e80ecb7a1 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/videotrackimpl.cc
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/videotrackimpl.cc
@@ -33,28 +33,22 @@ namespace webrtc {
 static const char kVideoTrackKind[] = "video";
 
 VideoTrack::VideoTrack(const std::string& label, uint32 ssrc)
-    : enabled_(true),
-      label_(label),
-      ssrc_(ssrc),
-      state_(kInitializing),
+    : MediaTrack<LocalVideoTrackInterface>(label, ssrc),
       video_device_(NULL) {
 }
 
 VideoTrack::VideoTrack(const std::string& label,
                        VideoCaptureModule* video_device)
-    : enabled_(true),
-      label_(label),
-      ssrc_(0),
-      state_(kInitializing),
+    : MediaTrack<LocalVideoTrackInterface>(label, 0),
       video_device_(video_device) {
 }
 
-void VideoTrack::SetRenderer(VideoRendererInterface* renderer) {
+void VideoTrack::SetRenderer(VideoRendererWrapperInterface* renderer) {
   video_renderer_ = renderer;
   NotifierImpl<LocalVideoTrackInterface>::FireOnChanged();
 }
 
-VideoRendererInterface* VideoTrack::GetRenderer() {
+VideoRendererWrapperInterface* VideoTrack::GetRenderer() {
   return video_renderer_.get();
 }
 
@@ -67,31 +61,6 @@ const char* VideoTrack::kind() const {
   return kVideoTrackKind;
 }
 
-bool VideoTrack::set_enabled(bool enable) {
-  bool fire_on_change = enable != enabled_;
-  enabled_ = enable;
-  if (fire_on_change)
-    NotifierImpl<LocalVideoTrackInterface>::FireOnChanged();
-}
-
-bool VideoTrack::set_ssrc(uint32 ssrc) {
-  ASSERT(ssrc_ == 0);
-  ASSERT(ssrc != 0);
-  if (ssrc_ != 0)
-    return false;
-  ssrc_ = ssrc;
-  NotifierImpl<LocalVideoTrackInterface>::FireOnChanged();
-  return true;
-}
-
-bool VideoTrack::set_state(TrackState new_state) {
-  bool fire_on_change = state_ != new_state;
-  state_ = new_state;
-  if (fire_on_change)
-    NotifierImpl<LocalVideoTrackInterface>::FireOnChanged();
-  return true;
-}
-
 scoped_refptr<VideoTrack> VideoTrack::CreateRemote(
     const std::string& label,
     uint32 ssrc) {
diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/videotrackimpl.h b/third_party_mods/libjingle/source/talk/app/webrtc_dev/videotrackimpl.h
index 79ffa3e398..929b2feac2 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtc_dev/videotrackimpl.h
+++ b/third_party_mods/libjingle/source/talk/app/webrtc_dev/videotrackimpl.h
@@ -28,9 +28,8 @@
 #ifndef TALK_APP_WEBRTC_VIDEOTRACKIMPL_H_
 #define TALK_APP_WEBRTC_VIDEOTRACKIMPL_H_
 
-#include <string>
-
 #include "talk/app/webrtc_dev/mediastream.h"
+#include "talk/app/webrtc_dev/mediatrackimpl.h"
 #include "talk/app/webrtc_dev/notifierimpl.h"
 #include "talk/app/webrtc_dev/scoped_refptr.h"
 
@@ -42,7 +41,7 @@
 
 namespace webrtc {
 
-class VideoTrack : public NotifierImpl<LocalVideoTrackInterface> {
+class VideoTrack : public MediaTrack<LocalVideoTrackInterface> {
  public:
   // Create a video track used for remote video tracks.
   static scoped_refptr<VideoTrack> CreateRemote(const std::string& label,
@@ -53,30 +52,18 @@ class VideoTrack : public NotifierImpl<LocalVideoTrackInterface> {
       VideoCaptureModule* video_device);
 
   virtual VideoCaptureModule* GetVideoCapture();
-  virtual void SetRenderer(VideoRendererInterface* renderer);
-  VideoRendererInterface* GetRenderer();
+  virtual void SetRenderer(VideoRendererWrapperInterface* renderer);
+  VideoRendererWrapperInterface* GetRenderer();
 
   virtual const char* kind() const;
-  virtual std::string label() const { return label_; }
-  virtual TrackType type() const { return kVideo; }
-  virtual uint32 ssrc() const { return ssrc_; }
-  virtual bool enabled() const { return enabled_; }
-  virtual TrackState state() const { return state_; }
-  virtual bool set_enabled(bool enable);
-  virtual bool set_ssrc(uint32 ssrc);
-  virtual bool set_state(TrackState new_state);
 
  protected:
   VideoTrack(const std::string& label, uint32 ssrc);
   VideoTrack(const std::string& label, VideoCaptureModule* video_device);
 
  private:
-  bool enabled_;
-  std::string label_;
-  uint32 ssrc_;
-  TrackState state_;
   scoped_refptr<VideoCaptureModule> video_device_;
-  scoped_refptr<VideoRendererInterface> video_renderer_;
+  scoped_refptr<VideoRendererWrapperInterface> video_renderer_;
 };
 
 }  // namespace webrtc
diff --git a/third_party_mods/libjingle/source/talk/examples/peerconnection_client/conductor.cc b/third_party_mods/libjingle/source/talk/examples/peerconnection_client/conductor.cc
index 9368ae7bf3..b60c005496 100644
--- a/third_party_mods/libjingle/source/talk/examples/peerconnection_client/conductor.cc
+++ b/third_party_mods/libjingle/source/talk/examples/peerconnection_client/conductor.cc
@@ -256,7 +256,7 @@ void Conductor::AddStreams() {
       peer_connection_factory_->CreateLocalVideoTrack(
           kVideoLabel, OpenVideoCaptureDevice()));
 
-  scoped_refptr<webrtc::VideoRendererInterface> renderer(
+  scoped_refptr<webrtc::VideoRendererWrapperInterface> renderer(
       webrtc::CreateVideoRenderer(
       main_wnd_->local_renderer()));
   video_track->SetRenderer(renderer);
@@ -343,18 +343,14 @@ void Conductor::UIThreadCallback(int msg_id, void* data) {
       webrtc::MediaStreamInterface* stream =
           reinterpret_cast<webrtc::MediaStreamInterface*>(
           data);
-      scoped_refptr<webrtc::MediaStreamTrackListInterface> tracks =
-          stream->tracks();
+      scoped_refptr<webrtc::MediaStreamTrackListInterface<
+      webrtc::VideoTrackInterface> > tracks = stream->video_tracks();
       for (size_t i = 0; i < tracks->count(); ++i) {
-        if (tracks->at(i)->type() ==
-            webrtc::MediaStreamTrackInterface::kVideo) {
-          webrtc::VideoTrackInterface* track =
-              reinterpret_cast<webrtc::VideoTrackInterface*>(tracks->at(i));
-          LOG(INFO) << "Setting video renderer for track: " << track->label();
-          scoped_refptr<webrtc::VideoRendererInterface> renderer(
-              webrtc::CreateVideoRenderer(main_wnd_->remote_renderer()));
-          track->SetRenderer(renderer);
-        }
+        webrtc::VideoTrackInterface* track = tracks->at(i);
+        LOG(INFO) << "Setting video renderer for track: " << track->label();
+        scoped_refptr<webrtc::VideoRendererWrapperInterface> renderer(
+            webrtc::CreateVideoRenderer(main_wnd_->remote_renderer()));
+        track->SetRenderer(renderer);
       }
       // If we haven't shared any streams with this peer (we're the receiver)
       // then do so now.