The change will separate the media tracks based on media type. MediaStreamInterface currently will have list for audio and video. This way we don't need to check for the track type before converting to respective mediatrack.

Review URL: http://webrtc-codereview.appspot.com/230003

git-svn-id: http://webrtc.googlecode.com/svn/trunk@756 4adac7df-926f-26a2-2b94-8c16560cd09d

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',

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),
+    : MediaTrack<LocalAudioTrackInterface>(label, ssrc),
-      label_(label),
-      ssrc_(ssrc),
-      state_(kInitializing),
       audio_device_(NULL) {
 }
 
 AudioTrack::AudioTrack(const std::string& label,
                        AudioDeviceModule* audio_device)
-    : enabled_(true),
+    : MediaTrack<LocalAudioTrackInterface>(label, 0),
-      label_(label),
-      ssrc_(0),
-      state_(kInitializing),
       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 =

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_;
 };
 

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 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.
+// webrtc::VideoRendererWrapperInterface take ownership of
-scoped_refptr<VideoRendererInterface> CreateVideoRenderer(
+// 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,
+template <class TrackType>
-                                      public Notifier {
+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

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,37 +183,29 @@ 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);
+    LocalVideoTrackInterface* track =
-    if (track->type() == MediaStreamTrackInterface::kVideo) {
+        static_cast<LocalVideoTrackInterface*>(tracklist->at(j));
-      LocalVideoTrackInterface* video_track =
+    VideoTrackHandler* handler(new LocalVideoTrackHandler(track, provider));
-          static_cast<LocalVideoTrackInterface*>(track);
-      VideoTrackHandler* handler(new LocalVideoTrackHandler(video_track,
-                                                            provider));
     video_handlers_.push_back(handler);
   }
 }
-}
 
 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);
+    VideoTrackInterface* track =
-    if (track->type() == MediaStreamTrackInterface::kVideo) {
+        static_cast<VideoTrackInterface*>(tracklist->at(j));
-      VideoTrackInterface* video_track =
+    VideoTrackHandler* handler(new RemoteVideoTrackHandler(track, provider));
-          static_cast<VideoTrackInterface*>(track);
-      VideoTrackHandler* handler(new RemoteVideoTrackHandler(video_track,
-                                                             provider));
     video_handlers_.push_back(handler);
   }
 }
-}
 
 MediaStreamHandlers::MediaStreamHandlers(MediaProviderInterface* provider)
     : provider_(provider) {

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_;
 };
 

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);
 

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 =
+  talk_base::RefCountImpl<MediaStream>* stream =
-      new talk_base::RefCountImpl<MediaStreamImpl>(label);
+      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;
-
+  audio_track_list_->AddTrack(track);
-  track_list_->AddTrack(track);
   return true;
 }
 
