diff --git a/third_party_mods/libjingle/libjingle.gyp b/third_party_mods/libjingle/libjingle.gyp index f59b5a0605..4eae08dd54 100644 --- a/third_party_mods/libjingle/libjingle.gyp +++ b/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', 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 new file mode 100644 index 0000000000..b6931d503b --- /dev/null +++ b/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 + TrackStateMessageData; +typedef talk_base::TypedMessageData 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(msg->pdata); + OnStateChanged(data->data()); + delete data; + break; + } + case MSG_TRACK_RENDERERCHANGED: { + OnRendererChanged(); + break; + } + case MSG_TRACK_ENABLEDCHANGED: { + TrackEnabledMessageData* data = + static_cast(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 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(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 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 tracklist(stream->tracks()); + + for (size_t j = 0; j < tracklist->count(); ++j) { + scoped_refptr track = tracklist->at(j); + if (track->kind().compare(kVideoTrackKind) == 0) { + LocalVideoTrack* video_track = + static_cast (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 tracklist(stream->tracks()); + + for (size_t j = 0; j < tracklist->count(); ++j) { + scoped_refptr track = tracklist->at(j); + if (track->kind().compare(kVideoTrackKind) == 0) { + VideoTrack* video_track = static_cast (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 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 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 new file mode 100644 index 0000000000..90e3480cc6 --- /dev/null +++ b/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 +#include + +#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 video_track_; + + private: + MediaStreamTrack::TrackState state_; + bool enabled_; + scoped_refptr 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 VideoTrackHandlers; + VideoTrackHandlers video_handlers_; + scoped_refptr 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 StreamHandlerList; + StreamHandlerList local_streams_handlers_; + StreamHandlerList remote_streams_handlers_; + MediaProviderInterface* provider_; +}; + +} // namespace webrtc + +#endif // TALK_APP_WEBRTC_MEDIASTREAMOBSERVER_H_ + 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 new file mode 100644 index 0000000000..c1bc7eb083 --- /dev/null +++ b/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 + +#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 stream(CreateLocalMediaStream(label)); + scoped_refptr video_track(CreateLocalVideoTrack( + kVideoDeviceName, NULL)); + video_track->set_ssrc(kVideoSsrc); + EXPECT_TRUE(stream->AddTrack(video_track)); + scoped_refptr renderer(CreateVideoRenderer(NULL)); + video_track->SetRenderer(renderer); + + MockMediaProvier provider; + MediaStreamHandlers handlers(&provider); + + scoped_refptr 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 stream(CreateLocalMediaStream(label)); + scoped_refptr 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 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 diff --git a/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamprovider.h b/third_party_mods/libjingle/source/talk/app/webrtc_dev/mediastreamprovider.h new file mode 100644 index 0000000000..d944961f14 --- /dev/null +++ b/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_