MediaStreamHandler implements eventhandlers for streams and tracks.

Sets local and remote renderer and capture device.

BUG=
TEST=

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

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

third_party_mods/libjingle/libjingle.gyp

@@ -686,8 +686,11 @@
             '<(libjingle_mods)/source/talk/app/webrtc_dev/audiotrackimpl.h',
             '<(libjingle_mods)/source/talk/app/webrtc_dev/audiotrackimpl.cc',
             '<(libjingle_mods)/source/talk/app/webrtc_dev/mediastream.h',
+            '<(libjingle_mods)/source/talk/app/webrtc_dev/mediastreamhandler.cc',
+            '<(libjingle_mods)/source/talk/app/webrtc_dev/mediastreamhandler.h',
+            '<(libjingle_mods)/source/talk/app/webrtc_dev/mediastreamprovider.h',
             '<(libjingle_mods)/source/talk/app/webrtc_dev/mediastreamimpl.h',
-            '<(libjingle_mods)/source/talk/app/webrtc_dev/mediastreamimpl.cc',            
+            '<(libjingle_mods)/source/talk/app/webrtc_dev/mediastreamimpl.cc',
             '<(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',
@@ -718,6 +721,7 @@
         ['peer_connection_dev==1', {          
           'dependencies': [
             'libjingle_app',
+            '../../testing/gmock.gyp:gmock',
             '../../testing/gtest.gyp:gtest',
             '../../testing/gtest.gyp:gtest_main',
             # TODO(perkj): Temporary build the client app here to make sure
@@ -746,7 +750,8 @@
             }],
           ], #conditions             
           'sources': [
-            '<(libjingle_mods)/source/talk/app/webrtc_dev/mediastreamimpl_unittest.cc',
+            '<(libjingle_mods)/source/talk/app/webrtc_dev/mediastreamhandler_unittest.cc',
+            '<(libjingle_mods)/source/talk/app/webrtc_dev/mediastreamimpl_unittest.cc',           
             '<(libjingle_mods)/source/talk/app/webrtc_dev/peerconnection_unittests.cc',
             '<(libjingle_mods)/source/talk/app/webrtc_dev/peerconnectionimpl_unittest.cc',
             '<(libjingle_mods)/source/talk/app/webrtc_dev/peerconnectionmanager_unittest.cc',

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

@@ -0,0 +1,284 @@
+/*
+ * 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.
+ */
+
+#include "talk/app/webrtc_dev/mediastreamhandler.h"
+
+#include "talk/app/webrtc_dev/scoped_refptr_msg.h"
+
+#ifdef WEBRTC_RELATIVE_PATH
+#include "modules/video_capture/main/interface/video_capture.h"
+#else
+#include "third_party/webrtc/files/include/video_capture.h"
+#endif
+
+namespace webrtc {
+
+enum {
+  MSG_TRACK_STATECHANGED = 1,
+  MSG_TRACK_RENDERERCHANGED = 2,
+  MSG_TRACK_ENABLEDCHANGED = 3,
+};
+
+typedef talk_base::TypedMessageData<MediaStreamTrack::TrackState>
+    TrackStateMessageData;
+typedef talk_base::TypedMessageData<bool> TrackEnabledMessageData;
+
+VideoTrackHandler::VideoTrackHandler(VideoTrack* track,
+                                     MediaProviderInterface* provider)
+    : provider_(provider),
+      video_track_(track),
+      state_(track->state()),
+      enabled_(track->enabled()),
+      renderer_(track->GetRenderer()),
+      signaling_thread_(talk_base::Thread::Current()) {
+  video_track_->RegisterObserver(this);
+}
+
+VideoTrackHandler::~VideoTrackHandler() {
+  video_track_->UnregisterObserver(this);
+}
+
+void VideoTrackHandler::OnChanged() {
+  if (state_ != video_track_->state()) {
+    state_ = video_track_->state();
+    TrackStateMessageData* state_param(new TrackStateMessageData(state_));
+    signaling_thread_->Post(this, MSG_TRACK_STATECHANGED, state_param);
+  }
+  if (renderer_.get() != video_track_->GetRenderer().get()) {
+    renderer_ = video_track_->GetRenderer();
+    signaling_thread_->Post(this, MSG_TRACK_RENDERERCHANGED);
+  }
+  if (enabled_ != video_track_->enabled()) {
+    enabled_ =video_track_->enabled();
+    TrackEnabledMessageData* enabled_param(
+        new TrackEnabledMessageData(enabled_));
+    signaling_thread_->Post(this, MSG_TRACK_ENABLEDCHANGED, enabled_param);
+  }
+}
+
+void VideoTrackHandler::OnMessage(talk_base::Message* msg) {
+  switch (msg->message_id) {
+    case MSG_TRACK_STATECHANGED: {
+      TrackStateMessageData* data =
+          static_cast<TrackStateMessageData*>(msg->pdata);
+      OnStateChanged(data->data());
+      delete data;
+      break;
+    }
+    case MSG_TRACK_RENDERERCHANGED: {
+      OnRendererChanged();
+      break;
+    }
+    case MSG_TRACK_ENABLEDCHANGED: {
+      TrackEnabledMessageData* data =
+          static_cast<TrackEnabledMessageData*>(msg->pdata);
+      OnEnabledChanged(data->data());
+      break;
+    }
+  }
+}
+
+LocalVideoTrackHandler::LocalVideoTrackHandler(
+    VideoTrack* track,
+    MediaProviderInterface* provider)
+    : VideoTrackHandler(track, provider) {
+  // If the Renderer is already set we want to start it.
+  if (video_track_->GetRenderer().get())
+    OnRendererChanged();
+}
+
+void LocalVideoTrackHandler::OnRendererChanged() {
+  scoped_refptr<VideoRenderer> renderer(video_track_->GetRenderer());
+  if (renderer.get())
+    provider_->SetLocalRenderer(video_track_->ssrc(), renderer->renderer());
+  else
+    provider_->SetLocalRenderer(video_track_->ssrc(), NULL);
+}
+
+void LocalVideoTrackHandler::OnStateChanged(
+    MediaStreamTrack::TrackState state) {
+  LocalVideoTrack* track = static_cast<LocalVideoTrack*>(video_track_.get());
+  if (state == VideoTrack::kLive) {
+    provider_->SetCaptureDevice(track->ssrc(), track->GetVideoCapture());
+  }
+}
+
+void LocalVideoTrackHandler::OnEnabledChanged(bool enabled) {
+  // TODO(perkj) What should happen when enabled is changed?
+}
+
+RemoteVideoTrackHandler::RemoteVideoTrackHandler(
+    VideoTrack* track,
+    MediaProviderInterface* provider)
+    : VideoTrackHandler(track, provider) {
+}
+
+void RemoteVideoTrackHandler::OnRendererChanged() {
+  scoped_refptr<VideoRenderer> renderer(video_track_->GetRenderer());
+  if (renderer.get())
+    provider_->SetRemoteRenderer(video_track_->ssrc(), renderer->renderer());
+  else
+    provider_->SetRemoteRenderer(video_track_->ssrc(), NULL);
+}
+
+void RemoteVideoTrackHandler::OnStateChanged(
+    MediaStreamTrack::TrackState state) {
+}
+
+void RemoteVideoTrackHandler::OnEnabledChanged(bool enabled) {
+  // TODO(perkj): What should happen when enabled is changed?
+}
+
+MediaStreamHandler::MediaStreamHandler(MediaStream* stream,
+                                       MediaProviderInterface* provider)
+    : stream_(stream),
+      provider_(provider) {
+}
+
+MediaStreamHandler::~MediaStreamHandler() {
+  for (VideoTrackHandlers::iterator it = video_handlers_.begin();
+       it != video_handlers_.end(); ++it) {
+    delete *it;
+  }
+}
+
+MediaStream* MediaStreamHandler::stream() {
+  return stream_.get();
+}
+
+void MediaStreamHandler::OnChanged() {
+  // TODO(perkj): Implement state change and enabled changed.
+}
+
+
+LocalMediaStreamHandler::LocalMediaStreamHandler(
+    MediaStream* stream,
+    MediaProviderInterface* provider)
+    : MediaStreamHandler(stream, provider) {
+  scoped_refptr<MediaStreamTrackList> tracklist(stream->tracks());
+
+  for (size_t j = 0; j < tracklist->count(); ++j) {
+    scoped_refptr<MediaStreamTrack> track = tracklist->at(j);
+    if (track->kind().compare(kVideoTrackKind) == 0) {
+      LocalVideoTrack* video_track =
+          static_cast<LocalVideoTrack*> (track.get());
+      VideoTrackHandler* handler(new LocalVideoTrackHandler(video_track,
+                                                            provider));
+      video_handlers_.push_back(handler);
+    }
+  }
+}
+
+RemoteMediaStreamHandler::RemoteMediaStreamHandler(
+    MediaStream* stream,
+    MediaProviderInterface* provider)
+    : MediaStreamHandler(stream, provider) {
+  scoped_refptr<MediaStreamTrackList> tracklist(stream->tracks());
+
+  for (size_t j = 0; j < tracklist->count(); ++j) {
+    scoped_refptr<MediaStreamTrack> track = tracklist->at(j);
+    if (track->kind().compare(kVideoTrackKind) == 0) {
+      VideoTrack* video_track = static_cast<VideoTrack*> (track.get());
+      VideoTrackHandler* handler(new RemoteVideoTrackHandler(video_track,
+                                                             provider));
+      video_handlers_.push_back(handler);
+    }
+  }
+}
+
+MediaStreamHandlers::MediaStreamHandlers(MediaProviderInterface* provider)
+    : provider_(provider) {
+}
+
+MediaStreamHandlers::~MediaStreamHandlers() {
+  for (StreamHandlerList::iterator it = remote_streams_handlers_.begin();
+       it != remote_streams_handlers_.end(); ++it) {
+    delete *it;
+  }
+  for (StreamHandlerList::iterator it = local_streams_handlers_.begin();
+       it != local_streams_handlers_.end(); ++it) {
+    delete *it;
+  }
+}
+
+void MediaStreamHandlers::AddRemoteStream(MediaStream* stream) {
+  RemoteMediaStreamHandler* handler = new RemoteMediaStreamHandler(stream,
+                                                                   provider_);
+  remote_streams_handlers_.push_back(handler);
+}
+
+void MediaStreamHandlers::RemoveRemoteStream(MediaStream* stream) {
+  StreamHandlerList::iterator it = remote_streams_handlers_.begin();
+  for (; it != remote_streams_handlers_.end(); ++it) {
+    if ((*it)->stream() == stream) {
+      delete *it;
+      break;
+    }
+  }
+  ASSERT(it != remote_streams_handlers_.end());
+  remote_streams_handlers_.erase(it);
+}
+
+void MediaStreamHandlers::CommitLocalStreams(StreamCollection* streams) {
+  // Iterate the old list of local streams.
+  // If its not found in the new collection it have been removed.
+  // We can not erase from the old collection at the same time as we iterate.
+  // That is what the ugly while(1) fix.
+  while (1) {
+    StreamHandlerList::iterator it = local_streams_handlers_.begin();
+    for (; it != local_streams_handlers_.end(); ++it) {
+      if (streams->find((*it)->stream()->label()) == NULL) {
+        delete *it;
+        break;
+      }
+    }
+    if (it != local_streams_handlers_.end()) {
+      local_streams_handlers_.erase(it);
+      continue;
+    }
+    break;
+  }
+
+  // Iterate the new collection of local streams.
+  // If its not found in the old collection it have been added.
+  for (size_t j = 0; j < streams->count(); ++j) {
+    scoped_refptr<MediaStream> stream = streams->at(j);
+    StreamHandlerList::iterator it = local_streams_handlers_.begin();
+    for (; it != local_streams_handlers_.end(); ++it) {
+      if (stream.get() == (*it)->stream())
+        break;
+    }
+    if (it == local_streams_handlers_.end()) {
+      LocalMediaStreamHandler* handler = new LocalMediaStreamHandler(
+          stream, provider_);
+      local_streams_handlers_.push_back(handler);
+    }
+  }
+};
+
+
+}  // namespace webrtc

third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamhandler.h

@@ -0,0 +1,139 @@
+/*
+ * 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.
+ */
+
+// This file contains classes for listening on changes on MediaStreams and
+// MediaTracks and making sure appropriate action is taken.
+// Example: If a user sets a rendererer on a local video track the renderer is
+// connected to the appropriate camera.
+
+#ifndef TALK_APP_WEBRTC_DEV_MEDIASTREAMHANDLER_H_
+#define TALK_APP_WEBRTC_DEV_MEDIASTREAMHANDLER_H_
+
+#include <list>
+#include <vector>
+
+#include "talk/app/webrtc_dev/mediastream.h"
+#include "talk/app/webrtc_dev/mediastreamprovider.h"
+#include "talk/app/webrtc_dev/peerconnection.h"
+#include "talk/base/thread.h"
+
+namespace webrtc {
+
+// VideoTrackHandler listen to events on a VideoTrack instance and
+// executes the requested change.
+class VideoTrackHandler : public Observer,
+                          public talk_base::MessageHandler {
+ public:
+  VideoTrackHandler(VideoTrack* track,
+                    MediaProviderInterface* provider);
+  virtual ~VideoTrackHandler();
+  virtual void OnChanged();
+
+ protected:
+  virtual void OnMessage(talk_base::Message* msg);
+
+  virtual void OnRendererChanged() = 0;
+  virtual void OnStateChanged(MediaStreamTrack::TrackState state) = 0;
+  virtual void OnEnabledChanged(bool enabled) = 0;
+
+  MediaProviderInterface* provider_;
+  scoped_refptr<VideoTrack> video_track_;
+
+ private:
+  MediaStreamTrack::TrackState state_;
+  bool enabled_;
+  scoped_refptr<VideoRenderer> renderer_;
+  talk_base::Thread* signaling_thread_;
+};
+
+class LocalVideoTrackHandler : public VideoTrackHandler {
+ public:
+  LocalVideoTrackHandler(VideoTrack* track,
+                         MediaProviderInterface* provider);
+
+ protected:
+  virtual void OnRendererChanged();
+  virtual void OnStateChanged(MediaStreamTrack::TrackState state);
+  virtual void OnEnabledChanged(bool enabled);
+};
+
+class RemoteVideoTrackHandler : public VideoTrackHandler {
+ public:
+  RemoteVideoTrackHandler(VideoTrack* track,
+                          MediaProviderInterface* provider);
+
+ protected:
+  virtual void OnRendererChanged();
+  virtual void OnStateChanged(MediaStreamTrack::TrackState state);
+  virtual void OnEnabledChanged(bool enabled);
+};
+
+class MediaStreamHandler : public Observer {
+ public:
+  MediaStreamHandler(MediaStream* stream, MediaProviderInterface* provider);
+  ~MediaStreamHandler();
+  MediaStream* stream();
+  virtual void OnChanged();
+
+ protected:
+  MediaProviderInterface* provider_;
+  typedef std::vector<VideoTrackHandler*> VideoTrackHandlers;
+  VideoTrackHandlers video_handlers_;
+  scoped_refptr<MediaStream> stream_;
+};
+
+class LocalMediaStreamHandler : public MediaStreamHandler {
+ public:
+  LocalMediaStreamHandler(MediaStream* stream,
+                          MediaProviderInterface* provider);
+};
+
+class RemoteMediaStreamHandler : public MediaStreamHandler {
+ public:
+  RemoteMediaStreamHandler(MediaStream* stream,
+                           MediaProviderInterface* provider);
+};
+
+class MediaStreamHandlers {
+ public:
+  explicit MediaStreamHandlers(MediaProviderInterface* provider);
+  ~MediaStreamHandlers();
+  void AddRemoteStream(MediaStream* stream);
+  void RemoveRemoteStream(MediaStream* stream);
+  void CommitLocalStreams(StreamCollection* streams);
+
+ private:
+  typedef std::list<MediaStreamHandler*> StreamHandlerList;
+  StreamHandlerList local_streams_handlers_;
+  StreamHandlerList remote_streams_handlers_;
+  MediaProviderInterface* provider_;
+};
+
+}  // namespace webrtc
+
+#endif  // TALK_APP_WEBRTC_MEDIASTREAMOBSERVER_H_
+

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

@@ -0,0 +1,142 @@
+/*
+ * 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.
+ */
+
+#include <string>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "talk/app/webrtc_dev/mediastream.h"
+#include "talk/app/webrtc_dev/mediastreamhandler.h"
+#include "talk/app/webrtc_dev/streamcollectionimpl.h"
+#include "talk/base/thread.h"
+
+using ::testing::Exactly;
+
+static const char kStreamLabel1[] = "local_stream_1";
+static const char kVideoDeviceName[] = "dummy_video_cam_1";
+static const uint32 kVideoSsrc = 1;
+
+namespace webrtc {
+
+// Helper class to test MediaStreamHandler.
+class MockMediaProvier : public MediaProviderInterface {
+ public:
+  MOCK_METHOD1(SetCaptureDevice, void(uint32 ssrc));
+  MOCK_METHOD1(SetLocalRenderer, void(uint32 ssrc));
+  MOCK_METHOD1(SetRemoteRenderer, void(uint32 ssrc));
+
+  virtual void SetCaptureDevice(uint32 ssrc, VideoCaptureModule* camera) {
+    SetCaptureDevice(ssrc);
+  }
+  virtual void SetLocalRenderer(uint32 ssrc,
+                                cricket::VideoRenderer* renderer) {
+    SetLocalRenderer(ssrc);
+  }
+
+  virtual void SetRemoteRenderer(uint32 ssrc,
+                                 cricket::VideoRenderer* renderer) {
+    SetRemoteRenderer(ssrc);
+  }
+  ~MockMediaProvier() {}
+};
+
+TEST(MediaStreamHandlerTest, LocalStreams) {
+  // Create a local stream.
+  std::string label(kStreamLabel1);
+  scoped_refptr<LocalMediaStream> stream(CreateLocalMediaStream(label));
+  scoped_refptr<LocalVideoTrack> video_track(CreateLocalVideoTrack(
+      kVideoDeviceName, NULL));
+  video_track->set_ssrc(kVideoSsrc);
+  EXPECT_TRUE(stream->AddTrack(video_track));
+  scoped_refptr<VideoRenderer> renderer(CreateVideoRenderer(NULL));
+  video_track->SetRenderer(renderer);
+
+  MockMediaProvier provider;
+  MediaStreamHandlers handlers(&provider);
+
+  scoped_refptr<StreamCollectionImpl> collection(
+      StreamCollectionImpl::Create());
+  collection->AddStream(stream);
+
+  EXPECT_CALL(provider, SetLocalRenderer(kVideoSsrc))
+      .Times(Exactly(1));
+  EXPECT_CALL(provider, SetCaptureDevice(kVideoSsrc))
+      .Times(Exactly(1));
+  handlers.CommitLocalStreams(collection);
+
+  video_track->set_state(MediaStreamTrack::kLive);
+  // Process posted messages.
+  talk_base::Thread::Current()->ProcessMessages(1);
+
+  collection->RemoveStream(stream);
+  handlers.CommitLocalStreams(collection);
+
+  video_track->set_state(MediaStreamTrack::kEnded);
+  // Process posted messages.
+  talk_base::Thread::Current()->ProcessMessages(1);
+}
+
+TEST(MediaStreamHandlerTest, RemoteStreams) {
+  // Create a local stream. We use local stream in this test as well because
+  // they are easier to create.
+  // LocalMediaStreams inherit from MediaStreams.
+  std::string label(kStreamLabel1);
+  scoped_refptr<LocalMediaStream> stream(CreateLocalMediaStream(label));
+  scoped_refptr<LocalVideoTrack> video_track(CreateLocalVideoTrack(
+      kVideoDeviceName, NULL));
+  video_track->set_ssrc(kVideoSsrc);
+  EXPECT_TRUE(stream->AddTrack(video_track));
+
+  MockMediaProvier provider;
+  MediaStreamHandlers handlers(&provider);
+
+  handlers.AddRemoteStream(stream);
+
+  EXPECT_CALL(provider, SetRemoteRenderer(kVideoSsrc))
+      .Times(Exactly(2));
+
+  // Set the renderer once.
+  scoped_refptr<VideoRenderer> renderer(CreateVideoRenderer(NULL));
+    video_track->SetRenderer(renderer);
+  talk_base::Thread::Current()->ProcessMessages(1);
+
+  // Change the already set renderer.
+  renderer = CreateVideoRenderer(NULL);
+    video_track->SetRenderer(renderer);
+  talk_base::Thread::Current()->ProcessMessages(1);
+
+  handlers.RemoveRemoteStream(stream);
+
+  // Change the renderer after the stream have been removed from handler.
+  // This should not trigger a call to SetRemoteRenderer.
+  renderer = CreateVideoRenderer(NULL);
+    video_track->SetRenderer(renderer);
+  // Process posted messages.
+  talk_base::Thread::Current()->ProcessMessages(1);
+}
+
+}  // namespace webrtc

third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamprovider.h

@@ -0,0 +1,51 @@
+/*
+ * 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_DEV_MEDIASTREAMPROVIDER_H_
+#define TALK_APP_WEBRTC_DEV_MEDIASTREAMPROVIDER_H_
+
+#include "talk/app/webrtc_dev/mediastream.h"
+
+namespace webrtc {
+
+// Interface for setting media devices on a certain MediaTrack.
+// This interface is called by classes in mediastreamhandler.h to
+// set new devices.
+class MediaProviderInterface {
+ public:
+  virtual void SetCaptureDevice(uint32 ssrc, VideoCaptureModule* camera) = 0;
+  virtual void SetLocalRenderer(uint32 ssrc,
+                                cricket::VideoRenderer* renderer) = 0;
+  virtual void SetRemoteRenderer(uint32 ssrc,
+                                 cricket::VideoRenderer* renderer) = 0;
+ protected:
+  virtual ~MediaProviderInterface() {}
+};
+
+}  // namespace webrtc
+
+#endif  // TALK_APP_WEBRTC_DEV_MEDIASTREAMPROVIDER_H_