-void MediaStreamImpl::MediaStreamTrackListImpl::AddTrack(
+bool MediaStream::AddTrack(VideoTrackInterface* track) {
-    MediaStreamTrackInterface* track) {
+  if (ready_state() != kInitializing)
-  tracks_.push_back(track);
+    return false;
-  NotifierImpl<MediaStreamTrackListInterface>::FireOnChanged();
+  video_track_list_->AddTrack(track);
+  return true;
 }
 
 }  // namespace webrtc

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 :
+  template<class T>
-    public NotifierImpl<MediaStreamTrackListInterface> {
+  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.
+  // Implement LocalMediaStreamInterface.
-  virtual bool AddTrack(MediaStreamTrackInterface* track);
+  virtual bool AddTrack(AudioTrackInterface* track);
-
+  virtual bool AddTrack(VideoTrackInterface* track);
-  // Implement MediaStream.
+  // 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

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());
+  scoped_refptr<MediaStreamTrackListInterface<VideoTrackInterface> > track_list(
-  stream->tracks()->RegisterObserver(&tracklist_observer);
+      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
+  EXPECT_EQ(1u, stream->video_tracks()->count());
-  // that the track have been added.
-  EXPECT_EQ(1u, tracklist_observer.NumChanges());
-  EXPECT_EQ(1u, stream->tracks()->count());
 
   // Verify the track.
   scoped_refptr<webrtc::MediaStreamTrackInterface> track(
-      stream->tracks()->at(0));
+      stream->video_tracks()->at(0));
-  EXPECT_EQ(MediaStreamTrackInterface::kVideo, track->type());
   EXPECT_EQ(0, track->label().compare(kVideoDeviceName));
   EXPECT_TRUE(track->enabled());
 

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(
+  explicit MediaStreamTrackMessageData(T* track)
-      webrtc::MediaStreamTrackInterface* 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,9 +93,14 @@ 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)),
+      media_stream_impl_(MediaStream::Create(label)),
-      track_list_(new talk_base::RefCountImpl<MediaStreamTrackListProxy>(
+      audio_tracks_(new talk_base::RefCountImpl<
-          media_stream_impl_->tracks(),
+                    MediaStreamTrackListProxy<AudioTrackInterface> >(
+                    media_stream_impl_->audio_tracks(),
+                    signaling_thread_)),
+      video_tracks_(new talk_base::RefCountImpl<
+                    MediaStreamTrackListProxy<VideoTrackInterface> >(
+                    media_stream_impl_->video_tracks(),
                     signaling_thread_)) {
 }
 
@@ -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);
+    AudioTrackMsgData msg(track);
-    Send(MSG_ADD_TRACK, &msg);
+    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: {
+    case MSG_ADD_AUDIO_TRACK: {
-      MediaStreamTrackMessageData * track =
+      AudioTrackMsgData * track =
-          static_cast<MediaStreamTrackMessageData*>(data);
+          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(
+template <class T>
-    MediaStreamTrackListInterface* track_list,
+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(
+template <class T>
-    Observer* observer) {
+void MediaStreamProxy::MediaStreamTrackListProxy<T>::Send(
-  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(
     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 =
+      MediaStreamTrackAtMessageData<T>* track =
-          static_cast<MediaStreamTrackAtMessageData*>(data);
+          static_cast<MediaStreamTrackAtMessageData<T>*>(data);
       track->track_ = track_list_->at(track->index_);
       break;
     }

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<MediaStream> media_stream_impl_;
-  scoped_refptr<MediaStreamTrackListProxy> track_list_;
+  scoped_refptr<MediaStreamTrackListProxy<AudioTrackInterface> > audio_tracks_;
+  scoped_refptr<MediaStreamTrackListProxy<VideoTrackInterface> > video_tracks_;
 };
 
 }  // namespace webrtc

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);

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);
+  virtual void SetRenderer(VideoRendererWrapperInterface* renderer);
-  VideoRendererInterface* GetRenderer();
+  VideoRendererWrapperInterface* GetRenderer();
 
  protected:
   VideoTrackProxy(const std::string& label,

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_

third_party_mods/libjingle/source/talk/app/webrtc_dev/peerconnectionsignaling.cc

@@ -297,30 +297,32 @@ 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.
+    scoped_refptr<MediaStreamTrackListInterface<AudioTrackInterface> >
-    for (size_t j = 0; j < tracks->count(); ++j) {
+        audio_tracks = stream->audio_tracks();
-      scoped_refptr<MediaStreamTrackInterface> track = tracks->at(j);
+    // For each audio track in the stream, add it to the MediaSessionOptions.
-      if (MediaStreamTrackInterface::kAudio == track->type()) {
+    for (size_t j = 0; j < audio_tracks->count(); ++j) {
-        // TODO(perkj): Better ssrc?
+      scoped_refptr<MediaStreamTrackInterface> track = audio_tracks->at(j);
-        // 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()) {
+
+    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_);  // TODO(perkj): Better ssrc?
+        track->set_ssrc(++ssrc_counter_);
       options->video_sources.push_back(cricket::SourceParam(track->ssrc(),
                                                             track->label(),
                                                             stream->label()));
     }
   }
 }
-}
 
 // Updates or Creates remote MediaStream objects given a
 // remote SessionDesription.
@@ -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(
+      scoped_refptr<MediaStreamTrackListInterface<AudioTrackInterface> >
-          old_stream->tracks());
+      audio_tracklist(old_stream->audio_tracks());
-      for (size_t j = 0; j < tracklist->count(); ++j) {
+      for (size_t j = 0; j < audio_tracklist->count(); ++j) {
-        tracklist->at(j)->set_state(MediaStreamTrackInterface::kEnded);
+        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,20 +460,22 @@ 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.
-
+    // Update tracks based on its type.
-    for (size_t j = 0; j < tracklist->count(); ++j) {
+    for (size_t j = 0; j < audiotracklist->count(); ++j) {
-      scoped_refptr<MediaStreamTrackInterface> track = tracklist->at(j);
+      scoped_refptr<MediaStreamTrackInterface> track = audiotracklist->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);
@@ -478,14 +487,16 @@ void PeerConnectionSignaling::UpdateSendingLocalStreams(
       track->set_state(MediaStreamTrackInterface::kLive);
       stream_ok = true;
     }
-      if (MediaStreamTrackInterface::kVideo == track->type()) {
+
+    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);
@@ -497,7 +508,7 @@ void PeerConnectionSignaling::UpdateSendingLocalStreams(
       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(
+      scoped_refptr<MediaStreamTrackListInterface<AudioTrackInterface> >
-          old_stream->tracks());
+          audio_tracklist(old_stream->audio_tracks());
-      for (size_t j = 0; j < tracklist->count(); ++j) {
+      for (size_t j = 0; j < audio_tracklist->count(); ++j) {
-        tracklist->at(j)->set_state(MediaStreamTrackInterface::kEnded);
+        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);
       }
     }
   }

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.

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);

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),
+    : MediaTrack<LocalVideoTrackInterface>(label, ssrc),
-      label_(label),
-      ssrc_(ssrc),
-      state_(kInitializing),
       video_device_(NULL) {
 }
 
 VideoTrack::VideoTrack(const std::string& label,
                        VideoCaptureModule* video_device)
-    : enabled_(true),
+    : MediaTrack<LocalVideoTrackInterface>(label, 0),
-      label_(label),
-      ssrc_(0),
-      state_(kInitializing),
       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) {

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);
+  virtual void SetRenderer(VideoRendererWrapperInterface* renderer);
-  VideoRendererInterface* GetRenderer();
+  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

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,19 +343,15 @@ void Conductor::UIThreadCallback(int msg_id, void* data) {
       webrtc::MediaStreamInterface* stream =
           reinterpret_cast<webrtc::MediaStreamInterface*>(
           data);
-      scoped_refptr<webrtc::MediaStreamTrackListInterface> tracks =
+      scoped_refptr<webrtc::MediaStreamTrackListInterface<
-          stream->tracks();
+      webrtc::VideoTrackInterface> > tracks = stream->video_tracks();
       for (size_t i = 0; i < tracks->count(); ++i) {
-        if (tracks->at(i)->type() ==
+        webrtc::VideoTrackInterface* track = tracks->at(i);
-            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(
+        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.
       if (active_streams_.empty())