Merge from git-svn r115 to master branch
Conflicts:
talk/libjingle.scons
talk/main.scons
talk/site_scons/talk.py
Change-Id: I173ec93b4b4a7aca68663dc756101325f280abf4
diff --git a/AUTHORS b/AUTHORS
index e491a9e..cbe3b77 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -1 +1,4 @@
Google Inc.
+Eric Rescorla, RTFM Inc.
+Pali Rohar
+Robert Nagy
diff --git a/CHANGELOG b/CHANGELOG
index 1f64bb0..ecc343f 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,5 +1,62 @@
Libjingle
+0.6.12 - Feb 07, 2012
+ - PeerConnection client for windows.
+ - Bug fixes.
+
+0.6.11 - Jan 24, 2012
+ - Improved ipv6 support.
+ - Initial DTLS support.
+ - Initial BUNDLE support.
+ - Update Jingle protocol to multistream.
+ - WebRTC Bug fixes.
+
+0.6.10 - Jan 11, 2012
+ - Support fullscreen screencasting of secondary displays.
+ - Add IPv6 support for libjingle's STUN components.
+ - Enable SRTP in PeerConnection v1.
+ - Bug fixes.
+
+0.6.9 - Jan 09, 2012
+ - Enable SRTP in PeerConnection.
+ - Bug fixes.
+
+0.6.8 - Dec 22, 2011
+ - Add a lot of unit tests
+ - Add a lot of older files to base/ and xmpp/
+ - Add examples/pcp add examples/peerconnection
+ - Improve support for IPV6
+
+0.6.7 - Dec 21, 2011
+ - Release new PeerConnection implementation to app/webrtc.
+ - Bug fixes.
+
+0.6.6 - Dec 14, 2011
+ - Fix support for rtcp multiplexing (aka rtcp-mux).
+ - Add more support for FreeBSD and OpenBSD.
+ - Add more unit tests to session/phone.
+ - Add session/phone/mediarecorder.cc.
+ - Fixed httpportallocator tests.
+
+0.6.5 - Dec 8, 2011
+ - Add IPv6 support in SocketAddress.
+ - Change PeerConnectionFactory inteface.
+ - Bug fixes.
+
+0.6.4 - Nov 30, 2011
+ - Branch app/webrtc to app/webrtcv1.
+ - Add more base unit tests.
+ - Add xmllite unit tests.
+ - Refactoring and bug fixes
+
+0.6.3 - Oct 26, 2011
+ - Add media unit tests
+ - Improve OpenSSL support
+ - Add SSL unit tests
+ - Add DTLS support to SslStreamAdapter
+ - Add initial support for media processors
+ - Updated WebRTC voice and video engines
+
0.6.2 - Oct 7, 2011
- Increase the video rtp buffer.
- Disable sound system for chromium build.
diff --git a/README b/README
index f40d4ea..638d002 100644
--- a/README
+++ b/README
@@ -95,13 +95,22 @@
copy talk\third_party\srtp\config.hw talk\third_party\srtp\crypto\include\config.h
2.2 Build Libjingle under Linux or OS X
- * First, make sure the SCONS_DIR environment variable is set correctly.
+ * On Linux, you need to install libssl-dev, libasound2-dev and gtk+2.0.
+ * Some optional new features in OpenSSL are only available in OpenSSL v1.0
+ and above. To build with new OpenSSL features, you need to add the
+ "HAS_OPENSSL_1_0" to the cppdefine under the
+ "talk.Library(env, name = jingle..." section in the "libjingle.scons" file.
+ Then download the OpenSSL v1.0 from the following URL:
+ http://www.openssl.org/source/openssl-1.0.0e.tar.gz
+ Unzip the downloaded package to the "third_party/openssl", such that it creates
+ the directory "third_party/openssl/include/", etc.
+ * To build Libjingle, first make sure the SCONS_DIR environment variable
+ is set correctly.
* Second, run talk/third_party/expat-2.0.1/configure and
talk/third_party/srtp/configure.
* Third, go to the talk/ directory and run $path_to_swtoolkit/hammer.sh. Run
$path_to_swtoolkit/hammer.sh --help for information on how to build for
different modes.
- * On Linux, you need to install libssl-dev, libasound2-dev and gtk+2.0.
2.3 Build Libjingle under Windows
* First, make sure the SCONS_DIR environment variable is set correctly and
diff --git a/talk/app/webrtc/audiotrackimpl.cc b/talk/app/webrtc/audiotrackimpl.cc
new file mode 100644
index 0000000..6fcef4a
--- /dev/null
+++ b/talk/app/webrtc/audiotrackimpl.cc
@@ -0,0 +1,71 @@
+/*
+ * libjingle
+ * Copyright 2004--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/audiotrackimpl.h"
+
+#include <string>
+
+namespace webrtc {
+
+static const char kAudioTrackKind[] = "audio";
+
+AudioTrack::AudioTrack(const std::string& label)
+ : MediaStreamTrack<LocalAudioTrackInterface>(label),
+ audio_device_(NULL) {
+}
+
+AudioTrack::AudioTrack(const std::string& label,
+ AudioDeviceModule* audio_device)
+ : MediaStreamTrack<LocalAudioTrackInterface>(label),
+ audio_device_(audio_device) {
+}
+
+ // Get the AudioDeviceModule associated with this track.
+AudioDeviceModule* AudioTrack::GetAudioDevice() {
+ return audio_device_.get();
+}
+
+ // Implement MediaStreamTrack
+std::string AudioTrack::kind() const {
+ return kAudioTrackKind;
+}
+
+talk_base::scoped_refptr<AudioTrack> AudioTrack::CreateRemote(
+ const std::string& label) {
+ talk_base::RefCountedObject<AudioTrack>* track =
+ new talk_base::RefCountedObject<AudioTrack>(label);
+ return track;
+}
+
+talk_base::scoped_refptr<AudioTrack> AudioTrack::CreateLocal(
+ const std::string& label,
+ AudioDeviceModule* audio_device) {
+ talk_base::RefCountedObject<AudioTrack>* track =
+ new talk_base::RefCountedObject<AudioTrack>(label, audio_device);
+ return track;
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/audiotrackimpl.h b/talk/app/webrtc/audiotrackimpl.h
new file mode 100644
index 0000000..df3b3cb
--- /dev/null
+++ b/talk/app/webrtc/audiotrackimpl.h
@@ -0,0 +1,70 @@
+/*
+ * 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_AUDIOTRACKIMPL_H_
+#define TALK_APP_WEBRTC_AUDIOTRACKIMPL_H_
+
+#include "talk/app/webrtc/mediastream.h"
+#include "talk/app/webrtc/mediatrackimpl.h"
+#include "talk/app/webrtc/notifierimpl.h"
+#include "talk/base/scoped_ref_ptr.h"
+
+#ifdef WEBRTC_RELATIVE_PATH
+#include "modules/audio_device/main/interface/audio_device.h"
+#else
+#include "third_party/webrtc/files/include/audio_device.h"
+#endif
+
+namespace webrtc {
+
+class AudioTrack : public MediaStreamTrack<LocalAudioTrackInterface> {
+ public:
+ // Creates a remote audio track.
+ static talk_base::scoped_refptr<AudioTrack> CreateRemote(
+ const std::string& label);
+ // Creates a local audio track.
+ static talk_base::scoped_refptr<AudioTrack> CreateLocal(
+ const std::string& label,
+ AudioDeviceModule* audio_device);
+
+ // Get the AudioDeviceModule associated with this track.
+ virtual AudioDeviceModule* GetAudioDevice();
+
+ // Implement MediaStreamTrack
+ virtual std::string kind() const;
+
+ protected:
+ explicit AudioTrack(const std::string& label);
+ AudioTrack(const std::string& label, AudioDeviceModule* audio_device);
+
+ private:
+ talk_base::scoped_refptr<AudioDeviceModule> audio_device_;
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_AUDIOTRACKIMPL_H_
diff --git a/talk/app/webrtc/fakeportallocatorfactory.h b/talk/app/webrtc/fakeportallocatorfactory.h
new file mode 100644
index 0000000..85885d4
--- /dev/null
+++ b/talk/app/webrtc/fakeportallocatorfactory.h
@@ -0,0 +1,60 @@
+/*
+ * 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 defines a fake port allocator factory used for testing.
+// This implementation creates instances of cricket::FakePortAllocator.
+
+#ifndef TALK_APP_WEBRTC_FAKEPORTALLOCATORFACTORY_H_
+#define TALK_APP_WEBRTC_FAKEPORTALLOCATORFACTORY_H_
+
+#include "talk/app/webrtc/peerconnection.h"
+#include "talk/p2p/client/fakeportallocator.h"
+
+namespace webrtc {
+
+class FakePortAllocatorFactory : public PortAllocatorFactoryInterface {
+ public:
+ static PortAllocatorFactoryInterface* Create() {
+ talk_base::RefCountedObject<FakePortAllocatorFactory>* allocator =
+ new talk_base::RefCountedObject<FakePortAllocatorFactory>();
+ return allocator;
+ }
+
+ virtual cricket::PortAllocator* CreatePortAllocator(
+ const std::vector<StunConfiguration>& stun_configurations,
+ const std::vector<TurnConfiguration>& turn_configurations) {
+ return new cricket::FakePortAllocator(talk_base::Thread::Current(), NULL);
+ }
+
+ protected:
+ FakePortAllocatorFactory() {}
+ ~FakePortAllocatorFactory() {}
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_FAKEPORTALLOCATORFACTORY_H_
diff --git a/talk/app/webrtc/mediastream.h b/talk/app/webrtc/mediastream.h
new file mode 100644
index 0000000..5db591a
--- /dev/null
+++ b/talk/app/webrtc/mediastream.h
@@ -0,0 +1,189 @@
+/*
+ * 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 interfaces for MediaStream and MediaTrack. These
+// interfaces are used for implementing MediaStream and MediaTrack as defined
+// in http://dev.w3.org/2011/webrtc/editor/webrtc.html#stream-api. These
+// interfaces must be used only with PeerConnection. PeerConnectionManager
+// interface provides the factory methods to create MediaStream and MediaTracks.
+
+#ifndef TALK_APP_WEBRTC_MEDIASTREAM_H_
+#define TALK_APP_WEBRTC_MEDIASTREAM_H_
+
+#include <string>
+
+#include "talk/base/basictypes.h"
+#include "talk/base/refcount.h"
+#include "talk/base/scoped_ref_ptr.h"
+
+namespace cricket {
+
+class VideoCapturer;
+class VideoRenderer;
+class MediaEngine;
+
+} // namespace cricket
+
+namespace webrtc {
+
+class AudioDeviceModule;
+
+// Generic observer interface.
+class ObserverInterface {
+ public:
+ virtual void OnChanged() = 0;
+
+ protected:
+ virtual ~ObserverInterface() {}
+};
+
+class NotifierInterface {
+ public:
+ virtual void RegisterObserver(ObserverInterface* observer) = 0;
+ virtual void UnregisterObserver(ObserverInterface* observer) = 0;
+
+ virtual ~NotifierInterface() {}
+};
+
+// Information about a track.
+class MediaStreamTrackInterface : public talk_base::RefCountInterface,
+ public NotifierInterface {
+ public:
+ enum TrackState {
+ kInitializing, // Track is beeing negotiated.
+ kLive = 1, // Track alive
+ kEnded = 2, // Track have ended
+ kFailed = 3, // Track negotiation failed.
+ };
+
+ virtual std::string kind() const = 0;
+ virtual std::string label() const = 0;
+ virtual bool enabled() const = 0;
+ virtual TrackState state() const = 0;
+ virtual bool set_enabled(bool enable) = 0;
+ // These methods should be called by implementation only.
+ virtual bool set_state(TrackState new_state) = 0;
+};
+
+// Reference counted wrapper for a VideoRenderer.
+class VideoRendererWrapperInterface : public talk_base::RefCountInterface {
+ public:
+ virtual cricket::VideoRenderer* renderer() = 0;
+
+ protected:
+ virtual ~VideoRendererWrapperInterface() {}
+};
+
+// Creates a reference counted object of type cricket::VideoRenderer.
+// webrtc::VideoRendererWrapperInterface take ownership of
+// cricket::VideoRenderer.
+talk_base::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.
+ // The VideoRendererInterface is stored as a scoped_refptr. This means that
+ // it is not allowed to call delete renderer after this API has been called.
+ virtual void SetRenderer(VideoRendererWrapperInterface* renderer) = 0;
+
+ // Get the VideoRenderer associated with this track.
+ virtual VideoRendererWrapperInterface* GetRenderer() = 0;
+
+ protected:
+ virtual ~VideoTrackInterface() {}
+};
+
+class LocalVideoTrackInterface : public VideoTrackInterface {
+ public:
+ // Get the VideoCapturer associated with the track.
+ virtual cricket::VideoCapturer* GetVideoCapture() = 0;
+
+ protected:
+ virtual ~LocalVideoTrackInterface() {}
+};
+
+class AudioTrackInterface : public MediaStreamTrackInterface {
+ public:
+ protected:
+ virtual ~AudioTrackInterface() {}
+};
+
+class LocalAudioTrackInterface : public AudioTrackInterface {
+ public:
+ // Get the AudioDeviceModule associated with this track.
+ virtual AudioDeviceModule* GetAudioDevice() = 0;
+ protected:
+ virtual ~LocalAudioTrackInterface() {}
+};
+
+// List of of tracks.
+template <class TrackType>
+class MediaStreamTrackListInterface : public talk_base::RefCountInterface {
+ public:
+ virtual size_t count() = 0;
+ virtual TrackType* at(size_t index) = 0;
+
+ protected:
+ virtual ~MediaStreamTrackListInterface() {}
+};
+
+typedef MediaStreamTrackListInterface<AudioTrackInterface> AudioTracks;
+typedef MediaStreamTrackListInterface<VideoTrackInterface> VideoTracks;
+
+class MediaStreamInterface : public talk_base::RefCountInterface,
+ public NotifierInterface {
+ public:
+ virtual std::string label() const = 0;
+ virtual AudioTracks* audio_tracks() = 0;
+ virtual VideoTracks* video_tracks() = 0;
+
+ enum ReadyState {
+ kInitializing,
+ kLive = 1, // Stream alive
+ kEnded = 2, // Stream have ended
+ };
+
+ virtual ReadyState ready_state() = 0;
+
+ // These methods should be called by implementation only.
+ virtual void set_ready_state(ReadyState state) = 0;
+
+ protected:
+ virtual ~MediaStreamInterface() {}
+};
+
+class LocalMediaStreamInterface : public MediaStreamInterface {
+ public:
+ virtual bool AddTrack(AudioTrackInterface* track) = 0;
+ virtual bool AddTrack(VideoTrackInterface* track) = 0;
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_MEDIASTREAM_H_
diff --git a/talk/app/webrtc/mediastream_unittest.cc b/talk/app/webrtc/mediastream_unittest.cc
new file mode 100644
index 0000000..97d0c64
--- /dev/null
+++ b/talk/app/webrtc/mediastream_unittest.cc
@@ -0,0 +1,389 @@
+/*
+ * 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 "talk/app/webrtc/mediastreamproxy.h"
+#include "talk/app/webrtc/mediastreamtrackproxy.h"
+#include "talk/base/refcount.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/thread.h"
+#include "talk/base/gunit.h"
+#include "testing/base/public/gmock.h"
+
+static const char kStreamLabel1[] = "local_stream_1";
+static const char kVideoTrackLabel[] = "dummy_video_cam_1";
+static const char kAudioTrackLabel[] = "dummy_microphone_1";
+
+using talk_base::scoped_refptr;
+using ::testing::Exactly;
+
+namespace {
+
+class ReadyStateMessageData : public talk_base::MessageData {
+ public:
+ ReadyStateMessageData(
+ webrtc::MediaStreamInterface* stream,
+ webrtc::MediaStreamInterface::ReadyState new_state)
+ : stream_(stream),
+ ready_state_(new_state) {
+ }
+
+ scoped_refptr<webrtc::MediaStreamInterface> stream_;
+ webrtc::MediaStreamInterface::ReadyState ready_state_;
+};
+
+class TrackStateMessageData : public talk_base::MessageData {
+ public:
+ TrackStateMessageData(
+ webrtc::MediaStreamTrackInterface* track,
+ webrtc::MediaStreamTrackInterface::TrackState state)
+ : track_(track),
+ state_(state) {
+ }
+
+ scoped_refptr<webrtc::MediaStreamTrackInterface> track_;
+ webrtc::MediaStreamTrackInterface::TrackState state_;
+};
+
+} // namespace anonymous
+
+namespace webrtc {
+
+// Helper class to test Observer.
+class MockObserver : public ObserverInterface {
+ public:
+ explicit MockObserver(talk_base::Thread* signaling_thread)
+ : signaling_thread_(signaling_thread) {
+ }
+
+ MOCK_METHOD0(DoOnChanged, void());
+ virtual void OnChanged() {
+ ASSERT_TRUE(talk_base::Thread::Current() == signaling_thread_);
+ DoOnChanged();
+ }
+ private:
+ talk_base::Thread* signaling_thread_;
+};
+
+class MockMediaStream: public LocalMediaStreamInterface {
+ public:
+ MockMediaStream(const std::string& label, talk_base::Thread* signaling_thread)
+ : stream_impl_(MediaStream::Create(label)),
+ signaling_thread_(signaling_thread) {
+ }
+ virtual void RegisterObserver(webrtc::ObserverInterface* observer) {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ stream_impl_->RegisterObserver(observer);
+ }
+ virtual void UnregisterObserver(webrtc::ObserverInterface* observer) {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ stream_impl_->UnregisterObserver(observer);
+ }
+ virtual std::string label() const {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return stream_impl_->label();
+ }
+ virtual AudioTracks* audio_tracks() {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return stream_impl_->audio_tracks();
+ }
+ virtual VideoTracks* video_tracks() {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return stream_impl_->video_tracks();
+ }
+ virtual ReadyState ready_state() {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return stream_impl_->ready_state();
+ }
+ virtual void set_ready_state(ReadyState state) {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return stream_impl_->set_ready_state(state);
+ }
+ virtual bool AddTrack(AudioTrackInterface* audio_track) {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return stream_impl_->AddTrack(audio_track);
+ }
+ virtual bool AddTrack(VideoTrackInterface* video_track) {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return stream_impl_->AddTrack(video_track);
+ }
+
+ private:
+ scoped_refptr<MediaStream> stream_impl_;
+ talk_base::Thread* signaling_thread_;
+};
+
+template <class T>
+class MockMediaStreamTrack: public T {
+ public:
+ MockMediaStreamTrack(T* implementation,
+ talk_base::Thread* signaling_thread)
+ : track_impl_(implementation),
+ signaling_thread_(signaling_thread) {
+ }
+ virtual void RegisterObserver(webrtc::ObserverInterface* observer) {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ track_impl_->RegisterObserver(observer);
+ }
+ virtual void UnregisterObserver(webrtc::ObserverInterface* observer) {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ track_impl_->UnregisterObserver(observer);
+ }
+ virtual std::string kind() const {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return track_impl_->kind();
+ }
+ virtual std::string label() const {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return track_impl_->label();
+ }
+ virtual bool enabled() const {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return track_impl_->enabled();
+ }
+ virtual MediaStreamTrackInterface::TrackState state() const {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return track_impl_->state();
+ }
+ virtual bool set_enabled(bool enabled) {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return track_impl_->set_enabled(enabled);
+ }
+ virtual bool set_state(webrtc::MediaStreamTrackInterface::TrackState state) {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return track_impl_->set_state(state);
+ }
+
+ protected:
+ scoped_refptr<T> track_impl_;
+ talk_base::Thread* signaling_thread_;
+};
+
+class MockLocalVideoTrack
+ : public MockMediaStreamTrack<LocalVideoTrackInterface> {
+ public:
+ MockLocalVideoTrack(LocalVideoTrackInterface* implementation,
+ talk_base::Thread* signaling_thread)
+ : MockMediaStreamTrack<LocalVideoTrackInterface>(implementation,
+ signaling_thread) {
+ }
+ virtual void SetRenderer(webrtc::VideoRendererWrapperInterface* renderer) {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ track_impl_->SetRenderer(renderer);
+ }
+ virtual VideoRendererWrapperInterface* GetRenderer() {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return track_impl_->GetRenderer();
+ }
+ virtual cricket::VideoCapturer* GetVideoCapture() {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return track_impl_->GetVideoCapture();
+ }
+};
+
+class MockLocalAudioTrack
+ : public MockMediaStreamTrack<LocalAudioTrackInterface> {
+ public:
+ MockLocalAudioTrack(LocalAudioTrackInterface* implementation,
+ talk_base::Thread* signaling_thread)
+ : MockMediaStreamTrack<LocalAudioTrackInterface>(implementation,
+ signaling_thread) {
+ }
+
+ virtual AudioDeviceModule* GetAudioDevice() {
+ EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_);
+ return track_impl_->GetAudioDevice();
+ }
+};
+
+class MediaStreamTest: public testing::Test,
+ public talk_base::MessageHandler {
+ protected:
+ virtual void SetUp() {
+ signaling_thread_ .reset(new talk_base::Thread());
+ ASSERT_TRUE(signaling_thread_->Start());
+
+ std::string label(kStreamLabel1);
+ // Create a stream proxy object that uses our mocked
+ // version of a LocalMediaStream.
+ scoped_refptr<MockMediaStream> mock_stream(
+ new talk_base::RefCountedObject<MockMediaStream>(label,
+ signaling_thread_.get()));
+ stream_ = MediaStreamProxy::Create(label, signaling_thread_.get(),
+ mock_stream);
+ ASSERT_TRUE(stream_.get() != NULL);
+ EXPECT_EQ(label, stream_->label());
+ EXPECT_EQ(MediaStreamInterface::kInitializing, stream_->ready_state());
+
+ // Create a video track proxy object that uses our mocked
+ // version of a LocalVideoTrack
+ scoped_refptr<VideoTrack> video_track_impl(
+ VideoTrack::CreateLocal(kVideoTrackLabel, NULL));
+ scoped_refptr<MockLocalVideoTrack> mock_videotrack(
+ new talk_base::RefCountedObject<MockLocalVideoTrack>(video_track_impl,
+ signaling_thread_.get()));
+ video_track_ = VideoTrackProxy::CreateLocal(mock_videotrack,
+ signaling_thread_.get());
+
+ ASSERT_TRUE(video_track_.get() != NULL);
+ EXPECT_EQ(MediaStreamTrackInterface::kInitializing, video_track_->state());
+
+ // Create an audio track proxy object that uses our mocked
+ // version of a LocalAudioTrack
+ scoped_refptr<AudioTrack> audio_track_impl(
+ AudioTrack::CreateLocal(kAudioTrackLabel, NULL));
+ scoped_refptr<MockLocalAudioTrack> mock_audiotrack(
+ new talk_base::RefCountedObject<MockLocalAudioTrack>(audio_track_impl,
+ signaling_thread_.get()));
+ audio_track_ = AudioTrackProxy::CreateLocal(mock_audiotrack,
+ signaling_thread_.get());
+
+ ASSERT_TRUE(audio_track_.get() != NULL);
+ EXPECT_EQ(MediaStreamTrackInterface::kInitializing, audio_track_->state());
+ }
+
+ enum {
+ MSG_SET_READYSTATE,
+ MSG_SET_TRACKSTATE,
+ };
+
+ // Set the ready state on the signaling thread.
+ // State can only be changed on the signaling thread.
+ void SetReadyState(MediaStreamInterface* stream,
+ MediaStreamInterface::ReadyState new_state) {
+ ReadyStateMessageData state(stream, new_state);
+ signaling_thread_->Send(this, MSG_SET_READYSTATE, &state);
+ }
+
+ // Set the track state on the signaling thread.
+ // State can only be changed on the signaling thread.
+ void SetTrackState(MediaStreamTrackInterface* track,
+ MediaStreamTrackInterface::TrackState new_state) {
+ TrackStateMessageData state(track, new_state);
+ signaling_thread_->Send(this, MSG_SET_TRACKSTATE, &state);
+ }
+
+ talk_base::scoped_ptr<talk_base::Thread> signaling_thread_;
+ scoped_refptr<LocalMediaStreamInterface> stream_;
+ scoped_refptr<LocalVideoTrackInterface> video_track_;
+ scoped_refptr<LocalAudioTrackInterface> audio_track_;
+
+ private:
+ // Implements talk_base::MessageHandler.
+ virtual void OnMessage(talk_base::Message* msg) {
+ switch (msg->message_id) {
+ case MSG_SET_READYSTATE: {
+ ReadyStateMessageData* state =
+ static_cast<ReadyStateMessageData*>(msg->pdata);
+ state->stream_->set_ready_state(state->ready_state_);
+ break;
+ }
+ case MSG_SET_TRACKSTATE: {
+ TrackStateMessageData* state =
+ static_cast<TrackStateMessageData*>(msg->pdata);
+ state->track_->set_state(state->state_);
+ break;
+ }
+ default:
+ break;
+ }
+ }
+};
+
+TEST_F(MediaStreamTest, CreateLocalStream) {
+ EXPECT_TRUE(stream_->AddTrack(video_track_));
+ EXPECT_TRUE(stream_->AddTrack(audio_track_));
+
+ ASSERT_EQ(1u, stream_->video_tracks()->count());
+ ASSERT_EQ(1u, stream_->audio_tracks()->count());
+
+ // Verify the video track.
+ scoped_refptr<webrtc::MediaStreamTrackInterface> track(
+ stream_->video_tracks()->at(0));
+ EXPECT_EQ(0, track->label().compare(kVideoTrackLabel));
+ EXPECT_TRUE(track->enabled());
+
+ // Verify the audio track.
+ track = stream_->audio_tracks()->at(0);
+ EXPECT_EQ(0, track->label().compare(kAudioTrackLabel));
+ EXPECT_TRUE(track->enabled());
+}
+
+TEST_F(MediaStreamTest, ChangeStreamState) {
+ MockObserver observer(signaling_thread_.get());
+ stream_->RegisterObserver(&observer);
+
+ EXPECT_CALL(observer, DoOnChanged())
+ .Times(Exactly(1));
+ SetReadyState(stream_, MediaStreamInterface::kLive);
+
+ EXPECT_EQ(MediaStreamInterface::kLive, stream_->ready_state());
+ // It should not be possible to add
+ // streams when the state has changed to live.
+ EXPECT_FALSE(stream_->AddTrack(audio_track_));
+ EXPECT_EQ(0u, stream_->audio_tracks()->count());
+}
+
+TEST_F(MediaStreamTest, ChangeVideoTrack) {
+ MockObserver observer(signaling_thread_.get());
+ video_track_->RegisterObserver(&observer);
+
+ EXPECT_CALL(observer, DoOnChanged())
+ .Times(Exactly(1));
+ video_track_->set_enabled(false);
+ EXPECT_FALSE(video_track_->state());
+
+ EXPECT_CALL(observer, DoOnChanged())
+ .Times(Exactly(1));
+ SetTrackState(video_track_, MediaStreamTrackInterface::kLive);
+ EXPECT_EQ(MediaStreamTrackInterface::kLive, video_track_->state());
+
+ EXPECT_CALL(observer, DoOnChanged())
+ .Times(Exactly(1));
+ scoped_refptr<VideoRendererWrapperInterface> renderer(
+ CreateVideoRenderer(NULL));
+ video_track_->SetRenderer(renderer.get());
+ EXPECT_TRUE(renderer.get() == video_track_->GetRenderer());
+}
+
+TEST_F(MediaStreamTest, ChangeAudioTrack) {
+ MockObserver observer(signaling_thread_.get());
+ audio_track_->RegisterObserver(&observer);
+
+ EXPECT_CALL(observer, DoOnChanged())
+ .Times(Exactly(1));
+ audio_track_->set_enabled(false);
+ EXPECT_FALSE(audio_track_->enabled());
+
+ EXPECT_CALL(observer, DoOnChanged())
+ .Times(Exactly(1));
+ SetTrackState(audio_track_, MediaStreamTrackInterface::kLive);
+ EXPECT_EQ(MediaStreamTrackInterface::kLive, audio_track_->state());
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/mediastreamhandler.cc b/talk/app/webrtc/mediastreamhandler.cc
new file mode 100644
index 0000000..d120b80
--- /dev/null
+++ b/talk/app/webrtc/mediastreamhandler.cc
@@ -0,0 +1,258 @@
+/*
+ * 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/mediastreamhandler.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 {
+
+VideoTrackHandler::VideoTrackHandler(VideoTrackInterface* track,
+ MediaProviderInterface* provider)
+ : provider_(provider),
+ video_track_(track),
+ state_(track->state()),
+ enabled_(track->enabled()),
+ renderer_(track->GetRenderer()) {
+ video_track_->RegisterObserver(this);
+}
+
+VideoTrackHandler::~VideoTrackHandler() {
+ video_track_->UnregisterObserver(this);
+}
+
+void VideoTrackHandler::OnChanged() {
+ if (state_ != video_track_->state()) {
+ state_ = video_track_->state();
+ OnStateChanged();
+ }
+ if (renderer_.get() != video_track_->GetRenderer()) {
+ renderer_ = video_track_->GetRenderer();
+ OnRendererChanged();
+ }
+ if (enabled_ != video_track_->enabled()) {
+ enabled_ = video_track_->enabled();
+ OnEnabledChanged();
+ }
+}
+
+LocalVideoTrackHandler::LocalVideoTrackHandler(
+ LocalVideoTrackInterface* track,
+ MediaProviderInterface* provider)
+ : VideoTrackHandler(track, provider),
+ local_video_track_(track) {
+}
+
+LocalVideoTrackHandler::~LocalVideoTrackHandler() {
+ // cricket::VideoRenderer and cricket::VideoCapturer is owned and deleted by
+ // the track. It must be removed from the media stream provider since it is
+ // possible that the tracks reference count is set to zero when
+ // local_video_track_ falls out of scope.
+ provider_->SetLocalRenderer(local_video_track_->label(), NULL);
+ provider_->SetCaptureDevice(local_video_track_->label(), NULL);
+}
+
+void LocalVideoTrackHandler::OnRendererChanged() {
+ VideoRendererWrapperInterface* renderer = video_track_->GetRenderer();
+ if (renderer)
+ provider_->SetLocalRenderer(video_track_->label(), renderer->renderer());
+ else
+ provider_->SetLocalRenderer(video_track_->label(), NULL);
+}
+
+void LocalVideoTrackHandler::OnStateChanged() {
+ if (local_video_track_->state() == VideoTrackInterface::kLive) {
+ provider_->SetCaptureDevice(local_video_track_->label(),
+ local_video_track_->GetVideoCapture());
+ VideoRendererWrapperInterface* renderer = video_track_->GetRenderer();
+ if (renderer)
+ provider_->SetLocalRenderer(video_track_->label(), renderer->renderer());
+ else
+ provider_->SetLocalRenderer(video_track_->label(), NULL);
+ }
+}
+
+void LocalVideoTrackHandler::OnEnabledChanged() {
+ // TODO What should happen when enabled is changed?
+}
+
+RemoteVideoTrackHandler::RemoteVideoTrackHandler(
+ VideoTrackInterface* track,
+ MediaProviderInterface* provider)
+ : VideoTrackHandler(track, provider),
+ remote_video_track_(track) {
+}
+
+RemoteVideoTrackHandler::~RemoteVideoTrackHandler() {
+ // Since cricket::VideoRenderer is not reference counted
+ // we need to remove the renderer before we are deleted.
+ provider_->SetRemoteRenderer(video_track_->label(), NULL);
+}
+
+
+void RemoteVideoTrackHandler::OnRendererChanged() {
+ VideoRendererWrapperInterface* renderer = video_track_->GetRenderer();
+ if (renderer)
+ provider_->SetRemoteRenderer(video_track_->label(), renderer->renderer());
+ else
+ provider_->SetRemoteRenderer(video_track_->label(), NULL);
+}
+
+void RemoteVideoTrackHandler::OnStateChanged() {
+}
+
+void RemoteVideoTrackHandler::OnEnabledChanged() {
+ // TODO: What should happen when enabled is changed?
+}
+
+MediaStreamHandler::MediaStreamHandler(MediaStreamInterface* stream,
+ MediaProviderInterface* provider)
+ : stream_(stream),
+ provider_(provider) {
+}
+
+MediaStreamHandler::~MediaStreamHandler() {
+ for (VideoTrackHandlers::iterator it = video_handlers_.begin();
+ it != video_handlers_.end(); ++it) {
+ delete *it;
+ }
+}
+
+MediaStreamInterface* MediaStreamHandler::stream() {
+ return stream_.get();
+}
+
+void MediaStreamHandler::OnChanged() {
+ // TODO: Implement state change and enabled changed.
+}
+
+
+LocalMediaStreamHandler::LocalMediaStreamHandler(
+ MediaStreamInterface* stream,
+ MediaProviderInterface* provider)
+ : MediaStreamHandler(stream, provider) {
+ VideoTracks* tracklist(stream->video_tracks());
+
+ for (size_t j = 0; j < tracklist->count(); ++j) {
+ LocalVideoTrackInterface* track =
+ static_cast<LocalVideoTrackInterface*>(tracklist->at(j));
+ VideoTrackHandler* handler(new LocalVideoTrackHandler(track, provider));
+ video_handlers_.push_back(handler);
+ }
+}
+
+RemoteMediaStreamHandler::RemoteMediaStreamHandler(
+ MediaStreamInterface* stream,
+ MediaProviderInterface* provider)
+ : MediaStreamHandler(stream, provider) {
+ VideoTracks* tracklist(stream->video_tracks());
+
+ for (size_t j = 0; j < tracklist->count(); ++j) {
+ VideoTrackInterface* track =
+ static_cast<VideoTrackInterface*>(tracklist->at(j));
+ VideoTrackHandler* handler(new RemoteVideoTrackHandler(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(MediaStreamInterface* stream) {
+ RemoteMediaStreamHandler* handler = new RemoteMediaStreamHandler(stream,
+ provider_);
+ remote_streams_handlers_.push_back(handler);
+}
+
+void MediaStreamHandlers::RemoveRemoteStream(MediaStreamInterface* 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(
+ StreamCollectionInterface* 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) {
+ MediaStreamInterface* stream = streams->at(j);
+ StreamHandlerList::iterator it = local_streams_handlers_.begin();
+ for (; it != local_streams_handlers_.end(); ++it) {
+ if (stream == (*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/talk/app/webrtc/mediastreamhandler.h b/talk/app/webrtc/mediastreamhandler.h
new file mode 100644
index 0000000..550a2d4
--- /dev/null
+++ b/talk/app/webrtc/mediastreamhandler.h
@@ -0,0 +1,144 @@
+/*
+ * 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_MEDIASTREAMHANDLER_H_
+#define TALK_APP_WEBRTC_MEDIASTREAMHANDLER_H_
+
+#include <list>
+#include <vector>
+
+#include "talk/app/webrtc/mediastream.h"
+#include "talk/app/webrtc/mediastreamprovider.h"
+#include "talk/app/webrtc/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 ObserverInterface {
+ public:
+ VideoTrackHandler(VideoTrackInterface* track,
+ MediaProviderInterface* provider);
+ virtual ~VideoTrackHandler();
+ virtual void OnChanged();
+
+ protected:
+ virtual void OnRendererChanged() = 0;
+ virtual void OnStateChanged() = 0;
+ virtual void OnEnabledChanged() = 0;
+
+ MediaProviderInterface* provider_;
+ VideoTrackInterface* video_track_;
+
+ private:
+ MediaStreamTrackInterface::TrackState state_;
+ bool enabled_;
+ talk_base::scoped_refptr<VideoRendererWrapperInterface> renderer_;
+};
+
+class LocalVideoTrackHandler : public VideoTrackHandler {
+ public:
+ LocalVideoTrackHandler(LocalVideoTrackInterface* track,
+ MediaProviderInterface* provider);
+ virtual ~LocalVideoTrackHandler();
+
+ protected:
+ virtual void OnRendererChanged();
+ virtual void OnStateChanged();
+ virtual void OnEnabledChanged();
+
+ private:
+ talk_base::scoped_refptr<LocalVideoTrackInterface> local_video_track_;
+};
+
+class RemoteVideoTrackHandler : public VideoTrackHandler {
+ public:
+ RemoteVideoTrackHandler(VideoTrackInterface* track,
+ MediaProviderInterface* provider);
+ virtual ~RemoteVideoTrackHandler();
+
+ protected:
+ virtual void OnRendererChanged();
+ virtual void OnStateChanged();
+ virtual void OnEnabledChanged();
+
+ private:
+ talk_base::scoped_refptr<VideoTrackInterface> remote_video_track_;
+};
+
+class MediaStreamHandler : public ObserverInterface {
+ public:
+ MediaStreamHandler(MediaStreamInterface* stream,
+ MediaProviderInterface* provider);
+ ~MediaStreamHandler();
+ MediaStreamInterface* stream();
+ virtual void OnChanged();
+
+ protected:
+ talk_base::scoped_refptr<MediaStreamInterface> stream_;
+ MediaProviderInterface* provider_;
+ typedef std::vector<VideoTrackHandler*> VideoTrackHandlers;
+ VideoTrackHandlers video_handlers_;
+};
+
+class LocalMediaStreamHandler : public MediaStreamHandler {
+ public:
+ LocalMediaStreamHandler(MediaStreamInterface* stream,
+ MediaProviderInterface* provider);
+};
+
+class RemoteMediaStreamHandler : public MediaStreamHandler {
+ public:
+ RemoteMediaStreamHandler(MediaStreamInterface* stream,
+ MediaProviderInterface* provider);
+};
+
+class MediaStreamHandlers {
+ public:
+ explicit MediaStreamHandlers(MediaProviderInterface* provider);
+ ~MediaStreamHandlers();
+ void AddRemoteStream(MediaStreamInterface* stream);
+ void RemoveRemoteStream(MediaStreamInterface* stream);
+ void CommitLocalStreams(StreamCollectionInterface* streams);
+
+ private:
+ typedef std::list<MediaStreamHandler*> StreamHandlerList;
+ StreamHandlerList local_streams_handlers_;
+ StreamHandlerList remote_streams_handlers_;
+ MediaProviderInterface* provider_;
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_MEDIASTREAMHANDLER_H_
+
diff --git a/talk/app/webrtc/mediastreamhandler_unittest.cc b/talk/app/webrtc/mediastreamhandler_unittest.cc
new file mode 100644
index 0000000..cd702bd
--- /dev/null
+++ b/talk/app/webrtc/mediastreamhandler_unittest.cc
@@ -0,0 +1,148 @@
+/*
+ * 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 "talk/app/webrtc/mediastreamimpl.h"
+#include "talk/app/webrtc/videotrackimpl.h"
+#include "talk/app/webrtc/mediastreamhandler.h"
+#include "talk/app/webrtc/streamcollectionimpl.h"
+#include "talk/base/thread.h"
+#include "talk/base/gunit.h"
+#include "testing/base/public/gmock.h"
+
+using ::testing::Exactly;
+
+static const char kStreamLabel1[] = "local_stream_1";
+static const char kVideoDeviceName[] = "dummy_video_cam_1";
+
+namespace webrtc {
+
+// Helper class to test MediaStreamHandler.
+class MockMediaProvier : public MediaProviderInterface {
+ public:
+ MOCK_METHOD1(SetCaptureDevice, bool(const std::string& name));
+ MOCK_METHOD1(SetLocalRenderer, void(const std::string& name));
+ MOCK_METHOD1(SetRemoteRenderer, void(const std::string& name));
+
+ virtual bool SetCaptureDevice(const std::string& name,
+ cricket::VideoCapturer* camera) {
+ return SetCaptureDevice(name);
+ }
+ virtual void SetLocalRenderer(const std::string& name,
+ cricket::VideoRenderer* renderer) {
+ SetLocalRenderer(name);
+ }
+
+ virtual void SetRemoteRenderer(const std::string& name,
+ cricket::VideoRenderer* renderer) {
+ SetRemoteRenderer(name);
+ }
+ ~MockMediaProvier() {}
+};
+
+TEST(MediaStreamHandlerTest, LocalStreams) {
+ // Create a local stream.
+ std::string label(kStreamLabel1);
+ talk_base::scoped_refptr<LocalMediaStreamInterface> stream(
+ MediaStream::Create(label));
+ talk_base::scoped_refptr<LocalVideoTrackInterface>
+ video_track(VideoTrack::CreateLocal(kVideoDeviceName, NULL));
+ EXPECT_TRUE(stream->AddTrack(video_track));
+ talk_base::scoped_refptr<VideoRendererWrapperInterface> renderer(
+ CreateVideoRenderer(NULL));
+ video_track->SetRenderer(renderer);
+
+ MockMediaProvier provider;
+ MediaStreamHandlers handlers(&provider);
+
+ talk_base::scoped_refptr<StreamCollection> collection(
+ StreamCollection::Create());
+ collection->AddStream(stream);
+
+ EXPECT_CALL(provider, SetLocalRenderer(kVideoDeviceName))
+ .Times(Exactly(2)); // SetLocalRender will also be called from dtor of
+ // LocalVideoTrackHandler
+ EXPECT_CALL(provider, SetCaptureDevice(kVideoDeviceName))
+ .Times(Exactly(2)); // SetCaptureDevice will also be called from dtor of
+ // LocalVideoTrackHandler
+ handlers.CommitLocalStreams(collection);
+
+ video_track->set_state(MediaStreamTrackInterface::kLive);
+ // Process posted messages.
+ talk_base::Thread::Current()->ProcessMessages(1);
+
+ collection->RemoveStream(stream);
+ handlers.CommitLocalStreams(collection);
+
+ video_track->set_state(MediaStreamTrackInterface::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);
+ talk_base::scoped_refptr<LocalMediaStreamInterface> stream(
+ MediaStream::Create(label));
+ talk_base::scoped_refptr<LocalVideoTrackInterface>
+ video_track(VideoTrack::CreateLocal(kVideoDeviceName, NULL));
+ EXPECT_TRUE(stream->AddTrack(video_track));
+
+ MockMediaProvier provider;
+ MediaStreamHandlers handlers(&provider);
+
+ handlers.AddRemoteStream(stream);
+
+ EXPECT_CALL(provider, SetRemoteRenderer(kVideoDeviceName))
+ .Times(Exactly(3)); // SetRemoteRenderer is also called from dtor of
+ // RemoteVideoTrackHandler.
+
+ // Set the renderer once.
+ talk_base::scoped_refptr<VideoRendererWrapperInterface> 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/talk/app/webrtc/mediastreamimpl.cc b/talk/app/webrtc/mediastreamimpl.cc
new file mode 100644
index 0000000..8920379
--- /dev/null
+++ b/talk/app/webrtc/mediastreamimpl.cc
@@ -0,0 +1,73 @@
+/*
+ * 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/mediastreamimpl.h"
+#include "talk/base/logging.h"
+
+namespace webrtc {
+
+talk_base::scoped_refptr<MediaStream> MediaStream::Create(
+ const std::string& label) {
+ talk_base::RefCountedObject<MediaStream>* stream =
+ new talk_base::RefCountedObject<MediaStream>(label);
+ return stream;
+}
+
+MediaStream::MediaStream(const std::string& label)
+ : label_(label),
+ ready_state_(MediaStreamInterface::kInitializing),
+ audio_track_list_(
+ new talk_base::RefCountedObject<
+ MediaStreamTrackList<AudioTrackInterface> >()),
+ video_track_list_(
+ new talk_base::RefCountedObject<
+ MediaStreamTrackList<VideoTrackInterface> >()) {
+}
+
+void MediaStream::set_ready_state(
+ MediaStreamInterface::ReadyState new_state) {
+ if (ready_state_ != new_state) {
+ ready_state_ = new_state;
+ Notifier<LocalMediaStreamInterface>::FireOnChanged();
+ }
+}
+
+bool MediaStream::AddTrack(AudioTrackInterface* track) {
+ if (ready_state() != kInitializing)
+ return false;
+ audio_track_list_->AddTrack(track);
+ return true;
+}
+
+bool MediaStream::AddTrack(VideoTrackInterface* track) {
+ if (ready_state() != kInitializing)
+ return false;
+ video_track_list_->AddTrack(track);
+ return true;
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/mediastreamimpl.h b/talk/app/webrtc/mediastreamimpl.h
new file mode 100644
index 0000000..44ede9b
--- /dev/null
+++ b/talk/app/webrtc/mediastreamimpl.h
@@ -0,0 +1,89 @@
+/*
+ * 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 the implementation of MediaStreamInterface interface.
+
+#ifndef TALK_APP_WEBRTC_MEDIASTREAMIMPL_H_
+#define TALK_APP_WEBRTC_MEDIASTREAMIMPL_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/app/webrtc/mediastream.h"
+#include "talk/app/webrtc/notifierimpl.h"
+
+namespace webrtc {
+class AudioTrack;
+class VideoTrack;
+
+class MediaStream : public Notifier<LocalMediaStreamInterface> {
+ public:
+ template<class T>
+ class MediaStreamTrackList : public MediaStreamTrackListInterface<T> {
+ public:
+ void AddTrack(T* track) {
+ tracks_.push_back(track);
+ }
+ virtual size_t count() { return tracks_.size(); }
+ virtual T* at(size_t index) {
+ return tracks_.at(index);
+ }
+
+ private:
+ std::vector<talk_base::scoped_refptr<T> > tracks_;
+ };
+
+ static talk_base::scoped_refptr<MediaStream> Create(const std::string& label);
+
+ // Implement LocalMediaStreamInterface.
+ virtual bool AddTrack(AudioTrackInterface* track);
+ virtual bool AddTrack(VideoTrackInterface* track);
+ // Implement MediaStreamInterface.
+ virtual std::string label() const { return label_; }
+ 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);
+
+ protected:
+ explicit MediaStream(const std::string& label);
+
+ std::string label_;
+ MediaStreamInterface::ReadyState ready_state_;
+ talk_base::scoped_refptr<MediaStreamTrackList<AudioTrackInterface> >
+ audio_track_list_;
+ talk_base::scoped_refptr<MediaStreamTrackList<VideoTrackInterface> >
+ video_track_list_;
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_MEDIASTREAMIMPL_H_
diff --git a/talk/app/webrtc/mediastreamprovider.h b/talk/app/webrtc/mediastreamprovider.h
new file mode 100644
index 0000000..e99b115
--- /dev/null
+++ b/talk/app/webrtc/mediastreamprovider.h
@@ -0,0 +1,58 @@
+/*
+ * 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_MEDIASTREAMPROVIDER_H_
+#define TALK_APP_WEBRTC_MEDIASTREAMPROVIDER_H_
+
+#include "talk/app/webrtc/mediastream.h"
+
+namespace cricket {
+
+class VideoCapturer;
+
+} // namespace cricket
+
+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 bool SetCaptureDevice(const std::string& name,
+ cricket::VideoCapturer* camera) = 0;
+ virtual void SetLocalRenderer(const std::string& name,
+ cricket::VideoRenderer* renderer) = 0;
+ virtual void SetRemoteRenderer(const std::string& name,
+ cricket::VideoRenderer* renderer) = 0;
+ protected:
+ virtual ~MediaProviderInterface() {}
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_MEDIASTREAMPROVIDER_H_
diff --git a/talk/app/webrtc/mediastreamproxy.cc b/talk/app/webrtc/mediastreamproxy.cc
new file mode 100644
index 0000000..7e74c86
--- /dev/null
+++ b/talk/app/webrtc/mediastreamproxy.cc
@@ -0,0 +1,318 @@
+/*
+ * 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/mediastreamproxy.h"
+#include "talk/base/refcount.h"
+#include "talk/base/scoped_ref_ptr.h"
+
+namespace {
+
+enum {
+ MSG_SET_TRACKLIST_IMPLEMENTATION = 1,
+ MSG_REGISTER_OBSERVER,
+ MSG_UNREGISTER_OBSERVER,
+ MSG_LABEL,
+ MSG_ADD_AUDIO_TRACK,
+ MSG_ADD_VIDEO_TRACK,
+ MSG_READY_STATE,
+ MSG_COUNT,
+ MSG_AT
+};
+
+typedef talk_base::TypedMessageData<std::string*> LabelMessageData;
+typedef talk_base::TypedMessageData<size_t> SizeTMessageData;
+typedef talk_base::TypedMessageData<webrtc::ObserverInterface*>
+ ObserverMessageData;
+typedef talk_base::TypedMessageData<webrtc::MediaStreamInterface::ReadyState>
+ ReadyStateMessageData;
+
+template<typename T>
+class MediaStreamTrackMessageData : public talk_base::MessageData {
+ public:
+ explicit MediaStreamTrackMessageData(T* track)
+ : track_(track),
+ result_(false) {
+ }
+
+ talk_base::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)
+ : index_(index) {
+ }
+
+ size_t index_;
+ talk_base::scoped_refptr<TrackType> track_;
+};
+
+class MediaStreamTrackListsMessageData : public talk_base::MessageData {
+ public:
+ talk_base::scoped_refptr<webrtc::AudioTracks> audio_tracks_;
+ talk_base::scoped_refptr<webrtc::VideoTracks> video_tracks_;
+};
+
+} // namespace anonymous
+
+namespace webrtc {
+
+talk_base::scoped_refptr<MediaStreamProxy> MediaStreamProxy::Create(
+ const std::string& label,
+ talk_base::Thread* signaling_thread) {
+ ASSERT(signaling_thread != NULL);
+ talk_base::RefCountedObject<MediaStreamProxy>* stream =
+ new talk_base::RefCountedObject<MediaStreamProxy>(
+ label, signaling_thread,
+ reinterpret_cast<LocalMediaStreamInterface*>(NULL));
+ return stream;
+}
+
+talk_base::scoped_refptr<MediaStreamProxy> MediaStreamProxy::Create(
+ const std::string& label,
+ talk_base::Thread* signaling_thread,
+ LocalMediaStreamInterface* media_stream_impl) {
+ ASSERT(signaling_thread != NULL);
+ ASSERT(media_stream_impl != NULL);
+ talk_base::RefCountedObject<MediaStreamProxy>* stream =
+ new talk_base::RefCountedObject<MediaStreamProxy>(label, signaling_thread,
+ media_stream_impl);
+ return stream;
+}
+
+MediaStreamProxy::MediaStreamProxy(const std::string& label,
+ talk_base::Thread* signaling_thread,
+ LocalMediaStreamInterface* media_stream_impl)
+ : signaling_thread_(signaling_thread),
+ media_stream_impl_(media_stream_impl),
+ audio_tracks_(new talk_base::RefCountedObject<
+ MediaStreamTrackListProxy<AudioTrackInterface> >(
+ signaling_thread_)),
+ video_tracks_(new talk_base::RefCountedObject<
+ MediaStreamTrackListProxy<VideoTrackInterface> >(
+ signaling_thread_)) {
+ if (media_stream_impl_ == NULL) {
+ media_stream_impl_ = MediaStream::Create(label);
+ }
+
+ MediaStreamTrackListsMessageData tracklists;
+ Send(MSG_SET_TRACKLIST_IMPLEMENTATION, &tracklists);
+ audio_tracks_->SetImplementation(tracklists.audio_tracks_);
+ video_tracks_->SetImplementation(tracklists.video_tracks_);
+}
+
+std::string MediaStreamProxy::label() const {
+ if (!signaling_thread_->IsCurrent()) {
+ std::string label;
+ LabelMessageData msg(&label);
+ Send(MSG_LABEL, &msg);
+ return label;
+ }
+ return media_stream_impl_->label();
+}
+
+MediaStreamInterface::ReadyState MediaStreamProxy::ready_state() {
+ if (!signaling_thread_->IsCurrent()) {
+ ReadyStateMessageData msg(MediaStreamInterface::kInitializing);
+ Send(MSG_READY_STATE, &msg);
+ return msg.data();
+ }
+ return media_stream_impl_->ready_state();
+}
+
+void MediaStreamProxy::set_ready_state(
+ MediaStreamInterface::ReadyState new_state) {
+ if (!signaling_thread_->IsCurrent()) {
+ // State should only be allowed to be changed from the signaling thread.
+ ASSERT(!"Not Allowed!");
+ return;
+ }
+ media_stream_impl_->set_ready_state(new_state);
+}
+
+bool MediaStreamProxy::AddTrack(AudioTrackInterface* track) {
+ if (!signaling_thread_->IsCurrent()) {
+ AudioTrackMsgData msg(track);
+ Send(MSG_ADD_AUDIO_TRACK, &msg);
+ return msg.result_;
+ }
+ return media_stream_impl_->AddTrack(track);
+}
+
+bool MediaStreamProxy::AddTrack(VideoTrackInterface* track) {
+ if (!signaling_thread_->IsCurrent()) {
+ VideoTrackMsgData msg(track);
+ Send(MSG_ADD_VIDEO_TRACK, &msg);
+ return msg.result_;
+ }
+ return media_stream_impl_->AddTrack(track);
+}
+
+void MediaStreamProxy::RegisterObserver(ObserverInterface* observer) {
+ if (!signaling_thread_->IsCurrent()) {
+ ObserverMessageData msg(observer);
+ Send(MSG_REGISTER_OBSERVER, &msg);
+ return;
+ }
+ media_stream_impl_->RegisterObserver(observer);
+}
+
+void MediaStreamProxy::UnregisterObserver(ObserverInterface* observer) {
+ if (!signaling_thread_->IsCurrent()) {
+ ObserverMessageData msg(observer);
+ Send(MSG_UNREGISTER_OBSERVER, &msg);
+ return;
+ }
+ media_stream_impl_->UnregisterObserver(observer);
+}
+
+void MediaStreamProxy::Send(uint32 id, talk_base::MessageData* data) const {
+ signaling_thread_->Send(const_cast<MediaStreamProxy*>(this), id,
+ data);
+}
+
+// Implement MessageHandler
+void MediaStreamProxy::OnMessage(talk_base::Message* msg) {
+ talk_base::MessageData* data = msg->pdata;
+ switch (msg->message_id) {
+ case MSG_SET_TRACKLIST_IMPLEMENTATION: {
+ MediaStreamTrackListsMessageData* lists =
+ static_cast<MediaStreamTrackListsMessageData*>(data);
+ lists->audio_tracks_ = media_stream_impl_->audio_tracks();
+ lists->video_tracks_ = media_stream_impl_->video_tracks();
+ break;
+ }
+ case MSG_REGISTER_OBSERVER: {
+ ObserverMessageData* observer = static_cast<ObserverMessageData*>(data);
+ media_stream_impl_->RegisterObserver(observer->data());
+ break;
+ }
+ case MSG_UNREGISTER_OBSERVER: {
+ ObserverMessageData* observer = static_cast<ObserverMessageData*>(data);
+ media_stream_impl_->UnregisterObserver(observer->data());
+ break;
+ }
+ case MSG_LABEL: {
+ LabelMessageData * label = static_cast<LabelMessageData*>(data);
+ *(label->data()) = media_stream_impl_->label();
+ break;
+ }
+ case MSG_ADD_AUDIO_TRACK: {
+ AudioTrackMsgData * track =
+ static_cast<AudioTrackMsgData *>(data);
+ track->result_ = media_stream_impl_->AddTrack(track->track_.get());
+ break;
+ }
+ case MSG_ADD_VIDEO_TRACK: {
+ VideoTrackMsgData * track =
+ static_cast<VideoTrackMsgData *>(data);
+ track->result_ = media_stream_impl_->AddTrack(track->track_.get());
+ break;
+ }
+ case MSG_READY_STATE: {
+ ReadyStateMessageData* state = static_cast<ReadyStateMessageData*>(data);
+ state->data() = media_stream_impl_->ready_state();
+ break;
+ }
+ default:
+ ASSERT(!"Not Implemented!");
+ break;
+ }
+}
+
+template <class T>
+MediaStreamProxy::MediaStreamTrackListProxy<T>::MediaStreamTrackListProxy(
+ talk_base::Thread* signaling_thread)
+ : signaling_thread_(signaling_thread) {
+}
+
+template <class T>
+void MediaStreamProxy::MediaStreamTrackListProxy<T>::SetImplementation(
+ MediaStreamTrackListInterface<T>* track_list) {
+ track_list_ = track_list;
+}
+
+template <class T>
+size_t MediaStreamProxy::MediaStreamTrackListProxy<T>::count() {
+ if (!signaling_thread_->IsCurrent()) {
+ SizeTMessageData msg(0u);
+ Send(MSG_COUNT, &msg);
+ return msg.data();
+ }
+ return track_list_->count();
+}
+
+template <class T>
+T* MediaStreamProxy::MediaStreamTrackListProxy<T>::at(
+ size_t index) {
+ if (!signaling_thread_->IsCurrent()) {
+ MediaStreamTrackAtMessageData<T> msg(index);
+ Send(MSG_AT, &msg);
+ return msg.track_;
+ }
+ return track_list_->at(index);
+}
+
+template <class T>
+void MediaStreamProxy::MediaStreamTrackListProxy<T>::Send(
+ uint32 id, talk_base::MessageData* data) const {
+ signaling_thread_->Send(
+ const_cast<MediaStreamProxy::MediaStreamTrackListProxy<T>*>(
+ this), id, data);
+}
+
+// Implement MessageHandler
+template <class T>
+void MediaStreamProxy::MediaStreamTrackListProxy<T>::OnMessage(
+ talk_base::Message* msg) {
+ talk_base::MessageData* data = msg->pdata;
+ switch (msg->message_id) {
+ case MSG_COUNT: {
+ SizeTMessageData* count = static_cast<SizeTMessageData*>(data);
+ count->data() = track_list_->count();
+ break;
+ }
+ case MSG_AT: {
+ MediaStreamTrackAtMessageData<T>* track =
+ static_cast<MediaStreamTrackAtMessageData<T>*>(data);
+ track->track_ = track_list_->at(track->index_);
+ break;
+ }
+ default:
+ ASSERT(!"Not Implemented!");
+ break;
+ }
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/mediastreamproxy.h b/talk/app/webrtc/mediastreamproxy.h
new file mode 100644
index 0000000..7d1068a
--- /dev/null
+++ b/talk/app/webrtc/mediastreamproxy.h
@@ -0,0 +1,111 @@
+/*
+ * 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_MEDIASTREAMPROXY_H_
+#define TALK_APP_WEBRTC_MEDIASTREAMPROXY_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/app/webrtc/mediastreamimpl.h"
+#include "talk/base/thread.h"
+
+namespace webrtc {
+using talk_base::scoped_refptr;
+
+// MediaStreamProxy is a proxy for the MediaStream interface. The purpose is
+// to make sure MediaStreamImpl is only accessed from the signaling thread.
+// It can be used as a proxy for both local and remote MediaStreams.
+class MediaStreamProxy : public LocalMediaStreamInterface,
+ public talk_base::MessageHandler {
+ public:
+ static scoped_refptr<MediaStreamProxy> Create(
+ const std::string& label,
+ talk_base::Thread* signaling_thread);
+
+ static scoped_refptr<MediaStreamProxy> Create(
+ const std::string& label,
+ talk_base::Thread* signaling_thread,
+ LocalMediaStreamInterface* media_stream_impl);
+
+ // Implement LocalStream.
+ virtual bool AddTrack(AudioTrackInterface* track);
+ virtual bool AddTrack(VideoTrackInterface* track);
+
+ // Implement MediaStream.
+ virtual std::string label() const;
+ virtual AudioTracks* audio_tracks() {
+ return audio_tracks_;
+ }
+ virtual VideoTracks* video_tracks() {
+ return video_tracks_;
+ }
+ virtual ReadyState ready_state();
+ virtual void set_ready_state(ReadyState new_state);
+
+ // Implement Notifier
+ virtual void RegisterObserver(ObserverInterface* observer);
+ virtual void UnregisterObserver(ObserverInterface* observer);
+
+ protected:
+ MediaStreamProxy(const std::string& label,
+ talk_base::Thread* signaling_thread,
+ LocalMediaStreamInterface* media_stream_impl);
+
+ template <class T>
+ class MediaStreamTrackListProxy : public MediaStreamTrackListInterface<T>,
+ public talk_base::MessageHandler {
+ public:
+ explicit MediaStreamTrackListProxy(talk_base::Thread* signaling_thread);
+
+ void SetImplementation(MediaStreamTrackListInterface<T>* track_list);
+ virtual size_t count();
+ virtual T* at(size_t index);
+
+ private:
+ void Send(uint32 id, talk_base::MessageData* data) const;
+ void OnMessage(talk_base::Message* msg);
+
+ talk_base::scoped_refptr<MediaStreamTrackListInterface<T> > track_list_;
+ mutable talk_base::Thread* signaling_thread_;
+ };
+ typedef MediaStreamTrackListProxy<AudioTrackInterface> AudioTrackListProxy;
+ typedef MediaStreamTrackListProxy<VideoTrackInterface> VideoTrackListProxy;
+
+ void Send(uint32 id, talk_base::MessageData* data) const;
+ // Implement MessageHandler.
+ virtual void OnMessage(talk_base::Message* msg);
+
+ mutable talk_base::Thread* signaling_thread_;
+ scoped_refptr<LocalMediaStreamInterface> media_stream_impl_;
+ scoped_refptr<AudioTrackListProxy> audio_tracks_;
+ scoped_refptr<VideoTrackListProxy> video_tracks_;
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_MEDIASTREAMPROXY_H_
diff --git a/talk/app/webrtc/mediastreamtrackproxy.cc b/talk/app/webrtc/mediastreamtrackproxy.cc
new file mode 100644
index 0000000..15b1d6d
--- /dev/null
+++ b/talk/app/webrtc/mediastreamtrackproxy.cc
@@ -0,0 +1,396 @@
+/*
+ * 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/mediastreamtrackproxy.h"
+
+#include "talk/session/phone/videocapturer.h"
+
+namespace {
+
+enum {
+ MSG_REGISTER_OBSERVER = 1,
+ MSG_UNREGISTER_OBSERVER,
+ MSG_LABEL,
+ MSG_ENABLED,
+ MSG_SET_ENABLED,
+ MSG_STATE,
+ MSG_GET_AUDIODEVICE,
+ MSG_GET_VIDEODEVICE,
+ MSG_GET_VIDEORENDERER,
+ MSG_SET_VIDEORENDERER,
+};
+
+typedef talk_base::TypedMessageData<std::string*> LabelMessageData;
+typedef talk_base::TypedMessageData<webrtc::ObserverInterface*>
+ ObserverMessageData;
+typedef talk_base::TypedMessageData
+ <webrtc::MediaStreamTrackInterface::TrackState> TrackStateMessageData;
+typedef talk_base::TypedMessageData<bool> EnableMessageData;
+
+
+class AudioDeviceMessageData : public talk_base::MessageData {
+ public:
+ talk_base::scoped_refptr<webrtc::AudioDeviceModule> audio_device_;
+};
+
+class VideoDeviceMessageData : public talk_base::MessageData {
+ public:
+ cricket::VideoCapturer* video_device_;
+};
+
+class VideoRendererMessageData : public talk_base::MessageData {
+ public:
+ talk_base::scoped_refptr<webrtc::VideoRendererWrapperInterface>
+ video_renderer_;
+};
+
+} // namespace anonymous
+
+namespace webrtc {
+
+template <class T>
+MediaStreamTrackProxy<T>::MediaStreamTrackProxy(
+ talk_base::Thread* signaling_thread)
+ : signaling_thread_(signaling_thread) {
+}
+
+template <class T>
+void MediaStreamTrackProxy<T>::Init(MediaStreamTrackInterface* track) {
+ track_ = track;
+}
+
+template <class T>
+std::string MediaStreamTrackProxy<T>::kind() const {
+ return track_->kind();
+}
+
+template <class T>
+std::string MediaStreamTrackProxy<T>::label() const {
+ if (!signaling_thread_->IsCurrent()) {
+ std::string label;
+ LabelMessageData msg(&label);
+ Send(MSG_LABEL, &msg);
+ return label;
+ }
+ return track_->label();
+}
+
+template <class T>
+MediaStreamTrackInterface::TrackState MediaStreamTrackProxy<T>::state() const {
+ if (!signaling_thread_->IsCurrent()) {
+ TrackStateMessageData msg(MediaStreamTrackInterface::kInitializing);
+ Send(MSG_STATE, &msg);
+ return msg.data();
+ }
+ return track_->state();
+}
+
+template <class T>
+bool MediaStreamTrackProxy<T>::enabled() const {
+ if (!signaling_thread_->IsCurrent()) {
+ EnableMessageData msg(false);
+ Send(MSG_ENABLED, &msg);
+ return msg.data();
+ }
+ return track_->enabled();
+}
+
+template <class T>
+bool MediaStreamTrackProxy<T>::set_enabled(bool enable) {
+ if (!signaling_thread_->IsCurrent()) {
+ EnableMessageData msg(enable);
+ Send(MSG_SET_ENABLED, &msg);
+ return msg.data();
+ }
+ return track_->set_enabled(enable);
+}
+
+template <class T>
+bool MediaStreamTrackProxy<T>::set_state(
+ MediaStreamTrackInterface::TrackState new_state) {
+ if (!signaling_thread_->IsCurrent()) {
+ // State should only be allowed to be changed from the signaling thread.
+ ASSERT(!"Not Allowed!");
+ return false;
+ }
+ return track_->set_state(new_state);
+}
+
+template <class T>
+void MediaStreamTrackProxy<T>::RegisterObserver(ObserverInterface* observer) {
+ if (!signaling_thread_->IsCurrent()) {
+ ObserverMessageData msg(observer);
+ Send(MSG_REGISTER_OBSERVER, &msg);
+ return;
+ }
+ track_->RegisterObserver(observer);
+}
+
+template <class T>
+void MediaStreamTrackProxy<T>::UnregisterObserver(ObserverInterface* observer) {
+ if (!signaling_thread_->IsCurrent()) {
+ ObserverMessageData msg(observer);
+ Send(MSG_UNREGISTER_OBSERVER, &msg);
+ return;
+ }
+ track_->UnregisterObserver(observer);
+}
+
+template <class T>
+void MediaStreamTrackProxy<T>::Send(uint32 id,
+ talk_base::MessageData* data) const {
+ signaling_thread_->Send(const_cast<MediaStreamTrackProxy<T>*>(this), id,
+ data);
+}
+
+template <class T>
+bool MediaStreamTrackProxy<T>::HandleMessage(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_->RegisterObserver(observer->data());
+ return true;
+ break;
+ }
+ case MSG_UNREGISTER_OBSERVER: {
+ ObserverMessageData* observer = static_cast<ObserverMessageData*>(data);
+ track_->UnregisterObserver(observer->data());
+ return true;
+ break;
+ }
+ case MSG_LABEL: {
+ LabelMessageData* label = static_cast<LabelMessageData*>(data);
+ *(label->data()) = track_->label();
+ return true;
+ }
+ case MSG_SET_ENABLED: {
+ EnableMessageData* enabled = static_cast<EnableMessageData*>(data);
+ enabled->data() = track_->set_enabled(enabled->data());
+ return true;
+ break;
+ }
+ case MSG_ENABLED: {
+ EnableMessageData* enabled = static_cast<EnableMessageData*>(data);
+ enabled->data() = track_->enabled();
+ return true;
+ break;
+ }
+ case MSG_STATE: {
+ TrackStateMessageData* state = static_cast<TrackStateMessageData*>(data);
+ state->data() = track_->state();
+ return true;
+ break;
+ }
+ default:
+ return false;
+ }
+}
+
+AudioTrackProxy::AudioTrackProxy(const std::string& label,
+ talk_base::Thread* signaling_thread)
+ : MediaStreamTrackProxy<LocalAudioTrackInterface>(signaling_thread),
+ audio_track_(AudioTrack::CreateRemote(label)) {
+ Init(audio_track_);
+}
+
+AudioTrackProxy::AudioTrackProxy(const std::string& label,
+ AudioDeviceModule* audio_device,
+ talk_base::Thread* signaling_thread)
+ : MediaStreamTrackProxy<LocalAudioTrackInterface>(signaling_thread),
+ audio_track_(AudioTrack::CreateLocal(label, audio_device)) {
+ Init(audio_track_);
+}
+
+AudioTrackProxy::AudioTrackProxy(LocalAudioTrackInterface* implementation,
+ talk_base::Thread* signaling_thread)
+ : MediaStreamTrackProxy<LocalAudioTrackInterface>(signaling_thread),
+ audio_track_(implementation) {
+ Init(audio_track_);
+}
+
+talk_base::scoped_refptr<AudioTrackInterface> AudioTrackProxy::CreateRemote(
+ const std::string& label,
+ talk_base::Thread* signaling_thread) {
+ ASSERT(signaling_thread != NULL);
+ talk_base::RefCountedObject<AudioTrackProxy>* track =
+ new talk_base::RefCountedObject<AudioTrackProxy>(label, signaling_thread);
+ return track;
+}
+
+talk_base::scoped_refptr<LocalAudioTrackInterface> AudioTrackProxy::CreateLocal(
+ const std::string& label,
+ AudioDeviceModule* audio_device,
+ talk_base::Thread* signaling_thread) {
+ ASSERT(signaling_thread != NULL);
+ talk_base::RefCountedObject<AudioTrackProxy>* track =
+ new talk_base::RefCountedObject<AudioTrackProxy>(label,
+ audio_device,
+ signaling_thread);
+ return track;
+}
+
+talk_base::scoped_refptr<LocalAudioTrackInterface> AudioTrackProxy::CreateLocal(
+ LocalAudioTrackInterface* implementation,
+ talk_base::Thread* signaling_thread) {
+ ASSERT(signaling_thread != NULL);
+ talk_base::RefCountedObject<AudioTrackProxy>* track =
+ new talk_base::RefCountedObject<AudioTrackProxy>(implementation,
+ signaling_thread);
+ return track;
+}
+
+AudioDeviceModule* AudioTrackProxy::GetAudioDevice() {
+ if (!signaling_thread_->IsCurrent()) {
+ AudioDeviceMessageData msg;
+ Send(MSG_GET_AUDIODEVICE, &msg);
+ return msg.audio_device_;
+ }
+ return audio_track_->GetAudioDevice();
+}
+
+void AudioTrackProxy::OnMessage(talk_base::Message* msg) {
+ if (!MediaStreamTrackProxy<LocalAudioTrackInterface>::HandleMessage(msg)) {
+ if (msg->message_id == MSG_GET_AUDIODEVICE) {
+ AudioDeviceMessageData* audio_device =
+ static_cast<AudioDeviceMessageData*>(msg->pdata);
+ audio_device->audio_device_ = audio_track_->GetAudioDevice();
+ } else {
+ ASSERT(!"Not Implemented!");
+ }
+ }
+}
+
+VideoTrackProxy::VideoTrackProxy(const std::string& label,
+ talk_base::Thread* signaling_thread)
+ : MediaStreamTrackProxy<LocalVideoTrackInterface>(signaling_thread),
+ video_track_(VideoTrack::CreateRemote(label)) {
+ Init(video_track_);
+}
+
+VideoTrackProxy::VideoTrackProxy(const std::string& label,
+ cricket::VideoCapturer* video_device,
+ talk_base::Thread* signaling_thread)
+ : MediaStreamTrackProxy<LocalVideoTrackInterface>(signaling_thread),
+ video_track_(VideoTrack::CreateLocal(label, video_device)) {
+ Init(video_track_);
+}
+
+VideoTrackProxy::VideoTrackProxy(LocalVideoTrackInterface* implementation,
+ talk_base::Thread* signaling_thread)
+ : MediaStreamTrackProxy<LocalVideoTrackInterface>(signaling_thread),
+ video_track_(implementation) {
+ Init(video_track_);
+}
+
+talk_base::scoped_refptr<VideoTrackInterface> VideoTrackProxy::CreateRemote(
+ const std::string& label,
+ talk_base::Thread* signaling_thread) {
+ ASSERT(signaling_thread != NULL);
+ talk_base::RefCountedObject<VideoTrackProxy>* track =
+ new talk_base::RefCountedObject<VideoTrackProxy>(label, signaling_thread);
+ return track;
+}
+
+talk_base::scoped_refptr<LocalVideoTrackInterface> VideoTrackProxy::CreateLocal(
+ const std::string& label,
+ cricket::VideoCapturer* video_device,
+ talk_base::Thread* signaling_thread) {
+ ASSERT(signaling_thread != NULL);
+ talk_base::RefCountedObject<VideoTrackProxy>* track =
+ new talk_base::RefCountedObject<VideoTrackProxy>(label, video_device,
+ signaling_thread);
+ return track;
+}
+
+talk_base::scoped_refptr<LocalVideoTrackInterface> VideoTrackProxy::CreateLocal(
+ LocalVideoTrackInterface* implementation,
+ talk_base::Thread* signaling_thread) {
+ ASSERT(signaling_thread != NULL);
+ talk_base::RefCountedObject<VideoTrackProxy>* track =
+ new talk_base::RefCountedObject<VideoTrackProxy>(implementation,
+ signaling_thread);
+ return track;
+}
+
+cricket::VideoCapturer* VideoTrackProxy::GetVideoCapture() {
+ if (!signaling_thread_->IsCurrent()) {
+ VideoDeviceMessageData msg;
+ Send(MSG_GET_VIDEODEVICE, &msg);
+ return msg.video_device_;
+ }
+ return video_track_->GetVideoCapture();
+}
+
+void VideoTrackProxy::SetRenderer(VideoRendererWrapperInterface* renderer) {
+ if (!signaling_thread_->IsCurrent()) {
+ VideoRendererMessageData msg;
+ msg.video_renderer_ = renderer;
+ Send(MSG_SET_VIDEORENDERER, &msg);
+ return;
+ }
+ return video_track_->SetRenderer(renderer);
+}
+
+VideoRendererWrapperInterface* VideoTrackProxy::GetRenderer() {
+ if (!signaling_thread_->IsCurrent()) {
+ VideoRendererMessageData msg;
+ Send(MSG_GET_VIDEORENDERER, &msg);
+ return msg.video_renderer_;
+ }
+ return video_track_->GetRenderer();
+}
+
+void VideoTrackProxy::OnMessage(talk_base::Message* msg) {
+ if (!MediaStreamTrackProxy<LocalVideoTrackInterface>::HandleMessage(msg)) {
+ switch (msg->message_id) {
+ case MSG_GET_VIDEODEVICE: {
+ VideoDeviceMessageData* video_device =
+ static_cast<VideoDeviceMessageData*>(msg->pdata);
+ video_device->video_device_ = video_track_->GetVideoCapture();
+ break;
+ }
+ case MSG_GET_VIDEORENDERER: {
+ VideoRendererMessageData* video_renderer =
+ static_cast<VideoRendererMessageData*>(msg->pdata);
+ video_renderer->video_renderer_ = video_track_->GetRenderer();
+ break;
+ }
+ case MSG_SET_VIDEORENDERER: {
+ VideoRendererMessageData* video_renderer =
+ static_cast<VideoRendererMessageData*>(msg->pdata);
+ video_track_->SetRenderer(video_renderer->video_renderer_.get());
+ break;
+ }
+ default:
+ ASSERT(!"Not Implemented!");
+ break;
+ }
+ }
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/mediastreamtrackproxy.h b/talk/app/webrtc/mediastreamtrackproxy.h
new file mode 100644
index 0000000..590d6ab
--- /dev/null
+++ b/talk/app/webrtc/mediastreamtrackproxy.h
@@ -0,0 +1,149 @@
+/*
+ * 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 includes proxy classes for tracks. The purpose is
+// to make sure tracks are only accessed from the signaling thread.
+
+#ifndef TALK_APP_WEBRTC_MEDIASTREAMTRACKPROXY_H_
+#define TALK_APP_WEBRTC_MEDIASTREAMTRACKPROXY_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/app/webrtc/audiotrackimpl.h"
+#include "talk/app/webrtc/mediastream.h"
+#include "talk/app/webrtc/videotrackimpl.h"
+#include "talk/base/thread.h"
+
+namespace cricket {
+
+class VideoCapturer;
+
+} // namespace cricket
+
+namespace webrtc {
+
+template <class T>
+class MediaStreamTrackProxy : public T,
+ talk_base::MessageHandler {
+ public:
+ void Init(MediaStreamTrackInterface* track);
+ // Implement MediaStreamTrack.
+
+ virtual std::string kind() const;
+ virtual std::string label() const;
+ virtual bool enabled() const;
+ virtual MediaStreamTrackInterface::TrackState state() const;
+ virtual bool set_enabled(bool enable);
+ virtual bool set_state(MediaStreamTrackInterface::TrackState new_state);
+
+ // Implement Notifier
+ virtual void RegisterObserver(ObserverInterface* observer);
+ virtual void UnregisterObserver(ObserverInterface* observer);
+
+ protected:
+ explicit MediaStreamTrackProxy(talk_base::Thread* signaling_thread);
+
+ void Send(uint32 id, talk_base::MessageData* data) const;
+ // Returns true if the message is handled.
+ bool HandleMessage(talk_base::Message* msg);
+
+ mutable talk_base::Thread* signaling_thread_;
+ MediaStreamTrackInterface* track_;
+};
+
+// AudioTrackProxy is a proxy for the AudioTrackInterface. The purpose is
+// to make sure AudioTrack is only accessed from the signaling thread.
+// It can be used as a proxy for both local and remote audio tracks.
+class AudioTrackProxy : public MediaStreamTrackProxy<LocalAudioTrackInterface> {
+ public:
+ static talk_base::scoped_refptr<AudioTrackInterface> CreateRemote(
+ const std::string& label,
+ talk_base::Thread* signaling_thread);
+ static talk_base::scoped_refptr<LocalAudioTrackInterface> CreateLocal(
+ const std::string& label,
+ AudioDeviceModule* audio_device,
+ talk_base::Thread* signaling_thread);
+ static talk_base::scoped_refptr<LocalAudioTrackInterface> CreateLocal(
+ LocalAudioTrackInterface* implementation,
+ talk_base::Thread* signaling_thread);
+
+ virtual AudioDeviceModule* GetAudioDevice();
+
+ protected:
+ AudioTrackProxy(const std::string& label,
+ talk_base::Thread* signaling_thread);
+ AudioTrackProxy(const std::string& label,
+ AudioDeviceModule* audio_device,
+ talk_base::Thread* signaling_thread);
+ AudioTrackProxy(LocalAudioTrackInterface* implementation,
+ talk_base::Thread* signaling_thread);
+ // Implement MessageHandler
+ virtual void OnMessage(talk_base::Message* msg);
+
+ talk_base::scoped_refptr<LocalAudioTrackInterface> audio_track_;
+};
+
+// VideoTrackProxy is a proxy for the VideoTrackInterface and
+// LocalVideoTrackInterface. The purpose is
+// to make sure VideoTrack is only accessed from the signaling thread.
+// It can be used as a proxy for both local and remote video tracks.
+class VideoTrackProxy : public MediaStreamTrackProxy<LocalVideoTrackInterface> {
+ public:
+ static talk_base::scoped_refptr<VideoTrackInterface> CreateRemote(
+ const std::string& label,
+ talk_base::Thread* signaling_thread);
+ static talk_base::scoped_refptr<LocalVideoTrackInterface> CreateLocal(
+ const std::string& label,
+ cricket::VideoCapturer* video_device,
+ talk_base::Thread* signaling_thread);
+ static talk_base::scoped_refptr<LocalVideoTrackInterface> CreateLocal(
+ LocalVideoTrackInterface* implementation,
+ talk_base::Thread* signaling_thread);
+
+ virtual cricket::VideoCapturer* GetVideoCapture();
+ virtual void SetRenderer(VideoRendererWrapperInterface* renderer);
+ VideoRendererWrapperInterface* GetRenderer();
+
+ protected:
+ VideoTrackProxy(const std::string& label,
+ talk_base::Thread* signaling_thread);
+ VideoTrackProxy(const std::string& label,
+ cricket::VideoCapturer* video_device,
+ talk_base::Thread* signaling_thread);
+ VideoTrackProxy(LocalVideoTrackInterface* implementation,
+ talk_base::Thread* signaling_thread);
+
+ // Implement MessageHandler
+ virtual void OnMessage(talk_base::Message* msg);
+
+ talk_base::scoped_refptr<LocalVideoTrackInterface> video_track_;
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_MEDIASTREAMTRACKPROXY_H_
diff --git a/talk/app/webrtc/mediatrackimpl.h b/talk/app/webrtc/mediatrackimpl.h
new file mode 100644
index 0000000..e60801d
--- /dev/null
+++ b/talk/app/webrtc/mediatrackimpl.h
@@ -0,0 +1,81 @@
+/*
+ * 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/mediastream.h"
+#include "talk/app/webrtc/notifierimpl.h"
+
+namespace webrtc {
+
+// MediaTrack implements the interface common to AudioTrackInterface and
+// VideoTrackInterface.
+template <typename T>
+class MediaStreamTrack : public Notifier<T> {
+ public:
+ typedef typename T::TrackState TypedTrackState;
+
+ virtual std::string label() const { return label_; }
+ virtual MediaStreamTrackInterface::TrackState 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) {
+ Notifier<T>::FireOnChanged();
+ }
+ return fire_on_change;
+ }
+ virtual bool set_state(MediaStreamTrackInterface::TrackState new_state) {
+ bool fire_on_change = (state_ != new_state);
+ state_ = new_state;
+ if (fire_on_change)
+ Notifier<T>::FireOnChanged();
+ return true;
+ }
+
+ protected:
+ explicit MediaStreamTrack(const std::string& label)
+ : enabled_(true),
+ label_(label),
+ state_(MediaStreamTrackInterface::kInitializing) {
+ }
+
+ private:
+ bool enabled_;
+ std::string label_;
+ MediaStreamTrackInterface::TrackState state_;
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_MEDIATRACKIMPL_H_
diff --git a/talk/app/webrtc/notifierimpl.h b/talk/app/webrtc/notifierimpl.h
new file mode 100644
index 0000000..bd7c183
--- /dev/null
+++ b/talk/app/webrtc/notifierimpl.h
@@ -0,0 +1,73 @@
+/*
+ * 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_NOTIFIERIMPL_H_
+#define TALK_APP_WEBRTC_NOTIFIERIMPL_H_
+
+#include <list>
+
+#include "talk/base/common.h"
+#include "talk/app/webrtc/mediastream.h"
+
+namespace webrtc {
+
+// Implement a template version of a notifier.
+template <class T>
+class Notifier : public T {
+ public:
+ Notifier() {
+ }
+
+ virtual void RegisterObserver(ObserverInterface* observer) {
+ ASSERT(observer != NULL);
+ observers_.push_back(observer);
+ }
+
+ virtual void UnregisterObserver(ObserverInterface* observer) {
+ for (std::list<ObserverInterface*>::iterator it = observers_.begin();
+ it != observers_.end(); it++) {
+ if (*it == observer) {
+ observers_.erase(it);
+ break;
+ }
+ }
+ }
+
+ void FireOnChanged() {
+ for (std::list<ObserverInterface*>::iterator it = observers_.begin();
+ it != observers_.end(); ++it) {
+ (*it)-> OnChanged();
+ }
+ }
+
+ protected:
+ std::list<ObserverInterface*> observers_;
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_NOTIFIERIMPL_H_
diff --git a/talk/app/webrtc/peerconnection.h b/talk/app/webrtc/peerconnection.h
index 62c2504..24a1cc4 100644
--- a/talk/app/webrtc/peerconnection.h
+++ b/talk/app/webrtc/peerconnection.h
@@ -1,6 +1,6 @@
/*
* libjingle
- * Copyright 2004--2011, Google Inc.
+ * 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:
@@ -25,107 +25,253 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+// This file contains the PeerConnection interface as defined in
+// http://dev.w3.org/2011/webrtc/editor/webrtc.html#peer-to-peer-connections.
+// Applications must use this interface to implement peerconnection.
+// PeerConnectionFactory class provides factory methods to create
+// peerconnection, mediastream and media tracks objects.
+//
+// The Following steps are needed to setup a typical call.
+// 1. Create a PeerConnectionFactoryInterface. Check constructors for more
+// information about input parameters.
+// 2. Create a PeerConnection object. Provide a configuration string which
+// points either to stun or turn server to generate ICE candidates and provide
+// an object that implements the PeerConnectionObserver interface.
+// Now PeerConnection will startcollecting ICE candidates.
+// 3. Create local MediaStream and MediaTracks using the PeerConnectionFactory
+// and add it to PeerConnection by calling AddStream.
+// 4. Once all mediastreams are added to peerconnection, call
+// CommitStreamChanges. Now PeerConnection starts generating an offer based on
+// the local mediastreams.
+// 5. When PeerConnection have generated the ICE candidates it will call the
+// observer OnSignalingMessage callback with the initial offer.
+// 6. When an Answer from peer received it must be supplied to the
+// PeerConnection by calling ProcessSignalingMessage.
+// At this point PeerConnection knows remote capabilities and ICE candidates.
+// Media will start flowing to the remote peer.
+
+// The Receiver of a call can decide to accept or reject the call.
+// This decision will be taken by the application not peerconnection.
+// If application decides to accept the call
+// 1. Create PeerConnectionFactoryInterface if it doesn't exist.
+// 2. Create new PeerConnection
+// 3. Provide the remote offer to the new PeerConnection object by calling
+// ProcessSignalingMessage.
+// 4. PeerConnection will call the observer function OnAddStream with remote
+// MediaStream and tracks information.
+// 5. PeerConnection will call the observer function OnSignalingMessage with
+// local ICE candidates in a answer message.
+// 6. Application can add it's own MediaStreams by calling AddStream.
+// When all streams have been added the application must call
+// CommitStreamChanges. Streams can be added at any time after the
+// PeerConnection object have been created.
+
#ifndef TALK_APP_WEBRTC_PEERCONNECTION_H_
#define TALK_APP_WEBRTC_PEERCONNECTION_H_
-// TODO - Add a factory class or some kind of PeerConnection manager
-// to support multiple PeerConnection object instantiation. This class will
-// create ChannelManager object and pass it to PeerConnection object. Otherwise
-// each PeerConnection object will have its own ChannelManager hence MediaEngine
-// and VoiceEngine/VideoEngine.
-
#include <string>
+#include <vector>
-namespace cricket {
-class VideoRenderer;
-}
+#include "talk/app/webrtc/mediastream.h"
+#include "talk/base/socketaddress.h"
namespace talk_base {
class Thread;
}
-namespace webrtc {
+namespace cricket {
+class PortAllocator;
+}
+namespace webrtc {
+class VideoCaptureModule;
+
+// MediaStream container interface.
+class StreamCollectionInterface : public talk_base::RefCountInterface {
+ public:
+ virtual size_t count() = 0;
+ virtual MediaStreamInterface* at(size_t index) = 0;
+ virtual MediaStreamInterface* find(const std::string& label) = 0;
+ protected:
+ // Dtor protected as objects shouldn't be deleted via this interface.
+ ~StreamCollectionInterface() {}
+};
+
+// PeerConnection callback interface. Application should implement these
+// methods.
class PeerConnectionObserver {
public:
- // serialized signaling message
+ enum StateType {
+ kReadyState,
+ kIceState,
+ kSdpState,
+ };
+
+ virtual void OnError() = 0;
+
+ virtual void OnMessage(const std::string& msg) = 0;
+
+ // Serialized signaling message
virtual void OnSignalingMessage(const std::string& msg) = 0;
- // Triggered when a remote peer accepts a media connection.
- virtual void OnAddStream(const std::string& stream_id, bool video) = 0;
+ // Triggered when ReadyState, SdpState or IceState have changed.
+ virtual void OnStateChange(StateType state_changed) = 0;
- // Triggered when a remote peer closes a media stream.
- virtual void OnRemoveStream(const std::string& stream_id, bool video) = 0;
+ // Triggered when media is received on a new stream from remote peer.
+ virtual void OnAddStream(MediaStreamInterface* stream) = 0;
+
+ // Triggered when a remote peer close a stream.
+ virtual void OnRemoveStream(MediaStreamInterface* stream) = 0;
protected:
// Dtor protected as objects shouldn't be deleted via this interface.
~PeerConnectionObserver() {}
};
-class PeerConnection {
+
+class PeerConnectionInterface : public talk_base::RefCountInterface {
public:
enum ReadyState {
- NEW = 0,
- NEGOTIATING,
- ACTIVE,
- CLOSED,
+ kNew,
+ kNegotiating,
+ kActive,
+ kClosing,
+ kClosed,
};
- virtual ~PeerConnection() {}
+ enum SdpState {
+ kSdpNew,
+ kSdpIdle,
+ kSdpWaiting,
+ };
- // Register a listener
- virtual void RegisterObserver(PeerConnectionObserver* observer) = 0;
+ // Process a signaling message using the ROAP protocol.
+ virtual void ProcessSignalingMessage(const std::string& msg) = 0;
- // SignalingMessage in json format
- virtual bool SignalingMessage(const std::string& msg) = 0;
+ // Sends the msg over a data stream.
+ virtual bool Send(const std::string& msg) = 0;
- // Asynchronously adds a local stream device to the peer
- // connection.
- virtual bool AddStream(const std::string& stream_id, bool video) = 0;
+ // Accessor methods to active local streams.
+ virtual talk_base::scoped_refptr<StreamCollectionInterface>
+ local_streams() = 0;
- // Asynchronously removes a local stream device from the peer
- // connection. The operation is complete when
- // PeerConnectionObserver::OnRemoveStream is called.
- virtual bool RemoveStream(const std::string& stream_id) = 0;
+ // Accessor methods to remote streams.
+ virtual talk_base::scoped_refptr<StreamCollectionInterface>
+ remote_streams() = 0;
- // Info the peerconnection that it is time to return the signaling
- // information. The operation is complete when
- // PeerConnectionObserver::OnSignalingMessage is called.
- virtual bool Connect() = 0;
+ // Add a new local stream.
+ // This function does not trigger any changes to the stream until
+ // CommitStreamChanges is called.
+ virtual void AddStream(LocalMediaStreamInterface* stream) = 0;
- // Remove all the streams and tear down the session.
- // After the Close() is called, the OnSignalingMessage will be invoked
- // asynchronously. And before OnSignalingMessage is called,
- // OnRemoveStream will be called for each stream that was active.
- // TODO: Add an event such as onclose, or onreadystatechanged
- // when the readystate reaches the closed state (no more streams in the
- // peerconnection object.
- virtual bool Close() = 0;
+ // Remove a local stream and stop sending it.
+ // This function does not trigger any changes to the stream until
+ // CommitStreamChanges is called.
+ virtual void RemoveStream(LocalMediaStreamInterface* stream) = 0;
- // Set the audio input & output devices based on the given device name.
- // An empty device name means to use the default audio device.
- virtual bool SetAudioDevice(const std::string& wave_in_device,
- const std::string& wave_out_device,
- int opts) = 0;
+ // Commit Stream changes. This will start sending media on new streams
+ // and stop sending media on removed streams.
+ virtual void CommitStreamChanges() = 0;
- // Set the video renderer for the camera preview.
- virtual bool SetLocalVideoRenderer(cricket::VideoRenderer* renderer) = 0;
+ // Close the current session. This will trigger a Shutdown message
+ // being sent and the readiness state change to Closing.
+ // After calling this function no changes can be made to the sending streams.
+ virtual void Close() = 0;
- // Set the video renderer for the specified stream.
- virtual bool SetVideoRenderer(const std::string& stream_id,
- cricket::VideoRenderer* renderer) = 0;
+ // Returns the current ReadyState.
+ virtual ReadyState ready_state() = 0;
- // Set video capture device
- // For Chromium the cam_device should use the capture session id.
- // For standalone app, cam_device is the camera name. It will try to
- // set the default capture device when cam_device is "".
- virtual bool SetVideoCapture(const std::string& cam_device) = 0;
+ // Returns the current SdpState.
+ virtual SdpState sdp_state() = 0;
- // Returns the state of the PeerConnection object. See the ReadyState
- // enum for valid values.
- virtual ReadyState GetReadyState() = 0;
+ protected:
+ // Dtor protected as objects shouldn't be deleted via this interface.
+ ~PeerConnectionInterface() {}
};
+// Helper function to create a new instance of cricket::VideoCapturer
+// from VideoCaptureModule.
+// TODO: This function should be removed once chrome implement video
+// capture as the cricket::VideoCapturer.
+cricket::VideoCapturer* CreateVideoCapturer(VideoCaptureModule* vcm);
+
+// Factory class used for creating cricket::PortAllocator that is used
+// for ICE negotiation.
+class PortAllocatorFactoryInterface : public talk_base::RefCountInterface {
+ public:
+ struct StunConfiguration {
+ StunConfiguration(const std::string& address, int port)
+ : server(address, port) {}
+ // STUN server address and port.
+ talk_base::SocketAddress server;
+ };
+
+ struct TurnConfiguration {
+ TurnConfiguration(const std::string& address,
+ int port,
+ const std::string& username,
+ const std::string& password)
+ : server(address, port),
+ username(username),
+ password(password) {}
+ talk_base::SocketAddress server;
+ std::string username;
+ std::string password;
+ };
+
+ virtual cricket::PortAllocator* CreatePortAllocator(
+ const std::vector<StunConfiguration>& stun_servers,
+ const std::vector<TurnConfiguration>& turn_configurations) = 0;
+
+ protected:
+ PortAllocatorFactoryInterface() {}
+ ~PortAllocatorFactoryInterface() {}
+};
+
+// PeerConnectionFactoryInterface is the factory interface use for creating
+// PeerConnection, MediaStream and media tracks.
+// PeerConnectionFactoryInterface will create required libjingle threads,
+// socket and network manager factory classes for networking.
+// If application decides to provide its own implementation of these classes
+// it should use alternate create method which accepts a threads and a
+// PortAllocatorFactoryInterface as input.
+class PeerConnectionFactoryInterface : public talk_base::RefCountInterface {
+ public:
+ virtual talk_base::scoped_refptr<PeerConnectionInterface>
+ CreatePeerConnection(const std::string& config,
+ PeerConnectionObserver* observer) = 0;
+
+ virtual talk_base::scoped_refptr<LocalMediaStreamInterface>
+ CreateLocalMediaStream(const std::string& label) = 0;
+
+ virtual talk_base::scoped_refptr<LocalVideoTrackInterface>
+ CreateLocalVideoTrack(const std::string& label,
+ cricket::VideoCapturer* video_device) = 0;
+
+ virtual talk_base::scoped_refptr<LocalAudioTrackInterface>
+ CreateLocalAudioTrack(const std::string& label,
+ AudioDeviceModule* audio_device) = 0;
+
+ protected:
+ // Dtor and ctor protected as objects shouldn't be created or deleted via
+ // this interface.
+ PeerConnectionFactoryInterface() {}
+ ~PeerConnectionFactoryInterface() {} // NOLINT
+};
+
+// Create a new instance of PeerConnectionFactoryInterface.
+talk_base::scoped_refptr<PeerConnectionFactoryInterface>
+CreatePeerConnectionFactory();
+
+// Create a new instance of PeerConnectionFactoryInterface.
+// Ownership of the arguments are not transfered to this object and must
+// remain in scope for the lifetime of the PeerConnectionFactoryInterface.
+talk_base::scoped_refptr<PeerConnectionFactoryInterface>
+CreatePeerConnectionFactory(talk_base::Thread* worker_thread,
+ talk_base::Thread* signaling_thread,
+ PortAllocatorFactoryInterface* factory,
+ AudioDeviceModule* default_adm);
+
} // namespace webrtc
#endif // TALK_APP_WEBRTC_PEERCONNECTION_H_
diff --git a/talk/app/webrtc/peerconnection_unittest.cc b/talk/app/webrtc/peerconnection_unittest.cc
new file mode 100644
index 0000000..2caa7c6
--- /dev/null
+++ b/talk/app/webrtc/peerconnection_unittest.cc
@@ -0,0 +1,351 @@
+/*
+ * 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 <stdio.h>
+
+#include <list>
+
+#include "talk/app/webrtc/mediastream.h"
+#include "talk/app/webrtc/peerconnection.h"
+#include "talk/app/webrtc/test/fakevideocapturemodule.h"
+#include "talk/base/gunit.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/thread.h"
+#include "talk/session/phone/fakevideorenderer.h"
+#include "talk/session/phone/videorenderer.h"
+
+void GetAllVideoTracks(webrtc::MediaStreamInterface* media_stream,
+ std::list<webrtc::VideoTrackInterface*>* video_tracks) {
+ webrtc::VideoTracks* track_list = media_stream->video_tracks();
+ for (size_t i = 0; i < track_list->count(); ++i) {
+ webrtc::VideoTrackInterface* track = track_list->at(i);
+ video_tracks->push_back(track);
+ }
+}
+
+class SignalingMessageReceiver {
+ public:
+ virtual void ReceiveMessage(const std::string& msg) = 0;
+
+ virtual int num_rendered_frames() = 0;
+
+ // Makes it possible for the remote side to decide when to start capturing.
+ // This makes it possible to wait with capturing until a renderer has been
+ // added.
+ virtual void StartCapturing() = 0;
+
+ protected:
+ SignalingMessageReceiver() {}
+ virtual ~SignalingMessageReceiver() {}
+};
+
+class PeerConnectionP2PTestClient
+ : public webrtc::PeerConnectionObserver,
+ public SignalingMessageReceiver {
+ public:
+ static PeerConnectionP2PTestClient* CreateClient(int id) {
+ PeerConnectionP2PTestClient* client = new PeerConnectionP2PTestClient(id);
+ if (!client->Init()) {
+ delete client;
+ return NULL;
+ }
+ return client;
+ }
+
+ ~PeerConnectionP2PTestClient() {
+ }
+
+ void StartSession() {
+ if (video_track_.get() != NULL) {
+ // Tracks have already been set up.
+ return;
+ }
+ // TODO: the default audio device module is used regardless of
+ // the second parameter to the CreateLocalAudioTrack(..) call. Maybe remove
+ // the second parameter from the API altogether?
+ talk_base::scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
+ peer_connection_factory_->CreateLocalAudioTrack("audio_track", NULL));
+
+ CreateLocalVideoTrack();
+
+ talk_base::scoped_refptr<webrtc::LocalMediaStreamInterface> stream =
+ peer_connection_factory_->CreateLocalMediaStream("stream_label");
+
+ stream->AddTrack(audio_track);
+ stream->AddTrack(video_track_);
+
+ peer_connection_->AddStream(stream);
+ peer_connection_->CommitStreamChanges();
+ }
+
+ void StartCapturing() {
+ if (fake_video_capture_module_ != NULL) {
+ fake_video_capture_module_->StartCapturing();
+ }
+ }
+
+ bool SessionActive() {
+ return peer_connection_->ready_state() ==
+ webrtc::PeerConnectionInterface::kActive;
+ }
+
+ void StopSession() {
+ if (fake_video_capture_module_ != NULL) {
+ fake_video_capture_module_->StopCapturing();
+ }
+ // TODO: investigate why calling Close() triggers a crash when
+ // deleting the PeerConnection.
+ // peer_connection_->Close();
+ }
+
+ void set_signaling_message_receiver(
+ SignalingMessageReceiver* signaling_message_receiver) {
+ signaling_message_receiver_ = signaling_message_receiver;
+ }
+
+ bool FramesReceivedCheck(int number_of_frames) {
+ if (number_of_frames > signaling_message_receiver_->num_rendered_frames()) {
+ return false;
+ }
+ else {
+ EXPECT_LT(number_of_frames, fake_video_capture_module_->sent_frames());
+ }
+ return true;
+ }
+
+ // SignalingMessageReceiver callback.
+ virtual void ReceiveMessage(const std::string& msg) {
+ peer_connection_->ProcessSignalingMessage(msg);
+ }
+
+ virtual int num_rendered_frames() {
+ if (fake_video_renderer_ == NULL) {
+ return -1;
+ }
+ return fake_video_renderer_->num_rendered_frames();
+ }
+
+ // PeerConnectionObserver callbacks.
+ virtual void OnError() {}
+ virtual void OnMessage(const std::string&) {}
+ virtual void OnSignalingMessage(const std::string& msg) {
+ if (signaling_message_receiver_ == NULL) {
+ // Remote party may be deleted.
+ return;
+ }
+ signaling_message_receiver_->ReceiveMessage(msg);
+ }
+ virtual void OnStateChange(StateType /*state_changed*/) {}
+ virtual void OnAddStream(webrtc::MediaStreamInterface* media_stream) {
+ std::list<webrtc::VideoTrackInterface*> video_tracks;
+ GetAllVideoTracks(media_stream, &video_tracks);
+ int track_id = 0;
+ // Currently only one video track is supported.
+ // TODO: enable multiple video tracks.
+ EXPECT_EQ(1u, video_tracks.size());
+ for (std::list<webrtc::VideoTrackInterface*>::iterator iter =
+ video_tracks.begin();
+ iter != video_tracks.end();
+ ++iter) {
+ fake_video_renderer_ = new cricket::FakeVideoRenderer();
+ video_renderer_wrapper_ = webrtc::CreateVideoRenderer(
+ fake_video_renderer_);
+ (*iter)->SetRenderer(video_renderer_wrapper_);
+ track_id++;
+ }
+ // The video renderer has been added. Tell the far end to start capturing
+ // frames. That way the number of captured frames should be equal to number
+ // of rendered frames.
+ if (signaling_message_receiver_ != NULL) {
+ signaling_message_receiver_->StartCapturing();
+ return;
+ }
+ }
+ virtual void OnRemoveStream(webrtc::MediaStreamInterface* /*media_stream*/) {
+ }
+
+ private:
+ explicit PeerConnectionP2PTestClient(int id)
+ : id_(id),
+ fake_video_capture_module_(NULL),
+ fake_video_renderer_(NULL),
+ signaling_message_receiver_(NULL) {
+ }
+
+ bool Init() {
+ EXPECT_TRUE(peer_connection_.get() == NULL);
+ EXPECT_TRUE(peer_connection_factory_.get() == NULL);
+ peer_connection_factory_ = webrtc::CreatePeerConnectionFactory();
+ if (peer_connection_factory_.get() == NULL) {
+ return false;
+ }
+
+ const std::string server_configuration = "STUN stun.l.google.com:19302";
+ peer_connection_ = peer_connection_factory_->CreatePeerConnection(
+ server_configuration, this);
+ return peer_connection_.get() != NULL;
+ }
+
+ void GenerateRecordingFileName(int track, std::string* file_name) {
+ if (file_name == NULL) {
+ return;
+ }
+ std::stringstream file_name_stream;
+ file_name_stream << "p2p_test_client_" << id_ << "_videotrack_" << track <<
+ ".yuv";
+ file_name->clear();
+ *file_name = file_name_stream.str();
+ }
+
+ void CreateLocalVideoTrack() {
+ fake_video_capture_module_ = FakeVideoCaptureModule::Create(
+ talk_base::Thread::Current());
+ // TODO: Use FakeVideoCapturer instead of FakeVideoCaptureModule.
+ video_track_ = peer_connection_factory_->CreateLocalVideoTrack(
+ "video_track", CreateVideoCapturer(fake_video_capture_module_));
+ }
+
+ int id_;
+ talk_base::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
+ talk_base::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
+ peer_connection_factory_;
+
+ // Owns and ensures that fake_video_capture_module_ is available as long as
+ // this class exists. It also ensures destruction of the memory associated
+ // with it when this class is deleted.
+ talk_base::scoped_refptr<webrtc::LocalVideoTrackInterface> video_track_;
+ // Needed to keep track of number of frames send.
+ FakeVideoCaptureModule* fake_video_capture_module_;
+ // Ensures that fake_video_renderer_ is available as long as this class
+ // exists. It also ensures destruction of the memory associated with it when
+ // this class is deleted.
+ talk_base::scoped_refptr<webrtc::VideoRendererWrapperInterface>
+ video_renderer_wrapper_;
+ // Needed to keep track of number of frames received.
+ cricket::FakeVideoRenderer* fake_video_renderer_;
+
+ // For remote peer communication.
+ SignalingMessageReceiver* signaling_message_receiver_;
+};
+
+class P2PTestConductor : public testing::Test {
+ public:
+ virtual void SetUp() {
+ EXPECT_TRUE(Init());
+ }
+ // Return true if session no longer is pending. I.e. if the session is active
+ // or failed.
+ bool ActivationNotPending() {
+ if (!IsInitialized()) {
+ return true;
+ }
+ return SessionActive();
+ }
+ bool SessionActive() {
+ return initiating_client_->SessionActive() &&
+ receiving_client_->SessionActive();
+ }
+ // Return true if the number of frames provided have been received or it is
+ // known that that will never occur (e.g. no frames will be sent or
+ // captured).
+ bool FramesNotPending(int frames_to_receive) {
+ if (!IsInitialized()) {
+ return true;
+ }
+ return FramesReceivedCheck(frames_to_receive);
+ }
+ bool FramesReceivedCheck(int frames_received) {
+ return initiating_client_->FramesReceivedCheck(frames_received) &&
+ receiving_client_->FramesReceivedCheck(frames_received);
+ }
+ ~P2PTestConductor() {
+ if (initiating_client_.get() != NULL) {
+ initiating_client_->set_signaling_message_receiver(NULL);
+ }
+ if (receiving_client_.get() != NULL) {
+ receiving_client_->set_signaling_message_receiver(NULL);
+ }
+ }
+
+ bool StartSession() {
+ if (!IsInitialized()) {
+ return false;
+ }
+ initiating_client_->StartSession();
+ receiving_client_->StartSession();
+ return true;
+ }
+
+ bool StopSession() {
+ if (!IsInitialized()) {
+ return false;
+ }
+ initiating_client_->StopSession();
+ receiving_client_->StopSession();
+ return true;
+ }
+
+ private:
+ bool Init() {
+ initiating_client_.reset(PeerConnectionP2PTestClient::CreateClient(0));
+ receiving_client_.reset(PeerConnectionP2PTestClient::CreateClient(1));
+ if ((initiating_client_.get() == NULL) ||
+ (receiving_client_.get() == NULL)) {
+ return false;
+ }
+ initiating_client_->set_signaling_message_receiver(receiving_client_.get());
+ receiving_client_->set_signaling_message_receiver(initiating_client_.get());
+ return true;
+ }
+ bool IsInitialized() const {
+ return (initiating_client_.get() != NULL) &&
+ (receiving_client_.get() != NULL);
+ }
+
+ talk_base::scoped_ptr<PeerConnectionP2PTestClient> initiating_client_;
+ talk_base::scoped_ptr<PeerConnectionP2PTestClient> receiving_client_;
+};
+
+// This test sets up a call between two parties. Both parties send static frames
+// to each other. Once the test is finished the number of sent frames is
+// compared to the number of received frames.
+TEST_F(P2PTestConductor, LocalP2PTest) {
+ EXPECT_TRUE(StartSession());
+ const int kMaxWaitForActivationMs = 5000;
+ EXPECT_TRUE_WAIT(ActivationNotPending(), kMaxWaitForActivationMs);
+ EXPECT_TRUE(SessionActive());
+
+ // TODO - These are failing on Windows dbg paricular on pulse.
+ // removing check now.
+#if 0
+ const int kEndFrameCount = 10;
+ const int kMaxWaitForFramesMs = 5000;
+ EXPECT_TRUE_WAIT(FramesNotPending(kEndFrameCount), kMaxWaitForFramesMs);
+ EXPECT_TRUE(FramesReceivedCheck(kEndFrameCount));
+#endif
+ EXPECT_TRUE(StopSession());
+}
diff --git a/talk/app/webrtc/peerconnectionfactory_unittest.cc b/talk/app/webrtc/peerconnectionfactory_unittest.cc
new file mode 100644
index 0000000..5056e17
--- /dev/null
+++ b/talk/app/webrtc/peerconnectionfactory_unittest.cc
@@ -0,0 +1,80 @@
+/*
+ * 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
+ * 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 "talk/app/webrtc/mediastreamimpl.h"
+#include "talk/app/webrtc/peerconnectionfactoryimpl.h"
+#include "talk/app/webrtc/fakeportallocatorfactory.h"
+#include "talk/base/gunit.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/thread.h"
+#include "talk/session/phone/webrtccommon.h"
+#include "talk/session/phone/webrtcvoe.h"
+
+static const char kStunConfiguration[] = "STUN stun.l.google.com:19302";
+
+namespace webrtc {
+
+class NullPeerConnectionObserver : public PeerConnectionObserver {
+ public:
+ virtual void OnError() {}
+ virtual void OnMessage(const std::string& msg) {}
+ virtual void OnSignalingMessage(const std::string& msg) {}
+ virtual void OnStateChange(StateType state_changed) {}
+ virtual void OnAddStream(MediaStreamInterface* stream) {}
+ virtual void OnRemoveStream(MediaStreamInterface* stream) {}
+};
+
+TEST(PeerConnectionFactory, CreatePCUsingInternalModules) {
+ talk_base::scoped_refptr<PeerConnectionFactoryInterface> factory(
+ CreatePeerConnectionFactory());
+ ASSERT_TRUE(factory.get() != NULL);
+
+ NullPeerConnectionObserver observer;
+ talk_base::scoped_refptr<PeerConnectionInterface> pc(
+ factory->CreatePeerConnection(kStunConfiguration, &observer));
+
+ EXPECT_TRUE(pc.get() != NULL);
+}
+
+TEST(PeerConnectionFactory, CreatePCUsingExternalModules) {
+ talk_base::scoped_refptr<PortAllocatorFactoryInterface> allocator_factory(
+ FakePortAllocatorFactory::Create());
+
+ talk_base::scoped_refptr<PeerConnectionFactoryInterface> factory =
+ CreatePeerConnectionFactory(talk_base::Thread::Current(),
+ talk_base::Thread::Current(),
+ allocator_factory.get(),
+ NULL);
+ ASSERT_TRUE(factory.get() != NULL);
+
+ NullPeerConnectionObserver observer;
+ talk_base::scoped_refptr<PeerConnectionInterface> pc(
+ factory->CreatePeerConnection(kStunConfiguration, &observer));
+ EXPECT_TRUE(pc.get() != NULL);
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/peerconnectionfactoryimpl.cc b/talk/app/webrtc/peerconnectionfactoryimpl.cc
new file mode 100644
index 0000000..e74e16e
--- /dev/null
+++ b/talk/app/webrtc/peerconnectionfactoryimpl.cc
@@ -0,0 +1,252 @@
+/*
+ * libjingle
+ * Copyright 2004--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/peerconnectionfactoryimpl.h"
+
+#include "talk/app/webrtc/mediastreamproxy.h"
+#include "talk/app/webrtc/mediastreamtrackproxy.h"
+#include "talk/app/webrtc/peerconnectionimpl.h"
+#include "talk/app/webrtc/portallocatorfactory.h"
+#include "talk/session/phone/dummydevicemanager.h"
+#include "talk/session/phone/webrtcmediaengine.h"
+
+#ifdef WEBRTC_RELATIVE_PATH
+#include "modules/audio_device/main/interface/audio_device.h"
+#else
+#include "third_party/webrtc/files/include/audio_device.h"
+#endif
+
+using talk_base::scoped_refptr;
+
+namespace {
+
+typedef talk_base::TypedMessageData<bool> InitMessageData;
+
+struct CreatePeerConnectionParams : public talk_base::MessageData {
+ CreatePeerConnectionParams(const std::string& configuration,
+ webrtc::PeerConnectionObserver* observer)
+ : configuration(configuration), observer(observer) {
+ }
+ scoped_refptr<webrtc::PeerConnectionInterface> peerconnection;
+ const std::string& configuration;
+ webrtc::PeerConnectionObserver* observer;
+};
+
+enum {
+ MSG_INIT_FACTORY = 1,
+ MSG_TERMINATE_FACTORY = 2,
+ MSG_CREATE_PEERCONNECTION = 3,
+};
+
+} // namespace
+
+namespace webrtc {
+
+scoped_refptr<PeerConnectionFactoryInterface>
+CreatePeerConnectionFactory() {
+ talk_base::RefCountedObject<PeerConnectionFactory>* pc_factory =
+ new talk_base::RefCountedObject<PeerConnectionFactory>();
+
+ if (!pc_factory->Initialize()) {
+ delete pc_factory;
+ pc_factory = NULL;
+ }
+ return pc_factory;
+}
+
+scoped_refptr<PeerConnectionFactoryInterface>
+CreatePeerConnectionFactory(talk_base::Thread* worker_thread,
+ talk_base::Thread* signaling_thread,
+ PortAllocatorFactoryInterface* factory,
+ AudioDeviceModule* default_adm) {
+ talk_base::RefCountedObject<PeerConnectionFactory>* pc_factory =
+ new talk_base::RefCountedObject<PeerConnectionFactory>(
+ worker_thread, signaling_thread, factory, default_adm);
+ if (!pc_factory->Initialize()) {
+ delete pc_factory;
+ pc_factory = NULL;
+ }
+ return pc_factory;
+}
+
+PeerConnectionFactory::PeerConnectionFactory()
+ : owns_ptrs_(true),
+ signaling_thread_(new talk_base::Thread),
+ worker_thread_(new talk_base::Thread) {
+ bool result = signaling_thread_->Start();
+ ASSERT(result);
+ result = worker_thread_->Start();
+ ASSERT(result);
+}
+
+PeerConnectionFactory::PeerConnectionFactory(
+ talk_base::Thread* worker_thread,
+ talk_base::Thread* signaling_thread,
+ PortAllocatorFactoryInterface* port_allocator_factory,
+ AudioDeviceModule* default_adm)
+ : owns_ptrs_(false),
+ signaling_thread_(signaling_thread),
+ worker_thread_(worker_thread),
+ allocator_factory_(port_allocator_factory),
+ default_adm_(default_adm) {
+ ASSERT(worker_thread != NULL);
+ ASSERT(signaling_thread != NULL);
+ ASSERT(allocator_factory_.get() != NULL);
+ // TODO: Currently there is no way creating an external adm in
+ // libjingle source tree. So we can 't currently assert if this is NULL.
+ // ASSERT(default_adm != NULL);
+}
+
+PeerConnectionFactory::~PeerConnectionFactory() {
+ signaling_thread_->Clear(this);
+ signaling_thread_->Send(this, MSG_TERMINATE_FACTORY);
+ if (owns_ptrs_) {
+ delete signaling_thread_;
+ delete worker_thread_;
+ }
+}
+
+bool PeerConnectionFactory::Initialize() {
+ InitMessageData result(false);
+ signaling_thread_->Send(this, MSG_INIT_FACTORY, &result);
+ return result.data();
+}
+
+void PeerConnectionFactory::OnMessage(talk_base::Message* msg) {
+ switch (msg->message_id) {
+ case MSG_INIT_FACTORY: {
+ InitMessageData* pdata = static_cast<InitMessageData*> (msg->pdata);
+ pdata->data() = Initialize_s();
+ break;
+ }
+ case MSG_TERMINATE_FACTORY: {
+ Terminate_s();
+ break;
+ }
+ case MSG_CREATE_PEERCONNECTION: {
+ CreatePeerConnectionParams* pdata =
+ static_cast<CreatePeerConnectionParams*> (msg->pdata);
+ pdata->peerconnection = CreatePeerConnection_s(pdata->configuration,
+ pdata->observer);
+ break;
+ }
+ }
+}
+
+bool PeerConnectionFactory::Initialize_s() {
+ if (owns_ptrs_) {
+ allocator_factory_ = PortAllocatorFactory::Create(worker_thread_);
+ if (allocator_factory_.get() == NULL)
+ return false;
+ }
+
+ cricket::DummyDeviceManager* device_manager(
+ new cricket::DummyDeviceManager());
+ // TODO: Need to make sure only one VoE is created inside
+ // WebRtcMediaEngine.
+ cricket::WebRtcMediaEngine* webrtc_media_engine(
+ new cricket::WebRtcMediaEngine(default_adm_.get(),
+ NULL, // No secondary adm.
+ NULL)); // No vcm available.
+
+ channel_manager_.reset(new cricket::ChannelManager(
+ webrtc_media_engine, device_manager, worker_thread_));
+ if (!channel_manager_->Init()) {
+ return false;
+ }
+ return true;
+}
+
+// Terminate what we created on the signaling thread.
+void PeerConnectionFactory::Terminate_s() {
+ channel_manager_.reset(NULL);
+ if (owns_ptrs_) {
+ allocator_factory_ = NULL;
+ }
+}
+
+scoped_refptr<PeerConnectionInterface>
+PeerConnectionFactory::CreatePeerConnection(
+ const std::string& configuration,
+ PeerConnectionObserver* observer) {
+ CreatePeerConnectionParams params(configuration, observer);
+ signaling_thread_->Send(this, MSG_CREATE_PEERCONNECTION, ¶ms);
+ return params.peerconnection;
+}
+
+scoped_refptr<PeerConnectionInterface>
+PeerConnectionFactory::CreatePeerConnection_s(
+ const std::string& configuration,
+ PeerConnectionObserver* observer) {
+ talk_base::RefCountedObject<PeerConnection>* pc(
+ new talk_base::RefCountedObject<PeerConnection>(this));
+ if (!pc->Initialize(configuration, observer)) {
+ delete pc;
+ pc = NULL;
+ }
+ return pc;
+}
+
+scoped_refptr<LocalMediaStreamInterface>
+PeerConnectionFactory::CreateLocalMediaStream(
+ const std::string& label) {
+ return MediaStreamProxy::Create(label, signaling_thread_);
+}
+
+scoped_refptr<LocalVideoTrackInterface>
+PeerConnectionFactory::CreateLocalVideoTrack(
+ const std::string& label,
+ cricket::VideoCapturer* video_device) {
+ return VideoTrackProxy::CreateLocal(label, video_device,
+ signaling_thread_);
+}
+
+scoped_refptr<LocalAudioTrackInterface>
+PeerConnectionFactory::CreateLocalAudioTrack(
+ const std::string& label,
+ AudioDeviceModule* audio_device) {
+ return AudioTrackProxy::CreateLocal(label, audio_device,
+ signaling_thread_);
+}
+
+cricket::ChannelManager* PeerConnectionFactory::channel_manager() {
+ return channel_manager_.get();
+}
+
+talk_base::Thread* PeerConnectionFactory::signaling_thread() {
+ return signaling_thread_;
+}
+
+talk_base::Thread* PeerConnectionFactory::worker_thread() {
+ return worker_thread_;
+}
+
+PortAllocatorFactoryInterface* PeerConnectionFactory::port_allocator_factory() {
+ return allocator_factory_.get();
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/peerconnectionfactoryimpl.h b/talk/app/webrtc/peerconnectionfactoryimpl.h
new file mode 100644
index 0000000..ba22d47
--- /dev/null
+++ b/talk/app/webrtc/peerconnectionfactoryimpl.h
@@ -0,0 +1,94 @@
+/*
+ * 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_PEERCONNECTIONFACTORYIMPL_H_
+#define TALK_APP_WEBRTC_PEERCONNECTIONFACTORYIMPL_H_
+
+#include <string>
+
+#include "talk/base/scoped_ptr.h"
+#include "talk/app/webrtc/peerconnection.h"
+#include "talk/app/webrtc/mediastream.h"
+#include "talk/base/thread.h"
+#include "talk/session/phone/channelmanager.h"
+
+namespace webrtc {
+
+class PeerConnectionFactory : public PeerConnectionFactoryInterface,
+ public talk_base::MessageHandler {
+ public:
+ talk_base::scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
+ const std::string& config,
+ PeerConnectionObserver* observer);
+ bool Initialize();
+
+ virtual talk_base::scoped_refptr<LocalMediaStreamInterface>
+ CreateLocalMediaStream(const std::string& label);
+
+ virtual talk_base::scoped_refptr<LocalVideoTrackInterface>
+ CreateLocalVideoTrack(const std::string& label,
+ cricket::VideoCapturer* video_device);
+
+ virtual talk_base::scoped_refptr<LocalAudioTrackInterface>
+ CreateLocalAudioTrack(const std::string& label,
+ AudioDeviceModule* audio_device);
+
+ virtual cricket::ChannelManager* channel_manager();
+ virtual talk_base::Thread* signaling_thread();
+ virtual talk_base::Thread* worker_thread();
+ virtual PortAllocatorFactoryInterface* port_allocator_factory();
+
+ protected:
+ PeerConnectionFactory();
+ PeerConnectionFactory(
+ talk_base::Thread* worker_thread,
+ talk_base::Thread* signaling_thread,
+ PortAllocatorFactoryInterface* port_allocator_factory,
+ AudioDeviceModule* default_adm);
+ virtual ~PeerConnectionFactory();
+
+
+ private:
+ bool Initialize_s();
+ void Terminate_s();
+ talk_base::scoped_refptr<PeerConnectionInterface> CreatePeerConnection_s(
+ const std::string& configuration,
+ PeerConnectionObserver* observer);
+ // Implements talk_base::MessageHandler.
+ void OnMessage(talk_base::Message* msg);
+
+ bool owns_ptrs_;
+ talk_base::Thread* signaling_thread_;
+ talk_base::Thread* worker_thread_;
+ talk_base::scoped_refptr<PortAllocatorFactoryInterface> allocator_factory_;
+ // External Audio device used for audio playback.
+ talk_base::scoped_refptr<AudioDeviceModule> default_adm_;
+ talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_PEERCONNECTIONFACTORYIMPL_H_
diff --git a/talk/app/webrtc/peerconnectionimpl.cc b/talk/app/webrtc/peerconnectionimpl.cc
index 28e4685..7f990f1 100644
--- a/talk/app/webrtc/peerconnectionimpl.cc
+++ b/talk/app/webrtc/peerconnectionimpl.cc
@@ -1,6 +1,6 @@
/*
* libjingle
- * Copyright 2004--2011, Google Inc.
+ * 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:
@@ -27,199 +27,366 @@
#include "talk/app/webrtc/peerconnectionimpl.h"
-#include "talk/app/webrtc/webrtcjson.h"
-#include "talk/app/webrtc/webrtcsession.h"
-#include "talk/base/basicpacketsocketfactory.h"
-#include "talk/base/helpers.h"
+#include <vector>
+
+#include "talk/app/webrtc/mediastreamhandler.h"
+#include "talk/app/webrtc/streamcollectionimpl.h"
#include "talk/base/logging.h"
#include "talk/base/stringencode.h"
-#include "talk/p2p/base/session.h"
-#include "talk/p2p/client/basicportallocator.h"
+#include "talk/session/phone/channelmanager.h"
+#include "talk/session/phone/webrtcvideocapturer.h"
+
+namespace {
+
+// The number of the tokens in the config string.
+static const size_t kConfigTokens = 2;
+static const size_t kServiceCount = 5;
+// The default stun port.
+static const int kDefaultPort = 3478;
+
+// NOTE: Must be in the same order as the ServiceType enum.
+static const char* kValidServiceTypes[kServiceCount] = {
+ "STUN", "STUNS", "TURN", "TURNS", "INVALID" };
+
+enum ServiceType {
+ STUN, // Indicates a STUN server.
+ STUNS, // Indicates a STUN server used with a TLS session.
+ TURN, // Indicates a TURN server
+ TURNS, // Indicates a TURN server used with a TLS session.
+ INVALID, // Unknown.
+};
+
+enum {
+ MSG_COMMITSTREAMCHANGES = 1,
+ MSG_PROCESSSIGNALINGMESSAGE = 2,
+ MSG_RETURNREMOTEMEDIASTREAMS = 3,
+ MSG_CLOSE = 4,
+ MSG_READYSTATE = 5,
+ MSG_SDPSTATE = 6,
+ MSG_TERMINATE = 7
+};
+
+typedef webrtc::PortAllocatorFactoryInterface::StunConfiguration
+ StunConfiguration;
+typedef webrtc::PortAllocatorFactoryInterface::TurnConfiguration
+ TurnConfiguration;
+
+bool static ParseConfigString(const std::string& config,
+ std::vector<StunConfiguration>* stun_config,
+ std::vector<TurnConfiguration>* turn_config) {
+ std::vector<std::string> tokens;
+ talk_base::tokenize(config, ' ', &tokens);
+
+ if (tokens.size() != kConfigTokens) {
+ LOG(WARNING) << "Invalid config string";
+ return false;
+ }
+
+ ServiceType service_type = INVALID;
+
+ const std::string& type = tokens[0];
+ for (size_t i = 0; i < kServiceCount; ++i) {
+ if (type.compare(kValidServiceTypes[i]) == 0) {
+ service_type = static_cast<ServiceType>(i);
+ break;
+ }
+ }
+
+ if (service_type == INVALID) {
+ LOG(WARNING) << "Invalid service type: " << type;
+ return false;
+ }
+ std::string service_address = tokens[1];
+
+ int port;
+ tokens.clear();
+ talk_base::tokenize(service_address, ':', &tokens);
+ if (tokens.size() != kConfigTokens) {
+ port = kDefaultPort;
+ } else {
+ port = talk_base::FromString<int>(tokens[1]);
+ if (port <= 0 || port > 0xffff) {
+ LOG(WARNING) << "Invalid port: " << tokens[1];
+ return false;
+ }
+ }
+
+ // TODO: Currently the specification does not tell us how to parse
+ // multiple addresses, username and password from the configuration string.
+ switch (service_type) {
+ case STUN:
+ stun_config->push_back(StunConfiguration(service_address, port));
+ break;
+ case TURN:
+ turn_config->push_back(TurnConfiguration(service_address, port, "", ""));
+ break;
+ case TURNS:
+ case STUNS:
+ case INVALID:
+ default:
+ LOG(WARNING) << "Configuration not supported";
+ return false;
+ }
+ return true;
+}
+
+struct SignalingParams : public talk_base::MessageData {
+ SignalingParams(const std::string& msg,
+ webrtc::StreamCollectionInterface* local_streams)
+ : msg(msg),
+ local_streams(local_streams) {}
+ const std::string msg;
+ talk_base::scoped_refptr<webrtc::StreamCollectionInterface> local_streams;
+};
+
+struct StreamCollectionParams : public talk_base::MessageData {
+ explicit StreamCollectionParams(webrtc::StreamCollectionInterface* streams)
+ : streams(streams) {}
+ talk_base::scoped_refptr<webrtc::StreamCollectionInterface> streams;
+};
+
+struct ReadyStateMessage : public talk_base::MessageData {
+ ReadyStateMessage() : state(webrtc::PeerConnectionInterface::kNew) {}
+ webrtc::PeerConnectionInterface::ReadyState state;
+};
+
+struct SdpStateMessage : public talk_base::MessageData {
+ SdpStateMessage() : state(webrtc::PeerConnectionInterface::kSdpNew) {}
+ webrtc::PeerConnectionInterface::SdpState state;
+};
+
+} // namespace
namespace webrtc {
-
-PeerConnectionImpl::PeerConnectionImpl(
- cricket::PortAllocator* port_allocator,
- cricket::ChannelManager* channel_manager,
- talk_base::Thread* signaling_thread)
- : port_allocator_(port_allocator),
- channel_manager_(channel_manager),
- signaling_thread_(signaling_thread),
- event_callback_(NULL),
- session_(NULL) {
+cricket::VideoCapturer* CreateVideoCapturer(VideoCaptureModule* vcm) {
+ cricket::WebRtcVideoCapturer* video_capturer =
+ new cricket::WebRtcVideoCapturer;
+ if (!video_capturer->Init(vcm)) {
+ delete video_capturer;
+ video_capturer = NULL;
+ }
+ return video_capturer;
}
-PeerConnectionImpl::~PeerConnectionImpl() {
+PeerConnection::PeerConnection(PeerConnectionFactory* factory)
+ : factory_(factory),
+ observer_(NULL),
+ ready_state_(kNew),
+ sdp_state_(kSdpNew),
+ local_media_streams_(StreamCollection::Create()) {
}
-bool PeerConnectionImpl::Init() {
- std::string sid;
- talk_base::CreateRandomString(8, &sid);
- const bool incoming = false;
- // default outgoing direction
- session_.reset(CreateMediaSession(sid, incoming));
- if (session_.get() == NULL) {
- ASSERT(false && "failed to initialize a session");
+PeerConnection::~PeerConnection() {
+ signaling_thread()->Clear(this);
+ signaling_thread()->Send(this, MSG_TERMINATE);
+}
+
+// Clean up what needs to be cleaned up on the signaling thread.
+void PeerConnection::Terminate_s() {
+ stream_handler_.reset();
+ signaling_.reset();
+ session_.reset();
+ port_allocator_.reset();
+}
+
+bool PeerConnection::Initialize(const std::string& configuration,
+ PeerConnectionObserver* observer) {
+ ASSERT(observer != NULL);
+ if (!observer)
return false;
- }
- return true;
+ observer_ = observer;
+ std::vector<PortAllocatorFactoryInterface::StunConfiguration> stun_config;
+ std::vector<PortAllocatorFactoryInterface::TurnConfiguration> turn_config;
+
+ ParseConfigString(configuration, &stun_config, &turn_config);
+
+ port_allocator_.reset(factory_->port_allocator_factory()->CreatePortAllocator(
+ stun_config, turn_config));
+
+ session_.reset(new WebRtcSession(factory_->channel_manager(),
+ factory_->signaling_thread(),
+ factory_->worker_thread(),
+ port_allocator_.get()));
+ signaling_.reset(new PeerConnectionSignaling(factory_->signaling_thread(),
+ session_.get()));
+ stream_handler_.reset(new MediaStreamHandlers(session_.get()));
+
+ signaling_->SignalNewPeerConnectionMessage.connect(
+ this, &PeerConnection::OnNewPeerConnectionMessage);
+ signaling_->SignalRemoteStreamAdded.connect(
+ this, &PeerConnection::OnRemoteStreamAdded);
+ signaling_->SignalRemoteStreamRemoved.connect(
+ this, &PeerConnection::OnRemoteStreamRemoved);
+ signaling_->SignalStateChange.connect(
+ this, &PeerConnection::OnSignalingStateChange);
+ // Register with WebRtcSession
+ session_->RegisterObserver(signaling_.get());
+
+ // Initialize the WebRtcSession. It creates transport channels etc.
+ const bool result = session_->Initialize();
+ if (result)
+ ChangeReadyState(PeerConnectionInterface::kNegotiating);
+ return result;
}
-void PeerConnectionImpl::RegisterObserver(PeerConnectionObserver* observer) {
- // This assert is to catch cases where two observer pointers are registered.
- // We only support one and if another is to be used, the current one must be
- // cleared first.
- ASSERT(observer == NULL || event_callback_ == NULL);
- event_callback_ = observer;
+talk_base::scoped_refptr<StreamCollectionInterface>
+PeerConnection::local_streams() {
+ return local_media_streams_;
}
-bool PeerConnectionImpl::SignalingMessage(
- const std::string& signaling_message) {
- // Deserialize signaling message
- cricket::SessionDescription* incoming_sdp = NULL;
- std::vector<cricket::Candidate> candidates;
- if (!ParseJsonSignalingMessage(signaling_message,
- &incoming_sdp, &candidates)) {
- return false;
- }
-
- bool ret = false;
- if (GetReadyState() == NEW) {
- // set direction to incoming, as message received first
- session_->set_incoming(true);
- ret = session_->OnInitiateMessage(incoming_sdp, candidates);
- } else {
- ret = session_->OnRemoteDescription(incoming_sdp, candidates);
- }
- return ret;
+talk_base::scoped_refptr<StreamCollectionInterface>
+PeerConnection::remote_streams() {
+ StreamCollectionParams msg(NULL);
+ signaling_thread()->Send(this, MSG_RETURNREMOTEMEDIASTREAMS, &msg);
+ return msg.streams;
}
-WebRtcSession* PeerConnectionImpl::CreateMediaSession(
- const std::string& id, bool incoming) {
- ASSERT(port_allocator_ != NULL);
- WebRtcSession* session = new WebRtcSession(id, incoming,
- port_allocator_, channel_manager_, signaling_thread_);
-
- if (session->Initiate()) {
- session->SignalAddStream.connect(
- this,
- &PeerConnectionImpl::OnAddStream);
- session->SignalRemoveStream.connect(
- this,
- &PeerConnectionImpl::OnRemoveStream);
- session->SignalLocalDescription.connect(
- this,
- &PeerConnectionImpl::OnLocalDescription);
- session->SignalFailedCall.connect(
- this,
- &PeerConnectionImpl::OnFailedCall);
- } else {
- delete session;
- session = NULL;
- }
- return session;
+void PeerConnection::ProcessSignalingMessage(const std::string& msg) {
+ SignalingParams* parameter(new SignalingParams(
+ msg, StreamCollection::Create(local_media_streams_)));
+ signaling_thread()->Post(this, MSG_PROCESSSIGNALINGMESSAGE, parameter);
}
-bool PeerConnectionImpl::AddStream(const std::string& stream_id, bool video) {
- bool ret = false;
- if (session_->HasStream(stream_id)) {
- ASSERT(false && "A stream with this name already exists");
- } else {
- if (!video) {
- ret = !session_->HasAudioChannel() &&
- session_->CreateVoiceChannel(stream_id);
- } else {
- ret = !session_->HasVideoChannel() &&
- session_->CreateVideoChannel(stream_id);
+void PeerConnection::AddStream(LocalMediaStreamInterface* local_stream) {
+ local_media_streams_->AddStream(local_stream);
+}
+
+void PeerConnection::RemoveStream(LocalMediaStreamInterface* remove_stream) {
+ local_media_streams_->RemoveStream(remove_stream);
+}
+
+void PeerConnection::CommitStreamChanges() {
+ StreamCollectionParams* msg(new StreamCollectionParams(
+ StreamCollection::Create(local_media_streams_)));
+ signaling_thread()->Post(this, MSG_COMMITSTREAMCHANGES, msg);
+}
+
+void PeerConnection::Close() {
+ signaling_thread()->Send(this, MSG_CLOSE);
+}
+
+PeerConnectionInterface::ReadyState PeerConnection::ready_state() {
+ ReadyStateMessage msg;
+ signaling_thread()->Send(this, MSG_READYSTATE, &msg);
+ return msg.state;
+}
+
+PeerConnectionInterface::SdpState PeerConnection::sdp_state() {
+ SdpStateMessage msg;
+ signaling_thread()->Send(this, MSG_SDPSTATE, &msg);
+ return msg.state;
+}
+
+void PeerConnection::OnMessage(talk_base::Message* msg) {
+ talk_base::MessageData* data = msg->pdata;
+ switch (msg->message_id) {
+ case MSG_COMMITSTREAMCHANGES: {
+ if (ready_state_ != PeerConnectionInterface::kClosed ||
+ ready_state_ != PeerConnectionInterface::kClosing) {
+ StreamCollectionParams* param(
+ static_cast<StreamCollectionParams*> (data));
+ signaling_->CreateOffer(param->streams);
+ stream_handler_->CommitLocalStreams(param->streams);
+ }
+ delete data; // Because it is Posted.
+ break;
}
- }
- return ret;
-}
-
-bool PeerConnectionImpl::RemoveStream(const std::string& stream_id) {
- return session_->RemoveStream(stream_id);
-}
-
-void PeerConnectionImpl::OnLocalDescription(
- const cricket::SessionDescription* desc,
- const std::vector<cricket::Candidate>& candidates) {
- if (!desc) {
- LOG(WARNING) << "no local SDP ";
- return;
- }
-
- std::string message;
- if (GetJsonSignalingMessage(desc, candidates, &message)) {
- if (event_callback_) {
- event_callback_->OnSignalingMessage(message);
+ case MSG_PROCESSSIGNALINGMESSAGE: {
+ if (ready_state_ != PeerConnectionInterface::kClosed) {
+ SignalingParams* params(static_cast<SignalingParams*> (data));
+ signaling_->ProcessSignalingMessage(params->msg, params->local_streams);
+ }
+ delete data; // Because it is Posted.
+ break;
}
+ case MSG_RETURNREMOTEMEDIASTREAMS: {
+ StreamCollectionParams* param(
+ static_cast<StreamCollectionParams*> (data));
+ param->streams = StreamCollection::Create(signaling_->remote_streams());
+ break;
+ }
+ case MSG_CLOSE: {
+ if (ready_state_ != PeerConnectionInterface::kClosed) {
+ ChangeReadyState(PeerConnectionInterface::kClosing);
+ signaling_->SendShutDown();
+ }
+ break;
+ }
+ case MSG_READYSTATE: {
+ ReadyStateMessage* msg(static_cast<ReadyStateMessage*> (data));
+ msg->state = ready_state_;
+ break;
+ }
+ case MSG_SDPSTATE: {
+ SdpStateMessage* msg(static_cast<SdpStateMessage*> (data));
+ msg->state = sdp_state_;
+ break;
+ }
+ case MSG_TERMINATE: {
+ Terminate_s();
+ break;
+ }
+ default:
+ ASSERT(!"NOT IMPLEMENTED");
+ break;
}
}
-void PeerConnectionImpl::OnFailedCall() {
- // TODO: implement.
+void PeerConnection::OnNewPeerConnectionMessage(const std::string& message) {
+ observer_->OnSignalingMessage(message);
}
-bool PeerConnectionImpl::SetAudioDevice(const std::string& wave_in_device,
- const std::string& wave_out_device,
- int opts) {
- return channel_manager_->SetAudioOptions(wave_in_device,
- wave_out_device,
- opts);
+void PeerConnection::OnRemoteStreamAdded(MediaStreamInterface* remote_stream) {
+ stream_handler_->AddRemoteStream(remote_stream);
+ observer_->OnAddStream(remote_stream);
}
-bool PeerConnectionImpl::SetLocalVideoRenderer(
- cricket::VideoRenderer* renderer) {
- return channel_manager_->SetLocalRenderer(renderer);
+void PeerConnection::OnRemoteStreamRemoved(
+ MediaStreamInterface* remote_stream) {
+ stream_handler_->RemoveRemoteStream(remote_stream);
+ observer_->OnRemoveStream(remote_stream);
}
-bool PeerConnectionImpl::SetVideoRenderer(const std::string& stream_id,
- cricket::VideoRenderer* renderer) {
- return session_->SetVideoRenderer(stream_id, renderer);
-}
-
-bool PeerConnectionImpl::SetVideoCapture(const std::string& cam_device) {
- return channel_manager_->SetVideoOptions(cam_device);
-}
-
-bool PeerConnectionImpl::Connect() {
- return session_->Connect();
-}
-
-// TODO - Close is not used anymore, should be removed.
-bool PeerConnectionImpl::Close() {
- session_->RemoveAllStreams();
- return true;
-}
-
-void PeerConnectionImpl::OnAddStream(const std::string& stream_id,
- bool video) {
- if (event_callback_) {
- event_callback_->OnAddStream(stream_id, video);
+void PeerConnection::OnSignalingStateChange(
+ PeerConnectionSignaling::State state) {
+ switch (state) {
+ case PeerConnectionSignaling::kInitializing:
+ break;
+ case PeerConnectionSignaling::kIdle:
+ if (ready_state_ == PeerConnectionInterface::kNegotiating)
+ ChangeReadyState(PeerConnectionInterface::kActive);
+ ChangeSdpState(PeerConnectionInterface::kSdpIdle);
+ break;
+ case PeerConnectionSignaling::kWaitingForAnswer:
+ ChangeSdpState(PeerConnectionInterface::kSdpWaiting);
+ break;
+ case PeerConnectionSignaling::kWaitingForOK:
+ ChangeSdpState(PeerConnectionInterface::kSdpWaiting);
+ break;
+ case PeerConnectionSignaling::kShutingDown:
+ ChangeReadyState(PeerConnectionInterface::kClosing);
+ break;
+ case PeerConnectionSignaling::kShutdownComplete:
+ ChangeReadyState(PeerConnectionInterface::kClosed);
+ signaling_thread()->Post(this, MSG_TERMINATE);
+ break;
+ default:
+ ASSERT(!"NOT IMPLEMENTED");
+ break;
}
}
-void PeerConnectionImpl::OnRemoveStream(const std::string& stream_id,
- bool video) {
- if (event_callback_) {
- event_callback_->OnRemoveStream(stream_id, video);
- }
+void PeerConnection::ChangeReadyState(
+ PeerConnectionInterface::ReadyState ready_state) {
+ ready_state_ = ready_state;
+ observer_->OnStateChange(PeerConnectionObserver::kReadyState);
}
-PeerConnectionImpl::ReadyState PeerConnectionImpl::GetReadyState() {
- ReadyState ready_state;
- cricket::BaseSession::State state = session_->state();
- if (state == cricket::BaseSession::STATE_INIT) {
- ready_state = NEW;
- } else if (state == cricket::BaseSession::STATE_INPROGRESS) {
- ready_state = ACTIVE;
- } else if (state == cricket::BaseSession::STATE_DEINIT) {
- ready_state = CLOSED;
- } else {
- ready_state = NEGOTIATING;
- }
- return ready_state;
+void PeerConnection::ChangeSdpState(
+ PeerConnectionInterface::SdpState sdp_state) {
+ sdp_state_ = sdp_state;
+ observer_->OnStateChange(PeerConnectionObserver::kSdpState);
}
} // namespace webrtc
diff --git a/talk/app/webrtc/peerconnectionimpl.h b/talk/app/webrtc/peerconnectionimpl.h
index 6ff2f25..2686cf2 100644
--- a/talk/app/webrtc/peerconnectionimpl.h
+++ b/talk/app/webrtc/peerconnectionimpl.h
@@ -1,6 +1,6 @@
/*
* libjingle
- * Copyright 2004--2011, Google Inc.
+ * 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:
@@ -28,68 +28,83 @@
#ifndef TALK_APP_WEBRTC_PEERCONNECTIONIMPL_H_
#define TALK_APP_WEBRTC_PEERCONNECTIONIMPL_H_
+#include <map>
#include <string>
-#include <vector>
#include "talk/app/webrtc/peerconnection.h"
-#include "talk/base/sigslot.h"
+#include "talk/app/webrtc/peerconnectionfactoryimpl.h"
+#include "talk/app/webrtc/peerconnectionsignaling.h"
+#include "talk/app/webrtc/streamcollectionimpl.h"
+#include "talk/app/webrtc/webrtcsession.h"
#include "talk/base/scoped_ptr.h"
-#include "talk/base/thread.h"
-#include "talk/session/phone/channelmanager.h"
-
-namespace cricket {
-class ChannelManager;
-class PortAllocator;
-class SessionDescription;
-}
+#include "talk/p2p/client/httpportallocator.h"
namespace webrtc {
-class WebRtcSession;
+class MediaStreamHandlers;
-class PeerConnectionImpl : public PeerConnection,
- public sigslot::has_slots<> {
+// PeerConnectionImpl implements the PeerConnection interface.
+// It uses PeerConnectionSignaling and WebRtcSession to implement
+// the PeerConnection functionality.
+class PeerConnection : public PeerConnectionInterface,
+ public talk_base::MessageHandler,
+ public sigslot::has_slots<> {
public:
- PeerConnectionImpl(cricket::PortAllocator* port_allocator,
- cricket::ChannelManager* channel_manager,
- talk_base::Thread* signaling_thread);
- virtual ~PeerConnectionImpl();
+ explicit PeerConnection(PeerConnectionFactory* factory);
- // PeerConnection interfaces
- virtual void RegisterObserver(PeerConnectionObserver* observer);
- virtual bool SignalingMessage(const std::string& msg);
- virtual bool AddStream(const std::string& stream_id, bool video);
- virtual bool RemoveStream(const std::string& stream_id);
- virtual bool Connect();
- virtual bool Close();
- virtual bool SetAudioDevice(const std::string& wave_in_device,
- const std::string& wave_out_device, int opts);
- virtual bool SetLocalVideoRenderer(cricket::VideoRenderer* renderer);
- virtual bool SetVideoRenderer(const std::string& stream_id,
- cricket::VideoRenderer* renderer);
- virtual bool SetVideoCapture(const std::string& cam_device);
- virtual ReadyState GetReadyState();
+ bool Initialize(const std::string& configuration,
+ PeerConnectionObserver* observer);
- cricket::ChannelManager* channel_manager() {
- return channel_manager_;
+ virtual ~PeerConnection();
+
+ virtual void ProcessSignalingMessage(const std::string& msg);
+ virtual bool Send(const std::string& msg) {
+ // TODO: implement
+ ASSERT(false);
+ return false;
}
-
- // Callbacks from PeerConnectionImplCallbacks
- void OnAddStream(const std::string& stream_id, bool video);
- void OnRemoveStream(const std::string& stream_id, bool video);
- void OnLocalDescription(
- const cricket::SessionDescription* desc,
- const std::vector<cricket::Candidate>& candidates);
- void OnFailedCall();
- bool Init();
+ virtual talk_base::scoped_refptr<StreamCollectionInterface> local_streams();
+ virtual talk_base::scoped_refptr<StreamCollectionInterface> remote_streams();
+ virtual void AddStream(LocalMediaStreamInterface* stream);
+ virtual void RemoveStream(LocalMediaStreamInterface* stream);
+ virtual void CommitStreamChanges();
+ virtual void Close();
+ virtual ReadyState ready_state();
+ virtual SdpState sdp_state();
private:
- WebRtcSession* CreateMediaSession(const std::string& id, bool incoming);
+ // Implement talk_base::MessageHandler.
+ void OnMessage(talk_base::Message* msg);
- cricket::PortAllocator* port_allocator_;
- cricket::ChannelManager* channel_manager_;
- talk_base::Thread* signaling_thread_;
- PeerConnectionObserver* event_callback_;
+ // Signals from PeerConnectionSignaling.
+ void OnNewPeerConnectionMessage(const std::string& message);
+ void OnRemoteStreamAdded(MediaStreamInterface* remote_stream);
+ void OnRemoteStreamRemoved(MediaStreamInterface* remote_stream);
+ void OnSignalingStateChange(PeerConnectionSignaling::State state);
+
+ void ChangeReadyState(PeerConnectionInterface::ReadyState ready_state);
+ void ChangeSdpState(PeerConnectionInterface::SdpState sdp_state);
+ void Terminate_s();
+
+ talk_base::Thread* signaling_thread() {
+ return factory_->signaling_thread();
+ }
+
+ // Storing the factory as a scoped reference pointer ensures that the memory
+ // in the PeerConnectionFactoryImpl remains available as long as the
+ // PeerConnection is running. It is passed to PeerConnection as a raw pointer.
+ // However, since the reference counting is done in the
+ // PeerConnectionFactoryInteface all instances created using the raw pointer
+ // will refer to the same reference count.
+ talk_base::scoped_refptr<PeerConnectionFactory> factory_;
+ PeerConnectionObserver* observer_;
+ ReadyState ready_state_;
+ SdpState sdp_state_;
+ talk_base::scoped_refptr<StreamCollection> local_media_streams_;
+
+ talk_base::scoped_ptr<cricket::PortAllocator> port_allocator_;
talk_base::scoped_ptr<WebRtcSession> session_;
+ talk_base::scoped_ptr<PeerConnectionSignaling> signaling_;
+ talk_base::scoped_ptr<MediaStreamHandlers> stream_handler_;
};
} // namespace webrtc
diff --git a/talk/app/webrtc/peerconnectionimpl_unittest.cc b/talk/app/webrtc/peerconnectionimpl_unittest.cc
new file mode 100644
index 0000000..5363af6
--- /dev/null
+++ b/talk/app/webrtc/peerconnectionimpl_unittest.cc
@@ -0,0 +1,287 @@
+/*
+ * 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 "talk/app/webrtc/fakeportallocatorfactory.h"
+#include "talk/app/webrtc/mediastreamimpl.h"
+#include "talk/app/webrtc/peerconnection.h"
+#include "talk/app/webrtc/peerconnectionimpl.h"
+#include "talk/app/webrtc/roapmessages.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/thread.h"
+#include "talk/base/gunit.h"
+
+static const char kStreamLabel1[] = "local_stream_1";
+static const char kStreamLabel2[] = "local_stream_2";
+static const char kStunConfiguration[] = "STUN stun.l.google.com:19302";
+static const char kInvalidConfiguration[] = "a13151913541234:19302";
+static const uint32 kTimeout = 5000U;
+
+using talk_base::scoped_ptr;
+using talk_base::scoped_refptr;
+using webrtc::FakePortAllocatorFactory;
+using webrtc::LocalMediaStreamInterface;
+using webrtc::LocalVideoTrackInterface;
+using webrtc::MediaStreamInterface;
+using webrtc::PeerConnectionInterface;
+using webrtc::PeerConnectionObserver;
+using webrtc::PortAllocatorFactoryInterface;
+using webrtc::RoapMessageBase;
+using webrtc::RoapOffer;
+
+
+// Create ROAP message for shutdown.
+static std::string CreateShutdownMessage() {
+ webrtc::RoapShutdown shutdown("dummy_session", "", "", 1);
+ return shutdown.Serialize();
+}
+
+// Create a ROAP answer message.
+// The session description in the answer is set to the same as in the offer.
+static std::string CreateAnswerMessage(const RoapMessageBase& msg) {
+ webrtc::RoapOffer offer(msg);
+ EXPECT_TRUE(offer.Parse());
+ cricket::SessionDescription* sdp_offer =
+ offer.ReleaseSessionDescription();
+ const cricket::ContentInfo* audio_content = GetFirstAudioContent(sdp_offer);
+ if (audio_content) {
+ const cricket::AudioContentDescription* desc =
+ static_cast<const cricket::AudioContentDescription*>(
+ audio_content->description);
+ cricket::CryptoParamsVec& cryptos =
+ const_cast<cricket::CryptoParamsVec&>(desc->cryptos());
+ cryptos.erase(cryptos.begin()++);
+ }
+
+ webrtc::RoapAnswer answer(offer.offer_session_id(), "dummy_session",
+ offer.session_token(), offer.response_token(),
+ offer.seq(), sdp_offer, offer.candidates());
+ return answer.Serialize();
+}
+
+// Create ROAP message to answer ok to a ROAP shutdown or ROAP answer message.
+static std::string CreateOkMessage(const RoapMessageBase& msg) {
+ webrtc::RoapOk ok(msg.offer_session_id(), "dummy_session",
+ msg.session_token(), msg.response_token(), msg.seq());
+ return ok.Serialize();
+}
+
+class MockPeerConnectionObserver : public PeerConnectionObserver {
+ public:
+ void SetPeerConnectionInterface(PeerConnectionInterface* pc) {
+ pc_ = pc;
+ state_ = pc_->ready_state();
+ sdp_state_ = pc_->sdp_state();
+ }
+ virtual void OnError() {}
+ virtual void OnMessage(const std::string& msg) {}
+ virtual void OnSignalingMessage(const std::string& msg) {
+ EXPECT_TRUE(last_message_.Parse(msg));
+ }
+ virtual void OnStateChange(StateType state_changed) {
+ if (pc_.get() == NULL)
+ return;
+ switch (state_changed) {
+ case kReadyState:
+ state_ = pc_->ready_state();
+ break;
+ case kSdpState:
+ sdp_state_ = pc_->sdp_state();
+ break;
+ case kIceState:
+ ADD_FAILURE();
+ break;
+ default:
+ ADD_FAILURE();
+ break;
+ }
+ }
+ virtual void OnAddStream(MediaStreamInterface* stream) {
+ last_added_stream_ = stream;
+ }
+ virtual void OnRemoveStream(MediaStreamInterface* stream) {
+ last_removed_stream_ = stream;
+ }
+
+ // Returns the label of the last added stream.
+ // Empty string if no stream have been added.
+ std::string GetLastAddedStreamLabel() {
+ if (last_added_stream_.get())
+ return last_added_stream_->label();
+ return "";
+ }
+ std::string GetLastRemovedStreamLabel() {
+ if (last_removed_stream_.get())
+ return last_removed_stream_->label();
+ return "";
+ }
+
+ talk_base::scoped_refptr<PeerConnectionInterface> pc_;
+ RoapMessageBase last_message_;
+ PeerConnectionInterface::ReadyState state_;
+ PeerConnectionInterface::SdpState sdp_state_;
+
+ private:
+ scoped_refptr<MediaStreamInterface> last_added_stream_;
+ scoped_refptr<MediaStreamInterface> last_removed_stream_;
+};
+
+class PeerConnectionImplTest : public testing::Test {
+ protected:
+ virtual void SetUp() {
+ port_allocator_factory_ = FakePortAllocatorFactory::Create();
+
+ pc_factory_ = webrtc::CreatePeerConnectionFactory(
+ talk_base::Thread::Current(), talk_base::Thread::Current(),
+ port_allocator_factory_.get(), NULL);
+ ASSERT_TRUE(pc_factory_.get() != NULL);
+ }
+
+ void CreatePeerConnection() {
+ pc_ = pc_factory_->CreatePeerConnection(kStunConfiguration, &observer_);
+ ASSERT_TRUE(pc_.get() != NULL);
+ observer_.SetPeerConnectionInterface(pc_.get());
+ EXPECT_EQ(PeerConnectionInterface::kNegotiating, observer_.state_);
+ }
+
+ void CreatePeerConnectionWithInvalidConfiguration() {
+ pc_ = pc_factory_->CreatePeerConnection(kInvalidConfiguration, &observer_);
+ ASSERT_TRUE(pc_.get() != NULL);
+ observer_.SetPeerConnectionInterface(pc_.get());
+ EXPECT_EQ(PeerConnectionInterface::kNegotiating, observer_.state_);
+ }
+
+ void AddStream(const std::string& label) {
+ // Create a local stream.
+ scoped_refptr<LocalMediaStreamInterface> stream(
+ pc_factory_->CreateLocalMediaStream(label));
+ scoped_refptr<LocalVideoTrackInterface> video_track(
+ pc_factory_->CreateLocalVideoTrack(label, NULL));
+ stream->AddTrack(video_track.get());
+ pc_->AddStream(stream);
+ pc_->CommitStreamChanges();
+
+ EXPECT_EQ_WAIT(PeerConnectionInterface::kSdpWaiting, observer_.sdp_state_,
+ kTimeout);
+ // Wait for the ICE agent to find the candidates and send an offer.
+ EXPECT_EQ_WAIT(RoapMessageBase::kOffer, observer_.last_message_.type(),
+ kTimeout);
+ }
+
+ scoped_refptr<PortAllocatorFactoryInterface> port_allocator_factory_;
+ scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory_;
+ scoped_refptr<PeerConnectionInterface> pc_;
+ MockPeerConnectionObserver observer_;
+};
+
+TEST_F(PeerConnectionImplTest, CreatePeerConnectionWithInvalidConfiguration) {
+ CreatePeerConnectionWithInvalidConfiguration();
+ AddStream(kStreamLabel1);
+}
+
+TEST_F(PeerConnectionImplTest, AddStream) {
+ CreatePeerConnection();
+ AddStream(kStreamLabel1);
+ ASSERT_EQ(1u, pc_->local_streams()->count());
+ EXPECT_EQ(kStreamLabel1, pc_->local_streams()->at(0)->label());
+
+ EXPECT_EQ_WAIT(PeerConnectionInterface::kNegotiating, observer_.state_,
+ kTimeout);
+ pc_->ProcessSignalingMessage(CreateAnswerMessage(observer_.last_message_));
+ EXPECT_EQ_WAIT(PeerConnectionInterface::kActive, observer_.state_, kTimeout);
+ EXPECT_EQ_WAIT(PeerConnectionInterface::kSdpIdle, observer_.sdp_state_,
+ kTimeout);
+ // Since we answer with the same session description as we offer we can
+ // check if OnAddStream have been called.
+ EXPECT_EQ(kStreamLabel1, observer_.GetLastAddedStreamLabel());
+ ASSERT_EQ(1u, pc_->remote_streams()->count());
+ EXPECT_EQ(kStreamLabel1, pc_->remote_streams()->at(0)->label());
+}
+
+TEST_F(PeerConnectionImplTest, DISABLED_UpdateStream) {
+ CreatePeerConnection();
+ AddStream(kStreamLabel1);
+ WAIT(PeerConnectionInterface::kNegotiating == observer_.state_, kTimeout);
+ pc_->ProcessSignalingMessage(CreateAnswerMessage(observer_.last_message_));
+ WAIT(PeerConnectionInterface::kActive == observer_.state_, kTimeout);
+ WAIT(PeerConnectionInterface::kSdpIdle == observer_.sdp_state_, kTimeout);
+
+ AddStream(kStreamLabel2);
+ ASSERT_EQ(2u, pc_->local_streams()->count());
+ EXPECT_EQ(kStreamLabel2, pc_->local_streams()->at(1)->label());
+ EXPECT_EQ_WAIT(PeerConnectionInterface::kSdpWaiting, observer_.sdp_state_,
+ kTimeout);
+ EXPECT_EQ(PeerConnectionInterface::kActive, observer_.state_);
+ pc_->ProcessSignalingMessage(CreateAnswerMessage(observer_.last_message_));
+ EXPECT_EQ_WAIT(PeerConnectionInterface::kSdpIdle, observer_.sdp_state_,
+ kTimeout);
+ // Since we answer with the same session description as we offer we can
+ // check if OnAddStream have been called.
+ EXPECT_EQ(kStreamLabel2, observer_.GetLastAddedStreamLabel());
+ ASSERT_EQ(2u, pc_->remote_streams()->count());
+ EXPECT_EQ(kStreamLabel2, pc_->remote_streams()->at(1)->label());
+
+ pc_->RemoveStream(static_cast<LocalMediaStreamInterface*>(
+ pc_->local_streams()->at(1)));
+ pc_->CommitStreamChanges();
+ EXPECT_EQ_WAIT(PeerConnectionInterface::kSdpWaiting, observer_.sdp_state_,
+ kTimeout);
+ pc_->ProcessSignalingMessage(CreateAnswerMessage(observer_.last_message_));
+ EXPECT_EQ_WAIT(PeerConnectionInterface::kSdpIdle, observer_.sdp_state_,
+ kTimeout);
+ EXPECT_EQ(kStreamLabel2, observer_.GetLastRemovedStreamLabel());
+ EXPECT_EQ(1u, pc_->local_streams()->count());
+}
+
+TEST_F(PeerConnectionImplTest, SendClose) {
+ CreatePeerConnection();
+ pc_->Close();
+ EXPECT_EQ(RoapMessageBase::kShutdown, observer_.last_message_.type());
+ EXPECT_EQ(PeerConnectionInterface::kClosing, observer_.state_);
+ pc_->ProcessSignalingMessage(CreateOkMessage(observer_.last_message_));
+ EXPECT_EQ_WAIT(PeerConnectionInterface::kClosed, observer_.state_, kTimeout);
+}
+
+TEST_F(PeerConnectionImplTest, ReceiveClose) {
+ CreatePeerConnection();
+ pc_->ProcessSignalingMessage(CreateShutdownMessage());
+ EXPECT_EQ_WAIT(RoapMessageBase::kOk, observer_.last_message_.type(),
+ kTimeout);
+ EXPECT_EQ(PeerConnectionInterface::kClosed, observer_.state_);
+}
+
+TEST_F(PeerConnectionImplTest, ReceiveCloseWhileExpectingAnswer) {
+ CreatePeerConnection();
+ AddStream(kStreamLabel1);
+
+ // Receive the shutdown message.
+ pc_->ProcessSignalingMessage(CreateShutdownMessage());
+ EXPECT_EQ_WAIT(RoapMessageBase::kOk, observer_.last_message_.type(),
+ kTimeout);
+ EXPECT_EQ(PeerConnectionInterface::kClosed, observer_.state_);
+}
diff --git a/talk/app/webrtc/peerconnectionsignaling.cc b/talk/app/webrtc/peerconnectionsignaling.cc
new file mode 100644
index 0000000..a3bfb63
--- /dev/null
+++ b/talk/app/webrtc/peerconnectionsignaling.cc
@@ -0,0 +1,596 @@
+/*
+ * 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/peerconnectionsignaling.h"
+
+#include <utility>
+
+#include "talk/app/webrtc/mediastreamproxy.h"
+#include "talk/app/webrtc/mediastreamtrackproxy.h"
+#include "talk/app/webrtc/sessiondescriptionprovider.h"
+#include "talk/app/webrtc/streamcollectionimpl.h"
+#include "talk/base/helpers.h"
+#include "talk/base/logging.h"
+#include "talk/base/messagequeue.h"
+#include "talk/session/phone/channelmanager.h"
+
+using talk_base::scoped_refptr;
+
+namespace webrtc {
+
+enum {
+ MSG_SEND_QUEUED_OFFER = 1,
+ MSG_GENERATE_ANSWER = 2,
+};
+
+// Verifies that a SessionDescription contains as least one valid media content
+// and a valid codec.
+static bool VerifyAnswer(const cricket::SessionDescription* answer_desc) {
+ // We need to verify that at least one media content with
+ // a codec is available.
+ const cricket::ContentInfo* audio_content =
+ GetFirstAudioContent(answer_desc);
+ if (audio_content) {
+ const cricket::AudioContentDescription* audio_desc =
+ static_cast<const cricket::AudioContentDescription*>(
+ audio_content->description);
+ if (audio_desc->codecs().size() > 0) {
+ return true;
+ }
+ }
+ const cricket::ContentInfo* video_content =
+ GetFirstVideoContent(answer_desc);
+ if (video_content) {
+ const cricket::VideoContentDescription* video_desc =
+ static_cast<const cricket::VideoContentDescription*>(
+ video_content->description);
+ if (video_desc->codecs().size() > 0) {
+ return true;
+ }
+ }
+ return false;
+}
+
+// Fills a MediaSessionOptions struct with the MediaTracks we want to sent given
+// the local MediaStreams. |local_streams| can be null if there are no tracks to
+// send.
+static void InitMediaSessionOptions(
+ cricket::MediaSessionOptions* options,
+ StreamCollectionInterface* local_streams) {
+ if (!VERIFY(options != NULL))
+ return;
+ // In order to be able to receive video,
+ // the has_video should always be true even if there are no video tracks.
+ options->has_video = true;
+ if (local_streams == NULL)
+ return;
+
+ for (size_t i = 0; i < local_streams->count(); ++i) {
+ MediaStreamInterface* stream = local_streams->at(i);
+
+ scoped_refptr<AudioTracks> audio_tracks(stream->audio_tracks());
+ // For each audio track in the stream, add it to the MediaSessionOptions.
+ for (size_t j = 0; j < audio_tracks->count(); ++j) {
+ scoped_refptr<MediaStreamTrackInterface> track(audio_tracks->at(j));
+ options->AddStream(cricket::MEDIA_TYPE_AUDIO, track->label(),
+ stream->label());
+ }
+
+ scoped_refptr<VideoTracks> 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));
+ options->AddStream(cricket::MEDIA_TYPE_VIDEO, track->label(),
+ stream->label());
+ }
+ }
+}
+
+PeerConnectionSignaling::PeerConnectionSignaling(
+ talk_base::Thread* signaling_thread,
+ SessionDescriptionProvider* provider)
+ : signaling_thread_(signaling_thread),
+ provider_(provider),
+ state_(kInitializing),
+ received_pre_offer_(false),
+ remote_streams_(StreamCollection::Create()),
+ local_streams_(StreamCollection::Create()) {
+}
+
+PeerConnectionSignaling::~PeerConnectionSignaling() {}
+
+void PeerConnectionSignaling::OnCandidatesReady(
+ const cricket::Candidates& candidates) {
+ if (!VERIFY(state_ == kInitializing))
+ return;
+ // Store the candidates.
+ candidates_ = candidates;
+ // If we have a queued remote offer we need to handle this first.
+ if (received_pre_offer_) {
+ received_pre_offer_ = false;
+ ChangeState(kWaitingForOK);
+ signaling_thread_->Post(this, MSG_GENERATE_ANSWER);
+ } else if (!queued_local_streams_.empty()) {
+ // Else if we have local queued offers.
+ ChangeState(kWaitingForAnswer);
+ signaling_thread_->Post(this, MSG_SEND_QUEUED_OFFER);
+ } else {
+ ChangeState(kIdle);
+ }
+}
+
+void PeerConnectionSignaling::ChangeState(State new_state) {
+ state_ = new_state;
+ SignalStateChange(state_);
+}
+
+void PeerConnectionSignaling::ProcessSignalingMessage(
+ const std::string& message,
+ StreamCollectionInterface* local_streams) {
+ ASSERT(talk_base::Thread::Current() == signaling_thread_);
+
+ RoapSession::ParseResult result = roap_session_.Parse(message);
+
+ // Signal an error message and return if a message is received after shutdown
+ // or it is not an ok message that is received during shutdown.
+ // No other messages from the remote peer can be processed in these states.
+ if (state_ == kShutdownComplete ||
+ (state_ == kShutingDown && result != RoapSession::kOk)) {
+ SignalNewPeerConnectionMessage(roap_session_.CreateErrorMessage(kNoMatch));
+ return;
+ }
+
+ switch (result) {
+ case RoapSession::kOffer: {
+ queued_local_streams_.clear();
+ queued_local_streams_.push_back(local_streams);
+
+ if (state_ == kWaitingForAnswer) {
+ // Message received out of order or Glare occurred and the decision was
+ // to use the incoming offer.
+ LOG(LS_INFO) << "Received offer while waiting for answer.";
+ // Be nice and handle this offer instead of the pending offer.
+ signaling_thread_->Clear(this, MSG_SEND_QUEUED_OFFER);
+ }
+
+ // Provide the remote session description and the remote candidates from
+ // the parsed ROAP message to the |provider_|.
+ // The session description ownership is transferred from |roap_session_|
+ // to |provider_|.
+ provider_->SetRemoteDescription(roap_session_.ReleaseRemoteDescription(),
+ cricket::CA_OFFER);
+ provider_->SetRemoteCandidates(roap_session_.RemoteCandidates());
+ // Update the known remote MediaStreams.
+ UpdateRemoteStreams(provider_->remote_description());
+
+ // If we are still Initializing we need to wait until we have our local
+ // candidates before we can handle the offer. Queue it and handle it when
+ // the state changes.
+ if (state_ == kInitializing) {
+ received_pre_offer_ = true;
+ break;
+ }
+
+ // Post a task to generate the answer.
+ signaling_thread_->Post(this, MSG_GENERATE_ANSWER);
+ ChangeState(kWaitingForOK);
+ break;
+ }
+ case RoapSession::kAnswerMoreComing: {
+ // We ignore this message for now and wait for the complete result.
+ LOG(LS_INFO) << "Received answer more coming.";
+ break;
+ }
+ case RoapSession::kAnswer: {
+ if (state_ != kWaitingForAnswer) {
+ LOG(LS_WARNING) << "Received an unexpected answer.";
+ return;
+ }
+
+ talk_base::scoped_ptr<cricket::SessionDescription> remote_desc(
+ roap_session_.ReleaseRemoteDescription());
+
+ // Pop the first item of queued StreamCollections containing local
+ // MediaStreams that just have been negotiated.
+ scoped_refptr<StreamCollectionInterface> streams(
+ queued_local_streams_.front());
+ queued_local_streams_.pop_front();
+ // Update the state of the local MediaStreams.
+ UpdateSendingLocalStreams(remote_desc.get(), streams);
+
+ // Hand the ownership of the local session description to |provider_|.
+ provider_->SetLocalDescription(local_desc_.release(), cricket::CA_OFFER);
+
+ // Provide the remote session description and the remote candidates from
+ // the parsed ROAP message to the |provider_|.
+ // The session description ownership is transferred from |roap_session_|
+ // to |provider_|.
+ provider_->SetRemoteDescription(remote_desc.release(),
+ cricket::CA_ANSWER);
+ provider_->SetRemoteCandidates(roap_session_.RemoteCandidates());
+ // Update the list of known remote MediaStreams.
+ UpdateRemoteStreams(provider_->remote_description());
+
+ // Let the remote peer know we have received the answer.
+ SignalNewPeerConnectionMessage(roap_session_.CreateOk());
+ // Check if we have more offers waiting in the queue.
+ if (!queued_local_streams_.empty()) {
+ // Send the next offer.
+ signaling_thread_->Post(this, MSG_SEND_QUEUED_OFFER);
+ } else {
+ ChangeState(kIdle);
+ }
+ break;
+ }
+ case RoapSession::kOk: {
+ if (state_ == kWaitingForOK) {
+ scoped_refptr<StreamCollectionInterface> streams(
+ queued_local_streams_.front());
+ queued_local_streams_.pop_front();
+ // Update the state of the local streams.
+ UpdateSendingLocalStreams(local_desc_.get(), streams);
+
+ // Hand over the ownership of the local description to the provider.
+ provider_->SetLocalDescription(local_desc_.release(),
+ cricket::CA_ANSWER);
+ ChangeState(kIdle);
+ // Check if we have an updated offer waiting in the queue.
+ if (!queued_local_streams_.empty())
+ signaling_thread_->Post(this, MSG_SEND_QUEUED_OFFER);
+ } else if (state_ == kShutingDown) {
+ ChangeState(kShutdownComplete);
+ }
+ break;
+ }
+ case RoapSession::kConflict: {
+ SignalNewPeerConnectionMessage(roap_session_.CreateErrorMessage(
+ kConflict));
+ break;
+ }
+ case RoapSession::kDoubleConflict: {
+ SignalNewPeerConnectionMessage(roap_session_.CreateErrorMessage(
+ kDoubleConflict));
+
+ // Recreate the offer with new sequence values etc.
+ ChangeState(kWaitingForAnswer);
+ signaling_thread_->Post(this, MSG_SEND_QUEUED_OFFER);
+ break;
+ }
+ case RoapSession::kError: {
+ if (roap_session_.RemoteError() != kConflict &&
+ roap_session_.RemoteError() != kDoubleConflict) {
+ SignalErrorMessageReceived(roap_session_.RemoteError());
+ // An error have occurred that we can't do anything about.
+ // Reset the state and wait for user action.
+ signaling_thread_->Clear(this);
+ queued_local_streams_.clear();
+ ChangeState(kIdle);
+ }
+ break;
+ }
+ case RoapSession::kShutDown: {
+ DoShutDown();
+ SignalNewPeerConnectionMessage(roap_session_.CreateOk());
+ ChangeState(kShutdownComplete);
+ break;
+ }
+ case RoapSession::kInvalidMessage: {
+ SignalNewPeerConnectionMessage(roap_session_.CreateErrorMessage(
+ kNoMatch));
+ return;
+ }
+ }
+}
+
+void PeerConnectionSignaling::CreateOffer(
+ StreamCollectionInterface* local_streams) {
+ if (!VERIFY(talk_base::Thread::Current() == signaling_thread_ &&
+ state_ != kShutingDown && state_ != kShutdownComplete)) {
+ return;
+ }
+
+ queued_local_streams_.push_back(local_streams);
+ if (state_ == kIdle) {
+ // Check if we can send a new offer.
+ // Only one offer is allowed at the time.
+ ChangeState(kWaitingForAnswer);
+ signaling_thread_->Post(this, MSG_SEND_QUEUED_OFFER);
+ }
+}
+
+void PeerConnectionSignaling::SendShutDown() {
+ DoShutDown();
+ SignalNewPeerConnectionMessage(roap_session_.CreateShutDown());
+}
+
+// Implement talk_base::MessageHandler.
+void PeerConnectionSignaling::OnMessage(talk_base::Message* msg) {
+ switch (msg->message_id) {
+ case MSG_SEND_QUEUED_OFFER:
+ CreateOffer_s();
+ break;
+ case MSG_GENERATE_ANSWER:
+ CreateAnswer_s();
+ break;
+ default:
+ ASSERT(!"Invalid value in switch statement.");
+ break;
+ }
+}
+
+void PeerConnectionSignaling::CreateOffer_s() {
+ ASSERT(!queued_local_streams_.empty());
+ scoped_refptr<StreamCollectionInterface> local_streams(
+ queued_local_streams_.front());
+ cricket::MediaSessionOptions options;
+ InitMediaSessionOptions(&options, local_streams);
+
+ local_desc_.reset(provider_->CreateOffer(options));
+ SignalNewPeerConnectionMessage(roap_session_.CreateOffer(local_desc_.get(),
+ candidates_));
+}
+
+void PeerConnectionSignaling::DoShutDown() {
+ ChangeState(kShutingDown);
+ signaling_thread_->Clear(this); // Don't send queued offers or answers.
+ queued_local_streams_.clear();
+ cricket::MediaSessionOptions options;
+ InitMediaSessionOptions(&options, NULL);
+
+ // Create new empty session descriptions without StreamParams.
+ // By applying these descriptions we don't send or receive any streams.
+ const SessionDescription* local_desc = provider_->CreateOffer(options);
+ SessionDescription* remote_desc = provider_->CreateAnswer(local_desc,
+ options);
+
+ provider_->SetRemoteDescription(remote_desc, cricket::CA_OFFER);
+ provider_->SetLocalDescription(local_desc, cricket::CA_ANSWER);
+
+ UpdateRemoteStreams(NULL);
+}
+
+void PeerConnectionSignaling::CreateAnswer_s() {
+ scoped_refptr<StreamCollectionInterface> streams(
+ queued_local_streams_.back());
+ // Clean up all queued collections of local streams except the last one.
+ // The last one is kept until the ok message is received for this answer and
+ // is needed for updating the state of the local streams.
+ queued_local_streams_.erase(queued_local_streams_.begin(),
+ --queued_local_streams_.end());
+
+ // Create a MediaSessionOptions object with the sources we want to send.
+ cricket::MediaSessionOptions options;
+ InitMediaSessionOptions(&options, streams);
+ // Create an local session description based on this.
+ local_desc_.reset(provider_->CreateAnswer(provider_->remote_description(),
+ options));
+ if (!VerifyAnswer(local_desc_.get())) {
+ SignalNewPeerConnectionMessage(roap_session_.CreateErrorMessage(kRefused));
+ return;
+ }
+
+ SignalNewPeerConnectionMessage(roap_session_.CreateAnswer(local_desc_.get(),
+ candidates_));
+}
+
+// Updates or Creates remote MediaStream objects given a
+// remote SessionDesription.
+// If the remote SessionDesription contain new remote MediaStreams
+// SignalRemoteStreamAdded is triggered. If a remote MediaStream is missing from
+// the remote SessionDescription SignalRemoteStreamRemoved is triggered.
+void PeerConnectionSignaling::UpdateRemoteStreams(
+ const cricket::SessionDescription* remote_desc) {
+ talk_base::scoped_refptr<StreamCollection> current_streams(
+ StreamCollection::Create());
+
+ const cricket::ContentInfo* audio_content = GetFirstAudioContent(remote_desc);
+ if (audio_content) {
+ const cricket::AudioContentDescription* audio_desc =
+ static_cast<const cricket::AudioContentDescription*>(
+ audio_content->description);
+
+ for (cricket::StreamParamsVec::const_iterator it =
+ audio_desc->streams().begin();
+ it != audio_desc->streams().end(); ++it) {
+ MediaStreamInterface* old_stream = remote_streams_->find(it->sync_label);
+ scoped_refptr<MediaStreamProxy> new_stream(static_cast<MediaStreamProxy*>(
+ current_streams->find(it->sync_label)));
+
+ if (old_stream == NULL) {
+ if (new_stream == NULL) {
+ // New stream
+ new_stream = MediaStreamProxy::Create(it->sync_label,
+ signaling_thread_);
+ current_streams->AddStream(new_stream);
+ }
+ scoped_refptr<AudioTrackInterface> track(
+ AudioTrackProxy::CreateRemote(it->name, signaling_thread_));
+ track->set_state(MediaStreamTrackInterface::kLive);
+ new_stream->AddTrack(track);
+ } else {
+ current_streams->AddStream(old_stream);
+ }
+ }
+ }
+
+ const cricket::ContentInfo* video_content = GetFirstVideoContent(remote_desc);
+ if (video_content) {
+ const cricket::VideoContentDescription* video_desc =
+ static_cast<const cricket::VideoContentDescription*>(
+ video_content->description);
+
+ for (cricket::StreamParamsVec::const_iterator it =
+ video_desc->streams().begin();
+ it != video_desc->streams().end(); ++it) {
+ MediaStreamInterface* old_stream = remote_streams_->find(it->sync_label);
+ scoped_refptr<MediaStreamProxy> new_stream(static_cast<MediaStreamProxy*>(
+ current_streams->find(it->sync_label)));
+ if (old_stream == NULL) {
+ if (new_stream == NULL) {
+ // New stream
+ new_stream = MediaStreamProxy::Create(it->sync_label,
+ signaling_thread_);
+ current_streams->AddStream(new_stream);
+ }
+ scoped_refptr<VideoTrackInterface> track(
+ VideoTrackProxy::CreateRemote(it->name, signaling_thread_));
+ new_stream->AddTrack(track);
+ track->set_state(MediaStreamTrackInterface::kLive);
+ } else {
+ current_streams->AddStream(old_stream);
+ }
+ }
+ }
+
+ // Iterate current_streams to find all new streams.
+ // Change the state of the new stream and SignalRemoteStreamAdded.
+ for (size_t i = 0; i < current_streams->count(); ++i) {
+ MediaStreamInterface* new_stream = current_streams->at(i);
+ MediaStreamInterface* old_stream = remote_streams_->find(
+ new_stream->label());
+ if (old_stream != NULL) continue;
+
+ new_stream->set_ready_state(MediaStreamInterface::kLive);
+ SignalRemoteStreamAdded(new_stream);
+ }
+
+ // Iterate the old list of remote streams.
+ // If a stream is not found in the new list it have been removed.
+ // Change the state of the removed stream and SignalRemoteStreamRemoved.
+ for (size_t i = 0; i < remote_streams_->count(); ++i) {
+ MediaStreamInterface* old_stream = remote_streams_->at(i);
+ MediaStreamInterface* new_stream = current_streams->find(
+ old_stream->label());
+ if (new_stream != NULL) continue;
+
+ old_stream->set_ready_state(MediaStreamInterface::kEnded);
+ scoped_refptr<AudioTracks> audio_tracklist(old_stream->audio_tracks());
+ for (size_t j = 0; j < audio_tracklist->count(); ++j) {
+ audio_tracklist->at(j)->set_state(MediaStreamTrackInterface::kEnded);
+ }
+ scoped_refptr<VideoTracks> 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);
+ }
+ // Prepare for next offer.
+ remote_streams_ = current_streams;
+}
+
+// Update the state of all local streams we have just negotiated. If the
+// negotiation succeeded the state is changed to kLive, if the negotiation
+// failed the state is changed to kEnded.
+void PeerConnectionSignaling::UpdateSendingLocalStreams(
+ const cricket::SessionDescription* answer_desc,
+ StreamCollectionInterface* negotiated_streams) {
+ talk_base::scoped_refptr<StreamCollection> current_local_streams(
+ StreamCollection::Create());
+
+ for (size_t i = 0; i < negotiated_streams->count(); ++i) {
+ scoped_refptr<MediaStreamInterface> stream(negotiated_streams->at(i));
+ scoped_refptr<AudioTracks> audiotracklist(stream->audio_tracks());
+ scoped_refptr<VideoTracks> 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 < audiotracklist->count(); ++j) {
+ scoped_refptr<MediaStreamTrackInterface> track(audiotracklist->at(j));
+ const cricket::ContentInfo* audio_content =
+ GetFirstAudioContent(answer_desc);
+ if (!audio_content) { // The remote does not accept audio.
+ track->set_state(MediaStreamTrackInterface::kFailed);
+ continue;
+ }
+
+ const cricket::AudioContentDescription* audio_desc =
+ static_cast<const cricket::AudioContentDescription*>(
+ audio_content->description);
+ if (audio_desc->codecs().size() <= 0) {
+ // No common codec.
+ track->set_state(MediaStreamTrackInterface::kFailed);
+ }
+ track->set_state(MediaStreamTrackInterface::kLive);
+ stream_ok = true;
+ }
+
+ for (size_t j = 0; j < videotracklist->count(); ++j) {
+ scoped_refptr<MediaStreamTrackInterface> track(videotracklist->at(j));
+ const cricket::ContentInfo* video_content =
+ GetFirstVideoContent(answer_desc);
+ if (!video_content) { // The remote does not accept video.
+ track->set_state(MediaStreamTrackInterface::kFailed);
+ continue;
+ }
+
+ const cricket::VideoContentDescription* video_desc =
+ static_cast<const cricket::VideoContentDescription*>(
+ video_content->description);
+ if (video_desc->codecs().size() <= 0) {
+ // No common codec.
+ track->set_state(MediaStreamTrackInterface::kFailed);
+ }
+ track->set_state(MediaStreamTrackInterface::kLive);
+ stream_ok = true;
+ }
+
+ if (stream_ok) {
+ // We have successfully negotiated to send this stream.
+ // Change the stream and store it as successfully negotiated.
+ stream->set_ready_state(MediaStreamInterface::kLive);
+ current_local_streams->AddStream(stream);
+ } else {
+ stream->set_ready_state(MediaStreamInterface::kEnded);
+ }
+ }
+
+ // Iterate the old list of local streams.
+ // If a stream is not found in the new list it have been removed.
+ // Change the state of the removed stream and all its tracks to kEnded.
+ for (size_t i = 0; i < local_streams_->count(); ++i) {
+ MediaStreamInterface* old_stream = local_streams_->at(i);
+ MediaStreamInterface* new_streams =
+ negotiated_streams->find(old_stream->label());
+
+ if (new_streams != NULL) continue;
+
+ old_stream->set_ready_state(MediaStreamInterface::kEnded);
+ scoped_refptr<AudioTracks> audio_tracklist(old_stream->audio_tracks());
+ for (size_t j = 0; j < audio_tracklist->count(); ++j) {
+ audio_tracklist->at(j)->set_state(MediaStreamTrackInterface::kEnded);
+ }
+ scoped_refptr<VideoTracks> video_tracklist(old_stream->video_tracks());
+ for (size_t j = 0; j < video_tracklist->count(); ++j) {
+ video_tracklist->at(j)->set_state(MediaStreamTrackInterface::kEnded);
+ }
+ }
+
+ // Update the local_streams_ for next update.
+ local_streams_ = current_local_streams;
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/peerconnectionsignaling.h b/talk/app/webrtc/peerconnectionsignaling.h
new file mode 100644
index 0000000..9e195ee
--- /dev/null
+++ b/talk/app/webrtc/peerconnectionsignaling.h
@@ -0,0 +1,262 @@
+/*
+ * 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 used for handling signaling between
+// two PeerConnections.
+
+#ifndef TALK_APP_WEBRTC_PEERCONNECTIONSIGNALING_H_
+#define TALK_APP_WEBRTC_PEERCONNECTIONSIGNALING_H_
+
+#include <list>
+#include <string>
+#include <vector>
+
+#include "talk/app/webrtc/roaperrorcodes.h"
+#include "talk/app/webrtc/roapsession.h"
+#include "talk/app/webrtc/webrtcsessionobserver.h"
+#include "talk/base/messagehandler.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/scoped_ref_ptr.h"
+#include "talk/base/sigslot.h"
+
+namespace cricket {
+class ChannelManager;
+class Candidate;
+typedef std::vector<Candidate> Candidates;
+}
+
+namespace talk_base {
+class Thread;
+}
+
+namespace webrtc {
+
+class SessionDescriptionProvider;
+class StreamCollection;
+class StreamCollectionInterface;
+class MediaStreamInterface;
+
+// PeerConnectionSignaling is a class responsible for handling signaling
+// between two PeerConnection objects. It creates remote MediaStream objects
+// when the remote peer signals it wants to send a new MediaStream. It changes
+// the state of local MediaStreams and tracks when a remote peer is ready to
+// receive media.
+//
+// PeerConnectionSignaling is Thread-compatible and all non-const methods are
+// expected to be called on the signaling thread.
+//
+// Note that before PeerConnectionSignaling can process an answer or create an
+// offer OnCandidatesReady has to be called. The last request to create an offer
+// or process an answer will be processed after OnCandidatesReady has been
+// called.
+//
+// Call CreateOffer to negotiate new local streams to send.
+// Call ProcessSignalingMessage when a new message has been received from the
+// remote peer. This might result in one or more signals being triggered to
+// indicate changes in the offer from the the remote peer or a detected error.
+// PeerConnectionSignaling creates Offers and Answers asynchronous on the
+// signaling thread.
+//
+// Example usage: Creating an offer with one audio track.
+//
+// class ProviderImpl : public SessionDescriptionProvider {
+// ...
+// };
+//
+// void OnSignalingMessage(const std::string& smessage) { ... }
+//
+// ProviderImpl impl;
+// PeerConnectionSignaling pc(talk_base::Thread::Current(), &impl);
+//
+// // Connect the function OnSignalingMessage to the signal
+// // SignalNewPeerConnectionMessage.
+// pc.SignalNewPeerConnectionMessage.connect(&OnSignalingMessage);
+//
+// // Initialize PeerConnectionSignaling by providing the candidates for
+// // this session.
+// pc.OnCandidatesReady(candidates);
+// // Create an offer with one stream with one audio track.
+// AudioTrack audio;
+// MediaStream local_stream1;
+// local_stream1.AddTrack(&audio);
+// StreamCollection local_streams;
+// local_streams.AddStream(&local_stream1)
+// pc.CreateOffer(&local_streams);
+// // When the offer has been created, OnsignalingMessage is called
+// // with the offer in a string. Provide this offer to the remote
+// // PeerConnection. The remote PeerConnection will then respond with an answer
+// // string. Provide this answer string to PeerConnectionSignaling.
+// pc.ProcessSignalingMessage(remote_message, &local_streams);
+
+
+class PeerConnectionSignaling : public WebRtcSessionObserver,
+ public talk_base::MessageHandler {
+ public:
+ enum State {
+ // Awaiting the local candidates.
+ kInitializing,
+ // Ready to sent new offer or receive a new offer.
+ kIdle,
+ // An offer has been sent and expect an answer.
+ kWaitingForAnswer,
+ // An answer have been sent and expect an ok message.
+ kWaitingForOK,
+ // SendShutdown has been called. No more messages are processed.
+ kShutingDown,
+ // Shutdown message have been received or remote peer have answered ok
+ // to a sent shutdown message.
+ kShutdownComplete,
+ };
+
+ // Constructs a PeerConnectionSignaling instance.
+ // signaling_thread - the thread where all signals will be triggered from.
+ // Also all calls to to methods are expected to be called on this thread.
+ // provider - Implementation of the SessionDescriptionProvider interface.
+ // This interface provides methods for returning local offer and answer
+ // session descriptions as well as functions for receiving events about
+ // negotiation completion and received remote session descriptions.
+ PeerConnectionSignaling(talk_base::Thread* signaling_thread,
+ SessionDescriptionProvider* provider);
+ virtual ~PeerConnectionSignaling();
+
+ // Process a received offer/answer from the remote peer.
+ // local_streams must be the collection of streams the peerconnection
+ // currently would like to send.
+ void ProcessSignalingMessage(const std::string& message,
+ StreamCollectionInterface* local_streams);
+
+ // Creates an offer containing all tracks in local_streams.
+ // When the offer is ready it is signaled by SignalNewPeerConnectionMessage.
+ // When the remote peer is ready to receive media on a stream , the state of
+ // the local streams will change to kLive.
+ void CreateOffer(StreamCollectionInterface* local_streams);
+
+ // Creates a ShutDown message to be sent to the remote peer.
+ // When the message is ready it is signaled by SignalNewPeerConnectionMessage.
+ // After calling this no more offers or answers to offers can be created.
+ void SendShutDown();
+
+ // Implements WebRtcSessionObserver interface.
+ // OnCandidatesReady is called when local candidates have been collected.
+ // This tell PeerConnectionSignaling that it is ready to respond to offers
+ // and create offer messages.
+ virtual void OnCandidatesReady(const cricket::Candidates& candidates);
+
+ // Returns all current remote MediaStreams.
+ StreamCollection* remote_streams() { return remote_streams_.get(); }
+
+ // Returns the current state.
+ State GetState() const { return state_; }
+
+ // A new ROAP message is ready to be sent. The listener to this signal is
+ // supposed to deliver this message to the remote peer.
+ sigslot::signal1<const std::string&> SignalNewPeerConnectionMessage;
+
+ // A new remote stream has been discovered.
+ sigslot::signal1<MediaStreamInterface*> SignalRemoteStreamAdded;
+
+ // A remote stream is no longer available.
+ sigslot::signal1<MediaStreamInterface*> SignalRemoteStreamRemoved;
+
+ // The signaling state have changed.
+ sigslot::signal1<State> SignalStateChange;
+
+ // Remote PeerConnection sent an error message.
+ sigslot::signal1<RoapErrorCode> SignalErrorMessageReceived;
+
+ private:
+ typedef std::list<talk_base::scoped_refptr<StreamCollectionInterface> >
+ StreamCollectionList;
+
+ // Implements talk_base::MessageHandler.
+ virtual void OnMessage(talk_base::Message* msg);
+
+ // Change the State and triggers the SignalStateChange signal.
+ void ChangeState(State new_state);
+
+ // Creates an offer on the signaling_thread_.
+ // This is either initiated by CreateOffer or OnCandidatesReady.
+ void CreateOffer_s();
+
+ // Creates an answer on the signaling thread.
+ // This is either initiated by ProcessSignalingMessage when a remote offer
+ // have been received or OnCandidatesReady.
+ void CreateAnswer_s();
+
+ // Notifies the provider_ and the active remote media streams
+ // about the shutdown.
+ // This is either initiated by ProcessSignalingMessage when a remote shutdown
+ // message have been received or by a call to SendShutDown.
+ void DoShutDown();
+
+ // Creates and destroys remote media streams based on remote_desc.
+ void UpdateRemoteStreams(const cricket::SessionDescription* remote_desc);
+
+ // Updates the state of local streams based on the answer_desc and the streams
+ // that have been negotiated in negotiated_streams.
+ void UpdateSendingLocalStreams(
+ const cricket::SessionDescription* answer_desc,
+ StreamCollectionInterface* negotiated_streams);
+
+ talk_base::Thread* signaling_thread_;
+ SessionDescriptionProvider* provider_;
+ State state_;
+
+ // Flag indicating PeerConnectionSignaling was called with an offer while
+ // PeerConnectionSignaling is in kInitializing state.
+ bool received_pre_offer_;
+
+ // LocalStreams queued for later use if ProcessSignalingMessage or CreateOffer
+ // is called while PeerConnectionSignaling is in kInitializing state or
+ // CreateOffer is called while PeerConnectionSignaling is currently sending
+ // an offer.
+ StreamCollectionList queued_local_streams_;
+
+ // Currently known remote MediaStreams.
+ talk_base::scoped_refptr<StreamCollection> remote_streams_;
+
+ // The local session description of the local MediaStreams that is being
+ // negotiated.
+ talk_base::scoped_ptr<const cricket::SessionDescription> local_desc_;
+
+ // Local MediaStreams being negotiated.
+ talk_base::scoped_refptr<StreamCollection> local_streams_;
+
+ // The set of local transport candidates used in negotiation.
+ // This is set by OnCandidatesReady.
+ cricket::Candidates candidates_;
+
+ // roap_session_ holds the ROAP-specific session state and is used for
+ // creating a parsing ROAP messages.
+ RoapSession roap_session_;
+
+ DISALLOW_COPY_AND_ASSIGN(PeerConnectionSignaling);
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_PEERCONNECTIONSIGNALING_H_
diff --git a/talk/app/webrtc/peerconnectionsignaling_unittest.cc b/talk/app/webrtc/peerconnectionsignaling_unittest.cc
new file mode 100644
index 0000000..8980128
--- /dev/null
+++ b/talk/app/webrtc/peerconnectionsignaling_unittest.cc
@@ -0,0 +1,592 @@
+/*
+ * 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 <map>
+#include <string>
+#include <utility>
+
+#include "talk/app/webrtc/audiotrackimpl.h"
+#include "talk/app/webrtc/mediastreamimpl.h"
+#include "talk/app/webrtc/peerconnectionsignaling.h"
+#include "talk/app/webrtc/sessiondescriptionprovider.h"
+#include "talk/app/webrtc/streamcollectionimpl.h"
+#include "talk/app/webrtc/videotrackimpl.h"
+#include "talk/base/gunit.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/thread.h"
+#include "talk/session/phone/channelmanager.h"
+
+static const char kStreamLabel1[] = "local_stream_1";
+static const char kStreamLabel2[] = "local_stream_2";
+static const char kAudioTrackLabel1[] = "local_audio_1";
+static const char kAudioTrackLabel2[] = "local_audio_2";
+static const char kVideoTrackLabel1[] = "local_video_1";
+
+namespace webrtc {
+
+typedef std::map<std::string, talk_base::scoped_refptr<MediaStreamInterface> >
+ MediaStreamMap;
+typedef std::pair<std::string, talk_base::scoped_refptr<MediaStreamInterface> >
+ RemotePair;
+
+// MockSignalingObserver implements functions for listening all signals from a
+// PeerConnectionSignaling instance.
+// The method AnswerPeer can be used to forward messages from one
+// PeerConnectionSignaling instance to another.
+class MockSignalingObserver : public sigslot::has_slots<> {
+ public:
+ MockSignalingObserver()
+ : last_error_(-1), // Initialize last_error_ to unused error code.
+ state_(PeerConnectionSignaling::kInitializing),
+ remote_peer_(NULL) {
+ }
+
+ virtual ~MockSignalingObserver() {}
+
+ // New remote stream have been discovered.
+ virtual void OnRemoteStreamAdded(MediaStreamInterface* remote_stream) {
+ EXPECT_EQ(MediaStreamInterface::kLive, remote_stream->ready_state());
+ remote_media_streams_.insert(RemotePair(remote_stream->label(),
+ remote_stream));
+ }
+
+ // Remote stream is no longer available.
+ virtual void OnRemoteStreamRemoved(MediaStreamInterface* remote_stream) {
+ EXPECT_TRUE(remote_media_streams_.find(remote_stream->label()) !=
+ remote_media_streams_.end());
+ EXPECT_EQ(MediaStreamInterface::kEnded, remote_stream->ready_state());
+ remote_media_streams_.erase(remote_stream->label());
+ }
+
+ virtual void OnStateChange(PeerConnectionSignaling::State state) {
+ state_ = state;
+ }
+
+ virtual void OnErrorReceived(RoapErrorCode error) {
+ last_error_ = error;
+ }
+
+ void OnSignalingMessage(const std::string& smessage) {
+ last_message_ = smessage;
+ if (remote_peer_) {
+ remote_peer_->ProcessSignalingMessage(smessage, remote_local_collection_);
+ }
+ }
+
+ // Tell this object to answer the remote_peer.
+ // remote_local_collection is the local collection the remote peer want to
+ // send in an answer.
+ void AnswerPeer(PeerConnectionSignaling* remote_peer,
+ StreamCollection* remote_local_collection) {
+ remote_peer_ = remote_peer;
+ remote_local_collection_ = remote_local_collection;
+ }
+
+ void CancelAnswerPeer() {
+ remote_peer_ = NULL;
+ remote_local_collection_.release();
+ }
+
+ MediaStreamInterface* RemoteStream(const std::string& label) {
+ MediaStreamMap::iterator it = remote_media_streams_.find(label);
+ if (it != remote_media_streams_.end())
+ return it->second;
+ return NULL;
+ }
+
+ std::string last_message_;
+ int last_error_;
+ PeerConnectionSignaling::State state_;
+
+ private:
+ MediaStreamMap remote_media_streams_;
+ talk_base::scoped_refptr<StreamCollection> remote_local_collection_;
+ PeerConnectionSignaling* remote_peer_;
+};
+
+// Mock implementation of SessionDescriptionProvider.
+// PeerConnectionSignaling uses this object to create session descriptions.
+class MockSessionDescriptionProvider : public SessionDescriptionProvider {
+ public:
+ explicit MockSessionDescriptionProvider(
+ cricket::ChannelManager* channel_manager)
+ : update_session_description_counter_(0),
+ session_description_factory_(
+ new cricket::MediaSessionDescriptionFactory(channel_manager)),
+ offer_set_(false) {
+ }
+ virtual cricket::SessionDescription* CreateOffer(
+ const cricket::MediaSessionOptions& options) {
+ return session_description_factory_->CreateOffer(options,
+ local_desc_.get());
+ }
+ virtual cricket::SessionDescription* CreateAnswer(
+ const cricket::SessionDescription*offer,
+ const cricket::MediaSessionOptions& options) {
+ return session_description_factory_->CreateAnswer(offer, options,
+ local_desc_.get());
+ }
+ virtual void SetLocalDescription(const cricket::SessionDescription* desc,
+ cricket::ContentAction type) {
+ local_desc_.reset(desc);
+ UpdateNegotiationState(type);
+ }
+ virtual void SetRemoteDescription(
+ cricket::SessionDescription* remote_offer,
+ cricket::ContentAction type) {
+ remote_desc_.reset(remote_offer);
+ UpdateNegotiationState(type);
+ }
+ virtual const cricket::SessionDescription* local_description() const {
+ return local_desc_.get();
+ }
+ virtual const cricket::SessionDescription* remote_description() const {
+ return remote_desc_.get();
+ }
+ virtual void SetRemoteCandidates(
+ const std::vector<cricket::Candidate>& remote_candidates) {
+ }
+
+ // |update_session_description_counter_| is the number of successful
+ // negotiations / re-negotiations.
+ size_t update_session_description_counter_;
+
+ protected:
+ void UpdateNegotiationState(cricket::ContentAction type) {
+ if (type == cricket::CA_ANSWER && offer_set_) {
+ // We have received and offer and now we receive an answer.
+ // Negotiation is done. Update the counter to indicate this.
+ ++update_session_description_counter_;
+ offer_set_ = false;
+ } else {
+ // Received an offer when expecting an answer.
+ EXPECT_FALSE(offer_set_);
+ offer_set_ = true;
+ }
+ }
+
+ talk_base::scoped_ptr<cricket::MediaSessionDescriptionFactory>
+ session_description_factory_;
+ talk_base::scoped_ptr<const cricket::SessionDescription> local_desc_;
+ talk_base::scoped_ptr<const cricket::SessionDescription> remote_desc_;
+ bool offer_set_;
+};
+
+// PeerConnectionSignalingTest create two PeerConnectionSignaling instances
+// and connects the signals to two MockSignalingObservers.
+// This is used in tests to test the signaling between to peers.
+class PeerConnectionSignalingTest: public testing::Test {
+ protected:
+ virtual void SetUp() {
+ channel_manager_.reset(new cricket::ChannelManager(
+ talk_base::Thread::Current()));
+ EXPECT_TRUE(channel_manager_->Init());
+ provider1_.reset(new MockSessionDescriptionProvider(
+ channel_manager_.get()));
+ provider2_.reset(new MockSessionDescriptionProvider(
+ channel_manager_.get()));
+
+ signaling1_.reset(new PeerConnectionSignaling(
+ talk_base::Thread::Current(), provider1_.get()));
+ observer1_.reset(new MockSignalingObserver());
+ signaling1_->SignalNewPeerConnectionMessage.connect(
+ observer1_.get(), &MockSignalingObserver::OnSignalingMessage);
+ signaling1_->SignalRemoteStreamAdded.connect(
+ observer1_.get(), &MockSignalingObserver::OnRemoteStreamAdded);
+ signaling1_->SignalRemoteStreamRemoved.connect(
+ observer1_.get(), &MockSignalingObserver::OnRemoteStreamRemoved);
+ signaling1_->SignalErrorMessageReceived.connect(
+ observer1_.get(), &MockSignalingObserver::OnErrorReceived);
+ signaling1_->SignalStateChange.connect(
+ observer1_.get(), &MockSignalingObserver::OnStateChange);
+
+ signaling2_.reset(new PeerConnectionSignaling(
+ talk_base::Thread::Current(), provider2_.get()));
+ observer2_.reset(new MockSignalingObserver());
+ signaling2_->SignalNewPeerConnectionMessage.connect(
+ observer2_.get(), &MockSignalingObserver::OnSignalingMessage);
+ signaling2_->SignalRemoteStreamAdded.connect(
+ observer2_.get(), &MockSignalingObserver::OnRemoteStreamAdded);
+ signaling2_->SignalRemoteStreamRemoved.connect(
+ observer2_.get(), &MockSignalingObserver::OnRemoteStreamRemoved);
+ signaling2_->SignalErrorMessageReceived.connect(
+ observer2_.get(), &MockSignalingObserver::OnErrorReceived);
+ signaling2_->SignalStateChange.connect(
+ observer2_.get(), &MockSignalingObserver::OnStateChange);
+ }
+
+ // Create a collection of streams be sent on signaling1__
+ talk_base::scoped_refptr<StreamCollection> CreateLocalCollection1() {
+ std::string label(kStreamLabel1);
+ talk_base::scoped_refptr<LocalMediaStreamInterface> stream1(
+ MediaStream::Create(label));
+
+ // Add a local audio track.
+ talk_base::scoped_refptr<LocalAudioTrackInterface>
+ audio_track(AudioTrack::CreateLocal(kAudioTrackLabel1, NULL));
+ stream1->AddTrack(audio_track);
+
+ // Add a local video track.
+ talk_base::scoped_refptr<LocalVideoTrackInterface>
+ video_track(VideoTrack::CreateLocal(kVideoTrackLabel1, NULL));
+ stream1->AddTrack(video_track);
+
+ talk_base::scoped_refptr<StreamCollection> local_collection1(
+ StreamCollection::Create());
+ local_collection1->AddStream(stream1);
+
+ return local_collection1;
+ }
+
+ talk_base::scoped_refptr<StreamCollection> CreateLocalCollection2() {
+ std::string label(kStreamLabel2);
+ talk_base::scoped_refptr<LocalMediaStreamInterface> stream2(
+ MediaStream::Create(label));
+
+ // Add a local audio track.
+ talk_base::scoped_refptr<LocalAudioTrackInterface>
+ audio_track(AudioTrack::CreateLocal(kAudioTrackLabel2, NULL));
+ stream2->AddTrack(audio_track);
+
+ talk_base::scoped_refptr<StreamCollection> local_collection2(
+ StreamCollection::Create());
+ local_collection2->AddStream(stream2);
+
+ return local_collection2;
+ }
+
+ void VerifyStreamStates(StreamCollection* collection,
+ MediaStreamInterface::ReadyState state,
+ MediaStreamTrackInterface::TrackState track_state) {
+ for (size_t i = 0; i < collection->count(); ++i) {
+ MediaStreamInterface* stream = collection->at(i);
+ EXPECT_EQ(state, stream->ready_state());
+ for (size_t j = 0; j < stream->audio_tracks()->count(); ++j) {
+ AudioTrackInterface* audio = stream->audio_tracks()->at(j);
+ EXPECT_EQ(track_state, audio->state());
+ }
+ for (size_t j = 0; j < stream->video_tracks()->count(); ++j) {
+ VideoTrackInterface* video = stream->video_tracks()->at(j);
+ EXPECT_EQ(track_state, video->state());
+ }
+ }
+ }
+
+ // Initialize and setup a simple call between signaling1_ and signaling2_.
+ // signaling1_ send stream with label kStreamLabel1 to signaling2_.
+ void SetUpOneWayCall() {
+ // Initialize signaling1_ and signaling_2 by providing the candidates.
+ signaling1_->OnCandidatesReady(candidates_);
+ signaling2_->OnCandidatesReady(candidates_);
+
+ // Create a local stream collection to be sent on signaling1_.
+ talk_base::scoped_refptr<StreamCollection> local_collection1(
+ CreateLocalCollection1());
+
+ talk_base::scoped_refptr<StreamCollection> local_collection2(
+ StreamCollection::Create());
+
+ // Connect all messages sent from signaling1_ to be received on signaling2_
+ observer1_->AnswerPeer(signaling2_.get(), local_collection2);
+ // Connect all messages sent from Peer2 to be received on Peer1
+ observer2_->AnswerPeer(signaling1_.get(), local_collection1);
+
+ signaling1_->CreateOffer(local_collection1);
+ EXPECT_EQ(PeerConnectionSignaling::kWaitingForAnswer,
+ signaling1_->GetState());
+ EXPECT_EQ(PeerConnectionSignaling::kIdle, signaling2_->GetState());
+
+ // Process posted messages to generate the offer and the answer to the
+ // offer.
+ talk_base::Thread::Current()->ProcessMessages(1);
+ talk_base::Thread::Current()->ProcessMessages(1);
+
+ // Make sure all is setup.
+ EXPECT_EQ(PeerConnectionSignaling::kIdle, signaling1_->GetState());
+ EXPECT_EQ(PeerConnectionSignaling::kIdle, signaling2_->GetState());
+
+ EXPECT_TRUE(observer2_->RemoteStream(kStreamLabel1) != NULL);
+ EXPECT_EQ(0u, signaling1_->remote_streams()->count());
+ EXPECT_EQ(1u, signaling2_->remote_streams()->count());
+ }
+
+ cricket::Candidates candidates_;
+ talk_base::scoped_ptr<MockSignalingObserver> observer1_;
+ talk_base::scoped_ptr<MockSignalingObserver> observer2_;
+ talk_base::scoped_ptr<MockSessionDescriptionProvider> provider1_;
+ talk_base::scoped_ptr<MockSessionDescriptionProvider> provider2_;
+ talk_base::scoped_ptr<PeerConnectionSignaling> signaling1_;
+ talk_base::scoped_ptr<PeerConnectionSignaling> signaling2_;
+ talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
+};
+
+TEST_F(PeerConnectionSignalingTest, SimpleOneWayCall) {
+ // Peer 1 create an offer with only one audio track.
+ talk_base::scoped_refptr<StreamCollection> local_collection1(
+ CreateLocalCollection1());
+
+ // Verify that the local stream is now initializing.
+ VerifyStreamStates(local_collection1.get(),
+ MediaStreamInterface::kInitializing,
+ MediaStreamTrackInterface::kInitializing);
+
+ // Peer 2 only receive. Create an empty collection
+ talk_base::scoped_refptr<StreamCollection> local_collection2(
+ StreamCollection::Create());
+
+ // Connect all messages sent from Peer1 to be received on Peer2
+ observer1_->AnswerPeer(signaling2_.get(), local_collection2);
+ // Connect all messages sent from Peer2 to be received on Peer1
+ observer2_->AnswerPeer(signaling1_.get(), local_collection1);
+
+ // Peer 1 generates the offer. It is not sent since there is no
+ // local candidates ready.
+ signaling1_->CreateOffer(local_collection1);
+
+ // Process posted messages.
+ talk_base::Thread::Current()->ProcessMessages(1);
+ EXPECT_EQ(PeerConnectionSignaling::kInitializing, signaling1_->GetState());
+
+ // Initialize signaling1_ by providing the candidates.
+ signaling1_->OnCandidatesReady(candidates_);
+ EXPECT_EQ(PeerConnectionSignaling::kWaitingForAnswer,
+ signaling1_->GetState());
+ // Process posted messages to allow signaling_1 to send the offer.
+ talk_base::Thread::Current()->ProcessMessages(1);
+
+ // Verify that signaling_2 is still not initialized.
+ // Even though it have received an offer.
+ EXPECT_EQ(PeerConnectionSignaling::kInitializing, signaling2_->GetState());
+
+ // Provide the candidates to signaling_2 and let it process the offer.
+ signaling2_->OnCandidatesReady(candidates_);
+ talk_base::Thread::Current()->ProcessMessages(1);
+
+ // Verify that the offer/answer have been exchanged and the state is good.
+ EXPECT_EQ(PeerConnectionSignaling::kIdle, signaling1_->GetState());
+ EXPECT_EQ(PeerConnectionSignaling::kIdle, signaling2_->GetState());
+
+ // Verify that the local stream is now sending.
+ VerifyStreamStates(local_collection1, MediaStreamInterface::kLive,
+ MediaStreamTrackInterface::kLive);
+
+ // Verify that PeerConnection2 is aware of the sending stream.
+ EXPECT_TRUE(observer2_->RemoteStream(kStreamLabel1) != NULL);
+
+ // Verify that both peers have updated the session descriptions.
+ EXPECT_EQ(1u, provider1_->update_session_description_counter_);
+ EXPECT_EQ(1u, provider2_->update_session_description_counter_);
+}
+
+TEST_F(PeerConnectionSignalingTest, Glare) {
+ // Setup a call.
+ SetUpOneWayCall();
+
+ // Stop sending all messages automatically between Peer 1 and Peer 2.
+ observer1_->CancelAnswerPeer();
+ observer2_->CancelAnswerPeer();
+
+ // Create an empty collection for Peer 1.
+ talk_base::scoped_refptr<StreamCollection> local_collection1(
+ StreamCollection::Create());
+ // Create a collection for Peer 2.
+ talk_base::scoped_refptr<StreamCollection> local_collection2(
+ CreateLocalCollection2());
+
+ // Peer 1 create an updated offer.
+ signaling1_->CreateOffer(local_collection1);
+ // Peer 2 create an updated offer.
+ signaling2_->CreateOffer(local_collection2);
+
+ // Process posted messages.
+ talk_base::Thread::Current()->ProcessMessages(1);
+ talk_base::Thread::Current()->ProcessMessages(1);
+
+ std::string offer_1 = observer1_->last_message_;
+ std::string offer_2 = observer2_->last_message_;
+ EXPECT_EQ(PeerConnectionSignaling::kWaitingForAnswer,
+ signaling1_->GetState());
+ EXPECT_EQ(PeerConnectionSignaling::kWaitingForAnswer,
+ signaling2_->GetState());
+
+ // Connect all messages sent from Peer 1 to be received on Peer 2
+ observer1_->AnswerPeer(signaling2_.get(), local_collection2);
+ // Connect all messages sent from Peer 2 to be received on Peer 1
+ observer2_->AnswerPeer(signaling1_.get(), local_collection1);
+
+ // Insert the two offers to each Peer to create the Glare.
+ signaling1_->ProcessSignalingMessage(offer_2, local_collection1);
+ signaling2_->ProcessSignalingMessage(offer_1, local_collection2);
+
+ talk_base::Thread::Current()->ProcessMessages(1);
+ talk_base::Thread::Current()->ProcessMessages(1);
+
+ // Make sure all is good.
+ EXPECT_EQ(PeerConnectionSignaling::kIdle, signaling1_->GetState());
+ EXPECT_EQ(PeerConnectionSignaling::kIdle, signaling2_->GetState());
+
+ // Verify that Peer 1 is receiving kStreamLabel2.
+ EXPECT_TRUE(observer1_->RemoteStream(kStreamLabel2) != NULL);
+ // Verify that Peer 2 don't receive any streams
+ // since it has been removed.
+ EXPECT_TRUE(observer2_->RemoteStream(kStreamLabel1) == NULL);
+
+ // Verify that both peers have updated the session descriptions.
+ EXPECT_EQ(2u, provider1_->update_session_description_counter_);
+ EXPECT_EQ(2u, provider2_->update_session_description_counter_);
+}
+
+TEST_F(PeerConnectionSignalingTest, AddRemoveStream) {
+ // Initialize signaling1_ and signaling_2 by providing the candidates.
+ signaling1_->OnCandidatesReady(candidates_);
+ signaling2_->OnCandidatesReady(candidates_);
+ // Create a local stream.
+ std::string label(kStreamLabel1);
+ talk_base::scoped_refptr<LocalMediaStreamInterface> stream(
+ MediaStream::Create(label));
+
+ // Add a local audio track.
+ talk_base::scoped_refptr<LocalAudioTrackInterface>
+ audio_track(AudioTrack::CreateLocal(kAudioTrackLabel1, NULL));
+ stream->AddTrack(audio_track);
+
+ // Add a local video track.
+ talk_base::scoped_refptr<LocalVideoTrackInterface>
+ video_track(VideoTrack::CreateLocal(kVideoTrackLabel1, NULL));
+ stream->AddTrack(video_track);
+
+ // Peer 1 create an empty collection
+ talk_base::scoped_refptr<StreamCollection> local_collection1(
+ StreamCollection::Create());
+
+ // Peer 2 create an empty collection
+ talk_base::scoped_refptr<StreamCollection> local_collection2(
+ StreamCollection::Create());
+
+ // Connect all messages sent from Peer1 to be received on Peer2
+ observer1_->AnswerPeer(signaling2_.get(), local_collection2);
+ // Connect all messages sent from Peer2 to be received on Peer1
+ observer2_->AnswerPeer(signaling1_.get(), local_collection1);
+
+ // Peer 1 creates an empty offer and send it to Peer2.
+ signaling1_->CreateOffer(local_collection1);
+ // Process posted messages.
+ talk_base::Thread::Current()->ProcessMessages(1);
+ talk_base::Thread::Current()->ProcessMessages(1);
+
+ // Verify that both peers have updated the session descriptions.
+ EXPECT_EQ(1u, provider1_->update_session_description_counter_);
+ EXPECT_EQ(1u, provider2_->update_session_description_counter_);
+
+ // Peer2 add a stream.
+ local_collection2->AddStream(stream);
+
+ signaling2_->CreateOffer(local_collection2);
+ talk_base::Thread::Current()->ProcessMessages(1);
+ talk_base::Thread::Current()->ProcessMessages(1);
+
+ // Verify that the PeerConnection 2 local stream is now sending.
+ VerifyStreamStates(local_collection2, MediaStreamInterface::kLive ,
+ MediaStreamTrackInterface::kLive);
+
+ // Verify that PeerConnection1 is aware of the sending stream.
+ EXPECT_TRUE(observer1_->RemoteStream(label) != NULL);
+
+ // Verify that both peers have updated the session descriptions.
+ EXPECT_EQ(2u, provider1_->update_session_description_counter_);
+ EXPECT_EQ(2u, provider2_->update_session_description_counter_);
+
+ // Remove the stream
+ local_collection2->RemoveStream(stream);
+
+ signaling2_->CreateOffer(local_collection2);
+ talk_base::Thread::Current()->ProcessMessages(1);
+ talk_base::Thread::Current()->ProcessMessages(1);
+
+ // Verify that PeerConnection1 is not aware of the sending stream.
+ EXPECT_TRUE(observer1_->RemoteStream(label) == NULL);
+
+ // Verify that the PeerConnection 2 local stream is now ended.
+ VerifyStreamStates(local_collection2, MediaStreamInterface::kEnded ,
+ MediaStreamTrackInterface::kEnded);
+
+ // Verify that both peers have updated the session descriptions.
+ EXPECT_EQ(3u, provider1_->update_session_description_counter_);
+ EXPECT_EQ(3u, provider2_->update_session_description_counter_);
+}
+
+TEST_F(PeerConnectionSignalingTest, ShutDown) {
+ // Setup a call.
+ SetUpOneWayCall();
+
+ signaling1_->SendShutDown();
+
+ EXPECT_EQ_WAIT(PeerConnectionSignaling::kShutdownComplete,
+ signaling1_->GetState(), 10);
+ EXPECT_EQ_WAIT(PeerConnectionSignaling::kShutdownComplete,
+ signaling2_->GetState(), 10);
+
+ EXPECT_EQ(0u, signaling1_->remote_streams()->count());
+ EXPECT_EQ(0u, signaling2_->remote_streams()->count());
+ EXPECT_TRUE(observer2_->RemoteStream(kStreamLabel1) == NULL);
+ EXPECT_EQ(PeerConnectionSignaling::kShutdownComplete, observer1_->state_);
+ EXPECT_EQ(PeerConnectionSignaling::kShutdownComplete, observer2_->state_);
+
+ // Verify that both peers have updated the session descriptions.
+ EXPECT_EQ(2u, provider1_->update_session_description_counter_);
+ EXPECT_EQ(2u, provider2_->update_session_description_counter_);
+}
+
+TEST_F(PeerConnectionSignalingTest, ReceiveError) {
+ // Initialize signaling1_
+ signaling1_->OnCandidatesReady(candidates_);
+
+ talk_base::scoped_refptr<StreamCollection> local_collection1(
+ CreateLocalCollection1());
+
+ signaling1_->CreateOffer(local_collection1);
+ talk_base::Thread::Current()->ProcessMessages(1);
+ EXPECT_EQ(PeerConnectionSignaling::kWaitingForAnswer,
+ signaling1_->GetState());
+
+ RoapSession roap_session;
+ roap_session.Parse(observer1_->last_message_);
+ signaling1_->ProcessSignalingMessage(roap_session.CreateErrorMessage(
+ kNoMatch), local_collection1);
+ EXPECT_EQ(kNoMatch, observer1_->last_error_);
+
+ // Check signaling have cleaned up.
+ EXPECT_EQ(PeerConnectionSignaling::kIdle, signaling1_->GetState());
+
+ signaling1_->CreateOffer(local_collection1);
+ talk_base::Thread::Current()->ProcessMessages(1);
+ EXPECT_EQ(PeerConnectionSignaling::kWaitingForAnswer,
+ signaling1_->GetState());
+}
+
+} // namespace webrtc
+
diff --git a/talk/app/webrtc/portallocatorfactory.cc b/talk/app/webrtc/portallocatorfactory.cc
new file mode 100644
index 0000000..e997216
--- /dev/null
+++ b/talk/app/webrtc/portallocatorfactory.cc
@@ -0,0 +1,95 @@
+/*
+ * libjingle
+ * Copyright 2004--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/portallocatorfactory.h"
+
+#include "talk/base/logging.h"
+#include "talk/base/network.h"
+#include "talk/base/basicpacketsocketfactory.h"
+#include "talk/base/thread.h"
+#include "talk/p2p/client/httpportallocator.h"
+
+static const char kUserAgent[] = "PeerConnection User Agent";
+
+namespace webrtc {
+
+using talk_base::scoped_ptr;
+
+talk_base::scoped_refptr<PortAllocatorFactoryInterface>
+PortAllocatorFactory::Create(
+ talk_base::Thread* worker_thread) {
+ talk_base::RefCountedObject<PortAllocatorFactory>* allocator =
+ new talk_base::RefCountedObject<PortAllocatorFactory>(worker_thread);
+ return allocator;
+}
+
+PortAllocatorFactory::PortAllocatorFactory(talk_base::Thread* worker_thread)
+ : network_manager_(new talk_base::BasicNetworkManager()),
+ socket_factory_(new talk_base::BasicPacketSocketFactory(worker_thread)) {
+}
+
+PortAllocatorFactory::~PortAllocatorFactory() {}
+
+cricket::PortAllocator* PortAllocatorFactory::CreatePortAllocator(
+ const std::vector<StunConfiguration>& stun,
+ const std::vector<TurnConfiguration>& turn) {
+
+ scoped_ptr<cricket::HttpPortAllocator> allocator(
+ new cricket::HttpPortAllocator(
+ network_manager_.get(), socket_factory_.get(), kUserAgent));
+
+ std::vector<talk_base::SocketAddress> stun_hosts;
+ typedef std::vector<StunConfiguration>::const_iterator StunIt;
+ for (StunIt stun_it = stun.begin(); stun_it != stun.end(); ++stun_it) {
+ stun_hosts.push_back(stun_it->server);
+ }
+ allocator->SetStunHosts(stun_hosts);
+
+ if (turn.size() > 0)
+ LOG(LS_INFO) << "Not using turn server params";
+
+ // TODO - Enable TURN support once WebRtcSession can handle
+ // relay candidates.
+#if 0
+ std::vector<std::string> relay_hosts;
+ typedef std::vector<TurnConfiguration>::const_iterator TurnIt;
+ for (TurnIt turn_it = turn.begin(); turn_it != turn.end(); ++turn_it) {
+ relay_hosts.push_back(turn_it->server.hostname());
+ }
+ allocator->SetRelayHosts(relay_hosts);
+
+ // Currently we can only set the password of one relay server.
+ // Use the password of the first server. User name can currently not be set.
+ // TODO: See above limitations.
+ if (turn.size() > 0)
+ allocator->SetRelayToken(turn[0].password);
+#endif
+
+ return allocator.release();
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/portallocatorfactory.h b/talk/app/webrtc/portallocatorfactory.h
new file mode 100644
index 0000000..1b0d753
--- /dev/null
+++ b/talk/app/webrtc/portallocatorfactory.h
@@ -0,0 +1,70 @@
+/*
+ * 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 defines the default implementation of
+// PortAllocatorFactoryInterface.
+// This implementation creates instances of cricket::HTTPPortAllocator and uses
+// the BasicNetworkManager and BasicPacketSocketFactory.
+
+#ifndef TALK_APP_WEBRTC_PORTALLOCATORFACTORY_H_
+#define TALK_APP_WEBRTC_PORTALLOCATORFACTORY_H_
+
+#include "talk/app/webrtc/peerconnection.h"
+#include "talk/base/scoped_ptr.h"
+
+namespace cricket {
+class PortAllocator;
+}
+
+namespace talk_base {
+class BasicNetworkManager;
+class BasicPacketSocketFactory;
+}
+
+namespace webrtc {
+
+class PortAllocatorFactory : public PortAllocatorFactoryInterface {
+ public:
+ static talk_base::scoped_refptr<PortAllocatorFactoryInterface> Create(
+ talk_base::Thread* worker_thread);
+
+ virtual cricket::PortAllocator* CreatePortAllocator(
+ const std::vector<StunConfiguration>& stun,
+ const std::vector<TurnConfiguration>& turn);
+
+ protected:
+ explicit PortAllocatorFactory(talk_base::Thread* worker_thread);
+ ~PortAllocatorFactory();
+
+ private:
+ talk_base::scoped_ptr<talk_base::BasicNetworkManager> network_manager_;
+ talk_base::scoped_ptr<talk_base::BasicPacketSocketFactory> socket_factory_;
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_PORTALLOCATORFACTORY_H_
diff --git a/talk/app/webrtc/roaperrorcodes.h b/talk/app/webrtc/roaperrorcodes.h
new file mode 100644
index 0000000..d13230d
--- /dev/null
+++ b/talk/app/webrtc/roaperrorcodes.h
@@ -0,0 +1,48 @@
+/*
+ * 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 contain an enum of possible error codes used in Roap.
+// The meaning of the error codes are defined in
+// http://tools.ietf.org/html/draft-jennings-rtcweb-signaling-01.
+
+#ifndef TALK_APP_WEBRTC_ROAPERRORCODES_H_
+#define TALK_APP_WEBRTC_ROAPERRORCODES_H_
+
+namespace webrtc {
+
+enum RoapErrorCode {
+ kNoMatch,
+ kTimeout,
+ kRefused,
+ kConflict,
+ kDoubleConflict,
+ kFailed
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_ROAPERRORCODES_H_
diff --git a/talk/app/webrtc/roapmessages.cc b/talk/app/webrtc/roapmessages.cc
new file mode 100644
index 0000000..e0528a7
--- /dev/null
+++ b/talk/app/webrtc/roapmessages.cc
@@ -0,0 +1,293 @@
+/*
+ * 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/roapmessages.h"
+
+#include "talk/app/webrtc/webrtcsdp.h"
+#include "talk/base/json.h"
+
+namespace webrtc {
+
+using cricket::Candidate;
+using cricket::SessionDescription;
+
+// ROAP message types. Must match the enum RoapMessageType.
+static const char* kMessageTypes[] = {
+ "OFFER",
+ "ANSWER",
+ "OK",
+ "SHUTDOWN",
+ "ERROR",
+};
+
+// ROAP error messages. Must match the enum RoapErrorCode.
+static const char* kErrorMessages[] = {
+ "NOMATCH",
+ "TIMEOUT",
+ "REFUSED",
+ "CONFLICT",
+ "DOUBLECONFLICT",
+ "FAILED",
+};
+
+// ROAP json keys.
+static const char kOffererSessionId[] = "offererSessionId";
+static const char kAnswererSessionId[] = "answererSessionId";
+static const char kSetSessionToken[] = "setSessionToken";
+static const char kSetResponseToken[] = "setResponseToken";
+static const char kResponseToken[] = "responseToken";
+static const char kSessionToken[] = "sessionToken";
+static const char kMessageType[] = "messageType";
+static const char kSequenceNumber[] = "seq";
+static const char kSessionDescription[] = "sdp";
+static const char kErrorType[] = "errorType";
+static const char kTieBreaker[] = "tieBreaker";
+static const char kMoreComing[] = "moreComing";
+
+RoapMessageBase::RoapMessageBase() : type_(kInvalid), seq_(0) {
+}
+
+RoapMessageBase::RoapMessageBase(RoapMessageType type,
+ const std::string& offer_session_id,
+ const std::string& answer_session_id,
+ const std::string& session_token,
+ const std::string& response_token,
+ uint32 seq)
+ : type_(type),
+ offer_session_id_(offer_session_id),
+ answer_session_id_(answer_session_id),
+ session_token_(session_token),
+ response_token_(response_token),
+ seq_(seq) {
+}
+
+bool RoapMessageBase::Parse(const std::string& message) {
+ Json::Reader reader;
+ if (!reader.parse(message, jmessage_))
+ return false;
+
+ std::string message_type;
+ GetStringFromJsonObject(jmessage_, kMessageType, &message_type);
+ if (message_type.empty())
+ return false;
+ bool valid_message_type = false;
+ for (int i = 0; i < kInvalid; i++) {
+ if (message_type == kMessageTypes[i]) {
+ type_ = static_cast<RoapMessageType>(i);
+ valid_message_type = true;
+ break;
+ }
+ }
+ if (!valid_message_type)
+ return false;
+
+ if (!GetStringFromJsonObject(jmessage_, kOffererSessionId,
+ &offer_session_id_) ||
+ offer_session_id_.empty()) {
+ // Parse offererSessionId. Allow error messages to not have an
+ // offererSessionId.
+ if (type_ != kError)
+ return false;
+ }
+
+ // answererSessionId does not necessarily need to exist in MessageBase.
+ GetStringFromJsonObject(jmessage_, kAnswererSessionId, &answer_session_id_);
+ // setSessionToken and setResponseToken is not required.
+ GetStringFromJsonObject(jmessage_, kSetSessionToken, &session_token_);
+ GetStringFromJsonObject(jmessage_, kSetResponseToken, &response_token_);
+
+ unsigned int temp_seq;
+ if (!GetUIntFromJsonObject(jmessage_, kSequenceNumber, &temp_seq)) {
+ return false;
+ }
+ if (temp_seq > 0xFFFFFFFF)
+ return false;
+ seq_ = static_cast<uint32>(temp_seq);
+
+ return true;
+}
+
+std::string RoapMessageBase::Serialize() {
+ Json::Value message;
+ SerializeElement(&message);
+ Json::StyledWriter writer;
+ return writer.write(message);
+}
+
+void RoapMessageBase::SerializeElement(Json::Value* message) {
+ ASSERT(message != NULL);
+ (*message)[kMessageType] = kMessageTypes[type_];
+ (*message)[kOffererSessionId] = offer_session_id_;
+ if (!answer_session_id_.empty())
+ (*message)[kAnswererSessionId] = answer_session_id_;
+ if (!session_token_.empty())
+ (*message)[kSessionToken] = session_token_;
+ if (!response_token_.empty())
+ (*message)[kResponseToken] = response_token_;
+ (*message)[kSequenceNumber] = seq_;
+}
+
+RoapOffer::RoapOffer(const std::string& offer_session_id,
+ const std::string& answer_session_id,
+ const std::string& session_token,
+ uint32 seq,
+ uint32 tie_breaker,
+ const SessionDescription* desc,
+ const std::vector<cricket::Candidate>& candidates)
+ : RoapMessageBase(kOffer, offer_session_id, answer_session_id,
+ session_token, "", seq),
+ tie_breaker_(tie_breaker),
+ desc_(desc),
+ candidates_(candidates) {
+}
+
+RoapOffer::RoapOffer(const RoapMessageBase& base)
+ : RoapMessageBase(base),
+ desc_(NULL) {}
+
+bool RoapOffer::Parse() {
+ if (!GetUIntFromJsonObject(jmessage_, kTieBreaker, &tie_breaker_)) {
+ return false;
+ }
+
+ std::string sdp_message;
+ if (!GetStringFromJsonObject(jmessage_, kSessionDescription, &sdp_message))
+ return false;
+
+ parsed_desc_.reset(new cricket::SessionDescription());
+ return SdpDeserialize(sdp_message, parsed_desc_.get(),
+ &candidates_);
+}
+
+void RoapOffer::SerializeElement(Json::Value* message) {
+ ASSERT(message != NULL);
+ RoapMessageBase::SerializeElement(message);
+ (*message)[kTieBreaker] = tie_breaker_;
+ (*message)[kSessionDescription] = SdpSerialize(*desc_, candidates_);
+}
+
+RoapAnswer::RoapAnswer(const std::string& offer_session_id,
+ const std::string& answer_session_id,
+ const std::string& session_token,
+ const std::string& response_token,
+ uint32 seq,
+ const SessionDescription* desc,
+ const std::vector<Candidate>& candidates)
+ : RoapMessageBase(kAnswer, offer_session_id, answer_session_id,
+ session_token, response_token, seq),
+ desc_(desc),
+ candidates_(candidates) {
+}
+
+RoapAnswer::RoapAnswer(const RoapMessageBase& base)
+ : RoapMessageBase(base),
+ more_coming_(false),
+ desc_(NULL) {}
+
+bool RoapAnswer::Parse() {
+ std::string more;
+ if (GetStringFromJsonObject(jmessage_, kMoreComing, &more) && more == "true")
+ more_coming_ = true;
+
+ std::string sdp_message;
+ if (!GetStringFromJsonObject(jmessage_, kSessionDescription, &sdp_message))
+ return false;
+
+ parsed_desc_.reset(new cricket::SessionDescription());
+ return SdpDeserialize(sdp_message, parsed_desc_.get(), &candidates_);
+}
+
+void RoapAnswer::SerializeElement(Json::Value* message) {
+ ASSERT(message != NULL);
+ RoapMessageBase::SerializeElement(message);
+
+ (*message)[kSessionDescription] = SdpSerialize(*desc_, candidates_);
+}
+
+RoapError::RoapError(const RoapMessageBase& base)
+ : RoapMessageBase(base), error_(kFailed) {
+}
+
+RoapError::RoapError(const std::string& offer_session_id,
+ const std::string& answer_session_id,
+ const std::string& session_token,
+ const std::string& response_token,
+ uint32 seq,
+ RoapErrorCode error)
+ : RoapMessageBase(kError, offer_session_id, answer_session_id,
+ session_token, response_token, seq),
+ error_(error) {
+}
+
+bool RoapError::Parse() {
+ std::string error_string;
+ GetStringFromJsonObject(jmessage_, kErrorType, &error_string);
+ if (error_string.empty())
+ return false;
+ for (int i = 0; i < ARRAY_SIZE(kErrorMessages); i++) {
+ if (error_string == kErrorMessages[i]) {
+ error_ = static_cast<RoapErrorCode>(i);
+ return true;
+ }
+ }
+ return false;
+}
+
+void RoapError::SerializeElement(Json::Value* message) {
+ ASSERT(message != NULL);
+ ASSERT(error_< ARRAY_SIZE(kErrorMessages));
+ RoapMessageBase::SerializeElement(message);
+
+ (*message)[kErrorType] = kErrorMessages[error_];
+}
+
+RoapOk::RoapOk(const RoapMessageBase& base)
+ : RoapMessageBase(base) {
+}
+
+RoapOk::RoapOk(const std::string& offer_session_id,
+ const std::string& answer_session_id,
+ const std::string& session_token,
+ const std::string& response_token,
+ uint32 seq)
+ : RoapMessageBase(kOk, offer_session_id, answer_session_id, session_token,
+ response_token, seq) {
+}
+
+RoapShutdown::RoapShutdown(const RoapMessageBase& base)
+ : RoapMessageBase(base) {
+}
+
+RoapShutdown::RoapShutdown(const std::string& offer_session_id,
+ const std::string& answer_session_id,
+ const std::string& session_token,
+ uint32 seq)
+ : RoapMessageBase(kShutdown, offer_session_id, answer_session_id,
+ session_token, "", seq) {
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/roapmessages.h b/talk/app/webrtc/roapmessages.h
new file mode 100644
index 0000000..7b18010
--- /dev/null
+++ b/talk/app/webrtc/roapmessages.h
@@ -0,0 +1,202 @@
+/*
+ * 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 contain classes for parsing and serializing ROAP messages.
+// The ROAP messages are defined in
+// http://tools.ietf.org/html/draft-jennings-rtcweb-signaling-01.
+
+#ifndef TALK_APP_WEBRTC_ROAPMESSAGES_H_
+#define TALK_APP_WEBRTC_ROAPMESSAGES_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/app/webrtc/roaperrorcodes.h"
+#include "talk/base/basictypes.h"
+#include "talk/base/json.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/p2p/base/candidate.h"
+#include "talk/p2p/base/sessiondescription.h"
+
+namespace webrtc {
+
+class RoapMessageBase {
+ public:
+ enum RoapMessageType {
+ kOffer = 0,
+ kAnswer = 1,
+ kOk = 2,
+ kShutdown = 3,
+ kError = 4,
+ kInvalid = 5,
+ };
+ RoapMessageBase();
+ RoapMessageBase(RoapMessageType type,
+ const std::string& offer_session_id,
+ const std::string& answer_session_id,
+ const std::string& session_token,
+ const std::string& response_token,
+ uint32 seq);
+
+ bool Parse(const std::string& message);
+ std::string Serialize();
+
+ RoapMessageType type() const { return type_; }
+ const std::string& offer_session_id() const { return offer_session_id_; }
+ const std::string& answer_session_id() const { return answer_session_id_; }
+ const std::string& session_token() const { return session_token_; }
+ const std::string& response_token() const { return response_token_; }
+ uint32 seq() const { return seq_; }
+
+ protected:
+ virtual void SerializeElement(Json::Value* message);
+ Json::Value jmessage_; // Contains the parsed json message.
+
+ private:
+ RoapMessageType type_;
+ std::string offer_session_id_;
+ std::string answer_session_id_;
+ std::string session_token_;
+ std::string response_token_;
+ uint32 seq_;
+};
+
+class RoapAnswer : public RoapMessageBase {
+ public:
+ explicit RoapAnswer(const RoapMessageBase& base);
+ // Note that the SessionDescription desc is used as a weak reference.
+ // The user of this class must ensure that desc outlives an instance of this
+ // object.
+ RoapAnswer(const std::string& offer_session_id,
+ const std::string& answer_session_id,
+ const std::string& session_token,
+ const std::string& response_token,
+ uint32 seq,
+ const cricket::SessionDescription* desc,
+ const std::vector<cricket::Candidate>& candidates);
+ bool Parse();
+
+ // Get remote SessionDescription if the session description has been parsed
+ // and the ownership is transferred to the caller.
+ // NULL otherwise.
+ cricket::SessionDescription* ReleaseSessionDescription() {
+ return parsed_desc_.release();
+ }
+ const std::vector<cricket::Candidate>& candidates() const {
+ return candidates_;
+ }
+ bool more_coming() const { return more_coming_ ; }
+
+ protected:
+ virtual void SerializeElement(Json::Value* message);
+
+ private:
+ bool more_coming_;
+ // Session description parsed in an offer.
+ talk_base::scoped_ptr<cricket::SessionDescription> parsed_desc_;
+ // Weak ref to a session description provided in the constructor.
+ const cricket::SessionDescription* desc_;
+ std::vector<cricket::Candidate> candidates_;
+};
+
+class RoapOffer : public RoapMessageBase {
+ public:
+ explicit RoapOffer(const RoapMessageBase& base);
+ // Note that the SessionDescription desc is used as a weak reference.
+ // The user of this class must ensure that desc outlives an instance of this
+ // object.
+ RoapOffer(const std::string& offer_session_id,
+ const std::string& answer_session_id,
+ const std::string& session_token,
+ uint32 seq,
+ uint32 tie_breaker,
+ const cricket::SessionDescription* desc,
+ const std::vector<cricket::Candidate>& candidates);
+ bool Parse();
+
+ uint32 tie_breaker() const { return tie_breaker_; }
+ // Get remote SessionDescription if the session description has been parsed
+ // and the ownership is transferred to the caller.
+ // NULL otherwise.
+ cricket::SessionDescription* ReleaseSessionDescription() {
+ return parsed_desc_.release();
+ }
+ const std::vector<cricket::Candidate>& candidates() { return candidates_; }
+
+ protected:
+ virtual void SerializeElement(Json::Value* message);
+
+ private:
+ uint32 tie_breaker_;
+ // Session description parsed in an offer.
+ talk_base::scoped_ptr<cricket::SessionDescription> parsed_desc_;
+ // Weak reference to a session description provided in the constructor.
+ const cricket::SessionDescription* desc_;
+ std::vector<cricket::Candidate> candidates_;
+};
+
+class RoapError : public RoapMessageBase {
+ public:
+ explicit RoapError(const RoapMessageBase& base);
+ RoapError(const std::string& offer_session_id,
+ const std::string& answer_session_id,
+ const std::string& session_token,
+ const std::string& response_token,
+ uint32 seq,
+ RoapErrorCode error);
+ bool Parse();
+ RoapErrorCode error() const { return error_; }
+
+ protected:
+ virtual void SerializeElement(Json::Value* message);
+
+ private:
+ RoapErrorCode error_;
+};
+
+class RoapOk : public RoapMessageBase {
+ public:
+ explicit RoapOk(const RoapMessageBase& base);
+ RoapOk(const std::string& offer_session_id,
+ const std::string& answer_session_id,
+ const std::string& session_token,
+ const std::string& response_token,
+ uint32 seq);
+};
+
+class RoapShutdown : public RoapMessageBase {
+ public:
+ explicit RoapShutdown(const RoapMessageBase& base);
+ RoapShutdown(const std::string& offer_session_id,
+ const std::string& answer_session_id,
+ const std::string& session_token,
+ uint32 seq);
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_ROAPMESSAGES_H_
diff --git a/talk/app/webrtc/roapmessages_unittest.cc b/talk/app/webrtc/roapmessages_unittest.cc
new file mode 100644
index 0000000..b432667
--- /dev/null
+++ b/talk/app/webrtc/roapmessages_unittest.cc
@@ -0,0 +1,227 @@
+/*
+ * 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 "talk/app/webrtc/roapmessages.h"
+#include "talk/base/gunit.h"
+#include "talk/base/logging.h"
+#include "talk/p2p/base/transport.h"
+#include "talk/session/phone/mediasession.h"
+
+using cricket::Candidates;
+using cricket::AudioContentDescription;
+using cricket::SessionDescription;
+using cricket::StreamParams;
+using cricket::VideoContentDescription;
+
+static const char kStreamLabel1[] = "local_stream_1";
+static const char kStream1Cname[] = "stream_1_cname";
+static const char kAudioTrackLabel1[] = "local_audio_1";
+static const uint32 kAudioTrack1Ssrc = 1;
+
+static const char kOfferSessionId[] = "offer_1";
+static const char kAnswerSessionId[] = "answer_1";
+static const char kSessionToken[] = "session_1";
+
+static const char kOfferReference[] =
+ "{\n"
+ " \"answererSessionId\" : \"answer_1\",\n"
+ " \"messageType\" : \"OFFER\",\n"
+ " \"offererSessionId\" : \"offer_1\",\n"
+ " \"sdp\" : \"v=0\\r\\n"
+ "o=- 0 0 IN IP4 127.0.0.1\\r\\n"
+ "s=\\r\\n"
+ "t=0 0\\r\\n"
+ "m=audio 0 RTP/AVPF\\r\\n"
+ "a=mid:audio\\r\\n"
+ "a=rtcp-mux\\r\\n"
+ "a=ssrc:1 cname:stream_1_cname mslabel:local_stream_1 "
+ "label:local_audio_1\\r\\n"
+ "\",\n" // End of sdp.
+ " \"seq\" : 1,\n"
+ " \"tieBreaker\" : 0\n"
+ "}\n";
+
+static const char kAnswerReference[] =
+ "{\n"
+ " \"answererSessionId\" : \"answer_1\",\n"
+ " \"messageType\" : \"ANSWER\",\n"
+ " \"offererSessionId\" : \"offer_1\",\n"
+ " \"sdp\" : \"v=0\\r\\n"
+ "o=- 0 0 IN IP4 127.0.0.1\\r\\n"
+ "s=\\r\\n"
+ "t=0 0\\r\\n"
+ "m=audio 0 RTP/AVPF\\r\\n"
+ "a=mid:audio\\r\\n"
+ "a=rtcp-mux\\r\\n"
+ "a=ssrc:1 cname:stream_1_cname mslabel:local_stream_1 "
+ "label:local_audio_1\\r\\n"
+ "\",\n" // End of sdp.
+ " \"seq\" : 1\n"
+ "}\n";
+
+static const char kOkReference[] =
+ "{\n"
+ " \"answererSessionId\" : \"answer_1\",\n"
+ " \"messageType\" : \"OK\",\n"
+ " \"offererSessionId\" : \"offer_1\",\n"
+ " \"seq\" : 1\n"
+ "}\n";
+
+static const char kShutdownReference[] =
+ "{\n"
+ " \"answererSessionId\" : \"answer_1\",\n"
+ " \"messageType\" : \"SHUTDOWN\",\n"
+ " \"offererSessionId\" : \"offer_1\",\n"
+ " \"seq\" : 1\n"
+ "}\n";
+
+static const char kErrorReference[] =
+ "{\n"
+ " \"answererSessionId\" : \"answer_1\",\n"
+ " \"errorType\" : \"TIMEOUT\",\n"
+ " \"messageType\" : \"ERROR\",\n"
+ " \"offererSessionId\" : \"offer_1\",\n"
+ " \"seq\" : 1\n"
+ "}\n";
+
+// RoapMessageTest creates a session description that matches the
+// reference messages above.
+class RoapMessageTest: public testing::Test {
+ public:
+ void SetUp() {
+ talk_base::scoped_ptr<AudioContentDescription> audio(
+ new AudioContentDescription());
+ audio->set_rtcp_mux(true);
+ StreamParams audio_stream;
+ audio_stream.name = kAudioTrackLabel1;
+ audio_stream.cname = kStream1Cname;
+ audio_stream.sync_label = kStreamLabel1;
+ audio_stream.ssrcs.push_back(kAudioTrack1Ssrc);
+ audio->AddStream(audio_stream);
+ desc1_.AddContent(cricket::CN_AUDIO, cricket::NS_JINGLE_RTP,
+ audio.release());
+ }
+ protected:
+ cricket::SessionDescription desc1_;
+ cricket::Candidates empty_candidates_;
+};
+
+static bool CompareRoapBase(const webrtc::RoapMessageBase& base1,
+ const webrtc::RoapMessageBase& base2) {
+ return base1.type() == base2.type() &&
+ base1.offer_session_id() == base2.offer_session_id() &&
+ base1.answer_session_id() == base2.answer_session_id() &&
+ base1.session_token() == base2.session_token() &&
+ base1.response_token() == base2.response_token() &&
+ base1.seq() == base2.seq();
+}
+
+static bool CompareRoapOffer(const webrtc::RoapOffer& offer1,
+ const webrtc::RoapOffer& offer2) {
+ return CompareRoapBase(offer1, offer2) &&
+ offer1.tie_breaker() == offer2.tie_breaker();
+}
+
+static bool CompareRoapAnswer(const webrtc::RoapAnswer& answer1,
+ const webrtc::RoapAnswer& answer2) {
+ return CompareRoapBase(answer1, answer2) &&
+ answer1.more_coming() == answer1.more_coming();
+}
+
+static bool CompareRoapError(const webrtc::RoapError& error1,
+ const webrtc::RoapError& error2) {
+ return CompareRoapBase(error1, error2) &&
+ error1.error() == error2.error();
+}
+
+TEST_F(RoapMessageTest, RoapOffer) {
+ webrtc::RoapOffer offer(kOfferSessionId, kAnswerSessionId, "", 1, 0, &desc1_,
+ empty_candidates_);
+ std::string offer_string = offer.Serialize();
+ EXPECT_TRUE(kOfferReference == offer_string);
+
+ webrtc::RoapMessageBase base;
+ EXPECT_TRUE(base.Parse(kOfferReference));
+ EXPECT_EQ(webrtc::RoapMessageBase::kOffer, base.type());
+ webrtc::RoapOffer parsed_offer(base);
+ EXPECT_TRUE(parsed_offer.Parse());
+ EXPECT_TRUE(CompareRoapOffer(offer, parsed_offer));
+}
+
+TEST_F(RoapMessageTest, RoapAnswer) {
+ webrtc::RoapAnswer answer(kOfferSessionId, kAnswerSessionId, "", "", 1,
+ &desc1_, empty_candidates_);
+ std::string answer_string = answer.Serialize();
+ EXPECT_TRUE(kAnswerReference == answer_string);
+
+ webrtc::RoapMessageBase base;
+ EXPECT_TRUE(base.Parse(kAnswerReference));
+ EXPECT_EQ(webrtc::RoapMessageBase::kAnswer, base.type());
+ webrtc::RoapAnswer parsed_answer(base);
+ EXPECT_TRUE(parsed_answer.Parse());
+ EXPECT_TRUE(CompareRoapAnswer(answer, parsed_answer));
+}
+
+TEST_F(RoapMessageTest, RoapOk) {
+ webrtc::RoapOk ok(kOfferSessionId, kAnswerSessionId, "", "", 1);
+ std::string ok_string = ok.Serialize();
+ EXPECT_TRUE(kOkReference == ok_string);
+
+ webrtc::RoapMessageBase base;
+ EXPECT_TRUE(base.Parse(kOkReference));
+ EXPECT_EQ(webrtc::RoapMessageBase::kOk, base.type());
+ webrtc::RoapOk parsed_ok(base);
+ EXPECT_TRUE(CompareRoapBase(ok, parsed_ok));
+}
+
+TEST_F(RoapMessageTest, RoapShutdown) {
+ webrtc::RoapShutdown shutdown(kOfferSessionId, kAnswerSessionId, "", 1);
+ std::string shutdown_string = shutdown.Serialize();
+ EXPECT_TRUE(kShutdownReference == shutdown_string);
+
+ webrtc::RoapMessageBase base;
+ EXPECT_TRUE(base.Parse(kShutdownReference));
+ EXPECT_EQ(webrtc::RoapMessageBase::kShutdown, base.type());
+ webrtc::RoapShutdown parsed_shutdown(base);
+ EXPECT_TRUE(CompareRoapBase(shutdown, parsed_shutdown));
+}
+
+TEST_F(RoapMessageTest, RoapError) {
+ webrtc::RoapError error(kOfferSessionId, kAnswerSessionId, "", "", 1,
+ webrtc::kTimeout);
+ std::string error_string = error.Serialize();
+ EXPECT_TRUE(kErrorReference == error_string);
+
+ webrtc::RoapMessageBase base;
+ EXPECT_TRUE(base.Parse(kErrorReference));
+ EXPECT_EQ(webrtc::RoapMessageBase::kError, base.type());
+ webrtc::RoapError parsed_error(base);
+ EXPECT_TRUE(parsed_error.Parse());
+ EXPECT_TRUE(CompareRoapError(error, parsed_error));
+}
diff --git a/talk/app/webrtc/roapsession.cc b/talk/app/webrtc/roapsession.cc
new file mode 100644
index 0000000..014539f
--- /dev/null
+++ b/talk/app/webrtc/roapsession.cc
@@ -0,0 +1,286 @@
+/*
+ * 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/roapsession.h"
+
+#include "talk/app/webrtc/roapmessages.h"
+#include "talk/base/helpers.h"
+#include "talk/base/logging.h"
+
+namespace webrtc {
+
+static const uint32 kMaxTieBreaker = 0xFFFFFFFE;
+
+static std::string CreateLocalId(const std::string& remote_id) {
+ std::string local_id;
+ do {
+ talk_base::CreateRandomString(32, &local_id);
+ ASSERT(!local_id.empty());
+ } while (local_id == remote_id);
+ return local_id;
+}
+
+RoapSession::RoapSession()
+ : seq_(0),
+ waiting_for_answer_(false),
+ received_seq_(0) {
+}
+
+std::string RoapSession::CreateOffer(
+ const SessionDescription* desc,
+ const std::vector<Candidate>& candidates) {
+ if (local_id_.empty()) {
+ local_id_ = CreateLocalId(remote_id_);
+ }
+
+ do {
+ local_tie_breaker_ = talk_base::CreateRandomNonZeroId();
+ } while (local_tie_breaker_ > kMaxTieBreaker);
+
+ RoapOffer offer(local_id_, remote_id_, session_token_, ++seq_,
+ local_tie_breaker_, desc, candidates);
+ waiting_for_answer_ = true;
+ return offer.Serialize();
+}
+
+std::string RoapSession::CreateAnswer(
+ const SessionDescription* desc,
+ const std::vector<Candidate>& candidates) {
+ ASSERT(!remote_id_.empty());
+ if (local_id_.empty()) {
+ local_id_ = CreateLocalId(remote_id_);
+ }
+
+ RoapAnswer answer(remote_id_, local_id_, session_token_, response_token_,
+ seq_, desc, candidates);
+ response_token_.clear();
+ return answer.Serialize();
+}
+
+std::string RoapSession::CreateOk() {
+ ASSERT(!remote_id_.empty());
+
+ if (local_id_.empty()) {
+ local_id_ = CreateLocalId(remote_id_);
+ }
+ RoapOk ok(remote_id_, local_id_, session_token_, response_token_, seq_);
+ response_token_.clear();
+ return ok.Serialize();
+}
+
+std::string RoapSession::CreateShutDown() {
+ if (local_id_.empty()) {
+ local_id_ = CreateLocalId(remote_id_);
+ }
+ RoapShutdown shutdown(local_id_, remote_id_, session_token_, ++seq_);
+ return shutdown.Serialize();
+}
+
+std::string RoapSession::CreateErrorMessage(RoapErrorCode error) {
+ if (local_id_.empty()) {
+ local_id_ = CreateLocalId(remote_id_);
+ }
+
+ RoapError message(received_offer_id_, local_id_, session_token_,
+ response_token_, received_seq_, error);
+ response_token_.clear();
+ return message.Serialize();
+}
+
+RoapSession::ParseResult RoapSession::Parse(
+ const std::string& msg) {
+ RoapMessageBase message;
+ if (!message.Parse(msg)) {
+ LOG(LS_ERROR) << "Parse failed. Invalid Roap message?";
+ return kInvalidMessage;
+ }
+
+ received_offer_id_ = message.offer_session_id();
+ received_answer_id_ = message.answer_session_id();
+ received_seq_ = message.seq();
+ session_token_ = message.session_token();
+ response_token_ = message.response_token();
+ ParseResult result = kInvalidMessage;
+
+ switch (message.type()) {
+ case RoapMessageBase::kOffer: {
+ RoapOffer offer(message);
+ if (!offer.Parse()) {
+ LOG(LS_ERROR) << "Parse failed. Invalid Offer message?";
+ return kInvalidMessage;
+ }
+ result = ValidateOffer(&offer);
+ break;
+ }
+ case RoapMessageBase::kAnswer: {
+ RoapAnswer answer(message);
+ if (!answer.Parse()) {
+ LOG(LS_ERROR) << "Parse failed. Invalid Answer message?";
+ result = kInvalidMessage;
+ } else {
+ result = ValidateAnswer(&answer);
+ }
+ break;
+ }
+ case RoapMessageBase::kOk: {
+ result = ValidateOk(message);
+ break;
+ }
+ case RoapMessageBase::kShutdown: {
+ // Always accept shutdown messages.
+ if (remote_id_.empty()) {
+ remote_id_ = message.offer_session_id();
+ }
+ seq_ = message.seq();
+ result = kShutDown;
+ break;
+ }
+ case RoapMessageBase::kError: {
+ RoapError error(message);
+ if (!error.Parse()) {
+ LOG(LS_ERROR) << "Parse failed. Invalid Error message?";
+ result = kInvalidMessage;
+ } else if (ValidateError(error) == kError) {
+ result = kError;
+ } // else ignore this error message.
+ break;
+ }
+ default: {
+ ASSERT(!"Unknown message type.");
+ LOG(LS_ERROR) << "Received unknown message.";
+ result = kInvalidMessage;
+ break;
+ }
+ }
+ return result;
+}
+
+RoapSession::ParseResult RoapSession::ValidateOffer(
+ RoapOffer* received_offer) {
+
+ /* Check if the incoming OFFER has a answererSessionId, if not it is
+ an initial offer. If the outstanding OFFER also is an initial
+ OFFER there is an Error. */
+ if (received_offer->answer_session_id().empty() &&
+ remote_id_.empty() && waiting_for_answer_) {
+ return kInvalidMessage;
+ }
+
+ if (remote_id_.empty()) {
+ remote_id_ = received_offer->offer_session_id();
+ }
+
+ // Check the message belong to this session.
+ bool result =
+ received_offer->offer_session_id() == remote_id_ &&
+ received_offer->answer_session_id() == local_id_;
+
+ if (!result || received_offer->seq() < seq_) {
+ return kInvalidMessage; // Old seq.
+ }
+
+ if (waiting_for_answer_) {
+ if (received_offer->seq() != seq_) {
+ return kInvalidMessage;
+ }
+ // Glare.
+ if (received_offer->tie_breaker() < local_tie_breaker_) {
+ return kConflict;
+ } else if (received_offer->tie_breaker() == local_tie_breaker_) {
+ return kDoubleConflict;
+ }
+ }
+ // seq ok or remote offer won the glare resolution.
+ seq_ = received_offer->seq();
+ remote_desc_.reset(received_offer->ReleaseSessionDescription());
+ remote_candidates_ = received_offer->candidates();
+ return kOffer;
+}
+
+RoapSession::ParseResult RoapSession::ValidateAnswer(
+ RoapAnswer* received_answer) {
+ if (remote_id_.empty()) {
+ remote_id_ = received_answer->answer_session_id();
+ }
+ bool result =
+ received_answer->offer_session_id() == local_id_ &&
+ received_answer->seq() == seq_ &&
+ received_answer->answer_session_id() == remote_id_;
+ if (!result) {
+ return kInvalidMessage;
+ }
+
+ remote_desc_.reset(received_answer->ReleaseSessionDescription());
+ remote_candidates_ = received_answer->candidates();
+ if (received_answer->more_coming()) {
+ return kAnswerMoreComing;
+ }
+ waiting_for_answer_ = false;
+ return kAnswer;
+}
+
+RoapSession::ParseResult RoapSession::ValidateOk(
+ const RoapMessageBase& message) {
+ if (remote_id_.empty()) {
+ remote_id_ = message.answer_session_id();
+ }
+ bool result =
+ message.offer_session_id() == local_id_ &&
+ message.seq() == seq_ &&
+ message.answer_session_id() == remote_id_;
+ if (!result) {
+ return kInvalidMessage;
+ }
+ return kOk;
+}
+
+RoapSession::ParseResult RoapSession::ValidateError(
+ const RoapError& message) {
+ bool result =
+ message.offer_session_id() == local_id_ && message.seq() == seq_;
+
+ if (!result) {
+ return kInvalidMessage;
+ }
+ waiting_for_answer_ = false;
+ remote_error_ = message.error();
+ return kError;
+}
+
+SessionDescription* RoapSession::ReleaseRemoteDescription() {
+ return remote_desc_.release();
+}
+
+const std::vector<Candidate>& RoapSession::RemoteCandidates() {
+ return remote_candidates_;
+}
+
+RoapErrorCode RoapSession::RemoteError() {
+ return remote_error_;
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/roapsession.h b/talk/app/webrtc/roapsession.h
new file mode 100644
index 0000000..7a0c27f
--- /dev/null
+++ b/talk/app/webrtc/roapsession.h
@@ -0,0 +1,121 @@
+/*
+ * 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 a class used for creating and parsing ROAP messages
+// as defined in http://tools.ietf.org/html/draft-jennings-rtcweb-signaling-01.
+// The RoapSession is responsible for keeping track of ROAP specific
+// attributes such as offerSessionId etc of a single session but not the logic
+// for when to create a specific message.
+
+#ifndef TALK_APP_WEBRTC_ROAPSESSION_H_
+#define TALK_APP_WEBRTC_ROAPSESSION_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/app/webrtc/roaperrorcodes.h"
+#include "talk/base/basictypes.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/p2p/base/candidate.h"
+#include "talk/p2p/base/sessiondescription.h"
+
+namespace webrtc {
+
+using cricket::Candidate;
+using cricket::SessionDescription;
+
+class RoapAnswer;
+class RoapError;
+class RoapMessageBase;
+class RoapOffer;
+
+class RoapSession {
+ public:
+ // ParseResult is the result of parsing a message.
+ // It can be either an identified message type or a detected error.
+ enum ParseResult {
+ kOffer,
+ kAnswerMoreComing, // More coming flag set. The SDP contains candidates.
+ kAnswer,
+ kOk,
+ kShutDown,
+ kError,
+ // The messages below is errors that can occur during parsing.
+ kConflict, // Conflict detected during parsing of offer.
+ kDoubleConflict, // Double conflict detected during parsing of offer.
+ kInvalidMessage // The parsed message is invalid.
+ };
+
+ RoapSession();
+
+ // Creates a ROAP offer message based on the provided session description and
+ // candidates. This will update states in the ROAP sessions variables such as
+ // sequence number and create a local session id.
+ std::string CreateOffer(const SessionDescription* desc,
+ const std::vector<Candidate>& candidates);
+
+ // Creates a ROAP answer message based on the provided session description and
+ // candidates. An offer must have been parsed before this function can be
+ // called.
+ std::string CreateAnswer(const SessionDescription* desc,
+ const std::vector<Candidate>& candidates);
+ std::string CreateOk();
+ std::string CreateShutDown();
+ std::string CreateErrorMessage(RoapErrorCode error);
+ ParseResult Parse(const std::string& msg);
+ RoapErrorCode RemoteError();
+ // Get remote SessionDescription. The ownership is transferred to the caller.
+ SessionDescription* ReleaseRemoteDescription();
+ const std::vector<Candidate>& RemoteCandidates();
+
+ private:
+ ParseResult ValidateOffer(RoapOffer* received_offer);
+ ParseResult ValidateAnswer(RoapAnswer* received_answer);
+ ParseResult ValidateOk(const RoapMessageBase& message);
+ ParseResult ValidateError(const RoapError& message);
+
+ uint32 seq_; // Sequence number of current message exchange.
+ std::string local_id_; // offererSessionId / answerSessionId of local peer.
+ std::string remote_id_; // offererSessionId / answerSessionId of remote peer.
+ uint32 local_tie_breaker_; // tieBreaker of last sent offer.
+ bool waiting_for_answer_;
+
+ std::string received_offer_id_; // offererSessionId in last received message.
+ std::string received_answer_id_; // answerSessionId in last received message.
+ uint32 received_seq_; // Sequence number of last received message.
+ std::string session_token_;
+ std::string response_token_;
+
+ talk_base::scoped_ptr<SessionDescription> remote_desc_;
+ std::vector<Candidate> remote_candidates_;
+
+ RoapErrorCode remote_error_;
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_ROAPSESSION_H_
diff --git a/talk/app/webrtc/roapsession_unittest.cc b/talk/app/webrtc/roapsession_unittest.cc
new file mode 100644
index 0000000..33cb7ab
--- /dev/null
+++ b/talk/app/webrtc/roapsession_unittest.cc
@@ -0,0 +1,350 @@
+/*
+ * 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 "talk/app/webrtc/roapmessages.h"
+#include "talk/app/webrtc/roapsession.h"
+#include "talk/base/gunit.h"
+#include "talk/base/logging.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/p2p/base/transport.h"
+#include "talk/session/phone/mediasession.h"
+
+using cricket::AudioContentDescription;
+using cricket::Candidates;
+using cricket::ContentInfo;
+using cricket::SessionDescription;
+using cricket::VideoContentDescription;
+using webrtc::RoapMessageBase;
+using webrtc::RoapSession;
+using webrtc::RoapOffer;
+
+// MediaStream 1
+static const char kStreamLabel1[] = "local_stream_1";
+static const char kStream1Cname[] = "stream_1_cname";
+static const char kAudioTrackLabel1[] = "local_audio_1";
+static const uint32 kAudioTrack1Ssrc = 1;
+static const char kVideoTrackLabel1[] = "local_video_1";
+static const uint32 kVideoTrack1Ssrc = 2;
+static const char kVideoTrackLabel2[] = "local_video_2";
+static const uint32 kVideoTrack2Ssrc = 3;
+
+// MediaStream 2
+static const char kStreamLabel2[] = "local_stream_2";
+static const char kStream2Cname[] = "stream_2_cname";
+static const char kAudioTrackLabel2[] = "local_audio_2";
+static const uint32 kAudioTrack2Ssrc = 4;
+static const char kVideoTrackLabel3[] = "local_video_3";
+static const uint32 kVideoTrack3Ssrc = 5;
+
+class RoapSessionTest: public testing::Test {
+ public:
+ void SetUp() {
+ talk_base::scoped_ptr<AudioContentDescription> audio(
+ new AudioContentDescription());
+ audio->set_rtcp_mux(true);
+ cricket::StreamParams audio_stream1;
+ audio_stream1.name = kAudioTrackLabel1;
+ audio_stream1.cname = kStream1Cname;
+ audio_stream1.sync_label = kStreamLabel1;
+ audio_stream1.ssrcs.push_back(kAudioTrack1Ssrc);
+ audio->AddStream(audio_stream1);
+ desc1_.AddContent(cricket::CN_AUDIO, cricket::NS_JINGLE_RTP,
+ audio.release());
+
+ talk_base::scoped_ptr<VideoContentDescription> video(
+ new VideoContentDescription());
+
+ cricket::StreamParams video_stream1;
+ video_stream1.name = kVideoTrackLabel1;
+ video_stream1.cname = kStream1Cname;
+ video_stream1.sync_label = kStreamLabel1;
+ video_stream1.ssrcs.push_back(kVideoTrack1Ssrc);
+ video->AddStream(video_stream1);
+
+ cricket::StreamParams video_stream2;
+ video_stream2.name = kVideoTrackLabel2;
+ video_stream2.cname = kStream1Cname;
+ video_stream2.sync_label = kStreamLabel1;
+ video_stream2.ssrcs.push_back(kVideoTrack2Ssrc);
+ video->AddStream(video_stream2);
+ desc1_.AddContent(cricket::CN_VIDEO, cricket::NS_JINGLE_RTP,
+ video.release());
+
+ audio.reset(new AudioContentDescription());
+ audio->set_rtcp_mux(true);
+ cricket::StreamParams audio_stream2;
+ audio_stream2.name = kAudioTrackLabel2;
+ audio_stream2.cname = kStream2Cname;
+ audio_stream2.sync_label = kStreamLabel2;
+ audio_stream2.ssrcs.push_back(kAudioTrack2Ssrc);
+ audio->AddStream(audio_stream2);
+ desc2_.AddContent(cricket::CN_AUDIO, cricket::NS_JINGLE_RTP,
+ audio.release());
+
+ video.reset(new VideoContentDescription());
+ cricket::StreamParams video_stream3;
+ video_stream3.name = kVideoTrackLabel3;
+ video_stream3.cname = kStream2Cname;
+ video_stream3.sync_label = kStreamLabel2;
+ video_stream3.ssrcs.push_back(kVideoTrack3Ssrc);
+ video->AddStream(video_stream3);
+ desc2_.AddContent(cricket::CN_VIDEO, cricket::NS_JINGLE_RTP,
+ video.release());
+
+ int port = 1234;
+ talk_base::SocketAddress address("127.0.0.1", port++);
+ cricket::Candidate candidate1("video_rtcp", "udp", address, 1,
+ "user_video_rtcp", "password_video_rtcp", "local", "eth0", 0);
+ address.SetPort(port++);
+ cricket::Candidate candidate2("video_rtp", "udp", address, 1,
+ "user_video_rtp", "password_video_rtp", "local", "eth0", 0);
+ address.SetPort(port++);
+ cricket::Candidate candidate3("rtp", "udp", address, 1,
+ "user_rtp", "password_rtp", "local", "eth0", 0);
+ address.SetPort(port++);
+ cricket::Candidate candidate4("rtcp", "udp", address, 1,
+ "user_rtcp", "password_rtcp", "local", "eth0", 0);
+
+ candidates_.push_back(candidate1);
+ candidates_.push_back(candidate2);
+ candidates_.push_back(candidate3);
+ candidates_.push_back(candidate4);
+ }
+
+ bool CompareSessionDescription(const SessionDescription* desc1,
+ const SessionDescription* desc2) {
+ const ContentInfo* audio_1 = desc1->GetContentByName("audio");
+ const AudioContentDescription* audio_desc_1 =
+ static_cast<const AudioContentDescription*>(audio_1->description);
+ const ContentInfo* video_1 = desc1->GetContentByName("video");
+ const VideoContentDescription* video_desc_1 =
+ static_cast<const VideoContentDescription*>(video_1->description);
+
+ const ContentInfo* audio_2 = desc2->GetContentByName("audio");
+ const AudioContentDescription* audio_desc_2 =
+ static_cast<const AudioContentDescription*>(audio_2->description);
+ const ContentInfo* video_2 = desc2->GetContentByName("video");
+ const VideoContentDescription* video_desc_2 =
+ static_cast<const VideoContentDescription*>(video_2->description);
+
+ // Check that all streams are equal. We only check that the number of
+ // codecs are the same and leave it for other unit tests to test
+ // parsing / serialization of the session description.
+ return audio_desc_1->codecs().size() == audio_desc_2->codecs().size() &&
+ audio_desc_1->streams() == audio_desc_2->streams() &&
+ video_desc_1->codecs().size() == video_desc_2->codecs().size() &&
+ video_desc_1->streams() == video_desc_2->streams();
+ }
+
+ bool CompareCandidates(const Candidates& c1, const Candidates& c2) {
+ if (c1.size() != c2.size())
+ return false;
+
+ Candidates::const_iterator it1 = c1.begin();
+ for (; it1 != c1.end(); ++it1) {
+ // It is ok if the order in the vector have changed.
+ Candidates::const_iterator it2 = c2.begin();
+ for (; it2 != c2.end(); ++it2) {
+ if (it1->IsEquivalent(*it2)) {
+ break;
+ }
+ }
+ if (it2 == c2.end())
+ return false;
+ }
+ return true;
+ }
+
+ protected:
+ cricket::SessionDescription desc1_;
+ cricket::SessionDescription desc2_;
+ cricket::Candidates candidates_;
+};
+
+TEST_F(RoapSessionTest, OfferAnswer) {
+ RoapSession roap_session1;
+ RoapSession roap_session2;
+
+ std::string offer_message = roap_session1.CreateOffer(&desc1_, candidates_);
+
+ // Check that it is valid to send to another peer.
+ EXPECT_EQ(RoapSession::kOffer, roap_session2.Parse(offer_message));
+ talk_base::scoped_ptr<const cricket::SessionDescription> received_offer(
+ roap_session2.ReleaseRemoteDescription());
+
+ ASSERT_TRUE(received_offer.get() != NULL);
+ EXPECT_TRUE(CompareSessionDescription(&desc1_, received_offer.get()));
+ EXPECT_TRUE(CompareCandidates(candidates_, roap_session2.RemoteCandidates()));
+
+ std::string answer_message = roap_session2.CreateAnswer(&desc2_, candidates_);
+
+ EXPECT_EQ(RoapSession::kAnswer, roap_session1.Parse(answer_message));
+ talk_base::scoped_ptr<const cricket::SessionDescription> received_answer(
+ roap_session1.ReleaseRemoteDescription());
+
+ EXPECT_TRUE(CompareSessionDescription(&desc2_, received_answer.get()));
+ EXPECT_FALSE(CompareSessionDescription(received_offer.get(),
+ received_answer.get()));
+ EXPECT_TRUE(CompareCandidates(candidates_, roap_session1.RemoteCandidates()));
+}
+
+TEST_F(RoapSessionTest, InvalidInitialization) {
+ RoapSession roap_session1;
+ RoapSession roap_session2;
+
+ std::string offer_message1 = roap_session1.CreateOffer(&desc1_, candidates_);
+ std::string offer_message2 = roap_session2.CreateOffer(&desc2_, candidates_);
+
+ // It is an error to receive an initial offer if you have sent an
+ // initial offer.
+ EXPECT_EQ(RoapSession::kInvalidMessage,
+ roap_session1.Parse(offer_message2));
+
+ EXPECT_EQ(RoapSession::kInvalidMessage,
+ roap_session2.Parse(offer_message1));
+}
+
+TEST_F(RoapSessionTest, Glare) {
+ RoapSession roap_session1;
+ RoapSession roap_session2;
+
+ // Setup. Need to exchange an offer and an answer in order to test for glare.
+ std::string offer_message1 = roap_session1.CreateOffer(&desc1_, candidates_);
+
+ roap_session2.Parse(offer_message1);
+ talk_base::scoped_ptr<const SessionDescription> received_offer(
+ roap_session2.ReleaseRemoteDescription());
+ std::string answer_message2 = roap_session2.CreateAnswer(&desc2_,
+ candidates_);
+ roap_session1.Parse(answer_message2);
+
+ // Ok- we should now have all we need. Create a glare condition by
+ // updating the offer simultaneously.
+ offer_message1 = roap_session1.CreateOffer(&desc2_, candidates_);
+ std::string offer_message2 = roap_session2.CreateOffer(&desc1_, candidates_);
+
+ EXPECT_TRUE(
+ (RoapSession::kOffer == roap_session1.Parse(offer_message2) &&
+ RoapSession::kConflict == roap_session2.Parse(offer_message1)) ||
+ (RoapSession::kOffer == roap_session2.Parse(offer_message1) &&
+ RoapSession::kConflict == roap_session1.Parse(offer_message2)));
+}
+
+// Test Glare resolution by setting different TieBreakers.
+TEST_F(RoapSessionTest, TieBreaker) {
+ RoapSession roap_session1;
+ RoapSession roap_session2;
+
+ // Offer 1
+ std::string offer_message1 = roap_session1.CreateOffer(&desc1_, candidates_);
+
+ EXPECT_EQ(RoapSession::kOffer, roap_session2.Parse(offer_message1));
+ talk_base::scoped_ptr<const SessionDescription> received_offer(
+ roap_session2.ReleaseRemoteDescription());
+ std::string answer_message2 = roap_session2.CreateAnswer(&desc2_,
+ candidates_);
+
+ EXPECT_EQ(RoapSession::kAnswer, roap_session1.Parse(answer_message2));
+
+ // Ok- we should now have all we need. Create a double conflict condition.
+ offer_message1 = roap_session1.CreateOffer(&desc2_, candidates_);
+ RoapMessageBase message_base;
+ EXPECT_TRUE(message_base.Parse(offer_message1));
+ RoapOffer message_offer(message_base);
+ EXPECT_TRUE(message_offer.Parse());
+ RoapOffer double_conflict_offer(message_offer.answer_session_id(),
+ message_offer.offer_session_id(),
+ "",
+ message_offer.seq(),
+ message_offer.tie_breaker(),
+ &desc1_,
+ candidates_);
+ EXPECT_EQ(RoapSession::kDoubleConflict,
+ roap_session1.Parse(double_conflict_offer.Serialize()));
+
+ RoapOffer losing_offer(message_offer.answer_session_id(),
+ message_offer.offer_session_id(),
+ "",
+ message_offer.seq(),
+ 0,
+ &desc1_,
+ candidates_);
+ EXPECT_EQ(RoapSession::kConflict,
+ roap_session1.Parse(losing_offer.Serialize()));
+
+ RoapOffer winning_offer(message_offer.answer_session_id(),
+ message_offer.offer_session_id(),
+ "",
+ message_offer.seq(),
+ 0xFFFFFFFF,
+ &desc1_,
+ candidates_);
+ EXPECT_EQ(RoapSession::kOffer,
+ roap_session1.Parse(winning_offer.Serialize()));
+}
+
+TEST_F(RoapSessionTest, ShutDownOk) {
+ RoapSession roap_session1;
+ std::string shutdown = roap_session1.CreateShutDown();
+
+ RoapSession roap_session2;
+ EXPECT_EQ(RoapSession::kShutDown, roap_session2.Parse(shutdown));
+
+ std::string ok_message = roap_session2.CreateOk();
+ EXPECT_EQ(RoapSession::kOk, roap_session1.Parse(ok_message));
+}
+
+TEST_F(RoapSessionTest, ErrorMessageCreation) {
+ RoapSession roap_session1;
+ RoapSession roap_session2;
+
+ std::string message = roap_session1.CreateErrorMessage(webrtc::kNoMatch);
+ EXPECT_EQ(RoapSession::kError, roap_session2.Parse(message));
+ EXPECT_EQ(webrtc::kNoMatch, roap_session2.RemoteError());
+
+ message = roap_session1.CreateErrorMessage(webrtc::kTimeout);
+ EXPECT_EQ(RoapSession::kError, roap_session2.Parse(message));
+ EXPECT_EQ(webrtc::kTimeout, roap_session2.RemoteError());
+
+ message = roap_session1.CreateErrorMessage(webrtc::kRefused);
+ EXPECT_EQ(RoapSession::kError, roap_session2.Parse(message));
+ EXPECT_EQ(webrtc::kRefused, roap_session2.RemoteError());
+
+ message = roap_session1.CreateErrorMessage(webrtc::kConflict);
+ EXPECT_EQ(RoapSession::kError, roap_session2.Parse(message));
+ EXPECT_EQ(webrtc::kConflict, roap_session2.RemoteError());
+
+ message = roap_session1.CreateErrorMessage(webrtc::kDoubleConflict);
+ EXPECT_EQ(RoapSession::kError, roap_session2.Parse(message));
+ EXPECT_EQ(webrtc::kDoubleConflict, roap_session2.RemoteError());
+
+ message = roap_session1.CreateErrorMessage(webrtc::kFailed);
+ EXPECT_EQ(RoapSession::kError, roap_session2.Parse(message));
+ EXPECT_EQ(webrtc::kFailed, roap_session2.RemoteError());
+}
diff --git a/talk/app/webrtc/sessiondescriptionprovider.h b/talk/app/webrtc/sessiondescriptionprovider.h
new file mode 100644
index 0000000..7142cdd
--- /dev/null
+++ b/talk/app/webrtc/sessiondescriptionprovider.h
@@ -0,0 +1,72 @@
+/*
+ * 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_SESSIONDESCRIPTIONPROVIDER_H_
+#define TALK_APP_WEBRTC_SESSIONDESCRIPTIONPROVIDER_H_
+
+#include "talk/session/phone/mediasession.h"
+#include "talk/p2p/base/candidate.h"
+#include "talk/p2p/base/sessiondescription.h"
+
+namespace webrtc {
+
+class SessionDescriptionProvider {
+ public:
+ // Creates a new SessionDescription based on |options|.
+ // It does not affect the currently set local or remote SessionDescription.
+ // Caller is owner of the created SessionDescription.
+ virtual cricket::SessionDescription* CreateOffer(
+ const cricket::MediaSessionOptions& options) = 0;
+
+ // Creates a new SessionDescription based on |offer| and |options|.
+ // It does not affect the currently set local or remote SessionDescription.
+ // Caller is owner of the created SessionDescription.
+ virtual cricket::SessionDescription* CreateAnswer(
+ const cricket::SessionDescription* offer,
+ const cricket::MediaSessionOptions& options) = 0;
+
+ // Transfers ownership of session description.
+ virtual void SetLocalDescription(const cricket::SessionDescription* desc,
+ cricket::ContentAction type) = 0;
+ virtual void SetRemoteDescription(cricket::SessionDescription* desc,
+ cricket::ContentAction type) = 0;
+ // Sets all the currently known remote candidates.
+ virtual void SetRemoteCandidates(
+ const std::vector<cricket::Candidate>& remote_candidates) = 0;
+
+ // Current local session description.
+ virtual const cricket::SessionDescription* local_description() const = 0;
+ // Current remote session description.
+ virtual const cricket::SessionDescription* remote_description() const = 0;
+
+ protected:
+ virtual ~SessionDescriptionProvider() {}
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_SESSIONDESCRIPTIONPROVIDER_H_
diff --git a/talk/app/webrtc/streamcollectionimpl.h b/talk/app/webrtc/streamcollectionimpl.h
new file mode 100644
index 0000000..76df3fd
--- /dev/null
+++ b/talk/app/webrtc/streamcollectionimpl.h
@@ -0,0 +1,103 @@
+/*
+ * 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_STREAMCOLLECTIONIMPL_H_
+#define TALK_APP_WEBRTC_STREAMCOLLECTIONIMPL_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/app/webrtc/peerconnection.h"
+
+namespace webrtc {
+
+// Implementation of StreamCollection.
+class StreamCollection : public StreamCollectionInterface {
+ public:
+ static talk_base::scoped_refptr<StreamCollection> Create() {
+ talk_base::RefCountedObject<StreamCollection>* implementation =
+ new talk_base::RefCountedObject<StreamCollection>();
+ return implementation;
+ }
+
+ static talk_base::scoped_refptr<StreamCollection> Create(
+ StreamCollection* streams) {
+ talk_base::RefCountedObject<StreamCollection>* implementation =
+ new talk_base::RefCountedObject<StreamCollection>(streams);
+ return implementation;
+ }
+
+ virtual size_t count() {
+ return media_streams_.size();
+ }
+
+ virtual MediaStreamInterface* at(size_t index) {
+ return media_streams_.at(index);
+ }
+
+ virtual MediaStreamInterface* find(const std::string& label) {
+ for (StreamVector::iterator it = media_streams_.begin();
+ it != media_streams_.end(); ++it) {
+ if ((*it)->label().compare(label) == 0) {
+ return (*it);
+ }
+ }
+ return NULL;
+ }
+
+ void AddStream(MediaStreamInterface* stream) {
+ for (StreamVector::iterator it = media_streams_.begin();
+ it != media_streams_.end(); ++it) {
+ if ((*it)->label().compare(stream->label()) == 0)
+ return;
+ }
+ media_streams_.push_back(stream);
+ }
+
+ void RemoveStream(MediaStreamInterface* remove_stream) {
+ for (StreamVector::iterator it = media_streams_.begin();
+ it != media_streams_.end(); ++it) {
+ if ((*it)->label().compare(remove_stream->label()) == 0) {
+ media_streams_.erase(it);
+ break;
+ }
+ }
+ }
+
+ protected:
+ StreamCollection() {}
+ explicit StreamCollection(StreamCollection* original)
+ : media_streams_(original->media_streams_) {
+ }
+ typedef std::vector<talk_base::scoped_refptr<MediaStreamInterface> >
+ StreamVector;
+ StreamVector media_streams_;
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_STREAMCOLLECTIONIMPL_H_
diff --git a/talk/app/webrtc/videorendererimpl.cc b/talk/app/webrtc/videorendererimpl.cc
new file mode 100644
index 0000000..6355e4b
--- /dev/null
+++ b/talk/app/webrtc/videorendererimpl.cc
@@ -0,0 +1,58 @@
+/*
+ * libjingle
+ * Copyright 2004--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/mediastreamimpl.h"
+
+#include "talk/session/phone/videorenderer.h"
+
+namespace webrtc {
+
+// VideoRendererImpl take ownership of cricket::VideoRenderer.
+class VideoRendererImpl : public VideoRendererWrapperInterface {
+ public:
+ explicit VideoRendererImpl(cricket::VideoRenderer* renderer)
+ : renderer_(renderer) {
+ }
+ virtual cricket::VideoRenderer* renderer() {
+ return renderer_;
+ }
+ protected:
+ ~VideoRendererImpl() {
+ delete renderer_;
+ }
+ private:
+ cricket::VideoRenderer* renderer_;
+};
+
+talk_base::scoped_refptr<VideoRendererWrapperInterface> CreateVideoRenderer(
+ cricket::VideoRenderer* renderer) {
+ talk_base::RefCountedObject<VideoRendererImpl>* r =
+ new talk_base::RefCountedObject<VideoRendererImpl>(renderer);
+ return r;
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/videotrackimpl.cc b/talk/app/webrtc/videotrackimpl.cc
new file mode 100644
index 0000000..0fb218a
--- /dev/null
+++ b/talk/app/webrtc/videotrackimpl.cc
@@ -0,0 +1,82 @@
+/*
+ * 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/videotrackimpl.h"
+
+#include <string>
+
+#include "talk/session/phone/webrtcvideocapturer.h"
+
+namespace webrtc {
+
+static const char kVideoTrackKind[] = "video";
+
+VideoTrack::VideoTrack(const std::string& label)
+ : MediaStreamTrack<LocalVideoTrackInterface>(label),
+ video_device_(NULL) {
+}
+
+VideoTrack::VideoTrack(const std::string& label,
+ cricket::VideoCapturer* video_device)
+ : MediaStreamTrack<LocalVideoTrackInterface>(label),
+ video_device_(NULL) {
+ video_device_.reset(video_device);
+}
+
+void VideoTrack::SetRenderer(VideoRendererWrapperInterface* renderer) {
+ video_renderer_ = renderer;
+ Notifier<LocalVideoTrackInterface>::FireOnChanged();
+}
+
+VideoRendererWrapperInterface* VideoTrack::GetRenderer() {
+ return video_renderer_.get();
+}
+
+ // Get the VideoCapture device associated with this track.
+cricket::VideoCapturer* VideoTrack::GetVideoCapture() {
+ return video_device_.get();
+}
+
+std::string VideoTrack::kind() const {
+ return kVideoTrackKind;
+}
+
+talk_base::scoped_refptr<VideoTrack> VideoTrack::CreateRemote(
+ const std::string& label) {
+ talk_base::RefCountedObject<VideoTrack>* track =
+ new talk_base::RefCountedObject<VideoTrack>(label);
+ return track;
+}
+
+talk_base::scoped_refptr<VideoTrack> VideoTrack::CreateLocal(
+ const std::string& label,
+ cricket::VideoCapturer* video_device) {
+ talk_base::RefCountedObject<VideoTrack>* track =
+ new talk_base::RefCountedObject<VideoTrack>(label, video_device);
+ return track;
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/videotrackimpl.h b/talk/app/webrtc/videotrackimpl.h
new file mode 100644
index 0000000..de99e6a
--- /dev/null
+++ b/talk/app/webrtc/videotrackimpl.h
@@ -0,0 +1,80 @@
+/*
+ * 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_VIDEOTRACKIMPL_H_
+#define TALK_APP_WEBRTC_VIDEOTRACKIMPL_H_
+
+#include <string>
+
+#include "talk/app/webrtc/mediastream.h"
+#include "talk/app/webrtc/mediatrackimpl.h"
+#include "talk/app/webrtc/notifierimpl.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/scoped_ref_ptr.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 cricket {
+
+class VideoCapturer;
+
+} // namespace cricket
+
+namespace webrtc {
+
+class VideoTrack : public MediaStreamTrack<LocalVideoTrackInterface> {
+ public:
+ // Create a video track used for remote video tracks.
+ static talk_base::scoped_refptr<VideoTrack> CreateRemote(
+ const std::string& label);
+ // Create a video track used for local video tracks.
+ static talk_base::scoped_refptr<VideoTrack> CreateLocal(
+ const std::string& label,
+ cricket::VideoCapturer* video_device);
+
+ virtual cricket::VideoCapturer* GetVideoCapture();
+ virtual void SetRenderer(VideoRendererWrapperInterface* renderer);
+ VideoRendererWrapperInterface* GetRenderer();
+
+ virtual std::string kind() const;
+
+ protected:
+ explicit VideoTrack(const std::string& label);
+ VideoTrack(const std::string& label, cricket::VideoCapturer* video_device);
+
+ private:
+ talk_base::scoped_ptr<cricket::VideoCapturer> video_device_;
+ talk_base::scoped_refptr<VideoRendererWrapperInterface> video_renderer_;
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_VIDEOTRACKIMPL_H_
diff --git a/talk/app/webrtc/webrtc.scons b/talk/app/webrtc/webrtc.scons
index 271d413..88ea3f4 100644
--- a/talk/app/webrtc/webrtc.scons
+++ b/talk/app/webrtc/webrtc.scons
@@ -3,58 +3,68 @@
Import('env')
-# local sources
-talk.Library(
- env,
- name = 'webrtc',
- srcs = [
- 'peerconnectionimpl.cc',
- 'peerconnectionproxy.cc',
- 'peerconnectionfactory.cc',
- 'webrtcjson.cc',
- 'webrtcsession.cc',
- ],
-)
+if env.Bit('have_webrtc_voice') and env.Bit('have_webrtc_video'):
+ # local sources
+ talk.Library(
+ env,
+ name = 'peerconnection',
+ srcs = [
+ 'audiotrackimpl.cc',
+ 'mediastreamhandler.cc',
+ 'mediastreamimpl.cc',
+ 'mediastreamproxy.cc',
+ 'mediastreamtrackproxy.cc',
+ 'peerconnectionfactoryimpl.cc',
+ 'peerconnectionimpl.cc',
+ 'peerconnectionsignaling.cc',
+ 'portallocatorfactory.cc',
+ 'roapmessages.cc',
+ 'roapsession.cc',
+ 'videorendererimpl.cc',
+ 'videotrackimpl.cc',
+ 'webrtcsdp.cc',
+ 'webrtcsession.cc',
+ ],
+ )
-talk.Unittest(
- env,
- name = 'webrtc',
- srcs = [
- 'peerconnection_unittest.cc',
- 'unittest_utilities.cc',
- 'webrtcsession_unittest.cc',
- ],
- libs = [
- 'base',
- 'expat',
- 'jpeg',
- 'json',
- 'webrtc',
- 'p2p',
- 'phone',
- 'srtp',
- 'xmpp',
- 'xmllite',
- 'yuvscaler'
- ],
- include_talk_media_libs = True,
- mac_libs = [
- 'crypto',
- 'ssl',
- ],
- mac_FRAMEWORKS = [
- 'Foundation',
- 'IOKit',
- 'QTKit',
- ],
- win_link_flags = [('', '/nodefaultlib:libcmt')[env.Bit('debug')]],
- lin_libs = [
- 'rt',
- 'dl',
- 'sound',
- 'X11',
- 'Xext',
- 'Xfixes',
- 'Xrandr'
- ],
-)
+ talk.Unittest(
+ env,
+ name = 'peerconnection',
+ srcs = [
+ 'test/fakevideocapturemodule.cc',
+ 'test/fileframesource.cc',
+ 'test/i420framesource.cc',
+ 'test/staticframesource.cc',
+ 'mediastream_unittest.cc',
+ 'mediastreamhandler_unittest.cc',
+ 'peerconnectionimpl_unittest.cc',
+ 'peerconnection_unittest.cc',
+ 'peerconnectionfactory_unittest.cc',
+ 'peerconnectionsignaling_unittest.cc',
+ 'roapmessages_unittest.cc',
+ 'roapsession_unittest.cc',
+ 'webrtcsdp_unittest.cc',
+ 'webrtcsession_unittest.cc',
+ ],
+ libs = [
+ 'base',
+ 'expat',
+ 'jpeg',
+ 'json',
+ 'p2p',
+ 'phone',
+ 'srtp',
+ 'xmllite',
+ 'xmpp',
+ 'yuvscaler',
+ 'peerconnection',
+ ],
+ win_link_flags = [('', '/nodefaultlib:libcmt')[env.Bit('debug')]],
+ lin_libs = [
+ 'sound',
+ ],
+ mac_libs = [
+ 'crypto',
+ 'ssl',
+ ],
+ )
diff --git a/talk/app/webrtc/webrtcjson.cc b/talk/app/webrtc/webrtcjson.cc
index 1662e23..2aaac97 100644
--- a/talk/app/webrtc/webrtcjson.cc
+++ b/talk/app/webrtc/webrtcjson.cc
@@ -1,6 +1,6 @@
/*
* libjingle
- * Copyright 2004--2011, Google Inc.
+ * 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:
@@ -29,94 +29,161 @@
#include <stdio.h>
#include <string>
+#include <vector>
#include "talk/base/json.h"
#include "talk/base/logging.h"
#include "talk/base/stringutils.h"
#include "talk/session/phone/codec.h"
+#include "talk/session/phone/cryptoparams.h"
+#include "talk/session/phone/mediasession.h"
#include "talk/session/phone/mediasessionclient.h"
namespace webrtc {
static const int kIceComponent = 1;
static const int kIceFoundation = 1;
-bool GetJsonSignalingMessage(
+static std::vector<Json::Value> ReadValues(const Json::Value& value,
+ const std::string& key);
+
+static void BuildContent(
const cricket::SessionDescription* sdp,
- const std::vector<cricket::Candidate>& candidates,
- std::string* signaling_message) {
- const cricket::ContentInfo* audio_content = GetFirstAudioContent(sdp);
- const cricket::ContentInfo* video_content = GetFirstVideoContent(sdp);
-
- std::vector<Json::Value> media;
- if (audio_content) {
- Json::Value value;
- BuildMediaMessage(*audio_content, candidates, false, &value);
- media.push_back(value);
- }
-
- if (video_content) {
- Json::Value value;
- BuildMediaMessage(*video_content, candidates, true, &value);
- media.push_back(value);
- }
-
- Json::Value signal;
- Append(&signal, "media", media);
-
- // Now serialize.
- *signaling_message = Serialize(signal);
-
- return true;
-}
-
-bool BuildMediaMessage(
const cricket::ContentInfo& content_info,
const std::vector<cricket::Candidate>& candidates,
bool video,
- Json::Value* params) {
+ Json::Value* content);
+
+static void BuildCandidate(const std::vector<cricket::Candidate>& candidates,
+ bool video,
+ std::vector<Json::Value>* jcandidates);
+
+static void BuildRtpMapParams(const cricket::ContentInfo& content_info,
+ bool video,
+ std::vector<Json::Value>* rtpmap);
+
+static void BuildCrypto(const cricket::ContentInfo& content_info,
+ bool video,
+ std::vector<Json::Value>* cryptos);
+
+static void BuildTrack(const cricket::SessionDescription* sdp,
+ bool video,
+ std::vector<Json::Value>* track);
+
+bool ParseContent(const Json::Value& jmessage,
+ cricket::SessionDescription* sdp,
+ std::vector<cricket::Candidate>* candidates);
+
+static bool ParseAudioCodec(const Json::Value& value,
+ cricket::AudioContentDescription* content);
+static bool ParseVideoCodec(const Json::Value& value,
+ cricket::VideoContentDescription* content);
+static bool ParseCrypto(const Json::Value& content,
+ cricket::MediaContentDescription* desc);
+
+static bool ParseCandidates(const Json::Value& content,
+ std::vector<cricket::Candidate>* candidates);
+
+static bool ParseTrack(const Json::Value& content,
+ cricket::MediaContentDescription* content_desc);
+
+static void Append(Json::Value* object, const std::string& key, bool value);
+static void Append(Json::Value* object, const std::string& key,
+ const char* value);
+static void Append(Json::Value* object, const std::string& key, int value);
+static void Append(Json::Value* object, const std::string& key,
+ const std::string& value);
+static void Append(Json::Value* object, const std::string& key, uint32 value);
+static void Append(Json::Value* object, const std::string& key,
+ const Json::Value& value);
+static void Append(Json::Value* object,
+ const std::string& key,
+ const std::vector<Json::Value>& values);
+
+void JsonSerializeSessionDescription(
+ const cricket::SessionDescription* sdp,
+ const std::vector<cricket::Candidate>& candidates,
+ Json::Value* message) {
+
+ const cricket::ContentInfo* audio_content = GetFirstAudioContent(sdp);
+ const cricket::ContentInfo* video_content = GetFirstVideoContent(sdp);
+
+ std::vector<Json::Value> together;
+ together.push_back("audio");
+ together.push_back("video");
+
+ std::vector<Json::Value> contents;
+
+ if (audio_content) {
+ Json::Value content;
+ BuildContent(sdp, *audio_content, candidates, false, &content);
+ contents.push_back(content);
+ }
+
+ if (video_content) {
+ Json::Value content;
+ BuildContent(sdp, *video_content, candidates, true, &content);
+ contents.push_back(content);
+ }
+
+ Append(message, "content", contents);
+ Append(message, "TOGETHER", together);
+}
+
+void BuildContent(
+ const cricket::SessionDescription* sdp,
+ const cricket::ContentInfo& content_info,
+ const std::vector<cricket::Candidate>& candidates,
+ bool video,
+ Json::Value* content) {
+ std::string label("media");
+ // TODO: Use enum instead of bool video to prepare for other
+ // media types such as the data media stream.
if (video) {
- Append(params, "label", 2); // always video 2
+ Append(content, label, "video");
} else {
- Append(params, "label", 1); // always audio 1
+ Append(content, label, "audio");
}
const cricket::MediaContentDescription* media_info =
- static_cast<const cricket::MediaContentDescription*> (
- content_info.description);
+ static_cast<const cricket::MediaContentDescription*> (
+ content_info.description);
if (media_info->rtcp_mux()) {
- Append(params, "rtcp_mux", true);
+ Append(content, "rtcp_mux", true);
}
+ // rtpmap
std::vector<Json::Value> rtpmap;
- if (!BuildRtpMapParams(content_info, video, &rtpmap)) {
- return false;
- }
+ BuildRtpMapParams(content_info, video, &rtpmap);
+ Append(content, "rtpmap", rtpmap);
- Append(params, "rtpmap", rtpmap);
+ // crypto
+ std::vector<Json::Value> crypto;
+ BuildCrypto(content_info, video, &crypto);
+ Append(content, "crypto", crypto);
- Json::Value attributes;
+ // candidate
std::vector<Json::Value> jcandidates;
+ BuildCandidate(candidates, video, &jcandidates);
+ Append(content, "candidate", jcandidates);
- if (!BuildAttributes(candidates, video, &jcandidates)) {
- return false;
- }
- Append(&attributes, "candidate", jcandidates);
- Append(params, "attributes", attributes);
- return true;
+ // track
+ std::vector<Json::Value> track;
+ BuildTrack(sdp, video, &track);
+ Append(content, "track", track);
}
-bool BuildRtpMapParams(const cricket::ContentInfo& content_info,
+void BuildRtpMapParams(const cricket::ContentInfo& content_info,
bool video,
std::vector<Json::Value>* rtpmap) {
if (!video) {
- const cricket::AudioContentDescription* audio_offer =
+ const cricket::AudioContentDescription* audio =
static_cast<const cricket::AudioContentDescription*>(
content_info.description);
std::vector<cricket::AudioCodec>::const_iterator iter =
- audio_offer->codecs().begin();
+ audio->codecs().begin();
std::vector<cricket::AudioCodec>::const_iterator iter_end =
- audio_offer->codecs().end();
+ audio->codecs().end();
for (; iter != iter_end; ++iter) {
Json::Value codec;
std::string codec_str(std::string("audio/").append(iter->name));
@@ -128,14 +195,14 @@
rtpmap->push_back(codec_id);
}
} else {
- const cricket::VideoContentDescription* video_offer =
+ const cricket::VideoContentDescription* video =
static_cast<const cricket::VideoContentDescription*>(
content_info.description);
std::vector<cricket::VideoCodec>::const_iterator iter =
- video_offer->codecs().begin();
+ video->codecs().begin();
std::vector<cricket::VideoCodec>::const_iterator iter_end =
- video_offer->codecs().end();
+ video->codecs().end();
for (; iter != iter_end; ++iter) {
Json::Value codec;
std::string codec_str(std::string("video/").append(iter->name));
@@ -145,12 +212,29 @@
rtpmap->push_back(codec_id);
}
}
- return true;
}
-bool BuildAttributes(const std::vector<cricket::Candidate>& candidates,
- bool video,
- std::vector<Json::Value>* jcandidates) {
+void BuildCrypto(const cricket::ContentInfo& content_info,
+ bool video,
+ std::vector<Json::Value>* cryptos) {
+ const cricket::MediaContentDescription* content_desc =
+ static_cast<const cricket::MediaContentDescription*>(
+ content_info.description);
+ std::vector<cricket::CryptoParams>::const_iterator iter =
+ content_desc->cryptos().begin();
+ std::vector<cricket::CryptoParams>::const_iterator iter_end =
+ content_desc->cryptos().end();
+ for (; iter != iter_end; ++iter) {
+ Json::Value crypto;
+ Append(&crypto, "cipher_suite", iter->cipher_suite);
+ Append(&crypto, "key_params", iter->key_params);
+ cryptos->push_back(crypto);
+ }
+}
+
+void BuildCandidate(const std::vector<cricket::Candidate>& candidates,
+ bool video,
+ std::vector<Json::Value>* jcandidates) {
std::vector<cricket::Candidate>::const_iterator iter =
candidates.begin();
std::vector<cricket::Candidate>::const_iterator iter_end =
@@ -160,95 +244,117 @@
(!iter->name().compare("video_rtp")))) ||
(!video && (!iter->name().compare("rtp") ||
(!iter->name().compare("rtcp"))))) {
- Json::Value candidate;
- Append(&candidate, "component", kIceComponent);
- Append(&candidate, "foundation", kIceFoundation);
- Append(&candidate, "generation", iter->generation());
- Append(&candidate, "proto", iter->protocol());
- Append(&candidate, "priority", iter->preference_str());
- Append(&candidate, "ip", iter->address().IPAsString());
- Append(&candidate, "port", iter->address().PortAsString());
- Append(&candidate, "type", iter->type());
- Append(&candidate, "name", iter->name());
- Append(&candidate, "network_name", iter->network_name());
- Append(&candidate, "username", iter->username());
- Append(&candidate, "password", iter->password());
- jcandidates->push_back(candidate);
+ Json::Value jcandidate;
+ Append(&jcandidate, "component", kIceComponent);
+ Append(&jcandidate, "foundation", kIceFoundation);
+ Append(&jcandidate, "generation", iter->generation());
+ Append(&jcandidate, "proto", iter->protocol());
+ Append(&jcandidate, "priority", iter->preference_str());
+ Append(&jcandidate, "ip", iter->address().IPAsString());
+ Append(&jcandidate, "port", iter->address().PortAsString());
+ Append(&jcandidate, "type", iter->type());
+ Append(&jcandidate, "name", iter->name());
+ Append(&jcandidate, "network_name", iter->network_name());
+ Append(&jcandidate, "username", iter->username());
+ Append(&jcandidate, "password", iter->password());
+ jcandidates->push_back(jcandidate);
}
}
- return true;
}
-std::string Serialize(const Json::Value& value) {
- Json::StyledWriter writer;
- return writer.write(value);
-}
+void BuildTrack(const cricket::SessionDescription* sdp,
+ bool video,
+ std::vector<Json::Value>* tracks) {
+ const cricket::ContentInfo* content;
+ if (video)
+ content = GetFirstVideoContent(sdp);
+ else
+ content = GetFirstAudioContent(sdp);
-bool Deserialize(const std::string& message, Json::Value* value) {
- Json::Reader reader;
- return reader.parse(message, *value);
-}
+ if (!content)
+ return;
-bool ParseJsonSignalingMessage(const std::string& signaling_message,
- cricket::SessionDescription** sdp,
- std::vector<cricket::Candidate>* candidates) {
- ASSERT(!(*sdp)); // expect this to be NULL
- // first deserialize message
- Json::Value value;
- if (!Deserialize(signaling_message, &value)) {
- return false;
+ const cricket::MediaContentDescription* desc =
+ static_cast<const cricket::MediaContentDescription*>(
+ content->description);
+ for (cricket::StreamParamsVec::const_iterator it = desc->streams().begin();
+ it != desc->streams().end();
+ ++it) {
+ // TODO: Support ssrcsgroups.
+ Json::Value track;
+ Append(&track, "ssrc", it->ssrcs[0]);
+ Append(&track, "cname", it->cname);
+ Append(&track, "stream_label", it->sync_label);
+ Append(&track, "label", it->name);
+ tracks->push_back(track);
}
+}
- // get media objects
- std::vector<Json::Value> mlines = ReadValues(value, "media");
- if (mlines.empty()) {
- // no m-lines found
+bool JsonDeserializeSessionDescription(
+ const Json::Value& message,
+ cricket::SessionDescription* sdp,
+ std::vector<cricket::Candidate>* candidates) {
+
+ ASSERT(sdp != NULL);
+ ASSERT(candidates != NULL);
+
+ if (sdp == NULL || candidates == NULL)
return false;
- }
- *sdp = new cricket::SessionDescription();
-
- // get codec information
- for (size_t i = 0; i < mlines.size(); ++i) {
- if (mlines[i]["label"].asInt() == 1) {
+ // Get content
+ std::vector<Json::Value> contents = ReadValues(message, "content");
+ if (contents.size() == 0)
+ return false;
+ for (size_t i = 0; i < contents.size(); ++i) {
+ Json::Value content = contents[i];
+ // candidates
+ if (!ParseCandidates(content, candidates))
+ return false;
+ // rtcp_mux
+ bool rtcp_mux;
+ if (!GetBoolFromJsonObject(content, "rtcp_mux", &rtcp_mux))
+ rtcp_mux = false;
+ // rtpmap
+ if (content["media"].asString().compare("audio") == 0) {
cricket::AudioContentDescription* audio_content =
new cricket::AudioContentDescription();
- ParseAudioCodec(mlines[i], audio_content);
- audio_content->set_rtcp_mux(ParseRtcpMux(mlines[i]));
+ if (!ParseAudioCodec(content, audio_content))
+ return false;
+ audio_content->set_rtcp_mux(rtcp_mux);
audio_content->SortCodecs();
- (*sdp)->AddContent(cricket::CN_AUDIO,
- cricket::NS_JINGLE_RTP, audio_content);
- ParseIceCandidates(mlines[i], candidates);
- } else {
+ // crypto
+ if (!ParseCrypto(content, audio_content))
+ return false;
+ // tracks
+ if (!ParseTrack(content, audio_content))
+ return false;
+ (sdp)->AddContent(cricket::CN_AUDIO,
+ cricket::NS_JINGLE_RTP, audio_content);
+ } else if (content["media"].asString().compare("video") == 0) {
cricket::VideoContentDescription* video_content =
new cricket::VideoContentDescription();
- ParseVideoCodec(mlines[i], video_content);
-
- video_content->set_rtcp_mux(ParseRtcpMux(mlines[i]));
+ if (!ParseVideoCodec(content, video_content))
+ return false;
+ video_content->set_rtcp_mux(rtcp_mux);
video_content->SortCodecs();
- (*sdp)->AddContent(cricket::CN_VIDEO,
- cricket::NS_JINGLE_RTP, video_content);
- ParseIceCandidates(mlines[i], candidates);
+ // crypto
+ if (!ParseCrypto(content, video_content))
+ return false;
+ if (!ParseTrack(content, video_content))
+ return false;
+ (sdp)->AddContent(cricket::CN_VIDEO,
+ cricket::NS_JINGLE_RTP, video_content);
}
}
return true;
}
-bool ParseRtcpMux(const Json::Value& value) {
- Json::Value rtcp_mux(ReadValue(value, "rtcp_mux"));
- if (!rtcp_mux.empty()) {
- if (rtcp_mux.asBool()) {
- return true;
- }
- }
- return false;
-}
-
bool ParseAudioCodec(const Json::Value& value,
cricket::AudioContentDescription* content) {
std::vector<Json::Value> rtpmap(ReadValues(value, "rtpmap"));
+ // When there's no codecs in common, rtpmap can be empty.
if (rtpmap.empty())
- return false;
+ return true;
std::vector<Json::Value>::const_iterator iter =
rtpmap.begin();
@@ -259,11 +365,13 @@
std::string pltype(iter->begin().memberName());
talk_base::FromString(pltype, &codec.id);
Json::Value codec_info((*iter)[pltype]);
- std::string codec_name(ReadString(codec_info, "codec"));
+ std::string codec_name;
+ if (!GetStringFromJsonObject(codec_info, "codec", &codec_name))
+ continue;
std::vector<std::string> tokens;
talk_base::split(codec_name, '/', &tokens);
codec.name = tokens[1];
- codec.clockrate = ReadUInt(codec_info, "clockrate");
+ GetIntFromJsonObject(codec_info, "clockrate", &codec.clockrate);
content->AddCodec(codec);
}
@@ -273,8 +381,9 @@
bool ParseVideoCodec(const Json::Value& value,
cricket::VideoContentDescription* content) {
std::vector<Json::Value> rtpmap(ReadValues(value, "rtpmap"));
+ // When there's no codecs in common, rtpmap can be empty.
if (rtpmap.empty())
- return false;
+ return true;
std::vector<Json::Value>::const_iterator iter =
rtpmap.begin();
@@ -293,14 +402,9 @@
return true;
}
-bool ParseIceCandidates(const Json::Value& value,
- std::vector<cricket::Candidate>* candidates) {
- Json::Value attributes(ReadValue(value, "attributes"));
- std::string ice_pwd(ReadString(attributes, "ice-pwd"));
- std::string ice_ufrag(ReadString(attributes, "ice-ufrag"));
-
- std::vector<Json::Value> jcandidates(ReadValues(attributes, "candidate"));
-
+bool ParseCandidates(const Json::Value& content,
+ std::vector<cricket::Candidate>* candidates) {
+ std::vector<Json::Value> jcandidates(ReadValues(content, "candidate"));
std::vector<Json::Value>::const_iterator iter =
jcandidates.begin();
std::vector<Json::Value>::const_iterator iter_end =
@@ -361,6 +465,68 @@
return true;
}
+bool ParseCrypto(const Json::Value& content,
+ cricket::MediaContentDescription* desc) {
+ std::vector<Json::Value> jcryptos(ReadValues(content, "crypto"));
+ std::vector<Json::Value>::const_iterator iter =
+ jcryptos.begin();
+ std::vector<Json::Value>::const_iterator iter_end =
+ jcryptos.end();
+ for (; iter != iter_end; ++iter) {
+ cricket::CryptoParams crypto;
+
+ std::string cipher_suite;
+ if (!GetStringFromJsonObject(*iter, "cipher_suite", &cipher_suite))
+ return false;
+ crypto.cipher_suite = cipher_suite;
+
+ std::string key_params;
+ if (!GetStringFromJsonObject(*iter, "key_params", &key_params))
+ return false;
+ crypto.key_params= key_params;
+
+ desc->AddCrypto(crypto);
+ }
+ return true;
+}
+
+bool ParseTrack(const Json::Value& content,
+ cricket::MediaContentDescription* content_desc) {
+ ASSERT(content_desc != NULL);
+ if (!content_desc)
+ return false;
+
+ std::vector<Json::Value> tracks(ReadValues(content, "track"));
+ std::vector<Json::Value>::const_iterator iter =
+ tracks.begin();
+ std::vector<Json::Value>::const_iterator iter_end =
+ tracks.end();
+ for (; iter != iter_end; ++iter) {
+ uint32 ssrc;
+ std::string label;
+ std::string cname;
+ std::string stream_label;
+ if (!GetUIntFromJsonObject(*iter, "ssrc", &ssrc))
+ return false;
+ // label is optional, it will be empty string if doesn't exist
+ GetStringFromJsonObject(*iter, "label", &label);
+ if (!GetStringFromJsonObject(*iter, "cname", &cname))
+ return false;
+ // stream_label is optional, it will be the same as cname if it
+ // doesn't exist.
+ GetStringFromJsonObject(*iter, "stream_label", &stream_label);
+ if (stream_label.empty())
+ stream_label = cname;
+ cricket::StreamParams stream;
+ stream.name = label;
+ stream.cname = cname;
+ stream.sync_label = stream_label;
+ stream.ssrcs.push_back(ssrc);
+ content_desc->AddStream(stream);
+ }
+ return true;
+}
+
std::vector<Json::Value> ReadValues(
const Json::Value& value, const std::string& key) {
std::vector<Json::Value> objects;
@@ -370,27 +536,11 @@
return objects;
}
-Json::Value ReadValue(const Json::Value& value, const std::string& key) {
- return value[key];
-}
-
-std::string ReadString(const Json::Value& value, const std::string& key) {
- return value[key].asString();
-}
-
-uint32 ReadUInt(const Json::Value& value, const std::string& key) {
- return value[key].asUInt();
-}
-
-double ReadDouble(const Json::Value& value, const std::string& key) {
- return value[key].asDouble();
-}
-
void Append(Json::Value* object, const std::string& key, bool value) {
(*object)[key] = Json::Value(value);
}
-void Append(Json::Value* object, const std::string& key, char * value) {
+void Append(Json::Value* object, const std::string& key, const char* value) {
(*object)[key] = Json::Value(value);
}
diff --git a/talk/app/webrtc/webrtcjson.h b/talk/app/webrtc/webrtcjson.h
index 906326d..069f4b6 100644
--- a/talk/app/webrtc/webrtcjson.h
+++ b/talk/app/webrtc/webrtcjson.h
@@ -1,6 +1,6 @@
/*
* libjingle
- * Copyright 2004--2011, Google Inc.
+ * 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:
@@ -29,80 +29,33 @@
#define TALK_APP_WEBRTC_WEBRTCJSON_H_
#include <string>
+#include <vector>
#ifdef WEBRTC_RELATIVE_PATH
#include "json/json.h"
#else
#include "third_party/jsoncpp/json.h"
#endif
-#include "talk/p2p/base/candidate.h"
-#include "talk/session/phone/codec.h"
-namespace Json {
-class Value;
-}
+#include "talk/p2p/base/candidate.h"
+#include "talk/p2p/base/sessiondescription.h"
namespace cricket {
-class AudioContentDescription;
-class VideoContentDescription;
-struct ContentInfo;
class SessionDescription;
}
namespace webrtc {
-std::vector<Json::Value> ReadValues(const Json::Value& value,
- const std::string& key);
-
-bool BuildMediaMessage(
- const cricket::ContentInfo& content_info,
- const std::vector<cricket::Candidate>& candidates,
- bool video,
- Json::Value* value);
-
-bool GetJsonSignalingMessage(
+void JsonSerializeSessionDescription(
const cricket::SessionDescription* sdp,
const std::vector<cricket::Candidate>& candidates,
- std::string* signaling_message);
+ Json::Value* media);
-bool BuildRtpMapParams(
- const cricket::ContentInfo& audio_offer,
- bool video,
- std::vector<Json::Value>* rtpmap);
+bool JsonDeserializeSessionDescription(
+ const Json::Value& message,
+ cricket::SessionDescription* sdp,
+ std::vector<cricket::Candidate>* candidates);
-bool BuildAttributes(const std::vector<cricket::Candidate>& candidates,
- bool video,
- std::vector<Json::Value>* jcandidates);
-
-std::string Serialize(const Json::Value& value);
-bool Deserialize(const std::string& message, Json::Value& value);
-
-bool ParseJsonSignalingMessage(const std::string& signaling_message,
- cricket::SessionDescription** sdp,
- std::vector<cricket::Candidate>* candidates);
-bool ParseRtcpMux(const Json::Value& value);
-bool ParseAudioCodec(const Json::Value& value,
- cricket::AudioContentDescription* content);
-bool ParseVideoCodec(const Json::Value& value,
- cricket::VideoContentDescription* content);
-bool ParseIceCandidates(const Json::Value& value,
- std::vector<cricket::Candidate>* candidates);
-Json::Value ReadValue(const Json::Value& value, const std::string& key);
-std::string ReadString(const Json::Value& value, const std::string& key);
-double ReadDouble(const Json::Value& value, const std::string& key);
-uint32 ReadUInt(const Json::Value& value, const std::string& key);
-
-void Append(Json::Value* object, const std::string& key, bool value);
-void Append(Json::Value* object, const std::string& key, char * value);
-void Append(Json::Value* object, const std::string& key, int value);
-void Append(Json::Value* object, const std::string& key,
- const std::string& value);
-void Append(Json::Value* object, const std::string& key, uint32 value);
-void Append(Json::Value* object, const std::string& key,
- const Json::Value& value);
-void Append(Json::Value* object,
- const std::string& key,
- const std::vector<Json::Value>& values);
-}
+} // namespace webrtc
#endif // TALK_APP_WEBRTC_WEBRTCJSON_H_
diff --git a/talk/app/webrtc/webrtcsdp.cc b/talk/app/webrtc/webrtcsdp.cc
new file mode 100644
index 0000000..bdf4d00
--- /dev/null
+++ b/talk/app/webrtc/webrtcsdp.cc
@@ -0,0 +1,776 @@
+/*
+ * 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/webrtcsdp.h"
+
+#include <stdio.h>
+#include <string>
+#include <vector>
+
+#include "talk/base/logging.h"
+#include "talk/base/stringutils.h"
+#include "talk/p2p/base/relayport.h"
+#include "talk/p2p/base/stunport.h"
+#include "talk/p2p/base/udpport.h"
+#include "talk/session/phone/codec.h"
+#include "talk/session/phone/cryptoparams.h"
+#include "talk/session/phone/mediasession.h"
+#include "talk/session/phone/mediasessionclient.h"
+
+using cricket::AudioContentDescription;
+using cricket::Candidate;
+using cricket::ContentDescription;
+using cricket::CryptoParams;
+using cricket::MediaContentDescription;
+using cricket::MediaType;
+using cricket::StreamParams;
+using cricket::VideoContentDescription;
+using talk_base::SocketAddress;
+
+namespace webrtc {
+
+// Line prefix
+static const int kLinePrefixLength = 2;
+static const char kLinePrefixVersion[] = "v=";
+static const char kLinePrefixOrigin[] = "o=";
+static const char kLinePrefixSessionName[] = "s=";
+static const char kLinePrefixSessionInfo[] = "i=";
+static const char kLinePrefixSessionUri[] = "u=";
+static const char kLinePrefixSessionEmail[] = "e=";
+static const char kLinePrefixSessionPhone[] = "p=";
+static const char kLinePrefixSessionConnection[] = "c=";
+static const char kLinePrefixSessionBandwidth[] = "b=";
+static const char kLinePrefixTiming[] = "t=";
+static const char kLinePrefixRepeatTimes[] = "r=";
+static const char kLinePrefixTimeZone[] = "z=";
+static const char kLinePrefixEncryptionKey[] = "k=";
+static const char kLinePrefixMedia[] = "m=";
+static const char kLinePrefixAttributes[] = "a=";
+
+// Attributes
+static const char kAttributeMid[] = "mid:";
+static const char kAttributeRtcpMux[] = "rtcp-mux";
+static const char kAttributeSsrc[] = "ssrc:";
+static const char kAttributeCname[] = "cname:";
+static const char kAttributeMslabel[] = "mslabel:";
+static const char kAttributeLabel[] = "label:";
+static const char kAttributeCrypto[] = "crypto:";
+static const char kAttributeCandidate[] = "candidate:";
+static const char kAttributeCandidateTyp[] = "typ";
+static const char kAttributeCandidateName[] = "name";
+static const char kAttributeCandidateNetworkName[] = "network_name";
+static const char kAttributeCandidateUsername[] = "username";
+static const char kAttributeCandidatePassword[] = "password";
+static const char kAttributeCandidateGeneration[] = "generation";
+static const char kAttributeRtpmap[] = "rtpmap:";
+
+// Candidate
+static const char kCandidateHost[] = "host";
+static const char kCandidateSrflx[] = "srflx";
+// TODO: How to map the prflx with circket candidate type
+// static const char kCandidatePrflx[] = "prflx";
+static const char kCandidateRelay[] = "relay";
+
+static const char kSdpDelimiter = ' ';
+static const char kLineBreak[] = "\r\n";
+
+// TODO: Generate the Session and Time description
+// instead of hardcoding.
+static const char kSessionVersion[] = "v=0";
+static const char kSessionOrigin[] = "o=- 0 0 IN IP4 127.0.0.1";
+static const char kSessionName[] = "s=";
+static const char kTimeDescription[] = "t=0 0";
+static const char kAttrGroup[] = "a=group:BUNDLE audio video";
+static const int kIceComponent = 1;
+static const int kIceFoundation = 1;
+static const char kMediaTypeVideo[] = "video";
+static const char kMediaTypeAudio[] = "audio";
+
+// Default Video resolution.
+// TODO: Implement negotiation of video resolution.
+static const int kDefaultVideoWidth = 640;
+static const int kDefaultVideoHeight = 480;
+static const int kDefaultVideoFrameRate = 30;
+static const int kDefaultVideoPreference = 0;
+
+static void BuildMediaDescription(const cricket::ContentInfo& content_info,
+ const MediaType media_type,
+ std::string* message);
+static void BuildRtpMap(const MediaContentDescription* media_desc,
+ const MediaType media_type,
+ std::string* message);
+static void BuildCandidate(const std::vector<Candidate>& candidates,
+ const MediaType media_type,
+ std::string* message);
+
+static bool ParseSessionDescription(const std::string& message, size_t* pos);
+static bool ParseTimeDescription(const std::string& message, size_t* pos);
+static bool ParseMediaDescription(const std::string& message, size_t* pos,
+ cricket::SessionDescription* desc);
+static bool ParseContent(const std::string& message,
+ const MediaType media_type,
+ size_t* pos,
+ ContentDescription* content);
+static bool ParseCandidates(const std::string& message,
+ std::vector<Candidate>* candidates);
+
+// Helper functions
+#define LOG_PREFIX_PARSING_ERROR(line_prefix) LOG(LS_ERROR) \
+ << "Failed to parse the \"" << line_prefix << "\" line";
+
+#define LOG_LINE_PARSING_ERROR(line) LOG(LS_ERROR) \
+ << "Failed to parse line:" << line;
+
+static bool AddLine(const std::string& line, std::string* message) {
+ if (!message)
+ return false;
+
+ message->append(line);
+ message->append(kLineBreak);
+ return true;
+}
+
+static bool GetLine(const std::string& message,
+ size_t* pos,
+ std::string* line) {
+ size_t line_begin = *pos;
+ size_t line_end = message.find('\n', line_begin);
+ if (line_end == std::string::npos) {
+ return false;
+ }
+ // Update the new start position
+ *pos = line_end + 1;
+ if (line_end > 0 && (message.at(line_end - 1) == '\r')) {
+ --line_end;
+ }
+ *line = message.substr(line_begin, (line_end - line_begin));
+ return true;
+}
+
+static bool GetLineWithPrefix(const std::string& message, size_t* pos,
+ std::string* line, const char* type) {
+ if (message.compare(*pos, kLinePrefixLength, type) != 0) {
+ return false;
+ }
+
+ if (!GetLine(message, pos, line))
+ return false;
+
+ return true;
+}
+
+static bool HasPrefix(const std::string& line,
+ const std::string& prefix,
+ size_t pos) {
+ return (line.compare(pos, prefix.size(), prefix) == 0);
+}
+
+static bool HasPrefix(const std::string& line,
+ const std::string& prefix) {
+ return HasPrefix(line, prefix, 0);
+}
+
+static bool HasAttribute(const std::string& line,
+ const std::string& attribute) {
+ return (line.compare(kLinePrefixLength, attribute.size(), attribute) == 0);
+}
+
+std::string SdpSerialize(const cricket::SessionDescription& desc,
+ const std::vector<Candidate>& candidates) {
+ return SdpFormat(SdpSerializeSessionDescription(desc),
+ SdpSerializeCandidates(candidates));
+}
+
+std::string SdpSerializeSessionDescription(
+ const cricket::SessionDescription& desc) {
+ std::string message;
+
+ // Session Description.
+ AddLine(kSessionVersion, &message);
+ AddLine(kSessionOrigin, &message);
+ AddLine(kSessionName, &message);
+
+ // Time Description.
+ AddLine(kTimeDescription, &message);
+
+ const cricket::ContentInfo* audio_content = GetFirstAudioContent(&desc);
+ const cricket::ContentInfo* video_content = GetFirstVideoContent(&desc);
+
+ // Group
+ if (audio_content && video_content)
+ AddLine(kAttrGroup, &message);
+
+ // Media Description
+ if (audio_content) {
+ BuildMediaDescription(*audio_content, cricket::MEDIA_TYPE_AUDIO, &message);
+ }
+
+ if (video_content) {
+ BuildMediaDescription(*video_content, cricket::MEDIA_TYPE_VIDEO, &message);
+ }
+
+ return message;
+}
+
+std::string SdpSerializeCandidates(const std::vector<Candidate>& candidates) {
+ std::string message;
+ // rfc5245
+ // a=candidate:<foundation> <component-id> <transport> <priority>
+ // <connection-address> <port> typ <candidate-types>
+ // [raddr <connection-address>] [rport <port>]
+ BuildCandidate(candidates, cricket::MEDIA_TYPE_AUDIO, &message);
+ BuildCandidate(candidates, cricket::MEDIA_TYPE_VIDEO, &message);
+ return message;
+}
+
+std::string SdpFormat(const std::string& desc, const std::string& candidates) {
+ std::string sdp; // New sdp message.
+
+ std::vector<Candidate> candidates_vector;
+ if (!ParseCandidates(candidates, &candidates_vector))
+ return sdp;
+
+ size_t pos = 0;
+ std::string line;
+ while (GetLine(desc, &pos, &line)) {
+ AddLine(line, &sdp); // Copy old line to new sdp.
+ if (!HasPrefix(line, kLinePrefixMedia)) {
+ continue; // Loop until the next m line.
+ }
+ if (HasAttribute(line, kMediaTypeVideo)) {
+ BuildCandidate(candidates_vector, cricket::MEDIA_TYPE_VIDEO, &sdp);
+ } else if (HasAttribute(line, kMediaTypeAudio)) {
+ BuildCandidate(candidates_vector, cricket::MEDIA_TYPE_AUDIO, &sdp);
+ }
+ }
+
+ return sdp;
+}
+
+
+bool SdpDeserialize(const std::string& message,
+ cricket::SessionDescription* desc,
+ std::vector<Candidate>* candidates) {
+ return SdpDeserializeSessionDescription(message, desc) &&
+ SdpDeserializeCandidates(message, candidates);
+}
+
+bool SdpDeserializeSessionDescription(const std::string& message,
+ cricket::SessionDescription* desc) {
+ size_t current_pos = 0;
+
+ // Session Description
+ if (!ParseSessionDescription(message, ¤t_pos)) {
+ return false;
+ }
+
+ // Time Description
+ if (!ParseTimeDescription(message, ¤t_pos)) {
+ return false;
+ }
+
+ // Media Description
+ if (!ParseMediaDescription(message, ¤t_pos, desc)) {
+ return false;
+ }
+
+ return true;
+}
+
+bool SdpDeserializeCandidates(const std::string& message,
+ std::vector<Candidate>* candidates) {
+ return ParseCandidates(message, candidates);
+}
+
+void BuildMediaDescription(const cricket::ContentInfo& content_info,
+ const MediaType media_type,
+ std::string* message) {
+ ASSERT(message != NULL);
+ // TODO: Rethink if we should use sprintfn instead of stringstream.
+ // According to the style guide, streams should only be used for logging.
+ // http://google-styleguide.googlecode.com/svn/
+ // trunk/cppguide.xml?showone=Streams#Streams
+ std::ostringstream os;
+ const MediaContentDescription* media_desc =
+ static_cast<const MediaContentDescription*> (
+ content_info.description);
+ ASSERT(media_desc != NULL);
+
+ // m=<media> <port> <proto> <fmt>
+ // fmt is a list of payload type numbers that MAY be used in the session.
+ const char* type = NULL;
+ if (media_type == cricket::MEDIA_TYPE_AUDIO)
+ type = kMediaTypeAudio;
+ else if (media_type == cricket::MEDIA_TYPE_VIDEO)
+ type = kMediaTypeVideo;
+ else
+ ASSERT(false);
+
+ std::string fmt;
+ if (media_type == cricket::MEDIA_TYPE_VIDEO) {
+ const VideoContentDescription* video_desc =
+ static_cast<const VideoContentDescription*>(media_desc);
+ for (std::vector<cricket::VideoCodec>::const_iterator it =
+ video_desc->codecs().begin();
+ it != video_desc->codecs().end(); ++it) {
+ fmt.append(" ");
+ fmt.append(talk_base::ToString<int>(it->id));
+ }
+ } else if (media_type == cricket::MEDIA_TYPE_AUDIO) {
+ const AudioContentDescription* audio_desc =
+ static_cast<const AudioContentDescription*>(media_desc);
+ for (std::vector<cricket::AudioCodec>::const_iterator it =
+ audio_desc->codecs().begin();
+ it != audio_desc->codecs().end(); ++it) {
+ fmt.append(" ");
+ fmt.append(talk_base::ToString<int>(it->id));
+ }
+ }
+ const int port = 0;
+ const char* proto = "RTP/AVPF";
+ os.str("");
+ os << kLinePrefixMedia << type << " " << port << " " << proto << fmt;
+ AddLine(os.str(), message);
+
+ // a=mid:<media>
+ os.str("");
+ os << kLinePrefixAttributes << kAttributeMid << type;
+ AddLine(os.str(), message);
+
+ // a=rtcp-mux
+ if (media_desc->rtcp_mux()) {
+ os.str("");
+ os << kLinePrefixAttributes << kAttributeRtcpMux;
+ AddLine(os.str(), message);
+ }
+
+ // a=crypto:<tag> <crypto-suite> <key-params> [<session-params>]
+ for (std::vector<CryptoParams>::const_iterator it =
+ media_desc->cryptos().begin();
+ it != media_desc->cryptos().end(); ++it) {
+ os.str("");
+ os << kLinePrefixAttributes << kAttributeCrypto << it->tag << " "
+ << it->cipher_suite << " "
+ << it->key_params << " "
+ << it->session_params;
+ AddLine(os.str(), message);
+ }
+
+ // a=rtpmap:<payload type> <encoding name>/<clock rate>
+ // [/<encodingparameters>]
+ BuildRtpMap(media_desc, media_type, message);
+
+ // draft - Mechanisms for Media Source Selection in SDP
+ // a=ssrc:<ssrc-id> <attribute>:<value>
+ // a=ssrc:<ssrc-id> cname:<value> mslabel:<value> label:<value>
+ for (cricket::StreamParamsVec::const_iterator it =
+ media_desc->streams().begin();
+ it != media_desc->streams().end(); ++it) {
+ // Require that the track belongs to a media stream,
+ // ie the sync_label is set. This extra check is necessary since the
+ // MediaContentDescription always contains a streamparam with an ssrc even
+ // if no track or media stream have been created.
+ if (it->sync_label.empty()) continue;
+
+ os.str("");
+ os << kLinePrefixAttributes << kAttributeSsrc << it->ssrcs[0] << " "
+ << kAttributeCname << it->cname << " "
+ << kAttributeMslabel << it->sync_label << " "
+ << kAttributeLabel << it->name;
+ AddLine(os.str(), message);
+ }
+}
+
+void BuildRtpMap(const MediaContentDescription* media_desc,
+ const MediaType media_type,
+ std::string* message) {
+ ASSERT(message != NULL);
+ ASSERT(media_desc != NULL);
+ std::ostringstream os;
+ if (media_type == cricket::MEDIA_TYPE_VIDEO) {
+ const VideoContentDescription* video_desc =
+ static_cast<const VideoContentDescription*>(media_desc);
+ for (std::vector<cricket::VideoCodec>::const_iterator it =
+ video_desc->codecs().begin();
+ it != video_desc->codecs().end(); ++it) {
+ // a=rtpmap:<payload type> <encoding name>/<clock rate>
+ // [/<encodingparameters>]
+ os.str("");
+ os << kLinePrefixAttributes << kAttributeRtpmap << it->id << " "
+ << it->name << "/" << 0;
+ AddLine(os.str(), message);
+ }
+ } else if (media_type == cricket::MEDIA_TYPE_AUDIO) {
+ const AudioContentDescription* audio_desc =
+ static_cast<const AudioContentDescription*>(media_desc);
+ for (std::vector<cricket::AudioCodec>::const_iterator it =
+ audio_desc->codecs().begin();
+ it != audio_desc->codecs().end(); ++it) {
+ // a=rtpmap:<payload type> <encoding name>/<clock rate>
+ // [/<encodingparameters>]
+ os.str("");
+ os << kLinePrefixAttributes << kAttributeRtpmap << it->id << " "
+ << it->name << "/" << it->clockrate;
+ AddLine(os.str(), message);
+ }
+ }
+}
+
+void BuildCandidate(const std::vector<Candidate>& candidates,
+ const MediaType media_type,
+ std::string* message) {
+ std::ostringstream os;
+ for (std::vector<Candidate>::const_iterator it = candidates.begin();
+ it != candidates.end(); ++it) {
+ // a=candidate:<foundation> <component-id> <transport> <priority>
+ // <connection-address> <port> typ <candidate-types>
+ // [raddr <connection-address>] [rport <port>]
+ // *(SP extension-att-name SP extension-att-value)
+ if (((media_type == cricket::MEDIA_TYPE_VIDEO) &&
+ (it->name() == "video_rtcp" || it->name() == "video_rtp")) ||
+ ((media_type == cricket::MEDIA_TYPE_AUDIO) &&
+ (it->name() == "rtp" || it->name() == "rtcp"))) {
+ std::string type;
+ // Map the cricket candidate type to "host" / "srflx" / "prflx" / "relay"
+ if (it->type() == cricket::LOCAL_PORT_TYPE) {
+ type = kCandidateHost;
+ } else if (it->type() == cricket::STUN_PORT_TYPE) {
+ type = kCandidateSrflx;
+ } else if (it->type() == cricket::RELAY_PORT_TYPE) {
+ type = kCandidateRelay;
+ } else {
+ ASSERT(false);
+ }
+ os.str("");
+ os << kLinePrefixAttributes << kAttributeCandidate
+ << kIceFoundation << " " << kIceComponent << " "
+ << it->protocol() << " " << it->preference_str() << " "
+ << it->address().IPAsString() << " "
+ << it->address().PortAsString() << " "
+ << kAttributeCandidateTyp << " " << type << " "
+ << kAttributeCandidateName << " " << it->name() << " "
+ << kAttributeCandidateNetworkName << " " << it->network_name() << " "
+ << kAttributeCandidateUsername << " " << it->username() << " "
+ << kAttributeCandidatePassword << " " << it->password() << " "
+ << kAttributeCandidateGeneration << " " << it->generation();
+ AddLine(os.str(), message);
+ }
+ }
+}
+
+bool ParseSessionDescription(const std::string& message, size_t* pos) {
+ std::string line;
+
+ // v= (protocol version)
+ if (!GetLineWithPrefix(message, pos, &line, kLinePrefixVersion)) {
+ LOG_PREFIX_PARSING_ERROR(kLinePrefixVersion);
+ return false;
+ }
+ // o= (originator and session identifier)
+ if (!GetLineWithPrefix(message, pos, &line, kLinePrefixOrigin)) {
+ LOG_PREFIX_PARSING_ERROR(kLinePrefixOrigin);
+ return false;
+ }
+ // s= (session name)
+ if (!GetLineWithPrefix(message, pos, &line, kLinePrefixSessionName)) {
+ LOG_PREFIX_PARSING_ERROR(kLinePrefixSessionName);
+ return false;
+ }
+
+ // Optional lines
+ // Those are the optional lines, so shouldn't return false if not present.
+ // i=* (session information)
+ GetLineWithPrefix(message, pos, &line, kLinePrefixSessionInfo);
+
+ // u=* (URI of description)
+ GetLineWithPrefix(message, pos, &line, kLinePrefixSessionUri);
+
+ // e=* (email address)
+ GetLineWithPrefix(message, pos, &line, kLinePrefixSessionEmail);
+
+ // p=* (phone number)
+ GetLineWithPrefix(message, pos, &line, kLinePrefixSessionPhone);
+
+ // c=* (connection information -- not required if included in
+ // all media)
+ GetLineWithPrefix(message, pos, &line, kLinePrefixSessionConnection);
+
+ // b=* (zero or more bandwidth information lines)
+ while (GetLineWithPrefix(message, pos, &line, kLinePrefixSessionBandwidth)) {
+ // By pass zero or more b lines.
+ }
+
+ return true;
+}
+
+bool ParseTimeDescription(const std::string& message, size_t* pos) {
+ std::string line;
+ // One or more time descriptions ("t=" and "r=" lines; see below)
+ // t= (time the session is active)
+ // r=* (zero or more repeat times)
+ // Ensure there's at least one time description
+ if (!GetLineWithPrefix(message, pos, &line, kLinePrefixTiming)) {
+ LOG_PREFIX_PARSING_ERROR(kLinePrefixTiming);
+ return false;
+ }
+
+ while (GetLineWithPrefix(message, pos, &line, kLinePrefixRepeatTimes)) {
+ // By pass zero or more r lines.
+ }
+
+ // Go through the rest of the time descriptions
+ while (GetLineWithPrefix(message, pos, &line, kLinePrefixTiming)) {
+ while (GetLineWithPrefix(message, pos, &line, kLinePrefixRepeatTimes)) {
+ // By pass zero or more r lines.
+ }
+ }
+
+ // z=* (time zone adjustments)
+ GetLineWithPrefix(message, pos, &line, kLinePrefixTimeZone);
+
+ // k=* (encryption key)
+ GetLineWithPrefix(message, pos, &line, kLinePrefixEncryptionKey);
+
+ // a=* (zero or more session attribute lines)
+ while (GetLineWithPrefix(message, pos, &line, kLinePrefixAttributes)) {
+ // TODO: parse the a=group:BUNDLE
+ }
+
+ return true;
+}
+
+bool ParseMediaDescription(const std::string& message, size_t* pos,
+ cricket::SessionDescription* desc) {
+ ASSERT(desc != NULL);
+
+ std::string line;
+
+ // Zero or more media descriptions
+ // m=<media> <port> <proto> <fmt>
+ while (GetLineWithPrefix(message, pos, &line, kLinePrefixMedia)) {
+ MediaType media_type = cricket::MEDIA_TYPE_VIDEO;
+ ContentDescription* content = NULL;
+ if (HasAttribute(line, kMediaTypeVideo)) {
+ media_type = cricket::MEDIA_TYPE_VIDEO;
+ content = new VideoContentDescription();
+ desc->AddContent(cricket::CN_VIDEO, cricket::NS_JINGLE_RTP, content);
+ } else if (HasAttribute(line, kMediaTypeAudio)) {
+ media_type = cricket::MEDIA_TYPE_AUDIO;
+ content = new AudioContentDescription();
+ desc->AddContent(cricket::CN_AUDIO, cricket::NS_JINGLE_RTP, content);
+ } else {
+ LOG(LS_WARNING) << "Unsupported media type: " << line;
+ }
+
+ if (!ParseContent(message, media_type, pos, content))
+ return false;
+ }
+ return true;
+}
+
+bool ParseContent(const std::string& message,
+ const MediaType media_type,
+ size_t* pos,
+ ContentDescription* content) {
+ std::string line;
+ // Loop until the next m line
+ while (!HasPrefix(message, kLinePrefixMedia, *pos)) {
+ if (!GetLine(message, pos, &line)) {
+ if (*pos >= message.size())
+ return true; // Done parsing
+ else
+ return false;
+ }
+
+ if (!content) {
+ // Unsupported media type, just skip it.
+ continue;
+ }
+
+ if (!HasPrefix(line, kLinePrefixAttributes)) {
+ // TODO: Handle other lines if needed.
+ continue;
+ }
+
+ MediaContentDescription* media_desc =
+ static_cast<MediaContentDescription*> (content);
+
+ std::vector<std::string> fields;
+ talk_base::split(line.substr(kLinePrefixLength), kSdpDelimiter, &fields);
+
+ if (HasAttribute(line, kAttributeMid)) {
+ continue;
+ } else if (HasAttribute(line, kAttributeRtcpMux)) {
+ media_desc->set_rtcp_mux(true);
+ } else if (HasAttribute(line, kAttributeSsrc)) {
+ // a=ssrc:<ssrc-id> cname:<value> mslabel:<value> label:<value>
+ uint32 ssrc = 0;
+ std::string cname;
+ std::string mslabel;
+ std::string label;
+ for (std::vector<std::string>::const_iterator it = fields.begin();
+ it != fields.end(); ++it) {
+ if (HasPrefix(*it, kAttributeSsrc)) {
+ ASSERT(it == fields.begin());
+ ssrc = talk_base::FromString<uint32>(
+ it->substr(strlen(kAttributeSsrc)));
+ } else if (HasPrefix(*it, kAttributeCname)) {
+ cname = it->substr(strlen(kAttributeCname));
+ } else if (HasPrefix(*it, kAttributeMslabel)) {
+ mslabel = it->substr(strlen(kAttributeMslabel));
+ } else if (HasPrefix(*it, kAttributeLabel)) {
+ label = it->substr(strlen(kAttributeLabel));
+ }
+ }
+ StreamParams stream;
+ stream.name = label;
+ stream.cname = cname;
+ stream.sync_label = mslabel;
+ stream.ssrcs.push_back(ssrc);
+ media_desc->AddStream(stream);
+ } else if (HasAttribute(line, kAttributeCrypto)) {
+ // a=crypto:<tag> <crypto-suite> <key-params> [<session-params>]
+ if (fields.size() < 3) { // 3 mandatory fields
+ LOG_LINE_PARSING_ERROR(line);
+ return false;
+ }
+ int tag = talk_base::FromString<int>(
+ fields[0].substr(strlen(kAttributeCrypto)));
+ const std::string crypto_suite = fields[1];
+ const std::string key_params = fields[2];
+ media_desc->AddCrypto(CryptoParams(tag, crypto_suite, key_params, ""));
+ } else if (HasAttribute(line, kAttributeCandidate)) {
+ continue; // Parse candidates separately.
+ } else if (HasAttribute(line, kAttributeRtpmap)) {
+ // a=rtpmap:<payload type> <encoding name>/<clock rate>
+ // [/<encodingparameters>]
+ // 2 mandatory fields
+ if (fields.size() < 2) {
+ LOG_LINE_PARSING_ERROR(line);
+ return false;
+ }
+ const int payload_type = talk_base::FromString<int>(
+ fields[0].substr(strlen(kAttributeRtpmap)));
+ const std::string encoder = fields[1];
+ const size_t pos = encoder.find("/");
+ if (pos == std::string::npos)
+ return false;
+ const std::string encoding_name = encoder.substr(0, pos);
+ const int clock_rate =
+ talk_base::FromString<int>(encoder.substr(pos + 1));
+ if (media_type == cricket::MEDIA_TYPE_VIDEO) {
+ VideoContentDescription* video_desc =
+ static_cast<VideoContentDescription*>(media_desc);
+ // TODO: We will send resolution in SDP. For now, use VGA.
+ video_desc->AddCodec(cricket::VideoCodec(payload_type, encoding_name,
+ kDefaultVideoWidth,
+ kDefaultVideoHeight,
+ kDefaultVideoFrameRate,
+ kDefaultVideoPreference));
+ } else if (media_type == cricket::MEDIA_TYPE_AUDIO) {
+ AudioContentDescription* audio_desc =
+ static_cast<AudioContentDescription*>(media_desc);
+ audio_desc->AddCodec(cricket::AudioCodec(payload_type, encoding_name,
+ clock_rate, 0, 0, 0));
+ }
+ } else {
+ LOG(LS_WARNING) << "Unsupported line: " << line;
+ }
+ }
+ return true;
+}
+
+bool ParseCandidates(const std::string& message,
+ std::vector<Candidate>* candidates) {
+ ASSERT(candidates != NULL);
+ std::string line;
+ size_t pos = 0;
+
+ // Loop until the next attribute line.
+ while (GetLine(message, &pos, &line)) {
+ if (!HasPrefix(line, kLinePrefixAttributes) ||
+ !HasAttribute(line, kAttributeCandidate)) {
+ continue; // Only parse candidates
+ }
+ std::vector<std::string> fields;
+ talk_base::split(line.substr(kLinePrefixLength), kSdpDelimiter, &fields);
+ // a=candidate:<foundation> <component-id> <transport> <priority>
+ // <connection-address> <port> typ <candidate-types>
+ // [raddr <connection-address>] [rport <port>]
+ // *(SP extension-att-name SP extension-att-value)
+ // 8 mandatory fields
+ if (fields.size() < 8 || (fields[6] != kAttributeCandidateTyp)) {
+ LOG_LINE_PARSING_ERROR(line);
+ return false;
+ }
+ const std::string transport = fields[2];
+ const float priority = talk_base::FromString<float>(fields[3]);
+ const std::string connection_address = fields[4];
+ const int port = talk_base::FromString<int>(fields[5]);
+ std::string candidate_type;
+ const std::string type = fields[7];
+ if (type == kCandidateHost) {
+ candidate_type = cricket::LOCAL_PORT_TYPE;
+ } else if (type == kCandidateSrflx) {
+ candidate_type = cricket::STUN_PORT_TYPE;
+ } else if (type == kCandidateRelay) {
+ candidate_type = cricket::RELAY_PORT_TYPE;
+ } else {
+ LOG(LS_ERROR) << "Unsupported candidate type from line: " << line;
+ return false;
+ }
+
+ // extension
+ std::string name;
+ std::string network_name;
+ std::string username;
+ std::string password;
+ uint32 generation = 0;
+ for (size_t i = 8; i < (fields.size() - 1); ++i) {
+ const std::string field = fields.at(i);
+ if (field == kAttributeCandidateName) {
+ name = fields.at(++i);
+ } else if (field == kAttributeCandidateNetworkName) {
+ network_name = fields.at(++i);
+ } else if (field == kAttributeCandidateUsername) {
+ username = fields.at(++i);
+ } else if (field == kAttributeCandidatePassword) {
+ password = fields.at(++i);
+ } else if (field == kAttributeCandidateGeneration) {
+ generation = talk_base::FromString<uint32>(fields.at(++i));
+ }
+ }
+
+ SocketAddress address(connection_address, port);
+ Candidate candidate(name, transport, address, priority, username,
+ password, candidate_type, network_name, generation);
+ candidates->push_back(candidate);
+ }
+ return true;
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/webrtcsdp.h b/talk/app/webrtc/webrtcsdp.h
new file mode 100644
index 0000000..e5c1b12
--- /dev/null
+++ b/talk/app/webrtc/webrtcsdp.h
@@ -0,0 +1,99 @@
+/*
+ * 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 contain functions for parsing and serializing SDP messages.
+// Related RFC/draft including:
+// * RFC 4566 - SDP
+// * RFC 5245 - ICE
+// * RFC 3388 - Grouping of Media Lines in SDP
+// * RFC 4568 - SDP Security Descriptions for Media Streams
+// * draft-lennox-mmusic-sdp-source-selection-02 -
+// Mechanisms for Media Source Selection in SDP
+
+#ifndef TALK_APP_WEBRTC_WEBRTCSDP_H_
+#define TALK_APP_WEBRTC_WEBRTCSDP_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/p2p/base/candidate.h"
+
+namespace cricket {
+class SessionDescription;
+}
+
+namespace webrtc {
+
+// Serializes the passed in SessionDescription and Candidates to a SDP string.
+// desc - The SessionDescription object to be serialized.
+// candidates - The Set of Candidate objects to be serialized.
+// return - SDP string serialized from the arguments.
+std::string SdpSerialize(const cricket::SessionDescription& desc,
+ const std::vector<cricket::Candidate>& candidates);
+
+// Serializes the passed in SessionDescription to a SDP string.
+// desc - The SessionDescription object to be serialized.
+std::string SdpSerializeSessionDescription(
+ const cricket::SessionDescription& desc);
+
+// Serializes the passed in Candidates to a SDP string.
+// candidates - The Set of Candidate objects to be serialized.
+std::string SdpSerializeCandidates(
+ const std::vector<cricket::Candidate>& candidates);
+
+// Deserializes the passed in SDP string to a SessionDescription and Candidates.
+// message - SDP string to be Deserialized.
+// desc - The SessionDescription object deserialized from the SDP string.
+// candidates - The set of Candidate deserialized from the SDP string.
+// return - true on success, false on failure.
+bool SdpDeserialize(const std::string& message,
+ cricket::SessionDescription* desc,
+ std::vector<cricket::Candidate>* candidates);
+
+// Deserializes the passed in SDP string to a SessionDescription.
+// Candidates are ignored.
+// message - SDP string to be Deserialized.
+// desc - The SessionDescription object deserialized from the SDP string.
+// return - true on success, false on failure.
+bool SdpDeserializeSessionDescription(const std::string& message,
+ cricket::SessionDescription* desc);
+
+// Deserializes the passed in SDP string to Candidates.
+// Only the candidates are parsed from the SDP string.
+// message - SDP string to be Deserialized.
+// candidates - The set of Candidate deserialized from the SDP string.
+// return - true on success, false on failure.
+bool SdpDeserializeCandidates(const std::string& message,
+ std::vector<cricket::Candidate>* candidates);
+
+// Formats a correct SDP string by reformatting a session description and
+// candidates.
+std::string SdpFormat(const std::string& desc, const std::string& candidates);
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_WEBRTCSDP_H_
diff --git a/talk/app/webrtc/webrtcsdp_unittest.cc b/talk/app/webrtc/webrtcsdp_unittest.cc
new file mode 100644
index 0000000..dbc7ccd
--- /dev/null
+++ b/talk/app/webrtc/webrtcsdp_unittest.cc
@@ -0,0 +1,374 @@
+/*
+ * 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 "talk/app/webrtc/webrtcsdp.h"
+#include "talk/base/gunit.h"
+#include "talk/base/logging.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/stringutils.h"
+#include "talk/p2p/base/constants.h"
+#include "talk/session/phone/mediasession.h"
+
+typedef std::vector<cricket::Candidate> Candidates;
+using cricket::AudioCodec;
+using cricket::AudioContentDescription;
+using cricket::ContentInfo;
+using cricket::CryptoParams;
+using cricket::SessionDescription;
+using cricket::StreamParams;
+using cricket::VideoCodec;
+using cricket::VideoContentDescription;
+
+// Reference sdp string
+static const char kSdpFullString[] =
+ "v=0\r\n"
+ "o=- 0 0 IN IP4 127.0.0.1\r\n"
+ "s=\r\n"
+ "t=0 0\r\n"
+ "a=group:BUNDLE audio video\r\n"
+ "m=audio 0 RTP/AVPF 103 104\r\n"
+ "a=candidate:1 1 udp 1 127.0.0.1 1234 typ host name rtp network_name "
+ "eth0 username user_rtp password password_rtp generation 0\r\n"
+ "a=candidate:1 1 udp 1 127.0.0.1 1235 typ host name rtcp network_name "
+ "eth0 username user_rtcp password password_rtcp generation 0\r\n"
+ "a=mid:audio\r\n"
+ "a=rtcp-mux\r\n"
+ "a=crypto:1 AES_CM_128_HMAC_SHA1_32 "
+ "inline:NzB4d1BINUAvLEw6UzF3WSJ+PSdFcGdUJShpX1Zj|2^20|1:32 \r\n"
+ "a=rtpmap:103 ISAC/16000\r\n"
+ "a=rtpmap:104 ISAC/32000\r\n"
+ "a=ssrc:1 cname:stream_1_cname mslabel:local_stream_1 "
+ "label:local_audio_1\r\n"
+ "a=ssrc:4 cname:stream_2_cname mslabel:local_stream_2 "
+ "label:local_audio_2\r\n"
+ "m=video 0 RTP/AVPF 120\r\n"
+ "a=candidate:1 1 udp 1 127.0.0.1 1236 typ host name video_rtcp "
+ "network_name eth0 username user_video_rtcp password password_video_rtcp "
+ "generation 0\r\n"
+ "a=candidate:1 1 udp 1 127.0.0.1 1237 typ host name video_rtp "
+ "network_name eth0 username user_video_rtp password password_video_rtp "
+ "generation 0\r\n"
+ "a=mid:video\r\n"
+ "a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
+ "inline:d0RmdmcmVCspeEc3QGZiNWpVLFJhQX1cfHAwJSoj|2^20|1:32 \r\n"
+ "a=rtpmap:120 VP8/0\r\n"
+ "a=ssrc:2 cname:stream_1_cname mslabel:local_stream_1 "
+ "label:local_video_1\r\n"
+ "a=ssrc:3 cname:stream_1_cname mslabel:local_stream_1 "
+ "label:local_video_2\r\n"
+ "a=ssrc:5 cname:stream_2_cname mslabel:local_stream_2 "
+ "label:local_video_3\r\n";
+
+// SDP reference string without the candidates.
+static const char kSdpString[] =
+ "v=0\r\n"
+ "o=- 0 0 IN IP4 127.0.0.1\r\n"
+ "s=\r\n"
+ "t=0 0\r\n"
+ "a=group:BUNDLE audio video\r\n"
+ "m=audio 0 RTP/AVPF 103 104\r\n"
+ "a=mid:audio\r\n"
+ "a=rtcp-mux\r\n"
+ "a=crypto:1 AES_CM_128_HMAC_SHA1_32 "
+ "inline:NzB4d1BINUAvLEw6UzF3WSJ+PSdFcGdUJShpX1Zj|2^20|1:32 \r\n"
+ "a=rtpmap:103 ISAC/16000\r\n"
+ "a=rtpmap:104 ISAC/32000\r\n"
+ "a=ssrc:1 cname:stream_1_cname mslabel:local_stream_1 "
+ "label:local_audio_1\r\n"
+ "a=ssrc:4 cname:stream_2_cname mslabel:local_stream_2 "
+ "label:local_audio_2\r\n"
+ "m=video 0 RTP/AVPF 120\r\n"
+ "a=mid:video\r\n"
+ "a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
+ "inline:d0RmdmcmVCspeEc3QGZiNWpVLFJhQX1cfHAwJSoj|2^20|1:32 \r\n"
+ "a=rtpmap:120 VP8/0\r\n"
+ "a=ssrc:2 cname:stream_1_cname mslabel:local_stream_1 "
+ "label:local_video_1\r\n"
+ "a=ssrc:3 cname:stream_1_cname mslabel:local_stream_1 "
+ "label:local_video_2\r\n"
+ "a=ssrc:5 cname:stream_2_cname mslabel:local_stream_2 "
+ "label:local_video_3\r\n";
+
+// Candidates reference string.
+static const char kSdpCandidates[] =
+ "a=candidate:1 1 udp 1 127.0.0.1 1234 typ host name rtp network_name "
+ "eth0 username user_rtp password password_rtp generation 0\r\n"
+ "a=candidate:1 1 udp 1 127.0.0.1 1235 typ host name rtcp network_name "
+ "eth0 username user_rtcp password password_rtcp generation 0\r\n"
+ "a=candidate:1 1 udp 1 127.0.0.1 1236 typ host name video_rtcp "
+ "network_name eth0 username user_video_rtcp password password_video_rtcp "
+ "generation 0\r\n"
+ "a=candidate:1 1 udp 1 127.0.0.1 1237 typ host name video_rtp "
+ "network_name eth0 username user_video_rtp password password_video_rtp "
+ "generation 0\r\n";
+
+static const char kSdpDestroyer[] = "!@#$%^&";
+
+// MediaStream 1
+static const char kStreamLabel1[] = "local_stream_1";
+static const char kStream1Cname[] = "stream_1_cname";
+static const char kAudioTrackLabel1[] = "local_audio_1";
+static const uint32 kAudioTrack1Ssrc = 1;
+static const char kVideoTrackLabel1[] = "local_video_1";
+static const uint32 kVideoTrack1Ssrc = 2;
+static const char kVideoTrackLabel2[] = "local_video_2";
+static const uint32 kVideoTrack2Ssrc = 3;
+
+// MediaStream 2
+static const char kStreamLabel2[] = "local_stream_2";
+static const char kStream2Cname[] = "stream_2_cname";
+static const char kAudioTrackLabel2[] = "local_audio_2";
+static const uint32 kAudioTrack2Ssrc = 4;
+static const char kVideoTrackLabel3[] = "local_video_3";
+static const uint32 kVideoTrack3Ssrc = 5;
+
+class WebRtcSdpTest : public testing::Test {
+ public:
+ WebRtcSdpTest() {
+ // AudioContentDescription
+ talk_base::scoped_ptr<AudioContentDescription> audio(
+ new AudioContentDescription());
+ audio->set_rtcp_mux(true);
+ StreamParams audio_stream1;
+ audio_stream1.name = kAudioTrackLabel1;
+ audio_stream1.cname = kStream1Cname;
+ audio_stream1.sync_label = kStreamLabel1;
+ audio_stream1.ssrcs.push_back(kAudioTrack1Ssrc);
+ audio->AddStream(audio_stream1);
+ StreamParams audio_stream2;
+ audio_stream2.name = kAudioTrackLabel2;
+ audio_stream2.cname = kStream2Cname;
+ audio_stream2.sync_label = kStreamLabel2;
+ audio_stream2.ssrcs.push_back(kAudioTrack2Ssrc);
+ audio->AddStream(audio_stream2);
+ audio->AddCrypto(CryptoParams(1, "AES_CM_128_HMAC_SHA1_32",
+ "inline:NzB4d1BINUAvLEw6UzF3WSJ+PSdFcGdUJShpX1Zj|2^20|1:32", ""));
+ audio->AddCodec(AudioCodec(103, "ISAC", 16000, 0, 0, 0));
+ audio->AddCodec(AudioCodec(104, "ISAC", 32000, 0, 0, 0));
+ desc_.AddContent(cricket::CN_AUDIO, cricket::NS_JINGLE_RTP,
+ audio.release());
+
+ // VideoContentDescription
+ talk_base::scoped_ptr<VideoContentDescription> video(
+ new VideoContentDescription());
+ StreamParams video_stream1;
+ video_stream1.name = kVideoTrackLabel1;
+ video_stream1.cname = kStream1Cname;
+ video_stream1.sync_label = kStreamLabel1;
+ video_stream1.ssrcs.push_back(kVideoTrack1Ssrc);
+ video->AddStream(video_stream1);
+ StreamParams video_stream2;
+ video_stream2.name = kVideoTrackLabel2;
+ video_stream2.cname = kStream1Cname;
+ video_stream2.sync_label = kStreamLabel1;
+ video_stream2.ssrcs.push_back(kVideoTrack2Ssrc);
+ video->AddStream(video_stream2);
+ StreamParams video_stream3;
+ video_stream3.name = kVideoTrackLabel3;
+ video_stream3.cname = kStream2Cname;
+ video_stream3.sync_label = kStreamLabel2;
+ video_stream3.ssrcs.push_back(kVideoTrack3Ssrc);
+ video->AddStream(video_stream3);
+ video->AddCrypto(CryptoParams(1, "AES_CM_128_HMAC_SHA1_80",
+ "inline:d0RmdmcmVCspeEc3QGZiNWpVLFJhQX1cfHAwJSoj|2^20|1:32", ""));
+ video->AddCodec(VideoCodec(120, "VP8", 640, 480, 30, 0));
+ desc_.AddContent(cricket::CN_VIDEO, cricket::NS_JINGLE_RTP,
+ video.release());
+
+ int port = 1234;
+ talk_base::SocketAddress address("127.0.0.1", port++);
+ cricket::Candidate candidate1("rtp", "udp", address, 1,
+ "user_rtp", "password_rtp", "local", "eth0", 0);
+ address.SetPort(port++);
+ cricket::Candidate candidate2("rtcp", "udp", address, 1,
+ "user_rtcp", "password_rtcp", "local", "eth0", 0);
+ address.SetPort(port++);
+ cricket::Candidate candidate3("video_rtcp", "udp", address, 1,
+ "user_video_rtcp", "password_video_rtcp", "local", "eth0", 0);
+ address.SetPort(port++);
+ cricket::Candidate candidate4("video_rtp", "udp", address, 1,
+ "user_video_rtp", "password_video_rtp", "local", "eth0", 0);
+
+ candidates_.push_back(candidate1);
+ candidates_.push_back(candidate2);
+ candidates_.push_back(candidate3);
+ candidates_.push_back(candidate4);
+ }
+
+ bool CompareSessionDescription(const SessionDescription& desc1,
+ const SessionDescription& desc2) {
+ const ContentInfo* ac1 = desc1.GetContentByName("audio");
+ const AudioContentDescription* acd1 =
+ static_cast<const AudioContentDescription*>(ac1->description);
+ const ContentInfo* vc1 = desc1.GetContentByName("video");
+ const VideoContentDescription* vcd1 =
+ static_cast<const VideoContentDescription*>(vc1->description);
+
+ const ContentInfo* ac2 = desc2.GetContentByName("audio");
+ const AudioContentDescription* acd2 =
+ static_cast<const AudioContentDescription*>(ac2->description);
+ const ContentInfo* vc2 = desc2.GetContentByName("video");
+ const VideoContentDescription* vcd2 =
+ static_cast<const VideoContentDescription*>(vc2->description);
+
+ // rtcp_mux
+ EXPECT_EQ(acd1->rtcp_mux(), acd2->rtcp_mux());
+ EXPECT_EQ(vcd1->rtcp_mux(), vcd2->rtcp_mux());
+
+ // cryptos
+ EXPECT_EQ(acd1->cryptos().size(), acd2->cryptos().size());
+ EXPECT_EQ(vcd1->cryptos().size(), vcd2->cryptos().size());
+ if (acd1->cryptos().size() != acd2->cryptos().size() ||
+ vcd1->cryptos().size() != vcd2->cryptos().size()) {
+ return false;
+ }
+ for (size_t i = 0; i< acd1->cryptos().size(); ++i) {
+ const CryptoParams c1 = acd1->cryptos().at(i);
+ const CryptoParams c2 = acd2->cryptos().at(i);
+ EXPECT_TRUE(c1.Matches(c2));
+ }
+ for (size_t i = 0; i< vcd1->cryptos().size(); ++i) {
+ const CryptoParams c1 = vcd1->cryptos().at(i);
+ const CryptoParams c2 = vcd2->cryptos().at(i);
+ EXPECT_TRUE(c1.Matches(c2));
+ }
+
+ // codecs
+ EXPECT_EQ(acd1->codecs().size(), acd2->codecs().size());
+ if (acd1->codecs().size() != acd2->codecs().size())
+ return false;
+ EXPECT_EQ(vcd1->codecs().size(), vcd2->codecs().size());
+ if (vcd1->codecs().size() != vcd2->codecs().size())
+ return false;
+ for (size_t i = 0; i< acd1->codecs().size(); ++i) {
+ const AudioCodec c1 = acd1->codecs().at(i);
+ const AudioCodec c2 = acd2->codecs().at(i);
+ EXPECT_TRUE(c1.Matches(c2));
+ }
+ for (size_t i = 0; i< vcd1->codecs().size(); ++i) {
+ const VideoCodec c1 = vcd1->codecs().at(i);
+ const VideoCodec c2 = vcd2->codecs().at(i);
+ EXPECT_TRUE(c1.Matches(c2));
+ EXPECT_EQ(c1.width, c2.width);
+ EXPECT_EQ(c1.height, c2.height);
+ EXPECT_EQ(c1.framerate, c2.framerate);
+ }
+
+ // streams
+ EXPECT_EQ(acd1->streams(), acd2->streams());
+ EXPECT_EQ(vcd1->streams(), vcd2->streams());
+
+ return true;
+ }
+
+ bool CompareCandidates(const Candidates& cs1, const Candidates& cs2) {
+ EXPECT_EQ(cs1.size(), cs2.size());
+ if (cs1.size() != cs2.size())
+ return false;
+ for (size_t i = 0; i< cs1.size(); ++i) {
+ const cricket::Candidate c1 = cs1.at(i);
+ const cricket::Candidate c2 = cs2.at(i);
+ EXPECT_TRUE(c1.IsEquivalent(c2));
+ }
+ return true;
+ }
+
+ bool ReplaceAndTryToParse(const char* search, const char* replace) {
+ SessionDescription desc;
+ std::vector<cricket::Candidate> candidates;
+ std::string sdp = kSdpFullString;
+ talk_base::replace_substrs(search, strlen(search), replace,
+ strlen(replace), &sdp);
+ return webrtc::SdpDeserialize(sdp, &desc, &candidates);
+ }
+
+ protected:
+ SessionDescription desc_;
+ Candidates candidates_;
+};
+
+TEST_F(WebRtcSdpTest, Serialize) {
+ std::string message = webrtc::SdpSerialize(desc_, candidates_);
+ LOG(LS_INFO) << "SDP: " << message;
+ EXPECT_EQ(std::string(kSdpFullString), message);
+}
+
+TEST_F(WebRtcSdpTest, SerializeSessionDescription) {
+ std::string message = webrtc::SdpSerializeSessionDescription(desc_);
+ EXPECT_EQ(std::string(kSdpString), message);
+}
+
+TEST_F(WebRtcSdpTest, SerializeCandidates) {
+ std::string message = webrtc::SdpSerializeCandidates(candidates_);
+ EXPECT_EQ(std::string(kSdpCandidates), message);
+}
+
+TEST_F(WebRtcSdpTest, Deserialize) {
+ SessionDescription desc;
+ std::vector<cricket::Candidate> candidates;
+ // Deserialize
+ EXPECT_TRUE(webrtc::SdpDeserialize(kSdpFullString, &desc, &candidates));
+ // Verify
+ LOG(LS_INFO) << "SDP: " << webrtc::SdpSerialize(desc, candidates);
+ EXPECT_TRUE(CompareSessionDescription(desc_, desc));
+}
+
+TEST_F(WebRtcSdpTest, DeserializeSessionDescription) {
+ SessionDescription desc;
+ EXPECT_TRUE(webrtc::SdpDeserializeSessionDescription(kSdpString, &desc));
+ EXPECT_TRUE(CompareSessionDescription(desc_, desc));
+}
+
+TEST_F(WebRtcSdpTest, DeserializeCandidates) {
+ std::vector<cricket::Candidate> candidates;
+ EXPECT_TRUE(webrtc::SdpDeserializeCandidates(kSdpCandidates, &candidates));
+ EXPECT_TRUE(CompareCandidates(candidates_, candidates));
+}
+
+TEST_F(WebRtcSdpTest, DeserializeBrokenSdp) {
+ // Broken session description
+ EXPECT_EQ(false, ReplaceAndTryToParse("v=", kSdpDestroyer));
+ EXPECT_EQ(false, ReplaceAndTryToParse("o=", kSdpDestroyer));
+ EXPECT_EQ(false, ReplaceAndTryToParse("s=", kSdpDestroyer));
+ // Broken time description
+ EXPECT_EQ(false, ReplaceAndTryToParse("t=", kSdpDestroyer));
+
+ // No group line
+ EXPECT_EQ(true, ReplaceAndTryToParse("a=group:BUNDLE audio video\r\n", ""));
+ EXPECT_EQ(true, ReplaceAndTryToParse("a=mid:audio\r\n", ""));
+ EXPECT_EQ(true, ReplaceAndTryToParse("a=mid:video\r\n", ""));
+
+ // Broken media description
+ EXPECT_EQ(true, ReplaceAndTryToParse("video 0 RTP/AVPF", kSdpDestroyer));
+}
+
+TEST_F(WebRtcSdpTest, FormatSdp) {
+ std::string full_sdp = webrtc::SdpFormat(kSdpString, kSdpCandidates);
+ EXPECT_EQ(kSdpFullString, full_sdp);
+}
diff --git a/talk/app/webrtc/webrtcsession.cc b/talk/app/webrtc/webrtcsession.cc
index de414c5..e08344c 100644
--- a/talk/app/webrtc/webrtcsession.cc
+++ b/talk/app/webrtc/webrtcsession.cc
@@ -1,6 +1,6 @@
/*
* libjingle
- * Copyright 2004--2011, Google Inc.
+ * 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:
@@ -27,498 +27,408 @@
#include "talk/app/webrtc/webrtcsession.h"
-#include <string>
-#include <vector>
-
-#include "talk/base/common.h"
-#include "talk/base/json.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/p2p/base/constants.h"
-#include "talk/p2p/base/sessiondescription.h"
-#include "talk/p2p/base/p2ptransport.h"
+#include "talk/app/webrtc/mediastream.h"
+#include "talk/app/webrtc/peerconnection.h"
+#include "talk/app/webrtc/peerconnectionsignaling.h"
+#include "talk/base/helpers.h"
+#include "talk/base/logging.h"
#include "talk/session/phone/channel.h"
#include "talk/session/phone/channelmanager.h"
-#include "talk/session/phone/mediasessionclient.h"
-#include "talk/session/phone/voicechannel.h"
+#include "talk/session/phone/mediasession.h"
+#include "talk/session/phone/videocapturer.h"
+
+using cricket::MediaContentDescription;
namespace webrtc {
enum {
MSG_CANDIDATE_TIMEOUT = 101,
+ MSG_CANDIDATE_DISCOVERY_TIMEOUT = 102,
};
-static const int kAudioMonitorPollFrequency = 100;
-static const int kMonitorPollFrequency = 1000;
-
-// We allow 30 seconds to establish a connection; beyond that we consider
-// it an error
+// We allow 30 seconds to establish a connection, otherwise it's an error.
static const int kCallSetupTimeout = 30 * 1000;
-// A loss of connectivity is probably due to the Internet connection going
-// down, and it might take a while to come back on wireless networks, so we
-// use a longer timeout for that.
-static const int kCallLostTimeout = 60 * 1000;
+static const int kCandidateDiscoveryTimeout = 2000;
-static const char kVideoStream[] = "video_rtp";
-static const char kAudioStream[] = "rtp";
+// TODO - These are magic string used by cricket::VideoChannel.
+// These should be moved to a common place.
+static const char kRtpVideoChannelStr[] = "video_rtp";
+static const char kRtcpVideoChannelStr[] = "video_rtcp";
-WebRtcSession::WebRtcSession(const std::string& id,
- bool incoming,
- cricket::PortAllocator* allocator,
- cricket::ChannelManager* channelmgr,
- talk_base::Thread* signaling_thread)
- : BaseSession(signaling_thread, channelmgr->worker_thread(),
- allocator, id, "", !incoming),
- transport_(NULL),
- channel_manager_(channelmgr),
- transports_writable_(false),
- muted_(false),
- camera_muted_(false),
- setup_timeout_(kCallSetupTimeout),
- signaling_thread_(signaling_thread),
- incoming_(incoming),
- port_allocator_(allocator),
- desc_factory_(channel_manager_) {
+// Constants for setting the default encoder size.
+// TODO: Implement proper negotiation of video resolution.
+static const int kDefaultVideoCodecId = 100;
+static const int kDefaultVideoCodecFramerate = 30;
+static const char kDefaultVideoCodecName[] = "VP8";
+static const int kDefaultVideoCodecWidth = 640;
+static const int kDefaultVideoCodecHeight = 480;
+
+// MediaSessionDescriptionFactory always creates one StreamParams for
+// legacy reasons even if options don't contain any streams.
+// We need to remove it in that case since here options contains all streams
+// we want to send.
+// TODO: This is placed in the wrong file. Can we solve this problem by
+// adding a method MediaSessionDescriptionFactory::set_add_legacy_streams(false)
+// to prevent it from creating legacy streams.
+static void RemoveLegacyStreams(const cricket::MediaSessionOptions& options,
+ cricket::SessionDescription* description) {
+ bool found_audio_stream = false;
+ bool found_video_stream = false;
+ for (cricket::MediaSessionOptions::Streams::const_iterator it =
+ options.streams.begin();
+ it != options.streams.end(); ++it) {
+ if (it->type == cricket::MEDIA_TYPE_AUDIO)
+ found_audio_stream = true;
+
+ if (it->type == cricket::MEDIA_TYPE_VIDEO)
+ found_video_stream = true;
+ }
+ if (found_audio_stream == false) {
+ const cricket::ContentInfo* audio_info =
+ cricket::GetFirstAudioContent(description);
+ if (audio_info) {
+ const cricket::MediaContentDescription* const_media_desc =
+ static_cast<const cricket::MediaContentDescription*>(
+ audio_info->description);
+ cricket::MediaContentDescription* media_desc =
+ const_cast<cricket::MediaContentDescription*> (const_media_desc);
+ media_desc->mutable_streams().clear();
+ }
+ }
+ if (found_video_stream == false) {
+ const cricket::ContentInfo* video_info =
+ cricket::GetFirstVideoContent(description);
+ if (video_info) {
+ const cricket::MediaContentDescription* const_media_desc =
+ static_cast<const cricket::MediaContentDescription*>(
+ video_info->description);
+ cricket::MediaContentDescription* media_desc =
+ const_cast<cricket::MediaContentDescription*> (const_media_desc);
+ media_desc->mutable_streams().clear();
+ }
+ }
+}
+
+WebRtcSession::WebRtcSession(cricket::ChannelManager* channel_manager,
+ talk_base::Thread* signaling_thread,
+ talk_base::Thread* worker_thread,
+ cricket::PortAllocator* port_allocator)
+ : cricket::BaseSession(signaling_thread, worker_thread, port_allocator,
+ talk_base::ToString(talk_base::CreateRandomId()),
+ cricket::NS_JINGLE_RTP, true),
+ channel_manager_(channel_manager),
+ observer_(NULL),
+ session_desc_factory_(channel_manager),
+ offer_sent_(false) {
}
WebRtcSession::~WebRtcSession() {
- RemoveAllStreams();
- // TODO: Do we still need Terminate?
- // if (state_ != STATE_RECEIVEDTERMINATE) {
- // Terminate();
- // }
- if (transport_) {
- delete transport_;
- transport_ = NULL;
+ Terminate();
+}
+
+bool WebRtcSession::Initialize() {
+ // By default SRTP-SDES is enabled in WebRtc.
+ set_secure_policy(cricket::SEC_REQUIRED);
+
+ const cricket::VideoCodec default_codec(kDefaultVideoCodecId,
+ kDefaultVideoCodecName, kDefaultVideoCodecWidth, kDefaultVideoCodecHeight,
+ kDefaultVideoCodecFramerate, 0);
+ channel_manager_->SetDefaultVideoEncoderConfig(
+ cricket::VideoEncoderConfig(default_codec));
+
+ return CreateChannels();
+}
+
+void WebRtcSession::Terminate() {
+ if (voice_channel_.get()) {
+ channel_manager_->DestroyVoiceChannel(voice_channel_.release());
+ }
+ if (video_channel_.get()) {
+ channel_manager_->DestroyVideoChannel(video_channel_.release());
}
}
-bool WebRtcSession::Initiate() {
- if (signaling_thread_ == NULL)
+void WebRtcSession::set_secure_policy(
+ cricket::SecureMediaPolicy secure_policy) {
+ session_desc_factory_.set_secure(secure_policy);
+}
+
+bool WebRtcSession::CreateChannels() {
+ voice_channel_.reset(channel_manager_->CreateVoiceChannel(
+ this, cricket::CN_AUDIO, true));
+ if (!voice_channel_.get()) {
+ LOG(LS_ERROR) << "Failed to create voice channel";
return false;
+ }
- transport_ = CreateTransport();
-
- if (transport_ == NULL)
+ video_channel_.reset(channel_manager_->CreateVideoChannel(
+ this, cricket::CN_VIDEO, true, voice_channel_.get()));
+ if (!video_channel_.get()) {
+ LOG(LS_ERROR) << "Failed to create video channel";
return false;
+ }
- transport_->set_allow_local_ips(true);
-
- // start transports
- transport_->SignalRequestSignaling.connect(
- this, &WebRtcSession::OnRequestSignaling);
- transport_->SignalCandidatesReady.connect(
- this, &WebRtcSession::OnCandidatesReady);
- transport_->SignalWritableState.connect(
- this, &WebRtcSession::OnWritableState);
- // Limit the amount of time that setting up a call may take.
- StartTransportTimeout(kCallSetupTimeout);
+ // TransportProxies and TransportChannels will be created when
+ // CreateVoiceChannel and CreateVideoChannel are called.
+ // Try connecting all transport channels. This is necessary to generate
+ // ICE candidates.
+ SpeculativelyConnectAllTransportChannels();
+ signaling_thread()->PostDelayed(
+ kCandidateDiscoveryTimeout, this, MSG_CANDIDATE_DISCOVERY_TIMEOUT);
return true;
}
-cricket::Transport* WebRtcSession::CreateTransport() {
+// Enabling voice and video channel.
+void WebRtcSession::EnableChannels() {
+ if (!voice_channel_->enabled())
+ voice_channel_->Enable(true);
+
+ if (!video_channel_->enabled())
+ video_channel_->Enable(true);
+}
+
+void WebRtcSession::OnTransportRequestSignaling(
+ cricket::Transport* transport) {
ASSERT(signaling_thread()->IsCurrent());
- return new cricket::P2PTransport(
- talk_base::Thread::Current(),
- channel_manager_->worker_thread(), port_allocator());
-}
-
-bool WebRtcSession::CreateVoiceChannel(const std::string& stream_id) {
- // RTCP disabled
- cricket::VoiceChannel* voice_channel =
- channel_manager_->CreateVoiceChannel(this, stream_id, true);
- if (voice_channel == NULL) {
- LOG(LERROR) << "Unable to create voice channel.";
- return false;
- }
- StreamInfo* stream_info = new StreamInfo(stream_id);
- stream_info->channel = voice_channel;
- stream_info->video = false;
- streams_.push_back(stream_info);
- return true;
-}
-
-bool WebRtcSession::CreateVideoChannel(const std::string& stream_id) {
- // RTCP disabled
- cricket::VideoChannel* video_channel =
- channel_manager_->CreateVideoChannel(this, stream_id, true, NULL);
- if (video_channel == NULL) {
- LOG(LERROR) << "Unable to create video channel.";
- return false;
- }
- StreamInfo* stream_info = new StreamInfo(stream_id);
- stream_info->channel = video_channel;
- stream_info->video = true;
- streams_.push_back(stream_info);
- return true;
-}
-
-cricket::TransportChannel* WebRtcSession::CreateChannel(
- const std::string& content_name,
- const std::string& name) {
- if (!transport_) {
- return NULL;
- }
- std::string type;
- if (content_name.compare(kVideoStream) == 0) {
- type = cricket::NS_GINGLE_VIDEO;
- } else {
- type = cricket::NS_GINGLE_AUDIO;
- }
- cricket::TransportChannel* transport_channel =
- transport_->CreateChannel(name, type);
- ASSERT(transport_channel != NULL);
- return transport_channel;
-}
-
-cricket::TransportChannel* WebRtcSession::GetChannel(
- const std::string& content_name, const std::string& name) {
- if (!transport_)
- return NULL;
-
- return transport_->GetChannel(name);
-}
-
-void WebRtcSession::DestroyChannel(
- const std::string& content_name, const std::string& name) {
- if (!transport_)
- return;
-
- transport_->DestroyChannel(name);
-}
-
-void WebRtcSession::OnMessage(talk_base::Message* message) {
- switch (message->message_id) {
- case MSG_CANDIDATE_TIMEOUT:
- if (transport_->writable()) {
- // This should never happen: The timout triggered even
- // though a call was successfully set up.
- ASSERT(false);
- }
- SignalFailedCall();
- break;
- default:
- cricket::BaseSession::OnMessage(message);
- break;
- }
-}
-
-bool WebRtcSession::Connect() {
- if (streams_.empty()) {
- // nothing to initiate
- return false;
- }
- // lets connect all the transport channels created before for this session
- transport_->ConnectChannels();
-
- // create an offer now. This is to call SetState
- // Actual offer will be send when OnCandidatesReady callback received
- cricket::SessionDescription* offer = CreateOffer();
- set_local_description(offer);
- SetState((incoming()) ? STATE_SENTACCEPT : STATE_SENTINITIATE);
-
- // Enable all the channels
- EnableAllStreams();
- SetVideoCapture(true);
- return true;
-}
-
-bool WebRtcSession::SetVideoRenderer(const std::string& stream_id,
- cricket::VideoRenderer* renderer) {
- bool ret = false;
- StreamMap::iterator iter;
- for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
- StreamInfo* stream_info = (*iter);
- if (stream_info->stream_id.compare(stream_id) == 0) {
- ASSERT(stream_info->channel != NULL);
- ASSERT(stream_info->video);
- cricket::VideoChannel* channel = static_cast<cricket::VideoChannel*>(
- stream_info->channel);
- ret = channel->SetRenderer(0, renderer);
- break;
- }
- }
- return ret;
-}
-
-bool WebRtcSession::SetVideoCapture(bool capture) {
- channel_manager_->SetVideoCapture(capture);
- return true;
-}
-
-bool WebRtcSession::RemoveStream(const std::string& stream_id) {
- bool ret = false;
- StreamMap::iterator iter;
- for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
- StreamInfo* sinfo = (*iter);
- if (sinfo->stream_id.compare(stream_id) == 0) {
- if (!sinfo->video) {
- cricket::VoiceChannel* channel = static_cast<cricket::VoiceChannel*> (
- sinfo->channel);
- channel->Enable(false);
- // Note: If later the channel is used by multiple streams, then we
- // should not destroy the channel until all the streams are removed.
- channel_manager_->DestroyVoiceChannel(channel);
- } else {
- cricket::VideoChannel* channel = static_cast<cricket::VideoChannel*> (
- sinfo->channel);
- channel->Enable(false);
- // Note: If later the channel is used by multiple streams, then we
- // should not destroy the channel until all the streams are removed.
- channel_manager_->DestroyVideoChannel(channel);
- }
- // channel and transport will be deleted in
- // DestroyVoiceChannel/DestroyVideoChannel
- streams_.erase(iter);
- ret = true;
- break;
- }
- }
- if (!ret) {
- LOG(LERROR) << "No streams found for stream id " << stream_id;
- // TODO: trigger onError callback
- }
- return ret;
-}
-
-void WebRtcSession::EnableAllStreams() {
- StreamMap::const_iterator i;
- for (i = streams_.begin(); i != streams_.end(); ++i) {
- cricket::BaseChannel* channel = (*i)->channel;
- if (channel)
- channel->Enable(true);
- }
-}
-
-void WebRtcSession::RemoveAllStreams() {
- SetState(STATE_RECEIVEDTERMINATE);
-
- // signaling_thread_->Post(this, MSG_RTC_REMOVEALLSTREAMS);
- // First build a list of streams to remove and then remove them.
- // The reason we do this is that if we remove the streams inside the
- // loop, a stream might get removed while we're enumerating and the iterator
- // will become invalid (and we crash).
- // streams_ entry will be removed from ChannelManager callback method
- // DestroyChannel
- std::vector<std::string> streams_to_remove;
- StreamMap::iterator iter;
- for (iter = streams_.begin(); iter != streams_.end(); ++iter)
- streams_to_remove.push_back((*iter)->stream_id);
-
- for (std::vector<std::string>::iterator i = streams_to_remove.begin();
- i != streams_to_remove.end(); ++i) {
- RemoveStream(*i);
- }
-}
-
-bool WebRtcSession::HasStream(const std::string& stream_id) const {
- StreamMap::const_iterator iter;
- for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
- StreamInfo* sinfo = (*iter);
- if (stream_id.compare(sinfo->stream_id) == 0) {
- return true;
- }
- }
- return false;
-}
-
-bool WebRtcSession::HasChannel(bool video) const {
- StreamMap::const_iterator iter;
- for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
- StreamInfo* sinfo = (*iter);
- if (sinfo->video == video) {
- return true;
- }
- }
- return false;
-}
-
-bool WebRtcSession::HasAudioChannel() const {
- return HasChannel(false);
-}
-
-bool WebRtcSession::HasVideoChannel() const {
- return HasChannel(true);
-}
-
-void WebRtcSession::OnRequestSignaling(cricket::Transport* transport) {
transport->OnSignalingReady();
}
-void WebRtcSession::OnWritableState(cricket::Transport* transport) {
- ASSERT(transport == transport_);
- const bool transports_writable = transport_->writable();
- if (transports_writable) {
- if (transports_writable != transports_writable_) {
- signaling_thread_->Clear(this, MSG_CANDIDATE_TIMEOUT);
- } else {
- // At one point all channels were writable and we had full connectivity,
- // but then we lost it. Start the timeout again to kill the call if it
- // doesn't come back.
- StartTransportTimeout(kCallLostTimeout);
- }
- transports_writable_ = transports_writable;
+void WebRtcSession::OnTransportConnecting(cricket::Transport* transport) {
+ ASSERT(signaling_thread()->IsCurrent());
+ // start monitoring for the write state of the transport.
+ OnTransportWritable(transport);
+}
+
+void WebRtcSession::OnTransportWritable(cricket::Transport* transport) {
+ ASSERT(signaling_thread()->IsCurrent());
+ // If the transport is not in writable state, start a timer to monitor
+ // the state. If the transport doesn't become writable state in 30 seconds
+ // then we are assuming call can't be continued.
+ signaling_thread()->Clear(this, MSG_CANDIDATE_TIMEOUT);
+ if (transport->HasChannels() && !transport->writable()) {
+ signaling_thread()->PostDelayed(
+ kCallSetupTimeout, this, MSG_CANDIDATE_TIMEOUT);
}
- NotifyTransportState();
- return;
}
-void WebRtcSession::StartTransportTimeout(int timeout) {
- talk_base::Thread::Current()->PostDelayed(timeout, this,
- MSG_CANDIDATE_TIMEOUT,
- NULL);
+void WebRtcSession::OnTransportCandidatesReady(
+ cricket::Transport* transport, const cricket::Candidates& candidates) {
+ ASSERT(signaling_thread()->IsCurrent());
+ // Any new candidates after offer is sent will be dropped here.
+ if (offer_sent_)
+ return;
+ InsertTransportCandidates(candidates);
}
-void WebRtcSession::NotifyTransportState() {
+void WebRtcSession::SendCandidates() {
+ ASSERT(!local_candidates_.empty());
+ observer_->OnCandidatesReady(local_candidates_);
+ offer_sent_ = true;
}
-bool WebRtcSession::OnInitiateMessage(
- cricket::SessionDescription* offer,
- const std::vector<cricket::Candidate>& candidates) {
- if (!offer) {
- LOG(LERROR) << "No SessionDescription from peer";
+void WebRtcSession::OnTransportChannelGone(cricket::Transport* transport,
+ const std::string& name) {
+ ASSERT(signaling_thread()->IsCurrent());
+}
+
+void WebRtcSession::OnMessage(talk_base::Message* msg) {
+ switch (msg->message_id) {
+ case MSG_CANDIDATE_TIMEOUT:
+ LOG(LS_ERROR) << "Transport is not in writable state.";
+ SignalError();
+ break;
+ case MSG_CANDIDATE_DISCOVERY_TIMEOUT:
+ SendCandidates();
+ break;
+ default:
+ break;
+ }
+}
+
+void WebRtcSession::InsertTransportCandidates(
+ const cricket::Candidates& candidates) {
+ for (cricket::Candidates::const_iterator citer = candidates.begin();
+ citer != candidates.end(); ++citer) {
+ local_candidates_.push_back(*citer);
+ }
+}
+
+bool WebRtcSession::SetCaptureDevice(const std::string& name,
+ cricket::VideoCapturer* camera) {
+ // should be called from a signaling thread
+ ASSERT(signaling_thread()->IsCurrent());
+
+ // TODO: Refactor this when there is support for multiple cameras.
+ const uint32 dummy_ssrc = 0;
+ if (!channel_manager_->SetVideoCapturer(camera, dummy_ssrc)) {
+ LOG(LS_ERROR) << "Failed to set capture device.";
return false;
}
- // Get capabilities from offer before generating an answer to it.
- cricket::MediaSessionOptions options;
- if (GetFirstAudioContent(offer))
- options.has_audio = true;
- if (GetFirstVideoContent(offer))
- options.has_video = true;
-
- talk_base::scoped_ptr<cricket::SessionDescription> answer;
- answer.reset(CreateAnswer(offer, options));
-
- if (!answer.get()) {
+ // Start the capture
+ cricket::CaptureResult ret = channel_manager_->SetVideoCapture(true);
+ if (ret != cricket::CR_SUCCESS && ret != cricket::CR_PENDING) {
+ LOG(LS_ERROR) << "Failed to start the capture device.";
return false;
}
- const cricket::ContentInfo* audio_content = GetFirstAudioContent(
- answer.get());
- const cricket::ContentInfo* video_content = GetFirstVideoContent(
- answer.get());
+ return true;
+}
- if (!audio_content && !video_content) {
- return false;
+void WebRtcSession::SetLocalRenderer(const std::string& name,
+ cricket::VideoRenderer* renderer) {
+ ASSERT(signaling_thread()->IsCurrent());
+ // TODO: Fix SetLocalRenderer.
+ // video_channel_->SetLocalRenderer(0, renderer);
+}
+
+void WebRtcSession::SetRemoteRenderer(const std::string& name,
+ cricket::VideoRenderer* renderer) {
+ ASSERT(signaling_thread()->IsCurrent());
+
+ const cricket::ContentInfo* video_info =
+ cricket::GetFirstVideoContent(remote_description());
+ if (!video_info) {
+ LOG(LS_ERROR) << "Video not received in this call";
}
- bool ret = true;
- if (audio_content) {
- ret = !HasAudioChannel() &&
- CreateVoiceChannel(audio_content->name);
- if (!ret) {
- LOG(LERROR) << "Failed to create voice channel for "
- << audio_content->name;
- return false;
- }
- }
-
- if (video_content) {
- ret = !HasVideoChannel() &&
- CreateVideoChannel(video_content->name);
- if (!ret) {
- LOG(LERROR) << "Failed to create video channel for "
- << video_content->name;
- return false;
- }
- }
- // Provide remote candidates to the transport
- transport_->OnRemoteCandidates(candidates);
-
- set_remote_description(offer);
- SetState(STATE_RECEIVEDINITIATE);
-
- transport_->ConnectChannels();
- EnableAllStreams();
-
- set_local_description(answer.release());
-
- // AddStream called only once with Video label
- if (video_content) {
- SignalAddStream(video_content->name, true);
+ const cricket::MediaContentDescription* video_content =
+ static_cast<const cricket::MediaContentDescription*>(
+ video_info->description);
+ cricket::StreamParams stream;
+ if (cricket::GetStreamByNickAndName(video_content->streams(), "", name,
+ &stream)) {
+ video_channel_->SetRenderer(stream.first_ssrc(), renderer);
} else {
- SignalAddStream(audio_content->name, false);
+ // Allow that |stream| does not exist if renderer is null but assert
+ // otherwise.
+ VERIFY(renderer == NULL);
}
- SetState(STATE_SENTACCEPT);
- return true;
}
-bool WebRtcSession::OnRemoteDescription(
- cricket::SessionDescription* desc,
- const std::vector<cricket::Candidate>& candidates) {
- if (state() == STATE_SENTACCEPT ||
- state() == STATE_RECEIVEDACCEPT ||
- state() == STATE_INPROGRESS) {
- transport_->OnRemoteCandidates(candidates);
- return true;
+cricket::SessionDescription* WebRtcSession::CreateOffer(
+ const cricket::MediaSessionOptions& options) {
+ if (!options.has_video) {
+ LOG(LS_WARNING) << "To receive video, has_video flag must be set to true";
+ return NULL;
}
- // Session description is always accepted.
- set_remote_description(desc);
- SetState(STATE_RECEIVEDACCEPT);
- // Will trigger OnWritableState() if successful.
- transport_->OnRemoteCandidates(candidates);
- if (!incoming()) {
- // Trigger OnAddStream callback at the initiator
- const cricket::ContentInfo* video_content = GetFirstVideoContent(desc);
- if (video_content && !SendSignalAddStream(true)) {
- LOG(LERROR) << "Video stream unexpected in answer.";
- return false;
- } else {
- const cricket::ContentInfo* audio_content = GetFirstAudioContent(desc);
- if (audio_content && !SendSignalAddStream(false)) {
- LOG(LERROR) << "Audio stream unexpected in answer.";
- return false;
- }
- }
- }
- return true;
-}
+ cricket::SessionDescription* offer(
+ session_desc_factory_.CreateOffer(options, local_description()));
-// Send the SignalAddStream with the stream_id based on the content type.
-bool WebRtcSession::SendSignalAddStream(bool video) {
- StreamMap::const_iterator iter;
- for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
- StreamInfo* sinfo = (*iter);
- if (sinfo->video == video) {
- SignalAddStream(sinfo->stream_id, video);
- return true;
- }
- }
- return false;
-}
-
-cricket::SessionDescription* WebRtcSession::CreateOffer() {
- cricket::MediaSessionOptions options;
- options.has_audio = false; // disable default option
- StreamMap::const_iterator iter;
- for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
- if ((*iter)->video) {
- options.has_video = true;
- } else {
- options.has_audio = true;
- }
- }
- return desc_factory_.CreateOffer(options);
+ // MediaSessionDescriptionFactory always creates one StreamParams for
+ // legacy reasons even if options don't contain any streams.
+ // We need to remove it in that case since here options contains all streams
+ // we want to send.
+ RemoveLegacyStreams(options, offer);
+ return offer;
}
cricket::SessionDescription* WebRtcSession::CreateAnswer(
const cricket::SessionDescription* offer,
const cricket::MediaSessionOptions& options) {
- return desc_factory_.CreateAnswer(offer, options);
+ cricket::SessionDescription* answer(
+ session_desc_factory_.CreateAnswer(offer, options,
+ local_description()));
+ // MediaSessionDescriptionFactory always creates one StreamParams for
+ // legacy reasons even if options don't contain any streams.
+ // We need to remove it in that case since here options contains all streams
+ // we want to send.
+ RemoveLegacyStreams(options, answer);
+ return answer;
}
-void WebRtcSession::SetError(Error error) {
- BaseSession::SetError(error);
-}
-
-void WebRtcSession::OnCandidatesReady(
- cricket::Transport* transport,
- const std::vector<cricket::Candidate>& candidates) {
- std::vector<cricket::Candidate>::const_iterator iter;
- for (iter = candidates.begin(); iter != candidates.end(); ++iter) {
- local_candidates_.push_back(*iter);
+void WebRtcSession::SetLocalDescription(const cricket::SessionDescription* desc,
+ cricket::ContentAction type) {
+ if (!VERIFY((type == cricket::CA_ANSWER &&
+ state() == STATE_RECEIVEDINITIATE) ||
+ (type == cricket::CA_OFFER &&
+ (state() != STATE_RECEIVEDINITIATE &&
+ state() != STATE_SENTINITIATE)))) {
+ LOG(LS_ERROR) << "SetLocalDescription called with action in wrong state, "
+ << "action: " << type << " state: " << state();
+ return;
}
- SignalLocalDescription(local_description(), candidates);
+
+ set_local_description(desc);
+ if (type == cricket::CA_ANSWER) {
+ EnableChannels();
+ SetState(STATE_SENTACCEPT);
+ } else {
+ SetState(STATE_SENTINITIATE);
+ }
}
-} /* namespace webrtc */
+
+void WebRtcSession::SetRemoteDescription(cricket::SessionDescription* desc,
+ cricket::ContentAction type) {
+ if (!VERIFY((type == cricket::CA_ANSWER &&
+ state() == STATE_SENTINITIATE) ||
+ (type == cricket::CA_OFFER &&
+ (state() != STATE_RECEIVEDINITIATE &&
+ state() != STATE_SENTINITIATE)))) {
+ LOG(LS_ERROR) << "SetRemoteDescription called with action in wrong state, "
+ << "action: " << type << " state: " << state();
+ return;
+ }
+ set_remote_description(desc);
+
+ if (type == cricket::CA_ANSWER) {
+ EnableChannels();
+ SetState(STATE_RECEIVEDACCEPT);
+ } else {
+ SetState(STATE_RECEIVEDINITIATE);
+ }
+}
+
+void WebRtcSession::SetRemoteCandidates(
+ const cricket::Candidates& candidates) {
+ // First partition the candidates for the proxies. During creation of channels
+ // we created CN_AUDIO (audio) and CN_VIDEO (video) proxies.
+ cricket::Candidates audio_candidates;
+ cricket::Candidates video_candidates;
+ for (cricket::Candidates::const_iterator citer = candidates.begin();
+ citer != candidates.end(); ++citer) {
+ if (((*citer).name().compare(kRtpVideoChannelStr) == 0) ||
+ ((*citer).name().compare(kRtcpVideoChannelStr)) == 0) {
+ // Candidate names for video rtp and rtcp channel
+ video_candidates.push_back(*citer);
+ } else {
+ // Candidates for audio rtp and rtcp channel
+ // Channel name will be "rtp" and "rtcp"
+ audio_candidates.push_back(*citer);
+ }
+ }
+
+ // TODO: Justins comment:This is bad encapsulation, suggest we add a
+ // helper to BaseSession to allow us to
+ // pass in candidates without touching the transport proxies.
+ if (!audio_candidates.empty()) {
+ cricket::TransportProxy* audio_proxy = GetTransportProxy(cricket::CN_AUDIO);
+ if (audio_proxy) {
+ // CompleteNegotiation will set actual impl's in Proxy.
+ if (!audio_proxy->negotiated())
+ audio_proxy->CompleteNegotiation();
+ // TODO - Add a interface to TransportProxy to accept
+ // remote candidate list.
+ audio_proxy->impl()->OnRemoteCandidates(audio_candidates);
+ } else {
+ LOG(LS_INFO) << "No audio TransportProxy exists";
+ }
+ }
+
+ if (!video_candidates.empty()) {
+ cricket::TransportProxy* video_proxy = GetTransportProxy(cricket::CN_VIDEO);
+ if (video_proxy) {
+ // CompleteNegotiation will set actual impl's in Proxy.
+ if (!video_proxy->negotiated())
+ video_proxy->CompleteNegotiation();
+ // TODO - Add a interface to TransportProxy to accept
+ // remote candidate list.
+ video_proxy->impl()->OnRemoteCandidates(video_candidates);
+ } else {
+ LOG(LS_INFO) << "No video TransportProxy exists";
+ }
+ }
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/webrtcsession.h b/talk/app/webrtc/webrtcsession.h
index 6338d25..3f8967e 100644
--- a/talk/app/webrtc/webrtcsession.h
+++ b/talk/app/webrtc/webrtcsession.h
@@ -1,6 +1,6 @@
/*
* libjingle
- * Copyright 2004--2011, Google Inc.
+ * 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:
@@ -28,178 +28,114 @@
#ifndef TALK_APP_WEBRTC_WEBRTCSESSION_H_
#define TALK_APP_WEBRTC_WEBRTCSESSION_H_
-#include <map>
#include <string>
#include <vector>
-#include "talk/base/logging.h"
-#include "talk/base/messagehandler.h"
-#include "talk/p2p/base/candidate.h"
+#include "talk/app/webrtc/mediastreamprovider.h"
+#include "talk/app/webrtc/sessiondescriptionprovider.h"
+#include "talk/app/webrtc/webrtcsessionobserver.h"
+#include "talk/base/sigslot.h"
+#include "talk/base/thread.h"
#include "talk/p2p/base/session.h"
-#include "talk/session/phone/channel.h"
-#include "talk/session/phone/mediachannel.h"
#include "talk/session/phone/mediasession.h"
namespace cricket {
+
class ChannelManager;
class Transport;
-class TransportChannel;
-class VoiceChannel;
+class VideoCapturer;
class VideoChannel;
-struct ConnectionInfo;
-}
+class VoiceChannel;
-namespace Json {
-class Value;
-}
+} // namespace cricket
namespace webrtc {
-typedef std::vector<cricket::AudioCodec> AudioCodecs;
-typedef std::vector<cricket::VideoCodec> VideoCodecs;
-
-class WebRtcSession : public cricket::BaseSession {
+class WebRtcSession : public cricket::BaseSession,
+ public MediaProviderInterface,
+ public SessionDescriptionProvider {
public:
- WebRtcSession(const std::string& id,
- bool incoming,
- cricket::PortAllocator* allocator,
- cricket::ChannelManager* channelmgr,
- talk_base::Thread* signaling_thread);
+ WebRtcSession(cricket::ChannelManager* channel_manager,
+ talk_base::Thread* signaling_thread,
+ talk_base::Thread* worker_thread,
+ cricket::PortAllocator* port_allocator);
+ virtual ~WebRtcSession();
- ~WebRtcSession();
+ bool Initialize();
- bool Initiate();
- bool Connect();
- bool OnRemoteDescription(cricket::SessionDescription* sdp,
- const std::vector<cricket::Candidate>& candidates);
- bool OnInitiateMessage(cricket::SessionDescription* sdp,
- const std::vector<cricket::Candidate>& candidates);
- bool CreateVoiceChannel(const std::string& stream_id);
- bool CreateVideoChannel(const std::string& stream_id);
- bool RemoveStream(const std::string& stream_id);
- void RemoveAllStreams();
-
- // Returns true if we have either a voice or video stream matching this label.
- bool HasStream(const std::string& label) const;
- bool HasChannel(bool video) const;
-
- // Returns true if there's one or more audio channels in the session.
- bool HasAudioChannel() const;
-
- // Returns true if there's one or more video channels in the session.
- bool HasVideoChannel() const;
-
- bool SetVideoRenderer(const std::string& stream_id,
- cricket::VideoRenderer* renderer);
-
- // This signal occurs when all the streams have been removed.
- // It is triggered by a successful call to the RemoveAllStream or
- // the OnRemoteDescription with stream deleted signaling message with the
- // candidates port equal to 0.
- sigslot::signal1<WebRtcSession*> SignalRemoveStreamMessage;
-
- // This signal indicates a stream has been added properly.
- // It is triggered by a successful call to the OnInitiateMessage or
- // the OnRemoteDescription and if it's going to the STATE_RECEIVEDACCEPT.
- sigslot::signal2<const std::string&, bool> SignalAddStream;
-
- // This signal occurs when one stream is removed with the signaling
- // message from the remote peer with the candidates port equal to 0.
- sigslot::signal2<const std::string&, bool> SignalRemoveStream;
-
- // This signal occurs when the local candidate is ready
- sigslot::signal2<const cricket::SessionDescription*,
- const std::vector<cricket::Candidate>&> SignalLocalDescription;
-
- // This signal triggers when setting up or resuming a call has not been
- // successful before a certain time out.
- sigslot::signal0<> SignalFailedCall;
-
- bool muted() const { return muted_; }
- bool camera_muted() const { return camera_muted_; }
- const std::vector<cricket::Candidate>& local_candidates() {
- return local_candidates_;
+ void RegisterObserver(WebRtcSessionObserver* observer) {
+ observer_ = observer;
}
- void set_incoming(bool incoming) { incoming_ = incoming; }
- bool incoming() const { return incoming_; }
- cricket::PortAllocator* port_allocator() const { return port_allocator_; }
- talk_base::Thread* signaling_thread() const { return signaling_thread_; }
- protected:
- // methods from cricket::BaseSession
- virtual void SetError(cricket::BaseSession::Error error);
- virtual cricket::TransportChannel* CreateChannel(
- const std::string& content_name, const std::string& name);
- virtual cricket::TransportChannel* GetChannel(
- const std::string& content_name, const std::string& name);
- virtual void DestroyChannel(
- const std::string& content_name, const std::string& name);
+ const cricket::VoiceChannel* voice_channel() const {
+ return voice_channel_.get();
+ }
+ const cricket::VideoChannel* video_channel() const {
+ return video_channel_.get();
+ }
+
+ void set_secure_policy(cricket::SecureMediaPolicy secure_policy);
+ cricket::SecureMediaPolicy secure_policy() const {
+ return session_desc_factory_.secure();
+ }
+
+ // Generic error message callback from WebRtcSession.
+ // TODO - It may be necessary to supply error code as well.
+ sigslot::signal0<> SignalError;
+
+ // Implements SessionDescriptionProvider
+ virtual cricket::SessionDescription* CreateOffer(
+ const cricket::MediaSessionOptions& options);
+ virtual cricket::SessionDescription* CreateAnswer(
+ const cricket::SessionDescription* offer,
+ const cricket::MediaSessionOptions& options);
+ virtual void SetLocalDescription(const cricket::SessionDescription* desc,
+ cricket::ContentAction type);
+ virtual void SetRemoteDescription(cricket::SessionDescription* desc,
+ cricket::ContentAction type);
+ virtual void SetRemoteCandidates(
+ const std::vector<cricket::Candidate>& remote_candidates);
+ virtual const cricket::SessionDescription* local_description() const {
+ return cricket::BaseSession::local_description();
+ }
+ virtual const cricket::SessionDescription* remote_description() const {
+ return cricket::BaseSession::remote_description();
+ }
private:
- struct StreamInfo {
- explicit StreamInfo(const std::string stream_id)
- : channel(NULL),
- video(false),
- stream_id(stream_id) {}
+ // Implements MediaProviderInterface.
+ virtual bool SetCaptureDevice(const std::string& name,
+ cricket::VideoCapturer* camera);
+ virtual void SetLocalRenderer(const std::string& name,
+ cricket::VideoRenderer* renderer);
+ virtual void SetRemoteRenderer(const std::string& name,
+ cricket::VideoRenderer* renderer);
- StreamInfo()
- : channel(NULL),
- video(false) {}
- cricket::BaseChannel* channel;
- bool video;
- std::string stream_id;
- };
- // Not really a map (vector).
- typedef std::vector<StreamInfo*> StreamMap;
+ // Transport related callbacks, override from cricket::BaseSession.
+ virtual void OnTransportRequestSignaling(cricket::Transport* transport);
+ virtual void OnTransportConnecting(cricket::Transport* transport);
+ virtual void OnTransportWritable(cricket::Transport* transport);
+ virtual void OnTransportCandidatesReady(
+ cricket::Transport* transport,
+ const cricket::Candidates& candidates);
+ virtual void OnTransportChannelGone(cricket::Transport* transport,
+ const std::string& name);
- // methods signaled by the transport
- void OnRequestSignaling(cricket::Transport* transport);
- void OnCandidatesReady(cricket::Transport* transport,
- const std::vector<cricket::Candidate>& candidates);
- void OnWritableState(cricket::Transport* transport);
- void OnTransportError(cricket::Transport* transport);
- void OnChannelGone(cricket::Transport* transport);
+ // Creates channels for voice and video.
+ bool CreateChannels();
+ void EnableChannels();
+ virtual void OnMessage(talk_base::Message* msg);
+ void InsertTransportCandidates(const cricket::Candidates& candidates);
+ void Terminate();
+ void SendCandidates();
- bool CheckForStreamDeleteMessage(
- const std::vector<cricket::Candidate>& candidates);
- void ProcessTerminateAccept(cricket::SessionDescription* desc);
-
- void UpdateTransportWritableState();
- bool CheckAllTransportsWritable();
- void StartTransportTimeout(int timeout);
- void NotifyTransportState();
-
- cricket::SessionDescription* CreateOffer();
- cricket::SessionDescription* CreateAnswer(
- const cricket::SessionDescription* answer,
- const cricket::MediaSessionOptions& options);
-
- // from MessageHandler
- virtual void OnMessage(talk_base::Message* message);
-
- virtual cricket::Transport* CreateTransport();
- cricket::Transport* GetTransport();
-
- typedef std::map<std::string, cricket::TransportChannel*> TransportChannelMap;
-
- bool SetVideoCapture(bool capture);
- void EnableAllStreams();
- bool SendSignalAddStream(bool video);
-
- cricket::Transport* transport_;
+ talk_base::scoped_ptr<cricket::VoiceChannel> voice_channel_;
+ talk_base::scoped_ptr<cricket::VideoChannel> video_channel_;
cricket::ChannelManager* channel_manager_;
- std::vector<StreamInfo*> streams_;
- TransportChannelMap transport_channels_;
- bool transports_writable_;
- bool muted_;
- bool camera_muted_;
- int setup_timeout_;
- std::vector<cricket::Candidate> local_candidates_;
-
- talk_base::Thread* signaling_thread_;
- bool incoming_;
- cricket::PortAllocator* port_allocator_;
- cricket::MediaSessionDescriptionFactory desc_factory_;
+ cricket::Candidates local_candidates_;
+ WebRtcSessionObserver* observer_;
+ cricket::MediaSessionDescriptionFactory session_desc_factory_;
+ bool offer_sent_;
};
} // namespace webrtc
diff --git a/talk/app/webrtc/webrtcsession_unittest.cc b/talk/app/webrtc/webrtcsession_unittest.cc
index 7a07614..9fb9b1d 100644
--- a/talk/app/webrtc/webrtcsession_unittest.cc
+++ b/talk/app/webrtc/webrtcsession_unittest.cc
@@ -1,6 +1,6 @@
/*
* libjingle
- * Copyright 2004--2011, Google Inc.
+ * 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:
@@ -25,383 +25,423 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include <stdio.h>
-
-#include <list>
-
-#include "base/gunit.h"
-#include "base/helpers.h"
-#include "talk/app/webrtc/unittest_utilities.h"
#include "talk/app/webrtc/webrtcsession.h"
+#include "talk/base/logging.h"
#include "talk/base/fakenetwork.h"
-#include "talk/base/scoped_ptr.h"
+#include "talk/base/firewallsocketserver.h"
+#include "talk/base/gunit.h"
+#include "talk/base/network.h"
+#include "talk/base/physicalsocketserver.h"
#include "talk/base/thread.h"
-#include "talk/p2p/base/portallocator.h"
-#include "talk/p2p/base/sessiondescription.h"
-#include "talk/p2p/client/fakeportallocator.h"
-#include "talk/session/phone/fakesession.h"
-#include "talk/session/phone/mediasessionclient.h"
+#include "talk/base/virtualsocketserver.h"
+#include "talk/p2p/base/stunserver.h"
+#include "talk/p2p/base/teststunserver.h"
+#include "talk/p2p/client/basicportallocator.h"
+#include "talk/session/phone/channelmanager.h"
+#include "talk/session/phone/fakedevicemanager.h"
+#include "talk/session/phone/fakemediaengine.h"
+#include "talk/session/phone/mediasession.h"
-class WebRtcSessionTest
- : public sigslot::has_slots<>,
- public testing::Test {
+using talk_base::SocketAddress;
+static const SocketAddress kClientAddr1("11.11.11.11", 0);
+static const SocketAddress kClientAddr2("22.22.22.22", 0);
+static const SocketAddress kStunAddr("99.99.99.1", cricket::STUN_SERVER_PORT);
+
+static const char kStream1[] = "stream1";
+static const char kVideoTrack1[] = "video1";
+static const char kAudioTrack1[] = "audio1";
+
+static const char kStream2[] = "stream2";
+static const char kVideoTrack2[] = "video2";
+static const char kAudioTrack2[] = "audio2";
+
+
+class MockWebRtcSessionObserver : public webrtc::WebRtcSessionObserver {
public:
- enum CallbackId {
- kNone,
- kOnAddStream,
- kOnRemoveStream,
- kOnLocalDescription,
- kOnFailedCall,
- };
-
- WebRtcSessionTest()
- : callback_ids_(),
- last_stream_id_(""),
- last_was_video_(false),
- last_description_ptr_(NULL),
- last_candidates_(),
- session_(NULL),
- id_(),
- receiving_(false),
- allocator_(NULL),
- channel_manager_(NULL),
- worker_thread_(NULL),
- signaling_thread_(NULL) {
- }
-
- ~WebRtcSessionTest() {
- session_.reset();
- }
-
- void OnAddStream(const std::string& stream_id, bool video) {
- callback_ids_.push_back(kOnAddStream);
- last_stream_id_ = stream_id;
- last_was_video_ = video;
- }
- void OnRemoveStream(const std::string& stream_id, bool video) {
- callback_ids_.push_back(kOnRemoveStream);
- last_stream_id_ = stream_id;
- last_was_video_ = video;
- }
- void OnLocalDescription(
- const cricket::SessionDescription* desc,
+ virtual void OnCandidatesReady(
const std::vector<cricket::Candidate>& candidates) {
- callback_ids_.push_back(kOnLocalDescription);
- last_description_ptr_.reset(CopySessionDescription(desc));
- CopyCandidates(candidates, &last_candidates_);
- }
- cricket::SessionDescription* GetLocalDescription(
- std::vector<cricket::Candidate>* candidates) {
- if (last_candidates_.empty()) {
- return NULL;
+ for (cricket::Candidates::const_iterator iter = candidates.begin();
+ iter != candidates.end(); ++iter) {
+ candidates_.push_back(*iter);
+ LOG(LS_INFO) << iter->ToString();
}
- if (!last_description_ptr_.get()) {
- return NULL;
- }
- CopyCandidates(last_candidates_, candidates);
- return CopySessionDescription(last_description_ptr_.get());
}
-
- void OnFailedCall() {
- callback_ids_.push_back(kOnFailedCall);
- }
-
- CallbackId PopOldestCallback() {
- if (callback_ids_.empty()) {
- return kNone;
- }
- const CallbackId return_value = callback_ids_.front();
- callback_ids_.pop_front();
- return return_value;
- }
-
- CallbackId PeekOldestCallback() {
- if (callback_ids_.empty()) {
- return kNone;
- }
- const CallbackId return_value = callback_ids_.front();
- return return_value;
- }
-
- void Reset() {
- callback_ids_.clear();
- last_stream_id_ = "";
- last_was_video_ = false;
- last_description_ptr_.reset();
- last_candidates_.clear();
- }
-
- bool WaitForCallback(CallbackId id, int timeout_ms) {
- bool success = false;
- for (int ms = 0; ms < timeout_ms; ms++) {
- const CallbackId peek_id = PeekOldestCallback();
- if (peek_id == id) {
- PopOldestCallback();
- success = true;
- break;
- } else if (peek_id != kNone) {
- success = false;
- break;
- }
- talk_base::Thread::Current()->ProcessMessages(1);
- }
- return success;
- }
-
- bool Init(bool receiving) {
- if (signaling_thread_ != NULL)
- return false;
- signaling_thread_ = talk_base::Thread::Current();
- receiving_ = receiving;
-
- if (worker_thread_!= NULL)
- return false;
- worker_thread_ = talk_base::Thread::Current();
-
- cricket::FakePortAllocator* fake_port_allocator =
- new cricket::FakePortAllocator(worker_thread_, NULL);
-
- allocator_.reset(static_cast<cricket::PortAllocator*>(fake_port_allocator));
-
- channel_manager_.reset(new cricket::ChannelManager(worker_thread_));
- if (!channel_manager_->Init())
- return false;
-
- talk_base::CreateRandomString(8, &id_);
-
- session_.reset(new webrtc::WebRtcSession(
- id_, receiving_ , allocator_.get(),
- channel_manager_.get(),
- signaling_thread_));
- session_->SignalAddStream.connect(this, &WebRtcSessionTest::OnAddStream);
- session_->SignalRemoveStream.connect(this,
- &WebRtcSessionTest::OnRemoveStream);
- session_->SignalLocalDescription.connect(this,
- &WebRtcSessionTest::OnLocalDescription);
- session_->SignalFailedCall.connect(this, &WebRtcSessionTest::OnFailedCall);
- return true;
- }
-
- // All session APIs must be called from the signaling thread.
- bool CallInitiate() {
- return session_->Initiate();
- }
-
- bool CallConnect() {
- if (!session_->Connect())
- return false;
- // This callback does not happen with FakeTransport!
- if (!WaitForCallback(kOnLocalDescription, 1000)) {
- return false;
- }
- return true;
- }
-
- bool CallOnRemoteDescription(
- cricket::SessionDescription* description,
- std::vector<cricket::Candidate> candidates) {
- if (!session_->OnRemoteDescription(description, candidates)) {
- return false;
- }
- if (!WaitForCallback(kOnAddStream, 1000)) {
- return false;
- }
- return true;
- }
-
- bool CallOnInitiateMessage(
- cricket::SessionDescription* description,
- const std::vector<cricket::Candidate>& candidates) {
- if (!session_->OnInitiateMessage(description, candidates)) {
- return false;
- }
- if (!WaitForCallback(kOnAddStream, 1000)) {
- return false;
- }
- return true;
- }
-
- bool CallCreateVoiceChannel(const std::string& stream_id) {
- if (!session_->CreateVoiceChannel(stream_id)) {
- return false;
- }
- return true;
- }
-
- bool CallCreateVideoChannel(const std::string& stream_id) {
- if (!session_->CreateVideoChannel(stream_id)) {
- return false;
- }
- return true;
- }
-
- bool CallRemoveStream(const std::string& stream_id) {
- return session_->RemoveStream(stream_id);
- }
-
- void CallRemoveAllStreams() {
- session_->RemoveAllStreams();
- }
-
- bool CallHasChannel(const std::string& label) {
- return session_->HasStream(label);
- }
-
- bool CallHasChannel(bool video) {
- return session_->HasChannel(video);
- }
-
- bool CallHasAudioChannel() {
- return session_->HasAudioChannel();
- }
-
- bool CallHasVideoChannel() {
- return session_->HasVideoChannel();
- }
-
- bool CallSetVideoRenderer(const std::string& stream_id,
- cricket::VideoRenderer* renderer) {
- return session_->SetVideoRenderer(stream_id, renderer);
- }
-
- const std::vector<cricket::Candidate>& CallLocalCandidates() {
- return session_->local_candidates();
- }
-
- private:
- std::list<CallbackId> callback_ids_;
-
- std::string last_stream_id_;
- bool last_was_video_;
- talk_base::scoped_ptr<cricket::SessionDescription> last_description_ptr_;
- std::vector<cricket::Candidate> last_candidates_;
-
- talk_base::scoped_ptr<webrtc::WebRtcSession> session_;
- std::string id_;
- bool receiving_;
-
- talk_base::scoped_ptr<cricket::PortAllocator> allocator_;
-
- talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
-
- talk_base::Thread* worker_thread_;
- talk_base::Thread* signaling_thread_;
+ std::vector<cricket::Candidate> candidates_;
};
-bool CallbackReceived(WebRtcSessionTest* session, int timeout) {
- EXPECT_EQ_WAIT(WebRtcSessionTest::kNone, session->PeekOldestCallback(),
- timeout);
- const WebRtcSessionTest::CallbackId peek_id =
- session->PeekOldestCallback();
- return peek_id != WebRtcSessionTest::kNone;
-}
+class WebRtcSessionForTest : public webrtc::WebRtcSession {
+ public:
+ WebRtcSessionForTest(cricket::ChannelManager* cmgr,
+ talk_base::Thread* signaling_thread,
+ talk_base::Thread* worker_thread,
+ cricket::PortAllocator* port_allocator)
+ : WebRtcSession(cmgr, signaling_thread, worker_thread, port_allocator) {
+ }
+ virtual ~WebRtcSessionForTest() {}
-TEST_F(WebRtcSessionTest, InitializationReceiveSanity) {
- const bool kReceiving = true;
- ASSERT_TRUE(Init(kReceiving));
- ASSERT_TRUE(CallInitiate());
+ using webrtc::WebRtcSession::CreateOffer;
+ using webrtc::WebRtcSession::CreateAnswer;
+ using webrtc::WebRtcSession::SetLocalDescription;
+ using webrtc::WebRtcSession::SetRemoteDescription;
+ using webrtc::WebRtcSession::SetRemoteCandidates;
+};
- // Should return false because no stream has been set up yet.
- EXPECT_FALSE(CallConnect());
- const bool kVideo = true;
- EXPECT_FALSE(CallHasChannel(kVideo));
- EXPECT_FALSE(CallHasChannel(!kVideo));
-
- EXPECT_EQ(kNone, PopOldestCallback());
-}
-
-TEST_F(WebRtcSessionTest, AudioSendCallSetUp) {
- const bool kReceiving = false;
- ASSERT_TRUE(Init(kReceiving));
-
- ASSERT_TRUE(CallInitiate());
-
- ASSERT_TRUE(CallCreateVoiceChannel("Audio"));
- ASSERT_TRUE(CallConnect());
-
- std::vector<cricket::Candidate> candidates;
- cricket::SessionDescription* local_session = GetLocalDescription(
- &candidates);
- ASSERT_FALSE(candidates.empty());
- ASSERT_FALSE(local_session == NULL);
- if (!CallOnRemoteDescription(local_session, candidates)) {
- delete local_session;
- FAIL();
+class WebRtcSessionTest : public testing::Test {
+ protected:
+ // TODO Investigate why ChannelManager crashes, if it's created
+ // after stun_server.
+ WebRtcSessionTest()
+ : media_engine(new cricket::FakeMediaEngine()),
+ device_manager(new cricket::FakeDeviceManager()),
+ channel_manager_(new cricket::ChannelManager(
+ media_engine, device_manager, talk_base::Thread::Current())),
+ desc_factory_(new cricket::MediaSessionDescriptionFactory(
+ channel_manager_.get())),
+ pss_(new talk_base::PhysicalSocketServer),
+ vss_(new talk_base::VirtualSocketServer(pss_.get())),
+ fss_(new talk_base::FirewallSocketServer(vss_.get())),
+ ss_scope_(fss_.get()),
+ stun_server_(talk_base::Thread::Current(), kStunAddr),
+ allocator_(&network_manager_, kStunAddr,
+ SocketAddress(), SocketAddress(), SocketAddress()) {
+ EXPECT_TRUE(channel_manager_->Init());
}
- // All callbacks should be caught. Assert it.
- ASSERT_FALSE(CallbackReceived(this, 1000));
- ASSERT_TRUE(CallHasAudioChannel() &&
- !CallHasVideoChannel());
-}
-
-TEST_F(WebRtcSessionTest, VideoSendCallSetUp) {
- const bool kReceiving = false;
- ASSERT_TRUE(Init(kReceiving));
-
- ASSERT_TRUE(CallInitiate());
-
- ASSERT_TRUE(CallCreateVideoChannel("Video"));
- ASSERT_TRUE(CallConnect());
-
- std::vector<cricket::Candidate> candidates;
- cricket::SessionDescription* local_session = GetLocalDescription(
- &candidates);
- ASSERT_FALSE(candidates.empty());
- ASSERT_FALSE(local_session == NULL);
-
- if (!CallOnRemoteDescription(local_session, candidates)) {
- delete local_session;
- FAIL();
+ bool InitializeSession() {
+ return session_->Initialize();
}
- // All callbacks should be caught. Assert it.
- ASSERT_FALSE(CallbackReceived(this, 1000));
- ASSERT_TRUE(!CallHasAudioChannel() &&
- CallHasVideoChannel());
+ void AddInterface(const SocketAddress& addr) {
+ network_manager_.AddInterface(addr);
+ }
+
+ void Init() {
+ ASSERT_TRUE(session_.get() == NULL);
+ session_.reset(new WebRtcSessionForTest(
+ channel_manager_.get(), talk_base::Thread::Current(),
+ talk_base::Thread::Current(), &allocator_));
+ session_->RegisterObserver(&observer_);
+
+ EXPECT_TRUE(session_->Initialize());
+
+ video_channel_ = media_engine->GetVideoChannel(0);
+ voice_channel_ = media_engine->GetVoiceChannel(0);
+ }
+
+ void PopulateFakeCandidates() {
+ const int num_of_channels = 4;
+ const char* const channel_names[num_of_channels] = {
+ "rtp", "rtcp", "video_rtp", "video_rtcp"
+ };
+
+ // max 4 transport channels;
+ candidates_.clear();
+ for (int i = 0; i < num_of_channels; ++i) {
+ cricket::Candidate candidate;
+ candidate.set_name(channel_names[i]);
+ candidates_.push_back(candidate);
+ }
+ }
+
+ // Create a session description based on options. Used for testing but don't
+ // test WebRtcSession.
+ cricket::SessionDescription* CreateTestOffer(
+ const cricket::MediaSessionOptions& options) {
+ desc_factory_->set_secure(cricket::SEC_REQUIRED);
+ return desc_factory_->CreateOffer(options, NULL);
+ }
+
+ // Create a session description based on options. Used for testing but don't
+ // test WebRtcSession.
+ cricket::SessionDescription* CreateTestAnswer(
+ const cricket::SessionDescription* offer,
+ const cricket::MediaSessionOptions& options) {
+ desc_factory_->set_secure(cricket::SEC_REQUIRED);
+ return desc_factory_->CreateAnswer(offer, options, NULL);
+ }
+
+ cricket::MediaSessionOptions OptionsWithStream1() {
+ cricket::MediaSessionOptions options;
+ options.AddStream(cricket::MEDIA_TYPE_VIDEO, kVideoTrack1, kStream1);
+ options.AddStream(cricket::MEDIA_TYPE_AUDIO, kAudioTrack1, kStream1);
+ return options;
+ }
+
+ cricket::MediaSessionOptions OptionsWithStream2() {
+ cricket::MediaSessionOptions options;
+ options.AddStream(cricket::MEDIA_TYPE_VIDEO, kVideoTrack2, kStream2);
+ options.AddStream(cricket::MEDIA_TYPE_AUDIO, kAudioTrack2, kStream2);
+ return options;
+ }
+
+ cricket::MediaSessionOptions OptionsWithStream1And2() {
+ cricket::MediaSessionOptions options;
+ options.AddStream(cricket::MEDIA_TYPE_VIDEO, kVideoTrack1, kStream1);
+ options.AddStream(cricket::MEDIA_TYPE_AUDIO, kAudioTrack1, kStream1);
+ options.AddStream(cricket::MEDIA_TYPE_VIDEO, kVideoTrack2, kStream2);
+ options.AddStream(cricket::MEDIA_TYPE_AUDIO, kAudioTrack2, kStream2);
+ return options;
+ }
+
+ cricket::MediaSessionOptions OptionsReceiveOnly() {
+ cricket::MediaSessionOptions options;
+ options.has_video = true;
+ return options;
+ }
+
+ bool ChannelsExist() {
+ return (session_->voice_channel() != NULL &&
+ session_->video_channel() != NULL);
+ }
+
+ void CheckTransportChannels() {
+ EXPECT_TRUE(session_->GetChannel(cricket::CN_AUDIO, "rtp") != NULL);
+ EXPECT_TRUE(session_->GetChannel(cricket::CN_AUDIO, "rtcp") != NULL);
+ EXPECT_TRUE(session_->GetChannel(cricket::CN_VIDEO, "video_rtp") != NULL);
+ EXPECT_TRUE(session_->GetChannel(cricket::CN_VIDEO, "video_rtcp") != NULL);
+ }
+
+ void VerifyCryptoParams(const cricket::SessionDescription* sdp,
+ bool offer) {
+ ASSERT_TRUE(session_.get() != NULL);
+ const cricket::ContentInfo* content = cricket::GetFirstAudioContent(sdp);
+ ASSERT_TRUE(content != NULL);
+ const cricket::AudioContentDescription* audio_content =
+ static_cast<const cricket::AudioContentDescription*>(
+ content->description);
+ ASSERT_TRUE(audio_content != NULL);
+ if (offer) {
+ ASSERT_EQ(2U, audio_content->cryptos().size());
+ // key(40) + inline string
+ ASSERT_EQ(47U, audio_content->cryptos()[0].key_params.size());
+ ASSERT_EQ("AES_CM_128_HMAC_SHA1_32",
+ audio_content->cryptos()[0].cipher_suite);
+ ASSERT_EQ("AES_CM_128_HMAC_SHA1_80",
+ audio_content->cryptos()[1].cipher_suite);
+ ASSERT_EQ(47U, audio_content->cryptos()[1].key_params.size());
+ } else {
+ ASSERT_EQ(1U, audio_content->cryptos().size());
+ // key(40) + inline string
+ ASSERT_EQ(47U, audio_content->cryptos()[0].key_params.size());
+ ASSERT_EQ("AES_CM_128_HMAC_SHA1_32",
+ audio_content->cryptos()[0].cipher_suite);
+ }
+
+ content = cricket::GetFirstVideoContent(sdp);
+ ASSERT_TRUE(content != NULL);
+ const cricket::VideoContentDescription* video_content =
+ static_cast<const cricket::VideoContentDescription*>(
+ content->description);
+ ASSERT_TRUE(video_content != NULL);
+ ASSERT_EQ(1U, video_content->cryptos().size());
+ ASSERT_EQ("AES_CM_128_HMAC_SHA1_80",
+ video_content->cryptos()[0].cipher_suite);
+ ASSERT_EQ(47U, video_content->cryptos()[0].key_params.size());
+ }
+
+ void VerifyNoCryptoParams(const cricket::SessionDescription* sdp) {
+ const cricket::ContentInfo* content = cricket::GetFirstAudioContent(sdp);
+ ASSERT_TRUE(content != NULL);
+ const cricket::AudioContentDescription* audio_content =
+ static_cast<const cricket::AudioContentDescription*>(
+ content->description);
+ ASSERT_TRUE(audio_content != NULL);
+ ASSERT_EQ(0U, audio_content->cryptos().size());
+
+ content = cricket::GetFirstVideoContent(sdp);
+ ASSERT_TRUE(content != NULL);
+ const cricket::VideoContentDescription* video_content =
+ static_cast<const cricket::VideoContentDescription*>(
+ content->description);
+ ASSERT_TRUE(video_content != NULL);
+ ASSERT_EQ(0U, video_content->cryptos().size());
+ }
+
+ void VerifyAnswerFromNonCryptoOffer() {
+ // Create a SDP without Crypto.
+ desc_factory_->set_secure(cricket::SEC_DISABLED);
+ cricket::MediaSessionOptions options;
+ options.has_video = true;
+ cricket::SessionDescription* offer =
+ desc_factory_->CreateOffer(options, NULL);
+ ASSERT_TRUE(offer != NULL);
+ VerifyNoCryptoParams(offer);
+ const cricket::SessionDescription* answer =
+ session_->CreateAnswer(offer, options);
+ // Answer should be NULL as no crypto params in offer.
+ ASSERT_TRUE(answer == NULL);
+ }
+
+ void VerifyAnswerFromCryptoOffer() {
+ desc_factory_->set_secure(cricket::SEC_REQUIRED);
+ cricket::MediaSessionOptions options;
+ options.has_video = true;
+ cricket::SessionDescription* offer =
+ desc_factory_->CreateOffer(options, NULL);
+ ASSERT_TRUE(offer != NULL);
+ VerifyCryptoParams(offer, true);
+ const cricket::SessionDescription* answer =
+ session_->CreateAnswer(offer, options);
+ ASSERT_TRUE(answer != NULL);
+ VerifyCryptoParams(answer, false);
+ }
+
+ cricket::FakeMediaEngine* media_engine;
+ cricket::FakeDeviceManager* device_manager;
+ talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
+ talk_base::scoped_ptr<cricket::MediaSessionDescriptionFactory> desc_factory_;
+ talk_base::scoped_ptr<talk_base::PhysicalSocketServer> pss_;
+ talk_base::scoped_ptr<talk_base::VirtualSocketServer> vss_;
+ talk_base::scoped_ptr<talk_base::FirewallSocketServer> fss_;
+ talk_base::SocketServerScope ss_scope_;
+ cricket::TestStunServer stun_server_;
+ talk_base::FakeNetworkManager network_manager_;
+ cricket::BasicPortAllocator allocator_;
+ talk_base::scoped_ptr<WebRtcSessionForTest> session_;
+ MockWebRtcSessionObserver observer_;
+ std::vector<cricket::Candidate> candidates_;
+ cricket::FakeVideoMediaChannel* video_channel_;
+ cricket::FakeVoiceMediaChannel* voice_channel_;
+};
+
+TEST_F(WebRtcSessionTest, TestInitialize) {
+ WebRtcSessionTest::Init();
+ EXPECT_TRUE(ChannelsExist());
+ CheckTransportChannels();
}
-TEST_F(WebRtcSessionTest, AudioReceiveCallSetUp) {
- const bool kReceiving = true;
- const bool video = false;
-
- ASSERT_TRUE(Init(kReceiving));
-
- std::vector<cricket::Candidate> candidates;
- cricket::SessionDescription* local_session =
- GenerateFakeSession(video, &candidates);
- ASSERT_FALSE(candidates.empty());
- ASSERT_FALSE(local_session == NULL);
- ASSERT_TRUE(CallInitiate());
- if (!CallOnInitiateMessage(local_session, candidates)) {
- delete local_session;
- FAIL();
- }
- ASSERT_TRUE(CallConnect());
- ASSERT_FALSE(CallbackReceived(this, 1000));
-
- ASSERT_TRUE(CallHasAudioChannel() &&
- !CallHasVideoChannel());
+TEST_F(WebRtcSessionTest, TestSessionCandidates) {
+ AddInterface(kClientAddr1);
+ WebRtcSessionTest::Init();
+ EXPECT_EQ_WAIT(8u, observer_.candidates_.size(), 3000);
}
-TEST_F(WebRtcSessionTest, VideoReceiveCallSetUp) {
- const bool kReceiving = true;
- const bool video = true;
+TEST_F(WebRtcSessionTest, TestMultihomeCandidataes) {
+ AddInterface(kClientAddr1);
+ AddInterface(kClientAddr2);
+ WebRtcSessionTest::Init();
+ EXPECT_EQ_WAIT(16u, observer_.candidates_.size(), 3000);
+}
- ASSERT_TRUE(Init(kReceiving));
+TEST_F(WebRtcSessionTest, TestStunError) {
+ AddInterface(kClientAddr1);
+ AddInterface(kClientAddr2);
+ fss_->AddRule(false, talk_base::FP_UDP, talk_base::FD_ANY, kClientAddr1);
+ WebRtcSessionTest::Init();
+ // Since kClientAddr1 is blocked, not expecting stun candidates for it.
+ EXPECT_EQ_WAIT(12u, observer_.candidates_.size(), 3000);
+}
- std::vector<cricket::Candidate> candidates;
- cricket::SessionDescription* local_session =
- GenerateFakeSession(video, &candidates);
- ASSERT_FALSE(candidates.empty());
- ASSERT_FALSE(local_session == NULL);
- ASSERT_TRUE(CallInitiate());
- if (!CallOnInitiateMessage(local_session, candidates)) {
- delete local_session;
- FAIL();
- }
- ASSERT_TRUE(CallConnect());
- ASSERT_FALSE(CallbackReceived(this, 1000));
- ASSERT_TRUE(!CallHasAudioChannel() &&
- CallHasVideoChannel());
+// Test creating offers and receive answers and make sure the
+// media engine creates the expected send and receive streams.
+TEST_F(WebRtcSessionTest, TestCreateOfferReceiveAnswer) {
+ WebRtcSessionTest::Init();
+ cricket::MediaSessionOptions options = OptionsWithStream1();
+ cricket::SessionDescription* offer = session_->CreateOffer(options);
+
+
+ cricket::MediaSessionOptions options2 = OptionsWithStream2();
+ cricket::SessionDescription* answer = CreateTestAnswer(offer, options2);
+
+
+ session_->SetLocalDescription(offer, cricket::CA_OFFER);
+ session_->SetRemoteDescription(answer, cricket::CA_ANSWER);
+
+ ASSERT_EQ(1u, video_channel_->recv_streams().size());
+ cricket::StreamParams recv_video_stream =
+ video_channel_->recv_streams()[0];
+ EXPECT_TRUE(kVideoTrack2 == recv_video_stream.name);
+
+ ASSERT_EQ(1u, voice_channel_->recv_streams().size());
+ cricket::StreamParams recv_audio_stream =
+ voice_channel_->recv_streams()[0];
+ EXPECT_TRUE(kAudioTrack2 == recv_audio_stream.name);
+
+ ASSERT_EQ(1u, video_channel_->send_streams().size());
+ EXPECT_TRUE(kVideoTrack1 == video_channel_->send_streams()[0].name);
+ ASSERT_EQ(1u, voice_channel_->send_streams().size());
+ EXPECT_TRUE(kAudioTrack1 == voice_channel_->send_streams()[0].name);
+
+ // Create new offer without send streams.
+ offer = session_->CreateOffer(OptionsReceiveOnly());
+ // Test with same answer.
+ session_->SetLocalDescription(offer, cricket::CA_OFFER);
+ session_->SetRemoteDescription(answer, cricket::CA_ANSWER);
+
+ EXPECT_EQ(0u, video_channel_->send_streams().size());
+ EXPECT_EQ(0u, voice_channel_->send_streams().size());
+
+ // Make sure the receive streams have not changed.
+ ASSERT_EQ(1u, video_channel_->recv_streams().size());
+ EXPECT_EQ(recv_video_stream, video_channel_->recv_streams()[0]);
+ ASSERT_EQ(1u, voice_channel_->recv_streams().size());
+ EXPECT_EQ(recv_audio_stream, voice_channel_->recv_streams()[0]);
+}
+
+// Test receiving offers and creating answers and make sure the
+// media engine creates the expected send and receive streams.
+TEST_F(WebRtcSessionTest, TestReceiveOfferCreateAnswer) {
+ WebRtcSessionTest::Init();
+ cricket::SessionDescription* offer = CreateTestOffer(OptionsWithStream2());
+
+ cricket::MediaSessionOptions answer_options = OptionsWithStream1();
+ cricket::SessionDescription* answer =
+ session_->CreateAnswer(offer, answer_options);
+ session_->SetRemoteDescription(offer, cricket::CA_OFFER);
+ session_->SetLocalDescription(answer, cricket::CA_ANSWER);
+
+ ASSERT_EQ(1u, video_channel_->recv_streams().size());
+ EXPECT_TRUE(kVideoTrack2 == video_channel_->recv_streams()[0].name);
+
+ ASSERT_EQ(1u, voice_channel_->recv_streams().size());
+ EXPECT_TRUE(kAudioTrack2 == voice_channel_->recv_streams()[0].name);
+
+ ASSERT_EQ(1u, video_channel_->send_streams().size());
+ EXPECT_TRUE(kVideoTrack1 == video_channel_->send_streams()[0].name);
+ ASSERT_EQ(1u, voice_channel_->send_streams().size());
+ EXPECT_TRUE(kAudioTrack1 == voice_channel_->send_streams()[0].name);
+
+ offer = CreateTestOffer(OptionsWithStream1And2());
+
+ // Answer by turning off all send streams.
+ answer = session_->CreateAnswer(offer, OptionsReceiveOnly());
+ session_->SetRemoteDescription(offer, cricket::CA_OFFER);
+ session_->SetLocalDescription(answer, cricket::CA_ANSWER);
+
+ ASSERT_EQ(2u, video_channel_->recv_streams().size());
+ EXPECT_TRUE(kVideoTrack1 == video_channel_->recv_streams()[0].name);
+ EXPECT_TRUE(kVideoTrack2 == video_channel_->recv_streams()[1].name);
+ ASSERT_EQ(2u, voice_channel_->recv_streams().size());
+ EXPECT_TRUE(kAudioTrack1 == voice_channel_->recv_streams()[0].name);
+ EXPECT_TRUE(kAudioTrack2 == voice_channel_->recv_streams()[1].name);
+
+ // Make we have no send streams.
+ EXPECT_EQ(0u, video_channel_->send_streams().size());
+ EXPECT_EQ(0u, voice_channel_->send_streams().size());
+}
+
+TEST_F(WebRtcSessionTest, TestDefaultSetSecurePolicy) {
+ WebRtcSessionTest::Init();
+ EXPECT_EQ(cricket::SEC_REQUIRED, session_->secure_policy());
+}
+
+TEST_F(WebRtcSessionTest, VerifyCryptoParamsInSDP) {
+ WebRtcSessionTest::Init();
+ VerifyCryptoParams(session_->CreateOffer(OptionsWithStream1()), true);
+}
+
+TEST_F(WebRtcSessionTest, VerifyNoCryptoParamsInSDP) {
+ WebRtcSessionTest::Init();
+ session_->set_secure_policy(cricket::SEC_DISABLED);
+ VerifyNoCryptoParams(session_->CreateOffer(OptionsWithStream1()));
+}
+
+TEST_F(WebRtcSessionTest, VerifyAnswerFromNonCryptoOffer) {
+ WebRtcSessionTest::Init();
+ VerifyAnswerFromNonCryptoOffer();
+}
+
+TEST_F(WebRtcSessionTest, VerifyAnswerFromCryptoOffer) {
+ WebRtcSessionTest::Init();
+ VerifyAnswerFromCryptoOffer();
}
diff --git a/talk/app/webrtc/webrtcsessionobserver.h b/talk/app/webrtc/webrtcsessionobserver.h
new file mode 100644
index 0000000..c1653c9
--- /dev/null
+++ b/talk/app/webrtc/webrtcsessionobserver.h
@@ -0,0 +1,47 @@
+/*
+ * 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_WEBRTCSESSIONOBSERVER_H_
+#define TALK_APP_WEBRTC_WEBRTCSESSIONOBSERVER_H_
+
+#include <vector>
+
+#include "talk/p2p/base/candidate.h"
+
+namespace webrtc {
+
+class WebRtcSessionObserver {
+ public:
+ virtual void OnCandidatesReady(
+ const std::vector<cricket::Candidate>& candiddates) = 0;
+ protected:
+ virtual ~WebRtcSessionObserver() {}
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_WEBRTCSESSIONOBSERVER_H_
diff --git a/talk/app/webrtcv1/peerconnection.h b/talk/app/webrtcv1/peerconnection.h
new file mode 100644
index 0000000..c28508f
--- /dev/null
+++ b/talk/app/webrtcv1/peerconnection.h
@@ -0,0 +1,131 @@
+/*
+ * libjingle
+ * Copyright 2004--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_PEERCONNECTION_H_
+#define TALK_APP_WEBRTC_PEERCONNECTION_H_
+
+// TODO - Add a factory class or some kind of PeerConnection manager
+// to support multiple PeerConnection object instantiation. This class will
+// create ChannelManager object and pass it to PeerConnection object. Otherwise
+// each PeerConnection object will have its own ChannelManager hence MediaEngine
+// and VoiceEngine/VideoEngine.
+
+#include <string>
+
+namespace cricket {
+class VideoRenderer;
+}
+
+namespace talk_base {
+class Thread;
+}
+
+namespace webrtc {
+
+class PeerConnectionObserver {
+ public:
+ // serialized signaling message
+ virtual void OnSignalingMessage(const std::string& msg) = 0;
+
+ // Triggered when a remote peer accepts a media connection.
+ virtual void OnAddStream(const std::string& stream_id, bool video) = 0;
+
+ // Triggered when a remote peer closes a media stream.
+ virtual void OnRemoveStream(const std::string& stream_id, bool video) = 0;
+
+ protected:
+ // Dtor protected as objects shouldn't be deleted via this interface.
+ virtual ~PeerConnectionObserver() {}
+};
+
+class PeerConnection {
+ public:
+ enum ReadyState {
+ NEW = 0,
+ NEGOTIATING,
+ ACTIVE,
+ CLOSED,
+ };
+
+ virtual ~PeerConnection() {}
+
+ // Register a listener
+ virtual void RegisterObserver(PeerConnectionObserver* observer) = 0;
+
+ // SignalingMessage in json format
+ virtual bool SignalingMessage(const std::string& msg) = 0;
+
+ // Asynchronously adds a local stream device to the peer
+ // connection.
+ virtual bool AddStream(const std::string& stream_id, bool video) = 0;
+
+ // Asynchronously removes a local stream device from the peer
+ // connection. The operation is complete when
+ // PeerConnectionObserver::OnRemoveStream is called.
+ virtual bool RemoveStream(const std::string& stream_id) = 0;
+
+ // Info the peerconnection that it is time to return the signaling
+ // information. The operation is complete when
+ // PeerConnectionObserver::OnSignalingMessage is called.
+ virtual bool Connect() = 0;
+
+ // Remove all the streams and tear down the session.
+ // After the Close() is called, the OnSignalingMessage will be invoked
+ // asynchronously. And before OnSignalingMessage is called,
+ // OnRemoveStream will be called for each stream that was active.
+ // TODO: Add an event such as onclose, or onreadystatechanged
+ // when the readystate reaches the closed state (no more streams in the
+ // peerconnection object.
+ virtual bool Close() = 0;
+
+ // Set the audio input & output devices based on the given device name.
+ // An empty device name means to use the default audio device.
+ virtual bool SetAudioDevice(const std::string& wave_in_device,
+ const std::string& wave_out_device,
+ int opts) = 0;
+
+ // Set the video renderer for the camera preview.
+ virtual bool SetLocalVideoRenderer(cricket::VideoRenderer* renderer) = 0;
+
+ // Set the video renderer for the specified stream.
+ virtual bool SetVideoRenderer(const std::string& stream_id,
+ cricket::VideoRenderer* renderer) = 0;
+
+ // Set video capture device
+ // For Chromium the cam_device should use the capture session id.
+ // For standalone app, cam_device is the camera name. It will try to
+ // set the default capture device when cam_device is "".
+ virtual bool SetVideoCapture(const std::string& cam_device) = 0;
+
+ // Returns the state of the PeerConnection object. See the ReadyState
+ // enum for valid values.
+ virtual ReadyState GetReadyState() = 0;
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_PEERCONNECTION_H_
diff --git a/talk/app/webrtc/peerconnectionfactory.cc b/talk/app/webrtcv1/peerconnectionfactory.cc
similarity index 90%
rename from talk/app/webrtc/peerconnectionfactory.cc
rename to talk/app/webrtcv1/peerconnectionfactory.cc
index 1b40c14..7bf2f89 100644
--- a/talk/app/webrtc/peerconnectionfactory.cc
+++ b/talk/app/webrtcv1/peerconnectionfactory.cc
@@ -25,9 +25,9 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "talk/app/webrtc/peerconnectionfactory.h"
+#include "talk/app/webrtcv1/peerconnectionfactory.h"
-#include "talk/app/webrtc/peerconnectionproxy.h"
+#include "talk/app/webrtcv1/peerconnectionproxy.h"
#include "talk/base/logging.h"
#include "talk/p2p/client/basicportallocator.h"
#include "talk/session/phone/channelmanager.h"
@@ -35,22 +35,18 @@
namespace webrtc {
PeerConnectionFactory::PeerConnectionFactory(
- cricket::PortAllocator* port_allocator,
cricket::MediaEngineInterface* media_engine,
cricket::DeviceManagerInterface* device_manager,
talk_base::Thread* worker_thread)
: initialized_(false),
- port_allocator_(port_allocator),
channel_manager_(new cricket::ChannelManager(media_engine,
device_manager,
worker_thread)) {
}
PeerConnectionFactory::PeerConnectionFactory(
- cricket::PortAllocator* port_allocator,
talk_base::Thread* worker_thread)
: initialized_(false),
- port_allocator_(port_allocator),
channel_manager_(new cricket::ChannelManager(worker_thread)) {
}
@@ -64,11 +60,12 @@
}
PeerConnection* PeerConnectionFactory::CreatePeerConnection(
+ cricket::PortAllocator* port_allocator,
talk_base::Thread* signaling_thread) {
PeerConnectionProxy* pc = NULL;
if (initialized_) {
pc = new PeerConnectionProxy(
- port_allocator_.get(), channel_manager_.get(), signaling_thread);
+ port_allocator, channel_manager_.get(), signaling_thread);
if (!pc->Init()) {
LOG(LERROR) << "Error in initializing PeerConnection";
delete pc;
diff --git a/talk/app/webrtc/peerconnectionfactory.h b/talk/app/webrtcv1/peerconnectionfactory.h
similarity index 85%
rename from talk/app/webrtc/peerconnectionfactory.h
rename to talk/app/webrtcv1/peerconnectionfactory.h
index 7c65e05..ea509d6 100644
--- a/talk/app/webrtc/peerconnectionfactory.h
+++ b/talk/app/webrtcv1/peerconnectionfactory.h
@@ -51,21 +51,20 @@
class PeerConnectionFactory {
public:
- PeerConnectionFactory(cricket::PortAllocator* port_allocator,
- cricket::MediaEngineInterface* media_engine,
+ PeerConnectionFactory(cricket::MediaEngineInterface* media_engine,
cricket::DeviceManagerInterface* device_manager,
talk_base::Thread* worker_thread);
- PeerConnectionFactory(cricket::PortAllocator* port_allocator,
- talk_base::Thread* worker_thread);
+ PeerConnectionFactory(talk_base::Thread* worker_thread);
virtual ~PeerConnectionFactory();
bool Initialize();
- PeerConnection* CreatePeerConnection(talk_base::Thread* signaling_thread);
+ PeerConnection* CreatePeerConnection(
+ cricket::PortAllocator* port_allocator,
+ talk_base::Thread* signaling_thread);
private:
bool initialized_;
- talk_base::scoped_ptr<cricket::PortAllocator> port_allocator_;
talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
};
diff --git a/talk/app/webrtcv1/peerconnectionimpl.cc b/talk/app/webrtcv1/peerconnectionimpl.cc
new file mode 100644
index 0000000..be67859
--- /dev/null
+++ b/talk/app/webrtcv1/peerconnectionimpl.cc
@@ -0,0 +1,225 @@
+/*
+ * libjingle
+ * Copyright 2004--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/webrtcv1/peerconnectionimpl.h"
+
+#include "talk/app/webrtcv1/webrtcjson.h"
+#include "talk/app/webrtcv1/webrtcsession.h"
+#include "talk/base/basicpacketsocketfactory.h"
+#include "talk/base/helpers.h"
+#include "talk/base/logging.h"
+#include "talk/base/stringencode.h"
+#include "talk/p2p/base/session.h"
+#include "talk/p2p/client/basicportallocator.h"
+
+namespace webrtc {
+
+
+PeerConnectionImpl::PeerConnectionImpl(
+ cricket::PortAllocator* port_allocator,
+ cricket::ChannelManager* channel_manager,
+ talk_base::Thread* signaling_thread)
+ : port_allocator_(port_allocator),
+ channel_manager_(channel_manager),
+ signaling_thread_(signaling_thread),
+ event_callback_(NULL),
+ session_(NULL) {
+}
+
+PeerConnectionImpl::~PeerConnectionImpl() {
+}
+
+bool PeerConnectionImpl::Init() {
+ std::string sid;
+ talk_base::CreateRandomString(8, &sid);
+ const bool incoming = false;
+ // default outgoing direction
+ session_.reset(CreateMediaSession(sid, incoming));
+ if (session_.get() == NULL) {
+ ASSERT(false && "failed to initialize a session");
+ return false;
+ }
+ return true;
+}
+
+void PeerConnectionImpl::RegisterObserver(PeerConnectionObserver* observer) {
+ // This assert is to catch cases where two observer pointers are registered.
+ // We only support one and if another is to be used, the current one must be
+ // cleared first.
+ ASSERT(observer == NULL || event_callback_ == NULL);
+ event_callback_ = observer;
+}
+
+bool PeerConnectionImpl::SignalingMessage(
+ const std::string& signaling_message) {
+ // Deserialize signaling message
+ cricket::SessionDescription* incoming_sdp = NULL;
+ std::vector<cricket::Candidate> candidates;
+ if (!ParseJsonSignalingMessage(signaling_message,
+ &incoming_sdp, &candidates)) {
+ return false;
+ }
+
+ bool ret = false;
+ if (GetReadyState() == NEW) {
+ // set direction to incoming, as message received first
+ session_->set_incoming(true);
+ ret = session_->OnInitiateMessage(incoming_sdp, candidates);
+ } else {
+ ret = session_->OnRemoteDescription(incoming_sdp, candidates);
+ }
+ return ret;
+}
+
+WebRtcSession* PeerConnectionImpl::CreateMediaSession(
+ const std::string& id, bool incoming) {
+ ASSERT(port_allocator_ != NULL);
+ WebRtcSession* session = new WebRtcSession(id, incoming,
+ port_allocator_, channel_manager_, signaling_thread_);
+
+ if (session->Initiate()) {
+ session->SignalAddStream.connect(
+ this,
+ &PeerConnectionImpl::OnAddStream);
+ session->SignalRemoveStream.connect(
+ this,
+ &PeerConnectionImpl::OnRemoveStream);
+ session->SignalLocalDescription.connect(
+ this,
+ &PeerConnectionImpl::OnLocalDescription);
+ session->SignalFailedCall.connect(
+ this,
+ &PeerConnectionImpl::OnFailedCall);
+ } else {
+ delete session;
+ session = NULL;
+ }
+ return session;
+}
+
+bool PeerConnectionImpl::AddStream(const std::string& stream_id, bool video) {
+ bool ret = false;
+ if (session_->HasStream(stream_id)) {
+ ASSERT(false && "A stream with this name already exists");
+ } else {
+ if (!video) {
+ ret = !session_->HasAudioChannel() &&
+ session_->CreateVoiceChannel(stream_id);
+ } else {
+ ret = !session_->HasVideoChannel() &&
+ session_->CreateVideoChannel(stream_id);
+ }
+ }
+ return ret;
+}
+
+bool PeerConnectionImpl::RemoveStream(const std::string& stream_id) {
+ return session_->RemoveStream(stream_id);
+}
+
+void PeerConnectionImpl::OnLocalDescription(
+ const cricket::SessionDescription* desc,
+ const std::vector<cricket::Candidate>& candidates) {
+ if (!desc) {
+ LOG(WARNING) << "no local SDP ";
+ return;
+ }
+
+ std::string message;
+ if (GetJsonSignalingMessage(desc, candidates, &message)) {
+ if (event_callback_) {
+ event_callback_->OnSignalingMessage(message);
+ }
+ }
+}
+
+void PeerConnectionImpl::OnFailedCall() {
+ // TODO: implement.
+}
+
+bool PeerConnectionImpl::SetAudioDevice(const std::string& wave_in_device,
+ const std::string& wave_out_device,
+ int opts) {
+ return channel_manager_->SetAudioOptions(wave_in_device,
+ wave_out_device,
+ opts);
+}
+
+bool PeerConnectionImpl::SetLocalVideoRenderer(
+ cricket::VideoRenderer* renderer) {
+ return channel_manager_->SetLocalRenderer(renderer);
+}
+
+bool PeerConnectionImpl::SetVideoRenderer(const std::string& stream_id,
+ cricket::VideoRenderer* renderer) {
+ return session_->SetVideoRenderer(stream_id, renderer);
+}
+
+bool PeerConnectionImpl::SetVideoCapture(const std::string& cam_device) {
+ return channel_manager_->SetVideoOptions(cam_device);
+}
+
+bool PeerConnectionImpl::Connect() {
+ return session_->Connect();
+}
+
+// TODO - Close is not used anymore, should be removed.
+bool PeerConnectionImpl::Close() {
+ session_->RemoveAllStreams();
+ return true;
+}
+
+void PeerConnectionImpl::OnAddStream(const std::string& stream_id,
+ bool video) {
+ if (event_callback_) {
+ event_callback_->OnAddStream(stream_id, video);
+ }
+}
+
+void PeerConnectionImpl::OnRemoveStream(const std::string& stream_id,
+ bool video) {
+ if (event_callback_) {
+ event_callback_->OnRemoveStream(stream_id, video);
+ }
+}
+
+PeerConnectionImpl::ReadyState PeerConnectionImpl::GetReadyState() {
+ ReadyState ready_state;
+ cricket::BaseSession::State state = session_->state();
+ if (state == cricket::BaseSession::STATE_INIT) {
+ ready_state = NEW;
+ } else if (state == cricket::BaseSession::STATE_INPROGRESS) {
+ ready_state = ACTIVE;
+ } else if (state == cricket::BaseSession::STATE_DEINIT) {
+ ready_state = CLOSED;
+ } else {
+ ready_state = NEGOTIATING;
+ }
+ return ready_state;
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtc/peerconnectionproxy.h b/talk/app/webrtcv1/peerconnectionimpl.h
similarity index 63%
copy from talk/app/webrtc/peerconnectionproxy.h
copy to talk/app/webrtcv1/peerconnectionimpl.h
index e83b4ec..8cb2414 100644
--- a/talk/app/webrtc/peerconnectionproxy.h
+++ b/talk/app/webrtcv1/peerconnectionimpl.h
@@ -25,33 +25,36 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef TALK_APP_WEBRTC_PEERCONNECTIONPROXY_H_
-#define TALK_APP_WEBRTC_PEERCONNECTIONPROXY_H_
+#ifndef TALK_APP_WEBRTC_PEERCONNECTIONIMPL_H_
+#define TALK_APP_WEBRTC_PEERCONNECTIONIMPL_H_
#include <string>
+#include <vector>
-#include "talk/app/webrtc/peerconnection.h"
+#include "talk/app/webrtcv1/peerconnection.h"
+#include "talk/base/sigslot.h"
#include "talk/base/scoped_ptr.h"
#include "talk/base/thread.h"
+#include "talk/session/phone/channelmanager.h"
namespace cricket {
class ChannelManager;
class PortAllocator;
+class SessionDescription;
}
namespace webrtc {
+class WebRtcSession;
-class PeerConnectionImpl;
-
-class PeerConnectionProxy : public PeerConnection,
- public talk_base::MessageHandler {
+class PeerConnectionImpl : public PeerConnection,
+ public sigslot::has_slots<> {
public:
- PeerConnectionProxy(cricket::PortAllocator* port_allocator,
- cricket::ChannelManager* channel_manager,
- talk_base::Thread* signaling_thread);
- virtual ~PeerConnectionProxy();
+ PeerConnectionImpl(cricket::PortAllocator* port_allocator,
+ cricket::ChannelManager* channel_manager,
+ talk_base::Thread* signaling_thread);
+ virtual ~PeerConnectionImpl();
- // PeerConnection interface implementation.
+ // PeerConnection interfaces
virtual void RegisterObserver(PeerConnectionObserver* observer);
virtual bool SignalingMessage(const std::string& msg);
virtual bool AddStream(const std::string& stream_id, bool video);
@@ -66,16 +69,29 @@
virtual bool SetVideoCapture(const std::string& cam_device);
virtual ReadyState GetReadyState();
- private:
+ cricket::ChannelManager* channel_manager() {
+ return channel_manager_;
+ }
+
+ // Callbacks from PeerConnectionImplCallbacks
+ void OnAddStream(const std::string& stream_id, bool video);
+ void OnRemoveStream(const std::string& stream_id, bool video);
+ void OnLocalDescription(
+ const cricket::SessionDescription* desc,
+ const std::vector<cricket::Candidate>& candidates);
+ void OnFailedCall();
bool Init();
- bool Send(uint32 id, talk_base::MessageData* data);
- virtual void OnMessage(talk_base::Message* message);
- talk_base::scoped_ptr<PeerConnectionImpl> peerconnection_impl_;
+ private:
+ WebRtcSession* CreateMediaSession(const std::string& id, bool incoming);
+
+ cricket::PortAllocator* port_allocator_;
+ cricket::ChannelManager* channel_manager_;
talk_base::Thread* signaling_thread_;
-
- friend class PeerConnectionFactory;
+ PeerConnectionObserver* event_callback_;
+ talk_base::scoped_ptr<WebRtcSession> session_;
};
-}
-#endif // TALK_APP_WEBRTC_PEERCONNECTIONPROXY_H_
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_PEERCONNECTIONIMPL_H_
diff --git a/talk/app/webrtc/peerconnectionproxy.cc b/talk/app/webrtcv1/peerconnectionproxy.cc
similarity index 98%
rename from talk/app/webrtc/peerconnectionproxy.cc
rename to talk/app/webrtcv1/peerconnectionproxy.cc
index fca3ad4..3994b00 100644
--- a/talk/app/webrtc/peerconnectionproxy.cc
+++ b/talk/app/webrtcv1/peerconnectionproxy.cc
@@ -25,9 +25,9 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "talk/app/webrtc/peerconnectionproxy.h"
+#include "talk/app/webrtcv1/peerconnectionproxy.h"
-#include "talk/app/webrtc/peerconnectionimpl.h"
+#include "talk/app/webrtcv1/peerconnectionimpl.h"
#include "talk/base/logging.h"
namespace webrtc {
diff --git a/talk/app/webrtc/peerconnectionproxy.h b/talk/app/webrtcv1/peerconnectionproxy.h
similarity index 98%
rename from talk/app/webrtc/peerconnectionproxy.h
rename to talk/app/webrtcv1/peerconnectionproxy.h
index e83b4ec..8d7fc26 100644
--- a/talk/app/webrtc/peerconnectionproxy.h
+++ b/talk/app/webrtcv1/peerconnectionproxy.h
@@ -30,7 +30,7 @@
#include <string>
-#include "talk/app/webrtc/peerconnection.h"
+#include "talk/app/webrtcv1/peerconnection.h"
#include "talk/base/scoped_ptr.h"
#include "talk/base/thread.h"
diff --git a/talk/app/webrtcv1/webrtcjson.cc b/talk/app/webrtcv1/webrtcjson.cc
new file mode 100644
index 0000000..644d76b
--- /dev/null
+++ b/talk/app/webrtcv1/webrtcjson.cc
@@ -0,0 +1,530 @@
+/*
+ * libjingle
+ * Copyright 2004--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/webrtcv1/webrtcjson.h"
+
+#ifdef WEBRTC_RELATIVE_PATH
+#include "json/json.h"
+#else
+#include "third_party/jsoncpp/json.h"
+#endif
+
+// TODO: Remove webrtcsession.h once we can get size from signaling.
+// webrtcsession.h is for kDefaultVideoCodecWidth and kDefaultVideoCodecHeight.
+#include "talk/app/webrtcv1/webrtcsession.h"
+#include "talk/base/json.h"
+#include "talk/base/logging.h"
+#include "talk/base/stringutils.h"
+#include "talk/session/phone/codec.h"
+#include "talk/session/phone/mediasessionclient.h"
+
+namespace webrtc {
+static const int kIceComponent = 1;
+static const int kIceFoundation = 1;
+
+static std::vector<Json::Value> ReadValues(const Json::Value& value,
+ const std::string& key);
+
+static bool BuildMediaMessage(
+ const cricket::ContentInfo& content_info,
+ const std::vector<cricket::Candidate>& candidates,
+ bool video,
+ Json::Value* value);
+
+static bool BuildRtpMapParams(
+ const cricket::ContentInfo& audio_offer,
+ bool video,
+ std::vector<Json::Value>* rtpmap);
+
+static void BuildCrypto(const cricket::ContentInfo& content_info,
+ bool video,
+ std::vector<Json::Value>* cryptos);
+
+
+static bool BuildAttributes(const std::vector<cricket::Candidate>& candidates,
+ bool video,
+ std::vector<Json::Value>* jcandidates);
+
+static std::string Serialize(const Json::Value& value);
+static bool Deserialize(const std::string& message, Json::Value* value);
+
+static bool ParseRtcpMux(const Json::Value& value);
+static bool ParseAudioCodec(const Json::Value& value,
+ cricket::AudioContentDescription* content);
+static bool ParseVideoCodec(const Json::Value& value,
+ cricket::VideoContentDescription* content);
+static bool ParseCrypto(const Json::Value& content,
+ cricket::MediaContentDescription* desc);
+static bool ParseIceCandidates(const Json::Value& value,
+ std::vector<cricket::Candidate>* candidates);
+
+static Json::Value ReadValue(const Json::Value& value, const std::string& key);
+static std::string ReadString(const Json::Value& value, const std::string& key);
+static uint32 ReadUInt(const Json::Value& value, const std::string& key);
+
+static void Append(Json::Value* object, const std::string& key, bool value);
+static void Append(Json::Value* object, const std::string& key, int value);
+static void Append(Json::Value* object, const std::string& key,
+ const std::string& value);
+static void Append(Json::Value* object, const std::string& key, uint32 value);
+static void Append(Json::Value* object, const std::string& key,
+ const Json::Value& value);
+static void Append(Json::Value* object,
+ const std::string& key,
+ const std::vector<Json::Value>& values);
+
+bool GetJsonSignalingMessage(
+ const cricket::SessionDescription* sdp,
+ const std::vector<cricket::Candidate>& candidates,
+ std::string* signaling_message) {
+ const cricket::ContentInfo* audio_content = GetFirstAudioContent(sdp);
+ const cricket::ContentInfo* video_content = GetFirstVideoContent(sdp);
+
+ std::vector<Json::Value> media;
+ if (audio_content) {
+ Json::Value value;
+ BuildMediaMessage(*audio_content, candidates, false, &value);
+ media.push_back(value);
+ }
+
+ if (video_content) {
+ Json::Value value;
+ BuildMediaMessage(*video_content, candidates, true, &value);
+ media.push_back(value);
+ }
+
+ Json::Value signal;
+ Append(&signal, "media", media);
+
+ // Now serialize.
+ *signaling_message = Serialize(signal);
+
+ return true;
+}
+
+bool BuildMediaMessage(
+ const cricket::ContentInfo& content_info,
+ const std::vector<cricket::Candidate>& candidates,
+ bool video,
+ Json::Value* params) {
+ if (video) {
+ Append(params, "label", 2); // always video 2
+ } else {
+ Append(params, "label", 1); // always audio 1
+ }
+
+ const cricket::MediaContentDescription* media_info =
+ static_cast<const cricket::MediaContentDescription*> (
+ content_info.description);
+ if (media_info->rtcp_mux()) {
+ Append(params, "rtcp_mux", true);
+ }
+
+ // rtpmap
+ std::vector<Json::Value> rtpmap;
+ if (!BuildRtpMapParams(content_info, video, &rtpmap)) {
+ return false;
+ }
+ Append(params, "rtpmap", rtpmap);
+
+ // crypto
+ std::vector<Json::Value> crypto;
+ BuildCrypto(content_info, video, &crypto);
+ Append(params, "crypto", crypto);
+
+ // Candidates
+ Json::Value attributes;
+ std::vector<Json::Value> jcandidates;
+ if (!BuildAttributes(candidates, video, &jcandidates)) {
+ return false;
+ }
+ Append(&attributes, "candidate", jcandidates);
+
+ Append(params, "attributes", attributes);
+ return true;
+}
+
+bool BuildRtpMapParams(const cricket::ContentInfo& content_info,
+ bool video,
+ std::vector<Json::Value>* rtpmap) {
+ if (!video) {
+ const cricket::AudioContentDescription* audio_offer =
+ static_cast<const cricket::AudioContentDescription*>(
+ content_info.description);
+
+ std::vector<cricket::AudioCodec>::const_iterator iter =
+ audio_offer->codecs().begin();
+ std::vector<cricket::AudioCodec>::const_iterator iter_end =
+ audio_offer->codecs().end();
+ for (; iter != iter_end; ++iter) {
+ Json::Value codec;
+ std::string codec_str(std::string("audio/").append(iter->name));
+ // adding clockrate
+ Append(&codec, "clockrate", iter->clockrate);
+ Append(&codec, "codec", codec_str);
+ Json::Value codec_id;
+ Append(&codec_id, talk_base::ToString(iter->id), codec);
+ rtpmap->push_back(codec_id);
+ }
+ } else {
+ const cricket::VideoContentDescription* video_offer =
+ static_cast<const cricket::VideoContentDescription*>(
+ content_info.description);
+
+ std::vector<cricket::VideoCodec>::const_iterator iter =
+ video_offer->codecs().begin();
+ std::vector<cricket::VideoCodec>::const_iterator iter_end =
+ video_offer->codecs().end();
+ for (; iter != iter_end; ++iter) {
+ Json::Value codec;
+ std::string codec_str(std::string("video/").append(iter->name));
+ Append(&codec, "codec", codec_str);
+ Json::Value codec_id;
+ Append(&codec_id, talk_base::ToString(iter->id), codec);
+ rtpmap->push_back(codec_id);
+ }
+ }
+ return true;
+}
+
+void BuildCrypto(const cricket::ContentInfo& content_info,
+ bool video,
+ std::vector<Json::Value>* cryptos) {
+ const cricket::MediaContentDescription* content_desc =
+ static_cast<const cricket::MediaContentDescription*>(
+ content_info.description);
+ std::vector<cricket::CryptoParams>::const_iterator iter =
+ content_desc->cryptos().begin();
+ std::vector<cricket::CryptoParams>::const_iterator iter_end =
+ content_desc->cryptos().end();
+ for (; iter != iter_end; ++iter) {
+ Json::Value crypto;
+ Append(&crypto, "cipher_suite", iter->cipher_suite);
+ Append(&crypto, "key_params", iter->key_params);
+ cryptos->push_back(crypto);
+ }
+}
+
+bool BuildAttributes(const std::vector<cricket::Candidate>& candidates,
+ bool video,
+ std::vector<Json::Value>* jcandidates) {
+ std::vector<cricket::Candidate>::const_iterator iter =
+ candidates.begin();
+ std::vector<cricket::Candidate>::const_iterator iter_end =
+ candidates.end();
+ for (; iter != iter_end; ++iter) {
+ if ((video && (!iter->name().compare("video_rtcp") ||
+ (!iter->name().compare("video_rtp")))) ||
+ (!video && (!iter->name().compare("rtp") ||
+ (!iter->name().compare("rtcp"))))) {
+ Json::Value candidate;
+ Append(&candidate, "component", kIceComponent);
+ Append(&candidate, "foundation", kIceFoundation);
+ Append(&candidate, "generation", iter->generation());
+ Append(&candidate, "proto", iter->protocol());
+ Append(&candidate, "priority", iter->preference_str());
+ Append(&candidate, "ip", iter->address().IPAsString());
+ Append(&candidate, "port", iter->address().PortAsString());
+ Append(&candidate, "type", iter->type());
+ Append(&candidate, "name", iter->name());
+ Append(&candidate, "network_name", iter->network_name());
+ Append(&candidate, "username", iter->username());
+ Append(&candidate, "password", iter->password());
+ jcandidates->push_back(candidate);
+ }
+ }
+ return true;
+}
+
+std::string Serialize(const Json::Value& value) {
+ Json::StyledWriter writer;
+ return writer.write(value);
+}
+
+bool Deserialize(const std::string& message, Json::Value* value) {
+ Json::Reader reader;
+ return reader.parse(message, *value);
+}
+
+bool ParseJsonSignalingMessage(const std::string& signaling_message,
+ cricket::SessionDescription** sdp,
+ std::vector<cricket::Candidate>* candidates) {
+ ASSERT(!(*sdp)); // expect this to be NULL
+ // first deserialize message
+ Json::Value value;
+ if (!Deserialize(signaling_message, &value)) {
+ return false;
+ }
+
+ // get media objects
+ std::vector<Json::Value> mlines = ReadValues(value, "media");
+ if (mlines.empty()) {
+ // no m-lines found
+ return false;
+ }
+
+ *sdp = new cricket::SessionDescription();
+
+ // get codec information
+ for (size_t i = 0; i < mlines.size(); ++i) {
+ if (mlines[i]["label"].asInt() == 1) {
+ cricket::AudioContentDescription* audio_content =
+ new cricket::AudioContentDescription();
+ ParseAudioCodec(mlines[i], audio_content);
+ audio_content->set_rtcp_mux(ParseRtcpMux(mlines[i]));
+ audio_content->SortCodecs();
+ (*sdp)->AddContent(cricket::CN_AUDIO,
+ cricket::NS_JINGLE_RTP, audio_content);
+ // crypto
+ if (!ParseCrypto(mlines[i], audio_content))
+ return false;
+ ParseIceCandidates(mlines[i], candidates);
+ } else {
+ cricket::VideoContentDescription* video_content =
+ new cricket::VideoContentDescription();
+ ParseVideoCodec(mlines[i], video_content);
+
+ video_content->set_rtcp_mux(ParseRtcpMux(mlines[i]));
+ video_content->SortCodecs();
+ (*sdp)->AddContent(cricket::CN_VIDEO,
+ cricket::NS_JINGLE_RTP, video_content);
+ if (!ParseCrypto(mlines[i], video_content))
+ return false;
+ ParseIceCandidates(mlines[i], candidates);
+ }
+ }
+ return true;
+}
+
+bool ParseRtcpMux(const Json::Value& value) {
+ Json::Value rtcp_mux(ReadValue(value, "rtcp_mux"));
+ if (!rtcp_mux.empty()) {
+ if (rtcp_mux.asBool()) {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool ParseAudioCodec(const Json::Value& value,
+ cricket::AudioContentDescription* content) {
+ std::vector<Json::Value> rtpmap(ReadValues(value, "rtpmap"));
+ if (rtpmap.empty())
+ return false;
+
+ std::vector<Json::Value>::const_iterator iter =
+ rtpmap.begin();
+ std::vector<Json::Value>::const_iterator iter_end =
+ rtpmap.end();
+ for (; iter != iter_end; ++iter) {
+ cricket::AudioCodec codec;
+ std::string pltype(iter->begin().memberName());
+ talk_base::FromString(pltype, &codec.id);
+ Json::Value codec_info((*iter)[pltype]);
+ std::string codec_name(ReadString(codec_info, "codec"));
+ std::vector<std::string> tokens;
+ talk_base::split(codec_name, '/', &tokens);
+ codec.name = tokens[1];
+ codec.clockrate = ReadUInt(codec_info, "clockrate");
+ content->AddCodec(codec);
+ }
+
+ return true;
+}
+
+bool ParseVideoCodec(const Json::Value& value,
+ cricket::VideoContentDescription* content) {
+ std::vector<Json::Value> rtpmap(ReadValues(value, "rtpmap"));
+ if (rtpmap.empty())
+ return false;
+
+ std::vector<Json::Value>::const_iterator iter =
+ rtpmap.begin();
+ std::vector<Json::Value>::const_iterator iter_end =
+ rtpmap.end();
+ for (; iter != iter_end; ++iter) {
+ cricket::VideoCodec codec;
+ std::string pltype(iter->begin().memberName());
+ talk_base::FromString(pltype, &codec.id);
+ Json::Value codec_info((*iter)[pltype]);
+ std::vector<std::string> tokens;
+ talk_base::split(codec_info["codec"].asString(), '/', &tokens);
+ codec.name = tokens[1];
+ // TODO: Remove once we can get size from signaling message.
+ codec.width = WebRtcSession::kDefaultVideoCodecWidth;
+ codec.height = WebRtcSession::kDefaultVideoCodecHeight;
+ content->AddCodec(codec);
+ }
+ return true;
+}
+
+bool ParseIceCandidates(const Json::Value& value,
+ std::vector<cricket::Candidate>* candidates) {
+ Json::Value attributes(ReadValue(value, "attributes"));
+ std::string ice_pwd(ReadString(attributes, "ice-pwd"));
+ std::string ice_ufrag(ReadString(attributes, "ice-ufrag"));
+
+ std::vector<Json::Value> jcandidates(ReadValues(attributes, "candidate"));
+
+ std::vector<Json::Value>::const_iterator iter =
+ jcandidates.begin();
+ std::vector<Json::Value>::const_iterator iter_end =
+ jcandidates.end();
+ for (; iter != iter_end; ++iter) {
+ cricket::Candidate cand;
+
+ unsigned int generation;
+ if (!GetUIntFromJsonObject(*iter, "generation", &generation))
+ return false;
+ cand.set_generation_str(talk_base::ToString(generation));
+
+ std::string proto;
+ if (!GetStringFromJsonObject(*iter, "proto", &proto))
+ return false;
+ cand.set_protocol(proto);
+
+ std::string priority;
+ if (!GetStringFromJsonObject(*iter, "priority", &priority))
+ return false;
+ cand.set_preference_str(priority);
+
+ std::string str;
+ talk_base::SocketAddress addr;
+ if (!GetStringFromJsonObject(*iter, "ip", &str))
+ return false;
+ addr.SetIP(str);
+ if (!GetStringFromJsonObject(*iter, "port", &str))
+ return false;
+ int port;
+ if (!talk_base::FromString(str, &port))
+ return false;
+ addr.SetPort(port);
+ cand.set_address(addr);
+
+ if (!GetStringFromJsonObject(*iter, "type", &str))
+ return false;
+ cand.set_type(str);
+
+ if (!GetStringFromJsonObject(*iter, "name", &str))
+ return false;
+ cand.set_name(str);
+
+ if (!GetStringFromJsonObject(*iter, "network_name", &str))
+ return false;
+ cand.set_network_name(str);
+
+ if (!GetStringFromJsonObject(*iter, "username", &str))
+ return false;
+ cand.set_username(str);
+
+ if (!GetStringFromJsonObject(*iter, "password", &str))
+ return false;
+ cand.set_password(str);
+
+ candidates->push_back(cand);
+ }
+ return true;
+}
+
+bool ParseCrypto(const Json::Value& content,
+ cricket::MediaContentDescription* desc) {
+ std::vector<Json::Value> jcryptos(ReadValues(content, "crypto"));
+ std::vector<Json::Value>::const_iterator iter =
+ jcryptos.begin();
+ std::vector<Json::Value>::const_iterator iter_end =
+ jcryptos.end();
+ for (; iter != iter_end; ++iter) {
+ cricket::CryptoParams crypto;
+
+ std::string cipher_suite;
+ if (!GetStringFromJsonObject(*iter, "cipher_suite", &cipher_suite))
+ return false;
+ crypto.cipher_suite = cipher_suite;
+
+ std::string key_params;
+ if (!GetStringFromJsonObject(*iter, "key_params", &key_params))
+ return false;
+ crypto.key_params= key_params;
+
+ desc->AddCrypto(crypto);
+ }
+ return true;
+}
+
+std::vector<Json::Value> ReadValues(
+ const Json::Value& value, const std::string& key) {
+ std::vector<Json::Value> objects;
+ for (Json::Value::ArrayIndex i = 0; i < value[key].size(); ++i) {
+ objects.push_back(value[key][i]);
+ }
+ return objects;
+}
+
+Json::Value ReadValue(const Json::Value& value, const std::string& key) {
+ return value[key];
+}
+
+std::string ReadString(const Json::Value& value, const std::string& key) {
+ return value[key].asString();
+}
+
+uint32 ReadUInt(const Json::Value& value, const std::string& key) {
+ return value[key].asUInt();
+}
+
+void Append(Json::Value* object, const std::string& key, bool value) {
+ (*object)[key] = Json::Value(value);
+}
+
+void Append(Json::Value* object, const std::string& key, int value) {
+ (*object)[key] = Json::Value(value);
+}
+
+void Append(Json::Value* object, const std::string& key,
+ const std::string& value) {
+ (*object)[key] = Json::Value(value);
+}
+
+void Append(Json::Value* object, const std::string& key, uint32 value) {
+ (*object)[key] = Json::Value(value);
+}
+
+void Append(Json::Value* object, const std::string& key,
+ const Json::Value& value) {
+ (*object)[key] = value;
+}
+
+void Append(Json::Value* object,
+ const std::string & key,
+ const std::vector<Json::Value>& values) {
+ for (std::vector<Json::Value>::const_iterator iter = values.begin();
+ iter != values.end(); ++iter) {
+ (*object)[key].append(*iter);
+ }
+}
+
+} // namespace webrtc
diff --git a/talk/app/webrtcv1/webrtcjson.h b/talk/app/webrtcv1/webrtcjson.h
new file mode 100644
index 0000000..d923f83
--- /dev/null
+++ b/talk/app/webrtcv1/webrtcjson.h
@@ -0,0 +1,59 @@
+/*
+ * libjingle
+ * Copyright 2004--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_WEBRTCJSON_H_
+#define TALK_APP_WEBRTC_WEBRTCJSON_H_
+
+#include <string>
+
+#include "talk/p2p/base/candidate.h"
+#include "talk/session/phone/codec.h"
+
+namespace Json {
+class Value;
+}
+
+namespace cricket {
+class AudioContentDescription;
+class VideoContentDescription;
+struct ContentInfo;
+class SessionDescription;
+}
+
+namespace webrtc {
+
+bool GetJsonSignalingMessage(
+ const cricket::SessionDescription* sdp,
+ const std::vector<cricket::Candidate>& candidates,
+ std::string* signaling_message);
+
+bool ParseJsonSignalingMessage(const std::string& signaling_message,
+ cricket::SessionDescription** sdp,
+ std::vector<cricket::Candidate>* candidates);
+}
+
+#endif // TALK_APP_WEBRTC_WEBRTCJSON_H_
diff --git a/talk/app/webrtcv1/webrtcsession.cc b/talk/app/webrtcv1/webrtcsession.cc
new file mode 100644
index 0000000..d30ee43
--- /dev/null
+++ b/talk/app/webrtcv1/webrtcsession.cc
@@ -0,0 +1,543 @@
+/*
+ * libjingle
+ * Copyright 2004--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/webrtcv1/webrtcsession.h"
+
+#include <string>
+#include <vector>
+
+#include "talk/base/common.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/p2p/base/constants.h"
+#include "talk/p2p/base/sessiondescription.h"
+#include "talk/p2p/base/p2ptransport.h"
+#include "talk/session/phone/channel.h"
+#include "talk/session/phone/channelmanager.h"
+#include "talk/session/phone/mediasessionclient.h"
+#include "talk/session/phone/voicechannel.h"
+
+namespace webrtc {
+
+enum {
+ MSG_CANDIDATE_TIMEOUT = 101,
+};
+
+static const int kAudioMonitorPollFrequency = 100;
+static const int kMonitorPollFrequency = 1000;
+
+// We allow 30 seconds to establish a connection; beyond that we consider
+// it an error
+static const int kCallSetupTimeout = 30 * 1000;
+// A loss of connectivity is probably due to the Internet connection going
+// down, and it might take a while to come back on wireless networks, so we
+// use a longer timeout for that.
+static const int kCallLostTimeout = 60 * 1000;
+
+static const char kVideoStream[] = "video_rtp";
+static const char kAudioStream[] = "rtp";
+
+static const int kDefaultVideoCodecId = 100;
+static const int kDefaultVideoCodecFramerate = 30;
+static const char kDefaultVideoCodecName[] = "VP8";
+
+WebRtcSession::WebRtcSession(const std::string& id,
+ bool incoming,
+ cricket::PortAllocator* allocator,
+ cricket::ChannelManager* channelmgr,
+ talk_base::Thread* signaling_thread)
+ : BaseSession(signaling_thread, channelmgr->worker_thread(),
+ allocator, id, "", !incoming),
+ transport_(NULL),
+ channel_manager_(channelmgr),
+ transports_writable_(false),
+ muted_(false),
+ camera_muted_(false),
+ setup_timeout_(kCallSetupTimeout),
+ signaling_thread_(signaling_thread),
+ incoming_(incoming),
+ port_allocator_(allocator),
+ desc_factory_(channel_manager_) {
+}
+
+WebRtcSession::~WebRtcSession() {
+ RemoveAllStreams();
+ // TODO: Do we still need Terminate?
+ // if (state_ != STATE_RECEIVEDTERMINATE) {
+ // Terminate();
+ // }
+ if (transport_) {
+ delete transport_;
+ transport_ = NULL;
+ }
+}
+
+bool WebRtcSession::Initiate() {
+ const cricket::VideoCodec default_codec(kDefaultVideoCodecId,
+ kDefaultVideoCodecName, kDefaultVideoCodecWidth, kDefaultVideoCodecHeight,
+ kDefaultVideoCodecFramerate, 0);
+ channel_manager_->SetDefaultVideoEncoderConfig(
+ cricket::VideoEncoderConfig(default_codec));
+
+ if (signaling_thread_ == NULL)
+ return false;
+
+ transport_ = CreateTransport();
+
+ if (transport_ == NULL)
+ return false;
+
+ transport_->set_allow_local_ips(true);
+
+ // start transports
+ transport_->SignalRequestSignaling.connect(
+ this, &WebRtcSession::OnRequestSignaling);
+ transport_->SignalCandidatesReady.connect(
+ this, &WebRtcSession::OnCandidatesReady);
+ transport_->SignalWritableState.connect(
+ this, &WebRtcSession::OnWritableState);
+ // Limit the amount of time that setting up a call may take.
+ StartTransportTimeout(kCallSetupTimeout);
+ // Set default secure option to SEC_REQUIRED.
+ desc_factory_.set_secure(cricket::SEC_REQUIRED);
+ return true;
+}
+
+cricket::Transport* WebRtcSession::CreateTransport() {
+ ASSERT(signaling_thread()->IsCurrent());
+ return new cricket::P2PTransport(
+ talk_base::Thread::Current(),
+ channel_manager_->worker_thread(), port_allocator());
+}
+
+bool WebRtcSession::CreateVoiceChannel(const std::string& stream_id) {
+ // RTCP disabled
+ cricket::VoiceChannel* voice_channel =
+ channel_manager_->CreateVoiceChannel(this, stream_id, true);
+ if (voice_channel == NULL) {
+ LOG(LERROR) << "Unable to create voice channel.";
+ return false;
+ }
+ StreamInfo* stream_info = new StreamInfo(stream_id);
+ stream_info->channel = voice_channel;
+ stream_info->video = false;
+ streams_.push_back(stream_info);
+ return true;
+}
+
+bool WebRtcSession::CreateVideoChannel(const std::string& stream_id) {
+ // RTCP disabled
+ cricket::VideoChannel* video_channel =
+ channel_manager_->CreateVideoChannel(this, stream_id, true, NULL);
+ if (video_channel == NULL) {
+ LOG(LERROR) << "Unable to create video channel.";
+ return false;
+ }
+ StreamInfo* stream_info = new StreamInfo(stream_id);
+ stream_info->channel = video_channel;
+ stream_info->video = true;
+ streams_.push_back(stream_info);
+ return true;
+}
+
+cricket::TransportChannel* WebRtcSession::CreateChannel(
+ const std::string& content_name,
+ const std::string& name) {
+ if (!transport_) {
+ return NULL;
+ }
+ std::string type;
+ if (content_name.compare(kVideoStream) == 0) {
+ type = cricket::NS_GINGLE_VIDEO;
+ } else {
+ type = cricket::NS_GINGLE_AUDIO;
+ }
+ cricket::TransportChannel* transport_channel =
+ transport_->CreateChannel(name, type);
+ ASSERT(transport_channel != NULL);
+ return transport_channel;
+}
+
+cricket::TransportChannel* WebRtcSession::GetChannel(
+ const std::string& content_name, const std::string& name) {
+ if (!transport_)
+ return NULL;
+
+ return transport_->GetChannel(name);
+}
+
+void WebRtcSession::DestroyChannel(
+ const std::string& content_name, const std::string& name) {
+ if (!transport_)
+ return;
+
+ transport_->DestroyChannel(name);
+}
+
+void WebRtcSession::OnMessage(talk_base::Message* message) {
+ switch (message->message_id) {
+ case MSG_CANDIDATE_TIMEOUT:
+ if (transport_->writable()) {
+ // This should never happen: The timout triggered even
+ // though a call was successfully set up.
+ ASSERT(false);
+ }
+ SignalFailedCall();
+ break;
+ default:
+ cricket::BaseSession::OnMessage(message);
+ break;
+ }
+}
+
+bool WebRtcSession::Connect() {
+ if (streams_.empty()) {
+ // nothing to initiate
+ return false;
+ }
+ // lets connect all the transport channels created before for this session
+ transport_->ConnectChannels();
+
+ // create an offer now. This is to call SetState
+ // Actual offer will be send when OnCandidatesReady callback received
+ cricket::SessionDescription* offer = CreateOffer();
+ set_local_description(offer);
+ SetState((incoming()) ? STATE_SENTACCEPT : STATE_SENTINITIATE);
+
+ // Enable all the channels
+ EnableAllStreams();
+ return SetVideoCapture(true);
+}
+
+bool WebRtcSession::SetVideoRenderer(const std::string& stream_id,
+ cricket::VideoRenderer* renderer) {
+ bool ret = false;
+ StreamMap::iterator iter;
+ for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
+ StreamInfo* stream_info = (*iter);
+ if (stream_info->stream_id.compare(stream_id) == 0) {
+ ASSERT(stream_info->channel != NULL);
+ ASSERT(stream_info->video);
+ cricket::VideoChannel* channel = static_cast<cricket::VideoChannel*>(
+ stream_info->channel);
+ ret = channel->SetRenderer(0, renderer);
+ break;
+ }
+ }
+ return ret;
+}
+
+bool WebRtcSession::SetVideoCapture(bool capture) {
+ cricket::CaptureResult ret = channel_manager_->SetVideoCapture(capture);
+ if (ret != cricket::CR_SUCCESS && ret != cricket::CR_PENDING) {
+ LOG(LS_ERROR) << "Failed to SetVideoCapture(" << capture << ").";
+ return false;
+ }
+ return true;
+}
+
+bool WebRtcSession::RemoveStream(const std::string& stream_id) {
+ bool ret = false;
+ StreamMap::iterator iter;
+ for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
+ StreamInfo* sinfo = (*iter);
+ if (sinfo->stream_id.compare(stream_id) == 0) {
+ if (!sinfo->video) {
+ cricket::VoiceChannel* channel = static_cast<cricket::VoiceChannel*> (
+ sinfo->channel);
+ channel->Enable(false);
+ // Note: If later the channel is used by multiple streams, then we
+ // should not destroy the channel until all the streams are removed.
+ channel_manager_->DestroyVoiceChannel(channel);
+ } else {
+ cricket::VideoChannel* channel = static_cast<cricket::VideoChannel*> (
+ sinfo->channel);
+ channel->Enable(false);
+ // Note: If later the channel is used by multiple streams, then we
+ // should not destroy the channel until all the streams are removed.
+ channel_manager_->DestroyVideoChannel(channel);
+ }
+ // channel and transport will be deleted in
+ // DestroyVoiceChannel/DestroyVideoChannel
+ streams_.erase(iter);
+ ret = true;
+ break;
+ }
+ }
+ if (!ret) {
+ LOG(LERROR) << "No streams found for stream id " << stream_id;
+ // TODO: trigger onError callback
+ }
+ return ret;
+}
+
+void WebRtcSession::EnableAllStreams() {
+ StreamMap::const_iterator i;
+ for (i = streams_.begin(); i != streams_.end(); ++i) {
+ cricket::BaseChannel* channel = (*i)->channel;
+ if (channel)
+ channel->Enable(true);
+ }
+}
+
+void WebRtcSession::RemoveAllStreams() {
+ SetState(STATE_RECEIVEDTERMINATE);
+
+ // signaling_thread_->Post(this, MSG_RTC_REMOVEALLSTREAMS);
+ // First build a list of streams to remove and then remove them.
+ // The reason we do this is that if we remove the streams inside the
+ // loop, a stream might get removed while we're enumerating and the iterator
+ // will become invalid (and we crash).
+ // streams_ entry will be removed from ChannelManager callback method
+ // DestroyChannel
+ std::vector<std::string> streams_to_remove;
+ StreamMap::iterator iter;
+ for (iter = streams_.begin(); iter != streams_.end(); ++iter)
+ streams_to_remove.push_back((*iter)->stream_id);
+
+ for (std::vector<std::string>::iterator i = streams_to_remove.begin();
+ i != streams_to_remove.end(); ++i) {
+ RemoveStream(*i);
+ }
+}
+
+bool WebRtcSession::HasStream(const std::string& stream_id) const {
+ StreamMap::const_iterator iter;
+ for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
+ StreamInfo* sinfo = (*iter);
+ if (stream_id.compare(sinfo->stream_id) == 0) {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool WebRtcSession::HasChannel(bool video) const {
+ StreamMap::const_iterator iter;
+ for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
+ StreamInfo* sinfo = (*iter);
+ if (sinfo->video == video) {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool WebRtcSession::HasAudioChannel() const {
+ return HasChannel(false);
+}
+
+bool WebRtcSession::HasVideoChannel() const {
+ return HasChannel(true);
+}
+
+void WebRtcSession::OnRequestSignaling(cricket::Transport* transport) {
+ transport->OnSignalingReady();
+}
+
+void WebRtcSession::OnWritableState(cricket::Transport* transport) {
+ ASSERT(transport == transport_);
+ const bool transports_writable = transport_->writable();
+ if (transports_writable) {
+ if (transports_writable != transports_writable_) {
+ signaling_thread_->Clear(this, MSG_CANDIDATE_TIMEOUT);
+ } else {
+ // At one point all channels were writable and we had full connectivity,
+ // but then we lost it. Start the timeout again to kill the call if it
+ // doesn't come back.
+ StartTransportTimeout(kCallLostTimeout);
+ }
+ transports_writable_ = transports_writable;
+ }
+ NotifyTransportState();
+ return;
+}
+
+void WebRtcSession::StartTransportTimeout(int timeout) {
+ talk_base::Thread::Current()->PostDelayed(timeout, this,
+ MSG_CANDIDATE_TIMEOUT,
+ NULL);
+}
+
+void WebRtcSession::NotifyTransportState() {
+}
+
+bool WebRtcSession::OnInitiateMessage(
+ cricket::SessionDescription* offer,
+ const std::vector<cricket::Candidate>& candidates) {
+ if (!offer) {
+ LOG(LERROR) << "No SessionDescription from peer";
+ return false;
+ }
+
+ // Get capabilities from offer before generating an answer to it.
+ cricket::MediaSessionOptions options;
+ if (GetFirstAudioContent(offer))
+ options.has_audio = true;
+ if (GetFirstVideoContent(offer))
+ options.has_video = true;
+
+ talk_base::scoped_ptr<cricket::SessionDescription> answer;
+ answer.reset(CreateAnswer(offer, options));
+
+ if (!answer.get()) {
+ return false;
+ }
+
+ const cricket::ContentInfo* audio_content = GetFirstAudioContent(
+ answer.get());
+ const cricket::ContentInfo* video_content = GetFirstVideoContent(
+ answer.get());
+
+ if (!audio_content && !video_content) {
+ return false;
+ }
+
+ bool ret = true;
+ if (audio_content) {
+ ret = !HasAudioChannel() &&
+ CreateVoiceChannel(audio_content->name);
+ if (!ret) {
+ LOG(LERROR) << "Failed to create voice channel for "
+ << audio_content->name;
+ return false;
+ }
+ }
+
+ if (video_content) {
+ ret = !HasVideoChannel() &&
+ CreateVideoChannel(video_content->name);
+ if (!ret) {
+ LOG(LERROR) << "Failed to create video channel for "
+ << video_content->name;
+ return false;
+ }
+ }
+ // Provide remote candidates to the transport
+ transport_->OnRemoteCandidates(candidates);
+
+ set_remote_description(offer);
+ SetState(STATE_RECEIVEDINITIATE);
+
+ transport_->ConnectChannels();
+ EnableAllStreams();
+ SetVideoCapture(true);
+
+ set_local_description(answer.release());
+
+ // AddStream called only once with Video label
+ if (video_content) {
+ SignalAddStream(video_content->name, true);
+ } else {
+ SignalAddStream(audio_content->name, false);
+ }
+ SetState(STATE_SENTACCEPT);
+ return true;
+}
+
+bool WebRtcSession::OnRemoteDescription(
+ cricket::SessionDescription* desc,
+ const std::vector<cricket::Candidate>& candidates) {
+ if (state() == STATE_SENTACCEPT ||
+ state() == STATE_RECEIVEDACCEPT ||
+ state() == STATE_INPROGRESS) {
+ transport_->OnRemoteCandidates(candidates);
+ return true;
+ }
+ // Session description is always accepted.
+ set_remote_description(desc);
+ SetState(STATE_RECEIVEDACCEPT);
+ // Will trigger OnWritableState() if successful.
+ transport_->OnRemoteCandidates(candidates);
+
+ if (!incoming()) {
+ // Trigger OnAddStream callback at the initiator
+ const cricket::ContentInfo* video_content = GetFirstVideoContent(desc);
+ if (video_content && !SendSignalAddStream(true)) {
+ LOG(LERROR) << "Video stream unexpected in answer.";
+ return false;
+ } else {
+ const cricket::ContentInfo* audio_content = GetFirstAudioContent(desc);
+ if (audio_content && !SendSignalAddStream(false)) {
+ LOG(LERROR) << "Audio stream unexpected in answer.";
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+// Send the SignalAddStream with the stream_id based on the content type.
+bool WebRtcSession::SendSignalAddStream(bool video) {
+ StreamMap::const_iterator iter;
+ for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
+ StreamInfo* sinfo = (*iter);
+ if (sinfo->video == video) {
+ SignalAddStream(sinfo->stream_id, video);
+ return true;
+ }
+ }
+ return false;
+}
+
+cricket::SessionDescription* WebRtcSession::CreateOffer() {
+ cricket::MediaSessionOptions options;
+ options.has_audio = false; // disable default option
+ StreamMap::const_iterator iter;
+ for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
+ if ((*iter)->video) {
+ options.has_video = true;
+ } else {
+ options.has_audio = true;
+ }
+ }
+ // We didn't save the previous offer.
+ const cricket::SessionDescription* previous_offer = NULL;
+ return desc_factory_.CreateOffer(options, previous_offer);
+}
+
+cricket::SessionDescription* WebRtcSession::CreateAnswer(
+ const cricket::SessionDescription* offer,
+ const cricket::MediaSessionOptions& options) {
+ // We didn't save the previous answer.
+ const cricket::SessionDescription* previous_answer = NULL;
+ return desc_factory_.CreateAnswer(offer, options, previous_answer);
+}
+
+void WebRtcSession::SetError(Error error) {
+ BaseSession::SetError(error);
+}
+
+void WebRtcSession::OnCandidatesReady(
+ cricket::Transport* transport,
+ const std::vector<cricket::Candidate>& candidates) {
+ std::vector<cricket::Candidate>::const_iterator iter;
+ for (iter = candidates.begin(); iter != candidates.end(); ++iter) {
+ local_candidates_.push_back(*iter);
+ }
+ SignalLocalDescription(local_description(), candidates);
+}
+} /* namespace webrtc */
diff --git a/talk/app/webrtcv1/webrtcsession.h b/talk/app/webrtcv1/webrtcsession.h
new file mode 100644
index 0000000..8f6c6ad
--- /dev/null
+++ b/talk/app/webrtcv1/webrtcsession.h
@@ -0,0 +1,210 @@
+/*
+ * libjingle
+ * Copyright 2004--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_WEBRTCSESSION_H_
+#define TALK_APP_WEBRTC_WEBRTCSESSION_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "talk/base/logging.h"
+#include "talk/base/messagehandler.h"
+#include "talk/p2p/base/candidate.h"
+#include "talk/p2p/base/session.h"
+#include "talk/session/phone/channel.h"
+#include "talk/session/phone/mediachannel.h"
+#include "talk/session/phone/mediasession.h"
+
+namespace cricket {
+class ChannelManager;
+class Transport;
+class TransportChannel;
+class VoiceChannel;
+class VideoChannel;
+struct ConnectionInfo;
+}
+
+namespace Json {
+class Value;
+}
+
+namespace webrtc {
+
+typedef std::vector<cricket::AudioCodec> AudioCodecs;
+typedef std::vector<cricket::VideoCodec> VideoCodecs;
+
+class WebRtcSession : public cricket::BaseSession {
+ public:
+ WebRtcSession(const std::string& id,
+ bool incoming,
+ cricket::PortAllocator* allocator,
+ cricket::ChannelManager* channelmgr,
+ talk_base::Thread* signaling_thread);
+
+ ~WebRtcSession();
+
+ bool Initiate();
+ bool Connect();
+ bool OnRemoteDescription(cricket::SessionDescription* sdp,
+ const std::vector<cricket::Candidate>& candidates);
+ bool OnInitiateMessage(cricket::SessionDescription* sdp,
+ const std::vector<cricket::Candidate>& candidates);
+ bool CreateVoiceChannel(const std::string& stream_id);
+ bool CreateVideoChannel(const std::string& stream_id);
+ bool RemoveStream(const std::string& stream_id);
+ void RemoveAllStreams();
+
+ // Returns true if we have either a voice or video stream matching this label.
+ bool HasStream(const std::string& label) const;
+ bool HasChannel(bool video) const;
+
+ // Returns true if there's one or more audio channels in the session.
+ bool HasAudioChannel() const;
+
+ // Returns true if there's one or more video channels in the session.
+ bool HasVideoChannel() const;
+
+ bool SetVideoRenderer(const std::string& stream_id,
+ cricket::VideoRenderer* renderer);
+
+ // This signal occurs when all the streams have been removed.
+ // It is triggered by a successful call to the RemoveAllStream or
+ // the OnRemoteDescription with stream deleted signaling message with the
+ // candidates port equal to 0.
+ sigslot::signal1<WebRtcSession*> SignalRemoveStreamMessage;
+
+ // This signal indicates a stream has been added properly.
+ // It is triggered by a successful call to the OnInitiateMessage or
+ // the OnRemoteDescription and if it's going to the STATE_RECEIVEDACCEPT.
+ sigslot::signal2<const std::string&, bool> SignalAddStream;
+
+ // This signal occurs when one stream is removed with the signaling
+ // message from the remote peer with the candidates port equal to 0.
+ sigslot::signal2<const std::string&, bool> SignalRemoveStream;
+
+ // This signal occurs when the local candidate is ready
+ sigslot::signal2<const cricket::SessionDescription*,
+ const std::vector<cricket::Candidate>&> SignalLocalDescription;
+
+ // This signal triggers when setting up or resuming a call has not been
+ // successful before a certain time out.
+ sigslot::signal0<> SignalFailedCall;
+
+ bool muted() const { return muted_; }
+ bool camera_muted() const { return camera_muted_; }
+ const std::vector<cricket::Candidate>& local_candidates() {
+ return local_candidates_;
+ }
+ void set_incoming(bool incoming) { incoming_ = incoming; }
+ bool incoming() const { return incoming_; }
+ cricket::PortAllocator* port_allocator() const { return port_allocator_; }
+ talk_base::Thread* signaling_thread() const { return signaling_thread_; }
+
+ static const int kDefaultVideoCodecWidth = 640;
+ static const int kDefaultVideoCodecHeight = 480;
+
+ protected:
+ // methods from cricket::BaseSession
+ virtual void SetError(cricket::BaseSession::Error error);
+ virtual cricket::TransportChannel* CreateChannel(
+ const std::string& content_name, const std::string& name);
+ virtual cricket::TransportChannel* GetChannel(
+ const std::string& content_name, const std::string& name);
+ virtual void DestroyChannel(
+ const std::string& content_name, const std::string& name);
+
+ private:
+ struct StreamInfo {
+ explicit StreamInfo(const std::string stream_id)
+ : channel(NULL),
+ video(false),
+ stream_id(stream_id) {}
+
+ StreamInfo()
+ : channel(NULL),
+ video(false) {}
+ cricket::BaseChannel* channel;
+ bool video;
+ std::string stream_id;
+ };
+ // Not really a map (vector).
+ typedef std::vector<StreamInfo*> StreamMap;
+
+ // methods signaled by the transport
+ void OnRequestSignaling(cricket::Transport* transport);
+ void OnCandidatesReady(cricket::Transport* transport,
+ const std::vector<cricket::Candidate>& candidates);
+ void OnWritableState(cricket::Transport* transport);
+ void OnTransportError(cricket::Transport* transport);
+ void OnChannelGone(cricket::Transport* transport);
+
+ bool CheckForStreamDeleteMessage(
+ const std::vector<cricket::Candidate>& candidates);
+ void ProcessTerminateAccept(cricket::SessionDescription* desc);
+
+ void UpdateTransportWritableState();
+ bool CheckAllTransportsWritable();
+ void StartTransportTimeout(int timeout);
+ void NotifyTransportState();
+
+ cricket::SessionDescription* CreateOffer();
+ cricket::SessionDescription* CreateAnswer(
+ const cricket::SessionDescription* answer,
+ const cricket::MediaSessionOptions& options);
+
+ // from MessageHandler
+ virtual void OnMessage(talk_base::Message* message);
+
+ virtual cricket::Transport* CreateTransport();
+ cricket::Transport* GetTransport();
+
+ typedef std::map<std::string, cricket::TransportChannel*> TransportChannelMap;
+
+ bool SetVideoCapture(bool capture);
+ void EnableAllStreams();
+ bool SendSignalAddStream(bool video);
+
+ cricket::Transport* transport_;
+ cricket::ChannelManager* channel_manager_;
+ std::vector<StreamInfo*> streams_;
+ TransportChannelMap transport_channels_;
+ bool transports_writable_;
+ bool muted_;
+ bool camera_muted_;
+ int setup_timeout_;
+ std::vector<cricket::Candidate> local_candidates_;
+
+ talk_base::Thread* signaling_thread_;
+ bool incoming_;
+ cricket::PortAllocator* port_allocator_;
+ cricket::MediaSessionDescriptionFactory desc_factory_;
+};
+
+} // namespace webrtc
+
+#endif // TALK_APP_WEBRTC_WEBRTCSESSION_H_
diff --git a/talk/app/webrtcv1/webrtcsession_unittest.cc b/talk/app/webrtcv1/webrtcsession_unittest.cc
new file mode 100644
index 0000000..6f27fb4
--- /dev/null
+++ b/talk/app/webrtcv1/webrtcsession_unittest.cc
@@ -0,0 +1,475 @@
+/*
+ * libjingle
+ * Copyright 2004--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 <stdio.h>
+
+#include <list>
+
+#include "talk/app/webrtcv1/unittest_utilities.h"
+#include "talk/app/webrtcv1/webrtcsession.h"
+#include "talk/base/fakenetwork.h"
+#include "talk/base/gunit.h"
+#include "talk/base/helpers.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/thread.h"
+#include "talk/p2p/base/fakesession.h"
+#include "talk/p2p/base/portallocator.h"
+#include "talk/p2p/base/sessiondescription.h"
+#include "talk/p2p/client/fakeportallocator.h"
+#include "talk/session/phone/dummydevicemanager.h"
+#include "talk/session/phone/fakewebrtcvcmfactory.h"
+#include "talk/session/phone/fakewebrtcvideocapturemodule.h"
+#include "talk/session/phone/mediasessionclient.h"
+#include "talk/session/phone/webrtcmediaengine.h"
+#include "talk/session/phone/webrtcvideocapturer.h"
+
+class WebRtcSessionTest
+ : public sigslot::has_slots<>,
+ public testing::Test {
+ public:
+ enum CallbackId {
+ kNone,
+ kOnAddStream,
+ kOnRemoveStream,
+ kOnLocalDescription,
+ kOnFailedCall,
+ };
+
+ WebRtcSessionTest()
+ : last_was_video_(false),
+ last_description_ptr_(NULL),
+ session_(NULL),
+ receiving_(false),
+ allocator_(NULL),
+ channel_manager_(NULL),
+ video_capturer_(NULL),
+ worker_thread_(NULL),
+ signaling_thread_(NULL) {
+ }
+
+ ~WebRtcSessionTest() {
+ session_.reset();
+ // Ensure the VideoCapturer be unregistered before destroyed.
+ channel_manager_->SetVideoCapturer(NULL, 0);
+ }
+
+ void OnAddStream(const std::string& stream_id, bool video) {
+ callback_ids_.push_back(kOnAddStream);
+ last_stream_id_ = stream_id;
+ last_was_video_ = video;
+ }
+ void OnRemoveStream(const std::string& stream_id, bool video) {
+ callback_ids_.push_back(kOnRemoveStream);
+ last_stream_id_ = stream_id;
+ last_was_video_ = video;
+ }
+ void OnLocalDescription(
+ const cricket::SessionDescription* desc,
+ const std::vector<cricket::Candidate>& candidates) {
+ callback_ids_.push_back(kOnLocalDescription);
+ last_description_ptr_.reset(CopySessionDescription(desc));
+ CopyCandidates(candidates, &last_candidates_);
+ }
+ cricket::SessionDescription* GetLocalDescription(
+ std::vector<cricket::Candidate>* candidates) {
+ if (last_candidates_.empty()) {
+ return NULL;
+ }
+ if (!last_description_ptr_.get()) {
+ return NULL;
+ }
+ CopyCandidates(last_candidates_, candidates);
+ return CopySessionDescription(last_description_ptr_.get());
+ }
+
+ void OnFailedCall() {
+ callback_ids_.push_back(kOnFailedCall);
+ }
+
+ CallbackId PopOldestCallback() {
+ if (callback_ids_.empty()) {
+ return kNone;
+ }
+ const CallbackId return_value = callback_ids_.front();
+ callback_ids_.pop_front();
+ return return_value;
+ }
+
+ CallbackId PeekOldestCallback() {
+ if (callback_ids_.empty()) {
+ return kNone;
+ }
+ const CallbackId return_value = callback_ids_.front();
+ return return_value;
+ }
+
+ void Reset() {
+ callback_ids_.clear();
+ last_stream_id_ = "";
+ last_was_video_ = false;
+ last_description_ptr_.reset();
+ last_candidates_.clear();
+ }
+
+ bool WaitForCallback(CallbackId id, int timeout_ms) {
+ bool success = false;
+ for (int ms = 0; ms < timeout_ms; ms++) {
+ const CallbackId peek_id = PeekOldestCallback();
+ if (peek_id == id) {
+ PopOldestCallback();
+ success = true;
+ break;
+ } else if (peek_id != kNone) {
+ success = false;
+ break;
+ }
+ talk_base::Thread::Current()->ProcessMessages(1);
+ }
+ return success;
+ }
+
+ bool Init(bool receiving) {
+ if (signaling_thread_ != NULL)
+ return false;
+ signaling_thread_ = talk_base::Thread::Current();
+ receiving_ = receiving;
+
+ if (worker_thread_!= NULL)
+ return false;
+ worker_thread_ = talk_base::Thread::Current();
+
+ cricket::FakePortAllocator* fake_port_allocator =
+ new cricket::FakePortAllocator(worker_thread_, NULL);
+
+ allocator_.reset(static_cast<cricket::PortAllocator*>(fake_port_allocator));
+
+ cricket::DummyDeviceManager* device_manager(
+ new cricket::DummyDeviceManager());
+ cricket::WebRtcMediaEngine* webrtc_media_engine(
+ new cricket::WebRtcMediaEngine(NULL, NULL, NULL));
+ channel_manager_.reset(new cricket::ChannelManager(webrtc_media_engine,
+ device_manager,
+ worker_thread_));
+ if (!channel_manager_->Init())
+ return false;
+
+ FakeWebRtcVideoCaptureModule* vcm =
+ new FakeWebRtcVideoCaptureModule(NULL, 123);
+ video_capturer_.reset(new cricket::WebRtcVideoCapturer);
+ if (!video_capturer_->Init(vcm)) {
+ return false;
+ }
+ // The SetVideoCapturer call doesn't transfer ownership.
+ if (!channel_manager_->SetVideoCapturer(video_capturer_.get(), 0))
+ return false;
+
+ talk_base::CreateRandomString(8, &id_);
+
+ session_.reset(new webrtc::WebRtcSession(
+ id_, receiving_ , allocator_.get(),
+ channel_manager_.get(),
+ signaling_thread_));
+ session_->SignalAddStream.connect(this, &WebRtcSessionTest::OnAddStream);
+ session_->SignalRemoveStream.connect(this,
+ &WebRtcSessionTest::OnRemoveStream);
+ session_->SignalLocalDescription.connect(this,
+ &WebRtcSessionTest::OnLocalDescription);
+ session_->SignalFailedCall.connect(this, &WebRtcSessionTest::OnFailedCall);
+ return true;
+ }
+
+ // All session APIs must be called from the signaling thread.
+ bool CallInitiate() {
+ return session_->Initiate();
+ }
+
+ bool CallConnect() {
+ if (!session_->Connect())
+ return false;
+ // This callback does not happen with FakeTransport!
+ if (!WaitForCallback(kOnLocalDescription, 1000)) {
+ return false;
+ }
+ return true;
+ }
+
+ bool CallOnRemoteDescription(
+ cricket::SessionDescription* description,
+ std::vector<cricket::Candidate> candidates) {
+ if (!session_->OnRemoteDescription(description, candidates)) {
+ return false;
+ }
+ if (!WaitForCallback(kOnAddStream, 1000)) {
+ return false;
+ }
+ return true;
+ }
+
+ bool CallOnInitiateMessage(
+ cricket::SessionDescription* description,
+ const std::vector<cricket::Candidate>& candidates) {
+ if (!session_->OnInitiateMessage(description, candidates)) {
+ return false;
+ }
+ if (!WaitForCallback(kOnAddStream, 1000)) {
+ return false;
+ }
+ return true;
+ }
+
+ bool CallCreateVoiceChannel(const std::string& stream_id) {
+ if (!session_->CreateVoiceChannel(stream_id)) {
+ return false;
+ }
+ return true;
+ }
+
+ bool CallCreateVideoChannel(const std::string& stream_id) {
+ if (!session_->CreateVideoChannel(stream_id)) {
+ return false;
+ }
+ return true;
+ }
+
+ bool CallRemoveStream(const std::string& stream_id) {
+ return session_->RemoveStream(stream_id);
+ }
+
+ void CallRemoveAllStreams() {
+ session_->RemoveAllStreams();
+ }
+
+ bool CallHasChannel(const std::string& label) {
+ return session_->HasStream(label);
+ }
+
+ bool CallHasChannel(bool video) {
+ return session_->HasChannel(video);
+ }
+
+ bool CallHasAudioChannel() {
+ return session_->HasAudioChannel();
+ }
+
+ bool CallHasVideoChannel() {
+ return session_->HasVideoChannel();
+ }
+
+ bool CallSetVideoRenderer(const std::string& stream_id,
+ cricket::VideoRenderer* renderer) {
+ return session_->SetVideoRenderer(stream_id, renderer);
+ }
+
+ const std::vector<cricket::Candidate>& CallLocalCandidates() {
+ return session_->local_candidates();
+ }
+ cricket::ChannelManager* channel_manager() const {
+ return channel_manager_.get();
+ }
+ const cricket::SessionDescription* local_description() const {
+ return session_->local_description();
+ }
+ cricket::SessionDescription* remote_description() const {
+ return session_->remote_description();
+ }
+
+ void VerifyCryptoParams(const cricket::SessionDescription* sdp,
+ bool offer) {
+ const cricket::ContentInfo* content = cricket::GetFirstAudioContent(sdp);
+ if (content) {
+ const cricket::AudioContentDescription* audio_content =
+ static_cast<const cricket::AudioContentDescription*>(
+ content->description);
+ ASSERT_TRUE(audio_content != NULL);
+ ASSERT_EQ(offer ? 2U : 1U, audio_content->cryptos().size());
+ // key(40) + inline string
+ ASSERT_EQ(47U, audio_content->cryptos()[0].key_params.size());
+ ASSERT_EQ("AES_CM_128_HMAC_SHA1_32",
+ audio_content->cryptos()[0].cipher_suite);
+ if (offer) {
+ ASSERT_EQ(47U, audio_content->cryptos()[1].key_params.size());
+ ASSERT_EQ("AES_CM_128_HMAC_SHA1_80",
+ audio_content->cryptos()[1].cipher_suite);
+ }
+ }
+ content = cricket::GetFirstVideoContent(sdp);
+ if (content) {
+ ASSERT_TRUE(content != NULL);
+ const cricket::VideoContentDescription* video_content =
+ static_cast<const cricket::VideoContentDescription*>(
+ content->description);
+ ASSERT_TRUE(video_content != NULL);
+ ASSERT_EQ(1U, video_content->cryptos().size());
+ ASSERT_EQ("AES_CM_128_HMAC_SHA1_80",
+ video_content->cryptos()[0].cipher_suite);
+ ASSERT_EQ(47U, video_content->cryptos()[0].key_params.size());
+ }
+ }
+
+ private:
+ std::list<CallbackId> callback_ids_;
+
+ std::string last_stream_id_;
+ bool last_was_video_;
+ talk_base::scoped_ptr<cricket::SessionDescription> last_description_ptr_;
+ std::vector<cricket::Candidate> last_candidates_;
+
+ talk_base::scoped_ptr<webrtc::WebRtcSession> session_;
+ std::string id_;
+ bool receiving_;
+
+ talk_base::scoped_ptr<cricket::PortAllocator> allocator_;
+
+ talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
+ talk_base::scoped_ptr<cricket::WebRtcVideoCapturer> video_capturer_;
+
+ talk_base::Thread* worker_thread_;
+ talk_base::Thread* signaling_thread_;
+};
+
+bool CallbackReceived(WebRtcSessionTest* session, int timeout) {
+ EXPECT_EQ_WAIT(WebRtcSessionTest::kNone, session->PeekOldestCallback(),
+ timeout);
+ const WebRtcSessionTest::CallbackId peek_id =
+ session->PeekOldestCallback();
+ return peek_id != WebRtcSessionTest::kNone;
+}
+
+TEST_F(WebRtcSessionTest, InitializationReceiveSanity) {
+ const bool kReceiving = true;
+ ASSERT_TRUE(Init(kReceiving));
+ ASSERT_TRUE(CallInitiate());
+
+ // Should return false because no stream has been set up yet.
+ EXPECT_FALSE(CallConnect());
+ const bool kVideo = true;
+ EXPECT_FALSE(CallHasChannel(kVideo));
+ EXPECT_FALSE(CallHasChannel(!kVideo));
+
+ EXPECT_EQ(kNone, PopOldestCallback());
+}
+
+TEST_F(WebRtcSessionTest, AudioSendCallSetUp) {
+ const bool kReceiving = false;
+ ASSERT_TRUE(Init(kReceiving));
+
+ ASSERT_TRUE(CallInitiate());
+
+ ASSERT_TRUE(CallCreateVoiceChannel("Audio"));
+ ASSERT_TRUE(CallConnect());
+
+ std::vector<cricket::Candidate> candidates;
+ cricket::SessionDescription* local_session = GetLocalDescription(
+ &candidates);
+ ASSERT_FALSE(candidates.empty());
+ ASSERT_FALSE(local_session == NULL);
+ if (!CallOnRemoteDescription(local_session, candidates)) {
+ delete local_session;
+ FAIL();
+ }
+
+ // All callbacks should be caught. Assert it.
+ ASSERT_FALSE(CallbackReceived(this, 1000));
+ ASSERT_TRUE(CallHasAudioChannel() &&
+ !CallHasVideoChannel());
+}
+
+TEST_F(WebRtcSessionTest, VideoSendCallSetUp) {
+ const bool kReceiving = false;
+ ASSERT_TRUE(Init(kReceiving));
+
+ ASSERT_TRUE(CallInitiate());
+
+ ASSERT_TRUE(CallCreateVideoChannel("Video"));
+ ASSERT_TRUE(CallConnect());
+
+ std::vector<cricket::Candidate> candidates;
+ cricket::SessionDescription* local_session = GetLocalDescription(
+ &candidates);
+ ASSERT_FALSE(candidates.empty());
+ ASSERT_FALSE(local_session == NULL);
+
+ if (!CallOnRemoteDescription(local_session, candidates)) {
+ delete local_session;
+ FAIL();
+ }
+
+ // All callbacks should be caught. Assert it.
+ ASSERT_FALSE(CallbackReceived(this, 1000));
+ ASSERT_TRUE(!CallHasAudioChannel() &&
+ CallHasVideoChannel());
+}
+
+TEST_F(WebRtcSessionTest, AudioReceiveCallSetUp) {
+ const bool kReceiving = true;
+ const bool video = false;
+
+ ASSERT_TRUE(Init(kReceiving));
+
+ std::vector<cricket::Candidate> candidates;
+ cricket::SessionDescription* local_session =
+ GenerateFakeSession(channel_manager(), video, &candidates);
+ ASSERT_FALSE(candidates.empty());
+ ASSERT_FALSE(local_session == NULL);
+ ASSERT_TRUE(CallInitiate());
+ if (!CallOnInitiateMessage(local_session, candidates)) {
+ delete local_session;
+ FAIL();
+ }
+
+ ASSERT_FALSE(CallbackReceived(this, 1000));
+ ASSERT_TRUE(CallHasAudioChannel() &&
+ !CallHasVideoChannel());
+ // Incoming call - local desc has the answer.
+ VerifyCryptoParams(local_description(), false);
+ VerifyCryptoParams(remote_description(), true);
+}
+
+TEST_F(WebRtcSessionTest, VideoReceiveCallSetUp) {
+ const bool kReceiving = true;
+ const bool video = true;
+
+ ASSERT_TRUE(Init(kReceiving));
+
+ std::vector<cricket::Candidate> candidates;
+ cricket::SessionDescription* local_session =
+ GenerateFakeSession(channel_manager(), video, &candidates);
+ ASSERT_FALSE(candidates.empty());
+ ASSERT_FALSE(local_session == NULL);
+ ASSERT_TRUE(CallInitiate());
+ if (!CallOnInitiateMessage(local_session, candidates)) {
+ delete local_session;
+ FAIL();
+ }
+
+ ASSERT_FALSE(CallbackReceived(this, 1000));
+ ASSERT_TRUE(!CallHasAudioChannel() &&
+ CallHasVideoChannel());
+ // Incoming call - local desc has the answer.
+ VerifyCryptoParams(local_description(), false);
+ VerifyCryptoParams(remote_description(), true);
+}
diff --git a/talk/app/webrtcv1/webrtcv1.scons b/talk/app/webrtcv1/webrtcv1.scons
new file mode 100644
index 0000000..a648422
--- /dev/null
+++ b/talk/app/webrtcv1/webrtcv1.scons
@@ -0,0 +1,61 @@
+# -*- Python -*-
+import talk
+
+Import('env')
+
+if env.Bit('have_webrtc_voice') and env.Bit('have_webrtc_video'):
+ # local sources
+ talk.Library(
+ env,
+ name = 'webrtcv1',
+ srcs = [
+ 'peerconnectionimpl.cc',
+ 'peerconnectionproxy.cc',
+ 'peerconnectionfactory.cc',
+ 'webrtcjson.cc',
+ 'webrtcsession.cc',
+ ],
+ )
+
+ talk.Unittest(
+ env,
+ name = 'webrtcv1',
+ srcs = [
+ 'peerconnection_unittest.cc',
+ 'unittest_utilities.cc',
+ 'webrtcsession_unittest.cc',
+ ],
+ libs = [
+ 'base',
+ 'expat',
+ 'jpeg',
+ 'json',
+ 'p2p',
+ 'phone',
+ 'srtp',
+ 'webrtcv1',
+ 'xmpp',
+ 'xmllite',
+ 'yuvscaler'
+ ],
+ include_talk_media_libs = True,
+ mac_libs = [
+ 'crypto',
+ 'ssl',
+ ],
+ mac_FRAMEWORKS = [
+ 'Foundation',
+ 'IOKit',
+ 'QTKit',
+ ],
+ win_link_flags = [('', '/nodefaultlib:libcmt')[env.Bit('debug')]],
+ lin_libs = [
+ 'rt',
+ 'dl',
+ 'sound',
+ 'X11',
+ 'Xext',
+ 'Xfixes',
+ 'Xrandr'
+ ],
+ )
diff --git a/talk/base/asynchttprequest.h b/talk/base/asynchttprequest.h
index a1e8aa0..13edf61 100644
--- a/talk/base/asynchttprequest.h
+++ b/talk/base/asynchttprequest.h
@@ -55,6 +55,7 @@
int start_delay() const { return start_delay_; }
void set_start_delay(int delay) { start_delay_ = delay; }
+ const ProxyInfo& proxy() const { return proxy_; }
void set_proxy(const ProxyInfo& proxy) {
proxy_ = proxy;
}
diff --git a/talk/base/atomicops.h b/talk/base/atomicops.h
new file mode 100644
index 0000000..94ade69
--- /dev/null
+++ b/talk/base/atomicops.h
@@ -0,0 +1,166 @@
+/*
+ * 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_BASE_ATOMICOPS_H_
+#define TALK_BASE_ATOMICOPS_H_
+
+#include <string>
+
+#include "talk/base/basictypes.h"
+#include "talk/base/common.h"
+#include "talk/base/logging.h"
+#include "talk/base/scoped_ptr.h"
+
+namespace talk_base {
+
+// A single-producer, single-consumer, fixed-size queue.
+// All methods not ending in Unsafe can be safely called without locking,
+// provided that calls to consumer methods (Peek/Pop) or producer methods (Push)
+// only happen on a single thread per method type. If multiple threads need to
+// read simultaneously or write simultaneously, other synchronization is
+// necessary. Synchronization is also required if a call into any Unsafe method
+// could happen at the same time as a call to any other method.
+template <typename T>
+class FixedSizeLockFreeQueue {
+ private:
+// Atomic primitives and memory barrier
+#if defined(__arm__)
+ typedef uint32 Atomic32;
+
+ // Copied from google3/base/atomicops-internals-arm-v6plus.h
+ static inline void MemoryBarrier() {
+ asm volatile("dmb":::"memory");
+ }
+
+ // Adapted from google3/base/atomicops-internals-arm-v6plus.h
+ static inline void AtomicIncrement(volatile Atomic32* ptr) {
+ Atomic32 str_success, value;
+ asm volatile (
+ "1:\n"
+ "ldrex %1, [%2]\n"
+ "add %1, %1, #1\n"
+ "strex %0, %1, [%2]\n"
+ "teq %0, #0\n"
+ "bne 1b"
+ : "=&r"(str_success), "=&r"(value)
+ : "r" (ptr)
+ : "cc", "memory");
+ }
+#elif !defined(SKIP_ATOMIC_CHECK)
+#error "No atomic operations defined for the given architecture."
+#endif
+
+ public:
+ // Constructs an empty queue, with capacity 0.
+ FixedSizeLockFreeQueue() : pushed_count_(0),
+ popped_count_(0),
+ capacity_(0),
+ data_(NULL) {}
+ // Constructs an empty queue with the given capacity.
+ FixedSizeLockFreeQueue(size_t capacity) : pushed_count_(0),
+ popped_count_(0),
+ capacity_(capacity),
+ data_(new T[capacity]) {}
+
+ // Pushes a value onto the queue. Returns true if the value was successfully
+ // pushed (there was space in the queue). This method can be safely called at
+ // the same time as PeekFront/PopFront.
+ bool PushBack(T value) {
+ if (capacity_ == 0) {
+ LOG(LS_WARNING) << "Queue capacity is 0.";
+ return false;
+ }
+ if (IsFull()) {
+ return false;
+ }
+
+ data_[pushed_count_ % capacity_] = value;
+ // Make sure the data is written before the count is incremented, so other
+ // threads can't see the value exists before being able to read it.
+ MemoryBarrier();
+ AtomicIncrement(&pushed_count_);
+ return true;
+ }
+
+ // Retrieves the oldest value pushed onto the queue. Returns true if there was
+ // an item to peek (the queue was non-empty). This method can be safely called
+ // at the same time as PushBack.
+ bool PeekFront(T* value_out) {
+ if (capacity_ == 0) {
+ LOG(LS_WARNING) << "Queue capacity is 0.";
+ return false;
+ }
+ if (IsEmpty()) {
+ return false;
+ }
+
+ *value_out = data_[popped_count_ % capacity_];
+ return true;
+ }
+
+ // Retrieves the oldest value pushed onto the queue and removes it from the
+ // queue. Returns true if there was an item to pop (the queue was non-empty).
+ // This method can be safely called at the same time as PushBack.
+ bool PopFront(T* value_out) {
+ if (PeekFront(value_out)) {
+ AtomicIncrement(&popped_count_);
+ return true;
+ }
+ return false;
+ }
+
+ // Clears the current items in the queue and sets the new (fixed) size. This
+ // method cannot be called at the same time as any other method.
+ void ClearAndResizeUnsafe(int new_capacity) {
+ capacity_ = new_capacity;
+ data_.reset(new T[new_capacity]);
+ pushed_count_ = 0;
+ popped_count_ = 0;
+ }
+
+ // Returns true if there is no space left in the queue for new elements.
+ int IsFull() const { return pushed_count_ == popped_count_ + capacity_; }
+ // Returns true if there are no elements in the queue.
+ int IsEmpty() const { return pushed_count_ == popped_count_; }
+ // Returns the current number of elements in the queue. This is always in the
+ // range [0, capacity]
+ size_t Size() const { return pushed_count_ - popped_count_; }
+
+ // Returns the capacity of the queue (max size).
+ size_t capacity() const { return capacity_; }
+
+ private:
+ volatile Atomic32 pushed_count_;
+ volatile Atomic32 popped_count_;
+ size_t capacity_;
+ talk_base::scoped_array<T> data_;
+ DISALLOW_COPY_AND_ASSIGN(FixedSizeLockFreeQueue);
+};
+
+}
+
+#endif // TALK_BASE_ATOMICOPS_H_
diff --git a/talk/base/atomicops_unittest.cc b/talk/base/atomicops_unittest.cc
new file mode 100644
index 0000000..24804c6
--- /dev/null
+++ b/talk/base/atomicops_unittest.cc
@@ -0,0 +1,96 @@
+/*
+ * 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.
+ */
+
+#if !defined(__arm__)
+// For testing purposes, define faked versions of the atomic operations
+#include "talk/base/basictypes.h"
+namespace talk_base {
+typedef uint32 Atomic32;
+static inline void MemoryBarrier() { }
+static inline void AtomicIncrement(volatile Atomic32* ptr) {
+ *ptr = *ptr + 1;
+}
+}
+#define SKIP_ATOMIC_CHECK
+#endif
+
+#include "talk/base/atomicops.h"
+#include "talk/base/gunit.h"
+#include "talk/base/helpers.h"
+#include "talk/base/logging.h"
+
+TEST(FixedSizeLockFreeQueueTest, TestDefaultConstruct) {
+ talk_base::FixedSizeLockFreeQueue<int> queue;
+ EXPECT_EQ(0u, queue.capacity());
+ EXPECT_EQ(0u, queue.Size());
+ EXPECT_FALSE(queue.PushBack(1));
+ int val;
+ EXPECT_FALSE(queue.PopFront(&val));
+}
+
+TEST(FixedSizeLockFreeQueueTest, TestConstruct) {
+ talk_base::FixedSizeLockFreeQueue<int> queue(5);
+ EXPECT_EQ(5u, queue.capacity());
+ EXPECT_EQ(0u, queue.Size());
+ int val;
+ EXPECT_FALSE(queue.PopFront(&val));
+}
+
+TEST(FixedSizeLockFreeQueueTest, TestPushPop) {
+ talk_base::FixedSizeLockFreeQueue<int> queue(2);
+ EXPECT_EQ(2u, queue.capacity());
+ EXPECT_EQ(0u, queue.Size());
+ EXPECT_TRUE(queue.PushBack(1));
+ EXPECT_EQ(1u, queue.Size());
+ EXPECT_TRUE(queue.PushBack(2));
+ EXPECT_EQ(2u, queue.Size());
+ EXPECT_FALSE(queue.PushBack(3));
+ EXPECT_EQ(2u, queue.Size());
+ int val;
+ EXPECT_TRUE(queue.PopFront(&val));
+ EXPECT_EQ(1, val);
+ EXPECT_EQ(1u, queue.Size());
+ EXPECT_TRUE(queue.PopFront(&val));
+ EXPECT_EQ(2, val);
+ EXPECT_EQ(0u, queue.Size());
+ EXPECT_FALSE(queue.PopFront(&val));
+ EXPECT_EQ(0u, queue.Size());
+}
+
+TEST(FixedSizeLockFreeQueueTest, TestResize) {
+ talk_base::FixedSizeLockFreeQueue<int> queue(2);
+ EXPECT_EQ(2u, queue.capacity());
+ EXPECT_EQ(0u, queue.Size());
+ EXPECT_TRUE(queue.PushBack(1));
+ EXPECT_EQ(1u, queue.Size());
+
+ queue.ClearAndResizeUnsafe(5);
+ EXPECT_EQ(5u, queue.capacity());
+ EXPECT_EQ(0u, queue.Size());
+ int val;
+ EXPECT_FALSE(queue.PopFront(&val));
+}
diff --git a/talk/base/autodetectproxy.cc b/talk/base/autodetectproxy.cc
index f79926d..37faa4d 100644
--- a/talk/base/autodetectproxy.cc
+++ b/talk/base/autodetectproxy.cc
@@ -107,7 +107,7 @@
proxy().address.hostname(),
sizeof address_hostname);
- uint32 address_ip = proxy().address.ip();
+ IPAddress address_ip = proxy().address.ipaddr();
uint16 address_port = proxy().address.port();
diff --git a/talk/base/bandwidthsmoother.cc b/talk/base/bandwidthsmoother.cc
new file mode 100644
index 0000000..130f2a8
--- /dev/null
+++ b/talk/base/bandwidthsmoother.cc
@@ -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.
+ */
+
+#include "talk/base/bandwidthsmoother.h"
+
+#include <limits.h>
+
+namespace talk_base {
+
+BandwidthSmoother::BandwidthSmoother(int initial_bandwidth_guess,
+ uint32 time_between_increase,
+ double percent_increase,
+ size_t samples_count_to_average)
+ : time_between_increase_(time_between_increase),
+ percent_increase_(talk_base::_max(1.0, percent_increase)),
+ time_at_last_change_(0),
+ bandwidth_estimation_(initial_bandwidth_guess),
+ accumulator_(samples_count_to_average) {
+}
+
+// Samples a new bandwidth measurement
+// returns true if the bandwidth estimation changed
+bool BandwidthSmoother::Sample(uint32 sample_time, int bandwidth) {
+ if (bandwidth < 0) {
+ return false;
+ }
+
+ accumulator_.AddSample(bandwidth);
+
+ // Replace bandwidth with the mean of sampled bandwidths.
+ bandwidth = accumulator_.ComputeMean();
+
+ if (bandwidth < bandwidth_estimation_) {
+ time_at_last_change_ = sample_time;
+ bandwidth_estimation_ = bandwidth;
+ return true;
+ }
+
+ const int old_bandwidth_estimation = bandwidth_estimation_;
+ const double increase_threshold_d = percent_increase_ * bandwidth_estimation_;
+ if (increase_threshold_d > INT_MAX) {
+ // If bandwidth goes any higher we would overflow.
+ return false;
+ }
+
+ const int increase_threshold = static_cast<int>(increase_threshold_d);
+ if (bandwidth < increase_threshold) {
+ time_at_last_change_ = sample_time;
+ // The value of bandwidth_estimation remains the same if we don't exceed
+ // percent_increase_ * bandwidth_estimation_ for at least
+ // time_between_increase_ time.
+ } else if (sample_time >= time_at_last_change_ + time_between_increase_) {
+ time_at_last_change_ = sample_time;
+ if (increase_threshold == 0) {
+ bandwidth_estimation_ = bandwidth / 2;
+ } else {
+ bandwidth_estimation_ = increase_threshold;
+ }
+ }
+ // Else don't make a change.
+
+ return old_bandwidth_estimation != bandwidth_estimation_;
+}
+
+} // namespace talk_base
+
diff --git a/talk/base/bandwidthsmoother.h b/talk/base/bandwidthsmoother.h
new file mode 100644
index 0000000..afd1e52
--- /dev/null
+++ b/talk/base/bandwidthsmoother.h
@@ -0,0 +1,71 @@
+/*
+ * 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_BASE_BANDWIDTHSMOOTHER_H_
+#define TALK_BASE_BANDWIDTHSMOOTHER_H_
+
+#include "talk/base/rollingaccumulator.h"
+#include "talk/base/timeutils.h"
+
+namespace talk_base {
+
+// The purpose of BandwidthSmoother is to smooth out bandwidth
+// estimations so that 'trstate' messages can be triggered when we
+// are "sure" there is sufficient bandwidth. To avoid frequent fluctuations,
+// we take a slightly pessimistic view of our bandwidth. We only increase
+// our estimation when we have sampled bandwidth measurements of values
+// at least as large as the current estimation * percent_increase
+// for at least time_between_increase time. If a sampled bandwidth
+// is less than our current estimation we immediately decrease our estimation
+// to that sampled value.
+class BandwidthSmoother {
+ public:
+ BandwidthSmoother(int initial_bandwidth_guess,
+ uint32 time_between_increase,
+ double percent_increase,
+ size_t samples_count_to_average);
+
+ // Samples a new bandwidth measurement.
+ // bandwidth is expected to be non-negative.
+ // returns true if the bandwidth estimation changed
+ bool Sample(uint32 sample_time, int bandwidth);
+
+ int get_bandwidth_estimation() const {
+ return bandwidth_estimation_;
+ }
+
+ private:
+ uint32 time_between_increase_;
+ double percent_increase_;
+ uint32 time_at_last_change_;
+ int bandwidth_estimation_;
+ RollingAccumulator<int> accumulator_;
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_BANDWIDTHSMOOTHER_H_
diff --git a/talk/base/bandwidthsmoother_unittest.cc b/talk/base/bandwidthsmoother_unittest.cc
new file mode 100644
index 0000000..1eb79bd
--- /dev/null
+++ b/talk/base/bandwidthsmoother_unittest.cc
@@ -0,0 +1,106 @@
+/*
+ * 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 <limits.h>
+
+#include "talk/base/bandwidthsmoother.h"
+#include "talk/base/gunit.h"
+
+namespace talk_base {
+
+class BandwidthSmootherTest : public testing::Test {
+ public:
+};
+
+static const int kTimeBetweenIncrease = 10;
+static const double kPercentIncrease = 1.1;
+static const size_t kSamplesCountToAverage = 1;
+
+TEST_F(BandwidthSmootherTest, TestSampleIncrease) {
+ BandwidthSmoother mon(1000, // initial_bandwidth_guess
+ kTimeBetweenIncrease,
+ kPercentIncrease,
+ kSamplesCountToAverage);
+
+ int bandwidth_sample = 1000;
+ EXPECT_EQ(bandwidth_sample, mon.get_bandwidth_estimation());
+ bandwidth_sample =
+ static_cast<int>(bandwidth_sample * kPercentIncrease);
+ EXPECT_FALSE(mon.Sample(9, bandwidth_sample));
+ EXPECT_TRUE(mon.Sample(10, bandwidth_sample));
+ EXPECT_EQ(bandwidth_sample, mon.get_bandwidth_estimation());
+ int next_expected_est =
+ static_cast<int>(bandwidth_sample * kPercentIncrease);
+ bandwidth_sample *= 2;
+ EXPECT_TRUE(mon.Sample(20, bandwidth_sample));
+ EXPECT_EQ(next_expected_est, mon.get_bandwidth_estimation());
+}
+
+TEST_F(BandwidthSmootherTest, TestSampleIncreaseFromZero) {
+ BandwidthSmoother mon(0, // initial_bandwidth_guess
+ kTimeBetweenIncrease,
+ kPercentIncrease,
+ kSamplesCountToAverage);
+
+ int bandwidth_sample = 1000;
+ EXPECT_FALSE(mon.Sample(9, bandwidth_sample));
+ EXPECT_TRUE(mon.Sample(10, bandwidth_sample));
+ EXPECT_EQ(bandwidth_sample/2, mon.get_bandwidth_estimation());
+}
+
+TEST_F(BandwidthSmootherTest, TestSampleDecrease) {
+ BandwidthSmoother mon(1000, // initial_bandwidth_guess
+ kTimeBetweenIncrease,
+ kPercentIncrease,
+ kSamplesCountToAverage);
+
+ int bandwidth_sample = 999;
+ EXPECT_TRUE(mon.Sample(1, bandwidth_sample));
+ EXPECT_EQ(bandwidth_sample, mon.get_bandwidth_estimation());
+}
+
+TEST_F(BandwidthSmootherTest, TestSampleRollover) {
+ const int initial_bandwidth_guess = 2000000000; // > INT_MAX/1.1
+ BandwidthSmoother mon(initial_bandwidth_guess,
+ kTimeBetweenIncrease,
+ kPercentIncrease,
+ kSamplesCountToAverage);
+
+ EXPECT_FALSE(mon.Sample(10, INT_MAX));
+ EXPECT_EQ(initial_bandwidth_guess, mon.get_bandwidth_estimation());
+}
+
+TEST_F(BandwidthSmootherTest, TestSampleNegative) {
+ BandwidthSmoother mon(1000, // initial_bandwidth_guess
+ kTimeBetweenIncrease,
+ kPercentIncrease,
+ kSamplesCountToAverage);
+
+ EXPECT_FALSE(mon.Sample(10, -1));
+}
+
+} // namespace talk_base
diff --git a/talk/base/base64_unittest.cc b/talk/base/base64_unittest.cc
new file mode 100644
index 0000000..644a5e0
--- /dev/null
+++ b/talk/base/base64_unittest.cc
@@ -0,0 +1,1004 @@
+/*
+ * 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/base/common.h"
+#include "talk/base/base64.h"
+#include "talk/base/gunit.h"
+#include "talk/base/logging.h"
+#include "talk/base/stringutils.h"
+#include "talk/base/stream.h"
+
+#include "talk/base/testbase64.h"
+
+using namespace std;
+using namespace talk_base;
+
+static struct {
+ size_t plain_length;
+ const char* plaintext;
+ const char* cyphertext;
+} base64_tests[] = {
+
+ // Basic bit patterns;
+ // values obtained with "echo -n '...' | uuencode -m test"
+
+ { 1, "\000", "AA==" },
+ { 1, "\001", "AQ==" },
+ { 1, "\002", "Ag==" },
+ { 1, "\004", "BA==" },
+ { 1, "\010", "CA==" },
+ { 1, "\020", "EA==" },
+ { 1, "\040", "IA==" },
+ { 1, "\100", "QA==" },
+ { 1, "\200", "gA==" },
+
+ { 1, "\377", "/w==" },
+ { 1, "\376", "/g==" },
+ { 1, "\375", "/Q==" },
+ { 1, "\373", "+w==" },
+ { 1, "\367", "9w==" },
+ { 1, "\357", "7w==" },
+ { 1, "\337", "3w==" },
+ { 1, "\277", "vw==" },
+ { 1, "\177", "fw==" },
+ { 2, "\000\000", "AAA=" },
+ { 2, "\000\001", "AAE=" },
+ { 2, "\000\002", "AAI=" },
+ { 2, "\000\004", "AAQ=" },
+ { 2, "\000\010", "AAg=" },
+ { 2, "\000\020", "ABA=" },
+ { 2, "\000\040", "ACA=" },
+ { 2, "\000\100", "AEA=" },
+ { 2, "\000\200", "AIA=" },
+ { 2, "\001\000", "AQA=" },
+ { 2, "\002\000", "AgA=" },
+ { 2, "\004\000", "BAA=" },
+ { 2, "\010\000", "CAA=" },
+ { 2, "\020\000", "EAA=" },
+ { 2, "\040\000", "IAA=" },
+ { 2, "\100\000", "QAA=" },
+ { 2, "\200\000", "gAA=" },
+
+ { 2, "\377\377", "//8=" },
+ { 2, "\377\376", "//4=" },
+ { 2, "\377\375", "//0=" },
+ { 2, "\377\373", "//s=" },
+ { 2, "\377\367", "//c=" },
+ { 2, "\377\357", "/+8=" },
+ { 2, "\377\337", "/98=" },
+ { 2, "\377\277", "/78=" },
+ { 2, "\377\177", "/38=" },
+ { 2, "\376\377", "/v8=" },
+ { 2, "\375\377", "/f8=" },
+ { 2, "\373\377", "+/8=" },
+ { 2, "\367\377", "9/8=" },
+ { 2, "\357\377", "7/8=" },
+ { 2, "\337\377", "3/8=" },
+ { 2, "\277\377", "v/8=" },
+ { 2, "\177\377", "f/8=" },
+
+ { 3, "\000\000\000", "AAAA" },
+ { 3, "\000\000\001", "AAAB" },
+ { 3, "\000\000\002", "AAAC" },
+ { 3, "\000\000\004", "AAAE" },
+ { 3, "\000\000\010", "AAAI" },
+ { 3, "\000\000\020", "AAAQ" },
+ { 3, "\000\000\040", "AAAg" },
+ { 3, "\000\000\100", "AABA" },
+ { 3, "\000\000\200", "AACA" },
+ { 3, "\000\001\000", "AAEA" },
+ { 3, "\000\002\000", "AAIA" },
+ { 3, "\000\004\000", "AAQA" },
+ { 3, "\000\010\000", "AAgA" },
+ { 3, "\000\020\000", "ABAA" },
+ { 3, "\000\040\000", "ACAA" },
+ { 3, "\000\100\000", "AEAA" },
+ { 3, "\000\200\000", "AIAA" },
+ { 3, "\001\000\000", "AQAA" },
+ { 3, "\002\000\000", "AgAA" },
+ { 3, "\004\000\000", "BAAA" },
+ { 3, "\010\000\000", "CAAA" },
+ { 3, "\020\000\000", "EAAA" },
+ { 3, "\040\000\000", "IAAA" },
+ { 3, "\100\000\000", "QAAA" },
+ { 3, "\200\000\000", "gAAA" },
+
+ { 3, "\377\377\377", "////" },
+ { 3, "\377\377\376", "///+" },
+ { 3, "\377\377\375", "///9" },
+ { 3, "\377\377\373", "///7" },
+ { 3, "\377\377\367", "///3" },
+ { 3, "\377\377\357", "///v" },
+ { 3, "\377\377\337", "///f" },
+ { 3, "\377\377\277", "//+/" },
+ { 3, "\377\377\177", "//9/" },
+ { 3, "\377\376\377", "//7/" },
+ { 3, "\377\375\377", "//3/" },
+ { 3, "\377\373\377", "//v/" },
+ { 3, "\377\367\377", "//f/" },
+ { 3, "\377\357\377", "/+//" },
+ { 3, "\377\337\377", "/9//" },
+ { 3, "\377\277\377", "/7//" },
+ { 3, "\377\177\377", "/3//" },
+ { 3, "\376\377\377", "/v//" },
+ { 3, "\375\377\377", "/f//" },
+ { 3, "\373\377\377", "+///" },
+ { 3, "\367\377\377", "9///" },
+ { 3, "\357\377\377", "7///" },
+ { 3, "\337\377\377", "3///" },
+ { 3, "\277\377\377", "v///" },
+ { 3, "\177\377\377", "f///" },
+
+ // Random numbers: values obtained with
+ //
+ // #! /bin/bash
+ // dd bs=$1 count=1 if=/dev/random of=/tmp/bar.random
+ // od -N $1 -t o1 /tmp/bar.random
+ // uuencode -m test < /tmp/bar.random
+ //
+ // where $1 is the number of bytes (2, 3)
+
+ { 2, "\243\361", "o/E=" },
+ { 2, "\024\167", "FHc=" },
+ { 2, "\313\252", "y6o=" },
+ { 2, "\046\041", "JiE=" },
+ { 2, "\145\236", "ZZ4=" },
+ { 2, "\254\325", "rNU=" },
+ { 2, "\061\330", "Mdg=" },
+ { 2, "\245\032", "pRo=" },
+ { 2, "\006\000", "BgA=" },
+ { 2, "\375\131", "/Vk=" },
+ { 2, "\303\210", "w4g=" },
+ { 2, "\040\037", "IB8=" },
+ { 2, "\261\372", "sfo=" },
+ { 2, "\335\014", "3Qw=" },
+ { 2, "\233\217", "m48=" },
+ { 2, "\373\056", "+y4=" },
+ { 2, "\247\232", "p5o=" },
+ { 2, "\107\053", "Rys=" },
+ { 2, "\204\077", "hD8=" },
+ { 2, "\276\211", "vok=" },
+ { 2, "\313\110", "y0g=" },
+ { 2, "\363\376", "8/4=" },
+ { 2, "\251\234", "qZw=" },
+ { 2, "\103\262", "Q7I=" },
+ { 2, "\142\312", "Yso=" },
+ { 2, "\067\211", "N4k=" },
+ { 2, "\220\001", "kAE=" },
+ { 2, "\152\240", "aqA=" },
+ { 2, "\367\061", "9zE=" },
+ { 2, "\133\255", "W60=" },
+ { 2, "\176\035", "fh0=" },
+ { 2, "\032\231", "Gpk=" },
+
+ { 3, "\013\007\144", "Cwdk" },
+ { 3, "\030\112\106", "GEpG" },
+ { 3, "\047\325\046", "J9Um" },
+ { 3, "\310\160\022", "yHAS" },
+ { 3, "\131\100\237", "WUCf" },
+ { 3, "\064\342\134", "NOJc" },
+ { 3, "\010\177\004", "CH8E" },
+ { 3, "\345\147\205", "5WeF" },
+ { 3, "\300\343\360", "wOPw" },
+ { 3, "\061\240\201", "MaCB" },
+ { 3, "\225\333\044", "ldsk" },
+ { 3, "\215\137\352", "jV/q" },
+ { 3, "\371\147\160", "+Wdw" },
+ { 3, "\030\320\051", "GNAp" },
+ { 3, "\044\174\241", "JHyh" },
+ { 3, "\260\127\037", "sFcf" },
+ { 3, "\111\045\033", "SSUb" },
+ { 3, "\202\114\107", "gkxH" },
+ { 3, "\057\371\042", "L/ki" },
+ { 3, "\223\247\244", "k6ek" },
+ { 3, "\047\216\144", "J45k" },
+ { 3, "\203\070\327", "gzjX" },
+ { 3, "\247\140\072", "p2A6" },
+ { 3, "\124\115\116", "VE1O" },
+ { 3, "\157\162\050", "b3Io" },
+ { 3, "\357\223\004", "75ME" },
+ { 3, "\052\117\156", "Kk9u" },
+ { 3, "\347\154\000", "52wA" },
+ { 3, "\303\012\142", "wwpi" },
+ { 3, "\060\035\362", "MB3y" },
+ { 3, "\130\226\361", "WJbx" },
+ { 3, "\173\013\071", "ews5" },
+ { 3, "\336\004\027", "3gQX" },
+ { 3, "\357\366\234", "7/ac" },
+ { 3, "\353\304\111", "68RJ" },
+ { 3, "\024\264\131", "FLRZ" },
+ { 3, "\075\114\251", "PUyp" },
+ { 3, "\315\031\225", "zRmV" },
+ { 3, "\154\201\276", "bIG+" },
+ { 3, "\200\066\072", "gDY6" },
+ { 3, "\142\350\267", "Yui3" },
+ { 3, "\033\000\166", "GwB2" },
+ { 3, "\210\055\077", "iC0/" },
+ { 3, "\341\037\124", "4R9U" },
+ { 3, "\161\103\152", "cUNq" },
+ { 3, "\270\142\131", "uGJZ" },
+ { 3, "\337\076\074", "3z48" },
+ { 3, "\375\106\362", "/Uby" },
+ { 3, "\227\301\127", "l8FX" },
+ { 3, "\340\002\234", "4AKc" },
+ { 3, "\121\064\033", "UTQb" },
+ { 3, "\157\134\143", "b1xj" },
+ { 3, "\247\055\327", "py3X" },
+ { 3, "\340\142\005", "4GIF" },
+ { 3, "\060\260\143", "MLBj" },
+ { 3, "\075\203\170", "PYN4" },
+ { 3, "\143\160\016", "Y3AO" },
+ { 3, "\313\013\063", "ywsz" },
+ { 3, "\174\236\135", "fJ5d" },
+ { 3, "\103\047\026", "QycW" },
+ { 3, "\365\005\343", "9QXj" },
+ { 3, "\271\160\223", "uXCT" },
+ { 3, "\362\255\172", "8q16" },
+ { 3, "\113\012\015", "SwoN" },
+
+ // various lengths, generated by this python script:
+ //
+ // from string import lowercase as lc
+ // for i in range(27):
+ // print '{ %2d, "%s",%s "%s" },' % (i, lc[:i], ' ' * (26-i),
+ // lc[:i].encode('base64').strip())
+
+ { 0, "abcdefghijklmnopqrstuvwxyz", "" },
+ { 1, "abcdefghijklmnopqrstuvwxyz", "YQ==" },
+ { 2, "abcdefghijklmnopqrstuvwxyz", "YWI=" },
+ { 3, "abcdefghijklmnopqrstuvwxyz", "YWJj" },
+ { 4, "abcdefghijklmnopqrstuvwxyz", "YWJjZA==" },
+ { 5, "abcdefghijklmnopqrstuvwxyz", "YWJjZGU=" },
+ { 6, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVm" },
+ { 7, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZw==" },
+ { 8, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2g=" },
+ { 9, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hp" },
+ { 10, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpag==" },
+ { 11, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpams=" },
+ { 12, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamts" },
+ { 13, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamtsbQ==" },
+ { 14, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamtsbW4=" },
+ { 15, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamtsbW5v" },
+ { 16, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamtsbW5vcA==" },
+ { 17, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamtsbW5vcHE=" },
+ { 18, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamtsbW5vcHFy" },
+ { 19, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamtsbW5vcHFycw==" },
+ { 20, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamtsbW5vcHFyc3Q=" },
+ { 21, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1" },
+ { 22, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dg==" },
+ { 23, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnc=" },
+ { 24, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4" },
+ { 25, "abcdefghijklmnopqrstuvwxy", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eQ==" },
+ { 26, "abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXo=" },
+};
+#if 0
+static struct {
+ const char* plaintext;
+ const char* cyphertext;
+} base64_strings[] = {
+
+ // The first few Google quotes
+ // Cyphertext created with "uuencode - GNU sharutils 4.2.1"
+ {
+ "Everyone! We're teetering on the brink of disaster."
+ " - Sergey Brin, 6/24/99, regarding the company's state "
+ "after the unleashing of Netscape/Google search",
+
+ "RXZlcnlvbmUhICBXZSdyZSB0ZWV0ZXJpbmcgb24gdGhlIGJyaW5rIG9mIGRp"
+ "c2FzdGVyLiAtIFNlcmdleSBCcmluLCA2LzI0Lzk5LCByZWdhcmRpbmcgdGhl"
+ "IGNvbXBhbnkncyBzdGF0ZSBhZnRlciB0aGUgdW5sZWFzaGluZyBvZiBOZXRz"
+ "Y2FwZS9Hb29nbGUgc2VhcmNo" },
+
+ {
+ "I'm not sure why we're still alive, but we seem to be."
+ " - Larry Page, 6/24/99, while hiding in the kitchenette "
+ "during the Netscape traffic overflow",
+
+ "SSdtIG5vdCBzdXJlIHdoeSB3ZSdyZSBzdGlsbCBhbGl2ZSwgYnV0IHdlIHNl"
+ "ZW0gdG8gYmUuIC0gTGFycnkgUGFnZSwgNi8yNC85OSwgd2hpbGUgaGlkaW5n"
+ "IGluIHRoZSBraXRjaGVuZXR0ZSBkdXJpbmcgdGhlIE5ldHNjYXBlIHRyYWZm"
+ "aWMgb3ZlcmZsb3c" },
+
+ {
+ "I think kids want porn."
+ " - Sergey Brin, 6/99, on why Google shouldn't prioritize a "
+ "filtered search for children and families",
+
+ "SSB0aGluayBraWRzIHdhbnQgcG9ybi4gLSBTZXJnZXkgQnJpbiwgNi85OSwg"
+ "b24gd2h5IEdvb2dsZSBzaG91bGRuJ3QgcHJpb3JpdGl6ZSBhIGZpbHRlcmVk"
+ "IHNlYXJjaCBmb3IgY2hpbGRyZW4gYW5kIGZhbWlsaWVz" },
+};
+#endif
+// Compare bytes 0..len-1 of x and y. If not equal, abort with verbose error
+// message showing position and numeric value that differed.
+// Handles embedded nulls just like any other byte.
+// Only added because string.compare() in gcc-3.3.3 seems to misbehave with
+// embedded nulls.
+// TODO: switch back to string.compare() if/when gcc is fixed
+#define EXPECT_EQ_ARRAY(len, x, y, msg) \
+ for (size_t j = 0; j < len; ++j) { \
+ if (x[j] != y[j]) { \
+ LOG(LS_ERROR) << "" # x << " != " # y \
+ << " byte " << j << " msg: " << msg; \
+ } \
+ }
+
+size_t Base64Escape(const unsigned char *src, size_t szsrc, char *dest,
+ size_t szdest) {
+ std::string escaped;
+ Base64::EncodeFromArray((const char *)src, szsrc, &escaped);
+ memcpy(dest, escaped.data(), min(escaped.size(), szdest));
+ return escaped.size();
+}
+
+size_t Base64Unescape(const char *src, size_t szsrc, char *dest,
+ size_t szdest) {
+ std::string unescaped;
+ EXPECT_TRUE(Base64::DecodeFromArray(src, szsrc, Base64::DO_LAX, &unescaped,
+ NULL));
+ memcpy(dest, unescaped.data(), min(unescaped.size(), szdest));
+ return unescaped.size();
+}
+
+size_t Base64Unescape(const char *src, size_t szsrc, string *s) {
+ EXPECT_TRUE(Base64::DecodeFromArray(src, szsrc, Base64::DO_LAX, s, NULL));
+ return s->size();
+}
+
+TEST(Base64, EncodeDecodeBattery) {
+ LOG(LS_VERBOSE) << "Testing base-64";
+
+ size_t i;
+
+ // Check the short strings; this tests the math (and boundaries)
+ for( i = 0; i < sizeof(base64_tests) / sizeof(base64_tests[0]); ++i ) {
+ char encode_buffer[100];
+ size_t encode_length;
+ char decode_buffer[100];
+ size_t decode_length;
+ size_t cypher_length;
+
+ LOG(LS_VERBOSE) << "B64: " << base64_tests[i].cyphertext;
+
+ const unsigned char* unsigned_plaintext =
+ reinterpret_cast<const unsigned char*>(base64_tests[i].plaintext);
+
+ cypher_length = strlen(base64_tests[i].cyphertext);
+
+ // The basic escape function:
+ memset(encode_buffer, 0, sizeof(encode_buffer));
+ encode_length = Base64Escape(unsigned_plaintext,
+ base64_tests[i].plain_length,
+ encode_buffer,
+ sizeof(encode_buffer));
+ // Is it of the expected length?
+ EXPECT_EQ(encode_length, cypher_length);
+
+ // Is it the expected encoded value?
+ EXPECT_STREQ(encode_buffer, base64_tests[i].cyphertext);
+
+ // If we encode it into a buffer of exactly the right length...
+ memset(encode_buffer, 0, sizeof(encode_buffer));
+ encode_length = Base64Escape(unsigned_plaintext,
+ base64_tests[i].plain_length,
+ encode_buffer,
+ cypher_length);
+ // Is it still of the expected length?
+ EXPECT_EQ(encode_length, cypher_length);
+
+ // And is the value still correct? (i.e., not losing the last byte)
+ EXPECT_STREQ(encode_buffer, base64_tests[i].cyphertext);
+
+ // If we decode it back:
+ memset(decode_buffer, 0, sizeof(decode_buffer));
+ decode_length = Base64Unescape(encode_buffer,
+ cypher_length,
+ decode_buffer,
+ sizeof(decode_buffer));
+
+ // Is it of the expected length?
+ EXPECT_EQ(decode_length, base64_tests[i].plain_length);
+
+ // Is it the expected decoded value?
+ EXPECT_EQ(0, memcmp(decode_buffer, base64_tests[i].plaintext, decode_length));
+
+ // Our decoder treats the padding '=' characters at the end as
+ // optional. If encode_buffer has any, run some additional
+ // tests that fiddle with them.
+ char* first_equals = strchr(encode_buffer, '=');
+ if (first_equals) {
+ // How many equals signs does the string start with?
+ int equals = (*(first_equals+1) == '=') ? 2 : 1;
+
+ // Try chopping off the equals sign(s) entirely. The decoder
+ // should still be okay with this.
+ string decoded2("this junk should also be ignored");
+ *first_equals = '\0';
+ EXPECT_NE(0U, Base64Unescape(encode_buffer, first_equals-encode_buffer,
+ &decoded2));
+ EXPECT_EQ(decoded2.size(), base64_tests[i].plain_length);
+ EXPECT_EQ_ARRAY(decoded2.size(), decoded2.data(), base64_tests[i].plaintext, i);
+
+ int len;
+
+ // try putting some extra stuff after the equals signs, or in between them
+ if (equals == 2) {
+ sprintfn(first_equals, 6, " = = ");
+ len = first_equals - encode_buffer + 5;
+ } else {
+ sprintfn(first_equals, 6, " = ");
+ len = first_equals - encode_buffer + 3;
+ }
+ decoded2.assign("this junk should be ignored");
+ EXPECT_NE(0U, Base64Unescape(encode_buffer, len, &decoded2));
+ EXPECT_EQ(decoded2.size(), base64_tests[i].plain_length);
+ EXPECT_EQ_ARRAY(decoded2.size(), decoded2, base64_tests[i].plaintext, i);
+ }
+ }
+}
+
+// here's a weird case: a giant base64 encoded stream which broke our base64
+// decoding. Let's test it explicitly.
+const char SpecificTest[] =
+ "/9j/4AAQSkZJRgABAgEASABIAAD/4Q0HRXhpZgAATU0AKgAAAAgADAEOAAIAAAAgAAAAngEPAAI\n"
+ "AAAAFAAAAvgEQAAIAAAAJAAAAwwESAAMAAAABAAEAAAEaAAUAAAABAAAAzAEbAAUAAAABAAAA1A\n"
+ "EoAAMAAAABAAIAAAExAAIAAAAUAAAA3AEyAAIAAAAUAAAA8AE8AAIAAAAQAAABBAITAAMAAAABA\n"
+ "AIAAIdpAAQAAAABAAABFAAAAsQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgAFNPTlkA\n"
+ "RFNDLVAyMDAAAAAASAAAAAEAAABIAAAAAUFkb2JlIFBob3Rvc2hvcCA3LjAAMjAwNzowMTozMCA\n"
+ "yMzoxMDowNABNYWMgT1MgWCAxMC40LjgAAByCmgAFAAAAAQAAAmqCnQAFAAAAAQAAAnKIIgADAA\n"
+ "AAAQACAACIJwADAAAAAQBkAACQAAAHAAAABDAyMjCQAwACAAAAFAAAAnqQBAACAAAAFAAAAo6RA\n"
+ "QAHAAAABAECAwCRAgAFAAAAAQAAAqKSBAAKAAAAAQAAAqqSBQAFAAAAAQAAArKSBwADAAAAAQAF\n"
+ "AACSCAADAAAAAQAAAACSCQADAAAAAQAPAACSCgAFAAAAAQAAArqgAAAHAAAABDAxMDCgAQADAAA\n"
+ "AAf//AACgAgAEAAAAAQAAAGSgAwAEAAAAAQAAAGSjAAAHAAAAAQMAAACjAQAHAAAAAQEAAACkAQ\n"
+ "ADAAAAAQAAAACkAgADAAAAAQAAAACkAwADAAAAAQAAAACkBgADAAAAAQAAAACkCAADAAAAAQAAA\n"
+ "ACkCQADAAAAAQAAAACkCgADAAAAAQAAAAAAAAAAAAAACgAAAZAAAAAcAAAACjIwMDc6MDE6MjAg\n"
+ "MjM6MDU6NTIAMjAwNzowMToyMCAyMzowNTo1MgAAAAAIAAAAAQAAAAAAAAAKAAAAMAAAABAAAAB\n"
+ "PAAAACgAAAAYBAwADAAAAAQAGAAABGgAFAAAAAQAAAxIBGwAFAAAAAQAAAxoBKAADAAAAAQACAA\n"
+ "ACAQAEAAAAAQAAAyICAgAEAAAAAQAACd0AAAAAAAAASAAAAAEAAABIAAAAAf/Y/+AAEEpGSUYAA\n"
+ "QIBAEgASAAA/+0ADEFkb2JlX0NNAAL/7gAOQWRvYmUAZIAAAAAB/9sAhAAMCAgICQgMCQkMEQsK\n"
+ "CxEVDwwMDxUYExMVExMYEQwMDAwMDBEMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAQ0LCw0\n"
+ "ODRAODhAUDg4OFBQODg4OFBEMDAwMDBERDAwMDAwMEQwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDA\n"
+ "wMDAz/wAARCABkAGQDASIAAhEBAxEB/90ABAAH/8QBPwAAAQUBAQEBAQEAAAAAAAAAAwABAgQFB\n"
+ "gcICQoLAQABBQEBAQEBAQAAAAAAAAABAAIDBAUGBwgJCgsQAAEEAQMCBAIFBwYIBQMMMwEAAhED\n"
+ "BCESMQVBUWETInGBMgYUkaGxQiMkFVLBYjM0coLRQwclklPw4fFjczUWorKDJkSTVGRFwqN0Nhf\n"
+ "SVeJl8rOEw9N14/NGJ5SkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2N0dXZ3eHl6e3x9fn9xEAAg\n"
+ "IBAgQEAwQFBgcHBgU1AQACEQMhMRIEQVFhcSITBTKBkRShsUIjwVLR8DMkYuFygpJDUxVjczTxJ\n"
+ "QYWorKDByY1wtJEk1SjF2RFVTZ0ZeLys4TD03Xj80aUpIW0lcTU5PSltcXV5fVWZnaGlqa2xtbm\n"
+ "9ic3R1dnd4eXp7fH/9oADAMBAAIRAxEAPwDy7bKNTUXNLz9EaJPDWMjxH4ozhtpYwaACT8ShaaW\n"
+ "bW0uEc9/JFfjj0Q4Hk/PRDxwX7y47W9z/AN9Cv4+O3ILK2DcRqT2CaSvEbcl1Jbz37KG1dBldLo\n"
+ "qaS4l9xGjG9v6yoDAdYIaIjUk+AREgo4y5sapirb8Yl0NHHdKvBNm4yA1o5Pc+SPEFvCWqB3HZF\n"
+ "Hj2SbWQ/afGFP0bHP8ATY0uc4w1o1JPkkimGiS2KvqlnmBkOZQTyydzgPMM9v8A0lp4v1Nx9gF1\n"
+ "tpdqJaGtH/S3I0i3lISXW/8AMqnd/O2bfg2eUkqVYf/Q8zuncO4Bj7lZ+n7f5Mj5KsJcY8NUZ4d\n"
+ "uEDVo1HkeU0rg3Om4H2rabCWUN7DQuK1n5FWKW4uCwG92gDRJBS6exhxmMboQI+Cv4WFTQ42Bs2\n"
+ "fvnkkqEmy2YxoMMbpVzaz6jt+RbpHZs8lzkHqrasKkYOKP0jgDfZ4N/wDM1tNrcWfSPmRyq9uNV\n"
+ "DnFg2s97i7UkjxKVrq0eVz3spZsja+ASDzwsh9jnOk/JFzb3XZD3v1c4yT8UACTCniKDUnKz5Nj\n"
+ "G33XV1DV73BrT8dF23SejV4zg9g33cOsPb+SxVvqv9ViwNy8vS0iWs/daf8A0Y5dpTi1sADGxCR\n"
+ "K1o0YBEmInlXWYbDBcDLdPJXa8f71Yrx2jnUoAqLnfZK5hJaW2vdwEk5a/wD/0fN6Ia/e76IiVf\n"
+ "xavUL7CPpnT4LNbYXAVjuQt/AqDmNYO/Kjnoy4hr5J8SwMhrRMaeSvbsxrfUazcOw4UX0Cisem2\n"
+ "SBoD4+Kz8nC6llbSLCRrubJA8kwUWbUDa29X1PMa7aQWjuDC0MXMdbDbhI7eazBiUfZ6GOYRe1s\n"
+ "WvGgJ8Vbw2+m4Bx9s6JpNHuuGo1FF53r/SHYua61gLse0lzXeBP5rkvqx0o5vVWz7WY49QkiQSP\n"
+ "oN/tLoevW/ogxv0HA7tJ0AnhT+pdDGYVl/wCdcTPkGn2NU0JWNWvlgAbHV6fEqdu2gR/r2WlWwt\n"
+ "AA5VXAEsLXTqJafArQY5rRr9LiPBJiZsZCI1pJjxCi0j4oncSICSkWwzwkjeaSch//0vO7sP7Lm\n"
+ "enO9ogtd5FbPT3Q5pCpZVc4ld3Lmn3O8j9EI2BYdunKjOobMQIyI+rusc2wx4d0eutwGnHh/uQc\n"
+ "Ha7ladj6mVANGvcqOgz0Go7HJ12/GEHcwvB/dPY6ImbbaMaASGuIBjkN7qofs9Ubg9g7OI9p/t/\n"
+ "RTSmhTHr0v6eSz6UgCPP2/wAVu9Ex2V49dVY2iACB4BZeVXQ/AJ3gzGnnOi2+kACpru8flUsNmt\n"
+ "zHRf6xfWCnoeAfTh2ZaQKazx/Ke7+QxcKz61fWA2uuObaC4zGhaPJrXBL64ZFmR124O09ENraPK\n"
+ "N3/AH5GqxIrZVUyp2K2vfdkENsDnxuex9m4Ox9n82xSgNd9D+p/XR1npgseR9ppOy4Dx/NfH/CL\n"
+ "oQJGunmvMv8AFq3KHVcq3HkYQbD2nuSf0I/rMavSg6TLjLigQhJ7Z58v9QkmlsTOqSCn/9PzL7R\n"
+ "d6Qq3n0wZ2zotXpT9xLfFYvkr/S7jXeB8E0jRkhKpC3q8LcJ/kmCrTnkuAPCq4do9Q/ytVbuAeY\n"
+ "Gg5lQybQK+82GBqEQUA1kOHPYf3LLsoyN36G5w8iUfHxepbXE2l0cApALgLHzBq9UxhTXU5hMC1\n"
+ "ktnSCup6S4Ctk+C5XqVGcaHPfuiuHkeTTuWz0+9zaKiH6CC0/yXBSQ2a/MxojV57634rq+v2PLY\n"
+ "be1r2nsYG13/AFKxbfCBMcr0brGAzrGEwCG31ncx0SfBzf7S4+zoHUWWsJq3hz9oLfcBH77R9H+\n"
+ "0pA13u/qPgDp/Q6ri39JlfpXkDx+h/msWn1L6wdO6bSbcrIbU2Q0xLnSe21kuVejJspbVS5+4bd\n"
+ "ocBAkD/orG+tP1ar67Wy7GtZTm1SCXfRsb+a18fRe38x6SG3/44H1Z3f0y2I+l6DoSXD/8xPrDs\n"
+ "3enVu3bdnqN3R+//USSVo//1PLohhce+gRWS0Nsby3lRgFkKxQyW7SgUh3em5Tbq2uB9wWw1wey\n"
+ "J1XGV2XYdm5k7e4WzidXY9oMwo5RZ4T6Hd1ixwfp96PWbAJBVTHzK7O6Ky5oJB1HZMqmUEFlkGy\n"
+ "xpa4zI1Hkq31dy7bMN9BAc3HeWAnnbyxEycmuup1jiAGglZ31PyrmZ9tQg1WtNj54EHR3/S2qTH\n"
+ "1Yc5GgD1FFtzPdWGkd2AyflogZmRmsz6PSrbXbdo+txOrP337f3fzVo15DK2uyrTtqpBOnBKx6b\n"
+ "7MjJsz7tHWOAYP3WD6LU6cqGjFCNl1MmvLcxv6YtDTLSAqP27LrdtYHXFnJZI+Tp3MWg68OpDPv\n"
+ "UMUM2lkQBoouKQ6swjE9Nml+1sz1PW+z6xt27zuj+skrX2ZvqR5z8kkuOfdPt43/1fMm/grFG6f\n"
+ "Lss9JA7JG7tnZs/SfJUrfS3foJ9TvHCopJsV8nWx/t24bJn8Fo/5TjWJXMJIS+i+G36TsZ/7Q9P\n"
+ "8ATfzfeOFofVSZv2/zvt+O3X/v65dJPjt/BiyfN1/wn0zre79nVej/ADG8ep4x2/6Srjd6TdviF\n"
+ "52ko8m6/Ht9X1KnftEo+POwxzK8mSTF46vrH6T1/OEl5Okkl//Z/+0uHFBob3Rvc2hvcCAzLjAA\n"
+ "OEJJTQQEAAAAAAArHAIAAAIAAhwCeAAfICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAA\n"
+ "4QklNBCUAAAAAABD7Caa9B0wqNp2P4sxXqayFOEJJTQPqAAAAAB2wPD94bWwgdmVyc2lvbj0iMS\n"
+ "4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPCFET0NUWVBFIHBsaXN0IFBVQkxJQyAiLS8vQXBwbGUgQ\n"
+ "29tcHV0ZXIvL0RURCBQTElTVCAxLjAvL0VOIiAiaHR0cDovL3d3dy5hcHBsZS5jb20vRFREcy9Q\n"
+ "cm9wZXJ0eUxpc3QtMS4wLmR0ZCI+CjxwbGlzdCB2ZXJzaW9uPSIxLjAiPgo8ZGljdD4KCTxrZXk\n"
+ "+Y29tLmFwcGxlLnByaW50LlBhZ2VGb3JtYXQuUE1Ib3Jpem9udGFsUmVzPC9rZXk+Cgk8ZGljdD\n"
+ "4KCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuY3JlYXRvcjwva2V5PgoJCTxzdHJpbmc+Y\n"
+ "29tLmFwcGxlLnByaW50aW5nbWFuYWdlcjwvc3RyaW5nPgoJCTxrZXk+Y29tLmFwcGxlLnByaW50\n"
+ "LnRpY2tldC5pdGVtQXJyYXk8L2tleT4KCQk8YXJyYXk+CgkJCTxkaWN0PgoJCQkJPGtleT5jb20\n"
+ "uYXBwbGUucHJpbnQuUGFnZUZvcm1hdC5QTUhvcml6b250YWxSZXM8L2tleT4KCQkJCTxyZWFsPj\n"
+ "cyPC9yZWFsPgoJCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LmNsaWVudDwva2V5PgoJC\n"
+ "QkJPHN0cmluZz5jb20uYXBwbGUucHJpbnRpbmdtYW5hZ2VyPC9zdHJpbmc+CgkJCQk8a2V5PmNv\n"
+ "bS5hcHBsZS5wcmludC50aWNrZXQubW9kRGF0ZTwva2V5PgoJCQkJPGRhdGU+MjAwNy0wMS0zMFQ\n"
+ "yMjowODo0MVo8L2RhdGU+CgkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuc3RhdGVGbG\n"
+ "FnPC9rZXk+CgkJCQk8aW50ZWdlcj4wPC9pbnRlZ2VyPgoJCQk8L2RpY3Q+CgkJPC9hcnJheT4KC\n"
+ "TwvZGljdD4KCTxrZXk+Y29tLmFwcGxlLnByaW50LlBhZ2VGb3JtYXQuUE1PcmllbnRhdGlvbjwv\n"
+ "a2V5PgoJPGRpY3Q+CgkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LmNyZWF0b3I8L2tleT4\n"
+ "KCQk8c3RyaW5nPmNvbS5hcHBsZS5wcmludGluZ21hbmFnZXI8L3N0cmluZz4KCQk8a2V5PmNvbS\n"
+ "5hcHBsZS5wcmludC50aWNrZXQuaXRlbUFycmF5PC9rZXk+CgkJPGFycmF5PgoJCQk8ZGljdD4KC\n"
+ "QkJCTxrZXk+Y29tLmFwcGxlLnByaW50LlBhZ2VGb3JtYXQuUE1PcmllbnRhdGlvbjwva2V5PgoJ\n"
+ "CQkJPGludGVnZXI+MTwvaW50ZWdlcj4KCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5\n"
+ "jbGllbnQ8L2tleT4KCQkJCTxzdHJpbmc+Y29tLmFwcGxlLnByaW50aW5nbWFuYWdlcjwvc3RyaW\n"
+ "5nPgoJCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lm1vZERhdGU8L2tleT4KCQkJCTxkY\n"
+ "XRlPjIwMDctMDEtMzBUMjI6MDg6NDFaPC9kYXRlPgoJCQkJPGtleT5jb20uYXBwbGUucHJpbnQu\n"
+ "dGlja2V0LnN0YXRlRmxhZzwva2V5PgoJCQkJPGludGVnZXI+MDwvaW50ZWdlcj4KCQkJPC9kaWN\n"
+ "0PgoJCTwvYXJyYXk+Cgk8L2RpY3Q+Cgk8a2V5PmNvbS5hcHBsZS5wcmludC5QYWdlRm9ybWF0Ll\n"
+ "BNU2NhbGluZzwva2V5PgoJPGRpY3Q+CgkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LmNyZ\n"
+ "WF0b3I8L2tleT4KCQk8c3RyaW5nPmNvbS5hcHBsZS5wcmludGluZ21hbmFnZXI8L3N0cmluZz4K\n"
+ "CQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuaXRlbUFycmF5PC9rZXk+CgkJPGFycmF5Pgo\n"
+ "JCQk8ZGljdD4KCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LlBhZ2VGb3JtYXQuUE1TY2FsaW5nPC\n"
+ "9rZXk+CgkJCQk8cmVhbD4xPC9yZWFsPgoJCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0L\n"
+ "mNsaWVudDwva2V5PgoJCQkJPHN0cmluZz5jb20uYXBwbGUucHJpbnRpbmdtYW5hZ2VyPC9zdHJp\n"
+ "bmc+CgkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQubW9kRGF0ZTwva2V5PgoJCQkJPGR\n"
+ "hdGU+MjAwNy0wMS0zMFQyMjowODo0MVo8L2RhdGU+CgkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC\n"
+ "50aWNrZXQuc3RhdGVGbGFnPC9rZXk+CgkJCQk8aW50ZWdlcj4wPC9pbnRlZ2VyPgoJCQk8L2RpY\n"
+ "3Q+CgkJPC9hcnJheT4KCTwvZGljdD4KCTxrZXk+Y29tLmFwcGxlLnByaW50LlBhZ2VGb3JtYXQu\n"
+ "UE1WZXJ0aWNhbFJlczwva2V5PgoJPGRpY3Q+CgkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V\n"
+ "0LmNyZWF0b3I8L2tleT4KCQk8c3RyaW5nPmNvbS5hcHBsZS5wcmludGluZ21hbmFnZXI8L3N0cm\n"
+ "luZz4KCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuaXRlbUFycmF5PC9rZXk+CgkJPGFyc\n"
+ "mF5PgoJCQk8ZGljdD4KCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LlBhZ2VGb3JtYXQuUE1WZXJ0\n"
+ "aWNhbFJlczwva2V5PgoJCQkJPHJlYWw+NzI8L3JlYWw+CgkJCQk8a2V5PmNvbS5hcHBsZS5wcml\n"
+ "udC50aWNrZXQuY2xpZW50PC9rZXk+CgkJCQk8c3RyaW5nPmNvbS5hcHBsZS5wcmludGluZ21hbm\n"
+ "FnZXI8L3N0cmluZz4KCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5tb2REYXRlPC9rZ\n"
+ "Xk+CgkJCQk8ZGF0ZT4yMDA3LTAxLTMwVDIyOjA4OjQxWjwvZGF0ZT4KCQkJCTxrZXk+Y29tLmFw\n"
+ "cGxlLnByaW50LnRpY2tldC5zdGF0ZUZsYWc8L2tleT4KCQkJCTxpbnRlZ2VyPjA8L2ludGVnZXI\n"
+ "+CgkJCTwvZGljdD4KCQk8L2FycmF5PgoJPC9kaWN0PgoJPGtleT5jb20uYXBwbGUucHJpbnQuUG\n"
+ "FnZUZvcm1hdC5QTVZlcnRpY2FsU2NhbGluZzwva2V5PgoJPGRpY3Q+CgkJPGtleT5jb20uYXBwb\n"
+ "GUucHJpbnQudGlja2V0LmNyZWF0b3I8L2tleT4KCQk8c3RyaW5nPmNvbS5hcHBsZS5wcmludGlu\n"
+ "Z21hbmFnZXI8L3N0cmluZz4KCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuaXRlbUFycmF\n"
+ "5PC9rZXk+CgkJPGFycmF5PgoJCQk8ZGljdD4KCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LlBhZ2\n"
+ "VGb3JtYXQuUE1WZXJ0aWNhbFNjYWxpbmc8L2tleT4KCQkJCTxyZWFsPjE8L3JlYWw+CgkJCQk8a\n"
+ "2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuY2xpZW50PC9rZXk+CgkJCQk8c3RyaW5nPmNvbS5h\n"
+ "cHBsZS5wcmludGluZ21hbmFnZXI8L3N0cmluZz4KCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnR\n"
+ "pY2tldC5tb2REYXRlPC9rZXk+CgkJCQk8ZGF0ZT4yMDA3LTAxLTMwVDIyOjA4OjQxWjwvZGF0ZT\n"
+ "4KCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5zdGF0ZUZsYWc8L2tleT4KCQkJCTxpb\n"
+ "nRlZ2VyPjA8L2ludGVnZXI+CgkJCTwvZGljdD4KCQk8L2FycmF5PgoJPC9kaWN0PgoJPGtleT5j\n"
+ "b20uYXBwbGUucHJpbnQuc3ViVGlja2V0LnBhcGVyX2luZm9fdGlja2V0PC9rZXk+Cgk8ZGljdD4\n"
+ "KCQk8a2V5PmNvbS5hcHBsZS5wcmludC5QYWdlRm9ybWF0LlBNQWRqdXN0ZWRQYWdlUmVjdDwva2\n"
+ "V5PgoJCTxkaWN0PgoJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuY3JlYXRvcjwva2V5P\n"
+ "goJCQk8c3RyaW5nPmNvbS5hcHBsZS5wcmludGluZ21hbmFnZXI8L3N0cmluZz4KCQkJPGtleT5j\n"
+ "b20uYXBwbGUucHJpbnQudGlja2V0Lml0ZW1BcnJheTwva2V5PgoJCQk8YXJyYXk+CgkJCQk8ZGl\n"
+ "jdD4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC5QYWdlRm9ybWF0LlBNQWRqdXN0ZWRQYWdlUm\n"
+ "VjdDwva2V5PgoJCQkJCTxhcnJheT4KCQkJCQkJPHJlYWw+MC4wPC9yZWFsPgoJCQkJCQk8cmVhb\n"
+ "D4wLjA8L3JlYWw+CgkJCQkJCTxyZWFsPjczNDwvcmVhbD4KCQkJCQkJPHJlYWw+NTc2PC9yZWFs\n"
+ "PgoJCQkJCTwvYXJyYXk+CgkJCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LmNsaWVudDw\n"
+ "va2V5PgoJCQkJCTxzdHJpbmc+Y29tLmFwcGxlLnByaW50aW5nbWFuYWdlcjwvc3RyaW5nPgoJCQ\n"
+ "kJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5tb2REYXRlPC9rZXk+CgkJCQkJPGRhdGU+M\n"
+ "jAwNy0wMS0zMFQyMjowODo0MVo8L2RhdGU+CgkJCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlj\n"
+ "a2V0LnN0YXRlRmxhZzwva2V5PgoJCQkJCTxpbnRlZ2VyPjA8L2ludGVnZXI+CgkJCQk8L2RpY3Q\n"
+ "+CgkJCTwvYXJyYXk+CgkJPC9kaWN0PgoJCTxrZXk+Y29tLmFwcGxlLnByaW50LlBhZ2VGb3JtYX\n"
+ "QuUE1BZGp1c3RlZFBhcGVyUmVjdDwva2V5PgoJCTxkaWN0PgoJCQk8a2V5PmNvbS5hcHBsZS5wc\n"
+ "mludC50aWNrZXQuY3JlYXRvcjwva2V5PgoJCQk8c3RyaW5nPmNvbS5hcHBsZS5wcmludGluZ21h\n"
+ "bmFnZXI8L3N0cmluZz4KCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lml0ZW1BcnJheTw\n"
+ "va2V5PgoJCQk8YXJyYXk+CgkJCQk8ZGljdD4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC5QYW\n"
+ "dlRm9ybWF0LlBNQWRqdXN0ZWRQYXBlclJlY3Q8L2tleT4KCQkJCQk8YXJyYXk+CgkJCQkJCTxyZ\n"
+ "WFsPi0xODwvcmVhbD4KCQkJCQkJPHJlYWw+LTE4PC9yZWFsPgoJCQkJCQk8cmVhbD43NzQ8L3Jl\n"
+ "YWw+CgkJCQkJCTxyZWFsPjU5NDwvcmVhbD4KCQkJCQk8L2FycmF5PgoJCQkJCTxrZXk+Y29tLmF\n"
+ "wcGxlLnByaW50LnRpY2tldC5jbGllbnQ8L2tleT4KCQkJCQk8c3RyaW5nPmNvbS5hcHBsZS5wcm\n"
+ "ludGluZ21hbmFnZXI8L3N0cmluZz4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQub\n"
+ "W9kRGF0ZTwva2V5PgoJCQkJCTxkYXRlPjIwMDctMDEtMzBUMjI6MDg6NDFaPC9kYXRlPgoJCQkJ\n"
+ "CTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5zdGF0ZUZsYWc8L2tleT4KCQkJCQk8aW50ZWd\n"
+ "lcj4wPC9pbnRlZ2VyPgoJCQkJPC9kaWN0PgoJCQk8L2FycmF5PgoJCTwvZGljdD4KCQk8a2V5Pm\n"
+ "NvbS5hcHBsZS5wcmludC5QYXBlckluZm8uUE1QYXBlck5hbWU8L2tleT4KCQk8ZGljdD4KCQkJP\n"
+ "GtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LmNyZWF0b3I8L2tleT4KCQkJPHN0cmluZz5jb20u\n"
+ "YXBwbGUucHJpbnQucG0uUG9zdFNjcmlwdDwvc3RyaW5nPgoJCQk8a2V5PmNvbS5hcHBsZS5wcml\n"
+ "udC50aWNrZXQuaXRlbUFycmF5PC9rZXk+CgkJCTxhcnJheT4KCQkJCTxkaWN0PgoJCQkJCTxrZX\n"
+ "k+Y29tLmFwcGxlLnByaW50LlBhcGVySW5mby5QTVBhcGVyTmFtZTwva2V5PgoJCQkJCTxzdHJpb\n"
+ "mc+bmEtbGV0dGVyPC9zdHJpbmc+CgkJCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LmNs\n"
+ "aWVudDwva2V5PgoJCQkJCTxzdHJpbmc+Y29tLmFwcGxlLnByaW50LnBtLlBvc3RTY3JpcHQ8L3N\n"
+ "0cmluZz4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQubW9kRGF0ZTwva2V5PgoJCQ\n"
+ "kJCTxkYXRlPjIwMDMtMDctMDFUMTc6NDk6MzZaPC9kYXRlPgoJCQkJCTxrZXk+Y29tLmFwcGxlL\n"
+ "nByaW50LnRpY2tldC5zdGF0ZUZsYWc8L2tleT4KCQkJCQk8aW50ZWdlcj4xPC9pbnRlZ2VyPgoJ\n"
+ "CQkJPC9kaWN0PgoJCQk8L2FycmF5PgoJCTwvZGljdD4KCQk8a2V5PmNvbS5hcHBsZS5wcmludC5\n"
+ "QYXBlckluZm8uUE1VbmFkanVzdGVkUGFnZVJlY3Q8L2tleT4KCQk8ZGljdD4KCQkJPGtleT5jb2\n"
+ "0uYXBwbGUucHJpbnQudGlja2V0LmNyZWF0b3I8L2tleT4KCQkJPHN0cmluZz5jb20uYXBwbGUuc\n"
+ "HJpbnQucG0uUG9zdFNjcmlwdDwvc3RyaW5nPgoJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNr\n"
+ "ZXQuaXRlbUFycmF5PC9rZXk+CgkJCTxhcnJheT4KCQkJCTxkaWN0PgoJCQkJCTxrZXk+Y29tLmF\n"
+ "wcGxlLnByaW50LlBhcGVySW5mby5QTVVuYWRqdXN0ZWRQYWdlUmVjdDwva2V5PgoJCQkJCTxhcn\n"
+ "JheT4KCQkJCQkJPHJlYWw+MC4wPC9yZWFsPgoJCQkJCQk8cmVhbD4wLjA8L3JlYWw+CgkJCQkJC\n"
+ "TxyZWFsPjczNDwvcmVhbD4KCQkJCQkJPHJlYWw+NTc2PC9yZWFsPgoJCQkJCTwvYXJyYXk+CgkJ\n"
+ "CQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LmNsaWVudDwva2V5PgoJCQkJCTxzdHJpbmc\n"
+ "+Y29tLmFwcGxlLnByaW50aW5nbWFuYWdlcjwvc3RyaW5nPgoJCQkJCTxrZXk+Y29tLmFwcGxlLn\n"
+ "ByaW50LnRpY2tldC5tb2REYXRlPC9rZXk+CgkJCQkJPGRhdGU+MjAwNy0wMS0zMFQyMjowODo0M\n"
+ "Vo8L2RhdGU+CgkJCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LnN0YXRlRmxhZzwva2V5\n"
+ "PgoJCQkJCTxpbnRlZ2VyPjA8L2ludGVnZXI+CgkJCQk8L2RpY3Q+CgkJCTwvYXJyYXk+CgkJPC9\n"
+ "kaWN0PgoJCTxrZXk+Y29tLmFwcGxlLnByaW50LlBhcGVySW5mby5QTVVuYWRqdXN0ZWRQYXBlcl\n"
+ "JlY3Q8L2tleT4KCQk8ZGljdD4KCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LmNyZWF0b\n"
+ "3I8L2tleT4KCQkJPHN0cmluZz5jb20uYXBwbGUucHJpbnQucG0uUG9zdFNjcmlwdDwvc3RyaW5n\n"
+ "PgoJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuaXRlbUFycmF5PC9rZXk+CgkJCTxhcnJ\n"
+ "heT4KCQkJCTxkaWN0PgoJCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LlBhcGVySW5mby5QTVVuYW\n"
+ "RqdXN0ZWRQYXBlclJlY3Q8L2tleT4KCQkJCQk8YXJyYXk+CgkJCQkJCTxyZWFsPi0xODwvcmVhb\n"
+ "D4KCQkJCQkJPHJlYWw+LTE4PC9yZWFsPgoJCQkJCQk8cmVhbD43NzQ8L3JlYWw+CgkJCQkJCTxy\n"
+ "ZWFsPjU5NDwvcmVhbD4KCQkJCQk8L2FycmF5PgoJCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnR\n"
+ "pY2tldC5jbGllbnQ8L2tleT4KCQkJCQk8c3RyaW5nPmNvbS5hcHBsZS5wcmludGluZ21hbmFnZX\n"
+ "I8L3N0cmluZz4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQubW9kRGF0ZTwva2V5P\n"
+ "goJCQkJCTxkYXRlPjIwMDctMDEtMzBUMjI6MDg6NDFaPC9kYXRlPgoJCQkJCTxrZXk+Y29tLmFw\n"
+ "cGxlLnByaW50LnRpY2tldC5zdGF0ZUZsYWc8L2tleT4KCQkJCQk8aW50ZWdlcj4wPC9pbnRlZ2V\n"
+ "yPgoJCQkJPC9kaWN0PgoJCQk8L2FycmF5PgoJCTwvZGljdD4KCQk8a2V5PmNvbS5hcHBsZS5wcm\n"
+ "ludC5QYXBlckluZm8ucHBkLlBNUGFwZXJOYW1lPC9rZXk+CgkJPGRpY3Q+CgkJCTxrZXk+Y29tL\n"
+ "mFwcGxlLnByaW50LnRpY2tldC5jcmVhdG9yPC9rZXk+CgkJCTxzdHJpbmc+Y29tLmFwcGxlLnBy\n"
+ "aW50LnBtLlBvc3RTY3JpcHQ8L3N0cmluZz4KCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V\n"
+ "0Lml0ZW1BcnJheTwva2V5PgoJCQk8YXJyYXk+CgkJCQk8ZGljdD4KCQkJCQk8a2V5PmNvbS5hcH\n"
+ "BsZS5wcmludC5QYXBlckluZm8ucHBkLlBNUGFwZXJOYW1lPC9rZXk+CgkJCQkJPHN0cmluZz5VU\n"
+ "yBMZXR0ZXI8L3N0cmluZz4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuY2xpZW50\n"
+ "PC9rZXk+CgkJCQkJPHN0cmluZz5jb20uYXBwbGUucHJpbnQucG0uUG9zdFNjcmlwdDwvc3RyaW5\n"
+ "nPgoJCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5tb2REYXRlPC9rZXk+CgkJCQkJPG\n"
+ "RhdGU+MjAwMy0wNy0wMVQxNzo0OTozNlo8L2RhdGU+CgkJCQkJPGtleT5jb20uYXBwbGUucHJpb\n"
+ "nQudGlja2V0LnN0YXRlRmxhZzwva2V5PgoJCQkJCTxpbnRlZ2VyPjE8L2ludGVnZXI+CgkJCQk8\n"
+ "L2RpY3Q+CgkJCTwvYXJyYXk+CgkJPC9kaWN0PgoJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2t\n"
+ "ldC5BUElWZXJzaW9uPC9rZXk+CgkJPHN0cmluZz4wMC4yMDwvc3RyaW5nPgoJCTxrZXk+Y29tLm\n"
+ "FwcGxlLnByaW50LnRpY2tldC5wcml2YXRlTG9jazwva2V5PgoJCTxmYWxzZS8+CgkJPGtleT5jb\n"
+ "20uYXBwbGUucHJpbnQudGlja2V0LnR5cGU8L2tleT4KCQk8c3RyaW5nPmNvbS5hcHBsZS5wcmlu\n"
+ "dC5QYXBlckluZm9UaWNrZXQ8L3N0cmluZz4KCTwvZGljdD4KCTxrZXk+Y29tLmFwcGxlLnByaW5\n"
+ "0LnRpY2tldC5BUElWZXJzaW9uPC9rZXk+Cgk8c3RyaW5nPjAwLjIwPC9zdHJpbmc+Cgk8a2V5Pm\n"
+ "NvbS5hcHBsZS5wcmludC50aWNrZXQucHJpdmF0ZUxvY2s8L2tleT4KCTxmYWxzZS8+Cgk8a2V5P\n"
+ "mNvbS5hcHBsZS5wcmludC50aWNrZXQudHlwZTwva2V5PgoJPHN0cmluZz5jb20uYXBwbGUucHJp\n"
+ "bnQuUGFnZUZvcm1hdFRpY2tldDwvc3RyaW5nPgo8L2RpY3Q+CjwvcGxpc3Q+CjhCSU0D6QAAAAA\n"
+ "AeAADAAAASABIAAAAAALeAkD/7v/uAwYCUgNnBSgD/AACAAAASABIAAAAAALYAigAAQAAAGQAAA\n"
+ "ABAAMDAwAAAAF//wABAAEAAAAAAAAAAAAAAABoCAAZAZAAAAAAACAAAAAAAAAAAAAAAAAAAAAAA\n"
+ "AAAAAAAAAAAADhCSU0D7QAAAAAAEABIAAAAAQABAEgAAAABAAE4QklNBCYAAAAAAA4AAAAAAAAA\n"
+ "AAAAP4AAADhCSU0EDQAAAAAABAAAAB44QklNBBkAAAAAAAQAAAAeOEJJTQPzAAAAAAAJAAAAAAA\n"
+ "AAAABADhCSU0ECgAAAAAAAQAAOEJJTScQAAAAAAAKAAEAAAAAAAAAAThCSU0D9QAAAAAASAAvZm\n"
+ "YAAQBsZmYABgAAAAAAAQAvZmYAAQChmZoABgAAAAAAAQAyAAAAAQBaAAAABgAAAAAAAQA1AAAAA\n"
+ "QAtAAAABgAAAAAAAThCSU0D+AAAAAAAcAAA/////////////////////////////wPoAAAAAP//\n"
+ "//////////////////////////8D6AAAAAD/////////////////////////////A+gAAAAA///\n"
+ "//////////////////////////wPoAAA4QklNBAgAAAAAABAAAAABAAACQAAAAkAAAAAAOEJJTQ\n"
+ "QeAAAAAAAEAAAAADhCSU0EGgAAAAADRQAAAAYAAAAAAAAAAAAAAGQAAABkAAAACABEAFMAQwAwA\n"
+ "DIAMwAyADUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAGQAAABkAAAAAAAAAAAA\n"
+ "AAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAEAAAAAAABudWxsAAAAAgAAAAZib3VuZHN\n"
+ "PYmpjAAAAAQAAAAAAAFJjdDEAAAAEAAAAAFRvcCBsb25nAAAAAAAAAABMZWZ0bG9uZwAAAAAAAA\n"
+ "AAQnRvbWxvbmcAAABkAAAAAFJnaHRsb25nAAAAZAAAAAZzbGljZXNWbExzAAAAAU9iamMAAAABA\n"
+ "AAAAAAFc2xpY2UAAAASAAAAB3NsaWNlSURsb25nAAAAAAAAAAdncm91cElEbG9uZwAAAAAAAAAG\n"
+ "b3JpZ2luZW51bQAAAAxFU2xpY2VPcmlnaW4AAAANYXV0b0dlbmVyYXRlZAAAAABUeXBlZW51bQA\n"
+ "AAApFU2xpY2VUeXBlAAAAAEltZyAAAAAGYm91bmRzT2JqYwAAAAEAAAAAAABSY3QxAAAABAAAAA\n"
+ "BUb3AgbG9uZwAAAAAAAAAATGVmdGxvbmcAAAAAAAAAAEJ0b21sb25nAAAAZAAAAABSZ2h0bG9uZ\n"
+ "wAAAGQAAAADdXJsVEVYVAAAAAEAAAAAAABudWxsVEVYVAAAAAEAAAAAAABNc2dlVEVYVAAAAAEA\n"
+ "AAAAAAZhbHRUYWdURVhUAAAAAQAAAAAADmNlbGxUZXh0SXNIVE1MYm9vbAEAAAAIY2VsbFRleHR\n"
+ "URVhUAAAAAQAAAAAACWhvcnpBbGlnbmVudW0AAAAPRVNsaWNlSG9yekFsaWduAAAAB2RlZmF1bH\n"
+ "QAAAAJdmVydEFsaWduZW51bQAAAA9FU2xpY2VWZXJ0QWxpZ24AAAAHZGVmYXVsdAAAAAtiZ0Nvb\n"
+ "G9yVHlwZWVudW0AAAARRVNsaWNlQkdDb2xvclR5cGUAAAAATm9uZQAAAAl0b3BPdXRzZXRsb25n\n"
+ "AAAAAAAAAApsZWZ0T3V0c2V0bG9uZwAAAAAAAAAMYm90dG9tT3V0c2V0bG9uZwAAAAAAAAALcml\n"
+ "naHRPdXRzZXRsb25nAAAAAAA4QklNBBEAAAAAAAEBADhCSU0EFAAAAAAABAAAAAE4QklNBAwAAA\n"
+ "AACfkAAAABAAAAZAAAAGQAAAEsAAB1MAAACd0AGAAB/9j/4AAQSkZJRgABAgEASABIAAD/7QAMQ\n"
+ "WRvYmVfQ00AAv/uAA5BZG9iZQBkgAAAAAH/2wCEAAwICAgJCAwJCQwRCwoLERUPDAwPFRgTExUT\n"
+ "ExgRDAwMDAwMEQwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwBDQsLDQ4NEA4OEBQODg4UFA4\n"
+ "ODg4UEQwMDAwMEREMDAwMDAwRDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAGQAZA\n"
+ "MBIgACEQEDEQH/3QAEAAf/xAE/AAABBQEBAQEBAQAAAAAAAAADAAECBAUGBwgJCgsBAAEFAQEBA\n"
+ "QEBAAAAAAAAAAEAAgMEBQYHCAkKCxAAAQQBAwIEAgUHBggFAwwzAQACEQMEIRIxBUFRYRMicYEy\n"
+ "BhSRobFCIyQVUsFiMzRygtFDByWSU/Dh8WNzNRaisoMmRJNUZEXCo3Q2F9JV4mXys4TD03Xj80Y\n"
+ "nlKSFtJXE1OT0pbXF1eX1VmZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3EQACAgECBAQDBAUGBwcGBT\n"
+ "UBAAIRAyExEgRBUWFxIhMFMoGRFKGxQiPBUtHwMyRi4XKCkkNTFWNzNPElBhaisoMHJjXC0kSTV\n"
+ "KMXZEVVNnRl4vKzhMPTdePzRpSkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2JzdHV2d3h5ent8f/\n"
+ "2gAMAwEAAhEDEQA/APLtso1NRc0vP0Rok8NYyPEfijOG2ljBoAJPxKFppZtbS4Rz38kV+OPRDge\n"
+ "T89EPHBfvLjtb3P8A30K/j47cgsrYNxGpPYJpK8RtyXUlvPfsobV0GV0uippLiX3EaMb2/rKgMB\n"
+ "1ghoiNST4BESCjjLmxqmKtvxiXQ0cd0q8E2bjIDWjk9z5I8QW8JaoHcdkUePZJtZD9p8YU/Rsc/\n"
+ "wBNjS5zjDWjUk+SSKYaJLYq+qWeYGQ5lBPLJ3OA8wz2/wDSWni/U3H2AXW2l2oloa0f9LcjSLeU\n"
+ "hJdb/wAyqd387Zt+DZ5SSpVh/9DzO6dw7gGPuVn6ft/kyPkqwlxjw1Rnh24QNWjUeR5TSuDc6bg\n"
+ "fatpsJZQ3sNC4rWfkVYpbi4LAb3aANEkFLp7GHGYxuhAj4K/hYVNDjYGzZ++eSSoSbLZjGgwxul\n"
+ "XNrPqO35FukdmzyXOQeqtqwqRg4o/SOAN9ng3/AMzW02txZ9I+ZHKr241UOcWDaz3uLtSSPEpWu\n"
+ "rR5XPeylmyNr4BIPPCyH2Oc6T8kXNvddkPe/VzjJPxQAJMKeIoNScrPk2MbfddXUNXvcGtPx0Xb\n"
+ "dJ6NXjOD2Dfdw6w9v5LFW+q/1WLA3Ly9LSJaz91p/wDRjl2lOLWwAMbEJErWjRgESYieVdZhsMF\n"
+ "wMt08ldrx/vVivHaOdSgCoud9krmElpba93ASTlr/AP/R83ohr97voiJV/Fq9QvsI+mdPgs1thc\n"
+ "BWO5C38CoOY1g78qOejLiGvknxLAyGtExp5K9uzGt9RrNw7DhRfQKKx6bZIGgPj4rPycLqWVtIs\n"
+ "JGu5skDyTBRZtQNrb1fU8xrtpBaO4MLQxcx1sNuEjt5rMGJR9noY5hF7Wxa8aAnxVvDb6bgHH2z\n"
+ "omk0e64ajUUXnev9Idi5rrWAux7SXNd4E/muS+rHSjm9VbPtZjj1CSJBI+g3+0uh69b+iDG/QcD\n"
+ "u0nQCeFP6l0MZhWX/AJ1xM+QafY1TQlY1a+WABsdXp8Sp27aBH+vZaVbC0ADlVcASwtdOolp8Ct\n"
+ "BjmtGv0uI8EmJmxkIjWkmPEKLSPiidxIgJKRbDPCSN5pJyH//S87uw/suZ6c72iC13kVs9PdDmk\n"
+ "KllVziV3cuafc7yP0QjYFh26cqM6hsxAjIj6u6xzbDHh3R663AaceH+5BwdruVp2PqZUA0a9yo6\n"
+ "DPQajscnXb8YQdzC8H909joiZttoxoBIa4gGOQ3uqh+z1RuD2Ds4j2n+39FNKaFMevS/p5LPpSA\n"
+ "I8/b/ABW70THZXj11VjaIAIHgFl5VdD8AneDMaec6Lb6QAKmu7x+VSw2a3MdF/rF9YKeh4B9OHZ\n"
+ "lpAprPH8p7v5DFwrPrV9YDa645toLjMaFo8mtcEvrhkWZHXbg7T0Q2to8o3f8AfkarEitlVTKnY\n"
+ "ra992QQ2wOfG57H2bg7H2fzbFKA130P6n9dHWemCx5H2mk7LgPH818f8IuhAka6ea8y/wAWrcod\n"
+ "VyrceRhBsPae5J/Qj+sxq9KDpMuMuKBCEntnny/1CSaWxM6pIKf/0/MvtF3pCrefTBnbOi1elP3\n"
+ "Et8Vi+Sv9LuNd4HwTSNGSEqkLerwtwn+SYKtOeS4A8Krh2j1D/K1Vu4B5gaDmVDJtAr7zYYGoRB\n"
+ "QDWQ4c9h/csuyjI3fobnDyJR8fF6ltcTaXRwCkAuAsfMGr1TGFNdTmEwLWS2dIK6npLgK2T4Lle\n"
+ "pUZxoc9+6K4eR5NO5bPT73NoqIfoILT/JcFJDZr8zGiNXnvrfiur6/Y8tht7WvaexgbXf8AUrFt\n"
+ "8IExyvRusYDOsYTAIbfWdzHRJ8HN/tLj7OgdRZawmreHP2gt9wEfvtH0f7SkDXe7+o+AOn9DquL\n"
+ "f0mV+leQPH6H+axafUvrB07ptJtyshtTZDTEudJ7bWS5V6MmyltVLn7ht2hwECQP+isb60/Vqvr\n"
+ "tbLsa1lObVIJd9Gxv5rXx9F7fzHpIbf/jgfVnd/TLYj6XoOhJcP/zE+sOzd6dW7dt2eo3dH7/9R\n"
+ "JJWj//U8uiGFx76BFZLQ2xvLeVGAWQrFDJbtKBSHd6blNura4H3BbDXB7InVcZXZdh2bmTt7hbO\n"
+ "J1dj2gzCjlFnhPod3WLHB+n3o9ZsAkFVMfMrs7orLmgkHUdkyqZQQWWQbLGlrjMjUeSrfV3Ltsw\n"
+ "30EBzcd5YCedvLETJya66nWOIAaCVnfU/KuZn21CDVa02PngQdHf9LapMfVhzkaAPUUW3M91YaR\n"
+ "3YDJ+WiBmZGazPo9Kttdt2j63E6s/fft/d/NWjXkMra7KtO2qkE6cErHpvsyMmzPu0dY4Bg/dYP\n"
+ "otTpyoaMUI2XUya8tzG/pi0NMtICo/bsut21gdcWclkj5OncxaDrw6kM+9QxQzaWRAGii4pDqzC\n"
+ "MT02aX7WzPU9b7PrG3bvO6P6yStfZm+pHnPySS4590+3jf/V8yb+CsUbp8uyz0kDskbu2dmz9J8\n"
+ "lSt9Ld+gn1O8cKikmxXydbH+3bhsmfwWj/lONYlcwkhL6L4bfpOxn/tD0/wBN/N944Wh9VJm/b/\n"
+ "O+347df+/rl0k+O38GLJ83X/CfTOt7v2dV6P8AMbx6njHb/pKuN3pN2+IXnaSjybr8e31fUqd+0\n"
+ "Sj487DHMryZJMXjq+sfpPX84SXk6SSX/9kAOEJJTQQhAAAAAABVAAAAAQEAAAAPAEEAZABvAGIA\n"
+ "ZQAgAFAAaABvAHQAbwBzAGgAbwBwAAAAEwBBAGQAbwBiAGUAIABQAGgAbwB0AG8AcwBoAG8AcAA\n"
+ "gADcALgAwAAAAAQA4QklNBAYAAAAAAAcABQAAAAEBAP/hFWdodHRwOi8vbnMuYWRvYmUuY29tL3\n"
+ "hhcC8xLjAvADw/eHBhY2tldCBiZWdpbj0n77u/JyBpZD0nVzVNME1wQ2VoaUh6cmVTek5UY3prY\n"
+ "zlkJz8+Cjw/YWRvYmUteGFwLWZpbHRlcnMgZXNjPSJDUiI/Pgo8eDp4YXBtZXRhIHhtbG5zOng9\n"
+ "J2Fkb2JlOm5zOm1ldGEvJyB4OnhhcHRrPSdYTVAgdG9vbGtpdCAyLjguMi0zMywgZnJhbWV3b3J\n"
+ "rIDEuNSc+CjxyZGY6UkRGIHhtbG5zOnJkZj0naHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi\n"
+ "1yZGYtc3ludGF4LW5zIycgeG1sbnM6aVg9J2h0dHA6Ly9ucy5hZG9iZS5jb20vaVgvMS4wLyc+C\n"
+ "gogPHJkZjpEZXNjcmlwdGlvbiBhYm91dD0ndXVpZDoyMmQwMmIwYS1iMjQ5LTExZGItOGFmOC05\n"
+ "MWQ1NDAzZjkyZjknCiAgeG1sbnM6cGRmPSdodHRwOi8vbnMuYWRvYmUuY29tL3BkZi8xLjMvJz4\n"
+ "KICA8IS0tIHBkZjpTdWJqZWN0IGlzIGFsaWFzZWQgLS0+CiA8L3JkZjpEZXNjcmlwdGlvbj4KCi\n"
+ "A8cmRmOkRlc2NyaXB0aW9uIGFib3V0PSd1dWlkOjIyZDAyYjBhLWIyNDktMTFkYi04YWY4LTkxZ\n"
+ "DU0MDNmOTJmOScKICB4bWxuczpwaG90b3Nob3A9J2h0dHA6Ly9ucy5hZG9iZS5jb20vcGhvdG9z\n"
+ "aG9wLzEuMC8nPgogIDwhLS0gcGhvdG9zaG9wOkNhcHRpb24gaXMgYWxpYXNlZCAtLT4KIDwvcmR\n"
+ "mOkRlc2NyaXB0aW9uPgoKIDxyZGY6RGVzY3JpcHRpb24gYWJvdXQ9J3V1aWQ6MjJkMDJiMGEtYj\n"
+ "I0OS0xMWRiLThhZjgtOTFkNTQwM2Y5MmY5JwogIHhtbG5zOnhhcD0naHR0cDovL25zLmFkb2JlL\n"
+ "mNvbS94YXAvMS4wLyc+CiAgPCEtLSB4YXA6RGVzY3JpcHRpb24gaXMgYWxpYXNlZCAtLT4KIDwv\n"
+ "cmRmOkRlc2NyaXB0aW9uPgoKIDxyZGY6RGVzY3JpcHRpb24gYWJvdXQ9J3V1aWQ6MjJkMDJiMGE\n"
+ "tYjI0OS0xMWRiLThhZjgtOTFkNTQwM2Y5MmY5JwogIHhtbG5zOnhhcE1NPSdodHRwOi8vbnMuYW\n"
+ "RvYmUuY29tL3hhcC8xLjAvbW0vJz4KICA8eGFwTU06RG9jdW1lbnRJRD5hZG9iZTpkb2NpZDpwa\n"
+ "G90b3Nob3A6MjJkMDJiMDYtYjI0OS0xMWRiLThhZjgtOTFkNTQwM2Y5MmY5PC94YXBNTTpEb2N1\n"
+ "bWVudElEPgogPC9yZGY6RGVzY3JpcHRpb24+CgogPHJkZjpEZXNjcmlwdGlvbiBhYm91dD0ndXV\n"
+ "pZDoyMmQwMmIwYS1iMjQ5LTExZGItOGFmOC05MWQ1NDAzZjkyZjknCiAgeG1sbnM6ZGM9J2h0dH\n"
+ "A6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvJz4KICA8ZGM6ZGVzY3JpcHRpb24+CiAgIDxyZ\n"
+ "GY6QWx0PgogICAgPHJkZjpsaSB4bWw6bGFuZz0neC1kZWZhdWx0Jz4gICAgICAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAgICAgPC9yZGY6bGk+CiAgIDwvcmRmOkFsdD4KICA8L2RjOmRlc2NyaXB0aW9\n"
+ "uPgogPC9yZGY6RGVzY3JpcHRpb24+Cgo8L3JkZjpSREY+CjwveDp4YXBtZXRhPgogICAgICAgIC\n"
+ "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI\n"
+ "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA\n"
+ "gICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC\n"
+ "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI\n"
+ "CAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA\n"
+ "gCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC\n"
+ "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgI\n"
+ "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICA\n"
+ "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC\n"
+ "AgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI\n"
+ "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA\n"
+ "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIA\n"
+ "ogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI\n"
+ "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA\n"
+ "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgIC\n"
+ "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI\n"
+ "CAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA\n"
+ "gICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC\n"
+ "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKI\n"
+ "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICA\n"
+ "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC\n"
+ "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgI\n"
+ "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA\n"
+ "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC\n"
+ "AgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI\n"
+ "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAg\n"
+ "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA\n"
+ "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgIC\n"
+ "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI\n"
+ "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA\n"
+ "gICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC\n"
+ "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI\n"
+ "CAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICA\n"
+ "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC\n"
+ "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgI\n"
+ "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICA\n"
+ "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC\n"
+ "AgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI\n"
+ "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg\n"
+ "ICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA\n"
+ "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgIC\n"
+ "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI\n"
+ "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA\n"
+ "gICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgIC\n"
+ "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI\n"
+ "CAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA\n"
+ "gICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC\n"
+ "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgI\n"
+ "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICA\n"
+ "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC\n"
+ "AgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgI\n"
+ "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg\n"
+ "ICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA\n"
+ "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC\n"
+ "AgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI\n"
+ "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAg\n"
+ "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA\n"
+ "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgIC\n"
+ "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKPD94cGFja2V0IGVuZD0ndyc/P\n"
+ "v/uAA5BZG9iZQBkQAAAAAH/2wCEAAQDAwMDAwQDAwQGBAMEBgcFBAQFBwgGBgcGBggKCAkJCQkI\n"
+ "CgoMDAwMDAoMDAwMDAwMDAwMDAwMDAwMDAwMDAwBBAUFCAcIDwoKDxQODg4UFA4ODg4UEQwMDAw\n"
+ "MEREMDAwMDAwRDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAGQAZAMBEQACEQEDEQ\n"
+ "H/3QAEAA3/xAGiAAAABwEBAQEBAAAAAAAAAAAEBQMCBgEABwgJCgsBAAICAwEBAQEBAAAAAAAAA\n"
+ "AEAAgMEBQYHCAkKCxAAAgEDAwIEAgYHAwQCBgJzAQIDEQQABSESMUFRBhNhInGBFDKRoQcVsUIj\n"
+ "wVLR4TMWYvAkcoLxJUM0U5KismNzwjVEJ5OjszYXVGR0w9LiCCaDCQoYGYSURUaktFbTVSga8uP\n"
+ "zxNTk9GV1hZWltcXV5fVmdoaWprbG1ub2N0dXZ3eHl6e3x9fn9zhIWGh4iJiouMjY6PgpOUlZaX\n"
+ "mJmam5ydnp+So6SlpqeoqaqrrK2ur6EQACAgECAwUFBAUGBAgDA20BAAIRAwQhEjFBBVETYSIGc\n"
+ "YGRMqGx8BTB0eEjQhVSYnLxMyQ0Q4IWklMlomOywgdz0jXiRIMXVJMICQoYGSY2RRonZHRVN/Kj\n"
+ "s8MoKdPj84SUpLTE1OT0ZXWFlaW1xdXl9UZWZnaGlqa2xtbm9kdXZ3eHl6e3x9fn9zhIWGh4iJi\n"
+ "ouMjY6Pg5SVlpeYmZqbnJ2en5KjpKWmp6ipqqusra6vr/2gAMAwEAAhEDEQA/APBnplwPAdR+GB\n"
+ "KY6dYtNG1w39yh4+xb+zIksgEfFaRSSoIx8f7RPRRkSWQimM+lRmwWVXFWYigHxUUVoMiJM+Fj0\n"
+ "tg0RBegLE0Wu+3c+GTBazFCGI7HtSp9slbFYYzyoBsegw2hY1Afl3wqqRqahk+0tDgKpgu4DAUU\n"
+ "+HY+GRS2ePiMKtUB3G+KGuONq//Q8OzpFbW5WnxMop4k9crG5ZnZNJkEOn21utVRYw7HxZtz+OR\n"
+ "vdsrZ2lRtci4aVxFEQA0neg/ZXxJpTITNNuOFss0vSotYNvZ2qGRkPKSTqiU8Sdqk5SZU5Ix8XJ\n"
+ "NNZ8k6bp8TtM73OputUtYq0Unux/hkRkJOzZLCAN2KR+VpbtSkCBaDnIzdlWu59u+XeJTjeASk8\n"
+ "+juZOESEAVqx8BvU/PJibScTrTy09560hkWOGFd2YgFnPQKD19zhOSkxw2l8Vm6XAiYb8gg+k5O\n"
+ "9mnhoon9H3cs5s7WF5pp29OGGMFndyaAKBuTiEEPQLD8h/NDmNdYlttNkYjlbFjcXCr3LLH8II8\n"
+ "C2WUGviZvon/OPWkm3RNSv72SYllMkKxQRV67CQMSKYQAxMkR/wBC56d61P0heel4cYuVOXWvTp\n"
+ "h4Qjjf/9Hw5qBYyISaqjBV+QpvkAzKcki4HomnIxck/wBhtlR2bhunvlDywddMUl4zW+kQ9FQ8X\n"
+ "nfuSewrtmPkycPvc/DhMhvyegXOrWWhmLQPKlsj6xIAiLCoZkY96nv7npmJvI2XOjQFMl0fyRqM\n"
+ "NoxvZvrGt33wlATwiMnVnY1LEdSfuyXF3KIDmUu88w2XlnTl8raAlb2ZFfVL0jdYRtQnxc7BfDC\n"
+ "OaJR7nm3me5tdOtjbMvp3ZRXkV6chVQRX79hmVjgZG+jgZ5jHGhzecXF5LPL6jEjstSSaDM51Ka\n"
+ "6MZ9S1C0sEBe8uZo4YCBXdjxGw60wEWyEqfUHkT8vLXRJFuLdTcaqfhlvWUErtukZ3ABPUjIXTE\n"
+ "m3rGmeV2Tk5UKz/AG/E/wAcgZKya20C3b02kjYtH8AqCygbkUH0nLYlgUb+gbWtPbpXt/n2ybB/\n"
+ "/9Lw4oaVxGd+PxH3qBkGaY3KyiSP01IkiUclH8sg+LKydm6INvZvKsFu+kWtvD8LRoFNRup6moO\n"
+ "aqd277HsGW+XPLmn6XM17FF6l7vW4fd2Zuu+RFls2tmUNrLJb7TSBertGQGqetDkxE0na0pvtHs\n"
+ "QkszWyiGAG5laYlnkeMVHJj8sA5rPk+SvMepTalqlxd3B5zTOXdj/MxqafLpm5xioh5nPK5kpRG\n"
+ "pkcKAST0A6k5NpfUP5K/ki1ssHmHzF+71KRQ8Nud/Qibb/kYw6/yjbrXISlSH07YaHbWyxx2kXE\n"
+ "KACB2zHJtLI7XSelBRvH2xCpvaaTDHXkOTVBPcUG2479RlsdmJVPRtvV+ylenQ0y62FP/9PxRpo\n"
+ "WG5FxKKxKFDA+GVS5NsebLdFsRePc3siVW4f4QR0QVAGYeSXR2unhtZ6s60K6jt+MMSFwtF2+xX\n"
+ "wr7eGUGLlRPQMsE2vxQm7itxKg3VCfT2+nb8cDYaCDtfOXmCCcROrQrUhkkCHYn6emRMqZxjbLd\n"
+ "F1+W/4xajHzjNCtQKMffETWUdngX5p+QZ9A8xS6hbo0ui37NNDPT7DOalHpsCD08Rmyw5ARTpdV\n"
+ "gIPEF35MeRn80ed4S5EdrpKm9kZ15K0iH92hB7Me/tmS60vt/QrCYyekiBdgSTXcjqV9q9MokFD\n"
+ "N7S3aFVVR8RoK9zldqndvAY6nffr/AGYQqLhjdpCoIAZW22HavU/LJBUP9WblX0xTw7fOmWsX/9\n"
+ "Tw7FdvMqWkQ3Z1qfED+mQIbI77PX/LFis9vBajZm2Y+x65rMh3t30Bsze400aVaIbSLk6r8CMRT\n"
+ "l/NmOcllnGDD9Y8uecNfEEiXrMgDGWAyGOOu5WlB+vMrHODTlxZCdjsyFdB006VpVtLasurQxBL\n"
+ "64WiLI4/aFT1ANOXemV5piR2b9NiljB4yyHy9CLOVI5GJhB+CvXY9R8xmINzs5HNZ+Z96BZpbxA\n"
+ "fVJo39UFefwopYgL4nMiMd2qZoIn/AJx00u3t/Lt7qpp9Yv5GLf5MUTERqfbvmzBeezjd9H+VlL\n"
+ "wSQzBqsvOGQD7L12rXsemPNxmXQSxxIPU2nFV4HYqR1xEUWj4ZAxBryr2G+J2VGDZlLrxUH6KZA\n"
+ "Fkqb15VFelfwy+2FP8A/9Xxlf6AdA182Yk9eFeLxSjoVfcfSMo4uIOfkweFOnpvlWYrLEwNFAA+\n"
+ "nMOYdrhFvQLeSO7coBXiK8iKiv07Zj8Ac4QtNrW1njUcKcT+yAR/xGmR4WcsStLpTuPU9IFaEsV\n"
+ "BP3k4m2AgBzSwyQNcIwNTE1aI3wnam9O2Ug7s5Ckk/NDndeVXa2H78MqqV6jmeBp9+ZWKXqDjZ4\n"
+ "+gvVvy30qCy0qzsLRBCnBI2VdgUTqPvOZ7y+Q7pz+bn5q6d+VflZxZlJ/NN4ypptk5qtB9qRwDX\n"
+ "gn/AAx2y2ItpfKFv+eH5qNeTajJ5ovVaVywSqvEtTUKqupAA6D2y0BNPtv/AJx//M5PzL8mJeXT\n"
+ "L+ndPf6rqarSpkAqsnEAAeoN6DpkJRYci9lROSgSUUH9o9K5Tw0ztfSHnXkOtK9q+PHwydq//9b\n"
+ "yxrVoZNBtNSA5zRMPXmH8j0CLXuBmHE+qneamHpEuqYeV7pzFVTRgQK5XMNmnlb1vyyY5QA1OwJ\n"
+ "+eUF2seTOLu5s7azVIVAkpVn/hhnIALG73Yz5jvb1dICqzpDNIqyFD8SxH7R28cxibZCiWOsdJs\n"
+ "PTM6XNstPhnkjIhcHuJBVfvOCiUSn0TfWrTTLjyw8guA/PifTO3xcxxA8a5ZAbimvJP0m3p/kFF\n"
+ "WxhmpWQJ9NW3zZPHz5vlb/nIDVbrWfzO1RJhxGnpDaRL/khA1T7ktmSOTAJhZaAUtLawsbayl8v\n"
+ "xWi3Gpay0cF3HPcFRJJHJMXVrcJ8UaAFG5LWjF8tAYW9H/wCcOo9bTzxrt/owkTyksZW5gkIKvI\n"
+ "7k26nvyReRJHyyBWT7dWQyOWlbnK2526e1O1MqIUFE84uPLkOdK9RXI0E2/wD/1/DA1bURZLY/W\n"
+ "ZDZqwb0eXw7dMgIi7bjllVXsz7yNcfWC0Vd3Ip92Y2UOz0cnsPlwyx8xQ/u24sMxCadoJp9LOXk\n"
+ "VX/uwRUE0BI8cokbLMyoKouHu2MaKGXw7fLDwgoGSkbHpaNZyLLHRSKcFFQQRvUdMlwUFOQyLzr\n"
+ "ztpCaba6fPau4ijv4OURY8AjVFKV7ZZiO+7Vnh6XvXkSWNbW2WTb92KDxIFMzwHlZc3zX+fuizW\n"
+ "f5p3ty8XGDU4YLmCQiisyII3+4rvl8UB5ffEghRGvOm7AbnvWvjk1fen/ONPldPKP5aWOpPCfr2\n"
+ "uE31y6q2wbaMEn+VAMDSdyzrzj+avlHyTp0l/r2rxWFuHWJuIeacu4qFCRgsajfBwsty89/6Gr/\n"
+ "ACa9an+JL/hSnrfoubhXwpXpjwhaL//Q8E1AqtcAZMs8l6i1nqMa1oSVP0VynKLDmaWdSfQXl69\n"
+ "jF1Jv8MhDb5rpB3AO7INRRLhhGp4R05FgaGvTMU8200xS70zVDMRp2pTIOvBmB3PgQP15kxIcnD\n"
+ "LH/EEz0rRvOJhldr9pQtCqyd6VrShGTqw5d4ARv9jHfOGl+ZJNMluLkyenaFbiRdqFYW5nrWuwO\n"
+ "MKB5MdSMRxnhlu9N8p6lLFpti63FUjCtFJTrDKvse2bEDZ4XJ9RZB+YPli2/Mjy5bxoUi1a0YS2\n"
+ "85UOwIXiy9jRu+TBppfOF1+V3m22vrdpNPM8cs/oo0VJlUqQPjValR3+IZNNvtLS9Yu9Mi0/TJr\n"
+ "kyp6QhWVVCIWRATsKBemwwFrDzT87fybs/wA1bW21PRb+DTvNlgGSRp6iC8i3KJJx+y6n7D0Pwm\n"
+ "hxBZXT55/6Fi/Nf0PW+qWXq+t6X1X67F6vD/ftK04V/wBl344U8b//0fBapxheVh9ocV+nviqY2\n"
+ "/qQJDew/bioWHiuQ8m0bbvaPKGtQ6jaxSo9JloCK75gZI0Xb4sgkHo8MouoAvP94BsRmGY7uWJU\n"
+ "gzbypOQpNOvIdK4Nw2WCE2tXulTkjEEbdafgclxMhFBas93dwyQzsWDghlJFONKHJCZtjOFBJfy\n"
+ "j1y9vPL9zpbIs0WkXL2sUjA8hDXlGCRXtt07ZuYvL5KJeo6bfajbkzWkcToR8dqshZ6in2fhNK/\n"
+ "PDTUlXmHVvMdr5o0v9H2kdrqGpfu7m0nkY87Uf7tkKAU4/s03ynLkEBbfihx7dGT6va67LbRMNR\n"
+ "aKOBuUTKgIBXoK1BOYR1M3aQ0mOt9yxUeZNdtJhFapLqMluSXkg5oxJrUMW5KevQ9MmNXXNqOiH\n"
+ "Rr/Hmv8A1r9I/oj95w+r+j9Yf1+NP5+nXtTD+dF8tkfkOlv/0vC3ph7f0/alcVTbS4A8QibuKb5\n"
+ "RI05EBYRFpdX3ly79a2qYCavH/EY7TCYyMD5PSdD8+wXUSn1ArDqOhBzFlipz4ZwWbaV5htbsgF\n"
+ "qg9crMXKErGyYwajFGzxyHlGSePbbwyqg5UZlCaxrFpaWU95LIqrEjMAT4Dp9OShGy1ZslBhv/A\n"
+ "Dj9rd/a+aL+xUK+m38L3d0HrxRo2HFtu5D8c27y8t30raarbWkU+u6g4gsNORn+EcUaSh2Pc0/4\n"
+ "lgtAjezzbT9SutY1i782al8Nxdyotqh6xWybIg+jc5q8s+I27bFDgFPQp9RE+nrag70+L6crrZu\n"
+ "4jajokdv6LW/Dii1Wo61PXKQN3KPK0L+h4/rnD/K5V78a5LhXxd3/0/DMXXtwxVNtL9Xkaf3f7N\n"
+ "etfbKMjdjtkZ9D6ufrlK0+HpX8coF9HJ26sXvfqXrf7i/U+uften/d/wCyrmQL6uOav0pvpP8Ai\n"
+ "b1F+rV59+vH6a5XLhcjH4nRmY/xpxHP0/UptWvT6Mx/RbmjxWK+aP8AFf1M/pCv1Kvxen9inavf\n"
+ "MrFwXtzcLUeLXq5Mv/I3nz1b0v8AjofuKVry9KrUpTanOlf9jmQ68va/zH9b/COn/o7/AI431mP\n"
+ "65SvLh+zWvbl9rMfNfC34K4kmj9T6lD6FKclp/DNYXZx5srsPrHor6nXvkgxTPS/U+rv6dPU5mt\n"
+ "fngFN5ulv+l/pL/Lp/scerHo//2Q==\n";
+
+static std::string gCommandLine;
+
+TEST(Base64, LargeSample) {
+ LOG(LS_VERBOSE) << "Testing specific base64 file";
+
+ char unescaped[64 * 1024];
+
+ // unescape that massive blob above
+ size_t size = Base64Unescape(SpecificTest,
+ sizeof(SpecificTest),
+ unescaped,
+ sizeof(unescaped));
+
+ EXPECT_EQ(size, sizeof(testbase64));
+ EXPECT_EQ(0, memcmp(testbase64, unescaped, sizeof(testbase64)));
+}
+
+bool DecodeTest(const char* encoded, size_t expect_unparsed,
+ const char* decoded, Base64::DecodeFlags flags)
+{
+ std::string result;
+ size_t consumed = 0, encoded_len = strlen(encoded);
+ bool success = Base64::DecodeFromArray(encoded, encoded_len, flags,
+ &result, &consumed);
+ size_t unparsed = encoded_len - consumed;
+ EXPECT_EQ(expect_unparsed, unparsed) << "\"" << encoded
+ << "\" -> \"" << decoded
+ << "\"";
+ EXPECT_STREQ(decoded, result.c_str());
+ return success;
+}
+
+#define Flags(x,y,z) \
+ Base64::DO_PARSE_##x | Base64::DO_PAD_##y | Base64::DO_TERM_##z
+
+TEST(Base64, DecodeParseOptions) {
+ // Trailing whitespace
+ EXPECT_TRUE (DecodeTest("YWJjZA== ", 1, "abcd", Flags(STRICT, YES, CHAR)));
+ EXPECT_TRUE (DecodeTest("YWJjZA== ", 0, "abcd", Flags(WHITE, YES, CHAR)));
+ EXPECT_TRUE (DecodeTest("YWJjZA== ", 0, "abcd", Flags(ANY, YES, CHAR)));
+
+ // Embedded whitespace
+ EXPECT_FALSE(DecodeTest("YWJjZA= =", 3, "abcd", Flags(STRICT, YES, CHAR)));
+ EXPECT_TRUE (DecodeTest("YWJjZA= =", 0, "abcd", Flags(WHITE, YES, CHAR)));
+ EXPECT_TRUE (DecodeTest("YWJjZA= =", 0, "abcd", Flags(ANY, YES, CHAR)));
+
+ // Embedded non-base64 characters
+ EXPECT_FALSE(DecodeTest("YWJjZA=*=", 3, "abcd", Flags(STRICT, YES, CHAR)));
+ EXPECT_FALSE(DecodeTest("YWJjZA=*=", 3, "abcd", Flags(WHITE, YES, CHAR)));
+ EXPECT_TRUE (DecodeTest("YWJjZA=*=", 0, "abcd", Flags(ANY, YES, CHAR)));
+
+ // Unexpected padding characters
+ EXPECT_FALSE(DecodeTest("YW=JjZA==", 7, "a", Flags(STRICT, YES, CHAR)));
+ EXPECT_FALSE(DecodeTest("YW=JjZA==", 7, "a", Flags(WHITE, YES, CHAR)));
+ EXPECT_TRUE (DecodeTest("YW=JjZA==", 0, "abcd", Flags(ANY, YES, CHAR)));
+}
+
+TEST(Base64, DecodePadOptions) {
+ // Padding
+ EXPECT_TRUE (DecodeTest("YWJjZA==", 0, "abcd", Flags(STRICT, YES, CHAR)));
+ EXPECT_TRUE (DecodeTest("YWJjZA==", 0, "abcd", Flags(STRICT, ANY, CHAR)));
+ EXPECT_TRUE (DecodeTest("YWJjZA==", 2, "abcd", Flags(STRICT, NO, CHAR)));
+
+ // Incomplete padding
+ EXPECT_FALSE(DecodeTest("YWJjZA=", 1, "abcd", Flags(STRICT, YES, CHAR)));
+ EXPECT_TRUE (DecodeTest("YWJjZA=", 1, "abcd", Flags(STRICT, ANY, CHAR)));
+ EXPECT_TRUE (DecodeTest("YWJjZA=", 1, "abcd", Flags(STRICT, NO, CHAR)));
+
+ // No padding
+ EXPECT_FALSE(DecodeTest("YWJjZA", 0, "abcd", Flags(STRICT, YES, CHAR)));
+ EXPECT_TRUE (DecodeTest("YWJjZA", 0, "abcd", Flags(STRICT, ANY, CHAR)));
+ EXPECT_TRUE (DecodeTest("YWJjZA", 0, "abcd", Flags(STRICT, NO, CHAR)));
+}
+
+TEST(Base64, DecodeTerminateOptions) {
+ // Complete quantum
+ EXPECT_TRUE (DecodeTest("YWJj", 0, "abc", Flags(STRICT, NO, BUFFER)));
+ EXPECT_TRUE (DecodeTest("YWJj", 0, "abc", Flags(STRICT, NO, CHAR)));
+ EXPECT_TRUE (DecodeTest("YWJj", 0, "abc", Flags(STRICT, NO, ANY)));
+
+ // Complete quantum with trailing data
+ EXPECT_FALSE(DecodeTest("YWJj*", 1, "abc", Flags(STRICT, NO, BUFFER)));
+ EXPECT_TRUE (DecodeTest("YWJj*", 1, "abc", Flags(STRICT, NO, CHAR)));
+ EXPECT_TRUE (DecodeTest("YWJj*", 1, "abc", Flags(STRICT, NO, ANY)));
+
+ // Incomplete quantum
+ EXPECT_FALSE(DecodeTest("YWJ", 0, "ab", Flags(STRICT, NO, BUFFER)));
+ EXPECT_FALSE(DecodeTest("YWJ", 0, "ab", Flags(STRICT, NO, CHAR)));
+ EXPECT_TRUE (DecodeTest("YWJ", 0, "ab", Flags(STRICT, NO, ANY)));
+}
diff --git a/talk/base/basicpacketsocketfactory.cc b/talk/base/basicpacketsocketfactory.cc
index 42721ba..d1da08e 100644
--- a/talk/base/basicpacketsocketfactory.cc
+++ b/talk/base/basicpacketsocketfactory.cc
@@ -157,7 +157,8 @@
} else {
// Otherwise, try to find a port in the provided range.
for (int port = min_port; ret < 0 && port <= max_port; ++port) {
- ret = socket->Bind(talk_base::SocketAddress(local_address.ip(), port));
+ ret = socket->Bind(talk_base::SocketAddress(local_address.ipaddr(),
+ port));
}
}
return ret;
diff --git a/talk/base/basictypes.h b/talk/base/basictypes.h
index 4193ede..4840631 100644
--- a/talk/base/basictypes.h
+++ b/talk/base/basictypes.h
@@ -25,12 +25,12 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef TALK_BASE_BASICTYPES_H__
-#define TALK_BASE_BASICTYPES_H__
+#ifndef TALK_BASE_BASICTYPES_H_
+#define TALK_BASE_BASICTYPES_H_
#include <stddef.h> // for NULL, size_t
-#ifndef WIN32
+#if !(defined(_MSC_VER) && (_MSC_VER < 1600))
#include <stdint.h> // for uintptr_t
#endif
@@ -40,7 +40,7 @@
#include "talk/base/constructormagic.h"
-#ifndef INT_TYPES_DEFINED
+#if !defined(INT_TYPES_DEFINED)
#define INT_TYPES_DEFINED
#ifdef COMPILER_MSVC
typedef unsigned __int64 uint64;
@@ -53,7 +53,18 @@
#endif
#define INT64_F "I64"
#else // COMPILER_MSVC
-#ifdef __LP64__
+// On Mac OS X, cssmconfig.h defines uint64 as uint64_t
+#if defined(OSX)
+typedef uint64_t uint64;
+typedef int64_t int64;
+#ifndef INT64_C
+#define INT64_C(x) x ## L
+#endif
+#ifndef UINT64_C
+#define UINT64_C(x) x ## UL
+#endif
+#define INT64_F "l"
+#elif defined(__LP64__)
typedef unsigned long uint64;
typedef long int64;
#ifndef INT64_C
@@ -80,7 +91,7 @@
typedef unsigned short uint16;
typedef short int16;
typedef unsigned char uint8;
-typedef char int8;
+typedef signed char int8;
#endif // INT_TYPES_DEFINED
#ifdef WIN32
@@ -102,15 +113,10 @@
#define CPU_X86 1
#endif
-#ifdef WIN32
-#define alignof(t) __alignof(t)
-#else // !WIN32
-#define alignof(t) __alignof__(t)
-#endif // !WIN32
-#define IS_ALIGNED(p, a) (0==(reinterpret_cast<uintptr_t>(p) & ((a)-1)))
#define ALIGNP(p, t) \
(reinterpret_cast<uint8*>(((reinterpret_cast<uintptr_t>(p) + \
((t)-1)) & ~((t)-1))))
+#define IS_ALIGNED(p, a) (!((uintptr_t)(p) & ((a) - 1)))
#ifndef UNUSED
#define UNUSED(x) Unused(static_cast<const void *>(&x))
@@ -127,4 +133,9 @@
#define GCC_ATTR(x)
#endif // !__GNUC__
-#endif // TALK_BASE_BASICTYPES_H__
+// Use these to declare and define a static local variable (static T;) so that
+// it is leaked so that its destructors are not called at exit.
+#define LIBJINGLE_DEFINE_STATIC_LOCAL(type, name, arguments) \
+ static type& name = *new type arguments
+
+#endif // TALK_BASE_BASICTYPES_H_
diff --git a/talk/base/buffer_unittest.cc b/talk/base/buffer_unittest.cc
new file mode 100644
index 0000000..b0aa243
--- /dev/null
+++ b/talk/base/buffer_unittest.cc
@@ -0,0 +1,160 @@
+/*
+ * libjingle
+ * Copyright 2004--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/base/buffer.h"
+#include "talk/base/gunit.h"
+
+namespace talk_base {
+
+static const char kTestData[] = {
+ 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF
+};
+
+TEST(BufferTest, TestConstructDefault) {
+ Buffer buf;
+ EXPECT_EQ(0U, buf.length());
+ EXPECT_EQ(0U, buf.capacity());
+ EXPECT_EQ(Buffer(), buf);
+}
+
+TEST(BufferTest, TestConstructEmptyWithCapacity) {
+ Buffer buf(NULL, 0, 256U);
+ EXPECT_EQ(0U, buf.length());
+ EXPECT_EQ(256U, buf.capacity());
+ EXPECT_EQ(Buffer(), buf);
+}
+
+TEST(BufferTest, TestConstructData) {
+ Buffer buf(kTestData, sizeof(kTestData));
+ EXPECT_EQ(sizeof(kTestData), buf.length());
+ EXPECT_EQ(sizeof(kTestData), buf.capacity());
+ EXPECT_EQ(0, memcmp(buf.data(), kTestData, sizeof(kTestData)));
+ EXPECT_EQ(Buffer(kTestData, sizeof(kTestData)), buf);
+}
+
+TEST(BufferTest, TestConstructDataWithCapacity) {
+ Buffer buf(kTestData, sizeof(kTestData), 256U);
+ EXPECT_EQ(sizeof(kTestData), buf.length());
+ EXPECT_EQ(256U, buf.capacity());
+ EXPECT_EQ(0, memcmp(buf.data(), kTestData, sizeof(kTestData)));
+ EXPECT_EQ(Buffer(kTestData, sizeof(kTestData)), buf);
+}
+
+TEST(BufferTest, TestConstructCopy) {
+ Buffer buf1(kTestData, sizeof(kTestData), 256), buf2(buf1);
+ EXPECT_EQ(sizeof(kTestData), buf2.length());
+ EXPECT_EQ(sizeof(kTestData), buf2.capacity()); // capacity isn't copied
+ EXPECT_EQ(0, memcmp(buf2.data(), kTestData, sizeof(kTestData)));
+ EXPECT_EQ(buf1, buf2);
+}
+
+TEST(BufferTest, TestAssign) {
+ Buffer buf1, buf2(kTestData, sizeof(kTestData), 256);
+ EXPECT_NE(buf1, buf2);
+ buf1 = buf2;
+ EXPECT_EQ(sizeof(kTestData), buf1.length());
+ EXPECT_EQ(sizeof(kTestData), buf1.capacity()); // capacity isn't copied
+ EXPECT_EQ(0, memcmp(buf1.data(), kTestData, sizeof(kTestData)));
+ EXPECT_EQ(buf1, buf2);
+}
+
+TEST(BufferTest, TestSetData) {
+ Buffer buf;
+ buf.SetData(kTestData, sizeof(kTestData));
+ EXPECT_EQ(sizeof(kTestData), buf.length());
+ EXPECT_EQ(sizeof(kTestData), buf.capacity());
+ EXPECT_EQ(0, memcmp(buf.data(), kTestData, sizeof(kTestData)));
+}
+
+TEST(BufferTest, TestAppendData) {
+ Buffer buf(kTestData, sizeof(kTestData));
+ buf.AppendData(kTestData, sizeof(kTestData));
+ EXPECT_EQ(2 * sizeof(kTestData), buf.length());
+ EXPECT_EQ(2 * sizeof(kTestData), buf.capacity());
+ EXPECT_EQ(0, memcmp(buf.data(), kTestData, sizeof(kTestData)));
+ EXPECT_EQ(0, memcmp(buf.data() + sizeof(kTestData),
+ kTestData, sizeof(kTestData)));
+}
+
+TEST(BufferTest, TestSetLengthSmaller) {
+ Buffer buf;
+ buf.SetData(kTestData, sizeof(kTestData));
+ buf.SetLength(sizeof(kTestData) / 2);
+ EXPECT_EQ(sizeof(kTestData) / 2, buf.length());
+ EXPECT_EQ(sizeof(kTestData), buf.capacity());
+ EXPECT_EQ(0, memcmp(buf.data(), kTestData, sizeof(kTestData) / 2));
+}
+
+TEST(BufferTest, TestSetLengthLarger) {
+ Buffer buf;
+ buf.SetData(kTestData, sizeof(kTestData));
+ buf.SetLength(sizeof(kTestData) * 2);
+ EXPECT_EQ(sizeof(kTestData) * 2, buf.length());
+ EXPECT_EQ(sizeof(kTestData) * 2, buf.capacity());
+ EXPECT_EQ(0, memcmp(buf.data(), kTestData, sizeof(kTestData)));
+}
+
+TEST(BufferTest, TestSetCapacitySmaller) {
+ Buffer buf;
+ buf.SetData(kTestData, sizeof(kTestData));
+ buf.SetCapacity(sizeof(kTestData) / 2); // should be ignored
+ EXPECT_EQ(sizeof(kTestData), buf.length());
+ EXPECT_EQ(sizeof(kTestData), buf.capacity());
+ EXPECT_EQ(0, memcmp(buf.data(), kTestData, sizeof(kTestData)));
+}
+
+TEST(BufferTest, TestSetCapacityLarger) {
+ Buffer buf(kTestData, sizeof(kTestData));
+ buf.SetCapacity(sizeof(kTestData) * 2);
+ EXPECT_EQ(sizeof(kTestData), buf.length());
+ EXPECT_EQ(sizeof(kTestData) * 2, buf.capacity());
+ EXPECT_EQ(0, memcmp(buf.data(), kTestData, sizeof(kTestData)));
+}
+
+TEST(BufferTest, TestSetCapacityThenSetLength) {
+ Buffer buf(kTestData, sizeof(kTestData));
+ buf.SetCapacity(sizeof(kTestData) * 4);
+ memcpy(buf.data() + sizeof(kTestData), kTestData, sizeof(kTestData));
+ buf.SetLength(sizeof(kTestData) * 2);
+ EXPECT_EQ(sizeof(kTestData) * 2, buf.length());
+ EXPECT_EQ(sizeof(kTestData) * 4, buf.capacity());
+ EXPECT_EQ(0, memcmp(buf.data(), kTestData, sizeof(kTestData)));
+ EXPECT_EQ(0, memcmp(buf.data() + sizeof(kTestData),
+ kTestData, sizeof(kTestData)));
+}
+
+TEST(BufferTest, TestTransfer) {
+ Buffer buf1(kTestData, sizeof(kTestData), 256U), buf2;
+ buf1.TransferTo(&buf2);
+ EXPECT_EQ(0U, buf1.length());
+ EXPECT_EQ(0U, buf1.capacity());
+ EXPECT_EQ(sizeof(kTestData), buf2.length());
+ EXPECT_EQ(256U, buf2.capacity()); // capacity does transfer
+ EXPECT_EQ(0, memcmp(buf2.data(), kTestData, sizeof(kTestData)));
+}
+
+} // namespace talk_base
diff --git a/talk/base/checks.h b/talk/base/checks.h
index 12adc25..83ad372 100644
--- a/talk/base/checks.h
+++ b/talk/base/checks.h
@@ -26,10 +26,10 @@
*/
// This module contains some basic debugging facilities.
+// Originally comes from shared/commandlineflags/checks.h
-
-#ifndef SHARED_COMMANDLINEFLAGS_CHECKS_H__
-#define SHARED_COMMANDLINEFLAGS_CHECKS_H__
+#ifndef TALK_BASE_CHECKS_H_
+#define TALK_BASE_CHECKS_H_
#include <string.h>
@@ -41,4 +41,4 @@
#define UNREACHABLE() \
Fatal(__FILE__, __LINE__, "unreachable code")
-#endif // SHARED_COMMANDLINEFLAGS_CHECKS_H__
+#endif // TALK_BASE_CHECKS_H_
diff --git a/talk/base/cpuid.cc b/talk/base/cpuid.cc
new file mode 100644
index 0000000..7f0326a
--- /dev/null
+++ b/talk/base/cpuid.cc
@@ -0,0 +1,140 @@
+/*
+ * 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/base/cpuid.h"
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#elif defined(__ANDROID__)
+#include <cpu-features.h>
+#elif defined(LINUX)
+#include "talk/base/linux.h"
+#endif
+
+// TODO: Use cpuid.h when gcc 4.4 is used on OSX and Linux.
+#if (defined(__pic__) || defined(__APPLE__)) && defined(__i386__)
+static inline void __cpuid(int cpu_info[4], int info_type) {
+ __asm__ volatile (
+ "mov %%ebx, %%edi\n"
+ "cpuid\n"
+ "xchg %%edi, %%ebx\n"
+ : "=a"(cpu_info[0]), "=D"(cpu_info[1]), "=c"(cpu_info[2]), "=d"(cpu_info[3])
+ : "a"(info_type)
+ );
+}
+#elif defined(__i386__) || defined(__x86_64__)
+static inline void __cpuid(int cpu_info[4], int info_type) {
+ __asm__ volatile (
+ "cpuid\n"
+ : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]), "=d"(cpu_info[3])
+ : "a"(info_type)
+ );
+}
+#endif
+
+namespace talk_base {
+
+// CPU detect function for SIMD instruction sets.
+bool CpuInfo::cpu_info_initialized_ = false;
+int CpuInfo::cpu_info_ = 0;
+// Global lock for cpu initialization.
+CriticalSection CpuInfo::crit_;
+
+#ifdef CPU_X86
+void cpuid(int cpu_info[4], int info_type) {
+ __cpuid(cpu_info, info_type);
+}
+#endif
+
+void CpuInfo::InitCpuFlags() {
+#ifdef CPU_X86
+ int cpu_info[4];
+ __cpuid(cpu_info, 1);
+ cpu_info_ = (cpu_info[2] & 0x00000200 ? kCpuHasSSSE3 : 0) |
+ (cpu_info[3] & 0x04000000 ? kCpuHasSSE2 : 0);
+#elif defined(__ANDROID__) && defined(__arm__)
+ uint64_t features = android_getCpuFeatures();
+ cpu_info_ = ((features & ANDROID_CPU_ARM_FEATURE_NEON) ? kCpuHasNEON : 0);
+#elif defined(LINUX) && defined(__arm__)
+ cpu_info_ = 0;
+ // Look for NEON support in /proc/cpuinfo
+ ProcCpuInfo proc_info;
+ size_t section_count;
+ if (proc_info.LoadFromSystem() &&
+ proc_info.GetSectionCount(§ion_count)) {
+ for (size_t i = 0; i < section_count; ++i) {
+ std::string out_features;
+ if (proc_info.GetSectionStringValue(i, "Features", &out_features)) {
+ if (out_features.find("neon") != std::string::npos) {
+ cpu_info_ |= kCpuHasNEON;
+ }
+ break;
+ }
+ }
+ }
+#elif defined(__ARM_NEON__)
+ // gcc -mfpu=neon defines __ARM_NEON__
+ // if code is specifically built for Neon-only, enable the flag.
+ cpu_info_ |= kCpuHasNEON;
+#else
+ cpu_info_ = 0;
+#endif
+ cpu_info_initialized_ = true;
+}
+
+void CpuInfo::MaskCpuFlagsForTest(int enable_flags) {
+ CritScope cs(&crit_);
+ InitCpuFlags();
+ cpu_info_ &= enable_flags;
+}
+
+bool CpuInfo::TestCpuFlag(int flag) {
+ if (!cpu_info_initialized_) {
+ CritScope cs(&crit_);
+ InitCpuFlags();
+ }
+ return cpu_info_ & flag ? true : false;
+}
+
+// Returns the vendor string from the cpu, e.g. "GenuineIntel", "AuthenticAMD".
+// See "Intel Processor Identification and the CPUID Instruction"
+// (Intel document number: 241618)
+std::string CpuInfo::GetCpuVendor() {
+#ifdef CPU_X86
+ int cpu_info[4];
+ cpuid(cpu_info, 0);
+ cpu_info[0] = cpu_info[1]; // Reorder output
+ cpu_info[1] = cpu_info[3];
+ cpu_info[2] = cpu_info[2];
+ cpu_info[3] = 0;
+ return std::string(reinterpret_cast<char *>(&cpu_info[0]));
+#else
+ return std::string("Undefined");
+#endif
+}
+
+} // namespace talk_base
diff --git a/talk/base/cpuid.h b/talk/base/cpuid.h
new file mode 100644
index 0000000..3688668
--- /dev/null
+++ b/talk/base/cpuid.h
@@ -0,0 +1,73 @@
+/*
+ * 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_BASE_CPUID_H_
+#define TALK_BASE_CPUID_H_
+
+#include <string>
+
+#include "talk/base/basictypes.h"
+#include "talk/base/criticalsection.h"
+
+namespace talk_base {
+
+#ifdef CPU_X86
+void cpuid(int cpu_info[4], int info_type);
+#endif
+
+class CpuInfo {
+ public:
+ // These flags are only valid on x86 processors
+ static const int kCpuHasSSE2 = 1;
+ static const int kCpuHasSSSE3 = 2;
+
+ // SIMD support on ARM processors
+ static const int kCpuHasNEON = 4;
+
+ // Detect CPU has SSE2 etc.
+ static bool TestCpuFlag(int flag);
+
+ // Detect CPU vendor: "GenuineIntel" or "AuthenticAMD"
+ static std::string GetCpuVendor();
+
+ // For testing, allow CPU flags to be disabled.
+ static void MaskCpuFlagsForTest(int enable_flags);
+
+ private:
+ // Global lock for the cpu initialization
+ static CriticalSection crit_;
+ static bool cpu_info_initialized_;
+ static int cpu_info_;
+
+ static void InitCpuFlags();
+
+ DISALLOW_IMPLICIT_CONSTRUCTORS(CpuInfo);
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_CPUID_H_
diff --git a/talk/base/cpuid_unittest.cc b/talk/base/cpuid_unittest.cc
new file mode 100644
index 0000000..f06178f
--- /dev/null
+++ b/talk/base/cpuid_unittest.cc
@@ -0,0 +1,86 @@
+/*
+ * 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 <iostream>
+
+#include "talk/base/cpuid.h"
+#include "talk/base/gunit.h"
+#include "talk/base/stringutils.h"
+
+
+// Tests CPUID instruction for Vendor identification.
+TEST(CpuInfoTest, CpuVendorNonEmpty) {
+ EXPECT_FALSE(talk_base::CpuInfo::GetCpuVendor().empty());
+}
+
+#ifdef CPU_X86
+
+// Tests Vendor identification is Intel or AMD.
+// See Also http://en.wikipedia.org/wiki/CPUID
+TEST(CpuInfoTest, CpuVendorIntelAMD) {
+ const std::string vendor = talk_base::CpuInfo::GetCpuVendor();
+ LOG(LS_INFO) << "CpuVendor: " << vendor;
+ EXPECT_TRUE(talk_base::string_match(vendor.c_str(),
+ "GenuineIntel") ||
+ talk_base::string_match(vendor.c_str(),
+ "AuthenticAMD"));
+}
+
+// Tests CPUID maximum function number.
+// Modern CPU has 11, but we expect at least 3.
+TEST(CpuInfoTest, CpuIdMax) {
+ int cpu_info[4] = { 0 };
+ talk_base::cpuid(cpu_info, 0);
+ LOG(LS_INFO) << "CpuId Max Function: " << cpu_info[0];
+ EXPECT_GE(cpu_info[0], 1);
+}
+
+// Tests CPUID functions 0 and 1 return different values.
+TEST(CpuInfoTest, CpuId) {
+ int cpu_info0[4] = { 0 };
+ int cpu_info1[4] = { 0 };
+ talk_base::cpuid(cpu_info0, 0);
+ talk_base::cpuid(cpu_info1, 1);
+ LOG(LS_INFO) << "CpuId Function 0: " << std::hex
+ << std::setfill('0') << std::setw(8) << cpu_info0[0] << " "
+ << std::setfill('0') << std::setw(8) << cpu_info0[1] << " "
+ << std::setfill('0') << std::setw(8) << cpu_info0[2] << " "
+ << std::setfill('0') << std::setw(8) << cpu_info0[3];
+ LOG(LS_INFO) << "CpuId Function 1: " << std::hex
+ << std::setfill('0') << std::setw(8) << cpu_info1[0] << " "
+ << std::setfill('0') << std::setw(8) << cpu_info1[1] << " "
+ << std::setfill('0') << std::setw(8) << cpu_info1[2] << " "
+ << std::setfill('0') << std::setw(8) << cpu_info1[3];
+ EXPECT_NE(memcmp(cpu_info0, cpu_info1, sizeof(cpu_info0)), 0);
+
+ LOG(LS_INFO) << "SSE2: "
+ << talk_base::CpuInfo::TestCpuFlag(talk_base::CpuInfo::kCpuHasSSE2);
+ LOG(LS_INFO) << "SSSE3: "
+ << talk_base::CpuInfo::TestCpuFlag(talk_base::CpuInfo::kCpuHasSSSE3);
+}
+#endif
+
diff --git a/talk/base/cpumonitor.cc b/talk/base/cpumonitor.cc
new file mode 100644
index 0000000..64f6147
--- /dev/null
+++ b/talk/base/cpumonitor.cc
@@ -0,0 +1,418 @@
+/*
+ * libjingle
+ * Copyright 2010 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/base/cpumonitor.h"
+
+#include <string>
+
+#include "talk/base/common.h"
+#include "talk/base/logging.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/systeminfo.h"
+#include "talk/base/thread.h"
+#include "talk/base/timeutils.h"
+
+#ifdef WIN32
+#include "talk/base/win32.h"
+#include <winternl.h>
+#endif
+
+#ifdef POSIX
+#include <sys/time.h>
+#endif
+
+#if defined(IOS) || defined(OSX)
+#include <mach/mach_host.h>
+#include <mach/mach_init.h>
+#include <mach/host_info.h>
+#include <mach/task.h>
+#endif // defined(IOS) || defined(OSX)
+
+#if defined(LINUX) || defined(ANDROID)
+#include <sys/resource.h>
+#include <errno.h>
+#include <stdio.h>
+#include "talk/base/fileutils.h"
+#include "talk/base/pathutils.h"
+#endif // defined(LINUX) || defined(ANDROID)
+
+#if defined(IOS) || defined(OSX)
+static uint64 TimeValueTToInt64(const time_value_t &time_value) {
+ return talk_base::kNumMicrosecsPerSec * time_value.seconds +
+ time_value.microseconds;
+}
+#endif // defined(IOS) || defined(OSX)
+
+// How CpuSampler works
+// When threads switch, the time they spent is accumulated to system counters.
+// The time can be treated as user, kernel or idle.
+// user time is applications.
+// kernel time is the OS, including the thread switching code itself.
+// typically kernel time indicates IO.
+// idle time is a process that wastes time when nothing is ready to run.
+//
+// User time is broken down by process (application). One of the applications
+// is the current process. When you add up all application times, this is
+// system time. If only your application is running, system time should be the
+// same as process time.
+//
+// All cores contribute to these accumulators. A dual core process is able to
+// process twice as many cycles as a single core. The actual code efficiency
+// may be worse, due to contention, but the available cycles is exactly twice
+// as many, and the cpu load will reflect the efficiency. Hyperthreads behave
+// the same way. The load will reflect 200%, but the actual amount of work
+// completed will be much less than a true dual core.
+//
+// Total available performance is the sum of all accumulators.
+// If you tracked this for 1 second, it would essentially give you the clock
+// rate - number of cycles per second.
+// Speed step / Turbo Boost is not considered, so infact more processing time
+// may be available.
+
+namespace talk_base {
+
+// Note Tests on Windows show 600 ms is minimum stable interval for Windows 7.
+static const int32 kDefaultInterval = 950; // Slightly under 1 second.
+
+CpuSampler::CpuSampler()
+ : min_load_interval_(kDefaultInterval)
+#ifdef WIN32
+ , get_system_times_(NULL),
+ nt_query_system_information_(NULL),
+ force_fallback_(false)
+#endif
+ {
+}
+
+CpuSampler::~CpuSampler() {
+}
+
+// Set minimum interval in ms between computing new load values. Default 950.
+void CpuSampler::set_load_interval(int min_load_interval) {
+ min_load_interval_ = min_load_interval;
+}
+
+bool CpuSampler::Init() {
+ sysinfo_.reset(new SystemInfo);
+ cpus_ = sysinfo_->GetMaxCpus();
+ if (cpus_ == 0) {
+ return false;
+ }
+#ifdef WIN32
+ // Note that GetSystemTimes is available in Windows XP SP1 or later.
+ // http://msdn.microsoft.com/en-us/library/ms724400.aspx
+ // NtQuerySystemInformation is used as a fallback.
+ if (!force_fallback_) {
+ get_system_times_ = GetProcAddress(GetModuleHandle(L"kernel32.dll"),
+ "GetSystemTimes");
+ }
+ nt_query_system_information_ = GetProcAddress(GetModuleHandle(L"ntdll.dll"),
+ "NtQuerySystemInformation");
+ if ((get_system_times_ == NULL) && (nt_query_system_information_ == NULL)) {
+ return false;
+ }
+#endif
+#if defined(LINUX) || defined(ANDROID)
+ Pathname sname("/proc/stat");
+ sfile_.reset(Filesystem::OpenFile(sname, "rb"));
+ if (sfile_.get() == NULL) {
+ LOG_ERR(LS_ERROR) << "open proc/stat failed:";
+ return false;
+ }
+ if (!sfile_->DisableBuffering()) {
+ LOG_ERR(LS_ERROR) << "could not disable buffering for proc/stat";
+ return false;
+ }
+#endif // defined(LINUX) || defined(ANDROID)
+ GetProcessLoad(); // Initialize values.
+ GetSystemLoad();
+ // Help next user call return valid data by recomputing load.
+ process_.prev_load_time_ = 0u;
+ system_.prev_load_time_ = 0u;
+ return true;
+}
+
+float CpuSampler::UpdateCpuLoad(uint64 current_total_times,
+ uint64 current_cpu_times,
+ uint64 *prev_total_times,
+ uint64 *prev_cpu_times) {
+ float result = 0.f;
+ if (current_total_times < *prev_total_times ||
+ current_cpu_times < *prev_cpu_times) {
+ LOG(LS_ERROR) << "Inconsistent time values are passed. ignored";
+ } else {
+ const uint64 cpu_diff = current_cpu_times - *prev_cpu_times;
+ const uint64 total_diff = current_total_times - *prev_total_times;
+ result = (total_diff == 0ULL ? 0.f :
+ static_cast<float>(1.0f * cpu_diff / total_diff));
+ if (result > static_cast<float>(cpus_)) {
+ result = static_cast<float>(cpus_);
+ }
+ *prev_total_times = current_total_times;
+ *prev_cpu_times = current_cpu_times;
+ }
+ return result;
+}
+
+float CpuSampler::GetSystemLoad() {
+ uint32 timenow = Time();
+ int elapsed = static_cast<int>(TimeDiff(timenow, system_.prev_load_time_));
+ if (min_load_interval_ != 0 && system_.prev_load_time_ != 0u &&
+ elapsed < min_load_interval_) {
+ return system_.prev_load_;
+ }
+#ifdef WIN32
+ uint64 total_times, cpu_times;
+
+ typedef BOOL (_stdcall *GST_PROC)(LPFILETIME, LPFILETIME, LPFILETIME);
+ typedef NTSTATUS (WINAPI *QSI_PROC)(SYSTEM_INFORMATION_CLASS,
+ PVOID, ULONG, PULONG);
+
+ GST_PROC get_system_times = reinterpret_cast<GST_PROC>(get_system_times_);
+ QSI_PROC nt_query_system_information = reinterpret_cast<QSI_PROC>(
+ nt_query_system_information_);
+
+ if (get_system_times) {
+ FILETIME idle_time, kernel_time, user_time;
+ if (!get_system_times(&idle_time, &kernel_time, &user_time)) {
+ LOG(LS_ERROR) << "::GetSystemTimes() failed: " << ::GetLastError();
+ return 0.f;
+ }
+ // kernel_time includes Kernel idle time, so no need to
+ // include cpu_time as total_times
+ total_times = ToUInt64(kernel_time) + ToUInt64(user_time);
+ cpu_times = total_times - ToUInt64(idle_time);
+
+ } else {
+ if (nt_query_system_information) {
+ ULONG returned_length = 0;
+ scoped_array<SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION> processor_info(
+ new SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION[cpus_]);
+ nt_query_system_information(
+ ::SystemProcessorPerformanceInformation,
+ reinterpret_cast<void*>(processor_info.get()),
+ cpus_ * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION),
+ &returned_length);
+
+ if (returned_length !=
+ (cpus_ * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION))) {
+ LOG(LS_ERROR) << "NtQuerySystemInformation has unexpected size";
+ return 0.f;
+ }
+
+ uint64 current_idle = 0;
+ uint64 current_kernel = 0;
+ uint64 current_user = 0;
+ for (int ix = 0; ix < cpus_; ++ix) {
+ current_idle += processor_info[ix].IdleTime.QuadPart;
+ current_kernel += processor_info[ix].UserTime.QuadPart;
+ current_user += processor_info[ix].KernelTime.QuadPart;
+ }
+ total_times = current_kernel + current_user;
+ cpu_times = total_times - current_idle;
+ } else {
+ return 0.f;
+ }
+ }
+#endif // WIN32
+
+#if defined(IOS) || defined(OSX)
+ host_cpu_load_info_data_t cpu_info;
+ mach_msg_type_number_t info_count = HOST_CPU_LOAD_INFO_COUNT;
+ if (KERN_SUCCESS != host_statistics(mach_host_self(), HOST_CPU_LOAD_INFO,
+ reinterpret_cast<host_info_t>(&cpu_info),
+ &info_count)) {
+ LOG(LS_ERROR) << "::host_statistics() failed";
+ return 0.f;
+ }
+
+ const uint64 cpu_times = cpu_info.cpu_ticks[CPU_STATE_NICE] +
+ cpu_info.cpu_ticks[CPU_STATE_SYSTEM] +
+ cpu_info.cpu_ticks[CPU_STATE_USER];
+ const uint64 total_times = cpu_times + cpu_info.cpu_ticks[CPU_STATE_IDLE];
+#endif // defined(IOS) || defined(OSX)
+
+#if defined(LINUX) || defined(ANDROID)
+ if (sfile_.get() == NULL) {
+ LOG(LS_ERROR) << "Invalid handle for proc/stat";
+ return 0.f;
+ }
+ std::string statbuf;
+ sfile_->SetPosition(0);
+ if (!sfile_->ReadLine(&statbuf)) {
+ LOG_ERR(LS_ERROR) << "Could not read proc/stat file";
+ return 0.f;
+ }
+
+ unsigned long long user;
+ unsigned long long nice;
+ unsigned long long system;
+ unsigned long long idle;
+ if (sscanf(statbuf.c_str(), "cpu %Lu %Lu %Lu %Lu",
+ &user, &nice,
+ &system, &idle) != 4) {
+ LOG_ERR(LS_ERROR) << "Could not parse cpu info";
+ return 0.f;
+ }
+ const uint64 cpu_times = nice + system + user;
+ const uint64 total_times = cpu_times + idle;
+#endif // defined(LINUX) || defined(ANDROID)
+ system_.prev_load_time_ = timenow;
+ system_.prev_load_ = UpdateCpuLoad(total_times,
+ cpu_times * cpus_,
+ &system_.prev_total_times_,
+ &system_.prev_cpu_times_);
+ return system_.prev_load_;
+}
+
+float CpuSampler::GetProcessLoad() {
+ uint32 timenow = Time();
+ int elapsed = static_cast<int>(TimeDiff(timenow, process_.prev_load_time_));
+ if (min_load_interval_ != 0 && process_.prev_load_time_ != 0u &&
+ elapsed < min_load_interval_) {
+ return process_.prev_load_;
+ }
+#ifdef WIN32
+ FILETIME current_file_time;
+ ::GetSystemTimeAsFileTime(¤t_file_time);
+
+ FILETIME create_time, exit_time, kernel_time, user_time;
+ if (!::GetProcessTimes(::GetCurrentProcess(),
+ &create_time, &exit_time, &kernel_time, &user_time)) {
+ LOG(LS_ERROR) << "::GetProcessTimes() failed: " << ::GetLastError();
+ return 0.f;
+ }
+
+ const uint64 total_times =
+ ToUInt64(current_file_time) - ToUInt64(create_time);
+ const uint64 cpu_times =
+ (ToUInt64(kernel_time) + ToUInt64(user_time));
+#endif // WIN32
+
+#ifdef POSIX
+ // Common to both OSX and Linux.
+ struct timeval tv;
+ gettimeofday(&tv, NULL);
+ const uint64 total_times = tv.tv_sec * kNumMicrosecsPerSec + tv.tv_usec;
+#endif
+
+#if defined(IOS) || defined(OSX)
+ // Get live thread usage.
+ task_thread_times_info task_times_info;
+ mach_msg_type_number_t info_count = TASK_THREAD_TIMES_INFO_COUNT;
+
+ if (KERN_SUCCESS != task_info(mach_task_self(), TASK_THREAD_TIMES_INFO,
+ reinterpret_cast<task_info_t>(&task_times_info),
+ &info_count)) {
+ LOG(LS_ERROR) << "::task_info(TASK_THREAD_TIMES_INFO) failed";
+ return 0.f;
+ }
+
+ // Get terminated thread usage.
+ task_basic_info task_term_info;
+ info_count = TASK_BASIC_INFO_COUNT;
+ if (KERN_SUCCESS != task_info(mach_task_self(), TASK_BASIC_INFO,
+ reinterpret_cast<task_info_t>(&task_term_info),
+ &info_count)) {
+ LOG(LS_ERROR) << "::task_info(TASK_BASIC_INFO) failed";
+ return 0.f;
+ }
+
+ const uint64 cpu_times = (TimeValueTToInt64(task_times_info.user_time) +
+ TimeValueTToInt64(task_times_info.system_time) +
+ TimeValueTToInt64(task_term_info.user_time) +
+ TimeValueTToInt64(task_term_info.system_time));
+#endif // defined(IOS) || defined(OSX)
+
+#if defined(LINUX) || defined(ANDROID)
+ rusage usage;
+ if (getrusage(RUSAGE_SELF, &usage) < 0) {
+ LOG_ERR(LS_ERROR) << "getrusage failed";
+ return 0.f;
+ }
+
+ const uint64 cpu_times =
+ (usage.ru_utime.tv_sec + usage.ru_stime.tv_sec) * kNumMicrosecsPerSec +
+ usage.ru_utime.tv_usec + usage.ru_stime.tv_usec;
+#endif // defined(LINUX) || defined(ANDROID)
+ process_.prev_load_time_ = timenow;
+ process_.prev_load_ = UpdateCpuLoad(total_times,
+ cpu_times,
+ &process_.prev_total_times_,
+ &process_.prev_cpu_times_);
+ return process_.prev_load_;
+}
+
+int CpuSampler::GetMaxCpus() const {
+ return cpus_;
+}
+
+int CpuSampler::GetCurrentCpus() {
+ return sysinfo_->GetCurCpus();
+}
+
+///////////////////////////////////////////////////////////////////
+// Implementation of class CpuMonitor.
+CpuMonitor::CpuMonitor(Thread* thread)
+ : monitor_thread_(thread ? thread : Thread::Current()) {
+ monitor_thread_->SignalQueueDestroyed.connect(
+ this, &CpuMonitor::OnMessageQueueDestroyed);
+}
+
+CpuMonitor::~CpuMonitor() {
+ Stop();
+}
+
+bool CpuMonitor::Start(int period_ms) {
+ if (!sampler_.Init()) return false;
+
+ period_ms_ = period_ms;
+ if (monitor_thread_) {
+ monitor_thread_->PostDelayed(period_ms_, this);
+ }
+ return true;
+}
+
+void CpuMonitor::Stop() {
+ if (monitor_thread_) {
+ monitor_thread_->Clear(this);
+ }
+}
+
+void CpuMonitor::OnMessage(Message* msg) {
+ int max_cpus = sampler_.GetMaxCpus();
+ int current_cpus = sampler_.GetCurrentCpus();
+ float process_load = sampler_.GetProcessLoad();
+ float system_load = sampler_.GetSystemLoad();
+ SignalUpdate(current_cpus, max_cpus, process_load, system_load);
+
+ if (monitor_thread_) {
+ monitor_thread_->PostDelayed(period_ms_, this);
+ }
+}
+
+} // namespace talk_base
diff --git a/talk/base/cpumonitor.h b/talk/base/cpumonitor.h
new file mode 100644
index 0000000..f633f50
--- /dev/null
+++ b/talk/base/cpumonitor.h
@@ -0,0 +1,139 @@
+/*
+ * libjingle
+ * Copyright 2010 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_BASE_CPUMONITOR_H_
+#define TALK_BASE_CPUMONITOR_H_
+
+#include "talk/base/basictypes.h"
+#include "talk/base/messagehandler.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/sigslot.h"
+#if defined(LINUX) || defined(ANDROID)
+#include "talk/base/stream.h"
+#endif // defined(LINUX) || defined(ANDROID)
+
+namespace talk_base {
+class Thread;
+class SystemInfo;
+
+struct CpuStats {
+ CpuStats()
+ : prev_total_times_(0),
+ prev_cpu_times_(0),
+ prev_load_(0.f),
+ prev_load_time_(0u) {
+ }
+
+ uint64 prev_total_times_;
+ uint64 prev_cpu_times_;
+ float prev_load_; // Previous load value.
+ uint32 prev_load_time_; // Time previous load value was taken.
+};
+
+// CpuSampler samples the process and system load.
+class CpuSampler {
+ public:
+ CpuSampler();
+ ~CpuSampler();
+
+ // Initialize CpuSampler. Returns true if successful.
+ bool Init();
+
+ // Set minimum interval in ms between computing new load values.
+ // Default 950 ms. Set to 0 to disable interval.
+ void set_load_interval(int min_load_interval);
+
+ // Return CPU load of current process as a float from 0 to 1.
+ float GetProcessLoad();
+
+ // Return CPU load of current process as a float from 0 to 1.
+ float GetSystemLoad();
+
+ // Return number of cpus. Includes hyperthreads.
+ int GetMaxCpus() const;
+
+ // Return current number of cpus available to this process.
+ int GetCurrentCpus();
+
+ // For testing. Allows forcing of fallback to using NTDLL functions.
+ void set_force_fallback(bool fallback) {
+#ifdef WIN32
+ force_fallback_ = fallback;
+#endif
+ }
+
+ private:
+ float UpdateCpuLoad(uint64 current_total_times,
+ uint64 current_cpu_times,
+ uint64 *prev_total_times,
+ uint64 *prev_cpu_times);
+ CpuStats process_;
+ CpuStats system_;
+ int cpus_;
+ int min_load_interval_; // Minimum time between computing new load.
+ scoped_ptr<SystemInfo> sysinfo_;
+#ifdef WIN32
+ void* get_system_times_;
+ void* nt_query_system_information_;
+ bool force_fallback_;
+#endif
+#if defined(LINUX) || defined(ANDROID)
+ // File for reading /proc/stat
+ scoped_ptr<FileStream> sfile_;
+#endif // defined(LINUX) || defined(ANDROID)
+};
+
+// CpuMonitor samples and signals the CPU load periodically.
+class CpuMonitor
+ : public talk_base::MessageHandler, public sigslot::has_slots<> {
+ public:
+ explicit CpuMonitor(Thread* thread);
+ virtual ~CpuMonitor();
+
+ bool Start(int period_ms);
+ void Stop();
+ // Signal parameters are current cpus, max cpus, process load and system load.
+ sigslot::signal4<int, int, float, float> SignalUpdate;
+
+ protected:
+ // Override virtual method of parent MessageHandler.
+ virtual void OnMessage(talk_base::Message* msg);
+ // Clear the monitor thread and stop sending it messages if the thread goes
+ // away before our lifetime.
+ void OnMessageQueueDestroyed() { monitor_thread_ = NULL; }
+
+ private:
+ Thread* monitor_thread_;
+ CpuSampler sampler_;
+ int period_ms_;
+
+ DISALLOW_COPY_AND_ASSIGN(CpuMonitor);
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_CPUMONITOR_H_
diff --git a/talk/base/cpumonitor_unittest.cc b/talk/base/cpumonitor_unittest.cc
new file mode 100644
index 0000000..e83c969
--- /dev/null
+++ b/talk/base/cpumonitor_unittest.cc
@@ -0,0 +1,401 @@
+/*
+ * libjingle
+ * Copyright 2010 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 <iomanip>
+#include <iostream>
+#include <vector>
+
+#ifdef WIN32
+#include "talk/base/win32.h"
+#endif
+
+#include "talk/base/cpumonitor.h"
+#include "talk/base/flags.h"
+#include "talk/base/gunit.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/thread.h"
+#include "talk/base/timeutils.h"
+#include "talk/base/timing.h"
+
+namespace talk_base {
+
+static const int kMaxCpus = 1024;
+static const int kSettleTime = 100; // Amount of time to between tests.
+static const int kIdleTime = 500; // Amount of time to be idle in ms.
+static const int kBusyTime = 1000; // Amount of time to be busy in ms.
+
+class BusyThread : public talk_base::Thread {
+ public:
+ BusyThread(double load, double duration, double interval) :
+ load_(load), duration_(duration), interval_(interval) {
+ }
+ void Run() {
+ Timing time;
+ double busy_time = interval_ * load_ / 100.0;
+ for (;;) {
+ time.BusyWait(busy_time);
+ time.IdleWait(interval_ - busy_time);
+ if (duration_) {
+ duration_ -= interval_;
+ if (duration_ <= 0) {
+ break;
+ }
+ }
+ }
+ }
+ private:
+ double load_;
+ double duration_;
+ double interval_;
+};
+
+class CpuLoadListener : public sigslot::has_slots<> {
+ public:
+ CpuLoadListener()
+ : current_cpus_(0),
+ cpus_(0),
+ process_load_(.0f),
+ system_load_(.0f),
+ count_(0) {
+ }
+
+ void OnCpuLoad(int current_cpus, int cpus, float proc_load, float sys_load) {
+ current_cpus_ = current_cpus;
+ cpus_ = cpus;
+ process_load_ = proc_load;
+ system_load_ = sys_load;
+ ++count_;
+ }
+
+ int current_cpus() const { return current_cpus_; }
+ int cpus() const { return cpus_; }
+ float process_load() const { return process_load_; }
+ float system_load() const { return system_load_; }
+ int count() const { return count_; }
+
+ private:
+ int current_cpus_;
+ int cpus_;
+ float process_load_;
+ float system_load_;
+ int count_;
+};
+
+// Set affinity (which cpu to run on), but respecting FLAG_affinity:
+// -1 means no affinity - run on whatever cpu is available.
+// 0 .. N means run on specific cpu. The tool will create N threads and call
+// SetThreadAffinity on 0 to N - 1 as cpu. FLAG_affinity sets the first cpu
+// so the range becomes affinity to affinity + N - 1
+// Note that this function affects Windows scheduling, effectively giving
+// the thread with affinity for a specified CPU more priority on that CPU.
+bool SetThreadAffinity(BusyThread* t, int cpu, int affinity) {
+#ifdef WIN32
+ if (affinity >= 0) {
+ return ::SetThreadAffinityMask(t->GetHandle(),
+ 1 << (cpu + affinity)) != FALSE;
+ }
+#endif
+ return true;
+}
+
+bool SetThreadPriority(BusyThread* t, int prio) {
+ if (!prio) {
+ return true;
+ }
+ bool ok = t->SetPriority(static_cast<talk_base::ThreadPriority>(prio));
+ if (!ok) {
+ std::cout << "Error setting thread priority." << std::endl;
+ }
+ return ok;
+}
+
+int CpuLoad(double cpuload, double duration, int numthreads,
+ int priority, double interval, int affinity) {
+ int ret = 0;
+ std::vector<BusyThread*> threads;
+ for (int i = 0; i < numthreads; ++i) {
+ threads.push_back(new BusyThread(cpuload, duration, interval));
+ // NOTE(fbarchard): Priority must be done before Start.
+ if (!SetThreadPriority(threads[i], priority) ||
+ !threads[i]->Start() ||
+ !SetThreadAffinity(threads[i], i, affinity)) {
+ ret = 1;
+ break;
+ }
+ }
+ // Wait on each thread
+ if (ret == 0) {
+ for (int i = 0; i < numthreads; ++i) {
+ threads[i]->Stop();
+ }
+ }
+
+ for (int i = 0; i < numthreads; ++i) {
+ delete threads[i];
+ }
+ return ret;
+}
+
+// Make 2 CPUs busy
+static void CpuTwoBusyLoop(int busytime) {
+ CpuLoad(100.0, busytime / 1000.0, 2, 1, 0.050, -1);
+}
+
+// Make 1 CPUs busy
+static void CpuBusyLoop(int busytime) {
+ CpuLoad(100.0, busytime / 1000.0, 1, 1, 0.050, -1);
+}
+
+// Make 1 use half CPU time.
+static void CpuHalfBusyLoop(int busytime) {
+ CpuLoad(50.0, busytime / 1000.0, 1, 1, 0.050, -1);
+}
+
+void TestCpuSampler(bool test_proc, bool test_sys, bool force_fallback) {
+ CpuSampler sampler;
+ sampler.set_force_fallback(force_fallback);
+ EXPECT_TRUE(sampler.Init());
+ sampler.set_load_interval(100);
+ int cpus = sampler.GetMaxCpus();
+
+ // Test1: CpuSampler under idle situation.
+ Thread::SleepMs(kSettleTime);
+ sampler.GetProcessLoad();
+ sampler.GetSystemLoad();
+
+ Thread::SleepMs(kIdleTime);
+
+ float proc_idle = 0.f, sys_idle = 0.f;
+ if (test_proc) {
+ proc_idle = sampler.GetProcessLoad();
+ }
+ if (test_sys) {
+ sys_idle = sampler.GetSystemLoad();
+ }
+ if (test_proc) {
+ LOG(LS_INFO) << "ProcessLoad Idle: "
+ << setiosflags(std::ios_base::fixed)
+ << std::setprecision(2) << std::setw(6) << proc_idle;
+ EXPECT_GE(proc_idle, 0.f);
+ EXPECT_LE(proc_idle, static_cast<float>(cpus));
+ }
+ if (test_sys) {
+ LOG(LS_INFO) << "SystemLoad Idle: "
+ << setiosflags(std::ios_base::fixed)
+ << std::setprecision(2) << std::setw(6) << sys_idle;
+ EXPECT_GE(sys_idle, 0.f);
+ EXPECT_LE(sys_idle, static_cast<float>(cpus));
+ }
+
+ // Test2: CpuSampler with main process at 50% busy.
+ Thread::SleepMs(kSettleTime);
+ sampler.GetProcessLoad();
+ sampler.GetSystemLoad();
+
+ CpuHalfBusyLoop(kBusyTime);
+
+ float proc_halfbusy = 0.f, sys_halfbusy = 0.f;
+ if (test_proc) {
+ proc_halfbusy = sampler.GetProcessLoad();
+ }
+ if (test_sys) {
+ sys_halfbusy = sampler.GetSystemLoad();
+ }
+ if (test_proc) {
+ LOG(LS_INFO) << "ProcessLoad Halfbusy: "
+ << setiosflags(std::ios_base::fixed)
+ << std::setprecision(2) << std::setw(6) << proc_halfbusy;
+ EXPECT_GE(proc_halfbusy, 0.f);
+ EXPECT_LE(proc_halfbusy, static_cast<float>(cpus));
+ }
+ if (test_sys) {
+ LOG(LS_INFO) << "SystemLoad Halfbusy: "
+ << setiosflags(std::ios_base::fixed)
+ << std::setprecision(2) << std::setw(6) << sys_halfbusy;
+ EXPECT_GE(sys_halfbusy, 0.f);
+ EXPECT_LE(sys_halfbusy, static_cast<float>(cpus));
+ }
+
+ // Test3: CpuSampler with main process busy.
+ Thread::SleepMs(kSettleTime);
+ sampler.GetProcessLoad();
+ sampler.GetSystemLoad();
+
+ CpuBusyLoop(kBusyTime);
+
+ float proc_busy = 0.f, sys_busy = 0.f;
+ if (test_proc) {
+ proc_busy = sampler.GetProcessLoad();
+ }
+ if (test_sys) {
+ sys_busy = sampler.GetSystemLoad();
+ }
+ if (test_proc) {
+ LOG(LS_INFO) << "ProcessLoad Busy: "
+ << setiosflags(std::ios_base::fixed)
+ << std::setprecision(2) << std::setw(6) << proc_busy;
+ EXPECT_GE(proc_busy, 0.f);
+ EXPECT_LE(proc_busy, static_cast<float>(cpus));
+ }
+ if (test_sys) {
+ LOG(LS_INFO) << "SystemLoad Busy: "
+ << setiosflags(std::ios_base::fixed)
+ << std::setprecision(2) << std::setw(6) << sys_busy;
+ EXPECT_GE(sys_busy, 0.f);
+ EXPECT_LE(sys_busy, static_cast<float>(cpus));
+ }
+
+ // Test4: CpuSampler with 2 cpus process busy.
+ if (cpus >= 2) {
+ Thread::SleepMs(kSettleTime);
+ sampler.GetProcessLoad();
+ sampler.GetSystemLoad();
+
+ CpuTwoBusyLoop(kBusyTime);
+
+ float proc_twobusy = 0.f, sys_twobusy = 0.f;
+ if (test_proc) {
+ proc_twobusy = sampler.GetProcessLoad();
+ }
+ if (test_sys) {
+ sys_twobusy = sampler.GetSystemLoad();
+ }
+ if (test_proc) {
+ LOG(LS_INFO) << "ProcessLoad 2 CPU Busy:"
+ << setiosflags(std::ios_base::fixed)
+ << std::setprecision(2) << std::setw(6) << proc_twobusy;
+ EXPECT_GE(proc_twobusy, 0.f);
+ EXPECT_LE(proc_twobusy, static_cast<float>(cpus));
+ }
+ if (test_sys) {
+ LOG(LS_INFO) << "SystemLoad 2 CPU Busy: "
+ << setiosflags(std::ios_base::fixed)
+ << std::setprecision(2) << std::setw(6) << sys_twobusy;
+ EXPECT_GE(sys_twobusy, 0.f);
+ EXPECT_LE(sys_twobusy, static_cast<float>(cpus));
+ }
+ }
+
+ // Test5: CpuSampler with idle process after being busy.
+ Thread::SleepMs(kSettleTime);
+ sampler.GetProcessLoad();
+ sampler.GetSystemLoad();
+
+ Thread::SleepMs(kIdleTime);
+
+ if (test_proc) {
+ proc_idle = sampler.GetProcessLoad();
+ }
+ if (test_sys) {
+ sys_idle = sampler.GetSystemLoad();
+ }
+ if (test_proc) {
+ LOG(LS_INFO) << "ProcessLoad Idle: "
+ << setiosflags(std::ios_base::fixed)
+ << std::setprecision(2) << std::setw(6) << proc_idle;
+ EXPECT_GE(proc_idle, 0.f);
+ EXPECT_LE(proc_idle, proc_busy);
+ }
+ if (test_sys) {
+ LOG(LS_INFO) << "SystemLoad Idle: "
+ << setiosflags(std::ios_base::fixed)
+ << std::setprecision(2) << std::setw(6) << sys_idle;
+ EXPECT_GE(sys_idle, 0.f);
+ EXPECT_LE(sys_idle, static_cast<float>(cpus));
+ }
+}
+
+TEST(CpuMonitorTest, TestCpus) {
+ CpuSampler sampler;
+ EXPECT_TRUE(sampler.Init());
+ int current_cpus = sampler.GetCurrentCpus();
+ int cpus = sampler.GetMaxCpus();
+ LOG(LS_INFO) << "Current Cpus: " << std::setw(9) << current_cpus;
+ LOG(LS_INFO) << "Maximum Cpus: " << std::setw(9) << cpus;
+ EXPECT_GT(cpus, 0);
+ EXPECT_LE(cpus, kMaxCpus);
+ EXPECT_GT(current_cpus, 0);
+ EXPECT_LE(current_cpus, cpus);
+}
+
+#ifdef WIN32
+// Tests overall system CpuSampler using legacy OS fallback code if applicable.
+TEST(CpuMonitorTest, TestGetSystemLoadForceFallback) {
+ TestCpuSampler(false, true, true);
+}
+#endif
+
+// Tests both process and system functions in use at same time.
+TEST(CpuMonitorTest, TestGetBothLoad) {
+ TestCpuSampler(true, true, false);
+}
+
+// Tests a query less than the interval produces the same value.
+TEST(CpuMonitorTest, TestInterval) {
+ CpuSampler sampler;
+ EXPECT_TRUE(sampler.Init());
+
+ // Test1: Interval of 500 ms
+ sampler.set_load_interval(500);
+
+ sampler.GetProcessLoad();
+ sampler.GetSystemLoad();
+
+ float proc_orig = sampler.GetProcessLoad();
+ float sys_orig = sampler.GetSystemLoad();
+
+ CpuBusyLoop(200);
+
+ float proc_halftime = sampler.GetProcessLoad();
+ float sys_halftime = sampler.GetSystemLoad();
+
+ EXPECT_EQ(proc_orig, proc_halftime);
+ EXPECT_EQ(sys_orig, sys_halftime);
+}
+
+TEST(CpuMonitorTest, TestCpuMonitor) {
+ CpuMonitor monitor(Thread::Current());
+ CpuLoadListener listener;
+ monitor.SignalUpdate.connect(&listener, &CpuLoadListener::OnCpuLoad);
+ EXPECT_TRUE(monitor.Start(10));
+ Thread::Current()->ProcessMessages(50);
+ EXPECT_GT(listener.count(), 2); // We have checked cpu load more than twice.
+ EXPECT_GT(listener.current_cpus(), 0);
+ EXPECT_GT(listener.cpus(), 0);
+ EXPECT_GE(listener.process_load(), .0f);
+ EXPECT_GE(listener.system_load(), .0f);
+
+ monitor.Stop();
+ // Wait 20 ms to ake sure all signals are delivered.
+ Thread::Current()->ProcessMessages(20);
+ int old_count = listener.count();
+ Thread::Current()->ProcessMessages(20);
+ // Verfy no more siganls.
+ EXPECT_EQ(old_count, listener.count());
+}
+
+} // namespace talk_base
diff --git a/talk/base/criticalsection.h b/talk/base/criticalsection.h
index fd0f06c..5a09a93 100644
--- a/talk/base/criticalsection.h
+++ b/talk/base/criticalsection.h
@@ -63,6 +63,13 @@
EnterCriticalSection(&crit_);
TRACK_OWNER(thread_ = GetCurrentThreadId());
}
+ bool TryEnter() {
+ if (TryEnterCriticalSection(&crit_) != FALSE) {
+ TRACK_OWNER(thread_ = GetCurrentThreadId());
+ return true;
+ }
+ return false;
+ }
void Leave() {
TRACK_OWNER(thread_ = 0);
LeaveCriticalSection(&crit_);
@@ -96,6 +103,13 @@
pthread_mutex_lock(&mutex_);
TRACK_OWNER(thread_ = pthread_self());
}
+ bool TryEnter() {
+ if (pthread_mutex_trylock(&mutex_) == 0) {
+ TRACK_OWNER(thread_ = pthread_self());
+ return true;
+ }
+ return false;
+ }
void Leave() {
TRACK_OWNER(thread_ = 0);
pthread_mutex_unlock(&mutex_);
diff --git a/talk/base/dbus.cc b/talk/base/dbus.cc
new file mode 100644
index 0000000..86fea4d
--- /dev/null
+++ b/talk/base/dbus.cc
@@ -0,0 +1,405 @@
+/*
+ * libjingle
+ * Copyright 2004--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.
+ */
+
+#ifdef HAVE_DBUS_GLIB
+
+#include "talk/base/dbus.h"
+
+#include <dbus/dbus-glib-lowlevel.h>
+
+#include "talk/base/thread.h"
+
+namespace talk_base {
+
+// Avoid static object construction/destruction on startup/shutdown.
+static pthread_once_t g_dbus_init_once = PTHREAD_ONCE_INIT;
+static LibDBusGlibSymbolTable *g_dbus_symbol = NULL;
+
+// Releases DBus-Glib symbols.
+static void ReleaseDBusGlibSymbol() {
+ if (g_dbus_symbol != NULL) {
+ delete g_dbus_symbol;
+ g_dbus_symbol = NULL;
+ }
+}
+
+// Loads DBus-Glib symbols.
+static void InitializeDBusGlibSymbol() {
+ // This is thread safe.
+ if (NULL == g_dbus_symbol) {
+ g_dbus_symbol = new LibDBusGlibSymbolTable();
+
+ // Loads dbus-glib
+ if (NULL == g_dbus_symbol || !g_dbus_symbol->Load()) {
+ LOG(LS_WARNING) << "Failed to load dbus-glib symbol table.";
+ ReleaseDBusGlibSymbol();
+ } else {
+ // Nothing we can do if atexit() failed. Just ignore its returned value.
+ atexit(ReleaseDBusGlibSymbol);
+ }
+ }
+}
+
+// Returns a reference to the given late-binded symbol, with the correct type.
+#define LATE(sym) LATESYM_GET(LibDBusGlibSymbolTable, \
+ DBusMonitor::GetDBusGlibSymbolTable(), sym)
+
+// Implementation of class DBusSigMessageData
+DBusSigMessageData::DBusSigMessageData(DBusMessage *message)
+ : TypedMessageData<DBusMessage *>(message) {
+ LATE(dbus_message_ref)(data());
+}
+
+DBusSigMessageData::~DBusSigMessageData() {
+ LATE(dbus_message_unref)(data());
+}
+
+// Implementation of class DBusSigFilter
+
+// Builds a DBus filter string from given DBus path, interface and member.
+std::string DBusSigFilter::BuildFilterString(const std::string &path,
+ const std::string &interface,
+ const std::string &member) {
+ std::string ret(DBUS_TYPE "='" DBUS_SIGNAL "'");
+ if (!path.empty()) {
+ ret += ("," DBUS_PATH "='");
+ ret += path;
+ ret += "'";
+ }
+ if (!interface.empty()) {
+ ret += ("," DBUS_INTERFACE "='");
+ ret += interface;
+ ret += "'";
+ }
+ if (!member.empty()) {
+ ret += ("," DBUS_MEMBER "='");
+ ret += member;
+ ret += "'";
+ }
+ return ret;
+}
+
+// Forwards the message to the given instance.
+DBusHandlerResult DBusSigFilter::DBusCallback(DBusConnection *dbus_conn,
+ DBusMessage *message,
+ void *instance) {
+ ASSERT(instance);
+ if (instance) {
+ return static_cast<DBusSigFilter *>(instance)->Callback(message);
+ }
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+// Posts a message to caller thread.
+DBusHandlerResult DBusSigFilter::Callback(DBusMessage *message) {
+ if (caller_thread_) {
+ caller_thread_->Post(this, DSM_SIGNAL, new DBusSigMessageData(message));
+ }
+ // Don't "eat" the message here. Let it pop up.
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+// From MessageHandler.
+void DBusSigFilter::OnMessage(Message *message) {
+ if (message != NULL && DSM_SIGNAL == message->message_id) {
+ DBusSigMessageData *msg =
+ static_cast<DBusSigMessageData *>(message->pdata);
+ if (msg) {
+ ProcessSignal(msg->data());
+ delete msg;
+ }
+ }
+}
+
+// Definition of private class DBusMonitoringThread.
+// It creates a worker-thread to listen signals on DBus. The worker-thread will
+// be running in a priate GMainLoop forever until either Stop() has been invoked
+// or it hits an error.
+class DBusMonitor::DBusMonitoringThread : public talk_base::Thread {
+ public:
+ explicit DBusMonitoringThread(DBusMonitor *monitor,
+ GMainContext *context,
+ GMainLoop *mainloop,
+ std::vector<DBusSigFilter *> *filter_list)
+ : monitor_(monitor),
+ context_(context),
+ mainloop_(mainloop),
+ connection_(NULL),
+ idle_source_(NULL),
+ filter_list_(filter_list) {
+ ASSERT(monitor_);
+ ASSERT(context_);
+ ASSERT(mainloop_);
+ ASSERT(filter_list_);
+ }
+
+ // Override virtual method of Thread. Context: worker-thread.
+ virtual void Run() {
+ ASSERT(NULL == connection_);
+
+ // Setup DBus connection and start monitoring.
+ monitor_->OnMonitoringStatusChanged(DMS_INITIALIZING);
+ if (!Setup()) {
+ LOG(LS_ERROR) << "DBus monitoring setup failed.";
+ monitor_->OnMonitoringStatusChanged(DMS_FAILED);
+ CleanUp();
+ return;
+ }
+ monitor_->OnMonitoringStatusChanged(DMS_RUNNING);
+ LATE(g_main_loop_run)(mainloop_);
+ monitor_->OnMonitoringStatusChanged(DMS_STOPPED);
+
+ // Done normally. Clean up DBus connection.
+ CleanUp();
+ return;
+ }
+
+ // Override virtual method of Thread. Context: caller-thread.
+ virtual void Stop() {
+ ASSERT(NULL == idle_source_);
+ // Add an idle source and let the gmainloop quit on idle.
+ idle_source_ = LATE(g_idle_source_new)();
+ if (idle_source_) {
+ LATE(g_source_set_callback)(idle_source_, &Idle, this, NULL);
+ LATE(g_source_attach)(idle_source_, context_);
+ } else {
+ LOG(LS_ERROR) << "g_idle_source_new() failed.";
+ QuitGMainloop(); // Try to quit anyway.
+ }
+
+ Thread::Stop(); // Wait for the thread.
+ }
+
+ private:
+ // Registers all DBus filters.
+ void RegisterAllFilters() {
+ ASSERT(NULL != LATE(dbus_g_connection_get_connection)(connection_));
+
+ for (std::vector<DBusSigFilter *>::iterator it = filter_list_->begin();
+ it != filter_list_->end(); ++it) {
+ DBusSigFilter *filter = (*it);
+ if (!filter) {
+ LOG(LS_ERROR) << "DBusSigFilter list corrupted.";
+ continue;
+ }
+
+ LATE(dbus_bus_add_match)(
+ LATE(dbus_g_connection_get_connection)(connection_),
+ filter->filter().c_str(), NULL);
+
+ if (!LATE(dbus_connection_add_filter)(
+ LATE(dbus_g_connection_get_connection)(connection_),
+ &DBusSigFilter::DBusCallback, filter, NULL)) {
+ LOG(LS_ERROR) << "dbus_connection_add_filter() failed."
+ << "Filter: " << filter->filter();
+ continue;
+ }
+ }
+ }
+
+ // Unregisters all DBus filters.
+ void UnRegisterAllFilters() {
+ ASSERT(NULL != LATE(dbus_g_connection_get_connection)(connection_));
+
+ for (std::vector<DBusSigFilter *>::iterator it = filter_list_->begin();
+ it != filter_list_->end(); ++it) {
+ DBusSigFilter *filter = (*it);
+ if (!filter) {
+ LOG(LS_ERROR) << "DBusSigFilter list corrupted.";
+ continue;
+ }
+ LATE(dbus_connection_remove_filter)(
+ LATE(dbus_g_connection_get_connection)(connection_),
+ &DBusSigFilter::DBusCallback, filter);
+ }
+ }
+
+ // Sets up the monitoring thread.
+ bool Setup() {
+ LATE(g_main_context_push_thread_default)(context_);
+
+ // Start connection to dbus.
+ // If dbus daemon is not running, returns false immediately.
+ connection_ = LATE(dbus_g_bus_get_private)(monitor_->type_, context_, NULL);
+ if (NULL == connection_) {
+ LOG(LS_ERROR) << "dbus_g_bus_get_private() unable to get connection.";
+ return false;
+ }
+ if (NULL == LATE(dbus_g_connection_get_connection)(connection_)) {
+ LOG(LS_ERROR) << "dbus_g_connection_get_connection() returns NULL. "
+ << "DBus daemon is probably not running.";
+ return false;
+ }
+
+ // Application don't exit if DBus daemon die.
+ LATE(dbus_connection_set_exit_on_disconnect)(
+ LATE(dbus_g_connection_get_connection)(connection_), FALSE);
+
+ // Connect all filters.
+ RegisterAllFilters();
+
+ return true;
+ }
+
+ // Cleans up the monitoring thread.
+ void CleanUp() {
+ if (idle_source_) {
+ // We did an attach() with the GSource, so we need to destroy() it.
+ LATE(g_source_destroy)(idle_source_);
+ // We need to unref() the GSource to end the last reference we got.
+ LATE(g_source_unref)(idle_source_);
+ idle_source_ = NULL;
+ }
+ if (connection_) {
+ if (LATE(dbus_g_connection_get_connection)(connection_)) {
+ UnRegisterAllFilters();
+ LATE(dbus_connection_close)(
+ LATE(dbus_g_connection_get_connection)(connection_));
+ }
+ LATE(dbus_g_connection_unref)(connection_);
+ connection_ = NULL;
+ }
+ LATE(g_main_loop_unref)(mainloop_);
+ mainloop_ = NULL;
+ LATE(g_main_context_unref)(context_);
+ context_ = NULL;
+ }
+
+ // Handles callback on Idle. We only add this source when ready to stop.
+ static gboolean Idle(gpointer data) {
+ static_cast<DBusMonitoringThread *>(data)->QuitGMainloop();
+ return TRUE;
+ }
+
+ // We only hit this when ready to quit.
+ void QuitGMainloop() {
+ LATE(g_main_loop_quit)(mainloop_);
+ }
+
+ DBusMonitor *monitor_;
+
+ GMainContext *context_;
+ GMainLoop *mainloop_;
+ DBusGConnection *connection_;
+ GSource *idle_source_;
+
+ std::vector<DBusSigFilter *> *filter_list_;
+};
+
+// Implementation of class DBusMonitor
+
+// Returns DBus-Glib symbol handle. Initialize it first if hasn't.
+LibDBusGlibSymbolTable *DBusMonitor::GetDBusGlibSymbolTable() {
+ // This is multi-thread safe.
+ pthread_once(&g_dbus_init_once, InitializeDBusGlibSymbol);
+
+ return g_dbus_symbol;
+};
+
+// Creates an instance of DBusMonitor
+DBusMonitor *DBusMonitor::Create(DBusBusType type) {
+ if (NULL == DBusMonitor::GetDBusGlibSymbolTable()) {
+ return NULL;
+ }
+ return new DBusMonitor(type);
+}
+
+DBusMonitor::DBusMonitor(DBusBusType type)
+ : type_(type),
+ status_(DMS_NOT_INITIALIZED),
+ monitoring_thread_(NULL) {
+ ASSERT(type_ == DBUS_BUS_SYSTEM || type_ == DBUS_BUS_SESSION);
+}
+
+DBusMonitor::~DBusMonitor() {
+ StopMonitoring();
+}
+
+bool DBusMonitor::AddFilter(DBusSigFilter *filter) {
+ if (monitoring_thread_) {
+ return false;
+ }
+ if (!filter) {
+ return false;
+ }
+ filter_list_.push_back(filter);
+ return true;
+}
+
+bool DBusMonitor::StartMonitoring() {
+ if (!monitoring_thread_) {
+ LATE(g_type_init)();
+ LATE(g_thread_init)(NULL);
+ LATE(dbus_g_thread_init)();
+
+ GMainContext *context = LATE(g_main_context_new)();
+ if (NULL == context) {
+ LOG(LS_ERROR) << "g_main_context_new() failed.";
+ return false;
+ }
+
+ GMainLoop *mainloop = LATE(g_main_loop_new)(context, FALSE);
+ if (NULL == mainloop) {
+ LOG(LS_ERROR) << "g_main_loop_new() failed.";
+ LATE(g_main_context_unref)(context);
+ return false;
+ }
+
+ monitoring_thread_ = new DBusMonitoringThread(this, context, mainloop,
+ &filter_list_);
+ if (monitoring_thread_ == NULL) {
+ LOG(LS_ERROR) << "Failed to create DBus monitoring thread.";
+ LATE(g_main_context_unref)(context);
+ LATE(g_main_loop_unref)(mainloop);
+ return false;
+ }
+ monitoring_thread_->Start();
+ }
+ return true;
+}
+
+bool DBusMonitor::StopMonitoring() {
+ if (monitoring_thread_) {
+ monitoring_thread_->Stop();
+ monitoring_thread_ = NULL;
+ }
+ return true;
+}
+
+DBusMonitor::DBusMonitorStatus DBusMonitor::GetStatus() {
+ return status_;
+}
+
+void DBusMonitor::OnMonitoringStatusChanged(DBusMonitorStatus status) {
+ status_ = status;
+}
+
+#undef LATE
+
+} // namespace talk_base
+
+#endif // HAVE_DBUS_GLIB
diff --git a/talk/base/dbus.h b/talk/base/dbus.h
new file mode 100644
index 0000000..7dce350
--- /dev/null
+++ b/talk/base/dbus.h
@@ -0,0 +1,185 @@
+/*
+ * libjingle
+ * Copyright 2004--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_BASE_DBUS_H_
+#define TALK_BASE_DBUS_H_
+
+#ifdef HAVE_DBUS_GLIB
+
+#include <dbus/dbus.h>
+
+#include <string>
+#include <vector>
+
+#include "talk/base/libdbusglibsymboltable.h"
+#include "talk/base/messagehandler.h"
+#include "talk/base/thread.h"
+
+namespace talk_base {
+
+#define DBUS_TYPE "type"
+#define DBUS_SIGNAL "signal"
+#define DBUS_PATH "path"
+#define DBUS_INTERFACE "interface"
+#define DBUS_MEMBER "member"
+
+#ifdef CHROMEOS
+#define CROS_PM_PATH "/"
+#define CROS_PM_INTERFACE "org.chromium.PowerManager"
+#define CROS_SIG_POWERCHANGED "PowerStateChanged"
+#define CROS_VALUE_SLEEP "mem"
+#define CROS_VALUE_RESUME "on"
+#else
+#define UP_PATH "/org/freedesktop/UPower"
+#define UP_INTERFACE "org.freedesktop.UPower"
+#define UP_SIG_SLEEPING "Sleeping"
+#define UP_SIG_RESUMING "Resuming"
+#endif // CHROMEOS
+
+// Wraps a DBus messages.
+class DBusSigMessageData : public TypedMessageData<DBusMessage *> {
+ public:
+ explicit DBusSigMessageData(DBusMessage *message);
+ ~DBusSigMessageData();
+};
+
+// DBusSigFilter is an abstract class that defines the interface of DBus
+// signal handling.
+// The subclasses implement ProcessSignal() for various purposes.
+// When a DBus signal comes, a DSM_SIGNAL message is posted to the caller thread
+// which will then invokes ProcessSignal().
+class DBusSigFilter : protected MessageHandler {
+ public:
+ enum DBusSigMessage { DSM_SIGNAL };
+
+ // This filter string should ususally come from BuildFilterString()
+ explicit DBusSigFilter(const std::string &filter)
+ : caller_thread_(Thread::Current()), filter_(filter) {
+ }
+
+ // Builds a DBus monitor filter string from given DBus path, interface, and
+ // member.
+ // See http://dbus.freedesktop.org/doc/api/html/group__DBusConnection.html
+ static std::string BuildFilterString(const std::string &path,
+ const std::string &interface,
+ const std::string &member);
+
+ // Handles callback on DBus messages by DBus system.
+ static DBusHandlerResult DBusCallback(DBusConnection *dbus_conn,
+ DBusMessage *message,
+ void *instance);
+
+ // Handles callback on DBus messages to each DBusSigFilter instance.
+ DBusHandlerResult Callback(DBusMessage *message);
+
+ // From MessageHandler.
+ virtual void OnMessage(Message *message);
+
+ // Returns the DBus monitor filter string.
+ const std::string &filter() const { return filter_; }
+
+ private:
+ // On caller thread.
+ virtual void ProcessSignal(DBusMessage *message) = 0;
+
+ Thread *caller_thread_;
+ const std::string filter_;
+};
+
+// DBusMonitor is a class for DBus signal monitoring.
+//
+// The caller-thread calls AddFilter() first to add the signals that it wants to
+// monitor and then calls StartMonitoring() to start the monitoring.
+// This will create a worker-thread which listens on DBus connection and sends
+// DBus signals back through the callback.
+// The worker-thread will be running forever until either StopMonitoring() is
+// called from the caller-thread or the worker-thread hit some error.
+//
+// Programming model:
+// 1. Caller-thread: Creates an object of DBusMonitor.
+// 2. Caller-thread: Calls DBusMonitor::AddFilter() one or several times.
+// 3. Caller-thread: StartMonitoring().
+// ...
+// 4. Worker-thread: DBus signal recieved. Post a message to caller-thread.
+// 5. Caller-thread: DBusFilterBase::ProcessSignal() is invoked.
+// ...
+// 6. Caller-thread: StopMonitoring().
+//
+// Assumption:
+// AddFilter(), StartMonitoring(), and StopMonitoring() methods are called by
+// a single thread. Hence, there is no need to make them thread safe.
+class DBusMonitor {
+ public:
+ // Status of DBus monitoring.
+ enum DBusMonitorStatus {
+ DMS_NOT_INITIALIZED, // Not initialized.
+ DMS_INITIALIZING, // Initializing the monitoring thread.
+ DMS_RUNNING, // Monitoring.
+ DMS_STOPPED, // Not monitoring. Stopped normally.
+ DMS_FAILED, // Not monitoring. Failed.
+ };
+
+ // Returns the DBus-Glib symbol table.
+ // We should only use this function to access DBus-Glib symbols.
+ static LibDBusGlibSymbolTable *GetDBusGlibSymbolTable();
+
+ // Creates an instance of DBusMonitor.
+ static DBusMonitor *Create(DBusBusType type);
+ ~DBusMonitor();
+
+ // Adds a filter to DBusMonitor.
+ bool AddFilter(DBusSigFilter *filter);
+
+ // Starts DBus message monitoring.
+ bool StartMonitoring();
+
+ // Stops DBus message monitoring.
+ bool StopMonitoring();
+
+ // Gets the status of DBus monitoring.
+ DBusMonitorStatus GetStatus();
+
+ private:
+ // Forward declaration. Defined in the .cc file.
+ class DBusMonitoringThread;
+
+ explicit DBusMonitor(DBusBusType type);
+
+ // Updates status_ when monitoring status has changed.
+ void OnMonitoringStatusChanged(DBusMonitorStatus status);
+
+ DBusBusType type_;
+ DBusMonitorStatus status_;
+ DBusMonitoringThread *monitoring_thread_;
+ std::vector<DBusSigFilter *> filter_list_;
+};
+
+} // namespace talk_base
+
+#endif // HAVE_DBUS_GLIB
+
+#endif // TALK_BASE_DBUS_H_
diff --git a/talk/base/dbus_unittest.cc b/talk/base/dbus_unittest.cc
new file mode 100644
index 0000000..2b9a545
--- /dev/null
+++ b/talk/base/dbus_unittest.cc
@@ -0,0 +1,249 @@
+/*
+ * 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.
+ */
+
+#ifdef HAVE_DBUS_GLIB
+
+#include "talk/base/dbus.h"
+#include "talk/base/gunit.h"
+#include "talk/base/thread.h"
+
+namespace talk_base {
+
+#define SIG_NAME "NameAcquired"
+
+static const uint32 kTimeoutMs = 5000U;
+
+class DBusSigFilterTest : public DBusSigFilter {
+ public:
+ // DBusSigFilterTest listens on DBus service itself for "NameAcquired" signal.
+ // This signal should be received when the application connects to DBus
+ // service and gains ownership of a name.
+ // http://dbus.freedesktop.org/doc/dbus-specification.html
+ DBusSigFilterTest()
+ : DBusSigFilter(GetFilter()),
+ message_received_(false) {
+ }
+
+ bool MessageReceived() {
+ return message_received_;
+ }
+
+ private:
+ static std::string GetFilter() {
+ return talk_base::DBusSigFilter::BuildFilterString("", "", SIG_NAME);
+ }
+
+ // Implement virtual method of DBusSigFilter. On caller thread.
+ virtual void ProcessSignal(DBusMessage *message) {
+ EXPECT_TRUE(message != NULL);
+ message_received_ = true;
+ }
+
+ bool message_received_;
+};
+
+TEST(DBusMonitorTest, StartStopStartStop) {
+ DBusSigFilterTest filter;
+ talk_base::scoped_ptr<talk_base::DBusMonitor> monitor;
+ monitor.reset(talk_base::DBusMonitor::Create(DBUS_BUS_SYSTEM));
+ if (monitor.get()) {
+ EXPECT_TRUE(monitor->AddFilter(&filter));
+
+ EXPECT_TRUE(monitor->StopMonitoring());
+ EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_NOT_INITIALIZED);
+
+ EXPECT_TRUE(monitor->StartMonitoring());
+ EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor->GetStatus(), kTimeoutMs);
+ EXPECT_TRUE(monitor->StopMonitoring());
+ EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED);
+ EXPECT_TRUE(monitor->StopMonitoring());
+ EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED);
+
+ EXPECT_TRUE(monitor->StartMonitoring());
+ EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor->GetStatus(), kTimeoutMs);
+ EXPECT_TRUE(monitor->StartMonitoring());
+ EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_RUNNING);
+ EXPECT_TRUE(monitor->StopMonitoring());
+ EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED);
+ } else {
+ LOG(LS_WARNING) << "DBus Monitor not started. Skipping test.";
+ }
+}
+
+// DBusMonitorTest listens on DBus service itself for "NameAcquired" signal.
+// This signal should be received when the application connects to DBus
+// service and gains ownership of a name.
+// This test is to make sure that we capture the "NameAcquired" signal.
+TEST(DBusMonitorTest, ReceivedNameAcquiredSignal) {
+ DBusSigFilterTest filter;
+ talk_base::scoped_ptr<talk_base::DBusMonitor> monitor;
+ monitor.reset(talk_base::DBusMonitor::Create(DBUS_BUS_SYSTEM));
+ if (monitor.get()) {
+ EXPECT_TRUE(monitor->AddFilter(&filter));
+
+ EXPECT_TRUE(monitor->StartMonitoring());
+ EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor->GetStatus(), kTimeoutMs);
+ EXPECT_TRUE_WAIT(filter.MessageReceived(), kTimeoutMs);
+ EXPECT_TRUE(monitor->StopMonitoring());
+ EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED);
+ } else {
+ LOG(LS_WARNING) << "DBus Monitor not started. Skipping test.";
+ }
+}
+
+TEST(DBusMonitorTest, ConcurrentMonitors) {
+ DBusSigFilterTest filter1;
+ talk_base::scoped_ptr<talk_base::DBusMonitor> monitor1;
+ monitor1.reset(talk_base::DBusMonitor::Create(DBUS_BUS_SYSTEM));
+ if (monitor1.get()) {
+ EXPECT_TRUE(monitor1->AddFilter(&filter1));
+ DBusSigFilterTest filter2;
+ talk_base::scoped_ptr<talk_base::DBusMonitor> monitor2;
+ monitor2.reset(talk_base::DBusMonitor::Create(DBUS_BUS_SYSTEM));
+ EXPECT_TRUE(monitor2->AddFilter(&filter2));
+
+ EXPECT_TRUE(monitor1->StartMonitoring());
+ EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor1->GetStatus(), kTimeoutMs);
+ EXPECT_TRUE(monitor2->StartMonitoring());
+ EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor2->GetStatus(), kTimeoutMs);
+
+ EXPECT_TRUE_WAIT(filter2.MessageReceived(), kTimeoutMs);
+ EXPECT_TRUE(monitor2->StopMonitoring());
+ EXPECT_EQ(monitor2->GetStatus(), DBusMonitor::DMS_STOPPED);
+
+ EXPECT_TRUE_WAIT(filter1.MessageReceived(), kTimeoutMs);
+ EXPECT_TRUE(monitor1->StopMonitoring());
+ EXPECT_EQ(monitor1->GetStatus(), DBusMonitor::DMS_STOPPED);
+ } else {
+ LOG(LS_WARNING) << "DBus Monitor not started. Skipping test.";
+ }
+}
+
+TEST(DBusMonitorTest, ConcurrentFilters) {
+ DBusSigFilterTest filter1;
+ DBusSigFilterTest filter2;
+ talk_base::scoped_ptr<talk_base::DBusMonitor> monitor;
+ monitor.reset(talk_base::DBusMonitor::Create(DBUS_BUS_SYSTEM));
+ if (monitor.get()) {
+ EXPECT_TRUE(monitor->AddFilter(&filter1));
+ EXPECT_TRUE(monitor->AddFilter(&filter2));
+
+ EXPECT_TRUE(monitor->StartMonitoring());
+ EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor->GetStatus(), kTimeoutMs);
+
+ EXPECT_TRUE_WAIT(filter1.MessageReceived(), kTimeoutMs);
+ EXPECT_TRUE_WAIT(filter2.MessageReceived(), kTimeoutMs);
+
+ EXPECT_TRUE(monitor->StopMonitoring());
+ EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED);
+ } else {
+ LOG(LS_WARNING) << "DBus Monitor not started. Skipping test.";
+ }
+}
+
+TEST(DBusMonitorTest, NoAddFilterIfRunning) {
+ DBusSigFilterTest filter1;
+ DBusSigFilterTest filter2;
+ talk_base::scoped_ptr<talk_base::DBusMonitor> monitor;
+ monitor.reset(talk_base::DBusMonitor::Create(DBUS_BUS_SYSTEM));
+ if (monitor.get()) {
+ EXPECT_TRUE(monitor->AddFilter(&filter1));
+
+ EXPECT_TRUE(monitor->StartMonitoring());
+ EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor->GetStatus(), kTimeoutMs);
+ EXPECT_FALSE(monitor->AddFilter(&filter2));
+
+ EXPECT_TRUE(monitor->StopMonitoring());
+ EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED);
+ } else {
+ LOG(LS_WARNING) << "DBus Monitor not started. Skipping test.";
+ }
+}
+
+TEST(DBusMonitorTest, AddFilterAfterStop) {
+ DBusSigFilterTest filter1;
+ DBusSigFilterTest filter2;
+ talk_base::scoped_ptr<talk_base::DBusMonitor> monitor;
+ monitor.reset(talk_base::DBusMonitor::Create(DBUS_BUS_SYSTEM));
+ if (monitor.get()) {
+ EXPECT_TRUE(monitor->AddFilter(&filter1));
+ EXPECT_TRUE(monitor->StartMonitoring());
+ EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor->GetStatus(), kTimeoutMs);
+ EXPECT_TRUE_WAIT(filter1.MessageReceived(), kTimeoutMs);
+ EXPECT_TRUE(monitor->StopMonitoring());
+ EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED);
+
+ EXPECT_TRUE(monitor->AddFilter(&filter2));
+ EXPECT_TRUE(monitor->StartMonitoring());
+ EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor->GetStatus(), kTimeoutMs);
+ EXPECT_TRUE_WAIT(filter1.MessageReceived(), kTimeoutMs);
+ EXPECT_TRUE_WAIT(filter2.MessageReceived(), kTimeoutMs);
+ EXPECT_TRUE(monitor->StopMonitoring());
+ EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED);
+ } else {
+ LOG(LS_WARNING) << "DBus Monitor not started. Skipping test.";
+ }
+}
+
+TEST(DBusMonitorTest, StopRightAfterStart) {
+ DBusSigFilterTest filter;
+ talk_base::scoped_ptr<talk_base::DBusMonitor> monitor;
+ monitor.reset(talk_base::DBusMonitor::Create(DBUS_BUS_SYSTEM));
+ if (monitor.get()) {
+ EXPECT_TRUE(monitor->AddFilter(&filter));
+
+ EXPECT_TRUE(monitor->StartMonitoring());
+ EXPECT_TRUE(monitor->StopMonitoring());
+
+ // Stop the monitoring thread right after it had been started.
+ // If the monitoring thread got a chance to receive a DBus signal, it would
+ // post a message to the main thread and signal the main thread wakeup.
+ // This message will be cleaned out automatically when the filter get
+ // destructed. Here we also consume the wakeup signal (if there is one) so
+ // that the testing (main) thread is reset to a clean state.
+ talk_base::Thread::Current()->ProcessMessages(1);
+ } else {
+ LOG(LS_WARNING) << "DBus Monitor not started.";
+ }
+}
+
+TEST(DBusSigFilter, BuildFilterString) {
+ EXPECT_EQ(DBusSigFilter::BuildFilterString("", "", ""),
+ (DBUS_TYPE "='" DBUS_SIGNAL "'"));
+ EXPECT_EQ(DBusSigFilter::BuildFilterString("p", "", ""),
+ (DBUS_TYPE "='" DBUS_SIGNAL "'," DBUS_PATH "='p'"));
+ EXPECT_EQ(DBusSigFilter::BuildFilterString("p","i", ""),
+ (DBUS_TYPE "='" DBUS_SIGNAL "'," DBUS_PATH "='p',"
+ DBUS_INTERFACE "='i'"));
+ EXPECT_EQ(DBusSigFilter::BuildFilterString("p","i","m"),
+ (DBUS_TYPE "='" DBUS_SIGNAL "'," DBUS_PATH "='p',"
+ DBUS_INTERFACE "='i'," DBUS_MEMBER "='m'"));
+}
+
+} // namespace talk_base
+
+#endif // HAVE_DBUS_GLIB
diff --git a/talk/base/diskcache_win32.cc b/talk/base/diskcache_win32.cc
new file mode 100644
index 0000000..b49ed81
--- /dev/null
+++ b/talk/base/diskcache_win32.cc
@@ -0,0 +1,103 @@
+/*
+ * libjingle
+ * Copyright 2006, 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/base/win32.h"
+#include <shellapi.h>
+#include <shlobj.h>
+#include <tchar.h>
+
+#include <time.h>
+
+#include "talk/base/common.h"
+#include "talk/base/diskcache.h"
+#include "talk/base/pathutils.h"
+#include "talk/base/stream.h"
+#include "talk/base/stringencode.h"
+#include "talk/base/stringutils.h"
+
+#include "talk/base/diskcache_win32.h"
+
+namespace talk_base {
+
+bool DiskCacheWin32::InitializeEntries() {
+ // Note: We could store the cache information in a separate file, for faster
+ // initialization. Figuring it out empirically works, too.
+
+ std::wstring path16 = ToUtf16(folder_);
+ path16.append(1, '*');
+
+ WIN32_FIND_DATA find_data;
+ HANDLE find_handle = FindFirstFile(path16.c_str(), &find_data);
+ if (find_handle != INVALID_HANDLE_VALUE) {
+ do {
+ size_t index;
+ std::string id;
+ if (!FilenameToId(ToUtf8(find_data.cFileName), &id, &index))
+ continue;
+
+ Entry* entry = GetOrCreateEntry(id, true);
+ entry->size += find_data.nFileSizeLow;
+ total_size_ += find_data.nFileSizeLow;
+ entry->streams = _max(entry->streams, index + 1);
+ FileTimeToUnixTime(find_data.ftLastWriteTime, &entry->last_modified);
+
+ } while (FindNextFile(find_handle, &find_data));
+
+ FindClose(find_handle);
+ }
+
+ return true;
+}
+
+bool DiskCacheWin32::PurgeFiles() {
+ std::wstring path16 = ToUtf16(folder_);
+ path16.append(1, '*');
+ path16.append(1, '\0');
+
+ SHFILEOPSTRUCT file_op = { 0 };
+ file_op.wFunc = FO_DELETE;
+ file_op.pFrom = path16.c_str();
+ file_op.fFlags = FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT
+ | FOF_NORECURSION | FOF_FILESONLY;
+ if (0 != SHFileOperation(&file_op)) {
+ LOG_F(LS_ERROR) << "Couldn't delete cache files";
+ return false;
+ }
+
+ return true;
+}
+
+bool DiskCacheWin32::FileExists(const std::string& filename) const {
+ DWORD result = ::GetFileAttributes(ToUtf16(filename).c_str());
+ return (INVALID_FILE_ATTRIBUTES != result);
+}
+
+bool DiskCacheWin32::DeleteFile(const std::string& filename) const {
+ return ::DeleteFile(ToUtf16(filename).c_str()) != 0;
+}
+
+}
diff --git a/talk/base/diskcache_win32.h b/talk/base/diskcache_win32.h
new file mode 100644
index 0000000..a5e8de5
--- /dev/null
+++ b/talk/base/diskcache_win32.h
@@ -0,0 +1,46 @@
+/*
+ * libjingle
+ * Copyright 2006, 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_BASE_DISKCACHEWIN32_H__
+#define TALK_BASE_DISKCACHEWIN32_H__
+
+#include "talk/base/diskcache.h"
+
+namespace talk_base {
+
+class DiskCacheWin32 : public DiskCache {
+ protected:
+ virtual bool InitializeEntries();
+ virtual bool PurgeFiles();
+
+ virtual bool FileExists(const std::string& filename) const;
+ virtual bool DeleteFile(const std::string& filename) const;
+};
+
+}
+
+#endif // TALK_BASE_DISKCACHEWIN32_H__
diff --git a/talk/base/fakenetwork.h b/talk/base/fakenetwork.h
new file mode 100644
index 0000000..c5ae4b6
--- /dev/null
+++ b/talk/base/fakenetwork.h
@@ -0,0 +1,106 @@
+/*
+ * libjingle
+ * Copyright 2009 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_BASE_FAKENETWORK_H_
+#define TALK_BASE_FAKENETWORK_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/base/network.h"
+#include "talk/base/messagehandler.h"
+#include "talk/base/socketaddress.h"
+#include "talk/base/stringencode.h"
+#include "talk/base/thread.h"
+
+namespace talk_base {
+
+// Fake network manager that allows us to manually specify the IPs to use.
+class FakeNetworkManager : public NetworkManagerBase,
+ public MessageHandler {
+ public:
+ FakeNetworkManager()
+ : thread_(Thread::Current()),
+ next_index_(0),
+ started_(false) {
+ }
+
+ void AddInterface(const SocketAddress& iface) {
+ // ensure a unique name for the interface
+ SocketAddress address("test" + talk_base::ToString(next_index_++), 0);
+ address.SetResolvedIP(iface.ipaddr());
+ ifaces_.push_back(address);
+ DoUpdateNetworks();
+ }
+
+ void RemoveInterface(const SocketAddress& iface) {
+ for (std::vector<SocketAddress>::iterator it = ifaces_.begin();
+ it != ifaces_.end(); ++it) {
+ if (it->EqualIPs(iface)) {
+ ifaces_.erase(it);
+ break;
+ }
+ }
+ DoUpdateNetworks();
+ }
+
+ virtual void StartUpdating() {
+ started_ = true;
+ thread_->Post(this);
+ }
+
+ virtual void StopUpdating() {
+ started_ = false;
+ }
+
+ // MessageHandler interface.
+ virtual void OnMessage(Message* msg) {
+ DoUpdateNetworks();
+ }
+
+ private:
+ void DoUpdateNetworks() {
+ if (!started_)
+ return;
+ std::vector<Network*> networks;
+ for (std::vector<SocketAddress>::iterator it = ifaces_.begin();
+ it != ifaces_.end(); ++it) {
+ networks.push_back(new Network(it->hostname(), it->hostname(),
+ it->ipaddr()));
+ }
+ MergeNetworkList(networks, true);
+ }
+
+ Thread* thread_;
+ std::vector<SocketAddress> ifaces_;
+ int next_index_;
+ bool started_;
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_FAKENETWORK_H_
diff --git a/talk/base/faketaskrunner.h b/talk/base/faketaskrunner.h
new file mode 100644
index 0000000..6b5b035
--- /dev/null
+++ b/talk/base/faketaskrunner.h
@@ -0,0 +1,55 @@
+/*
+ * 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.
+ */
+
+// A fake TaskRunner for use in unit tests.
+
+#ifndef TALK_BASE_FAKETASKRUNNER_H_
+#define TALK_BASE_FAKETASKRUNNER_H_
+
+#include "talk/base/taskparent.h"
+#include "talk/base/taskrunner.h"
+
+namespace talk_base {
+
+class FakeTaskRunner : public TaskRunner {
+ public:
+ FakeTaskRunner() : current_time_(0) {}
+ virtual ~FakeTaskRunner() {}
+
+ virtual void WakeTasks() { RunTasks(); }
+
+ virtual int64 CurrentTime() {
+ // Implement if needed.
+ return current_time_++;
+ }
+
+ int64 current_time_;
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_FAKETASKRUNNER_H_
diff --git a/talk/base/filelock.cc b/talk/base/filelock.cc
new file mode 100644
index 0000000..2bc7045
--- /dev/null
+++ b/talk/base/filelock.cc
@@ -0,0 +1,79 @@
+/*
+ * libjingle
+ * Copyright 2009, 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/base/filelock.h"
+
+#include "talk/base/fileutils.h"
+#include "talk/base/logging.h"
+#include "talk/base/pathutils.h"
+#include "talk/base/stream.h"
+
+namespace talk_base {
+
+FileLock::FileLock(const std::string& path, FileStream* file)
+ : path_(path), file_(file) {
+}
+
+FileLock::~FileLock() {
+ MaybeUnlock();
+}
+
+void FileLock::Unlock() {
+ LOG_F(LS_INFO);
+ MaybeUnlock();
+}
+
+void FileLock::MaybeUnlock() {
+ if (file_.get() != NULL) {
+ LOG(LS_INFO) << "Unlocking:" << path_;
+ file_->Close();
+ Filesystem::DeleteFile(path_);
+ file_.reset();
+ }
+}
+
+FileLock* FileLock::TryLock(const std::string& path) {
+ FileStream* stream = new FileStream();
+ bool ok = false;
+#ifdef WIN32
+ // Open and lock in a single operation.
+ ok = stream->OpenShare(path, "a", _SH_DENYRW, NULL);
+#else // Linux and OSX
+ ok = stream->Open(path, "a", NULL) && stream->TryLock();
+#endif
+ if (ok) {
+ return new FileLock(path, stream);
+ } else {
+ // Something failed, either we didn't succeed to open the
+ // file or we failed to lock it. Anyway remove the heap
+ // allocated object and then return NULL to indicate failure.
+ delete stream;
+ return NULL;
+ }
+}
+
+} // namespace talk_base
diff --git a/talk/base/filelock.h b/talk/base/filelock.h
new file mode 100644
index 0000000..a4936f5
--- /dev/null
+++ b/talk/base/filelock.h
@@ -0,0 +1,70 @@
+/*
+ * libjingle
+ * Copyright 2009, 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_BASE_FILELOCK_H_
+#define TALK_BASE_FILELOCK_H_
+
+#include <string>
+
+#include "talk/base/constructormagic.h"
+#include "talk/base/scoped_ptr.h"
+
+namespace talk_base {
+
+class FileStream;
+
+// Implements a very simple cross process lock based on a file.
+// When Lock(...) is called we try to open/create the file in read/write
+// mode without any sharing. (Or locking it with flock(...) on Unix)
+// If the process crash the OS will make sure that the file descriptor
+// is released and another process can accuire the lock.
+// This doesn't work on ancient OSX/Linux versions if used on NFS.
+// (Nfs-client before: ~2.6 and Linux Kernel < 2.6.)
+class FileLock {
+ public:
+ virtual ~FileLock();
+
+ // Attempts to lock the file. The caller owns the returned
+ // lock object. Returns NULL if the file already was locked.
+ static FileLock* TryLock(const std::string& path);
+ void Unlock();
+
+ protected:
+ FileLock(const std::string& path, FileStream* file);
+
+ private:
+ void MaybeUnlock();
+
+ std::string path_;
+ scoped_ptr<FileStream> file_;
+
+ DISALLOW_EVIL_CONSTRUCTORS(FileLock);
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_FILELOCK_H_
diff --git a/talk/base/filelock_unittest.cc b/talk/base/filelock_unittest.cc
new file mode 100644
index 0000000..e585f91
--- /dev/null
+++ b/talk/base/filelock_unittest.cc
@@ -0,0 +1,104 @@
+/*
+ * libjingle
+ * Copyright 2009, 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 "talk/base/event.h"
+#include "talk/base/filelock.h"
+#include "talk/base/fileutils.h"
+#include "talk/base/gunit.h"
+#include "talk/base/pathutils.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/thread.h"
+
+namespace talk_base {
+
+const static std::string kLockFile = "TestLockFile";
+const static int kTimeoutMS = 5000;
+
+class FileLockTest : public testing::Test, public Runnable {
+ public:
+ FileLockTest() : done_(false, false), thread_lock_failed_(false) {
+ }
+
+ virtual void Run(Thread* t) {
+ scoped_ptr<FileLock> lock(FileLock::TryLock(temp_file_.pathname()));
+ // The lock is already owned by the main thread of
+ // this test, therefore the TryLock(...) call should fail.
+ thread_lock_failed_ = lock.get() == NULL;
+ done_.Set();
+ }
+
+ protected:
+ virtual void SetUp() {
+ thread_lock_failed_ = false;
+ Filesystem::GetAppTempFolder(&temp_dir_);
+ temp_file_ = Pathname(temp_dir_.pathname(), kLockFile);
+ }
+
+ void LockOnThread() {
+ locker_.Start(this);
+ done_.Wait(kTimeoutMS);
+ }
+
+ Event done_;
+ Thread locker_;
+ bool thread_lock_failed_;
+ Pathname temp_dir_;
+ Pathname temp_file_;
+};
+
+TEST_F(FileLockTest, TestLockFileDeleted) {
+ scoped_ptr<FileLock> lock(FileLock::TryLock(temp_file_.pathname()));
+ EXPECT_TRUE(lock.get() != NULL);
+ EXPECT_FALSE(Filesystem::IsAbsent(temp_file_.pathname()));
+ lock->Unlock();
+ EXPECT_TRUE(Filesystem::IsAbsent(temp_file_.pathname()));
+}
+
+TEST_F(FileLockTest, TestLock) {
+ scoped_ptr<FileLock> lock(FileLock::TryLock(temp_file_.pathname()));
+ EXPECT_TRUE(lock.get() != NULL);
+}
+
+TEST_F(FileLockTest, TestLockX2) {
+ scoped_ptr<FileLock> lock1(FileLock::TryLock(temp_file_.pathname()));
+ EXPECT_TRUE(lock1.get() != NULL);
+
+ scoped_ptr<FileLock> lock2(FileLock::TryLock(temp_file_.pathname()));
+ EXPECT_TRUE(lock2.get() == NULL);
+}
+
+TEST_F(FileLockTest, TestThreadedLock) {
+ scoped_ptr<FileLock> lock(FileLock::TryLock(temp_file_.pathname()));
+ EXPECT_TRUE(lock.get() != NULL);
+
+ LockOnThread();
+ EXPECT_TRUE(thread_lock_failed_);
+}
+
+} // namespace talk_base
diff --git a/talk/base/fileutils.cc b/talk/base/fileutils.cc
index 4504d29..7b0d348 100644
--- a/talk/base/fileutils.cc
+++ b/talk/base/fileutils.cc
@@ -154,15 +154,17 @@
#endif
}
-scoped_ptr<FilesystemInterface> Filesystem::default_filesystem_;
+FilesystemInterface* Filesystem::default_filesystem_ = NULL;
+
FilesystemInterface *Filesystem::EnsureDefaultFilesystem() {
- if (!default_filesystem_.get())
+ if (!default_filesystem_) {
#ifdef WIN32
- default_filesystem_.reset(new Win32Filesystem());
+ default_filesystem_ = new Win32Filesystem();
#else
- default_filesystem_.reset(new UnixFilesystem());
+ default_filesystem_ = new UnixFilesystem();
#endif
- return default_filesystem_.get();
+ }
+ return default_filesystem_;
}
bool FilesystemInterface::CopyFolder(const Pathname &old_path,
diff --git a/talk/base/fileutils.h b/talk/base/fileutils.h
index 644516d..186c963 100644
--- a/talk/base/fileutils.h
+++ b/talk/base/fileutils.h
@@ -285,18 +285,18 @@
class Filesystem {
public:
static FilesystemInterface *default_filesystem() {
- ASSERT(default_filesystem_.get() != NULL);
- return default_filesystem_.get();
+ ASSERT(default_filesystem_ != NULL);
+ return default_filesystem_;
}
static void set_default_filesystem(FilesystemInterface *filesystem) {
- default_filesystem_.reset(filesystem);
+ default_filesystem_ = filesystem;
}
static FilesystemInterface *swap_default_filesystem(
FilesystemInterface *filesystem) {
- FilesystemInterface *cur = default_filesystem_.release();
- default_filesystem_.reset(filesystem);
+ FilesystemInterface *cur = default_filesystem_;
+ default_filesystem_ = filesystem;
return cur;
}
@@ -425,7 +425,7 @@
}
private:
- static scoped_ptr<FilesystemInterface> default_filesystem_;
+ static FilesystemInterface* default_filesystem_;
static FilesystemInterface *EnsureDefaultFilesystem();
DISALLOW_IMPLICIT_CONSTRUCTORS(Filesystem);
@@ -455,4 +455,3 @@
} // namespace talk_base
#endif // TALK_BASE_FILEUTILS_H_
-
diff --git a/talk/base/fileutils_mock.h b/talk/base/fileutils_mock.h
index 2ccb6a3..b91e802 100644
--- a/talk/base/fileutils_mock.h
+++ b/talk/base/fileutils_mock.h
@@ -33,9 +33,9 @@
#include <vector>
#include "talk/base/fileutils.h"
+#include "talk/base/gunit.h"
#include "talk/base/pathutils.h"
#include "talk/base/stream.h"
-#include "testing/base/public/gmock.h"
namespace talk_base {
@@ -168,81 +168,81 @@
}
bool CreatePrivateFile(const Pathname &filename) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool DeleteFile(const Pathname &filename) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool DeleteEmptyFolder(const Pathname &folder) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool DeleteFolderContents(const Pathname &folder) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool DeleteFolderAndContents(const Pathname &folder) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool CreateFolder(const Pathname &pathname) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool MoveFolder(const Pathname &old_path, const Pathname &new_path) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool MoveFile(const Pathname &old_path, const Pathname &new_path) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool CopyFile(const Pathname &old_path, const Pathname &new_path) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool IsFolder(const Pathname &pathname) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool IsFile(const Pathname &pathname) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool IsAbsent(const Pathname &pathname) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool IsTemporaryPath(const Pathname &pathname) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool GetTemporaryFolder(Pathname &path, bool create,
const std::string *append) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
std::string TempFilename(const Pathname &dir, const std::string &prefix) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return std::string();
}
bool GetFileSize(const Pathname &path, size_t *size) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool GetFileTime(const Pathname &path, FileTimeType which,
time_t* time) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool GetAppPathname(Pathname *path) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool GetAppDataFolder(Pathname *path, bool per_user) {
- EXPECT_TRUE_M(per_user, "Unsupported operation");
+ EXPECT_TRUE(per_user) << "Unsupported operation";
#ifdef WIN32
path->SetPathname("c:\\Users\\test_user", "");
#else
@@ -251,11 +251,11 @@
return true;
}
bool GetAppTempFolder(Pathname *path) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
bool GetDiskFreeSpace(const Pathname &path, int64 *freebytes) {
- EXPECT_TRUE_M(false, "Unsupported operation");
+ EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
Pathname GetCurrentDirectory() {
diff --git a/talk/base/firewallsocketserver.cc b/talk/base/firewallsocketserver.cc
index a99c72e..71385f8 100644
--- a/talk/base/firewallsocketserver.cc
+++ b/talk/base/firewallsocketserver.cc
@@ -177,11 +177,11 @@
const Rule& r = rules_[i];
if ((r.p != p) && (r.p != FP_ANY))
continue;
- if ((r.src.ip() != src.ip()) && !r.src.IsAny())
+ if ((r.src.ipaddr() != src.ipaddr()) && !r.src.IsAny())
continue;
if ((r.src.port() != src.port()) && (r.src.port() != 0))
continue;
- if ((r.dst.ip() != dst.ip()) && !r.dst.IsAny())
+ if ((r.dst.ipaddr() != dst.ipaddr()) && !r.dst.IsAny())
continue;
if ((r.dst.port() != dst.port()) && (r.dst.port() != 0))
continue;
diff --git a/talk/base/flags.h b/talk/base/flags.h
index a6eee00..f22e125 100644
--- a/talk/base/flags.h
+++ b/talk/base/flags.h
@@ -25,6 +25,9 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+
+// Originally comes from shared/commandlineflags/flags.h
+
// Flags are defined and declared using DEFINE_xxx and DECLARE_xxx macros,
// where xxx is the flag type. Flags are referred to via FLAG_yyy,
// where yyy is the flag name. For intialization and iteration of flags,
diff --git a/talk/base/gunit.h b/talk/base/gunit.h
index 9d04595..0682337 100644
--- a/talk/base/gunit.h
+++ b/talk/base/gunit.h
@@ -109,21 +109,6 @@
} \
} while (0);
-#ifdef __LP64__
-// When compiling in 64-bit mode we redefine the TEST and TEST_F macros to
-// append _64bit to all testsuite names to distinguish the test results from
-// those for the 32-bit cross-built binaries.
-#undef TEST
-#undef TEST_F
-// Copied and adjusted from google3/third_party/gtest/include/gtest/gtest.h
-#define TEST(test_case_name, test_name)\
- GTEST_TEST_(test_case_name##_64bit, test_name, \
- ::testing::Test, ::testing::internal::GetTestTypeId())
-#define TEST_F(test_fixture, test_name)\
- GTEST_TEST_(test_fixture##_64bit, test_name, test_fixture, \
- ::testing::internal::GetTypeId<test_fixture>())
-#endif
-
talk_base::Pathname GetTalkDirectory();
#endif // TALK_BASE_GUNIT_H_
diff --git a/talk/base/helpers.cc b/talk/base/helpers.cc
index 5b0e447..366a0fd 100644
--- a/talk/base/helpers.cc
+++ b/talk/base/helpers.cc
@@ -40,9 +40,10 @@
#endif
#include "talk/base/base64.h"
+#include "talk/base/basictypes.h"
#include "talk/base/logging.h"
#include "talk/base/scoped_ptr.h"
-#include "talk/base/time.h"
+#include "talk/base/timeutils.h"
// Protect against max macro inclusion.
#undef max
@@ -206,8 +207,9 @@
// This round about way of creating a global RNG is to safe-guard against
// indeterminant static initialization order.
scoped_ptr<RandomGenerator>& GetGlobalRng() {
- static scoped_ptr<RandomGenerator> g_rng(new SecureRandomGenerator());
- return g_rng;
+ LIBJINGLE_DEFINE_STATIC_LOCAL(scoped_ptr<RandomGenerator>, global_rng,
+ (new SecureRandomGenerator()));
+ return global_rng;
}
RandomGenerator& Rng() {
diff --git a/talk/base/ipaddress.cc b/talk/base/ipaddress.cc
new file mode 100644
index 0000000..036584f
--- /dev/null
+++ b/talk/base/ipaddress.cc
@@ -0,0 +1,388 @@
+/*
+ * libjingle
+ * Copyright 2004--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.
+ */
+
+#ifdef POSIX
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#ifdef OPENBSD
+#include <netinet/in_systm.h>
+#endif
+#include <netinet/ip.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <unistd.h>
+#endif
+
+#include <stdio.h>
+
+#include "talk/base/ipaddress.h"
+#include "talk/base/byteorder.h"
+#include "talk/base/nethelpers.h"
+#include "talk/base/logging.h"
+#include "talk/base/win32.h"
+
+namespace talk_base {
+
+static const unsigned char kMappedPrefix[] = {0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xFF, 0xFF};
+static bool IsPrivateV4(uint32 ip);
+static bool IsMappedAddress(const in6_addr& addr);
+static in_addr ExtractMappedAddress(const in6_addr& addr);
+
+uint32 IPAddress::v4AddressAsHostOrderInteger() const {
+ if (family_ == AF_INET) {
+ return ntohl(u_.ip4.s_addr);
+ } else {
+ return 0;
+ }
+}
+
+size_t IPAddress::Size() const {
+ switch (family_) {
+ case AF_INET:
+ return sizeof(in_addr);
+ case AF_INET6:
+ return sizeof(in6_addr);
+ }
+ return 0;
+}
+
+
+bool IPAddress::operator==(const IPAddress &other) const {
+ if (family_ != other.family_) {
+ return false;
+ }
+ if (family_ == AF_INET) {
+ return memcmp(&u_.ip4, &other.u_.ip4, sizeof(u_.ip4)) == 0;
+ }
+ if (family_ == AF_INET6) {
+ return memcmp(&u_.ip6, &other.u_.ip6, sizeof(u_.ip6)) == 0;
+ }
+ return family_ == AF_UNSPEC;
+}
+
+bool IPAddress::operator!=(const IPAddress &other) const {
+ return !((*this) == other);
+}
+
+bool IPAddress::operator >(const IPAddress &other) const {
+ return (*this) != other && !((*this) < other);
+}
+
+bool IPAddress::operator <(const IPAddress &other) const {
+ // IPv4 is 'less than' IPv6
+ if (family_ != other.family_) {
+ if (family_ == AF_UNSPEC) {
+ return true;
+ }
+ if (family_ == AF_INET && other.family_ == AF_INET6) {
+ return true;
+ }
+ return false;
+ }
+ // Comparing addresses of the same family.
+ switch (family_) {
+ case AF_INET: {
+ return ntohl(u_.ip4.s_addr) < ntohl(other.u_.ip4.s_addr);
+ }
+ case AF_INET6: {
+ return memcmp(&u_.ip6.s6_addr, &other.u_.ip6.s6_addr, 16) < 0;
+ }
+ }
+ // Catches AF_UNSPEC and invalid addresses.
+ return false;
+}
+
+std::ostream& operator<<(std::ostream& os, const IPAddress& ip) {
+ os << ip.ToString();
+ return os;
+}
+
+in6_addr IPAddress::ipv6_address() const {
+ return u_.ip6;
+}
+
+in_addr IPAddress::ipv4_address() const {
+ return u_.ip4;
+}
+
+std::string IPAddress::ToString() const {
+ if (family_ != AF_INET && family_ != AF_INET6) {
+ return std::string();
+ }
+ char buf[INET6_ADDRSTRLEN] = {0};
+ const void* src = &u_.ip4;
+ if (family_ == AF_INET6) {
+ src = &u_.ip6;
+ }
+ if (!talk_base::inet_ntop(family_, src, buf, sizeof(buf))) {
+ return std::string();
+ }
+ return std::string(buf);
+}
+
+IPAddress IPAddress::Normalized() const {
+ if (family_ != AF_INET6) {
+ return *this;
+ }
+ if (!IsMappedAddress(u_.ip6)) {
+ return *this;
+ }
+ in_addr addr = ExtractMappedAddress(u_.ip6);
+ return IPAddress(addr);
+}
+
+IPAddress IPAddress::AsIPv6Address() const {
+ if (family_ != AF_INET) {
+ return *this;
+ }
+ // uint32 v4 = (u_.ip4.s_addr);
+ in6_addr v6addr;
+ ::memcpy(&v6addr.s6_addr, kMappedPrefix, sizeof(kMappedPrefix));
+ ::memcpy(&v6addr.s6_addr[12], &u_.ip4.s_addr, sizeof(u_.ip4.s_addr));
+ return IPAddress(v6addr);
+}
+
+bool IsPrivateV4(uint32 ip_in_host_order) {
+ return ((ip_in_host_order >> 24) == 127) ||
+ ((ip_in_host_order >> 24) == 10) ||
+ ((ip_in_host_order >> 20) == ((172 << 4) | 1)) ||
+ ((ip_in_host_order >> 16) == ((192 << 8) | 168)) ||
+ ((ip_in_host_order >> 16) == ((169 << 8) | 254));
+}
+
+bool IsMappedAddress(const in6_addr& addr) {
+ return memcmp(&(addr.s6_addr), kMappedPrefix, sizeof(kMappedPrefix)) == 0;
+}
+
+in_addr ExtractMappedAddress(const in6_addr& in6) {
+ in_addr ipv4;
+ ::memcpy(&ipv4.s_addr, &in6.s6_addr[12], sizeof(ipv4.s_addr));
+ return ipv4;
+}
+
+bool IPFromHostEnt(hostent* host_ent, IPAddress* out) {
+ return IPFromHostEnt(host_ent, 0, out);
+}
+
+bool IPFromHostEnt(hostent* host_ent, int idx, IPAddress* out) {
+ if (!out || (idx < 0)) {
+ return false;
+ }
+ char** requested_address = host_ent->h_addr_list;
+ // Find the idx-th element (while checking for null, which terminates the
+ // list of addresses).
+ while (*requested_address && idx) {
+ idx--;
+ requested_address++;
+ }
+ if (!(*requested_address)) {
+ return false;
+ }
+
+ if (host_ent->h_addrtype == AF_INET) {
+ in_addr ip;
+ ip.s_addr = *reinterpret_cast<uint32*>(*requested_address);
+ *out = IPAddress(ip);
+ return true;
+ } else if (host_ent->h_addrtype == AF_INET6) {
+ in6_addr ip;
+ ::memcpy(&ip.s6_addr, *requested_address, host_ent->h_length);
+ *out = IPAddress(ip);
+ return true;
+ }
+ return false;
+}
+
+bool IPFromString(const std::string& str, IPAddress* out) {
+ if (!out) {
+ return false;
+ }
+ in_addr addr;
+ if (talk_base::inet_pton(AF_INET, str.c_str(), &addr) == 0) {
+ in6_addr addr6;
+ if (talk_base::inet_pton(AF_INET6, str.c_str(), &addr6) == 0) {
+ *out = IPAddress();
+ return false;
+ }
+ *out = IPAddress(addr6);
+ } else {
+ *out = IPAddress(addr);
+ }
+ return true;
+}
+
+bool IPIsAny(const IPAddress& ip) {
+ static const IPAddress kIPv4Any(INADDR_ANY);
+ static const IPAddress kIPv6Any(in6addr_any);
+ switch (ip.family()) {
+ case AF_INET:
+ return ip == kIPv4Any;
+ case AF_INET6:
+ return ip == kIPv6Any;
+ case AF_UNSPEC:
+ return false;
+ }
+ return false;
+}
+
+bool IPIsLoopback(const IPAddress& ip) {
+ static const IPAddress kIPv4Loopback(INADDR_LOOPBACK);
+ static const IPAddress kIPv6Loopback(in6addr_loopback);
+ switch (ip.family()) {
+ case AF_INET: {
+ return ip == kIPv4Loopback;
+ }
+ case AF_INET6: {
+ return ip == kIPv6Loopback;
+ }
+ }
+ return false;
+}
+
+bool IPIsPrivate(const IPAddress& ip) {
+ switch (ip.family()) {
+ case AF_INET: {
+ return IsPrivateV4(ip.v4AddressAsHostOrderInteger());
+ }
+ case AF_INET6: {
+ in6_addr v6 = ip.ipv6_address();
+ return (v6.s6_addr[0] == 0xFE && v6.s6_addr[1] == 0x80) ||
+ IPIsLoopback(ip);
+ }
+ }
+ return false;
+}
+
+size_t HashIP(const IPAddress& ip) {
+ switch (ip.family()) {
+ case AF_INET: {
+ return ip.ipv4_address().s_addr;
+ }
+ case AF_INET6: {
+ in6_addr v6addr = ip.ipv6_address();
+ const uint32* v6_as_ints =
+ reinterpret_cast<const uint32*>(&v6addr.s6_addr);
+ return v6_as_ints[0] ^ v6_as_ints[1] ^ v6_as_ints[2] ^ v6_as_ints[3];
+ }
+ }
+ return 0;
+}
+
+IPAddress TruncateIP(const IPAddress& ip, int length) {
+ if (length < 0) {
+ return IPAddress();
+ }
+ if (ip.family() == AF_INET) {
+ if (length > 31) {
+ return ip;
+ }
+ if (length == 0) {
+ return IPAddress(INADDR_ANY);
+ }
+ int mask = (0xFFFFFFFF << (32 - length));
+ uint32 host_order_ip = NetworkToHost32(ip.ipv4_address().s_addr);
+ in_addr masked;
+ masked.s_addr = HostToNetwork32(host_order_ip & mask);
+ return IPAddress(masked);
+ } else if (ip.family() == AF_INET6) {
+ if (length > 127) {
+ return ip;
+ }
+ if (length == 0) {
+ return IPAddress(in6addr_any);
+ }
+ in6_addr v6addr = ip.ipv6_address();
+ int position = length / 32;
+ int inner_length = (length - (position * 32));
+ int inner_mask = (0xFFFFFFFF << (32 - inner_length));
+ uint32* v6_as_ints =
+ reinterpret_cast<uint32*>(&v6addr.s6_addr);
+ in6_addr ip_addr = ip.ipv6_address();
+ for (int i = 0; i < 4; ++i) {
+ if (i == position) {
+ uint32 host_order_inner = NetworkToHost32(v6_as_ints[i]);
+ v6_as_ints[i] = HostToNetwork32(host_order_inner & inner_mask);
+ } else if (i > position) {
+ v6_as_ints[i] = 0;
+ }
+ }
+ return IPAddress(v6addr);
+ }
+ return IPAddress();
+}
+
+int CountIPMaskBits(IPAddress mask) {
+ // Doing this the lazy/simple way.
+ // Clever bit tricks welcome but please be careful re: byte order.
+ uint32 word_to_count = 0;
+ int bits = 0;
+ switch (mask.family()) {
+ case AF_INET: {
+ word_to_count = NetworkToHost32(mask.ipv4_address().s_addr);
+ break;
+ }
+ case AF_INET6: {
+ in6_addr v6addr = mask.ipv6_address();
+ const uint32* v6_as_ints =
+ reinterpret_cast<const uint32*>(&v6addr.s6_addr);
+ int i = 0;
+ for (; i < 4; ++i) {
+ if (v6_as_ints[i] != 0xFFFFFFFF) {
+ break;
+ }
+ }
+ if (i < 4) {
+ word_to_count = NetworkToHost32(v6_as_ints[i]);
+ }
+ bits = (i * 32);
+ break;
+ }
+ default: {
+ return 0;
+ }
+ }
+ // Check for byte boundaries before scanning.
+ if (word_to_count == 0) {
+ return bits;
+ } else if (word_to_count == 0xFF000000) {
+ return bits + 8;
+ } else if (word_to_count == 0xFFFF0000) {
+ return bits + 16;
+ } else if (word_to_count == 0xFFFFFF00) {
+ return bits + 24;
+ }
+
+ while (word_to_count & 0x80000000) {
+ word_to_count <<= 1;
+ ++bits;
+ }
+ return bits;
+}
+} // Namespace talk base
diff --git a/talk/base/ipaddress.h b/talk/base/ipaddress.h
new file mode 100644
index 0000000..b1063fd
--- /dev/null
+++ b/talk/base/ipaddress.h
@@ -0,0 +1,136 @@
+/*
+ * 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_BASE_IPADDRESS_H_
+#define TALK_BASE_IPADDRESS_H_
+
+#ifdef POSIX
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#endif
+#ifdef WIN32
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#endif
+#include <string.h>
+#include <string>
+#include <vector>
+
+#include "talk/base/basictypes.h"
+#ifdef WIN32
+#include "talk/base/win32.h"
+#endif
+
+namespace talk_base {
+
+// Version-agnostic IP address class, wraps a union of in_addr and in6_addr.
+class IPAddress {
+ public:
+ IPAddress() : family_(AF_UNSPEC) {
+ ::memset(&u_, 0, sizeof(u_));
+ }
+
+ explicit IPAddress(const in_addr &ip4) : family_(AF_INET) {
+ memset(&u_, 0, sizeof(u_));
+ u_.ip4 = ip4;
+ }
+
+ explicit IPAddress(const in6_addr &ip6) : family_(AF_INET6) {
+ u_.ip6 = ip6;
+ }
+
+ explicit IPAddress(uint32 ip_in_host_byte_order) : family_(AF_INET) {
+ memset(&u_, 0, sizeof(u_));
+ u_.ip4.s_addr = htonl(ip_in_host_byte_order);
+ }
+
+ IPAddress(const IPAddress &other) : family_(other.family_) {
+ ::memcpy(&u_, &other.u_, sizeof(u_));
+ }
+
+ ~IPAddress() {}
+
+ const IPAddress & operator=(const IPAddress &other) {
+ family_ = other.family_;
+ ::memcpy(&u_, &other.u_, sizeof(u_));
+ return *this;
+ }
+
+ bool operator==(const IPAddress &other) const;
+ bool operator!=(const IPAddress &other) const;
+ bool operator <(const IPAddress &other) const;
+ bool operator >(const IPAddress &other) const;
+ friend std::ostream& operator<<(std::ostream& os, const IPAddress& addr);
+
+ int family() const { return family_; }
+ in_addr ipv4_address() const;
+ in6_addr ipv6_address() const;
+
+ // Returns the number of bytes needed to store the raw address.
+ size_t Size() const;
+
+ // Wraps inet_ntop.
+ std::string ToString() const;
+
+ // Returns an unmapped address from a possibly-mapped address.
+ // Returns the same address if this isn't a mapped address.
+ IPAddress Normalized() const;
+
+ // Returns this address as an IPv6 address.
+ // Maps v4 addresses (as ::ffff:a.b.c.d), returns v6 addresses unchanged.
+ IPAddress AsIPv6Address() const;
+
+ // For socketaddress' benefit. Returns the IP in host byte order.
+ uint32 v4AddressAsHostOrderInteger() const;
+
+ private:
+ int family_;
+ union {
+ in_addr ip4;
+ in6_addr ip6;
+ } u_;
+};
+
+bool IPFromHostEnt(hostent* hostEnt, IPAddress* out);
+bool IPFromHostEnt(hostent* hostEnt, int idx, IPAddress* out);
+bool IPFromString(const std::string& str, IPAddress* out);
+bool IPIsAny(const IPAddress& ip);
+bool IPIsLoopback(const IPAddress& ip);
+bool IPIsPrivate(const IPAddress& ip);
+size_t HashIP(const IPAddress& ip);
+
+// Returns 'ip' truncated to be 'length' bits long.
+IPAddress TruncateIP(const IPAddress& ip, int length);
+// Returns the number of contiguously set bits, counting from the MSB in network
+// byte order, in this IPAddress. Bits after the first 0 encountered are not
+// counted.
+int CountIPMaskBits(IPAddress mask);
+} // namespace talk_base
+
+#endif // TALK_BASE_IPADDRESS_H_
diff --git a/talk/base/ipaddress_unittest.cc b/talk/base/ipaddress_unittest.cc
new file mode 100644
index 0000000..40cf187
--- /dev/null
+++ b/talk/base/ipaddress_unittest.cc
@@ -0,0 +1,765 @@
+/*
+ * libjingle
+ * Copyright 2004--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/base/gunit.h"
+#include "talk/base/ipaddress.h"
+
+namespace talk_base {
+
+static const unsigned int kIPv4AddrSize = 4;
+static const unsigned int kIPv6AddrSize = 16;
+static const unsigned int kIPv4RFC1918Addr = 0xC0A80701;
+static const unsigned int kIPv4PublicAddr = 0x01020304;
+static const in6_addr kIPv6LinkLocalAddr = {{{0xfe, 0x80, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0xbe, 0x30, 0x5b, 0xff,
+ 0xfe, 0xe5, 0x00, 0xc3}}};
+static const in6_addr kIPv6PublicAddr = {{{0x24, 0x01, 0xfa, 0x00,
+ 0x00, 0x04, 0x10, 0x00,
+ 0xbe, 0x30, 0x5b, 0xff,
+ 0xfe, 0xe5, 0x00, 0xc3}}};
+static const in6_addr kIPv6CompatAddr = {{{0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0xfe, 0xe5, 0x00, 0xc3}}};
+static const in6_addr kIPv4MappedAnyAddr = {{{0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xff, 0xff,
+ 0x00, 0x00, 0x00, 0x00}}};
+static const in6_addr kIPv4MappedLoopbackAddr = {{{0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xff, 0xff,
+ 0x7f, 0x00, 0x00, 0x01}}};
+static const in6_addr kIPv4MappedRFC1918Addr = {{{0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xff, 0xff,
+ 0xc0, 0xa8, 0x07, 0x01}}};
+static const in6_addr kIPv4MappedPublicAddr = {{{0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xff, 0xff,
+ 0x01, 0x02, 0x03, 0x04}}};
+static const in6_addr kIPv6AllNodes = {{{0xff, 0x02, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x01}}};
+
+static const std::string kIPv4AnyAddrString = "0.0.0.0";
+static const std::string kIPv4LoopbackAddrString = "127.0.0.1";
+static const std::string kIPv4RFC1918AddrString = "192.168.7.1";
+static const std::string kIPv4PublicAddrString = "1.2.3.4";
+static const std::string kIPv6AnyAddrString = "::";
+static const std::string kIPv6LoopbackAddrString = "::1";
+static const std::string kIPv6LinkLocalAddrString = "fe80::be30:5bff:fee5:c3";
+static const std::string kIPv6PublicAddrString =
+ "2401:fa00:4:1000:be30:5bff:fee5:c3";
+static const std::string kIPv4MappedAnyAddrString = "::ffff:0:0";
+static const std::string kIPv4MappedRFC1918AddrString = "::ffff:c0a8:701";
+static const std::string kIPv4MappedLoopbackAddrString = "::ffff:7f00:1";
+static const std::string kIPv4MappedPublicAddrString = "::ffff:102:0304";
+static const std::string kIPv4MappedV4StyleAddrString = "::ffff:192.168.7.1";
+
+static const std::string kIPv4BrokenString1 = "192.168.7.";
+static const std::string kIPv4BrokenString2 = "192.168.7.1.1";
+static const std::string kIPv4BrokenString3 = "192.168.7.1:80";
+static const std::string kIPv4BrokenString4 = "192.168.7.ONE";
+static const std::string kIPv4BrokenString5 = "-192.168.7.1";
+static const std::string kIPv4BrokenString6 = "256.168.7.1";
+static const std::string kIPv6BrokenString1 = "2401:fa00:4:1000:be30";
+static const std::string kIPv6BrokenString2 =
+ "2401:fa00:4:1000:be30:5bff:fee5:c3:1";
+static const std::string kIPv6BrokenString3 =
+ "[2401:fa00:4:1000:be30:5bff:fee5:c3]:1";
+static const std::string kIPv6BrokenString4 =
+ "2401::4::be30";
+static const std::string kIPv6BrokenString5 =
+ "2401:::4:fee5:be30";
+static const std::string kIPv6BrokenString6 =
+ "2401f:fa00:4:1000:be30:5bff:fee5:c3";
+static const std::string kIPv6BrokenString7 =
+ "2401:ga00:4:1000:be30:5bff:fee5:c3";
+static const std::string kIPv6BrokenString8 =
+ "2401:fa000:4:1000:be30:5bff:fee5:c3";
+static const std::string kIPv6BrokenString9 =
+ "2401:fal0:4:1000:be30:5bff:fee5:c3";
+static const std::string kIPv6BrokenString10 =
+ "::ffff:192.168.7.";
+static const std::string kIPv6BrokenString11 =
+ "::ffff:192.168.7.1.1.1";
+static const std::string kIPv6BrokenString12 =
+ "::fffe:192.168.7.1";
+static const std::string kIPv6BrokenString13 =
+ "::ffff:192.168.7.ff";
+static const std::string kIPv6BrokenString14 =
+ "0x2401:fa00:4:1000:be30:5bff:fee5:c3";
+
+bool IPFromHostEntWorks(const std::string& name, int expected_family,
+ IPAddress expected_addr) {
+ struct hostent* ent = gethostbyname(name.c_str());
+ if (ent) {
+ IPAddress addr;
+ if (!IPFromHostEnt(ent, &addr)) {
+ return false;
+ }
+ return addr == expected_addr;
+ }
+ return true;
+}
+
+bool AreEqual(const IPAddress& addr,
+ const IPAddress& addr2) {
+ if ((IPIsAny(addr) != IPIsAny(addr2)) ||
+ (IPIsLoopback(addr) != IPIsLoopback(addr2)) ||
+ (IPIsPrivate(addr) != IPIsPrivate(addr2)) ||
+ (HashIP(addr) != HashIP(addr2)) ||
+ (addr.Size() != addr2.Size()) ||
+ (addr.family() != addr2.family()) ||
+ (addr.ToString() != addr2.ToString())) {
+ return false;
+ }
+ in_addr v4addr, v4addr2;
+ v4addr = addr.ipv4_address();
+ v4addr2 = addr2.ipv4_address();
+ if (0 != memcmp(&v4addr, &v4addr2, sizeof(v4addr))) {
+ return false;
+ }
+ in6_addr v6addr, v6addr2;
+ v6addr = addr.ipv6_address();
+ v6addr2 = addr2.ipv6_address();
+ if (0 != memcmp(&v6addr, &v6addr2, sizeof(v6addr))) {
+ return false;
+ }
+ return true;
+}
+
+bool BrokenIPStringFails(const std::string& broken) {
+ IPAddress addr(0); // Intentionally make it v4.
+ if (IPFromString(kIPv4BrokenString1, &addr)) {
+ return false;
+ }
+ return addr.family() == AF_UNSPEC;
+}
+
+bool CheckMaskCount(const std::string& mask, int expected_length) {
+ IPAddress addr;
+ return IPFromString(mask, &addr) &&
+ (expected_length == CountIPMaskBits(addr));
+}
+
+bool CheckTruncateIP(const std::string& initial, int truncate_length,
+ const std::string& expected_result) {
+ IPAddress addr, expected;
+ IPFromString(initial, &addr);
+ IPFromString(expected_result, &expected);
+ IPAddress truncated = TruncateIP(addr, truncate_length);
+ return truncated == expected;
+}
+
+TEST(IPAddressTest, TestDefaultCtor) {
+ IPAddress addr;
+ EXPECT_FALSE(IPIsAny(addr));
+ EXPECT_FALSE(IPIsLoopback(addr));
+ EXPECT_FALSE(IPIsPrivate(addr));
+
+ EXPECT_EQ(0U, addr.Size());
+ EXPECT_EQ(AF_UNSPEC, addr.family());
+ EXPECT_EQ("", addr.ToString());
+}
+
+TEST(IPAddressTest, TestInAddrCtor) {
+ in_addr v4addr;
+
+ // Test V4 Any address.
+ v4addr.s_addr = INADDR_ANY;
+ IPAddress addr(v4addr);
+ EXPECT_TRUE(IPIsAny(addr));
+ EXPECT_FALSE(IPIsLoopback(addr));
+ EXPECT_FALSE(IPIsPrivate(addr));
+ EXPECT_EQ(kIPv4AddrSize, addr.Size());
+ EXPECT_EQ(kIPv4AnyAddrString, addr.ToString());
+
+ // Test a V4 loopback address.
+ v4addr.s_addr = htonl(INADDR_LOOPBACK);
+ addr = IPAddress(v4addr);
+ EXPECT_FALSE(IPIsAny(addr));
+ EXPECT_TRUE(IPIsLoopback(addr));
+ EXPECT_TRUE(IPIsPrivate(addr));
+ EXPECT_EQ(kIPv4AddrSize, addr.Size());
+ EXPECT_EQ(kIPv4LoopbackAddrString, addr.ToString());
+
+ // Test an RFC1918 address.
+ v4addr.s_addr = htonl(kIPv4RFC1918Addr);
+ addr = IPAddress(v4addr);
+ EXPECT_FALSE(IPIsAny(addr));
+ EXPECT_FALSE(IPIsLoopback(addr));
+ EXPECT_TRUE(IPIsPrivate(addr));
+ EXPECT_EQ(kIPv4AddrSize, addr.Size());
+ EXPECT_EQ(kIPv4RFC1918AddrString, addr.ToString());
+
+ // Test a 'normal' v4 address.
+ v4addr.s_addr = htonl(kIPv4PublicAddr);
+ addr = IPAddress(v4addr);
+ EXPECT_FALSE(IPIsAny(addr));
+ EXPECT_FALSE(IPIsLoopback(addr));
+ EXPECT_FALSE(IPIsPrivate(addr));
+ EXPECT_EQ(kIPv4AddrSize, addr.Size());
+ EXPECT_EQ(kIPv4PublicAddrString, addr.ToString());
+}
+
+TEST(IPAddressTest, TestInAddr6Ctor) {
+ // Test v6 empty.
+ IPAddress addr(in6addr_any);
+ EXPECT_TRUE(IPIsAny(addr));
+ EXPECT_FALSE(IPIsLoopback(addr));
+ EXPECT_FALSE(IPIsPrivate(addr));
+ EXPECT_EQ(kIPv6AddrSize, addr.Size());
+ EXPECT_EQ(kIPv6AnyAddrString, addr.ToString());
+
+ // Test v6 loopback.
+ addr = IPAddress(in6addr_loopback);
+ EXPECT_FALSE(IPIsAny(addr));
+ EXPECT_TRUE(IPIsLoopback(addr));
+ EXPECT_TRUE(IPIsPrivate(addr));
+ EXPECT_EQ(kIPv6AddrSize, addr.Size());
+ EXPECT_EQ(kIPv6LoopbackAddrString, addr.ToString());
+
+ // Test v6 link-local.
+ addr = IPAddress(kIPv6LinkLocalAddr);
+ EXPECT_FALSE(IPIsAny(addr));
+ EXPECT_FALSE(IPIsLoopback(addr));
+ EXPECT_TRUE(IPIsPrivate(addr));
+ EXPECT_EQ(kIPv6AddrSize, addr.Size());
+ EXPECT_EQ(kIPv6LinkLocalAddrString, addr.ToString());
+
+ // Test v6 global address.
+ addr = IPAddress(kIPv6PublicAddr);
+ EXPECT_FALSE(IPIsAny(addr));
+ EXPECT_FALSE(IPIsLoopback(addr));
+ EXPECT_FALSE(IPIsPrivate(addr));
+ EXPECT_EQ(kIPv6AddrSize, addr.Size());
+ EXPECT_EQ(kIPv6PublicAddrString, addr.ToString());
+}
+
+TEST(IPAddressTest, TestUint32Ctor) {
+ // Test V4 Any address.
+ IPAddress addr(0);
+ EXPECT_TRUE(IPIsAny(addr));
+ EXPECT_FALSE(IPIsLoopback(addr));
+ EXPECT_FALSE(IPIsPrivate(addr));
+ EXPECT_EQ(kIPv4AddrSize, addr.Size());
+ EXPECT_EQ(kIPv4AnyAddrString, addr.ToString());
+
+ // Test a V4 loopback address.
+ addr = IPAddress(INADDR_LOOPBACK);
+ EXPECT_FALSE(IPIsAny(addr));
+ EXPECT_TRUE(IPIsLoopback(addr));
+ EXPECT_TRUE(IPIsPrivate(addr));
+ EXPECT_EQ(kIPv4AddrSize, addr.Size());
+ EXPECT_EQ(kIPv4LoopbackAddrString, addr.ToString());
+
+ // Test an RFC1918 address.
+ addr = IPAddress(kIPv4RFC1918Addr);
+ EXPECT_FALSE(IPIsAny(addr));
+ EXPECT_FALSE(IPIsLoopback(addr));
+ EXPECT_TRUE(IPIsPrivate(addr));
+ EXPECT_EQ(kIPv4AddrSize, addr.Size());
+ EXPECT_EQ(kIPv4RFC1918AddrString, addr.ToString());
+
+ // Test a 'normal' v4 address.
+ addr = IPAddress(kIPv4PublicAddr);
+ EXPECT_FALSE(IPIsAny(addr));
+ EXPECT_FALSE(IPIsLoopback(addr));
+ EXPECT_FALSE(IPIsPrivate(addr));
+ EXPECT_EQ(kIPv4AddrSize, addr.Size());
+ EXPECT_EQ(kIPv4PublicAddrString, addr.ToString());
+}
+
+TEST(IPAddressTest, TestHostEntCtor) {
+ IPAddress addr(INADDR_LOOPBACK);
+ EXPECT_PRED3(IPFromHostEntWorks, "localhost", AF_INET, addr);
+
+ addr = IPAddress(kIPv6AllNodes);
+ EXPECT_PRED3(IPFromHostEntWorks, "ip6-allnodes", AF_INET6, addr);
+
+ // gethostbyname works for literal addresses too
+ addr = IPAddress(INADDR_ANY);
+ EXPECT_PRED3(IPFromHostEntWorks,
+ kIPv4AnyAddrString, AF_INET, addr);
+ addr = IPAddress(kIPv4RFC1918Addr);
+ EXPECT_PRED3(IPFromHostEntWorks,
+ kIPv4RFC1918AddrString, AF_INET, addr);
+ addr = IPAddress(kIPv4PublicAddr);
+ EXPECT_PRED3(IPFromHostEntWorks,
+ kIPv4PublicAddrString, AF_INET, addr);
+
+ addr = IPAddress(in6addr_any);
+ EXPECT_PRED3(IPFromHostEntWorks,
+ kIPv6AnyAddrString, AF_INET6, addr);
+ addr = IPAddress(in6addr_loopback);
+ EXPECT_PRED3(IPFromHostEntWorks,
+ kIPv6LoopbackAddrString, AF_INET6, addr);
+ addr = IPAddress(kIPv6LinkLocalAddr);
+ EXPECT_PRED3(IPFromHostEntWorks,
+ kIPv6LinkLocalAddrString, AF_INET6, addr);
+ addr = IPAddress(kIPv6PublicAddr);
+ EXPECT_PRED3(IPFromHostEntWorks,
+ kIPv6PublicAddrString, AF_INET6, addr);
+}
+
+TEST(IPAddressTest, TestCopyCtor) {
+ in_addr v4addr;
+ v4addr.s_addr = htonl(kIPv4PublicAddr);
+ IPAddress addr(v4addr);
+ IPAddress addr2(addr);
+
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr = IPAddress(INADDR_ANY);
+ addr2 = IPAddress(addr);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr = IPAddress(INADDR_LOOPBACK);
+ addr2 = IPAddress(addr);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr = IPAddress(kIPv4PublicAddr);
+ addr2 = IPAddress(addr);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr = IPAddress(kIPv4RFC1918Addr);
+ addr2 = IPAddress(addr);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr = IPAddress(in6addr_any);
+ addr2 = IPAddress(addr);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr = IPAddress(in6addr_loopback);
+ addr2 = IPAddress(addr);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr = IPAddress(kIPv6LinkLocalAddr);
+ addr2 = IPAddress(addr);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr = IPAddress(kIPv6PublicAddr);
+ addr2 = IPAddress(addr);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+}
+
+TEST(IPAddressTest, TestEquality) {
+ // Check v4 equality
+ in_addr v4addr, v4addr2;
+ v4addr.s_addr = htonl(kIPv4PublicAddr);
+ v4addr2.s_addr = htonl(kIPv4PublicAddr + 1);
+ IPAddress addr(v4addr);
+ IPAddress addr2(v4addr2);
+ IPAddress addr3(v4addr);
+
+ EXPECT_TRUE(addr == addr);
+ EXPECT_TRUE(addr2 == addr2);
+ EXPECT_TRUE(addr3 == addr3);
+ EXPECT_TRUE(addr == addr3);
+ EXPECT_TRUE(addr3 == addr);
+ EXPECT_FALSE(addr2 == addr);
+ EXPECT_FALSE(addr2 == addr3);
+ EXPECT_FALSE(addr == addr2);
+ EXPECT_FALSE(addr3 == addr2);
+
+ // Check v6 equality
+ IPAddress addr4(kIPv6PublicAddr);
+ IPAddress addr5(kIPv6LinkLocalAddr);
+ IPAddress addr6(kIPv6PublicAddr);
+
+ EXPECT_TRUE(addr4 == addr4);
+ EXPECT_TRUE(addr5 == addr5);
+ EXPECT_TRUE(addr4 == addr6);
+ EXPECT_TRUE(addr6 == addr4);
+ EXPECT_FALSE(addr4 == addr5);
+ EXPECT_FALSE(addr5 == addr4);
+ EXPECT_FALSE(addr6 == addr5);
+ EXPECT_FALSE(addr5 == addr6);
+
+ // Check v4/v6 cross-equality
+ EXPECT_FALSE(addr == addr4);
+ EXPECT_FALSE(addr == addr5);
+ EXPECT_FALSE(addr == addr6);
+ EXPECT_FALSE(addr4 == addr);
+ EXPECT_FALSE(addr5 == addr);
+ EXPECT_FALSE(addr6 == addr);
+ EXPECT_FALSE(addr2 == addr4);
+ EXPECT_FALSE(addr2 == addr5);
+ EXPECT_FALSE(addr2 == addr6);
+ EXPECT_FALSE(addr4 == addr2);
+ EXPECT_FALSE(addr5 == addr2);
+ EXPECT_FALSE(addr6 == addr2);
+ EXPECT_FALSE(addr3 == addr4);
+ EXPECT_FALSE(addr3 == addr5);
+ EXPECT_FALSE(addr3 == addr6);
+ EXPECT_FALSE(addr4 == addr3);
+ EXPECT_FALSE(addr5 == addr3);
+ EXPECT_FALSE(addr6 == addr3);
+
+ // Special cases: loopback and any.
+ // They're special but they're still not equal.
+ IPAddress v4loopback(htonl(INADDR_LOOPBACK));
+ IPAddress v6loopback(in6addr_loopback);
+ EXPECT_FALSE(v4loopback == v6loopback);
+
+ IPAddress v4any(0);
+ IPAddress v6any(in6addr_any);
+ EXPECT_FALSE(v4any == v6any);
+}
+
+TEST(IPAddressTest, TestComparison) {
+ // Defined in 'ascending' order.
+ // v6 > v4, and intra-family sorting is purely numerical
+ IPAddress addr0; // AF_UNSPEC
+ IPAddress addr1(INADDR_ANY); // 0.0.0.0
+ IPAddress addr2(kIPv4PublicAddr); // 1.2.3.4
+ IPAddress addr3(INADDR_LOOPBACK); // 127.0.0.1
+ IPAddress addr4(kIPv4RFC1918Addr); // 192.168.7.1.
+ IPAddress addr5(in6addr_any); // ::
+ IPAddress addr6(in6addr_loopback); // ::1
+ IPAddress addr7(kIPv6PublicAddr); // 2401....
+ IPAddress addr8(kIPv6LinkLocalAddr); // fe80....
+
+ EXPECT_TRUE(addr0 < addr1);
+ EXPECT_TRUE(addr1 < addr2);
+ EXPECT_TRUE(addr2 < addr3);
+ EXPECT_TRUE(addr3 < addr4);
+ EXPECT_TRUE(addr4 < addr5);
+ EXPECT_TRUE(addr5 < addr6);
+ EXPECT_TRUE(addr6 < addr7);
+ EXPECT_TRUE(addr7 < addr8);
+
+ EXPECT_FALSE(addr0 > addr1);
+ EXPECT_FALSE(addr1 > addr2);
+ EXPECT_FALSE(addr2 > addr3);
+ EXPECT_FALSE(addr3 > addr4);
+ EXPECT_FALSE(addr4 > addr5);
+ EXPECT_FALSE(addr5 > addr6);
+ EXPECT_FALSE(addr6 > addr7);
+ EXPECT_FALSE(addr7 > addr8);
+
+ EXPECT_FALSE(addr0 > addr0);
+ EXPECT_FALSE(addr1 > addr1);
+ EXPECT_FALSE(addr2 > addr2);
+ EXPECT_FALSE(addr3 > addr3);
+ EXPECT_FALSE(addr4 > addr4);
+ EXPECT_FALSE(addr5 > addr5);
+ EXPECT_FALSE(addr6 > addr6);
+ EXPECT_FALSE(addr7 > addr7);
+ EXPECT_FALSE(addr8 > addr8);
+
+ EXPECT_FALSE(addr0 < addr0);
+ EXPECT_FALSE(addr1 < addr1);
+ EXPECT_FALSE(addr2 < addr2);
+ EXPECT_FALSE(addr3 < addr3);
+ EXPECT_FALSE(addr4 < addr4);
+ EXPECT_FALSE(addr5 < addr5);
+ EXPECT_FALSE(addr6 < addr6);
+ EXPECT_FALSE(addr7 < addr7);
+ EXPECT_FALSE(addr8 < addr8);
+}
+
+TEST(IPAddressTest, TestFromString) {
+ IPAddress addr;
+ IPAddress addr2;
+ addr2 = IPAddress(INADDR_ANY);
+
+ EXPECT_TRUE(IPFromString(kIPv4AnyAddrString, &addr));
+ EXPECT_EQ(addr.ToString(), kIPv4AnyAddrString);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr2 = IPAddress(INADDR_LOOPBACK);
+ EXPECT_TRUE(IPFromString(kIPv4LoopbackAddrString, &addr));
+ EXPECT_EQ(addr.ToString(), kIPv4LoopbackAddrString);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr2 = IPAddress(kIPv4RFC1918Addr);
+ EXPECT_TRUE(IPFromString(kIPv4RFC1918AddrString, &addr));
+ EXPECT_EQ(addr.ToString(), kIPv4RFC1918AddrString);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr2 = IPAddress(kIPv4PublicAddr);
+ EXPECT_TRUE(IPFromString(kIPv4PublicAddrString, &addr));
+ EXPECT_EQ(addr.ToString(), kIPv4PublicAddrString);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr2 = IPAddress(in6addr_any);
+ EXPECT_TRUE(IPFromString(kIPv6AnyAddrString, &addr));
+ EXPECT_EQ(addr.ToString(), kIPv6AnyAddrString);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr2 = IPAddress(in6addr_loopback);
+ EXPECT_TRUE(IPFromString(kIPv6LoopbackAddrString, &addr));
+ EXPECT_EQ(addr.ToString(), kIPv6LoopbackAddrString);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr2 = IPAddress(kIPv6LinkLocalAddr);
+ EXPECT_TRUE(IPFromString(kIPv6LinkLocalAddrString, &addr));
+ EXPECT_EQ(addr.ToString(), kIPv6LinkLocalAddrString);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr2 = IPAddress(kIPv6PublicAddr);
+ EXPECT_TRUE(IPFromString(kIPv6PublicAddrString, &addr));
+ EXPECT_EQ(addr.ToString(), kIPv6PublicAddrString);
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ addr2 = IPAddress(kIPv4MappedRFC1918Addr);
+ EXPECT_TRUE(IPFromString(kIPv4MappedV4StyleAddrString, &addr));
+ EXPECT_PRED2(AreEqual, addr, addr2);
+
+ // Broken cases, should set addr to AF_UNSPEC.
+ EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString1);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString2);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString3);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString4);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString5);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString6);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString1);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString2);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString3);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString4);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString5);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString6);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString7);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString8);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString9);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString10);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString11);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString12);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString13);
+ EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString14);
+}
+
+TEST(IPAddressTest, TestIsPrivate) {
+ EXPECT_FALSE(IPIsPrivate(IPAddress(INADDR_ANY)));
+ EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv4PublicAddr)));
+ EXPECT_FALSE(IPIsPrivate(IPAddress(in6addr_any)));
+ EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv6PublicAddr)));
+ EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv4MappedAnyAddr)));
+ EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv4MappedPublicAddr)));
+
+ EXPECT_TRUE(IPIsPrivate(IPAddress(kIPv4RFC1918Addr)));
+ EXPECT_TRUE(IPIsPrivate(IPAddress(INADDR_LOOPBACK)));
+ EXPECT_TRUE(IPIsPrivate(IPAddress(in6addr_loopback)));
+ EXPECT_TRUE(IPIsPrivate(IPAddress(kIPv6LinkLocalAddr)));
+}
+
+TEST(IPAddressTest, TestIsLoopback) {
+ EXPECT_FALSE(IPIsLoopback(IPAddress(INADDR_ANY)));
+ EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4PublicAddr)));
+ EXPECT_FALSE(IPIsLoopback(IPAddress(in6addr_any)));
+ EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv6PublicAddr)));
+ EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4MappedAnyAddr)));
+ EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4MappedPublicAddr)));
+
+ EXPECT_TRUE(IPIsLoopback(IPAddress(INADDR_LOOPBACK)));
+ EXPECT_TRUE(IPIsLoopback(IPAddress(in6addr_loopback)));
+}
+
+TEST(IPAddressTest, TestNormalized) {
+ // Check normalizing a ::ffff:a.b.c.d address.
+ IPAddress addr;
+ EXPECT_TRUE(IPFromString(kIPv4MappedV4StyleAddrString, &addr));
+ IPAddress addr2(kIPv4RFC1918Addr);
+ addr = addr.Normalized();
+ EXPECT_EQ(addr2, addr);
+
+ // Check normalizing a ::ffff:aabb:ccdd address.
+ addr = IPAddress(kIPv4MappedPublicAddr);
+ addr2 = IPAddress(kIPv4PublicAddr);
+ addr = addr.Normalized();
+ EXPECT_EQ(addr, addr2);
+
+ // Check that a non-mapped v6 addresses isn't altered.
+ addr = IPAddress(kIPv6PublicAddr);
+ addr2 = IPAddress(kIPv6PublicAddr);
+ addr = addr.Normalized();
+ EXPECT_EQ(addr, addr2);
+
+ // Check that addresses that look a bit like mapped addresses aren't altered
+ EXPECT_TRUE(IPFromString("fe80::ffff:0102:0304", &addr));
+ addr2 = addr;
+ addr = addr.Normalized();
+ EXPECT_EQ(addr, addr2);
+ EXPECT_TRUE(IPFromString("::0102:0304", &addr));
+ addr2 = addr;
+ addr = addr.Normalized();
+ EXPECT_EQ(addr, addr2);
+ // This string should 'work' as an IP address but is not a mapped address,
+ // so it shouldn't change on normalization.
+ EXPECT_TRUE(IPFromString("::192.168.7.1", &addr));
+ addr2 = addr;
+ addr = addr.Normalized();
+ EXPECT_EQ(addr, addr2);
+
+ // Check that v4 addresses aren't altered.
+ addr = IPAddress(htonl(kIPv4PublicAddr));
+ addr2 = IPAddress(htonl(kIPv4PublicAddr));
+ addr = addr.Normalized();
+ EXPECT_EQ(addr, addr2);
+}
+
+TEST(IPAddressTest, TestAsIPv6Address) {
+ IPAddress addr(kIPv4PublicAddr);
+ IPAddress addr2(kIPv4MappedPublicAddr);
+ addr = addr.AsIPv6Address();
+ EXPECT_EQ(addr, addr2);
+
+ addr = IPAddress(kIPv4MappedPublicAddr);
+ addr2 = IPAddress(kIPv4MappedPublicAddr);
+ addr = addr.AsIPv6Address();
+ EXPECT_EQ(addr, addr2);
+
+ addr = IPAddress(kIPv6PublicAddr);
+ addr2 = IPAddress(kIPv6PublicAddr);
+ addr = addr.AsIPv6Address();
+ EXPECT_EQ(addr, addr2);
+}
+
+TEST(IPAddressTest, TestCountIPMaskBits) {
+ IPAddress mask;
+ // IPv4 on byte boundaries
+ EXPECT_PRED2(CheckMaskCount, "255.255.255.255", 32);
+ EXPECT_PRED2(CheckMaskCount, "255.255.255.0", 24);
+ EXPECT_PRED2(CheckMaskCount, "255.255.0.0", 16);
+ EXPECT_PRED2(CheckMaskCount, "255.0.0.0", 8);
+ EXPECT_PRED2(CheckMaskCount, "0.0.0.0", 0);
+
+ // IPv4 not on byte boundaries
+ EXPECT_PRED2(CheckMaskCount, "128.0.0.0", 1);
+ EXPECT_PRED2(CheckMaskCount, "224.0.0.0", 3);
+ EXPECT_PRED2(CheckMaskCount, "255.248.0.0", 13);
+ EXPECT_PRED2(CheckMaskCount, "255.255.224.0", 19);
+ EXPECT_PRED2(CheckMaskCount, "255.255.255.252", 30);
+
+ // V6 on byte boundaries
+ EXPECT_PRED2(CheckMaskCount, "::", 0);
+ EXPECT_PRED2(CheckMaskCount, "ff00::", 8);
+ EXPECT_PRED2(CheckMaskCount, "ffff::", 16);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ff00::", 24);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff::", 32);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ff00::", 40);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff::", 48);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ff00::", 56);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff::", 64);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ff00::", 72);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff::", 80);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ff00::", 88);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff::", 96);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ff00:0000", 104);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:0000", 112);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff00", 120);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 128);
+
+ // V6 not on byte boundaries.
+ EXPECT_PRED2(CheckMaskCount, "8000::", 1);
+ EXPECT_PRED2(CheckMaskCount, "ff80::", 9);
+ EXPECT_PRED2(CheckMaskCount, "ffff:fe00::", 23);
+ EXPECT_PRED2(CheckMaskCount, "ffff:fffe::", 31);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:e000::", 35);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffe0::", 43);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:f800::", 53);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:fff8::", 61);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:fc00::", 70);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:fffc::", 78);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:8000::", 81);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ff80::", 89);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:fe00::", 103);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:fffe:0000", 111);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fc00", 118);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffc", 126);
+
+ // Non-contiguous ranges. These are kind-of invalid but lets test them
+ // to make sure they don't crash anything or infinite loop or something.
+ EXPECT_PRED2(CheckMaskCount, "217.0.0.0", 2);
+ EXPECT_PRED2(CheckMaskCount, "255.185.0.0", 9);
+ EXPECT_PRED2(CheckMaskCount, "255.255.251.0", 21);
+ EXPECT_PRED2(CheckMaskCount, "255.255.251.255", 21);
+ EXPECT_PRED2(CheckMaskCount, "255.255.254.201", 23);
+ EXPECT_PRED2(CheckMaskCount, "::1", 0);
+ EXPECT_PRED2(CheckMaskCount, "fe80::1", 7);
+ EXPECT_PRED2(CheckMaskCount, "ff80::1", 9);
+ EXPECT_PRED2(CheckMaskCount, "ffff::1", 16);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ff00:1::1", 24);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff::ffff:1", 32);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ff00:1::", 40);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff::ff00", 48);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ff00:1234::", 56);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:0012::ffff", 64);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ff01::", 72);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:7f00::", 80);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ff7a::", 88);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:7f00:0000", 96);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ff70:0000", 104);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:0211", 112);
+ EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff7f", 120);
+}
+
+TEST(IPAddressTest, TestTruncateIP) {
+ EXPECT_PRED3(CheckTruncateIP, "255.255.255.255", 24, "255.255.255.0");
+ EXPECT_PRED3(CheckTruncateIP, "255.255.255.255", 16, "255.255.0.0");
+ EXPECT_PRED3(CheckTruncateIP, "255.255.255.255", 8, "255.0.0.0");
+ EXPECT_PRED3(CheckTruncateIP, "202.67.7.255", 24, "202.67.7.0");
+ EXPECT_PRED3(CheckTruncateIP, "202.129.65.205", 16, "202.129.0.0");
+ EXPECT_PRED3(CheckTruncateIP, "55.25.2.77", 8, "55.0.0.0");
+ EXPECT_PRED3(CheckTruncateIP, "74.128.99.254", 1, "0.0.0.0");
+ EXPECT_PRED3(CheckTruncateIP, "106.55.99.254", 3, "96.0.0.0");
+ EXPECT_PRED3(CheckTruncateIP, "172.167.53.222", 13, "172.160.0.0");
+ EXPECT_PRED3(CheckTruncateIP, "255.255.224.0", 18, "255.255.192.0");
+ EXPECT_PRED3(CheckTruncateIP, "255.255.255.252", 28, "255.255.255.240");
+
+ EXPECT_PRED3(CheckTruncateIP, "fe80:1111:2222:3333:4444:5555:6666:7777", 1,
+ "8000::");
+ EXPECT_PRED3(CheckTruncateIP, "fff0:1111:2222:3333:4444:5555:6666:7777", 9,
+ "ff80::");
+ EXPECT_PRED3(CheckTruncateIP, "ffff:ff80:1111:2222:3333:4444:5555:6666", 23,
+ "ffff:fe00::");
+ EXPECT_PRED3(CheckTruncateIP, "2400:f9af:e456:1111:2222:3333:4444:5555", 35,
+ "2400:f9af:e000::");
+ EXPECT_PRED3(CheckTruncateIP, "9999:1111:2233:4444:5555:6666:7777:8888", 53,
+ "9999:1111:2233:4000::");
+ EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 68,
+ "1111:2222:3333:4444:5000::");
+ EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 92,
+ "1111:2222:3333:4444:5555:6660::");
+ EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 105,
+ "1111:2222:3333:4444:5555:6666:7700::");
+ EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 124,
+ "1111:2222:3333:4444:5555:6666:7777:8880");
+
+ // Slightly degenerate cases
+ EXPECT_PRED3(CheckTruncateIP, "202.165.33.127", 32, "202.165.33.127");
+ EXPECT_PRED3(CheckTruncateIP, "235.105.77.12", 0, "0.0.0.0");
+ EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 128,
+ "1111:2222:3333:4444:5555:6666:7777:8888");
+ EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 0,
+ "::");
+}
+} // namespace talk_base
diff --git a/talk/base/json_unittest.cc b/talk/base/json_unittest.cc
new file mode 100644
index 0000000..a39b944
--- /dev/null
+++ b/talk/base/json_unittest.cc
@@ -0,0 +1,205 @@
+/*
+ * libjingle
+ * Copyright 2009, 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 <vector>
+#include "talk/base/gunit.h"
+#include "talk/base/json.h"
+
+static Json::Value in_s("foo");
+static Json::Value in_sn("99");
+static Json::Value in_si("-99");
+static Json::Value in_sb("true");
+static Json::Value in_sd("1.2");
+static Json::Value in_n(12);
+static Json::Value in_i(-12);
+static Json::Value in_u(34U);
+static Json::Value in_b(true);
+static Json::Value in_d(1.2);
+static Json::Value big_sn("12345678901234567890");
+static Json::Value big_si("-12345678901234567890");
+static Json::Value big_u(0xFFFFFFFF);
+static Json::Value bad_a(Json::arrayValue);
+static Json::Value bad_o(Json::objectValue);
+
+TEST(JsonTest, GetString) {
+ std::string out;
+ EXPECT_TRUE(GetStringFromJson(in_s, &out));
+ EXPECT_EQ("foo", out);
+ EXPECT_TRUE(GetStringFromJson(in_sn, &out));
+ EXPECT_EQ("99", out);
+ EXPECT_TRUE(GetStringFromJson(in_si, &out));
+ EXPECT_EQ("-99", out);
+ EXPECT_TRUE(GetStringFromJson(in_i, &out));
+ EXPECT_EQ("-12", out);
+ EXPECT_TRUE(GetStringFromJson(in_n, &out));
+ EXPECT_EQ("12", out);
+ EXPECT_TRUE(GetStringFromJson(in_u, &out));
+ EXPECT_EQ("34", out);
+ EXPECT_TRUE(GetStringFromJson(in_b, &out));
+ EXPECT_EQ("true", out);
+ // Not supported here yet.
+ EXPECT_FALSE(GetStringFromJson(bad_a, &out));
+ EXPECT_FALSE(GetStringFromJson(bad_o, &out));
+}
+
+TEST(JsonTest, GetInt) {
+ int out;
+ EXPECT_TRUE(GetIntFromJson(in_sn, &out));
+ EXPECT_EQ(99, out);
+ EXPECT_TRUE(GetIntFromJson(in_si, &out));
+ EXPECT_EQ(-99, out);
+ EXPECT_TRUE(GetIntFromJson(in_n, &out));
+ EXPECT_EQ(12, out);
+ EXPECT_TRUE(GetIntFromJson(in_i, &out));
+ EXPECT_EQ(-12, out);
+ EXPECT_TRUE(GetIntFromJson(in_u, &out));
+ EXPECT_EQ(34, out);
+ EXPECT_TRUE(GetIntFromJson(in_b, &out));
+ EXPECT_EQ(1, out);
+ EXPECT_FALSE(GetIntFromJson(in_s, &out));
+ EXPECT_FALSE(GetIntFromJson(big_sn, &out));
+ EXPECT_FALSE(GetIntFromJson(big_si, &out));
+ EXPECT_FALSE(GetIntFromJson(big_u, &out));
+ EXPECT_FALSE(GetIntFromJson(bad_a, &out));
+ EXPECT_FALSE(GetIntFromJson(bad_o, &out));
+}
+
+TEST(JsonTest, GetUInt) {
+ unsigned int out;
+ EXPECT_TRUE(GetUIntFromJson(in_sn, &out));
+ EXPECT_EQ(99U, out);
+ EXPECT_TRUE(GetUIntFromJson(in_n, &out));
+ EXPECT_EQ(12U, out);
+ EXPECT_TRUE(GetUIntFromJson(in_u, &out));
+ EXPECT_EQ(34U, out);
+ EXPECT_TRUE(GetUIntFromJson(in_b, &out));
+ EXPECT_EQ(1U, out);
+ EXPECT_TRUE(GetUIntFromJson(big_u, &out));
+ EXPECT_EQ(0xFFFFFFFFU, out);
+ EXPECT_FALSE(GetUIntFromJson(in_s, &out));
+ // TODO: Fail reading negative strings.
+ // EXPECT_FALSE(GetUIntFromJson(in_si, &out));
+ EXPECT_FALSE(GetUIntFromJson(in_i, &out));
+ EXPECT_FALSE(GetUIntFromJson(big_sn, &out));
+ EXPECT_FALSE(GetUIntFromJson(big_si, &out));
+ EXPECT_FALSE(GetUIntFromJson(bad_a, &out));
+ EXPECT_FALSE(GetUIntFromJson(bad_o, &out));
+}
+
+TEST(JsonTest, GetBool) {
+ bool out;
+ EXPECT_TRUE(GetBoolFromJson(in_sb, &out));
+ EXPECT_EQ(true, out);
+ EXPECT_TRUE(GetBoolFromJson(in_n, &out));
+ EXPECT_EQ(true, out);
+ EXPECT_TRUE(GetBoolFromJson(in_i, &out));
+ EXPECT_EQ(true, out);
+ EXPECT_TRUE(GetBoolFromJson(in_u, &out));
+ EXPECT_EQ(true, out);
+ EXPECT_TRUE(GetBoolFromJson(in_b, &out));
+ EXPECT_EQ(true, out);
+ EXPECT_TRUE(GetBoolFromJson(big_u, &out));
+ EXPECT_EQ(true, out);
+ EXPECT_FALSE(GetBoolFromJson(in_s, &out));
+ EXPECT_FALSE(GetBoolFromJson(in_sn, &out));
+ EXPECT_FALSE(GetBoolFromJson(in_si, &out));
+ EXPECT_FALSE(GetBoolFromJson(big_sn, &out));
+ EXPECT_FALSE(GetBoolFromJson(big_si, &out));
+ EXPECT_FALSE(GetBoolFromJson(bad_a, &out));
+ EXPECT_FALSE(GetBoolFromJson(bad_o, &out));
+}
+
+TEST(JsonTest, GetDouble) {
+ double out;
+ EXPECT_TRUE(GetDoubleFromJson(in_sn, &out));
+ EXPECT_EQ(99, out);
+ EXPECT_TRUE(GetDoubleFromJson(in_si, &out));
+ EXPECT_EQ(-99, out);
+ EXPECT_TRUE(GetDoubleFromJson(in_sd, &out));
+ EXPECT_EQ(1.2, out);
+ EXPECT_TRUE(GetDoubleFromJson(in_n, &out));
+ EXPECT_EQ(12, out);
+ EXPECT_TRUE(GetDoubleFromJson(in_i, &out));
+ EXPECT_EQ(-12, out);
+ EXPECT_TRUE(GetDoubleFromJson(in_u, &out));
+ EXPECT_EQ(34, out);
+ EXPECT_TRUE(GetDoubleFromJson(in_b, &out));
+ EXPECT_EQ(1, out);
+ EXPECT_TRUE(GetDoubleFromJson(in_d, &out));
+ EXPECT_EQ(1.2, out);
+ EXPECT_FALSE(GetDoubleFromJson(in_s, &out));
+}
+
+TEST(JsonTest, GetFromArray) {
+ Json::Value a, out;
+ a.append(in_s);
+ a.append(in_i);
+ a.append(in_u);
+ a.append(in_b);
+ EXPECT_TRUE(GetValueFromJsonArray(a, 0, &out));
+ EXPECT_TRUE(GetValueFromJsonArray(a, 3, &out));
+ EXPECT_FALSE(GetValueFromJsonArray(a, 99, &out));
+ EXPECT_FALSE(GetValueFromJsonArray(a, 0xFFFFFFFF, &out));
+}
+
+TEST(JsonTest, GetFromObject) {
+ Json::Value o, out;
+ o["string"] = in_s;
+ o["int"] = in_i;
+ o["uint"] = in_u;
+ o["bool"] = in_b;
+ EXPECT_TRUE(GetValueFromJsonObject(o, "int", &out));
+ EXPECT_TRUE(GetValueFromJsonObject(o, "bool", &out));
+ EXPECT_FALSE(GetValueFromJsonObject(o, "foo", &out));
+ EXPECT_FALSE(GetValueFromJsonObject(o, "", &out));
+}
+
+TEST(JsonTest, VectorToArray) {
+ std::vector<std::string> in;
+ Json::Value out;
+ in.push_back("a");
+ in.push_back("b");
+ in.push_back("c");
+ out = StringVectorToJsonValue(in);
+ EXPECT_EQ(in.size(), out.size());
+ for (Json::Value::ArrayIndex i = 0; i < in.size(); ++i) {
+ EXPECT_EQ(in[i], out[i].asString());
+ }
+}
+
+TEST(JsonTest, ArrayToVector) {
+ Json::Value in(Json::arrayValue);
+ std::vector<std::string> out;
+ in.append("a");
+ in.append("b");
+ in.append("c");
+ EXPECT_TRUE(JsonValueToStringVector(in, &out));
+ EXPECT_EQ(in.size(), out.size());
+ for (Json::Value::ArrayIndex i = 0; i < in.size(); ++i) {
+ EXPECT_EQ(in[i].asString(), out[i]);
+ }
+}
diff --git a/talk/base/latebindingsymboltable.cc b/talk/base/latebindingsymboltable.cc
index f9d59ab..348265e 100644
--- a/talk/base/latebindingsymboltable.cc
+++ b/talk/base/latebindingsymboltable.cc
@@ -37,7 +37,7 @@
inline static const char *GetDllError() {
#ifdef LINUX
- char *err = dlerror();
+ const char *err = dlerror();
if (err) {
return err;
} else {
@@ -75,7 +75,7 @@
void **symbol) {
#ifdef LINUX
*symbol = dlsym(handle, symbol_name);
- char *err = dlerror();
+ const char *err = dlerror();
if (err) {
LOG(LS_ERROR) << "Error loading symbol " << symbol_name << ": " << err;
return false;
diff --git a/talk/base/latebindingsymboltable_unittest.cc b/talk/base/latebindingsymboltable_unittest.cc
new file mode 100644
index 0000000..a16423e
--- /dev/null
+++ b/talk/base/latebindingsymboltable_unittest.cc
@@ -0,0 +1,80 @@
+/*
+ * libjingle
+ * Copyright 2010, 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.
+ */
+
+#ifdef LINUX
+#include <math.h>
+#endif
+
+#include "talk/base/gunit.h"
+#include "talk/base/latebindingsymboltable.h"
+
+namespace talk_base {
+
+#ifdef LINUX
+
+// Some libm symbols for our test.
+#define LIBM_SYMBOLS_LIST \
+ X(acos) \
+ X(sin) \
+ X(tan)
+
+LATE_BINDING_SYMBOL_TABLE_DECLARE_BEGIN(LibmTestSymbolTable)
+#define X(sym) \
+ LATE_BINDING_SYMBOL_TABLE_DECLARE_ENTRY(LibmTestSymbolTable, sym)
+LIBM_SYMBOLS_LIST
+#undef X
+LATE_BINDING_SYMBOL_TABLE_DECLARE_END(LibmTestSymbolTable)
+
+LATE_BINDING_SYMBOL_TABLE_DEFINE_BEGIN(LibmTestSymbolTable, "libm.so.6")
+#define X(sym) \
+ LATE_BINDING_SYMBOL_TABLE_DEFINE_ENTRY(LibmTestSymbolTable, sym)
+LIBM_SYMBOLS_LIST
+#undef X
+LATE_BINDING_SYMBOL_TABLE_DEFINE_END(LibmTestSymbolTable)
+
+#define LATE(sym) \
+ LATESYM_GET(LibmTestSymbolTable, &table, sym)
+
+TEST(LateBindingSymbolTable, libm) {
+ LibmTestSymbolTable table;
+ EXPECT_FALSE(table.IsLoaded());
+ ASSERT_TRUE(table.Load());
+ EXPECT_TRUE(table.IsLoaded());
+ EXPECT_EQ(LATE(acos)(0.5), acos(0.5));
+ EXPECT_EQ(LATE(sin)(0.5), sin(0.5));
+ EXPECT_EQ(LATE(tan)(0.5), tan(0.5));
+ // It would be nice to check that the addresses are the same, but the nature
+ // of dynamic linking and relocation makes them actually be different.
+ table.Unload();
+ EXPECT_FALSE(table.IsLoaded());
+}
+
+#else
+#error Not implemented
+#endif
+
+} // namespace talk_base
diff --git a/talk/base/libdbusglibsymboltable.cc b/talk/base/libdbusglibsymboltable.cc
new file mode 100644
index 0000000..3548a7c
--- /dev/null
+++ b/talk/base/libdbusglibsymboltable.cc
@@ -0,0 +1,41 @@
+/*
+ * libjingle
+ * Copyright 2004--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/base/libdbusglibsymboltable.h"
+
+namespace talk_base {
+
+LATE_BINDING_SYMBOL_TABLE_DEFINE_BEGIN(LibDBusGlibSymbolTable,
+ "libdbus-glib-1.so")
+#define X(sym) \
+ LATE_BINDING_SYMBOL_TABLE_DEFINE_ENTRY(LibDBusGlibSymbolTable, sym)
+LIBDBUS_GLIB_SYMBOLS_LIST
+#undef X
+LATE_BINDING_SYMBOL_TABLE_DEFINE_END(LibDBusGlibSymbolTable)
+
+} // namespace talk_base
+
diff --git a/talk/base/libdbusglibsymboltable.h b/talk/base/libdbusglibsymboltable.h
new file mode 100644
index 0000000..9aad8a5
--- /dev/null
+++ b/talk/base/libdbusglibsymboltable.h
@@ -0,0 +1,85 @@
+/*
+ * libjingle
+ * Copyright 2004--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_BASE_LIBDBUSGLIBSYMBOLTABLE_H_
+#define TALK_BASE_LIBDBUSGLIBSYMBOLTABLE_H_
+
+#include "talk/base/latebindingsymboltable.h"
+
+namespace talk_base {
+
+// The libdbus-glib symbols we need, as an X-Macro list.
+// This list must contain precisely every libdbus-glib function that is used in
+// dbus.cc.
+#define LIBDBUS_GLIB_SYMBOLS_LIST \
+ X(dbus_bus_add_match) \
+ X(dbus_connection_add_filter) \
+ X(dbus_connection_close) \
+ X(dbus_connection_remove_filter) \
+ X(dbus_connection_set_exit_on_disconnect) \
+ X(dbus_g_bus_get) \
+ X(dbus_g_bus_get_private) \
+ X(dbus_g_connection_get_connection) \
+ X(dbus_g_connection_unref) \
+ X(dbus_g_thread_init) \
+ X(dbus_message_get_interface) \
+ X(dbus_message_get_member) \
+ X(dbus_message_get_path) \
+ X(dbus_message_get_type) \
+ X(dbus_message_iter_get_arg_type) \
+ X(dbus_message_iter_get_basic) \
+ X(dbus_message_iter_init) \
+ X(dbus_message_ref) \
+ X(dbus_message_unref) \
+ X(g_free) \
+ X(g_idle_source_new) \
+ X(g_main_context_new) \
+ X(g_main_context_push_thread_default) \
+ X(g_main_context_unref) \
+ X(g_main_loop_new) \
+ X(g_main_loop_quit) \
+ X(g_main_loop_run) \
+ X(g_main_loop_unref) \
+ X(g_object_unref) \
+ X(g_source_attach) \
+ X(g_source_destroy) \
+ X(g_source_set_callback) \
+ X(g_source_unref) \
+ X(g_thread_init) \
+ X(g_type_init)
+
+LATE_BINDING_SYMBOL_TABLE_DECLARE_BEGIN(LibDBusGlibSymbolTable)
+#define X(sym) \
+ LATE_BINDING_SYMBOL_TABLE_DECLARE_ENTRY(LibDBusGlibSymbolTable, sym)
+LIBDBUS_GLIB_SYMBOLS_LIST
+#undef X
+LATE_BINDING_SYMBOL_TABLE_DECLARE_END(LibDBusGlibSymbolTable)
+
+} // namespace talk_base
+
+#endif // TALK_BASE_LIBDBUSGLIBSYMBOLTABLE_H_
+
diff --git a/talk/base/linux.cc b/talk/base/linux.cc
index 9303f4f..a4434f5 100644
--- a/talk/base/linux.cc
+++ b/talk/base/linux.cc
@@ -135,8 +135,23 @@
bool ProcCpuInfo::GetCpuFamily(int* id) {
int cpu_family = 0;
+#if defined(__arm__)
+ // On some ARM platforms, there is no 'cpu family' in '/proc/cpuinfo'. But
+ // there is 'CPU Architecture' which can be used as 'cpu family'.
+ // See http://en.wikipedia.org/wiki/ARM_architecture for a good list of
+ // ARM cpu families, architectures, and their mappings.
+ // There may be multiple sessions that aren't per-processor. We need to scan
+ // through each session until we find the first 'CPU architecture'.
+ size_t section_count = sections_.size();
+ for (size_t i = 0; i < section_count; ++i) {
+ if (GetSectionIntValue(i, "CPU architecture", &cpu_family)) {
+ // We returns the first one (if there are multiple entries).
+ break;
+ };
+ }
+#else
GetSectionIntValue(0, "cpu family", &cpu_family);
-
+#endif
if (id) {
*id = cpu_family;
}
diff --git a/talk/base/linux_unittest.cc b/talk/base/linux_unittest.cc
new file mode 100644
index 0000000..6e1a8a9
--- /dev/null
+++ b/talk/base/linux_unittest.cc
@@ -0,0 +1,119 @@
+/*
+ * libjingle
+ * Copyright 2008, 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 <stdio.h>
+#include "talk/base/linux.h"
+#include "talk/base/fileutils.h"
+#include "talk/base/logging.h"
+#include "testing/base/gunit.h"
+
+namespace talk_base {
+
+// These tests running on ARM are fairly specific to the output of the tegra2
+// ARM processor, and so may fail on other ARM-based systems.
+TEST(ProcCpuInfo, GetProcInfo) {
+ ProcCpuInfo proc_info;
+ EXPECT_TRUE(proc_info.LoadFromSystem());
+
+ int out_cpus = 0;
+ EXPECT_TRUE(proc_info.GetNumCpus(&out_cpus));
+ LOG(LS_INFO) << "GetNumCpus: " << out_cpus;
+ EXPECT_GT(out_cpus, 0);
+
+ int out_cpus_phys = 0;
+ EXPECT_TRUE(proc_info.GetNumPhysicalCpus(&out_cpus_phys));
+ LOG(LS_INFO) << "GetNumPhysicalCpus: " << out_cpus_phys;
+ EXPECT_GT(out_cpus_phys, 0);
+ EXPECT_LE(out_cpus_phys, out_cpus);
+
+ int out_family = 0;
+ EXPECT_TRUE(proc_info.GetCpuFamily(&out_family));
+ LOG(LS_INFO) << "cpu family: " << out_family;
+ EXPECT_GE(out_family, 4);
+
+#if defined(__arm__)
+ std::string out_processor;
+ EXPECT_TRUE(proc_info.GetSectionStringValue(0, "Processor", &out_processor));
+ LOG(LS_INFO) << "Processor: " << out_processor;
+ EXPECT_NE(std::string::npos, out_processor.find("ARM"));
+
+ // Most other info, such as model, stepping, vendor, etc.
+ // is missing on ARM systems.
+#else
+ int out_model = 0;
+ EXPECT_TRUE(proc_info.GetSectionIntValue(0, "model", &out_model));
+ LOG(LS_INFO) << "model: " << out_model;
+
+ int out_stepping = 0;
+ EXPECT_TRUE(proc_info.GetSectionIntValue(0, "stepping", &out_stepping));
+ LOG(LS_INFO) << "stepping: " << out_stepping;
+
+ int out_processor = 0;
+ EXPECT_TRUE(proc_info.GetSectionIntValue(0, "processor", &out_processor));
+ LOG(LS_INFO) << "processor: " << out_processor;
+ EXPECT_EQ(0, out_processor);
+
+ std::string out_str;
+ EXPECT_TRUE(proc_info.GetSectionStringValue(0, "vendor_id", &out_str));
+ LOG(LS_INFO) << "vendor_id: " << out_str;
+ EXPECT_FALSE(out_str.empty());
+#endif
+}
+
+TEST(ConfigParser, ParseConfig) {
+ ConfigParser parser;
+ MemoryStream *test_stream = new MemoryStream(
+ "Key1: Value1\n"
+ "Key2\t: Value2\n"
+ "Key3:Value3\n"
+ "\n"
+ "Key1:Value1\n");
+ ConfigParser::MapVector key_val_pairs;
+ parser.Attach(test_stream);
+ EXPECT_EQ(true, parser.Parse(&key_val_pairs));
+ EXPECT_EQ(2U, key_val_pairs.size());
+ EXPECT_EQ("Value1", key_val_pairs[0]["Key1"]);
+ EXPECT_EQ("Value2", key_val_pairs[0]["Key2"]);
+ EXPECT_EQ("Value3", key_val_pairs[0]["Key3"]);
+ EXPECT_EQ("Value1", key_val_pairs[1]["Key1"]);
+ key_val_pairs.clear();
+ EXPECT_EQ(true, parser.Open("/proc/cpuinfo"));
+ EXPECT_EQ(true, parser.Parse(&key_val_pairs));
+}
+
+TEST(ReadLinuxLsbRelease, ReturnsSomething) {
+ std::string str = ReadLinuxLsbRelease();
+ // ChromeOS don't have lsb_release
+ // EXPECT_FALSE(str.empty());
+}
+
+TEST(ReadLinuxUname, ReturnsSomething) {
+ std::string str = ReadLinuxUname();
+ EXPECT_FALSE(str.empty());
+}
+
+} // namespace talk_base
diff --git a/talk/base/linuxfdwalk.c b/talk/base/linuxfdwalk.c
new file mode 100644
index 0000000..4179f41
--- /dev/null
+++ b/talk/base/linuxfdwalk.c
@@ -0,0 +1,98 @@
+/*
+ * libjingle
+ * Copyright 2004--2009, 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 <sys/types.h>
+#include <dirent.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "talk/base/linuxfdwalk.h"
+
+// Parses a file descriptor number in base 10, requiring the strict format used
+// in /proc/*/fd. Returns the value, or -1 if not a valid string.
+static int parse_fd(const char *s) {
+ if (!*s) {
+ // Empty string is invalid.
+ return -1;
+ }
+ int val = 0;
+ do {
+ if (*s < '0' || *s > '9') {
+ // Non-numeric characters anywhere are invalid.
+ return -1;
+ }
+ int digit = *s++ - '0';
+ val = val * 10 + digit;
+ } while (*s);
+ return val;
+}
+
+int fdwalk(void (*func)(void *, int), void *opaque) {
+ DIR *dir = opendir("/proc/self/fd");
+ if (!dir) {
+ return -1;
+ }
+ int opendirfd = dirfd(dir);
+ int parse_errors = 0;
+ struct dirent *ent;
+ // Have to clear errno to distinguish readdir() completion from failure.
+ while (errno = 0, (ent = readdir(dir)) != NULL) {
+ if (strcmp(ent->d_name, ".") == 0 ||
+ strcmp(ent->d_name, "..") == 0) {
+ continue;
+ }
+ // We avoid atoi or strtol because those are part of libc and they involve
+ // locale stuff, which is probably not safe from a post-fork context in a
+ // multi-threaded app.
+ int fd = parse_fd(ent->d_name);
+ if (fd < 0) {
+ parse_errors = 1;
+ continue;
+ }
+ if (fd != opendirfd) {
+ (*func)(opaque, fd);
+ }
+ }
+ int saved_errno = errno;
+ if (closedir(dir) < 0) {
+ if (!saved_errno) {
+ // Return the closedir error.
+ return -1;
+ }
+ // Else ignore it because we have a more relevant error to return.
+ }
+ if (saved_errno) {
+ errno = saved_errno;
+ return -1;
+ } else if (parse_errors) {
+ errno = EBADF;
+ return -1;
+ } else {
+ return 0;
+ }
+}
diff --git a/talk/base/linuxfdwalk.h b/talk/base/linuxfdwalk.h
new file mode 100644
index 0000000..ea039bf
--- /dev/null
+++ b/talk/base/linuxfdwalk.h
@@ -0,0 +1,51 @@
+/*
+ * libjingle
+ * Copyright 2004--2009, 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_BASE_LINUXFDWALK_H_
+#define TALK_BASE_LINUXFDWALK_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Linux port of SunOS's fdwalk(3) call. It loops over all open file descriptors
+// and calls func on each one. Additionally, it is safe to use from the child
+// of a fork that hasn't exec'ed yet, so you can use it to close all open file
+// descriptors prior to exec'ing a daemon.
+// The return value is 0 if successful, or else -1 and errno is set. The
+// possible errors include any error that can be returned by opendir(),
+// readdir(), or closedir(), plus EBADF if there are problems parsing the
+// contents of /proc/self/fd.
+// The file descriptors that are enumerated will not include the file descriptor
+// used for the enumeration itself.
+int fdwalk(void (*func)(void *, int), void *opaque);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // TALK_BASE_LINUXFDWALK_H_
diff --git a/talk/base/linuxfdwalk_unittest.cc b/talk/base/linuxfdwalk_unittest.cc
new file mode 100644
index 0000000..ff14b66
--- /dev/null
+++ b/talk/base/linuxfdwalk_unittest.cc
@@ -0,0 +1,92 @@
+/*
+ * libjingle
+ * Copyright 2009, 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 <set>
+#include <sstream>
+
+#include "talk/base/gunit.h"
+#include "talk/base/linuxfdwalk.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+static const int kArbitraryLargeFdNumber = 424;
+
+static void FdCheckVisitor(void *data, int fd) {
+ std::set<int> *fds = static_cast<std::set<int> *>(data);
+ EXPECT_EQ(1U, fds->erase(fd));
+}
+
+static void FdEnumVisitor(void *data, int fd) {
+ std::set<int> *fds = static_cast<std::set<int> *>(data);
+ EXPECT_TRUE(fds->insert(fd).second);
+}
+
+// Checks that the set of open fds is exactly the given list.
+static void CheckOpenFdList(std::set<int> fds) {
+ EXPECT_EQ(0, fdwalk(&FdCheckVisitor, &fds));
+ EXPECT_EQ(0U, fds.size());
+}
+
+static void GetOpenFdList(std::set<int> *fds) {
+ fds->clear();
+ EXPECT_EQ(0, fdwalk(&FdEnumVisitor, fds));
+}
+
+TEST(LinuxFdWalk, TestFdWalk) {
+ std::set<int> fds;
+ GetOpenFdList(&fds);
+ std::ostringstream str;
+ // I have observed that the open set when starting a test is [0, 6]. Leaked
+ // fds would change that, but so can (e.g.) running under a debugger, so we
+ // can't really do an EXPECT. :(
+ str << "File descriptors open in test executable:";
+ for (std::set<int>::const_iterator i = fds.begin(); i != fds.end(); ++i) {
+ str << " " << *i;
+ }
+ LOG(LS_INFO) << str.str();
+ // Open some files.
+ int fd1 = open("/dev/null", O_RDONLY);
+ EXPECT_LE(0, fd1);
+ int fd2 = open("/dev/null", O_WRONLY);
+ EXPECT_LE(0, fd2);
+ int fd3 = open("/dev/null", O_RDWR);
+ EXPECT_LE(0, fd3);
+ int fd4 = dup2(fd3, kArbitraryLargeFdNumber);
+ EXPECT_LE(0, fd4);
+ EXPECT_TRUE(fds.insert(fd1).second);
+ EXPECT_TRUE(fds.insert(fd2).second);
+ EXPECT_TRUE(fds.insert(fd3).second);
+ EXPECT_TRUE(fds.insert(fd4).second);
+ CheckOpenFdList(fds);
+ EXPECT_EQ(0, close(fd1));
+ EXPECT_EQ(0, close(fd2));
+ EXPECT_EQ(0, close(fd3));
+ EXPECT_EQ(0, close(fd4));
+}
diff --git a/talk/base/linuxwindowpicker.cc b/talk/base/linuxwindowpicker.cc
new file mode 100644
index 0000000..250c1db
--- /dev/null
+++ b/talk/base/linuxwindowpicker.cc
@@ -0,0 +1,735 @@
+/*
+ * libjingle
+ * Copyright 2010 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/base/linuxwindowpicker.h"
+
+#include <math.h>
+#include <string.h>
+
+#include <string>
+
+#include <X11/Xatom.h>
+#include <X11/extensions/Xcomposite.h>
+#include <X11/extensions/Xrender.h>
+#include <X11/Xutil.h>
+
+#include "talk/base/logging.h"
+
+namespace talk_base {
+
+// Stupid X11. It seems none of the synchronous returns codes from X11 calls
+// are meaningful unless an asynchronous error handler is configured. This
+// RAII class registers and unregisters an X11 error handler.
+class XErrorSuppressor {
+ public:
+ explicit XErrorSuppressor(Display* display)
+ : display_(display), original_error_handler_(NULL) {
+ SuppressX11Errors();
+ }
+ ~XErrorSuppressor() {
+ UnsuppressX11Errors();
+ }
+
+ private:
+ static int ErrorHandler(Display* display, XErrorEvent* e) {
+ char buf[256];
+ XGetErrorText(display, e->error_code, buf, sizeof buf);
+ LOG(LS_WARNING) << "Received X11 error \"" << buf << "\" for request code "
+ << static_cast<unsigned int>(e->request_code);
+ return 0;
+ }
+
+ void SuppressX11Errors() {
+ XFlush(display_);
+ XSync(display_, False);
+ original_error_handler_ = XSetErrorHandler(&ErrorHandler);
+ }
+
+ void UnsuppressX11Errors() {
+ XFlush(display_);
+ XSync(display_, False);
+ XErrorHandler handler = XSetErrorHandler(original_error_handler_);
+ if (handler != &ErrorHandler) {
+ LOG(LS_WARNING) << "Unbalanced XSetErrorHandler() calls detected. "
+ << "Final error handler may not be what you expect!";
+ }
+ original_error_handler_ = NULL;
+ }
+
+ Display* display_;
+ XErrorHandler original_error_handler_;
+
+ DISALLOW_COPY_AND_ASSIGN(XErrorSuppressor);
+};
+
+// Hiding all X11 specifics inside its own class. This to avoid
+// conflicts between talk and X11 header declarations.
+class XWindowEnumerator {
+ public:
+ XWindowEnumerator()
+ : display_(NULL),
+ has_composite_extension_(false),
+ has_render_extension_(false) {
+ }
+
+ ~XWindowEnumerator() {
+ if (display_ != NULL) {
+ XCloseDisplay(display_);
+ }
+ }
+
+ bool Init() {
+ if (display_ != NULL) {
+ // Already initialized.
+ return true;
+ }
+ display_ = XOpenDisplay(NULL);
+ if (display_ == NULL) {
+ LOG(LS_ERROR) << "Failed to open display.";
+ return false;
+ }
+
+ XErrorSuppressor error_suppressor(display_);
+
+ wm_state_ = XInternAtom(display_, "WM_STATE", True);
+ net_wm_icon_ = XInternAtom(display_, "_NET_WM_ICON", False);
+
+ int event_base, error_base, major_version, minor_version;
+ if (XCompositeQueryExtension(display_, &event_base, &error_base) &&
+ XCompositeQueryVersion(display_, &major_version, &minor_version) &&
+ // XCompositeNameWindowPixmap() requires version 0.2
+ (major_version > 0 || minor_version >= 2)) {
+ has_composite_extension_ = true;
+ } else {
+ LOG(LS_INFO) << "Xcomposite extension not available or too old.";
+ }
+
+ if (XRenderQueryExtension(display_, &event_base, &error_base) &&
+ XRenderQueryVersion(display_, &major_version, &minor_version) &&
+ // XRenderSetPictureTransform() requires version 0.6
+ (major_version > 0 || minor_version >= 6)) {
+ has_render_extension_ = true;
+ } else {
+ LOG(LS_INFO) << "Xrender extension not available or too old.";
+ }
+ return true;
+ }
+
+ bool EnumerateWindows(WindowDescriptionList* descriptions) {
+ if (!Init()) {
+ return false;
+ }
+ XErrorSuppressor error_suppressor(display_);
+ int num_screens = XScreenCount(display_);
+ bool result = false;
+ for (int i = 0; i < num_screens; ++i) {
+ if (EnumerateScreenWindows(descriptions, i)) {
+ // We know we succeded on at least one screen.
+ result = true;
+ }
+ }
+ return result;
+ }
+
+ bool EnumerateDesktops(DesktopDescriptionList* descriptions) {
+ if (!Init()) {
+ return false;
+ }
+ XErrorSuppressor error_suppressor(display_);
+ int num_screens = XScreenCount(display_);
+ for (int i = 0; i < num_screens; ++i) {
+ Window root_window = XRootWindow(display_, i);
+ DesktopId id(DesktopId(root_window, i));
+ // TODO: Figure out an appropriate desktop title.
+ DesktopDescription desc(id, "");
+ descriptions->push_back(desc);
+ }
+ return num_screens > 0;
+ }
+
+ bool IsVisible(const WindowId& id) {
+ if (!Init()) {
+ return false;
+ }
+ XErrorSuppressor error_suppressor(display_);
+ XWindowAttributes attr;
+ if (!XGetWindowAttributes(display_, id.id(), &attr)) {
+ LOG(LS_ERROR) << "XGetWindowAttributes() failed";
+ return false;
+ }
+ return attr.map_state == IsViewable;
+ }
+
+ bool MoveToFront(const WindowId& id) {
+ if (!Init()) {
+ return false;
+ }
+ XErrorSuppressor error_suppressor(display_);
+ unsigned int num_children;
+ Window* children;
+ Window parent;
+ Window root;
+
+ // Find root window to pass event to.
+ int status = XQueryTree(display_, id.id(), &root, &parent, &children,
+ &num_children);
+ if (status == 0) {
+ LOG(LS_WARNING) << "Failed to query for child windows.";
+ return false;
+ }
+ if (children != NULL) {
+ XFree(children);
+ }
+
+ // Move the window to front.
+ XRaiseWindow(display_, id.id());
+
+ // Some window managers (e.g., metacity in GNOME) consider it illegal to
+ // raise a window without also giving it input focus with
+ // _NET_ACTIVE_WINDOW, so XRaiseWindow() on its own isn't enough.
+ Atom atom = XInternAtom(display_, "_NET_ACTIVE_WINDOW", True);
+ if (atom != None) {
+ XEvent xev;
+ long event_mask;
+
+ xev.xclient.type = ClientMessage;
+ xev.xclient.serial = 0;
+ xev.xclient.send_event = True;
+ xev.xclient.window = id.id();
+ xev.xclient.message_type = atom;
+
+ // The format member is set to 8, 16, or 32 and specifies whether the
+ // data should be viewed as a list of bytes, shorts, or longs.
+ xev.xclient.format = 32;
+
+ xev.xclient.data.l[0] = 0;
+ xev.xclient.data.l[1] = 0;
+ xev.xclient.data.l[2] = 0;
+ xev.xclient.data.l[3] = 0;
+ xev.xclient.data.l[4] = 0;
+
+ event_mask = SubstructureRedirectMask | SubstructureNotifyMask;
+
+ XSendEvent(display_, root, False, event_mask, &xev);
+ }
+ XFlush(display_);
+ return true;
+ }
+
+ uint8* GetWindowIcon(const WindowId& id, int* width, int* height) {
+ if (!Init()) {
+ return NULL;
+ }
+ XErrorSuppressor error_suppressor(display_);
+ Atom ret_type;
+ int format;
+ unsigned long length, bytes_after, size;
+ unsigned char* data = NULL;
+
+ // Find out the size of the icon data.
+ if (XGetWindowProperty(
+ display_, id.id(), net_wm_icon_, 0, 0, False, XA_CARDINAL,
+ &ret_type, &format, &length, &size, &data) == Success &&
+ data) {
+ XFree(data);
+ } else {
+ LOG(LS_ERROR) << "Failed to get size of the icon.";
+ return NULL;
+ }
+ // Get the icon data, the format is one uint32 each for width and height,
+ // followed by the actual pixel data.
+ if (size >= 2 &&
+ XGetWindowProperty(
+ display_, id.id(), net_wm_icon_, 0, size, False, XA_CARDINAL,
+ &ret_type, &format, &length, &bytes_after, &data) == Success &&
+ data) {
+ uint32* data_ptr = reinterpret_cast<uint32*>(data);
+ int w, h;
+ w = data_ptr[0];
+ h = data_ptr[1];
+ if (size < static_cast<unsigned long>(w * h + 2)) {
+ XFree(data);
+ LOG(LS_ERROR) << "Not a vaild icon.";
+ return NULL;
+ }
+ uint8* rgba =
+ ArgbToRgba(&data_ptr[2], 0, 0, w, h, w, h, true);
+ XFree(data);
+ *width = w;
+ *height = h;
+ return rgba;
+ } else {
+ LOG(LS_ERROR) << "Failed to get window icon data.";
+ return NULL;
+ }
+ }
+
+ uint8* GetWindowThumbnail(const WindowId& id, int width, int height) {
+ if (!Init()) {
+ return NULL;
+ }
+
+ if (!has_composite_extension_) {
+ // Without the Xcomposite extension we would only get a good thumbnail if
+ // the whole window is visible on screen and not covered by any
+ // other window. This is not something we want so instead, just
+ // bail out.
+ LOG(LS_INFO) << "No Xcomposite extension detected.";
+ return NULL;
+ }
+ XErrorSuppressor error_suppressor(display_);
+
+ Window root;
+ int x;
+ int y;
+ unsigned int src_width;
+ unsigned int src_height;
+ unsigned int border_width;
+ unsigned int depth;
+
+ // In addition to needing X11 server-side support for Xcomposite, it
+ // actually needs to be turned on for this window in order to get a good
+ // thumbnail. If the user has modern hardware/drivers but isn't using a
+ // compositing window manager, that won't be the case. We could
+ // automatically turn it on for all windows here so that we can get
+ // thumbnails, but the transition is visually ugly, so instead we just want
+ // to detect this case and bail out. To do so, we attempt to retrieve the
+ // backing pixmap for the window, which will only exist if the window has
+ // been redirected to offscreen drawing by a compositing window manager. If
+ // it doesn't exist, the calls will raise errors, so we must suppress errors
+ // to prevent libX11 from aborting the program.
+ Pixmap src_pixmap = XCompositeNameWindowPixmap(display_, id.id());
+ if (!src_pixmap) {
+ // Even if the backing pixmap doesn't exist, this still should have
+ // succeeded and returned a valid handle (it just wouldn't be a handle to
+ // anything). So this is a real error path.
+ LOG(LS_ERROR) << "XCompositeNameWindowPixmap() failed";
+ return NULL;
+ }
+ if (!XGetGeometry(display_, src_pixmap, &root, &x, &y,
+ &src_width, &src_height, &border_width,
+ &depth)) {
+ // If the window does not actually have a backing pixmap, this is the path
+ // that will "fail", so it's a warning rather than an error.
+ LOG(LS_WARNING) << "XGetGeometry() failed (probably composite is not in "
+ << "use)";
+ XFreePixmap(display_, src_pixmap);
+ return NULL;
+ }
+
+ // If we get to here, then composite is in use for this window and it has a
+ // valid backing pixmap.
+
+ XWindowAttributes attr;
+ if (!XGetWindowAttributes(display_, id.id(), &attr)) {
+ LOG(LS_ERROR) << "XGetWindowAttributes() failed";
+ XFreePixmap(display_, src_pixmap);
+ return NULL;
+ }
+
+ uint8* data = GetDrawableThumbnail(src_pixmap,
+ attr.visual,
+ src_width,
+ src_height,
+ width,
+ height);
+ XFreePixmap(display_, src_pixmap);
+ return data;
+ }
+
+ int GetNumDesktops() {
+ if (!Init()) {
+ return -1;
+ }
+
+ return XScreenCount(display_);
+ }
+
+ uint8* GetDesktopThumbnail(const DesktopId& id, int width, int height) {
+ if (!Init()) {
+ return NULL;
+ }
+ XErrorSuppressor error_suppressor(display_);
+
+ Window root_window = id.id();
+ XWindowAttributes attr;
+ if (!XGetWindowAttributes(display_, root_window, &attr)) {
+ LOG(LS_ERROR) << "XGetWindowAttributes() failed";
+ return NULL;
+ }
+
+ return GetDrawableThumbnail(root_window,
+ attr.visual,
+ attr.width,
+ attr.height,
+ width,
+ height);
+ }
+
+ private:
+ uint8* GetDrawableThumbnail(Drawable src_drawable,
+ Visual* visual,
+ int src_width,
+ int src_height,
+ int dst_width,
+ int dst_height) {
+ if (!has_render_extension_) {
+ // Without the Xrender extension we would have to read the full window and
+ // scale it down in our process. Xrender is over a decade old so we aren't
+ // going to expend effort to support that situation. We still need to
+ // check though because probably some virtual VNC displays are in this
+ // category.
+ LOG(LS_INFO) << "No Xrender extension detected.";
+ return NULL;
+ }
+
+ XRenderPictFormat* format = XRenderFindVisualFormat(display_,
+ visual);
+ if (!format) {
+ LOG(LS_ERROR) << "XRenderFindVisualFormat() failed";
+ return NULL;
+ }
+
+ // Create a picture to reference the window pixmap.
+ XRenderPictureAttributes pa;
+ pa.subwindow_mode = IncludeInferiors; // Don't clip child widgets
+ Picture src = XRenderCreatePicture(display_,
+ src_drawable,
+ format,
+ CPSubwindowMode,
+ &pa);
+ if (!src) {
+ LOG(LS_ERROR) << "XRenderCreatePicture() failed";
+ return NULL;
+ }
+
+ // Create a picture to reference the destination pixmap.
+ Pixmap dst_pixmap = XCreatePixmap(display_,
+ src_drawable,
+ dst_width,
+ dst_height,
+ format->depth);
+ if (!dst_pixmap) {
+ LOG(LS_ERROR) << "XCreatePixmap() failed";
+ XRenderFreePicture(display_, src);
+ return NULL;
+ }
+
+ Picture dst = XRenderCreatePicture(display_, dst_pixmap, format, 0, NULL);
+ if (!dst) {
+ LOG(LS_ERROR) << "XRenderCreatePicture() failed";
+ XFreePixmap(display_, dst_pixmap);
+ XRenderFreePicture(display_, src);
+ return NULL;
+ }
+
+ // Clear the background.
+ XRenderColor transparent = {0};
+ XRenderFillRectangle(display_,
+ PictOpSrc,
+ dst,
+ &transparent,
+ 0,
+ 0,
+ dst_width,
+ dst_height);
+
+ // Calculate how much we need to scale the image.
+ double scale_x = static_cast<double>(dst_width) /
+ static_cast<double>(src_width);
+ double scale_y = static_cast<double>(dst_height) /
+ static_cast<double>(src_height);
+ double scale = talk_base::_min(scale_y, scale_x);
+
+ int scaled_width = round(src_width * scale);
+ int scaled_height = round(src_height * scale);
+
+ // Render the thumbnail centered on both axis.
+ int centered_x = (dst_width - scaled_width) / 2;
+ int centered_y = (dst_height - scaled_height) / 2;
+
+ // Scaling matrix
+ XTransform xform = { {
+ { XDoubleToFixed(1), XDoubleToFixed(0), XDoubleToFixed(0) },
+ { XDoubleToFixed(0), XDoubleToFixed(1), XDoubleToFixed(0) },
+ { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(scale) }
+ } };
+ XRenderSetPictureTransform(display_, src, &xform);
+
+ // Apply filter to smooth out the image.
+ XRenderSetPictureFilter(display_, src, FilterBest, NULL, 0);
+
+ // Render the image to the destination picture.
+ XRenderComposite(display_,
+ PictOpSrc,
+ src,
+ None,
+ dst,
+ 0,
+ 0,
+ 0,
+ 0,
+ centered_x,
+ centered_y,
+ scaled_width,
+ scaled_height);
+
+ // Get the pixel data from the X server. TODO: XGetImage
+ // might be slow here, compare with ShmGetImage.
+ XImage* image = XGetImage(display_,
+ dst_pixmap,
+ 0,
+ 0,
+ dst_width,
+ dst_height,
+ AllPlanes, ZPixmap);
+ uint8* data = ArgbToRgba(reinterpret_cast<uint32*>(image->data),
+ centered_x,
+ centered_y,
+ scaled_width,
+ scaled_height,
+ dst_width,
+ dst_height,
+ false);
+ XDestroyImage(image);
+ XRenderFreePicture(display_, dst);
+ XFreePixmap(display_, dst_pixmap);
+ XRenderFreePicture(display_, src);
+ return data;
+ }
+
+ uint8* ArgbToRgba(uint32* argb_data, int x, int y, int w, int h,
+ int stride_x, int stride_y, bool has_alpha) {
+ uint8* p;
+ int len = stride_x * stride_y * 4;
+ uint8* data = new uint8[len];
+ memset(data, 0, len);
+ p = data + 4 * (y * stride_x + x);
+ for (int i = 0; i < h; ++i) {
+ for (int j = 0; j < w; ++j) {
+ uint32 argb;
+ uint32 rgba;
+ argb = argb_data[stride_x * (y + i) + x + j];
+ rgba = (argb << 8) | (argb >> 24);
+ *p = rgba >> 24;
+ ++p;
+ *p = (rgba >> 16) & 0xff;
+ ++p;
+ *p = (rgba >> 8) & 0xff;
+ ++p;
+ *p = has_alpha ? rgba & 0xFF : 0xFF;
+ ++p;
+ }
+ p += (stride_x - w) * 4;
+ }
+ return data;
+ }
+
+ bool EnumerateScreenWindows(WindowDescriptionList* descriptions, int screen) {
+ Window parent;
+ Window *children;
+ int status;
+ unsigned int num_children;
+ Window root_window = XRootWindow(display_, screen);
+ status = XQueryTree(display_, root_window, &root_window, &parent, &children,
+ &num_children);
+ if (status == 0) {
+ LOG(LS_ERROR) << "Failed to query for child windows.";
+ return false;
+ }
+ for (unsigned int i = 0; i < num_children; ++i) {
+ // Iterate in reverse order to display windows from front to back.
+ Window app_window = GetApplicationWindow(children[num_children - 1 - i]);
+ if (app_window &&
+ !LinuxWindowPicker::IsDesktopElement(display_, app_window)) {
+ std::string title;
+ if (GetWindowTitle(app_window, &title)) {
+ WindowId id(app_window);
+ WindowDescription desc(id, title);
+ descriptions->push_back(desc);
+ }
+ }
+ }
+ if (children != NULL) {
+ XFree(children);
+ }
+ return true;
+ }
+
+ bool GetWindowTitle(Window window, std::string* title) {
+ int status;
+ bool result = false;
+ XTextProperty window_name;
+ window_name.value = NULL;
+ if (window) {
+ status = XGetWMName(display_, window, &window_name);
+ if (status && window_name.value && window_name.nitems) {
+ int cnt;
+ char **list = NULL;
+ status = Xutf8TextPropertyToTextList(display_, &window_name, &list,
+ &cnt);
+ if (status >= Success && cnt && *list) {
+ if (cnt > 1) {
+ LOG(LS_INFO) << "Window has " << cnt
+ << " text properties, only using the first one.";
+ }
+ *title = *list;
+ result = true;
+ }
+ if (list != NULL) {
+ XFreeStringList(list);
+ }
+ }
+ if (window_name.value != NULL) {
+ XFree(window_name.value);
+ }
+ }
+ return result;
+ }
+
+ Window GetApplicationWindow(Window window) {
+ Window root, parent;
+ Window app_window = 0;
+ Window *children;
+ unsigned int num_children;
+ Atom type = None;
+ int format;
+ unsigned long nitems, after;
+ unsigned char *data;
+
+ int ret = XGetWindowProperty(display_, window,
+ wm_state_, 0L, 2,
+ False, wm_state_, &type, &format,
+ &nitems, &after, &data);
+ if (ret != Success) {
+ LOG(LS_ERROR) << "XGetWindowProperty failed with return code " << ret
+ << " for window " << window << ".";
+ return 0;
+ }
+ if (type != None) {
+ int64 state = static_cast<int64>(*data);
+ XFree(data);
+ return state == NormalState ? window : 0;
+ }
+ XFree(data);
+ if (!XQueryTree(display_, window, &root, &parent, &children,
+ &num_children)) {
+ LOG(LS_ERROR) << "Failed to query for child windows although window"
+ << "does not have a valid WM_STATE.";
+ return 0;
+ }
+ for (unsigned int i = 0; i < num_children; ++i) {
+ app_window = GetApplicationWindow(children[i]);
+ if (app_window) {
+ break;
+ }
+ }
+ if (children != NULL) {
+ XFree(children);
+ }
+ return app_window;
+ }
+
+ Atom wm_state_;
+ Atom net_wm_icon_;
+ Display* display_;
+ bool has_composite_extension_;
+ bool has_render_extension_;
+};
+
+LinuxWindowPicker::LinuxWindowPicker() : enumerator_(new XWindowEnumerator()) {
+}
+
+LinuxWindowPicker::~LinuxWindowPicker() {
+}
+
+bool LinuxWindowPicker::IsDesktopElement(_XDisplay* display, Window window) {
+ if (window == 0) {
+ LOG(LS_WARNING) << "Zero is never a valid window.";
+ return false;
+ }
+ XClassHint class_hint;
+ Status s = XGetClassHint(display, window, &class_hint);
+ bool result = false;
+ if (s == 0) {
+ // No hints, assume this is a normal application window.
+ return result;
+ }
+ static const std::string gnome_panel("gnome-panel");
+ static const std::string desktop_window("desktop_window");
+
+ if (gnome_panel.compare(class_hint.res_name) == 0 ||
+ desktop_window.compare(class_hint.res_name) == 0) {
+ result = true;
+ }
+ XFree(class_hint.res_name);
+ XFree(class_hint.res_class);
+ return result;
+}
+
+bool LinuxWindowPicker::Init() {
+ return enumerator_->Init();
+}
+
+bool LinuxWindowPicker::GetWindowList(WindowDescriptionList* descriptions) {
+ return enumerator_->EnumerateWindows(descriptions);
+}
+
+bool LinuxWindowPicker::GetDesktopList(DesktopDescriptionList* descriptions) {
+ return enumerator_->EnumerateDesktops(descriptions);
+}
+
+bool LinuxWindowPicker::IsVisible(const WindowId& id) {
+ return enumerator_->IsVisible(id);
+}
+
+bool LinuxWindowPicker::MoveToFront(const WindowId& id) {
+ return enumerator_->MoveToFront(id);
+}
+
+
+uint8* LinuxWindowPicker::GetWindowIcon(const WindowId& id, int* width,
+ int* height) {
+ return enumerator_->GetWindowIcon(id, width, height);
+}
+
+uint8* LinuxWindowPicker::GetWindowThumbnail(const WindowId& id, int width,
+ int height) {
+ return enumerator_->GetWindowThumbnail(id, width, height);
+}
+
+int LinuxWindowPicker::GetNumDesktops() {
+ return enumerator_->GetNumDesktops();
+}
+
+uint8* LinuxWindowPicker::GetDesktopThumbnail(const DesktopId& id,
+ int width,
+ int height) {
+ return enumerator_->GetDesktopThumbnail(id, width, height);
+}
+
+} // namespace talk_base
diff --git a/talk/base/linuxwindowpicker.h b/talk/base/linuxwindowpicker.h
new file mode 100644
index 0000000..ad92c6f
--- /dev/null
+++ b/talk/base/linuxwindowpicker.h
@@ -0,0 +1,66 @@
+/*
+ * libjingle
+ * Copyright 2010 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_BASE_LINUXWINDOWPICKER_H_
+#define TALK_BASE_LINUXWINDOWPICKER_H_
+
+#include "talk/base/basictypes.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/windowpicker.h"
+
+// Avoid include <X11/Xlib.h>.
+struct _XDisplay;
+typedef unsigned long Window;
+
+namespace talk_base {
+
+class XWindowEnumerator;
+
+class LinuxWindowPicker : public WindowPicker {
+ public:
+ LinuxWindowPicker();
+ ~LinuxWindowPicker();
+
+ static bool IsDesktopElement(_XDisplay* display, Window window);
+
+ virtual bool Init();
+ virtual bool IsVisible(const WindowId& id);
+ virtual bool MoveToFront(const WindowId& id);
+ virtual bool GetWindowList(WindowDescriptionList* descriptions);
+ virtual bool GetDesktopList(DesktopDescriptionList* descriptions);
+ uint8* GetWindowIcon(const WindowId& id, int* width, int* height);
+ uint8* GetWindowThumbnail(const WindowId& id, int width, int height);
+ int GetNumDesktops();
+ uint8* GetDesktopThumbnail(const DesktopId& id, int width, int height);
+
+ private:
+ scoped_ptr<XWindowEnumerator> enumerator_;
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_LINUXWINDOWPICKER_H_
diff --git a/talk/base/linuxwindowpicker_unittest.cc b/talk/base/linuxwindowpicker_unittest.cc
new file mode 100644
index 0000000..fa0d49a
--- /dev/null
+++ b/talk/base/linuxwindowpicker_unittest.cc
@@ -0,0 +1,46 @@
+/*
+ * libjingle
+ * Copyright 2010 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/base/gunit.h"
+#include "talk/base/linuxwindowpicker.h"
+#include "talk/base/logging.h"
+#include "talk/base/windowpicker.h"
+
+#ifndef LINUX
+#error Only for Linux
+#endif
+
+namespace talk_base {
+
+TEST(LinuxWindowPickerTest, TestGetWindowList) {
+ LinuxWindowPicker window_picker;
+ WindowDescriptionList descriptions;
+ window_picker.Init();
+ window_picker.GetWindowList(&descriptions);
+}
+
+} // namespace talk_base
diff --git a/talk/base/logging.cc b/talk/base/logging.cc
index b5c588c..f094042 100644
--- a/talk/base/logging.cc
+++ b/talk/base/logging.cc
@@ -51,7 +51,7 @@
#include "talk/base/stream.h"
#include "talk/base/stringencode.h"
#include "talk/base/stringutils.h"
-#include "talk/base/time.h"
+#include "talk/base/timeutils.h"
namespace talk_base {
diff --git a/talk/base/macasyncsocket.cc b/talk/base/macasyncsocket.cc
index e31be57..4924333 100644
--- a/talk/base/macasyncsocket.cc
+++ b/talk/base/macasyncsocket.cc
@@ -328,9 +328,11 @@
}
if (res) {
- // Add this socket to the run loop
- source_ = CFSocketCreateRunLoopSource(kCFAllocatorDefault, socket_, 0);
+ // Add this socket to the run loop, at priority 1 so that it will be
+ // queued behind any pending signals.
+ source_ = CFSocketCreateRunLoopSource(kCFAllocatorDefault, socket_, 1);
res = (source_ != NULL);
+ if (!res) errno = EINVAL;
}
if (res) {
diff --git a/talk/base/maccocoasocketserver.h b/talk/base/maccocoasocketserver.h
new file mode 100644
index 0000000..41c9f71
--- /dev/null
+++ b/talk/base/maccocoasocketserver.h
@@ -0,0 +1,106 @@
+/*
+ * libjingle
+ * Copyright 2007, 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.
+ */
+
+// A libjingle compatible SocketServer for OSX/iOS/Cocoa.
+
+#if !defined(USE_COCOA_THREADING) || (!defined(OSX) && !defined(IOS))
+#error You can only include this file on OSX or IOS, and must also define
+#error USE_COCOA_THREADING.
+#endif
+
+#import <Foundation/Foundation.h>
+
+#import "talk/base/messagequeue.h"
+#import "talk/base/socketserver.h"
+
+namespace talk_base {
+class MacCocoaSocketServer;
+}
+
+// MacCocoaSocketServerHelper serves as a delegate to NSMachPort or a target for
+// a timeout.
+@interface MacCocoaSocketServerHelper : NSObject {
+ // This is a weak reference. This works fine since the
+ // talk_base::MacCocoaSocketServer owns this object.
+ talk_base::MacCocoaSocketServer* socketServer; // weak.
+}
+
+@end
+
+namespace talk_base {
+
+// The name "SocketServer" is misleading for this class. This class inherits
+// from SocketServer, some variants of which create/use physical
+// sockets (specifically, PhysicalSocketServer). A general explanation
+// (courtesy of bpm) is that SocketServer is responsible for allowing a thread
+// to go into an efficient wait state while it waits for a timer to expire or an
+// incoming message from MessageQueue. For GUI applications, the main thread
+// must continue to pump the main event loop during this wait state, hence the
+// need for specialized SocketServers to run on the main thread.
+//
+// This particular socketServer however cannot handle a generalized wait state.
+// It can only handle Wait when called with cms == 0, or when cms > 0 and
+// process_io is false. In the former case, the process_io argument is ignored,
+// and in the latter case, the thread will sleep for cms milliSeconds.
+//
+// Use this class in a Cocoa application that uses libjingle's Task and
+// MessageQueue, on the main thread. The typical usage is something like this:
+//
+// talk_base::Thread* current = talk_base::Thread::Current();
+// MacCocoaSocketServer* ss =
+// new talk_base::MacCocoaSocketServer(current);
+// current->set_socketserver(ss);
+//
+// // Now schedule some libjingle tasks, then call
+//
+// [NSApp run];
+
+class MacCocoaSocketServer : public SocketServer {
+ public:
+ explicit MacCocoaSocketServer(MessageQueue* message_queue);
+ virtual ~MacCocoaSocketServer();
+
+ // SocketServer Interface. We don't create any synchronous sockets.
+ virtual Socket* CreateSocket(int type) { return NULL; }
+ virtual AsyncSocket* CreateAsyncSocket(int type);
+
+ virtual bool Wait(int cms, bool process_io);
+ virtual void WakeUp();
+
+ void Pump();
+
+ private:
+ // message_queue_ is not owned by this object.
+ // It is cached from the constructor argument.
+ MessageQueue* message_queue_; // weak.
+ MacCocoaSocketServerHelper* helper_;
+ NSTimer* timer_;
+
+ DISALLOW_EVIL_CONSTRUCTORS(MacCocoaSocketServer);
+};
+
+} // namespace talk_base
diff --git a/talk/base/maccocoasocketserver.mm b/talk/base/maccocoasocketserver.mm
new file mode 100644
index 0000000..6a91d43
--- /dev/null
+++ b/talk/base/maccocoasocketserver.mm
@@ -0,0 +1,127 @@
+/*
+ * libjingle
+ * Copyright 2007, 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.
+ */
+
+#import <assert.h>
+
+#import "talk/base/maccocoasocketserver.h"
+#import "talk/base/logging.h"
+#import "talk/base/macasyncsocket.h"
+
+static const double kTimerIntervalSecs = 0.1;
+
+@implementation MacCocoaSocketServerHelper
+
+- (id)initWithSocketServer:(talk_base::MacCocoaSocketServer*)ss {
+ self = [super init];
+ if (self) {
+ socketServer = ss;
+ }
+ return self;
+}
+
+- (void)timerFired:(NSTimer*)timer {
+ socketServer->Pump();
+}
+
+- (void)wakeUp {
+ socketServer->Pump();
+}
+
+@end
+
+namespace talk_base {
+
+MacCocoaSocketServer::MacCocoaSocketServer(MessageQueue* message_queue) :
+ message_queue_(message_queue) {
+ helper_ = [[MacCocoaSocketServerHelper alloc] initWithSocketServer:this];
+
+ NSTimer* timer =
+ [NSTimer scheduledTimerWithTimeInterval:kTimerIntervalSecs
+ target:helper_
+ selector:@selector(timerFired:)
+ userInfo:nil
+ repeats:YES];
+ timer_ = [timer retain];
+}
+
+MacCocoaSocketServer::~MacCocoaSocketServer() {
+ [timer_ invalidate];
+ [timer_ release];
+ [helper_ release];
+}
+
+AsyncSocket* MacCocoaSocketServer::CreateAsyncSocket(int type) {
+ assert(type == SOCK_STREAM);
+ return new MacAsyncSocket();
+}
+
+bool MacCocoaSocketServer::Wait(int cms, bool process_io) {
+ // Ideally we would have some way to run the UI loop for |cms| milliSeconds,
+ // or until WakeUp() is called (whichever is earlier).
+ // But there is no good solution for that - stopping/restarting the
+ // NSApp run loop or calling nextEventMatchingTask both have significant
+ // overhead, resulting in high CPU utilization when there are a lot of
+ // libjingle messages (hence WakeUp and Wait calls) floating around.
+
+ // Simply calling "usleep" will block the UI, which is OK when |process_io|
+ // is false.
+
+ if (cms != 0) {
+ assert(cms > 0 && !process_io);
+ if (cms < 0 || process_io) {
+ return false;
+ }
+ usleep(cms * 1000);
+ }
+
+ return true;
+}
+
+void MacCocoaSocketServer::WakeUp() {
+ [helper_ performSelectorOnMainThread:@selector(wakeUp)
+ withObject:nil
+ waitUntilDone:NO];
+}
+
+void MacCocoaSocketServer::Pump() {
+ // Process messages.
+
+ Message msg;
+ // We don't want to process an unbounded number of messages - while we do that
+ // the UI remains blocked. So we only process as many messages as are in the
+ // queue when we start.
+ //
+ // max(1,..) ensures we run Get() at least once, this is needed to check
+ // for "sent" messages that otherwise are not included into size() result.
+ for (size_t max_messages_to_process = _max<size_t>(1, message_queue_->size());
+ max_messages_to_process > 0 && message_queue_->Get(&msg, 0);
+ --max_messages_to_process) {
+ message_queue_->Dispatch(&msg);
+ }
+}
+
+} // namespace talk_base
diff --git a/talk/base/maccocoathreadhelper.h b/talk/base/maccocoathreadhelper.h
new file mode 100644
index 0000000..a3cb3a8
--- /dev/null
+++ b/talk/base/maccocoathreadhelper.h
@@ -0,0 +1,49 @@
+/*
+ * libjingle
+ * Copyright 2008 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.
+ */
+
+// Helper function for using Cocoa with Posix threads. This header should be
+// included from C/C++ files that want to use some Cocoa functionality without
+// using the .mm extension (mostly for files that are compiled on multiple
+// platforms).
+
+#ifndef TALK_BASE_MACCOCOATHREADHELPER_H__
+#define TALK_BASE_MACCOCOATHREADHELPER_H__
+
+#if !defined(USE_COCOA_THREADING) || (!defined(OSX) && !defined(IOS))
+#error You can only include this file on OSX or IOS, and must also define
+#error USE_COCOA_THREADING.
+#endif
+
+namespace talk_base {
+
+// Cocoa must be "put into multithreading mode" before Cocoa functionality can
+// be used on POSIX threads. This function does that.
+void InitCocoaMultiThreading();
+
+} // namespace talk_base
+
+#endif // TALK_BASE_MACCOCOATHREADHELPER_H__
diff --git a/talk/base/maccocoathreadhelper.mm b/talk/base/maccocoathreadhelper.mm
new file mode 100644
index 0000000..e8482ce
--- /dev/null
+++ b/talk/base/maccocoathreadhelper.mm
@@ -0,0 +1,78 @@
+/*
+ * libjingle
+ * Copyright 2007, 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.
+ */
+// Helper function for using Cocoa with Posix threading.
+
+#import <assert.h>
+#import <Foundation/Foundation.h>
+
+#import "talk/base/maccocoathreadhelper.h"
+
+// A dummy thread object which essentially does nothing.
+// This is used in InitCocoaMultiThreading method.
+@interface DummyThreadObject : NSObject {
+}
+
++ (void)dummyFunc:(NSObject*)obj;
+
+@end
+
+@implementation DummyThreadObject
+
++ (void)dummyFunc:(NSObject*)obj {
+ // nothing to do
+}
+
+@end
+
+namespace talk_base {
+
+// Cocoa must be "put into multithreading mode" before Cocoa functionality can
+// be used on POSIX threads. The way to do that is to spawn one thread that may
+// immediately exit.
+void InitCocoaMultiThreading() {
+ if ([NSThread isMultiThreaded] == NO) {
+ // The sole purpose of this autorelease pool is to avoid a console
+ // message on Leopard that tells us we're autoreleasing the thread
+ // with no autorelease pool in place; we can't set up an autorelease
+ // pool before this, because this is executed from an initializer,
+ // which is run before main. This means we leak an autorelease pool,
+ // and one thread, and if other objects are set up in initializers after
+ // this they'll be silently added to this pool and never released.
+
+ // Doing NSAutoreleasePool* hack = [[NSAutoreleasePool alloc] init];
+ // causes unused variable error.
+ NSAutoreleasePool* hack;
+ hack = [[NSAutoreleasePool alloc] init];
+ [NSThread detachNewThreadSelector:@selector(dummyFunc:)
+ toTarget:[DummyThreadObject class]
+ withObject:nil];
+ }
+
+ assert([NSThread isMultiThreaded]);
+}
+
+} // namespace talk_base
diff --git a/talk/base/macsocketserver.cc b/talk/base/macsocketserver.cc
index 154b83d..5b2ec03 100644
--- a/talk/base/macsocketserver.cc
+++ b/talk/base/macsocketserver.cc
@@ -41,6 +41,47 @@
ASSERT(found == 1);
}
+bool MacBaseSocketServer::SetPosixSignalHandler(int signum,
+ void (*handler)(int)) {
+ Dispatcher* dispatcher = signal_dispatcher();
+ if (!PhysicalSocketServer::SetPosixSignalHandler(signum, handler)) {
+ return false;
+ }
+
+ // Only register the FD once, when the first custom handler is installed.
+ if (!dispatcher && (dispatcher = signal_dispatcher())) {
+ CFFileDescriptorContext ctx = { 0 };
+ ctx.info = this;
+
+ CFFileDescriptorRef desc = CFFileDescriptorCreate(
+ kCFAllocatorDefault,
+ dispatcher->GetDescriptor(),
+ false,
+ &MacBaseSocketServer::FileDescriptorCallback,
+ &ctx);
+ if (!desc) {
+ return false;
+ }
+
+ CFFileDescriptorEnableCallBacks(desc, kCFFileDescriptorReadCallBack);
+ CFRunLoopSourceRef ref =
+ CFFileDescriptorCreateRunLoopSource(kCFAllocatorDefault, desc, 0);
+
+ if (!ref) {
+ CFRelease(desc);
+ return false;
+ }
+
+ CFRunLoopAddSource(CFRunLoopGetCurrent(), ref, kCFRunLoopCommonModes);
+ CFRelease(desc);
+ CFRelease(ref);
+ }
+
+ return true;
+}
+
+// Used to disable socket events from waking our message queue when
+// process_io is false. Does not disable signal event handling though.
void MacBaseSocketServer::EnableSocketCallbacks(bool enable) {
for (std::set<MacAsyncSocket*>::iterator it = sockets().begin();
it != sockets().end(); ++it) {
@@ -52,6 +93,21 @@
}
}
+void MacBaseSocketServer::FileDescriptorCallback(CFFileDescriptorRef fd,
+ CFOptionFlags flags,
+ void* context) {
+ MacBaseSocketServer* this_ss =
+ reinterpret_cast<MacBaseSocketServer*>(context);
+ ASSERT(this_ss);
+ Dispatcher* signal_dispatcher = this_ss->signal_dispatcher();
+ ASSERT(signal_dispatcher);
+
+ signal_dispatcher->OnPreEvent(DE_READ);
+ signal_dispatcher->OnEvent(DE_READ, 0);
+ CFFileDescriptorEnableCallBacks(fd, kCFFileDescriptorReadCallBack);
+}
+
+
///////////////////////////////////////////////////////////////////////////////
// MacCFSocketServer
///////////////////////////////////////////////////////////////////////////////
@@ -225,6 +281,9 @@
// MacCarbonAppSocketServer
///////////////////////////////////////////////////////////////////////////////
+// Carbon is deprecated for x64. Switch to Cocoa
+#if !defined(__x86_64__)
+
MacCarbonAppSocketServer::MacCarbonAppSocketServer()
: event_queue_(GetCurrentEventQueue()) {
// Install event handler
@@ -296,6 +355,7 @@
}
ReleaseEvent(wake_up);
}
+#endif
///////////////////////////////////////////////////////////////////////////////
// MacNotificationsSocketServer
diff --git a/talk/base/macsocketserver.h b/talk/base/macsocketserver.h
index 6a4a729..53118b8 100644
--- a/talk/base/macsocketserver.h
+++ b/talk/base/macsocketserver.h
@@ -31,6 +31,9 @@
void RegisterSocket(MacAsyncSocket* socket);
void UnregisterSocket(MacAsyncSocket* socket);
+ // PhysicalSocketServer Overrides
+ virtual bool SetPosixSignalHandler(int signum, void (*handler)(int));
+
protected:
void EnableSocketCallbacks(bool enable);
const std::set<MacAsyncSocket*>& sockets() {
@@ -38,6 +41,10 @@
}
private:
+ static void FileDescriptorCallback(CFFileDescriptorRef ref,
+ CFOptionFlags flags,
+ void* context);
+
std::set<MacAsyncSocket*> sockets_;
};
diff --git a/talk/base/macsocketserver_unittest.cc b/talk/base/macsocketserver_unittest.cc
new file mode 100644
index 0000000..a204c24
--- /dev/null
+++ b/talk/base/macsocketserver_unittest.cc
@@ -0,0 +1,195 @@
+/*
+ * libjingle
+ * Copyright 2009, 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/base/gunit.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/socket_unittest.h"
+#include "talk/base/thread.h"
+#include "talk/base/macsocketserver.h"
+
+namespace talk_base {
+
+class WakeThread : public Thread {
+ public:
+ WakeThread(SocketServer* ss) : ss_(ss) {
+ }
+ void Run() {
+ ss_->WakeUp();
+ }
+ private:
+ SocketServer* ss_;
+};
+
+// Test that MacCFSocketServer::Wait works as expected.
+TEST(MacCFSocketServerTest, TestWait) {
+ MacCFSocketServer server;
+ uint32 start = Time();
+ server.Wait(1000, true);
+ EXPECT_GE(TimeSince(start), 1000);
+}
+
+// Test that MacCFSocketServer::Wakeup works as expected.
+TEST(MacCFSocketServerTest, TestWakeup) {
+ MacCFSocketServer server;
+ WakeThread thread(&server);
+ uint32 start = Time();
+ thread.Start();
+ server.Wait(10000, true);
+ EXPECT_LT(TimeSince(start), 10000);
+}
+
+// Test that MacCarbonSocketServer::Wait works as expected.
+TEST(MacCarbonSocketServerTest, TestWait) {
+ MacCarbonSocketServer server;
+ uint32 start = Time();
+ server.Wait(1000, true);
+ EXPECT_GE(TimeSince(start), 1000);
+}
+
+// Test that MacCarbonSocketServer::Wakeup works as expected.
+TEST(MacCarbonSocketServerTest, TestWakeup) {
+ MacCarbonSocketServer server;
+ WakeThread thread(&server);
+ uint32 start = Time();
+ thread.Start();
+ server.Wait(10000, true);
+ EXPECT_LT(TimeSince(start), 10000);
+}
+
+// Test that MacCarbonAppSocketServer::Wait works as expected.
+TEST(MacCarbonAppSocketServerTest, TestWait) {
+ MacCarbonAppSocketServer server;
+ uint32 start = Time();
+ server.Wait(1000, true);
+ EXPECT_GE(TimeSince(start), 1000);
+}
+
+// Test that MacCarbonAppSocketServer::Wakeup works as expected.
+TEST(MacCarbonAppSocketServerTest, TestWakeup) {
+ MacCarbonAppSocketServer server;
+ WakeThread thread(&server);
+ uint32 start = Time();
+ thread.Start();
+ server.Wait(10000, true);
+ EXPECT_LT(TimeSince(start), 10000);
+}
+
+// Test that MacAsyncSocket passes all the generic Socket tests.
+class MacAsyncSocketTest : public SocketTest {
+ protected:
+ MacAsyncSocketTest()
+ : server_(CreateSocketServer()),
+ scope_(server_.get()) {}
+ // Override for other implementations of MacBaseSocketServer.
+ virtual MacBaseSocketServer* CreateSocketServer() {
+ return new MacCFSocketServer();
+ };
+ talk_base::scoped_ptr<MacBaseSocketServer> server_;
+ SocketServerScope scope_;
+};
+
+TEST_F(MacAsyncSocketTest, TestConnect) {
+ SocketTest::TestConnect();
+}
+
+TEST_F(MacAsyncSocketTest, TestConnectWithDnsLookup) {
+ SocketTest::TestConnectWithDnsLookup();
+}
+
+TEST_F(MacAsyncSocketTest, TestConnectFail) {
+ SocketTest::TestConnectFail();
+}
+
+// Reenable once we have mac async dns
+TEST_F(MacAsyncSocketTest, DISABLED_TestConnectWithDnsLookupFail) {
+ SocketTest::TestConnectWithDnsLookupFail();
+}
+
+TEST_F(MacAsyncSocketTest, TestConnectWithClosedSocket) {
+ SocketTest::TestConnectWithClosedSocket();
+}
+
+// Flaky at the moment (10% failure rate). Seems the client doesn't get
+// signalled in a timely manner...
+TEST_F(MacAsyncSocketTest, DISABLED_TestServerCloseDuringConnect) {
+ SocketTest::TestServerCloseDuringConnect();
+}
+// Flaky at the moment (0.5% failure rate). Seems the client doesn't get
+// signalled in a timely manner...
+TEST_F(MacAsyncSocketTest, TestClientCloseDuringConnect) {
+ SocketTest::TestClientCloseDuringConnect();
+}
+
+TEST_F(MacAsyncSocketTest, TestServerClose) {
+ SocketTest::TestServerClose();
+}
+
+TEST_F(MacAsyncSocketTest, TestCloseInClosedCallback) {
+ SocketTest::TestCloseInClosedCallback();
+}
+
+TEST_F(MacAsyncSocketTest, TestSocketServerWait) {
+ SocketTest::TestSocketServerWait();
+}
+
+TEST_F(MacAsyncSocketTest, TestTcp) {
+ SocketTest::TestTcp();
+}
+
+TEST_F(MacAsyncSocketTest, TestSingleFlowControlCallback) {
+ SocketTest::TestSingleFlowControlCallback();
+}
+
+TEST_F(MacAsyncSocketTest, DISABLED_TestUdp) {
+ SocketTest::TestUdp();
+}
+
+TEST_F(MacAsyncSocketTest, DISABLED_TestGetSetOptions) {
+ SocketTest::TestGetSetOptions();
+}
+
+class MacCarbonAsyncSocketTest : public MacAsyncSocketTest {
+ virtual MacBaseSocketServer* CreateSocketServer() {
+ return new MacCarbonSocketServer();
+ };
+};
+
+TEST_F(MacCarbonAsyncSocketTest, TestSocketServerWait) {
+ SocketTest::TestSocketServerWait();
+}
+
+class MacCarbonAppAsyncSocketTest : public MacAsyncSocketTest {
+ virtual MacBaseSocketServer* CreateSocketServer() {
+ return new MacCarbonAppSocketServer();
+ };
+};
+
+TEST_F(MacCarbonAppAsyncSocketTest, TestSocketServerWait) {
+ SocketTest::TestSocketServerWait();
+}
+
+} // namespace talk_base
diff --git a/talk/base/macutils_unittest.cc b/talk/base/macutils_unittest.cc
new file mode 100644
index 0000000..c66000a
--- /dev/null
+++ b/talk/base/macutils_unittest.cc
@@ -0,0 +1,54 @@
+/*
+ * libjingle
+ * Copyright 2009, 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/base/gunit.h"
+#include "talk/base/macutils.h"
+
+TEST(MacUtilsTest, GetOsVersionName) {
+ talk_base::MacOSVersionName ver = talk_base::GetOSVersionName();
+ EXPECT_NE(talk_base::kMacOSUnknown, ver);
+}
+
+TEST(MacUtilsTest, GetQuickTimeVersion) {
+ std::string version;
+ EXPECT_TRUE(talk_base::GetQuickTimeVersion(&version));
+}
+
+TEST(MacUtilsTest, RunAppleScriptCompileError) {
+ std::string script("set value to to 5");
+ EXPECT_FALSE(talk_base::RunAppleScript(script));
+}
+
+TEST(MacUtilsTest, RunAppleScriptRuntimeError) {
+ std::string script("set value to 5 / 0");
+ EXPECT_FALSE(talk_base::RunAppleScript(script));
+}
+
+TEST(MacUtilsTest, RunAppleScriptSuccess) {
+ std::string script("set value to 5");
+ EXPECT_TRUE(talk_base::RunAppleScript(script));
+}
diff --git a/talk/base/macwindowpicker.cc b/talk/base/macwindowpicker.cc
new file mode 100644
index 0000000..d9cb752
--- /dev/null
+++ b/talk/base/macwindowpicker.cc
@@ -0,0 +1,241 @@
+// Copyright 2010 Google Inc. All Rights Reserved
+
+
+#include "talk/base/macwindowpicker.h"
+
+#include <ApplicationServices/ApplicationServices.h>
+#include <CoreFoundation/CoreFoundation.h>
+#include <dlfcn.h>
+
+#include "talk/base/logging.h"
+#include "talk/base/macutils.h"
+
+namespace talk_base {
+
+static const char* kCoreGraphicsName =
+ "/System/Library/Frameworks/ApplicationServices.framework/Frameworks/"
+ "CoreGraphics.framework/CoreGraphics";
+
+static const char* kWindowListCopyWindowInfo = "CGWindowListCopyWindowInfo";
+static const char* kWindowListCreateDescriptionFromArray =
+ "CGWindowListCreateDescriptionFromArray";
+
+// Function pointer for holding the CGWindowListCopyWindowInfo function.
+typedef CFArrayRef(*CGWindowListCopyWindowInfoProc)(CGWindowListOption,
+ CGWindowID);
+
+// Function pointer for holding the CGWindowListCreateDescriptionFromArray
+// function.
+typedef CFArrayRef(*CGWindowListCreateDescriptionFromArrayProc)(CFArrayRef);
+
+MacWindowPicker::MacWindowPicker() : lib_handle_(NULL), get_window_list_(NULL),
+ get_window_list_desc_(NULL) {
+}
+
+MacWindowPicker::~MacWindowPicker() {
+ if (lib_handle_ != NULL) {
+ dlclose(lib_handle_);
+ }
+}
+
+bool MacWindowPicker::Init() {
+ // TODO: If this class grows to use more dynamically functions
+ // from the CoreGraphics framework, consider using
+ // talk/base/latebindingsymboltable.h.
+ lib_handle_ = dlopen(kCoreGraphicsName, RTLD_NOW);
+ if (lib_handle_ == NULL) {
+ LOG(LS_ERROR) << "Could not load CoreGraphics";
+ return false;
+ }
+
+ get_window_list_ = dlsym(lib_handle_, kWindowListCopyWindowInfo);
+ get_window_list_desc_ =
+ dlsym(lib_handle_, kWindowListCreateDescriptionFromArray);
+ if (get_window_list_ == NULL || get_window_list_desc_ == NULL) {
+ // The CGWindowListCopyWindowInfo and the
+ // CGWindowListCreateDescriptionFromArray functions was introduced
+ // in Leopard(10.5) so this is a normal failure on Tiger.
+ LOG(LS_INFO) << "Failed to load Core Graphics symbols";
+ dlclose(lib_handle_);
+ lib_handle_ = NULL;
+ return false;
+ }
+
+ return true;
+}
+
+bool MacWindowPicker::IsVisible(const WindowId& id) {
+ // Init if we're not already inited.
+ if (get_window_list_desc_ == NULL && !Init()) {
+ return false;
+ }
+ CGWindowID ids[1];
+ ids[0] = id.id();
+ CFArrayRef window_id_array =
+ CFArrayCreate(NULL, reinterpret_cast<const void **>(&ids), 1, NULL);
+
+ CFArrayRef window_array =
+ reinterpret_cast<CGWindowListCreateDescriptionFromArrayProc>(
+ get_window_list_desc_)(window_id_array);
+ if (window_array == NULL || 0 == CFArrayGetCount(window_array)) {
+ // Could not find the window. It might have been closed.
+ LOG(LS_INFO) << "Window not found";
+ CFRelease(window_id_array);
+ return false;
+ }
+
+ CFDictionaryRef window = reinterpret_cast<CFDictionaryRef>(
+ CFArrayGetValueAtIndex(window_array, 0));
+ CFBooleanRef is_visible = reinterpret_cast<CFBooleanRef>(
+ CFDictionaryGetValue(window, kCGWindowIsOnscreen));
+
+ // Check that the window is visible. If not we might crash.
+ bool visible = false;
+ if (is_visible != NULL) {
+ visible = CFBooleanGetValue(is_visible);
+ }
+ CFRelease(window_id_array);
+ CFRelease(window_array);
+ return visible;
+}
+
+bool MacWindowPicker::MoveToFront(const WindowId& id) {
+ // Init if we're not already initialized.
+ if (get_window_list_desc_ == NULL && !Init()) {
+ return false;
+ }
+ CGWindowID ids[1];
+ ids[0] = id.id();
+ CFArrayRef window_id_array =
+ CFArrayCreate(NULL, reinterpret_cast<const void **>(&ids), 1, NULL);
+
+ CFArrayRef window_array =
+ reinterpret_cast<CGWindowListCreateDescriptionFromArrayProc>(
+ get_window_list_desc_)(window_id_array);
+ if (window_array == NULL || 0 == CFArrayGetCount(window_array)) {
+ // Could not find the window. It might have been closed.
+ LOG(LS_INFO) << "Window not found";
+ CFRelease(window_id_array);
+ return false;
+ }
+
+ CFDictionaryRef window = reinterpret_cast<CFDictionaryRef>(
+ CFArrayGetValueAtIndex(window_array, 0));
+ CFStringRef window_name_ref = reinterpret_cast<CFStringRef>(
+ CFDictionaryGetValue(window, kCGWindowName));
+ CFNumberRef application_pid = reinterpret_cast<CFNumberRef>(
+ CFDictionaryGetValue(window, kCGWindowOwnerPID));
+
+ int pid_val;
+ CFNumberGetValue(application_pid, kCFNumberIntType, &pid_val);
+ std::string window_name;
+ ToUtf8(window_name_ref, &window_name);
+
+ // Build an applescript that sets the selected window to front
+ // within the application. Then set the application to front.
+ bool result = true;
+ std::stringstream ss;
+ ss << "tell application \"System Events\"\n"
+ << "set proc to the first item of (every process whose unix id is "
+ << pid_val
+ << ")\n"
+ << "tell proc to perform action \"AXRaise\" of window \""
+ << window_name
+ << "\"\n"
+ << "set the frontmost of proc to true\n"
+ << "end tell";
+ if (!RunAppleScript(ss.str())) {
+ // This might happen to for example X applications where the X
+ // server spawns of processes with their own PID but the X server
+ // is still registered as owner to the application windows. As a
+ // workaround, we put the X server process to front, meaning that
+ // all X applications will show up. The drawback with this
+ // workaround is that the application that we really wanted to set
+ // to front might be behind another X application.
+ ProcessSerialNumber psn;
+ pid_t pid = pid_val;
+ int res = GetProcessForPID(pid, &psn);
+ if (res != 0) {
+ LOG(LS_ERROR) << "Failed getting process for pid";
+ result = false;
+ }
+ res = SetFrontProcess(&psn);
+ if (res != 0) {
+ LOG(LS_ERROR) << "Failed setting process to front";
+ result = false;
+ }
+ }
+ CFRelease(window_id_array);
+ CFRelease(window_array);
+ return result;
+}
+
+bool MacWindowPicker::GetDesktopList(DesktopDescriptionList* descriptions) {
+ const uint32_t kMaxDisplays = 128;
+ CGDirectDisplayID active_displays[kMaxDisplays];
+ uint32_t display_count = 0;
+
+ CGError err = CGGetActiveDisplayList(kMaxDisplays,
+ active_displays,
+ &display_count);
+ if (err != kCGErrorSuccess) {
+ LOG_E(LS_ERROR, OS, err) << "Failed to enumerate the active displays.";
+ return false;
+ }
+ for (uint32_t i = 0; i < display_count; ++i) {
+ DesktopId id(active_displays[i], static_cast<int>(i));
+ // TODO: Figure out an appropriate desktop title.
+ DesktopDescription desc(id, "");
+ descriptions->push_back(desc);
+ }
+ return display_count > 0;
+}
+
+bool MacWindowPicker::GetWindowList(WindowDescriptionList* descriptions) {
+ // Init if we're not already inited.
+ if (get_window_list_ == NULL && !Init()) {
+ return false;
+ }
+
+ // Only get onscreen, non-desktop windows.
+ CFArrayRef window_array =
+ reinterpret_cast<CGWindowListCopyWindowInfoProc>(get_window_list_)(
+ kCGWindowListOptionOnScreenOnly | kCGWindowListExcludeDesktopElements,
+ kCGNullWindowID);
+ if (window_array == NULL) {
+ return false;
+ }
+
+ // Check windows to make sure they have an id, title, and use window layer 0.
+ CFIndex i;
+ CFIndex count = CFArrayGetCount(window_array);
+ for (i = 0; i < count; ++i) {
+ CFDictionaryRef window = reinterpret_cast<CFDictionaryRef>(
+ CFArrayGetValueAtIndex(window_array, i));
+ CFStringRef window_title = reinterpret_cast<CFStringRef>(
+ CFDictionaryGetValue(window, kCGWindowName));
+ CFNumberRef window_id = reinterpret_cast<CFNumberRef>(
+ CFDictionaryGetValue(window, kCGWindowNumber));
+ CFNumberRef window_layer = reinterpret_cast<CFNumberRef>(
+ CFDictionaryGetValue(window, kCGWindowLayer));
+ if (window_title != NULL && window_id != NULL && window_layer != NULL) {
+ std::string title_str;
+ int id_val, layer_val;
+ ToUtf8(window_title, &title_str);
+ CFNumberGetValue(window_id, kCFNumberIntType, &id_val);
+ CFNumberGetValue(window_layer, kCFNumberIntType, &layer_val);
+
+ // Discard windows without a title.
+ if (layer_val == 0 && title_str.length() > 0) {
+ WindowId id(static_cast<CGWindowID>(id_val));
+ WindowDescription desc(id, title_str);
+ descriptions->push_back(desc);
+ }
+ }
+ }
+
+ CFRelease(window_array);
+ return true;
+}
+
+} // namespace talk_base
diff --git a/talk/base/macwindowpicker.h b/talk/base/macwindowpicker.h
new file mode 100644
index 0000000..d1ca6b8
--- /dev/null
+++ b/talk/base/macwindowpicker.h
@@ -0,0 +1,29 @@
+// Copyright 2010 Google Inc. All Rights Reserved
+
+
+#ifndef TALK_BASE_MACWINDOWPICKER_H_
+#define TALK_BASE_MACWINDOWPICKER_H_
+
+#include "talk/base/windowpicker.h"
+
+namespace talk_base {
+
+class MacWindowPicker : public WindowPicker {
+ public:
+ MacWindowPicker();
+ ~MacWindowPicker();
+ virtual bool Init();
+ virtual bool IsVisible(const WindowId& id);
+ virtual bool MoveToFront(const WindowId& id);
+ virtual bool GetWindowList(WindowDescriptionList* descriptions);
+ virtual bool GetDesktopList(DesktopDescriptionList* descriptions);
+
+ private:
+ void* lib_handle_;
+ void* get_window_list_;
+ void* get_window_list_desc_;
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_MACWINDOWPICKER_H_
diff --git a/talk/base/macwindowpicker_unittest.cc b/talk/base/macwindowpicker_unittest.cc
new file mode 100644
index 0000000..9cb67db
--- /dev/null
+++ b/talk/base/macwindowpicker_unittest.cc
@@ -0,0 +1,39 @@
+// Copyright 2010 Google Inc. All Rights Reserved
+
+
+#include "talk/base/gunit.h"
+#include "talk/base/logging.h"
+#include "talk/base/macutils.h"
+#include "talk/base/macwindowpicker.h"
+#include "talk/base/windowpicker.h"
+
+#ifndef OSX
+#error Only for Mac OSX
+#endif
+
+namespace talk_base {
+
+bool IsLeopardOrLater() {
+ return GetOSVersionName() >= kMacOSLeopard;
+}
+
+// Test that this works on new versions and fails acceptably on old versions.
+TEST(MacWindowPickerTest, TestGetWindowList) {
+ MacWindowPicker picker, picker2;
+ WindowDescriptionList descriptions;
+ if (IsLeopardOrLater()) {
+ EXPECT_TRUE(picker.Init());
+ EXPECT_TRUE(picker.GetWindowList(&descriptions));
+ EXPECT_TRUE(picker2.GetWindowList(&descriptions)); // Init is optional
+ } else {
+ EXPECT_FALSE(picker.Init());
+ EXPECT_FALSE(picker.GetWindowList(&descriptions));
+ EXPECT_FALSE(picker2.GetWindowList(&descriptions));
+ }
+}
+
+// TODO: Add verification of the actual parsing, ie, add
+// functionality to inject a fake get_window_array function which
+// provide a pre-constructed list of windows.
+
+} // namespace talk_base
diff --git a/talk/base/mathutils.h b/talk/base/mathutils.h
new file mode 100644
index 0000000..eeb110a
--- /dev/null
+++ b/talk/base/mathutils.h
@@ -0,0 +1,37 @@
+/*
+ * libjingle
+ * Copyright 2005 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_BASE_MATHUTILS_H_
+#define TALK_BASE_MATHUTILS_H_
+
+#include <math.h>
+
+#ifndef M_PI
+#define M_PI 3.14159265359f
+#endif
+
+#endif // TALK_BASE_MATHUTILS_H_
diff --git a/talk/base/messagequeue.h b/talk/base/messagequeue.h
index 54d4860..2857182 100644
--- a/talk/base/messagequeue.h
+++ b/talk/base/messagequeue.h
@@ -39,9 +39,10 @@
#include "talk/base/criticalsection.h"
#include "talk/base/messagehandler.h"
#include "talk/base/scoped_ptr.h"
+#include "talk/base/scoped_ref_ptr.h"
#include "talk/base/sigslot.h"
#include "talk/base/socketserver.h"
-#include "talk/base/time.h"
+#include "talk/base/timeutils.h"
namespace talk_base {
@@ -98,6 +99,17 @@
scoped_ptr<T> data_;
};
+// Like ScopedMessageData, but for reference counted pointers.
+template <class T>
+class ScopedRefMessageData : public MessageData {
+ public:
+ explicit ScopedRefMessageData(T* data) : data_(data) { }
+ const scoped_refptr<T>& data() const { return data_; }
+ scoped_refptr<T>& data() { return data_; }
+ private:
+ scoped_refptr<T> data_;
+};
+
template<class T>
inline MessageData* WrapMessageData(const T& data) {
return new TypedMessageData<T>(data);
diff --git a/talk/base/messagequeue_unittest.cc b/talk/base/messagequeue_unittest.cc
index 7414618..1ca65ea 100644
--- a/talk/base/messagequeue_unittest.cc
+++ b/talk/base/messagequeue_unittest.cc
@@ -27,7 +27,7 @@
#include "talk/base/gunit.h"
#include "talk/base/logging.h"
-#include "talk/base/time.h"
+#include "talk/base/timeutils.h"
#include "talk/base/messagequeue.h"
using namespace talk_base;
diff --git a/talk/base/multipart.cc b/talk/base/multipart.cc
new file mode 100644
index 0000000..d280ff3
--- /dev/null
+++ b/talk/base/multipart.cc
@@ -0,0 +1,268 @@
+// libjingle
+// Copyright 2004--2010, 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/base/common.h"
+#include "talk/base/httpcommon.h"
+#include "talk/base/multipart.h"
+
+namespace talk_base {
+
+///////////////////////////////////////////////////////////////////////////////
+// MultipartStream
+///////////////////////////////////////////////////////////////////////////////
+
+MultipartStream::MultipartStream(const std::string& type,
+ const std::string& boundary)
+ : type_(type),
+ boundary_(boundary),
+ adding_(true),
+ current_(0),
+ position_(0) {
+ // The content type should be multipart/*.
+ ASSERT(0 == strncmp(type_.c_str(), "multipart/", 10));
+}
+
+MultipartStream::~MultipartStream() {
+ Close();
+}
+
+void MultipartStream::GetContentType(std::string* content_type) {
+ ASSERT(NULL != content_type);
+ content_type->assign(type_);
+ content_type->append("; boundary=");
+ content_type->append(boundary_);
+}
+
+bool MultipartStream::AddPart(StreamInterface* data_stream,
+ const std::string& content_disposition,
+ const std::string& content_type) {
+ if (!AddPart("", content_disposition, content_type))
+ return false;
+ parts_.push_back(data_stream);
+ data_stream->SignalEvent.connect(this, &MultipartStream::OnEvent);
+ return true;
+}
+
+bool MultipartStream::AddPart(const std::string& data,
+ const std::string& content_disposition,
+ const std::string& content_type) {
+ ASSERT(adding_);
+ if (!adding_)
+ return false;
+ std::stringstream ss;
+ if (!parts_.empty()) {
+ ss << "\r\n";
+ }
+ ss << "--" << boundary_ << "\r\n";
+ if (!content_disposition.empty()) {
+ ss << ToString(HH_CONTENT_DISPOSITION) << ": "
+ << content_disposition << "\r\n";
+ }
+ if (!content_type.empty()) {
+ ss << ToString(HH_CONTENT_TYPE) << ": "
+ << content_type << "\r\n";
+ }
+ ss << "\r\n" << data;
+ parts_.push_back(new MemoryStream(ss.str().data(), ss.str().size()));
+ return true;
+}
+
+void MultipartStream::EndParts() {
+ ASSERT(adding_);
+ if (!adding_)
+ return;
+
+ std::stringstream ss;
+ if (!parts_.empty()) {
+ ss << "\r\n";
+ }
+ ss << "--" << boundary_ << "--" << "\r\n";
+ parts_.push_back(new MemoryStream(ss.str().data(), ss.str().size()));
+
+ ASSERT(0 == current_);
+ ASSERT(0 == position_);
+ adding_ = false;
+ SignalEvent(this, SE_OPEN | SE_READ, 0);
+}
+
+size_t MultipartStream::GetPartSize(const std::string& data,
+ const std::string& content_disposition,
+ const std::string& content_type) const {
+ size_t size = 0;
+ if (!parts_.empty()) {
+ size += 2; // for "\r\n";
+ }
+ size += boundary_.size() + 4; // for "--boundary_\r\n";
+ if (!content_disposition.empty()) {
+ // for ToString(HH_CONTENT_DISPOSITION): content_disposition\r\n
+ size += std::string(ToString(HH_CONTENT_DISPOSITION)).size() + 2 +
+ content_disposition.size() + 2;
+ }
+ if (!content_type.empty()) {
+ // for ToString(HH_CONTENT_TYPE): content_type\r\n
+ size += std::string(ToString(HH_CONTENT_TYPE)).size() + 2 +
+ content_type.size() + 2;
+ }
+ size += 2 + data.size(); // for \r\ndata
+ return size;
+}
+
+size_t MultipartStream::GetEndPartSize() const {
+ size_t size = 0;
+ if (!parts_.empty()) {
+ size += 2; // for "\r\n";
+ }
+ size += boundary_.size() + 6; // for "--boundary_--\r\n";
+ return size;
+}
+
+//
+// StreamInterface
+//
+
+StreamState MultipartStream::GetState() const {
+ if (adding_) {
+ return SS_OPENING;
+ }
+ return (current_ < parts_.size()) ? SS_OPEN : SS_CLOSED;
+}
+
+StreamResult MultipartStream::Read(void* buffer, size_t buffer_len,
+ size_t* read, int* error) {
+ if (adding_) {
+ return SR_BLOCK;
+ }
+ size_t local_read;
+ if (!read) read = &local_read;
+ while (current_ < parts_.size()) {
+ StreamResult result = parts_[current_]->Read(buffer, buffer_len, read,
+ error);
+ if (SR_EOS != result) {
+ if (SR_SUCCESS == result) {
+ position_ += *read;
+ }
+ return result;
+ }
+ ++current_;
+ }
+ return SR_EOS;
+}
+
+StreamResult MultipartStream::Write(const void* data, size_t data_len,
+ size_t* written, int* error) {
+ if (error) {
+ *error = -1;
+ }
+ return SR_ERROR;
+}
+
+void MultipartStream::Close() {
+ for (size_t i = 0; i < parts_.size(); ++i) {
+ delete parts_[i];
+ }
+ parts_.clear();
+ adding_ = false;
+ current_ = 0;
+ position_ = 0;
+}
+
+bool MultipartStream::SetPosition(size_t position) {
+ if (adding_) {
+ return false;
+ }
+ size_t part_size, part_offset = 0;
+ for (size_t i = 0; i < parts_.size(); ++i) {
+ if (!parts_[i]->GetSize(&part_size)) {
+ return false;
+ }
+ if (part_offset + part_size > position) {
+ for (size_t j = i+1; j < _min(parts_.size(), current_+1); ++j) {
+ if (!parts_[j]->Rewind()) {
+ return false;
+ }
+ }
+ if (!parts_[i]->SetPosition(position - part_offset)) {
+ return false;
+ }
+ current_ = i;
+ position_ = position;
+ return true;
+ }
+ part_offset += part_size;
+ }
+ return false;
+}
+
+bool MultipartStream::GetPosition(size_t* position) const {
+ if (position) {
+ *position = position_;
+ }
+ return true;
+}
+
+bool MultipartStream::GetSize(size_t* size) const {
+ size_t part_size, total_size = 0;
+ for (size_t i = 0; i < parts_.size(); ++i) {
+ if (!parts_[i]->GetSize(&part_size)) {
+ return false;
+ }
+ total_size += part_size;
+ }
+ if (size) {
+ *size = total_size;
+ }
+ return true;
+}
+
+bool MultipartStream::GetAvailable(size_t* size) const {
+ if (adding_) {
+ return false;
+ }
+ size_t part_size, total_size = 0;
+ for (size_t i = current_; i < parts_.size(); ++i) {
+ if (!parts_[i]->GetAvailable(&part_size)) {
+ return false;
+ }
+ total_size += part_size;
+ }
+ if (size) {
+ *size = total_size;
+ }
+ return true;
+}
+
+//
+// StreamInterface Slots
+//
+
+void MultipartStream::OnEvent(StreamInterface* stream, int events, int error) {
+ if (adding_ || (current_ >= parts_.size()) || (parts_[current_] != stream)) {
+ return;
+ }
+ SignalEvent(this, events, error);
+}
+
+} // namespace talk_base
diff --git a/talk/base/multipart.h b/talk/base/multipart.h
new file mode 100644
index 0000000..cce592b
--- /dev/null
+++ b/talk/base/multipart.h
@@ -0,0 +1,94 @@
+// libjingle
+// Copyright 2004--2010, 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_BASE_MULTIPART_H__
+#define TALK_BASE_MULTIPART_H__
+
+#include <string>
+#include <vector>
+
+#include "talk/base/sigslot.h"
+#include "talk/base/stream.h"
+
+namespace talk_base {
+
+///////////////////////////////////////////////////////////////////////////////
+// MultipartStream - Implements an RFC2046 multipart stream by concatenating
+// the supplied parts together, and adding the correct boundaries.
+///////////////////////////////////////////////////////////////////////////////
+
+class MultipartStream : public StreamInterface, public sigslot::has_slots<> {
+ public:
+ MultipartStream(const std::string& type, const std::string& boundary);
+ virtual ~MultipartStream();
+
+ void GetContentType(std::string* content_type);
+
+ // Note: If content_disposition and/or content_type are the empty string,
+ // they will be omitted.
+ bool AddPart(StreamInterface* data_stream,
+ const std::string& content_disposition,
+ const std::string& content_type);
+ bool AddPart(const std::string& data,
+ const std::string& content_disposition,
+ const std::string& content_type);
+ void EndParts();
+
+ // Calculates the size of a part before actually adding the part.
+ size_t GetPartSize(const std::string& data,
+ const std::string& content_disposition,
+ const std::string& content_type) const;
+ size_t GetEndPartSize() const;
+
+ // StreamInterface
+ virtual StreamState GetState() const;
+ virtual StreamResult Read(void* buffer, size_t buffer_len,
+ size_t* read, int* error);
+ virtual StreamResult Write(const void* data, size_t data_len,
+ size_t* written, int* error);
+ virtual void Close();
+ virtual bool SetPosition(size_t position);
+ virtual bool GetPosition(size_t* position) const;
+ virtual bool GetSize(size_t* size) const;
+ virtual bool GetAvailable(size_t* size) const;
+
+ private:
+ typedef std::vector<StreamInterface*> PartList;
+
+ // StreamInterface Slots
+ void OnEvent(StreamInterface* stream, int events, int error);
+
+ std::string type_, boundary_;
+ PartList parts_;
+ bool adding_;
+ size_t current_; // The index into parts_ of the current read position.
+ size_t position_; // The current read position in bytes.
+
+ DISALLOW_COPY_AND_ASSIGN(MultipartStream);
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_MULTIPART_H__
diff --git a/talk/base/multipart_unittest.cc b/talk/base/multipart_unittest.cc
new file mode 100644
index 0000000..18e3cf9
--- /dev/null
+++ b/talk/base/multipart_unittest.cc
@@ -0,0 +1,142 @@
+/*
+ * libjingle
+ * Copyright 2010, 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 "talk/base/gunit.h"
+#include "talk/base/helpers.h"
+#include "talk/base/logging.h"
+#include "talk/base/pathutils.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/multipart.h"
+
+namespace talk_base {
+
+static const std::string kTestMultipartBoundary = "123456789987654321";
+static const std::string kTestContentType =
+ "multipart/form-data; boundary=123456789987654321";
+static const char kTestData[] = "This is a test.";
+static const char kTestStreamContent[] = "This is a test stream.";
+
+TEST(MultipartTest, TestBasicOperations) {
+ MultipartStream multipart("multipart/form-data", kTestMultipartBoundary);
+ std::string content_type;
+ multipart.GetContentType(&content_type);
+ EXPECT_EQ(kTestContentType, content_type);
+
+ EXPECT_EQ(talk_base::SS_OPENING, multipart.GetState());
+
+ // The multipart stream contains only --boundary--\r\n
+ size_t end_part_size = multipart.GetEndPartSize();
+ multipart.EndParts();
+ EXPECT_EQ(talk_base::SS_OPEN, multipart.GetState());
+ size_t size;
+ EXPECT_TRUE(multipart.GetSize(&size));
+ EXPECT_EQ(end_part_size, size);
+
+ // Write is not supported.
+ EXPECT_EQ(talk_base::SR_ERROR,
+ multipart.Write(kTestData, sizeof(kTestData), NULL, NULL));
+
+ multipart.Close();
+ EXPECT_EQ(talk_base::SS_CLOSED, multipart.GetState());
+ EXPECT_TRUE(multipart.GetSize(&size));
+ EXPECT_EQ(0U, size);
+}
+
+TEST(MultipartTest, TestAddAndRead) {
+ MultipartStream multipart("multipart/form-data", kTestMultipartBoundary);
+
+ size_t part_size =
+ multipart.GetPartSize(kTestData, "form-data; name=\"text\"", "text");
+ EXPECT_TRUE(multipart.AddPart(kTestData, "form-data; name=\"text\"", "text"));
+ size_t size;
+ EXPECT_TRUE(multipart.GetSize(&size));
+ EXPECT_EQ(part_size, size);
+
+ talk_base::MemoryStream* stream =
+ new talk_base::MemoryStream(kTestStreamContent);
+ size_t stream_size = 0;
+ EXPECT_TRUE(stream->GetSize(&stream_size));
+ part_size +=
+ multipart.GetPartSize("", "form-data; name=\"stream\"", "stream");
+ part_size += stream_size;
+
+ EXPECT_TRUE(multipart.AddPart(
+ new talk_base::MemoryStream(kTestStreamContent),
+ "form-data; name=\"stream\"",
+ "stream"));
+ EXPECT_TRUE(multipart.GetSize(&size));
+ EXPECT_EQ(part_size, size);
+
+ // In adding state, block read.
+ char buffer[1024];
+ EXPECT_EQ(talk_base::SR_BLOCK,
+ multipart.Read(buffer, sizeof(buffer), NULL, NULL));
+ // Write is not supported.
+ EXPECT_EQ(talk_base::SR_ERROR,
+ multipart.Write(buffer, sizeof(buffer), NULL, NULL));
+
+ part_size += multipart.GetEndPartSize();
+ multipart.EndParts();
+ EXPECT_TRUE(multipart.GetSize(&size));
+ EXPECT_EQ(part_size, size);
+
+ // Read the multipart stream into StringStream
+ std::string str;
+ talk_base::StringStream str_stream(str);
+ EXPECT_EQ(talk_base::SR_SUCCESS,
+ Flow(&multipart, buffer, sizeof(buffer), &str_stream));
+ EXPECT_EQ(size, str.length());
+
+ // Search three boundaries and two parts in the order.
+ size_t pos = 0;
+ pos = str.find(kTestMultipartBoundary);
+ EXPECT_NE(std::string::npos, pos);
+ pos += kTestMultipartBoundary.length();
+
+ pos = str.find(kTestData, pos);
+ EXPECT_NE(std::string::npos, pos);
+ pos += sizeof(kTestData);
+
+ pos = str.find(kTestMultipartBoundary, pos);
+ EXPECT_NE(std::string::npos, pos);
+ pos += kTestMultipartBoundary.length();
+
+ pos = str.find(kTestStreamContent, pos);
+ EXPECT_NE(std::string::npos, pos);
+ pos += sizeof(kTestStreamContent);
+
+ pos = str.find(kTestMultipartBoundary, pos);
+ EXPECT_NE(std::string::npos, pos);
+ pos += kTestMultipartBoundary.length();
+
+ pos = str.find(kTestMultipartBoundary, pos);
+ EXPECT_EQ(std::string::npos, pos);
+}
+
+} // namespace talk_base
diff --git a/talk/base/nat_unittest.cc b/talk/base/nat_unittest.cc
new file mode 100644
index 0000000..8f87b3a
--- /dev/null
+++ b/talk/base/nat_unittest.cc
@@ -0,0 +1,295 @@
+/*
+ * libjingle
+ * Copyright 2004, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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 "talk/base/gunit.h"
+#include "talk/base/host.h"
+#include "talk/base/logging.h"
+#include "talk/base/natserver.h"
+#include "talk/base/natsocketfactory.h"
+#include "talk/base/network.h"
+#include "talk/base/physicalsocketserver.h"
+#include "talk/base/testclient.h"
+#include "talk/base/virtualsocketserver.h"
+
+using namespace talk_base;
+
+bool CheckReceive(
+ TestClient* client, bool should_receive, const char* buf, size_t size) {
+ return (should_receive) ?
+ client->CheckNextPacket(buf, size, 0) :
+ client->CheckNoPacket();
+}
+
+TestClient* CreateTestClient(
+ SocketFactory* factory, const SocketAddress& local_addr) {
+ AsyncUDPSocket* socket = AsyncUDPSocket::Create(factory, local_addr);
+ return new TestClient(socket);
+}
+
+// Tests that when sending from internal_addr to external_addrs through the
+// NAT type specified by nat_type, all external addrs receive the sent packet
+// and, if exp_same is true, all use the same mapped-address on the NAT.
+void TestSend(
+ SocketServer* internal, const SocketAddress& internal_addr,
+ SocketServer* external, const SocketAddress external_addrs[4],
+ NATType nat_type, bool exp_same) {
+ Thread th_int(internal);
+ Thread th_ext(external);
+
+ SocketAddress server_addr = internal_addr;
+ server_addr.SetPort(0); // Auto-select a port
+ NATServer* nat = new NATServer(
+ nat_type, internal, server_addr, external, external_addrs[0]);
+ NATSocketFactory* natsf = new NATSocketFactory(internal,
+ nat->internal_address());
+
+ TestClient* in = CreateTestClient(natsf, internal_addr);
+ TestClient* out[4];
+ for (int i = 0; i < 4; i++)
+ out[i] = CreateTestClient(external, external_addrs[i]);
+
+ th_int.Start();
+ th_ext.Start();
+
+ const char* buf = "filter_test";
+ size_t len = strlen(buf);
+
+ in->SendTo(buf, len, out[0]->address());
+ SocketAddress trans_addr;
+ EXPECT_TRUE(out[0]->CheckNextPacket(buf, len, &trans_addr));
+
+ for (int i = 1; i < 4; i++) {
+ in->SendTo(buf, len, out[i]->address());
+ SocketAddress trans_addr2;
+ EXPECT_TRUE(out[i]->CheckNextPacket(buf, len, &trans_addr2));
+ bool are_same = (trans_addr == trans_addr2);
+ ASSERT_EQ(are_same, exp_same) << "same translated address";
+ }
+
+ th_int.Stop();
+ th_ext.Stop();
+
+ delete nat;
+ delete natsf;
+ delete in;
+ for (int i = 0; i < 4; i++)
+ delete out[i];
+}
+
+// Tests that when sending from external_addrs to internal_addr, the packet
+// is delivered according to the specified filter_ip and filter_port rules.
+void TestRecv(
+ SocketServer* internal, const SocketAddress& internal_addr,
+ SocketServer* external, const SocketAddress external_addrs[4],
+ NATType nat_type, bool filter_ip, bool filter_port) {
+ Thread th_int(internal);
+ Thread th_ext(external);
+
+ SocketAddress server_addr = internal_addr;
+ server_addr.SetPort(0); // Auto-select a port
+ NATServer* nat = new NATServer(
+ nat_type, internal, server_addr, external, external_addrs[0]);
+ NATSocketFactory* natsf = new NATSocketFactory(internal,
+ nat->internal_address());
+
+ TestClient* in = CreateTestClient(natsf, internal_addr);
+ TestClient* out[4];
+ for (int i = 0; i < 4; i++)
+ out[i] = CreateTestClient(external, external_addrs[i]);
+
+ th_int.Start();
+ th_ext.Start();
+
+ const char* buf = "filter_test";
+ size_t len = strlen(buf);
+
+ in->SendTo(buf, len, out[0]->address());
+ SocketAddress trans_addr;
+ EXPECT_TRUE(out[0]->CheckNextPacket(buf, len, &trans_addr));
+
+ out[1]->SendTo(buf, len, trans_addr);
+ EXPECT_TRUE(CheckReceive(in, !filter_ip, buf, len));
+
+ out[2]->SendTo(buf, len, trans_addr);
+ EXPECT_TRUE(CheckReceive(in, !filter_port, buf, len));
+
+ out[3]->SendTo(buf, len, trans_addr);
+ EXPECT_TRUE(CheckReceive(in, !filter_ip && !filter_port, buf, len));
+
+ th_int.Stop();
+ th_ext.Stop();
+
+ delete nat;
+ delete natsf;
+ delete in;
+ for (int i = 0; i < 4; i++)
+ delete out[i];
+}
+
+// Tests that NATServer allocates bindings properly.
+void TestBindings(
+ SocketServer* internal, const SocketAddress& internal_addr,
+ SocketServer* external, const SocketAddress external_addrs[4]) {
+ TestSend(internal, internal_addr, external, external_addrs,
+ NAT_OPEN_CONE, true);
+ TestSend(internal, internal_addr, external, external_addrs,
+ NAT_ADDR_RESTRICTED, true);
+ TestSend(internal, internal_addr, external, external_addrs,
+ NAT_PORT_RESTRICTED, true);
+ TestSend(internal, internal_addr, external, external_addrs,
+ NAT_SYMMETRIC, false);
+}
+
+// Tests that NATServer filters packets properly.
+void TestFilters(
+ SocketServer* internal, const SocketAddress& internal_addr,
+ SocketServer* external, const SocketAddress external_addrs[4]) {
+ TestRecv(internal, internal_addr, external, external_addrs,
+ NAT_OPEN_CONE, false, false);
+ TestRecv(internal, internal_addr, external, external_addrs,
+ NAT_ADDR_RESTRICTED, true, false);
+ TestRecv(internal, internal_addr, external, external_addrs,
+ NAT_PORT_RESTRICTED, true, true);
+ TestRecv(internal, internal_addr, external, external_addrs,
+ NAT_SYMMETRIC, true, true);
+}
+
+TEST(NatTest, TestPhysical) {
+ BasicNetworkManager network_manager;
+ network_manager.StartUpdating();
+ // Process pending messages so the network list is updated.
+ Thread::Current()->ProcessMessages(0);
+
+ std::vector<Network*> networks;
+ network_manager.GetNetworks(&networks);
+ if (networks.empty()) {
+ LOG(LS_WARNING) << "Not enough network adapters for test.";
+ return;
+ }
+
+ SocketAddress int_addr("127.0.0.1", 0);
+ std::string ext_ip1 = "127.0.0.1";
+ std::string ext_ip2 = networks[0]->ip().ToString();
+
+ LOG(LS_INFO) << "selected ip " << ext_ip2;
+
+ SocketAddress ext_addrs[4] = {
+ SocketAddress(ext_ip1, 0),
+ SocketAddress(ext_ip2, 0),
+ SocketAddress(ext_ip1, 0),
+ SocketAddress(ext_ip2, 0)
+ };
+
+ PhysicalSocketServer* int_pss = new PhysicalSocketServer();
+ PhysicalSocketServer* ext_pss = new PhysicalSocketServer();
+
+ TestBindings(int_pss, int_addr, ext_pss, ext_addrs);
+ TestFilters(int_pss, int_addr, ext_pss, ext_addrs);
+}
+
+class TestVirtualSocketServer : public VirtualSocketServer {
+ public:
+ explicit TestVirtualSocketServer(SocketServer* ss)
+ : VirtualSocketServer(ss) {}
+ // Expose this publicly
+ IPAddress GetNextIP(int af) { return VirtualSocketServer::GetNextIP(af); }
+};
+
+TEST(NatTest, TestVirtual) {
+ TestVirtualSocketServer* int_vss = new TestVirtualSocketServer(
+ new PhysicalSocketServer());
+ TestVirtualSocketServer* ext_vss = new TestVirtualSocketServer(
+ new PhysicalSocketServer());
+
+ // TODO: IPv6ize this test when the NAT stuff is v6ed.
+ SocketAddress int_addr, ext_addrs[4];
+ int_addr.SetIP(int_vss->GetNextIP(int_addr.ipaddr().family()));
+ ext_addrs[0].SetIP(ext_vss->GetNextIP(int_addr.ipaddr().family()));
+ ext_addrs[1].SetIP(ext_vss->GetNextIP(int_addr.ipaddr().family()));
+ ext_addrs[2].SetIP(ext_addrs[0].ipaddr());
+ ext_addrs[3].SetIP(ext_addrs[1].ipaddr());
+
+ TestBindings(int_vss, int_addr, ext_vss, ext_addrs);
+ TestFilters(int_vss, int_addr, ext_vss, ext_addrs);
+}
+
+
+// TODO: Finish this test
+class NatTcpTest : public testing::Test, public sigslot::has_slots<> {
+ public:
+ NatTcpTest() : connected_(false) {}
+ virtual void SetUp() {
+ int_vss_ = new TestVirtualSocketServer(new PhysicalSocketServer());
+ ext_vss_ = new TestVirtualSocketServer(new PhysicalSocketServer());
+ nat_ = new NATServer(NAT_OPEN_CONE, int_vss_, SocketAddress(),
+ ext_vss_, SocketAddress());
+ natsf_ = new NATSocketFactory(int_vss_, nat_->internal_address());
+ }
+ void OnConnectEvent(AsyncSocket* socket) {
+ connected_ = true;
+ }
+ void OnAcceptEvent(AsyncSocket* socket) {
+ accepted_ = server_->Accept(NULL);
+ }
+ void OnCloseEvent(AsyncSocket* socket, int error) {
+ }
+ void ConnectEvents() {
+ server_->SignalReadEvent.connect(this, &NatTcpTest::OnAcceptEvent);
+ client_->SignalConnectEvent.connect(this, &NatTcpTest::OnConnectEvent);
+ }
+ TestVirtualSocketServer* int_vss_;
+ TestVirtualSocketServer* ext_vss_;
+ NATServer* nat_;
+ NATSocketFactory* natsf_;
+ AsyncSocket* client_;
+ AsyncSocket* server_;
+ AsyncSocket* accepted_;
+ bool connected_;
+};
+
+TEST_F(NatTcpTest, DISABLED_TestConnectOut) {
+ server_ = ext_vss_->CreateAsyncSocket(SOCK_STREAM);
+ server_->Bind(SocketAddress());
+ server_->Listen(5);
+
+ client_ = int_vss_->CreateAsyncSocket(SOCK_STREAM);
+ EXPECT_GE(0, client_->Bind(SocketAddress()));
+ EXPECT_GE(0, client_->Connect(server_->GetLocalAddress()));
+
+
+ ConnectEvents();
+
+ EXPECT_TRUE_WAIT(connected_, 1000);
+ EXPECT_EQ(client_->GetRemoteAddress(), server_->GetLocalAddress());
+ EXPECT_EQ(client_->GetRemoteAddress(), accepted_->GetLocalAddress());
+ EXPECT_EQ(client_->GetLocalAddress(), accepted_->GetRemoteAddress());
+
+ client_->Close();
+}
+//#endif
diff --git a/talk/base/natserver.cc b/talk/base/natserver.cc
new file mode 100644
index 0000000..d287059
--- /dev/null
+++ b/talk/base/natserver.cc
@@ -0,0 +1,190 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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/base/natsocketfactory.h"
+#include "talk/base/natserver.h"
+#include "talk/base/logging.h"
+
+namespace talk_base {
+
+RouteCmp::RouteCmp(NAT* nat) : symmetric(nat->IsSymmetric()) {
+}
+
+size_t RouteCmp::operator()(const SocketAddressPair& r) const {
+ size_t h = r.source().Hash();
+ if (symmetric)
+ h ^= r.destination().Hash();
+ return h;
+}
+
+bool RouteCmp::operator()(
+ const SocketAddressPair& r1, const SocketAddressPair& r2) const {
+ if (r1.source() < r2.source())
+ return true;
+ if (r2.source() < r1.source())
+ return false;
+ if (symmetric && (r1.destination() < r2.destination()))
+ return true;
+ if (symmetric && (r2.destination() < r1.destination()))
+ return false;
+ return false;
+}
+
+AddrCmp::AddrCmp(NAT* nat)
+ : use_ip(nat->FiltersIP()), use_port(nat->FiltersPort()) {
+}
+
+size_t AddrCmp::operator()(const SocketAddress& a) const {
+ size_t h = 0;
+ if (use_ip)
+ h ^= HashIP(a.ipaddr());
+ if (use_port)
+ h ^= a.port() | (a.port() << 16);
+ return h;
+}
+
+bool AddrCmp::operator()(
+ const SocketAddress& a1, const SocketAddress& a2) const {
+ if (use_ip && (a1.ipaddr() < a2.ipaddr()))
+ return true;
+ if (use_ip && (a2.ipaddr() < a1.ipaddr()))
+ return false;
+ if (use_port && (a1.port() < a2.port()))
+ return true;
+ if (use_port && (a2.port() < a1.port()))
+ return false;
+ return false;
+}
+
+NATServer::NATServer(
+ NATType type, SocketFactory* internal, const SocketAddress& internal_addr,
+ SocketFactory* external, const SocketAddress& external_ip)
+ : external_(external), external_ip_(external_ip.ipaddr(), 0) {
+ nat_ = NAT::Create(type);
+
+ server_socket_ = AsyncUDPSocket::Create(internal, internal_addr);
+ server_socket_->SignalReadPacket.connect(this, &NATServer::OnInternalPacket);
+
+ int_map_ = new InternalMap(RouteCmp(nat_));
+ ext_map_ = new ExternalMap();
+}
+
+NATServer::~NATServer() {
+ for (InternalMap::iterator iter = int_map_->begin();
+ iter != int_map_->end();
+ iter++)
+ delete iter->second;
+
+ delete nat_;
+ delete server_socket_;
+ delete int_map_;
+ delete ext_map_;
+}
+
+void NATServer::OnInternalPacket(
+ AsyncPacketSocket* socket, const char* buf, size_t size,
+ const SocketAddress& addr) {
+
+ // Read the intended destination from the wire.
+ SocketAddress dest_addr;
+ int length = UnpackAddressFromNAT(buf, size, &dest_addr);
+
+ // Find the translation for these addresses (allocating one if necessary).
+ SocketAddressPair route(addr, dest_addr);
+ InternalMap::iterator iter = int_map_->find(route);
+ if (iter == int_map_->end()) {
+ Translate(route);
+ iter = int_map_->find(route);
+ }
+ ASSERT(iter != int_map_->end());
+
+ // Allow the destination to send packets back to the source.
+ iter->second->whitelist->insert(dest_addr);
+
+ // Send the packet to its intended destination.
+ iter->second->socket->SendTo(buf + length, size - length, dest_addr);
+}
+
+void NATServer::OnExternalPacket(
+ AsyncPacketSocket* socket, const char* buf, size_t size,
+ const SocketAddress& remote_addr) {
+
+ SocketAddress local_addr = socket->GetLocalAddress();
+
+ // Find the translation for this addresses.
+ ExternalMap::iterator iter = ext_map_->find(local_addr);
+ ASSERT(iter != ext_map_->end());
+
+ // Allow the NAT to reject this packet.
+ if (Filter(iter->second, remote_addr)) {
+ LOG(LS_INFO) << "Packet from " << remote_addr.ToString()
+ << " was filtered out by the NAT.";
+ return;
+ }
+
+ // Forward this packet to the internal address.
+ // First prepend the address in a quasi-STUN format.
+ scoped_array<char> real_buf(new char[size + kNATEncodedIPv6AddressSize]);
+ size_t addrlength = PackAddressForNAT(real_buf.get(),
+ size + kNATEncodedIPv6AddressSize,
+ remote_addr);
+ // Copy the data part after the address.
+ std::memcpy(real_buf.get() + addrlength, buf, size);
+ server_socket_->SendTo(real_buf.get(), size + addrlength,
+ iter->second->route.source());
+}
+
+void NATServer::Translate(const SocketAddressPair& route) {
+ AsyncUDPSocket* socket = AsyncUDPSocket::Create(external_, external_ip_);
+
+ if (!socket) {
+ LOG(LS_ERROR) << "Couldn't find a free port!";
+ return;
+ }
+
+ TransEntry* entry = new TransEntry(route, socket, nat_);
+ (*int_map_)[route] = entry;
+ (*ext_map_)[socket->GetLocalAddress()] = entry;
+ socket->SignalReadPacket.connect(this, &NATServer::OnExternalPacket);
+}
+
+bool NATServer::Filter(TransEntry* entry, const SocketAddress& ext_addr) {
+ return entry->whitelist->find(ext_addr) == entry->whitelist->end();
+}
+
+NATServer::TransEntry::TransEntry(
+ const SocketAddressPair& r, AsyncUDPSocket* s, NAT* nat)
+ : route(r), socket(s) {
+ whitelist = new AddressSet(AddrCmp(nat));
+}
+
+NATServer::TransEntry::~TransEntry() {
+ delete whitelist;
+ delete socket;
+}
+
+} // namespace talk_base
diff --git a/talk/base/natserver.h b/talk/base/natserver.h
new file mode 100644
index 0000000..0a6083c
--- /dev/null
+++ b/talk/base/natserver.h
@@ -0,0 +1,121 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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_BASE_NATSERVER_H_
+#define TALK_BASE_NATSERVER_H_
+
+#include <map>
+#include <set>
+
+#include "talk/base/asyncudpsocket.h"
+#include "talk/base/socketaddresspair.h"
+#include "talk/base/thread.h"
+#include "talk/base/socketfactory.h"
+#include "talk/base/nattypes.h"
+
+namespace talk_base {
+
+// Change how routes (socketaddress pairs) are compared based on the type of
+// NAT. The NAT server maintains a hashtable of the routes that it knows
+// about. So these affect which routes are treated the same.
+struct RouteCmp {
+ explicit RouteCmp(NAT* nat);
+ size_t operator()(const SocketAddressPair& r) const;
+ bool operator()(
+ const SocketAddressPair& r1, const SocketAddressPair& r2) const;
+
+ bool symmetric;
+};
+
+// Changes how addresses are compared based on the filtering rules of the NAT.
+struct AddrCmp {
+ explicit AddrCmp(NAT* nat);
+ size_t operator()(const SocketAddress& r) const;
+ bool operator()(const SocketAddress& r1, const SocketAddress& r2) const;
+
+ bool use_ip;
+ bool use_port;
+};
+
+// Implements the NAT device. It listens for packets on the internal network,
+// translates them, and sends them out over the external network.
+
+const int NAT_SERVER_PORT = 4237;
+
+class NATServer : public sigslot::has_slots<> {
+ public:
+ NATServer(
+ NATType type, SocketFactory* internal, const SocketAddress& internal_addr,
+ SocketFactory* external, const SocketAddress& external_ip);
+ ~NATServer();
+
+ SocketAddress internal_address() const {
+ return server_socket_->GetLocalAddress();
+ }
+
+ // Packets received on one of the networks.
+ void OnInternalPacket(AsyncPacketSocket* socket, const char* buf,
+ size_t size, const SocketAddress& addr);
+ void OnExternalPacket(AsyncPacketSocket* socket, const char* buf,
+ size_t size, const SocketAddress& remote_addr);
+
+ private:
+ typedef std::set<SocketAddress, AddrCmp> AddressSet;
+
+ /* Records a translation and the associated external socket. */
+ struct TransEntry {
+ TransEntry(const SocketAddressPair& r, AsyncUDPSocket* s, NAT* nat);
+ ~TransEntry();
+
+ SocketAddressPair route;
+ AsyncUDPSocket* socket;
+ AddressSet* whitelist;
+ };
+
+ typedef std::map<SocketAddressPair, TransEntry*, RouteCmp> InternalMap;
+ typedef std::map<SocketAddress, TransEntry*> ExternalMap;
+
+ /* Creates a new entry that translates the given route. */
+ void Translate(const SocketAddressPair& route);
+
+ /* Determines whether the NAT would filter out a packet from this address. */
+ bool Filter(TransEntry* entry, const SocketAddress& ext_addr);
+
+ NAT* nat_;
+ SocketFactory* internal_;
+ SocketFactory* external_;
+ SocketAddress external_ip_;
+ AsyncUDPSocket* server_socket_;
+ AsyncSocket* tcp_server_socket_;
+ InternalMap* int_map_;
+ ExternalMap* ext_map_;
+ DISALLOW_EVIL_CONSTRUCTORS(NATServer);
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_NATSERVER_H_
diff --git a/talk/base/natserver_main.cc b/talk/base/natserver_main.cc
new file mode 100644
index 0000000..a748108
--- /dev/null
+++ b/talk/base/natserver_main.cc
@@ -0,0 +1,57 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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 <iostream>
+
+#include "talk/base/natserver.h"
+#include "talk/base/host.h"
+#include "talk/base/physicalsocketserver.h"
+
+using namespace talk_base;
+
+int main(int argc, char* argv[]) {
+ if (argc != 3) {
+ std::cerr << "usage: natserver <internal-ip> <external-ip>" << std::endl;
+ exit(1);
+ }
+
+ SocketAddress internal = SocketAddress(argv[1]);
+ SocketAddress external = SocketAddress(argv[2]);
+ if (internal.EqualIPs(external)) {
+ std::cerr << "internal and external IPs must differ" << std::endl;
+ exit(1);
+ }
+
+ Thread* pthMain = Thread::Current();
+ PhysicalSocketServer* ss = new PhysicalSocketServer();
+ pthMain->set_socketserver(ss);
+ NATServer* server = new NATServer(NAT_OPEN_CONE, ss, internal, ss, external);
+ server = server;
+
+ pthMain->Run();
+ return 0;
+}
diff --git a/talk/base/natsocketfactory.cc b/talk/base/natsocketfactory.cc
new file mode 100644
index 0000000..de2cf2b
--- /dev/null
+++ b/talk/base/natsocketfactory.cc
@@ -0,0 +1,488 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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/base/natsocketfactory.h"
+
+#include "talk/base/logging.h"
+#include "talk/base/natserver.h"
+#include "talk/base/virtualsocketserver.h"
+
+namespace talk_base {
+
+// Packs the given socketaddress into the buffer in buf, in the quasi-STUN
+// format that the natserver uses.
+// Returns 0 if an invalid address is passed.
+size_t PackAddressForNAT(char* buf, size_t buf_size,
+ const SocketAddress& remote_addr) {
+ const IPAddress& ip = remote_addr.ipaddr();
+ int family = ip.family();
+ buf[0] = 0;
+ buf[1] = family;
+ // Writes the port.
+ *(reinterpret_cast<uint16*>(&buf[2])) = htons(remote_addr.port());
+ if (family == AF_INET) {
+ ASSERT(buf_size >= kNATEncodedIPv4AddressSize);
+ in_addr v4addr = ip.ipv4_address();
+ std::memcpy(&buf[4], &v4addr, kNATEncodedIPv4AddressSize - 4);
+ return kNATEncodedIPv4AddressSize;
+ } else if (family == AF_INET6) {
+ ASSERT(buf_size >= kNATEncodedIPv6AddressSize);
+ in6_addr v6addr = ip.ipv6_address();
+ std::memcpy(&buf[4], &v6addr, kNATEncodedIPv6AddressSize - 4);
+ return kNATEncodedIPv6AddressSize;
+ }
+ return 0U;
+}
+
+// Decodes the remote address from a packet that has been encoded with the nat's
+// quasi-STUN format. Returns the length of the address (i.e., the offset into
+// data where the original packet starts).
+size_t UnpackAddressFromNAT(const char* buf, size_t buf_size,
+ SocketAddress* remote_addr) {
+ ASSERT(buf_size >= 8);
+ ASSERT(buf[0] == 0);
+ int family = buf[1];
+ uint16 port = ntohs(*(reinterpret_cast<const uint16*>(&buf[2])));
+ if (family == AF_INET) {
+ const in_addr* v4addr = reinterpret_cast<const in_addr*>(&buf[4]);
+ *remote_addr = SocketAddress(IPAddress(*v4addr), port);
+ return kNATEncodedIPv4AddressSize;
+ } else if (family == AF_INET6) {
+ ASSERT(buf_size >= 20);
+ const in6_addr* v6addr = reinterpret_cast<const in6_addr*>(&buf[4]);
+ *remote_addr = SocketAddress(IPAddress(*v6addr), port);
+ return kNATEncodedIPv6AddressSize;
+ }
+ return 0U;
+}
+
+
+// NATSocket
+class NATSocket : public AsyncSocket, public sigslot::has_slots<> {
+ public:
+ explicit NATSocket(NATInternalSocketFactory* sf, int type)
+ : sf_(sf), type_(type), async_(true), connected_(false),
+ socket_(NULL), buf_(NULL), size_(0) {
+ }
+
+ virtual ~NATSocket() {
+ delete socket_;
+ delete[] buf_;
+ }
+
+ virtual SocketAddress GetLocalAddress() const {
+ return (socket_) ? socket_->GetLocalAddress() : SocketAddress();
+ }
+
+ virtual SocketAddress GetRemoteAddress() const {
+ return remote_addr_; // will be ANY if not connected
+ }
+
+ virtual int Bind(const SocketAddress& addr) {
+ if (socket_) { // already bound, bubble up error
+ return -1;
+ }
+
+ int result;
+ socket_ = sf_->CreateInternalSocket(type_, addr, &server_addr_);
+ result = (socket_) ? socket_->Bind(addr) : -1;
+ if (result >= 0) {
+ socket_->SignalConnectEvent.connect(this, &NATSocket::OnConnectEvent);
+ socket_->SignalReadEvent.connect(this, &NATSocket::OnReadEvent);
+ socket_->SignalWriteEvent.connect(this, &NATSocket::OnWriteEvent);
+ socket_->SignalCloseEvent.connect(this, &NATSocket::OnCloseEvent);
+ } else {
+ server_addr_.Clear();
+ delete socket_;
+ socket_ = NULL;
+ }
+
+ return result;
+ }
+
+ virtual int Connect(const SocketAddress& addr) {
+ if (!socket_) { // socket must be bound, for now
+ return -1;
+ }
+
+ int result = 0;
+ if (type_ == SOCK_STREAM) {
+ result = socket_->Connect(server_addr_.IsAny() ? addr : server_addr_);
+ } else {
+ connected_ = true;
+ }
+
+ if (result >= 0) {
+ remote_addr_ = addr;
+ }
+
+ return result;
+ }
+
+ virtual int Send(const void* data, size_t size) {
+ ASSERT(connected_);
+ return SendTo(data, size, remote_addr_);
+ }
+
+ virtual int SendTo(const void* data, size_t size, const SocketAddress& addr) {
+ ASSERT(!connected_ || addr == remote_addr_);
+ if (server_addr_.IsAny() || type_ == SOCK_STREAM) {
+ return socket_->SendTo(data, size, addr);
+ }
+ // This array will be too large for IPv4 packets, but only by 12 bytes.
+ scoped_array<char> buf(new char[size + kNATEncodedIPv6AddressSize]);
+ size_t addrlength = PackAddressForNAT(buf.get(),
+ size + kNATEncodedIPv6AddressSize,
+ addr);
+ size_t encoded_size = size + addrlength;
+ std::memcpy(buf.get() + addrlength, data, size);
+ int result = socket_->SendTo(buf.get(), encoded_size, server_addr_);
+ if (result >= 0) {
+ ASSERT(result == static_cast<int>(encoded_size));
+ result = result - static_cast<int>(addrlength);
+ }
+ return result;
+ }
+
+ virtual int Recv(void* data, size_t size) {
+ SocketAddress addr;
+ return RecvFrom(data, size, &addr);
+ }
+
+ virtual int RecvFrom(void* data, size_t size, SocketAddress *out_addr) {
+ if (server_addr_.IsAny() || type_ == SOCK_STREAM) {
+ return socket_->RecvFrom(data, size, out_addr);
+ }
+ // Make sure we have enough room to read the requested amount plus the
+ // largest possible header address.
+ SocketAddress remote_addr;
+ Grow(size + kNATEncodedIPv6AddressSize);
+
+ // Read the packet from the socket.
+ int result = socket_->RecvFrom(buf_, size_, &remote_addr);
+ if (result >= 0) {
+ ASSERT(remote_addr == server_addr_);
+
+ // TODO: we need better framing so we know how many bytes we can
+ // return before we need to read the next address. For UDP, this will be
+ // fine as long as the reader always reads everything in the packet.
+ ASSERT((size_t)result < size_);
+
+ // Decode the wire packet into the actual results.
+ SocketAddress real_remote_addr;
+ size_t addrlength =
+ UnpackAddressFromNAT(buf_, result, &real_remote_addr);
+ std::memcpy(data, buf_ + addrlength, result - addrlength);
+
+ // Make sure this packet should be delivered before returning it.
+ if (!connected_ || (real_remote_addr == remote_addr_)) {
+ if (out_addr)
+ *out_addr = real_remote_addr;
+ result = result - addrlength;
+ } else {
+ LOG(LS_ERROR) << "Dropping packet from unknown remote address: "
+ << real_remote_addr.ToString();
+ result = 0; // Tell the caller we didn't read anything
+ }
+ }
+
+ return result;
+ }
+
+ virtual int Close() {
+ int result = 0;
+ if (socket_) {
+ result = socket_->Close();
+ if (result >= 0) {
+ connected_ = false;
+ remote_addr_ = SocketAddress();
+ delete socket_;
+ socket_ = NULL;
+ }
+ }
+ return result;
+ }
+
+ virtual int Listen(int backlog) {
+ return socket_->Listen(backlog);
+ }
+ virtual AsyncSocket* Accept(SocketAddress *paddr) {
+ return socket_->Accept(paddr);
+ }
+ virtual int GetError() const {
+ return socket_->GetError();
+ }
+ virtual void SetError(int error) {
+ socket_->SetError(error);
+ }
+ virtual ConnState GetState() const {
+ return connected_ ? CS_CONNECTED : CS_CLOSED;
+ }
+ virtual int EstimateMTU(uint16* mtu) {
+ return socket_->EstimateMTU(mtu);
+ }
+ virtual int GetOption(Option opt, int* value) {
+ return socket_->GetOption(opt, value);
+ }
+ virtual int SetOption(Option opt, int value) {
+ return socket_->SetOption(opt, value);
+ }
+
+ void OnConnectEvent(AsyncSocket* socket) {
+ // If we're NATed, we need to send a request with the real addr to use.
+ ASSERT(socket == socket_);
+ if (server_addr_.IsAny()) {
+ connected_ = true;
+ SignalConnectEvent(this);
+ } else {
+ SendConnectRequest();
+ }
+ }
+ void OnReadEvent(AsyncSocket* socket) {
+ // If we're NATed, we need to process the connect reply.
+ ASSERT(socket == socket_);
+ if (type_ == SOCK_STREAM && !server_addr_.IsAny() && !connected_) {
+ HandleConnectReply();
+ } else {
+ SignalReadEvent(this);
+ }
+ }
+ void OnWriteEvent(AsyncSocket* socket) {
+ ASSERT(socket == socket_);
+ SignalWriteEvent(this);
+ }
+ void OnCloseEvent(AsyncSocket* socket, int error) {
+ ASSERT(socket == socket_);
+ SignalCloseEvent(this, error);
+ }
+
+ private:
+ // Makes sure the buffer is at least the given size.
+ void Grow(size_t new_size) {
+ if (size_ < new_size) {
+ delete[] buf_;
+ size_ = new_size;
+ buf_ = new char[size_];
+ }
+ }
+
+ // Sends the destination address to the server to tell it to connect.
+ void SendConnectRequest() {
+ char buf[256];
+ size_t length = PackAddressForNAT(buf, ARRAY_SIZE(buf), remote_addr_);
+ socket_->Send(buf, length);
+ }
+
+ // Handles the byte sent back from the server and fires the appropriate event.
+ void HandleConnectReply() {
+ char code;
+ socket_->Recv(&code, sizeof(code));
+ if (code == 0) {
+ SignalConnectEvent(this);
+ } else {
+ Close();
+ SignalCloseEvent(this, code);
+ }
+ }
+
+ NATInternalSocketFactory* sf_;
+ int type_;
+ bool async_;
+ bool connected_;
+ SocketAddress remote_addr_;
+ SocketAddress server_addr_; // address of the NAT server
+ AsyncSocket* socket_;
+ char* buf_;
+ size_t size_;
+};
+
+// NATSocketFactory
+NATSocketFactory::NATSocketFactory(SocketFactory* factory,
+ const SocketAddress& nat_addr)
+ : factory_(factory), nat_addr_(nat_addr) {
+}
+
+Socket* NATSocketFactory::CreateSocket(int type) {
+ return new NATSocket(this, type);
+}
+
+AsyncSocket* NATSocketFactory::CreateAsyncSocket(int type) {
+ return new NATSocket(this, type);
+}
+
+AsyncSocket* NATSocketFactory::CreateInternalSocket(int type,
+ const SocketAddress& local_addr, SocketAddress* nat_addr) {
+ *nat_addr = nat_addr_;
+ return factory_->CreateAsyncSocket(type);
+}
+
+// NATSocketServer
+NATSocketServer::NATSocketServer(SocketServer* server)
+ : server_(server), msg_queue_(NULL) {
+}
+
+NATSocketServer::Translator* NATSocketServer::GetTranslator(
+ const SocketAddress& ext_ip) {
+ return nats_.Get(ext_ip);
+}
+
+NATSocketServer::Translator* NATSocketServer::AddTranslator(
+ const SocketAddress& ext_ip, const SocketAddress& int_ip, NATType type) {
+ // Fail if a translator already exists with this extternal address.
+ if (nats_.Get(ext_ip))
+ return NULL;
+
+ return nats_.Add(ext_ip, new Translator(this, type, int_ip, server_, ext_ip));
+}
+
+void NATSocketServer::RemoveTranslator(
+ const SocketAddress& ext_ip) {
+ nats_.Remove(ext_ip);
+}
+
+Socket* NATSocketServer::CreateSocket(int type) {
+ return new NATSocket(this, type);
+}
+
+AsyncSocket* NATSocketServer::CreateAsyncSocket(int type) {
+ return new NATSocket(this, type);
+}
+
+AsyncSocket* NATSocketServer::CreateInternalSocket(int type,
+ const SocketAddress& local_addr, SocketAddress* nat_addr) {
+ AsyncSocket* socket = NULL;
+ Translator* nat = nats_.FindClient(local_addr);
+ if (nat) {
+ socket = nat->internal_factory()->CreateAsyncSocket(type);
+ *nat_addr = (type == SOCK_STREAM) ?
+ nat->internal_tcp_address() : nat->internal_address();
+ } else {
+ socket = server_->CreateAsyncSocket(type);
+ }
+ return socket;
+}
+
+// NATSocketServer::Translator
+NATSocketServer::Translator::Translator(
+ NATSocketServer* server, NATType type, const SocketAddress& int_ip,
+ SocketFactory* ext_factory, const SocketAddress& ext_ip)
+ : server_(server) {
+ // Create a new private network, and a NATServer running on the private
+ // network that bridges to the external network. Also tell the private
+ // network to use the same message queue as us.
+ VirtualSocketServer* internal_server = new VirtualSocketServer(server_);
+ internal_server->SetMessageQueue(server_->queue());
+ internal_factory_.reset(internal_server);
+ nat_server_.reset(new NATServer(type, internal_server, int_ip,
+ ext_factory, ext_ip));
+}
+
+
+NATSocketServer::Translator* NATSocketServer::Translator::GetTranslator(
+ const SocketAddress& ext_ip) {
+ return nats_.Get(ext_ip);
+}
+
+NATSocketServer::Translator* NATSocketServer::Translator::AddTranslator(
+ const SocketAddress& ext_ip, const SocketAddress& int_ip, NATType type) {
+ // Fail if a translator already exists with this extternal address.
+ if (nats_.Get(ext_ip))
+ return NULL;
+
+ AddClient(ext_ip);
+ return nats_.Add(ext_ip,
+ new Translator(server_, type, int_ip, server_, ext_ip));
+}
+void NATSocketServer::Translator::RemoveTranslator(
+ const SocketAddress& ext_ip) {
+ nats_.Remove(ext_ip);
+ RemoveClient(ext_ip);
+}
+
+bool NATSocketServer::Translator::AddClient(
+ const SocketAddress& int_ip) {
+ // Fail if a client already exists with this internal address.
+ if (clients_.find(int_ip) != clients_.end())
+ return false;
+
+ clients_.insert(int_ip);
+ return true;
+}
+
+void NATSocketServer::Translator::RemoveClient(
+ const SocketAddress& int_ip) {
+ std::set<SocketAddress>::iterator it = clients_.find(int_ip);
+ if (it != clients_.end()) {
+ clients_.erase(it);
+ }
+}
+
+NATSocketServer::Translator* NATSocketServer::Translator::FindClient(
+ const SocketAddress& int_ip) {
+ // See if we have the requested IP, or any of our children do.
+ return (clients_.find(int_ip) != clients_.end()) ?
+ this : nats_.FindClient(int_ip);
+}
+
+// NATSocketServer::TranslatorMap
+NATSocketServer::TranslatorMap::~TranslatorMap() {
+ for (TranslatorMap::iterator it = begin(); it != end(); ++it) {
+ delete it->second;
+ }
+}
+
+NATSocketServer::Translator* NATSocketServer::TranslatorMap::Get(
+ const SocketAddress& ext_ip) {
+ TranslatorMap::iterator it = find(ext_ip);
+ return (it != end()) ? it->second : NULL;
+}
+
+NATSocketServer::Translator* NATSocketServer::TranslatorMap::Add(
+ const SocketAddress& ext_ip, Translator* nat) {
+ (*this)[ext_ip] = nat;
+ return nat;
+}
+
+void NATSocketServer::TranslatorMap::Remove(
+ const SocketAddress& ext_ip) {
+ TranslatorMap::iterator it = find(ext_ip);
+ if (it != end()) {
+ delete it->second;
+ erase(it);
+ }
+}
+
+NATSocketServer::Translator* NATSocketServer::TranslatorMap::FindClient(
+ const SocketAddress& int_ip) {
+ Translator* nat = NULL;
+ for (TranslatorMap::iterator it = begin(); it != end() && !nat; ++it) {
+ nat = it->second->FindClient(int_ip);
+ }
+ return nat;
+}
+
+} // namespace talk_base
diff --git a/talk/base/natsocketfactory.h b/talk/base/natsocketfactory.h
new file mode 100644
index 0000000..d0566d3
--- /dev/null
+++ b/talk/base/natsocketfactory.h
@@ -0,0 +1,177 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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_BASE_NATSOCKETFACTORY_H_
+#define TALK_BASE_NATSOCKETFACTORY_H_
+
+#include <string>
+#include <map>
+#include <set>
+
+#include "talk/base/natserver.h"
+#include "talk/base/socketaddress.h"
+#include "talk/base/socketserver.h"
+
+namespace talk_base {
+
+const size_t kNATEncodedIPv4AddressSize = 8U;
+const size_t kNATEncodedIPv6AddressSize = 20U;
+
+// Used by the NAT socket implementation.
+class NATInternalSocketFactory {
+ public:
+ virtual ~NATInternalSocketFactory() {}
+ virtual AsyncSocket* CreateInternalSocket(int type,
+ const SocketAddress& local_addr, SocketAddress* nat_addr) = 0;
+};
+
+// Creates sockets that will send all traffic through a NAT, using an existing
+// NATServer instance running at nat_addr. The actual data is sent using sockets
+// from a socket factory, given to the constructor.
+class NATSocketFactory : public SocketFactory, public NATInternalSocketFactory {
+ public:
+ NATSocketFactory(SocketFactory* factory, const SocketAddress& nat_addr);
+
+ // SocketFactory implementation
+ virtual Socket* CreateSocket(int type);
+ virtual AsyncSocket* CreateAsyncSocket(int type);
+
+ // NATInternalSocketFactory implementation
+ virtual AsyncSocket* CreateInternalSocket(int type,
+ const SocketAddress& local_addr, SocketAddress* nat_addr);
+
+ private:
+ SocketFactory* factory_;
+ SocketAddress nat_addr_;
+ DISALLOW_EVIL_CONSTRUCTORS(NATSocketFactory);
+};
+
+// Creates sockets that will send traffic through a NAT depending on what
+// address they bind to. This can be used to simulate a client on a NAT sending
+// to a client that is not behind a NAT.
+// Note that the internal addresses of clients must be unique. This is because
+// there is only one socketserver per thread, and the Bind() address is used to
+// figure out which NAT (if any) the socket should talk to.
+//
+// Example with 3 NATs (2 cascaded), and 3 clients.
+// ss->AddTranslator("1.2.3.4", "192.168.0.1", NAT_ADDR_RESTRICTED);
+// ss->AddTranslator("99.99.99.99", "10.0.0.1", NAT_SYMMETRIC)->
+// AddTranslator("10.0.0.2", "192.168.1.1", NAT_OPEN_CONE);
+// ss->GetTranslator("1.2.3.4")->AddClient("1.2.3.4", "192.168.0.2");
+// ss->GetTranslator("99.99.99.99")->AddClient("10.0.0.3");
+// ss->GetTranslator("99.99.99.99")->GetTranslator("10.0.0.2")->
+// AddClient("192.168.1.2");
+class NATSocketServer : public SocketServer, public NATInternalSocketFactory {
+ public:
+ class Translator;
+ // holds a list of NATs
+ class TranslatorMap : private std::map<SocketAddress, Translator*> {
+ public:
+ ~TranslatorMap();
+ Translator* Get(const SocketAddress& ext_ip);
+ Translator* Add(const SocketAddress& ext_ip, Translator*);
+ void Remove(const SocketAddress& ext_ip);
+ Translator* FindClient(const SocketAddress& int_ip);
+ };
+
+ // a specific NAT
+ class Translator {
+ public:
+ Translator(NATSocketServer* server, NATType type,
+ const SocketAddress& int_addr, SocketFactory* ext_factory,
+ const SocketAddress& ext_addr);
+
+ SocketFactory* internal_factory() { return internal_factory_.get(); }
+ SocketAddress internal_address() const {
+ return nat_server_->internal_address();
+ }
+ SocketAddress internal_tcp_address() const {
+ return SocketAddress(); // nat_server_->internal_tcp_address();
+ }
+
+ Translator* GetTranslator(const SocketAddress& ext_ip);
+ Translator* AddTranslator(const SocketAddress& ext_ip,
+ const SocketAddress& int_ip, NATType type);
+ void RemoveTranslator(const SocketAddress& ext_ip);
+
+ bool AddClient(const SocketAddress& int_ip);
+ void RemoveClient(const SocketAddress& int_ip);
+
+ // Looks for the specified client in this or a child NAT.
+ Translator* FindClient(const SocketAddress& int_ip);
+
+ private:
+ NATSocketServer* server_;
+ scoped_ptr<SocketFactory> internal_factory_;
+ scoped_ptr<NATServer> nat_server_;
+ TranslatorMap nats_;
+ std::set<SocketAddress> clients_;
+ };
+
+ explicit NATSocketServer(SocketServer* ss);
+
+ SocketServer* socketserver() { return server_; }
+ MessageQueue* queue() { return msg_queue_; }
+
+ Translator* GetTranslator(const SocketAddress& ext_ip);
+ Translator* AddTranslator(const SocketAddress& ext_ip,
+ const SocketAddress& int_ip, NATType type);
+ void RemoveTranslator(const SocketAddress& ext_ip);
+
+ // SocketServer implementation
+ virtual Socket* CreateSocket(int type);
+ virtual AsyncSocket* CreateAsyncSocket(int type);
+ virtual void SetMessageQueue(MessageQueue* queue) {
+ msg_queue_ = queue;
+ server_->SetMessageQueue(queue);
+ }
+ virtual bool Wait(int cms, bool process_io) {
+ return server_->Wait(cms, process_io);
+ }
+ virtual void WakeUp() {
+ server_->WakeUp();
+ }
+
+ // NATInternalSocketFactory implementation
+ virtual AsyncSocket* CreateInternalSocket(int type,
+ const SocketAddress& local_addr, SocketAddress* nat_addr);
+
+ private:
+ SocketServer* server_;
+ MessageQueue* msg_queue_;
+ TranslatorMap nats_;
+ DISALLOW_EVIL_CONSTRUCTORS(NATSocketServer);
+};
+
+// Free-standing NAT helper functions.
+size_t PackAddressForNAT(char* buf, size_t buf_size,
+ const SocketAddress& remote_addr);
+size_t UnpackAddressFromNAT(const char* buf, size_t buf_size,
+ SocketAddress* remote_addr);
+} // namespace talk_base
+
+#endif // TALK_BASE_NATSOCKETFACTORY_H_
diff --git a/talk/base/nattypes.cc b/talk/base/nattypes.cc
new file mode 100644
index 0000000..290c3ad
--- /dev/null
+++ b/talk/base/nattypes.cc
@@ -0,0 +1,72 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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 <cassert>
+
+#include "talk/base/nattypes.h"
+
+namespace talk_base {
+
+class SymmetricNAT : public NAT {
+public:
+ bool IsSymmetric() { return true; }
+ bool FiltersIP() { return true; }
+ bool FiltersPort() { return true; }
+};
+
+class OpenConeNAT : public NAT {
+public:
+ bool IsSymmetric() { return false; }
+ bool FiltersIP() { return false; }
+ bool FiltersPort() { return false; }
+};
+
+class AddressRestrictedNAT : public NAT {
+public:
+ bool IsSymmetric() { return false; }
+ bool FiltersIP() { return true; }
+ bool FiltersPort() { return false; }
+};
+
+class PortRestrictedNAT : public NAT {
+public:
+ bool IsSymmetric() { return false; }
+ bool FiltersIP() { return true; }
+ bool FiltersPort() { return true; }
+};
+
+NAT* NAT::Create(NATType type) {
+ switch (type) {
+ case NAT_OPEN_CONE: return new OpenConeNAT();
+ case NAT_ADDR_RESTRICTED: return new AddressRestrictedNAT();
+ case NAT_PORT_RESTRICTED: return new PortRestrictedNAT();
+ case NAT_SYMMETRIC: return new SymmetricNAT();
+ default: assert(0); return 0;
+ }
+}
+
+} // namespace talk_base
diff --git a/talk/base/nattypes.h b/talk/base/nattypes.h
new file mode 100644
index 0000000..e9602c7
--- /dev/null
+++ b/talk/base/nattypes.h
@@ -0,0 +1,64 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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_BASE_NATTYPE_H__
+#define TALK_BASE_NATTYPE_H__
+
+namespace talk_base {
+
+/* Identifies each type of NAT that can be simulated. */
+enum NATType {
+ NAT_OPEN_CONE,
+ NAT_ADDR_RESTRICTED,
+ NAT_PORT_RESTRICTED,
+ NAT_SYMMETRIC
+};
+
+// Implements the rules for each specific type of NAT.
+class NAT {
+public:
+ virtual ~NAT() { }
+
+ // Determines whether this NAT uses both source and destination address when
+ // checking whether a mapping already exists.
+ virtual bool IsSymmetric() = 0;
+
+ // Determines whether this NAT drops packets received from a different IP
+ // the one last sent to.
+ virtual bool FiltersIP() = 0;
+
+ // Determines whether this NAT drops packets received from a different port
+ // the one last sent to.
+ virtual bool FiltersPort() = 0;
+
+ // Returns an implementation of the given type of NAT.
+ static NAT* Create(NATType type);
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_NATTYPE_H__
diff --git a/talk/base/nethelpers.cc b/talk/base/nethelpers.cc
index b408749..3961fc0 100644
--- a/talk/base/nethelpers.cc
+++ b/talk/base/nethelpers.cc
@@ -57,7 +57,7 @@
}
}
-#if defined(WIN32) || defined(ANDROID)
+#if defined(WIN32) || defined(ANDROID) || defined(OPENBSD)
static hostent* DeepCopyHostent(const hostent* ent) {
// Get the total number of bytes we need to copy, and allocate our buffer.
int num_aliases = 0, num_addrs = 0;
@@ -165,9 +165,16 @@
result = deep_copy;
#endif
*herrno = 0;
-#elif defined(OSX) || defined(IOS)
+#elif defined(OSX) || defined(IOS) || defined(FREEBSD)
// Mac OS returns an object with everything allocated.
result = getipnodebyname(hostname, AF_INET, AI_DEFAULT, herrno);
+#elif defined(OPENBSD)
+ hostent* ent = gethostbyname(hostname);
+ if (!ent) {
+ return NULL;
+ }
+ result = DeepCopyHostent(ent);
+ *herrno = 0;
#else
#error "I don't know how to do gethostbyname safely on your system."
#endif
@@ -177,7 +184,7 @@
// This function should mirror the above function, and free any resources
// allocated by the above.
void FreeHostEnt(hostent* host) {
-#if defined(OSX) || defined(IOS)
+#if defined(OSX) || defined(IOS) || defined(FREEBSD)
freehostent(host);
#elif defined(WIN32) || defined(POSIX)
free(host);
@@ -186,4 +193,20 @@
#endif
}
+const char* inet_ntop(int af, const void *src, char* dst, socklen_t size) {
+#ifdef WIN32
+ return win32_inet_ntop(af, src, dst, size);
+#else
+ return ::inet_ntop(af, src, dst, size);
+#endif
+}
+
+int inet_pton(int af, const char* src, void *dst) {
+#ifdef WIN32
+ return win32_inet_pton(af, src, dst);
+#else
+ return ::inet_pton(af, src, dst);
+#endif
+}
+
} // namespace talk_base
diff --git a/talk/base/nethelpers.h b/talk/base/nethelpers.h
index 4cba9a9..ca97738 100644
--- a/talk/base/nethelpers.h
+++ b/talk/base/nethelpers.h
@@ -71,6 +71,11 @@
hostent* SafeGetHostByName(const char* hostname, int* herrno);
void FreeHostEnt(hostent* host);
+// talk_base namespaced wrappers for inet_ntop and inet_pton so we can avoid
+// the windows-native versions of these.
+const char* inet_ntop(int af, const void *src, char* dst, socklen_t size);
+int inet_pton(int af, const char* src, void *dst);
+
} // namespace talk_base
#endif // TALK_BASE_NETHELPERS_H_
diff --git a/talk/base/network.cc b/talk/base/network.cc
index 2feb361..9d1a83d 100644
--- a/talk/base/network.cc
+++ b/talk/base/network.cc
@@ -64,34 +64,6 @@
// Fetch list of networks every two seconds.
const int kNetworksUpdateIntervalMs = 2000;
-#ifdef POSIX
-// Gets the default gateway for the specified interface.
-uint32 GetDefaultGateway(const std::string& name) {
-#ifdef OSX
- // TODO: /proc/net/route doesn't exist,
- // Use ioctl to get the routing table
- return 0xFFFFFFFF;
-#endif
-
- uint32 gateway_ip = 0;
-
- talk_base::FileStream fs;
- if (fs.Open("/proc/net/route", "r", NULL)) {
- std::string line;
- while (fs.ReadLine(&line) == talk_base::SR_SUCCESS && gateway_ip == 0) {
- char iface[16];
- unsigned int ip, gw;
- if (sscanf(line.c_str(), "%7s %8X %8X", iface, &ip, &gw) == 3 &&
- name == iface && ip == 0) {
- gateway_ip = ntohl(gw);
- }
- }
- }
-
- return gateway_ip;
-}
-#endif // POSIX
-
bool CompareNetworks(const Network* a, const Network* b) {
return a->name() < b->name();
}
@@ -146,11 +118,6 @@
network->set_ip(list[i]->ip());
}
- if (network->gateway_ip() != list[i]->gateway_ip()) {
- changed = true;
- network->set_gateway_ip(list[i]->gateway_ip());
- }
-
delete list[i];
}
@@ -199,10 +166,9 @@
struct sockaddr_in* inaddr =
reinterpret_cast<struct sockaddr_in*>(&ptr->ifr_ifru.ifru_addr);
if (inaddr->sin_family == AF_INET) {
- uint32 ip = ntohl(inaddr->sin_addr.s_addr);
+ IPAddress ip(inaddr->sin_addr);
scoped_ptr<Network> network(
- new Network(ptr->ifr_name, ptr->ifr_name, ip,
- GetDefaultGateway(ptr->ifr_name)));
+ new Network(ptr->ifr_name, ptr->ifr_name, ip));
network->set_ignored(IsIgnoredNetwork(*network));
if (include_ignored || !network->ignored()) {
networks->push_back(network.release());
@@ -235,6 +201,8 @@
scoped_array<char> buf(new char[len]);
IP_ADAPTER_INFO *infos = reinterpret_cast<IP_ADAPTER_INFO *>(buf.get());
+ // TODO: GetAdaptersInfo is IPv4 only. Replace with GetAddressesInfo when
+ // IPv6 support is needed in Network.
DWORD ret = GetAdaptersInfo(infos, &len);
if (ret != NO_ERROR) {
LOG_ERR_EX(LS_ERROR, ret) << "GetAdaptersInfo failed";
@@ -259,13 +227,13 @@
name = ost.str();
count++;
#endif // !_DEBUG
-
- scoped_ptr<Network> network(new Network(name, info->Description,
- SocketAddress::StringToIP(info->IpAddressList.IpAddress.String),
- SocketAddress::StringToIP(info->GatewayList.IpAddress.String)));
- network->set_ignored(IsIgnoredNetwork(*network));
- if (include_ignored || !network->ignored()) {
- networks->push_back(network.release());
+ IPAddress ip;
+ if (IPFromString(info->IpAddressList.IpAddress.String, &ip)) {
+ scoped_ptr<Network> network(new Network(name, info->Description, ip));
+ network->set_ignored(IsIgnoredNetwork(*network));
+ if (include_ignored || !network->ignored()) {
+ networks->push_back(network.release());
+ }
}
}
@@ -292,7 +260,10 @@
#endif
// Ignore any networks with a 0.x.y.z IP
- return (network.ip() < 0x01000000);
+ if (network.ip().family() == AF_INET) {
+ return (network.ip().v4AddressAsHostOrderInteger() < 0x01000000);
+ }
+ return false;
}
void BasicNetworkManager::StartUpdating() {
@@ -342,17 +313,15 @@
const Network* network = list[i];
if (!network->ignored() || include_ignored) {
LOG(LS_INFO) << network->ToString() << ": " << network->description()
- << ", Gateway="
- << SocketAddress::IPToString(network->gateway_ip())
<< ((network->ignored()) ? ", Ignored" : "");
}
}
}
Network::Network(const std::string& name, const std::string& desc,
- uint32 ip, uint32 gateway_ip)
- : name_(name), description_(desc), ip_(ip), gateway_ip_(gateway_ip),
- ignored_(false), uniform_numerator_(0), uniform_denominator_(0),
+ const IPAddress& ip)
+ : name_(name), description_(desc), ip_(ip), ignored_(false),
+ uniform_numerator_(0), uniform_denominator_(0),
exponential_numerator_(0), exponential_denominator_(0) {
}
@@ -361,7 +330,7 @@
// Print out the first space-terminated token of the network desc, plus
// the IP address.
ss << "Net[" << description_.substr(0, description_.find(' '))
- << ":" << SocketAddress::IPToString(ip_) << "]";
+ << ":" << ip_ << "]";
return ss.str();
}
diff --git a/talk/base/network.h b/talk/base/network.h
index 4b315c3..bb5f15d 100644
--- a/talk/base/network.h
+++ b/talk/base/network.h
@@ -34,6 +34,7 @@
#include <vector>
#include "talk/base/basictypes.h"
+#include "talk/base/ipaddress.h"
#include "talk/base/messagehandler.h"
#include "talk/base/sigslot.h"
@@ -135,8 +136,10 @@
// Represents a Unix-type network interface, with a name and single address.
class Network {
public:
+ Network() : ip_(INADDR_ANY) {}
+
Network(const std::string& name, const std::string& description,
- uint32 ip, uint32 gateway_ip);
+ const IPAddress& ip);
// Returns the index of this network. This is considered the primary key
// that identifies each network.
@@ -147,15 +150,11 @@
const std::string& description() const { return description_; }
// Identifies the current IP address used by this network.
- uint32 ip() const { return ip_; }
- void set_ip(uint32 ip) { ip_ = ip; }
+ const IPAddress& ip() const { return ip_; }
+ void set_ip(const IPAddress& ip) { ip_ = ip; }
- // Identifies the current gateway IP address used by this network.
- uint32 gateway_ip() const { return gateway_ip_; }
- void set_gateway_ip(uint32 ip) { gateway_ip_ = ip; }
-
- // Indicates whether this network should be ignored, perhaps because the
- // IP/gateway is 0, or the interface is one we know is invalid.
+ // Indicates whether this network should be ignored, perhaps because
+ // the IP is 0, or the interface is one we know is invalid.
bool ignored() const { return ignored_; }
void set_ignored(bool ignored) { ignored_ = ignored; }
@@ -167,8 +166,7 @@
std::string name_;
std::string description_;
- uint32 ip_;
- uint32 gateway_ip_;
+ IPAddress ip_;
bool ignored_;
SessionList sessions_;
double uniform_numerator_;
diff --git a/talk/base/network_unittest.cc b/talk/base/network_unittest.cc
index a55ba2f..d48abbb 100644
--- a/talk/base/network_unittest.cc
+++ b/talk/base/network_unittest.cc
@@ -33,15 +33,10 @@
// A network that should not be ignored.
static const Network kNetwork1("test1", "Test Network Adapter 1",
- 0x12345678, 0x12345601);
+ IPAddress(0x12345678));
// A network that should be ignored (IP is 0.1.0.4).
static const Network kNetwork2("test2", "Test Network Adapter 2",
- 0x00010004, 0x01000000);
-// A network that should not be ignored (IP is valid, but gateway is 0.0.0.1).
-// Previously, we attempted to ignore networks with no default gateway,
-// but if an explicit route is set, no default gateway is needed.
-static const Network kNetwork3("test3", "Test Network Adapter 3",
- 0x55667788, 0x01000000);
+ IPAddress(0x00010004));
class NetworkTest : public testing::Test, public sigslot::has_slots<> {
public:
@@ -63,6 +58,13 @@
return BasicNetworkManager::IsIgnoredNetwork(network);
}
+ NetworkManager::NetworkList GetNetworks(
+ const BasicNetworkManager& network_manager, bool include_ignored) {
+ NetworkManager::NetworkList list;
+ network_manager.CreateNetworks(include_ignored, &list);
+ return list;
+ }
+
protected:
bool callback_called_;
};
@@ -71,8 +73,7 @@
TEST_F(NetworkTest, TestNetworkConstruct) {
EXPECT_EQ("test1", kNetwork1.name());
EXPECT_EQ("Test Network Adapter 1", kNetwork1.description());
- EXPECT_EQ(0x12345678U, kNetwork1.ip());
- EXPECT_EQ(0x12345601U, kNetwork1.gateway_ip());
+ EXPECT_EQ(IPAddress(0x12345678U), kNetwork1.ip());
EXPECT_FALSE(kNetwork1.ignored());
}
@@ -80,7 +81,41 @@
TEST_F(NetworkTest, TestNetworkIgnore) {
EXPECT_FALSE(IsIgnoredNetwork(kNetwork1));
EXPECT_TRUE(IsIgnoredNetwork(kNetwork2));
- EXPECT_FALSE(IsIgnoredNetwork(kNetwork3));
+}
+
+TEST_F(NetworkTest, TestCreateNetworks) {
+ BasicNetworkManager manager;
+ NetworkManager::NetworkList result = GetNetworks(manager, true);
+ // We should be able to bind to any addresses we find.
+ // (Excluding IPv6 link-local for now, as we don't (yet) record scope ids.)
+ NetworkManager::NetworkList::iterator it;
+ for (it = result.begin();
+ it != result.end();
+ ++it) {
+ sockaddr_storage storage;
+ memset(&storage, 0, sizeof(storage));
+ IPAddress ip = (*it)->ip();
+ // This condition excludes FE80::/16, i.e. IPv6 link-local addresses. These
+ // require their scope id to be known. Remove when scope ids are supported.
+ if (!(ip.family() == AF_INET6 && IPIsPrivate(ip) && !IPIsLoopback(ip))) {
+ SocketAddress bindaddress(ip, 0);
+ // TODO: Make this use talk_base::AsyncSocket once it supports IPv6.
+ int fd = socket(ip.family(), SOCK_STREAM, IPPROTO_TCP);
+ if (fd > 0) {
+ size_t ipsize = bindaddress.ToSockAddrStorage(&storage);
+ EXPECT_GE(ipsize, 0U);
+ int success = ::bind(fd,
+ reinterpret_cast<sockaddr*>(&storage),
+ ipsize);
+ EXPECT_EQ(0, success);
+#ifdef WIN32
+ closesocket(fd);
+#else
+ close(fd);
+#endif
+ }
+ }
+ }
}
// Test that UpdateNetworks succeeds.
diff --git a/talk/base/openssladapter.cc b/talk/base/openssladapter.cc
index 4208b79..ea40172 100644
--- a/talk/base/openssladapter.cc
+++ b/talk/base/openssladapter.cc
@@ -747,6 +747,7 @@
X509_free(certificate);
+ // This should only ever be turned on for debugging and development.
if (!ok && ignore_bad_cert) {
LOG(LS_WARNING) << "TLS certificate check FAILED. "
<< "Allowing connection anyway.";
@@ -840,6 +841,7 @@
}
}
+ // Should only be used for debugging and development.
if (!ok && stream->ignore_bad_cert()) {
LOG(LS_WARNING) << "Ignoring cert error while verifying cert chain";
ok = 1;
diff --git a/talk/base/opensslidentity.cc b/talk/base/opensslidentity.cc
index a9d94b2..68b113b 100644
--- a/talk/base/opensslidentity.cc
+++ b/talk/base/opensslidentity.cc
@@ -147,6 +147,7 @@
static void LogSSLErrors(const std::string& prefix) {
char error_buf[200];
unsigned long err;
+
while ((err = ERR_get_error())) {
ERR_error_string_n(err, error_buf, sizeof(error_buf));
LOG(LS_ERROR) << prefix << ": " << error_buf << "\n";
@@ -224,6 +225,74 @@
return NULL;
}
+bool OpenSSLCertificate::GetDigestLength(const std::string &algorithm,
+ std::size_t *length) {
+ const EVP_MD *md;
+
+ if (!GetDigestEVP(algorithm, &md))
+ return false;
+
+ *length = EVP_MD_size(md);
+
+ return true;
+}
+
+bool OpenSSLCertificate::ComputeDigest(const std::string &algorithm,
+ unsigned char *digest,
+ std::size_t size,
+ std::size_t *length) const {
+ return ComputeDigest(x509_, algorithm, digest, size, length);
+}
+
+bool OpenSSLCertificate::ComputeDigest(const X509 *x509,
+ const std::string &algorithm,
+ unsigned char *digest,
+ std::size_t size,
+ std::size_t *length) {
+ const EVP_MD *md;
+ unsigned int n;
+
+ if (!GetDigestEVP(algorithm, &md))
+ return false;
+
+ if (size < static_cast<size_t>(EVP_MD_size(md)))
+ return false;
+
+ X509_digest(x509, md, digest, &n);
+
+ *length = n;
+
+ return true;
+}
+
+
+bool OpenSSLCertificate::GetDigestEVP(const std::string &algorithm,
+ const EVP_MD **mdp) {
+ const EVP_MD *md;
+ if (algorithm == DIGEST_SHA_1) {
+ md = EVP_sha1();
+ }
+#if OPENSSL_VERSION_NUMBER >= 0x10000000L
+ else if (algorithm == DIGEST_SHA_224) {
+ md = EVP_sha224();
+ } else if (algorithm == DIGEST_SHA_256) {
+ md = EVP_sha256();
+ } else if (algorithm == DIGEST_SHA_384) {
+ md = EVP_sha384();
+ } else if (algorithm == DIGEST_SHA_512) {
+ md = EVP_sha512();
+ }
+#endif
+ else {
+ return false;
+ }
+
+ // Can't happen
+ ASSERT(EVP_MD_size(md) >= 20);
+ *mdp = md;
+ return true;
+}
+
OpenSSLCertificate::~OpenSSLCertificate() {
X509_free(x509_);
}
diff --git a/talk/base/opensslidentity.h b/talk/base/opensslidentity.h
index 7cac419..f642736 100644
--- a/talk/base/opensslidentity.h
+++ b/talk/base/opensslidentity.h
@@ -87,6 +87,22 @@
virtual std::string ToPEMString() const;
+ // Compute the digest of the certificate given algorithm
+ virtual bool ComputeDigest(const std::string &algorithm,
+ unsigned char *digest, std::size_t size,
+ std::size_t *length) const;
+
+ // Compute the digest of a certificate as an X509 *
+ static bool ComputeDigest(const X509 *x509,
+ const std::string &algorithm,
+ unsigned char *digest,
+ std::size_t size,
+ std::size_t *length);
+
+ // Helper function to get the length of a digest
+ static bool GetDigestLength(const std::string &algorithm,
+ std::size_t *length);
+
private:
explicit OpenSSLCertificate(X509* x509) : x509_(x509) {
ASSERT(x509_ != NULL);
@@ -95,6 +111,10 @@
X509* x509_;
+ // Helper function to look up a digest
+ static bool GetDigestEVP(const std::string &algorithm,
+ const EVP_MD **md);
+
DISALLOW_EVIL_CONSTRUCTORS(OpenSSLCertificate);
};
@@ -132,6 +152,7 @@
DISALLOW_EVIL_CONSTRUCTORS(OpenSSLIdentity);
};
+
} // namespace talk_base
#endif // TALK_BASE_OPENSSLIDENTITY_H__
diff --git a/talk/base/opensslstreamadapter.cc b/talk/base/opensslstreamadapter.cc
index 6a34e13..be061ad 100644
--- a/talk/base/opensslstreamadapter.cc
+++ b/talk/base/opensslstreamadapter.cc
@@ -40,15 +40,41 @@
#include <openssl/ssl.h>
#include <openssl/x509v3.h>
+#include <vector>
+
#include "talk/base/common.h"
#include "talk/base/logging.h"
#include "talk/base/stream.h"
#include "talk/base/openssladapter.h"
#include "talk/base/opensslidentity.h"
#include "talk/base/stringutils.h"
+#include "talk/base/thread.h"
namespace talk_base {
+#if (OPENSSL_VERSION_NUMBER >= 0x10001000L)
+#define HAVE_DTLS_SRTP
+#endif
+
+#if (OPENSSL_VERSION_NUMBER >= 0x10000000L)
+#define HAVE_DTLS
+#endif
+
+#ifdef HAVE_DTLS_SRTP
+// SRTP cipher suite table
+struct SrtpCipherMapEntry {
+ const char* external_name;
+ const char* internal_name;
+};
+
+// This isn't elegant, but it's better than an external reference
+static SrtpCipherMapEntry SrtpCipherMap[] = {
+ {"AES_CM_128_HMAC_SHA1_80", "SRTP_AES128_CM_SHA1_80"},
+ {"AES_CM_128_HMAC_SHA1_32", "SRTP_AES128_CM_SHA1_32"},
+ {NULL, NULL}
+};
+#endif
+
//////////////////////////////////////////////////////////////////////
// StreamBIO
//////////////////////////////////////////////////////////////////////
@@ -166,7 +192,8 @@
role_(SSL_CLIENT),
ssl_read_needs_write_(false), ssl_write_needs_read_(false),
ssl_(NULL), ssl_ctx_(NULL),
- custom_verification_succeeded_(false) {
+ custom_verification_succeeded_(false),
+ ssl_mode_(SSL_MODE_TLS) {
}
OpenSSLStreamAdapter::~OpenSSLStreamAdapter() {
@@ -178,16 +205,130 @@
identity_.reset(static_cast<OpenSSLIdentity*>(identity));
}
-void OpenSSLStreamAdapter::SetServerRole() {
- role_ = SSL_SERVER;
+void OpenSSLStreamAdapter::SetServerRole(SSLRole role) {
+ role_ = role;
}
void OpenSSLStreamAdapter::SetPeerCertificate(SSLCertificate* cert) {
ASSERT(peer_certificate_.get() == NULL);
+ ASSERT(peer_certificate_digest_algorithm_.empty());
ASSERT(ssl_server_name_.empty());
peer_certificate_.reset(static_cast<OpenSSLCertificate*>(cert));
}
+bool OpenSSLStreamAdapter::SetPeerCertificateDigest(const std::string
+ &digest_alg,
+ const unsigned char*
+ digest_val,
+ size_t digest_len) {
+ ASSERT(peer_certificate_.get() == NULL);
+ ASSERT(peer_certificate_digest_algorithm_.size() == 0);
+ ASSERT(ssl_server_name_.empty());
+ size_t expected_len;
+
+ if (!OpenSSLCertificate::GetDigestLength(digest_alg, &expected_len)) {
+ LOG(LS_WARNING) << "Unknown digest algorithm: " << digest_alg;
+ return false;
+ }
+ if (expected_len != digest_len)
+ return false;
+
+ peer_certificate_digest_value_.SetData(digest_val, digest_len);
+ peer_certificate_digest_algorithm_ = digest_alg;
+
+ return true;
+}
+
+// Key Extractor interface
+bool OpenSSLStreamAdapter::ExportKeyingMaterial(const std::string& label,
+ const uint8* context,
+ size_t context_len,
+ bool use_context,
+ uint8* result,
+ size_t result_len) {
+#ifdef HAVE_DTLS_SRTP
+ int i;
+
+ i = SSL_export_keying_material(ssl_, result, result_len,
+ label.c_str(), label.length(),
+ const_cast<uint8 *>(context),
+ context_len, use_context);
+
+ if (i != 1)
+ return false;
+
+ return true;
+#else
+ return false;
+#endif
+}
+
+bool OpenSSLStreamAdapter::SetDtlsSrtpCiphers(
+ const std::vector<std::string>& ciphers) {
+ std::string internal_ciphers;
+
+ if (state_ != SSL_NONE)
+ return false;
+
+#ifdef HAVE_DTLS_SRTP
+ for (std::vector<std::string>::const_iterator cipher = ciphers.begin();
+ cipher != ciphers.end(); ++cipher) {
+ bool found = false;
+ for (SrtpCipherMapEntry *entry = SrtpCipherMap; entry->internal_name;
+ ++entry) {
+ if (*cipher == entry->external_name) {
+ found = true;
+ if (!internal_ciphers.empty())
+ internal_ciphers += ":";
+ internal_ciphers += entry->internal_name;
+ break;
+ }
+ }
+
+ if (!found) {
+ LOG(LS_ERROR) << "Could not find cipher: " << *cipher;
+ return false;
+ }
+ }
+
+ if (internal_ciphers.empty())
+ return false;
+
+ srtp_ciphers_ = internal_ciphers;
+ return true;
+#else
+ return false;
+#endif
+}
+
+bool OpenSSLStreamAdapter::GetDtlsSrtpCipher(std::string* cipher) {
+#ifdef HAVE_DTLS_SRTP
+ ASSERT(state_ == SSL_CONNECTED);
+ if (state_ != SSL_CONNECTED)
+ return false;
+
+ SRTP_PROTECTION_PROFILE *srtp_profile =
+ SSL_get_selected_srtp_profile(ssl_);
+
+ if (!srtp_profile)
+ return NULL;
+
+ for (SrtpCipherMapEntry *entry = SrtpCipherMap;
+ entry->internal_name; ++entry) {
+ if (!strcmp(entry->internal_name, srtp_profile->name)) {
+ *cipher = entry->external_name;
+ return true;
+ }
+ }
+
+ ASSERT(false); // This should never happen
+
+ return false;
+#else
+ return false;
+#endif
+}
+
int OpenSSLStreamAdapter::StartSSLWithServer(const char* server_name) {
ASSERT(server_name != NULL && server_name[0] != '\0');
ssl_server_name_ = server_name;
@@ -200,6 +341,11 @@
return StartSSL();
}
+void OpenSSLStreamAdapter::SetMode(SSLMode mode) {
+ ASSERT(state_ == SSL_NONE);
+ ssl_mode_ = mode;
+}
+
//
// StreamInterface Implementation
//
@@ -238,7 +384,8 @@
ssl_write_needs_read_ = false;
int code = SSL_write(ssl_, data, data_len);
- switch (SSL_get_error(ssl_, code)) {
+ int ssl_error = SSL_get_error(ssl_, code);
+ switch (ssl_error) {
case SSL_ERROR_NONE:
LOG(LS_INFO) << " -- success";
ASSERT(0 < code && static_cast<unsigned>(code) <= data_len);
@@ -255,7 +402,7 @@
case SSL_ERROR_ZERO_RETURN:
default:
- Error("SSL_write", (code ? code : -1), false);
+ Error("SSL_write", (ssl_error ? ssl_error : -1), false);
if (error)
*error = ssl_error_code_;
return SR_ERROR;
@@ -298,12 +445,26 @@
ssl_read_needs_write_ = false;
int code = SSL_read(ssl_, data, data_len);
- switch (SSL_get_error(ssl_, code)) {
+ int ssl_error = SSL_get_error(ssl_, code);
+ switch (ssl_error) {
case SSL_ERROR_NONE:
LOG(LS_INFO) << " -- success";
ASSERT(0 < code && static_cast<unsigned>(code) <= data_len);
if (read)
*read = code;
+
+ if (ssl_mode_ == SSL_MODE_DTLS) {
+ // Enforce atomic reads -- this is a short read
+ unsigned int pending = SSL_pending(ssl_);
+
+ if (pending) {
+ LOG(LS_INFO) << " -- short DTLS read. flushing";
+ FlushInput(pending);
+ if (error)
+ *error = SSE_MSG_TRUNC;
+ return SR_ERROR;
+ }
+ }
return SR_SUCCESS;
case SSL_ERROR_WANT_READ:
LOG(LS_INFO) << " -- error want read";
@@ -318,7 +479,7 @@
break;
default:
LOG(LS_INFO) << " -- error " << code;
- Error("SSL_read", (code ? code : -1), false);
+ Error("SSL_read", (ssl_error ? ssl_error : -1), false);
if (error)
*error = ssl_error_code_;
return SR_ERROR;
@@ -326,6 +487,27 @@
// not reached
}
+void OpenSSLStreamAdapter::FlushInput(unsigned int left) {
+ unsigned char buf[2048];
+
+ while (left) {
+ // This should always succeed
+ int toread = (sizeof(buf) < left) ? sizeof(buf) : left;
+ int code = SSL_read(ssl_, buf, toread);
+
+ int ssl_error = SSL_get_error(ssl_, code);
+ ASSERT(ssl_error == SSL_ERROR_NONE);
+
+ if (ssl_error != SSL_ERROR_NONE) {
+ LOG(LS_INFO) << " -- error " << code;
+ Error("SSL_read", (ssl_error ? ssl_error : -1), false);
+ return;
+ }
+ LOG(LS_INFO) << " -- flushed " << code << " bytes";
+ left -= code;
+ }
+}
+
void OpenSSLStreamAdapter::Close() {
Cleanup();
ASSERT(state_ == SSL_CLOSED || state_ == SSL_ERROR);
@@ -333,7 +515,7 @@
}
StreamState OpenSSLStreamAdapter::GetState() const {
- switch(state_) {
+ switch (state_) {
case SSL_WAIT:
case SSL_CONNECTING:
return SS_OPENING;
@@ -395,7 +577,7 @@
ASSERT(signal_error == 0);
signal_error = err;
}
- if(events_to_signal)
+ if (events_to_signal)
StreamAdapterInterface::OnEvent(stream, events_to_signal, signal_error);
}
@@ -420,7 +602,9 @@
ASSERT(state_ == SSL_CONNECTING);
// The underlying stream has open. If we are in peer-to-peer mode
// then a peer certificate must have been specified by now.
- ASSERT(!ssl_server_name_.empty() || peer_certificate_.get() != NULL);
+ ASSERT(!ssl_server_name_.empty() ||
+ peer_certificate_.get() != NULL ||
+ !peer_certificate_digest_algorithm_.empty());
LOG(LS_INFO) << "BeginSSL: "
<< (!ssl_server_name_.empty() ? ssl_server_name_ :
"with peer");
@@ -458,14 +642,19 @@
LOG(LS_INFO) << "ContinueSSL";
ASSERT(state_ == SSL_CONNECTING);
+ // Clear the DTLS timer
+ Thread::Current()->Clear(this, MSG_TIMEOUT);
+
int code = (role_ == SSL_CLIENT) ? SSL_connect(ssl_) : SSL_accept(ssl_);
- switch (SSL_get_error(ssl_, code)) {
+ int ssl_error;
+ switch (ssl_error = SSL_get_error(ssl_, code)) {
case SSL_ERROR_NONE:
LOG(LS_INFO) << " -- success";
if (!SSLPostConnectionCheck(ssl_, ssl_server_name_.c_str(),
peer_certificate_.get() != NULL
- ? peer_certificate_->x509() : NULL)) {
+ ? peer_certificate_->x509() : NULL,
+ peer_certificate_digest_algorithm_)) {
LOG(LS_ERROR) << "TLS post connection check failed";
return -1;
}
@@ -474,8 +663,17 @@
StreamAdapterInterface::OnEvent(stream(), SE_OPEN|SE_READ|SE_WRITE, 0);
break;
- case SSL_ERROR_WANT_READ:
- LOG(LS_INFO) << " -- error want read";
+ case SSL_ERROR_WANT_READ: {
+ LOG(LS_INFO) << " -- error want read";
+#ifdef HAVE_DTLS
+ struct timeval timeout;
+ if (DTLSv1_get_timeout(ssl_, &timeout)) {
+ int delay = timeout.tv_sec * 1000 + timeout.tv_usec/1000;
+
+ Thread::Current()->PostDelayed(delay, this, MSG_TIMEOUT, 0);
+ }
+#endif
+ }
break;
case SSL_ERROR_WANT_WRITE:
@@ -485,7 +683,7 @@
case SSL_ERROR_ZERO_RETURN:
default:
LOG(LS_INFO) << " -- error " << code;
- return (code != 0) ? code : -1;
+ return (ssl_error != 0) ? ssl_error : -1;
}
return 0;
@@ -519,11 +717,43 @@
}
identity_.reset();
peer_certificate_.reset();
+
+ // Clear the DTLS timer
+ Thread::Current()->Clear(this, MSG_TIMEOUT);
+}
+
+
+void OpenSSLStreamAdapter::OnMessage(Message* msg) {
+ // Process our own messages and then pass others to the superclass
+ if (MSG_TIMEOUT == msg->message_id) {
+ LOG(LS_INFO) << "DTLS timeout expired";
+#ifdef HAVE_DTLS
+ DTLSv1_handle_timeout(ssl_);
+#endif
+ ContinueSSL();
+ } else {
+ StreamInterface::OnMessage(msg);
+ }
}
SSL_CTX* OpenSSLStreamAdapter::SetupSSLContext() {
- SSL_CTX* ctx = SSL_CTX_new(role_ == SSL_CLIENT ? TLSv1_client_method()
- : TLSv1_server_method());
+ SSL_CTX *ctx = NULL;
+
+ if (role_ == SSL_CLIENT) {
+#ifdef HAVE_DTLS
+ ctx = SSL_CTX_new(ssl_mode_ == SSL_MODE_DTLS ?
+ DTLSv1_client_method() : TLSv1_client_method());
+#else
+ ctx = SSL_CTX_new(TLSv1_client_method());
+#endif
+ } else {
+#ifdef HAVE_DTLS
+ ctx = SSL_CTX_new(ssl_mode_ == SSL_MODE_DTLS ?
+ DTLSv1_server_method() : TLSv1_server_method());
+#else
+ ctx = SSL_CTX_new(TLSv1_server_method());
+#endif
+ }
if (ctx == NULL)
return NULL;
@@ -534,7 +764,7 @@
if (peer_certificate_.get() == NULL) { // traditional mode
// Add the root cert to the SSL context
- if(!OpenSSLAdapter::ConfigureTrustedRootCertificates(ctx)) {
+ if (!OpenSSLAdapter::ConfigureTrustedRootCertificates(ctx)) {
SSL_CTX_free(ctx);
return NULL;
}
@@ -553,6 +783,15 @@
SSL_CTX_set_verify_depth(ctx, 4);
SSL_CTX_set_cipher_list(ctx, "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
+#ifdef HAVE_DTLS_SRTP
+ if (!srtp_ciphers_.empty()) {
+ if (SSL_CTX_set_tlsext_use_srtp(ctx, srtp_ciphers_.c_str())) {
+ SSL_CTX_free(ctx);
+ return NULL;
+ }
+ }
+#endif
+
return ctx;
}
@@ -596,6 +835,29 @@
LOG(LS_INFO) << "Accepted self-signed peer certificate authority";
ok = 1;
}
+ } else if (!ok && !stream->peer_certificate_digest_algorithm_.empty()) {
+ X509* cert = X509_STORE_CTX_get_current_cert(store);
+ int err = X509_STORE_CTX_get_error(store);
+
+ // peer-to-peer mode: allow the certificate to be self-signed,
+ // assuming it matches the digest that was specified.
+ if (err == X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT) {
+ unsigned char digest[EVP_MAX_MD_SIZE];
+ std::size_t digest_length;
+
+ if (OpenSSLCertificate::
+ ComputeDigest(cert,
+ stream->peer_certificate_digest_algorithm_,
+ digest, sizeof(digest),
+ &digest_length)) {
+ Buffer computed_digest(digest, digest_length);
+ if (computed_digest == stream->peer_certificate_digest_value_) {
+ LOG(LS_INFO) <<
+ "Accepted self-signed peer certificate authority";
+ ok = 1;
+ }
+ }
+ }
} else if (!ok && OpenSSLAdapter::custom_verify_callback_) {
// this applies only in traditional mode
void* cert =
@@ -619,10 +881,12 @@
// sample in chapter 5
bool OpenSSLStreamAdapter::SSLPostConnectionCheck(SSL* ssl,
const char* server_name,
- const X509* peer_cert) {
+ const X509* peer_cert,
+ const std::string
+ &peer_digest) {
ASSERT(server_name != NULL);
bool ok;
- if(server_name[0] != '\0') { // traditional mode
+ if (server_name[0] != '\0') { // traditional mode
ok = OpenSSLAdapter::VerifyServerName(ssl, server_name, ignore_bad_cert());
if (ok) {
@@ -630,7 +894,7 @@
custom_verification_succeeded_);
}
} else { // peer-to-peer mode
- ASSERT(peer_cert != NULL);
+ ASSERT((peer_cert != NULL) || (!peer_digest.empty()));
// no server name validation
ok = true;
}
@@ -645,6 +909,30 @@
return ok;
}
+bool OpenSSLStreamAdapter::HaveDtls() {
+#ifdef HAVE_DTLS
+ return true;
+#else
+ return false;
+#endif
+}
+
+bool OpenSSLStreamAdapter::HaveDtlsSrtp() {
+#ifdef HAVE_DTLS_SRTP
+ return true;
+#else
+ return false;
+#endif
+}
+
+bool OpenSSLStreamAdapter::HaveExporter() {
+#ifdef HAVE_DTLS_SRTP
+ return true;
+#else
+ return false;
+#endif
+}
+
} // namespace talk_base
#endif // HAVE_OPENSSL_SSL_H
diff --git a/talk/base/opensslstreamadapter.h b/talk/base/opensslstreamadapter.h
index 16ec751..8e92a10 100644
--- a/talk/base/opensslstreamadapter.h
+++ b/talk/base/opensslstreamadapter.h
@@ -29,6 +29,9 @@
#define TALK_BASE_OPENSSLSTREAMADAPTER_H__
#include <string>
+#include <vector>
+
+#include "talk/base/buffer.h"
#include "talk/base/sslstreamadapter.h"
#include "talk/base/opensslidentity.h"
@@ -75,11 +78,17 @@
virtual ~OpenSSLStreamAdapter();
virtual void SetIdentity(SSLIdentity* identity);
- virtual void SetServerRole();
+
+ // Default argument is for compatibility
+ virtual void SetServerRole(SSLRole role = SSL_SERVER);
virtual void SetPeerCertificate(SSLCertificate* cert);
+ virtual bool SetPeerCertificateDigest(const std::string& digest_alg,
+ const unsigned char* digest_val,
+ size_t digest_len);
virtual int StartSSLWithServer(const char* server_name);
virtual int StartSSLWithPeer();
+ virtual void SetMode(SSLMode mode);
virtual StreamResult Read(void* data, size_t data_len,
size_t* read, int* error);
@@ -88,6 +97,24 @@
virtual void Close();
virtual StreamState GetState() const;
+ // Key Extractor interface
+ virtual bool ExportKeyingMaterial(const std::string& label,
+ const uint8* context,
+ size_t context_len,
+ bool use_context,
+ uint8* result,
+ size_t result_len);
+
+
+ // DTLS-SRTP interface
+ virtual bool SetDtlsSrtpCiphers(const std::vector<std::string>& ciphers);
+ virtual bool GetDtlsSrtpCipher(std::string* cipher);
+
+ // Capabilities interfaces
+ static bool HaveDtls();
+ static bool HaveDtlsSrtp();
+ static bool HaveExporter();
+
protected:
virtual void OnEvent(StreamInterface* stream, int events, int err);
@@ -102,9 +129,8 @@
SSL_ERROR, // some SSL error occurred, stream is closed
SSL_CLOSED // Clean close
};
- enum SSLRole {
- SSL_CLIENT, SSL_SERVER
- };
+
+ enum { MSG_TIMEOUT = MSG_MAX+1};
// The following three methods return 0 on success and a negative
// error code on failure. The error code may be from OpenSSL or -1
@@ -129,11 +155,18 @@
void Error(const char* context, int err, bool signal);
void Cleanup();
+ // Override MessageHandler
+ virtual void OnMessage(Message* msg);
+
+ // Flush the input buffers by reading left bytes (for DTLS)
+ void FlushInput(unsigned int left);
+
// SSL library configuration
SSL_CTX* SetupSSLContext();
// SSL verification check
bool SSLPostConnectionCheck(SSL* ssl, const char* server_name,
- const X509* peer_cert);
+ const X509* peer_cert,
+ const std::string& peer_digest);
// SSL certification verification error handler, called back from
// the openssl library. Returns an int interpreted as a boolean in
// the C style: zero means verification failure, non-zero means
@@ -151,17 +184,28 @@
SSL* ssl_;
SSL_CTX* ssl_ctx_;
- // in traditional mode, the server name that the server's certificate
- // must specify. Empty in peer-to-peer mode.
+
// Our key and certificate, mostly useful in peer-to-peer mode.
scoped_ptr<OpenSSLIdentity> identity_;
+ // in traditional mode, the server name that the server's certificate
+ // must specify. Empty in peer-to-peer mode.
std::string ssl_server_name_;
// In peer-to-peer mode, the certificate that the peer must
// present. Empty in traditional mode.
scoped_ptr<OpenSSLCertificate> peer_certificate_;
+ // In peer-to-peer mode, the digest of the certificate that
+ // the peer must present.
+ Buffer peer_certificate_digest_value_;
+ std::string peer_certificate_digest_algorithm_;
// OpenSSLAdapter::custom_verify_callback_ result
bool custom_verification_succeeded_;
+
+ // The DtlsSrtp ciphers
+ std::string srtp_ciphers_;
+
+ // Do DTLS or not
+ SSLMode ssl_mode_;
};
/////////////////////////////////////////////////////////////////////////////
diff --git a/talk/base/optionsfile.cc b/talk/base/optionsfile.cc
new file mode 100644
index 0000000..82a5c86
--- /dev/null
+++ b/talk/base/optionsfile.cc
@@ -0,0 +1,201 @@
+/*
+ * libjingle
+ * Copyright 2008, 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/base/optionsfile.h"
+
+#include <ctype.h>
+
+#include "talk/base/logging.h"
+#include "talk/base/stream.h"
+#include "talk/base/stringencode.h"
+
+namespace talk_base {
+
+OptionsFile::OptionsFile(const std::string &path) : path_(path) {
+}
+
+bool OptionsFile::Load() {
+ options_.clear();
+ // Open file.
+ FileStream stream;
+ int err;
+ if (!stream.Open(path_, "r", &err)) {
+ LOG_F(LS_WARNING) << "Could not open file, err=" << err;
+ // We do not consider this an error because we expect there to be no file
+ // until the user saves a setting.
+ return true;
+ }
+ // Read in all its data.
+ std::string line;
+ StreamResult res;
+ for (;;) {
+ res = stream.ReadLine(&line);
+ if (res != SR_SUCCESS) {
+ break;
+ }
+ size_t equals_pos = line.find('=');
+ if (equals_pos == std::string::npos) {
+ // We do not consider this an error. Instead we ignore the line and
+ // keep going.
+ LOG_F(LS_WARNING) << "Ignoring malformed line in " << path_;
+ continue;
+ }
+ std::string key(line, 0, equals_pos);
+ std::string value(line, equals_pos + 1, line.length() - (equals_pos + 1));
+ options_[key] = value;
+ }
+ if (res != SR_EOS) {
+ LOG_F(LS_ERROR) << "Error when reading from file";
+ return false;
+ } else {
+ return true;
+ }
+}
+
+bool OptionsFile::Save() {
+ // Open file.
+ FileStream stream;
+ int err;
+ if (!stream.Open(path_, "w", &err)) {
+ LOG_F(LS_ERROR) << "Could not open file, err=" << err;
+ return false;
+ }
+ // Write out all the data.
+ StreamResult res = SR_SUCCESS;
+ size_t written;
+ int error;
+ for (OptionsMap::const_iterator i = options_.begin(); i != options_.end();
+ ++i) {
+ res = stream.WriteAll(i->first.c_str(), i->first.length(), &written,
+ &error);
+ if (res != SR_SUCCESS) {
+ break;
+ }
+ res = stream.WriteAll("=", 1, &written, &error);
+ if (res != SR_SUCCESS) {
+ break;
+ }
+ res = stream.WriteAll(i->second.c_str(), i->second.length(), &written,
+ &error);
+ if (res != SR_SUCCESS) {
+ break;
+ }
+ res = stream.WriteAll("\n", 1, &written, &error);
+ if (res != SR_SUCCESS) {
+ break;
+ }
+ }
+ if (res != SR_SUCCESS) {
+ LOG_F(LS_ERROR) << "Unable to write to file";
+ return false;
+ } else {
+ return true;
+ }
+}
+
+bool OptionsFile::IsLegalName(const std::string &name) {
+ for (size_t pos = 0; pos < name.length(); ++pos) {
+ if (name[pos] == '\n' || name[pos] == '\\' || name[pos] == '=') {
+ // Illegal character.
+ LOG(LS_WARNING) << "Ignoring operation for illegal option " << name;
+ return false;
+ }
+ }
+ return true;
+}
+
+bool OptionsFile::IsLegalValue(const std::string &value) {
+ for (size_t pos = 0; pos < value.length(); ++pos) {
+ if (value[pos] == '\n' || value[pos] == '\\') {
+ // Illegal character.
+ LOG(LS_WARNING) << "Ignoring operation for illegal value " << value;
+ return false;
+ }
+ }
+ return true;
+}
+
+bool OptionsFile::GetStringValue(const std::string& option,
+ std::string *out_val) const {
+ LOG(LS_VERBOSE) << "OptionsFile::GetStringValue "
+ << option;
+ if (!IsLegalName(option)) {
+ return false;
+ }
+ OptionsMap::const_iterator i = options_.find(option);
+ if (i == options_.end()) {
+ return false;
+ }
+ *out_val = i->second;
+ return true;
+}
+
+bool OptionsFile::GetIntValue(const std::string& option,
+ int *out_val) const {
+ LOG(LS_VERBOSE) << "OptionsFile::GetIntValue "
+ << option;
+ if (!IsLegalName(option)) {
+ return false;
+ }
+ OptionsMap::const_iterator i = options_.find(option);
+ if (i == options_.end()) {
+ return false;
+ }
+ return FromString(i->second, out_val);
+}
+
+bool OptionsFile::SetStringValue(const std::string& option,
+ const std::string& value) {
+ LOG(LS_VERBOSE) << "OptionsFile::SetStringValue "
+ << option << ":" << value;
+ if (!IsLegalName(option) || !IsLegalValue(value)) {
+ return false;
+ }
+ options_[option] = value;
+ return true;
+}
+
+bool OptionsFile::SetIntValue(const std::string& option,
+ int value) {
+ LOG(LS_VERBOSE) << "OptionsFile::SetIntValue "
+ << option << ":" << value;
+ if (!IsLegalName(option)) {
+ return false;
+ }
+ return ToString(value, &options_[option]);
+}
+
+bool OptionsFile::RemoveValue(const std::string& option) {
+ LOG(LS_VERBOSE) << "OptionsFile::RemoveValue " << option;
+ if (!IsLegalName(option)) {
+ return false;
+ }
+ options_.erase(option);
+ return true;
+}
+
+} // namespace talk_base
diff --git a/talk/base/optionsfile.h b/talk/base/optionsfile.h
new file mode 100644
index 0000000..9e5f457
--- /dev/null
+++ b/talk/base/optionsfile.h
@@ -0,0 +1,66 @@
+/*
+ * libjingle
+ * Copyright 2008, 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_BASE_OPTIONSFILE_H_
+#define TALK_BASE_OPTIONSFILE_H_
+
+#include <map>
+#include <string>
+
+namespace talk_base {
+
+// Implements storage of simple options in a text file on disk. This is
+// cross-platform, but it is intended mostly for Linux where there is no
+// first-class options storage system.
+class OptionsFile {
+ public:
+ OptionsFile(const std::string &path);
+
+ // Loads the file from disk, overwriting the in-memory values.
+ bool Load();
+ // Saves the contents in memory, overwriting the on-disk values.
+ bool Save();
+
+ bool GetStringValue(const std::string& option, std::string* out_val) const;
+ bool GetIntValue(const std::string& option, int* out_val) const;
+ bool SetStringValue(const std::string& option, const std::string& val);
+ bool SetIntValue(const std::string& option, int val);
+ bool RemoveValue(const std::string& option);
+
+ private:
+ typedef std::map<std::string, std::string> OptionsMap;
+
+ static bool IsLegalName(const std::string &name);
+ static bool IsLegalValue(const std::string &value);
+
+ std::string path_;
+ OptionsMap options_;
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_OPTIONSFILE_H_
diff --git a/talk/base/optionsfile_unittest.cc b/talk/base/optionsfile_unittest.cc
new file mode 100644
index 0000000..65861ff
--- /dev/null
+++ b/talk/base/optionsfile_unittest.cc
@@ -0,0 +1,178 @@
+/*
+ * libjingle
+ * Copyright 2008, 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/base/gunit.h"
+#include "talk/base/optionsfile.h"
+
+namespace talk_base {
+
+#ifdef ANDROID
+static const char *kTestFile = "/sdcard/.testfile";
+#elif CHROMEOS
+static const char *kTestFile = "/tmp/.testfile";
+#else
+static const char *kTestFile = ".testfile";
+#endif
+
+static const std::string kTestOptionA = "test-option-a";
+static const std::string kTestOptionB = "test-option-b";
+static const std::string kTestString1 = "a string";
+static const std::string kTestString2 = "different string";
+static const std::string kOptionWithEquals = "foo=bar";
+static const std::string kOptionWithNewline = "foo\nbar";
+static const std::string kValueWithEquals = "baz=quux";
+static const std::string kValueWithNewline = "baz\nquux";
+static const std::string kEmptyString = "";
+static const char kOptionWithUtf8[] = {'O', 'p', 't', '\302', '\256', 'i', 'o',
+ 'n', '\342', '\204', '\242', '\0'}; // Opt(R)io(TM).
+static const char kValueWithUtf8[] = {'V', 'a', 'l', '\302', '\256', 'v', 'e',
+ '\342', '\204', '\242', '\0'}; // Val(R)ue(TM).
+static int kTestInt1 = 12345;
+static int kTestInt2 = 67890;
+static int kNegInt = -634;
+static int kZero = 0;
+
+TEST(OptionsFile, GetSetString) {
+ OptionsFile store(kTestFile);
+ // Clear contents of the file on disk.
+ EXPECT_TRUE(store.Save());
+ std::string out1, out2;
+ EXPECT_FALSE(store.GetStringValue(kTestOptionA, &out1));
+ EXPECT_FALSE(store.GetStringValue(kTestOptionB, &out2));
+ EXPECT_TRUE(store.SetStringValue(kTestOptionA, kTestString1));
+ EXPECT_TRUE(store.Save());
+ EXPECT_TRUE(store.Load());
+ EXPECT_TRUE(store.SetStringValue(kTestOptionB, kTestString2));
+ EXPECT_TRUE(store.Save());
+ EXPECT_TRUE(store.Load());
+ EXPECT_TRUE(store.GetStringValue(kTestOptionA, &out1));
+ EXPECT_TRUE(store.GetStringValue(kTestOptionB, &out2));
+ EXPECT_EQ(kTestString1, out1);
+ EXPECT_EQ(kTestString2, out2);
+ EXPECT_TRUE(store.RemoveValue(kTestOptionA));
+ EXPECT_TRUE(store.Save());
+ EXPECT_TRUE(store.Load());
+ EXPECT_TRUE(store.RemoveValue(kTestOptionB));
+ EXPECT_TRUE(store.Save());
+ EXPECT_TRUE(store.Load());
+ EXPECT_FALSE(store.GetStringValue(kTestOptionA, &out1));
+ EXPECT_FALSE(store.GetStringValue(kTestOptionB, &out2));
+}
+
+TEST(OptionsFile, GetSetInt) {
+ OptionsFile store(kTestFile);
+ // Clear contents of the file on disk.
+ EXPECT_TRUE(store.Save());
+ int out1, out2;
+ EXPECT_FALSE(store.GetIntValue(kTestOptionA, &out1));
+ EXPECT_FALSE(store.GetIntValue(kTestOptionB, &out2));
+ EXPECT_TRUE(store.SetIntValue(kTestOptionA, kTestInt1));
+ EXPECT_TRUE(store.Save());
+ EXPECT_TRUE(store.Load());
+ EXPECT_TRUE(store.SetIntValue(kTestOptionB, kTestInt2));
+ EXPECT_TRUE(store.Save());
+ EXPECT_TRUE(store.Load());
+ EXPECT_TRUE(store.GetIntValue(kTestOptionA, &out1));
+ EXPECT_TRUE(store.GetIntValue(kTestOptionB, &out2));
+ EXPECT_EQ(kTestInt1, out1);
+ EXPECT_EQ(kTestInt2, out2);
+ EXPECT_TRUE(store.RemoveValue(kTestOptionA));
+ EXPECT_TRUE(store.Save());
+ EXPECT_TRUE(store.Load());
+ EXPECT_TRUE(store.RemoveValue(kTestOptionB));
+ EXPECT_TRUE(store.Save());
+ EXPECT_TRUE(store.Load());
+ EXPECT_FALSE(store.GetIntValue(kTestOptionA, &out1));
+ EXPECT_FALSE(store.GetIntValue(kTestOptionB, &out2));
+ EXPECT_TRUE(store.SetIntValue(kTestOptionA, kNegInt));
+ EXPECT_TRUE(store.GetIntValue(kTestOptionA, &out1));
+ EXPECT_EQ(kNegInt, out1);
+ EXPECT_TRUE(store.SetIntValue(kTestOptionA, kZero));
+ EXPECT_TRUE(store.GetIntValue(kTestOptionA, &out1));
+ EXPECT_EQ(kZero, out1);
+}
+
+TEST(OptionsFile, Persist) {
+ {
+ OptionsFile store(kTestFile);
+ // Clear contents of the file on disk.
+ EXPECT_TRUE(store.Save());
+ EXPECT_TRUE(store.SetStringValue(kTestOptionA, kTestString1));
+ EXPECT_TRUE(store.SetIntValue(kTestOptionB, kNegInt));
+ EXPECT_TRUE(store.Save());
+ }
+ {
+ OptionsFile store(kTestFile);
+ // Load the saved contents from above.
+ EXPECT_TRUE(store.Load());
+ std::string out1;
+ int out2;
+ EXPECT_TRUE(store.GetStringValue(kTestOptionA, &out1));
+ EXPECT_TRUE(store.GetIntValue(kTestOptionB, &out2));
+ EXPECT_EQ(kTestString1, out1);
+ EXPECT_EQ(kNegInt, out2);
+ }
+}
+
+TEST(OptionsFile, SpecialCharacters) {
+ OptionsFile store(kTestFile);
+ // Clear contents of the file on disk.
+ EXPECT_TRUE(store.Save());
+ std::string out;
+ EXPECT_FALSE(store.SetStringValue(kOptionWithEquals, kTestString1));
+ EXPECT_FALSE(store.GetStringValue(kOptionWithEquals, &out));
+ EXPECT_FALSE(store.SetStringValue(kOptionWithNewline, kTestString1));
+ EXPECT_FALSE(store.GetStringValue(kOptionWithNewline, &out));
+ EXPECT_TRUE(store.SetStringValue(kOptionWithUtf8, kValueWithUtf8));
+ EXPECT_TRUE(store.SetStringValue(kTestOptionA, kTestString1));
+ EXPECT_TRUE(store.Save());
+ EXPECT_TRUE(store.Load());
+ EXPECT_TRUE(store.GetStringValue(kTestOptionA, &out));
+ EXPECT_EQ(kTestString1, out);
+ EXPECT_TRUE(store.GetStringValue(kOptionWithUtf8, &out));
+ EXPECT_EQ(kValueWithUtf8, out);
+ EXPECT_FALSE(store.SetStringValue(kTestOptionA, kValueWithNewline));
+ EXPECT_TRUE(store.GetStringValue(kTestOptionA, &out));
+ EXPECT_EQ(kTestString1, out);
+ EXPECT_TRUE(store.SetStringValue(kTestOptionA, kValueWithEquals));
+ EXPECT_TRUE(store.Save());
+ EXPECT_TRUE(store.Load());
+ EXPECT_TRUE(store.GetStringValue(kTestOptionA, &out));
+ EXPECT_EQ(kValueWithEquals, out);
+ EXPECT_TRUE(store.SetStringValue(kEmptyString, kTestString2));
+ EXPECT_TRUE(store.Save());
+ EXPECT_TRUE(store.Load());
+ EXPECT_TRUE(store.GetStringValue(kEmptyString, &out));
+ EXPECT_EQ(kTestString2, out);
+ EXPECT_TRUE(store.SetStringValue(kTestOptionB, kEmptyString));
+ EXPECT_TRUE(store.Save());
+ EXPECT_TRUE(store.Load());
+ EXPECT_TRUE(store.GetStringValue(kTestOptionB, &out));
+ EXPECT_EQ(kEmptyString, out);
+}
+
+} // namespace talk_base
diff --git a/talk/base/pathutils_unittest.cc b/talk/base/pathutils_unittest.cc
new file mode 100644
index 0000000..0a9739b
--- /dev/null
+++ b/talk/base/pathutils_unittest.cc
@@ -0,0 +1,65 @@
+/*
+ * libjingle
+ * Copyright 2007, 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/base/pathutils.h"
+#include "talk/base/gunit.h"
+
+TEST(Pathname, ReturnsDotForEmptyPathname) {
+ const std::string kCWD =
+ std::string(".") + talk_base::Pathname::DefaultFolderDelimiter();
+
+ talk_base::Pathname path("/", "");
+ EXPECT_FALSE(path.empty());
+ EXPECT_FALSE(path.folder().empty());
+ EXPECT_TRUE (path.filename().empty());
+ EXPECT_FALSE(path.pathname().empty());
+ EXPECT_EQ(std::string("/"), path.pathname());
+
+ path.SetPathname("", "foo");
+ EXPECT_FALSE(path.empty());
+ EXPECT_TRUE (path.folder().empty());
+ EXPECT_FALSE(path.filename().empty());
+ EXPECT_FALSE(path.pathname().empty());
+ EXPECT_EQ(std::string("foo"), path.pathname());
+
+ path.SetPathname("", "");
+ EXPECT_TRUE (path.empty());
+ EXPECT_TRUE (path.folder().empty());
+ EXPECT_TRUE (path.filename().empty());
+ EXPECT_FALSE(path.pathname().empty());
+ EXPECT_EQ(kCWD, path.pathname());
+
+ path.SetPathname(kCWD, "");
+ EXPECT_FALSE(path.empty());
+ EXPECT_FALSE(path.folder().empty());
+ EXPECT_TRUE (path.filename().empty());
+ EXPECT_FALSE(path.pathname().empty());
+ EXPECT_EQ(kCWD, path.pathname());
+
+ talk_base::Pathname path2("c:/foo bar.txt");
+ EXPECT_EQ(path2.url(), std::string("file:///c:/foo%20bar.txt"));
+}
diff --git a/talk/base/physicalsocketserver.cc b/talk/base/physicalsocketserver.cc
index 9cb5f4f..59eb550 100644
--- a/talk/base/physicalsocketserver.cc
+++ b/talk/base/physicalsocketserver.cc
@@ -57,7 +57,7 @@
#include "talk/base/logging.h"
#include "talk/base/nethelpers.h"
#include "talk/base/physicalsocketserver.h"
-#include "talk/base/time.h"
+#include "talk/base/timeutils.h"
#include "talk/base/winping.h"
#include "talk/base/win32socketinit.h"
@@ -591,7 +591,13 @@
// for 128.
static const int kNumPosixSignals = 128;
- static PosixSignalHandler *Instance() { return &instance_; }
+ // There is just a single global instance. (Signal handlers do not get any
+ // sort of user-defined void * parameter, so they can't access anything that
+ // isn't global.)
+ static PosixSignalHandler* Instance() {
+ LIBJINGLE_DEFINE_STATIC_LOCAL(PosixSignalHandler, instance, ());
+ return &instance;
+ }
// Returns true if the given signal number is set.
bool IsSignalSet(int signum) const {
@@ -674,11 +680,6 @@
close(fd2);
}
- // There is just a single global instance. (Signal handlers do not get any
- // sort of user-defined void * parameter, so they can't access anything that
- // isn't global.)
- static PosixSignalHandler instance_;
-
int afd_[2];
// These are boolean flags that will be set in our signal handler and read
// and cleared from Wait(). There is a race involved in this, but it is
@@ -693,8 +694,6 @@
volatile uint8 received_signal_[kNumPosixSignals];
};
-PosixSignalHandler PosixSignalHandler::instance_;
-
class PosixSignalDispatcher : public Dispatcher {
public:
PosixSignalDispatcher(PhysicalSocketServer *owner) : owner_(owner) {
@@ -1409,6 +1408,10 @@
return true;
}
+Dispatcher* PhysicalSocketServer::signal_dispatcher() {
+ return signal_dispatcher_.get();
+}
+
bool PhysicalSocketServer::InstallSignal(int signum, void (*handler)(int)) {
struct sigaction act;
// It doesn't really matter what we set this mask to.
diff --git a/talk/base/physicalsocketserver.h b/talk/base/physicalsocketserver.h
index aeb8348..1b7a298 100644
--- a/talk/base/physicalsocketserver.h
+++ b/talk/base/physicalsocketserver.h
@@ -2,26 +2,26 @@
* libjingle
* Copyright 2004--2005, Google Inc.
*
- * Redistribution and use in source and binary forms, with or without
+ * 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,
+ * 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
+ * 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
+ * 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,
+ * 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
+ * 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.
*/
@@ -73,7 +73,7 @@
// A socket server that provides the real sockets of the underlying OS.
class PhysicalSocketServer : public SocketServer {
-public:
+ public:
PhysicalSocketServer();
virtual ~PhysicalSocketServer();
@@ -104,10 +104,13 @@
// Dispatching signals on multiple PhysicalSocketServers is not reliable.
// The signal mask is not modified. It is the caller's responsibily to
// maintain it as desired.
- bool SetPosixSignalHandler(int signum, void (*handler)(int));
+ virtual bool SetPosixSignalHandler(int signum, void (*handler)(int));
+
+ protected:
+ Dispatcher* signal_dispatcher();
#endif
-private:
+ private:
typedef std::vector<Dispatcher*> DispatcherList;
typedef std::vector<size_t*> IteratorList;
diff --git a/talk/base/physicalsocketserver_unittest.cc b/talk/base/physicalsocketserver_unittest.cc
new file mode 100644
index 0000000..fa51e55
--- /dev/null
+++ b/talk/base/physicalsocketserver_unittest.cc
@@ -0,0 +1,224 @@
+/*
+ * libjingle
+ * Copyright 2004--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 <signal.h>
+#include <stdarg.h>
+
+#include "talk/base/gunit.h"
+#include "talk/base/logging.h"
+#include "talk/base/physicalsocketserver.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/socket_unittest.h"
+#include "talk/base/thread.h"
+
+namespace talk_base {
+
+class PhysicalSocketTest : public SocketTest {
+};
+
+TEST_F(PhysicalSocketTest, TestConnect) {
+ SocketTest::TestConnect();
+}
+
+TEST_F(PhysicalSocketTest, TestConnectWithDnsLookup) {
+ SocketTest::TestConnectWithDnsLookup();
+}
+
+TEST_F(PhysicalSocketTest, TestConnectFail) {
+ SocketTest::TestConnectFail();
+}
+
+TEST_F(PhysicalSocketTest, TestConnectWithDnsLookupFail) {
+ SocketTest::TestConnectWithDnsLookupFail();
+}
+
+#ifdef OSX
+// This test crashes the OS X kernel on 10.6 (at bsd/netinet/tcp_subr.c:2118).
+TEST_F(PhysicalSocketTest, DISABLED_TestConnectWithClosedSocket) {
+#else
+TEST_F(PhysicalSocketTest, TestConnectWithClosedSocket) {
+#endif
+ SocketTest::TestConnectWithClosedSocket();
+}
+
+TEST_F(PhysicalSocketTest, TestServerCloseDuringConnect) {
+ SocketTest::TestServerCloseDuringConnect();
+}
+
+TEST_F(PhysicalSocketTest, TestClientCloseDuringConnect) {
+ SocketTest::TestClientCloseDuringConnect();
+}
+
+TEST_F(PhysicalSocketTest, TestServerClose) {
+ SocketTest::TestServerClose();
+}
+
+TEST_F(PhysicalSocketTest, TestCloseInClosedCallback) {
+ SocketTest::TestCloseInClosedCallback();
+}
+
+TEST_F(PhysicalSocketTest, TestSocketServerWait) {
+ SocketTest::TestSocketServerWait();
+}
+
+TEST_F(PhysicalSocketTest, TestTcp) {
+ SocketTest::TestTcp();
+}
+
+TEST_F(PhysicalSocketTest, TestUdp) {
+ SocketTest::TestUdp();
+}
+
+TEST_F(PhysicalSocketTest, TestGetSetOptions) {
+ SocketTest::TestGetSetOptions();
+}
+
+#ifdef POSIX
+
+class PosixSignalDeliveryTest : public testing::Test {
+ public:
+ static void RecordSignal(int signum) {
+ signals_received_.push_back(signum);
+ signaled_thread_ = Thread::Current();
+ }
+
+ protected:
+ void SetUp() {
+ ss_.reset(new PhysicalSocketServer());
+ }
+
+ void TearDown() {
+ ss_.reset(NULL);
+ signals_received_.clear();
+ signaled_thread_ = NULL;
+ }
+
+ bool ExpectSignal(int signum) {
+ if (signals_received_.empty()) {
+ LOG(LS_ERROR) << "ExpectSignal(): No signal received";
+ return false;
+ }
+ if (signals_received_[0] != signum) {
+ LOG(LS_ERROR) << "ExpectSignal(): Received signal " <<
+ signals_received_[0] << ", expected " << signum;
+ return false;
+ }
+ signals_received_.erase(signals_received_.begin());
+ return true;
+ }
+
+ bool ExpectNone() {
+ bool ret = signals_received_.empty();
+ if (!ret) {
+ LOG(LS_ERROR) << "ExpectNone(): Received signal " << signals_received_[0]
+ << ", expected none";
+ }
+ return ret;
+ }
+
+ static std::vector<int> signals_received_;
+ static Thread *signaled_thread_;
+
+ scoped_ptr<PhysicalSocketServer> ss_;
+};
+
+std::vector<int> PosixSignalDeliveryTest::signals_received_;
+Thread *PosixSignalDeliveryTest::signaled_thread_ = NULL;
+
+// Test receiving a synchronous signal while not in Wait() and then entering
+// Wait() afterwards.
+TEST_F(PosixSignalDeliveryTest, RaiseThenWait) {
+ ss_->SetPosixSignalHandler(SIGTERM, &RecordSignal);
+ raise(SIGTERM);
+ EXPECT_TRUE(ss_->Wait(0, true));
+ EXPECT_TRUE(ExpectSignal(SIGTERM));
+ EXPECT_TRUE(ExpectNone());
+}
+
+// Test that we can handle getting tons of repeated signals and that we see all
+// the different ones.
+TEST_F(PosixSignalDeliveryTest, InsanelyManySignals) {
+ ss_->SetPosixSignalHandler(SIGTERM, &RecordSignal);
+ ss_->SetPosixSignalHandler(SIGINT, &RecordSignal);
+ for (int i = 0; i < 10000; ++i) {
+ raise(SIGTERM);
+ }
+ raise(SIGINT);
+ EXPECT_TRUE(ss_->Wait(0, true));
+ // Order will be lowest signal numbers first.
+ EXPECT_TRUE(ExpectSignal(SIGINT));
+ EXPECT_TRUE(ExpectSignal(SIGTERM));
+ EXPECT_TRUE(ExpectNone());
+}
+
+// Test that a signal during a Wait() call is detected.
+TEST_F(PosixSignalDeliveryTest, SignalDuringWait) {
+ ss_->SetPosixSignalHandler(SIGALRM, &RecordSignal);
+ alarm(1);
+ EXPECT_TRUE(ss_->Wait(1500, true));
+ EXPECT_TRUE(ExpectSignal(SIGALRM));
+ EXPECT_TRUE(ExpectNone());
+}
+
+class RaiseSigTermRunnable : public Runnable {
+ void Run(Thread *thread) {
+ thread->socketserver()->Wait(1000, false);
+
+ // Allow SIGTERM. This will be the only thread with it not masked so it will
+ // be delivered to us.
+ sigset_t mask;
+ sigemptyset(&mask);
+ pthread_sigmask(SIG_SETMASK, &mask, NULL);
+
+ // Raise it.
+ raise(SIGTERM);
+ }
+};
+
+// Test that it works no matter what thread the kernel chooses to give the
+// signal to (since it's not guaranteed to be the one that Wait() runs on).
+TEST_F(PosixSignalDeliveryTest, SignalOnDifferentThread) {
+ ss_->SetPosixSignalHandler(SIGTERM, &RecordSignal);
+ // Mask out SIGTERM so that it can't be delivered to this thread.
+ sigset_t mask;
+ sigemptyset(&mask);
+ sigaddset(&mask, SIGTERM);
+ EXPECT_EQ(0, pthread_sigmask(SIG_SETMASK, &mask, NULL));
+ // Start a new thread that raises it. It will have to be delivered to that
+ // thread. Our implementation should safely handle it and dispatch
+ // RecordSignal() on this thread.
+ scoped_ptr<Thread> thread(new Thread());
+ thread->Start(new RaiseSigTermRunnable());
+ EXPECT_TRUE(ss_->Wait(1500, true));
+ EXPECT_TRUE(ExpectSignal(SIGTERM));
+ EXPECT_EQ(Thread::Current(), signaled_thread_);
+ EXPECT_TRUE(ExpectNone());
+}
+
+#endif
+
+} // namespace talk_base
diff --git a/talk/base/posix.cc b/talk/base/posix.cc
new file mode 100644
index 0000000..3502f6d
--- /dev/null
+++ b/talk/base/posix.cc
@@ -0,0 +1,148 @@
+/*
+ * libjingle
+ * Copyright 2004--2009, 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/base/posix.h"
+
+#include <sys/wait.h>
+#include <errno.h>
+#include <unistd.h>
+
+#ifdef LINUX
+#include "talk/base/linuxfdwalk.h"
+#endif
+#include "talk/base/logging.h"
+
+namespace talk_base {
+
+#ifdef LINUX
+static void closefds(void *close_errors, int fd) {
+ if (fd <= 2) {
+ // We leave stdin/out/err open to the browser's terminal, if any.
+ return;
+ }
+ if (close(fd) < 0) {
+ *static_cast<bool *>(close_errors) = true;
+ }
+}
+#endif
+
+enum {
+ EXIT_FLAG_CHDIR_ERRORS = 1 << 0,
+#ifdef LINUX
+ EXIT_FLAG_FDWALK_ERRORS = 1 << 1,
+ EXIT_FLAG_CLOSE_ERRORS = 1 << 2,
+#endif
+ EXIT_FLAG_SECOND_FORK_FAILED = 1 << 3,
+};
+
+bool RunAsDaemon(const char *file, const char *const argv[]) {
+ // Fork intermediate child to daemonize.
+ pid_t pid = fork();
+ if (pid < 0) {
+ LOG_ERR(LS_ERROR) << "fork()";
+ return false;
+ } else if (!pid) {
+ // Child.
+
+ // We try to close all fds and change directory to /, but if that fails we
+ // keep going because it's not critical.
+ int exit_code = 0;
+ if (chdir("/") < 0) {
+ exit_code |= EXIT_FLAG_CHDIR_ERRORS;
+ }
+#ifdef LINUX
+ bool close_errors = false;
+ if (fdwalk(&closefds, &close_errors) < 0) {
+ exit_code |= EXIT_FLAG_FDWALK_ERRORS;
+ }
+ if (close_errors) {
+ exit_code |= EXIT_FLAG_CLOSE_ERRORS;
+ }
+#endif
+
+ // Fork again to become a daemon.
+ pid = fork();
+ // It is important that everything here use _exit() and not exit(), because
+ // exit() would call the destructors of all global variables in the whole
+ // process, which is both unnecessary and unsafe.
+ if (pid < 0) {
+ exit_code |= EXIT_FLAG_SECOND_FORK_FAILED;
+ _exit(exit_code); // if second fork failed
+ } else if (!pid) {
+ // Child.
+ // Successfully daemonized. Run command.
+ // POSIX requires the args to be typed as non-const for historical
+ // reasons, but it mandates that the actual implementation be const, so
+ // the cast is safe.
+ execvp(file, const_cast<char *const *>(argv));
+ _exit(255); // if execvp failed
+ }
+
+ // Parent.
+ // Successfully spawned process, but report any problems to the parent where
+ // we can log them.
+ _exit(exit_code);
+ }
+
+ // Parent. Reap intermediate child.
+ int status;
+ pid_t child = waitpid(pid, &status, 0);
+ if (child < 0) {
+ LOG_ERR(LS_ERROR) << "Error in waitpid()";
+ return false;
+ }
+ if (child != pid) {
+ // Should never happen (see man page).
+ LOG(LS_ERROR) << "waitpid() chose wrong child???";
+ return false;
+ }
+ if (!WIFEXITED(status)) {
+ LOG(LS_ERROR) << "Intermediate child killed uncleanly"; // Probably crashed
+ return false;
+ }
+
+ int exit_code = WEXITSTATUS(status);
+ if (exit_code & EXIT_FLAG_CHDIR_ERRORS) {
+ LOG(LS_WARNING) << "Child reported probles calling chdir()";
+ }
+#ifdef LINUX
+ if (exit_code & EXIT_FLAG_FDWALK_ERRORS) {
+ LOG(LS_WARNING) << "Child reported problems calling fdwalk()";
+ }
+ if (exit_code & EXIT_FLAG_CLOSE_ERRORS) {
+ LOG(LS_WARNING) << "Child reported problems calling close()";
+ }
+#endif
+ if (exit_code & EXIT_FLAG_SECOND_FORK_FAILED) {
+ LOG(LS_ERROR) << "Failed to daemonize";
+ // This means the command was not launched, so failure.
+ return false;
+ }
+ return true;
+}
+
+} // namespace talk_base
diff --git a/talk/base/posix.h b/talk/base/posix.h
new file mode 100644
index 0000000..15c2c90
--- /dev/null
+++ b/talk/base/posix.h
@@ -0,0 +1,42 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, 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_BASE_POSIX_H_
+#define TALK_BASE_POSIX_H_
+
+namespace talk_base {
+
+// Runs the given executable name as a daemon, so that it executes concurrently
+// with this process. Upon completion, the daemon process will automatically be
+// reaped by init(8), so an error exit status or a failure to start the
+// executable are not reported. Returns true if the daemon process was forked
+// successfully, else false.
+bool RunAsDaemon(const char *file, const char *const argv[]);
+
+} // namespace talk_base
+
+#endif // TALK_BASE_POSIX_H_
diff --git a/talk/base/proxy_unittest.cc b/talk/base/proxy_unittest.cc
new file mode 100644
index 0000000..e1a51f3
--- /dev/null
+++ b/talk/base/proxy_unittest.cc
@@ -0,0 +1,149 @@
+/*
+ * libjingle
+ * Copyright 2009, 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 "talk/base/autodetectproxy.h"
+#include "talk/base/gunit.h"
+#include "talk/base/httpserver.h"
+#include "talk/base/proxyserver.h"
+#include "talk/base/socketadapters.h"
+#include "talk/base/testclient.h"
+#include "talk/base/testechoserver.h"
+#include "talk/base/virtualsocketserver.h"
+
+using talk_base::Socket;
+using talk_base::Thread;
+using talk_base::SocketAddress;
+
+static const SocketAddress kSocksProxyIntAddr("1.2.3.4", 1080);
+static const SocketAddress kSocksProxyExtAddr("1.2.3.5", 0);
+static const SocketAddress kHttpsProxyIntAddr("1.2.3.4", 443);
+static const SocketAddress kHttpsProxyExtAddr("1.2.3.5", 0);
+static const SocketAddress kBogusProxyIntAddr("1.2.3.4", 999);
+
+// Used to run a proxy detect on the current thread. Otherwise we would need
+// to make both threads share the same VirtualSocketServer.
+class AutoDetectProxyRunner : public talk_base::AutoDetectProxy {
+ public:
+ explicit AutoDetectProxyRunner(const std::string& agent)
+ : AutoDetectProxy(agent) {}
+ void Run() {
+ DoWork();
+ Thread::Current()->Restart(); // needed to reset the messagequeue
+ }
+};
+
+// Sets up a virtual socket server and HTTPS/SOCKS5 proxy servers.
+class ProxyTest : public testing::Test {
+ public:
+ ProxyTest() : ss_(new talk_base::VirtualSocketServer(NULL)) {
+ Thread::Current()->set_socketserver(ss_.get());
+ socks_.reset(new talk_base::SocksProxyServer(
+ ss_.get(), kSocksProxyIntAddr, ss_.get(), kSocksProxyExtAddr));
+ https_.reset(new talk_base::HttpListenServer());
+ https_->Listen(kHttpsProxyIntAddr);
+ }
+ ~ProxyTest() {
+ Thread::Current()->set_socketserver(NULL);
+ }
+
+ talk_base::SocketServer* ss() { return ss_.get(); }
+
+ talk_base::ProxyType DetectProxyType(const SocketAddress& address) {
+ talk_base::ProxyType type;
+ AutoDetectProxyRunner* detect = new AutoDetectProxyRunner("unittest/1.0");
+ detect->set_proxy(address);
+ detect->Run(); // blocks until done
+ type = detect->proxy().type;
+ detect->Destroy(false);
+ return type;
+ }
+
+ private:
+ talk_base::scoped_ptr<talk_base::SocketServer> ss_;
+ talk_base::scoped_ptr<talk_base::SocksProxyServer> socks_;
+ // TODO: Make this a real HTTPS proxy server.
+ talk_base::scoped_ptr<talk_base::HttpListenServer> https_;
+};
+
+// Tests whether we can use a SOCKS5 proxy to connect to a server.
+TEST_F(ProxyTest, TestSocks5Connect) {
+ talk_base::AsyncSocket* socket = ss()->CreateAsyncSocket(SOCK_STREAM);
+ talk_base::AsyncSocksProxySocket* proxy_socket =
+ new talk_base::AsyncSocksProxySocket(socket, kSocksProxyIntAddr,
+ "", talk_base::CryptString());
+
+ talk_base::TestEchoServer server(Thread::Current(), SocketAddress());
+
+ talk_base::AsyncTCPSocket* packet_socket = talk_base::AsyncTCPSocket::Create(
+ proxy_socket, SocketAddress(), server.address());
+ EXPECT_TRUE(packet_socket != NULL);
+ talk_base::TestClient client(packet_socket);
+
+ EXPECT_EQ(Socket::CS_CONNECTING, proxy_socket->GetState());
+ EXPECT_TRUE(client.CheckConnected());
+ EXPECT_EQ(Socket::CS_CONNECTED, proxy_socket->GetState());
+ EXPECT_EQ(server.address(), client.remote_address());
+ client.Send("foo", 3);
+ EXPECT_TRUE(client.CheckNextPacket("foo", 3, NULL));
+ EXPECT_TRUE(client.CheckNoPacket());
+}
+
+/*
+// Tests whether we can use a HTTPS proxy to connect to a server.
+TEST_F(ProxyTest, TestHttpsConnect) {
+ AsyncSocket* socket = ss()->CreateAsyncSocket(SOCK_STREAM);
+ AsyncHttpsProxySocket* proxy_socket = new AsyncHttpsProxySocket(
+ socket, "unittest/1.0", kHttpsProxyIntAddress, "", CryptString());
+ TestClient client(new AsyncTCPSocket(proxy_socket));
+ TestEchoServer server(Thread::Current(), SocketAddress());
+
+ EXPECT_TRUE(client.Connect(server.address()));
+ EXPECT_TRUE(client.CheckConnected());
+ EXPECT_EQ(server.address(), client.remote_address());
+ client.Send("foo", 3);
+ EXPECT_TRUE(client.CheckNextPacket("foo", 3, NULL));
+ EXPECT_TRUE(client.CheckNoPacket());
+}
+*/
+
+// Tests whether we can autodetect a SOCKS5 proxy.
+TEST_F(ProxyTest, TestAutoDetectSocks5) {
+ EXPECT_EQ(talk_base::PROXY_SOCKS5, DetectProxyType(kSocksProxyIntAddr));
+}
+
+/*
+// Tests whether we can autodetect a HTTPS proxy.
+TEST_F(ProxyTest, TestAutoDetectHttps) {
+ EXPECT_EQ(talk_base::PROXY_HTTPS, DetectProxyType(kHttpsProxyIntAddr));
+}
+*/
+
+// Tests whether we fail properly for no proxy.
+TEST_F(ProxyTest, TestAutoDetectBogus) {
+ EXPECT_EQ(talk_base::PROXY_UNKNOWN, DetectProxyType(kBogusProxyIntAddr));
+}
diff --git a/talk/base/proxydetect.cc b/talk/base/proxydetect.cc
index 66213ee..4bfae29 100644
--- a/talk/base/proxydetect.cc
+++ b/talk/base/proxydetect.cc
@@ -233,7 +233,9 @@
m = 0;
uint32 mask = (m == 0) ? 0 : (~0UL) << (32 - m);
SocketAddress addr(url.host(), 0);
- return !addr.IsUnresolved() && ((addr.ip() & mask) == (ip & mask));
+ // TODO: Support IPv6 proxyitems. This code block is IPv4 only anyway.
+ return !addr.IsUnresolved() &&
+ ((addr.ipaddr().v4AddressAsHostOrderInteger() & mask) == (ip & mask));
}
// .foo.com
diff --git a/talk/base/proxydetect_unittest.cc b/talk/base/proxydetect_unittest.cc
new file mode 100644
index 0000000..4855650
--- /dev/null
+++ b/talk/base/proxydetect_unittest.cc
@@ -0,0 +1,182 @@
+/*
+ * libjingle
+ * Copyright 2010, 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 "talk/base/fileutils_mock.h"
+#include "talk/base/proxydetect.h"
+
+namespace talk_base {
+
+static const std::string kFirefoxProfilesIni =
+ "[Profile0]\n"
+ "Name=default\n"
+ "IsRelative=1\n"
+ "Path=Profiles/2de53ejb.default\n"
+ "Default=1\n";
+
+static const std::string kFirefoxHeader =
+ "# Mozilla User Preferences\n"
+ "\n"
+ "/* Some Comments\n"
+ "*\n"
+ "*/\n"
+ "\n";
+
+static const std::string kFirefoxCorruptHeader =
+ "iuahueqe32164";
+
+static const std::string kProxyAddress = "proxy.net.com";
+static const int kProxyPort = 9999;
+
+// Mocking out platform specific path to firefox prefs file.
+class FirefoxPrefsFileSystem : public FakeFileSystem {
+ public:
+ explicit FirefoxPrefsFileSystem(const std::vector<File>& all_files) :
+ FakeFileSystem(all_files) {
+ }
+ virtual FileStream* OpenFile(const Pathname& filename,
+ const std::string& mode) {
+ // TODO: We could have a platform dependent check of paths here.
+ std::string name = filename.basename();
+ name.append(filename.extension());
+ EXPECT_TRUE(name.compare("prefs.js") == 0 ||
+ name.compare("profiles.ini") == 0);
+ FileStream* stream = FakeFileSystem::OpenFile(name, mode);
+ return stream;
+ }
+};
+
+class ProxyDetectTest : public testing::Test {
+};
+
+bool GetProxyInfo(const std::string prefs, ProxyInfo* info) {
+ std::vector<talk_base::FakeFileSystem::File> files;
+ files.push_back(talk_base::FakeFileSystem::File("profiles.ini",
+ kFirefoxProfilesIni));
+ files.push_back(talk_base::FakeFileSystem::File("prefs.js", prefs));
+ talk_base::FilesystemScope fs(new talk_base::FirefoxPrefsFileSystem(files));
+ return GetProxySettingsForUrl("Firefox", "www.google.com", *info, false);
+}
+
+// Verifies that an empty Firefox prefs file results in no proxy detected.
+TEST_F(ProxyDetectTest, DISABLED_TestFirefoxEmptyPrefs) {
+ ProxyInfo proxy_info;
+ EXPECT_TRUE(GetProxyInfo(kFirefoxHeader, &proxy_info));
+ EXPECT_EQ(PROXY_NONE, proxy_info.type);
+}
+
+// Verifies that corrupted prefs file results in no proxy detected.
+TEST_F(ProxyDetectTest, DISABLED_TestFirefoxCorruptedPrefs) {
+ ProxyInfo proxy_info;
+ EXPECT_TRUE(GetProxyInfo(kFirefoxCorruptHeader, &proxy_info));
+ EXPECT_EQ(PROXY_NONE, proxy_info.type);
+}
+
+// Verifies that SOCKS5 proxy is detected if configured. SOCKS uses a
+// handshake protocol to inform the proxy software about the
+// connection that the client is trying to make and may be used for
+// any form of TCP or UDP socket connection.
+TEST_F(ProxyDetectTest, DISABLED_TestFirefoxProxySocks) {
+ ProxyInfo proxy_info;
+ SocketAddress proxy_address("proxy.socks.com", 6666);
+ std::string prefs(kFirefoxHeader);
+ prefs.append("user_pref(\"network.proxy.socks\", \"proxy.socks.com\");\n");
+ prefs.append("user_pref(\"network.proxy.socks_port\", 6666);\n");
+ prefs.append("user_pref(\"network.proxy.type\", 1);\n");
+
+ EXPECT_TRUE(GetProxyInfo(prefs, &proxy_info));
+
+ EXPECT_EQ(PROXY_SOCKS5, proxy_info.type);
+ EXPECT_EQ(proxy_address, proxy_info.address);
+}
+
+// Verified that SSL proxy is detected if configured. SSL proxy is an
+// extention of a HTTP proxy to support secure connections.
+TEST_F(ProxyDetectTest, DISABLED_TestFirefoxProxySsl) {
+ ProxyInfo proxy_info;
+ SocketAddress proxy_address("proxy.ssl.com", 7777);
+ std::string prefs(kFirefoxHeader);
+
+ prefs.append("user_pref(\"network.proxy.ssl\", \"proxy.ssl.com\");\n");
+ prefs.append("user_pref(\"network.proxy.ssl_port\", 7777);\n");
+ prefs.append("user_pref(\"network.proxy.type\", 1);\n");
+
+ EXPECT_TRUE(GetProxyInfo(prefs, &proxy_info));
+
+ EXPECT_EQ(PROXY_HTTPS, proxy_info.type);
+ EXPECT_EQ(proxy_address, proxy_info.address);
+}
+
+// Verifies that a HTTP proxy is detected if configured.
+TEST_F(ProxyDetectTest, DISABLED_TestFirefoxProxyHttp) {
+ ProxyInfo proxy_info;
+ SocketAddress proxy_address("proxy.http.com", 8888);
+ std::string prefs(kFirefoxHeader);
+
+ prefs.append("user_pref(\"network.proxy.http\", \"proxy.http.com\");\n");
+ prefs.append("user_pref(\"network.proxy.http_port\", 8888);\n");
+ prefs.append("user_pref(\"network.proxy.type\", 1);\n");
+
+ EXPECT_TRUE(GetProxyInfo(prefs, &proxy_info));
+
+ EXPECT_EQ(PROXY_HTTPS, proxy_info.type);
+ EXPECT_EQ(proxy_address, proxy_info.address);
+}
+
+// Verifies detection of automatic proxy detection.
+TEST_F(ProxyDetectTest, DISABLED_TestFirefoxProxyAuto) {
+ ProxyInfo proxy_info;
+ std::string prefs(kFirefoxHeader);
+
+ prefs.append("user_pref(\"network.proxy.type\", 4);\n");
+
+ EXPECT_TRUE(GetProxyInfo(prefs, &proxy_info));
+
+ EXPECT_EQ(PROXY_NONE, proxy_info.type);
+ EXPECT_TRUE(proxy_info.autodetect);
+ EXPECT_TRUE(proxy_info.autoconfig_url.empty());
+}
+
+// Verifies detection of automatic proxy detection using a static url
+// to config file.
+TEST_F(ProxyDetectTest, DISABLED_TestFirefoxProxyAutoUrl) {
+ ProxyInfo proxy_info;
+ std::string prefs(kFirefoxHeader);
+
+ prefs.append(
+ "user_pref(\"network.proxy.autoconfig_url\", \"http://a/b.pac\");\n");
+ prefs.append("user_pref(\"network.proxy.type\", 2);\n");
+
+ EXPECT_TRUE(GetProxyInfo(prefs, &proxy_info));
+
+ EXPECT_FALSE(proxy_info.autodetect);
+ EXPECT_EQ(PROXY_NONE, proxy_info.type);
+ EXPECT_EQ(0, proxy_info.autoconfig_url.compare("http://a/b.pac"));
+}
+
+} // namespace talk_base
diff --git a/talk/base/proxyserver.cc b/talk/base/proxyserver.cc
new file mode 100644
index 0000000..d764fd7
--- /dev/null
+++ b/talk/base/proxyserver.cc
@@ -0,0 +1,150 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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/base/proxyserver.h"
+
+#include <algorithm>
+#include "talk/base/socketfactory.h"
+
+namespace talk_base {
+
+// ProxyServer
+ProxyServer::ProxyServer(
+ SocketFactory* int_factory, const SocketAddress& int_addr,
+ SocketFactory* ext_factory, const SocketAddress& ext_ip)
+ : ext_factory_(ext_factory), ext_ip_(ext_ip.ipaddr(), 0), // strip off port
+ server_socket_(int_factory->CreateAsyncSocket(SOCK_STREAM)) {
+ server_socket_->Bind(int_addr);
+ server_socket_->Listen(5);
+ server_socket_->SignalReadEvent.connect(this, &ProxyServer::OnAcceptEvent);
+}
+
+ProxyServer::~ProxyServer() {
+ for (BindingList::iterator it = bindings_.begin();
+ it != bindings_.end(); ++it) {
+ delete (*it);
+ }
+}
+
+void ProxyServer::OnAcceptEvent(AsyncSocket* socket) {
+ ASSERT(socket == server_socket_.get());
+ AsyncSocket* int_socket = socket->Accept(NULL);
+ AsyncProxyServerSocket* wrapped_socket = WrapSocket(int_socket);
+ AsyncSocket* ext_socket = ext_factory_->CreateAsyncSocket(SOCK_STREAM);
+ ext_socket->Bind(ext_ip_);
+ bindings_.push_back(new ProxyBinding(wrapped_socket, ext_socket));
+}
+
+void ProxyServer::OnBindingDestroyed(ProxyBinding* binding) {
+ BindingList::iterator it =
+ std::find(bindings_.begin(), bindings_.end(), binding);
+ delete (*it);
+ bindings_.erase(it);
+}
+
+// ProxyBinding
+ProxyBinding::ProxyBinding(AsyncProxyServerSocket* int_socket,
+ AsyncSocket* ext_socket)
+ : int_socket_(int_socket), ext_socket_(ext_socket), connected_(false),
+ out_buffer_(kBufferSize), in_buffer_(kBufferSize) {
+ int_socket_->SignalConnectRequest.connect(this,
+ &ProxyBinding::OnConnectRequest);
+ int_socket_->SignalReadEvent.connect(this, &ProxyBinding::OnInternalRead);
+ int_socket_->SignalWriteEvent.connect(this, &ProxyBinding::OnInternalWrite);
+ int_socket_->SignalCloseEvent.connect(this, &ProxyBinding::OnInternalClose);
+ ext_socket_->SignalConnectEvent.connect(this,
+ &ProxyBinding::OnExternalConnect);
+ ext_socket_->SignalReadEvent.connect(this, &ProxyBinding::OnExternalRead);
+ ext_socket_->SignalWriteEvent.connect(this, &ProxyBinding::OnExternalWrite);
+ ext_socket_->SignalCloseEvent.connect(this, &ProxyBinding::OnExternalClose);
+}
+
+void ProxyBinding::OnConnectRequest(AsyncProxyServerSocket* socket,
+ const SocketAddress& addr) {
+ ASSERT(!connected_);
+ ext_socket_->Connect(addr);
+ // TODO: handle errors here
+}
+
+void ProxyBinding::OnInternalRead(AsyncSocket* socket) {
+ Read(int_socket_.get(), &out_buffer_);
+ Write(ext_socket_.get(), &out_buffer_);
+}
+
+void ProxyBinding::OnInternalWrite(AsyncSocket* socket) {
+ Write(int_socket_.get(), &in_buffer_);
+}
+
+void ProxyBinding::OnInternalClose(AsyncSocket* socket, int err) {
+ Destroy();
+}
+
+void ProxyBinding::OnExternalConnect(AsyncSocket* socket) {
+ connected_ = true;
+ int_socket_->SendConnectResult(0, socket->GetRemoteAddress());
+}
+
+void ProxyBinding::OnExternalRead(AsyncSocket* socket) {
+ Read(ext_socket_.get(), &in_buffer_);
+ Write(int_socket_.get(), &in_buffer_);
+}
+
+void ProxyBinding::OnExternalWrite(AsyncSocket* socket) {
+ Write(ext_socket_.get(), &out_buffer_);
+}
+
+void ProxyBinding::OnExternalClose(AsyncSocket* socket, int err) {
+ if (!connected_) {
+ int_socket_->SendConnectResult(err, SocketAddress());
+ }
+ Destroy();
+}
+
+void ProxyBinding::Read(AsyncSocket* socket, FifoBuffer* buffer) {
+ // Only read if the buffer is empty.
+ size_t size;
+ int read;
+ if (buffer->GetBuffered(&size) && size == 0) {
+ void* p = buffer->GetWriteBuffer(&size);
+ read = socket->Recv(p, size);
+ buffer->ConsumeWriteBuffer(_max(read, 0));
+ }
+}
+
+void ProxyBinding::Write(AsyncSocket* socket, FifoBuffer* buffer) {
+ size_t size;
+ int written;
+ const void* p = buffer->GetReadData(&size);
+ written = socket->Send(p, size);
+ buffer->ConsumeReadData(_max(written, 0));
+}
+
+void ProxyBinding::Destroy() {
+ SignalDestroyed(this);
+}
+
+} // namespace talk_base
diff --git a/talk/base/proxyserver.h b/talk/base/proxyserver.h
new file mode 100644
index 0000000..8e1ab6b
--- /dev/null
+++ b/talk/base/proxyserver.h
@@ -0,0 +1,113 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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_BASE_PROXYSERVER_H_
+#define TALK_BASE_PROXYSERVER_H_
+
+#include <list>
+#include "talk/base/asyncsocket.h"
+#include "talk/base/socketadapters.h"
+#include "talk/base/socketaddress.h"
+#include "talk/base/stream.h"
+
+namespace talk_base {
+
+class SocketFactory;
+
+// ProxyServer is a base class that allows for easy construction of proxy
+// servers. With its helper class ProxyBinding, it contains all the necessary
+// logic for receiving and bridging connections. The specific client-server
+// proxy protocol is implemented by an instance of the AsyncProxyServerSocket
+// class; children of ProxyServer implement WrapSocket appropriately to return
+// the correct protocol handler.
+
+class ProxyBinding : public sigslot::has_slots<> {
+ public:
+ ProxyBinding(AsyncProxyServerSocket* in_socket, AsyncSocket* out_socket);
+ sigslot::signal1<ProxyBinding*> SignalDestroyed;
+
+ private:
+ void OnConnectRequest(AsyncProxyServerSocket* socket,
+ const SocketAddress& addr);
+ void OnInternalRead(AsyncSocket* socket);
+ void OnInternalWrite(AsyncSocket* socket);
+ void OnInternalClose(AsyncSocket* socket, int err);
+ void OnExternalConnect(AsyncSocket* socket);
+ void OnExternalRead(AsyncSocket* socket);
+ void OnExternalWrite(AsyncSocket* socket);
+ void OnExternalClose(AsyncSocket* socket, int err);
+
+ static void Read(AsyncSocket* socket, FifoBuffer* buffer);
+ static void Write(AsyncSocket* socket, FifoBuffer* buffer);
+ void Destroy();
+
+ static const int kBufferSize = 4096;
+ scoped_ptr<AsyncProxyServerSocket> int_socket_;
+ scoped_ptr<AsyncSocket> ext_socket_;
+ bool connected_;
+ FifoBuffer out_buffer_;
+ FifoBuffer in_buffer_;
+ DISALLOW_EVIL_CONSTRUCTORS(ProxyBinding);
+};
+
+class ProxyServer : public sigslot::has_slots<> {
+ public:
+ ProxyServer(SocketFactory* int_factory, const SocketAddress& int_addr,
+ SocketFactory* ext_factory, const SocketAddress& ext_ip);
+ virtual ~ProxyServer();
+
+ protected:
+ void OnAcceptEvent(AsyncSocket* socket);
+ virtual AsyncProxyServerSocket* WrapSocket(AsyncSocket* socket) = 0;
+ void OnBindingDestroyed(ProxyBinding* binding);
+
+ private:
+ typedef std::list<ProxyBinding*> BindingList;
+ SocketFactory* ext_factory_;
+ SocketAddress ext_ip_;
+ scoped_ptr<AsyncSocket> server_socket_;
+ BindingList bindings_;
+ DISALLOW_EVIL_CONSTRUCTORS(ProxyServer);
+};
+
+// SocksProxyServer is a simple extension of ProxyServer to implement SOCKS.
+class SocksProxyServer : public ProxyServer {
+ public:
+ SocksProxyServer(SocketFactory* int_factory, const SocketAddress& int_addr,
+ SocketFactory* ext_factory, const SocketAddress& ext_ip)
+ : ProxyServer(int_factory, int_addr, ext_factory, ext_ip) {
+ }
+ protected:
+ AsyncProxyServerSocket* WrapSocket(AsyncSocket* socket) {
+ return new AsyncSocksProxyServerSocket(socket);
+ }
+ DISALLOW_EVIL_CONSTRUCTORS(SocksProxyServer);
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_PROXYSERVER_H_
diff --git a/talk/base/ratetracker.cc b/talk/base/ratetracker.cc
index d5207cd..383df93 100644
--- a/talk/base/ratetracker.cc
+++ b/talk/base/ratetracker.cc
@@ -26,7 +26,7 @@
*/
#include "talk/base/ratetracker.h"
-#include "talk/base/time.h"
+#include "talk/base/timeutils.h"
namespace talk_base {
diff --git a/talk/base/ratetracker_unittest.cc b/talk/base/ratetracker_unittest.cc
new file mode 100644
index 0000000..979d907
--- /dev/null
+++ b/talk/base/ratetracker_unittest.cc
@@ -0,0 +1,91 @@
+/*
+ * libjingle
+ * Copyright 2010, 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/base/gunit.h"
+#include "talk/base/ratetracker.h"
+
+namespace talk_base {
+
+class RateTrackerForTest : public RateTracker {
+ public:
+ RateTrackerForTest() : time_(0) {}
+ virtual uint32 Time() const { return time_; }
+ void AdvanceTime(uint32 delta) { time_ += delta; }
+
+ private:
+ uint32 time_;
+};
+
+TEST(RateTrackerTest, TestBasics) {
+ RateTrackerForTest tracker;
+ EXPECT_EQ(0U, tracker.total_units());
+ EXPECT_EQ(0U, tracker.units_second());
+
+ // Add a sample.
+ tracker.Update(1234);
+ // Advance the clock by 100 ms.
+ tracker.AdvanceTime(100);
+ // total_units should advance, but units_second should stay 0.
+ EXPECT_EQ(1234U, tracker.total_units());
+ EXPECT_EQ(0U, tracker.units_second());
+
+ // Repeat.
+ tracker.Update(1234);
+ tracker.AdvanceTime(100);
+ EXPECT_EQ(1234U * 2, tracker.total_units());
+ EXPECT_EQ(0U, tracker.units_second());
+
+ // Advance the clock by 800 ms, so we've elapsed a full second.
+ // units_second should now be filled in properly.
+ tracker.AdvanceTime(800);
+ EXPECT_EQ(1234U * 2, tracker.total_units());
+ EXPECT_EQ(1234U * 2, tracker.units_second());
+
+ // Poll the tracker again immediately. The reported rate should stay the same.
+ EXPECT_EQ(1234U * 2, tracker.total_units());
+ EXPECT_EQ(1234U * 2, tracker.units_second());
+
+ // Do nothing and advance by a second. We should drop down to zero.
+ tracker.AdvanceTime(1000);
+ EXPECT_EQ(1234U * 2, tracker.total_units());
+ EXPECT_EQ(0U, tracker.units_second());
+
+ // Send a bunch of data at a constant rate for 5.5 "seconds".
+ // We should report the rate properly.
+ for (int i = 0; i < 5500; i += 100) {
+ tracker.Update(9876U);
+ tracker.AdvanceTime(100);
+ }
+ EXPECT_EQ(9876U * 10, tracker.units_second());
+
+ // Advance the clock by 500 ms. Since we sent nothing over this half-second,
+ // the reported rate should be reduced by half.
+ tracker.AdvanceTime(500);
+ EXPECT_EQ(9876U * 5, tracker.units_second());
+}
+
+} // namespace talk_base
diff --git a/talk/base/refcount.h b/talk/base/refcount.h
new file mode 100644
index 0000000..ce49d9e
--- /dev/null
+++ b/talk/base/refcount.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_BASE_REFCOUNT_H_
+#define TALK_APP_BASE_REFCOUNT_H_
+
+#include <cstring>
+
+#include "talk/base/criticalsection.h"
+
+namespace talk_base {
+
+// Reference count interface.
+class RefCountInterface {
+ public:
+ virtual int AddRef() = 0;
+ virtual int Release() = 0;
+};
+
+template <class T>
+class RefCountedObject : public T {
+ public:
+ RefCountedObject() : ref_count_(0) {
+ }
+
+ template<typename P>
+ explicit RefCountedObject(P p) : T(p), ref_count_(0) {
+ }
+
+ template<typename P1, typename P2>
+ RefCountedObject(P1 p1, P2 p2) : T(p1, p2), ref_count_(0) {
+ }
+
+ template<typename P1, typename P2, typename P3>
+ RefCountedObject(P1 p1, P2 p2, P3 p3) : T(p1, p2, p3), ref_count_(0) {
+ }
+
+ template<typename P1, typename P2, typename P3, typename P4>
+ RefCountedObject(P1 p1, P2 p2, P3 p3, P4 p4)
+ : T(p1, p2, p3, p4), ref_count_(0) {
+ }
+
+ template<typename P1, typename P2, typename P3, typename P4, typename P5>
+ RefCountedObject(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
+ : T(p1, p2, p3, p4, p5), ref_count_(0) {
+ }
+
+ virtual int AddRef() {
+ return talk_base::AtomicOps::Increment(&ref_count_);
+ }
+
+ virtual int Release() {
+ int count = talk_base::AtomicOps::Decrement(&ref_count_);
+ if (!count) {
+ delete this;
+ }
+ return count;
+ }
+
+ protected:
+ int ref_count_;
+};
+
+} // namespace talk_base
+
+#endif // TALK_APP_BASE_REFCOUNT_H_
diff --git a/talk/base/rollingaccumulator.h b/talk/base/rollingaccumulator.h
new file mode 100644
index 0000000..3868031
--- /dev/null
+++ b/talk/base/rollingaccumulator.h
@@ -0,0 +1,116 @@
+/*
+ * 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_BASE_ROLLINGACCUMULATOR_H_
+#define TALK_BASE_ROLLINGACCUMULATOR_H_
+
+#include <vector>
+
+#include "talk/base/common.h"
+
+namespace talk_base {
+
+// RollingAccumulator stores and reports statistics
+// over N most recent samples.
+//
+// T is assumed to be an int, long, double or float.
+template<typename T>
+class RollingAccumulator {
+ public:
+ explicit RollingAccumulator(size_t max_count)
+ : count_(0),
+ next_index_(0),
+ sum_(0.0),
+ sum_2_(0.0),
+ samples_(max_count) {
+ }
+ ~RollingAccumulator() {
+ }
+
+ int max_count() const {
+ return samples_.size();
+ }
+
+ int count() const {
+ return count_;
+ }
+
+ void AddSample(T sample) {
+ if (count_ == max_count()) {
+ // Remove oldest sample.
+ T sample_to_remove = samples_[next_index_];
+ sum_ -= sample_to_remove;
+ sum_2_ -= sample_to_remove * sample_to_remove;
+ } else {
+ // Increase count of samples.
+ ++count_;
+ }
+ // Add new sample.
+ samples_[next_index_] = sample;
+ sum_ += sample;
+ sum_2_ += sample * sample;
+ // Update next_index_.
+ next_index_ = (next_index_ + 1) % max_count();
+ }
+
+ T ComputeSum() const {
+ return static_cast<T>(sum_);
+ }
+
+ T ComputeMean() const {
+ if (count_ == 0) {
+ return static_cast<T>(0);
+ }
+ return static_cast<T>(sum_ / count_);
+ }
+
+ // Compute estimated variance. Estimation is more accurate
+ // as the number of samples grows.
+ T ComputeVariance() const {
+ if (count_ == 0) {
+ return static_cast<T>(0);
+ }
+ // Var = E[x^2] - (E[x])^2
+ double count_inv = 1.0 / count_;
+ double mean_2 = sum_2_ * count_inv;
+ double mean = sum_ * count_inv;
+ return static_cast<T>(mean_2 - (mean * mean));
+ }
+
+ private:
+ int count_;
+ int next_index_;
+ double sum_; // Sum(x)
+ double sum_2_; // Sum(x*x)
+ std::vector<T> samples_;
+
+ DISALLOW_COPY_AND_ASSIGN(RollingAccumulator);
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_ROLLINGACCUMULATOR_H_
diff --git a/talk/base/rollingaccumulator_unittest.cc b/talk/base/rollingaccumulator_unittest.cc
new file mode 100644
index 0000000..3630e5b
--- /dev/null
+++ b/talk/base/rollingaccumulator_unittest.cc
@@ -0,0 +1,81 @@
+/*
+ * 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/base/gunit.h"
+#include "talk/base/rollingaccumulator.h"
+
+namespace talk_base {
+
+static bool IsApproximate(double expected, double value, double eps) {
+ return expected - eps <= value && value <= expected + eps;
+}
+
+TEST(RollingAccumulatorTest, TestZeroSamples) {
+ RollingAccumulator<int> accum(10);
+
+ EXPECT_EQ(0, accum.count());
+ EXPECT_EQ(0, accum.ComputeMean());
+ EXPECT_EQ(0, accum.ComputeVariance());
+}
+
+TEST(RollingAccumulatorTest, TestSomeSamples) {
+ RollingAccumulator<int> accum(10);
+ for (int i = 0; i < 4; ++i) {
+ accum.AddSample(i);
+ }
+
+ EXPECT_EQ(4, accum.count());
+ EXPECT_EQ(6, accum.ComputeSum());
+ EXPECT_EQ(1, accum.ComputeMean());
+ EXPECT_EQ(1, accum.ComputeVariance());
+}
+
+TEST(RollingAccumulatorTest, TestRollingSamples) {
+ RollingAccumulator<int> accum(10);
+ for (int i = 0; i < 12; ++i) {
+ accum.AddSample(i);
+ }
+
+ EXPECT_EQ(10, accum.count());
+ EXPECT_EQ(65, accum.ComputeSum());
+ EXPECT_EQ(6, accum.ComputeMean());
+ EXPECT_TRUE(IsApproximate(9, accum.ComputeVariance(), 1));
+}
+
+TEST(RollingAccumulatorTest, TestRollingSamplesDouble) {
+ RollingAccumulator<double> accum(10);
+ for (int i = 0; i < 23; ++i) {
+ accum.AddSample(5 * i);
+ }
+
+ EXPECT_EQ(10, accum.count());
+ EXPECT_TRUE(IsApproximate(875.0, accum.ComputeSum(), 1E-6));
+ EXPECT_TRUE(IsApproximate(87.5, accum.ComputeMean(), 1E-6));
+ EXPECT_TRUE(IsApproximate(229.166667, accum.ComputeVariance(), 25));
+}
+
+} // namespace talk_base
diff --git a/talk/base/scoped_autorelease_pool.h b/talk/base/scoped_autorelease_pool.h
new file mode 100644
index 0000000..611f811
--- /dev/null
+++ b/talk/base/scoped_autorelease_pool.h
@@ -0,0 +1,76 @@
+/*
+ * libjingle
+ * Copyright 2008 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.
+ */
+
+// Automatically initialize and and free an autoreleasepool. Never allocate
+// an instance of this class using "new" - that will result in a compile-time
+// error. Only use it as a stack object.
+//
+// Note: NSAutoreleasePool docs say that you should not normally need to
+// declare an NSAutoreleasePool as a member of an object - but there's nothing
+// that indicates it will be a problem, as long as the stack lifetime of the
+// pool exactly matches the stack lifetime of the object.
+
+#ifndef TALK_BASE_SCOPED_AUTORELEASE_POOL_H__
+#define TALK_BASE_SCOPED_AUTORELEASE_POOL_H__
+
+#if defined(IOS) || defined(OSX)
+
+#include "talk/base/common.h"
+
+// This header may be included from Obj-C files or C++ files.
+#ifdef __OBJC__
+@class NSAutoreleasePool;
+#else
+class NSAutoreleasePool;
+#endif
+
+namespace talk_base {
+
+class ScopedAutoreleasePool {
+ public:
+ ScopedAutoreleasePool();
+ ~ScopedAutoreleasePool();
+
+ private:
+ // Declaring private overrides of new and delete here enforces the "only use
+ // as a stack object" discipline.
+ //
+ // Note: new is declared as "throw()" to get around a gcc warning about new
+ // returning NULL, but this method will never get called and therefore will
+ // never actually throw any exception.
+ void* operator new(size_t size) throw() { return NULL; }
+ void operator delete (void* ptr) {}
+
+ NSAutoreleasePool* pool_;
+
+ DISALLOW_EVIL_CONSTRUCTORS(ScopedAutoreleasePool);
+};
+
+} // namespace talk_base
+
+#endif // IOS || OSX
+#endif // TALK_BASE_SCOPED_AUTORELEASE_POOL_H__
diff --git a/talk/base/scoped_autorelease_pool.mm b/talk/base/scoped_autorelease_pool.mm
new file mode 100644
index 0000000..4009c7b
--- /dev/null
+++ b/talk/base/scoped_autorelease_pool.mm
@@ -0,0 +1,42 @@
+/*
+ * libjingle
+ * Copyright 2008, 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.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import "talk/base/scoped_autorelease_pool.h"
+
+namespace talk_base {
+
+ScopedAutoreleasePool::ScopedAutoreleasePool() {
+ pool_ = [[NSAutoreleasePool alloc] init];
+}
+
+ScopedAutoreleasePool::~ScopedAutoreleasePool() {
+ [pool_ drain];
+}
+
+} // namespace talk_base
diff --git a/talk/base/scoped_ref_ptr.h b/talk/base/scoped_ref_ptr.h
new file mode 100644
index 0000000..3ce72cb
--- /dev/null
+++ b/talk/base/scoped_ref_ptr.h
@@ -0,0 +1,162 @@
+/*
+ * 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.
+ */
+
+// Originally these classes are from Chromium.
+// http://src.chromium.org/viewvc/chrome/trunk/src/base/memory/ref_counted.h?view=markup
+
+//
+// A smart pointer class for reference counted objects. Use this class instead
+// of calling AddRef and Release manually on a reference counted object to
+// avoid common memory leaks caused by forgetting to Release an object
+// reference. Sample usage:
+//
+// class MyFoo : public RefCounted<MyFoo> {
+// ...
+// };
+//
+// void some_function() {
+// scoped_refptr<MyFoo> foo = new MyFoo();
+// foo->Method(param);
+// // |foo| is released when this function returns
+// }
+//
+// void some_other_function() {
+// scoped_refptr<MyFoo> foo = new MyFoo();
+// ...
+// foo = NULL; // explicitly releases |foo|
+// ...
+// if (foo)
+// foo->Method(param);
+// }
+//
+// The above examples show how scoped_refptr<T> acts like a pointer to T.
+// Given two scoped_refptr<T> classes, it is also possible to exchange
+// references between the two objects, like so:
+//
+// {
+// scoped_refptr<MyFoo> a = new MyFoo();
+// scoped_refptr<MyFoo> b;
+//
+// b.swap(a);
+// // now, |b| references the MyFoo object, and |a| references NULL.
+// }
+//
+// To make both |a| and |b| in the above example reference the same MyFoo
+// object, simply use the assignment operator:
+//
+// {
+// scoped_refptr<MyFoo> a = new MyFoo();
+// scoped_refptr<MyFoo> b;
+//
+// b = a;
+// // now, |a| and |b| each own a reference to the same MyFoo object.
+// }
+//
+
+#ifndef TALK_BASE_SCOPED_REF_PTR_H_
+#define TALK_BASE_SCOPED_REF_PTR_H_
+
+namespace talk_base {
+
+template <class T>
+class scoped_refptr {
+ public:
+ scoped_refptr() : ptr_(NULL) {
+ }
+
+ scoped_refptr(T* p) : ptr_(p) {
+ if (ptr_)
+ ptr_->AddRef();
+ }
+
+ scoped_refptr(const scoped_refptr<T>& r) : ptr_(r.ptr_) {
+ if (ptr_)
+ ptr_->AddRef();
+ }
+
+ template <typename U>
+ scoped_refptr(const scoped_refptr<U>& r) : ptr_(r.get()) {
+ if (ptr_)
+ ptr_->AddRef();
+ }
+
+ ~scoped_refptr() {
+ if (ptr_)
+ ptr_->Release();
+ }
+
+ T* get() const { return ptr_; }
+ operator T*() const { return ptr_; }
+ T* operator->() const { return ptr_; }
+
+ // Release a pointer.
+ // The return value is the current pointer held by this object.
+ // If this object holds a NULL pointer, the return value is NULL.
+ // After this operation, this object will hold a NULL pointer,
+ // and will not own the object any more.
+ T* release() {
+ T* retVal = ptr_;
+ ptr_ = NULL;
+ return retVal;
+ }
+
+ scoped_refptr<T>& operator=(T* p) {
+ // AddRef first so that self assignment should work
+ if (p)
+ p->AddRef();
+ if (ptr_ )
+ ptr_ ->Release();
+ ptr_ = p;
+ return *this;
+ }
+
+ scoped_refptr<T>& operator=(const scoped_refptr<T>& r) {
+ return *this = r.ptr_;
+ }
+
+ template <typename U>
+ scoped_refptr<T>& operator=(const scoped_refptr<U>& r) {
+ return *this = r.get();
+ }
+
+ void swap(T** pp) {
+ T* p = ptr_;
+ ptr_ = *pp;
+ *pp = p;
+ }
+
+ void swap(scoped_refptr<T>& r) {
+ swap(&r.ptr_);
+ }
+
+ protected:
+ T* ptr_;
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_SCOPED_REF_PTR_H_
diff --git a/talk/base/sharedexclusivelock.cc b/talk/base/sharedexclusivelock.cc
new file mode 100644
index 0000000..0b0439a
--- /dev/null
+++ b/talk/base/sharedexclusivelock.cc
@@ -0,0 +1,61 @@
+/*
+ * 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/base/sharedexclusivelock.h"
+
+namespace talk_base {
+
+SharedExclusiveLock::SharedExclusiveLock()
+ : shared_count_is_zero_(true, true),
+ shared_count_(0) {
+}
+
+void SharedExclusiveLock::LockExclusive() {
+ cs_exclusive_.Enter();
+ shared_count_is_zero_.Wait(talk_base::kForever);
+}
+
+void SharedExclusiveLock::UnlockExclusive() {
+ cs_exclusive_.Leave();
+}
+
+void SharedExclusiveLock::LockShared() {
+ CritScope exclusive_scope(&cs_exclusive_);
+ CritScope shared_scope(&cs_shared_);
+ if (++shared_count_ == 1) {
+ shared_count_is_zero_.Reset();
+ }
+}
+
+void SharedExclusiveLock::UnlockShared() {
+ CritScope shared_scope(&cs_shared_);
+ if (--shared_count_ == 0) {
+ shared_count_is_zero_.Set();
+ }
+}
+
+} // namespace talk_base
diff --git a/talk/base/sharedexclusivelock.h b/talk/base/sharedexclusivelock.h
new file mode 100644
index 0000000..2bdd854
--- /dev/null
+++ b/talk/base/sharedexclusivelock.h
@@ -0,0 +1,93 @@
+/*
+ * 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_BASE_SHAREDEXCLUSIVELOCK_H_
+#define TALK_BASE_SHAREDEXCLUSIVELOCK_H_
+
+#include "talk/base/constructormagic.h"
+#include "talk/base/criticalsection.h"
+#include "talk/base/event.h"
+
+namespace talk_base {
+
+// This class provides shared-exclusive lock. It can be used in cases like
+// multiple-readers/single-writer model.
+class SharedExclusiveLock {
+ public:
+ SharedExclusiveLock();
+
+ // Locking/unlocking methods. It is encouraged to use SharedScope or
+ // ExclusiveScope for protection.
+ void LockExclusive();
+ void UnlockExclusive();
+ void LockShared();
+ void UnlockShared();
+
+ private:
+ talk_base::CriticalSection cs_exclusive_;
+ talk_base::CriticalSection cs_shared_;
+ talk_base::Event shared_count_is_zero_;
+ int shared_count_;
+
+ DISALLOW_COPY_AND_ASSIGN(SharedExclusiveLock);
+};
+
+class SharedScope {
+ public:
+ explicit SharedScope(SharedExclusiveLock* lock) : lock_(lock) {
+ lock_->LockShared();
+ }
+
+ ~SharedScope() {
+ lock_->UnlockShared();
+ }
+
+ private:
+ SharedExclusiveLock* lock_;
+
+ DISALLOW_COPY_AND_ASSIGN(SharedScope);
+};
+
+class ExclusiveScope {
+ public:
+ explicit ExclusiveScope(SharedExclusiveLock* lock) : lock_(lock) {
+ lock_->LockExclusive();
+ }
+
+ ~ExclusiveScope() {
+ lock_->UnlockExclusive();
+ }
+
+ private:
+ SharedExclusiveLock* lock_;
+
+ DISALLOW_COPY_AND_ASSIGN(ExclusiveScope);
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_SHAREDEXCLUSIVELOCK_H_
diff --git a/talk/base/sharedexclusivelock_unittest.cc b/talk/base/sharedexclusivelock_unittest.cc
new file mode 100644
index 0000000..46b7fdf
--- /dev/null
+++ b/talk/base/sharedexclusivelock_unittest.cc
@@ -0,0 +1,234 @@
+/*
+ * 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/base/common.h"
+#include "talk/base/gunit.h"
+#include "talk/base/messagehandler.h"
+#include "talk/base/messagequeue.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/sharedexclusivelock.h"
+#include "talk/base/thread.h"
+#include "talk/base/timeutils.h"
+
+namespace talk_base {
+
+static const uint32 kMsgRead = 0;
+static const uint32 kMsgWrite = 0;
+static const int kNoWaitThresholdInMs = 10;
+static const int kWaitThresholdInMs = 80;
+static const int kProcessTimeInMs = 100;
+static const int kProcessTimeoutInMs = 5000;
+
+class SharedExclusiveTask : public MessageHandler {
+ public:
+ SharedExclusiveTask(SharedExclusiveLock* shared_exclusive_lock,
+ int* value,
+ bool* done)
+ : shared_exclusive_lock_(shared_exclusive_lock),
+ waiting_time_in_ms_(0),
+ value_(value),
+ done_(done) {
+ worker_thread_.reset(new Thread());
+ worker_thread_->Start();
+ }
+
+ int waiting_time_in_ms() const { return waiting_time_in_ms_; }
+
+ protected:
+ scoped_ptr<Thread> worker_thread_;
+ SharedExclusiveLock* shared_exclusive_lock_;
+ int waiting_time_in_ms_;
+ int* value_;
+ bool* done_;
+};
+
+class ReadTask : public SharedExclusiveTask {
+ public:
+ ReadTask(SharedExclusiveLock* shared_exclusive_lock, int* value, bool* done)
+ : SharedExclusiveTask(shared_exclusive_lock, value, done) {
+ }
+
+ void PostRead(int* value) {
+ worker_thread_->Post(this, kMsgRead, new TypedMessageData<int*>(value));
+ }
+
+ private:
+ virtual void OnMessage(Message* message) {
+ ASSERT(talk_base::Thread::Current() == worker_thread_.get());
+ ASSERT(message != NULL);
+ ASSERT(message->message_id == kMsgRead);
+
+ TypedMessageData<int*>* message_data =
+ static_cast<TypedMessageData<int*>*>(message->pdata);
+
+ uint32 start_time = Time();
+ {
+ SharedScope ss(shared_exclusive_lock_);
+ waiting_time_in_ms_ = TimeDiff(Time(), start_time);
+
+ Thread::SleepMs(kProcessTimeInMs);
+ *message_data->data() = *value_;
+ *done_ = true;
+ }
+ delete message->pdata;
+ message->pdata = NULL;
+ }
+};
+
+class WriteTask : public SharedExclusiveTask {
+ public:
+ WriteTask(SharedExclusiveLock* shared_exclusive_lock, int* value, bool* done)
+ : SharedExclusiveTask(shared_exclusive_lock, value, done) {
+ }
+
+ void PostWrite(int value) {
+ worker_thread_->Post(this, kMsgWrite, new TypedMessageData<int>(value));
+ }
+
+ private:
+ virtual void OnMessage(Message* message) {
+ ASSERT(talk_base::Thread::Current() == worker_thread_.get());
+ ASSERT(message != NULL);
+ ASSERT(message->message_id == kMsgWrite);
+
+ TypedMessageData<int>* message_data =
+ static_cast<TypedMessageData<int>*>(message->pdata);
+
+ uint32 start_time = Time();
+ {
+ ExclusiveScope es(shared_exclusive_lock_);
+ waiting_time_in_ms_ = TimeDiff(Time(), start_time);
+
+ Thread::SleepMs(kProcessTimeInMs);
+ *value_ = message_data->data();
+ *done_ = true;
+ }
+ delete message->pdata;
+ message->pdata = NULL;
+ }
+};
+
+// Unit test for SharedExclusiveLock.
+class SharedExclusiveLockTest
+ : public testing::Test {
+ public:
+ SharedExclusiveLockTest() : value_(0) {
+ }
+
+ virtual void SetUp() {
+ shared_exclusive_lock_.reset(new SharedExclusiveLock());
+ }
+
+ protected:
+ scoped_ptr<SharedExclusiveLock> shared_exclusive_lock_;
+ int value_;
+};
+
+TEST_F(SharedExclusiveLockTest, TestSharedShared) {
+ int value0, value1;
+ bool done0, done1;
+ ReadTask reader0(shared_exclusive_lock_.get(), &value_, &done0);
+ ReadTask reader1(shared_exclusive_lock_.get(), &value_, &done1);
+
+ // Test shared locks can be shared without waiting.
+ {
+ SharedScope ss(shared_exclusive_lock_.get());
+ value_ = 1;
+ done0 = false;
+ done1 = false;
+ reader0.PostRead(&value0);
+ reader1.PostRead(&value1);
+ Thread::SleepMs(kProcessTimeInMs);
+ }
+
+ EXPECT_TRUE_WAIT(done0, kProcessTimeoutInMs);
+ EXPECT_EQ(1, value0);
+ EXPECT_LE(reader0.waiting_time_in_ms(), kNoWaitThresholdInMs);
+ EXPECT_TRUE_WAIT(done1, kProcessTimeoutInMs);
+ EXPECT_EQ(1, value1);
+ EXPECT_LE(reader1.waiting_time_in_ms(), kNoWaitThresholdInMs);
+}
+
+TEST_F(SharedExclusiveLockTest, TestSharedExclusive) {
+ bool done;
+ WriteTask writer(shared_exclusive_lock_.get(), &value_, &done);
+
+ // Test exclusive lock needs to wait for shared lock.
+ {
+ SharedScope ss(shared_exclusive_lock_.get());
+ value_ = 1;
+ done = false;
+ writer.PostWrite(2);
+ Thread::SleepMs(kProcessTimeInMs);
+ EXPECT_EQ(1, value_);
+ }
+
+ EXPECT_TRUE_WAIT(done, kProcessTimeoutInMs);
+ EXPECT_EQ(2, value_);
+ EXPECT_GE(writer.waiting_time_in_ms(), kWaitThresholdInMs);
+}
+
+TEST_F(SharedExclusiveLockTest, TestExclusiveShared) {
+ int value;
+ bool done;
+ ReadTask reader(shared_exclusive_lock_.get(), &value_, &done);
+
+ // Test shared lock needs to wait for exclusive lock.
+ {
+ ExclusiveScope es(shared_exclusive_lock_.get());
+ value_ = 1;
+ done = false;
+ reader.PostRead(&value);
+ Thread::SleepMs(kProcessTimeInMs);
+ value_ = 2;
+ }
+
+ EXPECT_TRUE_WAIT(done, kProcessTimeoutInMs);
+ EXPECT_EQ(2, value);
+ EXPECT_GE(reader.waiting_time_in_ms(), kWaitThresholdInMs);
+}
+
+TEST_F(SharedExclusiveLockTest, TestExclusiveExclusive) {
+ bool done;
+ WriteTask writer(shared_exclusive_lock_.get(), &value_, &done);
+
+ // Test exclusive lock needs to wait for exclusive lock.
+ {
+ ExclusiveScope es(shared_exclusive_lock_.get());
+ value_ = 1;
+ done = false;
+ writer.PostWrite(2);
+ Thread::SleepMs(kProcessTimeInMs);
+ EXPECT_EQ(1, value_);
+ }
+
+ EXPECT_TRUE_WAIT(done, kProcessTimeoutInMs);
+ EXPECT_EQ(2, value_);
+ EXPECT_GE(writer.waiting_time_in_ms(), kWaitThresholdInMs);
+}
+
+} // namespace talk_base
diff --git a/talk/base/socket.h b/talk/base/socket.h
index a55b3dc..ad8eee6 100644
--- a/talk/base/socket.h
+++ b/talk/base/socket.h
@@ -180,9 +180,10 @@
enum Option {
OPT_DONTFRAGMENT,
- OPT_RCVBUF, // receive buffer size
- OPT_SNDBUF, // send buffer size
- OPT_NODELAY // whether Nagle algorithm is enabled
+ OPT_RCVBUF, // receive buffer size
+ OPT_SNDBUF, // send buffer size
+ OPT_NODELAY, // whether Nagle algorithm is enabled
+ OPT_IPV6_V6ONLY // Whether the socket is IPv6 only.
};
virtual int GetOption(Option opt, int* value) = 0;
virtual int SetOption(Option opt, int value) = 0;
diff --git a/talk/base/socket_unittest.cc b/talk/base/socket_unittest.cc
new file mode 100644
index 0000000..8d5b3c5
--- /dev/null
+++ b/talk/base/socket_unittest.cc
@@ -0,0 +1,731 @@
+/*
+ * libjingle
+ * Copyright 2007, 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/base/socket_unittest.h"
+
+#include "talk/base/asyncudpsocket.h"
+#include "talk/base/gunit.h"
+#include "talk/base/socketserver.h"
+#include "talk/base/testclient.h"
+#include "talk/base/testutils.h"
+#include "talk/base/thread.h"
+
+namespace talk_base {
+
+static const SocketAddress kEmptyAddr;
+static const SocketAddress kLoopbackAddr(IPAddress(INADDR_LOOPBACK), 0);
+
+void SocketTest::TestConnect() {
+ testing::StreamSink sink;
+ SocketAddress accept_addr;
+
+ // Create client.
+ scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(client.get());
+ EXPECT_EQ(AsyncSocket::CS_CLOSED, client->GetState());
+ EXPECT_EQ(kEmptyAddr, client->GetLocalAddress());
+
+ // Create server and listen.
+ scoped_ptr<AsyncSocket> server(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(server.get());
+ EXPECT_EQ(0, server->Bind(kLoopbackAddr));
+ EXPECT_EQ(0, server->Listen(5));
+ EXPECT_EQ(AsyncSocket::CS_CONNECTING, server->GetState());
+
+ // Ensure no pending server connections, since we haven't done anything yet.
+ EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
+ EXPECT_TRUE(NULL == server->Accept(&accept_addr));
+ EXPECT_EQ(kEmptyAddr, accept_addr);
+
+ // Attempt connect to listening socket.
+ EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+ EXPECT_NE(kEmptyAddr, client->GetLocalAddress()); // Implicit Bind
+ EXPECT_NE(server->GetLocalAddress(), client->GetLocalAddress());
+
+ // Client is connecting, outcome not yet determined.
+ EXPECT_EQ(AsyncSocket::CS_CONNECTING, client->GetState());
+ EXPECT_FALSE(sink.Check(client.get(), testing::SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+
+ // Server has pending connection, accept it.
+ EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+ scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ ASSERT_TRUE(NULL != accepted.get());
+ EXPECT_NE(kEmptyAddr, accept_addr);
+ EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
+
+ // Connected from server perspective, check the addresses are correct.
+ EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState());
+ EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress());
+ EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
+
+ // Connected from client perspective, check the addresses are correct.
+ EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
+ EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
+ EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
+}
+
+void SocketTest::TestConnectWithDnsLookup() {
+ testing::StreamSink sink;
+ SocketAddress accept_addr;
+
+ // Create client.
+ scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(client.get());
+
+ // Create server and listen.
+ scoped_ptr<AsyncSocket> server(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(server.get());
+ EXPECT_EQ(0, server->Bind(kLoopbackAddr));
+ EXPECT_EQ(0, server->Listen(5));
+
+ // Attempt connect to listening socket.
+ SocketAddress dns_addr(server->GetLocalAddress());
+ dns_addr.SetIP("localhost");
+ EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+ // TODO: Bind when doing DNS lookup.
+ //EXPECT_NE(kEmptyAddr, client->GetLocalAddress()); // Implicit Bind
+
+ // Client is connecting, outcome not yet determined.
+ EXPECT_EQ(AsyncSocket::CS_CONNECTING, client->GetState());
+ EXPECT_FALSE(sink.Check(client.get(), testing::SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+
+ // Server has pending connection, accept it.
+ EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+ scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ ASSERT_TRUE(NULL != accepted.get());
+ EXPECT_NE(kEmptyAddr, accept_addr);
+ EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
+
+ // Connected from server perspective, check the addresses are correct.
+ EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState());
+ EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress());
+ EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
+
+ // Connected from client perspective, check the addresses are correct.
+ EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
+ EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
+ EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
+}
+
+void SocketTest::TestConnectFail() {
+ testing::StreamSink sink;
+ SocketAddress accept_addr;
+
+ // Create client.
+ scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(client.get());
+
+ // Create server, but don't listen yet.
+ scoped_ptr<AsyncSocket> server(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(server.get());
+ EXPECT_EQ(0, server->Bind(kLoopbackAddr));
+
+ // Attempt connect to a non-existent socket.
+ // We don't connect to the server socket created above, since on
+ // MacOS it takes about 75 seconds to get back an error!
+ SocketAddress bogus_addr(IPAddress(INADDR_LOOPBACK), 65535);
+ EXPECT_EQ(0, client->Connect(bogus_addr));
+
+ // Wait for connection to fail (ECONNREFUSED).
+ EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
+ EXPECT_FALSE(sink.Check(client.get(), testing::SSE_OPEN));
+ EXPECT_TRUE(sink.Check(client.get(), testing::SSE_ERROR));
+ EXPECT_EQ(kEmptyAddr, client->GetRemoteAddress());
+
+ // Should be no pending server connections.
+ EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
+ EXPECT_TRUE(NULL == server->Accept(&accept_addr));
+ EXPECT_EQ(kEmptyAddr, accept_addr);
+}
+
+void SocketTest::TestConnectWithDnsLookupFail() {
+ testing::StreamSink sink;
+ SocketAddress accept_addr;
+
+ // Create client.
+ scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(client.get());
+
+ // Create server, but don't listen yet.
+ scoped_ptr<AsyncSocket> server(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(server.get());
+ EXPECT_EQ(0, server->Bind(kLoopbackAddr));
+
+ // Attempt connect to a non-existent host.
+ // We don't connect to the server socket created above, since on
+ // MacOS it takes about 75 seconds to get back an error!
+ SocketAddress bogus_dns_addr("not-a-real-hostname", 65535);
+ EXPECT_EQ(0, client->Connect(bogus_dns_addr));
+
+ // Wait for connection to fail (EHOSTNOTFOUND).
+ EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
+ EXPECT_FALSE(sink.Check(client.get(), testing::SSE_OPEN));
+ EXPECT_TRUE(sink.Check(client.get(), testing::SSE_ERROR));
+ EXPECT_EQ(kEmptyAddr, client->GetRemoteAddress());
+
+ // Should be no pending server connections.
+ EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
+ EXPECT_TRUE(NULL == server->Accept(&accept_addr));
+ EXPECT_EQ(kEmptyAddr, accept_addr);
+}
+
+void SocketTest::TestConnectWithClosedSocket() {
+ // Create server and listen.
+ scoped_ptr<AsyncSocket> server(ss_->CreateAsyncSocket(SOCK_STREAM));
+ EXPECT_EQ(0, server->Bind(kLoopbackAddr));
+ EXPECT_EQ(0, server->Listen(5));
+
+ // Create a client and put in to CS_CLOSED state.
+ scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(SOCK_STREAM));
+ EXPECT_EQ(0, client->Close());
+ EXPECT_EQ(AsyncSocket::CS_CLOSED, client->GetState());
+
+ // Connect() should reinitialize the socket, and put it in to CS_CONNECTING.
+ EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress())));
+ EXPECT_EQ(AsyncSocket::CS_CONNECTING, client->GetState());
+}
+
+void SocketTest::TestServerCloseDuringConnect() {
+ testing::StreamSink sink;
+ SocketAddress accept_addr;
+
+ // Create client.
+ scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(client.get());
+
+ // Create server and listen.
+ scoped_ptr<AsyncSocket> server(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(server.get());
+ EXPECT_EQ(0, server->Bind(kLoopbackAddr));
+ EXPECT_EQ(0, server->Listen(5));
+
+ // Attempt connect to listening socket.
+ EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+
+ // Close down the server while the socket is in the accept queue.
+ EXPECT_TRUE_WAIT(sink.Check(server.get(), testing::SSE_READ), kTimeout);
+ server->Close();
+
+ // This should fail the connection for the client. Clean up.
+ EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
+ EXPECT_TRUE(sink.Check(client.get(), testing::SSE_ERROR));
+ client->Close();
+}
+
+void SocketTest::TestClientCloseDuringConnect() {
+ testing::StreamSink sink;
+ SocketAddress accept_addr;
+
+ // Create client.
+ scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(client.get());
+
+ // Create server and listen.
+ scoped_ptr<AsyncSocket> server(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(server.get());
+ EXPECT_EQ(0, server->Bind(kLoopbackAddr));
+ EXPECT_EQ(0, server->Listen(5));
+
+ // Attempt connect to listening socket.
+ EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+
+ // Close down the client while the socket is in the accept queue.
+ EXPECT_TRUE_WAIT(sink.Check(server.get(), testing::SSE_READ), kTimeout);
+ client->Close();
+
+ // The connection should still be able to be accepted.
+ scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ ASSERT_TRUE(NULL != accepted.get());
+ sink.Monitor(accepted.get());
+ EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState());
+
+ // The accepted socket should then close (possibly with err, timing-related)
+ EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, accepted->GetState(), kTimeout);
+ EXPECT_TRUE(sink.Check(accepted.get(), testing::SSE_CLOSE) ||
+ sink.Check(accepted.get(), testing::SSE_ERROR));
+
+ // The client should not get a close event.
+ EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+}
+
+void SocketTest::TestServerClose() {
+ testing::StreamSink sink;
+ SocketAddress accept_addr;
+
+ // Create client.
+ scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(client.get());
+
+ // Create server and listen.
+ scoped_ptr<AsyncSocket> server(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(server.get());
+ EXPECT_EQ(0, server->Bind(kLoopbackAddr));
+ EXPECT_EQ(0, server->Listen(5));
+
+ // Attempt connection.
+ EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+
+ // Accept connection.
+ EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+ scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ ASSERT_TRUE(NULL != accepted.get());
+ sink.Monitor(accepted.get());
+
+ // Both sides are now connected.
+ EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
+ EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
+ EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
+ EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
+
+ // Send data to the client, and then close the connection.
+ EXPECT_EQ(1, accepted->Send("a", 1));
+ accepted->Close();
+ EXPECT_EQ(AsyncSocket::CS_CLOSED, accepted->GetState());
+
+ // Expect that the client is notified, and has not yet closed.
+ EXPECT_TRUE_WAIT(sink.Check(client.get(), testing::SSE_READ), kTimeout);
+ EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_EQ(AsyncSocket::CS_CONNECTED, client->GetState());
+
+ // Ensure the data can be read.
+ char buffer[10];
+ EXPECT_EQ(1, client->Recv(buffer, sizeof(buffer)));
+ EXPECT_EQ('a', buffer[0]);
+
+ // Now we should close, but the remote address will remain.
+ EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
+ EXPECT_TRUE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_NE(kEmptyAddr, client->GetRemoteAddress());
+
+ // The closer should not get a close signal.
+ EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_CLOSE));
+ EXPECT_EQ(kEmptyAddr, accepted->GetRemoteAddress());
+
+ // And the closee should only get a single signal.
+ Thread::Current()->ProcessMessages(0);
+ EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+
+ // Close down the client and ensure all is good.
+ client->Close();
+ EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_EQ(kEmptyAddr, client->GetRemoteAddress());
+}
+
+class SocketCloser : public sigslot::has_slots<> {
+ public:
+ void OnClose(AsyncSocket* socket, int error) {
+ socket->Close(); // Deleting here would blow up the vector of handlers
+ // for the socket's signal.
+ }
+};
+
+void SocketTest::TestCloseInClosedCallback() {
+ testing::StreamSink sink;
+ SocketCloser closer;
+ SocketAddress accept_addr;
+
+ // Create client.
+ scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(client.get());
+ client->SignalCloseEvent.connect(&closer, &SocketCloser::OnClose);
+
+ // Create server and listen.
+ scoped_ptr<AsyncSocket> server(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(server.get());
+ EXPECT_EQ(0, server->Bind(kLoopbackAddr));
+ EXPECT_EQ(0, server->Listen(5));
+
+ // Attempt connection.
+ EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+
+ // Accept connection.
+ EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+ scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ ASSERT_TRUE(NULL != accepted.get());
+ sink.Monitor(accepted.get());
+
+ // Both sides are now connected.
+ EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
+ EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
+ EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
+ EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
+
+ // Send data to the client, and then close the connection.
+ accepted->Close();
+ EXPECT_EQ(AsyncSocket::CS_CLOSED, accepted->GetState());
+
+ // Expect that the client is notified, and has not yet closed.
+ EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_EQ(AsyncSocket::CS_CONNECTED, client->GetState());
+
+ // Now we should be closed and invalidated
+ EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
+ EXPECT_TRUE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_TRUE(Socket::CS_CLOSED == client->GetState());
+}
+
+class Sleeper : public MessageHandler {
+ public:
+ Sleeper() {}
+ void OnMessage(Message* msg) {
+ Thread::Current()->SleepMs(500);
+ }
+};
+
+void SocketTest::TestSocketServerWait() {
+ testing::StreamSink sink;
+ SocketAddress accept_addr;
+
+ // Create & connect server and client sockets.
+ scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(SOCK_STREAM));
+ scoped_ptr<AsyncSocket> server(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(client.get());
+ sink.Monitor(server.get());
+ EXPECT_EQ(0, server->Bind(kLoopbackAddr));
+ EXPECT_EQ(0, server->Listen(5));
+
+ EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+ EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+
+ scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ ASSERT_TRUE(NULL != accepted.get());
+ sink.Monitor(accepted.get());
+ EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState());
+ EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress());
+ EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
+
+ EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
+ EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
+ EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
+
+ // Do an i/o operation, triggering an eventual callback.
+ EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_READ));
+ char buf[1024] = {0};
+
+ EXPECT_EQ(1024, client->Send(buf, 1024));
+ EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_READ));
+
+ // Shouldn't signal when blocked in a thread Send, where process_io is false.
+ scoped_ptr<Thread> thread(new Thread());
+ thread->Start();
+ Sleeper sleeper;
+ TypedMessageData<AsyncSocket*> data(client.get());
+ thread->Send(&sleeper, 0, &data);
+ EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_READ));
+
+ // But should signal when process_io is true.
+ EXPECT_TRUE_WAIT((sink.Check(accepted.get(), testing::SSE_READ)), kTimeout);
+ EXPECT_LT(0, accepted->Recv(buf, 1024));
+}
+
+void SocketTest::TestTcp() {
+ testing::StreamSink sink;
+ SocketAddress accept_addr;
+
+ // Create test data.
+ const size_t kDataSize = 1024 * 1024;
+ scoped_array<char> send_buffer(new char[kDataSize]);
+ scoped_array<char> recv_buffer(new char[kDataSize]);
+ size_t send_pos = 0, recv_pos = 0;
+ for (size_t i = 0; i < kDataSize; ++i) {
+ send_buffer[i] = i;
+ recv_buffer[i] = 0;
+ }
+
+ // Create client.
+ scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(client.get());
+
+ // Create server and listen.
+ scoped_ptr<AsyncSocket> server(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(server.get());
+ EXPECT_EQ(0, server->Bind(kLoopbackAddr));
+ EXPECT_EQ(0, server->Listen(5));
+
+ // Attempt connection.
+ EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+
+ // Accept connection.
+ EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+ scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ ASSERT_TRUE(NULL != accepted.get());
+ sink.Monitor(accepted.get());
+
+ // Both sides are now connected.
+ EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
+ EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
+ EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
+ EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
+
+ // Send and receive a bunch of data.
+ bool send_waiting_for_writability = false;
+ bool send_expect_success = true;
+ bool recv_waiting_for_readability = true;
+ bool recv_expect_success = false;
+ int data_in_flight = 0;
+ while (recv_pos < kDataSize) {
+ // Send as much as we can if we've been cleared to send.
+ while (!send_waiting_for_writability && send_pos < kDataSize) {
+ int tosend = kDataSize - send_pos;
+ int sent = accepted->Send(send_buffer.get() + send_pos, tosend);
+ if (send_expect_success) {
+ // The first Send() after connecting or getting writability should
+ // succeed and send some data.
+ EXPECT_GT(sent, 0);
+ send_expect_success = false;
+ }
+ if (sent >= 0) {
+ EXPECT_LE(sent, tosend);
+ send_pos += sent;
+ data_in_flight += sent;
+ } else {
+ ASSERT_TRUE(accepted->IsBlocking());
+ send_waiting_for_writability = true;
+ }
+ }
+
+ // Read all the sent data.
+ while (data_in_flight > 0) {
+ if (recv_waiting_for_readability) {
+ // Wait until data is available.
+ EXPECT_TRUE_WAIT(sink.Check(client.get(), testing::SSE_READ), kTimeout);
+ recv_waiting_for_readability = false;
+ recv_expect_success = true;
+ }
+
+ // Receive as much as we can get in a single recv call.
+ int rcvd = client->Recv(recv_buffer.get() + recv_pos,
+ kDataSize - recv_pos);
+
+ if (recv_expect_success) {
+ // The first Recv() after getting readability should succeed and receive
+ // some data.
+ EXPECT_GT(rcvd, 0);
+ recv_expect_success = false;
+ }
+ if (rcvd >= 0) {
+ EXPECT_LE(rcvd, data_in_flight);
+ recv_pos += rcvd;
+ data_in_flight -= rcvd;
+ } else {
+ ASSERT_TRUE(client->IsBlocking());
+ recv_waiting_for_readability = true;
+ }
+ }
+
+ // Once all that we've sent has been rcvd, expect to be able to send again.
+ if (send_waiting_for_writability) {
+ EXPECT_TRUE_WAIT(sink.Check(accepted.get(), testing::SSE_WRITE),
+ kTimeout);
+ send_waiting_for_writability = false;
+ send_expect_success = true;
+ }
+ }
+
+ // The received data matches the sent data.
+ EXPECT_EQ(kDataSize, send_pos);
+ EXPECT_EQ(kDataSize, recv_pos);
+ EXPECT_EQ(0, memcmp(recv_buffer.get(), send_buffer.get(), kDataSize));
+
+ // Close down.
+ accepted->Close();
+ EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
+ EXPECT_TRUE(sink.Check(client.get(), testing::SSE_CLOSE));
+ client->Close();
+}
+
+void SocketTest::TestSingleFlowControlCallback() {
+ testing::StreamSink sink;
+ SocketAddress accept_addr;
+
+ // Create client.
+ scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(client.get());
+
+ // Create server and listen.
+ scoped_ptr<AsyncSocket> server(ss_->CreateAsyncSocket(SOCK_STREAM));
+ sink.Monitor(server.get());
+ EXPECT_EQ(0, server->Bind(kLoopbackAddr));
+ EXPECT_EQ(0, server->Listen(5));
+
+ // Attempt connection.
+ EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+
+ // Accept connection.
+ EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+ scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ ASSERT_TRUE(NULL != accepted.get());
+ sink.Monitor(accepted.get());
+
+ // Both sides are now connected.
+ EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
+ EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
+ EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
+ EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
+
+ // Fill the socket buffer.
+ char buf[1024 * 16] = {0};
+ while (accepted->Send(&buf, ARRAY_SIZE(buf)) != -1) {}
+ EXPECT_TRUE(accepted->IsBlocking());
+
+ // Expect no writable callbacks
+ EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_WRITE));
+
+ // Wait until data is available.
+ EXPECT_TRUE_WAIT(sink.Check(client.get(), testing::SSE_READ), kTimeout);
+
+ // Pull some data.
+ client->Recv(buf, ARRAY_SIZE(buf));
+
+ // Expect at least one additional writable callback.
+ EXPECT_TRUE_WAIT(sink.Check(accepted.get(), testing::SSE_WRITE), kTimeout);
+
+ // Adding data in response to the writeable callback shouldn't cause infinite
+ // callbacks.
+ int extras = 0;
+ for (int i = 0; i < 100; ++i) {
+ accepted->Send(&buf, ARRAY_SIZE(buf));
+ talk_base::Thread::Current()->ProcessMessages(1);
+ if (sink.Check(accepted.get(), testing::SSE_WRITE)) {
+ extras++;
+ }
+ }
+ EXPECT_LT(extras, 2);
+
+ // Close down.
+ accepted->Close();
+ client->Close();
+}
+
+void SocketTest::TestUdp() {
+ // Test basic bind and connect behavior.
+ SocketAddress addr1(kLoopbackAddr);
+ AsyncSocket* socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
+ EXPECT_EQ(AsyncSocket::CS_CLOSED, socket->GetState());
+ EXPECT_EQ(0, socket->Bind(addr1));
+ addr1 = socket->GetLocalAddress();
+ EXPECT_EQ(0, socket->Connect(addr1));
+ EXPECT_EQ(AsyncSocket::CS_CONNECTED, socket->GetState());
+ socket->Close();
+ EXPECT_EQ(AsyncSocket::CS_CLOSED, socket->GetState());
+ delete socket;
+
+ // Test send/receive behavior.
+ scoped_ptr<TestClient> client1(new TestClient(
+ AsyncUDPSocket::Create(ss_, addr1)));
+ scoped_ptr<TestClient> client2(new TestClient(
+ AsyncUDPSocket::Create(ss_, SocketAddress())));
+
+ SocketAddress addr2;
+ EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
+ EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr2));
+
+ SocketAddress addr3;
+ EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr2));
+ EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &addr3));
+ EXPECT_EQ(addr3, addr1);
+
+ // TODO: figure out what the intent is here
+ for (int i = 0; i < 10; ++i) {
+ client2.reset(new TestClient(AsyncUDPSocket::Create(ss_, SocketAddress())));
+
+ SocketAddress addr4;
+ EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
+ EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr4));
+ EXPECT_EQ(addr4.ipaddr(), addr2.ipaddr());
+
+ SocketAddress addr5;
+ EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr4));
+ EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &addr5));
+ EXPECT_EQ(addr5, addr1);
+
+ addr2 = addr4;
+ }
+}
+
+void SocketTest::TestGetSetOptions() {
+ talk_base::scoped_ptr<AsyncSocket> socket(ss_->CreateAsyncSocket(SOCK_DGRAM));
+ socket->Bind(kLoopbackAddr);
+
+ // Check SNDBUF/RCVBUF.
+ const int desired_size = 12345;
+#if defined(LINUX) || defined(ANDROID)
+ // Yes, really. It's in the kernel source.
+ const int expected_size = desired_size * 2;
+#else // !LINUX && !ANDROID
+ const int expected_size = desired_size;
+#endif // !LINUX && !ANDROID
+ int recv_size = 0;
+ int send_size = 0;
+ // get the initial sizes
+ ASSERT_NE(-1, socket->GetOption(Socket::OPT_RCVBUF, &recv_size));
+ ASSERT_NE(-1, socket->GetOption(Socket::OPT_SNDBUF, &send_size));
+ // set our desired sizes
+ ASSERT_NE(-1, socket->SetOption(Socket::OPT_RCVBUF, desired_size));
+ ASSERT_NE(-1, socket->SetOption(Socket::OPT_SNDBUF, desired_size));
+ // get the sizes again
+ ASSERT_NE(-1, socket->GetOption(Socket::OPT_RCVBUF, &recv_size));
+ ASSERT_NE(-1, socket->GetOption(Socket::OPT_SNDBUF, &send_size));
+ // make sure they are right
+ ASSERT_EQ(expected_size, recv_size);
+ ASSERT_EQ(expected_size, send_size);
+
+ // Check that we can't set NODELAY on a UDP socket.
+ int current_nd, desired_nd = 1;
+ ASSERT_EQ(-1, socket->GetOption(Socket::OPT_NODELAY, ¤t_nd));
+ ASSERT_EQ(-1, socket->SetOption(Socket::OPT_NODELAY, desired_nd));
+
+ // Try estimating MTU.
+ talk_base::scoped_ptr<AsyncSocket>
+ mtu_socket(ss_->CreateAsyncSocket(SOCK_DGRAM));
+ mtu_socket->Bind(kLoopbackAddr);
+ uint16 mtu;
+ // should fail until we connect
+ ASSERT_EQ(-1, mtu_socket->EstimateMTU(&mtu));
+ mtu_socket->Connect(kLoopbackAddr);
+#if defined(WIN32)
+ // now it should succeed
+ ASSERT_NE(-1, mtu_socket->EstimateMTU(&mtu));
+ ASSERT_GE(mtu, 1492); // should be at least the 1492 "plateau" on localhost
+#elif defined(OSX)
+ // except on OSX, where it's not yet implemented
+ ASSERT_EQ(-1, mtu_socket->EstimateMTU(&mtu));
+#else
+ // and the behavior seems unpredictable on Linux, failing on the build machine
+ // but succeeding on my Ubiquity instance.
+#endif
+}
+
+} // namespace talk_base
diff --git a/talk/base/socket_unittest.h b/talk/base/socket_unittest.h
new file mode 100644
index 0000000..481f073
--- /dev/null
+++ b/talk/base/socket_unittest.h
@@ -0,0 +1,64 @@
+/*
+ * libjingle
+ * Copyright 2009, 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_BASE_SOCKET_UNITTEST_H_
+#define TALK_BASE_SOCKET_UNITTEST_H_
+
+#include "talk/base/gunit.h"
+#include "talk/base/thread.h"
+
+namespace talk_base {
+
+// Generic socket tests, to be used when testing individual socketservers.
+// Derive your specific test class from SocketTest, install your
+// socketserver, and call the SocketTest test methods.
+class SocketTest : public testing::Test {
+ protected:
+ SocketTest() : ss_(NULL) {}
+ virtual void SetUp() { ss_ = Thread::Current()->socketserver(); }
+ void TestConnect();
+ void TestConnectWithDnsLookup();
+ void TestConnectFail();
+ void TestConnectWithDnsLookupFail();
+ void TestConnectWithClosedSocket();
+ void TestServerCloseDuringConnect();
+ void TestClientCloseDuringConnect();
+ void TestServerClose();
+ void TestCloseInClosedCallback();
+ void TestSocketServerWait();
+ void TestTcp();
+ void TestSingleFlowControlCallback();
+ void TestUdp();
+ void TestGetSetOptions();
+
+ static const int kTimeout = 5000; // ms
+ SocketServer* ss_;
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_SOCKET_UNITTEST_H_
diff --git a/talk/base/socketaddress.cc b/talk/base/socketaddress.cc
index cbb0805..a4c7275 100644
--- a/talk/base/socketaddress.cc
+++ b/talk/base/socketaddress.cc
@@ -25,10 +25,15 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include "talk/base/socketaddress.h"
+
#ifdef POSIX
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
+#if defined(OPENBSD)
+#include <netinet/in_systm.h>
+#endif
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <netdb.h>
@@ -41,22 +46,17 @@
#include "talk/base/common.h"
#include "talk/base/logging.h"
#include "talk/base/nethelpers.h"
-#include "talk/base/socketaddress.h"
#ifdef WIN32
-// Win32 doesn't provide inet_aton, so we add our own version here.
-// Since inet_addr returns 0xFFFFFFFF on error, if we get this value
-// we need to test the input to see if the address really was 255.255.255.255.
-// This is slightly fragile, but better than doing nothing.
-int inet_aton(const char* cp, struct in_addr* inp) {
- inp->s_addr = inet_addr(cp);
- return (inp->s_addr == INADDR_NONE &&
- strcmp(cp, "255.255.255.255") != 0) ? 0 : 1;
-}
-#endif // WIN32
+#include "talk/base/win32.h"
+#endif
namespace talk_base {
+// Address family constants for STUN (see RFC 5389).
+static const int kStunFamilyIPv4 = 1;
+static const int kStunFamilyIPv6 = 2;
+
SocketAddress::SocketAddress() {
Clear();
}
@@ -66,7 +66,12 @@
SetPort(port);
}
-SocketAddress::SocketAddress(uint32 ip, int port) {
+SocketAddress::SocketAddress(uint32 ip_as_host_order_integer, int port) {
+ SetIP(IPAddress(ip_as_host_order_integer));
+ SetPort(port);
+}
+
+SocketAddress::SocketAddress(const IPAddress& ip, int port) {
SetIP(ip);
SetPort(port);
}
@@ -77,36 +82,52 @@
void SocketAddress::Clear() {
hostname_.clear();
- ip_ = 0;
+ literal_ = false;
+ ip_ = IPAddress(INADDR_ANY);
port_ = 0;
}
bool SocketAddress::IsNil() const {
- return hostname_.empty() && (0 == ip_) && (0 == port_);
+ return hostname_.empty() && IPIsAny(ip_) && 0 == port_;
}
bool SocketAddress::IsComplete() const {
- return (0 != ip_) && (0 != port_);
+ return (!IPIsAny(ip_)) && (0 != port_);
}
SocketAddress& SocketAddress::operator=(const SocketAddress& addr) {
hostname_ = addr.hostname_;
ip_ = addr.ip_;
port_ = addr.port_;
+ literal_ = addr.literal_;
return *this;
}
-void SocketAddress::SetIP(uint32 ip) {
+void SocketAddress::SetIP(uint32 ip_as_host_order_integer) {
hostname_.clear();
+ literal_ = false;
+ ip_ = IPAddress(ip_as_host_order_integer);
+}
+
+void SocketAddress::SetIP(const IPAddress& ip) {
+ hostname_.clear();
+ literal_ = false;
ip_ = ip;
}
void SocketAddress::SetIP(const std::string& hostname) {
hostname_ = hostname;
- ip_ = StringToIP(hostname);
+ literal_ = IPFromString(hostname, &ip_);
+ if (!literal_) {
+ ip_ = IPAddress(INADDR_ANY);
+ }
}
-void SocketAddress::SetResolvedIP(uint32 ip) {
+void SocketAddress::SetResolvedIP(uint32 ip_as_host_order_integer) {
+ ip_ = IPAddress(ip_as_host_order_integer);
+}
+
+void SocketAddress::SetResolvedIP(const IPAddress& ip) {
ip_ = ip;
}
@@ -116,6 +137,10 @@
}
uint32 SocketAddress::ip() const {
+ return ip_.v4AddressAsHostOrderInteger();
+}
+
+const IPAddress& SocketAddress::ipaddr() const {
return ip_;
}
@@ -124,9 +149,15 @@
}
std::string SocketAddress::IPAsString() const {
- if (!hostname_.empty())
+ // If the hostname was a literal IP string, it may need to have square
+ // brackets added (for SocketAddress::ToString()).
+ if (!literal_ && !hostname_.empty())
return hostname_;
- return IPToString(ip_);
+ if (ip_.family() == AF_INET6) {
+ return "[" + ip_.ToString() + "]";
+ } else {
+ return ip_.ToString();
+ }
}
std::string SocketAddress::PortAsString() const {
@@ -144,11 +175,24 @@
}
bool SocketAddress::FromString(const std::string& str) {
- std::string::size_type pos = str.find(':');
- if (std::string::npos == pos)
- return false;
- SetPort(strtoul(str.substr(pos + 1).c_str(), NULL, 10));
- SetIP(str.substr(0, pos));
+ if (str.at(0) == '[') {
+ std::string::size_type closebracket = str.rfind(']');
+ if (closebracket != std::string::npos) {
+ std::string::size_type colon = str.find(':', closebracket);
+ if (colon != std::string::npos && colon > closebracket) {
+ SetPort(strtoul(str.substr(colon + 1).c_str(), NULL, 10));
+ SetIP(str.substr(1, closebracket - 1));
+ } else {
+ return false;
+ }
+ }
+ } else {
+ std::string::size_type pos = str.find(':');
+ if (std::string::npos == pos)
+ return false;
+ SetPort(strtoul(str.substr(pos + 1).c_str(), NULL, 10));
+ SetIP(str.substr(0, pos));
+ }
return true;
}
@@ -158,28 +202,25 @@
}
bool SocketAddress::IsAnyIP() const {
- return (ip_ == 0);
+ return IPIsAny(ip_);
}
bool SocketAddress::IsLoopbackIP() const {
- if (0 == ip_) {
- return (0 == stricmp(hostname_.c_str(), "localhost"));
- } else {
- return ((ip_ >> 24) == 127);
- }
+ return IPIsLoopback(ip_) || (IPIsAny(ip_) &&
+ 0 == strcmp(hostname_.c_str(), "localhost"));
}
bool SocketAddress::IsLocalIP() const {
if (IsLoopbackIP())
return true;
- std::vector<uint32> ips;
- if (0 == ip_) {
+ std::vector<IPAddress> ips;
+ if (IPIsAny(ip_)) {
if (!hostname_.empty()
&& (0 == stricmp(hostname_.c_str(), GetHostname().c_str()))) {
return true;
}
- } else if (GetLocalIPs(ips)) {
+ } else if (GetLocalIPs(&ips)) {
for (size_t i = 0; i < ips.size(); ++i) {
if (ips[i] == ip_) {
return true;
@@ -190,15 +231,11 @@
}
bool SocketAddress::IsPrivateIP() const {
- return ((ip_ >> 24) == 127) ||
- ((ip_ >> 24) == 10) ||
- ((ip_ >> 20) == ((172 << 4) | 1)) ||
- ((ip_ >> 16) == ((192 << 8) | 168)) ||
- ((ip_ >> 16) == ((169 << 8) | 254));
+ return IPIsPrivate(ip_);
}
bool SocketAddress::IsUnresolvedIP() const {
- return IsAny() && !hostname_.empty();
+ return IsAny() && !literal_ && !hostname_.empty();
}
bool SocketAddress::ResolveIP(bool force, int* error) {
@@ -210,9 +247,10 @@
LOG_F(LS_VERBOSE) << "(" << hostname_ << ")";
int errcode = 0;
if (hostent* pHost = SafeGetHostByName(hostname_.c_str(), &errcode)) {
- ip_ = NetworkToHost32(*reinterpret_cast<uint32*>(pHost->h_addr_list[0]));
- LOG_F(LS_VERBOSE) << "(" << hostname_ << ") resolved to: "
- << IPToString(ip_);
+ if (IPFromHostEnt(pHost, &ip_)) {
+ LOG_F(LS_VERBOSE) << "(" << hostname_ << ") resolved to: "
+ << ip_.ToString();
+ }
FreeHostEnt(pHost);
} else {
LOG_F(LS_ERROR) << "(" << hostname_ << ") err: " << errcode;
@@ -221,7 +259,7 @@
*error = errcode;
}
}
- return (ip_ != 0);
+ return (!IPIsAny(ip_));
}
bool SocketAddress::operator==(const SocketAddress& addr) const {
@@ -235,7 +273,7 @@
return false;
// We only check hostnames if both IPs are zero. This matches EqualIPs()
- if (addr.ip_ == 0) {
+ if (addr.IsAnyIP()) {
if (hostname_ < addr.hostname_)
return true;
else if (addr.hostname_ < hostname_)
@@ -246,7 +284,8 @@
}
bool SocketAddress::EqualIPs(const SocketAddress& addr) const {
- return (ip_ == addr.ip_) && ((ip_ != 0) || (hostname_ == addr.hostname_));
+ return (ip_ == addr.ip_) &&
+ ((!IPIsAny(ip_)) || (hostname_ == addr.hostname_));
}
bool SocketAddress::EqualPorts(const SocketAddress& addr) const {
@@ -255,41 +294,23 @@
size_t SocketAddress::Hash() const {
size_t h = 0;
- h ^= ip_;
+ h ^= HashIP(ip_);
h ^= port_ | (port_ << 16);
return h;
}
-size_t SocketAddress::Size_() const {
- return sizeof(ip_) + sizeof(port_) + 2;
-}
-
-bool SocketAddress::Write_(char* buf, int len) const {
- if (len < static_cast<int>(Size_()))
- return false;
- buf[0] = 0;
- buf[1] = AF_INET;
- SetBE16(buf + 2, port_);
- SetBE32(buf + 4, ip_);
- return true;
-}
-
-bool SocketAddress::Read_(const char* buf, int len) {
- if (len < static_cast<int>(Size_()) || buf[1] != AF_INET)
- return false;
- port_ = GetBE16(buf + 2);
- ip_ = GetBE32(buf + 4);
- return true;
-}
-
void SocketAddress::ToSockAddr(sockaddr_in* saddr) const {
memset(saddr, 0, sizeof(*saddr));
+ if (ip_.family() != AF_INET) {
+ saddr->sin_family = AF_UNSPEC;
+ return;
+ }
saddr->sin_family = AF_INET;
saddr->sin_port = HostToNetwork16(port_);
- if (0 == ip_) {
+ if (IPIsAny(ip_)) {
saddr->sin_addr.s_addr = INADDR_ANY;
} else {
- saddr->sin_addr.s_addr = HostToNetwork32(ip_);
+ saddr->sin_addr = ip_.ipv4_address();
}
}
@@ -298,29 +319,76 @@
return false;
SetIP(NetworkToHost32(saddr.sin_addr.s_addr));
SetPort(NetworkToHost16(saddr.sin_port));
+ literal_ = false;
return true;
}
-std::string SocketAddress::IPToString(uint32 ip) {
+static size_t ToSockAddrStorageHelper(sockaddr_storage* addr,
+ IPAddress ip, int port, int scope_id) {
+ memset(addr, 0, sizeof(sockaddr_storage));
+ addr->ss_family = ip.family();
+ if (addr->ss_family == AF_INET6) {
+ sockaddr_in6* saddr = reinterpret_cast<sockaddr_in6*>(addr);
+ saddr->sin6_addr = ip.ipv6_address();
+ saddr->sin6_port = HostToNetwork16(port);
+ saddr->sin6_scope_id = scope_id;
+ return sizeof(sockaddr_in6);
+ } else if (addr->ss_family == AF_INET) {
+ sockaddr_in* saddr = reinterpret_cast<sockaddr_in*>(addr);
+ saddr->sin_addr = ip.ipv4_address();
+ saddr->sin_port = HostToNetwork16(port);
+ return sizeof(sockaddr_in);
+ }
+ return 0;
+}
+
+size_t SocketAddress::ToDualStackSockAddrStorage(sockaddr_storage *addr) const {
+ return ToSockAddrStorageHelper(addr, ip_.AsIPv6Address(), port_, scope_id_);
+}
+
+size_t SocketAddress::ToSockAddrStorage(sockaddr_storage* addr) const {
+ return ToSockAddrStorageHelper(addr, ip_, port_, scope_id_);
+}
+
+std::string SocketAddress::IPToString(uint32 ip_as_host_order_integer) {
std::ostringstream ost;
- ost << ((ip >> 24) & 0xff);
+ ost << ((ip_as_host_order_integer >> 24) & 0xff);
ost << '.';
- ost << ((ip >> 16) & 0xff);
+ ost << ((ip_as_host_order_integer >> 16) & 0xff);
ost << '.';
- ost << ((ip >> 8) & 0xff);
+ ost << ((ip_as_host_order_integer >> 8) & 0xff);
ost << '.';
- ost << ((ip >> 0) & 0xff);
+ ost << ((ip_as_host_order_integer >> 0) & 0xff);
return ost.str();
}
bool SocketAddress::StringToIP(const std::string& hostname, uint32* ip) {
in_addr addr;
- if (inet_aton(hostname.c_str(), &addr) == 0)
+ if (talk_base::inet_pton(AF_INET, hostname.c_str(), &addr) == 0)
return false;
*ip = NetworkToHost32(addr.s_addr);
return true;
}
+bool SocketAddress::StringToIP(const std::string& hostname, IPAddress* ip) {
+ in_addr addr4;
+ if (talk_base::inet_pton(AF_INET, hostname.c_str(), &addr4) > 0) {
+ if (ip) {
+ *ip = IPAddress(addr4);
+ }
+ return true;
+ }
+
+ in6_addr addr6;
+ if (talk_base::inet_pton(AF_INET6, hostname.c_str(), &addr6) > 0) {
+ if (ip) {
+ *ip = IPAddress(addr6);
+ }
+ return true;
+ }
+ return false;
+}
+
uint32 SocketAddress::StringToIP(const std::string& hostname) {
uint32 ip = 0;
StringToIP(hostname, &ip);
@@ -334,25 +402,48 @@
return "";
}
-bool SocketAddress::GetLocalIPs(std::vector<uint32>& ips) {
- ips.clear();
+bool SocketAddress::GetLocalIPs(std::vector<IPAddress>* ips) {
+ if (!ips) {
+ return false;
+ }
+ ips->clear();
- const std::string hostname = GetHostname();
+ const std::string hostname = SocketAddress::GetHostname();
if (hostname.empty())
return false;
int errcode;
if (hostent* pHost = SafeGetHostByName(hostname.c_str(), &errcode)) {
for (size_t i = 0; pHost->h_addr_list[i]; ++i) {
- uint32 ip =
- NetworkToHost32(*reinterpret_cast<uint32 *>(pHost->h_addr_list[i]));
- ips.push_back(ip);
+ IPAddress ip;
+ if (IPFromHostEnt(pHost, i, &ip)) {
+ ips->push_back(ip);
+ }
}
FreeHostEnt(pHost);
- return !ips.empty();
+ return !ips->empty();
}
LOG(LS_ERROR) << "gethostbyname err: " << errcode;
return false;
}
+bool SocketAddressFromSockAddrStorage(const sockaddr_storage& addr,
+ SocketAddress* out) {
+ if (!out) {
+ return false;
+ }
+ if (addr.ss_family == AF_INET) {
+ const sockaddr_in* saddr = reinterpret_cast<const sockaddr_in*>(&addr);
+ *out = SocketAddress(IPAddress(saddr->sin_addr),
+ NetworkToHost16(saddr->sin_port));
+ return true;
+ } else if (addr.ss_family == AF_INET6) {
+ const sockaddr_in6* saddr = reinterpret_cast<const sockaddr_in6*>(&addr);
+ *out = SocketAddress(IPAddress(saddr->sin6_addr),
+ NetworkToHost16(saddr->sin6_port));
+ out->SetScopeID(saddr->sin6_scope_id);
+ return true;
+ }
+ return false;
+}
} // namespace talk_base
diff --git a/talk/base/socketaddress.h b/talk/base/socketaddress.h
index 4af80c9..9bd1fad 100644
--- a/talk/base/socketaddress.h
+++ b/talk/base/socketaddress.h
@@ -32,28 +32,31 @@
#include <vector>
#include <iosfwd>
#include "talk/base/basictypes.h"
+#include "talk/base/ipaddress.h"
+
#undef SetPort
struct sockaddr_in;
+struct sockaddr_storage;
namespace talk_base {
-// Records an IP address and port, which are 32 and 16 bit integers,
-// respectively, both in <b>host byte-order</b>.
+// Records an IP address and port.
class SocketAddress {
public:
// Creates a nil address.
SocketAddress();
- // Creates the address with the given host and port. If use_dns is true,
- // the hostname will be immediately resolved to an IP (which may block for
- // several seconds if DNS is not available). Alternately, set use_dns to
- // false, and then call Resolve() to complete resolution later, or use
- // SetResolvedIP to set the IP explictly.
+ // Creates the address with the given host and port. Host may be a
+ // literal IP string or a hostname to be resolved later with ResolveIP().
SocketAddress(const std::string& hostname, int port);
// Creates the address with the given IP and port.
- SocketAddress(uint32 ip, int port);
+ // IP is given as an integer in host byte order. V4 only, to be deprecated.
+ SocketAddress(uint32 ip_as_host_order_integer, int port);
+
+ // Creates the address with the given IP and port.
+ SocketAddress(const IPAddress& ip, int port);
// Creates a copy of the given address.
SocketAddress(const SocketAddress& addr);
@@ -70,8 +73,12 @@
// Replaces our address with the given one.
SocketAddress& operator=(const SocketAddress& addr);
+ // Changes the IP of this address to the given one, and clears the hostname
+ // IP is given as an integer in host byte order. V4 only, to be deprecated..
+ void SetIP(uint32 ip_as_host_order_integer);
+
// Changes the IP of this address to the given one, and clears the hostname.
- void SetIP(uint32 ip);
+ void SetIP(const IPAddress& ip);
// Changes the hostname of this address to the given one.
// Does not resolve the address; use Resolve to do so.
@@ -79,41 +86,59 @@
// Sets the IP address while retaining the hostname. Useful for bypassing
// DNS for a pre-resolved IP.
- void SetResolvedIP(uint32 ip);
+ // IP is given as an integer in host byte order. V4 only, to be deprecated.
+ void SetResolvedIP(uint32 ip_as_host_order_integer);
+
+ // Sets the IP address while retaining the hostname. Useful for bypassing
+ // DNS for a pre-resolved IP.
+ void SetResolvedIP(const IPAddress& ip);
// Changes the port of this address to the given one.
void SetPort(int port);
- // Returns the hostname
+ // Returns the hostname.
const std::string& hostname() const { return hostname_; }
- // Returns the IP address.
+ // Returns the IP address as a host byte order integer.
+ // Returns 0 for non-v4 addresses.
uint32 ip() const;
+ const IPAddress& ipaddr() const;
+
// Returns the port part of this address.
uint16 port() const;
- // Returns the IP address in dotted form.
+ // Returns the scope ID associated with this address. Scope IDs are a
+ // necessary addition to IPv6 link-local addresses, with different network
+ // interfaces having different scope-ids for their link-local addresses.
+ // IPv4 address do not have scope_ids and sockaddr_in structures do not have
+ // a field for them.
+ int scope_id() const {return scope_id_; }
+ void SetScopeID(int id) { scope_id_ = id; }
+
+ // Returns the IP address (or hostname) in printable form.
std::string IPAsString() const;
- // Returns the port as a string
+ // Returns the port as a string.
std::string PortAsString() const;
- // Returns hostname:port
+ // Returns hostname:port or [hostname]:port.
std::string ToString() const;
- // Parses hostname:port
+ // Parses hostname:port and [hostname]:port.
bool FromString(const std::string& str);
friend std::ostream& operator<<(std::ostream& os, const SocketAddress& addr);
- // Determines whether this represents a missing / any IP address. Hostname
- // and/or port may be set.
+ // Determines whether this represents a missing / any IP address.
+ // That is, 0.0.0.0 or ::.
+ // Hostname and/or port may be set.
bool IsAnyIP() const;
inline bool IsAny() const { return IsAnyIP(); } // deprecated
- // Determines whether the IP address refers to a loopback address, i.e. within
- // the range 127.0.0.0/8.
+ // Determines whether the IP address refers to a loopback address.
+ // For v4 addresses this means the address is in the range 127.0.0.0/8.
+ // For v6 addresses this means the address is ::1.
bool IsLoopbackIP() const;
// Determines wither the IP address refers to any adapter on the local
@@ -121,7 +146,8 @@
bool IsLocalIP() const;
// Determines whether the IP address is in one of the private ranges:
- // 127.0.0.0/8 10.0.0.0/8 192.168.0.0/16 172.16.0.0/12.
+ // For v4: 127.0.0.0/8 10.0.0.0/8 192.168.0.0/16 172.16.0.0/12.
+ // For v6: FE80::/16 and ::1.
bool IsPrivateIP() const;
// Determines whether the hostname has been resolved to an IP.
@@ -131,6 +157,7 @@
// Attempt to resolve a hostname to IP address.
// Returns false if resolution is required but failed, and sets error.
// 'force' will cause re-resolution of hostname.
+ // TODO: Deprecate this function.
bool ResolveIP(bool force = false, int* error = NULL);
// Determines whether this address is identical to the given one.
@@ -151,41 +178,54 @@
// Hashes this address into a small number.
size_t Hash() const;
- // Returns the size of this address when written.
- size_t Size_() const;
-
- // Writes this address into the given buffer, according to RFC 3489.
- bool Write_(char* buf, int len) const;
-
- // Reads this address from the given buffer, according to RFC 3489.
- bool Read_(const char* buf, int len);
-
// Write this address to a sockaddr_in.
+ // If IPv6, will zero out the sockaddr_in and sets family to AF_UNSPEC.
void ToSockAddr(sockaddr_in* saddr) const;
// Read this address from a sockaddr_in.
bool FromSockAddr(const sockaddr_in& saddr);
- // Converts the IP address given in compact form into dotted form.
- static std::string IPToString(uint32 ip);
+ // Read and write the address to/from a sockaddr_storage.
+ // Dual stack version always sets family to AF_INET6, and maps v4 addresses.
+ // The other version doesn't map, and outputs an AF_INET address for
+ // v4 or mapped addresses, and AF_INET6 addresses for others.
+ // Returns the size of the sockaddr_in or sockaddr_in6 structure that is
+ // written to the sockaddr_storage, or zero on failure.
+ size_t ToDualStackSockAddrStorage(sockaddr_storage* saddr) const;
+ size_t ToSockAddrStorage(sockaddr_storage* saddr) const;
+
+ // Converts the IP address given in 'compact form' into dotted form.
+ // IP is given as an integer in host byte order. V4 only, to be deprecated.
+ // TODO: Deprecate this.
+ static std::string IPToString(uint32 ip_as_host_order_integer);
// Converts the IP address given in dotted form into compact form.
- // Only dotted names (A.B.C.D) are resolved.
+ // Only dotted names (A.B.C.D) are converted.
+ // Output integer is returned in host byte order.
+ // TODO: Deprecate, replace wth agnostic versions.
static bool StringToIP(const std::string& str, uint32* ip);
- static uint32 StringToIP(const std::string& str); // deprecated
+ static uint32 StringToIP(const std::string& str);
- // Get local machine's hostname
- static std::string GetHostname();
+ // Converts the IP address given in printable form into an IPAddress.
+ static bool StringToIP(const std::string& str, IPAddress* ip);
- // Get a list of the local machine's ip addresses
- static bool GetLocalIPs(std::vector<uint32>& ips);
+ // Get a list of the local machine's ip addresses.
+ // TODO: Move to nethelpers or similar (doesn't belong in socketaddress).
+ static bool GetLocalIPs(std::vector<IPAddress>* ips);
private:
+ // Get local machine's hostname.
+ static std::string GetHostname();
std::string hostname_;
- uint32 ip_;
+ IPAddress ip_;
uint16 port_;
+ int scope_id_;
+ bool literal_; // Indicates that 'hostname_' contains a literal IP string.
};
+bool SocketAddressFromSockAddrStorage(const sockaddr_storage& saddr,
+ SocketAddress* out);
+
} // namespace talk_base
#endif // TALK_BASE_SOCKETADDRESS_H_
diff --git a/talk/base/socketaddress_unittest.cc b/talk/base/socketaddress_unittest.cc
index 95b0071..5ef05b5 100644
--- a/talk/base/socketaddress_unittest.cc
+++ b/talk/base/socketaddress_unittest.cc
@@ -31,41 +31,65 @@
#include "talk/base/gunit.h"
#include "talk/base/socketaddress.h"
+#include "talk/base/ipaddress.h"
namespace talk_base {
+const in6_addr kTestV6Addr = { { {0x20, 0x01, 0x0d, 0xb8,
+ 0x10, 0x20, 0x30, 0x40,
+ 0x50, 0x60, 0x70, 0x80,
+ 0x90, 0xA0, 0xB0, 0xC0} } };
+const in6_addr kMappedV4Addr = { { {0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xFF, 0xFF,
+ 0x01, 0x02, 0x03, 0x04} } };
+const std::string kTestV6AddrString = "2001:db8:1020:3040:5060:7080:90a0:b0c0";
+const std::string kTestV6AddrFullString =
+ "[2001:db8:1020:3040:5060:7080:90a0:b0c0]:5678";
+
TEST(SocketAddressTest, TestDefaultCtor) {
SocketAddress addr;
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0U, addr.ip());
+ EXPECT_EQ(IPAddress(INADDR_ANY), addr.ipaddr());
EXPECT_EQ(0, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("0.0.0.0:0", addr.ToString());
}
TEST(SocketAddressTest, TestIPPortCtor) {
- SocketAddress addr(0x01020304, 5678);
+ SocketAddress addr(IPAddress(0x01020304), 5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
-TEST(SocketAddressTest, TestStringPortCtor) {
+TEST(SocketAddressTest, TestIPv4StringPortCtor) {
SocketAddress addr("1.2.3.4", 5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
+TEST(SocketAddressTest, TestIPv6StringPortCtor) {
+ SocketAddress addr2(kTestV6AddrString, 1234);
+ IPAddress tocheck(kTestV6Addr);
+
+ EXPECT_FALSE(addr2.IsUnresolvedIP());
+ EXPECT_EQ(tocheck, addr2.ipaddr());
+ EXPECT_EQ(1234, addr2.port());
+ EXPECT_EQ(kTestV6AddrString, addr2.hostname());
+ EXPECT_EQ("[" + kTestV6AddrString + "]:1234", addr2.ToString());
+}
+
TEST(SocketAddressTest, TestSpecialStringPortCtor) {
// inet_addr doesn't handle this address properly.
SocketAddress addr("255.255.255.255", 5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0xFFFFFFFFU, addr.ip());
+ EXPECT_EQ(IPAddress(0xFFFFFFFFU), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("255.255.255.255", addr.hostname());
EXPECT_EQ("255.255.255.255:5678", addr.ToString());
@@ -74,7 +98,7 @@
TEST(SocketAddressTest, TestHostnamePortCtor) {
SocketAddress addr("a.b.com", 5678);
EXPECT_TRUE(addr.IsUnresolvedIP());
- EXPECT_EQ(0U, addr.ip());
+ EXPECT_EQ(IPAddress(INADDR_ANY), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
@@ -84,7 +108,7 @@
SocketAddress from("1.2.3.4", 5678);
SocketAddress addr(from);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -92,68 +116,77 @@
TEST(SocketAddressTest, TestAssign) {
SocketAddress from("1.2.3.4", 5678);
- SocketAddress addr(0x88888888, 9999);
+ SocketAddress addr(IPAddress(0x88888888), 9999);
addr = from;
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
TEST(SocketAddressTest, TestSetIPPort) {
- SocketAddress addr(0x88888888, 9999);
- addr.SetIP(0x01020304);
+ SocketAddress addr(IPAddress(0x88888888), 9999);
+ addr.SetIP(IPAddress(0x01020304));
addr.SetPort(5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
TEST(SocketAddressTest, TestSetIPFromString) {
- SocketAddress addr(0x88888888, 9999);
+ SocketAddress addr(IPAddress(0x88888888), 9999);
addr.SetIP("1.2.3.4");
addr.SetPort(5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
TEST(SocketAddressTest, TestSetIPFromHostname) {
- SocketAddress addr(0x88888888, 9999);
+ SocketAddress addr(IPAddress(0x88888888), 9999);
addr.SetIP("a.b.com");
addr.SetPort(5678);
EXPECT_TRUE(addr.IsUnresolvedIP());
- EXPECT_EQ(0U, addr.ip());
+ EXPECT_EQ(IPAddress(INADDR_ANY), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
- addr.SetResolvedIP(0x01020304);
+ addr.SetResolvedIP(IPAddress(0x01020304));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
}
-TEST(SocketAddressTest, TestFromString) {
+TEST(SocketAddressTest, TestFromIPv4String) {
SocketAddress addr;
EXPECT_TRUE(addr.FromString("1.2.3.4:5678"));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
+TEST(SocketAddressTest, TestFromIPv6String) {
+ SocketAddress addr;
+ EXPECT_TRUE(addr.FromString(kTestV6AddrFullString));
+ EXPECT_FALSE(addr.IsUnresolvedIP());
+ EXPECT_EQ(5678, addr.port());
+ EXPECT_EQ(kTestV6AddrString, addr.hostname());
+ EXPECT_EQ(kTestV6AddrFullString, addr.ToString());
+}
+
TEST(SocketAddressTest, TestFromHostname) {
SocketAddress addr;
EXPECT_TRUE(addr.FromString("a.b.com:5678"));
EXPECT_TRUE(addr.IsUnresolvedIP());
- EXPECT_EQ(0U, addr.ip());
+ EXPECT_EQ(IPAddress(INADDR_ANY), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
@@ -165,22 +198,61 @@
from.ToSockAddr(&addr_in);
EXPECT_TRUE(addr.FromSockAddr(addr_in));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
-TEST(SocketAddressTest, TestToFromBuffer) {
+TEST(SocketAddressTest, TestToFromSockAddrStorage) {
SocketAddress from("1.2.3.4", 5678), addr;
- char buf[8];
- EXPECT_TRUE(from.Write_(buf, sizeof(buf)));
- EXPECT_TRUE(addr.Read_(buf, sizeof(buf)));
+ sockaddr_storage addr_storage;
+ from.ToSockAddrStorage(&addr_storage);
+ EXPECT_TRUE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
+
+ addr.Clear();
+ from.ToDualStackSockAddrStorage(&addr_storage);
+ EXPECT_TRUE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
+ EXPECT_FALSE(addr.IsUnresolvedIP());
+ EXPECT_EQ(IPAddress(kMappedV4Addr), addr.ipaddr());
+ EXPECT_EQ(5678, addr.port());
+ EXPECT_EQ("", addr.hostname());
+ EXPECT_EQ("[::ffff:1.2.3.4]:5678", addr.ToString());
+
+ addr.Clear();
+ memset(&addr_storage, 0, sizeof(sockaddr_storage));
+ from = SocketAddress(kTestV6AddrString, 5678);
+ from.SetScopeID(6);
+ from.ToSockAddrStorage(&addr_storage);
+ EXPECT_TRUE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
+ EXPECT_FALSE(addr.IsUnresolvedIP());
+ EXPECT_EQ(IPAddress(kTestV6Addr), addr.ipaddr());
+ EXPECT_EQ(5678, addr.port());
+ EXPECT_EQ("", addr.hostname());
+ EXPECT_EQ(kTestV6AddrFullString, addr.ToString());
+ EXPECT_EQ(6, addr.scope_id());
+
+ addr.Clear();
+ from.ToDualStackSockAddrStorage(&addr_storage);
+ EXPECT_TRUE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
+ EXPECT_FALSE(addr.IsUnresolvedIP());
+ EXPECT_EQ(IPAddress(kTestV6Addr), addr.ipaddr());
+ EXPECT_EQ(5678, addr.port());
+ EXPECT_EQ("", addr.hostname());
+ EXPECT_EQ(kTestV6AddrFullString, addr.ToString());
+ EXPECT_EQ(6, addr.scope_id());
+
+ addr = from;
+ addr_storage.ss_family = AF_UNSPEC;
+ EXPECT_FALSE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
+ EXPECT_EQ(from, addr);
+
+ EXPECT_FALSE(SocketAddressFromSockAddrStorage(addr_storage, NULL));
}
TEST(SocketAddressTest, TestGoodResolve) {
@@ -191,7 +263,7 @@
EXPECT_EQ(0, error);
EXPECT_FALSE(addr.IsUnresolvedIP());
EXPECT_TRUE(addr.IsLoopbackIP());
- EXPECT_EQ(0x7F000001U, addr.ip());
+ EXPECT_EQ(IPAddress(INADDR_LOOPBACK), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("localhost", addr.hostname());
EXPECT_EQ("localhost:5678", addr.ToString());
@@ -206,4 +278,74 @@
EXPECT_TRUE(addr.IsUnresolvedIP());
}
+bool AreEqual(const SocketAddress& addr1,
+ const SocketAddress& addr2) {
+ return addr1 == addr2 && addr2 == addr1 &&
+ !(addr1 != addr2) && !(addr2 != addr1);
+}
+
+bool AreUnequal(const SocketAddress& addr1,
+ const SocketAddress& addr2) {
+ return !(addr1 == addr2) && !(addr2 == addr1) &&
+ addr1 != addr2 && addr2 != addr1;
+}
+
+TEST(SocketAddressTest, TestEqualityOperators) {
+ SocketAddress addr1("1.2.3.4", 5678);
+ SocketAddress addr2("1.2.3.4", 5678);
+ EXPECT_PRED2(AreEqual, addr1, addr2);
+
+ addr2 = SocketAddress("0.0.0.1", 5678);
+ EXPECT_PRED2(AreUnequal, addr1, addr2);
+
+ addr2 = SocketAddress("1.2.3.4", 1234);
+ EXPECT_PRED2(AreUnequal, addr1, addr2);
+
+ addr2 = SocketAddress(kTestV6AddrString, 5678);
+ EXPECT_PRED2(AreUnequal, addr1, addr2);
+
+ addr1 = SocketAddress(kTestV6AddrString, 5678);
+ EXPECT_PRED2(AreEqual, addr1, addr2);
+
+ addr2 = SocketAddress(kTestV6AddrString, 1234);
+ EXPECT_PRED2(AreUnequal, addr1, addr2);
+
+ addr2 = SocketAddress("fe80::1", 5678);
+ EXPECT_PRED2(AreUnequal, addr1, addr2);
+}
+
+bool IsLessThan(const SocketAddress& addr1,
+ const SocketAddress& addr2) {
+ return addr1 < addr2 &&
+ !(addr2 < addr1) &&
+ !(addr1 == addr2);
+}
+
+TEST(SocketAddressTest, TestComparisonOperator) {
+ SocketAddress addr1("1.2.3.4", 5678);
+ SocketAddress addr2("1.2.3.4", 5678);
+
+ EXPECT_FALSE(addr1 < addr2);
+ EXPECT_FALSE(addr2 < addr1);
+
+ addr2 = SocketAddress("1.2.3.4", 5679);
+ EXPECT_PRED2(IsLessThan, addr1, addr2);
+
+ addr2 = SocketAddress("2.2.3.4", 49152);
+ EXPECT_PRED2(IsLessThan, addr1, addr2);
+
+ addr2 = SocketAddress(kTestV6AddrString, 5678);
+ EXPECT_PRED2(IsLessThan, addr1, addr2);
+
+ addr1 = SocketAddress("fe80::1", 5678);
+ EXPECT_PRED2(IsLessThan, addr2, addr1);
+
+ addr2 = SocketAddress("fe80::1", 5679);
+ EXPECT_PRED2(IsLessThan, addr1, addr2);
+
+ addr2 = SocketAddress("fe80::1", 5678);
+ EXPECT_FALSE(addr1 < addr2);
+ EXPECT_FALSE(addr2 < addr1);
+}
+
} // namespace talk_base
diff --git a/talk/base/ssladapter.h b/talk/base/ssladapter.h
index 687cc24..1583dc2 100644
--- a/talk/base/ssladapter.h
+++ b/talk/base/ssladapter.h
@@ -25,8 +25,8 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef TALK_BASE_SSLADAPTER_H__
-#define TALK_BASE_SSLADAPTER_H__
+#ifndef TALK_BASE_SSLADAPTER_H_
+#define TALK_BASE_SSLADAPTER_H_
#include "talk/base/asyncsocket.h"
@@ -35,8 +35,8 @@
///////////////////////////////////////////////////////////////////////////////
class SSLAdapter : public AsyncSocketAdapter {
-public:
- SSLAdapter(AsyncSocket* socket)
+ public:
+ explicit SSLAdapter(AsyncSocket* socket)
: AsyncSocketAdapter(socket), ignore_bad_cert_(false) { }
bool ignore_bad_cert() const { return ignore_bad_cert_; }
@@ -50,7 +50,7 @@
// Create the default SSL adapter for this platform
static SSLAdapter* Create(AsyncSocket* socket);
-private:
+ private:
// If true, the server certificate need not match the configured hostname.
bool ignore_bad_cert_;
};
@@ -73,4 +73,4 @@
} // namespace talk_base
-#endif // TALK_BASE_SSLADAPTER_H__
+#endif // TALK_BASE_SSLADAPTER_H_
diff --git a/talk/base/sslidentity.cc b/talk/base/sslidentity.cc
index 665e700..0cb52f1 100644
--- a/talk/base/sslidentity.cc
+++ b/talk/base/sslidentity.cc
@@ -54,6 +54,13 @@
namespace talk_base {
+// From RFC 4572
+const char DIGEST_SHA_1[] = "sha-1";
+const char DIGEST_SHA_224[] = "sha-224";
+const char DIGEST_SHA_256[] = "sha-256";
+const char DIGEST_SHA_384[] = "sha-384";
+const char DIGEST_SHA_512[] = "sha-512";
+
SSLCertificate* SSLCertificate::FromPEMString(const std::string& pem_string,
int* pem_length) {
return OpenSSLCertificate::FromPEMString(pem_string, pem_length);
diff --git a/talk/base/sslidentity.h b/talk/base/sslidentity.h
index ed996b4..37e3080 100644
--- a/talk/base/sslidentity.h
+++ b/talk/base/sslidentity.h
@@ -34,6 +34,13 @@
namespace talk_base {
+// Definitions for the digest algorithms
+extern const char DIGEST_SHA_1[];
+extern const char DIGEST_SHA_224[];
+extern const char DIGEST_SHA_256[];
+extern const char DIGEST_SHA_384[];
+extern const char DIGEST_SHA_512[];
+
// Abstract interface overridden by SSL library specific
// implementations.
@@ -61,6 +68,11 @@
// Returns a PEM encoded string representation of the certificate.
virtual std::string ToPEMString() const = 0;
+
+ // Compute the digest of the certificate given algorithm
+ virtual bool ComputeDigest(const std::string &algorithm,
+ unsigned char *digest, std::size_t size,
+ std::size_t *length) const = 0;
};
// Our identity in an SSL negotiation: a keypair and certificate (both
diff --git a/talk/base/sslidentity_unittest.cc b/talk/base/sslidentity_unittest.cc
new file mode 100644
index 0000000..b6200cd
--- /dev/null
+++ b/talk/base/sslidentity_unittest.cc
@@ -0,0 +1,143 @@
+/*
+ * libjingle
+ * Copyright 2011, Google Inc.
+ * Portions Copyright 2011, RTFM, 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 "talk/base/gunit.h"
+#include "talk/base/sslidentity.h"
+
+const char kTestCertificate[] = "-----BEGIN CERTIFICATE-----\n"
+ "MIIB6TCCAVICAQYwDQYJKoZIhvcNAQEEBQAwWzELMAkGA1UEBhMCQVUxEzARBgNV\n"
+ "BAgTClF1ZWVuc2xhbmQxGjAYBgNVBAoTEUNyeXB0U29mdCBQdHkgTHRkMRswGQYD\n"
+ "VQQDExJUZXN0IENBICgxMDI0IGJpdCkwHhcNMDAxMDE2MjIzMTAzWhcNMDMwMTE0\n"
+ "MjIzMTAzWjBjMQswCQYDVQQGEwJBVTETMBEGA1UECBMKUXVlZW5zbGFuZDEaMBgG\n"
+ "A1UEChMRQ3J5cHRTb2Z0IFB0eSBMdGQxIzAhBgNVBAMTGlNlcnZlciB0ZXN0IGNl\n"
+ "cnQgKDUxMiBiaXQpMFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJ+zw4Qnlf8SMVIP\n"
+ "Fe9GEcStgOY2Ww/dgNdhjeD8ckUJNP5VZkVDTGiXav6ooKXfX3j/7tdkuD8Ey2//\n"
+ "Kv7+ue0CAwEAATANBgkqhkiG9w0BAQQFAAOBgQCT0grFQeZaqYb5EYfk20XixZV4\n"
+ "GmyAbXMftG1Eo7qGiMhYzRwGNWxEYojf5PZkYZXvSqZ/ZXHXa4g59jK/rJNnaVGM\n"
+ "k+xIX8mxQvlV0n5O9PIha5BX5teZnkHKgL8aKKLKW1BK7YTngsfSzzaeame5iKfz\n"
+ "itAE+OjGF+PFKbwX8Q==\n"
+ "-----END CERTIFICATE-----\n";
+
+const unsigned char kTestCertSha1[] = {0xA6, 0xC8, 0x59, 0xEA,
+ 0xC3, 0x7E, 0x6D, 0x33,
+ 0xCF, 0xE2, 0x69, 0x9D,
+ 0x74, 0xE6, 0xF6, 0x8A,
+ 0x9E, 0x47, 0xA7, 0xCA};
+
+class SSLIdentityTest : public testing::Test {
+ public:
+ SSLIdentityTest() :
+ identity1_(NULL), identity2_(NULL) {
+ }
+
+ ~SSLIdentityTest() {
+ }
+
+ virtual void SetUp() {
+ identity1_.reset(talk_base::SSLIdentity::Generate("test1"));
+ identity2_.reset(talk_base::SSLIdentity::Generate("test2"));
+
+ ASSERT_TRUE(identity1_.get() != NULL);
+ ASSERT_TRUE(identity2_.get() != NULL);
+
+ test_cert_.reset(
+ talk_base::SSLCertificate::FromPEMString(kTestCertificate, 0));
+ ASSERT_TRUE(test_cert_.get() != NULL);
+ }
+
+ void TestDigest(const std::string &algorithm, size_t expected_len,
+ const unsigned char *expected_digest = NULL) {
+ unsigned char digest1[64];
+ unsigned char digest1b[64];
+ unsigned char digest2[64];
+ size_t digest1_len;
+ size_t digest1b_len;
+ size_t digest2_len;
+ bool rv;
+
+ rv = identity1_->certificate().ComputeDigest(algorithm,
+ digest1, sizeof(digest1),
+ &digest1_len);
+ EXPECT_TRUE(rv);
+ EXPECT_EQ(expected_len, digest1_len);
+
+ rv = identity1_->certificate().ComputeDigest(algorithm,
+ digest1b, sizeof(digest1b),
+ &digest1b_len);
+ EXPECT_TRUE(rv);
+ EXPECT_EQ(expected_len, digest1b_len);
+ EXPECT_EQ(0, memcmp(digest1, digest1b, expected_len));
+
+
+ rv = identity2_->certificate().ComputeDigest(algorithm,
+ digest2, sizeof(digest2),
+ &digest2_len);
+ EXPECT_TRUE(rv);
+ EXPECT_EQ(expected_len, digest2_len);
+ EXPECT_NE(0, memcmp(digest1, digest2, expected_len));
+
+ // If we have an expected hash for the test cert, check it.
+ if (expected_digest != NULL) {
+ unsigned char digest3[64];
+ size_t digest3_len;
+
+ rv = test_cert_->ComputeDigest(algorithm, digest3, sizeof(digest3),
+ &digest3_len);
+ EXPECT_TRUE(rv);
+ EXPECT_EQ(expected_len, digest3_len);
+ EXPECT_EQ(0, memcmp(digest3, expected_digest, expected_len));
+ }
+ }
+
+ private:
+ talk_base::scoped_ptr<talk_base::SSLIdentity> identity1_;
+ talk_base::scoped_ptr<talk_base::SSLIdentity> identity2_;
+ talk_base::scoped_ptr<talk_base::SSLCertificate> test_cert_;
+};
+
+TEST_F(SSLIdentityTest, DigestSHA1) {
+ TestDigest(talk_base::DIGEST_SHA_1, 20, kTestCertSha1);
+}
+
+TEST_F(SSLIdentityTest, DigestSHA224) {
+ TestDigest(talk_base::DIGEST_SHA_224, 28);
+}
+
+TEST_F(SSLIdentityTest, DigestSHA256) {
+ TestDigest(talk_base::DIGEST_SHA_256, 32);
+}
+
+TEST_F(SSLIdentityTest, DigestSHA384) {
+ TestDigest(talk_base::DIGEST_SHA_384, 48);
+}
+
+TEST_F(SSLIdentityTest, DigestSHA512) {
+ TestDigest(talk_base::DIGEST_SHA_512, 64);
+}
diff --git a/talk/base/sslstreamadapter.cc b/talk/base/sslstreamadapter.cc
index 17121fd..aa0f468 100644
--- a/talk/base/sslstreamadapter.cc
+++ b/talk/base/sslstreamadapter.cc
@@ -65,6 +65,23 @@
#endif // !SSL_USE_OPENSSL && !SSL_USE_SCHANNEL
}
+// Note: this matches the logic above with SCHANNEL dominating
+#if SSL_USE_SCHANNEL || !SSL_USE_OPENSSL
+bool SSLStreamAdapter::HaveDtls() { return false; }
+bool SSLStreamAdapter::HaveDtlsSrtp() { return false; }
+bool SSLStreamAdapter::HaveExporter() { return false; }
+#else
+bool SSLStreamAdapter::HaveDtls() {
+ return OpenSSLStreamAdapter::HaveDtls();
+}
+bool SSLStreamAdapter::HaveDtlsSrtp() {
+ return OpenSSLStreamAdapter::HaveDtlsSrtp();
+}
+bool SSLStreamAdapter::HaveExporter() {
+ return OpenSSLStreamAdapter::HaveExporter();
+}
+#endif // !SSL_USE_OPENSSL && !SSL_USE_SCHANNEL
+
///////////////////////////////////////////////////////////////////////////////
} // namespace talk_base
diff --git a/talk/base/sslstreamadapter.h b/talk/base/sslstreamadapter.h
index 62cef08..2afe1da 100644
--- a/talk/base/sslstreamadapter.h
+++ b/talk/base/sslstreamadapter.h
@@ -28,6 +28,9 @@
#ifndef TALK_BASE_SSLSTREAMADAPTER_H__
#define TALK_BASE_SSLSTREAMADAPTER_H__
+#include <string>
+#include <vector>
+
#include "talk/base/stream.h"
#include "talk/base/sslidentity.h"
@@ -47,6 +50,13 @@
// for doing this are in SSLAdapter. They should possibly be moved out
// to a neutral class.
+
+enum SSLRole { SSL_CLIENT, SSL_SERVER };
+enum SSLMode { SSL_MODE_TLS, SSL_MODE_DTLS };
+
+// Errors for Read -- in the high range so no conflict with OpenSSL.
+enum { SSE_MSG_TRUNC = 0xff0001 };
+
class SSLStreamAdapter : public StreamAdapterInterface {
public:
// Instantiate an SSLStreamAdapter wrapping the given stream,
@@ -70,7 +80,12 @@
// Call this to indicate that we are to play the server's role in
// the peer-to-peer mode.
- virtual void SetServerRole() = 0;
+ // The default argument is for backward compatibility
+ // TODO(ekr@rtfm.com): rename this SetRole to reflect its new function
+ virtual void SetServerRole(SSLRole role = SSL_SERVER) = 0;
+
+ // Do DTLS or TLS
+ virtual void SetMode(SSLMode mode) = 0;
// The mode of operation is selected by calling either
// StartSSLWithServer or StartSSLWithPeer.
@@ -95,7 +110,7 @@
// StartSSLWithPeer starts negotiation in the special peer-to-peer
// mode.
// Generally, SetIdentity() and possibly SetServerRole() should have
- // been called before this.
+ // been called before this.
// SetPeerCertificate() must also be called. It may be called after
// StartSSLWithPeer() but must be called before the underlying
// stream opens.
@@ -112,6 +127,53 @@
// given SSLStream instance.
virtual void SetPeerCertificate(SSLCertificate* cert) = 0;
+ // Specify the digest of the certificate that our peer is expected to use in
+ // peer-to-peer mode. Only this certificate will be accepted during
+ // SSL verification. The certificate is assumed to have been
+ // obtained through some other secure channel (such as the XMPP
+ // channel). Unlike SetPeerCertificate(), this must specify the
+ // terminal certificate, not just a CA.
+ // SSLStream makes a copy of the digest value.
+ virtual bool SetPeerCertificateDigest(const std::string& digest_alg,
+ const unsigned char* digest_val,
+ size_t digest_len) = 0;
+
+ // Key Exporter interface from RFC 5705
+ // Arguments are:
+ // label -- the exporter label.
+ // part of the RFC defining each exporter
+ // usage (IN)
+ // context/context_len -- a context to bind to for this connection;
+ // optional, can be NULL, 0 (IN)
+ // use_context -- whether to use the context value
+ // (needed to distinguish no context from
+ // zero-length ones).
+ // result -- where to put the computed value
+ // result_len -- the length of the computed value
+ virtual bool ExportKeyingMaterial(const std::string& label,
+ const uint8* context,
+ size_t context_len,
+ bool use_context,
+ uint8* result,
+ size_t result_len) {
+ return false; // Default is unsupported
+ }
+
+
+ // DTLS-SRTP interface
+ virtual bool SetDtlsSrtpCiphers(const std::vector<std::string>& ciphers) {
+ return false;
+ }
+
+ virtual bool GetDtlsSrtpCipher(std::string* cipher) {
+ return false;
+ }
+
+ // Capabilities testing
+ static bool HaveDtls();
+ static bool HaveDtlsSrtp();
+ static bool HaveExporter();
+
// If true, the server certificate need not match the configured
// server_name, and in fact missing certificate authority and other
// verification errors are ignored.
diff --git a/talk/base/sslstreamadapter_unittest.cc b/talk/base/sslstreamadapter_unittest.cc
new file mode 100644
index 0000000..befcdbc
--- /dev/null
+++ b/talk/base/sslstreamadapter_unittest.cc
@@ -0,0 +1,756 @@
+/*
+ * libjingle
+ * Copyright 2011, Google Inc.
+ * Portions Copyright 2011, RTFM, 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 <set>
+
+#include "talk/base/gunit.h"
+#include "talk/base/helpers.h"
+#include "talk/base/ssladapter.h"
+#include "talk/base/sslidentity.h"
+#include "talk/base/sslstreamadapter.h"
+#include "talk/base/stream.h"
+
+static const int kBlockSize = 4096;
+static const char kAES_CM_HMAC_SHA1_80[] = "AES_CM_128_HMAC_SHA1_80";
+static const char kAES_CM_HMAC_SHA1_32[] = "AES_CM_128_HMAC_SHA1_32";
+static const char kExporterLabel[] = "label";
+static const unsigned char kExporterContext[] = "context";
+static int kExporterContextLen = sizeof(kExporterContext);
+
+#define MAYBE_SKIP_TEST(feature) \
+ if (!(talk_base::SSLStreamAdapter::feature())) { \
+ LOG(LS_INFO) << "Feature disabled... skipping"; \
+ return; \
+ }
+
+class SSLStreamAdapterTestBase;
+
+class SSLDummyStream : public talk_base::StreamInterface,
+ public sigslot::has_slots<> {
+ public:
+ explicit SSLDummyStream(SSLStreamAdapterTestBase *test,
+ const std::string &side,
+ talk_base::FifoBuffer *in,
+ talk_base::FifoBuffer *out) :
+ test_(test),
+ side_(side),
+ in_(in),
+ out_(out),
+ first_packet_(true) {
+ in_->SignalEvent.connect(this, &SSLDummyStream::OnEventIn);
+ out_->SignalEvent.connect(this, &SSLDummyStream::OnEventOut);
+ }
+
+ virtual talk_base::StreamState GetState() const { return talk_base::SS_OPEN; }
+
+ virtual talk_base::StreamResult Read(void* buffer, size_t buffer_len,
+ size_t* read, int* error) {
+ talk_base::StreamResult r;
+
+ r = in_->Read(buffer, buffer_len, read, error);
+ if (r == talk_base::SR_BLOCK)
+ return talk_base::SR_BLOCK;
+ if (r == talk_base::SR_EOS)
+ return talk_base::SR_EOS;
+
+ if (r != talk_base::SR_SUCCESS) {
+ ADD_FAILURE();
+ return talk_base::SR_ERROR;
+ }
+
+ return talk_base::SR_SUCCESS;
+ }
+
+ // Catch readability events on in and pass them up.
+ virtual void OnEventIn(talk_base::StreamInterface *stream, int sig,
+ int err) {
+ int mask = (talk_base::SE_READ | talk_base::SE_CLOSE);
+
+ if (sig & mask) {
+ LOG(LS_INFO) << "SSLDummyStream::OnEvent side=" << side_ << " sig="
+ << sig << " forwarding upward";
+ PostEvent(sig & mask, 0);
+ }
+ }
+
+ // Catch writeability events on out and pass them up.
+ virtual void OnEventOut(talk_base::StreamInterface *stream, int sig,
+ int err) {
+ if (sig & talk_base::SE_WRITE) {
+ LOG(LS_INFO) << "SSLDummyStream::OnEvent side=" << side_ << " sig="
+ << sig << " forwarding upward";
+
+ PostEvent(sig & talk_base::SE_WRITE, 0);
+ }
+ }
+
+ // Write to the outgoing FifoBuffer
+ talk_base::StreamResult WriteData(const void* data, size_t data_len,
+ size_t* written, int* error) {
+ return out_->Write(data, data_len, written, error);
+ }
+
+ // Defined later
+ virtual talk_base::StreamResult Write(const void* data, size_t data_len,
+ size_t* written, int* error);
+
+ virtual void Close() {
+ LOG(LS_INFO) << "Closing outbound stream";
+ out_->Close();
+ }
+
+ private:
+ SSLStreamAdapterTestBase *test_;
+ const std::string side_;
+ talk_base::FifoBuffer *in_;
+ talk_base::FifoBuffer *out_;
+ bool first_packet_;
+};
+
+class SSLStreamAdapterTestBase : public testing::Test,
+ public sigslot::has_slots<> {
+ public:
+ explicit SSLStreamAdapterTestBase(bool dtls) :
+ client_buffer_(4096), server_buffer_(4096),
+ client_stream_(
+ new SSLDummyStream(this, "c2s", &client_buffer_, &server_buffer_)),
+ server_stream_(
+ new SSLDummyStream(this, "s2c", &server_buffer_, &client_buffer_)),
+ client_ssl_(talk_base::SSLStreamAdapter::Create(client_stream_)),
+ server_ssl_(talk_base::SSLStreamAdapter::Create(server_stream_)),
+ client_identity_(NULL), server_identity_(NULL),
+ delay_(0), mtu_(1460), loss_(0), lose_first_packet_(false), dtls_(dtls),
+ handshake_wait_(5000), identities_set_(false) {
+ // Set use of the test RNG to get predictable loss patterns.
+ talk_base::SetRandomTestMode(true);
+
+ LOG(LS_INFO) << "Setup";
+ talk_base::InitializeSSL();
+
+ // Set up the slots
+ client_ssl_->SignalEvent.connect(this, &SSLStreamAdapterTestBase::OnEvent);
+ server_ssl_->SignalEvent.connect(this, &SSLStreamAdapterTestBase::OnEvent);
+
+ client_identity_ = talk_base::SSLIdentity::Generate("client");
+ server_identity_ = talk_base::SSLIdentity::Generate("server");
+
+ client_ssl_->SetIdentity(client_identity_);
+ server_ssl_->SetIdentity(server_identity_);
+ }
+
+ ~SSLStreamAdapterTestBase() {
+ // Put it back for the next test.
+ talk_base::SetRandomTestMode(false);
+ }
+
+ virtual void OnEvent(talk_base::StreamInterface *stream, int sig, int err) {
+ LOG(LS_INFO) << "SSLStreamAdapterTestBase::OnEvent sig=" << sig;
+
+ if (sig & talk_base::SE_READ) {
+ ReadData(stream);
+ }
+
+ if ((stream == client_ssl_.get()) && (sig & talk_base::SE_WRITE)) {
+ WriteData();
+ }
+ }
+
+ void SetPeerIdentitiesByCertificate(bool correct) {
+ LOG(LS_INFO) << "Setting peer identities by certificate";
+
+ if (correct) {
+ client_ssl_->SetPeerCertificate(server_identity_->certificate().
+ GetReference());
+ server_ssl_->SetPeerCertificate(client_identity_->certificate().
+ GetReference());
+ } else {
+ // If incorrect, set up to expect our own certificate at the peer
+ client_ssl_->SetPeerCertificate(client_identity_->certificate().
+ GetReference());
+ server_ssl_->SetPeerCertificate(server_identity_->certificate().
+ GetReference());
+ }
+ identities_set_ = true;
+ }
+
+ void SetPeerIdentitiesByDigest(bool correct) {
+ unsigned char digest[20];
+ size_t digest_len;
+ bool rv;
+
+ LOG(LS_INFO) << "Setting peer identities by digest";
+
+ rv = server_identity_->certificate().ComputeDigest(talk_base::DIGEST_SHA_1,
+ digest, 20,
+ &digest_len);
+ ASSERT_TRUE(rv);
+ if (!correct) {
+ LOG(LS_INFO) << "Setting bogus digest for server cert";
+ digest[0]++;
+ }
+ rv = client_ssl_->SetPeerCertificateDigest(talk_base::DIGEST_SHA_1, digest,
+ digest_len);
+ ASSERT_TRUE(rv);
+
+
+ rv = client_identity_->certificate().ComputeDigest(talk_base::DIGEST_SHA_1,
+ digest, 20, &digest_len);
+ ASSERT_TRUE(rv);
+ if (!correct) {
+ LOG(LS_INFO) << "Setting bogus digest for client cert";
+ digest[0]++;
+ }
+ rv = server_ssl_->SetPeerCertificateDigest(talk_base::DIGEST_SHA_1, digest,
+ digest_len);
+ ASSERT_TRUE(rv);
+
+ identities_set_ = true;
+ }
+
+ void TestHandshake(bool expect_success = true) {
+ server_ssl_->SetMode(dtls_ ? talk_base::SSL_MODE_DTLS :
+ talk_base::SSL_MODE_TLS);
+ client_ssl_->SetMode(dtls_ ? talk_base::SSL_MODE_DTLS :
+ talk_base::SSL_MODE_TLS);
+
+ if (!dtls_) {
+ // Make sure we simulate a reliable network for TLS.
+ // This is just a check to make sure that people don't write wrong
+ // tests.
+ ASSERT((mtu_ == 1460) && (loss_ == 0) && (lose_first_packet_ == 0));
+ }
+
+ if (!identities_set_)
+ SetPeerIdentitiesByDigest(true);
+
+ // Start the handshake
+ int rv;
+
+ server_ssl_->SetServerRole();
+ rv = server_ssl_->StartSSLWithPeer();
+ ASSERT_EQ(0, rv);
+
+ rv = client_ssl_->StartSSLWithPeer();
+ ASSERT_EQ(0, rv);
+
+ // Now run the handshake
+ if (expect_success) {
+ EXPECT_TRUE_WAIT((client_ssl_->GetState() == talk_base::SS_OPEN)
+ && (server_ssl_->GetState() == talk_base::SS_OPEN),
+ handshake_wait_);
+ } else {
+ EXPECT_TRUE_WAIT(client_ssl_->GetState() == talk_base::SS_CLOSED,
+ handshake_wait_);
+ }
+ }
+
+ talk_base::StreamResult DataWritten(SSLDummyStream *from, const void *data,
+ size_t data_len, size_t *written,
+ int *error) {
+ // Randomly drop loss_ percent of packets
+ if (talk_base::CreateRandomId() % 100 < static_cast<uint32>(loss_)) {
+ LOG(LS_INFO) << "Randomly dropping packet, size=" << data_len;
+ *written = data_len;
+ return talk_base::SR_SUCCESS;
+ }
+ if (dtls_ && (data_len > mtu_)) {
+ LOG(LS_INFO) << "Dropping packet > mtu, size=" << data_len;
+ *written = data_len;
+ return talk_base::SR_SUCCESS;
+ }
+
+ return from->WriteData(data, data_len, written, error);
+ }
+
+ void SetDelay(int delay) {
+ delay_ = delay;
+ }
+ int GetDelay() { return delay_; }
+
+ void SetLoseFirstPacket(bool lose) {
+ lose_first_packet_ = lose;
+ }
+ bool GetLoseFirstPacket() { return lose_first_packet_; }
+
+ void SetLoss(int percent) {
+ loss_ = percent;
+ }
+
+ void SetMtu(size_t mtu) {
+ mtu_ = mtu;
+ }
+
+ void SetHandshakeWait(int wait) {
+ handshake_wait_ = wait;
+ }
+
+ void SetDtlsSrtpCiphers(const std::vector<std::string> &ciphers,
+ bool client) {
+ if (client)
+ client_ssl_->SetDtlsSrtpCiphers(ciphers);
+ else
+ server_ssl_->SetDtlsSrtpCiphers(ciphers);
+ }
+
+ bool GetDtlsSrtpCipher(bool client, std::string *retval) {
+ if (client)
+ return client_ssl_->GetDtlsSrtpCipher(retval);
+ else
+ return server_ssl_->GetDtlsSrtpCipher(retval);
+ }
+
+ bool ExportKeyingMaterial(const char *label,
+ const unsigned char *context,
+ size_t context_len,
+ bool use_context,
+ bool client,
+ unsigned char *result,
+ size_t result_len) {
+ if (client)
+ return client_ssl_->ExportKeyingMaterial(label,
+ context, context_len,
+ use_context,
+ result, result_len);
+ else
+ return server_ssl_->ExportKeyingMaterial(label,
+ context, context_len,
+ use_context,
+ result, result_len);
+ }
+
+ // To be implemented by subclasses.
+ virtual void WriteData() = 0;
+ virtual void ReadData(talk_base::StreamInterface *stream) = 0;
+ virtual void TestTransfer(int size) = 0;
+
+ protected:
+ talk_base::FifoBuffer client_buffer_;
+ talk_base::FifoBuffer server_buffer_;
+ SSLDummyStream *client_stream_; // freed by client_ssl_ destructor
+ SSLDummyStream *server_stream_; // freed by server_ssl_ destructor
+ talk_base::scoped_ptr<talk_base::SSLStreamAdapter> client_ssl_;
+ talk_base::scoped_ptr<talk_base::SSLStreamAdapter> server_ssl_;
+ talk_base::SSLIdentity *client_identity_; // freed by client_ssl_ destructor
+ talk_base::SSLIdentity *server_identity_; // freed by server_ssl_ destructor
+ int delay_;
+ size_t mtu_;
+ int loss_;
+ bool lose_first_packet_;
+ bool dtls_;
+ int handshake_wait_;
+ bool identities_set_;
+};
+
+
+class SSLStreamAdapterTestTLS : public SSLStreamAdapterTestBase {
+ public:
+ SSLStreamAdapterTestTLS() :
+ SSLStreamAdapterTestBase(false) {
+ };
+
+ // Test data transfer for TLS
+ virtual void TestTransfer(int size) {
+ LOG(LS_INFO) << "Starting transfer test with " << size << " bytes";
+ // Create some dummy data to send.
+ size_t received;
+
+ send_stream_.ReserveSize(size);
+ for (int i = 0; i < size; ++i) {
+ char ch = static_cast<char>(i);
+ send_stream_.Write(&ch, 1, NULL, NULL);
+ }
+ send_stream_.Rewind();
+
+ // Prepare the receive stream.
+ recv_stream_.ReserveSize(size);
+
+ // Start sending
+ WriteData();
+
+ // Wait for the client to close
+ EXPECT_TRUE_WAIT(server_ssl_->GetState() == talk_base::SS_CLOSED, 10000);
+
+ // Now check the data
+ recv_stream_.GetSize(&received);
+ EXPECT_EQ(static_cast<size_t>(size), received);
+ EXPECT_EQ(0, memcmp(send_stream_.GetBuffer(),
+ recv_stream_.GetBuffer(), size));
+ }
+
+ void WriteData() {
+ size_t position, tosend, size;
+ talk_base::StreamResult rv;
+ size_t sent;
+ char block[kBlockSize];
+
+ send_stream_.GetSize(&size);
+ if (!size)
+ return;
+
+ for (;;) {
+ send_stream_.GetPosition(&position);
+ if (send_stream_.Read(block, sizeof(block), &tosend, NULL) !=
+ talk_base::SR_EOS) {
+ rv = client_ssl_->Write(block, tosend, &sent, 0);
+
+ if (rv == talk_base::SR_SUCCESS) {
+ send_stream_.SetPosition(position + sent);
+ LOG(LS_VERBOSE) << "Sent: " << position + sent;
+ } else if (rv == talk_base::SR_BLOCK) {
+ LOG(LS_VERBOSE) << "Blocked...";
+ send_stream_.SetPosition(position);
+ break;
+ } else {
+ ADD_FAILURE();
+ break;
+ }
+ } else {
+ // Now close
+ LOG(LS_INFO) << "Wrote " << position << " bytes. Closing";
+ client_ssl_->Close();
+ break;
+ }
+ }
+ };
+
+ virtual void ReadData(talk_base::StreamInterface *stream) {
+ char buffer[1600];
+ size_t bread;
+ int err2;
+ talk_base::StreamResult r;
+
+ for (;;) {
+ r = stream->Read(buffer, sizeof(buffer), &bread, &err2);
+
+ if (r == talk_base::SR_ERROR) {
+ // Unfortunately, errors are the way that the stream adapter
+ // signals close right now
+ stream->Close();
+ return;
+ }
+
+ if (r == talk_base::SR_BLOCK)
+ break;
+
+ ASSERT_EQ(talk_base::SR_SUCCESS, r);
+ LOG(LS_INFO) << "Read " << bread;
+
+ recv_stream_.Write(buffer, bread, NULL, NULL);
+ }
+ }
+
+ private:
+ talk_base::MemoryStream send_stream_;
+ talk_base::MemoryStream recv_stream_;
+};
+
+
+class SSLStreamAdapterTestDTLS : public SSLStreamAdapterTestBase {
+ public:
+ SSLStreamAdapterTestDTLS() :
+ SSLStreamAdapterTestBase(true),
+ packet_size_(1000), count_(0), sent_(0) {
+ }
+
+ virtual void WriteData() {
+ unsigned char *packet = new unsigned char[1600];
+
+ do {
+ memset(packet, sent_ & 0xff, packet_size_);
+ *(reinterpret_cast<uint32_t *>(packet)) = sent_;
+
+ size_t sent;
+ int rv = client_ssl_->Write(packet, packet_size_, &sent, 0);
+ if (rv == talk_base::SR_SUCCESS) {
+ LOG(LS_VERBOSE) << "Sent: " << sent_;
+ sent_++;
+ } else if (rv == talk_base::SR_BLOCK) {
+ LOG(LS_VERBOSE) << "Blocked...";
+ break;
+ } else {
+ ADD_FAILURE();
+ break;
+ }
+ } while (sent_ < count_);
+
+ delete [] packet;
+ }
+
+ virtual void ReadData(talk_base::StreamInterface *stream) {
+ unsigned char *buffer = new unsigned char[2000];
+ size_t bread;
+ int err2;
+ talk_base::StreamResult r;
+
+ for (;;) {
+ r = stream->Read(buffer, 2000,
+ &bread, &err2);
+
+ if (r == talk_base::SR_ERROR) {
+ // Unfortunately, errors are the way that the stream adapter
+ // signals close right now
+ stream->Close();
+ return;
+ }
+
+ if (r == talk_base::SR_BLOCK)
+ break;
+
+ ASSERT_EQ(talk_base::SR_SUCCESS, r);
+ LOG(LS_INFO) << "Read " << bread;
+
+ // Now parse the datagram
+ ASSERT_EQ(packet_size_, bread);
+ uint32_t packet_num = *(reinterpret_cast<uint32_t *>(buffer));
+
+ for (size_t i = 4; i < packet_size_; i++) {
+ ASSERT_EQ((packet_num & 0xff), buffer[i]);
+ }
+ received_.insert(packet_num);
+ }
+ }
+
+ virtual void TestTransfer(int count) {
+ count_ = count;
+
+ WriteData();
+
+ EXPECT_TRUE_WAIT(sent_ == count_, 10000);
+ LOG(LS_INFO) << "sent_ == " << sent_;
+
+ if (loss_ == 0) {
+ EXPECT_TRUE_WAIT(static_cast<size_t>(sent_) == received_.size(), 1000);
+ } else {
+ LOG(LS_INFO) << "Sent " << sent_ << " packets; received " <<
+ received_.size();
+ }
+ };
+
+ private:
+ size_t packet_size_;
+ int count_;
+ int sent_;
+ std::set<int> received_;
+};
+
+
+talk_base::StreamResult SSLDummyStream::Write(const void* data, size_t data_len,
+ size_t* written, int* error) {
+ *written = data_len;
+
+ LOG(LS_INFO) << "Writing to loopback " << data_len;
+
+ if (first_packet_) {
+ first_packet_ = false;
+ if (test_->GetLoseFirstPacket()) {
+ LOG(LS_INFO) << "Losing initial packet of length " << data_len;
+ return talk_base::SR_SUCCESS;
+ }
+ }
+
+ return test_->DataWritten(this, data, data_len, written, error);
+
+ return talk_base::SR_SUCCESS;
+};
+
+
+// Basic tests: TLS
+// Test that we can make a handshake work
+TEST_F(SSLStreamAdapterTestTLS, TestTLSConnect) {
+ TestHandshake();
+};
+
+// Test transfer -- trivial
+TEST_F(SSLStreamAdapterTestTLS, TestTLSTransfer) {
+ TestHandshake();
+ TestTransfer(100000);
+};
+
+// Test a handshake with a bogus peer digest
+TEST_F(SSLStreamAdapterTestTLS, TestTLSBogusDigest) {
+ SetPeerIdentitiesByDigest(false);
+ TestHandshake(false);
+};
+
+// Test a handshake with a peer certificate
+TEST_F(SSLStreamAdapterTestTLS, TestTLSPeerCertificate) {
+ SetPeerIdentitiesByCertificate(true);
+ TestHandshake();
+};
+
+// Test a handshake with a bogus peer certificate
+TEST_F(SSLStreamAdapterTestTLS, TestTLSBogusPeerCertificate) {
+ SetPeerIdentitiesByCertificate(false);
+ TestHandshake(false);
+};
+// Test moving a bunch of data
+
+// Basic tests: DTLS
+// Test that we can make a handshake work
+TEST_F(SSLStreamAdapterTestDTLS, TestDTLSConnect) {
+ MAYBE_SKIP_TEST(HaveDtls);
+ TestHandshake();
+};
+
+// Test that we can make a handshake work if the first packet in
+// each direction is lost. This gives us predictable loss
+// rather than having to tune random
+TEST_F(SSLStreamAdapterTestDTLS, TestDTLSConnectWithLostFirstPacket) {
+ MAYBE_SKIP_TEST(HaveDtls);
+ SetLoseFirstPacket(true);
+ TestHandshake();
+};
+
+// Test a handshake with loss and delay
+TEST_F(SSLStreamAdapterTestDTLS,
+ TestDTLSConnectWithLostFirstPacketDelay2s) {
+ MAYBE_SKIP_TEST(HaveDtls);
+ SetLoseFirstPacket(true);
+ SetDelay(2000);
+ SetHandshakeWait(20000);
+ TestHandshake();
+};
+
+// Test a handshake with small MTU
+TEST_F(SSLStreamAdapterTestDTLS, TestDTLSConnectWithSmallMtu) {
+ MAYBE_SKIP_TEST(HaveDtls);
+ SetMtu(700);
+ TestHandshake();
+};
+
+// Test transfer -- trivial
+TEST_F(SSLStreamAdapterTestDTLS, TestDTLSTransfer) {
+ MAYBE_SKIP_TEST(HaveDtls);
+ TestHandshake();
+ TestTransfer(100);
+};
+
+TEST_F(SSLStreamAdapterTestDTLS, TestDTLSTransferWithLoss) {
+ MAYBE_SKIP_TEST(HaveDtls);
+ TestHandshake();
+ SetLoss(10);
+ TestTransfer(100);
+};
+
+// Test DTLS-SRTP with all high ciphers
+TEST_F(SSLStreamAdapterTestDTLS, TestDTLSSrtpHigh) {
+ MAYBE_SKIP_TEST(HaveDtlsSrtp);
+ std::vector<std::string> high;
+ high.push_back(kAES_CM_HMAC_SHA1_80);
+ SetDtlsSrtpCiphers(high, true);
+ SetDtlsSrtpCiphers(high, false);
+ TestHandshake();
+
+ std::string client_cipher;
+ ASSERT_TRUE(GetDtlsSrtpCipher(true, &client_cipher));
+ std::string server_cipher;
+ ASSERT_TRUE(GetDtlsSrtpCipher(false, &server_cipher));
+
+ ASSERT_EQ(client_cipher, server_cipher);
+ ASSERT_EQ(client_cipher, kAES_CM_HMAC_SHA1_80);
+};
+
+// Test DTLS-SRTP with all low ciphers
+TEST_F(SSLStreamAdapterTestDTLS, TestDTLSSrtpLow) {
+ MAYBE_SKIP_TEST(HaveDtlsSrtp);
+ std::vector<std::string> low;
+ low.push_back(kAES_CM_HMAC_SHA1_32);
+ SetDtlsSrtpCiphers(low, true);
+ SetDtlsSrtpCiphers(low, false);
+ TestHandshake();
+
+ std::string client_cipher;
+ ASSERT_TRUE(GetDtlsSrtpCipher(true, &client_cipher));
+ std::string server_cipher;
+ ASSERT_TRUE(GetDtlsSrtpCipher(false, &server_cipher));
+
+ ASSERT_EQ(client_cipher, server_cipher);
+ ASSERT_EQ(client_cipher, kAES_CM_HMAC_SHA1_32);
+};
+
+
+// Test DTLS-SRTP with a mismatch -- should not converge
+TEST_F(SSLStreamAdapterTestDTLS, TestDTLSSrtpHighLow) {
+ MAYBE_SKIP_TEST(HaveDtlsSrtp);
+ std::vector<std::string> high;
+ high.push_back(kAES_CM_HMAC_SHA1_80);
+ std::vector<std::string> low;
+ low.push_back(kAES_CM_HMAC_SHA1_32);
+ SetDtlsSrtpCiphers(high, true);
+ SetDtlsSrtpCiphers(low, false);
+ TestHandshake();
+
+ std::string client_cipher;
+ ASSERT_FALSE(GetDtlsSrtpCipher(true, &client_cipher));
+ std::string server_cipher;
+ ASSERT_FALSE(GetDtlsSrtpCipher(false, &server_cipher));
+};
+
+// Test DTLS-SRTP with each side being mixed -- should select high
+TEST_F(SSLStreamAdapterTestDTLS, TestDTLSSrtpMixed) {
+ MAYBE_SKIP_TEST(HaveDtlsSrtp);
+ std::vector<std::string> mixed;
+ mixed.push_back(kAES_CM_HMAC_SHA1_80);
+ mixed.push_back(kAES_CM_HMAC_SHA1_32);
+ SetDtlsSrtpCiphers(mixed, true);
+ SetDtlsSrtpCiphers(mixed, false);
+ TestHandshake();
+
+ std::string client_cipher;
+ ASSERT_TRUE(GetDtlsSrtpCipher(true, &client_cipher));
+ std::string server_cipher;
+ ASSERT_TRUE(GetDtlsSrtpCipher(false, &server_cipher));
+
+ ASSERT_EQ(client_cipher, server_cipher);
+ ASSERT_EQ(client_cipher, kAES_CM_HMAC_SHA1_80);
+};
+
+// Test an exporter
+TEST_F(SSLStreamAdapterTestDTLS, TestDTLSExporter) {
+ MAYBE_SKIP_TEST(HaveExporter);
+ TestHandshake();
+ unsigned char client_out[20];
+ unsigned char server_out[20];
+
+ bool result;
+ result = ExportKeyingMaterial(kExporterLabel,
+ kExporterContext, kExporterContextLen,
+ true, true,
+ client_out, sizeof(client_out));
+ ASSERT_TRUE(result);
+
+ result = ExportKeyingMaterial(kExporterLabel,
+ kExporterContext, kExporterContextLen,
+ true, false,
+ server_out, sizeof(server_out));
+ ASSERT_TRUE(result);
+
+ ASSERT_TRUE(!memcmp(client_out, server_out, sizeof(client_out)));
+}
diff --git a/talk/base/stream.cc b/talk/base/stream.cc
index 9fcb1a8..24a97dc 100644
--- a/talk/base/stream.cc
+++ b/talk/base/stream.cc
@@ -50,11 +50,6 @@
///////////////////////////////////////////////////////////////////////////////
// StreamInterface
///////////////////////////////////////////////////////////////////////////////
-
-enum {
- MSG_POST_EVENT = 0xF1F1
-};
-
StreamInterface::~StreamInterface() {
}
@@ -174,9 +169,8 @@
///////////////////////////////////////////////////////////////////////////////
StreamTap::StreamTap(StreamInterface* stream, StreamInterface* tap)
-: StreamAdapterInterface(stream), tap_(NULL), tap_result_(SR_SUCCESS),
- tap_error_(0)
-{
+ : StreamAdapterInterface(stream), tap_(NULL), tap_result_(SR_SUCCESS),
+ tap_error_(0) {
AttachTap(tap);
}
@@ -228,24 +222,21 @@
///////////////////////////////////////////////////////////////////////////////
StreamSegment::StreamSegment(StreamInterface* stream)
-: StreamAdapterInterface(stream), start_(SIZE_UNKNOWN), pos_(0),
- length_(SIZE_UNKNOWN)
-{
+ : StreamAdapterInterface(stream), start_(SIZE_UNKNOWN), pos_(0),
+ length_(SIZE_UNKNOWN) {
// It's ok for this to fail, in which case start_ is left as SIZE_UNKNOWN.
stream->GetPosition(&start_);
}
StreamSegment::StreamSegment(StreamInterface* stream, size_t length)
-: StreamAdapterInterface(stream), start_(SIZE_UNKNOWN), pos_(0),
- length_(length)
-{
+ : StreamAdapterInterface(stream), start_(SIZE_UNKNOWN), pos_(0),
+ length_(length) {
// It's ok for this to fail, in which case start_ is left as SIZE_UNKNOWN.
stream->GetPosition(&start_);
}
StreamResult StreamSegment::Read(void* buffer, size_t buffer_len,
- size_t* read, int* error)
-{
+ size_t* read, int* error) {
if (SIZE_UNKNOWN != length_) {
if (pos_ >= length_)
return SR_EOS;
@@ -744,6 +735,12 @@
// all events are done on the owner_ thread
}
+FifoBuffer::FifoBuffer(size_t size, Thread *owner)
+ : state_(SS_OPEN), buffer_(new char[size]), buffer_length_(size),
+ data_length_(0), read_position_(0), owner_(owner) {
+ // all events are done on the owner_ thread
+}
+
FifoBuffer::~FifoBuffer() {
}
@@ -872,7 +869,7 @@
const size_t write_position = (read_position_ + data_length_)
% buffer_length_;
- *size = (write_position >= read_position_) ?
+ *size = (write_position > read_position_ || data_length_ == 0) ?
buffer_length_ - write_position : read_position_ - write_position;
return &buffer_[write_position];
}
@@ -950,8 +947,7 @@
LoggingAdapter::LoggingAdapter(StreamInterface* stream, LoggingSeverity level,
const std::string& label, bool hex_mode)
-: StreamAdapterInterface(stream), level_(level), hex_mode_(hex_mode)
-{
+ : StreamAdapterInterface(stream), level_(level), hex_mode_(hex_mode) {
set_label(label);
}
@@ -974,7 +970,8 @@
StreamResult LoggingAdapter::Write(const void* data, size_t data_len,
size_t* written, int* error) {
- size_t local_written; if (!written) written = &local_written;
+ size_t local_written;
+ if (!written) written = &local_written;
StreamResult result = StreamAdapterInterface::Write(data, data_len, written,
error);
if (result == SR_SUCCESS) {
@@ -1007,13 +1004,11 @@
///////////////////////////////////////////////////////////////////////////////
StringStream::StringStream(std::string& str)
-: str_(str), read_pos_(0), read_only_(false)
-{
+ : str_(str), read_pos_(0), read_only_(false) {
}
StringStream::StringStream(const std::string& str)
-: str_(const_cast<std::string&>(str)), read_pos_(0), read_only_(true)
-{
+ : str_(const_cast<std::string&>(str)), read_pos_(0), read_only_(true) {
}
StreamState StringStream::GetState() const {
@@ -1169,4 +1164,4 @@
///////////////////////////////////////////////////////////////////////////////
-} // namespace talk_base
+} // namespace talk_base
diff --git a/talk/base/stream.h b/talk/base/stream.h
index 0798741..808156c 100644
--- a/talk/base/stream.h
+++ b/talk/base/stream.h
@@ -67,6 +67,10 @@
class StreamInterface : public MessageHandler {
public:
+ enum {
+ MSG_POST_EVENT = 0xF1F1, MSG_MAX = MSG_POST_EVENT
+ };
+
virtual ~StreamInterface();
virtual StreamState GetState() const = 0;
@@ -125,7 +129,7 @@
// latter operation but not the former.
//
- // The following four methods are used to avoid coping data multiple times.
+ // The following four methods are used to avoid copying data multiple times.
// GetReadData returns a pointer to a buffer which is owned by the stream.
// The buffer contains data_len bytes. NULL is returned if no data is
@@ -556,6 +560,8 @@
public:
// Creates a FIFO buffer with the specified capacity.
explicit FifoBuffer(size_t length);
+ // Creates a FIFO buffer with the specified capacity and owner
+ FifoBuffer(size_t length, Thread* owner);
virtual ~FifoBuffer();
// Gets the amount of data currently readable from the buffer.
bool GetBuffered(size_t* data_len) const;
diff --git a/talk/base/stream_unittest.cc b/talk/base/stream_unittest.cc
index d0c5718..b96279b 100644
--- a/talk/base/stream_unittest.cc
+++ b/talk/base/stream_unittest.cc
@@ -35,14 +35,14 @@
///////////////////////////////////////////////////////////////////////////////
class TestStream : public StreamInterface {
-public:
+ public:
TestStream() : pos_(0) { }
virtual StreamState GetState() const { return SS_OPEN; }
virtual StreamResult Read(void* buffer, size_t buffer_len,
size_t* read, int* error) {
unsigned char* uc_buffer = static_cast<unsigned char*>(buffer);
- for (size_t i=0; i<buffer_len; ++i) {
+ for (size_t i = 0; i < buffer_len; ++i) {
uc_buffer[i] = pos_++;
}
if (read)
@@ -71,14 +71,14 @@
return false;
}
-private:
+ private:
unsigned char pos_;
};
bool VerifyTestBuffer(unsigned char* buffer, size_t len,
unsigned char value) {
bool passed = true;
- for (size_t i=0; i<len; ++i) {
+ for (size_t i = 0; i < len; ++i) {
if (buffer[i] != value++) {
passed = false;
break;
@@ -393,6 +393,15 @@
EXPECT_EQ(SR_EOS, stream->Read(out, kSize / 2, &bytes, NULL));
}
+TEST(FifoBufferTest, FullBufferCheck) {
+ FifoBuffer buff(10);
+ buff.ConsumeWriteBuffer(10);
+
+ size_t free;
+ EXPECT_TRUE(buff.GetWriteBuffer(&free) != NULL);
+ EXPECT_EQ(0U, free);
+}
+
TEST(FifoBufferTest, WriteOffsetAndReadOffset) {
const size_t kSize = 16;
const char in[kSize * 2 + 1] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
@@ -442,4 +451,4 @@
EXPECT_EQ(SR_BLOCK, buf.ReadOffset(out, 10, 16, NULL));
}
-} // namespace talk_base
+} // namespace talk_base
diff --git a/talk/base/systeminfo.cc b/talk/base/systeminfo.cc
new file mode 100644
index 0000000..7cbc418
--- /dev/null
+++ b/talk/base/systeminfo.cc
@@ -0,0 +1,461 @@
+/*
+ * libjingle
+ * Copyright 2008 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.
+ */
+
+#ifdef WIN32
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/win32.h" // first because it brings in win32 stuff
+#ifndef EXCLUDE_D3D9
+#include <d3d9.h>
+#endif
+
+#elif defined(OSX)
+#include <ApplicationServices/ApplicationServices.h>
+#include <CoreServices/CoreServices.h>
+#include <sys/sysctl.h>
+#include "talk/base/macconversion.h"
+#elif defined(IOS)
+#include <sys/sysctl.h>
+#elif defined(LINUX) || defined(ANDROID)
+#include <unistd.h>
+#include "talk/base/linux.h"
+#endif
+
+#include "talk/base/common.h"
+#include "talk/base/cpuid.h"
+#include "talk/base/logging.h"
+#include "talk/base/stringutils.h"
+#include "talk/base/systeminfo.h"
+
+namespace talk_base {
+
+// See Also: http://msdn.microsoft.com/en-us/library/ms683194(v=vs.85).aspx
+#ifdef WIN32
+typedef BOOL (WINAPI *LPFN_GLPI)(
+ PSYSTEM_LOGICAL_PROCESSOR_INFORMATION,
+ PDWORD);
+
+static int NumCores() {
+ // GetLogicalProcessorInformation() is available on Windows XP SP3 and beyond.
+ LPFN_GLPI glpi = reinterpret_cast<LPFN_GLPI>(GetProcAddress(
+ GetModuleHandle(L"kernel32"),
+ "GetLogicalProcessorInformation"));
+ if (NULL == glpi) {
+ return -1;
+ }
+ // Determine buffer size, allocate and get processor information.
+ // Size can change between calls (unlikely), so a loop is done.
+ DWORD return_length = 0;
+ scoped_array<SYSTEM_LOGICAL_PROCESSOR_INFORMATION> infos;
+ while (!glpi(infos.get(), &return_length)) {
+ if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
+ infos.reset(new SYSTEM_LOGICAL_PROCESSOR_INFORMATION[
+ return_length / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION)]);
+ } else {
+ return -1;
+ }
+ }
+ int processor_core_count = 0;
+ for (size_t i = 0;
+ i < return_length / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION); ++i) {
+ if (infos[i].Relationship == RelationProcessorCore) {
+ ++processor_core_count;
+ }
+ }
+ return processor_core_count;
+}
+#endif
+
+// Note(fbarchard):
+// Family and model are extended family and extended model. 8 bits each.
+SystemInfo::SystemInfo()
+ : physical_cpus_(1), logical_cpus_(1),
+ cpu_family_(0), cpu_model_(0), cpu_stepping_(0),
+ cpu_speed_(0), memory_(0) {
+ // Initialize the basic information.
+
+#if defined(__arm__)
+ cpu_arch_ = ARCH_ARM;
+#elif defined(CPU_X86)
+ cpu_arch_ = ARCH_X86;
+#else
+#error "Unknown architecture."
+#endif
+
+#ifdef WIN32
+ SYSTEM_INFO si;
+ GetSystemInfo(&si);
+ logical_cpus_ = si.dwNumberOfProcessors;
+ physical_cpus_ = NumCores();
+ if (physical_cpus_ <= 0) {
+ physical_cpus_ = logical_cpus_;
+ }
+ cpu_family_ = si.wProcessorLevel;
+ cpu_model_ = si.wProcessorRevision >> 8;
+ cpu_stepping_ = si.wProcessorRevision & 0xFF;
+#elif defined(OSX) || defined(IOS)
+ uint32_t sysctl_value;
+ size_t length = sizeof(sysctl_value);
+ if (!sysctlbyname("hw.physicalcpu_max", &sysctl_value, &length, NULL, 0)) {
+ physical_cpus_ = static_cast<int>(sysctl_value);
+ }
+ length = sizeof(sysctl_value);
+ if (!sysctlbyname("hw.logicalcpu_max", &sysctl_value, &length, NULL, 0)) {
+ logical_cpus_ = static_cast<int>(sysctl_value);
+ }
+ length = sizeof(sysctl_value);
+ if (!sysctlbyname("machdep.cpu.family", &sysctl_value, &length, NULL, 0)) {
+ cpu_family_ = static_cast<int>(sysctl_value);
+ }
+ length = sizeof(sysctl_value);
+ if (!sysctlbyname("machdep.cpu.model", &sysctl_value, &length, NULL, 0)) {
+ cpu_model_ = static_cast<int>(sysctl_value);
+ }
+ length = sizeof(sysctl_value);
+ if (!sysctlbyname("machdep.cpu.stepping", &sysctl_value, &length, NULL, 0)) {
+ cpu_stepping_ = static_cast<int>(sysctl_value);
+ }
+#else // LINUX || ANDROID
+ ProcCpuInfo proc_info;
+ if (proc_info.LoadFromSystem()) {
+ proc_info.GetNumCpus(&logical_cpus_);
+ proc_info.GetNumPhysicalCpus(&physical_cpus_);
+ proc_info.GetCpuFamily(&cpu_family_);
+#if !defined(__arm__)
+ // These values aren't found on ARM systems.
+ proc_info.GetSectionIntValue(0, "model", &cpu_model_);
+ proc_info.GetSectionIntValue(0, "stepping", &cpu_stepping_);
+ proc_info.GetSectionIntValue(0, "cpu MHz", &cpu_speed_);
+#endif
+ }
+
+ // ProcCpuInfo reads cpu speed from "cpu MHz" under /proc/cpuinfo.
+ // But that number is a moving target which can change on-the-fly according to
+ // many factors including system workload.
+ // See /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_governors.
+ // The one in /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq is more
+ // accurate. We use it as our cpu speed when it is available.
+ int max_freq = talk_base::ReadCpuMaxFreq();
+ if (max_freq > 0) {
+ cpu_speed_ = max_freq;
+ }
+#endif
+}
+
+// Return the number of cpu threads available to the system.
+int SystemInfo::GetMaxCpus() {
+ return logical_cpus_;
+}
+
+// Return the number of cpu cores available to the system.
+int SystemInfo::GetMaxPhysicalCpus() {
+ return physical_cpus_;
+}
+
+// Return the number of cpus available to the process. Since affinity can be
+// changed on the fly, do not cache this value.
+// Can be affected by heat.
+int SystemInfo::GetCurCpus() {
+ int cur_cpus;
+#ifdef WIN32
+ DWORD process_mask, system_mask;
+ ::GetProcessAffinityMask(::GetCurrentProcess(), &process_mask, &system_mask);
+ for (cur_cpus = 0; process_mask; ++cur_cpus) {
+ // Sparse-ones algorithm. There are slightly faster methods out there but
+ // they are unintuitive and won't make a difference on a single dword.
+ process_mask &= (process_mask - 1);
+ }
+#elif defined(OSX)
+ // Find number of _available_ cores
+ cur_cpus = MPProcessorsScheduled();
+#elif defined(IOS)
+ uint32_t sysctl_value;
+ size_t length = sizeof(sysctl_value);
+ int error = sysctlbyname("hw.ncpu", &sysctl_value, &length, NULL, 0);
+ cur_cpus = !error ? static_cast<int>(sysctl_value) : 1;
+#else
+ // Linux, Solaris, ANDROID
+ cur_cpus = static_cast<int>(sysconf(_SC_NPROCESSORS_ONLN));
+#endif
+ return cur_cpus;
+}
+
+// Return the type of this CPU.
+SystemInfo::Architecture SystemInfo::GetCpuArchitecture() {
+ return cpu_arch_;
+}
+
+// Returns the vendor string from the cpu, e.g. "GenuineIntel", "AuthenticAMD".
+// See "Intel Processor Identification and the CPUID Instruction"
+// (Intel document number: 241618)
+std::string SystemInfo::GetCpuVendor() {
+ if (cpu_vendor_.empty()) {
+ cpu_vendor_ = talk_base::CpuInfo::GetCpuVendor();
+ }
+ return cpu_vendor_;
+}
+
+// Return the "family" of this CPU.
+int SystemInfo::GetCpuFamily() {
+ return cpu_family_;
+}
+
+// Return the "model" of this CPU.
+int SystemInfo::GetCpuModel() {
+ return cpu_model_;
+}
+
+// Return the "stepping" of this CPU.
+int SystemInfo::GetCpuStepping() {
+ return cpu_stepping_;
+}
+
+// Return the clockrate of the primary processor in Mhz. This value can be
+// cached. Returns -1 on error.
+int SystemInfo::GetMaxCpuSpeed() {
+ if (cpu_speed_) {
+ return cpu_speed_;
+ }
+
+#ifdef WIN32
+ HKEY key;
+ static const WCHAR keyName[] =
+ L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0";
+
+ if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyName , 0, KEY_QUERY_VALUE, &key)
+ == ERROR_SUCCESS) {
+ DWORD data, len;
+ len = sizeof(data);
+
+ if (RegQueryValueEx(key, L"~Mhz", 0, 0, reinterpret_cast<LPBYTE>(&data),
+ &len) == ERROR_SUCCESS) {
+ cpu_speed_ = data;
+ } else {
+ LOG(LS_WARNING) << "Failed to query registry value HKLM\\" << keyName
+ << "\\~Mhz";
+ cpu_speed_ = -1;
+ }
+
+ RegCloseKey(key);
+ } else {
+ LOG(LS_WARNING) << "Failed to open registry key HKLM\\" << keyName;
+ cpu_speed_ = -1;
+ }
+#elif defined(IOS) || defined(OSX)
+ uint64_t sysctl_value;
+ size_t length = sizeof(sysctl_value);
+ int error = sysctlbyname("hw.cpufrequency_max", &sysctl_value, &length, NULL, 0);
+ cpu_speed_ = !error ? static_cast<int>(sysctl_value/1000000) : -1;
+#else
+ // TODO: Implement using proc/cpuinfo
+ cpu_speed_ = 0;
+#endif
+ return cpu_speed_;
+}
+
+// Dynamically check the current clockrate, which could be reduced because of
+// powersaving profiles. Eventually for windows we want to query WMI for
+// root\WMI::ProcessorPerformance.InstanceName="Processor_Number_0".frequency
+int SystemInfo::GetCurCpuSpeed() {
+#ifdef WIN32
+ // TODO: Add WMI check, requires COM initialization
+ // NOTE(fbarchard): Testable on Sandy Bridge.
+ return GetMaxCpuSpeed();
+#elif defined(IOS) || defined(OSX)
+ uint64_t sysctl_value;
+ size_t length = sizeof(sysctl_value);
+ int error = sysctlbyname("hw.cpufrequency", &sysctl_value, &length, NULL, 0);
+ return !error ? static_cast<int>(sysctl_value/1000000) : GetMaxCpuSpeed();
+#else // LINUX || ANDROID
+ // TODO: Use proc/cpuinfo for Cur speed on Linux.
+ return GetMaxCpuSpeed();
+#endif
+}
+
+// Returns the amount of installed physical memory in Bytes. Cacheable.
+// Returns -1 on error.
+int64 SystemInfo::GetMemorySize() {
+ if (memory_) {
+ return memory_;
+ }
+
+#ifdef WIN32
+ MEMORYSTATUSEX status = {0};
+ status.dwLength = sizeof(status);
+
+ if (GlobalMemoryStatusEx(&status)) {
+ memory_ = status.ullTotalPhys;
+ } else {
+ LOG_GLE(LS_WARNING) << "GlobalMemoryStatusEx failed.";
+ memory_ = -1;
+ }
+
+#elif defined(OSX) || defined(IOS)
+ size_t len = sizeof(memory_);
+ int error = sysctlbyname("hw.memsize", &memory_, &len, NULL, 0);
+ if (error || memory_ == 0) {
+ memory_ = -1;
+ }
+#else
+ memory_ = static_cast<int64>(sysconf(_SC_PHYS_PAGES)) *
+ static_cast<int64>(sysconf(_SC_PAGESIZE));
+ if (memory_ < 0) {
+ LOG(LS_WARNING) << "sysconf(_SC_PHYS_PAGES) failed."
+ << "sysconf(_SC_PHYS_PAGES) " << sysconf(_SC_PHYS_PAGES)
+ << "sysconf(_SC_PAGESIZE) " << sysconf(_SC_PAGESIZE);
+ memory_ = -1;
+ }
+#endif
+
+ return memory_;
+}
+
+
+// Return the name of the machine model we are currently running on.
+// This is a human readable string that consists of the name and version
+// number of the hardware, i.e 'MacBookAir1,1'. Returns an empty string if
+// model can not be determined. The string is cached for subsequent calls.
+std::string SystemInfo::GetMachineModel() {
+ if (!machine_model_.empty()) {
+ return machine_model_;
+ }
+
+#if defined(OSX) || defined(IOS)
+ char buffer[128];
+ size_t length = sizeof(buffer);
+ int error = sysctlbyname("hw.model", buffer, &length, NULL, 0);
+ if (!error) {
+ machine_model_.assign(buffer, length - 1);
+ } else {
+ machine_model_.clear();
+ }
+#else
+ machine_model_ = "Not available";
+#endif
+
+ return machine_model_;
+}
+
+#ifdef OSX
+// Helper functions to query IOKit for video hardware properties.
+static CFTypeRef SearchForProperty(io_service_t port, CFStringRef name) {
+ return IORegistryEntrySearchCFProperty(port, kIOServicePlane,
+ name, kCFAllocatorDefault,
+ kIORegistryIterateRecursively | kIORegistryIterateParents);
+}
+
+static void GetProperty(io_service_t port, CFStringRef name, int* value) {
+ if (!value) return;
+ CFTypeRef ref = SearchForProperty(port, name);
+ if (ref) {
+ CFTypeID refType = CFGetTypeID(ref);
+ if (CFNumberGetTypeID() == refType) {
+ CFNumberRef number = reinterpret_cast<CFNumberRef>(ref);
+ p_convertCFNumberToInt(number, value);
+ } else if (CFDataGetTypeID() == refType) {
+ CFDataRef data = reinterpret_cast<CFDataRef>(ref);
+ if (CFDataGetLength(data) == sizeof(UInt32)) {
+ *value = *reinterpret_cast<const UInt32*>(CFDataGetBytePtr(data));
+ }
+ }
+ CFRelease(ref);
+ }
+}
+
+static void GetProperty(io_service_t port, CFStringRef name,
+ std::string* value) {
+ if (!value) return;
+ CFTypeRef ref = SearchForProperty(port, name);
+ if (ref) {
+ CFTypeID refType = CFGetTypeID(ref);
+ if (CFStringGetTypeID() == refType) {
+ CFStringRef stringRef = reinterpret_cast<CFStringRef>(ref);
+ p_convertHostCFStringRefToCPPString(stringRef, *value);
+ } else if (CFDataGetTypeID() == refType) {
+ CFDataRef dataRef = reinterpret_cast<CFDataRef>(ref);
+ *value = std::string(reinterpret_cast<const char*>(
+ CFDataGetBytePtr(dataRef)), CFDataGetLength(dataRef));
+ }
+ CFRelease(ref);
+ }
+}
+#endif
+
+// Fills a struct with information on the graphics adapater and returns true
+// iff successful.
+bool SystemInfo::GetGpuInfo(GpuInfo *info) {
+ if (!info) return false;
+#if defined(WIN32) && !defined(EXCLUDE_D3D9)
+ D3DADAPTER_IDENTIFIER9 identifier;
+ HRESULT hr = E_FAIL;
+ HINSTANCE d3d_lib = LoadLibrary(L"d3d9.dll");
+
+ if (d3d_lib) {
+ typedef IDirect3D9* (WINAPI *D3DCreate9Proc)(UINT);
+ D3DCreate9Proc d3d_create_proc = reinterpret_cast<D3DCreate9Proc>(
+ GetProcAddress(d3d_lib, "Direct3DCreate9"));
+ if (d3d_create_proc) {
+ IDirect3D9* d3d = d3d_create_proc(D3D_SDK_VERSION);
+ if (d3d) {
+ hr = d3d->GetAdapterIdentifier(D3DADAPTER_DEFAULT, 0, &identifier);
+ d3d->Release();
+ }
+ }
+ FreeLibrary(d3d_lib);
+ }
+
+ if (hr != D3D_OK) {
+ LOG(LS_ERROR) << "Failed to access Direct3D9 information.";
+ return false;
+ }
+
+ info->device_name = identifier.DeviceName;
+ info->description = identifier.Description;
+ info->vendor_id = identifier.VendorId;
+ info->device_id = identifier.DeviceId;
+ info->driver = identifier.Driver;
+ // driver_version format: product.version.subversion.build
+ std::stringstream ss;
+ ss << HIWORD(identifier.DriverVersion.HighPart) << "."
+ << LOWORD(identifier.DriverVersion.HighPart) << "."
+ << HIWORD(identifier.DriverVersion.LowPart) << "."
+ << LOWORD(identifier.DriverVersion.LowPart);
+ info->driver_version = ss.str();
+ return true;
+#elif defined(OSX)
+ // We'll query the IOKit for the gpu of the main display.
+ io_service_t display_service_port = CGDisplayIOServicePort(
+ kCGDirectMainDisplay);
+ GetProperty(display_service_port, CFSTR("vendor-id"), &info->vendor_id);
+ GetProperty(display_service_port, CFSTR("device-id"), &info->device_id);
+ GetProperty(display_service_port, CFSTR("model"), &info->description);
+ return true;
+#else // LINUX || ANDROID
+ // TODO: Implement this on Linux
+ return false;
+#endif
+}
+} // namespace talk_base
diff --git a/talk/base/systeminfo.h b/talk/base/systeminfo.h
new file mode 100644
index 0000000..cf8e537
--- /dev/null
+++ b/talk/base/systeminfo.h
@@ -0,0 +1,94 @@
+/*
+ * libjingle
+ * Copyright 2008 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_BASE_SYSTEMINFO_H__
+#define TALK_BASE_SYSTEMINFO_H__
+
+#include <string>
+
+#include "talk/base/basictypes.h"
+
+namespace talk_base {
+
+class SystemInfo {
+ public:
+ enum Architecture {
+ ARCH_X86 = 0,
+ ARCH_X64 = 1,
+ ARCH_ARM = 2
+ };
+
+ SystemInfo();
+
+ // The number of CPU Cores in the system.
+ int GetMaxPhysicalCpus();
+ // The number of CPU Threads in the system.
+ int GetMaxCpus();
+ // The number of CPU Threads currently available to this process.
+ int GetCurCpus();
+ // Identity of the CPUs.
+ Architecture GetCpuArchitecture();
+ std::string GetCpuVendor();
+ int GetCpuFamily();
+ int GetCpuModel();
+ int GetCpuStepping();
+ // Estimated speed of the CPUs, in MHz.
+ int GetMaxCpuSpeed();
+ int GetCurCpuSpeed();
+ // Total amount of physical memory, in bytes.
+ int64 GetMemorySize();
+ // The model name of the machine, e.g. "MacBookAir1,1"
+ std::string GetMachineModel();
+
+ // The gpu identifier
+ struct GpuInfo {
+ GpuInfo() : vendor_id(0), device_id(0) {}
+ std::string device_name;
+ std::string description;
+ int vendor_id;
+ int device_id;
+ std::string driver;
+ std::string driver_version;
+ };
+ bool GetGpuInfo(GpuInfo *info);
+
+ private:
+ int physical_cpus_;
+ int logical_cpus_;
+ Architecture cpu_arch_;
+ std::string cpu_vendor_;
+ int cpu_family_;
+ int cpu_model_;
+ int cpu_stepping_;
+ int cpu_speed_;
+ int64 memory_;
+ std::string machine_model_;
+};
+
+}
+
+#endif // TALK_BASE_SYSTEMINFO_H__
diff --git a/talk/base/systeminfo_unittest.cc b/talk/base/systeminfo_unittest.cc
new file mode 100644
index 0000000..6df0db5
--- /dev/null
+++ b/talk/base/systeminfo_unittest.cc
@@ -0,0 +1,143 @@
+/*
+ * libjingle
+ * Copyright 2009, 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/base/gunit.h"
+#include "talk/base/stringutils.h"
+#include "talk/base/systeminfo.h"
+
+#ifdef CPU_X86
+
+// CPUID-based tests only work on X86
+
+// Tests CPUID instruction for Vendor identification.
+TEST(SystemInfoTest, CpuVendorNonEmpty) {
+ talk_base::SystemInfo info;
+ LOG(LS_INFO) << "CpuVendor: " << info.GetCpuVendor();
+ EXPECT_FALSE(info.GetCpuVendor().empty());
+}
+
+// Tests Vendor identification is Intel or AMD.
+// See Also http://en.wikipedia.org/wiki/CPUID
+TEST(SystemInfoTest, CpuVendorIntelAMD) {
+ talk_base::SystemInfo info;
+ EXPECT_TRUE(talk_base::string_match(info.GetCpuVendor().c_str(),
+ "GenuineIntel") ||
+ talk_base::string_match(info.GetCpuVendor().c_str(),
+ "AuthenticAMD"));
+}
+
+#endif // CPU_X86
+
+// Tests MachineModel is set.
+TEST(SystemInfoTest, MachineModelNonEmpty) {
+ talk_base::SystemInfo info;
+ LOG(LS_INFO) << "MachineModel: " << info.GetMachineModel();
+ EXPECT_FALSE(info.GetMachineModel().empty());
+}
+
+// Tests maximum cpu clockrate.
+TEST(SystemInfoTest, CpuMaxCpuSpeed) {
+ talk_base::SystemInfo info;
+ LOG(LS_INFO) << "MaxCpuSpeed: " << info.GetMaxCpuSpeed();
+ EXPECT_GT(info.GetMaxCpuSpeed(), 0);
+}
+
+// Tests current cpu clockrate.
+TEST(SystemInfoTest, CpuCurCpuSpeed) {
+ talk_base::SystemInfo info;
+ LOG(LS_INFO) << "MaxCurSpeed: " << info.GetCurCpuSpeed();
+ EXPECT_GT(info.GetCurCpuSpeed(), 0);
+}
+
+// Tests physical memory size.
+TEST(SystemInfoTest, MemorySize) {
+ talk_base::SystemInfo info;
+ LOG(LS_INFO) << "MemorySize: " << info.GetMemorySize();
+ EXPECT_GT(info.GetMemorySize(), -1);
+}
+
+// Tests number of logical cpus available to the system.
+TEST(SystemInfoTest, MaxCpus) {
+ talk_base::SystemInfo info;
+ LOG(LS_INFO) << "MaxCpus: " << info.GetMaxCpus();
+ EXPECT_GT(info.GetMaxCpus(), 0);
+}
+
+// Tests number of physical cpus available to the system.
+TEST(SystemInfoTest, MaxPhysicalCpus) {
+ talk_base::SystemInfo info;
+ LOG(LS_INFO) << "MaxPhysicalCpus: " << info.GetMaxPhysicalCpus();
+ EXPECT_GT(info.GetMaxPhysicalCpus(), 0);
+ EXPECT_LE(info.GetMaxPhysicalCpus(), info.GetMaxCpus());
+}
+
+// Tests number of logical cpus available to the process.
+TEST(SystemInfoTest, CurCpus) {
+ talk_base::SystemInfo info;
+ LOG(LS_INFO) << "CurCpus: " << info.GetCurCpus();
+ EXPECT_GT(info.GetCurCpus(), 0);
+ EXPECT_LE(info.GetCurCpus(), info.GetMaxCpus());
+}
+
+#ifdef CPU_X86
+
+// CPU family/model/steeping is only available on X86
+
+// Tests Intel CPU Family identification.
+TEST(SystemInfoTest, CpuFamilyNonZero) {
+ talk_base::SystemInfo info;
+ LOG(LS_INFO) << "CpuFamily: " << info.GetCpuFamily();
+ EXPECT_GT(info.GetCpuFamily(), 0);
+}
+
+// Tests Intel CPU Model identification.
+TEST(SystemInfoTest, CpuModelNonZero) {
+ talk_base::SystemInfo info;
+ LOG(LS_INFO) << "CpuModel: " << info.GetCpuModel();
+ EXPECT_GT(info.GetCpuModel(), 0);
+}
+
+// Tests Intel CPU Stepping identification.
+TEST(SystemInfoTest, CpuSteppingNonZero) {
+ talk_base::SystemInfo info;
+ LOG(LS_INFO) << "CpuStepping: " << info.GetCpuStepping();
+ EXPECT_GT(info.GetCpuStepping(), 0);
+}
+
+#endif // CPU_X86
+
+#if WIN32 && !defined(EXCLUDE_D3D9)
+TEST(SystemInfoTest, GpuInfo) {
+ talk_base::SystemInfo info;
+ talk_base::SystemInfo::GpuInfo gi;
+ EXPECT_TRUE(info.GetGpuInfo(&gi));
+ LOG(LS_INFO) << "GpuDriver: " << gi.driver;
+ EXPECT_FALSE(gi.driver.empty());
+ LOG(LS_INFO) << "GpuDriverVersion: " << gi.driver_version;
+ EXPECT_FALSE(gi.driver_version.empty());
+}
+#endif
diff --git a/talk/base/task.cc b/talk/base/task.cc
index ad17438..c37797c 100644
--- a/talk/base/task.cc
+++ b/talk/base/task.cc
@@ -197,22 +197,15 @@
}
std::string Task::GetStateName(int state) const {
- static const std::string STR_BLOCKED("BLOCKED");
- static const std::string STR_INIT("INIT");
- static const std::string STR_START("START");
- static const std::string STR_DONE("DONE");
- static const std::string STR_ERROR("ERROR");
- static const std::string STR_RESPONSE("RESPONSE");
- static const std::string STR_HUH("??");
switch (state) {
- case STATE_BLOCKED: return STR_BLOCKED;
- case STATE_INIT: return STR_INIT;
- case STATE_START: return STR_START;
- case STATE_DONE: return STR_DONE;
- case STATE_ERROR: return STR_ERROR;
- case STATE_RESPONSE: return STR_RESPONSE;
+ case STATE_BLOCKED: return "BLOCKED";
+ case STATE_INIT: return "INIT";
+ case STATE_START: return "START";
+ case STATE_DONE: return "DONE";
+ case STATE_ERROR: return "ERROR";
+ case STATE_RESPONSE: return "RESPONSE";
}
- return STR_HUH;
+ return "??";
}
int Task::Process(int state) {
diff --git a/talk/base/task_unittest.cc b/talk/base/task_unittest.cc
index 076ff6f..0c4a7a2 100644
--- a/talk/base/task_unittest.cc
+++ b/talk/base/task_unittest.cc
@@ -43,7 +43,7 @@
#include "talk/base/task.h"
#include "talk/base/taskrunner.h"
#include "talk/base/thread.h"
-#include "talk/base/time.h"
+#include "talk/base/timeutils.h"
namespace talk_base {
diff --git a/talk/base/testbase64.h b/talk/base/testbase64.h
new file mode 100644
index 0000000..39dd00c
--- /dev/null
+++ b/talk/base/testbase64.h
@@ -0,0 +1,5 @@
+/* This file was generated by googleclient/talk/binary2header.sh */
+
+static unsigned char testbase64[] = {
+0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01, 0x02, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xff, 0xe1, 0x0d, 0x07, 0x45, 0x78, 0x69, 0x66, 0x00, 0x00, 0x4d, 0x4d, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0c, 0x01, 0x0e, 0x00, 0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x9e, 0x01, 0x0f, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xbe, 0x01, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xc3, 0x01, 0x12, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x1a, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xcc, 0x01, 0x1b, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xd4, 0x01, 0x28, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x01, 0x31, 0x00, 0x02, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xdc, 0x01, 0x32, 0x00, 0x02, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xf0, 0x01, 0x3c, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x01, 0x04, 0x02, 0x13, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x87, 0x69, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x14, 0x00, 0x00, 0x02, 0xc4, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x53, 0x4f, 0x4e, 0x59, 0x00, 0x44, 0x53, 0x43, 0x2d, 0x50, 0x32, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x01, 0x41, 0x64, 0x6f, 0x62, 0x65, 0x20, 0x50, 0x68, 0x6f, 0x74, 0x6f, 0x73, 0x68, 0x6f, 0x70, 0x20, 0x37, 0x2e, 0x30, 0x00, 0x32, 0x30, 0x30, 0x37, 0x3a, 0x30, 0x31, 0x3a, 0x33, 0x30, 0x20, 0x32, 0x33, 0x3a, 0x31, 0x30, 0x3a, 0x30, 0x34, 0x00, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x20, 0x31, 0x30, 0x2e, 0x34, 0x2e, 0x38, 0x00, 0x00, 0x1c, 0x82, 0x9a, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x6a, 0x82, 0x9d, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x72, 0x88, 0x22, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x88, 0x27, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x64, 0x00, 0x00, 0x90, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04, 0x30, 0x32, 0x32, 0x30, 0x90, 0x03, 0x00, 0x02, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x02, 0x7a, 0x90, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x02, 0x8e, 0x91, 0x01, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04, 0x01, 0x02, 0x03, 0x00, 0x91, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0xa2, 0x92, 0x04, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0xaa, 0x92, 0x05, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0xb2, 0x92, 0x07, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x05, 0x00, 0x00, 0x92, 0x08, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x92, 0x09, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0f, 0x00, 0x00, 0x92, 0x0a, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0xba, 0xa0, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04, 0x30, 0x31, 0x30, 0x30, 0xa0, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00, 0xa0, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x64, 0xa0, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x64, 0xa3, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0xa3, 0x01, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0xa4, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xa4, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xa4, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xa4, 0x06, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xa4, 0x08, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xa4, 0x09, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xa4, 0x0a, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x01, 0x90, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x0a, 0x32, 0x30, 0x30, 0x37, 0x3a, 0x30, 0x31, 0x3a, 0x32, 0x30, 0x20, 0x32, 0x33, 0x3a, 0x30, 0x35, 0x3a, 0x35, 0x32, 0x00, 0x32, 0x30, 0x30, 0x37, 0x3a, 0x30, 0x31, 0x3a, 0x32, 0x30, 0x20, 0x32, 0x33, 0x3a, 0x30, 0x35, 0x3a, 0x35, 0x32, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x06, 0x01, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x06, 0x00, 0x00, 0x01, 0x1a, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x12, 0x01, 0x1b, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x1a, 0x01, 0x28, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x02, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x22, 0x02, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x09, 0xdd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x01, 0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01, 0x02, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xff, 0xed, 0x00, 0x0c, 0x41, 0x64, 0x6f, 0x62, 0x65, 0x5f, 0x43, 0x4d, 0x00, 0x02, 0xff, 0xee, 0x00, 0x0e, 0x41, 0x64, 0x6f, 0x62, 0x65, 0x00, 0x64, 0x80, 0x00, 0x00, 0x00, 0x01, 0xff, 0xdb, 0x00, 0x84, 0x00, 0x0c, 0x08, 0x08, 0x08, 0x09, 0x08, 0x0c, 0x09, 0x09, 0x0c, 0x11, 0x0b, 0x0a, 0x0b, 0x11, 0x15, 0x0f, 0x0c, 0x0c, 0x0f, 0x15, 0x18, 0x13, 0x13, 0x15, 0x13, 0x13, 0x18, 0x11, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x11, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x01, 0x0d, 0x0b, 0x0b, 0x0d, 0x0e, 0x0d, 0x10, 0x0e, 0x0e, 0x10, 0x14, 0x0e, 0x0e, 0x0e, 0x14, 0x14, 0x0e, 0x0e, 0x0e, 0x0e, 0x14, 0x11, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x11, 0x11, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x11, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xff, 0xc0, 0x00, 0x11, 0x08, 0x00, 0x64, 0x00, 0x64, 0x03, 0x01, 0x22, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xdd, 0x00, 0x04, 0x00, 0x07, 0xff, 0xc4, 0x01, 0x3f, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x01, 0x02, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x01, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x10, 0x00, 0x01, 0x04, 0x01, 0x03, 0x02, 0x04, 0x02, 0x05, 0x07, 0x06, 0x08, 0x05, 0x03, 0x0c, 0x33, 0x01, 0x00, 0x02, 0x11, 0x03, 0x04, 0x21, 0x12, 0x31, 0x05, 0x41, 0x51, 0x61, 0x13, 0x22, 0x71, 0x81, 0x32, 0x06, 0x14, 0x91, 0xa1, 0xb1, 0x42, 0x23, 0x24, 0x15, 0x52, 0xc1, 0x62, 0x33, 0x34, 0x72, 0x82, 0xd1, 0x43, 0x07, 0x25, 0x92, 0x53, 0xf0, 0xe1, 0xf1, 0x63, 0x73, 0x35, 0x16, 0xa2, 0xb2, 0x83, 0x26, 0x44, 0x93, 0x54, 0x64, 0x45, 0xc2, 0xa3, 0x74, 0x36, 0x17, 0xd2, 0x55, 0xe2, 0x65, 0xf2, 0xb3, 0x84, 0xc3, 0xd3, 0x75, 0xe3, 0xf3, 0x46, 0x27, 0x94, 0xa4, 0x85, 0xb4, 0x95, 0xc4, 0xd4, 0xe4, 0xf4, 0xa5, 0xb5, 0xc5, 0xd5, 0xe5, 0xf5, 0x56, 0x66, 0x76, 0x86, 0x96, 0xa6, 0xb6, 0xc6, 0xd6, 0xe6, 0xf6, 0x37, 0x47, 0x57, 0x67, 0x77, 0x87, 0x97, 0xa7, 0xb7, 0xc7, 0xd7, 0xe7, 0xf7, 0x11, 0x00, 0x02, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x05, 0x06, 0x07, 0x07, 0x06, 0x05, 0x35, 0x01, 0x00, 0x02, 0x11, 0x03, 0x21, 0x31, 0x12, 0x04, 0x41, 0x51, 0x61, 0x71, 0x22, 0x13, 0x05, 0x32, 0x81, 0x91, 0x14, 0xa1, 0xb1, 0x42, 0x23, 0xc1, 0x52, 0xd1, 0xf0, 0x33, 0x24, 0x62, 0xe1, 0x72, 0x82, 0x92, 0x43, 0x53, 0x15, 0x63, 0x73, 0x34, 0xf1, 0x25, 0x06, 0x16, 0xa2, 0xb2, 0x83, 0x07, 0x26, 0x35, 0xc2, 0xd2, 0x44, 0x93, 0x54, 0xa3, 0x17, 0x64, 0x45, 0x55, 0x36, 0x74, 0x65, 0xe2, 0xf2, 0xb3, 0x84, 0xc3, 0xd3, 0x75, 0xe3, 0xf3, 0x46, 0x94, 0xa4, 0x85, 0xb4, 0x95, 0xc4, 0xd4, 0xe4, 0xf4, 0xa5, 0xb5, 0xc5, 0xd5, 0xe5, 0xf5, 0x56, 0x66, 0x76, 0x86, 0x96, 0xa6, 0xb6, 0xc6, 0xd6, 0xe6, 0xf6, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77, 0x87, 0x97, 0xa7, 0xb7, 0xc7, 0xff, 0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f, 0x00, 0xf2, 0xed, 0xb2, 0x8d, 0x4d, 0x45, 0xcd, 0x2f, 0x3f, 0x44, 0x68, 0x93, 0xc3, 0x58, 0xc8, 0xf1, 0x1f, 0x8a, 0x33, 0x86, 0xda, 0x58, 0xc1, 0xa0, 0x02, 0x4f, 0xc4, 0xa1, 0x69, 0xa5, 0x9b, 0x5b, 0x4b, 0x84, 0x73, 0xdf, 0xc9, 0x15, 0xf8, 0xe3, 0xd1, 0x0e, 0x07, 0x93, 0xf3, 0xd1, 0x0f, 0x1c, 0x17, 0xef, 0x2e, 0x3b, 0x5b, 0xdc, 0xff, 0x00, 0xdf, 0x42, 0xbf, 0x8f, 0x8e, 0xdc, 0x82, 0xca, 0xd8, 0x37, 0x11, 0xa9, 0x3d, 0x82, 0x69, 0x2b, 0xc4, 0x6d, 0xc9, 0x75, 0x25, 0xbc, 0xf7, 0xec, 0xa1, 0xb5, 0x74, 0x19, 0x5d, 0x2e, 0x8a, 0x9a, 0x4b, 0x89, 0x7d, 0xc4, 0x68, 0xc6, 0xf6, 0xfe, 0xb2, 0xa0, 0x30, 0x1d, 0x60, 0x86, 0x88, 0x8d, 0x49, 0x3e, 0x01, 0x11, 0x20, 0xa3, 0x8c, 0xb9, 0xb1, 0xaa, 0x62, 0xad, 0xbf, 0x18, 0x97, 0x43, 0x47, 0x1d, 0xd2, 0xaf, 0x04, 0xd9, 0xb8, 0xc8, 0x0d, 0x68, 0xe4, 0xf7, 0x3e, 0x48, 0xf1, 0x05, 0xbc, 0x25, 0xaa, 0x07, 0x71, 0xd9, 0x14, 0x78, 0xf6, 0x49, 0xb5, 0x90, 0xfd, 0xa7, 0xc6, 0x14, 0xfd, 0x1b, 0x1c, 0xff, 0x00, 0x4d, 0x8d, 0x2e, 0x73, 0x8c, 0x35, 0xa3, 0x52, 0x4f, 0x92, 0x48, 0xa6, 0x1a, 0x24, 0xb6, 0x2a, 0xfa, 0xa5, 0x9e, 0x60, 0x64, 0x39, 0x94, 0x13, 0xcb, 0x27, 0x73, 0x80, 0xf3, 0x0c, 0xf6, 0xff, 0x00, 0xd2, 0x5a, 0x78, 0xbf, 0x53, 0x71, 0xf6, 0x01, 0x75, 0xb6, 0x97, 0x6a, 0x25, 0xa1, 0xad, 0x1f, 0xf4, 0xb7, 0x23, 0x48, 0xb7, 0x94, 0x84, 0x97, 0x5b, 0xff, 0x00, 0x32, 0xa9, 0xdd, 0xfc, 0xed, 0x9b, 0x7e, 0x0d, 0x9e, 0x52, 0x4a, 0x95, 0x61, 0xff, 0xd0, 0xf3, 0x3b, 0xa7, 0x70, 0xee, 0x01, 0x8f, 0xb9, 0x59, 0xfa, 0x7e, 0xdf, 0xe4, 0xc8, 0xf9, 0x2a, 0xc2, 0x5c, 0x63, 0xc3, 0x54, 0x67, 0x87, 0x6e, 0x10, 0x35, 0x68, 0xd4, 0x79, 0x1e, 0x53, 0x4a, 0xe0, 0xdc, 0xe9, 0xb8, 0x1f, 0x6a, 0xda, 0x6c, 0x25, 0x94, 0x37, 0xb0, 0xd0, 0xb8, 0xad, 0x67, 0xe4, 0x55, 0x8a, 0x5b, 0x8b, 0x82, 0xc0, 0x6f, 0x76, 0x80, 0x34, 0x49, 0x05, 0x2e, 0x9e, 0xc6, 0x1c, 0x66, 0x31, 0xba, 0x10, 0x23, 0xe0, 0xaf, 0xe1, 0x61, 0x53, 0x43, 0x8d, 0x81, 0xb3, 0x67, 0xef, 0x9e, 0x49, 0x2a, 0x12, 0x6c, 0xb6, 0x63, 0x1a, 0x0c, 0x31, 0xba, 0x55, 0xcd, 0xac, 0xfa, 0x8e, 0xdf, 0x91, 0x6e, 0x91, 0xd9, 0xb3, 0xc9, 0x73, 0x90, 0x7a, 0xab, 0x6a, 0xc2, 0xa4, 0x60, 0xe2, 0x8f, 0xd2, 0x38, 0x03, 0x7d, 0x9e, 0x0d, 0xff, 0x00, 0xcc, 0xd6, 0xd3, 0x6b, 0x71, 0x67, 0xd2, 0x3e, 0x64, 0x72, 0xab, 0xdb, 0x8d, 0x54, 0x39, 0xc5, 0x83, 0x6b, 0x3d, 0xee, 0x2e, 0xd4, 0x92, 0x3c, 0x4a, 0x56, 0xba, 0xb4, 0x79, 0x5c, 0xf7, 0xb2, 0x96, 0x6c, 0x8d, 0xaf, 0x80, 0x48, 0x3c, 0xf0, 0xb2, 0x1f, 0x63, 0x9c, 0xe9, 0x3f, 0x24, 0x5c, 0xdb, 0xdd, 0x76, 0x43, 0xde, 0xfd, 0x5c, 0xe3, 0x24, 0xfc, 0x50, 0x00, 0x93, 0x0a, 0x78, 0x8a, 0x0d, 0x49, 0xca, 0xcf, 0x93, 0x63, 0x1b, 0x7d, 0xd7, 0x57, 0x50, 0xd5, 0xef, 0x70, 0x6b, 0x4f, 0xc7, 0x45, 0xdb, 0x74, 0x9e, 0x8d, 0x5e, 0x33, 0x83, 0xd8, 0x37, 0xdd, 0xc3, 0xac, 0x3d, 0xbf, 0x92, 0xc5, 0x5b, 0xea, 0xbf, 0xd5, 0x62, 0xc0, 0xdc, 0xbc, 0xbd, 0x2d, 0x22, 0x5a, 0xcf, 0xdd, 0x69, 0xff, 0x00, 0xd1, 0x8e, 0x5d, 0xa5, 0x38, 0xb5, 0xb0, 0x00, 0xc6, 0xc4, 0x24, 0x4a, 0xd6, 0x8d, 0x18, 0x04, 0x49, 0x88, 0x9e, 0x55, 0xd6, 0x61, 0xb0, 0xc1, 0x70, 0x32, 0xdd, 0x3c, 0x95, 0xda, 0xf1, 0xfe, 0xf5, 0x62, 0xbc, 0x76, 0x8e, 0x75, 0x28, 0x02, 0xa2, 0xe7, 0x7d, 0x92, 0xb9, 0x84, 0x96, 0x96, 0xda, 0xf7, 0x70, 0x12, 0x4e, 0x5a, 0xff, 0x00, 0xff, 0xd1, 0xf3, 0x7a, 0x21, 0xaf, 0xde, 0xef, 0xa2, 0x22, 0x55, 0xfc, 0x5a, 0xbd, 0x42, 0xfb, 0x08, 0xfa, 0x67, 0x4f, 0x82, 0xcd, 0x6d, 0x85, 0xc0, 0x56, 0x3b, 0x90, 0xb7, 0xf0, 0x2a, 0x0e, 0x63, 0x58, 0x3b, 0xf2, 0xa3, 0x9e, 0x8c, 0xb8, 0x86, 0xbe, 0x49, 0xf1, 0x2c, 0x0c, 0x86, 0xb4, 0x4c, 0x69, 0xe4, 0xaf, 0x6e, 0xcc, 0x6b, 0x7d, 0x46, 0xb3, 0x70, 0xec, 0x38, 0x51, 0x7d, 0x02, 0x8a, 0xc7, 0xa6, 0xd9, 0x20, 0x68, 0x0f, 0x8f, 0x8a, 0xcf, 0xc9, 0xc2, 0xea, 0x59, 0x5b, 0x48, 0xb0, 0x91, 0xae, 0xe6, 0xc9, 0x03, 0xc9, 0x30, 0x51, 0x66, 0xd4, 0x0d, 0xad, 0xbd, 0x5f, 0x53, 0xcc, 0x6b, 0xb6, 0x90, 0x5a, 0x3b, 0x83, 0x0b, 0x43, 0x17, 0x31, 0xd6, 0xc3, 0x6e, 0x12, 0x3b, 0x79, 0xac, 0xc1, 0x89, 0x47, 0xd9, 0xe8, 0x63, 0x98, 0x45, 0xed, 0x6c, 0x5a, 0xf1, 0xa0, 0x27, 0xc5, 0x5b, 0xc3, 0x6f, 0xa6, 0xe0, 0x1c, 0x7d, 0xb3, 0xa2, 0x69, 0x34, 0x7b, 0xae, 0x1a, 0x8d, 0x45, 0x17, 0x9d, 0xeb, 0xfd, 0x21, 0xd8, 0xb9, 0xae, 0xb5, 0x80, 0xbb, 0x1e, 0xd2, 0x5c, 0xd7, 0x78, 0x13, 0xf9, 0xae, 0x4b, 0xea, 0xc7, 0x4a, 0x39, 0xbd, 0x55, 0xb3, 0xed, 0x66, 0x38, 0xf5, 0x09, 0x22, 0x41, 0x23, 0xe8, 0x37, 0xfb, 0x4b, 0xa1, 0xeb, 0xd6, 0xfe, 0x88, 0x31, 0xbf, 0x41, 0xc0, 0xee, 0xd2, 0x74, 0x02, 0x78, 0x53, 0xfa, 0x97, 0x43, 0x19, 0x85, 0x65, 0xff, 0x00, 0x9d, 0x71, 0x33, 0xe4, 0x1a, 0x7d, 0x8d, 0x53, 0x42, 0x56, 0x35, 0x6b, 0xe5, 0x80, 0x06, 0xc7, 0x57, 0xa7, 0xc4, 0xa9, 0xdb, 0xb6, 0x81, 0x1f, 0xeb, 0xd9, 0x69, 0x56, 0xc2, 0xd0, 0x00, 0xe5, 0x55, 0xc0, 0x12, 0xc2, 0xd7, 0x4e, 0xa2, 0x5a, 0x7c, 0x0a, 0xd0, 0x63, 0x9a, 0xd1, 0xaf, 0xd2, 0xe2, 0x3c, 0x12, 0x62, 0x66, 0xc6, 0x42, 0x23, 0x5a, 0x49, 0x8f, 0x10, 0xa2, 0xd2, 0x3e, 0x28, 0x9d, 0xc4, 0x88, 0x09, 0x29, 0x16, 0xc3, 0x3c, 0x24, 0x8d, 0xe6, 0x92, 0x72, 0x1f, 0xff, 0xd2, 0xf3, 0xbb, 0xb0, 0xfe, 0xcb, 0x99, 0xe9, 0xce, 0xf6, 0x88, 0x2d, 0x77, 0x91, 0x5b, 0x3d, 0x3d, 0xd0, 0xe6, 0x90, 0xa9, 0x65, 0x57, 0x38, 0x95, 0xdd, 0xcb, 0x9a, 0x7d, 0xce, 0xf2, 0x3f, 0x44, 0x23, 0x60, 0x58, 0x76, 0xe9, 0xca, 0x8c, 0xea, 0x1b, 0x31, 0x02, 0x32, 0x23, 0xea, 0xee, 0xb1, 0xcd, 0xb0, 0xc7, 0x87, 0x74, 0x7a, 0xeb, 0x70, 0x1a, 0x71, 0xe1, 0xfe, 0xe4, 0x1c, 0x1d, 0xae, 0xe5, 0x69, 0xd8, 0xfa, 0x99, 0x50, 0x0d, 0x1a, 0xf7, 0x2a, 0x3a, 0x0c, 0xf4, 0x1a, 0x8e, 0xc7, 0x27, 0x5d, 0xbf, 0x18, 0x41, 0xdc, 0xc2, 0xf0, 0x7f, 0x74, 0xf6, 0x3a, 0x22, 0x66, 0xdb, 0x68, 0xc6, 0x80, 0x48, 0x6b, 0x88, 0x06, 0x39, 0x0d, 0xee, 0xaa, 0x1f, 0xb3, 0xd5, 0x1b, 0x83, 0xd8, 0x3b, 0x38, 0x8f, 0x69, 0xfe, 0xdf, 0xd1, 0x4d, 0x29, 0xa1, 0x4c, 0x7a, 0xf4, 0xbf, 0xa7, 0x92, 0xcf, 0xa5, 0x20, 0x08, 0xf3, 0xf6, 0xff, 0x00, 0x15, 0xbb, 0xd1, 0x31, 0xd9, 0x5e, 0x3d, 0x75, 0x56, 0x36, 0x88, 0x00, 0x81, 0xe0, 0x16, 0x5e, 0x55, 0x74, 0x3f, 0x00, 0x9d, 0xe0, 0xcc, 0x69, 0xe7, 0x3a, 0x2d, 0xbe, 0x90, 0x00, 0xa9, 0xae, 0xef, 0x1f, 0x95, 0x4b, 0x0d, 0x9a, 0xdc, 0xc7, 0x45, 0xfe, 0xb1, 0x7d, 0x60, 0xa7, 0xa1, 0xe0, 0x1f, 0x4e, 0x1d, 0x99, 0x69, 0x02, 0x9a, 0xcf, 0x1f, 0xca, 0x7b, 0xbf, 0x90, 0xc5, 0xc2, 0xb3, 0xeb, 0x57, 0xd6, 0x03, 0x6b, 0xae, 0x39, 0xb6, 0x82, 0xe3, 0x31, 0xa1, 0x68, 0xf2, 0x6b, 0x5c, 0x12, 0xfa, 0xe1, 0x91, 0x66, 0x47, 0x5d, 0xb8, 0x3b, 0x4f, 0x44, 0x36, 0xb6, 0x8f, 0x28, 0xdd, 0xff, 0x00, 0x7e, 0x46, 0xab, 0x12, 0x2b, 0x65, 0x55, 0x32, 0xa7, 0x62, 0xb6, 0xbd, 0xf7, 0x64, 0x10, 0xdb, 0x03, 0x9f, 0x1b, 0x9e, 0xc7, 0xd9, 0xb8, 0x3b, 0x1f, 0x67, 0xf3, 0x6c, 0x52, 0x80, 0xd7, 0x7d, 0x0f, 0xea, 0x7f, 0x5d, 0x1d, 0x67, 0xa6, 0x0b, 0x1e, 0x47, 0xda, 0x69, 0x3b, 0x2e, 0x03, 0xc7, 0xf3, 0x5f, 0x1f, 0xf0, 0x8b, 0xa1, 0x02, 0x46, 0xba, 0x79, 0xaf, 0x32, 0xff, 0x00, 0x16, 0xad, 0xca, 0x1d, 0x57, 0x2a, 0xdc, 0x79, 0x18, 0x41, 0xb0, 0xf6, 0x9e, 0xe4, 0x9f, 0xd0, 0x8f, 0xeb, 0x31, 0xab, 0xd2, 0x83, 0xa4, 0xcb, 0x8c, 0xb8, 0xa0, 0x42, 0x12, 0x7b, 0x67, 0x9f, 0x2f, 0xf5, 0x09, 0x26, 0x96, 0xc4, 0xce, 0xa9, 0x20, 0xa7, 0xff, 0xd3, 0xf3, 0x2f, 0xb4, 0x5d, 0xe9, 0x0a, 0xb7, 0x9f, 0x4c, 0x19, 0xdb, 0x3a, 0x2d, 0x5e, 0x94, 0xfd, 0xc4, 0xb7, 0xc5, 0x62, 0xf9, 0x2b, 0xfd, 0x2e, 0xe3, 0x5d, 0xe0, 0x7c, 0x13, 0x48, 0xd1, 0x92, 0x12, 0xa9, 0x0b, 0x7a, 0xbc, 0x2d, 0xc2, 0x7f, 0x92, 0x60, 0xab, 0x4e, 0x79, 0x2e, 0x00, 0xf0, 0xaa, 0xe1, 0xda, 0x3d, 0x43, 0xfc, 0xad, 0x55, 0xbb, 0x80, 0x79, 0x81, 0xa0, 0xe6, 0x54, 0x32, 0x6d, 0x02, 0xbe, 0xf3, 0x61, 0x81, 0xa8, 0x44, 0x14, 0x03, 0x59, 0x0e, 0x1c, 0xf6, 0x1f, 0xdc, 0xb2, 0xec, 0xa3, 0x23, 0x77, 0xe8, 0x6e, 0x70, 0xf2, 0x25, 0x1f, 0x1f, 0x17, 0xa9, 0x6d, 0x71, 0x36, 0x97, 0x47, 0x00, 0xa4, 0x02, 0xe0, 0x2c, 0x7c, 0xc1, 0xab, 0xd5, 0x31, 0x85, 0x35, 0xd4, 0xe6, 0x13, 0x02, 0xd6, 0x4b, 0x67, 0x48, 0x2b, 0xa9, 0xe9, 0x2e, 0x02, 0xb6, 0x4f, 0x82, 0xe5, 0x7a, 0x95, 0x19, 0xc6, 0x87, 0x3d, 0xfb, 0xa2, 0xb8, 0x79, 0x1e, 0x4d, 0x3b, 0x96, 0xcf, 0x4f, 0xbd, 0xcd, 0xa2, 0xa2, 0x1f, 0xa0, 0x82, 0xd3, 0xfc, 0x97, 0x05, 0x24, 0x36, 0x6b, 0xf3, 0x31, 0xa2, 0x35, 0x79, 0xef, 0xad, 0xf8, 0xae, 0xaf, 0xaf, 0xd8, 0xf2, 0xd8, 0x6d, 0xed, 0x6b, 0xda, 0x7b, 0x18, 0x1b, 0x5d, 0xff, 0x00, 0x52, 0xb1, 0x6d, 0xf0, 0x81, 0x31, 0xca, 0xf4, 0x6e, 0xb1, 0x80, 0xce, 0xb1, 0x84, 0xc0, 0x21, 0xb7, 0xd6, 0x77, 0x31, 0xd1, 0x27, 0xc1, 0xcd, 0xfe, 0xd2, 0xe3, 0xec, 0xe8, 0x1d, 0x45, 0x96, 0xb0, 0x9a, 0xb7, 0x87, 0x3f, 0x68, 0x2d, 0xf7, 0x01, 0x1f, 0xbe, 0xd1, 0xf4, 0x7f, 0xb4, 0xa4, 0x0d, 0x77, 0xbb, 0xfa, 0x8f, 0x80, 0x3a, 0x7f, 0x43, 0xaa, 0xe2, 0xdf, 0xd2, 0x65, 0x7e, 0x95, 0xe4, 0x0f, 0x1f, 0xa1, 0xfe, 0x6b, 0x16, 0x9f, 0x52, 0xfa, 0xc1, 0xd3, 0xba, 0x6d, 0x26, 0xdc, 0xac, 0x86, 0xd4, 0xd9, 0x0d, 0x31, 0x2e, 0x74, 0x9e, 0xdb, 0x59, 0x2e, 0x55, 0xe8, 0xc9, 0xb2, 0x96, 0xd5, 0x4b, 0x9f, 0xb8, 0x6d, 0xda, 0x1c, 0x04, 0x09, 0x03, 0xfe, 0x8a, 0xc6, 0xfa, 0xd3, 0xf5, 0x6a, 0xbe, 0xbb, 0x5b, 0x2e, 0xc6, 0xb5, 0x94, 0xe6, 0xd5, 0x20, 0x97, 0x7d, 0x1b, 0x1b, 0xf9, 0xad, 0x7c, 0x7d, 0x17, 0xb7, 0xf3, 0x1e, 0x92, 0x1b, 0x7f, 0xf8, 0xe0, 0x7d, 0x59, 0xdd, 0xfd, 0x32, 0xd8, 0x8f, 0xa5, 0xe8, 0x3a, 0x12, 0x5c, 0x3f, 0xfc, 0xc4, 0xfa, 0xc3, 0xb3, 0x77, 0xa7, 0x56, 0xed, 0xdb, 0x76, 0x7a, 0x8d, 0xdd, 0x1f, 0xbf, 0xfd, 0x44, 0x92, 0x56, 0x8f, 0xff, 0xd4, 0xf2, 0xe8, 0x86, 0x17, 0x1e, 0xfa, 0x04, 0x56, 0x4b, 0x43, 0x6c, 0x6f, 0x2d, 0xe5, 0x46, 0x01, 0x64, 0x2b, 0x14, 0x32, 0x5b, 0xb4, 0xa0, 0x52, 0x1d, 0xde, 0x9b, 0x94, 0xdb, 0xab, 0x6b, 0x81, 0xf7, 0x05, 0xb0, 0xd7, 0x07, 0xb2, 0x27, 0x55, 0xc6, 0x57, 0x65, 0xd8, 0x76, 0x6e, 0x64, 0xed, 0xee, 0x16, 0xce, 0x27, 0x57, 0x63, 0xda, 0x0c, 0xc2, 0x8e, 0x51, 0x67, 0x84, 0xfa, 0x1d, 0xdd, 0x62, 0xc7, 0x07, 0xe9, 0xf7, 0xa3, 0xd6, 0x6c, 0x02, 0x41, 0x55, 0x31, 0xf3, 0x2b, 0xb3, 0xba, 0x2b, 0x2e, 0x68, 0x24, 0x1d, 0x47, 0x64, 0xca, 0xa6, 0x50, 0x41, 0x65, 0x90, 0x6c, 0xb1, 0xa5, 0xae, 0x33, 0x23, 0x51, 0xe4, 0xab, 0x7d, 0x5d, 0xcb, 0xb6, 0xcc, 0x37, 0xd0, 0x40, 0x73, 0x71, 0xde, 0x58, 0x09, 0xe7, 0x6f, 0x2c, 0x44, 0xc9, 0xc9, 0xae, 0xba, 0x9d, 0x63, 0x88, 0x01, 0xa0, 0x95, 0x9d, 0xf5, 0x3f, 0x2a, 0xe6, 0x67, 0xdb, 0x50, 0x83, 0x55, 0xad, 0x36, 0x3e, 0x78, 0x10, 0x74, 0x77, 0xfd, 0x2d, 0xaa, 0x4c, 0x7d, 0x58, 0x73, 0x91, 0xa0, 0x0f, 0x51, 0x45, 0xb7, 0x33, 0xdd, 0x58, 0x69, 0x1d, 0xd8, 0x0c, 0x9f, 0x96, 0x88, 0x19, 0x99, 0x19, 0xac, 0xcf, 0xa3, 0xd2, 0xad, 0xb5, 0xdb, 0x76, 0x8f, 0xad, 0xc4, 0xea, 0xcf, 0xdf, 0x7e, 0xdf, 0xdd, 0xfc, 0xd5, 0xa3, 0x5e, 0x43, 0x2b, 0x6b, 0xb2, 0xad, 0x3b, 0x6a, 0xa4, 0x13, 0xa7, 0x04, 0xac, 0x7a, 0x6f, 0xb3, 0x23, 0x26, 0xcc, 0xfb, 0xb4, 0x75, 0x8e, 0x01, 0x83, 0xf7, 0x58, 0x3e, 0x8b, 0x53, 0xa7, 0x2a, 0x1a, 0x31, 0x42, 0x36, 0x5d, 0x4c, 0x9a, 0xf2, 0xdc, 0xc6, 0xfe, 0x98, 0xb4, 0x34, 0xcb, 0x48, 0x0a, 0x8f, 0xdb, 0xb2, 0xeb, 0x76, 0xd6, 0x07, 0x5c, 0x59, 0xc9, 0x64, 0x8f, 0x93, 0xa7, 0x73, 0x16, 0x83, 0xaf, 0x0e, 0xa4, 0x33, 0xef, 0x50, 0xc5, 0x0c, 0xda, 0x59, 0x10, 0x06, 0x8a, 0x2e, 0x29, 0x0e, 0xac, 0xc2, 0x31, 0x3d, 0x36, 0x69, 0x7e, 0xd6, 0xcc, 0xf5, 0x3d, 0x6f, 0xb3, 0xeb, 0x1b, 0x76, 0xef, 0x3b, 0xa3, 0xfa, 0xc9, 0x2b, 0x5f, 0x66, 0x6f, 0xa9, 0x1e, 0x73, 0xf2, 0x49, 0x2e, 0x39, 0xf7, 0x4f, 0xb7, 0x8d, 0xff, 0xd5, 0xf3, 0x26, 0xfe, 0x0a, 0xc5, 0x1b, 0xa7, 0xcb, 0xb2, 0xcf, 0x49, 0x03, 0xb2, 0x46, 0xee, 0xd9, 0xd9, 0xb3, 0xf4, 0x9f, 0x25, 0x4a, 0xdf, 0x4b, 0x77, 0xe8, 0x27, 0xd4, 0xef, 0x1c, 0x2a, 0x29, 0x26, 0xc5, 0x7c, 0x9d, 0x6c, 0x7f, 0xb7, 0x6e, 0x1b, 0x26, 0x7f, 0x05, 0xa3, 0xfe, 0x53, 0x8d, 0x62, 0x57, 0x30, 0x92, 0x12, 0xfa, 0x2f, 0x86, 0xdf, 0xa4, 0xec, 0x67, 0xfe, 0xd0, 0xf4, 0xff, 0x00, 0x4d, 0xfc, 0xdf, 0x78, 0xe1, 0x68, 0x7d, 0x54, 0x99, 0xbf, 0x6f, 0xf3, 0xbe, 0xdf, 0x8e, 0xdd, 0x7f, 0xef, 0xeb, 0x97, 0x49, 0x3e, 0x3b, 0x7f, 0x06, 0x2c, 0x9f, 0x37, 0x5f, 0xf0, 0x9f, 0x4c, 0xeb, 0x7b, 0xbf, 0x67, 0x55, 0xe8, 0xff, 0x00, 0x31, 0xbc, 0x7a, 0x9e, 0x31, 0xdb, 0xfe, 0x92, 0xae, 0x37, 0x7a, 0x4d, 0xdb, 0xe2, 0x17, 0x9d, 0xa4, 0xa3, 0xc9, 0xba, 0xfc, 0x7b, 0x7d, 0x5f, 0x52, 0xa7, 0x7e, 0xd1, 0x28, 0xf8, 0xf3, 0xb0, 0xc7, 0x32, 0xbc, 0x99, 0x24, 0xc5, 0xe3, 0xab, 0xeb, 0x1f, 0xa4, 0xf5, 0xfc, 0xe1, 0x25, 0xe4, 0xe9, 0x24, 0x97, 0xff, 0xd9, 0xff, 0xed, 0x2e, 0x1c, 0x50, 0x68, 0x6f, 0x74, 0x6f, 0x73, 0x68, 0x6f, 0x70, 0x20, 0x33, 0x2e, 0x30, 0x00, 0x38, 0x42, 0x49, 0x4d, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2b, 0x1c, 0x02, 0x00, 0x00, 0x02, 0x00, 0x02, 0x1c, 0x02, 0x78, 0x00, 0x1f, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x38, 0x42, 0x49, 0x4d, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xfb, 0x09, 0xa6, 0xbd, 0x07, 0x4c, 0x2a, 0x36, 0x9d, 0x8f, 0xe2, 0xcc, 0x57, 0xa9, 0xac, 0x85, 0x38, 0x42, 0x49, 0x4d, 0x03, 0xea, 0x00, 0x00, 0x00, 0x00, 0x1d, 0xb0, 0x3c, 0x3f, 0x78, 0x6d, 0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x31, 0x2e, 0x30, 0x22, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x3d, 0x22, 0x55, 0x54, 0x46, 0x2d, 0x38, 0x22, 0x3f, 0x3e, 0x0a, 0x3c, 0x21, 0x44, 0x4f, 0x43, 0x54, 0x59, 0x50, 0x45, 0x20, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x50, 0x55, 0x42, 0x4c, 0x49, 0x43, 0x20, 0x22, 0x2d, 0x2f, 0x2f, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x72, 0x2f, 0x2f, 0x44, 0x54, 0x44, 0x20, 0x50, 0x4c, 0x49, 0x53, 0x54, 0x20, 0x31, 0x2e, 0x30, 0x2f, 0x2f, 0x45, 0x4e, 0x22, 0x20, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x44, 0x54, 0x44, 0x73, 0x2f, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4c, 0x69, 0x73, 0x74, 0x2d, 0x31, 0x2e, 0x30, 0x2e, 0x64, 0x74, 0x64, 0x22, 0x3e, 0x0a, 0x3c, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x31, 0x2e, 0x30, 0x22, 0x3e, 0x0a, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2e, 0x50, 0x4d, 0x48, 0x6f, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x74, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x69, 0x74, 0x65, 0x6d, 0x41, 0x72, 0x72, 0x61, 0x79, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2e, 0x50, 0x4d, 0x48, 0x6f, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x74, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x37, 0x32, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x6d, 0x6f, 0x64, 0x44, 0x61, 0x74, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x32, 0x30, 0x30, 0x37, 0x2d, 0x30, 0x31, 0x2d, 0x33, 0x30, 0x54, 0x32, 0x32, 0x3a, 0x30, 0x38, 0x3a, 0x34, 0x31, 0x5a, 0x3c, 0x2f, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x30, 0x3c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x2f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2e, 0x50, 0x4d, 0x4f, 0x72, 0x69, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x69, 0x74, 0x65, 0x6d, 0x41, 0x72, 0x72, 0x61, 0x79, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2e, 0x50, 0x4d, 0x4f, 0x72, 0x69, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x31, 0x3c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x6d, 0x6f, 0x64, 0x44, 0x61, 0x74, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x32, 0x30, 0x30, 0x37, 0x2d, 0x30, 0x31, 0x2d, 0x33, 0x30, 0x54, 0x32, 0x32, 0x3a, 0x30, 0x38, 0x3a, 0x34, 0x31, 0x5a, 0x3c, 0x2f, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x30, 0x3c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x2f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2e, 0x50, 0x4d, 0x53, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x69, 0x74, 0x65, 0x6d, 0x41, 0x72, 0x72, 0x61, 0x79, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2e, 0x50, 0x4d, 0x53, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x31, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x6d, 0x6f, 0x64, 0x44, 0x61, 0x74, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x32, 0x30, 0x30, 0x37, 0x2d, 0x30, 0x31, 0x2d, 0x33, 0x30, 0x54, 0x32, 0x32, 0x3a, 0x30, 0x38, 0x3a, 0x34, 0x31, 0x5a, 0x3c, 0x2f, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x30, 0x3c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x2f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2e, 0x50, 0x4d, 0x56, 0x65, 0x72, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x69, 0x74, 0x65, 0x6d, 0x41, 0x72, 0x72, 0x61, 0x79, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2e, 0x50, 0x4d, 0x56, 0x65, 0x72, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x37, 0x32, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x6d, 0x6f, 0x64, 0x44, 0x61, 0x74, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x32, 0x30, 0x30, 0x37, 0x2d, 0x30, 0x31, 0x2d, 0x33, 0x30, 0x54, 0x32, 0x32, 0x3a, 0x30, 0x38, 0x3a, 0x34, 0x31, 0x5a, 0x3c, 0x2f, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x30, 0x3c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x2f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2e, 0x50, 0x4d, 0x56, 0x65, 0x72, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x53, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x69, 0x74, 0x65, 0x6d, 0x41, 0x72, 0x72, 0x61, 0x79, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2e, 0x50, 0x4d, 0x56, 0x65, 0x72, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x53, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x31, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x6d, 0x6f, 0x64, 0x44, 0x61, 0x74, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x32, 0x30, 0x30, 0x37, 0x2d, 0x30, 0x31, 0x2d, 0x33, 0x30, 0x54, 0x32, 0x32, 0x3a, 0x30, 0x38, 0x3a, 0x34, 0x31, 0x5a, 0x3c, 0x2f, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x30, 0x3c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x2f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x70, 0x61, 0x70, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2e, 0x50, 0x4d, 0x41, 0x64, 0x6a, 0x75, 0x73, 0x74, 0x65, 0x64, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x63, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x69, 0x74, 0x65, 0x6d, 0x41, 0x72, 0x72, 0x61, 0x79, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2e, 0x50, 0x4d, 0x41, 0x64, 0x6a, 0x75, 0x73, 0x74, 0x65, 0x64, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x63, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x30, 0x2e, 0x30, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x30, 0x2e, 0x30, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x37, 0x33, 0x34, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x35, 0x37, 0x36, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x6d, 0x6f, 0x64, 0x44, 0x61, 0x74, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x32, 0x30, 0x30, 0x37, 0x2d, 0x30, 0x31, 0x2d, 0x33, 0x30, 0x54, 0x32, 0x32, 0x3a, 0x30, 0x38, 0x3a, 0x34, 0x31, 0x5a, 0x3c, 0x2f, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x30, 0x3c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2e, 0x50, 0x4d, 0x41, 0x64, 0x6a, 0x75, 0x73, 0x74, 0x65, 0x64, 0x50, 0x61, 0x70, 0x65, 0x72, 0x52, 0x65, 0x63, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x69, 0x74, 0x65, 0x6d, 0x41, 0x72, 0x72, 0x61, 0x79, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2e, 0x50, 0x4d, 0x41, 0x64, 0x6a, 0x75, 0x73, 0x74, 0x65, 0x64, 0x50, 0x61, 0x70, 0x65, 0x72, 0x52, 0x65, 0x63, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x2d, 0x31, 0x38, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x2d, 0x31, 0x38, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x37, 0x37, 0x34, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x35, 0x39, 0x34, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x6d, 0x6f, 0x64, 0x44, 0x61, 0x74, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x32, 0x30, 0x30, 0x37, 0x2d, 0x30, 0x31, 0x2d, 0x33, 0x30, 0x54, 0x32, 0x32, 0x3a, 0x30, 0x38, 0x3a, 0x34, 0x31, 0x5a, 0x3c, 0x2f, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x30, 0x3c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x70, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x50, 0x4d, 0x50, 0x61, 0x70, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x70, 0x6d, 0x2e, 0x50, 0x6f, 0x73, 0x74, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x69, 0x74, 0x65, 0x6d, 0x41, 0x72, 0x72, 0x61, 0x79, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x70, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x50, 0x4d, 0x50, 0x61, 0x70, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x6e, 0x61, 0x2d, 0x6c, 0x65, 0x74, 0x74, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x70, 0x6d, 0x2e, 0x50, 0x6f, 0x73, 0x74, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x6d, 0x6f, 0x64, 0x44, 0x61, 0x74, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x32, 0x30, 0x30, 0x33, 0x2d, 0x30, 0x37, 0x2d, 0x30, 0x31, 0x54, 0x31, 0x37, 0x3a, 0x34, 0x39, 0x3a, 0x33, 0x36, 0x5a, 0x3c, 0x2f, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x31, 0x3c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x70, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x50, 0x4d, 0x55, 0x6e, 0x61, 0x64, 0x6a, 0x75, 0x73, 0x74, 0x65, 0x64, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x63, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x70, 0x6d, 0x2e, 0x50, 0x6f, 0x73, 0x74, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x69, 0x74, 0x65, 0x6d, 0x41, 0x72, 0x72, 0x61, 0x79, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x70, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x50, 0x4d, 0x55, 0x6e, 0x61, 0x64, 0x6a, 0x75, 0x73, 0x74, 0x65, 0x64, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x63, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x30, 0x2e, 0x30, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x30, 0x2e, 0x30, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x37, 0x33, 0x34, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x35, 0x37, 0x36, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x6d, 0x6f, 0x64, 0x44, 0x61, 0x74, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x32, 0x30, 0x30, 0x37, 0x2d, 0x30, 0x31, 0x2d, 0x33, 0x30, 0x54, 0x32, 0x32, 0x3a, 0x30, 0x38, 0x3a, 0x34, 0x31, 0x5a, 0x3c, 0x2f, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x30, 0x3c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x70, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x50, 0x4d, 0x55, 0x6e, 0x61, 0x64, 0x6a, 0x75, 0x73, 0x74, 0x65, 0x64, 0x50, 0x61, 0x70, 0x65, 0x72, 0x52, 0x65, 0x63, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x70, 0x6d, 0x2e, 0x50, 0x6f, 0x73, 0x74, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x69, 0x74, 0x65, 0x6d, 0x41, 0x72, 0x72, 0x61, 0x79, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x70, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x50, 0x4d, 0x55, 0x6e, 0x61, 0x64, 0x6a, 0x75, 0x73, 0x74, 0x65, 0x64, 0x50, 0x61, 0x70, 0x65, 0x72, 0x52, 0x65, 0x63, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x2d, 0x31, 0x38, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x2d, 0x31, 0x38, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x37, 0x37, 0x34, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x35, 0x39, 0x34, 0x3c, 0x2f, 0x72, 0x65, 0x61, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x6d, 0x6f, 0x64, 0x44, 0x61, 0x74, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x32, 0x30, 0x30, 0x37, 0x2d, 0x30, 0x31, 0x2d, 0x33, 0x30, 0x54, 0x32, 0x32, 0x3a, 0x30, 0x38, 0x3a, 0x34, 0x31, 0x5a, 0x3c, 0x2f, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x30, 0x3c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x70, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x70, 0x70, 0x64, 0x2e, 0x50, 0x4d, 0x50, 0x61, 0x70, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x70, 0x6d, 0x2e, 0x50, 0x6f, 0x73, 0x74, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x69, 0x74, 0x65, 0x6d, 0x41, 0x72, 0x72, 0x61, 0x79, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x70, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x70, 0x70, 0x64, 0x2e, 0x50, 0x4d, 0x50, 0x61, 0x70, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x55, 0x53, 0x20, 0x4c, 0x65, 0x74, 0x74, 0x65, 0x72, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x70, 0x6d, 0x2e, 0x50, 0x6f, 0x73, 0x74, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x6d, 0x6f, 0x64, 0x44, 0x61, 0x74, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x32, 0x30, 0x30, 0x33, 0x2d, 0x30, 0x37, 0x2d, 0x30, 0x31, 0x54, 0x31, 0x37, 0x3a, 0x34, 0x39, 0x3a, 0x33, 0x36, 0x5a, 0x3c, 0x2f, 0x64, 0x61, 0x74, 0x65, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x31, 0x3c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x41, 0x50, 0x49, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x30, 0x30, 0x2e, 0x32, 0x30, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2f, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x70, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x41, 0x50, 0x49, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x30, 0x30, 0x2e, 0x32, 0x30, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x3c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2f, 0x3e, 0x0a, 0x09, 0x3c, 0x6b, 0x65, 0x79, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x3c, 0x2f, 0x6b, 0x65, 0x79, 0x3e, 0x0a, 0x09, 0x3c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x0a, 0x3c, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x3e, 0x0a, 0x3c, 0x2f, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x3e, 0x0a, 0x38, 0x42, 0x49, 0x4d, 0x03, 0xe9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x03, 0x00, 0x00, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x02, 0xde, 0x02, 0x40, 0xff, 0xee, 0xff, 0xee, 0x03, 0x06, 0x02, 0x52, 0x03, 0x67, 0x05, 0x28, 0x03, 0xfc, 0x00, 0x02, 0x00, 0x00, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x02, 0xd8, 0x02, 0x28, 0x00, 0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x01, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x01, 0x7f, 0xff, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x08, 0x00, 0x19, 0x01, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x42, 0x49, 0x4d, 0x03, 0xed, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x48, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x48, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x38, 0x42, 0x49, 0x4d, 0x04, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x80, 0x00, 0x00, 0x38, 0x42, 0x49, 0x4d, 0x04, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1e, 0x38, 0x42, 0x49, 0x4d, 0x04, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1e, 0x38, 0x42, 0x49, 0x4d, 0x03, 0xf3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x38, 0x42, 0x49, 0x4d, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x38, 0x42, 0x49, 0x4d, 0x27, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x38, 0x42, 0x49, 0x4d, 0x03, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x2f, 0x66, 0x66, 0x00, 0x01, 0x00, 0x6c, 0x66, 0x66, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x2f, 0x66, 0x66, 0x00, 0x01, 0x00, 0xa1, 0x99, 0x9a, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x32, 0x00, 0x00, 0x00, 0x01, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x35, 0x00, 0x00, 0x00, 0x01, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x38, 0x42, 0x49, 0x4d, 0x03, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xe8, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xe8, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xe8, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xe8, 0x00, 0x00, 0x38, 0x42, 0x49, 0x4d, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x38, 0x42, 0x49, 0x4d, 0x04, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x38, 0x42, 0x49, 0x4d, 0x04, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x03, 0x45, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x08, 0x00, 0x44, 0x00, 0x53, 0x00, 0x43, 0x00, 0x30, 0x00, 0x32, 0x00, 0x33, 0x00, 0x32, 0x00, 0x35, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6e, 0x75, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x4f, 0x62, 0x6a, 0x63, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0x63, 0x74, 0x31, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x54, 0x6f, 0x70, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x65, 0x66, 0x74, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x74, 0x6f, 0x6d, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x52, 0x67, 0x68, 0x74, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x06, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x73, 0x56, 0x6c, 0x4c, 0x73, 0x00, 0x00, 0x00, 0x01, 0x4f, 0x62, 0x6a, 0x63, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x49, 0x44, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x44, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x65, 0x6e, 0x75, 0x6d, 0x00, 0x00, 0x00, 0x0c, 0x45, 0x53, 0x6c, 0x69, 0x63, 0x65, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x0d, 0x61, 0x75, 0x74, 0x6f, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x00, 0x00, 0x00, 0x00, 0x54, 0x79, 0x70, 0x65, 0x65, 0x6e, 0x75, 0x6d, 0x00, 0x00, 0x00, 0x0a, 0x45, 0x53, 0x6c, 0x69, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x00, 0x00, 0x00, 0x00, 0x49, 0x6d, 0x67, 0x20, 0x00, 0x00, 0x00, 0x06, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x4f, 0x62, 0x6a, 0x63, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0x63, 0x74, 0x31, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x54, 0x6f, 0x70, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x65, 0x66, 0x74, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x74, 0x6f, 0x6d, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x52, 0x67, 0x68, 0x74, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x03, 0x75, 0x72, 0x6c, 0x54, 0x45, 0x58, 0x54, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6e, 0x75, 0x6c, 0x6c, 0x54, 0x45, 0x58, 0x54, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4d, 0x73, 0x67, 0x65, 0x54, 0x45, 0x58, 0x54, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x61, 0x6c, 0x74, 0x54, 0x61, 0x67, 0x54, 0x45, 0x58, 0x54, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x63, 0x65, 0x6c, 0x6c, 0x54, 0x65, 0x78, 0x74, 0x49, 0x73, 0x48, 0x54, 0x4d, 0x4c, 0x62, 0x6f, 0x6f, 0x6c, 0x01, 0x00, 0x00, 0x00, 0x08, 0x63, 0x65, 0x6c, 0x6c, 0x54, 0x65, 0x78, 0x74, 0x54, 0x45, 0x58, 0x54, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x68, 0x6f, 0x72, 0x7a, 0x41, 0x6c, 0x69, 0x67, 0x6e, 0x65, 0x6e, 0x75, 0x6d, 0x00, 0x00, 0x00, 0x0f, 0x45, 0x53, 0x6c, 0x69, 0x63, 0x65, 0x48, 0x6f, 0x72, 0x7a, 0x41, 0x6c, 0x69, 0x67, 0x6e, 0x00, 0x00, 0x00, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x00, 0x00, 0x00, 0x09, 0x76, 0x65, 0x72, 0x74, 0x41, 0x6c, 0x69, 0x67, 0x6e, 0x65, 0x6e, 0x75, 0x6d, 0x00, 0x00, 0x00, 0x0f, 0x45, 0x53, 0x6c, 0x69, 0x63, 0x65, 0x56, 0x65, 0x72, 0x74, 0x41, 0x6c, 0x69, 0x67, 0x6e, 0x00, 0x00, 0x00, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x00, 0x00, 0x00, 0x0b, 0x62, 0x67, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x65, 0x6e, 0x75, 0x6d, 0x00, 0x00, 0x00, 0x11, 0x45, 0x53, 0x6c, 0x69, 0x63, 0x65, 0x42, 0x47, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x00, 0x00, 0x00, 0x00, 0x4e, 0x6f, 0x6e, 0x65, 0x00, 0x00, 0x00, 0x09, 0x74, 0x6f, 0x70, 0x4f, 0x75, 0x74, 0x73, 0x65, 0x74, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x6c, 0x65, 0x66, 0x74, 0x4f, 0x75, 0x74, 0x73, 0x65, 0x74, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x4f, 0x75, 0x74, 0x73, 0x65, 0x74, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x4f, 0x75, 0x74, 0x73, 0x65, 0x74, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x42, 0x49, 0x4d, 0x04, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x38, 0x42, 0x49, 0x4d, 0x04, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x38, 0x42, 0x49, 0x4d, 0x04, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x09, 0xf9, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x01, 0x2c, 0x00, 0x00, 0x75, 0x30, 0x00, 0x00, 0x09, 0xdd, 0x00, 0x18, 0x00, 0x01, 0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01, 0x02, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xff, 0xed, 0x00, 0x0c, 0x41, 0x64, 0x6f, 0x62, 0x65, 0x5f, 0x43, 0x4d, 0x00, 0x02, 0xff, 0xee, 0x00, 0x0e, 0x41, 0x64, 0x6f, 0x62, 0x65, 0x00, 0x64, 0x80, 0x00, 0x00, 0x00, 0x01, 0xff, 0xdb, 0x00, 0x84, 0x00, 0x0c, 0x08, 0x08, 0x08, 0x09, 0x08, 0x0c, 0x09, 0x09, 0x0c, 0x11, 0x0b, 0x0a, 0x0b, 0x11, 0x15, 0x0f, 0x0c, 0x0c, 0x0f, 0x15, 0x18, 0x13, 0x13, 0x15, 0x13, 0x13, 0x18, 0x11, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x11, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x01, 0x0d, 0x0b, 0x0b, 0x0d, 0x0e, 0x0d, 0x10, 0x0e, 0x0e, 0x10, 0x14, 0x0e, 0x0e, 0x0e, 0x14, 0x14, 0x0e, 0x0e, 0x0e, 0x0e, 0x14, 0x11, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x11, 0x11, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x11, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xff, 0xc0, 0x00, 0x11, 0x08, 0x00, 0x64, 0x00, 0x64, 0x03, 0x01, 0x22, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xdd, 0x00, 0x04, 0x00, 0x07, 0xff, 0xc4, 0x01, 0x3f, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x01, 0x02, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x01, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x10, 0x00, 0x01, 0x04, 0x01, 0x03, 0x02, 0x04, 0x02, 0x05, 0x07, 0x06, 0x08, 0x05, 0x03, 0x0c, 0x33, 0x01, 0x00, 0x02, 0x11, 0x03, 0x04, 0x21, 0x12, 0x31, 0x05, 0x41, 0x51, 0x61, 0x13, 0x22, 0x71, 0x81, 0x32, 0x06, 0x14, 0x91, 0xa1, 0xb1, 0x42, 0x23, 0x24, 0x15, 0x52, 0xc1, 0x62, 0x33, 0x34, 0x72, 0x82, 0xd1, 0x43, 0x07, 0x25, 0x92, 0x53, 0xf0, 0xe1, 0xf1, 0x63, 0x73, 0x35, 0x16, 0xa2, 0xb2, 0x83, 0x26, 0x44, 0x93, 0x54, 0x64, 0x45, 0xc2, 0xa3, 0x74, 0x36, 0x17, 0xd2, 0x55, 0xe2, 0x65, 0xf2, 0xb3, 0x84, 0xc3, 0xd3, 0x75, 0xe3, 0xf3, 0x46, 0x27, 0x94, 0xa4, 0x85, 0xb4, 0x95, 0xc4, 0xd4, 0xe4, 0xf4, 0xa5, 0xb5, 0xc5, 0xd5, 0xe5, 0xf5, 0x56, 0x66, 0x76, 0x86, 0x96, 0xa6, 0xb6, 0xc6, 0xd6, 0xe6, 0xf6, 0x37, 0x47, 0x57, 0x67, 0x77, 0x87, 0x97, 0xa7, 0xb7, 0xc7, 0xd7, 0xe7, 0xf7, 0x11, 0x00, 0x02, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x05, 0x06, 0x07, 0x07, 0x06, 0x05, 0x35, 0x01, 0x00, 0x02, 0x11, 0x03, 0x21, 0x31, 0x12, 0x04, 0x41, 0x51, 0x61, 0x71, 0x22, 0x13, 0x05, 0x32, 0x81, 0x91, 0x14, 0xa1, 0xb1, 0x42, 0x23, 0xc1, 0x52, 0xd1, 0xf0, 0x33, 0x24, 0x62, 0xe1, 0x72, 0x82, 0x92, 0x43, 0x53, 0x15, 0x63, 0x73, 0x34, 0xf1, 0x25, 0x06, 0x16, 0xa2, 0xb2, 0x83, 0x07, 0x26, 0x35, 0xc2, 0xd2, 0x44, 0x93, 0x54, 0xa3, 0x17, 0x64, 0x45, 0x55, 0x36, 0x74, 0x65, 0xe2, 0xf2, 0xb3, 0x84, 0xc3, 0xd3, 0x75, 0xe3, 0xf3, 0x46, 0x94, 0xa4, 0x85, 0xb4, 0x95, 0xc4, 0xd4, 0xe4, 0xf4, 0xa5, 0xb5, 0xc5, 0xd5, 0xe5, 0xf5, 0x56, 0x66, 0x76, 0x86, 0x96, 0xa6, 0xb6, 0xc6, 0xd6, 0xe6, 0xf6, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77, 0x87, 0x97, 0xa7, 0xb7, 0xc7, 0xff, 0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f, 0x00, 0xf2, 0xed, 0xb2, 0x8d, 0x4d, 0x45, 0xcd, 0x2f, 0x3f, 0x44, 0x68, 0x93, 0xc3, 0x58, 0xc8, 0xf1, 0x1f, 0x8a, 0x33, 0x86, 0xda, 0x58, 0xc1, 0xa0, 0x02, 0x4f, 0xc4, 0xa1, 0x69, 0xa5, 0x9b, 0x5b, 0x4b, 0x84, 0x73, 0xdf, 0xc9, 0x15, 0xf8, 0xe3, 0xd1, 0x0e, 0x07, 0x93, 0xf3, 0xd1, 0x0f, 0x1c, 0x17, 0xef, 0x2e, 0x3b, 0x5b, 0xdc, 0xff, 0x00, 0xdf, 0x42, 0xbf, 0x8f, 0x8e, 0xdc, 0x82, 0xca, 0xd8, 0x37, 0x11, 0xa9, 0x3d, 0x82, 0x69, 0x2b, 0xc4, 0x6d, 0xc9, 0x75, 0x25, 0xbc, 0xf7, 0xec, 0xa1, 0xb5, 0x74, 0x19, 0x5d, 0x2e, 0x8a, 0x9a, 0x4b, 0x89, 0x7d, 0xc4, 0x68, 0xc6, 0xf6, 0xfe, 0xb2, 0xa0, 0x30, 0x1d, 0x60, 0x86, 0x88, 0x8d, 0x49, 0x3e, 0x01, 0x11, 0x20, 0xa3, 0x8c, 0xb9, 0xb1, 0xaa, 0x62, 0xad, 0xbf, 0x18, 0x97, 0x43, 0x47, 0x1d, 0xd2, 0xaf, 0x04, 0xd9, 0xb8, 0xc8, 0x0d, 0x68, 0xe4, 0xf7, 0x3e, 0x48, 0xf1, 0x05, 0xbc, 0x25, 0xaa, 0x07, 0x71, 0xd9, 0x14, 0x78, 0xf6, 0x49, 0xb5, 0x90, 0xfd, 0xa7, 0xc6, 0x14, 0xfd, 0x1b, 0x1c, 0xff, 0x00, 0x4d, 0x8d, 0x2e, 0x73, 0x8c, 0x35, 0xa3, 0x52, 0x4f, 0x92, 0x48, 0xa6, 0x1a, 0x24, 0xb6, 0x2a, 0xfa, 0xa5, 0x9e, 0x60, 0x64, 0x39, 0x94, 0x13, 0xcb, 0x27, 0x73, 0x80, 0xf3, 0x0c, 0xf6, 0xff, 0x00, 0xd2, 0x5a, 0x78, 0xbf, 0x53, 0x71, 0xf6, 0x01, 0x75, 0xb6, 0x97, 0x6a, 0x25, 0xa1, 0xad, 0x1f, 0xf4, 0xb7, 0x23, 0x48, 0xb7, 0x94, 0x84, 0x97, 0x5b, 0xff, 0x00, 0x32, 0xa9, 0xdd, 0xfc, 0xed, 0x9b, 0x7e, 0x0d, 0x9e, 0x52, 0x4a, 0x95, 0x61, 0xff, 0xd0, 0xf3, 0x3b, 0xa7, 0x70, 0xee, 0x01, 0x8f, 0xb9, 0x59, 0xfa, 0x7e, 0xdf, 0xe4, 0xc8, 0xf9, 0x2a, 0xc2, 0x5c, 0x63, 0xc3, 0x54, 0x67, 0x87, 0x6e, 0x10, 0x35, 0x68, 0xd4, 0x79, 0x1e, 0x53, 0x4a, 0xe0, 0xdc, 0xe9, 0xb8, 0x1f, 0x6a, 0xda, 0x6c, 0x25, 0x94, 0x37, 0xb0, 0xd0, 0xb8, 0xad, 0x67, 0xe4, 0x55, 0x8a, 0x5b, 0x8b, 0x82, 0xc0, 0x6f, 0x76, 0x80, 0x34, 0x49, 0x05, 0x2e, 0x9e, 0xc6, 0x1c, 0x66, 0x31, 0xba, 0x10, 0x23, 0xe0, 0xaf, 0xe1, 0x61, 0x53, 0x43, 0x8d, 0x81, 0xb3, 0x67, 0xef, 0x9e, 0x49, 0x2a, 0x12, 0x6c, 0xb6, 0x63, 0x1a, 0x0c, 0x31, 0xba, 0x55, 0xcd, 0xac, 0xfa, 0x8e, 0xdf, 0x91, 0x6e, 0x91, 0xd9, 0xb3, 0xc9, 0x73, 0x90, 0x7a, 0xab, 0x6a, 0xc2, 0xa4, 0x60, 0xe2, 0x8f, 0xd2, 0x38, 0x03, 0x7d, 0x9e, 0x0d, 0xff, 0x00, 0xcc, 0xd6, 0xd3, 0x6b, 0x71, 0x67, 0xd2, 0x3e, 0x64, 0x72, 0xab, 0xdb, 0x8d, 0x54, 0x39, 0xc5, 0x83, 0x6b, 0x3d, 0xee, 0x2e, 0xd4, 0x92, 0x3c, 0x4a, 0x56, 0xba, 0xb4, 0x79, 0x5c, 0xf7, 0xb2, 0x96, 0x6c, 0x8d, 0xaf, 0x80, 0x48, 0x3c, 0xf0, 0xb2, 0x1f, 0x63, 0x9c, 0xe9, 0x3f, 0x24, 0x5c, 0xdb, 0xdd, 0x76, 0x43, 0xde, 0xfd, 0x5c, 0xe3, 0x24, 0xfc, 0x50, 0x00, 0x93, 0x0a, 0x78, 0x8a, 0x0d, 0x49, 0xca, 0xcf, 0x93, 0x63, 0x1b, 0x7d, 0xd7, 0x57, 0x50, 0xd5, 0xef, 0x70, 0x6b, 0x4f, 0xc7, 0x45, 0xdb, 0x74, 0x9e, 0x8d, 0x5e, 0x33, 0x83, 0xd8, 0x37, 0xdd, 0xc3, 0xac, 0x3d, 0xbf, 0x92, 0xc5, 0x5b, 0xea, 0xbf, 0xd5, 0x62, 0xc0, 0xdc, 0xbc, 0xbd, 0x2d, 0x22, 0x5a, 0xcf, 0xdd, 0x69, 0xff, 0x00, 0xd1, 0x8e, 0x5d, 0xa5, 0x38, 0xb5, 0xb0, 0x00, 0xc6, 0xc4, 0x24, 0x4a, 0xd6, 0x8d, 0x18, 0x04, 0x49, 0x88, 0x9e, 0x55, 0xd6, 0x61, 0xb0, 0xc1, 0x70, 0x32, 0xdd, 0x3c, 0x95, 0xda, 0xf1, 0xfe, 0xf5, 0x62, 0xbc, 0x76, 0x8e, 0x75, 0x28, 0x02, 0xa2, 0xe7, 0x7d, 0x92, 0xb9, 0x84, 0x96, 0x96, 0xda, 0xf7, 0x70, 0x12, 0x4e, 0x5a, 0xff, 0x00, 0xff, 0xd1, 0xf3, 0x7a, 0x21, 0xaf, 0xde, 0xef, 0xa2, 0x22, 0x55, 0xfc, 0x5a, 0xbd, 0x42, 0xfb, 0x08, 0xfa, 0x67, 0x4f, 0x82, 0xcd, 0x6d, 0x85, 0xc0, 0x56, 0x3b, 0x90, 0xb7, 0xf0, 0x2a, 0x0e, 0x63, 0x58, 0x3b, 0xf2, 0xa3, 0x9e, 0x8c, 0xb8, 0x86, 0xbe, 0x49, 0xf1, 0x2c, 0x0c, 0x86, 0xb4, 0x4c, 0x69, 0xe4, 0xaf, 0x6e, 0xcc, 0x6b, 0x7d, 0x46, 0xb3, 0x70, 0xec, 0x38, 0x51, 0x7d, 0x02, 0x8a, 0xc7, 0xa6, 0xd9, 0x20, 0x68, 0x0f, 0x8f, 0x8a, 0xcf, 0xc9, 0xc2, 0xea, 0x59, 0x5b, 0x48, 0xb0, 0x91, 0xae, 0xe6, 0xc9, 0x03, 0xc9, 0x30, 0x51, 0x66, 0xd4, 0x0d, 0xad, 0xbd, 0x5f, 0x53, 0xcc, 0x6b, 0xb6, 0x90, 0x5a, 0x3b, 0x83, 0x0b, 0x43, 0x17, 0x31, 0xd6, 0xc3, 0x6e, 0x12, 0x3b, 0x79, 0xac, 0xc1, 0x89, 0x47, 0xd9, 0xe8, 0x63, 0x98, 0x45, 0xed, 0x6c, 0x5a, 0xf1, 0xa0, 0x27, 0xc5, 0x5b, 0xc3, 0x6f, 0xa6, 0xe0, 0x1c, 0x7d, 0xb3, 0xa2, 0x69, 0x34, 0x7b, 0xae, 0x1a, 0x8d, 0x45, 0x17, 0x9d, 0xeb, 0xfd, 0x21, 0xd8, 0xb9, 0xae, 0xb5, 0x80, 0xbb, 0x1e, 0xd2, 0x5c, 0xd7, 0x78, 0x13, 0xf9, 0xae, 0x4b, 0xea, 0xc7, 0x4a, 0x39, 0xbd, 0x55, 0xb3, 0xed, 0x66, 0x38, 0xf5, 0x09, 0x22, 0x41, 0x23, 0xe8, 0x37, 0xfb, 0x4b, 0xa1, 0xeb, 0xd6, 0xfe, 0x88, 0x31, 0xbf, 0x41, 0xc0, 0xee, 0xd2, 0x74, 0x02, 0x78, 0x53, 0xfa, 0x97, 0x43, 0x19, 0x85, 0x65, 0xff, 0x00, 0x9d, 0x71, 0x33, 0xe4, 0x1a, 0x7d, 0x8d, 0x53, 0x42, 0x56, 0x35, 0x6b, 0xe5, 0x80, 0x06, 0xc7, 0x57, 0xa7, 0xc4, 0xa9, 0xdb, 0xb6, 0x81, 0x1f, 0xeb, 0xd9, 0x69, 0x56, 0xc2, 0xd0, 0x00, 0xe5, 0x55, 0xc0, 0x12, 0xc2, 0xd7, 0x4e, 0xa2, 0x5a, 0x7c, 0x0a, 0xd0, 0x63, 0x9a, 0xd1, 0xaf, 0xd2, 0xe2, 0x3c, 0x12, 0x62, 0x66, 0xc6, 0x42, 0x23, 0x5a, 0x49, 0x8f, 0x10, 0xa2, 0xd2, 0x3e, 0x28, 0x9d, 0xc4, 0x88, 0x09, 0x29, 0x16, 0xc3, 0x3c, 0x24, 0x8d, 0xe6, 0x92, 0x72, 0x1f, 0xff, 0xd2, 0xf3, 0xbb, 0xb0, 0xfe, 0xcb, 0x99, 0xe9, 0xce, 0xf6, 0x88, 0x2d, 0x77, 0x91, 0x5b, 0x3d, 0x3d, 0xd0, 0xe6, 0x90, 0xa9, 0x65, 0x57, 0x38, 0x95, 0xdd, 0xcb, 0x9a, 0x7d, 0xce, 0xf2, 0x3f, 0x44, 0x23, 0x60, 0x58, 0x76, 0xe9, 0xca, 0x8c, 0xea, 0x1b, 0x31, 0x02, 0x32, 0x23, 0xea, 0xee, 0xb1, 0xcd, 0xb0, 0xc7, 0x87, 0x74, 0x7a, 0xeb, 0x70, 0x1a, 0x71, 0xe1, 0xfe, 0xe4, 0x1c, 0x1d, 0xae, 0xe5, 0x69, 0xd8, 0xfa, 0x99, 0x50, 0x0d, 0x1a, 0xf7, 0x2a, 0x3a, 0x0c, 0xf4, 0x1a, 0x8e, 0xc7, 0x27, 0x5d, 0xbf, 0x18, 0x41, 0xdc, 0xc2, 0xf0, 0x7f, 0x74, 0xf6, 0x3a, 0x22, 0x66, 0xdb, 0x68, 0xc6, 0x80, 0x48, 0x6b, 0x88, 0x06, 0x39, 0x0d, 0xee, 0xaa, 0x1f, 0xb3, 0xd5, 0x1b, 0x83, 0xd8, 0x3b, 0x38, 0x8f, 0x69, 0xfe, 0xdf, 0xd1, 0x4d, 0x29, 0xa1, 0x4c, 0x7a, 0xf4, 0xbf, 0xa7, 0x92, 0xcf, 0xa5, 0x20, 0x08, 0xf3, 0xf6, 0xff, 0x00, 0x15, 0xbb, 0xd1, 0x31, 0xd9, 0x5e, 0x3d, 0x75, 0x56, 0x36, 0x88, 0x00, 0x81, 0xe0, 0x16, 0x5e, 0x55, 0x74, 0x3f, 0x00, 0x9d, 0xe0, 0xcc, 0x69, 0xe7, 0x3a, 0x2d, 0xbe, 0x90, 0x00, 0xa9, 0xae, 0xef, 0x1f, 0x95, 0x4b, 0x0d, 0x9a, 0xdc, 0xc7, 0x45, 0xfe, 0xb1, 0x7d, 0x60, 0xa7, 0xa1, 0xe0, 0x1f, 0x4e, 0x1d, 0x99, 0x69, 0x02, 0x9a, 0xcf, 0x1f, 0xca, 0x7b, 0xbf, 0x90, 0xc5, 0xc2, 0xb3, 0xeb, 0x57, 0xd6, 0x03, 0x6b, 0xae, 0x39, 0xb6, 0x82, 0xe3, 0x31, 0xa1, 0x68, 0xf2, 0x6b, 0x5c, 0x12, 0xfa, 0xe1, 0x91, 0x66, 0x47, 0x5d, 0xb8, 0x3b, 0x4f, 0x44, 0x36, 0xb6, 0x8f, 0x28, 0xdd, 0xff, 0x00, 0x7e, 0x46, 0xab, 0x12, 0x2b, 0x65, 0x55, 0x32, 0xa7, 0x62, 0xb6, 0xbd, 0xf7, 0x64, 0x10, 0xdb, 0x03, 0x9f, 0x1b, 0x9e, 0xc7, 0xd9, 0xb8, 0x3b, 0x1f, 0x67, 0xf3, 0x6c, 0x52, 0x80, 0xd7, 0x7d, 0x0f, 0xea, 0x7f, 0x5d, 0x1d, 0x67, 0xa6, 0x0b, 0x1e, 0x47, 0xda, 0x69, 0x3b, 0x2e, 0x03, 0xc7, 0xf3, 0x5f, 0x1f, 0xf0, 0x8b, 0xa1, 0x02, 0x46, 0xba, 0x79, 0xaf, 0x32, 0xff, 0x00, 0x16, 0xad, 0xca, 0x1d, 0x57, 0x2a, 0xdc, 0x79, 0x18, 0x41, 0xb0, 0xf6, 0x9e, 0xe4, 0x9f, 0xd0, 0x8f, 0xeb, 0x31, 0xab, 0xd2, 0x83, 0xa4, 0xcb, 0x8c, 0xb8, 0xa0, 0x42, 0x12, 0x7b, 0x67, 0x9f, 0x2f, 0xf5, 0x09, 0x26, 0x96, 0xc4, 0xce, 0xa9, 0x20, 0xa7, 0xff, 0xd3, 0xf3, 0x2f, 0xb4, 0x5d, 0xe9, 0x0a, 0xb7, 0x9f, 0x4c, 0x19, 0xdb, 0x3a, 0x2d, 0x5e, 0x94, 0xfd, 0xc4, 0xb7, 0xc5, 0x62, 0xf9, 0x2b, 0xfd, 0x2e, 0xe3, 0x5d, 0xe0, 0x7c, 0x13, 0x48, 0xd1, 0x92, 0x12, 0xa9, 0x0b, 0x7a, 0xbc, 0x2d, 0xc2, 0x7f, 0x92, 0x60, 0xab, 0x4e, 0x79, 0x2e, 0x00, 0xf0, 0xaa, 0xe1, 0xda, 0x3d, 0x43, 0xfc, 0xad, 0x55, 0xbb, 0x80, 0x79, 0x81, 0xa0, 0xe6, 0x54, 0x32, 0x6d, 0x02, 0xbe, 0xf3, 0x61, 0x81, 0xa8, 0x44, 0x14, 0x03, 0x59, 0x0e, 0x1c, 0xf6, 0x1f, 0xdc, 0xb2, 0xec, 0xa3, 0x23, 0x77, 0xe8, 0x6e, 0x70, 0xf2, 0x25, 0x1f, 0x1f, 0x17, 0xa9, 0x6d, 0x71, 0x36, 0x97, 0x47, 0x00, 0xa4, 0x02, 0xe0, 0x2c, 0x7c, 0xc1, 0xab, 0xd5, 0x31, 0x85, 0x35, 0xd4, 0xe6, 0x13, 0x02, 0xd6, 0x4b, 0x67, 0x48, 0x2b, 0xa9, 0xe9, 0x2e, 0x02, 0xb6, 0x4f, 0x82, 0xe5, 0x7a, 0x95, 0x19, 0xc6, 0x87, 0x3d, 0xfb, 0xa2, 0xb8, 0x79, 0x1e, 0x4d, 0x3b, 0x96, 0xcf, 0x4f, 0xbd, 0xcd, 0xa2, 0xa2, 0x1f, 0xa0, 0x82, 0xd3, 0xfc, 0x97, 0x05, 0x24, 0x36, 0x6b, 0xf3, 0x31, 0xa2, 0x35, 0x79, 0xef, 0xad, 0xf8, 0xae, 0xaf, 0xaf, 0xd8, 0xf2, 0xd8, 0x6d, 0xed, 0x6b, 0xda, 0x7b, 0x18, 0x1b, 0x5d, 0xff, 0x00, 0x52, 0xb1, 0x6d, 0xf0, 0x81, 0x31, 0xca, 0xf4, 0x6e, 0xb1, 0x80, 0xce, 0xb1, 0x84, 0xc0, 0x21, 0xb7, 0xd6, 0x77, 0x31, 0xd1, 0x27, 0xc1, 0xcd, 0xfe, 0xd2, 0xe3, 0xec, 0xe8, 0x1d, 0x45, 0x96, 0xb0, 0x9a, 0xb7, 0x87, 0x3f, 0x68, 0x2d, 0xf7, 0x01, 0x1f, 0xbe, 0xd1, 0xf4, 0x7f, 0xb4, 0xa4, 0x0d, 0x77, 0xbb, 0xfa, 0x8f, 0x80, 0x3a, 0x7f, 0x43, 0xaa, 0xe2, 0xdf, 0xd2, 0x65, 0x7e, 0x95, 0xe4, 0x0f, 0x1f, 0xa1, 0xfe, 0x6b, 0x16, 0x9f, 0x52, 0xfa, 0xc1, 0xd3, 0xba, 0x6d, 0x26, 0xdc, 0xac, 0x86, 0xd4, 0xd9, 0x0d, 0x31, 0x2e, 0x74, 0x9e, 0xdb, 0x59, 0x2e, 0x55, 0xe8, 0xc9, 0xb2, 0x96, 0xd5, 0x4b, 0x9f, 0xb8, 0x6d, 0xda, 0x1c, 0x04, 0x09, 0x03, 0xfe, 0x8a, 0xc6, 0xfa, 0xd3, 0xf5, 0x6a, 0xbe, 0xbb, 0x5b, 0x2e, 0xc6, 0xb5, 0x94, 0xe6, 0xd5, 0x20, 0x97, 0x7d, 0x1b, 0x1b, 0xf9, 0xad, 0x7c, 0x7d, 0x17, 0xb7, 0xf3, 0x1e, 0x92, 0x1b, 0x7f, 0xf8, 0xe0, 0x7d, 0x59, 0xdd, 0xfd, 0x32, 0xd8, 0x8f, 0xa5, 0xe8, 0x3a, 0x12, 0x5c, 0x3f, 0xfc, 0xc4, 0xfa, 0xc3, 0xb3, 0x77, 0xa7, 0x56, 0xed, 0xdb, 0x76, 0x7a, 0x8d, 0xdd, 0x1f, 0xbf, 0xfd, 0x44, 0x92, 0x56, 0x8f, 0xff, 0xd4, 0xf2, 0xe8, 0x86, 0x17, 0x1e, 0xfa, 0x04, 0x56, 0x4b, 0x43, 0x6c, 0x6f, 0x2d, 0xe5, 0x46, 0x01, 0x64, 0x2b, 0x14, 0x32, 0x5b, 0xb4, 0xa0, 0x52, 0x1d, 0xde, 0x9b, 0x94, 0xdb, 0xab, 0x6b, 0x81, 0xf7, 0x05, 0xb0, 0xd7, 0x07, 0xb2, 0x27, 0x55, 0xc6, 0x57, 0x65, 0xd8, 0x76, 0x6e, 0x64, 0xed, 0xee, 0x16, 0xce, 0x27, 0x57, 0x63, 0xda, 0x0c, 0xc2, 0x8e, 0x51, 0x67, 0x84, 0xfa, 0x1d, 0xdd, 0x62, 0xc7, 0x07, 0xe9, 0xf7, 0xa3, 0xd6, 0x6c, 0x02, 0x41, 0x55, 0x31, 0xf3, 0x2b, 0xb3, 0xba, 0x2b, 0x2e, 0x68, 0x24, 0x1d, 0x47, 0x64, 0xca, 0xa6, 0x50, 0x41, 0x65, 0x90, 0x6c, 0xb1, 0xa5, 0xae, 0x33, 0x23, 0x51, 0xe4, 0xab, 0x7d, 0x5d, 0xcb, 0xb6, 0xcc, 0x37, 0xd0, 0x40, 0x73, 0x71, 0xde, 0x58, 0x09, 0xe7, 0x6f, 0x2c, 0x44, 0xc9, 0xc9, 0xae, 0xba, 0x9d, 0x63, 0x88, 0x01, 0xa0, 0x95, 0x9d, 0xf5, 0x3f, 0x2a, 0xe6, 0x67, 0xdb, 0x50, 0x83, 0x55, 0xad, 0x36, 0x3e, 0x78, 0x10, 0x74, 0x77, 0xfd, 0x2d, 0xaa, 0x4c, 0x7d, 0x58, 0x73, 0x91, 0xa0, 0x0f, 0x51, 0x45, 0xb7, 0x33, 0xdd, 0x58, 0x69, 0x1d, 0xd8, 0x0c, 0x9f, 0x96, 0x88, 0x19, 0x99, 0x19, 0xac, 0xcf, 0xa3, 0xd2, 0xad, 0xb5, 0xdb, 0x76, 0x8f, 0xad, 0xc4, 0xea, 0xcf, 0xdf, 0x7e, 0xdf, 0xdd, 0xfc, 0xd5, 0xa3, 0x5e, 0x43, 0x2b, 0x6b, 0xb2, 0xad, 0x3b, 0x6a, 0xa4, 0x13, 0xa7, 0x04, 0xac, 0x7a, 0x6f, 0xb3, 0x23, 0x26, 0xcc, 0xfb, 0xb4, 0x75, 0x8e, 0x01, 0x83, 0xf7, 0x58, 0x3e, 0x8b, 0x53, 0xa7, 0x2a, 0x1a, 0x31, 0x42, 0x36, 0x5d, 0x4c, 0x9a, 0xf2, 0xdc, 0xc6, 0xfe, 0x98, 0xb4, 0x34, 0xcb, 0x48, 0x0a, 0x8f, 0xdb, 0xb2, 0xeb, 0x76, 0xd6, 0x07, 0x5c, 0x59, 0xc9, 0x64, 0x8f, 0x93, 0xa7, 0x73, 0x16, 0x83, 0xaf, 0x0e, 0xa4, 0x33, 0xef, 0x50, 0xc5, 0x0c, 0xda, 0x59, 0x10, 0x06, 0x8a, 0x2e, 0x29, 0x0e, 0xac, 0xc2, 0x31, 0x3d, 0x36, 0x69, 0x7e, 0xd6, 0xcc, 0xf5, 0x3d, 0x6f, 0xb3, 0xeb, 0x1b, 0x76, 0xef, 0x3b, 0xa3, 0xfa, 0xc9, 0x2b, 0x5f, 0x66, 0x6f, 0xa9, 0x1e, 0x73, 0xf2, 0x49, 0x2e, 0x39, 0xf7, 0x4f, 0xb7, 0x8d, 0xff, 0xd5, 0xf3, 0x26, 0xfe, 0x0a, 0xc5, 0x1b, 0xa7, 0xcb, 0xb2, 0xcf, 0x49, 0x03, 0xb2, 0x46, 0xee, 0xd9, 0xd9, 0xb3, 0xf4, 0x9f, 0x25, 0x4a, 0xdf, 0x4b, 0x77, 0xe8, 0x27, 0xd4, 0xef, 0x1c, 0x2a, 0x29, 0x26, 0xc5, 0x7c, 0x9d, 0x6c, 0x7f, 0xb7, 0x6e, 0x1b, 0x26, 0x7f, 0x05, 0xa3, 0xfe, 0x53, 0x8d, 0x62, 0x57, 0x30, 0x92, 0x12, 0xfa, 0x2f, 0x86, 0xdf, 0xa4, 0xec, 0x67, 0xfe, 0xd0, 0xf4, 0xff, 0x00, 0x4d, 0xfc, 0xdf, 0x78, 0xe1, 0x68, 0x7d, 0x54, 0x99, 0xbf, 0x6f, 0xf3, 0xbe, 0xdf, 0x8e, 0xdd, 0x7f, 0xef, 0xeb, 0x97, 0x49, 0x3e, 0x3b, 0x7f, 0x06, 0x2c, 0x9f, 0x37, 0x5f, 0xf0, 0x9f, 0x4c, 0xeb, 0x7b, 0xbf, 0x67, 0x55, 0xe8, 0xff, 0x00, 0x31, 0xbc, 0x7a, 0x9e, 0x31, 0xdb, 0xfe, 0x92, 0xae, 0x37, 0x7a, 0x4d, 0xdb, 0xe2, 0x17, 0x9d, 0xa4, 0xa3, 0xc9, 0xba, 0xfc, 0x7b, 0x7d, 0x5f, 0x52, 0xa7, 0x7e, 0xd1, 0x28, 0xf8, 0xf3, 0xb0, 0xc7, 0x32, 0xbc, 0x99, 0x24, 0xc5, 0xe3, 0xab, 0xeb, 0x1f, 0xa4, 0xf5, 0xfc, 0xe1, 0x25, 0xe4, 0xe9, 0x24, 0x97, 0xff, 0xd9, 0x00, 0x38, 0x42, 0x49, 0x4d, 0x04, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x41, 0x00, 0x64, 0x00, 0x6f, 0x00, 0x62, 0x00, 0x65, 0x00, 0x20, 0x00, 0x50, 0x00, 0x68, 0x00, 0x6f, 0x00, 0x74, 0x00, 0x6f, 0x00, 0x73, 0x00, 0x68, 0x00, 0x6f, 0x00, 0x70, 0x00, 0x00, 0x00, 0x13, 0x00, 0x41, 0x00, 0x64, 0x00, 0x6f, 0x00, 0x62, 0x00, 0x65, 0x00, 0x20, 0x00, 0x50, 0x00, 0x68, 0x00, 0x6f, 0x00, 0x74, 0x00, 0x6f, 0x00, 0x73, 0x00, 0x68, 0x00, 0x6f, 0x00, 0x70, 0x00, 0x20, 0x00, 0x37, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x38, 0x42, 0x49, 0x4d, 0x04, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0xff, 0xe1, 0x15, 0x67, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6e, 0x73, 0x2e, 0x61, 0x64, 0x6f, 0x62, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x61, 0x70, 0x2f, 0x31, 0x2e, 0x30, 0x2f, 0x00, 0x3c, 0x3f, 0x78, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x3d, 0x27, 0xef, 0xbb, 0xbf, 0x27, 0x20, 0x69, 0x64, 0x3d, 0x27, 0x57, 0x35, 0x4d, 0x30, 0x4d, 0x70, 0x43, 0x65, 0x68, 0x69, 0x48, 0x7a, 0x72, 0x65, 0x53, 0x7a, 0x4e, 0x54, 0x63, 0x7a, 0x6b, 0x63, 0x39, 0x64, 0x27, 0x3f, 0x3e, 0x0a, 0x3c, 0x3f, 0x61, 0x64, 0x6f, 0x62, 0x65, 0x2d, 0x78, 0x61, 0x70, 0x2d, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x20, 0x65, 0x73, 0x63, 0x3d, 0x22, 0x43, 0x52, 0x22, 0x3f, 0x3e, 0x0a, 0x3c, 0x78, 0x3a, 0x78, 0x61, 0x70, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3a, 0x78, 0x3d, 0x27, 0x61, 0x64, 0x6f, 0x62, 0x65, 0x3a, 0x6e, 0x73, 0x3a, 0x6d, 0x65, 0x74, 0x61, 0x2f, 0x27, 0x20, 0x78, 0x3a, 0x78, 0x61, 0x70, 0x74, 0x6b, 0x3d, 0x27, 0x58, 0x4d, 0x50, 0x20, 0x74, 0x6f, 0x6f, 0x6c, 0x6b, 0x69, 0x74, 0x20, 0x32, 0x2e, 0x38, 0x2e, 0x32, 0x2d, 0x33, 0x33, 0x2c, 0x20, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x31, 0x2e, 0x35, 0x27, 0x3e, 0x0a, 0x3c, 0x72, 0x64, 0x66, 0x3a, 0x52, 0x44, 0x46, 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3a, 0x72, 0x64, 0x66, 0x3d, 0x27, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x77, 0x33, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x31, 0x39, 0x39, 0x39, 0x2f, 0x30, 0x32, 0x2f, 0x32, 0x32, 0x2d, 0x72, 0x64, 0x66, 0x2d, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x2d, 0x6e, 0x73, 0x23, 0x27, 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3a, 0x69, 0x58, 0x3d, 0x27, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6e, 0x73, 0x2e, 0x61, 0x64, 0x6f, 0x62, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x58, 0x2f, 0x31, 0x2e, 0x30, 0x2f, 0x27, 0x3e, 0x0a, 0x0a, 0x20, 0x3c, 0x72, 0x64, 0x66, 0x3a, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x3d, 0x27, 0x75, 0x75, 0x69, 0x64, 0x3a, 0x32, 0x32, 0x64, 0x30, 0x32, 0x62, 0x30, 0x61, 0x2d, 0x62, 0x32, 0x34, 0x39, 0x2d, 0x31, 0x31, 0x64, 0x62, 0x2d, 0x38, 0x61, 0x66, 0x38, 0x2d, 0x39, 0x31, 0x64, 0x35, 0x34, 0x30, 0x33, 0x66, 0x39, 0x32, 0x66, 0x39, 0x27, 0x0a, 0x20, 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3a, 0x70, 0x64, 0x66, 0x3d, 0x27, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6e, 0x73, 0x2e, 0x61, 0x64, 0x6f, 0x62, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x64, 0x66, 0x2f, 0x31, 0x2e, 0x33, 0x2f, 0x27, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x21, 0x2d, 0x2d, 0x20, 0x70, 0x64, 0x66, 0x3a, 0x53, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x64, 0x20, 0x2d, 0x2d, 0x3e, 0x0a, 0x20, 0x3c, 0x2f, 0x72, 0x64, 0x66, 0x3a, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x0a, 0x20, 0x3c, 0x72, 0x64, 0x66, 0x3a, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x3d, 0x27, 0x75, 0x75, 0x69, 0x64, 0x3a, 0x32, 0x32, 0x64, 0x30, 0x32, 0x62, 0x30, 0x61, 0x2d, 0x62, 0x32, 0x34, 0x39, 0x2d, 0x31, 0x31, 0x64, 0x62, 0x2d, 0x38, 0x61, 0x66, 0x38, 0x2d, 0x39, 0x31, 0x64, 0x35, 0x34, 0x30, 0x33, 0x66, 0x39, 0x32, 0x66, 0x39, 0x27, 0x0a, 0x20, 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3a, 0x70, 0x68, 0x6f, 0x74, 0x6f, 0x73, 0x68, 0x6f, 0x70, 0x3d, 0x27, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6e, 0x73, 0x2e, 0x61, 0x64, 0x6f, 0x62, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x68, 0x6f, 0x74, 0x6f, 0x73, 0x68, 0x6f, 0x70, 0x2f, 0x31, 0x2e, 0x30, 0x2f, 0x27, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x21, 0x2d, 0x2d, 0x20, 0x70, 0x68, 0x6f, 0x74, 0x6f, 0x73, 0x68, 0x6f, 0x70, 0x3a, 0x43, 0x61, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x64, 0x20, 0x2d, 0x2d, 0x3e, 0x0a, 0x20, 0x3c, 0x2f, 0x72, 0x64, 0x66, 0x3a, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x0a, 0x20, 0x3c, 0x72, 0x64, 0x66, 0x3a, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x3d, 0x27, 0x75, 0x75, 0x69, 0x64, 0x3a, 0x32, 0x32, 0x64, 0x30, 0x32, 0x62, 0x30, 0x61, 0x2d, 0x62, 0x32, 0x34, 0x39, 0x2d, 0x31, 0x31, 0x64, 0x62, 0x2d, 0x38, 0x61, 0x66, 0x38, 0x2d, 0x39, 0x31, 0x64, 0x35, 0x34, 0x30, 0x33, 0x66, 0x39, 0x32, 0x66, 0x39, 0x27, 0x0a, 0x20, 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3a, 0x78, 0x61, 0x70, 0x3d, 0x27, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6e, 0x73, 0x2e, 0x61, 0x64, 0x6f, 0x62, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x61, 0x70, 0x2f, 0x31, 0x2e, 0x30, 0x2f, 0x27, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x21, 0x2d, 0x2d, 0x20, 0x78, 0x61, 0x70, 0x3a, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x64, 0x20, 0x2d, 0x2d, 0x3e, 0x0a, 0x20, 0x3c, 0x2f, 0x72, 0x64, 0x66, 0x3a, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x0a, 0x20, 0x3c, 0x72, 0x64, 0x66, 0x3a, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x3d, 0x27, 0x75, 0x75, 0x69, 0x64, 0x3a, 0x32, 0x32, 0x64, 0x30, 0x32, 0x62, 0x30, 0x61, 0x2d, 0x62, 0x32, 0x34, 0x39, 0x2d, 0x31, 0x31, 0x64, 0x62, 0x2d, 0x38, 0x61, 0x66, 0x38, 0x2d, 0x39, 0x31, 0x64, 0x35, 0x34, 0x30, 0x33, 0x66, 0x39, 0x32, 0x66, 0x39, 0x27, 0x0a, 0x20, 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3a, 0x78, 0x61, 0x70, 0x4d, 0x4d, 0x3d, 0x27, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6e, 0x73, 0x2e, 0x61, 0x64, 0x6f, 0x62, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x61, 0x70, 0x2f, 0x31, 0x2e, 0x30, 0x2f, 0x6d, 0x6d, 0x2f, 0x27, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x78, 0x61, 0x70, 0x4d, 0x4d, 0x3a, 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x3e, 0x61, 0x64, 0x6f, 0x62, 0x65, 0x3a, 0x64, 0x6f, 0x63, 0x69, 0x64, 0x3a, 0x70, 0x68, 0x6f, 0x74, 0x6f, 0x73, 0x68, 0x6f, 0x70, 0x3a, 0x32, 0x32, 0x64, 0x30, 0x32, 0x62, 0x30, 0x36, 0x2d, 0x62, 0x32, 0x34, 0x39, 0x2d, 0x31, 0x31, 0x64, 0x62, 0x2d, 0x38, 0x61, 0x66, 0x38, 0x2d, 0x39, 0x31, 0x64, 0x35, 0x34, 0x30, 0x33, 0x66, 0x39, 0x32, 0x66, 0x39, 0x3c, 0x2f, 0x78, 0x61, 0x70, 0x4d, 0x4d, 0x3a, 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x3e, 0x0a, 0x20, 0x3c, 0x2f, 0x72, 0x64, 0x66, 0x3a, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x0a, 0x20, 0x3c, 0x72, 0x64, 0x66, 0x3a, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x3d, 0x27, 0x75, 0x75, 0x69, 0x64, 0x3a, 0x32, 0x32, 0x64, 0x30, 0x32, 0x62, 0x30, 0x61, 0x2d, 0x62, 0x32, 0x34, 0x39, 0x2d, 0x31, 0x31, 0x64, 0x62, 0x2d, 0x38, 0x61, 0x66, 0x38, 0x2d, 0x39, 0x31, 0x64, 0x35, 0x34, 0x30, 0x33, 0x66, 0x39, 0x32, 0x66, 0x39, 0x27, 0x0a, 0x20, 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3a, 0x64, 0x63, 0x3d, 0x27, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x70, 0x75, 0x72, 0x6c, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x64, 0x63, 0x2f, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x31, 0x2e, 0x31, 0x2f, 0x27, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x64, 0x63, 0x3a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x3c, 0x72, 0x64, 0x66, 0x3a, 0x41, 0x6c, 0x74, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x72, 0x64, 0x66, 0x3a, 0x6c, 0x69, 0x20, 0x78, 0x6d, 0x6c, 0x3a, 0x6c, 0x61, 0x6e, 0x67, 0x3d, 0x27, 0x78, 0x2d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x27, 0x3e, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x2f, 0x72, 0x64, 0x66, 0x3a, 0x6c, 0x69, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x3c, 0x2f, 0x72, 0x64, 0x66, 0x3a, 0x41, 0x6c, 0x74, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x2f, 0x64, 0x63, 0x3a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x20, 0x3c, 0x2f, 0x72, 0x64, 0x66, 0x3a, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x0a, 0x3c, 0x2f, 0x72, 0x64, 0x66, 0x3a, 0x52, 0x44, 0x46, 0x3e, 0x0a, 0x3c, 0x2f, 0x78, 0x3a, 0x78, 0x61, 0x70, 0x6d, 0x65, 0x74, 0x61, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x3c, 0x3f, 0x78, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x20, 0x65, 0x6e, 0x64, 0x3d, 0x27, 0x77, 0x27, 0x3f, 0x3e, 0xff, 0xee, 0x00, 0x0e, 0x41, 0x64, 0x6f, 0x62, 0x65, 0x00, 0x64, 0x40, 0x00, 0x00, 0x00, 0x01, 0xff, 0xdb, 0x00, 0x84, 0x00, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x03, 0x03, 0x04, 0x06, 0x04, 0x03, 0x04, 0x06, 0x07, 0x05, 0x04, 0x04, 0x05, 0x07, 0x08, 0x06, 0x06, 0x07, 0x06, 0x06, 0x08, 0x0a, 0x08, 0x09, 0x09, 0x09, 0x09, 0x08, 0x0a, 0x0a, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0a, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x01, 0x04, 0x05, 0x05, 0x08, 0x07, 0x08, 0x0f, 0x0a, 0x0a, 0x0f, 0x14, 0x0e, 0x0e, 0x0e, 0x14, 0x14, 0x0e, 0x0e, 0x0e, 0x0e, 0x14, 0x11, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x11, 0x11, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x11, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xff, 0xc0, 0x00, 0x11, 0x08, 0x00, 0x64, 0x00, 0x64, 0x03, 0x01, 0x11, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xdd, 0x00, 0x04, 0x00, 0x0d, 0xff, 0xc4, 0x01, 0xa2, 0x00, 0x00, 0x00, 0x07, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 0x03, 0x02, 0x06, 0x01, 0x00, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x01, 0x00, 0x02, 0x02, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x02, 0x06, 0x07, 0x03, 0x04, 0x02, 0x06, 0x02, 0x73, 0x01, 0x02, 0x03, 0x11, 0x04, 0x00, 0x05, 0x21, 0x12, 0x31, 0x41, 0x51, 0x06, 0x13, 0x61, 0x22, 0x71, 0x81, 0x14, 0x32, 0x91, 0xa1, 0x07, 0x15, 0xb1, 0x42, 0x23, 0xc1, 0x52, 0xd1, 0xe1, 0x33, 0x16, 0x62, 0xf0, 0x24, 0x72, 0x82, 0xf1, 0x25, 0x43, 0x34, 0x53, 0x92, 0xa2, 0xb2, 0x63, 0x73, 0xc2, 0x35, 0x44, 0x27, 0x93, 0xa3, 0xb3, 0x36, 0x17, 0x54, 0x64, 0x74, 0xc3, 0xd2, 0xe2, 0x08, 0x26, 0x83, 0x09, 0x0a, 0x18, 0x19, 0x84, 0x94, 0x45, 0x46, 0xa4, 0xb4, 0x56, 0xd3, 0x55, 0x28, 0x1a, 0xf2, 0xe3, 0xf3, 0xc4, 0xd4, 0xe4, 0xf4, 0x65, 0x75, 0x85, 0x95, 0xa5, 0xb5, 0xc5, 0xd5, 0xe5, 0xf5, 0x66, 0x76, 0x86, 0x96, 0xa6, 0xb6, 0xc6, 0xd6, 0xe6, 0xf6, 0x37, 0x47, 0x57, 0x67, 0x77, 0x87, 0x97, 0xa7, 0xb7, 0xc7, 0xd7, 0xe7, 0xf7, 0x38, 0x48, 0x58, 0x68, 0x78, 0x88, 0x98, 0xa8, 0xb8, 0xc8, 0xd8, 0xe8, 0xf8, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79, 0x89, 0x99, 0xa9, 0xb9, 0xc9, 0xd9, 0xe9, 0xf9, 0x2a, 0x3a, 0x4a, 0x5a, 0x6a, 0x7a, 0x8a, 0x9a, 0xaa, 0xba, 0xca, 0xda, 0xea, 0xfa, 0x11, 0x00, 0x02, 0x02, 0x01, 0x02, 0x03, 0x05, 0x05, 0x04, 0x05, 0x06, 0x04, 0x08, 0x03, 0x03, 0x6d, 0x01, 0x00, 0x02, 0x11, 0x03, 0x04, 0x21, 0x12, 0x31, 0x41, 0x05, 0x51, 0x13, 0x61, 0x22, 0x06, 0x71, 0x81, 0x91, 0x32, 0xa1, 0xb1, 0xf0, 0x14, 0xc1, 0xd1, 0xe1, 0x23, 0x42, 0x15, 0x52, 0x62, 0x72, 0xf1, 0x33, 0x24, 0x34, 0x43, 0x82, 0x16, 0x92, 0x53, 0x25, 0xa2, 0x63, 0xb2, 0xc2, 0x07, 0x73, 0xd2, 0x35, 0xe2, 0x44, 0x83, 0x17, 0x54, 0x93, 0x08, 0x09, 0x0a, 0x18, 0x19, 0x26, 0x36, 0x45, 0x1a, 0x27, 0x64, 0x74, 0x55, 0x37, 0xf2, 0xa3, 0xb3, 0xc3, 0x28, 0x29, 0xd3, 0xe3, 0xf3, 0x84, 0x94, 0xa4, 0xb4, 0xc4, 0xd4, 0xe4, 0xf4, 0x65, 0x75, 0x85, 0x95, 0xa5, 0xb5, 0xc5, 0xd5, 0xe5, 0xf5, 0x46, 0x56, 0x66, 0x76, 0x86, 0x96, 0xa6, 0xb6, 0xc6, 0xd6, 0xe6, 0xf6, 0x47, 0x57, 0x67, 0x77, 0x87, 0x97, 0xa7, 0xb7, 0xc7, 0xd7, 0xe7, 0xf7, 0x38, 0x48, 0x58, 0x68, 0x78, 0x88, 0x98, 0xa8, 0xb8, 0xc8, 0xd8, 0xe8, 0xf8, 0x39, 0x49, 0x59, 0x69, 0x79, 0x89, 0x99, 0xa9, 0xb9, 0xc9, 0xd9, 0xe9, 0xf9, 0x2a, 0x3a, 0x4a, 0x5a, 0x6a, 0x7a, 0x8a, 0x9a, 0xaa, 0xba, 0xca, 0xda, 0xea, 0xfa, 0xff, 0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f, 0x00, 0xf0, 0x67, 0xa6, 0x5c, 0x0f, 0x01, 0xd4, 0x7e, 0x18, 0x12, 0x98, 0xe9, 0xd6, 0x2d, 0x34, 0x6d, 0x70, 0xdf, 0xdc, 0xa1, 0xe3, 0xec, 0x5b, 0xfb, 0x32, 0x24, 0xb2, 0x01, 0x1f, 0x15, 0xa4, 0x52, 0x4a, 0x82, 0x31, 0xf1, 0xfe, 0xd1, 0x3d, 0x14, 0x64, 0x49, 0x64, 0x22, 0x98, 0xcf, 0xa5, 0x46, 0x6c, 0x16, 0x55, 0x71, 0x56, 0x62, 0x28, 0x07, 0xc5, 0x45, 0x15, 0xa0, 0xc8, 0x89, 0x33, 0xe1, 0x63, 0xd2, 0xd8, 0x34, 0x44, 0x17, 0xa0, 0x2c, 0x4d, 0x16, 0xbb, 0xed, 0xdc, 0xf8, 0x64, 0xc1, 0x6b, 0x31, 0x42, 0x18, 0x8e, 0xc7, 0xb5, 0x2a, 0x7d, 0xb2, 0x56, 0xc5, 0x61, 0x8c, 0xf2, 0xa0, 0x1b, 0x1e, 0x83, 0x0d, 0xa1, 0x63, 0x50, 0x1f, 0x97, 0x7c, 0x2a, 0xa9, 0x1a, 0x9a, 0x86, 0x4f, 0xb4, 0xb4, 0x38, 0x0a, 0xa6, 0x0b, 0xb8, 0x0c, 0x05, 0x14, 0xf8, 0x76, 0x3e, 0x19, 0x14, 0xb6, 0x78, 0xf8, 0x8c, 0x2a, 0xd5, 0x01, 0xdc, 0x6f, 0x8a, 0x1a, 0xe3, 0x8d, 0xab, 0xff, 0xd0, 0xf0, 0xec, 0xe9, 0x15, 0xb5, 0xb9, 0x5a, 0x7c, 0x4c, 0xa2, 0x9e, 0x24, 0xf5, 0xca, 0xc6, 0xe5, 0x99, 0xd9, 0x34, 0x99, 0x04, 0x3a, 0x7d, 0xb5, 0xba, 0xd5, 0x51, 0x63, 0x0e, 0xc7, 0xc5, 0x9b, 0x73, 0xf8, 0xe4, 0x6f, 0x76, 0xca, 0xd9, 0xda, 0x54, 0x6d, 0x72, 0x2e, 0x1a, 0x57, 0x11, 0x44, 0x40, 0x0d, 0x27, 0x7a, 0x0f, 0xd9, 0x5f, 0x12, 0x69, 0x4c, 0x84, 0xcd, 0x36, 0xe3, 0x85, 0xb2, 0xcd, 0x2f, 0x4a, 0x8b, 0x58, 0x36, 0xf6, 0x76, 0xa8, 0x64, 0x64, 0x3c, 0xa4, 0x93, 0xaa, 0x25, 0x3c, 0x49, 0xda, 0xa4, 0xe5, 0x26, 0x54, 0xe4, 0x8c, 0x7c, 0x5c, 0x93, 0x4d, 0x67, 0xc9, 0x3a, 0x6e, 0x9f, 0x13, 0xb4, 0xce, 0xf7, 0x3a, 0x9b, 0xad, 0x52, 0xd6, 0x2a, 0xd1, 0x49, 0xee, 0xc7, 0xf8, 0x64, 0x46, 0x42, 0x4e, 0xcd, 0x92, 0xc2, 0x00, 0xdd, 0x8a, 0x47, 0xe5, 0x69, 0x6e, 0xd4, 0xa4, 0x08, 0x16, 0x83, 0x9c, 0x8c, 0xdd, 0x95, 0x6b, 0xb9, 0xf6, 0xef, 0x97, 0x78, 0x94, 0xe3, 0x78, 0x04, 0xa4, 0xf3, 0xe8, 0xee, 0x64, 0xe1, 0x12, 0x10, 0x05, 0x6a, 0xc7, 0xc0, 0x6f, 0x53, 0xf3, 0xc9, 0x89, 0xb4, 0x9c, 0x4e, 0xb4, 0xf2, 0xd3, 0xde, 0x7a, 0xd2, 0x19, 0x16, 0x38, 0x61, 0x5d, 0xd9, 0x88, 0x05, 0x9c, 0xf4, 0x0a, 0x0f, 0x5f, 0x73, 0x84, 0xe4, 0xa4, 0xc7, 0x0d, 0xa5, 0xf1, 0x59, 0xba, 0x5c, 0x08, 0x98, 0x6f, 0xc8, 0x20, 0xfa, 0x4e, 0x4e, 0xf6, 0x69, 0xe1, 0xa2, 0x89, 0xfd, 0x1f, 0x77, 0x2c, 0xe6, 0xce, 0xd6, 0x17, 0x9a, 0x69, 0xdb, 0xd3, 0x86, 0x18, 0xc1, 0x67, 0x77, 0x26, 0x80, 0x28, 0x1b, 0x93, 0x88, 0x41, 0x0f, 0x40, 0xb0, 0xfc, 0x87, 0xf3, 0x43, 0x98, 0xd7, 0x58, 0x96, 0xdb, 0x4d, 0x91, 0x88, 0xe5, 0x6c, 0x58, 0xdc, 0x5c, 0x2a, 0xf7, 0x2c, 0xb1, 0xfc, 0x20, 0x8f, 0x02, 0xd9, 0x65, 0x06, 0xbe, 0x26, 0x6f, 0xa2, 0x7f, 0xce, 0x3d, 0x69, 0x26, 0xdd, 0x13, 0x52, 0xbf, 0xbd, 0x92, 0x62, 0x59, 0x4c, 0x90, 0xac, 0x50, 0x45, 0x5e, 0xbb, 0x09, 0x03, 0x12, 0x29, 0x84, 0x00, 0xc4, 0xc9, 0x11, 0xff, 0x00, 0x42, 0xe7, 0xa7, 0x7a, 0xd4, 0xfd, 0x21, 0x79, 0xe9, 0x78, 0x71, 0x8b, 0x95, 0x39, 0x75, 0xaf, 0x4e, 0x98, 0x78, 0x42, 0x38, 0xdf, 0xff, 0xd1, 0xf0, 0xe6, 0xa0, 0x58, 0xc8, 0x84, 0x9a, 0xaa, 0x30, 0x55, 0xf9, 0x0a, 0x6f, 0x90, 0x0c, 0xca, 0x72, 0x48, 0xb8, 0x1e, 0x89, 0xa7, 0x23, 0x17, 0x24, 0xff, 0x00, 0x61, 0xb6, 0x54, 0x76, 0x6e, 0x1b, 0xa7, 0xbe, 0x50, 0xf2, 0xc1, 0xd7, 0x4c, 0x52, 0x5e, 0x33, 0x5b, 0xe9, 0x10, 0xf4, 0x54, 0x3c, 0x5e, 0x77, 0xee, 0x49, 0xec, 0x2b, 0xb6, 0x63, 0xe4, 0xc9, 0xc3, 0xef, 0x73, 0xf0, 0xe1, 0x32, 0x1b, 0xf2, 0x7a, 0x05, 0xce, 0xad, 0x65, 0xa1, 0x98, 0xb4, 0x0f, 0x2a, 0x5b, 0x23, 0xeb, 0x12, 0x00, 0x88, 0xb0, 0xa8, 0x66, 0x46, 0x3d, 0xea, 0x7b, 0xfb, 0x9e, 0x99, 0x89, 0xbc, 0x8d, 0x97, 0x3a, 0x34, 0x05, 0x32, 0x5d, 0x1f, 0xc9, 0x1a, 0x8c, 0x36, 0x8c, 0x6f, 0x66, 0xfa, 0xc6, 0xb7, 0x7d, 0xf0, 0x94, 0x04, 0xf0, 0x88, 0xc9, 0xd5, 0x9d, 0x8d, 0x4b, 0x11, 0xd4, 0x9f, 0xbb, 0x25, 0xc5, 0xdc, 0xa2, 0x03, 0x99, 0x4b, 0xbc, 0xf3, 0x0d, 0x97, 0x96, 0x74, 0xe5, 0xf2, 0xb6, 0x80, 0x95, 0xbd, 0x99, 0x15, 0xf5, 0x4b, 0xd2, 0x37, 0x58, 0x46, 0xd4, 0x27, 0xc5, 0xce, 0xc1, 0x7c, 0x30, 0x8e, 0x68, 0x94, 0x7b, 0x9e, 0x6d, 0xe6, 0x7b, 0x9b, 0x5d, 0x3a, 0xd8, 0xdb, 0x32, 0xfa, 0x77, 0x65, 0x15, 0xe4, 0x57, 0xa7, 0x21, 0x55, 0x04, 0x57, 0xef, 0xd8, 0x66, 0x56, 0x38, 0x19, 0x1b, 0xe8, 0xe0, 0x67, 0x98, 0xc7, 0x1a, 0x1c, 0xde, 0x71, 0x71, 0x79, 0x2c, 0xf2, 0xfa, 0x8c, 0x48, 0xec, 0xb5, 0x24, 0x9a, 0x0c, 0xce, 0x75, 0x29, 0xae, 0x8c, 0x67, 0xd4, 0xb5, 0x0b, 0x4b, 0x04, 0x05, 0xef, 0x2e, 0x66, 0x8e, 0x18, 0x08, 0x15, 0xdd, 0x8f, 0x11, 0xb0, 0xeb, 0x4c, 0x04, 0x5b, 0x21, 0x2a, 0x7d, 0x41, 0xe4, 0x4f, 0xcb, 0xcb, 0x5d, 0x12, 0x45, 0xb8, 0xb7, 0x53, 0x71, 0xaa, 0x9f, 0x86, 0x5b, 0xd6, 0x50, 0x4a, 0xed, 0xba, 0x46, 0x77, 0x00, 0x13, 0xd4, 0x8c, 0x85, 0xd3, 0x12, 0x6d, 0xeb, 0x1a, 0x67, 0x95, 0xd9, 0x39, 0x39, 0x50, 0xac, 0xff, 0x00, 0x6f, 0xc4, 0xff, 0x00, 0x1c, 0x81, 0x92, 0xb2, 0x6b, 0x6d, 0x02, 0xdd, 0xbd, 0x36, 0x92, 0x36, 0x2d, 0x1f, 0xc0, 0x2a, 0x0b, 0x28, 0x1b, 0x91, 0x41, 0xf4, 0x9c, 0xb6, 0x25, 0x81, 0x46, 0xfe, 0x81, 0xb5, 0xad, 0x3d, 0xba, 0x57, 0xb7, 0xf9, 0xf6, 0xc9, 0xb0, 0x7f, 0xff, 0xd2, 0xf0, 0xe2, 0x86, 0x95, 0xc4, 0x67, 0x7e, 0x3f, 0x11, 0xf7, 0xa8, 0x19, 0x06, 0x69, 0x8d, 0xca, 0xca, 0x24, 0x8f, 0xd3, 0x52, 0x24, 0x89, 0x47, 0x25, 0x1f, 0xcb, 0x20, 0xf8, 0xb2, 0xb2, 0x76, 0x6e, 0x88, 0x36, 0xf6, 0x6f, 0x2a, 0xc1, 0x6e, 0xfa, 0x45, 0xad, 0xbc, 0x3f, 0x0b, 0x46, 0x81, 0x4d, 0x46, 0xea, 0x7a, 0x9a, 0x83, 0x9a, 0xa9, 0xdd, 0xbb, 0xec, 0x7b, 0x06, 0x5b, 0xe5, 0xcf, 0x2e, 0x69, 0xfa, 0x5c, 0xcd, 0x7b, 0x14, 0x5e, 0xa5, 0xee, 0xf5, 0xb8, 0x7d, 0xdd, 0x99, 0xba, 0xef, 0x91, 0x16, 0x5b, 0x36, 0xb6, 0x65, 0x0d, 0xac, 0xb2, 0x5b, 0xed, 0x34, 0x81, 0x7a, 0xbb, 0x46, 0x40, 0x6a, 0x9e, 0xb4, 0x39, 0x31, 0x13, 0x49, 0xda, 0xd2, 0x9b, 0xed, 0x1e, 0xc4, 0x24, 0xb3, 0x35, 0xb2, 0x88, 0x60, 0x06, 0xe6, 0x56, 0x98, 0x96, 0x79, 0x1e, 0x31, 0x51, 0xc9, 0x8f, 0xcb, 0x00, 0xe6, 0xb3, 0xe4, 0xf9, 0x2b, 0xcc, 0x7a, 0x94, 0xda, 0x96, 0xa9, 0x71, 0x77, 0x70, 0x79, 0xcd, 0x33, 0x97, 0x76, 0x3f, 0xcc, 0xc6, 0xa6, 0x9f, 0x2e, 0x99, 0xb9, 0xc6, 0x2a, 0x21, 0xe6, 0x73, 0xca, 0xe6, 0x4a, 0x51, 0x1a, 0x99, 0x1c, 0x28, 0x04, 0x93, 0xd0, 0x0e, 0xa4, 0xe4, 0xda, 0x5f, 0x50, 0xfe, 0x4a, 0xfe, 0x48, 0xb5, 0xb2, 0xc1, 0xe6, 0x1f, 0x31, 0x7e, 0xef, 0x52, 0x91, 0x43, 0xc3, 0x6e, 0x77, 0xf4, 0x22, 0x6d, 0xbf, 0xe4, 0x63, 0x0e, 0xbf, 0xca, 0x36, 0xeb, 0x5c, 0x84, 0xa5, 0x48, 0x7d, 0x3b, 0x61, 0xa1, 0xdb, 0x5b, 0x2c, 0x71, 0xda, 0x45, 0xc4, 0x28, 0x00, 0x81, 0xdb, 0x31, 0xc9, 0xb4, 0xb2, 0x3b, 0x5d, 0x27, 0xa5, 0x05, 0x1b, 0xc7, 0xdb, 0x10, 0xa9, 0xbd, 0xa6, 0x93, 0x0c, 0x75, 0xe4, 0x39, 0x35, 0x41, 0x3d, 0xc5, 0x06, 0xdb, 0x8e, 0xfd, 0x46, 0x5b, 0x1d, 0x98, 0x95, 0x4f, 0x46, 0xdb, 0xd5, 0xfb, 0x29, 0x5e, 0x9d, 0x0d, 0x32, 0xeb, 0x61, 0x4f, 0xff, 0xd3, 0xf1, 0x46, 0x9a, 0x16, 0x1b, 0x91, 0x71, 0x28, 0xac, 0x4a, 0x14, 0x30, 0x3e, 0x19, 0x54, 0xb9, 0x36, 0xc7, 0x9b, 0x2d, 0xd1, 0x6c, 0x45, 0xe3, 0xdc, 0xde, 0xc8, 0x95, 0x5b, 0x87, 0xf8, 0x41, 0x1d, 0x10, 0x54, 0x01, 0x98, 0x79, 0x25, 0xd1, 0xda, 0xe9, 0xe1, 0xb5, 0x9e, 0xac, 0xeb, 0x42, 0xba, 0x8e, 0xdf, 0x8c, 0x31, 0x21, 0x70, 0xb4, 0x5d, 0xbe, 0xc5, 0x7c, 0x2b, 0xed, 0xe1, 0x94, 0x18, 0xb9, 0x51, 0x3d, 0x03, 0x2c, 0x13, 0x6b, 0xf1, 0x42, 0x6e, 0xe2, 0xb7, 0x12, 0xa0, 0xdd, 0x50, 0x9f, 0x4f, 0x6f, 0xa7, 0x6f, 0xc7, 0x03, 0x61, 0xa0, 0x83, 0xb5, 0xf3, 0x97, 0x98, 0x20, 0x9c, 0x44, 0xea, 0xd0, 0xad, 0x48, 0x64, 0x90, 0x21, 0xd8, 0x9f, 0xa7, 0xa6, 0x44, 0xca, 0x99, 0xc6, 0x36, 0xcb, 0x74, 0x5d, 0x7e, 0x5b, 0xfe, 0x31, 0x6a, 0x31, 0xf3, 0x8c, 0xd0, 0xad, 0x40, 0xa3, 0x1f, 0x7c, 0x44, 0xd6, 0x51, 0xd9, 0xe0, 0x5f, 0x9a, 0x7e, 0x41, 0x9f, 0x40, 0xf3, 0x14, 0xba, 0x85, 0xba, 0x34, 0xba, 0x2d, 0xfb, 0x34, 0xd0, 0xcf, 0x4f, 0xb0, 0xce, 0x6a, 0x51, 0xe9, 0xb0, 0x20, 0xf4, 0xf1, 0x19, 0xb2, 0xc3, 0x90, 0x11, 0x4e, 0x97, 0x55, 0x80, 0x83, 0xc4, 0x17, 0x7e, 0x4c, 0x79, 0x19, 0xfc, 0xd1, 0xe7, 0x78, 0x4b, 0x91, 0x1d, 0xae, 0x92, 0xa6, 0xf6, 0x46, 0x75, 0xe4, 0xad, 0x22, 0x1f, 0xdd, 0xa1, 0x07, 0xb3, 0x1e, 0xfe, 0xd9, 0x92, 0xeb, 0x4b, 0xed, 0xfd, 0x0a, 0xc2, 0x63, 0x27, 0xa4, 0x88, 0x17, 0x60, 0x49, 0x35, 0xdc, 0x8e, 0xa5, 0x7d, 0xab, 0xd3, 0x28, 0x90, 0x50, 0xcd, 0xed, 0x2d, 0xda, 0x15, 0x55, 0x51, 0xf1, 0x1a, 0x0a, 0xf7, 0x39, 0x5d, 0xaa, 0x77, 0x6f, 0x01, 0x8e, 0xa7, 0x7d, 0xfa, 0xff, 0x00, 0x66, 0x10, 0xa8, 0xb8, 0x63, 0x76, 0x90, 0xa8, 0x20, 0x06, 0x56, 0xdb, 0x61, 0xda, 0xbd, 0x4f, 0xcb, 0x24, 0x15, 0x0f, 0xf5, 0x66, 0xe5, 0x5f, 0x4c, 0x53, 0xc3, 0xb7, 0xce, 0x99, 0x6b, 0x17, 0xff, 0xd4, 0xf0, 0xec, 0x57, 0x6f, 0x32, 0xa5, 0xa4, 0x43, 0x76, 0x75, 0xa9, 0xf1, 0x03, 0xfa, 0x64, 0x08, 0x6c, 0x8e, 0xfb, 0x3d, 0x7f, 0xcb, 0x16, 0x2b, 0x3d, 0xbc, 0x16, 0xa3, 0x66, 0x6d, 0x98, 0xfb, 0x1e, 0xb9, 0xac, 0xc8, 0x77, 0xb7, 0x7d, 0x01, 0xb3, 0x37, 0xb8, 0xd3, 0x46, 0x95, 0x68, 0x86, 0xd2, 0x2e, 0x4e, 0xab, 0xf0, 0x23, 0x11, 0x4e, 0x5f, 0xcd, 0x98, 0xe7, 0x25, 0x96, 0x71, 0x83, 0x0f, 0xd6, 0x3c, 0xb9, 0xe7, 0x0d, 0x7c, 0x41, 0x22, 0x5e, 0xb3, 0x20, 0x0c, 0x65, 0x80, 0xc8, 0x63, 0x8e, 0xbb, 0x95, 0xa5, 0x07, 0xeb, 0xcc, 0xac, 0x73, 0x83, 0x4e, 0x5c, 0x59, 0x09, 0xd8, 0xec, 0xc8, 0x57, 0x41, 0xd3, 0x4e, 0x95, 0xa5, 0x5b, 0x4b, 0x6a, 0xcb, 0xab, 0x43, 0x10, 0x4b, 0xeb, 0x85, 0xa2, 0x2c, 0x8e, 0x3f, 0x68, 0x54, 0xf5, 0x00, 0xd3, 0x97, 0x7a, 0x65, 0x79, 0xa6, 0x24, 0x76, 0x6f, 0xd3, 0x62, 0x96, 0x30, 0x78, 0xcb, 0x21, 0xf2, 0xf4, 0x22, 0xce, 0x54, 0x8e, 0x46, 0x26, 0x10, 0x7e, 0x0a, 0xf5, 0xd8, 0xf5, 0x1f, 0x31, 0x98, 0x83, 0x73, 0xb3, 0x91, 0xcd, 0x67, 0xe6, 0x7d, 0xe8, 0x16, 0x69, 0x6f, 0x10, 0x1f, 0x54, 0x9a, 0x37, 0xf5, 0x41, 0x5e, 0x7f, 0x0a, 0x29, 0x62, 0x02, 0xf8, 0x9c, 0xc8, 0x8c, 0x77, 0x6a, 0x99, 0xa0, 0x89, 0xff, 0x00, 0x9c, 0x74, 0xd2, 0xed, 0xed, 0xfc, 0xbb, 0x7b, 0xaa, 0x9a, 0x7d, 0x62, 0xfe, 0x46, 0x2d, 0xfe, 0x4c, 0x51, 0x31, 0x11, 0xa9, 0xf6, 0xef, 0x9b, 0x30, 0x5e, 0x7b, 0x38, 0xdd, 0xf4, 0x7f, 0x95, 0x94, 0xbc, 0x12, 0x43, 0x30, 0x6a, 0xb2, 0xf3, 0x86, 0x40, 0x3e, 0xcb, 0xd7, 0x6a, 0xd7, 0xb1, 0xe9, 0x8f, 0x37, 0x19, 0x97, 0x41, 0x2c, 0x71, 0x20, 0xf5, 0x36, 0x9c, 0x55, 0x78, 0x1d, 0x8a, 0x91, 0xd7, 0x11, 0x14, 0x5a, 0x3e, 0x19, 0x03, 0x10, 0x6b, 0xca, 0xbd, 0x86, 0xf8, 0x9d, 0x95, 0x18, 0x36, 0x65, 0x2e, 0xbc, 0x54, 0x1f, 0xa2, 0x99, 0x00, 0x59, 0x2a, 0x6f, 0x5e, 0x55, 0x15, 0xe9, 0x5f, 0xc3, 0x2f, 0xb6, 0x14, 0xff, 0x00, 0xff, 0xd5, 0xf1, 0x95, 0xfe, 0x80, 0x74, 0x0d, 0x7c, 0xd9, 0x89, 0x3d, 0x78, 0x57, 0x8b, 0xc5, 0x28, 0xe8, 0x55, 0xf7, 0x1f, 0x48, 0xca, 0x38, 0xb8, 0x83, 0x9f, 0x93, 0x07, 0x85, 0x3a, 0x7a, 0x6f, 0x95, 0x66, 0x2b, 0x2c, 0x4c, 0x0d, 0x14, 0x00, 0x3e, 0x9c, 0xc3, 0x98, 0x76, 0xb8, 0x45, 0xbd, 0x02, 0xde, 0x48, 0xee, 0xdc, 0xa0, 0x15, 0xe2, 0x2b, 0xc8, 0x8a, 0x8a, 0xfd, 0x3b, 0x66, 0x3f, 0x00, 0x73, 0x84, 0x2d, 0x36, 0xb5, 0xb5, 0x9e, 0x35, 0x1c, 0x29, 0xc4, 0xfe, 0xc8, 0x04, 0x7f, 0xc4, 0x69, 0x91, 0xe1, 0x67, 0x2c, 0x4a, 0xd2, 0xe9, 0x4e, 0xe3, 0xd4, 0xf4, 0x81, 0x5a, 0x12, 0xc5, 0x41, 0x3f, 0x79, 0x38, 0x9b, 0x60, 0x20, 0x07, 0x34, 0xb0, 0xc9, 0x03, 0x5c, 0x23, 0x03, 0x53, 0x13, 0x56, 0x88, 0xdf, 0x09, 0xda, 0x9b, 0xd3, 0xb6, 0x52, 0x0e, 0xec, 0xe4, 0x29, 0x24, 0xfc, 0xd0, 0xe7, 0x75, 0xe5, 0x57, 0x6b, 0x61, 0xfb, 0xf0, 0xca, 0xaa, 0x57, 0xa8, 0xe6, 0x78, 0x1a, 0x7d, 0xf9, 0x95, 0x8a, 0x5e, 0xa0, 0xe3, 0x67, 0x8f, 0xa0, 0xbd, 0x5b, 0xf2, 0xdf, 0x4a, 0x82, 0xcb, 0x4a, 0xb3, 0xb0, 0xb4, 0x41, 0x0a, 0x70, 0x48, 0xd9, 0x57, 0x60, 0x51, 0x3a, 0x8f, 0xbc, 0xe6, 0x7b, 0xcb, 0xe4, 0x3b, 0xa7, 0x3f, 0x9b, 0x9f, 0x9a, 0xba, 0x77, 0xe5, 0x5f, 0x95, 0x9c, 0x59, 0x94, 0x9f, 0xcd, 0x37, 0x8c, 0xa9, 0xa6, 0xd9, 0x39, 0xaa, 0xd0, 0x7d, 0xa9, 0x1c, 0x03, 0x5e, 0x09, 0xff, 0x00, 0x0c, 0x76, 0xcb, 0x62, 0x2d, 0xa5, 0xf2, 0x85, 0xbf, 0xe7, 0x87, 0xe6, 0xa3, 0x5e, 0x4d, 0xa8, 0xc9, 0xe6, 0x8b, 0xd5, 0x69, 0x5c, 0xb0, 0x4a, 0xab, 0xc4, 0xb5, 0x35, 0x0a, 0xaa, 0xea, 0x40, 0x03, 0xa0, 0xf6, 0xcb, 0x40, 0x4d, 0x3e, 0xdb, 0xff, 0x00, 0x9c, 0x7f, 0xfc, 0xce, 0x4f, 0xcc, 0xbf, 0x26, 0x25, 0xe5, 0xd3, 0x2f, 0xe9, 0xdd, 0x3d, 0xfe, 0xab, 0xa9, 0xaa, 0xd2, 0xa6, 0x40, 0x2a, 0xb2, 0x71, 0x00, 0x01, 0xea, 0x0d, 0xe8, 0x3a, 0x64, 0x25, 0x16, 0x1c, 0x8b, 0xd9, 0x51, 0x39, 0x28, 0x12, 0x51, 0x41, 0xfd, 0xa3, 0xd2, 0xb9, 0x4f, 0x0d, 0x33, 0xb5, 0xf4, 0x87, 0x9d, 0x79, 0x0e, 0xb4, 0xaf, 0x6a, 0xf8, 0xf1, 0xf0, 0xc9, 0xda, 0xbf, 0xff, 0xd6, 0xf2, 0xc6, 0xb5, 0x68, 0x64, 0xd0, 0x6d, 0x35, 0x20, 0x39, 0xcd, 0x13, 0x0f, 0x5e, 0x61, 0xfc, 0x8f, 0x40, 0x8b, 0x5e, 0xe0, 0x66, 0x1c, 0x4f, 0xaa, 0x9d, 0xe6, 0xa6, 0x1e, 0x91, 0x2e, 0xa9, 0x87, 0x95, 0xee, 0x9c, 0xc5, 0x55, 0x34, 0x60, 0x40, 0xae, 0x57, 0x30, 0xd9, 0xa7, 0x95, 0xbd, 0x6f, 0xcb, 0x26, 0x39, 0x40, 0x0d, 0x4e, 0xc0, 0x9f, 0x9e, 0x50, 0x5d, 0xac, 0x79, 0x33, 0x8b, 0xbb, 0x9b, 0x3b, 0x6b, 0x35, 0x48, 0x54, 0x09, 0x29, 0x56, 0x7f, 0xe1, 0x86, 0x72, 0x00, 0x2c, 0x6e, 0xf7, 0x63, 0x3e, 0x63, 0xbd, 0xbd, 0x5d, 0x20, 0x2a, 0xb3, 0xa4, 0x33, 0x48, 0xab, 0x21, 0x43, 0xf1, 0x2c, 0x47, 0xed, 0x1d, 0xbc, 0x73, 0x18, 0x9b, 0x64, 0x28, 0x96, 0x3a, 0xc7, 0x49, 0xb0, 0xf4, 0xcc, 0xe9, 0x73, 0x6c, 0xb4, 0xf8, 0x67, 0x92, 0x32, 0x21, 0x70, 0x7b, 0x89, 0x05, 0x57, 0xef, 0x38, 0x28, 0x94, 0x4a, 0x7d, 0x13, 0x7d, 0x6a, 0xd3, 0x4c, 0xb8, 0xf2, 0xc3, 0xc8, 0x2e, 0x03, 0xf3, 0xe2, 0x7d, 0x33, 0xb7, 0xc5, 0xcc, 0x71, 0x03, 0xc6, 0xb9, 0x64, 0x06, 0xe2, 0x9a, 0xf2, 0x4f, 0xd2, 0x6d, 0xe9, 0xfe, 0x41, 0x45, 0x5b, 0x18, 0x66, 0xa5, 0x64, 0x09, 0xf4, 0xd5, 0xb7, 0xcd, 0x93, 0xc7, 0xcf, 0x9b, 0xe5, 0x6f, 0xf9, 0xc8, 0x0d, 0x56, 0xeb, 0x59, 0xfc, 0xce, 0xd5, 0x12, 0x61, 0xc4, 0x69, 0xe9, 0x0d, 0xa4, 0x4b, 0xfe, 0x48, 0x40, 0xd5, 0x3e, 0xe4, 0xb6, 0x64, 0x8e, 0x4c, 0x02, 0x61, 0x65, 0xa0, 0x14, 0xb4, 0xb6, 0xb0, 0xb1, 0xb6, 0xb2, 0x97, 0xcb, 0xf1, 0x5a, 0x2d, 0xc6, 0xa5, 0xac, 0xb4, 0x70, 0x5d, 0xc7, 0x3d, 0xc1, 0x51, 0x24, 0x91, 0xc9, 0x31, 0x75, 0x6b, 0x70, 0x9f, 0x14, 0x68, 0x01, 0x46, 0xe4, 0xb5, 0xa3, 0x17, 0xcb, 0x40, 0x61, 0x6f, 0x47, 0xff, 0x00, 0x9c, 0x3a, 0x8f, 0x5b, 0x4f, 0x3c, 0x6b, 0xb7, 0xfa, 0x30, 0x91, 0x3c, 0xa4, 0xb1, 0x95, 0xb9, 0x82, 0x42, 0x0a, 0xbc, 0x8e, 0xe4, 0xdb, 0xa9, 0xef, 0xc9, 0x17, 0x91, 0x24, 0x7c, 0xb2, 0x05, 0x64, 0xfb, 0x75, 0x64, 0x32, 0x39, 0x69, 0x5b, 0x9c, 0xad, 0xb9, 0xdb, 0xa7, 0xb5, 0x3b, 0x53, 0x2a, 0x21, 0x41, 0x44, 0xf3, 0x8b, 0x8f, 0x2e, 0x43, 0x9d, 0x2b, 0xd4, 0x57, 0x23, 0x41, 0x36, 0xff, 0x00, 0xff, 0xd7, 0xf0, 0xc0, 0xd5, 0xb5, 0x11, 0x64, 0xb6, 0x3f, 0x59, 0x90, 0xd9, 0xab, 0x06, 0xf4, 0x79, 0x7c, 0x3b, 0x74, 0xc8, 0x08, 0x8b, 0xb6, 0xe3, 0x96, 0x55, 0x57, 0xb3, 0x3e, 0xf2, 0x35, 0xc7, 0xd6, 0x0b, 0x45, 0x5d, 0xdc, 0x8a, 0x7d, 0xd9, 0x8d, 0x94, 0x3b, 0x3d, 0x1c, 0x9e, 0xc3, 0xe5, 0xc3, 0x2c, 0x7c, 0xc5, 0x0f, 0xee, 0xdb, 0x8b, 0x0c, 0xc4, 0x26, 0x9d, 0xa0, 0x9a, 0x7d, 0x2c, 0xe5, 0xe4, 0x55, 0x7f, 0xee, 0xc1, 0x15, 0x04, 0xd0, 0x12, 0x3c, 0x72, 0x89, 0x1b, 0x2c, 0xcc, 0xa8, 0x2a, 0x8b, 0x87, 0xbb, 0x63, 0x1a, 0x28, 0x65, 0xf0, 0xed, 0xf2, 0xc3, 0xc2, 0x0a, 0x06, 0x4a, 0x46, 0xc7, 0xa5, 0xa3, 0x59, 0xc8, 0xb2, 0xc7, 0x45, 0x22, 0x9c, 0x14, 0x54, 0x10, 0x46, 0xf5, 0x1d, 0x32, 0x5c, 0x14, 0x14, 0xe4, 0x32, 0x2f, 0x3a, 0xf3, 0xb6, 0x90, 0x9a, 0x6d, 0xae, 0x9f, 0x3d, 0xab, 0xb8, 0x8a, 0x3b, 0xf8, 0x39, 0x44, 0x58, 0xf0, 0x08, 0xd5, 0x14, 0xa5, 0x7b, 0x65, 0x98, 0x8e, 0xfb, 0xb5, 0x67, 0x87, 0xa5, 0xef, 0x5e, 0x44, 0x96, 0x35, 0xb5, 0xb6, 0x59, 0x36, 0xfd, 0xd8, 0xa0, 0xf1, 0x20, 0x53, 0x33, 0xc0, 0x79, 0x59, 0x73, 0x7c, 0xd7, 0xf9, 0xfb, 0xa2, 0xcd, 0x67, 0xf9, 0xa7, 0x7b, 0x72, 0xf1, 0x71, 0x83, 0x53, 0x86, 0x0b, 0x98, 0x24, 0x22, 0x8a, 0xcc, 0x88, 0x23, 0x7f, 0xb8, 0xae, 0xf9, 0x7c, 0x50, 0x1e, 0x5f, 0x7c, 0x48, 0x21, 0x44, 0x6b, 0xce, 0x9b, 0xb0, 0x1b, 0x9e, 0xf5, 0xaf, 0x8e, 0x4d, 0x5f, 0x7a, 0x7f, 0xce, 0x34, 0xf9, 0x5d, 0x3c, 0xa3, 0xf9, 0x69, 0x63, 0xa9, 0x3c, 0x27, 0xeb, 0xda, 0xe1, 0x37, 0xd7, 0x2e, 0xaa, 0xdb, 0x06, 0xda, 0x30, 0x49, 0xfe, 0x54, 0x03, 0x03, 0x49, 0xdc, 0xb3, 0xaf, 0x38, 0xfe, 0x6a, 0xf9, 0x47, 0xc9, 0x3a, 0x74, 0x97, 0xfa, 0xf6, 0xaf, 0x15, 0x85, 0xb8, 0x75, 0x89, 0xb8, 0x87, 0x9a, 0x72, 0xee, 0x2a, 0x14, 0x24, 0x60, 0xb1, 0xa8, 0xdf, 0x07, 0x0b, 0x2d, 0xcb, 0xcf, 0x7f, 0xe8, 0x6a, 0xff, 0x00, 0x26, 0xbd, 0x6a, 0x7f, 0x89, 0x2f, 0xf8, 0x52, 0x9e, 0xb7, 0xe8, 0xb9, 0xb8, 0x57, 0xc2, 0x95, 0xe9, 0x8f, 0x08, 0x5a, 0x2f, 0xff, 0xd0, 0xf0, 0x4d, 0x40, 0xaa, 0xd7, 0x00, 0x64, 0xcb, 0x3c, 0x97, 0xa8, 0xb5, 0x9e, 0xa3, 0x1a, 0xd6, 0x84, 0x95, 0x3f, 0x45, 0x72, 0x9c, 0xa2, 0xc3, 0x99, 0xa5, 0x9d, 0x49, 0xf4, 0x17, 0x97, 0xaf, 0x63, 0x17, 0x52, 0x6f, 0xf0, 0xc8, 0x43, 0x6f, 0x9a, 0xe9, 0x07, 0x70, 0x0e, 0xec, 0x83, 0x51, 0x44, 0xb8, 0x61, 0x1a, 0x9e, 0x11, 0xd3, 0x91, 0x60, 0x68, 0x6b, 0xd3, 0x31, 0x4f, 0x36, 0xd3, 0x4c, 0x52, 0xef, 0x4c, 0xd5, 0x0c, 0xc4, 0x69, 0xda, 0x94, 0xc8, 0x3a, 0xf0, 0x66, 0x07, 0x73, 0xe0, 0x40, 0xfd, 0x79, 0x93, 0x12, 0x1c, 0x9c, 0x32, 0xc7, 0xfc, 0x41, 0x33, 0xd2, 0xb4, 0x6f, 0x38, 0x98, 0x65, 0x76, 0xbf, 0x69, 0x42, 0xd0, 0xaa, 0xc9, 0xde, 0x95, 0xad, 0x28, 0x46, 0x4e, 0xac, 0x39, 0x77, 0x80, 0x11, 0xbf, 0xd8, 0xc7, 0x7c, 0xe1, 0xa5, 0xf9, 0x92, 0x4d, 0x32, 0x5b, 0x8b, 0x93, 0x27, 0xa7, 0x68, 0x56, 0xe2, 0x45, 0xda, 0x85, 0x61, 0x6e, 0x67, 0xad, 0x6b, 0xb0, 0x38, 0xc2, 0x81, 0xe4, 0xc7, 0x52, 0x31, 0x1c, 0x67, 0x86, 0x5b, 0xbd, 0x37, 0xca, 0x7a, 0x94, 0xb1, 0x69, 0xb6, 0x2e, 0xb7, 0x15, 0x48, 0xc2, 0xb4, 0x52, 0x53, 0xac, 0x32, 0xaf, 0xb1, 0xed, 0x9b, 0x10, 0x36, 0x78, 0x5c, 0x9f, 0x51, 0x64, 0x1f, 0x98, 0x3e, 0x58, 0xb6, 0xfc, 0xc8, 0xf2, 0xe5, 0xbc, 0x68, 0x52, 0x2d, 0x5a, 0xd1, 0x84, 0xb6, 0xf3, 0x95, 0x0e, 0xc0, 0x85, 0xe2, 0xcb, 0xd8, 0xd1, 0xbb, 0xe4, 0xc1, 0xa6, 0x97, 0xce, 0x17, 0x5f, 0x95, 0xde, 0x6d, 0xb6, 0xbe, 0xb7, 0x69, 0x34, 0xf3, 0x3c, 0x72, 0xcf, 0xe8, 0xa3, 0x45, 0x49, 0x95, 0x4a, 0x90, 0x3e, 0x35, 0x5a, 0x95, 0x1d, 0xfe, 0x21, 0x93, 0x4d, 0xbe, 0xd2, 0xd2, 0xf5, 0x8b, 0xbd, 0x32, 0x2d, 0x3f, 0x4c, 0x9a, 0xe4, 0xca, 0x9e, 0x90, 0x85, 0x65, 0x55, 0x08, 0x85, 0x91, 0x01, 0x3b, 0x0a, 0x05, 0xe9, 0xb0, 0xc0, 0x5a, 0xc3, 0xcd, 0x3f, 0x3b, 0x7f, 0x26, 0xec, 0xff, 0x00, 0x35, 0x6d, 0x6d, 0xb5, 0x3d, 0x16, 0xfe, 0x0d, 0x3b, 0xcd, 0x96, 0x01, 0x92, 0x46, 0x9e, 0xa2, 0x0b, 0xc8, 0xb7, 0x28, 0x92, 0x71, 0xfb, 0x2e, 0xa7, 0xec, 0x3d, 0x0f, 0xc2, 0x68, 0x71, 0x05, 0x95, 0xd3, 0xe7, 0x9f, 0xfa, 0x16, 0x2f, 0xcd, 0x7f, 0x43, 0xd6, 0xfa, 0xa5, 0x97, 0xab, 0xeb, 0x7a, 0x5f, 0x55, 0xfa, 0xec, 0x5e, 0xaf, 0x0f, 0xf7, 0xed, 0x2b, 0x4e, 0x15, 0xff, 0x00, 0x65, 0xdf, 0x8e, 0x14, 0xf1, 0xbf, 0xff, 0xd1, 0xf0, 0x5a, 0xa7, 0x18, 0x5e, 0x56, 0x1f, 0x68, 0x71, 0x5f, 0xa7, 0xbe, 0x2a, 0x98, 0xdb, 0xfa, 0x90, 0x24, 0x37, 0xb0, 0xfd, 0xb8, 0xa8, 0x58, 0x78, 0xae, 0x43, 0xc9, 0xb4, 0x6d, 0xbb, 0xda, 0x3c, 0xa1, 0xad, 0x43, 0xa8, 0xda, 0xc5, 0x2a, 0x3d, 0x26, 0x5a, 0x02, 0x2b, 0xbe, 0x60, 0x64, 0x8d, 0x17, 0x6f, 0x8b, 0x20, 0x90, 0x7a, 0x3c, 0x32, 0x8b, 0xa8, 0x02, 0xf3, 0xfd, 0xe0, 0x1b, 0x11, 0x98, 0x66, 0x3b, 0xb9, 0x62, 0x54, 0x83, 0x36, 0xf2, 0xa4, 0xe4, 0x29, 0x34, 0xeb, 0xc8, 0x74, 0xae, 0x0d, 0xc3, 0x65, 0x82, 0x13, 0x6b, 0x57, 0xba, 0x54, 0xe4, 0x8c, 0x41, 0x1b, 0x75, 0xa7, 0xe0, 0x72, 0x5c, 0x4c, 0x84, 0x50, 0x5a, 0xb3, 0xdd, 0xdd, 0xc3, 0x24, 0x33, 0xb1, 0x60, 0xe0, 0x86, 0x52, 0x45, 0x38, 0xd2, 0x87, 0x24, 0x26, 0x6d, 0x8c, 0xe1, 0x41, 0x25, 0xfc, 0xa3, 0xd7, 0x2f, 0x6f, 0x3c, 0xbf, 0x73, 0xa5, 0xb2, 0x2c, 0xd1, 0x69, 0x17, 0x2f, 0x6b, 0x14, 0x8c, 0x0f, 0x21, 0x0d, 0x79, 0x46, 0x09, 0x15, 0xed, 0xb7, 0x4e, 0xd9, 0xb9, 0x8b, 0xcb, 0xe4, 0xa2, 0x5e, 0xa3, 0xa6, 0xdf, 0x6a, 0x36, 0xe4, 0xcd, 0x69, 0x1c, 0x4e, 0x84, 0x7c, 0x76, 0xab, 0x21, 0x67, 0xa8, 0xa7, 0xd9, 0xf8, 0x4d, 0x2b, 0xf3, 0xc3, 0x4d, 0x49, 0x57, 0x98, 0x75, 0x6f, 0x31, 0xda, 0xf9, 0xa3, 0x4b, 0xfd, 0x1f, 0x69, 0x1d, 0xae, 0xa1, 0xa9, 0x7e, 0xee, 0xe6, 0xd2, 0x79, 0x18, 0xf3, 0xb5, 0x1f, 0xee, 0xd9, 0x0a, 0x01, 0x4e, 0x3f, 0xb3, 0x4d, 0xf2, 0x9c, 0xb9, 0x04, 0x05, 0xb7, 0xe2, 0x87, 0x1e, 0xdd, 0x19, 0x3e, 0xaf, 0x6b, 0xae, 0xcb, 0x6d, 0x13, 0x0d, 0x45, 0xa2, 0x8e, 0x06, 0xe5, 0x13, 0x2a, 0x02, 0x01, 0x5e, 0x82, 0xb5, 0x04, 0xe6, 0x11, 0xd4, 0xcd, 0xda, 0x43, 0x49, 0x8e, 0xb7, 0xdc, 0xb1, 0x51, 0xe6, 0x4d, 0x76, 0xd2, 0x61, 0x15, 0xaa, 0x4b, 0xa8, 0xc9, 0x6e, 0x49, 0x79, 0x20, 0xe6, 0x8c, 0x49, 0xad, 0x43, 0x16, 0xe4, 0xa7, 0xaf, 0x43, 0xd3, 0x26, 0x35, 0x75, 0xcd, 0xa8, 0xe8, 0x87, 0x46, 0xbf, 0xc7, 0x9a, 0xff, 0x00, 0xd6, 0xbf, 0x48, 0xfe, 0x88, 0xfd, 0xe7, 0x0f, 0xab, 0xfa, 0x3f, 0x58, 0x7f, 0x5f, 0x8d, 0x3f, 0x9f, 0xa7, 0x5e, 0xd4, 0xc3, 0xf9, 0xd1, 0x7c, 0xb6, 0x47, 0xe4, 0x3a, 0x5b, 0xff, 0xd2, 0xf0, 0xb7, 0xa6, 0x1e, 0xdf, 0xd3, 0xf6, 0xa5, 0x71, 0x54, 0xdb, 0x4b, 0x80, 0x3c, 0x42, 0x26, 0xee, 0x29, 0xbe, 0x51, 0x23, 0x4e, 0x44, 0x05, 0x84, 0x45, 0xa5, 0xd5, 0xf7, 0x97, 0x2e, 0xfd, 0x6b, 0x6a, 0x98, 0x09, 0xab, 0xc7, 0xfc, 0x46, 0x3b, 0x4c, 0x26, 0x32, 0x30, 0x3e, 0x4f, 0x49, 0xd0, 0xfc, 0xfb, 0x05, 0xd4, 0x4a, 0x7d, 0x40, 0xac, 0x3a, 0x8e, 0x84, 0x1c, 0xc5, 0x96, 0x2a, 0x73, 0xe1, 0x9c, 0x16, 0x6d, 0xa5, 0x79, 0x86, 0xd6, 0xec, 0x80, 0x5a, 0xa0, 0xf5, 0xca, 0xcc, 0x5c, 0xa1, 0x2b, 0x1b, 0x26, 0x30, 0x6a, 0x31, 0x46, 0xcf, 0x1c, 0x87, 0x94, 0x64, 0x9e, 0x3d, 0xb6, 0xf0, 0xca, 0xa8, 0x39, 0x51, 0x99, 0x42, 0x6b, 0x1a, 0xc5, 0xa5, 0xa5, 0x94, 0xf7, 0x92, 0xc8, 0xaa, 0xb1, 0x23, 0x30, 0x04, 0xf8, 0x0e, 0x9f, 0x4e, 0x4a, 0x11, 0xb2, 0xd5, 0x9b, 0x25, 0x06, 0x1b, 0xff, 0x00, 0x38, 0xfd, 0xad, 0xdf, 0xda, 0xf9, 0xa2, 0xfe, 0xc5, 0x42, 0xbe, 0x9b, 0x7f, 0x0b, 0xdd, 0xdd, 0x07, 0xaf, 0x14, 0x68, 0xd8, 0x71, 0x6d, 0xbb, 0x90, 0xfc, 0x73, 0x6e, 0xf2, 0xf2, 0xdd, 0xf4, 0xad, 0xa6, 0xab, 0x6d, 0x69, 0x14, 0xfa, 0xee, 0xa0, 0xe2, 0x0b, 0x0d, 0x39, 0x19, 0xfe, 0x11, 0xc5, 0x1a, 0x4a, 0x1d, 0x8f, 0x73, 0x4f, 0xf8, 0x96, 0x0b, 0x40, 0x8d, 0xec, 0xf3, 0x6d, 0x3f, 0x52, 0xba, 0xd6, 0x35, 0x8b, 0xbf, 0x36, 0x6a, 0x5f, 0x0d, 0xc5, 0xdc, 0xa8, 0xb6, 0xa8, 0x7a, 0xc5, 0x6c, 0x9b, 0x22, 0x0f, 0xa3, 0x73, 0x9a, 0xbc, 0xb3, 0xe2, 0x36, 0xed, 0xb1, 0x43, 0x80, 0x53, 0xd0, 0xa7, 0xd4, 0x44, 0xfa, 0x7a, 0xda, 0x83, 0xbd, 0x3e, 0x2f, 0xa7, 0x2b, 0xad, 0x9b, 0xb8, 0x8d, 0xa8, 0xe8, 0x91, 0xdb, 0xfa, 0x2d, 0x6f, 0xc3, 0x8a, 0x2d, 0x56, 0xa3, 0xad, 0x4f, 0x5c, 0xa4, 0x0d, 0xdc, 0xa3, 0xca, 0xd0, 0xbf, 0xa1, 0xe3, 0xfa, 0xe7, 0x0f, 0xf2, 0xb9, 0x57, 0xbf, 0x1a, 0xe4, 0xb8, 0x57, 0xc5, 0xdd, 0xff, 0xd3, 0xf0, 0xcc, 0x5d, 0x7b, 0x70, 0xc5, 0x53, 0x6d, 0x2f, 0xd5, 0xe4, 0x69, 0xfd, 0xdf, 0xec, 0xd7, 0xad, 0x7d, 0xb2, 0x8c, 0x8d, 0xd8, 0xed, 0x91, 0x9f, 0x43, 0xea, 0xe7, 0xeb, 0x94, 0xad, 0x3e, 0x1e, 0x95, 0xfc, 0x72, 0x81, 0x7d, 0x1c, 0x9d, 0xba, 0xb1, 0x7b, 0xdf, 0xa9, 0x7a, 0xdf, 0xee, 0x2f, 0xd4, 0xfa, 0xe7, 0xed, 0x7a, 0x7f, 0xdd, 0xff, 0x00, 0xb2, 0xae, 0x64, 0x0b, 0xea, 0xe3, 0x9a, 0xbf, 0x4a, 0x6f, 0xa4, 0xff, 0x00, 0x89, 0xbd, 0x45, 0xfa, 0xb5, 0x79, 0xf7, 0xeb, 0xc7, 0xe9, 0xae, 0x57, 0x2e, 0x17, 0x23, 0x1f, 0x89, 0xd1, 0x99, 0x8f, 0xf1, 0xa7, 0x11, 0xcf, 0xd3, 0xf5, 0x29, 0xb5, 0x6b, 0xd3, 0xe8, 0xcc, 0x7f, 0x45, 0xb9, 0xa3, 0xc5, 0x62, 0xbe, 0x68, 0xff, 0x00, 0x15, 0xfd, 0x4c, 0xfe, 0x90, 0xaf, 0xd4, 0xab, 0xf1, 0x7a, 0x7f, 0x62, 0x9d, 0xab, 0xdf, 0x32, 0xb1, 0x70, 0x5e, 0xdc, 0xdc, 0x2d, 0x47, 0x8b, 0x5e, 0xae, 0x4c, 0xbf, 0xf2, 0x37, 0x9f, 0x3d, 0x5b, 0xd2, 0xff, 0x00, 0x8e, 0x87, 0xee, 0x29, 0x5a, 0xf2, 0xf4, 0xaa, 0xd4, 0xa5, 0x36, 0xa7, 0x3a, 0x57, 0xfd, 0x8e, 0x64, 0x3a, 0xf2, 0xf6, 0xbf, 0xcc, 0x7f, 0x5b, 0xfc, 0x23, 0xa7, 0xfe, 0x8e, 0xff, 0x00, 0x8e, 0x37, 0xd6, 0x63, 0xfa, 0xe5, 0x2b, 0xcb, 0x87, 0xec, 0xd6, 0xbd, 0xb9, 0x7d, 0xac, 0xc7, 0xcd, 0x7c, 0x2d, 0xf8, 0x2b, 0x89, 0x26, 0x8f, 0xd4, 0xfa, 0x94, 0x3e, 0x85, 0x29, 0xc9, 0x69, 0xfc, 0x33, 0x58, 0x5d, 0x9c, 0x79, 0xb2, 0xbb, 0x0f, 0xac, 0x7a, 0x2b, 0xea, 0x75, 0xef, 0x92, 0x0c, 0x53, 0x3d, 0x2f, 0xd4, 0xfa, 0xbb, 0xfa, 0x74, 0xf5, 0x39, 0x9a, 0xd7, 0xe7, 0x80, 0x53, 0x79, 0xba, 0x5b, 0xfe, 0x97, 0xfa, 0x4b, 0xfc, 0xba, 0x7f, 0xb1, 0xc7, 0xab, 0x1e, 0x8f, 0xff, 0xd9
+};
diff --git a/talk/base/testclient.cc b/talk/base/testclient.cc
new file mode 100644
index 0000000..8a605ce
--- /dev/null
+++ b/talk/base/testclient.cc
@@ -0,0 +1,137 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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/base/testclient.h"
+#include "talk/base/thread.h"
+#include "talk/base/timeutils.h"
+
+namespace talk_base {
+
+// DESIGN: Each packet received is put it into a list of packets.
+// Callers can retrieve received packets from any thread by calling
+// NextPacket.
+
+TestClient::TestClient(AsyncPacketSocket* socket) : socket_(socket) {
+ packets_ = new std::vector<Packet*>();
+ socket_->SignalReadPacket.connect(this, &TestClient::OnPacket);
+}
+
+TestClient::~TestClient() {
+ delete socket_;
+ for (unsigned i = 0; i < packets_->size(); i++)
+ delete (*packets_)[i];
+ delete packets_;
+}
+
+bool TestClient::CheckConnState(AsyncPacketSocket::State state) {
+ // Wait for our timeout value until the socket reaches the desired state.
+ uint32 end = TimeAfter(kTimeout);
+ while (socket_->GetState() != state && TimeUntil(end) > 0)
+ Thread::Current()->ProcessMessages(1);
+ return (socket_->GetState() == state);
+}
+
+int TestClient::Send(const char* buf, size_t size) {
+ return socket_->Send(buf, size);
+}
+
+int TestClient::SendTo(const char* buf, size_t size,
+ const SocketAddress& dest) {
+ return socket_->SendTo(buf, size, dest);
+}
+
+TestClient::Packet* TestClient::NextPacket() {
+ // If no packets are currently available, we go into a get/dispatch loop for
+ // at most 1 second. If, during the loop, a packet arrives, then we can stop
+ // early and return it.
+
+ // Note that the case where no packet arrives is important. We often want to
+ // test that a packet does not arrive.
+
+ // Note also that we only try to pump our current thread's message queue.
+ // Pumping another thread's queue could lead to messages being dispatched from
+ // the wrong thread to non-thread-safe objects.
+
+ uint32 end = TimeAfter(kTimeout);
+ while (packets_->size() == 0 && TimeUntil(end) > 0)
+ Thread::Current()->ProcessMessages(1);
+
+ // Return the first packet placed in the queue.
+ Packet* packet = NULL;
+ if (packets_->size() > 0) {
+ CritScope cs(&crit_);
+ packet = packets_->front();
+ packets_->erase(packets_->begin());
+ }
+
+ return packet;
+}
+
+bool TestClient::CheckNextPacket(const char* buf, size_t size,
+ SocketAddress* addr) {
+ bool res = false;
+ Packet* packet = NextPacket();
+ if (packet) {
+ res = (packet->size == size && std::memcmp(packet->buf, buf, size) == 0);
+ if (addr)
+ *addr = packet->addr;
+ delete packet;
+ }
+ return res;
+}
+
+bool TestClient::CheckNoPacket() {
+ bool res;
+ Packet* packet = NextPacket();
+ res = (packet == NULL);
+ delete packet;
+ return res;
+}
+
+void TestClient::OnPacket(AsyncPacketSocket* socket, const char* buf,
+ size_t size, const SocketAddress& remote_addr) {
+ CritScope cs(&crit_);
+ packets_->push_back(new Packet(remote_addr, buf, size));
+}
+
+TestClient::Packet::Packet(const SocketAddress& a, const char* b, size_t s)
+ : addr(a), buf(0), size(s) {
+ buf = new char[size];
+ memcpy(buf, b, size);
+}
+
+TestClient::Packet::Packet(const Packet& p)
+ : addr(p.addr), buf(0), size(p.size) {
+ buf = new char[size];
+ memcpy(buf, p.buf, size);
+}
+
+TestClient::Packet::~Packet() {
+ delete[] buf;
+}
+
+} // namespace talk_base
diff --git a/talk/base/testclient.h b/talk/base/testclient.h
new file mode 100644
index 0000000..400e58f
--- /dev/null
+++ b/talk/base/testclient.h
@@ -0,0 +1,102 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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_BASE_TESTCLIENT_H_
+#define TALK_BASE_TESTCLIENT_H_
+
+#include <vector>
+#include "talk/base/asyncudpsocket.h"
+#include "talk/base/criticalsection.h"
+
+namespace talk_base {
+
+// A simple client that can send TCP or UDP data and check that it receives
+// what it expects to receive. Useful for testing server functionality.
+class TestClient : public sigslot::has_slots<> {
+ public:
+ // Records the contents of a packet that was received.
+ struct Packet {
+ Packet(const SocketAddress& a, const char* b, size_t s);
+ Packet(const Packet& p);
+ virtual ~Packet();
+
+ SocketAddress addr;
+ char* buf;
+ size_t size;
+ };
+
+ // Creates a client that will send and receive with the given socket and
+ // will post itself messages with the given thread.
+ explicit TestClient(AsyncPacketSocket* socket);
+ ~TestClient();
+
+ SocketAddress address() const { return socket_->GetLocalAddress(); }
+ SocketAddress remote_address() const { return socket_->GetRemoteAddress(); }
+
+ // Checks that the socket moves to the specified connect state.
+ bool CheckConnState(AsyncPacketSocket::State state);
+
+ // Checks that the socket is connected to the remote side.
+ bool CheckConnected() {
+ return CheckConnState(AsyncPacketSocket::STATE_CONNECTED);
+ }
+
+ // Sends using the clients socket.
+ int Send(const char* buf, size_t size);
+
+ // Sends using the clients socket to the given destination.
+ int SendTo(const char* buf, size_t size, const SocketAddress& dest);
+
+ // Returns the next packet received by the client or 0 if none is received
+ // within a reasonable amount of time. The caller must delete the packet
+ // when done with it.
+ Packet* NextPacket();
+
+ // Checks that the next packet has the given contents. Returns the remote
+ // address that the packet was sent from.
+ bool CheckNextPacket(const char* buf, size_t len, SocketAddress* addr);
+
+ // Checks that no packets have arrived or will arrive in the next second.
+ bool CheckNoPacket();
+
+ private:
+ static const int kTimeout = 1000;
+ // Workaround for the fact that AsyncPacketSocket::GetConnState doesn't exist.
+ Socket::ConnState GetState();
+ // Slot for packets read on the socket.
+ void OnPacket(AsyncPacketSocket* socket, const char* buf, size_t len,
+ const SocketAddress& remote_addr);
+
+ CriticalSection crit_;
+ AsyncPacketSocket* socket_;
+ std::vector<Packet*>* packets_;
+ DISALLOW_EVIL_CONSTRUCTORS(TestClient);
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_TESTCLIENT_H_
diff --git a/talk/base/testclient_unittest.cc b/talk/base/testclient_unittest.cc
new file mode 100644
index 0000000..ee91067
--- /dev/null
+++ b/talk/base/testclient_unittest.cc
@@ -0,0 +1,70 @@
+/*
+ * libjingle
+ * Copyright 2006, 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/base/gunit.h"
+#include "talk/base/host.h"
+#include "talk/base/physicalsocketserver.h"
+#include "talk/base/testclient.h"
+#include "talk/base/testechoserver.h"
+#include "talk/base/thread.h"
+
+using namespace talk_base;
+
+static const SocketAddress kLocalHostAnyAddr("127.0.0.1", 0);
+
+// Tests whether the TestClient can send UDP to itself.
+TEST(TestClientTest, TestUdp) {
+ Thread *main = Thread::Current();
+ AsyncSocket* socket = main->socketserver()->CreateAsyncSocket(SOCK_DGRAM);
+ socket->Bind(kLocalHostAnyAddr);
+
+ TestClient client(new AsyncUDPSocket(socket));
+ SocketAddress addr = client.address(), from;
+ EXPECT_EQ(3, client.SendTo("foo", 3, addr));
+ EXPECT_TRUE(client.CheckNextPacket("foo", 3, &from));
+ EXPECT_EQ(from, addr);
+ EXPECT_TRUE(client.CheckNoPacket());
+}
+
+// Tests whether the TestClient can connect to a server and exchange data.
+TEST(TestClientTest, TestTcp) {
+ Thread *main = Thread::Current();
+ TestEchoServer server(main, kLocalHostAnyAddr);
+
+ AsyncSocket* socket = main->socketserver()->CreateAsyncSocket(SOCK_STREAM);
+ AsyncTCPSocket* tcp_socket = AsyncTCPSocket::Create(
+ socket, kLocalHostAnyAddr, server.address());
+ ASSERT_TRUE(tcp_socket != NULL);
+
+ TestClient client(tcp_socket);
+ SocketAddress addr = client.address(), from;
+ EXPECT_TRUE(client.CheckConnected());
+ EXPECT_EQ(3, client.Send("foo", 3));
+ EXPECT_TRUE(client.CheckNextPacket("foo", 3, &from));
+ EXPECT_EQ(from, server.address());
+ EXPECT_TRUE(client.CheckNoPacket());
+}
diff --git a/talk/base/thread.cc b/talk/base/thread.cc
index 5e0eec4..8b11485 100644
--- a/talk/base/thread.cc
+++ b/talk/base/thread.cc
@@ -36,7 +36,7 @@
#include "talk/base/common.h"
#include "talk/base/logging.h"
#include "talk/base/stringutils.h"
-#include "talk/base/time.h"
+#include "talk/base/timeutils.h"
#ifdef USE_COCOA_THREADING
#if !defined(OSX) && !defined(IOS)
@@ -48,14 +48,15 @@
namespace talk_base {
-ThreadManager g_thmgr;
+ThreadManager* ThreadManager::Instance() {
+ LIBJINGLE_DEFINE_STATIC_LOCAL(ThreadManager, thread_manager, ());
+ return &thread_manager;
+}
#ifdef POSIX
-pthread_key_t ThreadManager::key_;
-
ThreadManager::ThreadManager() {
pthread_key_create(&key_, NULL);
- main_thread_ = WrapCurrentThread();
+ WrapCurrentThread();
#ifdef USE_COCOA_THREADING
InitCocoaMultiThreading();
#endif
@@ -69,7 +70,6 @@
ScopedAutoreleasePool pool;
#endif
UnwrapCurrentThread();
- // Unwrap deletes main_thread_ automatically.
pthread_key_delete(key_);
}
@@ -77,17 +77,15 @@
return static_cast<Thread *>(pthread_getspecific(key_));
}
-void ThreadManager::SetCurrent(Thread *thread) {
+void ThreadManager::SetCurrentThread(Thread *thread) {
pthread_setspecific(key_, thread);
}
#endif
#ifdef WIN32
-DWORD ThreadManager::key_;
-
ThreadManager::ThreadManager() {
key_ = TlsAlloc();
- main_thread_ = WrapCurrentThread();
+ WrapCurrentThread();
}
ThreadManager::~ThreadManager() {
@@ -99,7 +97,7 @@
return static_cast<Thread *>(TlsGetValue(key_));
}
-void ThreadManager::SetCurrent(Thread *thread) {
+void ThreadManager::SetCurrentThread(Thread *thread) {
TlsSetValue(key_, thread);
}
#endif
@@ -109,7 +107,7 @@
Thread* result = CurrentThread();
if (NULL == result) {
result = new Thread();
- result->WrapCurrent();
+ result->WrapCurrentWithThreadManager(this);
}
return result;
}
@@ -123,25 +121,6 @@
}
}
-void ThreadManager::Add(Thread *thread) {
- CritScope cs(&crit_);
- threads_.push_back(thread);
-}
-
-void ThreadManager::Remove(Thread *thread) {
- CritScope cs(&crit_);
- threads_.erase(std::remove(threads_.begin(), threads_.end(), thread),
- threads_.end());
-}
-
-void ThreadManager::StopAllThreads_() {
- // TODO: In order to properly implement, Threads need to be ref-counted.
- CritScope cs(&g_thmgr.crit_);
- for (size_t i = 0; i < g_thmgr.threads_.size(); ++i) {
- g_thmgr.threads_[i]->Stop();
- }
-}
-
struct ThreadInit {
Thread* thread;
Runnable* runnable;
@@ -157,7 +136,6 @@
#endif
owned_(true),
delete_self_when_complete_(false) {
- g_thmgr.Add(this);
SetName("Thread", this); // default name
}
@@ -165,7 +143,6 @@
Stop();
if (active_)
Clear(NULL);
- g_thmgr.Remove(this);
}
bool Thread::SleepMs(int milliseconds) {
@@ -231,6 +208,10 @@
ASSERT(!started_);
if (started_) return false;
+ // Make sure that ThreadManager is created on the main thread before
+ // we start a new thread.
+ ThreadManager::Instance();
+
ThreadInit* init = new ThreadInit;
init->thread = this;
init->runnable = runnable;
@@ -334,7 +315,7 @@
void* Thread::PreRun(void* pv) {
ThreadInit* init = static_cast<ThreadInit*>(pv);
- ThreadManager::SetCurrent(init->thread);
+ ThreadManager::Instance()->SetCurrentThread(init->thread);
#if defined(WIN32)
SetThreadName(GetCurrentThreadId(), init->thread->name_.c_str());
#elif defined(POSIX)
@@ -509,6 +490,10 @@
}
bool Thread::WrapCurrent() {
+ return WrapCurrentWithThreadManager(ThreadManager::Instance());
+}
+
+bool Thread::WrapCurrentWithThreadManager(ThreadManager* thread_manager) {
if (started_)
return false;
#if defined(WIN32)
@@ -524,13 +509,13 @@
#endif
owned_ = false;
started_ = true;
- ThreadManager::SetCurrent(this);
+ thread_manager->SetCurrentThread(this);
return true;
}
void Thread::UnwrapCurrent() {
// Clears the platform-specific thread-specific storage.
- ThreadManager::SetCurrent(NULL);
+ ThreadManager::Instance()->SetCurrentThread(NULL);
#ifdef WIN32
if (!CloseHandle(thread_)) {
LOG_GLE(LS_ERROR) << "When unwrapping thread, failed to close handle.";
@@ -541,14 +526,14 @@
AutoThread::AutoThread(SocketServer* ss) : Thread(ss) {
- if (!ThreadManager::CurrentThread()) {
- ThreadManager::SetCurrent(this);
+ if (!ThreadManager::Instance()->CurrentThread()) {
+ ThreadManager::Instance()->SetCurrentThread(this);
}
}
AutoThread::~AutoThread() {
- if (ThreadManager::CurrentThread() == this) {
- ThreadManager::SetCurrent(NULL);
+ if (ThreadManager::Instance()->CurrentThread() == this) {
+ ThreadManager::Instance()->SetCurrentThread(NULL);
}
}
diff --git a/talk/base/thread.h b/talk/base/thread.h
index 04ceeef..13fc68c 100644
--- a/talk/base/thread.h
+++ b/talk/base/thread.h
@@ -53,10 +53,10 @@
ThreadManager();
~ThreadManager();
- static Thread *CurrentThread();
- static void SetCurrent(Thread *thread);
- void Add(Thread *thread);
- void Remove(Thread *thread);
+ static ThreadManager* Instance();
+
+ Thread* CurrentThread();
+ void SetCurrentThread(Thread* thread);
// Returns a thread object with its thread_ ivar set
// to whatever the OS uses to represent the thread.
@@ -71,22 +71,16 @@
// shame to break it. It is also conceivable on Win32 that we won't even
// be able to get synchronization privileges, in which case the result
// will have a NULL handle.
- static Thread *WrapCurrentThread();
- static void UnwrapCurrentThread();
-
- static void StopAllThreads_(); // Experimental
+ Thread *WrapCurrentThread();
+ void UnwrapCurrentThread();
private:
- Thread *main_thread_;
- std::vector<Thread *> threads_;
- CriticalSection crit_;
-
#ifdef POSIX
- static pthread_key_t key_;
+ pthread_key_t key_;
#endif
#ifdef WIN32
- static DWORD key_;
+ DWORD key_;
#endif
DISALLOW_COPY_AND_ASSIGN(ThreadManager);
@@ -126,11 +120,11 @@
virtual ~Thread();
static inline Thread* Current() {
- return ThreadManager::CurrentThread();
+ return ThreadManager::Instance()->CurrentThread();
}
bool IsCurrent() const {
- return (ThreadManager::CurrentThread() == this);
+ return ThreadManager::Instance()->CurrentThread() == this;
}
// Sleeps the calling thread for the specified number of milliseconds, during
@@ -215,6 +209,11 @@
private:
static void *PreRun(void *pv);
+ // ThreadManager calls this instead WrapCurrent() because
+ // ThreadManager::Instance() cannot be used while ThreadManager is
+ // being created.
+ bool WrapCurrentWithThreadManager(ThreadManager* thread_manager);
+
std::list<_SendMessage> sendlist_;
std::string name_;
ThreadPriority priority_;
diff --git a/talk/base/thread_unittest.cc b/talk/base/thread_unittest.cc
index a70b52d..1a3ce75 100644
--- a/talk/base/thread_unittest.cc
+++ b/talk/base/thread_unittest.cc
@@ -124,9 +124,6 @@
CustomThread() {}
virtual ~CustomThread() {}
bool Start() { return false; }
-
- bool WrapCurrent() { return talk_base::Thread::WrapCurrent(); }
- void UnwrapCurrent() { talk_base::Thread::UnwrapCurrent(); }
};
@@ -220,7 +217,7 @@
}
TEST(ThreadTest, Wrap) {
- Thread* current_thread = ThreadManager::CurrentThread();
+ Thread* current_thread = Thread::Current();
current_thread->UnwrapCurrent();
CustomThread* cthread = new CustomThread();
EXPECT_TRUE(cthread->WrapCurrent());
diff --git a/talk/base/time.h b/talk/base/time.h
index eca0e4e..8453ef5 100644
--- a/talk/base/time.h
+++ b/talk/base/time.h
@@ -1,6 +1,6 @@
/*
* libjingle
- * Copyright 2004--2005, Google Inc.
+ * Copyright 2005 Google Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
@@ -36,6 +36,15 @@
namespace talk_base {
+static const int64 kNumMillisecsPerSec = 1000;
+static const int64 kNumMicrosecsPerSec = 1000000;
+static const int64 kNumNanosecsPerSec = 1000000000;
+
+static const int64 kNumMicrosecsPerMillisec = kNumMicrosecsPerSec /
+ kNumMillisecsPerSec;
+static const int64 kNumNanosecsPerMillisec = kNumNanosecsPerSec /
+ kNumMillisecsPerSec;
+
typedef uint32 TimeStamp;
// Returns the current time in milliseconds.
diff --git a/talk/base/timeutils.cc b/talk/base/timeutils.cc
new file mode 100644
index 0000000..98ba0bc
--- /dev/null
+++ b/talk/base/timeutils.cc
@@ -0,0 +1,125 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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.
+ */
+
+#ifdef POSIX
+#include <sys/time.h>
+#endif
+
+#ifdef WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+
+#include "talk/base/common.h"
+#include "talk/base/timeutils.h"
+
+#define EFFICIENT_IMPLEMENTATION 1
+
+namespace talk_base {
+
+const uint32 LAST = 0xFFFFFFFF;
+const uint32 HALF = 0x80000000;
+
+#ifdef POSIX
+uint32 Time() {
+ struct timeval tv;
+ gettimeofday(&tv, 0);
+ return tv.tv_sec * 1000 + tv.tv_usec / 1000;
+}
+#endif
+
+#ifdef WIN32
+uint32 Time() {
+ return GetTickCount();
+}
+#endif
+
+uint32 StartTime() {
+ // Close to program execution time
+ static const uint32 g_start = Time();
+ return g_start;
+}
+
+// Make sure someone calls it so that it gets initialized
+static uint32 ignore = StartTime();
+
+uint32 TimeAfter(int32 elapsed) {
+ ASSERT(elapsed >= 0);
+ ASSERT(static_cast<uint32>(elapsed) < HALF);
+ return Time() + elapsed;
+}
+
+bool TimeIsBetween(uint32 earlier, uint32 middle, uint32 later) {
+ if (earlier <= later) {
+ return ((earlier <= middle) && (middle <= later));
+ } else {
+ return !((later < middle) && (middle < earlier));
+ }
+}
+
+bool TimeIsLaterOrEqual(uint32 earlier, uint32 later) {
+#if EFFICIENT_IMPLEMENTATION
+ int32 diff = later - earlier;
+ return (diff >= 0 && static_cast<uint32>(diff) < HALF);
+#else
+ const bool later_or_equal = TimeIsBetween(earlier, later, earlier + HALF);
+ return later_or_equal;
+#endif
+}
+
+bool TimeIsLater(uint32 earlier, uint32 later) {
+#if EFFICIENT_IMPLEMENTATION
+ int32 diff = later - earlier;
+ return (diff > 0 && static_cast<uint32>(diff) < HALF);
+#else
+ const bool earlier_or_equal = TimeIsBetween(later, earlier, later + HALF);
+ return !earlier_or_equal;
+#endif
+}
+
+int32 TimeDiff(uint32 later, uint32 earlier) {
+#if EFFICIENT_IMPLEMENTATION
+ return later - earlier;
+#else
+ const bool later_or_equal = TimeIsBetween(earlier, later, earlier + HALF);
+ if (later_or_equal) {
+ if (earlier <= later) {
+ return static_cast<long>(later - earlier);
+ } else {
+ return static_cast<long>(later + (LAST - earlier) + 1);
+ }
+ } else {
+ if (later <= earlier) {
+ return -static_cast<long>(earlier - later);
+ } else {
+ return -static_cast<long>(earlier + (LAST - later) + 1);
+ }
+ }
+#endif
+}
+
+} // namespace talk_base
diff --git a/talk/base/timeutils.h b/talk/base/timeutils.h
new file mode 100644
index 0000000..713fd77
--- /dev/null
+++ b/talk/base/timeutils.h
@@ -0,0 +1,90 @@
+/*
+ * libjingle
+ * Copyright 2005 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_BASE_TIMEUTILS_H_
+#define TALK_BASE_TIMEUTILS_H_
+
+#ifndef WIN32
+#include <time.h>
+#endif
+
+#include "talk/base/basictypes.h"
+
+namespace talk_base {
+
+static const int64 kNumMillisecsPerSec = 1000;
+static const int64 kNumMicrosecsPerSec = 1000000;
+static const int64 kNumNanosecsPerSec = 1000000000;
+
+static const int64 kNumMicrosecsPerMillisec = kNumMicrosecsPerSec /
+ kNumMillisecsPerSec;
+static const int64 kNumNanosecsPerMillisec = kNumNanosecsPerSec /
+ kNumMillisecsPerSec;
+
+typedef uint32 TimeStamp;
+
+// Returns the current time in milliseconds.
+uint32 Time();
+
+// Approximate time when the program started.
+uint32 StartTime();
+
+// Returns a future timestamp, 'elapsed' milliseconds from now.
+uint32 TimeAfter(int32 elapsed);
+
+// Comparisons between time values, which can wrap around.
+bool TimeIsBetween(uint32 earlier, uint32 middle, uint32 later); // Inclusive
+bool TimeIsLaterOrEqual(uint32 earlier, uint32 later); // Inclusive
+bool TimeIsLater(uint32 earlier, uint32 later); // Exclusive
+
+// Returns the later of two timestamps.
+inline uint32 TimeMax(uint32 ts1, uint32 ts2) {
+ return TimeIsLaterOrEqual(ts1, ts2) ? ts2 : ts1;
+}
+
+// Returns the earlier of two timestamps.
+inline uint32 TimeMin(uint32 ts1, uint32 ts2) {
+ return TimeIsLaterOrEqual(ts1, ts2) ? ts1 : ts2;
+}
+
+// Number of milliseconds that would elapse between 'earlier' and 'later'
+// timestamps. The value is negative if 'later' occurs before 'earlier'.
+int32 TimeDiff(uint32 later, uint32 earlier);
+
+// The number of milliseconds that have elapsed since 'earlier'.
+inline int32 TimeSince(uint32 earlier) {
+ return TimeDiff(Time(), earlier);
+}
+
+// The number of milliseconds that will elapse between now and 'later'.
+inline int32 TimeUntil(uint32 later) {
+ return TimeDiff(later, Time());
+}
+
+} // namespace talk_base
+
+#endif // TALK_BASE_TIMEUTILS_H_
diff --git a/talk/base/timeutils_unittest.cc b/talk/base/timeutils_unittest.cc
new file mode 100644
index 0000000..9f315ee
--- /dev/null
+++ b/talk/base/timeutils_unittest.cc
@@ -0,0 +1,136 @@
+/*
+ * libjingle
+ * Copyright 2004--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/base/common.h"
+#include "talk/base/gunit.h"
+#include "talk/base/thread.h"
+#include "talk/base/timeutils.h"
+
+namespace talk_base {
+
+TEST(TimeTest, Comparison) {
+ // Obtain two different times, in known order
+ TimeStamp ts_earlier = Time();
+ Thread::SleepMs(100);
+ TimeStamp ts_now = Time();
+ EXPECT_NE(ts_earlier, ts_now);
+
+ // Common comparisons
+ EXPECT_TRUE( TimeIsLaterOrEqual(ts_earlier, ts_now));
+ EXPECT_TRUE( TimeIsLater( ts_earlier, ts_now));
+ EXPECT_FALSE(TimeIsLaterOrEqual(ts_now, ts_earlier));
+ EXPECT_FALSE(TimeIsLater( ts_now, ts_earlier));
+
+ // Edge cases
+ EXPECT_TRUE( TimeIsLaterOrEqual(ts_earlier, ts_earlier));
+ EXPECT_FALSE(TimeIsLater( ts_earlier, ts_earlier));
+
+ // Obtain a third time
+ TimeStamp ts_later = TimeAfter(100);
+ EXPECT_NE(ts_now, ts_later);
+ EXPECT_TRUE( TimeIsLater(ts_now, ts_later));
+ EXPECT_TRUE( TimeIsLater(ts_earlier, ts_later));
+
+ // Common comparisons
+ EXPECT_TRUE( TimeIsBetween(ts_earlier, ts_now, ts_later));
+ EXPECT_FALSE(TimeIsBetween(ts_earlier, ts_later, ts_now));
+ EXPECT_FALSE(TimeIsBetween(ts_now, ts_earlier, ts_later));
+ EXPECT_TRUE( TimeIsBetween(ts_now, ts_later, ts_earlier));
+ EXPECT_TRUE( TimeIsBetween(ts_later, ts_earlier, ts_now));
+ EXPECT_FALSE(TimeIsBetween(ts_later, ts_now, ts_earlier));
+
+ // Edge cases
+ EXPECT_TRUE( TimeIsBetween(ts_earlier, ts_earlier, ts_earlier));
+ EXPECT_TRUE( TimeIsBetween(ts_earlier, ts_earlier, ts_later));
+ EXPECT_TRUE( TimeIsBetween(ts_earlier, ts_later, ts_later));
+
+ // Earlier of two times
+ EXPECT_EQ(ts_earlier, TimeMin(ts_earlier, ts_earlier));
+ EXPECT_EQ(ts_earlier, TimeMin(ts_earlier, ts_now));
+ EXPECT_EQ(ts_earlier, TimeMin(ts_earlier, ts_later));
+ EXPECT_EQ(ts_earlier, TimeMin(ts_now, ts_earlier));
+ EXPECT_EQ(ts_earlier, TimeMin(ts_later, ts_earlier));
+
+ // Later of two times
+ EXPECT_EQ(ts_earlier, TimeMax(ts_earlier, ts_earlier));
+ EXPECT_EQ(ts_now, TimeMax(ts_earlier, ts_now));
+ EXPECT_EQ(ts_later, TimeMax(ts_earlier, ts_later));
+ EXPECT_EQ(ts_now, TimeMax(ts_now, ts_earlier));
+ EXPECT_EQ(ts_later, TimeMax(ts_later, ts_earlier));
+}
+
+TEST(TimeTest, Intervals) {
+ TimeStamp ts_earlier = Time();
+ TimeStamp ts_later = TimeAfter(500);
+
+ // We can't depend on ts_later and ts_earlier to be exactly 500 apart
+ // since time elapses between the calls to Time() and TimeAfter(500)
+ EXPECT_LE(500, TimeDiff(ts_later, ts_earlier));
+ EXPECT_GE(-500, TimeDiff(ts_earlier, ts_later));
+
+ // Time has elapsed since ts_earlier
+ EXPECT_GE(TimeSince(ts_earlier), 0);
+
+ // ts_earlier is earlier than now, so TimeUntil ts_earlier is -ve
+ EXPECT_LE(TimeUntil(ts_earlier), 0);
+
+ // ts_later likely hasn't happened yet, so TimeSince could be -ve
+ // but within 500
+ EXPECT_GE(TimeSince(ts_later), -500);
+
+ // TimeUntil ts_later is at most 500
+ EXPECT_LE(TimeUntil(ts_later), 500);
+}
+
+TEST(TimeTest, BoundaryComparison) {
+ // Obtain two different times, in known order
+ TimeStamp ts_earlier = static_cast<TimeStamp>(-50);
+ TimeStamp ts_later = ts_earlier + 100;
+ EXPECT_NE(ts_earlier, ts_later);
+
+ // Common comparisons
+ EXPECT_TRUE( TimeIsLaterOrEqual(ts_earlier, ts_later));
+ EXPECT_TRUE( TimeIsLater( ts_earlier, ts_later));
+ EXPECT_FALSE(TimeIsLaterOrEqual(ts_later, ts_earlier));
+ EXPECT_FALSE(TimeIsLater( ts_later, ts_earlier));
+
+ // Earlier of two times
+ EXPECT_EQ(ts_earlier, TimeMin(ts_earlier, ts_earlier));
+ EXPECT_EQ(ts_earlier, TimeMin(ts_earlier, ts_later));
+ EXPECT_EQ(ts_earlier, TimeMin(ts_later, ts_earlier));
+
+ // Later of two times
+ EXPECT_EQ(ts_earlier, TimeMax(ts_earlier, ts_earlier));
+ EXPECT_EQ(ts_later, TimeMax(ts_earlier, ts_later));
+ EXPECT_EQ(ts_later, TimeMax(ts_later, ts_earlier));
+
+ // Interval
+ EXPECT_EQ(100, TimeDiff(ts_later, ts_earlier));
+ EXPECT_EQ(-100, TimeDiff(ts_earlier, ts_later));
+}
+
+} // namespace talk_base
diff --git a/talk/base/timing.cc b/talk/base/timing.cc
new file mode 100644
index 0000000..5e1c6c8
--- /dev/null
+++ b/talk/base/timing.cc
@@ -0,0 +1,152 @@
+/*
+ * libjingle
+ * Copyright 2008, 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/base/timing.h"
+
+#if defined(POSIX)
+#define _POSIX_C_SOURCE 199506L
+#endif
+
+#include <time.h>
+
+#if defined(POSIX)
+#include <errno.h>
+#include <math.h>
+#include <sys/time.h>
+#if defined(OSX)
+#include <mach/mach.h>
+#include <mach/clock.h>
+#endif
+#elif defined(WIN32)
+#include <sys/timeb.h>
+#include "talk/base/win32.h"
+#endif
+
+Timing::Timing() {
+#if defined(WIN32)
+ QueryPerformanceFrequency(&tick_hz_);
+
+ // This may fail, but we handle failure gracefully in the methods
+ // that use it (use alternative sleep method).
+ //
+ // TODO: Make it possible for user to tell if IdleWait will
+ // be done at lesser resolution because of this.
+ timer_handle_ = CreateWaitableTimer(NULL, // Security attributes.
+ FALSE, // Manual reset?
+ NULL); // Timer name.
+#endif
+}
+
+Timing::~Timing() {
+#if defined(WIN32)
+ if (timer_handle_ != NULL)
+ CloseHandle(timer_handle_);
+#endif
+}
+
+double Timing::WallTimeNow() {
+#if defined(POSIX)
+ struct timeval time;
+ gettimeofday(&time, NULL);
+ // Convert from second (1.0) and microsecond (1e-6).
+ return (static_cast<double>(time.tv_sec) +
+ static_cast<double>(time.tv_usec) * 1.0e-6);
+
+#elif defined(WIN32)
+ struct _timeb time;
+ _ftime(&time);
+ // Convert from second (1.0) and milliseconds (1e-3).
+ return (static_cast<double>(time.time) +
+ static_cast<double>(time.millitm) * 1.0e-3);
+#endif
+}
+
+double Timing::TimerNow() {
+#if defined(OSX)
+ // No clock_gettime on OSX.
+ clock_serv_t clock;
+ mach_timespec_t time;
+ host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &clock);
+ clock_get_time(clock, &time);
+ return (static_cast<double>(time.tv_sec) +
+ static_cast<double>(time.tv_nsec) * 1.0e-9);
+#elif defined(POSIX)
+ struct timespec time;
+ clock_gettime(CLOCK_MONOTONIC, &time);
+ // Convert from second (1.0) and nanosecond (1e-9).
+ return (static_cast<double>(time.tv_sec) +
+ static_cast<double>(time.tv_nsec) * 1.0e-9);
+
+#elif defined(WIN32)
+ LARGE_INTEGER count;
+ QueryPerformanceCounter(&count);
+ return (static_cast<double>(count.QuadPart) /
+ static_cast<double>(tick_hz_.QuadPart));
+#endif
+}
+
+double Timing::BusyWait(double period) {
+ double start_time = TimerNow();
+ while (TimerNow() - start_time < period) {
+ }
+ return TimerNow() - start_time;
+}
+
+double Timing::IdleWait(double period) {
+ double start_time = TimerNow();
+
+#if defined(POSIX)
+ double sec_int, sec_frac = modf(period, &sec_int);
+ struct timespec ts;
+ ts.tv_sec = static_cast<time_t>(sec_int);
+ ts.tv_nsec = static_cast<long>(sec_frac * 1.0e9); // NOLINT
+
+ // NOTE(liulk): for the NOLINT above, long is the appropriate POSIX
+ // type.
+
+ // POSIX nanosleep may be interrupted by signals.
+ while (nanosleep(&ts, &ts) == -1 && errno == EINTR) {
+ }
+
+#elif defined(WIN32)
+ if (timer_handle_ != NULL) {
+ LARGE_INTEGER due_time;
+
+ // Negative indicates relative time. The unit is 100 nanoseconds.
+ due_time.QuadPart = -LONGLONG(period * 1.0e7);
+
+ SetWaitableTimer(timer_handle_, &due_time, 0, NULL, NULL, TRUE);
+ WaitForSingleObject(timer_handle_, INFINITE);
+ } else {
+ // Still attempts to sleep with lesser resolution.
+ // The unit is in milliseconds.
+ Sleep(DWORD(period * 1.0e3));
+ }
+#endif
+
+ return TimerNow() - start_time;
+}
diff --git a/talk/base/timing.h b/talk/base/timing.h
new file mode 100644
index 0000000..f94daf0
--- /dev/null
+++ b/talk/base/timing.h
@@ -0,0 +1,72 @@
+/*
+ * libjingle
+ * Copyright 2008, 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_MAGICFLUTE_TESTING_TIMING_H_
+#define TALK_MAGICFLUTE_TESTING_TIMING_H_
+
+#if defined(WIN32)
+#include "talk/base/win32.h"
+#endif
+
+class Timing {
+ public:
+ Timing();
+ virtual ~Timing();
+
+ // WallTimeNow() returns the current wall-clock time in seconds,
+ // within 10 milliseconds resolution.
+ double WallTimeNow();
+
+ // TimerNow() is like WallTimeNow(), but is monotonically
+ // increasing. It returns seconds in resolution of 10 microseconds
+ // or better. Although timer and wall-clock time have the same
+ // timing unit, they do not necessarily correlate because wall-clock
+ // time may be adjusted backwards, hence not monotonic.
+ double TimerNow();
+
+ // BusyWait() exhausts CPU as long as the time elapsed is less than
+ // the specified interval in seconds. Returns the actual waiting
+ // time based on TimerNow() measurement.
+ double BusyWait(double period);
+
+ // IdleWait() relinquishes control of CPU for specified period in
+ // seconds. It uses highest resolution sleep mechanism as possible,
+ // but does not otherwise guarantee the accuracy. Returns the
+ // actual waiting time based on TimerNow() measurement.
+ //
+ // This function is not re-entrant for an object. Create a fresh
+ // Timing object for each thread.
+ double IdleWait(double period);
+
+ private:
+#if defined(WIN32)
+ LARGE_INTEGER tick_hz_;
+ HANDLE timer_handle_;
+#endif
+};
+
+#endif // TALK_MAGICFLUTE_TESTING_TIMING_H_
diff --git a/talk/base/transformadapter.cc b/talk/base/transformadapter.cc
new file mode 100644
index 0000000..53a55a8
--- /dev/null
+++ b/talk/base/transformadapter.cc
@@ -0,0 +1,202 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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/base/transformadapter.h"
+
+#include <cstring>
+
+#include "talk/base/common.h"
+
+namespace talk_base {
+
+///////////////////////////////////////////////////////////////////////////////
+
+TransformAdapter::TransformAdapter(StreamInterface * stream,
+ TransformInterface * transform,
+ bool direction_read)
+ : StreamAdapterInterface(stream), transform_(transform),
+ direction_read_(direction_read), state_(ST_PROCESSING), len_(0) {
+}
+
+TransformAdapter::~TransformAdapter() {
+ TransformAdapter::Close();
+ delete transform_;
+}
+
+StreamResult
+TransformAdapter::Read(void * buffer, size_t buffer_len,
+ size_t * read, int * error) {
+ if (!direction_read_)
+ return SR_EOS;
+
+ while (state_ != ST_ERROR) {
+ if (state_ == ST_COMPLETE)
+ return SR_EOS;
+
+ // Buffer more data
+ if ((state_ == ST_PROCESSING) && (len_ < sizeof(buffer_))) {
+ size_t subread;
+ StreamResult result = StreamAdapterInterface::Read(
+ buffer_ + len_,
+ sizeof(buffer_) - len_,
+ &subread,
+ &error_);
+ if (result == SR_BLOCK) {
+ return SR_BLOCK;
+ } else if (result == SR_ERROR) {
+ state_ = ST_ERROR;
+ break;
+ } else if (result == SR_EOS) {
+ state_ = ST_FLUSHING;
+ } else {
+ len_ += subread;
+ }
+ }
+
+ // Process buffered data
+ size_t in_len = len_;
+ size_t out_len = buffer_len;
+ StreamResult result = transform_->Transform(buffer_, &in_len,
+ buffer, &out_len,
+ (state_ == ST_FLUSHING));
+ ASSERT(result != SR_BLOCK);
+ if (result == SR_EOS) {
+ // Note: Don't signal SR_EOS this iteration, unless out_len is zero
+ state_ = ST_COMPLETE;
+ } else if (result == SR_ERROR) {
+ state_ = ST_ERROR;
+ error_ = -1; // TODO: propagate error
+ break;
+ } else if ((out_len == 0) && (state_ == ST_FLUSHING)) {
+ // If there is no output AND no more input, then something is wrong
+ state_ = ST_ERROR;
+ error_ = -1; // TODO: better error code?
+ break;
+ }
+
+ len_ -= in_len;
+ if (len_ > 0)
+ memmove(buffer_, buffer_ + in_len, len_);
+
+ if (out_len == 0)
+ continue;
+
+ if (read)
+ *read = out_len;
+ return SR_SUCCESS;
+ }
+
+ if (error)
+ *error = error_;
+ return SR_ERROR;
+}
+
+StreamResult
+TransformAdapter::Write(const void * data, size_t data_len,
+ size_t * written, int * error) {
+ if (direction_read_)
+ return SR_EOS;
+
+ size_t bytes_written = 0;
+ while (state_ != ST_ERROR) {
+ if (state_ == ST_COMPLETE)
+ return SR_EOS;
+
+ if (len_ < sizeof(buffer_)) {
+ // Process buffered data
+ size_t in_len = data_len;
+ size_t out_len = sizeof(buffer_) - len_;
+ StreamResult result = transform_->Transform(data, &in_len,
+ buffer_ + len_, &out_len,
+ (state_ == ST_FLUSHING));
+
+ ASSERT(result != SR_BLOCK);
+ if (result == SR_EOS) {
+ // Note: Don't signal SR_EOS this iteration, unless no data written
+ state_ = ST_COMPLETE;
+ } else if (result == SR_ERROR) {
+ ASSERT(false); // When this happens, think about what should be done
+ state_ = ST_ERROR;
+ error_ = -1; // TODO: propagate error
+ break;
+ }
+
+ len_ = out_len;
+ bytes_written = in_len;
+ }
+
+ size_t pos = 0;
+ while (pos < len_) {
+ size_t subwritten;
+ StreamResult result = StreamAdapterInterface::Write(buffer_ + pos,
+ len_ - pos,
+ &subwritten,
+ &error_);
+ if (result == SR_BLOCK) {
+ ASSERT(false); // TODO: we should handle this
+ return SR_BLOCK;
+ } else if (result == SR_ERROR) {
+ state_ = ST_ERROR;
+ break;
+ } else if (result == SR_EOS) {
+ state_ = ST_COMPLETE;
+ break;
+ }
+
+ pos += subwritten;
+ }
+
+ len_ -= pos;
+ if (len_ > 0)
+ memmove(buffer_, buffer_ + pos, len_);
+
+ if (bytes_written == 0)
+ continue;
+
+ if (written)
+ *written = bytes_written;
+ return SR_SUCCESS;
+ }
+
+ if (error)
+ *error = error_;
+ return SR_ERROR;
+}
+
+void
+TransformAdapter::Close() {
+ if (!direction_read_ && (state_ == ST_PROCESSING)) {
+ state_ = ST_FLUSHING;
+ do {
+ Write(0, 0, NULL, NULL);
+ } while (state_ == ST_FLUSHING);
+ }
+ state_ = ST_COMPLETE;
+ StreamAdapterInterface::Close();
+}
+
+} // namespace talk_base
diff --git a/talk/base/transformadapter.h b/talk/base/transformadapter.h
new file mode 100644
index 0000000..e96a13d
--- /dev/null
+++ b/talk/base/transformadapter.h
@@ -0,0 +1,97 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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_BASE_TRANSFORMADAPTER_H__
+#define TALK_BASE_TRANSFORMADAPTER_H__
+
+#include "talk/base/stream.h"
+
+namespace talk_base {
+///////////////////////////////////////////////////////////////////////////////
+
+class TransformInterface {
+public:
+ virtual ~TransformInterface() { }
+
+ // Transform should convert the in_len bytes of input into the out_len-sized
+ // output buffer. If flush is true, there will be no more data following
+ // input.
+ // After the transformation, in_len contains the number of bytes consumed, and
+ // out_len contains the number of bytes ready in output.
+ // Note: Transform should not return SR_BLOCK, as there is no asynchronous
+ // notification available.
+ virtual StreamResult Transform(const void * input, size_t * in_len,
+ void * output, size_t * out_len,
+ bool flush) = 0;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+// TransformAdapter causes all data passed through to be transformed by the
+// supplied TransformInterface object, which may apply compression, encryption,
+// etc.
+
+class TransformAdapter : public StreamAdapterInterface {
+public:
+ // Note that the transformation is unidirectional, in the direction specified
+ // by the constructor. Operations in the opposite direction result in SR_EOS.
+ TransformAdapter(StreamInterface * stream,
+ TransformInterface * transform,
+ bool direction_read);
+ virtual ~TransformAdapter();
+
+ virtual StreamResult Read(void * buffer, size_t buffer_len,
+ size_t * read, int * error);
+ virtual StreamResult Write(const void * data, size_t data_len,
+ size_t * written, int * error);
+ virtual void Close();
+
+ // Apriori, we can't tell what the transformation does to the stream length.
+ virtual bool GetAvailable(size_t* size) const { return false; }
+ virtual bool ReserveSize(size_t size) { return true; }
+
+ // Transformations might not be restartable
+ virtual bool Rewind() { return false; }
+
+private:
+ enum State { ST_PROCESSING, ST_FLUSHING, ST_COMPLETE, ST_ERROR };
+ enum { BUFFER_SIZE = 1024 };
+
+ TransformInterface * transform_;
+ bool direction_read_;
+ State state_;
+ int error_;
+
+ char buffer_[BUFFER_SIZE];
+ size_t len_;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+} // namespace talk_base
+
+#endif // TALK_BASE_TRANSFORMADAPTER_H__
diff --git a/talk/base/unittest_main.cc b/talk/base/unittest_main.cc
index 56fbc54..bca3671 100644
--- a/talk/base/unittest_main.cc
+++ b/talk/base/unittest_main.cc
@@ -69,7 +69,6 @@
return path;
}
-
int main(int argc, char** argv) {
testing::InitGoogleTest(&argc, argv);
FlagList::SetFlagsFromCommandLine(&argc, argv, false);
diff --git a/talk/base/unixfilesystem.cc b/talk/base/unixfilesystem.cc
index 096c511..02d0a73 100644
--- a/talk/base/unixfilesystem.cc
+++ b/talk/base/unixfilesystem.cc
@@ -483,9 +483,9 @@
existing_path.SetFolder(existing_path.parent_folder());
}
#ifdef ANDROID
- struct statfs fs;
- memset(&fs, 0, sizeof(fs));
- if (0 != statfs(existing_path.pathname().c_str(), &fs))
+ struct statfs vfs;
+ memset(&vfs, 0, sizeof(vfs));
+ if (0 != statfs(existing_path.pathname().c_str(), &vfs))
return false;
#else
struct statvfs vfs;
@@ -493,12 +493,10 @@
if (0 != statvfs(existing_path.pathname().c_str(), &vfs))
return false;
#endif // ANDROID
-#ifdef LINUX
+#if defined(LINUX) || defined(ANDROID)
*freebytes = static_cast<int64>(vfs.f_bsize) * vfs.f_bavail;
#elif defined(OSX)
*freebytes = static_cast<int64>(vfs.f_frsize) * vfs.f_bavail;
-#elif defined(ANDROID)
- *freebytes = static_cast<int64>(fs.f_bsize) * fs.f_bavail;
#endif
return true;
diff --git a/talk/base/versionparsing.cc b/talk/base/versionparsing.cc
new file mode 100644
index 0000000..03f3dec
--- /dev/null
+++ b/talk/base/versionparsing.cc
@@ -0,0 +1,74 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, 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/base/versionparsing.h"
+
+#include <cstdlib>
+
+namespace talk_base {
+
+bool ParseVersionString(const std::string& version_str,
+ int num_expected_segments,
+ int version[]) {
+ size_t pos = 0;
+ for (int i = 0;;) {
+ size_t dot_pos = version_str.find('.', pos);
+ size_t n;
+ if (dot_pos == std::string::npos) {
+ // npos here is a special value meaning "to the end of the string"
+ n = std::string::npos;
+ } else {
+ n = dot_pos - pos;
+ }
+
+ version[i] = atoi(version_str.substr(pos, n).c_str());
+
+ if (++i >= num_expected_segments) break;
+
+ if (dot_pos == std::string::npos) {
+ // Previous segment was not terminated by a dot, but there's supposed to
+ // be more segments, so that's an error.
+ return false;
+ }
+ pos = dot_pos + 1;
+ }
+ return true;
+}
+
+int CompareVersions(const int version1[],
+ const int version2[],
+ int num_segments) {
+ for (int i = 0; i < num_segments; ++i) {
+ int diff = version1[i] - version2[i];
+ if (diff != 0) {
+ return diff;
+ }
+ }
+ return 0;
+}
+
+} // namespace talk_base
diff --git a/talk/base/versionparsing.h b/talk/base/versionparsing.h
new file mode 100644
index 0000000..c66ad25
--- /dev/null
+++ b/talk/base/versionparsing.h
@@ -0,0 +1,52 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, 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_BASE_VERSIONPARSING_H_
+#define TALK_BASE_VERSIONPARSING_H_
+
+#include <string>
+
+namespace talk_base {
+
+// Parses a version string into an array. "num_expected_segments" must be the
+// number of numerical segments that the version is expected to have (e.g.,
+// "1.1.2.0" has 4). "version" must be an array of that length to hold the
+// parsed numbers.
+// Returns "true" iff successful.
+bool ParseVersionString(const std::string& version_str,
+ int num_expected_segments,
+ int version[]);
+
+// Computes the lexicographical order of two versions. The return value
+// indicates the order in the standard way (e.g., see strcmp()).
+int CompareVersions(const int version1[],
+ const int version2[],
+ int num_segments);
+
+} // namespace talk_base
+
+#endif // TALK_BASE_VERSIONPARSING_H_
diff --git a/talk/base/versionparsing_unittest.cc b/talk/base/versionparsing_unittest.cc
new file mode 100644
index 0000000..b083265
--- /dev/null
+++ b/talk/base/versionparsing_unittest.cc
@@ -0,0 +1,91 @@
+/*
+ * libjingle
+ * Copyright 2010, 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/base/versionparsing.h"
+
+#include "talk/base/gunit.h"
+
+namespace talk_base {
+
+static const int kExampleSegments = 4;
+
+typedef int ExampleVersion[kExampleSegments];
+
+TEST(VersionParsing, TestGoodParse) {
+ ExampleVersion ver;
+ std::string str1("1.1.2.0");
+ static const ExampleVersion expect1 = {1, 1, 2, 0};
+ EXPECT_TRUE(ParseVersionString(str1, kExampleSegments, ver));
+ EXPECT_EQ(0, CompareVersions(ver, expect1, kExampleSegments));
+ std::string str2("2.0.0.1");
+ static const ExampleVersion expect2 = {2, 0, 0, 1};
+ EXPECT_TRUE(ParseVersionString(str2, kExampleSegments, ver));
+ EXPECT_EQ(0, CompareVersions(ver, expect2, kExampleSegments));
+}
+
+TEST(VersionParsing, TestBadParse) {
+ ExampleVersion ver;
+ std::string str1("1.1.2");
+ EXPECT_FALSE(ParseVersionString(str1, kExampleSegments, ver));
+ std::string str2("");
+ EXPECT_FALSE(ParseVersionString(str2, kExampleSegments, ver));
+ std::string str3("garbarge");
+ EXPECT_FALSE(ParseVersionString(str3, kExampleSegments, ver));
+}
+
+TEST(VersionParsing, TestCompare) {
+ static const ExampleVersion ver1 = {1, 0, 21, 0};
+ static const ExampleVersion ver2 = {1, 1, 2, 0};
+ static const ExampleVersion ver3 = {1, 1, 3, 0};
+ static const ExampleVersion ver4 = {1, 1, 3, 9861};
+
+ // Test that every combination of comparisons has the expected outcome.
+ EXPECT_EQ(0, CompareVersions(ver1, ver1, kExampleSegments));
+ EXPECT_EQ(0, CompareVersions(ver2, ver2, kExampleSegments));
+ EXPECT_EQ(0, CompareVersions(ver3, ver3, kExampleSegments));
+ EXPECT_EQ(0, CompareVersions(ver4, ver4, kExampleSegments));
+
+ EXPECT_GT(0, CompareVersions(ver1, ver2, kExampleSegments));
+ EXPECT_LT(0, CompareVersions(ver2, ver1, kExampleSegments));
+
+ EXPECT_GT(0, CompareVersions(ver1, ver3, kExampleSegments));
+ EXPECT_LT(0, CompareVersions(ver3, ver1, kExampleSegments));
+
+ EXPECT_GT(0, CompareVersions(ver1, ver4, kExampleSegments));
+ EXPECT_LT(0, CompareVersions(ver4, ver1, kExampleSegments));
+
+ EXPECT_GT(0, CompareVersions(ver2, ver3, kExampleSegments));
+ EXPECT_LT(0, CompareVersions(ver3, ver2, kExampleSegments));
+
+ EXPECT_GT(0, CompareVersions(ver2, ver4, kExampleSegments));
+ EXPECT_LT(0, CompareVersions(ver4, ver2, kExampleSegments));
+
+ EXPECT_GT(0, CompareVersions(ver3, ver4, kExampleSegments));
+ EXPECT_LT(0, CompareVersions(ver4, ver3, kExampleSegments));
+}
+
+} // namespace talk_base
diff --git a/talk/base/virtualsocket_unittest.cc b/talk/base/virtualsocket_unittest.cc
new file mode 100644
index 0000000..93fb5ef
--- /dev/null
+++ b/talk/base/virtualsocket_unittest.cc
@@ -0,0 +1,1009 @@
+/*
+ * libjingle
+ * Copyright 2006, 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 <time.h>
+#ifdef POSIX
+#include <netinet/in.h>
+#endif
+#include <cmath>
+
+#include "talk/base/logging.h"
+#include "talk/base/gunit.h"
+#include "talk/base/testclient.h"
+#include "talk/base/testutils.h"
+#include "talk/base/thread.h"
+#include "talk/base/timeutils.h"
+#include "talk/base/virtualsocketserver.h"
+
+using namespace talk_base;
+
+// Sends at a constant rate but with random packet sizes.
+struct Sender : public MessageHandler {
+ Sender(Thread* th, AsyncSocket* s, uint32 rt)
+ : thread(th), socket(new AsyncUDPSocket(s)),
+ done(false), rate(rt), count(0) {
+ last_send = Time();
+ thread->PostDelayed(NextDelay(), this, 1);
+ }
+
+ uint32 NextDelay() {
+ uint32 size = (rand() % 4096) + 1;
+ return 1000 * size / rate;
+ }
+
+ void OnMessage(Message* pmsg) {
+ ASSERT_EQ(1u, pmsg->message_id);
+
+ if (done)
+ return;
+
+ uint32 cur_time = Time();
+ uint32 delay = cur_time - last_send;
+ uint32 size = rate * delay / 1000;
+ size = std::min<uint32>(size, 4096);
+ size = std::max<uint32>(size, sizeof(uint32));
+
+ count += size;
+ memcpy(dummy, &cur_time, sizeof(cur_time));
+ socket->Send(dummy, size);
+
+ last_send = cur_time;
+ thread->PostDelayed(NextDelay(), this, 1);
+ }
+
+ Thread* thread;
+ scoped_ptr<AsyncUDPSocket> socket;
+ bool done;
+ uint32 rate; // bytes per second
+ uint32 count;
+ uint32 last_send;
+ char dummy[4096];
+};
+
+struct Receiver : public MessageHandler, public sigslot::has_slots<> {
+ Receiver(Thread* th, AsyncSocket* s, uint32 bw)
+ : thread(th), socket(new AsyncUDPSocket(s)), bandwidth(bw), done(false),
+ count(0), sec_count(0), sum(0), sum_sq(0), samples(0) {
+ socket->SignalReadPacket.connect(this, &Receiver::OnReadPacket);
+ thread->PostDelayed(1000, this, 1);
+ }
+
+ ~Receiver() {
+ thread->Clear(this);
+ }
+
+ void OnReadPacket(AsyncPacketSocket* s, const char* data, size_t size,
+ const SocketAddress& remote_addr) {
+ ASSERT_EQ(socket.get(), s);
+ ASSERT_GE(size, 4U);
+
+ count += size;
+ sec_count += size;
+
+ uint32 send_time = *reinterpret_cast<const uint32*>(data);
+ uint32 recv_time = Time();
+ uint32 delay = recv_time - send_time;
+ sum += delay;
+ sum_sq += delay * delay;
+ samples += 1;
+ }
+
+ void OnMessage(Message* pmsg) {
+ ASSERT_EQ(1u, pmsg->message_id);
+
+ if (done)
+ return;
+
+ // It is always possible for us to receive more than expected because
+ // packets can be further delayed in delivery.
+ if (bandwidth > 0)
+ ASSERT_TRUE(sec_count <= 5 * bandwidth / 4);
+ sec_count = 0;
+ thread->PostDelayed(1000, this, 1);
+ }
+
+ Thread* thread;
+ scoped_ptr<AsyncUDPSocket> socket;
+ uint32 bandwidth;
+ bool done;
+ uint32 count;
+ uint32 sec_count;
+ double sum;
+ double sum_sq;
+ uint32 samples;
+};
+
+class VirtualSocketServerTest : public testing::Test {
+ public:
+ VirtualSocketServerTest() : ss_(new VirtualSocketServer(NULL)),
+ kIPv4AnyAddress(IPAddress(INADDR_ANY), 0),
+ kIPv6AnyAddress(IPAddress(in6addr_any), 0) {
+ }
+
+ void CheckAddressIncrementalization(const SocketAddress& post,
+ const SocketAddress& pre) {
+ EXPECT_EQ(post.port(), pre.port() + 1);
+ IPAddress post_ip = post.ipaddr();
+ IPAddress pre_ip = pre.ipaddr();
+ EXPECT_EQ(pre_ip.family(), post_ip.family());
+ if (post_ip.family() == AF_INET) {
+ in_addr pre_ipv4 = pre_ip.ipv4_address();
+ in_addr post_ipv4 = post_ip.ipv4_address();
+ int difference = ntohl(post_ipv4.s_addr) - ntohl(pre_ipv4.s_addr);
+ EXPECT_EQ(1, difference);
+ } else if (post_ip.family() == AF_INET6) {
+ in6_addr post_ip6 = post_ip.ipv6_address();
+ in6_addr pre_ip6 = pre_ip.ipv6_address();
+ uint32* post_as_ints = reinterpret_cast<uint32*>(&post_ip6.s6_addr);
+ uint32* pre_as_ints = reinterpret_cast<uint32*>(&pre_ip6.s6_addr);
+ EXPECT_EQ(post_as_ints[3], pre_as_ints[3] + 1);
+ }
+ }
+
+ void BasicTest(const SocketAddress& initial_addr) {
+ AsyncSocket* socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
+ socket->Bind(initial_addr);
+ SocketAddress server_addr = socket->GetLocalAddress();
+ // Make sure VSS didn't switch families on us.
+ EXPECT_EQ(server_addr.ipaddr().family(),
+ initial_addr.ipaddr().family());
+
+ TestClient* client1 = new TestClient(new AsyncUDPSocket(socket));
+ AsyncSocket* socket2 = ss_->CreateAsyncSocket(SOCK_DGRAM);
+ TestClient* client2 = new TestClient(new AsyncUDPSocket(socket2));
+
+ SocketAddress client2_addr;
+ EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
+ EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
+
+ SocketAddress client1_addr;
+ EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
+ EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
+ EXPECT_EQ(client1_addr, server_addr);
+
+ for (int i = 0; i < 10; i++) {
+ client2 = new TestClient(AsyncUDPSocket::Create(ss_, SocketAddress()));
+
+ SocketAddress next_client2_addr;
+ EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
+ EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &next_client2_addr));
+ CheckAddressIncrementalization(next_client2_addr, client2_addr);
+ // EXPECT_EQ(next_client2_addr.port(), client2_addr.port() + 1);
+
+ SocketAddress server_addr2;
+ EXPECT_EQ(6, client1->SendTo("bizbaz", 6, next_client2_addr));
+ EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &server_addr2));
+ EXPECT_EQ(server_addr2, server_addr);
+
+ client2_addr = next_client2_addr;
+ }
+ }
+
+ // initial_addr should be made from either INADDR_ANY or in6addr_any.
+ void ConnectTest(const SocketAddress& initial_addr) {
+ testing::StreamSink sink;
+ SocketAddress accept_addr;
+ const SocketAddress kEmptyAddr;
+
+ // Create client
+ AsyncSocket* client = ss_->CreateAsyncSocket(SOCK_STREAM);
+ sink.Monitor(client);
+ EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
+ EXPECT_EQ(client->GetLocalAddress(), kEmptyAddr);
+
+ // Create server
+ AsyncSocket* server = ss_->CreateAsyncSocket(SOCK_STREAM);
+ sink.Monitor(server);
+ EXPECT_NE(0, server->Listen(5)); // Bind required
+ EXPECT_EQ(0, server->Bind(initial_addr));
+ EXPECT_EQ(server->GetLocalAddress().ipaddr().family(),
+ initial_addr.ipaddr().family());
+ EXPECT_EQ(0, server->Listen(5));
+ EXPECT_EQ(server->GetState(), AsyncSocket::CS_CONNECTING);
+
+ // No pending server connections
+ EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
+ EXPECT_TRUE(NULL == server->Accept(&accept_addr));
+ EXPECT_EQ(accept_addr, kEmptyAddr);
+
+ // Attempt connect to listening socket
+ EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+ EXPECT_NE(client->GetLocalAddress(), kEmptyAddr); // Implicit Bind
+ EXPECT_NE(client->GetLocalAddress(), server->GetLocalAddress());
+
+ // Client is connecting
+ EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
+ EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
+
+ ss_->ProcessMessagesUntilIdle();
+
+ // Client still connecting
+ EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
+ EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
+
+ // Server has pending connection
+ EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
+ Socket* accepted = server->Accept(&accept_addr);
+ EXPECT_TRUE(NULL != accepted);
+ EXPECT_NE(accept_addr, kEmptyAddr);
+ EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
+
+ EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED);
+ EXPECT_EQ(accepted->GetLocalAddress(), server->GetLocalAddress());
+ EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
+
+ ss_->ProcessMessagesUntilIdle();
+
+ // Client has connected
+ EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTED);
+ EXPECT_TRUE(sink.Check(client, testing::SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
+ EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
+ EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
+ }
+
+ void ConnectToNonListenerTest(const SocketAddress& initial_addr) {
+ testing::StreamSink sink;
+ SocketAddress accept_addr;
+ const SocketAddress kEmptyAddr;
+
+ // Create client
+ AsyncSocket* client = ss_->CreateAsyncSocket(SOCK_STREAM);
+ sink.Monitor(client);
+
+ // Create server
+ AsyncSocket* server = ss_->CreateAsyncSocket(SOCK_STREAM);
+ sink.Monitor(server);
+ EXPECT_EQ(0, server->Bind(initial_addr));
+ EXPECT_EQ(server->GetLocalAddress().ipaddr().family(),
+ initial_addr.ipaddr().family());
+ // Attempt connect to non-listening socket
+ EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+
+ ss_->ProcessMessagesUntilIdle();
+
+ // No pending server connections
+ EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
+ EXPECT_TRUE(NULL == server->Accept(&accept_addr));
+ EXPECT_EQ(accept_addr, kEmptyAddr);
+
+ // Connection failed
+ EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
+ EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
+ EXPECT_TRUE(sink.Check(client, testing::SSE_ERROR));
+ EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr);
+ }
+
+ void CloseDuringConnectTest(const SocketAddress& initial_addr) {
+ testing::StreamSink sink;
+ SocketAddress accept_addr;
+ const SocketAddress kEmptyAddr;
+
+ // Create client and server
+ AsyncSocket* client = ss_->CreateAsyncSocket(SOCK_STREAM);
+ sink.Monitor(client);
+ AsyncSocket* server = ss_->CreateAsyncSocket(SOCK_STREAM);
+ sink.Monitor(server);
+
+ // Initiate connect
+ EXPECT_EQ(0, server->Bind(initial_addr));
+ EXPECT_EQ(server->GetLocalAddress().ipaddr().family(),
+ initial_addr.ipaddr().family());
+
+ EXPECT_EQ(0, server->Listen(5));
+ EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+
+ // Server close before socket enters accept queue
+ EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
+ server->Close();
+
+ ss_->ProcessMessagesUntilIdle();
+
+ // Result: connection failed
+ EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
+ EXPECT_TRUE(sink.Check(client, testing::SSE_ERROR));
+
+ // New server
+ delete server;
+ server = ss_->CreateAsyncSocket(SOCK_STREAM);
+ sink.Monitor(server);
+
+ // Initiate connect
+ EXPECT_EQ(0, server->Bind(initial_addr));
+ EXPECT_EQ(server->GetLocalAddress().ipaddr().family(),
+ initial_addr.ipaddr().family());
+
+ EXPECT_EQ(0, server->Listen(5));
+ EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+
+ ss_->ProcessMessagesUntilIdle();
+
+ // Server close while socket is in accept queue
+ EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
+ server->Close();
+
+ ss_->ProcessMessagesUntilIdle();
+
+ // Result: connection failed
+ EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
+ EXPECT_TRUE(sink.Check(client, testing::SSE_ERROR));
+
+ // New server
+ delete server;
+ server = ss_->CreateAsyncSocket(SOCK_STREAM);
+ sink.Monitor(server);
+
+ // Initiate connect
+ EXPECT_EQ(0, server->Bind(initial_addr));
+ EXPECT_EQ(server->GetLocalAddress().ipaddr().family(),
+ initial_addr.ipaddr().family());
+
+ EXPECT_EQ(0, server->Listen(5));
+ EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+
+ ss_->ProcessMessagesUntilIdle();
+
+ // Server accepts connection
+ EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
+ AsyncSocket* accepted = server->Accept(&accept_addr);
+ ASSERT_TRUE(NULL != accepted);
+ sink.Monitor(accepted);
+
+ // Client closes before connection complets
+ EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED);
+
+ // Connected message has not been processed yet.
+ EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
+ client->Close();
+
+ ss_->ProcessMessagesUntilIdle();
+
+ // Result: accepted socket closes
+ EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CLOSED);
+ EXPECT_TRUE(sink.Check(accepted, testing::SSE_CLOSE));
+ EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
+ }
+
+ void CloseTest(const SocketAddress& initial_addr) {
+ testing::StreamSink sink;
+ const SocketAddress kEmptyAddr;
+
+ // Create clients
+ AsyncSocket* a = ss_->CreateAsyncSocket(SOCK_STREAM);
+ sink.Monitor(a);
+ a->Bind(initial_addr);
+ EXPECT_EQ(a->GetLocalAddress().ipaddr().family(),
+ initial_addr.ipaddr().family());
+
+
+ AsyncSocket* b = ss_->CreateAsyncSocket(SOCK_STREAM);
+ sink.Monitor(b);
+ b->Bind(initial_addr);
+ EXPECT_EQ(b->GetLocalAddress().ipaddr().family(),
+ initial_addr.ipaddr().family());
+
+ EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
+ EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
+
+ ss_->ProcessMessagesUntilIdle();
+
+ EXPECT_TRUE(sink.Check(a, testing::SSE_OPEN));
+ EXPECT_EQ(a->GetState(), AsyncSocket::CS_CONNECTED);
+ EXPECT_EQ(a->GetRemoteAddress(), b->GetLocalAddress());
+
+ EXPECT_TRUE(sink.Check(b, testing::SSE_OPEN));
+ EXPECT_EQ(b->GetState(), AsyncSocket::CS_CONNECTED);
+ EXPECT_EQ(b->GetRemoteAddress(), a->GetLocalAddress());
+
+ EXPECT_EQ(1, a->Send("a", 1));
+ b->Close();
+ EXPECT_EQ(1, a->Send("b", 1));
+
+ ss_->ProcessMessagesUntilIdle();
+
+ char buffer[10];
+ EXPECT_FALSE(sink.Check(b, testing::SSE_READ));
+ EXPECT_EQ(-1, b->Recv(buffer, 10));
+
+ EXPECT_TRUE(sink.Check(a, testing::SSE_CLOSE));
+ EXPECT_EQ(a->GetState(), AsyncSocket::CS_CLOSED);
+ EXPECT_EQ(a->GetRemoteAddress(), kEmptyAddr);
+
+ EXPECT_FALSE(sink.Check(b, testing::SSE_CLOSE)); // No signal for Closer
+ EXPECT_EQ(b->GetState(), AsyncSocket::CS_CLOSED);
+ EXPECT_EQ(b->GetRemoteAddress(), kEmptyAddr);
+ }
+
+ void TcpSendTest(const SocketAddress& initial_addr) {
+ testing::StreamSink sink;
+ const SocketAddress kEmptyAddr;
+
+ // Connect two sockets
+ AsyncSocket* a = ss_->CreateAsyncSocket(SOCK_STREAM);
+ sink.Monitor(a);
+ a->Bind(initial_addr);
+ EXPECT_EQ(a->GetLocalAddress().ipaddr().family(),
+ initial_addr.ipaddr().family());
+
+ AsyncSocket* b = ss_->CreateAsyncSocket(SOCK_STREAM);
+ sink.Monitor(b);
+ b->Bind(initial_addr);
+ EXPECT_EQ(b->GetLocalAddress().ipaddr().family(),
+ initial_addr.ipaddr().family());
+
+ EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
+ EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
+
+ ss_->ProcessMessagesUntilIdle();
+
+ const size_t kBufferSize = 2000;
+ ss_->set_send_buffer_capacity(kBufferSize);
+ ss_->set_recv_buffer_capacity(kBufferSize);
+
+ const size_t kDataSize = 5000;
+ char send_buffer[kDataSize], recv_buffer[kDataSize];
+ for (size_t i = 0; i < kDataSize; ++i) send_buffer[i] = i;
+ memset(recv_buffer, 0, sizeof(recv_buffer));
+ size_t send_pos = 0, recv_pos = 0;
+
+ // Can't send more than send buffer in one write
+ int result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
+ EXPECT_EQ(static_cast<int>(kBufferSize), result);
+ send_pos += result;
+
+ ss_->ProcessMessagesUntilIdle();
+ EXPECT_FALSE(sink.Check(a, testing::SSE_WRITE));
+ EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
+
+ // Receive buffer is already filled, fill send buffer again
+ result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
+ EXPECT_EQ(static_cast<int>(kBufferSize), result);
+ send_pos += result;
+
+ ss_->ProcessMessagesUntilIdle();
+ EXPECT_FALSE(sink.Check(a, testing::SSE_WRITE));
+ EXPECT_FALSE(sink.Check(b, testing::SSE_READ));
+
+ // No more room in send or receive buffer
+ result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
+ EXPECT_EQ(-1, result);
+ EXPECT_TRUE(a->IsBlocking());
+
+ // Read a subset of the data
+ result = b->Recv(recv_buffer + recv_pos, 500);
+ EXPECT_EQ(500, result);
+ recv_pos += result;
+
+ ss_->ProcessMessagesUntilIdle();
+ EXPECT_TRUE(sink.Check(a, testing::SSE_WRITE));
+ EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
+
+ // Room for more on the sending side
+ result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
+ EXPECT_EQ(500, result);
+ send_pos += result;
+
+ // Empty the recv buffer
+ while (true) {
+ result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos);
+ if (result < 0) {
+ EXPECT_EQ(-1, result);
+ EXPECT_TRUE(b->IsBlocking());
+ break;
+ }
+ recv_pos += result;
+ }
+
+ ss_->ProcessMessagesUntilIdle();
+ EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
+
+ // Continue to empty the recv buffer
+ while (true) {
+ result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos);
+ if (result < 0) {
+ EXPECT_EQ(-1, result);
+ EXPECT_TRUE(b->IsBlocking());
+ break;
+ }
+ recv_pos += result;
+ }
+
+ // Send last of the data
+ result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
+ EXPECT_EQ(500, result);
+ send_pos += result;
+
+ ss_->ProcessMessagesUntilIdle();
+ EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
+
+ // Receive the last of the data
+ while (true) {
+ result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos);
+ if (result < 0) {
+ EXPECT_EQ(-1, result);
+ EXPECT_TRUE(b->IsBlocking());
+ break;
+ }
+ recv_pos += result;
+ }
+
+ ss_->ProcessMessagesUntilIdle();
+ EXPECT_FALSE(sink.Check(b, testing::SSE_READ));
+
+ // The received data matches the sent data
+ EXPECT_EQ(kDataSize, send_pos);
+ EXPECT_EQ(kDataSize, recv_pos);
+ EXPECT_EQ(0, memcmp(recv_buffer, send_buffer, kDataSize));
+ }
+
+ void TcpSendsPacketsInOrderTest(const SocketAddress& initial_addr) {
+ const SocketAddress kEmptyAddr;
+
+ // Connect two sockets
+ AsyncSocket* a = ss_->CreateAsyncSocket(SOCK_STREAM);
+ AsyncSocket* b = ss_->CreateAsyncSocket(SOCK_STREAM);
+ a->Bind(initial_addr);
+ EXPECT_EQ(a->GetLocalAddress().ipaddr().family(),
+ initial_addr.ipaddr().family());
+
+ b->Bind(initial_addr);
+ EXPECT_EQ(b->GetLocalAddress().ipaddr().family(),
+ initial_addr.ipaddr().family());
+
+ EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
+ EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
+ ss_->ProcessMessagesUntilIdle();
+
+ // First, deliver all packets in 0 ms.
+ char buffer[2] = { 0, 0 };
+ const size_t cNumPackets = 10;
+ for (size_t i = 0; i < cNumPackets; ++i) {
+ buffer[0] = '0' + i;
+ EXPECT_EQ(1, a->Send(buffer, 1));
+ }
+
+ ss_->ProcessMessagesUntilIdle();
+
+ for (size_t i = 0; i < cNumPackets; ++i) {
+ EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer)));
+ EXPECT_EQ(static_cast<char>('0' + i), buffer[0]);
+ }
+
+ // Next, deliver packets at random intervals
+ const uint32 mean = 50;
+ const uint32 stddev = 50;
+
+ ss_->set_delay_mean(mean);
+ ss_->set_delay_stddev(stddev);
+ ss_->UpdateDelayDistribution();
+
+ for (size_t i = 0; i < cNumPackets; ++i) {
+ buffer[0] = 'A' + i;
+ EXPECT_EQ(1, a->Send(buffer, 1));
+ }
+
+ ss_->ProcessMessagesUntilIdle();
+
+ for (size_t i = 0; i < cNumPackets; ++i) {
+ EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer)));
+ EXPECT_EQ(static_cast<char>('A' + i), buffer[0]);
+ }
+ }
+
+ void BandwidthTest(const SocketAddress& initial_addr) {
+ AsyncSocket* send_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
+ AsyncSocket* recv_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
+ ASSERT_EQ(0, send_socket->Bind(initial_addr));
+ ASSERT_EQ(0, recv_socket->Bind(initial_addr));
+ EXPECT_EQ(send_socket->GetLocalAddress().ipaddr().family(),
+ initial_addr.ipaddr().family());
+ EXPECT_EQ(recv_socket->GetLocalAddress().ipaddr().family(),
+ initial_addr.ipaddr().family());
+ ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
+
+ uint32 bandwidth = 64 * 1024;
+ ss_->set_bandwidth(bandwidth);
+
+ Thread* pthMain = Thread::Current();
+ Sender sender(pthMain, send_socket, 80 * 1024);
+ Receiver receiver(pthMain, recv_socket, bandwidth);
+
+ pthMain->ProcessMessages(5000);
+ sender.done = true;
+ pthMain->ProcessMessages(5000);
+
+ ASSERT_TRUE(receiver.count >= 5 * 3 * bandwidth / 4);
+ ASSERT_TRUE(receiver.count <= 6 * bandwidth); // queue could drain for 1s
+
+ ss_->set_bandwidth(0);
+ }
+
+ void DelayTest(const SocketAddress& initial_addr) {
+ time_t seed = ::time(NULL);
+ LOG(LS_VERBOSE) << "seed = " << seed;
+ srand(seed);
+
+ const uint32 mean = 2000;
+ const uint32 stddev = 500;
+
+ ss_->set_delay_mean(mean);
+ ss_->set_delay_stddev(stddev);
+ ss_->UpdateDelayDistribution();
+
+ AsyncSocket* send_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
+ AsyncSocket* recv_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
+ ASSERT_EQ(0, send_socket->Bind(initial_addr));
+ ASSERT_EQ(0, recv_socket->Bind(initial_addr));
+ EXPECT_EQ(send_socket->GetLocalAddress().ipaddr().family(),
+ initial_addr.ipaddr().family());
+ EXPECT_EQ(recv_socket->GetLocalAddress().ipaddr().family(),
+ initial_addr.ipaddr().family());
+ ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
+
+ Thread* pthMain = Thread::Current();
+ // Avg packet size is 2K, so at 200KB/s for 10s, we should see about
+ // 1000 packets, which is necessary to get a good distribution.
+ Sender sender(pthMain, send_socket, 100 * 2 * 1024);
+ Receiver receiver(pthMain, recv_socket, 0);
+
+ pthMain->ProcessMessages(10000);
+ sender.done = receiver.done = true;
+ ss_->ProcessMessagesUntilIdle();
+
+ const double sample_mean = receiver.sum / receiver.samples;
+ double num =
+ receiver.samples * receiver.sum_sq - receiver.sum * receiver.sum;
+ double den = receiver.samples * (receiver.samples - 1);
+ const double sample_stddev = std::sqrt(num / den);
+ LOG(LS_VERBOSE) << "mean=" << sample_mean << " stddev=" << sample_stddev;
+
+ EXPECT_LE(500u, receiver.samples);
+ // We initially used a 0.1 fudge factor, but on the build machine, we
+ // have seen the value differ by as much as 0.13.
+ EXPECT_NEAR(mean, sample_mean, 0.15 * mean);
+ EXPECT_NEAR(stddev, sample_stddev, 0.15 * stddev);
+
+ ss_->set_delay_mean(0);
+ ss_->set_delay_stddev(0);
+ ss_->UpdateDelayDistribution();
+ }
+
+ // Test cross-family communication between a client bound to client_addr and a
+ // server bound to server_addr. shouldSucceed indicates if communication is
+ // expected to work or not.
+ void CrossFamilyConnectionTest(const SocketAddress& client_addr,
+ const SocketAddress& server_addr,
+ bool shouldSucceed) {
+ testing::StreamSink sink;
+ SocketAddress accept_address;
+ const SocketAddress kEmptyAddr;
+
+ // Client gets a IPv4 address
+ AsyncSocket* client = ss_->CreateAsyncSocket(SOCK_STREAM);
+ sink.Monitor(client);
+ EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
+ EXPECT_EQ(client->GetLocalAddress(), kEmptyAddr);
+ client->Bind(client_addr);
+
+ // Server gets a non-mapped non-any IPv6 address.
+ // IPv4 sockets should not be able to connect to this.
+ AsyncSocket* server = ss_->CreateAsyncSocket(SOCK_STREAM);
+ sink.Monitor(server);
+ server->Bind(server_addr);
+ server->Listen(5);
+
+ if (shouldSucceed) {
+ EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+ ss_->ProcessMessagesUntilIdle();
+ EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
+ Socket* accepted = server->Accept(&accept_address);
+ EXPECT_TRUE(NULL != accepted);
+ EXPECT_NE(kEmptyAddr, accept_address);
+ ss_->ProcessMessagesUntilIdle();
+ EXPECT_TRUE(sink.Check(client, testing::SSE_OPEN));
+ EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
+ } else {
+ // Check that the connection failed.
+ EXPECT_EQ(-1, client->Connect(server->GetLocalAddress()));
+ ss_->ProcessMessagesUntilIdle();
+
+ EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
+ EXPECT_TRUE(NULL == server->Accept(&accept_address));
+ EXPECT_EQ(accept_address, kEmptyAddr);
+ EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
+ EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
+ EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr);
+ }
+ }
+
+ // Test cross-family datagram sending between a client bound to client_addr
+ // and a server bound to server_addr. shouldSucceed indicates if sending is
+ // expected to succed or not.
+ void CrossFamilyDatagramTest(const SocketAddress& client_addr,
+ const SocketAddress& server_addr,
+ bool shouldSucceed) {
+ AsyncSocket* socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
+ socket->Bind(server_addr);
+ SocketAddress bound_server_addr = socket->GetLocalAddress();
+ TestClient* client1 = new TestClient(new AsyncUDPSocket(socket));
+
+ AsyncSocket* socket2 = ss_->CreateAsyncSocket(SOCK_DGRAM);
+ socket2->Bind(client_addr);
+ TestClient* client2 = new TestClient(new AsyncUDPSocket(socket2));
+ SocketAddress client2_addr;
+
+ if (shouldSucceed) {
+ EXPECT_EQ(3, client2->SendTo("foo", 3, bound_server_addr));
+ EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
+ SocketAddress client1_addr;
+ EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
+ EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
+ EXPECT_EQ(client1_addr, bound_server_addr);
+ } else {
+ EXPECT_EQ(-1, client2->SendTo("foo", 3, bound_server_addr));
+ EXPECT_FALSE(client1->CheckNextPacket("foo", 3, 0));
+ }
+ }
+
+ protected:
+ virtual void SetUp() {
+ Thread::Current()->set_socketserver(ss_);
+ }
+ virtual void TearDown() {
+ Thread::Current()->set_socketserver(NULL);
+ }
+
+ VirtualSocketServer* ss_;
+ const SocketAddress kIPv4AnyAddress;
+ const SocketAddress kIPv6AnyAddress;
+};
+
+TEST_F(VirtualSocketServerTest, basic_v4) {
+ SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 5000);
+ BasicTest(ipv4_test_addr);
+}
+
+TEST_F(VirtualSocketServerTest, basic_v6) {
+ SocketAddress ipv6_test_addr(IPAddress(in6addr_any), 5000);
+ BasicTest(ipv6_test_addr);
+}
+
+TEST_F(VirtualSocketServerTest, connect_v4) {
+ ConnectTest(kIPv4AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, connect_v6) {
+ ConnectTest(kIPv6AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, connect_to_non_listener_v4) {
+ ConnectToNonListenerTest(kIPv4AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, connect_to_non_listener_v6) {
+ ConnectToNonListenerTest(kIPv6AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, close_during_connect_v4) {
+ CloseDuringConnectTest(kIPv4AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, close_during_connect_v6) {
+ CloseDuringConnectTest(kIPv6AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, close_v4) {
+ CloseTest(kIPv4AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, close_v6) {
+ CloseTest(kIPv6AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, tcp_send_v4) {
+ TcpSendTest(kIPv4AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, tcp_send_v6) {
+ TcpSendTest(kIPv6AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, TcpSendsPacketsInOrder_v4) {
+ TcpSendsPacketsInOrderTest(kIPv4AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, TcpSendsPacketsInOrder_v6) {
+ TcpSendsPacketsInOrderTest(kIPv6AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, bandwidth_v4) {
+ SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 1000);
+ BandwidthTest(ipv4_test_addr);
+}
+
+TEST_F(VirtualSocketServerTest, bandwidth_v6) {
+ SocketAddress ipv6_test_addr(IPAddress(in6addr_any), 1000);
+ BandwidthTest(ipv6_test_addr);
+}
+
+TEST_F(VirtualSocketServerTest, delay_v4) {
+ SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 1000);
+ DelayTest(ipv4_test_addr);
+}
+
+TEST_F(VirtualSocketServerTest, delay_v6) {
+ SocketAddress ipv6_test_addr(IPAddress(in6addr_any), 1000);
+ DelayTest(ipv6_test_addr);
+}
+
+// Works, receiving socket sees 127.0.0.2.
+TEST_F(VirtualSocketServerTest, CanConnectFromMappedIPv6ToIPv4Any) {
+ CrossFamilyConnectionTest(SocketAddress("::ffff:127.0.0.2", 0),
+ SocketAddress("0.0.0.0", 5000),
+ true);
+}
+
+// Fails.
+TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToIPv4Any) {
+ CrossFamilyConnectionTest(SocketAddress("::2", 0),
+ SocketAddress("0.0.0.0", 5000),
+ false);
+}
+
+// Fails.
+TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToMappedIPv6) {
+ CrossFamilyConnectionTest(SocketAddress("::2", 0),
+ SocketAddress("::ffff:127.0.0.1", 5000),
+ false);
+}
+
+// Works. receiving socket sees ::ffff:127.0.0.2.
+TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToIPv6Any) {
+ CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
+ SocketAddress("::", 5000),
+ true);
+}
+
+// Fails.
+TEST_F(VirtualSocketServerTest, CantConnectFromIPv4ToUnMappedIPv6) {
+ CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
+ SocketAddress("::1", 5000),
+ false);
+}
+
+// Works. Receiving socket sees ::ffff:127.0.0.1.
+TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToMappedIPv6) {
+ CrossFamilyConnectionTest(SocketAddress("127.0.0.1", 0),
+ SocketAddress("::ffff:127.0.0.2", 5000),
+ true);
+}
+
+// Works, receiving socket sees a result from GetNextIP.
+TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv6ToIPv4Any) {
+ CrossFamilyConnectionTest(SocketAddress("::", 0),
+ SocketAddress("0.0.0.0", 5000),
+ true);
+}
+
+// Works, receiving socket sees whatever GetNextIP gave the client.
+TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv4ToIPv6Any) {
+ CrossFamilyConnectionTest(SocketAddress(),
+ SocketAddress("::", 5000),
+ true);
+}
+
+TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv4ToIPv6Any) {
+ CrossFamilyDatagramTest(SocketAddress(),
+ SocketAddress("::", 5000),
+ true);
+}
+
+TEST_F(VirtualSocketServerTest, CanSendDatagramFromMappedIPv6ToIPv4Any) {
+ CrossFamilyDatagramTest(SocketAddress("::ffff:127.0.0.1", 0),
+ SocketAddress("0.0.0.0", 5000),
+ true);
+}
+
+TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToIPv4Any) {
+ CrossFamilyDatagramTest(SocketAddress("::2", 0),
+ SocketAddress("0.0.0.0", 5000),
+ false);
+}
+
+TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToMappedIPv6) {
+ CrossFamilyDatagramTest(SocketAddress("::2", 0),
+ SocketAddress("::ffff:127.0.0.1", 5000),
+ false);
+}
+
+TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToIPv6Any) {
+ CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
+ SocketAddress("::", 5000),
+ true);
+}
+
+TEST_F(VirtualSocketServerTest, CantSendDatagramFromIPv4ToUnMappedIPv6) {
+ CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
+ SocketAddress("::1", 5000),
+ false);
+}
+
+TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToMappedIPv6) {
+ CrossFamilyDatagramTest(SocketAddress("127.0.0.1", 0),
+ SocketAddress("::ffff:127.0.0.2", 5000),
+ true);
+}
+
+TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv6ToIPv4Any) {
+ CrossFamilyDatagramTest(SocketAddress("::", 0),
+ SocketAddress("0.0.0.0", 5000),
+ true);
+}
+
+TEST_F(VirtualSocketServerTest, CreatesStandardDistribution) {
+ const uint32 kTestMean[] = { 10, 100, 333, 1000 };
+ const double kTestDev[] = { 0.25, 0.1, 0.01 };
+ // TODO: The current code only works for 1000 data points or more.
+ const uint32 kTestSamples[] = { /*10, 100,*/ 1000 };
+ for (size_t midx = 0; midx < ARRAY_SIZE(kTestMean); ++midx) {
+ for (size_t didx = 0; didx < ARRAY_SIZE(kTestDev); ++didx) {
+ for (size_t sidx = 0; sidx < ARRAY_SIZE(kTestSamples); ++sidx) {
+ ASSERT_LT(0u, kTestSamples[sidx]);
+ const uint32 kStdDev =
+ static_cast<uint32>(kTestDev[didx] * kTestMean[midx]);
+ VirtualSocketServer::Function* f =
+ VirtualSocketServer::CreateDistribution(kTestMean[midx],
+ kStdDev,
+ kTestSamples[sidx]);
+ ASSERT_TRUE(NULL != f);
+ ASSERT_EQ(kTestSamples[sidx], f->size());
+ double sum = 0;
+ for (uint32 i = 0; i < f->size(); ++i) {
+ sum += (*f)[i].second;
+ }
+ const double mean = sum / f->size();
+ double sum_sq_dev = 0;
+ for (uint32 i = 0; i < f->size(); ++i) {
+ double dev = (*f)[i].second - mean;
+ sum_sq_dev += dev * dev;
+ }
+ const double stddev = std::sqrt(sum_sq_dev / f->size());
+ EXPECT_NEAR(kTestMean[midx], mean, 0.1 * kTestMean[midx])
+ << "M=" << kTestMean[midx]
+ << " SD=" << kStdDev
+ << " N=" << kTestSamples[sidx];
+ EXPECT_NEAR(kStdDev, stddev, 0.1 * kStdDev)
+ << "M=" << kTestMean[midx]
+ << " SD=" << kStdDev
+ << " N=" << kTestSamples[sidx];
+ delete f;
+ }
+ }
+ }
+}
diff --git a/talk/base/virtualsocketserver.cc b/talk/base/virtualsocketserver.cc
new file mode 100644
index 0000000..c18ffb6
--- /dev/null
+++ b/talk/base/virtualsocketserver.cc
@@ -0,0 +1,1102 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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/base/virtualsocketserver.h"
+
+#include <errno.h>
+
+#include <algorithm>
+#include <cmath>
+#include <map>
+#include <vector>
+
+#include "talk/base/common.h"
+#include "talk/base/logging.h"
+#include "talk/base/physicalsocketserver.h"
+#include "talk/base/socketaddresspair.h"
+#include "talk/base/thread.h"
+#include "talk/base/timeutils.h"
+
+namespace talk_base {
+#ifdef WIN32
+const in_addr kInitialNextIPv4 = { {0x01, 0, 0, 0} };
+#else
+// This value is entirely arbitrary, hence the lack of concern about endianness.
+const in_addr kInitialNextIPv4 = { 0x01000000 };
+#endif
+// Starts at ::2 so as to not cause confusion with ::1.
+const in6_addr kInitialNextIPv6 = { { {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2
+ } } };
+
+const uint16 kFirstEphemeralPort = 49152;
+const uint16 kLastEphemeralPort = 65535;
+const uint16 kEphemeralPortCount = kLastEphemeralPort - kFirstEphemeralPort + 1;
+const uint32 kDefaultNetworkCapacity = 64 * 1024;
+const uint32 kDefaultTcpBufferSize = 32 * 1024;
+
+const uint32 UDP_HEADER_SIZE = 28; // IP + UDP headers
+const uint32 TCP_HEADER_SIZE = 40; // IP + TCP headers
+const uint32 TCP_MSS = 1400; // Maximum segment size
+
+// Note: The current algorithm doesn't work for sample sizes smaller than this.
+const int NUM_SAMPLES = 1000;
+
+enum {
+ MSG_ID_PACKET,
+ MSG_ID_CONNECT,
+ MSG_ID_DISCONNECT,
+};
+
+// Packets are passed between sockets as messages. We copy the data just like
+// the kernel does.
+class Packet : public MessageData {
+ public:
+ Packet(const char* data, size_t size, const SocketAddress& from)
+ : size_(size), consumed_(0), from_(from) {
+ ASSERT(NULL != data);
+ data_ = new char[size_];
+ std::memcpy(data_, data, size_);
+ }
+
+ virtual ~Packet() {
+ delete[] data_;
+ }
+
+ const char* data() const { return data_ + consumed_; }
+ size_t size() const { return size_ - consumed_; }
+ const SocketAddress& from() const { return from_; }
+
+ // Remove the first size bytes from the data.
+ void Consume(size_t size) {
+ ASSERT(size + consumed_ < size_);
+ consumed_ += size;
+ }
+
+ private:
+ char* data_;
+ size_t size_, consumed_;
+ SocketAddress from_;
+};
+
+struct MessageAddress : public MessageData {
+ explicit MessageAddress(const SocketAddress& a) : addr(a) { }
+ SocketAddress addr;
+};
+
+// Implements the socket interface using the virtual network. Packets are
+// passed as messages using the message queue of the socket server.
+class VirtualSocket : public AsyncSocket, public MessageHandler {
+ public:
+ VirtualSocket(VirtualSocketServer* server, int type, bool async)
+ : server_(server), type_(type), async_(async), state_(CS_CLOSED),
+ listen_queue_(NULL), write_enabled_(false), network_size_(0),
+ recv_buffer_size_(0), bound_(false), was_any_(false) {
+ ASSERT((type_ == SOCK_DGRAM) || (type_ == SOCK_STREAM));
+ ASSERT(async_ || (type_ != SOCK_STREAM)); // We only support async streams
+ }
+
+ virtual ~VirtualSocket() {
+ Close();
+
+ for (RecvBuffer::iterator it = recv_buffer_.begin();
+ it != recv_buffer_.end(); ++it) {
+ delete *it;
+ }
+ }
+
+ virtual SocketAddress GetLocalAddress() const {
+ return local_addr_;
+ }
+
+ virtual SocketAddress GetRemoteAddress() const {
+ return remote_addr_;
+ }
+
+ // Used by server sockets to set the local address without binding.
+ void SetLocalAddress(const SocketAddress& addr) {
+ local_addr_ = addr;
+ }
+
+ virtual int Bind(const SocketAddress& addr) {
+ if (!local_addr_.IsAny()) {
+ error_ = EINVAL;
+ return -1;
+ }
+ local_addr_ = addr;
+ int result = server_->Bind(this, &local_addr_);
+ if (result != 0) {
+ local_addr_.Clear();
+ error_ = EADDRINUSE;
+ } else {
+ bound_ = true;
+ was_any_ = addr.IsAnyIP();
+ }
+ return result;
+ }
+
+ virtual int Connect(const SocketAddress& addr) {
+ return InitiateConnect(addr, true);
+ }
+
+ virtual int Close() {
+ if (!local_addr_.IsAny() && bound_) {
+ // Remove from the binding table.
+ server_->Unbind(local_addr_, this);
+ bound_ = false;
+ }
+
+ if (SOCK_STREAM == type_) {
+ // Cancel pending sockets
+ if (listen_queue_) {
+ while (!listen_queue_->empty()) {
+ SocketAddress addr = listen_queue_->front();
+
+ // Disconnect listening socket.
+ server_->Disconnect(server_->LookupBinding(addr));
+ listen_queue_->pop_front();
+ }
+ delete listen_queue_;
+ listen_queue_ = NULL;
+ }
+ // Disconnect stream sockets
+ if (CS_CONNECTED == state_) {
+ // Disconnect remote socket, check if it is a child of a server socket.
+ VirtualSocket* socket =
+ server_->LookupConnection(local_addr_, remote_addr_);
+ if (!socket) {
+ // Not a server socket child, then see if it is bound.
+ // TODO: If this is indeed a server socket that has no
+ // children this will cause the server socket to be
+ // closed. This might lead to unexpected results, how to fix this?
+ socket = server_->LookupBinding(remote_addr_);
+ }
+ server_->Disconnect(socket);
+
+ // Remove mapping for both directions.
+ server_->RemoveConnection(remote_addr_, local_addr_);
+ server_->RemoveConnection(local_addr_, remote_addr_);
+ }
+ // Cancel potential connects
+ MessageList msgs;
+ if (server_->msg_queue_) {
+ server_->msg_queue_->Clear(this, MSG_ID_CONNECT, &msgs);
+ }
+ for (MessageList::iterator it = msgs.begin(); it != msgs.end(); ++it) {
+ ASSERT(NULL != it->pdata);
+ MessageAddress* data = static_cast<MessageAddress*>(it->pdata);
+
+ // Lookup remote side.
+ VirtualSocket* socket = server_->LookupConnection(local_addr_,
+ data->addr);
+ if (socket) {
+ // Server socket, remote side is a socket retreived by
+ // accept. Accepted sockets are not bound so we will not
+ // find it by looking in the bindings table.
+ server_->Disconnect(socket);
+ server_->RemoveConnection(local_addr_, data->addr);
+ } else {
+ server_->Disconnect(server_->LookupBinding(data->addr));
+ }
+ delete data;
+ }
+ // Clear incoming packets and disconnect messages
+ if (server_->msg_queue_) {
+ server_->msg_queue_->Clear(this);
+ }
+ }
+
+ state_ = CS_CLOSED;
+ local_addr_.Clear();
+ remote_addr_.Clear();
+ return 0;
+ }
+
+ virtual int Send(const void *pv, size_t cb) {
+ if (CS_CONNECTED != state_) {
+ error_ = ENOTCONN;
+ return -1;
+ }
+ if (SOCK_DGRAM == type_) {
+ return SendUdp(pv, cb, remote_addr_);
+ } else {
+ return SendTcp(pv, cb);
+ }
+ }
+
+ virtual int SendTo(const void *pv, size_t cb, const SocketAddress& addr) {
+ if (SOCK_DGRAM == type_) {
+ return SendUdp(pv, cb, addr);
+ } else {
+ if (CS_CONNECTED != state_) {
+ error_ = ENOTCONN;
+ return -1;
+ }
+ return SendTcp(pv, cb);
+ }
+ }
+
+ virtual int Recv(void *pv, size_t cb) {
+ SocketAddress addr;
+ return RecvFrom(pv, cb, &addr);
+ }
+
+ virtual int RecvFrom(void *pv, size_t cb, SocketAddress *paddr) {
+ // If we don't have a packet, then either error or wait for one to arrive.
+ if (recv_buffer_.empty()) {
+ if (async_) {
+ error_ = EAGAIN;
+ return -1;
+ }
+ while (recv_buffer_.empty()) {
+ Message msg;
+ server_->msg_queue_->Get(&msg);
+ server_->msg_queue_->Dispatch(&msg);
+ }
+ }
+
+ // Return the packet at the front of the queue.
+ Packet* packet = recv_buffer_.front();
+ size_t data_read = _min(cb, packet->size());
+ std::memcpy(pv, packet->data(), data_read);
+ *paddr = packet->from();
+
+ if (data_read < packet->size()) {
+ packet->Consume(data_read);
+ } else {
+ recv_buffer_.pop_front();
+ delete packet;
+ }
+
+ if (SOCK_STREAM == type_) {
+ bool was_full = (recv_buffer_size_ == server_->recv_buffer_capacity_);
+ recv_buffer_size_ -= data_read;
+ if (was_full) {
+ VirtualSocket* sender = server_->LookupBinding(remote_addr_);
+ ASSERT(NULL != sender);
+ server_->SendTcp(sender);
+ }
+ }
+
+ return static_cast<int>(data_read);
+ }
+
+ virtual int Listen(int backlog) {
+ ASSERT(SOCK_STREAM == type_);
+ ASSERT(CS_CLOSED == state_);
+ if (local_addr_.IsAny()) {
+ error_ = EINVAL;
+ return -1;
+ }
+ ASSERT(NULL == listen_queue_);
+ listen_queue_ = new ListenQueue;
+ state_ = CS_CONNECTING;
+ return 0;
+ }
+
+ virtual VirtualSocket* Accept(SocketAddress *paddr) {
+ if (NULL == listen_queue_) {
+ error_ = EINVAL;
+ return NULL;
+ }
+ while (!listen_queue_->empty()) {
+ VirtualSocket* socket = new VirtualSocket(server_, type_, async_);
+
+ // Set the new local address to the same as this server socket.
+ socket->SetLocalAddress(local_addr_);
+ // Sockets made from a socket that 'was Any' need to inherit that.
+ socket->set_was_any(was_any_);
+ SocketAddress remote_addr(listen_queue_->front());
+ int result = socket->InitiateConnect(remote_addr, false);
+ listen_queue_->pop_front();
+ if (result != 0) {
+ delete socket;
+ continue;
+ }
+ socket->CompleteConnect(remote_addr, false);
+ if (paddr) {
+ *paddr = remote_addr;
+ }
+ return socket;
+ }
+ error_ = EWOULDBLOCK;
+ return NULL;
+ }
+
+ virtual int GetError() const {
+ return error_;
+ }
+
+ virtual void SetError(int error) {
+ error_ = error;
+ }
+
+ virtual ConnState GetState() const {
+ return state_;
+ }
+
+ virtual int GetOption(Option opt, int* value) {
+ OptionsMap::const_iterator it = options_map_.find(opt);
+ if (it == options_map_.end()) {
+ return -1;
+ }
+ *value = it->second;
+ return 0; // 0 is success to emulate getsockopt()
+ }
+
+ virtual int SetOption(Option opt, int value) {
+ options_map_[opt] = value;
+ return 0; // 0 is success to emulate setsockopt()
+ }
+
+ virtual int EstimateMTU(uint16* mtu) {
+ if (CS_CONNECTED != state_)
+ return ENOTCONN;
+ else
+ return 65536;
+ }
+
+ void OnMessage(Message *pmsg) {
+ if (pmsg->message_id == MSG_ID_PACKET) {
+ //ASSERT(!local_addr_.IsAny());
+ ASSERT(NULL != pmsg->pdata);
+ Packet* packet = static_cast<Packet*>(pmsg->pdata);
+
+ recv_buffer_.push_back(packet);
+
+ if (async_) {
+ SignalReadEvent(this);
+ }
+ } else if (pmsg->message_id == MSG_ID_CONNECT) {
+ ASSERT(NULL != pmsg->pdata);
+ MessageAddress* data = static_cast<MessageAddress*>(pmsg->pdata);
+ if (listen_queue_ != NULL) {
+ listen_queue_->push_back(data->addr);
+ if (async_) {
+ SignalReadEvent(this);
+ }
+ } else if ((SOCK_STREAM == type_) && (CS_CONNECTING == state_)) {
+ CompleteConnect(data->addr, true);
+ } else {
+ LOG(LS_VERBOSE) << "Socket at " << local_addr_ << " is not listening";
+ server_->Disconnect(server_->LookupBinding(data->addr));
+ }
+ delete data;
+ } else if (pmsg->message_id == MSG_ID_DISCONNECT) {
+ ASSERT(SOCK_STREAM == type_);
+ if (CS_CLOSED != state_) {
+ int error = (CS_CONNECTING == state_) ? ECONNREFUSED : 0;
+ state_ = CS_CLOSED;
+ remote_addr_.Clear();
+ if (async_) {
+ SignalCloseEvent(this, error);
+ }
+ }
+ } else {
+ ASSERT(false);
+ }
+ }
+
+ bool was_any() { return was_any_; }
+ void set_was_any(bool was_any) { was_any_ = was_any; }
+
+ private:
+ struct NetworkEntry {
+ uint32 size;
+ uint32 done_time;
+ };
+
+ typedef std::deque<SocketAddress> ListenQueue;
+ typedef std::deque<NetworkEntry> NetworkQueue;
+ typedef std::vector<char> SendBuffer;
+ typedef std::list<Packet*> RecvBuffer;
+ typedef std::map<Option, int> OptionsMap;
+
+ int InitiateConnect(const SocketAddress& addr, bool use_delay) {
+ if (!remote_addr_.IsAny()) {
+ error_ = (CS_CONNECTED == state_) ? EISCONN : EINPROGRESS;
+ return -1;
+ }
+ if (local_addr_.IsAny()) {
+ // If there's no local address set, grab a random one in the correct AF.
+ int result = 0;
+ if (addr.ipaddr().family() == AF_INET) {
+ result = Bind(SocketAddress("0.0.0.0", 0));
+ } else if (addr.ipaddr().family() == AF_INET6) {
+ result = Bind(SocketAddress("::", 0));
+ }
+ if (result != 0) {
+ return result;
+ }
+ }
+ if (type_ == SOCK_DGRAM) {
+ remote_addr_ = addr;
+ state_ = CS_CONNECTED;
+ } else {
+ int result = server_->Connect(this, addr, use_delay);
+ if (result != 0) {
+ error_ = EHOSTUNREACH;
+ return -1;
+ }
+ state_ = CS_CONNECTING;
+ }
+ return 0;
+ }
+
+ void CompleteConnect(const SocketAddress& addr, bool notify) {
+ ASSERT(CS_CONNECTING == state_);
+ remote_addr_ = addr;
+ state_ = CS_CONNECTED;
+ server_->AddConnection(remote_addr_, local_addr_, this);
+ if (async_ && notify) {
+ SignalConnectEvent(this);
+ }
+ }
+
+ int SendUdp(const void* pv, size_t cb, const SocketAddress& addr) {
+ // If we have not been assigned a local port, then get one.
+ if (local_addr_.IsAny()) {
+ int result = server_->Bind(this, &local_addr_);
+ if (result != 0) {
+ local_addr_.Clear();
+ error_ = EADDRINUSE;
+ return result;
+ }
+ }
+
+ // Send the data in a message to the appropriate socket.
+ return server_->SendUdp(this, static_cast<const char*>(pv), cb, addr);
+ }
+
+ int SendTcp(const void* pv, size_t cb) {
+ size_t capacity = server_->send_buffer_capacity_ - send_buffer_.size();
+ if (0 == capacity) {
+ write_enabled_ = true;
+ error_ = EWOULDBLOCK;
+ return -1;
+ }
+ size_t consumed = _min(cb, capacity);
+ const char* cpv = static_cast<const char*>(pv);
+ send_buffer_.insert(send_buffer_.end(), cpv, cpv + consumed);
+ server_->SendTcp(this);
+ return consumed;
+ }
+
+ VirtualSocketServer* server_;
+ int type_;
+ bool async_;
+ ConnState state_;
+ int error_;
+ SocketAddress local_addr_;
+ SocketAddress remote_addr_;
+
+ // Pending sockets which can be Accepted
+ ListenQueue* listen_queue_;
+
+ // Data which tcp has buffered for sending
+ SendBuffer send_buffer_;
+ bool write_enabled_;
+
+ // Critical section to protect the recv_buffer and queue_
+ CriticalSection crit_;
+
+ // Network model that enforces bandwidth and capacity constraints
+ NetworkQueue network_;
+ uint32 network_size_;
+
+ // Data which has been received from the network
+ RecvBuffer recv_buffer_;
+ // The amount of data which is in flight or in recv_buffer_
+ uint32 recv_buffer_size_;
+
+ // Is this socket bound?
+ bool bound_;
+
+ // When we bind a socket to Any, VSS's Bind gives it another address. For
+ // dual-stack sockets, we want to distinguish between sockets that were
+ // explicitly given a particular address and sockets that had one picked
+ // for them by VSS.
+ bool was_any_;
+
+ // Store the options that are set
+ OptionsMap options_map_;
+
+ friend class VirtualSocketServer;
+};
+
+VirtualSocketServer::VirtualSocketServer(SocketServer* ss)
+ : server_(ss), server_owned_(false), msg_queue_(NULL), stop_on_idle_(false),
+ network_delay_(Time()), next_ipv4_(kInitialNextIPv4),
+ next_ipv6_(kInitialNextIPv6), next_port_(kFirstEphemeralPort),
+ bindings_(new AddressMap()), connections_(new ConnectionMap()),
+ bandwidth_(0), network_capacity_(kDefaultNetworkCapacity),
+ send_buffer_capacity_(kDefaultTcpBufferSize),
+ recv_buffer_capacity_(kDefaultTcpBufferSize),
+ delay_mean_(0), delay_stddev_(0), delay_samples_(NUM_SAMPLES),
+ delay_dist_(NULL), drop_prob_(0.0) {
+ if (!server_) {
+ server_ = new PhysicalSocketServer();
+ server_owned_ = true;
+ }
+ UpdateDelayDistribution();
+}
+
+VirtualSocketServer::~VirtualSocketServer() {
+ delete bindings_;
+ delete connections_;
+ delete delay_dist_;
+ if (server_owned_) {
+ delete server_;
+ }
+}
+
+IPAddress VirtualSocketServer::GetNextIP(int family) {
+ if (family == AF_INET) {
+ IPAddress next_ip(next_ipv4_);
+ next_ipv4_.s_addr = htonl(ntohl(next_ipv4_.s_addr) + 1);
+ return next_ip;
+ } else if (family == AF_INET6) {
+ IPAddress next_ip(next_ipv6_);
+ uint32* as_ints = reinterpret_cast<uint32*>(&next_ipv6_.s6_addr);
+ as_ints[3] += 1;
+ return next_ip;
+ }
+ return IPAddress();
+}
+
+uint16 VirtualSocketServer::GetNextPort() {
+ uint16 port = next_port_;
+ if (next_port_ < kLastEphemeralPort) {
+ ++next_port_;
+ } else {
+ next_port_ = kFirstEphemeralPort;
+ }
+ return port;
+}
+
+Socket* VirtualSocketServer::CreateSocket(int type) {
+ return CreateSocketInternal(type);
+}
+
+AsyncSocket* VirtualSocketServer::CreateAsyncSocket(int type) {
+ return CreateSocketInternal(type);
+}
+
+VirtualSocket* VirtualSocketServer::CreateSocketInternal(int type) {
+ return new VirtualSocket(this, type, true);
+}
+
+void VirtualSocketServer::SetMessageQueue(MessageQueue* msg_queue) {
+ msg_queue_ = msg_queue;
+ if (msg_queue_) {
+ msg_queue_->SignalQueueDestroyed.connect(this,
+ &VirtualSocketServer::OnMessageQueueDestroyed);
+ }
+}
+
+bool VirtualSocketServer::Wait(int cmsWait, bool process_io) {
+ ASSERT(msg_queue_ == Thread::Current());
+ if (stop_on_idle_ && Thread::Current()->empty()) {
+ return false;
+ }
+ return socketserver()->Wait(cmsWait, process_io);
+}
+
+void VirtualSocketServer::WakeUp() {
+ socketserver()->WakeUp();
+}
+
+bool VirtualSocketServer::ProcessMessagesUntilIdle() {
+ ASSERT(msg_queue_ == Thread::Current());
+ stop_on_idle_ = true;
+ while (!msg_queue_->empty()) {
+ Message msg;
+ if (msg_queue_->Get(&msg, kForever)) {
+ msg_queue_->Dispatch(&msg);
+ }
+ }
+ stop_on_idle_ = false;
+ return !msg_queue_->IsQuitting();
+}
+
+int VirtualSocketServer::Bind(VirtualSocket* socket,
+ const SocketAddress& addr) {
+ ASSERT(NULL != socket);
+ // Address must be completely specified at this point
+ ASSERT(!IPIsAny(addr.ipaddr()));
+ ASSERT(addr.port() != 0);
+
+ // Normalize the address (turns v6-mapped addresses into v4-addresses).
+ SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
+
+ AddressMap::value_type entry(normalized, socket);
+ return bindings_->insert(entry).second ? 0 : -1;
+}
+
+int VirtualSocketServer::Bind(VirtualSocket* socket, SocketAddress* addr) {
+ ASSERT(NULL != socket);
+
+ if (IPIsAny(addr->ipaddr())) {
+ addr->SetIP(GetNextIP(addr->ipaddr().family()));
+ } else {
+ addr->SetIP(addr->ipaddr().Normalized());
+ }
+
+ if (addr->port() == 0) {
+ for (int i = 0; i < kEphemeralPortCount; ++i) {
+ addr->SetPort(GetNextPort());
+ if (bindings_->find(*addr) == bindings_->end()) {
+ break;
+ }
+ }
+ }
+
+ return Bind(socket, *addr);
+}
+
+VirtualSocket* VirtualSocketServer::LookupBinding(const SocketAddress& addr) {
+ SocketAddress normalized(addr.ipaddr().Normalized(),
+ addr.port());
+ AddressMap::iterator it = bindings_->find(normalized);
+ return (bindings_->end() != it) ? it->second : NULL;
+}
+
+int VirtualSocketServer::Unbind(const SocketAddress& addr,
+ VirtualSocket* socket) {
+ SocketAddress normalized(addr.ipaddr().Normalized(),
+ addr.port());
+ ASSERT((*bindings_)[normalized] == socket);
+ bindings_->erase(bindings_->find(normalized));
+ return 0;
+}
+
+void VirtualSocketServer::AddConnection(const SocketAddress& local,
+ const SocketAddress& remote,
+ VirtualSocket* remote_socket) {
+ // Add this socket pair to our routing table. This will allow
+ // multiple clients to connect to the same server address.
+ SocketAddress local_normalized(local.ipaddr().Normalized(),
+ local.port());
+ SocketAddress remote_normalized(remote.ipaddr().Normalized(),
+ remote.port());
+ SocketAddressPair address_pair(local_normalized, remote_normalized);
+ connections_->insert(std::pair<SocketAddressPair,
+ VirtualSocket*>(address_pair, remote_socket));
+}
+
+VirtualSocket* VirtualSocketServer::LookupConnection(
+ const SocketAddress& local,
+ const SocketAddress& remote) {
+ SocketAddress local_normalized(local.ipaddr().Normalized(),
+ local.port());
+ SocketAddress remote_normalized(remote.ipaddr().Normalized(),
+ remote.port());
+ SocketAddressPair address_pair(local_normalized, remote_normalized);
+ ConnectionMap::iterator it = connections_->find(address_pair);
+ return (connections_->end() != it) ? it->second : NULL;
+}
+
+void VirtualSocketServer::RemoveConnection(const SocketAddress& local,
+ const SocketAddress& remote) {
+ SocketAddress local_normalized(local.ipaddr().Normalized(),
+ local.port());
+ SocketAddress remote_normalized(remote.ipaddr().Normalized(),
+ remote.port());
+ SocketAddressPair address_pair(local_normalized, remote_normalized);
+ connections_->erase(address_pair);
+}
+
+static double Random() {
+ return static_cast<double>(rand()) / RAND_MAX;
+}
+
+int VirtualSocketServer::Connect(VirtualSocket* socket,
+ const SocketAddress& remote_addr,
+ bool use_delay) {
+ uint32 delay = use_delay ? GetRandomTransitDelay() : 0;
+ VirtualSocket* remote = LookupBinding(remote_addr);
+ if (!CanInteractWith(socket, remote)) {
+ LOG(LS_INFO) << "Address family mismatch between "
+ << socket->GetLocalAddress() << " and " << remote_addr;
+ return -1;
+ }
+ if (remote != NULL) {
+ SocketAddress addr = socket->GetLocalAddress();
+ msg_queue_->PostDelayed(delay, remote, MSG_ID_CONNECT,
+ new MessageAddress(addr));
+ } else {
+ LOG(LS_INFO) << "No one listening at " << remote_addr;
+ msg_queue_->PostDelayed(delay, socket, MSG_ID_DISCONNECT);
+ }
+ return 0;
+}
+
+bool VirtualSocketServer::Disconnect(VirtualSocket* socket) {
+ if (socket) {
+ // Remove the mapping.
+ msg_queue_->Post(socket, MSG_ID_DISCONNECT);
+ return true;
+ }
+ return false;
+}
+
+int VirtualSocketServer::SendUdp(VirtualSocket* socket,
+ const char* data, size_t data_size,
+ const SocketAddress& remote_addr) {
+ // See if we want to drop this packet.
+ if (Random() < drop_prob_) {
+ LOG(LS_VERBOSE) << "Dropping packet: bad luck";
+ return static_cast<int>(data_size);
+ }
+
+ VirtualSocket* recipient = LookupBinding(remote_addr);
+ if (!recipient) {
+ // Make a fake recipient for address family checking.
+ scoped_ptr<VirtualSocket> dummy_socket(CreateSocketInternal(SOCK_DGRAM));
+ dummy_socket->SetLocalAddress(remote_addr);
+ if (!CanInteractWith(socket, dummy_socket.get())) {
+ LOG(LS_VERBOSE) << "Incompatible address families: "
+ << socket->GetLocalAddress() << " and " << remote_addr;
+ return -1;
+ }
+ LOG(LS_VERBOSE) << "No one listening at " << remote_addr;
+ return static_cast<int>(data_size);
+ }
+
+ if (!CanInteractWith(socket, recipient)) {
+ LOG(LS_VERBOSE) << "Incompatible address families: "
+ << socket->GetLocalAddress() << " and " << remote_addr;
+ return -1;
+ }
+
+ CritScope cs(&socket->crit_);
+
+ uint32 cur_time = Time();
+ PurgeNetworkPackets(socket, cur_time);
+
+ // Determine whether we have enough bandwidth to accept this packet. To do
+ // this, we need to update the send queue. Once we know it's current size,
+ // we know whether we can fit this packet.
+ //
+ // NOTE: There are better algorithms for maintaining such a queue (such as
+ // "Derivative Random Drop"); however, this algorithm is a more accurate
+ // simulation of what a normal network would do.
+
+ size_t packet_size = data_size + UDP_HEADER_SIZE;
+ if (socket->network_size_ + packet_size > network_capacity_) {
+ LOG(LS_VERBOSE) << "Dropping packet: network capacity exceeded";
+ return static_cast<int>(data_size);
+ }
+
+ AddPacketToNetwork(socket, recipient, cur_time, data, data_size,
+ UDP_HEADER_SIZE, false);
+
+ return static_cast<int>(data_size);
+}
+
+void VirtualSocketServer::SendTcp(VirtualSocket* socket) {
+ // TCP can't send more data than will fill up the receiver's buffer.
+ // We track the data that is in the buffer plus data in flight using the
+ // recipient's recv_buffer_size_. Anything beyond that must be stored in the
+ // sender's buffer. We will trigger the buffered data to be sent when data
+ // is read from the recv_buffer.
+
+ // Lookup the local/remote pair in the connections table.
+ VirtualSocket* recipient = LookupConnection(socket->local_addr_,
+ socket->remote_addr_);
+ if (!recipient) {
+ LOG(LS_VERBOSE) << "Sending data to no one.";
+ return;
+ }
+
+ CritScope cs(&socket->crit_);
+
+ uint32 cur_time = Time();
+ PurgeNetworkPackets(socket, cur_time);
+
+ while (true) {
+ size_t available = recv_buffer_capacity_ - recipient->recv_buffer_size_;
+ size_t max_data_size = _min<size_t>(available, TCP_MSS - TCP_HEADER_SIZE);
+ size_t data_size = _min(socket->send_buffer_.size(), max_data_size);
+ if (0 == data_size)
+ break;
+
+ AddPacketToNetwork(socket, recipient, cur_time, &socket->send_buffer_[0],
+ data_size, TCP_HEADER_SIZE, true);
+ recipient->recv_buffer_size_ += data_size;
+
+ size_t new_buffer_size = socket->send_buffer_.size() - data_size;
+ // Avoid undefined access beyond the last element of the vector.
+ // This only happens when new_buffer_size is 0.
+ if (data_size < socket->send_buffer_.size()) {
+ // memmove is required for potentially overlapping source/destination.
+ memmove(&socket->send_buffer_[0], &socket->send_buffer_[data_size],
+ new_buffer_size);
+ }
+ socket->send_buffer_.resize(new_buffer_size);
+ }
+
+ if (socket->write_enabled_
+ && (socket->send_buffer_.size() < send_buffer_capacity_)) {
+ socket->write_enabled_ = false;
+ socket->SignalWriteEvent(socket);
+ }
+}
+
+void VirtualSocketServer::AddPacketToNetwork(VirtualSocket* sender,
+ VirtualSocket* recipient,
+ uint32 cur_time,
+ const char* data,
+ size_t data_size,
+ size_t header_size,
+ bool ordered) {
+ VirtualSocket::NetworkEntry entry;
+ entry.size = data_size + header_size;
+
+ sender->network_size_ += entry.size;
+ uint32 send_delay = SendDelay(sender->network_size_);
+ entry.done_time = cur_time + send_delay;
+ sender->network_.push_back(entry);
+
+ // Find the delay for crossing the many virtual hops of the network.
+ uint32 transit_delay = GetRandomTransitDelay();
+
+ // Post the packet as a message to be delivered (on our own thread)
+ Packet* p = new Packet(data, data_size, sender->local_addr_);
+ uint32 ts = TimeAfter(send_delay + transit_delay);
+ if (ordered) {
+ // Ensure that new packets arrive after previous ones
+ // TODO: consider ordering on a per-socket basis, since this
+ // introduces artifical delay.
+ ts = TimeMax(ts, network_delay_);
+ }
+ msg_queue_->PostAt(ts, recipient, MSG_ID_PACKET, p);
+ network_delay_ = TimeMax(ts, network_delay_);
+}
+
+void VirtualSocketServer::PurgeNetworkPackets(VirtualSocket* socket,
+ uint32 cur_time) {
+ while (!socket->network_.empty() &&
+ (socket->network_.front().done_time <= cur_time)) {
+ ASSERT(socket->network_size_ >= socket->network_.front().size);
+ socket->network_size_ -= socket->network_.front().size;
+ socket->network_.pop_front();
+ }
+}
+
+uint32 VirtualSocketServer::SendDelay(uint32 size) {
+ if (bandwidth_ == 0)
+ return 0;
+ else
+ return 1000 * size / bandwidth_;
+}
+
+#if 0
+void PrintFunction(std::vector<std::pair<double, double> >* f) {
+ return;
+ double sum = 0;
+ for (uint32 i = 0; i < f->size(); ++i) {
+ std::cout << (*f)[i].first << '\t' << (*f)[i].second << std::endl;
+ sum += (*f)[i].second;
+ }
+ if (!f->empty()) {
+ const double mean = sum / f->size();
+ double sum_sq_dev = 0;
+ for (uint32 i = 0; i < f->size(); ++i) {
+ double dev = (*f)[i].second - mean;
+ sum_sq_dev += dev * dev;
+ }
+ std::cout << "Mean = " << mean << " StdDev = "
+ << sqrt(sum_sq_dev / f->size()) << std::endl;
+ }
+}
+#endif // <unused>
+
+void VirtualSocketServer::UpdateDelayDistribution() {
+ Function* dist = CreateDistribution(delay_mean_, delay_stddev_,
+ delay_samples_);
+ // We take a lock just to make sure we don't leak memory.
+ {
+ CritScope cs(&delay_crit_);
+ delete delay_dist_;
+ delay_dist_ = dist;
+ }
+}
+
+static double PI = 4 * std::atan(1.0);
+
+static double Normal(double x, double mean, double stddev) {
+ double a = (x - mean) * (x - mean) / (2 * stddev * stddev);
+ return std::exp(-a) / (stddev * sqrt(2 * PI));
+}
+
+#if 0 // static unused gives a warning
+static double Pareto(double x, double min, double k) {
+ if (x < min)
+ return 0;
+ else
+ return k * std::pow(min, k) / std::pow(x, k+1);
+}
+#endif
+
+VirtualSocketServer::Function* VirtualSocketServer::CreateDistribution(
+ uint32 mean, uint32 stddev, uint32 samples) {
+ Function* f = new Function();
+
+ if (0 == stddev) {
+ f->push_back(Point(mean, 1.0));
+ } else {
+ double start = 0;
+ if (mean >= 4 * static_cast<double>(stddev))
+ start = mean - 4 * static_cast<double>(stddev);
+ double end = mean + 4 * static_cast<double>(stddev);
+
+ for (uint32 i = 0; i < samples; i++) {
+ double x = start + (end - start) * i / (samples - 1);
+ double y = Normal(x, mean, stddev);
+ f->push_back(Point(x, y));
+ }
+ }
+ return Resample(Invert(Accumulate(f)), 0, 1, samples);
+}
+
+uint32 VirtualSocketServer::GetRandomTransitDelay() {
+ size_t index = rand() % delay_dist_->size();
+ double delay = (*delay_dist_)[index].second;
+ //LOG_F(LS_INFO) << "random[" << index << "] = " << delay;
+ return static_cast<uint32>(delay);
+}
+
+struct FunctionDomainCmp {
+ bool operator()(const VirtualSocketServer::Point& p1,
+ const VirtualSocketServer::Point& p2) {
+ return p1.first < p2.first;
+ }
+ bool operator()(double v1, const VirtualSocketServer::Point& p2) {
+ return v1 < p2.first;
+ }
+ bool operator()(const VirtualSocketServer::Point& p1, double v2) {
+ return p1.first < v2;
+ }
+};
+
+VirtualSocketServer::Function* VirtualSocketServer::Accumulate(Function* f) {
+ ASSERT(f->size() >= 1);
+ double v = 0;
+ for (Function::size_type i = 0; i < f->size() - 1; ++i) {
+ double dx = (*f)[i + 1].first - (*f)[i].first;
+ double avgy = ((*f)[i + 1].second + (*f)[i].second) / 2;
+ (*f)[i].second = v;
+ v = v + dx * avgy;
+ }
+ (*f)[f->size()-1].second = v;
+ return f;
+}
+
+VirtualSocketServer::Function* VirtualSocketServer::Invert(Function* f) {
+ for (Function::size_type i = 0; i < f->size(); ++i)
+ std::swap((*f)[i].first, (*f)[i].second);
+
+ std::sort(f->begin(), f->end(), FunctionDomainCmp());
+ return f;
+}
+
+VirtualSocketServer::Function* VirtualSocketServer::Resample(
+ Function* f, double x1, double x2, uint32 samples) {
+ Function* g = new Function();
+
+ for (size_t i = 0; i < samples; i++) {
+ double x = x1 + (x2 - x1) * i / (samples - 1);
+ double y = Evaluate(f, x);
+ g->push_back(Point(x, y));
+ }
+
+ delete f;
+ return g;
+}
+
+double VirtualSocketServer::Evaluate(Function* f, double x) {
+ Function::iterator iter =
+ std::lower_bound(f->begin(), f->end(), x, FunctionDomainCmp());
+ if (iter == f->begin()) {
+ return (*f)[0].second;
+ } else if (iter == f->end()) {
+ ASSERT(f->size() >= 1);
+ return (*f)[f->size() - 1].second;
+ } else if (iter->first == x) {
+ return iter->second;
+ } else {
+ double x1 = (iter - 1)->first;
+ double y1 = (iter - 1)->second;
+ double x2 = iter->first;
+ double y2 = iter->second;
+ return y1 + (y2 - y1) * (x - x1) / (x2 - x1);
+ }
+}
+
+bool VirtualSocketServer::CanInteractWith(VirtualSocket* local,
+ VirtualSocket* remote) {
+ if (!local || !remote) {
+ return false;
+ }
+ IPAddress local_ip = local->GetLocalAddress().ipaddr();
+ IPAddress remote_ip = remote->GetLocalAddress().ipaddr();
+ IPAddress local_normalized = local_ip.Normalized();
+ IPAddress remote_normalized = remote_ip.Normalized();
+ // Check if the addresses are the same family after Normalization (turns
+ // mapped IPv6 address into IPv4 addresses).
+ // This will stop unmapped V6 addresses from talking to mapped V6 addresses.
+ if (local_normalized.family() == remote_normalized.family()) {
+ return true;
+ }
+
+ // If ip1 is IPv4 and ip2 is :: and ip2 is not IPV6_V6ONLY.
+ int remote_v6_only = 0;
+ remote->GetOption(Socket::OPT_IPV6_V6ONLY, &remote_v6_only);
+ if (local_ip.family() == AF_INET && !remote_v6_only && IPIsAny(remote_ip)) {
+ return true;
+ }
+ // Same check, backwards.
+ int local_v6_only = 0;
+ local->GetOption(Socket::OPT_IPV6_V6ONLY, &local_v6_only);
+ if (remote_ip.family() == AF_INET && !local_v6_only && IPIsAny(local_ip)) {
+ return true;
+ }
+
+ // Check to see if either socket was explicitly bound to IPv6-any.
+ // These sockets can talk with anyone.
+ if (local_ip.family() == AF_INET6 && local->was_any()) {
+ return true;
+ }
+ if (remote_ip.family() == AF_INET6 && remote->was_any()) {
+ return true;
+ }
+
+ return false;
+}
+
+} // namespace talk_base
diff --git a/talk/base/virtualsocketserver.h b/talk/base/virtualsocketserver.h
new file mode 100644
index 0000000..d35d586
--- /dev/null
+++ b/talk/base/virtualsocketserver.h
@@ -0,0 +1,247 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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_BASE_VIRTUALSOCKETSERVER_H_
+#define TALK_BASE_VIRTUALSOCKETSERVER_H_
+
+#include <cassert>
+#include <deque>
+#include <map>
+
+#include "talk/base/messagequeue.h"
+#include "talk/base/socketserver.h"
+
+namespace talk_base {
+
+class VirtualSocket;
+class SocketAddressPair;
+
+// Simulates a network in the same manner as a loopback interface. The
+// interface can create as many addresses as you want. All of the sockets
+// created by this network will be able to communicate with one another, unless
+// they are bound to addresses from incompatible families.
+class VirtualSocketServer : public SocketServer, public sigslot::has_slots<> {
+ public:
+ // TODO: Add "owned" parameter.
+ // If "owned" is set, the supplied socketserver will be deleted later.
+ explicit VirtualSocketServer(SocketServer* ss);
+ virtual ~VirtualSocketServer();
+
+ SocketServer* socketserver() { return server_; }
+
+ // Limits the network bandwidth (maximum bytes per second). Zero means that
+ // all sends occur instantly. Defaults to 0.
+ uint32 bandwidth() const { return bandwidth_; }
+ void set_bandwidth(uint32 bandwidth) { bandwidth_ = bandwidth; }
+
+ // Limits the amount of data which can be in flight on the network without
+ // packet loss (on a per sender basis). Defaults to 64 KB.
+ uint32 network_capacity() const { return network_capacity_; }
+ void set_network_capacity(uint32 capacity) {
+ network_capacity_ = capacity;
+ }
+
+ // The amount of data which can be buffered by tcp on the sender's side
+ uint32 send_buffer_capacity() const { return send_buffer_capacity_; }
+ void set_send_buffer_capacity(uint32 capacity) {
+ send_buffer_capacity_ = capacity;
+ }
+
+ // The amount of data which can be buffered by tcp on the receiver's side
+ uint32 recv_buffer_capacity() const { return recv_buffer_capacity_; }
+ void set_recv_buffer_capacity(uint32 capacity) {
+ recv_buffer_capacity_ = capacity;
+ }
+
+ // Controls the (transit) delay for packets sent in the network. This does
+ // not inclue the time required to sit in the send queue. Both of these
+ // values are measured in milliseconds. Defaults to no delay.
+ uint32 delay_mean() const { return delay_mean_; }
+ uint32 delay_stddev() const { return delay_stddev_; }
+ uint32 delay_samples() const { return delay_samples_; }
+ void set_delay_mean(uint32 delay_mean) { delay_mean_ = delay_mean; }
+ void set_delay_stddev(uint32 delay_stddev) {
+ delay_stddev_ = delay_stddev;
+ }
+ void set_delay_samples(uint32 delay_samples) {
+ delay_samples_ = delay_samples;
+ }
+
+ // If the (transit) delay parameters are modified, this method should be
+ // called to recompute the new distribution.
+ void UpdateDelayDistribution();
+
+ // Controls the (uniform) probability that any sent packet is dropped. This
+ // is separate from calculations to drop based on queue size.
+ double drop_probability() { return drop_prob_; }
+ void set_drop_probability(double drop_prob) {
+ assert((0 <= drop_prob) && (drop_prob <= 1));
+ drop_prob_ = drop_prob;
+ }
+
+ // SocketFactory:
+ virtual Socket* CreateSocket(int type);
+ virtual AsyncSocket* CreateAsyncSocket(int type);
+
+ // SocketServer:
+ virtual void SetMessageQueue(MessageQueue* queue);
+ virtual bool Wait(int cms, bool process_io);
+ virtual void WakeUp();
+
+ typedef std::pair<double, double> Point;
+ typedef std::vector<Point> Function;
+
+ static Function* CreateDistribution(uint32 mean, uint32 stddev,
+ uint32 samples);
+
+ // Similar to Thread::ProcessMessages, but it only processes messages until
+ // there are no immediate messages or pending network traffic. Returns false
+ // if Thread::Stop() was called.
+ bool ProcessMessagesUntilIdle();
+
+ protected:
+ // Returns a new IP not used before in this network.
+ IPAddress GetNextIP(int family);
+ uint16 GetNextPort();
+
+ VirtualSocket* CreateSocketInternal(int type);
+
+ // Binds the given socket to addr, assigning and IP and Port if necessary
+ int Bind(VirtualSocket* socket, SocketAddress* addr);
+
+ // Binds the given socket to the given (fully-defined) address.
+ int Bind(VirtualSocket* socket, const SocketAddress& addr);
+
+ // Find the socket bound to the given address
+ VirtualSocket* LookupBinding(const SocketAddress& addr);
+
+ int Unbind(const SocketAddress& addr, VirtualSocket* socket);
+
+ // Adds a mapping between this socket pair and the socket.
+ void AddConnection(const SocketAddress& client,
+ const SocketAddress& server,
+ VirtualSocket* socket);
+
+ // Find the socket pair corresponding to this server address.
+ VirtualSocket* LookupConnection(const SocketAddress& client,
+ const SocketAddress& server);
+
+ void RemoveConnection(const SocketAddress& client,
+ const SocketAddress& server);
+
+ // Connects the given socket to the socket at the given address
+ int Connect(VirtualSocket* socket, const SocketAddress& remote_addr,
+ bool use_delay);
+
+ // Sends a disconnect message to the socket at the given address
+ bool Disconnect(VirtualSocket* socket);
+
+ // Sends the given packet to the socket at the given address (if one exists).
+ int SendUdp(VirtualSocket* socket, const char* data, size_t data_size,
+ const SocketAddress& remote_addr);
+
+ // Moves as much data as possible from the sender's buffer to the network
+ void SendTcp(VirtualSocket* socket);
+
+ // Places a packet on the network.
+ void AddPacketToNetwork(VirtualSocket* socket, VirtualSocket* recipient,
+ uint32 cur_time, const char* data, size_t data_size,
+ size_t header_size, bool ordered);
+
+ // Removes stale packets from the network
+ void PurgeNetworkPackets(VirtualSocket* socket, uint32 cur_time);
+
+ // Computes the number of milliseconds required to send a packet of this size.
+ uint32 SendDelay(uint32 size);
+
+ // Returns a random transit delay chosen from the appropriate distribution.
+ uint32 GetRandomTransitDelay();
+
+ // Basic operations on functions. Those that return a function also take
+ // ownership of the function given (and hence, may modify or delete it).
+ static Function* Accumulate(Function* f);
+ static Function* Invert(Function* f);
+ static Function* Resample(Function* f, double x1, double x2, uint32 samples);
+ static double Evaluate(Function* f, double x);
+
+ // NULL out our message queue if it goes away. Necessary in the case where
+ // our lifetime is greater than that of the thread we are using, since we
+ // try to send Close messages for all connected sockets when we shutdown.
+ void OnMessageQueueDestroyed() { msg_queue_ = NULL; }
+
+ // Determine if two sockets should be able to communicate.
+ // We don't (currently) specify an address family for sockets; instead,
+ // the currently bound address is used to infer the address family.
+ // Any socket that is not explicitly bound to an IPv4 address is assumed to be
+ // dual-stack capable.
+ // This function tests if two addresses can communicate, as well as the
+ // sockets to which they may be bound (the addresses may or may not yet be
+ // bound to the sockets).
+ // First the addresses are tested (after normalization):
+ // If both have the same family, then communication is OK.
+ // If only one is IPv4 then false, unless the other is bound to ::.
+ // This applies even if the IPv4 address is 0.0.0.0.
+ // The socket arguments are optional; the sockets are checked to see if they
+ // were explicitly bound to IPv6-any ('::'), and if so communication is
+ // permitted.
+ // NB: This scheme doesn't permit non-dualstack IPv6 sockets.
+ static bool CanInteractWith(VirtualSocket* local, VirtualSocket* remote);
+
+ private:
+ friend class VirtualSocket;
+
+ typedef std::map<SocketAddress, VirtualSocket*> AddressMap;
+ typedef std::map<SocketAddressPair, VirtualSocket*> ConnectionMap;
+
+ SocketServer* server_;
+ bool server_owned_;
+ MessageQueue* msg_queue_;
+ bool stop_on_idle_;
+ uint32 network_delay_;
+ in_addr next_ipv4_;
+ in6_addr next_ipv6_;
+ uint16 next_port_;
+ AddressMap* bindings_;
+ ConnectionMap* connections_;
+
+ uint32 bandwidth_;
+ uint32 network_capacity_;
+ uint32 send_buffer_capacity_;
+ uint32 recv_buffer_capacity_;
+ uint32 delay_mean_;
+ uint32 delay_stddev_;
+ uint32 delay_samples_;
+ Function* delay_dist_;
+ CriticalSection delay_crit_;
+
+ double drop_prob_;
+ DISALLOW_EVIL_CONSTRUCTORS(VirtualSocketServer);
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_VIRTUALSOCKETSERVER_H_
diff --git a/talk/base/win32.cc b/talk/base/win32.cc
index 5e28aa9..3937781 100644
--- a/talk/base/win32.cc
+++ b/talk/base/win32.cc
@@ -26,13 +26,272 @@
*/
#include "talk/base/win32.h"
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
#include <algorithm>
#include "talk/base/basictypes.h"
#include "talk/base/common.h"
+#include "talk/base/logging.h"
namespace talk_base {
+// Helper function declarations for inet_ntop/inet_pton.
+static const char* inet_ntop_v4(const void* src, char* dst, socklen_t size);
+static const char* inet_ntop_v6(const void* src, char* dst, socklen_t size);
+static int inet_pton_v4(const char* src, void* dst);
+static int inet_pton_v6(const char* src, void* dst);
+
+// Implementation of inet_ntop (create a printable representation of an
+// ip address). XP doesn't have its own inet_ntop, and
+// WSAAddressToString requires both IPv6 to be installed and for Winsock
+// to be initialized.
+const char* win32_inet_ntop(int af, const void *src,
+ char* dst, socklen_t size) {
+ if (!src || !dst) {
+ return NULL;
+ }
+ switch (af) {
+ case AF_INET: {
+ return inet_ntop_v4(src, dst, size);
+ }
+ case AF_INET6: {
+ return inet_ntop_v6(src, dst, size);
+ }
+ }
+ return NULL;
+}
+
+// As above, but for inet_pton. Wraps inet_addr for v4, and implements inet_pton
+// for v6. Slightly more permissive than the RFC specified inet_pton, as it uses
+// windows' inet_addr which permits octal and hexadecimal values in v4
+// addresses, while inet_pton only allows decimal.
+// Note that our inet_ntop will output normal 'dotted' v4 addresses only.
+int win32_inet_pton(int af, const char* src, void* dst) {
+ if (!src || !dst) {
+ return 0;
+ }
+ if (af == AF_INET) {
+ return inet_pton_v4(src, dst);
+ } else if (af == AF_INET6) {
+ return inet_pton_v6(src, dst);
+ }
+ return -1;
+}
+
+// Helper function for inet_ntop for IPv4 addresses.
+// Outputs "dotted-quad" decimal notation.
+const char* inet_ntop_v4(const void* src, char* dst, socklen_t size) {
+ if (size < INET_ADDRSTRLEN) {
+ return NULL;
+ }
+ const struct in_addr* as_in_addr =
+ reinterpret_cast<const struct in_addr*>(src);
+ talk_base::sprintfn(dst, size, "%d.%d.%d.%d",
+ as_in_addr->S_un.S_un_b.s_b1,
+ as_in_addr->S_un.S_un_b.s_b2,
+ as_in_addr->S_un.S_un_b.s_b3,
+ as_in_addr->S_un.S_un_b.s_b4);
+ return dst;
+}
+
+// Helper function for inet_ntop for IPv6 addresses.
+const char* inet_ntop_v6(const void* src, char* dst, socklen_t size) {
+ if (size < INET6_ADDRSTRLEN) {
+ return NULL;
+ }
+ const uint16* as_shorts =
+ reinterpret_cast<const uint16*>(src);
+ int runpos[8];
+ int current = 1;
+ int max = 1;
+ int maxpos = -1;
+ int run_array_size = ARRAY_SIZE(runpos);
+ // Run over the address marking runs of 0s.
+ for (int i = 0; i < run_array_size; ++i) {
+ if (as_shorts[i] == 0) {
+ runpos[i] = current;
+ if (current > max) {
+ maxpos = i;
+ max = current;
+ }
+ ++current;
+ } else {
+ runpos[i] = -1;
+ current =1;
+ }
+ }
+
+ if (max > 1) {
+ int tmpmax = maxpos;
+ // Run back through, setting -1 for all but the longest run.
+ for (int i = run_array_size - 1; i >= 0; i--) {
+ if (i > tmpmax) {
+ runpos[i] = -1;
+ } else if (runpos[i] == -1) {
+ // We're less than maxpos, we hit a -1, so the 'good' run is done.
+ // Setting tmpmax -1 means all remaining positions get set to -1.
+ tmpmax = -1;
+ }
+ }
+ }
+
+ char* cursor = dst;
+ // Print IPv4 compatible and IPv4 mapped addresses using the IPv4 helper.
+ // These addresses have an initial run of either eight zero-bytes followed
+ // by 0xFFFF, or an initial run of ten zero-bytes.
+ if (runpos[0] == 1 && (maxpos == 5 ||
+ (maxpos == 4 && as_shorts[5] == 0xFFFF))) {
+ *cursor++ = ':';
+ *cursor++ = ':';
+ if (maxpos == 4) {
+ cursor += talk_base::sprintfn(cursor, INET6_ADDRSTRLEN - 2, "ffff:");
+ }
+ const struct in_addr* as_v4 =
+ reinterpret_cast<const struct in_addr*>(&(as_shorts[6]));
+ inet_ntop_v4(as_v4, cursor, (INET6_ADDRSTRLEN - (cursor - dst)));
+ } else {
+ for (int i = 0; i < run_array_size; ++i) {
+ if (runpos[i] == -1) {
+ cursor += talk_base::sprintfn(cursor,
+ INET6_ADDRSTRLEN - (cursor - dst),
+ "%x", ntohs(as_shorts[i]));
+ if (i != 7 && runpos[i + 1] != 1) {
+ *cursor++ = ':';
+ }
+ } else if (runpos[i] == 1) {
+ // Entered the run; print the colons and skip the run.
+ *cursor++ = ':';
+ *cursor++ = ':';
+ i += (max - 1);
+ }
+ }
+ }
+ return dst;
+}
+
+// Helper function for inet_pton for IPv4 addresses.
+// Uses win32's inet_addr.
+int inet_pton_v4(const char* src, void* dst) {
+ uint32 ip = inet_addr(src);
+ if (ip == 0xFFFFFFFF && strcmp(src, "255.255.255.255") != 0) {
+ return 0;
+ }
+ struct in_addr* dst_as_in_addr = reinterpret_cast<struct in_addr*>(dst);
+ dst_as_in_addr->s_addr = ip;
+ return 1;
+}
+
+// Helper function for inet_pton for IPv6 addresses.
+int inet_pton_v6(const char* src, void* dst) {
+ // sscanf will pick any other invalid chars up, but it parses 0xnnnn as hex.
+ // Check for literal x in the input string.
+ const char* readcursor = src;
+ char c = *readcursor++;
+ while (c) {
+ if (c == 'x') {
+ return 0;
+ }
+ c = *readcursor++;
+ }
+ readcursor = src;
+
+ struct in6_addr an_addr;
+ memset(&an_addr, 0, sizeof(an_addr));
+
+ uint16* addr_cursor = reinterpret_cast<uint16*>(&an_addr.s6_addr[0]);
+ uint16* addr_end = reinterpret_cast<uint16*>(&an_addr.s6_addr[16]);
+ bool seencompressed = false;
+
+ // Addresses that start with "::" (i.e., a run of initial zeros) or
+ // "::ffff:" can potentially be IPv4 mapped or compatibility addresses.
+ // These have dotted-style IPv4 addresses on the end (e.g. "::192.168.7.1").
+ if (*readcursor == ':' && *(readcursor+1) == ':' &&
+ *(readcursor + 2) != 0) {
+ // Check for periods, which we'll take as a sign of v4 addresses.
+ const char* addrstart = readcursor + 2;
+ if (talk_base::strchr(addrstart, ".")) {
+ const char* colon = talk_base::strchr(addrstart, "::");
+ if (colon) {
+ uint16 a_short;
+ int bytesread = 0;
+ if (sscanf(addrstart, "%hx%n", &a_short, &bytesread) != 1 ||
+ a_short != 0xFFFF || bytesread != 4) {
+ // Colons + periods means has to be ::ffff:a.b.c.d. But it wasn't.
+ return 0;
+ } else {
+ an_addr.s6_addr[10] = 0xFF;
+ an_addr.s6_addr[11] = 0xFF;
+ addrstart = colon + 1;
+ }
+ }
+ struct in_addr v4;
+ if (inet_pton_v4(addrstart, &v4.s_addr)) {
+ memcpy(&an_addr.s6_addr[12], &v4, sizeof(v4));
+ memcpy(dst, &an_addr, sizeof(an_addr));
+ return 1;
+ } else {
+ // Invalid v4 address.
+ return 0;
+ }
+ }
+ }
+
+ // For addresses without a trailing IPv4 component ('normal' IPv6 addresses).
+ while (*readcursor != 0 && addr_cursor < addr_end) {
+ if (*readcursor == ':') {
+ if (*(readcursor + 1) == ':') {
+ if (seencompressed) {
+ // Can only have one compressed run of zeroes ("::") per address.
+ return 0;
+ }
+ // Hit a compressed run. Count colons to figure out how much of the
+ // address is skipped.
+ readcursor += 2;
+ const char* coloncounter = readcursor;
+ int coloncount = 0;
+ if (*coloncounter == 0) {
+ // Special case - trailing ::.
+ addr_cursor = addr_end;
+ } else {
+ while (*coloncounter) {
+ if (*coloncounter == ':') {
+ ++coloncount;
+ }
+ ++coloncounter;
+ }
+ // (coloncount + 1) is the number of shorts left in the address.
+ addr_cursor = addr_end - (coloncount + 1);
+ seencompressed = true;
+ }
+ } else {
+ ++readcursor;
+ }
+ } else {
+ uint16 word;
+ int bytesread = 0;
+ if (sscanf(readcursor, "%hx%n", &word, &bytesread) != 1) {
+ return 0;
+ } else {
+ *addr_cursor = htons(word);
+ ++addr_cursor;
+ readcursor += bytesread;
+ if (*readcursor != ':' && *readcursor != '\0') {
+ return 0;
+ }
+ }
+ }
+ }
+
+ if (*readcursor != '\0' || addr_cursor < addr_end) {
+ // Catches addresses too short or too long.
+ return 0;
+ }
+ memcpy(dst, &an_addr, sizeof(an_addr));
+ return 1;
+}
+
//
// Unix time is in seconds relative to 1/1/1970. So we compute the windows
// FILETIME of that time/date, then we add/subtract in appropriate units to
@@ -178,6 +437,4 @@
}
return ret;
}
-
} // namespace talk_base
-
diff --git a/talk/base/win32.h b/talk/base/win32.h
index 6274b0e..9c6ea3f 100644
--- a/talk/base/win32.h
+++ b/talk/base/win32.h
@@ -54,6 +54,9 @@
namespace talk_base {
+const char* win32_inet_ntop(int af, const void *src, char* dst, socklen_t size);
+int win32_inet_pton(int af, const char* src, void *dst);
+
///////////////////////////////////////////////////////////////////////////////
inline std::wstring ToUtf16(const char* utf8, size_t len) {
diff --git a/talk/base/win32_unittest.cc b/talk/base/win32_unittest.cc
new file mode 100644
index 0000000..4800e6e
--- /dev/null
+++ b/talk/base/win32_unittest.cc
@@ -0,0 +1,54 @@
+/*
+ * libjingle
+ * Copyright 2010, 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 "talk/base/gunit.h"
+#include "talk/base/win32.h"
+
+#ifndef WIN32
+#error Only for Windows
+#endif
+
+namespace talk_base {
+
+class Win32Test : public testing::Test {
+ public:
+ Win32Test() {
+ }
+};
+
+TEST_F(Win32Test, FileTimeToUInt64Test) {
+ FILETIME ft;
+ ft.dwHighDateTime = 0xBAADF00D;
+ ft.dwLowDateTime = 0xFEED3456;
+
+ uint64 expected = 0xBAADF00DFEED3456;
+ EXPECT_EQ(expected, ToUInt64(ft));
+}
+
+} // namespace talk_base
diff --git a/talk/base/win32regkey.cc b/talk/base/win32regkey.cc
new file mode 100644
index 0000000..de74327
--- /dev/null
+++ b/talk/base/win32regkey.cc
@@ -0,0 +1,1119 @@
+/*
+ * libjingle
+ * Copyright 2003-2008, 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.
+ */
+
+// Registry configuration wrapers class implementation
+//
+// Change made by S. Ganesh - ganesh@google.com:
+// Use SHQueryValueEx instead of RegQueryValueEx throughout.
+// A call to the SHLWAPI function is essentially a call to the standard
+// function but with post-processing:
+// * to fix REG_SZ or REG_EXPAND_SZ data that is not properly null-terminated;
+// * to expand REG_EXPAND_SZ data.
+
+#include "talk/base/win32regkey.h"
+
+#include <shlwapi.h>
+
+#include "talk/base/common.h"
+#include "talk/base/logging.h"
+#include "talk/base/scoped_ptr.h"
+
+namespace talk_base {
+
+RegKey::RegKey() {
+ h_key_ = NULL;
+}
+
+RegKey::~RegKey() {
+ Close();
+}
+
+HRESULT RegKey::Create(HKEY parent_key, const wchar_t* key_name) {
+ return Create(parent_key,
+ key_name,
+ REG_NONE,
+ REG_OPTION_NON_VOLATILE,
+ KEY_ALL_ACCESS,
+ NULL,
+ NULL);
+}
+
+HRESULT RegKey::Open(HKEY parent_key, const wchar_t* key_name) {
+ return Open(parent_key, key_name, KEY_ALL_ACCESS);
+}
+
+bool RegKey::HasValue(const TCHAR* value_name) const {
+ return (ERROR_SUCCESS == ::RegQueryValueEx(h_key_, value_name, NULL,
+ NULL, NULL, NULL));
+}
+
+HRESULT RegKey::SetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ DWORD value) {
+ ASSERT(full_key_name != NULL);
+
+ return SetValueStaticHelper(full_key_name, value_name, REG_DWORD, &value);
+}
+
+HRESULT RegKey::SetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ DWORD64 value) {
+ ASSERT(full_key_name != NULL);
+
+ return SetValueStaticHelper(full_key_name, value_name, REG_QWORD, &value);
+}
+
+HRESULT RegKey::SetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ float value) {
+ ASSERT(full_key_name != NULL);
+
+ return SetValueStaticHelper(full_key_name, value_name,
+ REG_BINARY, &value, sizeof(value));
+}
+
+HRESULT RegKey::SetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ double value) {
+ ASSERT(full_key_name != NULL);
+
+ return SetValueStaticHelper(full_key_name, value_name,
+ REG_BINARY, &value, sizeof(value));
+}
+
+HRESULT RegKey::SetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ const TCHAR* value) {
+ ASSERT(full_key_name != NULL);
+ ASSERT(value != NULL);
+
+ return SetValueStaticHelper(full_key_name, value_name,
+ REG_SZ, const_cast<wchar_t*>(value));
+}
+
+HRESULT RegKey::SetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ const uint8* value,
+ DWORD byte_count) {
+ ASSERT(full_key_name != NULL);
+
+ return SetValueStaticHelper(full_key_name, value_name, REG_BINARY,
+ const_cast<uint8*>(value), byte_count);
+}
+
+HRESULT RegKey::SetValueMultiSZ(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ const uint8* value,
+ DWORD byte_count) {
+ ASSERT(full_key_name != NULL);
+
+ return SetValueStaticHelper(full_key_name, value_name, REG_MULTI_SZ,
+ const_cast<uint8*>(value), byte_count);
+}
+
+HRESULT RegKey::GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ DWORD* value) {
+ ASSERT(full_key_name != NULL);
+ ASSERT(value != NULL);
+
+ return GetValueStaticHelper(full_key_name, value_name, REG_DWORD, value);
+}
+
+HRESULT RegKey::GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ DWORD64* value) {
+ ASSERT(full_key_name != NULL);
+ ASSERT(value != NULL);
+
+ return GetValueStaticHelper(full_key_name, value_name, REG_QWORD, value);
+}
+
+HRESULT RegKey::GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ float* value) {
+ ASSERT(value != NULL);
+ ASSERT(full_key_name != NULL);
+
+ DWORD byte_count = 0;
+ scoped_array<byte> buffer;
+ HRESULT hr = GetValueStaticHelper(full_key_name, value_name,
+ REG_BINARY, buffer.accept(), &byte_count);
+ if (SUCCEEDED(hr)) {
+ ASSERT(byte_count == sizeof(*value));
+ if (byte_count == sizeof(*value)) {
+ *value = *reinterpret_cast<float*>(buffer.get());
+ }
+ }
+ return hr;
+}
+
+HRESULT RegKey::GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ double* value) {
+ ASSERT(value != NULL);
+ ASSERT(full_key_name != NULL);
+
+ DWORD byte_count = 0;
+ scoped_array<byte> buffer;
+ HRESULT hr = GetValueStaticHelper(full_key_name, value_name,
+ REG_BINARY, buffer.accept(), &byte_count);
+ if (SUCCEEDED(hr)) {
+ ASSERT(byte_count == sizeof(*value));
+ if (byte_count == sizeof(*value)) {
+ *value = *reinterpret_cast<double*>(buffer.get());
+ }
+ }
+ return hr;
+}
+
+HRESULT RegKey::GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ wchar_t** value) {
+ ASSERT(full_key_name != NULL);
+ ASSERT(value != NULL);
+
+ return GetValueStaticHelper(full_key_name, value_name, REG_SZ, value);
+}
+
+HRESULT RegKey::GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ std::wstring* value) {
+ ASSERT(full_key_name != NULL);
+ ASSERT(value != NULL);
+
+ scoped_array<wchar_t> buffer;
+ HRESULT hr = RegKey::GetValue(full_key_name, value_name, buffer.accept());
+ if (SUCCEEDED(hr)) {
+ value->assign(buffer.get());
+ }
+ return hr;
+}
+
+HRESULT RegKey::GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ std::vector<std::wstring>* value) {
+ ASSERT(full_key_name != NULL);
+ ASSERT(value != NULL);
+
+ return GetValueStaticHelper(full_key_name, value_name, REG_MULTI_SZ, value);
+}
+
+HRESULT RegKey::GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ uint8** value,
+ DWORD* byte_count) {
+ ASSERT(full_key_name != NULL);
+ ASSERT(value != NULL);
+ ASSERT(byte_count != NULL);
+
+ return GetValueStaticHelper(full_key_name, value_name,
+ REG_BINARY, value, byte_count);
+}
+
+HRESULT RegKey::DeleteSubKey(const wchar_t* key_name) {
+ ASSERT(key_name != NULL);
+ ASSERT(h_key_ != NULL);
+
+ LONG res = ::RegDeleteKey(h_key_, key_name);
+ HRESULT hr = HRESULT_FROM_WIN32(res);
+ if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) ||
+ hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND)) {
+ hr = S_FALSE;
+ }
+ return hr;
+}
+
+HRESULT RegKey::DeleteValue(const wchar_t* value_name) {
+ ASSERT(h_key_ != NULL);
+
+ LONG res = ::RegDeleteValue(h_key_, value_name);
+ HRESULT hr = HRESULT_FROM_WIN32(res);
+ if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) ||
+ hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND)) {
+ hr = S_FALSE;
+ }
+ return hr;
+}
+
+HRESULT RegKey::Close() {
+ HRESULT hr = S_OK;
+ if (h_key_ != NULL) {
+ LONG res = ::RegCloseKey(h_key_);
+ hr = HRESULT_FROM_WIN32(res);
+ h_key_ = NULL;
+ }
+ return hr;
+}
+
+HRESULT RegKey::Create(HKEY parent_key,
+ const wchar_t* key_name,
+ wchar_t* lpszClass,
+ DWORD options,
+ REGSAM sam_desired,
+ LPSECURITY_ATTRIBUTES lpSecAttr,
+ LPDWORD lpdwDisposition) {
+ ASSERT(key_name != NULL);
+ ASSERT(parent_key != NULL);
+
+ DWORD dw = 0;
+ HKEY h_key = NULL;
+ LONG res = ::RegCreateKeyEx(parent_key, key_name, 0, lpszClass, options,
+ sam_desired, lpSecAttr, &h_key, &dw);
+ HRESULT hr = HRESULT_FROM_WIN32(res);
+
+ if (lpdwDisposition) {
+ *lpdwDisposition = dw;
+ }
+
+ // we have to close the currently opened key
+ // before replacing it with the new one
+ if (hr == S_OK) {
+ hr = Close();
+ ASSERT(hr == S_OK);
+ h_key_ = h_key;
+ }
+ return hr;
+}
+
+HRESULT RegKey::Open(HKEY parent_key,
+ const wchar_t* key_name,
+ REGSAM sam_desired) {
+ ASSERT(key_name != NULL);
+ ASSERT(parent_key != NULL);
+
+ HKEY h_key = NULL;
+ LONG res = ::RegOpenKeyEx(parent_key, key_name, 0, sam_desired, &h_key);
+ HRESULT hr = HRESULT_FROM_WIN32(res);
+
+ // we have to close the currently opened key
+ // before replacing it with the new one
+ if (hr == S_OK) {
+ // close the currently opened key if any
+ hr = Close();
+ ASSERT(hr == S_OK);
+ h_key_ = h_key;
+ }
+ return hr;
+}
+
+// save the key and all of its subkeys and values to a file
+HRESULT RegKey::Save(const wchar_t* full_key_name, const wchar_t* file_name) {
+ ASSERT(full_key_name != NULL);
+ ASSERT(file_name != NULL);
+
+ std::wstring key_name(full_key_name);
+ HKEY h_key = GetRootKeyInfo(&key_name);
+ if (!h_key) {
+ return E_FAIL;
+ }
+
+ RegKey key;
+ HRESULT hr = key.Open(h_key, key_name.c_str(), KEY_READ);
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ AdjustCurrentProcessPrivilege(SE_BACKUP_NAME, true);
+ LONG res = ::RegSaveKey(key.h_key_, file_name, NULL);
+ AdjustCurrentProcessPrivilege(SE_BACKUP_NAME, false);
+
+ return HRESULT_FROM_WIN32(res);
+}
+
+// restore the key and all of its subkeys and values which are saved into a file
+HRESULT RegKey::Restore(const wchar_t* full_key_name,
+ const wchar_t* file_name) {
+ ASSERT(full_key_name != NULL);
+ ASSERT(file_name != NULL);
+
+ std::wstring key_name(full_key_name);
+ HKEY h_key = GetRootKeyInfo(&key_name);
+ if (!h_key) {
+ return E_FAIL;
+ }
+
+ RegKey key;
+ HRESULT hr = key.Open(h_key, key_name.c_str(), KEY_WRITE);
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ AdjustCurrentProcessPrivilege(SE_RESTORE_NAME, true);
+ LONG res = ::RegRestoreKey(key.h_key_, file_name, REG_FORCE_RESTORE);
+ AdjustCurrentProcessPrivilege(SE_RESTORE_NAME, false);
+
+ return HRESULT_FROM_WIN32(res);
+}
+
+// check if the current key has the specified subkey
+bool RegKey::HasSubkey(const wchar_t* key_name) const {
+ ASSERT(key_name != NULL);
+
+ RegKey key;
+ HRESULT hr = key.Open(h_key_, key_name, KEY_READ);
+ key.Close();
+ return hr == S_OK;
+}
+
+// static flush key
+HRESULT RegKey::FlushKey(const wchar_t* full_key_name) {
+ ASSERT(full_key_name != NULL);
+
+ HRESULT hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
+ // get the root HKEY
+ std::wstring key_name(full_key_name);
+ HKEY h_key = GetRootKeyInfo(&key_name);
+
+ if (h_key != NULL) {
+ LONG res = ::RegFlushKey(h_key);
+ hr = HRESULT_FROM_WIN32(res);
+ }
+ return hr;
+}
+
+// static SET helper
+HRESULT RegKey::SetValueStaticHelper(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ DWORD type,
+ LPVOID value,
+ DWORD byte_count) {
+ ASSERT(full_key_name != NULL);
+
+ HRESULT hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
+ // get the root HKEY
+ std::wstring key_name(full_key_name);
+ HKEY h_key = GetRootKeyInfo(&key_name);
+
+ if (h_key != NULL) {
+ RegKey key;
+ hr = key.Create(h_key, key_name.c_str());
+ if (hr == S_OK) {
+ switch (type) {
+ case REG_DWORD:
+ hr = key.SetValue(value_name, *(static_cast<DWORD*>(value)));
+ break;
+ case REG_QWORD:
+ hr = key.SetValue(value_name, *(static_cast<DWORD64*>(value)));
+ break;
+ case REG_SZ:
+ hr = key.SetValue(value_name, static_cast<const wchar_t*>(value));
+ break;
+ case REG_BINARY:
+ hr = key.SetValue(value_name, static_cast<const uint8*>(value),
+ byte_count);
+ break;
+ case REG_MULTI_SZ:
+ hr = key.SetValue(value_name, static_cast<const uint8*>(value),
+ byte_count, type);
+ break;
+ default:
+ ASSERT(false);
+ hr = HRESULT_FROM_WIN32(ERROR_DATATYPE_MISMATCH);
+ break;
+ }
+ // close the key after writing
+ HRESULT temp_hr = key.Close();
+ if (hr == S_OK) {
+ hr = temp_hr;
+ }
+ }
+ }
+ return hr;
+}
+
+// static GET helper
+HRESULT RegKey::GetValueStaticHelper(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ DWORD type,
+ LPVOID value,
+ DWORD* byte_count) {
+ ASSERT(full_key_name != NULL);
+
+ HRESULT hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
+ // get the root HKEY
+ std::wstring key_name(full_key_name);
+ HKEY h_key = GetRootKeyInfo(&key_name);
+
+ if (h_key != NULL) {
+ RegKey key;
+ hr = key.Open(h_key, key_name.c_str(), KEY_READ);
+ if (hr == S_OK) {
+ switch (type) {
+ case REG_DWORD:
+ hr = key.GetValue(value_name, reinterpret_cast<DWORD*>(value));
+ break;
+ case REG_QWORD:
+ hr = key.GetValue(value_name, reinterpret_cast<DWORD64*>(value));
+ break;
+ case REG_SZ:
+ hr = key.GetValue(value_name, reinterpret_cast<wchar_t**>(value));
+ break;
+ case REG_MULTI_SZ:
+ hr = key.GetValue(value_name, reinterpret_cast<
+ std::vector<std::wstring>*>(value));
+ break;
+ case REG_BINARY:
+ hr = key.GetValue(value_name, reinterpret_cast<uint8**>(value),
+ byte_count);
+ break;
+ default:
+ ASSERT(false);
+ hr = HRESULT_FROM_WIN32(ERROR_DATATYPE_MISMATCH);
+ break;
+ }
+ // close the key after writing
+ HRESULT temp_hr = key.Close();
+ if (hr == S_OK) {
+ hr = temp_hr;
+ }
+ }
+ }
+ return hr;
+}
+
+// GET helper
+HRESULT RegKey::GetValueHelper(const wchar_t* value_name,
+ DWORD* type,
+ uint8** value,
+ DWORD* byte_count) const {
+ ASSERT(byte_count != NULL);
+ ASSERT(value != NULL);
+ ASSERT(type != NULL);
+
+ // init return buffer
+ *value = NULL;
+
+ // get the size of the return data buffer
+ LONG res = ::SHQueryValueEx(h_key_, value_name, NULL, type, NULL, byte_count);
+ HRESULT hr = HRESULT_FROM_WIN32(res);
+
+ if (hr == S_OK) {
+ // if the value length is 0, nothing to do
+ if (*byte_count != 0) {
+ // allocate the buffer
+ *value = new byte[*byte_count];
+ ASSERT(*value != NULL);
+
+ // make the call again to get the data
+ res = ::SHQueryValueEx(h_key_, value_name, NULL,
+ type, *value, byte_count);
+ hr = HRESULT_FROM_WIN32(res);
+ ASSERT(hr == S_OK);
+ }
+ }
+ return hr;
+}
+
+// Int32 Get
+HRESULT RegKey::GetValue(const wchar_t* value_name, DWORD* value) const {
+ ASSERT(value != NULL);
+
+ DWORD type = 0;
+ DWORD byte_count = sizeof(DWORD);
+ LONG res = ::SHQueryValueEx(h_key_, value_name, NULL, &type,
+ value, &byte_count);
+ HRESULT hr = HRESULT_FROM_WIN32(res);
+ ASSERT((hr != S_OK) || (type == REG_DWORD));
+ ASSERT((hr != S_OK) || (byte_count == sizeof(DWORD)));
+ return hr;
+}
+
+// Int64 Get
+HRESULT RegKey::GetValue(const wchar_t* value_name, DWORD64* value) const {
+ ASSERT(value != NULL);
+
+ DWORD type = 0;
+ DWORD byte_count = sizeof(DWORD64);
+ LONG res = ::SHQueryValueEx(h_key_, value_name, NULL, &type,
+ value, &byte_count);
+ HRESULT hr = HRESULT_FROM_WIN32(res);
+ ASSERT((hr != S_OK) || (type == REG_QWORD));
+ ASSERT((hr != S_OK) || (byte_count == sizeof(DWORD64)));
+ return hr;
+}
+
+// String Get
+HRESULT RegKey::GetValue(const wchar_t* value_name, wchar_t** value) const {
+ ASSERT(value != NULL);
+
+ DWORD byte_count = 0;
+ DWORD type = 0;
+
+ // first get the size of the string buffer
+ LONG res = ::SHQueryValueEx(h_key_, value_name, NULL,
+ &type, NULL, &byte_count);
+ HRESULT hr = HRESULT_FROM_WIN32(res);
+
+ if (hr == S_OK) {
+ // allocate room for the string and a terminating \0
+ *value = new wchar_t[(byte_count / sizeof(wchar_t)) + 1];
+
+ if ((*value) != NULL) {
+ if (byte_count != 0) {
+ // make the call again
+ res = ::SHQueryValueEx(h_key_, value_name, NULL, &type,
+ *value, &byte_count);
+ hr = HRESULT_FROM_WIN32(res);
+ } else {
+ (*value)[0] = L'\0';
+ }
+
+ ASSERT((hr != S_OK) || (type == REG_SZ) ||
+ (type == REG_MULTI_SZ) || (type == REG_EXPAND_SZ));
+ } else {
+ hr = E_OUTOFMEMORY;
+ }
+ }
+
+ return hr;
+}
+
+// get a string value
+HRESULT RegKey::GetValue(const wchar_t* value_name, std::wstring* value) const {
+ ASSERT(value != NULL);
+
+ DWORD byte_count = 0;
+ DWORD type = 0;
+
+ // first get the size of the string buffer
+ LONG res = ::SHQueryValueEx(h_key_, value_name, NULL,
+ &type, NULL, &byte_count);
+ HRESULT hr = HRESULT_FROM_WIN32(res);
+
+ if (hr == S_OK) {
+ if (byte_count != 0) {
+ // Allocate some memory and make the call again
+ value->resize(byte_count / sizeof(wchar_t) + 1);
+ res = ::SHQueryValueEx(h_key_, value_name, NULL, &type,
+ &value->at(0), &byte_count);
+ hr = HRESULT_FROM_WIN32(res);
+ value->resize(wcslen(value->data()));
+ } else {
+ value->clear();
+ }
+
+ ASSERT((hr != S_OK) || (type == REG_SZ) ||
+ (type == REG_MULTI_SZ) || (type == REG_EXPAND_SZ));
+ }
+
+ return hr;
+}
+
+// convert REG_MULTI_SZ bytes to string array
+HRESULT RegKey::MultiSZBytesToStringArray(const uint8* buffer,
+ DWORD byte_count,
+ std::vector<std::wstring>* value) {
+ ASSERT(buffer != NULL);
+ ASSERT(value != NULL);
+
+ const wchar_t* data = reinterpret_cast<const wchar_t*>(buffer);
+ DWORD data_len = byte_count / sizeof(wchar_t);
+ value->clear();
+ if (data_len > 1) {
+ // must be terminated by two null characters
+ if (data[data_len - 1] != 0 || data[data_len - 2] != 0) {
+ return E_INVALIDARG;
+ }
+
+ // put null-terminated strings into arrays
+ while (*data) {
+ std::wstring str(data);
+ value->push_back(str);
+ data += str.length() + 1;
+ }
+ }
+ return S_OK;
+}
+
+// get a std::vector<std::wstring> value from REG_MULTI_SZ type
+HRESULT RegKey::GetValue(const wchar_t* value_name,
+ std::vector<std::wstring>* value) const {
+ ASSERT(value != NULL);
+
+ DWORD byte_count = 0;
+ DWORD type = 0;
+ uint8* buffer = 0;
+
+ // first get the size of the buffer
+ HRESULT hr = GetValueHelper(value_name, &type, &buffer, &byte_count);
+ ASSERT((hr != S_OK) || (type == REG_MULTI_SZ));
+
+ if (SUCCEEDED(hr)) {
+ hr = MultiSZBytesToStringArray(buffer, byte_count, value);
+ }
+
+ return hr;
+}
+
+// Binary data Get
+HRESULT RegKey::GetValue(const wchar_t* value_name,
+ uint8** value,
+ DWORD* byte_count) const {
+ ASSERT(byte_count != NULL);
+ ASSERT(value != NULL);
+
+ DWORD type = 0;
+ HRESULT hr = GetValueHelper(value_name, &type, value, byte_count);
+ ASSERT((hr != S_OK) || (type == REG_MULTI_SZ) || (type == REG_BINARY));
+ return hr;
+}
+
+// Raw data get
+HRESULT RegKey::GetValue(const wchar_t* value_name,
+ uint8** value,
+ DWORD* byte_count,
+ DWORD*type) const {
+ ASSERT(type != NULL);
+ ASSERT(byte_count != NULL);
+ ASSERT(value != NULL);
+
+ return GetValueHelper(value_name, type, value, byte_count);
+}
+
+// Int32 set
+HRESULT RegKey::SetValue(const wchar_t* value_name, DWORD value) const {
+ ASSERT(h_key_ != NULL);
+
+ LONG res = ::RegSetValueEx(h_key_, value_name, NULL, REG_DWORD,
+ reinterpret_cast<const uint8*>(&value),
+ sizeof(DWORD));
+ return HRESULT_FROM_WIN32(res);
+}
+
+// Int64 set
+HRESULT RegKey::SetValue(const wchar_t* value_name, DWORD64 value) const {
+ ASSERT(h_key_ != NULL);
+
+ LONG res = ::RegSetValueEx(h_key_, value_name, NULL, REG_QWORD,
+ reinterpret_cast<const uint8*>(&value),
+ sizeof(DWORD64));
+ return HRESULT_FROM_WIN32(res);
+}
+
+// String set
+HRESULT RegKey::SetValue(const wchar_t* value_name,
+ const wchar_t* value) const {
+ ASSERT(value != NULL);
+ ASSERT(h_key_ != NULL);
+
+ LONG res = ::RegSetValueEx(h_key_, value_name, NULL, REG_SZ,
+ reinterpret_cast<const uint8*>(value),
+ (lstrlen(value) + 1) * sizeof(wchar_t));
+ return HRESULT_FROM_WIN32(res);
+}
+
+// Binary data set
+HRESULT RegKey::SetValue(const wchar_t* value_name,
+ const uint8* value,
+ DWORD byte_count) const {
+ ASSERT(h_key_ != NULL);
+
+ // special case - if 'value' is NULL make sure byte_count is zero
+ if (value == NULL) {
+ byte_count = 0;
+ }
+
+ LONG res = ::RegSetValueEx(h_key_, value_name, NULL,
+ REG_BINARY, value, byte_count);
+ return HRESULT_FROM_WIN32(res);
+}
+
+// Raw data set
+HRESULT RegKey::SetValue(const wchar_t* value_name,
+ const uint8* value,
+ DWORD byte_count,
+ DWORD type) const {
+ ASSERT(value != NULL);
+ ASSERT(h_key_ != NULL);
+
+ LONG res = ::RegSetValueEx(h_key_, value_name, NULL, type, value, byte_count);
+ return HRESULT_FROM_WIN32(res);
+}
+
+bool RegKey::HasKey(const wchar_t* full_key_name) {
+ ASSERT(full_key_name != NULL);
+
+ // get the root HKEY
+ std::wstring key_name(full_key_name);
+ HKEY h_key = GetRootKeyInfo(&key_name);
+
+ if (h_key != NULL) {
+ RegKey key;
+ HRESULT hr = key.Open(h_key, key_name.c_str(), KEY_READ);
+ key.Close();
+ return S_OK == hr;
+ }
+ return false;
+}
+
+// static version of HasValue
+bool RegKey::HasValue(const wchar_t* full_key_name, const wchar_t* value_name) {
+ ASSERT(full_key_name != NULL);
+
+ bool has_value = false;
+ // get the root HKEY
+ std::wstring key_name(full_key_name);
+ HKEY h_key = GetRootKeyInfo(&key_name);
+
+ if (h_key != NULL) {
+ RegKey key;
+ if (key.Open(h_key, key_name.c_str(), KEY_READ) == S_OK) {
+ has_value = key.HasValue(value_name);
+ key.Close();
+ }
+ }
+ return has_value;
+}
+
+HRESULT RegKey::GetValueType(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ DWORD* value_type) {
+ ASSERT(full_key_name != NULL);
+ ASSERT(value_type != NULL);
+
+ *value_type = REG_NONE;
+
+ std::wstring key_name(full_key_name);
+ HKEY h_key = GetRootKeyInfo(&key_name);
+
+ RegKey key;
+ HRESULT hr = key.Open(h_key, key_name.c_str(), KEY_READ);
+ if (SUCCEEDED(hr)) {
+ LONG res = ::SHQueryValueEx(key.h_key_, value_name, NULL, value_type,
+ NULL, NULL);
+ if (res != ERROR_SUCCESS) {
+ hr = HRESULT_FROM_WIN32(res);
+ }
+ }
+
+ return hr;
+}
+
+HRESULT RegKey::DeleteKey(const wchar_t* full_key_name) {
+ ASSERT(full_key_name != NULL);
+
+ return DeleteKey(full_key_name, true);
+}
+
+HRESULT RegKey::DeleteKey(const wchar_t* full_key_name, bool recursively) {
+ ASSERT(full_key_name != NULL);
+
+ // need to open the parent key first
+ // get the root HKEY
+ std::wstring key_name(full_key_name);
+ HKEY h_key = GetRootKeyInfo(&key_name);
+
+ // get the parent key
+ std::wstring parent_key(GetParentKeyInfo(&key_name));
+
+ RegKey key;
+ HRESULT hr = key.Open(h_key, parent_key.c_str());
+
+ if (hr == S_OK) {
+ hr = recursively ? key.RecurseDeleteSubKey(key_name.c_str())
+ : key.DeleteSubKey(key_name.c_str());
+ } else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) ||
+ hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND)) {
+ hr = S_FALSE;
+ }
+
+ key.Close();
+ return hr;
+}
+
+HRESULT RegKey::DeleteValue(const wchar_t* full_key_name,
+ const wchar_t* value_name) {
+ ASSERT(full_key_name != NULL);
+
+ HRESULT hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
+ // get the root HKEY
+ std::wstring key_name(full_key_name);
+ HKEY h_key = GetRootKeyInfo(&key_name);
+
+ if (h_key != NULL) {
+ RegKey key;
+ hr = key.Open(h_key, key_name.c_str());
+ if (hr == S_OK) {
+ hr = key.DeleteValue(value_name);
+ key.Close();
+ }
+ }
+ return hr;
+}
+
+HRESULT RegKey::RecurseDeleteSubKey(const wchar_t* key_name) {
+ ASSERT(key_name != NULL);
+
+ RegKey key;
+ HRESULT hr = key.Open(h_key_, key_name);
+
+ if (hr == S_OK) {
+ // enumerate all subkeys of this key and recursivelly delete them
+ FILETIME time = {0};
+ wchar_t key_name_buf[kMaxKeyNameChars] = {0};
+ DWORD key_name_buf_size = kMaxKeyNameChars;
+ while (hr == S_OK &&
+ ::RegEnumKeyEx(key.h_key_, 0, key_name_buf, &key_name_buf_size,
+ NULL, NULL, NULL, &time) == ERROR_SUCCESS) {
+ hr = key.RecurseDeleteSubKey(key_name_buf);
+
+ // restore the buffer size
+ key_name_buf_size = kMaxKeyNameChars;
+ }
+ // close the top key
+ key.Close();
+ }
+
+ if (hr == S_OK) {
+ // the key has no more children keys
+ // delete the key and all of its values
+ hr = DeleteSubKey(key_name);
+ }
+
+ return hr;
+}
+
+HKEY RegKey::GetRootKeyInfo(std::wstring* full_key_name) {
+ ASSERT(full_key_name != NULL);
+
+ HKEY h_key = NULL;
+ // get the root HKEY
+ int index = full_key_name->find(L'\\');
+ std::wstring root_key;
+
+ if (index == -1) {
+ root_key = *full_key_name;
+ *full_key_name = L"";
+ } else {
+ root_key = full_key_name->substr(0, index);
+ *full_key_name = full_key_name->substr(index + 1,
+ full_key_name->length() - index - 1);
+ }
+
+ for (std::wstring::iterator iter = root_key.begin();
+ iter != root_key.end(); ++iter) {
+ *iter = toupper(*iter);
+ }
+
+ if (!root_key.compare(L"HKLM") ||
+ !root_key.compare(L"HKEY_LOCAL_MACHINE")) {
+ h_key = HKEY_LOCAL_MACHINE;
+ } else if (!root_key.compare(L"HKCU") ||
+ !root_key.compare(L"HKEY_CURRENT_USER")) {
+ h_key = HKEY_CURRENT_USER;
+ } else if (!root_key.compare(L"HKU") ||
+ !root_key.compare(L"HKEY_USERS")) {
+ h_key = HKEY_USERS;
+ } else if (!root_key.compare(L"HKCR") ||
+ !root_key.compare(L"HKEY_CLASSES_ROOT")) {
+ h_key = HKEY_CLASSES_ROOT;
+ }
+
+ return h_key;
+}
+
+
+// Returns true if this key name is 'safe' for deletion
+// (doesn't specify a key root)
+bool RegKey::SafeKeyNameForDeletion(const wchar_t* key_name) {
+ ASSERT(key_name != NULL);
+ std::wstring key(key_name);
+
+ HKEY root_key = GetRootKeyInfo(&key);
+
+ if (!root_key) {
+ key = key_name;
+ }
+ if (key.empty()) {
+ return false;
+ }
+ bool found_subkey = false, backslash_found = false;
+ for (size_t i = 0 ; i < key.length() ; ++i) {
+ if (key[i] == L'\\') {
+ backslash_found = true;
+ } else if (backslash_found) {
+ found_subkey = true;
+ break;
+ }
+ }
+ return (root_key == HKEY_USERS) ? found_subkey : true;
+}
+
+std::wstring RegKey::GetParentKeyInfo(std::wstring* key_name) {
+ ASSERT(key_name != NULL);
+
+ // get the parent key
+ int index = key_name->rfind(L'\\');
+ std::wstring parent_key;
+ if (index == -1) {
+ parent_key = L"";
+ } else {
+ parent_key = key_name->substr(0, index);
+ *key_name = key_name->substr(index + 1, key_name->length() - index - 1);
+ }
+
+ return parent_key;
+}
+
+// get the number of values for this key
+uint32 RegKey::GetValueCount() {
+ DWORD num_values = 0;
+
+ LONG res = ::RegQueryInfoKey(
+ h_key_, // key handle
+ NULL, // buffer for class name
+ NULL, // size of class string
+ NULL, // reserved
+ NULL, // number of subkeys
+ NULL, // longest subkey size
+ NULL, // longest class string
+ &num_values, // number of values for this key
+ NULL, // longest value name
+ NULL, // longest value data
+ NULL, // security descriptor
+ NULL); // last write time
+
+ ASSERT(res == ERROR_SUCCESS);
+ return num_values;
+}
+
+// Enumerators for the value_names for this key
+
+// Called to get the value name for the given value name index
+// Use GetValueCount() to get the total value_name count for this key
+// Returns failure if no key at the specified index
+HRESULT RegKey::GetValueNameAt(int index, std::wstring* value_name,
+ DWORD* type) {
+ ASSERT(value_name != NULL);
+
+ LONG res = ERROR_SUCCESS;
+ wchar_t value_name_buf[kMaxValueNameChars] = {0};
+ DWORD value_name_buf_size = kMaxValueNameChars;
+ res = ::RegEnumValue(h_key_, index, value_name_buf, &value_name_buf_size,
+ NULL, type, NULL, NULL);
+
+ if (res == ERROR_SUCCESS) {
+ value_name->assign(value_name_buf);
+ }
+
+ return HRESULT_FROM_WIN32(res);
+}
+
+uint32 RegKey::GetSubkeyCount() {
+ // number of values for key
+ DWORD num_subkeys = 0;
+
+ LONG res = ::RegQueryInfoKey(
+ h_key_, // key handle
+ NULL, // buffer for class name
+ NULL, // size of class string
+ NULL, // reserved
+ &num_subkeys, // number of subkeys
+ NULL, // longest subkey size
+ NULL, // longest class string
+ NULL, // number of values for this key
+ NULL, // longest value name
+ NULL, // longest value data
+ NULL, // security descriptor
+ NULL); // last write time
+
+ ASSERT(res == ERROR_SUCCESS);
+ return num_subkeys;
+}
+
+HRESULT RegKey::GetSubkeyNameAt(int index, std::wstring* key_name) {
+ ASSERT(key_name != NULL);
+
+ LONG res = ERROR_SUCCESS;
+ wchar_t key_name_buf[kMaxKeyNameChars] = {0};
+ DWORD key_name_buf_size = kMaxKeyNameChars;
+
+ res = ::RegEnumKeyEx(h_key_, index, key_name_buf, &key_name_buf_size,
+ NULL, NULL, NULL, NULL);
+
+ if (res == ERROR_SUCCESS) {
+ key_name->assign(key_name_buf);
+ }
+
+ return HRESULT_FROM_WIN32(res);
+}
+
+// Is the key empty: having no sub-keys and values
+bool RegKey::IsKeyEmpty(const wchar_t* full_key_name) {
+ ASSERT(full_key_name != NULL);
+
+ bool is_empty = true;
+
+ // Get the root HKEY
+ std::wstring key_name(full_key_name);
+ HKEY h_key = GetRootKeyInfo(&key_name);
+
+ // Open the key to check
+ if (h_key != NULL) {
+ RegKey key;
+ HRESULT hr = key.Open(h_key, key_name.c_str(), KEY_READ);
+ if (SUCCEEDED(hr)) {
+ is_empty = key.GetSubkeyCount() == 0 && key.GetValueCount() == 0;
+ key.Close();
+ }
+ }
+
+ return is_empty;
+}
+
+bool AdjustCurrentProcessPrivilege(const TCHAR* privilege, bool to_enable) {
+ ASSERT(privilege != NULL);
+
+ bool ret = false;
+ HANDLE token;
+ if (::OpenProcessToken(::GetCurrentProcess(),
+ TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token)) {
+ LUID luid;
+ memset(&luid, 0, sizeof(luid));
+ if (::LookupPrivilegeValue(NULL, privilege, &luid)) {
+ TOKEN_PRIVILEGES privs;
+ privs.PrivilegeCount = 1;
+ privs.Privileges[0].Luid = luid;
+ privs.Privileges[0].Attributes = to_enable ? SE_PRIVILEGE_ENABLED : 0;
+ if (::AdjustTokenPrivileges(token, FALSE, &privs, 0, NULL, 0)) {
+ ret = true;
+ } else {
+ LOG_GLE(LS_ERROR) << "AdjustTokenPrivileges failed";
+ }
+ } else {
+ LOG_GLE(LS_ERROR) << "LookupPrivilegeValue failed";
+ }
+ CloseHandle(token);
+ } else {
+ LOG_GLE(LS_ERROR) << "OpenProcessToken(GetCurrentProcess) failed";
+ }
+
+ return ret;
+}
+
+} // namespace talk_base
diff --git a/talk/base/win32regkey.h b/talk/base/win32regkey.h
new file mode 100644
index 0000000..9f01ce1
--- /dev/null
+++ b/talk/base/win32regkey.h
@@ -0,0 +1,354 @@
+/*
+ * libjingle
+ * Copyright 2003-2007, 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.
+ */
+
+// Registry configuration wrappers class
+//
+// Offers static functions for convenient
+// fast access for individual values
+//
+// Also provides a wrapper class for efficient
+// batch operations on values of a given registry key.
+//
+
+#ifndef TALK_BASE_WIN32REGKEY_H_
+#define TALK_BASE_WIN32REGKEY_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/base/basictypes.h"
+#include "talk/base/win32.h"
+
+namespace talk_base {
+
+// maximum sizes registry key and value names
+const int kMaxKeyNameChars = 255 + 1;
+const int kMaxValueNameChars = 16383 + 1;
+
+class RegKey {
+ public:
+ // constructor
+ RegKey();
+
+ // destructor
+ ~RegKey();
+
+ // create a reg key
+ HRESULT Create(HKEY parent_key, const wchar_t* key_name);
+
+ HRESULT Create(HKEY parent_key,
+ const wchar_t* key_name,
+ wchar_t* reg_class,
+ DWORD options,
+ REGSAM sam_desired,
+ LPSECURITY_ATTRIBUTES lp_sec_attr,
+ LPDWORD lp_disposition);
+
+ // open an existing reg key
+ HRESULT Open(HKEY parent_key, const wchar_t* key_name);
+
+ HRESULT Open(HKEY parent_key, const wchar_t* key_name, REGSAM sam_desired);
+
+ // close this reg key
+ HRESULT Close();
+
+ // check if the key has a specified value
+ bool HasValue(const wchar_t* value_name) const;
+
+ // get the number of values for this key
+ uint32 GetValueCount();
+
+ // Called to get the value name for the given value name index
+ // Use GetValueCount() to get the total value_name count for this key
+ // Returns failure if no key at the specified index
+ // If you modify the key while enumerating, the indexes will be out of order.
+ // Since the index order is not guaranteed, you need to reset your counting
+ // loop.
+ // 'type' refers to REG_DWORD, REG_QWORD, etc..
+ // 'type' can be NULL if not interested in the value type
+ HRESULT GetValueNameAt(int index, std::wstring* value_name, DWORD* type);
+
+ // check if the current key has the specified subkey
+ bool HasSubkey(const wchar_t* key_name) const;
+
+ // get the number of subkeys for this key
+ uint32 GetSubkeyCount();
+
+ // Called to get the key name for the given key index
+ // Use GetSubkeyCount() to get the total count for this key
+ // Returns failure if no key at the specified index
+ // If you modify the key while enumerating, the indexes will be out of order.
+ // Since the index order is not guaranteed, you need to reset your counting
+ // loop.
+ HRESULT GetSubkeyNameAt(int index, std::wstring* key_name);
+
+ // SETTERS
+
+ // set an int32 value - use when reading multiple values from a key
+ HRESULT SetValue(const wchar_t* value_name, DWORD value) const;
+
+ // set an int64 value
+ HRESULT SetValue(const wchar_t* value_name, DWORD64 value) const;
+
+ // set a string value
+ HRESULT SetValue(const wchar_t* value_name, const wchar_t* value) const;
+
+ // set binary data
+ HRESULT SetValue(const wchar_t* value_name,
+ const uint8* value,
+ DWORD byte_count) const;
+
+ // set raw data, including type
+ HRESULT SetValue(const wchar_t* value_name,
+ const uint8* value,
+ DWORD byte_count,
+ DWORD type) const;
+
+ // GETTERS
+
+ // get an int32 value
+ HRESULT GetValue(const wchar_t* value_name, DWORD* value) const;
+
+ // get an int64 value
+ HRESULT GetValue(const wchar_t* value_name, DWORD64* value) const;
+
+ // get a string value - the caller must free the return buffer
+ HRESULT GetValue(const wchar_t* value_name, wchar_t** value) const;
+
+ // get a string value
+ HRESULT GetValue(const wchar_t* value_name, std::wstring* value) const;
+
+ // get a std::vector<std::wstring> value from REG_MULTI_SZ type
+ HRESULT GetValue(const wchar_t* value_name,
+ std::vector<std::wstring>* value) const;
+
+ // get binary data - the caller must free the return buffer
+ HRESULT GetValue(const wchar_t* value_name,
+ uint8** value,
+ DWORD* byte_count) const;
+
+ // get raw data, including type - the caller must free the return buffer
+ HRESULT GetValue(const wchar_t* value_name,
+ uint8** value,
+ DWORD* byte_count,
+ DWORD* type) const;
+
+ // STATIC VERSIONS
+
+ // flush
+ static HRESULT FlushKey(const wchar_t* full_key_name);
+
+ // check if a key exists
+ static bool HasKey(const wchar_t* full_key_name);
+
+ // check if the key has a specified value
+ static bool HasValue(const wchar_t* full_key_name, const wchar_t* value_name);
+
+ // SETTERS
+
+ // STATIC int32 set
+ static HRESULT SetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ DWORD value);
+
+ // STATIC int64 set
+ static HRESULT SetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ DWORD64 value);
+
+ // STATIC float set
+ static HRESULT SetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ float value);
+
+ // STATIC double set
+ static HRESULT SetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ double value);
+
+ // STATIC string set
+ static HRESULT SetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ const wchar_t* value);
+
+ // STATIC binary data set
+ static HRESULT SetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ const uint8* value,
+ DWORD byte_count);
+
+ // STATIC multi-string set
+ static HRESULT SetValueMultiSZ(const wchar_t* full_key_name,
+ const TCHAR* value_name,
+ const uint8* value,
+ DWORD byte_count);
+
+ // GETTERS
+
+ // STATIC int32 get
+ static HRESULT GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ DWORD* value);
+
+ // STATIC int64 get
+ //
+ // Note: if you are using time64 you should
+ // likely use GetLimitedTimeValue (util.h) instead of this method.
+ static HRESULT GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ DWORD64* value);
+
+ // STATIC float get
+ static HRESULT GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ float* value);
+
+ // STATIC double get
+ static HRESULT GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ double* value);
+
+ // STATIC string get
+ // Note: the caller must free the return buffer for wchar_t* version
+ static HRESULT GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ wchar_t** value);
+ static HRESULT GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ std::wstring* value);
+
+ // STATIC REG_MULTI_SZ get
+ static HRESULT GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ std::vector<std::wstring>* value);
+
+ // STATIC get binary data - the caller must free the return buffer
+ static HRESULT GetValue(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ uint8** value,
+ DWORD* byte_count);
+
+ // Get type of a registry value
+ static HRESULT GetValueType(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ DWORD* value_type);
+
+ // delete a subkey of the current key (with no subkeys)
+ HRESULT DeleteSubKey(const wchar_t* key_name);
+
+ // recursively delete a sub key of the current key (and all its subkeys)
+ HRESULT RecurseDeleteSubKey(const wchar_t* key_name);
+
+ // STATIC version of delete key - handles nested keys also
+ // delete a key and all its sub-keys recursively
+ // Returns S_FALSE if key didn't exist, S_OK if deletion was successful,
+ // and failure otherwise.
+ static HRESULT DeleteKey(const wchar_t* full_key_name);
+
+ // STATIC version of delete key
+ // delete a key recursively or non-recursively
+ // Returns S_FALSE if key didn't exist, S_OK if deletion was successful,
+ // and failure otherwise.
+ static HRESULT DeleteKey(const wchar_t* full_key_name, bool recursive);
+
+ // delete the specified value
+ HRESULT DeleteValue(const wchar_t* value_name);
+
+ // STATIC version of delete value
+ // Returns S_FALSE if key didn't exist, S_OK if deletion was successful,
+ // and failure otherwise.
+ static HRESULT DeleteValue(const wchar_t* full_key_name,
+ const wchar_t* value_name);
+
+ // Peek inside (use a RegKey as a smart wrapper around a registry handle)
+ HKEY key() { return h_key_; }
+
+ // helper function to get the HKEY and the root key from a string
+ // modifies the argument in place and returns the key name
+ // e.g. HKLM\\Software\\Google\... returns HKLM, "Software\\Google\..."
+ // Necessary for the static versions that use the full name of the reg key
+ static HKEY GetRootKeyInfo(std::wstring* full_key_name);
+
+ // Returns true if this key name is 'safe' for deletion (doesn't specify a key
+ // root)
+ static bool SafeKeyNameForDeletion(const wchar_t* key_name);
+
+ // save the key and all of its subkeys and values to a file
+ static HRESULT Save(const wchar_t* full_key_name, const wchar_t* file_name);
+
+ // restore the key and all of its subkeys and values which are saved into a
+ // file
+ static HRESULT Restore(const wchar_t* full_key_name,
+ const wchar_t* file_name);
+
+ // Is the key empty: having no sub-keys and values
+ static bool IsKeyEmpty(const wchar_t* full_key_name);
+
+ private:
+
+ // helper function to get any value from the registry
+ // used when the size of the data is unknown
+ HRESULT GetValueHelper(const wchar_t* value_name,
+ DWORD* type, uint8** value,
+ DWORD* byte_count) const;
+
+ // helper function to get the parent key name and the subkey from a string
+ // modifies the argument in place and returns the key name
+ // Necessary for the static versions that use the full name of the reg key
+ static std::wstring GetParentKeyInfo(std::wstring* key_name);
+
+ // common SET Helper for the static case
+ static HRESULT SetValueStaticHelper(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ DWORD type,
+ LPVOID value,
+ DWORD byte_count = 0);
+
+ // common GET Helper for the static case
+ static HRESULT GetValueStaticHelper(const wchar_t* full_key_name,
+ const wchar_t* value_name,
+ DWORD type,
+ LPVOID value,
+ DWORD* byte_count = NULL);
+
+ // convert REG_MULTI_SZ bytes to string array
+ static HRESULT MultiSZBytesToStringArray(const uint8* buffer,
+ DWORD byte_count,
+ std::vector<std::wstring>* value);
+
+ // the HKEY for the current key
+ HKEY h_key_;
+
+ // for unittest
+ friend void RegKeyHelperFunctionsTest();
+
+ DISALLOW_EVIL_CONSTRUCTORS(RegKey);
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_WIN32REGKEY_H_
diff --git a/talk/base/win32regkey_unittest.cc b/talk/base/win32regkey_unittest.cc
new file mode 100644
index 0000000..1dd8fe4
--- /dev/null
+++ b/talk/base/win32regkey_unittest.cc
@@ -0,0 +1,607 @@
+/*
+ * libjingle
+ * Copyright 2003-2008, 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.
+ */
+
+// Unittest for registry access API
+
+#include "talk/base/gunit.h"
+#include "talk/base/common.h"
+#include "talk/base/win32regkey.h"
+
+namespace talk_base {
+
+#ifndef EXPECT_SUCCEEDED
+#define EXPECT_SUCCEEDED(x) EXPECT_TRUE(SUCCEEDED(x))
+#endif
+
+#ifndef EXPECT_FAILED
+#define EXPECT_FAILED(x) EXPECT_TRUE(FAILED(x))
+#endif
+
+#define kBaseKey L"Software\\Google\\__TEST"
+#define kSubkeyName L"subkey_test"
+
+const wchar_t kRkey1[] = kBaseKey;
+const wchar_t kRkey1SubkeyName[] = kSubkeyName;
+const wchar_t kRkey1Subkey[] = kBaseKey L"\\" kSubkeyName;
+const wchar_t kFullRkey1[] = L"HKCU\\" kBaseKey;
+const wchar_t kFullRkey1Subkey[] = L"HKCU\\" kBaseKey L"\\" kSubkeyName;
+
+const wchar_t kValNameInt[] = L"Int32 Value";
+const DWORD kIntVal = 20;
+const DWORD kIntVal2 = 30;
+
+const wchar_t kValNameInt64[] = L"Int64 Value";
+const DWORD64 kIntVal64 = 119600064000000000uI64;
+
+const wchar_t kValNameFloat[] = L"Float Value";
+const float kFloatVal = 12.3456789f;
+
+const wchar_t kValNameDouble[] = L"Double Value";
+const double kDoubleVal = 98.7654321;
+
+const wchar_t kValNameStr[] = L"Str Value";
+const wchar_t kStrVal[] = L"Some string data 1";
+const wchar_t kStrVal2[] = L"Some string data 2";
+
+const wchar_t kValNameBinary[] = L"Binary Value";
+const char kBinaryVal[] = "Some binary data abcdefghi 1";
+const char kBinaryVal2[] = "Some binary data abcdefghi 2";
+
+const wchar_t kValNameMultiStr[] = L"MultiStr Value";
+const wchar_t kMultiSZ[] = L"abc\0def\0P12345\0";
+const wchar_t kEmptyMultiSZ[] = L"";
+const wchar_t kInvalidMultiSZ[] = {L'6', L'7', L'8'};
+
+// friend function of RegKey
+void RegKeyHelperFunctionsTest() {
+ // Try out some dud values
+ std::wstring temp_key = L"";
+ EXPECT_TRUE(RegKey::GetRootKeyInfo(&temp_key) == NULL);
+ EXPECT_STREQ(temp_key.c_str(), L"");
+
+ temp_key = L"a";
+ EXPECT_TRUE(RegKey::GetRootKeyInfo(&temp_key) == NULL);
+ EXPECT_STREQ(temp_key.c_str(), L"");
+
+ // The basics
+ temp_key = L"HKLM\\a";
+ EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_LOCAL_MACHINE);
+ EXPECT_STREQ(temp_key.c_str(), L"a");
+
+ temp_key = L"HKEY_LOCAL_MACHINE\\a";
+ EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_LOCAL_MACHINE);
+ EXPECT_STREQ(temp_key.c_str(), L"a");
+
+ temp_key = L"HKCU\\a";
+ EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_CURRENT_USER);
+ EXPECT_STREQ(temp_key.c_str(), L"a");
+
+ temp_key = L"HKEY_CURRENT_USER\\a";
+ EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_CURRENT_USER);
+ EXPECT_STREQ(temp_key.c_str(), L"a");
+
+ temp_key = L"HKU\\a";
+ EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_USERS);
+ EXPECT_STREQ(temp_key.c_str(), L"a");
+
+ temp_key = L"HKEY_USERS\\a";
+ EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_USERS);
+ EXPECT_STREQ(temp_key.c_str(), L"a");
+
+ temp_key = L"HKCR\\a";
+ EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_CLASSES_ROOT);
+ EXPECT_STREQ(temp_key.c_str(), L"a");
+
+ temp_key = L"HKEY_CLASSES_ROOT\\a";
+ EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_CLASSES_ROOT);
+ EXPECT_STREQ(temp_key.c_str(), L"a");
+
+ // Make sure it is case insensitive
+ temp_key = L"hkcr\\a";
+ EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_CLASSES_ROOT);
+ EXPECT_STREQ(temp_key.c_str(), L"a");
+
+ temp_key = L"hkey_CLASSES_ROOT\\a";
+ EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_CLASSES_ROOT);
+ EXPECT_STREQ(temp_key.c_str(), L"a");
+
+ //
+ // Test RegKey::GetParentKeyInfo
+ //
+
+ // dud cases
+ temp_key = L"";
+ EXPECT_STREQ(RegKey::GetParentKeyInfo(&temp_key).c_str(), L"");
+ EXPECT_STREQ(temp_key.c_str(), L"");
+
+ temp_key = L"a";
+ EXPECT_STREQ(RegKey::GetParentKeyInfo(&temp_key).c_str(), L"");
+ EXPECT_STREQ(temp_key.c_str(), L"a");
+
+ temp_key = L"a\\b";
+ EXPECT_STREQ(RegKey::GetParentKeyInfo(&temp_key).c_str(), L"a");
+ EXPECT_STREQ(temp_key.c_str(), L"b");
+
+ temp_key = L"\\b";
+ EXPECT_STREQ(RegKey::GetParentKeyInfo(&temp_key).c_str(), L"");
+ EXPECT_STREQ(temp_key.c_str(), L"b");
+
+ // Some regular cases
+ temp_key = L"HKEY_CLASSES_ROOT\\moon";
+ EXPECT_STREQ(RegKey::GetParentKeyInfo(&temp_key).c_str(),
+ L"HKEY_CLASSES_ROOT");
+ EXPECT_STREQ(temp_key.c_str(), L"moon");
+
+ temp_key = L"HKEY_CLASSES_ROOT\\moon\\doggy";
+ EXPECT_STREQ(RegKey::GetParentKeyInfo(&temp_key).c_str(),
+ L"HKEY_CLASSES_ROOT\\moon");
+ EXPECT_STREQ(temp_key.c_str(), L"doggy");
+
+ //
+ // Test MultiSZBytesToStringArray
+ //
+
+ std::vector<std::wstring> result;
+ EXPECT_SUCCEEDED(RegKey::MultiSZBytesToStringArray(
+ reinterpret_cast<const uint8*>(kMultiSZ), sizeof(kMultiSZ), &result));
+ EXPECT_EQ(result.size(), 3);
+ EXPECT_STREQ(result[0].c_str(), L"abc");
+ EXPECT_STREQ(result[1].c_str(), L"def");
+ EXPECT_STREQ(result[2].c_str(), L"P12345");
+
+ EXPECT_SUCCEEDED(RegKey::MultiSZBytesToStringArray(
+ reinterpret_cast<const uint8*>(kEmptyMultiSZ),
+ sizeof(kEmptyMultiSZ), &result));
+ EXPECT_EQ(result.size(), 0);
+ EXPECT_FALSE(SUCCEEDED(RegKey::MultiSZBytesToStringArray(
+ reinterpret_cast<const uint8*>(kInvalidMultiSZ),
+ sizeof(kInvalidMultiSZ), &result)));
+}
+
+TEST(RegKeyTest, RegKeyHelperFunctionsTest) {
+ RegKeyHelperFunctionsTest();
+}
+
+TEST(RegKeyTest, RegKeyNonStaticFunctionsTest) {
+ DWORD int_val = 0;
+ DWORD64 int64_val = 0;
+ wchar_t* str_val = NULL;
+ uint8* binary_val = NULL;
+ DWORD uint8_count = 0;
+
+ // Just in case...
+ // make sure the no test key residue is left from previous aborted runs
+ RegKey::DeleteKey(kFullRkey1);
+
+ // initial state
+ RegKey r_key;
+ EXPECT_TRUE(r_key.key() == NULL);
+
+ // create a reg key
+ EXPECT_SUCCEEDED(r_key.Create(HKEY_CURRENT_USER, kRkey1));
+
+ // do the create twice - it should return the already created one
+ EXPECT_SUCCEEDED(r_key.Create(HKEY_CURRENT_USER, kRkey1));
+
+ // now do an open - should work just fine
+ EXPECT_SUCCEEDED(r_key.Open(HKEY_CURRENT_USER, kRkey1));
+
+ // get an in-existent value
+ EXPECT_EQ(r_key.GetValue(kValNameInt, &int_val),
+ HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND));
+
+ // set and get some values
+
+ // set an INT 32
+ EXPECT_SUCCEEDED(r_key.SetValue(kValNameInt, kIntVal));
+
+ // check that the value exists
+ EXPECT_TRUE(r_key.HasValue(kValNameInt));
+
+ // read it back
+ EXPECT_SUCCEEDED(r_key.GetValue(kValNameInt, &int_val));
+ EXPECT_EQ(int_val, kIntVal);
+
+ // set it again!
+ EXPECT_SUCCEEDED(r_key.SetValue(kValNameInt, kIntVal2));
+
+ // read it again
+ EXPECT_SUCCEEDED(r_key.GetValue(kValNameInt, &int_val));
+ EXPECT_EQ(int_val, kIntVal2);
+
+ // delete the value
+ EXPECT_SUCCEEDED(r_key.DeleteValue(kValNameInt));
+
+ // check that the value is gone
+ EXPECT_FALSE(r_key.HasValue(kValNameInt));
+
+ // set an INT 64
+ EXPECT_SUCCEEDED(r_key.SetValue(kValNameInt64, kIntVal64));
+
+ // check that the value exists
+ EXPECT_TRUE(r_key.HasValue(kValNameInt64));
+
+ // read it back
+ EXPECT_SUCCEEDED(r_key.GetValue(kValNameInt64, &int64_val));
+ EXPECT_EQ(int64_val, kIntVal64);
+
+ // delete the value
+ EXPECT_SUCCEEDED(r_key.DeleteValue(kValNameInt64));
+
+ // check that the value is gone
+ EXPECT_FALSE(r_key.HasValue(kValNameInt64));
+
+ // set a string
+ EXPECT_SUCCEEDED(r_key.SetValue(kValNameStr, kStrVal));
+
+ // check that the value exists
+ EXPECT_TRUE(r_key.HasValue(kValNameStr));
+
+ // read it back
+ EXPECT_SUCCEEDED(r_key.GetValue(kValNameStr, &str_val));
+ EXPECT_TRUE(lstrcmp(str_val, kStrVal) == 0);
+ delete[] str_val;
+
+ // set it again
+ EXPECT_SUCCEEDED(r_key.SetValue(kValNameStr, kStrVal2));
+
+ // read it again
+ EXPECT_SUCCEEDED(r_key.GetValue(kValNameStr, &str_val));
+ EXPECT_TRUE(lstrcmp(str_val, kStrVal2) == 0);
+ delete[] str_val;
+
+ // delete the value
+ EXPECT_SUCCEEDED(r_key.DeleteValue(kValNameStr));
+
+ // check that the value is gone
+ EXPECT_FALSE(r_key.HasValue(kValNameInt));
+
+ // set a binary value
+ EXPECT_SUCCEEDED(r_key.SetValue(kValNameBinary,
+ reinterpret_cast<const uint8*>(kBinaryVal), sizeof(kBinaryVal) - 1));
+
+ // check that the value exists
+ EXPECT_TRUE(r_key.HasValue(kValNameBinary));
+
+ // read it back
+ EXPECT_SUCCEEDED(r_key.GetValue(kValNameBinary, &binary_val, &uint8_count));
+ EXPECT_TRUE(memcmp(binary_val, kBinaryVal, sizeof(kBinaryVal) - 1) == 0);
+ delete[] binary_val;
+
+ // set it again
+ EXPECT_SUCCEEDED(r_key.SetValue(kValNameBinary,
+ reinterpret_cast<const uint8*>(kBinaryVal2), sizeof(kBinaryVal) - 1));
+
+ // read it again
+ EXPECT_SUCCEEDED(r_key.GetValue(kValNameBinary, &binary_val, &uint8_count));
+ EXPECT_TRUE(memcmp(binary_val, kBinaryVal2, sizeof(kBinaryVal2) - 1) == 0);
+ delete[] binary_val;
+
+ // delete the value
+ EXPECT_SUCCEEDED(r_key.DeleteValue(kValNameBinary));
+
+ // check that the value is gone
+ EXPECT_FALSE(r_key.HasValue(kValNameBinary));
+
+ // set some values and check the total count
+
+ // set an INT 32
+ EXPECT_SUCCEEDED(r_key.SetValue(kValNameInt, kIntVal));
+
+ // set an INT 64
+ EXPECT_SUCCEEDED(r_key.SetValue(kValNameInt64, kIntVal64));
+
+ // set a string
+ EXPECT_SUCCEEDED(r_key.SetValue(kValNameStr, kStrVal));
+
+ // set a binary value
+ EXPECT_SUCCEEDED(r_key.SetValue(kValNameBinary,
+ reinterpret_cast<const uint8*>(kBinaryVal), sizeof(kBinaryVal) - 1));
+
+ // get the value count
+ uint32 value_count = r_key.GetValueCount();
+ EXPECT_EQ(value_count, 4);
+
+ // check the value names
+ std::wstring value_name;
+ DWORD type = 0;
+
+ EXPECT_SUCCEEDED(r_key.GetValueNameAt(0, &value_name, &type));
+ EXPECT_STREQ(value_name.c_str(), kValNameInt);
+ EXPECT_EQ(type, REG_DWORD);
+
+ EXPECT_SUCCEEDED(r_key.GetValueNameAt(1, &value_name, &type));
+ EXPECT_STREQ(value_name.c_str(), kValNameInt64);
+ EXPECT_EQ(type, REG_QWORD);
+
+ EXPECT_SUCCEEDED(r_key.GetValueNameAt(2, &value_name, &type));
+ EXPECT_STREQ(value_name.c_str(), kValNameStr);
+ EXPECT_EQ(type, REG_SZ);
+
+ EXPECT_SUCCEEDED(r_key.GetValueNameAt(3, &value_name, &type));
+ EXPECT_STREQ(value_name.c_str(), kValNameBinary);
+ EXPECT_EQ(type, REG_BINARY);
+
+ // check that there are no more values
+ EXPECT_FAILED(r_key.GetValueNameAt(4, &value_name, &type));
+
+ uint32 subkey_count = r_key.GetSubkeyCount();
+ EXPECT_EQ(subkey_count, 0);
+
+ // now create a subkey and make sure we can get the name
+ RegKey temp_key;
+ EXPECT_SUCCEEDED(temp_key.Create(HKEY_CURRENT_USER, kRkey1Subkey));
+
+ // check the subkey exists
+ EXPECT_TRUE(r_key.HasSubkey(kRkey1SubkeyName));
+
+ // check the name
+ EXPECT_EQ(r_key.GetSubkeyCount(), 1);
+
+ std::wstring subkey_name;
+ EXPECT_SUCCEEDED(r_key.GetSubkeyNameAt(0, &subkey_name));
+ EXPECT_STREQ(subkey_name.c_str(), kRkey1SubkeyName);
+
+ // delete the key
+ EXPECT_SUCCEEDED(r_key.DeleteSubKey(kRkey1));
+
+ // close this key
+ EXPECT_SUCCEEDED(r_key.Close());
+
+ // whack the whole key
+ EXPECT_SUCCEEDED(RegKey::DeleteKey(kFullRkey1));
+}
+
+TEST(RegKeyTest, RegKeyStaticFunctionsTest) {
+ DWORD int_val = 0;
+ DWORD64 int64_val = 0;
+ float float_val = 0;
+ double double_val = 0;
+ wchar_t* str_val = NULL;
+ std::wstring wstr_val;
+ uint8* binary_val = NULL;
+ DWORD uint8_count = 0;
+
+ // Just in case...
+ // make sure the no test key residue is left from previous aborted runs
+ RegKey::DeleteKey(kFullRkey1);
+
+ // get an in-existent value from an un-existent key
+ EXPECT_EQ(RegKey::GetValue(kFullRkey1, kValNameInt, &int_val),
+ HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND));
+
+ // set int32
+ EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameInt, kIntVal));
+
+ // check that the value exists
+ EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameInt));
+
+ // get an in-existent value from an existent key
+ EXPECT_EQ(RegKey::GetValue(kFullRkey1, L"bogus", &int_val),
+ HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND));
+
+ // read it back
+ EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameInt, &int_val));
+ EXPECT_EQ(int_val, kIntVal);
+
+ // delete the value
+ EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameInt));
+
+ // check that the value is gone
+ EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameInt));
+
+ // set int64
+ EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameInt64, kIntVal64));
+
+ // check that the value exists
+ EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameInt64));
+
+ // read it back
+ EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameInt64, &int64_val));
+ EXPECT_EQ(int64_val, kIntVal64);
+
+ // delete the value
+ EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameInt64));
+
+ // check that the value is gone
+ EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameInt64));
+
+ // set float
+ EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameFloat, kFloatVal));
+
+ // check that the value exists
+ EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameFloat));
+
+ // read it back
+ EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameFloat, &float_val));
+ EXPECT_EQ(float_val, kFloatVal);
+
+ // delete the value
+ EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameFloat));
+
+ // check that the value is gone
+ EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameFloat));
+ EXPECT_FAILED(RegKey::GetValue(kFullRkey1, kValNameFloat, &float_val));
+
+ // set double
+ EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameDouble, kDoubleVal));
+
+ // check that the value exists
+ EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameDouble));
+
+ // read it back
+ EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameDouble, &double_val));
+ EXPECT_EQ(double_val, kDoubleVal);
+
+ // delete the value
+ EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameDouble));
+
+ // check that the value is gone
+ EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameDouble));
+ EXPECT_FAILED(RegKey::GetValue(kFullRkey1, kValNameDouble, &double_val));
+
+ // set string
+ EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameStr, kStrVal));
+
+ // check that the value exists
+ EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameStr));
+
+ // read it back
+ EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameStr, &str_val));
+ EXPECT_TRUE(lstrcmp(str_val, kStrVal) == 0);
+ delete[] str_val;
+
+ // read it back in std::wstring
+ EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameStr, &wstr_val));
+ EXPECT_STREQ(wstr_val.c_str(), kStrVal);
+
+ // get an in-existent value from an existent key
+ EXPECT_EQ(RegKey::GetValue(kFullRkey1, L"bogus", &str_val),
+ HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND));
+
+ // delete the value
+ EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameStr));
+
+ // check that the value is gone
+ EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameStr));
+
+ // set binary
+ EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameBinary,
+ reinterpret_cast<const uint8*>(kBinaryVal), sizeof(kBinaryVal)-1));
+
+ // check that the value exists
+ EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameBinary));
+
+ // read it back
+ EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameBinary,
+ &binary_val, &uint8_count));
+ EXPECT_TRUE(memcmp(binary_val, kBinaryVal, sizeof(kBinaryVal)-1) == 0);
+ delete[] binary_val;
+
+ // delete the value
+ EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameBinary));
+
+ // check that the value is gone
+ EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameBinary));
+
+ // special case - set a binary value with length 0
+ EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameBinary,
+ reinterpret_cast<const uint8*>(kBinaryVal), 0));
+
+ // check that the value exists
+ EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameBinary));
+
+ // read it back
+ EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameBinary,
+ &binary_val, &uint8_count));
+ EXPECT_EQ(uint8_count, 0);
+ EXPECT_TRUE(binary_val == NULL);
+ delete[] binary_val;
+
+ // delete the value
+ EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameBinary));
+
+ // check that the value is gone
+ EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameBinary));
+
+ // special case - set a NULL binary value
+ EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameBinary, NULL, 100));
+
+ // check that the value exists
+ EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameBinary));
+
+ // read it back
+ EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameBinary,
+ &binary_val, &uint8_count));
+ EXPECT_EQ(uint8_count, 0);
+ EXPECT_TRUE(binary_val == NULL);
+ delete[] binary_val;
+
+ // delete the value
+ EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameBinary));
+
+ // check that the value is gone
+ EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameBinary));
+
+ // test read/write REG_MULTI_SZ value
+ std::vector<std::wstring> result;
+ EXPECT_SUCCEEDED(RegKey::SetValueMultiSZ(kFullRkey1, kValNameMultiStr,
+ reinterpret_cast<const uint8*>(kMultiSZ), sizeof(kMultiSZ)));
+ EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameMultiStr, &result));
+ EXPECT_EQ(result.size(), 3);
+ EXPECT_STREQ(result[0].c_str(), L"abc");
+ EXPECT_STREQ(result[1].c_str(), L"def");
+ EXPECT_STREQ(result[2].c_str(), L"P12345");
+ EXPECT_SUCCEEDED(RegKey::SetValueMultiSZ(kFullRkey1, kValNameMultiStr,
+ reinterpret_cast<const uint8*>(kEmptyMultiSZ), sizeof(kEmptyMultiSZ)));
+ EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameMultiStr, &result));
+ EXPECT_EQ(result.size(), 0);
+ // writing REG_MULTI_SZ value will automatically add ending null characters
+ EXPECT_SUCCEEDED(RegKey::SetValueMultiSZ(kFullRkey1, kValNameMultiStr,
+ reinterpret_cast<const uint8*>(kInvalidMultiSZ), sizeof(kInvalidMultiSZ)));
+ EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameMultiStr, &result));
+ EXPECT_EQ(result.size(), 1);
+ EXPECT_STREQ(result[0].c_str(), L"678");
+
+ // Run the following test only in dev machine
+ // This is because the build machine might not have admin privilege
+#ifdef IS_PRIVATE_BUILD
+ // get a temp file name
+ wchar_t temp_path[MAX_PATH] = {0};
+ EXPECT_LT(::GetTempPath(ARRAY_SIZE(temp_path), temp_path),
+ static_cast<DWORD>(ARRAY_SIZE(temp_path)));
+ wchar_t temp_file[MAX_PATH] = {0};
+ EXPECT_NE(::GetTempFileName(temp_path, L"rkut_",
+ ::GetTickCount(), temp_file), 0);
+
+ // test save
+ EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1Subkey, kValNameInt, kIntVal));
+ EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1Subkey, kValNameInt64, kIntVal64));
+ EXPECT_SUCCEEDED(RegKey::Save(kFullRkey1Subkey, temp_file));
+ EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1Subkey, kValNameInt));
+ EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1Subkey, kValNameInt64));
+
+ // test restore
+ EXPECT_SUCCEEDED(RegKey::Restore(kFullRkey1Subkey, temp_file));
+ int_val = 0;
+ EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1Subkey, kValNameInt, &int_val));
+ EXPECT_EQ(int_val, kIntVal);
+ int64_val = 0;
+ EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1Subkey,
+ kValNameInt64,
+ &int64_val));
+ EXPECT_EQ(int64_val, kIntVal64);
+
+ // delete the temp file
+ EXPECT_EQ(TRUE, ::DeleteFile(temp_file));
+#endif
+
+ // whack the whole key
+ EXPECT_SUCCEEDED(RegKey::DeleteKey(kFullRkey1));
+}
+
+} // namespace talk_base
diff --git a/talk/base/win32socketserver.cc b/talk/base/win32socketserver.cc
index 0915aaf..90bb010 100644
--- a/talk/base/win32socketserver.cc
+++ b/talk/base/win32socketserver.cc
@@ -168,7 +168,7 @@
virtual bool OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
LRESULT& result);
- virtual void OnFinalMessage(HWND hWnd);
+ virtual void OnNcDestroy();
private:
bool OnSocketNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& result);
@@ -226,8 +226,13 @@
return true;
}
-void Win32Socket::EventSink::OnFinalMessage(HWND hWnd) {
- delete this;
+void Win32Socket::EventSink::OnNcDestroy() {
+ if (parent_) {
+ LOG(LS_ERROR) << "EventSink hwnd is being destroyed, but the event sink"
+ " hasn't yet been disposed.";
+ } else {
+ delete this;
+ }
}
/////////////////////////////////////////////////////////////////////////////
@@ -741,7 +746,10 @@
// was a message for the dialog that it handled internally.
// Otherwise, dispatch as usual via Translate/DispatchMessage.
b = GetMessage(&msg, NULL, 0, 0);
- if (b) {
+ if (b == -1) {
+ LOG_GLE(LS_ERROR) << "GetMessage failed.";
+ return false;
+ } else if(b) {
if (!hdlg_ || !IsDialogMessage(hdlg_, &msg)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
diff --git a/talk/base/win32socketserver_unittest.cc b/talk/base/win32socketserver_unittest.cc
new file mode 100644
index 0000000..8531861
--- /dev/null
+++ b/talk/base/win32socketserver_unittest.cc
@@ -0,0 +1,91 @@
+// Copyright 2009 Google Inc. All Rights Reserved.
+
+
+#include "talk/base/gunit.h"
+#include "talk/base/socket_unittest.h"
+#include "talk/base/thread.h"
+#include "talk/base/win32socketserver.h"
+
+namespace talk_base {
+
+// Test that Win32SocketServer::Wait works as expected.
+TEST(Win32SocketServerTest, TestWait) {
+ Win32SocketServer server(NULL);
+ uint32 start = Time();
+ server.Wait(1000, true);
+ EXPECT_GE(TimeSince(start), 1000);
+}
+
+// Test that Win32Socket::Pump does not touch general Windows messages.
+TEST(Win32SocketServerTest, TestPump) {
+ Win32SocketServer server(NULL);
+ SocketServerScope scope(&server);
+ EXPECT_EQ(TRUE, PostMessage(NULL, WM_USER, 999, 0));
+ server.Pump();
+ MSG msg;
+ EXPECT_EQ(TRUE, PeekMessage(&msg, NULL, 0, 0, PM_REMOVE));
+ EXPECT_EQ(WM_USER, msg.message);
+ EXPECT_EQ(999, msg.wParam);
+}
+
+// Test that Win32Socket passes all the generic Socket tests.
+class Win32SocketTest : public SocketTest {
+ protected:
+ Win32SocketTest() : server_(NULL), scope_(&server_) {}
+ Win32SocketServer server_;
+ SocketServerScope scope_;
+};
+
+TEST_F(Win32SocketTest, TestConnect) {
+ SocketTest::TestConnect();
+}
+
+TEST_F(Win32SocketTest, TestConnectWithDnsLookup) {
+ SocketTest::TestConnectWithDnsLookup();
+}
+
+TEST_F(Win32SocketTest, TestConnectFail) {
+ SocketTest::TestConnectFail();
+}
+
+TEST_F(Win32SocketTest, TestConnectWithDnsLookupFail) {
+ SocketTest::TestConnectWithDnsLookupFail();
+}
+
+TEST_F(Win32SocketTest, TestConnectWithClosedSocket) {
+ SocketTest::TestConnectWithClosedSocket();
+}
+
+TEST_F(Win32SocketTest, TestServerCloseDuringConnect) {
+ SocketTest::TestServerCloseDuringConnect();
+}
+
+TEST_F(Win32SocketTest, TestClientCloseDuringConnect) {
+ SocketTest::TestClientCloseDuringConnect();
+}
+
+TEST_F(Win32SocketTest, TestServerClose) {
+ SocketTest::TestServerClose();
+}
+
+TEST_F(Win32SocketTest, TestCloseInClosedCallback) {
+ SocketTest::TestCloseInClosedCallback();
+}
+
+TEST_F(Win32SocketTest, TestSocketServerWait) {
+ SocketTest::TestSocketServerWait();
+}
+
+TEST_F(Win32SocketTest, TestTcp) {
+ SocketTest::TestTcp();
+}
+
+TEST_F(Win32SocketTest, TestUdp) {
+ SocketTest::TestUdp();
+}
+
+TEST_F(Win32SocketTest, TestGetSetOptions) {
+ SocketTest::TestGetSetOptions();
+}
+
+} // namespace talk_base
diff --git a/talk/base/win32toolhelp.h b/talk/base/win32toolhelp.h
new file mode 100644
index 0000000..64a191a
--- /dev/null
+++ b/talk/base/win32toolhelp.h
@@ -0,0 +1,166 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+
+
+#ifndef TALK_BASE_WIN32TOOLHELP_H_
+#define TALK_BASE_WIN32TOOLHELP_H_
+
+#ifndef WIN32
+#error WIN32 Only
+#endif
+
+#include "talk/base/win32.h"
+
+// Should be included first, but that causes redefinitions.
+#include <tlhelp32.h>
+
+#include "talk/base/constructormagic.h"
+
+namespace talk_base {
+
+// The toolhelp api used to enumerate processes and their modules
+// on Windows is very repetetive and clunky to use. This little
+// template wraps it to make it a little more programmer friendly.
+//
+// Traits: Traits type that adapts the enumerator to the corresponding
+// win32 toolhelp api. Each traits class need to:
+// - define the type of the enumerated data as a public symbol Type
+//
+// - implement bool First(HANDLE, T*) normally calls a
+// Xxxx32First method in the toolhelp API. Ex Process32First(...)
+//
+// - implement bool Next(HANDLE, T*) normally calls a
+// Xxxx32Next method in the toolhelp API. Ex Process32Next(...)
+//
+// - implement bool CloseHandle(HANDLE)
+//
+template<typename Traits>
+class ToolhelpEnumeratorBase {
+ public:
+ ToolhelpEnumeratorBase(HANDLE snapshot)
+ : snapshot_(snapshot), broken_(false), first_(true) {
+
+ // Clear out the Traits::Type structure instance.
+ Zero(¤t_);
+ }
+
+ virtual ~ToolhelpEnumeratorBase() {
+ Close();
+ }
+
+ // Moves forward to the next object using the First and Next
+ // pointers. If either First or Next ever indicates an failure
+ // all subsequent calls to this method will fail; the enumerator
+ // object is considered broken.
+ bool Next() {
+ if (!Valid()) {
+ return false;
+ }
+
+ // Move the iteration forward.
+ current_.dwSize = sizeof(typename Traits::Type);
+ bool incr_ok = false;
+ if (first_) {
+ incr_ok = Traits::First(snapshot_, ¤t_);
+ first_ = false;
+ } else {
+ incr_ok = Traits::Next(snapshot_, ¤t_);
+ }
+
+ if (!incr_ok) {
+ Zero(¤t_);
+ broken_ = true;
+ }
+
+ return incr_ok;
+ }
+
+ const typename Traits::Type& current() const {
+ return current_;
+ }
+
+ void Close() {
+ if (snapshot_ != INVALID_HANDLE_VALUE) {
+ Traits::CloseHandle(snapshot_);
+ snapshot_ = INVALID_HANDLE_VALUE;
+ }
+ }
+
+ private:
+ // Checks the state of the snapshot handle.
+ bool Valid() {
+ return snapshot_ != INVALID_HANDLE_VALUE && !broken_;
+ }
+
+ static void Zero(typename Traits::Type* buff) {
+ ZeroMemory(buff, sizeof(typename Traits::Type));
+ }
+
+ HANDLE snapshot_;
+ typename Traits::Type current_;
+ bool broken_;
+ bool first_;
+};
+
+class ToolhelpTraits {
+ public:
+ static HANDLE CreateSnapshot(uint32 flags, uint32 process_id) {
+ return CreateToolhelp32Snapshot(flags, process_id);
+ }
+
+ static bool CloseHandle(HANDLE handle) {
+ return ::CloseHandle(handle) == TRUE;
+ }
+};
+
+class ToolhelpProcessTraits : public ToolhelpTraits {
+ public:
+ typedef PROCESSENTRY32 Type;
+
+ static bool First(HANDLE handle, Type* t) {
+ return ::Process32First(handle, t) == TRUE;
+ }
+
+ static bool Next(HANDLE handle, Type* t) {
+ return ::Process32Next(handle, t) == TRUE;
+ }
+};
+
+class ProcessEnumerator : public ToolhelpEnumeratorBase<ToolhelpProcessTraits> {
+ public:
+ ProcessEnumerator()
+ : ToolhelpEnumeratorBase(
+ ToolhelpProcessTraits::CreateSnapshot(TH32CS_SNAPPROCESS, 0)) {
+ }
+
+ private:
+ DISALLOW_EVIL_CONSTRUCTORS(ProcessEnumerator);
+};
+
+class ToolhelpModuleTraits : public ToolhelpTraits {
+ public:
+ typedef MODULEENTRY32 Type;
+
+ static bool First(HANDLE handle, Type* t) {
+ return ::Module32First(handle, t) == TRUE;
+ }
+
+ static bool Next(HANDLE handle, Type* t) {
+ return ::Module32Next(handle, t) == TRUE;
+ }
+};
+
+class ModuleEnumerator : public ToolhelpEnumeratorBase<ToolhelpModuleTraits> {
+ public:
+ explicit ModuleEnumerator(uint32 process_id)
+ : ToolhelpEnumeratorBase(
+ ToolhelpModuleTraits::CreateSnapshot(TH32CS_SNAPMODULE,
+ process_id)) {
+ }
+
+ private:
+ DISALLOW_EVIL_CONSTRUCTORS(ModuleEnumerator);
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_WIN32TOOLHELP_H_
diff --git a/talk/base/win32toolhelp_unittest.cc b/talk/base/win32toolhelp_unittest.cc
new file mode 100644
index 0000000..529bef9
--- /dev/null
+++ b/talk/base/win32toolhelp_unittest.cc
@@ -0,0 +1,296 @@
+/*
+ * libjingle
+ * Copyright 2010, 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/base/gunit.h"
+#include "talk/base/pathutils.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/win32toolhelp.h"
+
+namespace talk_base {
+
+typedef struct {
+ // Required to match the toolhelp api struct 'design'.
+ DWORD dwSize;
+ int a;
+ uint32 b;
+} TestData;
+
+class Win32ToolhelpTest : public testing::Test {
+ public:
+ Win32ToolhelpTest() {
+ }
+
+ HANDLE AsHandle() {
+ return reinterpret_cast<HANDLE>(this);
+ }
+
+ static Win32ToolhelpTest* AsFixture(HANDLE handle) {
+ return reinterpret_cast<Win32ToolhelpTest*>(handle);
+ }
+
+ static bool First(HANDLE handle, TestData* d) {
+ Win32ToolhelpTest* tst = Win32ToolhelpTest::AsFixture(handle);
+ // This method should be called only once for every test.
+ // If it is called more than once it return false which
+ // should break the test.
+ EXPECT_EQ(0, tst->first_called_); // Just to be safe.
+ if (tst->first_called_ > 0) {
+ return false;
+ }
+
+ *d = kTestData[0];
+ tst->index_ = 1;
+ ++(tst->first_called_);
+ return true;
+ }
+
+ static bool Next(HANDLE handle, TestData* d) {
+ Win32ToolhelpTest* tst = Win32ToolhelpTest::AsFixture(handle);
+ ++(tst->next_called_);
+
+ if (tst->index_ >= kTestDataSize) {
+ return FALSE;
+ }
+
+ *d = kTestData[tst->index_];
+ ++(tst->index_);
+ return true;
+ }
+
+ static bool Fail(HANDLE handle, TestData* d) {
+ Win32ToolhelpTest* tst = Win32ToolhelpTest::AsFixture(handle);
+ ++(tst->fail_called_);
+ return false;
+ }
+
+ static bool CloseHandle(HANDLE handle) {
+ Win32ToolhelpTest* tst = Win32ToolhelpTest::AsFixture(handle);
+ ++(tst->close_handle_called_);
+ return true;
+ }
+
+ protected:
+ virtual void SetUp() {
+ fail_called_ = 0;
+ first_called_ = 0;
+ next_called_ = 0;
+ close_handle_called_ = 0;
+ index_ = 0;
+ }
+
+ static bool AllZero(const TestData& data) {
+ return data.dwSize == 0 && data.a == 0 && data.b == 0;
+ }
+
+ static bool Equals(const TestData& expected, const TestData& actual) {
+ return expected.dwSize == actual.dwSize
+ && expected.a == actual.a
+ && expected.b == actual.b;
+ }
+
+ bool CheckCallCounters(int first, int next, int fail, int close) {
+ bool match = first_called_ == first && next_called_ == next
+ && fail_called_ == fail && close_handle_called_ == close;
+
+ if (!match) {
+ LOG(LS_ERROR) << "Expected: ("
+ << first << ", "
+ << next << ", "
+ << fail << ", "
+ << close << ")";
+
+ LOG(LS_ERROR) << "Actual: ("
+ << first_called_ << ", "
+ << next_called_ << ", "
+ << fail_called_ << ", "
+ << close_handle_called_ << ")";
+ }
+ return match;
+ }
+
+ static const int kTestDataSize = 3;
+ static const TestData kTestData[];
+ int index_;
+ int first_called_;
+ int fail_called_;
+ int next_called_;
+ int close_handle_called_;
+};
+
+const TestData Win32ToolhelpTest::kTestData[] = {
+ {1, 1, 1}, {2, 2, 2}, {3, 3, 3}
+};
+
+
+class TestTraits {
+ public:
+ typedef TestData Type;
+
+ static bool First(HANDLE handle, Type* t) {
+ return Win32ToolhelpTest::First(handle, t);
+ }
+
+ static bool Next(HANDLE handle, Type* t) {
+ return Win32ToolhelpTest::Next(handle, t);
+ }
+
+ static bool CloseHandle(HANDLE handle) {
+ return Win32ToolhelpTest::CloseHandle(handle);
+ }
+};
+
+class BadFirstTraits {
+ public:
+ typedef TestData Type;
+
+ static bool First(HANDLE handle, Type* t) {
+ return Win32ToolhelpTest::Fail(handle, t);
+ }
+
+ static bool Next(HANDLE handle, Type* t) {
+ // This should never be called.
+ ADD_FAILURE();
+ return false;
+ }
+
+ static bool CloseHandle(HANDLE handle) {
+ return Win32ToolhelpTest::CloseHandle(handle);
+ }
+};
+
+class BadNextTraits {
+ public:
+ typedef TestData Type;
+
+ static bool First(HANDLE handle, Type* t) {
+ return Win32ToolhelpTest::First(handle, t);
+ }
+
+ static bool Next(HANDLE handle, Type* t) {
+ return Win32ToolhelpTest::Fail(handle, t);
+ }
+
+ static bool CloseHandle(HANDLE handle) {
+ return Win32ToolhelpTest::CloseHandle(handle);
+ }
+};
+
+// The toolhelp in normally inherited but most of
+// these tests only excercise the methods from the
+// traits therefore I use a typedef to make the
+// test code easier to read.
+typedef talk_base::ToolhelpEnumeratorBase<TestTraits> EnumeratorForTest;
+
+TEST_F(Win32ToolhelpTest, TestNextWithInvalidCtorHandle) {
+ EnumeratorForTest t(INVALID_HANDLE_VALUE);
+
+ EXPECT_FALSE(t.Next());
+ EXPECT_TRUE(CheckCallCounters(0, 0, 0, 0));
+}
+
+// Tests that Next() returns false if the first-pointer
+// function fails.
+TEST_F(Win32ToolhelpTest, TestNextFirstFails) {
+ typedef talk_base::ToolhelpEnumeratorBase<BadFirstTraits> BadEnumerator;
+ talk_base::scoped_ptr<BadEnumerator> t(new BadEnumerator(AsHandle()));
+
+ // If next ever fails it shall always fail.
+ EXPECT_FALSE(t->Next());
+ EXPECT_FALSE(t->Next());
+ EXPECT_FALSE(t->Next());
+ t.reset();
+ EXPECT_TRUE(CheckCallCounters(0, 0, 1, 1));
+}
+
+// Tests that Next() returns false if the next-pointer
+// function fails.
+TEST_F(Win32ToolhelpTest, TestNextNextFails) {
+ typedef talk_base::ToolhelpEnumeratorBase<BadNextTraits> BadEnumerator;
+ talk_base::scoped_ptr<BadEnumerator> t(new BadEnumerator(AsHandle()));
+
+ // If next ever fails it shall always fail. No more calls
+ // shall be dispatched to Next(...).
+ EXPECT_TRUE(t->Next());
+ EXPECT_FALSE(t->Next());
+ EXPECT_FALSE(t->Next());
+ t.reset();
+ EXPECT_TRUE(CheckCallCounters(1, 0, 1, 1));
+}
+
+
+// Tests that current returns an object is all zero's
+// if Next() hasn't been called.
+TEST_F(Win32ToolhelpTest, TestCurrentNextNotCalled) {
+ talk_base::scoped_ptr<EnumeratorForTest> t(new EnumeratorForTest(AsHandle()));
+ EXPECT_TRUE(AllZero(t->current()));
+ t.reset();
+ EXPECT_TRUE(CheckCallCounters(0, 0, 0, 1));
+}
+
+// Tests the simple everything works path through the code.
+TEST_F(Win32ToolhelpTest, TestCurrentNextCalled) {
+ talk_base::scoped_ptr<EnumeratorForTest> t(new EnumeratorForTest(AsHandle()));
+
+ EXPECT_TRUE(t->Next());
+ EXPECT_TRUE(Equals(t->current(), kTestData[0]));
+ EXPECT_TRUE(t->Next());
+ EXPECT_TRUE(Equals(t->current(), kTestData[1]));
+ EXPECT_TRUE(t->Next());
+ EXPECT_TRUE(Equals(t->current(), kTestData[2]));
+ EXPECT_FALSE(t->Next());
+ t.reset();
+ EXPECT_TRUE(CheckCallCounters(1, 3, 0, 1));
+}
+
+TEST_F(Win32ToolhelpTest, TestCurrentProcess) {
+ int size = MAX_PATH;
+ WCHAR buf[MAX_PATH];
+ GetModuleFileName(NULL, buf, ARRAY_SIZE(buf));
+ std::wstring name = ToUtf16(Pathname(ToUtf8(buf)).filename());
+
+ talk_base::ProcessEnumerator processes;
+ bool found = false;
+ while (processes.Next()) {
+ if (!name.compare(processes.current().szExeFile)) {
+ found = true;
+ break;
+ }
+ }
+ EXPECT_TRUE(found);
+
+ talk_base::ModuleEnumerator modules(processes.current().th32ProcessID);
+ found = false;
+ while (modules.Next()) {
+ if (!name.compare(modules.current().szModule)) {
+ found = true;
+ break;
+ }
+ }
+ EXPECT_TRUE(found);
+}
+
+} // namespace talk_base
diff --git a/talk/base/win32window.cc b/talk/base/win32window.cc
index 0e7761f..5b6275e 100644
--- a/talk/base/win32window.cc
+++ b/talk/base/win32window.cc
@@ -103,12 +103,12 @@
LRESULT Win32Window::WndProc(HWND hwnd, UINT uMsg,
WPARAM wParam, LPARAM lParam) {
Win32Window* that = reinterpret_cast<Win32Window*>(
- ::GetWindowLongPtr(hwnd, GWL_USERDATA));
+ ::GetWindowLongPtr(hwnd, GWLP_USERDATA));
if (!that && (WM_CREATE == uMsg)) {
CREATESTRUCT* cs = reinterpret_cast<CREATESTRUCT*>(lParam);
that = static_cast<Win32Window*>(cs->lpCreateParams);
that->wnd_ = hwnd;
- ::SetWindowLongPtr(hwnd, GWL_USERDATA, reinterpret_cast<LONG_PTR>(that));
+ ::SetWindowLongPtr(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(that));
}
if (that) {
LRESULT result;
@@ -120,9 +120,9 @@
}
}
if (WM_NCDESTROY == uMsg) {
- ::SetWindowLongPtr(hwnd, GWL_USERDATA, NULL);
+ ::SetWindowLongPtr(hwnd, GWLP_USERDATA, NULL);
that->wnd_ = NULL;
- that->OnDestroyed();
+ that->OnNcDestroy();
}
if (handled) {
return result;
diff --git a/talk/base/win32window.h b/talk/base/win32window.h
index 66a56ce..992c8e7 100644
--- a/talk/base/win32window.h
+++ b/talk/base/win32window.h
@@ -2,26 +2,26 @@
* libjingle
* Copyright 2004--2005, Google Inc.
*
- * Redistribution and use in source and binary forms, with or without
+ * 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,
+ * 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
+ * 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
+ * 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,
+ * 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
+ * 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.
*/
@@ -59,7 +59,7 @@
LRESULT& result);
virtual bool OnClose() { return true; }
- virtual void OnDestroyed() { }
+ virtual void OnNcDestroy() { }
private:
static LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg, WPARAM wParam,
diff --git a/talk/base/win32window_unittest.cc b/talk/base/win32window_unittest.cc
new file mode 100644
index 0000000..96173b7
--- /dev/null
+++ b/talk/base/win32window_unittest.cc
@@ -0,0 +1,83 @@
+/*
+ * libjingle
+ * Copyright 2009, 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/base/gunit.h"
+#include "talk/base/common.h"
+#include "talk/base/win32window.h"
+#include "talk/base/logging.h"
+
+static LRESULT kDummyResult = 0x1234ABCD;
+
+class TestWindow : public talk_base::Win32Window {
+ public:
+ TestWindow() : destroyed_(false) { memset(&msg_, 0, sizeof(msg_)); }
+ const MSG& msg() const { return msg_; }
+ bool destroyed() const { return destroyed_; }
+
+ virtual bool OnMessage(UINT uMsg, WPARAM wParam,
+ LPARAM lParam, LRESULT& result) {
+ msg_.message = uMsg;
+ msg_.wParam = wParam;
+ msg_.lParam = lParam;
+ result = kDummyResult;
+ return true;
+ }
+ virtual void OnNcDestroy() {
+ destroyed_ = true;
+ }
+
+ private:
+ MSG msg_;
+ bool destroyed_;
+};
+
+TEST(Win32WindowTest, Basics) {
+ TestWindow wnd;
+ EXPECT_TRUE(wnd.handle() == NULL);
+ EXPECT_FALSE(wnd.destroyed());
+ EXPECT_TRUE(wnd.Create(0, L"Test", 0, 0, 0, 0, 100, 100));
+ EXPECT_TRUE(wnd.handle() != NULL);
+ EXPECT_EQ(kDummyResult, ::SendMessage(wnd.handle(), WM_USER, 1, 2));
+ EXPECT_EQ(WM_USER, wnd.msg().message);
+ EXPECT_EQ(1, wnd.msg().wParam);
+ EXPECT_EQ(2, wnd.msg().lParam);
+ wnd.Destroy();
+ EXPECT_TRUE(wnd.handle() == NULL);
+ EXPECT_TRUE(wnd.destroyed());
+}
+
+TEST(Win32WindowTest, MultipleWindows) {
+ TestWindow wnd1, wnd2;
+ EXPECT_TRUE(wnd1.Create(0, L"Test", 0, 0, 0, 0, 100, 100));
+ EXPECT_TRUE(wnd2.Create(0, L"Test", 0, 0, 0, 0, 100, 100));
+ EXPECT_TRUE(wnd1.handle() != NULL);
+ EXPECT_TRUE(wnd2.handle() != NULL);
+ wnd1.Destroy();
+ wnd2.Destroy();
+ EXPECT_TRUE(wnd2.handle() == NULL);
+ EXPECT_TRUE(wnd1.handle() == NULL);
+}
diff --git a/talk/base/win32windowpicker.cc b/talk/base/win32windowpicker.cc
new file mode 100644
index 0000000..b674d35
--- /dev/null
+++ b/talk/base/win32windowpicker.cc
@@ -0,0 +1,115 @@
+// Copyright 2010 Google Inc. All Rights Reserved
+
+
+#include "talk/base/win32windowpicker.h"
+
+#include <string>
+#include <vector>
+
+#include "talk/base/common.h"
+#include "talk/base/logging.h"
+
+namespace talk_base {
+
+namespace {
+
+// Window class names that we want to filter out.
+const char kProgramManagerClass[] = "Progman";
+const char kButtonClass[] = "Button";
+
+} // namespace
+
+BOOL CALLBACK Win32WindowPicker::EnumProc(HWND hwnd, LPARAM l_param) {
+ WindowDescriptionList* descriptions =
+ reinterpret_cast<WindowDescriptionList*>(l_param);
+
+ // Skip windows that are invisible, minimized, have no title, or are owned,
+ // unless they have the app window style set. Except for minimized windows,
+ // this is what Alt-Tab does.
+ // TODO: Figure out how to grab a thumbnail of a minimized window and
+ // include them in the list.
+ int len = GetWindowTextLength(hwnd);
+ HWND owner = GetWindow(hwnd, GW_OWNER);
+ LONG exstyle = GetWindowLong(hwnd, GWL_EXSTYLE);
+ if (len == 0 || IsIconic(hwnd) || !IsWindowVisible(hwnd) ||
+ (owner && !(exstyle & WS_EX_APPWINDOW))) {
+ // TODO: Investigate if windows without title still could be
+ // interesting to share. We could use the name of the process as title:
+ //
+ // GetWindowThreadProcessId()
+ // OpenProcess()
+ // QueryFullProcessImageName()
+ return TRUE;
+ }
+
+ // Skip the Program Manager window and the Start button.
+ TCHAR class_name_w[500];
+ ::GetClassName(hwnd, class_name_w, 500);
+ std::string class_name = ToUtf8(class_name_w, wcslen(class_name_w));
+ if (class_name == kProgramManagerClass || class_name == kButtonClass) {
+ // We don't want the Program Manager window nor the Start button.
+ return TRUE;
+ }
+
+ TCHAR window_title[500];
+ GetWindowText(hwnd, window_title, ARRAY_SIZE(window_title));
+ std::string title = ToUtf8(window_title, wcslen(window_title));
+ WindowId id(hwnd);
+ WindowDescription desc(id, title);
+ descriptions->push_back(desc);
+ return TRUE;
+}
+
+BOOL CALLBACK Win32WindowPicker::MonitorEnumProc(HMONITOR h_monitor,
+ HDC hdc_monitor,
+ LPRECT lprc_monitor,
+ LPARAM l_param) {
+ DesktopDescriptionList* desktop_desc =
+ reinterpret_cast<DesktopDescriptionList*>(l_param);
+
+ DesktopId id(h_monitor, desktop_desc->size());
+ // TODO: Figure out an appropriate desktop title.
+ DesktopDescription desc(id, "");
+ desktop_desc->push_back(desc);
+ return TRUE;
+}
+
+Win32WindowPicker::Win32WindowPicker() {
+}
+
+bool Win32WindowPicker::Init() {
+ return true;
+}
+// TODO: Consider changing enumeration to clear() descriptions
+// before append().
+bool Win32WindowPicker::GetWindowList(WindowDescriptionList* descriptions) {
+ LPARAM desc = reinterpret_cast<LPARAM>(descriptions);
+ return EnumWindows(Win32WindowPicker::EnumProc, desc) != FALSE;
+}
+
+bool Win32WindowPicker::GetDesktopList(DesktopDescriptionList* descriptions) {
+ // Create a fresh WindowDescriptionList so that we can use desktop_desc.size()
+ // in MonitorEnumProc to compute the desktop index.
+ DesktopDescriptionList desktop_desc;
+ HDC hdc = GetDC(NULL);
+ bool success = false;
+ if (EnumDisplayMonitors(hdc, NULL, Win32WindowPicker::MonitorEnumProc,
+ reinterpret_cast<LPARAM>(&desktop_desc)) != FALSE) {
+ // Append the desktop descriptions to the end of the returned descriptions.
+ descriptions->insert(descriptions->end(), desktop_desc.begin(),
+ desktop_desc.end());
+ success = true;
+ }
+ ReleaseDC(NULL, hdc);
+ return success;
+}
+
+bool Win32WindowPicker::IsVisible(const WindowId& id) {
+ return (::IsWindow(id.id()) != FALSE && ::IsWindowVisible(id.id()) != FALSE);
+}
+
+bool Win32WindowPicker::MoveToFront(const WindowId& id) {
+ return SetForegroundWindow(id.id()) != FALSE;
+}
+
+} // namespace talk_base
diff --git a/talk/base/win32windowpicker.h b/talk/base/win32windowpicker.h
new file mode 100644
index 0000000..d5f779b
--- /dev/null
+++ b/talk/base/win32windowpicker.h
@@ -0,0 +1,31 @@
+// Copyright 2010 Google Inc. All Rights Reserved
+
+
+#ifndef TALK_BASE_WIN32WINDOWPICKER_H_
+#define TALK_BASE_WIN32WINDOWPICKER_H_
+
+#include "talk/base/win32.h"
+#include "talk/base/windowpicker.h"
+
+namespace talk_base {
+
+class Win32WindowPicker : public WindowPicker {
+ public:
+ Win32WindowPicker();
+ virtual bool Init();
+ virtual bool IsVisible(const WindowId& id);
+ virtual bool MoveToFront(const WindowId& id);
+ virtual bool GetWindowList(WindowDescriptionList* descriptions);
+ virtual bool GetDesktopList(DesktopDescriptionList* descriptions);
+
+ protected:
+ static BOOL CALLBACK EnumProc(HWND hwnd, LPARAM l_param);
+ static BOOL CALLBACK MonitorEnumProc(HMONITOR h_monitor,
+ HDC hdc_monitor,
+ LPRECT lprc_monitor,
+ LPARAM l_param);
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_WIN32WINDOWPICKER_H_
diff --git a/talk/base/win32windowpicker_unittest.cc b/talk/base/win32windowpicker_unittest.cc
new file mode 100644
index 0000000..065193e
--- /dev/null
+++ b/talk/base/win32windowpicker_unittest.cc
@@ -0,0 +1,94 @@
+// Copyright 2010 Google Inc. All Rights Reserved
+
+
+#include "talk/base/gunit.h"
+#include "talk/base/common.h"
+#include "talk/base/logging.h"
+#include "talk/base/win32window.h"
+#include "talk/base/win32windowpicker.h"
+#include "talk/base/windowpicker.h"
+
+#ifndef WIN32
+#error Only for Windows
+#endif
+
+namespace talk_base {
+
+static const TCHAR* kVisibleWindowTitle = L"Visible Window";
+static const TCHAR* kInvisibleWindowTitle = L"Invisible Window";
+
+class Win32WindowPickerForTest : public Win32WindowPicker {
+ public:
+ Win32WindowPickerForTest() {
+ EXPECT_TRUE(visible_window_.Create(NULL, kVisibleWindowTitle, WS_VISIBLE,
+ 0, 0, 0, 0, 0));
+ EXPECT_TRUE(invisible_window_.Create(NULL, kInvisibleWindowTitle, 0,
+ 0, 0, 0, 0, 0));
+ }
+
+ ~Win32WindowPickerForTest() {
+ visible_window_.Destroy();
+ invisible_window_.Destroy();
+ }
+
+ virtual bool GetWindowList(WindowDescriptionList* descriptions) {
+ if (!Win32WindowPicker::EnumProc(visible_window_.handle(),
+ reinterpret_cast<LPARAM>(descriptions))) {
+ return false;
+ }
+ if (!Win32WindowPicker::EnumProc(invisible_window_.handle(),
+ reinterpret_cast<LPARAM>(descriptions))) {
+ return false;
+ }
+ return true;
+ }
+
+ Win32Window* visible_window() {
+ return &visible_window_;
+ }
+
+ Win32Window* invisible_window() {
+ return &invisible_window_;
+ }
+
+ private:
+ Win32Window visible_window_;
+ Win32Window invisible_window_;
+};
+
+TEST(Win32WindowPickerTest, TestGetWindowList) {
+ Win32WindowPickerForTest window_picker;
+ WindowDescriptionList descriptions;
+ EXPECT_TRUE(window_picker.GetWindowList(&descriptions));
+ EXPECT_EQ(1, descriptions.size());
+ WindowDescription desc = descriptions.front();
+ EXPECT_EQ(window_picker.visible_window()->handle(), desc.id().id());
+ TCHAR window_title[500];
+ GetWindowText(window_picker.visible_window()->handle(), window_title,
+ ARRAY_SIZE(window_title));
+ EXPECT_EQ(ToUtf8(window_title, wcslen(window_title)),
+ ToUtf8(kVisibleWindowTitle, wcslen(kVisibleWindowTitle)));
+}
+
+TEST(Win32WindowPickerTest, TestIsVisible) {
+ Win32WindowPickerForTest window_picker;
+ HWND visible_id = window_picker.visible_window()->handle();
+ HWND invisible_id = window_picker.invisible_window()->handle();
+ EXPECT_TRUE(window_picker.IsVisible(WindowId(visible_id)));
+ EXPECT_FALSE(window_picker.IsVisible(WindowId(invisible_id)));
+}
+
+TEST(Win32WindowPickerTest, TestMoveToFront) {
+ Win32WindowPickerForTest window_picker;
+ HWND visible_id = window_picker.visible_window()->handle();
+ HWND invisible_id = window_picker.invisible_window()->handle();
+
+ // There are a number of condition where SetForegroundWindow might
+ // fail depending on the state of the calling process. To be on the
+ // safe side we doesn't expect MoveToFront to return true, just test
+ // that we don't crash.
+ window_picker.MoveToFront(WindowId(visible_id));
+ window_picker.MoveToFront(WindowId(invisible_id));
+}
+
+} // namespace talk_base
diff --git a/talk/base/window.h b/talk/base/window.h
new file mode 100644
index 0000000..b855193
--- /dev/null
+++ b/talk/base/window.h
@@ -0,0 +1,127 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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_BASE_WINDOW_H_
+#define TALK_BASE_WINDOW_H_
+
+// Define platform specific window types.
+#if defined(LINUX)
+typedef unsigned long Window; // Avoid include <X11/Xlib.h>.
+#elif defined(WIN32)
+// We commonly include win32.h in talk/base so just include it here.
+#include "talk/base/win32.h" // Include HWND, HMONITOR.
+#elif defined(OSX)
+typedef unsigned int CGWindowID;
+typedef unsigned int CGDirectDisplayID;
+#endif
+
+namespace talk_base {
+
+class WindowId {
+ public:
+ // Define WindowT for each platform.
+#if defined(LINUX)
+ typedef Window WindowT;
+#elif defined(WIN32)
+ typedef HWND WindowT;
+#elif defined(OSX)
+ typedef CGWindowID WindowT;
+#else
+ typedef unsigned int WindowT;
+#endif
+
+ static WindowId Cast(int id) {
+#if defined(WIN32)
+ return WindowId(reinterpret_cast<WindowId::WindowT>(id));
+#else
+ return WindowId(static_cast<WindowId::WindowT>(id));
+#endif
+ }
+
+ WindowId() : id_(0) {}
+ WindowId(const WindowT& id) : id_(id) {} // NOLINT
+ const WindowT& id() const { return id_; }
+ bool IsValid() const { return id_ != 0; }
+ bool Equals(const WindowId& other) const {
+ return id_ == other.id();
+ }
+
+ private:
+ WindowT id_;
+};
+
+class DesktopId {
+ public:
+ // Define DesktopT for each platform.
+#if defined(LINUX)
+ typedef Window DesktopT;
+#elif defined(WIN32)
+ typedef HMONITOR DesktopT;
+#elif defined(OSX)
+ typedef CGDirectDisplayID DesktopT;
+#else
+ typedef unsigned int DesktopT;
+#endif
+
+ static DesktopId Cast(int id, int index) {
+#if defined(WIN32)
+ return DesktopId(reinterpret_cast<DesktopId::DesktopT>(id), index);
+#else
+ return DesktopId(static_cast<DesktopId::DesktopT>(id), index);
+#endif
+ }
+
+ DesktopId() : id_(0), index_(-1) {}
+ DesktopId(const DesktopT& id, int index) // NOLINT
+ : id_(id), index_(index) {
+ }
+ const DesktopT& id() const { return id_; }
+ int index() const { return index_; }
+ bool IsValid() const { return index_ != -1; }
+ bool Equals(const DesktopId& other) const {
+ return id_ == other.id() && index_ == other.index();
+ }
+
+ private:
+ // Id is the platform specific desktop identifier.
+ DesktopT id_;
+ // Index is the desktop index as enumerated by each platform.
+ // Desktop capturer typically takes the index instead of id.
+ int index_;
+};
+
+// Window event types.
+enum WindowEvent {
+ WE_RESIZE = 0,
+ WE_CLOSE = 1,
+ WE_MINIMIZE = 2,
+ WE_RESTORE = 3,
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_WINDOW_H_
diff --git a/talk/base/windowpicker.h b/talk/base/windowpicker.h
new file mode 100644
index 0000000..242fabc
--- /dev/null
+++ b/talk/base/windowpicker.h
@@ -0,0 +1,70 @@
+// Copyright 2010 Google Inc. All Rights Reserved
+
+// thorcarpenter@google.com (Thor Carpenter)
+
+#ifndef TALK_BASE_WINDOWPICKER_H_
+#define TALK_BASE_WINDOWPICKER_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/base/window.h"
+
+namespace talk_base {
+
+class WindowDescription {
+ public:
+ WindowDescription() : id_() {}
+ WindowDescription(const WindowId& id, const std::string& title)
+ : id_(id), title_(title) {
+ }
+ const WindowId& id() const { return id_; }
+ void set_id(const WindowId& id) { id_ = id; }
+ const std::string& title() const { return title_; }
+ void set_title(const std::string& title) { title_ = title; }
+
+ private:
+ WindowId id_;
+ std::string title_;
+};
+
+class DesktopDescription {
+ public:
+ DesktopDescription() : id_() {}
+ DesktopDescription(const DesktopId& id, const std::string& title)
+ : id_(id), title_(title) {
+ }
+ const DesktopId& id() const { return id_; }
+ void set_id(const DesktopId& id) { id_ = id; }
+ const std::string& title() const { return title_; }
+ void set_title(const std::string& title) { title_ = title; }
+
+ private:
+ DesktopId id_;
+ std::string title_;
+};
+
+typedef std::vector<WindowDescription> WindowDescriptionList;
+typedef std::vector<DesktopDescription> DesktopDescriptionList;
+
+class WindowPicker {
+ public:
+ virtual ~WindowPicker() {}
+ virtual bool Init() = 0;
+
+ // TODO: Move this two methods to window.h when we no longer need to load
+ // CoreGraphics dynamically.
+ virtual bool IsVisible(const WindowId& id) = 0;
+ virtual bool MoveToFront(const WindowId& id) = 0;
+
+ // Gets a list of window description and appends to descriptions.
+ // Returns true if successful.
+ virtual bool GetWindowList(WindowDescriptionList* descriptions) = 0;
+ // Gets a list of desktop descriptions and appends to descriptions.
+ // Returns true if successful.
+ virtual bool GetDesktopList(DesktopDescriptionList* descriptions) = 0;
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_WINDOWPICKER_H_
diff --git a/talk/base/windowpickerfactory.h b/talk/base/windowpickerfactory.h
new file mode 100644
index 0000000..e001a2c
--- /dev/null
+++ b/talk/base/windowpickerfactory.h
@@ -0,0 +1,69 @@
+/*
+ * libjingle
+ * Copyright 2010 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_BASE_WINDOWPICKERFACTORY_H_
+#define TALK_BASE_WINDOWPICKERFACTORY_H_
+
+#if defined(WIN32)
+#include "talk/base/win32windowpicker.h"
+#elif defined(OSX)
+#include "talk/base/macutils.h"
+#include "talk/base/macwindowpicker.h"
+#elif defined(LINUX)
+#include "talk/base/linuxwindowpicker.h"
+#endif
+
+#include "talk/base/windowpicker.h"
+
+namespace talk_base {
+
+class WindowPickerFactory {
+ public:
+ static WindowPicker* CreateWindowPicker() {
+#if defined(WIN32)
+ return new Win32WindowPicker();
+#elif defined(OSX)
+ return new MacWindowPicker();
+#elif defined(LINUX)
+ return new LinuxWindowPicker();
+#else
+ return NULL;
+#endif
+ }
+
+ static bool IsSupported() {
+#ifdef OSX
+ return GetOSVersionName() >= kMacOSLeopard;
+#else
+ return true;
+#endif
+ }
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_WINDOWPICKERFACTORY_H_
diff --git a/talk/base/winfirewall_unittest.cc b/talk/base/winfirewall_unittest.cc
new file mode 100644
index 0000000..9987716
--- /dev/null
+++ b/talk/base/winfirewall_unittest.cc
@@ -0,0 +1,57 @@
+/*
+ * libjingle
+ * Copyright 2010, 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/base/gunit.h"
+#include "talk/base/winfirewall.h"
+
+#include <objbase.h>
+
+namespace talk_base {
+
+TEST(WinFirewallTest, ReadStatus) {
+ ::CoInitialize(NULL);
+ WinFirewall fw;
+ HRESULT hr;
+ bool authorized;
+
+ EXPECT_FALSE(fw.QueryAuthorized("bogus.exe", &authorized));
+ EXPECT_TRUE(fw.Initialize(&hr));
+ EXPECT_EQ(S_OK, hr);
+
+ EXPECT_TRUE(fw.QueryAuthorized("bogus.exe", &authorized));
+
+ // Unless we mock out INetFwMgr we can't really have an expectation either way
+ // about whether we're authorized. It will depend on the settings of the
+ // machine running the test. Same goes for AddApplication.
+
+ fw.Shutdown();
+ EXPECT_FALSE(fw.QueryAuthorized("bogus.exe", &authorized));
+
+ ::CoUninitialize();
+}
+
+} // namespace talk_base
diff --git a/talk/base/winping.cc b/talk/base/winping.cc
index 1802e03..a16ac78 100644
--- a/talk/base/winping.cc
+++ b/talk/base/winping.cc
@@ -180,7 +180,7 @@
}
delete[] data_;
- delete reply_;
+ delete[] reply_;
}
WinPing::PingResult WinPing::Ping(
diff --git a/talk/examples/call/call_main.cc b/talk/examples/call/call_main.cc
index b9f5696..c2be1e8 100644
--- a/talk/examples/call/call_main.cc
+++ b/talk/examples/call/call_main.cc
@@ -25,14 +25,15 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include <cstdio>
+#include <cstring>
#include <time.h>
#include <iomanip>
#include <iostream>
-#include <cstdio>
-#include <cstring>
#include <vector>
-#include "talk/base/logging.h"
+
#include "talk/base/flags.h"
+#include "talk/base/logging.h"
#ifdef OSX
#include "talk/base/macsocketserver.h"
#endif
@@ -40,16 +41,19 @@
#include "talk/base/stream.h"
#include "talk/base/ssladapter.h"
#include "talk/base/win32socketserver.h"
-#include "talk/p2p/base/constants.h"
-#include "talk/xmpp/xmppclientsettings.h"
#include "talk/examples/login/xmppthread.h"
#include "talk/examples/login/xmppauth.h"
#include "talk/examples/login/xmpppump.h"
#include "talk/examples/call/callclient.h"
#include "talk/examples/call/console.h"
-#include "talk/session/phone/filemediaengine.h"
+#include "talk/examples/call/mediaenginefactory.h"
+#include "talk/p2p/base/constants.h"
+#ifdef ANDROID
+#include "talk/session/phone/androidmediaengine.h"
+#endif
#include "talk/session/phone/mediasessionclient.h"
#include "talk/session/phone/srtpfilter.h"
+#include "talk/xmpp/xmppclientsettings.h"
class DebugLog : public sigslot::has_slots<> {
public:
@@ -177,48 +181,18 @@
static DebugLog debug_log_;
static const int DEFAULT_PORT = 5222;
+#ifdef ANDROID
+static std::vector<cricket::AudioCodec> codecs;
+static const cricket::AudioCodec ISAC(103, "ISAC", 40000, 16000, 1, 0);
-cricket::MediaEngineInterface* CreateFileMediaEngine(const char* voice_in,
- const char* voice_out,
- const char* video_in,
- const char* video_out) {
- cricket::FileMediaEngine* file_media_engine = new cricket::FileMediaEngine;
- // Set the RTP dump file names.
- if (voice_in) {
- file_media_engine->set_voice_input_filename(voice_in);
- }
- if (voice_out) {
- file_media_engine->set_voice_output_filename(voice_out);
- }
- if (video_in) {
- file_media_engine->set_video_input_filename(video_in);
- }
- if (video_out) {
- file_media_engine->set_video_output_filename(video_out);
- }
+cricket::MediaEngine *AndroidMediaEngineFactory() {
+ cricket::FakeMediaEngine *engine = new cricket::FakeMediaEngine();
- // Set voice and video codecs. TODO: The codecs actually depend on
- // the the input voice and video streams.
- std::vector<cricket::AudioCodec> voice_codecs;
- voice_codecs.push_back(
- cricket::AudioCodec(9, "G722", 16000, 0, 1, 0));
- voice_codecs.push_back(
- cricket::AudioCodec(0, "PCMU", 8000, 0, 1, 0));
- voice_codecs.push_back(
- cricket::AudioCodec(13, "CN", 8000, 0, 1, 0));
- voice_codecs.push_back(
- cricket::AudioCodec(105, "CN", 16000, 0, 1, 0));
- file_media_engine->set_voice_codecs(voice_codecs);
- std::vector<cricket::VideoCodec> video_codecs;
- video_codecs.push_back(
- cricket::VideoCodec(97, "H264", 320, 240, 30, 0));
- video_codecs.push_back(
- cricket::VideoCodec(99, "H264-SVC", 640, 360, 30, 0));
- file_media_engine->set_video_codecs(video_codecs);
-
- return file_media_engine;
+ codecs.push_back(ISAC);
+ engine->SetAudioCodecs(codecs);
+ return engine;
}
-
+#endif
// TODO: Move this into Console.
void Print(const char* chars) {
@@ -236,22 +210,25 @@
// define options
DEFINE_bool(a, false, "Turn on auto accept.");
DEFINE_bool(d, false, "Turn on debugging.");
- DEFINE_string(
- protocol, "hybrid",
+ DEFINE_string(protocol, "hybrid",
"Initial signaling protocol to use: jingle, gingle, or hybrid.");
- DEFINE_string(
- secure, "enable",
+ DEFINE_string(secure, "enable",
"Disable or enable encryption: disable, enable, require.");
+ DEFINE_string(tls, "enable",
+ "Disable or enable tls: disable, enable, require.");
+ DEFINE_bool(allowplain, false, "Allow plain authentication");
DEFINE_bool(testserver, false, "Use test server");
- DEFINE_bool(plainserver, false, "Turn off tls and allow plain password.");
DEFINE_int(portallocator, 0, "Filter out unwanted connection types.");
DEFINE_string(filterhost, NULL, "Filter out the host from all candidates.");
DEFINE_string(pmuc, "groupchat.google.com", "The persistant muc domain.");
DEFINE_string(s, "talk.google.com", "The connection server to use.");
+ DEFINE_string(capsnode, "http://code.google.com/p/libjingle/call",
+ "Caps node: A URI identifying the app.");
+ DEFINE_string(capsver, "0.6",
+ "Caps ver: A string identifying the version of the app.");
DEFINE_string(voiceinput, NULL, "RTP dump file for voice input.");
DEFINE_string(voiceoutput, NULL, "RTP dump file for voice output.");
DEFINE_string(videoinput, NULL, "RTP dump file for video input.");
- DEFINE_string(yuvvideoinput, NULL, "YUV file for video input.");
DEFINE_string(videooutput, NULL, "RTP dump file for video output.");
DEFINE_bool(render, true, "Renders the video.");
DEFINE_bool(debugsrtp, false, "Enable debugging for srtp.");
@@ -268,11 +245,14 @@
bool debug = FLAG_d;
std::string protocol = FLAG_protocol;
bool test_server = FLAG_testserver;
- bool plain_server = FLAG_plainserver;
+ bool allow_plain = FLAG_allowplain;
+ std::string tls = FLAG_tls;
int32 portallocator_flags = FLAG_portallocator;
std::string pmuc_domain = FLAG_pmuc;
std::string server = FLAG_s;
std::string secure = FLAG_secure;
+ std::string caps_node = FLAG_capsnode;
+ std::string caps_ver = FLAG_capsver;
bool debugsrtp = FLAG_debugsrtp;
bool render = FLAG_render;
@@ -342,15 +322,24 @@
xcs.set_user(jid.node());
xcs.set_resource("call");
xcs.set_host(jid.domain());
- xcs.set_use_tls(!test_server);
+ xcs.set_allow_plain(allow_plain);
- if (plain_server) {
- xcs.set_use_tls(false);
- xcs.set_allow_plain(true);
+ if(tls == "disable") {
+ xcs.set_use_tls(buzz::TLS_DISABLED);
+ } else if (tls == "enable") {
+ xcs.set_use_tls(buzz::TLS_ENABLED);
+ } else if (tls == "require") {
+ xcs.set_use_tls(buzz::TLS_REQUIRED);
+ } else {
+ Print("Invalid TLS option, must be enable, disable, or require.\n");
+ return 1;
}
+
if (test_server) {
pass.password() = jid.node();
xcs.set_allow_plain(true);
+ xcs.set_use_tls(buzz::TLS_DISABLED);
+ xcs.set_test_server_domain("google.com");
}
xcs.set_pass(talk_base::CryptString(pass));
@@ -371,11 +360,14 @@
talk_base::InitializeSSL();
+#ifdef ANDROID
+ InitAndroidMediaEngineFactory(AndroidMediaEngineFactory);
+#endif
#if WIN32
// Need to pump messages on our main thread on Windows.
talk_base::Win32Thread w32_thread;
- talk_base::ThreadManager::SetCurrent(&w32_thread);
+ talk_base::ThreadManager::Instance()->SetCurrentThread(&w32_thread);
#endif
talk_base::Thread* main_thread = talk_base::Thread::Current();
#ifdef OSX
@@ -384,16 +376,18 @@
#endif
XmppPump pump;
- CallClient *client = new CallClient(pump.client());
+ CallClient *client = new CallClient(pump.client(), caps_node, caps_ver);
if (FLAG_voiceinput || FLAG_voiceoutput ||
FLAG_videoinput || FLAG_videooutput) {
- // If any dump file is specified, we use FileMediaEngine.
- cricket::MediaEngineInterface* engine = CreateFileMediaEngine(
- FLAG_voiceinput, FLAG_voiceoutput, FLAG_videoinput, FLAG_videooutput);
- // The engine will be released by the client later.
+ // If any dump file is specified, we use a FileMediaEngine.
+ cricket::MediaEngineInterface* engine =
+ MediaEngineFactory::CreateFileMediaEngine(
+ FLAG_voiceinput, FLAG_voiceoutput,
+ FLAG_videoinput, FLAG_videooutput);
client->SetMediaEngine(engine);
}
+
Console *console = new Console(main_thread, client);
client->SetConsole(console);
client->SetAutoAccept(auto_accept);
@@ -410,7 +404,7 @@
pump.client()->SignalLogOutput.connect(&debug_log_, &DebugLog::Output);
}
- pump.DoLogin(xcs, new XmppSocket(true), NULL);
+ pump.DoLogin(xcs, new XmppSocket(buzz::TLS_REQUIRED), NULL);
main_thread->Run();
pump.DoDisconnect();
diff --git a/talk/examples/call/call_unittest.cc b/talk/examples/call/call_unittest.cc
new file mode 100644
index 0000000..d95f1dd
--- /dev/null
+++ b/talk/examples/call/call_unittest.cc
@@ -0,0 +1,37 @@
+/*
+ * libjingle
+ * Copyright 2008, 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.
+ */
+
+// Main function for all unit tests in talk/examples/call
+
+#include "talk/base/logging.h"
+#include "testing/base/public/gunit.h"
+
+int main(int argc, char **argv) {
+ talk_base::LogMessage::LogToDebug(talk_base::LogMessage::NO_LOGGING);
+ testing::ParseGUnitFlags(&argc, argv);
+ return RUN_ALL_TESTS();
+}
diff --git a/talk/examples/call/callclient.cc b/talk/examples/call/callclient.cc
index 3c65272..89f964b 100644
--- a/talk/examples/call/callclient.cc
+++ b/talk/examples/call/callclient.cc
@@ -43,7 +43,6 @@
#include "talk/examples/call/mucinvitesendtask.h"
#include "talk/examples/call/friendinvitesendtask.h"
#include "talk/examples/call/muc.h"
-#include "talk/examples/call/voicemailjidrequester.h"
#include "talk/p2p/base/sessionmanager.h"
#include "talk/p2p/client/basicportallocator.h"
#include "talk/p2p/client/sessionmanagertask.h"
@@ -111,6 +110,7 @@
" record Starts recording (just signalling; not actually recording.)\n"
" unrecord Stops recording (just signalling; not actually recording.)\n"
" rmute [nick] Remote mute another participant.\n"
+" block [nick] Block another participant.\n"
" quit Quits the application.\n"
"";
@@ -131,12 +131,12 @@
" given JID and with optional bandwidth.\n"
" vcall [jid] [bw] Initiates a video call to the user[/room] with\n"
" the given JID and with optional bandwidth.\n"
-" voicemail [jid] Leave a voicemail for the user with the given JID.\n"
" join [room_jid] Joins a multi-user-chat with room JID.\n"
" ljoin [room_name] Joins a MUC by looking up JID from room name.\n"
" invite user [room] Invites a friend to a multi-user-chat.\n"
" leave [room] Leaves a multi-user-chat.\n"
" nick [nick] Sets the nick.\n"
+" priority [int] Sets the priority.\n"
" getdevs Prints the available media devices.\n"
" quit Quits the application.\n"
"";
@@ -171,6 +171,7 @@
if (command == "accept") {
cricket::CallOptions options;
options.video_bandwidth = GetInt(words, 1, cricket::kAutoBandwidth);
+ options.has_video = true;
Accept(options);
} else if (command == "reject") {
Reject();
@@ -211,6 +212,11 @@
const std::string& nick = words[1];
hangout_pubsub_client_->RemoteMute(nick);
}
+ } else if ((command == "block") && (words.size() == 2)) {
+ if (InMuc()) {
+ const std::string& nick = words[1];
+ hangout_pubsub_client_->BlockMedia(nick);
+ }
} else if ((command == "dtmf") && (words.size() == 2)) {
int ev = std::string("0123456789*#").find(words[1][0]);
call_->PressDTMF(ev);
@@ -256,19 +262,22 @@
LeaveMuc(GetWord(words, 1, ""));
} else if (command == "nick") {
SetNick(GetWord(words, 1, ""));
+ } else if (command == "priority") {
+ int priority = GetInt(words, 1, 0);
+ SetPriority(priority);
+ SendStatus();
} else if (command == "getdevs") {
GetDevices();
} else if ((words.size() == 2) && (command == "setvol")) {
SetVolume(words[1]);
- } else if (command == "voicemail") {
- CallVoicemail((words.size() >= 2) ? words[1] : "");
} else {
console_->PrintLine(CONSOLE_COMMANDS);
}
}
}
-CallClient::CallClient(buzz::XmppClient* xmpp_client)
+CallClient::CallClient(buzz::XmppClient* xmpp_client,
+ const std::string& caps_node, const std::string& version)
: xmpp_client_(xmpp_client),
worker_thread_(NULL),
media_engine_(NULL),
@@ -288,6 +297,8 @@
initial_protocol_(cricket::PROTOCOL_HYBRID),
secure_policy_(cricket::SEC_DISABLED) {
xmpp_client_->SignalStateChange.connect(this, &CallClient::OnStateChange);
+ my_status_.set_caps_node(caps_node);
+ my_status_.set_version(version);
}
CallClient::~CallClient() {
@@ -431,8 +442,8 @@
void CallClient::OnCallCreate(cricket::Call* call) {
call->SignalSessionState.connect(this, &CallClient::OnSessionState);
- call->SignalMediaSourcesUpdate.connect(
- this, &CallClient::OnMediaSourcesUpdate);
+ call->SignalMediaStreamsUpdate.connect(
+ this, &CallClient::OnMediaStreamsUpdate);
}
void CallClient::OnSessionState(cricket::Call* call,
@@ -452,6 +463,7 @@
}
cricket::CallOptions options;
if (auto_accept_) {
+ options.has_video = true;
Accept(options);
}
} else if (state == cricket::Session::STATE_SENTINITIATE) {
@@ -477,20 +489,38 @@
void CallClient::OnSpeakerChanged(cricket::Call* call,
cricket::Session* session,
- const cricket::NamedSource& speaker) {
- if (speaker.ssrc == 0) {
+ const cricket::StreamParams& speaker) {
+ if (!speaker.has_ssrcs()) {
console_->PrintLine("Session %s has no current speaker.",
session->id().c_str());
} else if (speaker.nick.empty()) {
console_->PrintLine("Session %s speaker change to unknown (%u).",
- session->id().c_str(), speaker.ssrc);
+ session->id().c_str(), speaker.first_ssrc());
} else {
console_->PrintLine("Session %s speaker changed to %s (%u).",
session->id().c_str(), speaker.nick.c_str(),
- speaker.ssrc);
+ speaker.first_ssrc());
}
}
+void SetMediaCaps(int media_caps, buzz::Status* status) {
+ status->set_voice_capability((media_caps & cricket::AUDIO_RECV) != 0);
+ status->set_video_capability((media_caps & cricket::VIDEO_RECV) != 0);
+ status->set_camera_capability((media_caps & cricket::VIDEO_SEND) != 0);
+}
+
+void SetCaps(int media_caps, buzz::Status* status) {
+ status->set_know_capabilities(true);
+ status->set_pmuc_capability(true);
+ SetMediaCaps(media_caps, status);
+}
+
+void SetAvailable(const buzz::Jid& jid, buzz::Status* status) {
+ status->set_jid(jid);
+ status->set_available(true);
+ status->set_show(buzz::Status::SHOW_ONLINE);
+}
+
void CallClient::InitPresence() {
presence_push_ = new buzz::PresencePushTask(xmpp_client_, this);
presence_push_->SignalStatusUpdate.connect(
@@ -502,7 +532,9 @@
presence_push_->Start();
presence_out_ = new buzz::PresenceOutTask(xmpp_client_);
- RefreshStatus();
+ SetAvailable(xmpp_client_->jid(), &my_status_);
+ SetCaps(media_client_->GetCapabilities(), &my_status_);
+ SendStatus(my_status_);
presence_out_->Start();
muc_invite_recv_ = new buzz::MucInviteRecvTask(xmpp_client_);
@@ -517,23 +549,8 @@
friend_invite_send_->Start();
}
-void CallClient::RefreshStatus() {
- int media_caps = media_client_->GetCapabilities();
- my_status_.set_jid(xmpp_client_->jid());
- my_status_.set_available(true);
- my_status_.set_show(buzz::Status::SHOW_ONLINE);
- my_status_.set_priority(0);
- my_status_.set_know_capabilities(true);
- my_status_.set_pmuc_capability(true);
- my_status_.set_voice_capability(
- (media_caps & cricket::AUDIO_RECV) != 0);
- my_status_.set_video_capability(
- (media_caps & cricket::VIDEO_RECV) != 0);
- my_status_.set_camera_capability(
- (media_caps & cricket::VIDEO_SEND) != 0);
- my_status_.set_is_google_client(true);
- my_status_.set_version("1.0.0.67");
- presence_out_->Send(my_status_);
+void CallClient::SendStatus(const buzz::Status& status) {
+ presence_out_->Send(status);
}
void CallClient::OnStatusUpdate(const buzz::Status& status) {
@@ -613,10 +630,6 @@
// if the first character is a +, assume it's a phone number
found_jid = callto_jid;
found = true;
- } else if (callto_jid.resource() == "voicemail") {
- // if the resource is /voicemail, allow that
- found_jid = callto_jid;
- found = true;
} else {
// otherwise, it's a friend
for (RosterMap::iterator iter = roster_->begin();
@@ -673,6 +686,8 @@
this, &CallClient::OnRecordingStateChange);
hangout_pubsub_client_->SignalRemoteMute.connect(
this, &CallClient::OnRemoteMuted);
+ hangout_pubsub_client_->SignalMediaBlock.connect(
+ this, &CallClient::OnMediaBlocked);
hangout_pubsub_client_->SignalRequestError.connect(
this, &CallClient::OnHangoutRequestError);
hangout_pubsub_client_->SignalPublishAudioMuteError.connect(
@@ -709,7 +724,7 @@
const std::string& nick, bool was_recording, bool is_recording) {
if (!was_recording && is_recording) {
console_->PrintLine("%s now recording.", nick.c_str());
- } else if (was_recording && is_recording) {
+ } else if (was_recording && !is_recording) {
console_->PrintLine("%s no longer recording.", nick.c_str());
}
}
@@ -726,6 +741,12 @@
}
}
+void CallClient::OnMediaBlocked(const std::string& blockee_nick,
+ const std::string& blocker_nick) {
+ console_->PrintLine("%s blocked by %s.",
+ blockee_nick.c_str(), blocker_nick.c_str());
+}
+
void CallClient::OnHangoutRequestError(const std::string& node,
const buzz::XmlElement* stanza) {
console_->PrintLine("Failed request pub sub items for node %s.",
@@ -753,31 +774,6 @@
console_->PrintLine("Failed to remote mute.");
}
-void CallClient::CallVoicemail(const std::string& name) {
- buzz::Jid jid(name);
- if (!jid.IsValid() || jid.node() == "") {
- console_->PrintLine("Invalid JID. JIDs should be in the form user@domain.");
- return;
- }
- buzz::VoicemailJidRequester *request =
- new buzz::VoicemailJidRequester(xmpp_client_, jid, my_status_.jid());
- request->SignalGotVoicemailJid.connect(this,
- &CallClient::OnFoundVoicemailJid);
- request->SignalVoicemailJidError.connect(this,
- &CallClient::OnVoicemailJidError);
- request->Start();
-}
-
-void CallClient::OnFoundVoicemailJid(const buzz::Jid& to,
- const buzz::Jid& voicemail) {
- console_->PrintLine("Calling %s's voicemail.", to.Str().c_str());
- PlaceCall(voicemail, cricket::CallOptions());
-}
-
-void CallClient::OnVoicemailJidError(const buzz::Jid& to) {
- console_->PrintLine("Unable to voicemail %s.", to.Str().c_str());
-}
-
void CallClient::Accept(const cricket::CallOptions& options) {
ASSERT(call_ && incoming_call_);
ASSERT(call_->sessions().size() == 1);
@@ -832,9 +828,8 @@
domain = room_name.substr(room_name.find("@") + 1);
}
- buzz::MucRoomLookupTask* lookup_query_task =
- new buzz::MucRoomLookupTask(
- xmpp_client_, buzz::JID_GOOGLE_MUC_LOOKUP, room, domain);
+ buzz::MucRoomLookupTask* lookup_query_task = new buzz::MucRoomLookupTask(
+ xmpp_client_, buzz::Jid(buzz::STR_GOOGLE_MUC_LOOKUP_JID), room, domain);
lookup_query_task->SignalResult.connect(this,
&CallClient::OnRoomLookupResponse);
lookup_query_task->SignalError.connect(this,
@@ -984,20 +979,26 @@
}
bool CallClient::InMuc() {
- return FirstMucJid().IsValid();
+ const buzz::Jid* muc_jid = FirstMucJid();
+ if (!muc_jid) return false;
+ return muc_jid->IsValid();
}
-const buzz::Jid& CallClient::FirstMucJid() {
- return mucs_.begin()->first;
+const buzz::Jid* CallClient::FirstMucJid() {
+ if (mucs_.empty()) return NULL;
+ return &(mucs_.begin()->first);
}
void CallClient::LeaveMuc(const std::string& room) {
buzz::Jid room_jid;
+ const buzz::Jid* muc_jid = FirstMucJid();
if (room.length() > 0) {
room_jid = buzz::Jid(room);
} else if (mucs_.size() > 0) {
// leave the first MUC if no JID specified
- room_jid = FirstMucJid();
+ if (muc_jid) {
+ room_jid = *(muc_jid);
+ }
}
if (!room_jid.IsValid()) {
@@ -1103,31 +1104,36 @@
void CallClient::OnDevicesChange() {
console_->PrintLine("Devices changed.");
- RefreshStatus();
+ SetMediaCaps(media_client_->GetCapabilities(), &my_status_);
+ SendStatus(my_status_);
}
void CallClient::SetVolume(const std::string& level) {
media_client_->SetOutputVolume(strtol(level.c_str(), NULL, 10));
}
-void CallClient::OnMediaSourcesUpdate(cricket::Call* call,
+void CallClient::OnMediaStreamsUpdate(cricket::Call* call,
cricket::Session* session,
- const cricket::MediaSources& sources) {
- for (cricket::NamedSources::const_iterator it = sources.video().begin();
- it != sources.video().end(); ++it) {
- if (it->removed) {
- RemoveStaticRenderedView(it->ssrc);
- } else {
- if (render_) {
+ const cricket::MediaStreams& added,
+ const cricket::MediaStreams& removed) {
+ if (call->video()) {
+ for (std::vector<cricket::StreamParams>::const_iterator
+ it = removed.video().begin(); it != removed.video().end(); ++it) {
+ RemoveStaticRenderedView(it->first_ssrc());
+ }
+
+ if (render_) {
+ for (std::vector<cricket::StreamParams>::const_iterator
+ it = added.video().begin(); it != added.video().end(); ++it) {
// TODO: Make dimensions and positions more configurable.
int offset = (50 * static_views_accumulated_count_) % 300;
- AddStaticRenderedView(session, it->ssrc, 640, 400, 30,
+ AddStaticRenderedView(session, it->first_ssrc(), 640, 400, 30,
offset, offset);
}
}
- }
- SendViewRequest(session);
+ SendViewRequest(session);
+ }
}
// TODO: Would these methods to add and remove views make
diff --git a/talk/examples/call/callclient.h b/talk/examples/call/callclient.h
index 568a818..76184dc 100644
--- a/talk/examples/call/callclient.h
+++ b/talk/examples/call/callclient.h
@@ -47,7 +47,6 @@
class MucInviteRecvTask;
class MucInviteSendTask;
class FriendInviteSendTask;
-class VoicemailJidRequester;
class DiscoInfoQueryTask;
class Muc;
class Status;
@@ -74,7 +73,8 @@
class Call;
class SessionManagerTask;
struct CallOptions;
-struct NamedSource;
+struct MediaStreams;
+struct StreamParams;
}
struct RosterItem {
@@ -98,7 +98,9 @@
class CallClient: public sigslot::has_slots<> {
public:
- explicit CallClient(buzz::XmppClient* xmpp_client);
+ CallClient(buzz::XmppClient* xmpp_client,
+ const std::string& caps_node,
+ const std::string& version);
~CallClient();
cricket::MediaSessionClient* media_client() const { return media_client_; }
@@ -117,6 +119,13 @@
void SetConsole(Console *console) {
console_ = console;
}
+ void SetPriority(int priority) {
+ my_status_.set_priority(priority);
+ }
+ void SendStatus() {
+ SendStatus(my_status_);
+ }
+ void SendStatus(const buzz::Status& status);
void ParseLine(const std::string &str);
@@ -127,7 +136,7 @@
void LookupAndJoinMuc(const std::string& room_name);
void InviteToMuc(const std::string& user, const std::string& room);
bool InMuc();
- const buzz::Jid& FirstMucJid();
+ const buzz::Jid* FirstMucJid();
void LeaveMuc(const std::string& room);
void SetNick(const std::string& muc_nick);
void SetPortAllocatorFlags(uint32 flags) { portallocator_flags_ = flags; }
@@ -157,7 +166,6 @@
void InitMedia();
void InitPresence();
- void RefreshStatus();
void OnRequestSignaling();
void OnSessionCreate(cricket::Session* session, bool initiate);
void OnCallCreate(cricket::Call* call);
@@ -180,6 +188,8 @@
void OnRemoteMuted(const std::string& mutee_nick,
const std::string& muter_nick,
bool should_mute_locally);
+ void OnMediaBlocked(const std::string& blockee_nick,
+ const std::string& blocker_nick);
void OnHangoutRequestError(const std::string& node,
const buzz::XmlElement* stanza);
void OnHangoutPublishAudioMuteError(const std::string& task_id,
@@ -192,14 +202,13 @@
const std::string& mutee_nick,
const buzz::XmlElement* stanza);
void OnDevicesChange();
- void OnFoundVoicemailJid(const buzz::Jid& to, const buzz::Jid& voicemail);
- void OnVoicemailJidError(const buzz::Jid& to);
- void OnMediaSourcesUpdate(cricket::Call* call,
+ void OnMediaStreamsUpdate(cricket::Call* call,
cricket::Session* session,
- const cricket::MediaSources& sources);
+ const cricket::MediaStreams& added,
+ const cricket::MediaStreams& removed);
void OnSpeakerChanged(cricket::Call* call,
cricket::Session* session,
- const cricket::NamedSource& speaker_source);
+ const cricket::StreamParams& speaker_stream);
void OnRoomLookupResponse(buzz::MucRoomLookupTask* task,
const buzz::MucRoomInfo& room_info);
void OnRoomLookupError(buzz::IqTask* task,
@@ -223,7 +232,6 @@
void PrintRoster();
void MakeCallTo(const std::string& name, const cricket::CallOptions& options);
void PlaceCall(const buzz::Jid& jid, const cricket::CallOptions& options);
- void CallVoicemail(const std::string& name);
void Accept(const cricket::CallOptions& options);
void Reject();
void Quit();
diff --git a/talk/examples/call/callclient_unittest.cc b/talk/examples/call/callclient_unittest.cc
new file mode 100644
index 0000000..0c2fd95
--- /dev/null
+++ b/talk/examples/call/callclient_unittest.cc
@@ -0,0 +1,47 @@
+/*
+ * libjingle
+ * Copyright 2008, 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.
+ */
+
+// Unit tests for CallClient
+
+#include "talk/base/gunit.h"
+#include "talk/examples/call/callclient.h"
+#include "talk/examples/login/xmppthread.h"
+#include "talk/session/phone/mediaengine.h"
+#include "talk/session/phone/filemediaengine.h"
+
+TEST(CallClientTest, CreateCallClientWithDefaultMediaEngine) {
+ XmppPump pump;
+ CallClient *client = new CallClient(pump.client(), "app", "version");
+ delete client;
+}
+
+TEST(CallClientTest, CreateCallClientWithFileMediaEngine) {
+ XmppPump pump;
+ CallClient *client = new CallClient(pump.client(), "app", "version");
+ client->SetMediaEngine(new cricket::FileMediaEngine);
+ delete client;
+}
diff --git a/talk/examples/call/mediaenginefactory.cc b/talk/examples/call/mediaenginefactory.cc
new file mode 100644
index 0000000..7bd39c9
--- /dev/null
+++ b/talk/examples/call/mediaenginefactory.cc
@@ -0,0 +1,82 @@
+//
+// libjingle
+// Copyright 2004--2007, 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/examples/call/mediaenginefactory.h"
+
+#include "talk/base/stringutils.h"
+#include "talk/session/phone/mediaengine.h"
+#include "talk/session/phone/fakemediaengine.h"
+#include "talk/session/phone/filemediaengine.h"
+
+std::vector<cricket::AudioCodec> RequiredAudioCodecs() {
+ std::vector<cricket::AudioCodec> audio_codecs;
+ audio_codecs.push_back(
+ cricket::AudioCodec(9, "G722", 16000, 0, 1, 0));
+ audio_codecs.push_back(
+ cricket::AudioCodec(0, "PCMU", 8000, 0, 1, 0));
+ audio_codecs.push_back(
+ cricket::AudioCodec(13, "CN", 8000, 0, 1, 0));
+ audio_codecs.push_back(
+ cricket::AudioCodec(105, "CN", 16000, 0, 1, 0));
+ return audio_codecs;
+}
+
+std::vector<cricket::VideoCodec> RequiredVideoCodecs() {
+ std::vector<cricket::VideoCodec> video_codecs;
+ video_codecs.push_back(
+ cricket::VideoCodec(97, "H264", 320, 240, 30, 0));
+ video_codecs.push_back(
+ cricket::VideoCodec(99, "H264-SVC", 640, 360, 30, 0));
+ return video_codecs;
+}
+
+cricket::MediaEngineInterface* MediaEngineFactory::CreateFileMediaEngine(
+ const char* voice_in, const char* voice_out,
+ const char* video_in, const char* video_out) {
+
+ cricket::FileMediaEngine* file_media_engine = new cricket::FileMediaEngine;
+ // Set the RTP dump file names.
+ if (voice_in) {
+ file_media_engine->set_voice_input_filename(voice_in);
+ }
+ if (voice_out) {
+ file_media_engine->set_voice_output_filename(voice_out);
+ }
+ if (video_in) {
+ file_media_engine->set_video_input_filename(video_in);
+ }
+ if (video_out) {
+ file_media_engine->set_video_output_filename(video_out);
+ }
+
+ // Set voice and video codecs. TODO: The codecs actually depend on
+ // the the input voice and video streams.
+ file_media_engine->set_voice_codecs(RequiredAudioCodecs());
+ file_media_engine->set_video_codecs(RequiredVideoCodecs());
+
+ return file_media_engine;
+}
diff --git a/talk/examples/call/mediaenginefactory.h b/talk/examples/call/mediaenginefactory.h
new file mode 100644
index 0000000..f7ba68e
--- /dev/null
+++ b/talk/examples/call/mediaenginefactory.h
@@ -0,0 +1,40 @@
+/*
+ * 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_EXAMPLES_CALL_MEDIAENGINEFACTORY_H_
+#define TALK_EXAMPLES_CALL_MEDIAENGINEFACTORY_H_
+
+#include "talk/session/phone/mediaengine.h"
+
+class MediaEngineFactory {
+ public:
+ static cricket::MediaEngineInterface* CreateFileMediaEngine(
+ const char* voice_in, const char* voice_out,
+ const char* video_in, const char* video_out);
+};
+
+#endif // TALK_EXAMPLES_CALL_MEDIAENGINEFACTORY_H_
diff --git a/talk/examples/call/presenceouttask.cc b/talk/examples/call/presenceouttask.cc
index 919a1af..222036f 100644
--- a/talk/examples/call/presenceouttask.cc
+++ b/talk/examples/call/presenceouttask.cc
@@ -39,7 +39,9 @@
if (GetState() != STATE_INIT && GetState() != STATE_START)
return XMPP_RETURN_BADSTATE;
- QueueStanza(TranslateStatus(s));
+ XmlElement * presence = TranslateStatus(s);
+ QueueStanza(presence);
+ delete presence;
return XMPP_RETURN_OK;
}
@@ -51,6 +53,7 @@
XmlElement * presence = TranslateStatus(s);
presence->AddAttr(QN_TO, j.Str());
QueueStanza(presence);
+ delete presence;
return XMPP_RETURN_OK;
}
@@ -63,6 +66,7 @@
presence->AddAttr(QN_TYPE, "probe");
QueueStanza(presence);
+ delete presence;
return XMPP_RETURN_OK;
}
@@ -117,9 +121,9 @@
result->AddElement(new XmlElement(QN_PRIORITY));
result->AddText(pri, 1);
- if (s.know_capabilities() && s.is_google_client()) {
+ if (s.know_capabilities()) {
result->AddElement(new XmlElement(QN_CAPS_C, true));
- result->AddAttr(QN_NODE, GOOGLE_CLIENT_NODE, 1);
+ result->AddAttr(QN_NODE, s.caps_node(), 1);
result->AddAttr(QN_VER, s.version(), 1);
std::string caps;
diff --git a/talk/examples/call/presencepushtask.cc b/talk/examples/call/presencepushtask.cc
index fba3322..97e0d35 100644
--- a/talk/examples/call/presencepushtask.cc
+++ b/talk/examples/call/presencepushtask.cc
@@ -187,11 +187,8 @@
std::string exts = caps->Attr(QN_EXT);
s->set_know_capabilities(true);
-
- if (node == GOOGLE_CLIENT_NODE) {
- s->set_is_google_client(true);
- s->set_version(ver);
- }
+ s->set_caps_node(node);
+ s->set_version(ver);
if (ListContainsToken(exts, "voice-v1")) {
s->set_voice_capability(true);
diff --git a/talk/examples/call/status.h b/talk/examples/call/status.h
index c3778e5..fb8fbc8 100644
--- a/talk/examples/call/status.h
+++ b/talk/examples/call/status.h
@@ -31,24 +31,22 @@
#include "talk/xmpp/jid.h"
#include "talk/xmpp/constants.h"
-#define GOOGLE_CLIENT_NODE "http://www.google.com/xmpp/client/caps"
-
namespace buzz {
class Status {
public:
- Status() :
- pri_(0),
- show_(SHOW_NONE),
- available_(false),
- e_code_(0),
- feedback_probation_(false),
- know_capabilities_(false),
- voice_capability_(false),
- pmuc_capability_(false),
- video_capability_(false),
- camera_capability_(false),
- is_google_client_(false) {}
+ Status()
+ : pri_(0),
+ show_(SHOW_NONE),
+ available_(false),
+ e_code_(0),
+ feedback_probation_(false),
+ know_capabilities_(false),
+ voice_capability_(false),
+ pmuc_capability_(false),
+ video_capability_(false),
+ camera_capability_(false) {
+ }
~Status() {}
@@ -66,29 +64,29 @@
SHOW_CHAT = 6,
};
- const Jid & jid() const { return jid_; }
+ const Jid& jid() const { return jid_; }
int priority() const { return pri_; }
Show show() const { return show_; }
- const std::string & status() const { return status_; }
- const std::string & nick() const { return nick_; }
+ const std::string& status() const { return status_; }
+ const std::string& nick() const { return nick_; }
bool available() const { return available_ ; }
int error_code() const { return e_code_; }
- const std::string & error_string() const { return e_str_; }
+ const std::string& error_string() const { return e_str_; }
bool know_capabilities() const { return know_capabilities_; }
bool voice_capability() const { return voice_capability_; }
bool pmuc_capability() const { return pmuc_capability_; }
bool video_capability() const { return video_capability_; }
bool camera_capability() const { return camera_capability_; }
- bool is_google_client() const { return is_google_client_; }
- const std::string & version() const { return version_; }
+ const std::string& caps_node() const { return caps_node_; }
+ const std::string& version() const { return version_; }
bool feedback_probation() const { return feedback_probation_; }
const std::string& sent_time() const { return sent_time_; }
- void set_jid(const Jid & jid) { jid_ = jid; }
+ void set_jid(const Jid& jid) { jid_ = jid; }
void set_priority(int pri) { pri_ = pri; }
void set_show(Show show) { show_ = show; }
- void set_status(const std::string & status) { status_ = status; }
- void set_nick(const std::string & nick) { nick_ = nick; }
+ void set_status(const std::string& status) { status_ = status; }
+ void set_nick(const std::string& nick) { nick_ = nick; }
void set_available(bool a) { available_ = a; }
void set_error(int e_code, const std::string e_str)
{ e_code_ = e_code; e_str_ = e_str; }
@@ -97,22 +95,22 @@
void set_pmuc_capability(bool f) { pmuc_capability_ = f; }
void set_video_capability(bool f) { video_capability_ = f; }
void set_camera_capability(bool f) { camera_capability_ = f; }
- void set_is_google_client(bool f) { is_google_client_ = f; }
- void set_version(const std::string & v) { version_ = v; }
+ void set_caps_node(const std::string& f) { caps_node_ = f; }
+ void set_version(const std::string& v) { version_ = v; }
void set_feedback_probation(bool f) { feedback_probation_ = f; }
void set_sent_time(const std::string& time) { sent_time_ = time; }
- void UpdateWith(const Status & new_value) {
+ void UpdateWith(const Status& new_value) {
if (!new_value.know_capabilities()) {
bool k = know_capabilities();
- bool i = is_google_client();
bool p = voice_capability();
+ std::string node = caps_node();
std::string v = version();
*this = new_value;
set_know_capabilities(k);
- set_is_google_client(i);
+ set_caps_node(node);
set_voice_capability(p);
set_version(v);
}
@@ -175,7 +173,7 @@
return result;
}
- static std::string TrimStatus(const std::string & st) {
+ static std::string TrimStatus(const std::string& st) {
std::string s(st);
int j = 0;
bool collapsing = true;
@@ -220,7 +218,7 @@
bool pmuc_capability_;
bool video_capability_;
bool camera_capability_;
- bool is_google_client_;
+ std::string caps_node_;
std::string version_;
std::string sent_time_; // from the jabber:x:delay element
diff --git a/talk/examples/login/autoportallocator.h b/talk/examples/login/autoportallocator.h
new file mode 100644
index 0000000..7e0b062
--- /dev/null
+++ b/talk/examples/login/autoportallocator.h
@@ -0,0 +1,69 @@
+/*
+ * libjingle
+ * Copyright 2010, 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_EXAMPLES_LOGIN_AUTOPORTALLOCATOR_H_
+#define TALK_EXAMPLES_LOGIN_AUTOPORTALLOCATOR_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/examples/login/jingleinfotask.h"
+#include "talk/base/sigslot.h"
+#include "talk/p2p/client/httpportallocator.h"
+#include "talk/xmpp/xmppclient.h"
+
+// This class sets the relay and stun servers using XmppClient.
+// It enables the client to traverse Proxy and NAT.
+class AutoPortAllocator : public cricket::HttpPortAllocator {
+ public:
+ AutoPortAllocator(talk_base::NetworkManager* network_manager,
+ const std::string& user_agent)
+ : cricket::HttpPortAllocator(network_manager, user_agent) {
+ }
+
+ // Creates and initiates a task to get relay token from XmppClient and set
+ // it appropriately.
+ void SetXmppClient(buzz::XmppClient* client) {
+ // The JingleInfoTask is freed by the task-runner.
+ buzz::JingleInfoTask* jit = new buzz::JingleInfoTask(client);
+ jit->SignalJingleInfo.connect(this, &AutoPortAllocator::OnJingleInfo);
+ jit->Start();
+ jit->RefreshJingleInfoNow();
+ }
+
+ private:
+ void OnJingleInfo(
+ const std::string& token,
+ const std::vector<std::string>& relay_hosts,
+ const std::vector<talk_base::SocketAddress>& stun_hosts) {
+ SetRelayToken(token);
+ SetStunHosts(stun_hosts);
+ SetRelayHosts(relay_hosts);
+ }
+};
+
+#endif // TALK_EXAMPLES_LOGIN_AUTOPORTALLOCATOR_H_
diff --git a/talk/examples/login/jingleinfotask.cc b/talk/examples/login/jingleinfotask.cc
new file mode 100644
index 0000000..c8932cd
--- /dev/null
+++ b/talk/examples/login/jingleinfotask.cc
@@ -0,0 +1,137 @@
+/*
+ * libjingle
+ * Copyright 2010, 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/examples/login/jingleinfotask.h"
+#include "talk/base/socketaddress.h"
+#include "talk/xmpp/constants.h"
+#include "talk/xmpp/xmppclient.h"
+#include "talk/xmpp/xmpptask.h"
+
+namespace buzz {
+
+class JingleInfoTask::JingleInfoGetTask : public XmppTask {
+ public:
+ explicit JingleInfoGetTask(XmppTaskParentInterface* parent)
+ : XmppTask(parent, XmppEngine::HL_SINGLE),
+ done_(false) {}
+
+ virtual int ProcessStart() {
+ talk_base::scoped_ptr<XmlElement> get(
+ MakeIq(STR_GET, Jid(), task_id()));
+ get->AddElement(new XmlElement(QN_JINGLE_INFO_QUERY, true));
+ if (SendStanza(get.get()) != XMPP_RETURN_OK) {
+ return STATE_ERROR;
+ }
+ return STATE_RESPONSE;
+ }
+ virtual int ProcessResponse() {
+ if (done_)
+ return STATE_DONE;
+ return STATE_BLOCKED;
+ }
+
+ protected:
+ virtual bool HandleStanza(const XmlElement * stanza) {
+ if (!MatchResponseIq(stanza, Jid(), task_id()))
+ return false;
+
+ if (stanza->Attr(QN_TYPE) != STR_RESULT)
+ return false;
+
+ // Queue the stanza with the parent so these don't get handled out of order
+ JingleInfoTask* parent = static_cast<JingleInfoTask*>(GetParent());
+ parent->QueueStanza(stanza);
+
+ // Wake ourselves so we can go into the done state
+ done_ = true;
+ Wake();
+ return true;
+ }
+
+ bool done_;
+};
+
+
+void JingleInfoTask::RefreshJingleInfoNow() {
+ JingleInfoGetTask* get_task = new JingleInfoGetTask(this);
+ get_task->Start();
+}
+
+bool
+JingleInfoTask::HandleStanza(const XmlElement * stanza) {
+ if (!MatchRequestIq(stanza, "set", QN_JINGLE_INFO_QUERY))
+ return false;
+
+ // only respect relay push from the server
+ Jid from(stanza->Attr(QN_FROM));
+ if (!from.IsEmpty() &&
+ !from.BareEquals(GetClient()->jid()) &&
+ from != Jid(GetClient()->jid().domain()))
+ return false;
+
+ QueueStanza(stanza);
+ return true;
+}
+
+int
+JingleInfoTask::ProcessStart() {
+ std::vector<std::string> relay_hosts;
+ std::vector<talk_base::SocketAddress> stun_hosts;
+ std::string relay_token;
+ const XmlElement * stanza = NextStanza();
+ if (stanza == NULL)
+ return STATE_BLOCKED;
+ const XmlElement * query = stanza->FirstNamed(QN_JINGLE_INFO_QUERY);
+ if (query == NULL)
+ return STATE_START;
+ const XmlElement *stun = query->FirstNamed(QN_JINGLE_INFO_STUN);
+ if (stun) {
+ for (const XmlElement *server = stun->FirstNamed(QN_JINGLE_INFO_SERVER);
+ server != NULL; server = server->NextNamed(QN_JINGLE_INFO_SERVER)) {
+ std::string host = server->Attr(QN_JINGLE_INFO_HOST);
+ std::string port = server->Attr(QN_JINGLE_INFO_UDP);
+ if (host != STR_EMPTY && host != STR_EMPTY) {
+ stun_hosts.push_back(talk_base::SocketAddress(host, atoi(port.c_str())));
+ }
+ }
+ }
+
+ const XmlElement *relay = query->FirstNamed(QN_JINGLE_INFO_RELAY);
+ if (relay) {
+ relay_token = relay->TextNamed(QN_JINGLE_INFO_TOKEN);
+ for (const XmlElement *server = relay->FirstNamed(QN_JINGLE_INFO_SERVER);
+ server != NULL; server = server->NextNamed(QN_JINGLE_INFO_SERVER)) {
+ std::string host = server->Attr(QN_JINGLE_INFO_HOST);
+ if (host != STR_EMPTY) {
+ relay_hosts.push_back(host);
+ }
+ }
+ }
+ SignalJingleInfo(relay_token, relay_hosts, stun_hosts);
+ return STATE_START;
+}
+}
diff --git a/talk/examples/login/jingleinfotask.h b/talk/examples/login/jingleinfotask.h
new file mode 100644
index 0000000..dbc3fb0
--- /dev/null
+++ b/talk/examples/login/jingleinfotask.h
@@ -0,0 +1,61 @@
+/*
+ * libjingle
+ * Copyright 2010, 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_EXAMPLES_LOGIN_JINGLEINFOTASK_H_
+#define TALK_EXAMPLES_LOGIN_JINGLEINFOTASK_H_
+
+#include <vector>
+
+#include "talk/p2p/client/httpportallocator.h"
+#include "talk/xmpp/xmppengine.h"
+#include "talk/xmpp/xmpptask.h"
+#include "talk/base/sigslot.h"
+
+namespace buzz {
+
+class JingleInfoTask : public XmppTask {
+ public:
+ explicit JingleInfoTask(XmppTaskParentInterface* parent) :
+ XmppTask(parent, XmppEngine::HL_TYPE) {}
+
+ virtual int ProcessStart();
+ void RefreshJingleInfoNow();
+
+ sigslot::signal3<const std::string &,
+ const std::vector<std::string> &,
+ const std::vector<talk_base::SocketAddress> &>
+ SignalJingleInfo;
+
+ protected:
+ class JingleInfoGetTask;
+ friend class JingleInfoGetTask;
+
+ virtual bool HandleStanza(const XmlElement * stanza);
+};
+}
+
+#endif // TALK_EXAMPLES_LOGIN_JINGLEINFOTASK_H_
diff --git a/talk/examples/login/login_main.cc b/talk/examples/login/login_main.cc
index 186020a..9cd00b9 100644
--- a/talk/examples/login/login_main.cc
+++ b/talk/examples/login/login_main.cc
@@ -31,6 +31,7 @@
#include "talk/base/thread.h"
#include "talk/xmpp/xmppclientsettings.h"
#include "talk/examples/login/xmppthread.h"
+#include "talk/xmpp/xmppengine.h"
int main(int argc, char **argv) {
std::cout << "Auth Cookie: ";
@@ -48,7 +49,7 @@
buzz::XmppClientSettings xcs;
xcs.set_user(username.c_str());
xcs.set_host("gmail.com");
- xcs.set_use_tls(false);
+ xcs.set_use_tls(buzz::TLS_DISABLED);
xcs.set_auth_cookie(auth_cookie.c_str());
xcs.set_server(talk_base::SocketAddress("talk.google.com", 5222));
thread.Login(xcs);
diff --git a/talk/examples/login/xmppauth.cc b/talk/examples/login/xmppauth.cc
index 3551b97..7773e00 100644
--- a/talk/examples/login/xmppauth.cc
+++ b/talk/examples/login/xmppauth.cc
@@ -2,26 +2,26 @@
* libjingle
* Copyright 2004--2005, Google Inc.
*
- * Redistribution and use in source and binary forms, with or without
+ * 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,
+ * 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
+ * 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
+ * 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,
+ * 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
+ * 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.
*/
@@ -37,7 +37,7 @@
XmppAuth::~XmppAuth() {
}
-
+
void XmppAuth::StartPreXmppAuth(const buzz::Jid & jid,
const talk_base::SocketAddress & server,
const talk_base::CryptString & pass,
@@ -49,25 +49,26 @@
SignalAuthDone();
}
-
+
std::string XmppAuth::ChooseBestSaslMechanism(
const std::vector<std::string> & mechanisms,
bool encrypted) {
std::vector<std::string>::const_iterator it;
- // a token is the weakest auth - 15s, service-limited, so prefer it.
+ // A token is the weakest auth - 15s, service-limited, so prefer it.
it = std::find(mechanisms.begin(), mechanisms.end(), "X-GOOGLE-TOKEN");
if (it != mechanisms.end() && !auth_cookie_.empty())
return "X-GOOGLE-TOKEN";
- // a cookie is the next weakest - 14 days
+ // A cookie is the next weakest - 14 days.
it = std::find(mechanisms.begin(), mechanisms.end(), "X-GOOGLE-COOKIE");
if (it != mechanisms.end() && !auth_cookie_.empty())
return "X-GOOGLE-COOKIE";
- it = std::find(mechanisms.begin(), mechanisms.end(), "PLAIN");
- if (it != mechanisms.end())
- return "PLAIN";
+ // As a last resort, use plain authentication.
+ it = std::find(mechanisms.begin(), mechanisms.end(), "PLAIN");
+ if (it != mechanisms.end())
+ return "PLAIN";
// No good mechanism found
return "";
diff --git a/talk/examples/login/xmpppump.h b/talk/examples/login/xmpppump.h
index 4e79748..6f705ec 100644
--- a/talk/examples/login/xmpppump.h
+++ b/talk/examples/login/xmpppump.h
@@ -31,7 +31,7 @@
#include "talk/base/messagequeue.h"
#include "talk/base/taskrunner.h"
#include "talk/base/thread.h"
-#include "talk/base/time.h"
+#include "talk/base/timeutils.h"
#include "talk/xmpp/xmppclient.h"
#include "talk/xmpp/xmppengine.h"
#include "talk/xmpp/xmpptask.h"
diff --git a/talk/examples/login/xmppsocket.cc b/talk/examples/login/xmppsocket.cc
index 75325e4..cbd4661 100644
--- a/talk/examples/login/xmppsocket.cc
+++ b/talk/examples/login/xmppsocket.cc
@@ -45,13 +45,13 @@
#endif // FEATURE_ENABLE_SSL
#endif // USE_SSLSTREAM
-XmppSocket::XmppSocket(bool tls) : tls_(tls) {
+XmppSocket::XmppSocket(buzz::TlsOptions tls) : tls_(tls) {
talk_base::Thread* pth = talk_base::Thread::Current();
talk_base::AsyncSocket* socket =
pth->socketserver()->CreateAsyncSocket(SOCK_STREAM);
#ifndef USE_SSLSTREAM
#ifdef FEATURE_ENABLE_SSL
- if (tls_) {
+ if (tls_ != buzz::TLS_DISABLED) {
socket = talk_base::SSLAdapter::Create(socket);
}
#endif // FEATURE_ENABLE_SSL
@@ -65,7 +65,7 @@
cricket_socket_ = socket;
stream_ = new talk_base::SocketStream(cricket_socket_);
#ifdef FEATURE_ENABLE_SSL
- if (tls_)
+ if (tls_ != buzz::TLS_DISABLED)
stream_ = talk_base::SSLStreamAdapter::Create(stream_);
#endif // FEATURE_ENABLE_SSL
stream_->SignalEvent.connect(this, &XmppSocket::OnEvent);
@@ -226,7 +226,7 @@
bool XmppSocket::StartTls(const std::string & domainname) {
#if defined(FEATURE_ENABLE_SSL)
- if (!tls_)
+ if (tls_ == buzz::TLS_DISABLED)
return false;
#ifndef USE_SSLSTREAM
talk_base::SSLAdapter* ssl_adapter =
diff --git a/talk/examples/login/xmppsocket.h b/talk/examples/login/xmppsocket.h
index bce8ee3..ed9f6e1 100644
--- a/talk/examples/login/xmppsocket.h
+++ b/talk/examples/login/xmppsocket.h
@@ -32,6 +32,7 @@
#include "talk/base/bytebuffer.h"
#include "talk/base/sigslot.h"
#include "talk/xmpp/asyncsocket.h"
+#include "talk/xmpp/xmppengine.h"
// The below define selects the SSLStreamAdapter implementation for
// SSL, as opposed to the SSLAdapter socket adapter.
@@ -44,7 +45,7 @@
class XmppSocket : public buzz::AsyncSocket, public sigslot::has_slots<> {
public:
- XmppSocket(bool tls);
+ XmppSocket(buzz::TlsOptions tls);
~XmppSocket();
virtual buzz::AsyncSocket::State state();
@@ -75,7 +76,7 @@
#endif // USE_SSLSTREAM
buzz::AsyncSocket::State state_;
talk_base::ByteBuffer buffer_;
- bool tls_;
+ buzz::TlsOptions tls_;
};
#endif // _XMPPSOCKET_H_
diff --git a/talk/examples/login/xmppthread.cc b/talk/examples/login/xmppthread.cc
index c030391..5345643 100644
--- a/talk/examples/login/xmppthread.cc
+++ b/talk/examples/login/xmppthread.cc
@@ -25,8 +25,9 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "talk/xmpp/xmppclientsettings.h"
#include "talk/examples/login/xmppthread.h"
+
+#include "talk/xmpp/xmppclientsettings.h"
#include "talk/examples/login/xmppauth.h"
namespace {
@@ -70,7 +71,8 @@
if (pmsg->message_id == MSG_LOGIN) {
ASSERT(pmsg->pdata != NULL);
LoginData* data = reinterpret_cast<LoginData*>(pmsg->pdata);
- pump_->DoLogin(data->xcs, new XmppSocket(false), new XmppAuth());
+ pump_->DoLogin(data->xcs, new XmppSocket(buzz::TLS_DISABLED),
+ new XmppAuth());
delete data;
} else if (pmsg->message_id == MSG_DISCONNECT) {
pump_->DoDisconnect();
diff --git a/talk/examples/login/xmppthread.h b/talk/examples/login/xmppthread.h
index bfed5e0..efaa67a 100644
--- a/talk/examples/login/xmppthread.h
+++ b/talk/examples/login/xmppthread.h
@@ -25,13 +25,15 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef _XMPPTHREAD_H_
-#define _XMPPTHREAD_H_
+#ifndef TALK_EXAMPLES_LOGIN_XMPPTHREAD_H_
+#define TALK_EXAMPLES_LOGIN_XMPPTHREAD_H_
-#include "talk/xmpp/xmppclientsettings.h"
#include "talk/base/thread.h"
#include "talk/examples/login/xmpppump.h"
#include "talk/examples/login/xmppsocket.h"
+#include "talk/xmpp/xmppclientsettings.h"
+#include "talk/xmpp/xmppengine.h"
+
class XmppThread:
public talk_base::Thread, XmppPumpNotify, talk_base::MessageHandler {
@@ -53,4 +55,4 @@
void OnMessage(talk_base::Message* pmsg);
};
-#endif // _XMPPTHREAD_H_
+#endif // TALK_EXAMPLES_LOGIN_XMPPTHREAD_H_
diff --git a/talk/examples/pcp/pcp_main.cc b/talk/examples/pcp/pcp_main.cc
new file mode 100644
index 0000000..3ec263f
--- /dev/null
+++ b/talk/examples/pcp/pcp_main.cc
@@ -0,0 +1,709 @@
+#define _CRT_SECURE_NO_DEPRECATE 1
+
+#include <time.h>
+
+#include <iomanip>
+#include <iostream>
+#include <string>
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif // HAVE_CONFIG_H
+
+#if HAVE_OPENSSL_SSL_H
+#define USE_SSL_TUNNEL
+#endif
+
+#include "talk/base/basicdefs.h"
+#include "talk/base/common.h"
+#include "talk/base/helpers.h"
+#include "talk/base/logging.h"
+#include "talk/base/ssladapter.h"
+#include "talk/base/stringutils.h"
+#include "talk/base/thread.h"
+#include "talk/examples/login/autoportallocator.h"
+#include "talk/examples/login/xmpppump.h"
+#include "talk/examples/login/xmppsocket.h"
+#include "talk/p2p/base/sessionmanager.h"
+#include "talk/p2p/client/sessionmanagertask.h"
+#include "talk/xmpp/xmppengine.h"
+#ifdef USE_SSL_TUNNEL
+#include "talk/session/tunnel/securetunnelsessionclient.h"
+#endif
+#include "talk/session/tunnel/tunnelsessionclient.h"
+#include "talk/xmpp/xmppclient.h"
+#include "talk/xmpp/xmppclientsettings.h"
+
+#ifndef MAX_PATH
+#define MAX_PATH 256
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER < 1400)
+// The following are necessary to properly link when compiling STL without
+// /EHsc, otherwise known as C++ exceptions.
+void __cdecl std::_Throw(const std::exception &) {}
+std::_Prhand std::_Raise_handler = 0;
+#endif
+
+enum {
+ MSG_LOGIN_COMPLETE = 1,
+ MSG_LOGIN_FAILED,
+ MSG_DONE,
+};
+
+buzz::Jid gUserJid;
+talk_base::InsecureCryptStringImpl gUserPass;
+std::string gXmppHost = "talk.google.com";
+int gXmppPort = 5222;
+buzz::TlsOptions gXmppUseTls = buzz::TLS_REQUIRED;
+
+class DebugLog : public sigslot::has_slots<> {
+public:
+ DebugLog() :
+ debug_input_buf_(NULL), debug_input_len_(0), debug_input_alloc_(0),
+ debug_output_buf_(NULL), debug_output_len_(0), debug_output_alloc_(0),
+ censor_password_(false)
+ {}
+ char * debug_input_buf_;
+ int debug_input_len_;
+ int debug_input_alloc_;
+ char * debug_output_buf_;
+ int debug_output_len_;
+ int debug_output_alloc_;
+ bool censor_password_;
+
+ void Input(const char * data, int len) {
+ if (debug_input_len_ + len > debug_input_alloc_) {
+ char * old_buf = debug_input_buf_;
+ debug_input_alloc_ = 4096;
+ while (debug_input_alloc_ < debug_input_len_ + len) {
+ debug_input_alloc_ *= 2;
+ }
+ debug_input_buf_ = new char[debug_input_alloc_];
+ memcpy(debug_input_buf_, old_buf, debug_input_len_);
+ delete[] old_buf;
+ }
+ memcpy(debug_input_buf_ + debug_input_len_, data, len);
+ debug_input_len_ += len;
+ DebugPrint(debug_input_buf_, &debug_input_len_, false);
+ }
+
+ void Output(const char * data, int len) {
+ if (debug_output_len_ + len > debug_output_alloc_) {
+ char * old_buf = debug_output_buf_;
+ debug_output_alloc_ = 4096;
+ while (debug_output_alloc_ < debug_output_len_ + len) {
+ debug_output_alloc_ *= 2;
+ }
+ debug_output_buf_ = new char[debug_output_alloc_];
+ memcpy(debug_output_buf_, old_buf, debug_output_len_);
+ delete[] old_buf;
+ }
+ memcpy(debug_output_buf_ + debug_output_len_, data, len);
+ debug_output_len_ += len;
+ DebugPrint(debug_output_buf_, &debug_output_len_, true);
+ }
+
+ static bool
+ IsAuthTag(const char * str, size_t len) {
+ if (str[0] == '<' && str[1] == 'a' &&
+ str[2] == 'u' &&
+ str[3] == 't' &&
+ str[4] == 'h' &&
+ str[5] <= ' ') {
+ std::string tag(str, len);
+
+ if (tag.find("mechanism") != std::string::npos)
+ return true;
+
+ }
+ return false;
+ }
+
+ void
+ DebugPrint(char * buf, int * plen, bool output) {
+ int len = *plen;
+ if (len > 0) {
+ time_t tim = time(NULL);
+ struct tm * now = localtime(&tim);
+ char *time_string = asctime(now);
+ if (time_string) {
+ size_t time_len = strlen(time_string);
+ if (time_len > 0) {
+ time_string[time_len-1] = 0; // trim off terminating \n
+ }
+ }
+ LOG(INFO) << (output ? "SEND >>>>>>>>>>>>>>>>>>>>>>>>>" : "RECV <<<<<<<<<<<<<<<<<<<<<<<<<")
+ << " : " << time_string;
+
+ bool indent;
+ int start = 0, nest = 3;
+ for (int i = 0; i < len; i += 1) {
+ if (buf[i] == '>') {
+ if ((i > 0) && (buf[i-1] == '/')) {
+ indent = false;
+ } else if ((start + 1 < len) && (buf[start + 1] == '/')) {
+ indent = false;
+ nest -= 2;
+ } else {
+ indent = true;
+ }
+
+ // Output a tag
+ LOG(INFO) << std::setw(nest) << " " << std::string(buf + start, i + 1 - start);
+
+ if (indent)
+ nest += 2;
+
+ // Note if it's a PLAIN auth tag
+ if (IsAuthTag(buf + start, i + 1 - start)) {
+ censor_password_ = true;
+ }
+
+ // incr
+ start = i + 1;
+ }
+
+ if (buf[i] == '<' && start < i) {
+ if (censor_password_) {
+ LOG(INFO) << std::setw(nest) << " " << "## TEXT REMOVED ##";
+ censor_password_ = false;
+ }
+ else {
+ LOG(INFO) << std::setw(nest) << " " << std::string(buf + start, i - start);
+ }
+ start = i;
+ }
+ }
+ len = len - start;
+ memcpy(buf, buf + start, len);
+ *plen = len;
+ }
+ }
+
+};
+
+static DebugLog debug_log_;
+
+// Prints out a usage message then exits.
+void Usage() {
+ std::cerr << "Usage:" << std::endl;
+ std::cerr << " pcp [options] <my_jid> (server mode)" << std::endl;
+ std::cerr << " pcp [options] <my_jid> <src_file> <dst_full_jid>:<dst_file> (client sending)" << std::endl;
+ std::cerr << " pcp [options] <my_jid> <src_full_jid>:<src_file> <dst_file> (client rcv'ing)" << std::endl;
+ std::cerr << " --verbose" << std::endl;
+ std::cerr << " --xmpp-host=<host>" << std::endl;
+ std::cerr << " --xmpp-port=<port>" << std::endl;
+ std::cerr << " --xmpp-use-tls=(true|false)" << std::endl;
+ exit(1);
+}
+
+// Prints out an error message, a usage message, then exits.
+void Error(const std::string& msg) {
+ std::cerr << "error: " << msg << std::endl;
+ std::cerr << std::endl;
+ Usage();
+}
+
+void FatalError(const std::string& msg) {
+ std::cerr << "error: " << msg << std::endl;
+ std::cerr << std::endl;
+ exit(1);
+}
+
+// Determines whether the given string is an option. If so, the name and
+// value are appended to the given strings.
+bool ParseArg(const char* arg, std::string* name, std::string* value) {
+ if (strncmp(arg, "--", 2) != 0)
+ return false;
+
+ const char* eq = strchr(arg + 2, '=');
+ if (eq) {
+ if (name)
+ name->append(arg + 2, eq);
+ if (value)
+ value->append(eq + 1, arg + strlen(arg));
+ } else {
+ if (name)
+ name->append(arg + 2, arg + strlen(arg));
+ if (value)
+ value->clear();
+ }
+
+ return true;
+}
+
+int ParseIntArg(const std::string& name, const std::string& value) {
+ char* end;
+ long val = strtol(value.c_str(), &end, 10);
+ if (*end != '\0')
+ Error(std::string("value of option ") + name + " must be an integer");
+ return static_cast<int>(val);
+}
+
+#ifdef WIN32
+#pragma warning(push)
+// disable "unreachable code" warning b/c it varies between dbg and opt
+#pragma warning(disable: 4702)
+#endif
+bool ParseBoolArg(const std::string& name, const std::string& value) {
+ if (value == "true")
+ return true;
+ else if (value == "false")
+ return false;
+ else {
+ Error(std::string("value of option ") + name + " must be true or false");
+ return false;
+ }
+}
+#ifdef WIN32
+#pragma warning(pop)
+#endif
+
+void ParseFileArg(const char* arg, buzz::Jid* jid, std::string* file) {
+ const char* sep = strchr(arg, ':');
+ if (!sep) {
+ *file = arg;
+ } else {
+ buzz::Jid jid_arg(std::string(arg, sep-arg));
+ if (jid_arg.IsBare())
+ Error("A full JID is required for the source or destination arguments.");
+ *jid = jid_arg;
+ *file = std::string(sep+1);
+ }
+}
+
+
+void SetConsoleEcho(bool on) {
+#ifdef WIN32
+ HANDLE hIn = GetStdHandle(STD_INPUT_HANDLE);
+ if ((hIn == INVALID_HANDLE_VALUE) || (hIn == NULL))
+ return;
+
+ DWORD mode;
+ if (!GetConsoleMode(hIn, &mode))
+ return;
+
+ if (on) {
+ mode = mode | ENABLE_ECHO_INPUT;
+ } else {
+ mode = mode & ~ENABLE_ECHO_INPUT;
+ }
+
+ SetConsoleMode(hIn, mode);
+#else
+ int re;
+ if (on)
+ re = system("stty echo");
+ else
+ re = system("stty -echo");
+ if (-1 == re)
+ return;
+#endif
+}
+
+// Fills in a settings object with the values from the arguments.
+buzz::XmppClientSettings LoginSettings() {
+ buzz::XmppClientSettings xcs;
+ xcs.set_user(gUserJid.node());
+ xcs.set_host(gUserJid.domain());
+ xcs.set_resource("pcp");
+ xcs.set_pass(talk_base::CryptString(gUserPass));
+ talk_base::SocketAddress server(gXmppHost, gXmppPort);
+ xcs.set_server(server);
+ xcs.set_use_tls(gXmppUseTls);
+ return xcs;
+}
+
+// Runs the current thread until a message with the given ID is seen.
+uint32 Loop(const std::vector<uint32>& ids) {
+ talk_base::Message msg;
+ while (talk_base::Thread::Current()->Get(&msg)) {
+ if (msg.phandler == NULL) {
+ if (std::find(ids.begin(), ids.end(), msg.message_id) != ids.end())
+ return msg.message_id;
+ std::cout << "orphaned message: " << msg.message_id;
+ continue;
+ }
+ talk_base::Thread::Current()->Dispatch(&msg);
+ }
+ return 0;
+}
+
+#ifdef WIN32
+#pragma warning(disable:4355)
+#endif
+
+class CustomXmppPump : public XmppPumpNotify, public XmppPump {
+public:
+ CustomXmppPump() : XmppPump(this), server_(false) { }
+
+ void Serve(cricket::TunnelSessionClient* client) {
+ client->SignalIncomingTunnel.connect(this,
+ &CustomXmppPump::OnIncomingTunnel);
+ server_ = true;
+ }
+
+ void OnStateChange(buzz::XmppEngine::State state) {
+ switch (state) {
+ case buzz::XmppEngine::STATE_START:
+ std::cout << "connecting..." << std::endl;
+ break;
+ case buzz::XmppEngine::STATE_OPENING:
+ std::cout << "logging in..." << std::endl;
+ break;
+ case buzz::XmppEngine::STATE_OPEN:
+ std::cout << "logged in..." << std::endl;
+ talk_base::Thread::Current()->Post(NULL, MSG_LOGIN_COMPLETE);
+ break;
+ case buzz::XmppEngine::STATE_CLOSED:
+ std::cout << "logged out..." << std::endl;
+ talk_base::Thread::Current()->Post(NULL, MSG_LOGIN_FAILED);
+ break;
+ }
+ }
+
+ void OnIncomingTunnel(cricket::TunnelSessionClient* client, buzz::Jid jid,
+ std::string description, cricket::Session* session) {
+ std::cout << "IncomingTunnel from " << jid.Str()
+ << ": " << description << std::endl;
+ if (!server_ || (file_.get() != NULL)) {
+ client->DeclineTunnel(session);
+ return;
+ }
+ std::string filename;
+ bool send;
+ if (strncmp(description.c_str(), "send:", 5) == 0) {
+ send = true;
+ } else if (strncmp(description.c_str(), "recv:", 5) == 0) {
+ send = false;
+ } else {
+ client->DeclineTunnel(session);
+ return;
+ }
+ filename = description.substr(5);
+ talk_base::StreamInterface* stream = client->AcceptTunnel(session);
+ if (!ProcessStream(stream, filename, send))
+ talk_base::Thread::Current()->Post(NULL, MSG_DONE);
+
+ // TODO: There is a potential memory leak, however, since the PCP
+ // app doesn't work right now, I can't verify the fix actually works, so
+ // comment out the following line until we fix the PCP app.
+
+ // delete stream;
+ }
+
+ bool ProcessStream(talk_base::StreamInterface* stream,
+ const std::string& filename, bool send) {
+ ASSERT(file_.get() == NULL);
+ sending_ = send;
+ file_.reset(new talk_base::FileStream);
+ buffer_len_ = 0;
+ int err;
+ if (!file_->Open(filename.c_str(), sending_ ? "rb" : "wb", &err)) {
+ std::cerr << "Error opening <" << filename << ">: "
+ << std::strerror(err) << std::endl;
+ return false;
+ }
+ stream->SignalEvent.connect(this, &CustomXmppPump::OnStreamEvent);
+ if (stream->GetState() == talk_base::SS_CLOSED) {
+ std::cerr << "Failed to establish P2P tunnel" << std::endl;
+ return false;
+ }
+ if (stream->GetState() == talk_base::SS_OPEN) {
+ OnStreamEvent(stream,
+ talk_base::SE_OPEN | talk_base::SE_READ | talk_base::SE_WRITE, 0);
+ }
+ return true;
+ }
+
+ void OnStreamEvent(talk_base::StreamInterface* stream, int events,
+ int error) {
+ if (events & talk_base::SE_CLOSE) {
+ if (error == 0) {
+ std::cout << "Tunnel closed normally" << std::endl;
+ } else {
+ std::cout << "Tunnel closed with error: " << error << std::endl;
+ }
+ Cleanup(stream);
+ return;
+ }
+ if (events & talk_base::SE_OPEN) {
+ std::cout << "Tunnel connected" << std::endl;
+ }
+ talk_base::StreamResult result;
+ size_t count;
+ if (sending_ && (events & talk_base::SE_WRITE)) {
+ LOG(LS_VERBOSE) << "Tunnel SE_WRITE";
+ while (true) {
+ size_t write_pos = 0;
+ while (write_pos < buffer_len_) {
+ result = stream->Write(buffer_ + write_pos, buffer_len_ - write_pos,
+ &count, &error);
+ if (result == talk_base::SR_SUCCESS) {
+ write_pos += count;
+ continue;
+ }
+ if (result == talk_base::SR_BLOCK) {
+ buffer_len_ -= write_pos;
+ memmove(buffer_, buffer_ + write_pos, buffer_len_);
+ LOG(LS_VERBOSE) << "Tunnel write block";
+ return;
+ }
+ if (result == talk_base::SR_EOS) {
+ std::cout << "Tunnel closed unexpectedly on write" << std::endl;
+ } else {
+ std::cout << "Tunnel write error: " << error << std::endl;
+ }
+ Cleanup(stream);
+ return;
+ }
+ buffer_len_ = 0;
+ while (buffer_len_ < sizeof(buffer_)) {
+ result = file_->Read(buffer_ + buffer_len_,
+ sizeof(buffer_) - buffer_len_,
+ &count, &error);
+ if (result == talk_base::SR_SUCCESS) {
+ buffer_len_ += count;
+ continue;
+ }
+ if (result == talk_base::SR_EOS) {
+ if (buffer_len_ > 0)
+ break;
+ std::cout << "End of file" << std::endl;
+ // A hack until we have friendly shutdown
+ Cleanup(stream, true);
+ return;
+ } else if (result == talk_base::SR_BLOCK) {
+ std::cout << "File blocked unexpectedly on read" << std::endl;
+ } else {
+ std::cout << "File read error: " << error << std::endl;
+ }
+ Cleanup(stream);
+ return;
+ }
+ }
+ }
+ if (!sending_ && (events & talk_base::SE_READ)) {
+ LOG(LS_VERBOSE) << "Tunnel SE_READ";
+ while (true) {
+ buffer_len_ = 0;
+ while (buffer_len_ < sizeof(buffer_)) {
+ result = stream->Read(buffer_ + buffer_len_,
+ sizeof(buffer_) - buffer_len_,
+ &count, &error);
+ if (result == talk_base::SR_SUCCESS) {
+ buffer_len_ += count;
+ continue;
+ }
+ if (result == talk_base::SR_BLOCK) {
+ if (buffer_len_ > 0)
+ break;
+ LOG(LS_VERBOSE) << "Tunnel read block";
+ return;
+ }
+ if (result == talk_base::SR_EOS) {
+ std::cout << "Tunnel closed unexpectedly on read" << std::endl;
+ } else {
+ std::cout << "Tunnel read error: " << error << std::endl;
+ }
+ Cleanup(stream);
+ return;
+ }
+ size_t write_pos = 0;
+ while (write_pos < buffer_len_) {
+ result = file_->Write(buffer_ + write_pos, buffer_len_ - write_pos,
+ &count, &error);
+ if (result == talk_base::SR_SUCCESS) {
+ write_pos += count;
+ continue;
+ }
+ if (result == talk_base::SR_EOS) {
+ std::cout << "File closed unexpectedly on write" << std::endl;
+ } else if (result == talk_base::SR_BLOCK) {
+ std::cout << "File blocked unexpectedly on write" << std::endl;
+ } else {
+ std::cout << "File write error: " << error << std::endl;
+ }
+ Cleanup(stream);
+ return;
+ }
+ }
+ }
+ }
+
+ void Cleanup(talk_base::StreamInterface* stream, bool delay = false) {
+ LOG(LS_VERBOSE) << "Closing";
+ stream->Close();
+ file_.reset();
+ if (!server_) {
+ if (delay)
+ talk_base::Thread::Current()->PostDelayed(2000, NULL, MSG_DONE);
+ else
+ talk_base::Thread::Current()->Post(NULL, MSG_DONE);
+ }
+ }
+
+private:
+ bool server_, sending_;
+ talk_base::scoped_ptr<talk_base::FileStream> file_;
+ char buffer_[1024 * 64];
+ size_t buffer_len_;
+};
+
+int main(int argc, char **argv) {
+ talk_base::LogMessage::LogThreads();
+ talk_base::LogMessage::LogTimestamps();
+
+ // TODO: Default the username to the current users's name.
+
+ // Parse the arguments.
+
+ int index = 1;
+ while (index < argc) {
+ std::string name, value;
+ if (!ParseArg(argv[index], &name, &value))
+ break;
+
+ if (name == "help") {
+ Usage();
+ } else if (name == "verbose") {
+ talk_base::LogMessage::LogToDebug(talk_base::LS_VERBOSE);
+ } else if (name == "xmpp-host") {
+ gXmppHost = value;
+ } else if (name == "xmpp-port") {
+ gXmppPort = ParseIntArg(name, value);
+ } else if (name == "xmpp-use-tls") {
+ gXmppUseTls = ParseBoolArg(name, value)?
+ buzz::TLS_REQUIRED : buzz::TLS_DISABLED;
+ } else {
+ Error(std::string("unknown option: ") + name);
+ }
+
+ index += 1;
+ }
+
+ if (index >= argc)
+ Error("bad arguments");
+ gUserJid = buzz::Jid(argv[index++]);
+ if (!gUserJid.IsValid())
+ Error("bad arguments");
+
+ char path[MAX_PATH];
+#if WIN32
+ GetCurrentDirectoryA(MAX_PATH, path);
+#else
+ if (NULL == getcwd(path, MAX_PATH))
+ Error("Unable to get current path");
+#endif
+
+ std::cout << "Directory: " << std::string(path) << std::endl;
+
+ buzz::Jid gSrcJid;
+ buzz::Jid gDstJid;
+ std::string gSrcFile;
+ std::string gDstFile;
+
+ bool as_server = true;
+ if (index + 2 == argc) {
+ ParseFileArg(argv[index], &gSrcJid, &gSrcFile);
+ ParseFileArg(argv[index+1], &gDstJid, &gDstFile);
+ if(gSrcJid.Str().empty() == gDstJid.Str().empty())
+ Error("Exactly one of source JID or destination JID must be empty.");
+ as_server = false;
+ } else if (index != argc) {
+ Error("bad arguments");
+ }
+
+ std::cout << "Password: ";
+ SetConsoleEcho(false);
+ std::cin >> gUserPass.password();
+ SetConsoleEcho(true);
+ std::cout << std::endl;
+
+ talk_base::InitializeSSL();
+ // Log in.
+ CustomXmppPump pump;
+ pump.client()->SignalLogInput.connect(&debug_log_, &DebugLog::Input);
+ pump.client()->SignalLogOutput.connect(&debug_log_, &DebugLog::Output);
+ pump.DoLogin(LoginSettings(), new XmppSocket(gXmppUseTls), 0);
+ //new XmppAuth());
+
+ // Wait until login succeeds.
+ std::vector<uint32> ids;
+ ids.push_back(MSG_LOGIN_COMPLETE);
+ ids.push_back(MSG_LOGIN_FAILED);
+ if (MSG_LOGIN_FAILED == Loop(ids))
+ FatalError("Failed to connect");
+
+ {
+ talk_base::scoped_ptr<buzz::XmlElement> presence(
+ new buzz::XmlElement(buzz::QN_PRESENCE));
+ presence->AddElement(new buzz::XmlElement(buzz::QN_PRIORITY));
+ presence->AddText("-1", 1);
+ pump.SendStanza(presence.get());
+ }
+
+ std::string user_jid_str = pump.client()->jid().Str();
+ std::cout << "Logged in as " << user_jid_str << std::endl;
+
+ // Prepare the random number generator.
+ talk_base::InitRandom(user_jid_str.c_str(), user_jid_str.size());
+
+ // Create the P2P session manager.
+ talk_base::BasicNetworkManager network_manager;
+ AutoPortAllocator allocator(&network_manager, "pcp_agent");
+ allocator.SetXmppClient(pump.client());
+ cricket::SessionManager session_manager(&allocator);
+#ifdef USE_SSL_TUNNEL
+ cricket::SecureTunnelSessionClient session_client(pump.client()->jid(),
+ &session_manager);
+ if (!session_client.GenerateIdentity())
+ FatalError("Failed to generate SSL identity");
+#else // !USE_SSL_TUNNEL
+ cricket::TunnelSessionClient session_client(pump.client()->jid(),
+ &session_manager);
+#endif // USE_SSL_TUNNEL
+ cricket::SessionManagerTask *receiver =
+ new cricket::SessionManagerTask(pump.client(), &session_manager);
+ receiver->EnableOutgoingMessages();
+ receiver->Start();
+
+ bool success = true;
+
+ // Establish the appropriate connection.
+ if (as_server) {
+ pump.Serve(&session_client);
+ } else {
+ talk_base::StreamInterface* stream = NULL;
+ std::string filename;
+ bool sending;
+ if (gSrcJid.Str().empty()) {
+ std::string message("recv:");
+ message.append(gDstFile);
+ stream = session_client.CreateTunnel(gDstJid, message);
+ filename = gSrcFile;
+ sending = true;
+ } else {
+ std::string message("send:");
+ message.append(gSrcFile);
+ stream = session_client.CreateTunnel(gSrcJid, message);
+ filename = gDstFile;
+ sending = false;
+ }
+ success = pump.ProcessStream(stream, filename, sending);
+ }
+
+ if (success) {
+ // Wait until the copy is done.
+ ids.clear();
+ ids.push_back(MSG_DONE);
+ ids.push_back(MSG_LOGIN_FAILED);
+ Loop(ids);
+ }
+
+ // Log out.
+ pump.DoDisconnect();
+
+ return 0;
+}
diff --git a/talk/examples/peerconnection/client/conductor.cc b/talk/examples/peerconnection/client/conductor.cc
new file mode 100644
index 0000000..3557f11
--- /dev/null
+++ b/talk/examples/peerconnection/client/conductor.cc
@@ -0,0 +1,399 @@
+/*
+ * 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/examples/peerconnection/client/conductor.h"
+
+#include <utility>
+
+#ifdef WEBRTC_RELATIVE_PATH
+#include "modules/video_capture/main/interface/video_capture_factory.h"
+#else
+#include "third_party/webrtc/files/include/video_capture_factory.h"
+#endif
+#include "talk/app/webrtc/peerconnection.h"
+#include "talk/examples/peerconnection/client/defaults.h"
+#include "talk/base/common.h"
+#include "talk/base/logging.h"
+#include "talk/p2p/client/basicportallocator.h"
+#include "talk/session/phone/videorendererfactory.h"
+
+Conductor::Conductor(PeerConnectionClient* client, MainWindow* main_wnd)
+ : peer_id_(-1),
+ client_(client),
+ main_wnd_(main_wnd) {
+ client_->RegisterObserver(this);
+ main_wnd->RegisterObserver(this);
+}
+
+Conductor::~Conductor() {
+ ASSERT(peer_connection_.get() == NULL);
+}
+
+bool Conductor::connection_active() const {
+ return peer_connection_.get() != NULL;
+}
+
+void Conductor::Close() {
+ client_->SignOut();
+ DeletePeerConnection();
+}
+
+bool Conductor::InitializePeerConnection() {
+ ASSERT(peer_connection_factory_.get() == NULL);
+ ASSERT(peer_connection_.get() == NULL);
+
+ peer_connection_factory_ = webrtc::CreatePeerConnectionFactory();
+
+ if (!peer_connection_factory_.get()) {
+ main_wnd_->MessageBox("Error",
+ "Failed to initialize PeerConnectionFactory", true);
+ DeletePeerConnection();
+ return false;
+ }
+
+ peer_connection_ = peer_connection_factory_->CreatePeerConnection(
+ GetPeerConnectionString(), this);
+
+ if (!peer_connection_.get()) {
+ main_wnd_->MessageBox("Error",
+ "CreatePeerConnection failed", true);
+ DeletePeerConnection();
+ }
+ return peer_connection_.get() != NULL;
+}
+
+void Conductor::DeletePeerConnection() {
+ peer_connection_ = NULL;
+ active_streams_.clear();
+ peer_connection_factory_ = NULL;
+ peer_id_ = -1;
+}
+
+void Conductor::EnsureStreamingUI() {
+ ASSERT(peer_connection_.get() != NULL);
+ if (main_wnd_->IsWindow()) {
+ if (main_wnd_->current_ui() != MainWindow::STREAMING)
+ main_wnd_->SwitchToStreamingUI();
+ }
+}
+
+//
+// PeerConnectionObserver implementation.
+//
+
+void Conductor::OnError() {
+ LOG(LS_ERROR) << __FUNCTION__;
+ main_wnd_->QueueUIThreadCallback(PEER_CONNECTION_ERROR, NULL);
+}
+
+void Conductor::OnSignalingMessage(const std::string& msg) {
+ LOG(INFO) << __FUNCTION__;
+
+ std::string* msg_copy = new std::string(msg);
+ main_wnd_->QueueUIThreadCallback(SEND_MESSAGE_TO_PEER, msg_copy);
+}
+
+// Called when a remote stream is added
+void Conductor::OnAddStream(webrtc::MediaStreamInterface* stream) {
+ LOG(INFO) << __FUNCTION__ << " " << stream->label();
+
+ stream->AddRef();
+ main_wnd_->QueueUIThreadCallback(NEW_STREAM_ADDED,
+ stream);
+}
+
+void Conductor::OnRemoveStream(webrtc::MediaStreamInterface* stream) {
+ LOG(INFO) << __FUNCTION__ << " " << stream->label();
+ stream->AddRef();
+ main_wnd_->QueueUIThreadCallback(STREAM_REMOVED,
+ stream);
+}
+
+//
+// PeerConnectionClientObserver implementation.
+//
+
+void Conductor::OnSignedIn() {
+ LOG(INFO) << __FUNCTION__;
+ main_wnd_->SwitchToPeerList(client_->peers());
+}
+
+void Conductor::OnDisconnected() {
+ LOG(INFO) << __FUNCTION__;
+
+ DeletePeerConnection();
+
+ if (main_wnd_->IsWindow())
+ main_wnd_->SwitchToConnectUI();
+}
+
+void Conductor::OnPeerConnected(int id, const std::string& name) {
+ LOG(INFO) << __FUNCTION__;
+ // Refresh the list if we're showing it.
+ if (main_wnd_->current_ui() == MainWindow::LIST_PEERS)
+ main_wnd_->SwitchToPeerList(client_->peers());
+}
+
+void Conductor::OnPeerDisconnected(int id) {
+ LOG(INFO) << __FUNCTION__;
+ if (id == peer_id_) {
+ LOG(INFO) << "Our peer disconnected";
+ main_wnd_->QueueUIThreadCallback(PEER_CONNECTION_CLOSED, NULL);
+ } else {
+ // Refresh the list if we're showing it.
+ if (main_wnd_->current_ui() == MainWindow::LIST_PEERS)
+ main_wnd_->SwitchToPeerList(client_->peers());
+ }
+}
+
+void Conductor::OnMessageFromPeer(int peer_id, const std::string& message) {
+ ASSERT(peer_id_ == peer_id || peer_id_ == -1);
+ ASSERT(!message.empty());
+
+ if (!peer_connection_.get()) {
+ ASSERT(peer_id_ == -1);
+ peer_id_ = peer_id;
+
+ // Got an offer. Give it to the PeerConnection instance.
+ // Once processed, we will get a callback to OnSignalingMessage with
+ // our 'answer' which we'll send to the peer.
+ LOG(INFO) << "Got an offer from our peer: " << peer_id;
+ if (!InitializePeerConnection()) {
+ LOG(LS_ERROR) << "Failed to initialize our PeerConnection instance";
+ client_->SignOut();
+ return;
+ }
+ } else if (peer_id != peer_id_) {
+ ASSERT(peer_id_ != -1);
+ LOG(WARNING) << "Received an offer from a peer while already in a "
+ "conversation with a different peer.";
+ return;
+ }
+
+ peer_connection_->ProcessSignalingMessage(message);
+}
+
+void Conductor::OnMessageSent(int err) {
+ // Process the next pending message if any.
+ main_wnd_->QueueUIThreadCallback(SEND_MESSAGE_TO_PEER, NULL);
+}
+
+//
+// MainWndCallback implementation.
+//
+
+bool Conductor::StartLogin(const std::string& server, int port) {
+ if (client_->is_connected())
+ return false;
+
+ if (!client_->Connect(server, port, GetPeerName())) {
+ main_wnd_->MessageBox("Error", ("Failed to connect to " + server).c_str(),
+ true);
+ return false;
+ }
+
+ return true;
+}
+
+void Conductor::DisconnectFromServer() {
+ if (client_->is_connected())
+ client_->SignOut();
+}
+
+void Conductor::ConnectToPeer(int peer_id) {
+ ASSERT(peer_id_ == -1);
+ ASSERT(peer_id != -1);
+
+ if (peer_connection_.get()) {
+ main_wnd_->MessageBox("Error",
+ "We only support connecting to one peer at a time", true);
+ return;
+ }
+
+ if (InitializePeerConnection()) {
+ peer_id_ = peer_id;
+ AddStreams();
+ } else {
+ main_wnd_->MessageBox("Error", "Failed to initialize PeerConnection", true);
+ }
+}
+
+talk_base::scoped_refptr<webrtc::VideoCaptureModule>
+Conductor::OpenVideoCaptureDevice() {
+ webrtc::VideoCaptureModule::DeviceInfo* device_info(
+ webrtc::VideoCaptureFactory::CreateDeviceInfo(0));
+ talk_base::scoped_refptr<webrtc::VideoCaptureModule> video_device;
+
+ const size_t kMaxDeviceNameLength = 128;
+ const size_t kMaxUniqueIdLength = 256;
+ uint8 device_name[kMaxDeviceNameLength];
+ uint8 unique_id[kMaxUniqueIdLength];
+
+ const size_t device_count = device_info->NumberOfDevices();
+ for (size_t i = 0; i < device_count; ++i) {
+ // Get the name of the video capture device.
+ device_info->GetDeviceName(i, device_name, kMaxDeviceNameLength, unique_id,
+ kMaxUniqueIdLength);
+ // Try to open this device.
+ video_device =
+ webrtc::VideoCaptureFactory::Create(0, unique_id);
+ if (video_device.get())
+ break;
+ }
+ delete device_info;
+ return video_device;
+}
+
+void Conductor::AddStreams() {
+ if (active_streams_.find(kStreamLabel) != active_streams_.end())
+ return; // Already added.
+
+ talk_base::scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
+ peer_connection_factory_->CreateLocalAudioTrack(kAudioLabel, NULL));
+
+ talk_base::scoped_refptr<webrtc::LocalVideoTrackInterface> video_track(
+ peer_connection_factory_->CreateLocalVideoTrack(
+ kVideoLabel, CreateVideoCapturer(OpenVideoCaptureDevice())));
+
+ video_track->SetRenderer(main_wnd_->local_renderer());
+
+ talk_base::scoped_refptr<webrtc::LocalMediaStreamInterface> stream =
+ peer_connection_factory_->CreateLocalMediaStream(kStreamLabel);
+
+ stream->AddTrack(audio_track);
+ stream->AddTrack(video_track);
+ peer_connection_->AddStream(stream);
+ peer_connection_->CommitStreamChanges();
+ typedef std::pair<std::string,
+ talk_base::scoped_refptr<webrtc::MediaStreamInterface> >
+ MediaStreamPair;
+ active_streams_.insert(MediaStreamPair(stream->label(), stream));
+ main_wnd_->SwitchToStreamingUI();
+}
+
+void Conductor::DisconnectFromCurrentPeer() {
+ LOG(INFO) << __FUNCTION__;
+ if (peer_connection_.get()) {
+ client_->SendHangUp(peer_id_);
+ DeletePeerConnection();
+ }
+
+ if (main_wnd_->IsWindow())
+ main_wnd_->SwitchToPeerList(client_->peers());
+}
+
+void Conductor::UIThreadCallback(int msg_id, void* data) {
+ switch (msg_id) {
+ case PEER_CONNECTION_CLOSED:
+ LOG(INFO) << "PEER_CONNECTION_CLOSED";
+ DeletePeerConnection();
+
+ ASSERT(active_streams_.empty());
+
+ if (main_wnd_->IsWindow()) {
+ if (client_->is_connected()) {
+ main_wnd_->SwitchToPeerList(client_->peers());
+ } else {
+ main_wnd_->SwitchToConnectUI();
+ }
+ } else {
+ DisconnectFromServer();
+ }
+ break;
+
+ case SEND_MESSAGE_TO_PEER: {
+ LOG(INFO) << "SEND_MESSAGE_TO_PEER";
+ std::string* msg = reinterpret_cast<std::string*>(data);
+ if (msg) {
+ // For convenience, we always run the message through the queue.
+ // This way we can be sure that messages are sent to the server
+ // in the same order they were signaled without much hassle.
+ pending_messages_.push_back(msg);
+ }
+
+ if (!pending_messages_.empty() && !client_->IsSendingMessage()) {
+ msg = pending_messages_.front();
+ pending_messages_.pop_front();
+
+ if (!client_->SendToPeer(peer_id_, *msg) && peer_id_ != -1) {
+ LOG(LS_ERROR) << "SendToPeer failed";
+ DisconnectFromServer();
+ }
+ delete msg;
+ }
+
+ if (!peer_connection_.get())
+ peer_id_ = -1;
+
+ break;
+ }
+
+ case PEER_CONNECTION_ADDSTREAMS:
+ AddStreams();
+ break;
+
+ case PEER_CONNECTION_ERROR:
+ main_wnd_->MessageBox("Error", "an unknown error occurred", true);
+ break;
+
+ case NEW_STREAM_ADDED: {
+ webrtc::MediaStreamInterface* stream =
+ reinterpret_cast<webrtc::MediaStreamInterface*>(
+ data);
+ talk_base::scoped_refptr<webrtc::VideoTracks> tracks =
+ stream->video_tracks();
+ for (size_t i = 0; i < tracks->count(); ++i) {
+ webrtc::VideoTrackInterface* track = tracks->at(i);
+ LOG(INFO) << "Setting video renderer for track: " << track->label();
+ track->SetRenderer(main_wnd_->remote_renderer());
+ }
+ // If we haven't shared any streams with this peer (we're the receiver)
+ // then do so now.
+ if (active_streams_.empty())
+ AddStreams();
+ stream->Release();
+ break;
+ }
+
+ case STREAM_REMOVED: {
+ webrtc::MediaStreamInterface* stream =
+ reinterpret_cast<webrtc::MediaStreamInterface*>(
+ data);
+ active_streams_.erase(stream->label());
+ stream->Release();
+ if (active_streams_.empty()) {
+ LOG(INFO) << "All streams have been closed.";
+ main_wnd_->QueueUIThreadCallback(PEER_CONNECTION_CLOSED, NULL);
+ }
+ break;
+ }
+
+ default:
+ ASSERT(false);
+ break;
+ }
+}
diff --git a/talk/examples/peerconnection/client/conductor.h b/talk/examples/peerconnection/client/conductor.h
new file mode 100644
index 0000000..4268d74
--- /dev/null
+++ b/talk/examples/peerconnection/client/conductor.h
@@ -0,0 +1,134 @@
+/*
+ * 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 PEERCONNECTION_SAMPLES_CLIENT_CONDUCTOR_H_
+#define PEERCONNECTION_SAMPLES_CLIENT_CONDUCTOR_H_
+#pragma once
+
+#include <deque>
+#include <map>
+#include <set>
+#include <string>
+
+#include "talk/examples/peerconnection/client/main_wnd.h"
+#include "talk/examples/peerconnection/client/peer_connection_client.h"
+#include "talk/app/webrtc/mediastream.h"
+#include "talk/app/webrtc/peerconnection.h"
+#include "talk/base/scoped_ptr.h"
+
+namespace webrtc {
+class VideoCaptureModule;
+} // namespace webrtc
+
+namespace cricket {
+class VideoRenderer;
+} // namespace cricket
+
+class Conductor
+ : public webrtc::PeerConnectionObserver,
+ public PeerConnectionClientObserver,
+ public MainWndCallback {
+ public:
+ enum CallbackID {
+ MEDIA_CHANNELS_INITIALIZED = 1,
+ PEER_CONNECTION_CLOSED,
+ SEND_MESSAGE_TO_PEER,
+ PEER_CONNECTION_ADDSTREAMS,
+ PEER_CONNECTION_ERROR,
+ NEW_STREAM_ADDED,
+ STREAM_REMOVED,
+ };
+
+ Conductor(PeerConnectionClient* client, MainWindow* main_wnd);
+ ~Conductor();
+
+ bool connection_active() const;
+
+ virtual void Close();
+
+ protected:
+ bool InitializePeerConnection();
+ void DeletePeerConnection();
+ void EnsureStreamingUI();
+ void AddStreams();
+ talk_base::scoped_refptr<webrtc::VideoCaptureModule> OpenVideoCaptureDevice();
+
+ //
+ // PeerConnectionObserver implementation.
+ //
+ virtual void OnError();
+ virtual void OnMessage(const std::string& msg) {}
+ virtual void OnSignalingMessage(const std::string& msg);
+ virtual void OnStateChange(
+ webrtc::PeerConnectionObserver::StateType state_changed) {}
+ virtual void OnAddStream(webrtc::MediaStreamInterface* stream);
+ virtual void OnRemoveStream(webrtc::MediaStreamInterface* stream);
+
+
+ //
+ // PeerConnectionClientObserver implementation.
+ //
+
+ virtual void OnSignedIn();
+
+ virtual void OnDisconnected();
+
+ virtual void OnPeerConnected(int id, const std::string& name);
+
+ virtual void OnPeerDisconnected(int id);
+
+ virtual void OnMessageFromPeer(int peer_id, const std::string& message);
+
+ virtual void OnMessageSent(int err);
+
+ //
+ // MainWndCallback implementation.
+ //
+
+ virtual bool StartLogin(const std::string& server, int port);
+
+ virtual void DisconnectFromServer();
+
+ virtual void ConnectToPeer(int peer_id);
+
+ virtual void DisconnectFromCurrentPeer();
+
+ virtual void UIThreadCallback(int msg_id, void* data);
+
+ protected:
+ int peer_id_;
+ talk_base::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
+ talk_base::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
+ peer_connection_factory_;
+ PeerConnectionClient* client_;
+ MainWindow* main_wnd_;
+ std::deque<std::string*> pending_messages_;
+ std::map<std::string, talk_base::scoped_refptr<webrtc::MediaStreamInterface> >
+ active_streams_;
+};
+
+#endif // PEERCONNECTION_SAMPLES_CLIENT_CONDUCTOR_H_
diff --git a/talk/examples/peerconnection/client/defaults.cc b/talk/examples/peerconnection/client/defaults.cc
new file mode 100644
index 0000000..eb895d0
--- /dev/null
+++ b/talk/examples/peerconnection/client/defaults.cc
@@ -0,0 +1,75 @@
+/*
+ * 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/examples/peerconnection/client/defaults.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef WIN32
+#include <winsock2.h>
+#else
+#include <unistd.h>
+#endif
+
+#include "talk/base/common.h"
+
+const char kAudioLabel[] = "audio_label";
+const char kVideoLabel[] = "video_label";
+const char kStreamLabel[] = "stream_label";
+const uint16 kDefaultServerPort = 8888;
+
+std::string GetEnvVarOrDefault(const char* env_var_name,
+ const char* default_value) {
+ std::string value;
+ const char* env_var = getenv(env_var_name);
+ if (env_var)
+ value = env_var;
+
+ if (value.empty())
+ value = default_value;
+
+ return value;
+}
+
+std::string GetPeerConnectionString() {
+ return GetEnvVarOrDefault("WEBRTC_CONNECT", "STUN stun.l.google.com:19302");
+}
+
+std::string GetDefaultServerName() {
+ return GetEnvVarOrDefault("WEBRTC_SERVER", "localhost");
+}
+
+std::string GetPeerName() {
+ char computer_name[256];
+ if (gethostname(computer_name, ARRAY_SIZE(computer_name)) != 0)
+ strcpy(computer_name, "host");
+ std::string ret(GetEnvVarOrDefault("USERNAME", "user"));
+ ret += '@';
+ ret += computer_name;
+ return ret;
+}
diff --git a/talk/examples/peerconnection/client/defaults.h b/talk/examples/peerconnection/client/defaults.h
new file mode 100644
index 0000000..f646149
--- /dev/null
+++ b/talk/examples/peerconnection/client/defaults.h
@@ -0,0 +1,47 @@
+/*
+ * 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 PEERCONNECTION_SAMPLES_CLIENT_DEFAULTS_H_
+#define PEERCONNECTION_SAMPLES_CLIENT_DEFAULTS_H_
+#pragma once
+
+#include <string>
+
+#include "talk/base/basictypes.h"
+
+extern const char kAudioLabel[];
+extern const char kVideoLabel[];
+extern const char kStreamLabel[];
+extern const uint16 kDefaultServerPort;
+
+std::string GetEnvVarOrDefault(const char* env_var_name,
+ const char* default_value);
+std::string GetPeerConnectionString();
+std::string GetDefaultServerName();
+std::string GetPeerName();
+
+#endif // PEERCONNECTION_SAMPLES_CLIENT_DEFAULTS_H_
diff --git a/talk/examples/peerconnection/client/linux/main.cc b/talk/examples/peerconnection/client/linux/main.cc
new file mode 100644
index 0000000..ab912ab
--- /dev/null
+++ b/talk/examples/peerconnection/client/linux/main.cc
@@ -0,0 +1,102 @@
+/*
+ * 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 <gtk/gtk.h>
+
+#include "talk/examples/peerconnection/client/conductor.h"
+#include "talk/examples/peerconnection/client/linux/main_wnd.h"
+#include "talk/examples/peerconnection/client/peer_connection_client.h"
+
+#include "talk/base/thread.h"
+
+class CustomSocketServer : public talk_base::PhysicalSocketServer {
+ public:
+ CustomSocketServer(talk_base::Thread* thread, GtkMainWnd* wnd)
+ : thread_(thread), wnd_(wnd), conductor_(NULL), client_(NULL) {}
+ virtual ~CustomSocketServer() {}
+
+ void set_client(PeerConnectionClient* client) { client_ = client; }
+ void set_conductor(Conductor* conductor) { conductor_ = conductor; }
+
+ // Override so that we can also pump the GTK message loop.
+ virtual bool Wait(int cms, bool process_io) {
+ // Pump GTK events.
+ // TODO: We really should move either the socket server or UI to a
+ // different thread. Alternatively we could look at merging the two loops
+ // by implementing a dispatcher for the socket server and/or use
+ // g_main_context_set_poll_func.
+ while (gtk_events_pending())
+ gtk_main_iteration();
+
+ if (!wnd_->IsWindow() && !conductor_->connection_active() &&
+ client_ != NULL && !client_->is_connected()) {
+ thread_->Quit();
+ }
+ return talk_base::PhysicalSocketServer::Wait(0/*cms == -1 ? 1 : cms*/,
+ process_io);
+ }
+
+ protected:
+ talk_base::Thread* thread_;
+ GtkMainWnd* wnd_;
+ Conductor* conductor_;
+ PeerConnectionClient* client_;
+};
+
+int main(int argc, char* argv[]) {
+ gtk_init(&argc, &argv);
+ g_type_init();
+ g_thread_init(NULL);
+
+ GtkMainWnd wnd;
+ wnd.Create();
+
+ talk_base::AutoThread auto_thread;
+ talk_base::Thread* thread = talk_base::Thread::Current();
+ CustomSocketServer socket_server(thread, &wnd);
+ thread->set_socketserver(&socket_server);
+
+ // Must be constructed after we set the socketserver.
+ PeerConnectionClient client;
+ Conductor conductor(&client, &wnd);
+ socket_server.set_client(&client);
+ socket_server.set_conductor(&conductor);
+
+ thread->Run();
+
+ // gtk_main();
+ wnd.Destroy();
+
+ thread->set_socketserver(NULL);
+ // TODO: Run the Gtk main loop to tear down the connection.
+ //while (gtk_events_pending()) {
+ // gtk_main_iteration();
+ //}
+
+ return 0;
+}
+
diff --git a/talk/examples/peerconnection/client/linux/main_wnd.cc b/talk/examples/peerconnection/client/linux/main_wnd.cc
new file mode 100644
index 0000000..3335985
--- /dev/null
+++ b/talk/examples/peerconnection/client/linux/main_wnd.cc
@@ -0,0 +1,482 @@
+/*
+ * 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/examples/peerconnection/client/linux/main_wnd.h"
+
+#include <gdk/gdkkeysyms.h>
+#include <gtk/gtk.h>
+#include <stddef.h>
+
+#include "talk/examples/peerconnection/client/defaults.h"
+#include "talk/base/common.h"
+#include "talk/base/logging.h"
+#include "talk/base/stringutils.h"
+
+using talk_base::sprintfn;
+
+namespace {
+
+//
+// Simple static functions that simply forward the callback to the
+// GtkMainWnd instance.
+//
+
+gboolean OnDestroyedCallback(GtkWidget* widget, GdkEvent* event,
+ gpointer data) {
+ reinterpret_cast<GtkMainWnd*>(data)->OnDestroyed(widget, event);
+ return FALSE;
+}
+
+void OnClickedCallback(GtkWidget* widget, gpointer data) {
+ reinterpret_cast<GtkMainWnd*>(data)->OnClicked(widget);
+}
+
+gboolean OnKeyPressCallback(GtkWidget* widget, GdkEventKey* key,
+ gpointer data) {
+ reinterpret_cast<GtkMainWnd*>(data)->OnKeyPress(widget, key);
+ return false;
+}
+
+void OnRowActivatedCallback(GtkTreeView* tree_view, GtkTreePath* path,
+ GtkTreeViewColumn* column, gpointer data) {
+ reinterpret_cast<GtkMainWnd*>(data)->OnRowActivated(tree_view, path, column);
+}
+
+// Creates a tree view, that we use to display the list of peers.
+void InitializeList(GtkWidget* list) {
+ GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
+ GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(
+ "List Items", renderer, "text", 0, NULL);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
+ GtkListStore* store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
+ gtk_tree_view_set_model(GTK_TREE_VIEW(list), GTK_TREE_MODEL(store));
+ g_object_unref(store);
+}
+
+// Adds an entry to a tree view.
+void AddToList(GtkWidget* list, const gchar* str, int value) {
+ GtkListStore* store = GTK_LIST_STORE(
+ gtk_tree_view_get_model(GTK_TREE_VIEW(list)));
+
+ GtkTreeIter iter;
+ gtk_list_store_append(store, &iter);
+ gtk_list_store_set(store, &iter, 0, str, 1, value, -1);
+}
+
+struct UIThreadCallbackData {
+ explicit UIThreadCallbackData(MainWndCallback* cb, int id, void* d)
+ : callback(cb), msg_id(id), data(d) {}
+ MainWndCallback* callback;
+ int msg_id;
+ void* data;
+};
+
+gboolean HandleUIThreadCallback(gpointer data) {
+ UIThreadCallbackData* cb_data = reinterpret_cast<UIThreadCallbackData*>(data);
+ cb_data->callback->UIThreadCallback(cb_data->msg_id, cb_data->data);
+ delete cb_data;
+ return false;
+}
+
+gboolean Redraw(gpointer data) {
+ GtkMainWnd* wnd = reinterpret_cast<GtkMainWnd*>(data);
+ wnd->OnRedraw();
+ return false;
+}
+} // end anonymous
+
+//
+// GtkMainWnd implementation.
+//
+
+GtkMainWnd::GtkMainWnd()
+ : window_(NULL), draw_area_(NULL), vbox_(NULL), server_edit_(NULL),
+ port_edit_(NULL), peer_list_(NULL), callback_(NULL),
+ server_("localhost") {
+ char buffer[10];
+ sprintfn(buffer, sizeof(buffer), "%i", kDefaultServerPort);
+ port_ = buffer;
+}
+
+GtkMainWnd::~GtkMainWnd() {
+ ASSERT(!IsWindow());
+}
+
+void GtkMainWnd::RegisterObserver(MainWndCallback* callback) {
+ callback_ = callback;
+}
+
+bool GtkMainWnd::IsWindow() {
+ return window_ != NULL && GTK_IS_WINDOW(window_);
+}
+
+void GtkMainWnd::MessageBox(const char* caption, const char* text,
+ bool is_error) {
+ GtkWidget* dialog = gtk_message_dialog_new(GTK_WINDOW(window_),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ is_error ? GTK_MESSAGE_ERROR : GTK_MESSAGE_INFO,
+ GTK_BUTTONS_CLOSE, "%s", text);
+ gtk_window_set_title(GTK_WINDOW(dialog), caption);
+ gtk_dialog_run(GTK_DIALOG(dialog));
+ gtk_widget_destroy(dialog);
+}
+
+MainWindow::UI GtkMainWnd::current_ui() {
+ if (vbox_)
+ return CONNECT_TO_SERVER;
+
+ if (peer_list_)
+ return LIST_PEERS;
+
+ return STREAMING;
+}
+
+webrtc::VideoRendererWrapperInterface* GtkMainWnd::local_renderer() {
+ if (!local_renderer_wrapper_.get())
+ local_renderer_wrapper_ =
+ webrtc::CreateVideoRenderer(new VideoRenderer(this));
+ return local_renderer_wrapper_.get();
+}
+
+webrtc::VideoRendererWrapperInterface* GtkMainWnd::remote_renderer() {
+ if (!remote_renderer_wrapper_.get())
+ remote_renderer_wrapper_ =
+ webrtc::CreateVideoRenderer(new VideoRenderer(this));
+ return remote_renderer_wrapper_.get();
+}
+
+void GtkMainWnd::QueueUIThreadCallback(int msg_id, void* data) {
+ g_idle_add(HandleUIThreadCallback,
+ new UIThreadCallbackData(callback_, msg_id, data));
+}
+
+bool GtkMainWnd::Create() {
+ ASSERT(window_ == NULL);
+
+ window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ if (window_) {
+ gtk_window_set_position(GTK_WINDOW(window_), GTK_WIN_POS_CENTER);
+ gtk_window_set_default_size(GTK_WINDOW(window_), 640, 480);
+ gtk_window_set_title(GTK_WINDOW(window_), "PeerConnection client");
+ g_signal_connect(G_OBJECT(window_), "delete-event",
+ G_CALLBACK(&OnDestroyedCallback), this);
+ g_signal_connect(window_, "key-press-event", G_CALLBACK(OnKeyPressCallback),
+ this);
+
+ SwitchToConnectUI();
+ }
+
+ return window_ != NULL;
+}
+
+bool GtkMainWnd::Destroy() {
+ if (!IsWindow())
+ return false;
+
+ gtk_widget_destroy(window_);
+ window_ = NULL;
+
+ return true;
+}
+
+void GtkMainWnd::SwitchToConnectUI() {
+ LOG(INFO) << __FUNCTION__;
+
+ ASSERT(IsWindow());
+ ASSERT(vbox_ == NULL);
+
+ gtk_container_set_border_width(GTK_CONTAINER(window_), 10);
+
+ if (peer_list_) {
+ gtk_widget_destroy(peer_list_);
+ peer_list_ = NULL;
+ }
+
+ vbox_ = gtk_vbox_new(FALSE, 5);
+ GtkWidget* valign = gtk_alignment_new(0, 1, 0, 0);
+ gtk_container_add(GTK_CONTAINER(vbox_), valign);
+ gtk_container_add(GTK_CONTAINER(window_), vbox_);
+
+ GtkWidget* hbox = gtk_hbox_new(FALSE, 5);
+
+ GtkWidget* label = gtk_label_new("Server");
+ gtk_container_add(GTK_CONTAINER(hbox), label);
+
+ server_edit_ = gtk_entry_new();
+ gtk_entry_set_text(GTK_ENTRY(server_edit_), server_.c_str());
+ gtk_widget_set_size_request(server_edit_, 400, 30);
+ gtk_container_add(GTK_CONTAINER(hbox), server_edit_);
+
+ port_edit_ = gtk_entry_new();
+ gtk_entry_set_text(GTK_ENTRY(port_edit_), port_.c_str());
+ gtk_widget_set_size_request(port_edit_, 70, 30);
+ gtk_container_add(GTK_CONTAINER(hbox), port_edit_);
+
+ GtkWidget* button = gtk_button_new_with_label("Connect");
+ gtk_widget_set_size_request(button, 70, 30);
+ g_signal_connect(button, "clicked", G_CALLBACK(OnClickedCallback), this);
+ gtk_container_add(GTK_CONTAINER(hbox), button);
+
+ GtkWidget* halign = gtk_alignment_new(1, 0, 0, 0);
+ gtk_container_add(GTK_CONTAINER(halign), hbox);
+ gtk_box_pack_start(GTK_BOX(vbox_), halign, FALSE, FALSE, 0);
+
+ gtk_widget_show_all(window_);
+}
+
+void GtkMainWnd::SwitchToPeerList(const Peers& peers) {
+ LOG(INFO) << __FUNCTION__;
+
+ // Clean up buffers from a potential previous session.
+ local_renderer_wrapper_ = NULL;
+ remote_renderer_wrapper_ = NULL;
+
+ if (!peer_list_) {
+ gtk_container_set_border_width(GTK_CONTAINER(window_), 0);
+ if (vbox_) {
+ gtk_widget_destroy(vbox_);
+ vbox_ = NULL;
+ server_edit_ = NULL;
+ port_edit_ = NULL;
+ } else if (draw_area_) {
+ gtk_widget_destroy(draw_area_);
+ draw_area_ = NULL;
+ draw_buffer_.reset();
+ }
+
+ peer_list_ = gtk_tree_view_new();
+ g_signal_connect(peer_list_, "row-activated",
+ G_CALLBACK(OnRowActivatedCallback), this);
+ gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(peer_list_), FALSE);
+ InitializeList(peer_list_);
+ gtk_container_add(GTK_CONTAINER(window_), peer_list_);
+ gtk_widget_show_all(window_);
+ } else {
+ GtkListStore* store =
+ GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(peer_list_)));
+ gtk_list_store_clear(store);
+ }
+
+ AddToList(peer_list_, "List of currently connected peers:", -1);
+ for (Peers::const_iterator i = peers.begin(); i != peers.end(); ++i)
+ AddToList(peer_list_, i->second.c_str(), i->first);
+}
+
+void GtkMainWnd::SwitchToStreamingUI() {
+ LOG(INFO) << __FUNCTION__;
+
+ ASSERT(draw_area_ == NULL);
+
+ gtk_container_set_border_width(GTK_CONTAINER(window_), 0);
+ if (peer_list_) {
+ gtk_widget_destroy(peer_list_);
+ peer_list_ = NULL;
+ }
+
+ draw_area_ = gtk_drawing_area_new();
+ gtk_container_add(GTK_CONTAINER(window_), draw_area_);
+
+ gtk_widget_show_all(window_);
+}
+
+void GtkMainWnd::OnDestroyed(GtkWidget* widget, GdkEvent* event) {
+ callback_->Close();
+ window_ = NULL;
+ draw_area_ = NULL;
+ vbox_ = NULL;
+ server_edit_ = NULL;
+ port_edit_ = NULL;
+ peer_list_ = NULL;
+}
+
+void GtkMainWnd::OnClicked(GtkWidget* widget) {
+ server_ = gtk_entry_get_text(GTK_ENTRY(server_edit_));
+ port_ = gtk_entry_get_text(GTK_ENTRY(port_edit_));
+ int port = port_.length() ? atoi(port_.c_str()) : 0;
+ callback_->StartLogin(server_, port);
+}
+
+void GtkMainWnd::OnKeyPress(GtkWidget* widget, GdkEventKey* key) {
+ if (key->type == GDK_KEY_PRESS) {
+ switch (key->keyval) {
+ case GDK_Escape:
+ if (draw_area_) {
+ callback_->DisconnectFromCurrentPeer();
+ } else if (peer_list_) {
+ callback_->DisconnectFromServer();
+ }
+ break;
+
+ case GDK_KP_Enter:
+ case GDK_Return:
+ if (vbox_) {
+ OnClicked(NULL);
+ } else if (peer_list_) {
+ // OnRowActivated will be called automatically when the user
+ // presses enter.
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+}
+
+void GtkMainWnd::OnRowActivated(GtkTreeView* tree_view, GtkTreePath* path,
+ GtkTreeViewColumn* column) {
+ ASSERT(peer_list_ != NULL);
+ GtkTreeIter iter;
+ GtkTreeModel* model;
+ GtkTreeSelection* selection =
+ gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
+ if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
+ char* text;
+ int id = -1;
+ gtk_tree_model_get(model, &iter, 0, &text, 1, &id, -1);
+ if (id != -1)
+ callback_->ConnectToPeer(id);
+ g_free(text);
+ }
+}
+
+void GtkMainWnd::OnRedraw() {
+ gdk_threads_enter();
+
+ VideoRenderer* remote_renderer =
+ static_cast<VideoRenderer*>(remote_renderer_wrapper_->renderer());
+ if (remote_renderer && remote_renderer->image() != NULL &&
+ draw_area_ != NULL) {
+ int width = remote_renderer->width();
+ int height = remote_renderer->height();
+
+ if (!draw_buffer_.get()) {
+ draw_buffer_size_ = (width * height * 4) * 4;
+ draw_buffer_.reset(new uint8[draw_buffer_size_]);
+ gtk_widget_set_size_request(draw_area_, width * 2, height * 2);
+ }
+
+ const uint32* image = reinterpret_cast<const uint32*>(
+ remote_renderer->image());
+ uint32* scaled = reinterpret_cast<uint32*>(draw_buffer_.get());
+ for (int r = 0; r < height; ++r) {
+ for (int c = 0; c < width; ++c) {
+ int x = c * 2;
+ scaled[x] = scaled[x + 1] = image[c];
+ }
+
+ uint32* prev_line = scaled;
+ scaled += width * 2;
+ memcpy(scaled, prev_line, (width * 2) * 4);
+
+ image += width;
+ scaled += width * 2;
+ }
+
+ VideoRenderer* local_renderer =
+ static_cast<VideoRenderer*>(local_renderer_wrapper_->renderer());
+ if (local_renderer && local_renderer->image()) {
+ image = reinterpret_cast<const uint32*>(local_renderer->image());
+ scaled = reinterpret_cast<uint32*>(draw_buffer_.get());
+ // Position the local preview on the right side.
+ scaled += (width * 2) - (local_renderer->width() / 2);
+ // right margin...
+ scaled -= 10;
+ // ... towards the bottom.
+ scaled += (height * width * 4) -
+ ((local_renderer->height() / 2) *
+ (local_renderer->width() / 2) * 4);
+ // bottom margin...
+ scaled -= (width * 2) * 5;
+ for (int r = 0; r < local_renderer->height(); r += 2) {
+ for (int c = 0; c < local_renderer->width(); c += 2) {
+ scaled[c / 2] = image[c + r * local_renderer->width()];
+ }
+ scaled += width * 2;
+ }
+ }
+
+ gdk_draw_rgb_32_image(draw_area_->window,
+ draw_area_->style->fg_gc[GTK_STATE_NORMAL],
+ 0,
+ 0,
+ width * 2,
+ height * 2,
+ GDK_RGB_DITHER_MAX,
+ draw_buffer_.get(),
+ (width * 2) * 4);
+ }
+
+ gdk_threads_leave();
+}
+
+GtkMainWnd::VideoRenderer::VideoRenderer(GtkMainWnd* main_wnd)
+ : width_(0), height_(0), main_wnd_(main_wnd) {
+}
+
+GtkMainWnd::VideoRenderer::~VideoRenderer() {
+}
+
+bool GtkMainWnd::VideoRenderer::SetSize(int width, int height, int reserved) {
+ gdk_threads_enter();
+ width_ = width;
+ height_ = height;
+ image_.reset(new uint8[width * height * 4]);
+ gdk_threads_leave();
+ return true;
+}
+
+bool GtkMainWnd::VideoRenderer::RenderFrame(const cricket::VideoFrame* frame) {
+ gdk_threads_enter();
+
+ int size = width_ * height_ * 4;
+ // TODO: Convert directly to RGBA
+ frame->ConvertToRgbBuffer(cricket::FOURCC_ARGB,
+ image_.get(),
+ size,
+ width_ * 4);
+ // Convert the B,G,R,A frame to R,G,B,A, which is accepted by GTK.
+ // The 'A' is just padding for GTK, so we can use it as temp.
+ uint8* pix = image_.get();
+ uint8* end = image_.get() + size;
+ while (pix < end) {
+ pix[3] = pix[0]; // Save B to A.
+ pix[0] = pix[2]; // Set Red.
+ pix[2] = pix[3]; // Set Blue.
+ pix[3] = 0xFF; // Fixed Alpha.
+ pix += 4;
+ }
+
+ gdk_threads_leave();
+
+ g_idle_add(Redraw, main_wnd_);
+
+ return true;
+}
+
+
diff --git a/talk/examples/peerconnection/client/linux/main_wnd.h b/talk/examples/peerconnection/client/linux/main_wnd.h
new file mode 100644
index 0000000..c0f020a
--- /dev/null
+++ b/talk/examples/peerconnection/client/linux/main_wnd.h
@@ -0,0 +1,134 @@
+/*
+ * 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 PEERCONNECTION_SAMPLES_CLIENT_LINUX_MAIN_WND_H_
+#define PEERCONNECTION_SAMPLES_CLIENT_LINUX_MAIN_WND_H_
+
+#include "talk/examples/peerconnection/client/main_wnd.h"
+#include "talk/examples/peerconnection/client/peer_connection_client.h"
+
+// Forward declarations.
+typedef struct _GtkWidget GtkWidget;
+typedef union _GdkEvent GdkEvent;
+typedef struct _GdkEventKey GdkEventKey;
+typedef struct _GtkTreeView GtkTreeView;
+typedef struct _GtkTreePath GtkTreePath;
+typedef struct _GtkTreeViewColumn GtkTreeViewColumn;
+
+// Implements the main UI of the peer connection client.
+// This is functionally equivalent to the MainWnd class in the Windows
+// implementation.
+class GtkMainWnd : public MainWindow {
+ public:
+ GtkMainWnd();
+ ~GtkMainWnd();
+
+ virtual void RegisterObserver(MainWndCallback* callback);
+ virtual bool IsWindow();
+ virtual void SwitchToConnectUI();
+ virtual void SwitchToPeerList(const Peers& peers);
+ virtual void SwitchToStreamingUI();
+ virtual void MessageBox(const char* caption, const char* text,
+ bool is_error);
+ virtual MainWindow::UI current_ui();
+ virtual webrtc::VideoRendererWrapperInterface* local_renderer();
+ virtual webrtc::VideoRendererWrapperInterface* remote_renderer();
+
+ virtual void QueueUIThreadCallback(int msg_id, void* data);
+
+ // Creates and shows the main window with the |Connect UI| enabled.
+ bool Create();
+
+ // Destroys the window. When the window is destroyed, it ends the
+ // main message loop.
+ bool Destroy();
+
+ // Callback for when the main window is destroyed.
+ void OnDestroyed(GtkWidget* widget, GdkEvent* event);
+
+ // Callback for when the user clicks the "Connect" button.
+ void OnClicked(GtkWidget* widget);
+
+ // Callback for keystrokes. Used to capture Esc and Return.
+ void OnKeyPress(GtkWidget* widget, GdkEventKey* key);
+
+ // Callback when the user double clicks a peer in order to initiate a
+ // connection.
+ void OnRowActivated(GtkTreeView* tree_view, GtkTreePath* path,
+ GtkTreeViewColumn* column);
+
+ void OnRedraw();
+
+ protected:
+ class VideoRenderer : public cricket::VideoRenderer {
+ public:
+ explicit VideoRenderer(GtkMainWnd* main_wnd);
+ virtual ~VideoRenderer();
+
+ virtual bool SetSize(int width, int height, int reserved);
+
+ virtual bool RenderFrame(const cricket::VideoFrame* frame);
+
+ const uint8* image() const {
+ return image_.get();
+ }
+
+ int width() const {
+ return width_;
+ }
+
+ int height() const {
+ return height_;
+ }
+
+ protected:
+ talk_base::scoped_array<uint8> image_;
+ int width_;
+ int height_;
+ GtkMainWnd* main_wnd_;
+ };
+
+ protected:
+ GtkWidget* window_; // Our main window.
+ GtkWidget* draw_area_; // The drawing surface for rendering video streams.
+ GtkWidget* vbox_; // Container for the Connect UI.
+ GtkWidget* server_edit_;
+ GtkWidget* port_edit_;
+ GtkWidget* peer_list_; // The list of peers.
+ MainWndCallback* callback_;
+ std::string server_;
+ std::string port_;
+ talk_base::scoped_refptr<webrtc::VideoRendererWrapperInterface>
+ local_renderer_wrapper_;
+ talk_base::scoped_refptr<webrtc::VideoRendererWrapperInterface>
+ remote_renderer_wrapper_;
+ talk_base::scoped_ptr<uint8> draw_buffer_;
+ int draw_buffer_size_;
+};
+
+#endif // PEERCONNECTION_SAMPLES_CLIENT_LINUX_MAIN_WND_H_
diff --git a/talk/examples/peerconnection/client/main.cc b/talk/examples/peerconnection/client/main.cc
new file mode 100644
index 0000000..8d2bdc9
--- /dev/null
+++ b/talk/examples/peerconnection/client/main.cc
@@ -0,0 +1,68 @@
+/*
+ * 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/examples/peerconnection/client/conductor.h"
+#include "talk/examples/peerconnection/client/main_wnd.h"
+#include "talk/examples/peerconnection/client/peer_connection_client.h"
+#include "talk/base/win32socketinit.h"
+
+
+int PASCAL wWinMain(HINSTANCE instance, HINSTANCE prev_instance,
+ wchar_t* cmd_line, int cmd_show) {
+ talk_base::EnsureWinsockInit();
+
+ MainWnd wnd;
+ if (!wnd.Create()) {
+ ASSERT(false);
+ return -1;
+ }
+
+ PeerConnectionClient client;
+ Conductor conductor(&client, &wnd);
+
+ // Main loop.
+ MSG msg;
+ BOOL gm;
+ while ((gm = ::GetMessage(&msg, NULL, 0, 0)) != 0 && gm != -1) {
+ if (!wnd.PreTranslateMessage(&msg)) {
+ ::TranslateMessage(&msg);
+ ::DispatchMessage(&msg);
+ }
+ }
+
+ if (conductor.connection_active() || client.is_connected()) {
+ while ((conductor.connection_active() || client.is_connected()) &&
+ (gm = ::GetMessage(&msg, NULL, 0, 0)) != 0 && gm != -1) {
+ if (!wnd.PreTranslateMessage(&msg)) {
+ ::TranslateMessage(&msg);
+ ::DispatchMessage(&msg);
+ }
+ }
+ }
+
+ return 0;
+}
diff --git a/talk/examples/peerconnection/client/main_wnd.cc b/talk/examples/peerconnection/client/main_wnd.cc
new file mode 100644
index 0000000..367922e
--- /dev/null
+++ b/talk/examples/peerconnection/client/main_wnd.cc
@@ -0,0 +1,610 @@
+/*
+ * 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/examples/peerconnection/client/main_wnd.h"
+
+#include <math.h>
+
+#include "talk/base/common.h"
+#include "talk/base/logging.h"
+#include "talk/examples/peerconnection/client/defaults.h"
+
+ATOM MainWnd::wnd_class_ = 0;
+const wchar_t MainWnd::kClassName[] = L"WebRTC_MainWnd";
+
+namespace {
+
+const char kConnecting[] = "Connecting... ";
+const char kNoVideoStreams[] = "(no video streams either way)";
+const char kNoIncomingStream[] = "(no incoming video)";
+
+void CalculateWindowSizeForText(HWND wnd, const wchar_t* text,
+ size_t* width, size_t* height) {
+ HDC dc = ::GetDC(wnd);
+ RECT text_rc = {0};
+ ::DrawText(dc, text, -1, &text_rc, DT_CALCRECT | DT_SINGLELINE);
+ ::ReleaseDC(wnd, dc);
+ RECT client, window;
+ ::GetClientRect(wnd, &client);
+ ::GetWindowRect(wnd, &window);
+
+ *width = text_rc.right - text_rc.left;
+ *width += (window.right - window.left) -
+ (client.right - client.left);
+ *height = text_rc.bottom - text_rc.top;
+ *height += (window.bottom - window.top) -
+ (client.bottom - client.top);
+}
+
+HFONT GetDefaultFont() {
+ static HFONT font = reinterpret_cast<HFONT>(GetStockObject(DEFAULT_GUI_FONT));
+ return font;
+}
+
+std::string GetWindowText(HWND wnd) {
+ char text[MAX_PATH] = {0};
+ ::GetWindowTextA(wnd, &text[0], ARRAYSIZE(text));
+ return text;
+}
+
+void AddListBoxItem(HWND listbox, const std::string& str, LPARAM item_data) {
+ LRESULT index = ::SendMessageA(listbox, LB_ADDSTRING, 0,
+ reinterpret_cast<LPARAM>(str.c_str()));
+ ::SendMessageA(listbox, LB_SETITEMDATA, index, item_data);
+}
+
+} // namespace
+
+MainWnd::MainWnd()
+ : ui_(CONNECT_TO_SERVER), wnd_(NULL), edit1_(NULL), edit2_(NULL),
+ label1_(NULL), label2_(NULL), button_(NULL), listbox_(NULL),
+ destroyed_(false), callback_(NULL), nested_msg_(NULL) {
+}
+
+MainWnd::~MainWnd() {
+ ASSERT(!IsWindow());
+}
+
+bool MainWnd::Create() {
+ ASSERT(wnd_ == NULL);
+ if (!RegisterWindowClass())
+ return false;
+
+ ui_thread_id_ = ::GetCurrentThreadId();
+ wnd_ = ::CreateWindowExW(WS_EX_OVERLAPPEDWINDOW, kClassName, L"WebRTC",
+ WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CLIPCHILDREN,
+ CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
+ NULL, NULL, GetModuleHandle(NULL), this);
+
+ ::SendMessage(wnd_, WM_SETFONT, reinterpret_cast<WPARAM>(GetDefaultFont()),
+ TRUE);
+
+ CreateChildWindows();
+ SwitchToConnectUI();
+
+ return wnd_ != NULL;
+}
+
+bool MainWnd::Destroy() {
+ BOOL ret = FALSE;
+ if (IsWindow()) {
+ ret = ::DestroyWindow(wnd_);
+ }
+
+ return ret != FALSE;
+}
+
+void MainWnd::RegisterObserver(MainWndCallback* callback) {
+ callback_ = callback;
+}
+
+bool MainWnd::IsWindow() {
+ return wnd_ && ::IsWindow(wnd_) != FALSE;
+}
+
+bool MainWnd::PreTranslateMessage(MSG* msg) {
+ bool ret = false;
+ if (msg->message == WM_CHAR) {
+ if (msg->wParam == VK_TAB) {
+ HandleTabbing();
+ ret = true;
+ } else if (msg->wParam == VK_RETURN) {
+ OnDefaultAction();
+ ret = true;
+ } else if (msg->wParam == VK_ESCAPE) {
+ if (callback_) {
+ if (ui_ == STREAMING) {
+ callback_->DisconnectFromCurrentPeer();
+ } else {
+ callback_->DisconnectFromServer();
+ }
+ }
+ }
+ } else if (msg->hwnd == NULL && msg->message == UI_THREAD_CALLBACK) {
+ callback_->UIThreadCallback(static_cast<int>(msg->wParam),
+ reinterpret_cast<void*>(msg->lParam));
+ ret = true;
+ }
+ return ret;
+}
+
+void MainWnd::SwitchToConnectUI() {
+ ASSERT(IsWindow());
+ LayoutPeerListUI(false);
+ ui_ = CONNECT_TO_SERVER;
+ LayoutConnectUI(true);
+ ::SetFocus(edit1_);
+}
+
+void MainWnd::SwitchToPeerList(const Peers& peers) {
+ // Clean up buffers from a potential previous session.
+ local_renderer_wrapper_ = NULL;
+ remote_renderer_wrapper_ = NULL;
+
+ LayoutConnectUI(false);
+
+ ::SendMessage(listbox_, LB_RESETCONTENT, 0, 0);
+
+ AddListBoxItem(listbox_, "List of currently connected peers:", -1);
+ Peers::const_iterator i = peers.begin();
+ for (; i != peers.end(); ++i)
+ AddListBoxItem(listbox_, i->second.c_str(), i->first);
+
+ ui_ = LIST_PEERS;
+ LayoutPeerListUI(true);
+ ::SetFocus(listbox_);
+}
+
+void MainWnd::SwitchToStreamingUI() {
+ LayoutConnectUI(false);
+ LayoutPeerListUI(false);
+ ui_ = STREAMING;
+}
+
+void MainWnd::MessageBox(const char* caption, const char* text, bool is_error) {
+ DWORD flags = MB_OK;
+ if (is_error)
+ flags |= MB_ICONERROR;
+
+ ::MessageBoxA(handle(), text, caption, flags);
+}
+
+webrtc::VideoRendererWrapperInterface* MainWnd::local_renderer() {
+ if (!local_renderer_wrapper_.get())
+ local_renderer_wrapper_ =
+ webrtc::CreateVideoRenderer(new VideoRenderer(handle(), 1, 1));
+ return local_renderer_wrapper_.get();
+}
+
+webrtc::VideoRendererWrapperInterface* MainWnd::remote_renderer() {
+ if (!remote_renderer_wrapper_.get())
+ remote_renderer_wrapper_ =
+ webrtc::CreateVideoRenderer(new VideoRenderer(handle(), 1, 1));
+ return remote_renderer_wrapper_.get();
+}
+
+void MainWnd::QueueUIThreadCallback(int msg_id, void* data) {
+ ::PostThreadMessage(ui_thread_id_, UI_THREAD_CALLBACK,
+ static_cast<WPARAM>(msg_id), reinterpret_cast<LPARAM>(data));
+}
+
+void MainWnd::OnPaint() {
+ PAINTSTRUCT ps;
+ ::BeginPaint(handle(), &ps);
+
+ RECT rc;
+ ::GetClientRect(handle(), &rc);
+
+ webrtc::VideoRendererWrapperInterface* renderer_wrapper = local_renderer();
+ VideoRenderer* local_renderer = renderer_wrapper ?
+ static_cast<VideoRenderer*>(renderer_wrapper->renderer()) : NULL;
+ renderer_wrapper = remote_renderer();
+ VideoRenderer* remote_renderer = renderer_wrapper ?
+ static_cast<VideoRenderer*>(renderer_wrapper->renderer()) : NULL;
+ if (ui_ == STREAMING && remote_renderer && local_renderer) {
+ AutoLock<VideoRenderer> local_lock(local_renderer);
+ AutoLock<VideoRenderer> remote_lock(remote_renderer);
+
+ const BITMAPINFO& bmi = remote_renderer->bmi();
+ int height = abs(bmi.bmiHeader.biHeight);
+ int width = bmi.bmiHeader.biWidth;
+
+ const uint8* image = remote_renderer->image();
+ if (image != NULL) {
+ HDC dc_mem = ::CreateCompatibleDC(ps.hdc);
+ ::SetStretchBltMode(dc_mem, HALFTONE);
+
+ // Set the map mode so that the ratio will be maintained for us.
+ HDC all_dc[] = { ps.hdc, dc_mem };
+ for (int i = 0; i < ARRAY_SIZE(all_dc); ++i) {
+ SetMapMode(all_dc[i], MM_ISOTROPIC);
+ SetWindowExtEx(all_dc[i], width, height, NULL);
+ SetViewportExtEx(all_dc[i], rc.right, rc.bottom, NULL);
+ }
+
+ HBITMAP bmp_mem = ::CreateCompatibleBitmap(ps.hdc, rc.right, rc.bottom);
+ HGDIOBJ bmp_old = ::SelectObject(dc_mem, bmp_mem);
+
+ POINT logical_area = { rc.right, rc.bottom };
+ DPtoLP(ps.hdc, &logical_area, 1);
+
+ HBRUSH brush = ::CreateSolidBrush(RGB(0, 0, 0));
+ RECT logical_rect = {0, 0, logical_area.x, logical_area.y };
+ ::FillRect(dc_mem, &logical_rect, brush);
+ ::DeleteObject(brush);
+
+ int max_unit = (std::max)(width, height);
+ int x = (logical_area.x / 2) - (width / 2);
+ int y = (logical_area.y / 2) - (height / 2);
+
+ StretchDIBits(dc_mem, x, y, width, height,
+ 0, 0, width, height, image, &bmi, DIB_RGB_COLORS, SRCCOPY);
+
+ if ((rc.right - rc.left) > 200 && (rc.bottom - rc.top) > 200) {
+ const BITMAPINFO& bmi = local_renderer->bmi();
+ image = local_renderer->image();
+ int thumb_width = bmi.bmiHeader.biWidth / 4;
+ int thumb_height = abs(bmi.bmiHeader.biHeight) / 4;
+ StretchDIBits(dc_mem,
+ logical_area.x - thumb_width - 10,
+ logical_area.y - thumb_height - 10,
+ thumb_width, thumb_height,
+ 0, 0, bmi.bmiHeader.biWidth, -bmi.bmiHeader.biHeight,
+ image, &bmi, DIB_RGB_COLORS, SRCCOPY);
+ }
+
+ BitBlt(ps.hdc, 0, 0, logical_area.x, logical_area.y,
+ dc_mem, 0, 0, SRCCOPY);
+
+ // Cleanup.
+ ::SelectObject(dc_mem, bmp_old);
+ ::DeleteObject(bmp_mem);
+ ::DeleteDC(dc_mem);
+ } else {
+ // We're still waiting for the video stream to be initialized.
+ HBRUSH brush = ::CreateSolidBrush(RGB(0, 0, 0));
+ ::FillRect(ps.hdc, &rc, brush);
+ ::DeleteObject(brush);
+
+ HGDIOBJ old_font = ::SelectObject(ps.hdc, GetDefaultFont());
+ ::SetTextColor(ps.hdc, RGB(0xff, 0xff, 0xff));
+ ::SetBkMode(ps.hdc, TRANSPARENT);
+
+ std::string text(kConnecting);
+ if (!local_renderer->image()) {
+ text += kNoVideoStreams;
+ } else {
+ text += kNoIncomingStream;
+ }
+ ::DrawTextA(ps.hdc, text.c_str(), -1, &rc,
+ DT_SINGLELINE | DT_CENTER | DT_VCENTER);
+ ::SelectObject(ps.hdc, old_font);
+ }
+ } else {
+ HBRUSH brush = ::CreateSolidBrush(::GetSysColor(COLOR_WINDOW));
+ ::FillRect(ps.hdc, &rc, brush);
+ ::DeleteObject(brush);
+ }
+
+ ::EndPaint(handle(), &ps);
+}
+
+void MainWnd::OnDestroyed() {
+ PostQuitMessage(0);
+}
+
+void MainWnd::OnDefaultAction() {
+ if (!callback_)
+ return;
+ if (ui_ == CONNECT_TO_SERVER) {
+ std::string server(GetWindowText(edit1_));
+ std::string port_str(GetWindowText(edit2_));
+ int port = port_str.length() ? atoi(port_str.c_str()) : 0;
+ callback_->StartLogin(server, port);
+ } else if (ui_ == LIST_PEERS) {
+ LRESULT sel = ::SendMessage(listbox_, LB_GETCURSEL, 0, 0);
+ if (sel != LB_ERR) {
+ LRESULT peer_id = ::SendMessage(listbox_, LB_GETITEMDATA, sel, 0);
+ if (peer_id != -1 && callback_) {
+ callback_->ConnectToPeer(peer_id);
+ }
+ }
+ } else {
+ MessageBoxA(wnd_, "OK!", "Yeah", MB_OK);
+ }
+}
+
+bool MainWnd::OnMessage(UINT msg, WPARAM wp, LPARAM lp, LRESULT* result) {
+ switch (msg) {
+ case WM_ERASEBKGND:
+ *result = TRUE;
+ return true;
+
+ case WM_PAINT:
+ OnPaint();
+ return true;
+
+ case WM_SETFOCUS:
+ if (ui_ == CONNECT_TO_SERVER) {
+ SetFocus(edit1_);
+ } else if (ui_ == LIST_PEERS) {
+ SetFocus(listbox_);
+ }
+ return true;
+
+ case WM_SIZE:
+ if (ui_ == CONNECT_TO_SERVER) {
+ LayoutConnectUI(true);
+ } else if (ui_ == LIST_PEERS) {
+ LayoutPeerListUI(true);
+ }
+ break;
+
+ case WM_CTLCOLORSTATIC:
+ *result = reinterpret_cast<LRESULT>(GetSysColorBrush(COLOR_WINDOW));
+ return true;
+
+ case WM_COMMAND:
+ if (button_ == reinterpret_cast<HWND>(lp)) {
+ if (BN_CLICKED == HIWORD(wp))
+ OnDefaultAction();
+ } else if (listbox_ == reinterpret_cast<HWND>(lp)) {
+ if (LBN_DBLCLK == HIWORD(wp)) {
+ OnDefaultAction();
+ }
+ }
+ return true;
+
+ case WM_CLOSE:
+ if (callback_)
+ callback_->Close();
+ break;
+ }
+ return false;
+}
+
+// static
+LRESULT CALLBACK MainWnd::WndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
+ MainWnd* me = reinterpret_cast<MainWnd*>(
+ ::GetWindowLongPtr(hwnd, GWL_USERDATA));
+ if (!me && WM_CREATE == msg) {
+ CREATESTRUCT* cs = reinterpret_cast<CREATESTRUCT*>(lp);
+ me = reinterpret_cast<MainWnd*>(cs->lpCreateParams);
+ me->wnd_ = hwnd;
+ ::SetWindowLongPtr(hwnd, GWL_USERDATA, reinterpret_cast<LONG_PTR>(me));
+ }
+
+ LRESULT result = 0;
+ if (me) {
+ void* prev_nested_msg = me->nested_msg_;
+ me->nested_msg_ = &msg;
+
+ bool handled = me->OnMessage(msg, wp, lp, &result);
+ if (WM_NCDESTROY == msg) {
+ me->destroyed_ = true;
+ } else if (!handled) {
+ result = ::DefWindowProc(hwnd, msg, wp, lp);
+ }
+
+ if (me->destroyed_ && prev_nested_msg == NULL) {
+ me->OnDestroyed();
+ me->wnd_ = NULL;
+ me->destroyed_ = false;
+ }
+
+ me->nested_msg_ = prev_nested_msg;
+ } else {
+ result = ::DefWindowProc(hwnd, msg, wp, lp);
+ }
+
+ return result;
+}
+
+// static
+bool MainWnd::RegisterWindowClass() {
+ if (wnd_class_)
+ return true;
+
+ WNDCLASSEX wcex = { sizeof(WNDCLASSEX) };
+ wcex.style = CS_DBLCLKS;
+ wcex.hInstance = GetModuleHandle(NULL);
+ wcex.hbrBackground = reinterpret_cast<HBRUSH>(COLOR_WINDOW + 1);
+ wcex.hCursor = ::LoadCursor(NULL, IDC_ARROW);
+ wcex.lpfnWndProc = &WndProc;
+ wcex.lpszClassName = kClassName;
+ wnd_class_ = ::RegisterClassEx(&wcex);
+ ASSERT(wnd_class_ != 0);
+ return wnd_class_ != 0;
+}
+
+void MainWnd::CreateChildWindow(HWND* wnd, MainWnd::ChildWindowID id,
+ const wchar_t* class_name, DWORD control_style,
+ DWORD ex_style) {
+ if (::IsWindow(*wnd))
+ return;
+
+ // Child windows are invisible at first, and shown after being resized.
+ DWORD style = WS_CHILD | control_style;
+ *wnd = ::CreateWindowEx(ex_style, class_name, L"", style,
+ 100, 100, 100, 100, wnd_,
+ reinterpret_cast<HMENU>(id),
+ GetModuleHandle(NULL), NULL);
+ ASSERT(::IsWindow(*wnd) != FALSE);
+ ::SendMessage(*wnd, WM_SETFONT, reinterpret_cast<WPARAM>(GetDefaultFont()),
+ TRUE);
+}
+
+void MainWnd::CreateChildWindows() {
+ // Create the child windows in tab order.
+ CreateChildWindow(&label1_, LABEL1_ID, L"Static", ES_CENTER | ES_READONLY, 0);
+ CreateChildWindow(&edit1_, EDIT_ID, L"Edit",
+ ES_LEFT | ES_NOHIDESEL | WS_TABSTOP, WS_EX_CLIENTEDGE);
+ CreateChildWindow(&label2_, LABEL2_ID, L"Static", ES_CENTER | ES_READONLY, 0);
+ CreateChildWindow(&edit2_, EDIT_ID, L"Edit",
+ ES_LEFT | ES_NOHIDESEL | WS_TABSTOP, WS_EX_CLIENTEDGE);
+ CreateChildWindow(&button_, BUTTON_ID, L"Button", BS_CENTER | WS_TABSTOP, 0);
+
+ CreateChildWindow(&listbox_, LISTBOX_ID, L"ListBox",
+ LBS_HASSTRINGS | LBS_NOTIFY, WS_EX_CLIENTEDGE);
+
+ ::SetWindowTextA(edit1_, GetDefaultServerName().c_str());
+ ::SetWindowTextA(edit2_, "8888");
+}
+
+void MainWnd::LayoutConnectUI(bool show) {
+ struct Windows {
+ HWND wnd;
+ const wchar_t* text;
+ size_t width;
+ size_t height;
+ } windows[] = {
+ { label1_, L"Server" },
+ { edit1_, L"XXXyyyYYYgggXXXyyyYYYggg" },
+ { label2_, L":" },
+ { edit2_, L"XyXyX" },
+ { button_, L"Connect" },
+ };
+
+ if (show) {
+ const size_t kSeparator = 5;
+ size_t total_width = (ARRAYSIZE(windows) - 1) * kSeparator;
+
+ for (size_t i = 0; i < ARRAYSIZE(windows); ++i) {
+ CalculateWindowSizeForText(windows[i].wnd, windows[i].text,
+ &windows[i].width, &windows[i].height);
+ total_width += windows[i].width;
+ }
+
+ RECT rc;
+ ::GetClientRect(wnd_, &rc);
+ size_t x = (rc.right / 2) - (total_width / 2);
+ size_t y = rc.bottom / 2;
+ for (size_t i = 0; i < ARRAYSIZE(windows); ++i) {
+ size_t top = y - (windows[i].height / 2);
+ ::MoveWindow(windows[i].wnd, x, top, windows[i].width, windows[i].height,
+ TRUE);
+ x += kSeparator + windows[i].width;
+ if (windows[i].text[0] != 'X')
+ ::SetWindowText(windows[i].wnd, windows[i].text);
+ ::ShowWindow(windows[i].wnd, SW_SHOWNA);
+ }
+ } else {
+ for (size_t i = 0; i < ARRAYSIZE(windows); ++i) {
+ ::ShowWindow(windows[i].wnd, SW_HIDE);
+ }
+ }
+}
+
+void MainWnd::LayoutPeerListUI(bool show) {
+ if (show) {
+ RECT rc;
+ ::GetClientRect(wnd_, &rc);
+ ::MoveWindow(listbox_, 0, 0, rc.right, rc.bottom, TRUE);
+ ::ShowWindow(listbox_, SW_SHOWNA);
+ } else {
+ ::ShowWindow(listbox_, SW_HIDE);
+ InvalidateRect(wnd_, NULL, TRUE);
+ }
+}
+
+void MainWnd::HandleTabbing() {
+ bool shift = ((::GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0);
+ UINT next_cmd = shift ? GW_HWNDPREV : GW_HWNDNEXT;
+ UINT loop_around_cmd = shift ? GW_HWNDLAST : GW_HWNDFIRST;
+ HWND focus = GetFocus(), next;
+ do {
+ next = ::GetWindow(focus, next_cmd);
+ if (IsWindowVisible(next) &&
+ (GetWindowLong(next, GWL_STYLE) & WS_TABSTOP)) {
+ break;
+ }
+
+ if (!next) {
+ next = ::GetWindow(focus, loop_around_cmd);
+ if (IsWindowVisible(next) &&
+ (GetWindowLong(next, GWL_STYLE) & WS_TABSTOP)) {
+ break;
+ }
+ }
+ focus = next;
+ } while (true);
+ ::SetFocus(next);
+}
+
+//
+// MainWnd::VideoRenderer
+//
+
+MainWnd::VideoRenderer::VideoRenderer(HWND wnd, int width, int height)
+ : wnd_(wnd) {
+ ::InitializeCriticalSection(&buffer_lock_);
+ ZeroMemory(&bmi_, sizeof(bmi_));
+ bmi_.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+ bmi_.bmiHeader.biPlanes = 1;
+ bmi_.bmiHeader.biBitCount = 32;
+ bmi_.bmiHeader.biCompression = BI_RGB;
+ bmi_.bmiHeader.biWidth = width;
+ bmi_.bmiHeader.biHeight = -height;
+ bmi_.bmiHeader.biSizeImage = width * height *
+ (bmi_.bmiHeader.biBitCount >> 3);
+}
+
+MainWnd::VideoRenderer::~VideoRenderer() {
+ ::DeleteCriticalSection(&buffer_lock_);
+}
+
+bool MainWnd::VideoRenderer::SetSize(int width, int height, int reserved) {
+ AutoLock<VideoRenderer> lock(this);
+
+ bmi_.bmiHeader.biWidth = width;
+ bmi_.bmiHeader.biHeight = -height;
+ bmi_.bmiHeader.biSizeImage = width * height *
+ (bmi_.bmiHeader.biBitCount >> 3);
+ image_.reset(new uint8[bmi_.bmiHeader.biSizeImage]);
+
+ return true;
+}
+
+bool MainWnd::VideoRenderer::RenderFrame(const cricket::VideoFrame* frame) {
+ if (!frame)
+ return false;
+
+ {
+ AutoLock<VideoRenderer> lock(this);
+
+ ASSERT(image_.get() != NULL);
+ frame->ConvertToRgbBuffer(cricket::FOURCC_ARGB,
+ image_.get(),
+ bmi_.bmiHeader.biSizeImage,
+ bmi_.bmiHeader.biWidth *
+ bmi_.bmiHeader.biBitCount / 8);
+ }
+
+ InvalidateRect(wnd_, NULL, TRUE);
+
+ return true;
+}
diff --git a/talk/examples/peerconnection/client/main_wnd.h b/talk/examples/peerconnection/client/main_wnd.h
new file mode 100644
index 0000000..17243b3
--- /dev/null
+++ b/talk/examples/peerconnection/client/main_wnd.h
@@ -0,0 +1,210 @@
+/*
+ * 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 PEERCONNECTION_SAMPLES_CLIENT_MAIN_WND_H_
+#define PEERCONNECTION_SAMPLES_CLIENT_MAIN_WND_H_
+#pragma once
+
+#include <map>
+#include <string>
+
+#include "talk/app/webrtc/mediastream.h"
+#include "talk/examples/peerconnection/client/peer_connection_client.h"
+#include "talk/base/win32.h"
+#include "talk/session/phone/mediachannel.h"
+#include "talk/session/phone/videocommon.h"
+#include "talk/session/phone/videoframe.h"
+#include "talk/session/phone/videorenderer.h"
+
+class MainWndCallback {
+ public:
+ virtual bool StartLogin(const std::string& server, int port) = 0;
+ virtual void DisconnectFromServer() = 0;
+ virtual void ConnectToPeer(int peer_id) = 0;
+ virtual void DisconnectFromCurrentPeer() = 0;
+ virtual void UIThreadCallback(int msg_id, void* data) = 0;
+ virtual void Close() = 0;
+ protected:
+ virtual ~MainWndCallback() {}
+};
+
+// Pure virtual interface for the main window.
+class MainWindow {
+ public:
+ virtual ~MainWindow() {}
+
+ enum UI {
+ CONNECT_TO_SERVER,
+ LIST_PEERS,
+ STREAMING,
+ };
+
+ virtual void RegisterObserver(MainWndCallback* callback) = 0;
+
+ virtual bool IsWindow() = 0;
+ virtual void MessageBox(const char* caption, const char* text,
+ bool is_error) = 0;
+
+ virtual UI current_ui() = 0;
+
+ virtual void SwitchToConnectUI() = 0;
+ virtual void SwitchToPeerList(const Peers& peers) = 0;
+ virtual void SwitchToStreamingUI() = 0;
+
+ virtual webrtc::VideoRendererWrapperInterface* local_renderer() = 0;
+ virtual webrtc::VideoRendererWrapperInterface* remote_renderer() = 0;
+
+ virtual void QueueUIThreadCallback(int msg_id, void* data) = 0;
+};
+
+#ifdef WIN32
+
+class MainWnd : public MainWindow {
+ public:
+ static const wchar_t kClassName[];
+
+ enum WindowMessages {
+ UI_THREAD_CALLBACK = WM_APP + 1,
+ };
+
+ MainWnd();
+ ~MainWnd();
+
+ bool Create();
+ bool Destroy();
+ bool PreTranslateMessage(MSG* msg);
+
+ virtual void RegisterObserver(MainWndCallback* callback);
+ virtual bool IsWindow();
+ virtual void SwitchToConnectUI();
+ virtual void SwitchToPeerList(const Peers& peers);
+ virtual void SwitchToStreamingUI();
+ virtual void MessageBox(const char* caption, const char* text,
+ bool is_error);
+ virtual UI current_ui() { return ui_; }
+
+ virtual webrtc::VideoRendererWrapperInterface* local_renderer();
+ virtual webrtc::VideoRendererWrapperInterface* remote_renderer();
+
+ virtual void QueueUIThreadCallback(int msg_id, void* data);
+
+ HWND handle() const { return wnd_; }
+
+ class VideoRenderer : public cricket::VideoRenderer {
+ public:
+ VideoRenderer(HWND wnd, int width, int height);
+ virtual ~VideoRenderer();
+
+ void Lock() {
+ ::EnterCriticalSection(&buffer_lock_);
+ }
+
+ void Unlock() {
+ ::LeaveCriticalSection(&buffer_lock_);
+ }
+
+ virtual bool SetSize(int width, int height, int reserved);
+
+ // Called when a new frame is available for display.
+ virtual bool RenderFrame(const cricket::VideoFrame* frame);
+
+ const BITMAPINFO& bmi() const { return bmi_; }
+ const uint8* image() const { return image_.get(); }
+
+ protected:
+ enum {
+ SET_SIZE,
+ RENDER_FRAME,
+ };
+
+ HWND wnd_;
+ BITMAPINFO bmi_;
+ talk_base::scoped_array<uint8> image_;
+ CRITICAL_SECTION buffer_lock_;
+ };
+
+ // A little helper class to make sure we always to proper locking and
+ // unlocking when working with VideoRenderer buffers.
+ template <typename T>
+ class AutoLock {
+ public:
+ explicit AutoLock(T* obj) : obj_(obj) { obj_->Lock(); }
+ ~AutoLock() { obj_->Unlock(); }
+ protected:
+ T* obj_;
+ };
+
+ protected:
+ enum ChildWindowID {
+ EDIT_ID = 1,
+ BUTTON_ID,
+ LABEL1_ID,
+ LABEL2_ID,
+ LISTBOX_ID,
+ };
+
+ void OnPaint();
+ void OnDestroyed();
+
+ void OnDefaultAction();
+
+ bool OnMessage(UINT msg, WPARAM wp, LPARAM lp, LRESULT* result);
+
+ static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp);
+ static bool RegisterWindowClass();
+
+ void CreateChildWindow(HWND* wnd, ChildWindowID id, const wchar_t* class_name,
+ DWORD control_style, DWORD ex_style);
+ void CreateChildWindows();
+
+ void LayoutConnectUI(bool show);
+ void LayoutPeerListUI(bool show);
+
+ void HandleTabbing();
+
+ private:
+ talk_base::scoped_refptr<webrtc::VideoRendererWrapperInterface>
+ local_renderer_wrapper_;
+ talk_base::scoped_refptr<webrtc::VideoRendererWrapperInterface>
+ remote_renderer_wrapper_;
+ UI ui_;
+ HWND wnd_;
+ DWORD ui_thread_id_;
+ HWND edit1_;
+ HWND edit2_;
+ HWND label1_;
+ HWND label2_;
+ HWND button_;
+ HWND listbox_;
+ bool destroyed_;
+ void* nested_msg_;
+ MainWndCallback* callback_;
+ static ATOM wnd_class_;
+};
+#endif // WIN32
+
+#endif // PEERCONNECTION_SAMPLES_CLIENT_MAIN_WND_H_
diff --git a/talk/examples/peerconnection/client/peer_connection_client.cc b/talk/examples/peerconnection/client/peer_connection_client.cc
new file mode 100644
index 0000000..64706de
--- /dev/null
+++ b/talk/examples/peerconnection/client/peer_connection_client.cc
@@ -0,0 +1,499 @@
+/*
+ * 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/examples/peerconnection/client/peer_connection_client.h"
+
+#include "talk/examples/peerconnection/client/defaults.h"
+#include "talk/base/common.h"
+#include "talk/base/nethelpers.h"
+#include "talk/base/logging.h"
+#include "talk/base/stringutils.h"
+
+#ifdef WIN32
+#include "talk/base/win32socketserver.h"
+#endif
+
+using talk_base::sprintfn;
+
+namespace {
+
+// This is our magical hangup signal.
+const char kByeMessage[] = "BYE";
+
+talk_base::AsyncSocket* CreateClientSocket() {
+#ifdef WIN32
+ return new talk_base::Win32Socket();
+#elif defined(POSIX)
+ talk_base::Thread* thread = talk_base::Thread::Current();
+ ASSERT(thread != NULL);
+ return thread->socketserver()->CreateAsyncSocket(SOCK_STREAM);
+#else
+#error Platform not supported.
+#endif
+}
+
+}
+
+PeerConnectionClient::PeerConnectionClient()
+ : callback_(NULL),
+ control_socket_(CreateClientSocket()),
+ hanging_get_(CreateClientSocket()),
+ state_(NOT_CONNECTED),
+ my_id_(-1) {
+ control_socket_->SignalCloseEvent.connect(this,
+ &PeerConnectionClient::OnClose);
+ hanging_get_->SignalCloseEvent.connect(this,
+ &PeerConnectionClient::OnClose);
+ control_socket_->SignalConnectEvent.connect(this,
+ &PeerConnectionClient::OnConnect);
+ hanging_get_->SignalConnectEvent.connect(this,
+ &PeerConnectionClient::OnHangingGetConnect);
+ control_socket_->SignalReadEvent.connect(this,
+ &PeerConnectionClient::OnRead);
+ hanging_get_->SignalReadEvent.connect(this,
+ &PeerConnectionClient::OnHangingGetRead);
+}
+
+PeerConnectionClient::~PeerConnectionClient() {
+}
+
+int PeerConnectionClient::id() const {
+ return my_id_;
+}
+
+bool PeerConnectionClient::is_connected() const {
+ return my_id_ != -1;
+}
+
+const Peers& PeerConnectionClient::peers() const {
+ return peers_;
+}
+
+void PeerConnectionClient::RegisterObserver(
+ PeerConnectionClientObserver* callback) {
+ ASSERT(!callback_);
+ callback_ = callback;
+}
+
+bool PeerConnectionClient::Connect(const std::string& server, int port,
+ const std::string& client_name) {
+ ASSERT(!server.empty());
+ ASSERT(!client_name.empty());
+
+ if (state_ != NOT_CONNECTED) {
+ LOG(WARNING)
+ << "The client must not be connected before you can call Connect()";
+ return false;
+ }
+
+ if (server.empty() || client_name.empty())
+ return false;
+
+ if (port <= 0)
+ port = kDefaultServerPort;
+
+ server_address_.SetIP(server);
+ server_address_.SetPort(port);
+
+ if (server_address_.IsUnresolved()) {
+ int errcode = 0;
+ hostent* h = talk_base::SafeGetHostByName(
+ server_address_.IPAsString().c_str(), &errcode);
+ if (!h) {
+ LOG(LS_ERROR) << "Failed to resolve host name: "
+ << server_address_.IPAsString();
+ return false;
+ } else {
+ server_address_.SetResolvedIP(
+ ntohl(*reinterpret_cast<uint32*>(h->h_addr_list[0])));
+ talk_base::FreeHostEnt(h);
+ }
+ }
+
+ char buffer[1024];
+ sprintfn(buffer, sizeof(buffer),
+ "GET /sign_in?%s HTTP/1.0\r\n\r\n", client_name.c_str());
+ onconnect_data_ = buffer;
+
+ bool ret = ConnectControlSocket();
+ if (ret)
+ state_ = SIGNING_IN;
+
+ return ret;
+}
+
+bool PeerConnectionClient::SendToPeer(int peer_id, const std::string& message) {
+ if (state_ != CONNECTED)
+ return false;
+
+ ASSERT(is_connected());
+ ASSERT(control_socket_->GetState() == talk_base::Socket::CS_CLOSED);
+ if (!is_connected() || peer_id == -1)
+ return false;
+
+ char headers[1024];
+ sprintfn(headers, sizeof(headers),
+ "POST /message?peer_id=%i&to=%i HTTP/1.0\r\n"
+ "Content-Length: %i\r\n"
+ "Content-Type: text/plain\r\n"
+ "\r\n",
+ my_id_, peer_id, message.length());
+ onconnect_data_ = headers;
+ onconnect_data_ += message;
+ return ConnectControlSocket();
+}
+
+bool PeerConnectionClient::SendHangUp(int peer_id) {
+ return SendToPeer(peer_id, kByeMessage);
+}
+
+bool PeerConnectionClient::IsSendingMessage() {
+ return state_ == CONNECTED &&
+ control_socket_->GetState() != talk_base::Socket::CS_CLOSED;
+}
+
+bool PeerConnectionClient::SignOut() {
+ if (state_ == NOT_CONNECTED || state_ == SIGNING_OUT)
+ return true;
+
+ if (hanging_get_->GetState() != talk_base::Socket::CS_CLOSED)
+ hanging_get_->Close();
+
+ if (control_socket_->GetState() == talk_base::Socket::CS_CLOSED) {
+ state_ = SIGNING_OUT;
+
+ if (my_id_ != -1) {
+ char buffer[1024];
+ sprintfn(buffer, sizeof(buffer),
+ "GET /sign_out?peer_id=%i HTTP/1.0\r\n\r\n", my_id_);
+ onconnect_data_ = buffer;
+ return ConnectControlSocket();
+ } else {
+ // Can occur if the app is closed before we finish connecting.
+ return true;
+ }
+ } else {
+ state_ = SIGNING_OUT_WAITING;
+ }
+
+ return true;
+}
+
+void PeerConnectionClient::Close() {
+ control_socket_->Close();
+ hanging_get_->Close();
+ onconnect_data_.clear();
+ peers_.clear();
+ my_id_ = -1;
+ state_ = NOT_CONNECTED;
+}
+
+bool PeerConnectionClient::ConnectControlSocket() {
+ ASSERT(control_socket_->GetState() == talk_base::Socket::CS_CLOSED);
+ int err = control_socket_->Connect(server_address_);
+ if (err == SOCKET_ERROR) {
+ Close();
+ return false;
+ }
+ return true;
+}
+
+void PeerConnectionClient::OnConnect(talk_base::AsyncSocket* socket) {
+ ASSERT(!onconnect_data_.empty());
+ size_t sent = socket->Send(onconnect_data_.c_str(), onconnect_data_.length());
+ ASSERT(sent == onconnect_data_.length());
+ UNUSED(sent);
+ onconnect_data_.clear();
+}
+
+void PeerConnectionClient::OnHangingGetConnect(talk_base::AsyncSocket* socket) {
+ char buffer[1024];
+ sprintfn(buffer, sizeof(buffer),
+ "GET /wait?peer_id=%i HTTP/1.0\r\n\r\n", my_id_);
+ int len = strlen(buffer);
+ int sent = socket->Send(buffer, len);
+ ASSERT(sent == len);
+ UNUSED2(sent, len);
+}
+
+void PeerConnectionClient::OnMessageFromPeer(int peer_id,
+ const std::string& message) {
+ if (message.length() == (sizeof(kByeMessage) - 1) &&
+ message.compare(kByeMessage) == 0) {
+ callback_->OnPeerDisconnected(peer_id);
+ } else {
+ callback_->OnMessageFromPeer(peer_id, message);
+ }
+}
+
+bool PeerConnectionClient::GetHeaderValue(const std::string& data,
+ size_t eoh,
+ const char* header_pattern,
+ size_t* value) {
+ ASSERT(value != NULL);
+ size_t found = data.find(header_pattern);
+ if (found != std::string::npos && found < eoh) {
+ *value = atoi(&data[found + strlen(header_pattern)]);
+ return true;
+ }
+ return false;
+}
+
+bool PeerConnectionClient::GetHeaderValue(const std::string& data, size_t eoh,
+ const char* header_pattern,
+ std::string* value) {
+ ASSERT(value != NULL);
+ size_t found = data.find(header_pattern);
+ if (found != std::string::npos && found < eoh) {
+ size_t begin = found + strlen(header_pattern);
+ size_t end = data.find("\r\n", begin);
+ if (end == std::string::npos)
+ end = eoh;
+ value->assign(data.substr(begin, end - begin));
+ return true;
+ }
+ return false;
+}
+
+bool PeerConnectionClient::ReadIntoBuffer(talk_base::AsyncSocket* socket,
+ std::string* data,
+ size_t* content_length) {
+ LOG(INFO) << __FUNCTION__;
+
+ char buffer[0xffff];
+ do {
+ int bytes = socket->Recv(buffer, sizeof(buffer));
+ if (bytes <= 0)
+ break;
+ data->append(buffer, bytes);
+ } while (true);
+
+ bool ret = false;
+ size_t i = data->find("\r\n\r\n");
+ if (i != std::string::npos) {
+ LOG(INFO) << "Headers received";
+ if (GetHeaderValue(*data, i, "\r\nContent-Length: ", content_length)) {
+ LOG(INFO) << "Expecting " << *content_length << " bytes.";
+ size_t total_response_size = (i + 4) + *content_length;
+ if (data->length() >= total_response_size) {
+ ret = true;
+ std::string should_close;
+ const char kConnection[] = "\r\nConnection: ";
+ if (GetHeaderValue(*data, i, kConnection, &should_close) &&
+ should_close.compare("close") == 0) {
+ socket->Close();
+ // Since we closed the socket, there was no notification delivered
+ // to us. Compensate by letting ourselves know.
+ OnClose(socket, 0);
+ }
+ } else {
+ // We haven't received everything. Just continue to accept data.
+ }
+ } else {
+ LOG(LS_ERROR) << "No content length field specified by the server.";
+ }
+ }
+ return ret;
+}
+
+void PeerConnectionClient::OnRead(talk_base::AsyncSocket* socket) {
+ LOG(INFO) << __FUNCTION__;
+ size_t content_length = 0;
+ if (ReadIntoBuffer(socket, &control_data_, &content_length)) {
+ size_t peer_id = 0, eoh = 0;
+ bool ok = ParseServerResponse(control_data_, content_length, &peer_id,
+ &eoh);
+ if (ok) {
+ if (my_id_ == -1) {
+ // First response. Let's store our server assigned ID.
+ ASSERT(state_ == SIGNING_IN);
+ my_id_ = peer_id;
+ ASSERT(my_id_ != -1);
+
+ // The body of the response will be a list of already connected peers.
+ if (content_length) {
+ size_t pos = eoh + 4;
+ while (pos < control_data_.size()) {
+ size_t eol = control_data_.find('\n', pos);
+ if (eol == std::string::npos)
+ break;
+ int id = 0;
+ std::string name;
+ bool connected;
+ if (ParseEntry(control_data_.substr(pos, eol - pos), &name, &id,
+ &connected) && id != my_id_) {
+ peers_[id] = name;
+ callback_->OnPeerConnected(id, name);
+ }
+ pos = eol + 1;
+ }
+ }
+ ASSERT(is_connected());
+ callback_->OnSignedIn();
+ } else if (state_ == SIGNING_OUT) {
+ Close();
+ callback_->OnDisconnected();
+ } else if (state_ == SIGNING_OUT_WAITING) {
+ SignOut();
+ }
+ }
+
+ control_data_.clear();
+
+ if (state_ == SIGNING_IN) {
+ ASSERT(hanging_get_->GetState() == talk_base::Socket::CS_CLOSED);
+ state_ = CONNECTED;
+ hanging_get_->Connect(server_address_);
+ }
+ }
+}
+
+void PeerConnectionClient::OnHangingGetRead(talk_base::AsyncSocket* socket) {
+ LOG(INFO) << __FUNCTION__;
+ size_t content_length = 0;
+ if (ReadIntoBuffer(socket, ¬ification_data_, &content_length)) {
+ size_t peer_id = 0, eoh = 0;
+ bool ok = ParseServerResponse(notification_data_, content_length,
+ &peer_id, &eoh);
+
+ if (ok) {
+ // Store the position where the body begins.
+ size_t pos = eoh + 4;
+
+ if (my_id_ == static_cast<int>(peer_id)) {
+ // A notification about a new member or a member that just
+ // disconnected.
+ int id = 0;
+ std::string name;
+ bool connected = false;
+ if (ParseEntry(notification_data_.substr(pos), &name, &id,
+ &connected)) {
+ if (connected) {
+ peers_[id] = name;
+ callback_->OnPeerConnected(id, name);
+ } else {
+ peers_.erase(id);
+ callback_->OnPeerDisconnected(id);
+ }
+ }
+ } else {
+ OnMessageFromPeer(peer_id, notification_data_.substr(pos));
+ }
+ }
+
+ notification_data_.clear();
+ }
+
+ if (hanging_get_->GetState() == talk_base::Socket::CS_CLOSED &&
+ state_ == CONNECTED) {
+ hanging_get_->Connect(server_address_);
+ }
+}
+
+bool PeerConnectionClient::ParseEntry(const std::string& entry,
+ std::string* name,
+ int* id,
+ bool* connected) {
+ ASSERT(name != NULL);
+ ASSERT(id != NULL);
+ ASSERT(connected != NULL);
+ ASSERT(!entry.empty());
+
+ *connected = false;
+ size_t separator = entry.find(',');
+ if (separator != std::string::npos) {
+ *id = atoi(&entry[separator + 1]);
+ name->assign(entry.substr(0, separator));
+ separator = entry.find(',', separator + 1);
+ if (separator != std::string::npos) {
+ *connected = atoi(&entry[separator + 1]) ? true : false;
+ }
+ }
+ return !name->empty();
+}
+
+int PeerConnectionClient::GetResponseStatus(const std::string& response) {
+ int status = -1;
+ size_t pos = response.find(' ');
+ if (pos != std::string::npos)
+ status = atoi(&response[pos + 1]);
+ return status;
+}
+
+bool PeerConnectionClient::ParseServerResponse(const std::string& response,
+ size_t content_length,
+ size_t* peer_id,
+ size_t* eoh) {
+ LOG(INFO) << response;
+
+ int status = GetResponseStatus(response.c_str());
+ if (status != 200) {
+ LOG(LS_ERROR) << "Received error from server";
+ Close();
+ callback_->OnDisconnected();
+ return false;
+ }
+
+ *eoh = response.find("\r\n\r\n");
+ ASSERT(*eoh != std::string::npos);
+ if (*eoh == std::string::npos)
+ return false;
+
+ *peer_id = -1;
+
+ // See comment in peer_channel.cc for why we use the Pragma header and
+ // not e.g. "X-Peer-Id".
+ GetHeaderValue(response, *eoh, "\r\nPragma: ", peer_id);
+
+ return true;
+}
+
+void PeerConnectionClient::OnClose(talk_base::AsyncSocket* socket, int err) {
+ LOG(INFO) << __FUNCTION__;
+
+ socket->Close();
+
+#ifdef WIN32
+ if (err != WSAECONNREFUSED) {
+#else
+ if (err != ECONNREFUSED) {
+#endif
+ if (socket == hanging_get_.get()) {
+ if (state_ == CONNECTED) {
+ LOG(INFO) << "Issuing a new hanging get";
+ hanging_get_->Close();
+ hanging_get_->Connect(server_address_);
+ }
+ } else {
+ callback_->OnMessageSent(err);
+ }
+ } else {
+ LOG(WARNING) << "Failed to connect to the server";
+ Close();
+ callback_->OnDisconnected();
+ }
+}
diff --git a/talk/examples/peerconnection/client/peer_connection_client.h b/talk/examples/peerconnection/client/peer_connection_client.h
new file mode 100644
index 0000000..f47a24d
--- /dev/null
+++ b/talk/examples/peerconnection/client/peer_connection_client.h
@@ -0,0 +1,126 @@
+/*
+ * 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 PEERCONNECTION_SAMPLES_CLIENT_PEER_CONNECTION_CLIENT_H_
+#define PEERCONNECTION_SAMPLES_CLIENT_PEER_CONNECTION_CLIENT_H_
+#pragma once
+
+#include <map>
+#include <string>
+
+#include "talk/base/sigslot.h"
+#include "talk/base/physicalsocketserver.h"
+#include "talk/base/scoped_ptr.h"
+
+typedef std::map<int, std::string> Peers;
+
+struct PeerConnectionClientObserver {
+ virtual void OnSignedIn() = 0; // Called when we're logged on.
+ virtual void OnDisconnected() = 0;
+ virtual void OnPeerConnected(int id, const std::string& name) = 0;
+ virtual void OnPeerDisconnected(int peer_id) = 0;
+ virtual void OnMessageFromPeer(int peer_id, const std::string& message) = 0;
+ virtual void OnMessageSent(int err) = 0;
+
+ protected:
+ virtual ~PeerConnectionClientObserver() {}
+};
+
+class PeerConnectionClient : public sigslot::has_slots<> {
+ public:
+ enum State {
+ NOT_CONNECTED,
+ SIGNING_IN,
+ CONNECTED,
+ SIGNING_OUT_WAITING,
+ SIGNING_OUT,
+ };
+
+ PeerConnectionClient();
+ ~PeerConnectionClient();
+
+ int id() const;
+ bool is_connected() const;
+ const Peers& peers() const;
+
+ void RegisterObserver(PeerConnectionClientObserver* callback);
+
+ bool Connect(const std::string& server, int port,
+ const std::string& client_name);
+
+ bool SendToPeer(int peer_id, const std::string& message);
+ bool SendHangUp(int peer_id);
+ bool IsSendingMessage();
+
+ bool SignOut();
+
+ protected:
+ void Close();
+ bool ConnectControlSocket();
+ void OnConnect(talk_base::AsyncSocket* socket);
+ void OnHangingGetConnect(talk_base::AsyncSocket* socket);
+ void OnMessageFromPeer(int peer_id, const std::string& message);
+
+ // Quick and dirty support for parsing HTTP header values.
+ bool GetHeaderValue(const std::string& data, size_t eoh,
+ const char* header_pattern, size_t* value);
+
+ bool GetHeaderValue(const std::string& data, size_t eoh,
+ const char* header_pattern, std::string* value);
+
+ // Returns true if the whole response has been read.
+ bool ReadIntoBuffer(talk_base::AsyncSocket* socket, std::string* data,
+ size_t* content_length);
+
+ void OnRead(talk_base::AsyncSocket* socket);
+
+ void OnHangingGetRead(talk_base::AsyncSocket* socket);
+
+ // Parses a single line entry in the form "<name>,<id>,<connected>"
+ bool ParseEntry(const std::string& entry, std::string* name, int* id,
+ bool* connected);
+
+ int GetResponseStatus(const std::string& response);
+
+ bool ParseServerResponse(const std::string& response, size_t content_length,
+ size_t* peer_id, size_t* eoh);
+
+ void OnClose(talk_base::AsyncSocket* socket, int err);
+
+ PeerConnectionClientObserver* callback_;
+ talk_base::SocketAddress server_address_;
+ talk_base::scoped_ptr<talk_base::AsyncSocket> control_socket_;
+ talk_base::scoped_ptr<talk_base::AsyncSocket> hanging_get_;
+ std::string onconnect_data_;
+ std::string control_data_;
+ std::string notification_data_;
+ Peers peers_;
+ State state_;
+ int my_id_;
+};
+
+#endif // PEERCONNECTION_SAMPLES_CLIENT_PEER_CONNECTION_CLIENT_H_
diff --git a/talk/examples/peerconnection/server/data_socket.cc b/talk/examples/peerconnection/server/data_socket.cc
new file mode 100644
index 0000000..81cba2e
--- /dev/null
+++ b/talk/examples/peerconnection/server/data_socket.cc
@@ -0,0 +1,304 @@
+/*
+ * 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/examples/peerconnection/server/data_socket.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "talk/examples/peerconnection/server/utils.h"
+
+static const char kHeaderTerminator[] = "\r\n\r\n";
+static const int kHeaderTerminatorLength = sizeof(kHeaderTerminator) - 1;
+
+// static
+const char DataSocket::kCrossOriginAllowHeaders[] =
+ "Access-Control-Allow-Origin: *\r\n"
+ "Access-Control-Allow-Credentials: true\r\n"
+ "Access-Control-Allow-Methods: POST, GET, OPTIONS\r\n"
+ "Access-Control-Allow-Headers: Content-Type, "
+ "Content-Length, Connection, Cache-Control\r\n"
+ "Access-Control-Expose-Headers: Content-Length, X-Peer-Id\r\n";
+
+#if defined(WIN32)
+class WinsockInitializer {
+ static WinsockInitializer singleton;
+
+ WinsockInitializer() {
+ WSADATA data;
+ WSAStartup(MAKEWORD(1, 0), &data);
+ }
+
+ public:
+ ~WinsockInitializer() { WSACleanup(); }
+};
+WinsockInitializer WinsockInitializer::singleton;
+#endif
+
+//
+// SocketBase
+//
+
+bool SocketBase::Create() {
+ assert(!valid());
+ socket_ = ::socket(AF_INET, SOCK_STREAM, 0);
+ return valid();
+}
+
+void SocketBase::Close() {
+ if (socket_ != INVALID_SOCKET) {
+ closesocket(socket_);
+ socket_ = INVALID_SOCKET;
+ }
+}
+
+//
+// DataSocket
+//
+
+std::string DataSocket::request_arguments() const {
+ size_t args = request_path_.find('?');
+ if (args != std::string::npos)
+ return request_path_.substr(args + 1);
+ return "";
+}
+
+bool DataSocket::PathEquals(const char* path) const {
+ assert(path);
+ size_t args = request_path_.find('?');
+ if (args != std::string::npos)
+ return request_path_.substr(0, args).compare(path) == 0;
+ return request_path_.compare(path) == 0;
+}
+
+bool DataSocket::OnDataAvailable(bool* close_socket) {
+ assert(valid());
+ char buffer[0xfff] = {0};
+ int bytes = recv(socket_, buffer, sizeof(buffer), 0);
+ if (bytes == SOCKET_ERROR || bytes == 0) {
+ *close_socket = true;
+ return false;
+ }
+
+ *close_socket = false;
+
+ bool ret = true;
+ if (headers_received()) {
+ if (method_ != POST) {
+ // unexpectedly received data.
+ ret = false;
+ } else {
+ data_.append(buffer, bytes);
+ }
+ } else {
+ request_headers_.append(buffer, bytes);
+ size_t found = request_headers_.find(kHeaderTerminator);
+ if (found != std::string::npos) {
+ data_ = request_headers_.substr(found + kHeaderTerminatorLength);
+ request_headers_.resize(found + kHeaderTerminatorLength);
+ ret = ParseHeaders();
+ }
+ }
+ return ret;
+}
+
+bool DataSocket::Send(const std::string& data) const {
+ return send(socket_, data.data(), data.length(), 0) != SOCKET_ERROR;
+}
+
+bool DataSocket::Send(const std::string& status, bool connection_close,
+ const std::string& content_type,
+ const std::string& extra_headers,
+ const std::string& data) const {
+ assert(valid());
+ assert(!status.empty());
+ std::string buffer("HTTP/1.1 " + status + "\r\n");
+
+ buffer += "Server: PeerConnectionTestServer/0.1\r\n"
+ "Cache-Control: no-cache\r\n";
+
+ if (connection_close)
+ buffer += "Connection: close\r\n";
+
+ if (!content_type.empty())
+ buffer += "Content-Type: " + content_type + "\r\n";
+
+ buffer += "Content-Length: " + int2str(data.size()) + "\r\n";
+
+ if (!extra_headers.empty()) {
+ buffer += extra_headers;
+ // Extra headers are assumed to have a separator per header.
+ }
+
+ buffer += kCrossOriginAllowHeaders;
+
+ buffer += "\r\n";
+ buffer += data;
+
+ return Send(buffer);
+}
+
+void DataSocket::Clear() {
+ method_ = INVALID;
+ content_length_ = 0;
+ content_type_.clear();
+ request_path_.clear();
+ request_headers_.clear();
+ data_.clear();
+}
+
+bool DataSocket::ParseHeaders() {
+ assert(!request_headers_.empty());
+ assert(method_ == INVALID);
+ size_t i = request_headers_.find("\r\n");
+ if (i == std::string::npos)
+ return false;
+
+ if (!ParseMethodAndPath(request_headers_.data(), i))
+ return false;
+
+ assert(method_ != INVALID);
+ assert(!request_path_.empty());
+
+ if (method_ == POST) {
+ const char* headers = request_headers_.data() + i + 2;
+ size_t len = request_headers_.length() - i - 2;
+ if (!ParseContentLengthAndType(headers, len))
+ return false;
+ }
+
+ return true;
+}
+
+bool DataSocket::ParseMethodAndPath(const char* begin, size_t len) {
+ struct {
+ const char* method_name;
+ size_t method_name_len;
+ RequestMethod id;
+ } supported_methods[] = {
+ { "GET", 3, GET },
+ { "POST", 4, POST },
+ { "OPTIONS", 7, OPTIONS },
+ };
+
+ const char* path = NULL;
+ for (size_t i = 0; i < ARRAYSIZE(supported_methods); ++i) {
+ if (len > supported_methods[i].method_name_len &&
+ isspace(begin[supported_methods[i].method_name_len]) &&
+ strncmp(begin, supported_methods[i].method_name,
+ supported_methods[i].method_name_len) == 0) {
+ method_ = supported_methods[i].id;
+ path = begin + supported_methods[i].method_name_len;
+ break;
+ }
+ }
+
+ const char* end = begin + len;
+ if (!path || path >= end)
+ return false;
+
+ ++path;
+ begin = path;
+ while (!isspace(*path) && path < end)
+ ++path;
+
+ request_path_.assign(begin, path - begin);
+
+ return true;
+}
+
+bool DataSocket::ParseContentLengthAndType(const char* headers, size_t length) {
+ assert(content_length_ == 0);
+ assert(content_type_.empty());
+
+ const char* end = headers + length;
+ while (headers && headers < end) {
+ if (!isspace(headers[0])) {
+ static const char kContentLength[] = "Content-Length:";
+ static const char kContentType[] = "Content-Type:";
+ if ((headers + ARRAYSIZE(kContentLength)) < end &&
+ strncmp(headers, kContentLength,
+ ARRAYSIZE(kContentLength) - 1) == 0) {
+ headers += ARRAYSIZE(kContentLength) - 1;
+ while (headers[0] == ' ')
+ ++headers;
+ content_length_ = atoi(headers);
+ } else if ((headers + ARRAYSIZE(kContentType)) < end &&
+ strncmp(headers, kContentType,
+ ARRAYSIZE(kContentType) - 1) == 0) {
+ headers += ARRAYSIZE(kContentType) - 1;
+ while (headers[0] == ' ')
+ ++headers;
+ const char* type_end = strstr(headers, "\r\n");
+ if (type_end == NULL)
+ type_end = end;
+ content_type_.assign(headers, type_end);
+ }
+ } else {
+ ++headers;
+ }
+ headers = strstr(headers, "\r\n");
+ if (headers)
+ headers += 2;
+ }
+
+ return !content_type_.empty() && content_length_ != 0;
+}
+
+//
+// ListeningSocket
+//
+
+bool ListeningSocket::Listen(unsigned short port) {
+ assert(valid());
+ int enabled = 1;
+ setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR,
+ reinterpret_cast<const char*>(&enabled), sizeof(enabled));
+ struct sockaddr_in addr = {0};
+ addr.sin_family = AF_INET;
+ addr.sin_addr.s_addr = htonl(INADDR_ANY);
+ addr.sin_port = htons(port);
+ if (bind(socket_, reinterpret_cast<const sockaddr*>(&addr),
+ sizeof(addr)) == SOCKET_ERROR) {
+ printf("bind failed\n");
+ return false;
+ }
+ return listen(socket_, 5) != SOCKET_ERROR;
+}
+
+DataSocket* ListeningSocket::Accept() const {
+ assert(valid());
+ struct sockaddr_in addr = {0};
+ socklen_t size = sizeof(addr);
+ int client = accept(socket_, reinterpret_cast<sockaddr*>(&addr), &size);
+ if (client == INVALID_SOCKET)
+ return NULL;
+
+ return new DataSocket(client);
+}
+
diff --git a/talk/examples/peerconnection/server/data_socket.h b/talk/examples/peerconnection/server/data_socket.h
new file mode 100644
index 0000000..b2ba28d
--- /dev/null
+++ b/talk/examples/peerconnection/server/data_socket.h
@@ -0,0 +1,168 @@
+/*
+ * 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_EXAMPLES_PEERCONNECTION_SERVER_DATA_SOCKET_H_
+#define TALK_EXAMPLES_PEERCONNECTION_SERVER_DATA_SOCKET_H_
+#pragma once
+
+#ifdef WIN32
+#include <winsock2.h>
+typedef int socklen_t;
+#else
+#include <netinet/in.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#define closesocket close
+#endif
+
+#include <string>
+
+#ifndef SOCKET_ERROR
+#define SOCKET_ERROR (-1)
+#endif
+
+#ifndef INVALID_SOCKET
+#define INVALID_SOCKET static_cast<int>(~0)
+#endif
+
+class SocketBase {
+ public:
+ SocketBase() : socket_(INVALID_SOCKET) { }
+ explicit SocketBase(int socket) : socket_(socket) { }
+ ~SocketBase() { Close(); }
+
+ int socket() const { return socket_; }
+ bool valid() const { return socket_ != INVALID_SOCKET; }
+
+ bool Create();
+ void Close();
+
+ protected:
+ int socket_;
+};
+
+// Represents an HTTP server socket.
+class DataSocket : public SocketBase {
+ public:
+ enum RequestMethod {
+ INVALID,
+ GET,
+ POST,
+ OPTIONS,
+ };
+
+ explicit DataSocket(int socket)
+ : SocketBase(socket),
+ method_(INVALID),
+ content_length_(0) {
+ }
+
+ ~DataSocket() {
+ }
+
+ static const char kCrossOriginAllowHeaders[];
+
+ bool headers_received() const { return method_ != INVALID; }
+
+ RequestMethod method() const { return method_; }
+
+ const std::string& request_path() const { return request_path_; }
+ std::string request_arguments() const;
+
+ const std::string& data() const { return data_; }
+
+ const std::string& content_type() const { return content_type_; }
+
+ size_t content_length() const { return content_length_; }
+
+ bool request_received() const {
+ return headers_received() && (method_ != POST || data_received());
+ }
+
+ bool data_received() const {
+ return method_ != POST || data_.length() >= content_length_;
+ }
+
+ // Checks if the request path (minus arguments) matches a given path.
+ bool PathEquals(const char* path) const;
+
+ // Called when we have received some data from clients.
+ // Returns false if an error occurred.
+ bool OnDataAvailable(bool* close_socket);
+
+ // Send a raw buffer of bytes.
+ bool Send(const std::string& data) const;
+
+ // Send an HTTP response. The |status| should start with a valid HTTP
+ // response code, followed by a string. E.g. "200 OK".
+ // If |connection_close| is set to true, an extra "Connection: close" HTTP
+ // header will be included. |content_type| is the mime content type, not
+ // including the "Content-Type: " string.
+ // |extra_headers| should be either empty or a list of headers where each
+ // header terminates with "\r\n".
+ // |data| is the body of the message. It's length will be specified via
+ // a "Content-Length" header.
+ bool Send(const std::string& status, bool connection_close,
+ const std::string& content_type,
+ const std::string& extra_headers, const std::string& data) const;
+
+ // Clears all held state and prepares the socket for receiving a new request.
+ void Clear();
+
+ protected:
+ // A fairly relaxed HTTP header parser. Parses the method, path and
+ // content length (POST only) of a request.
+ // Returns true if a valid request was received and no errors occurred.
+ bool ParseHeaders();
+
+ // Figures out whether the request is a GET or POST and what path is
+ // being requested.
+ bool ParseMethodAndPath(const char* begin, size_t len);
+
+ // Determines the length of the body and it's mime type.
+ bool ParseContentLengthAndType(const char* headers, size_t length);
+
+ protected:
+ RequestMethod method_;
+ size_t content_length_;
+ std::string content_type_;
+ std::string request_path_;
+ std::string request_headers_;
+ std::string data_;
+};
+
+// The server socket. Accepts connections and generates DataSocket instances
+// for each new connection.
+class ListeningSocket : public SocketBase {
+ public:
+ ListeningSocket() {}
+
+ bool Listen(unsigned short port);
+ DataSocket* Accept() const;
+};
+
+#endif // TALK_EXAMPLES_PEERCONNECTION_SERVER_DATA_SOCKET_H_
diff --git a/talk/examples/peerconnection/server/main.cc b/talk/examples/peerconnection/server/main.cc
new file mode 100644
index 0000000..63a573b
--- /dev/null
+++ b/talk/examples/peerconnection/server/main.cc
@@ -0,0 +1,176 @@
+/*
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <vector>
+
+#include "talk/examples/peerconnection/server/data_socket.h"
+#include "talk/examples/peerconnection/server/peer_channel.h"
+#include "talk/examples/peerconnection/server/utils.h"
+
+static const size_t kMaxConnections = (FD_SETSIZE - 2);
+
+void HandleBrowserRequest(DataSocket* ds, bool* quit) {
+ assert(ds && ds->valid());
+ assert(quit);
+
+ const std::string& path = ds->request_path();
+
+ *quit = (path.compare("/quit") == 0);
+
+ if (*quit) {
+ ds->Send("200 OK", true, "text/html", "",
+ "<html><body>Quitting...</body></html>");
+ } else if (ds->method() == DataSocket::OPTIONS) {
+ // We'll get this when a browsers do cross-resource-sharing requests.
+ // The headers to allow cross-origin script support will be set inside
+ // Send.
+ ds->Send("200 OK", true, "", "", "");
+ } else {
+ // Here we could write some useful output back to the browser depending on
+ // the path.
+ printf("Received an invalid request: %s\n", ds->request_path().c_str());
+ ds->Send("500 Sorry", true, "text/html", "",
+ "<html><body>Sorry, not yet implemented</body></html>");
+ }
+}
+
+int main(int argc, char** argv) {
+ // TODO: make configurable.
+ static const unsigned short port = 8888;
+
+ ListeningSocket listener;
+ if (!listener.Create()) {
+ printf("Failed to create server socket\n");
+ return -1;
+ } else if (!listener.Listen(port)) {
+ printf("Failed to listen on server socket\n");
+ return -1;
+ }
+
+ printf("Server listening on port %i\n", port);
+
+ PeerChannel clients;
+ typedef std::vector<DataSocket*> SocketArray;
+ SocketArray sockets;
+ bool quit = false;
+ while (!quit) {
+ fd_set socket_set;
+ FD_ZERO(&socket_set);
+ if (listener.valid())
+ FD_SET(listener.socket(), &socket_set);
+
+ for (SocketArray::iterator i = sockets.begin(); i != sockets.end(); ++i)
+ FD_SET((*i)->socket(), &socket_set);
+
+ struct timeval timeout = { 10, 0 };
+ if (select(FD_SETSIZE, &socket_set, NULL, NULL, &timeout) == SOCKET_ERROR) {
+ printf("select failed\n");
+ break;
+ }
+
+ for (SocketArray::iterator i = sockets.begin(); i != sockets.end(); ++i) {
+ DataSocket* s = *i;
+ bool socket_done = true;
+ if (FD_ISSET(s->socket(), &socket_set)) {
+ if (s->OnDataAvailable(&socket_done) && s->request_received()) {
+ ChannelMember* member = clients.Lookup(s);
+ if (member || PeerChannel::IsPeerConnection(s)) {
+ if (!member) {
+ if (s->PathEquals("/sign_in")) {
+ clients.AddMember(s);
+ } else {
+ printf("No member found for: %s\n",
+ s->request_path().c_str());
+ s->Send("500 Error", true, "text/plain", "",
+ "Peer most likely gone.");
+ }
+ } else if (member->is_wait_request(s)) {
+ // no need to do anything.
+ socket_done = false;
+ } else {
+ ChannelMember* target = clients.IsTargetedRequest(s);
+ if (target) {
+ member->ForwardRequestToPeer(s, target);
+ } else if (s->PathEquals("/sign_out")) {
+ s->Send("200 OK", true, "text/plain", "", "");
+ } else {
+ printf("Couldn't find target for request: %s\n",
+ s->request_path().c_str());
+ s->Send("500 Error", true, "text/plain", "",
+ "Peer most likely gone.");
+ }
+ }
+ } else {
+ HandleBrowserRequest(s, &quit);
+ if (quit) {
+ printf("Quitting...\n");
+ FD_CLR(listener.socket(), &socket_set);
+ listener.Close();
+ clients.CloseAll();
+ }
+ }
+ }
+ } else {
+ socket_done = false;
+ }
+
+ if (socket_done) {
+ printf("Disconnecting socket\n");
+ clients.OnClosing(s);
+ assert(s->valid()); // Close must not have been called yet.
+ FD_CLR(s->socket(), &socket_set);
+ delete (*i);
+ i = sockets.erase(i);
+ if (i == sockets.end())
+ break;
+ }
+ }
+
+ clients.CheckForTimeout();
+
+ if (FD_ISSET(listener.socket(), &socket_set)) {
+ DataSocket* s = listener.Accept();
+ if (sockets.size() >= kMaxConnections) {
+ delete s; // sorry, that's all we can take.
+ printf("Connection limit reached\n");
+ } else {
+ sockets.push_back(s);
+ printf("New connection...\n");
+ }
+ }
+ }
+
+ for (SocketArray::iterator i = sockets.begin(); i != sockets.end(); ++i)
+ delete (*i);
+ sockets.clear();
+
+ return 0;
+}
diff --git a/talk/examples/peerconnection/server/peer_channel.cc b/talk/examples/peerconnection/server/peer_channel.cc
new file mode 100644
index 0000000..5409941
--- /dev/null
+++ b/talk/examples/peerconnection/server/peer_channel.cc
@@ -0,0 +1,369 @@
+/*
+ * 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/examples/peerconnection/server/peer_channel.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <algorithm>
+
+#include "talk/examples/peerconnection/server/data_socket.h"
+#include "talk/examples/peerconnection/server/utils.h"
+
+// Set to the peer id of the originator when messages are being
+// exchanged between peers, but set to the id of the receiving peer
+// itself when notifications are sent from the server about the state
+// of other peers.
+//
+// WORKAROUND: Since support for CORS varies greatly from one browser to the
+// next, we don't use a custom name for our peer-id header (originally it was
+// "X-Peer-Id: "). Instead, we use a "simple header", "Pragma" which should
+// always be exposed to CORS requests. There is a special CORS header devoted
+// to exposing proprietary headers (Access-Control-Expose-Headers), however
+// at this point it is not working correctly in some popular browsers.
+static const char kPeerIdHeader[] = "Pragma: ";
+
+static const char* kRequestPaths[] = {
+ "/wait", "/sign_out", "/message",
+};
+
+enum RequestPathIndex {
+ kWait,
+ kSignOut,
+ kMessage,
+};
+
+//
+// ChannelMember
+//
+
+int ChannelMember::s_member_id_ = 0;
+
+ChannelMember::ChannelMember(DataSocket* socket)
+ : waiting_socket_(NULL), id_(++s_member_id_),
+ connected_(true), timestamp_(time(NULL)) {
+ assert(socket);
+ assert(socket->method() == DataSocket::GET);
+ assert(socket->PathEquals("/sign_in"));
+ name_ = socket->request_arguments(); // TODO: urldecode
+ if (!name_.length())
+ name_ = "peer_" + int2str(id_);
+ std::replace(name_.begin(), name_.end(), ',', '_');
+}
+
+ChannelMember::~ChannelMember() {
+}
+
+bool ChannelMember::is_wait_request(DataSocket* ds) const {
+ return ds && ds->PathEquals(kRequestPaths[kWait]);
+}
+
+bool ChannelMember::TimedOut() {
+ return waiting_socket_ == NULL && (time(NULL) - timestamp_) > 30;
+}
+
+std::string ChannelMember::GetPeerIdHeader() const {
+ std::string ret(kPeerIdHeader + int2str(id_) + "\r\n");
+ return ret;
+}
+
+bool ChannelMember::NotifyOfOtherMember(const ChannelMember& other) {
+ assert(&other != this);
+ QueueResponse("200 OK", "text/plain", GetPeerIdHeader(),
+ other.GetEntry());
+ return true;
+}
+
+// Returns a string in the form "name,id\n".
+std::string ChannelMember::GetEntry() const {
+ char entry[1024] = {0};
+ sprintf(entry, "%s,%i,%i\n", name_.c_str(), id_, connected_); // NOLINT
+ return entry;
+}
+
+void ChannelMember::ForwardRequestToPeer(DataSocket* ds, ChannelMember* peer) {
+ assert(peer);
+ assert(ds);
+
+ std::string extra_headers(GetPeerIdHeader());
+
+ if (peer == this) {
+ ds->Send("200 OK", true, ds->content_type(), extra_headers,
+ ds->data());
+ } else {
+ printf("Client %s sending to %s\n",
+ name_.c_str(), peer->name().c_str());
+ peer->QueueResponse("200 OK", ds->content_type(), extra_headers,
+ ds->data());
+ ds->Send("200 OK", true, "text/plain", "", "");
+ }
+}
+
+void ChannelMember::OnClosing(DataSocket* ds) {
+ if (ds == waiting_socket_) {
+ waiting_socket_ = NULL;
+ timestamp_ = time(NULL);
+ }
+}
+
+void ChannelMember::QueueResponse(const std::string& status,
+ const std::string& content_type,
+ const std::string& extra_headers,
+ const std::string& data) {
+ if (waiting_socket_) {
+ assert(queue_.size() == 0);
+ assert(waiting_socket_->method() == DataSocket::GET);
+ bool ok = waiting_socket_->Send(status, true, content_type, extra_headers,
+ data);
+ if (!ok) {
+ printf("Failed to deliver data to waiting socket\n");
+ }
+ waiting_socket_ = NULL;
+ timestamp_ = time(NULL);
+ } else {
+ QueuedResponse qr;
+ qr.status = status;
+ qr.content_type = content_type;
+ qr.extra_headers = extra_headers;
+ qr.data = data;
+ queue_.push(qr);
+ }
+}
+
+void ChannelMember::SetWaitingSocket(DataSocket* ds) {
+ assert(ds->method() == DataSocket::GET);
+ if (ds && !queue_.empty()) {
+ assert(waiting_socket_ == NULL);
+ const QueuedResponse& response = queue_.back();
+ ds->Send(response.status, true, response.content_type,
+ response.extra_headers, response.data);
+ queue_.pop();
+ } else {
+ waiting_socket_ = ds;
+ }
+}
+
+
+//
+// PeerChannel
+//
+
+// static
+bool PeerChannel::IsPeerConnection(const DataSocket* ds) {
+ assert(ds);
+ return (ds->method() == DataSocket::POST && ds->content_length() > 0) ||
+ (ds->method() == DataSocket::GET && ds->PathEquals("/sign_in"));
+}
+
+ChannelMember* PeerChannel::Lookup(DataSocket* ds) const {
+ assert(ds);
+
+ if (ds->method() != DataSocket::GET && ds->method() != DataSocket::POST)
+ return NULL;
+
+ size_t i = 0;
+ for (; i < ARRAYSIZE(kRequestPaths); ++i) {
+ if (ds->PathEquals(kRequestPaths[i]))
+ break;
+ }
+
+ if (i == ARRAYSIZE(kRequestPaths))
+ return NULL;
+
+ std::string args(ds->request_arguments());
+ static const char kPeerId[] = "peer_id=";
+ size_t found = args.find(kPeerId);
+ if (found == std::string::npos)
+ return NULL;
+
+ int id = atoi(&args[found + ARRAYSIZE(kPeerId) - 1]);
+ Members::const_iterator iter = members_.begin();
+ for (; iter != members_.end(); ++iter) {
+ if (id == (*iter)->id()) {
+ if (i == kWait)
+ (*iter)->SetWaitingSocket(ds);
+ if (i == kSignOut)
+ (*iter)->set_disconnected();
+ return *iter;
+ }
+ }
+
+ return NULL;
+}
+
+ChannelMember* PeerChannel::IsTargetedRequest(const DataSocket* ds) const {
+ assert(ds);
+ // Regardless of GET or POST, we look for the peer_id parameter
+ // only in the request_path.
+ const std::string& path = ds->request_path();
+ size_t args = path.find('?');
+ if (args == std::string::npos)
+ return NULL;
+ size_t found;
+ const char kTargetPeerIdParam[] = "to=";
+ do {
+ found = path.find(kTargetPeerIdParam, args);
+ if (found == std::string::npos)
+ return NULL;
+ if (found == (args + 1) || path[found - 1] == '&') {
+ found += ARRAYSIZE(kTargetPeerIdParam) - 1;
+ break;
+ }
+ args = found + ARRAYSIZE(kTargetPeerIdParam) - 1;
+ } while (true);
+ int id = atoi(&path[found]);
+ Members::const_iterator i = members_.begin();
+ for (; i != members_.end(); ++i) {
+ if ((*i)->id() == id) {
+ return *i;
+ }
+ }
+ return NULL;
+}
+
+bool PeerChannel::AddMember(DataSocket* ds) {
+ assert(IsPeerConnection(ds));
+ ChannelMember* new_guy = new ChannelMember(ds);
+ Members failures;
+ BroadcastChangedState(*new_guy, &failures);
+ HandleDeliveryFailures(&failures);
+ members_.push_back(new_guy);
+
+ printf("New member added (total=%s): %s\n",
+ size_t2str(members_.size()).c_str(), new_guy->name().c_str());
+
+ // Let the newly connected peer know about other members of the channel.
+ std::string content_type;
+ std::string response = BuildResponseForNewMember(*new_guy, &content_type);
+ ds->Send("200 Added", true, content_type, new_guy->GetPeerIdHeader(),
+ response);
+ return true;
+}
+
+void PeerChannel::CloseAll() {
+ Members::const_iterator i = members_.begin();
+ for (; i != members_.end(); ++i) {
+ (*i)->QueueResponse("200 OK", "text/plain", "", "Server shutting down");
+ }
+ DeleteAll();
+}
+
+void PeerChannel::OnClosing(DataSocket* ds) {
+ for (Members::iterator i = members_.begin(); i != members_.end(); ++i) {
+ ChannelMember* m = (*i);
+ m->OnClosing(ds);
+ if (!m->connected()) {
+ i = members_.erase(i);
+ Members failures;
+ BroadcastChangedState(*m, &failures);
+ HandleDeliveryFailures(&failures);
+ delete m;
+ if (i == members_.end())
+ break;
+ }
+ }
+ printf("Total connected: %s\n", size_t2str(members_.size()).c_str());
+}
+
+void PeerChannel::CheckForTimeout() {
+ for (Members::iterator i = members_.begin(); i != members_.end(); ++i) {
+ ChannelMember* m = (*i);
+ if (m->TimedOut()) {
+ printf("Timeout: %s\n", m->name().c_str());
+ m->set_disconnected();
+ i = members_.erase(i);
+ Members failures;
+ BroadcastChangedState(*m, &failures);
+ HandleDeliveryFailures(&failures);
+ delete m;
+ if (i == members_.end())
+ break;
+ }
+ }
+}
+
+void PeerChannel::DeleteAll() {
+ for (Members::iterator i = members_.begin(); i != members_.end(); ++i)
+ delete (*i);
+ members_.clear();
+}
+
+void PeerChannel::BroadcastChangedState(const ChannelMember& member,
+ Members* delivery_failures) {
+ // This function should be called prior to DataSocket::Close().
+ assert(delivery_failures);
+
+ if (!member.connected()) {
+ printf("Member disconnected: %s\n", member.name().c_str());
+ }
+
+ Members::iterator i = members_.begin();
+ for (; i != members_.end(); ++i) {
+ if (&member != (*i)) {
+ if (!(*i)->NotifyOfOtherMember(member)) {
+ (*i)->set_disconnected();
+ delivery_failures->push_back(*i);
+ i = members_.erase(i);
+ if (i == members_.end())
+ break;
+ }
+ }
+ }
+}
+
+void PeerChannel::HandleDeliveryFailures(Members* failures) {
+ assert(failures);
+
+ while (!failures->empty()) {
+ Members::iterator i = failures->begin();
+ ChannelMember* member = *i;
+ assert(!member->connected());
+ failures->erase(i);
+ BroadcastChangedState(*member, failures);
+ delete member;
+ }
+}
+
+// Builds a simple list of "name,id\n" entries for each member.
+std::string PeerChannel::BuildResponseForNewMember(const ChannelMember& member,
+ std::string* content_type) {
+ assert(content_type);
+
+ *content_type = "text/plain";
+ // The peer itself will always be the first entry.
+ std::string response(member.GetEntry());
+ for (Members::iterator i = members_.begin(); i != members_.end(); ++i) {
+ if (member.id() != (*i)->id()) {
+ assert((*i)->connected());
+ response += (*i)->GetEntry();
+ }
+ }
+
+ return response;
+}
diff --git a/talk/examples/peerconnection/server/peer_channel.h b/talk/examples/peerconnection/server/peer_channel.h
new file mode 100644
index 0000000..2ecc789
--- /dev/null
+++ b/talk/examples/peerconnection/server/peer_channel.h
@@ -0,0 +1,137 @@
+/*
+ * 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_EXAMPLES_PEERCONNECTION_SERVER_PEER_CHANNEL_H_
+#define TALK_EXAMPLES_PEERCONNECTION_SERVER_PEER_CHANNEL_H_
+#pragma once
+
+#include <time.h>
+
+#include <queue>
+#include <string>
+#include <vector>
+
+class DataSocket;
+
+// Represents a single peer connected to the server.
+class ChannelMember {
+ public:
+ explicit ChannelMember(DataSocket* socket);
+ ~ChannelMember();
+
+ bool connected() const { return connected_; }
+ int id() const { return id_; }
+ void set_disconnected() { connected_ = false; }
+ bool is_wait_request(DataSocket* ds) const;
+ const std::string& name() const { return name_; }
+
+ bool TimedOut();
+
+ std::string GetPeerIdHeader() const;
+
+ bool NotifyOfOtherMember(const ChannelMember& other);
+
+ // Returns a string in the form "name,id\n".
+ std::string GetEntry() const;
+
+ void ForwardRequestToPeer(DataSocket* ds, ChannelMember* peer);
+
+ void OnClosing(DataSocket* ds);
+
+ void QueueResponse(const std::string& status, const std::string& content_type,
+ const std::string& extra_headers, const std::string& data);
+
+ void SetWaitingSocket(DataSocket* ds);
+
+ protected:
+ struct QueuedResponse {
+ std::string status, content_type, extra_headers, data;
+ };
+
+ DataSocket* waiting_socket_;
+ int id_;
+ bool connected_;
+ time_t timestamp_;
+ std::string name_;
+ std::queue<QueuedResponse> queue_;
+ static int s_member_id_;
+};
+
+// Manages all currently connected peers.
+class PeerChannel {
+ public:
+ typedef std::vector<ChannelMember*> Members;
+
+ PeerChannel() {
+ }
+
+ ~PeerChannel() {
+ DeleteAll();
+ }
+
+ const Members& members() const { return members_; }
+
+ // Returns true if the request should be treated as a new ChannelMember
+ // request. Otherwise the request is not peerconnection related.
+ static bool IsPeerConnection(const DataSocket* ds);
+
+ // Finds a connected peer that's associated with the |ds| socket.
+ ChannelMember* Lookup(DataSocket* ds) const;
+
+ // Checks if the request has a "peer_id" parameter and if so, looks up the
+ // peer for which the request is targeted at.
+ ChannelMember* IsTargetedRequest(const DataSocket* ds) const;
+
+ // Adds a new ChannelMember instance to the list of connected peers and
+ // associates it with the socket.
+ bool AddMember(DataSocket* ds);
+
+ // Closes all connections and sends a "shutting down" message to all
+ // connected peers.
+ void CloseAll();
+
+ // Called when a socket was determined to be closing by the peer (or if the
+ // connection went dead).
+ void OnClosing(DataSocket* ds);
+
+ void CheckForTimeout();
+
+ protected:
+ void DeleteAll();
+ void BroadcastChangedState(const ChannelMember& member,
+ Members* delivery_failures);
+ void HandleDeliveryFailures(Members* failures);
+
+ // Builds a simple list of "name,id\n" entries for each member.
+ std::string BuildResponseForNewMember(const ChannelMember& member,
+ std::string* content_type);
+
+ protected:
+ Members members_;
+};
+
+#endif // TALK_EXAMPLES_PEERCONNECTION_SERVER_PEER_CHANNEL_H_
diff --git a/talk/examples/peerconnection/server/server_test.html b/talk/examples/peerconnection/server/server_test.html
new file mode 100644
index 0000000..d7c2266
--- /dev/null
+++ b/talk/examples/peerconnection/server/server_test.html
@@ -0,0 +1,263 @@
+<html>
+<head>
+<title>PeerConnection server test page</title>
+
+<script>
+var request = null;
+var hangingGet = null;
+var localName;
+var server;
+var my_id = -1;
+var other_peers = {};
+var message_counter = 0;
+
+function trace(txt) {
+ var elem = document.getElementById("debug");
+ elem.innerHTML += txt + "<br>";
+}
+
+function handleServerNotification(data) {
+ trace("Server notification: " + data);
+ var parsed = data.split(',');
+ if (parseInt(parsed[2]) != 0)
+ other_peers[parseInt(parsed[1])] = parsed[0];
+}
+
+function handlePeerMessage(peer_id, data) {
+ ++message_counter;
+ var str = "Message from '" + other_peers[peer_id] + "' ";
+ str += "<span id='toggle_" + message_counter + "' onclick='toggleMe(this);' ";
+ str += "style='cursor: pointer'>+</span><br>";
+ str += "<blockquote id='msg_" + message_counter + "' style='display:none'>";
+ str += data + "</blockquote>";
+ trace(str);
+ if (document.getElementById("loopback").checked) {
+ if (data.search("OFFER") != -1) {
+ // In loopback mode, replace the ROAP OFFER with ROAP ANSWER.
+ data = data.replace("OFFER", "ANSWER");
+ // Keep only the first crypto line for each m line in the answer.
+ var mlineBegin = data.indexOf("m=", 0);
+ while (mlineBegin != -1) {
+ var cryptoBegin = data.indexOf("a=crypto:", mlineBegin);
+ if (cryptoBegin == -1) {
+ // No more crypto lines.
+ break;
+ }
+ // Skip the first crypto line.
+ cryptoBegin = data.indexOf("a=crypto:", cryptoBegin + 1);
+ // Update the mlineBegin to the the next m line.
+ mlineBegin = data.indexOf("m=", mlineBegin + 1);
+ while (cryptoBegin != -1 && cryptoBegin < mlineBegin) {
+ var cryptoEnd = data.indexOf("\\n", cryptoBegin);
+ var crypto = data.substring(cryptoBegin, cryptoEnd + 2);
+ data = data.replace(crypto, "");
+ // Search for the the next crypto line.
+ cryptoBegin = data.indexOf("a=crypto:", cryptoBegin + 1);
+ }
+ }
+ var lines = data.split("\n");
+ for (var i = 1; i < lines.length; ++i) {
+ // Look for the offererSessionId and use it as answererSessionId
+ if (lines[i].length > 0 && lines[i].search("offererSessionId") != -1) {
+ var answer_session_id =
+ lines[i].replace("offererSessionId", "answererSessionId");
+ answer_session_id += "\n" + lines[i];
+ data = data.replace(lines[i], answer_session_id);
+ }
+ }
+ }
+ sendToPeer(peer_id, data);
+ }
+}
+
+function GetIntHeader(r, name) {
+ var val = r.getResponseHeader(name);
+ return val != null && val.length ? parseInt(val) : -1;
+}
+
+function hangingGetCallback() {
+ try {
+ if (hangingGet.readyState != 4)
+ return;
+ if (hangingGet.status != 200) {
+ trace("server error: " + hangingGet.statusText);
+ disconnect();
+ } else {
+ var peer_id = GetIntHeader(hangingGet, "Pragma");
+ if (peer_id == my_id) {
+ handleServerNotification(hangingGet.responseText);
+ } else {
+ handlePeerMessage(peer_id, hangingGet.responseText);
+ }
+ }
+
+ if (hangingGet) {
+ hangingGet.abort();
+ hangingGet = null;
+ }
+
+ if (my_id != -1)
+ window.setTimeout(startHangingGet, 0);
+ } catch (e) {
+ trace("Hanging get error: " + e.description);
+ }
+}
+
+function startHangingGet() {
+ try {
+ hangingGet = new XMLHttpRequest();
+ hangingGet.onreadystatechange = hangingGetCallback;
+ hangingGet.ontimeout = onHangingGetTimeout;
+ hangingGet.open("GET", server + "/wait?peer_id=" + my_id, true);
+ hangingGet.send();
+ } catch (e) {
+ trace("error" + e.description);
+ }
+}
+
+function onHangingGetTimeout() {
+ trace("hanging get timeout. issuing again.");
+ hangingGet.abort();
+ hangingGet = null;
+ if (my_id != -1)
+ window.setTimeout(startHangingGet, 0);
+}
+
+function signInCallback() {
+ try {
+ if (request.readyState == 4) {
+ if (request.status == 200) {
+ var peers = request.responseText.split("\n");
+ my_id = parseInt(peers[0].split(',')[1]);
+ trace("My id: " + my_id);
+ for (var i = 1; i < peers.length; ++i) {
+ if (peers[i].length > 0) {
+ trace("Peer " + i + ": " + peers[i]);
+ var parsed = peers[i].split(',');
+ other_peers[parseInt(parsed[1])] = parsed[0];
+ }
+ }
+ startHangingGet();
+ request = null;
+ }
+ }
+ } catch (e) {
+ trace("error: " + e.description);
+ }
+}
+
+function signIn() {
+ try {
+ request = new XMLHttpRequest();
+ request.onreadystatechange = signInCallback;
+ request.open("GET", server + "/sign_in?" + localName, true);
+ request.send();
+ } catch (e) {
+ trace("error: " + e.description);
+ }
+}
+
+function sendToPeer(peer_id, data) {
+ if (my_id == -1) {
+ alert("Not connected");
+ return;
+ }
+ if (peer_id == my_id) {
+ alert("Can't send a message to oneself :)");
+ return;
+ }
+ var r = new XMLHttpRequest();
+ r.open("POST", server + "/message?peer_id=" + my_id + "&to=" + peer_id,
+ false);
+ r.setRequestHeader("Content-Type", "text/plain");
+ r.send(data);
+ r = null;
+}
+
+function connect() {
+ localName = document.getElementById("local").value.toLowerCase();
+ server = document.getElementById("server").value.toLowerCase();
+ if (localName.length == 0) {
+ alert("I need a name please.");
+ document.getElementById("local").focus();
+ } else {
+ document.getElementById("connect").disabled = true;
+ document.getElementById("disconnect").disabled = false;
+ document.getElementById("send").disabled = false;
+ signIn();
+ }
+}
+
+function disconnect() {
+ if (request) {
+ request.abort();
+ request = null;
+ }
+
+ if (hangingGet) {
+ hangingGet.abort();
+ hangingGet = null;
+ }
+
+ if (my_id != -1) {
+ request = new XMLHttpRequest();
+ request.open("GET", server + "/sign_out?peer_id=" + my_id, false);
+ request.send();
+ request = null;
+ my_id = -1;
+ }
+
+ document.getElementById("connect").disabled = false;
+ document.getElementById("disconnect").disabled = true;
+ document.getElementById("send").disabled = true;
+}
+
+window.onbeforeunload = disconnect;
+
+function send() {
+ var text = document.getElementById("message").value;
+ var peer_id = parseInt(document.getElementById("peer_id").value);
+ if (!text.length || peer_id == 0) {
+ alert("No text supplied or invalid peer id");
+ } else {
+ sendToPeer(peer_id, text);
+ }
+}
+
+function toggleMe(obj) {
+ var id = obj.id.replace("toggle", "msg");
+ var t = document.getElementById(id);
+ if (obj.innerText == "+") {
+ obj.innerText = "-";
+ t.style.display = "block";
+ } else {
+ obj.innerText = "+";
+ t.style.display = "none";
+ }
+}
+
+</script>
+
+</head>
+<body>
+Server: <input type="text" id="server" value="http://localhost:8888" /><br>
+<input type="checkbox" id="loopback" checked="checked"/> Loopback (just send
+received messages right back)<br>
+Your name: <input type="text" id="local" value="my_name"/>
+<button id="connect" onclick="connect();">Connect</button>
+<button disabled="true" id="disconnect"
+ onclick="disconnect();">Disconnect</button>
+<br>
+<table><tr><td>
+Target peer id: <input type="text" id="peer_id" size="3"/></td><td>
+Message: <input type="text" id="message"/></td><td>
+<button disabled="true" id="send" onclick="send();">Send</button>
+</td></tr></table>
+<button onclick="document.getElementById('debug').innerHTML='';">
+Clear log</button>
+
+<pre id="debug">
+</pre>
+<br><hr>
+</body>
+</html>
diff --git a/talk/examples/peerconnection/server/utils.cc b/talk/examples/peerconnection/server/utils.cc
new file mode 100644
index 0000000..25ec10c
--- /dev/null
+++ b/talk/examples/peerconnection/server/utils.cc
@@ -0,0 +1,47 @@
+/*
+ * 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/examples/peerconnection/server/utils.h"
+
+#include <stdio.h>
+
+std::string int2str(int i) {
+ char buffer[11] = {0};
+ sprintf(buffer, "%d", i); // NOLINT
+ return buffer;
+}
+
+std::string size_t2str(size_t i) {
+ char buffer[32] = {0};
+#ifdef WIN32
+ // %zu isn't supported on Windows.
+ sprintf(buffer, "%Iu", i); // NOLINT
+#else
+ sprintf(buffer, "%zu", i); // NOLINT
+#endif
+ return buffer;
+}
diff --git a/talk/examples/peerconnection/server/utils.h b/talk/examples/peerconnection/server/utils.h
new file mode 100644
index 0000000..d05a2c3
--- /dev/null
+++ b/talk/examples/peerconnection/server/utils.h
@@ -0,0 +1,53 @@
+/*
+ * 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_EXAMPLES_PEERCONNECTION_SERVER_UTILS_H_
+#define TALK_EXAMPLES_PEERCONNECTION_SERVER_UTILS_H_
+#pragma once
+
+#ifndef assert
+#ifndef WIN32
+#include <assert.h>
+#else
+#ifndef NDEBUG
+#define assert(expr) ((void)((expr) ? true : __debugbreak()))
+#else
+#define assert(expr) ((void)0)
+#endif // NDEBUG
+#endif // WIN32
+#endif // assert
+
+#include <string>
+
+#ifndef ARRAYSIZE
+#define ARRAYSIZE(x) (sizeof(x) / sizeof(x[0]))
+#endif
+
+std::string int2str(int i);
+std::string size_t2str(size_t i);
+
+#endif // TALK_EXAMPLES_PEERCONNECTION_SERVER_UTILS_H_
diff --git a/talk/examples/plus/libjingleplus.cc b/talk/examples/plus/libjingleplus.cc
new file mode 100644
index 0000000..4d27dfd
--- /dev/null
+++ b/talk/examples/plus/libjingleplus.cc
@@ -0,0 +1,736 @@
+/*
+ * libjingle
+ * Copyright 2006, 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 <iostream>
+#include "libjingleplus.h"
+#ifdef WIN32
+#include "talk/base/win32socketserver.h"
+#endif
+#include "talk/base/physicalsocketserver.h"
+#include "talk/base/logging.h"
+#include "talk/examples/login/xmppauth.h"
+#include "talk/examples/login/xmppsocket.h"
+#include "talk/examples/login/xmpppump.h"
+#include "presencepushtask.h"
+#include "talk/app/status.h"
+#include "talk/app/message.h"
+#include "rostertask.h"
+#include "talk/app/iqtask.h"
+#include "talk/app/presenceouttask.h"
+#include "talk/app/receivemessagetask.h"
+#include "talk/app/rostersettask.h"
+#include "talk/app/sendmessagetask.h"
+
+enum {
+ MSG_START,
+
+ // main thread to worker
+ MSG_LOGIN,
+ MSG_DISCONNECT,
+ MSG_SEND_PRESENCE,
+ MSG_SEND_DIRECTED_PRESENCE,
+ MSG_SEND_DIRECTED_MUC_PRESENCE,
+ MSG_SEND_XMPP_MESSAGE,
+ MSG_SEND_XMPP_IQ,
+ MSG_UPDATE_ROSTER_ITEM,
+ MSG_REMOVE_ROSTER_ITEM,
+
+ // worker thread to main thread
+ MSG_STATE_CHANGE,
+ MSG_STATUS_UPDATE,
+ MSG_STATUS_ERROR,
+ MSG_ROSTER_REFRESH_STARTED,
+ MSG_ROSTER_REFRESH_FINISHED,
+ MSG_ROSTER_ITEM_UPDATED,
+ MSG_ROSTER_ITEM_REMOVED,
+ MSG_ROSTER_SUBSCRIBE,
+ MSG_ROSTER_UNSUBSCRIBE,
+ MSG_ROSTER_SUBSCRIBED,
+ MSG_ROSTER_UNSUBSCRIBED,
+ MSG_INCOMING_MESSAGE,
+ MSG_IQ_COMPLETE,
+ MSG_XMPP_INPUT,
+ MSG_XMPP_OUTPUT
+};
+
+class LibjinglePlusWorker : public talk_base::MessageHandler,
+ public XmppPumpNotify,
+ public sigslot::has_slots<> {
+ public:
+ LibjinglePlusWorker(LibjinglePlus *ljp, LibjinglePlusNotify *notify) :
+ worker_thread_(NULL), ljp_(ljp), notify_(notify),
+ ppt_(NULL), rmt_(NULL), rt_(NULL), is_test_login_(false) {
+
+ main_thread_.reset(new talk_base::AutoThread());
+#ifdef WIN32
+ ss_.reset(new talk_base::Win32SocketServer(main_thread_.get()));
+ main_thread_->set_socketserver(ss_.get());
+#endif
+
+ pump_.reset(new XmppPump(this));
+
+ pump_->client()->SignalLogInput.connect(this, &LibjinglePlusWorker::OnInputDebug);
+ pump_->client()->SignalLogOutput.connect(this, &LibjinglePlusWorker::OnOutputDebug);
+ //pump_->client()->SignalStateChange.connect(this, &LibjinglePlusWorker::OnStateChange);
+ }
+
+ ~LibjinglePlusWorker() {
+ if (worker_thread_) {
+ worker_thread_->Send(this, MSG_DISCONNECT);
+ delete worker_thread_;
+ }
+ }
+
+ virtual void OnMessage(talk_base::Message *msg) {
+ switch (msg->message_id) {
+ case MSG_START:
+ LoginW();
+ break;
+ case MSG_DISCONNECT:
+ DisconnectW();
+ break;
+ case MSG_SEND_XMPP_MESSAGE:
+ SendXmppMessageW(static_cast<SendMessageData*>(msg->pdata)->m_);
+ delete msg->pdata;
+ break;
+ case MSG_SEND_XMPP_IQ:
+ SendXmppIqW(static_cast<SendIqData*>(msg->pdata)->to_jid_,
+ static_cast<SendIqData*>(msg->pdata)->is_get_,
+ static_cast<SendIqData*>(msg->pdata)->xml_element_);
+ delete msg->pdata;
+ break;
+ case MSG_SEND_PRESENCE:
+ SendPresenceW(static_cast<SendPresenceData*>(msg->pdata)->s_);
+ delete msg->pdata;
+ break;
+ case MSG_SEND_DIRECTED_PRESENCE:
+ SendDirectedPresenceW(static_cast<SendDirectedPresenceData*>(msg->pdata)->j_,
+ static_cast<SendDirectedPresenceData*>(msg->pdata)->s_);
+ delete msg->pdata;
+ break;
+ case MSG_SEND_DIRECTED_MUC_PRESENCE:
+ SendDirectedMUCPresenceW(static_cast<SendDirectedMUCPresenceData*>(msg->pdata)->j_,
+ static_cast<SendDirectedMUCPresenceData*>(msg->pdata)->s_,
+ static_cast<SendDirectedMUCPresenceData*>(msg->pdata)->un_,
+ static_cast<SendDirectedMUCPresenceData*>(msg->pdata)->ac_,
+ static_cast<SendDirectedMUCPresenceData*>(msg->pdata)->am_,
+ static_cast<SendDirectedMUCPresenceData*>(msg->pdata)->role_);
+ delete msg->pdata;
+ break;
+ case MSG_UPDATE_ROSTER_ITEM:
+ UpdateRosterItemW(static_cast<UpdateRosterItemData*>(msg->pdata)->jid_,
+ static_cast<UpdateRosterItemData*>(msg->pdata)->n_,
+ static_cast<UpdateRosterItemData*>(msg->pdata)->g_,
+ static_cast<UpdateRosterItemData*>(msg->pdata)->grt_);
+ delete msg->pdata;
+ break;
+ case MSG_REMOVE_ROSTER_ITEM:
+ RemoveRosterItemW(static_cast<JidData*>(msg->pdata)->jid_);
+ delete msg->pdata;
+ break;
+
+
+
+
+ case MSG_STATUS_UPDATE:
+ OnStatusUpdateW(static_cast<SendPresenceData*>(msg->pdata)->s_);
+ delete msg->pdata;
+ break;
+ case MSG_STATUS_ERROR:
+ OnStatusErrorW(static_cast<StatusErrorData*>(msg->pdata)->stanza_);
+ delete msg->pdata;
+ break;
+ case MSG_STATE_CHANGE:
+ OnStateChangeW(static_cast<StateChangeData*>(msg->pdata)->s_);
+ delete msg->pdata;
+ break;
+ case MSG_ROSTER_REFRESH_STARTED:
+ OnRosterRefreshStartedW();
+ break;
+ case MSG_ROSTER_REFRESH_FINISHED:
+ OnRosterRefreshFinishedW();
+ break;
+ case MSG_ROSTER_ITEM_UPDATED:
+ OnRosterItemUpdatedW(static_cast<RosterItemData*>(msg->pdata)->ri_);
+ delete msg->pdata;
+ break;
+ case MSG_ROSTER_ITEM_REMOVED:
+ OnRosterItemRemovedW(static_cast<RosterItemData*>(msg->pdata)->ri_);
+ delete msg->pdata;
+ break;
+ case MSG_ROSTER_SUBSCRIBE:
+ OnRosterSubscribeW(static_cast<JidData*>(msg->pdata)->jid_);
+ delete msg->pdata;
+ break;
+ case MSG_ROSTER_UNSUBSCRIBE:
+ OnRosterUnsubscribeW(static_cast<JidData*>(msg->pdata)->jid_);
+ delete msg->pdata;
+ break;
+ case MSG_ROSTER_SUBSCRIBED:
+ OnRosterSubscribedW(static_cast<JidData*>(msg->pdata)->jid_);
+ delete msg->pdata;
+ break;
+ case MSG_ROSTER_UNSUBSCRIBED:
+ OnRosterUnsubscribedW(static_cast<JidData*>(msg->pdata)->jid_);
+ delete msg->pdata;
+ break;
+ case MSG_INCOMING_MESSAGE:
+ OnIncomingMessageW(static_cast<XmppMessageData*>(msg->pdata)->m_);
+ delete msg->pdata;
+ break;
+ case MSG_IQ_COMPLETE:
+ OnIqCompleteW(static_cast<IqCompleteData*>(msg->pdata)->success_,
+ static_cast<IqCompleteData*>(msg->pdata)->stanza_);
+ delete msg->pdata;
+ break;
+ case MSG_XMPP_OUTPUT:
+ OnOutputDebugW(static_cast<StringData*>(msg->pdata)->s_);
+ delete msg->pdata;
+ break;
+ case MSG_XMPP_INPUT:
+ OnInputDebugW(static_cast<StringData*>(msg->pdata)->s_);
+ delete msg->pdata;
+ break;
+ }
+ }
+
+ void Login(const std::string &jid, const std::string &password,
+ const std::string &machine_address, bool is_test, bool cookie_auth) {
+ is_test_login_ = is_test;
+
+ xcs_.set_user(jid);
+ if (cookie_auth) {
+ xcs_.set_auth_cookie(password);
+ } else {
+ talk_base::InsecureCryptStringImpl pass;
+ pass.password() = password;
+ xcs_.set_pass(talk_base::CryptString(pass));
+ }
+ xcs_.set_host(is_test ? "google.com" : "gmail.com");
+ xcs_.set_resource("libjingleplus");
+ xcs_.set_server(talk_base::SocketAddress(machine_address, 5222));
+ xcs_.set_use_tls(!is_test);
+ if (is_test) {
+ xcs_.set_allow_plain(true);
+ }
+
+ worker_thread_ = new talk_base::Thread(&pss_);
+ worker_thread_->Start();
+ worker_thread_->Send(this, MSG_START);
+ }
+
+ void SendXmppMessage(const buzz::XmppMessage &m) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ worker_thread_->Post(this, MSG_SEND_XMPP_MESSAGE, new SendMessageData(m));
+ }
+
+ void SendXmppIq(const buzz::Jid &to_jid, bool is_get,
+ const buzz::XmlElement *xml_element) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ worker_thread_->Post(this, MSG_SEND_XMPP_IQ,
+ new SendIqData(to_jid, is_get, xml_element));
+ }
+
+ void SendPresence(const buzz::Status & s) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ worker_thread_->Post(this, MSG_SEND_PRESENCE, new SendPresenceData(s));
+ }
+
+ void SendDirectedPresence (const buzz::Jid &j, const buzz::Status &s) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ worker_thread_->Post(this, MSG_SEND_DIRECTED_PRESENCE, new SendDirectedPresenceData(j,s));
+ }
+
+ void SendDirectedMUCPresence(const buzz::Jid &j, const buzz::Status &s,
+ const std::string &un, const std::string &ac,
+ const std::string &am, const std::string &role) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ worker_thread_->Post(this, MSG_SEND_DIRECTED_MUC_PRESENCE, new SendDirectedMUCPresenceData(j,s,un,ac,am, role));
+ }
+
+ void UpdateRosterItem(const buzz::Jid & jid, const std::string & name,
+ const std::vector<std::string> & groups, buzz::GrType grt) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ worker_thread_->Post(this, MSG_UPDATE_ROSTER_ITEM, new UpdateRosterItemData(jid,name,groups,grt));
+ }
+
+ void RemoveRosterItemW(const buzz::Jid &jid) {
+ buzz::RosterSetTask *rst = new buzz::RosterSetTask(pump_.get()->client());
+ rst->Remove(jid);
+ rst->Start();
+ }
+
+ void RemoveRosterItem(const buzz::Jid &jid) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ worker_thread_->Post(this, MSG_REMOVE_ROSTER_ITEM, new JidData(jid));
+ }
+
+ void DoCallbacks() {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ talk_base::Message m;
+ while (main_thread_->Get(&m, 0)) {
+ main_thread_->Dispatch(&m);
+ }
+ }
+
+ private:
+
+ struct UpdateRosterItemData : public talk_base::MessageData {
+ UpdateRosterItemData(const buzz::Jid &jid, const std::string &name,
+ const std::vector<std::string> &groups, buzz::GrType grt) :
+ jid_(jid), n_(name), g_(groups), grt_(grt) {}
+ buzz::Jid jid_;
+ std::string n_;
+ std::vector<std::string> g_;
+ buzz::GrType grt_;
+ };
+
+ void UpdateRosterItemW(const buzz::Jid &jid, const std::string &name,
+ const std::vector<std::string> &groups, buzz::GrType grt) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ buzz::RosterSetTask *rst = new buzz::RosterSetTask(pump_.get()->client());
+ rst->Update(jid, name, groups, grt);
+ rst->Start();
+ }
+
+ struct StringData : public talk_base::MessageData {
+ StringData(std::string s) : s_(s) {}
+ std::string s_;
+ };
+
+ void OnInputDebugW(const std::string &data) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ if (notify_)
+ notify_->OnXmppInput(data);
+ }
+
+ void OnInputDebug(const char *data, int len) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ main_thread_->Post(this, MSG_XMPP_INPUT, new StringData(std::string(data,len)));
+ if (notify_)
+ notify_->WakeupMainThread();
+ }
+
+ void OnOutputDebugW(const std::string &data) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ if (notify_)
+ notify_->OnXmppOutput(data);
+ }
+
+ void OnOutputDebug(const char *data, int len) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ main_thread_->Post(this, MSG_XMPP_OUTPUT, new StringData(std::string(data,len)));
+ if (notify_)
+ notify_->WakeupMainThread();
+ }
+
+ struct StateChangeData : public talk_base::MessageData {
+ StateChangeData(buzz::XmppEngine::State state) : s_(state) {}
+ buzz::XmppEngine::State s_;
+ };
+
+ void OnStateChange(buzz::XmppEngine::State state) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ switch (state) {
+ case buzz::XmppEngine::STATE_OPEN:
+ ppt_ = new buzz::PresencePushTask(pump_.get()->client());
+ ppt_->SignalStatusUpdate.connect(this,
+ &LibjinglePlusWorker::OnStatusUpdate);
+ ppt_->SignalStatusError.connect(this,
+ &LibjinglePlusWorker::OnStatusError);
+ ppt_->Start();
+
+ rmt_ = new buzz::ReceiveMessageTask(pump_.get()->client(), buzz::XmppEngine::HL_ALL);
+ rmt_->SignalIncomingMessage.connect(this, &LibjinglePlusWorker::OnIncomingMessage);
+ rmt_->Start();
+
+ rt_ = new buzz::RosterTask(pump_.get()->client());
+ rt_->SignalRosterItemUpdated.connect(this, &LibjinglePlusWorker::OnRosterItemUpdated);
+ rt_->SignalRosterItemRemoved.connect(this, &LibjinglePlusWorker::OnRosterItemRemoved);
+ rt_->SignalSubscribe.connect(this, &LibjinglePlusWorker::OnRosterSubscribe);
+ rt_->SignalUnsubscribe.connect(this, &LibjinglePlusWorker::OnRosterUnsubscribe);
+ rt_->SignalSubscribed.connect(this, &LibjinglePlusWorker::OnRosterSubscribed);
+ rt_->SignalUnsubscribed.connect(this, &LibjinglePlusWorker::OnRosterUnsubscribed);
+ rt_->SignalRosterRefreshStarted.connect(this, &LibjinglePlusWorker::OnRosterRefreshStarted);
+ rt_->SignalRosterRefreshFinished.connect(this, &LibjinglePlusWorker::OnRosterRefreshFinished);
+ rt_->Start();
+ rt_->RefreshRosterNow();
+
+ break;
+ }
+ main_thread_->Post(this, MSG_STATE_CHANGE, new StateChangeData(state));
+ if (notify_)
+ notify_->WakeupMainThread();
+ }
+
+ void OnStateChangeW(buzz::XmppEngine::State state) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ if (notify_)
+ notify_->OnStateChange(state);
+ }
+
+ struct RosterItemData : public talk_base::MessageData {
+ RosterItemData(const buzz::RosterItem &ri) : ri_(ri) {}
+ buzz::RosterItem ri_;
+ };
+
+ void OnRosterItemUpdatedW(const buzz::RosterItem &ri) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ if (notify_)
+ notify_->OnRosterItemUpdated(ri);
+ }
+
+ void OnRosterItemUpdated(const buzz::RosterItem &ri, bool huh) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ main_thread_->Post(this, MSG_ROSTER_ITEM_UPDATED, new RosterItemData(ri));
+ if (notify_)
+ notify_->WakeupMainThread();
+ }
+
+ void OnRosterItemRemovedW(const buzz::RosterItem &ri) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ if (notify_)
+ notify_->OnRosterItemRemoved(ri);
+ }
+
+ void OnRosterItemRemoved(const buzz::RosterItem &ri) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ main_thread_->Post(this, MSG_ROSTER_ITEM_REMOVED, new RosterItemData(ri));
+ if (notify_)
+ notify_->WakeupMainThread();
+ }
+
+ struct JidData : public talk_base::MessageData {
+ JidData(const buzz::Jid& jid) : jid_(jid) {}
+ const buzz::Jid jid_;
+ };
+
+ void OnRosterSubscribeW(const buzz::Jid& jid) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ if (notify_)
+ notify_->OnRosterSubscribe(jid);
+ }
+
+ void OnRosterSubscribe(const buzz::Jid& jid) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ main_thread_->Post(this, MSG_ROSTER_SUBSCRIBE, new JidData(jid));
+ if (notify_)
+ notify_->WakeupMainThread();
+ }
+
+ void OnRosterUnsubscribeW(const buzz::Jid &jid) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ if (notify_)
+ notify_->OnRosterUnsubscribe(jid);
+ }
+
+ void OnRosterUnsubscribe(const buzz::Jid &jid) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ main_thread_->Post(this, MSG_ROSTER_UNSUBSCRIBE, new JidData(jid));
+ if (notify_)
+ notify_->WakeupMainThread();
+ }
+
+ void OnRosterSubscribedW(const buzz::Jid &jid) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ if (notify_)
+ notify_->OnRosterSubscribed(jid);
+ }
+
+ void OnRosterSubscribed(const buzz::Jid &jid) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ main_thread_->Post(this, MSG_ROSTER_SUBSCRIBED, new JidData(jid));
+ if (notify_)
+ notify_->WakeupMainThread();
+ }
+
+ void OnRosterUnsubscribedW(const buzz::Jid &jid) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ if (notify_)
+ notify_->OnRosterUnsubscribed(jid);
+ }
+
+ void OnRosterUnsubscribed(const buzz::Jid &jid) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ main_thread_->Post(this, MSG_ROSTER_UNSUBSCRIBED, new JidData(jid));
+ if (notify_)
+ notify_->WakeupMainThread();
+ }
+
+ void OnRosterRefreshStartedW() {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ if (notify_)
+ notify_->OnRosterRefreshStarted();
+ }
+
+ void OnRosterRefreshStarted() {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ main_thread_->Post(this, MSG_ROSTER_REFRESH_STARTED);
+ if (notify_)
+ notify_->WakeupMainThread();
+ }
+
+ void OnRosterRefreshFinishedW() {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ if (notify_)
+ notify_->OnRosterRefreshFinished();
+ }
+
+ void OnRosterRefreshFinished() {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ main_thread_->Post(this, MSG_ROSTER_REFRESH_FINISHED);
+ if (notify_)
+ notify_->WakeupMainThread();
+ }
+
+ struct XmppMessageData : talk_base::MessageData {
+ XmppMessageData(const buzz::XmppMessage &m) : m_(m) {}
+ buzz::XmppMessage m_;
+ };
+
+ void OnIncomingMessageW(const buzz::XmppMessage &msg) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ if (notify_)
+ notify_->OnMessage(msg);
+ }
+
+ void OnIncomingMessage(const buzz::XmppMessage &msg) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ main_thread_->Post(this, MSG_INCOMING_MESSAGE, new XmppMessageData(msg));
+ if (notify_)
+ notify_->WakeupMainThread();
+ }
+
+ void OnStatusUpdateW (const buzz::Status &status) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ if (notify_)
+ notify_->OnStatusUpdate(status);
+ }
+
+ void OnStatusUpdate (const buzz::Status &status) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ main_thread_->Post(this, MSG_STATUS_UPDATE, new SendPresenceData(status));
+ if (notify_)
+ notify_->WakeupMainThread();
+ }
+
+ struct StatusErrorData : talk_base::MessageData {
+ StatusErrorData(const buzz::XmlElement &stanza) : stanza_(stanza) {}
+ buzz::XmlElement stanza_;
+ };
+
+ void OnStatusErrorW (const buzz::XmlElement &stanza) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ if (notify_)
+ notify_->OnStatusError(stanza);
+ }
+
+ void OnStatusError (const buzz::XmlElement &stanza) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ main_thread_->Post(this, MSG_STATUS_ERROR, new StatusErrorData(stanza));
+ if (notify_)
+ notify_->WakeupMainThread();
+ }
+
+ void LoginW() {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ XmppSocket* socket = new XmppSocket(true);
+ pump_->DoLogin(xcs_, socket, is_test_login_ ? NULL : new XmppAuth());
+ socket->SignalCloseEvent.connect(this,
+ &LibjinglePlusWorker::OnXmppSocketClose);
+ }
+
+ void DisconnectW() {
+ assert(talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ pump_->DoDisconnect();
+ }
+
+ void SendXmppMessageW(const buzz::XmppMessage &m) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ buzz::SendMessageTask * smt = new buzz::SendMessageTask(pump_.get()->client());
+ smt->Send(m);
+ smt->Start();
+ }
+
+ void SendXmppIqW(const buzz::Jid &to_jid, bool is_get,
+ const buzz::XmlElement *xml_element) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ buzz::IqTask *iq_task = new buzz::IqTask(pump_.get()->client(),
+ is_get, to_jid, const_cast<buzz::XmlElement *>(xml_element));
+ iq_task->SignalDone.connect(this, &LibjinglePlusWorker::OnIqComplete);
+ iq_task->Start();
+ }
+
+ struct IqCompleteData : public talk_base::MessageData {
+ IqCompleteData(bool success, const buzz::XmlElement *stanza) :
+ success_(success), stanza_(*stanza) {}
+ bool success_;
+ buzz::XmlElement stanza_;
+ };
+
+ void OnIqCompleteW(bool success, const buzz::XmlElement& stanza) {
+ assert(talk_base::ThreadManager::CurrentThread() != worker_thread_);
+ if (notify_)
+ notify_->OnIqDone(success, stanza);
+ }
+
+ void OnIqComplete(bool success, const buzz::XmlElement *stanza) {
+ assert(talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ main_thread_->Post(this, MSG_IQ_COMPLETE,
+ new IqCompleteData(success, stanza));
+ if (notify_)
+ notify_->WakeupMainThread();
+ }
+
+ void SendPresenceW(const buzz::Status & s) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ buzz::PresenceOutTask *pot = new buzz::PresenceOutTask(pump_.get()->client());
+ pot->Send(s);
+ pot->Start();
+ }
+
+
+ void SendDirectedMUCPresenceW(const buzz::Jid & j, const buzz::Status & s,
+ const std::string &user_nick, const std::string &api_capability,
+ const std::string &api_message, const std::string &role) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ buzz::PresenceOutTask *pot = new buzz::PresenceOutTask(pump_.get()->client());
+ pot->SendDirectedMUC(j,s,user_nick,api_capability,api_message, role);
+ pot->Start();
+ }
+
+ void SendDirectedPresenceW(const buzz::Jid & j, const buzz::Status & s) {
+ assert (talk_base::ThreadManager::CurrentThread() == worker_thread_);
+ buzz::PresenceOutTask *pot = new buzz::PresenceOutTask(pump_.get()->client());
+ pot->SendDirected(j,s);
+ pot->Start();
+ }
+
+ void OnXmppSocketClose(int error) {
+ notify_->OnSocketClose(error);
+ }
+
+ struct SendMessageData : public talk_base::MessageData {
+ SendMessageData(const buzz::XmppMessage &m) : m_(m) {}
+ buzz::XmppMessage m_;
+ };
+
+ struct SendIqData : public talk_base::MessageData {
+ SendIqData(const buzz::Jid &jid, bool is_get, const buzz::XmlElement *m)
+ : to_jid_(jid), is_get_(is_get), xml_element_(m) {}
+ buzz::Jid to_jid_;
+ bool is_get_;
+ const buzz::XmlElement *xml_element_;
+ };
+
+ struct SendPresenceData : public talk_base::MessageData {
+ SendPresenceData(const buzz::Status &s) : s_(s) {}
+ buzz::Status s_;
+ };
+
+ struct SendDirectedPresenceData : public talk_base::MessageData {
+ SendDirectedPresenceData(const buzz::Jid &j, const buzz::Status &s) : j_(j), s_(s) {}
+ buzz::Jid j_;
+ buzz::Status s_;
+ };
+
+ struct SendDirectedMUCPresenceData : public talk_base::MessageData {
+ SendDirectedMUCPresenceData(const buzz::Jid &j, const buzz::Status &s,
+ const std::string &un, const std::string &ac,
+ const std::string &am, const std::string &role)
+ : j_(j), s_(s), un_(un), ac_(ac), am_(am), role_(role) {}
+ buzz::Jid j_;
+ buzz::Status s_;
+ std::string un_;
+ std::string ac_;
+ std::string am_;
+ std::string role_;
+ };
+
+ talk_base::scoped_ptr<talk_base::Win32SocketServer> ss_;
+ talk_base::scoped_ptr<talk_base::Thread> main_thread_;
+ talk_base::Thread *worker_thread_;
+
+ LibjinglePlus *ljp_;
+ LibjinglePlusNotify *notify_;
+ buzz::XmppClientSettings xcs_;
+ talk_base::PhysicalSocketServer pss_;
+
+ talk_base::scoped_ptr<XmppPump> pump_;
+ buzz::PresencePushTask * ppt_;
+ buzz::ReceiveMessageTask * rmt_;
+ buzz::RosterTask * rt_;
+
+ bool is_test_login_;
+};
+
+LibjinglePlus::LibjinglePlus(LibjinglePlusNotify *notify)
+{
+ worker_ = new LibjinglePlusWorker(this, notify);
+}
+
+LibjinglePlus::~LibjinglePlus()
+{
+ delete worker_;
+ worker_ = NULL;
+}
+
+void LibjinglePlus::Login(const std::string &jid,
+ const std::string &password,
+ const std::string &machine_address,
+ bool is_test, bool cookie_auth) {
+ worker_->Login(jid, password, machine_address, is_test, cookie_auth);
+}
+
+void LibjinglePlus::SendPresence(const buzz::Status & s) {
+ worker_->SendPresence(s);
+}
+
+void LibjinglePlus::SendDirectedPresence(const buzz::Jid & j, const buzz::Status & s) {
+ worker_->SendDirectedPresence(j,s);
+}
+
+void LibjinglePlus::SendDirectedMUCPresence(const buzz::Jid & j,
+ const buzz::Status & s, const std::string &user_nick,
+ const std::string &api_capability, const std::string &api_message,
+ const std::string &role) {
+ worker_->SendDirectedMUCPresence(j,s,user_nick,api_capability,api_message,
+ role);
+}
+
+void LibjinglePlus::SendXmppMessage(const buzz::XmppMessage & m) {
+ worker_->SendXmppMessage(m);
+}
+
+void LibjinglePlus::SendXmppIq(const buzz::Jid &to_jid, bool is_get,
+ const buzz::XmlElement *iq_element) {
+ worker_->SendXmppIq(to_jid, is_get, iq_element);
+}
+
+void LibjinglePlus::DoCallbacks() {
+ worker_->DoCallbacks();
+}
diff --git a/talk/examples/plus/libjingleplus.h b/talk/examples/plus/libjingleplus.h
new file mode 100644
index 0000000..a2898f5
--- /dev/null
+++ b/talk/examples/plus/libjingleplus.h
@@ -0,0 +1,154 @@
+/*
+ * libjingle
+ * Copyright 2006, 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.
+ */
+
+// LibjinglePlus is a class that connects to Google Talk, creates
+// some common tasks, and emits signals when things change
+
+#ifndef LIBJINGLEPLUS_H__
+#define LIBJINGLEPLUS_H__
+
+#include "talk/base/basicdefs.h"
+#include "talk/app/rosteritem.h"
+#include "talk/app/message.h"
+#include "talk/app/status.h"
+#include "talk/xmpp/xmppengine.h"
+#include "talk/base/scoped_ptr.h"
+
+
+class LibjinglePlusWorker;
+
+class LibjinglePlusNotify {
+ public:
+ virtual ~LibjinglePlusNotify() {}
+
+ /* Libjingle+ works on its own thread. It will call WakeupMainThread
+ * when it has something to report. The main thread should then wake up,
+ * and call DoCallbacks on the LibjinglePlus object.
+ *
+ * This function gets called from libjingle+'s worker thread. All other
+ * methods in LibjinglePlusNotify get called from the thread you call
+ * DoCallbacks() on.
+ *
+ * If running on Windows, libjingle+ will use Windows messages to generate
+ * callbacks from the main thread, and you don't need to do anything here.
+ */
+ virtual void WakeupMainThread() = 0;
+
+ /* Connection */
+ /* Called when the connection state changes */
+ virtual void OnStateChange(buzz::XmppEngine::State) = 0;
+
+ /* Called when the socket closes */
+ virtual void OnSocketClose(int error_code) = 0;
+
+ /* Called when XMPP is being sent or received. Used for debugging */
+ virtual void OnXmppOutput(const std::string &output) = 0;
+ virtual void OnXmppInput(const std::string &input) = 0;
+
+ /* Presence */
+ /* Called when someone's Status is updated */
+ virtual void OnStatusUpdate(const buzz::Status &status) = 0;
+
+ /* Called when a status update results in an error */
+ virtual void OnStatusError(const buzz::XmlElement &stanza) = 0;
+
+ /* Called with an IQ return code */
+ virtual void OnIqDone(bool success, const buzz::XmlElement &stanza) = 0;
+
+ /* Message */
+ /* Called when a message comes in. */
+ virtual void OnMessage(const buzz::XmppMessage &message) = 0;
+
+ /* Roster */
+
+ /* Called when we start refreshing the roster */
+ virtual void OnRosterRefreshStarted() = 0;
+ /* Called when we have the entire roster */
+ virtual void OnRosterRefreshFinished() = 0;
+ /* Called when an item on the roster is created or updated */
+ virtual void OnRosterItemUpdated(const buzz::RosterItem &ri) = 0;
+ /* Called when an item on the roster is removed */
+ virtual void OnRosterItemRemoved(const buzz::RosterItem &ri) = 0;
+
+ /* Subscriptions */
+ virtual void OnRosterSubscribe(const buzz::Jid &jid) = 0;
+ virtual void OnRosterUnsubscribe(const buzz::Jid &jid) = 0;
+ virtual void OnRosterSubscribed(const buzz::Jid &jid) = 0;
+ virtual void OnRosterUnsubscribed(const buzz::Jid &jid) = 0;
+
+};
+
+class LibjinglePlus
+{
+ public:
+ /* Provide the constructor with your interface. */
+ LibjinglePlus(LibjinglePlusNotify *notify);
+ ~LibjinglePlus();
+
+ /* Logs in and starts doing stuff
+ *
+ * If cookie_auth is true, password must be a Gaia SID. Otherwise,
+ * it should be the user's password
+ */
+ void Login(const std::string &username, const std::string &password,
+ const std::string &machine_address, bool is_test, bool cookie_auth);
+
+ /* Set Presence */
+ void SendPresence(const buzz::Status & s);
+ void SendDirectedPresence(const buzz::Jid & j, const buzz::Status & s);
+ void SendDirectedMUCPresence(const buzz::Jid & j, const buzz::Status & s,
+ const std::string &user_nick, const std::string &api_capability,
+ const std::string &api_message, const std::string &role);
+
+ /* Send Message */
+ void SendXmppMessage(const buzz::XmppMessage & m);
+
+ /* Send IQ */
+ void SendXmppIq(const buzz::Jid &to_jid, bool is_get,
+ const buzz::XmlElement *iq_element);
+
+ /* Set Roster */
+ void UpdateRosterItem(const buzz::Jid & jid, const std::string & name,
+ const std::vector<std::string> & groups, buzz::GrType grt);
+ void RemoveRosterItem(const buzz::Jid &jid);
+
+ /* Call this from the thread you want to receive callbacks on. Typically, this will be called
+ * after your WakeupMainThread() notify function is called.
+ *
+ * On Windows, libjingle+ will trigger its callback from the Windows message loop, and
+ * you needn't call this yourself.
+ */
+ void DoCallbacks();
+
+ private:
+ void LoginInternal(const std::string &jid, const std::string &password,
+ const std::string &machine_address, bool is_test);
+
+ LibjinglePlusWorker *worker_;
+};
+
+#endif // LIBJINGLE_PLUS_H__
diff --git a/talk/examples/plus/presencepushtask.cc b/talk/examples/plus/presencepushtask.cc
new file mode 100644
index 0000000..9d5ed28
--- /dev/null
+++ b/talk/examples/plus/presencepushtask.cc
@@ -0,0 +1,201 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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/base/stringencode.h"
+#include "presencepushtask.h"
+#include "talk/xmpp/constants.h"
+#include <sstream>
+
+
+namespace buzz {
+
+// string helper functions -----------------------------------------------------
+
+static bool
+IsXmlSpace(int ch) {
+ return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
+}
+
+static bool
+ListContainsToken(const std::string & list, const std::string & token) {
+ size_t i = list.find(token);
+ if (i == std::string::npos || token.empty())
+ return false;
+ bool boundary_before = (i == 0 || IsXmlSpace(list[i - 1]));
+ bool boundary_after = (i == list.length() - token.length() || IsXmlSpace(list[i + token.length()]));
+ return boundary_before && boundary_after;
+}
+
+
+bool
+PresencePushTask::HandleStanza(const XmlElement * stanza) {
+ if (stanza->Name() != QN_PRESENCE)
+ return false;
+ if (stanza->HasAttr(QN_TYPE) && stanza->Attr(QN_TYPE) != STR_UNAVAILABLE) {
+ if (stanza->Attr(QN_TYPE) == STR_ERROR) {
+ // Pass on the error.
+ const XmlElement* error_xml_elem = stanza->FirstNamed(QN_ERROR);
+ if (!error_xml_elem) {
+ return false;
+ }
+ SignalStatusError(*error_xml_elem);
+ return true;
+ }
+ }
+ QueueStanza(stanza);
+ return true;
+}
+
+static bool IsUtf8FirstByte(int c) {
+ return (((c)&0x80)==0) || // is single byte
+ ((unsigned char)((c)-0xc0)<0x3e); // or is lead byte
+}
+
+int
+PresencePushTask::ProcessStart() {
+ const XmlElement * stanza = NextStanza();
+ if (stanza == NULL)
+ return STATE_BLOCKED;
+ Status s;
+
+ s.set_jid(Jid(stanza->Attr(QN_FROM)));
+
+ if (stanza->Attr(QN_TYPE) == STR_UNAVAILABLE) {
+ s.set_available(false);
+ SignalStatusUpdate(s);
+ }
+ else {
+ s.set_available(true);
+ const XmlElement * status = stanza->FirstNamed(QN_STATUS);
+ if (status != NULL) {
+ s.set_status(status->BodyText());
+
+ // Truncate status messages longer than 300 bytes
+ if (s.status().length() > 300) {
+ size_t len = 300;
+
+ // Be careful not to split legal utf-8 chars in half
+ while (!IsUtf8FirstByte(s.status()[len]) && len > 0) {
+ len -= 1;
+ }
+ std::string truncated(s.status(), 0, len);
+ s.set_status(truncated);
+ }
+ }
+
+ const XmlElement * priority = stanza->FirstNamed(QN_PRIORITY);
+ if (priority != NULL) {
+ int pri;
+ if (talk_base::FromString(priority->BodyText(), &pri)) {
+ s.set_priority(pri);
+ }
+ }
+
+ const XmlElement * show = stanza->FirstNamed(QN_SHOW);
+ if (show == NULL || show->FirstChild() == NULL) {
+ s.set_show(Status::SHOW_ONLINE);
+ }
+ else {
+ if (show->BodyText() == "away") {
+ s.set_show(Status::SHOW_AWAY);
+ }
+ else if (show->BodyText() == "xa") {
+ s.set_show(Status::SHOW_XA);
+ }
+ else if (show->BodyText() == "dnd") {
+ s.set_show(Status::SHOW_DND);
+ }
+ else if (show->BodyText() == "chat") {
+ s.set_show(Status::SHOW_CHAT);
+ }
+ else {
+ s.set_show(Status::SHOW_ONLINE);
+ }
+ }
+
+ const XmlElement * caps = stanza->FirstNamed(QN_CAPS_C);
+ if (caps != NULL) {
+ std::string node = caps->Attr(QN_NODE);
+ std::string ver = caps->Attr(QN_VER);
+ std::string exts = caps->Attr(QN_EXT);
+
+ s.set_know_capabilities(true);
+ std::string capability;
+ std::stringstream ss(exts);
+ while (ss >> capability) {
+ s.AddCapability(capability);
+ }
+
+ s->set_caps_node(node);
+ s->set_version(ver);
+ }
+
+ const XmlElement* delay = stanza->FirstNamed(kQnDelayX);
+ if (delay != NULL) {
+ // Ideally we would parse this according to the Psuedo ISO-8601 rules
+ // that are laid out in JEP-0082:
+ // http://www.jabber.org/jeps/jep-0082.html
+ std::string stamp = delay->Attr(kQnStamp);
+ s.set_sent_time(stamp);
+ }
+
+ const XmlElement *nick = stanza->FirstNamed(kQnNickname);
+ if (nick) {
+ std::string user_nick = nick->BodyText();
+ s.set_user_nick(user_nick);
+ }
+
+ const XmlElement *plugin = stanza->FirstNamed(QN_PLUGIN);
+ if (plugin) {
+ const XmlElement *api_cap = plugin->FirstNamed(QN_CAPABILITY);
+ if (api_cap) {
+ const std::string &api_capability = api_cap->BodyText();
+ s.set_api_capability(api_capability);
+ }
+ const XmlElement *api_msg = plugin->FirstNamed(QN_DATA);
+ if (api_msg) {
+ const std::string &api_message = api_msg->BodyText();
+ s.set_api_message(api_message);
+ }
+ }
+
+ const XmlElement* data_x = stanza->FirstNamed(QN_MUC_USER_X);
+ if (data_x != NULL) {
+ const XmlElement* item = data_x->FirstNamed(QN_MUC_USER_ITEM);
+ if (item != NULL) {
+ s.set_muc_role(item->Attr(QN_ROLE));
+ }
+ }
+
+ SignalStatusUpdate(s);
+ }
+
+ return STATE_START;
+}
+
+
+}
diff --git a/talk/examples/plus/presencepushtask.h b/talk/examples/plus/presencepushtask.h
new file mode 100644
index 0000000..b9c8038
--- /dev/null
+++ b/talk/examples/plus/presencepushtask.h
@@ -0,0 +1,53 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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 _PRESENCEPUSHTASK_H_
+#define _PRESENCEPUSHTASK_H_
+
+#include "talk/xmpp/xmppengine.h"
+#include "talk/xmpp/xmpptask.h"
+#include "talk/base/sigslot.h"
+#include "talk/app/status.h"
+
+namespace buzz {
+
+class PresencePushTask : public XmppTask {
+
+public:
+ PresencePushTask(Task * parent) : XmppTask(parent, XmppEngine::HL_TYPE) {}
+ virtual int ProcessStart();
+ sigslot::signal1<const Status &>SignalStatusUpdate;
+ sigslot::signal1<const XmlElement &> SignalStatusError;
+
+protected:
+ virtual bool HandleStanza(const XmlElement * stanza);
+};
+
+
+}
+
+#endif
diff --git a/talk/examples/plus/rostertask.cc b/talk/examples/plus/rostertask.cc
new file mode 100644
index 0000000..1344d08
--- /dev/null
+++ b/talk/examples/plus/rostertask.cc
@@ -0,0 +1,218 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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 "rostertask.h"
+#include "talk/xmpp/constants.h"
+#include "talk/base/stream.h"
+
+#undef WIN32
+#ifdef WIN32
+#include "talk/app/win32/offlineroster.h"
+#endif
+
+namespace buzz {
+
+class RosterTask::RosterGetTask : public XmppTask {
+public:
+ RosterGetTask(Task * parent) : XmppTask(parent, XmppEngine::HL_SINGLE),
+ done_(false) {}
+
+ virtual int ProcessStart();
+ virtual int ProcessResponse();
+
+protected:
+ virtual bool HandleStanza(const XmlElement * stanza);
+
+ bool done_;
+};
+
+//==============================================================================
+// RosterTask
+//==============================================================================
+void RosterTask::RefreshRosterNow() {
+ RosterGetTask* get_task = new RosterGetTask(this);
+ ResumeTimeout();
+ get_task->Start();
+}
+
+void RosterTask::TranslateItems(const XmlElement * rosterQueryResult) {
+#if defined(FEATURE_ENABLE_PSTN)
+#ifdef WIN32
+ // We build up a list of contacts which have had information persisted offline.
+ // we'll remove items from this list if we get a buzz::SUBSCRIBE_REMOVE
+ // subscription. After updating all the items from the server, we'll then
+ // update (and merge) any roster items left in our map of offline items
+ XmlElement *el_local = OfflineRoster::RetrieveOfflineRoster(GetClient()->jid());
+ std::map<buzz::Jid, RosterItem> jid_to_item;
+ if (el_local) {
+ for (XmlElement *el_item = el_local->FirstNamed(QN_ROSTER_ITEM);
+ el_item != NULL;
+ el_item = el_item->NextNamed(QN_ROSTER_ITEM)) {
+ RosterItem roster_item;
+ roster_item.FromXml(el_item);
+
+ jid_to_item[roster_item.jid()] = roster_item;
+ }
+ }
+#endif // WIN32
+#endif // FEATURE_ENABLE_PSTN
+
+ const XmlElement * xml_item;
+ for (xml_item = rosterQueryResult->FirstNamed(QN_ROSTER_ITEM);
+ xml_item != NULL; xml_item = xml_item->NextNamed(QN_ROSTER_ITEM)) {
+ RosterItem roster_item;
+ roster_item.FromXml(xml_item);
+
+ if (roster_item.subscription() == buzz::SUBSCRIBE_REMOVE) {
+ SignalRosterItemRemoved(roster_item);
+
+#if defined(FEATURE_ENABLE_PSTN)
+#ifdef WIN32
+ std::map<buzz::Jid, RosterItem>::iterator it =
+ jid_to_item.find(roster_item.jid());
+
+ if (it != jid_to_item.end())
+ jid_to_item.erase(it);
+#endif
+#endif
+ } else {
+ SignalRosterItemUpdated(roster_item, false);
+ }
+ }
+
+#if defined(FEATURE_ENABLE_PSTN)
+#ifdef WIN32
+ for (std::map<buzz::Jid, RosterItem>::iterator it = jid_to_item.begin();
+ it != jid_to_item.end(); ++it) {
+ SignalRosterItemUpdated(it->second, true);
+ }
+#endif
+#endif
+}
+
+int RosterTask::ProcessStart() {
+ const XmlElement * stanza = NextStanza();
+ if (stanza == NULL)
+ return STATE_BLOCKED;
+
+ if (stanza->Name() == QN_IQ) {
+ SuspendTimeout();
+ bool result = (stanza->Attr(QN_TYPE) == STR_RESULT);
+ if (result)
+ SignalRosterRefreshStarted();
+
+ TranslateItems(stanza->FirstNamed(QN_ROSTER_QUERY));
+
+ if (result)
+ SignalRosterRefreshFinished();
+ } else if (stanza->Name() == QN_PRESENCE) {
+ Jid jid(stanza->Attr(QN_FROM));
+ std::string type = stanza->Attr(QN_TYPE);
+ if (type == "subscribe")
+ SignalSubscribe(jid);
+ else if (type == "unsubscribe")
+ SignalUnsubscribe(jid);
+ else if (type == "subscribed")
+ SignalSubscribed(jid);
+ else if (type == "unsubscribed")
+ SignalUnsubscribed(jid);
+ }
+
+ return STATE_START;
+}
+
+bool RosterTask::HandleStanza(const XmlElement * stanza) {
+ if (!MatchRequestIq(stanza, STR_SET, QN_ROSTER_QUERY)) {
+ // Not a roster IQ. Look for a presence instead
+ if (stanza->Name() != QN_PRESENCE)
+ return false;
+ if (!stanza->HasAttr(QN_TYPE))
+ return false;
+ std::string type = stanza->Attr(QN_TYPE);
+ if (type == "subscribe" || type == "unsubscribe" ||
+ type == "subscribed" || type == "unsubscribed") {
+ QueueStanza(stanza);
+ return true;
+ }
+ return false;
+ }
+
+ // only respect roster push from the server
+ Jid from(stanza->Attr(QN_FROM));
+ if (from != JID_EMPTY &&
+ !from.BareEquals(GetClient()->jid()) &&
+ from != Jid(GetClient()->jid().domain()))
+ return false;
+
+ XmlElement * result = MakeIqResult(stanza);
+ result->AddElement(new XmlElement(QN_ROSTER_QUERY, true));
+ SendStanza(result);
+
+ QueueStanza(stanza);
+ return true;
+}
+
+
+//==============================================================================
+// RosterTask::RosterGetTask
+//==============================================================================
+int RosterTask::RosterGetTask::ProcessStart() {
+ talk_base::scoped_ptr<XmlElement> get(MakeIq(STR_GET, JID_EMPTY, task_id()));
+ get->AddElement(new XmlElement(QN_ROSTER_QUERY, true));
+ get->AddAttr(QN_XMLNS_GR, NS_GR, 1);
+ get->AddAttr(QN_GR_EXT, "2", 1);
+ get->AddAttr(QN_GR_INCLUDE, "all", 1);
+ if (SendStanza(get.get()) != XMPP_RETURN_OK) {
+ return STATE_ERROR;
+ }
+ return STATE_RESPONSE;
+}
+
+int RosterTask::RosterGetTask::ProcessResponse() {
+ if (done_)
+ return STATE_DONE;
+ return STATE_BLOCKED;
+}
+
+bool RosterTask::RosterGetTask::HandleStanza(const XmlElement * stanza) {
+ if (!MatchResponseIq(stanza, JID_EMPTY, task_id()))
+ return false;
+
+ if (stanza->Attr(QN_TYPE) != STR_RESULT)
+ return false;
+
+ // Queue the stanza with the parent so these don't get handled out of order
+ RosterTask* parent = static_cast<RosterTask*>(GetParent());
+ parent->QueueStanza(stanza);
+
+ // Wake ourselves so we can go into the done state
+ done_ = true;
+ Wake();
+ return true;
+}
+
+}
diff --git a/talk/examples/plus/rostertask.h b/talk/examples/plus/rostertask.h
new file mode 100644
index 0000000..beab1f9
--- /dev/null
+++ b/talk/examples/plus/rostertask.h
@@ -0,0 +1,72 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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 _PHONE_CLIENT_ROSTERTASK_H_
+#define _PHONE_CLIENT_ROSTERTASK_H_
+
+#include "talk/xmpp/xmppclient.h"
+#include "talk/xmpp/xmpptask.h"
+#include "talk/app/rosteritem.h"
+#include "talk/base/sigslot.h"
+
+namespace buzz {
+
+class RosterTask : public XmppTask {
+public:
+ RosterTask(Task * parent) :
+ XmppTask(parent, XmppEngine::HL_TYPE) {}
+
+ // Roster items removed or updated. This can come from a push or a get
+ sigslot::signal2<const RosterItem &, bool> SignalRosterItemUpdated;
+ sigslot::signal1<const RosterItem &> SignalRosterItemRemoved;
+
+ // Subscription messages
+ sigslot::signal1<const Jid &> SignalSubscribe;
+ sigslot::signal1<const Jid &> SignalUnsubscribe;
+ sigslot::signal1<const Jid &> SignalSubscribed;
+ sigslot::signal1<const Jid &> SignalUnsubscribed;
+
+ // Roster get
+ void RefreshRosterNow();
+ sigslot::signal0<> SignalRosterRefreshStarted;
+ sigslot::signal0<> SignalRosterRefreshFinished;
+
+ virtual int ProcessStart();
+
+protected:
+ void TranslateItems(const XmlElement *rosterQueryResult);
+
+ virtual bool HandleStanza(const XmlElement * stanza);
+
+ // Inner class for doing the roster get
+ class RosterGetTask;
+ friend class RosterGetTask;
+};
+
+}
+
+#endif // _PHONE_CLIENT_ROSTERTASK_H_
diff --git a/talk/examples/plus/testutil/libjingleplus_main.cc b/talk/examples/plus/testutil/libjingleplus_main.cc
new file mode 100644
index 0000000..b5a0686
--- /dev/null
+++ b/talk/examples/plus/testutil/libjingleplus_main.cc
@@ -0,0 +1,119 @@
+/*
+ * libjingle
+ * Copyright 2006, 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 <iostream>
+#include <string>
+
+#include "talk/base/thread.h"
+#include "talk/libjingle-plus/libjingleplus.h"
+#include "talk/libjingle-plus/testutil/libjingleplus_test_notifier.h"
+
+#if defined(_MSC_VER) && (_MSC_VER < 1400)
+void __cdecl std::_Throw(const std::exception &) {}
+std::_Prhand std::_Raise_handler =0;
+#endif
+
+
+void SetConsoleEcho(bool on) {
+#ifdef WIN32
+ HANDLE hIn = GetStdHandle(STD_INPUT_HANDLE);
+ if ((hIn == INVALID_HANDLE_VALUE) || (hIn == NULL))
+ return;
+
+ DWORD mode;
+ if (!GetConsoleMode(hIn, &mode))
+ return;
+
+ if (on) {
+ mode = mode | ENABLE_ECHO_INPUT;
+ } else {
+ mode = mode & ~ENABLE_ECHO_INPUT;
+ }
+
+ SetConsoleMode(hIn, mode);
+#else
+ if (on)
+ system("stty echo");
+ else
+ system("stty -echo");
+#endif
+}
+
+int main (int argc, char **argv)
+{
+ std::string username;
+ std::string password;
+
+ bool gaia = false;
+
+ for (int i = 1; i < argc; i++) {
+ if (!strcmp(argv[i], "-gaia"))
+ gaia = true;
+ }
+
+ std::cout << "Username: ";
+ std::cin >> username;
+ std::cout << (gaia ? "Gaia cookie: " : "Password: ");
+ SetConsoleEcho(false);
+ std::cin >> password;
+ SetConsoleEcho(true);
+
+ // Create a LibjinglePlus object and give it the notifier interface
+ LibjinglePlus ljp(new Notifier);
+
+ // Login
+ ljp.Login(username, password, "talk.google.com", false, gaia);
+
+ buzz::Status s;
+ s.set_available(true);
+ s.set_show(buzz::Status::SHOW_ONLINE);
+ s.set_status("I'm online.");
+
+ buzz::XmppMessage m;
+ m.set_to(buzz::Jid(username + "@gmail.com"));
+ m.set_body("What's up?");
+
+ // Typically, you would wait for WakeupMainThread to be called, and then call
+ // DoCallbacks. Because I have nothing else to do on the main thread, I'm just going
+ // to do a few things after 10 seconds and then poll every 2ms.
+ Sleep(10000);
+ // ljp.DoCallbacks();
+ ljp.SendPresence(s);
+ ljp.SendXmppMessage(m);
+
+#ifdef WIN32
+ MSG msg;
+ while (GetMessage(&msg, NULL, 0, 0)) {
+ DispatchMessage(&msg);
+ }
+#else
+ for (;;) {
+ ljp.DoCallbacks();
+ Sleep(2);
+ }
+#endif
+}
diff --git a/talk/examples/plus/testutil/libjingleplus_test_notifier.h b/talk/examples/plus/testutil/libjingleplus_test_notifier.h
new file mode 100644
index 0000000..3a1af55
--- /dev/null
+++ b/talk/examples/plus/testutil/libjingleplus_test_notifier.h
@@ -0,0 +1,101 @@
+/*
+ * libjingle
+ * Copyright 2006, 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 <iostream>
+#include <string>
+
+#include "talk/libjingle-plus/libjingleplus.h"
+
+class Notifier : virtual public LibjinglePlusNotify {
+ virtual void OnStateChange(buzz::XmppEngine::State state) {
+ std::cout << "State change: " << state << std::endl;
+ }
+
+ virtual void OnSocketClose(int error_code) {
+ std::cout << "Socket close: " << error_code << std::endl;
+ }
+
+ virtual void OnXmppOutput(const std::string &output) {
+ std::cout << ">>>>>>>>" << std::endl << output << std::endl << ">>>>>>>>" << std::endl;
+ }
+
+ virtual void OnXmppInput(const std::string &input) {
+ std::cout << "<<<<<<<<" << std::endl << input << std::endl << "<<<<<<<<" << std::endl;
+ }
+
+
+ virtual void OnStatusUpdate(const buzz::Status &status) {
+ std::string from = status.jid().Str();
+ std::cout << from << " - " << status.status() << std::endl;
+ }
+
+ virtual void OnStatusError(const buzz::XmlElement &stanza) {
+ }
+
+ virtual void OnIqDone(bool success, const buzz::XmlElement &stanza) {
+ }
+
+ virtual void OnMessage(const buzz::XmppMessage &m) {
+ if (m.body() != "")
+ std::cout << m.from().Str() << ": " << m.body() << std::endl;
+ }
+
+ void OnRosterItemUpdated(const buzz::RosterItem &ri) {
+ std::cout << "Roster item: " << ri.jid().Str() << std::endl;
+ }
+
+ virtual void OnRosterItemRemoved(const buzz::RosterItem &ri) {
+ std::cout << "Roster item removed: " << ri.jid().Str() << std::endl;
+ }
+
+ virtual void OnRosterSubscribe(const buzz::Jid& jid) {
+ std::cout << "Subscribing: " << jid.Str() << std::endl;
+ }
+
+ virtual void OnRosterUnsubscribe(const buzz::Jid &jid) {
+ std::cout << "Unsubscribing: " <<jid.Str() << std::endl;
+ }
+
+ virtual void OnRosterSubscribed(const buzz::Jid &jid) {
+ std::cout << "Subscribed: " << jid.Str() << std::endl;
+ }
+
+ virtual void OnRosterUnsubscribed(const buzz::Jid &jid) {
+ std::cout << "Unsubscribed: " << jid.Str() << std::endl;
+ }
+
+ virtual void OnRosterRefreshStarted() {
+ std::cout << "Refreshing roster." << std::endl;
+ }
+
+ virtual void OnRosterRefreshFinished() {
+ std::cout << "Roster refreshed." << std::endl;
+ }
+
+ virtual void WakeupMainThread() {
+ }
+};
diff --git a/talk/examples/plus/testutil/libjingleplus_unittest.cc b/talk/examples/plus/testutil/libjingleplus_unittest.cc
new file mode 100644
index 0000000..d7f6325
--- /dev/null
+++ b/talk/examples/plus/testutil/libjingleplus_unittest.cc
@@ -0,0 +1,52 @@
+/*
+ * libjingle
+ * Copyright 2006, 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 "testing/base/gunit.h"
+#include "talk/libjingle-plus/libjingleplus.h"
+#include "talk/libjingle-plus/testutil/libjingleplus_test_notifier.h"
+
+#if defined(_MSC_VER) && (_MSC_VER < 1400)
+void __cdecl std::_Throw(const std::exception &) {}
+std::_Prhand std::_Raise_handler =0;
+#endif
+
+namespace talk_base {
+
+TEST(LibjingleTest, ConstructDestruct) {
+ for (int i = 0; i < 5; ++i) {
+ LibjinglePlus *libjingleplus = new LibjinglePlus(new Notifier);
+ libjingleplus->Login("eaterleaver0", "Buzzt3st", "talk.google.com", false, false);
+
+ delete libjingleplus;
+ }
+}
+}
+
+int main(int argc, char** argv) {
+ testing::ParseGUnitFlags(&argc, argv);
+ return RUN_ALL_TESTS();
+}
diff --git a/talk/libjingle.scons b/talk/libjingle.scons
index bfd82b0..ff073a0 100644
--- a/talk/libjingle.scons
+++ b/talk/libjingle.scons
@@ -26,10 +26,14 @@
],
includedirs = [
"third_party/gtest/include",
+ "third_party/expat-2.0.1/lib",
+ "third_party/srtp",
"third_party/gtest",
],
cppdefines = [
"LIBJINGLE_UNITTEST",
+ "EXPAT_RELATIVE_PATH",
+ "SRTP_RELATIVE_PATH",
],
)
talk.Library(env, name = "srtp",
@@ -70,19 +74,16 @@
lin_srcs = [
"base/latebindingsymboltable.cc",
"base/linux.cc",
+ "base/linuxfdwalk.c",
+ "base/libdbusglibsymboltable.cc",
"session/phone/libudevsymboltable.cc",
+ "session/phone/linuxdevicemanager.cc",
"session/phone/v4llookup.cc",
"sound/alsasoundsystem.cc",
"sound/alsasymboltable.cc",
"sound/linuxsoundsystem.cc",
- "sound/nullsoundsystem.cc",
- "sound/nullsoundsystemfactory.cc",
"sound/pulseaudiosoundsystem.cc",
"sound/pulseaudiosymboltable.cc",
- "sound/platformsoundsystem.cc",
- "sound/platformsoundsystemfactory.cc",
- "sound/soundsysteminterface.cc",
- "sound/soundsystemproxy.cc",
],
dependent_target_settings = {
'lin_libs': [
@@ -100,13 +101,17 @@
"base/macconversion.cc",
"base/macsocketserver.cc",
"base/macutils.cc",
+ "base/macwindowpicker.cc",
+ "base/scoped_autorelease_pool.mm",
"session/phone/carbonvideorenderer.cc",
- "session/phone/devicemanager_mac.mm",
+ "session/phone/macdevicemanager.cc",
+ "session/phone/macdevicemanagermm.mm",
],
posix_srcs = [
"base/unixfilesystem.cc",
"base/opensslidentity.cc",
"base/opensslstreamadapter.cc",
+ "base/posix.cc",
"base/sslidentity.cc",
"base/sslstreamadapter.cc",
],
@@ -127,13 +132,17 @@
"base/asynctcpsocket.cc",
"base/asyncudpsocket.cc",
"base/autodetectproxy.cc",
+ "base/bandwidthsmoother.cc",
"base/base64.cc",
"base/basicpacketsocketfactory.cc",
"base/bytebuffer.cc",
"base/checks.cc",
"base/common.cc",
+ "base/cpuid.cc",
+ "base/cpumonitor.cc",
"base/diskcache.cc",
"base/event.cc",
+ "base/filelock.cc",
"base/fileutils.cc",
"base/firewallsocketserver.cc",
"base/flags.cc",
@@ -144,18 +153,26 @@
"base/httpcommon.cc",
"base/httprequest.cc",
"base/httpserver.cc",
+ "base/ipaddress.cc",
"base/logging.cc",
"base/md5c.c",
"base/messagehandler.cc",
"base/messagequeue.cc",
+ "base/multipart.cc",
+ "base/natserver.cc",
+ "base/natsocketfactory.cc",
+ "base/nattypes.cc",
"base/nethelpers.cc",
"base/network.cc",
"base/openssladapter.cc",
+ "base/optionsfile.cc",
"base/pathutils.cc",
"base/physicalsocketserver.cc",
"base/proxydetect.cc",
"base/proxyinfo.cc",
+ "base/proxyserver.cc",
"base/ratetracker.cc",
+ "base/sharedexclusivelock.cc",
"base/signalthread.cc",
"base/socketadapters.cc",
"base/socketaddress.cc",
@@ -168,18 +185,27 @@
"base/stringdigest.cc",
"base/stringencode.cc",
"base/stringutils.cc",
+ "base/systeminfo.cc",
"base/task.cc",
"base/taskparent.cc",
"base/taskrunner.cc",
+ "base/testclient.cc",
"base/thread.cc",
- "base/time.cc",
+ "base/timeutils.cc",
+ "base/timing.cc",
+ "base/transformadapter.cc",
"base/urlencode.cc",
+ "base/versionparsing.cc",
+ "base/virtualsocketserver.cc",
"base/worker.cc",
"p2p/base/constants.cc",
"p2p/base/p2ptransport.cc",
"p2p/base/p2ptransportchannel.cc",
"p2p/base/parsing.cc",
"p2p/base/port.cc",
+ "p2p/base/portallocator.cc",
+ "p2p/base/portallocatorsessionproxy.cc",
+ "p2p/base/portproxy.cc",
"p2p/base/pseudotcp.cc",
"p2p/base/relayport.cc",
"p2p/base/relayserver.cc",
@@ -199,6 +225,7 @@
"p2p/base/transportchannelproxy.cc",
"p2p/base/udpport.cc",
"p2p/client/basicportallocator.cc",
+ "p2p/client/connectivitychecker.cc",
"p2p/client/httpportallocator.cc",
"p2p/client/socketmonitor.cc",
"session/tunnel/pseudotcpchannel.cc",
@@ -211,11 +238,14 @@
"session/phone/codec.cc",
"session/phone/currentspeakermonitor.cc",
"session/phone/devicemanager.cc",
+ "session/phone/dummydevicemanager.cc",
"session/phone/filemediaengine.cc",
"session/phone/gipsmediaengine.cc",
+ "session/phone/filevideocapturer.cc",
"session/phone/mediaengine.cc",
"session/phone/mediamessages.cc",
"session/phone/mediamonitor.cc",
+ "session/phone/mediarecorder.cc",
"session/phone/mediasession.cc",
"session/phone/mediasessionclient.cc",
"session/phone/rtpdump.cc",
@@ -223,6 +253,18 @@
"session/phone/rtcpmuxfilter.cc",
"session/phone/soundclip.cc",
"session/phone/srtpfilter.cc",
+ "session/phone/ssrcmuxfilter.cc",
+ "session/phone/streamparams.cc",
+ "session/phone/videoadapter.cc",
+ "session/phone/videocapturer.cc",
+ "session/phone/videocommon.cc",
+ "session/phone/videoframe.cc",
+ "sound/nullsoundsystem.cc",
+ "sound/nullsoundsystemfactory.cc",
+ "sound/platformsoundsystem.cc",
+ "sound/platformsoundsystemfactory.cc",
+ "sound/soundsysteminterface.cc",
+ "sound/soundsystemproxy.cc",
"xmllite/qname.cc",
"xmllite/xmlbuilder.cc",
"xmllite/xmlconstants.cc",
@@ -234,11 +276,13 @@
"xmpp/hangoutpubsubclient.cc",
"xmpp/iqtask.cc",
"xmpp/jid.cc",
+ "xmpp/moduleimpl.cc",
"xmpp/mucroomconfigtask.cc",
+ "xmpp/mucroomhistorytask.cc",
"xmpp/mucroomlookuptask.cc",
"xmpp/pubsubclient.cc",
+ "xmpp/pubsub_task.cc",
"xmpp/pubsubtasks.cc",
- "xmpp/ratelimitmanager.cc",
"xmpp/receivetask.cc",
"xmpp/saslmechanism.cc",
"xmpp/xmppclient.cc",
@@ -253,24 +297,36 @@
"third_party/expat-2.0.1/lib",
"third_party/srtp/include",
"third_party/srtp/crypto/include",
+ "third_party/openssl/include",
],
win_srcs = [
+ "base/diskcache_win32.cc",
"base/schanneladapter.cc",
"base/win32.cc",
+ "base/win32regkey.cc",
"base/win32filesystem.cc",
"base/win32securityerrors.cc",
"base/win32socketserver.cc",
"base/win32socketinit.cc",
"base/win32window.cc",
+ "base/win32windowpicker.cc",
"base/winfirewall.cc",
"base/winping.cc",
+ "session/phone/win32devicemanager.cc",
"session/phone/gdivideorenderer.cc",
],
mac_ccflags = [
"-Wno-deprecated-declarations",
],
extra_srcs = [
+ "base/dbus.cc",
"base/json.cc",
+ "base/linuxwindowpicker.cc",
+ "base/natserver_main.cc",
+ "base/maccocoasocketserver.mm",
+ "base/maccocoathreadhelper.mm",
+ "xmpp/chatroommoduleimpl.cc",
+ "xmpp/rostermoduleimpl.cc",
],
)
talk.Library(env, name = "xmpphelp",
@@ -278,6 +334,7 @@
"jingle",
],
srcs = [
+ "examples/login/jingleinfotask.cc",
"examples/login/xmppauth.cc",
"examples/login/xmpppump.cc",
"examples/login/xmppsocket.cc",
@@ -293,10 +350,14 @@
],
includedirs = [
"third_party/gtest/include",
+ "third_party/expat-2.0.1/lib",
+ "third_party/srtp",
"third_party/gtest",
],
cppdefines = [
"LIBJINGLE_UNITTEST",
+ "EXPAT_RELATIVE_PATH",
+ "SRTP_RELATIVE_PATH",
],
)
talk.App(env, name = "login",
@@ -340,9 +401,6 @@
"crypto",
"ssl",
],
- cppdefines = [
- "FEATURE_ENABLE_VOICEMAIL",
- ],
lin_libs = [
# :TODO: (kedong) add nexus videorenderer later
# "videorenderer",
@@ -351,13 +409,12 @@
"examples/call/call_main.cc",
"examples/call/callclient.cc",
"examples/call/console.cc",
- "examples/call/discoitemsquerytask.cc",
"examples/call/friendinvitesendtask.cc",
+ "examples/call/mediaenginefactory.cc",
"examples/call/mucinviterecvtask.cc",
"examples/call/mucinvitesendtask.cc",
"examples/call/presenceouttask.cc",
"examples/call/presencepushtask.cc",
- "examples/call/voicemailjidrequester.cc",
],
libs = [
"jingle",
@@ -386,39 +443,267 @@
],
)
talk.Unittest(env, name = "base",
- libs = [
- "jingle",
+ lin_srcs = [
+ "base/latebindingsymboltable_unittest.cc",
+ "base/linux_unittest.cc",
+ "base/linuxfdwalk_unittest.cc",
+ ],
+ mac_srcs = [
+ "base/macsocketserver_unittest.cc",
+ "base/macutils_unittest.cc",
+ "base/macwindowpicker_unittest.cc",
+ ],
+ posix_srcs = [
+ "base/sslidentity_unittest.cc",
+ "base/sslstreamadapter_unittest.cc",
+ ],
+ cppdefines = [
+ "LIBJINGLE_UNITTEST",
+ "EXPAT_RELATIVE_PATH",
+ "SRTP_RELATIVE_PATH",
],
srcs = [
"base/asynchttprequest_unittest.cc",
+ "base/atomicops_unittest.cc",
"base/autodetectproxy_unittest.cc",
+ "base/bandwidthsmoother_unittest.cc",
+ "base/base64_unittest.cc",
+ "base/buffer_unittest.cc",
"base/bytebuffer_unittest.cc",
+ "base/cpuid_unittest.cc",
+ "base/cpumonitor_unittest.cc",
"base/event_unittest.cc",
+ "base/filelock_unittest.cc",
"base/fileutils_unittest.cc",
"base/helpers_unittest.cc",
"base/host_unittest.cc",
"base/httpbase_unittest.cc",
"base/httpcommon_unittest.cc",
"base/httpserver_unittest.cc",
+ "base/ipaddress_unittest.cc",
"base/logging_unittest.cc",
"base/messagequeue_unittest.cc",
+ "base/multipart_unittest.cc",
+ "base/nat_unittest.cc",
"base/network_unittest.cc",
+ "base/optionsfile_unittest.cc",
+ "base/pathutils_unittest.cc",
+ "base/physicalsocketserver_unittest.cc",
+ "base/proxy_unittest.cc",
+ "base/proxydetect_unittest.cc",
+ "base/ratetracker_unittest.cc",
"base/referencecountedsingletonfactory_unittest.cc",
+ "base/rollingaccumulator_unittest.cc",
+ "base/sharedexclusivelock_unittest.cc",
"base/signalthread_unittest.cc",
+ "base/socket_unittest.cc",
"base/socketaddress_unittest.cc",
"base/stream_unittest.cc",
"base/stringencode_unittest.cc",
"base/stringutils_unittest.cc",
+ "base/systeminfo_unittest.cc",
"base/task_unittest.cc",
+ "base/testclient_unittest.cc",
"base/thread_unittest.cc",
- "base/time_unittest.cc",
+ "base/timeutils_unittest.cc",
"base/urlencode_unittest.cc",
+ "base/versionparsing_unittest.cc",
+ "base/virtualsocket_unittest.cc",
],
includedirs = [
"third_party/gtest/include",
+ "third_party/expat-2.0.1/lib",
+ "third_party/srtp",
+ "third_party/gtest",
+ ],
+ win_srcs = [
+ "base/win32_unittest.cc",
+ "base/win32regkey_unittest.cc",
+ "base/win32socketserver_unittest.cc",
+ "base/win32toolhelp_unittest.cc",
+ "base/win32window_unittest.cc",
+ "base/win32windowpicker_unittest.cc",
+ "base/winfirewall_unittest.cc",
+ ],
+ libs = [
+ "jingle",
+ ],
+ extra_srcs = [
+ "base/dbus_unittest.cc",
+ "base/json_unittest.cc",
+ "base/linuxwindowpicker_unittest.cc",
+ ],
+)
+talk.Unittest(env, name = "p2p",
+ mac_FRAMEWORKS = [
+ "Foundation",
+ "IOKit",
+ "QTKit",
+ ],
+ mac_libs = [
+ "crypto",
+ "ssl",
+ ],
+ cppdefines = [
+ "LIBJINGLE_UNITTEST",
+ "EXPAT_RELATIVE_PATH",
+ "SRTP_RELATIVE_PATH",
+ ],
+ srcs = [
+ "p2p/base/p2ptransportchannel_unittest.cc",
+ "p2p/base/port_unittest.cc",
+ "p2p/base/pseudotcp_unittest.cc",
+ "p2p/base/relayport_unittest.cc",
+ "p2p/base/relayserver_unittest.cc",
+ "p2p/base/session_unittest.cc",
+ "p2p/base/stun_unittest.cc",
+ "p2p/base/stunport_unittest.cc",
+ "p2p/base/stunrequest_unittest.cc",
+ "p2p/base/stunserver_unittest.cc",
+ "p2p/base/transport_unittest.cc",
+ "p2p/client/connectivitychecker_unittest.cc",
+ "p2p/client/portallocator_unittest.cc",
+ ],
+ includedirs = [
+ "third_party/gtest/include",
+ "third_party/expat-2.0.1/lib",
+ "third_party/srtp",
+ "third_party/gtest",
+ ],
+ libs = [
+ "jingle",
+ "expat",
+ ],
+)
+talk.Unittest(env, name = "media",
+ libs = [
+ "jingle",
+ "expat",
+ "srtp",
+ ],
+ srcs = [
+ "session/phone/channel_unittest.cc",
+ "session/phone/channelmanager_unittest.cc",
+ "session/phone/codec_unittest.cc",
+ "session/phone/currentspeakermonitor_unittest.cc",
+ "session/phone/devicemanager_unittest.cc",
+ "session/phone/dummydevicemanager_unittest.cc",
+ "session/phone/filemediaengine_unittest.cc",
+ "session/phone/filevideocapturer_unittest.cc",
+ "session/phone/mediarecorder_unittest.cc",
+ "session/phone/mediamessages_unittest.cc",
+ "session/phone/mediasession_unittest.cc",
+ "session/phone/mediasessionclient_unittest.cc",
+ "session/phone/rtcpmuxfilter_unittest.cc",
+ "session/phone/rtpdump_unittest.cc",
+ "session/phone/rtputils_unittest.cc",
+ "session/phone/srtpfilter_unittest.cc",
+ "session/phone/ssrcmuxfilter_unittest.cc",
+ "session/phone/testutils.cc",
+ "session/phone/videocapturer_unittest.cc",
+ "session/phone/videocommon_unittest.cc",
+ ],
+ includedirs = [
+ "third_party/gtest/include",
+ "third_party/expat-2.0.1/lib",
+ "third_party/srtp",
"third_party/gtest",
],
cppdefines = [
"LIBJINGLE_UNITTEST",
+ "EXPAT_RELATIVE_PATH",
+ "SRTP_RELATIVE_PATH",
+ ],
+ win_libs = [
+ "winmm.lib",
+ "strmiids",
+ ],
+)
+talk.Unittest(env, name = "sound",
+ libs = [
+ "jingle",
+ ],
+ srcs = [
+ "sound/automaticallychosensoundsystem_unittest.cc",
+ ],
+ mac_libs = [
+ "crypto",
+ "ssl",
+ ],
+ includedirs = [
+ "third_party/gtest/include",
+ "third_party/expat-2.0.1/lib",
+ "third_party/srtp",
+ "third_party/gtest",
+ ],
+ cppdefines = [
+ "LIBJINGLE_UNITTEST",
+ "EXPAT_RELATIVE_PATH",
+ "SRTP_RELATIVE_PATH",
+ ],
+)
+talk.Unittest(env, name = "xmllite",
+ libs = [
+ "jingle",
+ "expat",
+ ],
+ srcs = [
+ "xmllite/qname_unittest.cc",
+ "xmllite/xmlbuilder_unittest.cc",
+ "xmllite/xmlelement_unittest.cc",
+ "xmllite/xmlnsstack_unittest.cc",
+ "xmllite/xmlparser_unittest.cc",
+ "xmllite/xmlprinter_unittest.cc",
+ ],
+ mac_libs = [
+ "crypto",
+ "ssl",
+ ],
+ includedirs = [
+ "third_party/gtest/include",
+ "third_party/expat-2.0.1/lib",
+ "third_party/srtp",
+ "third_party/gtest",
+ ],
+ cppdefines = [
+ "LIBJINGLE_UNITTEST",
+ "EXPAT_RELATIVE_PATH",
+ "SRTP_RELATIVE_PATH",
+ ],
+)
+talk.Unittest(env, name = "xmpp",
+ mac_libs = [
+ "crypto",
+ "ssl",
+ ],
+ cppdefines = [
+ "LIBJINGLE_UNITTEST",
+ "EXPAT_RELATIVE_PATH",
+ "SRTP_RELATIVE_PATH",
+ ],
+ srcs = [
+ "xmpp/hangoutpubsubclient_unittest.cc",
+ "xmpp/jid_unittest.cc",
+ "xmpp/mucroomconfigtask_unittest.cc",
+ "xmpp/mucroomlookuptask_unittest.cc",
+ "xmpp/pubsubclient_unittest.cc",
+ "xmpp/pubsubtasks_unittest.cc",
+ "xmpp/util_unittest.cc",
+ "xmpp/xmppengine_unittest.cc",
+ "xmpp/xmpplogintask_unittest.cc",
+ "xmpp/xmppstanzaparser_unittest.cc",
+ ],
+ includedirs = [
+ "third_party/gtest/include",
+ "third_party/expat-2.0.1/lib",
+ "third_party/srtp",
+ "third_party/gtest",
+ ],
+ libs = [
+ "jingle",
+ "expat",
+ ],
+ extra_srcs = [
+ "xmpp/chatroommodule_unittest.cc",
],
)
diff --git a/talk/main.scons b/talk/main.scons
index 5ad5065..6b6b891 100644
--- a/talk/main.scons
+++ b/talk/main.scons
@@ -69,6 +69,8 @@
'HAVE_SRTP',
'HAVE_GIPS',
],
+ # Ensure the os environment is captured for any scripts we call out to
+ ENV = os.environ,
)
# This is where we set common environments
@@ -78,18 +80,15 @@
if platform.architecture()[0] == "64bit":
root_env.SetBits('build_platform_64bit')
-# This bit denotes that an env is for pure 64-bit builds. When set, all build
-# artifacts will be 64-bit. When unset, we will still produce some 64-bit
-# artifacts on 64-bit Linux via the legacy also64bit setting on our targets.
-# When the pure 64-bit build is considered stable, the also64bit setting will go
-# away.
+# This bit denotes that an env is for 64-bit builds. When set, all build
+# artifacts will be 64-bit. When unset, all build artifacts will be 32-bit.
DeclareBit('host_platform_64bit', 'Platform of the host machine (where artifacts will execute) is 64-bit')
DeclareBit('host_platform_mipsel', 'Platform of the host machine (where artifacts will execute) is mipsel')
-def same_arch(env):
- """Whether the host machine and build machine architectures match."""
- return env.Bit('host_platform_64bit') == env.Bit('build_platform_64bit')
+def CrossBuilding(env):
+ return env.Bit('host_platform_64bit') != env.Bit('build_platform_64bit')
+root_env.AddMethod(CrossBuilding)
DeclareBit('use_static_openssl', 'Build OpenSSL as a static library')
@@ -107,6 +106,8 @@
'no', 'or', 'pl', 'pt-BR', 'pt-PT', 'ro', 'ru', 'sk', 'sl', 'sr', 'sv',
'ta', 'te', 'th', 'tl', 'tr', 'uk', 'ur', 'vi', 'zh-CN', 'zh-TW'])
+AddTargetGroup('all_breakpads', 'breakpad files can be built')
+
#-------------------------------------------------------------------------------
# W I N D O W S
#
@@ -293,6 +294,13 @@
# Needed for a clean ABI and for link-time dead-code removal to work
# properly.
'-fvisibility=hidden',
+ # Generate debugging info in the DWARF2 format.
+ '-gdwarf-2',
+ # Generate maximal debugging information. (It is stripped from what we ship
+ # to users, so we want it for both dbg and opt.)
+ # Note that hammer automatically supplies "-g" for mac/linux dbg, so that
+ # flag must be filtered out of linux_dbg and mac_dbg envs below.
+ '-g3',
],
CXXFLAGS = [
'-Wno-non-virtual-dtor',
@@ -311,6 +319,9 @@
#'fill_plist',
],
)
+# Use static OpenSSL on mac so that we can use the latest APIs on all
+# supported mac platforms (10.5+).
+mac_env.SetBits('use_static_openssl')
mac_env.Append(
CPPDEFINES = [
'OSX',
@@ -320,8 +331,6 @@
'-arch', 'i386',
'-isysroot', '/Developer/SDKs/MacOSX10.5.sdk',
'-fasm-blocks',
- # Generate debugging info in the DWARF2 format.
- '-gdwarf-2',
],
LINKFLAGS = [
'-Wl,-search_paths_first',
@@ -334,8 +343,7 @@
'-mmacosx-version-min=10.5',
'-isysroot', '/Developer/SDKs/MacOSX10.5.sdk',
'-m32',
- '-dead-strip'
- '-gdwarf-2',
+ '-dead_strip',
],
FRAMEWORKS = [
'CoreServices',
@@ -360,8 +368,13 @@
mac_dbg_env.Append(
CCFLAGS = [
'-O0',
- ]
+ ],
+ CPPDEFINES = [
+ 'DEBUG=1',
+ ],
)
+# Remove -g set by hammer, which is not what we want (we have set -g3 above).
+mac_dbg_env.FilterOut(CCFLAGS = ['-g'])
envs.append(mac_dbg_env)
mac_opt_env = mac_env.Clone(
@@ -377,6 +390,7 @@
# out. Maybe it's a different version of gcc?
'-Wno-unused-variable',
],
+ # Hammer automatically specifies -Os for mac opt.
)
envs.append(mac_opt_env)
@@ -399,11 +413,6 @@
# Needed for link-time dead-code removal to work properly.
'-ffunction-sections',
'-fdata-sections',
- # Generate debugging info in the DWARF2 format.
- '-gdwarf-2',
- # Generate maximal debugging information. (It is stripped from what we ship
- # to users, so we want it for both dbg and opt.)
- '-g3',
],
LINKFLAGS = [
# Enable dead-code removal.
@@ -467,11 +476,26 @@
# product would end up being broken on any computer with a different version
# installed. So instead we build it ourself and statically link to it.
linux_env.SetBits('use_static_openssl')
+
linux_env.SetBits('host_platform_mipsel')
- dbg_groups = ['default', 'all']
+
+ groups = ['all']
+ if not linux_env.CrossBuilding():
+ groups = groups + ['all-native']
+ # The native-arch dbg build is the default.
+ dbg_groups = groups + ['default']
+ native_desc = ', native '
+ # No suffix for native modes.
+ type_suffix = ''
+ else:
+ groups = groups + ['all-cross']
+ dbg_groups = groups
+ native_desc = ', cross-built for '
+
linux_dbg_env = linux_env.Clone(
BUILD_TYPE = 'dbg' + type_suffix,
- BUILD_TYPE_DESCRIPTION = 'Linux debug build' + desc_suffix,
+ BUILD_TYPE_DESCRIPTION = 'Linux debug build%s%s' % (native_desc,
+ desc_suffix),
BUILD_GROUPS = dbg_groups,
tools = ['target_debug'],
)
@@ -481,8 +505,9 @@
linux_opt_env = linux_env.Clone(
BUILD_TYPE = 'opt' + type_suffix,
- BUILD_TYPE_DESCRIPTION = 'Linux optimized build' + desc_suffix,
- BUILD_GROUPS = ['all'],
+ BUILD_TYPE_DESCRIPTION = 'Linux optimized build%s%s' % (native_desc,
+ desc_suffix),
+ BUILD_GROUPS = groups,
tools = ['target_optimized'],
)
# Remove -O2 set by hammer, which is not what we want.
@@ -492,6 +517,90 @@
gen_linux_mips(linux_mipsel_env, '', '')
+#-------------------------------------------------------------------------------
+# L I N U X -- C R O S S -- B U I L D
+
+# Cross build requires the following tool names be provided by the environment:
+linux_cross_common_env = linux_common_env.Clone(
+ AR = os.environ.get("AR"),
+ AS = os.environ.get("AS"),
+ LD = os.environ.get("LD"),
+ NM = os.environ.get("NM"),
+ RANLIB = os.environ.get("RANLIB"),
+ CC = str(os.environ.get("CC")) +
+ ' --sysroot=' + str(os.environ.get("SYSROOT")),
+ CXX = str(os.environ.get("CXX")) +
+ ' --sysroot=' + str(os.environ.get("SYSROOT")),
+)
+
+# The rest of these paths and flags are optional:
+if os.environ.get("CPPPATH"):
+ linux_cross_common_env.Append(
+ CPPPATH = os.environ.get("CPPPATH").split(':'),
+ )
+if os.environ.get("LIBPATH"):
+ linux_cross_common_env.Append(
+ LIBPATH = os.environ.get("LIBPATH").split(':'),
+ )
+if os.environ.get("CFLAGS"):
+ linux_cross_common_env.Append(
+ CFLAGS = os.environ.get("CFLAGS").split(' '),
+ )
+if os.environ.get("CCFLAGS"):
+ linux_cross_common_env.Append(
+ CCFLAGS = os.environ.get("CCFLAGS").split(' '),
+ )
+if os.environ.get("CXXFLAGS"):
+ linux_cross_common_env.Append(
+ CXXFLAGS = os.environ.get("CXXFLAGS").split(' '),
+ )
+if os.environ.get("LIBFLAGS"):
+ linux_cross_common_env.Append(
+ _LIBFLAGS = os.environ.get("LIBFLAGS").split(' '),
+ )
+
+#-------------------------------------------------------------------------------
+# L I N U X -- C R O S S -- B U I L D -- A R M
+
+linux_cross_arm_env = linux_cross_common_env.Clone()
+linux_cross_arm_env.Append(
+ CPPDEFINES = [
+ 'NACL_BUILD_ARCH=arm',
+ 'DISABLE_EFFECTS=1',
+ ],
+ CCFLAGS = [
+ '-fPIC',
+ ],
+)
+DeclareBit('arm', 'ARM build')
+linux_cross_arm_env.SetBits('arm')
+
+# Detect NEON support from the -mfpu build flag.
+DeclareBit('arm_neon', 'ARM supporting neon')
+if '-mfpu=neon' in linux_cross_arm_env['CFLAGS'] or \
+ '-mfpu=neon' in linux_cross_arm_env['CCFLAGS'] or \
+ '-mfpu=neon' in linux_cross_arm_env['CXXFLAGS']:
+ print "Building with ARM NEON support."
+ linux_cross_arm_env.SetBits('arm_neon')
+
+
+linux_cross_arm_dbg_env = linux_cross_arm_env.Clone(
+ BUILD_TYPE = 'arm-dbg',
+ BUILD_TYPE_DESCRIPTION = 'Cross-compiled ARM debug build',
+ BUILD_GROUPS = ['arm'],
+ tools = ['target_debug'],
+)
+envs.append(linux_cross_arm_dbg_env)
+
+linux_cross_arm_opt_env = linux_cross_arm_env.Clone(
+ BUILD_TYPE = 'arm-opt',
+ BUILD_TYPE_DESCRIPTION = 'Cross-compiled ARM optimized build',
+ BUILD_GROUPS = ['arm'],
+ tools = ['target_optimized'],
+)
+envs.append(linux_cross_arm_opt_env)
+
+
# TODO(): Clone linux envs for 64bit. See 'variant' documentation.
diff --git a/talk/p2p/base/constants.cc b/talk/p2p/base/constants.cc
index 178bd59..fe89aa7 100644
--- a/talk/p2p/base/constants.cc
+++ b/talk/p2p/base/constants.cc
@@ -25,207 +25,206 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include "talk/p2p/base/constants.h"
+
#include <string>
-#include "talk/p2p/base/constants.h"
#include "talk/xmllite/qname.h"
namespace cricket {
-const std::string NS_EMPTY("");
-const std::string NS_JINGLE("urn:xmpp:jingle:1");
-const std::string NS_JINGLE_DRAFT("google:jingle");
-const std::string NS_GINGLE("http://www.google.com/session");
+const char NS_EMPTY[] = "";
+const char NS_JINGLE[] = "urn:xmpp:jingle:1";
+const char NS_JINGLE_DRAFT[] = "google:jingle";
+const char NS_GINGLE[] = "http://www.google.com/session";
// actions (aka <session> or <jingle>)
-const buzz::QName QN_ACTION(true, NS_EMPTY, "action");
-const std::string LN_INITIATOR("initiator");
-const buzz::QName QN_INITIATOR(true, NS_EMPTY, LN_INITIATOR);
-const buzz::QName QN_CREATOR(true, NS_EMPTY, "creator");
+const buzz::StaticQName QN_ACTION = { NS_EMPTY, "action" };
+const char LN_INITIATOR[] = "initiator";
+const buzz::StaticQName QN_INITIATOR = { NS_EMPTY, LN_INITIATOR };
+const buzz::StaticQName QN_CREATOR = { NS_EMPTY, "creator" };
-const buzz::QName QN_JINGLE(true, NS_JINGLE, "jingle");
-const buzz::QName QN_JINGLE_CONTENT(true, NS_JINGLE, "content");
-const buzz::QName QN_JINGLE_CONTENT_NAME(true, NS_EMPTY, "name");
-const buzz::QName QN_JINGLE_CONTENT_MEDIA(true, NS_EMPTY, "media");
-const buzz::QName QN_JINGLE_REASON(true, NS_JINGLE, "reason");
-const std::string JINGLE_CONTENT_MEDIA_AUDIO("audio");
-const std::string JINGLE_CONTENT_MEDIA_VIDEO("video");
-const std::string JINGLE_ACTION_SESSION_INITIATE("session-initiate");
-const std::string JINGLE_ACTION_SESSION_INFO("session-info");
-const std::string JINGLE_ACTION_SESSION_ACCEPT("session-accept");
-const std::string JINGLE_ACTION_SESSION_TERMINATE("session-terminate");
-const std::string JINGLE_ACTION_TRANSPORT_INFO("transport-info");
-const std::string JINGLE_ACTION_TRANSPORT_ACCEPT("transport-accept");
-const std::string JINGLE_ACTION_DESCRIPTION_INFO("description-info");
+const buzz::StaticQName QN_JINGLE = { NS_JINGLE, "jingle" };
+const buzz::StaticQName QN_JINGLE_CONTENT = { NS_JINGLE, "content" };
+const buzz::StaticQName QN_JINGLE_CONTENT_NAME = { NS_EMPTY, "name" };
+const buzz::StaticQName QN_JINGLE_CONTENT_MEDIA = { NS_EMPTY, "media" };
+const buzz::StaticQName QN_JINGLE_REASON = { NS_JINGLE, "reason" };
+const char JINGLE_CONTENT_MEDIA_AUDIO[] = "audio";
+const char JINGLE_CONTENT_MEDIA_VIDEO[] = "video";
+const char JINGLE_ACTION_SESSION_INITIATE[] = "session-initiate";
+const char JINGLE_ACTION_SESSION_INFO[] = "session-info";
+const char JINGLE_ACTION_SESSION_ACCEPT[] = "session-accept";
+const char JINGLE_ACTION_SESSION_TERMINATE[] = "session-terminate";
+const char JINGLE_ACTION_TRANSPORT_INFO[] = "transport-info";
+const char JINGLE_ACTION_TRANSPORT_ACCEPT[] = "transport-accept";
+const char JINGLE_ACTION_DESCRIPTION_INFO[] = "description-info";
-const buzz::QName QN_GINGLE_SESSION(true, NS_GINGLE, "session");
-const std::string GINGLE_ACTION_INITIATE("initiate");
-const std::string GINGLE_ACTION_INFO("info");
-const std::string GINGLE_ACTION_ACCEPT("accept");
-const std::string GINGLE_ACTION_REJECT("reject");
-const std::string GINGLE_ACTION_TERMINATE("terminate");
-const std::string GINGLE_ACTION_CANDIDATES("candidates");
-const std::string GINGLE_ACTION_UPDATE("update");
+const buzz::StaticQName QN_GINGLE_SESSION = { NS_GINGLE, "session" };
+const char GINGLE_ACTION_INITIATE[] = "initiate";
+const char GINGLE_ACTION_INFO[] = "info";
+const char GINGLE_ACTION_ACCEPT[] = "accept";
+const char GINGLE_ACTION_REJECT[] = "reject";
+const char GINGLE_ACTION_TERMINATE[] = "terminate";
+const char GINGLE_ACTION_CANDIDATES[] = "candidates";
+const char GINGLE_ACTION_UPDATE[] = "update";
-const std::string LN_ERROR("error");
-const buzz::QName QN_GINGLE_REDIRECT(true, NS_GINGLE, "redirect");
-const std::string STR_REDIRECT_PREFIX("xmpp:");
+const char LN_ERROR[] = "error";
+const buzz::StaticQName QN_GINGLE_REDIRECT = { NS_GINGLE, "redirect" };
+const char STR_REDIRECT_PREFIX[] = "xmpp:";
// Session Contents (aka Gingle <session><description>
// or Jingle <content><description>)
-const std::string LN_DESCRIPTION("description");
-const std::string LN_PAYLOADTYPE("payload-type");
-const buzz::QName QN_ID(true, NS_EMPTY, "id");
-const buzz::QName QN_SID(true, NS_EMPTY, "sid");
-const buzz::QName QN_NAME(true, NS_EMPTY, "name");
-const buzz::QName QN_CLOCKRATE(true, NS_EMPTY, "clockrate");
-const buzz::QName QN_BITRATE(true, NS_EMPTY, "bitrate");
-const buzz::QName QN_CHANNELS(true, NS_EMPTY, "channels");
-const buzz::QName QN_WIDTH(true, NS_EMPTY, "width");
-const buzz::QName QN_HEIGHT(true, NS_EMPTY, "height");
-const buzz::QName QN_FRAMERATE(true, NS_EMPTY, "framerate");
-const std::string LN_NAME("name");
-const std::string LN_VALUE("value");
-const buzz::QName QN_PAYLOADTYPE_PARAMETER_NAME(true, NS_EMPTY, LN_NAME);
-const buzz::QName QN_PAYLOADTYPE_PARAMETER_VALUE(true, NS_EMPTY, LN_VALUE);
-const std::string PAYLOADTYPE_PARAMETER_BITRATE("bitrate");
-const std::string PAYLOADTYPE_PARAMETER_HEIGHT("height");
-const std::string PAYLOADTYPE_PARAMETER_WIDTH("width");
-const std::string PAYLOADTYPE_PARAMETER_FRAMERATE("framerate");
-const std::string LN_BANDWIDTH("bandwidth");
+const char LN_DESCRIPTION[] = "description";
+const char LN_PAYLOADTYPE[] = "payload-type";
+const buzz::StaticQName QN_ID = { NS_EMPTY, "id" };
+const buzz::StaticQName QN_SID = { NS_EMPTY, "sid" };
+const buzz::StaticQName QN_NAME = { NS_EMPTY, "name" };
+const buzz::StaticQName QN_CLOCKRATE = { NS_EMPTY, "clockrate" };
+const buzz::StaticQName QN_BITRATE = { NS_EMPTY, "bitrate" };
+const buzz::StaticQName QN_CHANNELS = { NS_EMPTY, "channels" };
+const buzz::StaticQName QN_WIDTH = { NS_EMPTY, "width" };
+const buzz::StaticQName QN_HEIGHT = { NS_EMPTY, "height" };
+const buzz::StaticQName QN_FRAMERATE = { NS_EMPTY, "framerate" };
+const char LN_NAME[] = "name";
+const char LN_VALUE[] = "value";
+const buzz::StaticQName QN_PAYLOADTYPE_PARAMETER_NAME = { NS_EMPTY, LN_NAME };
+const buzz::StaticQName QN_PAYLOADTYPE_PARAMETER_VALUE = { NS_EMPTY, LN_VALUE };
+const char PAYLOADTYPE_PARAMETER_BITRATE[] = "bitrate";
+const char PAYLOADTYPE_PARAMETER_HEIGHT[] = "height";
+const char PAYLOADTYPE_PARAMETER_WIDTH[] = "width";
+const char PAYLOADTYPE_PARAMETER_FRAMERATE[] = "framerate";
+const char LN_BANDWIDTH[] = "bandwidth";
-const std::string CN_AUDIO("audio");
-const std::string CN_VIDEO("video");
-const std::string CN_OTHER("main");
+const char CN_AUDIO[] = "audio";
+const char CN_VIDEO[] = "video";
+const char CN_OTHER[] = "main";
+// other SDP related strings
+const char GN_BUNDLE[] = "BUNDLE";
-const std::string NS_JINGLE_RTP("urn:xmpp:jingle:apps:rtp:1");
-const buzz::QName QN_JINGLE_RTP_CONTENT(
- true, NS_JINGLE_RTP, LN_DESCRIPTION);
-const buzz::QName QN_JINGLE_SSRC(true, NS_EMPTY, "ssrc");
-const buzz::QName QN_JINGLE_RTP_PAYLOADTYPE(
- true, NS_JINGLE_RTP, LN_PAYLOADTYPE);
-const buzz::QName QN_JINGLE_RTP_BANDWIDTH(
- true, NS_JINGLE_RTP, LN_BANDWIDTH);
-const buzz::QName QN_JINGLE_RTCP_MUX(true, NS_JINGLE_RTP, "rtcp-mux");
-const buzz::QName QN_PARAMETER(true, NS_JINGLE_RTP, "parameter");
+const char NS_JINGLE_RTP[] = "urn:xmpp:jingle:apps:rtp:1";
+const buzz::StaticQName QN_JINGLE_RTP_CONTENT =
+ { NS_JINGLE_RTP, LN_DESCRIPTION };
+const buzz::StaticQName QN_SSRC = { NS_EMPTY, "ssrc" };
+const buzz::StaticQName QN_JINGLE_RTP_PAYLOADTYPE =
+ { NS_JINGLE_RTP, LN_PAYLOADTYPE };
+const buzz::StaticQName QN_JINGLE_RTP_BANDWIDTH =
+ { NS_JINGLE_RTP, LN_BANDWIDTH };
+const buzz::StaticQName QN_JINGLE_RTCP_MUX = { NS_JINGLE_RTP, "rtcp-mux" };
+const buzz::StaticQName QN_PARAMETER = { NS_JINGLE_RTP, "parameter" };
-const std::string NS_GINGLE_AUDIO("http://www.google.com/session/phone");
-const buzz::QName QN_GINGLE_AUDIO_CONTENT(
- true, NS_GINGLE_AUDIO, LN_DESCRIPTION);
-const buzz::QName QN_GINGLE_AUDIO_PAYLOADTYPE(
- true, NS_GINGLE_AUDIO, LN_PAYLOADTYPE);
-const buzz::QName QN_GINGLE_AUDIO_SRCID(true, NS_GINGLE_AUDIO, "src-id");
-const std::string NS_GINGLE_VIDEO("http://www.google.com/session/video");
-const buzz::QName QN_GINGLE_VIDEO_CONTENT(
- true, NS_GINGLE_VIDEO, LN_DESCRIPTION);
-const buzz::QName QN_GINGLE_VIDEO_PAYLOADTYPE(
- true, NS_GINGLE_VIDEO, LN_PAYLOADTYPE);
-const buzz::QName QN_GINGLE_VIDEO_SRCID(true, NS_GINGLE_VIDEO, "src-id");
-const buzz::QName QN_GINGLE_VIDEO_BANDWIDTH(
- true, NS_GINGLE_VIDEO, LN_BANDWIDTH);
+const char NS_GINGLE_AUDIO[] = "http://www.google.com/session/phone";
+const buzz::StaticQName QN_GINGLE_AUDIO_CONTENT =
+ { NS_GINGLE_AUDIO, LN_DESCRIPTION };
+const buzz::StaticQName QN_GINGLE_AUDIO_PAYLOADTYPE =
+ { NS_GINGLE_AUDIO, LN_PAYLOADTYPE };
+const buzz::StaticQName QN_GINGLE_AUDIO_SRCID = { NS_GINGLE_AUDIO, "src-id" };
+const char NS_GINGLE_VIDEO[] = "http://www.google.com/session/video";
+const buzz::StaticQName QN_GINGLE_VIDEO_CONTENT =
+ { NS_GINGLE_VIDEO, LN_DESCRIPTION };
+const buzz::StaticQName QN_GINGLE_VIDEO_PAYLOADTYPE =
+ { NS_GINGLE_VIDEO, LN_PAYLOADTYPE };
+const buzz::StaticQName QN_GINGLE_VIDEO_SRCID = { NS_GINGLE_VIDEO, "src-id" };
+const buzz::StaticQName QN_GINGLE_VIDEO_BANDWIDTH =
+ { NS_GINGLE_VIDEO, LN_BANDWIDTH };
// Crypto support.
-const buzz::QName QN_ENCRYPTION(true, NS_JINGLE_RTP, "encryption");
-const buzz::QName QN_ENCRYPTION_REQUIRED(true, NS_EMPTY, "required");
-const buzz::QName QN_CRYPTO(true, NS_JINGLE_RTP, "crypto");
-const buzz::QName QN_GINGLE_AUDIO_CRYPTO_USAGE(true, NS_GINGLE_AUDIO, "usage");
-const buzz::QName QN_GINGLE_VIDEO_CRYPTO_USAGE(true, NS_GINGLE_VIDEO, "usage");
-const buzz::QName QN_CRYPTO_SUITE(true, NS_EMPTY, "crypto-suite");
-const buzz::QName QN_CRYPTO_KEY_PARAMS(true, NS_EMPTY, "key-params");
-const buzz::QName QN_CRYPTO_TAG(true, NS_EMPTY, "tag");
-const buzz::QName QN_CRYPTO_SESSION_PARAMS(true, NS_EMPTY, "session-params");
+const buzz::StaticQName QN_ENCRYPTION = { NS_JINGLE_RTP, "encryption" };
+const buzz::StaticQName QN_ENCRYPTION_REQUIRED = { NS_EMPTY, "required" };
+const buzz::StaticQName QN_CRYPTO = { NS_JINGLE_RTP, "crypto" };
+const buzz::StaticQName QN_GINGLE_AUDIO_CRYPTO_USAGE =
+ { NS_GINGLE_AUDIO, "usage" };
+const buzz::StaticQName QN_GINGLE_VIDEO_CRYPTO_USAGE =
+ { NS_GINGLE_VIDEO, "usage" };
+const buzz::StaticQName QN_CRYPTO_SUITE = { NS_EMPTY, "crypto-suite" };
+const buzz::StaticQName QN_CRYPTO_KEY_PARAMS = { NS_EMPTY, "key-params" };
+const buzz::StaticQName QN_CRYPTO_TAG = { NS_EMPTY, "tag" };
+const buzz::StaticQName QN_CRYPTO_SESSION_PARAMS =
+ { NS_EMPTY, "session-params" };
// transports and candidates
-const std::string LN_TRANSPORT("transport");
-const std::string LN_CANDIDATE("candidate");
-const buzz::QName QN_UFRAG(true, cricket::NS_EMPTY, "ufrag");
-const buzz::QName QN_PWD(true, cricket::NS_EMPTY, "pwd");
-const buzz::QName QN_COMPONENT(true, cricket::NS_EMPTY, "component");
-const buzz::QName QN_IP(true, cricket::NS_EMPTY, "ip");
-const buzz::QName QN_PORT(true, cricket::NS_EMPTY, "port");
-const buzz::QName QN_NETWORK(true, cricket::NS_EMPTY, "network");
-const buzz::QName QN_GENERATION(true, cricket::NS_EMPTY, "generation");
-const buzz::QName QN_PRIORITY(true, cricket::NS_EMPTY, "priority");
-const buzz::QName QN_PROTOCOL(true, cricket::NS_EMPTY, "protocol");
-const std::string JINGLE_CANDIDATE_TYPE_PEER_STUN("prflx");
-const std::string JINGLE_CANDIDATE_TYPE_SERVER_STUN("srflx");
-const std::string JINGLE_CANDIDATE_NAME_RTP("1");
-const std::string JINGLE_CANDIDATE_NAME_RTCP("2");
+const char LN_TRANSPORT[] = "transport";
+const char LN_CANDIDATE[] = "candidate";
+const buzz::StaticQName QN_UFRAG = { cricket::NS_EMPTY, "ufrag" };
+const buzz::StaticQName QN_PWD = { cricket::NS_EMPTY, "pwd" };
+const buzz::StaticQName QN_COMPONENT = { cricket::NS_EMPTY, "component" };
+const buzz::StaticQName QN_IP = { cricket::NS_EMPTY, "ip" };
+const buzz::StaticQName QN_PORT = { cricket::NS_EMPTY, "port" };
+const buzz::StaticQName QN_NETWORK = { cricket::NS_EMPTY, "network" };
+const buzz::StaticQName QN_GENERATION = { cricket::NS_EMPTY, "generation" };
+const buzz::StaticQName QN_PRIORITY = { cricket::NS_EMPTY, "priority" };
+const buzz::StaticQName QN_PROTOCOL = { cricket::NS_EMPTY, "protocol" };
+const char JINGLE_CANDIDATE_TYPE_PEER_STUN[] = "prflx";
+const char JINGLE_CANDIDATE_TYPE_SERVER_STUN[] = "srflx";
+const char JINGLE_CANDIDATE_NAME_RTP[] = "1";
+const char JINGLE_CANDIDATE_NAME_RTCP[] = "2";
// TODO Once we are full ICE-UDP compliant, use this namespace.
// For now, just use the same as NS_GINGLE_P2P.
-// const std::string NS_JINGLE_ICE_UDP("urn:xmpp:jingle:transports:ice-udp:1");
-const std::string NS_GINGLE_P2P("http://www.google.com/transport/p2p");
-const buzz::QName QN_GINGLE_P2P_TRANSPORT(true, NS_GINGLE_P2P, LN_TRANSPORT);
-const buzz::QName QN_GINGLE_P2P_CANDIDATE(true, NS_GINGLE_P2P, LN_CANDIDATE);
-const buzz::QName QN_GINGLE_P2P_UNKNOWN_CHANNEL_NAME(
- true, NS_GINGLE_P2P, "unknown-channel-name");
-const buzz::QName QN_GINGLE_CANDIDATE(true, NS_GINGLE, LN_CANDIDATE);
-const buzz::QName QN_ADDRESS(true, cricket::NS_EMPTY, "address");
-const buzz::QName QN_USERNAME(true, cricket::NS_EMPTY, "username");
-const buzz::QName QN_PASSWORD(true, cricket::NS_EMPTY, "password");
-const buzz::QName QN_PREFERENCE(true, cricket::NS_EMPTY, "preference");
-const std::string GINGLE_CANDIDATE_TYPE_STUN("stun");
-const std::string GINGLE_CANDIDATE_NAME_RTP("rtp");
-const std::string GINGLE_CANDIDATE_NAME_RTCP("rtcp");
-const std::string GINGLE_CANDIDATE_NAME_VIDEO_RTP("video_rtp");
-const std::string GINGLE_CANDIDATE_NAME_VIDEO_RTCP("video_rtcp");
+// const char NS_JINGLE_ICE_UDP[] = "urn:xmpp:jingle:transports:ice-udp:1";
+const char NS_GINGLE_P2P[] = "http://www.google.com/transport/p2p";
+const buzz::StaticQName QN_GINGLE_P2P_TRANSPORT =
+ { NS_GINGLE_P2P, LN_TRANSPORT };
+const buzz::StaticQName QN_GINGLE_P2P_CANDIDATE =
+ { NS_GINGLE_P2P, LN_CANDIDATE };
+const buzz::StaticQName QN_GINGLE_P2P_UNKNOWN_CHANNEL_NAME =
+ { NS_GINGLE_P2P, "unknown-channel-name" };
+const buzz::StaticQName QN_GINGLE_CANDIDATE = { NS_GINGLE, LN_CANDIDATE };
+const buzz::StaticQName QN_ADDRESS = { cricket::NS_EMPTY, "address" };
+const buzz::StaticQName QN_USERNAME = { cricket::NS_EMPTY, "username" };
+const buzz::StaticQName QN_PASSWORD = { cricket::NS_EMPTY, "password" };
+const buzz::StaticQName QN_PREFERENCE = { cricket::NS_EMPTY, "preference" };
+const char GINGLE_CANDIDATE_TYPE_STUN[] = "stun";
+const char GINGLE_CANDIDATE_NAME_RTP[] = "rtp";
+const char GINGLE_CANDIDATE_NAME_RTCP[] = "rtcp";
+const char GINGLE_CANDIDATE_NAME_VIDEO_RTP[] = "video_rtp";
+const char GINGLE_CANDIDATE_NAME_VIDEO_RTCP[] = "video_rtcp";
// terminate reasons and errors
-const std::string JINGLE_ERROR_BAD_REQUEST("bad-request");
-const std::string JINGLE_ERROR_OUT_OF_ORDER("out-of-order");
-const std::string JINGLE_ERROR_UNKNOWN_SESSION("unknown-session");
+const char JINGLE_ERROR_BAD_REQUEST[] = "bad-request";
+const char JINGLE_ERROR_OUT_OF_ORDER[] = "out-of-order";
+const char JINGLE_ERROR_UNKNOWN_SESSION[] = "unknown-session";
// Call terminate reasons from XEP-166
-const std::string STR_TERMINATE_DECLINE("decline");
-const std::string STR_TERMINATE_SUCCESS("success");
-const std::string STR_TERMINATE_ERROR("general-error");
-const std::string STR_TERMINATE_INCOMPATIBLE_PARAMETERS(
- "incompatible-parameters");
+const char STR_TERMINATE_DECLINE[] = "decline";
+const char STR_TERMINATE_SUCCESS[] = "success";
+const char STR_TERMINATE_ERROR[] = "general-error";
+const char STR_TERMINATE_INCOMPATIBLE_PARAMETERS[] = "incompatible-parameters";
// Old terminate reasons used by cricket
-const std::string STR_TERMINATE_CALL_ENDED("call-ended");
-const std::string STR_TERMINATE_RECIPIENT_UNAVAILABLE("recipient-unavailable");
-const std::string STR_TERMINATE_RECIPIENT_BUSY("recipient-busy");
-const std::string STR_TERMINATE_INSUFFICIENT_FUNDS("insufficient-funds");
-const std::string STR_TERMINATE_NUMBER_MALFORMED("number-malformed");
-const std::string STR_TERMINATE_NUMBER_DISALLOWED("number-disallowed");
-const std::string STR_TERMINATE_PROTOCOL_ERROR("protocol-error");
-const std::string STR_TERMINATE_INTERNAL_SERVER_ERROR("internal-server-error");
-const std::string STR_TERMINATE_UNKNOWN_ERROR("unknown-error");
+const char STR_TERMINATE_CALL_ENDED[] = "call-ended";
+const char STR_TERMINATE_RECIPIENT_UNAVAILABLE[] = "recipient-unavailable";
+const char STR_TERMINATE_RECIPIENT_BUSY[] = "recipient-busy";
+const char STR_TERMINATE_INSUFFICIENT_FUNDS[] = "insufficient-funds";
+const char STR_TERMINATE_NUMBER_MALFORMED[] = "number-malformed";
+const char STR_TERMINATE_NUMBER_DISALLOWED[] = "number-disallowed";
+const char STR_TERMINATE_PROTOCOL_ERROR[] = "protocol-error";
+const char STR_TERMINATE_INTERNAL_SERVER_ERROR[] = "internal-server-error";
+const char STR_TERMINATE_UNKNOWN_ERROR[] = "unknown-error";
// Draft view and notify messages.
-const buzz::QName QN_JINGLE_DRAFT_CONTENT_NAME(true, cricket::NS_EMPTY, "name");
-const std::string STR_JINGLE_DRAFT_CONTENT_NAME_VIDEO("video");
-const std::string STR_JINGLE_DRAFT_CONTENT_NAME_AUDIO("audio");
-const buzz::QName QN_JINGLE_DRAFT_NOTIFY(true, NS_JINGLE_DRAFT, "notify");
-const buzz::QName QN_JINGLE_DRAFT_SOURCE(
- true, NS_JINGLE_DRAFT, "source");
-const buzz::QName QN_JINGLE_DRAFT_SOURCE_NICK(true, cricket::NS_EMPTY, "nick");
-const buzz::QName QN_JINGLE_DRAFT_SOURCE_NAME(true, cricket::NS_EMPTY, "name");
-const buzz::QName QN_JINGLE_DRAFT_SOURCE_USAGE(true, cricket::NS_EMPTY, "usage");
-const buzz::QName QN_JINGLE_DRAFT_SOURCE_STATE(true, cricket::NS_EMPTY, "state");
-const std::string STR_JINGLE_DRAFT_SOURCE_STATE_REMOVED("removed");
-const buzz::QName QN_JINGLE_DRAFT_SOURCE_SSRC(true, NS_JINGLE_DRAFT, "ssrc");
-const buzz::QName QN_JINGLE_DRAFT_VIEW(true, NS_JINGLE_DRAFT, "view");
-const buzz::QName QN_JINGLE_DRAFT_VIEW_TYPE(true, cricket::NS_EMPTY, "type");
-const std::string STR_JINGLE_DRAFT_VIEW_TYPE_NONE("none");
-const std::string STR_JINGLE_DRAFT_VIEW_TYPE_STATIC("static");
-const buzz::QName QN_JINGLE_DRAFT_VIEW_SSRC(true, cricket::NS_EMPTY, "ssrc");
-const buzz::QName QN_JINGLE_DRAFT_VIEW_PARAMS(true, NS_JINGLE_DRAFT, "params");
-const buzz::QName QN_JINGLE_DRAFT_VIEW_PARAMS_WIDTH(
- true, cricket::NS_EMPTY, "width");
-const buzz::QName QN_JINGLE_DRAFT_VIEW_PARAMS_HEIGHT(
- true, cricket::NS_EMPTY, "height");
-const buzz::QName QN_JINGLE_DRAFT_VIEW_PARAMS_FRAMERATE(
- true, cricket::NS_EMPTY, "framerate");
-const buzz::QName QN_JINGLE_DRAFT_VIEW_PARAMS_PREFERENCE(
- true, cricket::NS_EMPTY, "preference");
+const char STR_JINGLE_DRAFT_CONTENT_NAME_VIDEO[] = "video";
+const char STR_JINGLE_DRAFT_CONTENT_NAME_AUDIO[] = "audio";
+const buzz::StaticQName QN_NICK = { cricket::NS_EMPTY, "nick" };
+const buzz::StaticQName QN_TYPE = { cricket::NS_EMPTY, "type" };
+const buzz::StaticQName QN_JINGLE_DRAFT_VIEW = { NS_JINGLE_DRAFT, "view" };
+const char STR_JINGLE_DRAFT_VIEW_TYPE_NONE[] = "none";
+const char STR_JINGLE_DRAFT_VIEW_TYPE_STATIC[] = "static";
+const buzz::StaticQName QN_JINGLE_DRAFT_PARAMS = { NS_JINGLE_DRAFT, "params" };
+const buzz::StaticQName QN_JINGLE_DRAFT_STREAMS = { NS_JINGLE_DRAFT, "streams" };
+const buzz::StaticQName QN_JINGLE_DRAFT_STREAM = { NS_JINGLE_DRAFT, "stream" };
+const buzz::StaticQName QN_DISPLAY = { cricket::NS_EMPTY, "display" };
+const buzz::StaticQName QN_CNAME = { cricket::NS_EMPTY, "cname" };
+const buzz::StaticQName QN_JINGLE_DRAFT_SSRC = { NS_JINGLE_DRAFT, "ssrc" };
+const buzz::StaticQName QN_JINGLE_DRAFT_SSRC_GROUP =
+ { NS_JINGLE_DRAFT, "ssrc-group" };
+const buzz::StaticQName QN_SEMANTICS = { cricket::NS_EMPTY, "semantics" };
+const buzz::StaticQName QN_JINGLE_LEGACY_NOTIFY = { NS_JINGLE_DRAFT, "notify" };
+const buzz::StaticQName QN_JINGLE_LEGACY_SOURCE = { NS_JINGLE_DRAFT, "source" };
// old stuff
#ifdef FEATURE_ENABLE_VOICEMAIL
-const std::string NS_VOICEMAIL("http://www.google.com/session/voicemail");
-const buzz::QName QN_VOICEMAIL_REGARDING(true, NS_VOICEMAIL, "regarding");
+const char NS_VOICEMAIL[] = "http://www.google.com/session/voicemail";
+const buzz::StaticQName QN_VOICEMAIL_REGARDING = { NS_VOICEMAIL, "regarding" };
#endif
} // namespace cricket
diff --git a/talk/p2p/base/constants.h b/talk/p2p/base/constants.h
index ab0ed2c..3e85914 100644
--- a/talk/p2p/base/constants.h
+++ b/talk/p2p/base/constants.h
@@ -42,10 +42,10 @@
// these are useful when you need to find a tag
// that has different namespaces (like <description> or <transport>)
-extern const std::string NS_EMPTY;
-extern const std::string NS_JINGLE;
-extern const std::string NS_JINGLE_DRAFT;
-extern const std::string NS_GINGLE;
+extern const char NS_EMPTY[];
+extern const char NS_JINGLE[];
+extern const char NS_JINGLE_DRAFT[];
+extern const char NS_GINGLE[];
enum SignalingProtocol {
PROTOCOL_JINGLE,
@@ -54,189 +54,187 @@
};
// actions (aka Gingle <session> or Jingle <jingle>)
-extern const buzz::QName QN_ACTION;
-extern const std::string LN_INITIATOR;
-extern const buzz::QName QN_INITIATOR;
-extern const buzz::QName QN_CREATOR;
+extern const buzz::StaticQName QN_ACTION;
+extern const char LN_INITIATOR[];
+extern const buzz::StaticQName QN_INITIATOR;
+extern const buzz::StaticQName QN_CREATOR;
-extern const buzz::QName QN_JINGLE;
-extern const buzz::QName QN_JINGLE_CONTENT;
-extern const buzz::QName QN_JINGLE_CONTENT_NAME;
-extern const buzz::QName QN_JINGLE_CONTENT_MEDIA;
-extern const buzz::QName QN_JINGLE_REASON;
-extern const std::string JINGLE_CONTENT_MEDIA_AUDIO;
-extern const std::string JINGLE_CONTENT_MEDIA_VIDEO;
-extern const std::string JINGLE_ACTION_SESSION_INITIATE;
-extern const std::string JINGLE_ACTION_SESSION_INFO;
-extern const std::string JINGLE_ACTION_SESSION_ACCEPT;
-extern const std::string JINGLE_ACTION_SESSION_TERMINATE;
-extern const std::string JINGLE_ACTION_TRANSPORT_INFO;
-extern const std::string JINGLE_ACTION_TRANSPORT_ACCEPT;
-extern const std::string JINGLE_ACTION_DESCRIPTION_INFO;
+extern const buzz::StaticQName QN_JINGLE;
+extern const buzz::StaticQName QN_JINGLE_CONTENT;
+extern const buzz::StaticQName QN_JINGLE_CONTENT_NAME;
+extern const buzz::StaticQName QN_JINGLE_CONTENT_MEDIA;
+extern const buzz::StaticQName QN_JINGLE_REASON;
+extern const char JINGLE_CONTENT_MEDIA_AUDIO[];
+extern const char JINGLE_CONTENT_MEDIA_VIDEO[];
+extern const char JINGLE_ACTION_SESSION_INITIATE[];
+extern const char JINGLE_ACTION_SESSION_INFO[];
+extern const char JINGLE_ACTION_SESSION_ACCEPT[];
+extern const char JINGLE_ACTION_SESSION_TERMINATE[];
+extern const char JINGLE_ACTION_TRANSPORT_INFO[];
+extern const char JINGLE_ACTION_TRANSPORT_ACCEPT[];
+extern const char JINGLE_ACTION_DESCRIPTION_INFO[];
-extern const buzz::QName QN_GINGLE_SESSION;
-extern const std::string GINGLE_ACTION_INITIATE;
-extern const std::string GINGLE_ACTION_INFO;
-extern const std::string GINGLE_ACTION_ACCEPT;
-extern const std::string GINGLE_ACTION_REJECT;
-extern const std::string GINGLE_ACTION_TERMINATE;
-extern const std::string GINGLE_ACTION_CANDIDATES;
-extern const std::string GINGLE_ACTION_UPDATE;
+extern const buzz::StaticQName QN_GINGLE_SESSION;
+extern const char GINGLE_ACTION_INITIATE[];
+extern const char GINGLE_ACTION_INFO[];
+extern const char GINGLE_ACTION_ACCEPT[];
+extern const char GINGLE_ACTION_REJECT[];
+extern const char GINGLE_ACTION_TERMINATE[];
+extern const char GINGLE_ACTION_CANDIDATES[];
+extern const char GINGLE_ACTION_UPDATE[];
-extern const std::string LN_ERROR;
-extern const buzz::QName QN_GINGLE_REDIRECT;
-extern const std::string STR_REDIRECT_PREFIX;
+extern const char LN_ERROR[];
+extern const buzz::StaticQName QN_GINGLE_REDIRECT;
+extern const char STR_REDIRECT_PREFIX[];
// Session Contents (aka Gingle <session><description>
// or Jingle <content><description>)
-extern const std::string LN_DESCRIPTION;
-extern const std::string LN_PAYLOADTYPE;
-extern const buzz::QName QN_ID;
-extern const buzz::QName QN_SID;
-extern const buzz::QName QN_NAME;
-extern const buzz::QName QN_CLOCKRATE;
-extern const buzz::QName QN_BITRATE;
-extern const buzz::QName QN_CHANNELS;
-extern const buzz::QName QN_WIDTH;
-extern const buzz::QName QN_HEIGHT;
-extern const buzz::QName QN_FRAMERATE;
-extern const buzz::QName QN_PARAMETER;
-extern const std::string LN_NAME;
-extern const std::string LN_VALUE;
-extern const buzz::QName QN_PAYLOADTYPE_PARAMETER_NAME;
-extern const buzz::QName QN_PAYLOADTYPE_PARAMETER_VALUE;
-extern const std::string PAYLOADTYPE_PARAMETER_BITRATE;
-extern const std::string PAYLOADTYPE_PARAMETER_HEIGHT;
-extern const std::string PAYLOADTYPE_PARAMETER_WIDTH;
-extern const std::string PAYLOADTYPE_PARAMETER_FRAMERATE;
-extern const std::string LN_BANDWIDTH;
+extern const char LN_DESCRIPTION[];
+extern const char LN_PAYLOADTYPE[];
+extern const buzz::StaticQName QN_ID;
+extern const buzz::StaticQName QN_SID;
+extern const buzz::StaticQName QN_NAME;
+extern const buzz::StaticQName QN_CLOCKRATE;
+extern const buzz::StaticQName QN_BITRATE;
+extern const buzz::StaticQName QN_CHANNELS;
+extern const buzz::StaticQName QN_PARAMETER;
+extern const char LN_NAME[];
+extern const char LN_VALUE[];
+extern const buzz::StaticQName QN_PAYLOADTYPE_PARAMETER_NAME;
+extern const buzz::StaticQName QN_PAYLOADTYPE_PARAMETER_VALUE;
+extern const char PAYLOADTYPE_PARAMETER_BITRATE[];
+extern const char PAYLOADTYPE_PARAMETER_HEIGHT[];
+extern const char PAYLOADTYPE_PARAMETER_WIDTH[];
+extern const char PAYLOADTYPE_PARAMETER_FRAMERATE[];
+extern const char LN_BANDWIDTH[];
// CN_ == "content name". When we initiate a session, we choose the
// name, and when we receive a Gingle session, we provide default
// names (since Gingle has no content names). But when we receive a
// Jingle call, the content name can be anything, so don't rely on
// these values being the same as the ones received.
-extern const std::string CN_AUDIO;
-extern const std::string CN_VIDEO;
-extern const std::string CN_OTHER;
+extern const char CN_AUDIO[];
+extern const char CN_VIDEO[];
+extern const char CN_OTHER[];
+// other SDP related strings
+// GN stands for group name
+extern const char GN_BUNDLE[];
-extern const std::string NS_JINGLE_RTP;
-extern const buzz::QName QN_JINGLE_RTP_CONTENT;
-extern const buzz::QName QN_JINGLE_SSRC;
-extern const buzz::QName QN_JINGLE_RTP_PAYLOADTYPE;
-extern const buzz::QName QN_JINGLE_RTP_BANDWIDTH;
-extern const buzz::QName QN_JINGLE_RTCP_MUX;
+extern const char NS_JINGLE_RTP[];
+extern const buzz::StaticQName QN_JINGLE_RTP_CONTENT;
+extern const buzz::StaticQName QN_SSRC;
+extern const buzz::StaticQName QN_JINGLE_RTP_PAYLOADTYPE;
+extern const buzz::StaticQName QN_JINGLE_RTP_BANDWIDTH;
+extern const buzz::StaticQName QN_JINGLE_RTCP_MUX;
-extern const std::string NS_GINGLE_AUDIO;
-extern const buzz::QName QN_GINGLE_AUDIO_CONTENT;
-extern const buzz::QName QN_GINGLE_AUDIO_PAYLOADTYPE;
-extern const buzz::QName QN_GINGLE_AUDIO_SRCID;
-extern const std::string NS_GINGLE_VIDEO;
-extern const buzz::QName QN_GINGLE_VIDEO_CONTENT;
-extern const buzz::QName QN_GINGLE_VIDEO_PAYLOADTYPE;
-extern const buzz::QName QN_GINGLE_VIDEO_SRCID;
-extern const buzz::QName QN_GINGLE_VIDEO_BANDWIDTH;
+extern const char NS_GINGLE_AUDIO[];
+extern const buzz::StaticQName QN_GINGLE_AUDIO_CONTENT;
+extern const buzz::StaticQName QN_GINGLE_AUDIO_PAYLOADTYPE;
+extern const buzz::StaticQName QN_GINGLE_AUDIO_SRCID;
+extern const char NS_GINGLE_VIDEO[];
+extern const buzz::StaticQName QN_GINGLE_VIDEO_CONTENT;
+extern const buzz::StaticQName QN_GINGLE_VIDEO_PAYLOADTYPE;
+extern const buzz::StaticQName QN_GINGLE_VIDEO_SRCID;
+extern const buzz::StaticQName QN_GINGLE_VIDEO_BANDWIDTH;
// Crypto support.
-extern const buzz::QName QN_ENCRYPTION;
-extern const buzz::QName QN_ENCRYPTION_REQUIRED;
-extern const buzz::QName QN_CRYPTO;
-extern const buzz::QName QN_GINGLE_AUDIO_CRYPTO_USAGE;
-extern const buzz::QName QN_GINGLE_VIDEO_CRYPTO_USAGE;
-extern const buzz::QName QN_CRYPTO_SUITE;
-extern const buzz::QName QN_CRYPTO_KEY_PARAMS;
-extern const buzz::QName QN_CRYPTO_TAG;
-extern const buzz::QName QN_CRYPTO_SESSION_PARAMS;
+extern const buzz::StaticQName QN_ENCRYPTION;
+extern const buzz::StaticQName QN_ENCRYPTION_REQUIRED;
+extern const buzz::StaticQName QN_CRYPTO;
+extern const buzz::StaticQName QN_GINGLE_AUDIO_CRYPTO_USAGE;
+extern const buzz::StaticQName QN_GINGLE_VIDEO_CRYPTO_USAGE;
+extern const buzz::StaticQName QN_CRYPTO_SUITE;
+extern const buzz::StaticQName QN_CRYPTO_KEY_PARAMS;
+extern const buzz::StaticQName QN_CRYPTO_TAG;
+extern const buzz::StaticQName QN_CRYPTO_SESSION_PARAMS;
// transports and candidates
-extern const std::string LN_TRANSPORT;
-extern const std::string LN_CANDIDATE;
-extern const buzz::QName QN_JINGLE_P2P_TRANSPORT;
-extern const buzz::QName QN_JINGLE_P2P_CANDIDATE;
-extern const buzz::QName QN_UFRAG;
-extern const buzz::QName QN_COMPONENT;
-extern const buzz::QName QN_PWD;
-extern const buzz::QName QN_IP;
-extern const buzz::QName QN_PORT;
-extern const buzz::QName QN_NETWORK;
-extern const buzz::QName QN_GENERATION;
-extern const buzz::QName QN_PRIORITY;
-extern const buzz::QName QN_PROTOCOL;
-extern const std::string JINGLE_CANDIDATE_TYPE_PEER_STUN;
-extern const std::string JINGLE_CANDIDATE_TYPE_SERVER_STUN;
-extern const std::string JINGLE_CANDIDATE_NAME_RTP;
-extern const std::string JINGLE_CANDIDATE_NAME_RTCP;
+extern const char LN_TRANSPORT[];
+extern const char LN_CANDIDATE[];
+extern const buzz::StaticQName QN_JINGLE_P2P_TRANSPORT;
+extern const buzz::StaticQName QN_JINGLE_P2P_CANDIDATE;
+extern const buzz::StaticQName QN_UFRAG;
+extern const buzz::StaticQName QN_COMPONENT;
+extern const buzz::StaticQName QN_PWD;
+extern const buzz::StaticQName QN_IP;
+extern const buzz::StaticQName QN_PORT;
+extern const buzz::StaticQName QN_NETWORK;
+extern const buzz::StaticQName QN_GENERATION;
+extern const buzz::StaticQName QN_PRIORITY;
+extern const buzz::StaticQName QN_PROTOCOL;
+extern const char JINGLE_CANDIDATE_TYPE_PEER_STUN[];
+extern const char JINGLE_CANDIDATE_TYPE_SERVER_STUN[];
+extern const char JINGLE_CANDIDATE_NAME_RTP[];
+extern const char JINGLE_CANDIDATE_NAME_RTCP[];
-extern const std::string NS_GINGLE_P2P;
-extern const buzz::QName QN_GINGLE_P2P_TRANSPORT;
-extern const buzz::QName QN_GINGLE_P2P_CANDIDATE;
-extern const buzz::QName QN_GINGLE_P2P_UNKNOWN_CHANNEL_NAME;
-extern const buzz::QName QN_GINGLE_CANDIDATE;
-extern const buzz::QName QN_ADDRESS;
-extern const buzz::QName QN_USERNAME;
-extern const buzz::QName QN_PASSWORD;
-extern const buzz::QName QN_PREFERENCE;
-extern const std::string GINGLE_CANDIDATE_TYPE_STUN;
-extern const std::string GINGLE_CANDIDATE_NAME_RTP;
-extern const std::string GINGLE_CANDIDATE_NAME_RTCP;
-extern const std::string GINGLE_CANDIDATE_NAME_VIDEO_RTP;
-extern const std::string GINGLE_CANDIDATE_NAME_VIDEO_RTCP;
+extern const char NS_GINGLE_P2P[];
+extern const buzz::StaticQName QN_GINGLE_P2P_TRANSPORT;
+extern const buzz::StaticQName QN_GINGLE_P2P_CANDIDATE;
+extern const buzz::StaticQName QN_GINGLE_P2P_UNKNOWN_CHANNEL_NAME;
+extern const buzz::StaticQName QN_GINGLE_CANDIDATE;
+extern const buzz::StaticQName QN_ADDRESS;
+extern const buzz::StaticQName QN_USERNAME;
+extern const buzz::StaticQName QN_PASSWORD;
+extern const buzz::StaticQName QN_PREFERENCE;
+extern const char GINGLE_CANDIDATE_TYPE_STUN[];
+extern const char GINGLE_CANDIDATE_NAME_RTP[];
+extern const char GINGLE_CANDIDATE_NAME_RTCP[];
+extern const char GINGLE_CANDIDATE_NAME_VIDEO_RTP[];
+extern const char GINGLE_CANDIDATE_NAME_VIDEO_RTCP[];
-extern const std::string NS_GINGLE_RAW;
-extern const buzz::QName QN_GINGLE_RAW_TRANSPORT;
-extern const buzz::QName QN_GINGLE_RAW_CHANNEL;
+extern const char NS_GINGLE_RAW[];
+extern const buzz::StaticQName QN_GINGLE_RAW_TRANSPORT;
+extern const buzz::StaticQName QN_GINGLE_RAW_CHANNEL;
// terminate reasons and errors: see http://xmpp.org/extensions/xep-0166.html
-extern const std::string JINGLE_ERROR_BAD_REQUEST; // like parse error
+extern const char JINGLE_ERROR_BAD_REQUEST[]; // like parse error
// got transport-info before session-initiate, for example
-extern const std::string JINGLE_ERROR_OUT_OF_ORDER;
-extern const std::string JINGLE_ERROR_UNKNOWN_SESSION;
+extern const char JINGLE_ERROR_OUT_OF_ORDER[];
+extern const char JINGLE_ERROR_UNKNOWN_SESSION[];
// Call terminate reasons from XEP-166
-extern const std::string STR_TERMINATE_DECLINE; // polite reject
-extern const std::string STR_TERMINATE_SUCCESS; // polite hangup
-extern const std::string STR_TERMINATE_ERROR; // something bad happened
-extern const std::string STR_TERMINATE_INCOMPATIBLE_PARAMETERS; // no codecs?
+extern const char STR_TERMINATE_DECLINE[]; // polite reject
+extern const char STR_TERMINATE_SUCCESS[]; // polite hangup
+extern const char STR_TERMINATE_ERROR[]; // something bad happened
+extern const char STR_TERMINATE_INCOMPATIBLE_PARAMETERS[]; // no codecs?
// Old terminate reasons used by cricket
-extern const std::string STR_TERMINATE_CALL_ENDED;
-extern const std::string STR_TERMINATE_RECIPIENT_UNAVAILABLE;
-extern const std::string STR_TERMINATE_RECIPIENT_BUSY;
-extern const std::string STR_TERMINATE_INSUFFICIENT_FUNDS;
-extern const std::string STR_TERMINATE_NUMBER_MALFORMED;
-extern const std::string STR_TERMINATE_NUMBER_DISALLOWED;
-extern const std::string STR_TERMINATE_PROTOCOL_ERROR;
-extern const std::string STR_TERMINATE_INTERNAL_SERVER_ERROR;
-extern const std::string STR_TERMINATE_UNKNOWN_ERROR;
+extern const char STR_TERMINATE_CALL_ENDED[];
+extern const char STR_TERMINATE_RECIPIENT_UNAVAILABLE[];
+extern const char STR_TERMINATE_RECIPIENT_BUSY[];
+extern const char STR_TERMINATE_INSUFFICIENT_FUNDS[];
+extern const char STR_TERMINATE_NUMBER_MALFORMED[];
+extern const char STR_TERMINATE_NUMBER_DISALLOWED[];
+extern const char STR_TERMINATE_PROTOCOL_ERROR[];
+extern const char STR_TERMINATE_INTERNAL_SERVER_ERROR[];
+extern const char STR_TERMINATE_UNKNOWN_ERROR[];
// Draft view and notify messages.
-extern const buzz::QName QN_JINGLE_DRAFT_CONTENT_NAME;
-extern const std::string STR_JINGLE_DRAFT_CONTENT_NAME_VIDEO;
-extern const std::string STR_JINGLE_DRAFT_CONTENT_NAME_AUDIO;
-extern const buzz::QName QN_JINGLE_DRAFT_NOTIFY;
-extern const buzz::QName QN_JINGLE_DRAFT_SOURCE;
-extern const buzz::QName QN_JINGLE_DRAFT_SOURCE_NICK;
-extern const buzz::QName QN_JINGLE_DRAFT_SOURCE_NAME;
-extern const buzz::QName QN_JINGLE_DRAFT_SOURCE_USAGE;
-extern const buzz::QName QN_JINGLE_DRAFT_SOURCE_STATE;
-extern const std::string STR_JINGLE_DRAFT_SOURCE_STATE_REMOVED;
-extern const buzz::QName QN_JINGLE_DRAFT_SOURCE_SSRC;
-extern const buzz::QName QN_JINGLE_DRAFT_VIEW;
-extern const buzz::QName QN_JINGLE_DRAFT_VIEW_NAME;
-extern const buzz::QName QN_JINGLE_DRAFT_VIEW_TYPE;
-extern const std::string STR_JINGLE_DRAFT_VIEW_TYPE_NONE;
-extern const std::string STR_JINGLE_DRAFT_VIEW_TYPE_STATIC;
-extern const buzz::QName QN_JINGLE_DRAFT_VIEW_SSRC;
-extern const buzz::QName QN_JINGLE_DRAFT_VIEW_PARAMS;
-extern const buzz::QName QN_JINGLE_DRAFT_VIEW_PARAMS_WIDTH;
-extern const buzz::QName QN_JINGLE_DRAFT_VIEW_PARAMS_HEIGHT;
-extern const buzz::QName QN_JINGLE_DRAFT_VIEW_PARAMS_FRAMERATE;
-extern const buzz::QName QN_JINGLE_DRAFT_VIEW_PARAMS_PREFERENCE;
+extern const char STR_JINGLE_DRAFT_CONTENT_NAME_VIDEO[];
+extern const char STR_JINGLE_DRAFT_CONTENT_NAME_AUDIO[];
+extern const buzz::StaticQName QN_NICK;
+extern const buzz::StaticQName QN_TYPE;
+extern const buzz::StaticQName QN_JINGLE_DRAFT_VIEW;
+extern const char STR_JINGLE_DRAFT_VIEW_TYPE_NONE[];
+extern const char STR_JINGLE_DRAFT_VIEW_TYPE_STATIC[];
+extern const buzz::StaticQName QN_JINGLE_DRAFT_PARAMS;
+extern const buzz::StaticQName QN_WIDTH;
+extern const buzz::StaticQName QN_HEIGHT;
+extern const buzz::StaticQName QN_FRAMERATE;
+extern const buzz::StaticQName QN_JINGLE_DRAFT_STREAM;
+extern const buzz::StaticQName QN_JINGLE_DRAFT_STREAMS;
+extern const buzz::StaticQName QN_DISPLAY;
+extern const buzz::StaticQName QN_CNAME;
+extern const buzz::StaticQName QN_JINGLE_DRAFT_SSRC;
+extern const buzz::StaticQName QN_JINGLE_DRAFT_SSRC_GROUP;
+extern const buzz::StaticQName QN_SEMANTICS;
+extern const buzz::StaticQName QN_JINGLE_LEGACY_NOTIFY;
+extern const buzz::StaticQName QN_JINGLE_LEGACY_SOURCE;
// old stuff
#ifdef FEATURE_ENABLE_VOICEMAIL
-extern const std::string NS_VOICEMAIL;
-extern const buzz::QName QN_VOICEMAIL_REGARDING;
+extern const char NS_VOICEMAIL[];
+extern const buzz::StaticQName QN_VOICEMAIL_REGARDING;
#endif
} // namespace cricket
diff --git a/talk/p2p/base/fakesession.h b/talk/p2p/base/fakesession.h
new file mode 100644
index 0000000..1928613
--- /dev/null
+++ b/talk/p2p/base/fakesession.h
@@ -0,0 +1,233 @@
+// libjingle
+// Copyright 2009 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_SESSION_PHONE_FAKESESSION_H_
+#define TALK_SESSION_PHONE_FAKESESSION_H_
+
+#include <map>
+#include <string>
+
+#include "talk/p2p/base/session.h"
+#include "talk/p2p/base/transport.h"
+#include "talk/p2p/base/transportchannel.h"
+#include "talk/p2p/base/transportchannelimpl.h"
+
+namespace cricket {
+
+class FakeTransport;
+
+// Fake transport channel class, which can be passed to anything that needs a
+// transport channel. Can be informed of another FakeTransportChannel via
+// SetDestination.
+class FakeTransportChannel : public TransportChannelImpl {
+ public:
+ explicit FakeTransportChannel(Transport* transport,
+ const std::string& name,
+ const std::string& session_type)
+ : TransportChannelImpl(name, session_type),
+ transport_(transport),
+ dest_(NULL),
+ state_(STATE_INIT) {
+ }
+ ~FakeTransportChannel() {
+ Reset();
+ }
+
+ virtual Transport* GetTransport() {
+ return transport_;
+ }
+ virtual void Connect() {
+ if (state_ == STATE_INIT) {
+ state_ = STATE_CONNECTING;
+ }
+ }
+ virtual void Reset() {
+ if (state_ != STATE_INIT) {
+ state_ = STATE_INIT;
+ if (dest_) {
+ dest_->state_ = STATE_INIT;
+ dest_->dest_ = NULL;
+ dest_ = NULL;
+ }
+ }
+ }
+
+ void SetDestination(FakeTransportChannel* dest) {
+ if (state_ == STATE_CONNECTING && dest) {
+ // This simulates the delivery of candidates.
+ dest_ = dest;
+ dest_->dest_ = this;
+ state_ = STATE_CONNECTED;
+ dest_->state_ = STATE_CONNECTED;
+ set_writable(true);
+ dest_->set_writable(true);
+ } else if (state_ == STATE_CONNECTED && !dest) {
+ // Simulates loss of connectivity, by asymmetrically forgetting dest_.
+ dest_ = NULL;
+ state_ = STATE_CONNECTING;
+ set_writable(false);
+ }
+ }
+
+ virtual int SendPacket(const char *data, size_t len) {
+ if (state_ != STATE_CONNECTED) {
+ return -1;
+ }
+ dest_->SignalReadPacket(dest_, data, len);
+ return len;
+ }
+ virtual int SetOption(talk_base::Socket::Option opt, int value) {
+ return true;
+ }
+ virtual int GetError() {
+ return 0;
+ }
+
+ virtual void OnSignalingReady() {
+ }
+ virtual void OnCandidate(const Candidate& candidate) {
+ }
+
+ private:
+ enum State { STATE_INIT, STATE_CONNECTING, STATE_CONNECTED };
+ Transport* transport_;
+ FakeTransportChannel* dest_;
+ State state_;
+};
+
+// Fake transport class, which can be passed to anything that needs a Transport.
+// Can be informed of another FakeTransport via SetDestination (low-tech way
+// of doing candidates)
+class FakeTransport : public Transport {
+ public:
+ typedef std::map<std::string, FakeTransportChannel*> ChannelMap;
+ FakeTransport(talk_base::Thread* signaling_thread,
+ talk_base::Thread* worker_thread)
+ : Transport(signaling_thread, worker_thread, "test", NULL),
+ dest_(NULL) {
+ }
+ ~FakeTransport() {
+ DestroyAllChannels();
+ }
+
+ const ChannelMap& channels() const { return channels_; }
+
+ void SetDestination(FakeTransport* dest) {
+ dest_ = dest;
+ for (ChannelMap::iterator it = channels_.begin(); it != channels_.end();
+ ++it) {
+ SetChannelDestination(it->first, it->second);
+ }
+ }
+
+ protected:
+ virtual TransportChannelImpl* CreateTransportChannel(
+ const std::string& name, const std::string& session_type) {
+ if (channels_.find(name) != channels_.end()) {
+ return NULL;
+ }
+ FakeTransportChannel* channel =
+ new FakeTransportChannel(this, name, session_type);
+ SetChannelDestination(name, channel);
+ channels_[name] = channel;
+ return channel;
+ }
+ virtual void DestroyTransportChannel(TransportChannelImpl* channel) {
+ channels_.erase(channel->name());
+ delete channel;
+ }
+
+ private:
+ void SetChannelDestination(const std::string& name,
+ FakeTransportChannel* channel) {
+ FakeTransportChannel* dest_channel = NULL;
+ if (dest_) {
+ dest_channel =
+ static_cast<FakeTransportChannel*>(dest_->GetChannel(name));
+ }
+ channel->SetDestination(dest_channel);
+ }
+
+ ChannelMap channels_;
+ FakeTransport* dest_;
+};
+
+// Fake session class, which can be passed into a BaseChannel object for
+// test purposes. Can be connected to other FakeSessions via Connect().
+class FakeSession : public BaseSession {
+ public:
+ FakeSession()
+ : BaseSession(talk_base::Thread::Current(),
+ talk_base::Thread::Current(),
+ NULL, "", "", true),
+ fail_create_channel_(false) {
+ }
+
+ FakeTransport* GetTransport(const std::string& content_name) {
+ return static_cast<FakeTransport*>(
+ BaseSession::GetTransport(content_name));
+ }
+
+ void Connect(FakeSession* dest) {
+ // Simulate the exchange of candidates.
+ CompleteNegotiation();
+ dest->CompleteNegotiation();
+ for (TransportMap::const_iterator it = transport_proxies().begin();
+ it != transport_proxies().end(); ++it) {
+ static_cast<FakeTransport*>(it->second->impl())->SetDestination(
+ dest->GetTransport(it->first));
+ }
+ }
+
+ virtual cricket::TransportChannel* CreateChannel(
+ const std::string& content_name, const std::string& name) {
+ if (fail_create_channel_) {
+ return NULL;
+ }
+ return BaseSession::CreateChannel(content_name, name);
+ }
+
+ void set_fail_channel_creation(bool fail_channel_creation) {
+ fail_create_channel_ = fail_channel_creation;
+ }
+
+ protected:
+ virtual Transport* CreateTransport() {
+ return new FakeTransport(signaling_thread(), worker_thread());
+ }
+ void CompleteNegotiation() {
+ for (TransportMap::const_iterator it = transport_proxies().begin();
+ it != transport_proxies().end(); ++it) {
+ it->second->CompleteNegotiation();
+ }
+ }
+
+ private:
+ bool fail_create_channel_;
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_FAKESESSION_H_
diff --git a/talk/p2p/base/p2ptransport.cc b/talk/p2p/base/p2ptransport.cc
index dd170ff..5f55ef9 100644
--- a/talk/p2p/base/p2ptransport.cc
+++ b/talk/p2p/base/p2ptransport.cc
@@ -143,7 +143,7 @@
return true;
}
-const buzz::QName& GetCandidateQName(SignalingProtocol protocol) {
+static const buzz::StaticQName& GetCandidateQName(SignalingProtocol protocol) {
if (protocol == PROTOCOL_GINGLE) {
return QN_GINGLE_CANDIDATE;
} else {
diff --git a/talk/p2p/base/p2ptransportchannel.cc b/talk/p2p/base/p2ptransportchannel.cc
index 17f52a7..87a0222 100644
--- a/talk/p2p/base/p2ptransportchannel.cc
+++ b/talk/p2p/base/p2ptransportchannel.cc
@@ -301,7 +301,7 @@
// Handle stun packets
void P2PTransportChannel::OnUnknownAddress(
Port *port, const talk_base::SocketAddress &address, StunMessage *stun_msg,
- const std::string &remote_username) {
+ const std::string &remote_username, bool port_muxed) {
ASSERT(worker_thread_ == talk_base::Thread::Current());
// Port has received a valid stun packet from an address that no Connection
@@ -316,11 +316,17 @@
break;
}
}
+
if (candidate == NULL) {
+ if (port_muxed) {
+ // When Ports are muxed, SignalUnknownAddress is delivered to all
+ // P2PTransportChannel belong to a session. Return from here will
+ // save us from sending stun binding error message from incorrect channel.
+ return;
+ }
// Don't know about this username, the request is bogus
// This sometimes happens if a binding response comes in before the ACCEPT
// message. It is totally valid; the retry state machine will try again.
-
port->SendBindingErrorResponse(stun_msg, address,
STUN_ERROR_STALE_CREDENTIALS, STUN_ERROR_REASON_STALE_CREDENTIALS);
delete stun_msg;
@@ -451,6 +457,13 @@
return true;
}
+bool P2PTransportChannel::FindConnection(
+ cricket::Connection* connection) const {
+ std::vector<Connection*>::const_iterator citer =
+ std::find(connections_.begin(), connections_.end(), connection);
+ return citer != connections_.end();
+}
+
// Maintain our remote candidate list, adding this new remote one.
void P2PTransportChannel::RememberRemoteCandidate(
const Candidate& remote_candidate, Port* origin_port) {
@@ -900,8 +913,11 @@
const char *data, size_t len) {
ASSERT(worker_thread_ == talk_base::Thread::Current());
- // Let the client know of an incoming packet
+ // Do not deliver, if packet doesn't belong to the correct transport channel.
+ if (!FindConnection(connection))
+ return;
+ // Let the client know of an incoming packet
SignalReadPacket(this, data, len);
}
@@ -933,7 +949,8 @@
void P2PTransportChannel::OnSignalingReady() {
if (waiting_for_signaling_) {
waiting_for_signaling_ = false;
- AddAllocatorSession(allocator_->CreateSession(name(), content_type()));
+ AddAllocatorSession(allocator_->CreateSession(
+ session_id(), name(), content_type()));
thread()->PostDelayed(kAllocatePeriod, this, MSG_ALLOCATE);
}
}
diff --git a/talk/p2p/base/p2ptransportchannel.h b/talk/p2p/base/p2ptransportchannel.h
index 0083d23..6b4d979 100644
--- a/talk/p2p/base/p2ptransportchannel.h
+++ b/talk/p2p/base/p2ptransportchannel.h
@@ -116,11 +116,12 @@
bool readable);
bool CreateConnection(Port* port, const Candidate& remote_candidate,
Port* origin_port, bool readable);
+ bool FindConnection(cricket::Connection* connection) const;
void RememberRemoteCandidate(const Candidate& remote_candidate,
Port* origin_port);
void OnUnknownAddress(Port *port, const talk_base::SocketAddress &addr,
StunMessage *stun_msg,
- const std::string &remote_username);
+ const std::string &remote_username, bool port_muxed);
void OnPortReady(PortAllocatorSession *session, Port* port);
void OnCandidatesReady(PortAllocatorSession *session,
const std::vector<Candidate>& candidates);
diff --git a/talk/p2p/base/p2ptransportchannel_unittest.cc b/talk/p2p/base/p2ptransportchannel_unittest.cc
new file mode 100644
index 0000000..ae5ab62
--- /dev/null
+++ b/talk/p2p/base/p2ptransportchannel_unittest.cc
@@ -0,0 +1,659 @@
+/*
+ * libjingle
+ * Copyright 2009 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/base/fakenetwork.h"
+#include "talk/base/firewallsocketserver.h"
+#include "talk/base/gunit.h"
+#include "talk/base/helpers.h"
+#include "talk/base/logging.h"
+#include "talk/base/natserver.h"
+#include "talk/base/natsocketfactory.h"
+#include "talk/base/physicalsocketserver.h"
+#include "talk/base/proxyserver.h"
+#include "talk/base/socketaddress.h"
+#include "talk/base/thread.h"
+#include "talk/base/virtualsocketserver.h"
+#include "talk/p2p/base/p2ptransportchannel.h"
+#include "talk/p2p/base/testrelayserver.h"
+#include "talk/p2p/base/teststunserver.h"
+#include "talk/p2p/client/basicportallocator.h"
+
+using talk_base::SocketAddress;
+
+static const int kDefaultTimeout = 1000;
+static const int kOnlyLocalPorts = cricket::PORTALLOCATOR_DISABLE_STUN |
+ cricket::PORTALLOCATOR_DISABLE_RELAY |
+ cricket::PORTALLOCATOR_DISABLE_TCP;
+// Addresses on the public internet.
+static const SocketAddress kPublicAddrs[2] =
+ { SocketAddress("11.11.11.11", 0), SocketAddress("22.22.22.22", 0) };
+// For configuring multihomed clients.
+static const SocketAddress kAlternateAddrs[2] =
+ { SocketAddress("11.11.11.101", 0), SocketAddress("22.22.22.202", 0) };
+// Addresses for HTTP proxy servers.
+static const SocketAddress kHttpsProxyAddrs[2] =
+ { SocketAddress("11.11.11.1", 443), SocketAddress("22.22.22.1", 443) };
+// Addresses for SOCKS proxy servers.
+static const SocketAddress kSocksProxyAddrs[2] =
+ { SocketAddress("11.11.11.1", 1080), SocketAddress("22.22.22.1", 1080) };
+// Internal addresses for NAT boxes.
+static const SocketAddress kNatAddrs[2] =
+ { SocketAddress("192.168.1.1", 0), SocketAddress("192.168.2.1", 0) };
+// Private addresses inside the NAT private networks.
+static const SocketAddress kPrivateAddrs[2] =
+ { SocketAddress("192.168.1.11", 0), SocketAddress("192.168.2.22", 0) };
+// For cascaded NATs, the internal addresses of the inner NAT boxes.
+static const SocketAddress kCascadedNatAddrs[2] =
+ { SocketAddress("192.168.10.1", 0), SocketAddress("192.168.20.1", 0) };
+// For cascaded NATs, private addresses inside the inner private networks.
+static const SocketAddress kCascadedPrivateAddrs[2] =
+ { SocketAddress("192.168.10.11", 0), SocketAddress("192.168.20.22", 0) };
+// The address of the public STUN server.
+static const SocketAddress kStunAddr("99.99.99.1", cricket::STUN_SERVER_PORT);
+// The addresses for the public relay server.
+static const SocketAddress kRelayUdpIntAddr("99.99.99.2", 5000);
+static const SocketAddress kRelayUdpExtAddr("99.99.99.3", 5001);
+static const SocketAddress kRelayTcpIntAddr("99.99.99.2", 5002);
+static const SocketAddress kRelayTcpExtAddr("99.99.99.3", 5003);
+static const SocketAddress kRelaySslTcpIntAddr("99.99.99.2", 5004);
+static const SocketAddress kRelaySslTcpExtAddr("99.99.99.3", 5005);
+
+// This test simulates 2 P2P endpoints that want to establish connectivity
+// with each other over various network topologies and conditions, which can be
+// specified in each individial test.
+// A virtual network (via VirtualSocketServer) along with virtual firewalls and
+// NATs (via Firewall/NATSocketServer) are used to simulate the various network
+// conditions. We can configure the IP addresses of the endpoints,
+// block various types of connectivity, or add arbitrary levels of NAT.
+// We also run a STUN server and a relay server on the virtual network to allow
+// our typical P2P mechanisms to do their thing.
+// For each case, we expect the P2P stack to eventually settle on a specific
+// form of connectivity to the other side. The test checks that the P2P
+// negotiation successfully establishes connectivity within a certain time,
+// and that the result is what we expect.
+// Note that this class is a base class for use by other tests, who will provide
+// specialized test behavior.
+class P2PTransportChannelTestBase : public testing::Test,
+ public sigslot::has_slots<> {
+ public:
+ P2PTransportChannelTestBase()
+ : main_(talk_base::Thread::Current()),
+ pss_(new talk_base::PhysicalSocketServer),
+ vss_(new talk_base::VirtualSocketServer(pss_.get())),
+ nss_(new talk_base::NATSocketServer(vss_.get())),
+ ss_(new talk_base::FirewallSocketServer(nss_.get())),
+ ss_scope_(ss_.get()),
+ stun_server_(main_, kStunAddr),
+ relay_server_(main_, kRelayUdpIntAddr, kRelayUdpExtAddr,
+ kRelayTcpIntAddr, kRelayTcpExtAddr,
+ kRelaySslTcpIntAddr, kRelaySslTcpExtAddr),
+ socks_server1_(ss_.get(), kSocksProxyAddrs[0],
+ ss_.get(), kSocksProxyAddrs[0]),
+ socks_server2_(ss_.get(), kSocksProxyAddrs[1],
+ ss_.get(), kSocksProxyAddrs[1]),
+ allocator1_(&network_manager1_, kStunAddr,
+ kRelayUdpIntAddr, kRelayTcpIntAddr, kRelaySslTcpIntAddr),
+ allocator2_(&network_manager2_, kStunAddr,
+ kRelayUdpIntAddr, kRelayTcpIntAddr, kRelaySslTcpIntAddr) {
+ }
+
+ protected:
+ enum Config {
+ OPEN, // Open to the Internet
+ NAT_FULL_CONE, // NAT, no filtering
+ NAT_ADDR_RESTRICTED, // NAT, must send to an addr to recv
+ NAT_PORT_RESTRICTED, // NAT, must send to an addr+port to recv
+ NAT_SYMMETRIC, // NAT, endpoint-dependent bindings
+ NAT_DOUBLE_CONE, // Double NAT, both cone
+ NAT_SYMMETRIC_THEN_CONE, // Double NAT, symmetric outer, cone inner
+ BLOCK_UDP, // Firewall, UDP in/out blocked
+ BLOCK_UDP_AND_INCOMING_TCP, // Firewall, UDP in/out and TCP in blocked
+ BLOCK_ALL_BUT_OUTGOING_HTTP, // Firewall, only TCP out on 80/443
+ PROXY_HTTPS, // All traffic through HTTPS proxy
+ PROXY_SOCKS, // All traffic through SOCKS proxy
+ NUM_CONFIGS
+ };
+
+ struct Result {
+ Result(const std::string& lt, const std::string lp,
+ const std::string& rt, const std::string rp, int wait)
+ : local_type(lt), local_proto(lp), remote_type(rt), remote_proto(rp),
+ connect_wait(wait) {
+ }
+ std::string local_type;
+ std::string local_proto;
+ std::string remote_type;
+ std::string remote_proto;
+ int connect_wait;
+ };
+
+ // Common results.
+ static const Result kLocalUdpToLocalUdp;
+ static const Result kLocalUdpToStunUdp;
+ static const Result kStunUdpToLocalUdp;
+ static const Result kStunUdpToStunUdp;
+ static const Result kLocalUdpToRelayUdp;
+ static const Result kLocalTcpToLocalTcp;
+
+ static void SetUpTestCase() {
+ // Ensure the RNG is inited.
+ talk_base::InitRandom(NULL, 0);
+ }
+
+ talk_base::NATSocketServer* nat() { return nss_.get(); }
+ talk_base::FirewallSocketServer* fw() { return ss_.get(); }
+
+ cricket::PortAllocator* GetAllocator(int endpoint) {
+ return (endpoint == 0) ? &allocator1_ : &allocator2_;
+ }
+ void AddAddress(int endpoint, const SocketAddress& addr) {
+ talk_base::FakeNetworkManager& manager = (endpoint == 0) ?
+ network_manager1_ : network_manager2_;
+ manager.AddInterface(addr);
+ }
+ void RemoveAddress(int endpoint, const SocketAddress& addr) {
+ talk_base::FakeNetworkManager& manager = (endpoint == 0) ?
+ network_manager1_ : network_manager2_;
+ manager.RemoveInterface(addr);
+ }
+ void SetProxy(int endpoint, talk_base::ProxyType type) {
+ talk_base::ProxyInfo info;
+ info.type = type;
+ info.address = (type == talk_base::PROXY_HTTPS) ?
+ kHttpsProxyAddrs[endpoint] : kSocksProxyAddrs[endpoint];
+ GetAllocator(endpoint)->set_proxy("unittest/1.0", info);
+ }
+ void SetAllocatorFlags(int endpoint, int flags) {
+ GetAllocator(endpoint)->set_flags(flags);
+ }
+
+ void Test(const Result& expected) {
+ int32 connect_start = talk_base::Time(), connect_time;
+
+ // Create the channels and wait for them to connect.
+ CreateChannels();
+ EXPECT_TRUE_WAIT_MARGIN(ch1_.get() != NULL && ch2_.get() != NULL &&
+ ch1_->readable() && ch1_->writable() &&
+ ch2_->readable() && ch2_->writable(),
+ expected.connect_wait,
+ 1000);
+ connect_time = talk_base::TimeSince(connect_start);
+ if (connect_time < expected.connect_wait) {
+ LOG(LS_INFO) << "Connect time: " << connect_time << " ms";
+ } else {
+ LOG(LS_INFO) << "Connect time: " << "TIMEOUT ("
+ << expected.connect_wait << " ms)";
+ }
+
+ // Allow a few turns of the crank for the best connections to emerge.
+ // This may take up to 2 seconds.
+ if (ch1_->best_connection() && ch2_->best_connection()) {
+ int32 converge_start = talk_base::Time(), converge_time;
+ int converge_wait = 2000;
+ EXPECT_TRUE_WAIT_MARGIN(
+ LocalCandidate(ch1_.get())->type() == expected.local_type &&
+ LocalCandidate(ch1_.get())->protocol() == expected.local_proto &&
+ RemoteCandidate(ch1_.get())->type() == expected.remote_type &&
+ RemoteCandidate(ch1_.get())->protocol() == expected.remote_proto,
+ converge_wait,
+ converge_wait);
+
+ // Also do EXPECT_EQ on each part so that failures are more verbose.
+ EXPECT_EQ(expected.local_type, LocalCandidate(ch1_.get())->type());
+ EXPECT_EQ(expected.local_proto, LocalCandidate(ch1_.get())->protocol());
+ EXPECT_EQ(expected.remote_type, RemoteCandidate(ch1_.get())->type());
+ EXPECT_EQ(expected.remote_proto, RemoteCandidate(ch1_.get())->protocol());
+
+ /* TODO: Check ch2 candidates.
+ EXPECT_EQ(expected.local_type2, LocalCandidate(ch1_.get())->type());
+ EXPECT_EQ(expected.local_proto2, LocalCandidate(ch1_.get())->protocol());
+ EXPECT_EQ(expected.remote_type2, RemoteCandidate(ch1_.get())->type());
+ EXPECT_EQ(expected.remote_proto2, RemoteCandidate(ch1_.get())->protocol());
+ */
+
+ converge_time = talk_base::TimeSince(converge_start);
+ if (converge_time < converge_wait) {
+ LOG(LS_INFO) << "Converge time: " << converge_time << " ms";
+ } else {
+ LOG(LS_INFO) << "Converge time: " << "TIMEOUT ("
+ << converge_wait << " ms)";
+ }
+ }
+
+ // TODO: Send some data and make sure it gets there.
+
+ // Destroy the channels, and wait for them to be fully cleaned up.
+ DestroyChannels();
+ }
+
+ void CreateChannels() {
+ ch1_.reset(new cricket::P2PTransportChannel("a", "unittest",
+ NULL, &allocator1_));
+ ch2_.reset(new cricket::P2PTransportChannel("b", "unittest",
+ NULL, &allocator2_));
+ ch1_->SignalRequestSignaling.connect(ch1_.get(),
+ &cricket::P2PTransportChannel::OnSignalingReady);
+ ch2_->SignalRequestSignaling.connect(ch2_.get(),
+ &cricket::P2PTransportChannel::OnSignalingReady);
+ ch1_->SignalCandidateReady.connect(this,
+ &P2PTransportChannelTestBase::OnCandidate);
+ ch2_->SignalCandidateReady.connect(this,
+ &P2PTransportChannelTestBase::OnCandidate);
+ ch1_->Connect();
+ ch2_->Connect();
+ }
+ void DestroyChannels() {
+ ch1_.reset();
+ ch2_.reset();
+ }
+ cricket::P2PTransportChannel* ch1() { return ch1_.get(); }
+ cricket::P2PTransportChannel* ch2() { return ch2_.get(); }
+
+ // We pass the candidates directly to the other side.
+ void OnCandidate(cricket::TransportChannelImpl* ch,
+ const cricket::Candidate& c) {
+ if (ch == ch1_.get()) {
+ LOG(LS_INFO) << "Candidate(1->2): " << c.type() << ", " << c.protocol()
+ << ", " << c.address().ToString() << ", " << c.username()
+ << ", " << c.generation();
+ ch2_->OnCandidate(c);
+ } else {
+ LOG(LS_INFO) << "Candidate(2->1): " << c.type() << ", " << c.protocol()
+ << ", " << c.address().ToString() << ", " << c.username()
+ << ", " << c.generation();
+ ch1_->OnCandidate(c);
+ }
+ }
+ static const cricket::Candidate* LocalCandidate(
+ cricket::P2PTransportChannel* ch) {
+ return (ch && ch->best_connection()) ?
+ &ch->best_connection()->local_candidate() : NULL;
+ }
+ static const cricket::Candidate* RemoteCandidate(
+ cricket::P2PTransportChannel* ch) {
+ return (ch && ch->best_connection()) ?
+ &ch->best_connection()->remote_candidate() : NULL;
+ }
+
+ private:
+ enum { MSG_CONNECT, MSG_DISCONNECT };
+ talk_base::Thread* main_;
+ talk_base::scoped_ptr<talk_base::PhysicalSocketServer> pss_;
+ talk_base::scoped_ptr<talk_base::VirtualSocketServer> vss_;
+ talk_base::scoped_ptr<talk_base::NATSocketServer> nss_;
+ talk_base::scoped_ptr<talk_base::FirewallSocketServer> ss_;
+ talk_base::SocketServerScope ss_scope_;
+ cricket::TestStunServer stun_server_;
+ cricket::TestRelayServer relay_server_;
+ talk_base::SocksProxyServer socks_server1_;
+ talk_base::SocksProxyServer socks_server2_;
+ talk_base::FakeNetworkManager network_manager1_;
+ talk_base::FakeNetworkManager network_manager2_;
+ cricket::BasicPortAllocator allocator1_;
+ cricket::BasicPortAllocator allocator2_;
+ talk_base::scoped_ptr<cricket::P2PTransportChannel> ch1_;
+ talk_base::scoped_ptr<cricket::P2PTransportChannel> ch2_;
+};
+
+// The tests have only a few outcomes, which we predefine.
+const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
+ kLocalUdpToLocalUdp("local", "udp", "local", "udp", 1000);
+const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
+ kLocalUdpToStunUdp("local", "udp", "stun", "udp", 1000);
+const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
+ kStunUdpToLocalUdp("stun", "udp", "local", "udp", 1000);
+const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
+ kStunUdpToStunUdp("stun", "udp", "stun", "udp", 1000);
+const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
+ kLocalUdpToRelayUdp("local", "udp", "relay", "udp", 2000);
+const P2PTransportChannelTestBase::Result P2PTransportChannelTestBase::
+ kLocalTcpToLocalTcp("local", "tcp", "local", "tcp", 3000);
+
+// Test the matrix of all the connectivity types we expect to see in the wild.
+// Just test every combination of the configs in the Config enum.
+class P2PTransportChannelTest : public P2PTransportChannelTestBase {
+ protected:
+ static const Result* kMatrix[NUM_CONFIGS][NUM_CONFIGS];
+ void ConfigureEndpoints(Config config1, Config config2) {
+ ConfigureEndpoint(0, config1);
+ ConfigureEndpoint(1, config2);
+ }
+ void ConfigureEndpoint(int endpoint, Config config) {
+ switch (config) {
+ case OPEN:
+ AddAddress(endpoint, kPublicAddrs[endpoint]);
+ break;
+ case NAT_FULL_CONE:
+ case NAT_ADDR_RESTRICTED:
+ case NAT_PORT_RESTRICTED:
+ case NAT_SYMMETRIC:
+ AddAddress(endpoint, kPrivateAddrs[endpoint]);
+ // Add a single NAT of the desired type
+ nat()->AddTranslator(kPublicAddrs[endpoint], kNatAddrs[endpoint],
+ static_cast<talk_base::NATType>(config - NAT_FULL_CONE))->
+ AddClient(kPrivateAddrs[endpoint]);
+ break;
+ case NAT_DOUBLE_CONE:
+ case NAT_SYMMETRIC_THEN_CONE:
+ AddAddress(endpoint, kCascadedPrivateAddrs[endpoint]);
+ // Add a two cascaded NATs of the desired types
+ nat()->AddTranslator(kPublicAddrs[endpoint], kNatAddrs[endpoint],
+ (config == NAT_DOUBLE_CONE) ?
+ talk_base::NAT_OPEN_CONE : talk_base::NAT_SYMMETRIC)->
+ AddTranslator(kPrivateAddrs[endpoint], kCascadedNatAddrs[endpoint],
+ talk_base::NAT_OPEN_CONE)->
+ AddClient(kCascadedPrivateAddrs[endpoint]);
+ break;
+ case BLOCK_UDP:
+ case BLOCK_UDP_AND_INCOMING_TCP:
+ case BLOCK_ALL_BUT_OUTGOING_HTTP:
+ case PROXY_HTTPS:
+ case PROXY_SOCKS:
+ AddAddress(endpoint, kPublicAddrs[endpoint]);
+ // Block all UDP
+ fw()->AddRule(false, talk_base::FP_UDP, talk_base::FD_ANY,
+ kPublicAddrs[endpoint]);
+ if (config == BLOCK_UDP_AND_INCOMING_TCP) {
+ // Block TCP inbound to the endpoint
+ fw()->AddRule(false, talk_base::FP_TCP, SocketAddress(),
+ kPublicAddrs[endpoint]);
+ } else if (config == BLOCK_ALL_BUT_OUTGOING_HTTP) {
+ // Block all TCP to/from the endpoint except 80/443 out
+ fw()->AddRule(true, talk_base::FP_TCP, kPublicAddrs[endpoint],
+ SocketAddress(talk_base::IPAddress(INADDR_ANY), 80));
+ fw()->AddRule(true, talk_base::FP_TCP, kPublicAddrs[endpoint],
+ SocketAddress(talk_base::IPAddress(INADDR_ANY), 443));
+ fw()->AddRule(false, talk_base::FP_TCP, talk_base::FD_ANY,
+ kPublicAddrs[endpoint]);
+ } else if (config == PROXY_HTTPS) {
+ // Block all TCP to/from the endpoint except to the proxy server
+ fw()->AddRule(true, talk_base::FP_TCP, kPublicAddrs[endpoint],
+ kHttpsProxyAddrs[endpoint]);
+ fw()->AddRule(false, talk_base::FP_TCP, talk_base::FD_ANY,
+ kPublicAddrs[endpoint]);
+ SetProxy(endpoint, talk_base::PROXY_HTTPS);
+ } else if (config == PROXY_SOCKS) {
+ // Block all TCP to/from the endpoint except to the proxy server
+ fw()->AddRule(true, talk_base::FP_TCP, kPublicAddrs[endpoint],
+ kSocksProxyAddrs[endpoint]);
+ fw()->AddRule(false, talk_base::FP_TCP, talk_base::FD_ANY,
+ kPublicAddrs[endpoint]);
+ SetProxy(endpoint, talk_base::PROXY_SOCKS5);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+};
+
+// Shorthands for use in the test matrix.
+#define LULU &kLocalUdpToLocalUdp
+#define LUSU &kLocalUdpToStunUdp
+#define SULU &kStunUdpToLocalUdp
+#define SUSU &kStunUdpToStunUdp
+#define LURU &kLocalUdpToRelayUdp
+#define LTLT &kLocalTcpToLocalTcp
+// TODO: Enable these once TestRelayServer can accept external TCP.
+#define LTRT NULL
+#define LSRS NULL
+
+// Test matrix. Originator behavior defined by rows, receiever by columns.
+// TODO: Fix NULLs caused by lack of TCP support in NATSocket.
+// TODO: Fix NULLs caused by no HTTP proxy support.
+// TODO: Rearrange rows/columns from best to worst.
+const P2PTransportChannelTest::Result*
+ P2PTransportChannelTest::kMatrix[NUM_CONFIGS][NUM_CONFIGS] = {
+// OPEN CONE ADDR PORT SYMM 2CON SCON !UDP !TCP HTTP PRXH PRXS
+/*OP*/ {LULU, LULU, LULU, LULU, LULU, LULU, LULU, LTLT, LTLT, LSRS, NULL, LTLT},
+/*CO*/ {LULU, LULU, LULU, SULU, SULU, LULU, SULU, NULL, NULL, LSRS, NULL, LTRT},
+/*AD*/ {LULU, LULU, LULU, SUSU, SUSU, LULU, SUSU, NULL, NULL, LSRS, NULL, LTRT},
+/*PO*/ {LULU, LUSU, SUSU, SUSU, LURU, LUSU, LURU, NULL, NULL, LSRS, NULL, LTRT},
+/*SY*/ {LULU, LUSU, SUSU, LURU, LURU, LUSU, LURU, NULL, NULL, LSRS, NULL, LTRT},
+/*2C*/ {LULU, LULU, LULU, SULU, SULU, LULU, SULU, NULL, NULL, LSRS, NULL, LTRT},
+/*SC*/ {LULU, LUSU, SUSU, LURU, LURU, LUSU, LURU, NULL, NULL, LSRS, NULL, LTRT},
+/*!U*/ {LTLT, NULL, NULL, NULL, NULL, NULL, NULL, LTLT, LTLT, LSRS, NULL, LTRT},
+/*!T*/ {LTRT, NULL, NULL, NULL, NULL, NULL, NULL, LTLT, LTRT, LSRS, NULL, LTRT},
+/*HT*/ {LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, NULL, LSRS},
+/*PR*/ {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
+/*PR*/ {LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LSRS, NULL, LTRT},
+};
+
+// The actual tests that exercise all the various configurations.
+// Test names are of the form P2PTransportChannelTest_TestOPENToNAT_FULL_CONE
+#define P2P_TEST_DECLARATION(x, y, z) \
+ TEST_F(P2PTransportChannelTest, z##Test##x##To##y) { \
+ ConfigureEndpoints(x, y); \
+ if (kMatrix[x][y] != NULL) \
+ Test(*kMatrix[x][y]); \
+ else \
+ LOG(LS_WARNING) << "Not yet implemented"; \
+ }
+
+#define P2P_TEST(x, y) \
+ P2P_TEST_DECLARATION(x, y,)
+
+#define FLAKY_P2P_TEST(x, y) \
+ P2P_TEST_DECLARATION(x, y, DISABLED_)
+
+#define P2P_TEST_SET(x) \
+ P2P_TEST(x, OPEN) \
+ P2P_TEST(x, NAT_FULL_CONE) \
+ P2P_TEST(x, NAT_ADDR_RESTRICTED) \
+ P2P_TEST(x, NAT_PORT_RESTRICTED) \
+ P2P_TEST(x, NAT_SYMMETRIC) \
+ P2P_TEST(x, NAT_DOUBLE_CONE) \
+ P2P_TEST(x, NAT_SYMMETRIC_THEN_CONE) \
+ P2P_TEST(x, BLOCK_UDP) \
+ P2P_TEST(x, BLOCK_UDP_AND_INCOMING_TCP) \
+ P2P_TEST(x, BLOCK_ALL_BUT_OUTGOING_HTTP) \
+ P2P_TEST(x, PROXY_HTTPS) \
+ P2P_TEST(x, PROXY_SOCKS)
+
+#define FLAKY_P2P_TEST_SET(x) \
+ P2P_TEST(x, OPEN) \
+ P2P_TEST(x, NAT_FULL_CONE) \
+ FLAKY_P2P_TEST(x, NAT_ADDR_RESTRICTED) \
+ P2P_TEST(x, NAT_PORT_RESTRICTED) \
+ P2P_TEST(x, NAT_SYMMETRIC) \
+ P2P_TEST(x, NAT_DOUBLE_CONE) \
+ P2P_TEST(x, NAT_SYMMETRIC_THEN_CONE) \
+ P2P_TEST(x, BLOCK_UDP) \
+ P2P_TEST(x, BLOCK_UDP_AND_INCOMING_TCP) \
+ P2P_TEST(x, BLOCK_ALL_BUT_OUTGOING_HTTP) \
+ P2P_TEST(x, PROXY_HTTPS) \
+ P2P_TEST(x, PROXY_SOCKS)
+
+P2P_TEST_SET(OPEN)
+P2P_TEST_SET(NAT_FULL_CONE)
+FLAKY_P2P_TEST_SET(NAT_ADDR_RESTRICTED)
+FLAKY_P2P_TEST_SET(NAT_PORT_RESTRICTED)
+FLAKY_P2P_TEST_SET(NAT_SYMMETRIC)
+P2P_TEST_SET(NAT_DOUBLE_CONE)
+FLAKY_P2P_TEST_SET(NAT_SYMMETRIC_THEN_CONE)
+P2P_TEST_SET(BLOCK_UDP)
+P2P_TEST_SET(BLOCK_UDP_AND_INCOMING_TCP)
+P2P_TEST_SET(BLOCK_ALL_BUT_OUTGOING_HTTP)
+P2P_TEST_SET(PROXY_HTTPS)
+P2P_TEST_SET(PROXY_SOCKS)
+
+// Test that a host behind NAT cannot be reached when incoming_only
+// is set to true.
+TEST_F(P2PTransportChannelTest, IncomingOnlyBlocked) {
+ ConfigureEndpoints(NAT_FULL_CONE, OPEN);
+
+ CreateChannels();
+ ch1()->set_incoming_only(true);
+
+ // Sleep for 1 second and verify that the channels are not connected.
+ talk_base::Thread::SleepMs(1000);
+
+ EXPECT_FALSE(ch1()->readable());
+ EXPECT_FALSE(ch1()->writable());
+ EXPECT_FALSE(ch2()->readable());
+ EXPECT_FALSE(ch2()->writable());
+
+ DestroyChannels();
+}
+
+// Test that a peer behind NAT can connect to a peer that has
+// incoming_only flag set.
+TEST_F(P2PTransportChannelTest, IncomingOnlyOpen) {
+ ConfigureEndpoints(OPEN, NAT_FULL_CONE);
+
+ CreateChannels();
+ ch1()->set_incoming_only(true);
+
+ EXPECT_TRUE_WAIT_MARGIN(ch1() != NULL && ch2() != NULL &&
+ ch1()->readable() && ch1()->writable() &&
+ ch2()->readable() && ch2()->writable(),
+ 1000, 1000);
+
+ DestroyChannels();
+}
+
+// Test what happens when we have 2 users behind the same NAT. This can lead
+// to interesting behavior because the STUN server will only give out the
+// address of the outermost NAT.
+class P2PTransportChannelSameNatTest : public P2PTransportChannelTestBase {
+ protected:
+ void ConfigureEndpoints(Config nat_type, Config config1, Config config2) {
+ ASSERT(nat_type >= NAT_FULL_CONE && nat_type <= NAT_SYMMETRIC);
+ talk_base::NATSocketServer::Translator* outer_nat =
+ nat()->AddTranslator(kPublicAddrs[0], kNatAddrs[0],
+ static_cast<talk_base::NATType>(nat_type - NAT_FULL_CONE));
+ ConfigureEndpoint(outer_nat, 0, config1);
+ ConfigureEndpoint(outer_nat, 1, config2);
+ }
+ void ConfigureEndpoint(talk_base::NATSocketServer::Translator* nat,
+ int endpoint, Config config) {
+ ASSERT(config <= NAT_SYMMETRIC);
+ if (config == OPEN) {
+ AddAddress(endpoint, kPrivateAddrs[endpoint]);
+ nat->AddClient(kPrivateAddrs[endpoint]);
+ } else {
+ AddAddress(endpoint, kCascadedPrivateAddrs[endpoint]);
+ nat->AddTranslator(kPrivateAddrs[endpoint], kCascadedNatAddrs[endpoint],
+ static_cast<talk_base::NATType>(config - NAT_FULL_CONE))->AddClient(
+ kCascadedPrivateAddrs[endpoint]);
+ }
+ }
+};
+
+TEST_F(P2PTransportChannelSameNatTest, TestConesBehindSameCone) {
+ ConfigureEndpoints(NAT_FULL_CONE, NAT_FULL_CONE, NAT_FULL_CONE);
+ Test(kLocalUdpToLocalUdp);
+}
+
+// Test what happens when we have multiple available pathways.
+// In the future we will try different RTTs and configs for the different
+// interfaces, so that we can simulate a user with Ethernet and VPN networks.
+class P2PTransportChannelMultihomedTest : public P2PTransportChannelTestBase {
+};
+
+// Test that we can establish connectivity when both peers are multihomed.
+TEST_F(P2PTransportChannelMultihomedTest, TestBasic) {
+ AddAddress(0, kPublicAddrs[0]);
+ AddAddress(0, kAlternateAddrs[0]);
+ AddAddress(1, kPublicAddrs[1]);
+ AddAddress(1, kAlternateAddrs[1]);
+ Test(kLocalUdpToLocalUdp);
+}
+
+// Test that we can quickly switch links if an interface goes down.
+TEST_F(P2PTransportChannelMultihomedTest, TestFailover) {
+ AddAddress(0, kPublicAddrs[0]);
+ AddAddress(1, kPublicAddrs[1]);
+ AddAddress(1, kAlternateAddrs[1]);
+ // Use only local ports for simplicity.
+ SetAllocatorFlags(0, kOnlyLocalPorts);
+ SetAllocatorFlags(1, kOnlyLocalPorts);
+
+ // Create channels and let them go writable, as usual.
+ CreateChannels();
+ EXPECT_TRUE_WAIT(ch1()->readable() && ch1()->writable() &&
+ ch2()->readable() && ch2()->writable(),
+ 1000);
+ EXPECT_TRUE(
+ ch1()->best_connection() && ch2()->best_connection() &&
+ LocalCandidate(ch1())->address().EqualIPs(kPublicAddrs[0]) &&
+ RemoteCandidate(ch1())->address().EqualIPs(kPublicAddrs[1]));
+
+ // Blackhole any traffic to or from the public addrs.
+ LOG(LS_INFO) << "Failing over...";
+ fw()->AddRule(false, talk_base::FP_ANY, talk_base::FD_ANY,
+ kPublicAddrs[1]);
+
+ // We should detect loss of connectivity within 5 seconds or so.
+ EXPECT_TRUE_WAIT(!ch1()->writable(), 7000);
+
+ // We should switch over to use the alternate addr immediately
+ // when we lose writability.
+ EXPECT_TRUE_WAIT(
+ ch1()->best_connection() && ch2()->best_connection() &&
+ LocalCandidate(ch1())->address().EqualIPs(kPublicAddrs[0]) &&
+ RemoteCandidate(ch1())->address().EqualIPs(kAlternateAddrs[1]),
+ 3000);
+
+ DestroyChannels();
+}
+
+// Test that we can switch links in a coordinated fashion.
+TEST_F(P2PTransportChannelMultihomedTest, TestDrain) {
+ AddAddress(0, kPublicAddrs[0]);
+ AddAddress(1, kPublicAddrs[1]);
+ // Use only local ports for simplicity.
+ SetAllocatorFlags(0, kOnlyLocalPorts);
+ SetAllocatorFlags(1, kOnlyLocalPorts);
+
+ // Create channels and let them go writable, as usual.
+ CreateChannels();
+ EXPECT_TRUE_WAIT(ch1()->readable() && ch1()->writable() &&
+ ch2()->readable() && ch2()->writable(),
+ 1000);
+ EXPECT_TRUE(
+ ch1()->best_connection() && ch2()->best_connection() &&
+ LocalCandidate(ch1())->address().EqualIPs(kPublicAddrs[0]) &&
+ RemoteCandidate(ch1())->address().EqualIPs(kPublicAddrs[1]));
+
+ // Remove the public interface, add the alternate interface, and allocate
+ // a new generation of candidates for the new interface (via Connect()).
+ LOG(LS_INFO) << "Draining...";
+ AddAddress(1, kAlternateAddrs[1]);
+ RemoveAddress(1, kPublicAddrs[1]);
+ ch2()->Connect();
+
+ // We should switch over to use the alternate address after
+ // an exchange of pings.
+ EXPECT_TRUE_WAIT(
+ ch1()->best_connection() && ch2()->best_connection() &&
+ LocalCandidate(ch1())->address().EqualIPs(kPublicAddrs[0]) &&
+ RemoteCandidate(ch1())->address().EqualIPs(kAlternateAddrs[1]),
+ 3000);
+
+ DestroyChannels();
+}
diff --git a/talk/p2p/base/parsing.cc b/talk/p2p/base/parsing.cc
index a54d379..ebe0596 100644
--- a/talk/p2p/base/parsing.cc
+++ b/talk/p2p/base/parsing.cc
@@ -120,6 +120,14 @@
}
}
+void AddXmlAttrIfNonEmpty(buzz::XmlElement* elem,
+ const buzz::QName name,
+ const std::string& value) {
+ if (!value.empty()) {
+ elem->AddAttr(name, value);
+ }
+}
+
void AddXmlChildren(buzz::XmlElement* parent,
const std::vector<buzz::XmlElement*>& children) {
for (std::vector<buzz::XmlElement*>::const_iterator iter = children.begin();
diff --git a/talk/p2p/base/parsing.h b/talk/p2p/base/parsing.h
index 7931431..96f4e8b 100644
--- a/talk/p2p/base/parsing.h
+++ b/talk/p2p/base/parsing.h
@@ -112,6 +112,7 @@
const buzz::XmlElement* GetXmlChild(const buzz::XmlElement* parent,
const std::string& name);
+
bool RequireXmlChild(const buzz::XmlElement* parent,
const std::string& name,
const buzz::XmlElement** child,
@@ -120,6 +121,9 @@
const buzz::QName& name,
std::string* value,
ParseError* error);
+void AddXmlAttrIfNonEmpty(buzz::XmlElement* elem,
+ const buzz::QName name,
+ const std::string& value);
void AddXmlChildren(buzz::XmlElement* parent,
const std::vector<buzz::XmlElement*>& children);
void CopyXmlChildren(const buzz::XmlElement* source, buzz::XmlElement* dest);
diff --git a/talk/p2p/base/port.cc b/talk/p2p/base/port.cc
index bb4ab26..d47e90e 100644
--- a/talk/p2p/base/port.cc
+++ b/talk/p2p/base/port.cc
@@ -126,7 +126,7 @@
Port::Port(talk_base::Thread* thread, const std::string& type,
talk_base::PacketSocketFactory* factory, talk_base::Network* network,
- uint32 ip, int min_port, int max_port)
+ const talk_base::IPAddress& ip, int min_port, int max_port)
: thread_(thread),
factory_(factory),
type_(type),
@@ -212,7 +212,7 @@
} else if (!msg) {
// STUN message handled already
} else if (msg->type() == STUN_BINDING_REQUEST) {
- SignalUnknownAddress(this, addr, msg, remote_username);
+ SignalUnknownAddress(this, addr, msg, remote_username, false);
} else {
// NOTE(tschmelcher): STUN_BINDING_RESPONSE is benign. It occurs if we
// pruned a connection for this port while it had STUN requests in flight,
@@ -351,7 +351,7 @@
StunAddressAttribute* addr_attr =
StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
addr_attr->SetPort(addr.port());
- addr_attr->SetIP(addr.ip());
+ addr_attr->SetIP(addr.ipaddr());
response.AddAttribute(addr_attr);
// Send the response message.
@@ -528,11 +528,8 @@
}
const Candidate& Connection::local_candidate() const {
- if (local_candidate_index_ < port_->candidates().size())
- return port_->candidates()[local_candidate_index_];
- ASSERT(false);
- static Candidate foo;
- return foo;
+ ASSERT(local_candidate_index_ < port_->candidates().size());
+ return port_->candidates()[local_candidate_index_];
}
void Connection::set_read_state(ReadState value) {
diff --git a/talk/p2p/base/port.h b/talk/p2p/base/port.h
index 8304146..1e81b0a 100644
--- a/talk/p2p/base/port.h
+++ b/talk/p2p/base/port.h
@@ -77,7 +77,7 @@
public:
Port(talk_base::Thread* thread, const std::string& type,
talk_base::PacketSocketFactory* factory, talk_base::Network* network,
- uint32 ip, int min_port, int max_port);
+ const talk_base::IPAddress& ip, int min_port, int max_port);
virtual ~Port();
// The thread on which this port performs its I/O.
@@ -107,7 +107,6 @@
const std::string& password() const { return password_; }
void set_password(const std::string& password) { password_ = password; }
-
// A value in [0,1] that indicates the preference for this port versus other
// ports on this client. (Larger indicates more preference.)
float preference() const { return preference_; }
@@ -141,7 +140,8 @@
const AddressMap& connections() { return connections_; }
// Returns the connection to the given address or NULL if none exists.
- Connection* GetConnection(const talk_base::SocketAddress& remote_addr);
+ virtual Connection* GetConnection(
+ const talk_base::SocketAddress& remote_addr);
// Creates a new connection to the given address.
enum CandidateOrigin { ORIGIN_THIS_PORT, ORIGIN_OTHER_PORT, ORIGIN_MESSAGE };
@@ -160,15 +160,15 @@
// Indicates that we received a successful STUN binding request from an
// address that doesn't correspond to any current connection. To turn this
// into a real connection, call CreateConnection.
- sigslot::signal4<Port*, const talk_base::SocketAddress&, StunMessage*,
- const std::string&> SignalUnknownAddress;
+ sigslot::signal5<Port*, const talk_base::SocketAddress&, StunMessage*,
+ const std::string&, bool> SignalUnknownAddress;
// Sends a response message (normal or error) to the given request. One of
// these methods should be called as a response to SignalUnknownAddress.
// NOTE: You MUST call CreateConnection BEFORE SendBindingResponse.
- void SendBindingResponse(StunMessage* request,
- const talk_base::SocketAddress& addr);
- void SendBindingErrorResponse(
+ virtual void SendBindingResponse(StunMessage* request,
+ const talk_base::SocketAddress& addr);
+ virtual void SendBindingErrorResponse(
StunMessage* request, const talk_base::SocketAddress& addr,
int error_code, const std::string& reason);
@@ -211,6 +211,9 @@
// Debugging description of this port
std::string ToString() const;
+ talk_base::IPAddress& ip() { return ip_; }
+ int min_port() { return min_port_; }
+ int max_port() { return max_port_; }
protected:
// Fills in the local address of the port.
@@ -241,7 +244,7 @@
talk_base::PacketSocketFactory* factory_;
std::string type_;
talk_base::Network* network_;
- uint32 ip_;
+ talk_base::IPAddress ip_;
int min_port_;
int max_port_;
uint32 generation_;
diff --git a/talk/p2p/base/port_unittest.cc b/talk/p2p/base/port_unittest.cc
new file mode 100644
index 0000000..9a84606
--- /dev/null
+++ b/talk/p2p/base/port_unittest.cc
@@ -0,0 +1,761 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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/base/basicpacketsocketfactory.h"
+#include "talk/base/gunit.h"
+#include "talk/base/helpers.h"
+#include "talk/base/host.h"
+#include "talk/base/logging.h"
+#include "talk/base/natserver.h"
+#include "talk/base/natsocketfactory.h"
+#include "talk/base/physicalsocketserver.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/socketaddress.h"
+#include "talk/base/stringutils.h"
+#include "talk/base/thread.h"
+#include "talk/base/virtualsocketserver.h"
+#include "talk/p2p/base/relayport.h"
+#include "talk/p2p/base/stunport.h"
+#include "talk/p2p/base/tcpport.h"
+#include "talk/p2p/base/udpport.h"
+#include "talk/p2p/base/teststunserver.h"
+#include "talk/p2p/base/testrelayserver.h"
+
+using talk_base::AsyncPacketSocket;
+using talk_base::NATType;
+using talk_base::NAT_OPEN_CONE;
+using talk_base::NAT_ADDR_RESTRICTED;
+using talk_base::NAT_PORT_RESTRICTED;
+using talk_base::NAT_SYMMETRIC;
+using talk_base::PacketSocketFactory;
+using talk_base::scoped_ptr;
+using talk_base::Socket;
+using talk_base::SocketAddress;
+using namespace cricket;
+
+static const int kTimeout = 1000;
+static const SocketAddress kLocalAddr1 = SocketAddress("192.168.1.2", 0);
+static const SocketAddress kLocalAddr2 = SocketAddress("192.168.1.3", 0);
+static const SocketAddress kNatAddr1 = SocketAddress("77.77.77.77",
+ talk_base::NAT_SERVER_PORT);
+static const SocketAddress kNatAddr2 = SocketAddress("88.88.88.88",
+ talk_base::NAT_SERVER_PORT);
+static const SocketAddress kStunAddr = SocketAddress("99.99.99.1",
+ STUN_SERVER_PORT);
+static const SocketAddress kRelayUdpIntAddr("99.99.99.2", 5000);
+static const SocketAddress kRelayUdpExtAddr("99.99.99.3", 5001);
+static const SocketAddress kRelayTcpIntAddr("99.99.99.2", 5002);
+static const SocketAddress kRelayTcpExtAddr("99.99.99.3", 5003);
+static const SocketAddress kRelaySslTcpIntAddr("99.99.99.2", 5004);
+static const SocketAddress kRelaySslTcpExtAddr("99.99.99.3", 5005);
+
+static Candidate GetCandidate(Port* port) {
+ assert(port->candidates().size() == 1);
+ return port->candidates()[0];
+}
+
+static SocketAddress GetAddress(Port* port) {
+ return GetCandidate(port).address();
+}
+
+class TestChannel : public sigslot::has_slots<> {
+ public:
+ TestChannel(Port* p1, Port* p2)
+ : src_(p1), dst_(p2), address_count_(0), conn_(NULL),
+ remote_request_(NULL) {
+ src_->SignalAddressReady.connect(this, &TestChannel::OnAddressReady);
+ src_->SignalUnknownAddress.connect(this, &TestChannel::OnUnknownAddress);
+ }
+
+ int address_count() { return address_count_; }
+ Connection* conn() { return conn_; }
+ const SocketAddress& remote_address() { return remote_address_; }
+ const std::string remote_fragment() { return remote_frag_; }
+
+ void Start() {
+ src_->PrepareAddress();
+ }
+ void CreateConnection() {
+ conn_ = src_->CreateConnection(GetCandidate(dst_), Port::ORIGIN_MESSAGE);
+ }
+ void AcceptConnection() {
+ ASSERT_TRUE(remote_request_ != NULL);
+ Candidate c = GetCandidate(dst_);
+ c.set_address(remote_address_);
+ conn_ = src_->CreateConnection(c, Port::ORIGIN_MESSAGE);
+ src_->SendBindingResponse(remote_request_, remote_address_);
+ delete remote_request_;
+ }
+ void Ping() {
+ conn_->Ping(0);
+ }
+ void Stop() {
+ conn_->SignalDestroyed.connect(this, &TestChannel::OnDestroyed);
+ conn_->Destroy();
+ }
+
+ void OnAddressReady(Port* port) {
+ address_count_++;
+ }
+
+ void OnUnknownAddress(Port* port, const SocketAddress& addr,
+ StunMessage* msg, const std::string& rf,
+ bool /*port_muxed*/) {
+ ASSERT_EQ(src_.get(), port);
+ if (!remote_address_.IsAny()) {
+ ASSERT_EQ(remote_address_, addr);
+ delete remote_request_;
+ }
+ remote_address_ = addr;
+ remote_request_ = msg;
+ remote_frag_ = rf;
+ }
+
+ void OnDestroyed(Connection* conn) {
+ ASSERT_EQ(conn_, conn);
+ conn_ = NULL;
+ }
+
+ private:
+ talk_base::Thread* thread_;
+ talk_base::scoped_ptr<Port> src_;
+ Port* dst_;
+
+ int address_count_;
+ Connection* conn_;
+ SocketAddress remote_address_;
+ StunMessage* remote_request_;
+ std::string remote_frag_;
+};
+
+class PortTest : public testing::Test {
+ public:
+ PortTest()
+ : main_(talk_base::Thread::Current()),
+ pss_(new talk_base::PhysicalSocketServer),
+ ss_(new talk_base::VirtualSocketServer(pss_.get())),
+ ss_scope_(ss_.get()),
+ network_("unittest", "unittest", talk_base::IPAddress(INADDR_ANY)),
+ socket_factory_(talk_base::Thread::Current()),
+ nat_factory1_(ss_.get(), kNatAddr1),
+ nat_factory2_(ss_.get(), kNatAddr2),
+ nat_socket_factory1_(&nat_factory1_),
+ nat_socket_factory2_(&nat_factory2_),
+ stun_server_(main_, kStunAddr),
+ relay_server_(main_, kRelayUdpIntAddr, kRelayUdpExtAddr,
+ kRelayTcpIntAddr, kRelayTcpExtAddr,
+ kRelaySslTcpIntAddr, kRelaySslTcpExtAddr) {
+ }
+
+ protected:
+ static void SetUpTestCase() {
+ // Ensure the RNG is inited.
+ talk_base::InitRandom(NULL, 0);
+ }
+
+ void TestLocalToLocal() {
+ UDPPort* port1 = CreateUdpPort(kLocalAddr1);
+ UDPPort* port2 = CreateUdpPort(kLocalAddr2);
+ TestConnectivity("udp", port1, "udp", port2, true, true, true, true);
+ }
+ void TestLocalToStun(NATType type) {
+ UDPPort* port1 = CreateUdpPort(kLocalAddr1);
+ nat_server2_.reset(CreateNatServer(kNatAddr2, type));
+ StunPort* port2 = CreateStunPort(kLocalAddr2, &nat_socket_factory2_);
+ TestConnectivity("udp", port1, StunName(type), port2,
+ type == NAT_OPEN_CONE, true, type != NAT_SYMMETRIC, true);
+ }
+ void TestLocalToRelay(ProtocolType proto) {
+ UDPPort* port1 = CreateUdpPort(kLocalAddr1);
+ RelayPort* port2 = CreateRelayPort(kLocalAddr2, proto, PROTO_UDP);
+ TestConnectivity("udp", port1, RelayName(proto), port2,
+ true, true, true, true);
+ }
+ void TestStunToLocal(NATType type) {
+ nat_server1_.reset(CreateNatServer(kNatAddr1, type));
+ StunPort* port1 = CreateStunPort(kLocalAddr1, &nat_socket_factory1_);
+ UDPPort* port2 = CreateUdpPort(kLocalAddr2);
+ TestConnectivity(StunName(type), port1, "udp", port2,
+ true, type != NAT_SYMMETRIC, true, true);
+ }
+ void TestStunToStun(NATType type1, NATType type2) {
+ nat_server1_.reset(CreateNatServer(kNatAddr1, type1));
+ StunPort* port1 = CreateStunPort(kLocalAddr1, &nat_socket_factory1_);
+ nat_server2_.reset(CreateNatServer(kNatAddr2, type2));
+ StunPort* port2 = CreateStunPort(kLocalAddr2, &nat_socket_factory2_);
+ TestConnectivity(StunName(type1), port1, StunName(type2), port2,
+ type2 == NAT_OPEN_CONE,
+ type1 != NAT_SYMMETRIC, type2 != NAT_SYMMETRIC,
+ type1 + type2 < (NAT_PORT_RESTRICTED + NAT_SYMMETRIC));
+ }
+ void TestStunToRelay(NATType type, ProtocolType proto) {
+ nat_server1_.reset(CreateNatServer(kNatAddr1, type));
+ StunPort* port1 = CreateStunPort(kLocalAddr1, &nat_socket_factory1_);
+ RelayPort* port2 = CreateRelayPort(kLocalAddr2, proto, PROTO_UDP);
+ TestConnectivity(StunName(type), port1, RelayName(proto), port2,
+ true, type != NAT_SYMMETRIC, true, true);
+ }
+ void TestTcpToTcp() {
+ TCPPort* port1 = CreateTcpPort(kLocalAddr1);
+ TCPPort* port2 = CreateTcpPort(kLocalAddr2);
+ TestConnectivity("tcp", port1, "tcp", port2, true, false, true, true);
+ }
+ void TestTcpToRelay(ProtocolType proto) {
+ TCPPort* port1 = CreateTcpPort(kLocalAddr1);
+ RelayPort* port2 = CreateRelayPort(kLocalAddr2, proto, PROTO_TCP);
+ TestConnectivity("tcp", port1, RelayName(proto), port2,
+ true, false, true, true);
+ }
+ void TestSslTcpToRelay(ProtocolType proto) {
+ TCPPort* port1 = CreateTcpPort(kLocalAddr1);
+ RelayPort* port2 = CreateRelayPort(kLocalAddr2, proto, PROTO_SSLTCP);
+ TestConnectivity("ssltcp", port1, RelayName(proto), port2,
+ true, false, true, true);
+ }
+
+ // helpers for above functions
+ UDPPort* CreateUdpPort(const SocketAddress& addr) {
+ return CreateUdpPort(addr, &socket_factory_);
+ }
+ UDPPort* CreateUdpPort(const SocketAddress& addr,
+ PacketSocketFactory* socket_factory) {
+ return UDPPort::Create(main_, socket_factory, &network_,
+ addr.ipaddr(), 0, 0);
+ }
+ TCPPort* CreateTcpPort(const SocketAddress& addr) {
+ return CreateTcpPort(addr, &socket_factory_);
+ }
+ TCPPort* CreateTcpPort(const SocketAddress& addr,
+ PacketSocketFactory* socket_factory) {
+ return TCPPort::Create(main_, socket_factory, &network_,
+ addr.ipaddr(), 0, 0, true);
+ }
+ StunPort* CreateStunPort(const SocketAddress& addr,
+ talk_base::PacketSocketFactory* factory) {
+ return StunPort::Create(main_, factory, &network_,
+ addr.ipaddr(), 0, 0, kStunAddr);
+ }
+ RelayPort* CreateRelayPort(const SocketAddress& addr,
+ ProtocolType int_proto, ProtocolType ext_proto) {
+ std::string user = talk_base::CreateRandomString(16);
+ std::string pass = talk_base::CreateRandomString(16);
+ RelayPort* port = RelayPort::Create(main_, &socket_factory_, &network_,
+ addr.ipaddr(), 0, 0, user, pass, "");
+ SocketAddress addrs[] =
+ { kRelayUdpIntAddr, kRelayTcpIntAddr, kRelaySslTcpIntAddr };
+ port->AddServerAddress(ProtocolAddress(addrs[int_proto], int_proto));
+ // TODO: Add an external address for ext_proto, so that the
+ // other side can connect to this port using a non-UDP protocol.
+ return port;
+ }
+ talk_base::NATServer* CreateNatServer(const SocketAddress& addr,
+ talk_base::NATType type) {
+ return new talk_base::NATServer(type, ss_.get(), addr, ss_.get(), addr);
+ }
+ static const char* StunName(NATType type) {
+ switch (type) {
+ case NAT_OPEN_CONE: return "stun(open cone)";
+ case NAT_ADDR_RESTRICTED: return "stun(addr restricted)";
+ case NAT_PORT_RESTRICTED: return "stun(port restricted)";
+ case NAT_SYMMETRIC: return "stun(symmetric)";
+ default: return "stun(?)";
+ }
+ }
+ static const char* RelayName(ProtocolType type) {
+ switch (type) {
+ case PROTO_UDP: return "relay(udp)";
+ case PROTO_TCP: return "relay(tcp)";
+ case PROTO_SSLTCP: return "relay(ssltcp)";
+ default: return "relay(?)";
+ }
+ }
+
+ // this does all the work
+ void TestConnectivity(const char* name1, Port* port1,
+ const char* name2, Port* port2,
+ bool accept, bool same_addr1,
+ bool same_addr2, bool possible);
+
+ private:
+ talk_base::Thread* main_;
+ talk_base::scoped_ptr<talk_base::PhysicalSocketServer> pss_;
+ talk_base::scoped_ptr<talk_base::VirtualSocketServer> ss_;
+ talk_base::SocketServerScope ss_scope_;
+ talk_base::Network network_;
+ talk_base::BasicPacketSocketFactory socket_factory_;
+ talk_base::scoped_ptr<talk_base::NATServer> nat_server1_;
+ talk_base::scoped_ptr<talk_base::NATServer> nat_server2_;
+ talk_base::NATSocketFactory nat_factory1_;
+ talk_base::NATSocketFactory nat_factory2_;
+ talk_base::BasicPacketSocketFactory nat_socket_factory1_;
+ talk_base::BasicPacketSocketFactory nat_socket_factory2_;
+ TestStunServer stun_server_;
+ TestRelayServer relay_server_;
+};
+
+void PortTest::TestConnectivity(const char* name1, Port* port1,
+ const char* name2, Port* port2,
+ bool accept, bool same_addr1,
+ bool same_addr2, bool possible) {
+ LOG(LS_INFO) << "Test: " << name1 << " to " << name2 << ": ";
+ port1->set_name("src");
+ port2->set_name("dst");
+
+ // Set up channels.
+ TestChannel ch1(port1, port2);
+ TestChannel ch2(port2, port1);
+ EXPECT_EQ(0, ch1.address_count());
+ EXPECT_EQ(0, ch2.address_count());
+
+ // Acquire addresses.
+ ch1.Start();
+ ch2.Start();
+ ASSERT_EQ_WAIT(1, ch1.address_count(), kTimeout);
+ ASSERT_EQ_WAIT(1, ch2.address_count(), kTimeout);
+
+ // Send a ping from src to dst. This may or may not make it.
+ ch1.CreateConnection();
+ ASSERT_TRUE(ch1.conn() != NULL);
+ EXPECT_TRUE_WAIT(ch1.conn()->connected(), kTimeout); // for TCP connect
+ ch1.Ping();
+ WAIT(!ch2.remote_address().IsAny(), kTimeout);
+
+ if (accept) {
+ // We are able to send a ping from src to dst. This is the case when
+ // sending to UDP ports and cone NATs.
+ EXPECT_TRUE(ch1.remote_address().IsAny());
+ EXPECT_EQ(ch2.remote_fragment(), port1->username_fragment());
+
+ // Ensure the ping came from the same address used for src.
+ // This is the case unless the source NAT was symmetric.
+ if (same_addr1) EXPECT_EQ(ch2.remote_address(), GetAddress(port1));
+ EXPECT_TRUE(same_addr2);
+
+ // Send a ping from dst to src.
+ ch2.AcceptConnection();
+ ASSERT_TRUE(ch2.conn() != NULL);
+ ch2.Ping();
+ EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch2.conn()->write_state(),
+ kTimeout);
+ } else {
+ // We can't send a ping from src to dst, so flip it around. This will happen
+ // when the destination NAT is addr/port restricted or symmetric.
+ EXPECT_TRUE(ch1.remote_address().IsAny());
+ EXPECT_TRUE(ch2.remote_address().IsAny());
+
+ // Send a ping from dst to src. Again, this may or may not make it.
+ ch2.CreateConnection();
+ ASSERT_TRUE(ch2.conn() != NULL);
+ ch2.Ping();
+ WAIT(ch2.conn()->write_state() == Connection::STATE_WRITABLE, kTimeout);
+
+ if (same_addr1 && same_addr2) {
+ // The new ping got back to the source.
+ EXPECT_EQ(Connection::STATE_READABLE, ch1.conn()->read_state());
+ EXPECT_EQ(Connection::STATE_WRITABLE, ch2.conn()->write_state());
+
+ // First connection may not be writable if the first ping did not get
+ // through. So we will have to do another.
+ if (ch1.conn()->write_state() == Connection::STATE_WRITE_CONNECT) {
+ ch1.Ping();
+ EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),
+ kTimeout);
+ }
+ } else if (!same_addr1 && possible) {
+ // The new ping went to the candidate address, but that address was bad.
+ // This will happen when the source NAT is symmetric.
+ EXPECT_TRUE(ch1.remote_address().IsAny());
+ EXPECT_TRUE(ch2.remote_address().IsAny());
+
+ // However, since we have now sent a ping to the source IP, we should be
+ // able to get a ping from it. This gives us the real source address.
+ ch1.Ping();
+ EXPECT_TRUE_WAIT(!ch2.remote_address().IsAny(), kTimeout);
+ EXPECT_EQ(Connection::STATE_READ_TIMEOUT, ch2.conn()->read_state());
+ EXPECT_TRUE(ch1.remote_address().IsAny());
+
+ // Pick up the actual address and establish the connection.
+ ch2.AcceptConnection();
+ ASSERT_TRUE(ch2.conn() != NULL);
+ ch2.Ping();
+ EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch2.conn()->write_state(),
+ kTimeout);
+ } else if (!same_addr2 && possible) {
+ // The new ping came in, but from an unexpected address. This will happen
+ // when the destination NAT is symmetric.
+ EXPECT_FALSE(ch1.remote_address().IsAny());
+ EXPECT_EQ(Connection::STATE_READ_TIMEOUT, ch1.conn()->read_state());
+
+ // Update our address and complete the connection.
+ ch1.AcceptConnection();
+ ch1.Ping();
+ EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),
+ kTimeout);
+ } else { // (!possible)
+ // There should be s no way for the pings to reach each other. Check it.
+ EXPECT_TRUE(ch1.remote_address().IsAny());
+ EXPECT_TRUE(ch2.remote_address().IsAny());
+ ch1.Ping();
+ WAIT(!ch2.remote_address().IsAny(), kTimeout);
+ EXPECT_TRUE(ch1.remote_address().IsAny());
+ EXPECT_TRUE(ch2.remote_address().IsAny());
+ }
+ }
+
+ // Everything should be good, unless we know the situation is impossible.
+ ASSERT_TRUE(ch1.conn() != NULL);
+ ASSERT_TRUE(ch2.conn() != NULL);
+ if (possible) {
+ EXPECT_EQ(Connection::STATE_READABLE, ch1.conn()->read_state());
+ EXPECT_EQ(Connection::STATE_WRITABLE, ch1.conn()->write_state());
+ EXPECT_EQ(Connection::STATE_READABLE, ch2.conn()->read_state());
+ EXPECT_EQ(Connection::STATE_WRITABLE, ch2.conn()->write_state());
+ } else {
+ EXPECT_NE(Connection::STATE_READABLE, ch1.conn()->read_state());
+ EXPECT_NE(Connection::STATE_WRITABLE, ch1.conn()->write_state());
+ EXPECT_NE(Connection::STATE_READABLE, ch2.conn()->read_state());
+ EXPECT_NE(Connection::STATE_WRITABLE, ch2.conn()->write_state());
+ }
+
+ // Tear down and ensure that goes smoothly.
+ ch1.Stop();
+ ch2.Stop();
+ EXPECT_TRUE_WAIT(ch1.conn() == NULL, kTimeout);
+ EXPECT_TRUE_WAIT(ch2.conn() == NULL, kTimeout);
+}
+
+class FakePacketSocketFactory : public talk_base::PacketSocketFactory {
+ public:
+ FakePacketSocketFactory()
+ : next_udp_socket_(NULL),
+ next_server_tcp_socket_(NULL),
+ next_client_tcp_socket_(NULL) {
+ }
+ virtual ~FakePacketSocketFactory() { }
+
+ virtual AsyncPacketSocket* CreateUdpSocket(
+ const SocketAddress& address, int min_port, int max_port) {
+ EXPECT_TRUE(next_udp_socket_ != NULL);
+ AsyncPacketSocket* result = next_udp_socket_;
+ next_udp_socket_ = NULL;
+ return result;
+ }
+
+ virtual AsyncPacketSocket* CreateServerTcpSocket(
+ const SocketAddress& local_address, int min_port, int max_port,
+ bool ssl) {
+ EXPECT_TRUE(next_server_tcp_socket_ != NULL);
+ AsyncPacketSocket* result = next_server_tcp_socket_;
+ next_server_tcp_socket_ = NULL;
+ return result;
+ }
+
+ // TODO: |proxy_info| and |user_agent| should be set
+ // per-factory and not when socket is created.
+ virtual AsyncPacketSocket* CreateClientTcpSocket(
+ const SocketAddress& local_address, const SocketAddress& remote_address,
+ const talk_base::ProxyInfo& proxy_info,
+ const std::string& user_agent, bool ssl) {
+ EXPECT_TRUE(next_client_tcp_socket_ != NULL);
+ AsyncPacketSocket* result = next_client_tcp_socket_;
+ next_client_tcp_socket_ = NULL;
+ return result;
+ }
+
+ void set_next_udp_socket(AsyncPacketSocket* next_udp_socket) {
+ next_udp_socket_ = next_udp_socket;
+ }
+ void set_next_server_tcp_socket(AsyncPacketSocket* next_server_tcp_socket) {
+ next_server_tcp_socket_ = next_server_tcp_socket;
+ }
+ void set_next_client_tcp_socket(AsyncPacketSocket* next_client_tcp_socket) {
+ next_client_tcp_socket_ = next_client_tcp_socket;
+ }
+
+ private:
+ AsyncPacketSocket* next_udp_socket_;
+ AsyncPacketSocket* next_server_tcp_socket_;
+ AsyncPacketSocket* next_client_tcp_socket_;
+};
+
+class FakeAsyncPacketSocket : public AsyncPacketSocket {
+ public:
+ // Returns current local address. Address may be set to NULL if the
+ // socket is not bound yet (GetState() returns STATE_BINDING).
+ virtual SocketAddress GetLocalAddress() const {
+ return SocketAddress();
+ }
+
+ // Returns remote address. Returns zeroes if this is not a client TCP socket.
+ virtual SocketAddress GetRemoteAddress() const {
+ return SocketAddress();
+ }
+
+ // Send a packet.
+ virtual int Send(const void *pv, size_t cb) {
+ return cb;
+ }
+ virtual int SendTo(const void *pv, size_t cb, const SocketAddress& addr) {
+ return cb;
+ }
+ virtual int Close() {
+ return 0;
+ }
+
+ virtual State GetState() const { return state_; }
+ virtual int GetOption(Socket::Option opt, int* value) { return 0; }
+ virtual int SetOption(Socket::Option opt, int value) { return 0; }
+ virtual int GetError() const { return 0; }
+ virtual void SetError(int error) { }
+
+ void set_state(State state) { state_ = state; }
+
+ private:
+ State state_;
+};
+
+// Local -> XXXX
+TEST_F(PortTest, TestLocalToLocal) {
+ TestLocalToLocal();
+}
+
+TEST_F(PortTest, TestLocalToConeNat) {
+ TestLocalToStun(NAT_OPEN_CONE);
+}
+
+TEST_F(PortTest, TestLocalToARNat) {
+ TestLocalToStun(NAT_ADDR_RESTRICTED);
+}
+
+TEST_F(PortTest, TestLocalToPRNat) {
+ TestLocalToStun(NAT_PORT_RESTRICTED);
+}
+
+TEST_F(PortTest, TestLocalToSymNat) {
+ TestLocalToStun(NAT_SYMMETRIC);
+}
+
+TEST_F(PortTest, TestLocalToRelay) {
+ TestLocalToRelay(PROTO_UDP);
+}
+
+TEST_F(PortTest, TestLocalToTcpRelay) {
+ TestLocalToRelay(PROTO_TCP);
+}
+
+TEST_F(PortTest, TestLocalToSslTcpRelay) {
+ TestLocalToRelay(PROTO_SSLTCP);
+}
+
+// Cone NAT -> XXXX
+TEST_F(PortTest, TestConeNatToLocal) {
+ TestStunToLocal(NAT_OPEN_CONE);
+}
+
+TEST_F(PortTest, TestConeNatToConeNat) {
+ TestStunToStun(NAT_OPEN_CONE, NAT_OPEN_CONE);
+}
+
+TEST_F(PortTest, TestConeNatToARNat) {
+ TestStunToStun(NAT_OPEN_CONE, NAT_ADDR_RESTRICTED);
+}
+
+TEST_F(PortTest, TestConeNatToPRNat) {
+ TestStunToStun(NAT_OPEN_CONE, NAT_PORT_RESTRICTED);
+}
+
+TEST_F(PortTest, TestConeNatToSymNat) {
+ TestStunToStun(NAT_OPEN_CONE, NAT_SYMMETRIC);
+}
+
+TEST_F(PortTest, TestConeNatToRelay) {
+ TestStunToRelay(NAT_OPEN_CONE, PROTO_UDP);
+}
+
+TEST_F(PortTest, TestConeNatToTcpRelay) {
+ TestStunToRelay(NAT_OPEN_CONE, PROTO_TCP);
+}
+
+// Address-restricted NAT -> XXXX
+TEST_F(PortTest, TestARNatToLocal) {
+ TestStunToLocal(NAT_ADDR_RESTRICTED);
+}
+
+TEST_F(PortTest, TestARNatToConeNat) {
+ TestStunToStun(NAT_ADDR_RESTRICTED, NAT_OPEN_CONE);
+}
+
+TEST_F(PortTest, TestARNatToARNat) {
+ TestStunToStun(NAT_ADDR_RESTRICTED, NAT_ADDR_RESTRICTED);
+}
+
+TEST_F(PortTest, TestARNatToPRNat) {
+ TestStunToStun(NAT_ADDR_RESTRICTED, NAT_PORT_RESTRICTED);
+}
+
+TEST_F(PortTest, TestARNatToSymNat) {
+ TestStunToStun(NAT_ADDR_RESTRICTED, NAT_SYMMETRIC);
+}
+
+TEST_F(PortTest, TestARNatToRelay) {
+ TestStunToRelay(NAT_ADDR_RESTRICTED, PROTO_UDP);
+}
+
+TEST_F(PortTest, TestARNATNatToTcpRelay) {
+ TestStunToRelay(NAT_ADDR_RESTRICTED, PROTO_TCP);
+}
+
+// Port-restricted NAT -> XXXX
+TEST_F(PortTest, TestPRNatToLocal) {
+ TestStunToLocal(NAT_PORT_RESTRICTED);
+}
+
+TEST_F(PortTest, TestPRNatToConeNat) {
+ TestStunToStun(NAT_PORT_RESTRICTED, NAT_OPEN_CONE);
+}
+
+TEST_F(PortTest, TestPRNatToARNat) {
+ TestStunToStun(NAT_PORT_RESTRICTED, NAT_ADDR_RESTRICTED);
+}
+
+TEST_F(PortTest, TestPRNatToPRNat) {
+ TestStunToStun(NAT_PORT_RESTRICTED, NAT_PORT_RESTRICTED);
+}
+
+TEST_F(PortTest, TestPRNatToSymNat) {
+ // Will "fail"
+ TestStunToStun(NAT_PORT_RESTRICTED, NAT_SYMMETRIC);
+}
+
+TEST_F(PortTest, TestPRNatToRelay) {
+ TestStunToRelay(NAT_PORT_RESTRICTED, PROTO_UDP);
+}
+
+TEST_F(PortTest, TestPRNatToTcpRelay) {
+ TestStunToRelay(NAT_PORT_RESTRICTED, PROTO_TCP);
+}
+
+// Symmetric NAT -> XXXX
+TEST_F(PortTest, TestSymNatToLocal) {
+ TestStunToLocal(NAT_SYMMETRIC);
+}
+
+TEST_F(PortTest, TestSymNatToConeNat) {
+ TestStunToStun(NAT_SYMMETRIC, NAT_OPEN_CONE);
+}
+
+TEST_F(PortTest, TestSymNatToARNat) {
+ TestStunToStun(NAT_SYMMETRIC, NAT_ADDR_RESTRICTED);
+}
+
+TEST_F(PortTest, TestSymNatToPRNat) {
+ // Will "fail"
+ TestStunToStun(NAT_SYMMETRIC, NAT_PORT_RESTRICTED);
+}
+
+TEST_F(PortTest, TestSymNatToSymNat) {
+ // Will "fail"
+ TestStunToStun(NAT_SYMMETRIC, NAT_SYMMETRIC);
+}
+
+TEST_F(PortTest, TestSymNatToRelay) {
+ TestStunToRelay(NAT_SYMMETRIC, PROTO_UDP);
+}
+
+TEST_F(PortTest, TestSymNatToTcpRelay) {
+ TestStunToRelay(NAT_SYMMETRIC, PROTO_TCP);
+}
+
+// Outbound TCP -> XXXX
+TEST_F(PortTest, TestTcpToTcp) {
+ TestTcpToTcp();
+}
+
+/* TODO: Enable these once testrelayserver can accept external TCP.
+TEST_F(PortTest, TestTcpToTcpRelay) {
+ TestTcpToRelay(PROTO_TCP);
+}
+
+TEST_F(PortTest, TestTcpToSslTcpRelay) {
+ TestTcpToRelay(PROTO_SSLTCP);
+}
+*/
+
+// Outbound SSLTCP -> XXXX
+/* TODO: Enable these once testrelayserver can accept external SSL.
+TEST_F(PortTest, TestSslTcpToTcpRelay) {
+ TestSslTcpToRelay(PROTO_TCP);
+}
+
+TEST_F(PortTest, TestSslTcpToSslTcpRelay) {
+ TestSslTcpToRelay(PROTO_SSLTCP);
+}
+*/
+
+TEST_F(PortTest, TestTcpNoDelay) {
+ TCPPort* port1 = CreateTcpPort(kLocalAddr1);
+ int option_value = -1;
+ int success = port1->GetOption(talk_base::Socket::OPT_NODELAY,
+ &option_value);
+ ASSERT_EQ(0, success); // GetOption() should complete successfully w/ 0
+ ASSERT_EQ(1, option_value);
+ delete port1;
+}
+
+TEST_F(PortTest, TestDelayedBindingUdp) {
+ FakeAsyncPacketSocket *socket = new FakeAsyncPacketSocket();
+ FakePacketSocketFactory socket_factory;
+
+ socket_factory.set_next_udp_socket(socket);
+ scoped_ptr<UDPPort> port(
+ CreateUdpPort(kLocalAddr1, &socket_factory));
+
+ socket->set_state(AsyncPacketSocket::STATE_BINDING);
+ port->PrepareAddress();
+
+ EXPECT_EQ(0U, port->candidates().size());
+ socket->SignalAddressReady(socket, kLocalAddr2);
+
+ EXPECT_EQ(1U, port->candidates().size());
+}
+
+TEST_F(PortTest, TestDelayedBindingTcp) {
+ FakeAsyncPacketSocket *socket = new FakeAsyncPacketSocket();
+ FakePacketSocketFactory socket_factory;
+
+ socket_factory.set_next_server_tcp_socket(socket);
+ scoped_ptr<TCPPort> port(
+ CreateTcpPort(kLocalAddr1, &socket_factory));
+
+ socket->set_state(AsyncPacketSocket::STATE_BINDING);
+ port->PrepareAddress();
+
+ EXPECT_EQ(0U, port->candidates().size());
+ socket->SignalAddressReady(socket, kLocalAddr2);
+
+ EXPECT_EQ(1U, port->candidates().size());
+}
diff --git a/talk/p2p/base/portallocator.cc b/talk/p2p/base/portallocator.cc
new file mode 100644
index 0000000..974117f
--- /dev/null
+++ b/talk/p2p/base/portallocator.cc
@@ -0,0 +1,83 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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/p2p/base/portallocator.h"
+
+#include "talk/p2p/base/portallocatorsessionproxy.h"
+
+namespace cricket {
+
+PortAllocator::~PortAllocator() {
+ for (SessionMuxerMap::iterator iter = muxers_.begin();
+ iter != muxers_.end(); ++iter) {
+ delete iter->second;
+ }
+}
+
+PortAllocatorSession* PortAllocator::CreateSession(
+ const std::string& sid,
+ const std::string& name,
+ const std::string& session_type) {
+ if (flags_ & PORTALLOCATOR_ENABLE_BUNDLE) {
+ PortAllocatorSessionMuxer* muxer = GetSessionMuxer(sid);
+ if (!muxer) {
+ PortAllocatorSession* session_impl = CreateSession(name, session_type);
+ // Create PortAllocatorSessionMuxer object for |session_impl|.
+ muxer = new PortAllocatorSessionMuxer(session_impl);
+ muxer->SignalDestroyed.connect(
+ this, &PortAllocator::OnSessionMuxerDestroyed);
+ // Add PortAllocatorSession to the map.
+ muxers_[sid] = muxer;
+ }
+ PortAllocatorSessionProxy* proxy =
+ new PortAllocatorSessionProxy(name, session_type, flags_);
+ muxer->RegisterSessionProxy(proxy);
+ return proxy;
+ }
+ return CreateSession(name, session_type);
+}
+
+PortAllocatorSessionMuxer* PortAllocator::GetSessionMuxer(
+ const std::string& sid) const {
+ SessionMuxerMap::const_iterator iter = muxers_.find(sid);
+ if (iter != muxers_.end())
+ return iter->second;
+ return NULL;
+}
+
+void PortAllocator::OnSessionMuxerDestroyed(
+ PortAllocatorSessionMuxer* session) {
+ SessionMuxerMap::iterator iter;
+ for (iter = muxers_.begin(); iter != muxers_.end(); ++iter) {
+ if (iter->second == session)
+ break;
+ }
+ if (iter != muxers_.end())
+ muxers_.erase(iter);
+}
+
+} // namespace cricket
diff --git a/talk/p2p/base/portallocator.h b/talk/p2p/base/portallocator.h
index 175bdbc..79a08c1 100644
--- a/talk/p2p/base/portallocator.h
+++ b/talk/p2p/base/portallocator.h
@@ -47,18 +47,31 @@
const uint32 PORTALLOCATOR_DISABLE_RELAY = 0x04;
const uint32 PORTALLOCATOR_DISABLE_TCP = 0x08;
const uint32 PORTALLOCATOR_ENABLE_SHAKER = 0x10;
+const uint32 PORTALLOCATOR_ENABLE_BUNDLE = 0x20;
const uint32 kDefaultPortAllocatorFlags = 0;
+class PortAllocatorSessionMuxer;
+
class PortAllocatorSession : public sigslot::has_slots<> {
public:
- explicit PortAllocatorSession(uint32 flags) : flags_(flags) {}
+ // TODO Remove session_type argument (and other places), as
+ // its not used.
+ explicit PortAllocatorSession(const std::string& name,
+ const std::string& session_type,
+ uint32 flags) :
+ name_(name),
+ session_type_(session_type),
+ flags_(flags) {
+ }
// Subclasses should clean up any ports created.
virtual ~PortAllocatorSession() {}
uint32 flags() const { return flags_; }
void set_flags(uint32 flags) { flags_ = flags; }
+ const std::string& name() const { return name_; }
+ const std::string& session_type() const { return session_type_; }
// Prepares an initial set of ports to try.
virtual void GetInitialPorts() = 0;
@@ -74,23 +87,33 @@
uint32 generation() { return generation_; }
void set_generation(uint32 generation) { generation_ = generation; }
+ sigslot::signal1<PortAllocatorSession*> SignalDestroyed;
+
+ protected:
+ std::string name_;
+ std::string session_type_;
private:
uint32 flags_;
uint32 generation_;
};
-class PortAllocator {
+class PortAllocator : public sigslot::has_slots<> {
public:
PortAllocator() :
flags_(kDefaultPortAllocatorFlags),
min_port_(0),
max_port_(0) {
}
- virtual ~PortAllocator() {}
+ virtual ~PortAllocator();
- virtual PortAllocatorSession *CreateSession(const std::string &name,
- const std::string &session_type) = 0;
+ PortAllocatorSession* CreateSession(
+ const std::string& sid,
+ const std::string& name,
+ const std::string& session_type);
+
+ PortAllocatorSessionMuxer* GetSessionMuxer(const std::string& sid) const;
+ void OnSessionMuxerDestroyed(PortAllocatorSessionMuxer* session);
uint32 flags() const { return flags_; }
void set_flags(uint32 flags) { flags_ = flags; }
@@ -116,11 +139,18 @@
}
protected:
+ virtual PortAllocatorSession* CreateSession(const std::string &name,
+ const std::string &session_type) = 0;
+
+ typedef std::map<std::string, PortAllocatorSessionMuxer*> SessionMuxerMap;
+
uint32 flags_;
std::string agent_;
talk_base::ProxyInfo proxy_;
int min_port_;
int max_port_;
+
+ SessionMuxerMap muxers_;
};
} // namespace cricket
diff --git a/talk/p2p/base/portallocatorsessionproxy.cc b/talk/p2p/base/portallocatorsessionproxy.cc
new file mode 100644
index 0000000..8305cd3
--- /dev/null
+++ b/talk/p2p/base/portallocatorsessionproxy.cc
@@ -0,0 +1,154 @@
+/*
+ * libjingle
+ * Copyright 2004--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/p2p/base/portallocatorsessionproxy.h"
+
+#include "talk/p2p/base/portallocator.h"
+#include "talk/p2p/base/portproxy.h"
+
+namespace cricket {
+
+PortAllocatorSessionMuxer::PortAllocatorSessionMuxer(
+ PortAllocatorSession* session)
+ : session_(session) {
+ session_->SignalPortReady.connect(
+ this, &PortAllocatorSessionMuxer::OnPortReady);
+}
+
+PortAllocatorSessionMuxer::~PortAllocatorSessionMuxer() {
+ for (size_t i = 0; i < session_proxies_.size(); ++i)
+ delete session_proxies_[i];
+
+ SignalDestroyed(this);
+}
+
+void PortAllocatorSessionMuxer::RegisterSessionProxy(
+ PortAllocatorSessionProxy* session_proxy) {
+ session_proxies_.push_back(session_proxy);
+ session_proxy->SignalDestroyed.connect(
+ this, &PortAllocatorSessionMuxer::OnSessionProxyDestroyed);
+ session_proxy->set_impl(session_.get());
+}
+
+void PortAllocatorSessionMuxer::OnPortReady(PortAllocatorSession* session,
+ Port* port) {
+ ASSERT(session == session_.get());
+ ports_.push_back(port);
+ port->SignalDestroyed.connect(
+ this, &PortAllocatorSessionMuxer::OnPortDestroyed);
+}
+
+void PortAllocatorSessionMuxer::OnPortDestroyed(Port* port) {
+ std::vector<Port*>::iterator it =
+ std::find(ports_.begin(), ports_.end(), port);
+ if (it != ports_.end())
+ ports_.erase(it);
+}
+
+void PortAllocatorSessionMuxer::OnSessionProxyDestroyed(
+ PortAllocatorSession* proxy) {
+ std::vector<PortAllocatorSessionProxy*>::iterator it =
+ std::find(session_proxies_.begin(), session_proxies_.end(), proxy);
+ if (it != session_proxies_.end())
+ session_proxies_.erase(it);
+
+ if (session_proxies_.empty()) {
+ // Destroy PortAllocatorSession and its associated muxer object if all
+ // proxies belonging to this session are already destroyed.
+ delete this;
+ }
+}
+
+PortAllocatorSessionProxy::~PortAllocatorSessionProxy() {
+ std::map<Port*, PortProxy*>::iterator it;
+ for (it = proxy_ports_.begin(); it != proxy_ports_.end(); it++)
+ delete it->second;
+
+ SignalDestroyed(this);
+}
+
+void PortAllocatorSessionProxy::set_impl(
+ PortAllocatorSession* session) {
+ impl_ = session;
+
+ impl_->SignalCandidatesReady.connect(
+ this, &PortAllocatorSessionProxy::OnCandidatesReady);
+ impl_->SignalPortReady.connect(
+ this, &PortAllocatorSessionProxy::OnPortReady);
+}
+
+void PortAllocatorSessionProxy::GetInitialPorts() {
+ ASSERT(impl_ != NULL);
+ impl_->GetInitialPorts();
+}
+
+void PortAllocatorSessionProxy::StartGetAllPorts() {
+ ASSERT(impl_ != NULL);
+ impl_->StartGetAllPorts();
+}
+
+void PortAllocatorSessionProxy::StopGetAllPorts() {
+ ASSERT(impl_ != NULL);
+ impl_->StartGetAllPorts();
+}
+
+bool PortAllocatorSessionProxy::IsGettingAllPorts() {
+ ASSERT(impl_ != NULL);
+ return impl_->IsGettingAllPorts();
+}
+
+void PortAllocatorSessionProxy::OnPortReady(PortAllocatorSession* session,
+ Port* port) {
+ ASSERT(session == impl_);
+
+ PortProxy* proxy_port = new PortProxy(
+ port->thread(), port->type(), port->socket_factory(), port->network(),
+ port->ip(), port->min_port(), port->max_port());
+ proxy_port->set_impl(port);
+ proxy_ports_[port] = proxy_port;
+ SignalPortReady(this, proxy_port);
+}
+
+void PortAllocatorSessionProxy::OnCandidatesReady(
+ PortAllocatorSession* session,
+ const std::vector<Candidate>& candidates) {
+ ASSERT(session == impl_);
+
+ // Since all proxy sessions share a common PortAllocatorSession,
+ // all Candidates will have name associated with the common PAS.
+ // Change Candidate name with the PortAllocatorSessionProxy name.
+ std::vector<Candidate> our_candidates;
+ for (size_t i = 0; i < candidates.size(); ++i) {
+ Candidate new_local_candidate = candidates[i];
+ new_local_candidate.set_name(name_);
+ our_candidates.push_back(new_local_candidate);
+ }
+
+ SignalCandidatesReady(this, our_candidates);
+}
+
+} // namespace cricket
diff --git a/talk/p2p/base/portallocatorsessionproxy.h b/talk/p2p/base/portallocatorsessionproxy.h
new file mode 100644
index 0000000..5f9eaec
--- /dev/null
+++ b/talk/p2p/base/portallocatorsessionproxy.h
@@ -0,0 +1,101 @@
+/*
+ * libjingle
+ * Copyright 2004--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_P2P_BASE_PORTALLOCATORSESSIONPROXY_H_
+#define TALK_P2P_BASE_PORTALLOCATORSESSIONPROXY_H_
+
+#include <string>
+
+#include "talk/p2p/base/candidate.h"
+#include "talk/p2p/base/portallocator.h"
+
+namespace cricket {
+class PortAllocator;
+class PortAllocatorSessionProxy;
+class PortProxy;
+
+// This class maintains the list of cricket::Port* objects. Ports will be
+// deleted upon receiving SignalDestroyed signal. This class is used when
+// PORTALLOCATOR_ENABLE_BUNDLE flag is set.
+
+class PortAllocatorSessionMuxer : public sigslot::has_slots<> {
+ public:
+ explicit PortAllocatorSessionMuxer(PortAllocatorSession* session);
+ virtual ~PortAllocatorSessionMuxer();
+
+ void RegisterSessionProxy(PortAllocatorSessionProxy* session_proxy);
+
+ void OnPortReady(PortAllocatorSession* session, Port* port);
+ void OnPortDestroyed(Port* port);
+
+ const std::vector<Port*>& ports() { return ports_; }
+
+ sigslot::signal1<PortAllocatorSessionMuxer*> SignalDestroyed;
+
+ private:
+ void OnSessionProxyDestroyed(PortAllocatorSession* proxy);
+
+ // Port will be deleted when SignalDestroyed received, otherwise delete
+ // happens when PortAllocatorSession dtor is called.
+ std::vector<Port*> ports_;
+ talk_base::scoped_ptr<PortAllocatorSession> session_;
+ std::vector<PortAllocatorSessionProxy*> session_proxies_;
+};
+
+class PortAllocatorSessionProxy : public PortAllocatorSession {
+ public:
+ PortAllocatorSessionProxy(const std::string& name,
+ const std::string& session_type,
+ uint32 flags)
+ : PortAllocatorSession(name, session_type, flags),
+ impl_(NULL) {}
+
+ virtual ~PortAllocatorSessionProxy();
+
+ PortAllocatorSession* impl() { return impl_; }
+ void set_impl(PortAllocatorSession* session);
+
+ // Forwards call to the actual PortAllocatorSession.
+ virtual void GetInitialPorts();
+ virtual void StartGetAllPorts();
+ virtual void StopGetAllPorts();
+ virtual bool IsGettingAllPorts();
+
+ private:
+ void OnPortReady(PortAllocatorSession* session, Port* port);
+ void OnCandidatesReady(PortAllocatorSession* session,
+ const std::vector<Candidate>& candidates);
+ void OnPortDestroyed(Port* port);
+
+ // This is the actual PortAllocatorSession, owned by PortAllocator.
+ PortAllocatorSession* impl_;
+ std::map<Port*, PortProxy*> proxy_ports_;
+};
+
+} // namespace cricket
+
+#endif // TALK_P2P_BASE_PORTALLOCATORSESSIONPROXY_H_
diff --git a/talk/p2p/base/portproxy.cc b/talk/p2p/base/portproxy.cc
new file mode 100644
index 0000000..6c20127
--- /dev/null
+++ b/talk/p2p/base/portproxy.cc
@@ -0,0 +1,85 @@
+/*
+ * libjingle
+ * Copyright 2004--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/p2p/base/portproxy.h"
+
+namespace cricket {
+
+void PortProxy::set_impl(Port* port) {
+ impl_ = port;
+ impl_->SignalUnknownAddress.connect(
+ this, &PortProxy::OnUnknownAddress);
+ impl_->SignalDestroyed.connect(this, &PortProxy::OnPortDestroyed);
+}
+
+void PortProxy::PrepareAddress() {
+ impl_->PrepareAddress();
+}
+
+Connection* PortProxy::CreateConnection(const Candidate& remote_candidate,
+ CandidateOrigin origin) {
+ ASSERT(impl_ != NULL);
+ return impl_->CreateConnection(remote_candidate, origin);
+}
+
+int PortProxy::SendTo(const void* data,
+ size_t size,
+ const talk_base::SocketAddress& addr,
+ bool payload) {
+ ASSERT(impl_ != NULL);
+ return impl_->SendTo(data, size, addr, payload);
+}
+
+int PortProxy::SetOption(talk_base::Socket::Option opt,
+ int value) {
+ ASSERT(impl_ != NULL);
+ return impl_->SetOption(opt, value);
+}
+
+int PortProxy::GetError() {
+ ASSERT(impl_ != NULL);
+ return impl_->GetError();
+}
+
+void PortProxy::OnUnknownAddress(
+ Port *port,
+ const talk_base::SocketAddress &addr,
+ StunMessage *stun_msg,
+ const std::string &remote_username,
+ bool port_muxed) {
+ ASSERT(port == impl_);
+ ASSERT(!port_muxed);
+ SignalUnknownAddress(this, addr, stun_msg, remote_username, true);
+}
+
+void PortProxy::OnPortDestroyed(Port* port) {
+ ASSERT(port == impl_);
+ // |port| will be destroyed in PortAllocatorSessionMuxer.
+ SignalDestroyed(this);
+}
+
+} // namespace cricket
diff --git a/talk/p2p/base/portproxy.h b/talk/p2p/base/portproxy.h
new file mode 100644
index 0000000..49707d4
--- /dev/null
+++ b/talk/p2p/base/portproxy.h
@@ -0,0 +1,85 @@
+/*
+ * libjingle
+ * Copyright 2004--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_P2P_BASE_PORTPROXY_H_
+#define TALK_P2P_BASE_PORTPROXY_H_
+
+#include "talk/p2p/base/port.h"
+
+namespace cricket {
+
+class PortProxy : public Port {
+ public:
+ PortProxy(talk_base::Thread* thread, const std::string& type,
+ talk_base::PacketSocketFactory* factory,
+ talk_base::Network* network,
+ const talk_base::IPAddress& ip, int min_port, int max_port)
+ : Port(thread, type, factory, network, ip, min_port, max_port) {
+ }
+ virtual ~PortProxy() {}
+
+ Port* impl() { return impl_; }
+ void set_impl(Port* port);
+
+ // Forwards call to the actual Port.
+ virtual void PrepareAddress();
+ virtual Connection* CreateConnection(const Candidate& remote_candidate,
+ CandidateOrigin origin);
+ virtual int SendTo(
+ const void* data, size_t size, const talk_base::SocketAddress& addr,
+ bool payload);
+ virtual int SetOption(talk_base::Socket::Option opt, int value);
+ virtual int GetError();
+
+ virtual void SendBindingResponse(StunMessage* request,
+ const talk_base::SocketAddress& addr) {
+ impl_->SendBindingResponse(request, addr);
+ }
+
+ virtual Connection* GetConnection(
+ const talk_base::SocketAddress& remote_addr) {
+ return impl_->GetConnection(remote_addr);
+ }
+
+ virtual void SendBindingErrorResponse(
+ StunMessage* request, const talk_base::SocketAddress& addr,
+ int error_code, const std::string& reason) {
+ impl_->SendBindingErrorResponse(request, addr, error_code, reason);
+ }
+
+ private:
+ void OnUnknownAddress(Port *port, const talk_base::SocketAddress &addr,
+ StunMessage *stun_msg,
+ const std::string &remote_username,
+ bool port_muxed);
+ void OnPortDestroyed(Port* port);
+ Port* impl_;
+};
+
+} // namespace cricket
+
+#endif // TALK_P2P_BASE_PORTPROXY_H_
diff --git a/talk/p2p/base/pseudotcp.cc b/talk/p2p/base/pseudotcp.cc
index fc903e0..99a1f43 100644
--- a/talk/p2p/base/pseudotcp.cc
+++ b/talk/p2p/base/pseudotcp.cc
@@ -38,7 +38,7 @@
#include "talk/base/logging.h"
#include "talk/base/socket.h"
#include "talk/base/stringutils.h"
-#include "talk/base/time.h"
+#include "talk/base/timeutils.h"
// The following logging is for detailed (packet-level) analysis only.
#define _DBG_NONE 0
diff --git a/talk/p2p/base/pseudotcp_unittest.cc b/talk/p2p/base/pseudotcp_unittest.cc
new file mode 100644
index 0000000..7bf5874
--- /dev/null
+++ b/talk/p2p/base/pseudotcp_unittest.cc
@@ -0,0 +1,845 @@
+/*
+ * 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 <vector>
+
+#include "talk/base/gunit.h"
+#include "talk/base/helpers.h"
+#include "talk/base/messagehandler.h"
+#include "talk/base/stream.h"
+#include "talk/base/thread.h"
+#include "talk/base/timeutils.h"
+#include "talk/p2p/base/pseudotcp.h"
+
+using cricket::PseudoTcp;
+
+static const int kConnectTimeoutMs = 10000; // ~3 * default RTO of 3000ms
+static const int kTransferTimeoutMs = 15000;
+static const int kBlockSize = 4096;
+
+class PseudoTcpForTest : public cricket::PseudoTcp {
+ public:
+ PseudoTcpForTest(cricket::IPseudoTcpNotify* notify, uint32 conv)
+ : PseudoTcp(notify, conv) {
+ }
+
+ bool isReceiveBufferFull() const {
+ return PseudoTcp::isReceiveBufferFull();
+ }
+
+ void disableWindowScale() {
+ PseudoTcp::disableWindowScale();
+ }
+};
+
+class PseudoTcpTestBase : public testing::Test,
+ public talk_base::MessageHandler,
+ public cricket::IPseudoTcpNotify {
+ public:
+ PseudoTcpTestBase()
+ : local_(this, 1),
+ remote_(this, 1),
+ have_connected_(false),
+ have_disconnected_(false),
+ local_mtu_(65535),
+ remote_mtu_(65535),
+ delay_(0),
+ loss_(0) {
+ // Set use of the test RNG to get predictable loss patterns.
+ talk_base::SetRandomTestMode(true);
+ }
+ ~PseudoTcpTestBase() {
+ // Put it back for the next test.
+ talk_base::SetRandomTestMode(false);
+ }
+ void SetLocalMtu(int mtu) {
+ local_.NotifyMTU(mtu);
+ local_mtu_ = mtu;
+ }
+ void SetRemoteMtu(int mtu) {
+ remote_.NotifyMTU(mtu);
+ remote_mtu_ = mtu;
+ }
+ void SetDelay(int delay) {
+ delay_ = delay;
+ }
+ void SetLoss(int percent) {
+ loss_ = percent;
+ }
+ void SetOptNagling(bool enable_nagles) {
+ local_.SetOption(PseudoTcp::OPT_NODELAY, !enable_nagles);
+ remote_.SetOption(PseudoTcp::OPT_NODELAY, !enable_nagles);
+ }
+ void SetOptAckDelay(int ack_delay) {
+ local_.SetOption(PseudoTcp::OPT_ACKDELAY, ack_delay);
+ remote_.SetOption(PseudoTcp::OPT_ACKDELAY, ack_delay);
+ }
+ void SetOptSndBuf(int size) {
+ local_.SetOption(PseudoTcp::OPT_SNDBUF, size);
+ remote_.SetOption(PseudoTcp::OPT_SNDBUF, size);
+ }
+ void SetRemoteOptRcvBuf(int size) {
+ remote_.SetOption(PseudoTcp::OPT_RCVBUF, size);
+ }
+ void SetLocalOptRcvBuf(int size) {
+ local_.SetOption(PseudoTcp::OPT_RCVBUF, size);
+ }
+ void DisableRemoteWindowScale() {
+ remote_.disableWindowScale();
+ }
+ void DisableLocalWindowScale() {
+ local_.disableWindowScale();
+ }
+
+ protected:
+ int Connect() {
+ int ret = local_.Connect();
+ if (ret == 0) {
+ UpdateLocalClock();
+ }
+ return ret;
+ }
+ void Close() {
+ local_.Close(false);
+ UpdateLocalClock();
+ }
+
+ enum { MSG_LPACKET, MSG_RPACKET, MSG_LCLOCK, MSG_RCLOCK, MSG_IOCOMPLETE,
+ MSG_WRITE};
+ virtual void OnTcpOpen(PseudoTcp* tcp) {
+ // Consider ourselves connected when the local side gets OnTcpOpen.
+ // OnTcpWriteable isn't fired at open, so we trigger it now.
+ LOG(LS_VERBOSE) << "Opened";
+ if (tcp == &local_) {
+ have_connected_ = true;
+ OnTcpWriteable(tcp);
+ }
+ }
+ // Test derived from the base should override
+ // virtual void OnTcpReadable(PseudoTcp* tcp)
+ // and
+ // virtual void OnTcpWritable(PseudoTcp* tcp)
+ virtual void OnTcpClosed(PseudoTcp* tcp, uint32 error) {
+ // Consider ourselves closed when the remote side gets OnTcpClosed.
+ // TODO: OnTcpClosed is only ever notified in case of error in
+ // the current implementation. Solicited close is not (yet) supported.
+ LOG(LS_VERBOSE) << "Closed";
+ EXPECT_EQ(0U, error);
+ if (tcp == &remote_) {
+ have_disconnected_ = true;
+ }
+ }
+ virtual WriteResult TcpWritePacket(PseudoTcp* tcp,
+ const char* buffer, size_t len) {
+ // Randomly drop the desired percentage of packets.
+ // Also drop packets that are larger than the configured MTU.
+ if (talk_base::CreateRandomId() % 100 < static_cast<uint32>(loss_)) {
+ LOG(LS_VERBOSE) << "Randomly dropping packet, size=" << len;
+ } else if (len > static_cast<size_t>(
+ talk_base::_min(local_mtu_, remote_mtu_))) {
+ LOG(LS_VERBOSE) << "Dropping packet that exceeds path MTU, size=" << len;
+ } else {
+ int id = (tcp == &local_) ? MSG_RPACKET : MSG_LPACKET;
+ std::string packet(buffer, len);
+ talk_base::Thread::Current()->PostDelayed(delay_, this, id,
+ talk_base::WrapMessageData(packet));
+ }
+ return WR_SUCCESS;
+ }
+
+ void UpdateLocalClock() { UpdateClock(&local_, MSG_LCLOCK); }
+ void UpdateRemoteClock() { UpdateClock(&remote_, MSG_RCLOCK); }
+ void UpdateClock(PseudoTcp* tcp, uint32 message) {
+ long interval; // NOLINT
+ tcp->GetNextClock(PseudoTcp::Now(), interval);
+ interval = talk_base::_max<int>(interval, 0L); // sometimes interval is < 0
+ talk_base::Thread::Current()->Clear(this, message);
+ talk_base::Thread::Current()->PostDelayed(interval, this, message);
+ }
+
+ virtual void OnMessage(talk_base::Message* message) {
+ switch (message->message_id) {
+ case MSG_LPACKET: {
+ const std::string& s(
+ talk_base::UseMessageData<std::string>(message->pdata));
+ local_.NotifyPacket(s.c_str(), s.size());
+ UpdateLocalClock();
+ break;
+ }
+ case MSG_RPACKET: {
+ const std::string& s(
+ talk_base::UseMessageData<std::string>(message->pdata));
+ remote_.NotifyPacket(s.c_str(), s.size());
+ UpdateRemoteClock();
+ break;
+ }
+ case MSG_LCLOCK:
+ local_.NotifyClock(PseudoTcp::Now());
+ UpdateLocalClock();
+ break;
+ case MSG_RCLOCK:
+ remote_.NotifyClock(PseudoTcp::Now());
+ UpdateRemoteClock();
+ break;
+ default:
+ break;
+ }
+ delete message->pdata;
+ }
+
+ PseudoTcpForTest local_;
+ PseudoTcpForTest remote_;
+ talk_base::MemoryStream send_stream_;
+ talk_base::MemoryStream recv_stream_;
+ bool have_connected_;
+ bool have_disconnected_;
+ int local_mtu_;
+ int remote_mtu_;
+ int delay_;
+ int loss_;
+};
+
+class PseudoTcpTest : public PseudoTcpTestBase {
+ public:
+ void TestTransfer(int size) {
+ uint32 start, elapsed;
+ size_t received;
+ // Create some dummy data to send.
+ send_stream_.ReserveSize(size);
+ for (int i = 0; i < size; ++i) {
+ char ch = static_cast<char>(i);
+ send_stream_.Write(&ch, 1, NULL, NULL);
+ }
+ send_stream_.Rewind();
+ // Prepare the receive stream.
+ recv_stream_.ReserveSize(size);
+ // Connect and wait until connected.
+ start = talk_base::Time();
+ EXPECT_EQ(0, Connect());
+ EXPECT_TRUE_WAIT(have_connected_, kConnectTimeoutMs);
+ // Sending will start from OnTcpWriteable and complete when all data has
+ // been received.
+ EXPECT_TRUE_WAIT(have_disconnected_, kTransferTimeoutMs);
+ elapsed = talk_base::TimeSince(start);
+ recv_stream_.GetSize(&received);
+ // Ensure we closed down OK and we got the right data.
+ // TODO: Ensure the errors are cleared properly.
+ //EXPECT_EQ(0, local_.GetError());
+ //EXPECT_EQ(0, remote_.GetError());
+ EXPECT_EQ(static_cast<size_t>(size), received);
+ EXPECT_EQ(0, memcmp(send_stream_.GetBuffer(),
+ recv_stream_.GetBuffer(), size));
+ LOG(LS_INFO) << "Transferred " << received << " bytes in " << elapsed
+ << " ms (" << size * 8 / elapsed << " Kbps)";
+ }
+
+ private:
+ // IPseudoTcpNotify interface
+
+ virtual void OnTcpReadable(PseudoTcp* tcp) {
+ // Stream bytes to the recv stream as they arrive.
+ if (tcp == &remote_) {
+ ReadData();
+
+ // TODO: OnTcpClosed() is currently only notified on error -
+ // there is no on-the-wire equivalent of TCP FIN.
+ // So we fake the notification when all the data has been read.
+ size_t received, required;
+ recv_stream_.GetPosition(&received);
+ send_stream_.GetSize(&required);
+ if (received == required)
+ OnTcpClosed(&remote_, 0);
+ }
+ }
+ virtual void OnTcpWriteable(PseudoTcp* tcp) {
+ // Write bytes from the send stream when we can.
+ // Shut down when we've sent everything.
+ if (tcp == &local_) {
+ LOG(LS_VERBOSE) << "Flow Control Lifted";
+ bool done;
+ WriteData(&done);
+ if (done) {
+ Close();
+ }
+ }
+ }
+
+ void ReadData() {
+ char block[kBlockSize];
+ size_t position;
+ int rcvd;
+ do {
+ rcvd = remote_.Recv(block, sizeof(block));
+ if (rcvd != -1) {
+ recv_stream_.Write(block, rcvd, NULL, NULL);
+ recv_stream_.GetPosition(&position);
+ LOG(LS_VERBOSE) << "Received: " << position;
+ }
+ } while (rcvd > 0);
+ }
+ void WriteData(bool* done) {
+ size_t position, tosend;
+ int sent;
+ char block[kBlockSize];
+ do {
+ send_stream_.GetPosition(&position);
+ if (send_stream_.Read(block, sizeof(block), &tosend, NULL) !=
+ talk_base::SR_EOS) {
+ sent = local_.Send(block, tosend);
+ UpdateLocalClock();
+ if (sent != -1) {
+ send_stream_.SetPosition(position + sent);
+ LOG(LS_VERBOSE) << "Sent: " << position + sent;
+ } else {
+ send_stream_.SetPosition(position);
+ LOG(LS_VERBOSE) << "Flow Controlled";
+ }
+ } else {
+ sent = tosend = 0;
+ }
+ } while (sent > 0);
+ *done = (tosend == 0);
+ }
+
+ private:
+ talk_base::MemoryStream send_stream_;
+ talk_base::MemoryStream recv_stream_;
+};
+
+
+class PseudoTcpTestPingPong : public PseudoTcpTestBase {
+ public:
+ PseudoTcpTestPingPong()
+ : iterations_remaining_(0),
+ sender_(NULL),
+ receiver_(NULL),
+ bytes_per_send_(0) {
+ }
+ void SetBytesPerSend(int bytes) {
+ bytes_per_send_ = bytes;
+ }
+ void TestPingPong(int size, int iterations) {
+ uint32 start, elapsed;
+ iterations_remaining_ = iterations;
+ receiver_ = &remote_;
+ sender_ = &local_;
+ // Create some dummy data to send.
+ send_stream_.ReserveSize(size);
+ for (int i = 0; i < size; ++i) {
+ char ch = static_cast<char>(i);
+ send_stream_.Write(&ch, 1, NULL, NULL);
+ }
+ send_stream_.Rewind();
+ // Prepare the receive stream.
+ recv_stream_.ReserveSize(size);
+ // Connect and wait until connected.
+ start = talk_base::Time();
+ EXPECT_EQ(0, Connect());
+ EXPECT_TRUE_WAIT(have_connected_, kConnectTimeoutMs);
+ // Sending will start from OnTcpWriteable and stop when the required
+ // number of iterations have completed.
+ EXPECT_TRUE_WAIT(have_disconnected_, kTransferTimeoutMs);
+ elapsed = talk_base::TimeSince(start);
+ LOG(LS_INFO) << "Performed " << iterations << " pings in "
+ << elapsed << " ms";
+ }
+
+ private:
+ // IPseudoTcpNotify interface
+
+ virtual void OnTcpReadable(PseudoTcp* tcp) {
+ if (tcp != receiver_) {
+ LOG_F(LS_ERROR) << "unexpected OnTcpReadable";
+ return;
+ }
+ // Stream bytes to the recv stream as they arrive.
+ ReadData();
+ // If we've received the desired amount of data, rewind things
+ // and send it back the other way!
+ size_t position, desired;
+ recv_stream_.GetPosition(&position);
+ send_stream_.GetSize(&desired);
+ if (position == desired) {
+ if (receiver_ == &local_ && --iterations_remaining_ == 0) {
+ Close();
+ // TODO: Fake OnTcpClosed() on the receiver for now.
+ OnTcpClosed(&remote_, 0);
+ return;
+ }
+ PseudoTcp* tmp = receiver_;
+ receiver_ = sender_;
+ sender_ = tmp;
+ recv_stream_.Rewind();
+ send_stream_.Rewind();
+ OnTcpWriteable(sender_);
+ }
+ }
+ virtual void OnTcpWriteable(PseudoTcp* tcp) {
+ if (tcp != sender_)
+ return;
+ // Write bytes from the send stream when we can.
+ // Shut down when we've sent everything.
+ LOG(LS_VERBOSE) << "Flow Control Lifted";
+ WriteData();
+ }
+
+ void ReadData() {
+ char block[kBlockSize];
+ size_t position;
+ int rcvd;
+ do {
+ rcvd = receiver_->Recv(block, sizeof(block));
+ if (rcvd != -1) {
+ recv_stream_.Write(block, rcvd, NULL, NULL);
+ recv_stream_.GetPosition(&position);
+ LOG(LS_VERBOSE) << "Received: " << position;
+ }
+ } while (rcvd > 0);
+ }
+ void WriteData() {
+ size_t position, tosend;
+ int sent;
+ char block[kBlockSize];
+ do {
+ send_stream_.GetPosition(&position);
+ tosend = bytes_per_send_ ? bytes_per_send_ : sizeof(block);
+ if (send_stream_.Read(block, tosend, &tosend, NULL) !=
+ talk_base::SR_EOS) {
+ sent = sender_->Send(block, tosend);
+ UpdateLocalClock();
+ if (sent != -1) {
+ send_stream_.SetPosition(position + sent);
+ LOG(LS_VERBOSE) << "Sent: " << position + sent;
+ } else {
+ send_stream_.SetPosition(position);
+ LOG(LS_VERBOSE) << "Flow Controlled";
+ }
+ } else {
+ sent = tosend = 0;
+ }
+ } while (sent > 0);
+ }
+
+ private:
+ int iterations_remaining_;
+ PseudoTcp* sender_;
+ PseudoTcp* receiver_;
+ int bytes_per_send_;
+};
+
+// Fill the receiver window until it is full, drain it and then
+// fill it with the same amount. This is to test that receiver window
+// contracts and enlarges correctly.
+class PseudoTcpTestReceiveWindow : public PseudoTcpTestBase {
+ public:
+ // Not all the data are transfered, |size| just need to be big enough
+ // to fill up the receiver window twice.
+ void TestTransfer(int size) {
+ // Create some dummy data to send.
+ send_stream_.ReserveSize(size);
+ for (int i = 0; i < size; ++i) {
+ char ch = static_cast<char>(i);
+ send_stream_.Write(&ch, 1, NULL, NULL);
+ }
+ send_stream_.Rewind();
+
+ // Prepare the receive stream.
+ recv_stream_.ReserveSize(size);
+
+ // Connect and wait until connected.
+ EXPECT_EQ(0, Connect());
+ EXPECT_TRUE_WAIT(have_connected_, kConnectTimeoutMs);
+
+ talk_base::Thread::Current()->Post(this, MSG_WRITE);
+ EXPECT_TRUE_WAIT(have_disconnected_, kTransferTimeoutMs);
+
+ ASSERT_EQ(2u, send_position_.size());
+ ASSERT_EQ(2u, recv_position_.size());
+
+ const size_t estimated_recv_window = recv_position_[0];
+
+ // The difference in consecutive send positions should equal the
+ // receive window size or match very closely. This verifies that receive
+ // window is open after receiver drained all the data.
+ const size_t send_position_diff = send_position_[1] - send_position_[0];
+ EXPECT_GE(1024u, estimated_recv_window - send_position_diff);
+
+ // Receiver drained the receive window twice.
+ EXPECT_EQ(2 * estimated_recv_window, recv_position_[1]);
+ }
+
+ virtual void OnMessage(talk_base::Message* message) {
+ int message_id = message->message_id;
+ PseudoTcpTestBase::OnMessage(message);
+
+ switch (message_id) {
+ case MSG_WRITE: {
+ WriteData();
+ break;
+ }
+ default:
+ break;
+ }
+ }
+
+ uint32 EstimateReceiveWindowSize() const {
+ return recv_position_[0];
+ }
+
+ uint32 EstimateSendWindowSize() const {
+ return send_position_[0] - recv_position_[0];
+ }
+
+ private:
+ // IPseudoTcpNotify interface
+ virtual void OnTcpReadable(PseudoTcp* tcp) {
+ }
+
+ virtual void OnTcpWriteable(PseudoTcp* tcp) {
+ }
+
+ void ReadUntilIOPending() {
+ char block[kBlockSize];
+ size_t position;
+ int rcvd;
+
+ do {
+ rcvd = remote_.Recv(block, sizeof(block));
+ if (rcvd != -1) {
+ recv_stream_.Write(block, rcvd, NULL, NULL);
+ recv_stream_.GetPosition(&position);
+ LOG(LS_VERBOSE) << "Received: " << position;
+ }
+ } while (rcvd > 0);
+
+ recv_stream_.GetPosition(&position);
+ recv_position_.push_back(position);
+
+ // Disconnect if we have done two transfers.
+ if (recv_position_.size() == 2u) {
+ Close();
+ OnTcpClosed(&remote_, 0);
+ } else {
+ WriteData();
+ }
+ }
+
+ void WriteData() {
+ size_t position, tosend;
+ int sent;
+ char block[kBlockSize];
+ do {
+ send_stream_.GetPosition(&position);
+ if (send_stream_.Read(block, sizeof(block), &tosend, NULL) !=
+ talk_base::SR_EOS) {
+ sent = local_.Send(block, tosend);
+ UpdateLocalClock();
+ if (sent != -1) {
+ send_stream_.SetPosition(position + sent);
+ LOG(LS_VERBOSE) << "Sent: " << position + sent;
+ } else {
+ send_stream_.SetPosition(position);
+ LOG(LS_VERBOSE) << "Flow Controlled";
+ }
+ } else {
+ sent = tosend = 0;
+ }
+ } while (sent > 0);
+
+ if (remote_.isReceiveBufferFull()) {
+ send_stream_.GetPosition(&position);
+ send_position_.push_back(position);
+
+ // Drain the receiver buffer.
+ ReadUntilIOPending();
+ } else {
+ // If the receiver side is not full then keep writing.
+ talk_base::Thread::Current()->PostDelayed(10, this, MSG_WRITE);
+ }
+ }
+
+ private:
+ talk_base::MemoryStream send_stream_;
+ talk_base::MemoryStream recv_stream_;
+
+ std::vector<size_t> send_position_;
+ std::vector<size_t> recv_position_;
+};
+
+// Basic end-to-end data transfer tests
+
+// Test the normal case of sending data from one side to the other.
+TEST_F(PseudoTcpTest, TestSend) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ TestTransfer(1000000);
+}
+
+// Test sending data with a 50 ms RTT. Transmission should take longer due
+// to a slower ramp-up in send rate.
+TEST_F(PseudoTcpTest, TestSendWithDelay) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetDelay(50);
+ TestTransfer(1000000);
+}
+
+// Test sending data with packet loss. Transmission should take much longer due
+// to send back-off when loss occurs.
+TEST_F(PseudoTcpTest, TestSendWithLoss) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetLoss(10);
+ TestTransfer(100000); // less data so test runs faster
+}
+
+// Test sending data with a 50 ms RTT and 10% packet loss. Transmission should
+// take much longer due to send back-off and slower detection of loss.
+TEST_F(PseudoTcpTest, TestSendWithDelayAndLoss) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetDelay(50);
+ SetLoss(10);
+ TestTransfer(100000); // less data so test runs faster
+}
+
+// Test sending data with 10% packet loss and Nagling disabled. Transmission
+// should take about the same time as with Nagling enabled.
+TEST_F(PseudoTcpTest, TestSendWithLossAndOptNaglingOff) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetLoss(10);
+ SetOptNagling(false);
+ TestTransfer(100000); // less data so test runs faster
+}
+
+// Test sending data with 10% packet loss and Delayed ACK disabled.
+// Transmission should be slightly faster than with it enabled.
+TEST_F(PseudoTcpTest, TestSendWithLossAndOptAckDelayOff) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetLoss(10);
+ SetOptAckDelay(0);
+ TestTransfer(100000);
+}
+
+// Test sending data with 50ms delay and Nagling disabled.
+TEST_F(PseudoTcpTest, TestSendWithDelayAndOptNaglingOff) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetDelay(50);
+ SetOptNagling(false);
+ TestTransfer(100000); // less data so test runs faster
+}
+
+// Test sending data with 50ms delay and Delayed ACK disabled.
+TEST_F(PseudoTcpTest, TestSendWithDelayAndOptAckDelayOff) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetDelay(50);
+ SetOptAckDelay(0);
+ TestTransfer(100000); // less data so test runs faster
+}
+
+// Test a large receive buffer with a sender that doesn't support scaling.
+TEST_F(PseudoTcpTest, TestSendRemoteNoWindowScale) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetLocalOptRcvBuf(100000);
+ DisableRemoteWindowScale();
+ TestTransfer(1000000);
+}
+
+// Test a large sender-side receive buffer with a receiver that doesn't support
+// scaling.
+TEST_F(PseudoTcpTest, TestSendLocalNoWindowScale) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetRemoteOptRcvBuf(100000);
+ DisableLocalWindowScale();
+ TestTransfer(1000000);
+}
+
+// Test when both sides use window scaling.
+TEST_F(PseudoTcpTest, TestSendBothUseWindowScale) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetRemoteOptRcvBuf(100000);
+ SetLocalOptRcvBuf(100000);
+ TestTransfer(1000000);
+}
+
+// Test using a large window scale value.
+TEST_F(PseudoTcpTest, TestSendLargeInFlight) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetRemoteOptRcvBuf(100000);
+ SetLocalOptRcvBuf(100000);
+ SetOptSndBuf(150000);
+ TestTransfer(1000000);
+}
+
+TEST_F(PseudoTcpTest, TestSendBothUseLargeWindowScale) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetRemoteOptRcvBuf(1000000);
+ SetLocalOptRcvBuf(1000000);
+ TestTransfer(10000000);
+}
+
+// Test using a small receive buffer.
+TEST_F(PseudoTcpTest, TestSendSmallReceiveBuffer) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetRemoteOptRcvBuf(10000);
+ SetLocalOptRcvBuf(10000);
+ TestTransfer(1000000);
+}
+
+// Test using a very small receive buffer.
+TEST_F(PseudoTcpTest, TestSendVerySmallReceiveBuffer) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetRemoteOptRcvBuf(100);
+ SetLocalOptRcvBuf(100);
+ TestTransfer(100000);
+}
+
+// Ping-pong (request/response) tests
+
+// Test sending <= 1x MTU of data in each ping/pong. Should take <10ms.
+TEST_F(PseudoTcpTestPingPong, TestPingPong1xMtu) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ TestPingPong(100, 100);
+}
+
+// Test sending 2x-3x MTU of data in each ping/pong. Should take <10ms.
+TEST_F(PseudoTcpTestPingPong, TestPingPong3xMtu) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ TestPingPong(400, 100);
+}
+
+// Test sending 1x-2x MTU of data in each ping/pong.
+// Should take ~1s, due to interaction between Nagling and Delayed ACK.
+TEST_F(PseudoTcpTestPingPong, TestPingPong2xMtu) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ TestPingPong(2000, 5);
+}
+
+// Test sending 1x-2x MTU of data in each ping/pong with Delayed ACK off.
+// Should take <10ms.
+TEST_F(PseudoTcpTestPingPong, TestPingPong2xMtuWithAckDelayOff) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetOptAckDelay(0);
+ TestPingPong(2000, 100);
+}
+
+// Test sending 1x-2x MTU of data in each ping/pong with Nagling off.
+// Should take <10ms.
+TEST_F(PseudoTcpTestPingPong, TestPingPong2xMtuWithNaglingOff) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetOptNagling(false);
+ TestPingPong(2000, 5);
+}
+
+// Test sending a ping as pair of short (non-full) segments.
+// Should take ~1s, due to Delayed ACK interaction with Nagling.
+TEST_F(PseudoTcpTestPingPong, TestPingPongShortSegments) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetOptAckDelay(5000);
+ SetBytesPerSend(50); // i.e. two Send calls per payload
+ TestPingPong(100, 5);
+}
+
+// Test sending ping as a pair of short (non-full) segments, with Nagling off.
+// Should take <10ms.
+TEST_F(PseudoTcpTestPingPong, TestPingPongShortSegmentsWithNaglingOff) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetOptNagling(false);
+ SetBytesPerSend(50); // i.e. two Send calls per payload
+ TestPingPong(100, 5);
+}
+
+// Test sending <= 1x MTU of data ping/pong, in two segments, no Delayed ACK.
+// Should take ~1s.
+TEST_F(PseudoTcpTestPingPong, TestPingPongShortSegmentsWithAckDelayOff) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetBytesPerSend(50); // i.e. two Send calls per payload
+ SetOptAckDelay(0);
+ TestPingPong(100, 5);
+}
+
+// Test that receive window expands and contract correctly.
+TEST_F(PseudoTcpTestReceiveWindow, TestReceiveWindow) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetOptNagling(false);
+ SetOptAckDelay(0);
+ TestTransfer(1024 * 1000);
+}
+
+// Test setting send window size to a very small value.
+TEST_F(PseudoTcpTestReceiveWindow, TestSetVerySmallSendWindowSize) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetOptNagling(false);
+ SetOptAckDelay(0);
+ SetOptSndBuf(900);
+ TestTransfer(1024 * 1000);
+ EXPECT_EQ(900u, EstimateSendWindowSize());
+}
+
+// Test setting receive window size to a value other than default.
+TEST_F(PseudoTcpTestReceiveWindow, TestSetReceiveWindowSize) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1500);
+ SetOptNagling(false);
+ SetOptAckDelay(0);
+ SetRemoteOptRcvBuf(100000);
+ SetLocalOptRcvBuf(100000);
+ TestTransfer(1024 * 1000);
+ EXPECT_EQ(100000u, EstimateReceiveWindowSize());
+}
+
+/* Test sending data with mismatched MTUs. We should detect this and reduce
+// our packet size accordingly.
+// TODO: This doesn't actually work right now. The current code
+// doesn't detect if the MTU is set too high on either side.
+TEST_F(PseudoTcpTest, TestSendWithMismatchedMtus) {
+ SetLocalMtu(1500);
+ SetRemoteMtu(1280);
+ TestTransfer(1000000);
+}
+*/
diff --git a/talk/p2p/base/rawtransportchannel.cc b/talk/p2p/base/rawtransportchannel.cc
index 8736053..0c2691c 100644
--- a/talk/p2p/base/rawtransportchannel.cc
+++ b/talk/p2p/base/rawtransportchannel.cc
@@ -95,7 +95,8 @@
void RawTransportChannel::Connect() {
// Create an allocator that only returns stun and relay ports.
- allocator_session_ = allocator_->CreateSession(name(), content_type());
+ allocator_session_ = allocator_->CreateSession(
+ session_id(), name(), content_type());
uint32 flags = PORTALLOCATOR_DISABLE_UDP | PORTALLOCATOR_DISABLE_TCP;
diff --git a/talk/p2p/base/relayport.cc b/talk/p2p/base/relayport.cc
index 76bd5ff..c6c066a 100644
--- a/talk/p2p/base/relayport.cc
+++ b/talk/p2p/base/relayport.cc
@@ -187,9 +187,9 @@
RelayPort::RelayPort(
talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
- talk_base::Network* network, uint32 ip, int min_port, int max_port,
- const std::string& username, const std::string& password,
- const std::string& magic_cookie)
+ talk_base::Network* network, const talk_base::IPAddress& ip,
+ int min_port, int max_port, const std::string& username,
+ const std::string& password, const std::string& magic_cookie)
: Port(thread, RELAY_PORT_TYPE, factory, network, ip, min_port, max_port),
ready_(false),
magic_cookie_(magic_cookie),
@@ -554,7 +554,7 @@
StunAddressAttribute* addr_attr =
StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
- addr_attr->SetIP(addr.ip());
+ addr_attr->SetIP(addr.ipaddr());
addr_attr->SetPort(addr.port());
request.AddAttribute(addr_attr);
@@ -702,7 +702,7 @@
return;
}
- talk_base::SocketAddress remote_addr2(addr_attr->ip(), addr_attr->port());
+ talk_base::SocketAddress remote_addr2(addr_attr->ipaddr(), addr_attr->port());
const StunByteStringAttribute* data_attr = msg.GetByteString(STUN_ATTR_DATA);
if (!data_attr) {
@@ -764,7 +764,7 @@
} else if (addr_attr->family() != 1) {
LOG(INFO) << "Mapped address has bad family";
} else {
- talk_base::SocketAddress addr(addr_attr->ip(), addr_attr->port());
+ talk_base::SocketAddress addr(addr_attr->ipaddr(), addr_attr->port());
entry_->OnConnect(addr, connection_);
}
diff --git a/talk/p2p/base/relayport.h b/talk/p2p/base/relayport.h
index 62bb758..2137606 100644
--- a/talk/p2p/base/relayport.h
+++ b/talk/p2p/base/relayport.h
@@ -55,9 +55,9 @@
// RelayPort doesn't yet do anything fancy in the ctor.
static RelayPort* Create(
talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
- talk_base::Network* network, uint32 ip, int min_port, int max_port,
- const std::string& username, const std::string& password,
- const std::string& magic_cookie) {
+ talk_base::Network* network, const talk_base::IPAddress& ip,
+ int min_port, int max_port, const std::string& username,
+ const std::string& password, const std::string& magic_cookie) {
return new RelayPort(thread, factory, network, ip, min_port, max_port,
username, password, magic_cookie);
}
@@ -85,9 +85,9 @@
protected:
RelayPort(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
- talk_base::Network*, uint32 ip, int min_port, int max_port,
- const std::string& username, const std::string& password,
- const std::string& magic_cookie);
+ talk_base::Network*, const talk_base::IPAddress& ip,
+ int min_port, int max_port, const std::string& username,
+ const std::string& password, const std::string& magic_cookie);
bool Init();
void SetReady();
diff --git a/talk/p2p/base/relayport_unittest.cc b/talk/p2p/base/relayport_unittest.cc
new file mode 100644
index 0000000..688e635
--- /dev/null
+++ b/talk/p2p/base/relayport_unittest.cc
@@ -0,0 +1,292 @@
+/*
+ * libjingle
+ * Copyright 2009 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/base/basicpacketsocketfactory.h"
+#include "talk/base/logging.h"
+#include "talk/base/gunit.h"
+#include "talk/base/helpers.h"
+#include "talk/base/physicalsocketserver.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/socketadapters.h"
+#include "talk/base/socketaddress.h"
+#include "talk/base/thread.h"
+#include "talk/base/virtualsocketserver.h"
+#include "talk/p2p/base/relayport.h"
+#include "talk/p2p/base/relayserver.h"
+
+using talk_base::SocketAddress;
+
+static const SocketAddress kLocalAddress = SocketAddress("192.168.1.2", 0);
+static const SocketAddress kRelayUdpAddr = SocketAddress("99.99.99.1", 5000);
+static const SocketAddress kRelayTcpAddr = SocketAddress("99.99.99.2", 5001);
+static const SocketAddress kRelaySslAddr = SocketAddress("99.99.99.3", 443);
+static const SocketAddress kRelayExtAddr = SocketAddress("99.99.99.3", 5002);
+
+static const int kTimeoutMs = 1000;
+static const int kMaxTimeoutMs = 5000;
+
+// Tests connecting a RelayPort to a fake relay server
+// (cricket::RelayServer) using all currently available protocols. The
+// network layer is faked out by using a VirtualSocketServer for
+// creating sockets. The test will monitor the current state of the
+// RelayPort and created sockets by listening for signals such as,
+// SignalConnectFailure, SignalConnectTimeout, SignalSocketClosed and
+// SignalReadPacket.
+class RelayPortTest : public testing::Test,
+ public sigslot::has_slots<> {
+ public:
+ RelayPortTest()
+ : main_(talk_base::Thread::Current()),
+ physical_socket_server_(new talk_base::PhysicalSocketServer),
+ virtual_socket_server_(new talk_base::VirtualSocketServer(
+ physical_socket_server_.get())),
+ ss_scope_(virtual_socket_server_.get()),
+ network_("unittest", "unittest", talk_base::IPAddress(INADDR_ANY)),
+ socket_factory_(talk_base::Thread::Current()),
+ username_(talk_base::CreateRandomString(16)),
+ password_(talk_base::CreateRandomString(16)),
+ relay_port_(cricket::RelayPort::Create(main_, &socket_factory_,
+ &network_,
+ kLocalAddress.ipaddr(),
+ 0, 0, username_, password_, "")),
+ relay_server_(new cricket::RelayServer(main_)) {
+ }
+
+ void OnReadPacket(talk_base::AsyncPacketSocket* socket,
+ const char* data, size_t size,
+ const talk_base::SocketAddress& remote_addr) {
+ received_packet_count_[socket]++;
+ }
+
+ void OnConnectFailure(const cricket::ProtocolAddress* addr) {
+ failed_connections_.push_back(*addr);
+ }
+
+ void OnSoftTimeout(const cricket::ProtocolAddress* addr) {
+ soft_timedout_connections_.push_back(*addr);
+ }
+
+ protected:
+ static void SetUpTestCase() {
+ // Ensure the RNG is inited.
+ talk_base::InitRandom(NULL, 0);
+ }
+
+ virtual void SetUp() {
+ // The relay server needs an external socket to work properly.
+ talk_base::AsyncUDPSocket* ext_socket =
+ CreateAsyncUdpSocket(kRelayExtAddr);
+ relay_server_->AddExternalSocket(ext_socket);
+
+ // Listen for failures.
+ relay_port_->SignalConnectFailure.
+ connect(this, &RelayPortTest::OnConnectFailure);
+
+ // Listen for soft timeouts.
+ relay_port_->SignalSoftTimeout.
+ connect(this, &RelayPortTest::OnSoftTimeout);
+ }
+
+ // Udp has the highest 'goodness' value of the three different
+ // protocols used for connecting to the relay server. As soon as
+ // PrepareAddress is called, the RelayPort will start trying to
+ // connect to the given UDP address. As soon as a response to the
+ // sent STUN allocate request message has been received, the
+ // RelayPort will consider the connection to be complete and will
+ // abort any other connection attempts.
+ void TestConnectUdp() {
+ // Add a UDP socket to the relay server.
+ talk_base::AsyncUDPSocket* internal_udp_socket =
+ CreateAsyncUdpSocket(kRelayUdpAddr);
+ talk_base::AsyncSocket* server_socket = CreateServerSocket(kRelayTcpAddr);
+
+ relay_server_->AddInternalSocket(internal_udp_socket);
+ relay_server_->AddInternalServerSocket(server_socket, cricket::PROTO_TCP);
+
+ // Now add our relay addresses to the relay port and let it start.
+ relay_port_->AddServerAddress(
+ cricket::ProtocolAddress(kRelayUdpAddr, cricket::PROTO_UDP));
+ relay_port_->AddServerAddress(
+ cricket::ProtocolAddress(kRelayTcpAddr, cricket::PROTO_TCP));
+ relay_port_->PrepareAddress();
+
+ // Should be connected.
+ EXPECT_TRUE_WAIT(relay_port_->IsReady(), kTimeoutMs);
+
+ // Make sure that we are happy with UDP, ie. not continuing with
+ // TCP, SSLTCP, etc.
+ WAIT(relay_server_->HasConnection(kRelayTcpAddr), kTimeoutMs);
+
+ // Should have only one connection.
+ EXPECT_EQ(1, relay_server_->GetConnectionCount());
+
+ // Should be the UDP address.
+ EXPECT_TRUE(relay_server_->HasConnection(kRelayUdpAddr));
+ }
+
+ // TCP has the second best 'goodness' value, and as soon as UDP
+ // connection has failed, the RelayPort will attempt to connect via
+ // TCP. Here we add a fake UDP address together with a real TCP
+ // address to simulate an UDP failure. As soon as UDP has failed the
+ // RelayPort will try the TCP adress and succed.
+ void TestConnectTcp() {
+ // Create a fake UDP address for relay port to simulate a failure.
+ cricket::ProtocolAddress fake_protocol_address =
+ cricket::ProtocolAddress(kRelayUdpAddr, cricket::PROTO_UDP);
+
+ // Create a server socket for the RelayServer.
+ talk_base::AsyncSocket* server_socket = CreateServerSocket(kRelayTcpAddr);
+ relay_server_->AddInternalServerSocket(server_socket, cricket::PROTO_TCP);
+
+ // Add server addresses to the relay port and let it start.
+ relay_port_->AddServerAddress(
+ cricket::ProtocolAddress(fake_protocol_address));
+ relay_port_->AddServerAddress(
+ cricket::ProtocolAddress(kRelayTcpAddr, cricket::PROTO_TCP));
+ relay_port_->PrepareAddress();
+
+ EXPECT_FALSE(relay_port_->IsReady());
+
+ // Should have timed out in 200 + 200 + 400 + 800 + 1600 ms.
+ EXPECT_TRUE_WAIT(HasFailed(&fake_protocol_address), 3600);
+
+ // Wait until relayport is ready.
+ EXPECT_TRUE_WAIT(relay_port_->IsReady(), kMaxTimeoutMs);
+
+ // Should have only one connection.
+ EXPECT_EQ(1, relay_server_->GetConnectionCount());
+
+ // Should be the TCP address.
+ EXPECT_TRUE(relay_server_->HasConnection(kRelayTcpAddr));
+ }
+
+ void TestConnectSslTcp() {
+ // Create a fake TCP address for relay port to simulate a failure.
+ // We skip UDP here since transition from UDP to TCP has been
+ // tested above.
+ cricket::ProtocolAddress fake_protocol_address =
+ cricket::ProtocolAddress(kRelayTcpAddr, cricket::PROTO_TCP);
+
+ // Create a ssl server socket for the RelayServer.
+ talk_base::AsyncSocket* ssl_server_socket =
+ CreateServerSocket(kRelaySslAddr);
+ relay_server_->AddInternalServerSocket(ssl_server_socket,
+ cricket::PROTO_SSLTCP);
+
+ // Create a tcp server socket that listens on the fake address so
+ // the relay port can attempt to connect to it.
+ talk_base::scoped_ptr<talk_base::AsyncSocket> tcp_server_socket(
+ CreateServerSocket(kRelayTcpAddr));
+
+ // Add server addresses to the relay port and let it start.
+ relay_port_->AddServerAddress(fake_protocol_address);
+ relay_port_->AddServerAddress(
+ cricket::ProtocolAddress(kRelaySslAddr, cricket::PROTO_SSLTCP));
+ relay_port_->PrepareAddress();
+ EXPECT_FALSE(relay_port_->IsReady());
+
+ // Should have timed out in 3000 ms(relayport.cc, kSoftConnectTimeoutMs).
+ EXPECT_TRUE_WAIT_MARGIN(HasTimedOut(&fake_protocol_address), 3000, 100);
+
+ // Wait until relayport is ready.
+ EXPECT_TRUE_WAIT(relay_port_->IsReady(), kMaxTimeoutMs);
+
+ // Should have only one connection.
+ EXPECT_EQ(1, relay_server_->GetConnectionCount());
+
+ // Should be the SSLTCP address.
+ EXPECT_TRUE(relay_server_->HasConnection(kRelaySslAddr));
+ }
+
+ private:
+ talk_base::AsyncUDPSocket* CreateAsyncUdpSocket(const SocketAddress addr) {
+ talk_base::AsyncSocket* socket =
+ virtual_socket_server_->CreateAsyncSocket(SOCK_DGRAM);
+ talk_base::AsyncUDPSocket* packet_socket =
+ talk_base::AsyncUDPSocket::Create(socket, addr);
+ EXPECT_TRUE(packet_socket != NULL);
+ packet_socket->SignalReadPacket.connect(this, &RelayPortTest::OnReadPacket);
+ return packet_socket;
+ }
+
+ talk_base::AsyncSocket* CreateServerSocket(const SocketAddress addr) {
+ talk_base::AsyncSocket* socket =
+ virtual_socket_server_->CreateAsyncSocket(SOCK_STREAM);
+ EXPECT_GE(socket->Bind(addr), 0);
+ EXPECT_GE(socket->Listen(5), 0);
+ return socket;
+ }
+
+ bool HasFailed(cricket::ProtocolAddress* addr) {
+ for (size_t i = 0; i < failed_connections_.size(); i++) {
+ if (failed_connections_[i].address == addr->address &&
+ failed_connections_[i].proto == addr->proto) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ bool HasTimedOut(cricket::ProtocolAddress* addr) {
+ for (size_t i = 0; i < soft_timedout_connections_.size(); i++) {
+ if (soft_timedout_connections_[i].address == addr->address &&
+ soft_timedout_connections_[i].proto == addr->proto) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ typedef std::map<talk_base::AsyncPacketSocket*, int> PacketMap;
+
+ talk_base::Thread* main_;
+ talk_base::scoped_ptr<talk_base::PhysicalSocketServer>
+ physical_socket_server_;
+ talk_base::scoped_ptr<talk_base::VirtualSocketServer> virtual_socket_server_;
+ talk_base::SocketServerScope ss_scope_;
+ talk_base::Network network_;
+ talk_base::BasicPacketSocketFactory socket_factory_;
+ std::string username_;
+ std::string password_;
+ talk_base::scoped_ptr<cricket::RelayPort> relay_port_;
+ talk_base::scoped_ptr<cricket::RelayServer> relay_server_;
+ std::vector<cricket::ProtocolAddress> failed_connections_;
+ std::vector<cricket::ProtocolAddress> soft_timedout_connections_;
+ PacketMap received_packet_count_;
+};
+
+TEST_F(RelayPortTest, ConnectUdp) {
+ TestConnectUdp();
+}
+
+TEST_F(RelayPortTest, ConnectTcp) {
+ TestConnectTcp();
+}
+
+TEST_F(RelayPortTest, ConnectSslTcp) {
+ TestConnectSslTcp();
+}
diff --git a/talk/p2p/base/relayserver.cc b/talk/p2p/base/relayserver.cc
index 554337f..b17da5b 100644
--- a/talk/p2p/base/relayserver.cc
+++ b/talk/p2p/base/relayserver.cc
@@ -444,7 +444,7 @@
StunAddressAttribute* addr_attr =
StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
- addr_attr->SetIP(ext_addr.ip());
+ addr_attr->SetIP(ext_addr.ipaddr());
addr_attr->SetPort(ext_addr.port());
response.AddAttribute(addr_attr);
@@ -478,7 +478,7 @@
return;
}
- talk_base::SocketAddress ext_addr(addr_attr->ip(), addr_attr->port());
+ talk_base::SocketAddress ext_addr(addr_attr->ipaddr(), addr_attr->port());
RelayServerConnection* ext_conn =
int_conn->binding()->GetExternalConnection(ext_addr);
if (!ext_conn) {
@@ -620,7 +620,7 @@
StunAddressAttribute* addr_attr =
StunAttribute::CreateAddress(STUN_ATTR_SOURCE_ADDRESS2);
- addr_attr->SetIP(from_addr.ip());
+ addr_attr->SetIP(from_addr.ipaddr());
addr_attr->SetPort(from_addr.port());
msg.AddAttribute(addr_attr);
diff --git a/talk/p2p/base/relayserver.h b/talk/p2p/base/relayserver.h
index d34c099..a5fcc24 100644
--- a/talk/p2p/base/relayserver.h
+++ b/talk/p2p/base/relayserver.h
@@ -35,7 +35,7 @@
#include "talk/base/asyncudpsocket.h"
#include "talk/base/socketaddresspair.h"
#include "talk/base/thread.h"
-#include "talk/base/time.h"
+#include "talk/base/timeutils.h"
#include "talk/p2p/base/port.h"
#include "talk/p2p/base/stun.h"
diff --git a/talk/p2p/base/relayserver_unittest.cc b/talk/p2p/base/relayserver_unittest.cc
new file mode 100644
index 0000000..0f96e27
--- /dev/null
+++ b/talk/p2p/base/relayserver_unittest.cc
@@ -0,0 +1,546 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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 "talk/base/gunit.h"
+#include "talk/base/helpers.h"
+#include "talk/base/host.h"
+#include "talk/base/logging.h"
+#include "talk/base/physicalsocketserver.h"
+#include "talk/base/socketaddress.h"
+#include "talk/base/testclient.h"
+#include "talk/base/thread.h"
+#include "talk/p2p/base/relayserver.h"
+
+using talk_base::SocketAddress;
+using namespace cricket;
+
+static const uint32 LIFETIME = 4; // seconds
+static const SocketAddress server_int_addr("127.0.0.1", 5000);
+static const SocketAddress server_ext_addr("127.0.0.1", 5001);
+static const SocketAddress client1_addr("127.0.0.1", 6000 + (rand() % 1000));
+static const SocketAddress client2_addr("127.0.0.1", 7000 + (rand() % 1000));
+static const char* bad = "this is a completely nonsensical message whose only "
+ "purpose is to make the parser go 'ack'. it doesn't "
+ "look anything like a normal stun message";
+static const char* msg1 = "spamspamspamspamspamspamspambakedbeansspam";
+static const char* msg2 = "Lobster Thermidor a Crevette with a mornay sauce...";
+
+class RelayServerTest : public testing::Test {
+ public:
+ static void SetUpTestCase() {
+ talk_base::InitRandom(NULL, 0);
+ }
+ RelayServerTest()
+ : main_(talk_base::Thread::Current()), ss_(main_->socketserver()),
+ username_(talk_base::CreateRandomString(12)),
+ password_(talk_base::CreateRandomString(12)) {
+ }
+ protected:
+ virtual void SetUp() {
+ server_.reset(new RelayServer(main_));
+
+ server_->AddInternalSocket(
+ talk_base::AsyncUDPSocket::Create(ss_, server_int_addr));
+ server_->AddExternalSocket(
+ talk_base::AsyncUDPSocket::Create(ss_, server_ext_addr));
+
+ client1_.reset(new talk_base::TestClient(
+ talk_base::AsyncUDPSocket::Create(ss_, client1_addr)));
+ client2_.reset(new talk_base::TestClient(
+ talk_base::AsyncUDPSocket::Create(ss_, client2_addr)));
+ }
+
+ void Allocate() {
+ talk_base::scoped_ptr<StunMessage> req(
+ CreateStunMessage(STUN_ALLOCATE_REQUEST));
+ AddUsernameAttr(req.get(), username_);
+ AddLifetimeAttr(req.get(), LIFETIME);
+ Send1(req.get());
+ delete Receive1();
+ }
+ void Bind() {
+ talk_base::scoped_ptr<StunMessage> req(
+ CreateStunMessage(STUN_BINDING_REQUEST));
+ AddUsernameAttr(req.get(), username_);
+ Send2(req.get());
+ delete Receive1();
+ }
+
+ void Send1(const StunMessage* msg) {
+ talk_base::ByteBuffer buf;
+ msg->Write(&buf);
+ SendRaw1(buf.Data(), buf.Length());
+ }
+ void Send2(const StunMessage* msg) {
+ talk_base::ByteBuffer buf;
+ msg->Write(&buf);
+ SendRaw2(buf.Data(), buf.Length());
+ }
+ void SendRaw1(const char* data, int len) {
+ return Send(client1_.get(), data, len, server_int_addr);
+ }
+ void SendRaw2(const char* data, int len) {
+ return Send(client2_.get(), data, len, server_ext_addr);
+ }
+ void Send(talk_base::TestClient* client, const char* data,
+ int len, const SocketAddress& addr) {
+ client->SendTo(data, len, addr);
+ }
+
+ StunMessage* Receive1() {
+ return Receive(client1_.get());
+ }
+ StunMessage* Receive2() {
+ return Receive(client2_.get());
+ }
+ std::string ReceiveRaw1() {
+ return ReceiveRaw(client1_.get());
+ }
+ std::string ReceiveRaw2() {
+ return ReceiveRaw(client2_.get());
+ }
+ StunMessage* Receive(talk_base::TestClient* client) {
+ StunMessage* msg = NULL;
+ talk_base::TestClient::Packet* packet = client->NextPacket();
+ if (packet) {
+ talk_base::ByteBuffer buf(packet->buf, packet->size);
+ msg = new StunMessage();
+ msg->Read(&buf);
+ delete packet;
+ }
+ return msg;
+ }
+ std::string ReceiveRaw(talk_base::TestClient* client) {
+ std::string raw;
+ talk_base::TestClient::Packet* packet = client->NextPacket();
+ if (packet) {
+ raw = std::string(packet->buf, packet->size);
+ delete packet;
+ }
+ return raw;
+ }
+
+ static StunMessage* CreateStunMessage(StunMessageType type) {
+ StunMessage* msg = new StunMessage();
+ msg->SetType(type);
+ msg->SetTransactionID(
+ talk_base::CreateRandomString(kStunTransactionIdLength));
+ return msg;
+ }
+ static void AddMagicCookieAttr(StunMessage* msg) {
+ StunByteStringAttribute* attr =
+ StunAttribute::CreateByteString(STUN_ATTR_MAGIC_COOKIE);
+ attr->CopyBytes(TURN_MAGIC_COOKIE_VALUE, sizeof(TURN_MAGIC_COOKIE_VALUE));
+ msg->AddAttribute(attr);
+ }
+ static void AddUsernameAttr(StunMessage* msg, const std::string& val) {
+ StunByteStringAttribute* attr =
+ StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
+ attr->CopyBytes(val.c_str(), val.size());
+ msg->AddAttribute(attr);
+ }
+ static void AddLifetimeAttr(StunMessage* msg, int val) {
+ StunUInt32Attribute* attr =
+ StunAttribute::CreateUInt32(STUN_ATTR_LIFETIME);
+ attr->SetValue(val);
+ msg->AddAttribute(attr);
+ }
+ static void AddDestinationAttr(StunMessage* msg, const SocketAddress& addr) {
+ StunAddressAttribute* attr =
+ StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
+ attr->SetIP(addr.ipaddr());
+ attr->SetPort(addr.port());
+ msg->AddAttribute(attr);
+ }
+
+ talk_base::Thread* main_;
+ talk_base::SocketServer* ss_;
+ talk_base::scoped_ptr<RelayServer> server_;
+ talk_base::scoped_ptr<talk_base::TestClient> client1_;
+ talk_base::scoped_ptr<talk_base::TestClient> client2_;
+ std::string username_;
+ std::string password_;
+};
+
+// Send a complete nonsense message and verify that it is rejected.
+TEST_F(RelayServerTest, TestBadRequest) {
+ talk_base::scoped_ptr<StunMessage> res;
+
+ SendRaw1(bad, std::strlen(bad));
+ res.reset(Receive1());
+
+ ASSERT_TRUE(res.get() != NULL);
+ EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, res->type());
+
+ const StunErrorCodeAttribute* err = res->GetErrorCode();
+ ASSERT_TRUE(err != NULL);
+ EXPECT_EQ(4, err->error_class());
+ EXPECT_EQ(0, err->number());
+ EXPECT_EQ("Bad Request", err->reason());
+}
+
+// Send an allocate request without a username and verify it is rejected.
+TEST_F(RelayServerTest, TestAllocateNoUsername) {
+ talk_base::scoped_ptr<StunMessage> req(
+ CreateStunMessage(STUN_ALLOCATE_REQUEST)), res;
+
+ Send1(req.get());
+ res.reset(Receive1());
+
+ ASSERT_TRUE(res.get() != NULL);
+ EXPECT_EQ(STUN_ALLOCATE_ERROR_RESPONSE, res->type());
+ EXPECT_EQ(req->transaction_id(), res->transaction_id());
+
+ const StunErrorCodeAttribute* err = res->GetErrorCode();
+ ASSERT_TRUE(err != NULL);
+ EXPECT_EQ(4, err->error_class());
+ EXPECT_EQ(32, err->number());
+ EXPECT_EQ("Missing Username", err->reason());
+}
+
+// Send a binding request and verify that it is rejected.
+TEST_F(RelayServerTest, TestBindingRequest) {
+ talk_base::scoped_ptr<StunMessage> req(
+ CreateStunMessage(STUN_BINDING_REQUEST)), res;
+ AddUsernameAttr(req.get(), username_);
+
+ Send1(req.get());
+ res.reset(Receive1());
+
+ ASSERT_TRUE(res.get() != NULL);
+ EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, res->type());
+ EXPECT_EQ(req->transaction_id(), res->transaction_id());
+
+ const StunErrorCodeAttribute* err = res->GetErrorCode();
+ ASSERT_TRUE(err != NULL);
+ EXPECT_EQ(6, err->error_class());
+ EXPECT_EQ(0, err->number());
+ EXPECT_EQ("Operation Not Supported", err->reason());
+}
+
+// Send an allocate request and verify that it is accepted.
+TEST_F(RelayServerTest, TestAllocate) {
+ talk_base::scoped_ptr<StunMessage> req(
+ CreateStunMessage(STUN_ALLOCATE_REQUEST)), res;
+ AddUsernameAttr(req.get(), username_);
+ AddLifetimeAttr(req.get(), LIFETIME);
+
+ Send1(req.get());
+ res.reset(Receive1());
+
+ ASSERT_TRUE(res.get() != NULL);
+ EXPECT_EQ(STUN_ALLOCATE_RESPONSE, res->type());
+ EXPECT_EQ(req->transaction_id(), res->transaction_id());
+
+ const StunAddressAttribute* mapped_addr =
+ res->GetAddress(STUN_ATTR_MAPPED_ADDRESS);
+ ASSERT_TRUE(mapped_addr != NULL);
+ EXPECT_EQ(1, mapped_addr->family());
+ EXPECT_EQ(server_ext_addr.port(), mapped_addr->port());
+ EXPECT_EQ(server_ext_addr.ipaddr(), mapped_addr->ipaddr());
+
+ const StunUInt32Attribute* res_lifetime_attr =
+ res->GetUInt32(STUN_ATTR_LIFETIME);
+ ASSERT_TRUE(res_lifetime_attr != NULL);
+ EXPECT_EQ(LIFETIME, res_lifetime_attr->value());
+}
+
+// Send a second allocate request and verify that it is also accepted, though
+// the lifetime should be ignored.
+TEST_F(RelayServerTest, TestReallocate) {
+ Allocate();
+
+ talk_base::scoped_ptr<StunMessage> req(
+ CreateStunMessage(STUN_ALLOCATE_REQUEST)), res;
+ AddMagicCookieAttr(req.get());
+ AddUsernameAttr(req.get(), username_);
+
+ Send1(req.get());
+ res.reset(Receive1());
+
+ ASSERT_TRUE(res.get() != NULL);
+ EXPECT_EQ(STUN_ALLOCATE_RESPONSE, res->type());
+ EXPECT_EQ(req->transaction_id(), res->transaction_id());
+
+ const StunAddressAttribute* mapped_addr =
+ res->GetAddress(STUN_ATTR_MAPPED_ADDRESS);
+ ASSERT_TRUE(mapped_addr != NULL);
+ EXPECT_EQ(1, mapped_addr->family());
+ EXPECT_EQ(server_ext_addr.port(), mapped_addr->port());
+ EXPECT_EQ(server_ext_addr.ipaddr(), mapped_addr->ipaddr());
+
+ const StunUInt32Attribute* lifetime_attr =
+ res->GetUInt32(STUN_ATTR_LIFETIME);
+ ASSERT_TRUE(lifetime_attr != NULL);
+ EXPECT_EQ(LIFETIME, lifetime_attr->value());
+}
+
+// Send a request from another client and see that it arrives at the first
+// client in the binding.
+TEST_F(RelayServerTest, TestRemoteBind) {
+ Allocate();
+
+ talk_base::scoped_ptr<StunMessage> req(
+ CreateStunMessage(STUN_BINDING_REQUEST)), res;
+ AddUsernameAttr(req.get(), username_);
+
+ Send2(req.get());
+ res.reset(Receive1());
+
+ ASSERT_TRUE(res.get() != NULL);
+ EXPECT_EQ(STUN_DATA_INDICATION, res->type());
+
+ const StunByteStringAttribute* recv_data =
+ res->GetByteString(STUN_ATTR_DATA);
+ ASSERT_TRUE(recv_data != NULL);
+
+ talk_base::ByteBuffer buf(recv_data->bytes(), recv_data->length());
+ talk_base::scoped_ptr<StunMessage> res2(new StunMessage());
+ EXPECT_TRUE(res2->Read(&buf));
+ EXPECT_EQ(STUN_BINDING_REQUEST, res2->type());
+ EXPECT_EQ(req->transaction_id(), res2->transaction_id());
+
+ const StunAddressAttribute* src_addr =
+ res->GetAddress(STUN_ATTR_SOURCE_ADDRESS2);
+ ASSERT_TRUE(src_addr != NULL);
+ EXPECT_EQ(1, src_addr->family());
+ EXPECT_EQ(client2_addr.ipaddr(), src_addr->ipaddr());
+ EXPECT_EQ(client2_addr.port(), src_addr->port());
+
+ EXPECT_TRUE(Receive2() == NULL);
+}
+
+// Send a complete nonsense message to the established connection and verify
+// that it is dropped by the server.
+TEST_F(RelayServerTest, TestRemoteBadRequest) {
+ Allocate();
+ Bind();
+
+ SendRaw1(bad, std::strlen(bad));
+ EXPECT_TRUE(Receive1() == NULL);
+ EXPECT_TRUE(Receive2() == NULL);
+}
+
+// Send a send request without a username and verify it is rejected.
+TEST_F(RelayServerTest, TestSendRequestMissingUsername) {
+ Allocate();
+ Bind();
+
+ talk_base::scoped_ptr<StunMessage> req(
+ CreateStunMessage(STUN_SEND_REQUEST)), res;
+ AddMagicCookieAttr(req.get());
+
+ Send1(req.get());
+ res.reset(Receive1());
+
+ ASSERT_TRUE(res.get() != NULL);
+ EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type());
+ EXPECT_EQ(req->transaction_id(), res->transaction_id());
+
+ const StunErrorCodeAttribute* err = res->GetErrorCode();
+ ASSERT_TRUE(err != NULL);
+ EXPECT_EQ(4, err->error_class());
+ EXPECT_EQ(32, err->number());
+ EXPECT_EQ("Missing Username", err->reason());
+}
+
+// Send a send request with the wrong username and verify it is rejected.
+TEST_F(RelayServerTest, TestSendRequestBadUsername) {
+ Allocate();
+ Bind();
+
+ talk_base::scoped_ptr<StunMessage> req(
+ CreateStunMessage(STUN_SEND_REQUEST)), res;
+ AddMagicCookieAttr(req.get());
+ AddUsernameAttr(req.get(), "foobarbizbaz");
+
+ Send1(req.get());
+ res.reset(Receive1());
+
+ ASSERT_TRUE(res.get() != NULL);
+ EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type());
+ EXPECT_EQ(req->transaction_id(), res->transaction_id());
+
+ const StunErrorCodeAttribute* err = res->GetErrorCode();
+ ASSERT_TRUE(err != NULL);
+ EXPECT_EQ(4, err->error_class());
+ EXPECT_EQ(30, err->number());
+ EXPECT_EQ("Stale Credentials", err->reason());
+}
+
+// Send a send request without a destination address and verify that it is
+// rejected.
+TEST_F(RelayServerTest, TestSendRequestNoDestinationAddress) {
+ Allocate();
+ Bind();
+
+ talk_base::scoped_ptr<StunMessage> req(
+ CreateStunMessage(STUN_SEND_REQUEST)), res;
+ AddMagicCookieAttr(req.get());
+ AddUsernameAttr(req.get(), username_);
+
+ Send1(req.get());
+ res.reset(Receive1());
+
+ ASSERT_TRUE(res.get() != NULL);
+ EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type());
+ EXPECT_EQ(req->transaction_id(), res->transaction_id());
+
+ const StunErrorCodeAttribute* err = res->GetErrorCode();
+ ASSERT_TRUE(err != NULL);
+ EXPECT_EQ(4, err->error_class());
+ EXPECT_EQ(0, err->number());
+ EXPECT_EQ("Bad Request", err->reason());
+}
+
+// Send a send request without data and verify that it is rejected.
+TEST_F(RelayServerTest, TestSendRequestNoData) {
+ Allocate();
+ Bind();
+
+ talk_base::scoped_ptr<StunMessage> req(
+ CreateStunMessage(STUN_SEND_REQUEST)), res;
+ AddMagicCookieAttr(req.get());
+ AddUsernameAttr(req.get(), username_);
+ AddDestinationAttr(req.get(), client2_addr);
+
+ Send1(req.get());
+ res.reset(Receive1());
+
+ ASSERT_TRUE(res.get() != NULL);
+ EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type());
+ EXPECT_EQ(req->transaction_id(), res->transaction_id());
+
+ const StunErrorCodeAttribute* err = res->GetErrorCode();
+ ASSERT_TRUE(err != NULL);
+ EXPECT_EQ(4, err->error_class());
+ EXPECT_EQ(00, err->number());
+ EXPECT_EQ("Bad Request", err->reason());
+}
+
+// Send a binding request after an allocate and verify that it is rejected.
+TEST_F(RelayServerTest, TestSendRequestWrongType) {
+ Allocate();
+ Bind();
+
+ talk_base::scoped_ptr<StunMessage> req(
+ CreateStunMessage(STUN_BINDING_REQUEST)), res;
+ AddMagicCookieAttr(req.get());
+ AddUsernameAttr(req.get(), username_);
+
+ Send1(req.get());
+ res.reset(Receive1());
+
+ ASSERT_TRUE(res.get() != NULL);
+ EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, res->type());
+ EXPECT_EQ(req->transaction_id(), res->transaction_id());
+
+ const StunErrorCodeAttribute* err = res->GetErrorCode();
+ ASSERT_TRUE(err != NULL);
+ EXPECT_EQ(6, err->error_class());
+ EXPECT_EQ(0, err->number());
+ EXPECT_EQ("Operation Not Supported", err->reason());
+}
+
+// Verify that we can send traffic back and forth between the clients after a
+// successful allocate and bind.
+TEST_F(RelayServerTest, TestSendRaw) {
+ Allocate();
+ Bind();
+
+ for (int i = 0; i < 10; i++) {
+ talk_base::scoped_ptr<StunMessage> req(
+ CreateStunMessage(STUN_SEND_REQUEST)), res;
+ AddMagicCookieAttr(req.get());
+ AddUsernameAttr(req.get(), username_);
+ AddDestinationAttr(req.get(), client2_addr);
+
+ StunByteStringAttribute* send_data =
+ StunAttribute::CreateByteString(STUN_ATTR_DATA);
+ send_data->CopyBytes(msg1);
+ req->AddAttribute(send_data);
+
+ Send1(req.get());
+ EXPECT_EQ(msg1, ReceiveRaw2());
+ SendRaw2(msg2, std::strlen(msg2));
+ res.reset(Receive1());
+
+ ASSERT_TRUE(res.get() != NULL);
+ EXPECT_EQ(STUN_DATA_INDICATION, res->type());
+
+ const StunAddressAttribute* src_addr =
+ res->GetAddress(STUN_ATTR_SOURCE_ADDRESS2);
+ ASSERT_TRUE(src_addr != NULL);
+ EXPECT_EQ(1, src_addr->family());
+ EXPECT_EQ(client2_addr.ipaddr(), src_addr->ipaddr());
+ EXPECT_EQ(client2_addr.port(), src_addr->port());
+
+ const StunByteStringAttribute* recv_data =
+ res->GetByteString(STUN_ATTR_DATA);
+ ASSERT_TRUE(recv_data != NULL);
+ EXPECT_EQ(strlen(msg2), recv_data->length());
+ EXPECT_EQ(0, memcmp(msg2, recv_data->bytes(), recv_data->length()));
+ }
+}
+
+// Verify that a binding expires properly, and rejects send requests.
+TEST_F(RelayServerTest, TestExpiration) {
+ Allocate();
+ Bind();
+
+ // Wait twice the lifetime to make sure the server has expired the binding.
+ talk_base::Thread::Current()->ProcessMessages((LIFETIME * 2) * 1000);
+
+ talk_base::scoped_ptr<StunMessage> req(
+ CreateStunMessage(STUN_SEND_REQUEST)), res;
+ AddMagicCookieAttr(req.get());
+ AddUsernameAttr(req.get(), username_);
+ AddDestinationAttr(req.get(), client2_addr);
+
+ StunByteStringAttribute* data_attr =
+ StunAttribute::CreateByteString(STUN_ATTR_DATA);
+ data_attr->CopyBytes(msg1);
+ req->AddAttribute(data_attr);
+
+ Send1(req.get());
+ res.reset(Receive1());
+
+ ASSERT_TRUE(res.get() != NULL);
+ EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type());
+
+ const StunErrorCodeAttribute* err = res->GetErrorCode();
+ ASSERT_TRUE(err != NULL);
+ EXPECT_EQ(6, err->error_class());
+ EXPECT_EQ(0, err->number());
+ EXPECT_EQ("Operation Not Supported", err->reason());
+
+ // Also verify that traffic from the external client is ignored.
+ SendRaw2(msg2, std::strlen(msg2));
+ EXPECT_TRUE(ReceiveRaw1().empty());
+}
diff --git a/talk/p2p/base/session.cc b/talk/p2p/base/session.cc
index b5be361..aba5ac4 100644
--- a/talk/p2p/base/session.cc
+++ b/talk/p2p/base/session.cc
@@ -32,11 +32,11 @@
#include "talk/base/scoped_ptr.h"
#include "talk/xmpp/constants.h"
#include "talk/xmpp/jid.h"
+#include "talk/p2p/base/p2ptransport.h"
+#include "talk/p2p/base/p2ptransportchannel.h"
#include "talk/p2p/base/sessionclient.h"
#include "talk/p2p/base/transport.h"
#include "talk/p2p/base/transportchannelproxy.h"
-#include "talk/p2p/base/p2ptransport.h"
-#include "talk/p2p/base/p2ptransportchannel.h"
#include "talk/p2p/base/constants.h"
@@ -64,13 +64,21 @@
iter->second->SignalDestroyed(iter->second);
delete iter->second;
}
- delete transport_;
+ if (owner_)
+ delete transport_;
}
std::string TransportProxy::type() const {
return transport_->type();
}
+void TransportProxy::SetImplementation(Transport* impl, bool owner) {
+ if (owner_ && transport_)
+ delete transport_;
+ transport_ = impl;
+ owner_ = owner;
+}
+
TransportChannel* TransportProxy::GetChannel(const std::string& name) {
return GetProxy(name);
}
@@ -148,6 +156,7 @@
TransportChannelImpl* impl = transport_->GetChannel(name);
if (impl == NULL) {
impl = transport_->CreateChannel(name, content_type);
+ impl->set_session_id(sid_);
}
return impl;
}
@@ -156,7 +165,34 @@
const std::string& name, TransportChannelProxy* proxy) {
TransportChannelImpl* impl = GetOrCreateImpl(name, proxy->content_type());
ASSERT(impl != NULL);
- proxy->SetImplementation(impl);
+ proxy->SetImplementation(impl, true);
+}
+
+// This method will use TransportChannelImpls of and deletes what it owns.
+void TransportProxy::CopyTransportProxyChannels(TransportProxy* proxy) {
+ size_t index = 0;
+ for (ChannelMap::const_iterator iter = proxy->channels().begin();
+ iter != proxy->channels().end(); ++iter, ++index) {
+ ReplaceImpl(iter->second, index);
+ }
+}
+
+void TransportProxy::ReplaceImpl(TransportChannelProxy* channel,
+ size_t index) {
+ if (index < channels().size()) {
+ ChannelMap::const_iterator iter = channels().begin();
+ // Get handle the index which needs to be replaced.
+ for (size_t i = 0; i < index; ++i, ++iter);
+
+ TransportChannelProxy* target_channel = iter->second;
+ if (target_channel) {
+ // Deleting TransportChannelImpl before replacing it.
+ transport_->DestroyChannel(iter->first);
+ target_channel->SetImplementation(channel->impl(), false);
+ }
+ } else {
+ LOG(LS_WARNING) << "invalid TransportChannelProxy index to replace";
+ }
}
BaseSession::BaseSession(talk_base::Thread* signaling_thread,
@@ -249,7 +285,7 @@
transport->SignalChannelGone.connect(
this, &BaseSession::OnTransportChannelGone);
- transproxy = new TransportProxy(content_name, transport);
+ transproxy = new TransportProxy(sid_, content_name, transport);
transports_[content_name] = transproxy;
return transproxy;
@@ -323,6 +359,59 @@
}
}
+bool BaseSession::ContentsGrouped() {
+ // TODO - present implementation checks for groups present
+ // in SDP. It may be necessary to check content_names in groups of both
+ // local and remote descriptions. Assumption here is that when this method
+ // returns true, media contents can be muxed.
+ if (local_description()->HasGroup(GN_BUNDLE) &&
+ remote_description()->HasGroup(GN_BUNDLE)) {
+ return true;
+ }
+ return false;
+}
+
+bool BaseSession::MaybeEnableMuxingSupport() {
+ bool ret = true;
+ if (!ContentsGrouped()) {
+ LOG(LS_INFO) << "Contents are not grouped together cannot be muxed";
+ } else {
+ // Always use first content name from the group for muxing. Hence ordering
+ // of content names in SDP should match to the order in group.
+ const ContentGroup* muxed_content_group =
+ local_description()->GetGroupByName(GN_BUNDLE);
+ const std::string* content_name =
+ muxed_content_group->FirstContentName();
+ if (content_name) {
+ const ContentInfo* content =
+ local_description_->GetContentByName(*content_name);
+ ASSERT(content != NULL);
+ SetSelectedProxy(content->name, muxed_content_group);
+ }
+ }
+ return ret;
+}
+
+void BaseSession::SetSelectedProxy(const std::string& content_name,
+ const ContentGroup* muxed_group) {
+ TransportProxy* selected_proxy = GetTransportProxy(content_name);
+ if (selected_proxy) {
+ ASSERT(selected_proxy->negotiated());
+ for (TransportMap::iterator iter = transports_.begin();
+ iter != transports_.end(); ++iter) {
+ // If content is part of group, then try to replace the Proxy with
+ // the selected.
+ if (iter->first != content_name &&
+ muxed_group->HasContentName(iter->first)) {
+ TransportProxy* proxy = iter->second;
+ proxy->CopyTransportProxyChannels(selected_proxy);
+ // After replacing the TransportChannels, replace Transport
+ proxy->SetImplementation(selected_proxy->impl(), false);
+ }
+ }
+ }
+}
+
void BaseSession::OnMessage(talk_base::Message *pmsg) {
switch (pmsg->message_id) {
case MSG_TIMEOUT:
@@ -414,6 +503,7 @@
return false;
}
+ MaybeEnableMuxingSupport(); // Enable transport channel mux if supported.
SetState(Session::STATE_SENTACCEPT);
return true;
}
@@ -648,8 +738,8 @@
case ACTION_TRANSPORT_ACCEPT:
valid = OnTransportAcceptMessage(msg, &error);
break;
- case ACTION_UPDATE:
- valid = OnUpdateMessage(msg, &error);
+ case ACTION_DESCRIPTION_INFO:
+ valid = OnDescriptionInfoMessage(msg, &error);
break;
default:
valid = BadMessage(buzz::QN_STANZA_BAD_REQUEST,
@@ -796,6 +886,7 @@
OnInitiateAcked();
set_remote_description(new SessionDescription(accept.ClearContents()));
+ MaybeEnableMuxingSupport(); // Enable transport channel mux if supported.
SetState(STATE_RECEIVEDACCEPT);
// Users of Session may listen to state change and call Reject().
@@ -856,7 +947,7 @@
return true;
}
-bool Session::OnUpdateMessage(const SessionMessage& msg,
+bool Session::OnDescriptionInfoMessage(const SessionMessage& msg,
MessageError* error) {
if (!CheckState(STATE_INPROGRESS, error))
return false;
@@ -869,27 +960,33 @@
}
ContentInfos updated_contents = description_info.ClearContents();
- ContentInfos::iterator it;
+ // TODO: Currently, reflector sends back
+ // video stream updates even for an audio-only call, which causes
+ // this to fail. Put this back once reflector is fixed.
+ //
+ // ContentInfos::iterator it;
// First, ensure all updates are valid before modifying remote_description_.
- for (it = updated_contents.begin(); it != updated_contents.end(); ++it) {
- if (remote_description()->GetContentByName(it->name) == NULL) {
- return false;
- }
+ // for (it = updated_contents.begin(); it != updated_contents.end(); ++it) {
+ // if (remote_description()->GetContentByName(it->name) == NULL) {
+ // return false;
+ // }
+ // }
- // TODO: We should add a check to ensure that the updated
- // contents are compatible with the original contents.
- }
+ // TODO: We used to replace contents from an update, but
+ // that no longer works with partial updates. We need to figure out
+ // a way to merge patial updates into contents. For now, users of
+ // Session should listen to SignalRemoteDescriptionUpdate and handle
+ // updates. They should not expect remote_description to be the
+ // latest value.
+ //
+ // for (it = updated_contents.begin(); it != updated_contents.end(); ++it) {
+ // remote_description()->RemoveContentByName(it->name);
+ // remote_description()->AddContent(it->name, it->type, it->description);
+ // }
+ // }
- // Merge the updates into the remote description.
- for (it = updated_contents.begin(); it != updated_contents.end(); ++it) {
- LOG(LS_INFO) << "Updating content " << it->name;
- remote_description()->RemoveContentByName(it->name);
- remote_description()->AddContent(it->name, it->type, it->description);
- }
-
- SignalRemoteDescriptionUpdate(this);
-
+ SignalRemoteDescriptionUpdate(this, updated_contents);
return true;
}
diff --git a/talk/p2p/base/session.h b/talk/p2p/base/session.h
index cb3c1fc..b57468b 100644
--- a/talk/p2p/base/session.h
+++ b/talk/p2p/base/session.h
@@ -76,17 +76,29 @@
// initiate, and for speculatively connecting channels. Previously, a
// session had one ChannelMap and transport. Now, with multiple
// transports per session, we need multiple ChannelMaps as well.
+
+typedef std::map<std::string, TransportChannelProxy*> ChannelMap;
+
class TransportProxy {
public:
- TransportProxy(const std::string& content_name, Transport* transport)
- : content_name_(content_name),
+ TransportProxy(
+ const std::string& sid,
+ const std::string& content_name,
+ Transport* transport)
+ : sid_(sid),
+ content_name_(content_name),
transport_(transport),
+ owner_(true),
state_(STATE_INIT),
sent_candidates_(false) {}
~TransportProxy();
std::string content_name() const { return content_name_; }
Transport* impl() const { return transport_; }
+ // TransportProxy can contain a pointer to Transport for which it's not the
+ // actual owner. In that case it shouldn't try to delete Transport object.
+ // TODO - Remove this hack when ref count support is available.
+ void SetImplementation(Transport* impl, bool owner);
std::string type() const;
bool negotiated() const { return state_ == STATE_NEGOTIATED; }
const Candidates& sent_candidates() const { return sent_candidates_; }
@@ -102,6 +114,8 @@
void ClearUnsentCandidates() { unsent_candidates_.clear(); }
void SpeculativelyConnectChannels();
void CompleteNegotiation();
+ void CopyTransportProxyChannels(TransportProxy* proxy);
+ const ChannelMap& channels() { return channels_; }
private:
enum TransportState {
@@ -110,15 +124,16 @@
STATE_NEGOTIATED
};
- typedef std::map<std::string, TransportChannelProxy*> ChannelMap;
-
TransportChannelProxy* GetProxy(const std::string& name);
+ void ReplaceImpl(TransportChannelProxy* channel_proxy, size_t index);
TransportChannelImpl* GetOrCreateImpl(const std::string& name,
const std::string& content_type);
void SetProxyImpl(const std::string& name, TransportChannelProxy* proxy);
+ std::string sid_;
std::string content_name_;
Transport* transport_;
+ bool owner_;
TransportState state_;
ChannelMap channels_;
Candidates sent_candidates_;
@@ -231,12 +246,12 @@
// Returns the current state of the session. See the enum above for details.
// Each time the state changes, we will fire this signal.
State state() const { return state_; }
- sigslot::signal2<BaseSession *, State> SignalState;
+ sigslot::signal2<BaseSession* , State> SignalState;
// Returns the last error in the session. See the enum above for details.
// Each time the an error occurs, we will fire this signal.
Error error() const { return error_; }
- sigslot::signal2<BaseSession *, Error> SignalError;
+ sigslot::signal2<BaseSession* , Error> SignalError;
// Updates the state, signaling if necessary.
virtual void SetState(State state);
@@ -244,8 +259,10 @@
// Updates the error state, signaling if necessary.
virtual void SetError(Error error);
- // Fired when the remote description is updated.
- sigslot::signal1<BaseSession *> SignalRemoteDescriptionUpdate;
+ // Fired when the remote description is updated, with the updated
+ // contents.
+ sigslot::signal2<BaseSession* , const ContentInfos&>
+ SignalRemoteDescriptionUpdate;
// Returns the transport that has been negotiated or NULL if
// negotiation is still in progress.
@@ -270,6 +287,7 @@
// Send when doing so.
virtual void DestroyChannel(const std::string& content_name,
const std::string& channel_name);
+
protected:
const TransportMap& transport_proxies() const { return transports_; }
// Get a TransportProxy by content_name or transport. NULL if not found.
@@ -283,6 +301,9 @@
void OnSignalingReady();
void SpeculativelyConnectAllTransportChannels();
+ // This method will mux transport channels by content_name.
+ // First content is used for muxing.
+ bool MaybeEnableMuxingSupport();
// Called when a transport requests signaling.
virtual void OnTransportRequestSignaling(Transport* transport) {
@@ -325,10 +346,19 @@
virtual void OnMessage(talk_base::Message *pmsg);
protected:
-// private:
State state_;
Error error_;
+
private:
+ // This method will check GroupInfo in local and remote SessionDescriptions.
+ bool ContentsGrouped();
+ // This method will delete the Transport and TransportChannelImpl's and
+ // replace those with the selected Transport objects. Selection is done
+ // based on the content_name and in this case first MediaContent information
+ // is used for mux.
+ void SetSelectedProxy(const std::string& content_name,
+ const ContentGroup* muxed_group);
+
talk_base::Thread* signaling_thread_;
talk_base::Thread* worker_thread_;
PortAllocator* port_allocator_;
@@ -511,7 +541,7 @@
// sending of each message. When messages are received by the other client,
// they should be handed to OnIncomingMessage.
// (These are called only by SessionManager.)
- sigslot::signal2<Session *, const buzz::XmlElement*> SignalOutgoingMessage;
+ sigslot::signal2<Session* , const buzz::XmlElement*> SignalOutgoingMessage;
void OnIncomingMessage(const SessionMessage& msg);
void OnIncomingResponse(const buzz::XmlElement* orig_stanza,
@@ -539,7 +569,7 @@
bool OnTerminateMessage(const SessionMessage& msg, MessageError* error);
bool OnTransportInfoMessage(const SessionMessage& msg, MessageError* error);
bool OnTransportAcceptMessage(const SessionMessage& msg, MessageError* error);
- bool OnUpdateMessage(const SessionMessage& msg, MessageError* error);
+ bool OnDescriptionInfoMessage(const SessionMessage& msg, MessageError* error);
bool OnRedirectError(const SessionRedirect& redirect, SessionError* error);
// Verifies that we are in the appropriate state to receive this message.
diff --git a/talk/p2p/base/session_unittest.cc b/talk/p2p/base/session_unittest.cc
new file mode 100644
index 0000000..aec4986
--- /dev/null
+++ b/talk/p2p/base/session_unittest.cc
@@ -0,0 +1,2231 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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 <cstring>
+#include <sstream>
+#include <deque>
+#include <map>
+
+#include "talk/base/basicpacketsocketfactory.h"
+#include "talk/base/common.h"
+#include "talk/base/gunit.h"
+#include "talk/base/helpers.h"
+#include "talk/base/host.h"
+#include "talk/base/logging.h"
+#include "talk/base/natserver.h"
+#include "talk/base/natsocketfactory.h"
+#include "talk/base/stringencode.h"
+#include "talk/p2p/base/constants.h"
+#include "talk/p2p/base/parsing.h"
+#include "talk/p2p/base/portallocator.h"
+#include "talk/p2p/base/p2ptransport.h"
+#include "talk/p2p/base/relayport.h"
+#include "talk/p2p/base/relayserver.h"
+#include "talk/p2p/base/session.h"
+#include "talk/p2p/base/sessionclient.h"
+#include "talk/p2p/base/sessionmanager.h"
+#include "talk/p2p/base/stunport.h"
+#include "talk/p2p/base/stunserver.h"
+#include "talk/p2p/base/transportchannel.h"
+#include "talk/p2p/base/transportchannelproxy.h"
+#include "talk/p2p/base/udpport.h"
+#include "talk/xmpp/constants.h"
+
+using cricket::SignalingProtocol;
+using cricket::PROTOCOL_HYBRID;
+using cricket::PROTOCOL_JINGLE;
+using cricket::PROTOCOL_GINGLE;
+
+static const std::string kInitiator = "init@init.com";
+static const std::string kResponder = "resp@resp.com";
+// Expected from test random number generator.
+static const std::string kSessionId = "2154761789";
+// TODO: When we need to test more than one transport type,
+// allow this to be injected like the content types are.
+static const std::string kTransportType = "http://www.google.com/transport/p2p";
+
+// Controls how long we wait for a session to send messages that we
+// expect, in milliseconds. We put it high to avoid flaky tests.
+static const int kEventTimeout = 5000;
+
+static const int kNumPorts = 2;
+static const int kPort0 = 28653;
+static const int kPortStep = 5;
+
+static const std::string kNotifyNick1 = "derekcheng_google.com^59422C27";
+static const std::string kNotifyNick2 = "someoneelses_google.com^7abd6a7a20";
+static const uint32 kNotifyAudioSsrc1 = 2625839801U;
+static const uint32 kNotifyAudioSsrc2 = 2529430427U;
+static const uint32 kNotifyVideoSsrc1 = 3;
+static const uint32 kNotifyVideoSsrc2 = 2;
+
+static const std::string kViewRequestNick = "param_google.com^16A3CDBE";
+static const uint32 kViewRequestSsrc = 4;
+static const int kViewRequestWidth = 320;
+static const int kViewRequestHeight = 200;
+static const int kViewRequestFrameRate = 15;
+
+int GetPort(int port_index) {
+ return kPort0 + (port_index * kPortStep);
+}
+
+std::string GetPortString(int port_index) {
+ return talk_base::ToString(GetPort(port_index));
+}
+
+// Only works for port_index < 10, which is fine for our purposes.
+std::string GetUsername(int port_index) {
+ return "username" + std::string(8, talk_base::ToString(port_index)[0]);
+}
+
+// Only works for port_index < 10, which is fine for our purposes.
+std::string GetPassword(int port_index) {
+ return "password" + std::string(8, talk_base::ToString(port_index)[0]);
+}
+
+std::string IqAck(const std::string& id,
+ const std::string& from,
+ const std::string& to) {
+ return "<cli:iq"
+ " to=\"" + to + "\""
+ " id=\"" + id + "\""
+ " type=\"result\""
+ " from=\"" + from + "\""
+ " xmlns:cli=\"jabber:client\""
+ "/>";
+}
+
+std::string IqSet(const std::string& id,
+ const std::string& from,
+ const std::string& to,
+ const std::string& content) {
+ return "<cli:iq"
+ " to=\"" + to + "\""
+ " type=\"set\""
+ " from=\"" + from + "\""
+ " id=\"" + id + "\""
+ " xmlns:cli=\"jabber:client\""
+ ">"
+ + content +
+ "</cli:iq>";
+}
+
+std::string IqError(const std::string& id,
+ const std::string& from,
+ const std::string& to,
+ const std::string& content) {
+ return "<cli:error"
+ " to=\"" + to + "\""
+ " type=\"error\""
+ " from=\"" + from + "\""
+ " id=\"" + id + "\""
+ " xmlns:cli=\"jabber:client\""
+ ">"
+ + content +
+ "</cli:error>";
+}
+
+std::string GingleSessionXml(const std::string& type,
+ const std::string& content) {
+ return "<session"
+ " xmlns=\"http://www.google.com/session\""
+ " type=\"" + type + "\""
+ " id=\"" + kSessionId + "\""
+ " initiator=\"" + kInitiator + "\""
+ ">"
+ + content +
+ "</session>";
+}
+
+std::string GingleDescriptionXml(const std::string& content_type) {
+ return "<description"
+ " xmlns=\"" + content_type + "\""
+ "/>";
+}
+
+std::string P2pCandidateXml(const std::string& name, int port_index) {
+ return "<candidate"
+ " name=\"" + name + "\""
+ " address=\"127.0.0.1\""
+ " port=\"" + GetPortString(port_index) + "\""
+ " preference=\"1\""
+ " username=\"" + GetUsername(port_index) + "\""
+ " protocol=\"udp\""
+ " generation=\"0\""
+ " password=\"" + GetPassword(port_index) + "\""
+ " type=\"local\""
+ " network=\"network\""
+ "/>";
+}
+
+std::string JingleActionXml(const std::string& action,
+ const std::string& content) {
+ return "<jingle"
+ " xmlns=\"urn:xmpp:jingle:1\""
+ " action=\"" + action + "\""
+ " sid=\"" + kSessionId + "\""
+ ">"
+ + content +
+ "</jingle>";
+}
+
+std::string JingleInitiateActionXml(const std::string& content) {
+ return "<jingle"
+ " xmlns=\"urn:xmpp:jingle:1\""
+ " action=\"session-initiate\""
+ " sid=\"" + kSessionId + "\""
+ " initiator=\"" + kInitiator + "\""
+ ">"
+ + content +
+ "</jingle>";
+}
+
+std::string JingleEmptyContentXml(const std::string& content_name,
+ const std::string& content_type,
+ const std::string& transport_type) {
+ return "<content"
+ " name=\"" + content_name + "\""
+ " creator=\"initiator\""
+ ">"
+ "<description"
+ " xmlns=\"" + content_type + "\""
+ "/>"
+ "<transport"
+ " xmlns=\"" + transport_type + "\""
+ "/>"
+ "</content>";
+}
+
+std::string JingleContentXml(const std::string& content_name,
+ const std::string& content_type,
+ const std::string& transport_type,
+ const std::string& transport_main) {
+ std::string transport = transport_type.empty() ? "" :
+ "<transport"
+ " xmlns=\"" + transport_type + "\""
+ ">"
+ + transport_main +
+ "</transport>";
+
+ return"<content"
+ " name=\"" + content_name + "\""
+ " creator=\"initiator\""
+ ">"
+ "<description"
+ " xmlns=\"" + content_type + "\""
+ "/>"
+ + transport +
+ "</content>";
+}
+
+std::string JingleTransportContentXml(const std::string& content_name,
+ const std::string& transport_type,
+ const std::string& content) {
+ return "<content"
+ " name=\"" + content_name + "\""
+ " creator=\"initiator\""
+ ">"
+ "<transport"
+ " xmlns=\"" + transport_type + "\""
+ ">"
+ + content +
+ "</transport>"
+ "</content>";
+}
+
+std::string GingleInitiateXml(const std::string& content_type) {
+ return GingleSessionXml(
+ "initiate",
+ GingleDescriptionXml(content_type));
+}
+
+std::string JingleInitiateXml(const std::string& content_name_a,
+ const std::string& content_type_a,
+ const std::string& content_name_b,
+ const std::string& content_type_b) {
+ if (content_name_b.empty()) {
+ return JingleInitiateActionXml(
+ JingleEmptyContentXml(
+ content_name_a, content_type_a, kTransportType));
+ } else {
+ return JingleInitiateActionXml(
+ JingleEmptyContentXml(
+ content_name_a, content_type_a, kTransportType) +
+ JingleEmptyContentXml(
+ content_name_b, content_type_b, kTransportType));
+ }
+}
+
+std::string GingleAcceptXml(const std::string& content_type) {
+ return GingleSessionXml(
+ "accept",
+ GingleDescriptionXml(content_type));
+}
+
+std::string JingleAcceptXml(const std::string& content_name_a,
+ const std::string& content_type_a,
+ const std::string& content_name_b,
+ const std::string& content_type_b) {
+ if (content_name_b.empty()) {
+ return JingleActionXml(
+ "session-accept",
+ JingleEmptyContentXml(
+ content_name_a, content_type_a, kTransportType));
+ } else {
+ return JingleActionXml(
+ "session-accept",
+ JingleEmptyContentXml(
+ content_name_a, content_type_a, kTransportType) +
+ JingleEmptyContentXml(
+ content_name_b, content_type_b, kTransportType));
+ }
+}
+
+std::string Gingle2CandidatesXml(const std::string& channel_name,
+ int port_index0,
+ int port_index1) {
+ return GingleSessionXml(
+ "candidates",
+ P2pCandidateXml(channel_name, port_index0) +
+ P2pCandidateXml(channel_name, port_index1));
+}
+
+std::string Gingle4CandidatesXml(const std::string& channel_name_a,
+ int port_index0,
+ int port_index1,
+ const std::string& channel_name_b,
+ int port_index2,
+ int port_index3) {
+ return GingleSessionXml(
+ "candidates",
+ P2pCandidateXml(channel_name_a, port_index0) +
+ P2pCandidateXml(channel_name_a, port_index1) +
+ P2pCandidateXml(channel_name_b, port_index2) +
+ P2pCandidateXml(channel_name_b, port_index3));
+}
+
+std::string Jingle2TransportInfoXml(const std::string& content_name,
+ const std::string& channel_name,
+ int port_index0,
+ int port_index1) {
+ return JingleActionXml(
+ "transport-info",
+ JingleTransportContentXml(
+ content_name, kTransportType,
+ P2pCandidateXml(channel_name, port_index0) +
+ P2pCandidateXml(channel_name, port_index1)));
+}
+
+std::string Jingle4TransportInfoXml(const std::string& content_name,
+ const std::string& channel_name_a,
+ int port_index0,
+ int port_index1,
+ const std::string& channel_name_b,
+ int port_index2,
+ int port_index3) {
+ return JingleActionXml(
+ "transport-info",
+ JingleTransportContentXml(
+ content_name, kTransportType,
+ P2pCandidateXml(channel_name_a, port_index0) +
+ P2pCandidateXml(channel_name_a, port_index1) +
+ P2pCandidateXml(channel_name_b, port_index2) +
+ P2pCandidateXml(channel_name_b, port_index3)));
+}
+
+std::string JingleDescriptionInfoXml(const std::string& content_name,
+ const std::string& content_type) {
+ return JingleActionXml(
+ "description-info",
+ JingleContentXml(content_name, content_type, "", ""));
+}
+
+std::string GingleRejectXml(const std::string& reason) {
+ return GingleSessionXml(
+ "reject",
+ "<" + reason + "/>");
+}
+
+std::string JingleTerminateXml(const std::string& reason) {
+ return JingleActionXml(
+ "session-terminate",
+ "<reason><" + reason + "/></reason>");
+}
+
+std::string GingleTerminateXml(const std::string& reason) {
+ return GingleSessionXml(
+ "terminate",
+ "<" + reason + "/>");
+}
+
+std::string GingleRedirectXml(const std::string& intitiate,
+ const std::string& target) {
+ return intitiate +
+ "<error code=\"302\" type=\"modify\">"
+ "<redirect xmlns=\"http://www.google.com/session\">"
+ "xmpp:" + target +
+ "</redirect>"
+ "</error>";
+}
+
+std::string JingleRedirectXml(const std::string& intitiate,
+ const std::string& target) {
+ return intitiate +
+ "<error code=\"302\" type=\"modify\">"
+ "<redirect xmlns=\"urn:ietf:params:xml:ns:xmpp-stanzas\">"
+ "xmpp:" + target +
+ "</redirect>"
+ "</error>";
+}
+
+std::string InitiateXml(SignalingProtocol protocol,
+ const std::string& gingle_content_type,
+ const std::string& content_name_a,
+ const std::string& content_type_a,
+ const std::string& content_name_b,
+ const std::string& content_type_b) {
+ switch (protocol) {
+ case PROTOCOL_JINGLE:
+ return JingleInitiateXml(content_name_a, content_type_a,
+ content_name_b, content_type_b);
+ case PROTOCOL_GINGLE:
+ return GingleInitiateXml(gingle_content_type);
+ case PROTOCOL_HYBRID:
+ return JingleInitiateXml(content_name_a, content_type_a,
+ content_name_b, content_type_b) +
+ GingleInitiateXml(gingle_content_type);
+ }
+ return "";
+}
+
+std::string InitiateXml(SignalingProtocol protocol,
+ const std::string& content_name,
+ const std::string& content_type) {
+ return InitiateXml(protocol,
+ content_type,
+ content_name, content_type,
+ "", "");
+}
+
+std::string AcceptXml(SignalingProtocol protocol,
+ const std::string& gingle_content_type,
+ const std::string& content_name_a,
+ const std::string& content_type_a,
+ const std::string& content_name_b,
+ const std::string& content_type_b) {
+ switch (protocol) {
+ case PROTOCOL_JINGLE:
+ return JingleAcceptXml(content_name_a, content_type_a,
+ content_name_b, content_type_b);
+ case PROTOCOL_GINGLE:
+ return GingleAcceptXml(gingle_content_type);
+ case PROTOCOL_HYBRID:
+ return
+ JingleAcceptXml(content_name_a, content_type_a,
+ content_name_b, content_type_b) +
+ GingleAcceptXml(gingle_content_type);
+ }
+ return "";
+}
+
+
+std::string AcceptXml(SignalingProtocol protocol,
+ const std::string& content_name,
+ const std::string& content_type) {
+ return AcceptXml(protocol,
+ content_type,
+ content_name, content_type,
+ "", "");
+}
+
+std::string TransportInfo2Xml(SignalingProtocol protocol,
+ const std::string& content_name,
+ const std::string& channel_name,
+ int port_index0,
+ int port_index1) {
+ switch (protocol) {
+ case PROTOCOL_JINGLE:
+ return Jingle2TransportInfoXml(
+ content_name,
+ channel_name, port_index0, port_index1);
+ case PROTOCOL_GINGLE:
+ return Gingle2CandidatesXml(
+ channel_name, port_index0, port_index1);
+ case PROTOCOL_HYBRID:
+ return
+ Jingle2TransportInfoXml(
+ content_name,
+ channel_name, port_index0, port_index1) +
+ Gingle2CandidatesXml(
+ channel_name, port_index0, port_index1);
+ }
+ return "";
+}
+
+std::string TransportInfo4Xml(SignalingProtocol protocol,
+ const std::string& content_name,
+ const std::string& channel_name_a,
+ int port_index0,
+ int port_index1,
+ const std::string& channel_name_b,
+ int port_index2,
+ int port_index3) {
+ switch (protocol) {
+ case PROTOCOL_JINGLE:
+ return Jingle4TransportInfoXml(
+ content_name,
+ channel_name_a, port_index0, port_index1,
+ channel_name_b, port_index2, port_index3);
+ case PROTOCOL_GINGLE:
+ return Gingle4CandidatesXml(
+ channel_name_a, port_index0, port_index1,
+ channel_name_b, port_index2, port_index3);
+ case PROTOCOL_HYBRID:
+ return
+ Jingle4TransportInfoXml(
+ content_name,
+ channel_name_a, port_index0, port_index1,
+ channel_name_b, port_index2, port_index3) +
+ Gingle4CandidatesXml(
+ channel_name_a, port_index0, port_index1,
+ channel_name_b, port_index2, port_index3);
+ }
+ return "";
+}
+
+std::string RejectXml(SignalingProtocol protocol,
+ const std::string& reason) {
+ switch (protocol) {
+ case PROTOCOL_JINGLE:
+ return JingleTerminateXml(reason);
+ case PROTOCOL_GINGLE:
+ return GingleRejectXml(reason);
+ case PROTOCOL_HYBRID:
+ return JingleTerminateXml(reason) +
+ GingleRejectXml(reason);
+ }
+ return "";
+}
+
+std::string TerminateXml(SignalingProtocol protocol,
+ const std::string& reason) {
+ switch (protocol) {
+ case PROTOCOL_JINGLE:
+ return JingleTerminateXml(reason);
+ case PROTOCOL_GINGLE:
+ return GingleTerminateXml(reason);
+ case PROTOCOL_HYBRID:
+ return JingleTerminateXml(reason) +
+ GingleTerminateXml(reason);
+ }
+ return "";
+}
+
+std::string RedirectXml(SignalingProtocol protocol,
+ const std::string& initiate,
+ const std::string& target) {
+ switch (protocol) {
+ case PROTOCOL_JINGLE:
+ return JingleRedirectXml(initiate, target);
+ case PROTOCOL_GINGLE:
+ return GingleRedirectXml(initiate, target);
+ }
+ return "";
+}
+
+// TODO: Break out and join with fakeportallocator.h
+class TestPortAllocatorSession : public cricket::PortAllocatorSession {
+ public:
+ TestPortAllocatorSession(const std::string& name,
+ const std::string& session_type,
+ const int port_offset)
+ : PortAllocatorSession(name, session_type, 0),
+ port_offset_(port_offset),
+ ports_(kNumPorts),
+ address_("127.0.0.1", 0),
+ network_("network", "unittest", address_.ipaddr()),
+ socket_factory_(talk_base::Thread::Current()),
+ running_(false),
+ port_(28653) {
+ }
+
+ ~TestPortAllocatorSession() {
+ for (size_t i = 0; i < ports_.size(); i++)
+ delete ports_[i];
+ }
+
+ virtual void GetInitialPorts() {
+ for (int i = 0; i < kNumPorts; i++) {
+ int index = port_offset_ + i;
+ ports_[i] = cricket::UDPPort::Create(
+ talk_base::Thread::Current(), &socket_factory_,
+ &network_, address_.ipaddr(), GetPort(index), GetPort(index));
+ ports_[i]->set_username_fragment(GetUsername(index));
+ ports_[i]->set_password(GetPassword(index));
+ AddPort(ports_[i]);
+ }
+ }
+
+ virtual void StartGetAllPorts() { running_ = true; }
+ virtual void StopGetAllPorts() { running_ = false; }
+ virtual bool IsGettingAllPorts() { return running_; }
+
+ void AddPort(cricket::Port* port) {
+ port->set_name(name_);
+ port->set_preference(1.0);
+ port->set_generation(0);
+ port->SignalDestroyed.connect(
+ this, &TestPortAllocatorSession::OnPortDestroyed);
+ port->SignalAddressReady.connect(
+ this, &TestPortAllocatorSession::OnAddressReady);
+ port->PrepareAddress();
+ SignalPortReady(this, port);
+ }
+
+ void OnPortDestroyed(cricket::Port* port) {
+ for (size_t i = 0; i < ports_.size(); i++) {
+ if (ports_[i] == port)
+ ports_[i] = NULL;
+ }
+ }
+
+ void OnAddressReady(cricket::Port* port) {
+ SignalCandidatesReady(this, port->candidates());
+ }
+
+ private:
+ int port_offset_;
+ std::vector<cricket::Port*> ports_;
+ talk_base::SocketAddress address_;
+ talk_base::Network network_;
+ talk_base::BasicPacketSocketFactory socket_factory_;
+ bool running_;
+ int port_;
+};
+
+class TestPortAllocator : public cricket::PortAllocator {
+ public:
+ TestPortAllocator() : port_offset_(0) {}
+
+ virtual cricket::PortAllocatorSession*
+ CreateSession(const std::string &name,
+ const std::string &content_type) {
+ port_offset_ += 2;
+ return new TestPortAllocatorSession(name, content_type, port_offset_ - 2);
+ }
+
+ int port_offset_;
+};
+
+class TestContentDescription : public cricket::ContentDescription {
+ public:
+ explicit TestContentDescription(const std::string& gingle_content_type,
+ const std::string& content_type)
+ : gingle_content_type(gingle_content_type),
+ content_type(content_type) {
+ }
+
+ std::string gingle_content_type;
+ std::string content_type;
+};
+
+cricket::SessionDescription* NewTestSessionDescription(
+ const std::string gingle_content_type,
+ const std::string& content_name_a, const std::string& content_type_a,
+ const std::string& content_name_b, const std::string& content_type_b) {
+
+ cricket::SessionDescription* offer = new cricket::SessionDescription();
+ offer->AddContent(content_name_a, content_type_a,
+ new TestContentDescription(gingle_content_type,
+ content_type_a));
+ if (content_name_a != content_name_b) {
+ offer->AddContent(content_name_b, content_type_b,
+ new TestContentDescription(gingle_content_type,
+ content_type_b));
+ }
+ return offer;
+}
+
+cricket::SessionDescription* NewTestSessionDescription(
+ const std::string& content_name, const std::string& content_type) {
+
+ cricket::SessionDescription* offer = new cricket::SessionDescription();
+ offer->AddContent(content_name, content_type,
+ new TestContentDescription(content_type,
+ content_type));
+ return offer;
+}
+
+struct TestSessionClient: public cricket::SessionClient,
+ public sigslot::has_slots<> {
+ public:
+ TestSessionClient() {
+ }
+
+ ~TestSessionClient() {
+ }
+
+ virtual bool ParseContent(SignalingProtocol protocol,
+ const buzz::XmlElement* elem,
+ const cricket::ContentDescription** content,
+ cricket::ParseError* error) {
+ std::string content_type;
+ std::string gingle_content_type;
+ if (protocol == PROTOCOL_GINGLE) {
+ gingle_content_type = elem->Name().Namespace();
+ } else {
+ content_type = elem->Name().Namespace();
+ }
+
+ *content = new TestContentDescription(gingle_content_type, content_type);
+ return true;
+ }
+
+ virtual bool WriteContent(SignalingProtocol protocol,
+ const cricket::ContentDescription* untyped_content,
+ buzz::XmlElement** elem,
+ cricket::WriteError* error) {
+ const TestContentDescription* content =
+ static_cast<const TestContentDescription*>(untyped_content);
+ std::string content_type = (protocol == PROTOCOL_GINGLE ?
+ content->gingle_content_type :
+ content->content_type);
+ *elem = new buzz::XmlElement(
+ buzz::QName(content_type, "description"), true);
+ return true;
+ }
+
+ void OnSessionCreate(cricket::Session* session, bool initiate) {
+ }
+
+ void OnSessionDestroy(cricket::Session* session) {
+ }
+};
+
+struct ChannelHandler : sigslot::has_slots<> {
+ explicit ChannelHandler(cricket::TransportChannel* p)
+ : channel(p), last_readable(false), last_writable(false), data_count(0),
+ last_size(0) {
+ p->SignalReadableState.connect(this, &ChannelHandler::OnReadableState);
+ p->SignalWritableState.connect(this, &ChannelHandler::OnWritableState);
+ p->SignalReadPacket.connect(this, &ChannelHandler::OnReadPacket);
+ }
+
+ bool writable() const {
+ return last_writable && channel->writable();
+ }
+
+ bool readable() const {
+ return last_readable && channel->readable();
+ }
+
+ void OnReadableState(cricket::TransportChannel* p) {
+ EXPECT_EQ(channel, p);
+ last_readable = channel->readable();
+ }
+
+ void OnWritableState(cricket::TransportChannel* p) {
+ EXPECT_EQ(channel, p);
+ last_writable = channel->writable();
+ }
+
+ void OnReadPacket(cricket::TransportChannel* p, const char* buf,
+ size_t size) {
+ EXPECT_EQ(channel, p);
+ EXPECT_LE(size, sizeof(last_data));
+ data_count += 1;
+ last_size = size;
+ std::memcpy(last_data, buf, size);
+ }
+
+ void Send(const char* data, size_t size) {
+ int result = channel->SendPacket(data, size);
+ EXPECT_EQ(static_cast<int>(size), result);
+ }
+
+ cricket::TransportChannel* channel;
+ bool last_readable, last_writable;
+ int data_count;
+ char last_data[4096];
+ size_t last_size;
+};
+
+void PrintStanza(const std::string& message,
+ const buzz::XmlElement* stanza) {
+ printf("%s: %s\n", message.c_str(), stanza->Str().c_str());
+}
+
+class TestClient : public sigslot::has_slots<> {
+ public:
+ TestClient(cricket::PortAllocator* port_allocator,
+ int* next_message_id,
+ const std::string& local_name,
+ SignalingProtocol start_protocol,
+ const std::string& content_type,
+ const std::string& content_name_a,
+ const std::string& channel_name_a,
+ const std::string& content_name_b,
+ const std::string& channel_name_b) {
+ Construct(port_allocator, next_message_id, local_name, start_protocol,
+ content_type, content_name_a, channel_name_a, std::string(""),
+ content_name_b, channel_name_b, std::string(""));
+ }
+
+ TestClient(cricket::PortAllocator* port_allocator,
+ int* next_message_id,
+ const std::string& local_name,
+ SignalingProtocol start_protocol,
+ const std::string& content_type,
+ const std::string& content_name_a,
+ const std::string& channel_name_a,
+ const std::string& channel_name_aa,
+ const std::string& content_name_b,
+ const std::string& channel_name_b,
+ const std::string& channel_name_bb) {
+ Construct(port_allocator, next_message_id, local_name, start_protocol,
+ content_type, content_name_a, channel_name_a, channel_name_aa,
+ content_name_b, channel_name_b, channel_name_bb);
+ }
+
+ ~TestClient() {
+ if (session) {
+ session_manager->DestroySession(session);
+ EXPECT_EQ(1U, session_destroyed_count);
+ }
+ delete session_manager;
+ delete client;
+ }
+
+ void Construct(cricket::PortAllocator* pa,
+ int* message_id,
+ const std::string& lname,
+ SignalingProtocol protocol,
+ const std::string& cont_type,
+ const std::string& cont_name_a,
+ const std::string& chan_name_a,
+ const std::string& chan_name_aa,
+ const std::string& cont_name_b,
+ const std::string& chan_name_b,
+ const std::string& chan_name_bb) {
+ port_allocator_ = pa;
+ next_message_id = message_id;
+ local_name = lname;
+ start_protocol = protocol;
+ content_type = cont_type;
+ content_name_a = cont_name_a;
+ channel_name_a = chan_name_a;
+ channel_name_aa = chan_name_aa;
+ content_name_b = cont_name_b;
+ channel_name_b = chan_name_b;
+ channel_name_bb = chan_name_bb;
+ session_created_count = 0;
+ session_destroyed_count = 0;
+ session_remote_description_update_count = 0;
+ last_expected_sent_stanza = NULL;
+ session = NULL;
+ last_session_state = cricket::BaseSession::STATE_INIT;
+ chan_a = NULL;
+ chan_b = NULL;
+ blow_up_on_error = true;
+ error_count = 0;
+ if (!chan_name_aa.empty() || !chan_name_bb.empty()) {
+ chan_aa = NULL;
+ chan_bb = NULL;
+ }
+
+ session_manager = new cricket::SessionManager(port_allocator_);
+ session_manager->SignalSessionCreate.connect(
+ this, &TestClient::OnSessionCreate);
+ session_manager->SignalSessionDestroy.connect(
+ this, &TestClient::OnSessionDestroy);
+ session_manager->SignalOutgoingMessage.connect(
+ this, &TestClient::OnOutgoingMessage);
+
+ client = new TestSessionClient();
+ session_manager->AddClient(content_type, client);
+ EXPECT_EQ(client, session_manager->GetClient(content_type));
+ }
+
+ uint32 sent_stanza_count() const {
+ return sent_stanzas.size();
+ }
+
+ const buzz::XmlElement* stanza() const {
+ return last_expected_sent_stanza;
+ }
+
+ cricket::BaseSession::State session_state() const {
+ EXPECT_EQ(last_session_state, session->state());
+ return session->state();
+ }
+
+ void SetSessionState(cricket::BaseSession::State state) {
+ session->SetState(state);
+ EXPECT_EQ_WAIT(last_session_state, session->state(), kEventTimeout);
+ }
+
+ void CreateSession() {
+ session_manager->CreateSession(local_name, content_type);
+ }
+
+ void DeliverStanza(const buzz::XmlElement* stanza) {
+ session_manager->OnIncomingMessage(stanza);
+ }
+
+ void DeliverStanza(const std::string& str) {
+ buzz::XmlElement* stanza = buzz::XmlElement::ForStr(str);
+ session_manager->OnIncomingMessage(stanza);
+ delete stanza;
+ }
+
+ void DeliverAckToLastStanza() {
+ const buzz::XmlElement* orig_stanza = stanza();
+ const buzz::XmlElement* response_stanza =
+ buzz::XmlElement::ForStr(IqAck(orig_stanza->Attr(buzz::QN_IQ), "", ""));
+ session_manager->OnIncomingResponse(orig_stanza, response_stanza);
+ delete response_stanza;
+ }
+
+ void ExpectSentStanza(const std::string& expected) {
+ EXPECT_TRUE(!sent_stanzas.empty()) <<
+ "Found no stanza when expected " << expected;
+
+ last_expected_sent_stanza = sent_stanzas.front();
+ sent_stanzas.pop_front();
+
+ std::string actual = last_expected_sent_stanza->Str();
+ EXPECT_EQ(expected, actual);
+ }
+
+ void SkipUnsentStanza() {
+ GetNextOutgoingMessageID();
+ }
+
+ bool HasTransport(const std::string& content_name) const {
+ ASSERT(session != NULL);
+ const cricket::Transport* transport = session->GetTransport(content_name);
+ return transport != NULL && (kTransportType == transport->type());
+ }
+
+ bool HasChannel(const std::string& content_name,
+ const std::string& channel_name) const {
+ ASSERT(session != NULL);
+ const cricket::TransportChannel* channel =
+ session->GetChannel(content_name, channel_name);
+ return channel != NULL && (channel_name == channel->name());
+ }
+
+ cricket::TransportChannel* GetChannel(const std::string& content_name,
+ const std::string& channel_name) const {
+ ASSERT(session != NULL);
+ return session->GetChannel(content_name, channel_name);
+ }
+
+ void OnSessionCreate(cricket::Session* created_session, bool initiate) {
+ session_created_count += 1;
+
+ session = created_session;
+ session->set_current_protocol(start_protocol);
+ session->set_allow_local_ips(true);
+ session->SignalState.connect(this, &TestClient::OnSessionState);
+ session->SignalError.connect(this, &TestClient::OnSessionError);
+ session->SignalRemoteDescriptionUpdate.connect(
+ this, &TestClient::OnSessionRemoteDescriptionUpdate);
+
+ CreateChannels();
+ }
+
+ void OnSessionDestroy(cricket::Session *session) {
+ session_destroyed_count += 1;
+ }
+
+ void OnSessionState(cricket::BaseSession* session,
+ cricket::BaseSession::State state) {
+ // EXPECT_EQ does not allow use of this, hence the tmp variable.
+ cricket::BaseSession* tmp = this->session;
+ EXPECT_EQ(tmp, session);
+ last_session_state = state;
+ }
+
+ void OnSessionError(cricket::BaseSession* session,
+ cricket::BaseSession::Error error) {
+ // EXPECT_EQ does not allow use of this, hence the tmp variable.
+ cricket::BaseSession* tmp = this->session;
+ EXPECT_EQ(tmp, session);
+ if (blow_up_on_error) {
+ EXPECT_TRUE(false);
+ } else {
+ error_count++;
+ }
+ }
+
+ void OnSessionRemoteDescriptionUpdate(cricket::BaseSession* session,
+ const cricket::ContentInfos& contents) {
+ session_remote_description_update_count++;
+ }
+
+ void PrepareCandidates() {
+ session_manager->OnSignalingReady();
+ }
+
+ void OnOutgoingMessage(cricket::SessionManager* manager,
+ const buzz::XmlElement* stanza) {
+ buzz::XmlElement* elem = new buzz::XmlElement(*stanza);
+ EXPECT_TRUE(elem->Name() == buzz::QN_IQ);
+ EXPECT_TRUE(elem->HasAttr(buzz::QN_TO));
+ EXPECT_FALSE(elem->HasAttr(buzz::QN_FROM));
+ EXPECT_TRUE(elem->HasAttr(buzz::QN_TYPE));
+ EXPECT_TRUE((elem->Attr(buzz::QN_TYPE) == "set") ||
+ (elem->Attr(buzz::QN_TYPE) == "result") ||
+ (elem->Attr(buzz::QN_TYPE) == "error"));
+
+ elem->SetAttr(buzz::QN_FROM, local_name);
+ if (elem->Attr(buzz::QN_TYPE) == "set") {
+ EXPECT_FALSE(elem->HasAttr(buzz::QN_ID));
+ elem->SetAttr(buzz::QN_ID, GetNextOutgoingMessageID());
+ }
+
+ // Uncommenting this is useful for debugging.
+ // PrintStanza("OutgoingMessage", elem);
+ sent_stanzas.push_back(elem);
+ }
+
+ std::string GetNextOutgoingMessageID() {
+ int message_id = (*next_message_id)++;
+ std::ostringstream ost;
+ ost << message_id;
+ return ost.str();
+ }
+
+ void CreateChannels() {
+ ASSERT(session != NULL);
+ chan_a = new ChannelHandler(
+ session->CreateChannel(content_name_a, channel_name_a));
+ chan_b = new ChannelHandler(
+ session->CreateChannel(content_name_b, channel_name_b));
+ if (!channel_name_aa.empty() && !channel_name_bb.empty()) {
+ chan_aa = new ChannelHandler(
+ session->CreateChannel(content_name_a, channel_name_aa));
+ chan_bb = new ChannelHandler(
+ session->CreateChannel(content_name_b, channel_name_bb));
+ }
+ }
+
+ int* next_message_id;
+ std::string local_name;
+ SignalingProtocol start_protocol;
+ std::string content_type;
+ std::string content_name_a;
+ std::string channel_name_a;
+ std::string channel_name_aa;
+ std::string content_name_b;
+ std::string channel_name_b;
+ std::string channel_name_bb;
+
+ uint32 session_created_count;
+ uint32 session_destroyed_count;
+ uint32 session_remote_description_update_count;
+ std::deque<buzz::XmlElement*> sent_stanzas;
+ buzz::XmlElement* last_expected_sent_stanza;
+
+ cricket::SessionManager* session_manager;
+ TestSessionClient* client;
+ cricket::PortAllocator* port_allocator_;
+ cricket::Session* session;
+ cricket::BaseSession::State last_session_state;
+ ChannelHandler* chan_a;
+ ChannelHandler* chan_aa;
+ ChannelHandler* chan_b;
+ ChannelHandler* chan_bb;
+ bool blow_up_on_error;
+ int error_count;
+};
+
+class SessionTest : public testing::Test {
+ protected:
+ virtual void SetUp() {
+ // Seed needed for each test to satisfy expectations.
+ talk_base::SetRandomTestMode(true);
+ }
+
+ virtual void TearDown() {
+ talk_base::SetRandomTestMode(false);
+ }
+
+ // Tests sending data between two clients, over two channels.
+ void TestSendRecv(ChannelHandler* chan1a,
+ ChannelHandler* chan1b,
+ ChannelHandler* chan2a,
+ ChannelHandler* chan2b) {
+ const char* dat1a = "spamspamspamspamspamspamspambakedbeansspam";
+ const char* dat2a = "mapssnaebdekabmapsmapsmapsmapsmapsmapsmaps";
+ const char* dat1b = "Lobster Thermidor a Crevette with a mornay sauce...";
+ const char* dat2b = "...ecuas yanrom a htiw etteverC a rodimrehT retsboL";
+
+ for (int i = 0; i < 20; i++) {
+ chan1a->Send(dat1a, strlen(dat1a));
+ chan1b->Send(dat1b, strlen(dat1b));
+ chan2a->Send(dat2a, strlen(dat2a));
+ chan2b->Send(dat2b, strlen(dat2b));
+
+ EXPECT_EQ_WAIT(i + 1, chan1a->data_count, kEventTimeout);
+ EXPECT_EQ_WAIT(i + 1, chan1b->data_count, kEventTimeout);
+ EXPECT_EQ_WAIT(i + 1, chan2a->data_count, kEventTimeout);
+ EXPECT_EQ_WAIT(i + 1, chan2b->data_count, kEventTimeout);
+
+ EXPECT_EQ(strlen(dat2a), chan1a->last_size);
+ EXPECT_EQ(strlen(dat2b), chan1b->last_size);
+ EXPECT_EQ(strlen(dat1a), chan2a->last_size);
+ EXPECT_EQ(strlen(dat1b), chan2b->last_size);
+
+ EXPECT_EQ(0, std::memcmp(chan1a->last_data, dat2a,
+ strlen(dat2a)));
+ EXPECT_EQ(0, std::memcmp(chan1b->last_data, dat2b,
+ strlen(dat2b)));
+ EXPECT_EQ(0, std::memcmp(chan2a->last_data, dat1a,
+ strlen(dat1a)));
+ EXPECT_EQ(0, std::memcmp(chan2b->last_data, dat1b,
+ strlen(dat1b)));
+ }
+ }
+
+ // Test an initiate from one client to another, each with
+ // independent initial protocols. Checks for the correct initiates,
+ // candidates, and accept messages, and tests that working network
+ // channels are established.
+ void TestSession(SignalingProtocol initiator_protocol,
+ SignalingProtocol responder_protocol,
+ SignalingProtocol resulting_protocol,
+ const std::string& gingle_content_type,
+ const std::string& content_type,
+ const std::string& content_name_a,
+ const std::string& channel_name_a,
+ const std::string& content_name_b,
+ const std::string& channel_name_b,
+ const std::string& initiate_xml,
+ const std::string& transport_info_a_xml,
+ const std::string& transport_info_b_xml,
+ const std::string& transport_info_reply_a_xml,
+ const std::string& transport_info_reply_b_xml,
+ const std::string& accept_xml) {
+ talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+ new TestPortAllocator());
+ int next_message_id = 0;
+
+ talk_base::scoped_ptr<TestClient> initiator(
+ new TestClient(allocator.get(), &next_message_id,
+ kInitiator, initiator_protocol,
+ content_type,
+ content_name_a, channel_name_a,
+ content_name_b, channel_name_b));
+ talk_base::scoped_ptr<TestClient> responder(
+ new TestClient(allocator.get(), &next_message_id,
+ kResponder, responder_protocol,
+ content_type,
+ content_name_a, channel_name_a,
+ content_name_b, channel_name_b));
+
+ // Create Session and check channels and state.
+ initiator->CreateSession();
+ EXPECT_EQ(1U, initiator->session_created_count);
+ EXPECT_EQ(kSessionId, initiator->session->id());
+ EXPECT_EQ(initiator->session->local_name(), kInitiator);
+ EXPECT_EQ(cricket::BaseSession::STATE_INIT,
+ initiator->session_state());
+
+ EXPECT_TRUE(initiator->HasTransport(content_name_a));
+ EXPECT_TRUE(initiator->HasChannel(content_name_a, channel_name_a));
+ EXPECT_TRUE(initiator->HasTransport(content_name_b));
+ EXPECT_TRUE(initiator->HasChannel(content_name_b, channel_name_b));
+
+ // Initiate and expect initiate message sent.
+ cricket::SessionDescription* offer = NewTestSessionDescription(
+ gingle_content_type,
+ content_name_a, content_type,
+ content_name_b, content_type);
+ EXPECT_TRUE(initiator->session->Initiate(kResponder, offer));
+ EXPECT_EQ(initiator->session->remote_name(), kResponder);
+ EXPECT_EQ(initiator->session->local_description(), offer);
+
+ EXPECT_TRUE_WAIT(initiator->sent_stanza_count() > 0, kEventTimeout);
+ EXPECT_EQ(cricket::BaseSession::STATE_SENTINITIATE,
+ initiator->session_state());
+ initiator->ExpectSentStanza(
+ IqSet("0", kInitiator, kResponder, initiate_xml));
+
+ // Deliver the initiate. Expect ack and session created with
+ // transports.
+ responder->DeliverStanza(initiator->stanza());
+ responder->ExpectSentStanza(
+ IqAck("0", kResponder, kInitiator));
+ EXPECT_EQ(0U, responder->sent_stanza_count());
+
+ EXPECT_EQ(1U, responder->session_created_count);
+ EXPECT_EQ(kSessionId, responder->session->id());
+ EXPECT_EQ(responder->session->local_name(), kResponder);
+ EXPECT_EQ(responder->session->remote_name(), kInitiator);
+ EXPECT_EQ(cricket::BaseSession::STATE_RECEIVEDINITIATE,
+ responder->session_state());
+
+ EXPECT_TRUE(responder->HasTransport(content_name_a));
+ EXPECT_TRUE(responder->HasChannel(content_name_a, channel_name_a));
+ EXPECT_TRUE(responder->HasTransport(content_name_b));
+ EXPECT_TRUE(responder->HasChannel(content_name_b, channel_name_b));
+
+ // Expect transport-info message from initiator.
+ // But don't send candidates until initiate ack is received.
+ initiator->PrepareCandidates();
+ WAIT(initiator->sent_stanza_count() > 0, 100);
+ EXPECT_EQ(0U, initiator->sent_stanza_count());
+ initiator->DeliverAckToLastStanza();
+ EXPECT_TRUE_WAIT(initiator->sent_stanza_count() > 0, kEventTimeout);
+ initiator->ExpectSentStanza(
+ IqSet("1", kInitiator, kResponder, transport_info_a_xml));
+
+ // Deliver transport-info and expect ack.
+ responder->DeliverStanza(initiator->stanza());
+ responder->ExpectSentStanza(
+ IqAck("1", kResponder, kInitiator));
+
+ if (!transport_info_b_xml.empty()) {
+ // Expect second transport-info message from initiator.
+ EXPECT_TRUE_WAIT(initiator->sent_stanza_count() > 0, kEventTimeout);
+ initiator->ExpectSentStanza(
+ IqSet("2", kInitiator, kResponder, transport_info_b_xml));
+ EXPECT_EQ(0U, initiator->sent_stanza_count());
+
+ // Deliver second transport-info message and expect ack.
+ responder->DeliverStanza(initiator->stanza());
+ responder->ExpectSentStanza(
+ IqAck("2", kResponder, kInitiator));
+ } else {
+ EXPECT_EQ(0U, initiator->sent_stanza_count());
+ EXPECT_EQ(0U, responder->sent_stanza_count());
+ initiator->SkipUnsentStanza();
+ }
+
+ // Expect reply transport-info message from responder.
+ responder->PrepareCandidates();
+ EXPECT_TRUE_WAIT(responder->sent_stanza_count() > 0, kEventTimeout);
+ responder->ExpectSentStanza(
+ IqSet("3", kResponder, kInitiator, transport_info_reply_a_xml));
+
+ // Deliver reply transport-info and expect ack.
+ initiator->DeliverStanza(responder->stanza());
+ initiator->ExpectSentStanza(
+ IqAck("3", kInitiator, kResponder));
+
+ if (!transport_info_reply_b_xml.empty()) {
+ // Expect second reply transport-info message from responder.
+ EXPECT_TRUE_WAIT(responder->sent_stanza_count() > 0, kEventTimeout);
+ responder->ExpectSentStanza(
+ IqSet("4", kResponder, kInitiator, transport_info_reply_b_xml));
+ EXPECT_EQ(0U, responder->sent_stanza_count());
+
+ // Deliver second reply transport-info message and expect ack.
+ initiator->DeliverStanza(responder->stanza());
+ initiator->ExpectSentStanza(
+ IqAck("4", kInitiator, kResponder));
+ EXPECT_EQ(0U, initiator->sent_stanza_count());
+ } else {
+ EXPECT_EQ(0U, initiator->sent_stanza_count());
+ EXPECT_EQ(0U, responder->sent_stanza_count());
+ responder->SkipUnsentStanza();
+ }
+
+ // The channels should be able to become writable at this point. This
+ // requires pinging, so it may take a little while.
+ EXPECT_TRUE_WAIT(initiator->chan_a->writable() &&
+ initiator->chan_a->readable(), kEventTimeout);
+ EXPECT_TRUE_WAIT(initiator->chan_b->writable() &&
+ initiator->chan_b->readable(), kEventTimeout);
+ EXPECT_TRUE_WAIT(responder->chan_a->writable() &&
+ responder->chan_a->readable(), kEventTimeout);
+ EXPECT_TRUE_WAIT(responder->chan_b->writable() &&
+ responder->chan_b->readable(), kEventTimeout);
+
+ // Accept the session and expect accept stanza.
+ cricket::SessionDescription* answer = NewTestSessionDescription(
+ gingle_content_type,
+ content_name_a, content_type,
+ content_name_b, content_type);
+ EXPECT_TRUE(responder->session->Accept(answer));
+ EXPECT_EQ(responder->session->local_description(), answer);
+
+ responder->ExpectSentStanza(
+ IqSet("5", kResponder, kInitiator, accept_xml));
+ EXPECT_EQ(0U, responder->sent_stanza_count());
+
+ // Deliver the accept message and expect an ack.
+ initiator->DeliverStanza(responder->stanza());
+ EXPECT_TRUE_WAIT(initiator->sent_stanza_count() > 0, kEventTimeout);
+ initiator->ExpectSentStanza(
+ IqAck("5", kInitiator, kResponder));
+ EXPECT_EQ(0U, initiator->sent_stanza_count());
+
+ // Both sessions should be in progress and have functioning
+ // channels.
+ EXPECT_EQ(resulting_protocol, initiator->session->current_protocol());
+ EXPECT_EQ(resulting_protocol, responder->session->current_protocol());
+ EXPECT_EQ_WAIT(cricket::BaseSession::STATE_INPROGRESS,
+ initiator->session_state(), kEventTimeout);
+ EXPECT_EQ_WAIT(cricket::BaseSession::STATE_INPROGRESS,
+ responder->session_state(), kEventTimeout);
+ TestSendRecv(initiator->chan_a, initiator->chan_b,
+ responder->chan_a, responder->chan_b);
+
+ if (resulting_protocol == PROTOCOL_JINGLE) {
+ // Deliver a description-info message to the initiator and check if the
+ // content description changes.
+ EXPECT_EQ(0U, initiator->session_remote_description_update_count);
+
+ const cricket::SessionDescription* old_session_desc =
+ initiator->session->remote_description();
+ const cricket::ContentInfo* old_content_a =
+ old_session_desc->GetContentByName(content_name_a);
+ const cricket::ContentDescription* old_content_desc_a =
+ old_content_a->description;
+ const cricket::ContentInfo* old_content_b =
+ old_session_desc->GetContentByName(content_name_b);
+ const cricket::ContentDescription* old_content_desc_b =
+ old_content_b->description;
+ EXPECT_TRUE(old_content_desc_a != NULL);
+ EXPECT_TRUE(old_content_desc_b != NULL);
+
+ LOG(LS_INFO) << "A " << old_content_a->name;
+ LOG(LS_INFO) << "B " << old_content_b->name;
+
+ std::string description_info_xml =
+ JingleDescriptionInfoXml(content_name_a, content_type);
+ initiator->DeliverStanza(
+ IqSet("6", kResponder, kInitiator, description_info_xml));
+ responder->SkipUnsentStanza();
+ EXPECT_EQ(1U, initiator->session_remote_description_update_count);
+
+ const cricket::SessionDescription* new_session_desc =
+ initiator->session->remote_description();
+ const cricket::ContentInfo* new_content_a =
+ new_session_desc->GetContentByName(content_name_a);
+ const cricket::ContentDescription* new_content_desc_a =
+ new_content_a->description;
+ const cricket::ContentInfo* new_content_b =
+ new_session_desc->GetContentByName(content_name_b);
+ const cricket::ContentDescription* new_content_desc_b =
+ new_content_b->description;
+ EXPECT_TRUE(new_content_desc_a != NULL);
+ EXPECT_TRUE(new_content_desc_b != NULL);
+
+ // TODO: We used to replace contents from an update, but
+ // that no longer works with partial updates. We need to figure out
+ // a way to merge patial updates into contents. For now, users of
+ // Session should listen to SignalRemoteDescriptionUpdate and handle
+ // updates. They should not expect remote_description to be the
+ // latest value.
+ // See session.cc OnDescriptionInfoMessage.
+
+ // EXPECT_NE(old_content_desc_a, new_content_desc_a);
+
+ // if (content_name_a != content_name_b) {
+ // // If content_name_a != content_name_b, then b's content description
+ // // should not have changed since the description-info message only
+ // // contained an update for content_name_a.
+ // EXPECT_EQ(old_content_desc_b, new_content_desc_b);
+ // }
+
+ EXPECT_TRUE_WAIT(initiator->sent_stanza_count() > 0, kEventTimeout);
+ initiator->ExpectSentStanza(
+ IqAck("6", kInitiator, kResponder));
+ EXPECT_EQ(0U, initiator->sent_stanza_count());
+ } else {
+ responder->SkipUnsentStanza();
+ }
+
+ initiator->session->Terminate();
+ initiator->ExpectSentStanza(
+ IqSet("7", kInitiator, kResponder,
+ TerminateXml(resulting_protocol,
+ cricket::STR_TERMINATE_SUCCESS)));
+
+ responder->DeliverStanza(initiator->stanza());
+ responder->ExpectSentStanza(
+ IqAck("7", kResponder, kInitiator));
+ EXPECT_EQ(cricket::BaseSession::STATE_SENTTERMINATE,
+ initiator->session_state());
+ EXPECT_EQ(cricket::BaseSession::STATE_RECEIVEDTERMINATE,
+ responder->session_state());
+ }
+
+ // Test an initiate with other content, called "main".
+ void TestOtherContent(SignalingProtocol initiator_protocol,
+ SignalingProtocol responder_protocol,
+ SignalingProtocol resulting_protocol) {
+ std::string content_name = "main";
+ std::string content_type = "http://oink.splat/session";
+ std::string content_name_a = content_name;
+ std::string channel_name_a = "rtcp";
+ std::string content_name_b = content_name;
+ std::string channel_name_b = "rtp";
+ std::string initiate_xml = InitiateXml(
+ initiator_protocol,
+ content_name_a, content_type);
+ std::string transport_info_a_xml = TransportInfo4Xml(
+ initiator_protocol, content_name,
+ channel_name_a, 0, 1,
+ channel_name_b, 2, 3);
+ std::string transport_info_b_xml = "";
+ std::string transport_info_reply_a_xml = TransportInfo4Xml(
+ resulting_protocol, content_name,
+ channel_name_a, 4, 5,
+ channel_name_b, 6, 7);
+ std::string transport_info_reply_b_xml = "";
+ std::string accept_xml = AcceptXml(
+ resulting_protocol,
+ content_name_a, content_type);
+
+
+ TestSession(initiator_protocol, responder_protocol, resulting_protocol,
+ content_type,
+ content_type,
+ content_name_a, channel_name_a,
+ content_name_b, channel_name_b,
+ initiate_xml,
+ transport_info_a_xml, transport_info_b_xml,
+ transport_info_reply_a_xml, transport_info_reply_b_xml,
+ accept_xml);
+ }
+
+ // Test an initiate with audio content.
+ void TestAudioContent(SignalingProtocol initiator_protocol,
+ SignalingProtocol responder_protocol,
+ SignalingProtocol resulting_protocol) {
+ std::string gingle_content_type = cricket::NS_GINGLE_AUDIO;
+ std::string content_name = cricket::CN_AUDIO;
+ std::string content_type = cricket::NS_JINGLE_RTP;
+ std::string channel_name_a = "rtcp";
+ std::string channel_name_b = "rtp";
+ std::string initiate_xml = InitiateXml(
+ initiator_protocol,
+ gingle_content_type,
+ content_name, content_type,
+ "", "");
+ std::string transport_info_a_xml = TransportInfo4Xml(
+ initiator_protocol, content_name,
+ channel_name_a, 0, 1,
+ channel_name_b, 2, 3);
+ std::string transport_info_b_xml = "";
+ std::string transport_info_reply_a_xml = TransportInfo4Xml(
+ resulting_protocol, content_name,
+ channel_name_a, 4, 5,
+ channel_name_b, 6, 7);
+ std::string transport_info_reply_b_xml = "";
+ std::string accept_xml = AcceptXml(
+ resulting_protocol,
+ gingle_content_type,
+ content_name, content_type,
+ "", "");
+
+
+ TestSession(initiator_protocol, responder_protocol, resulting_protocol,
+ gingle_content_type,
+ content_type,
+ content_name, channel_name_a,
+ content_name, channel_name_b,
+ initiate_xml,
+ transport_info_a_xml, transport_info_b_xml,
+ transport_info_reply_a_xml, transport_info_reply_b_xml,
+ accept_xml);
+ }
+
+ // Since media content is "split" into two contents (audio and
+ // video), we need to treat it special.
+ void TestVideoContents(SignalingProtocol initiator_protocol,
+ SignalingProtocol responder_protocol,
+ SignalingProtocol resulting_protocol) {
+ std::string content_type = cricket::NS_JINGLE_RTP;
+ std::string gingle_content_type = cricket::NS_GINGLE_VIDEO;
+ std::string content_name_a = cricket::CN_AUDIO;
+ std::string channel_name_a = "rtcp";
+ std::string content_name_b = cricket::CN_VIDEO;
+ std::string channel_name_b = "video_rtp";
+
+ std::string initiate_xml = InitiateXml(
+ initiator_protocol,
+ gingle_content_type,
+ content_name_a, content_type,
+ content_name_b, content_type);
+ std::string transport_info_a_xml = TransportInfo2Xml(
+ initiator_protocol, content_name_a,
+ channel_name_a, 0, 1);
+ std::string transport_info_b_xml = TransportInfo2Xml(
+ initiator_protocol, content_name_b,
+ channel_name_b, 2, 3);
+ std::string transport_info_reply_a_xml = TransportInfo2Xml(
+ resulting_protocol, content_name_a,
+ channel_name_a, 4, 5);
+ std::string transport_info_reply_b_xml = TransportInfo2Xml(
+ resulting_protocol, content_name_b,
+ channel_name_b, 6, 7);
+ std::string accept_xml = AcceptXml(
+ resulting_protocol,
+ gingle_content_type,
+ content_name_a, content_type,
+ content_name_b, content_type);
+
+ TestSession(initiator_protocol, responder_protocol, resulting_protocol,
+ gingle_content_type,
+ content_type,
+ content_name_a, channel_name_a,
+ content_name_b, channel_name_b,
+ initiate_xml,
+ transport_info_a_xml, transport_info_b_xml,
+ transport_info_reply_a_xml, transport_info_reply_b_xml,
+ accept_xml);
+ }
+
+ void TestBadRedirect(SignalingProtocol protocol) {
+ std::string content_name = "main";
+ std::string content_type = "http://oink.splat/session";
+ std::string channel_name_a = "chana";
+ std::string channel_name_b = "chanb";
+ std::string initiate_xml = InitiateXml(
+ protocol, content_name, content_type);
+ std::string transport_info_xml = TransportInfo4Xml(
+ protocol, content_name,
+ channel_name_a, 0, 1,
+ channel_name_b, 2, 3);
+ std::string transport_info_reply_xml = TransportInfo4Xml(
+ protocol, content_name,
+ channel_name_a, 4, 5,
+ channel_name_b, 6, 7);
+ std::string accept_xml = AcceptXml(
+ protocol, content_name, content_type);
+ std::string responder_full = kResponder + "/full";
+
+ talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+ new TestPortAllocator());
+ int next_message_id = 0;
+
+ talk_base::scoped_ptr<TestClient> initiator(
+ new TestClient(allocator.get(), &next_message_id,
+ kInitiator, protocol,
+ content_type,
+ content_name, channel_name_a,
+ content_name, channel_name_b));
+
+ talk_base::scoped_ptr<TestClient> responder(
+ new TestClient(allocator.get(), &next_message_id,
+ responder_full, protocol,
+ content_type,
+ content_name, channel_name_a,
+ content_name, channel_name_b));
+
+ // Create Session and check channels and state.
+ initiator->CreateSession();
+ EXPECT_EQ(1U, initiator->session_created_count);
+ EXPECT_EQ(kSessionId, initiator->session->id());
+ EXPECT_EQ(initiator->session->local_name(), kInitiator);
+ EXPECT_EQ(cricket::BaseSession::STATE_INIT,
+ initiator->session_state());
+
+ EXPECT_TRUE(initiator->HasChannel(content_name, channel_name_a));
+ EXPECT_TRUE(initiator->HasChannel(content_name, channel_name_b));
+
+ // Initiate and expect initiate message sent.
+ cricket::SessionDescription* offer = NewTestSessionDescription(
+ content_name, content_type);
+ EXPECT_TRUE(initiator->session->Initiate(kResponder, offer));
+ EXPECT_EQ(initiator->session->remote_name(), kResponder);
+ EXPECT_EQ(initiator->session->local_description(), offer);
+
+ EXPECT_TRUE_WAIT(initiator->sent_stanza_count() > 0, kEventTimeout);
+ EXPECT_EQ(cricket::BaseSession::STATE_SENTINITIATE,
+ initiator->session_state());
+ initiator->ExpectSentStanza(
+ IqSet("0", kInitiator, kResponder, initiate_xml));
+
+ // Expect transport-info message from initiator.
+ initiator->DeliverAckToLastStanza();
+ initiator->PrepareCandidates();
+ EXPECT_TRUE_WAIT(initiator->sent_stanza_count() > 0, kEventTimeout);
+ initiator->ExpectSentStanza(
+ IqSet("1", kInitiator, kResponder, transport_info_xml));
+
+ // Send an unauthorized redirect to the initiator and expect it be ignored.
+ initiator->blow_up_on_error = false;
+ const buzz::XmlElement* initiate_stanza = initiator->stanza();
+ talk_base::scoped_ptr<buzz::XmlElement> redirect_stanza(
+ buzz::XmlElement::ForStr(
+ IqError("ER", kResponder, kInitiator,
+ RedirectXml(protocol, initiate_xml, "not@allowed.com"))));
+ initiator->session_manager->OnFailedSend(
+ initiate_stanza, redirect_stanza.get());
+ EXPECT_EQ(initiator->session->remote_name(), kResponder);
+ initiator->blow_up_on_error = true;
+ EXPECT_EQ(initiator->error_count, 1);
+ }
+
+ void TestGoodRedirect(SignalingProtocol protocol) {
+ std::string content_name = "main";
+ std::string content_type = "http://oink.splat/session";
+ std::string channel_name_a = "chana";
+ std::string channel_name_b = "chanb";
+ std::string initiate_xml = InitiateXml(
+ protocol, content_name, content_type);
+ std::string transport_info_xml = TransportInfo4Xml(
+ protocol, content_name,
+ channel_name_a, 0, 1,
+ channel_name_b, 2, 3);
+ std::string transport_info_reply_xml = TransportInfo4Xml(
+ protocol, content_name,
+ channel_name_a, 4, 5,
+ channel_name_b, 6, 7);
+ std::string accept_xml = AcceptXml(
+ protocol, content_name, content_type);
+ std::string responder_full = kResponder + "/full";
+
+ talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+ new TestPortAllocator());
+ int next_message_id = 0;
+
+ talk_base::scoped_ptr<TestClient> initiator(
+ new TestClient(allocator.get(), &next_message_id,
+ kInitiator, protocol,
+ content_type,
+ content_name, channel_name_a,
+ content_name, channel_name_b));
+
+ talk_base::scoped_ptr<TestClient> responder(
+ new TestClient(allocator.get(), &next_message_id,
+ responder_full, protocol,
+ content_type,
+ content_name, channel_name_a,
+ content_name, channel_name_b));
+
+ // Create Session and check channels and state.
+ initiator->CreateSession();
+ EXPECT_EQ(1U, initiator->session_created_count);
+ EXPECT_EQ(kSessionId, initiator->session->id());
+ EXPECT_EQ(initiator->session->local_name(), kInitiator);
+ EXPECT_EQ(cricket::BaseSession::STATE_INIT,
+ initiator->session_state());
+
+ EXPECT_TRUE(initiator->HasChannel(content_name, channel_name_a));
+ EXPECT_TRUE(initiator->HasChannel(content_name, channel_name_b));
+
+ // Initiate and expect initiate message sent.
+ cricket::SessionDescription* offer = NewTestSessionDescription(
+ content_name, content_type);
+ EXPECT_TRUE(initiator->session->Initiate(kResponder, offer));
+ EXPECT_EQ(initiator->session->remote_name(), kResponder);
+ EXPECT_EQ(initiator->session->local_description(), offer);
+
+ EXPECT_TRUE_WAIT(initiator->sent_stanza_count() > 0, kEventTimeout);
+ EXPECT_EQ(cricket::BaseSession::STATE_SENTINITIATE,
+ initiator->session_state());
+ initiator->ExpectSentStanza(
+ IqSet("0", kInitiator, kResponder, initiate_xml));
+
+ // Expect transport-info message from initiator.
+ initiator->DeliverAckToLastStanza();
+ initiator->PrepareCandidates();
+ EXPECT_TRUE_WAIT(initiator->sent_stanza_count() > 0, kEventTimeout);
+ initiator->ExpectSentStanza(
+ IqSet("1", kInitiator, kResponder, transport_info_xml));
+
+ // Send a redirect to the initiator and expect all of the message
+ // to be resent.
+ const buzz::XmlElement* initiate_stanza = initiator->stanza();
+ talk_base::scoped_ptr<buzz::XmlElement> redirect_stanza(
+ buzz::XmlElement::ForStr(
+ IqError("ER2", kResponder, kInitiator,
+ RedirectXml(protocol, initiate_xml, responder_full))));
+ initiator->session_manager->OnFailedSend(
+ initiate_stanza, redirect_stanza.get());
+ EXPECT_EQ(initiator->session->remote_name(), responder_full);
+
+ EXPECT_TRUE_WAIT(initiator->sent_stanza_count() > 0, kEventTimeout);
+ initiator->ExpectSentStanza(
+ IqSet("2", kInitiator, responder_full, initiate_xml));
+ initiator->ExpectSentStanza(
+ IqSet("3", kInitiator, responder_full, transport_info_xml));
+
+ // Deliver the initiate. Expect ack and session created with
+ // transports.
+ responder->DeliverStanza(
+ IqSet("2", kInitiator, responder_full, initiate_xml));
+ responder->ExpectSentStanza(
+ IqAck("2", responder_full, kInitiator));
+ EXPECT_EQ(0U, responder->sent_stanza_count());
+
+ EXPECT_EQ(1U, responder->session_created_count);
+ EXPECT_EQ(kSessionId, responder->session->id());
+ EXPECT_EQ(responder->session->local_name(), responder_full);
+ EXPECT_EQ(responder->session->remote_name(), kInitiator);
+ EXPECT_EQ(cricket::BaseSession::STATE_RECEIVEDINITIATE,
+ responder->session_state());
+
+ EXPECT_TRUE(responder->HasChannel(content_name, channel_name_a));
+ EXPECT_TRUE(responder->HasChannel(content_name, channel_name_b));
+
+ // Deliver transport-info and expect ack.
+ responder->DeliverStanza(
+ IqSet("3", kInitiator, responder_full, transport_info_xml));
+ responder->ExpectSentStanza(
+ IqAck("3", responder_full, kInitiator));
+
+ // Expect reply transport-infos sent to new remote JID
+ responder->PrepareCandidates();
+ EXPECT_TRUE_WAIT(responder->sent_stanza_count() > 0, kEventTimeout);
+ responder->ExpectSentStanza(
+ IqSet("4", responder_full, kInitiator, transport_info_reply_xml));
+
+ initiator->DeliverStanza(responder->stanza());
+ initiator->ExpectSentStanza(
+ IqAck("4", kInitiator, responder_full));
+
+ // The channels should be able to become writable at this point. This
+ // requires pinging, so it may take a little while.
+ EXPECT_TRUE_WAIT(initiator->chan_a->writable() &&
+ initiator->chan_a->readable(), kEventTimeout);
+ EXPECT_TRUE_WAIT(initiator->chan_b->writable() &&
+ initiator->chan_b->readable(), kEventTimeout);
+ EXPECT_TRUE_WAIT(responder->chan_a->writable() &&
+ responder->chan_a->readable(), kEventTimeout);
+ EXPECT_TRUE_WAIT(responder->chan_b->writable() &&
+ responder->chan_b->readable(), kEventTimeout);
+
+ // Accept the session and expect accept stanza.
+ cricket::SessionDescription* answer = NewTestSessionDescription(
+ content_name, content_type);
+ EXPECT_TRUE(responder->session->Accept(answer));
+ EXPECT_EQ(responder->session->local_description(), answer);
+
+ responder->ExpectSentStanza(
+ IqSet("5", responder_full, kInitiator, accept_xml));
+ EXPECT_EQ(0U, responder->sent_stanza_count());
+
+ // Deliver the accept message and expect an ack.
+ initiator->DeliverStanza(responder->stanza());
+ EXPECT_TRUE_WAIT(initiator->sent_stanza_count() > 0, kEventTimeout);
+ initiator->ExpectSentStanza(
+ IqAck("5", kInitiator, responder_full));
+ EXPECT_EQ(0U, initiator->sent_stanza_count());
+
+ // Both sessions should be in progress and have functioning
+ // channels.
+ EXPECT_EQ_WAIT(cricket::BaseSession::STATE_INPROGRESS,
+ initiator->session_state(), kEventTimeout);
+ EXPECT_EQ_WAIT(cricket::BaseSession::STATE_INPROGRESS,
+ responder->session_state(), kEventTimeout);
+ TestSendRecv(initiator->chan_a, initiator->chan_b,
+ responder->chan_a, responder->chan_b);
+ }
+
+ void TestCandidatesInInitiateAndAccept(const std::string& test_name) {
+ std::string content_name = "main";
+ std::string content_type = "http://oink.splat/session";
+ std::string channel_name_a = "rtcp";
+ std::string channel_name_b = "rtp";
+ cricket::SignalingProtocol protocol = PROTOCOL_JINGLE;
+
+ talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+ new TestPortAllocator());
+ int next_message_id = 0;
+
+ talk_base::scoped_ptr<TestClient> initiator(
+ new TestClient(allocator.get(), &next_message_id,
+ kInitiator, protocol,
+ content_type,
+ content_name, channel_name_a,
+ content_name, channel_name_b));
+
+ talk_base::scoped_ptr<TestClient> responder(
+ new TestClient(allocator.get(), &next_message_id,
+ kResponder, protocol,
+ content_type,
+ content_name, channel_name_a,
+ content_name, channel_name_b));
+
+ // Create Session and check channels and state.
+ initiator->CreateSession();
+ EXPECT_TRUE(initiator->HasTransport(content_name));
+ EXPECT_TRUE(initiator->HasChannel(content_name, channel_name_a));
+ EXPECT_TRUE(initiator->HasTransport(content_name));
+ EXPECT_TRUE(initiator->HasChannel(content_name, channel_name_b));
+
+ // Initiate and expect initiate message sent.
+ cricket::SessionDescription* offer = NewTestSessionDescription(
+ content_name, content_type);
+ EXPECT_TRUE(initiator->session->Initiate(kResponder, offer));
+
+ EXPECT_TRUE_WAIT(initiator->sent_stanza_count() > 0, kEventTimeout);
+ EXPECT_EQ(cricket::BaseSession::STATE_SENTINITIATE,
+ initiator->session_state());
+ initiator->ExpectSentStanza(
+ IqSet("0", kInitiator, kResponder,
+ InitiateXml(protocol, content_name, content_type)));
+
+ // Fake the delivery the initiate and candidates together.
+ responder->DeliverStanza(
+ IqSet("A", kInitiator, kResponder,
+ JingleInitiateActionXml(
+ JingleContentXml(
+ content_name, content_type, kTransportType,
+ P2pCandidateXml(channel_name_a, 0) +
+ P2pCandidateXml(channel_name_a, 1) +
+ P2pCandidateXml(channel_name_b, 2) +
+ P2pCandidateXml(channel_name_b, 3)))));
+ responder->ExpectSentStanza(
+ IqAck("A", kResponder, kInitiator));
+ EXPECT_EQ(0U, responder->sent_stanza_count());
+
+ EXPECT_EQ(1U, responder->session_created_count);
+ EXPECT_EQ(kSessionId, responder->session->id());
+ EXPECT_EQ(responder->session->local_name(), kResponder);
+ EXPECT_EQ(responder->session->remote_name(), kInitiator);
+ EXPECT_EQ(cricket::BaseSession::STATE_RECEIVEDINITIATE,
+ responder->session_state());
+
+ EXPECT_TRUE(responder->HasTransport(content_name));
+ EXPECT_TRUE(responder->HasChannel(content_name, channel_name_a));
+ EXPECT_TRUE(responder->HasTransport(content_name));
+ EXPECT_TRUE(responder->HasChannel(content_name, channel_name_b));
+
+ // Expect transport-info message from initiator.
+ // But don't send candidates until initiate ack is received.
+ initiator->DeliverAckToLastStanza();
+ initiator->PrepareCandidates();
+ EXPECT_TRUE_WAIT(initiator->sent_stanza_count() > 0, kEventTimeout);
+ initiator->ExpectSentStanza(
+ IqSet("1", kInitiator, kResponder,
+ TransportInfo4Xml(protocol, content_name,
+ channel_name_a, 0, 1,
+ channel_name_b, 2, 3)));
+
+ responder->PrepareCandidates();
+ EXPECT_TRUE_WAIT(responder->sent_stanza_count() > 0, kEventTimeout);
+ responder->ExpectSentStanza(
+ IqSet("2", kResponder, kInitiator,
+ TransportInfo4Xml(protocol, content_name,
+ channel_name_a, 4, 5,
+ channel_name_b, 6, 7)));
+
+ // Accept the session and expect accept stanza.
+ cricket::SessionDescription* answer = NewTestSessionDescription(
+ content_name, content_type);
+ EXPECT_TRUE(responder->session->Accept(answer));
+
+ responder->ExpectSentStanza(
+ IqSet("3", kResponder, kInitiator,
+ AcceptXml(protocol, content_name, content_type)));
+ EXPECT_EQ(0U, responder->sent_stanza_count());
+
+ // Fake the delivery the accept and candidates together.
+ initiator->DeliverStanza(
+ IqSet("B", kResponder, kInitiator,
+ JingleActionXml("session-accept",
+ JingleContentXml(
+ content_name, content_type, kTransportType,
+ P2pCandidateXml(channel_name_a, 4) +
+ P2pCandidateXml(channel_name_a, 5) +
+ P2pCandidateXml(channel_name_b, 6) +
+ P2pCandidateXml(channel_name_b, 7)))));
+ EXPECT_TRUE_WAIT(initiator->sent_stanza_count() > 0, kEventTimeout);
+ initiator->ExpectSentStanza(
+ IqAck("B", kInitiator, kResponder));
+ EXPECT_EQ(0U, initiator->sent_stanza_count());
+
+ // The channels should be able to become writable at this point. This
+ // requires pinging, so it may take a little while.
+ EXPECT_TRUE_WAIT(initiator->chan_a->writable() &&
+ initiator->chan_a->readable(), kEventTimeout);
+ EXPECT_TRUE_WAIT(initiator->chan_b->writable() &&
+ initiator->chan_b->readable(), kEventTimeout);
+ EXPECT_TRUE_WAIT(responder->chan_a->writable() &&
+ responder->chan_a->readable(), kEventTimeout);
+ EXPECT_TRUE_WAIT(responder->chan_b->writable() &&
+ responder->chan_b->readable(), kEventTimeout);
+
+
+ // Both sessions should be in progress and have functioning
+ // channels.
+ EXPECT_EQ(protocol, initiator->session->current_protocol());
+ EXPECT_EQ(protocol, responder->session->current_protocol());
+ EXPECT_EQ_WAIT(cricket::BaseSession::STATE_INPROGRESS,
+ initiator->session_state(), kEventTimeout);
+ EXPECT_EQ_WAIT(cricket::BaseSession::STATE_INPROGRESS,
+ responder->session_state(), kEventTimeout);
+ TestSendRecv(initiator->chan_a, initiator->chan_b,
+ responder->chan_a, responder->chan_b);
+ }
+
+ // Tests that when an initiator terminates right after initiate,
+ // everything behaves correctly.
+ void TestEarlyTerminationFromInitiator(SignalingProtocol protocol) {
+ std::string content_name = "main";
+ std::string content_type = "http://oink.splat/session";
+
+ talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+ new TestPortAllocator());
+ int next_message_id = 0;
+
+ talk_base::scoped_ptr<TestClient> initiator(
+ new TestClient(allocator.get(), &next_message_id,
+ kInitiator, protocol,
+ content_type,
+ content_name, "a",
+ content_name, "b"));
+
+ talk_base::scoped_ptr<TestClient> responder(
+ new TestClient(allocator.get(), &next_message_id,
+ kResponder, protocol,
+ content_type,
+ content_name, "a",
+ content_name, "b"));
+
+ // Send initiate
+ initiator->CreateSession();
+ EXPECT_TRUE(initiator->session->Initiate(
+ kResponder, NewTestSessionDescription(content_name, content_type)));
+ initiator->ExpectSentStanza(
+ IqSet("0", kInitiator, kResponder,
+ InitiateXml(protocol, content_name, content_type)));
+ EXPECT_EQ(cricket::BaseSession::STATE_SENTINITIATE,
+ initiator->session_state());
+
+ responder->DeliverStanza(initiator->stanza());
+ responder->ExpectSentStanza(
+ IqAck("0", kResponder, kInitiator));
+ EXPECT_EQ(cricket::BaseSession::STATE_RECEIVEDINITIATE,
+ responder->session_state());
+
+ initiator->session->TerminateWithReason(cricket::STR_TERMINATE_ERROR);
+ initiator->ExpectSentStanza(
+ IqSet("1", kInitiator, kResponder,
+ TerminateXml(protocol, cricket::STR_TERMINATE_ERROR)));
+ EXPECT_EQ(cricket::BaseSession::STATE_SENTTERMINATE,
+ initiator->session_state());
+
+ responder->DeliverStanza(initiator->stanza());
+ responder->ExpectSentStanza(
+ IqAck("1", kResponder, kInitiator));
+ EXPECT_EQ(cricket::BaseSession::STATE_RECEIVEDTERMINATE,
+ responder->session_state());
+ }
+
+ // Tests that when the responder rejects, everything behaves
+ // correctly.
+ void TestRejection(SignalingProtocol protocol) {
+ std::string content_name = "main";
+ std::string content_type = "http://oink.splat/session";
+
+ talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+ new TestPortAllocator());
+ int next_message_id = 0;
+
+ talk_base::scoped_ptr<TestClient> initiator(
+ new TestClient(allocator.get(), &next_message_id,
+ kInitiator, protocol,
+ content_type,
+ content_name, "a",
+ content_name, "b"));
+
+ // Send initiate
+ initiator->CreateSession();
+ EXPECT_TRUE(initiator->session->Initiate(
+ kResponder, NewTestSessionDescription(content_name, content_type)));
+ initiator->ExpectSentStanza(
+ IqSet("0", kInitiator, kResponder,
+ InitiateXml(protocol, content_name, content_type)));
+ EXPECT_EQ(cricket::BaseSession::STATE_SENTINITIATE,
+ initiator->session_state());
+
+ initiator->DeliverStanza(
+ IqSet("1", kResponder, kInitiator,
+ RejectXml(protocol, cricket::STR_TERMINATE_ERROR)));
+ initiator->ExpectSentStanza(
+ IqAck("1", kInitiator, kResponder));
+ if (protocol == PROTOCOL_JINGLE) {
+ EXPECT_EQ(cricket::BaseSession::STATE_RECEIVEDTERMINATE,
+ initiator->session_state());
+ } else {
+ EXPECT_EQ(cricket::BaseSession::STATE_RECEIVEDREJECT,
+ initiator->session_state());
+ }
+ }
+
+ void TestTransportMux() {
+ std::string content_type = cricket::NS_JINGLE_RTP;
+ std::string gingle_content_type = cricket::NS_GINGLE_VIDEO;
+ std::string content_name_a = cricket::CN_AUDIO;
+ std::string channel_name_a = "rtp";
+ std::string channel_name_aa = "rtcp";
+ std::string content_name_b = cricket::CN_VIDEO;
+ std::string channel_name_b = "video_rtp";
+ std::string channel_name_bb = "video_rtcp";
+ cricket::SignalingProtocol protocol = PROTOCOL_JINGLE;
+
+ talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+ new TestPortAllocator());
+ int next_message_id = 0;
+
+ talk_base::scoped_ptr<TestClient> initiator(
+ new TestClient(allocator.get(), &next_message_id,
+ kInitiator, protocol,
+ content_type,
+ content_name_a, channel_name_a, channel_name_aa,
+ content_name_b, channel_name_b, channel_name_bb));
+
+ // First creating the offer and answer session descriptions required for
+ // testing.
+ cricket::SessionDescription* offer = NewTestSessionDescription(
+ gingle_content_type,
+ content_name_a, content_type,
+ content_name_b, content_type);
+ // Add group information to the offer
+ cricket::ContentGroup group(cricket::GN_BUNDLE);
+ group.AddContentName(content_name_a);
+ group.AddContentName(content_name_b);
+ EXPECT_TRUE(group.HasContentName(content_name_a));
+ EXPECT_TRUE(group.HasContentName(content_name_b));
+ offer->AddGroup(group);
+
+ // Creating answer for the offer.
+ cricket::SessionDescription* answer = NewTestSessionDescription(
+ gingle_content_type,
+ content_name_a, content_type,
+ content_name_b, content_type);
+ // Check if group "TOGETHER" exists in the offer. If it's present then
+ // remote supports muxing.
+ EXPECT_TRUE(offer->HasGroup(cricket::GN_BUNDLE));
+ const cricket::ContentGroup* group_offer =
+ offer->GetGroupByName(cricket::GN_BUNDLE);
+ // Not creating new copy in answer, for test we can use this for test.
+ answer->AddGroup(*group_offer);
+ EXPECT_TRUE(answer->HasGroup(cricket::GN_BUNDLE));
+
+ initiator->CreateSession();
+ EXPECT_TRUE(initiator->session->Initiate(
+ kResponder, offer));
+
+ EXPECT_TRUE(initiator->HasTransport(content_name_a));
+ EXPECT_TRUE(initiator->HasChannel(content_name_a, channel_name_a));
+ EXPECT_TRUE(initiator->HasChannel(content_name_a, channel_name_aa));
+ EXPECT_TRUE(initiator->HasTransport(content_name_b));
+ EXPECT_TRUE(initiator->HasChannel(content_name_b, channel_name_b));
+ EXPECT_TRUE(initiator->HasChannel(content_name_b, channel_name_bb));
+ // This test will not create initiator and responder. Manually change
+ // session state and invoke methods.
+ initiator->PrepareCandidates();
+ EXPECT_EQ(cricket::BaseSession::STATE_SENTINITIATE,
+ initiator->session_state());
+ // Now apply answer to the session and move session state to
+ // STATE_RECEIVEDACCEPT
+ initiator->session->set_remote_description(answer);
+ initiator->session->SetState(cricket::BaseSession::STATE_RECEIVEDACCEPT);
+ cricket::TransportChannel* chan_a =
+ initiator->GetChannel(content_name_a, channel_name_a);
+ cricket::TransportChannel* chan_b =
+ initiator->GetChannel(content_name_b, channel_name_b);
+ // Since we know these are TransportChannelProxy, type cast it.
+ cricket::TransportChannelProxy* proxy_chan_a =
+ static_cast<cricket::TransportChannelProxy*>(chan_a);
+ cricket::TransportChannelProxy* proxy_chan_b =
+ static_cast<cricket::TransportChannelProxy*>(chan_b);
+ EXPECT_EQ(proxy_chan_a->impl(), proxy_chan_b->impl());
+ cricket::TransportChannel* chan_aa =
+ initiator->GetChannel(content_name_a, channel_name_aa);
+ cricket::TransportChannel* chan_bb =
+ initiator->GetChannel(content_name_b, channel_name_bb);
+ cricket::TransportChannelProxy* proxy_chan_aa =
+ static_cast<cricket::TransportChannelProxy*>(chan_aa);
+ cricket::TransportChannelProxy* proxy_chan_bb =
+ static_cast<cricket::TransportChannelProxy*>(chan_bb);
+ EXPECT_EQ(proxy_chan_aa->impl(), proxy_chan_bb->impl());
+ // TODO - Add test code to send data after mux is enabled.
+ }
+};
+
+// For each of these, "X => Y = Z" means "if a client with protocol X
+// initiates to a client with protocol Y, they end up speaking protocol Z.
+
+// Gingle => Gingle = Gingle (with other content)
+TEST_F(SessionTest, GingleToGingleOtherContent) {
+ TestOtherContent(PROTOCOL_GINGLE, PROTOCOL_GINGLE, PROTOCOL_GINGLE);
+}
+
+// Gingle => Gingle = Gingle (with audio content)
+TEST_F(SessionTest, GingleToGingleAudioContent) {
+ TestAudioContent(PROTOCOL_GINGLE, PROTOCOL_GINGLE, PROTOCOL_GINGLE);
+}
+
+// Gingle => Gingle = Gingle (with video contents)
+TEST_F(SessionTest, GingleToGingleVideoContents) {
+ TestVideoContents(PROTOCOL_GINGLE, PROTOCOL_GINGLE, PROTOCOL_GINGLE);
+}
+
+
+// Jingle => Jingle = Jingle (with other content)
+TEST_F(SessionTest, JingleToJingleOtherContent) {
+ TestOtherContent(PROTOCOL_JINGLE, PROTOCOL_JINGLE, PROTOCOL_JINGLE);
+}
+
+// Jingle => Jingle = Jingle (with audio content)
+TEST_F(SessionTest, JingleToJingleAudioContent) {
+ TestAudioContent(PROTOCOL_JINGLE, PROTOCOL_JINGLE, PROTOCOL_JINGLE);
+}
+
+// Jingle => Jingle = Jingle (with video contents)
+TEST_F(SessionTest, JingleToJingleVideoContents) {
+ TestVideoContents(PROTOCOL_JINGLE, PROTOCOL_JINGLE, PROTOCOL_JINGLE);
+}
+
+
+// Hybrid => Hybrid = Jingle (with other content)
+TEST_F(SessionTest, HybridToHybridOtherContent) {
+ TestOtherContent(PROTOCOL_HYBRID, PROTOCOL_HYBRID, PROTOCOL_JINGLE);
+}
+
+// Hybrid => Hybrid = Jingle (with audio content)
+TEST_F(SessionTest, HybridToHybridAudioContent) {
+ TestAudioContent(PROTOCOL_HYBRID, PROTOCOL_HYBRID, PROTOCOL_JINGLE);
+}
+
+// Hybrid => Hybrid = Jingle (with video contents)
+TEST_F(SessionTest, HybridToHybridVideoContents) {
+ TestVideoContents(PROTOCOL_HYBRID, PROTOCOL_HYBRID, PROTOCOL_JINGLE);
+}
+
+
+// Gingle => Hybrid = Gingle (with other content)
+TEST_F(SessionTest, GingleToHybridOtherContent) {
+ TestOtherContent(PROTOCOL_GINGLE, PROTOCOL_HYBRID, PROTOCOL_GINGLE);
+}
+
+// Gingle => Hybrid = Gingle (with audio content)
+TEST_F(SessionTest, GingleToHybridAudioContent) {
+ TestAudioContent(PROTOCOL_GINGLE, PROTOCOL_HYBRID, PROTOCOL_GINGLE);
+}
+
+// Gingle => Hybrid = Gingle (with video contents)
+TEST_F(SessionTest, GingleToHybridVideoContents) {
+ TestVideoContents(PROTOCOL_GINGLE, PROTOCOL_HYBRID, PROTOCOL_GINGLE);
+}
+
+
+// Jingle => Hybrid = Jingle (with other content)
+TEST_F(SessionTest, JingleToHybridOtherContent) {
+ TestOtherContent(PROTOCOL_JINGLE, PROTOCOL_HYBRID, PROTOCOL_JINGLE);
+}
+
+// Jingle => Hybrid = Jingle (with audio content)
+TEST_F(SessionTest, JingleToHybridAudioContent) {
+ TestAudioContent(PROTOCOL_JINGLE, PROTOCOL_HYBRID, PROTOCOL_JINGLE);
+}
+
+// Jingle => Hybrid = Jingle (with video contents)
+TEST_F(SessionTest, JingleToHybridVideoContents) {
+ TestVideoContents(PROTOCOL_JINGLE, PROTOCOL_HYBRID, PROTOCOL_JINGLE);
+}
+
+
+// Hybrid => Gingle = Gingle (with other content)
+TEST_F(SessionTest, HybridToGingleOtherContent) {
+ TestOtherContent(PROTOCOL_HYBRID, PROTOCOL_GINGLE, PROTOCOL_GINGLE);
+}
+
+// Hybrid => Gingle = Gingle (with audio content)
+TEST_F(SessionTest, HybridToGingleAudioContent) {
+ TestAudioContent(PROTOCOL_HYBRID, PROTOCOL_GINGLE, PROTOCOL_GINGLE);
+}
+
+// Hybrid => Gingle = Gingle (with video contents)
+TEST_F(SessionTest, HybridToGingleVideoContents) {
+ TestVideoContents(PROTOCOL_HYBRID, PROTOCOL_GINGLE, PROTOCOL_GINGLE);
+}
+
+
+// Hybrid => Jingle = Jingle (with other content)
+TEST_F(SessionTest, HybridToJingleOtherContent) {
+ TestOtherContent(PROTOCOL_HYBRID, PROTOCOL_JINGLE, PROTOCOL_JINGLE);
+}
+
+// Hybrid => Jingle = Jingle (with audio content)
+TEST_F(SessionTest, HybridToJingleAudioContent) {
+ TestAudioContent(PROTOCOL_HYBRID, PROTOCOL_JINGLE, PROTOCOL_JINGLE);
+}
+
+// Hybrid => Jingle = Jingle (with video contents)
+TEST_F(SessionTest, HybridToJingleVideoContents) {
+ TestVideoContents(PROTOCOL_HYBRID, PROTOCOL_JINGLE, PROTOCOL_JINGLE);
+}
+
+
+TEST_F(SessionTest, GingleEarlyTerminationFromInitiator) {
+ TestEarlyTerminationFromInitiator(PROTOCOL_GINGLE);
+}
+
+TEST_F(SessionTest, JingleEarlyTerminationFromInitiator) {
+ TestEarlyTerminationFromInitiator(PROTOCOL_JINGLE);
+}
+
+TEST_F(SessionTest, HybridEarlyTerminationFromInitiator) {
+ TestEarlyTerminationFromInitiator(PROTOCOL_HYBRID);
+}
+
+
+TEST_F(SessionTest, GingleRejection) {
+ TestRejection(PROTOCOL_GINGLE);
+}
+
+TEST_F(SessionTest, JingleRejection) {
+ TestRejection(PROTOCOL_JINGLE);
+}
+
+TEST_F(SessionTest, GingleGoodRedirect) {
+ TestGoodRedirect(PROTOCOL_GINGLE);
+}
+
+TEST_F(SessionTest, JingleGoodRedirect) {
+ TestGoodRedirect(PROTOCOL_JINGLE);
+}
+
+TEST_F(SessionTest, GingleBadRedirect) {
+ TestBadRedirect(PROTOCOL_GINGLE);
+}
+
+TEST_F(SessionTest, JingleBadRedirect) {
+ TestBadRedirect(PROTOCOL_JINGLE);
+}
+
+TEST_F(SessionTest, TestCandidatesInInitiateAndAccept) {
+ TestCandidatesInInitiateAndAccept("Candidates in initiate/accept");
+}
+
+TEST_F(SessionTest, TestTransportMux) {
+ TestTransportMux();
+}
diff --git a/talk/p2p/base/sessiondescription.cc b/talk/p2p/base/sessiondescription.cc
index 6554f5a..add9236 100644
--- a/talk/p2p/base/sessiondescription.cc
+++ b/talk/p2p/base/sessiondescription.cc
@@ -53,6 +53,29 @@
return NULL;
}
+void ContentGroup::AddContentName(const std::string& content_name) {
+ content_types_.insert(content_name);
+}
+
+bool ContentGroup::RemoveContentName(const std::string& content_name) {
+ bool ret = false;
+ std::set<std::string>::iterator iter;
+ iter = content_types_.find(content_name);
+ if (iter != content_types_.end()) {
+ content_types_.erase(iter);
+ ret = true;
+ }
+ return ret;
+}
+
+bool ContentGroup::HasContentName(const std::string& content_name) const {
+ return (content_types_.find(content_name) != content_types_.end());
+}
+
+const std::string* ContentGroup::FirstContentName() const {
+ return (content_types_.begin() != content_types_.end()) ?
+ &(*content_types_.begin()) : NULL;
+}
const ContentInfo* SessionDescription::GetContentByName(
const std::string& name) const {
return FindContentInfoByName(contents_, name);
@@ -63,6 +86,10 @@
return FindContentInfoByType(contents_, type);
}
+const ContentInfo* SessionDescription::FirstContent() const {
+ return (contents_.empty()) ? NULL : &(*contents_.begin());
+}
+
void SessionDescription::AddContent(const std::string& name,
const std::string& type,
const ContentDescription* description) {
@@ -82,4 +109,34 @@
return false;
}
+void SessionDescription::RemoveGroupByName(const std::string& name) {
+ for (ContentGroups::iterator iter = groups_.begin();
+ iter != groups_.end(); ++iter) {
+ if (iter->semantics() == name) {
+ groups_.erase(iter);
+ }
+ }
+}
+
+bool SessionDescription::HasGroup(const std::string& name) const {
+ for (ContentGroups::const_iterator iter = groups_.begin();
+ iter != groups_.end(); ++iter) {
+ if (iter->semantics() == name) {
+ return true;
+ }
+ }
+ return false;
+}
+
+const ContentGroup* SessionDescription::GetGroupByName(
+ const std::string& name) const {
+ for (ContentGroups::const_iterator iter = groups_.begin();
+ iter != groups_.end(); ++iter) {
+ if (iter->semantics() == name) {
+ return &(*iter);
+ }
+ }
+ return NULL;
+}
+
} // namespace cricket
diff --git a/talk/p2p/base/sessiondescription.h b/talk/p2p/base/sessiondescription.h
index 38c902b..153fe97 100644
--- a/talk/p2p/base/sessiondescription.h
+++ b/talk/p2p/base/sessiondescription.h
@@ -28,6 +28,7 @@
#ifndef TALK_P2P_BASE_SESSIONDESCRIPTION_H_
#define TALK_P2P_BASE_SESSIONDESCRIPTION_H_
+#include <set>
#include <string>
#include <vector>
@@ -55,7 +56,28 @@
const ContentDescription* description;
};
+// This class provides a mechanism to aggregate different media contents into a
+// group. This group can also be shared with the peers in a pre-defined format.
+// GroupInfo should be populated only with the |content_name| of the
+// MediaDescription.
+class ContentGroup {
+ public:
+ explicit ContentGroup(const std::string& semantics) :
+ semantics_(semantics) {}
+ void AddContentName(const std::string& content_name);
+ bool RemoveContentName(const std::string& content_name);
+ bool HasContentName(const std::string& content_name) const;
+ const std::string* FirstContentName() const;
+ const std::string& semantics() const { return semantics_; }
+
+ private:
+ std::string semantics_;
+ std::set<std::string> content_types_;
+};
+
typedef std::vector<ContentInfo> ContentInfos;
+typedef std::vector<ContentGroup> ContentGroups;
+
const ContentInfo* FindContentInfoByName(
const ContentInfos& contents, const std::string& name);
const ContentInfo* FindContentInfoByType(
@@ -71,6 +93,7 @@
contents_(contents) {}
const ContentInfo* GetContentByName(const std::string& name) const;
const ContentInfo* FirstContentByType(const std::string& type) const;
+ const ContentInfo* FirstContent() const;
// Takes ownership of ContentDescription*.
void AddContent(const std::string& name,
const std::string& type,
@@ -84,9 +107,14 @@
delete content->description;
}
}
+ bool HasGroup(const std::string& name) const;
+ void AddGroup(const ContentGroup& group) { groups_.push_back(group); }
+ void RemoveGroupByName(const std::string& name);
+ const ContentGroup* GetGroupByName(const std::string& name) const;
private:
ContentInfos contents_;
+ ContentGroups groups_;
};
// Indicates whether a ContentDescription was an offer or an answer, as
diff --git a/talk/p2p/base/sessionmessages.cc b/talk/p2p/base/sessionmessages.cc
index ae2e656..96f91d1 100644
--- a/talk/p2p/base/sessionmessages.cc
+++ b/talk/p2p/base/sessionmessages.cc
@@ -73,9 +73,9 @@
if (type == JINGLE_ACTION_TRANSPORT_ACCEPT)
return ACTION_TRANSPORT_ACCEPT;
if (type == JINGLE_ACTION_DESCRIPTION_INFO)
- return ACTION_UPDATE;
+ return ACTION_DESCRIPTION_INFO;
if (type == GINGLE_ACTION_UPDATE)
- return ACTION_UPDATE;
+ return ACTION_DESCRIPTION_INFO;
return ACTION_UNKNOWN;
}
@@ -362,7 +362,7 @@
}
buzz::XmlElement* NewTransportElement(const std::string& name) {
- return new buzz::XmlElement(buzz::QName(true, name, LN_TRANSPORT), true);
+ return new buzz::XmlElement(buzz::QName(name, LN_TRANSPORT), true);
}
bool WriteCandidates(SignalingProtocol protocol,
@@ -678,6 +678,7 @@
static bool ParseContentMessage(
SignalingProtocol protocol,
const buzz::XmlElement* action_elem,
+ bool expect_transports,
const ContentParserMap& content_parsers,
const TransportParserMap& trans_parsers,
SessionInitiate* init,
@@ -688,7 +689,8 @@
&init->contents, error))
return false;
- if (!ParseGingleTransportInfos(action_elem, init->contents, trans_parsers,
+ if (expect_transports &&
+ !ParseGingleTransportInfos(action_elem, init->contents, trans_parsers,
&init->transports, error))
return false;
} else {
@@ -696,7 +698,8 @@
&init->contents, error))
return false;
- if (!ParseJingleTransportInfos(action_elem, init->contents, trans_parsers,
+ if (expect_transports &&
+ !ParseJingleTransportInfos(action_elem, init->contents, trans_parsers,
&init->transports, error))
return false;
}
@@ -735,7 +738,8 @@
const TransportParserMap& trans_parsers,
SessionInitiate* init,
ParseError* error) {
- return ParseContentMessage(protocol, action_elem,
+ bool expect_transports = true;
+ return ParseContentMessage(protocol, action_elem, expect_transports,
content_parsers, trans_parsers,
init, error);
}
@@ -759,7 +763,8 @@
const TransportParserMap& transport_parsers,
SessionAccept* accept,
ParseError* error) {
- return ParseContentMessage(protocol, action_elem,
+ bool expect_transports = true;
+ return ParseContentMessage(protocol, action_elem, expect_transports,
content_parsers, transport_parsers,
accept, error);
}
@@ -807,13 +812,12 @@
const SessionTerminate& term,
XmlElements* elems) {
if (protocol == PROTOCOL_GINGLE) {
- elems->push_back(new buzz::XmlElement(
- buzz::QName(true, NS_GINGLE, term.reason)));
+ elems->push_back(new buzz::XmlElement(buzz::QName(NS_GINGLE, term.reason)));
} else {
if (!term.reason.empty()) {
buzz::XmlElement* reason_elem = new buzz::XmlElement(QN_JINGLE_REASON);
reason_elem->AddElement(new buzz::XmlElement(
- buzz::QName(true, NS_JINGLE, term.reason)));
+ buzz::QName(NS_JINGLE, term.reason)));
elems->push_back(reason_elem);
}
}
@@ -825,7 +829,8 @@
const TransportParserMap& transport_parsers,
DescriptionInfo* description_info,
ParseError* error) {
- return ParseContentMessage(protocol, action_elem,
+ bool expect_transports = false;
+ return ParseContentMessage(protocol, action_elem, expect_transports,
content_parsers, transport_parsers,
description_info, error);
}
diff --git a/talk/p2p/base/sessionmessages.h b/talk/p2p/base/sessionmessages.h
index 214fa8c..1486f0c 100644
--- a/talk/p2p/base/sessionmessages.h
+++ b/talk/p2p/base/sessionmessages.h
@@ -62,7 +62,7 @@
ACTION_TRANSPORT_INFO,
ACTION_TRANSPORT_ACCEPT,
- ACTION_UPDATE,
+ ACTION_DESCRIPTION_INFO,
};
// Abstraction of a <jingle> element within an <iq> stanza, per XMPP
diff --git a/talk/p2p/base/stun.cc b/talk/p2p/base/stun.cc
index fab14af..b7f6b52 100644
--- a/talk/p2p/base/stun.cc
+++ b/talk/p2p/base/stun.cc
@@ -42,16 +42,17 @@
const char STUN_ERROR_REASON_SERVER_ERROR[] = "SERVER ERROR";
const char TURN_MAGIC_COOKIE_VALUE[] = { '\x72', '\xC6', '\x4B', '\xC6' };
+const char EMPTY_TRANSACTION_ID[] = "0000000000000000";
StunMessage::StunMessage()
: type_(0), length_(0),
- transaction_id_("000000000000") {
+ transaction_id_(EMPTY_TRANSACTION_ID) {
ASSERT(IsValidTransactionId(transaction_id_));
attrs_ = new std::vector<StunAttribute*>();
}
StunMessage::~StunMessage() {
- for (unsigned i = 0; i < attrs_->size(); i++)
+ for (size_t i = 0; i < attrs_->size(); i++)
delete (*attrs_)[i];
delete attrs_;
}
@@ -63,14 +64,22 @@
return false;
}
-void StunMessage::SetTransactionID(const std::string& str) {
- ASSERT(IsValidTransactionId(str));
+bool StunMessage::SetTransactionID(const std::string& str) {
+ if (!IsValidTransactionId(str)) {
+ return false;
+ }
transaction_id_ = str;
+ return true;
}
void StunMessage::AddAttribute(StunAttribute* attr) {
attrs_->push_back(attr);
- length_ += attr->length() + 4;
+ attr->SetOwner(this);
+ size_t attr_length = attr->length();
+ if (attr_length % 4 != 0) {
+ attr_length += (4 - (attr_length % 4));
+ }
+ length_ += attr_length + 4;
}
const StunAddressAttribute*
@@ -138,7 +147,7 @@
}
const StunAttribute* StunMessage::GetAttribute(StunAttributeType type) const {
- for (unsigned i = 0; i < attrs_->size(); i++) {
+ for (size_t i = 0; i < attrs_->size(); i++) {
if ((*attrs_)[i]->type() == type)
return (*attrs_)[i];
}
@@ -176,7 +185,7 @@
ASSERT(IsValidTransactionId(transaction_id));
transaction_id_ = transaction_id;
- if (length_ > buf->Length())
+ if (length_ != buf->Length())
return false;
attrs_->resize(0);
@@ -189,9 +198,13 @@
if (!buf->ReadUInt16(&attr_length))
return false;
- StunAttribute* attr = StunAttribute::Create(attr_type, attr_length);
+ StunAttribute* attr = StunAttribute::Create(attr_type, attr_length,
+ this);
if (!attr) {
// Skip an unknown attribute.
+ if ((attr_length % 4) != 0) {
+ attr_length += (4 - (attr_length % 4));
+ }
if (!buf->Consume(attr_length))
return false;
} else {
@@ -213,7 +226,7 @@
buf->WriteUInt32(kStunMagicCookie);
buf->WriteString(transaction_id_);
- for (unsigned i = 0; i < attrs_->size(); i++) {
+ for (size_t i = 0; i < attrs_->size(); i++) {
buf->WriteUInt16((*attrs_)[i]->type());
buf->WriteUInt16((*attrs_)[i]->length());
(*attrs_)[i]->Write(buf);
@@ -229,17 +242,19 @@
: type_(type), length_(length) {
}
-StunAttribute* StunAttribute::Create(uint16 type, uint16 length) {
+StunAttribute* StunAttribute::Create(uint16 type,
+ uint16 length,
+ StunMessage* owner) {
switch (type) {
case STUN_ATTR_MAPPED_ADDRESS:
case STUN_ATTR_DESTINATION_ADDRESS:
case STUN_ATTR_SOURCE_ADDRESS2:
- // TODO: Addresses may be different size for IPv6
- // addresses, but we don't support IPv6 yet. Fix address parsing
- // when IPv6 support is implemented.
- if (length != StunAddressAttribute::SIZE)
+ if (length != StunAddressAttribute::SIZE_IP4 &&
+ length != StunAddressAttribute::SIZE_IP6) {
+ LOG(LS_WARNING) << "Invalid length specified for address attribute";
return NULL;
- return new StunAddressAttribute(type);
+ }
+ return new StunAddressAttribute(type, length);
case STUN_ATTR_LIFETIME:
case STUN_ATTR_BANDWIDTH:
@@ -250,14 +265,12 @@
case STUN_ATTR_USERNAME:
case STUN_ATTR_MAGIC_COOKIE:
- return (length % 4 == 0) ? new StunByteStringAttribute(type, length) : 0;
+ case STUN_ATTR_DATA:
+ return new StunByteStringAttribute(type, length);
case STUN_ATTR_MESSAGE_INTEGRITY:
return (length == 20) ? new StunByteStringAttribute(type, length) : 0;
- case STUN_ATTR_DATA:
- return new StunByteStringAttribute(type, length);
-
case STUN_ATTR_ERROR_CODE:
if (length < StunErrorCodeAttribute::MIN_SIZE)
return NULL;
@@ -267,27 +280,42 @@
return (length % 2 == 0) ? new StunUInt16ListAttribute(type, length) : 0;
case STUN_ATTR_XOR_MAPPED_ADDRESS:
- // TODO: Addresses may be different size for IPv6
- // addresses, but we don't support IPv6 yet. Fix address parsing
- // when IPv6 support is implemented.
- if (length != StunAddressAttribute::SIZE)
+ if (length != StunAddressAttribute::SIZE_IP4 &&
+ length != StunAddressAttribute::SIZE_IP6) {
+ LOG(LS_WARNING) << "Invalid length specified for XOR address attribute";
return NULL;
- return new StunXorAddressAttribute(type);
+ }
+ return new StunXorAddressAttribute(type, length, owner);
default:
return NULL;
}
}
+void StunAttribute::ConsumePadding(talk_base::ByteBuffer* buf) const {
+ int remainder = length_ % 4;
+ if (remainder > 0) {
+ buf->Consume(4 - remainder);
+ }
+}
+
+void StunAttribute::WritePadding(talk_base::ByteBuffer* buf) const {
+ int remainder = length_ % 4;
+ if (remainder > 0) {
+ char zeroes[4] = {0};
+ buf->WriteBytes(zeroes, 4 - remainder);
+ }
+}
+
StunAddressAttribute* StunAttribute::CreateAddress(uint16 type) {
switch (type) {
case STUN_ATTR_MAPPED_ADDRESS:
case STUN_ATTR_DESTINATION_ADDRESS:
case STUN_ATTR_SOURCE_ADDRESS2:
- return new StunAddressAttribute(type);
+ return new StunAddressAttribute(type, StunAddressAttribute::SIZE_IP4);
case STUN_ATTR_XOR_MAPPED_ADDRESS:
- return new StunXorAddressAttribute(type);
+ return new StunXorAddressAttribute(type, StunAddressAttribute::SIZE_IP4);
default:
ASSERT(false);
@@ -331,68 +359,146 @@
return new StunUInt16ListAttribute(STUN_ATTR_UNKNOWN_ATTRIBUTES, 0);
}
-StunAddressAttribute::StunAddressAttribute(uint16 type)
- : StunAttribute(type, SIZE), family_(STUN_ADDRESS_IPV4), port_(0), ip_(0) {
-}
-
-void StunAddressAttribute::SetFamily(StunAddressFamily family) {
- family_ = family;
-}
+StunAddressAttribute::StunAddressAttribute(uint16 type, uint16 length)
+ : StunAttribute(type, length) { }
bool StunAddressAttribute::Read(ByteBuffer* buf) {
uint8 dummy;
if (!buf->ReadUInt8(&dummy))
return false;
- uint8 family;
- // We don't expect IPv6 address here because IPv6 addresses would
- // not pass the attribute size check in StunAttribute::Create().
- if (!buf->ReadUInt8(&family) || family != STUN_ADDRESS_IPV4) {
+ uint8 stun_family;
+ if (!buf->ReadUInt8(&stun_family)) {
return false;
}
- family_ = static_cast<StunAddressFamily>(family);
-
- if (!buf->ReadUInt16(&port_))
+ uint16 port;
+ if (!buf->ReadUInt16(&port))
return false;
-
- if (!buf->ReadUInt32(&ip_))
+ if (stun_family == STUN_ADDRESS_IPV4) {
+ in_addr v4addr;
+ if (length() != SIZE_IP4) {
+ return false;
+ }
+ if (!buf->ReadBytes(reinterpret_cast<char*>(&v4addr), sizeof(v4addr))) {
+ return false;
+ }
+ talk_base::IPAddress ipaddr(v4addr);
+ SetAddress(talk_base::SocketAddress(ipaddr, port));
+ } else if (stun_family == STUN_ADDRESS_IPV6) {
+ in6_addr v6addr;
+ if (length() != SIZE_IP6) {
+ return false;
+ }
+ if (!buf->ReadBytes(reinterpret_cast<char*>(&v6addr), sizeof(v6addr))) {
+ return false;
+ }
+ talk_base::IPAddress ipaddr(v6addr);
+ SetAddress(talk_base::SocketAddress(ipaddr, port));
+ } else {
return false;
-
+ }
return true;
}
void StunAddressAttribute::Write(ByteBuffer* buf) const {
- // Only IPv4 address family is currently supported.
- ASSERT(family_ == STUN_ADDRESS_IPV4);
-
+ StunAddressFamily address_family = family();
+ if (address_family == STUN_ADDRESS_UNDEF) {
+ LOG(LS_ERROR) << "Error writing address attribute: unknown family.";
+ return;
+ }
buf->WriteUInt8(0);
- buf->WriteUInt8(family_);
- buf->WriteUInt16(port_);
- buf->WriteUInt32(ip_);
+ buf->WriteUInt8(address_family);
+ buf->WriteUInt16(address_.port());
+ switch (address_family) {
+ case STUN_ADDRESS_IPV4: {
+ in_addr v4addr = address_.ipaddr().ipv4_address();
+ buf->WriteBytes(reinterpret_cast<char*>(&v4addr), sizeof(v4addr));
+ break;
+ }
+ case STUN_ADDRESS_IPV6: {
+ in6_addr v6addr = address_.ipaddr().ipv6_address();
+ buf->WriteBytes(reinterpret_cast<char*>(&v6addr), sizeof(v6addr));
+ break;
+ }
+ }
}
-StunXorAddressAttribute::StunXorAddressAttribute(uint16 type)
- : StunAddressAttribute(type) {
+StunXorAddressAttribute::StunXorAddressAttribute(uint16 type, uint16 length)
+ : StunAddressAttribute(type, length), owner_(NULL) { }
+
+StunXorAddressAttribute::StunXorAddressAttribute(uint16 type,
+ uint16 length,
+ StunMessage* owner)
+ : StunAddressAttribute(type, length), owner_(owner) { }
+
+talk_base::IPAddress StunXorAddressAttribute::GetXoredIP() const {
+ if (owner_) {
+ talk_base::IPAddress ip = ipaddr();
+ switch (ip.family()) {
+ case AF_INET: {
+ in_addr v4addr = ip.ipv4_address();
+ v4addr.s_addr =
+ (v4addr.s_addr ^ talk_base::HostToNetwork32(kStunMagicCookie));
+ return talk_base::IPAddress(v4addr);
+ break;
+ }
+ case AF_INET6: {
+ in6_addr v6addr = ip.ipv6_address();
+ const std::string& transaction_id = owner_->transaction_id();
+ if (transaction_id.length() == 12) {
+ uint32 transactionid_as_ints[3];
+ memcpy(&transactionid_as_ints[0], transaction_id.c_str(),
+ transaction_id.length());
+ uint32* ip_as_ints = reinterpret_cast<uint32*>(&v6addr.s6_addr);
+ // Transaction ID is in network byte order, but magic cookie
+ // is stored in host byte order.
+ ip_as_ints[0] =
+ (ip_as_ints[0] ^ talk_base::HostToNetwork32(kStunMagicCookie));
+ ip_as_ints[1] = (ip_as_ints[1] ^ transactionid_as_ints[0]);
+ ip_as_ints[2] = (ip_as_ints[2] ^ transactionid_as_ints[1]);
+ ip_as_ints[3] = (ip_as_ints[3] ^ transactionid_as_ints[2]);
+ return talk_base::IPAddress(v6addr);
+ }
+ break;
+ }
+ }
+ }
+ // Invalid ip family or transaction ID, or missing owner.
+ // Return an AF_UNSPEC address.
+ return talk_base::IPAddress();
}
bool StunXorAddressAttribute::Read(ByteBuffer* buf) {
if (!StunAddressAttribute::Read(buf))
return false;
-
- SetPort(port() ^ (kStunMagicCookie >> 16));
- SetIP(ip() ^ kStunMagicCookie);
-
+ uint16 xoredport = port() ^ (kStunMagicCookie >> 16);
+ talk_base::IPAddress xored_ip = GetXoredIP();
+ SetAddress(talk_base::SocketAddress(xored_ip, xoredport));
return true;
}
void StunXorAddressAttribute::Write(ByteBuffer* buf) const {
- // Only IPv4 address family is currently supported.
- ASSERT(family() == STUN_ADDRESS_IPV4);
-
+ StunAddressFamily address_family = family();
+ if (address_family == STUN_ADDRESS_UNDEF) {
+ LOG(LS_ERROR) << "Error writing xor-address attribute: unknown family.";
+ return;
+ }
buf->WriteUInt8(0);
buf->WriteUInt8(family());
buf->WriteUInt16(port() ^ (kStunMagicCookie >> 16));
- buf->WriteUInt32(ip() ^ kStunMagicCookie);
+ talk_base::IPAddress xored_ip = GetXoredIP();
+ switch (xored_ip.family()) {
+ case AF_INET: {
+ in_addr v4addr = xored_ip.ipv4_address();
+ buf->WriteBytes(reinterpret_cast<const char*>(&v4addr), sizeof(v4addr));
+ break;
+ }
+ case AF_INET6: {
+ in6_addr v6addr = xored_ip.ipv6_address();
+ buf->WriteBytes(reinterpret_cast<const char*>(&v6addr), sizeof(v6addr));
+ break;
+ }
+ }
}
StunUInt32Attribute::StunUInt32Attribute(uint16 type)
@@ -458,13 +564,18 @@
bool StunByteStringAttribute::Read(ByteBuffer* buf) {
bytes_ = new char[length()];
- if (!buf->ReadBytes(bytes_, length()))
+ if (!buf->ReadBytes(bytes_, length())) {
return false;
+ }
+
+ ConsumePadding(buf);
+
return true;
}
void StunByteStringAttribute::Write(ByteBuffer* buf) const {
buf->WriteBytes(bytes_, length());
+ WritePadding(buf);
}
StunErrorCodeAttribute::StunErrorCodeAttribute(uint16 type, uint16 length)
@@ -496,6 +607,7 @@
if (!buf->ReadString(&reason_, length() - 4))
return false;
+ ConsumePadding(buf);
return true;
}
@@ -503,6 +615,7 @@
void StunErrorCodeAttribute::Write(ByteBuffer* buf) const {
buf->WriteUInt32(error_code());
buf->WriteString(reason_);
+ WritePadding(buf);
}
StunUInt16ListAttribute::StunUInt16ListAttribute(uint16 type, uint16 length)
@@ -538,12 +651,20 @@
return false;
attr_types_->push_back(attr);
}
+ // Padding of these attributes is done in RFC 5389 style. This is
+ // slightly different from RFC3489, but it shouldn't be important.
+ // RFC3489 pads out to a 32 bit boundary by duplicating one of the
+ // entries in the list (not necessarily the last one - it's unspecified).
+ // RFC5389 pads on the end, and the bytes are always ignored.
+ ConsumePadding(buf);
return true;
}
void StunUInt16ListAttribute::Write(ByteBuffer* buf) const {
- for (unsigned i = 0; i < attr_types_->size(); i++)
+ for (size_t i = 0; i < attr_types_->size(); i++) {
buf->WriteUInt16((*attr_types_)[i]);
+ }
+ WritePadding(buf);
}
StunMessageType GetStunResponseType(StunMessageType request_type) {
@@ -572,4 +693,4 @@
}
}
-} // namespace cricket
+} // namespace cricket
diff --git a/talk/p2p/base/stun.h b/talk/p2p/base/stun.h
index efc5f2c..b8b470f 100644
--- a/talk/p2p/base/stun.h
+++ b/talk/p2p/base/stun.h
@@ -36,6 +36,7 @@
#include "talk/base/basictypes.h"
#include "talk/base/bytebuffer.h"
+#include "talk/base/socketaddress.h"
namespace cricket {
@@ -63,19 +64,19 @@
// implemented yet, particularly REALM, NONCE, SOFTWARE,
// ALTERNATE-SERVE and FINGEPRINT. Implement them.
enum StunAttributeType {
- STUN_ATTR_MAPPED_ADDRESS = 0x0001, // Address
- STUN_ATTR_USERNAME = 0x0006, // ByteString, multiple of 4 bytes
- STUN_ATTR_MESSAGE_INTEGRITY = 0x0008, // ByteString, 20 bytes
- STUN_ATTR_ERROR_CODE = 0x0009, // ErrorCode
- STUN_ATTR_UNKNOWN_ATTRIBUTES = 0x000a, // UInt16List
- STUN_ATTR_LIFETIME = 0x000d, // UInt32
- STUN_ATTR_MAGIC_COOKIE = 0x000f, // ByteString, 4 bytes
- STUN_ATTR_BANDWIDTH = 0x0010, // UInt32
- STUN_ATTR_DESTINATION_ADDRESS = 0x0011, // Address
- STUN_ATTR_SOURCE_ADDRESS2 = 0x0012, // Address
- STUN_ATTR_DATA = 0x0013, // ByteString
- STUN_ATTR_XOR_MAPPED_ADDRESS = 0x0020, // XorAddress
- STUN_ATTR_OPTIONS = 0x8001 // UInt32
+ STUN_ATTR_MAPPED_ADDRESS = 0x0001, // Address
+ STUN_ATTR_USERNAME = 0x0006, // ByteString, multiple of 4 bytes
+ STUN_ATTR_MESSAGE_INTEGRITY = 0x0008, // ByteString, 20 bytes
+ STUN_ATTR_ERROR_CODE = 0x0009, // ErrorCode
+ STUN_ATTR_UNKNOWN_ATTRIBUTES = 0x000a, // UInt16List
+ STUN_ATTR_LIFETIME = 0x000d, // UInt32
+ STUN_ATTR_MAGIC_COOKIE = 0x000f, // ByteString, 4 bytes
+ STUN_ATTR_BANDWIDTH = 0x0010, // UInt32
+ STUN_ATTR_DESTINATION_ADDRESS = 0x0011, // Address
+ STUN_ATTR_SOURCE_ADDRESS2 = 0x0012, // Address
+ STUN_ATTR_DATA = 0x0013, // ByteString
+ STUN_ATTR_XOR_MAPPED_ADDRESS = 0x0020, // XorAddress
+ STUN_ATTR_OPTIONS = 0x8001 // UInt32
};
enum StunErrorCodes {
@@ -91,6 +92,8 @@
};
enum StunAddressFamily {
+ // NB: UNDEF is not part of the STUN spec.
+ STUN_ADDRESS_UNDEF = 0,
STUN_ADDRESS_IPV4 = 1,
STUN_ADDRESS_IPV6 = 2
};
@@ -122,7 +125,7 @@
// appropriate class (see above). The Get* methods will return instances of
// that attribute class.
class StunMessage {
-public:
+ public:
StunMessage();
~StunMessage();
StunMessageType type() const { return static_cast<StunMessageType>(type_); }
@@ -137,7 +140,7 @@
bool IsLegacy() const;
void SetType(StunMessageType type) { type_ = type; }
- void SetTransactionID(const std::string& str);
+ bool SetTransactionID(const std::string& str);
const StunAddressAttribute* GetAddress(StunAttributeType type) const;
const StunUInt32Attribute* GetUInt32(StunAttributeType type) const;
@@ -156,7 +159,7 @@
// successful.
void Write(talk_base::ByteBuffer* buf) const;
-private:
+ private:
uint16 type_;
uint16 length_;
std::string transaction_id_;
@@ -168,7 +171,7 @@
// Base class for all STUN/TURN attributes.
class StunAttribute {
-public:
+ public:
virtual ~StunAttribute() {}
StunAttributeType type() const {
@@ -176,6 +179,9 @@
}
uint16 length() const { return length_; }
+ // Only XorAddressAttribute needs this so far.
+ virtual void SetOwner(StunMessage* owner) { }
+
// Reads the body (not the type or length) for this type of attribute from
// the given buffer. Return value is true if successful.
virtual bool Read(talk_base::ByteBuffer* buf) = 0;
@@ -184,8 +190,9 @@
// value is true if successful.
virtual void Write(talk_base::ByteBuffer* buf) const = 0;
- // Creates an attribute object with the given type and len.
- static StunAttribute* Create(uint16 type, uint16 length);
+ // Creates an attribute object with the given type, length and transaction id.
+ static StunAttribute* Create(uint16 type, uint16 length,
+ StunMessage* owner);
// Creates an attribute object with the given type and smallest length.
static StunAddressAttribute* CreateAddress(uint16 type);
@@ -195,52 +202,94 @@
static StunUInt16ListAttribute* CreateUnknownAttributes();
static StunTransportPrefsAttribute* CreateTransportPrefs();
-protected:
+ protected:
StunAttribute(uint16 type, uint16 length);
-
void SetLength(uint16 length) { length_ = length; }
+ void WritePadding(talk_base::ByteBuffer* buf) const;
+ void ConsumePadding(talk_base::ByteBuffer* buf) const;
-private:
+ private:
uint16 type_;
uint16 length_;
};
// Implements STUN/TURN attributes that record an Internet address.
class StunAddressAttribute : public StunAttribute {
-public:
- explicit StunAddressAttribute(uint16 type);
+ public:
+ StunAddressAttribute(uint16 type, uint16 length);
- static const uint16 SIZE = 8;
+ static const uint16 SIZE_UNDEF = 0;
+ static const uint16 SIZE_IP4 = 8;
+ static const uint16 SIZE_IP6 = 20;
- StunAddressFamily family() const { return family_; }
- uint16 port() const { return port_; }
- uint32 ip() const { return ip_; }
+ StunAddressFamily family() const {
+ switch (address_.ipaddr().family()) {
+ case AF_INET:
+ return STUN_ADDRESS_IPV4;
+ case AF_INET6:
+ return STUN_ADDRESS_IPV6;
+ }
+ return STUN_ADDRESS_UNDEF;
+ }
- void SetFamily(StunAddressFamily family);
- void SetIP(uint32 ip) { ip_ = ip; }
- void SetPort(uint16 port) { port_ = port; }
+ uint16 port() const { return address_.port(); }
+ const talk_base::IPAddress& ipaddr() const { return address_.ipaddr(); }
+ void SetAddress(const talk_base::SocketAddress& addr) {
+ address_ = addr;
+ EnsureAddressLength();
+ }
+ const talk_base::SocketAddress& GetAddress() const { return address_; }
+ void SetIP(const talk_base::IPAddress& ip) {
+ address_.SetIP(ip);
+ EnsureAddressLength();
+ }
+ void SetPort(uint16 port) { address_.SetPort(port); }
virtual bool Read(talk_base::ByteBuffer* buf);
virtual void Write(talk_base::ByteBuffer* buf) const;
-private:
- StunAddressFamily family_;
- uint16 port_;
- uint32 ip_;
+ private:
+ void EnsureAddressLength() {
+ switch (family()) {
+ case STUN_ADDRESS_IPV4: {
+ SetLength(SIZE_IP4);
+ break;
+ }
+ case STUN_ADDRESS_IPV6: {
+ SetLength(SIZE_IP6);
+ break;
+ }
+ default: {
+ SetLength(SIZE_UNDEF);
+ break;
+ }
+ }
+ }
+ talk_base::SocketAddress address_;
};
-// Implements STUN/TURN attributes that record an Internet address.
+// Implements STUN/TURN attributes that record an Internet address. When encoded
+// in a STUN message, the address contained in this attribute is XORed with the
+// transaction ID of the message.
class StunXorAddressAttribute : public StunAddressAttribute {
-public:
- explicit StunXorAddressAttribute(uint16 type);
+ public:
+ StunXorAddressAttribute(uint16 type, uint16 length);
+ StunXorAddressAttribute(uint16 type, uint16 length,
+ StunMessage* owner);
+ virtual void SetOwner(StunMessage* owner) {
+ owner_ = owner;
+ }
virtual bool Read(talk_base::ByteBuffer* buf);
virtual void Write(talk_base::ByteBuffer* buf) const;
+ private:
+ talk_base::IPAddress GetXoredIP() const;
+ StunMessage* owner_;
};
// Implements STUN/TURN attributs that record a 32-bit integer.
class StunUInt32Attribute : public StunAttribute {
-public:
+ public:
explicit StunUInt32Attribute(uint16 type);
static const uint16 SIZE = 4;
@@ -255,13 +304,13 @@
bool Read(talk_base::ByteBuffer* buf);
void Write(talk_base::ByteBuffer* buf) const;
-private:
+ private:
uint32 bits_;
};
-// Implements STUN/TURN attributs that record an arbitrary byte string
+// Implements STUN/TURN attributes that record an arbitrary byte string
class StunByteStringAttribute : public StunAttribute {
-public:
+ public:
StunByteStringAttribute(uint16 type, uint16 length);
~StunByteStringAttribute();
@@ -269,7 +318,7 @@
void SetBytes(char* bytes, uint16 length);
- void CopyBytes(const char* bytes); // uses strlen
+ void CopyBytes(const char* bytes); // uses strlen
void CopyBytes(const void* bytes, uint16 length);
uint8 GetByte(int index) const;
@@ -278,13 +327,13 @@
bool Read(talk_base::ByteBuffer* buf);
void Write(talk_base::ByteBuffer* buf) const;
-private:
+ private:
char* bytes_;
};
-// Implements STUN/TURN attributs that record an error code.
+// Implements STUN/TURN attributes that record an error code.
class StunErrorCodeAttribute : public StunAttribute {
-public:
+ public:
StunErrorCodeAttribute(uint16 type, uint16 length);
~StunErrorCodeAttribute();
@@ -303,15 +352,15 @@
bool Read(talk_base::ByteBuffer* buf);
void Write(talk_base::ByteBuffer* buf) const;
-private:
+ private:
uint8 class_;
uint8 number_;
std::string reason_;
};
-// Implements STUN/TURN attributs that record a list of attribute names.
+// Implements STUN/TURN attributes that record a list of attribute names.
class StunUInt16ListAttribute : public StunAttribute {
-public:
+ public:
StunUInt16ListAttribute(uint16 type, uint16 length);
~StunUInt16ListAttribute();
@@ -323,7 +372,7 @@
bool Read(talk_base::ByteBuffer* buf);
void Write(talk_base::ByteBuffer* buf) const;
-private:
+ private:
std::vector<uint16>* attr_types_;
};
@@ -339,6 +388,6 @@
// Returns the error response type for the given request type.
StunMessageType GetStunErrorResponseType(StunMessageType request_type);
-} // namespace cricket
+} // namespace cricket
#endif // TALK_P2P_BASE_STUN_H_
diff --git a/talk/p2p/base/stun_unittest.cc b/talk/p2p/base/stun_unittest.cc
new file mode 100644
index 0000000..1152bee
--- /dev/null
+++ b/talk/p2p/base/stun_unittest.cc
@@ -0,0 +1,997 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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 "talk/base/bytebuffer.h"
+#include "talk/base/gunit.h"
+#include "talk/base/logging.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/socketaddress.h"
+#include "talk/p2p/base/stun.h"
+
+namespace cricket {
+
+class StunTest : public ::testing::Test {
+ protected:
+ void CheckStunHeader(const StunMessage& msg, StunMessageType expected_type,
+ size_t expected_length) {
+ ASSERT_EQ(expected_type, msg.type());
+ ASSERT_EQ(expected_length, msg.length());
+ }
+
+ void CheckStunTransactionID(const StunMessage& msg,
+ const unsigned char* expectedID, size_t length) {
+ ASSERT_EQ(0, std::memcmp(msg.transaction_id().c_str(),
+ expectedID, length));
+ }
+
+ void CheckStunAddressAttribute(const StunAddressAttribute* addr,
+ StunAddressFamily expected_family,
+ int expected_port,
+ talk_base::IPAddress expected_address) {
+ ASSERT_EQ(expected_family, addr->family());
+ ASSERT_EQ(expected_port, addr->port());
+
+ if (addr->family() == STUN_ADDRESS_IPV4) {
+ in_addr v4_address = expected_address.ipv4_address();
+ in_addr stun_address = addr->ipaddr().ipv4_address();
+ ASSERT_EQ(0, std::memcmp(&v4_address, &stun_address,
+ sizeof(stun_address)));
+ } else if (addr->family() == STUN_ADDRESS_IPV6) {
+ in6_addr v6_address = expected_address.ipv6_address();
+ in6_addr stun_address = addr->ipaddr().ipv6_address();
+ ASSERT_EQ(0, std::memcmp(&v6_address, &stun_address,
+ sizeof(stun_address)));
+ } else {
+ ASSERT_TRUE(addr->family() == STUN_ADDRESS_IPV6 ||
+ addr->family() == STUN_ADDRESS_IPV4);
+ }
+ }
+
+ size_t ReadStunMessageTestCase(StunMessage* msg,
+ const unsigned char* testcase,
+ size_t size) {
+ const char* input = reinterpret_cast<const char*>(testcase);
+ talk_base::ByteBuffer buf(input, size);
+ if (msg->Read(&buf)) {
+ // Returns the size the stun message should report itself as being
+ return (size - 20);
+ } else {
+ return 0;
+ }
+ }
+};
+
+
+// Sample STUN packets with various attributes
+// Gathered by wiresharking pjproject's pjnath test programs
+// pjproject available at www.pjsip.org
+
+static const unsigned char kStunMessageWithIPv6MappedAddress[] = {
+ 0x00, 0x01, 0x00, 0x18, // message header
+ 0x21, 0x12, 0xa4, 0x42, // transaction id
+ 0x29, 0x1f, 0xcd, 0x7c,
+ 0xba, 0x58, 0xab, 0xd7,
+ 0xf2, 0x41, 0x01, 0x00,
+ 0x00, 0x01, 0x00, 0x14, // Address type (mapped), length
+ 0x00, 0x02, 0xb8, 0x81, // family (IPv6), port
+ 0x24, 0x01, 0xfa, 0x00, // an IPv6 address
+ 0x00, 0x04, 0x10, 0x00,
+ 0xbe, 0x30, 0x5b, 0xff,
+ 0xfe, 0xe5, 0x00, 0xc3
+};
+
+static const unsigned char kStunMessageWithIPv4MappedAddress[] = {
+ 0x01, 0x01, 0x00, 0x0c, // binding response, length 12
+ 0x21, 0x12, 0xa4, 0x42, // magic cookie
+ 0x29, 0x1f, 0xcd, 0x7c, // transaction ID
+ 0xba, 0x58, 0xab, 0xd7,
+ 0xf2, 0x41, 0x01, 0x00,
+ 0x00, 0x01, 0x00, 0x08, // Mapped, 8 byte length
+ 0x00, 0x01, 0x9d, 0xfc, // AF_INET, unxor-ed port
+ 0xac, 0x17, 0x44, 0xe6 // IPv4 address
+};
+
+// Test XOR-mapped IP addresses:
+static const unsigned char kStunMessageWithIPv6XorMappedAddress[] = {
+ 0x01, 0x01, 0x00, 0x18, // message header (binding response)
+ 0x21, 0x12, 0xa4, 0x42, // magic cookie (rfc5389)
+ 0xe3, 0xa9, 0x46, 0xe1, // transaction ID
+ 0x7c, 0x00, 0xc2, 0x62,
+ 0x54, 0x08, 0x01, 0x00,
+ 0x00, 0x20, 0x00, 0x14, // Address Type (XOR), length
+ 0x00, 0x02, 0xcb, 0x5b, // family, XOR-ed port
+ 0x05, 0x13, 0x5e, 0x42, // XOR-ed IPv6 address
+ 0xe3, 0xad, 0x56, 0xe1,
+ 0xc2, 0x30, 0x99, 0x9d,
+ 0xaa, 0xed, 0x01, 0xc3
+};
+
+static const unsigned char kStunMessageWithIPv4XorMappedAddress[] = {
+ 0x01, 0x01, 0x00, 0x0c, // message header (binding response)
+ 0x21, 0x12, 0xa4, 0x42, // magic cookie
+ 0x29, 0x1f, 0xcd, 0x7c, // transaction ID
+ 0xba, 0x58, 0xab, 0xd7,
+ 0xf2, 0x41, 0x01, 0x00,
+ 0x00, 0x20, 0x00, 0x08, // address type (xor), length
+ 0x00, 0x01, 0xfc, 0xb5, // family (AF_INET), XOR-ed port
+ 0x8d, 0x05, 0xe0, 0xa4 // IPv4 address
+};
+
+// ByteString Attribute (username)
+static const unsigned char kStunMessageWithByteStringAttribute[] = {
+ 0x00, 0x01, 0x00, 0x0c,
+ 0x21, 0x12, 0xa4, 0x42,
+ 0xe3, 0xa9, 0x46, 0xe1,
+ 0x7c, 0x00, 0xc2, 0x62,
+ 0x54, 0x08, 0x01, 0x00,
+ 0x00, 0x06, 0x00, 0x08, // username attribute (length 8)
+ 0x61, 0x62, 0x63, 0x64, // abcdefgh
+ 0x65, 0x66, 0x67, 0x68
+};
+
+// Message with an unknown but comprehensible optional attribute.
+// Parsing should succeed despite this unknown attribute.
+static const unsigned char kStunMessageWithUnknownAttribute[] = {
+ 0x00, 0x01, 0x00, 0x14,
+ 0x21, 0x12, 0xa4, 0x42,
+ 0xe3, 0xa9, 0x46, 0xe1,
+ 0x7c, 0x00, 0xc2, 0x62,
+ 0x54, 0x08, 0x01, 0x00,
+ 0x00, 0xaa, 0x00, 0x07, // Unknown attribute, length 7 (needs padding!)
+ 0x61, 0x62, 0x63, 0x64, // abcdefg + padding
+ 0x65, 0x66, 0x67, 0x00,
+ 0x00, 0x0d, 0x00, 0x04, // Followed by a known attribute we can
+ 0x00, 0x00, 0x00, 0x0b // check for.
+};
+
+// ByteString Attribute (username) with padding byte
+static const unsigned char kStunMessageWithPaddedByteStringAttribute[] = {
+ 0x00, 0x01, 0x00, 0x08,
+ 0x21, 0x12, 0xa4, 0x42,
+ 0xe3, 0xa9, 0x46, 0xe1,
+ 0x7c, 0x00, 0xc2, 0x62,
+ 0x54, 0x08, 0x01, 0x00,
+ 0x00, 0x06, 0x00, 0x03, // username attribute (length 3)
+ 0x61, 0x62, 0x63, 0xcc // abc
+};
+
+// Message with an Unknown Attributes (uint16 list) attribute.
+static const unsigned char kStunMessageWithUInt16ListAttribute[] = {
+ 0x00, 0x01, 0x00, 0x0c,
+ 0x21, 0x12, 0xa4, 0x42,
+ 0xe3, 0xa9, 0x46, 0xe1,
+ 0x7c, 0x00, 0xc2, 0x62,
+ 0x54, 0x08, 0x01, 0x00,
+ 0x00, 0x0a, 0x00, 0x06, // username attribute (length 6)
+ 0x00, 0x01, 0x10, 0x00, // three attributes plus padding
+ 0xAB, 0xCU, 0xBE, 0xEF
+};
+
+// Error response message (unauthorized)
+static const unsigned char kStunMessageWithErrorAttribute[] = {
+ 0x01, 0x13, 0x00, 0x14,
+ 0x21, 0x12, 0xa4, 0x42,
+ 0x29, 0x1f, 0xcd, 0x7c,
+ 0xba, 0x58, 0xab, 0xd7,
+ 0xf2, 0x41, 0x01, 0x00,
+ 0x00, 0x09, 0x00, 0x10,
+ 0x00, 0x00, 0x04, 0x01,
+ 0x55, 0x6e, 0x61, 0x75,
+ 0x74, 0x68, 0x6f, 0x72,
+ 0x69, 0x7a, 0x65, 0x64
+};
+
+// Message with an address attribute with an unknown address family,
+// and a byte string attribute. Check that we quit reading after the
+// bogus address family and don't read the username attribute.
+static const unsigned char kStunMessageWithInvalidAddressFamily[] = {
+ 0x01, 0x01, 0x00, 0x18, // binding response, length 24
+ 0x21, 0x12, 0xa4, 0x42, // magic cookie
+ 0x29, 0x1f, 0xcd, 0x7c, // transaction ID
+ 0xba, 0x58, 0xab, 0xd7,
+ 0xf2, 0x41, 0x01, 0x00,
+ 0x00, 0x01, 0x00, 0x08, // Mapped address, 4 byte length
+ 0x00, 0x09, 0xfe, 0xed, // Bogus address family (port unimportant).
+ 0xac, 0x17, 0x44, 0xe6, // Should be skipped.
+ 0x00, 0x06, 0x00, 0x08, // Username attribute (length 8)
+ 0x61, 0x62, 0x63, 0x64, // abcdefgh
+ 0x65, 0x66, 0x67, 0x68
+};
+
+// Message with an address attribute with an invalid address length.
+// Should fail to be read.
+static const unsigned char kStunMessageWithInvalidAddressLength[] = {
+ 0x01, 0x01, 0x00, 0x18, // binding response, length 24
+ 0x21, 0x12, 0xa4, 0x42, // magic cookie
+ 0x29, 0x1f, 0xcd, 0x7c, // transaction ID
+ 0xba, 0x58, 0xab, 0xd7,
+ 0xf2, 0x41, 0x01, 0x00,
+ 0x00, 0x01, 0x00, 0x0c, // Mapped address, 12 byte length
+ 0x00, 0x01, 0xfe, 0xed, // Claims to be AF_INET.
+ 0xac, 0x17, 0x44, 0xe6,
+ 0x00, 0x06, 0x00, 0x08
+};
+
+// Sample messages with an invalid length Field
+
+// The actual length in bytes of the invalid messages (including STUN header)
+static const int kRealLengthOfInvalidLengthTestCases = 32;
+
+static const unsigned char kStunMessageWithZeroLength[] = {
+ 0x00, 0x01, 0x00, 0x00, // length of 0 (last 2 bytes)
+ 0x21, 0x12, 0xA4, 0x42, // magic cookie
+ '0', '1', '2', '3', // transaction id
+ '4', '5', '6', '7',
+ '8', '9', 'a', 'b',
+ 0x00, 0x20, 0x00, 0x08, // xor mapped address
+ 0x00, 0x01, 0x21, 0x1F,
+ 0x21, 0x12, 0xA4, 0x53,
+};
+
+static const unsigned char kStunMessageWithExcessLength[] = {
+ 0x00, 0x01, 0x00, 0x55, // length of 85
+ 0x21, 0x12, 0xA4, 0x42, // magic cookie
+ '0', '1', '2', '3', // transaction id
+ '4', '5', '6', '7',
+ '8', '9', 'a', 'b',
+ 0x00, 0x20, 0x00, 0x08, // xor mapped address
+ 0x00, 0x01, 0x21, 0x1F,
+ 0x21, 0x12, 0xA4, 0x53,
+};
+
+static const unsigned char kStunMessageWithSmallLength[] = {
+ 0x00, 0x01, 0x00, 0x03, // length of 3
+ 0x21, 0x12, 0xA4, 0x42, // magic cookie
+ '0', '1', '2', '3', // transaction id
+ '4', '5', '6', '7',
+ '8', '9', 'a', 'b',
+ 0x00, 0x20, 0x00, 0x08, // xor mapped address
+ 0x00, 0x01, 0x21, 0x1F,
+ 0x21, 0x12, 0xA4, 0x53,
+};
+
+// Legacy STUN tests.
+// Included for completeness, but it's not recommended to change these.
+static const unsigned char kStunMessageWithManyAttributes[] = {
+ 0x00, 0x01, 0x00, 136, // message header
+ 0x21, 0x12, 0xA4, 0x42, // magic cookie
+ '0', '1', '2', '3', // transaction id
+ '4', '5', '6', '7',
+ '8', '9', 'a', 'b',
+ 0x00, 0x01, 0x00, 8, // mapped address
+ 0x00, 0x01, 0x00, 13,
+ 0x00, 0x00, 0x00, 17,
+ 0x00, 0x06, 0x00, 12, // username
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
+ 0x00, 0x08, 0x00, 20, // message integrity
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
+ 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
+ 0x00, 0x09, 0x00, 12, // error code
+ 0x00, 0x00, 2, 10,
+ 'f', 'o', 'o', ' ', 'b', 'a', 'r', '!',
+ 0x00, 0x0a, 0x00, 4, // unknown attributes
+ 0x00, 0x01, 0x00, 0x02,
+ 0x00, 0x0d, 0x00, 4, // lifetime
+ 0x00, 0x00, 0x00, 11,
+ 0x00, 0x0f, 0x00, 4, // magic cookie
+ 0x72, 0xc6, 0x4b, 0xc6,
+ 0x00, 0x10, 0x00, 4, // bandwidth
+ 0x00, 0x00, 0x00, 6,
+ 0x00, 0x11, 0x00, 8, // destination address
+ 0x00, 0x01, 0x00, 13,
+ 0x00, 0x00, 0x00, 17,
+ 0x00, 0x12, 0x00, 8, // source address 2
+ 0x00, 0x01, 0x00, 13,
+ 0x00, 0x00, 0x00, 17,
+ 0x00, 0x13, 0x00, 7, // data
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 0 // DATA must be padded per rfc5766.
+};
+
+// RTCP packet, for testing we correctly ignore non stun packet types.
+// V=2, P=false, RC=0, Type=200, Len=6, Sender-SSRC=85, etc
+static const unsigned char kRtcpPacket[] = {
+ 0x80, 0xc8, 0x00, 0x06, 0x00, 0x00, 0x00, 0x55,
+ 0xce, 0xa5, 0x18, 0x3a, 0x39, 0xcc, 0x7d, 0x09,
+ 0x23, 0xed, 0x19, 0x07, 0x00, 0x00, 0x01, 0x56,
+ 0x00, 0x03, 0x73, 0x50,
+};
+
+// A transaction ID without the 'magic cookie' portion
+// pjnat's test programs use this transaction ID a lot.
+const unsigned char kTestTransactionId1[] = { 0x029, 0x01f, 0x0cd, 0x07c,
+ 0x0ba, 0x058, 0x0ab, 0x0d7,
+ 0x0f2, 0x041, 0x001, 0x000 };
+
+// They use this one sometimes too.
+const unsigned char kTestTransactionId2[] = { 0x0e3, 0x0a9, 0x046, 0x0e1,
+ 0x07c, 0x000, 0x0c2, 0x062,
+ 0x054, 0x008, 0x001, 0x000 };
+
+const in6_addr kIPv6TestAddress1 = { { { 0x24, 0x01, 0xfa, 0x00,
+ 0x00, 0x04, 0x10, 0x00,
+ 0xbe, 0x30, 0x5b, 0xff,
+ 0xfe, 0xe5, 0x00, 0xc3 } } };
+const in6_addr kIPv6TestAddress2 = { { { 0x24, 0x01, 0xfa, 0x00,
+ 0x00, 0x04, 0x10, 0x12,
+ 0x06, 0x0c, 0xce, 0xff,
+ 0xfe, 0x1f, 0x61, 0xa4 } } };
+
+// This is kIPv6TestAddress1 xor-ed with kTestTransactionID2.
+const in6_addr kIPv6XoredTestAddress = { { { 0x05, 0x13, 0x5e, 0x42,
+ 0xe3, 0xad, 0x56, 0xe1,
+ 0xc2, 0x30, 0x99, 0x9d,
+ 0xaa, 0xed, 0x01, 0xc3 } } };
+
+#ifdef POSIX
+const in_addr kIPv4TestAddress1 = { 0xe64417ac };
+// This is kIPv4TestAddress xored with the STUN magic cookie.
+const in_addr kIPv4XoredTestAddress = { 0x8d05e0a4 };
+#elif defined WIN32
+// Windows in_addr has a union with a uchar[] array first.
+const in_addr kIPv4XoredTestAddress = { { 0x8d, 0x05, 0xe0, 0xa4 } };
+const in_addr kIPv4TestAddress1 = { { 0x0ac, 0x017, 0x044, 0x0e6 } };
+#endif
+const char kTestUserName1[] = "abcdefgh";
+const char kTestUserName2[] = "abc";
+const char kTestErrorReason[] = "Unauthorized";
+const int kTestErrorClass = 4;
+const int kTestErrorNumber = 1;
+
+const int kTestMessagePort1 = 59977;
+const int kTestMessagePort2 = 47233;
+const int kTestMessagePort3 = 56743;
+const int kTestMessagePort4 = 40444;
+
+#define ReadStunMessage(X, Y) ReadStunMessageTestCase(X, Y, sizeof(Y));
+
+TEST_F(StunTest, ReadMessageWithIPv4AddressAttribute) {
+ StunMessage msg;
+ size_t size = ReadStunMessage(&msg, kStunMessageWithIPv4MappedAddress);
+ CheckStunHeader(msg, STUN_BINDING_RESPONSE, size);
+ CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
+
+ const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
+ talk_base::IPAddress test_address(kIPv4TestAddress1);
+ CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV4,
+ kTestMessagePort4, test_address);
+}
+
+TEST_F(StunTest, ReadMessageWithIPv4XorAddressAttribute) {
+ StunMessage msg;
+ StunMessage msg2;
+ size_t size = ReadStunMessage(&msg, kStunMessageWithIPv4XorMappedAddress);
+ CheckStunHeader(msg, STUN_BINDING_RESPONSE, size);
+ CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
+
+ const StunAddressAttribute* addr =
+ msg.GetAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
+ talk_base::IPAddress test_address(kIPv4TestAddress1);
+ CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV4,
+ kTestMessagePort3, test_address);
+}
+
+TEST_F(StunTest, ReadMessageWithIPv6AddressAttribute) {
+ StunMessage msg;
+ size_t size = ReadStunMessage(&msg, kStunMessageWithIPv6MappedAddress);
+ CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
+ CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
+
+ talk_base::IPAddress test_address(kIPv6TestAddress1);
+
+ const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
+ CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV6,
+ kTestMessagePort2, test_address);
+}
+
+TEST_F(StunTest, ReadMessageWithInvalidAddressAttribute) {
+ StunMessage msg;
+ size_t size = ReadStunMessage(&msg, kStunMessageWithIPv6MappedAddress);
+ CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
+ CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
+
+ talk_base::IPAddress test_address(kIPv6TestAddress1);
+
+ const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
+ CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV6,
+ kTestMessagePort2, test_address);
+}
+
+TEST_F(StunTest, ReadMessageWithIPv6XorAddressAttribute) {
+ StunMessage msg;
+ size_t size = ReadStunMessage(&msg, kStunMessageWithIPv6XorMappedAddress);
+
+ talk_base::IPAddress test_address(kIPv6TestAddress1);
+
+ CheckStunHeader(msg, STUN_BINDING_RESPONSE, size);
+ CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
+
+ const StunAddressAttribute* addr =
+ msg.GetAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
+ CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV6,
+ kTestMessagePort1, test_address);
+}
+
+TEST_F(StunTest, SetIPv6XorAddressAttributeOwner) {
+ StunMessage msg;
+ StunMessage msg2;
+ size_t size = ReadStunMessage(&msg, kStunMessageWithIPv6XorMappedAddress);
+
+ talk_base::IPAddress test_address(kIPv6TestAddress1);
+
+ CheckStunHeader(msg, STUN_BINDING_RESPONSE, size);
+ CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
+
+ const StunAddressAttribute* addr =
+ msg.GetAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
+ CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV6,
+ kTestMessagePort1, test_address);
+
+ // Owner with a different transaction ID.
+ msg2.SetTransactionID("ABCDABCDABCD");
+ StunXorAddressAttribute addr2(STUN_ATTR_XOR_MAPPED_ADDRESS, 20);
+ addr2.SetIP(addr->ipaddr());
+ addr2.SetPort(addr->port());
+ addr2.SetOwner(&msg2);
+ // The internal IP address shouldn't change.
+ ASSERT_EQ(addr2.ipaddr(), addr->ipaddr());
+
+ talk_base::ByteBuffer correct_buf;
+ talk_base::ByteBuffer wrong_buf;
+ addr->Write(&correct_buf);
+ addr2.Write(&wrong_buf);
+ // But when written out, the buffers should look different.
+ ASSERT_NE(0, std::memcmp(correct_buf.Data(),
+ wrong_buf.Data(),
+ wrong_buf.Length()));
+ // And when reading a known good value, the address should be wrong
+ addr2.Read(&correct_buf);
+ ASSERT_NE(addr->ipaddr(), addr2.ipaddr());
+ addr2.SetIP(addr->ipaddr());
+ addr2.SetPort(addr->port());
+ // Try writing with no owner at all. Should write 4 bytes (1 byte reserved,
+ // 2 bytes port, 1 byte address family, 0 bytes address). This is an invalid
+ // but well-formed address attribute.
+ addr2.SetOwner(NULL);
+ ASSERT_EQ(addr2.ipaddr(), addr->ipaddr());
+ wrong_buf.Shift(wrong_buf.Length());
+ addr2.Write(&wrong_buf);
+ ASSERT_EQ(4U, wrong_buf.Length());
+ ASSERT_NE(wrong_buf.Length(), correct_buf.Length());
+ ASSERT_NE(0, std::memcmp(correct_buf.Data(),
+ wrong_buf.Data(),
+ wrong_buf.Length()));
+}
+
+TEST_F(StunTest, SetIPv4XorAddressAttributeOwner) {
+ // Unlike the IPv6XorAddressAttributeOwner test, IPv4 XOR address attributes
+ // should _not_ be affected by a change in owner. IPv4 XOR address uses the
+ // magic cookie value which is fixed.
+ StunMessage msg;
+ StunMessage msg2;
+ size_t size = ReadStunMessage(&msg, kStunMessageWithIPv4XorMappedAddress);
+
+ talk_base::IPAddress test_address(kIPv4TestAddress1);
+
+ CheckStunHeader(msg, STUN_BINDING_RESPONSE, size);
+ CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
+
+ const StunAddressAttribute* addr =
+ msg.GetAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
+ CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV4,
+ kTestMessagePort3, test_address);
+
+ // Owner with a different transaction ID.
+ msg2.SetTransactionID("ABCDABCDABCD");
+ StunXorAddressAttribute addr2(STUN_ATTR_XOR_MAPPED_ADDRESS, 20);
+ addr2.SetIP(addr->ipaddr());
+ addr2.SetPort(addr->port());
+ addr2.SetOwner(&msg2);
+ // The internal IP address shouldn't change.
+ ASSERT_EQ(addr2.ipaddr(), addr->ipaddr());
+
+ talk_base::ByteBuffer correct_buf;
+ talk_base::ByteBuffer wrong_buf;
+ addr->Write(&correct_buf);
+ addr2.Write(&wrong_buf);
+ // The same address data should be written.
+ ASSERT_EQ(0, std::memcmp(correct_buf.Data(),
+ wrong_buf.Data(),
+ wrong_buf.Length()));
+ // And an attribute should be able to un-XOR an address belonging to a message
+ // with a different transaction ID.
+ addr2.Read(&correct_buf);
+ ASSERT_EQ(addr->ipaddr(), addr2.ipaddr());
+
+ // However, no owner is still an error. Write 4 bytes and a 0 length address.
+ addr2.SetOwner(NULL);
+ ASSERT_EQ(addr2.ipaddr(), addr->ipaddr());
+ wrong_buf.Shift(wrong_buf.Length());
+ addr2.Write(&wrong_buf);
+ ASSERT_NE(wrong_buf.Length(), correct_buf.Length());
+ ASSERT_NE(0, std::memcmp(correct_buf.Data(),
+ wrong_buf.Data(),
+ wrong_buf.Length()));
+}
+
+TEST_F(StunTest, CreateIPv6AddressAttribute) {
+ talk_base::IPAddress test_ip(kIPv6TestAddress2);
+
+ StunAddressAttribute* addr =
+ StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
+ talk_base::SocketAddress test_addr(test_ip, kTestMessagePort2);
+ addr->SetAddress(test_addr);
+
+ CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV6,
+ kTestMessagePort2, test_ip);
+ delete addr;
+}
+
+TEST_F(StunTest, CreateIPv4AddressAttribute) {
+ struct in_addr test_in_addr;
+ test_in_addr.s_addr = 0xBEB0B0BE;
+ talk_base::IPAddress test_ip(test_in_addr);
+
+ StunAddressAttribute* addr =
+ StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
+ talk_base::SocketAddress test_addr(test_ip, kTestMessagePort2);
+ addr->SetAddress(test_addr);
+
+ CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV4,
+ kTestMessagePort2, test_ip);
+ delete addr;
+}
+
+TEST_F(StunTest, WriteMessageWithIPv6AddressAttribute) {
+ StunMessage msg;
+ size_t size = sizeof(kStunMessageWithIPv6MappedAddress);
+
+ talk_base::IPAddress test_ip(kIPv6TestAddress1);
+
+ msg.SetType(STUN_BINDING_REQUEST);
+ msg.SetTransactionID(
+ std::string(reinterpret_cast<const char*>(kTestTransactionId1),
+ kStunTransactionIdLength));
+ CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
+
+ StunAddressAttribute* addr =
+ StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
+ talk_base::SocketAddress test_addr(test_ip, kTestMessagePort2);
+ addr->SetAddress(test_addr);
+ msg.AddAttribute(addr);
+
+ CheckStunHeader(msg, STUN_BINDING_REQUEST, (size - 20));
+
+ talk_base::ByteBuffer out;
+ msg.Write(&out);
+ ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv6MappedAddress));
+ int len1 = out.Length();
+ std::string bytes;
+ out.ReadString(&bytes, len1);
+ ASSERT_EQ(0, std::memcmp(bytes.c_str(),
+ kStunMessageWithIPv6MappedAddress,
+ len1));
+}
+
+TEST_F(StunTest, WriteMessageWithIPv4AddressAttribute) {
+ StunMessage msg;
+ size_t size = sizeof(kStunMessageWithIPv4MappedAddress);
+
+ talk_base::IPAddress test_ip(kIPv4TestAddress1);
+
+ msg.SetType(STUN_BINDING_RESPONSE);
+ msg.SetTransactionID(
+ std::string(reinterpret_cast<const char*>(kTestTransactionId1),
+ kStunTransactionIdLength));
+ CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
+
+ StunAddressAttribute* addr =
+ StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
+ talk_base::SocketAddress test_addr(test_ip, kTestMessagePort4);
+ addr->SetAddress(test_addr);
+ msg.AddAttribute(addr);
+
+ CheckStunHeader(msg, STUN_BINDING_RESPONSE, (size - 20));
+
+ talk_base::ByteBuffer out;
+ msg.Write(&out);
+ ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv4MappedAddress));
+ int len1 = out.Length();
+ std::string bytes;
+ out.ReadString(&bytes, len1);
+ ASSERT_EQ(0, std::memcmp(bytes.c_str(),
+ kStunMessageWithIPv4MappedAddress,
+ len1));
+}
+
+TEST_F(StunTest, WriteMessageWithIPv6XorAddressAttribute) {
+ StunMessage msg;
+ size_t size = sizeof(kStunMessageWithIPv6XorMappedAddress);
+
+ talk_base::IPAddress test_ip(kIPv6TestAddress1);
+
+ msg.SetType(STUN_BINDING_RESPONSE);
+ msg.SetTransactionID(
+ std::string(reinterpret_cast<const char*>(kTestTransactionId2),
+ kStunTransactionIdLength));
+ CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
+
+ StunAddressAttribute* addr =
+ StunAttribute::CreateAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
+ talk_base::SocketAddress test_addr(test_ip, kTestMessagePort1);
+ addr->SetAddress(test_addr);
+ msg.AddAttribute(addr);
+
+ CheckStunHeader(msg, STUN_BINDING_RESPONSE, (size - 20));
+
+ talk_base::ByteBuffer out;
+ msg.Write(&out);
+ ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv6XorMappedAddress));
+ int len1 = out.Length();
+ std::string bytes;
+ out.ReadString(&bytes, len1);
+ ASSERT_EQ(0, std::memcmp(bytes.c_str(),
+ kStunMessageWithIPv6XorMappedAddress,
+ len1));
+}
+
+TEST_F(StunTest, WriteMessageWithIPv4XoreAddressAttribute) {
+ StunMessage msg;
+ size_t size = sizeof(kStunMessageWithIPv4XorMappedAddress);
+
+ talk_base::IPAddress test_ip(kIPv4TestAddress1);
+
+ msg.SetType(STUN_BINDING_RESPONSE);
+ msg.SetTransactionID(
+ std::string(reinterpret_cast<const char*>(kTestTransactionId1),
+ kStunTransactionIdLength));
+ CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
+
+ StunAddressAttribute* addr =
+ StunAttribute::CreateAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
+ talk_base::SocketAddress test_addr(test_ip, kTestMessagePort3);
+ addr->SetAddress(test_addr);
+ msg.AddAttribute(addr);
+
+ CheckStunHeader(msg, STUN_BINDING_RESPONSE, (size - 20));
+
+ talk_base::ByteBuffer out;
+ msg.Write(&out);
+ ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv4XorMappedAddress));
+ int len1 = out.Length();
+ std::string bytes;
+ out.ReadString(&bytes, len1);
+ ASSERT_EQ(0, std::memcmp(bytes.c_str(),
+ kStunMessageWithIPv4XorMappedAddress,
+ len1));
+}
+
+TEST_F(StunTest, ReadByteStringAttribute) {
+ StunMessage msg;
+ size_t size = ReadStunMessage(&msg, kStunMessageWithByteStringAttribute);
+
+ CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
+ CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
+ const StunByteStringAttribute* username =
+ msg.GetByteString(STUN_ATTR_USERNAME);
+ ASSERT_EQ(0, std::memcmp(kTestUserName1, username->bytes(),
+ username->length()));
+}
+
+TEST_F(StunTest, ReadPaddedByteStringAttribute) {
+ StunMessage msg;
+ size_t size = ReadStunMessage(&msg,
+ kStunMessageWithPaddedByteStringAttribute);
+ ASSERT_NE(0U, size);
+ CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
+ CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
+ const StunByteStringAttribute* username =
+ msg.GetByteString(STUN_ATTR_USERNAME);
+ ASSERT_EQ(0, std::memcmp(kTestUserName2, username->bytes(),
+ username->length()));
+}
+
+TEST_F(StunTest, ReadErrorCodeAttribute) {
+ StunMessage msg;
+ size_t size = ReadStunMessage(&msg, kStunMessageWithErrorAttribute);
+
+ CheckStunHeader(msg, STUN_ALLOCATE_ERROR_RESPONSE, size);
+ CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
+ const StunErrorCodeAttribute* errorcode = msg.GetErrorCode();
+ ASSERT_EQ(kTestErrorClass, errorcode->error_class());
+ ASSERT_EQ(kTestErrorNumber, errorcode->number());
+ std::string reason = errorcode->reason();
+ ASSERT_EQ(0, strcmp(reason.c_str(), kTestErrorReason));
+}
+
+TEST_F(StunTest, ReadMessageWithAnUnknownAttribute) {
+ StunMessage msg;
+ size_t size = ReadStunMessage(&msg, kStunMessageWithUnknownAttribute);
+ CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
+
+ // Parsing should have succeeded and there should be a lifetime attribute
+ const StunUInt32Attribute* uval = msg.GetUInt32(STUN_ATTR_LIFETIME);
+ EXPECT_TRUE(uval != NULL);
+ if (uval != NULL) {
+ EXPECT_EQ(11U, uval->value());
+ }
+}
+
+TEST_F(StunTest, ReadMessageWithAUInt16ListAttribute) {
+ StunMessage msg;
+ size_t size = ReadStunMessage(&msg, kStunMessageWithUInt16ListAttribute);
+ CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
+ const StunUInt16ListAttribute* types = msg.GetUnknownAttributes();
+ EXPECT_EQ(3U, types->Size());
+ EXPECT_EQ(0x1U, types->GetType(0));
+ EXPECT_EQ(0x1000U, types->GetType(1));
+ EXPECT_EQ(0xAB0CU, types->GetType(2));
+}
+
+TEST_F(StunTest, WriteMessageWithAUInt16ListAttribute) {
+ StunMessage msg;
+ size_t size = sizeof(kStunMessageWithUInt16ListAttribute);
+
+ msg.SetType(STUN_BINDING_REQUEST);
+ msg.SetTransactionID(
+ std::string(reinterpret_cast<const char*>(kTestTransactionId2),
+ kStunTransactionIdLength));
+ CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
+ StunUInt16ListAttribute* list = StunAttribute::CreateUnknownAttributes();
+ list->AddType(0x1U);
+ list->AddType(0x1000U);
+ list->AddType(0xAB0CU);
+ msg.AddAttribute(list);
+ CheckStunHeader(msg, STUN_BINDING_REQUEST, (size - 20));
+
+ talk_base::ByteBuffer out;
+ msg.Write(&out);
+ ASSERT_EQ(size, out.Length());
+ // Check everything up to the padding.
+ ASSERT_EQ(0, std::memcmp(out.Data(), kStunMessageWithUInt16ListAttribute,
+ size - 2));
+}
+
+void CheckFailureToRead(const unsigned char* testcase, size_t length) {
+ StunMessage msg;
+ const char* input = reinterpret_cast<const char*>(testcase);
+ talk_base::ByteBuffer buf(input, length);
+ ASSERT_FALSE(msg.Read(&buf));
+}
+
+TEST_F(StunTest, FailToReadInvalidMessages) {
+ CheckFailureToRead(kStunMessageWithZeroLength,
+ kRealLengthOfInvalidLengthTestCases);
+ CheckFailureToRead(kStunMessageWithSmallLength,
+ kRealLengthOfInvalidLengthTestCases);
+ CheckFailureToRead(kStunMessageWithExcessLength,
+ kRealLengthOfInvalidLengthTestCases);
+}
+
+#undef ReadStunMessage
+
+// Test that we don't care what order we set the parts of an address
+TEST_F(StunTest, CreateAddressInArbitraryOrder) {
+ StunAddressAttribute* addr =
+ StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
+ // Port first
+ addr->SetPort(kTestMessagePort1);
+ addr->SetIP(talk_base::IPAddress(kIPv4TestAddress1));
+ ASSERT_EQ(kTestMessagePort1, addr->port());
+ ASSERT_EQ(talk_base::IPAddress(kIPv4TestAddress1), addr->ipaddr());
+
+ StunAddressAttribute* addr2 =
+ StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
+ // IP first
+ addr2->SetIP(talk_base::IPAddress(kIPv4TestAddress1));
+ addr2->SetPort(kTestMessagePort2);
+ ASSERT_EQ(kTestMessagePort2, addr2->port());
+ ASSERT_EQ(talk_base::IPAddress(kIPv4TestAddress1), addr2->ipaddr());
+
+ delete addr;
+ delete addr2;
+}
+
+// Legacy test bodies
+static void DoTest(const char* input, size_t size, const char* transaction_id) {
+ StunMessage msg, msg2;
+ in_addr legacy_in_addr;
+ legacy_in_addr.s_addr = htonl(17U);
+ talk_base::IPAddress legacy_ip(legacy_in_addr);
+
+ talk_base::ByteBuffer buf(input, size);
+ EXPECT_TRUE(msg.Read(&buf));
+
+ EXPECT_EQ(STUN_BINDING_REQUEST, msg.type());
+ EXPECT_EQ(size - 20, msg.length());
+ EXPECT_EQ(transaction_id, msg.transaction_id());
+
+ msg2.SetType(STUN_BINDING_REQUEST);
+ msg2.SetTransactionID(transaction_id);
+
+ const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
+ ASSERT_TRUE(addr != NULL);
+ EXPECT_EQ(1, addr->family());
+ EXPECT_EQ(13, addr->port());
+ EXPECT_EQ(legacy_ip, addr->ipaddr());
+
+ StunAddressAttribute* addr2 =
+ StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
+ addr2->SetPort(13);
+ addr2->SetIP(legacy_ip);
+ msg2.AddAttribute(addr2);
+
+ const StunByteStringAttribute* bytes = msg.GetByteString(STUN_ATTR_USERNAME);
+ ASSERT_TRUE(bytes != NULL);
+ EXPECT_EQ(12, bytes->length());
+ EXPECT_EQ(0, std::memcmp(bytes->bytes(), "abcdefghijkl", bytes->length()));
+
+ StunByteStringAttribute* bytes2 =
+ StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
+ bytes2->CopyBytes("abcdefghijkl");
+ msg2.AddAttribute(bytes2);
+
+ bytes = msg.GetByteString(STUN_ATTR_MESSAGE_INTEGRITY);
+ ASSERT_TRUE(bytes != NULL);
+ EXPECT_EQ(20, bytes->length());
+ EXPECT_EQ(0, std::memcmp(bytes->bytes(),
+ "abcdefghijklmnopqrst",
+ bytes->length()));
+
+ bytes2 = StunAttribute::CreateByteString(STUN_ATTR_MESSAGE_INTEGRITY);
+ bytes2->CopyBytes("abcdefghijklmnopqrst");
+ msg2.AddAttribute(bytes2);
+
+ const StunErrorCodeAttribute* ecode = msg.GetErrorCode();
+ ASSERT_TRUE(ecode != NULL);
+ EXPECT_EQ(2, ecode->error_class());
+ EXPECT_EQ(10, ecode->number());
+ EXPECT_EQ("foo bar!", ecode->reason());
+
+ StunErrorCodeAttribute* ecode2 = StunAttribute::CreateErrorCode();
+ ecode2->SetErrorClass(2);
+ ecode2->SetNumber(10);
+ ecode2->SetReason("foo bar!");
+ msg2.AddAttribute(ecode2);
+
+ const StunUInt16ListAttribute* unknown = msg.GetUnknownAttributes();
+ ASSERT_TRUE(unknown != NULL);
+ EXPECT_EQ(2U, unknown->Size());
+ EXPECT_EQ(1U, unknown->GetType(0));
+ EXPECT_EQ(2U, unknown->GetType(1));
+
+ StunUInt16ListAttribute* unknown2 = StunAttribute::CreateUnknownAttributes();
+ unknown2->AddType(1);
+ unknown2->AddType(2);
+ msg2.AddAttribute(unknown2);
+
+ const StunUInt32Attribute* uval = msg.GetUInt32(STUN_ATTR_LIFETIME);
+ ASSERT_TRUE(uval != NULL);
+ EXPECT_EQ(11U, uval->value());
+
+ StunUInt32Attribute* uval2 = StunAttribute::CreateUInt32(STUN_ATTR_LIFETIME);
+ uval2->SetValue(11);
+ msg2.AddAttribute(uval2);
+
+ bytes = msg.GetByteString(STUN_ATTR_MAGIC_COOKIE);
+ ASSERT_TRUE(bytes != NULL);
+ EXPECT_EQ(4, bytes->length());
+ EXPECT_EQ(0, std::memcmp(bytes->bytes(), TURN_MAGIC_COOKIE_VALUE,
+ sizeof(TURN_MAGIC_COOKIE_VALUE)));
+
+ bytes2 = StunAttribute::CreateByteString(STUN_ATTR_MAGIC_COOKIE);
+ bytes2->CopyBytes(reinterpret_cast<const char*>(TURN_MAGIC_COOKIE_VALUE),
+ sizeof(TURN_MAGIC_COOKIE_VALUE));
+ msg2.AddAttribute(bytes2);
+
+ uval = msg.GetUInt32(STUN_ATTR_BANDWIDTH);
+ ASSERT_TRUE(uval != NULL);
+ EXPECT_EQ(6U, uval->value());
+
+ uval2 = StunAttribute::CreateUInt32(STUN_ATTR_BANDWIDTH);
+ uval2->SetValue(6);
+ msg2.AddAttribute(uval2);
+
+ addr = msg.GetAddress(STUN_ATTR_DESTINATION_ADDRESS);
+ ASSERT_TRUE(addr != NULL);
+ EXPECT_EQ(1, addr->family());
+ EXPECT_EQ(13, addr->port());
+ EXPECT_EQ(legacy_ip, addr->ipaddr());
+
+ addr2 = StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
+ addr2->SetPort(13);
+ addr2->SetIP(legacy_ip);
+ msg2.AddAttribute(addr2);
+
+ addr = msg.GetAddress(STUN_ATTR_SOURCE_ADDRESS2);
+ ASSERT_TRUE(addr != NULL);
+ EXPECT_EQ(1, addr->family());
+ EXPECT_EQ(13, addr->port());
+ EXPECT_EQ(legacy_ip, addr->ipaddr());
+
+ addr2 = StunAttribute::CreateAddress(STUN_ATTR_SOURCE_ADDRESS2);
+ addr2->SetPort(13);
+ addr2->SetIP(legacy_ip);
+ msg2.AddAttribute(addr2);
+
+ bytes = msg.GetByteString(STUN_ATTR_DATA);
+ ASSERT_TRUE(bytes != NULL);
+ EXPECT_EQ(7, bytes->length());
+ EXPECT_EQ(0, std::memcmp(bytes->bytes(), "abcdefg", bytes->length()));
+
+ bytes2 = StunAttribute::CreateByteString(STUN_ATTR_DATA);
+ bytes2->CopyBytes("abcdefg");
+ msg2.AddAttribute(bytes2);
+
+ talk_base::ByteBuffer out;
+ msg.Write(&out);
+ EXPECT_EQ(size, out.Length());
+ size_t len1 = out.Length();
+ std::string outstring;
+ out.ReadString(&outstring, len1);
+ EXPECT_EQ(0, std::memcmp(outstring.c_str(), input, len1));
+
+ talk_base::ByteBuffer out2;
+ msg2.Write(&out2);
+ EXPECT_EQ(size, out2.Length());
+ size_t len2 = out2.Length();
+ std::string outstring2;
+ out2.ReadString(&outstring2, len2);
+ EXPECT_EQ(0, std::memcmp(outstring2.c_str(), input, len2));
+}
+
+TEST_F(StunTest, TestStunPacket) {
+ DoTest(reinterpret_cast<const char*>(kStunMessageWithManyAttributes),
+ sizeof(kStunMessageWithManyAttributes),
+ "0123456789ab");
+}
+
+TEST_F(StunTest, TestRejectsRtcpPacket) {
+ StunMessage msg;
+
+ talk_base::ByteBuffer buf(
+ reinterpret_cast<const char*>(kRtcpPacket), sizeof(kRtcpPacket));
+ EXPECT_FALSE(msg.Read(&buf));
+}
+
+TEST_F(StunTest, TestLegacyPacket) {
+ // The RFC3489 packet in this test is the same as
+ // kStunMessageWithManyAttributes, but with a different value where the
+ // magic cookie was.
+ talk_base::scoped_array<char>
+ rfc3489_packet(new char[sizeof(kStunMessageWithManyAttributes)]);
+ memcpy(rfc3489_packet.get(), kStunMessageWithManyAttributes,
+ sizeof(kStunMessageWithManyAttributes));
+ // Overwrites the magic cookie here.
+ memcpy(&rfc3489_packet[4], &kStunMessageWithManyAttributes[8], 4);
+
+ DoTest(reinterpret_cast<const char*>(rfc3489_packet.get()),
+ sizeof(kStunMessageWithManyAttributes), "01230123456789ab");
+}
+
+} // namespace cricket
diff --git a/talk/p2p/base/stunport.cc b/talk/p2p/base/stunport.cc
index ba797ff..7328b99 100644
--- a/talk/p2p/base/stunport.cc
+++ b/talk/p2p/base/stunport.cc
@@ -66,7 +66,7 @@
} else if (addr_attr->family() != 1) {
LOG(LS_ERROR) << "Binding address has bad family";
} else {
- talk_base::SocketAddress addr(addr_attr->ip(), addr_attr->port());
+ talk_base::SocketAddress addr(addr_attr->ipaddr(), addr_attr->port());
port_->AddAddress(addr, "udp", true);
}
@@ -127,7 +127,7 @@
StunPort::StunPort(talk_base::Thread* thread,
talk_base::PacketSocketFactory* factory,
talk_base::Network* network,
- uint32 ip, int min_port, int max_port,
+ const talk_base::IPAddress& ip, int min_port, int max_port,
const talk_base::SocketAddress& server_addr)
: Port(thread, STUN_PORT_TYPE, factory, network, ip, min_port, max_port),
server_addr_(server_addr),
diff --git a/talk/p2p/base/stunport.h b/talk/p2p/base/stunport.h
index 26f46a5..c74ad4d 100644
--- a/talk/p2p/base/stunport.h
+++ b/talk/p2p/base/stunport.h
@@ -49,7 +49,8 @@
static StunPort* Create(talk_base::Thread* thread,
talk_base::PacketSocketFactory* factory,
talk_base::Network* network,
- uint32 ip, int min_port, int max_port,
+ const talk_base::IPAddress& ip,
+ int min_port, int max_port,
const talk_base::SocketAddress& server_addr) {
StunPort* port = new StunPort(thread, factory, network,
ip, min_port, max_port, server_addr);
@@ -88,7 +89,8 @@
protected:
StunPort(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
- talk_base::Network* network, uint32 ip, int min_port, int max_port,
+ talk_base::Network* network, const talk_base::IPAddress& ip,
+ int min_port, int max_port,
const talk_base::SocketAddress& server_addr);
bool Init();
diff --git a/talk/p2p/base/stunport_unittest.cc b/talk/p2p/base/stunport_unittest.cc
new file mode 100644
index 0000000..3d830ba
--- /dev/null
+++ b/talk/p2p/base/stunport_unittest.cc
@@ -0,0 +1,141 @@
+/*
+ * libjingle
+ * Copyright 2009 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/base/basicpacketsocketfactory.h"
+#include "talk/base/gunit.h"
+#include "talk/base/helpers.h"
+#include "talk/base/socketaddress.h"
+#include "talk/p2p/base/stunport.h"
+#include "talk/p2p/base/teststunserver.h"
+
+using talk_base::SocketAddress;
+
+static const SocketAddress kLocalAddr("127.0.0.1", 0);
+static const SocketAddress kStunAddr("127.0.0.1", 5000);
+static const SocketAddress kBadAddr("0.0.0.1", 5000);
+static const SocketAddress kStunHostnameAddr("localhost", 5000);
+static const SocketAddress kBadHostnameAddr("not-a-real-hostname", 5000);
+static const int kTimeoutMs = 10000;
+
+// Tests connecting a StunPort to a fake STUN server (cricket::StunServer)
+// TODO: Use a VirtualSocketServer here. We have to use a
+// PhysicalSocketServer right now since DNS is not part of SocketServer yet.
+class StunPortTest : public testing::Test,
+ public sigslot::has_slots<> {
+ public:
+ StunPortTest()
+ : network_("unittest", "unittest", talk_base::IPAddress(INADDR_ANY)),
+ socket_factory_(talk_base::Thread::Current()),
+ stun_server_(new cricket::TestStunServer(
+ talk_base::Thread::Current(), kStunAddr)),
+ done_(false), error_(false) {
+ }
+
+ const cricket::Port* port() const { return stun_port_.get(); }
+ bool done() const { return done_; }
+ bool error() const { return error_; }
+
+ void CreateStunPort(const talk_base::SocketAddress& server_addr) {
+ stun_port_.reset(cricket::StunPort::Create(
+ talk_base::Thread::Current(), &socket_factory_, &network_,
+ kLocalAddr.ipaddr(), 0, 0, server_addr));
+ stun_port_->SignalAddressReady.connect(this,
+ &StunPortTest::OnAddressReady);
+ stun_port_->SignalAddressError.connect(this,
+ &StunPortTest::OnAddressError);
+ }
+
+ void PrepareAddress() {
+ stun_port_->PrepareAddress();
+ }
+
+ protected:
+ static void SetUpTestCase() {
+ // Ensure the RNG is inited.
+ talk_base::InitRandom(NULL, 0);
+ }
+
+ void OnAddressReady(cricket::Port* port) {
+ done_ = true;
+ error_ = false;
+ }
+ void OnAddressError(cricket::Port* port) {
+ done_ = true;
+ error_ = true;
+ }
+
+ private:
+ talk_base::Network network_;
+ talk_base::BasicPacketSocketFactory socket_factory_;
+ talk_base::scoped_ptr<cricket::StunPort> stun_port_;
+ talk_base::scoped_ptr<cricket::TestStunServer> stun_server_;
+ bool done_;
+ bool error_;
+};
+
+// Test that we can create a STUN port
+TEST_F(StunPortTest, TestBasic) {
+ CreateStunPort(kStunAddr);
+ EXPECT_EQ("stun", port()->type());
+ EXPECT_EQ(0U, port()->candidates().size());
+}
+
+// Test that we can get an address from a STUN server.
+TEST_F(StunPortTest, TestPrepareAddress) {
+ CreateStunPort(kStunAddr);
+ PrepareAddress();
+ EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+ ASSERT_EQ(1U, port()->candidates().size());
+ EXPECT_TRUE(kLocalAddr.EqualIPs(port()->candidates()[0].address()));
+}
+
+// Test that we fail properly if we can't get an address.
+TEST_F(StunPortTest, TestPrepareAddressFail) {
+ CreateStunPort(kBadAddr);
+ PrepareAddress();
+ EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+ EXPECT_TRUE(error());
+ EXPECT_EQ(0U, port()->candidates().size());
+}
+
+// Test that we can get an address from a STUN server specified by a hostname.
+TEST_F(StunPortTest, TestPrepareAddressHostname) {
+ CreateStunPort(kStunHostnameAddr);
+ PrepareAddress();
+ EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+ ASSERT_EQ(1U, port()->candidates().size());
+ EXPECT_TRUE(kLocalAddr.EqualIPs(port()->candidates()[0].address()));
+}
+
+// Test that we handle hostname lookup failures properly.
+TEST_F(StunPortTest, TestPrepareAddressHostnameFail) {
+ CreateStunPort(kBadHostnameAddr);
+ PrepareAddress();
+ EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+ EXPECT_TRUE(error());
+ EXPECT_EQ(0U, port()->candidates().size());
+}
diff --git a/talk/p2p/base/stunrequest_unittest.cc b/talk/p2p/base/stunrequest_unittest.cc
new file mode 100644
index 0000000..524c5e6
--- /dev/null
+++ b/talk/p2p/base/stunrequest_unittest.cc
@@ -0,0 +1,225 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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/base/gunit.h"
+#include "talk/base/helpers.h"
+#include "talk/base/logging.h"
+#include "talk/base/timeutils.h"
+#include "talk/p2p/base/stunrequest.h"
+
+using namespace cricket;
+
+class StunRequestTest : public testing::Test,
+ public sigslot::has_slots<> {
+ public:
+ static void SetUpTestCase() {
+ talk_base::InitRandom(NULL, 0);
+ }
+ StunRequestTest()
+ : manager_(talk_base::Thread::Current()),
+ request_count_(0), response_(NULL),
+ success_(false), failure_(false), timeout_(false) {
+ manager_.SignalSendPacket.connect(this, &StunRequestTest::OnSendPacket);
+ }
+
+ void OnSendPacket(const void* data, size_t size, StunRequest* req) {
+ request_count_++;
+ }
+
+ void OnResponse(StunMessage* res) {
+ response_ = res;
+ success_ = true;
+ }
+ void OnErrorResponse(StunMessage* res) {
+ response_ = res;
+ failure_ = true;
+ }
+ void OnTimeout() {
+ timeout_ = true;
+ }
+
+ protected:
+ static StunMessage* CreateStunMessage(StunMessageType type,
+ StunMessage* req) {
+ StunMessage* msg = new StunMessage();
+ msg->SetType(type);
+ if (req) {
+ msg->SetTransactionID(req->transaction_id());
+ } else {
+ msg->SetTransactionID(
+ talk_base::CreateRandomString(kStunTransactionIdLength));
+ }
+ return msg;
+ }
+ static int TotalDelay(int sends) {
+ int total = 0;
+ for (int i = 0; i < sends; i++) {
+ if (i < 4)
+ total += 100 << i;
+ else
+ total += 1600;
+ }
+ return total;
+ }
+
+ StunRequestManager manager_;
+ int request_count_;
+ StunMessage* response_;
+ bool success_;
+ bool failure_;
+ bool timeout_;
+};
+
+// Forwards results to the test class.
+class StunRequestThunker : public StunRequest {
+ public:
+ StunRequestThunker(StunMessage* msg, StunRequestTest* test)
+ : StunRequest(msg), test_(test) {}
+ explicit StunRequestThunker(StunRequestTest* test) : test_(test) {}
+ private:
+ virtual void OnResponse(StunMessage* res) {
+ test_->OnResponse(res);
+ }
+ virtual void OnErrorResponse(StunMessage* res) {
+ test_->OnErrorResponse(res);
+ }
+ virtual void OnTimeout() {
+ test_->OnTimeout();
+ }
+
+ virtual void Prepare(StunMessage* request) {
+ request->SetType(STUN_BINDING_REQUEST);
+ }
+
+ StunRequestTest* test_;
+};
+
+// Test handling of a normal binding response.
+TEST_F(StunRequestTest, TestSuccess) {
+ StunMessage* req = CreateStunMessage(STUN_BINDING_REQUEST, NULL);
+ StunMessage* res = CreateStunMessage(STUN_BINDING_RESPONSE, req);
+
+ manager_.Send(new StunRequestThunker(req, this));
+ EXPECT_TRUE(manager_.CheckResponse(res));
+
+ EXPECT_TRUE(response_ == res);
+ EXPECT_TRUE(success_);
+ EXPECT_FALSE(failure_);
+ EXPECT_FALSE(timeout_);
+ delete res;
+}
+
+// Test handling of an error binding response.
+TEST_F(StunRequestTest, TestError) {
+ StunMessage* req = CreateStunMessage(STUN_BINDING_REQUEST, NULL);
+ StunMessage* res = CreateStunMessage(STUN_BINDING_ERROR_RESPONSE, req);
+
+ manager_.Send(new StunRequestThunker(req, this));
+ EXPECT_TRUE(manager_.CheckResponse(res));
+
+ EXPECT_TRUE(response_ == res);
+ EXPECT_FALSE(success_);
+ EXPECT_TRUE(failure_);
+ EXPECT_FALSE(timeout_);
+ delete res;
+}
+
+// Test handling of a binding response with the wrong transaction id.
+TEST_F(StunRequestTest, TestUnexpected) {
+ StunMessage* req = CreateStunMessage(STUN_BINDING_REQUEST, NULL);
+ StunMessage* res = CreateStunMessage(STUN_BINDING_RESPONSE, NULL);
+
+ manager_.Send(new StunRequestThunker(req, this));
+ EXPECT_FALSE(manager_.CheckResponse(res));
+
+ EXPECT_TRUE(response_ == NULL);
+ EXPECT_FALSE(success_);
+ EXPECT_FALSE(failure_);
+ EXPECT_FALSE(timeout_);
+ delete res;
+}
+
+// Test that requests are sent at the right times, and that the 9th request
+// (sent at 7900 ms) can be properly replied to.
+TEST_F(StunRequestTest, TestBackoff) {
+ StunMessage* req = CreateStunMessage(STUN_BINDING_REQUEST, NULL);
+ StunMessage* res = CreateStunMessage(STUN_BINDING_RESPONSE, req);
+
+ uint32 start = talk_base::Time();
+ manager_.Send(new StunRequestThunker(req, this));
+ for (int i = 0; i < 9; ++i) {
+ while (request_count_ == i)
+ talk_base::Thread::Current()->ProcessMessages(1);
+ int32 elapsed = talk_base::TimeSince(start);
+ LOG(LS_INFO) << "STUN request #" << (i + 1)
+ << " sent at " << elapsed << " ms";
+ EXPECT_GE(TotalDelay(i + 1), elapsed);
+ }
+ EXPECT_TRUE(manager_.CheckResponse(res));
+
+ EXPECT_TRUE(response_ == res);
+ EXPECT_TRUE(success_);
+ EXPECT_FALSE(failure_);
+ EXPECT_FALSE(timeout_);
+ delete res;
+}
+
+// Test that we timeout properly if no response is received in 9500 ms.
+TEST_F(StunRequestTest, TestTimeout) {
+ StunMessage* req = CreateStunMessage(STUN_BINDING_REQUEST, NULL);
+ StunMessage* res = CreateStunMessage(STUN_BINDING_RESPONSE, req);
+
+ manager_.Send(new StunRequestThunker(req, this));
+ talk_base::Thread::Current()->ProcessMessages(10000); // > STUN timeout
+ EXPECT_FALSE(manager_.CheckResponse(res));
+
+ EXPECT_TRUE(response_ == NULL);
+ EXPECT_FALSE(success_);
+ EXPECT_FALSE(failure_);
+ EXPECT_TRUE(timeout_);
+ delete res;
+}
+
+// Regression test for specific crash where we receive a response with the
+// same id as a request that doesn't have an underlying StunMessage yet.
+TEST_F(StunRequestTest, TestNoEmptyRequest) {
+ StunRequestThunker* request = new StunRequestThunker(this);
+
+ manager_.SendDelayed(request, 100);
+
+ StunMessage dummy_req;
+ dummy_req.SetTransactionID(request->id());
+ StunMessage* res = CreateStunMessage(STUN_BINDING_RESPONSE, &dummy_req);
+
+ EXPECT_TRUE(manager_.CheckResponse(res));
+
+ EXPECT_TRUE(response_ == res);
+ EXPECT_TRUE(success_);
+ EXPECT_FALSE(failure_);
+ EXPECT_FALSE(timeout_);
+ delete res;
+}
diff --git a/talk/p2p/base/stunserver.cc b/talk/p2p/base/stunserver.cc
index f34fd2d..8a5d447 100644
--- a/talk/p2p/base/stunserver.cc
+++ b/talk/p2p/base/stunserver.cc
@@ -96,7 +96,7 @@
mapped_addr = StunAttribute::CreateAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
}
mapped_addr->SetPort(remote_addr.port());
- mapped_addr->SetIP(remote_addr.ip());
+ mapped_addr->SetIP(remote_addr.ipaddr());
response.AddAttribute(mapped_addr);
// TODO: Add username and message-integrity.
diff --git a/talk/p2p/base/stunserver_unittest.cc b/talk/p2p/base/stunserver_unittest.cc
new file mode 100644
index 0000000..b7f2f00
--- /dev/null
+++ b/talk/p2p/base/stunserver_unittest.cc
@@ -0,0 +1,129 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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 "talk/base/gunit.h"
+#include "talk/base/logging.h"
+#include "talk/base/physicalsocketserver.h"
+#include "talk/base/virtualsocketserver.h"
+#include "talk/base/testclient.h"
+#include "talk/base/thread.h"
+#include "talk/p2p/base/stunserver.h"
+
+using namespace cricket;
+
+static const talk_base::SocketAddress server_addr("99.99.99.1", 3478);
+static const talk_base::SocketAddress client_addr("1.2.3.4", 1234);
+
+class StunServerTest : public testing::Test {
+ public:
+ StunServerTest()
+ : pss_(new talk_base::PhysicalSocketServer),
+ ss_(new talk_base::VirtualSocketServer(pss_.get())),
+ worker_(ss_.get()) {
+ }
+ virtual void SetUp() {
+ server_.reset(new StunServer(
+ talk_base::AsyncUDPSocket::Create(ss_.get(), server_addr)));
+ client_.reset(new talk_base::TestClient(
+ talk_base::AsyncUDPSocket::Create(ss_.get(), client_addr)));
+
+ worker_.Start();
+ }
+ void Send(const StunMessage& msg) {
+ talk_base::ByteBuffer buf;
+ msg.Write(&buf);
+ Send(buf.Data(), buf.Length());
+ }
+ void Send(const char* buf, int len) {
+ client_->SendTo(buf, len, server_addr);
+ }
+ StunMessage* Receive() {
+ StunMessage* msg = NULL;
+ talk_base::TestClient::Packet* packet = client_->NextPacket();
+ if (packet) {
+ talk_base::ByteBuffer buf(packet->buf, packet->size);
+ msg = new StunMessage();
+ msg->Read(&buf);
+ delete packet;
+ }
+ return msg;
+ }
+ private:
+ talk_base::scoped_ptr<talk_base::PhysicalSocketServer> pss_;
+ talk_base::scoped_ptr<talk_base::VirtualSocketServer> ss_;
+ talk_base::Thread worker_;
+ talk_base::scoped_ptr<StunServer> server_;
+ talk_base::scoped_ptr<talk_base::TestClient> client_;
+};
+
+TEST_F(StunServerTest, TestGood) {
+ StunMessage req;
+ std::string transaction_id = "0123456789ab";
+ req.SetType(STUN_BINDING_REQUEST);
+ req.SetTransactionID(transaction_id);
+ Send(req);
+
+ StunMessage* msg = Receive();
+ ASSERT_TRUE(msg != NULL);
+ EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
+ EXPECT_EQ(req.transaction_id(), msg->transaction_id());
+
+ const StunAddressAttribute* mapped_addr =
+ msg->GetAddress(STUN_ATTR_MAPPED_ADDRESS);
+ EXPECT_TRUE(mapped_addr != NULL);
+ EXPECT_EQ(1, mapped_addr->family());
+ EXPECT_EQ(client_addr.port(), mapped_addr->port());
+ if (mapped_addr->ipaddr() != client_addr.ipaddr()) {
+ LOG(LS_WARNING) << "Warning: mapped IP ("
+ << mapped_addr->ipaddr()
+ << ") != local IP (" << client_addr.ipaddr()
+ << ")";
+ }
+
+ delete msg;
+}
+
+TEST_F(StunServerTest, TestBad) {
+ const char* bad = "this is a completely nonsensical message whose only "
+ "purpose is to make the parser go 'ack'. it doesn't "
+ "look anything like a normal stun message";
+ Send(bad, std::strlen(bad));
+
+ StunMessage* msg = Receive();
+ ASSERT_TRUE(msg != NULL);
+ EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type());
+
+ const StunErrorCodeAttribute* err = msg->GetErrorCode();
+ EXPECT_TRUE(err != NULL);
+ EXPECT_EQ(4, err->error_class());
+ EXPECT_EQ(0, err->number());
+ EXPECT_EQ("Bad Request", err->reason());
+
+ delete msg;
+}
diff --git a/talk/p2p/base/tcpport.cc b/talk/p2p/base/tcpport.cc
index 555ba73..4db4761 100644
--- a/talk/p2p/base/tcpport.cc
+++ b/talk/p2p/base/tcpport.cc
@@ -35,7 +35,7 @@
TCPPort::TCPPort(talk_base::Thread* thread,
talk_base::PacketSocketFactory* factory,
- talk_base::Network* network, uint32 ip,
+ talk_base::Network* network, const talk_base::IPAddress& ip,
int min_port, int max_port, bool allow_listen)
: Port(thread, LOCAL_PORT_TYPE, factory, network, ip, min_port, max_port),
incoming_only_(false),
@@ -218,7 +218,7 @@
}
} else {
// Incoming connections should match the network address.
- ASSERT(socket_->GetLocalAddress().ip() == port->ip_);
+ ASSERT(socket_->GetLocalAddress().ipaddr() == port->ip_);
}
if (socket_) {
diff --git a/talk/p2p/base/tcpport.h b/talk/p2p/base/tcpport.h
index 8345b12..5ce917d 100644
--- a/talk/p2p/base/tcpport.h
+++ b/talk/p2p/base/tcpport.h
@@ -50,7 +50,8 @@
static TCPPort* Create(talk_base::Thread* thread,
talk_base::PacketSocketFactory* factory,
talk_base::Network* network,
- uint32 ip, int min_port, int max_port,
+ const talk_base::IPAddress& ip,
+ int min_port, int max_port,
bool allow_listen) {
TCPPort* port = new TCPPort(thread, factory, network,
ip, min_port, max_port, allow_listen);
@@ -73,8 +74,8 @@
protected:
TCPPort(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
- talk_base::Network* network, uint32 ip, int min_port, int max_port,
- bool allow_listen);
+ talk_base::Network* network, const talk_base::IPAddress& ip,
+ int min_port, int max_port, bool allow_listen);
bool Init();
// Handles sending using the local TCP socket.
diff --git a/talk/p2p/base/testrelayserver.h b/talk/p2p/base/testrelayserver.h
new file mode 100644
index 0000000..45c2b7c
--- /dev/null
+++ b/talk/p2p/base/testrelayserver.h
@@ -0,0 +1,118 @@
+/*
+ * libjingle
+ * Copyright 2008 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_P2P_BASE_TESTRELAYSERVER_H_
+#define TALK_P2P_BASE_TESTRELAYSERVER_H_
+
+#include "talk/base/asynctcpsocket.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/socketadapters.h"
+#include "talk/base/sigslot.h"
+#include "talk/base/thread.h"
+#include "talk/p2p/base/relayserver.h"
+
+namespace cricket {
+
+// A test relay server. Useful for unit tests.
+class TestRelayServer : public sigslot::has_slots<> {
+ public:
+ TestRelayServer(talk_base::Thread* thread,
+ const talk_base::SocketAddress& udp_int_addr,
+ const talk_base::SocketAddress& udp_ext_addr,
+ const talk_base::SocketAddress& tcp_int_addr,
+ const talk_base::SocketAddress& tcp_ext_addr,
+ const talk_base::SocketAddress& ssl_int_addr,
+ const talk_base::SocketAddress& ssl_ext_addr)
+ : server_(thread) {
+ server_.AddInternalSocket(talk_base::AsyncUDPSocket::Create(
+ thread->socketserver(), udp_int_addr));
+ server_.AddExternalSocket(talk_base::AsyncUDPSocket::Create(
+ thread->socketserver(), udp_ext_addr));
+
+ tcp_int_socket_.reset(CreateListenSocket(thread, tcp_int_addr));
+ tcp_ext_socket_.reset(CreateListenSocket(thread, tcp_ext_addr));
+ ssl_int_socket_.reset(CreateListenSocket(thread, ssl_int_addr));
+ ssl_ext_socket_.reset(CreateListenSocket(thread, ssl_ext_addr));
+ }
+ int GetConnectionCount() const {
+ return server_.GetConnectionCount();
+ }
+ talk_base::SocketAddressPair GetConnection(int connection) const {
+ return server_.GetConnection(connection);
+ }
+ bool HasConnection(const talk_base::SocketAddress& address) const {
+ return server_.HasConnection(address);
+ }
+
+ private:
+ talk_base::AsyncSocket* CreateListenSocket(talk_base::Thread* thread,
+ const talk_base::SocketAddress& addr) {
+ talk_base::AsyncSocket* socket =
+ thread->socketserver()->CreateAsyncSocket(SOCK_STREAM);
+ socket->Bind(addr);
+ socket->Listen(5);
+ socket->SignalReadEvent.connect(this, &TestRelayServer::OnAccept);
+ return socket;
+ }
+ void OnAccept(talk_base::AsyncSocket* socket) {
+ bool external = (socket == tcp_ext_socket_.get() ||
+ socket == ssl_ext_socket_.get());
+ bool ssl = (socket == ssl_int_socket_.get() ||
+ socket == ssl_ext_socket_.get());
+ talk_base::AsyncSocket* raw_socket = socket->Accept(NULL);
+ if (raw_socket) {
+ talk_base::AsyncTCPSocket* packet_socket = new talk_base::AsyncTCPSocket(
+ (!ssl) ? raw_socket :
+ new talk_base::AsyncSSLServerSocket(raw_socket), false);
+ if (!external) {
+ packet_socket->SignalClose.connect(this,
+ &TestRelayServer::OnInternalClose);
+ server_.AddInternalSocket(packet_socket);
+ } else {
+ packet_socket->SignalClose.connect(this,
+ &TestRelayServer::OnExternalClose);
+ server_.AddExternalSocket(packet_socket);
+ }
+ }
+ }
+ void OnInternalClose(talk_base::AsyncPacketSocket* socket, int error) {
+ server_.RemoveInternalSocket(socket);
+ }
+ void OnExternalClose(talk_base::AsyncPacketSocket* socket, int error) {
+ server_.RemoveExternalSocket(socket);
+ }
+ private:
+ cricket::RelayServer server_;
+ talk_base::scoped_ptr<talk_base::AsyncSocket> tcp_int_socket_;
+ talk_base::scoped_ptr<talk_base::AsyncSocket> tcp_ext_socket_;
+ talk_base::scoped_ptr<talk_base::AsyncSocket> ssl_int_socket_;
+ talk_base::scoped_ptr<talk_base::AsyncSocket> ssl_ext_socket_;
+};
+
+} // namespace cricket
+
+#endif // TALK_P2P_BASE_TESTRELAYSERVER_H_
diff --git a/talk/p2p/base/teststunserver.h b/talk/p2p/base/teststunserver.h
new file mode 100644
index 0000000..4574bf8
--- /dev/null
+++ b/talk/p2p/base/teststunserver.h
@@ -0,0 +1,54 @@
+/*
+ * libjingle
+ * Copyright 2008 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_P2P_BASE_TESTSTUNSERVER_H_
+#define TALK_P2P_BASE_TESTSTUNSERVER_H_
+
+#include "talk/base/socketaddress.h"
+#include "talk/base/thread.h"
+#include "talk/p2p/base/stunserver.h"
+
+namespace cricket {
+
+// A test STUN server. Useful for unit tests.
+class TestStunServer {
+ public:
+ TestStunServer(talk_base::Thread* thread,
+ const talk_base::SocketAddress& addr)
+ : socket_(thread->socketserver()->CreateAsyncSocket(SOCK_DGRAM)),
+ udp_socket_(talk_base::AsyncUDPSocket::Create(socket_, addr)),
+ server_(udp_socket_) {
+ }
+ private:
+ talk_base::AsyncSocket* socket_;
+ talk_base::AsyncUDPSocket* udp_socket_;
+ cricket::StunServer server_;
+};
+
+} // namespace cricket
+
+#endif // TALK_P2P_BASE_TESTSTUNSERVER_H_
diff --git a/talk/p2p/base/transport_unittest.cc b/talk/p2p/base/transport_unittest.cc
new file mode 100644
index 0000000..7718484
--- /dev/null
+++ b/talk/p2p/base/transport_unittest.cc
@@ -0,0 +1,69 @@
+/*
+ * 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/base/gunit.h"
+#include "talk/base/thread.h"
+#include "talk/p2p/base/p2ptransport.h"
+
+class TransportTest : public testing::Test,
+ public sigslot::has_slots<> {
+ public:
+ TransportTest()
+ : thread_(talk_base::Thread::Current()),
+ transport_(new cricket::P2PTransport(thread_, thread_, NULL)),
+ connecting_signalled_(false) {
+ transport_->SignalConnecting.connect(this, &TransportTest::OnConnecting);
+ }
+
+ protected:
+ void OnConnecting(cricket::Transport* transport) {
+ connecting_signalled_ = true;
+ }
+
+ talk_base::Thread* thread_;
+ talk_base::scoped_ptr<cricket::P2PTransport> transport_;
+ bool connecting_signalled_;
+};
+
+TEST_F(TransportTest, TestDestroyAllClearsPosts) {
+ EXPECT_TRUE(transport_->CreateChannel("test", "media") != NULL);
+
+ transport_->ConnectChannels();
+ transport_->DestroyAllChannels();
+
+ thread_->ProcessMessages(0);
+ EXPECT_FALSE(connecting_signalled_);
+}
+
+TEST_F(TransportTest, TestConnectChannelsDoesSignal) {
+ EXPECT_TRUE(transport_->CreateChannel("test", "media") != NULL);
+ transport_->ConnectChannels();
+ EXPECT_FALSE(connecting_signalled_);
+
+ EXPECT_TRUE_WAIT(connecting_signalled_, 100);
+}
+
diff --git a/talk/p2p/base/transportchannel.h b/talk/p2p/base/transportchannel.h
index 2672e80..74d0107 100644
--- a/talk/p2p/base/transportchannel.h
+++ b/talk/p2p/base/transportchannel.h
@@ -47,6 +47,8 @@
readable_(false), writable_(false) {}
virtual ~TransportChannel() {}
+ // Returns the session id of this channel.
+ const std::string& session_id() const { return session_id_; }
// Returns the name of this channel.
const std::string& name() const { return name_; }
const std::string& content_type() const { return content_type_; }
@@ -66,6 +68,12 @@
// supported by all transport types.
virtual int SetOption(talk_base::Socket::Option opt, int value) = 0;
+ // Sets session id which created this transport channel.
+ // This is called from TransportProxy::GetOrCreateImpl.
+ void set_session_id(const std::string& session_id) {
+ session_id_ = session_id;
+ }
+
// Returns the most recent error that occurred on this channel.
virtual int GetError() = 0;
@@ -95,7 +103,9 @@
// Sets the writable state, signaling if necessary.
void set_writable(bool writable);
+
private:
+ std::string session_id_;
std::string name_;
std::string content_type_;
bool readable_;
diff --git a/talk/p2p/base/transportchannelproxy.cc b/talk/p2p/base/transportchannelproxy.cc
index f87383e..4e035b1 100644
--- a/talk/p2p/base/transportchannelproxy.cc
+++ b/talk/p2p/base/transportchannelproxy.cc
@@ -34,15 +34,16 @@
TransportChannelProxy::TransportChannelProxy(const std::string& name,
const std::string& content_type)
- : TransportChannel(name, content_type), impl_(NULL) {
+ : TransportChannel(name, content_type), impl_(NULL), owner_(false) {
}
TransportChannelProxy::~TransportChannelProxy() {
- if (impl_)
+ if (owner_ && impl_)
impl_->GetTransport()->DestroyChannel(impl_->name());
}
-void TransportChannelProxy::SetImplementation(TransportChannelImpl* impl) {
+void TransportChannelProxy::SetImplementation(TransportChannelImpl* impl,
+ bool owner) {
impl_ = impl;
impl_->SignalReadableState.connect(
this, &TransportChannelProxy::OnReadableState);
@@ -56,6 +57,7 @@
impl_->SetOption(it->first, it->second);
}
pending_options_.clear();
+ owner_ = owner;
}
int TransportChannelProxy::SendPacket(const char* data, size_t len) {
diff --git a/talk/p2p/base/transportchannelproxy.h b/talk/p2p/base/transportchannelproxy.h
index 957c304..6923429 100644
--- a/talk/p2p/base/transportchannelproxy.h
+++ b/talk/p2p/base/transportchannelproxy.h
@@ -49,7 +49,10 @@
TransportChannelImpl* impl() { return impl_; }
// Sets the implementation to which we will proxy.
- void SetImplementation(TransportChannelImpl* impl);
+ // Impl can be belong to some other TransportChannelProxy,
+ // in that case it should't try to delete. TODO - Remove this hack
+ // when ref count support is available.
+ void SetImplementation(TransportChannelImpl* impl, bool owner);
// Implementation of the TransportChannel interface. These simply forward to
// the implementation.
@@ -62,6 +65,7 @@
typedef std::pair<talk_base::Socket::Option, int> OptionPair;
typedef std::vector<OptionPair> OptionList;
TransportChannelImpl* impl_;
+ bool owner_;
OptionList pending_options_;
// Catch signals from the implementation channel. These just forward to the
diff --git a/talk/p2p/base/udpport.cc b/talk/p2p/base/udpport.cc
index 8355b00..311fb45 100644
--- a/talk/p2p/base/udpport.cc
+++ b/talk/p2p/base/udpport.cc
@@ -38,7 +38,7 @@
UDPPort::UDPPort(talk_base::Thread* thread,
talk_base::PacketSocketFactory* factory,
talk_base::Network* network,
- uint32 ip, int min_port, int max_port)
+ const talk_base::IPAddress& ip, int min_port, int max_port)
: Port(thread, LOCAL_PORT_TYPE, factory, network, ip, min_port, max_port),
socket_(NULL),
error_(0) {
diff --git a/talk/p2p/base/udpport.h b/talk/p2p/base/udpport.h
index d74d4a3..5d767bb 100644
--- a/talk/p2p/base/udpport.h
+++ b/talk/p2p/base/udpport.h
@@ -48,7 +48,8 @@
static UDPPort* Create(talk_base::Thread* thread,
talk_base::PacketSocketFactory* factory,
talk_base::Network* network,
- uint32 ip, int min_port, int max_port) {
+ const talk_base::IPAddress& ip,
+ int min_port, int max_port) {
UDPPort* port = new UDPPort(thread, factory, network,
ip, min_port, max_port);
if (!port->Init()) {
@@ -68,7 +69,8 @@
protected:
UDPPort(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
- talk_base::Network* network, uint32 ip, int min_port, int max_port);
+ talk_base::Network* network, const talk_base::IPAddress& ip,
+ int min_port, int max_port);
bool Init();
// Handles sending using the local UDP socket.
diff --git a/talk/p2p/client/basicportallocator.cc b/talk/p2p/client/basicportallocator.cc
index 51d069e..b77d5ed 100644
--- a/talk/p2p/client/basicportallocator.cc
+++ b/talk/p2p/client/basicportallocator.cc
@@ -154,7 +154,7 @@
BasicPortAllocatorSession* session_;
talk_base::Network* network_;
- uint32 ip_;
+ talk_base::IPAddress ip_;
PortConfiguration* config_;
bool running_;
int step_;
@@ -229,8 +229,8 @@
BasicPortAllocator *allocator,
const std::string &name,
const std::string &session_type)
- : PortAllocatorSession(allocator->flags()), allocator_(allocator),
- name_(name), session_type_(session_type), network_thread_(NULL),
+ : PortAllocatorSession(name, session_type, allocator->flags()),
+ allocator_(allocator), network_thread_(NULL),
socket_factory_(allocator->socket_factory()), allocation_started_(false),
network_manager_started_(false),
running_(false) {
diff --git a/talk/p2p/client/basicportallocator.h b/talk/p2p/client/basicportallocator.h
index 0e1d00a..f38bac6 100644
--- a/talk/p2p/client/basicportallocator.h
+++ b/talk/p2p/client/basicportallocator.h
@@ -43,7 +43,7 @@
public:
BasicPortAllocator(talk_base::NetworkManager* network_manager,
talk_base::PacketSocketFactory* socket_factory);
- BasicPortAllocator(talk_base::NetworkManager* network_manager);
+ explicit BasicPortAllocator(talk_base::NetworkManager* network_manager);
BasicPortAllocator(talk_base::NetworkManager* network_manager,
const talk_base::SocketAddress& stun_server,
const talk_base::SocketAddress& relay_server_udp,
@@ -114,8 +114,6 @@
~BasicPortAllocatorSession();
virtual BasicPortAllocator* allocator() { return allocator_; }
- const std::string& name() const { return name_; }
- const std::string& session_type() const { return session_type_; }
talk_base::Thread* network_thread() { return network_thread_; }
talk_base::PacketSocketFactory* socket_factory() { return socket_factory_; }
@@ -130,7 +128,7 @@
// Adds a port configuration that is now ready. Once we have one for each
// network (or a timeout occurs), we will start allocating ports.
- void ConfigReady(PortConfiguration* config);
+ virtual void ConfigReady(PortConfiguration* config);
// MessageHandler. Can be overriden if message IDs do not conflict.
virtual void OnMessage(talk_base::Message *message);
@@ -154,8 +152,6 @@
void OnShake();
BasicPortAllocator* allocator_;
- std::string name_;
- std::string session_type_;
talk_base::Thread* network_thread_;
talk_base::scoped_ptr<talk_base::PacketSocketFactory> owned_socket_factory_;
talk_base::PacketSocketFactory* socket_factory_;
diff --git a/talk/p2p/client/connectivitychecker.cc b/talk/p2p/client/connectivitychecker.cc
new file mode 100644
index 0000000..de97924
--- /dev/null
+++ b/talk/p2p/client/connectivitychecker.cc
@@ -0,0 +1,513 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+
+#include <string>
+
+#include "talk/p2p/client/connectivitychecker.h"
+
+#include "talk/base/asynchttprequest.h"
+#include "talk/base/autodetectproxy.h"
+#include "talk/base/basicpacketsocketfactory.h"
+#include "talk/base/helpers.h"
+#include "talk/base/httpcommon.h"
+#include "talk/base/logging.h"
+#include "talk/base/proxydetect.h"
+#include "talk/base/thread.h"
+#include "talk/p2p/base/candidate.h"
+#include "talk/p2p/base/common.h"
+#include "talk/p2p/base/port.h"
+#include "talk/p2p/base/relayport.h"
+#include "talk/p2p/base/stunport.h"
+
+namespace cricket {
+
+static const char kSessionTypeVideo[] =
+ "http://www.google.com/session/video";
+static const char kSessionNameRtp[] = "rtp";
+
+static const char kDefaultStunHostname[] = "stun.l.google.com";
+static const int kDefaultStunPort = 19302;
+
+// Default maximum time in milliseconds we will wait for connections.
+static const uint32 kDefaultTimeoutMs = 3000;
+
+enum {
+ MSG_START = 1,
+ MSG_STOP = 2,
+ MSG_TIMEOUT = 3,
+ MSG_SIGNAL_RESULTS = 4
+};
+
+class TestHttpPortAllocator : public HttpPortAllocator {
+ public:
+ TestHttpPortAllocator(talk_base::NetworkManager* network_manager,
+ const std::string& user_agent,
+ const std::string& relay_token) :
+ HttpPortAllocator(network_manager, user_agent) {
+ SetRelayToken(relay_token);
+ }
+ PortAllocatorSession* CreateSession(
+ const std::string& name, const std::string& session_type) {
+ return new TestHttpPortAllocatorSession(this, name, session_type,
+ stun_hosts(), relay_hosts(),
+ relay_token(), user_agent());
+ }
+};
+
+void TestHttpPortAllocatorSession::ConfigReady(PortConfiguration* config) {
+ SignalConfigReady(config, proxy_);
+}
+
+void TestHttpPortAllocatorSession::OnRequestDone(
+ talk_base::SignalThread* data) {
+ talk_base::AsyncHttpRequest* request =
+ static_cast<talk_base::AsyncHttpRequest*>(data);
+
+ // Tell the checker that the request is complete.
+ SignalRequestDone(request);
+
+ // Pass on the response to super class.
+ HttpPortAllocatorSession::OnRequestDone(data);
+}
+
+ConnectivityChecker::ConnectivityChecker(
+ talk_base::Thread* worker,
+ const std::string& jid,
+ const std::string& session_id,
+ const std::string& user_agent,
+ const std::string& relay_token,
+ const std::string& connection)
+ : worker_(worker),
+ jid_(jid),
+ session_id_(session_id),
+ user_agent_(user_agent),
+ relay_token_(relay_token),
+ connection_(connection),
+ proxy_detect_(NULL),
+ timeout_ms_(kDefaultTimeoutMs),
+ stun_address_(kDefaultStunHostname, kDefaultStunPort) {
+}
+
+ConnectivityChecker::~ConnectivityChecker() {
+ Stop();
+ nics_.clear();
+}
+
+bool ConnectivityChecker::Initialize() {
+ network_manager_.reset(CreateNetworkManager());
+ socket_factory_.reset(CreateSocketFactory(worker_));
+ port_allocator_.reset(CreatePortAllocator(network_manager_.get(),
+ user_agent_, relay_token_));
+ return true;
+}
+
+void ConnectivityChecker::Start() {
+ main_ = talk_base::Thread::Current();
+ worker_->Post(this, MSG_START);
+}
+
+void ConnectivityChecker::Stop() {
+ worker_->Post(this, MSG_STOP);
+}
+
+void ConnectivityChecker::CleanUp() {
+ ASSERT(worker_ == talk_base::Thread::Current());
+ worker_->Clear(this, MSG_TIMEOUT);
+ if (proxy_detect_) {
+ proxy_detect_->Release();
+ proxy_detect_ = NULL;
+ }
+
+ for (uint32 i = 0; i < sessions_.size(); ++i) {
+ delete sessions_[i];
+ }
+ sessions_.clear();
+ for (uint32 i = 0; i < ports_.size(); ++i) {
+ delete ports_[i];
+ }
+ ports_.clear();
+}
+
+bool ConnectivityChecker::AddNic(const talk_base::IPAddress& ip,
+ const talk_base::SocketAddress& proxy_addr) {
+ NicMap::iterator i = nics_.find(NicId(ip, proxy_addr));
+ if (i != nics_.end()) {
+ // Already have it.
+ return false;
+ }
+ uint32 now = talk_base::Time();
+ NicInfo info;
+ info.ip = ip;
+ info.proxy_info = GetProxyInfo();
+ info.stun.start_time_ms = now;
+ nics_.insert(std::pair<NicId, NicInfo>(NicId(ip, proxy_addr), info));
+ return true;
+}
+
+void ConnectivityChecker::SetProxyInfo(const talk_base::ProxyInfo& proxy_info) {
+ port_allocator_->set_proxy(user_agent_, proxy_info);
+ AllocatePorts();
+}
+
+talk_base::ProxyInfo ConnectivityChecker::GetProxyInfo() const {
+ talk_base::ProxyInfo proxy_info;
+ if (proxy_detect_) {
+ proxy_info = proxy_detect_->proxy();
+ }
+ return proxy_info;
+}
+
+void ConnectivityChecker::CheckNetworks() {
+ network_manager_->SignalNetworksChanged.connect(
+ this, &ConnectivityChecker::OnNetworksChanged);
+ network_manager_->StartUpdating();
+}
+
+void ConnectivityChecker::OnMessage(talk_base::Message *msg) {
+ switch (msg->message_id) {
+ case MSG_START:
+ ASSERT(worker_ == talk_base::Thread::Current());
+ worker_->PostDelayed(timeout_ms_, this, MSG_TIMEOUT);
+ CheckNetworks();
+ break;
+ case MSG_STOP:
+ // We were stopped, just close down without signaling.
+ OnCheckDone(false);
+ break;
+ case MSG_TIMEOUT:
+ // Close down and signal results.
+ OnCheckDone(true);
+ break;
+ case MSG_SIGNAL_RESULTS:
+ ASSERT(main_ == talk_base::Thread::Current());
+ SignalCheckDone(this);
+ break;
+ default:
+ LOG(LS_ERROR) << "Unknown message: " << msg->message_id;
+ }
+}
+
+void ConnectivityChecker::OnCheckDone(bool signal_results) {
+ // Clean up memory allocated by the worker thread.
+ CleanUp();
+
+ if (signal_results) {
+ main_->Post(this, MSG_SIGNAL_RESULTS);
+ }
+}
+
+void ConnectivityChecker::OnProxyDetect(talk_base::SignalThread* thread) {
+ ASSERT(worker_ == talk_base::Thread::Current());
+ if (proxy_detect_->proxy().type != talk_base::PROXY_NONE) {
+ SetProxyInfo(proxy_detect_->proxy());
+ }
+}
+
+void ConnectivityChecker::OnRequestDone(talk_base::AsyncHttpRequest* request) {
+ ASSERT(worker_ == talk_base::Thread::Current());
+ // Since we don't know what nic were actually used for the http request,
+ // for now, just use the first one.
+ std::vector<talk_base::Network*> networks;
+ network_manager_->GetNetworks(&networks);
+ if (networks.empty()) {
+ LOG(LS_ERROR) << "No networks while registering http start.";
+ return;
+ }
+ talk_base::ProxyInfo proxy_info = request->proxy();
+ NicMap::iterator i = nics_.find(NicId(networks[0]->ip(), proxy_info.address));
+ if (i != nics_.end()) {
+ int port = request->port();
+ uint32 now = talk_base::Time();
+ NicInfo* nic_info = &i->second;
+ if (port == talk_base::HTTP_DEFAULT_PORT) {
+ nic_info->http.rtt = now - nic_info->http.start_time_ms;
+ } else if (port == talk_base::HTTP_SECURE_PORT) {
+ nic_info->https.rtt = now - nic_info->https.start_time_ms;
+ } else {
+ LOG(LS_ERROR) << "Got response with unknown port: " << port;
+ }
+ } else {
+ LOG(LS_ERROR) << "No nic info found while receiving response.";
+ }
+}
+
+void ConnectivityChecker::OnConfigReady(
+ const PortConfiguration* config,
+ const talk_base::ProxyInfo& proxy_info) {
+ ASSERT(worker_ == talk_base::Thread::Current());
+
+ // Since we send requests on both HTTP and HTTPS we will get two
+ // configs per nic. Results from the second will overwrite the
+ // result from the first.
+ // TODO: Handle multiple pings on one nic.
+ CreateRelayPorts(config, proxy_info);
+}
+
+void ConnectivityChecker::OnRelayAddressReady(Port* port) {
+ ASSERT(worker_ == talk_base::Thread::Current());
+ RelayPort* relay_port = reinterpret_cast<RelayPort*>(port);
+ const ProtocolAddress* address = relay_port->ServerAddress(0);
+ talk_base::IPAddress ip = port->network()->ip();
+ NicMap::iterator i = nics_.find(NicId(ip, port->proxy().address));
+ if (i != nics_.end()) {
+ // We have it already, add the new information.
+ NicInfo* nic_info = &i->second;
+ ConnectInfo* connect_info = NULL;
+ if (address) {
+ switch (address->proto) {
+ case PROTO_UDP:
+ connect_info = &nic_info->udp;
+ break;
+ case PROTO_TCP:
+ connect_info = &nic_info->tcp;
+ break;
+ case PROTO_SSLTCP:
+ connect_info = &nic_info->ssltcp;
+ break;
+ default:
+ LOG(LS_ERROR) << " relay address with bad protocol added";
+ }
+ if (connect_info) {
+ connect_info->rtt =
+ talk_base::TimeSince(connect_info->start_time_ms);
+ }
+ }
+ } else {
+ LOG(LS_ERROR) << " got relay address for non-existing nic";
+ }
+}
+
+void ConnectivityChecker::OnStunAddressReady(Port* port) {
+ ASSERT(worker_ == talk_base::Thread::Current());
+ const std::vector<Candidate> candidates = port->candidates();
+ Candidate c = candidates[0];
+ talk_base::IPAddress ip = port->network()->ip();
+ NicMap::iterator i = nics_.find(NicId(ip, port->proxy().address));
+ if (i != nics_.end()) {
+ // We have it already, add the new information.
+ uint32 now = talk_base::Time();
+ NicInfo* nic_info = &i->second;
+ nic_info->external_address = c.address();
+ nic_info->stun_server_address = static_cast<StunPort*>(port)->server_addr();
+ nic_info->stun.rtt = now - nic_info->stun.start_time_ms;
+ } else {
+ LOG(LS_ERROR) << "Got stun address for non-existing nic";
+ }
+}
+
+void ConnectivityChecker::OnStunAddressError(Port* port) {
+ ASSERT(worker_ == talk_base::Thread::Current());
+ LOG(LS_ERROR) << "Stun address error.";
+ talk_base::IPAddress ip = port->network()->ip();
+ NicMap::iterator i = nics_.find(NicId(ip, port->proxy().address));
+ if (i != nics_.end()) {
+ // We have it already, add the new information.
+ NicInfo* nic_info = &i->second;
+ nic_info->stun_server_address = static_cast<StunPort*>(port)->server_addr();
+ }
+}
+
+void ConnectivityChecker::OnRelayAddressError(Port* port) {
+ ASSERT(worker_ == talk_base::Thread::Current());
+ LOG(LS_ERROR) << "Relay address error.";
+}
+
+void ConnectivityChecker::OnNetworksChanged() {
+ ASSERT(worker_ == talk_base::Thread::Current());
+ std::vector<talk_base::Network*> networks;
+ network_manager_->GetNetworks(&networks);
+ if (networks.empty()) {
+ LOG(LS_ERROR) << "Machine has no networks; nothing to do";
+ return;
+ }
+ AllocatePorts();
+}
+
+HttpPortAllocator* ConnectivityChecker::CreatePortAllocator(
+ talk_base::NetworkManager* network_manager,
+ const std::string& user_agent,
+ const std::string& relay_token) {
+ return new TestHttpPortAllocator(network_manager, user_agent, relay_token);
+}
+
+StunPort* ConnectivityChecker::CreateStunPort(
+ const PortConfiguration* config, talk_base::Network* network) {
+ return StunPort::Create(worker_,
+ socket_factory_.get(),
+ network,
+ network->ip(),
+ 0,
+ 0,
+ config->stun_address);
+}
+
+RelayPort* ConnectivityChecker::CreateRelayPort(
+ const PortConfiguration* config, talk_base::Network* network) {
+ return RelayPort::Create(worker_,
+ socket_factory_.get(),
+ network,
+ network->ip(),
+ port_allocator_->min_port(),
+ port_allocator_->max_port(),
+ config->username,
+ config->password,
+ config->magic_cookie);
+}
+
+void ConnectivityChecker::CreateRelayPorts(
+ const PortConfiguration* config,
+ const talk_base::ProxyInfo& proxy_info) {
+ PortConfiguration::RelayList::const_iterator relay;
+ std::vector<talk_base::Network*> networks;
+ network_manager_->GetNetworks(&networks);
+ if (networks.empty()) {
+ LOG(LS_ERROR) << "Machine has no networks; no relay ports created.";
+ return;
+ }
+ for (relay = config->relays.begin();
+ relay != config->relays.end(); ++relay) {
+ for (uint32 i = 0; i < networks.size(); ++i) {
+ NicMap::iterator iter = nics_.find(NicId(networks[i]->ip(),
+ proxy_info.address));
+ if (iter != nics_.end()) {
+ // TODO: Now setting the same start time for all protocols.
+ // This might affect accuracy, but since we are mainly looking for
+ // connect failures or number that stick out, this is good enough.
+ uint32 now = talk_base::Time();
+ NicInfo* nic_info = &iter->second;
+ nic_info->udp.start_time_ms = now;
+ nic_info->tcp.start_time_ms = now;
+ nic_info->ssltcp.start_time_ms = now;
+
+ // Add the addresses of this protocol.
+ PortConfiguration::PortList::const_iterator relay_port;
+ for (relay_port = relay->ports.begin();
+ relay_port != relay->ports.end();
+ ++relay_port) {
+ RelayPort* port = CreateRelayPort(config, networks[i]);
+ port->AddServerAddress(*relay_port);
+ port->AddExternalAddress(*relay_port);
+
+ nic_info->media_server_address = port->ServerAddress(0)->address;
+
+ // Listen to network events.
+ port->SignalAddressReady.connect(
+ this, &ConnectivityChecker::OnRelayAddressReady);
+ port->SignalAddressError.connect(
+ this, &ConnectivityChecker::OnRelayAddressError);
+
+ port->set_proxy(user_agent_, proxy_info);
+
+ // Start fetching an address for this port.
+ port->PrepareAddress();
+ ports_.push_back(port);
+ }
+ } else {
+ LOG(LS_ERROR) << "Failed to find nic info when creating relay ports.";
+ }
+ }
+ }
+}
+
+void ConnectivityChecker::AllocatePorts() {
+ PortConfiguration config(stun_address_,
+ talk_base::CreateRandomString(16),
+ talk_base::CreateRandomString(16),
+ "");
+ std::vector<talk_base::Network*> networks;
+ network_manager_->GetNetworks(&networks);
+ if (networks.empty()) {
+ LOG(LS_ERROR) << "Machine has no networks; no ports will be allocated";
+ return;
+ }
+ talk_base::ProxyInfo proxy_info = GetProxyInfo();
+ bool allocate_relay_ports = false;
+ for (uint32 i = 0; i < networks.size(); ++i) {
+ if (AddNic(networks[i]->ip(), proxy_info.address)) {
+ Port* port = CreateStunPort(&config, networks[i]);
+
+ // Listen to network events.
+ port->SignalAddressReady.connect(
+ this, &ConnectivityChecker::OnStunAddressReady);
+ port->SignalAddressError.connect(
+ this, &ConnectivityChecker::OnStunAddressError);
+
+ port->set_proxy(user_agent_, proxy_info);
+ port->PrepareAddress();
+ ports_.push_back(port);
+ allocate_relay_ports = true;
+ }
+ }
+
+ // If any new ip/proxy combinations were added, send a relay allocate.
+ if (allocate_relay_ports) {
+ AllocateRelayPorts();
+ }
+
+ // Initiate proxy detection.
+ InitiateProxyDetection();
+}
+
+void ConnectivityChecker::InitiateProxyDetection() {
+ // Only start if we haven't been started before.
+ if (!proxy_detect_) {
+ proxy_detect_ = new talk_base::AutoDetectProxy(user_agent_);
+ talk_base::Url<char> host_url("/", "relay.google.com",
+ talk_base::HTTP_DEFAULT_PORT);
+ host_url.set_secure(true);
+ proxy_detect_->set_server_url(host_url.url());
+ proxy_detect_->SignalWorkDone.connect(
+ this, &ConnectivityChecker::OnProxyDetect);
+ proxy_detect_->Start();
+ }
+}
+
+void ConnectivityChecker::AllocateRelayPorts() {
+ // Currently we are using the 'default' nic for http(s) requests.
+ TestHttpPortAllocatorSession* allocator_session =
+ reinterpret_cast<TestHttpPortAllocatorSession*>(
+ port_allocator_->CreateSession(kSessionNameRtp, kSessionTypeVideo));
+ allocator_session->set_proxy(port_allocator_->proxy());
+ allocator_session->SignalConfigReady.connect(
+ this, &ConnectivityChecker::OnConfigReady);
+ allocator_session->SignalRequestDone.connect(
+ this, &ConnectivityChecker::OnRequestDone);
+
+ // Try both http and https.
+ RegisterHttpStart(talk_base::HTTP_SECURE_PORT);
+ allocator_session->SendSessionRequest("relay.l.google.com",
+ talk_base::HTTP_SECURE_PORT);
+ RegisterHttpStart(talk_base::HTTP_DEFAULT_PORT);
+ allocator_session->SendSessionRequest("relay.l.google.com",
+ talk_base::HTTP_DEFAULT_PORT);
+
+ sessions_.push_back(allocator_session);
+}
+
+void ConnectivityChecker::RegisterHttpStart(int port) {
+ // Since we don't know what nic were actually used for the http request,
+ // for now, just use the first one.
+ std::vector<talk_base::Network*> networks;
+ network_manager_->GetNetworks(&networks);
+ if (networks.empty()) {
+ LOG(LS_ERROR) << "No networks while registering http start.";
+ return;
+ }
+ talk_base::ProxyInfo proxy_info = GetProxyInfo();
+ NicMap::iterator i = nics_.find(NicId(networks[0]->ip(), proxy_info.address));
+ if (i != nics_.end()) {
+ uint32 now = talk_base::Time();
+ NicInfo* nic_info = &i->second;
+ if (port == talk_base::HTTP_DEFAULT_PORT) {
+ nic_info->http.start_time_ms = now;
+ } else if (port == talk_base::HTTP_SECURE_PORT) {
+ nic_info->https.start_time_ms = now;
+ } else {
+ LOG(LS_ERROR) << "Registering start time for unknown port: " << port;
+ }
+ } else {
+ LOG(LS_ERROR) << "Error, no nic info found while registering http start.";
+ }
+}
+
+} // namespace talk_base
diff --git a/talk/p2p/client/connectivitychecker.h b/talk/p2p/client/connectivitychecker.h
new file mode 100644
index 0000000..18a1c7f
--- /dev/null
+++ b/talk/p2p/client/connectivitychecker.h
@@ -0,0 +1,260 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+
+#ifndef TALK_P2P_CLIENT_CONNECTIVITYCHECKER_H_
+#define TALK_P2P_CLIENT_CONNECTIVITYCHECKER_H_
+
+#include <map>
+#include <string>
+
+#include "talk/base/network.h"
+#include "talk/base/basicpacketsocketfactory.h"
+#include "talk/base/basictypes.h"
+#include "talk/base/messagehandler.h"
+#include "talk/base/proxyinfo.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/sigslot.h"
+#include "talk/base/socketaddress.h"
+#include "talk/p2p/client/httpportallocator.h"
+
+namespace talk_base {
+class AsyncHttpRequest;
+class AutoDetectProxy;
+class BasicPacketSocketFactory;
+class NetworkManager;
+class PacketSocketFactory;
+class SignalThread;
+class TestHttpPortAllocatorSession;
+class Thread;
+}
+
+namespace cricket {
+class HttpPortAllocator;
+class Port;
+class PortAllocatorSession;
+struct PortConfiguration;
+class RelayPort;
+class StunPort;
+
+// Contains details about a discovered firewall that are of interest
+// when debugging call failures.
+struct FirewallInfo {
+ std::string brand;
+ std::string model;
+
+ // TODO: List of current port mappings.
+};
+
+// Contains details about a specific connect attempt.
+struct ConnectInfo {
+ ConnectInfo()
+ : rtt(-1), error(0) {}
+ // Time when the connection was initiated. Needed for calculating
+ // the round trip time.
+ uint32 start_time_ms;
+ // Round trip time in milliseconds or -1 for failed connection.
+ int32 rtt;
+ // Error code representing low level errors like socket errors.
+ int error;
+};
+
+// Identifier for a network interface and proxy address pair.
+struct NicId {
+ NicId(const talk_base::IPAddress& ip,
+ const talk_base::SocketAddress& proxy_address)
+ : ip(ip),
+ proxy_address(proxy_address) {
+ }
+ talk_base::IPAddress ip;
+ talk_base::SocketAddress proxy_address;
+};
+
+// Comparator implementation identifying unique network interface and
+// proxy address pairs.
+class NicIdComparator {
+ public:
+ int compare(const NicId &first, const NicId &second) const {
+ if (first.ip == second.ip) {
+ // Compare proxy address.
+ if (first.proxy_address == second.proxy_address) {
+ return 0;
+ } else {
+ return first.proxy_address < second.proxy_address? -1 : 1;
+ }
+ }
+ return first.ip < second.ip ? -1 : 1;
+ }
+
+ bool operator()(const NicId &first, const NicId &second) const {
+ return (compare(first, second) < 0);
+ }
+};
+
+// Contains information of a network interface and proxy address pair.
+struct NicInfo {
+ NicInfo() {}
+ talk_base::IPAddress ip;
+ talk_base::ProxyInfo proxy_info;
+ talk_base::SocketAddress external_address;
+ talk_base::SocketAddress stun_server_address;
+ talk_base::SocketAddress media_server_address;
+ ConnectInfo stun;
+ ConnectInfo http;
+ ConnectInfo https;
+ ConnectInfo udp;
+ ConnectInfo tcp;
+ ConnectInfo ssltcp;
+ FirewallInfo firewall;
+};
+
+// Holds the result of the connectivity check.
+class NicMap : public std::map<NicId, NicInfo, NicIdComparator> {
+};
+
+class TestHttpPortAllocatorSession : public HttpPortAllocatorSession {
+ public:
+ TestHttpPortAllocatorSession(
+ HttpPortAllocator* allocator, const std::string &name,
+ const std::string& session_type,
+ const std::vector<talk_base::SocketAddress>& stun_hosts,
+ const std::vector<std::string>& relay_hosts,
+ const std::string& relay_token,
+ const std::string& user_agent)
+ : HttpPortAllocatorSession(allocator, name, session_type, stun_hosts,
+ relay_hosts, relay_token, user_agent) {
+ }
+ void set_proxy(const talk_base::ProxyInfo& proxy) {
+ proxy_ = proxy;
+ }
+
+ void ConfigReady(PortConfiguration* config);
+
+ void OnRequestDone(talk_base::SignalThread* data);
+
+ sigslot::signal2<const PortConfiguration*,
+ const talk_base::ProxyInfo&> SignalConfigReady;
+ sigslot::signal1<talk_base::AsyncHttpRequest*> SignalRequestDone;
+
+ private:
+ talk_base::ProxyInfo proxy_;
+};
+
+// Runs a request/response check on all network interface and proxy
+// address combinations. The check is considered done either when all
+// checks has been successful or when the check times out.
+class ConnectivityChecker
+ : public talk_base::MessageHandler, public sigslot::has_slots<> {
+ public:
+ ConnectivityChecker(talk_base::Thread* worker,
+ const std::string& jid,
+ const std::string& session_id,
+ const std::string& user_agent,
+ const std::string& relay_token,
+ const std::string& connection);
+ virtual ~ConnectivityChecker();
+
+ // Virtual for gMock.
+ virtual bool Initialize();
+ virtual void Start();
+ virtual void Stop();
+
+ // MessageHandler implementation.
+ virtual void OnMessage(talk_base::Message *msg);
+
+ const NicMap& GetResults() const {
+ return nics_;
+ }
+
+ void set_timeout_ms(uint32 timeout) {
+ timeout_ms_ = timeout;
+ }
+
+ void set_stun_address(const talk_base::SocketAddress& stun_address) {
+ stun_address_ = stun_address;
+ }
+
+ const std::string& connection() const {
+ return connection_;
+ }
+
+ talk_base::Thread* worker() {
+ return worker_;
+ }
+
+ const std::string& jid() const {
+ return jid_;
+ }
+
+ const std::string& session_id() const {
+ return session_id_;
+ }
+
+ // Context: Main Thread. Signalled when the connectivity check is complete.
+ sigslot::signal1<ConnectivityChecker*> SignalCheckDone;
+
+ protected:
+ // Can be overridden for test.
+ virtual talk_base::NetworkManager* CreateNetworkManager() {
+ return new talk_base::BasicNetworkManager();
+ }
+ virtual talk_base::BasicPacketSocketFactory* CreateSocketFactory(
+ talk_base::Thread* thread) {
+ return new talk_base::BasicPacketSocketFactory(thread);
+ }
+ virtual HttpPortAllocator* CreatePortAllocator(
+ talk_base::NetworkManager* network_manager,
+ const std::string& user_agent,
+ const std::string& relay_token);
+ virtual StunPort* CreateStunPort(const PortConfiguration* config,
+ talk_base::Network* network);
+ virtual RelayPort* CreateRelayPort(const PortConfiguration* config,
+ talk_base::Network* network);
+ virtual void InitiateProxyDetection();
+ virtual void SetProxyInfo(const talk_base::ProxyInfo& info);
+ virtual talk_base::ProxyInfo GetProxyInfo() const;
+
+ private:
+ bool AddNic(const talk_base::IPAddress& ip,
+ const talk_base::SocketAddress& proxy_address);
+ void AllocatePorts();
+ void AllocateRelayPorts();
+ void CheckNetworks();
+ void CreateRelayPorts(const PortConfiguration* config,
+ const talk_base::ProxyInfo& proxy_info);
+
+ // Must be called by the worker thread.
+ void CleanUp();
+
+ void OnCheckDone(bool signal_results);
+ void OnRequestDone(talk_base::AsyncHttpRequest* request);
+ void OnRelayAddressReady(Port* port);
+ void OnStunAddressReady(Port* port);
+ void OnRelayAddressError(Port* port);
+ void OnStunAddressError(Port* port);
+ void OnNetworksChanged();
+ void OnProxyDetect(talk_base::SignalThread* thread);
+ void OnConfigReady(const PortConfiguration*,
+ const talk_base::ProxyInfo& proxy);
+ void OnConfigWithProxyReady(const PortConfiguration*);
+ void RegisterHttpStart(int port);
+ talk_base::Thread* worker_;
+ std::string jid_;
+ std::string session_id_;
+ std::string user_agent_;
+ std::string relay_token_;
+ std::string connection_;
+ talk_base::AutoDetectProxy* proxy_detect_;
+ talk_base::scoped_ptr<talk_base::NetworkManager> network_manager_;
+ talk_base::scoped_ptr<talk_base::BasicPacketSocketFactory> socket_factory_;
+ talk_base::scoped_ptr<HttpPortAllocator> port_allocator_;
+ NicMap nics_;
+ std::vector<Port*> ports_;
+ std::vector<PortAllocatorSession*> sessions_;
+ uint32 timeout_ms_;
+ talk_base::SocketAddress stun_address_;
+ talk_base::Thread* main_;
+};
+
+} // namespace cricket
+
+#endif // TALK_P2P_CLIENT_CONNECTIVITYCHECKER_H_
diff --git a/talk/p2p/client/connectivitychecker_unittest.cc b/talk/p2p/client/connectivitychecker_unittest.cc
new file mode 100644
index 0000000..d63704a
--- /dev/null
+++ b/talk/p2p/client/connectivitychecker_unittest.cc
@@ -0,0 +1,367 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+
+#include <string>
+
+#include "talk/base/asynchttprequest.h"
+#include "talk/base/basicpacketsocketfactory.h"
+#include "talk/base/gunit.h"
+#include "talk/base/fakenetwork.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/socketaddress.h"
+#include "talk/p2p/base/relayport.h"
+#include "talk/p2p/base/stunport.h"
+#include "talk/p2p/client/connectivitychecker.h"
+#include "talk/p2p/client/httpportallocator.h"
+
+namespace cricket {
+
+static const talk_base::SocketAddress kClientAddr1("11.11.11.11", 0);
+static const talk_base::SocketAddress kClientAddr2("22.22.22.22", 0);
+static const talk_base::SocketAddress kExternalAddr("33.33.33.33", 3333);
+static const talk_base::SocketAddress kStunAddr("44.44.44.44", 4444);
+static const talk_base::SocketAddress kRelayAddr("55.55.55.55", 5555);
+static const talk_base::SocketAddress kProxyAddr("66.66.66.66", 6666);
+static const talk_base::ProxyType kProxyType = talk_base::PROXY_HTTPS;
+static const char kSessionName[] = "rtp_test";
+static const char kSessionType[] = "http://www.google.com/session/test";
+static const char kRelayHost[] = "relay.google.com";
+static const char kRelayToken[] =
+ "CAESFwoOb2phQGdvb2dsZS5jb20Q043h47MmGhBTB1rbfIXkhuarDCZe+xF6";
+static const char kBrowserAgent[] = "browser_test";
+static const char kJid[] = "a.b@c";
+static const char kUserName[] = "testuser";
+static const char kPassword[] = "testpassword";
+static const char kMagicCookie[] = "testcookie";
+static const char kRelayUdpPort[] = "4444";
+static const char kRelayTcpPort[] = "5555";
+static const char kRelaySsltcpPort[] = "6666";
+static const char kSessionId[] = "testsession";
+static const char kConnection[] = "testconnection";
+static const int kMinPort = 1000;
+static const int kMaxPort = 2000;
+
+// Fake implementation to mock away real network usage.
+class FakeRelayPort : public RelayPort {
+ public:
+ FakeRelayPort(talk_base::Thread* thread,
+ talk_base::PacketSocketFactory* factory,
+ talk_base::Network* network,
+ const talk_base::IPAddress& ip,
+ int min_port,
+ int max_port,
+ const std::string& username,
+ const std::string& password,
+ const std::string& magic_cookie)
+ : RelayPort(thread,
+ factory,
+ network,
+ ip,
+ min_port,
+ max_port,
+ username,
+ password,
+ magic_cookie) {
+ }
+
+ // Just signal that we are done.
+ virtual void PrepareAddress() {
+ SignalAddressReady(this);
+ }
+};
+
+// Fake implementation to mock away real network usage.
+class FakeStunPort : public StunPort {
+ public:
+ FakeStunPort(talk_base::Thread* thread,
+ talk_base::PacketSocketFactory* factory,
+ talk_base::Network* network,
+ const talk_base::IPAddress& ip,
+ int min_port,
+ int max_port,
+ const talk_base::SocketAddress& server_addr)
+ : StunPort(thread,
+ factory,
+ network,
+ ip,
+ min_port,
+ max_port,
+ server_addr) {
+ }
+
+ // Just set external address and signal that we are done.
+ virtual void PrepareAddress() {
+ AddAddress(kExternalAddr, "udp", true);
+ SignalAddressReady(this);
+ }
+};
+
+// Fake implementation to mock away real network usage by responding
+// to http requests immediately.
+class FakeHttpPortAllocatorSession : public TestHttpPortAllocatorSession {
+ public:
+ FakeHttpPortAllocatorSession(
+ HttpPortAllocator* allocator,
+ const std::string& name,
+ const std::string& session_type,
+ const std::vector<talk_base::SocketAddress>& stun_hosts,
+ const std::vector<std::string>& relay_hosts,
+ const std::string& relay_token,
+ const std::string& agent)
+ : TestHttpPortAllocatorSession(allocator,
+ name,
+ session_type,
+ stun_hosts,
+ relay_hosts,
+ relay_token,
+ agent) {
+ }
+ virtual void SendSessionRequest(const std::string& host, int port) {
+ FakeReceiveSessionResponse(host, port);
+ }
+
+ // Pass results to the real implementation.
+ void FakeReceiveSessionResponse(const std::string& host, int port) {
+ talk_base::AsyncHttpRequest* response = CreateAsyncHttpResponse(port);
+ TestHttpPortAllocatorSession::OnRequestDone(response);
+ response->Destroy(true);
+ }
+
+ private:
+ // Helper method for creating a response to a relay session request.
+ talk_base::AsyncHttpRequest* CreateAsyncHttpResponse(int port) {
+ talk_base::AsyncHttpRequest* request =
+ new talk_base::AsyncHttpRequest(kBrowserAgent);
+ std::stringstream ss;
+ ss << "username=" << kUserName << std::endl
+ << "password=" << kPassword << std::endl
+ << "magic_cookie=" << kMagicCookie << std::endl
+ << "relay.ip=" << kRelayAddr.IPAsString() << std::endl
+ << "relay.udp_port=" << kRelayUdpPort << std::endl
+ << "relay.tcp_port=" << kRelayTcpPort << std::endl
+ << "relay.ssltcp_port=" << kRelaySsltcpPort << std::endl;
+ request->response().document.reset(
+ new talk_base::MemoryStream(ss.str().c_str()));
+ request->response().set_success();
+ request->set_port(port);
+ request->set_secure(port == talk_base::HTTP_SECURE_PORT);
+ return request;
+ }
+};
+
+// Fake implementation for creating fake http sessions.
+class FakeHttpPortAllocator : public HttpPortAllocator {
+ public:
+ FakeHttpPortAllocator(talk_base::NetworkManager* network_manager,
+ const std::string& user_agent)
+ : HttpPortAllocator(network_manager, user_agent) {
+ }
+
+ virtual PortAllocatorSession* CreateSession(const std::string& name,
+ const std::string& session_type) {
+ std::vector<talk_base::SocketAddress> stun_hosts;
+ stun_hosts.push_back(kStunAddr);
+ std::vector<std::string> relay_hosts;
+ relay_hosts.push_back(kRelayHost);
+ return new FakeHttpPortAllocatorSession(this,
+ kSessionName,
+ kSessionType,
+ stun_hosts,
+ relay_hosts,
+ kRelayToken,
+ kBrowserAgent);
+ }
+};
+
+class ConnectivityCheckerForTest : public ConnectivityChecker {
+ public:
+ ConnectivityCheckerForTest(talk_base::Thread* worker,
+ const std::string& jid,
+ const std::string& session_id,
+ const std::string& user_agent,
+ const std::string& relay_token,
+ const std::string& connection)
+ : ConnectivityChecker(worker,
+ jid,
+ session_id,
+ user_agent,
+ relay_token,
+ connection),
+ proxy_initiated_(false) {
+ }
+
+ talk_base::FakeNetworkManager* network_manager() const {
+ return network_manager_;
+ }
+
+ FakeHttpPortAllocator* port_allocator() const {
+ return fake_port_allocator_;
+ }
+
+ protected:
+ // Overridden methods for faking a real network.
+ virtual talk_base::NetworkManager* CreateNetworkManager() {
+ network_manager_ = new talk_base::FakeNetworkManager();
+ return network_manager_;
+ }
+ virtual talk_base::BasicPacketSocketFactory* CreateSocketFactory(
+ talk_base::Thread* thread) {
+ // Create socket factory, for simplicity, let it run on the current thread.
+ socket_factory_ =
+ new talk_base::BasicPacketSocketFactory(talk_base::Thread::Current());
+ return socket_factory_;
+ }
+ virtual HttpPortAllocator* CreatePortAllocator(
+ talk_base::NetworkManager* network_manager,
+ const std::string& user_agent,
+ const std::string& relay_token) {
+ fake_port_allocator_ =
+ new FakeHttpPortAllocator(network_manager, user_agent);
+ return fake_port_allocator_;
+ }
+ virtual StunPort* CreateStunPort(const PortConfiguration* config,
+ talk_base::Network* network) {
+ return new FakeStunPort(worker(),
+ socket_factory_,
+ network,
+ network->ip(),
+ kMinPort,
+ kMaxPort,
+ config->stun_address);
+ }
+ virtual RelayPort* CreateRelayPort(const PortConfiguration* config,
+ talk_base::Network* network) {
+ return new FakeRelayPort(worker(),
+ socket_factory_,
+ network,
+ network->ip(),
+ kMinPort,
+ kMaxPort,
+ config->username,
+ config->password,
+ config->magic_cookie);
+ }
+ virtual void InitiateProxyDetection() {
+ if (!proxy_initiated_) {
+ proxy_initiated_ = true;
+ proxy_info_.address = kProxyAddr;
+ proxy_info_.type = kProxyType;
+ SetProxyInfo(proxy_info_);
+ }
+ }
+
+ virtual talk_base::ProxyInfo GetProxyInfo() const {
+ return proxy_info_;
+ }
+
+ private:
+ talk_base::BasicPacketSocketFactory* socket_factory_;
+ FakeHttpPortAllocator* fake_port_allocator_;
+ talk_base::FakeNetworkManager* network_manager_;
+ talk_base::ProxyInfo proxy_info_;
+ bool proxy_initiated_;
+};
+
+class ConnectivityCheckerTest : public testing::Test {
+ protected:
+ void VerifyNic(const NicInfo& info,
+ const talk_base::SocketAddress& local_address) {
+ // Verify that the external address has been set.
+ EXPECT_EQ(kExternalAddr, info.external_address);
+
+ // Verify that the stun server address has been set.
+ EXPECT_EQ(kStunAddr, info.stun_server_address);
+
+ // Verify that the media server address has been set. Don't care
+ // about port since it is different for different protocols.
+ EXPECT_EQ(kRelayAddr.ipaddr(), info.media_server_address.ipaddr());
+
+ // Verify that local ip matches.
+ EXPECT_EQ(local_address.ipaddr(), info.ip);
+
+ // Verify that we have received responses for our
+ // pings. Unsuccessful ping has rtt value -1, successful >= 0.
+ EXPECT_GE(info.stun.rtt, 0);
+ EXPECT_GE(info.udp.rtt, 0);
+ EXPECT_GE(info.tcp.rtt, 0);
+ EXPECT_GE(info.ssltcp.rtt, 0);
+
+ // If proxy has been set, verify address and type.
+ if (!info.proxy_info.address.IsNil()) {
+ EXPECT_EQ(kProxyAddr, info.proxy_info.address);
+ EXPECT_EQ(kProxyType, info.proxy_info.type);
+ }
+ }
+};
+
+// Tests a configuration with two network interfaces. Verifies that 4
+// combinations of ip/proxy are created and that all protocols are
+// tested on each combination.
+TEST_F(ConnectivityCheckerTest, TestStart) {
+ ConnectivityCheckerForTest connectivity_checker(talk_base::Thread::Current(),
+ kJid,
+ kSessionId,
+ kBrowserAgent,
+ kRelayToken,
+ kConnection);
+ connectivity_checker.Initialize();
+ connectivity_checker.set_stun_address(kStunAddr);
+ connectivity_checker.network_manager()->AddInterface(kClientAddr1);
+ connectivity_checker.network_manager()->AddInterface(kClientAddr2);
+
+ connectivity_checker.Start();
+ talk_base::Thread::Current()->ProcessMessages(1000);
+
+ NicMap nics = connectivity_checker.GetResults();
+
+ // There should be 4 nics in our map. 2 for each interface added,
+ // one with proxy set and one without.
+ EXPECT_EQ(4U, nics.size());
+
+ // First verify interfaces without proxy.
+ talk_base::SocketAddress nilAddress;
+
+ // First lookup the address of the first nic combined with no proxy.
+ NicMap::iterator i = nics.find(NicId(kClientAddr1.ipaddr(), nilAddress));
+ ASSERT(i != nics.end());
+ NicInfo info = i->second;
+ VerifyNic(info, kClientAddr1);
+
+ // Then make sure the second device has been tested without proxy.
+ i = nics.find(NicId(kClientAddr2.ipaddr(), nilAddress));
+ ASSERT(i != nics.end());
+ info = i->second;
+ VerifyNic(info, kClientAddr2);
+
+ // Now verify both interfaces with proxy.
+ i = nics.find(NicId(kClientAddr1.ipaddr(), kProxyAddr));
+ ASSERT(i != nics.end());
+ info = i->second;
+ VerifyNic(info, kClientAddr1);
+
+ i = nics.find(NicId(kClientAddr2.ipaddr(), kProxyAddr));
+ ASSERT(i != nics.end());
+ info = i->second;
+ VerifyNic(info, kClientAddr2);
+};
+
+// Tests that nothing bad happens if thera are no network interfaces
+// available to check.
+TEST_F(ConnectivityCheckerTest, TestStartNoNetwork) {
+ ConnectivityCheckerForTest connectivity_checker(talk_base::Thread::Current(),
+ kJid,
+ kSessionId,
+ kBrowserAgent,
+ kRelayToken,
+ kConnection);
+ connectivity_checker.Initialize();
+ connectivity_checker.Start();
+ talk_base::Thread::Current()->ProcessMessages(1000);
+
+ NicMap nics = connectivity_checker.GetResults();
+
+ // Verify that no nics where checked.
+ EXPECT_EQ(0U, nics.size());
+}
+
+} // namespace cricket
diff --git a/talk/p2p/client/httpportallocator.cc b/talk/p2p/client/httpportallocator.cc
index 1a25287..e231fab 100644
--- a/talk/p2p/client/httpportallocator.cc
+++ b/talk/p2p/client/httpportallocator.cc
@@ -27,6 +27,7 @@
#include "talk/p2p/client/httpportallocator.h"
+#include <algorithm>
#include <map>
#include "talk/base/asynchttprequest.h"
@@ -89,14 +90,13 @@
namespace cricket {
-// HttpPortAllocator
+// HttpPortAllocatorBase
-const int HttpPortAllocator::kHostPort = 80;
-const int HttpPortAllocator::kNumRetries = 5;
+const int HttpPortAllocatorBase::kNumRetries = 5;
-const char HttpPortAllocator::kCreateSessionURL[] = "/create_session";
+const char HttpPortAllocatorBase::kCreateSessionURL[] = "/create_session";
-HttpPortAllocator::HttpPortAllocator(
+HttpPortAllocatorBase::HttpPortAllocatorBase(
talk_base::NetworkManager* network_manager,
talk_base::PacketSocketFactory* socket_factory,
const std::string &user_agent)
@@ -106,7 +106,7 @@
talk_base::SocketAddress("stun.l.google.com", 19302));
}
-HttpPortAllocator::HttpPortAllocator(
+HttpPortAllocatorBase::HttpPortAllocatorBase(
talk_base::NetworkManager* network_manager,
const std::string &user_agent)
: BasicPortAllocator(network_manager), agent_(user_agent) {
@@ -115,19 +115,13 @@
talk_base::SocketAddress("stun.l.google.com", 19302));
}
-HttpPortAllocator::~HttpPortAllocator() {
+HttpPortAllocatorBase::~HttpPortAllocatorBase() {
}
-PortAllocatorSession *HttpPortAllocator::CreateSession(
- const std::string& name, const std::string& session_type) {
- return new HttpPortAllocatorSession(this, name, session_type, stun_hosts_,
- relay_hosts_, relay_token_, agent_);
-}
+// HttpPortAllocatorSessionBase
-// HttpPortAllocatorSession
-
-HttpPortAllocatorSession::HttpPortAllocatorSession(
- HttpPortAllocator* allocator, const std::string &name,
+HttpPortAllocatorSessionBase::HttpPortAllocatorSessionBase(
+ HttpPortAllocatorBase* allocator, const std::string &name,
const std::string& session_type,
const std::vector<talk_base::SocketAddress>& stun_hosts,
const std::vector<std::string>& relay_hosts,
@@ -138,7 +132,9 @@
relay_token_(relay_token), agent_(user_agent), attempts_(0) {
}
-void HttpPortAllocatorSession::GetPortConfigurations() {
+HttpPortAllocatorSessionBase::~HttpPortAllocatorSessionBase() {}
+
+void HttpPortAllocatorSessionBase::GetPortConfigurations() {
// Creating relay sessions can take time and is done asynchronously.
// Creating stun sessions could also take time and could be done aysnc also,
// but for now is done here and added to the initial config. Note any later
@@ -149,7 +145,7 @@
TryCreateRelaySession();
}
-void HttpPortAllocatorSession::TryCreateRelaySession() {
+void HttpPortAllocatorSessionBase::TryCreateRelaySession() {
if (allocator()->flags() & PORTALLOCATOR_DISABLE_RELAY) {
LOG(LS_VERBOSE) << "HttpPortAllocator: Relay ports disabled, skipping.";
return;
@@ -174,52 +170,10 @@
LOG(LS_WARNING) << "No relay auth token found.";
}
- SendSessionRequest(host, HttpPortAllocator::kHostPort);
+ SendSessionRequest(host, talk_base::HTTP_SECURE_PORT);
}
-void HttpPortAllocatorSession::SendSessionRequest(const std::string& host,
- int port) {
- // Initiate an HTTP request to create a session through the chosen host.
- talk_base::AsyncHttpRequest* request =
- new talk_base::AsyncHttpRequest(agent_);
- request->SignalWorkDone.connect(this,
- &HttpPortAllocatorSession::OnRequestDone);
-
- request->set_proxy(allocator()->proxy());
- request->response().document.reset(new talk_base::MemoryStream);
- request->request().verb = talk_base::HV_GET;
- request->request().path = HttpPortAllocator::kCreateSessionURL;
- request->request().addHeader("X-Talk-Google-Relay-Auth", relay_token_, true);
- request->request().addHeader("X-Google-Relay-Auth", relay_token_, true);
- request->request().addHeader("X-Session-Type", session_type(), true);
- request->request().addHeader("X-Stream-Type", name(), true);
- request->set_host(host);
- request->set_port(port);
- request->Start();
- request->Release();
-}
-
-void HttpPortAllocatorSession::OnRequestDone(talk_base::SignalThread* data) {
- talk_base::AsyncHttpRequest* request =
- static_cast<talk_base::AsyncHttpRequest*>(data);
- if (request->response().scode != 200) {
- LOG(LS_WARNING) << "HTTPPortAllocator: request "
- << " received error " << request->response().scode;
- TryCreateRelaySession();
- return;
- }
- LOG(LS_INFO) << "HTTPPortAllocator: request succeeded";
-
- talk_base::MemoryStream* stream =
- static_cast<talk_base::MemoryStream*>(request->response().document.get());
- stream->Rewind();
- size_t length;
- stream->GetSize(&length);
- std::string resp = std::string(stream->GetBuffer(), length);
- ReceiveSessionResponse(resp);
-}
-
-void HttpPortAllocatorSession::ReceiveSessionResponse(
+void HttpPortAllocatorSessionBase::ReceiveSessionResponse(
const std::string& response) {
StringMap map;
@@ -256,4 +210,99 @@
ConfigReady(config);
}
+// HttpPortAllocator
+
+HttpPortAllocator::HttpPortAllocator(
+ talk_base::NetworkManager* network_manager,
+ talk_base::PacketSocketFactory* socket_factory,
+ const std::string &user_agent)
+ : HttpPortAllocatorBase(network_manager, socket_factory, user_agent) {
+}
+
+HttpPortAllocator::HttpPortAllocator(
+ talk_base::NetworkManager* network_manager,
+ const std::string &user_agent)
+ : HttpPortAllocatorBase(network_manager, user_agent) {
+}
+HttpPortAllocator::~HttpPortAllocator() {}
+
+PortAllocatorSession* HttpPortAllocator::CreateSession(
+ const std::string& name, const std::string& session_type) {
+ return new HttpPortAllocatorSession(this, name, session_type, stun_hosts(),
+ relay_hosts(), relay_token(), user_agent());
+}
+
+// HttpPortAllocatorSession
+
+HttpPortAllocatorSession::HttpPortAllocatorSession(
+ HttpPortAllocator* allocator,
+ const std::string& name,
+ const std::string& session_type,
+ const std::vector<talk_base::SocketAddress>& stun_hosts,
+ const std::vector<std::string>& relay_hosts,
+ const std::string& relay,
+ const std::string& agent)
+ : HttpPortAllocatorSessionBase(allocator, name, session_type, stun_hosts,
+ relay_hosts, relay, agent) {
+}
+
+HttpPortAllocatorSession::~HttpPortAllocatorSession() {
+ for (std::list<talk_base::AsyncHttpRequest*>::iterator it = requests_.begin();
+ it != requests_.end(); ++it) {
+ (*it)->Destroy(true);
+ }
+}
+
+void HttpPortAllocatorSession::SendSessionRequest(const std::string& host,
+ int port) {
+ // Initiate an HTTP request to create a session through the chosen host.
+ talk_base::AsyncHttpRequest* request =
+ new talk_base::AsyncHttpRequest(user_agent());
+ request->SignalWorkDone.connect(this,
+ &HttpPortAllocatorSession::OnRequestDone);
+
+ request->set_secure(port == talk_base::HTTP_SECURE_PORT);
+ request->set_proxy(allocator()->proxy());
+ request->response().document.reset(new talk_base::MemoryStream);
+ request->request().verb = talk_base::HV_GET;
+ request->request().path = HttpPortAllocator::kCreateSessionURL;
+ request->request().addHeader("X-Talk-Google-Relay-Auth", relay_token(), true);
+ request->request().addHeader("X-Google-Relay-Auth", relay_token(), true);
+ request->request().addHeader("X-Session-Type", session_type(), true);
+ request->request().addHeader("X-Stream-Type", name(), true);
+ request->set_host(host);
+ request->set_port(port);
+ request->Start();
+ request->Release();
+ requests_.push_back(request);
+}
+
+void HttpPortAllocatorSession::OnRequestDone(talk_base::SignalThread* data) {
+ talk_base::AsyncHttpRequest* request =
+ static_cast<talk_base::AsyncHttpRequest*>(data);
+
+ // Remove the request from the list of active requests.
+ std::list<talk_base::AsyncHttpRequest*>::iterator it =
+ std::find(requests_.begin(), requests_.end(), request);
+ if (it != requests_.end()) {
+ requests_.erase(it);
+ }
+
+ if (request->response().scode != 200) {
+ LOG(LS_WARNING) << "HTTPPortAllocator: request "
+ << " received error " << request->response().scode;
+ TryCreateRelaySession();
+ return;
+ }
+ LOG(LS_INFO) << "HTTPPortAllocator: request succeeded";
+
+ talk_base::MemoryStream* stream =
+ static_cast<talk_base::MemoryStream*>(request->response().document.get());
+ stream->Rewind();
+ size_t length;
+ stream->GetSize(&length);
+ std::string resp = std::string(stream->GetBuffer(), length);
+ ReceiveSessionResponse(resp);
+}
+
} // namespace cricket
diff --git a/talk/p2p/client/httpportallocator.h b/talk/p2p/client/httpportallocator.h
index e7211c5..e47a69e 100644
--- a/talk/p2p/client/httpportallocator.h
+++ b/talk/p2p/client/httpportallocator.h
@@ -28,36 +28,39 @@
#ifndef TALK_P2P_CLIENT_HTTPPORTALLOCATOR_H_
#define TALK_P2P_CLIENT_HTTPPORTALLOCATOR_H_
+#include <list>
#include <string>
#include <vector>
#include "talk/p2p/client/basicportallocator.h"
namespace talk_base {
+class AsyncHttpRequest;
class SignalThread;
}
namespace cricket {
-class HttpPortAllocator : public BasicPortAllocator {
+class HttpPortAllocatorBase : public BasicPortAllocator {
public:
- // Records the port on the hosts that will receive HTTP requests.
- static const int kHostPort;
-
// The number of HTTP requests we should attempt before giving up.
static const int kNumRetries;
// Records the URL that we will GET in order to create a session.
static const char kCreateSessionURL[];
- HttpPortAllocator(talk_base::NetworkManager* network_manager,
- const std::string& user_agent);
- HttpPortAllocator(talk_base::NetworkManager* network_manager,
- talk_base::PacketSocketFactory* socket_factory,
- const std::string& user_agent);
- virtual ~HttpPortAllocator();
+ HttpPortAllocatorBase(talk_base::NetworkManager* network_manager,
+ const std::string& user_agent);
+ HttpPortAllocatorBase(talk_base::NetworkManager* network_manager,
+ talk_base::PacketSocketFactory* socket_factory,
+ const std::string& user_agent);
+ virtual ~HttpPortAllocatorBase();
- virtual PortAllocatorSession* CreateSession(const std::string& name,
- const std::string& session_type);
+ // CreateSession is defined in BasicPortAllocator but is
+ // redefined here as pure virtual.
+ virtual PortAllocatorSession* CreateSession(
+ const std::string& name,
+ const std::string& session_type) = 0;
+
void SetStunHosts(const std::vector<talk_base::SocketAddress>& hosts) {
if (!hosts.empty()) {
stun_hosts_ = hosts;
@@ -95,7 +98,58 @@
class RequestData;
-class HttpPortAllocatorSession : public BasicPortAllocatorSession {
+class HttpPortAllocatorSessionBase : public BasicPortAllocatorSession {
+ public:
+ HttpPortAllocatorSessionBase(
+ HttpPortAllocatorBase* allocator,
+ const std::string& name,
+ const std::string& session_type,
+ const std::vector<talk_base::SocketAddress>& stun_hosts,
+ const std::vector<std::string>& relay_hosts,
+ const std::string& relay,
+ const std::string& agent);
+ virtual ~HttpPortAllocatorSessionBase();
+
+ const std::string& relay_token() const {
+ return relay_token_;
+ }
+
+ const std::string& user_agent() const {
+ return agent_;
+ }
+
+ virtual void SendSessionRequest(const std::string& host, int port) = 0;
+ virtual void ReceiveSessionResponse(const std::string& response);
+
+ protected:
+ virtual void GetPortConfigurations();
+ void TryCreateRelaySession();
+ virtual HttpPortAllocatorBase* allocator() {
+ return static_cast<HttpPortAllocatorBase*>(
+ BasicPortAllocatorSession::allocator());
+ }
+
+ private:
+ std::vector<std::string> relay_hosts_;
+ std::vector<talk_base::SocketAddress> stun_hosts_;
+ std::string relay_token_;
+ std::string agent_;
+ int attempts_;
+};
+
+class HttpPortAllocator : public HttpPortAllocatorBase {
+ public:
+ HttpPortAllocator(talk_base::NetworkManager* network_manager,
+ const std::string& user_agent);
+ HttpPortAllocator(talk_base::NetworkManager* network_manager,
+ talk_base::PacketSocketFactory* socket_factory,
+ const std::string& user_agent);
+ virtual ~HttpPortAllocator();
+ virtual PortAllocatorSession* CreateSession(const std::string& name,
+ const std::string& session_type);
+};
+
+class HttpPortAllocatorSession : public HttpPortAllocatorSessionBase {
public:
HttpPortAllocatorSession(
HttpPortAllocator* allocator,
@@ -105,31 +159,16 @@
const std::vector<std::string>& relay_hosts,
const std::string& relay,
const std::string& agent);
- virtual ~HttpPortAllocatorSession() {}
+ virtual ~HttpPortAllocatorSession();
- const std::string& relay_token() const {
- return relay_token_;
- }
virtual void SendSessionRequest(const std::string& host, int port);
- virtual void ReceiveSessionResponse(const std::string& response);
protected:
- virtual void GetPortConfigurations();
- void TryCreateRelaySession();
+ // Protected for diagnostics.
+ virtual void OnRequestDone(talk_base::SignalThread* request);
private:
- virtual HttpPortAllocator* allocator() {
- return static_cast<HttpPortAllocator*>(
- BasicPortAllocatorSession::allocator());
- }
-
- void OnRequestDone(talk_base::SignalThread* request);
-
- std::vector<std::string> relay_hosts_;
- std::vector<talk_base::SocketAddress> stun_hosts_;
- std::string relay_token_;
- std::string agent_;
- int attempts_;
+ std::list<talk_base::AsyncHttpRequest*> requests_;
};
} // namespace cricket
diff --git a/talk/p2p/client/portallocator_unittest.cc b/talk/p2p/client/portallocator_unittest.cc
new file mode 100644
index 0000000..f5bb37c
--- /dev/null
+++ b/talk/p2p/client/portallocator_unittest.cc
@@ -0,0 +1,396 @@
+/*
+ * libjingle
+ * Copyright 2009 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/base/fakenetwork.h"
+#include "talk/base/firewallsocketserver.h"
+#include "talk/base/gunit.h"
+#include "talk/base/helpers.h"
+#include "talk/base/logging.h"
+#include "talk/base/network.h"
+#include "talk/base/physicalsocketserver.h"
+#include "talk/base/socketaddress.h"
+#include "talk/base/thread.h"
+#include "talk/base/virtualsocketserver.h"
+#include "talk/p2p/base/p2ptransportchannel.h"
+#include "talk/p2p/base/portallocatorsessionproxy.h"
+#include "talk/p2p/base/testrelayserver.h"
+#include "talk/p2p/base/teststunserver.h"
+#include "talk/p2p/client/basicportallocator.h"
+#include "talk/p2p/client/httpportallocator.h"
+
+using talk_base::SocketAddress;
+using talk_base::Thread;
+
+static const SocketAddress kClientAddr("11.11.11.11", 0);
+static const SocketAddress kRemoteClientAddr("22.22.22.22", 0);
+static const SocketAddress kStunAddr("99.99.99.1", cricket::STUN_SERVER_PORT);
+static const SocketAddress kRelayUdpIntAddr("99.99.99.2", 5000);
+static const SocketAddress kRelayUdpExtAddr("99.99.99.3", 5001);
+static const SocketAddress kRelayTcpIntAddr("99.99.99.2", 5002);
+static const SocketAddress kRelayTcpExtAddr("99.99.99.3", 5003);
+static const SocketAddress kRelaySslTcpIntAddr("99.99.99.2", 5004);
+static const SocketAddress kRelaySslTcpExtAddr("99.99.99.3", 5005);
+
+// Minimum and maximum port for port range tests.
+static const int kMinPort = 10000;
+static const int kMaxPort = 10099;
+
+// Helper for dumping candidates
+std::ostream& operator<<(std::ostream& os, const cricket::Candidate& c) {
+ os << c.ToString();
+ return os;
+}
+
+class PortAllocatorTest : public testing::Test, public sigslot::has_slots<> {
+ public:
+ static void SetUpTestCase() {
+ // Ensure the RNG is inited.
+ talk_base::InitRandom(NULL, 0);
+ }
+ PortAllocatorTest()
+ : pss_(new talk_base::PhysicalSocketServer),
+ vss_(new talk_base::VirtualSocketServer(pss_.get())),
+ fss_(new talk_base::FirewallSocketServer(vss_.get())),
+ ss_scope_(fss_.get()),
+ stun_server_(Thread::Current(), kStunAddr),
+ relay_server_(Thread::Current(), kRelayUdpIntAddr, kRelayUdpExtAddr,
+ kRelayTcpIntAddr, kRelayTcpExtAddr,
+ kRelaySslTcpIntAddr, kRelaySslTcpExtAddr),
+ allocator_(&network_manager_, kStunAddr,
+ kRelayUdpIntAddr, kRelayTcpIntAddr, kRelaySslTcpIntAddr) {
+ }
+
+ void AddInterface(const SocketAddress& addr) {
+ network_manager_.AddInterface(addr);
+ }
+ bool SetPortRange(int min_port, int max_port) {
+ return allocator_.SetPortRange(min_port, max_port);
+ }
+ bool CreateSession(const std::string& name, const std::string& type) {
+ session_.reset(allocator_.CreateSession(name, type));
+ if (!session_.get())
+ return false;
+
+ session_->SignalPortReady.connect(this,
+ &PortAllocatorTest::OnPortReady);
+ session_->SignalCandidatesReady.connect(this,
+ &PortAllocatorTest::OnCandidatesReady);
+ return true;
+ }
+
+ cricket::PortAllocatorSession* CreateSession(
+ const std::string& sid, const std::string& name,
+ const std::string& type, cricket::PortAllocator* allocator) {
+ cricket::PortAllocatorSession* session =
+ allocator->CreateSession(sid, name, type);
+ session->SignalPortReady.connect(this,
+ &PortAllocatorTest::OnPortReady);
+ session->SignalCandidatesReady.connect(this,
+ &PortAllocatorTest::OnCandidatesReady);
+ return session;
+ }
+
+ static bool CheckCandidate(const cricket::Candidate& c,
+ const std::string& name, const std::string& type,
+ const std::string& proto,
+ const SocketAddress& addr) {
+ return (c.name() == name && c.type() == type &&
+ c.protocol() == proto && c.address().ipaddr() == addr.ipaddr() &&
+ (addr.port() == 0 || (c.address().port() == addr.port())));
+ }
+ static bool CheckPort(const talk_base::SocketAddress& addr,
+ int min_port, int max_port) {
+ return (addr.port() >= min_port && addr.port() <= max_port);
+ }
+
+ cricket::PortAllocator* CreateAllocator() {
+ return new cricket::BasicPortAllocator(
+ &network_manager_, kStunAddr, SocketAddress(),
+ SocketAddress(), SocketAddress());
+ }
+
+ cricket::P2PTransportChannel* CreateTransportChannel(
+ const std::string& name, cricket::PortAllocator* allocator) {
+ return new cricket::P2PTransportChannel(name, "unittest", NULL, allocator);
+ }
+
+ protected:
+ cricket::BasicPortAllocator& allocator() { return allocator_; }
+
+ void OnPortReady(cricket::PortAllocatorSession* ses, cricket::Port* port) {
+ LOG(LS_INFO) << "OnPortReady: " << port->ToString();
+ ports_.push_back(port);
+ }
+ void OnCandidatesReady(cricket::PortAllocatorSession* ses,
+ const std::vector<cricket::Candidate>& candidates) {
+ for (size_t i = 0; i < candidates.size(); ++i) {
+ LOG(LS_INFO) << "OnCandidatesReady: " << candidates[i].ToString();
+ candidates_.push_back(candidates[i]);
+ }
+ }
+
+ talk_base::scoped_ptr<talk_base::PhysicalSocketServer> pss_;
+ talk_base::scoped_ptr<talk_base::VirtualSocketServer> vss_;
+ talk_base::scoped_ptr<talk_base::FirewallSocketServer> fss_;
+ talk_base::SocketServerScope ss_scope_;
+ cricket::TestStunServer stun_server_;
+ cricket::TestRelayServer relay_server_;
+ talk_base::FakeNetworkManager network_manager_;
+ cricket::BasicPortAllocator allocator_;
+ talk_base::scoped_ptr<cricket::PortAllocatorSession> session_;
+ std::vector<cricket::Port*> ports_;
+ std::vector<cricket::Candidate> candidates_;
+};
+
+// Tests that we can init the port allocator and create a session.
+TEST_F(PortAllocatorTest, TestBasic) {
+ EXPECT_EQ(&network_manager_, allocator().network_manager());
+ EXPECT_EQ(kStunAddr, allocator().stun_address());
+ EXPECT_EQ(kRelayUdpIntAddr, allocator().relay_address_udp());
+ EXPECT_EQ(kRelayTcpIntAddr, allocator().relay_address_tcp());
+ EXPECT_EQ(kRelaySslTcpIntAddr, allocator().relay_address_ssl());
+ EXPECT_TRUE(CreateSession("rtp", "unittest"));
+}
+
+// Tests that we can get the local and STUN addresses successfully.
+TEST_F(PortAllocatorTest, TestGetInitialPorts) {
+ AddInterface(kClientAddr);
+ EXPECT_TRUE(CreateSession("rtp", "unittest"));
+ session_->GetInitialPorts();
+ ASSERT_EQ_WAIT(2U, candidates_.size(), 1000);
+ EXPECT_PRED5(CheckCandidate, candidates_[0],
+ "rtp", "local", "udp", kClientAddr);
+ EXPECT_PRED5(CheckCandidate, candidates_[1],
+ "rtp", "stun", "udp", kClientAddr);
+ EXPECT_EQ(2U, ports_.size());
+}
+
+// Tests that we can get all the desired addresses successfully.
+TEST_F(PortAllocatorTest, TestGetAllPorts) {
+ AddInterface(kClientAddr);
+ EXPECT_TRUE(CreateSession("rtp", "unittest"));
+ session_->GetInitialPorts();
+ session_->StartGetAllPorts();
+ ASSERT_EQ_WAIT(2U, candidates_.size(), 1000);
+ EXPECT_EQ(2U, ports_.size());
+ ASSERT_EQ_WAIT(4U, candidates_.size(), 2000);
+ EXPECT_EQ(3U, ports_.size());
+ EXPECT_PRED5(CheckCandidate, candidates_[2],
+ "rtp", "relay", "udp", kRelayUdpIntAddr);
+ EXPECT_PRED5(CheckCandidate, candidates_[3],
+ "rtp", "relay", "udp", kRelayUdpExtAddr);
+ ASSERT_EQ_WAIT(6U, candidates_.size(), 1500);
+ EXPECT_PRED5(CheckCandidate, candidates_[4],
+ "rtp", "relay", "tcp", kRelayTcpIntAddr);
+ EXPECT_PRED5(CheckCandidate, candidates_[5],
+ "rtp", "local", "tcp", kClientAddr);
+ EXPECT_EQ(4U, ports_.size());
+ ASSERT_EQ_WAIT(7U, candidates_.size(), 2000);
+ EXPECT_PRED5(CheckCandidate, candidates_[6],
+ "rtp", "relay", "ssltcp", kRelaySslTcpIntAddr);
+ EXPECT_EQ(4U, ports_.size());
+}
+
+// Test that we restrict client ports appropriately when a port range is set.
+// We check the candidates for udp/stun/tcp ports, and the from address
+// for relay ports.
+TEST_F(PortAllocatorTest, TestGetAllPortsPortRange) {
+ AddInterface(kClientAddr);
+ // Check that an invalid port range fails.
+ EXPECT_FALSE(SetPortRange(kMaxPort, kMinPort));
+ // Check that a null port range succeeds.
+ EXPECT_TRUE(SetPortRange(0, 0));
+ // Check that a valid port range succeeds.
+ EXPECT_TRUE(SetPortRange(kMinPort, kMaxPort));
+ EXPECT_TRUE(CreateSession("rtp", "unittest"));
+ session_->GetInitialPorts();
+ session_->StartGetAllPorts();
+ ASSERT_EQ_WAIT(2U, candidates_.size(), 1000);
+ EXPECT_EQ(2U, ports_.size());
+ // Check the port number for the UDP port object.
+ EXPECT_PRED3(CheckPort, candidates_[0].address(), kMinPort, kMaxPort);
+ // Check the port number for the STUN port object.
+ EXPECT_PRED3(CheckPort, candidates_[1].address(), kMinPort, kMaxPort);
+ ASSERT_EQ_WAIT(4U, candidates_.size(), 2000);
+ EXPECT_EQ(3U, ports_.size());
+ // Check the port number used to connect to the relay server.
+ EXPECT_PRED3(CheckPort, relay_server_.GetConnection(0).source(),
+ kMinPort, kMaxPort);
+ ASSERT_EQ_WAIT(6U, candidates_.size(), 1500);
+ EXPECT_EQ(4U, ports_.size());
+ // Check the port number for the TCP port object.
+ EXPECT_PRED3(CheckPort, candidates_[5].address(), kMinPort, kMaxPort);
+}
+
+// Test that we don't crash or malfunction if we have no network adapters.
+// TODO: Find a way to exit early here.
+TEST_F(PortAllocatorTest, TestGetAllPortsNoAdapters) {
+ EXPECT_TRUE(CreateSession("rtp", "unittest"));
+ session_->GetInitialPorts();
+ session_->StartGetAllPorts();
+ WAIT(candidates_.size() > 0, 2000);
+}
+
+// Test that we don't crash or malfunction if we can't create UDP sockets.
+TEST_F(PortAllocatorTest, TestGetAllPortsNoUdpSockets) {
+ AddInterface(kClientAddr);
+ fss_->set_udp_sockets_enabled(false);
+ EXPECT_TRUE(CreateSession("rtp", "unittest"));
+ session_->GetInitialPorts();
+ session_->StartGetAllPorts();
+ ASSERT_EQ_WAIT(2U, candidates_.size(), 2000);
+ EXPECT_PRED5(CheckCandidate, candidates_[0],
+ "rtp", "relay", "udp", kRelayUdpIntAddr);
+ EXPECT_PRED5(CheckCandidate, candidates_[1],
+ "rtp", "relay", "udp", kRelayUdpExtAddr);
+ ASSERT_EQ_WAIT(4U, candidates_.size(), 2000);
+ EXPECT_PRED5(CheckCandidate, candidates_[2],
+ "rtp", "relay", "tcp", kRelayTcpIntAddr);
+ EXPECT_PRED5(CheckCandidate, candidates_[3],
+ "rtp", "local", "tcp", kClientAddr);
+ EXPECT_EQ(2U, ports_.size());
+ ASSERT_EQ_WAIT(5U, candidates_.size(), 2000);
+ EXPECT_PRED5(CheckCandidate, candidates_[4],
+ "rtp", "relay", "ssltcp", kRelaySslTcpIntAddr);
+ EXPECT_EQ(2U, ports_.size());
+}
+
+// Test that we don't crash or malfunction if we can't create UDP sockets or
+// listen on TCP sockets. We still give out a local TCP address, since
+// apparently this is needed for the remote side to accept our connection.
+TEST_F(PortAllocatorTest, TestGetAllPortsNoUdpSocketsNoTcpListen) {
+ AddInterface(kClientAddr);
+ fss_->set_udp_sockets_enabled(false);
+ fss_->set_tcp_listen_enabled(false);
+ EXPECT_TRUE(CreateSession("rtp", "unittest"));
+ session_->GetInitialPorts();
+ session_->StartGetAllPorts();
+ ASSERT_EQ_WAIT(2U, candidates_.size(), 3000);
+ EXPECT_PRED5(CheckCandidate, candidates_[0],
+ "rtp", "relay", "udp", kRelayUdpIntAddr);
+ EXPECT_PRED5(CheckCandidate, candidates_[1],
+ "rtp", "relay", "udp", kRelayUdpExtAddr);
+ ASSERT_EQ_WAIT(4U, candidates_.size(), 2000);
+ EXPECT_PRED5(CheckCandidate, candidates_[2],
+ "rtp", "relay", "tcp", kRelayTcpIntAddr);
+ EXPECT_PRED5(CheckCandidate, candidates_[3],
+ "rtp", "local", "tcp", kClientAddr);
+ EXPECT_EQ(2U, ports_.size());
+ ASSERT_EQ_WAIT(5U, candidates_.size(), 2000);
+ EXPECT_PRED5(CheckCandidate, candidates_[4],
+ "rtp", "relay", "ssltcp", kRelaySslTcpIntAddr);
+ EXPECT_EQ(2U, ports_.size());
+}
+
+// Test that we don't crash or malfunction if we can't create any sockets.
+// TODO: Find a way to exit early here.
+TEST_F(PortAllocatorTest, TestGetAllPortsNoSockets) {
+ AddInterface(kClientAddr);
+ fss_->set_tcp_sockets_enabled(false);
+ fss_->set_udp_sockets_enabled(false);
+ EXPECT_TRUE(CreateSession("rtp", "unittest"));
+ session_->GetInitialPorts();
+ session_->StartGetAllPorts();
+ WAIT(candidates_.size() > 0, 2000);
+}
+
+// Test that the httpportallocator correctly maintains its lists of stun and
+// relay servers, by never allowing an empty list.
+TEST(HttpPortAllocatorTest, TestHttpPortAllocatorHostLists) {
+ talk_base::FakeNetworkManager network_manager;
+ cricket::HttpPortAllocator alloc(&network_manager, "unit test agent");
+ EXPECT_EQ(1U, alloc.relay_hosts().size());
+ EXPECT_EQ(1U, alloc.stun_hosts().size());
+
+ std::vector<std::string> relay_servers;
+ std::vector<talk_base::SocketAddress> stun_servers;
+
+ alloc.SetRelayHosts(relay_servers);
+ alloc.SetStunHosts(stun_servers);
+ EXPECT_EQ(1U, alloc.relay_hosts().size());
+ EXPECT_EQ(1U, alloc.stun_hosts().size());
+
+ relay_servers.push_back("1.unittest.corp.google.com");
+ relay_servers.push_back("2.unittest.corp.google.com");
+ stun_servers.push_back(
+ talk_base::SocketAddress("1.unittest.corp.google.com", 0));
+ stun_servers.push_back(
+ talk_base::SocketAddress("2.unittest.corp.google.com", 0));
+ alloc.SetRelayHosts(relay_servers);
+ alloc.SetStunHosts(stun_servers);
+ EXPECT_EQ(2U, alloc.relay_hosts().size());
+ EXPECT_EQ(2U, alloc.stun_hosts().size());
+}
+
+TEST_F(PortAllocatorTest, TestBasicMuxFeatures) {
+ talk_base::scoped_ptr<cricket::PortAllocator> allocator(CreateAllocator());
+ allocator->set_flags(cricket::PORTALLOCATOR_ENABLE_BUNDLE);
+ // Session ID - session1.
+ talk_base::scoped_ptr<cricket::PortAllocatorSession> session1(
+ CreateSession("session1", "rtp", "audio", allocator.get()));
+ talk_base::scoped_ptr<cricket::PortAllocatorSession> session2(
+ CreateSession("session1", "rtcp", "audio", allocator.get()));
+ // We know that PortAllocator is creating a proxy session when bundle flag
+ // is enabled, it's safe to type cast session objects.
+ cricket::PortAllocatorSessionProxy* proxy1 =
+ static_cast<cricket::PortAllocatorSessionProxy*>(session1.get());
+ ASSERT_TRUE(proxy1 != NULL);
+ cricket::PortAllocatorSessionProxy* proxy2 =
+ static_cast<cricket::PortAllocatorSessionProxy*>(session2.get());
+ ASSERT_TRUE(proxy2 != NULL);
+ EXPECT_EQ(proxy1->impl(), proxy2->impl());
+ AddInterface(kClientAddr);
+ session1->GetInitialPorts();
+ session2->GetInitialPorts();
+ // Each session should receive two proxy ports of local and stun.
+ ASSERT_EQ_WAIT(4U, ports_.size(), 1000);
+ EXPECT_EQ(4U, candidates_.size());
+ EXPECT_PRED5(CheckCandidate, candidates_[0],
+ "rtp", "local", "udp", kClientAddr);
+ EXPECT_PRED5(CheckCandidate, candidates_[1],
+ "rtcp", "local", "udp", kClientAddr);
+ EXPECT_PRED5(CheckCandidate, candidates_[2],
+ "rtp", "stun", "udp", kClientAddr);
+ EXPECT_PRED5(CheckCandidate, candidates_[3],
+ "rtcp", "stun", "udp", kClientAddr);
+ talk_base::scoped_ptr<cricket::PortAllocatorSession> session3(
+ CreateSession("session1", "video_rtp", "video", allocator.get()));
+ // ListenToEvents(session3.get());
+ session3->GetInitialPorts();
+ // Since real ports and sessions are already allocated and signal sent, no
+ // new ports will be allocated when new proxy session created.
+ talk_base::Thread::Current()->ProcessMessages(1000);
+ EXPECT_NE(6U, ports_.size());
+ // Creating a PortAllocatorSession with different session name from above.
+ // In this case proxy PAS should have a different PAS.
+ // Session ID - session2.
+ talk_base::scoped_ptr<cricket::PortAllocatorSession> session4(
+ CreateSession("session2", "video_rtp", "video", allocator.get()));
+ cricket::PortAllocatorSessionProxy* proxy4 =
+ static_cast<cricket::PortAllocatorSessionProxy*>(session4.get());
+ EXPECT_NE(proxy4->impl(), proxy1->impl());
+}
diff --git a/talk/session/phone/audioframe.h b/talk/session/phone/audioframe.h
new file mode 100644
index 0000000..bcd8410
--- /dev/null
+++ b/talk/session/phone/audioframe.h
@@ -0,0 +1,61 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, 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_SESSION_PHONE_AUDIOFRAME_H_
+#define TALK_SESSION_PHONE_AUDIOFRAME_H_
+
+namespace cricket {
+
+class AudioFrame {
+ public:
+ AudioFrame()
+ : audio10ms_(NULL),
+ length_(0),
+ sampling_frequency_(8000),
+ stereo_(false) {
+ }
+ AudioFrame(int16* audio, size_t audio_length, int sample_freq, bool stereo)
+ : audio10ms_(audio),
+ length_(audio_length),
+ sampling_frequency_(sample_freq),
+ stereo_(stereo) {
+ }
+
+ int16* GetData() { return audio10ms_; }
+ size_t GetSize() const { return length_; }
+ int GetSamplingFrequency() const { return sampling_frequency_; }
+ bool GetStereo() const { return stereo_; }
+
+ private:
+ int16* audio10ms_;
+ size_t length_;
+ int sampling_frequency_;
+ bool stereo_;
+};
+
+} // namespace cricket
+#endif // TALK_SESSION_PHONE_AUDIOFRAME_H_
diff --git a/talk/session/phone/call.cc b/talk/session/phone/call.cc
index e01e937..0273353 100644
--- a/talk/session/phone/call.cc
+++ b/talk/session/phone/call.cc
@@ -29,6 +29,7 @@
#include "talk/base/helpers.h"
#include "talk/base/logging.h"
#include "talk/base/thread.h"
+#include "talk/p2p/base/parsing.h"
#include "talk/session/phone/call.h"
#include "talk/session/phone/mediasessionclient.h"
@@ -140,8 +141,8 @@
StaticVideoViews::const_iterator it;
for (it = view_request.static_video_views.begin();
it != view_request.static_video_views.end(); ++it) {
- NamedSource found_source;
- bool found = media_sources_.GetVideoSourceBySsrc(it->ssrc, &found_source);
+ StreamParams found_stream;
+ bool found = recv_streams_.GetVideoStreamBySsrc(it->ssrc, &found_stream);
if (!found) {
LOG(LS_WARNING) <<
"Tried sending view request for bad ssrc: " << it->ssrc;
@@ -151,7 +152,7 @@
XmlElements elems;
WriteError error;
- if (!WriteViewRequest(CN_VIDEO, view_request, &elems, &error)) {
+ if (!WriteJingleViewRequest(CN_VIDEO, view_request, &elems, &error)) {
LOG(LS_ERROR) << "Couldn't write out view request: " << error.text;
return false;
}
@@ -178,34 +179,41 @@
}
}
-void Call::AddVoiceStream(Session *session, uint32 voice_ssrc) {
+
+
+
+void Call::AddAudioRecvStream(Session *session, const StreamParams& stream) {
VoiceChannel *voice_channel = GetVoiceChannel(session);
- if (voice_channel && voice_ssrc) {
- voice_channel->AddStream(voice_ssrc);
+ if (voice_channel && stream.has_ssrcs()) {
+ voice_channel->AddRecvStream(stream);
}
+ recv_streams_.AddAudioStream(stream);
}
-void Call::AddVideoStream(Session *session, uint32 video_ssrc) {
+void Call::AddVideoRecvStream(Session *session, const StreamParams& stream) {
VideoChannel *video_channel = GetVideoChannel(session);
- if (video_channel && video_ssrc) {
- // TODO: Do we need the audio_ssrc here?
- // It doesn't seem to be used.
- video_channel->AddStream(video_ssrc, 0U);
+ if (video_channel && stream.has_ssrcs()) {
+ video_channel->AddRecvStream(stream);
}
+ recv_streams_.AddVideoStream(stream);
}
-void Call::RemoveVoiceStream(Session *session, uint32 voice_ssrc) {
+void Call::RemoveAudioRecvStream(Session *session, const StreamParams& stream) {
VoiceChannel *voice_channel = GetVoiceChannel(session);
- if (voice_channel && voice_ssrc) {
- voice_channel->RemoveStream(voice_ssrc);
+ // TODO: Change RemoveRecvStream to take a stream argument.
+ if (voice_channel && stream.has_ssrcs()) {
+ voice_channel->RemoveRecvStream(stream.first_ssrc());
}
+ recv_streams_.RemoveAudioStreamByNickAndName(stream.nick, stream.name);
}
-void Call::RemoveVideoStream(Session *session, uint32 video_ssrc) {
+void Call::RemoveVideoRecvStream(Session *session, const StreamParams& stream) {
VideoChannel *video_channel = GetVideoChannel(session);
- if (video_channel && video_ssrc) {
- video_channel->RemoveStream(video_ssrc);
+ // TODO: Change RemoveRecvStream to take a stream argument.
+ if (video_channel && stream.has_ssrcs()) {
+ video_channel->RemoveRecvStream(stream.first_ssrc());
}
+ recv_streams_.RemoveVideoStreamByNickAndName(stream.nick, stream.name);
}
void Call::OnMessage(talk_base::Message *message) {
@@ -239,13 +247,6 @@
VoiceChannel *voice_channel = NULL;
VideoChannel *video_channel = NULL;
- // Generate a random string for the RTCP CNAME, as stated in RFC 6222.
- // This string is only used for synchronization, and therefore is opaque.
- std::string rtcp_cname;
- if (!talk_base::CreateRandomString(16, &rtcp_cname)) {
- return false;
- }
-
const ContentInfo* audio_offer = GetFirstAudioContent(offer);
const ContentInfo* video_offer = GetFirstVideoContent(offer);
video_ = (video_offer != NULL);
@@ -257,7 +258,6 @@
// voice_channel can be NULL in case of NullVoiceEngine.
if (voice_channel) {
voice_channel_map_[session->id()] = voice_channel;
- voice_channel->SetRtcpCName(rtcp_cname);
voice_channel->SignalMediaMonitor.connect(this, &Call::OnMediaMonitor);
voice_channel->StartMediaMonitor(kMediaMonitorInterval);
} else {
@@ -271,7 +271,6 @@
// video_channel can be NULL in case of NullVideoEngine.
if (video_channel) {
video_channel_map_[session->id()] = video_channel;
- video_channel->SetRtcpCName(rtcp_cname);
video_channel->SignalMediaMonitor.connect(this, &Call::OnMediaMonitor);
video_channel->StartMediaMonitor(kMediaMonitorInterval);
} else {
@@ -284,7 +283,10 @@
sessions_.push_back(session);
session->SignalState.connect(this, &Call::OnSessionState);
session->SignalError.connect(this, &Call::OnSessionError);
- session->SignalInfoMessage.connect(this, &Call::OnSessionInfo);
+ session->SignalInfoMessage.connect(
+ this, &Call::OnSessionInfoMessage);
+ session->SignalRemoteDescriptionUpdate.connect(
+ this, &Call::OnRemoteDescriptionUpdate);
session->SignalReceivedTerminateReason
.connect(this, &Call::OnReceivedTerminateReason);
@@ -553,11 +555,10 @@
}
void Call::OnSpeakerMonitor(CurrentSpeakerMonitor* monitor, uint32 ssrc) {
- NamedSource source;
- source.ssrc = ssrc;
- media_sources_.GetAudioSourceBySsrc(ssrc, &source);
+ StreamParams stream;
+ recv_streams_.GetAudioStreamBySsrc(ssrc, &stream);
SignalSpeakerMonitor(this, static_cast<Session *>(monitor->session()),
- source);
+ stream);
}
void Call::OnConnectionMonitor(VideoChannel *channel,
@@ -593,92 +594,136 @@
SignalSessionError(this, static_cast<Session *>(session), error);
}
-void Call::OnSessionInfo(Session *session,
- const buzz::XmlElement* action_elem) {
- // We have a different list of "updates" because we only want to
- // signal the sources that were added or removed. We want to filter
- // out un-changed sources.
- cricket::MediaSources updates;
+void Call::OnSessionInfoMessage(Session *session,
+ const buzz::XmlElement* action_elem) {
+ if (!IsJingleViewRequest(action_elem)) {
+ return;
+ }
- if (IsSourcesNotify(action_elem)) {
- MediaSources sources;
- ParseError error;
- if (!ParseSourcesNotify(action_elem, session->remote_description(),
- &sources, &error)) {
- // TODO: Is there a way we can signal an IQ error
- // back to the sender?
- LOG(LS_WARNING) << "Invalid sources notify message: " << error.text;
- return;
- }
+ ViewRequest view_request;
+ ParseError error;
+ if (!ParseJingleViewRequest(action_elem, &view_request, &error)) {
+ LOG(LS_WARNING) << "Failed to parse view request: " << error.text;
+ return;
+ }
- NamedSources::iterator it;
- for (it = sources.mutable_audio()->begin();
- it != sources.mutable_audio()->end(); ++it) {
- bool found = false;
- NamedSource found_source;
- if (it->ssrc_set) {
- found = media_sources_.GetAudioSourceBySsrc(it->ssrc, &found_source);
- } else {
- // For backwards compatibility, we remove by nick.
- // TODO: Remove once all senders use explicit remove by ssrc.
- found = media_sources_.GetFirstAudioSourceByNick(it->nick,
- &found_source);
- if (found) {
- it->SetSsrc(found_source.ssrc);
- it->removed = true;
- } else {
- continue; // No ssrc to remove.
- }
- }
- if (it->removed && found) {
- RemoveVoiceStream(session, found_source.ssrc);
- media_sources_.RemoveAudioSourceBySsrc(it->ssrc);
- updates.mutable_audio()->push_back(*it);
- LOG(LS_INFO) << "Removed voice stream: " << found_source.ssrc;
- } else if (!it->removed && !found) {
- AddVoiceStream(session, it->ssrc);
- media_sources_.AddAudioSource(*it);
- updates.mutable_audio()->push_back(*it);
- LOG(LS_INFO) << "Added voice stream: " << it->ssrc;
- }
- }
- for (it = sources.mutable_video()->begin();
- it != sources.mutable_video()->end(); ++it) {
- bool found = false;
- NamedSource found_source;
- if (it->ssrc_set) {
- found = media_sources_.GetVideoSourceBySsrc(it->ssrc, &found_source);
- } else {
- // For backwards compatibility, we remove by nick.
- // TODO: Remove once all senders use explicit remove by ssrc.
- found = media_sources_.GetFirstVideoSourceByNick(it->nick,
- &found_source);
- if (found) {
- it->SetSsrc(found_source.ssrc);
- it->removed = true;
- } else {
- continue; // No ssrc to remove.
- }
- }
- if (it->removed && found) {
- RemoveVideoStream(session, found_source.ssrc);
- media_sources_.RemoveVideoSourceBySsrc(it->ssrc);
- updates.mutable_video()->push_back(*it);
- LOG(LS_INFO) << "Removed video stream: " << found_source.ssrc;
- } else if (!it->removed && !found) {
- AddVideoStream(session, it->ssrc);
- media_sources_.AddVideoSource(*it);
- updates.mutable_video()->push_back(*it);
- LOG(LS_INFO) << "Added video stream: " << it->ssrc;
- }
- }
+ VideoChannel *video_channel = GetVideoChannel(session);
+ if (video_channel == NULL) {
+ LOG(LS_WARNING) << "Ignore view request since we have no video channel.";
+ return;
+ }
- if (!updates.audio().empty() || !updates.video().empty()) {
- SignalMediaSourcesUpdate(this, session, updates);
+ if (!video_channel->ApplyViewRequest(view_request)) {
+ LOG(LS_WARNING) << "Failed to ApplyViewRequest.";
+ }
+}
+
+void FindStreamChanges(const std::vector<StreamParams>& streams,
+ const std::vector<StreamParams>& updates,
+ std::vector<StreamParams>* added_streams,
+ std::vector<StreamParams>* removed_streams) {
+ for (std::vector<StreamParams>::const_iterator update = updates.begin();
+ update != updates.end(); ++update) {
+ StreamParams stream;
+ if (GetStreamByNickAndName(streams, update->nick, update->name, &stream)) {
+ if (!update->has_ssrcs()) {
+ removed_streams->push_back(stream);
+ }
+ } else {
+ // There's a bug on reflector that will send <stream>s even
+ // though there is not ssrc (which means there isn't really a
+ // stream). To work around it, we simply ignore new <stream>s
+ // that don't have any ssrcs.
+ if (update->has_ssrcs()) {
+ added_streams->push_back(*update);
+ }
}
}
}
+void Call::OnRemoteDescriptionUpdate(BaseSession *base_session,
+ const ContentInfos& updated_contents) {
+ Session* session = static_cast<Session *>(base_session);
+
+ cricket::MediaStreams added_streams;
+ cricket::MediaStreams removed_streams;
+ std::vector<StreamParams>::const_iterator stream;
+
+ const ContentInfo* audio_content = GetFirstAudioContent(updated_contents);
+ if (audio_content) {
+ const AudioContentDescription* audio_update =
+ static_cast<const AudioContentDescription*>(audio_content->description);
+ if (!audio_update->codecs().empty()) {
+ UpdateVoiceChannelRemoteContent(session, audio_update);
+ }
+
+ FindStreamChanges(recv_streams_.audio(),
+ audio_update->streams(),
+ added_streams.mutable_audio(),
+ removed_streams.mutable_audio());
+ for (stream = added_streams.audio().begin();
+ stream != added_streams.audio().end();
+ ++stream) {
+ AddAudioRecvStream(session, *stream);
+ }
+ for (stream = removed_streams.audio().begin();
+ stream != removed_streams.audio().end();
+ ++stream) {
+ RemoveAudioRecvStream(session, *stream);
+ }
+ }
+
+ const ContentInfo* video_content = GetFirstVideoContent(updated_contents);
+ if (video_content) {
+ const VideoContentDescription* video_update =
+ static_cast<const VideoContentDescription*>(video_content->description);
+ if (!video_update->codecs().empty()) {
+ UpdateVideoChannelRemoteContent(session, video_update);
+ }
+
+ FindStreamChanges(recv_streams_.video(),
+ video_update->streams(),
+ added_streams.mutable_video(),
+ removed_streams.mutable_video());
+ for (stream = added_streams.video().begin();
+ stream != added_streams.video().end();
+ ++stream) {
+ AddVideoRecvStream(session, *stream);
+ }
+ for (stream = removed_streams.video().begin();
+ stream != removed_streams.video().end();
+ ++stream) {
+ RemoveVideoRecvStream(session, *stream);
+ }
+ }
+
+ if (!added_streams.empty() || !removed_streams.empty()) {
+ SignalMediaStreamsUpdate(this, session, added_streams, removed_streams);
+ }
+}
+
+bool Call::UpdateVoiceChannelRemoteContent(
+ Session* session, const AudioContentDescription* audio) {
+ VoiceChannel *voice_channel = GetVoiceChannel(session);
+ if (!voice_channel->SetRemoteContent(audio, CA_UPDATE)) {
+ LOG(LS_ERROR) << "Failure in audio SetRemoteContent with CA_UPDATE";
+ session->SetError(BaseSession::ERROR_CONTENT);
+ return false;
+ }
+ return true;
+}
+
+bool Call::UpdateVideoChannelRemoteContent(
+ Session* session, const VideoContentDescription* video) {
+ VideoChannel *video_channel = GetVideoChannel(session);
+ if (!video_channel->SetRemoteContent(video, CA_UPDATE)) {
+ LOG(LS_ERROR) << "Failure in video SetRemoteContent with CA_UPDATE";
+ session->SetError(BaseSession::ERROR_CONTENT);
+ return false;
+ }
+ return true;
+}
+
void Call::OnReceivedTerminateReason(Session *session,
const std::string &reason) {
session_client_->session_manager()->signaling_thread()->Clear(this,
diff --git a/talk/session/phone/call.h b/talk/session/phone/call.h
index 357f884..e081c55 100644
--- a/talk/session/phone/call.h
+++ b/talk/session/phone/call.h
@@ -40,6 +40,7 @@
#include "talk/session/phone/currentspeakermonitor.h"
#include "talk/session/phone/mediamessages.h"
#include "talk/session/phone/mediasession.h"
+#include "talk/session/phone/streamparams.h"
namespace cricket {
@@ -61,7 +62,7 @@
void RejectSession(Session *session);
void TerminateSession(Session *session);
void Terminate();
- bool SendViewRequest(Session* session,
+ bool SendViewRequest(Session *session,
const ViewRequest& view_request);
void SetLocalRenderer(VideoRenderer* renderer);
void SetVideoRenderer(Session *session, uint32 ssrc,
@@ -105,23 +106,30 @@
SignalConnectionMonitor;
sigslot::signal2<Call *, const VoiceMediaInfo&> SignalMediaMonitor;
sigslot::signal2<Call *, const AudioInfo&> SignalAudioMonitor;
- // Empty nick on NamedSource means "unknown".
- // Ssrc of 0 on NamedSource means "no current speaker".
+ // Empty nick on StreamParams means "unknown".
+ // No ssrcs in StreamParams means "no current speaker".
sigslot::signal3<Call *,
Session *,
- const NamedSource&> SignalSpeakerMonitor;
+ const StreamParams&> SignalSpeakerMonitor;
sigslot::signal2<Call *, const std::vector<ConnectionInfo> &>
SignalVideoConnectionMonitor;
sigslot::signal2<Call *, const VideoMediaInfo&> SignalVideoMediaMonitor;
- sigslot::signal3<Call *,
+ // Gives added streams and removed streams, in that order.
+ sigslot::signal4<Call *,
Session *,
- const MediaSources&> SignalMediaSourcesUpdate;
+ const MediaStreams&,
+ const MediaStreams&> SignalMediaStreamsUpdate;
private:
void OnMessage(talk_base::Message *message);
void OnSessionState(BaseSession *session, BaseSession::State state);
void OnSessionError(BaseSession *session, Session::Error error);
- void OnSessionInfo(Session *session, const buzz::XmlElement* action_elem);
+ void OnSessionInfoMessage(
+ Session *session, const buzz::XmlElement* action_elem);
+ void OnViewRequest(
+ Session *session, const ViewRequest& view_request);
+ void OnRemoteDescriptionUpdate(
+ BaseSession *session, const ContentInfos& updated_contents);
void OnReceivedTerminateReason(Session *session, const std::string &reason);
void IncomingSession(Session *session, const SessionDescription* offer);
// Returns true on success.
@@ -137,18 +145,24 @@
void OnConnectionMonitor(VideoChannel *channel,
const std::vector<ConnectionInfo> &infos);
void OnMediaMonitor(VideoChannel *channel, const VideoMediaInfo& info);
- VoiceChannel* GetVoiceChannel(Session* session);
- VideoChannel* GetVideoChannel(Session* session);
- void AddVoiceStream(Session *session, uint32 voice_ssrc);
- void AddVideoStream(Session *session, uint32 video_ssrc);
- void RemoveVoiceStream(Session *session, uint32 voice_ssrc);
- void RemoveVideoStream(Session *session, uint32 video_ssrc);
+ VoiceChannel* GetVoiceChannel(Session *session);
+ VideoChannel* GetVideoChannel(Session *session);
+ bool UpdateVoiceChannelRemoteContent(Session *session,
+ const AudioContentDescription* audio);
+ bool UpdateVideoChannelRemoteContent(Session *session,
+ const VideoContentDescription* video);
+ void AddAudioRecvStream(Session *session, const StreamParams& audio_stream);
+ void AddVideoRecvStream(Session *session, const StreamParams& video_stream);
+ void RemoveAudioRecvStream(
+ Session *session, const StreamParams& audio_stream);
+ void RemoveVideoRecvStream(
+ Session *session, const StreamParams& video_stream);
void ContinuePlayDTMF();
uint32 id_;
MediaSessionClient *session_client_;
std::vector<Session *> sessions_;
- MediaSources media_sources_;
+ MediaStreams recv_streams_;
std::map<std::string, VoiceChannel *> voice_channel_map_;
std::map<std::string, VideoChannel *> video_channel_map_;
std::map<std::string, CurrentSpeakerMonitor *> speaker_monitor_map_;
diff --git a/talk/session/phone/channel.cc b/talk/session/phone/channel.cc
index 9cc88ff..1481887 100644
--- a/talk/session/phone/channel.cc
+++ b/talk/session/phone/channel.cc
@@ -33,16 +33,143 @@
#include "talk/base/logging.h"
#include "talk/p2p/base/transportchannel.h"
#include "talk/session/phone/channelmanager.h"
+#include "talk/session/phone/mediamessages.h"
#include "talk/session/phone/mediasessionclient.h"
#include "talk/session/phone/rtcpmuxfilter.h"
#include "talk/session/phone/rtputils.h"
namespace cricket {
+enum {
+ MSG_ENABLE = 1,
+ MSG_DISABLE = 2,
+ MSG_MUTE = 3,
+ MSG_UNMUTE = 4,
+ MSG_SETREMOTECONTENT = 5,
+ MSG_SETLOCALCONTENT = 6,
+ MSG_EARLYMEDIATIMEOUT = 8,
+ MSG_PRESSDTMF = 9,
+ MSG_SETRENDERER = 10,
+ MSG_ADDRECVSTREAM = 11,
+ MSG_REMOVERECVSTREAM = 12,
+ MSG_SETRINGBACKTONE = 13,
+ MSG_PLAYRINGBACKTONE = 14,
+ MSG_SETMAXSENDBANDWIDTH = 15,
+ MSG_ADDSCREENCAST = 16,
+ MSG_REMOVESCREENCAST = 17,
+ // Removed MSG_SETRTCPCNAME = 18. It is no longer used.
+ MSG_SENDINTRAFRAME = 19,
+ MSG_REQUESTINTRAFRAME = 20,
+ MSG_SCREENCASTWINDOWEVENT = 21,
+ MSG_RTPPACKET = 22,
+ MSG_RTCPPACKET = 23,
+ MSG_CHANNEL_ERROR = 24,
+ MSG_ENABLECPUADAPTATION = 25,
+ MSG_DISABLECPUADAPTATION = 26,
+ MSG_SCALEVOLUME = 27,
+ MSG_HANDLEVIEWREQUEST = 28
+};
+
+struct SetContentData : public talk_base::MessageData {
+ SetContentData(const MediaContentDescription* content, ContentAction action)
+ : content(content),
+ action(action),
+ result(false) {
+ }
+ const MediaContentDescription* content;
+ ContentAction action;
+ bool result;
+};
+
+struct SetBandwidthData : public talk_base::MessageData {
+ explicit SetBandwidthData(int value) : value(value), result(false) {}
+ int value;
+ bool result;
+};
+
+struct SetRingbackToneMessageData : public talk_base::MessageData {
+ SetRingbackToneMessageData(const void* b, int l)
+ : buf(b),
+ len(l),
+ result(false) {
+ }
+ const void* buf;
+ int len;
+ bool result;
+};
+
+struct PlayRingbackToneMessageData : public talk_base::MessageData {
+ PlayRingbackToneMessageData(uint32 s, bool p, bool l)
+ : ssrc(s),
+ play(p),
+ loop(l),
+ result(false) {
+ }
+ uint32 ssrc;
+ bool play;
+ bool loop;
+ bool result;
+};
+struct DtmfMessageData : public talk_base::MessageData {
+ DtmfMessageData(int d, bool p)
+ : digit(d),
+ playout(p),
+ result(false) {
+ }
+ int digit;
+ bool playout;
+ bool result;
+};
+struct ScaleVolumeMessageData : public talk_base::MessageData {
+ ScaleVolumeMessageData(uint32 s, double l, double r)
+ : ssrc(s),
+ left(l),
+ right(r),
+ result(false) {
+ }
+ uint32 ssrc;
+ double left;
+ double right;
+ bool result;
+};
+
struct PacketMessageData : public talk_base::MessageData {
talk_base::Buffer packet;
};
+struct RenderMessageData : public talk_base::MessageData {
+ RenderMessageData(uint32 s, VideoRenderer* r) : ssrc(s), renderer(r) {}
+ uint32 ssrc;
+ VideoRenderer* renderer;
+};
+
+struct ScreencastMessageData : public talk_base::MessageData {
+ ScreencastMessageData(uint32 s, const ScreencastId& id)
+ : ssrc(s),
+ window_id(id) {
+ }
+ uint32 ssrc;
+ ScreencastId window_id;
+};
+
+struct ScreencastEventData : public talk_base::MessageData {
+ ScreencastEventData(uint32 s, talk_base::WindowEvent we)
+ : ssrc(s),
+ event(we) {
+ }
+ uint32 ssrc;
+ talk_base::WindowEvent event;
+};
+
+struct ViewRequestMessageData : public talk_base::MessageData {
+ explicit ViewRequestMessageData(const ViewRequest& r)
+ : request(r),
+ result(false) {
+ }
+ ViewRequest request;
+ bool result;
+};
+
struct VoiceChannelErrorMessageData : public talk_base::MessageData {
VoiceChannelErrorMessageData(uint32 in_ssrc,
VoiceMediaChannel::Error in_error)
@@ -61,6 +188,18 @@
VideoMediaChannel::Error error;
};
+struct SsrcMessageData : public talk_base::MessageData {
+ explicit SsrcMessageData(uint32 ssrc) : ssrc(ssrc), result(false) {}
+ uint32 ssrc;
+ bool result;
+};
+
+struct StreamMessageData : public talk_base::MessageData {
+ explicit StreamMessageData(const StreamParams& sp) : sp(sp), result(false) {}
+ StreamParams sp;
+ bool result;
+};
+
static const char* PacketType(bool rtcp) {
return (!rtcp) ? "RTP" : "RTCP";
}
@@ -125,35 +264,34 @@
this, &BaseChannel::OnChannelRead);
session_->SignalState.connect(this, &BaseChannel::OnSessionState);
- session_->SignalRemoteDescriptionUpdate.connect(this,
- &BaseChannel::OnRemoteDescriptionUpdate);
OnSessionState(session(), session()->state());
set_rtcp_transport_channel(rtcp_transport_channel);
return true;
}
+// Can be called from thread other than worker thread
bool BaseChannel::Enable(bool enable) {
- // Can be called from thread other than worker thread
Send(enable ? MSG_ENABLE : MSG_DISABLE);
return true;
}
+// Can be called from thread other than worker thread
bool BaseChannel::Mute(bool mute) {
- // Can be called from thread other than worker thread
+ Clear(MSG_UNMUTE); // Clear any penging auto-unmutes.
Send(mute ? MSG_MUTE : MSG_UNMUTE);
return true;
}
-bool BaseChannel::RemoveStream(uint32 ssrc) {
- StreamMessageData data(ssrc, 0);
- Send(MSG_REMOVESTREAM, &data);
- return true;
+bool BaseChannel::AddRecvStream(const StreamParams& sp) {
+ StreamMessageData data(sp);
+ Send(MSG_ADDRECVSTREAM, &data);
+ return data.result;
}
-bool BaseChannel::SetRtcpCName(const std::string& cname) {
- SetRtcpCNameData data(cname);
- Send(MSG_SETRTCPCNAME, &data);
+bool BaseChannel::RemoveRecvStream(uint32 ssrc) {
+ SsrcMessageData data(ssrc);
+ Send(MSG_REMOVERECVSTREAM, &data);
return data.result;
}
@@ -346,6 +484,14 @@
return;
}
+ // If this channel is suppose to handle RTP data, that is determined by
+ // checking against ssrc filter. This is necessary to do it here to avoid
+ // double decryption.
+ if (ssrc_filter_.IsActive() &&
+ !ssrc_filter_.DemuxPacket(packet->data(), packet->length(), rtcp)) {
+ return;
+ }
+
// Signal to the media sink before unprotecting the packet. TODO:
// Separate APIs to record unprotected media and protected header.
{
@@ -429,16 +575,6 @@
}
}
-void BaseChannel::OnRemoteDescriptionUpdate(BaseSession* session) {
- const MediaContentDescription* content =
- GetFirstContent(session->remote_description());
-
- if (content && !SetRemoteContent(content, CA_UPDATE)) {
- LOG(LS_ERROR) << "Failure in SetRemoteContent with CA_UPDATE";
- session->SetError(BaseSession::ERROR_CONTENT);
- }
-}
-
void BaseChannel::EnableMedia_w() {
ASSERT(worker_thread_ == talk_base::Thread::Current());
if (enabled_)
@@ -509,10 +645,6 @@
return media_channel()->SetSendBandwidth(true, max_bandwidth);
}
-bool BaseChannel::SetRtcpCName_w(const std::string& cname) {
- return media_channel()->SetRtcpCName(cname);
-}
-
bool BaseChannel::SetSrtp_w(const std::vector<CryptoParams>& cryptos,
ContentAction action, ContentSource src) {
bool ret;
@@ -549,6 +681,177 @@
return ret;
}
+bool BaseChannel::AddRecvStream_w(const StreamParams& sp) {
+ ASSERT(worker_thread() == talk_base::Thread::Current());
+ if (!media_channel()->AddRecvStream(sp))
+ return false;
+
+ return ssrc_filter_.AddStream(sp);
+}
+
+bool BaseChannel::RemoveRecvStream_w(uint32 ssrc) {
+ ASSERT(worker_thread() == talk_base::Thread::Current());
+ ssrc_filter_.RemoveStream(ssrc);
+ return media_channel()->RemoveRecvStream(ssrc);
+}
+
+bool BaseChannel::UpdateLocalStreams_w(const std::vector<StreamParams>& streams,
+ ContentAction action) {
+ if (!VERIFY(action == CA_OFFER || action == CA_ANSWER || action == CA_UPDATE))
+ return false;
+
+ // If this is an update, streams only contain streams that have changed.
+ if (action == CA_UPDATE) {
+ for (StreamParamsVec::const_iterator it = streams.begin();
+ it != streams.end(); ++it) {
+ StreamParams existing_stream;
+ bool stream_exist = GetStreamByNickAndName(local_streams_, it->nick,
+ it->name, &existing_stream);
+ if (!stream_exist && it->has_ssrcs()) {
+ if (media_channel()->AddSendStream(*it)) {
+ local_streams_.push_back(*it);
+ LOG(LS_INFO) << "Add send stream ssrc: " << it->first_ssrc();
+ } else {
+ LOG(LS_INFO) << "Failed to add send stream ssrc: "
+ << it->first_ssrc();
+ return false;
+ }
+ } else if (stream_exist && !it->has_ssrcs()) {
+ if (!media_channel()->RemoveSendStream(existing_stream.first_ssrc())) {
+ LOG(LS_ERROR) << "Failed to remove send stream with ssrc "
+ << it->first_ssrc() << ".";
+ return false;
+ }
+ RemoveStreamBySsrc(&local_streams_, existing_stream.first_ssrc());
+ } else {
+ LOG(LS_WARNING) << "Ignore unsupported stream update";
+ }
+ }
+ return true;
+ }
+ // Else streams are all the streams we want to send.
+
+ // Check for streams that have been removed.
+ bool ret = true;
+ for (StreamParamsVec::const_iterator it = local_streams_.begin();
+ it != local_streams_.end(); ++it) {
+ if (!GetStreamBySsrc(streams, it->first_ssrc(), NULL)) {
+ if (!media_channel()->RemoveSendStream(it->first_ssrc())) {
+ LOG(LS_ERROR) << "Failed to remove send stream with ssrc "
+ << it->first_ssrc() << ".";
+ ret = false;
+ }
+ }
+ }
+ // Check for new streams.
+ for (StreamParamsVec::const_iterator it = streams.begin();
+ it != streams.end(); ++it) {
+ if (!GetStreamBySsrc(local_streams_, it->first_ssrc(), NULL)) {
+ if (media_channel()->AddSendStream(*it)) {
+ LOG(LS_INFO) << "Add send ssrc: " << it->ssrcs[0];
+ } else {
+ LOG(LS_INFO) << "Failed to add send stream ssrc: " << it->first_ssrc();
+ ret = false;
+ }
+ }
+ }
+ local_streams_ = streams;
+ return ret;
+}
+
+bool BaseChannel::UpdateRemoteStreams_w(
+ const std::vector<StreamParams>& streams,
+ ContentAction action) {
+ // If this is an update, streams only contain streams that have changed.
+ if (action == CA_UPDATE) {
+ for (StreamParamsVec::const_iterator it = streams.begin();
+ it != streams.end(); ++it) {
+ StreamParams existing_stream;
+ bool stream_exists = GetStreamByNickAndName(remote_streams_, it->nick,
+ it->name, &existing_stream);
+ if (!stream_exists && it->has_ssrcs()) {
+ if (AddRecvStream_w(*it)) {
+ remote_streams_.push_back(*it);
+ LOG(LS_INFO) << "Add remote stream ssrc: " << it->first_ssrc();
+ } else {
+ LOG(LS_INFO) << "Failed to add remote stream ssrc: "
+ << it->first_ssrc();
+ return false;
+ }
+ } else if (stream_exists && !it->has_ssrcs()) {
+ if (!RemoveRecvStream_w(existing_stream.first_ssrc())) {
+ LOG(LS_ERROR) << "Failed to remove remote stream with ssrc "
+ << it->first_ssrc() << ".";
+ return false;
+ }
+ RemoveStreamBySsrc(&remote_streams_, existing_stream.first_ssrc());
+ } else {
+ LOG(LS_WARNING) << "Ignore unsupported stream update";
+ }
+ }
+ return true;
+ }
+ // Else streams are all the streams we want to receive.
+
+ // Check for streams that have been removed.
+ bool ret = true;
+ for (StreamParamsVec::const_iterator it = remote_streams_.begin();
+ it != remote_streams_.end(); ++it) {
+ if (!GetStreamBySsrc(streams, it->first_ssrc(), NULL)) {
+ if (!RemoveRecvStream_w(it->first_ssrc())) {
+ LOG(LS_ERROR) << "Failed to remove remote stream with ssrc "
+ << it->first_ssrc() << ".";
+ ret = false;
+ }
+ }
+ }
+ // Check for new streams.
+ for (StreamParamsVec::const_iterator it = streams.begin();
+ it != streams.end(); ++it) {
+ if (!GetStreamBySsrc(remote_streams_, it->first_ssrc(), NULL)) {
+ if (AddRecvStream_w(*it)) {
+ LOG(LS_INFO) << "Add remote ssrc: " << it->ssrcs[0];
+ } else {
+ LOG(LS_INFO) << "Failed to add remote stream ssrc: "
+ << it->first_ssrc();
+ ret = false;
+ }
+ }
+ }
+ remote_streams_ = streams;
+ return ret;
+}
+
+bool BaseChannel::SetBaseLocalContent_w(const MediaContentDescription* content,
+ ContentAction action) {
+ bool ret = UpdateLocalStreams_w(content->streams(), action);
+ // Set local SRTP parameters (what we will encrypt with).
+ ret &= SetSrtp_w(content->cryptos(), action, CS_LOCAL);
+ // Set local RTCP mux parameters.
+ ret &= SetRtcpMux_w(content->rtcp_mux(), action, CS_LOCAL);
+ // Set local RTP header extensions.
+ if (content->rtp_header_extensions_set()) {
+ ret &= media_channel()->SetRecvRtpHeaderExtensions(
+ content->rtp_header_extensions());
+ }
+ return ret;
+}
+
+bool BaseChannel::SetBaseRemoteContent_w(const MediaContentDescription* content,
+ ContentAction action) {
+ bool ret = UpdateRemoteStreams_w(content->streams(), action);
+ // Set remote SRTP parameters (what the other side will encrypt with).
+ ret &= SetSrtp_w(content->cryptos(), action, CS_REMOTE);
+ // Set remote RTCP mux parameters.
+ ret &= SetRtcpMux_w(content->rtcp_mux(), action, CS_REMOTE);
+ // Set remote RTP header extensions.
+ if (content->rtp_header_extensions_set()) {
+ ret &= media_channel()->SetSendRtpHeaderExtensions(
+ content->rtp_header_extensions());
+ }
+ return ret;
+}
+
void BaseChannel::OnMessage(talk_base::Message *pmsg) {
switch (pmsg->message_id) {
case MSG_ENABLE:
@@ -564,13 +867,6 @@
case MSG_UNMUTE:
UnmuteMedia_w();
break;
-
- case MSG_SETRTCPCNAME: {
- SetRtcpCNameData* data = static_cast<SetRtcpCNameData*>(pmsg->pdata);
- data->result = SetRtcpCName_w(data->cname);
- break;
- }
-
case MSG_SETLOCALCONTENT: {
SetContentData* data = static_cast<SetContentData*>(pmsg->pdata);
data->result = SetLocalContent_w(data->content, data->action);
@@ -581,13 +877,16 @@
data->result = SetRemoteContent_w(data->content, data->action);
break;
}
-
- case MSG_REMOVESTREAM: {
+ case MSG_ADDRECVSTREAM: {
StreamMessageData* data = static_cast<StreamMessageData*>(pmsg->pdata);
- RemoveStream_w(data->ssrc1);
+ data->result = AddRecvStream_w(data->sp);
break;
}
-
+ case MSG_REMOVERECVSTREAM: {
+ SsrcMessageData* data = static_cast<SsrcMessageData*>(pmsg->pdata);
+ data->result = RemoveRecvStream_w(data->ssrc);
+ break;
+ }
case MSG_SETMAXSENDBANDWIDTH: {
SetBandwidthData* data = static_cast<SetBandwidthData*>(pmsg->pdata);
data->result = SetMaxSendBandwidth_w(data->value);
@@ -641,7 +940,9 @@
bool rtcp)
: BaseChannel(thread, media_engine, media_channel, session, content_name,
rtcp),
- received_media_(false) {
+ received_media_(false),
+ mute_on_type_(false),
+ mute_on_type_timeout_(kTypingBlackoutPeriod) {
}
VoiceChannel::~VoiceChannel() {
@@ -665,12 +966,6 @@
return true;
}
-bool VoiceChannel::AddStream(uint32 ssrc) {
- StreamMessageData data(ssrc, 0);
- Send(MSG_ADDSTREAM, &data);
- return true;
-}
-
bool VoiceChannel::SetRingbackTone(const void* buf, int len) {
SetRingbackToneMessageData data(buf, len);
Send(MSG_SETRINGBACKTONE, &data);
@@ -774,7 +1069,7 @@
if (!media_channel()->SetPlayout(recv)) {
SendLastMediaError();
}
-
+
// Send outgoing data if we're the active call, we have the remote content,
// and we have had some form of connectivity.
bool send = enabled() && has_remote_content() && was_ever_writable();
@@ -804,27 +1099,17 @@
const AudioContentDescription* audio =
static_cast<const AudioContentDescription*>(content);
ASSERT(audio != NULL);
+ if (!audio) return false;
- bool ret;
- if (audio->ssrc_set()) {
- media_channel()->SetSendSsrc(audio->ssrc());
- LOG(LS_INFO) << "Set send ssrc for audio: " << audio->ssrc();
+ bool ret = SetBaseLocalContent_w(content, action);
+ // Set local audio codecs (what we want to receive).
+ // TODO: Change action != CA_UPDATE to !audio->partial() when partial
+ // is set properly.
+ if (action != CA_UPDATE || audio->has_codecs()) {
+ ret &= media_channel()->SetRecvCodecs(audio->codecs());
}
- // set SRTP
- ret = SetSrtp_w(audio->cryptos(), action, CS_LOCAL);
- // set RTCP mux
- if (ret) {
- ret = SetRtcpMux_w(audio->rtcp_mux(), action, CS_LOCAL);
- }
- // set payload type and config for voice codecs
- if (ret) {
- ret = media_channel()->SetRecvCodecs(audio->codecs());
- }
- // set header extensions
- if (ret && audio->rtp_header_extensions_set()) {
- ret = media_channel()->SetRecvRtpHeaderExtensions(
- audio->rtp_header_extensions());
- }
+
+ // If everything worked, see if we can start receiving.
if (ret) {
set_has_local_content(true);
ChangeState();
@@ -842,34 +1127,32 @@
const AudioContentDescription* audio =
static_cast<const AudioContentDescription*>(content);
ASSERT(audio != NULL);
+ if (!audio) return false;
- bool ret;
- // set SRTP
- ret = SetSrtp_w(audio->cryptos(), action, CS_REMOTE);
- // set RTCP mux
- if (ret) {
- ret = SetRtcpMux_w(audio->rtcp_mux(), action, CS_REMOTE);
- }
- // set codecs and payload types
- if (ret) {
- ret = media_channel()->SetSendCodecs(audio->codecs());
- }
- // set header extensions
- if (ret && audio->rtp_header_extensions_set()) {
- ret = media_channel()->SetSendRtpHeaderExtensions(
- audio->rtp_header_extensions());
+ bool ret = true;
+ // Set remote video codecs (what the other side wants to receive).
+ if (action != CA_UPDATE || audio->has_codecs()) {
+ ret &= media_channel()->SetSendCodecs(audio->codecs());
}
- int audio_options = 0;
- if (audio->conference_mode()) {
- audio_options |= OPT_CONFERENCE;
- }
- if (!media_channel()->SetOptions(audio_options)) {
- // Log an error on failure, but don't abort the call.
- LOG(LS_ERROR) << "Failed to set voice channel options";
+ ret &= SetBaseRemoteContent_w(content, action);
+
+ if (action != CA_UPDATE) {
+ // Tweak our audio processing settings, if needed.
+ int audio_options = 0;
+ if (audio->conference_mode()) {
+ audio_options |= OPT_CONFERENCE;
+ }
+ if (audio->agc_minus_10db()) {
+ audio_options |= OPT_AGC_MINUS_10DB;
+ }
+ if (!media_channel()->SetOptions(audio_options)) {
+ // Log an error on failure, but don't abort the call.
+ LOG(LS_ERROR) << "Failed to set voice channel options";
+ }
}
- // update state
+ // If everything worked, see if we can start sending.
if (ret) {
set_has_remote_content(true);
ChangeState();
@@ -879,15 +1162,6 @@
return ret;
}
-void VoiceChannel::AddStream_w(uint32 ssrc) {
- ASSERT(worker_thread() == talk_base::Thread::Current());
- media_channel()->AddStream(ssrc);
-}
-
-void VoiceChannel::RemoveStream_w(uint32 ssrc) {
- media_channel()->RemoveStream(ssrc);
-}
-
bool VoiceChannel::SetRingbackTone_w(const void* buf, int len) {
ASSERT(worker_thread() == talk_base::Thread::Current());
return media_channel()->SetRingbackTone(static_cast<const char*>(buf), len);
@@ -925,11 +1199,6 @@
void VoiceChannel::OnMessage(talk_base::Message *pmsg) {
switch (pmsg->message_id) {
- case MSG_ADDSTREAM: {
- StreamMessageData* data = static_cast<StreamMessageData*>(pmsg->pdata);
- AddStream_w(data->ssrc1);
- break;
- }
case MSG_SETRINGBACKTONE: {
SetRingbackToneMessageData* data =
static_cast<SetRingbackToneMessageData*>(pmsg->pdata);
@@ -963,7 +1232,6 @@
delete data;
break;
}
-
default:
BaseChannel::OnMessage(pmsg);
break;
@@ -987,9 +1255,14 @@
}
void VoiceChannel::OnVoiceChannelError(
- uint32 ssrc, VoiceMediaChannel::Error error) {
- VoiceChannelErrorMessageData *data = new VoiceChannelErrorMessageData(
- ssrc, error);
+ uint32 ssrc, VoiceMediaChannel::Error err) {
+ if (err == VoiceMediaChannel::ERROR_REC_TYPING_NOISE_DETECTED &&
+ mute_on_type_ && !muted()) {
+ Mute(true);
+ PostDelayed(mute_on_type_timeout_, MSG_UNMUTE, NULL);
+ }
+ VoiceChannelErrorMessageData* data = new VoiceChannelErrorMessageData(
+ ssrc, err);
signaling_thread()->Post(this, MSG_CHANNEL_ERROR, data);
}
@@ -1036,6 +1309,8 @@
rtcp_channel)) {
return false;
}
+ media_channel()->SignalScreencastWindowEvent.connect(
+ this, &VideoChannel::OnScreencastWindowEvent);
media_channel()->SignalMediaError.connect(
this, &VideoChannel::OnVideoChannelError);
srtp_filter()->SignalSrtpError.connect(
@@ -1056,19 +1331,29 @@
DisableMedia_w();
}
-bool VideoChannel::AddStream(uint32 ssrc, uint32 voice_ssrc) {
- StreamMessageData data(ssrc, voice_ssrc);
- Send(MSG_ADDSTREAM, &data);
- return true;
-}
-
bool VideoChannel::SetRenderer(uint32 ssrc, VideoRenderer* renderer) {
RenderMessageData data(ssrc, renderer);
Send(MSG_SETRENDERER, &data);
return true;
}
+bool VideoChannel::ApplyViewRequest(const ViewRequest& request) {
+ ViewRequestMessageData data(request);
+ Send(MSG_HANDLEVIEWREQUEST, &data);
+ return data.result;
+}
+bool VideoChannel::AddScreencast(uint32 ssrc, const ScreencastId& id) {
+ ScreencastMessageData data(ssrc, id);
+ Send(MSG_ADDSCREENCAST, &data);
+ return true;
+}
+
+bool VideoChannel::RemoveScreencast(uint32 ssrc) {
+ ScreencastMessageData data(ssrc, ScreencastId());
+ Send(MSG_REMOVESCREENCAST, &data);
+ return true;
+}
bool VideoChannel::SendIntraFrame() {
Send(MSG_SENDINTRAFRAME);
@@ -1136,26 +1421,15 @@
const VideoContentDescription* video =
static_cast<const VideoContentDescription*>(content);
ASSERT(video != NULL);
+ if (!video) return false;
- bool ret;
- if (video->ssrc_set()) {
- media_channel()->SetSendSsrc(video->ssrc());
- LOG(LS_INFO) << "Set send ssrc for video: " << video->ssrc();
+ bool ret = SetBaseLocalContent_w(content, action);
+ // Set local video codecs (what we want to receive).
+ if (action != CA_UPDATE || video->has_codecs()) {
+ ret &= media_channel()->SetRecvCodecs(video->codecs());
}
- // set SRTP
- ret = SetSrtp_w(video->cryptos(), action, CS_LOCAL);
- // set RTCP mux
- if (ret) {
- ret = SetRtcpMux_w(video->rtcp_mux(), action, CS_LOCAL);
- }
- // set payload types and config for receiving video
- if (ret) {
- ret = media_channel()->SetRecvCodecs(video->codecs());
- }
- if (ret && video->rtp_header_extensions_set()) {
- ret = media_channel()->SetRecvRtpHeaderExtensions(
- video->rtp_header_extensions());
- }
+
+ // If everything worked, see if we can start receiving.
if (ret) {
set_has_local_content(true);
ChangeState();
@@ -1173,28 +1447,33 @@
const VideoContentDescription* video =
static_cast<const VideoContentDescription*>(content);
ASSERT(video != NULL);
+ if (!video) return false;
- bool ret;
- // set SRTP
- ret = SetSrtp_w(video->cryptos(), action, CS_REMOTE);
- // set RTCP mux
- if (ret) {
- ret = SetRtcpMux_w(video->rtcp_mux(), action, CS_REMOTE);
+ bool ret = true;
+ // Set remote video codecs (what the other side wants to receive).
+ if (action != CA_UPDATE || video->has_codecs()) {
+ ret &= media_channel()->SetSendCodecs(video->codecs());
}
- // Set video bandwidth parameters.
- if (ret) {
+
+ ret &= SetBaseRemoteContent_w(content, action);
+
+ if (action != CA_UPDATE) {
+ // Tweak our video processing settings, if needed.
+ int video_options = 0;
+ if (video->conference_mode()) {
+ video_options |= OPT_CONFERENCE;
+ }
+ if (!media_channel()->SetOptions(video_options)) {
+ // Log an error on failure, but don't abort the call.
+ LOG(LS_ERROR) << "Failed to set video channel options";
+ }
+ // Set bandwidth parameters (what the other side wants to get, default=auto)
int bandwidth_bps = video->bandwidth();
bool auto_bandwidth = (bandwidth_bps == kAutoBandwidth);
- ret = media_channel()->SetSendBandwidth(auto_bandwidth, bandwidth_bps);
+ ret &= media_channel()->SetSendBandwidth(auto_bandwidth, bandwidth_bps);
}
- if (ret) {
- ret = media_channel()->SetSendCodecs(video->codecs());
- }
- // set header extensions
- if (ret && video->rtp_header_extensions_set()) {
- ret = media_channel()->SetSendRtpHeaderExtensions(
- video->rtp_header_extensions());
- }
+
+ // If everything worked, see if we can start sending.
if (ret) {
set_has_remote_content(true);
ChangeState();
@@ -1204,31 +1483,87 @@
return ret;
}
-void VideoChannel::AddStream_w(uint32 ssrc, uint32 voice_ssrc) {
- media_channel()->AddStream(ssrc, voice_ssrc);
-}
+bool VideoChannel::ApplyViewRequest_w(const ViewRequest& request) {
+ bool ret = true;
+ // Set the send format for each of the local streams. If the view request
+ // does not contain a local stream, set its send format to 0x0, which will
+ // drop all frames.
+ for (std::vector<StreamParams>::const_iterator it = local_streams().begin();
+ it != local_streams().end(); ++it) {
+ VideoFormat format(0, 0, 0, cricket::FOURCC_I420);
+ StaticVideoViews::const_iterator view;
+ for (view = request.static_video_views.begin();
+ view != request.static_video_views.end(); ++view) {
+ // Sender view request from Reflector has SSRC 0 (b/5977302). Here we hack
+ // the client to apply the view request with SSRC 0. TODO: Remove
+ // 0 == view->SSRC once Reflector uses the correct SSRC in view request.
+ if (it->has_ssrc(view->ssrc) || 0 == view->ssrc) {
+ format.width = view->width;
+ format.height = view->height;
+ format.interval = cricket::VideoFormat::FpsToInterval(view->framerate);
+ break;
+ }
+ }
-void VideoChannel::RemoveStream_w(uint32 ssrc) {
- media_channel()->RemoveStream(ssrc);
+ ret &= media_channel()->SetSendStreamFormat(it->first_ssrc(), format);
+ }
+
+ // Check if the view request has invalid streams.
+ for (StaticVideoViews::const_iterator it = request.static_video_views.begin();
+ it != request.static_video_views.end(); ++it) {
+ if (!GetStreamBySsrc(local_streams(), it->ssrc, NULL)) {
+ LOG(LS_WARNING) << "View request's SSRC " << it->ssrc
+ << " is not in the local streams.";
+ }
+ }
+
+ return ret;
}
void VideoChannel::SetRenderer_w(uint32 ssrc, VideoRenderer* renderer) {
media_channel()->SetRenderer(ssrc, renderer);
}
+void VideoChannel::AddScreencast_w(uint32 ssrc, const ScreencastId& id) {
+ media_channel()->AddScreencast(ssrc, id);
+}
+
+void VideoChannel::RemoveScreencast_w(uint32 ssrc) {
+ media_channel()->RemoveScreencast(ssrc);
+}
+
+void VideoChannel::OnScreencastWindowEvent_s(uint32 ssrc,
+ talk_base::WindowEvent we) {
+ ASSERT(signaling_thread() == talk_base::Thread::Current());
+ SignalScreencastWindowEvent(ssrc, we);
+}
void VideoChannel::OnMessage(talk_base::Message *pmsg) {
switch (pmsg->message_id) {
- case MSG_ADDSTREAM: {
- StreamMessageData* data = static_cast<StreamMessageData*>(pmsg->pdata);
- AddStream_w(data->ssrc1, data->ssrc2);
- break;
- }
case MSG_SETRENDERER: {
RenderMessageData* data = static_cast<RenderMessageData*>(pmsg->pdata);
SetRenderer_w(data->ssrc, data->renderer);
break;
}
+ case MSG_ADDSCREENCAST: {
+ ScreencastMessageData* data =
+ static_cast<ScreencastMessageData*>(pmsg->pdata);
+ AddScreencast_w(data->ssrc, data->window_id);
+ break;
+ }
+ case MSG_REMOVESCREENCAST: {
+ ScreencastMessageData* data =
+ static_cast<ScreencastMessageData*>(pmsg->pdata);
+ RemoveScreencast_w(data->ssrc);
+ break;
+ }
+ case MSG_SCREENCASTWINDOWEVENT: {
+ ScreencastEventData* data =
+ static_cast<ScreencastEventData*>(pmsg->pdata);
+ OnScreencastWindowEvent_s(data->ssrc, data->event);
+ delete data;
+ break;
+ }
case MSG_SENDINTRAFRAME:
SendIntraFrame_w();
break;
@@ -1248,6 +1583,12 @@
delete data;
break;
}
+ case MSG_HANDLEVIEWREQUEST: {
+ ViewRequestMessageData* data =
+ static_cast<ViewRequestMessageData*>(pmsg->pdata);
+ data->result = ApplyViewRequest_w(data->request);
+ break;
+ }
default:
BaseChannel::OnMessage(pmsg);
break;
@@ -1265,6 +1606,11 @@
SignalMediaMonitor(this, info);
}
+void VideoChannel::OnScreencastWindowEvent(uint32 ssrc,
+ talk_base::WindowEvent event) {
+ ScreencastEventData* pdata = new ScreencastEventData(ssrc, event);
+ signaling_thread()->Post(this, MSG_SCREENCASTWINDOWEVENT, pdata);
+}
void VideoChannel::OnVideoChannelError(uint32 ssrc,
VideoMediaChannel::Error error) {
diff --git a/talk/session/phone/channel.h b/talk/session/phone/channel.h
index 324c35c..df0124f 100644
--- a/talk/session/phone/channel.h
+++ b/talk/session/phone/channel.h
@@ -35,6 +35,7 @@
#include "talk/base/criticalsection.h"
#include "talk/base/network.h"
#include "talk/base/sigslot.h"
+#include "talk/base/window.h"
#include "talk/p2p/client/socketmonitor.h"
#include "talk/p2p/base/session.h"
#include "talk/session/phone/audiomonitor.h"
@@ -42,38 +43,16 @@
#include "talk/session/phone/mediaengine.h"
#include "talk/session/phone/mediamonitor.h"
#include "talk/session/phone/rtcpmuxfilter.h"
+#include "talk/session/phone/screencastid.h"
+#include "talk/session/phone/ssrcmuxfilter.h"
+#include "talk/session/phone/streamparams.h"
#include "talk/session/phone/srtpfilter.h"
namespace cricket {
class MediaContentDescription;
struct CryptoParams;
-
-enum {
- MSG_ENABLE = 1,
- MSG_DISABLE = 2,
- MSG_MUTE = 3,
- MSG_UNMUTE = 4,
- MSG_SETREMOTECONTENT = 5,
- MSG_SETLOCALCONTENT = 6,
- MSG_EARLYMEDIATIMEOUT = 8,
- MSG_PRESSDTMF = 9,
- MSG_SETRENDERER = 10,
- MSG_ADDSTREAM = 11,
- MSG_REMOVESTREAM = 12,
- MSG_SETRINGBACKTONE = 13,
- MSG_PLAYRINGBACKTONE = 14,
- MSG_SETMAXSENDBANDWIDTH = 15,
- MSG_SETRTCPCNAME = 18,
- MSG_SENDINTRAFRAME = 19,
- MSG_REQUESTINTRAFRAME = 20,
- MSG_RTPPACKET = 22,
- MSG_RTCPPACKET = 23,
- MSG_CHANNEL_ERROR = 24,
- MSG_ENABLECPUADAPTATION = 25,
- MSG_DISABLECPUADAPTATION = 26,
- MSG_SCALEVOLUME = 27
-};
+struct ViewRequest;
// BaseChannel contains logic common to voice and video, including
// enable/mute, marshaling calls to a worker thread, and
@@ -102,7 +81,6 @@
bool secure() const { return srtp_filter_.IsActive(); }
// Channel control
- bool SetRtcpCName(const std::string& cname);
bool SetLocalContent(const MediaContentDescription* content,
ContentAction action);
bool SetRemoteContent(const MediaContentDescription* content,
@@ -113,7 +91,8 @@
bool Mute(bool mute);
// Multiplexing
- bool RemoveStream(uint32 ssrc);
+ bool AddRecvStream(const StreamParams& sp);
+ bool RemoveRecvStream(uint32 ssrc);
// Monitoring
void StartConnectionMonitor(int cms);
@@ -159,6 +138,15 @@
return !SignalRecvPacket.is_empty();
}
+ SsrcMuxFilter* ssrc_filter() { return &ssrc_filter_; }
+
+ const std::vector<StreamParams>& local_streams() const {
+ return local_streams_;
+ }
+ const std::vector<StreamParams>& remote_streams() const {
+ return remote_streams_;
+ }
+
protected:
MediaEngineInterface* media_engine() const { return media_engine_; }
virtual MediaChannel* media_channel() const { return media_channel_; }
@@ -199,7 +187,6 @@
// Setting the send codec based on the remote description.
void OnSessionState(BaseSession* session, BaseSession::State state);
- void OnRemoteDescriptionUpdate(BaseSession* session);
void EnableMedia_w();
void DisableMedia_w();
@@ -207,38 +194,24 @@
void UnmuteMedia_w();
void ChannelWritable_w();
void ChannelNotWritable_w();
-
- struct StreamMessageData : public talk_base::MessageData {
- StreamMessageData(uint32 s1, uint32 s2) : ssrc1(s1), ssrc2(s2) {}
- uint32 ssrc1;
- uint32 ssrc2;
- };
- virtual void RemoveStream_w(uint32 ssrc) = 0;
+ bool AddRecvStream_w(const StreamParams& sp);
+ bool RemoveRecvStream_w(uint32 ssrc);
virtual void ChangeState() = 0;
- struct SetRtcpCNameData : public talk_base::MessageData {
- explicit SetRtcpCNameData(const std::string& cname)
- : cname(cname), result(false) {}
- std::string cname;
- bool result;
- };
- bool SetRtcpCName_w(const std::string& cname);
-
- struct SetContentData : public talk_base::MessageData {
- SetContentData(const MediaContentDescription* content,
- ContentAction action)
- : content(content), action(action), result(false) {}
- const MediaContentDescription* content;
- ContentAction action;
- bool result;
- };
-
// Gets the content appropriate to the channel (audio or video).
virtual const MediaContentDescription* GetFirstContent(
const SessionDescription* sdesc) = 0;
+ bool UpdateLocalStreams_w(const std::vector<StreamParams>& streams,
+ ContentAction action);
+ bool UpdateRemoteStreams_w(const std::vector<StreamParams>& streams,
+ ContentAction action);
+ bool SetBaseLocalContent_w(const MediaContentDescription* content,
+ ContentAction action);
virtual bool SetLocalContent_w(const MediaContentDescription* content,
ContentAction action) = 0;
+ bool SetBaseRemoteContent_w(const MediaContentDescription* content,
+ ContentAction action);
virtual bool SetRemoteContent_w(const MediaContentDescription* content,
ContentAction action) = 0;
@@ -246,11 +219,6 @@
ContentSource src);
bool SetRtcpMux_w(bool enable, ContentAction action, ContentSource src);
- struct SetBandwidthData : public talk_base::MessageData {
- explicit SetBandwidthData(int value) : value(value), result(false) {}
- int value;
- bool result;
- };
bool SetMaxSendBandwidth_w(int max_bandwidth);
// From MessageHandler
@@ -270,6 +238,8 @@
MediaEngineInterface *media_engine_;
BaseSession *session_;
MediaChannel *media_channel_;
+ std::vector<StreamParams> local_streams_;
+ std::vector<StreamParams> remote_streams_;
std::string content_name_;
bool rtcp_;
@@ -277,6 +247,7 @@
TransportChannel *rtcp_transport_channel_;
SrtpFilter srtp_filter_;
RtcpMuxFilter rtcp_mux_filter_;
+ SsrcMuxFilter ssrc_filter_;
talk_base::scoped_ptr<SocketMonitor> socket_monitor_;
bool enabled_;
bool writable_;
@@ -301,9 +272,6 @@
return static_cast<VoiceMediaChannel*>(BaseChannel::media_channel());
}
- // Add an incoming stream with the specified SSRC.
- bool AddStream(uint32 ssrc);
-
bool SetRingbackTone(const void* buf, int len);
void SetEarlyMedia(bool enable);
// This signal is emitted when we have gone a period of time without
@@ -314,6 +282,10 @@
bool PlayRingbackTone(uint32 ssrc, bool play, bool loop);
bool PressDTMF(int digit, bool playout);
bool SetOutputScaling(uint32 ssrc, double left, double right);
+ void set_mute_on_type(bool enable, int timeout) {
+ mute_on_type_ = enable;
+ mute_on_type_timeout_ = talk_base::_max(0, timeout);
+ }
// Monitoring functions
sigslot::signal2<VoiceChannel*, const std::vector<ConnectionInfo> &>
@@ -337,52 +309,9 @@
sigslot::signal3<VoiceChannel*, uint32, VoiceMediaChannel::Error>
SignalMediaError;
- private:
- struct SetRingbackToneMessageData : public talk_base::MessageData {
- SetRingbackToneMessageData(const void* b, int l)
- : buf(b),
- len(l),
- result(false) {
- }
- const void* buf;
- int len;
- bool result;
- };
- struct PlayRingbackToneMessageData : public talk_base::MessageData {
- PlayRingbackToneMessageData(uint32 s, bool p, bool l)
- : ssrc(s),
- play(p),
- loop(l),
- result(false) {
- }
- uint32 ssrc;
- bool play;
- bool loop;
- bool result;
- };
- struct DtmfMessageData : public talk_base::MessageData {
- DtmfMessageData(int d, bool p)
- : digit(d),
- playout(p),
- result(false) {
- }
- int digit;
- bool playout;
- bool result;
- };
- struct ScaleVolumeMessageData : public talk_base::MessageData {
- ScaleVolumeMessageData(uint32 s, double l, double r)
- : ssrc(s),
- left(l),
- right(r),
- result(false) {
- }
- uint32 ssrc;
- double left;
- double right;
- bool result;
- };
+ static const int kTypingBlackoutPeriod = 1500;
+ private:
// overrides from BaseChannel
virtual void OnChannelRead(TransportChannel* channel,
const char *data, size_t len);
@@ -394,9 +323,6 @@
virtual bool SetRemoteContent_w(const MediaContentDescription* content,
ContentAction action);
- void AddStream_w(uint32 ssrc);
- void RemoveStream_w(uint32 ssrc);
-
bool SetRingbackTone_w(const void* buf, int len);
bool PlayRingbackTone_w(uint32 ssrc, bool play, bool loop);
void HandleEarlyMediaTimeout();
@@ -417,6 +343,8 @@
bool received_media_;
talk_base::scoped_ptr<VoiceMediaMonitor> media_monitor_;
talk_base::scoped_ptr<AudioMonitor> audio_monitor_;
+ bool mute_on_type_;
+ int mute_on_type_timeout_;
};
// VideoChannel is a specialization for video.
@@ -434,11 +362,11 @@
return static_cast<VideoMediaChannel*>(BaseChannel::media_channel());
}
- // Add an incoming stream with the specified SSRC.
- bool AddStream(uint32 ssrc, uint32 voice_ssrc);
-
bool SetRenderer(uint32 ssrc, VideoRenderer* renderer);
+ bool ApplyViewRequest(const ViewRequest& request);
+ bool AddScreencast(uint32 ssrc, const ScreencastId& id);
+ bool RemoveScreencast(uint32 ssrc);
sigslot::signal2<VideoChannel*, const std::vector<ConnectionInfo> &>
SignalConnectionMonitor;
@@ -446,6 +374,7 @@
void StartMediaMonitor(int cms);
void StopMediaMonitor();
sigslot::signal2<VideoChannel*, const VideoMediaInfo&> SignalMediaMonitor;
+ sigslot::signal2<uint32, talk_base::WindowEvent> SignalScreencastWindowEvent;
bool SendIntraFrame();
bool RequestIntraFrame();
@@ -464,9 +393,6 @@
virtual bool SetRemoteContent_w(const MediaContentDescription* content,
ContentAction action);
- void AddStream_w(uint32 ssrc, uint32 voice_ssrc);
- void RemoveStream_w(uint32 ssrc);
-
void SendIntraFrame_w() {
media_channel()->SendIntraFrame();
}
@@ -480,24 +406,24 @@
media_channel()->SetOptions(enable ? OPT_CPU_ADAPTATION : 0);
}
- struct RenderMessageData : public talk_base::MessageData {
- RenderMessageData(uint32 s, VideoRenderer* r) : ssrc(s), renderer(r) {}
- uint32 ssrc;
- VideoRenderer* renderer;
- };
-
-
+ bool ApplyViewRequest_w(const ViewRequest& request);
void SetRenderer_w(uint32 ssrc, VideoRenderer* renderer);
+ void AddScreencast_w(uint32 ssrc, const ScreencastId&);
+ void RemoveScreencast_w(uint32 ssrc);
+ void OnScreencastWindowEvent_s(uint32 ssrc, talk_base::WindowEvent we);
virtual void OnMessage(talk_base::Message *pmsg);
virtual void OnConnectionMonitorUpdate(
SocketMonitor *monitor, const std::vector<ConnectionInfo> &infos);
virtual void OnMediaMonitorUpdate(
VideoMediaChannel *media_channel, const VideoMediaInfo& info);
+ virtual void OnScreencastWindowEvent(uint32 ssrc,
+ talk_base::WindowEvent event);
void OnVideoChannelError(uint32 ssrc, VideoMediaChannel::Error error);
void OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode, SrtpFilter::Error error);
+
VoiceChannel *voice_channel_;
VideoRenderer *renderer_;
talk_base::scoped_ptr<VideoMediaMonitor> media_monitor_;
diff --git a/talk/session/phone/channel_unittest.cc b/talk/session/phone/channel_unittest.cc
new file mode 100644
index 0000000..fa6c938
--- /dev/null
+++ b/talk/session/phone/channel_unittest.cc
@@ -0,0 +1,1916 @@
+// libjingle
+// Copyright 2009 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/base/fileutils.h"
+#include "talk/base/gunit.h"
+#include "talk/base/helpers.h"
+#include "talk/base/logging.h"
+#include "talk/base/pathutils.h"
+#include "talk/base/signalthread.h"
+#include "talk/p2p/base/fakesession.h"
+#include "talk/session/phone/channel.h"
+#include "talk/session/phone/fakemediaengine.h"
+#include "talk/session/phone/fakertp.h"
+#include "talk/session/phone/mediamessages.h"
+#include "talk/session/phone/mediasessionclient.h"
+#include "talk/session/phone/mediarecorder.h"
+#include "talk/session/phone/rtpdump.h"
+
+using cricket::CA_OFFER;
+using cricket::CA_ANSWER;
+using cricket::CA_UPDATE;
+using cricket::StreamParams;
+
+static const cricket::AudioCodec kPcmuCodec(0, "PCMU", 64000, 8000, 1, 0);
+static const cricket::AudioCodec kPcmaCodec(8, "PCMA", 64000, 8000, 1, 0);
+static const cricket::AudioCodec kIsacCodec(103, "ISAC", 40000, 16000, 1, 0);
+static const cricket::VideoCodec kH264Codec(97, "H264", 640, 400, 30, 0);
+static const cricket::VideoCodec kH264SvcCodec(99, "H264-SVC", 320, 200, 15, 0);
+static const uint32 kSsrc1 = 0x1111;
+static const uint32 kSsrc2 = 0x2222;
+static const uint32 kSsrc3 = 0x3333;
+static const char kCName[] = "a@b.com";
+
+class VoiceTraits {
+ public:
+ typedef cricket::VoiceChannel Channel;
+ typedef cricket::FakeVoiceMediaChannel MediaChannel;
+ typedef cricket::AudioContentDescription Content;
+ typedef cricket::AudioCodec Codec;
+ typedef cricket::VoiceMediaInfo MediaInfo;
+};
+
+class VideoTraits {
+ public:
+ typedef cricket::VideoChannel Channel;
+ typedef cricket::FakeVideoMediaChannel MediaChannel;
+ typedef cricket::VideoContentDescription Content;
+ typedef cricket::VideoCodec Codec;
+ typedef cricket::VideoMediaInfo MediaInfo;
+};
+
+// Base class for Voice/VideoChannel tests
+template<class T>
+class ChannelTest : public testing::Test, public sigslot::has_slots<> {
+ public:
+ enum Flags { RTCP = 0x1, RTCP_MUX = 0x2, SECURE = 0x4, SSRC_MUX = 0x8 };
+ ChannelTest(const uint8* rtp_data, int rtp_len,
+ const uint8* rtcp_data, int rtcp_len)
+ : media_channel1_(NULL),
+ media_channel2_(NULL),
+ rtp_packet_(reinterpret_cast<const char*>(rtp_data), rtp_len),
+ rtcp_packet_(reinterpret_cast<const char*>(rtcp_data), rtcp_len),
+ media_info_callbacks1_(),
+ media_info_callbacks2_(),
+ ssrc_(0),
+ error_(T::MediaChannel::ERROR_NONE) {
+ }
+
+ void CreateChannels(int flags1, int flags2) {
+ CreateChannels(new typename T::MediaChannel(NULL),
+ new typename T::MediaChannel(NULL),
+ flags1, flags2, talk_base::Thread::Current());
+ }
+ void CreateChannels(int flags) {
+ CreateChannels(new typename T::MediaChannel(NULL),
+ new typename T::MediaChannel(NULL),
+ flags, talk_base::Thread::Current());
+ }
+ void CreateChannels(int flags1, int flags2,
+ talk_base::Thread* thread) {
+ CreateChannels(new typename T::MediaChannel(NULL),
+ new typename T::MediaChannel(NULL),
+ flags1, flags2, thread);
+ }
+ void CreateChannels(int flags,
+ talk_base::Thread* thread) {
+ CreateChannels(new typename T::MediaChannel(NULL),
+ new typename T::MediaChannel(NULL),
+ flags, thread);
+ }
+ void CreateChannels(
+ typename T::MediaChannel* ch1, typename T::MediaChannel* ch2,
+ int flags1, int flags2, talk_base::Thread* thread) {
+ media_channel1_ = ch1;
+ media_channel2_ = ch2;
+ channel1_.reset(CreateChannel(thread, &media_engine_, ch1, &session1_,
+ (flags1 & RTCP) != 0));
+ channel2_.reset(CreateChannel(thread, &media_engine_, ch2, &session2_,
+ (flags2 & RTCP) != 0));
+ channel1_->SignalMediaMonitor.connect(
+ this, &ChannelTest<T>::OnMediaMonitor);
+ channel2_->SignalMediaMonitor.connect(
+ this, &ChannelTest<T>::OnMediaMonitor);
+ channel1_->SignalMediaError.connect(
+ this, &ChannelTest<T>::OnMediaChannelError);
+ channel2_->SignalMediaError.connect(
+ this, &ChannelTest<T>::OnMediaChannelError);
+ CreateContent(flags1, kPcmuCodec, kH264Codec, &local_media_content1_);
+ CreateContent(flags2, kPcmuCodec, kH264Codec, &local_media_content2_);
+ CopyContent(local_media_content1_, &remote_media_content1_);
+ CopyContent(local_media_content2_, &remote_media_content2_);
+ // Add stream information (SSRC) to the local content but not to the remote
+ // content. This means that we per default know the SSRC of what we send but
+ // not what we receive.
+ AddLegacyStreamInContent(kSsrc1, flags1, &local_media_content1_);
+ AddLegacyStreamInContent(kSsrc2, flags2, &local_media_content2_);
+
+ // If SSRC_MUX is used we also need to know the SSRC of the incoming stream.
+ if (flags1 & SSRC_MUX) {
+ AddLegacyStreamInContent(kSsrc1, flags1, &remote_media_content1_);
+ }
+ if (flags2 & SSRC_MUX) {
+ AddLegacyStreamInContent(kSsrc2, flags2, &remote_media_content2_);
+ }
+ }
+
+ void CreateChannels(
+ typename T::MediaChannel* ch1, typename T::MediaChannel* ch2,
+ int flags, talk_base::Thread* thread) {
+ media_channel1_ = ch1;
+ media_channel2_ = ch2;
+ channel1_.reset(CreateChannel(thread, &media_engine_, ch1, &session1_,
+ (flags & RTCP) != 0));
+ channel2_.reset(CreateChannel(thread, &media_engine_, ch2, &session1_,
+ (flags & RTCP) != 0));
+ channel1_->SignalMediaMonitor.connect(
+ this, &ChannelTest<T>::OnMediaMonitor);
+ channel2_->SignalMediaMonitor.connect(
+ this, &ChannelTest<T>::OnMediaMonitor);
+ channel2_->SignalMediaError.connect(
+ this, &ChannelTest<T>::OnMediaChannelError);
+ CreateContent(flags, kPcmuCodec, kH264Codec, &local_media_content1_);
+ CreateContent(flags, kPcmuCodec, kH264Codec, &local_media_content2_);
+ CopyContent(local_media_content1_, &remote_media_content1_);
+ CopyContent(local_media_content2_, &remote_media_content2_);
+ // Add stream information (SSRC) to the local content but not to the remote
+ // content. This means that we per default know the SSRC of what we send but
+ // not what we receive.
+ AddLegacyStreamInContent(kSsrc1, flags, &local_media_content1_);
+ AddLegacyStreamInContent(kSsrc2, flags, &local_media_content2_);
+
+ // If SSRC_MUX is used we also need to know the SSRC of the incoming stream.
+ if (flags & SSRC_MUX) {
+ AddLegacyStreamInContent(kSsrc1, flags, &remote_media_content1_);
+ AddLegacyStreamInContent(kSsrc2, flags, &remote_media_content2_);
+ }
+ }
+ typename T::Channel* CreateChannel(talk_base::Thread* thread,
+ cricket::MediaEngineInterface* engine,
+ typename T::MediaChannel* ch,
+ cricket::BaseSession* session,
+ bool rtcp) {
+ typename T::Channel* channel = new typename T::Channel(
+ thread, engine, ch, session, cricket::CN_AUDIO, rtcp);
+ if (!channel->Init()) {
+ delete channel;
+ channel = NULL;
+ }
+ return channel;
+ }
+
+ bool SendInitiate() {
+ bool result = channel1_->SetLocalContent(&local_media_content1_, CA_OFFER);
+ if (result) {
+ channel1_->Enable(true);
+ result = channel2_->SetRemoteContent(&remote_media_content1_, CA_OFFER);
+ if (result) {
+ result = channel2_->SetLocalContent(&local_media_content2_, CA_ANSWER);
+ if (result) {
+ session1_.Connect(&session2_);
+ }
+ }
+ }
+ return result;
+ }
+ bool SendAccept() {
+ channel2_->Enable(true);
+ return channel1_->SetRemoteContent(&remote_media_content2_, CA_ANSWER);
+ }
+ bool SendTerminate() {
+ channel1_.reset();
+ channel2_.reset();
+ return true;
+ }
+
+ bool AddStream1(int id) {
+ return channel1_->AddRecvStream(cricket::StreamParams::CreateLegacy(id));
+ }
+ bool RemoveStream1(int id) {
+ return channel1_->RemoveRecvStream(id);
+ }
+
+ cricket::FakeTransport* GetTransport1() {
+ return session1_.GetTransport(channel1_->content_name());
+ }
+ cricket::FakeTransport* GetTransport2() {
+ return session2_.GetTransport(channel2_->content_name());
+ }
+
+ bool SendRtp1() {
+ return media_channel1_->SendRtp(rtp_packet_.c_str(), rtp_packet_.size());
+ }
+ bool SendRtp2() {
+ return media_channel2_->SendRtp(rtp_packet_.c_str(), rtp_packet_.size());
+ }
+ bool SendRtcp1() {
+ return media_channel1_->SendRtcp(rtcp_packet_.c_str(), rtcp_packet_.size());
+ }
+ bool SendRtcp2() {
+ return media_channel2_->SendRtcp(rtcp_packet_.c_str(), rtcp_packet_.size());
+ }
+ // Methods to send custom data.
+ bool SendCustomRtp1(uint32 ssrc) {
+ std::string data(CreateRtpData(ssrc));
+ return media_channel1_->SendRtp(data.c_str(), data.size());
+ }
+ bool SendCustomRtp2(uint32 ssrc) {
+ std::string data(CreateRtpData(ssrc));
+ return media_channel2_->SendRtp(data.c_str(), data.size());
+ }
+ bool SendCustomRtcp1(uint32 ssrc) {
+ std::string data(CreateRtcpData(ssrc));
+ return media_channel1_->SendRtcp(data.c_str(), data.size());
+ }
+ bool SendCustomRtcp2(uint32 ssrc) {
+ std::string data(CreateRtcpData(ssrc));
+ return media_channel2_->SendRtcp(data.c_str(), data.size());
+ }
+ bool CheckRtp1() {
+ return media_channel1_->CheckRtp(rtp_packet_.c_str(), rtp_packet_.size());
+ }
+ bool CheckRtp2() {
+ return media_channel2_->CheckRtp(rtp_packet_.c_str(), rtp_packet_.size());
+ }
+ bool CheckRtcp1() {
+ return media_channel1_->CheckRtcp(rtcp_packet_.c_str(),
+ rtcp_packet_.size());
+ }
+ bool CheckRtcp2() {
+ return media_channel2_->CheckRtcp(rtcp_packet_.c_str(),
+ rtcp_packet_.size());
+ }
+ // Methods to check custom data.
+ bool CheckCustomRtp1(uint32 ssrc) {
+ std::string data(CreateRtpData(ssrc));
+ return media_channel1_->CheckRtp(data.c_str(), data.size());
+ }
+ bool CheckCustomRtp2(uint32 ssrc) {
+ std::string data(CreateRtpData(ssrc));
+ return media_channel2_->CheckRtp(data.c_str(), data.size());
+ }
+ bool CheckCustomRtcp1(uint32 ssrc) {
+ std::string data(CreateRtcpData(ssrc));
+ return media_channel1_->CheckRtcp(data.c_str(), data.size());
+ }
+ bool CheckCustomRtcp2(uint32 ssrc) {
+ std::string data(CreateRtcpData(ssrc));
+ return media_channel2_->CheckRtcp(data.c_str(), data.size());
+ }
+ std::string CreateRtpData(uint32 ssrc) {
+ std::string data(rtp_packet_);
+ // Set SSRC in the rtp packet copy.
+ talk_base::SetBE32(const_cast<char*>(data.c_str()) + 8, ssrc);
+ return data;
+ }
+ std::string CreateRtcpData(uint32 ssrc) {
+ std::string data(rtcp_packet_);
+ // Set SSRC in the rtcp packet copy.
+ talk_base::SetBE32(const_cast<char*>(data.c_str()) + 4, ssrc);
+ return data;
+ }
+
+ bool CheckNoRtp1() {
+ return media_channel1_->CheckNoRtp();
+ }
+ bool CheckNoRtp2() {
+ return media_channel2_->CheckNoRtp();
+ }
+ bool CheckNoRtcp1() {
+ return media_channel1_->CheckNoRtcp();
+ }
+ bool CheckNoRtcp2() {
+ return media_channel2_->CheckNoRtcp();
+ }
+
+ void CreateContent(int flags,
+ const cricket::AudioCodec& audio_codec,
+ const cricket::VideoCodec& video_codec,
+ typename T::Content* content) {
+ // overridden in specialized classes
+ }
+ void CopyContent(const typename T::Content& source,
+ typename T::Content* content) {
+ // overridden in specialized classes
+ }
+
+ class CallThread : public talk_base::SignalThread {
+ public:
+ typedef bool (ChannelTest<T>::*Method)();
+ CallThread(ChannelTest<T>* obj, Method method, bool* result)
+ : obj_(obj),
+ method_(method),
+ result_(result) {
+ *result = false;
+ }
+ virtual void DoWork() {
+ bool result = (*obj_.*method_)();
+ if (result_) {
+ *result_ = result;
+ }
+ }
+ private:
+ ChannelTest<T>* obj_;
+ Method method_;
+ bool* result_;
+ };
+ void CallOnThread(typename CallThread::Method method, bool* result) {
+ CallThread* thread = new CallThread(this, method, result);
+ thread->Start();
+ thread->Release();
+ }
+
+ void CallOnThreadAndWaitForDone(typename CallThread::Method method,
+ bool* result) {
+ CallThread* thread = new CallThread(this, method, result);
+ thread->Start();
+ thread->Destroy(true);
+ }
+
+ bool CodecMatches(const typename T::Codec& c1, const typename T::Codec& c2) {
+ return false; // overridden in specialized classes
+ }
+
+ void OnMediaMonitor(typename T::Channel* channel,
+ const typename T::MediaInfo& info) {
+ if (channel == channel1_.get()) {
+ media_info_callbacks1_++;
+ } else if (channel == channel2_.get()) {
+ media_info_callbacks2_++;
+ }
+ }
+
+ void OnMediaChannelError(typename T::Channel* channel,
+ uint32 ssrc,
+ typename T::MediaChannel::Error error) {
+ ssrc_ = ssrc;
+ error_ = error;
+ }
+
+ void AddLegacyStreamInContent(uint32 ssrc, int flags,
+ typename T::Content* content) {
+ // Base implementation.
+ }
+
+ // Tests that can be used by derived classes.
+
+ // Basic sanity check.
+ void TestInit() {
+ CreateChannels(0, 0);
+ EXPECT_FALSE(channel1_->secure());
+ EXPECT_FALSE(media_channel1_->sending());
+ EXPECT_FALSE(media_channel1_->playout());
+ EXPECT_TRUE(media_channel1_->codecs().empty());
+ EXPECT_TRUE(media_channel1_->recv_streams().empty());
+ EXPECT_TRUE(media_channel1_->rtp_packets().empty());
+ EXPECT_TRUE(media_channel1_->rtcp_packets().empty());
+ }
+
+ // Test that SetLocalContent and SetRemoteContent properly configure
+ // the codecs.
+ void TestSetContents() {
+ CreateChannels(0, 0);
+ typename T::Content content;
+ CreateContent(0, kPcmuCodec, kH264Codec, &content);
+ EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER));
+ EXPECT_EQ(0U, media_channel1_->codecs().size());
+ EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER));
+ ASSERT_EQ(1U, media_channel1_->codecs().size());
+ EXPECT_TRUE(CodecMatches(content.codecs()[0],
+ media_channel1_->codecs()[0]));
+ }
+
+ // Test that SetLocalContent and SetRemoteContent properly deals
+ // with an empty offer.
+ void TestSetContentsNullOffer() {
+ CreateChannels(0, 0);
+ typename T::Content content;
+ EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER));
+ CreateContent(0, kPcmuCodec, kH264Codec, &content);
+ EXPECT_EQ(0U, media_channel1_->codecs().size());
+ EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER));
+ ASSERT_EQ(1U, media_channel1_->codecs().size());
+ EXPECT_TRUE(CodecMatches(content.codecs()[0],
+ media_channel1_->codecs()[0]));
+ }
+
+ // Test that SetLocalContent and SetRemoteContent properly set RTCP
+ // mux.
+ void TestSetContentsRtcpMux() {
+ CreateChannels(RTCP, RTCP);
+ EXPECT_TRUE(channel1_->rtcp_transport_channel() != NULL);
+ EXPECT_TRUE(channel2_->rtcp_transport_channel() != NULL);
+ typename T::Content content;
+ CreateContent(0, kPcmuCodec, kH264Codec, &content);
+ // Both sides agree on mux. Should no longer be a separate RTCP channel.
+ content.set_rtcp_mux(true);
+ EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER));
+ EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER));
+ EXPECT_TRUE(channel1_->rtcp_transport_channel() == NULL);
+ // Only initiator supports mux. Should still have a separate RTCP channel.
+ EXPECT_TRUE(channel2_->SetLocalContent(&content, CA_OFFER));
+ content.set_rtcp_mux(false);
+ EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_ANSWER));
+ EXPECT_TRUE(channel2_->rtcp_transport_channel() != NULL);
+ }
+
+ // Test that SetRemoteContent properly deals with a content update.
+ void TestSetRemoteContentUpdate() {
+ CreateChannels(0, 0);
+ typename T::Content content;
+ CreateContent(RTCP | RTCP_MUX | SECURE, kPcmuCodec, kH264Codec, &content);
+ EXPECT_EQ(0U, media_channel1_->codecs().size());
+ EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER));
+ EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER));
+ ASSERT_EQ(1U, media_channel1_->codecs().size());
+ EXPECT_TRUE(CodecMatches(content.codecs()[0],
+ media_channel1_->codecs()[0]));
+ // Now update with other codecs.
+ typename T::Content update_content;
+ update_content.set_partial(true);
+ CreateContent(0, kIsacCodec, kH264SvcCodec, &update_content);
+ EXPECT_TRUE(channel1_->SetRemoteContent(&update_content, CA_UPDATE));
+ ASSERT_EQ(1U, media_channel1_->codecs().size());
+ EXPECT_TRUE(CodecMatches(update_content.codecs()[0],
+ media_channel1_->codecs()[0]));
+ // Now update without any codecs. This is ignored.
+ typename T::Content empty_content;
+ empty_content.set_partial(true);
+ EXPECT_TRUE(channel1_->SetRemoteContent(&empty_content, CA_UPDATE));
+ ASSERT_EQ(1U, media_channel1_->codecs().size());
+ EXPECT_TRUE(CodecMatches(update_content.codecs()[0],
+ media_channel1_->codecs()[0]));
+ }
+
+ // Test that Add/RemoveStream properly forward to the media channel.
+ void TestStreams() {
+ CreateChannels(0, 0);
+ EXPECT_TRUE(AddStream1(1));
+ EXPECT_TRUE(AddStream1(2));
+ EXPECT_EQ(2U, media_channel1_->recv_streams().size());
+ EXPECT_TRUE(RemoveStream1(2));
+ EXPECT_EQ(1U, media_channel1_->recv_streams().size());
+ EXPECT_TRUE(RemoveStream1(1));
+ EXPECT_EQ(0U, media_channel1_->recv_streams().size());
+ }
+
+ // Test that SetLocalContent properly handles adding and removing StreamParams
+ // to the local content description.
+ // This test uses the CA_UPDATE action that don't require a full
+ // MediaContentDescription to do an update.
+ void TestUpdateStreamsInLocalContent() {
+ cricket::StreamParams stream1;
+ stream1.name = "Stream1";
+ stream1.nick = "1";
+ stream1.ssrcs.push_back(kSsrc1);
+ stream1.cname = "stream1_cname";
+
+ cricket::StreamParams stream2;
+ stream2.name = "Stream2";
+ stream2.nick = "2";
+ stream2.ssrcs.push_back(kSsrc2);
+ stream2.cname = "stream2_cname";
+
+ cricket::StreamParams stream3;
+ stream3.name = "Stream3";
+ stream3.nick = "3";
+ stream3.ssrcs.push_back(kSsrc3);
+ stream3.cname = "stream3_cname";
+
+ CreateChannels(0, 0);
+ typename T::Content content1;
+ CreateContent(0, kPcmuCodec, kH264Codec, &content1);
+ content1.AddStream(stream1);
+ EXPECT_EQ(0u, media_channel1_->send_streams().size());
+ EXPECT_TRUE(channel1_->SetLocalContent(&content1, CA_OFFER));
+
+ ASSERT_EQ(1u, media_channel1_->send_streams().size());
+ EXPECT_EQ(stream1, media_channel1_->send_streams()[0]);
+
+ // Update the local streams by adding another sending stream.
+ // Use a partial updated session description.
+ typename T::Content content2;
+ content2.AddStream(stream2);
+ content2.AddStream(stream3);
+ content2.set_partial(true);
+ EXPECT_TRUE(channel1_->SetLocalContent(&content2, CA_UPDATE));
+ ASSERT_EQ(3u, media_channel1_->send_streams().size());
+ EXPECT_EQ(stream1, media_channel1_->send_streams()[0]);
+ EXPECT_EQ(stream2, media_channel1_->send_streams()[1]);
+ EXPECT_EQ(stream3, media_channel1_->send_streams()[2]);
+
+ // Update the local streams by removing the first sending stream.
+ // This is done by removing all SSRCS for this particular stream.
+ typename T::Content content3;
+ stream1.ssrcs.clear();
+ content3.AddStream(stream1);
+ content3.set_partial(true);
+ EXPECT_TRUE(channel1_->SetLocalContent(&content3, CA_UPDATE));
+ ASSERT_EQ(2u, media_channel1_->send_streams().size());
+ EXPECT_EQ(stream2, media_channel1_->send_streams()[0]);
+ EXPECT_EQ(stream3, media_channel1_->send_streams()[1]);
+
+ // Update the local streams with a stream that does not change.
+ // THe update is ignored.
+ typename T::Content content4;
+ content4.AddStream(stream2);
+ content4.set_partial(true);
+ EXPECT_TRUE(channel1_->SetLocalContent(&content4, CA_UPDATE));
+ ASSERT_EQ(2u, media_channel1_->send_streams().size());
+ EXPECT_EQ(stream2, media_channel1_->send_streams()[0]);
+ EXPECT_EQ(stream3, media_channel1_->send_streams()[1]);
+ }
+
+ // Test that SetRemoteContent properly handles adding and removing
+ // StreamParams to the remote content description.
+ // This test uses the CA_UPDATE action that don't require a full
+ // MediaContentDescription to do an update.
+ void TestUpdateStreamsInRemoteContent() {
+ cricket::StreamParams stream1;
+ stream1.name = "Stream1";
+ stream1.nick = "1";
+ stream1.ssrcs.push_back(kSsrc1);
+ stream1.cname = "stream1_cname";
+
+ cricket::StreamParams stream2;
+ stream2.name = "Stream2";
+ stream2.nick = "2";
+ stream2.ssrcs.push_back(kSsrc2);
+ stream2.cname = "stream2_cname";
+
+ cricket::StreamParams stream3;
+ stream3.name = "Stream3";
+ stream3.nick = "3";
+ stream3.ssrcs.push_back(kSsrc3);
+ stream3.cname = "stream3_cname";
+
+ CreateChannels(0, 0);
+ typename T::Content content1;
+ CreateContent(0, kPcmuCodec, kH264Codec, &content1);
+ content1.AddStream(stream1);
+ EXPECT_EQ(0u, media_channel1_->recv_streams().size());
+ EXPECT_TRUE(channel1_->SetRemoteContent(&content1, CA_OFFER));
+
+ ASSERT_EQ(1u, media_channel1_->codecs().size());
+ ASSERT_EQ(1u, media_channel1_->recv_streams().size());
+ EXPECT_EQ(stream1, media_channel1_->recv_streams()[0]);
+
+ // Update the remote streams by adding another sending stream.
+ // Use a partial updated session description.
+ typename T::Content content2;
+ content2.AddStream(stream2);
+ content2.AddStream(stream3);
+ content2.set_partial(true);
+ EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_UPDATE));
+ ASSERT_EQ(3u, media_channel1_->recv_streams().size());
+ EXPECT_EQ(stream1, media_channel1_->recv_streams()[0]);
+ EXPECT_EQ(stream2, media_channel1_->recv_streams()[1]);
+ EXPECT_EQ(stream3, media_channel1_->recv_streams()[2]);
+
+ // Update the remote streams by removing the first stream.
+ // This is done by removing all SSRCS for this particular stream.
+ typename T::Content content3;
+ stream1.ssrcs.clear();
+ content3.AddStream(stream1);
+ content3.set_partial(true);
+ EXPECT_TRUE(channel1_->SetRemoteContent(&content3, CA_UPDATE));
+ ASSERT_EQ(2u, media_channel1_->recv_streams().size());
+ EXPECT_EQ(stream2, media_channel1_->recv_streams()[0]);
+ EXPECT_EQ(stream3, media_channel1_->recv_streams()[1]);
+
+ // Update the remote streams with a stream that does not change.
+ // The update is ignored.
+ typename T::Content content4;
+ content4.AddStream(stream2);
+ content4.set_partial(true);
+ EXPECT_TRUE(channel1_->SetRemoteContent(&content4, CA_UPDATE));
+ ASSERT_EQ(2u, media_channel1_->recv_streams().size());
+ EXPECT_EQ(stream2, media_channel1_->recv_streams()[0]);
+ EXPECT_EQ(stream3, media_channel1_->recv_streams()[1]);
+ }
+
+ // Test that SetLocalContent and SetRemoteContent properly
+ // handles adding and removing StreamParams when the action is a full
+ // CA_OFFER / CA_ANSWER.
+ void TestChangeStreamParamsInContent() {
+ cricket::StreamParams stream1;
+ stream1.name = "Stream1";
+ stream1.ssrcs.push_back(kSsrc1);
+ stream1.cname = "stream1_cname";
+
+ cricket::StreamParams stream2;
+ stream2.name = "Stream2";
+ stream2.ssrcs.push_back(kSsrc2);
+ stream2.cname = "stream2_cname";
+
+ // Setup a call where channel 1 send |stream1| to channel 2.
+ CreateChannels(0, 0);
+ typename T::Content content1;
+ CreateContent(0, kPcmuCodec, kH264Codec, &content1);
+ content1.AddStream(stream1);
+ EXPECT_TRUE(channel1_->SetLocalContent(&content1, CA_OFFER));
+ EXPECT_TRUE(channel1_->Enable(true));
+ EXPECT_EQ(1u, media_channel1_->send_streams().size());
+
+ EXPECT_TRUE(channel2_->SetRemoteContent(&content1, CA_OFFER));
+ EXPECT_EQ(1u, media_channel2_->recv_streams().size());
+ session1_.Connect(&session2_);
+
+ // Channel 2 do not send anything.
+ typename T::Content content2;
+ CreateContent(0, kPcmuCodec, kH264Codec, &content2);
+ EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_ANSWER));
+ EXPECT_EQ(0u, media_channel1_->recv_streams().size());
+ EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_ANSWER));
+ EXPECT_TRUE(channel2_->Enable(true));
+ EXPECT_EQ(0u, media_channel2_->send_streams().size());
+
+ EXPECT_TRUE(SendCustomRtp1(kSsrc1));
+ EXPECT_TRUE(CheckCustomRtp2(kSsrc1));
+
+ // Let channel 2 update the content by sending |stream2| and enable SRTP.
+ typename T::Content content3;
+ CreateContent(SECURE, kPcmuCodec, kH264Codec, &content3);
+ content3.AddStream(stream2);
+ EXPECT_TRUE(channel2_->SetLocalContent(&content3, CA_OFFER));
+ ASSERT_EQ(1u, media_channel2_->send_streams().size());
+ EXPECT_EQ(stream2, media_channel2_->send_streams()[0]);
+
+ EXPECT_TRUE(channel1_->SetRemoteContent(&content3, CA_OFFER));
+ ASSERT_EQ(1u, media_channel1_->recv_streams().size());
+ EXPECT_EQ(stream2, media_channel1_->recv_streams()[0]);
+
+ // Channel 1 replies but stop sending stream1.
+ typename T::Content content4;
+ CreateContent(SECURE, kPcmuCodec, kH264Codec, &content4);
+ EXPECT_TRUE(channel1_->SetLocalContent(&content4, CA_ANSWER));
+ EXPECT_EQ(0u, media_channel1_->send_streams().size());
+
+ EXPECT_TRUE(channel2_->SetRemoteContent(&content4, CA_ANSWER));
+ EXPECT_EQ(0u, media_channel2_->recv_streams().size());
+
+ EXPECT_TRUE(channel1_->secure());
+ EXPECT_TRUE(channel2_->secure());
+ EXPECT_TRUE(SendCustomRtp2(kSsrc2));
+ EXPECT_TRUE(CheckCustomRtp1(kSsrc2));
+ }
+
+ // Test that we only start playout and sending at the right times.
+ void TestPlayoutAndSendingStates() {
+ CreateChannels(0, 0);
+ EXPECT_FALSE(media_channel1_->playout());
+ EXPECT_FALSE(media_channel1_->sending());
+ EXPECT_FALSE(media_channel2_->playout());
+ EXPECT_FALSE(media_channel2_->sending());
+ EXPECT_TRUE(channel1_->Enable(true));
+ EXPECT_FALSE(media_channel1_->playout());
+ EXPECT_FALSE(media_channel1_->sending());
+ EXPECT_TRUE(channel1_->SetLocalContent(&local_media_content1_, CA_OFFER));
+ EXPECT_TRUE(media_channel1_->playout());
+ EXPECT_FALSE(media_channel1_->sending());
+ EXPECT_TRUE(channel2_->SetRemoteContent(&local_media_content1_, CA_OFFER));
+ EXPECT_FALSE(media_channel2_->playout());
+ EXPECT_FALSE(media_channel2_->sending());
+ EXPECT_TRUE(channel2_->SetLocalContent(&local_media_content2_, CA_ANSWER));
+ EXPECT_FALSE(media_channel2_->playout());
+ EXPECT_FALSE(media_channel2_->sending());
+ session1_.Connect(&session2_);
+ EXPECT_TRUE(media_channel1_->playout());
+ EXPECT_FALSE(media_channel1_->sending());
+ EXPECT_FALSE(media_channel2_->playout());
+ EXPECT_FALSE(media_channel2_->sending());
+ EXPECT_TRUE(channel2_->Enable(true));
+ EXPECT_TRUE(media_channel2_->playout());
+ EXPECT_TRUE(media_channel2_->sending());
+ EXPECT_TRUE(channel1_->SetRemoteContent(&local_media_content2_, CA_ANSWER));
+ EXPECT_TRUE(media_channel1_->playout());
+ EXPECT_TRUE(media_channel1_->sending());
+ }
+
+ // Test setting up a call.
+ void TestCallSetup() {
+ CreateChannels(0, 0);
+ EXPECT_FALSE(channel1_->secure());
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(media_channel1_->playout());
+ EXPECT_FALSE(media_channel1_->sending());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_FALSE(channel1_->secure());
+ EXPECT_TRUE(media_channel1_->sending());
+ EXPECT_EQ(1U, media_channel1_->codecs().size());
+ EXPECT_TRUE(media_channel2_->playout());
+ EXPECT_TRUE(media_channel2_->sending());
+ EXPECT_EQ(1U, media_channel2_->codecs().size());
+ }
+
+ // Test that we don't crash if packets are sent during call teardown
+ // when RTCP mux is enabled. This is a regression test against a specific
+ // race condition that would only occur when a RTCP packet was sent during
+ // teardown of a channel on which RTCP mux was enabled.
+ void TestCallTeardownRtcpMux() {
+ class LastWordMediaChannel : public T::MediaChannel {
+ public:
+ LastWordMediaChannel() : T::MediaChannel(NULL) {}
+ ~LastWordMediaChannel() {
+ T::MediaChannel::SendRtp(kPcmuFrame, sizeof(kPcmuFrame));
+ T::MediaChannel::SendRtcp(kRtcpReport, sizeof(kRtcpReport));
+ }
+ };
+ CreateChannels(new LastWordMediaChannel(), new LastWordMediaChannel(),
+ RTCP | RTCP_MUX, RTCP | RTCP_MUX,
+ talk_base::Thread::Current());
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_TRUE(SendTerminate());
+ }
+
+ // Send voice RTP data to the other side and ensure it gets there.
+ void SendRtpToRtp() {
+ CreateChannels(0, 0);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_EQ(1U, GetTransport1()->channels().size());
+ EXPECT_EQ(1U, GetTransport2()->channels().size());
+ EXPECT_TRUE(SendRtp1());
+ EXPECT_TRUE(SendRtp2());
+ EXPECT_TRUE(CheckRtp1());
+ EXPECT_TRUE(CheckRtp2());
+ EXPECT_TRUE(CheckNoRtp1());
+ EXPECT_TRUE(CheckNoRtp2());
+ }
+
+ // Check that RTCP is not transmitted if both sides don't support RTCP.
+ void SendNoRtcpToNoRtcp() {
+ CreateChannels(0, 0);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_EQ(1U, GetTransport1()->channels().size());
+ EXPECT_EQ(1U, GetTransport2()->channels().size());
+ EXPECT_FALSE(SendRtcp1());
+ EXPECT_FALSE(SendRtcp2());
+ EXPECT_TRUE(CheckNoRtcp1());
+ EXPECT_TRUE(CheckNoRtcp2());
+ }
+
+ // Check that RTCP is not transmitted if the callee doesn't support RTCP.
+ void SendNoRtcpToRtcp() {
+ CreateChannels(0, RTCP);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_EQ(1U, GetTransport1()->channels().size());
+ EXPECT_EQ(2U, GetTransport2()->channels().size());
+ EXPECT_FALSE(SendRtcp1());
+ EXPECT_FALSE(SendRtcp2());
+ EXPECT_TRUE(CheckNoRtcp1());
+ EXPECT_TRUE(CheckNoRtcp2());
+ }
+
+ // Check that RTCP is not transmitted if the caller doesn't support RTCP.
+ void SendRtcpToNoRtcp() {
+ CreateChannels(RTCP, 0);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_EQ(2U, GetTransport1()->channels().size());
+ EXPECT_EQ(1U, GetTransport2()->channels().size());
+ EXPECT_FALSE(SendRtcp1());
+ EXPECT_FALSE(SendRtcp2());
+ EXPECT_TRUE(CheckNoRtcp1());
+ EXPECT_TRUE(CheckNoRtcp2());
+ }
+
+ // Check that RTCP is transmitted if both sides support RTCP.
+ void SendRtcpToRtcp() {
+ CreateChannels(RTCP, RTCP);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_EQ(2U, GetTransport1()->channels().size());
+ EXPECT_EQ(2U, GetTransport2()->channels().size());
+ EXPECT_TRUE(SendRtcp1());
+ EXPECT_TRUE(SendRtcp2());
+ EXPECT_TRUE(CheckRtcp1());
+ EXPECT_TRUE(CheckRtcp2());
+ EXPECT_TRUE(CheckNoRtcp1());
+ EXPECT_TRUE(CheckNoRtcp2());
+ }
+
+ // Check that RTCP is transmitted if only the initiator supports mux.
+ void SendRtcpMuxToRtcp() {
+ CreateChannels(RTCP | RTCP_MUX, RTCP);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_EQ(2U, GetTransport1()->channels().size());
+ EXPECT_EQ(2U, GetTransport2()->channels().size());
+ EXPECT_TRUE(SendRtcp1());
+ EXPECT_TRUE(SendRtcp2());
+ EXPECT_TRUE(CheckRtcp1());
+ EXPECT_TRUE(CheckRtcp2());
+ EXPECT_TRUE(CheckNoRtcp1());
+ EXPECT_TRUE(CheckNoRtcp2());
+ }
+
+ // Check that RTP and RTCP are transmitted ok when both sides support mux.
+ void SendRtcpMuxToRtcpMux() {
+ CreateChannels(RTCP | RTCP_MUX, RTCP | RTCP_MUX);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_EQ(2U, GetTransport1()->channels().size());
+ EXPECT_EQ(1U, GetTransport2()->channels().size());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_EQ(1U, GetTransport1()->channels().size());
+ EXPECT_TRUE(SendRtp1());
+ EXPECT_TRUE(SendRtp2());
+ EXPECT_TRUE(SendRtcp1());
+ EXPECT_TRUE(SendRtcp2());
+ EXPECT_TRUE(CheckRtp1());
+ EXPECT_TRUE(CheckRtp2());
+ EXPECT_TRUE(CheckNoRtp1());
+ EXPECT_TRUE(CheckNoRtp2());
+ EXPECT_TRUE(CheckRtcp1());
+ EXPECT_TRUE(CheckRtcp2());
+ EXPECT_TRUE(CheckNoRtcp1());
+ EXPECT_TRUE(CheckNoRtcp2());
+ }
+
+ // Check that RTCP data sent by the initiator before the accept is not muxed.
+ void SendEarlyRtcpMuxToRtcp() {
+ CreateChannels(RTCP | RTCP_MUX, RTCP);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_EQ(2U, GetTransport1()->channels().size());
+ EXPECT_EQ(2U, GetTransport2()->channels().size());
+
+ // RTCP can be sent before the call is accepted, if the transport is ready.
+ // It should not be muxed though, as the remote side doesn't support mux.
+ EXPECT_TRUE(SendRtcp1());
+ EXPECT_TRUE(CheckNoRtp2());
+ EXPECT_TRUE(CheckRtcp2());
+
+ // Send RTCP packet from callee and verify that it is received.
+ EXPECT_TRUE(SendRtcp2());
+ EXPECT_TRUE(CheckNoRtp1());
+ EXPECT_TRUE(CheckRtcp1());
+
+ // Complete call setup and ensure everything is still OK.
+ EXPECT_TRUE(SendAccept());
+ EXPECT_EQ(2U, GetTransport1()->channels().size());
+ EXPECT_TRUE(SendRtcp1());
+ EXPECT_TRUE(CheckRtcp2());
+ EXPECT_TRUE(SendRtcp2());
+ EXPECT_TRUE(CheckRtcp1());
+ }
+
+
+ // Check that RTCP data is not muxed until both sides have enabled muxing,
+ // but that we properly demux before we get the accept message, since there
+ // is a race between RTP data and the jingle accept.
+ void SendEarlyRtcpMuxToRtcpMux() {
+ CreateChannels(RTCP | RTCP_MUX, RTCP | RTCP_MUX);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_EQ(2U, GetTransport1()->channels().size());
+ EXPECT_EQ(1U, GetTransport2()->channels().size());
+
+ // RTCP can't be sent yet, since the RTCP transport isn't writable, and
+ // we haven't yet received the accept that says we should mux.
+ EXPECT_FALSE(SendRtcp1());
+
+ // Send muxed RTCP packet from callee and verify that it is received.
+ EXPECT_TRUE(SendRtcp2());
+ EXPECT_TRUE(CheckNoRtp1());
+ EXPECT_TRUE(CheckRtcp1());
+
+ // Complete call setup and ensure everything is still OK.
+ EXPECT_TRUE(SendAccept());
+ EXPECT_EQ(1U, GetTransport1()->channels().size());
+ EXPECT_TRUE(SendRtcp1());
+ EXPECT_TRUE(CheckRtcp2());
+ EXPECT_TRUE(SendRtcp2());
+ EXPECT_TRUE(CheckRtcp1());
+ }
+
+ // Test that we properly send SRTP with RTCP in both directions.
+ void SendSrtpToSrtp() {
+ CreateChannels(RTCP | SECURE, RTCP | SECURE);
+ EXPECT_FALSE(channel1_->secure());
+ EXPECT_FALSE(channel2_->secure());
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_TRUE(channel1_->secure());
+ EXPECT_TRUE(channel2_->secure());
+ EXPECT_TRUE(SendRtp1());
+ EXPECT_TRUE(SendRtp2());
+ EXPECT_TRUE(SendRtcp1());
+ EXPECT_TRUE(SendRtcp2());
+ EXPECT_TRUE(CheckRtp1());
+ EXPECT_TRUE(CheckRtp2());
+ EXPECT_TRUE(CheckNoRtp1());
+ EXPECT_TRUE(CheckNoRtp2());
+ EXPECT_TRUE(CheckRtcp1());
+ EXPECT_TRUE(CheckRtcp2());
+ EXPECT_TRUE(CheckNoRtcp1());
+ EXPECT_TRUE(CheckNoRtcp2());
+ }
+
+ // Test that we properly handling SRTP negotiating down to RTP.
+ void SendSrtpToRtp() {
+ CreateChannels(RTCP | SECURE, RTCP);
+ EXPECT_FALSE(channel1_->secure());
+ EXPECT_FALSE(channel2_->secure());
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_FALSE(channel1_->secure());
+ EXPECT_FALSE(channel2_->secure());
+ EXPECT_TRUE(SendRtp1());
+ EXPECT_TRUE(SendRtp2());
+ EXPECT_TRUE(SendRtcp1());
+ EXPECT_TRUE(SendRtcp2());
+ EXPECT_TRUE(CheckRtp1());
+ EXPECT_TRUE(CheckRtp2());
+ EXPECT_TRUE(CheckNoRtp1());
+ EXPECT_TRUE(CheckNoRtp2());
+ EXPECT_TRUE(CheckRtcp1());
+ EXPECT_TRUE(CheckRtcp2());
+ EXPECT_TRUE(CheckNoRtcp1());
+ EXPECT_TRUE(CheckNoRtcp2());
+ }
+
+ // Test that we properly send SRTP with RTCP mux in both directions.
+ void SendSrtcpMux() {
+ CreateChannels(RTCP | RTCP_MUX | SECURE, RTCP | RTCP_MUX | SECURE);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_TRUE(SendRtp1());
+ EXPECT_TRUE(SendRtp2());
+ EXPECT_TRUE(SendRtcp1());
+ EXPECT_TRUE(SendRtcp2());
+ EXPECT_TRUE(CheckRtp1());
+ EXPECT_TRUE(CheckRtp2());
+ EXPECT_TRUE(CheckNoRtp1());
+ EXPECT_TRUE(CheckNoRtp2());
+ EXPECT_TRUE(CheckRtcp1());
+ EXPECT_TRUE(CheckRtcp2());
+ EXPECT_TRUE(CheckNoRtcp1());
+ EXPECT_TRUE(CheckNoRtcp2());
+ }
+
+ // Test that we properly send RTP without SRTP from a thread.
+ void SendRtpToRtpOnThread() {
+ bool sent_rtp1, sent_rtp2, sent_rtcp1, sent_rtcp2;
+ CreateChannels(RTCP, RTCP);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ CallOnThread(&ChannelTest<T>::SendRtp1, &sent_rtp1);
+ CallOnThread(&ChannelTest<T>::SendRtp2, &sent_rtp2);
+ CallOnThread(&ChannelTest<T>::SendRtcp1, &sent_rtcp1);
+ CallOnThread(&ChannelTest<T>::SendRtcp2, &sent_rtcp2);
+ EXPECT_TRUE_WAIT(CheckRtp1(), 1000);
+ EXPECT_TRUE_WAIT(CheckRtp2(), 1000);
+ EXPECT_TRUE_WAIT(sent_rtp1, 1000);
+ EXPECT_TRUE_WAIT(sent_rtp2, 1000);
+ EXPECT_TRUE(CheckNoRtp1());
+ EXPECT_TRUE(CheckNoRtp2());
+ EXPECT_TRUE_WAIT(CheckRtcp1(), 1000);
+ EXPECT_TRUE_WAIT(CheckRtcp2(), 1000);
+ EXPECT_TRUE_WAIT(sent_rtcp1, 1000);
+ EXPECT_TRUE_WAIT(sent_rtcp2, 1000);
+ EXPECT_TRUE(CheckNoRtcp1());
+ EXPECT_TRUE(CheckNoRtcp2());
+ }
+
+ // Test that we properly send SRTP with RTCP from a thread.
+ void SendSrtpToSrtpOnThread() {
+ bool sent_rtp1, sent_rtp2, sent_rtcp1, sent_rtcp2;
+ CreateChannels(RTCP | SECURE, RTCP | SECURE);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ CallOnThread(&ChannelTest<T>::SendRtp1, &sent_rtp1);
+ CallOnThread(&ChannelTest<T>::SendRtp2, &sent_rtp2);
+ CallOnThread(&ChannelTest<T>::SendRtcp1, &sent_rtcp1);
+ CallOnThread(&ChannelTest<T>::SendRtcp2, &sent_rtcp2);
+ EXPECT_TRUE_WAIT(CheckRtp1(), 1000);
+ EXPECT_TRUE_WAIT(CheckRtp2(), 1000);
+ EXPECT_TRUE_WAIT(sent_rtp1, 1000);
+ EXPECT_TRUE_WAIT(sent_rtp2, 1000);
+ EXPECT_TRUE(CheckNoRtp1());
+ EXPECT_TRUE(CheckNoRtp2());
+ EXPECT_TRUE_WAIT(CheckRtcp1(), 1000);
+ EXPECT_TRUE_WAIT(CheckRtcp2(), 1000);
+ EXPECT_TRUE_WAIT(sent_rtcp1, 1000);
+ EXPECT_TRUE_WAIT(sent_rtcp2, 1000);
+ EXPECT_TRUE(CheckNoRtcp1());
+ EXPECT_TRUE(CheckNoRtcp2());
+ }
+
+ // Test that the mediachannel retains its sending state after the transport
+ // becomes non-writable.
+ void SendWithWritabilityLoss() {
+ CreateChannels(0, 0);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_EQ(1U, GetTransport1()->channels().size());
+ EXPECT_EQ(1U, GetTransport2()->channels().size());
+ EXPECT_TRUE(SendRtp1());
+ EXPECT_TRUE(SendRtp2());
+ EXPECT_TRUE(CheckRtp1());
+ EXPECT_TRUE(CheckRtp2());
+ EXPECT_TRUE(CheckNoRtp1());
+ EXPECT_TRUE(CheckNoRtp2());
+
+ GetTransport1()->SetDestination(NULL);
+ EXPECT_TRUE(media_channel1_->sending());
+ EXPECT_FALSE(SendRtp1());
+ EXPECT_TRUE(SendRtp2());
+ EXPECT_TRUE(CheckRtp1());
+ EXPECT_TRUE(CheckNoRtp2());
+
+ GetTransport1()->SetDestination(GetTransport2());
+ EXPECT_TRUE(media_channel1_->sending());
+ EXPECT_TRUE(SendRtp1());
+ EXPECT_TRUE(SendRtp2());
+ EXPECT_TRUE(CheckRtp1());
+ EXPECT_TRUE(CheckRtp2());
+ EXPECT_TRUE(CheckNoRtp1());
+ EXPECT_TRUE(CheckNoRtp2());
+ }
+
+ void SendSsrcMuxToSsrcMuxWithRtcpMux() {
+ CreateChannels(SSRC_MUX | RTCP | RTCP_MUX, SSRC_MUX | RTCP | RTCP_MUX);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_EQ(2U, GetTransport1()->channels().size());
+ EXPECT_EQ(1U, GetTransport2()->channels().size());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_EQ(1U, GetTransport1()->channels().size());
+ EXPECT_EQ(1U, GetTransport2()->channels().size());
+ EXPECT_TRUE(channel1_->ssrc_filter()->IsActive());
+ // channel1 - should have media_content2 as remote. i.e. kSsrc2
+ EXPECT_TRUE(channel1_->ssrc_filter()->FindStream(kSsrc2));
+ EXPECT_TRUE(channel2_->ssrc_filter()->IsActive());
+ // channel2 - should have media_content1 as remote. i.e. kSsrc1
+ EXPECT_TRUE(channel2_->ssrc_filter()->FindStream(kSsrc1));
+ EXPECT_TRUE(SendCustomRtp1(kSsrc1));
+ EXPECT_TRUE(SendCustomRtp2(kSsrc2));
+ EXPECT_TRUE(SendCustomRtcp1(kSsrc1));
+ EXPECT_TRUE(SendCustomRtcp2(kSsrc2));
+ EXPECT_TRUE(CheckCustomRtp1(kSsrc2));
+ EXPECT_TRUE(CheckNoRtp1());
+ EXPECT_TRUE(CheckCustomRtp2(kSsrc1));
+ EXPECT_TRUE(CheckNoRtp2());
+ EXPECT_TRUE(CheckCustomRtcp1(kSsrc2));
+ EXPECT_TRUE(CheckNoRtcp1());
+ EXPECT_TRUE(CheckCustomRtcp2(kSsrc1));
+ EXPECT_TRUE(CheckNoRtcp2());
+ }
+
+ void SendSsrcMuxToSsrcMux() {
+ CreateChannels(SSRC_MUX | RTCP, SSRC_MUX | RTCP);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_EQ(2U, GetTransport1()->channels().size());
+ EXPECT_EQ(2U, GetTransport2()->channels().size());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_EQ(2U, GetTransport1()->channels().size());
+ EXPECT_EQ(2U, GetTransport2()->channels().size());
+ EXPECT_TRUE(channel1_->ssrc_filter()->IsActive());
+ // channel1 - should have media_content2 as remote. i.e. kSsrc2
+ EXPECT_TRUE(channel1_->ssrc_filter()->FindStream(kSsrc2));
+ EXPECT_TRUE(channel2_->ssrc_filter()->IsActive());
+ // channel2 - should have media_content1 as remote. i.e. kSsrc1
+ EXPECT_TRUE(SendCustomRtp1(kSsrc1));
+ EXPECT_TRUE(SendCustomRtp2(kSsrc2));
+ EXPECT_TRUE(SendCustomRtcp1(kSsrc1));
+ EXPECT_TRUE(SendCustomRtcp2(kSsrc2));
+ EXPECT_TRUE(CheckCustomRtp1(kSsrc2));
+ EXPECT_FALSE(CheckCustomRtp1(kSsrc1));
+ EXPECT_TRUE(CheckCustomRtp2(kSsrc1));
+ EXPECT_FALSE(CheckCustomRtp2(kSsrc2));
+ EXPECT_TRUE(CheckCustomRtcp1(kSsrc2));
+ EXPECT_FALSE(CheckCustomRtcp1(kSsrc1));
+ EXPECT_TRUE(CheckCustomRtcp2(kSsrc1));
+ EXPECT_FALSE(CheckCustomRtcp2(kSsrc2));
+ }
+
+ // Test that the media monitor can be run and gives timely callbacks.
+ void TestMediaMonitor() {
+ static const int kTimeout = 500;
+ CreateChannels(0, 0);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ channel1_->StartMediaMonitor(100);
+ channel2_->StartMediaMonitor(100);
+ // Ensure we get callbacks and stop.
+ EXPECT_TRUE_WAIT(media_info_callbacks1_ > 0, kTimeout);
+ EXPECT_TRUE_WAIT(media_info_callbacks2_ > 0, kTimeout);
+ channel1_->StopMediaMonitor();
+ channel2_->StopMediaMonitor();
+ // Ensure a restart of a stopped monitor works.
+ channel1_->StartMediaMonitor(100);
+ EXPECT_TRUE_WAIT(media_info_callbacks1_ > 0, kTimeout);
+ channel1_->StopMediaMonitor();
+ // Ensure stopping a stopped monitor is OK.
+ channel1_->StopMediaMonitor();
+ }
+
+ void TestMediaSinks() {
+ CreateChannels(0, 0);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_FALSE(channel1_->HasSendSinks());
+ EXPECT_FALSE(channel1_->HasRecvSinks());
+
+ talk_base::Pathname path;
+ EXPECT_TRUE(talk_base::Filesystem::GetTemporaryFolder(path, true, NULL));
+ path.SetFilename("sink-test.rtpdump");
+ talk_base::scoped_ptr<cricket::RtpDumpSink> sink(
+ new cricket::RtpDumpSink(path.pathname()));
+ sink->set_packet_filter(cricket::PF_ALL);
+ EXPECT_TRUE(sink->Enable(true));
+ channel1_->RegisterSendSink(sink.get(), &cricket::RtpDumpSink::OnPacket);
+ EXPECT_TRUE(channel1_->HasSendSinks());
+ EXPECT_FALSE(channel1_->HasRecvSinks());
+ // The first packet is recorded with header + data.
+ EXPECT_TRUE(SendRtp1());
+ // The second packet is recorded with header only.
+ sink->set_packet_filter(cricket::PF_RTPHEADER);
+ EXPECT_TRUE(SendRtp1());
+ // The third packet is not recorded since sink is disabled.
+ EXPECT_TRUE(sink->Enable(false));
+ EXPECT_TRUE(SendRtp1());
+ // The fourth packet is not recorded since sink is unregistered.
+ EXPECT_TRUE(sink->Enable(true));
+ channel1_->UnregisterSendSink(sink.get());
+ EXPECT_TRUE(SendRtp1());
+ sink.reset(); // This will close the file.
+
+ // Read the recorded file and verify two packets.
+ talk_base::scoped_ptr<talk_base::StreamInterface> stream(
+ talk_base::Filesystem::OpenFile(path, "rb"));
+
+ cricket::RtpDumpReader reader(stream.get());
+ cricket::RtpDumpPacket packet;
+ EXPECT_EQ(talk_base::SR_SUCCESS, reader.ReadPacket(&packet));
+ std::string read_packet(reinterpret_cast<const char*>(&packet.data[0]),
+ packet.data.size());
+ EXPECT_EQ(rtp_packet_, read_packet);
+
+ EXPECT_EQ(talk_base::SR_SUCCESS, reader.ReadPacket(&packet));
+ size_t len = 0;
+ packet.GetRtpHeaderLen(&len);
+ EXPECT_EQ(len, packet.data.size());
+ EXPECT_EQ(0, memcmp(&packet.data[0], rtp_packet_.c_str(), len));
+
+ EXPECT_EQ(talk_base::SR_EOS, reader.ReadPacket(&packet));
+
+ // Delete the file for media recording.
+ stream.reset();
+ EXPECT_TRUE(talk_base::Filesystem::DeleteFile(path));
+ }
+
+ void TestSetContentFailure() {
+ CreateChannels(0, 0);
+ typename T::Content content;
+ cricket::SessionDescription* sdesc_loc = new cricket::SessionDescription();
+ cricket::SessionDescription* sdesc_rem = new cricket::SessionDescription();
+
+ // Set up the session description.
+ CreateContent(0, kPcmuCodec, kH264Codec, &content);
+ sdesc_loc->AddContent(cricket::CN_AUDIO, cricket::NS_JINGLE_RTP,
+ new cricket::AudioContentDescription());
+ sdesc_loc->AddContent(cricket::CN_VIDEO, cricket::NS_JINGLE_RTP,
+ new cricket::VideoContentDescription());
+ EXPECT_TRUE(session1_.set_local_description(sdesc_loc));
+ sdesc_rem->AddContent(cricket::CN_AUDIO, cricket::NS_JINGLE_RTP,
+ new cricket::AudioContentDescription());
+ sdesc_rem->AddContent(cricket::CN_VIDEO, cricket::NS_JINGLE_RTP,
+ new cricket::VideoContentDescription());
+ EXPECT_TRUE(session1_.set_remote_description(sdesc_rem));
+
+ // Test failures in SetLocalContent.
+ media_channel1_->set_fail_set_recv_codecs(true);
+ session1_.SetError(cricket::BaseSession::ERROR_NONE);
+ session1_.SignalState(&session1_, cricket::Session::STATE_SENTINITIATE);
+ EXPECT_EQ(cricket::BaseSession::ERROR_CONTENT, session1_.error());
+ media_channel1_->set_fail_set_recv_codecs(true);
+ session1_.SetError(cricket::BaseSession::ERROR_NONE);
+ session1_.SignalState(&session1_, cricket::Session::STATE_SENTACCEPT);
+ EXPECT_EQ(cricket::BaseSession::ERROR_CONTENT, session1_.error());
+
+ // Test failures in SetRemoteContent.
+ media_channel1_->set_fail_set_send_codecs(true);
+ session1_.SetError(cricket::BaseSession::ERROR_NONE);
+ session1_.SignalState(&session1_, cricket::Session::STATE_RECEIVEDINITIATE);
+ EXPECT_EQ(cricket::BaseSession::ERROR_CONTENT, session1_.error());
+ media_channel1_->set_fail_set_send_codecs(true);
+ session1_.SetError(cricket::BaseSession::ERROR_NONE);
+ session1_.SignalState(&session1_, cricket::Session::STATE_RECEIVEDACCEPT);
+ EXPECT_EQ(cricket::BaseSession::ERROR_CONTENT, session1_.error());
+ }
+
+ void TestFlushRtcp() {
+ bool send_rtcp1;
+
+ CreateChannels(RTCP, RTCP);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_EQ(2U, GetTransport1()->channels().size());
+ EXPECT_EQ(2U, GetTransport2()->channels().size());
+
+ // Send RTCP1 from a different thread.
+ CallOnThreadAndWaitForDone(&ChannelTest<T>::SendRtcp1, &send_rtcp1);
+ EXPECT_TRUE(send_rtcp1);
+ // The sending message is only posted. channel2_ should be empty.
+ EXPECT_TRUE(CheckNoRtcp2());
+
+ // When channel1_ is deleted, the RTCP packet should be sent out to
+ // channel2_.
+ channel1_.reset();
+ EXPECT_TRUE(CheckRtcp2());
+ }
+
+ void TestChangeStateError() {
+ CreateChannels(RTCP, RTCP);
+ EXPECT_TRUE(SendInitiate());
+ media_channel2_->set_fail_set_send(true);
+ EXPECT_TRUE(channel2_->Enable(true));
+ EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_REC_DEVICE_OPEN_FAILED,
+ error_);
+ }
+
+ void TestSrtpError() {
+ static const unsigned char kBadPacket[] = {
+ 0x90, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
+ };
+ CreateChannels(RTCP | SECURE, RTCP | SECURE);
+ EXPECT_FALSE(channel1_->secure());
+ EXPECT_FALSE(channel2_->secure());
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_TRUE(channel1_->secure());
+ EXPECT_TRUE(channel2_->secure());
+ channel2_->set_srtp_signal_silent_time(200);
+
+ // Testing failures in sending packets.
+ EXPECT_FALSE(media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket)));
+ // The first failure will trigger an error.
+ EXPECT_EQ_WAIT(T::MediaChannel::ERROR_REC_SRTP_ERROR, error_, 500);
+ error_ = T::MediaChannel::ERROR_NONE;
+ // The next 1 sec failures will not trigger an error.
+ EXPECT_FALSE(media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket)));
+ // Wait for a while to ensure no message comes in.
+ talk_base::Thread::Current()->ProcessMessages(210);
+ EXPECT_EQ(T::MediaChannel::ERROR_NONE, error_);
+ // The error will be triggered again.
+ EXPECT_FALSE(media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket)));
+ EXPECT_EQ_WAIT(T::MediaChannel::ERROR_REC_SRTP_ERROR, error_, 500);
+
+ // Testing failures in receiving packets.
+ error_ = T::MediaChannel::ERROR_NONE;
+ cricket::TransportChannel* transport_channel =
+ channel2_->transport_channel();
+ transport_channel->SignalReadPacket(
+ transport_channel, reinterpret_cast<const char*>(kBadPacket),
+ sizeof(kBadPacket));
+ EXPECT_EQ_WAIT(T::MediaChannel::ERROR_PLAY_SRTP_AUTH_FAILED, error_, 500);
+ }
+
+ protected:
+ cricket::FakeSession session1_;
+ cricket::FakeSession session2_;
+ cricket::FakeMediaEngine media_engine_;
+ // The media channels are owned by the voice channel objects below.
+ typename T::MediaChannel* media_channel1_;
+ typename T::MediaChannel* media_channel2_;
+ talk_base::scoped_ptr<typename T::Channel> channel1_;
+ talk_base::scoped_ptr<typename T::Channel> channel2_;
+ typename T::Content local_media_content1_;
+ typename T::Content local_media_content2_;
+ typename T::Content remote_media_content1_;
+ typename T::Content remote_media_content2_;
+ // The RTP and RTCP packets to send in the tests.
+ std::string rtp_packet_;
+ std::string rtcp_packet_;
+ int media_info_callbacks1_;
+ int media_info_callbacks2_;
+ uint32 ssrc_;
+ typename T::MediaChannel::Error error_;
+};
+
+
+template<>
+void ChannelTest<VoiceTraits>::CreateContent(
+ int flags,
+ const cricket::AudioCodec& audio_codec,
+ const cricket::VideoCodec& video_codec,
+ cricket::AudioContentDescription* audio) {
+ audio->AddCodec(audio_codec);
+ audio->set_rtcp_mux((flags & RTCP_MUX) != 0);
+ if (flags & SECURE) {
+ audio->AddCrypto(cricket::CryptoParams(
+ 1, cricket::CS_AES_CM_128_HMAC_SHA1_32,
+ "inline:" + talk_base::CreateRandomString(40), ""));
+ }
+}
+
+template<>
+void ChannelTest<VoiceTraits>::CopyContent(
+ const cricket::AudioContentDescription& source,
+ cricket::AudioContentDescription* audio) {
+ *audio = source;
+}
+
+template<>
+bool ChannelTest<VoiceTraits>::CodecMatches(const cricket::AudioCodec& c1,
+ const cricket::AudioCodec& c2) {
+ return c1.name == c2.name && c1.clockrate == c2.clockrate &&
+ c1.bitrate == c2.bitrate && c1.channels == c2.channels;
+}
+
+template<>
+void ChannelTest<VoiceTraits>::AddLegacyStreamInContent(
+ uint32 ssrc, int flags, cricket::AudioContentDescription* audio) {
+ audio->AddLegacyStream(ssrc);
+}
+
+class VoiceChannelTest
+ : public ChannelTest<VoiceTraits> {
+ public:
+ typedef ChannelTest<VoiceTraits>
+ Base;
+ VoiceChannelTest() : Base(kPcmuFrame, sizeof(kPcmuFrame),
+ kRtcpReport, sizeof(kRtcpReport)) {
+ }
+};
+
+// override to add NULL parameter
+template<>
+cricket::VideoChannel* ChannelTest<VideoTraits>::CreateChannel(
+ talk_base::Thread* thread, cricket::MediaEngineInterface* engine,
+ cricket::FakeVideoMediaChannel* ch, cricket::BaseSession* session,
+ bool rtcp) {
+ cricket::VideoChannel* channel = new cricket::VideoChannel(
+ thread, engine, ch, session, cricket::CN_VIDEO, rtcp, NULL);
+ if (!channel->Init()) {
+ delete channel;
+ channel = NULL;
+ }
+ return channel;
+}
+
+// override to add 0 parameter
+template<>
+bool ChannelTest<VideoTraits>::AddStream1(int id) {
+ return channel1_->AddRecvStream(cricket::StreamParams::CreateLegacy(id));
+}
+
+template<>
+void ChannelTest<VideoTraits>::CreateContent(
+ int flags,
+ const cricket::AudioCodec& audio_codec,
+ const cricket::VideoCodec& video_codec,
+ cricket::VideoContentDescription* video) {
+ video->AddCodec(video_codec);
+ video->set_rtcp_mux((flags & RTCP_MUX) != 0);
+ if (flags & SECURE) {
+ video->AddCrypto(cricket::CryptoParams(
+ 1, cricket::CS_AES_CM_128_HMAC_SHA1_80,
+ "inline:" + talk_base::CreateRandomString(40), ""));
+ }
+}
+
+template<>
+void ChannelTest<VideoTraits>::CopyContent(
+ const cricket::VideoContentDescription& source,
+ cricket::VideoContentDescription* video) {
+ *video = source;
+}
+
+template<>
+bool ChannelTest<VideoTraits>::CodecMatches(const cricket::VideoCodec& c1,
+ const cricket::VideoCodec& c2) {
+ return c1.name == c2.name && c1.width == c2.width && c1.height == c2.height &&
+ c1.framerate == c2.framerate;
+}
+
+template<>
+void ChannelTest<VideoTraits>::AddLegacyStreamInContent(
+ uint32 ssrc, int flags, cricket::VideoContentDescription* video) {
+ video->AddLegacyStream(ssrc);
+}
+
+class VideoChannelTest
+ : public ChannelTest<VideoTraits> {
+ public:
+ typedef ChannelTest<VideoTraits>
+ Base;
+ VideoChannelTest() : Base(kH264Packet, sizeof(kH264Packet),
+ kRtcpReport, sizeof(kRtcpReport)) {
+ }
+};
+
+
+// VoiceChannelTest
+
+TEST_F(VoiceChannelTest, TestInit) {
+ Base::TestInit();
+ EXPECT_FALSE(media_channel1_->muted());
+ EXPECT_TRUE(media_channel1_->dtmf_queue().empty());
+}
+
+TEST_F(VoiceChannelTest, TestSetContents) {
+ Base::TestSetContents();
+}
+
+TEST_F(VoiceChannelTest, TestSetContentsNullOffer) {
+ Base::TestSetContentsNullOffer();
+}
+
+TEST_F(VoiceChannelTest, TestSetContentsRtcpMux) {
+ Base::TestSetContentsRtcpMux();
+}
+
+TEST_F(VoiceChannelTest, TestSetRemoteContentUpdate) {
+ Base::TestSetRemoteContentUpdate();
+}
+
+TEST_F(VoiceChannelTest, TestStreams) {
+ Base::TestStreams();
+}
+
+TEST_F(VoiceChannelTest, TestUpdateStreamsInLocalContent) {
+ Base::TestUpdateStreamsInLocalContent();
+}
+
+TEST_F(VoiceChannelTest, TestUpdateRemoteStreamsInContent) {
+ Base::TestUpdateStreamsInRemoteContent();
+}
+
+TEST_F(VoiceChannelTest, TestChangeStreamParamsInContent) {
+ Base::TestChangeStreamParamsInContent();
+}
+
+TEST_F(VoiceChannelTest, TestPlayoutAndSendingStates) {
+ Base::TestPlayoutAndSendingStates();
+}
+
+TEST_F(VoiceChannelTest, TestCallSetup) {
+ Base::TestCallSetup();
+}
+
+TEST_F(VoiceChannelTest, TestCallTeardownRtcpMux) {
+ Base::TestCallTeardownRtcpMux();
+}
+
+TEST_F(VoiceChannelTest, SendRtpToRtp) {
+ Base::SendRtpToRtp();
+}
+
+TEST_F(VoiceChannelTest, SendNoRtcpToNoRtcp) {
+ Base::SendNoRtcpToNoRtcp();
+}
+
+TEST_F(VoiceChannelTest, SendNoRtcpToRtcp) {
+ Base::SendNoRtcpToRtcp();
+}
+
+TEST_F(VoiceChannelTest, SendRtcpToNoRtcp) {
+ Base::SendRtcpToNoRtcp();
+}
+
+TEST_F(VoiceChannelTest, SendRtcpToRtcp) {
+ Base::SendRtcpToRtcp();
+}
+
+TEST_F(VoiceChannelTest, SendRtcpMuxToRtcp) {
+ Base::SendRtcpMuxToRtcp();
+}
+
+TEST_F(VoiceChannelTest, SendRtcpMuxToRtcpMux) {
+ Base::SendRtcpMuxToRtcpMux();
+}
+
+TEST_F(VoiceChannelTest, SendEarlyRtcpMuxToRtcp) {
+ Base::SendEarlyRtcpMuxToRtcp();
+}
+
+TEST_F(VoiceChannelTest, SendEarlyRtcpMuxToRtcpMux) {
+ Base::SendEarlyRtcpMuxToRtcpMux();
+}
+
+TEST_F(VoiceChannelTest, SendSrtpToSrtp) {
+ Base::SendSrtpToSrtp();
+}
+
+TEST_F(VoiceChannelTest, SendSrtpToRtp) {
+ Base::SendSrtpToSrtp();
+}
+
+TEST_F(VoiceChannelTest, SendSrtcpMux) {
+ Base::SendSrtcpMux();
+}
+
+TEST_F(VoiceChannelTest, SendRtpToRtpOnThread) {
+ Base::SendRtpToRtpOnThread();
+}
+
+TEST_F(VoiceChannelTest, SendSrtpToSrtpOnThread) {
+ Base::SendSrtpToSrtpOnThread();
+}
+
+TEST_F(VoiceChannelTest, SendWithWritabilityLoss) {
+ Base::SendWithWritabilityLoss();
+}
+
+TEST_F(VoiceChannelTest, TestMediaMonitor) {
+ Base::TestMediaMonitor();
+}
+
+// Test that Mute properly forwards to the media channel.
+TEST_F(VoiceChannelTest, TestMute) {
+ CreateChannels(0, 0);
+ EXPECT_FALSE(media_channel1_->muted());
+ EXPECT_TRUE(channel1_->Mute(true));
+ EXPECT_TRUE(media_channel1_->muted());
+ EXPECT_TRUE(channel1_->Mute(false));
+ EXPECT_FALSE(media_channel1_->muted());
+}
+
+// Test that keyboard automute works correctly.
+TEST_F(VoiceChannelTest, TestKeyboardMute) {
+ CreateChannels(0, 0);
+ EXPECT_FALSE(media_channel1_->muted());
+ EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_NONE, error_);
+
+ cricket::VoiceMediaChannel::Error e =
+ cricket::VoiceMediaChannel::ERROR_REC_TYPING_NOISE_DETECTED;
+
+ // Typing doesn't mute automatically
+ media_channel1_->TriggerError(0, e);
+ talk_base::Thread::Current()->ProcessMessages(0);
+ EXPECT_EQ(e, error_);
+ EXPECT_FALSE(media_channel1_->muted());
+
+ // But it does when enabled
+ channel1_->set_mute_on_type(true, 200);
+ media_channel1_->TriggerError(0, e);
+ error_ = cricket::VoiceMediaChannel::ERROR_NONE;
+ EXPECT_TRUE_WAIT(error_ == e, 100);
+ EXPECT_TRUE(media_channel1_->muted());
+ EXPECT_TRUE_WAIT(!media_channel1_->muted(), 250); // And resets.
+
+ // Muting manually preemts auto-unmute
+ media_channel1_->TriggerError(0, e);
+ error_ = cricket::VoiceMediaChannel::ERROR_NONE;
+ EXPECT_TRUE_WAIT(error_ == e, 100);
+ EXPECT_TRUE(media_channel1_->muted());
+ EXPECT_TRUE(channel1_->Mute(true));
+ talk_base::Thread::Current()->ProcessMessages(250);
+ EXPECT_TRUE(media_channel1_->muted());
+}
+
+// Test that PressDTMF properly forwards to the media channel.
+TEST_F(VoiceChannelTest, TestDtmf) {
+ CreateChannels(0, 0);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_EQ(0U, media_channel1_->dtmf_queue().size());
+ EXPECT_TRUE(channel1_->PressDTMF(1, true));
+ EXPECT_TRUE(channel1_->PressDTMF(8, false));
+ ASSERT_EQ(2U, media_channel1_->dtmf_queue().size());
+ EXPECT_EQ(1, media_channel1_->dtmf_queue()[0].first);
+ EXPECT_EQ(true, media_channel1_->dtmf_queue()[0].second);
+ EXPECT_EQ(8, media_channel1_->dtmf_queue()[1].first);
+ EXPECT_FALSE(media_channel1_->dtmf_queue()[1].second);
+}
+
+TEST_F(VoiceChannelTest, TestMediaSinks) {
+ Base::TestMediaSinks();
+}
+
+TEST_F(VoiceChannelTest, TestSetContentFailure) {
+ Base::TestSetContentFailure();
+}
+
+TEST_F(VoiceChannelTest, TestFlushRtcp) {
+ Base::TestFlushRtcp();
+}
+
+TEST_F(VoiceChannelTest, TestChangeStateError) {
+ Base::TestChangeStateError();
+}
+
+TEST_F(VoiceChannelTest, TestSrtpError) {
+ Base::TestSrtpError();
+}
+
+// Test that we can play a ringback tone properly.
+TEST_F(VoiceChannelTest, TestRingbackTone) {
+ CreateChannels(RTCP, RTCP);
+ EXPECT_FALSE(media_channel1_->ringback_tone_play());
+ EXPECT_TRUE(channel1_->SetRingbackTone("RIFF", 4));
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ // Play ringback tone, no loop.
+ EXPECT_TRUE(channel1_->PlayRingbackTone(0, true, false));
+ EXPECT_EQ(0U, media_channel1_->ringback_tone_ssrc());
+ EXPECT_TRUE(media_channel1_->ringback_tone_play());
+ EXPECT_FALSE(media_channel1_->ringback_tone_loop());
+ // Stop the ringback tone.
+ EXPECT_TRUE(channel1_->PlayRingbackTone(0, false, false));
+ EXPECT_FALSE(media_channel1_->ringback_tone_play());
+ // Add a stream.
+ EXPECT_TRUE(AddStream1(1));
+ // Play ringback tone, looping, on the new stream.
+ EXPECT_TRUE(channel1_->PlayRingbackTone(1, true, true));
+ EXPECT_EQ(1U, media_channel1_->ringback_tone_ssrc());
+ EXPECT_TRUE(media_channel1_->ringback_tone_play());
+ EXPECT_TRUE(media_channel1_->ringback_tone_loop());
+ // Stop the ringback tone.
+ EXPECT_TRUE(channel1_->PlayRingbackTone(1, false, false));
+ EXPECT_FALSE(media_channel1_->ringback_tone_play());
+}
+
+// Test that we can scale the output volume properly for 1:1 calls.
+TEST_F(VoiceChannelTest, TestScaleVolume1to1Call) {
+ CreateChannels(RTCP, RTCP);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ double left, right;
+
+ // Default is (1.0, 1.0).
+ EXPECT_TRUE(media_channel1_->GetOutputScaling(0, &left, &right));
+ EXPECT_DOUBLE_EQ(1.0, left);
+ EXPECT_DOUBLE_EQ(1.0, right);
+ // invalid ssrc.
+ EXPECT_FALSE(media_channel1_->GetOutputScaling(3, &left, &right));
+
+ // Set scale to (1.5, 0.5).
+ EXPECT_TRUE(channel1_->SetOutputScaling(0, 1.5, 0.5));
+ EXPECT_TRUE(media_channel1_->GetOutputScaling(0, &left, &right));
+ EXPECT_DOUBLE_EQ(1.5, left);
+ EXPECT_DOUBLE_EQ(0.5, right);
+
+ // Set scale to (0, 0).
+ EXPECT_TRUE(channel1_->SetOutputScaling(0, 0.0, 0.0));
+ EXPECT_TRUE(media_channel1_->GetOutputScaling(0, &left, &right));
+ EXPECT_DOUBLE_EQ(0.0, left);
+ EXPECT_DOUBLE_EQ(0.0, right);
+}
+
+// Test that we can scale the output volume properly for multiway calls.
+TEST_F(VoiceChannelTest, TestScaleVolumeMultiwayCall) {
+ CreateChannels(RTCP, RTCP);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+ EXPECT_TRUE(AddStream1(1));
+ EXPECT_TRUE(AddStream1(2));
+
+ double left, right;
+ // Default is (1.0, 1.0).
+ EXPECT_TRUE(media_channel1_->GetOutputScaling(0, &left, &right));
+ EXPECT_DOUBLE_EQ(1.0, left);
+ EXPECT_DOUBLE_EQ(1.0, right);
+ EXPECT_TRUE(media_channel1_->GetOutputScaling(1, &left, &right));
+ EXPECT_DOUBLE_EQ(1.0, left);
+ EXPECT_DOUBLE_EQ(1.0, right);
+ EXPECT_TRUE(media_channel1_->GetOutputScaling(2, &left, &right));
+ EXPECT_DOUBLE_EQ(1.0, left);
+ EXPECT_DOUBLE_EQ(1.0, right);
+ // invalid ssrc.
+ EXPECT_FALSE(media_channel1_->GetOutputScaling(3, &left, &right));
+
+ // Set scale to (1.5, 0.5) for ssrc = 1.
+ EXPECT_TRUE(channel1_->SetOutputScaling(1, 1.5, 0.5));
+ EXPECT_TRUE(media_channel1_->GetOutputScaling(1, &left, &right));
+ EXPECT_DOUBLE_EQ(1.5, left);
+ EXPECT_DOUBLE_EQ(0.5, right);
+ EXPECT_TRUE(media_channel1_->GetOutputScaling(2, &left, &right));
+ EXPECT_DOUBLE_EQ(1.0, left);
+ EXPECT_DOUBLE_EQ(1.0, right);
+ EXPECT_TRUE(media_channel1_->GetOutputScaling(0, &left, &right));
+ EXPECT_DOUBLE_EQ(1.0, left);
+ EXPECT_DOUBLE_EQ(1.0, right);
+
+ // Set scale to (0, 0) for all ssrcs.
+ EXPECT_TRUE(channel1_->SetOutputScaling(0, 0.0, 0.0));
+ EXPECT_TRUE(media_channel1_->GetOutputScaling(0, &left, &right));
+ EXPECT_DOUBLE_EQ(0.0, left);
+ EXPECT_DOUBLE_EQ(0.0, right);
+ EXPECT_TRUE(media_channel1_->GetOutputScaling(1, &left, &right));
+ EXPECT_DOUBLE_EQ(0.0, left);
+ EXPECT_DOUBLE_EQ(0.0, right);
+ EXPECT_TRUE(media_channel1_->GetOutputScaling(2, &left, &right));
+ EXPECT_DOUBLE_EQ(0.0, left);
+ EXPECT_DOUBLE_EQ(0.0, right);
+}
+
+TEST_F(VoiceChannelTest, SendSsrcMuxToSsrcMux) {
+ Base::SendSsrcMuxToSsrcMux();
+}
+
+TEST_F(VoiceChannelTest, SendSsrcMuxToSsrcMuxWithRtcpMux) {
+ Base::SendSsrcMuxToSsrcMuxWithRtcpMux();
+}
+
+// VideoChannelTest
+TEST_F(VideoChannelTest, TestInit) {
+ Base::TestInit();
+}
+
+TEST_F(VideoChannelTest, TestSetContents) {
+ Base::TestSetContents();
+}
+
+TEST_F(VideoChannelTest, TestSetContentsNullOffer) {
+ Base::TestSetContentsNullOffer();
+}
+
+TEST_F(VideoChannelTest, TestSetContentsRtcpMux) {
+ Base::TestSetContentsRtcpMux();
+}
+
+TEST_F(VideoChannelTest, TestSetRemoteContentUpdate) {
+ Base::TestSetRemoteContentUpdate();
+}
+
+TEST_F(VideoChannelTest, TestStreams) {
+ Base::TestStreams();
+}
+
+TEST_F(VideoChannelTest, TestUpdateStreamsInLocalContent) {
+ Base::TestUpdateStreamsInLocalContent();
+}
+
+TEST_F(VideoChannelTest, TestUpdateRemoteStreamsInContent) {
+ Base::TestUpdateStreamsInRemoteContent();
+}
+
+TEST_F(VideoChannelTest, TestChangeStreamParamsInContent) {
+ Base::TestChangeStreamParamsInContent();
+}
+
+TEST_F(VideoChannelTest, TestPlayoutAndSendingStates) {
+ Base::TestPlayoutAndSendingStates();
+}
+
+TEST_F(VideoChannelTest, TestCallSetup) {
+ Base::TestCallSetup();
+}
+
+TEST_F(VideoChannelTest, TestCallTeardownRtcpMux) {
+ Base::TestCallTeardownRtcpMux();
+}
+
+TEST_F(VideoChannelTest, SendRtpToRtp) {
+ Base::SendRtpToRtp();
+}
+
+TEST_F(VideoChannelTest, SendNoRtcpToNoRtcp) {
+ Base::SendNoRtcpToNoRtcp();
+}
+
+TEST_F(VideoChannelTest, SendNoRtcpToRtcp) {
+ Base::SendNoRtcpToRtcp();
+}
+
+TEST_F(VideoChannelTest, SendRtcpToNoRtcp) {
+ Base::SendRtcpToNoRtcp();
+}
+
+TEST_F(VideoChannelTest, SendRtcpToRtcp) {
+ Base::SendRtcpToRtcp();
+}
+
+TEST_F(VideoChannelTest, SendRtcpMuxToRtcp) {
+ Base::SendRtcpMuxToRtcp();
+}
+
+TEST_F(VideoChannelTest, SendRtcpMuxToRtcpMux) {
+ Base::SendRtcpMuxToRtcpMux();
+}
+
+TEST_F(VideoChannelTest, SendEarlyRtcpMuxToRtcp) {
+ Base::SendEarlyRtcpMuxToRtcp();
+}
+
+TEST_F(VideoChannelTest, SendEarlyRtcpMuxToRtcpMux) {
+ Base::SendEarlyRtcpMuxToRtcpMux();
+}
+
+TEST_F(VideoChannelTest, SendSrtpToSrtp) {
+ Base::SendSrtpToSrtp();
+}
+
+TEST_F(VideoChannelTest, SendSrtpToRtp) {
+ Base::SendSrtpToSrtp();
+}
+
+TEST_F(VideoChannelTest, SendSrtcpMux) {
+ Base::SendSrtcpMux();
+}
+
+TEST_F(VideoChannelTest, SendRtpToRtpOnThread) {
+ Base::SendRtpToRtpOnThread();
+}
+
+TEST_F(VideoChannelTest, SendSrtpToSrtpOnThread) {
+ Base::SendSrtpToSrtpOnThread();
+}
+
+TEST_F(VideoChannelTest, SendWithWritabilityLoss) {
+ Base::SendWithWritabilityLoss();
+}
+
+TEST_F(VideoChannelTest, TestMediaMonitor) {
+ Base::TestMediaMonitor();
+}
+
+TEST_F(VideoChannelTest, TestMediaSinks) {
+ Base::TestMediaSinks();
+}
+
+TEST_F(VideoChannelTest, TestSetContentFailure) {
+ Base::TestSetContentFailure();
+}
+
+TEST_F(VideoChannelTest, TestFlushRtcp) {
+ Base::TestFlushRtcp();
+}
+
+TEST_F(VideoChannelTest, SendSsrcMuxToSsrcMux) {
+ Base::SendSsrcMuxToSsrcMux();
+}
+
+TEST_F(VideoChannelTest, SendSsrcMuxToSsrcMuxWithRtcpMux) {
+ Base::SendSsrcMuxToSsrcMuxWithRtcpMux();
+}
+
+// TODO: Add VideoChannelTest.TestChangeStateError.
+
+TEST_F(VideoChannelTest, TestSrtpError) {
+ Base::TestSrtpError();
+}
+
+TEST_F(VideoChannelTest, TestApplyViewRequest) {
+ CreateChannels(0, 0);
+ EXPECT_TRUE(SendInitiate());
+ EXPECT_TRUE(SendAccept());
+
+ cricket::VideoFormat send_format;
+ EXPECT_TRUE(media_channel1_->GetSendStreamFormat(kSsrc1, &send_format));
+ EXPECT_EQ(640, send_format.width);
+ EXPECT_EQ(400, send_format.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), send_format.interval);
+
+ cricket::ViewRequest request;
+ request.static_video_views.push_back(
+ cricket::StaticVideoView(kSsrc1, 320, 200, 15));
+ EXPECT_TRUE(channel1_->ApplyViewRequest(request));
+ EXPECT_TRUE(media_channel1_->GetSendStreamFormat(kSsrc1, &send_format));
+ EXPECT_EQ(320, send_format.width);
+ EXPECT_EQ(200, send_format.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(15), send_format.interval);
+
+ // Short term hack for view request with SSRC 0. TODO: Remove this
+ // once Reflector uses the correct SSRC in view request (b/5977302).
+ request.static_video_views.clear();
+ request.static_video_views.push_back(
+ cricket::StaticVideoView(0, 160, 100, 8));
+ EXPECT_TRUE(channel1_->ApplyViewRequest(request));
+ EXPECT_TRUE(media_channel1_->GetSendStreamFormat(kSsrc1, &send_format));
+ EXPECT_EQ(160, send_format.width);
+ EXPECT_EQ(100, send_format.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(8), send_format.interval);
+
+ request.static_video_views.clear();
+ EXPECT_TRUE(channel1_->ApplyViewRequest(request));
+ EXPECT_TRUE(media_channel1_->GetSendStreamFormat(kSsrc1, &send_format));
+ EXPECT_EQ(0, send_format.width);
+ EXPECT_EQ(0, send_format.height);
+}
diff --git a/talk/session/phone/channelmanager.cc b/talk/session/phone/channelmanager.cc
index 8f8a0fc..7cca61a 100644
--- a/talk/session/phone/channelmanager.cc
+++ b/talk/session/phone/channelmanager.cc
@@ -59,8 +59,16 @@
MSG_DESTROYSOUNDCLIP = 18,
MSG_CAMERASTARTED = 19,
MSG_SETVIDEOCAPTURE = 20,
+ MSG_TERMINATE = 21,
+ MSG_REGISTERVIDEOPROCESSOR = 22,
+ MSG_UNREGISTERVIDEOPROCESSOR = 23,
+ MSG_REGISTERVOICEPROCESSOR = 24,
+ MSG_UNREGISTERVOICEPROCESSOR = 25,
+ MSG_SETVIDEOCAPTURER = 26,
};
+static const int kNotSetOutputVolume = -1;
+
struct CreationParams : public talk_base::MessageData {
CreationParams(BaseSession* session, const std::string& content_name,
bool rtcp, VoiceChannel* voice_channel)
@@ -117,6 +125,16 @@
bool result;
};
+struct Capturer : public talk_base::MessageData {
+ Capturer(VideoCapturer* c, uint32 s)
+ : capturer(c),
+ ssrc(s),
+ result(false) {}
+ VideoCapturer* capturer;
+ uint32 ssrc;
+ bool result;
+};
+
struct LoggingOptions : public talk_base::MessageData {
explicit LoggingOptions(int lev, const char* f) : level(lev), filter(f) {}
int level;
@@ -125,11 +143,27 @@
struct CaptureParams : public talk_base::MessageData {
explicit CaptureParams(bool c) : capture(c), result(CR_FAILURE) {}
-
bool capture;
CaptureResult result;
};
+struct VideoProcessorParams : public talk_base::MessageData {
+ VideoProcessorParams(uint32 s, VideoProcessor* p)
+ : ssrc(s), processor(p), result(false) {}
+ uint32 ssrc;
+ VideoProcessor* processor;
+ bool result;
+};
+
+struct VoiceProcessorParams : public talk_base::MessageData {
+ VoiceProcessorParams(uint32 c, VoiceProcessor* p, MediaProcessorDirection d)
+ : ssrc(c), direction(d), processor(p), result(false) {}
+ uint32 ssrc;
+ MediaProcessorDirection direction;
+ VoiceProcessor* processor;
+ bool result;
+};
+
ChannelManager::ChannelManager(talk_base::Thread* worker_thread)
: media_engine_(MediaEngineFactory::Create()),
device_manager_(cricket::DeviceManagerFactory::Create()),
@@ -139,6 +173,7 @@
audio_in_device_(DeviceManagerInterface::kDefaultDeviceName),
audio_out_device_(DeviceManagerInterface::kDefaultDeviceName),
audio_options_(MediaEngineInterface::DEFAULT_AUDIO_OPTIONS),
+ audio_output_volume_(kNotSetOutputVolume),
local_renderer_(NULL),
capturing_(false),
monitoring_(false) {
@@ -156,6 +191,7 @@
audio_in_device_(DeviceManagerInterface::kDefaultDeviceName),
audio_out_device_(DeviceManagerInterface::kDefaultDeviceName),
audio_options_(MediaEngineInterface::DEFAULT_AUDIO_OPTIONS),
+ audio_output_volume_(kNotSetOutputVolume),
local_renderer_(NULL),
capturing_(false),
monitoring_(false) {
@@ -166,8 +202,6 @@
// Init the device manager immediately, and set up our default video device.
SignalDevicesChange.repeat(device_manager_->SignalDevicesChange);
device_manager_->Init();
- // Set camera_device_ to the name of the default video capturer.
- SetVideoOptions(DeviceManagerInterface::kDefaultDeviceName);
// Camera is started asynchronously, request callbacks when startup
// completes to be able to forward them to the rendering manager.
@@ -250,6 +284,14 @@
<< " speaker: " << audio_out_device_
<< " options: " << audio_options_;
}
+
+ // If audio_output_volume_ has been set via SetOutputVolume(), set the
+ // audio output volume of the engine.
+ if (kNotSetOutputVolume != audio_output_volume_ &&
+ !SetOutputVolume(audio_output_volume_)) {
+ LOG(LS_WARNING) << "Failed to SetOutputVolume to "
+ << audio_output_volume_;
+ }
if (!SetVideoOptions(camera_device_) && !camera_device_.empty()) {
LOG(LS_WARNING) << "Failed to SetVideoOptions with camera: "
<< camera_device_;
@@ -278,8 +320,14 @@
if (!initialized_) {
return;
}
+ Send(MSG_TERMINATE, NULL);
+ media_engine_->Terminate();
+ initialized_ = false;
+}
- // Need to destroy the voice/video channels
+void ChannelManager::Terminate_w() {
+ ASSERT(worker_thread_ == talk_base::Thread::Current());
+ // Need to destroy the voice/video channels
while (!video_channels_.empty()) {
DestroyVideoChannel_w(video_channels_.back());
}
@@ -289,9 +337,6 @@
while (!soundclips_.empty()) {
DestroySoundclip_w(soundclips_.back());
}
-
- media_engine_->Terminate();
- initialized_ = false;
}
VoiceChannel* ChannelManager::CreateVoiceChannel(
@@ -302,8 +347,6 @@
VoiceChannel* ChannelManager::CreateVoiceChannel_w(
BaseSession* session, const std::string& content_name, bool rtcp) {
- talk_base::CritScope cs(&crit_);
-
// This is ok to alloc from a thread other than the worker thread
ASSERT(initialized_);
VoiceMediaChannel* media_channel = media_engine_->CreateChannel();
@@ -329,7 +372,6 @@
}
void ChannelManager::DestroyVoiceChannel_w(VoiceChannel* voice_channel) {
- talk_base::CritScope cs(&crit_);
// Destroy voice channel.
ASSERT(initialized_);
VoiceChannels::iterator it = std::find(voice_channels_.begin(),
@@ -352,8 +394,6 @@
VideoChannel* ChannelManager::CreateVideoChannel_w(
BaseSession* session, const std::string& content_name, bool rtcp,
VoiceChannel* voice_channel) {
- talk_base::CritScope cs(&crit_);
-
// This is ok to alloc from a thread other than the worker thread
ASSERT(initialized_);
VideoMediaChannel* media_channel =
@@ -382,7 +422,6 @@
}
void ChannelManager::DestroyVideoChannel_w(VideoChannel *video_channel) {
- talk_base::CritScope cs(&crit_);
// Destroy voice channel.
ASSERT(initialized_);
VideoChannels::iterator it = std::find(video_channels_.begin(),
@@ -402,8 +441,6 @@
}
Soundclip* ChannelManager::CreateSoundclip_w() {
- talk_base::CritScope cs(&crit_);
-
ASSERT(initialized_);
ASSERT(worker_thread_ == talk_base::Thread::Current());
@@ -425,7 +462,6 @@
}
void ChannelManager::DestroySoundclip_w(Soundclip* soundclip) {
- talk_base::CritScope cs(&crit_);
// Destroy soundclip.
ASSERT(initialized_);
Soundclips::iterator it = std::find(soundclips_.begin(),
@@ -485,7 +521,6 @@
// Set the audio devices
if (ret) {
- talk_base::CritScope cs(&crit_);
ret = media_engine_->SetSoundDevices(in_dev, out_dev);
}
@@ -509,8 +544,17 @@
}
bool ChannelManager::SetOutputVolume(int level) {
- VolumeLevel volume(level);
- return (Send(MSG_SETOUTPUTVOLUME, &volume) && volume.result);
+ bool ret = level >= 0 && level <= 255;
+ if (initialized_) {
+ VolumeLevel volume(level);
+ ret &= Send(MSG_SETOUTPUTVOLUME, &volume) && volume.result;
+ }
+
+ if (ret) {
+ audio_output_volume_ = level;
+ }
+
+ return ret;
}
bool ChannelManager::SetOutputVolume_w(int level) {
@@ -520,22 +564,33 @@
}
bool ChannelManager::GetVideoOptions(std::string* cam_name) {
+ if (camera_device_.empty()) {
+ // Initialize camera_device_ with default.
+ Device device;
+ if (!device_manager_->GetVideoCaptureDevice(
+ DeviceManagerInterface::kDefaultDeviceName, &device)) {
+ LOG(LS_WARNING) << "Device manager can't find default camera: " <<
+ DeviceManagerInterface::kDefaultDeviceName;
+ return false;
+ }
+ camera_device_ = device.name;
+ }
*cam_name = camera_device_;
return true;
}
bool ChannelManager::SetVideoOptions(const std::string& cam_name) {
Device device;
+ bool ret = true;
if (!device_manager_->GetVideoCaptureDevice(cam_name, &device)) {
if (!cam_name.empty()) {
LOG(LS_WARNING) << "Device manager can't find camera: " << cam_name;
}
- return false;
+ ret = false;
}
// If we're running, tell the media engine about it.
- bool ret = true;
- if (initialized_) {
+ if (initialized_ && ret) {
VideoOptions options(&device);
ret = (Send(MSG_SETVIDEOOPTIONS, &options) && options.result);
}
@@ -543,7 +598,18 @@
// If everything worked, retain the name of the selected camera.
if (ret) {
camera_device_ = device.name;
+ } else if (camera_device_.empty()) {
+ // When video option setting fails, we still want camera_device_ to be in a
+ // good state, so we initialize it with default if it's empty.
+ Device default_device;
+ if (!device_manager_->GetVideoCaptureDevice(
+ DeviceManagerInterface::kDefaultDeviceName, &default_device)) {
+ LOG(LS_WARNING) << "Device manager can't find default camera: " <<
+ DeviceManagerInterface::kDefaultDeviceName;
+ }
+ camera_device_ = default_device.name;
}
+
return ret;
}
@@ -607,6 +673,21 @@
return media_engine_->SetLocalRenderer(renderer);
}
+bool ChannelManager::SetVideoCapturer(VideoCapturer* capturer, uint32 ssrc) {
+ bool ret = true;
+ if (initialized_) {
+ Capturer capture(capturer, ssrc);
+ ret = (Send(MSG_SETVIDEOCAPTURER, &capture) && capture.result);
+ }
+ return ret;
+}
+
+bool ChannelManager::SetVideoCapturer_w(VideoCapturer* capturer, uint32 ssrc) {
+ ASSERT(worker_thread_ == talk_base::Thread::Current());
+ ASSERT(initialized_);
+ return media_engine_->SetVideoCapturer(capturer, ssrc);
+}
+
CaptureResult ChannelManager::SetVideoCapture(bool capture) {
bool ret;
CaptureParams capture_params(capture);
@@ -655,6 +736,62 @@
}
}
+// TODO: For now pass this request through the mediaengine to the
+// voice and video engines to do the real work. Once the capturer refactoring
+// is done, we will access the capturer using the ssrc (similar to how the
+// renderer is accessed today) and register with it directly.
+bool ChannelManager::RegisterVideoProcessor(uint32 ssrc,
+ VideoProcessor* processor) {
+ VideoProcessorParams processor_params(ssrc, processor);
+ return (Send(MSG_REGISTERVIDEOPROCESSOR, &processor_params) &&
+ processor_params.result);
+}
+bool ChannelManager::RegisterVideoProcessor_w(uint32 ssrc,
+ VideoProcessor* processor) {
+ return media_engine_->RegisterVideoProcessor(processor);
+}
+
+bool ChannelManager::UnregisterVideoProcessor(uint32 ssrc,
+ VideoProcessor* processor) {
+ VideoProcessorParams processor_params(ssrc, processor);
+ return (Send(MSG_UNREGISTERVIDEOPROCESSOR, &processor_params) &&
+ processor_params.result);
+}
+bool ChannelManager::UnregisterVideoProcessor_w(uint32 ssrc,
+ VideoProcessor* processor) {
+ return media_engine_->UnregisterVideoProcessor(processor);
+}
+
+bool ChannelManager::RegisterVoiceProcessor(
+ uint32 ssrc,
+ VoiceProcessor* processor,
+ MediaProcessorDirection direction) {
+ VoiceProcessorParams processor_params(ssrc, processor, direction);
+ return (Send(MSG_REGISTERVOICEPROCESSOR, &processor_params) &&
+ processor_params.result);
+}
+bool ChannelManager::RegisterVoiceProcessor_w(
+ uint32 ssrc,
+ VoiceProcessor* processor,
+ MediaProcessorDirection direction) {
+ return media_engine_->RegisterVoiceProcessor(ssrc, processor, direction);
+}
+
+bool ChannelManager::UnregisterVoiceProcessor(
+ uint32 ssrc,
+ VoiceProcessor* processor,
+ MediaProcessorDirection direction) {
+ VoiceProcessorParams processor_params(ssrc, processor, direction);
+ return (Send(MSG_UNREGISTERVOICEPROCESSOR, &processor_params) &&
+ processor_params.result);
+}
+bool ChannelManager::UnregisterVoiceProcessor_w(
+ uint32 ssrc,
+ VoiceProcessor* processor,
+ MediaProcessorDirection direction) {
+ return media_engine_->UnregisterVoiceProcessor(ssrc, processor, direction);
+}
+
bool ChannelManager::Send(uint32 id, talk_base::MessageData* data) {
if (!worker_thread_ || !initialized_) return false;
worker_thread_->Send(this, id, data);
@@ -746,6 +883,11 @@
p->result = SetLocalRenderer_w(p->renderer);
break;
}
+ case MSG_SETVIDEOCAPTURER: {
+ Capturer* p = static_cast<Capturer*>(data);
+ p->result = SetVideoCapturer_w(p->capturer, p->ssrc);
+ break;
+ }
case MSG_SETVIDEOCAPTURE: {
CaptureParams* p = static_cast<CaptureParams*>(data);
p->result = SetVideoCapture_w(p->capture);
@@ -766,6 +908,38 @@
delete data;
break;
}
+ case MSG_TERMINATE: {
+ Terminate_w();
+ break;
+ }
+ case MSG_REGISTERVIDEOPROCESSOR: {
+ VideoProcessorParams* data =
+ static_cast<VideoProcessorParams*>(message->pdata);
+ data->result = RegisterVideoProcessor_w(data->ssrc, data->processor);
+ break;
+ }
+ case MSG_UNREGISTERVIDEOPROCESSOR: {
+ VideoProcessorParams* data =
+ static_cast<VideoProcessorParams*>(message->pdata);
+ data->result = UnregisterVideoProcessor_w(data->ssrc, data->processor);
+ break;
+ }
+ case MSG_REGISTERVOICEPROCESSOR: {
+ VoiceProcessorParams* data =
+ static_cast<VoiceProcessorParams*>(message->pdata);
+ data->result = RegisterVoiceProcessor_w(data->ssrc,
+ data->processor,
+ data->direction);
+ break;
+ }
+ case MSG_UNREGISTERVOICEPROCESSOR: {
+ VoiceProcessorParams* data =
+ static_cast<VoiceProcessorParams*>(message->pdata);
+ data->result = UnregisterVoiceProcessor_w(data->ssrc,
+ data->processor,
+ data->direction);
+ break;
+ }
}
}
diff --git a/talk/session/phone/channelmanager.h b/talk/session/phone/channelmanager.h
index c574a43..9d100ee 100644
--- a/talk/session/phone/channelmanager.h
+++ b/talk/session/phone/channelmanager.h
@@ -41,7 +41,9 @@
namespace cricket {
class Soundclip;
+class VideoProcessor;
class VoiceChannel;
+class VoiceProcessor;
// ChannelManager allows the MediaEngine to run on a separate thread, and takes
// care of marshalling calls between threads. It also creates and keeps track of
@@ -83,10 +85,6 @@
bool initialized() const { return initialized_; }
// Starts up the media engine.
bool Init();
- // TODO: Remove this temporary API once Flute is updated.
- bool Init(talk_base::Thread* thread) {
- return set_worker_thread(thread) && Init();
- }
// Shuts down the media engine.
void Terminate();
@@ -132,6 +130,9 @@
bool monitoring() const { return monitoring_; }
// Sets the local renderer where to renderer the local camera.
bool SetLocalRenderer(VideoRenderer* renderer);
+ // Sets the externally provided video capturer. The ssrc is the ssrc of the
+ // (video) stream for which the video capturer should be set.
+ bool SetVideoCapturer(VideoCapturer* capturer, uint32 ssrc);
// Starts and stops the local camera and renders it to the local renderer.
CaptureResult SetVideoCapture(bool capture);
bool capturing() const { return capturing_; }
@@ -140,6 +141,21 @@
void SetVoiceLogging(int level, const char* filter);
void SetVideoLogging(int level, const char* filter);
+ // The channel manager handles the Tx side for Video processing,
+ // as well as Tx and Rx side for Voice processing.
+ // (The Rx Video processing will go throug the simplerenderingmanager,
+ // to be implemented).
+ bool RegisterVideoProcessor(uint32 ssrc,
+ VideoProcessor* processor);
+ bool UnregisterVideoProcessor(uint32 ssrc,
+ VideoProcessor* processor);
+ bool RegisterVoiceProcessor(uint32 ssrc,
+ VoiceProcessor* processor,
+ MediaProcessorDirection direction);
+ bool UnregisterVoiceProcessor(uint32 ssrc,
+ VoiceProcessor* processor,
+ MediaProcessorDirection direction);
+
// The operations below occur on the main thread.
bool GetAudioInputDevices(std::vector<std::string>* names);
@@ -155,6 +171,7 @@
void Construct();
bool Send(uint32 id, talk_base::MessageData* pdata);
+ void Terminate_w();
VoiceChannel* CreateVoiceChannel_w(
BaseSession* session, const std::string& content_name, bool rtcp);
void DestroyVoiceChannel_w(VoiceChannel* voice_channel);
@@ -172,14 +189,25 @@
bool SetVideoOptions_w(const Device* cam_device);
bool SetDefaultVideoEncoderConfig_w(const VideoEncoderConfig& config);
bool SetLocalRenderer_w(VideoRenderer* renderer);
+ bool SetVideoCapturer_w(VideoCapturer* capturer, uint32 ssrc);
CaptureResult SetVideoCapture_w(bool capture);
void SetMediaLogging(bool video, int level, const char* filter);
void SetMediaLogging_w(bool video, int level, const char* filter);
void OnVideoCaptureResult(VideoCapturer* capturer,
CaptureResult result);
+ bool RegisterVideoProcessor_w(uint32 ssrc,
+ VideoProcessor* processor);
+ bool UnregisterVideoProcessor_w(uint32 ssrc,
+ VideoProcessor* processor);
+ bool RegisterVoiceProcessor_w(uint32 ssrc,
+ VoiceProcessor* processor,
+ MediaProcessorDirection direction);
+ bool UnregisterVoiceProcessor_w(uint32 ssrc,
+ VoiceProcessor* processor,
+ MediaProcessorDirection direction);
+
void OnMessage(talk_base::Message *message);
- talk_base::CriticalSection crit_;
talk_base::scoped_ptr<MediaEngineInterface> media_engine_;
talk_base::scoped_ptr<DeviceManagerInterface> device_manager_;
bool initialized_;
@@ -193,6 +221,7 @@
std::string audio_in_device_;
std::string audio_out_device_;
int audio_options_;
+ int audio_output_volume_;
std::string camera_device_;
VideoEncoderConfig default_video_encoder_config_;
VideoRenderer* local_renderer_;
diff --git a/talk/session/phone/channelmanager_unittest.cc b/talk/session/phone/channelmanager_unittest.cc
new file mode 100644
index 0000000..0c132ac
--- /dev/null
+++ b/talk/session/phone/channelmanager_unittest.cc
@@ -0,0 +1,523 @@
+// libjingle
+// Copyright 2008 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/base/gunit.h"
+#include "talk/base/logging.h"
+#include "talk/base/thread.h"
+#include "talk/p2p/base/fakesession.h"
+#include "talk/session/phone/channelmanager.h"
+#include "talk/session/phone/fakedevicemanager.h"
+#include "talk/session/phone/fakemediaengine.h"
+#include "talk/session/phone/fakemediaprocessor.h"
+#include "talk/session/phone/nullvideorenderer.h"
+
+class ChannelManagerTest : public testing::Test {
+ protected:
+ ChannelManagerTest() : fme_(NULL), fdm_(NULL), cm_(NULL) {
+ }
+
+ virtual void SetUp() {
+ fme_ = new cricket::FakeMediaEngine();
+ fdm_ = new cricket::FakeDeviceManager();
+ cm_ = new cricket::ChannelManager(fme_, fdm_, talk_base::Thread::Current());
+ session_ = new cricket::FakeSession();
+
+ std::vector<std::string> in_device_list, out_device_list, vid_device_list;
+ in_device_list.push_back("audio-in1");
+ in_device_list.push_back("audio-in2");
+ out_device_list.push_back("audio-out1");
+ out_device_list.push_back("audio-out2");
+ vid_device_list.push_back("video-in1");
+ vid_device_list.push_back("video-in2");
+ fdm_->SetAudioInputDevices(in_device_list);
+ fdm_->SetAudioOutputDevices(out_device_list);
+ fdm_->SetVideoCaptureDevices(vid_device_list);
+ }
+
+ virtual void TearDown() {
+ delete session_;
+ delete cm_;
+ cm_ = NULL;
+ fdm_ = NULL;
+ fme_ = NULL;
+ }
+
+ talk_base::Thread worker_;
+ cricket::FakeMediaEngine* fme_;
+ cricket::FakeDeviceManager* fdm_;
+ cricket::ChannelManager* cm_;
+ cricket::FakeSession* session_;
+};
+
+// Test that we startup/shutdown properly.
+TEST_F(ChannelManagerTest, StartupShutdown) {
+ EXPECT_FALSE(cm_->initialized());
+ EXPECT_EQ(talk_base::Thread::Current(), cm_->worker_thread());
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_TRUE(cm_->initialized());
+ cm_->Terminate();
+ EXPECT_FALSE(cm_->initialized());
+}
+
+// Test that we startup/shutdown properly with a worker thread.
+TEST_F(ChannelManagerTest, StartupShutdownOnThread) {
+ worker_.Start();
+ EXPECT_FALSE(cm_->initialized());
+ EXPECT_EQ(talk_base::Thread::Current(), cm_->worker_thread());
+ EXPECT_TRUE(cm_->set_worker_thread(&worker_));
+ EXPECT_EQ(&worker_, cm_->worker_thread());
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_TRUE(cm_->initialized());
+ // Setting the worker thread while initialized should fail.
+ EXPECT_FALSE(cm_->set_worker_thread(talk_base::Thread::Current()));
+ cm_->Terminate();
+ EXPECT_FALSE(cm_->initialized());
+}
+
+// Test that we fail to startup if we're given an unstarted thread.
+TEST_F(ChannelManagerTest, StartupShutdownOnUnstartedThread) {
+ EXPECT_TRUE(cm_->set_worker_thread(&worker_));
+ EXPECT_FALSE(cm_->Init());
+ EXPECT_FALSE(cm_->initialized());
+}
+
+// Test that we can create and destroy a voice and video channel.
+TEST_F(ChannelManagerTest, CreateDestroyChannels) {
+ EXPECT_TRUE(cm_->Init());
+ cricket::VoiceChannel* voice_channel = cm_->CreateVoiceChannel(
+ session_, cricket::CN_AUDIO, false);
+ EXPECT_TRUE(voice_channel != NULL);
+ cricket::VideoChannel* video_channel =
+ cm_->CreateVideoChannel(session_, cricket::CN_VIDEO,
+ false, voice_channel);
+ EXPECT_TRUE(video_channel != NULL);
+ cm_->DestroyVideoChannel(video_channel);
+ cm_->DestroyVoiceChannel(voice_channel);
+ cm_->Terminate();
+}
+
+// Test that we can create and destroy a voice and video channel with a worker.
+TEST_F(ChannelManagerTest, CreateDestroyChannelsOnThread) {
+ worker_.Start();
+ EXPECT_TRUE(cm_->set_worker_thread(&worker_));
+ EXPECT_TRUE(cm_->Init());
+ cricket::VoiceChannel* voice_channel = cm_->CreateVoiceChannel(
+ session_, cricket::CN_AUDIO, false);
+ EXPECT_TRUE(voice_channel != NULL);
+ cricket::VideoChannel* video_channel =
+ cm_->CreateVideoChannel(session_, cricket::CN_VIDEO,
+ false, voice_channel);
+ EXPECT_TRUE(video_channel != NULL);
+ cm_->DestroyVideoChannel(video_channel);
+ cm_->DestroyVoiceChannel(voice_channel);
+ cm_->Terminate();
+}
+
+// Test that we fail to create a voice/video channel if the session is unable
+// to create a cricket::TransportChannel
+TEST_F(ChannelManagerTest, NoTransportChannelTest) {
+ EXPECT_TRUE(cm_->Init());
+ session_->set_fail_channel_creation(true);
+ // The test is useless unless the session does not fail creating
+ // cricket::TransportChannel.
+ ASSERT_TRUE(session_->CreateChannel("audio", "rtp") == NULL);
+
+ cricket::VoiceChannel* voice_channel = cm_->CreateVoiceChannel(
+ session_, cricket::CN_AUDIO, false);
+ EXPECT_TRUE(voice_channel == NULL);
+ cricket::VideoChannel* video_channel =
+ cm_->CreateVideoChannel(session_, cricket::CN_VIDEO,
+ false, voice_channel);
+ EXPECT_TRUE(video_channel == NULL);
+ cm_->Terminate();
+}
+
+// Test that SetDefaultVideoCodec passes through the right values.
+TEST_F(ChannelManagerTest, SetDefaultVideoEncoderConfig) {
+ cricket::VideoCodec codec(96, "G264", 1280, 720, 60, 0);
+ cricket::VideoEncoderConfig config(codec, 1, 2);
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_TRUE(cm_->SetDefaultVideoEncoderConfig(config));
+ EXPECT_EQ(config, fme_->default_video_encoder_config());
+}
+
+// Test that SetDefaultVideoCodec passes through the right values.
+TEST_F(ChannelManagerTest, SetDefaultVideoCodecBeforeInit) {
+ cricket::VideoCodec codec(96, "G264", 1280, 720, 60, 0);
+ cricket::VideoEncoderConfig config(codec, 1, 2);
+ EXPECT_TRUE(cm_->SetDefaultVideoEncoderConfig(config));
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_EQ(config, fme_->default_video_encoder_config());
+}
+
+TEST_F(ChannelManagerTest, SetAudioOptionsBeforeInit) {
+ // Test that values that we set before Init are applied.
+ EXPECT_TRUE(cm_->SetAudioOptions("audio-in1", "audio-out1", 0x2));
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_EQ("audio-in1", fme_->audio_in_device());
+ EXPECT_EQ("audio-out1", fme_->audio_out_device());
+ EXPECT_EQ(0x2, fme_->audio_options());
+}
+
+TEST_F(ChannelManagerTest, GetAudioOptionsBeforeInit) {
+ std::string audio_in, audio_out;
+ int opts;
+ // Test that GetAudioOptions works before Init.
+ EXPECT_TRUE(cm_->SetAudioOptions("audio-in2", "audio-out2", 0x1));
+ EXPECT_TRUE(cm_->GetAudioOptions(&audio_in, &audio_out, &opts));
+ EXPECT_EQ("audio-in2", audio_in);
+ EXPECT_EQ("audio-out2", audio_out);
+ EXPECT_EQ(0x1, opts);
+ // Test that options set before Init can be gotten after Init.
+ EXPECT_TRUE(cm_->SetAudioOptions("audio-in1", "audio-out1", 0x2));
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_TRUE(cm_->GetAudioOptions(&audio_in, &audio_out, &opts));
+ EXPECT_EQ("audio-in1", audio_in);
+ EXPECT_EQ("audio-out1", audio_out);
+ EXPECT_EQ(0x2, opts);
+}
+
+TEST_F(ChannelManagerTest, SetAudioOptions) {
+ // Test initial state.
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_EQ("", fme_->audio_in_device());
+ EXPECT_EQ("", fme_->audio_out_device());
+ EXPECT_EQ(cricket::MediaEngineInterface::DEFAULT_AUDIO_OPTIONS,
+ fme_->audio_options());
+ // Test setting defaults.
+ EXPECT_TRUE(cm_->SetAudioOptions("", "", 0x3));
+ EXPECT_EQ("", fme_->audio_in_device());
+ EXPECT_EQ("", fme_->audio_out_device());
+ EXPECT_EQ(0x3, fme_->audio_options());
+ // Test setting specific values.
+ EXPECT_TRUE(cm_->SetAudioOptions("audio-in1", "audio-out1", 0x2));
+ EXPECT_EQ("audio-in1", fme_->audio_in_device());
+ EXPECT_EQ("audio-out1", fme_->audio_out_device());
+ EXPECT_EQ(0x2, fme_->audio_options());
+ // Test setting bad values.
+ EXPECT_FALSE(cm_->SetAudioOptions("audio-in9", "audio-out2", 0x1));
+}
+
+TEST_F(ChannelManagerTest, GetAudioOptions) {
+ std::string audio_in, audio_out;
+ int opts;
+ // Test initial state.
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_TRUE(cm_->GetAudioOptions(&audio_in, &audio_out, &opts));
+ EXPECT_EQ(std::string(cricket::DeviceManagerInterface::kDefaultDeviceName),
+ audio_in);
+ EXPECT_EQ(std::string(cricket::DeviceManagerInterface::kDefaultDeviceName),
+ audio_out);
+ EXPECT_EQ(cricket::MediaEngineInterface::DEFAULT_AUDIO_OPTIONS, opts);
+ // Test that we get back specific values that we set.
+ EXPECT_TRUE(cm_->SetAudioOptions("audio-in1", "audio-out1", 0x2));
+ EXPECT_TRUE(cm_->GetAudioOptions(&audio_in, &audio_out, &opts));
+ EXPECT_EQ("audio-in1", audio_in);
+ EXPECT_EQ("audio-out1", audio_out);
+ EXPECT_EQ(0x2, opts);
+}
+
+TEST_F(ChannelManagerTest, SetVideoOptionsBeforeInit) {
+ // Test that values that we set before Init are applied.
+ EXPECT_TRUE(cm_->SetVideoOptions("video-in2"));
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_EQ("video-in2", fme_->video_in_device());
+}
+
+TEST_F(ChannelManagerTest, GetVideoOptionsBeforeInit) {
+ std::string video_in;
+ // Test that GetVideoOptions works before Init.
+ EXPECT_TRUE(cm_->SetVideoOptions("video-in1"));
+ EXPECT_TRUE(cm_->GetVideoOptions(&video_in));
+ EXPECT_EQ("video-in1", video_in);
+ // Test that options set before Init can be gotten after Init.
+ EXPECT_TRUE(cm_->SetVideoOptions("video-in2"));
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_TRUE(cm_->GetVideoOptions(&video_in));
+ EXPECT_EQ("video-in2", video_in);
+}
+
+TEST_F(ChannelManagerTest, SetVideoOptions) {
+ // Test setting defaults.
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_TRUE(cm_->SetVideoOptions("")); // will use DeviceManager default
+ EXPECT_EQ("video-in1", fme_->video_in_device());
+ // Test setting specific values.
+ EXPECT_TRUE(cm_->SetVideoOptions("video-in2"));
+ EXPECT_EQ("video-in2", fme_->video_in_device());
+ // TODO: Add test for invalid value here.
+}
+
+// Test unplugging and plugging back the preferred devices. When the preferred
+// device is unplugged, we fall back to the default device. When the preferred
+// device is plugged back, we use it.
+TEST_F(ChannelManagerTest, SetAudioOptionsUnplugPlug) {
+ // Set preferences "audio-in1" and "audio-out1" before init.
+ EXPECT_TRUE(cm_->SetAudioOptions("audio-in1", "audio-out1", 0x2));
+ // Unplug device "audio-in1" and "audio-out1".
+ std::vector<std::string> in_device_list, out_device_list;
+ in_device_list.push_back("audio-in2");
+ out_device_list.push_back("audio-out2");
+ fdm_->SetAudioInputDevices(in_device_list);
+ fdm_->SetAudioOutputDevices(out_device_list);
+ // Init should fall back to default devices.
+ EXPECT_TRUE(cm_->Init());
+ // The media engine should use the default.
+ EXPECT_EQ("", fme_->audio_in_device());
+ EXPECT_EQ("", fme_->audio_out_device());
+ // The channel manager keeps the preferences "audio-in1" and "audio-out1".
+ std::string audio_in, audio_out;
+ int opts;
+ EXPECT_TRUE(cm_->GetAudioOptions(&audio_in, &audio_out, &opts));
+ EXPECT_EQ("audio-in1", audio_in);
+ EXPECT_EQ("audio-out1", audio_out);
+ cm_->Terminate();
+
+ // Plug devices "audio-in2" and "audio-out2" back.
+ in_device_list.push_back("audio-in1");
+ out_device_list.push_back("audio-out1");
+ fdm_->SetAudioInputDevices(in_device_list);
+ fdm_->SetAudioOutputDevices(out_device_list);
+ // Init again. The preferences, "audio-in2" and "audio-out2", are used.
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_EQ("audio-in1", fme_->audio_in_device());
+ EXPECT_EQ("audio-out1", fme_->audio_out_device());
+ EXPECT_TRUE(cm_->GetAudioOptions(&audio_in, &audio_out, &opts));
+ EXPECT_EQ("audio-in1", audio_in);
+ EXPECT_EQ("audio-out1", audio_out);
+}
+
+// We have one camera. Unplug it, fall back to no camera.
+TEST_F(ChannelManagerTest, SetVideoOptionsUnplugPlugOneCamera) {
+ // Set preferences "video-in1" before init.
+ std::vector<std::string> vid_device_list;
+ vid_device_list.push_back("video-in1");
+ fdm_->SetVideoCaptureDevices(vid_device_list);
+ EXPECT_TRUE(cm_->SetVideoOptions("video-in1"));
+
+ // Unplug "video-in1".
+ vid_device_list.clear();
+ fdm_->SetVideoCaptureDevices(vid_device_list);
+
+ // Init should fall back to avatar.
+ EXPECT_TRUE(cm_->Init());
+ // The media engine should use no camera.
+ EXPECT_EQ("", fme_->video_in_device());
+ // The channel manager keeps the user preference "video-in".
+ std::string video_in;
+ EXPECT_TRUE(cm_->GetVideoOptions(&video_in));
+ EXPECT_EQ("video-in1", video_in);
+ cm_->Terminate();
+
+ // Plug device "video-in1" back.
+ vid_device_list.push_back("video-in1");
+ fdm_->SetVideoCaptureDevices(vid_device_list);
+ // Init again. The user preferred device, "video-in1", is used.
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_EQ("video-in1", fme_->video_in_device());
+ EXPECT_TRUE(cm_->GetVideoOptions(&video_in));
+ EXPECT_EQ("video-in1", video_in);
+}
+
+// We have multiple cameras. Unplug the preferred, fall back to another camera.
+TEST_F(ChannelManagerTest, SetVideoOptionsUnplugPlugTwoDevices) {
+ // Set video device to "video-in1" before init.
+ EXPECT_TRUE(cm_->SetVideoOptions("video-in1"));
+ // Unplug device "video-in1".
+ std::vector<std::string> vid_device_list;
+ vid_device_list.push_back("video-in2");
+ fdm_->SetVideoCaptureDevices(vid_device_list);
+ // Init should fall back to default device "video-in2".
+ EXPECT_TRUE(cm_->Init());
+ // The media engine should use the default device "video-in2".
+ EXPECT_EQ("video-in2", fme_->video_in_device());
+ // The channel manager keeps the user preference "video-in".
+ std::string video_in;
+ EXPECT_TRUE(cm_->GetVideoOptions(&video_in));
+ EXPECT_EQ("video-in1", video_in);
+ cm_->Terminate();
+
+ // Plug device "video-in1" back.
+ vid_device_list.push_back("video-in1");
+ fdm_->SetVideoCaptureDevices(vid_device_list);
+ // Init again. The user preferred device, "video-in1", is used.
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_EQ("video-in1", fme_->video_in_device());
+ EXPECT_TRUE(cm_->GetVideoOptions(&video_in));
+ EXPECT_EQ("video-in1", video_in);
+}
+
+TEST_F(ChannelManagerTest, GetVideoOptions) {
+ std::string video_in;
+ // Test setting/getting defaults.
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_TRUE(cm_->SetVideoOptions(""));
+ EXPECT_TRUE(cm_->GetVideoOptions(&video_in));
+ EXPECT_EQ("video-in1", video_in);
+ // Test setting/getting specific values.
+ EXPECT_TRUE(cm_->SetVideoOptions("video-in2"));
+ EXPECT_TRUE(cm_->GetVideoOptions(&video_in));
+ EXPECT_EQ("video-in2", video_in);
+}
+
+TEST_F(ChannelManagerTest, GetSetOutputVolumeBeforeInit) {
+ int level;
+ // Before init, SetOutputVolume() remembers the volume but does not change the
+ // volume of the engine. GetOutputVolume() should fail.
+ EXPECT_EQ(-1, fme_->output_volume());
+ EXPECT_FALSE(cm_->GetOutputVolume(&level));
+ EXPECT_FALSE(cm_->SetOutputVolume(-1)); // Invalid volume.
+ EXPECT_TRUE(cm_->SetOutputVolume(99));
+ EXPECT_EQ(-1, fme_->output_volume());
+
+ // Init() will apply the remembered volume.
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_TRUE(cm_->GetOutputVolume(&level));
+ EXPECT_EQ(99, level);
+ EXPECT_EQ(level, fme_->output_volume());
+
+ EXPECT_TRUE(cm_->SetOutputVolume(60));
+ EXPECT_TRUE(cm_->GetOutputVolume(&level));
+ EXPECT_EQ(60, level);
+ EXPECT_EQ(level, fme_->output_volume());
+}
+
+TEST_F(ChannelManagerTest, GetSetOutputVolume) {
+ int level;
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_TRUE(cm_->GetOutputVolume(&level));
+ EXPECT_EQ(level, fme_->output_volume());
+
+ EXPECT_FALSE(cm_->SetOutputVolume(-1)); // Invalid volume.
+ EXPECT_TRUE(cm_->SetOutputVolume(60));
+ EXPECT_EQ(60, fme_->output_volume());
+ EXPECT_TRUE(cm_->GetOutputVolume(&level));
+ EXPECT_EQ(60, level);
+}
+
+// Test that a value set before Init is applied properly.
+TEST_F(ChannelManagerTest, SetLocalRendererBeforeInit) {
+ cricket::NullVideoRenderer renderer;
+ EXPECT_TRUE(cm_->SetLocalRenderer(&renderer));
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_EQ(&renderer, fme_->local_renderer());
+}
+
+// Test that a value set after init is passed through properly.
+TEST_F(ChannelManagerTest, SetLocalRenderer) {
+ cricket::NullVideoRenderer renderer;
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_TRUE(cm_->SetLocalRenderer(&renderer));
+ EXPECT_EQ(&renderer, fme_->local_renderer());
+}
+
+// Test that logging options set before Init are applied properly,
+// and retained even after Init.
+TEST_F(ChannelManagerTest, SetLoggingBeforeInit) {
+ cm_->SetVoiceLogging(talk_base::LS_INFO, "test-voice");
+ cm_->SetVideoLogging(talk_base::LS_VERBOSE, "test-video");
+ EXPECT_EQ(talk_base::LS_INFO, fme_->voice_loglevel());
+ EXPECT_STREQ("test-voice", fme_->voice_logfilter().c_str());
+ EXPECT_EQ(talk_base::LS_VERBOSE, fme_->video_loglevel());
+ EXPECT_STREQ("test-video", fme_->video_logfilter().c_str());
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_EQ(talk_base::LS_INFO, fme_->voice_loglevel());
+ EXPECT_STREQ("test-voice", fme_->voice_logfilter().c_str());
+ EXPECT_EQ(talk_base::LS_VERBOSE, fme_->video_loglevel());
+ EXPECT_STREQ("test-video", fme_->video_logfilter().c_str());
+}
+
+// Test that logging options set after Init are applied properly.
+TEST_F(ChannelManagerTest, SetLogging) {
+ EXPECT_TRUE(cm_->Init());
+ cm_->SetVoiceLogging(talk_base::LS_INFO, "test-voice");
+ cm_->SetVideoLogging(talk_base::LS_VERBOSE, "test-video");
+ EXPECT_EQ(talk_base::LS_INFO, fme_->voice_loglevel());
+ EXPECT_STREQ("test-voice", fme_->voice_logfilter().c_str());
+ EXPECT_EQ(talk_base::LS_VERBOSE, fme_->video_loglevel());
+ EXPECT_STREQ("test-video", fme_->video_logfilter().c_str());
+}
+
+// Test that SetVideoCapture passes through the right value.
+TEST_F(ChannelManagerTest, SetVideoCapture) {
+ // Should fail until we are initialized.
+ EXPECT_FALSE(fme_->capture());
+ EXPECT_EQ(cricket::CR_FAILURE, cm_->SetVideoCapture(true));
+ EXPECT_FALSE(fme_->capture());
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_FALSE(fme_->capture());
+ EXPECT_EQ(cricket::CR_SUCCESS, cm_->SetVideoCapture(true));
+ EXPECT_TRUE(fme_->capture());
+ EXPECT_EQ(cricket::CR_SUCCESS, cm_->SetVideoCapture(false));
+ EXPECT_FALSE(fme_->capture());
+}
+
+// Test that the Video/Voice Processors register and unregister
+TEST_F(ChannelManagerTest, RegisterProcessors) {
+ cricket::FakeMediaProcessor fmp;
+ EXPECT_TRUE(cm_->Init());
+ EXPECT_FALSE(fme_->video_processor_registered());
+ EXPECT_FALSE(fme_->voice_processor_registered(cricket::MPD_TX));
+ EXPECT_FALSE(fme_->voice_processor_registered(cricket::MPD_RX));
+
+ EXPECT_TRUE(cm_->RegisterVideoProcessor(1, &fmp));
+ EXPECT_TRUE(fme_->video_processor_registered());
+ EXPECT_FALSE(fme_->voice_processor_registered(cricket::MPD_TX));
+ EXPECT_FALSE(fme_->voice_processor_registered(cricket::MPD_RX));
+
+ EXPECT_TRUE(cm_->UnregisterVideoProcessor(1, &fmp));
+ EXPECT_FALSE(fme_->video_processor_registered());
+ EXPECT_FALSE(fme_->voice_processor_registered(cricket::MPD_TX));
+ EXPECT_FALSE(fme_->voice_processor_registered(cricket::MPD_RX));
+
+ EXPECT_TRUE(cm_->RegisterVoiceProcessor(1,
+ &fmp,
+ cricket::MPD_RX));
+ EXPECT_FALSE(fme_->video_processor_registered());
+ EXPECT_FALSE(fme_->voice_processor_registered(cricket::MPD_TX));
+ EXPECT_TRUE(fme_->voice_processor_registered(cricket::MPD_RX));
+
+
+ EXPECT_TRUE(cm_->UnregisterVoiceProcessor(1,
+ &fmp,
+ cricket::MPD_RX));
+ EXPECT_FALSE(fme_->video_processor_registered());
+ EXPECT_FALSE(fme_->voice_processor_registered(cricket::MPD_TX));
+ EXPECT_FALSE(fme_->voice_processor_registered(cricket::MPD_RX));
+
+ EXPECT_TRUE(cm_->RegisterVoiceProcessor(1,
+ &fmp,
+ cricket::MPD_TX));
+ EXPECT_FALSE(fme_->video_processor_registered());
+ EXPECT_TRUE(fme_->voice_processor_registered(cricket::MPD_TX));
+ EXPECT_FALSE(fme_->voice_processor_registered(cricket::MPD_RX));
+
+ EXPECT_TRUE(cm_->UnregisterVoiceProcessor(1,
+ &fmp,
+ cricket::MPD_TX));
+ EXPECT_FALSE(fme_->video_processor_registered());
+ EXPECT_FALSE(fme_->voice_processor_registered(cricket::MPD_TX));
+ EXPECT_FALSE(fme_->voice_processor_registered(cricket::MPD_RX));
+}
diff --git a/talk/session/phone/codec_unittest.cc b/talk/session/phone/codec_unittest.cc
new file mode 100644
index 0000000..18e1eb6
--- /dev/null
+++ b/talk/session/phone/codec_unittest.cc
@@ -0,0 +1,222 @@
+/*
+ * libjingle
+ * Copyright 2009--2010, 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/base/gunit.h"
+#include "talk/session/phone/codec.h"
+
+using cricket::AudioCodec;
+using cricket::VideoCodec;
+using cricket::VideoEncoderConfig;
+
+class CodecTest : public testing::Test {
+ public:
+ CodecTest() {}
+};
+
+TEST_F(CodecTest, TestAudioCodecOperators) {
+ AudioCodec c0(96, "A", 44100, 20000, 2, 3);
+ AudioCodec c1(95, "A", 44100, 20000, 2, 3);
+ AudioCodec c2(96, "x", 44100, 20000, 2, 3);
+ AudioCodec c3(96, "A", 48000, 20000, 2, 3);
+ AudioCodec c4(96, "A", 44100, 10000, 2, 3);
+ AudioCodec c5(96, "A", 44100, 20000, 1, 3);
+ AudioCodec c6(96, "A", 44100, 20000, 2, 1);
+ EXPECT_TRUE(c0 != c1);
+ EXPECT_TRUE(c0 != c2);
+ EXPECT_TRUE(c0 != c3);
+ EXPECT_TRUE(c0 != c4);
+ EXPECT_TRUE(c0 != c5);
+ EXPECT_TRUE(c0 != c6);
+
+ AudioCodec c7;
+ AudioCodec c8(0, "", 0, 0, 0, 0);
+ AudioCodec c9 = c0;
+ EXPECT_TRUE(c8 == c7);
+ EXPECT_TRUE(c9 != c7);
+ EXPECT_TRUE(c9 == c0);
+
+ AudioCodec c10(c0);
+ AudioCodec c11(c0);
+ AudioCodec c12(c0);
+ AudioCodec c13(c0);
+ c10.params["x"] = "abc";
+ c11.params["x"] = "def";
+ c12.params["y"] = "abc";
+ c13.params["x"] = "abc";
+ EXPECT_TRUE(c10 != c0);
+ EXPECT_TRUE(c11 != c0);
+ EXPECT_TRUE(c11 != c10);
+ EXPECT_TRUE(c12 != c0);
+ EXPECT_TRUE(c12 != c10);
+ EXPECT_TRUE(c12 != c11);
+ EXPECT_TRUE(c13 == c10);
+}
+
+TEST_F(CodecTest, TestAudioCodecMatches) {
+ // Test a codec with a static payload type.
+ AudioCodec c0(95, "A", 44100, 20000, 2, 3);
+ EXPECT_TRUE(c0.Matches(95, ""));
+ EXPECT_FALSE(c0.Matches(96, ""));
+ EXPECT_TRUE(c0.Matches(AudioCodec(95, "", 44100, 20000, 2, 0)));
+ EXPECT_TRUE(c0.Matches(AudioCodec(95, "", 44100, 20000, 0, 0)));
+ EXPECT_TRUE(c0.Matches(AudioCodec(95, "", 44100, 0, 0, 0)));
+ EXPECT_TRUE(c0.Matches(AudioCodec(95, "", 0, 0, 0, 0)));
+ EXPECT_FALSE(c0.Matches(AudioCodec(96, "", 44100, 20000, 2, 0)));
+ EXPECT_FALSE(c0.Matches(AudioCodec(95, "", 55100, 20000, 2, 0)));
+ EXPECT_FALSE(c0.Matches(AudioCodec(95, "", 44100, 30000, 2, 0)));
+ EXPECT_FALSE(c0.Matches(AudioCodec(95, "", 44100, 20000, 1, 0)));
+ EXPECT_FALSE(c0.Matches(AudioCodec(95, "", 55100, 30000, 1, 0)));
+
+ // Test a codec with a dynamic payload type.
+ AudioCodec c1(96, "A", 44100, 20000, 2, 3);
+ EXPECT_TRUE(c1.Matches(96, "A"));
+ EXPECT_TRUE(c1.Matches(97, "A"));
+ EXPECT_TRUE(c1.Matches(96, "a"));
+ EXPECT_TRUE(c1.Matches(97, "a"));
+ EXPECT_FALSE(c1.Matches(96, ""));
+ EXPECT_FALSE(c1.Matches(95, "A"));
+ EXPECT_TRUE(c1.Matches(AudioCodec(96, "A", 0, 0, 0, 0)));
+ EXPECT_FALSE(c1.Matches(AudioCodec(96, "", 44100, 20000, 2, 0)));
+ EXPECT_FALSE(c1.Matches(AudioCodec(96, "A", 55100, 30000, 1, 0)));
+
+ // Test a codec with a dynamic payload type, and auto bitrate.
+ AudioCodec c2(97, "A", 16000, 0, 1, 3);
+ // Use default bitrate.
+ EXPECT_TRUE(c2.Matches(AudioCodec(97, "A", 16000, 0, 1, 0)));
+ EXPECT_TRUE(c2.Matches(AudioCodec(97, "A", 16000, 0, 0, 0)));
+ // Use explicit bitrate.
+ EXPECT_TRUE(c2.Matches(AudioCodec(97, "A", 16000, 32000, 1, 0)));
+ // Backward compatibility with clients that might send "-1" (for default).
+ EXPECT_TRUE(c2.Matches(AudioCodec(97, "A", 16000, -1, 1, 0)));
+}
+
+TEST_F(CodecTest, TestVideoCodecOperators) {
+ VideoCodec c0(96, "V", 320, 200, 30, 3);
+ VideoCodec c1(95, "V", 320, 200, 30, 3);
+ VideoCodec c2(96, "x", 320, 200, 30, 3);
+ VideoCodec c3(96, "V", 120, 200, 30, 3);
+ VideoCodec c4(96, "V", 320, 100, 30, 3);
+ VideoCodec c5(96, "V", 320, 200, 10, 3);
+ VideoCodec c6(96, "V", 320, 200, 30, 1);
+ EXPECT_TRUE(c0 != c1);
+ EXPECT_TRUE(c0 != c2);
+ EXPECT_TRUE(c0 != c3);
+ EXPECT_TRUE(c0 != c4);
+ EXPECT_TRUE(c0 != c5);
+ EXPECT_TRUE(c0 != c6);
+
+ VideoCodec c7;
+ VideoCodec c8(0, "", 0, 0, 0, 0);
+ VideoCodec c9 = c0;
+ EXPECT_TRUE(c8 == c7);
+ EXPECT_TRUE(c9 != c7);
+ EXPECT_TRUE(c9 == c0);
+
+ VideoCodec c10(c0);
+ VideoCodec c11(c0);
+ VideoCodec c12(c0);
+ VideoCodec c13(c0);
+ c10.params["x"] = "abc";
+ c11.params["x"] = "def";
+ c12.params["y"] = "abc";
+ c13.params["x"] = "abc";
+ EXPECT_TRUE(c10 != c0);
+ EXPECT_TRUE(c11 != c0);
+ EXPECT_TRUE(c11 != c10);
+ EXPECT_TRUE(c12 != c0);
+ EXPECT_TRUE(c12 != c10);
+ EXPECT_TRUE(c12 != c11);
+ EXPECT_TRUE(c13 == c10);
+}
+
+TEST_F(CodecTest, TestVideoCodecMatches) {
+ // Test a codec with a static payload type.
+ VideoCodec c0(95, "V", 320, 200, 30, 3);
+ EXPECT_TRUE(c0.Matches(95, ""));
+ EXPECT_FALSE(c0.Matches(96, ""));
+ EXPECT_TRUE(c0.Matches(VideoCodec(95, "", 640, 400, 15, 0)));
+ EXPECT_FALSE(c0.Matches(VideoCodec(96, "", 320, 200, 30, 0)));
+
+ // Test a codec with a dynamic payload type.
+ VideoCodec c1(96, "V", 320, 200, 30, 3);
+ EXPECT_TRUE(c1.Matches(96, "V"));
+ EXPECT_TRUE(c1.Matches(97, "V"));
+ EXPECT_TRUE(c1.Matches(96, "v"));
+ EXPECT_TRUE(c1.Matches(97, "v"));
+ EXPECT_FALSE(c1.Matches(96, ""));
+ EXPECT_FALSE(c1.Matches(95, "V"));
+ EXPECT_TRUE(c1.Matches(VideoCodec(96, "V", 640, 400, 15, 0)));
+ EXPECT_FALSE(c1.Matches(VideoCodec(96, "", 320, 200, 30, 0)));
+}
+
+TEST_F(CodecTest, TestVideoEncoderConfigOperators) {
+ VideoEncoderConfig c1(VideoCodec(
+ 96, "SVC", 320, 200, 30, 3), 1, 2);
+ VideoEncoderConfig c2(VideoCodec(
+ 95, "SVC", 320, 200, 30, 3), 1, 2);
+ VideoEncoderConfig c3(VideoCodec(
+ 96, "xxx", 320, 200, 30, 3), 1, 2);
+ VideoEncoderConfig c4(VideoCodec(
+ 96, "SVC", 120, 200, 30, 3), 1, 2);
+ VideoEncoderConfig c5(VideoCodec(
+ 96, "SVC", 320, 100, 30, 3), 1, 2);
+ VideoEncoderConfig c6(VideoCodec(
+ 96, "SVC", 320, 200, 10, 3), 1, 2);
+ VideoEncoderConfig c7(VideoCodec(
+ 96, "SVC", 320, 200, 30, 1), 1, 2);
+ VideoEncoderConfig c8(VideoCodec(
+ 96, "SVC", 320, 200, 30, 3), 0, 2);
+ VideoEncoderConfig c9(VideoCodec(
+ 96, "SVC", 320, 200, 30, 3), 1, 1);
+ EXPECT_TRUE(c1 != c2);
+ EXPECT_TRUE(c1 != c2);
+ EXPECT_TRUE(c1 != c3);
+ EXPECT_TRUE(c1 != c4);
+ EXPECT_TRUE(c1 != c5);
+ EXPECT_TRUE(c1 != c6);
+ EXPECT_TRUE(c1 != c7);
+ EXPECT_TRUE(c1 != c8);
+ EXPECT_TRUE(c1 != c9);
+
+ VideoEncoderConfig c10;
+ VideoEncoderConfig c11(VideoCodec(
+ 0, "", 0, 0, 0, 0));
+ VideoEncoderConfig c12(VideoCodec(
+ 0, "", 0, 0, 0, 0),
+ VideoEncoderConfig::kDefaultMaxThreads,
+ VideoEncoderConfig::kDefaultCpuProfile);
+ VideoEncoderConfig c13 = c1;
+ VideoEncoderConfig c14(VideoCodec(
+ 0, "", 0, 0, 0, 0), 0, 0);
+
+ EXPECT_TRUE(c11 == c10);
+ EXPECT_TRUE(c12 == c10);
+ EXPECT_TRUE(c13 != c10);
+ EXPECT_TRUE(c13 == c1);
+ EXPECT_TRUE(c14 != c11);
+ EXPECT_TRUE(c14 != c12);
+}
diff --git a/talk/session/phone/currentspeakermonitor.cc b/talk/session/phone/currentspeakermonitor.cc
index bfc20a2..a148b7a 100644
--- a/talk/session/phone/currentspeakermonitor.cc
+++ b/talk/session/phone/currentspeakermonitor.cc
@@ -56,8 +56,8 @@
if (!started_) {
call_->SignalAudioMonitor.connect(
this, &CurrentSpeakerMonitor::OnAudioMonitor);
- call_->SignalMediaSourcesUpdate.connect(
- this, &CurrentSpeakerMonitor::OnMediaSourcesUpdate);
+ call_->SignalMediaStreamsUpdate.connect(
+ this, &CurrentSpeakerMonitor::OnMediaStreamsUpdate);
started_ = true;
}
@@ -66,7 +66,7 @@
void CurrentSpeakerMonitor::Stop() {
if (started_) {
call_->SignalAudioMonitor.disconnect(this);
- call_->SignalMediaSourcesUpdate.disconnect(this);
+ call_->SignalMediaStreamsUpdate.disconnect(this);
started_ = false;
ssrc_to_speaking_state_map_.clear();
@@ -106,8 +106,9 @@
state_it != ssrc_to_speaking_state_map_.end(); ++state_it) {
bool is_previous_speaker = current_speaker_ssrc_ == state_it->first;
- // This uses a state machine in order to gradually identify members as
- // having started or stopped speaking.
+ // This uses a state machine in order to gradually identify
+ // members as having started or stopped speaking. Matches the
+ // algorithm used by the hangouts js code.
std::map<uint32, int>::const_iterator level_it =
active_ssrc_to_level_map.find(state_it->first);
@@ -186,21 +187,20 @@
}
}
-void CurrentSpeakerMonitor::OnMediaSourcesUpdate(Call* call,
+void CurrentSpeakerMonitor::OnMediaStreamsUpdate(Call* call,
Session* session,
- const MediaSources& sources) {
+ const MediaStreams& added,
+ const MediaStreams& removed) {
if (call == call_ && session == session_) {
- // Update the speaking state map based on new or removed sources.
- NamedSources::const_iterator it;
- for (it = sources.audio().begin(); it != sources.audio().end(); it++) {
- if (it->ssrc_set) {
- if (it->removed) {
- ssrc_to_speaking_state_map_.erase(it->ssrc);
- } else if (ssrc_to_speaking_state_map_.find(it->ssrc) ==
- ssrc_to_speaking_state_map_.begin()) {
- ssrc_to_speaking_state_map_[it->ssrc] = SS_NOT_SPEAKING;
- }
- }
+ // Update the speaking state map based on added and removed streams.
+ for (std::vector<cricket::StreamParams>::const_iterator
+ it = removed.video().begin(); it != removed.video().end(); ++it) {
+ ssrc_to_speaking_state_map_.erase(it->first_ssrc());
+ }
+
+ for (std::vector<cricket::StreamParams>::const_iterator
+ it = added.video().begin(); it != added.video().end(); ++it) {
+ ssrc_to_speaking_state_map_[it->first_ssrc()] = SS_NOT_SPEAKING;
}
}
}
diff --git a/talk/session/phone/currentspeakermonitor.h b/talk/session/phone/currentspeakermonitor.h
index 84207fb..7871a82 100644
--- a/talk/session/phone/currentspeakermonitor.h
+++ b/talk/session/phone/currentspeakermonitor.h
@@ -42,7 +42,7 @@
class Call;
class Session;
struct AudioInfo;
-struct MediaSources;
+struct MediaStreams;
// Note that the call's audio monitor must be started before this is started.
// It's recommended that the audio monitor be started with a 100 ms period.
@@ -68,9 +68,10 @@
private:
void OnAudioMonitor(Call* call, const AudioInfo& info);
- void OnMediaSourcesUpdate(Call* call,
+ void OnMediaStreamsUpdate(Call* call,
Session* session,
- const MediaSources& sources);
+ const MediaStreams& added,
+ const MediaStreams& removed);
// These are states that a participant will pass through so that we gradually
// recognize that they have started and stopped speaking. This avoids
diff --git a/talk/session/phone/currentspeakermonitor_unittest.cc b/talk/session/phone/currentspeakermonitor_unittest.cc
new file mode 100644
index 0000000..264fa25
--- /dev/null
+++ b/talk/session/phone/currentspeakermonitor_unittest.cc
@@ -0,0 +1,232 @@
+/*
+ * libjingle
+ * Copyright 2004--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/base/gunit.h"
+#include "talk/base/thread.h"
+#include "talk/session/phone/call.h"
+#include "talk/session/phone/currentspeakermonitor.h"
+
+namespace cricket {
+
+static const uint32 kSsrc1 = 1001;
+static const uint32 kSsrc2 = 1002;
+static const uint32 kMinTimeBetweenSwitches = 10;
+// Due to limited system clock resolution, the CurrentSpeakerMonitor may
+// actually require more or less time between switches than that specified
+// in the call to set_min_time_between_switches. To be safe, we sleep for
+// 90 ms more than the min time between switches before checking for a switch.
+// I am assuming system clocks do not have a coarser resolution than 90 ms.
+static const uint32 kSleepTimeBetweenSwitches = 100;
+
+class MockCall : public Call {
+ public:
+ MockCall() : Call(NULL) {}
+
+ void EmitAudioMonitor(const AudioInfo& info) {
+ SignalAudioMonitor(this, info);
+ }
+};
+
+class CurrentSpeakerMonitorTest : public testing::Test,
+ public sigslot::has_slots<> {
+ public:
+ CurrentSpeakerMonitorTest() {
+ call_ = new MockCall();
+ monitor_ = new CurrentSpeakerMonitor(call_, NULL);
+ // Shrink the minimum time betweeen switches to 10 ms so we don't have to
+ // slow down our tests.
+ monitor_->set_min_time_between_switches(kMinTimeBetweenSwitches);
+ monitor_->SignalUpdate.connect(this, &CurrentSpeakerMonitorTest::OnUpdate);
+ current_speaker_ = 0;
+ num_changes_ = 0;
+ monitor_->Start();
+ }
+
+ ~CurrentSpeakerMonitorTest() {
+ delete monitor_;
+ delete call_;
+ }
+
+ protected:
+ MockCall* call_;
+ CurrentSpeakerMonitor* monitor_;
+ int num_changes_;
+ uint32 current_speaker_;
+
+ void OnUpdate(CurrentSpeakerMonitor* monitor, uint32 current_speaker) {
+ current_speaker_ = current_speaker;
+ num_changes_++;
+ }
+};
+
+static void InitAudioInfo(AudioInfo* info, int input_level, int output_level) {
+ info->input_level = input_level;
+ info->output_level = output_level;
+}
+
+TEST_F(CurrentSpeakerMonitorTest, NoActiveStreams) {
+ AudioInfo info;
+ InitAudioInfo(&info, 0, 0);
+ call_->EmitAudioMonitor(info);
+
+ EXPECT_EQ(current_speaker_, 0U);
+ EXPECT_EQ(num_changes_, 0);
+}
+
+TEST_F(CurrentSpeakerMonitorTest, MultipleActiveStreams) {
+ AudioInfo info;
+ InitAudioInfo(&info, 0, 0);
+
+ info.active_streams.push_back(std::make_pair(kSsrc1, 3));
+ info.active_streams.push_back(std::make_pair(kSsrc2, 7));
+ call_->EmitAudioMonitor(info);
+
+ // No speaker recognized because the initial sample is treated as possibly
+ // just noise and disregarded.
+ EXPECT_EQ(current_speaker_, 0U);
+ EXPECT_EQ(num_changes_, 0);
+
+ info.active_streams.push_back(std::make_pair(kSsrc1, 3));
+ info.active_streams.push_back(std::make_pair(kSsrc2, 7));
+ call_->EmitAudioMonitor(info);
+
+ EXPECT_EQ(current_speaker_, kSsrc2);
+ EXPECT_EQ(num_changes_, 1);
+}
+
+TEST_F(CurrentSpeakerMonitorTest, RapidSpeakerChange) {
+ AudioInfo info;
+ InitAudioInfo(&info, 0, 0);
+
+ info.active_streams.push_back(std::make_pair(kSsrc1, 3));
+ info.active_streams.push_back(std::make_pair(kSsrc2, 7));
+ call_->EmitAudioMonitor(info);
+
+ EXPECT_EQ(current_speaker_, 0U);
+ EXPECT_EQ(num_changes_, 0);
+
+ info.active_streams.push_back(std::make_pair(kSsrc1, 3));
+ info.active_streams.push_back(std::make_pair(kSsrc2, 7));
+ call_->EmitAudioMonitor(info);
+
+ EXPECT_EQ(current_speaker_, kSsrc2);
+ EXPECT_EQ(num_changes_, 1);
+
+ info.active_streams.push_back(std::make_pair(kSsrc1, 9));
+ info.active_streams.push_back(std::make_pair(kSsrc2, 1));
+ call_->EmitAudioMonitor(info);
+
+ // We expect no speaker change because of the rapid change.
+ EXPECT_EQ(current_speaker_, kSsrc2);
+ EXPECT_EQ(num_changes_, 1);
+}
+
+TEST_F(CurrentSpeakerMonitorTest, SpeakerChange) {
+ AudioInfo info;
+ InitAudioInfo(&info, 0, 0);
+
+ info.active_streams.push_back(std::make_pair(kSsrc1, 3));
+ info.active_streams.push_back(std::make_pair(kSsrc2, 7));
+ call_->EmitAudioMonitor(info);
+
+ EXPECT_EQ(current_speaker_, 0U);
+ EXPECT_EQ(num_changes_, 0);
+
+ info.active_streams.push_back(std::make_pair(kSsrc1, 3));
+ info.active_streams.push_back(std::make_pair(kSsrc2, 7));
+ call_->EmitAudioMonitor(info);
+
+ EXPECT_EQ(current_speaker_, kSsrc2);
+ EXPECT_EQ(num_changes_, 1);
+
+ // Wait so the changes don't come so rapidly.
+ talk_base::Thread::SleepMs(kSleepTimeBetweenSwitches);
+
+ info.active_streams.push_back(std::make_pair(kSsrc1, 9));
+ info.active_streams.push_back(std::make_pair(kSsrc2, 1));
+ call_->EmitAudioMonitor(info);
+
+ EXPECT_EQ(current_speaker_, kSsrc1);
+ EXPECT_EQ(num_changes_, 2);
+}
+
+TEST_F(CurrentSpeakerMonitorTest, InterwordSilence) {
+ AudioInfo info;
+ InitAudioInfo(&info, 0, 0);
+
+ info.active_streams.push_back(std::make_pair(kSsrc1, 3));
+ info.active_streams.push_back(std::make_pair(kSsrc2, 7));
+ call_->EmitAudioMonitor(info);
+
+ EXPECT_EQ(current_speaker_, 0U);
+ EXPECT_EQ(num_changes_, 0);
+
+ info.active_streams.push_back(std::make_pair(kSsrc1, 3));
+ info.active_streams.push_back(std::make_pair(kSsrc2, 7));
+ call_->EmitAudioMonitor(info);
+
+ EXPECT_EQ(current_speaker_, kSsrc2);
+ EXPECT_EQ(num_changes_, 1);
+
+ info.active_streams.push_back(std::make_pair(kSsrc1, 3));
+ info.active_streams.push_back(std::make_pair(kSsrc2, 7));
+ call_->EmitAudioMonitor(info);
+
+ EXPECT_EQ(current_speaker_, kSsrc2);
+ EXPECT_EQ(num_changes_, 1);
+
+ // Wait so the changes don't come so rapidly.
+ talk_base::Thread::SleepMs(kSleepTimeBetweenSwitches);
+
+ info.active_streams.push_back(std::make_pair(kSsrc1, 3));
+ info.active_streams.push_back(std::make_pair(kSsrc2, 0));
+ call_->EmitAudioMonitor(info);
+
+ // Current speaker shouldn't have changed because we treat this as an inter-
+ // word silence.
+ EXPECT_EQ(current_speaker_, kSsrc2);
+ EXPECT_EQ(num_changes_, 1);
+
+ info.active_streams.push_back(std::make_pair(kSsrc1, 3));
+ info.active_streams.push_back(std::make_pair(kSsrc2, 0));
+ call_->EmitAudioMonitor(info);
+
+ // Current speaker shouldn't have changed because we treat this as an inter-
+ // word silence.
+ EXPECT_EQ(current_speaker_, kSsrc2);
+ EXPECT_EQ(num_changes_, 1);
+
+ info.active_streams.push_back(std::make_pair(kSsrc1, 3));
+ info.active_streams.push_back(std::make_pair(kSsrc2, 0));
+ call_->EmitAudioMonitor(info);
+
+ // At this point, we should have concluded that SSRC2 stopped speaking.
+ EXPECT_EQ(current_speaker_, kSsrc1);
+ EXPECT_EQ(num_changes_, 2);
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/devicemanager.cc b/talk/session/phone/devicemanager.cc
index 6188461..67dfe41 100644
--- a/talk/session/phone/devicemanager.cc
+++ b/talk/session/phone/devicemanager.cc
@@ -27,40 +27,6 @@
#include "talk/session/phone/devicemanager.h"
-#if WIN32
-#include <atlbase.h>
-#include <dbt.h>
-#include <strmif.h> // must come before ks.h
-#include <ks.h>
-#include <ksmedia.h>
-#define INITGUID // For PKEY_AudioEndpoint_GUID
-#include <mmdeviceapi.h>
-#include <mmsystem.h>
-#include <functiondiscoverykeys_devpkey.h>
-#include <uuids.h>
-#include "talk/base/win32.h" // ToUtf8
-#include "talk/base/win32window.h"
-#elif OSX
-#include <CoreAudio/CoreAudio.h>
-#include <QuickTime/QuickTime.h>
-#elif LINUX
-#include <libudev.h>
-#include <unistd.h>
-#include "talk/base/linux.h"
-#include "talk/base/fileutils.h"
-#include "talk/base/pathutils.h"
-#include "talk/base/physicalsocketserver.h"
-#include "talk/base/stream.h"
-#include "talk/session/phone/libudevsymboltable.h"
-#include "talk/session/phone/v4llookup.h"
-#if !defined(NO_SOUND_SYSTEM)
-#include "talk/sound/platformsoundsystem.h"
-#include "talk/sound/platformsoundsystemfactory.h"
-#include "talk/sound/sounddevicelocator.h"
-#include "talk/sound/soundsysteminterface.h"
-#endif // !defined(NO_SOUND_SYSTEM)
-#endif
-
#include "talk/base/logging.h"
#include "talk/base/stringutils.h"
#include "talk/base/thread.h"
@@ -70,135 +36,30 @@
// Initialize to empty string.
const char DeviceManagerInterface::kDefaultDeviceName[] = "";
-DeviceManagerInterface* DeviceManagerFactory::Create() {
- return new DeviceManager();
-}
-
-#ifdef WIN32
-class DeviceWatcher : public talk_base::Win32Window {
- public:
- explicit DeviceWatcher(DeviceManager* dm);
- bool Start();
- void Stop();
-
- private:
- HDEVNOTIFY Register(REFGUID guid);
- void Unregister(HDEVNOTIFY notify);
- virtual bool OnMessage(UINT msg, WPARAM wp, LPARAM lp, LRESULT& result);
-
- DeviceManager* manager_;
- HDEVNOTIFY audio_notify_;
- HDEVNOTIFY video_notify_;
-};
-#elif defined(LINUX)
-class DeviceWatcher : private talk_base::Dispatcher {
- public:
- explicit DeviceWatcher(DeviceManager* dm);
- bool Start();
- void Stop();
-
- private:
- virtual uint32 GetRequestedEvents();
- virtual void OnPreEvent(uint32 ff);
- virtual void OnEvent(uint32 ff, int err);
- virtual int GetDescriptor();
- virtual bool IsDescriptorClosed();
-
- DeviceManager* manager_;
- LibUDevSymbolTable libudev_;
- struct udev* udev_;
- struct udev_monitor* udev_monitor_;
- bool registered_;
-};
-#define LATE(sym) LATESYM_GET(LibUDevSymbolTable, &libudev_, sym)
-#elif defined(OSX)
-class DeviceWatcher {
- public:
- explicit DeviceWatcher(DeviceManager* dm);
- bool Start();
- void Stop();
- private:
- DeviceManager* manager_;
- void* impl_;
-};
-#endif
-
-#if defined(CHROMEOS)
-static bool ShouldAudioDeviceBeIgnored(const std::string& device_name);
-#endif
-#if !defined(LINUX) && !defined(IOS)
-static bool ShouldVideoDeviceBeIgnored(const std::string& device_name);
-#endif
-#ifndef OSX
-static bool GetVideoDevices(std::vector<Device>* out);
-#endif
-#if WIN32
-static const wchar_t kFriendlyName[] = L"FriendlyName";
-static const wchar_t kDevicePath[] = L"DevicePath";
-static const char kUsbDevicePathPrefix[] = "\\\\?\\usb";
-static bool GetDevices(const CLSID& catid, std::vector<Device>* out);
-static bool GetCoreAudioDevices(bool input, std::vector<Device>* devs);
-static bool GetWaveDevices(bool input, std::vector<Device>* devs);
-#elif OSX
-static const int kVideoDeviceOpenAttempts = 3;
-static const UInt32 kAudioDeviceNameLength = 64;
-// Obj-C functions defined in devicemanager-mac.mm
-extern void* CreateDeviceWatcherCallback(DeviceManager* dm);
-extern void ReleaseDeviceWatcherCallback(void* impl);
-extern bool GetQTKitVideoDevices(std::vector<Device>* out);
-static bool GetAudioDeviceIDs(bool inputs, std::vector<AudioDeviceID>* out);
-static bool GetAudioDeviceName(AudioDeviceID id, bool input, std::string* out);
-#endif
-
DeviceManager::DeviceManager()
- : initialized_(false),
-#if defined(WIN32)
- need_couninitialize_(false),
-#endif
- watcher_(new DeviceWatcher(this))
-#if defined(LINUX) && !defined(NO_SOUND_SYSTEM)
- , sound_system_(new PlatformSoundSystemFactory())
-#endif
- {
+ : initialized_(false) {
}
DeviceManager::~DeviceManager() {
- if (initialized_) {
+ if (initialized()) {
Terminate();
}
- delete watcher_;
}
bool DeviceManager::Init() {
- if (!initialized_) {
-#if defined(WIN32)
- HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
- need_couninitialize_ = SUCCEEDED(hr);
- if (FAILED(hr)) {
- LOG(LS_ERROR) << "CoInitialize failed, hr=" << hr;
- if (hr != RPC_E_CHANGED_MODE) {
- return false;
- }
- }
-#endif
- if (!watcher_->Start()) {
+ if (!initialized()) {
+ if (!watcher()->Start()) {
return false;
}
- initialized_ = true;
+ set_initialized(true);
}
return true;
}
void DeviceManager::Terminate() {
- if (initialized_) {
- watcher_->Stop();
-#if defined(WIN32)
- if (need_couninitialize_) {
- CoUninitialize();
- need_couninitialize_ = false;
- }
-#endif
- initialized_ = false;
+ if (initialized()) {
+ watcher()->Stop();
+ set_initialized(false);
}
}
@@ -218,11 +79,11 @@
}
bool DeviceManager::GetAudioInputDevices(std::vector<Device>* devices) {
- return GetAudioDevicesByPlatform(true, devices);
+ return GetAudioDevices(true, devices);
}
bool DeviceManager::GetAudioOutputDevices(std::vector<Device>* devices) {
- return GetAudioDevicesByPlatform(false, devices);
+ return GetAudioDevices(false, devices);
}
bool DeviceManager::GetAudioInputDevice(const std::string& name, Device* out) {
@@ -233,55 +94,20 @@
return GetAudioDevice(false, name, out);
}
-#ifdef OSX
-static bool FilterDevice(const Device& d) {
- return ShouldVideoDeviceBeIgnored(d.name);
-}
-#endif
-
bool DeviceManager::GetVideoCaptureDevices(std::vector<Device>* devices) {
devices->clear();
-#ifdef OSX
- if (GetQTKitVideoDevices(devices)) {
- // Now filter out any known incompatible devices
- devices->erase(remove_if(devices->begin(), devices->end(), FilterDevice),
- devices->end());
- return true;
- }
+#if defined(ANDROID) || defined(IOS)
+ // TODO: Incomplete. Use ANDROID implementation for IOS
+ // to quiet compiler.
+ // On Android, we treat the camera(s) as a single device. Even if there are
+ // multiple cameras, that's abstracted away at a higher level.
+ Device dev("camera", "1"); // name and ID
+ devices->push_back(dev);
+#else
return false;
-#else
- return GetVideoDevices(devices);
#endif
}
-bool DeviceManager::GetDefaultVideoCaptureDevice(Device* device) {
- bool ret = false;
-#if WIN32
- // If there are multiple capture devices, we want the first USB one.
- // This avoids issues with defaulting to virtual cameras or grabber cards.
- std::vector<Device> devices;
- ret = (GetVideoDevices(&devices) && !devices.empty());
- if (ret) {
- *device = devices[0];
- for (size_t i = 0; i < devices.size(); ++i) {
- if (strnicmp(devices[i].id.c_str(), kUsbDevicePathPrefix,
- ARRAY_SIZE(kUsbDevicePathPrefix) - 1) == 0) {
- *device = devices[i];
- break;
- }
- }
- }
-#else
- // We just return the first device.
- std::vector<Device> devices;
- ret = (GetVideoCaptureDevices(&devices) && !devices.empty());
- if (ret) {
- *device = devices[0];
- }
-#endif
- return ret;
-}
-
bool DeviceManager::GetVideoCaptureDevice(const std::string& name,
Device* out) {
// If the name is empty, return the default device.
@@ -305,6 +131,25 @@
return false;
}
+bool DeviceManager::GetAudioDevices(bool input,
+ std::vector<Device>* devs) {
+ devs->clear();
+#ifdef ANDROID
+ // Under Android, we don't access the device file directly.
+ // Arbitrary use 0 for the mic and 1 for the output.
+ // These ids are used in MediaEngine::SetSoundDevices(in, out);
+ // The strings are for human consumption.
+ if (input) {
+ devs->push_back(Device("audiorecord", 0));
+ } else {
+ devs->push_back(Device("audiotrack", 1));
+ }
+ return true;
+#else
+ return false;
+#endif
+}
+
bool DeviceManager::GetAudioDevice(bool is_input, const std::string& name,
Device* out) {
// If the name is empty, return the default device id.
@@ -329,695 +174,50 @@
return ret;
}
-bool DeviceManager::GetAudioDevicesByPlatform(bool input,
- std::vector<Device>* devs) {
- devs->clear();
-
-#if defined(LINUX) && !defined(NO_SOUND_SYSTEM)
- if (!sound_system_.get()) {
- return false;
- }
- SoundSystemInterface::SoundDeviceLocatorList list;
- bool success;
- if (input) {
- success = sound_system_->EnumerateCaptureDevices(&list);
- } else {
- success = sound_system_->EnumeratePlaybackDevices(&list);
- }
- if (!success) {
- LOG(LS_ERROR) << "Can't enumerate devices";
- sound_system_.release();
- return false;
- }
- // We have to start the index at 1 because GIPS VoiceEngine puts the default
- // device at index 0, but Enumerate(Capture|Playback)Devices does not include
- // a locator for the default device.
- int index = 1;
- for (SoundSystemInterface::SoundDeviceLocatorList::iterator i = list.begin();
- i != list.end();
- ++i, ++index) {
-#if defined(CHROMEOS)
- // On ChromeOS, we ignore ALSA surround and S/PDIF devices.
- if (!ShouldAudioDeviceBeIgnored((*i)->device_name())) {
-#endif
- devs->push_back(Device((*i)->name(), index));
-#if defined(CHROMEOS)
- }
-#endif
- }
- SoundSystemInterface::ClearSoundDeviceLocatorList(&list);
- sound_system_.release();
- return true;
-
-#elif defined(WIN32)
- if (talk_base::IsWindowsVistaOrLater()) {
- return GetCoreAudioDevices(input, devs);
- } else {
- return GetWaveDevices(input, devs);
- }
-
-#elif defined(OSX)
- std::vector<AudioDeviceID> dev_ids;
- bool ret = GetAudioDeviceIDs(input, &dev_ids);
+bool DeviceManager::GetDefaultVideoCaptureDevice(Device* device) {
+ bool ret = false;
+ // We just return the first device.
+ std::vector<Device> devices;
+ ret = (GetVideoCaptureDevices(&devices) && !devices.empty());
if (ret) {
- for (size_t i = 0; i < dev_ids.size(); ++i) {
- std::string name;
- if (GetAudioDeviceName(dev_ids[i], input, &name)) {
- devs->push_back(Device(name, dev_ids[i]));
- }
- }
+ *device = devices[0];
}
return ret;
-
-#else
- return false;
-#endif
}
-#if defined(WIN32)
-bool GetVideoDevices(std::vector<Device>* devices) {
- return GetDevices(CLSID_VideoInputDeviceCategory, devices);
-}
-
-bool GetDevices(const CLSID& catid, std::vector<Device>* devices) {
- HRESULT hr;
-
- // CComPtr is a scoped pointer that will be auto released when going
- // out of scope. CoUninitialize must not be called before the
- // release.
- CComPtr<ICreateDevEnum> sys_dev_enum;
- CComPtr<IEnumMoniker> cam_enum;
- if (FAILED(hr = sys_dev_enum.CoCreateInstance(CLSID_SystemDeviceEnum)) ||
- FAILED(hr = sys_dev_enum->CreateClassEnumerator(catid, &cam_enum, 0))) {
- LOG(LS_ERROR) << "Failed to create device enumerator, hr=" << hr;
+bool DeviceManager::ShouldDeviceBeIgnored(const std::string& device_name,
+ const char* const exclusion_list[]) {
+ // If exclusion_list is empty return directly.
+ if (!exclusion_list)
return false;
- }
- // Only enum devices if CreateClassEnumerator returns S_OK. If there are no
- // devices available, S_FALSE will be returned, but enumMk will be NULL.
- if (hr == S_OK) {
- CComPtr<IMoniker> mk;
- while (cam_enum->Next(1, &mk, NULL) == S_OK) {
- CComPtr<IPropertyBag> bag;
- if (SUCCEEDED(mk->BindToStorage(NULL, NULL,
- __uuidof(bag), reinterpret_cast<void**>(&bag)))) {
- CComVariant name, path;
- std::string name_str, path_str;
- if (SUCCEEDED(bag->Read(kFriendlyName, &name, 0)) &&
- name.vt == VT_BSTR) {
- name_str = talk_base::ToUtf8(name.bstrVal);
- if (!ShouldVideoDeviceBeIgnored(name_str)) {
- // Get the device id if one exists.
- if (SUCCEEDED(bag->Read(kDevicePath, &path, 0)) &&
- path.vt == VT_BSTR) {
- path_str = talk_base::ToUtf8(path.bstrVal);
- }
-
- devices->push_back(Device(name_str, path_str));
- }
- }
- }
- mk = NULL;
+ int i = 0;
+ while (exclusion_list[i]) {
+ if (strnicmp(device_name.c_str(), exclusion_list[i],
+ strlen(exclusion_list[i])) == 0) {
+ LOG(LS_INFO) << "Ignoring device " << device_name;
+ return true;
}
+ ++i;
}
-
- return true;
-}
-
-HRESULT GetStringProp(IPropertyStore* bag, PROPERTYKEY key, std::string* out) {
- out->clear();
- PROPVARIANT var;
- PropVariantInit(&var);
-
- HRESULT hr = bag->GetValue(key, &var);
- if (SUCCEEDED(hr)) {
- if (var.pwszVal)
- *out = talk_base::ToUtf8(var.pwszVal);
- else
- hr = E_FAIL;
- }
-
- PropVariantClear(&var);
- return hr;
-}
-
-// Adapted from http://msdn.microsoft.com/en-us/library/dd370812(v=VS.85).aspx
-HRESULT CricketDeviceFromImmDevice(IMMDevice* device, Device* out) {
- CComPtr<IPropertyStore> props;
-
- HRESULT hr = device->OpenPropertyStore(STGM_READ, &props);
- if (FAILED(hr)) {
- return hr;
- }
-
- // Get the endpoint's name and id.
- std::string name, guid;
- hr = GetStringProp(props, PKEY_Device_FriendlyName, &name);
- if (SUCCEEDED(hr)) {
- hr = GetStringProp(props, PKEY_AudioEndpoint_GUID, &guid);
-
- if (SUCCEEDED(hr)) {
- out->name = name;
- out->id = guid;
- }
- }
- return hr;
-}
-
-bool GetCoreAudioDevices(bool input, std::vector<Device>* devs) {
- HRESULT hr = S_OK;
- CComPtr<IMMDeviceEnumerator> enumerator;
-
- hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_ALL,
- __uuidof(IMMDeviceEnumerator), reinterpret_cast<void**>(&enumerator));
- if (SUCCEEDED(hr)) {
- CComPtr<IMMDeviceCollection> devices;
- hr = enumerator->EnumAudioEndpoints((input ? eCapture : eRender),
- DEVICE_STATE_ACTIVE, &devices);
- if (SUCCEEDED(hr)) {
- unsigned int count;
- hr = devices->GetCount(&count);
-
- if (SUCCEEDED(hr)) {
- for (unsigned int i = 0; i < count; i++) {
- CComPtr<IMMDevice> device;
-
- // Get pointer to endpoint number i.
- hr = devices->Item(i, &device);
- if (FAILED(hr)) {
- break;
- }
-
- Device dev;
- hr = CricketDeviceFromImmDevice(device, &dev);
- if (SUCCEEDED(hr)) {
- devs->push_back(dev);
- } else {
- LOG(LS_WARNING) << "Unable to query IMM Device, skipping. HR="
- << hr;
- hr = S_FALSE;
- }
- }
- }
- }
- }
-
- if (FAILED(hr)) {
- LOG(LS_WARNING) << "GetCoreAudioDevices failed with hr " << hr;
- return false;
- }
- return true;
-}
-
-bool GetWaveDevices(bool input, std::vector<Device>* devs) {
- // Note, we don't use the System Device Enumerator interface here since it
- // adds lots of pseudo-devices to the list, such as DirectSound and Wave
- // variants of the same device.
- if (input) {
- int num_devs = waveInGetNumDevs();
- for (int i = 0; i < num_devs; ++i) {
- WAVEINCAPS caps;
- if (waveInGetDevCaps(i, &caps, sizeof(caps)) == MMSYSERR_NOERROR &&
- caps.wChannels > 0) {
- devs->push_back(Device(talk_base::ToUtf8(caps.szPname),
- talk_base::ToString(i)));
- }
- }
- } else {
- int num_devs = waveOutGetNumDevs();
- for (int i = 0; i < num_devs; ++i) {
- WAVEOUTCAPS caps;
- if (waveOutGetDevCaps(i, &caps, sizeof(caps)) == MMSYSERR_NOERROR &&
- caps.wChannels > 0) {
- devs->push_back(Device(talk_base::ToUtf8(caps.szPname), i));
- }
- }
- }
- return true;
-}
-
-DeviceWatcher::DeviceWatcher(DeviceManager* manager)
- : manager_(manager), audio_notify_(NULL), video_notify_(NULL) {
-}
-
-bool DeviceWatcher::Start() {
- if (!Create(NULL, _T("libjingle DeviceWatcher Window"),
- 0, 0, 0, 0, 0, 0)) {
- return false;
- }
-
- audio_notify_ = Register(KSCATEGORY_AUDIO);
- if (!audio_notify_) {
- Stop();
- return false;
- }
-
- video_notify_ = Register(KSCATEGORY_VIDEO);
- if (!video_notify_) {
- Stop();
- return false;
- }
-
- return true;
-}
-
-void DeviceWatcher::Stop() {
- UnregisterDeviceNotification(video_notify_);
- video_notify_ = NULL;
- UnregisterDeviceNotification(audio_notify_);
- audio_notify_ = NULL;
- Destroy();
-}
-
-HDEVNOTIFY DeviceWatcher::Register(REFGUID guid) {
- DEV_BROADCAST_DEVICEINTERFACE dbdi;
- dbdi.dbcc_size = sizeof(dbdi);
- dbdi.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
- dbdi.dbcc_classguid = guid;
- dbdi.dbcc_name[0] = '\0';
- return RegisterDeviceNotification(handle(), &dbdi,
- DEVICE_NOTIFY_WINDOW_HANDLE);
-}
-
-void DeviceWatcher::Unregister(HDEVNOTIFY handle) {
- UnregisterDeviceNotification(handle);
-}
-
-bool DeviceWatcher::OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
- LRESULT& result) {
- if (uMsg == WM_DEVICECHANGE) {
- if (wParam == DBT_DEVICEARRIVAL ||
- wParam == DBT_DEVICEREMOVECOMPLETE) {
- DEV_BROADCAST_DEVICEINTERFACE* dbdi =
- reinterpret_cast<DEV_BROADCAST_DEVICEINTERFACE*>(lParam);
- if (dbdi->dbcc_classguid == KSCATEGORY_AUDIO ||
- dbdi->dbcc_classguid == KSCATEGORY_VIDEO) {
- manager_->OnDevicesChange();
- }
- }
- result = 0;
- return true;
- }
-
return false;
}
-#elif defined(OSX)
-static bool GetAudioDeviceIDs(bool input,
- std::vector<AudioDeviceID>* out_dev_ids) {
- UInt32 propsize;
- OSErr err = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices,
- &propsize, NULL);
- if (0 != err) {
- LOG(LS_ERROR) << "Couldn't get information about property, "
- << "so no device list acquired.";
+
+bool DeviceManager::FilterDevices(std::vector<Device>* devices,
+ const char* const exclusion_list[]) {
+ if (!devices) {
return false;
}
- size_t num_devices = propsize / sizeof(AudioDeviceID);
- talk_base::scoped_array<AudioDeviceID> device_ids(
- new AudioDeviceID[num_devices]);
-
- err = AudioHardwareGetProperty(kAudioHardwarePropertyDevices,
- &propsize, device_ids.get());
- if (0 != err) {
- LOG(LS_ERROR) << "Failed to get device ids, "
- << "so no device listing acquired.";
- return false;
- }
-
- for (size_t i = 0; i < num_devices; ++i) {
- AudioDeviceID an_id = device_ids[i];
- // find out the number of channels for this direction
- // (input/output) on this device -
- // we'll ignore anything with no channels.
- err = AudioDeviceGetPropertyInfo(an_id, 0, input,
- kAudioDevicePropertyStreams,
- &propsize, NULL);
- if (0 == err) {
- unsigned num_channels = propsize / sizeof(AudioStreamID);
- if (0 < num_channels) {
- out_dev_ids->push_back(an_id);
- }
+ for (std::vector<Device>::iterator it = devices->begin();
+ it != devices->end(); ) {
+ if (ShouldDeviceBeIgnored(it->name, exclusion_list)) {
+ it = devices->erase(it);
} else {
- LOG(LS_ERROR) << "No property info for stream property for device id "
- << an_id << "(is_input == " << input
- << "), so not including it in the list.";
+ ++it;
}
}
-
return true;
}
-static bool GetAudioDeviceName(AudioDeviceID id,
- bool input,
- std::string* out_name) {
- UInt32 nameLength = kAudioDeviceNameLength;
- char name[kAudioDeviceNameLength + 1];
- OSErr err = AudioDeviceGetProperty(id, 0, input,
- kAudioDevicePropertyDeviceName,
- &nameLength, name);
- if (0 != err) {
- LOG(LS_ERROR) << "No name acquired for device id " << id;
- return false;
- }
-
- *out_name = name;
- return true;
-}
-
-DeviceWatcher::DeviceWatcher(DeviceManager* manager)
- : manager_(manager), impl_(NULL) {
-}
-
-bool DeviceWatcher::Start() {
- if (!impl_) {
- impl_ = CreateDeviceWatcherCallback(manager_);
- }
- return impl_ != NULL;
-}
-
-void DeviceWatcher::Stop() {
- if (impl_) {
- ReleaseDeviceWatcherCallback(impl_);
- impl_ = NULL;
- }
-}
-
-#elif defined(LINUX)
-static const std::string kVideoMetaPathK2_4("/proc/video/dev/");
-static const std::string kVideoMetaPathK2_6("/sys/class/video4linux/");
-
-enum MetaType { M2_4, M2_6, NONE };
-
-static void ScanDeviceDirectory(const std::string& devdir,
- std::vector<Device>* devices) {
- talk_base::scoped_ptr<talk_base::DirectoryIterator> directoryIterator(
- talk_base::Filesystem::IterateDirectory());
-
- if (directoryIterator->Iterate(talk_base::Pathname(devdir))) {
- do {
- std::string filename = directoryIterator->Name();
- std::string device_name = devdir + filename;
- if (!directoryIterator->IsDots()) {
- if (filename.find("video") == 0 &&
- V4LLookup::IsV4L2Device(device_name)) {
- devices->push_back(Device(device_name, device_name));
- }
- }
- } while (directoryIterator->Next());
- }
-}
-
-static std::string GetVideoDeviceNameK2_6(const std::string& device_meta_path) {
- std::string device_name;
-
- talk_base::scoped_ptr<talk_base::FileStream> device_meta_stream(
- talk_base::Filesystem::OpenFile(device_meta_path, "r"));
-
- if (device_meta_stream.get() != NULL) {
- if (device_meta_stream->ReadLine(&device_name) != talk_base::SR_SUCCESS) {
- LOG(LS_ERROR) << "Failed to read V4L2 device meta " << device_meta_path;
- }
- device_meta_stream->Close();
- }
-
- return device_name;
-}
-
-static std::string Trim(const std::string& s, const std::string& drop = " \t") {
- std::string::size_type first = s.find_first_not_of(drop);
- std::string::size_type last = s.find_last_not_of(drop);
-
- if (first == std::string::npos || last == std::string::npos)
- return std::string("");
-
- return s.substr(first, last - first + 1);
-}
-
-static std::string GetVideoDeviceNameK2_4(const std::string& device_meta_path) {
- talk_base::ConfigParser::MapVector all_values;
-
- talk_base::ConfigParser config_parser;
- talk_base::FileStream* file_stream =
- talk_base::Filesystem::OpenFile(device_meta_path, "r");
-
- if (file_stream == NULL) return "";
-
- config_parser.Attach(file_stream);
- config_parser.Parse(&all_values);
-
- for (talk_base::ConfigParser::MapVector::iterator i = all_values.begin();
- i != all_values.end(); ++i) {
- talk_base::ConfigParser::SimpleMap::iterator device_name_i =
- i->find("name");
-
- if (device_name_i != i->end()) {
- return device_name_i->second;
- }
- }
-
- return "";
-}
-
-static std::string GetVideoDeviceName(MetaType meta,
- const std::string& device_file_name) {
- std::string device_meta_path;
- std::string device_name;
- std::string meta_file_path;
-
- if (meta == M2_6) {
- meta_file_path = kVideoMetaPathK2_6 + device_file_name + "/name";
-
- LOG(LS_INFO) << "Trying " + meta_file_path;
- device_name = GetVideoDeviceNameK2_6(meta_file_path);
-
- if (device_name.empty()) {
- meta_file_path = kVideoMetaPathK2_6 + device_file_name + "/model";
-
- LOG(LS_INFO) << "Trying " << meta_file_path;
- device_name = GetVideoDeviceNameK2_6(meta_file_path);
- }
- } else {
- meta_file_path = kVideoMetaPathK2_4 + device_file_name;
- LOG(LS_INFO) << "Trying " << meta_file_path;
- device_name = GetVideoDeviceNameK2_4(meta_file_path);
- }
-
- if (device_name.empty()) {
- device_name = "/dev/" + device_file_name;
- LOG(LS_ERROR)
- << "Device name not found, defaulting to device path " << device_name;
- }
-
- LOG(LS_INFO) << "Name for " << device_file_name << " is " << device_name;
-
- return Trim(device_name);
-}
-
-static void ScanV4L2Devices(std::vector<Device>* devices) {
- LOG(LS_INFO) << ("Enumerating V4L2 devices");
-
- MetaType meta;
- std::string metadata_dir;
-
- talk_base::scoped_ptr<talk_base::DirectoryIterator> directoryIterator(
- talk_base::Filesystem::IterateDirectory());
-
- // Try and guess kernel version
- if (directoryIterator->Iterate(kVideoMetaPathK2_6)) {
- meta = M2_6;
- metadata_dir = kVideoMetaPathK2_6;
- } else if (directoryIterator->Iterate(kVideoMetaPathK2_4)) {
- meta = M2_4;
- metadata_dir = kVideoMetaPathK2_4;
- } else {
- meta = NONE;
- }
-
- if (meta != NONE) {
- LOG(LS_INFO) << "V4L2 device metadata found at " << metadata_dir;
-
- do {
- std::string filename = directoryIterator->Name();
-
- if (filename.find("video") == 0) {
- std::string device_path = "/dev/" + filename;
-
- if (V4LLookup::IsV4L2Device(device_path)) {
- devices->push_back(
- Device(GetVideoDeviceName(meta, filename), device_path));
- }
- }
- } while (directoryIterator->Next());
- } else {
- LOG(LS_ERROR) << "Unable to detect v4l2 metadata directory";
- }
-
- if (devices->size() == 0) {
- LOG(LS_INFO) << "Plan B. Scanning all video devices in /dev directory";
- ScanDeviceDirectory("/dev/", devices);
- }
-
- LOG(LS_INFO) << "Total V4L2 devices found : " << devices->size();
-}
-
-static bool GetVideoDevices(std::vector<Device>* devices) {
- ScanV4L2Devices(devices);
- return true;
-}
-
-DeviceWatcher::DeviceWatcher(DeviceManager* dm)
- : manager_(dm), udev_(NULL), udev_monitor_(NULL), registered_(false) {}
-
-bool DeviceWatcher::Start() {
- // We deliberately return true in the failure paths here because libudev is
- // not a critical component of a Linux system so it may not be present/usable,
- // and we don't want to halt DeviceManager initialization in such a case.
- if (!libudev_.Load()) {
- LOG(LS_WARNING) << "libudev not present/usable; DeviceWatcher disabled";
- return true;
- }
- udev_ = LATE(udev_new)();
- if (!udev_) {
- LOG_ERR(LS_ERROR) << "udev_new()";
- return true;
- }
- // The second argument here is the event source. It can be either "kernel" or
- // "udev", but "udev" is the only correct choice. Apps listen on udev and the
- // udev daemon in turn listens on the kernel.
- udev_monitor_ = LATE(udev_monitor_new_from_netlink)(udev_, "udev");
- if (!udev_monitor_) {
- LOG_ERR(LS_ERROR) << "udev_monitor_new_from_netlink()";
- return true;
- }
- // We only listen for changes in the video devices. Audio devices are more or
- // less unimportant because receiving device change notifications really only
- // matters for broadcasting updated send/recv capabilities based on whether
- // there is at least one device available, and almost all computers have at
- // least one audio device. Also, PulseAudio device notifications don't come
- // from the udev daemon, they come from the PulseAudio daemon, so we'd only
- // want to listen for audio device changes from udev if using ALSA. For
- // simplicity, we don't bother with any audio stuff at all.
- if (LATE(udev_monitor_filter_add_match_subsystem_devtype)(udev_monitor_,
- "video4linux",
- NULL) < 0) {
- LOG_ERR(LS_ERROR) << "udev_monitor_filter_add_match_subsystem_devtype()";
- return true;
- }
- if (LATE(udev_monitor_enable_receiving)(udev_monitor_) < 0) {
- LOG_ERR(LS_ERROR) << "udev_monitor_enable_receiving()";
- return true;
- }
- static_cast<talk_base::PhysicalSocketServer*>(
- talk_base::Thread::Current()->socketserver())->Add(this);
- registered_ = true;
- return true;
-}
-
-void DeviceWatcher::Stop() {
- if (registered_) {
- static_cast<talk_base::PhysicalSocketServer*>(
- talk_base::Thread::Current()->socketserver())->Remove(this);
- registered_ = false;
- }
- if (udev_monitor_) {
- LATE(udev_monitor_unref)(udev_monitor_);
- udev_monitor_ = NULL;
- }
- if (udev_) {
- LATE(udev_unref)(udev_);
- udev_ = NULL;
- }
- libudev_.Unload();
-}
-
-uint32 DeviceWatcher::GetRequestedEvents() {
- return talk_base::DE_READ;
-}
-
-void DeviceWatcher::OnPreEvent(uint32 ff) {
- // Nothing to do.
-}
-
-void DeviceWatcher::OnEvent(uint32 ff, int err) {
- udev_device* device = LATE(udev_monitor_receive_device)(udev_monitor_);
- if (!device) {
- // Probably the socket connection to the udev daemon was terminated (perhaps
- // the daemon crashed or is being restarted?).
- LOG_ERR(LS_WARNING) << "udev_monitor_receive_device()";
- // Stop listening to avoid potential livelock (an fd with EOF in it is
- // always considered readable).
- static_cast<talk_base::PhysicalSocketServer*>(
- talk_base::Thread::Current()->socketserver())->Remove(this);
- registered_ = false;
- return;
- }
- // Else we read the device successfully.
-
- // Since we already have our own filesystem-based device enumeration code, we
- // simply re-enumerate rather than inspecting the device event.
- LATE(udev_device_unref)(device);
- manager_->OnDevicesChange();
-}
-
-int DeviceWatcher::GetDescriptor() {
- return LATE(udev_monitor_get_fd)(udev_monitor_);
-}
-
-bool DeviceWatcher::IsDescriptorClosed() {
- // If it is closed then we will just get an error in
- // udev_monitor_receive_device and unregister, so we don't need to check for
- // it separately.
- return false;
-}
-
-#endif
-
-#if defined(CHROMEOS)
-// Checks if we want to ignore this audio device.
-static bool ShouldAudioDeviceBeIgnored(const std::string& device_name) {
- static const char* const kFilteredAudioDevicesName[] = {
- "surround40:",
- "surround41:",
- "surround50:",
- "surround51:",
- "surround71:",
- "iec958:" // S/PDIF
- };
- for (int i = 0; i < ARRAY_SIZE(kFilteredAudioDevicesName); ++i) {
- if (0 == device_name.find(kFilteredAudioDevicesName[i])) {
- LOG(LS_INFO) << "Ignoring device " << device_name;
- return true;
- }
- }
- return false;
-}
-#endif
-
-// TODO: Try to get hold of a copy of Final Cut to understand why we
-// crash while scanning their components on OS X.
-#if !defined(LINUX) && !defined(IOS)
-static bool ShouldVideoDeviceBeIgnored(const std::string& device_name) {
- static const char* const kFilteredVideoDevicesName[] = {
- "Google Camera Adapter", // Our own magiccams
-#ifdef WIN32
- "Asus virtual Camera", // Bad Asus desktop virtual cam
- "Bluetooth Video", // Bad Sony viao bluetooth sharing driver
-#elif OSX
- "DVCPRO HD", // Final cut
- "Sonix SN9C201p", // Crashes in OpenAComponent and CloseComponent
-#endif
- };
-
- for (int i = 0; i < ARRAY_SIZE(kFilteredVideoDevicesName); ++i) {
- if (strnicmp(device_name.c_str(), kFilteredVideoDevicesName[i],
- strlen(kFilteredVideoDevicesName[i])) == 0) {
- LOG(LS_INFO) << "Ignoring device " << device_name;
- return true;
- }
- }
- return false;
-}
-#endif
-
-}; // namespace cricket
+} // namespace cricket
diff --git a/talk/session/phone/devicemanager.h b/talk/session/phone/devicemanager.h
index d846ee5..3cf3554 100644
--- a/talk/session/phone/devicemanager.h
+++ b/talk/session/phone/devicemanager.h
@@ -31,26 +31,12 @@
#include <string>
#include <vector>
+#include "talk/base/scoped_ptr.h"
#include "talk/base/sigslot.h"
#include "talk/base/stringencode.h"
-#ifdef BUILD_WITH_CHROMIUM
-// The SoundSystem related code refers to some definitions that are not
-// available in chromium. (LS_VERBOSE, DISALLOW_ASSIGN etc.)
-// For now, disable the sound system code from devicemanager.h/cc.
-// TODO: Split the DeviceManager implemenations out of
-// devicemanager.h/cc so that we can exclude the DeviceManager impls from
-// libjingle build when they are not needed.
-#define NO_SOUND_SYSTEM
-#endif
-#if defined(LINUX) && !defined(NO_SOUND_SYSTEM)
-#include "talk/sound/soundsystemfactory.h"
-#endif
-
namespace cricket {
-class DeviceWatcher;
-
// Used to represent an audio or video capture or render device.
struct Device {
Device() {}
@@ -93,6 +79,14 @@
static const char kDefaultDeviceName[];
};
+class DeviceWatcher {
+ public:
+ explicit DeviceWatcher(DeviceManagerInterface* dm) {}
+ virtual ~DeviceWatcher() {}
+ virtual bool Start() { return true; }
+ virtual void Stop() {}
+};
+
class DeviceManagerFactory {
public:
static DeviceManagerInterface* Create();
@@ -122,25 +116,28 @@
virtual bool GetVideoCaptureDevices(std::vector<Device>* devs);
virtual bool GetVideoCaptureDevice(const std::string& name, Device* out);
+ // The exclusion_list MUST be a NULL terminated list.
+ static bool FilterDevices(std::vector<Device>* devices,
+ const char* const exclusion_list[]);
bool initialized() const { return initialized_; }
- void OnDevicesChange() { SignalDevicesChange(); }
protected:
+ virtual bool GetAudioDevices(bool input, std::vector<Device>* devs);
virtual bool GetAudioDevice(bool is_input, const std::string& name,
Device* out);
virtual bool GetDefaultVideoCaptureDevice(Device* device);
- private:
- bool GetAudioDevicesByPlatform(bool input, std::vector<Device>* devs);
+ void set_initialized(bool initialized) { initialized_ = initialized; }
+ void set_watcher(DeviceWatcher* watcher) { watcher_.reset(watcher); }
+ DeviceWatcher* watcher() { return watcher_.get(); }
+
+ private:
+ // The exclusion_list MUST be a NULL terminated list.
+ static bool ShouldDeviceBeIgnored(const std::string& device_name,
+ const char* const exclusion_list[]);
bool initialized_;
-#ifdef WIN32
- bool need_couninitialize_;
-#endif
- DeviceWatcher* watcher_;
-#if defined(LINUX) && !defined(NO_SOUND_SYSTEM)
- SoundSystemHandle sound_system_;
-#endif
+ talk_base::scoped_ptr<DeviceWatcher> watcher_;
};
} // namespace cricket
diff --git a/talk/session/phone/devicemanager_unittest.cc b/talk/session/phone/devicemanager_unittest.cc
new file mode 100644
index 0000000..a64eab9
--- /dev/null
+++ b/talk/session/phone/devicemanager_unittest.cc
@@ -0,0 +1,312 @@
+/*
+ * libjingle
+ * Copyright 2004--2008, 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.
+ */
+
+#ifdef WIN32
+#include "talk/base/win32.h"
+#include <objbase.h>
+#endif
+#include "talk/base/fileutils.h"
+#include "talk/base/gunit.h"
+#include "talk/base/logging.h"
+#include "talk/base/pathutils.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/stream.h"
+#include "talk/session/phone/devicemanager.h"
+#include "talk/session/phone/v4llookup.h"
+
+#ifdef LINUX
+// TODO: Figure out why this doesn't compile on Windows.
+#include "talk/base/fileutils_mock.h"
+#endif // LINUX
+
+#include "talk/session/phone/devicemanager.h"
+
+using talk_base::Pathname;
+using talk_base::FileTimeType;
+using talk_base::scoped_ptr;
+using cricket::Device;
+using cricket::DeviceManager;
+using cricket::DeviceManagerFactory;
+using cricket::DeviceManagerInterface;
+
+// Test that we startup/shutdown properly.
+TEST(DeviceManagerTest, StartupShutdown) {
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
+ EXPECT_TRUE(dm->Init());
+ dm->Terminate();
+}
+
+// Test CoInitEx behavior
+#ifdef WIN32
+TEST(DeviceManagerTest, CoInitialize) {
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
+ std::vector<Device> devices;
+ // Ensure that calls to video device work if COM is not yet initialized.
+ EXPECT_TRUE(dm->Init());
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&devices));
+ dm->Terminate();
+ // Ensure that the ref count is correct.
+ EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
+ CoUninitialize();
+ // Ensure that Init works in COINIT_APARTMENTTHREADED setting.
+ EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_APARTMENTTHREADED));
+ EXPECT_TRUE(dm->Init());
+ dm->Terminate();
+ CoUninitialize();
+ // Ensure that the ref count is correct.
+ EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_APARTMENTTHREADED));
+ CoUninitialize();
+ // Ensure that Init works in COINIT_MULTITHREADED setting.
+ EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
+ EXPECT_TRUE(dm->Init());
+ dm->Terminate();
+ CoUninitialize();
+ // Ensure that the ref count is correct.
+ EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
+ CoUninitialize();
+}
+#endif
+
+// Test enumerating devices (although we may not find any).
+TEST(DeviceManagerTest, GetDevices) {
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
+ std::vector<Device> audio_ins, audio_outs, video_ins;
+ std::vector<cricket::Device> video_in_devs;
+ cricket::Device def_video;
+ EXPECT_TRUE(dm->Init());
+ EXPECT_TRUE(dm->GetAudioInputDevices(&audio_ins));
+ EXPECT_TRUE(dm->GetAudioOutputDevices(&audio_outs));
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&video_ins));
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&video_in_devs));
+ EXPECT_EQ(video_ins.size(), video_in_devs.size());
+ // If we have any video devices, we should be able to pick a default.
+ EXPECT_TRUE(dm->GetVideoCaptureDevice(
+ cricket::DeviceManagerInterface::kDefaultDeviceName, &def_video)
+ != video_ins.empty());
+}
+
+// Test that we return correct ids for default and bogus devices.
+TEST(DeviceManagerTest, GetAudioDeviceIds) {
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
+ Device device;
+ EXPECT_TRUE(dm->Init());
+ EXPECT_TRUE(dm->GetAudioInputDevice(
+ cricket::DeviceManagerInterface::kDefaultDeviceName, &device));
+ EXPECT_EQ("-1", device.id);
+ EXPECT_TRUE(dm->GetAudioOutputDevice(
+ cricket::DeviceManagerInterface::kDefaultDeviceName, &device));
+ EXPECT_EQ("-1", device.id);
+ EXPECT_FALSE(dm->GetAudioInputDevice("_NOT A REAL DEVICE_", &device));
+ EXPECT_FALSE(dm->GetAudioOutputDevice("_NOT A REAL DEVICE_", &device));
+}
+
+// Test that we get the video capture device by name properly.
+TEST(DeviceManagerTest, GetVideoDeviceIds) {
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
+ Device device;
+ EXPECT_TRUE(dm->Init());
+ EXPECT_FALSE(dm->GetVideoCaptureDevice("_NOT A REAL DEVICE_", &device));
+ std::vector<Device> video_ins;
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&video_ins));
+ if (!video_ins.empty()) {
+ // Get the default device with the parameter kDefaultDeviceName.
+ EXPECT_TRUE(dm->GetVideoCaptureDevice(
+ cricket::DeviceManagerInterface::kDefaultDeviceName, &device));
+
+ // Get the first device with the parameter video_ins[0].name.
+ EXPECT_TRUE(dm->GetVideoCaptureDevice(video_ins[0].name, &device));
+ EXPECT_EQ(device.name, video_ins[0].name);
+ EXPECT_EQ(device.id, video_ins[0].id);
+ }
+}
+
+TEST(DeviceManagerTest, VerifyDevicesListsAreCleared) {
+ const std::string imaginary("_NOT A REAL DEVICE_");
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
+ std::vector<Device> audio_ins, audio_outs, video_ins;
+ audio_ins.push_back(Device(imaginary, imaginary));
+ audio_outs.push_back(Device(imaginary, imaginary));
+ video_ins.push_back(Device(imaginary, imaginary));
+ EXPECT_TRUE(dm->Init());
+ EXPECT_TRUE(dm->GetAudioInputDevices(&audio_ins));
+ EXPECT_TRUE(dm->GetAudioOutputDevices(&audio_outs));
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&video_ins));
+ for (size_t i = 0; i < audio_ins.size(); ++i) {
+ EXPECT_NE(imaginary, audio_ins[i].name);
+ }
+ for (size_t i = 0; i < audio_outs.size(); ++i) {
+ EXPECT_NE(imaginary, audio_outs[i].name);
+ }
+ for (size_t i = 0; i < video_ins.size(); ++i) {
+ EXPECT_NE(imaginary, video_ins[i].name);
+ }
+}
+
+static bool CompareDeviceList(std::vector<Device>& devices,
+ const char* const device_list[], int list_size) {
+ if (list_size != static_cast<int>(devices.size())) {
+ return false;
+ }
+ for (int i = 0; i < list_size; ++i) {
+ if (devices[i].name.compare(device_list[i]) != 0) {
+ return false;
+ }
+ }
+ return true;
+}
+
+TEST(DeviceManagerTest, VerifyFilterDevices) {
+ static const char* const kTotalDevicesName[] = {
+ "Google Camera Adapters are tons of fun.",
+ "device1",
+ "device2",
+ "device3",
+ "device4",
+ "device5",
+ "Google Camera Adapter 0",
+ "Google Camera Adapter 1",
+ };
+ static const char* const kFilteredDevicesName[] = {
+ "device2",
+ "device4",
+ "Google Camera Adapter",
+ NULL,
+ };
+ static const char* const kDevicesName[] = {
+ "device1",
+ "device3",
+ "device5",
+ };
+ std::vector<Device> devices;
+ for (int i = 0; i < ARRAY_SIZE(kTotalDevicesName); ++i) {
+ devices.push_back(Device(kTotalDevicesName[i], i));
+ }
+ EXPECT_TRUE(CompareDeviceList(devices, kTotalDevicesName,
+ ARRAY_SIZE(kTotalDevicesName)));
+ // Return false if given NULL as the exclusion list.
+ EXPECT_TRUE(DeviceManager::FilterDevices(&devices, NULL));
+ // The devices should not change.
+ EXPECT_TRUE(CompareDeviceList(devices, kTotalDevicesName,
+ ARRAY_SIZE(kTotalDevicesName)));
+ EXPECT_TRUE(DeviceManager::FilterDevices(&devices, kFilteredDevicesName));
+ EXPECT_TRUE(CompareDeviceList(devices, kDevicesName,
+ ARRAY_SIZE(kDevicesName)));
+}
+
+#ifdef LINUX
+class FakeV4LLookup : public cricket::V4LLookup {
+ public:
+ explicit FakeV4LLookup(std::vector<std::string> device_paths)
+ : device_paths_(device_paths) {}
+
+ protected:
+ bool CheckIsV4L2Device(const std::string& device) {
+ return std::find(device_paths_.begin(), device_paths_.end(), device)
+ != device_paths_.end();
+ }
+
+ private:
+ std::vector<std::string> device_paths_;
+};
+
+TEST(DeviceManagerTest, GetVideoCaptureDevices_K2_6) {
+ std::vector<std::string> devices;
+ devices.push_back("/dev/video0");
+ devices.push_back("/dev/video5");
+ cricket::V4LLookup::SetV4LLookup(new FakeV4LLookup(devices));
+
+ std::vector<talk_base::FakeFileSystem::File> files;
+ files.push_back(talk_base::FakeFileSystem::File("/dev/video0", ""));
+ files.push_back(talk_base::FakeFileSystem::File("/dev/video5", ""));
+ files.push_back(talk_base::FakeFileSystem::File(
+ "/sys/class/video4linux/video0/name", "Video Device 1"));
+ files.push_back(talk_base::FakeFileSystem::File(
+ "/sys/class/video4linux/video1/model", "Bad Device"));
+ files.push_back(
+ talk_base::FakeFileSystem::File("/sys/class/video4linux/video5/model",
+ "Video Device 2"));
+ talk_base::FilesystemScope fs(new talk_base::FakeFileSystem(files));
+
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
+ std::vector<Device> video_ins;
+ EXPECT_TRUE(dm->Init());
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&video_ins));
+ EXPECT_EQ(2u, video_ins.size());
+ EXPECT_EQ("Video Device 1", video_ins.at(0).name);
+ EXPECT_EQ("Video Device 2", video_ins.at(1).name);
+}
+
+TEST(DeviceManagerTest, GetVideoCaptureDevices_K2_4) {
+ std::vector<std::string> devices;
+ devices.push_back("/dev/video0");
+ devices.push_back("/dev/video5");
+ cricket::V4LLookup::SetV4LLookup(new FakeV4LLookup(devices));
+
+ std::vector<talk_base::FakeFileSystem::File> files;
+ files.push_back(talk_base::FakeFileSystem::File("/dev/video0", ""));
+ files.push_back(talk_base::FakeFileSystem::File("/dev/video5", ""));
+ files.push_back(talk_base::FakeFileSystem::File(
+ "/proc/video/dev/video0",
+ "param1: value1\nname: Video Device 1\n param2: value2\n"));
+ files.push_back(talk_base::FakeFileSystem::File(
+ "/proc/video/dev/video1",
+ "param1: value1\nname: Bad Device\n param2: value2\n"));
+ files.push_back(talk_base::FakeFileSystem::File(
+ "/proc/video/dev/video5",
+ "param1: value1\nname: Video Device 2\n param2: value2\n"));
+ talk_base::FilesystemScope fs(new talk_base::FakeFileSystem(files));
+
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
+ std::vector<Device> video_ins;
+ EXPECT_TRUE(dm->Init());
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&video_ins));
+ EXPECT_EQ(2u, video_ins.size());
+ EXPECT_EQ("Video Device 1", video_ins.at(0).name);
+ EXPECT_EQ("Video Device 2", video_ins.at(1).name);
+}
+
+TEST(DeviceManagerTest, GetVideoCaptureDevices_KUnknown) {
+ std::vector<std::string> devices;
+ devices.push_back("/dev/video0");
+ devices.push_back("/dev/video5");
+ cricket::V4LLookup::SetV4LLookup(new FakeV4LLookup(devices));
+
+ std::vector<talk_base::FakeFileSystem::File> files;
+ files.push_back(talk_base::FakeFileSystem::File("/dev/video0", ""));
+ files.push_back(talk_base::FakeFileSystem::File("/dev/video1", ""));
+ files.push_back(talk_base::FakeFileSystem::File("/dev/video5", ""));
+ talk_base::FilesystemScope fs(new talk_base::FakeFileSystem(files));
+
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
+ std::vector<Device> video_ins;
+ EXPECT_TRUE(dm->Init());
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&video_ins));
+ EXPECT_EQ(2u, video_ins.size());
+ EXPECT_EQ("/dev/video0", video_ins.at(0).name);
+ EXPECT_EQ("/dev/video5", video_ins.at(1).name);
+}
+#endif // LINUX
diff --git a/talk/session/phone/dummydevicemanager.cc b/talk/session/phone/dummydevicemanager.cc
new file mode 100644
index 0000000..5c2d1c2
--- /dev/null
+++ b/talk/session/phone/dummydevicemanager.cc
@@ -0,0 +1,36 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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/session/phone/dummydevicemanager.h"
+
+namespace cricket {
+
+DeviceManagerInterface* DeviceManagerFactory::Create() {
+ return new DummyDeviceManager();
+}
+
+}; // namespace cricket
diff --git a/talk/session/phone/dummydevicemanager_unittest.cc b/talk/session/phone/dummydevicemanager_unittest.cc
new file mode 100644
index 0000000..3fe734e
--- /dev/null
+++ b/talk/session/phone/dummydevicemanager_unittest.cc
@@ -0,0 +1,104 @@
+/*
+ * libjingle
+ * Copyright 2004--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/base/gunit.h"
+#include "talk/session/phone/dummydevicemanager.h"
+
+using cricket::Device;
+using cricket::DummyDeviceManager;
+
+// Test that we startup/shutdown properly.
+TEST(DummyDeviceManagerTest, StartupShutdown) {
+ DummyDeviceManager dm;
+ EXPECT_TRUE(dm.Init());
+ dm.Terminate();
+}
+
+// Test enumerating capabilities.
+TEST(DummyDeviceManagerTest, GetCapabilities) {
+ DummyDeviceManager dm;
+ int capabilities = dm.GetCapabilities();
+ EXPECT_EQ((cricket::AUDIO_SEND | cricket::AUDIO_RECV |
+ cricket::VIDEO_SEND | cricket::VIDEO_RECV), capabilities);
+}
+
+// Test enumerating devices.
+TEST(DummyDeviceManagerTest, GetDevices) {
+ DummyDeviceManager dm;
+ EXPECT_TRUE(dm.Init());
+ std::vector<Device> audio_ins, audio_outs, video_ins;
+ EXPECT_TRUE(dm.GetAudioInputDevices(&audio_ins));
+ EXPECT_TRUE(dm.GetAudioOutputDevices(&audio_outs));
+ EXPECT_TRUE(dm.GetVideoCaptureDevices(&video_ins));
+}
+
+// Test that we return correct ids for default and bogus devices.
+TEST(DummyDeviceManagerTest, GetAudioDeviceIds) {
+ DummyDeviceManager dm;
+ Device device;
+ EXPECT_TRUE(dm.Init());
+ EXPECT_TRUE(dm.GetAudioInputDevice(
+ cricket::DeviceManagerInterface::kDefaultDeviceName, &device));
+ EXPECT_EQ("-1", device.id);
+ EXPECT_TRUE(dm.GetAudioOutputDevice(
+ cricket::DeviceManagerInterface::kDefaultDeviceName, &device));
+ EXPECT_EQ("-1", device.id);
+ EXPECT_FALSE(dm.GetAudioInputDevice("_NOT A REAL DEVICE_", &device));
+ EXPECT_FALSE(dm.GetAudioOutputDevice("_NOT A REAL DEVICE_", &device));
+}
+
+// Test that we get the video capture device by name properly.
+TEST(DummyDeviceManagerTest, GetVideoDeviceIds) {
+ DummyDeviceManager dm;
+ Device device;
+ EXPECT_TRUE(dm.Init());
+ EXPECT_FALSE(dm.GetVideoCaptureDevice("_NOT A REAL DEVICE_", &device));
+ EXPECT_TRUE(dm.GetVideoCaptureDevice(
+ cricket::DeviceManagerInterface::kDefaultDeviceName, &device));
+}
+
+TEST(DummyDeviceManagerTest, VerifyDevicesListsAreCleared) {
+ const std::string imaginary("_NOT A REAL DEVICE_");
+ DummyDeviceManager dm;
+ std::vector<Device> audio_ins, audio_outs, video_ins;
+ audio_ins.push_back(Device(imaginary, imaginary));
+ audio_outs.push_back(Device(imaginary, imaginary));
+ video_ins.push_back(Device(imaginary, imaginary));
+ EXPECT_TRUE(dm.Init());
+ EXPECT_TRUE(dm.GetAudioInputDevices(&audio_ins));
+ EXPECT_TRUE(dm.GetAudioOutputDevices(&audio_outs));
+ EXPECT_TRUE(dm.GetVideoCaptureDevices(&video_ins));
+ for (size_t i = 0; i < audio_ins.size(); ++i) {
+ EXPECT_NE(imaginary, audio_ins[i].name);
+ }
+ for (size_t i = 0; i < audio_outs.size(); ++i) {
+ EXPECT_NE(imaginary, audio_outs[i].name);
+ }
+ for (size_t i = 0; i < video_ins.size(); ++i) {
+ EXPECT_NE(imaginary, video_ins[i].name);
+ }
+}
diff --git a/talk/session/phone/fakemediaengine.h b/talk/session/phone/fakemediaengine.h
new file mode 100644
index 0000000..b772c9c
--- /dev/null
+++ b/talk/session/phone/fakemediaengine.h
@@ -0,0 +1,831 @@
+/*
+ * libjingle
+ * Copyright 2004--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_SESSION_PHONE_FAKEMEDIAENGINE_H_
+#define TALK_SESSION_PHONE_FAKEMEDIAENGINE_H_
+
+#include <list>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "talk/base/buffer.h"
+#include "talk/p2p/base/sessiondescription.h"
+#include "talk/session/phone/mediaengine.h"
+#include "talk/session/phone/streamparams.h"
+#include "talk/session/phone/rtputils.h"
+
+namespace cricket {
+
+class FakeMediaEngine;
+class FakeVideoEngine;
+class FakeVoiceEngine;
+
+// A common helper class that handles sending and receiving RTP/RTCP packets.
+template<class Base>
+class RtpHelper : public Base {
+ public:
+ RtpHelper()
+ : options_(0),
+ sending_(false),
+ playout_(false),
+ fail_set_send_codecs_(false),
+ fail_set_recv_codecs_(false),
+ send_ssrc_(0) {
+ }
+ const std::vector<RtpHeaderExtension>& recv_extensions() {
+ return recv_extensions_;
+ }
+ const std::vector<RtpHeaderExtension>& send_extensions() {
+ return send_extensions_;
+ }
+ bool sending() const { return sending_; }
+ bool playout() const { return playout_; }
+ const std::list<std::string>& rtp_packets() const { return rtp_packets_; }
+ const std::list<std::string>& rtcp_packets() const { return rtcp_packets_; }
+ int options() const { return options_; }
+
+ bool SendRtp(const void* data, int len) {
+ if (!sending_ || !Base::network_interface_) {
+ return false;
+ }
+ talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+ return Base::network_interface_->SendPacket(&packet);
+ }
+ bool SendRtcp(const void* data, int len) {
+ if (!Base::network_interface_) {
+ return false;
+ }
+ talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+ return Base::network_interface_->SendRtcp(&packet);
+ }
+
+ bool CheckRtp(const void* data, int len) {
+ bool success = !rtp_packets_.empty();
+ if (success) {
+ std::string packet = rtp_packets_.front();
+ rtp_packets_.pop_front();
+ success = (packet == std::string(static_cast<const char*>(data), len));
+ }
+ return success;
+ }
+ bool CheckRtcp(const void* data, int len) {
+ bool success = !rtcp_packets_.empty();
+ if (success) {
+ std::string packet = rtcp_packets_.front();
+ rtcp_packets_.pop_front();
+ success = (packet == std::string(static_cast<const char*>(data), len));
+ }
+ return success;
+ }
+ bool CheckNoRtp() {
+ return rtp_packets_.empty();
+ }
+ bool CheckNoRtcp() {
+ return rtcp_packets_.empty();
+ }
+ virtual bool SetOptions(int options) {
+ options_ = options;
+ return true;
+ }
+ virtual bool SetRecvRtpHeaderExtensions(
+ const std::vector<RtpHeaderExtension>& extensions) {
+ recv_extensions_ = extensions;
+ return true;
+ }
+ virtual bool SetSendRtpHeaderExtensions(
+ const std::vector<RtpHeaderExtension>& extensions) {
+ send_extensions_ = extensions;
+ return true;
+ }
+ void set_fail_set_send_codecs(bool fail) {
+ fail_set_send_codecs_ = fail;
+ }
+ void set_fail_set_recv_codecs(bool fail) {
+ fail_set_recv_codecs_ = fail;
+ }
+ virtual bool AddSendStream(const StreamParams& sp) {
+ if (std::find(send_streams_.begin(), send_streams_.end(), sp) !=
+ send_streams_.end()) {
+ return false;
+ }
+ send_streams_.push_back(sp);
+ return true;
+ }
+ virtual bool RemoveSendStream(uint32 ssrc) {
+ return RemoveStreamBySsrc(&send_streams_, ssrc);
+ }
+ virtual bool AddRecvStream(const StreamParams& sp) {
+ if (std::find(receive_streams_.begin(), receive_streams_.end(), sp) !=
+ receive_streams_.end()) {
+ return false;
+ }
+ receive_streams_.push_back(sp);
+ return true;
+ }
+ virtual bool RemoveRecvStream(uint32 ssrc) {
+ return RemoveStreamBySsrc(&receive_streams_, ssrc);
+ }
+ const std::vector<StreamParams>& send_streams() const {
+ return send_streams_;
+ }
+ const std::vector<StreamParams>& recv_streams() const {
+ return receive_streams_;
+ }
+ bool HasRecvStream(uint32 ssrc) const {
+ return GetStreamBySsrc(receive_streams_, ssrc, NULL);
+ }
+
+ // TODO: This is to support legacy unit test that only check one
+ // sending stream.
+ const uint32 send_ssrc() {
+ if (send_streams_.empty())
+ return 0;
+ return send_streams_[0].first_ssrc();
+ }
+
+ // TODO: This is to support legacy unit test that only check one
+ // sending stream.
+ const std::string rtcp_cname() {
+ if (send_streams_.empty())
+ return "";
+ return send_streams_[0].cname;
+ }
+
+ protected:
+ bool set_sending(bool send) {
+ sending_ = send;
+ return true;
+ }
+ void set_playout(bool playout) { playout_ = playout; }
+ virtual void OnPacketReceived(talk_base::Buffer* packet) {
+ rtp_packets_.push_back(std::string(packet->data(), packet->length()));
+ }
+ virtual void OnRtcpReceived(talk_base::Buffer* packet) {
+ rtcp_packets_.push_back(std::string(packet->data(), packet->length()));
+ }
+ bool fail_set_send_codecs() const {
+ return fail_set_send_codecs_;
+ }
+ bool fail_set_recv_codecs() const {
+ return fail_set_recv_codecs_;
+ }
+
+ private:
+ int options_;
+ bool sending_;
+ bool playout_;
+ std::vector<RtpHeaderExtension> recv_extensions_;
+ std::vector<RtpHeaderExtension> send_extensions_;
+ std::list<std::string> rtp_packets_;
+ std::list<std::string> rtcp_packets_;
+ std::vector<StreamParams> send_streams_;
+ std::vector<StreamParams> receive_streams_;
+ bool fail_set_send_codecs_;
+ bool fail_set_recv_codecs_;
+ uint32 send_ssrc_;
+ std::string rtcp_cname_;
+};
+
+class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> {
+ public:
+ typedef std::pair<int, bool> DtmfEvent;
+ explicit FakeVoiceMediaChannel(FakeVoiceEngine* engine)
+ : engine_(engine),
+ muted_(false),
+ fail_set_send_(false),
+ ringback_tone_ssrc_(0),
+ ringback_tone_play_(false),
+ ringback_tone_loop_(false) {
+ output_scalings_[0] = OutputScaling(); // For default channel.
+ }
+ ~FakeVoiceMediaChannel();
+ const std::vector<AudioCodec>& recv_codecs() const { return recv_codecs_; }
+ const std::vector<AudioCodec>& send_codecs() const { return send_codecs_; }
+ const std::vector<AudioCodec>& codecs() const { return send_codecs(); }
+ bool muted() const { return muted_; }
+ const std::vector<DtmfEvent>& dtmf_queue() const { return dtmf_queue_; }
+
+ uint32 ringback_tone_ssrc() const { return ringback_tone_ssrc_; }
+ bool ringback_tone_play() const { return ringback_tone_play_; }
+ bool ringback_tone_loop() const { return ringback_tone_loop_; }
+
+ virtual bool SetRecvCodecs(const std::vector<AudioCodec> &codecs) {
+ if (fail_set_recv_codecs()) {
+ // Fake the failure in SetRecvCodecs.
+ return false;
+ }
+ recv_codecs_= codecs;
+ return true;
+ }
+ virtual bool SetSendCodecs(const std::vector<AudioCodec> &codecs) {
+ if (fail_set_send_codecs()) {
+ // Fake the failure in SetSendCodecs.
+ return false;
+ }
+ send_codecs_= codecs;
+ return true;
+ }
+ virtual bool SetPlayout(bool playout) {
+ set_playout(playout);
+ return true;
+ }
+ virtual bool SetSend(SendFlags flag) {
+ if (fail_set_send_) {
+ return false;
+ }
+ return set_sending(flag != SEND_NOTHING);
+ }
+ virtual bool SetSendBandwidth(bool autobw, int bps) { return true; }
+ virtual bool Mute(bool on) {
+ muted_ = on;
+ return true;
+ }
+ virtual bool AddRecvStream(const StreamParams& sp) {
+ if (!RtpHelper<VoiceMediaChannel>::AddRecvStream(sp))
+ return false;
+ output_scalings_[sp.first_ssrc()] = OutputScaling();
+ return true;
+ }
+ virtual bool RemoveRecvStream(uint32 ssrc) {
+ if (!RtpHelper<VoiceMediaChannel>::RemoveRecvStream(ssrc))
+ return false;
+ output_scalings_.erase(ssrc);
+ return true;
+ }
+
+ virtual bool GetActiveStreams(AudioInfo::StreamList* streams) {
+ return true;
+ }
+ virtual int GetOutputLevel() { return 0; }
+
+ virtual bool SetRingbackTone(const char *buf, int len) { return true; }
+ virtual bool PlayRingbackTone(uint32 ssrc, bool play, bool loop) {
+ ringback_tone_ssrc_ = ssrc;
+ ringback_tone_play_ = play;
+ ringback_tone_loop_ = loop;
+ return true;
+ }
+
+ virtual bool PressDTMF(int event, bool playout) {
+ dtmf_queue_.push_back(std::make_pair(event, playout));
+ return true;
+ }
+
+ virtual bool SetOutputScaling(uint32 ssrc, double left, double right) {
+ if (0 == ssrc) {
+ std::map<uint32, OutputScaling>::iterator it;
+ for (it = output_scalings_.begin(); it != output_scalings_.end(); ++it) {
+ it->second.left = left;
+ it->second.right = right;
+ }
+ return true;
+ } else if (output_scalings_.find(ssrc) != output_scalings_.end()) {
+ output_scalings_[ssrc].left = left;
+ output_scalings_[ssrc].right = right;
+ return true;
+ }
+ return false;
+ }
+ virtual bool GetOutputScaling(uint32 ssrc, double* left, double* right) {
+ if (output_scalings_.find(ssrc) == output_scalings_.end()) return false;
+ *left = output_scalings_[ssrc].left;
+ *right = output_scalings_[ssrc].right;
+ return true;
+ }
+
+ virtual bool GetStats(VoiceMediaInfo* info) { return false; }
+ virtual void GetLastMediaError(uint32* ssrc,
+ VoiceMediaChannel::Error* error) {
+ *ssrc = 0;
+ *error = fail_set_send_ ? VoiceMediaChannel::ERROR_REC_DEVICE_OPEN_FAILED
+ : VoiceMediaChannel::ERROR_NONE;
+ }
+
+ void set_fail_set_send(bool fail) { fail_set_send_ = fail; }
+ void TriggerError(uint32 ssrc, VoiceMediaChannel::Error error) {
+ VoiceMediaChannel::SignalMediaError(ssrc, error);
+ }
+
+ private:
+ struct OutputScaling {
+ OutputScaling() : left(1.0), right(1.0) {}
+ double left, right;
+ };
+
+ FakeVoiceEngine* engine_;
+ std::vector<AudioCodec> recv_codecs_;
+ std::vector<AudioCodec> send_codecs_;
+ bool muted_;
+ std::map<uint32, OutputScaling> output_scalings_;
+ std::vector<DtmfEvent> dtmf_queue_;
+ bool fail_set_send_;
+ uint32 ringback_tone_ssrc_;
+ bool ringback_tone_play_;
+ bool ringback_tone_loop_;
+};
+
+class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
+ public:
+ explicit FakeVideoMediaChannel(FakeVideoEngine* engine)
+ : engine_(engine),
+ muted_(false),
+ screen_casting_(false),
+ sent_intra_frame_(false),
+ requested_intra_frame_(false) {
+ }
+ ~FakeVideoMediaChannel();
+
+ const std::vector<VideoCodec>& recv_codecs() const { return recv_codecs_; }
+ const std::vector<VideoCodec>& send_codecs() const { return send_codecs_; }
+ const std::vector<VideoCodec>& codecs() const { return send_codecs(); }
+ bool muted() const { return muted_; }
+ bool rendering() const { return playout(); }
+ const std::map<uint32, VideoRenderer*>& renderers() const {
+ return renderers_;
+ }
+ bool GetSendStreamFormat(uint32 ssrc, VideoFormat* format) {
+ if (send_formats_.find(ssrc) == send_formats_.end()) {
+ return false;
+ }
+ *format = send_formats_[ssrc];
+ return true;
+ }
+ virtual bool SetSendStreamFormat(uint32 ssrc, const VideoFormat& format) {
+ if (send_formats_.find(ssrc) == send_formats_.end()) {
+ return false;
+ }
+ send_formats_[ssrc] = format;
+ return true;
+ }
+
+ virtual bool AddSendStream(const StreamParams& sp) {
+ if (!RtpHelper<VideoMediaChannel>::AddSendStream(sp)) {
+ return false;
+ }
+ SetSendStreamDefaultFormat(sp.first_ssrc());
+ return true;
+ }
+ virtual bool RemoveSendStream(uint32 ssrc) {
+ send_formats_.erase(ssrc);
+ return RtpHelper<VideoMediaChannel>::RemoveSendStream(ssrc);
+ }
+
+ virtual bool SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
+ if (fail_set_recv_codecs()) {
+ // Fake the failure in SetRecvCodecs.
+ return false;
+ }
+ recv_codecs_= codecs;
+ return true;
+ }
+ virtual bool SetSendCodecs(const std::vector<VideoCodec>& codecs) {
+ if (fail_set_send_codecs()) {
+ // Fake the failure in SetSendCodecs.
+ return false;
+ }
+ send_codecs_= codecs;
+
+ for (std::vector<StreamParams>::const_iterator it = send_streams().begin();
+ it != send_streams().end(); ++it) {
+ SetSendStreamDefaultFormat(it->first_ssrc());
+ }
+ return true;
+ }
+ virtual bool SetRender(bool render) {
+ set_playout(render);
+ return true;
+ }
+ virtual bool SetRenderer(uint32 ssrc, VideoRenderer* r) {
+ if (ssrc != 0 && renderers_.find(ssrc) == renderers_.end()) {
+ return false;
+ }
+ if (ssrc != 0) {
+ renderers_[ssrc] = r;
+ }
+ return true;
+ }
+
+ virtual bool SetSend(bool send) {
+ return set_sending(send);
+ }
+ virtual bool AddScreencast(uint32 ssrc, const ScreencastId& id) {
+ screen_casting_ = true;
+ return true;
+ }
+ virtual bool RemoveScreencast(uint32 ssrc) {
+ screen_casting_ = false;
+ return true;
+ }
+ virtual bool SetSendBandwidth(bool autobw, int bps) { return true; }
+ virtual bool Mute(bool on) {
+ muted_ = on;
+ return true;
+ }
+ virtual bool AddRecvStream(const StreamParams& sp) {
+ if (!RtpHelper<VideoMediaChannel>::AddRecvStream(sp))
+ return false;
+ renderers_[sp.first_ssrc()] = NULL;
+ return true;
+ }
+ virtual bool RemoveRecvStream(uint32 ssrc) {
+ if (!RtpHelper<VideoMediaChannel>::RemoveRecvStream(ssrc))
+ return false;
+ renderers_.erase(ssrc);
+ return true;
+ }
+
+ virtual bool GetStats(VideoMediaInfo* info) { return false; }
+ virtual bool SendIntraFrame() {
+ sent_intra_frame_= true;
+ return true;
+ }
+ virtual bool RequestIntraFrame() {
+ requested_intra_frame_ = true;
+ return true;
+ }
+ void set_sent_intra_frame(bool v) { sent_intra_frame_ = v; }
+ bool sent_intra_frame() const { return sent_intra_frame_; }
+ void set_requested_intra_frame(bool v) { requested_intra_frame_ = v; }
+ bool requested_intra_frame() const { return requested_intra_frame_; }
+ bool screen_casting() const { return screen_casting_; }
+
+ private:
+ // Be default, each send stream uses the first send codec format.
+ void SetSendStreamDefaultFormat(uint32 ssrc) {
+ if (!send_codecs_.empty()) {
+ send_formats_[ssrc] = VideoFormat(
+ send_codecs_[0].width,
+ send_codecs_[0].height,
+ cricket::VideoFormat::FpsToInterval(send_codecs_[0].framerate),
+ cricket::FOURCC_I420);
+ }
+ }
+
+ FakeVideoEngine* engine_;
+ std::vector<VideoCodec> recv_codecs_;
+ std::vector<VideoCodec> send_codecs_;
+ std::map<uint32, VideoRenderer*> renderers_;
+ std::map<uint32, VideoFormat> send_formats_;
+ bool muted_;
+ bool screen_casting_;
+ bool sent_intra_frame_;
+ bool requested_intra_frame_;
+};
+
+class FakeSoundclipMedia : public SoundclipMedia {
+ public:
+ virtual bool PlaySound(const char *buf, int len, int flags) {
+ return true;
+ }
+};
+
+// A base class for all of the shared parts between FakeVoiceEngine
+// and FakeVideoEngine.
+class FakeBaseEngine {
+ public:
+ FakeBaseEngine()
+ : loglevel_(-1),
+ options_(0),
+ options_changed_(false),
+ fail_create_channel_(false) {
+ }
+
+ bool Init() { return true; }
+ void Terminate() {}
+
+ bool SetOptions(int options) {
+ options_ = options;
+ options_changed_ = true;
+ return true;
+ }
+
+ void SetLogging(int level, const char* filter) {
+ loglevel_ = level;
+ logfilter_ = filter;
+ }
+
+ void set_fail_create_channel(bool fail) { fail_create_channel_ = fail; }
+
+ protected:
+ int loglevel_;
+ std::string logfilter_;
+ int options_;
+ // Flag used by optionsmessagehandler_unittest for checking whether any
+ // relevant setting has been updated.
+ // TODO: Replace with explicit checks of before & after values.
+ bool options_changed_;
+ bool fail_create_channel_;
+};
+
+class FakeVoiceEngine : public FakeBaseEngine {
+ public:
+ FakeVoiceEngine()
+ : output_volume_(-1),
+ rx_processor_(NULL),
+ tx_processor_(NULL) {
+ }
+
+ int GetCapabilities() {
+ return AUDIO_SEND | AUDIO_RECV;
+ }
+
+ VoiceMediaChannel* CreateChannel() {
+ if (fail_create_channel_) {
+ return NULL;
+ }
+
+ FakeVoiceMediaChannel* ch = new FakeVoiceMediaChannel(this);
+ channels_.push_back(ch);
+ return ch;
+ }
+ FakeVoiceMediaChannel* GetChannel(size_t index) {
+ return (channels_.size() > index) ? channels_[index] : NULL;
+ }
+ void UnregisterChannel(VoiceMediaChannel* channel) {
+ channels_.erase(std::find(channels_.begin(), channels_.end(), channel));
+ }
+ SoundclipMedia* CreateSoundclip() {
+ return new FakeSoundclipMedia();
+ }
+
+ const std::vector<AudioCodec>& codecs() {
+ return codecs_;
+ }
+ void SetCodecs(const std::vector<AudioCodec> codecs) {
+ codecs_ = codecs;
+ }
+
+ bool SetDevices(const Device* in_device,
+ const Device* out_device) {
+ in_device_ = (in_device) ? in_device->name : "";
+ out_device_ = (out_device) ? out_device->name : "";
+ options_changed_ = true;
+ return true;
+ }
+
+ bool GetOutputVolume(int* level) {
+ *level = output_volume_;
+ return true;
+ }
+
+ bool SetOutputVolume(int level) {
+ output_volume_ = level;
+ options_changed_ = true;
+ return true;
+ }
+
+ int GetInputLevel() {
+ return 0;
+ }
+
+ bool SetLocalMonitor(bool enable) {
+ return true;
+ }
+
+ bool RegisterProcessor(uint32 ssrc,
+ VoiceProcessor* voice_processor,
+ MediaProcessorDirection direction) {
+ if (direction == MPD_RX) {
+ rx_processor_ = voice_processor;
+ return true;
+ } else if (direction == MPD_TX) {
+ tx_processor_ = voice_processor;
+ return true;
+ }
+ return false;
+ }
+
+ bool UnregisterProcessor(uint32 ssrc,
+ VoiceProcessor* voice_processor,
+ MediaProcessorDirection direction) {
+ bool unregistered = false;
+ if (direction & MPD_RX) {
+ rx_processor_ = NULL;
+ unregistered = true;
+ }
+ if (direction & MPD_TX) {
+ tx_processor_ = NULL;
+ unregistered = true;
+ }
+ return unregistered;
+ }
+
+ private:
+ std::vector<FakeVoiceMediaChannel*> channels_;
+ std::vector<AudioCodec> codecs_;
+ int output_volume_;
+ std::string in_device_;
+ std::string out_device_;
+ VoiceProcessor* rx_processor_;
+ VoiceProcessor* tx_processor_;
+
+ friend class FakeMediaEngine;
+};
+
+class FakeVideoEngine : public FakeBaseEngine {
+ public:
+ FakeVideoEngine()
+ : renderer_(NULL),
+ capture_(false),
+ processor_(NULL) {
+ }
+
+ int GetCapabilities() {
+ return VIDEO_SEND | VIDEO_RECV;
+ }
+ bool SetDefaultEncoderConfig(const VideoEncoderConfig& config) {
+ default_encoder_config_ = config;
+ return true;
+ }
+ const VideoEncoderConfig& default_encoder_config() const {
+ return default_encoder_config_;
+ }
+
+ VideoMediaChannel* CreateChannel(VoiceMediaChannel* channel) {
+ if (fail_create_channel_) {
+ return NULL;
+ }
+
+ FakeVideoMediaChannel* ch = new FakeVideoMediaChannel(this);
+ channels_.push_back(ch);
+ return ch;
+ }
+ FakeVideoMediaChannel* GetChannel(size_t index) {
+ return (channels_.size() > index) ? channels_[index] : NULL;
+ }
+ void UnregisterChannel(VideoMediaChannel* channel) {
+ channels_.erase(std::find(channels_.begin(), channels_.end(), channel));
+ }
+
+ const std::vector<VideoCodec>& codecs() const {
+ return codecs_;
+ }
+ bool FindCodec(const VideoCodec& in) {
+ for (size_t i = 0; i < codecs_.size(); ++i) {
+ if (codecs_[i].Matches(in)) {
+ return true;
+ }
+ }
+ return false;
+ }
+ void SetCodecs(const std::vector<VideoCodec> codecs) {
+ codecs_ = codecs;
+ }
+
+ bool SetCaptureDevice(const Device* device) {
+ in_device_ = (device) ? device->name : "";
+ options_changed_ = true;
+ return true;
+ }
+ bool SetLocalRenderer(VideoRenderer* r) {
+ renderer_ = r;
+ return true;
+ }
+ bool SetVideoCapturer(VideoCapturer* /*capturer*/, uint32 /*ssrc*/) {
+ return false;
+ }
+ CaptureResult SetCapture(bool capture) {
+ capture_ = capture;
+ return CR_SUCCESS;
+ }
+ bool RegisterProcessor(VideoProcessor* video_processor) {
+ processor_ = video_processor;
+ return true;
+ }
+
+ bool UnregisterProcessor(VideoProcessor* video_processor) {
+ processor_ = NULL;
+ return true;
+ }
+
+ sigslot::signal2<VideoCapturer*, CaptureResult> SignalCaptureResult;
+
+ private:
+ std::vector<FakeVideoMediaChannel*> channels_;
+ std::vector<VideoCodec> codecs_;
+ VideoEncoderConfig default_encoder_config_;
+ std::string in_device_;
+ VideoRenderer* renderer_;
+ bool capture_;
+ VideoProcessor* processor_;
+
+ friend class FakeMediaEngine;
+};
+
+class FakeMediaEngine
+ : public CompositeMediaEngine<FakeVoiceEngine, FakeVideoEngine> {
+ public:
+ FakeMediaEngine() {
+ voice_ = FakeVoiceEngine();
+ video_ = FakeVideoEngine();
+ }
+ virtual ~FakeMediaEngine() {}
+
+ virtual void SetAudioCodecs(const std::vector<AudioCodec> codecs) {
+ voice_.SetCodecs(codecs);
+ }
+
+ virtual void SetVideoCodecs(const std::vector<VideoCodec> codecs) {
+ video_.SetCodecs(codecs);
+ }
+
+ FakeVoiceMediaChannel* GetVoiceChannel(size_t index) {
+ return voice_.GetChannel(index);
+ }
+
+ FakeVideoMediaChannel* GetVideoChannel(size_t index) {
+ return video_.GetChannel(index);
+ }
+
+ int audio_options() const { return voice_.options_; }
+ int output_volume() const { return voice_.output_volume_; }
+ const VideoEncoderConfig& default_video_encoder_config() const {
+ return video_.default_encoder_config_;
+ }
+ const std::string& audio_in_device() const { return voice_.in_device_; }
+ const std::string& audio_out_device() const { return voice_.out_device_; }
+ const std::string& video_in_device() const { return video_.in_device_; }
+ VideoRenderer* local_renderer() { return video_.renderer_; }
+ int voice_loglevel() const { return voice_.loglevel_; }
+ const std::string& voice_logfilter() const { return voice_.logfilter_; }
+ int video_loglevel() const { return video_.loglevel_; }
+ const std::string& video_logfilter() const { return video_.logfilter_; }
+ bool capture() const { return video_.capture_; }
+ bool options_changed() const {
+ return voice_.options_changed_ || video_.options_changed_;
+ }
+ void clear_options_changed() {
+ video_.options_changed_ = false;
+ voice_.options_changed_ = false;
+ }
+ void set_fail_create_channel(bool fail) {
+ voice_.set_fail_create_channel(fail);
+ video_.set_fail_create_channel(fail);
+ }
+ bool video_processor_registered () const {return video_.processor_ != NULL;}
+ bool voice_processor_registered(MediaProcessorDirection direction) const {
+ if (direction == MPD_RX) {
+ return voice_.rx_processor_ != NULL;
+ } else if (direction == MPD_TX) {
+ return voice_.tx_processor_ != NULL;
+ }
+ return false;
+ }
+};
+
+// CompositeMediaEngine with FakeVoiceEngine to expose SetAudioCodecs to
+// establish a media connectionwith minimum set of audio codes required
+template<class VIDEO>
+class CompositeMediaEngineWithFakeVoiceEngine
+ : public CompositeMediaEngine<FakeVoiceEngine, VIDEO> {
+ public:
+ CompositeMediaEngineWithFakeVoiceEngine() {}
+ virtual ~CompositeMediaEngineWithFakeVoiceEngine() {}
+
+ virtual void SetAudioCodecs(const std::vector<AudioCodec>& codecs) {
+ CompositeMediaEngine<FakeVoiceEngine, VIDEO>::voice_.SetCodecs(codecs);
+ }
+};
+
+// Have to come afterwards due to declaration order
+inline FakeVoiceMediaChannel::~FakeVoiceMediaChannel() {
+ if (engine_) {
+ engine_->UnregisterChannel(this);
+ }
+}
+
+inline FakeVideoMediaChannel::~FakeVideoMediaChannel() {
+ if (engine_) {
+ engine_->UnregisterChannel(this);
+ }
+}
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_FAKEMEDIAENGINE_H_
diff --git a/talk/session/phone/fakemediaprocessor.h b/talk/session/phone/fakemediaprocessor.h
new file mode 100644
index 0000000..7b88595
--- /dev/null
+++ b/talk/session/phone/fakemediaprocessor.h
@@ -0,0 +1,68 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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_SESSION_PHONE_FAKEMEDIAPROCESSOR_H_
+#define TALK_SESSION_PHONE_FAKEMEDIAPROCESSOR_H_
+
+#include "talk/session/phone/videoprocessor.h"
+#include "talk/session/phone/voiceprocessor.h"
+
+namespace cricket {
+
+class AudioFrame;
+
+class FakeMediaProcessor : public VoiceProcessor, public VideoProcessor {
+ public:
+ FakeMediaProcessor()
+ : voice_frame_count_(0),
+ video_frame_count_(0) {
+ }
+ virtual ~FakeMediaProcessor() {}
+
+ virtual void OnFrame(uint32 ssrc,
+ AudioFrame* frame) {
+ ++voice_frame_count_;
+ }
+ virtual void OnFrame(uint32 ssrc,
+ VideoFrame* frame_ptr) {
+ ++video_frame_count_;
+ }
+ virtual void OnVoiceMute(uint32 ssrc, bool muted) {}
+ virtual void OnVideoMute(uint32 ssrc, bool muted) {}
+
+ int voice_frame_count() const { return voice_frame_count_; }
+ int video_frame_count() const { return video_frame_count_; }
+
+ private:
+ // TODO: make is a map so that we can multiple ssrcs
+ int voice_frame_count_;
+ int video_frame_count_;
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_FAKEMEDIAPROCESSOR_H_
diff --git a/talk/session/phone/fakenetworkinterface.h b/talk/session/phone/fakenetworkinterface.h
new file mode 100644
index 0000000..58b24a2
--- /dev/null
+++ b/talk/session/phone/fakenetworkinterface.h
@@ -0,0 +1,173 @@
+/*
+ * libjingle
+ * Copyright 2004--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_SESSION_PHONE_FAKENETWORKINTERFACE_H_
+#define TALK_SESSION_PHONE_FAKENETWORKINTERFACE_H_
+
+#include <vector>
+
+#include "talk/base/buffer.h"
+#include "talk/base/byteorder.h"
+#include "talk/base/criticalsection.h"
+#include "talk/base/messagehandler.h"
+#include "talk/base/messagequeue.h"
+#include "talk/base/thread.h"
+#include "talk/session/phone/mediachannel.h"
+
+namespace cricket {
+
+// Fake NetworkInterface that sends/receives RTP/RTCP packets.
+class FakeNetworkInterface : public MediaChannel::NetworkInterface,
+ public talk_base::MessageHandler {
+ public:
+ FakeNetworkInterface()
+ : thread_(talk_base::Thread::Current()),
+ dest_(NULL),
+ conf_(false),
+ sendbuf_size_(-1),
+ recvbuf_size_(-1) {
+ }
+
+ void SetDestination(MediaChannel* dest) { dest_ = dest; }
+
+ // Conference mode is a mode where instead of simply forwarding the packets,
+ // the transport will send multiple copies of the packet with the specified
+ // SSRCs. This allows us to simulate receiving media from multiple sources.
+ void SetConferenceMode(bool conf, const std::vector<uint32>& ssrcs) {
+ conf_ = conf;
+ ssrcs_ = ssrcs;
+ }
+
+ int NumRtpBytes() {
+ talk_base::CritScope cs(&crit_);
+ int bytes = 0;
+ for (size_t i = 0; i < rtp_packets_.size(); ++i) {
+ bytes += rtp_packets_[i].length();
+ }
+ return bytes;
+ }
+
+ int NumRtpPackets() {
+ talk_base::CritScope cs(&crit_);
+ return rtp_packets_.size();
+ }
+
+ // Note: callers are responsible for deleting the returned buffer.
+ const talk_base::Buffer* GetRtpPacket(int index) {
+ talk_base::CritScope cs(&crit_);
+ if (index >= NumRtpPackets()) {
+ return NULL;
+ }
+ return new talk_base::Buffer(rtp_packets_[index]);
+ }
+
+ int NumRtcpPackets() {
+ talk_base::CritScope cs(&crit_);
+ return rtcp_packets_.size();
+ }
+
+ // Note: callers are responsible for deleting the returned buffer.
+ const talk_base::Buffer* GetRtcpPacket(int index) {
+ talk_base::CritScope cs(&crit_);
+ if (index >= NumRtcpPackets()) {
+ return NULL;
+ }
+ return new talk_base::Buffer(rtcp_packets_[index]);
+ }
+
+ int sendbuf_size() const { return sendbuf_size_; }
+ int recvbuf_size() const { return recvbuf_size_; }
+
+ protected:
+ virtual bool SendPacket(talk_base::Buffer* packet) {
+ talk_base::CritScope cs(&crit_);
+ rtp_packets_.push_back(*packet);
+ if (conf_) {
+ talk_base::Buffer buffer_copy(*packet);
+ for (size_t i = 0; i < ssrcs_.size(); ++i) {
+ talk_base::SetBE32(buffer_copy.data() + 8, ssrcs_[i]);
+ PostMessage(ST_RTP, buffer_copy);
+ }
+ } else {
+ PostMessage(ST_RTP, *packet);
+ }
+ return true;
+ }
+
+ virtual bool SendRtcp(talk_base::Buffer* packet) {
+ talk_base::CritScope cs(&crit_);
+ rtcp_packets_.push_back(*packet);
+ if (!conf_) {
+ // don't worry about RTCP in conf mode for now
+ PostMessage(ST_RTCP, *packet);
+ }
+ return true;
+ }
+
+ virtual int SetOption(SocketType type, talk_base::Socket::Option opt,
+ int option) {
+ if (opt == talk_base::Socket::OPT_SNDBUF) {
+ sendbuf_size_ = option;
+ } else if (opt == talk_base::Socket::OPT_RCVBUF) {
+ recvbuf_size_ = option;
+ }
+ return 0;
+ }
+
+ void PostMessage(int id, const talk_base::Buffer& packet) {
+ thread_->Post(this, id, talk_base::WrapMessageData(packet));
+ }
+
+ virtual void OnMessage(talk_base::Message* msg) {
+ talk_base::TypedMessageData<talk_base::Buffer>* msg_data =
+ static_cast<talk_base::TypedMessageData<talk_base::Buffer>*>(
+ msg->pdata);
+ if (dest_) {
+ if (msg->message_id == ST_RTP) {
+ dest_->OnPacketReceived(&msg_data->data());
+ } else {
+ dest_->OnRtcpReceived(&msg_data->data());
+ }
+ }
+ delete msg_data;
+ }
+
+ private:
+ talk_base::Thread* thread_;
+ MediaChannel* dest_;
+ bool conf_;
+ std::vector<uint32> ssrcs_;
+ talk_base::CriticalSection crit_;
+ std::vector<talk_base::Buffer> rtp_packets_;
+ std::vector<talk_base::Buffer> rtcp_packets_;
+ int sendbuf_size_;
+ int recvbuf_size_;
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_FAKENETWORKINTERFACE_H_
diff --git a/talk/session/phone/fakertp.h b/talk/session/phone/fakertp.h
new file mode 100644
index 0000000..30e3793
--- /dev/null
+++ b/talk/session/phone/fakertp.h
@@ -0,0 +1,97 @@
+/*
+ * libjingle
+ * Copyright 2004--2008, 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.
+ */
+
+// Fake RTP and RTCP packets to use in unit tests.
+
+#ifndef TALK_SESSION_PHONE_FAKERTP_H_
+#define TALK_SESSION_PHONE_FAKERTP_H_
+
+// A typical PCMU RTP packet.
+// PT=0, SN=1, TS=0, SSRC=1
+// all data FF
+static const unsigned char kPcmuFrame[] = {
+ 0x80, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+};
+
+// A typical Receiver Report RTCP packet.
+// PT=RR, LN=1, SSRC=1
+// send SSRC=2, all other fields 0
+static const unsigned char kRtcpReport[] = {
+ 0x80, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+// PT = 97, TS = 0, Seq = 1, SSRC = 2
+// H264 - NRI = 1, Type = 1, bit stream = FF
+
+static const unsigned char kH264Packet[] = {
+ 0x80, 0x61, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+ 0x21, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+};
+
+#endif // TALK_SESSION_PHONE_FAKERTP_H_
diff --git a/talk/session/phone/fakevideocapturer.h b/talk/session/phone/fakevideocapturer.h
new file mode 100644
index 0000000..335bc8d
--- /dev/null
+++ b/talk/session/phone/fakevideocapturer.h
@@ -0,0 +1,118 @@
+/*
+ * libjingle
+ * Copyright 2004--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_SESSION_PHONE_FAKEVIDEOCAPTURER_H_
+#define TALK_SESSION_PHONE_FAKEVIDEOCAPTURER_H_
+
+#include <vector>
+
+#include "talk/session/phone/videocapturer.h"
+#include "talk/session/phone/videocommon.h"
+#include "talk/session/phone/videoframe.h"
+
+namespace cricket {
+
+// Fake video capturer that allows the test to manually pump in frames.
+class FakeVideoCapturer : public cricket::VideoCapturer {
+ public:
+ FakeVideoCapturer()
+ : running_(false),
+ next_timestamp_(0) {
+ // Default supported formats. Use ResetSupportedFormats to over write.
+ std::vector<cricket::VideoFormat> formats;
+ formats.push_back(cricket::VideoFormat(640, 480,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ formats.push_back(cricket::VideoFormat(320, 240,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ formats.push_back(cricket::VideoFormat(160, 120,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ ResetSupportedFormats(formats);
+ }
+ ~FakeVideoCapturer() {
+ SignalDestroyed(this);
+ }
+
+ void ResetSupportedFormats(const std::vector<cricket::VideoFormat>& formats) {
+ SetSupportedFormats(formats);
+ }
+ bool CaptureFrame() {
+ if (!GetCaptureFormat()) {
+ return false;
+ }
+ return CaptureCustomFrame(GetCaptureFormat()->width,
+ GetCaptureFormat()->height,
+ GetCaptureFormat()->fourcc);
+ }
+ bool CaptureCustomFrame(int width, int height, uint32 fourcc) {
+ if (!running_) {
+ return false;
+ }
+
+ // Currently, |fourcc| is always I420.
+ uint32 size = cricket::VideoFrame::SizeOf(width, height);
+ cricket::CapturedFrame frame;
+ frame.width = width;
+ frame.height = height;
+ frame.fourcc = fourcc;
+ frame.data_size = size;
+ frame.elapsed_time = frame.time_stamp = next_timestamp_;
+ next_timestamp_ += 33333333; // 30 fps
+
+ talk_base::scoped_array<char> data(new char[size]);
+ memset(data.get(), 0, size);
+ frame.data = data.get();
+ SignalFrameCaptured(this, &frame);
+ return true;
+ }
+ sigslot::signal1<FakeVideoCapturer*> SignalDestroyed;
+
+ virtual cricket::CaptureResult Start(const cricket::VideoFormat& format) {
+ cricket::VideoFormat supported;
+ if (GetBestCaptureFormat(format, &supported)) {
+ SetCaptureFormat(&supported);
+ }
+ running_ = true;
+ return cricket::CR_SUCCESS;
+ }
+ virtual void Stop() {
+ running_ = false;
+ SetCaptureFormat(NULL);
+ }
+ virtual bool IsRunning() { return running_; }
+ bool GetPreferredFourccs(std::vector<uint32>* fourccs) {
+ fourccs->push_back(cricket::FOURCC_I420);
+ return true;
+ }
+
+ private:
+ bool running_;
+ int64 next_timestamp_;
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_FAKEVIDEOCAPTURER_H_
diff --git a/talk/session/phone/fakevideorenderer.h b/talk/session/phone/fakevideorenderer.h
new file mode 100644
index 0000000..3227fa4
--- /dev/null
+++ b/talk/session/phone/fakevideorenderer.h
@@ -0,0 +1,77 @@
+/*
+ * 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_SESSION_PHONE_FAKEVIDEORENDERER_H_
+#define TALK_SESSION_PHONE_FAKEVIDEORENDERER_H_
+
+#include "talk/base/sigslot.h"
+#include "talk/session/phone/videorenderer.h"
+
+namespace cricket {
+
+// Faked video renderer that has a callback for actions on rendering.
+class FakeVideoRenderer : public VideoRenderer {
+ public:
+ FakeVideoRenderer()
+ : width_(0),
+ height_(0),
+ num_set_sizes_(0),
+ num_rendered_frames_(0) {
+ }
+
+ virtual bool SetSize(int width, int height, int reserved) {
+ width_ = width;
+ height_ = height;
+ ++num_set_sizes_;
+ SignalSetSize(width, height, reserved);
+ return true;
+ }
+
+ virtual bool RenderFrame(const VideoFrame* frame) {
+ ++num_rendered_frames_;
+ SignalRenderFrame(frame);
+ return true;
+ }
+
+ int width() const { return width_; }
+ int height() const { return height_; }
+ int num_set_sizes() const { return num_set_sizes_; }
+ int num_rendered_frames() const { return num_rendered_frames_; }
+
+ sigslot::signal3<int, int, int> SignalSetSize;
+ sigslot::signal1<const VideoFrame*> SignalRenderFrame;
+
+ private:
+ int width_;
+ int height_;
+ int num_set_sizes_;
+ int num_rendered_frames_;
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_FAKEVIDEORENDERER_H_
diff --git a/talk/session/phone/fakewebrtccommon.h b/talk/session/phone/fakewebrtccommon.h
new file mode 100644
index 0000000..a960e8b
--- /dev/null
+++ b/talk/session/phone/fakewebrtccommon.h
@@ -0,0 +1,55 @@
+/*
+ * 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_SESSION_PHONE_FAKEWEBRTCCOMMON_H_
+#define TALK_SESSION_PHONE_FAKEWEBRTCCOMMON_H_
+
+namespace cricket {
+
+#define WEBRTC_STUB(method, args) \
+ virtual int method args { return 0; }
+
+#define WEBRTC_STUB_CONST(method, args) \
+ virtual int method args const { return 0; }
+
+#define WEBRTC_FUNC(method, args) \
+ virtual int method args
+
+#define WEBRTC_FUNC_CONST(method, args) \
+ virtual int method args const
+
+#define WEBRTC_BOOL_FUNC(method, args) \
+ virtual bool method args
+
+#define WEBRTC_CHECK_CHANNEL(channel) \
+ if (channels_.find(channel) == channels_.end()) return -1;
+
+#define WEBRTC_ASSERT_CHANNEL(channel) \
+ ASSERT(channels_.find(channel) != channels_.end());
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_FAKEWEBRTCCOMMON_H_
diff --git a/talk/session/phone/fakewebrtcdeviceinfo.h b/talk/session/phone/fakewebrtcdeviceinfo.h
new file mode 100644
index 0000000..c969236
--- /dev/null
+++ b/talk/session/phone/fakewebrtcdeviceinfo.h
@@ -0,0 +1,123 @@
+// libjingle
+// Copyright 2004--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_SESSION_PHONE_FAKEWEBRTCDEVICEINFO_H_
+#define TALK_SESSION_PHONE_FAKEWEBRTCDEVICEINFO_H_
+
+#include <vector>
+
+#include "talk/base/stringutils.h"
+#include "talk/session/phone/webrtcvideocapturer.h"
+
+// Fake class for mocking out webrtc::VideoCaptureModule::DeviceInfo.
+class FakeWebRtcDeviceInfo : public webrtc::VideoCaptureModule::DeviceInfo {
+ public:
+ struct Device {
+ Device(const std::string& n, const std::string& i) : name(n), id(i) {}
+ std::string name;
+ std::string id;
+ std::string product;
+ std::vector<webrtc::VideoCaptureCapability> caps;
+ };
+ FakeWebRtcDeviceInfo() {}
+ void AddDevice(const std::string& device_name, const std::string& device_id) {
+ devices_.push_back(Device(device_name, device_id));
+ }
+ void AddCapability(const std::string& device_id,
+ const webrtc::VideoCaptureCapability& cap) {
+ Device* dev = GetDeviceById(
+ reinterpret_cast<const WebRtc_UWord8*>(device_id.c_str()));
+ if (!dev) return;
+ dev->caps.push_back(cap);
+ }
+ virtual WebRtc_UWord32 NumberOfDevices() {
+ return devices_.size();
+ }
+ virtual WebRtc_Word32 GetDeviceName(WebRtc_UWord32 device_num,
+ WebRtc_UWord8* device_name,
+ WebRtc_UWord32 device_name_len,
+ WebRtc_UWord8* device_id,
+ WebRtc_UWord32 device_id_len,
+ WebRtc_UWord8* product_id,
+ WebRtc_UWord32 product_id_len) {
+ Device* dev = GetDeviceByIndex(device_num);
+ if (!dev) return -1;
+ talk_base::strcpyn(reinterpret_cast<char*>(device_name), device_name_len,
+ dev->name.c_str());
+ talk_base::strcpyn(reinterpret_cast<char*>(device_id), device_id_len,
+ dev->id.c_str());
+ if (product_id) {
+ talk_base::strcpyn(reinterpret_cast<char*>(product_id), product_id_len,
+ dev->product.c_str());
+ }
+ return 0;
+ }
+ virtual WebRtc_Word32 NumberOfCapabilities(const WebRtc_UWord8* device_id) {
+ Device* dev = GetDeviceById(device_id);
+ if (!dev) return -1;
+ return dev->caps.size();
+ }
+ virtual WebRtc_Word32 GetCapability(const WebRtc_UWord8* device_id,
+ const WebRtc_UWord32 device_cap_num,
+ webrtc::VideoCaptureCapability& cap) {
+ Device* dev = GetDeviceById(device_id);
+ if (!dev) return -1;
+ if (device_cap_num >= dev->caps.size()) return -1;
+ cap = dev->caps[device_cap_num];
+ return 0;
+ }
+ virtual WebRtc_Word32 GetOrientation(const WebRtc_UWord8* device_id,
+ webrtc::VideoCaptureRotation& rotation) {
+ return -1; // not implemented
+ }
+ virtual WebRtc_Word32 GetBestMatchedCapability(
+ const WebRtc_UWord8* device_id,
+ const webrtc::VideoCaptureCapability requested,
+ webrtc::VideoCaptureCapability& resulting) {
+ return -1; // not implemented
+ }
+ virtual WebRtc_Word32 DisplayCaptureSettingsDialogBox(
+ const WebRtc_UWord8* device_id, const WebRtc_UWord8* dialog_title,
+ void* parent, WebRtc_UWord32 x, WebRtc_UWord32 y) {
+ return -1; // not implemented
+ }
+
+ Device* GetDeviceByIndex(size_t num) {
+ return (num < devices_.size()) ? &devices_[num] : NULL;
+ }
+ Device* GetDeviceById(const WebRtc_UWord8* device_id) {
+ for (size_t i = 0; i < devices_.size(); ++i) {
+ if (devices_[i].id == reinterpret_cast<const char*>(device_id)) {
+ return &devices_[i];
+ }
+ }
+ return NULL;
+ }
+
+ private:
+ std::vector<Device> devices_;
+};
+
+#endif // TALK_SESSION_PHONE_FAKEWEBRTCDEVICEINFO_H_
diff --git a/talk/session/phone/fakewebrtcvcmfactory.h b/talk/session/phone/fakewebrtcvcmfactory.h
new file mode 100644
index 0000000..e5c660c
--- /dev/null
+++ b/talk/session/phone/fakewebrtcvcmfactory.h
@@ -0,0 +1,63 @@
+// libjingle
+// Copyright 2004--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_SESSION_PHONE_FAKEWEBRTCVCMFACTORY_H_
+#define TALK_SESSION_PHONE_FAKEWEBRTCVCMFACTORY_H_
+
+#include <vector>
+
+#include "talk/session/phone/fakewebrtcvideocapturemodule.h"
+#include "talk/session/phone/webrtcvideocapturer.h"
+
+// Factory class to allow the fakes above to be injected into
+// WebRtcVideoCapturer.
+class FakeWebRtcVcmFactory : public cricket::WebRtcVcmFactoryInterface {
+ public:
+ virtual webrtc::VideoCaptureModule* Create(int module_id,
+ const WebRtc_UWord8* device_id) {
+ if (!device_info.GetDeviceById(device_id)) return NULL;
+ FakeWebRtcVideoCaptureModule* module =
+ new FakeWebRtcVideoCaptureModule(this, module_id);
+ modules.push_back(module);
+ return module;
+ }
+ virtual webrtc::VideoCaptureModule::DeviceInfo* CreateDeviceInfo(int id) {
+ return &device_info;
+ }
+ virtual void DestroyDeviceInfo(webrtc::VideoCaptureModule::DeviceInfo* info) {
+ }
+ void OnDestroyed(webrtc::VideoCaptureModule* module) {
+ std::remove(modules.begin(), modules.end(), module);
+ }
+ FakeWebRtcDeviceInfo device_info;
+ std::vector<FakeWebRtcVideoCaptureModule*> modules;
+};
+
+FakeWebRtcVideoCaptureModule::~FakeWebRtcVideoCaptureModule() {
+ if (factory_)
+ factory_->OnDestroyed(this);
+}
+
+#endif // TALK_SESSION_PHONE_FAKEWEBRTCVCMFACTORY_H_
diff --git a/talk/session/phone/fakewebrtcvideocapturemodule.h b/talk/session/phone/fakewebrtcvideocapturemodule.h
new file mode 100644
index 0000000..e3d7db1
--- /dev/null
+++ b/talk/session/phone/fakewebrtcvideocapturemodule.h
@@ -0,0 +1,169 @@
+// libjingle
+// Copyright 2004--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_SESSION_PHONE_FAKEWEBRTCVIDEOCAPTUREMODULE_H_
+#define TALK_SESSION_PHONE_FAKEWEBRTCVIDEOCAPTUREMODULE_H_
+
+#include <vector>
+
+#include "talk/session/phone/testutils.h"
+#include "talk/session/phone/fakewebrtcdeviceinfo.h"
+#include "talk/session/phone/webrtcvideocapturer.h"
+
+class FakeWebRtcVcmFactory;
+
+// Fake class for mocking out webrtc::VideoCaptureModule.
+class FakeWebRtcVideoCaptureModule : public webrtc::VideoCaptureModule {
+ public:
+ FakeWebRtcVideoCaptureModule(FakeWebRtcVcmFactory* factory, WebRtc_Word32 id)
+ : factory_(factory),
+ id_(id),
+ callback_(NULL),
+ running_(false),
+ delay_(0) {
+ }
+ virtual int32_t Version(char* version,
+ uint32_t& remaining_buffer_in_bytes,
+ uint32_t& position) const {
+ return 0;
+ }
+ virtual int32_t TimeUntilNextProcess() {
+ return 0;
+ }
+ virtual int32_t Process() {
+ return 0;
+ }
+ virtual WebRtc_Word32 ChangeUniqueId(const WebRtc_Word32 id) {
+ id_ = id;
+ return 0;
+ }
+ virtual WebRtc_Word32 RegisterCaptureDataCallback(
+ webrtc::VideoCaptureDataCallback& callback) {
+ callback_ = &callback;
+ return 0;
+ }
+ virtual WebRtc_Word32 DeRegisterCaptureDataCallback() {
+ callback_ = NULL;
+ return 0;
+ }
+ virtual WebRtc_Word32 RegisterCaptureCallback(
+ webrtc::VideoCaptureFeedBack& callback) {
+ return -1; // not implemented
+ }
+ virtual WebRtc_Word32 DeRegisterCaptureCallback() {
+ return 0;
+ }
+ virtual WebRtc_Word32 StartCapture(
+ const webrtc::VideoCaptureCapability& cap) {
+ if (running_) return -1;
+ cap_ = cap;
+ running_ = true;
+ return 0;
+ }
+ virtual WebRtc_Word32 StopCapture() {
+ running_ = false;
+ return 0;
+ }
+ virtual WebRtc_Word32 StartSendImage(const webrtc::VideoFrame& frame,
+ WebRtc_Word32 framerate) {
+ return -1; // not implemented
+ }
+ virtual WebRtc_Word32 StopSendImage() {
+ return 0;
+ }
+ virtual const WebRtc_UWord8* CurrentDeviceName() const {
+ return NULL; // not implemented
+ }
+ virtual bool CaptureStarted() {
+ return running_;
+ }
+ virtual WebRtc_Word32 CaptureSettings(
+ webrtc::VideoCaptureCapability& settings) {
+ if (!running_) return -1;
+ settings = cap_;
+ return 0;
+ }
+ virtual WebRtc_Word32 SetCaptureDelay(WebRtc_Word32 delay) {
+ delay_ = delay;
+ return 0;
+ }
+ virtual WebRtc_Word32 CaptureDelay() {
+ return delay_;
+ }
+ virtual WebRtc_Word32 SetCaptureRotation(
+ webrtc::VideoCaptureRotation rotation) {
+ return -1; // not implemented
+ }
+ virtual VideoCaptureEncodeInterface* GetEncodeInterface(
+ const webrtc::VideoCodec& codec) {
+ return NULL; // not implemented
+ }
+ virtual WebRtc_Word32 EnableFrameRateCallback(const bool enable) {
+ return -1; // not implemented
+ }
+ virtual WebRtc_Word32 EnableNoPictureAlarm(const bool enable) {
+ return -1; // not implemented
+ }
+ virtual int32_t AddRef() {
+ return 0;
+ }
+ virtual int32_t Release() {
+ delete this;
+ return 0;
+ }
+
+ bool SendFrame(int w, int h) {
+ if (!running_) return false;
+ webrtc::VideoFrame sample;
+ sample.SetWidth(w);
+ sample.SetHeight(h);
+ if (sample.VerifyAndAllocate(I420_SIZE(w, h)) == -1 ||
+ sample.SetLength(sample.Size()) == -1) {
+ return false;
+ }
+ if (callback_) {
+ callback_->OnIncomingCapturedFrame(id_, sample,
+ webrtc::kVideoCodecUnknown);
+ }
+ return true;
+ }
+
+ const webrtc::VideoCaptureCapability& cap() const {
+ return cap_;
+ }
+
+ private:
+ // Ref-counted, use Release() instead.
+ ~FakeWebRtcVideoCaptureModule();
+
+ FakeWebRtcVcmFactory* factory_;
+ int id_;
+ webrtc::VideoCaptureDataCallback* callback_;
+ bool running_;
+ webrtc::VideoCaptureCapability cap_;
+ int delay_;
+};
+
+#endif // TALK_SESSION_PHONE_FAKEWEBRTCVIDEOCAPTUREMODULE_H_
diff --git a/talk/session/phone/fakewebrtcvideoengine.h b/talk/session/phone/fakewebrtcvideoengine.h
new file mode 100644
index 0000000..cbac785
--- /dev/null
+++ b/talk/session/phone/fakewebrtcvideoengine.h
@@ -0,0 +1,628 @@
+/*
+ * libjingle
+ * Copyright 2010, 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_SESSION_PHONE_FAKEWEBRTCVIDEOENGINE_H_
+#define TALK_SESSION_PHONE_FAKEWEBRTCVIDEOENGINE_H_
+
+#include <list>
+#include <map>
+#include <vector>
+
+#include "talk/base/basictypes.h"
+#include "talk/base/stringutils.h"
+#include "talk/session/phone/codec.h"
+#include "talk/session/phone/fakewebrtccommon.h"
+#include "talk/session/phone/webrtcvie.h"
+
+namespace webrtc {
+
+bool operator==(const webrtc::VideoCodec& c1, const webrtc::VideoCodec& c2) {
+ return memcmp(&c1, &c2, sizeof(c1)) == 0;
+}
+
+}
+
+namespace cricket {
+
+#define WEBRTC_CHECK_CAPTURER(capturer) \
+ if (capturers_.find(capturer) == capturers_.end()) return -1;
+
+#define WEBRTC_ASSERT_CAPTURER(capturer) \
+ ASSERT(capturers_.find(capturer) != capturers_.end());
+
+static const int kStartVideoBitrate = 300;
+static const int kMaxVideoBitrate = 1000;
+
+// WebRtc channel id and capture id share the same number space.
+// This is how AddRenderer(renderId, ...) is able to tell if it is adding a
+// renderer for a channel or it is adding a renderer for a capturer.
+static const int kViEChannelIdBase = 0;
+static const int kViEChannelIdMax = 1000;
+static const int kViECaptureIdBase = 10000; // Make sure there is a gap.
+static const int kViECaptureIdMax = 11000;
+
+class FakeWebRtcVideoEngine
+ : public webrtc::ViEBase,
+ public webrtc::ViECodec,
+ public webrtc::ViECapture,
+ public webrtc::ViENetwork,
+ public webrtc::ViERender,
+ public webrtc::ViERTP_RTCP,
+ public webrtc::ViEImageProcess {
+ public:
+ struct Channel {
+ Channel()
+ : capture_id_(-1),
+ has_renderer_(false),
+ render_started_(false),
+ send(false),
+ local_ssrc_(0),
+ rtcp_status_(webrtc::kRtcpNone),
+ key_frame_request_method_(webrtc::kViEKeyFrameRequestNone),
+ tmmbr_(false),
+ remb_send_(false),
+ remb_(false),
+ nack_(false),
+ hybrid_nack_fec_(false) {
+ memset(&send_codec, 0, sizeof(send_codec));
+ }
+ int capture_id_;
+ bool has_renderer_;
+ bool render_started_;
+ bool send;
+ int local_ssrc_;
+ std::string cname_;
+ webrtc::ViERTCPMode rtcp_status_;
+ webrtc::ViEKeyFrameRequestMethod key_frame_request_method_;
+ bool tmmbr_;
+ bool remb_send_; // This channel send REMB packets.
+ bool remb_; // This channel report BWE using remb.
+ bool nack_;
+ bool hybrid_nack_fec_;
+ std::vector<webrtc::VideoCodec> recv_codecs;
+ webrtc::VideoCodec send_codec;
+ };
+ class Capturer : public webrtc::ViEExternalCapture {
+ public:
+ Capturer() : channel_id_(-1) { }
+ int channel_id() const { return channel_id_; }
+ void set_channel_id(int channel_id) { channel_id_ = channel_id; }
+
+ // From ViEExternalCapture
+ virtual int IncomingFrame(unsigned char* videoFrame,
+ unsigned int videoFrameLength,
+ unsigned short width,
+ unsigned short height,
+ webrtc::RawVideoType videoType,
+ unsigned long long captureTime) {
+ return 0;
+ }
+ virtual int IncomingFrameI420(
+ const webrtc::ViEVideoFrameI420& video_frame,
+ unsigned long long captureTime) {
+ return 0;
+ }
+
+ private:
+ int channel_id_;
+ };
+
+ FakeWebRtcVideoEngine(const cricket::VideoCodec* const* codecs,
+ int num_codecs)
+ : inited_(false),
+ last_channel_(kViEChannelIdBase - 1),
+ fail_create_channel_(false),
+ last_capturer_(kViECaptureIdBase - 1),
+ fail_alloc_capturer_(false),
+ codecs_(codecs),
+ num_codecs_(num_codecs) {
+ }
+
+ ~FakeWebRtcVideoEngine() {
+ ASSERT(0 == channels_.size());
+ ASSERT(0 == capturers_.size());
+ }
+ bool IsInited() const { return inited_; }
+
+ int GetLastChannel() const { return last_channel_; }
+ int GetNumChannels() const { return channels_.size(); }
+ void set_fail_create_channel(bool fail_create_channel) {
+ fail_create_channel_ = fail_create_channel;
+ }
+
+ int GetLastCapturer() const { return last_capturer_; }
+ int GetNumCapturers() const { return capturers_.size(); }
+ void set_fail_alloc_capturer(bool fail_alloc_capturer) {
+ fail_alloc_capturer_ = fail_alloc_capturer;
+ }
+
+ int GetCaptureId(int channel) const {
+ WEBRTC_ASSERT_CHANNEL(channel);
+ return channels_.find(channel)->second->capture_id_;
+ }
+ bool GetHasRenderer(int channel) const {
+ WEBRTC_ASSERT_CHANNEL(channel);
+ return channels_.find(channel)->second->has_renderer_;
+ }
+ bool GetRenderStarted(int channel) const {
+ WEBRTC_ASSERT_CHANNEL(channel);
+ return channels_.find(channel)->second->render_started_;
+ }
+ bool GetSend(int channel) const {
+ WEBRTC_ASSERT_CHANNEL(channel);
+ return channels_.find(channel)->second->send;
+ }
+ int GetCaptureChannelId(int capture_id) const {
+ WEBRTC_ASSERT_CAPTURER(capture_id);
+ return capturers_.find(capture_id)->second->channel_id();
+ }
+ webrtc::ViERTCPMode GetRtcpStatus(int channel) const {
+ WEBRTC_ASSERT_CHANNEL(channel);
+ return channels_.find(channel)->second->rtcp_status_;
+ }
+ webrtc::ViEKeyFrameRequestMethod GetKeyFrameRequestMethod(int channel) const {
+ WEBRTC_ASSERT_CHANNEL(channel);
+ return channels_.find(channel)->second->key_frame_request_method_;
+ }
+ bool GetTmmbrStatus(int channel) const {
+ WEBRTC_ASSERT_CHANNEL(channel);
+ return channels_.find(channel)->second->tmmbr_;
+ }
+ bool GetRembStatus(int channel) const {
+ WEBRTC_ASSERT_CHANNEL(channel);
+ return channels_.find(channel)->second->remb_;
+ }
+ bool GetRembStatusSend(int channel) const {
+ WEBRTC_ASSERT_CHANNEL(channel);
+ return channels_.find(channel)->second->remb_send_;
+ }
+ bool GetNackStatus(int channel) const {
+ WEBRTC_ASSERT_CHANNEL(channel);
+ return channels_.find(channel)->second->nack_;
+ }
+ bool GetHybridNackFecStatus(int channel) const {
+ WEBRTC_ASSERT_CHANNEL(channel);
+ return channels_.find(channel)->second->hybrid_nack_fec_;
+ }
+
+ bool ReceiveCodecRegistered(int channel,
+ const webrtc::VideoCodec& codec) const {
+ WEBRTC_ASSERT_CHANNEL(channel);
+ const std::vector<webrtc::VideoCodec>& codecs =
+ channels_.find(channel)->second->recv_codecs;
+ return std::find(codecs.begin(), codecs.end(), codec) != codecs.end();
+ };
+
+ WEBRTC_STUB(Release, ());
+
+ // webrtc::ViEBase
+ WEBRTC_FUNC(Init, ()) {
+ inited_ = true;
+ return 0;
+ };
+ WEBRTC_STUB(SetVoiceEngine, (webrtc::VoiceEngine*));
+ WEBRTC_FUNC(CreateChannel, (int& channel)) { // NOLINT
+ if (fail_create_channel_) {
+ return -1;
+ }
+ if (kViEChannelIdMax == last_channel_) {
+ return -1;
+ }
+ Channel* ch = new Channel();
+ channels_[++last_channel_] = ch;
+ channel = last_channel_;
+ return 0;
+ };
+ WEBRTC_STUB(CreateChannel, (int&, int));
+ WEBRTC_FUNC(DeleteChannel, (const int channel)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ delete channels_[channel];
+ channels_.erase(channel);
+ return 0;
+ }
+ WEBRTC_STUB(ConnectAudioChannel, (const int, const int));
+ WEBRTC_STUB(DisconnectAudioChannel, (const int));
+ WEBRTC_FUNC(StartSend, (const int channel)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->send = true;
+ return 0;
+ }
+ WEBRTC_FUNC(StopSend, (const int channel)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->send = false;
+ return 0;
+ }
+ WEBRTC_STUB(StartReceive, (const int));
+ WEBRTC_STUB(StopReceive, (const int));
+ WEBRTC_STUB(RegisterObserver, (webrtc::ViEBaseObserver&));
+ WEBRTC_STUB(DeregisterObserver, ());
+ WEBRTC_STUB(GetVersion, (char version[1024]));
+ WEBRTC_STUB(LastError, ());
+
+ // webrtc::ViECodec
+ WEBRTC_FUNC(NumberOfCodecs, ()) const {
+ return num_codecs_;
+ };
+ WEBRTC_FUNC(GetCodec, (const unsigned char list_number,
+ webrtc::VideoCodec& out_codec)) const {
+ if (list_number >= NumberOfCodecs()) {
+ return -1;
+ }
+ memset(&out_codec, 0, sizeof(out_codec));
+ const cricket::VideoCodec& c(*codecs_[list_number]);
+ if ("I420" == c.name) {
+ out_codec.codecType = webrtc::kVideoCodecI420;
+ } else if ("VP8" == c.name) {
+ out_codec.codecType = webrtc::kVideoCodecVP8;
+ } else if ("red" == c.name) {
+ out_codec.codecType = webrtc::kVideoCodecRED;
+ } else if ("ulpfec" == c.name) {
+ out_codec.codecType = webrtc::kVideoCodecULPFEC;
+ } else {
+ out_codec.codecType = webrtc::kVideoCodecUnknown;
+ }
+ talk_base::strcpyn(out_codec.plName, sizeof(out_codec.plName),
+ c.name.c_str());
+ out_codec.plType = c.id;
+ out_codec.width = c.width;
+ out_codec.height = c.height;
+ out_codec.startBitrate = kStartVideoBitrate;
+ out_codec.maxBitrate = kMaxVideoBitrate;
+ out_codec.minBitrate = kStartVideoBitrate;
+ out_codec.maxFramerate = c.framerate;
+ return 0;
+ };
+ WEBRTC_FUNC(SetSendCodec, (const int channel,
+ const webrtc::VideoCodec& codec)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->send_codec = codec;
+ return 0;
+ };
+ WEBRTC_FUNC(GetSendCodec, (const int channel,
+ webrtc::VideoCodec& codec)) const { // NOLINT
+ WEBRTC_CHECK_CHANNEL(channel);
+ codec = channels_.find(channel)->second->send_codec;
+ return 0;
+ };
+ WEBRTC_FUNC(SetReceiveCodec, (const int channel,
+ const webrtc::VideoCodec& codec)) { // NOLINT
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->recv_codecs.push_back(codec);
+ return 0;
+ };
+ WEBRTC_STUB_CONST(GetReceiveCodec, (const int, webrtc::VideoCodec&));
+ WEBRTC_STUB_CONST(GetCodecConfigParameters, (const int,
+ unsigned char*, unsigned char&));
+ WEBRTC_STUB(SetImageScaleStatus, (const int, const bool));
+ WEBRTC_STUB_CONST(GetSendCodecStastistics, (const int,
+ unsigned int&, unsigned int&));
+ WEBRTC_STUB_CONST(GetReceiveCodecStastistics, (const int,
+ unsigned int&, unsigned int&));
+ virtual unsigned int GetDiscardedPackets(const int channel) const {
+ return 0;
+ }
+
+ WEBRTC_STUB(SetKeyFrameRequestCallbackStatus, (const int, const bool));
+ WEBRTC_STUB(SetSignalKeyPacketLossStatus, (const int, const bool,
+ const bool));
+ WEBRTC_STUB(RegisterEncoderObserver, (const int,
+ webrtc::ViEEncoderObserver&));
+ WEBRTC_STUB(DeregisterEncoderObserver, (const int));
+ WEBRTC_STUB(RegisterDecoderObserver, (const int,
+ webrtc::ViEDecoderObserver&));
+ WEBRTC_STUB(DeregisterDecoderObserver, (const int));
+ WEBRTC_STUB(SendKeyFrame, (const int));
+ WEBRTC_STUB(WaitForFirstKeyFrame, (const int, const bool));
+ WEBRTC_STUB(SetInverseH263Logic, (int, bool));
+
+ // webrtc::ViECapture
+ WEBRTC_STUB(NumberOfCaptureDevices, ());
+ WEBRTC_STUB(GetCaptureDevice, (unsigned int, char*,
+ const unsigned int, char*, const unsigned int));
+ WEBRTC_STUB(AllocateCaptureDevice, (const char*, const unsigned int, int&));
+ WEBRTC_FUNC(AllocateExternalCaptureDevice,
+ (int& capture_id, webrtc::ViEExternalCapture*& capture)) {
+ if (fail_alloc_capturer_) {
+ return -1;
+ }
+ if (kViECaptureIdMax == last_capturer_) {
+ return -1;
+ }
+ Capturer* cap = new Capturer();
+ capturers_[++last_capturer_] = cap;
+ capture_id = last_capturer_;
+ capture = cap;
+ return 0;
+ }
+ WEBRTC_STUB(AllocateCaptureDevice, (webrtc::VideoCaptureModule&, int&));
+ WEBRTC_FUNC(ReleaseCaptureDevice, (const int capture_id)) {
+ WEBRTC_CHECK_CAPTURER(capture_id);
+ delete capturers_[capture_id];
+ capturers_.erase(capture_id);
+ return 0;
+ }
+ WEBRTC_FUNC(ConnectCaptureDevice, (const int capture_id,
+ const int channel)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ WEBRTC_CHECK_CAPTURER(capture_id);
+ channels_[channel]->capture_id_ = capture_id;
+ capturers_[capture_id]->set_channel_id(channel);
+ return 0;
+ }
+ WEBRTC_FUNC(DisconnectCaptureDevice, (const int channel)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ int capture_id = channels_[channel]->capture_id_;
+ WEBRTC_CHECK_CAPTURER(capture_id);
+ channels_[channel]->capture_id_ = -1;
+ capturers_[capture_id]->set_channel_id(-1);
+ return 0;
+ }
+ WEBRTC_STUB(StartCapture, (const int, const webrtc::CaptureCapability));
+ WEBRTC_STUB(StopCapture, (const int));
+ WEBRTC_STUB(SetRotateCapturedFrames, (const int,
+ const webrtc::RotateCapturedFrame));
+ WEBRTC_STUB(SetCaptureDelay, (const int, const unsigned int));
+ WEBRTC_STUB(NumberOfCapabilities, (const char*, const unsigned int));
+ WEBRTC_STUB(GetCaptureCapability, (const char*, const unsigned int,
+ const unsigned int, webrtc::CaptureCapability&));
+ WEBRTC_STUB(ShowCaptureSettingsDialogBox, (const char*, const unsigned int,
+ const char*, void*, const unsigned int, const unsigned int));
+ WEBRTC_STUB(GetOrientation, (const char*, webrtc::RotateCapturedFrame&));
+ WEBRTC_STUB(EnableBrightnessAlarm, (const int, const bool));
+ WEBRTC_STUB(RegisterObserver, (const int, webrtc::ViECaptureObserver&));
+ WEBRTC_STUB(DeregisterObserver, (const int));
+
+ // webrtc::ViENetwork
+ WEBRTC_STUB(SetLocalReceiver, (const int, const unsigned short,
+ const unsigned short, const char*));
+ WEBRTC_STUB(GetLocalReceiver, (const int, unsigned short&,
+ unsigned short&, char*));
+ WEBRTC_STUB(SetSendDestination, (const int, const char*, const unsigned short,
+ const unsigned short, const unsigned short, const unsigned short));
+ WEBRTC_STUB(GetSendDestination, (const int, char*, unsigned short&,
+ unsigned short&, unsigned short&, unsigned short&));
+ WEBRTC_STUB(RegisterSendTransport, (const int, webrtc::Transport&));
+ WEBRTC_STUB(DeregisterSendTransport, (const int));
+ WEBRTC_STUB(ReceivedRTPPacket, (const int, const void*, const int));
+ WEBRTC_STUB(ReceivedRTCPPacket, (const int, const void*, const int));
+ WEBRTC_STUB(GetSourceInfo, (const int, unsigned short&, unsigned short&,
+ char*, unsigned int));
+ WEBRTC_STUB(GetLocalIP, (char*, bool));
+ WEBRTC_STUB(EnableIPv6, (int));
+ // Not using WEBRTC_STUB due to bool return value
+ virtual bool IsIPv6Enabled(int channel) { return true; }
+ WEBRTC_STUB(SetSourceFilter, (const int, const unsigned short,
+ const unsigned short, const char*));
+ WEBRTC_STUB(GetSourceFilter, (const int, unsigned short&,
+ unsigned short&, char*));
+ WEBRTC_STUB(SetSendToS, (const int, const int, const bool));
+ WEBRTC_STUB(GetSendToS, (const int, int&, bool&));
+ WEBRTC_STUB(SetSendGQoS, (const int, const bool, const int, const int));
+ WEBRTC_STUB(GetSendGQoS, (const int, bool&, int&, int&));
+ WEBRTC_STUB(SetMTU, (int, unsigned int));
+ WEBRTC_STUB(SetPacketTimeoutNotification, (const int, bool, int));
+ WEBRTC_STUB(RegisterObserver, (const int, webrtc::ViENetworkObserver&));
+ WEBRTC_STUB(SetPeriodicDeadOrAliveStatus, (const int, const bool,
+ const unsigned int));
+ WEBRTC_STUB(SendUDPPacket, (const int, const void*, const unsigned int,
+ int&, bool));
+
+ // webrtc::ViERender
+ WEBRTC_STUB(RegisterVideoRenderModule, (webrtc::VideoRender&));
+ WEBRTC_STUB(DeRegisterVideoRenderModule, (webrtc::VideoRender&));
+ WEBRTC_STUB(AddRenderer, (const int, void*, const unsigned int, const float,
+ const float, const float, const float));
+ WEBRTC_FUNC(RemoveRenderer, (const int render_id)) {
+ if (IsCapturerId(render_id)) {
+ WEBRTC_CHECK_CAPTURER(render_id);
+ return 0;
+ } else if (IsChannelId(render_id)) {
+ WEBRTC_CHECK_CHANNEL(render_id);
+ channels_[render_id]->has_renderer_ = false;
+ return 0;
+ }
+ return -1;
+ }
+ WEBRTC_FUNC(StartRender, (const int render_id)) {
+ if (IsCapturerId(render_id)) {
+ WEBRTC_CHECK_CAPTURER(render_id);
+ return 0;
+ } else if (IsChannelId(render_id)) {
+ WEBRTC_CHECK_CHANNEL(render_id);
+ channels_[render_id]->render_started_ = true;
+ return 0;
+ }
+ return -1;
+ }
+ WEBRTC_FUNC(StopRender, (const int render_id)) {
+ if (IsCapturerId(render_id)) {
+ WEBRTC_CHECK_CAPTURER(render_id);
+ return 0;
+ } else if (IsChannelId(render_id)) {
+ WEBRTC_CHECK_CHANNEL(render_id);
+ channels_[render_id]->render_started_ = false;
+ return 0;
+ }
+ return -1;
+ }
+ WEBRTC_STUB(ConfigureRender, (int, const unsigned int, const float,
+ const float, const float, const float));
+ WEBRTC_STUB(MirrorRenderStream, (const int, const bool, const bool,
+ const bool));
+ WEBRTC_FUNC(AddRenderer, (const int render_id,
+ webrtc::RawVideoType video_type,
+ webrtc::ExternalRenderer* renderer)) {
+ if (IsCapturerId(render_id)) {
+ WEBRTC_CHECK_CAPTURER(render_id);
+ return 0;
+ } else if (IsChannelId(render_id)) {
+ WEBRTC_CHECK_CHANNEL(render_id);
+ channels_[render_id]->has_renderer_ = true;
+ return 0;
+ }
+ return -1;
+ }
+
+ // webrtc::ViERTP_RTCP
+ WEBRTC_FUNC(SetLocalSSRC, (const int channel,
+ const unsigned int ssrc,
+ const webrtc::StreamType usage,
+ const unsigned char simulcast_idx)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->local_ssrc_ = ssrc;
+ return 0;
+ }
+ WEBRTC_STUB_CONST(SetRemoteSSRCType, (const int,
+ const webrtc::StreamType, const unsigned int));
+
+ WEBRTC_FUNC_CONST(GetLocalSSRC, (const int channel,
+ unsigned int& ssrc)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ ssrc = channels_.find(channel)->second->local_ssrc_;
+ return 0;
+ }
+ WEBRTC_STUB_CONST(GetRemoteSSRC, (const int, unsigned int&));
+ WEBRTC_STUB_CONST(GetRemoteCSRCs, (const int, unsigned int*));
+ WEBRTC_STUB(SetStartSequenceNumber, (const int, unsigned short));
+ WEBRTC_FUNC(SetRTCPStatus,
+ (const int channel, const webrtc::ViERTCPMode mode)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->rtcp_status_ = mode;
+ return 0;
+ }
+ WEBRTC_STUB_CONST(GetRTCPStatus, (const int, webrtc::ViERTCPMode&));
+ WEBRTC_FUNC(SetRTCPCName, (const int channel,
+ const char rtcp_cname[KMaxRTCPCNameLength])) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->cname_.assign(rtcp_cname);
+ return 0;
+ }
+ WEBRTC_FUNC_CONST(GetRTCPCName, (const int channel,
+ char rtcp_cname[KMaxRTCPCNameLength])) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ talk_base::strcpyn(rtcp_cname, KMaxRTCPCNameLength,
+ channels_.find(channel)->second->cname_.c_str());
+ return 0;
+ }
+ WEBRTC_STUB_CONST(GetRemoteRTCPCName, (const int, char*));
+ WEBRTC_STUB(SendApplicationDefinedRTCPPacket, (const int, const unsigned char,
+ unsigned int, const char*, unsigned short));
+ WEBRTC_FUNC(SetNACKStatus, (const int channel, const bool enable)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->nack_ = enable;
+ channels_[channel]->hybrid_nack_fec_ = false;
+ return 0;
+ }
+ WEBRTC_STUB(SetFECStatus, (const int, const bool, const unsigned char,
+ const unsigned char));
+ WEBRTC_FUNC(SetHybridNACKFECStatus, (const int channel, const bool enable,
+ const unsigned char red_type, const unsigned char fec_type)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ if (red_type == fec_type ||
+ red_type == channels_[channel]->send_codec.plType ||
+ fec_type == channels_[channel]->send_codec.plType) {
+ return -1;
+ }
+ channels_[channel]->nack_ = false;
+ channels_[channel]->hybrid_nack_fec_ = true;
+ return 0;
+ }
+ WEBRTC_FUNC(SetKeyFrameRequestMethod,
+ (const int channel,
+ const webrtc::ViEKeyFrameRequestMethod method)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->key_frame_request_method_ = method;
+ return 0;
+ }
+ WEBRTC_BOOL_FUNC(SetRembStatus, (int channel, bool send, bool receive)) {
+ if (channels_.find(channel) == channels_.end())
+ return false;
+ channels_[channel]->remb_send_ = send;
+ channels_[channel]->remb_ = receive;
+ return true;
+ }
+ WEBRTC_FUNC(SetTMMBRStatus, (const int channel, const bool enable)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->tmmbr_ = enable;
+ return 0;
+ }
+ WEBRTC_STUB_CONST(GetReceivedRTCPStatistics, (const int, unsigned short&,
+ unsigned int&, unsigned int&, unsigned int&, int&));
+ WEBRTC_STUB_CONST(GetSentRTCPStatistics, (const int, unsigned short&,
+ unsigned int&, unsigned int&, unsigned int&, int&));
+ WEBRTC_STUB_CONST(GetRTPStatistics, (const int, unsigned int&, unsigned int&,
+ unsigned int&, unsigned int&));
+ WEBRTC_STUB_CONST(GetBandwidthUsage, (const int, unsigned int&,
+ unsigned int&, unsigned int&, unsigned int&));
+
+ WEBRTC_STUB(SetRTPKeepAliveStatus, (const int, bool, const char,
+ const unsigned int));
+ WEBRTC_STUB_CONST(GetRTPKeepAliveStatus,
+ (const int, bool&, char&, unsigned int&));
+ WEBRTC_STUB(StartRTPDump, (const int, const char*, webrtc::RTPDirections));
+ WEBRTC_STUB(StopRTPDump, (const int, webrtc::RTPDirections));
+ WEBRTC_STUB(RegisterRTPObserver, (const int, webrtc::ViERTPObserver&));
+ WEBRTC_STUB(DeregisterRTPObserver, (const int));
+ WEBRTC_STUB(RegisterRTCPObserver, (const int, webrtc::ViERTCPObserver&));
+ WEBRTC_STUB(DeregisterRTCPObserver, (const int));
+
+ // webrtc::ViEImageProcess
+ WEBRTC_STUB(RegisterCaptureEffectFilter, (const int,
+ webrtc::ViEEffectFilter&));
+ WEBRTC_STUB(DeregisterCaptureEffectFilter, (const int));
+ WEBRTC_STUB(RegisterSendEffectFilter, (const int,
+ webrtc::ViEEffectFilter&));
+ WEBRTC_STUB(DeregisterSendEffectFilter, (const int));
+ WEBRTC_STUB(RegisterRenderEffectFilter, (const int,
+ webrtc::ViEEffectFilter&));
+ WEBRTC_STUB(DeregisterRenderEffectFilter, (const int));
+ WEBRTC_STUB(EnableDeflickering, (const int, const bool));
+ WEBRTC_STUB(EnableDenoising, (const int, const bool));
+ WEBRTC_STUB(EnableColorEnhancement, (const int, const bool));
+
+ private:
+ bool IsChannelId(int id) const {
+ return (id >= kViEChannelIdBase && id <= kViEChannelIdMax);
+ }
+ bool IsCapturerId(int id) const {
+ return (id >= kViECaptureIdBase && id <= kViECaptureIdMax);
+ }
+
+ bool inited_;
+ int last_channel_;
+ std::map<int, Channel*> channels_;
+ bool fail_create_channel_;
+ int last_capturer_;
+ std::map<int, Capturer*> capturers_;
+ bool fail_alloc_capturer_;
+ const cricket::VideoCodec* const* codecs_;
+ int num_codecs_;
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_FAKEWEBRTCVIDEOENGINE_H_
diff --git a/talk/session/phone/fakewebrtcvoiceengine.h b/talk/session/phone/fakewebrtcvoiceengine.h
new file mode 100644
index 0000000..568d408
--- /dev/null
+++ b/talk/session/phone/fakewebrtcvoiceengine.h
@@ -0,0 +1,851 @@
+/*
+ * libjingle
+ * Copyright 2010, 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_SESSION_PHONE_FAKEWEBRTCVOICEENGINE_H_
+#define TALK_SESSION_PHONE_FAKEWEBRTCVOICEENGINE_H_
+
+#include <list>
+#include <map>
+#include <vector>
+
+#include "talk/base/basictypes.h"
+#include "talk/base/stringutils.h"
+#include "talk/session/phone/codec.h"
+#include "talk/session/phone/fakewebrtccommon.h"
+#include "talk/session/phone/voiceprocessor.h"
+#include "talk/session/phone/webrtcvoe.h"
+
+namespace cricket {
+
+static const char kFakeDefaultDeviceName[] = "Fake Default";
+static const int kFakeDefaultDeviceId = -1;
+static const char kFakeDeviceName[] = "Fake Device";
+#ifdef WIN32
+static const int kFakeDeviceId = 0;
+#else
+static const int kFakeDeviceId = 1;
+#endif
+
+class FakeWebRtcVoiceEngine
+ : public webrtc::VoEAudioProcessing,
+ public webrtc::VoEBase, public webrtc::VoECodec, public webrtc::VoEDtmf,
+ public webrtc::VoEFile, public webrtc::VoEHardware,
+ public webrtc::VoEExternalMedia, public webrtc::VoENetEqStats,
+ public webrtc::VoENetwork, public webrtc::VoERTP_RTCP,
+ public webrtc::VoEVideoSync, public webrtc::VoEVolumeControl {
+ public:
+ struct Channel {
+ Channel()
+ : external_transport(false),
+ send(false),
+ playout(false),
+ file(false),
+ vad(false),
+ fec(false),
+ cn8_type(13),
+ cn16_type(105),
+ dtmf_type(106),
+ fec_type(117),
+ send_ssrc(0),
+ level_header_ext_(-1) {
+ memset(&send_codec, 0, sizeof(send_codec));
+ }
+ bool external_transport;
+ bool send;
+ bool playout;
+ bool file;
+ bool vad;
+ bool fec;
+ int cn8_type;
+ int cn16_type;
+ int dtmf_type;
+ int fec_type;
+ uint32 send_ssrc;
+ int level_header_ext_;
+ std::vector<webrtc::CodecInst> recv_codecs;
+ webrtc::CodecInst send_codec;
+ std::list<std::string> packets;
+ };
+
+ FakeWebRtcVoiceEngine(const cricket::AudioCodec* const* codecs,
+ int num_codecs)
+ : inited_(false),
+ last_channel_(-1),
+ fail_create_channel_(false),
+ codecs_(codecs),
+ num_codecs_(num_codecs),
+ ec_enabled_(false),
+ ns_enabled_(false),
+ ec_mode_(webrtc::kEcDefault),
+ ns_mode_(webrtc::kNsDefault),
+ observer_(NULL),
+ playout_fail_channel_(-1),
+ send_fail_channel_(-1),
+ fail_start_recording_microphone_(false),
+ recording_microphone_(false),
+ media_processor_(NULL) {
+ memset(&agc_config_, 0, sizeof(agc_config_));
+ }
+ ~FakeWebRtcVoiceEngine() {
+ // Ought to have all been deleted by the WebRtcVoiceMediaChannel
+ // destructors, but just in case ...
+ for (std::map<int, Channel*>::const_iterator i = channels_.begin();
+ i != channels_.end(); ++i) {
+ delete i->second;
+ }
+ }
+ bool IsExternalMediaProcessorRegistered() const {
+ return media_processor_ != NULL;
+ }
+ bool IsInited() const { return inited_; }
+ int GetLastChannel() const { return last_channel_; }
+ int GetNumChannels() const { return channels_.size(); }
+ bool GetPlayout(int channel) {
+ return channels_[channel]->playout;
+ }
+ bool GetSend(int channel) {
+ return channels_[channel]->send;
+ }
+ bool GetRecordingMicrophone() {
+ return recording_microphone_;
+ }
+ bool GetVAD(int channel) {
+ return channels_[channel]->vad;
+ }
+ bool GetFEC(int channel) {
+ return channels_[channel]->fec;
+ }
+ int GetSendCNPayloadType(int channel, bool wideband) {
+ return (wideband) ?
+ channels_[channel]->cn16_type :
+ channels_[channel]->cn8_type;
+ }
+ int GetSendTelephoneEventPayloadType(int channel) {
+ return channels_[channel]->dtmf_type;
+ }
+ int GetSendFECPayloadType(int channel) {
+ return channels_[channel]->fec_type;
+ }
+ bool CheckPacket(int channel, const void* data, size_t len) {
+ bool result = !CheckNoPacket(channel);
+ if (result) {
+ std::string packet = channels_[channel]->packets.front();
+ result = (packet == std::string(static_cast<const char*>(data), len));
+ channels_[channel]->packets.pop_front();
+ }
+ return result;
+ }
+ bool CheckNoPacket(int channel) {
+ return channels_[channel]->packets.empty();
+ }
+ void TriggerCallbackOnError(int channel_num, int err_code) {
+ ASSERT(observer_ != NULL);
+ observer_->CallbackOnError(channel_num, err_code);
+ }
+ void set_playout_fail_channel(int channel) {
+ playout_fail_channel_ = channel;
+ }
+ void set_send_fail_channel(int channel) {
+ send_fail_channel_ = channel;
+ }
+ void set_fail_start_recording_microphone(
+ bool fail_start_recording_microphone) {
+ fail_start_recording_microphone_ = fail_start_recording_microphone;
+ }
+ void set_fail_create_channel(bool fail_create_channel) {
+ fail_create_channel_ = fail_create_channel;
+ }
+ void TriggerProcessPacket(MediaProcessorDirection direction) {
+ webrtc::ProcessingTypes pt =
+ (direction == cricket::MPD_TX) ?
+ webrtc::kRecordingPerChannel : webrtc::kPlaybackPerChannel;
+ if (media_processor_ != NULL) {
+ media_processor_->Process(0,
+ pt,
+ NULL,
+ 0,
+ 0,
+ true);
+ }
+ }
+
+ WEBRTC_STUB(Release, ());
+
+ // webrtc::VoEBase
+ WEBRTC_FUNC(RegisterVoiceEngineObserver, (
+ webrtc::VoiceEngineObserver& observer)) {
+ observer_ = &observer;
+ return 0;
+ }
+ WEBRTC_STUB(DeRegisterVoiceEngineObserver, ());
+ WEBRTC_STUB(RegisterAudioDeviceModule, (webrtc::AudioDeviceModule& adm));
+ WEBRTC_STUB(DeRegisterAudioDeviceModule, ());
+
+ WEBRTC_FUNC(Init, (webrtc::AudioDeviceModule* adm)) {
+ inited_ = true;
+ return 0;
+ }
+ WEBRTC_FUNC(Terminate, ()) {
+ inited_ = false;
+ return 0;
+ }
+ WEBRTC_STUB(MaxNumOfChannels, ());
+ WEBRTC_FUNC(CreateChannel, ()) {
+ if (fail_create_channel_) {
+ return -1;
+ }
+ Channel* ch = new Channel();
+ for (int i = 0; i < NumOfCodecs(); ++i) {
+ webrtc::CodecInst codec;
+ GetCodec(i, codec);
+ ch->recv_codecs.push_back(codec);
+ }
+ channels_[++last_channel_] = ch;
+ return last_channel_;
+ }
+ WEBRTC_FUNC(DeleteChannel, (int channel)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ delete channels_[channel];
+ channels_.erase(channel);
+ return 0;
+ }
+ WEBRTC_STUB(SetLocalReceiver, (int channel, int port, int RTCPport,
+ const char ipaddr[64],
+ const char multiCastAddr[64]));
+ WEBRTC_STUB(GetLocalReceiver, (int channel, int& port, int& RTCPport,
+ char ipaddr[64]));
+ WEBRTC_STUB(SetSendDestination, (int channel, int port,
+ const char ipaddr[64],
+ int sourcePort, int RTCPport));
+ WEBRTC_STUB(GetSendDestination, (int channel, int& port, char ipaddr[64],
+ int& sourcePort, int& RTCPport));
+ WEBRTC_STUB(StartReceive, (int channel));
+ WEBRTC_FUNC(StartPlayout, (int channel)) {
+ if (playout_fail_channel_ != channel) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->playout = true;
+ return 0;
+ } else {
+ // When playout_fail_channel_ == channel, fail the StartPlayout on this
+ // channel.
+ return -1;
+ }
+ }
+ WEBRTC_FUNC(StartSend, (int channel)) {
+ if (send_fail_channel_ != channel) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->send = true;
+ return 0;
+ } else {
+ // When send_fail_channel_ == channel, fail the StartSend on this
+ // channel.
+ return -1;
+ }
+ }
+ WEBRTC_STUB(StopReceive, (int channel));
+ WEBRTC_FUNC(StopPlayout, (int channel)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->playout = false;
+ return 0;
+ }
+ WEBRTC_FUNC(StopSend, (int channel)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->send = false;
+ return 0;
+ }
+ WEBRTC_STUB(GetVersion, (char version[1024]));
+ WEBRTC_STUB(LastError, ());
+ WEBRTC_STUB(SetOnHoldStatus, (int, bool, webrtc::OnHoldModes));
+ WEBRTC_STUB(GetOnHoldStatus, (int, bool&, webrtc::OnHoldModes&));
+ WEBRTC_STUB(SetNetEQPlayoutMode, (int, webrtc::NetEqModes));
+ WEBRTC_STUB(GetNetEQPlayoutMode, (int, webrtc::NetEqModes&));
+ WEBRTC_STUB(SetNetEQBGNMode, (int, webrtc::NetEqBgnModes));
+ WEBRTC_STUB(GetNetEQBGNMode, (int, webrtc::NetEqBgnModes&));
+
+ // webrtc::VoECodec
+ WEBRTC_FUNC(NumOfCodecs, ()) {
+ return num_codecs_;
+ }
+ WEBRTC_FUNC(GetCodec, (int index, webrtc::CodecInst& codec)) {
+ if (index < 0 || index >= NumOfCodecs()) {
+ return -1;
+ }
+ const cricket::AudioCodec& c(*codecs_[index]);
+ codec.pltype = c.id;
+ talk_base::strcpyn(codec.plname, sizeof(codec.plname), c.name.c_str());
+ codec.plfreq = c.clockrate;
+ codec.pacsize = 0;
+ codec.channels = c.channels;
+ codec.rate = c.bitrate;
+ return 0;
+ }
+ WEBRTC_FUNC(SetSendCodec, (int channel, const webrtc::CodecInst& codec)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->send_codec = codec;
+ return 0;
+ }
+ WEBRTC_FUNC(GetSendCodec, (int channel, webrtc::CodecInst& codec)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ codec = channels_[channel]->send_codec;
+ return 0;
+ }
+ WEBRTC_STUB(GetRecCodec, (int channel, webrtc::CodecInst& codec));
+ WEBRTC_STUB(SetAMREncFormat, (int channel, webrtc::AmrMode mode));
+ WEBRTC_STUB(SetAMRDecFormat, (int channel, webrtc::AmrMode mode));
+ WEBRTC_STUB(SetAMRWbEncFormat, (int channel, webrtc::AmrMode mode));
+ WEBRTC_STUB(SetAMRWbDecFormat, (int channel, webrtc::AmrMode mode));
+ WEBRTC_STUB(SetISACInitTargetRate, (int channel, int rateBps,
+ bool useFixedFrameSize));
+ WEBRTC_STUB(SetISACMaxRate, (int channel, int rateBps));
+ WEBRTC_STUB(SetISACMaxPayloadSize, (int channel, int sizeBytes));
+ WEBRTC_FUNC(SetRecPayloadType, (int channel,
+ const webrtc::CodecInst& codec)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ Channel* ch = channels_[channel];
+ // Check if something else already has this slot.
+ if (codec.pltype != -1) {
+ for (std::vector<webrtc::CodecInst>::iterator it =
+ ch->recv_codecs.begin(); it != ch->recv_codecs.end(); ++it) {
+ if (it->pltype == codec.pltype) {
+ return -1;
+ }
+ }
+ }
+ // Otherwise try to find this codec and update its payload type.
+ for (std::vector<webrtc::CodecInst>::iterator it = ch->recv_codecs.begin();
+ it != ch->recv_codecs.end(); ++it) {
+ if (strcmp(it->plname, codec.plname) == 0 &&
+ it->plfreq == codec.plfreq) {
+ it->pltype = codec.pltype;
+ return 0;
+ }
+ }
+ return -1; // not found
+ }
+ WEBRTC_FUNC(SetSendCNPayloadType, (int channel, int type,
+ webrtc::PayloadFrequencies frequency)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ if (frequency == webrtc::kFreq8000Hz) {
+ channels_[channel]->cn8_type = type;
+ } else if (frequency == webrtc::kFreq16000Hz) {
+ channels_[channel]->cn16_type = type;
+ }
+ return 0;
+ }
+ WEBRTC_FUNC(GetRecPayloadType, (int channel, webrtc::CodecInst& codec)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ Channel* ch = channels_[channel];
+ for (std::vector<webrtc::CodecInst>::iterator it = ch->recv_codecs.begin();
+ it != ch->recv_codecs.end(); ++it) {
+ if (strcmp(it->plname, codec.plname) == 0 &&
+ it->plfreq == codec.plfreq &&
+ it->pltype != -1) {
+ codec.pltype = it->pltype;
+ return 0;
+ }
+ }
+ return -1; // not found
+ }
+ WEBRTC_FUNC(SetVADStatus, (int channel, bool enable, webrtc::VadModes mode,
+ bool disableDTX)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->vad = enable;
+ return 0;
+ }
+ WEBRTC_STUB(GetVADStatus, (int channel, bool& enabled,
+ webrtc::VadModes& mode, bool& disabledDTX));
+
+ // webrtc::VoEDtmf
+ WEBRTC_STUB(SendTelephoneEvent, (int channel, int eventCode,
+ bool outOfBand = true, int lengthMs = 160, int attenuationDb = 10));
+
+ WEBRTC_FUNC(SetSendTelephoneEventPayloadType,
+ (int channel, unsigned char type)) {
+ channels_[channel]->dtmf_type = type;
+ return 0;
+ };
+ WEBRTC_STUB(GetSendTelephoneEventPayloadType,
+ (int channel, unsigned char& type));
+
+ WEBRTC_STUB(SetDtmfFeedbackStatus, (bool enable, bool directFeedback));
+ WEBRTC_STUB(GetDtmfFeedbackStatus, (bool& enabled, bool& directFeedback));
+ WEBRTC_STUB(RegisterTelephoneEventDetection, (int channel,
+ webrtc::TelephoneEventDetectionMethods detectionMethod,
+ webrtc::VoETelephoneEventObserver& observer));
+ WEBRTC_STUB(DeRegisterTelephoneEventDetection, (int channel));
+ WEBRTC_STUB(SetDtmfPlayoutStatus, (int channel, bool enable));
+ WEBRTC_STUB(GetDtmfPlayoutStatus, (int channel, bool& enabled));
+
+
+ WEBRTC_STUB(PlayDtmfTone,
+ (int eventCode, int lengthMs = 200, int attenuationDb = 10));
+ WEBRTC_STUB(StartPlayingDtmfTone,
+ (int eventCode, int attenuationDb = 10));
+ WEBRTC_STUB(StopPlayingDtmfTone, ());
+ WEBRTC_STUB(GetTelephoneEventDetectionStatus, (int channel,
+ bool& enabled, webrtc::TelephoneEventDetectionMethods& detectionMethod));
+
+ // webrtc::VoEFile
+ WEBRTC_FUNC(StartPlayingFileLocally, (int channel, const char* fileNameUTF8,
+ bool loop, webrtc::FileFormats format,
+ float volumeScaling, int startPointMs,
+ int stopPointMs)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->file = true;
+ return 0;
+ }
+ WEBRTC_FUNC(StartPlayingFileLocally, (int channel, webrtc::InStream* stream,
+ webrtc::FileFormats format,
+ float volumeScaling, int startPointMs,
+ int stopPointMs)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->file = true;
+ return 0;
+ }
+ WEBRTC_FUNC(StopPlayingFileLocally, (int channel)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->file = false;
+ return 0;
+ }
+ WEBRTC_FUNC(IsPlayingFileLocally, (int channel)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ return (channels_[channel]->file) ? 1 : 0;
+ }
+ WEBRTC_STUB(ScaleLocalFilePlayout, (int channel, float scale));
+ WEBRTC_STUB(StartPlayingFileAsMicrophone, (int channel,
+ const char* fileNameUTF8,
+ bool loop,
+ bool mixWithMicrophone,
+ webrtc::FileFormats format,
+ float volumeScaling));
+ WEBRTC_STUB(StartPlayingFileAsMicrophone, (int channel,
+ webrtc::InStream* stream,
+ bool mixWithMicrophone,
+ webrtc::FileFormats format,
+ float volumeScaling));
+ WEBRTC_STUB(StopPlayingFileAsMicrophone, (int channel));
+ WEBRTC_STUB(IsPlayingFileAsMicrophone, (int channel));
+ WEBRTC_STUB(ScaleFileAsMicrophonePlayout, (int channel, float scale));
+ WEBRTC_STUB(StartRecordingPlayout, (int channel, const char* fileNameUTF8,
+ webrtc::CodecInst* compression,
+ int maxSizeBytes));
+ WEBRTC_STUB(StartRecordingPlayout, (int channel, webrtc::OutStream* stream,
+ webrtc::CodecInst* compression));
+ WEBRTC_STUB(StopRecordingPlayout, (int channel));
+ WEBRTC_FUNC(StartRecordingMicrophone, (const char* fileNameUTF8,
+ webrtc::CodecInst* compression,
+ int maxSizeBytes)) {
+ if (fail_start_recording_microphone_) {
+ return -1;
+ }
+ recording_microphone_ = true;
+ return 0;
+ }
+ WEBRTC_FUNC(StartRecordingMicrophone, (webrtc::OutStream* stream,
+ webrtc::CodecInst* compression)) {
+ if (fail_start_recording_microphone_) {
+ return -1;
+ }
+ recording_microphone_ = true;
+ return 0;
+ }
+ WEBRTC_FUNC(StopRecordingMicrophone, ()) {
+ if (!recording_microphone_) {
+ return -1;
+ }
+ recording_microphone_ = false;
+ return 0;
+ }
+ WEBRTC_STUB(ConvertPCMToWAV, (const char* fileNameInUTF8,
+ const char* fileNameOutUTF8));
+ WEBRTC_STUB(ConvertPCMToWAV, (webrtc::InStream* streamIn,
+ webrtc::OutStream* streamOut));
+ WEBRTC_STUB(ConvertWAVToPCM, (const char* fileNameInUTF8,
+ const char* fileNameOutUTF8));
+ WEBRTC_STUB(ConvertWAVToPCM, (webrtc::InStream* streamIn,
+ webrtc::OutStream* streamOut));
+ WEBRTC_STUB(ConvertPCMToCompressed, (const char* fileNameInUTF8,
+ const char* fileNameOutUTF8,
+ webrtc::CodecInst* compression));
+ WEBRTC_STUB(ConvertPCMToCompressed, (webrtc::InStream* streamIn,
+ webrtc::OutStream* streamOut,
+ webrtc::CodecInst* compression));
+ WEBRTC_STUB(ConvertCompressedToPCM, (const char* fileNameInUTF8,
+ const char* fileNameOutUTF8));
+ WEBRTC_STUB(ConvertCompressedToPCM, (webrtc::InStream* streamIn,
+ webrtc::OutStream* streamOut));
+ WEBRTC_STUB(GetFileDuration, (const char* fileNameUTF8, int& durationMs,
+ webrtc::FileFormats format));
+ WEBRTC_STUB(GetPlaybackPosition, (int channel, int& positionMs));
+
+ // webrtc::VoEHardware
+ WEBRTC_STUB(GetCPULoad, (int&));
+ WEBRTC_STUB(GetSystemCPULoad, (int&));
+ WEBRTC_FUNC(GetNumOfRecordingDevices, (int& num)) {
+ return GetNumDevices(num);
+ }
+ WEBRTC_FUNC(GetNumOfPlayoutDevices, (int& num)) {
+ return GetNumDevices(num);
+ }
+ WEBRTC_FUNC(GetRecordingDeviceName, (int i, char* name, char* guid)) {
+ return GetDeviceName(i, name, guid);
+ }
+ WEBRTC_FUNC(GetPlayoutDeviceName, (int i, char* name, char* guid)) {
+ return GetDeviceName(i, name, guid);
+ }
+ WEBRTC_STUB(SetRecordingDevice, (int, webrtc::StereoChannel));
+ WEBRTC_STUB(SetPlayoutDevice, (int));
+ WEBRTC_STUB(SetAudioDeviceLayer, (webrtc::AudioLayers));
+ WEBRTC_STUB(GetAudioDeviceLayer, (webrtc::AudioLayers&));
+ WEBRTC_STUB(GetPlayoutDeviceStatus, (bool&));
+ WEBRTC_STUB(GetRecordingDeviceStatus, (bool&));
+ WEBRTC_STUB(ResetAudioDevice, ());
+ WEBRTC_STUB(AudioDeviceControl, (unsigned int, unsigned int, unsigned int));
+ WEBRTC_STUB(NeedMorePlayData, (short int*, int, int, int, int&));
+ WEBRTC_STUB(RecordedDataIsAvailable, (short int*, int, int, int, int&));
+ WEBRTC_STUB(GetDevice, (char*, unsigned int));
+ WEBRTC_STUB(GetPlatform, (char*, unsigned int));
+ WEBRTC_STUB(GetOS, (char*, unsigned int));
+ WEBRTC_STUB(SetGrabPlayout, (bool));
+ WEBRTC_STUB(SetGrabRecording, (bool));
+ WEBRTC_STUB(SetLoudspeakerStatus, (bool enable));
+ WEBRTC_STUB(GetLoudspeakerStatus, (bool& enabled));
+ WEBRTC_STUB(EnableBuiltInAEC, (bool enable));
+ virtual bool BuiltInAECIsEnabled() const { return true; }
+ WEBRTC_STUB(SetSamplingRate, (int));
+ WEBRTC_STUB(GetSamplingRate, (int&));
+
+ // webrtc::VoENetEqStats
+ WEBRTC_STUB(GetNetworkStatistics, (int, webrtc::NetworkStatistics&));
+ WEBRTC_STUB(GetPreferredBufferSize, (int, short unsigned int&));
+ WEBRTC_STUB(ResetJitterStatistics, (int));
+
+ // webrtc::VoENetwork
+ WEBRTC_FUNC(RegisterExternalTransport, (int channel,
+ webrtc::Transport& transport)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->external_transport = true;
+ return 0;
+ }
+ WEBRTC_FUNC(DeRegisterExternalTransport, (int channel)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->external_transport = false;
+ return 0;
+ }
+ WEBRTC_FUNC(ReceivedRTPPacket, (int channel, const void* data,
+ unsigned int length)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ if (!channels_[channel]->external_transport) return -1;
+ channels_[channel]->packets.push_back(
+ std::string(static_cast<const char*>(data), length));
+ return 0;
+ }
+ WEBRTC_STUB(ReceivedRTCPPacket, (int channel, const void* data,
+ unsigned int length));
+ WEBRTC_STUB(GetSourceInfo, (int channel, int& rtpPort, int& rtcpPort,
+ char ipaddr[64]));
+ WEBRTC_STUB(GetLocalIP, (char ipaddr[64], bool ipv6));
+ WEBRTC_STUB(EnableIPv6, (int channel));
+ // Not using WEBRTC_STUB due to bool return value
+ virtual bool IPv6IsEnabled(int channel) { return true; }
+ WEBRTC_STUB(SetSourceFilter, (int channel, int rtpPort, int rtcpPort,
+ const char ipaddr[64]));
+ WEBRTC_STUB(GetSourceFilter, (int channel, int& rtpPort, int& rtcpPort,
+ char ipaddr[64]));
+ WEBRTC_STUB(SetSendTOS, (int channel, int priority,
+ int DSCP, bool useSetSockopt));
+ WEBRTC_STUB(GetSendTOS, (int channel, int& priority,
+ int& DSCP, bool& useSetSockopt));
+ WEBRTC_STUB(SetSendGQoS, (int channel, bool enable, int serviceType,
+ int overrideDSCP));
+ WEBRTC_STUB(GetSendGQoS, (int channel, bool& enabled, int& serviceType,
+ int& overrideDSCP));
+ WEBRTC_STUB(SetPacketTimeoutNotification, (int channel, bool enable,
+ int timeoutSeconds));
+ WEBRTC_STUB(GetPacketTimeoutNotification, (int channel, bool& enable,
+ int& timeoutSeconds));
+ WEBRTC_STUB(RegisterDeadOrAliveObserver, (int channel,
+ webrtc::VoEConnectionObserver& observer));
+ WEBRTC_STUB(DeRegisterDeadOrAliveObserver, (int channel));
+ WEBRTC_STUB(GetPeriodicDeadOrAliveStatus, (int channel, bool& enabled,
+ int& sampleTimeSeconds));
+ WEBRTC_STUB(SetPeriodicDeadOrAliveStatus, (int channel, bool enable,
+ int sampleTimeSeconds));
+ WEBRTC_STUB(SendUDPPacket, (int channel, const void* data,
+ unsigned int length, int& transmittedBytes,
+ bool useRtcpSocket));
+
+ // webrtc::VoERTP_RTCP
+ WEBRTC_STUB(RegisterRTPObserver, (int channel,
+ webrtc::VoERTPObserver& observer));
+ WEBRTC_STUB(DeRegisterRTPObserver, (int channel));
+ WEBRTC_STUB(RegisterRTCPObserver, (int channel,
+ webrtc::VoERTCPObserver& observer));
+ WEBRTC_STUB(DeRegisterRTCPObserver, (int channel));
+ WEBRTC_FUNC(SetLocalSSRC, (int channel, unsigned int ssrc)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->send_ssrc = ssrc;
+ return 0;
+ }
+ WEBRTC_FUNC(GetLocalSSRC, (int channel, unsigned int& ssrc)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ ssrc = channels_[channel]->send_ssrc;
+ return 0;
+ }
+ WEBRTC_STUB(GetRemoteSSRC, (int channel, unsigned int& ssrc));
+ WEBRTC_FUNC(SetRTPAudioLevelIndicationStatus, (int channel, bool enable,
+ unsigned char ID)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->level_header_ext_ = (enable) ? ID : -1;
+ return 0;
+ }
+ WEBRTC_FUNC(GetRTPAudioLevelIndicationStatus, (int channel, bool& enabled,
+ unsigned char& ID)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ enabled = (channels_[channel]->level_header_ext_ != -1);
+ ID = channels_[channel]->level_header_ext_;
+ return 0;
+ }
+ WEBRTC_STUB(GetRemoteCSRCs, (int channel, unsigned int arrCSRC[15]));
+ WEBRTC_STUB(GetRemoteEnergy, (int channel, unsigned char arrEnergy[15]));
+ WEBRTC_STUB(SetRTCPStatus, (int channel, bool enable));
+ WEBRTC_STUB(GetRTCPStatus, (int channel, bool& enabled));
+ WEBRTC_STUB(SetRTCP_CNAME, (int channel, const char cname[256]));
+ WEBRTC_STUB(GetRTCP_CNAME, (int channel, char cname[256]));
+ WEBRTC_STUB(GetRemoteRTCP_CNAME, (int channel, char* cname));
+ WEBRTC_STUB(GetRemoteRTCPData, (int channel, unsigned int& NTPHigh,
+ unsigned int& NTPLow,
+ unsigned int& timestamp,
+ unsigned int& playoutTimestamp,
+ unsigned int* jitter,
+ unsigned short* fractionLost));
+ WEBRTC_STUB(SendApplicationDefinedRTCPPacket, (int channel,
+ const unsigned char subType,
+ unsigned int name,
+ const char* data,
+ unsigned short dataLength));
+ WEBRTC_STUB(GetRTPStatistics, (int channel, unsigned int& averageJitterMs,
+ unsigned int& maxJitterMs,
+ unsigned int& discardedPackets));
+ WEBRTC_STUB(GetRTCPStatistics, (int channel, unsigned short& fractionLost,
+ unsigned int& cumulativeLost,
+ unsigned int& extendedMax,
+ unsigned int& jitterSamples, int& rttMs));
+ WEBRTC_STUB(GetRTCPStatistics, (int channel, webrtc::CallStatistics& stats));
+ WEBRTC_FUNC(SetFECStatus, (int channel, bool enable, int redPayloadtype)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ channels_[channel]->fec = enable;
+ channels_[channel]->fec_type = redPayloadtype;
+ return 0;
+ }
+ WEBRTC_FUNC(GetFECStatus, (int channel, bool& enable, int& redPayloadtype)) {
+ WEBRTC_CHECK_CHANNEL(channel);
+ enable = channels_[channel]->fec;
+ redPayloadtype = channels_[channel]->fec_type;
+ return 0;
+ }
+ WEBRTC_STUB(SetRTPKeepaliveStatus, (int channel, bool enable,
+ unsigned char unknownPayloadType,
+ int deltaTransmitTimeSeconds));
+ WEBRTC_STUB(GetRTPKeepaliveStatus, (int channel, bool& enabled,
+ unsigned char& unknownPayloadType,
+ int& deltaTransmitTimeSeconds));
+ WEBRTC_STUB(StartRTPDump, (int channel, const char* fileNameUTF8,
+ webrtc::RTPDirections direction));
+ WEBRTC_STUB(StopRTPDump, (int channel, webrtc::RTPDirections direction));
+ WEBRTC_STUB(RTPDumpIsActive, (int channel, webrtc::RTPDirections direction));
+ WEBRTC_STUB(InsertExtraRTPPacket, (int channel, unsigned char payloadType,
+ bool markerBit, const char* payloadData,
+ unsigned short payloadSize));
+
+ // webrtc::VoEVideoSync
+ WEBRTC_STUB(GetPlayoutBufferSize, (int& bufferMs));
+ WEBRTC_STUB(GetPlayoutTimestamp, (int channel, unsigned int& timestamp));
+ WEBRTC_STUB(GetRtpRtcp, (int, webrtc::RtpRtcp*&));
+ WEBRTC_STUB(SetInitTimestamp, (int channel, unsigned int timestamp));
+ WEBRTC_STUB(SetInitSequenceNumber, (int channel, short sequenceNumber));
+ WEBRTC_STUB(SetMinimumPlayoutDelay, (int channel, int delayMs));
+ WEBRTC_STUB(GetDelayEstimate, (int channel, int& delayMs));
+ WEBRTC_STUB(GetSoundcardBufferSize, (int& bufferMs));
+
+ // webrtc::VoEVolumeControl
+ WEBRTC_STUB(SetSpeakerVolume, (unsigned int));
+ WEBRTC_STUB(GetSpeakerVolume, (unsigned int&));
+ WEBRTC_STUB(SetSystemOutputMute, (bool));
+ WEBRTC_STUB(GetSystemOutputMute, (bool&));
+ WEBRTC_STUB(SetMicVolume, (unsigned int));
+ WEBRTC_STUB(GetMicVolume, (unsigned int&));
+ WEBRTC_STUB(SetInputMute, (int, bool));
+ WEBRTC_STUB(GetInputMute, (int, bool&));
+ WEBRTC_STUB(SetSystemInputMute, (bool));
+ WEBRTC_STUB(GetSystemInputMute, (bool&));
+ WEBRTC_STUB(GetSpeechInputLevel, (unsigned int&));
+ WEBRTC_STUB(GetSpeechOutputLevel, (int, unsigned int&));
+ WEBRTC_STUB(GetSpeechInputLevelFullRange, (unsigned int&));
+ WEBRTC_STUB(GetSpeechOutputLevelFullRange, (int, unsigned int&));
+ WEBRTC_STUB(SetChannelOutputVolumeScaling, (int, float));
+ WEBRTC_STUB(GetChannelOutputVolumeScaling, (int, float&));
+ WEBRTC_STUB(SetOutputVolumePan, (int, float, float));
+ WEBRTC_STUB(GetOutputVolumePan, (int, float&, float&));
+
+ // webrtc::VoEAudioProcessing
+ WEBRTC_FUNC(SetNsStatus, (bool enable, webrtc::NsModes mode)) {
+ ns_enabled_ = enable;
+ ns_mode_ = mode;
+ return 0;
+ }
+ WEBRTC_FUNC(GetNsStatus, (bool& enabled, webrtc::NsModes& mode)) {
+ enabled = ns_enabled_;
+ mode = ns_mode_;
+ return 0;
+ }
+ WEBRTC_STUB(SetAgcStatus, (bool enable, webrtc::AgcModes mode));
+ WEBRTC_STUB(GetAgcStatus, (bool& enabled, webrtc::AgcModes& mode));
+
+ WEBRTC_FUNC(SetAgcConfig, (const webrtc::AgcConfig config)) {
+ agc_config_ = config;
+ return 0;
+ }
+ WEBRTC_FUNC(GetAgcConfig, (webrtc::AgcConfig& config)) {
+ config = agc_config_;
+ return 0;
+ }
+ WEBRTC_FUNC(SetEcStatus, (bool enable, webrtc::EcModes mode)) {
+ ec_enabled_ = enable;
+ ec_mode_ = mode;
+ return 0;
+ }
+ WEBRTC_FUNC(GetEcStatus, (bool& enabled, webrtc::EcModes& mode)) {
+ enabled = ec_enabled_;
+ mode = ec_mode_;
+ return 0;
+ }
+ WEBRTC_STUB(SetAecmMode, (webrtc::AecmModes mode, bool enableCNG));
+ WEBRTC_STUB(GetAecmMode, (webrtc::AecmModes& mode, bool& enabledCNG));
+ WEBRTC_STUB(SetRxNsStatus, (int channel, bool enable, webrtc::NsModes mode));
+ WEBRTC_STUB(GetRxNsStatus, (int channel, bool& enabled,
+ webrtc::NsModes& mode));
+ WEBRTC_STUB(SetRxAgcStatus, (int channel, bool enable,
+ webrtc::AgcModes mode));
+ WEBRTC_STUB(GetRxAgcStatus, (int channel, bool& enabled,
+ webrtc::AgcModes& mode));
+ WEBRTC_STUB(SetRxAgcConfig, (int channel, const webrtc::AgcConfig config));
+ WEBRTC_STUB(GetRxAgcConfig, (int channel, webrtc::AgcConfig& config));
+
+ WEBRTC_STUB(RegisterRxVadObserver, (int, webrtc::VoERxVadCallback&));
+ WEBRTC_STUB(DeRegisterRxVadObserver, (int channel));
+ WEBRTC_STUB(VoiceActivityIndicator, (int channel));
+ WEBRTC_STUB(SetEcMetricsStatus, (bool enable));
+ WEBRTC_STUB(GetEcMetricsStatus, (bool& enable));
+ WEBRTC_STUB(GetEchoMetrics, (int& ERL, int& ERLE, int& RERL, int& A_NLP));
+ WEBRTC_STUB(GetEcDelayMetrics, (int& delay_median, int& delay_std));
+
+ WEBRTC_STUB(StartDebugRecording, (const char* fileNameUTF8));
+ WEBRTC_STUB(StopDebugRecording, ());
+
+ WEBRTC_STUB(SetTypingDetectionStatus, (bool enable));
+ WEBRTC_STUB(GetTypingDetectionStatus, (bool& enabled));
+
+ // webrtc::VoEExternalMedia
+ WEBRTC_FUNC(RegisterExternalMediaProcessing,
+ (int channel, webrtc::ProcessingTypes type,
+ webrtc::VoEMediaProcess& processObject)) {
+ media_processor_ = &processObject;
+ return 0;
+ }
+ WEBRTC_FUNC(DeRegisterExternalMediaProcessing,
+ (int channel, webrtc::ProcessingTypes type)) {
+ media_processor_ = NULL;
+ return 0;
+ }
+ WEBRTC_STUB(SetExternalRecordingStatus, (bool enable));
+ WEBRTC_STUB(SetExternalPlayoutStatus, (bool enable));
+ WEBRTC_STUB(ExternalRecordingInsertData,
+ (const WebRtc_Word16 speechData10ms[], int lengthSamples,
+ int samplingFreqHz, int current_delay_ms));
+ WEBRTC_STUB(ExternalPlayoutGetData,
+ (WebRtc_Word16 speechData10ms[], int samplingFreqHz,
+ int current_delay_ms, int& lengthSamples));
+
+ private:
+ int GetNumDevices(int& num) {
+#ifdef WIN32
+ num = 1;
+#else
+ // On non-Windows platforms VE adds a special entry for the default device,
+ // so if there is one physical device then there are two entries in the
+ // list.
+ num = 2;
+#endif
+ return 0;
+ }
+
+ int GetDeviceName(int i, char* name, char* guid) {
+ const char *s;
+#ifdef WIN32
+ if (0 == i) {
+ s = kFakeDeviceName;
+ } else {
+ return -1;
+ }
+#else
+ // See comment above.
+ if (0 == i) {
+ s = kFakeDefaultDeviceName;
+ } else if (1 == i) {
+ s = kFakeDeviceName;
+ } else {
+ return -1;
+ }
+#endif
+ strcpy(name, s);
+ guid[0] = '\0';
+ return 0;
+ }
+
+ bool inited_;
+ int last_channel_;
+ std::map<int, Channel*> channels_;
+ bool fail_create_channel_;
+ const cricket::AudioCodec* const* codecs_;
+ int num_codecs_;
+ bool ec_enabled_;
+ bool ns_enabled_;
+ webrtc::EcModes ec_mode_;
+ webrtc::NsModes ns_mode_;
+ webrtc::AgcConfig agc_config_;
+ webrtc::VoiceEngineObserver* observer_;
+ int playout_fail_channel_;
+ int send_fail_channel_;
+ bool fail_start_recording_microphone_;
+ bool recording_microphone_;
+ webrtc::VoEMediaProcess* media_processor_;
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_FAKEWEBRTCVOICEENGINE_H_
diff --git a/talk/session/phone/filemediaengine.cc b/talk/session/phone/filemediaengine.cc
index 2a7b8d8..6f2c5e1 100644
--- a/talk/session/phone/filemediaengine.cc
+++ b/talk/session/phone/filemediaengine.cc
@@ -34,6 +34,7 @@
#include "talk/base/stream.h"
#include "talk/session/phone/rtpdump.h"
#include "talk/session/phone/rtputils.h"
+#include "talk/session/phone/streamparams.h"
namespace cricket {
@@ -258,7 +259,8 @@
FileVoiceChannel::FileVoiceChannel(
talk_base::StreamInterface* input_file_stream,
talk_base::StreamInterface* output_file_stream)
- : rtp_sender_receiver_(new RtpSenderReceiver(this, input_file_stream,
+ : send_ssrc_(0),
+ rtp_sender_receiver_(new RtpSenderReceiver(this, input_file_stream,
output_file_stream)) {}
FileVoiceChannel::~FileVoiceChannel() {}
@@ -272,8 +274,22 @@
return rtp_sender_receiver_->SetSend(flag != SEND_NOTHING);
}
-void FileVoiceChannel::SetSendSsrc(uint32 ssrc) {
- rtp_sender_receiver_->SetSendSsrc(ssrc);
+bool FileVoiceChannel::AddSendStream(const StreamParams& sp) {
+ if (send_ssrc_ != 0 || sp.ssrcs.size() != 1) {
+ LOG(LS_ERROR) << "FileVoiceChannel only supports one send stream.";
+ return false;
+ }
+ send_ssrc_ = sp.ssrcs[0];
+ rtp_sender_receiver_->SetSendSsrc(send_ssrc_);
+ return true;
+}
+
+bool FileVoiceChannel::RemoveSendStream(uint32 ssrc) {
+ if (ssrc != send_ssrc_)
+ return false;
+ send_ssrc_ = 0;
+ rtp_sender_receiver_->SetSendSsrc(send_ssrc_);
+ return true;
}
void FileVoiceChannel::OnPacketReceived(talk_base::Buffer* packet) {
@@ -286,7 +302,8 @@
FileVideoChannel::FileVideoChannel(
talk_base::StreamInterface* input_file_stream,
talk_base::StreamInterface* output_file_stream)
- : rtp_sender_receiver_(new RtpSenderReceiver(this, input_file_stream,
+ : send_ssrc_(0),
+ rtp_sender_receiver_(new RtpSenderReceiver(this, input_file_stream,
output_file_stream)) {}
FileVideoChannel::~FileVideoChannel() {}
@@ -300,8 +317,22 @@
return rtp_sender_receiver_->SetSend(send);
}
-void FileVideoChannel::SetSendSsrc(uint32 ssrc) {
- rtp_sender_receiver_->SetSendSsrc(ssrc);
+bool FileVideoChannel::AddSendStream(const StreamParams& sp) {
+ if (send_ssrc_ != 0 || sp.ssrcs.size() != 1) {
+ LOG(LS_ERROR) << "FileVideoChannel only support one send stream.";
+ return false;
+ }
+ send_ssrc_ = sp.ssrcs[0];
+ rtp_sender_receiver_->SetSendSsrc(send_ssrc_);
+ return true;
+}
+
+bool FileVideoChannel::RemoveSendStream(uint32 ssrc) {
+ if (ssrc != send_ssrc_)
+ return false;
+ send_ssrc_ = 0;
+ rtp_sender_receiver_->SetSendSsrc(send_ssrc_);
+ return true;
}
void FileVideoChannel::OnPacketReceived(talk_base::Buffer* packet) {
diff --git a/talk/session/phone/filemediaengine.h b/talk/session/phone/filemediaengine.h
index b20e0f2..03d91ca 100644
--- a/talk/session/phone/filemediaengine.h
+++ b/talk/session/phone/filemediaengine.h
@@ -93,7 +93,13 @@
return true;
}
virtual bool SetVideoCaptureDevice(const Device* cam_device) { return true; }
- virtual bool GetOutputVolume(int* level) { *level = 0; return true; }
+ virtual bool SetVideoCapturer(VideoCapturer* /*capturer*/, uint32 /*ssrc*/) {
+ return true;
+ }
+ virtual bool GetOutputVolume(int* level) {
+ *level = 0;
+ return true;
+ }
virtual bool SetOutputVolume(int level) { return true; }
virtual int GetInputLevel() { return 0; }
virtual bool SetLocalMonitor(bool enable) { return true; }
@@ -111,6 +117,23 @@
virtual void SetVoiceLogging(int min_sev, const char* filter) {}
virtual void SetVideoLogging(int min_sev, const char* filter) {}
+ virtual bool RegisterVideoProcessor(VideoProcessor* processor) {
+ return true;
+ }
+ virtual bool UnregisterVideoProcessor(VideoProcessor* processor) {
+ return true;
+ }
+ virtual bool RegisterVoiceProcessor(uint32 ssrc,
+ VoiceProcessor* processor,
+ MediaProcessorDirection direction) {
+ return true;
+ }
+ virtual bool UnregisterVoiceProcessor(uint32 ssrc,
+ VoiceProcessor* processor,
+ MediaProcessorDirection direction) {
+ return true;
+ }
+
private:
std::string voice_input_filename_;
std::string voice_output_filename_;
@@ -145,8 +168,6 @@
}
virtual bool SetPlayout(bool playout) { return true; }
virtual bool SetSend(SendFlags flag);
- virtual bool AddStream(uint32 ssrc) { return true; }
- virtual bool RemoveStream(uint32 ssrc) { return true; }
virtual bool GetActiveStreams(AudioInfo::StreamList* actives) { return true; }
virtual int GetOutputLevel() { return 0; }
virtual bool SetOutputScaling(uint32 ssrc, double left, double right) {
@@ -165,13 +186,16 @@
// Implement pure virtual methods of MediaChannel.
virtual void OnPacketReceived(talk_base::Buffer* packet);
virtual void OnRtcpReceived(talk_base::Buffer* packet) {}
- virtual void SetSendSsrc(uint32 ssrc);
- virtual bool SetRtcpCName(const std::string& cname) { return true; }
+ virtual bool AddSendStream(const StreamParams& sp);
+ virtual bool RemoveSendStream(uint32 ssrc);
+ virtual bool AddRecvStream(const StreamParams& sp) { return true; }
+ virtual bool RemoveRecvStream(uint32 ssrc) { return true; }
virtual bool Mute(bool on) { return false; }
virtual bool SetSendBandwidth(bool autobw, int bps) { return true; }
virtual bool SetOptions(int options) { return true; }
private:
+ uint32 send_ssrc_;
talk_base::scoped_ptr<RtpSenderReceiver> rtp_sender_receiver_;
DISALLOW_COPY_AND_ASSIGN(FileVoiceChannel);
};
@@ -187,6 +211,9 @@
return true;
}
virtual bool SetSendCodecs(const std::vector<VideoCodec>& codecs);
+ virtual bool SetSendStreamFormat(uint32 ssrc, const VideoFormat& format) {
+ return true;
+ }
virtual bool SetRecvRtpHeaderExtensions(
const std::vector<RtpHeaderExtension>& extensions) {
return true;
@@ -197,11 +224,13 @@
}
virtual bool SetRender(bool render) { return true; }
virtual bool SetSend(bool send);
- virtual bool AddStream(uint32 ssrc, uint32 voice_ssrc) { return true; }
- virtual bool RemoveStream(uint32 ssrc) { return true; }
virtual bool SetRenderer(uint32 ssrc, VideoRenderer* renderer) {
return true;
}
+ virtual bool AddScreencast(uint32 ssrc, const ScreencastId& id) {
+ return true;
+ }
+ virtual bool RemoveScreencast(uint32 ssrc) { return true; }
virtual bool GetStats(VideoMediaInfo* info) { return true; }
virtual bool SendIntraFrame() { return false; }
virtual bool RequestIntraFrame() { return false; }
@@ -209,13 +238,16 @@
// Implement pure virtual methods of MediaChannel.
virtual void OnPacketReceived(talk_base::Buffer* packet);
virtual void OnRtcpReceived(talk_base::Buffer* packet) {}
- virtual void SetSendSsrc(uint32 ssrc);
- virtual bool SetRtcpCName(const std::string& cname) { return true; }
+ virtual bool AddSendStream(const StreamParams& sp);
+ virtual bool RemoveSendStream(uint32 ssrc);
+ virtual bool AddRecvStream(const StreamParams& sp) { return true; }
+ virtual bool RemoveRecvStream(uint32 ssrc) { return true; }
virtual bool Mute(bool on) { return false; }
virtual bool SetSendBandwidth(bool autobw, int bps) { return true; }
virtual bool SetOptions(int options) { return true; }
private:
+ uint32 send_ssrc_;
talk_base::scoped_ptr<RtpSenderReceiver> rtp_sender_receiver_;
DISALLOW_COPY_AND_ASSIGN(FileVideoChannel);
};
diff --git a/talk/session/phone/filemediaengine_unittest.cc b/talk/session/phone/filemediaengine_unittest.cc
new file mode 100644
index 0000000..c915251
--- /dev/null
+++ b/talk/session/phone/filemediaengine_unittest.cc
@@ -0,0 +1,463 @@
+/*
+ * libjingle
+ * Copyright 2004--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 <set>
+
+#include "talk/base/buffer.h"
+#include "talk/base/gunit.h"
+#include "talk/base/helpers.h"
+#include "talk/base/pathutils.h"
+#include "talk/base/stream.h"
+#include "talk/session/phone/filemediaengine.h"
+#include "talk/session/phone/rtpdump.h"
+#include "talk/session/phone/streamparams.h"
+#include "talk/session/phone/testutils.h"
+
+namespace cricket {
+
+static const int kWaitTimeMs = 100;
+static const std::string kFakeFileName = "foobar";
+
+//////////////////////////////////////////////////////////////////////////////
+// Media channel sends RTP packets via NetworkInterface. Rather than sending
+// packets to the network, FileNetworkInterface writes packets to a stream and
+// feeds packets back to the channel via OnPacketReceived.
+//////////////////////////////////////////////////////////////////////////////
+class FileNetworkInterface : public MediaChannel::NetworkInterface {
+ public:
+ FileNetworkInterface(talk_base::StreamInterface* output, MediaChannel* ch)
+ : media_channel_(ch),
+ num_sent_packets_(0) {
+ if (output) {
+ dump_writer_.reset(new RtpDumpWriter(output));
+ }
+ }
+
+ // Implement pure virtual methods of NetworkInterface.
+ virtual bool SendPacket(talk_base::Buffer* packet) {
+ if (!packet) return false;
+
+ if (media_channel_) {
+ media_channel_->OnPacketReceived(packet);
+ }
+ if (dump_writer_.get() &&
+ talk_base::SR_SUCCESS != dump_writer_->WriteRtpPacket(
+ packet->data(), packet->length())) {
+ return false;
+ }
+
+ ++num_sent_packets_;
+ return true;
+ }
+
+ virtual bool SendRtcp(talk_base::Buffer* packet) { return false; }
+ virtual int SetOption(MediaChannel::NetworkInterface::SocketType type,
+ talk_base::Socket::Option opt, int option) {
+ return 0;
+ }
+
+ size_t num_sent_packets() const { return num_sent_packets_; }
+
+ private:
+ MediaChannel* media_channel_;
+ talk_base::scoped_ptr<RtpDumpWriter> dump_writer_;
+ size_t num_sent_packets_;
+
+ DISALLOW_COPY_AND_ASSIGN(FileNetworkInterface);
+};
+
+class FileMediaEngineTest : public testing::Test {
+ public:
+ virtual void SetUp() {
+ setup_ok_ = true;
+ setup_ok_ &= GetTempFilename(&voice_input_filename_);
+ setup_ok_ &= GetTempFilename(&voice_output_filename_);
+ setup_ok_ &= GetTempFilename(&video_input_filename_);
+ setup_ok_ &= GetTempFilename(&video_output_filename_);
+ }
+ virtual void TearDown() {
+ // Force to close the dump files, if opened.
+ voice_channel_.reset();
+ video_channel_.reset();
+
+ DeleteTempFile(voice_input_filename_);
+ DeleteTempFile(voice_output_filename_);
+ DeleteTempFile(video_input_filename_);
+ DeleteTempFile(video_output_filename_);
+ }
+
+ protected:
+ bool CreateEngineAndChannels(const std::string& voice_in,
+ const std::string& voice_out,
+ const std::string& video_in,
+ const std::string& video_out,
+ size_t ssrc_count) {
+ // Force to close the dump files, if opened.
+ voice_channel_.reset();
+ video_channel_.reset();
+
+ bool ret = setup_ok_;
+ if (!voice_in.empty()) {
+ ret &= WriteTestPacketsToFile(voice_in, ssrc_count);
+ }
+ if (!video_in.empty()) {
+ ret &= WriteTestPacketsToFile(video_in, ssrc_count);
+ }
+
+ engine_.reset(new FileMediaEngine);
+ engine_->set_voice_input_filename(voice_in);
+ engine_->set_voice_output_filename(voice_out);
+ engine_->set_video_input_filename(video_in);
+ engine_->set_video_output_filename(video_out);
+
+ voice_channel_.reset(engine_->CreateChannel());
+ video_channel_.reset(engine_->CreateVideoChannel(NULL));
+
+ return ret;
+ }
+
+ bool GetTempFilename(std::string* filename) {
+ talk_base::Pathname temp_path;
+ if (!talk_base::Filesystem::GetTemporaryFolder(temp_path, true, NULL)) {
+ return false;
+ }
+ temp_path.SetPathname(
+ talk_base::Filesystem::TempFilename(temp_path, "fme-test-"));
+
+ if (filename) {
+ *filename = temp_path.pathname();
+ }
+ return true;
+ }
+
+ bool WriteTestPacketsToFile(const std::string& filename, size_t ssrc_count) {
+ talk_base::scoped_ptr<talk_base::StreamInterface> stream(
+ talk_base::Filesystem::OpenFile(talk_base::Pathname(filename), "wb"));
+ bool ret = (NULL != stream.get());
+ RtpDumpWriter writer(stream.get());
+
+ for (size_t i = 0; i < ssrc_count; ++i) {
+ ret &= RtpTestUtility::WriteTestPackets(
+ RtpTestUtility::GetTestPacketCount(), false,
+ RtpTestUtility::kDefaultSsrc + i, &writer);
+ }
+ return ret;
+ }
+
+ void DeleteTempFile(std::string filename) {
+ talk_base::Pathname pathname(filename);
+ if (talk_base::Filesystem::IsFile(talk_base::Pathname(pathname))) {
+ talk_base::Filesystem::DeleteFile(pathname);
+ }
+ }
+
+ bool GetSsrcAndPacketCounts(talk_base::StreamInterface* stream,
+ size_t* ssrc_count, size_t* packet_count) {
+ talk_base::scoped_ptr<RtpDumpReader> reader(new RtpDumpReader(stream));
+ size_t count = 0;
+ RtpDumpPacket packet;
+ std::set<uint32> ssrcs;
+ while (talk_base::SR_SUCCESS == reader->ReadPacket(&packet)) {
+ count++;
+ uint32 ssrc;
+ if (!packet.GetRtpSsrc(&ssrc)) {
+ return false;
+ }
+ ssrcs.insert(ssrc);
+ }
+ if (ssrc_count) {
+ *ssrc_count = ssrcs.size();
+ }
+ if (packet_count) {
+ *packet_count = count;
+ }
+ return true;
+ }
+
+ static const uint32 kWaitTimeout = 3000;
+ bool setup_ok_;
+ std::string voice_input_filename_;
+ std::string voice_output_filename_;
+ std::string video_input_filename_;
+ std::string video_output_filename_;
+ talk_base::scoped_ptr<FileMediaEngine> engine_;
+ talk_base::scoped_ptr<VoiceMediaChannel> voice_channel_;
+ talk_base::scoped_ptr<VideoMediaChannel> video_channel_;
+};
+
+TEST_F(FileMediaEngineTest, TestDefaultImplementation) {
+ EXPECT_TRUE(CreateEngineAndChannels("", "", "", "", 1));
+ EXPECT_TRUE(engine_->Init());
+ EXPECT_EQ(0, engine_->GetCapabilities());
+ EXPECT_TRUE(NULL == voice_channel_.get());
+ EXPECT_TRUE(NULL == video_channel_.get());
+ EXPECT_TRUE(NULL == engine_->CreateSoundclip());
+ EXPECT_TRUE(engine_->SetAudioOptions(0));
+ EXPECT_TRUE(engine_->SetVideoOptions(0));
+ VideoEncoderConfig video_encoder_config;
+ EXPECT_TRUE(engine_->SetDefaultVideoEncoderConfig(video_encoder_config));
+ EXPECT_TRUE(engine_->SetSoundDevices(NULL, NULL));
+ EXPECT_TRUE(engine_->SetVideoCaptureDevice(NULL));
+ EXPECT_TRUE(engine_->SetOutputVolume(0));
+ EXPECT_EQ(0, engine_->GetInputLevel());
+ EXPECT_TRUE(engine_->SetLocalMonitor(true));
+ EXPECT_TRUE(engine_->SetLocalRenderer(NULL));
+ EXPECT_EQ(CR_SUCCESS, engine_->SetVideoCapture(true));
+ EXPECT_EQ(0U, engine_->audio_codecs().size());
+ EXPECT_EQ(0U, engine_->video_codecs().size());
+ AudioCodec voice_codec;
+ EXPECT_TRUE(engine_->FindAudioCodec(voice_codec));
+ VideoCodec video_codec;
+ EXPECT_TRUE(engine_->FindVideoCodec(video_codec));
+ engine_->Terminate();
+}
+
+// Test that when file path is not pointing to a valid stream file, the channel
+// creation function should fail and return NULL.
+TEST_F(FileMediaEngineTest, TestBadFilePath) {
+ engine_.reset(new FileMediaEngine);
+ engine_->set_voice_input_filename(kFakeFileName);
+ engine_->set_video_input_filename(kFakeFileName);
+ EXPECT_TRUE(engine_->CreateChannel() == NULL);
+ EXPECT_TRUE(engine_->CreateVideoChannel(NULL) == NULL);
+}
+
+TEST_F(FileMediaEngineTest, TestCodecs) {
+ EXPECT_TRUE(CreateEngineAndChannels("", "", "", "", 1));
+ std::vector<AudioCodec> voice_codecs = engine_->audio_codecs();
+ std::vector<VideoCodec> video_codecs = engine_->video_codecs();
+ EXPECT_EQ(0U, voice_codecs.size());
+ EXPECT_EQ(0U, video_codecs.size());
+
+ AudioCodec voice_codec(103, "ISAC", 16000, 0, 1, 0);
+ voice_codecs.push_back(voice_codec);
+ engine_->set_voice_codecs(voice_codecs);
+ voice_codecs = engine_->audio_codecs();
+ ASSERT_EQ(1U, voice_codecs.size());
+ EXPECT_EQ(voice_codec, voice_codecs[0]);
+
+ VideoCodec video_codec(96, "H264-SVC", 320, 240, 30, 0);
+ video_codecs.push_back(video_codec);
+ engine_->set_video_codecs(video_codecs);
+ video_codecs = engine_->video_codecs();
+ ASSERT_EQ(1U, video_codecs.size());
+ EXPECT_EQ(video_codec, video_codecs[0]);
+}
+
+// Test that the capabilities and channel creation of the Filemedia engine
+// depend on the stream parameters passed to its constructor.
+TEST_F(FileMediaEngineTest, TestGetCapabilities) {
+ EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_, "", "", "", 1));
+ EXPECT_EQ(AUDIO_SEND, engine_->GetCapabilities());
+ EXPECT_TRUE(NULL != voice_channel_.get());
+ EXPECT_TRUE(NULL == video_channel_.get());
+
+ EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_,
+ voice_output_filename_, "", "", 1));
+ EXPECT_EQ(AUDIO_SEND | AUDIO_RECV, engine_->GetCapabilities());
+ EXPECT_TRUE(NULL != voice_channel_.get());
+ EXPECT_TRUE(NULL == video_channel_.get());
+
+ EXPECT_TRUE(CreateEngineAndChannels("", "", video_input_filename_, "", 1));
+ EXPECT_EQ(VIDEO_SEND, engine_->GetCapabilities());
+ EXPECT_TRUE(NULL == voice_channel_.get());
+ EXPECT_TRUE(NULL != video_channel_.get());
+
+ EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_,
+ voice_output_filename_,
+ video_input_filename_,
+ video_output_filename_,
+ 1));
+ EXPECT_EQ(AUDIO_SEND | AUDIO_RECV | VIDEO_SEND | VIDEO_RECV,
+ engine_->GetCapabilities());
+ EXPECT_TRUE(NULL != voice_channel_.get());
+ EXPECT_TRUE(NULL != video_channel_.get());
+}
+
+// FileVideoChannel is the same as FileVoiceChannel in terms of receiving and
+// sending the RTP packets. We therefore test only FileVoiceChannel.
+
+// Test that SetSend() controls whether a voice channel sends RTP packets.
+TEST_F(FileMediaEngineTest, TestVoiceChannelSetSend) {
+ EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_,
+ voice_output_filename_, "", "", 1));
+ EXPECT_TRUE(NULL != voice_channel_.get());
+ talk_base::MemoryStream net_dump;
+ FileNetworkInterface net_interface(&net_dump, voice_channel_.get());
+ voice_channel_->SetInterface(&net_interface);
+
+ // The channel is not sending yet.
+ talk_base::Thread::Current()->ProcessMessages(kWaitTimeMs);
+ EXPECT_EQ(0U, net_interface.num_sent_packets());
+
+ // The channel starts sending.
+ voice_channel_->SetSend(SEND_MICROPHONE);
+ EXPECT_TRUE_WAIT(net_interface.num_sent_packets() >= 1U, kWaitTimeout);
+
+ // The channel stops sending.
+ voice_channel_->SetSend(SEND_NOTHING);
+ // Wait until packets are all delivered.
+ talk_base::Thread::Current()->ProcessMessages(kWaitTimeMs);
+ size_t old_number = net_interface.num_sent_packets();
+ talk_base::Thread::Current()->ProcessMessages(kWaitTimeMs);
+ EXPECT_EQ(old_number, net_interface.num_sent_packets());
+
+ // The channel starts sending again.
+ voice_channel_->SetSend(SEND_MICROPHONE);
+ EXPECT_TRUE_WAIT(net_interface.num_sent_packets() > old_number, kWaitTimeout);
+
+ // When the function exits, the net_interface object is released. The sender
+ // thread may call net_interface to send packets, which results in a segment
+ // fault. We hence stop sending and wait until all packets are delivered
+ // before we exit this function.
+ voice_channel_->SetSend(SEND_NOTHING);
+ talk_base::Thread::Current()->ProcessMessages(kWaitTimeMs);
+}
+
+// Test the sender thread of the channel. The sender sends RTP packets
+// continuously with proper sequence number, timestamp, and payload.
+TEST_F(FileMediaEngineTest, TestVoiceChannelSenderThread) {
+ EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_,
+ voice_output_filename_, "", "", 1));
+ EXPECT_TRUE(NULL != voice_channel_.get());
+ talk_base::MemoryStream net_dump;
+ FileNetworkInterface net_interface(&net_dump, voice_channel_.get());
+ voice_channel_->SetInterface(&net_interface);
+
+ voice_channel_->SetSend(SEND_MICROPHONE);
+ // Wait until the number of sent packets is no less than 2 * kPacketNumber.
+ EXPECT_TRUE_WAIT(
+ net_interface.num_sent_packets() >=
+ 2 * RtpTestUtility::GetTestPacketCount(),
+ kWaitTimeout);
+ voice_channel_->SetSend(SEND_NOTHING);
+ // Wait until packets are all delivered.
+ talk_base::Thread::Current()->ProcessMessages(kWaitTimeMs);
+ EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
+ 2 * RtpTestUtility::GetTestPacketCount(), &net_dump,
+ RtpTestUtility::kDefaultSsrc));
+
+ // Each sent packet is dumped to net_dump and is also feed to the channel
+ // via OnPacketReceived, which in turn writes the packets into voice_output_.
+ // We next verify the packets in voice_output_.
+ voice_channel_.reset(); // Force to close the files.
+ talk_base::scoped_ptr<talk_base::StreamInterface> voice_output_;
+ voice_output_.reset(talk_base::Filesystem::OpenFile(
+ talk_base::Pathname(voice_output_filename_), "rb"));
+ EXPECT_TRUE(voice_output_.get() != NULL);
+ EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
+ 2 * RtpTestUtility::GetTestPacketCount(), voice_output_.get(),
+ RtpTestUtility::kDefaultSsrc));
+}
+
+// Test that we can specify the ssrc for outgoing RTP packets.
+TEST_F(FileMediaEngineTest, TestVoiceChannelSendSsrc) {
+ EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_,
+ voice_output_filename_, "", "", 1));
+ EXPECT_TRUE(NULL != voice_channel_.get());
+ const uint32 send_ssrc = RtpTestUtility::kDefaultSsrc + 1;
+ voice_channel_->AddSendStream(StreamParams::CreateLegacy(send_ssrc));
+
+ talk_base::MemoryStream net_dump;
+ FileNetworkInterface net_interface(&net_dump, voice_channel_.get());
+ voice_channel_->SetInterface(&net_interface);
+
+ voice_channel_->SetSend(SEND_MICROPHONE);
+ // Wait until the number of sent packets is no less than 2 * kPacketNumber.
+ EXPECT_TRUE_WAIT(
+ net_interface.num_sent_packets() >=
+ 2 * RtpTestUtility::GetTestPacketCount(),
+ kWaitTimeout);
+ voice_channel_->SetSend(SEND_NOTHING);
+ // Wait until packets are all delivered.
+ talk_base::Thread::Current()->ProcessMessages(kWaitTimeMs);
+ EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
+ 2 * RtpTestUtility::GetTestPacketCount(), &net_dump, send_ssrc));
+
+ // Each sent packet is dumped to net_dump and is also feed to the channel
+ // via OnPacketReceived, which in turn writes the packets into voice_output_.
+ // We next verify the packets in voice_output_.
+ voice_channel_.reset(); // Force to close the files.
+ talk_base::scoped_ptr<talk_base::StreamInterface> voice_output_;
+ voice_output_.reset(talk_base::Filesystem::OpenFile(
+ talk_base::Pathname(voice_output_filename_), "rb"));
+ EXPECT_TRUE(voice_output_.get() != NULL);
+ EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
+ 2 * RtpTestUtility::GetTestPacketCount(), voice_output_.get(),
+ send_ssrc));
+}
+
+// Test the sender thread of the channel, where the input rtpdump has two SSRCs.
+TEST_F(FileMediaEngineTest, TestVoiceChannelSenderThreadTwoSsrcs) {
+ EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_,
+ voice_output_filename_, "", "", 2));
+ // Verify that voice_input_filename_ contains 2 *
+ // RtpTestUtility::GetTestPacketCount() packets
+ // with different SSRCs.
+ talk_base::scoped_ptr<talk_base::StreamInterface> input_stream(
+ talk_base::Filesystem::OpenFile(
+ talk_base::Pathname(voice_input_filename_), "rb"));
+ ASSERT_TRUE(NULL != input_stream.get());
+ size_t ssrc_count;
+ size_t packet_count;
+ EXPECT_TRUE(GetSsrcAndPacketCounts(input_stream.get(), &ssrc_count,
+ &packet_count));
+ EXPECT_EQ(2U, ssrc_count);
+ EXPECT_EQ(2 * RtpTestUtility::GetTestPacketCount(), packet_count);
+ input_stream.reset();
+
+ // Send 2 * RtpTestUtility::GetTestPacketCount() packets and verify that all
+ // these packets have the same SSRCs (that is, the packets with different
+ // SSRCs are skipped by the filemediaengine).
+ EXPECT_TRUE(NULL != voice_channel_.get());
+ talk_base::MemoryStream net_dump;
+ FileNetworkInterface net_interface(&net_dump, voice_channel_.get());
+ voice_channel_->SetInterface(&net_interface);
+ voice_channel_->SetSend(SEND_MICROPHONE);
+ EXPECT_TRUE_WAIT(
+ net_interface.num_sent_packets() >=
+ 2 * RtpTestUtility::GetTestPacketCount(),
+ kWaitTimeout);
+ voice_channel_->SetSend(SEND_NOTHING);
+ // Wait until packets are all delivered.
+ talk_base::Thread::Current()->ProcessMessages(kWaitTimeMs);
+ net_dump.Rewind();
+ EXPECT_TRUE(GetSsrcAndPacketCounts(&net_dump, &ssrc_count, &packet_count));
+ EXPECT_EQ(1U, ssrc_count);
+ EXPECT_GE(packet_count, 2 * RtpTestUtility::GetTestPacketCount());
+}
+
+// Test SendIntraFrame() and RequestIntraFrame() of video channel.
+TEST_F(FileMediaEngineTest, TestVideoChannelIntraFrame) {
+ EXPECT_TRUE(CreateEngineAndChannels("", "", video_input_filename_,
+ video_output_filename_, 1));
+ EXPECT_TRUE(NULL != video_channel_.get());
+ EXPECT_FALSE(video_channel_->SendIntraFrame());
+ EXPECT_FALSE(video_channel_->RequestIntraFrame());
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/filevideocapturer.cc b/talk/session/phone/filevideocapturer.cc
new file mode 100644
index 0000000..00272c5
--- /dev/null
+++ b/talk/session/phone/filevideocapturer.cc
@@ -0,0 +1,350 @@
+// libjingle
+// Copyright 2004--2005, 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.
+//
+// Implementation of VideoRecorder and FileVideoCapturer.
+
+#include "talk/session/phone/filevideocapturer.h"
+
+#include "talk/base/bytebuffer.h"
+#include "talk/base/logging.h"
+#include "talk/base/thread.h"
+
+namespace cricket {
+
+/////////////////////////////////////////////////////////////////////
+// Implementation of class VideoRecorder
+/////////////////////////////////////////////////////////////////////
+bool VideoRecorder::Start(const std::string& filename, bool write_header) {
+ Stop();
+ write_header_ = write_header;
+ int err;
+ if (!video_file_.Open(filename, "wb", &err)) {
+ LOG(LS_ERROR) << "Unable to open file " << filename << " err=" << err;
+ return false;
+ }
+ return true;
+}
+
+void VideoRecorder::Stop() {
+ video_file_.Close();
+}
+
+bool VideoRecorder::RecordFrame(const CapturedFrame& frame) {
+ if (talk_base::SS_CLOSED == video_file_.GetState()) {
+ LOG(LS_ERROR) << "File not opened yet";
+ return false;
+ }
+
+ uint32 size = 0;
+ if (!frame.GetDataSize(&size)) {
+ LOG(LS_ERROR) << "Unable to calculate the data size of the frame";
+ return false;
+ }
+
+ if (write_header_) {
+ // Convert the frame header to bytebuffer.
+ talk_base::ByteBuffer buffer;
+ buffer.WriteUInt32(frame.width);
+ buffer.WriteUInt32(frame.height);
+ buffer.WriteUInt32(frame.fourcc);
+ buffer.WriteUInt32(frame.pixel_width);
+ buffer.WriteUInt32(frame.pixel_height);
+ buffer.WriteUInt64(frame.elapsed_time);
+ buffer.WriteUInt64(frame.time_stamp);
+ buffer.WriteUInt32(size);
+
+ // Write the bytebuffer to file.
+ if (talk_base::SR_SUCCESS != video_file_.Write(buffer.Data(),
+ buffer.Length(),
+ NULL,
+ NULL)) {
+ LOG(LS_ERROR) << "Failed to write frame header";
+ return false;
+ }
+ }
+ // Write the frame data to file.
+ if (talk_base::SR_SUCCESS != video_file_.Write(frame.data,
+ size,
+ NULL,
+ NULL)) {
+ LOG(LS_ERROR) << "Failed to write frame data";
+ return false;
+ }
+
+ return true;
+}
+
+///////////////////////////////////////////////////////////////////////
+// Definition of private class FileReadThread that periodically reads
+// frames from a file.
+///////////////////////////////////////////////////////////////////////
+class FileVideoCapturer::FileReadThread
+ : public talk_base::Thread, public talk_base::MessageHandler {
+ public:
+ explicit FileReadThread(FileVideoCapturer* capturer)
+ : capturer_(capturer),
+ finished_(false) {
+ }
+
+ // Override virtual method of parent Thread. Context: Worker Thread.
+ virtual void Run() {
+ // Read the first frame and start the message pump. The pump runs until
+ // Stop() is called externally or Quit() is called by OnMessage().
+ int waiting_time_ms = 0;
+ if (capturer_ && capturer_->ReadFrame(true, &waiting_time_ms)) {
+ PostDelayed(waiting_time_ms, this);
+ Thread::Run();
+ }
+ finished_ = true;
+ }
+
+ // Override virtual method of parent MessageHandler. Context: Worker Thread.
+ virtual void OnMessage(talk_base::Message* /*pmsg*/) {
+ int waiting_time_ms = 0;
+ if (capturer_ && capturer_->ReadFrame(false, &waiting_time_ms)) {
+ PostDelayed(waiting_time_ms, this);
+ } else {
+ Quit();
+ }
+ }
+
+ // Check if Run() is finished.
+ bool Finished() const { return finished_; }
+
+ private:
+ FileVideoCapturer* capturer_;
+ bool finished_;
+
+ DISALLOW_COPY_AND_ASSIGN(FileReadThread);
+};
+
+/////////////////////////////////////////////////////////////////////
+// Implementation of class FileVideoCapturer
+/////////////////////////////////////////////////////////////////////
+static const int64 kNumNanoSecsPerMilliSec = 1000000;
+
+FileVideoCapturer::FileVideoCapturer()
+ : frame_buffer_size_(0),
+ file_read_thread_(NULL),
+ repeat_(0),
+ start_time_ns_(0),
+ last_frame_timestamp_ns_(0),
+ ignore_framerate_(false) {
+}
+
+FileVideoCapturer::~FileVideoCapturer() {
+ Stop();
+ delete[] static_cast<char*> (captured_frame_.data);
+}
+
+bool FileVideoCapturer::Init(const std::string& filename) {
+ if (IsRunning()) {
+ LOG(LS_ERROR) << "The file video capturer is already running";
+ return false;
+ }
+ // Open the file.
+ int err;
+ if (!video_file_.Open(filename, "rb", &err)) {
+ LOG(LS_ERROR) << "Unable to open the file " << filename << " err=" << err;
+ return false;
+ }
+ // Read the first frame's header to determine the supported format.
+ CapturedFrame frame;
+ if (talk_base::SR_SUCCESS != ReadFrameHeader(&frame)) {
+ LOG(LS_ERROR) << "Failed to read the first frame header";
+ video_file_.Close();
+ return false;
+ }
+ // Seek back to the start of the file.
+ if (!video_file_.SetPosition(0)) {
+ LOG(LS_ERROR) << "Failed to seek back to beginning of the file";
+ video_file_.Close();
+ return false;
+ }
+
+ // Enumerate the supported formats. We have only one supported format. We set
+ // the frame interval to kMinimumInterval here. In Start(), if the capture
+ // format's interval is greater than kMinimumInterval, we use the interval;
+ // otherwise, we use the timestamp in the file to control the interval.
+ VideoFormat format(frame.width, frame.height, VideoFormat::kMinimumInterval,
+ frame.fourcc);
+ std::vector<VideoFormat> supported;
+ supported.push_back(format);
+
+ SetId(filename);
+ SetSupportedFormats(supported);
+ return true;
+}
+
+CaptureResult FileVideoCapturer::Start(const VideoFormat& capture_format) {
+ if (IsRunning()) {
+ LOG(LS_ERROR) << "The file video capturer is already running";
+ return CR_FAILURE;
+ }
+
+ if (talk_base::SS_CLOSED == video_file_.GetState()) {
+ LOG(LS_ERROR) << "File not opened yet";
+ return CR_NO_DEVICE;
+ } else if (!video_file_.SetPosition(0)) {
+ LOG(LS_ERROR) << "Failed to seek back to beginning of the file";
+ return CR_FAILURE;
+ }
+
+ SetCaptureFormat(&capture_format);
+ // Create a thread to read the file.
+ file_read_thread_ = new FileReadThread(this);
+ bool ret = file_read_thread_->Start();
+ start_time_ns_ = kNumNanoSecsPerMilliSec *
+ static_cast<int64>(talk_base::Time());
+ if (ret) {
+ LOG(LS_INFO) << "File video capturer '" << GetId() << "' started";
+ return CR_SUCCESS;
+ } else {
+ LOG(LS_ERROR) << "File video capturer '" << GetId() << "' failed to start";
+ return CR_FAILURE;
+ }
+}
+
+bool FileVideoCapturer::IsRunning() {
+ return file_read_thread_ && !file_read_thread_->Finished();
+}
+
+void FileVideoCapturer::Stop() {
+ if (file_read_thread_) {
+ file_read_thread_->Stop();
+ file_read_thread_ = NULL;
+ LOG(LS_INFO) << "File video capturer '" << GetId() << "' stopped";
+ }
+ SetCaptureFormat(NULL);
+}
+
+bool FileVideoCapturer::GetPreferredFourccs(std::vector<uint32>* fourccs) {
+ if (!fourccs) {
+ return false;
+ }
+
+ fourccs->push_back(GetSupportedFormats()->at(0).fourcc);
+ return true;
+}
+
+talk_base::StreamResult FileVideoCapturer::ReadFrameHeader(
+ CapturedFrame* frame) {
+ // We first read kFrameHeaderSize bytes from the file stream to a memory
+ // buffer, then construct a bytebuffer from the memory buffer, and finally
+ // read the frame header from the bytebuffer.
+ char header[CapturedFrame::kFrameHeaderSize];
+ talk_base::StreamResult sr;
+ sr = video_file_.Read(header,
+ CapturedFrame::kFrameHeaderSize,
+ NULL,
+ NULL);
+ if (talk_base::SR_SUCCESS == sr) {
+ talk_base::ByteBuffer buffer(header, CapturedFrame::kFrameHeaderSize);
+ buffer.ReadUInt32(reinterpret_cast<uint32*>(&frame->width));
+ buffer.ReadUInt32(reinterpret_cast<uint32*>(&frame->height));
+ buffer.ReadUInt32(&frame->fourcc);
+ buffer.ReadUInt32(&frame->pixel_width);
+ buffer.ReadUInt32(&frame->pixel_height);
+ buffer.ReadUInt64(reinterpret_cast<uint64*>(&frame->elapsed_time));
+ buffer.ReadUInt64(reinterpret_cast<uint64*>(&frame->time_stamp));
+ buffer.ReadUInt32(&frame->data_size);
+ }
+
+ return sr;
+}
+
+// Executed in the context of FileReadThread.
+bool FileVideoCapturer::ReadFrame(bool first_frame, int* wait_time_ms) {
+ uint32 start_read_time_ms = talk_base::Time();
+
+ // 1. Signal the previously read frame to downstream.
+ if (!first_frame) {
+ captured_frame_.time_stamp = kNumNanoSecsPerMilliSec *
+ static_cast<int64>(start_read_time_ms);
+ captured_frame_.elapsed_time = captured_frame_.time_stamp - start_time_ns_;
+ SignalFrameCaptured(this, &captured_frame_);
+ }
+
+ // 2. Read the next frame.
+ if (talk_base::SS_CLOSED == video_file_.GetState()) {
+ LOG(LS_ERROR) << "File not opened yet";
+ return false;
+ }
+ // 2.1 Read the frame header.
+ talk_base::StreamResult result = ReadFrameHeader(&captured_frame_);
+ if (talk_base::SR_EOS == result) { // Loop back if repeat.
+ if (repeat_ != talk_base::kForever) {
+ if (repeat_ > 0) {
+ --repeat_;
+ } else {
+ return false;
+ }
+ }
+
+ if (video_file_.SetPosition(0)) {
+ result = ReadFrameHeader(&captured_frame_);
+ }
+ }
+ if (talk_base::SR_SUCCESS != result) {
+ LOG(LS_ERROR) << "Failed to read the frame header";
+ return false;
+ }
+ // 2.2 Reallocate memory for the frame data if necessary.
+ if (frame_buffer_size_ < captured_frame_.data_size) {
+ frame_buffer_size_ = captured_frame_.data_size;
+ delete[] static_cast<char*> (captured_frame_.data);
+ captured_frame_.data = new char[frame_buffer_size_];
+ }
+ // 2.3 Read the frame adata.
+ if (talk_base::SR_SUCCESS != video_file_.Read(captured_frame_.data,
+ captured_frame_.data_size,
+ NULL, NULL)) {
+ LOG(LS_ERROR) << "Failed to read frame data";
+ return false;
+ }
+
+ // 3. Decide how long to wait for the next frame.
+ *wait_time_ms = 0;
+
+ // If the capture format's interval is not kMinimumInterval, we use it to
+ // control the rate; otherwise, we use the timestamp in the file to control
+ // the rate.
+ if (!first_frame && !ignore_framerate_) {
+ int64 interval_ns =
+ GetCaptureFormat()->interval > VideoFormat::kMinimumInterval ?
+ GetCaptureFormat()->interval :
+ captured_frame_.time_stamp - last_frame_timestamp_ns_;
+ int interval_ms = static_cast<int>(interval_ns / kNumNanoSecsPerMilliSec);
+ interval_ms -= talk_base::Time() - start_read_time_ms;
+ if (interval_ms > 0) {
+ *wait_time_ms = interval_ms;
+ }
+ }
+ // Keep the original timestamp read from the file.
+ last_frame_timestamp_ns_ = captured_frame_.time_stamp;
+ return true;
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/filevideocapturer.h b/talk/session/phone/filevideocapturer.h
new file mode 100644
index 0000000..6423c02
--- /dev/null
+++ b/talk/session/phone/filevideocapturer.h
@@ -0,0 +1,135 @@
+// libjingle
+// Copyright 2004--2005, 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 two classes, VideoRecorder and FileVideoCapturer.
+// VideoRecorder records the captured frames into a file. The file stores a
+// sequence of captured frames; each frame has a header defined in struct
+// CapturedFrame, followed by the frame data.
+//
+// FileVideoCapturer, a subclass of VideoCapturer, is a simulated video capturer
+// that periodically reads images from a previously recorded file.
+
+#ifndef TALK_SESSION_PHONE_FILEVIDEOCAPTURER_H_
+#define TALK_SESSION_PHONE_FILEVIDEOCAPTURER_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/base/stream.h"
+#include "talk/session/phone/videocapturer.h"
+
+namespace talk_base {
+class FileStream;
+}
+
+namespace cricket {
+
+// Utility class to record the frames captured by a video capturer into a file.
+class VideoRecorder {
+ public:
+ VideoRecorder() {}
+ ~VideoRecorder() { Stop(); }
+
+ // Start the recorder by opening the specified file. Return true if the file
+ // is opened successfully. write_header should normally be true; false means
+ // write raw frame pixel data to file without any headers.
+ bool Start(const std::string& filename, bool write_header);
+ // Stop the recorder by closing the file.
+ void Stop();
+ // Record a video frame to the file. Return true if the frame is written to
+ // the file successfully. This method needs to be called after Start() and
+ // before Stop().
+ bool RecordFrame(const CapturedFrame& frame);
+
+ private:
+ talk_base::FileStream video_file_;
+ bool write_header_;
+
+ DISALLOW_COPY_AND_ASSIGN(VideoRecorder);
+};
+
+// Simulated video capturer that periodically reads frames from a file.
+class FileVideoCapturer : public VideoCapturer {
+ public:
+ FileVideoCapturer();
+ virtual ~FileVideoCapturer();
+
+ // Set how many times to repeat reading the file. Repeat forever if the
+ // parameter is talk_base::kForever(-1); no repeat if the parameter is 0 or
+ // less than -1.
+ void set_repeat(int repeat) { repeat_ = repeat; }
+
+ // If ignore_framerate is true, file is read as quickly as possible. If
+ // false, read rate is controlled by the timestamps in the video file
+ // (thus simulating camera capture). Default value set to false.
+ void set_ignore_framerate(bool ignore_framerate) {
+ ignore_framerate_ = ignore_framerate;
+ }
+
+ bool Init(const std::string& filename);
+
+ // Override virtual methods of parent class VideoCapturer.
+ virtual CaptureResult Start(const VideoFormat& capture_format);
+ virtual void Stop();
+ virtual bool IsRunning();
+
+ protected:
+ // Override virtual methods of parent class VideoCapturer.
+ virtual bool GetPreferredFourccs(std::vector<uint32>* fourccs);
+
+ // Read the frame header from the file stream, video_file_.
+ talk_base::StreamResult ReadFrameHeader(CapturedFrame* frame);
+
+ // Read a frame and determine how long to wait for the next frame. If the
+ // frame is read successfully, Set the output parameter, wait_time_ms and
+ // return true. Otherwise, do not change wait_time_ms and return false.
+ bool ReadFrame(bool first_frame, int* wait_time_ms);
+
+ // Return the CapturedFrame - useful for extracting contents after reading
+ // a frame. Should be used only while still reading a file (i.e. only while
+ // the CapturedFrame object still exists).
+ const CapturedFrame* frame() const {
+ return &captured_frame_;
+ }
+
+ private:
+ class FileReadThread; // Forward declaration, defined in .cc.
+
+ talk_base::FileStream video_file_;
+ CapturedFrame captured_frame_;
+ // The number of bytes allocated buffer for captured_frame_.data.
+ uint32 frame_buffer_size_;
+ FileReadThread* file_read_thread_;
+ int repeat_; // How many times to repeat the file.
+ int64 start_time_ns_; // Time when the file video capturer starts.
+ int64 last_frame_timestamp_ns_; // Timestamp of last read frame.
+ bool ignore_framerate_;
+
+ DISALLOW_COPY_AND_ASSIGN(FileVideoCapturer);
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_FILEVIDEOCAPTURER_H_
diff --git a/talk/session/phone/filevideocapturer_unittest.cc b/talk/session/phone/filevideocapturer_unittest.cc
new file mode 100644
index 0000000..8692703
--- /dev/null
+++ b/talk/session/phone/filevideocapturer_unittest.cc
@@ -0,0 +1,175 @@
+/*
+ * libjingle
+ * Copyright 2004--2008, 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 <stdio.h>
+#include <vector>
+
+#include "talk/base/gunit.h"
+#include "talk/base/logging.h"
+#include "talk/base/thread.h"
+#include "talk/session/phone/filevideocapturer.h"
+#include "talk/session/phone/testutils.h"
+
+namespace {
+
+class FileVideoCapturerTest : public testing::Test {
+ public:
+ virtual void SetUp() {
+ capturer_.reset(new cricket::FileVideoCapturer);
+ }
+
+ bool OpenFile(const std::string& filename) {
+ return capturer_->Init(cricket::GetTestFilePath(filename));
+ }
+
+ protected:
+ class VideoCapturerListener : public sigslot::has_slots<> {
+ public:
+ VideoCapturerListener()
+ : frame_count_(0),
+ frame_width_(0),
+ frame_height_(0),
+ resolution_changed_(false) {
+ }
+
+ void OnFrameCaptured(cricket::VideoCapturer* capturer,
+ const cricket::CapturedFrame* frame) {
+ ++frame_count_;
+ if (1 == frame_count_) {
+ frame_width_ = frame->width;
+ frame_height_ = frame->height;
+ } else if (frame_width_ != frame->width ||
+ frame_height_ != frame->height) {
+ resolution_changed_ = true;
+ }
+ }
+
+ int frame_count() const { return frame_count_; }
+ int frame_width() const { return frame_width_; }
+ int frame_height() const { return frame_height_; }
+ bool resolution_changed() const { return resolution_changed_; }
+
+ private:
+ int frame_count_;
+ int frame_width_;
+ int frame_height_;
+ bool resolution_changed_;
+ };
+
+ talk_base::scoped_ptr<cricket::FileVideoCapturer> capturer_;
+ cricket::VideoFormat capture_format_;
+};
+
+TEST_F(FileVideoCapturerTest, TestNotOpened) {
+ EXPECT_EQ("", capturer_->GetId());
+ EXPECT_EQ(NULL, capturer_->GetSupportedFormats());
+ EXPECT_EQ(NULL, capturer_->GetCaptureFormat());
+ EXPECT_FALSE(capturer_->IsRunning());
+}
+
+TEST_F(FileVideoCapturerTest, TestInvalidOpen) {
+ EXPECT_FALSE(OpenFile("NotmeNotme"));
+}
+
+TEST_F(FileVideoCapturerTest, TestOpen) {
+ EXPECT_TRUE(OpenFile("captured-320x240-2s-48.frames"));
+ EXPECT_NE("", capturer_->GetId());
+ EXPECT_TRUE(NULL != capturer_->GetSupportedFormats());
+ EXPECT_EQ(1U, capturer_->GetSupportedFormats()->size());
+ EXPECT_EQ(NULL, capturer_->GetCaptureFormat()); // not started yet
+ EXPECT_FALSE(capturer_->IsRunning());
+}
+
+TEST_F(FileVideoCapturerTest, TestLargeSmallDesiredFormat) {
+ EXPECT_TRUE(OpenFile("captured-320x240-2s-48.frames"));
+ // desired format with large resolution.
+ cricket::VideoFormat desired(
+ 3200, 2400, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_ANY);
+ EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &capture_format_));
+ EXPECT_EQ(320, capture_format_.width);
+ EXPECT_EQ(240, capture_format_.height);
+
+ // Desired format with small resolution.
+ desired.width = 0;
+ desired.height = 0;
+ EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &capture_format_));
+ EXPECT_EQ(320, capture_format_.width);
+ EXPECT_EQ(240, capture_format_.height);
+}
+
+TEST_F(FileVideoCapturerTest, TestSupportedAsDesiredFormat) {
+ EXPECT_TRUE(OpenFile("captured-320x240-2s-48.frames"));
+ // desired format same as the capture format supported by the file
+ cricket::VideoFormat desired = capturer_->GetSupportedFormats()->at(0);
+ EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &capture_format_));
+ EXPECT_TRUE(desired == capture_format_);
+
+ // desired format same as the supported capture format except the fourcc
+ desired.fourcc = cricket::FOURCC_ANY;
+ EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &capture_format_));
+ EXPECT_NE(capture_format_.fourcc, desired.fourcc);
+
+ // desired format with minimum interval
+ desired.interval = cricket::VideoFormat::kMinimumInterval;
+ EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &capture_format_));
+}
+
+TEST_F(FileVideoCapturerTest, TestNoRepeat) {
+ EXPECT_TRUE(OpenFile("captured-320x240-2s-48.frames"));
+ VideoCapturerListener listener;
+ capturer_->SignalFrameCaptured.connect(
+ &listener, &VideoCapturerListener::OnFrameCaptured);
+ capturer_->set_repeat(0);
+ capture_format_ = capturer_->GetSupportedFormats()->at(0);
+ EXPECT_EQ(cricket::CR_SUCCESS, capturer_->Start(capture_format_));
+ EXPECT_TRUE_WAIT(!capturer_->IsRunning(), 20000);
+ EXPECT_EQ(48, listener.frame_count());
+}
+
+TEST_F(FileVideoCapturerTest, TestRepeatForever) {
+ // Start the capturer_ with 50 fps and read no less than 150 frames.
+ EXPECT_TRUE(OpenFile("captured-320x240-2s-48.frames"));
+ VideoCapturerListener listener;
+ capturer_->SignalFrameCaptured.connect(
+ &listener, &VideoCapturerListener::OnFrameCaptured);
+ capturer_->set_repeat(talk_base::kForever);
+ capture_format_ = capturer_->GetSupportedFormats()->at(0);
+ capture_format_.interval = cricket::VideoFormat::FpsToInterval(50);
+ EXPECT_EQ(cricket::CR_SUCCESS, capturer_->Start(capture_format_));
+ EXPECT_TRUE(NULL != capturer_->GetCaptureFormat());
+ EXPECT_TRUE(capture_format_ == *capturer_->GetCaptureFormat());
+ EXPECT_TRUE_WAIT(!capturer_->IsRunning() ||
+ listener.frame_count() >= 150, 20000);
+ capturer_->Stop();
+ EXPECT_FALSE(capturer_->IsRunning());
+ EXPECT_GE(listener.frame_count(), 150);
+ EXPECT_FALSE(listener.resolution_changed());
+ EXPECT_EQ(listener.frame_width(), capture_format_.width);
+ EXPECT_EQ(listener.frame_height(), capture_format_.height);
+}
+
+} // unnamed namespace
diff --git a/talk/session/phone/linuxdevicemanager.cc b/talk/session/phone/linuxdevicemanager.cc
new file mode 100644
index 0000000..6bad677
--- /dev/null
+++ b/talk/session/phone/linuxdevicemanager.cc
@@ -0,0 +1,410 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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/session/phone/linuxdevicemanager.h"
+
+#include <libudev.h>
+#include <unistd.h>
+#include "talk/base/linux.h"
+#include "talk/base/logging.h"
+#include "talk/base/fileutils.h"
+#include "talk/base/pathutils.h"
+#include "talk/base/physicalsocketserver.h"
+#include "talk/base/stream.h"
+#include "talk/base/stringutils.h"
+#include "talk/base/thread.h"
+#include "talk/session/phone/libudevsymboltable.h"
+#include "talk/session/phone/mediacommon.h"
+#include "talk/session/phone/v4llookup.h"
+#include "talk/sound/platformsoundsystem.h"
+#include "talk/sound/platformsoundsystemfactory.h"
+#include "talk/sound/sounddevicelocator.h"
+#include "talk/sound/soundsysteminterface.h"
+
+namespace cricket {
+
+DeviceManagerInterface* DeviceManagerFactory::Create() {
+ return new LinuxDeviceManager();
+}
+
+class LinuxDeviceWatcher
+ : public DeviceWatcher,
+ private talk_base::Dispatcher {
+ public:
+ explicit LinuxDeviceWatcher(DeviceManagerInterface* dm);
+ virtual ~LinuxDeviceWatcher();
+ virtual bool Start();
+ virtual void Stop();
+
+ private:
+ virtual uint32 GetRequestedEvents();
+ virtual void OnPreEvent(uint32 ff);
+ virtual void OnEvent(uint32 ff, int err);
+ virtual int GetDescriptor();
+ virtual bool IsDescriptorClosed();
+
+ DeviceManagerInterface* manager_;
+ LibUDevSymbolTable libudev_;
+ struct udev* udev_;
+ struct udev_monitor* udev_monitor_;
+ bool registered_;
+};
+
+#define LATE(sym) LATESYM_GET(LibUDevSymbolTable, &libudev_, sym)
+
+static const char* const kFilteredAudioDevicesName[] = {
+#if defined(CHROMEOS)
+ "surround40:",
+ "surround41:",
+ "surround50:",
+ "surround51:",
+ "surround71:",
+ "iec958:", // S/PDIF
+#endif
+ NULL,
+};
+static const char* kFilteredVideoDevicesName[] = {
+ NULL,
+};
+
+LinuxDeviceManager::LinuxDeviceManager()
+ : sound_system_(new PlatformSoundSystemFactory()) {
+ set_watcher(new LinuxDeviceWatcher(this));
+}
+
+LinuxDeviceManager::~LinuxDeviceManager() {
+}
+
+bool LinuxDeviceManager::GetAudioDevices(bool input,
+ std::vector<Device>* devs) {
+ devs->clear();
+ if (!sound_system_.get()) {
+ return false;
+ }
+ SoundSystemInterface::SoundDeviceLocatorList list;
+ bool success;
+ if (input) {
+ success = sound_system_->EnumerateCaptureDevices(&list);
+ } else {
+ success = sound_system_->EnumeratePlaybackDevices(&list);
+ }
+ if (!success) {
+ LOG(LS_ERROR) << "Can't enumerate devices";
+ sound_system_.release();
+ return false;
+ }
+ // We have to start the index at 1 because GIPS VoiceEngine puts the default
+ // device at index 0, but Enumerate(Capture|Playback)Devices does not include
+ // a locator for the default device.
+ int index = 1;
+ for (SoundSystemInterface::SoundDeviceLocatorList::iterator i = list.begin();
+ i != list.end();
+ ++i, ++index) {
+ devs->push_back(Device((*i)->name(), index));
+ }
+ SoundSystemInterface::ClearSoundDeviceLocatorList(&list);
+ sound_system_.release();
+ return FilterDevices(devs, kFilteredAudioDevicesName);
+}
+
+static const std::string kVideoMetaPathK2_4("/proc/video/dev/");
+static const std::string kVideoMetaPathK2_6("/sys/class/video4linux/");
+
+enum MetaType { M2_4, M2_6, NONE };
+
+static void ScanDeviceDirectory(const std::string& devdir,
+ std::vector<Device>* devices) {
+ talk_base::scoped_ptr<talk_base::DirectoryIterator> directoryIterator(
+ talk_base::Filesystem::IterateDirectory());
+
+ if (directoryIterator->Iterate(talk_base::Pathname(devdir))) {
+ do {
+ std::string filename = directoryIterator->Name();
+ std::string device_name = devdir + filename;
+ if (!directoryIterator->IsDots()) {
+ if (filename.find("video") == 0 &&
+ V4LLookup::IsV4L2Device(device_name)) {
+ devices->push_back(Device(device_name, device_name));
+ }
+ }
+ } while (directoryIterator->Next());
+ }
+}
+
+static std::string GetVideoDeviceNameK2_6(const std::string& device_meta_path) {
+ std::string device_name;
+
+ talk_base::scoped_ptr<talk_base::FileStream> device_meta_stream(
+ talk_base::Filesystem::OpenFile(device_meta_path, "r"));
+
+ if (device_meta_stream.get() != NULL) {
+ if (device_meta_stream->ReadLine(&device_name) != talk_base::SR_SUCCESS) {
+ LOG(LS_ERROR) << "Failed to read V4L2 device meta " << device_meta_path;
+ }
+ device_meta_stream->Close();
+ }
+
+ return device_name;
+}
+
+static std::string Trim(const std::string& s, const std::string& drop = " \t") {
+ std::string::size_type first = s.find_first_not_of(drop);
+ std::string::size_type last = s.find_last_not_of(drop);
+
+ if (first == std::string::npos || last == std::string::npos)
+ return std::string("");
+
+ return s.substr(first, last - first + 1);
+}
+
+static std::string GetVideoDeviceNameK2_4(const std::string& device_meta_path) {
+ talk_base::ConfigParser::MapVector all_values;
+
+ talk_base::ConfigParser config_parser;
+ talk_base::FileStream* file_stream =
+ talk_base::Filesystem::OpenFile(device_meta_path, "r");
+
+ if (file_stream == NULL) return "";
+
+ config_parser.Attach(file_stream);
+ config_parser.Parse(&all_values);
+
+ for (talk_base::ConfigParser::MapVector::iterator i = all_values.begin();
+ i != all_values.end(); ++i) {
+ talk_base::ConfigParser::SimpleMap::iterator device_name_i =
+ i->find("name");
+
+ if (device_name_i != i->end()) {
+ return device_name_i->second;
+ }
+ }
+
+ return "";
+}
+
+static std::string GetVideoDeviceName(MetaType meta,
+ const std::string& device_file_name) {
+ std::string device_meta_path;
+ std::string device_name;
+ std::string meta_file_path;
+
+ if (meta == M2_6) {
+ meta_file_path = kVideoMetaPathK2_6 + device_file_name + "/name";
+
+ LOG(LS_INFO) << "Trying " + meta_file_path;
+ device_name = GetVideoDeviceNameK2_6(meta_file_path);
+
+ if (device_name.empty()) {
+ meta_file_path = kVideoMetaPathK2_6 + device_file_name + "/model";
+
+ LOG(LS_INFO) << "Trying " << meta_file_path;
+ device_name = GetVideoDeviceNameK2_6(meta_file_path);
+ }
+ } else {
+ meta_file_path = kVideoMetaPathK2_4 + device_file_name;
+ LOG(LS_INFO) << "Trying " << meta_file_path;
+ device_name = GetVideoDeviceNameK2_4(meta_file_path);
+ }
+
+ if (device_name.empty()) {
+ device_name = "/dev/" + device_file_name;
+ LOG(LS_ERROR)
+ << "Device name not found, defaulting to device path " << device_name;
+ }
+
+ LOG(LS_INFO) << "Name for " << device_file_name << " is " << device_name;
+
+ return Trim(device_name);
+}
+
+static void ScanV4L2Devices(std::vector<Device>* devices) {
+ LOG(LS_INFO) << ("Enumerating V4L2 devices");
+
+ MetaType meta;
+ std::string metadata_dir;
+
+ talk_base::scoped_ptr<talk_base::DirectoryIterator> directoryIterator(
+ talk_base::Filesystem::IterateDirectory());
+
+ // Try and guess kernel version
+ if (directoryIterator->Iterate(kVideoMetaPathK2_6)) {
+ meta = M2_6;
+ metadata_dir = kVideoMetaPathK2_6;
+ } else if (directoryIterator->Iterate(kVideoMetaPathK2_4)) {
+ meta = M2_4;
+ metadata_dir = kVideoMetaPathK2_4;
+ } else {
+ meta = NONE;
+ }
+
+ if (meta != NONE) {
+ LOG(LS_INFO) << "V4L2 device metadata found at " << metadata_dir;
+
+ do {
+ std::string filename = directoryIterator->Name();
+
+ if (filename.find("video") == 0) {
+ std::string device_path = "/dev/" + filename;
+
+ if (V4LLookup::IsV4L2Device(device_path)) {
+ devices->push_back(
+ Device(GetVideoDeviceName(meta, filename), device_path));
+ }
+ }
+ } while (directoryIterator->Next());
+ } else {
+ LOG(LS_ERROR) << "Unable to detect v4l2 metadata directory";
+ }
+
+ if (devices->size() == 0) {
+ LOG(LS_INFO) << "Plan B. Scanning all video devices in /dev directory";
+ ScanDeviceDirectory("/dev/", devices);
+ }
+
+ LOG(LS_INFO) << "Total V4L2 devices found : " << devices->size();
+}
+
+bool LinuxDeviceManager::GetVideoCaptureDevices(std::vector<Device>* devices) {
+ devices->clear();
+ ScanV4L2Devices(devices);
+ return FilterDevices(devices, kFilteredVideoDevicesName);
+}
+
+LinuxDeviceWatcher::LinuxDeviceWatcher(DeviceManagerInterface* dm)
+ : DeviceWatcher(dm),
+ manager_(dm),
+ udev_(NULL),
+ udev_monitor_(NULL),
+ registered_(false) {
+}
+
+LinuxDeviceWatcher::~LinuxDeviceWatcher() {
+}
+
+bool LinuxDeviceWatcher::Start() {
+ // We deliberately return true in the failure paths here because libudev is
+ // not a critical component of a Linux system so it may not be present/usable,
+ // and we don't want to halt LinuxDeviceManager initialization in such a case.
+ if (!libudev_.Load()) {
+ LOG(LS_WARNING) << "libudev not present/usable; LinuxDeviceWatcher disabled";
+ return true;
+ }
+ udev_ = LATE(udev_new)();
+ if (!udev_) {
+ LOG_ERR(LS_ERROR) << "udev_new()";
+ return true;
+ }
+ // The second argument here is the event source. It can be either "kernel" or
+ // "udev", but "udev" is the only correct choice. Apps listen on udev and the
+ // udev daemon in turn listens on the kernel.
+ udev_monitor_ = LATE(udev_monitor_new_from_netlink)(udev_, "udev");
+ if (!udev_monitor_) {
+ LOG_ERR(LS_ERROR) << "udev_monitor_new_from_netlink()";
+ return true;
+ }
+ // We only listen for changes in the video devices. Audio devices are more or
+ // less unimportant because receiving device change notifications really only
+ // matters for broadcasting updated send/recv capabilities based on whether
+ // there is at least one device available, and almost all computers have at
+ // least one audio device. Also, PulseAudio device notifications don't come
+ // from the udev daemon, they come from the PulseAudio daemon, so we'd only
+ // want to listen for audio device changes from udev if using ALSA. For
+ // simplicity, we don't bother with any audio stuff at all.
+ if (LATE(udev_monitor_filter_add_match_subsystem_devtype)(udev_monitor_,
+ "video4linux",
+ NULL) < 0) {
+ LOG_ERR(LS_ERROR) << "udev_monitor_filter_add_match_subsystem_devtype()";
+ return true;
+ }
+ if (LATE(udev_monitor_enable_receiving)(udev_monitor_) < 0) {
+ LOG_ERR(LS_ERROR) << "udev_monitor_enable_receiving()";
+ return true;
+ }
+ static_cast<talk_base::PhysicalSocketServer*>(
+ talk_base::Thread::Current()->socketserver())->Add(this);
+ registered_ = true;
+ return true;
+}
+
+void LinuxDeviceWatcher::Stop() {
+ if (registered_) {
+ static_cast<talk_base::PhysicalSocketServer*>(
+ talk_base::Thread::Current()->socketserver())->Remove(this);
+ registered_ = false;
+ }
+ if (udev_monitor_) {
+ LATE(udev_monitor_unref)(udev_monitor_);
+ udev_monitor_ = NULL;
+ }
+ if (udev_) {
+ LATE(udev_unref)(udev_);
+ udev_ = NULL;
+ }
+ libudev_.Unload();
+}
+
+uint32 LinuxDeviceWatcher::GetRequestedEvents() {
+ return talk_base::DE_READ;
+}
+
+void LinuxDeviceWatcher::OnPreEvent(uint32 ff) {
+ // Nothing to do.
+}
+
+void LinuxDeviceWatcher::OnEvent(uint32 ff, int err) {
+ udev_device* device = LATE(udev_monitor_receive_device)(udev_monitor_);
+ if (!device) {
+ // Probably the socket connection to the udev daemon was terminated (perhaps
+ // the daemon crashed or is being restarted?).
+ LOG_ERR(LS_WARNING) << "udev_monitor_receive_device()";
+ // Stop listening to avoid potential livelock (an fd with EOF in it is
+ // always considered readable).
+ static_cast<talk_base::PhysicalSocketServer*>(
+ talk_base::Thread::Current()->socketserver())->Remove(this);
+ registered_ = false;
+ return;
+ }
+ // Else we read the device successfully.
+
+ // Since we already have our own filesystem-based device enumeration code, we
+ // simply re-enumerate rather than inspecting the device event.
+ LATE(udev_device_unref)(device);
+ manager_->SignalDevicesChange();
+}
+
+int LinuxDeviceWatcher::GetDescriptor() {
+ return LATE(udev_monitor_get_fd)(udev_monitor_);
+}
+
+bool LinuxDeviceWatcher::IsDescriptorClosed() {
+ // If it is closed then we will just get an error in
+ // udev_monitor_receive_device and unregister, so we don't need to check for
+ // it separately.
+ return false;
+}
+
+}; // namespace cricket
diff --git a/talk/session/phone/linuxdevicemanager.h b/talk/session/phone/linuxdevicemanager.h
new file mode 100644
index 0000000..dce3286
--- /dev/null
+++ b/talk/session/phone/linuxdevicemanager.h
@@ -0,0 +1,55 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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_SESSION_PHONE_LINUXDEVICEMANAGER_H_
+#define TALK_SESSION_PHONE_LINUXDEVICEMANAGER_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/base/sigslot.h"
+#include "talk/base/stringencode.h"
+#include "talk/session/phone/devicemanager.h"
+#include "talk/sound/soundsystemfactory.h"
+
+namespace cricket {
+
+class LinuxDeviceManager : public DeviceManager {
+ public:
+ LinuxDeviceManager();
+ virtual ~LinuxDeviceManager();
+
+ virtual bool GetVideoCaptureDevices(std::vector<Device>* devs);
+
+ private:
+ virtual bool GetAudioDevices(bool input, std::vector<Device>* devs);
+ SoundSystemHandle sound_system_;
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_LINUXDEVICEMANAGER_H_
diff --git a/talk/session/phone/macdevicemanager.cc b/talk/session/phone/macdevicemanager.cc
new file mode 100644
index 0000000..bad5ea9
--- /dev/null
+++ b/talk/session/phone/macdevicemanager.cc
@@ -0,0 +1,198 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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/session/phone/macdevicemanager.h"
+
+#include <CoreAudio/CoreAudio.h>
+#include <QuickTime/QuickTime.h>
+
+#include "talk/base/logging.h"
+#include "talk/base/stringutils.h"
+#include "talk/base/thread.h"
+#include "talk/session/phone/mediacommon.h"
+
+class DeviceWatcherImpl;
+
+namespace cricket {
+
+DeviceManagerInterface* DeviceManagerFactory::Create() {
+ return new MacDeviceManager();
+}
+
+class MacDeviceWatcher : public DeviceWatcher {
+ public:
+ explicit MacDeviceWatcher(DeviceManagerInterface* dm);
+ virtual ~MacDeviceWatcher();
+ virtual bool Start();
+ virtual void Stop();
+
+ private:
+ DeviceManagerInterface* manager_;
+ DeviceWatcherImpl* impl_;
+};
+
+static const char* kFilteredAudioDevicesName[] = {
+ NULL,
+};
+// TODO: Try to get hold of a copy of Final Cut to understand why we
+// crash while scanning their components on OS X.
+static const char* const kFilteredVideoDevicesName[] = {
+ "Google Camera Adapter", // Our own magiccams
+ "DVCPRO HD", // Final cut
+ "Sonix SN9C201p", // Crashes in OpenAComponent and CloseComponent
+ NULL,
+};
+static const int kVideoDeviceOpenAttempts = 3;
+static const UInt32 kAudioDeviceNameLength = 64;
+// Obj-C functions defined in macdevicemanagermm.mm
+// TODO: have a shared header for these function defines.
+extern DeviceWatcherImpl* CreateDeviceWatcherCallback(
+ DeviceManagerInterface* dm);
+extern void ReleaseDeviceWatcherCallback(DeviceWatcherImpl* impl);
+extern bool GetQTKitVideoDevices(std::vector<Device>* out);
+static bool GetAudioDeviceIDs(bool inputs, std::vector<AudioDeviceID>* out);
+static bool GetAudioDeviceName(AudioDeviceID id, bool input, std::string* out);
+
+MacDeviceManager::MacDeviceManager() {
+ set_watcher(new MacDeviceWatcher(this));
+}
+
+MacDeviceManager::~MacDeviceManager() {
+}
+
+bool MacDeviceManager::GetVideoCaptureDevices(std::vector<Device>* devices) {
+ devices->clear();
+ if (!GetQTKitVideoDevices(devices)) {
+ return false;
+ }
+ return FilterDevices(devices, kFilteredVideoDevicesName);
+}
+
+bool MacDeviceManager::GetAudioDevices(bool input,
+ std::vector<Device>* devs) {
+ devs->clear();
+ std::vector<AudioDeviceID> dev_ids;
+ bool ret = GetAudioDeviceIDs(input, &dev_ids);
+ if (!ret) {
+ return false;
+ }
+ for (size_t i = 0; i < dev_ids.size(); ++i) {
+ std::string name;
+ if (GetAudioDeviceName(dev_ids[i], input, &name)) {
+ devs->push_back(Device(name, dev_ids[i]));
+ }
+ }
+ return FilterDevices(devs, kFilteredAudioDevicesName);
+}
+
+static bool GetAudioDeviceIDs(bool input,
+ std::vector<AudioDeviceID>* out_dev_ids) {
+ UInt32 propsize;
+ OSErr err = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices,
+ &propsize, NULL);
+ if (0 != err) {
+ LOG(LS_ERROR) << "Couldn't get information about property, "
+ << "so no device list acquired.";
+ return false;
+ }
+
+ size_t num_devices = propsize / sizeof(AudioDeviceID);
+ talk_base::scoped_array<AudioDeviceID> device_ids(
+ new AudioDeviceID[num_devices]);
+
+ err = AudioHardwareGetProperty(kAudioHardwarePropertyDevices,
+ &propsize, device_ids.get());
+ if (0 != err) {
+ LOG(LS_ERROR) << "Failed to get device ids, "
+ << "so no device listing acquired.";
+ return false;
+ }
+
+ for (size_t i = 0; i < num_devices; ++i) {
+ AudioDeviceID an_id = device_ids[i];
+ // find out the number of channels for this direction
+ // (input/output) on this device -
+ // we'll ignore anything with no channels.
+ err = AudioDeviceGetPropertyInfo(an_id, 0, input,
+ kAudioDevicePropertyStreams,
+ &propsize, NULL);
+ if (0 == err) {
+ unsigned num_channels = propsize / sizeof(AudioStreamID);
+ if (0 < num_channels) {
+ out_dev_ids->push_back(an_id);
+ }
+ } else {
+ LOG(LS_ERROR) << "No property info for stream property for device id "
+ << an_id << "(is_input == " << input
+ << "), so not including it in the list.";
+ }
+ }
+
+ return true;
+}
+
+static bool GetAudioDeviceName(AudioDeviceID id,
+ bool input,
+ std::string* out_name) {
+ UInt32 nameLength = kAudioDeviceNameLength;
+ char name[kAudioDeviceNameLength + 1];
+ OSErr err = AudioDeviceGetProperty(id, 0, input,
+ kAudioDevicePropertyDeviceName,
+ &nameLength, name);
+ if (0 != err) {
+ LOG(LS_ERROR) << "No name acquired for device id " << id;
+ return false;
+ }
+
+ *out_name = name;
+ return true;
+}
+
+MacDeviceWatcher::MacDeviceWatcher(DeviceManagerInterface* manager)
+ : DeviceWatcher(manager),
+ manager_(manager),
+ impl_(NULL) {
+}
+
+MacDeviceWatcher::~MacDeviceWatcher() {
+}
+
+bool MacDeviceWatcher::Start() {
+ if (!impl_) {
+ impl_ = CreateDeviceWatcherCallback(manager_);
+ }
+ return impl_ != NULL;
+}
+
+void MacDeviceWatcher::Stop() {
+ if (impl_) {
+ ReleaseDeviceWatcherCallback(impl_);
+ impl_ = NULL;
+ }
+}
+
+}; // namespace cricket
diff --git a/talk/session/phone/macdevicemanager.h b/talk/session/phone/macdevicemanager.h
new file mode 100644
index 0000000..ec4cfc0
--- /dev/null
+++ b/talk/session/phone/macdevicemanager.h
@@ -0,0 +1,56 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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_SESSION_PHONE_MACDEVICEMANAGER_H_
+#define TALK_SESSION_PHONE_MACDEVICEMANAGER_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/base/sigslot.h"
+#include "talk/base/stringencode.h"
+#include "talk/session/phone/devicemanager.h"
+
+namespace cricket {
+
+class DeviceWatcher;
+
+class MacDeviceManager : public DeviceManager {
+ public:
+ MacDeviceManager();
+ virtual ~MacDeviceManager();
+
+ virtual bool GetVideoCaptureDevices(std::vector<Device>* devs);
+
+ private:
+ virtual bool GetAudioDevices(bool input, std::vector<Device>* devs);
+ bool FilterDevice(const Device& d);
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_MACDEVICEMANAGER_H_
diff --git a/talk/session/phone/macdevicemanagermm.mm b/talk/session/phone/macdevicemanagermm.mm
new file mode 100644
index 0000000..db970c2
--- /dev/null
+++ b/talk/session/phone/macdevicemanagermm.mm
@@ -0,0 +1,116 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, 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/session/phone/devicemanager.h"
+
+#import <assert.h>
+#import <QTKit/QTKit.h>
+
+#include "talk/base/logging.h"
+
+@interface DeviceWatcherImpl : NSObject {
+ @private
+ cricket::DeviceManagerInterface* manager_;
+}
+- (id)init:(cricket::DeviceManagerInterface*)manager;
+- (void)onDevicesChanged:(NSNotification *)notification;
+@end
+
+@implementation DeviceWatcherImpl
+- (id)init:(cricket::DeviceManagerInterface*)manager {
+ if ((self = [super init])) {
+ assert(manager != NULL);
+ manager_ = manager;
+ [[NSNotificationCenter defaultCenter] addObserver:self
+ selector:@selector(onDevicesChanged:)
+ name:QTCaptureDeviceWasConnectedNotification
+ object:nil];
+ [[NSNotificationCenter defaultCenter] addObserver:self
+ selector:@selector(onDevicesChanged:)
+ name:QTCaptureDeviceWasDisconnectedNotification
+ object:nil];
+ }
+ return self;
+}
+
+- (void)dealloc {
+ [[NSNotificationCenter defaultCenter] removeObserver:self];
+ [super dealloc];
+}
+- (void)onDevicesChanged:(NSNotification *)notification {
+ manager_->SignalDevicesChange();
+}
+@end
+
+namespace cricket {
+
+DeviceWatcherImpl* CreateDeviceWatcherCallback(
+ DeviceManagerInterface* manager) {
+ NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+ DeviceWatcherImpl* impl = [[DeviceWatcherImpl alloc] init:manager];
+ [pool drain];
+ return impl;
+}
+
+void ReleaseDeviceWatcherCallback(DeviceWatcherImpl* watcher) {
+ NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+ [watcher release];
+ [pool drain];
+}
+
+bool GetQTKitVideoDevices(std::vector<Device>* devices) {
+ NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+
+ NSArray* qt_capture_devices =
+ [QTCaptureDevice inputDevicesWithMediaType:QTMediaTypeVideo];
+ NSUInteger count = [qt_capture_devices count];
+ LOG(LS_INFO) << count << " capture device(s) found:";
+ for (QTCaptureDevice* qt_capture_device in qt_capture_devices) {
+ static NSString* const kFormat = @"localizedDisplayName: \"%@\", "
+ @"modelUniqueID: \"%@\", uniqueID \"%@\", isConnected: %d, isOpen: %d, "
+ @"isInUseByAnotherApplication: %d";
+ NSString* info = [NSString stringWithFormat:kFormat,
+ [qt_capture_device localizedDisplayName],
+ [qt_capture_device modelUniqueID],
+ [qt_capture_device uniqueID],
+ [qt_capture_device isConnected],
+ [qt_capture_device isOpen],
+ [qt_capture_device isInUseByAnotherApplication]];
+ LOG(LS_INFO) << [info UTF8String];
+
+ std::string name([[qt_capture_device localizedDisplayName]
+ UTF8String]);
+ devices->push_back(Device(name,
+ [[qt_capture_device uniqueID]
+ UTF8String]));
+ }
+
+ [pool drain];
+ return true;
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/mediachannel.h b/talk/session/phone/mediachannel.h
index aa32671..cf86ce6 100644
--- a/talk/session/phone/mediachannel.h
+++ b/talk/session/phone/mediachannel.h
@@ -34,6 +34,7 @@
#include "talk/base/basictypes.h"
#include "talk/base/sigslot.h"
#include "talk/base/socket.h"
+#include "talk/base/window.h"
#include "talk/session/phone/codec.h"
// TODO: re-evaluate this include
#include "talk/session/phone/audiomonitor.h"
@@ -44,6 +45,9 @@
namespace cricket {
+class ScreencastId;
+struct StreamParams;
+struct VideoFormat;
class VideoRenderer;
const int kMinRtpHeaderExtensionId = 1;
@@ -72,13 +76,18 @@
// TODO: SendRecv direction;
};
-enum VoiceMediaChannelOptions {
- OPT_CONFERENCE = 0x10000, // tune the audio stream for conference mode
+enum MediaChannelOptions {
+ // Tune the stream for conference mode.
+ OPT_CONFERENCE = 0x0001
+};
+enum VoiceMediaChannelOptions {
+ // Tune the audio stream for vcs with different target levels.
+ OPT_AGC_MINUS_10DB = 0x80000000
};
enum VideoMediaChannelOptions {
- // Increase the output framerate by 2x by interpolating frames
+ // Increase the output framerate by 2x by interpolating frames.
OPT_INTERPOLATE = 0x10000,
// Enable video adaptation due to cpu load.
OPT_CPU_ADAPTATION = 0x20000
@@ -109,10 +118,21 @@
virtual void OnPacketReceived(talk_base::Buffer* packet) = 0;
// Called when a RTCP packet is received.
virtual void OnRtcpReceived(talk_base::Buffer* packet) = 0;
- // Sets the SSRC to be used for outgoing data.
- virtual void SetSendSsrc(uint32 id) = 0;
- // Set the CNAME of RTCP
- virtual bool SetRtcpCName(const std::string& cname) = 0;
+ // Creates a new outgoing media stream with SSRCs and CNAME as described
+ // by sp.
+ virtual bool AddSendStream(const StreamParams& sp) = 0;
+ // Removes an outgoing media stream.
+ // ssrc must be the first SSRC of the media stream if the stream uses
+ // multiple SSRCs.
+ virtual bool RemoveSendStream(uint32 ssrc) = 0;
+ // Creates a new incoming media stream with SSRCs and CNAME as described
+ // by sp.
+ virtual bool AddRecvStream(const StreamParams& sp) = 0;
+ // Removes an incoming media stream.
+ // ssrc must be the first SSRC of the media stream if the stream uses
+ // multiple SSRCs.
+ virtual bool RemoveRecvStream(uint32 ssrc) = 0;
+
// Mutes the channel.
virtual bool Mute(bool on) = 0;
@@ -138,7 +158,24 @@
};
struct VoiceSenderInfo {
+ VoiceSenderInfo()
+ : ssrc(0),
+ bytes_sent(0),
+ packets_sent(0),
+ packets_lost(0),
+ fraction_lost(0.0),
+ ext_seqnum(0),
+ rtt_ms(0),
+ jitter_ms(0),
+ audio_level(0),
+ echo_delay_median_ms(0),
+ echo_delay_std_ms(0),
+ echo_return_loss(0),
+ echo_return_loss_enhancement(0) {
+ }
+
uint32 ssrc;
+ std::string codec_name;
int bytes_sent;
int packets_sent;
int packets_lost;
@@ -147,9 +184,27 @@
int rtt_ms;
int jitter_ms;
int audio_level;
+ int echo_delay_median_ms;
+ int echo_delay_std_ms;
+ int echo_return_loss;
+ int echo_return_loss_enhancement;
};
struct VoiceReceiverInfo {
+ VoiceReceiverInfo()
+ : ssrc(0),
+ bytes_rcvd(0),
+ packets_rcvd(0),
+ packets_lost(0),
+ fraction_lost(0.0),
+ ext_seqnum(0),
+ jitter_ms(0),
+ jitter_buffer_ms(0),
+ jitter_buffer_preferred_ms(0),
+ delay_estimate_ms(0),
+ audio_level(0) {
+ }
+
uint32 ssrc;
int bytes_rcvd;
int packets_rcvd;
@@ -164,7 +219,26 @@
};
struct VideoSenderInfo {
+ VideoSenderInfo()
+ : ssrc(0),
+ bytes_sent(0),
+ packets_sent(0),
+ packets_cached(0),
+ packets_lost(0),
+ fraction_lost(0.0),
+ firs_rcvd(0),
+ nacks_rcvd(0),
+ rtt_ms(0),
+ frame_width(0),
+ frame_height(0),
+ framerate_input(0),
+ framerate_sent(0),
+ nominal_bitrate(0),
+ preferred_bitrate(0) {
+ }
+
uint32 ssrc;
+ std::string codec_name;
int bytes_sent;
int packets_sent;
int packets_cached;
@@ -182,6 +256,22 @@
};
struct VideoReceiverInfo {
+ VideoReceiverInfo()
+ : ssrc(0),
+ bytes_rcvd(0),
+ packets_rcvd(0),
+ packets_lost(0),
+ packets_concealed(0),
+ fraction_lost(0.0),
+ firs_sent(0),
+ nacks_sent(0),
+ frame_width(0),
+ frame_height(0),
+ framerate_rcvd(0),
+ framerate_decoded(0),
+ framerate_output(0) {
+ }
+
uint32 ssrc;
int bytes_rcvd;
// vector<int> layer_bytes_rcvd;
@@ -199,6 +289,16 @@
};
struct BandwidthEstimationInfo {
+ BandwidthEstimationInfo()
+ : available_send_bandwidth(0),
+ available_recv_bandwidth(0),
+ target_enc_bitrate(0),
+ actual_enc_bitrate(0),
+ retransmit_bitrate(0),
+ transmit_bitrate(0),
+ bucket_delay(0) {
+ }
+
int available_send_bandwidth;
int available_recv_bandwidth;
int target_enc_bitrate;
@@ -261,10 +361,6 @@
virtual bool SetPlayout(bool playout) = 0;
// Starts or stops sending (and potentially capture) of local audio.
virtual bool SetSend(SendFlags flag) = 0;
- // Adds a new receive-only stream with the specified SSRC.
- virtual bool AddStream(uint32 ssrc) = 0;
- // Removes a stream added with AddStream.
- virtual bool RemoveStream(uint32 ssrc) = 0;
// Gets current energy levels for all incoming streams.
virtual bool GetActiveStreams(AudioInfo::StreamList* actives) = 0;
// Get the current energy level of the stream sent to the speaker.
@@ -315,17 +411,17 @@
virtual bool SetRecvCodecs(const std::vector<VideoCodec> &codecs) = 0;
// Sets the codecs/payload types to be used for outgoing media.
virtual bool SetSendCodecs(const std::vector<VideoCodec> &codecs) = 0;
+ // Sets the format of a specified outgoing stream.
+ virtual bool SetSendStreamFormat(uint32 ssrc, const VideoFormat& format) = 0;
// Starts or stops playout of received video.
virtual bool SetRender(bool render) = 0;
// Starts or stops transmission (and potentially capture) of local video.
virtual bool SetSend(bool send) = 0;
- // Adds a new receive-only stream with the specified SSRC.
- virtual bool AddStream(uint32 ssrc, uint32 voice_ssrc) = 0;
- // Removes a stream added with AddStream.
- virtual bool RemoveStream(uint32 ssrc) = 0;
// Sets the renderer object to be used for the specified stream.
// If SSRC is 0, the renderer is used for the 'default' stream.
virtual bool SetRenderer(uint32 ssrc, VideoRenderer* renderer) = 0;
+ virtual bool AddScreencast(uint32 ssrc, const ScreencastId& id) = 0;
+ virtual bool RemoveScreencast(uint32 ssrc) = 0;
// Gets quality stats for the channel.
virtual bool GetStats(VideoMediaInfo* info) = 0;
@@ -334,6 +430,8 @@
// Reuqest each of the remote senders to send an intra frame.
virtual bool RequestIntraFrame() = 0;
+ // Signals events from the currently active window.
+ sigslot::signal2<uint32, talk_base::WindowEvent> SignalScreencastWindowEvent;
sigslot::signal2<uint32, Error> SignalMediaError;
protected:
diff --git a/talk/session/phone/mediaengine.cc b/talk/session/phone/mediaengine.cc
index 992fc15..05c7274 100644
--- a/talk/session/phone/mediaengine.cc
+++ b/talk/session/phone/mediaengine.cc
@@ -29,6 +29,8 @@
#if defined(HAVE_LINPHONE)
#include "talk/session/phone/linphonemediaengine.h"
+#elif defined(ANDROID)
+#include "talk/session/phone/androidmediaengine.h"
#else
#if defined(HAVE_WEBRTC_VOICE)
#include "talk/session/phone/webrtcvoiceengine.h"
@@ -47,6 +49,11 @@
#endif
#if defined(HAVE_WEBRTC_VIDEO)
+template<>
+CompositeMediaEngine<WebRtcVoiceEngine, WebRtcVideoEngine>::
+ CompositeMediaEngine() {
+ video_.SetVoiceEngine(&voice_);
+}
#define VIDEO_ENG_NAME WebRtcVideoEngine
#endif
@@ -58,6 +65,8 @@
MediaEngineInterface* MediaEngineFactory::Create() {
#if defined(HAVE_LINPHONE)
return new LinphoneMediaEngine("", "");
+#elif defined(ANDROID)
+ return AndroidMediaEngineFactory::Create();
#elif defined(AUDIO_ENG_NAME) && defined(VIDEO_ENG_NAME)
return new CompositeMediaEngine<AUDIO_ENG_NAME, VIDEO_ENG_NAME>();
#else
diff --git a/talk/session/phone/mediaengine.h b/talk/session/phone/mediaengine.h
index 9ea808d..cc77099 100644
--- a/talk/session/phone/mediaengine.h
+++ b/talk/session/phone/mediaengine.h
@@ -32,6 +32,7 @@
#include <CoreAudio/CoreAudio.h>
#endif
+#include <climits>
#include <string>
#include <vector>
@@ -40,10 +41,19 @@
#include "talk/session/phone/devicemanager.h"
#include "talk/session/phone/mediachannel.h"
#include "talk/session/phone/mediacommon.h"
+#include "talk/session/phone/videoprocessor.h"
#include "talk/session/phone/videocommon.h"
+#include "talk/session/phone/voiceprocessor.h"
namespace cricket {
+// TODO: For now, a hard-coded ssrc is used as the video ssrc.
+// This is because when the video frame is passed to the mediaprocessor for
+// processing, it doesn't have the correct ssrc. Since currently only Tx
+// Video processing is supported, this is ok. When we switch over to trigger
+// from capturer, this should be fixed and this const removed.
+const uint32 kDummyVideoSsrc = 0xFFFFFFFF;
+
class VideoCapturer;
// MediaEngineInterface is an abstraction of a media engine which can be
@@ -58,7 +68,6 @@
ECHO_CANCELLATION = 1 << 0,
AUTO_GAIN_CONTROL = 1 << 1,
NOISE_SUPPRESSION = 1 << 2,
- TYPING_DETECTION = 1 << 3,
DEFAULT_AUDIO_OPTIONS = ECHO_CANCELLATION | AUTO_GAIN_CONTROL
};
enum VideoOptions {
@@ -100,6 +109,9 @@
virtual bool SetSoundDevices(const Device* in_device,
const Device* out_device) = 0;
virtual bool SetVideoCaptureDevice(const Device* cam_device) = 0;
+ // Sets the externally provided video capturer. The ssrc is the ssrc of the
+ // (video) stream for which the video capturer should be set.
+ virtual bool SetVideoCapturer(VideoCapturer* capturer, uint32 ssrc) = 0;
// Device configuration
// Gets the current speaker volume, as a value between 0 and 255.
@@ -126,6 +138,16 @@
virtual void SetVoiceLogging(int min_sev, const char* filter) = 0;
virtual void SetVideoLogging(int min_sev, const char* filter) = 0;
+ // media processors for effects
+ virtual bool RegisterVideoProcessor(VideoProcessor* video_processor) = 0;
+ virtual bool UnregisterVideoProcessor(VideoProcessor* video_processor) = 0;
+ virtual bool RegisterVoiceProcessor(uint32 ssrc,
+ VoiceProcessor* video_processor,
+ MediaProcessorDirection direction) = 0;
+ virtual bool UnregisterVoiceProcessor(uint32 ssrc,
+ VoiceProcessor* video_processor,
+ MediaProcessorDirection direction) = 0;
+
sigslot::repeater2<VideoCapturer*, CaptureResult>
SignalVideoCaptureResult;
};
@@ -136,7 +158,6 @@
static MediaEngineInterface* Create();
};
-
// CompositeMediaEngine constructs a MediaEngine from separate
// voice and video engine classes.
template<class VOICE, class VIDEO>
@@ -189,6 +210,9 @@
virtual bool SetVideoCaptureDevice(const Device* cam_device) {
return video_.SetCaptureDevice(cam_device);
}
+ virtual bool SetVideoCapturer(VideoCapturer* capturer, uint32 ssrc) {
+ return video_.SetVideoCapturer(capturer, ssrc);
+ }
virtual bool GetOutputVolume(int* level) {
return voice_.GetOutputVolume(level);
@@ -224,6 +248,23 @@
return video_.SetLogging(min_sev, filter);
}
+ virtual bool RegisterVideoProcessor(VideoProcessor* processor) {
+ return video_.RegisterProcessor(processor);
+ }
+ virtual bool UnregisterVideoProcessor(VideoProcessor* processor) {
+ return video_.UnregisterProcessor(processor);
+ }
+ virtual bool RegisterVoiceProcessor(uint32 ssrc,
+ VoiceProcessor* processor,
+ MediaProcessorDirection direction) {
+ return voice_.RegisterProcessor(ssrc, processor, direction);
+ }
+ virtual bool UnregisterVoiceProcessor(uint32 ssrc,
+ VoiceProcessor* processor,
+ MediaProcessorDirection direction) {
+ return voice_.UnregisterProcessor(ssrc, processor, direction);
+ }
+
protected:
VOICE voice_;
VIDEO video_;
@@ -256,6 +297,12 @@
bool SetLocalMonitor(bool enable) { return true; }
const std::vector<AudioCodec>& codecs() { return codecs_; }
void SetLogging(int min_sev, const char* filter) {}
+ bool RegisterProcessor(uint32 ssrc,
+ VoiceProcessor* voice_processor,
+ MediaProcessorDirection direction) { return true; }
+ bool UnregisterProcessor(uint32 ssrc,
+ VoiceProcessor* voice_processor,
+ MediaProcessorDirection direction) { return true; }
private:
std::vector<AudioCodec> codecs_;
@@ -282,6 +329,10 @@
CaptureResult SetCapture(bool capture) { return CR_SUCCESS; }
const std::vector<VideoCodec>& codecs() { return codecs_; }
void SetLogging(int min_sev, const char* filter) {}
+ bool RegisterProcessor(VideoProcessor* video_processor) { return true; }
+ bool UnregisterProcessor(VideoProcessor* video_processor) { return true; }
+ bool SetVideoCapturer(VideoCapturer* capturer, uint32 ssrc) { return true; }
+
sigslot::signal2<VideoCapturer*, CaptureResult> SignalCaptureResult;
private:
std::vector<VideoCodec> codecs_;
diff --git a/talk/session/phone/mediamessages.cc b/talk/session/phone/mediamessages.cc
index 9031351..3dd6982 100644
--- a/talk/session/phone/mediamessages.cc
+++ b/talk/session/phone/mediamessages.cc
@@ -31,55 +31,22 @@
#include "talk/session/phone/mediamessages.h"
+#include "talk/base/logging.h"
#include "talk/base/stringencode.h"
#include "talk/p2p/base/constants.h"
+#include "talk/p2p/base/parsing.h"
#include "talk/session/phone/mediasessionclient.h"
+#include "talk/session/phone/streamparams.h"
#include "talk/xmllite/xmlelement.h"
namespace cricket {
namespace {
-bool GetFirstSourceByNick(const NamedSources& sources,
- const std::string& nick,
- NamedSource* source_out) {
- for (NamedSources::const_iterator source = sources.begin();
- source != sources.end(); ++source) {
- if (source->nick == nick) {
- *source_out = *source;
- return true;
- }
- }
- return false;
-}
-
-bool GetSourceBySsrc(const NamedSources& sources, uint32 ssrc,
- NamedSource* source_out) {
- for (NamedSources::const_iterator source = sources.begin();
- source != sources.end(); ++source) {
- if (source->ssrc == ssrc) {
- *source_out = *source;
- return true;
- }
- }
- return false;
-}
-
-// NOTE: There is no check here for duplicate sources, so check before
+// NOTE: There is no check here for duplicate streams, so check before
// adding.
-void AddSource(NamedSources* sources, const NamedSource& source) {
- sources->push_back(source);
-}
-
-void RemoveSourceBySsrc(uint32 ssrc, NamedSources* sources) {
- for (NamedSources::iterator source = sources->begin();
- source != sources->end(); ) {
- if (source->ssrc == ssrc) {
- source = sources->erase(source);
- } else {
- ++source;
- }
- }
+void AddStream(std::vector<StreamParams>* streams, const StreamParams& stream) {
+ streams->push_back(stream);
}
bool ParseSsrc(const std::string& string, uint32* ssrc) {
@@ -93,41 +60,14 @@
return ParseSsrc(element->BodyText(), ssrc);
}
-bool ParseNamedSource(const buzz::XmlElement* source_elem,
- NamedSource* named_source,
- ParseError* error) {
- named_source->nick = source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_NICK);
- if (named_source->nick.empty()) {
- return BadParse("Missing or invalid nick.", error);
- }
-
- named_source->name = source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_NAME);
- named_source->usage = source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_USAGE);
- named_source->removed =
- STR_JINGLE_DRAFT_SOURCE_STATE_REMOVED ==
- source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_STATE);
-
- const buzz::XmlElement* ssrc_elem =
- source_elem->FirstNamed(QN_JINGLE_DRAFT_SOURCE_SSRC);
- if (ssrc_elem != NULL && !ssrc_elem->BodyText().empty()) {
- uint32 ssrc;
- if (!ParseSsrc(ssrc_elem->BodyText(), &ssrc)) {
- return BadParse("Missing or invalid ssrc.", error);
- }
- named_source->SetSsrc(ssrc);
- }
-
- return true;
-}
-
// Builds a <view> element according to the following spec:
// goto/jinglemuc
buzz::XmlElement* CreateViewElem(const std::string& name,
const std::string& type) {
buzz::XmlElement* view_elem =
new buzz::XmlElement(QN_JINGLE_DRAFT_VIEW, true);
- view_elem->AddAttr(QN_JINGLE_DRAFT_CONTENT_NAME, name);
- view_elem->SetAttr(QN_JINGLE_DRAFT_VIEW_TYPE, type);
+ view_elem->AddAttr(QN_NAME, name);
+ view_elem->SetAttr(QN_TYPE, type);
return view_elem;
}
@@ -144,16 +84,13 @@
const StaticVideoView& view) {
buzz::XmlElement* view_elem =
CreateVideoViewElem(content_name, STR_JINGLE_DRAFT_VIEW_TYPE_STATIC);
- AddXmlAttr(view_elem, QN_JINGLE_DRAFT_VIEW_SSRC, view.ssrc);
+ AddXmlAttr(view_elem, QN_SSRC, view.ssrc);
- buzz::XmlElement* params_elem = new buzz::XmlElement(
- QN_JINGLE_DRAFT_VIEW_PARAMS);
- AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_WIDTH, view.width);
- AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_HEIGHT, view.height);
- AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_FRAMERATE,
- view.framerate);
- AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_PREFERENCE,
- view.preference);
+ buzz::XmlElement* params_elem = new buzz::XmlElement(QN_JINGLE_DRAFT_PARAMS);
+ AddXmlAttr(params_elem, QN_WIDTH, view.width);
+ AddXmlAttr(params_elem, QN_HEIGHT, view.height);
+ AddXmlAttr(params_elem, QN_FRAMERATE, view.framerate);
+ AddXmlAttr(params_elem, QN_PREFERENCE, view.preference);
view_elem->AddElement(params_elem);
return view_elem;
@@ -161,49 +98,100 @@
} // namespace
-bool MediaSources::GetFirstAudioSourceByNick(
- const std::string& nick, NamedSource* source) {
- return GetFirstSourceByNick(audio_, nick, source);
+bool MediaStreams::GetAudioStreamByNickAndName(
+ const std::string& nick, const std::string& name, StreamParams* stream) {
+ return GetStreamByNickAndName(audio_, nick, name, stream);
}
-bool MediaSources::GetFirstVideoSourceByNick(
- const std::string& nick, NamedSource* source) {
- return GetFirstSourceByNick(video_, nick, source);
+bool MediaStreams::GetVideoStreamByNickAndName(
+ const std::string& nick, const std::string& name, StreamParams* stream) {
+ return GetStreamByNickAndName(video_, nick, name, stream);
}
-void MediaSources::CopyFrom(const MediaSources& sources) {
- audio_ = sources.audio_;
- video_ = sources.video_;
+void MediaStreams::CopyFrom(const MediaStreams& streams) {
+ audio_ = streams.audio_;
+ video_ = streams.video_;
}
-bool MediaSources::GetAudioSourceBySsrc(uint32 ssrc, NamedSource* source) {
- return GetSourceBySsrc(audio_, ssrc, source);
+bool MediaStreams::GetAudioStreamBySsrc(uint32 ssrc, StreamParams* stream) {
+ return GetStreamBySsrc(audio_, ssrc, stream);
}
-bool MediaSources::GetVideoSourceBySsrc(uint32 ssrc, NamedSource* source) {
- return GetSourceBySsrc(video_, ssrc, source);
+bool MediaStreams::GetVideoStreamBySsrc(uint32 ssrc, StreamParams* stream) {
+ return GetStreamBySsrc(video_, ssrc, stream);
}
-void MediaSources::AddAudioSource(const NamedSource& source) {
- AddSource(&audio_, source);
+void MediaStreams::AddAudioStream(const StreamParams& stream) {
+ AddStream(&audio_, stream);
}
-void MediaSources::AddVideoSource(const NamedSource& source) {
- AddSource(&video_, source);
+void MediaStreams::AddVideoStream(const StreamParams& stream) {
+ AddStream(&video_, stream);
}
-void MediaSources::RemoveAudioSourceBySsrc(uint32 ssrc) {
- RemoveSourceBySsrc(ssrc, &audio_);
+void MediaStreams::RemoveAudioStreamByNickAndName(
+ const std::string& nick, const std::string& name) {
+ RemoveStreamByNickAndName(&audio_, nick, name);
}
-void MediaSources::RemoveVideoSourceBySsrc(uint32 ssrc) {
- RemoveSourceBySsrc(ssrc, &video_);
+void MediaStreams::RemoveVideoStreamByNickAndName(
+ const std::string& nick, const std::string& name) {
+ RemoveStreamByNickAndName(&video_, nick, name);
}
-bool WriteViewRequest(const std::string& content_name,
- const ViewRequest& request,
- XmlElements* elems,
- WriteError* error) {
+bool IsJingleViewRequest(const buzz::XmlElement* action_elem) {
+ return action_elem->FirstNamed(QN_JINGLE_DRAFT_VIEW) != NULL;
+}
+
+bool ParseStaticVideoView(const buzz::XmlElement* view_elem,
+ StaticVideoView* view,
+ ParseError* error) {
+ if (!ParseSsrc(view_elem->Attr(QN_SSRC), &(view->ssrc))) {
+ return BadParse("Invalid or missing view ssrc.", error);
+ }
+
+ const buzz::XmlElement* params_elem =
+ view_elem->FirstNamed(QN_JINGLE_DRAFT_PARAMS);
+ if (params_elem) {
+ view->width = GetXmlAttr(params_elem, QN_WIDTH, 0);
+ view->height = GetXmlAttr(params_elem, QN_HEIGHT, 0);
+ view->framerate = GetXmlAttr(params_elem, QN_FRAMERATE, 0);
+ view->preference = GetXmlAttr(params_elem, QN_PREFERENCE, 0);
+ } else {
+ return BadParse("Missing view params.", error);
+ }
+
+ return true;
+}
+
+bool ParseJingleViewRequest(const buzz::XmlElement* action_elem,
+ ViewRequest* view_request,
+ ParseError* error) {
+ for (const buzz::XmlElement* view_elem =
+ action_elem->FirstNamed(QN_JINGLE_DRAFT_VIEW);
+ view_elem != NULL;
+ view_elem = view_elem->NextNamed(QN_JINGLE_DRAFT_VIEW)) {
+ std::string type = view_elem->Attr(QN_TYPE);
+ if (STR_JINGLE_DRAFT_VIEW_TYPE_NONE == type) {
+ view_request->static_video_views.clear();
+ return true;
+ } else if (STR_JINGLE_DRAFT_VIEW_TYPE_STATIC == type) {
+ StaticVideoView static_video_view(0, 0, 0, 0);
+ if (!ParseStaticVideoView(view_elem, &static_video_view, error)) {
+ return false;
+ }
+ view_request->static_video_views.push_back(static_video_view);
+ } else {
+ LOG(LS_INFO) << "Ingnoring unknown view type: " << type;
+ }
+ }
+ return true;
+}
+
+bool WriteJingleViewRequest(const std::string& content_name,
+ const ViewRequest& request,
+ XmlElements* elems,
+ WriteError* error) {
if (request.static_video_views.empty()) {
elems->push_back(CreateNoneVideoViewElem(content_name));
} else {
@@ -216,46 +204,150 @@
return true;
}
-bool IsSourcesNotify(const buzz::XmlElement* action_elem) {
- return action_elem->FirstNamed(QN_JINGLE_DRAFT_NOTIFY) != NULL;
+bool ParseSsrcAsLegacyStream(const buzz::XmlElement* desc_elem,
+ std::vector<StreamParams>* streams,
+ ParseError* error) {
+ const std::string ssrc_str = desc_elem->Attr(QN_SSRC);
+ if (!ssrc_str.empty()) {
+ uint32 ssrc;
+ if (!ParseSsrc(ssrc_str, &ssrc)) {
+ return BadParse("Missing or invalid ssrc.", error);
+ }
+
+ streams->push_back(StreamParams::CreateLegacy(ssrc));
+ }
+ return true;
}
-bool ParseSourcesNotify(const buzz::XmlElement* action_elem,
- const SessionDescription* session_description,
- MediaSources* sources,
+bool ParseSsrcs(const buzz::XmlElement* parent_elem,
+ std::vector<uint32>* ssrcs,
+ ParseError* error) {
+ for (const buzz::XmlElement* ssrc_elem =
+ parent_elem->FirstNamed(QN_JINGLE_DRAFT_SSRC);
+ ssrc_elem != NULL;
+ ssrc_elem = ssrc_elem->NextNamed(QN_JINGLE_DRAFT_SSRC)) {
+ uint32 ssrc;
+ if (!ParseSsrc(ssrc_elem->BodyText(), &ssrc)) {
+ return BadParse("Missing or invalid ssrc.", error);
+ }
+
+ ssrcs->push_back(ssrc);
+ }
+ return true;
+}
+
+bool ParseSsrcGroups(const buzz::XmlElement* parent_elem,
+ std::vector<SsrcGroup>* ssrc_groups,
+ ParseError* error) {
+ for (const buzz::XmlElement* group_elem =
+ parent_elem->FirstNamed(QN_JINGLE_DRAFT_SSRC_GROUP);
+ group_elem != NULL;
+ group_elem = group_elem->NextNamed(QN_JINGLE_DRAFT_SSRC_GROUP)) {
+ std::string semantics = group_elem->Attr(QN_SEMANTICS);
+ std::vector<uint32> ssrcs;
+ if (!ParseSsrcs(group_elem, &ssrcs, error)) {
+ return false;
+ }
+ ssrc_groups->push_back(SsrcGroup(semantics, ssrcs));
+ }
+ return true;
+}
+
+bool ParseJingleStream(const buzz::XmlElement* stream_elem,
+ std::vector<StreamParams>* streams,
+ ParseError* error) {
+ StreamParams stream;
+ stream.nick = stream_elem->Attr(QN_NICK);
+ stream.name = stream_elem->Attr(QN_NAME);
+ stream.type = stream_elem->Attr(QN_TYPE);
+ stream.display = stream_elem->Attr(QN_DISPLAY);
+ stream.cname = stream_elem->Attr(QN_CNAME);
+ if (!ParseSsrcs(stream_elem, &(stream.ssrcs), error)) {
+ return false;
+ }
+ std::vector<SsrcGroup> ssrc_groups;
+ if (!ParseSsrcGroups(stream_elem, &(stream.ssrc_groups), error)) {
+ return false;
+ }
+ streams->push_back(stream);
+ return true;
+}
+
+bool HasJingleStreams(const buzz::XmlElement* desc_elem) {
+ const buzz::XmlElement* streams_elem =
+ desc_elem->FirstNamed(QN_JINGLE_DRAFT_STREAMS);
+ return (streams_elem != NULL);
+}
+
+bool ParseJingleStreams(const buzz::XmlElement* desc_elem,
+ std::vector<StreamParams>* streams,
ParseError* error) {
- for (const buzz::XmlElement* notify_elem =
- action_elem->FirstNamed(QN_JINGLE_DRAFT_NOTIFY);
- notify_elem != NULL;
- notify_elem = notify_elem->NextNamed(QN_JINGLE_DRAFT_NOTIFY)) {
- std::string content_name = notify_elem->Attr(QN_JINGLE_DRAFT_CONTENT_NAME);
- for (const buzz::XmlElement* source_elem =
- notify_elem->FirstNamed(QN_JINGLE_DRAFT_SOURCE);
- source_elem != NULL;
- source_elem = source_elem->NextNamed(QN_JINGLE_DRAFT_SOURCE)) {
- NamedSource named_source;
- if (!ParseNamedSource(source_elem, &named_source, error)) {
- return false;
- }
-
- if (session_description == NULL) {
- return BadParse("Unknown content name: " + content_name, error);
- }
- const ContentInfo* content =
- FindContentInfoByName(session_description->contents(), content_name);
- if (content == NULL) {
- return BadParse("Unknown content name: " + content_name, error);
- }
-
- if (IsAudioContent(content)) {
- sources->mutable_audio()->push_back(named_source);
- } else if (IsVideoContent(content)) {
- sources->mutable_video()->push_back(named_source);
- }
+ const buzz::XmlElement* streams_elem =
+ desc_elem->FirstNamed(QN_JINGLE_DRAFT_STREAMS);
+ if (streams_elem == NULL) {
+ return BadParse("Missing streams element.", error);
+ }
+ for (const buzz::XmlElement* stream_elem =
+ streams_elem->FirstNamed(QN_JINGLE_DRAFT_STREAM);
+ stream_elem != NULL;
+ stream_elem = stream_elem->NextNamed(QN_JINGLE_DRAFT_STREAM)) {
+ if (!ParseJingleStream(stream_elem, streams, error)) {
+ return false;
}
}
-
return true;
}
+void WriteSsrcs(const std::vector<uint32>& ssrcs,
+ buzz::XmlElement* parent_elem) {
+ for (std::vector<uint32>::const_iterator ssrc = ssrcs.begin();
+ ssrc != ssrcs.end(); ++ssrc) {
+ buzz::XmlElement* ssrc_elem =
+ new buzz::XmlElement(QN_JINGLE_DRAFT_SSRC, false);
+ SetXmlBody(ssrc_elem, *ssrc);
+
+ parent_elem->AddElement(ssrc_elem);
+ }
+}
+
+void WriteSsrcGroups(const std::vector<SsrcGroup>& groups,
+ buzz::XmlElement* parent_elem) {
+ for (std::vector<SsrcGroup>::const_iterator group = groups.begin();
+ group != groups.end(); ++group) {
+ buzz::XmlElement* group_elem =
+ new buzz::XmlElement(QN_JINGLE_DRAFT_SSRC_GROUP, false);
+ AddXmlAttrIfNonEmpty(group_elem, QN_SEMANTICS, group->semantics);
+ WriteSsrcs(group->ssrcs, group_elem);
+
+ parent_elem->AddElement(group_elem);
+ }
+}
+
+void WriteJingleStream(const StreamParams& stream,
+ buzz::XmlElement* parent_elem) {
+ buzz::XmlElement* stream_elem =
+ new buzz::XmlElement(QN_JINGLE_DRAFT_STREAM, false);
+ AddXmlAttrIfNonEmpty(stream_elem, QN_NICK, stream.nick);
+ AddXmlAttrIfNonEmpty(stream_elem, QN_NAME, stream.name);
+ AddXmlAttrIfNonEmpty(stream_elem, QN_TYPE, stream.type);
+ AddXmlAttrIfNonEmpty(stream_elem, QN_DISPLAY, stream.display);
+ AddXmlAttrIfNonEmpty(stream_elem, QN_CNAME, stream.cname);
+ WriteSsrcs(stream.ssrcs, stream_elem);
+ WriteSsrcGroups(stream.ssrc_groups, stream_elem);
+
+ parent_elem->AddElement(stream_elem);
+}
+
+void WriteJingleStreams(const std::vector<StreamParams>& streams,
+ buzz::XmlElement* parent_elem) {
+ buzz::XmlElement* streams_elem =
+ new buzz::XmlElement(QN_JINGLE_DRAFT_STREAMS, true);
+ for (std::vector<StreamParams>::const_iterator stream = streams.begin();
+ stream != streams.end(); ++stream) {
+ WriteJingleStream(*stream, streams_elem);
+ }
+
+ parent_elem->AddElement(streams_elem);
+}
+
} // namespace cricket
diff --git a/talk/session/phone/mediamessages.h b/talk/session/phone/mediamessages.h
index 541572f..6f38a64 100644
--- a/talk/session/phone/mediamessages.h
+++ b/talk/session/phone/mediamessages.h
@@ -45,62 +45,50 @@
namespace cricket {
-// In a <notify> message, there are number of sources with names.
-// This represents one such named source.
-struct NamedSource {
- NamedSource() : ssrc(0), ssrc_set(false), removed(false) {}
+struct StreamParams;
- void SetSsrc(uint32 ssrc) {
- this->ssrc = ssrc;
- this->ssrc_set = true;
+// A collection of audio and video streams. Most of the methods are
+// merely for convenience. Many of these methods are keyed by ssrc,
+// which is the source identifier in the RTP spec
+// (http://tools.ietf.org/html/rfc3550).
+struct MediaStreams {
+ public:
+ MediaStreams() {}
+ void CopyFrom(const MediaStreams& sources);
+
+ bool empty() const {
+ return audio_.empty() && video_.empty();
}
- std::string nick;
- std::string name;
- std::string usage;
- uint32 ssrc;
- bool ssrc_set;
- bool removed;
-};
+ std::vector<StreamParams>* mutable_audio() { return &audio_; }
+ std::vector<StreamParams>* mutable_video() { return &video_; }
+ const std::vector<StreamParams>& audio() const { return audio_; }
+ const std::vector<StreamParams>& video() const { return video_; }
-// TODO: Remove this, according to c++ readability.
-typedef std::vector<NamedSource> NamedSources;
-
-// A collection of named audio sources and named video sources, as
-// would be found in a typical <notify> message. Most of the methods
-// are merely for convenience. Many of these methods are keyed by
-// ssrc, which is the source identifier in the RTP spec
-// (http://tools.ietf.org/html/rfc3550).
-struct MediaSources {
- public:
- MediaSources() {}
- void CopyFrom(const MediaSources& sources);
-
- NamedSources* mutable_audio() { return &audio_; }
- NamedSources* mutable_video() { return &video_; }
- const NamedSources& audio() const { return audio_; }
- const NamedSources& video() const { return video_; }
-
+ // Remove the streams with the given name. Names are only unique to
+ // nicks, so you need the nick as well.
+ bool GetAudioStreamByNickAndName(
+ const std::string& nick, const std::string& name, StreamParams* source);
+ bool GetVideoStreamByNickAndName(
+ const std::string& nick, const std::string& name, StreamParams* source);
// Get the source with the given ssrc. Returns true if found.
- bool GetAudioSourceBySsrc(uint32 ssrc, NamedSource* source);
- bool GetVideoSourceBySsrc(uint32 ssrc, NamedSource* source);
- // Get the first source with the given nick. Returns true if found.
- // TODO: Remove the following two methods once all
- // senders use explicit-remove by ssrc.
- bool GetFirstAudioSourceByNick(const std::string& nick, NamedSource* source);
- bool GetFirstVideoSourceByNick(const std::string& nick, NamedSource* source);
+ bool GetAudioStreamBySsrc(uint32 ssrc, StreamParams* source);
+ bool GetVideoStreamBySsrc(uint32 ssrc, StreamParams* source);
// Add a source.
- void AddAudioSource(const NamedSource& source);
- void AddVideoSource(const NamedSource& source);
- // Remove the source with the given ssrc.
- void RemoveAudioSourceBySsrc(uint32 ssrc);
- void RemoveVideoSourceBySsrc(uint32 ssrc);
+ void AddAudioStream(const StreamParams& source);
+ void AddVideoStream(const StreamParams& source);
+ // Remove the source with the given name. Names are only unique to
+ // nicks, so you need the nick as well.
+ void RemoveAudioStreamByNickAndName(const std::string& nick,
+ const std::string& name);
+ void RemoveVideoStreamByNickAndName(const std::string& nick,
+ const std::string& name);
private:
- NamedSources audio_;
- NamedSources video_;
+ std::vector<StreamParams> audio_;
+ std::vector<StreamParams> video_;
- DISALLOW_COPY_AND_ASSIGN(MediaSources);
+ DISALLOW_COPY_AND_ASSIGN(MediaStreams);
};
// In a <view> message, there are a number of views specified. This
@@ -123,28 +111,45 @@
typedef std::vector<StaticVideoView> StaticVideoViews;
-// Represents a whole <view> message, which contains many views.
+// Represents a whole view request message, which contains many views.
struct ViewRequest {
StaticVideoViews static_video_views;
};
+// If the parent element (usually <jingle>) is a jingle view.
+bool IsJingleViewRequest(const buzz::XmlElement* action_elem);
+
+// Parses a view request from the parent element (usually
+// <jingle>). If it fails, it returns false and fills an error
+// message.
+bool ParseJingleViewRequest(const buzz::XmlElement* action_elem,
+ ViewRequest* view_request,
+ ParseError* error);
+
// Serializes a view request to XML. If it fails, returns false and
// fills in an error message.
-bool WriteViewRequest(const std::string& content_name,
- const ViewRequest& view,
- XmlElements* elems,
- WriteError* error);
+bool WriteJingleViewRequest(const std::string& content_name,
+ const ViewRequest& view,
+ XmlElements* elems,
+ WriteError* error);
+// TODO: Get rid of legacy source notify and replace with
+// description-info as soon as reflector is capable of sending it.
bool IsSourcesNotify(const buzz::XmlElement* action_elem);
-// Parses a notify message from XML. If it fails, returns false and
-// fills in an error message.
-// The session_description is needed to map content_name => media type.
-bool ParseSourcesNotify(const buzz::XmlElement* action_elem,
- const SessionDescription* session_description,
- MediaSources* sources,
+// If the given elem has <streams>.
+bool HasJingleStreams(const buzz::XmlElement* desc_elem);
+
+// Parses streams from a jingle <description>. If it fails, returns
+// false and fills an error message.
+bool ParseJingleStreams(const buzz::XmlElement* desc_elem,
+ std::vector<StreamParams>* streams,
ParseError* error);
+// Write a <streams> element to the parent_elem.
+void WriteJingleStreams(const std::vector<StreamParams>& streams,
+ buzz::XmlElement* parent_elem);
+
} // namespace cricket
#endif // TALK_SESSION_PHONE_MEDIAMESSAGES_H_
diff --git a/talk/session/phone/mediamessages_unittest.cc b/talk/session/phone/mediamessages_unittest.cc
new file mode 100644
index 0000000..a76d296
--- /dev/null
+++ b/talk/session/phone/mediamessages_unittest.cc
@@ -0,0 +1,286 @@
+/*
+ * libjingle
+ * Copyright 2004--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/session/phone/mediamessages.h"
+
+#include <string>
+#include <vector>
+
+#include "talk/base/gunit.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/p2p/base/constants.h"
+#include "talk/session/phone/mediasessionclient.h"
+#include "talk/xmllite/xmlelement.h"
+
+// Unit tests for mediamessages.cc.
+
+namespace cricket {
+
+namespace {
+
+static const char kViewVideoNoneXml[] =
+ "<view xmlns='google:jingle'"
+ " name='video1'"
+ " type='none'"
+ "/>";
+
+class MediaMessagesTest : public testing::Test {
+ public:
+ // CreateMediaSessionDescription uses a static variable cricket::NS_JINGLE_RTP
+ // defined in another file and cannot be used to initialize another static
+ // variable (http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.14)
+ MediaMessagesTest()
+ : remote_description_(CreateMediaSessionDescription("audio1", "video1")) {
+ }
+
+ protected:
+ static std::string ViewVideoStaticVgaXml(const std::string& ssrc) {
+ return "<view xmlns='google:jingle'"
+ " name='video1'"
+ " type='static'"
+ " ssrc='" + ssrc + "'"
+ ">"
+ "<params"
+ " width='640'"
+ " height='480'"
+ " framerate='30'"
+ " preference='0'"
+ " />"
+ "</view>";
+ }
+
+ static cricket::StreamParams CreateStream(const std::string& nick,
+ const std::string& name,
+ uint32 ssrc1,
+ uint32 ssrc2,
+ const std::string& semantics,
+ const std::string& type,
+ const std::string& display) {
+ StreamParams stream;
+ stream.nick = nick;
+ stream.name = name;
+ stream.ssrcs.push_back(ssrc1);
+ stream.ssrcs.push_back(ssrc2);
+ stream.ssrc_groups.push_back(
+ cricket::SsrcGroup(semantics, stream.ssrcs));
+ stream.type = type;
+ stream.display = display;
+ return stream;
+ }
+
+ static std::string StreamsXml(const std::string& stream1,
+ const std::string& stream2) {
+ return "<streams xmlns='google:jingle'>"
+ + stream1
+ + stream2 +
+ "</streams>";
+ }
+
+
+ static std::string StreamXml(const std::string& nick,
+ const std::string& name,
+ const std::string& ssrc1,
+ const std::string& ssrc2,
+ const std::string& semantics,
+ const std::string& type,
+ const std::string& display) {
+ return "<stream"
+ " nick='" + nick + "'"
+ " name='" + name + "'"
+ " type='" + type + "'"
+ " display='" + display + "'"
+ ">"
+ "<ssrc>" + ssrc1 + "</ssrc>"
+ "<ssrc>" + ssrc2 + "</ssrc>"
+ "<ssrc-group"
+ " semantics='" + semantics + "'"
+ ">"
+ "<ssrc>" + ssrc1 + "</ssrc>"
+ "<ssrc>" + ssrc2 + "</ssrc>"
+ "</ssrc-group>"
+ "</stream>";
+ }
+
+ static cricket::SessionDescription* CreateMediaSessionDescription(
+ const std::string& audio_content_name,
+ const std::string& video_content_name) {
+ cricket::SessionDescription* desc = new cricket::SessionDescription();
+ desc->AddContent(audio_content_name, cricket::NS_JINGLE_RTP,
+ new cricket::AudioContentDescription());
+ desc->AddContent(video_content_name, cricket::NS_JINGLE_RTP,
+ new cricket::VideoContentDescription());
+ return desc;
+ }
+
+ talk_base::scoped_ptr<cricket::SessionDescription> remote_description_;
+};
+
+} // anonymous namespace
+
+// Test serializing/deserializing an empty <view> message.
+TEST_F(MediaMessagesTest, ViewNoneToFromXml) {
+ buzz::XmlElement* expected_view_elem =
+ buzz::XmlElement::ForStr(kViewVideoNoneXml);
+ talk_base::scoped_ptr<buzz::XmlElement> action_elem(
+ new buzz::XmlElement(QN_JINGLE));
+
+ EXPECT_FALSE(cricket::IsJingleViewRequest(action_elem.get()));
+ action_elem->AddElement(expected_view_elem);
+ EXPECT_TRUE(cricket::IsJingleViewRequest(action_elem.get()));
+
+ cricket::ViewRequest view_request;
+ cricket::XmlElements actual_view_elems;
+ cricket::WriteError error;
+
+ ASSERT_TRUE(cricket::WriteJingleViewRequest(
+ "video1", view_request, &actual_view_elems, &error));
+
+ ASSERT_EQ(1U, actual_view_elems.size());
+ EXPECT_EQ(expected_view_elem->Str(), actual_view_elems[0]->Str());
+
+ cricket::ParseError parse_error;
+ EXPECT_TRUE(cricket::IsJingleViewRequest(action_elem.get()));
+ ASSERT_TRUE(cricket::ParseJingleViewRequest(
+ action_elem.get(), &view_request, &parse_error));
+ EXPECT_EQ(0U, view_request.static_video_views.size());
+}
+
+// Test serializing/deserializing an a simple vga <view> message.
+TEST_F(MediaMessagesTest, ViewVgaToFromXml) {
+ talk_base::scoped_ptr<buzz::XmlElement> action_elem(
+ new buzz::XmlElement(QN_JINGLE));
+ buzz::XmlElement* expected_view_elem1 =
+ buzz::XmlElement::ForStr(ViewVideoStaticVgaXml("1234"));
+ buzz::XmlElement* expected_view_elem2 =
+ buzz::XmlElement::ForStr(ViewVideoStaticVgaXml("2468"));
+ action_elem->AddElement(expected_view_elem1);
+ action_elem->AddElement(expected_view_elem2);
+
+ cricket::ViewRequest view_request;
+ cricket::XmlElements actual_view_elems;
+ cricket::WriteError error;
+
+ view_request.static_video_views.push_back(
+ cricket::StaticVideoView(1234, 640, 480, 30));
+ view_request.static_video_views.push_back(
+ cricket::StaticVideoView(2468, 640, 480, 30));
+
+ ASSERT_TRUE(cricket::WriteJingleViewRequest(
+ "video1", view_request, &actual_view_elems, &error));
+
+ ASSERT_EQ(2U, actual_view_elems.size());
+ EXPECT_EQ(expected_view_elem1->Str(), actual_view_elems[0]->Str());
+ EXPECT_EQ(expected_view_elem2->Str(), actual_view_elems[1]->Str());
+
+ view_request.static_video_views.clear();
+ cricket::ParseError parse_error;
+ EXPECT_TRUE(cricket::IsJingleViewRequest(action_elem.get()));
+ ASSERT_TRUE(cricket::ParseJingleViewRequest(
+ action_elem.get(), &view_request, &parse_error));
+ EXPECT_EQ(2U, view_request.static_video_views.size());
+ EXPECT_EQ(1234U, view_request.static_video_views[0].ssrc);
+ EXPECT_EQ(640, view_request.static_video_views[0].width);
+ EXPECT_EQ(480, view_request.static_video_views[0].height);
+ EXPECT_EQ(30, view_request.static_video_views[0].framerate);
+ EXPECT_EQ(2468U, view_request.static_video_views[1].ssrc);
+}
+
+// Test deserializing bad view XML.
+TEST_F(MediaMessagesTest, ParseBadViewXml) {
+ talk_base::scoped_ptr<buzz::XmlElement> action_elem(
+ new buzz::XmlElement(QN_JINGLE));
+ buzz::XmlElement* view_elem =
+ buzz::XmlElement::ForStr(ViewVideoStaticVgaXml("not-an-ssrc"));
+ action_elem->AddElement(view_elem);
+
+ cricket::ViewRequest view_request;
+ cricket::ParseError parse_error;
+ ASSERT_FALSE(cricket::ParseJingleViewRequest(
+ action_elem.get(), &view_request, &parse_error));
+}
+
+
+// Test serializing/deserializing typical streams xml.
+TEST_F(MediaMessagesTest, StreamsToFromXml) {
+ talk_base::scoped_ptr<buzz::XmlElement> expected_streams_elem(
+ buzz::XmlElement::ForStr(
+ StreamsXml(
+ StreamXml("nick1", "name1", "101", "102",
+ "semantics1", "type1", "display1"),
+ StreamXml("nick2", "name2", "201", "202",
+ "semantics2", "type2", "display2"))));
+
+ std::vector<cricket::StreamParams> expected_streams;
+ expected_streams.push_back(CreateStream("nick1", "name1", 101U, 102U,
+ "semantics1", "type1", "display1"));
+ expected_streams.push_back(CreateStream("nick2", "name2", 201U, 202U,
+ "semantics2", "type2", "display2"));
+
+ talk_base::scoped_ptr<buzz::XmlElement> actual_desc_elem(
+ new buzz::XmlElement(QN_JINGLE_RTP_CONTENT));
+ cricket::WriteJingleStreams(expected_streams, actual_desc_elem.get());
+
+ const buzz::XmlElement* actual_streams_elem =
+ actual_desc_elem->FirstNamed(QN_JINGLE_DRAFT_STREAMS);
+ ASSERT_TRUE(actual_streams_elem != NULL);
+ EXPECT_EQ(expected_streams_elem->Str(), actual_streams_elem->Str());
+
+ talk_base::scoped_ptr<buzz::XmlElement> expected_desc_elem(
+ new buzz::XmlElement(QN_JINGLE_RTP_CONTENT));
+ expected_desc_elem->AddElement(new buzz::XmlElement(
+ *expected_streams_elem));
+ std::vector<cricket::StreamParams> actual_streams;
+ cricket::ParseError parse_error;
+
+ EXPECT_TRUE(cricket::HasJingleStreams(expected_desc_elem.get()));
+ ASSERT_TRUE(cricket::ParseJingleStreams(
+ expected_desc_elem.get(), &actual_streams, &parse_error));
+ EXPECT_EQ(2U, actual_streams.size());
+ EXPECT_EQ(expected_streams[0], actual_streams[0]);
+ EXPECT_EQ(expected_streams[1], actual_streams[1]);
+}
+
+// Test deserializing bad streams xml.
+TEST_F(MediaMessagesTest, StreamsFromBadXml) {
+ talk_base::scoped_ptr<buzz::XmlElement> streams_elem(
+ buzz::XmlElement::ForStr(
+ StreamsXml(
+ StreamXml("nick1", "name1", "101", "not-an-ssrc",
+ "semantics1", "type1", "display1"),
+ StreamXml("nick2", "name2", "202", "not-an-ssrc",
+ "semantics2", "type2", "display2"))));
+ talk_base::scoped_ptr<buzz::XmlElement> desc_elem(
+ new buzz::XmlElement(QN_JINGLE_RTP_CONTENT));
+ desc_elem->AddElement(new buzz::XmlElement(*streams_elem));
+
+ std::vector<cricket::StreamParams> actual_streams;
+ cricket::ParseError parse_error;
+ ASSERT_FALSE(cricket::ParseJingleStreams(
+ desc_elem.get(), &actual_streams, &parse_error));
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/mediaprocessorinterface.h b/talk/session/phone/mediaprocessorinterface.h
new file mode 100644
index 0000000..2f8d02a
--- /dev/null
+++ b/talk/session/phone/mediaprocessorinterface.h
@@ -0,0 +1,84 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, 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_SESSION_PHONE_MEDIAPROCESSORINTERFACE_H_
+#define TALK_SESSION_PHONE_MEDIAPROCESSORINTERFACE_H_
+
+#include "talk/base/basictypes.h"
+#include "talk/base/sigslot.h"
+#include "talk/session/phone/videoframe.h"
+
+namespace cricket {
+
+enum MediaProcessorDirection {
+ MPD_RX = 1 << 0,
+ MPD_TX = 1 << 1,
+ MPD_RX_AND_TX = MPD_RX | MPD_TX,
+};
+
+struct AudioFrame {
+ AudioFrame()
+ : audio10ms(NULL),
+ length(0),
+ sampling_freq(8000),
+ is_stereo(false) {
+ }
+
+ AudioFrame(int16* audio, size_t audio_length, int sample_freq, bool stereo)
+ : audio10ms(audio),
+ length(audio_length),
+ sampling_freq(sample_freq),
+ is_stereo(stereo) {
+ }
+
+ int16* audio10ms;
+ size_t length;
+ int sampling_freq;
+ bool is_stereo;
+};
+
+class VoiceProcessor : public sigslot::has_slots<> {
+ public:
+ virtual ~VoiceProcessor() {}
+ // Contents of frame may be manipulated by the processor.
+ // The processed data is expected to be the same size as the
+ // original data
+ virtual void OnFrame(uint32 ssrc, AudioFrame* frame) = 0;
+};
+
+class VideoProcessor : public sigslot::has_slots<> {
+ public:
+ virtual ~VideoProcessor() {}
+ // Contents of frame may be manipulated by the processor.
+ // The processed data is expected to be the same size as the
+ // original data
+ virtual void OnFrame(uint32 ssrc, VideoFrame* frame) = 0;
+};
+
+} // namespace cricket
+#endif // TALK_SESSION_PHONE_MEDIAPROCESSORINTERFACE_H_
diff --git a/talk/session/phone/mediarecorder.cc b/talk/session/phone/mediarecorder.cc
new file mode 100644
index 0000000..7b06e48
--- /dev/null
+++ b/talk/session/phone/mediarecorder.cc
@@ -0,0 +1,225 @@
+/*
+ * libjingle
+ * Copyright 2010, 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/session/phone/mediarecorder.h"
+
+#include <limits.h>
+
+#include <string>
+
+#include "talk/base/fileutils.h"
+#include "talk/base/logging.h"
+#include "talk/base/pathutils.h"
+#include "talk/session/phone/channel.h"
+#include "talk/session/phone/rtpdump.h"
+
+
+namespace cricket {
+
+///////////////////////////////////////////////////////////////////////////
+// Implementation of RtpDumpSink.
+///////////////////////////////////////////////////////////////////////////
+RtpDumpSink::RtpDumpSink(const std::string& filename)
+ : max_size_(INT_MAX),
+ recording_(false),
+ packet_filter_(PF_NONE),
+ filename_(filename) {
+}
+
+RtpDumpSink::~RtpDumpSink() {}
+
+void RtpDumpSink::SetMaxSize(size_t size) {
+ talk_base::CritScope cs(&critical_section_);
+ max_size_ = size;
+}
+
+bool RtpDumpSink::Enable(bool enable) {
+ talk_base::CritScope cs(&critical_section_);
+
+ recording_ = enable;
+
+ // Create a file and the RTP writer if we have not done yet.
+ if (recording_ && !writer_.get()) {
+ stream_.reset(talk_base::Filesystem::OpenFile(
+ talk_base::Pathname(filename_), "wb"));
+ if (!stream_.get()) {
+ return false;
+ }
+ writer_.reset(new RtpDumpWriter(stream_.get()));
+ writer_->set_packet_filter(packet_filter_);
+ } else if (!recording_ && stream_.get()) {
+ stream_->Flush();
+ }
+ return true;
+}
+
+void RtpDumpSink::OnPacket(const void* data, size_t size, bool rtcp) {
+ talk_base::CritScope cs(&critical_section_);
+
+ if (recording_ && writer_.get()) {
+ size_t current_size;
+ if (writer_->GetDumpSize(¤t_size) &&
+ current_size + RtpDumpPacket::kHeaderLength + size <= max_size_) {
+ if (!rtcp) {
+ writer_->WriteRtpPacket(data, size);
+ } else {
+ // TODO: Enable recording RTCP.
+ }
+ }
+ }
+}
+
+void RtpDumpSink::set_packet_filter(int filter) {
+ talk_base::CritScope cs(&critical_section_);
+ packet_filter_ = filter;
+ if (writer_.get()) {
+ writer_->set_packet_filter(packet_filter_);
+ }
+}
+
+void RtpDumpSink::Flush() {
+ talk_base::CritScope cs(&critical_section_);
+ if (stream_.get()) {
+ stream_->Flush();
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////
+// Implementation of MediaRecorder.
+///////////////////////////////////////////////////////////////////////////
+MediaRecorder::MediaRecorder() {}
+
+MediaRecorder::~MediaRecorder() {
+ talk_base::CritScope cs(&critical_section_);
+ std::map<BaseChannel*, SinkPair*>::iterator itr;
+ for (itr = sinks_.begin(); itr != sinks_.end(); ++itr) {
+ delete itr->second;
+ }
+}
+
+bool MediaRecorder::AddChannel(VoiceChannel* channel,
+ const std::string& send_filename,
+ const std::string& recv_filename,
+ int filter) {
+ return InternalAddChannel(channel, false, send_filename, recv_filename,
+ filter);
+}
+bool MediaRecorder::AddChannel(VideoChannel* channel,
+ const std::string& send_filename,
+ const std::string& recv_filename,
+ int filter) {
+ return InternalAddChannel(channel, true, send_filename, recv_filename,
+ filter);
+}
+
+bool MediaRecorder::InternalAddChannel(BaseChannel* channel,
+ bool video_channel,
+ const std::string& send_filename,
+ const std::string& recv_filename,
+ int filter) {
+ if (!channel) {
+ return false;
+ }
+
+ talk_base::CritScope cs(&critical_section_);
+ if (sinks_.end() != sinks_.find(channel)) {
+ return false; // The channel was added already.
+ }
+
+ SinkPair* sink_pair = new SinkPair;
+ sink_pair->video_channel = video_channel;
+ sink_pair->filter = filter;
+ sink_pair->send_sink.reset(new RtpDumpSink(send_filename));
+ sink_pair->send_sink->set_packet_filter(filter);
+ sink_pair->recv_sink.reset(new RtpDumpSink(recv_filename));
+ sink_pair->recv_sink->set_packet_filter(filter);
+ sinks_[channel] = sink_pair;
+
+ return true;
+}
+
+void MediaRecorder::RemoveChannel(BaseChannel* channel) {
+ talk_base::CritScope cs(&critical_section_);
+ std::map<BaseChannel*, SinkPair*>::iterator itr = sinks_.find(channel);
+ if (sinks_.end() != itr) {
+ channel->UnregisterSendSink(itr->second->send_sink.get());
+ channel->UnregisterRecvSink(itr->second->recv_sink.get());
+ delete itr->second;
+ sinks_.erase(itr);
+ }
+}
+
+bool MediaRecorder::EnableChannel(
+ BaseChannel* channel, bool enable_send, bool enable_recv) {
+ talk_base::CritScope cs(&critical_section_);
+ std::map<BaseChannel*, SinkPair*>::iterator itr = sinks_.find(channel);
+ if (sinks_.end() == itr) {
+ return false;
+ }
+
+ SinkPair* sink_pair = itr->second;
+ RtpDumpSink* sink = sink_pair->send_sink.get();
+ sink->Enable(enable_send);
+ if (enable_send) {
+ channel->RegisterSendSink(sink, &RtpDumpSink::OnPacket);
+ } else {
+ channel->UnregisterSendSink(sink);
+ }
+
+ sink = sink_pair->recv_sink.get();
+ sink->Enable(enable_recv);
+ if (enable_recv) {
+ channel->RegisterRecvSink(sink, &RtpDumpSink::OnPacket);
+ } else {
+ channel->UnregisterRecvSink(sink);
+ }
+
+ if (sink_pair->video_channel &&
+ (sink_pair->filter & PF_RTPPACKET) == PF_RTPPACKET) {
+ // Request a full intra frame.
+ VideoChannel* video_channel = static_cast<VideoChannel*>(channel);
+ if (enable_send) {
+ video_channel->SendIntraFrame();
+ }
+ if (enable_recv) {
+ video_channel->RequestIntraFrame();
+ }
+ }
+
+ return true;
+}
+
+void MediaRecorder::FlushSinks() {
+ talk_base::CritScope cs(&critical_section_);
+ std::map<BaseChannel*, SinkPair*>::iterator itr;
+ for (itr = sinks_.begin(); itr != sinks_.end(); ++itr) {
+ itr->second->send_sink->Flush();
+ itr->second->recv_sink->Flush();
+ }
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/mediarecorder.h b/talk/session/phone/mediarecorder.h
new file mode 100644
index 0000000..fa77e6d
--- /dev/null
+++ b/talk/session/phone/mediarecorder.h
@@ -0,0 +1,117 @@
+/*
+ * libjingle
+ * Copyright 2010, 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_SESSION_PHONE_MEDIARECORDER_H_
+#define TALK_SESSION_PHONE_MEDIARECORDER_H_
+
+#include <map>
+#include <string>
+
+#include "talk/base/criticalsection.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/sigslot.h"
+#include "talk/session/phone/mediasink.h"
+
+namespace talk_base {
+class Pathname;
+class FileStream;
+}
+
+namespace cricket {
+
+class BaseChannel;
+class VideoChannel;
+class VoiceChannel;
+class RtpDumpWriter;
+
+// RtpDumpSink implements MediaSinkInterface by dumping the RTP/RTCP packets to
+// a file.
+class RtpDumpSink : public MediaSinkInterface, public sigslot::has_slots<> {
+ public:
+ explicit RtpDumpSink(const std::string& filename);
+ virtual ~RtpDumpSink();
+
+ virtual void SetMaxSize(size_t size);
+ virtual bool Enable(bool enable);
+ virtual bool IsEnabled() const { return recording_; }
+ virtual void OnPacket(const void* data, size_t size, bool rtcp);
+ virtual void set_packet_filter(int filter);
+ int packet_filter() const { return packet_filter_; }
+ void Flush();
+
+ private:
+ size_t max_size_;
+ bool recording_;
+ int packet_filter_;
+ std::string filename_;
+ talk_base::scoped_ptr<talk_base::FileStream> stream_;
+ talk_base::scoped_ptr<RtpDumpWriter> writer_;
+ talk_base::CriticalSection critical_section_;
+
+ DISALLOW_COPY_AND_ASSIGN(RtpDumpSink);
+};
+
+class MediaRecorder {
+ public:
+ MediaRecorder();
+ virtual ~MediaRecorder();
+
+ bool AddChannel(VoiceChannel* channel,
+ const std::string& send_filename,
+ const std::string& recv_filename,
+ int filter);
+ bool AddChannel(VideoChannel* channel,
+ const std::string& send_filename,
+ const std::string& recv_filename,
+ int filter);
+ void RemoveChannel(BaseChannel* channel);
+ bool EnableChannel(BaseChannel* channel, bool enable_send, bool enable_recv);
+ void FlushSinks();
+
+ private:
+ struct SinkPair {
+ bool video_channel;
+ int filter;
+ talk_base::scoped_ptr<RtpDumpSink> send_sink;
+ talk_base::scoped_ptr<RtpDumpSink> recv_sink;
+ };
+
+ bool InternalAddChannel(BaseChannel* channel,
+ bool video_channel,
+ const std::string& send_filename,
+ const std::string& recv_filename,
+ int filter);
+
+ std::map<BaseChannel*, SinkPair*> sinks_;
+ talk_base::CriticalSection critical_section_;
+
+ DISALLOW_COPY_AND_ASSIGN(MediaRecorder);
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_MEDIARECORDER_H_
diff --git a/talk/session/phone/mediarecorder_unittest.cc b/talk/session/phone/mediarecorder_unittest.cc
new file mode 100644
index 0000000..59d1afe
--- /dev/null
+++ b/talk/session/phone/mediarecorder_unittest.cc
@@ -0,0 +1,344 @@
+// libjingle
+// Copyright 2010 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 "talk/base/bytebuffer.h"
+#include "talk/base/fileutils.h"
+#include "talk/base/gunit.h"
+#include "talk/base/pathutils.h"
+#include "talk/base/thread.h"
+#include "talk/p2p/base/fakesession.h"
+#include "talk/session/phone/channel.h"
+#include "talk/session/phone/fakemediaengine.h"
+#include "talk/session/phone/mediarecorder.h"
+#include "talk/session/phone/rtpdump.h"
+#include "talk/session/phone/testutils.h"
+
+namespace cricket {
+
+/////////////////////////////////////////////////////////////////////////
+// Test RtpDumpSink
+/////////////////////////////////////////////////////////////////////////
+class RtpDumpSinkTest : public testing::Test {
+ public:
+ virtual void SetUp() {
+ EXPECT_TRUE(talk_base::Filesystem::GetTemporaryFolder(path_, true, NULL));
+ path_.SetFilename("sink-test.rtpdump");
+ sink_.reset(new RtpDumpSink(path_.pathname()));
+
+ for (int i = 0; i < ARRAY_SIZE(rtp_buf_); ++i) {
+ RtpTestUtility::kTestRawRtpPackets[i].WriteToByteBuffer(
+ RtpTestUtility::kDefaultSsrc, &rtp_buf_[i]);
+ }
+ }
+
+ virtual void TearDown() {
+ stream_.reset();
+ EXPECT_TRUE(talk_base::Filesystem::DeleteFile(path_));
+ }
+
+ protected:
+ void OnRtpPacket(const RawRtpPacket& raw) {
+ talk_base::ByteBuffer buf;
+ raw.WriteToByteBuffer(RtpTestUtility::kDefaultSsrc, &buf);
+ sink_->OnPacket(buf.Data(), buf.Length(), false);
+ }
+
+ talk_base::StreamResult ReadPacket(RtpDumpPacket* packet) {
+ if (!stream_.get()) {
+ sink_.reset(); // This will close the file. So we can read it.
+ stream_.reset(talk_base::Filesystem::OpenFile(path_, "rb"));
+ reader_.reset(new RtpDumpReader(stream_.get()));
+ }
+ return reader_->ReadPacket(packet);
+ }
+
+ talk_base::Pathname path_;
+ talk_base::scoped_ptr<RtpDumpSink> sink_;
+ talk_base::ByteBuffer rtp_buf_[3];
+ talk_base::scoped_ptr<talk_base::StreamInterface> stream_;
+ talk_base::scoped_ptr<RtpDumpReader> reader_;
+};
+
+TEST_F(RtpDumpSinkTest, TestRtpDumpSink) {
+ // By default, the sink is disabled. The 1st packet is not written.
+ EXPECT_FALSE(sink_->IsEnabled());
+ sink_->set_packet_filter(PF_ALL);
+ OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[0]);
+
+ // Enable the sink. The 2nd packet is written.
+ EXPECT_TRUE(sink_->Enable(true));
+ EXPECT_TRUE(sink_->IsEnabled());
+ EXPECT_TRUE(talk_base::Filesystem::IsFile(path_.pathname()));
+ OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[1]);
+
+ // Disable the sink. The 3rd packet is not written.
+ EXPECT_TRUE(sink_->Enable(false));
+ EXPECT_FALSE(sink_->IsEnabled());
+ OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[2]);
+
+ // Read the recorded file and verify it contains only the 2nd packet.
+ RtpDumpPacket packet;
+ EXPECT_EQ(talk_base::SR_SUCCESS, ReadPacket(&packet));
+ EXPECT_TRUE(RtpTestUtility::VerifyPacket(
+ &packet, &RtpTestUtility::kTestRawRtpPackets[1], false));
+ EXPECT_EQ(talk_base::SR_EOS, ReadPacket(&packet));
+}
+
+TEST_F(RtpDumpSinkTest, TestRtpDumpSinkMaxSize) {
+ EXPECT_TRUE(sink_->Enable(true));
+ sink_->set_packet_filter(PF_ALL);
+ sink_->SetMaxSize(strlen(RtpDumpFileHeader::kFirstLine) +
+ RtpDumpFileHeader::kHeaderLength +
+ RtpDumpPacket::kHeaderLength +
+ RtpTestUtility::kTestRawRtpPackets[0].size());
+ OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[0]);
+
+ // Exceed the limit size: the 2nd and 3rd packets are not written.
+ OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[1]);
+ OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[2]);
+
+ // Read the recorded file and verify that it contains only the first packet.
+ RtpDumpPacket packet;
+ EXPECT_EQ(talk_base::SR_SUCCESS, ReadPacket(&packet));
+ EXPECT_TRUE(RtpTestUtility::VerifyPacket(
+ &packet, &RtpTestUtility::kTestRawRtpPackets[0], false));
+ EXPECT_EQ(talk_base::SR_EOS, ReadPacket(&packet));
+}
+
+TEST_F(RtpDumpSinkTest, TestRtpDumpSinkFilter) {
+ // The default filter is PF_NONE.
+ EXPECT_EQ(PF_NONE, sink_->packet_filter());
+
+ // Set to PF_RTPHEADER before enable.
+ sink_->set_packet_filter(PF_RTPHEADER);
+ EXPECT_EQ(PF_RTPHEADER, sink_->packet_filter());
+ EXPECT_TRUE(sink_->Enable(true));
+ // We dump only the header of the first packet.
+ OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[0]);
+
+ // Set the filter to PF_RTPPACKET. We dump all the second packet.
+ sink_->set_packet_filter(PF_RTPPACKET);
+ EXPECT_EQ(PF_RTPPACKET, sink_->packet_filter());
+ OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[1]);
+
+ // Set the filter to PF_NONE. We do not dump the third packet.
+ sink_->set_packet_filter(PF_NONE);
+ EXPECT_EQ(PF_NONE, sink_->packet_filter());
+ OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[2]);
+
+ // Read the recorded file and verify the header of the first packet and
+ // the whole packet for the second packet.
+ RtpDumpPacket packet;
+ EXPECT_EQ(talk_base::SR_SUCCESS, ReadPacket(&packet));
+ EXPECT_TRUE(RtpTestUtility::VerifyPacket(
+ &packet, &RtpTestUtility::kTestRawRtpPackets[0], true));
+ EXPECT_EQ(talk_base::SR_SUCCESS, ReadPacket(&packet));
+ EXPECT_TRUE(RtpTestUtility::VerifyPacket(
+ &packet, &RtpTestUtility::kTestRawRtpPackets[1], false));
+ EXPECT_EQ(talk_base::SR_EOS, ReadPacket(&packet));
+}
+
+/////////////////////////////////////////////////////////////////////////
+// Test MediaRecorder
+/////////////////////////////////////////////////////////////////////////
+void TestMediaRecorder(BaseChannel* channel,
+ FakeVideoMediaChannel* video_media_channel,
+ int filter) {
+ // Create media recorder.
+ talk_base::scoped_ptr<MediaRecorder> recorder(new MediaRecorder);
+ // Fail to EnableChannel before AddChannel.
+ EXPECT_FALSE(recorder->EnableChannel(channel, true, true));
+ EXPECT_FALSE(channel->HasSendSinks());
+ EXPECT_FALSE(channel->HasRecvSinks());
+
+ // Add the channel to the recorder.
+ talk_base::Pathname path;
+ EXPECT_TRUE(talk_base::Filesystem::GetTemporaryFolder(path, true, NULL));
+ path.SetFilename("send.rtpdump");
+ std::string send_file = path.pathname();
+ path.SetFilename("recv.rtpdump");
+ std::string recv_file = path.pathname();
+ if (video_media_channel) {
+ EXPECT_TRUE(recorder->AddChannel(static_cast<VideoChannel*>(channel),
+ send_file, recv_file, filter));
+ } else {
+ EXPECT_TRUE(recorder->AddChannel(static_cast<VoiceChannel*>(channel),
+ send_file, recv_file, filter));
+ }
+
+ // Enable recording only the sent media.
+ EXPECT_TRUE(recorder->EnableChannel(channel, true, false));
+ EXPECT_TRUE(channel->HasSendSinks());
+ EXPECT_FALSE(channel->HasRecvSinks());
+ if (video_media_channel) {
+ EXPECT_TRUE_WAIT(video_media_channel->sent_intra_frame(), 100);
+ }
+
+ // Enable recording only the received meida.
+ EXPECT_TRUE(recorder->EnableChannel(channel, false, true));
+ EXPECT_FALSE(channel->HasSendSinks());
+ EXPECT_TRUE(channel->HasRecvSinks());
+ if (video_media_channel) {
+ EXPECT_TRUE(video_media_channel->requested_intra_frame());
+ }
+
+ // Enable recording both the sent and the received video.
+ EXPECT_TRUE(recorder->EnableChannel(channel, true, true));
+ EXPECT_TRUE(channel->HasSendSinks());
+ EXPECT_TRUE(channel->HasRecvSinks());
+
+ // Enable recording only headers.
+ if (video_media_channel) {
+ video_media_channel->set_sent_intra_frame(false);
+ video_media_channel->set_requested_intra_frame(false);
+ }
+ EXPECT_TRUE(recorder->EnableChannel(channel, true, true));
+ EXPECT_TRUE(channel->HasSendSinks());
+ EXPECT_TRUE(channel->HasRecvSinks());
+ if (video_media_channel) {
+ if ((filter & PF_RTPPACKET) == PF_RTPPACKET) {
+ // If record the whole RTP packet, trigers FIR.
+ EXPECT_TRUE(video_media_channel->requested_intra_frame());
+ EXPECT_TRUE(video_media_channel->sent_intra_frame());
+ } else {
+ // If record only the RTP header, does not triger FIR.
+ EXPECT_FALSE(video_media_channel->requested_intra_frame());
+ EXPECT_FALSE(video_media_channel->sent_intra_frame());
+ }
+ }
+
+ // Remove the voice channel from the recorder.
+ recorder->RemoveChannel(channel);
+ EXPECT_FALSE(channel->HasSendSinks());
+ EXPECT_FALSE(channel->HasRecvSinks());
+
+ // Delete all files.
+ recorder.reset();
+ EXPECT_TRUE(talk_base::Filesystem::DeleteFile(send_file));
+ EXPECT_TRUE(talk_base::Filesystem::DeleteFile(recv_file));
+}
+
+// Fisrt start recording header and then start recording media. Verify that
+// differnt files are created for header and media.
+void TestRecordHeaderAndMedia(BaseChannel* channel,
+ FakeVideoMediaChannel* video_media_channel) {
+ // Create RTP header recorder.
+ talk_base::scoped_ptr<MediaRecorder> header_recorder(new MediaRecorder);
+
+ talk_base::Pathname path;
+ EXPECT_TRUE(talk_base::Filesystem::GetTemporaryFolder(path, true, NULL));
+ path.SetFilename("send-header.rtpdump");
+ std::string send_header_file = path.pathname();
+ path.SetFilename("recv-header.rtpdump");
+ std::string recv_header_file = path.pathname();
+ if (video_media_channel) {
+ EXPECT_TRUE(header_recorder->AddChannel(
+ static_cast<VideoChannel*>(channel),
+ send_header_file, recv_header_file, PF_RTPHEADER));
+ } else {
+ EXPECT_TRUE(header_recorder->AddChannel(
+ static_cast<VoiceChannel*>(channel),
+ send_header_file, recv_header_file, PF_RTPHEADER));
+ }
+
+ // Enable recording both sent and received.
+ EXPECT_TRUE(header_recorder->EnableChannel(channel, true, true));
+ EXPECT_TRUE(channel->HasSendSinks());
+ EXPECT_TRUE(channel->HasRecvSinks());
+ if (video_media_channel) {
+ EXPECT_FALSE(video_media_channel->sent_intra_frame());
+ EXPECT_FALSE(video_media_channel->requested_intra_frame());
+ }
+
+ // Verify that header files are created.
+ EXPECT_TRUE(talk_base::Filesystem::IsFile(send_header_file));
+ EXPECT_TRUE(talk_base::Filesystem::IsFile(recv_header_file));
+
+ // Create RTP header recorder.
+ talk_base::scoped_ptr<MediaRecorder> recorder(new MediaRecorder);
+ path.SetFilename("send.rtpdump");
+ std::string send_file = path.pathname();
+ path.SetFilename("recv.rtpdump");
+ std::string recv_file = path.pathname();
+ if (video_media_channel) {
+ EXPECT_TRUE(recorder->AddChannel(
+ static_cast<VideoChannel*>(channel),
+ send_file, recv_file, PF_RTPPACKET));
+ } else {
+ EXPECT_TRUE(recorder->AddChannel(
+ static_cast<VoiceChannel*>(channel),
+ send_file, recv_file, PF_RTPPACKET));
+ }
+
+ // Enable recording both sent and received.
+ EXPECT_TRUE(recorder->EnableChannel(channel, true, true));
+ EXPECT_TRUE(channel->HasSendSinks());
+ EXPECT_TRUE(channel->HasRecvSinks());
+ if (video_media_channel) {
+ EXPECT_TRUE_WAIT(video_media_channel->sent_intra_frame(), 100);
+ EXPECT_TRUE(video_media_channel->requested_intra_frame());
+ }
+
+ // Verify that media files are created.
+ EXPECT_TRUE(talk_base::Filesystem::IsFile(send_file));
+ EXPECT_TRUE(talk_base::Filesystem::IsFile(recv_file));
+
+ // Delete all files.
+ header_recorder.reset();
+ recorder.reset();
+ EXPECT_TRUE(talk_base::Filesystem::DeleteFile(send_header_file));
+ EXPECT_TRUE(talk_base::Filesystem::DeleteFile(recv_header_file));
+ EXPECT_TRUE(talk_base::Filesystem::DeleteFile(send_file));
+ EXPECT_TRUE(talk_base::Filesystem::DeleteFile(recv_file));
+}
+
+TEST(MediaRecorderTest, TestMediaRecorderVoiceChannel) {
+ // Create the voice channel.
+ cricket::FakeSession session;
+ cricket::FakeMediaEngine media_engine;
+ VoiceChannel channel(talk_base::Thread::Current(), &media_engine,
+ new FakeVoiceMediaChannel(NULL), &session, "", false);
+ EXPECT_TRUE(channel.Init());
+ TestMediaRecorder(&channel, NULL, PF_RTPPACKET);
+ TestMediaRecorder(&channel, NULL, PF_RTPHEADER);
+ TestRecordHeaderAndMedia(&channel, NULL);
+}
+
+TEST(MediaRecorderTest, TestMediaRecorderVideoChannel) {
+ // Create the video channel.
+ cricket::FakeSession session;
+ cricket::FakeMediaEngine media_engine;
+ FakeVideoMediaChannel* media_channel = new FakeVideoMediaChannel(NULL);
+ VideoChannel channel(talk_base::Thread::Current(), &media_engine,
+ media_channel, &session, "", false, NULL);
+ EXPECT_TRUE(channel.Init());
+ TestMediaRecorder(&channel, media_channel, PF_RTPPACKET);
+ TestMediaRecorder(&channel, media_channel, PF_RTPHEADER);
+ TestRecordHeaderAndMedia(&channel, media_channel);
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/mediasession.cc b/talk/session/phone/mediasession.cc
index b423708..ed4eaa7 100644
--- a/talk/session/phone/mediasession.cc
+++ b/talk/session/phone/mediasession.cc
@@ -29,6 +29,7 @@
#include "talk/base/helpers.h"
#include "talk/base/logging.h"
+#include "talk/base/scoped_ptr.h"
#include "talk/p2p/base/constants.h"
#include "talk/session/phone/channelmanager.h"
#include "talk/session/phone/cryptoparams.h"
@@ -41,6 +42,8 @@
namespace cricket {
+using talk_base::scoped_ptr;
+
static bool CreateCryptoParams(int tag, const std::string& cipher,
CryptoParams *out) {
std::string key;
@@ -102,40 +105,215 @@
return false;
}
+static const StreamParams* FindFirstStreamParamsByCname(
+ const StreamParamsVec& params_vec,
+ const std::string& cname) {
+ for (StreamParamsVec::const_iterator it = params_vec.begin();
+ it != params_vec.end(); ++it) {
+ if (cname == it->cname)
+ return &*it;
+ }
+ return NULL;
+}
+
+// Generates a new CNAME or the CNAME of an already existing StreamParams
+// if a StreamParams exist for another Stream in streams with sync_label
+// sync_label.
+static bool GenerateCname(const StreamParamsVec& params_vec,
+ const MediaSessionOptions::Streams& streams,
+ const std::string& synch_label,
+ std::string* cname) {
+ ASSERT(cname != NULL);
+ if (!cname)
+ return false;
+
+ // Check if a CNAME exist for any of the other synched streams.
+ for (MediaSessionOptions::Streams::const_iterator stream_it = streams.begin();
+ stream_it != streams.end() ; ++stream_it) {
+ if (synch_label != stream_it->sync_label)
+ continue;
+
+ StreamParams param;
+ // nick is empty for StreamParams generated using
+ // MediaSessionDescriptionFactory.
+ if (GetStreamByNickAndName(params_vec, "", stream_it->name,
+ ¶m)) {
+ *cname = param.cname;
+ return true;
+ }
+ }
+ // No other stream seems to exist that we should sync with.
+ // Generate a random string for the RTCP CNAME, as stated in RFC 6222.
+ // This string is only used for synchronization, and therefore is opaque.
+ do {
+ if (!talk_base::CreateRandomString(16, cname)) {
+ ASSERT(false);
+ return false;
+ }
+ } while (FindFirstStreamParamsByCname(params_vec, *cname));
+
+ return true;
+}
+
+// Generate a new SSRC and make sure it does not exist in params_vec.
+static uint32 GenerateSsrc(const StreamParamsVec& params_vec) {
+ uint32 ssrc = 0;
+ do {
+ ssrc = talk_base::CreateRandomNonZeroId();
+ } while (GetStreamBySsrc(params_vec, ssrc, NULL));
+ return ssrc;
+}
+
+// Finds all StreamParams of all media types and attach them to stream_params.
+static void GetCurrentStreamParams(const SessionDescription* sdesc,
+ StreamParamsVec* stream_params) {
+ if (!sdesc)
+ return;
+
+ const ContentInfos& contents = sdesc->contents();
+ for (ContentInfos::const_iterator content = contents.begin();
+ content != contents.end(); content++) {
+ if (!IsAudioContent(&*content) && !IsVideoContent(&*content))
+ continue;
+ const MediaContentDescription* media =
+ static_cast<const MediaContentDescription*>(
+ content->description);
+ const StreamParamsVec& streams = media->streams();
+ for (StreamParamsVec::const_iterator it = streams.begin();
+ it != streams.end(); ++it) {
+ stream_params->push_back(*it);
+ }
+ }
+}
+
+// Adds a StreamParams for each Stream in Streams with media type
+// media_type to content_description.
+// current_parms - All currently known StreamParams of any media type.
+static bool AddStreamParams(
+ MediaType media_type,
+ const MediaSessionOptions::Streams& streams,
+ StreamParamsVec* current_params,
+ MediaContentDescription* content_description) {
+ for (MediaSessionOptions::Streams::const_iterator stream_it = streams.begin();
+ stream_it != streams.end(); ++stream_it) {
+ if (stream_it->type != media_type)
+ continue; // Wrong media type.
+
+ StreamParams param;
+ // nick is empty for StreamParams generated using
+ // MediaSessionDescriptionFactory.
+ if (!GetStreamByNickAndName(*current_params, "", stream_it->name, ¶m)) {
+ // This is a new stream.
+ // Get a CNAME. Either new or same as one of the other synched streams.
+ std::string cname;
+ if (!GenerateCname(*current_params, streams, stream_it->sync_label,
+ &cname)) {
+ return false;
+ }
+ uint32 ssrc = GenerateSsrc(*current_params);
+ // TODO: Generate the more complex types of stream_params.
+
+ StreamParams stream_param;
+ stream_param.name = stream_it->name;
+ stream_param.ssrcs.push_back(ssrc);
+ stream_param.cname = cname;
+ stream_param.sync_label = stream_it->sync_label;
+ content_description->AddStream(stream_param);
+
+ // Store the new StreamParams in current_params.
+ // This is necessary so that we can use the CNAME for other media types.
+ current_params->push_back(stream_param);
+ } else {
+ content_description->AddStream(param);
+ }
+ }
+ return true;
+}
+
+void MediaSessionOptions::AddStream(MediaType type,
+ const std::string& name,
+ const std::string& sync_label) {
+ streams.push_back(Stream(type, name, sync_label));
+
+ if (type == MEDIA_TYPE_VIDEO)
+ has_video = true;
+ else if (type == MEDIA_TYPE_AUDIO)
+ has_audio = true;
+}
+
+void MediaSessionOptions::RemoveStream(MediaType type,
+ const std::string& name) {
+ Streams::iterator stream_it = streams.begin();
+ for (; stream_it != streams.end(); ++stream_it) {
+ if (stream_it->type == type && stream_it->name == name) {
+ streams.erase(stream_it);
+ return;
+ }
+ }
+ ASSERT(false);
+}
+
MediaSessionDescriptionFactory::MediaSessionDescriptionFactory()
- : secure_(SEC_DISABLED) {
+ : secure_(SEC_DISABLED),
+ add_legacy_(true) {
}
MediaSessionDescriptionFactory::MediaSessionDescriptionFactory(
ChannelManager* channel_manager)
- : secure_(SEC_DISABLED) {
+ : secure_(SEC_DISABLED),
+ add_legacy_(true) {
channel_manager->GetSupportedAudioCodecs(&audio_codecs_);
channel_manager->GetSupportedVideoCodecs(&video_codecs_);
}
SessionDescription* MediaSessionDescriptionFactory::CreateOffer(
- const MediaSessionOptions& options) {
- SessionDescription* offer = new SessionDescription();
+ const MediaSessionOptions& options,
+ const SessionDescription* current_description) {
+ scoped_ptr<SessionDescription> offer(new SessionDescription());
+
+ StreamParamsVec current_params;
+ GetCurrentStreamParams(current_description, ¤t_params);
if (options.has_audio) {
- AudioContentDescription* audio = new AudioContentDescription();
+ scoped_ptr<AudioContentDescription> audio(new AudioContentDescription());
for (AudioCodecs::const_iterator codec = audio_codecs_.begin();
codec != audio_codecs_.end(); ++codec) {
audio->AddCodec(*codec);
}
audio->SortCodecs();
- audio->set_ssrc(talk_base::CreateRandomNonZeroId());
- audio->set_rtcp_mux(true);
+ if (!AddStreamParams(MEDIA_TYPE_AUDIO, options.streams, ¤t_params,
+ audio.get())) {
+ return NULL; // Abort, something went seriously wrong.
+ }
+
+ if (options.streams.empty() && add_legacy_) {
+ // TODO: Remove this legacy stream when all apps use StreamParams.
+ audio->AddLegacyStream(talk_base::CreateRandomNonZeroId());
+ }
+ audio->set_multistream(options.is_muc);
+ audio->set_rtcp_mux(options.rtcp_mux_enabled);
audio->set_lang(lang_);
if (secure() != SEC_DISABLED) {
CryptoParamsVec audio_cryptos;
- if (GetSupportedAudioCryptos(&audio_cryptos)) {
- for (CryptoParamsVec::const_iterator crypto = audio_cryptos.begin();
- crypto != audio_cryptos.end(); ++crypto) {
- audio->AddCrypto(*crypto);
+ if (current_description) {
+ // Copy crypto parameters from the previous offer.
+ const ContentInfo* info =
+ GetFirstAudioContent(current_description);
+ if (info) {
+ const AudioContentDescription* desc =
+ static_cast<const AudioContentDescription*>(info->description);
+ audio_cryptos = desc->cryptos();
}
}
+ if (audio_cryptos.empty())
+ GetSupportedAudioCryptos(&audio_cryptos); // Generate new cryptos.
+
+ for (CryptoParamsVec::const_iterator crypto = audio_cryptos.begin();
+ crypto != audio_cryptos.end(); ++crypto) {
+ audio->AddCrypto(*crypto);
+ }
+
if (secure() == SEC_REQUIRED) {
if (audio->cryptos().empty()) {
return NULL; // Abort, crypto required but none found.
@@ -144,30 +322,47 @@
}
}
- offer->AddContent(CN_AUDIO, NS_JINGLE_RTP, audio);
+ offer->AddContent(CN_AUDIO, NS_JINGLE_RTP, audio.release());
}
// add video codecs, if this is a video call
if (options.has_video) {
- VideoContentDescription* video = new VideoContentDescription();
+ scoped_ptr<VideoContentDescription> video(new VideoContentDescription());
for (VideoCodecs::const_iterator codec = video_codecs_.begin();
codec != video_codecs_.end(); ++codec) {
video->AddCodec(*codec);
}
video->SortCodecs();
- video->set_ssrc(talk_base::CreateRandomNonZeroId());
+ if (!AddStreamParams(MEDIA_TYPE_VIDEO, options.streams, ¤t_params,
+ video.get())) {
+ return NULL; // Abort, something went seriously wrong.
+ }
+
+ if (options.streams.empty() && add_legacy_) {
+ // TODO: Remove this legacy stream when all apps use StreamParams.
+ video->AddLegacyStream(talk_base::CreateRandomNonZeroId());
+ }
+ video->set_multistream(options.is_muc);
video->set_bandwidth(options.video_bandwidth);
- video->set_rtcp_mux(true);
+ video->set_rtcp_mux(options.rtcp_mux_enabled);
if (secure() != SEC_DISABLED) {
CryptoParamsVec video_cryptos;
- if (GetSupportedVideoCryptos(&video_cryptos)) {
- for (CryptoParamsVec::const_iterator crypto = video_cryptos.begin();
- crypto != video_cryptos.end(); ++crypto) {
- video->AddCrypto(*crypto);
+ if (current_description) {
+ // Copy crypto parameters from the previous offer.
+ const VideoContentDescription* desc =
+ GetFirstVideoContentDescription(current_description);
+ if (desc) {
+ video_cryptos = desc->cryptos();
}
}
+ if (video_cryptos.empty())
+ GetSupportedVideoCryptos(&video_cryptos); // Generate new crypto.
+ for (CryptoParamsVec::const_iterator crypto = video_cryptos.begin();
+ crypto != video_cryptos.end(); ++crypto) {
+ video->AddCrypto(*crypto);
+ }
if (secure() == SEC_REQUIRED) {
if (video->cryptos().empty()) {
return NULL; // Abort, crypto required but none found.
@@ -176,24 +371,29 @@
}
}
- offer->AddContent(CN_VIDEO, NS_JINGLE_RTP, video);
+ offer->AddContent(CN_VIDEO, NS_JINGLE_RTP, video.release());
}
- return offer;
+ return offer.release();
}
SessionDescription* MediaSessionDescriptionFactory::CreateAnswer(
- const SessionDescription* offer, const MediaSessionOptions& options) {
+ const SessionDescription* offer, const MediaSessionOptions& options,
+ const SessionDescription* current_description) {
// The answer contains the intersection of the codecs in the offer with the
// codecs we support, ordered by our local preference. As indicated by
// XEP-0167, we retain the same payload ids from the offer in the answer.
- SessionDescription* accept = new SessionDescription();
+ scoped_ptr<SessionDescription> accept(new SessionDescription());
+
+ StreamParamsVec current_params;
+ GetCurrentStreamParams(current_description, ¤t_params);
const ContentInfo* audio_content = GetFirstAudioContent(offer);
if (audio_content && options.has_audio) {
const AudioContentDescription* audio_offer =
static_cast<const AudioContentDescription*>(audio_content->description);
- AudioContentDescription* audio_accept = new AudioContentDescription();
+ scoped_ptr<AudioContentDescription> audio_accept(
+ new AudioContentDescription());
for (AudioCodecs::const_iterator ours = audio_codecs_.begin();
ours != audio_codecs_.end(); ++ours) {
for (AudioCodecs::const_iterator theirs = audio_offer->codecs().begin();
@@ -207,13 +407,40 @@
}
audio_accept->SortCodecs();
- audio_accept->set_ssrc(talk_base::CreateRandomNonZeroId());
- audio_accept->set_rtcp_mux(audio_offer->rtcp_mux());
+ if (!AddStreamParams(MEDIA_TYPE_AUDIO, options.streams, ¤t_params,
+ audio_accept.get())) {
+ return NULL; // Abort, something went seriously wrong.
+ }
+
+ if (options.streams.empty() && add_legacy_) {
+ // TODO: Remove this legacy stream when all apps use StreamParams.
+ audio_accept->AddLegacyStream(talk_base::CreateRandomNonZeroId());
+ }
+ audio_accept->set_rtcp_mux(
+ options.rtcp_mux_enabled && audio_offer->rtcp_mux());
if (secure() != SEC_DISABLED) {
CryptoParams crypto;
if (SelectCrypto(audio_offer, &crypto)) {
+ if (current_description) {
+ // Check if this crypto already exist in the previous
+ // session description. Use it in that case.
+ const ContentInfo* info =
+ GetFirstAudioContent(current_description);
+ if (info) {
+ const AudioContentDescription* desc =
+ static_cast<const AudioContentDescription*>(info->description);
+ const CryptoParamsVec& cryptos = desc->cryptos();
+ for (CryptoParamsVec::const_iterator it = cryptos.begin();
+ it != cryptos.end(); ++it) {
+ if (crypto.Matches(*it)) {
+ crypto = *it;
+ break;
+ }
+ }
+ }
+ }
audio_accept->AddCrypto(crypto);
}
}
@@ -222,7 +449,8 @@
(audio_offer->crypto_required() || secure() == SEC_REQUIRED)) {
return NULL; // Fails the session setup.
}
- accept->AddContent(audio_content->name, audio_content->type, audio_accept);
+ accept->AddContent(audio_content->name, audio_content->type,
+ audio_accept.release());
} else {
LOG(LS_INFO) << "Audio is not supported in answer";
}
@@ -231,7 +459,8 @@
if (video_content && options.has_video) {
const VideoContentDescription* video_offer =
static_cast<const VideoContentDescription*>(video_content->description);
- VideoContentDescription* video_accept = new VideoContentDescription();
+ scoped_ptr<VideoContentDescription> video_accept(
+ new VideoContentDescription());
for (VideoCodecs::const_iterator ours = video_codecs_.begin();
ours != video_codecs_.end(); ++ours) {
for (VideoCodecs::const_iterator theirs = video_offer->codecs().begin();
@@ -243,16 +472,40 @@
}
}
}
+ if (!AddStreamParams(MEDIA_TYPE_VIDEO, options.streams, ¤t_params,
+ video_accept.get())) {
+ return NULL; // Abort, something went seriously wrong.
+ }
- video_accept->set_ssrc(talk_base::CreateRandomNonZeroId());
+ if (options.streams.empty() && add_legacy_) {
+ // TODO: Remove this legacy stream when all apps use StreamParams.
+ video_accept->AddLegacyStream(talk_base::CreateRandomNonZeroId());
+ }
video_accept->set_bandwidth(options.video_bandwidth);
- video_accept->set_rtcp_mux(video_offer->rtcp_mux());
+ video_accept->set_rtcp_mux(
+ options.rtcp_mux_enabled && video_offer->rtcp_mux());
video_accept->SortCodecs();
if (secure() != SEC_DISABLED) {
CryptoParams crypto;
if (SelectCrypto(video_offer, &crypto)) {
+ if (current_description) {
+ // Check if this crypto already exist in the previous
+ // session description. Use it in that case.
+ const VideoContentDescription* desc =
+ GetFirstVideoContentDescription(current_description);
+ if (desc) {
+ const CryptoParamsVec& cryptos = desc->cryptos();
+ for (CryptoParamsVec::const_iterator it = cryptos.begin();
+ it != cryptos.end(); ++it) {
+ if (crypto.Matches(*it)) {
+ crypto = *it;
+ break;
+ }
+ }
+ }
+ }
video_accept->AddCrypto(crypto);
}
}
@@ -261,12 +514,12 @@
(video_offer->crypto_required() || secure() == SEC_REQUIRED)) {
return NULL; // Fails the session setup.
}
- accept->AddContent(video_content->name, video_content->type, video_accept);
+ accept->AddContent(video_content->name, video_content->type,
+ video_accept.release());
} else {
LOG(LS_INFO) << "Video is not supported in answer";
}
-
- return accept;
+ return accept.release();
}
static bool IsMediaContent(const ContentInfo* content, MediaType media_type) {
@@ -287,12 +540,8 @@
return IsMediaContent(content, MEDIA_TYPE_VIDEO);
}
-static const ContentInfo* GetFirstMediaContent(const SessionDescription* sdesc,
+static const ContentInfo* GetFirstMediaContent(const ContentInfos& contents,
MediaType media_type) {
- if (sdesc == NULL)
- return NULL;
-
- const ContentInfos& contents = sdesc->contents();
for (ContentInfos::const_iterator content = contents.begin();
content != contents.end(); content++) {
if (IsMediaContent(&*content, media_type)) {
@@ -302,6 +551,22 @@
return NULL;
}
+const ContentInfo* GetFirstAudioContent(const ContentInfos& contents) {
+ return GetFirstMediaContent(contents, MEDIA_TYPE_AUDIO);
+}
+
+const ContentInfo* GetFirstVideoContent(const ContentInfos& contents) {
+ return GetFirstMediaContent(contents, MEDIA_TYPE_VIDEO);
+}
+
+static const ContentInfo* GetFirstMediaContent(const SessionDescription* sdesc,
+ MediaType media_type) {
+ if (sdesc == NULL)
+ return NULL;
+
+ return GetFirstMediaContent(sdesc->contents(), media_type);
+}
+
const ContentInfo* GetFirstAudioContent(const SessionDescription* sdesc) {
return GetFirstMediaContent(sdesc, MEDIA_TYPE_AUDIO);
}
@@ -310,4 +575,18 @@
return GetFirstMediaContent(sdesc, MEDIA_TYPE_VIDEO);
}
+const AudioContentDescription* GetFirstAudioContentDescription(
+ const SessionDescription* sdesc) {
+ const ContentInfo* content = GetFirstAudioContent(sdesc);
+ const ContentDescription* description = content ? content->description : NULL;
+ return static_cast<const AudioContentDescription*>(description);
+}
+
+const VideoContentDescription* GetFirstVideoContentDescription(
+ const SessionDescription* sdesc) {
+ const ContentInfo* content = GetFirstVideoContent(sdesc);
+ const ContentDescription* description = content ? content->description : NULL;
+ return static_cast<const VideoContentDescription*>(description);
+}
+
} // namespace cricket
diff --git a/talk/session/phone/mediasession.h b/talk/session/phone/mediasession.h
index 4e2a8fb..718f013 100644
--- a/talk/session/phone/mediasession.h
+++ b/talk/session/phone/mediasession.h
@@ -37,6 +37,7 @@
#include "talk/session/phone/codec.h"
#include "talk/session/phone/cryptoparams.h"
#include "talk/session/phone/mediachannel.h"
+#include "talk/session/phone/streamparams.h"
#include "talk/p2p/base/sessiondescription.h"
namespace cricket {
@@ -64,6 +65,11 @@
SEC_REQUIRED
};
+enum MediaType {
+ MEDIA_TYPE_AUDIO,
+ MEDIA_TYPE_VIDEO
+};
+
// Options to control how session descriptions are generated.
const int kAutoBandwidth = -1;
struct MediaSessionOptions {
@@ -71,41 +77,55 @@
has_audio(true), // Audio enabled by default.
has_video(false),
is_muc(false),
+ rtcp_mux_enabled(true),
video_bandwidth(kAutoBandwidth) {
}
+ // Add a stream with MediaType type and id name.
+ // All streams with the same sync_label will get the same CNAME.
+ // All names must be unique.
+ void AddStream(MediaType type,
+ const std::string& name,
+ const std::string& sync_label);
+ void RemoveStream(MediaType type, const std::string& name);
+
bool has_audio;
bool has_video;
bool is_muc;
+ bool rtcp_mux_enabled;
// bps. -1 == auto.
int video_bandwidth;
-};
-enum MediaType {
- MEDIA_TYPE_AUDIO,
- MEDIA_TYPE_VIDEO
+ struct Stream {
+ Stream(MediaType type,
+ const std::string& name,
+ const std::string& sync_label)
+ : type(type), name(name), sync_label(sync_label) {
+ }
+ MediaType type;
+ std::string name;
+ std::string sync_label;
+ };
+
+ typedef std::vector<Stream> Streams;
+ Streams streams;
};
// "content" (as used in XEP-0166) descriptions for voice and video.
class MediaContentDescription : public ContentDescription {
public:
MediaContentDescription()
- : ssrc_(0),
- ssrc_set_(false),
- rtcp_mux_(false),
+ : rtcp_mux_(false),
bandwidth_(kAutoBandwidth),
crypto_required_(false),
- rtp_header_extensions_set_(false) {
+ rtp_header_extensions_set_(false),
+ multistream_(false),
+ conference_mode_(false),
+ partial_(false) {
}
virtual MediaType type() const = 0;
-
- uint32 ssrc() const { return ssrc_; }
- bool ssrc_set() const { return ssrc_set_; }
- void set_ssrc(uint32 ssrc) {
- ssrc_ = ssrc;
- ssrc_set_ = true;
- }
+ virtual bool has_codecs() const = 0;
bool rtcp_mux() const { return rtcp_mux_; }
void set_rtcp_mux(bool mux) { rtcp_mux_ = mux; }
@@ -141,16 +161,63 @@
bool rtp_header_extensions_set() const {
return rtp_header_extensions_set_;
}
+ // True iff the client supports multiple streams.
+ void set_multistream(bool multistream) { multistream_ = multistream; }
+ bool multistream() const { return multistream_; }
+ const StreamParamsVec& streams() const {
+ return streams_;
+ }
+ // TODO: Remove this by giving mediamessage.cc access
+ // to MediaContentDescription
+ StreamParamsVec& mutable_streams() {
+ return streams_;
+ }
+ void AddStream(const StreamParams& stream) {
+ streams_.push_back(stream);
+ }
+ // Legacy streams have an ssrc, but nothing else.
+ void AddLegacyStream(uint32 ssrc) {
+ streams_.push_back(StreamParams::CreateLegacy(ssrc));
+ }
+ // Sets the CNAME of all StreamParams if it have not been set.
+ // This can be used to set the CNAME of legacy streams.
+ void SetCnameIfEmpty(const std::string& cname) {
+ for (cricket::StreamParamsVec::iterator it = streams_.begin();
+ it != streams_.end(); ++it) {
+ if (it->cname.empty())
+ it->cname = cname;
+ }
+ }
+ uint32 first_ssrc() const {
+ if (streams_.empty()) {
+ return 0;
+ }
+ return streams_[0].first_ssrc();
+ }
+ bool has_ssrcs() const {
+ if (streams_.empty()) {
+ return false;
+ }
+ return streams_[0].has_ssrcs();
+ }
+
+ void set_conference_mode(bool enable) { conference_mode_ = enable; }
+ bool conference_mode() const { return conference_mode_; }
+
+ void set_partial(bool partial) { partial_ = partial; }
+ bool partial() const { return partial_; }
protected:
- uint32 ssrc_;
- bool ssrc_set_;
bool rtcp_mux_;
int bandwidth_;
std::vector<CryptoParams> cryptos_;
bool crypto_required_;
std::vector<RtpHeaderExtension> rtp_header_extensions_;
bool rtp_header_extensions_set_;
+ bool multistream_;
+ StreamParamsVec streams_;
+ bool conference_mode_;
+ bool partial_;
};
template <class C>
@@ -161,6 +228,8 @@
};
const std::vector<C>& codecs() const { return codecs_; }
+ void set_codecs(const std::vector<C>& codecs) { codecs_ = codecs; }
+ virtual bool has_codecs() const { return !codecs_.empty(); }
void AddCodec(const C& codec) {
codecs_.push_back(codec);
}
@@ -175,21 +244,22 @@
class AudioContentDescription : public MediaContentDescriptionImpl<AudioCodec> {
public:
AudioContentDescription() :
- conference_mode_(false) {}
+ agc_minus_10db_(false) {}
virtual MediaType type() const { return MEDIA_TYPE_AUDIO; }
- bool conference_mode() const { return conference_mode_; }
- void set_conference_mode(bool enable) {
- conference_mode_ = enable;
- }
-
const std::string &lang() const { return lang_; }
void set_lang(const std::string &lang) { lang_ = lang; }
+ bool agc_minus_10db() const { return agc_minus_10db_; }
+ void set_agc_minus_10db(bool enable) {
+ agc_minus_10db_ = enable;
+ }
private:
- bool conference_mode_;
+ bool agc_minus_10db_;
+
+ private:
std::string lang_;
};
@@ -215,23 +285,40 @@
void set_video_codecs(const VideoCodecs& codecs) { video_codecs_ = codecs; }
SecureMediaPolicy secure() const { return secure_; }
void set_secure(SecureMediaPolicy s) { secure_ = s; }
+ // Decides if a StreamParams shall be added to the audio and video media
+ // content in SessionDescription when CreateOffer and CreateAnswer is called
+ // even if |options| don't include a Stream. This is needed to support legacy
+ // applications. |add_legacy_| is true per default.
+ void set_add_legacy_streams(bool add_legacy) { add_legacy_ = add_legacy; }
- SessionDescription* CreateOffer(const MediaSessionOptions& options);
- SessionDescription* CreateAnswer(const SessionDescription* offer,
- const MediaSessionOptions& options);
+ SessionDescription* CreateOffer(
+ const MediaSessionOptions& options,
+ const SessionDescription* current_description);
+
+ SessionDescription* CreateAnswer(
+ const SessionDescription* offer,
+ const MediaSessionOptions& options,
+ const SessionDescription* current_description);
private:
AudioCodecs audio_codecs_;
VideoCodecs video_codecs_;
SecureMediaPolicy secure_;
+ bool add_legacy_;
std::string lang_;
};
// Convenience functions.
bool IsAudioContent(const ContentInfo* content);
bool IsVideoContent(const ContentInfo* content);
+const ContentInfo* GetFirstAudioContent(const ContentInfos& contents);
+const ContentInfo* GetFirstVideoContent(const ContentInfos& contents);
const ContentInfo* GetFirstAudioContent(const SessionDescription* sdesc);
const ContentInfo* GetFirstVideoContent(const SessionDescription* sdesc);
+const AudioContentDescription* GetFirstAudioContentDescription(
+ const SessionDescription* sdesc);
+const VideoContentDescription* GetFirstVideoContentDescription(
+ const SessionDescription* sdesc);
} // namespace cricket
diff --git a/talk/session/phone/mediasession_unittest.cc b/talk/session/phone/mediasession_unittest.cc
new file mode 100644
index 0000000..974531e
--- /dev/null
+++ b/talk/session/phone/mediasession_unittest.cc
@@ -0,0 +1,624 @@
+/*
+ * libjingle
+ * Copyright 2004--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 <vector>
+
+#include "talk/base/gunit.h"
+#include "talk/p2p/base/constants.h"
+#include "talk/session/phone/codec.h"
+#include "talk/session/phone/mediasession.h"
+#include "talk/session/phone/srtpfilter.h"
+#include "talk/session/phone/testutils.h"
+
+#ifdef HAVE_SRTP
+#define ASSERT_CRYPTO(cd, r, s, cs) \
+ ASSERT_EQ(r, cd->crypto_required()); \
+ ASSERT_EQ(s, cd->cryptos().size()); \
+ ASSERT_EQ(std::string(cs), cd->cryptos()[0].cipher_suite)
+#else
+#define ASSERT_CRYPTO(c, r, s, cs) \
+ ASSERT_EQ(false, cd->crypto_required()); \
+ ASSERT_EQ(0U, cd->cryptos().size());
+#endif
+
+using cricket::MediaSessionDescriptionFactory;
+using cricket::MediaSessionOptions;
+using cricket::MediaType;
+using cricket::SessionDescription;
+using cricket::SsrcGroup;
+using cricket::StreamParams;
+using cricket::StreamParamsVec;
+using cricket::ContentInfo;
+using cricket::CryptoParamsVec;
+using cricket::AudioContentDescription;
+using cricket::VideoContentDescription;
+using cricket::GetFirstAudioContentDescription;
+using cricket::GetFirstVideoContentDescription;
+using cricket::kAutoBandwidth;
+using cricket::AudioCodec;
+using cricket::VideoCodec;
+using cricket::NS_JINGLE_RTP;
+using cricket::MEDIA_TYPE_AUDIO;
+using cricket::MEDIA_TYPE_VIDEO;
+using cricket::SEC_ENABLED;
+using cricket::CS_AES_CM_128_HMAC_SHA1_32;
+using cricket::CS_AES_CM_128_HMAC_SHA1_80;
+
+static const AudioCodec kAudioCodecs1[] = {
+ AudioCodec(103, "ISAC", 16000, -1, 1, 5),
+ AudioCodec(102, "iLBC", 8000, 13300, 1, 4),
+ AudioCodec(0, "PCMU", 8000, 64000, 1, 3),
+ AudioCodec(8, "PCMA", 8000, 64000, 1, 2),
+ AudioCodec(117, "red", 8000, 0, 1, 1),
+};
+
+static const AudioCodec kAudioCodecs2[] = {
+ AudioCodec(126, "speex", 16000, 22000, 1, 3),
+ AudioCodec(127, "iLBC", 8000, 13300, 1, 2),
+ AudioCodec(0, "PCMU", 8000, 64000, 1, 1),
+};
+
+static const AudioCodec kAudioCodecsAnswer[] = {
+ AudioCodec(102, "iLBC", 8000, 13300, 1, 2),
+ AudioCodec(0, "PCMU", 8000, 64000, 1, 1),
+};
+
+static const VideoCodec kVideoCodecs1[] = {
+ VideoCodec(96, "H264-SVC", 320, 200, 30, 2),
+ VideoCodec(97, "H264", 320, 200, 30, 1)
+};
+
+static const VideoCodec kVideoCodecs2[] = {
+ VideoCodec(126, "H264", 320, 200, 30, 2),
+ VideoCodec(127, "H263", 320, 200, 30, 1)
+};
+
+static const VideoCodec kVideoCodecsAnswer[] = {
+ VideoCodec(97, "H264", 320, 200, 30, 2)
+};
+
+static const uint32 kSimulcastParamsSsrc[] = {10, 11, 20, 21, 30, 31};
+static const uint32 kSimSsrc[] = {10, 20, 30};
+static const uint32 kFec1Ssrc[] = {10, 11};
+static const uint32 kFec2Ssrc[] = {20, 21};
+static const uint32 kFec3Ssrc[] = {30, 31};
+
+static const char kMediaStream1[] = "stream_1";
+static const char kMediaStream2[] = "stream_2";
+static const char kVideoTrack1[] = "video_1";
+static const char kVideoTrack2[] = "video_2";
+static const char kAudioTrack1[] = "audio_1";
+static const char kAudioTrack2[] = "audio_2";
+static const char kAudioTrack3[] = "audio_3";
+
+class MediaSessionDescriptionFactoryTest : public testing::Test {
+ public:
+ MediaSessionDescriptionFactoryTest() {
+ f1_.set_audio_codecs(MAKE_VECTOR(kAudioCodecs1));
+ f1_.set_video_codecs(MAKE_VECTOR(kVideoCodecs1));
+ f2_.set_audio_codecs(MAKE_VECTOR(kAudioCodecs2));
+ f2_.set_video_codecs(MAKE_VECTOR(kVideoCodecs2));
+ }
+
+ // Create a video StreamParamsVec object with:
+ // - one video stream with 3 simulcast streams and FEC,
+ StreamParamsVec CreateComplexVideoStreamParamsVec() {
+ SsrcGroup sim_group("SIM", MAKE_VECTOR(kSimSsrc));
+ SsrcGroup fec_group1("FEC", MAKE_VECTOR(kFec1Ssrc));
+ SsrcGroup fec_group2("FEC", MAKE_VECTOR(kFec2Ssrc));
+ SsrcGroup fec_group3("FEC", MAKE_VECTOR(kFec3Ssrc));
+
+ std::vector<SsrcGroup> ssrc_groups;
+ ssrc_groups.push_back(sim_group);
+ ssrc_groups.push_back(fec_group1);
+ ssrc_groups.push_back(fec_group2);
+ ssrc_groups.push_back(fec_group3);
+
+ StreamParams simulcast_params;
+ simulcast_params.name = kVideoTrack1;
+ simulcast_params.ssrcs = MAKE_VECTOR(kSimulcastParamsSsrc);
+ simulcast_params.ssrc_groups = ssrc_groups;
+ simulcast_params.cname = "Video_SIM_FEC";
+ simulcast_params.sync_label = kMediaStream1;
+
+ StreamParamsVec video_streams;
+ video_streams.push_back(simulcast_params);
+
+ return video_streams;
+ }
+ bool CompareCryptoParams(const CryptoParamsVec& c1,
+ const CryptoParamsVec& c2) {
+ if (c1.size() != c2.size())
+ return false;
+ for (size_t i = 0; i < c1.size(); ++i)
+ if (c1[i].tag != c2[i].tag || c1[i].cipher_suite != c2[i].cipher_suite ||
+ c1[i].key_params != c2[i].key_params ||
+ c1[i].session_params != c2[i].session_params)
+ return false;
+ return true;
+ }
+
+ protected:
+ MediaSessionDescriptionFactory f1_;
+ MediaSessionDescriptionFactory f2_;
+};
+
+// Create a typical audio offer, and ensure it matches what we expect.
+TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioOffer) {
+ f1_.set_secure(SEC_ENABLED);
+ talk_base::scoped_ptr<SessionDescription> offer(
+ f1_.CreateOffer(MediaSessionOptions(), NULL));
+ ASSERT_TRUE(offer.get() != NULL);
+ const ContentInfo* ac = offer->GetContentByName("audio");
+ const ContentInfo* vc = offer->GetContentByName("video");
+ ASSERT_TRUE(ac != NULL);
+ ASSERT_TRUE(vc == NULL);
+ EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
+ const AudioContentDescription* acd =
+ static_cast<const AudioContentDescription*>(ac->description);
+ EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
+ EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
+ EXPECT_NE(0U, acd->first_ssrc()); // a random nonzero ssrc
+ EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // default bandwidth (auto)
+ EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
+ ASSERT_CRYPTO(acd, false, 2U, CS_AES_CM_128_HMAC_SHA1_32);
+}
+
+// Create a typical video offer, and ensure it matches what we expect.
+TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoOffer) {
+ MediaSessionOptions opts;
+ opts.has_video = true;
+ f1_.set_secure(SEC_ENABLED);
+ talk_base::scoped_ptr<SessionDescription>
+ offer(f1_.CreateOffer(opts, NULL));
+ ASSERT_TRUE(offer.get() != NULL);
+ const ContentInfo* ac = offer->GetContentByName("audio");
+ const ContentInfo* vc = offer->GetContentByName("video");
+ ASSERT_TRUE(ac != NULL);
+ ASSERT_TRUE(vc != NULL);
+ EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
+ EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
+ const AudioContentDescription* acd =
+ static_cast<const AudioContentDescription*>(ac->description);
+ const VideoContentDescription* vcd =
+ static_cast<const VideoContentDescription*>(vc->description);
+ EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
+ EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
+ EXPECT_NE(0U, acd->first_ssrc()); // a random nonzero ssrc
+ EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // default bandwidth (auto)
+ EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
+ ASSERT_CRYPTO(acd, false, 2U, CS_AES_CM_128_HMAC_SHA1_32);
+ EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
+ EXPECT_EQ(f1_.video_codecs(), vcd->codecs());
+ EXPECT_NE(0U, vcd->first_ssrc()); // a random nonzero ssrc
+ EXPECT_EQ(kAutoBandwidth, vcd->bandwidth()); // default bandwidth (auto)
+ EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on
+ ASSERT_CRYPTO(vcd, false, 1U, CS_AES_CM_128_HMAC_SHA1_80);
+}
+
+// Create an audio, video offer without legacy StreamParams.
+TEST_F(MediaSessionDescriptionFactoryTest,
+ TestCreateOfferWithoutLegacyStreams) {
+ MediaSessionOptions opts;
+ opts.has_video = true;
+ f1_.set_add_legacy_streams(false);
+ talk_base::scoped_ptr<SessionDescription>
+ offer(f1_.CreateOffer(opts, NULL));
+ ASSERT_TRUE(offer.get() != NULL);
+ const ContentInfo* ac = offer->GetContentByName("audio");
+ const ContentInfo* vc = offer->GetContentByName("video");
+ ASSERT_TRUE(ac != NULL);
+ ASSERT_TRUE(vc != NULL);
+ const AudioContentDescription* acd =
+ static_cast<const AudioContentDescription*>(ac->description);
+ const VideoContentDescription* vcd =
+ static_cast<const VideoContentDescription*>(vc->description);
+
+ EXPECT_FALSE(vcd->has_ssrcs()); // No StreamParams.
+ EXPECT_FALSE(acd->has_ssrcs()); // No StreamParams.
+}
+
+// Create a typical audio answer, and ensure it matches what we expect.
+TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswer) {
+ f1_.set_secure(SEC_ENABLED);
+ f2_.set_secure(SEC_ENABLED);
+ talk_base::scoped_ptr<SessionDescription> offer(
+ f1_.CreateOffer(MediaSessionOptions(), NULL));
+ ASSERT_TRUE(offer.get() != NULL);
+ talk_base::scoped_ptr<SessionDescription> answer(
+ f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
+ const ContentInfo* ac = answer->GetContentByName("audio");
+ const ContentInfo* vc = answer->GetContentByName("video");
+ ASSERT_TRUE(ac != NULL);
+ ASSERT_TRUE(vc == NULL);
+ EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
+ const AudioContentDescription* acd =
+ static_cast<const AudioContentDescription*>(ac->description);
+ EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
+ EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
+ EXPECT_NE(0U, acd->first_ssrc()); // a random nonzero ssrc
+ EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // negotiated auto bw
+ EXPECT_TRUE(acd->rtcp_mux()); // negotiated rtcp-mux
+ ASSERT_CRYPTO(acd, false, 1U, CS_AES_CM_128_HMAC_SHA1_32);
+}
+
+// Create a typical video answer, and ensure it matches what we expect.
+TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswer) {
+ MediaSessionOptions opts;
+ opts.has_video = true;
+ f1_.set_secure(SEC_ENABLED);
+ f2_.set_secure(SEC_ENABLED);
+ talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+ ASSERT_TRUE(offer.get() != NULL);
+ talk_base::scoped_ptr<SessionDescription> answer(
+ f2_.CreateAnswer(offer.get(), opts, NULL));
+ const ContentInfo* ac = answer->GetContentByName("audio");
+ const ContentInfo* vc = answer->GetContentByName("video");
+ ASSERT_TRUE(ac != NULL);
+ ASSERT_TRUE(vc != NULL);
+ EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
+ EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
+ const AudioContentDescription* acd =
+ static_cast<const AudioContentDescription*>(ac->description);
+ const VideoContentDescription* vcd =
+ static_cast<const VideoContentDescription*>(vc->description);
+ EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
+ EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
+ EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // negotiated auto bw
+ EXPECT_NE(0U, acd->first_ssrc()); // a random nonzero ssrc
+ EXPECT_TRUE(acd->rtcp_mux()); // negotiated rtcp-mux
+ ASSERT_CRYPTO(acd, false, 1U, CS_AES_CM_128_HMAC_SHA1_32);
+ EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
+ EXPECT_EQ(MAKE_VECTOR(kVideoCodecsAnswer), vcd->codecs());
+ EXPECT_NE(0U, vcd->first_ssrc()); // a random nonzero ssrc
+ EXPECT_TRUE(vcd->rtcp_mux()); // negotiated rtcp-mux
+ ASSERT_CRYPTO(vcd, false, 1U, CS_AES_CM_128_HMAC_SHA1_80);
+}
+
+// Create an audio, video answer without legacy StreamParams.
+TEST_F(MediaSessionDescriptionFactoryTest,
+ TestCreateAnswerWithoutLegacyStreams) {
+ MediaSessionOptions opts;
+ opts.has_video = true;
+ f1_.set_add_legacy_streams(false);
+ f2_.set_add_legacy_streams(false);
+ talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+ ASSERT_TRUE(offer.get() != NULL);
+ talk_base::scoped_ptr<SessionDescription> answer(
+ f2_.CreateAnswer(offer.get(), opts, NULL));
+ const ContentInfo* ac = answer->GetContentByName("audio");
+ const ContentInfo* vc = answer->GetContentByName("video");
+ ASSERT_TRUE(ac != NULL);
+ ASSERT_TRUE(vc != NULL);
+ const AudioContentDescription* acd =
+ static_cast<const AudioContentDescription*>(ac->description);
+ const VideoContentDescription* vcd =
+ static_cast<const VideoContentDescription*>(vc->description);
+
+ EXPECT_FALSE(acd->has_ssrcs()); // No StreamParams.
+ EXPECT_FALSE(vcd->has_ssrcs()); // No StreamParams.
+}
+
+TEST_F(MediaSessionDescriptionFactoryTest, TestPartial) {
+ MediaSessionOptions opts;
+ opts.has_video = true;
+ f1_.set_secure(SEC_ENABLED);
+ talk_base::scoped_ptr<SessionDescription>
+ offer(f1_.CreateOffer(opts, NULL));
+ ASSERT_TRUE(offer.get() != NULL);
+ const ContentInfo* ac = offer->GetContentByName("audio");
+ const ContentInfo* vc = offer->GetContentByName("video");
+ AudioContentDescription* acd = const_cast<AudioContentDescription*>(
+ static_cast<const AudioContentDescription*>(ac->description));
+ VideoContentDescription* vcd = const_cast<VideoContentDescription*>(
+ static_cast<const VideoContentDescription*>(vc->description));
+
+ EXPECT_FALSE(acd->partial()); // default is false.
+ acd->set_partial(true);
+ EXPECT_TRUE(acd->partial());
+ acd->set_partial(false);
+ EXPECT_FALSE(acd->partial());
+
+ EXPECT_FALSE(vcd->partial()); // default is false.
+ vcd->set_partial(true);
+ EXPECT_TRUE(vcd->partial());
+ vcd->set_partial(false);
+ EXPECT_FALSE(vcd->partial());
+}
+
+// Create a typical video answer, and ensure it matches what we expect.
+TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswerRtcpMux) {
+ MediaSessionOptions offer_opts;
+ MediaSessionOptions answer_opts;
+ answer_opts.has_video = true;
+ offer_opts.has_video = true;
+
+ talk_base::scoped_ptr<SessionDescription> offer(NULL);
+ talk_base::scoped_ptr<SessionDescription> answer(NULL);
+
+ offer_opts.rtcp_mux_enabled = true;
+ answer_opts.rtcp_mux_enabled = true;
+
+ offer.reset(f1_.CreateOffer(offer_opts, NULL));
+ answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
+ ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
+ ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
+ ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
+ ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
+ EXPECT_TRUE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
+ EXPECT_TRUE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
+ EXPECT_TRUE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
+ EXPECT_TRUE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
+
+ offer_opts.rtcp_mux_enabled = true;
+ answer_opts.rtcp_mux_enabled = false;
+
+ offer.reset(f1_.CreateOffer(offer_opts, NULL));
+ answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
+ ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
+ ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
+ ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
+ ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
+ EXPECT_TRUE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
+ EXPECT_TRUE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
+ EXPECT_FALSE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
+ EXPECT_FALSE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
+
+ offer_opts.rtcp_mux_enabled = false;
+ answer_opts.rtcp_mux_enabled = true;
+
+ offer.reset(f1_.CreateOffer(offer_opts, NULL));
+ answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
+ ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
+ ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
+ ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
+ ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
+ EXPECT_FALSE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
+ EXPECT_FALSE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
+ EXPECT_FALSE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
+ EXPECT_FALSE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
+
+ offer_opts.rtcp_mux_enabled = false;
+ answer_opts.rtcp_mux_enabled = false;
+
+ offer.reset(f1_.CreateOffer(offer_opts, NULL));
+ answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
+ ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
+ ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
+ ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
+ ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
+ EXPECT_FALSE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
+ EXPECT_FALSE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
+ EXPECT_FALSE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
+ EXPECT_FALSE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
+}
+
+// Create an audio-only answer to a video offer.
+TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswerToVideo) {
+ MediaSessionOptions opts;
+ opts.has_video = true;
+ talk_base::scoped_ptr<SessionDescription>
+ offer(f1_.CreateOffer(opts, NULL));
+ ASSERT_TRUE(offer.get() != NULL);
+ talk_base::scoped_ptr<SessionDescription> answer(
+ f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
+ const ContentInfo* ac = answer->GetContentByName("audio");
+ const ContentInfo* vc = answer->GetContentByName("video");
+ ASSERT_TRUE(ac != NULL);
+ ASSERT_TRUE(vc == NULL);
+}
+
+// Create an audio and video offer with:
+// - one video track,
+// - two audio tracks.
+// and ensure it matches what we expect. Also updates the initial offer by
+// adding a new video track and replaces one of the audio tracks.
+TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoOffer) {
+ MediaSessionOptions opts;
+ opts.AddStream(MEDIA_TYPE_VIDEO, kVideoTrack1, kMediaStream1);
+ opts.AddStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
+ opts.AddStream(MEDIA_TYPE_AUDIO, kAudioTrack2, kMediaStream1);
+
+ f1_.set_secure(SEC_ENABLED);
+ talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+
+ ASSERT_TRUE(offer.get() != NULL);
+ const ContentInfo* ac = offer->GetContentByName("audio");
+ const ContentInfo* vc = offer->GetContentByName("video");
+ ASSERT_TRUE(ac != NULL);
+ ASSERT_TRUE(vc != NULL);
+ const AudioContentDescription* acd =
+ static_cast<const AudioContentDescription*>(ac->description);
+ const VideoContentDescription* vcd =
+ static_cast<const VideoContentDescription*>(vc->description);
+ EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
+ EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
+
+ const StreamParamsVec& audio_streams = acd->streams();
+ ASSERT_EQ(2U, audio_streams.size());
+ EXPECT_EQ(audio_streams[0].cname , audio_streams[1].cname);
+ EXPECT_EQ(kAudioTrack1, audio_streams[0].name);
+ ASSERT_EQ(1U, audio_streams[0].ssrcs.size());
+ EXPECT_NE(0U, audio_streams[0].ssrcs[0]);
+ EXPECT_EQ(kAudioTrack2, audio_streams[1].name);
+ ASSERT_EQ(1U, audio_streams[1].ssrcs.size());
+ EXPECT_NE(0U, audio_streams[1].ssrcs[0]);
+
+ EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // default bandwidth (auto)
+ EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
+ ASSERT_CRYPTO(acd, false, 2U, CS_AES_CM_128_HMAC_SHA1_32);
+
+ EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
+ EXPECT_EQ(f1_.video_codecs(), vcd->codecs());
+ ASSERT_CRYPTO(vcd, false, 1U, CS_AES_CM_128_HMAC_SHA1_80);
+
+ const StreamParamsVec& video_streams = vcd->streams();
+ ASSERT_EQ(1U, video_streams.size());
+ EXPECT_EQ(video_streams[0].cname, audio_streams[0].cname);
+ EXPECT_EQ(kVideoTrack1, video_streams[0].name);
+ EXPECT_EQ(kAutoBandwidth, vcd->bandwidth()); // default bandwidth (auto)
+ EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on
+
+
+ // Update the offer. Add a new video track that is not synched to the
+ // other tracks and replace audio track 2 with audio track 3.
+ opts.AddStream(MEDIA_TYPE_VIDEO, kVideoTrack2, kMediaStream2);
+ opts.RemoveStream(MEDIA_TYPE_AUDIO, kAudioTrack2);
+ opts.AddStream(MEDIA_TYPE_AUDIO, kAudioTrack3, kMediaStream1);
+ talk_base::scoped_ptr<SessionDescription>
+ updated_offer(f1_.CreateOffer(opts, offer.get()));
+
+ ASSERT_TRUE(updated_offer.get() != NULL);
+ ac = updated_offer->GetContentByName("audio");
+ vc = updated_offer->GetContentByName("video");
+ ASSERT_TRUE(ac != NULL);
+ ASSERT_TRUE(vc != NULL);
+ const AudioContentDescription* updated_acd =
+ static_cast<const AudioContentDescription*>(ac->description);
+ const VideoContentDescription* updated_vcd =
+ static_cast<const VideoContentDescription*>(vc->description);
+
+ EXPECT_EQ(acd->type(), updated_acd->type());
+ EXPECT_EQ(acd->codecs(), updated_acd->codecs());
+ EXPECT_EQ(vcd->type(), updated_vcd->type());
+ EXPECT_EQ(vcd->codecs(), updated_vcd->codecs());
+ ASSERT_CRYPTO(updated_acd, false, 2U, CS_AES_CM_128_HMAC_SHA1_32);
+ EXPECT_TRUE(CompareCryptoParams(acd->cryptos(), updated_acd->cryptos()));
+ ASSERT_CRYPTO(updated_vcd, false, 1U, CS_AES_CM_128_HMAC_SHA1_80);
+ EXPECT_TRUE(CompareCryptoParams(vcd->cryptos(), updated_vcd->cryptos()));
+
+ const StreamParamsVec& updated_audio_streams = updated_acd->streams();
+ ASSERT_EQ(2U, updated_audio_streams.size());
+ EXPECT_EQ(audio_streams[0], updated_audio_streams[0]);
+ EXPECT_EQ(kAudioTrack3, updated_audio_streams[1].name); // New audio track.
+ ASSERT_EQ(1U, updated_audio_streams[1].ssrcs.size());
+ EXPECT_NE(0U, updated_audio_streams[1].ssrcs[0]);
+ EXPECT_EQ(updated_audio_streams[0].cname, updated_audio_streams[1].cname);
+
+ const StreamParamsVec& updated_video_streams = updated_vcd->streams();
+ ASSERT_EQ(2U, updated_video_streams.size());
+ EXPECT_EQ(video_streams[0], updated_video_streams[0]);
+ EXPECT_EQ(kVideoTrack2, updated_video_streams[1].name);
+ EXPECT_NE(updated_video_streams[1].cname, updated_video_streams[0].cname);
+}
+
+// Create an audio and video answer to a standard video offer with:
+// - one video track,
+// - two audio tracks.
+// and ensure it matches what we expect. Also updates the initial answer by
+// adding a new video track and removes one of the audio tracks.
+TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoAnswer) {
+ MediaSessionOptions offer_opts;
+ offer_opts.has_video = true;
+ f1_.set_secure(SEC_ENABLED);
+ f2_.set_secure(SEC_ENABLED);
+ talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(offer_opts,
+ NULL));
+
+ MediaSessionOptions opts;
+ opts.AddStream(MEDIA_TYPE_VIDEO, kVideoTrack1, kMediaStream1);
+ opts.AddStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
+ opts.AddStream(MEDIA_TYPE_AUDIO, kAudioTrack2, kMediaStream1);
+
+ talk_base::scoped_ptr<SessionDescription>
+ answer(f2_.CreateAnswer(offer.get(), opts, NULL));
+
+ ASSERT_TRUE(answer.get() != NULL);
+ const ContentInfo* ac = answer->GetContentByName("audio");
+ const ContentInfo* vc = answer->GetContentByName("video");
+ ASSERT_TRUE(ac != NULL);
+ ASSERT_TRUE(vc != NULL);
+ const AudioContentDescription* acd =
+ static_cast<const AudioContentDescription*>(ac->description);
+ const VideoContentDescription* vcd =
+ static_cast<const VideoContentDescription*>(vc->description);
+ EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
+ EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
+ ASSERT_CRYPTO(acd, false, 1U, CS_AES_CM_128_HMAC_SHA1_32);
+ ASSERT_CRYPTO(vcd, false, 1U, CS_AES_CM_128_HMAC_SHA1_80);
+
+ const StreamParamsVec& audio_streams = acd->streams();
+ ASSERT_EQ(2U, audio_streams.size());
+ EXPECT_TRUE(audio_streams[0].cname == audio_streams[1].cname);
+ EXPECT_EQ(kAudioTrack1, audio_streams[0].name);
+ ASSERT_EQ(1U, audio_streams[0].ssrcs.size());
+ EXPECT_NE(0U, audio_streams[0].ssrcs[0]);
+ EXPECT_EQ(kAudioTrack2, audio_streams[1].name);
+ ASSERT_EQ(1U, audio_streams[1].ssrcs.size());
+ EXPECT_NE(0U, audio_streams[1].ssrcs[0]);
+
+ EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // default bandwidth (auto)
+ EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
+
+ EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
+ EXPECT_EQ(MAKE_VECTOR(kVideoCodecsAnswer), vcd->codecs());
+
+ const StreamParamsVec& video_streams = vcd->streams();
+ ASSERT_EQ(1U, video_streams.size());
+ EXPECT_EQ(video_streams[0].cname, audio_streams[0].cname);
+ EXPECT_EQ(kVideoTrack1, video_streams[0].name);
+ EXPECT_EQ(kAutoBandwidth, vcd->bandwidth()); // default bandwidth (auto)
+ EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on
+
+ // Update the answer. Add a new video track that is not synched to the
+ // other traacks and remove 1 audio track.
+ opts.AddStream(MEDIA_TYPE_VIDEO, kVideoTrack2, kMediaStream2);
+ opts.RemoveStream(MEDIA_TYPE_AUDIO, kAudioTrack2);
+ talk_base::scoped_ptr<SessionDescription>
+ updated_answer(f2_.CreateAnswer(offer.get(), opts, answer.get()));
+
+ ASSERT_TRUE(updated_answer.get() != NULL);
+ ac = updated_answer->GetContentByName("audio");
+ vc = updated_answer->GetContentByName("video");
+ ASSERT_TRUE(ac != NULL);
+ ASSERT_TRUE(vc != NULL);
+ const AudioContentDescription* updated_acd =
+ static_cast<const AudioContentDescription*>(ac->description);
+ const VideoContentDescription* updated_vcd =
+ static_cast<const VideoContentDescription*>(vc->description);
+
+ ASSERT_CRYPTO(updated_acd, false, 1U, CS_AES_CM_128_HMAC_SHA1_32);
+ EXPECT_TRUE(CompareCryptoParams(acd->cryptos(), updated_acd->cryptos()));
+ ASSERT_CRYPTO(updated_vcd, false, 1U, CS_AES_CM_128_HMAC_SHA1_80);
+ EXPECT_TRUE(CompareCryptoParams(vcd->cryptos(), updated_vcd->cryptos()));
+
+ EXPECT_EQ(acd->type(), updated_acd->type());
+ EXPECT_EQ(acd->codecs(), updated_acd->codecs());
+ EXPECT_EQ(vcd->type(), updated_vcd->type());
+ EXPECT_EQ(vcd->codecs(), updated_vcd->codecs());
+
+ const StreamParamsVec& updated_audio_streams = updated_acd->streams();
+ ASSERT_EQ(1U, updated_audio_streams.size());
+ EXPECT_TRUE(audio_streams[0] == updated_audio_streams[0]);
+
+ const StreamParamsVec& updated_video_streams = updated_vcd->streams();
+ ASSERT_EQ(2U, updated_video_streams.size());
+ EXPECT_EQ(video_streams[0], updated_video_streams[0]);
+ EXPECT_EQ(kVideoTrack2, updated_video_streams[1].name);
+ EXPECT_NE(updated_video_streams[1].cname, updated_video_streams[0].cname);
+}
diff --git a/talk/session/phone/mediasessionclient.cc b/talk/session/phone/mediasessionclient.cc
index 3491d26..07ccf13 100644
--- a/talk/session/phone/mediasessionclient.cc
+++ b/talk/session/phone/mediasessionclient.cc
@@ -36,6 +36,7 @@
#include "talk/p2p/base/constants.h"
#include "talk/p2p/base/parsing.h"
#include "talk/session/phone/cryptoparams.h"
+#include "talk/session/phone/mediamessages.h"
#include "talk/session/phone/srtpfilter.h"
#include "talk/xmpp/constants.h"
#include "talk/xmllite/qname.h"
@@ -198,6 +199,8 @@
return session;
}
+// TODO: Move all of the parsing and writing functions into
+// mediamessages.cc, with unit tests.
bool ParseGingleAudioCodec(const buzz::XmlElement* element, AudioCodec* out) {
int id = GetXmlAttr(element, QN_ID, -1);
if (id < 0)
@@ -225,26 +228,30 @@
return true;
}
-uint32 parse_ssrc(const std::string& ssrc) {
- // TODO: Return an error rather than defaulting to 0.
- uint32 default_ssrc = 0U;
- return talk_base::FromString(default_ssrc, ssrc);
+// Parses an ssrc string as a legacy stream. If it fails, returns
+// false and fills an error message.
+bool ParseSsrcAsLegacyStream(const std::string& ssrc_str,
+ std::vector<StreamParams>* streams,
+ ParseError* error) {
+ if (!ssrc_str.empty()) {
+ uint32 ssrc;
+ if (!talk_base::FromString(ssrc_str, &ssrc)) {
+ return BadParse("Missing or invalid ssrc.", error);
+ }
+
+ streams->push_back(StreamParams::CreateLegacy(ssrc));
+ }
+ return true;
}
void ParseGingleSsrc(const buzz::XmlElement* parent_elem,
const buzz::QName& name,
- MediaContentDescription* content) {
+ MediaContentDescription* media) {
const buzz::XmlElement* ssrc_elem = parent_elem->FirstNamed(name);
if (ssrc_elem) {
- content->set_ssrc(parse_ssrc(ssrc_elem->BodyText()));
- }
-}
-
-void ParseJingleSsrc(const buzz::XmlElement* desc_elem,
- MediaContentDescription* content) {
- const std::string ssrc = desc_elem->Attr(QN_JINGLE_SSRC);
- if (!ssrc.empty()) {
- content->set_ssrc(parse_ssrc(ssrc));
+ ParseError error;
+ ParseSsrcAsLegacyStream(
+ ssrc_elem->BodyText(), &(media->mutable_streams()), &error);
}
}
@@ -304,7 +311,7 @@
void ParseBandwidth(const buzz::XmlElement* parent_elem,
MediaContentDescription* media) {
const buzz::XmlElement* bw_elem = GetXmlChild(parent_elem, LN_BANDWIDTH);
- int bandwidth_kbps;
+ int bandwidth_kbps = -1;
if (bw_elem && talk_base::FromString(bw_elem->BodyText(), &bandwidth_kbps)) {
if (bandwidth_kbps >= 0) {
media->set_bandwidth(bandwidth_kbps * 1000);
@@ -454,6 +461,23 @@
return true;
}
+bool ParseJingleStreamsOrLegacySsrc(const buzz::XmlElement* desc_elem,
+ MediaContentDescription* media,
+ ParseError* error) {
+ if (HasJingleStreams(desc_elem)) {
+ if (!ParseJingleStreams(desc_elem, &(media->mutable_streams()), error)) {
+ return false;
+ }
+ } else {
+ const std::string ssrc_str = desc_elem->Attr(QN_SSRC);
+ if (!ParseSsrcAsLegacyStream(
+ ssrc_str, &(media->mutable_streams()), error)) {
+ return false;
+ }
+ }
+ return true;
+}
+
bool ParseJingleAudioContent(const buzz::XmlElement* content_elem,
const ContentDescription** content,
ParseError* error) {
@@ -469,12 +493,16 @@
}
}
- ParseJingleSsrc(content_elem, audio);
+ if (!ParseJingleStreamsOrLegacySsrc(content_elem, audio, error)) {
+ return false;
+ }
if (!ParseJingleEncryption(content_elem, audio, error)) {
return false;
}
- // TODO: Figure out how to integrate SSRC into Jingle.
+
+ audio->set_rtcp_mux(content_elem->FirstNamed(QN_JINGLE_RTCP_MUX) != NULL);
+
*content = audio;
return true;
}
@@ -494,13 +522,17 @@
}
}
- ParseJingleSsrc(content_elem, video);
+ if (!ParseJingleStreamsOrLegacySsrc(content_elem, video, error)) {
+ return false;
+ }
ParseBandwidth(content_elem, video);
if (!ParseJingleEncryption(content_elem, video, error)) {
return false;
}
- // TODO: Figure out how to integrate SSRC into Jingle.
+
+ video->set_rtcp_mux(content_elem->FirstNamed(QN_JINGLE_RTCP_MUX) != NULL);
+
*content = video;
return true;
}
@@ -625,9 +657,9 @@
codec != audio->codecs().end(); ++codec) {
elem->AddElement(CreateGingleAudioCodecElem(*codec));
}
- if (audio->ssrc_set()) {
+ if (audio->has_ssrcs()) {
elem->AddElement(CreateGingleSsrcElem(
- QN_GINGLE_AUDIO_SRCID, audio->ssrc()));
+ QN_GINGLE_AUDIO_SRCID, audio->first_ssrc()));
}
const CryptoParamsVec& cryptos = audio->cryptos();
@@ -636,8 +668,6 @@
QN_GINGLE_AUDIO_CRYPTO_USAGE,
crypto_required));
}
-
-
return elem;
}
@@ -651,9 +681,9 @@
codec != video->codecs().end(); ++codec) {
elem->AddElement(CreateGingleVideoCodecElem(*codec));
}
- if (video->ssrc_set()) {
+ if (video->has_ssrcs()) {
elem->AddElement(CreateGingleSsrcElem(
- QN_GINGLE_VIDEO_SRCID, video->ssrc()));
+ QN_GINGLE_VIDEO_SRCID, video->first_ssrc()));
}
if (video->bandwidth() != kAutoBandwidth) {
elem->AddElement(CreateBandwidthElem(QN_GINGLE_VIDEO_BANDWIDTH,
@@ -714,15 +744,19 @@
return elem;
}
-void WriteJingleSsrc(const MediaContentDescription* media,
- buzz::XmlElement* elem) {
- // TODO: Right now, we have an ssrc=0 to mean "let the
- // server choose". In Jingle, it would make the most sense to just
- // leave off the attribute. But then we can't have an ssrc of 0.
- // Once we have initiator-choosen ssrcs, we can remove this check
- // and write out ssrc=0.
- if (media->ssrc_set() && (media->ssrc() != 0)) {
- AddXmlAttr(elem, QN_JINGLE_SSRC, media->ssrc());
+void WriteLegacyJingleSsrc(const MediaContentDescription* media,
+ buzz::XmlElement* elem) {
+ if (media->has_ssrcs()) {
+ AddXmlAttr(elem, QN_SSRC, media->first_ssrc());
+ }
+}
+
+void WriteJingleStreamsOrLegacySsrc(const MediaContentDescription* media,
+ buzz::XmlElement* desc_elem) {
+ if (!media->multistream()) {
+ WriteLegacyJingleSsrc(media, desc_elem);
+ } else {
+ WriteJingleStreams(media->streams(), desc_elem);
}
}
@@ -732,7 +766,7 @@
new buzz::XmlElement(QN_JINGLE_RTP_CONTENT, true);
elem->SetAttr(QN_JINGLE_CONTENT_MEDIA, JINGLE_CONTENT_MEDIA_AUDIO);
- WriteJingleSsrc(audio, elem);
+ WriteJingleStreamsOrLegacySsrc(audio, elem);
for (AudioCodecs::const_iterator codec = audio->codecs().begin();
codec != audio->codecs().end(); ++codec) {
@@ -757,7 +791,7 @@
new buzz::XmlElement(QN_JINGLE_RTP_CONTENT, true);
elem->SetAttr(QN_JINGLE_CONTENT_MEDIA, JINGLE_CONTENT_MEDIA_VIDEO);
- WriteJingleSsrc(video, elem);
+ WriteJingleStreamsOrLegacySsrc(video, elem);
for (VideoCodecs::const_iterator codec = video->codecs().begin();
codec != video->codecs().end(); ++codec) {
diff --git a/talk/session/phone/mediasessionclient.h b/talk/session/phone/mediasessionclient.h
index c5c455f..893e95f 100644
--- a/talk/session/phone/mediasessionclient.h
+++ b/talk/session/phone/mediasessionclient.h
@@ -98,11 +98,11 @@
}
SessionDescription* CreateOffer(const CallOptions& options) {
- return desc_factory_.CreateOffer(options);
+ return desc_factory_.CreateOffer(options, NULL);
}
SessionDescription* CreateAnswer(const SessionDescription* offer,
const CallOptions& options) {
- return desc_factory_.CreateAnswer(offer, options);
+ return desc_factory_.CreateAnswer(offer, options, NULL);
}
sigslot::signal2<Call *, Call *> SignalFocus;
diff --git a/talk/session/phone/mediasessionclient_unittest.cc b/talk/session/phone/mediasessionclient_unittest.cc
new file mode 100644
index 0000000..8232d3d
--- /dev/null
+++ b/talk/session/phone/mediasessionclient_unittest.cc
@@ -0,0 +1,2775 @@
+/*
+ * libjingle
+ * Copyright 2004--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 <vector>
+
+#include "talk/base/gunit.h"
+#include "talk/base/logging.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/p2p/base/constants.h"
+#include "talk/p2p/client/basicportallocator.h"
+#include "talk/session/phone/fakedevicemanager.h"
+#include "talk/session/phone/fakemediaengine.h"
+#include "talk/session/phone/mediasessionclient.h"
+#include "talk/xmllite/xmlelement.h"
+#include "talk/xmllite/xmlbuilder.h"
+#include "talk/xmllite/xmlprinter.h"
+#include "talk/xmpp/constants.h"
+
+// The codecs that our FakeMediaEngine will support. Order is important, since
+// the tests check that our messages have codecs in the correct order.
+static const cricket::AudioCodec kAudioCodecs[] = {
+ cricket::AudioCodec(103, "ISAC", 16000, -1, 1, 18),
+ cricket::AudioCodec(104, "ISAC", 32000, -1, 1, 17),
+ cricket::AudioCodec(119, "ISACLC", 16000, 40000, 1, 16),
+ cricket::AudioCodec(99, "speex", 16000, 22000, 1, 15),
+ cricket::AudioCodec(97, "IPCMWB", 16000, 80000, 1, 14),
+ cricket::AudioCodec(9, "G722", 16000, 64000, 1, 13),
+ cricket::AudioCodec(102, "iLBC", 8000, 13300, 1, 12),
+ cricket::AudioCodec(98, "speex", 8000, 11000, 1, 11),
+ cricket::AudioCodec(3, "GSM", 8000, 13000, 1, 10),
+ cricket::AudioCodec(100, "EG711U", 8000, 64000, 1, 9),
+ cricket::AudioCodec(101, "EG711A", 8000, 64000, 1, 8),
+ cricket::AudioCodec(0, "PCMU", 8000, 64000, 1, 7),
+ cricket::AudioCodec(8, "PCMA", 8000, 64000, 1, 6),
+ cricket::AudioCodec(126, "CN", 32000, 0, 1, 5),
+ cricket::AudioCodec(105, "CN", 16000, 0, 1, 4),
+ cricket::AudioCodec(13, "CN", 8000, 0, 1, 3),
+ cricket::AudioCodec(117, "red", 8000, 0, 1, 2),
+ cricket::AudioCodec(106, "telephone-event", 8000, 0, 1, 1)
+};
+
+static const cricket::VideoCodec kVideoCodecs[] = {
+ cricket::VideoCodec(96, "H264-SVC", 320, 200, 30, 1)
+};
+
+const std::string kGingleCryptoOffer = \
+ "<rtp:encryption xmlns:rtp='urn:xmpp:jingle:apps:rtp:1'> " \
+ " <usage/> " \
+ " <rtp:crypto tag='145' crypto-suite='AES_CM_128_HMAC_SHA1_32'" \
+ " key-params='inline:hsWuSQJxx7przmb8HM+ZkeNcG3HezSNID7LmfDa9'/>" \
+ " <rtp:crypto tag='51' crypto-suite='AES_CM_128_HMAC_SHA1_80'" \
+ " key-params='inline:J4lfdUL8W1F7TNJKcbuygaQuA429SJy2e9JctPUy'/>" \
+ "</rtp:encryption> ";
+
+// Jingle offer does not have any <usage> element.
+const std::string kJingleCryptoOffer = \
+ "<rtp:encryption xmlns:rtp='urn:xmpp:jingle:apps:rtp:1'> " \
+ " <rtp:crypto tag='145' crypto-suite='AES_CM_128_HMAC_SHA1_32'" \
+ " key-params='inline:hsWuSQJxx7przmb8HM+ZkeNcG3HezSNID7LmfDa9'/>" \
+ " <rtp:crypto tag='51' crypto-suite='AES_CM_128_HMAC_SHA1_80'" \
+ " key-params='inline:J4lfdUL8W1F7TNJKcbuygaQuA429SJy2e9JctPUy'/>" \
+ "</rtp:encryption> ";
+
+
+const std::string kGingleRequiredCryptoOffer = \
+ "<rtp:encryption xmlns:rtp='urn:xmpp:jingle:apps:rtp:1' required='true'> "\
+ " <usage/> " \
+ " <rtp:crypto tag='145' crypto-suite='AES_CM_128_HMAC_SHA1_32'" \
+ " key-params='inline:hsWuSQJxx7przmb8HM+ZkeNcG3HezSNID7LmfDa9'/>" \
+ " <rtp:crypto tag='51' crypto-suite='AES_CM_128_HMAC_SHA1_80'" \
+ " key-params='inline:J4lfdUL8W1F7TNJKcbuygaQuA429SJy2e9JctPUy'/>" \
+ "</rtp:encryption> ";
+
+const std::string kJingleRequiredCryptoOffer = \
+ "<rtp:encryption xmlns:rtp='urn:xmpp:jingle:apps:rtp:1' required='true'> "\
+ " <rtp:crypto tag='145' crypto-suite='AES_CM_128_HMAC_SHA1_32'" \
+ " key-params='inline:hsWuSQJxx7przmb8HM+ZkeNcG3HezSNID7LmfDa9'/>" \
+ " <rtp:crypto tag='51' crypto-suite='AES_CM_128_HMAC_SHA1_80'" \
+ " key-params='inline:J4lfdUL8W1F7TNJKcbuygaQuA429SJy2e9JctPUy'/>" \
+ "</rtp:encryption> ";
+
+
+const std::string kGingleUnsupportedCryptoOffer = \
+ "<rtp:encryption xmlns:rtp='urn:xmpp:jingle:apps:rtp:1'> " \
+ " <usage/> " \
+ " <rtp:crypto tag='145' crypto-suite='NOT_SUPPORTED_1'" \
+ " key-params='inline:hsWuSQJxx7przmb8HM+ZkeNcG3HezSNID7LmfDa9'/>" \
+ " <rtp:crypto tag='51' crypto-suite='NOT_SUPPORTED_2'" \
+ " key-params='inline:J4lfdUL8W1F7TNJKcbuygaQuA429SJy2e9JctPUy'/>" \
+ "</rtp:encryption> ";
+
+const std::string kJingleUnsupportedCryptoOffer = \
+ "<rtp:encryption xmlns:rtp='urn:xmpp:jingle:apps:rtp:1'> " \
+ " <rtp:crypto tag='145' crypto-suite='NOT_SUPPORTED_1'" \
+ " key-params='inline:hsWuSQJxx7przmb8HM+ZkeNcG3HezSNID7LmfDa9'/>" \
+ " <rtp:crypto tag='51' crypto-suite='NOT_SUPPORTED_2'" \
+ " key-params='inline:J4lfdUL8W1F7TNJKcbuygaQuA429SJy2e9JctPUy'/>" \
+ "</rtp:encryption> ";
+
+
+// With unsupported but with required="true"
+const std::string kGingleRequiredUnsupportedCryptoOffer = \
+ "<rtp:encryption xmlns:rtp='urn:xmpp:jingle:apps:rtp:1' required='true'>" \
+ " <usage/> " \
+ " <rtp:crypto tag='145' crypto-suite='NOT_SUPPORTED_1'" \
+ " key-params='inline:hsWuSQJxx7przmb8HM+ZkeNcG3HezSNID7LmfDa9'/>" \
+ " <rtp:crypto tag='51' crypto-suite='NOT_SUPPORTED_2'" \
+ " key-params='inline:J4lfdUL8W1F7TNJKcbuygaQuA429SJy2e9JctPUy'/>" \
+ "</rtp:encryption> ";
+
+const std::string kJingleRequiredUnsupportedCryptoOffer = \
+ "<rtp:encryption xmlns:rtp='urn:xmpp:jingle:apps:rtp:1' required='true'>" \
+ " <rtp:crypto tag='145' crypto-suite='NOT_SUPPORTED_1' " \
+ " key-params='inline:hsWuSQJxx7przmb8HM+ZkeNcG3HezSNID7LmfDa9'/> " \
+ " <rtp:crypto tag='51' crypto-suite='NOT_SUPPORTED_2' " \
+ " key-params='inline:J4lfdUL8W1F7TNJKcbuygaQuA429SJy2e9JctPUy'/>" \
+ "</rtp:encryption> ";
+
+const std::string kGingleInitiate(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <session xmlns='http://www.google.com/session' type='initiate'" \
+ " id='abcdef' initiator='me@domain.com/resource'> " \
+ " <description xmlns='http://www.google.com/session/phone'> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='103' name='ISAC' clockrate='16000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='104' name='ISAC' clockrate='32000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='119' name='ISACLC' clockrate='16000' bitrate='40000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='99' name='speex' clockrate='16000' bitrate='22000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='97' name='IPCMWB' clockrate='16000' bitrate='80000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='9' name='G722' clockrate='16000' bitrate='64000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='102' name='iLBC' clockrate='8000' bitrate='13300' />" \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='98' name='speex' clockrate='8000' bitrate='11000' />" \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='3' name='GSM' clockrate='8000' bitrate='13000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='100' name='EG711U' clockrate='8000' bitrate='64000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='101' name='EG711A' clockrate='8000' bitrate='64000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='0' name='PCMU' clockrate='8000' bitrate='64000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='8' name='PCMA' clockrate='8000' bitrate='64000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='126' name='CN' clockrate='32000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='105' name='CN' clockrate='16000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='13' name='CN' clockrate='8000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='117' name='red' clockrate='8000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='106' name='telephone-event' clockrate='8000' /> " \
+ " </description> " \
+ " </session> " \
+ "</iq> ");
+
+const std::string kJingleInitiate(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' " \
+ " sid='abcdef' initiator='me@domain.com/resource'> " \
+ " <content name='test audio'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='audio'> " \
+ " <payload-type id='103' name='ISAC' clockrate='16000'/> " \
+ " <payload-type id='104' name='ISAC' clockrate='32000'/> " \
+ " <payload-type " \
+ " id='119' name='ISACLC' clockrate='16000'> " \
+ " <parameter name='bitrate' value='40000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='99' name='speex' clockrate='16000'> " \
+ " <parameter name='bitrate' value='22000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='97' name='IPCMWB' clockrate='16000'> " \
+ " <parameter name='bitrate' value='80000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='9' name='G722' clockrate='16000'> " \
+ " <parameter name='bitrate' value='64000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='102' name='iLBC' clockrate='8000'> " \
+ " <parameter name='bitrate' value='13300'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='98' name='speex' clockrate='8000'> " \
+ " <parameter name='bitrate' value='11000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='3' name='GSM' clockrate='8000'> " \
+ " <parameter name='bitrate' value='13000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='100' name='EG711U' clockrate='8000'> " \
+ " <parameter name='bitrate' value='64000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='101' name='EG711A' clockrate='8000'> " \
+ " <parameter name='bitrate' value='64000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='0' name='PCMU' clockrate='8000'> " \
+ " <parameter name='bitrate' value='64000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='8' name='PCMA' clockrate='8000'> " \
+ " <parameter name='bitrate' value='64000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='126' name='CN' clockrate='32000' /> " \
+ " <payload-type " \
+ " id='105' name='CN' clockrate='16000' /> " \
+ " <payload-type " \
+ " id='13' name='CN' clockrate='8000' /> " \
+ " <payload-type " \
+ " id='117' name='red' clockrate='8000' /> " \
+ " <payload-type " \
+ " id='106' name='telephone-event' clockrate='8000' /> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " </jingle> " \
+ "</iq> ");
+
+// Initiate string with a different order of supported codecs.
+// Should accept the supported ones, but with our desired order.
+const std::string kGingleInitiateDifferentPreference(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <session xmlns='http://www.google.com/session' type='initiate'" \
+ " id='abcdef' initiator='me@domain.com/resource'> " \
+ " <description xmlns='http://www.google.com/session/phone'> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='104' name='ISAC' clockrate='32000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='97' name='IPCMWB' clockrate='16000' bitrate='80000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='9' name='G722' clockrate='16000' bitrate='64000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='119' name='ISACLC' clockrate='16000' bitrate='40000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='103' name='ISAC' clockrate='16000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='99' name='speex' clockrate='16000' bitrate='22000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='100' name='EG711U' clockrate='8000' bitrate='64000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='101' name='EG711A' clockrate='8000' bitrate='64000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='0' name='PCMU' clockrate='8000' bitrate='64000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='8' name='PCMA' clockrate='8000' bitrate='64000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='102' name='iLBC' clockrate='8000' bitrate='13300' />" \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='3' name='GSM' clockrate='8000' bitrate='13000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='98' name='speex' clockrate='8000' bitrate='11000' />" \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='126' name='CN' clockrate='32000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='105' name='CN' clockrate='16000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='13' name='CN' clockrate='8000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='117' name='red' clockrate='8000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='106' name='telephone-event' clockrate='8000' /> " \
+ " </description> " \
+ " </session> " \
+ "</iq> ");
+
+const std::string kJingleInitiateDifferentPreference(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' " \
+ " sid='abcdef' initiator='me@domain.com/resource'> " \
+ " <content name='test audio'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='audio'> " \
+ " <payload-type id='104' name='ISAC' clockrate='32000'/> " \
+ " <payload-type " \
+ " id='97' name='IPCMWB' clockrate='16000'> " \
+ " <parameter name='bitrate' value='80000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='9' name='G722' clockrate='16000'> " \
+ " <parameter name='bitrate' value='64000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='119' name='ISACLC' clockrate='16000'> " \
+ " <parameter name='bitrate' value='40000'/> " \
+ " </payload-type> " \
+ " <payload-type id='103' name='ISAC' clockrate='16000'/> " \
+ " <payload-type " \
+ " id='99' name='speex' clockrate='16000'> " \
+ " <parameter name='bitrate' value='22000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='100' name='EG711U' clockrate='8000'> " \
+ " <parameter name='bitrate' value='64000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='101' name='EG711A' clockrate='8000'> " \
+ " <parameter name='bitrate' value='64000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='0' name='PCMU' clockrate='8000'> " \
+ " <parameter name='bitrate' value='64000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='8' name='PCMA' clockrate='8000'> " \
+ " <parameter name='bitrate' value='64000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='102' name='iLBC' clockrate='8000'> " \
+ " <parameter name='bitrate' value='13300'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='3' name='GSM' clockrate='8000'> " \
+ " <parameter name='bitrate' value='13000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='98' name='speex' clockrate='8000'> " \
+ " <parameter name='bitrate' value='11000'/> " \
+ " </payload-type> " \
+ " <payload-type " \
+ " id='126' name='CN' clockrate='32000' /> " \
+ " <payload-type " \
+ " id='105' name='CN' clockrate='16000' /> " \
+ " <payload-type " \
+ " id='13' name='CN' clockrate='8000' /> " \
+ " <payload-type " \
+ " id='117' name='red' clockrate='8000' /> " \
+ " <payload-type " \
+ " id='106' name='telephone-event' clockrate='8000' /> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " </jingle> " \
+ "</iq> ");
+
+const std::string kGingleVideoInitiate(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <session xmlns='http://www.google.com/session' type='initiate'" \
+ " id='abcdef' initiator='me@domain.com/resource'> " \
+ " <description xmlns='http://www.google.com/session/video'> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='103' name='ISAC' clockrate='16000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/video' " \
+ " id='99' name='H264-SVC' framerate='30' " \
+ " height='200' width='320'/> " \
+ " </description> " \
+ " </session> " \
+ "</iq> ");
+
+const std::string kJingleVideoInitiate(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' " \
+ " sid='abcdef' initiator='me@domain.com/resource'> " \
+ " <content name='test audio'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='audio'> " \
+ " <payload-type id='103' name='ISAC' clockrate='16000'/> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " <content name='test video'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='video'> " \
+ " <payload-type id='99' name='H264-SVC'> " \
+ " <parameter name='height' value='200'/> " \
+ " <parameter name='width' value='320'/> " \
+ " <parameter name='framerate' value='30'/> " \
+ " </payload-type> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " </jingle> " \
+ "</iq> ");
+
+const std::string kJingleVideoInitiateWithBandwidth(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' " \
+ " sid='abcdef' initiator='me@domain.com/resource'> " \
+ " <content name='test audio'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='audio'> " \
+ " <payload-type id='103' name='ISAC' clockrate='16000'/> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " <content name='test video'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='video'> " \
+ " <payload-type id='99' name='H264-SVC'> " \
+ " <parameter name='height' value='200'/> " \
+ " <parameter name='width' value='320'/> " \
+ " <parameter name='framerate' value='30'/> " \
+ " </payload-type> " \
+ " <bandwidth type='AS'>42</bandwidth> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " </jingle> " \
+ "</iq> ");
+
+const std::string kJingleVideoInitiateWithRtcpMux(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' " \
+ " sid='abcdef' initiator='me@domain.com/resource'> " \
+ " <content name='test audio'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='audio'> " \
+ " <payload-type id='103' name='ISAC' clockrate='16000'/> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " <content name='test video'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='video'> " \
+ " <payload-type id='99' name='H264-SVC'> " \
+ " <parameter name='height' value='200'/> " \
+ " <parameter name='width' value='320'/> " \
+ " <parameter name='framerate' value='30'/> " \
+ " </payload-type> " \
+ " <rtcp-mux/> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " </jingle> " \
+ "</iq> ");
+
+// Initiate string with a combination of supported and unsupported codecs
+// Should accept the supported ones
+const std::string kGingleInitiateSomeUnsupported(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <session xmlns='http://www.google.com/session' type='initiate'" \
+ " id='abcdef' initiator='me@domain.com/resource'> " \
+ " <description xmlns='http://www.google.com/session/phone'> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='103' name='ISAC' clockrate='16000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='97' name='ASDFDS' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='102' name='1010' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='107' name='DFAS' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='100' name='EG711U' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='101' name='EG711A' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='0' name='PCMU' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='110' name=':)' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='13' name='CN' /> " \
+ " </description> " \
+ " </session> " \
+ "</iq> ");
+
+const std::string kJingleInitiateSomeUnsupported(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' " \
+ " sid='abcdef' initiator='me@domain.com/resource'> " \
+ " <content name='test audio'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='audio'> " \
+ " <payload-type " \
+ " id='103' name='ISAC' clockrate='16000' /> " \
+ " <payload-type " \
+ " id='97' name='ASDFDS' /> " \
+ " <payload-type " \
+ " id='102' name='1010' /> " \
+ " <payload-type " \
+ " id='107' name='DFAS' /> " \
+ " <payload-type " \
+ " id='100' name='EG711U' /> " \
+ " <payload-type " \
+ " id='101' name='EG711A' /> " \
+ " <payload-type " \
+ " id='0' name='PCMU' /> " \
+ " <payload-type " \
+ " id='110' name=':)' /> " \
+ " <payload-type " \
+ " id='13' name='CN' /> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " </jingle> " \
+ "</iq> ");
+
+const std::string kGingleVideoInitiateWithBandwidth(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <session xmlns='http://www.google.com/session' type='initiate'" \
+ " id='abcdef' initiator='me@domain.com/resource'> " \
+ " <description xmlns='http://www.google.com/session/video'> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='103' name='ISAC' clockrate='16000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/video' " \
+ " id='99' name='H264-SVC' framerate='30' " \
+ " height='200' width='320'/> " \
+ " <bandwidth type='AS'>42</bandwidth> " \
+ " </description> " \
+ " </session> " \
+ "</iq> ");
+
+// Initiate string without any supported codecs. Should send a reject.
+const std::string kGingleInitiateNoSupportedAudioCodecs(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <session xmlns='http://www.google.com/session' type='initiate'" \
+ " id='abcdef' initiator='me@domain.com/resource'> " \
+ " <description xmlns='http://www.google.com/session/phone'> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='123' name='Supercodec6000' /> " \
+ " </description> " \
+ " </session> " \
+ "</iq> ");
+
+const std::string kJingleInitiateNoSupportedAudioCodecs(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' " \
+ " sid='abcdef' initiator='me@domain.com/resource'> " \
+ " <content name='test audio'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='audio'>" \
+ " <payload-type " \
+ " id='123' name='Supercodec6000' /> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " </jingle> " \
+ "</iq> ");
+
+// Initiate string without any codecs. Assumes ancient version of Cricket
+// and tries a session with ISAC and PCMU
+const std::string kGingleInitiateNoAudioCodecs(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <session xmlns='http://www.google.com/session' type='initiate'" \
+ " id='abcdef' initiator='me@domain.com/resource'> " \
+ " <description xmlns='http://www.google.com/session/phone'> " \
+ " </description> " \
+ " </session> " \
+ "</iq> ");
+
+const std::string kJingleInitiateNoAudioCodecs(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' " \
+ " sid='abcdef' initiator='me@domain.com/resource'> " \
+ " <content name='test audio'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='audio'>" \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " </jingle> " \
+ "</iq> ");
+
+// The codecs are supported, but not at the given clockrates. Should send
+// a reject.
+const std::string kGingleInitiateWrongClockrates(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <session xmlns='http://www.google.com/session' type='initiate'" \
+ " id='abcdef' initiator='me@domain.com/resource'> " \
+ " <description xmlns='http://www.google.com/session/phone'> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='103' name='ISAC' clockrate='8000'/> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='97' name='IPCMWB' clockrate='1337'/> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='102' name='iLBC' clockrate='1982' /> " \
+ " </description> " \
+ " </session> " \
+ "</iq> ");
+
+const std::string kJingleInitiateWrongClockrates(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' " \
+ " sid='abcdef' initiator='me@domain.com/resource'> " \
+ " <content name='test audio'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='audio'>" \
+ " <payload-type " \
+ " id='103' name='ISAC' clockrate='8000'/> " \
+ " <payload-type " \
+ " id='97' name='IPCMWB' clockrate='1337'/> " \
+ " <payload-type " \
+ " id='102' name='iLBC' clockrate='1982' /> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " </jingle> " \
+ "</iq> ");
+
+// The codecs are supported, but not with the given number of channels.
+// Should send a reject.
+const std::string kGingleInitiateWrongChannels(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <session xmlns='http://www.google.com/session' type='initiate'" \
+ " id='abcdef' initiator='me@domain.com/resource'> " \
+ " <description xmlns='http://www.google.com/session/phone'> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='103' name='ISAC' channels='2'/> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='97' name='IPCMWB' channels='3'/> " \
+ " </description> " \
+ " </session> " \
+ "</iq> ");
+
+const std::string kJingleInitiateWrongChannels(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <jingle xmlns='urn:xmpp:jingle:1' action='session-initiate'> " \
+ " <content name='test audio'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='audio'>" \
+ " <payload-type " \
+ " id='103' name='ISAC' channels='2'/> " \
+ " <payload-type " \
+ " id='97' name='IPCMWB' channels='3'/> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " </jingle> " \
+ "</iq> ");
+
+// Initiate with a dynamic codec not using GIPS default payload id. Should
+// accept with provided payload id.
+const std::string kGingleInitiateDynamicAudioCodecs(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <session xmlns='http://www.google.com/session' type='initiate'" \
+ " id='abcdef' initiator='me@domain.com/resource'> " \
+ " <description xmlns='http://www.google.com/session/phone'> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='123' name='speex' clockrate='16000'/> " \
+ " </description> " \
+ " </session> " \
+ "</iq> ");
+
+const std::string kJingleInitiateDynamicAudioCodecs(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' " \
+ " sid='abcdef' initiator='me@domain.com/resource'> " \
+ " <content name='test audio'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='audio'>" \
+ " <payload-type " \
+ " id='123' name='speex' clockrate='16000'/> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " </jingle> " \
+ "</iq> ");
+
+// Initiate string with nothing but static codec id's. Should accept.
+const std::string kGingleInitiateStaticAudioCodecs(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <session xmlns='http://www.google.com/session' type='initiate'" \
+ " id='abcdef' initiator='me@domain.com/resource'> " \
+ " <description xmlns='http://www.google.com/session/phone'> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='3' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='0' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='8' /> " \
+ " </description> " \
+ " </session> " \
+ "</iq> ");
+
+const std::string kJingleInitiateStaticAudioCodecs(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' " \
+ " sid='abcdef' initiator='me@domain.com/resource'> " \
+ " <content name='test audio'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='audio'>" \
+ " <payload-type id='3' /> " \
+ " <payload-type id='0' /> " \
+ " <payload-type id='8' /> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " </jingle> " \
+ "</iq> ");
+
+// Initiate with payload type-less codecs. Should reject.
+const std::string kGingleInitiateNoPayloadTypes(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <session xmlns='http://www.google.com/session' type='initiate'" \
+ " id='abcdef' initiator='me@domain.com/resource'> " \
+ " <description xmlns='http://www.google.com/session/phone'> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " name='ISAC' clockrate='16000'/> " \
+ " </description> " \
+ " </session> " \
+ "</iq> ");
+
+const std::string kJingleInitiateNoPayloadTypes(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <jingle xmlns='urn:xmpp:jingle:1' action='session-initiate'> " \
+ " sid='abcdef' initiator='me@domain.com/resource'> " \
+ " <content name='test audio'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='audio'>" \
+ " <payload-type name='ISAC' clockrate='16000'/> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " </jingle> " \
+ "</iq> ");
+
+// Initiate with unnamed dynamic codces. Should reject.
+const std::string kGingleInitiateDynamicWithoutNames(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <session xmlns='http://www.google.com/session' type='initiate'" \
+ " id='abcdef' initiator='me@domain.com/resource'> " \
+ " <description xmlns='http://www.google.com/session/phone'> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='100' clockrate='16000'/> " \
+ " </description> " \
+ " </session> " \
+ "</iq> ");
+
+const std::string kJingleInitiateDynamicWithoutNames(
+ "<iq xmlns='jabber:client' from='me@domain.com/resource' " \
+ " to='user@domain.com/resource' type='set' id='123'> " \
+ " <jingle xmlns='urn:xmpp:jingle:1' action='session-initiate'> " \
+ " sid='abcdef' initiator='me@domain.com/resource'> " \
+ " <content name='test audio'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' media='audio'>" \
+ " <payload-type id='100' clockrate='16000'/> " \
+ " </description> " \
+ " <transport xmlns=\"http://www.google.com/transport/p2p\"/> " \
+ " </content> " \
+ " </jingle> " \
+ "</iq> ");
+
+const uint32 kAudioSsrc = 4294967295U;
+const uint32 kVideoSsrc = 87654321;
+// Note that this message does not specify a session ID. It must be populated
+// before use.
+const std::string kGingleAcceptWithSsrcs(
+ "<iq xmlns='jabber:client' from='me@mydomain.com' " \
+ " to='user@domain.com/resource' type='set' id='150'> " \
+ " <session xmlns='http://www.google.com/session' type='accept' " \
+ " initiator='me@domain.com/resource'> " \
+ " <description xmlns='http://www.google.com/session/video'> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='103' name='ISAC' clockrate='16000' /> " \
+ " <payload-type xmlns='http://www.google.com/session/phone' " \
+ " id='104' name='ISAC' clockrate='32000' /> " \
+ " <src-id xmlns='http://www.google.com/session/phone'> " \
+ " 4294967295</src-id> " \
+ " <src-id>87654321</src-id> " \
+ " </description> " \
+ " </session> " \
+ "</iq> ");
+
+const std::string kJingleAcceptWithSsrcs(
+ "<iq xmlns='jabber:client' from='me@mydomain.com' " \
+ " to='user@domain.com/resource' type='set' id='150'> " \
+ " <jingle xmlns='urn:xmpp:jingle:1' action='session-accept' " \
+ " initiator='me@domain.com/resource'> " \
+ " <content name='audio'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' " \
+ " media='audio' ssrc='4294967295'> " \
+ " <payload-type id='103' name='ISAC' clockrate='16000'/> " \
+ " <payload-type id='104' name='ISAC' clockrate='32000'/> " \
+ " </description> " \
+ " <transport xmlns='http://www.google.com/transport/p2p'/> " \
+ " </content> " \
+ " <content name='video'> " \
+ " <description xmlns='urn:xmpp:jingle:apps:rtp:1' " \
+ " media='video' ssrc='87654321'> " \
+ " </description> " \
+ " <transport xmlns='http://www.google.com/transport/p2p'/> " \
+ " </content> " \
+ " </jingle> " \
+ "</iq> ");
+
+std::string JingleView(const std::string& ssrc,
+ const std::string& width,
+ const std::string& height,
+ const std::string& framerate) {
+ // We have some slightly weird whitespace formatting to make the
+ // actual XML generated match the expected XML here.
+ return \
+ "<cli:iq"
+ " to='me@mydomain.com'"
+ " type='set'"
+ " xmlns:cli='jabber:client'>"
+ "<jingle"
+ " xmlns='urn:xmpp:jingle:1'"
+ " action='session-info'"
+ " sid=''>"
+ "<view xmlns='google:jingle'"
+ " name='video'"
+ " type='static'"
+ " ssrc='" + ssrc + "'>"
+ "<params"
+ " width='" + width + "'"
+ " height='" + height + "'"
+ " framerate='" + framerate + "'"
+ " preference='0'/>"
+ "</view>"
+ "</jingle>"
+ "</cli:iq>";
+}
+
+std::string JingleStreamAdd(const std::string& content_name,
+ const std::string& nick,
+ const std::string& name,
+ const std::string& ssrc) {
+ return \
+ "<iq"
+ " xmlns='jabber:client'"
+ " from='me@mydomain.com'"
+ " to='user@domain.com/resource'"
+ " type='set'"
+ " id='150'>"
+ " <jingle"
+ " xmlns='urn:xmpp:jingle:1'"
+ " action='description-info'>"
+ " <content"
+ " xmlns='urn:xmpp:jingle:1'"
+ " name='" + content_name + "'>"
+ " <description"
+ " xmlns='urn:xmpp:jingle:apps:rtp:1'"
+ " media='" + content_name + "'>"
+ " <streams"
+ " xmlns='google:jingle'>"
+ " <stream"
+ " nick='" + nick + "'"
+ " name='" + name + "'>"
+ " <ssrc>" + ssrc + "</ssrc>"
+ " </stream>"
+ " </streams>"
+ " </description>"
+ " </content>"
+ " </jingle>"
+ "</iq>";
+}
+
+std::string JingleStreamAddWithoutSsrc(const std::string& content_name,
+ const std::string& nick,
+ const std::string& name) {
+ return \
+ "<iq"
+ " xmlns='jabber:client'"
+ " from='me@mydomain.com'"
+ " to='user@domain.com/resource'"
+ " type='set'"
+ " id='150'>"
+ " <jingle"
+ " xmlns='urn:xmpp:jingle:1'"
+ " action='description-info'>"
+ " <content"
+ " xmlns='urn:xmpp:jingle:1'"
+ " name='" + content_name + "'>"
+ " <description"
+ " xmlns='urn:xmpp:jingle:apps:rtp:1'"
+ " media='" + content_name + "'>"
+ " <streams"
+ " xmlns='google:jingle'>"
+ " <stream"
+ " nick='" + nick + "'"
+ " name='" + name + "'>"
+ " </stream>"
+ " </streams>"
+ " </description>"
+ " </content>"
+ " </jingle>"
+ "</iq>";
+}
+
+std::string JingleStreamRemove(const std::string& content_name,
+ const std::string& nick,
+ const std::string& name) {
+ return \
+ "<iq"
+ " xmlns='jabber:client'"
+ " from='me@mydomain.com'"
+ " to='user@domain.com/resource'"
+ " type='set'"
+ " id='150'>"
+ " <jingle"
+ " xmlns='urn:xmpp:jingle:1'"
+ " action='description-info'>"
+ " <content"
+ " xmlns='urn:xmpp:jingle:1'"
+ " name='" + content_name + "'>"
+ " <description"
+ " xmlns='urn:xmpp:jingle:apps:rtp:1'"
+ " media='" + content_name + "'>"
+ " <streams"
+ " xmlns='google:jingle'>"
+ " <stream"
+ " nick='" + nick + "'"
+ " name='" + name + "'/>"
+ " </streams>"
+ " </description>"
+ " </content>"
+ " </jingle>"
+ "</iq>";
+}
+
+buzz::XmlElement* CopyElement(const buzz::XmlElement* elem) {
+ return new buzz::XmlElement(*elem);
+}
+
+static std::string AddEncryption(std::string stanza, std::string encryption) {
+ std::string::size_type pos = stanza.find("</description>");
+ while (pos != std::string::npos) {
+ stanza = stanza.insert(pos, encryption);
+ pos = stanza.find("</description>", pos + encryption.length() + 1);
+ }
+ return stanza;
+}
+
+
+int IntFromJingleCodecParameter(const buzz::XmlElement* parameter,
+ const std::string& expected_name) {
+ if (parameter) {
+ const std::string& actual_name =
+ parameter->Attr(cricket::QN_PAYLOADTYPE_PARAMETER_NAME);
+
+ EXPECT_EQ(expected_name, actual_name)
+ << "wrong parameter name. Expected '"
+ << expected_name << "'. Actually '"
+ << actual_name << "'.";
+
+ return atoi(parameter->Attr(
+ cricket::QN_PAYLOADTYPE_PARAMETER_VALUE).c_str());
+ }
+ return 0;
+}
+
+// Parses and extracts payload and codec info from test XML. Since
+// that XML will be in various contents (Gingle and Jingle), we need an
+// abstract parser with one concrete implementation per XML content.
+class MediaSessionTestParser {
+ public:
+ virtual buzz::XmlElement* ActionFromStanza(buzz::XmlElement* stanza) = 0;
+ virtual buzz::XmlElement* ContentFromAction(buzz::XmlElement* action) = 0;
+ virtual buzz::XmlElement* NextContent(buzz::XmlElement* content) = 0;
+ virtual buzz::XmlElement* PayloadTypeFromContent(
+ buzz::XmlElement* content) = 0;
+ virtual buzz::XmlElement* NextFromPayloadType(
+ buzz::XmlElement* payload_type) = 0;
+ virtual cricket::AudioCodec AudioCodecFromPayloadType(
+ const buzz::XmlElement* payload_type) = 0;
+ virtual cricket::VideoCodec VideoCodecFromPayloadType(
+ const buzz::XmlElement* payload_type) = 0;
+ virtual buzz::XmlElement* EncryptionFromContent(
+ buzz::XmlElement* content) = 0;
+ virtual buzz::XmlElement* NextFromEncryption(
+ buzz::XmlElement* encryption) = 0;
+ virtual const buzz::XmlElement* BandwidthFromContent(
+ buzz::XmlElement* content) = 0;
+ virtual const buzz::XmlElement* RtcpMuxFromContent(
+ buzz::XmlElement* content) = 0;
+ virtual bool ActionIsTerminate(const buzz::XmlElement* action) = 0;
+ virtual ~MediaSessionTestParser() {}
+};
+
+class JingleSessionTestParser : public MediaSessionTestParser {
+ public:
+ JingleSessionTestParser() : action_(NULL) {}
+
+ ~JingleSessionTestParser() {
+ delete action_;
+ }
+
+ buzz::XmlElement* ActionFromStanza(buzz::XmlElement* stanza) {
+ return stanza->FirstNamed(cricket::QN_JINGLE);
+ }
+
+ buzz::XmlElement* ContentFromAction(buzz::XmlElement* action) {
+ // We need to be able to use multiple contents, but the action
+ // gets deleted before we can call NextContent, so we need to
+ // stash away a copy.
+ action_ = CopyElement(action);
+ return action_->FirstNamed(cricket::QN_JINGLE_CONTENT);
+ }
+
+ buzz::XmlElement* NextContent(buzz::XmlElement* content) {
+ // For some reason, content->NextNamed(cricket::QN_JINGLE_CONTENT)
+ // doesn't work.
+ return action_->FirstNamed(cricket::QN_JINGLE_CONTENT)
+ ->NextNamed(cricket::QN_JINGLE_CONTENT);
+ }
+
+ buzz::XmlElement* PayloadTypeFromContent(buzz::XmlElement* content) {
+ buzz::XmlElement* content_desc =
+ content->FirstNamed(cricket::QN_JINGLE_RTP_CONTENT);
+ if (!content_desc)
+ return NULL;
+
+ return content_desc->FirstNamed(cricket::QN_JINGLE_RTP_PAYLOADTYPE);
+ }
+
+ buzz::XmlElement* NextFromPayloadType(buzz::XmlElement* payload_type) {
+ return payload_type->NextNamed(cricket::QN_JINGLE_RTP_PAYLOADTYPE);
+ }
+
+ cricket::AudioCodec AudioCodecFromPayloadType(
+ const buzz::XmlElement* payload_type) {
+ int id = 0;
+ if (payload_type->HasAttr(cricket::QN_ID))
+ id = atoi(payload_type->Attr(cricket::QN_ID).c_str());
+
+ std::string name = "";
+ if (payload_type->HasAttr(cricket::QN_NAME))
+ name = payload_type->Attr(cricket::QN_NAME);
+
+ int clockrate = 0;
+ if (payload_type->HasAttr(cricket::QN_CLOCKRATE))
+ clockrate = atoi(payload_type->Attr(cricket::QN_CLOCKRATE).c_str());
+
+ int bitrate = IntFromJingleCodecParameter(
+ payload_type->FirstNamed(cricket::QN_PARAMETER), "bitrate");
+
+ int channels = 1;
+ if (payload_type->HasAttr(cricket::QN_CHANNELS))
+ channels = atoi(payload_type->Attr(
+ cricket::QN_CHANNELS).c_str());
+
+ return cricket::AudioCodec(id, name, clockrate, bitrate, channels, 0);
+ }
+
+ cricket::VideoCodec VideoCodecFromPayloadType(
+ const buzz::XmlElement* payload_type) {
+ int id = 0;
+ if (payload_type->HasAttr(cricket::QN_ID))
+ id = atoi(payload_type->Attr(cricket::QN_ID).c_str());
+
+ std::string name = "";
+ if (payload_type->HasAttr(cricket::QN_NAME))
+ name = payload_type->Attr(cricket::QN_NAME);
+
+ int width = 0;
+ int height = 0;
+ int framerate = 0;
+ const buzz::XmlElement* param =
+ payload_type->FirstNamed(cricket::QN_PARAMETER);
+ if (param) {
+ width = IntFromJingleCodecParameter(param, "width");
+ param = param->NextNamed(cricket::QN_PARAMETER);
+ if (param) {
+ height = IntFromJingleCodecParameter(param, "height");
+ param = param->NextNamed(cricket::QN_PARAMETER);
+ if (param) {
+ framerate = IntFromJingleCodecParameter(param, "framerate");
+ }
+ }
+ }
+
+ return cricket::VideoCodec(id, name, width, height, framerate, 0);
+ }
+
+ bool ActionIsTerminate(const buzz::XmlElement* action) {
+ return (action->HasAttr(cricket::QN_ACTION) &&
+ action->Attr(cricket::QN_ACTION) == "session-terminate");
+ }
+
+ buzz::XmlElement* EncryptionFromContent(buzz::XmlElement* content) {
+ buzz::XmlElement* content_desc =
+ content->FirstNamed(cricket::QN_JINGLE_RTP_CONTENT);
+ if (!content_desc)
+ return NULL;
+
+ return content_desc->FirstNamed(cricket::QN_ENCRYPTION);
+ }
+
+ buzz::XmlElement* NextFromEncryption(buzz::XmlElement* encryption) {
+ return encryption->NextNamed(cricket::QN_ENCRYPTION);
+ }
+
+ const buzz::XmlElement* BandwidthFromContent(buzz::XmlElement* content) {
+ buzz::XmlElement* content_desc =
+ content->FirstNamed(cricket::QN_JINGLE_RTP_CONTENT);
+ if (!content_desc)
+ return NULL;
+
+ return content_desc->FirstNamed(cricket::QN_JINGLE_RTP_BANDWIDTH);
+ }
+
+ const buzz::XmlElement* RtcpMuxFromContent(buzz::XmlElement* content) {
+ return content->FirstNamed(cricket::QN_JINGLE_RTCP_MUX);
+ }
+
+ private:
+ buzz::XmlElement* action_;
+};
+
+class GingleSessionTestParser : public MediaSessionTestParser {
+ public:
+ GingleSessionTestParser() : found_content_count_(0) {}
+
+ buzz::XmlElement* ActionFromStanza(buzz::XmlElement* stanza) {
+ return stanza->FirstNamed(cricket::QN_GINGLE_SESSION);
+ }
+
+ buzz::XmlElement* ContentFromAction(buzz::XmlElement* session) {
+ buzz::XmlElement* content =
+ session->FirstNamed(cricket::QN_GINGLE_AUDIO_CONTENT);
+ if (content == NULL)
+ content = session->FirstNamed(cricket::QN_GINGLE_VIDEO_CONTENT);
+ return content;
+ }
+
+ // Assumes contents are in order of audio, and then video.
+ buzz::XmlElement* NextContent(buzz::XmlElement* content) {
+ found_content_count_++;
+ return content;
+ }
+
+ buzz::XmlElement* PayloadTypeFromContent(buzz::XmlElement* content) {
+ if (found_content_count_ > 0) {
+ return content->FirstNamed(cricket::QN_GINGLE_VIDEO_PAYLOADTYPE);
+ } else {
+ return content->FirstNamed(cricket::QN_GINGLE_AUDIO_PAYLOADTYPE);
+ }
+ }
+
+ buzz::XmlElement* NextFromPayloadType(buzz::XmlElement* payload_type) {
+ if (found_content_count_ > 0) {
+ return payload_type->NextNamed(cricket::QN_GINGLE_VIDEO_PAYLOADTYPE);
+ } else {
+ return payload_type->NextNamed(cricket::QN_GINGLE_AUDIO_PAYLOADTYPE);
+ }
+ }
+
+ cricket::AudioCodec AudioCodecFromPayloadType(
+ const buzz::XmlElement* payload_type) {
+ int id = 0;
+ if (payload_type->HasAttr(cricket::QN_ID))
+ id = atoi(payload_type->Attr(cricket::QN_ID).c_str());
+
+ std::string name;
+ if (payload_type->HasAttr(cricket::QN_NAME))
+ name = payload_type->Attr(cricket::QN_NAME);
+
+ int clockrate = 0;
+ if (payload_type->HasAttr(cricket::QN_CLOCKRATE))
+ clockrate = atoi(payload_type->Attr(cricket::QN_CLOCKRATE).c_str());
+
+ int bitrate = 0;
+ if (payload_type->HasAttr(cricket::QN_BITRATE))
+ bitrate = atoi(payload_type->Attr(cricket::QN_BITRATE).c_str());
+
+ int channels = 1;
+ if (payload_type->HasAttr(cricket::QN_CHANNELS))
+ channels = atoi(payload_type->Attr(cricket::QN_CHANNELS).c_str());
+
+ return cricket::AudioCodec(id, name, clockrate, bitrate, channels, 0);
+ }
+
+ cricket::VideoCodec VideoCodecFromPayloadType(
+ const buzz::XmlElement* payload_type) {
+ int id = 0;
+ if (payload_type->HasAttr(cricket::QN_ID))
+ id = atoi(payload_type->Attr(cricket::QN_ID).c_str());
+
+ std::string name;
+ if (payload_type->HasAttr(cricket::QN_NAME))
+ name = payload_type->Attr(cricket::QN_NAME);
+
+ int width = 0;
+ if (payload_type->HasAttr(cricket::QN_WIDTH))
+ width = atoi(payload_type->Attr(cricket::QN_WIDTH).c_str());
+
+ int height = 0;
+ if (payload_type->HasAttr(cricket::QN_HEIGHT))
+ height = atoi(payload_type->Attr(cricket::QN_HEIGHT).c_str());
+
+ int framerate = 1;
+ if (payload_type->HasAttr(cricket::QN_FRAMERATE))
+ framerate = atoi(payload_type->Attr(cricket::QN_FRAMERATE).c_str());
+
+ return cricket::VideoCodec(id, name, width, height, framerate, 0);
+ }
+
+ buzz::XmlElement* EncryptionFromContent(
+ buzz::XmlElement* content) {
+ return content->FirstNamed(cricket::QN_ENCRYPTION);
+ }
+
+ buzz::XmlElement* NextFromEncryption(buzz::XmlElement* encryption) {
+ return encryption->NextNamed(cricket::QN_ENCRYPTION);
+ }
+
+ const buzz::XmlElement* BandwidthFromContent(buzz::XmlElement* content) {
+ return content->FirstNamed(cricket::QN_GINGLE_VIDEO_BANDWIDTH);
+ }
+
+ const buzz::XmlElement* RtcpMuxFromContent(buzz::XmlElement* content) {
+ return NULL;
+ }
+
+ bool ActionIsTerminate(const buzz::XmlElement* session) {
+ return (session->HasAttr(buzz::QN_TYPE) &&
+ session->Attr(buzz::QN_TYPE) == "terminate");
+ }
+
+ int found_content_count_;
+};
+
+class MediaSessionClientTest : public sigslot::has_slots<> {
+ public:
+ explicit MediaSessionClientTest(MediaSessionTestParser* parser,
+ cricket::SignalingProtocol initial_protocol) {
+ nm_ = new talk_base::BasicNetworkManager();
+ pa_ = new cricket::BasicPortAllocator(nm_);
+ sm_ = new cricket::SessionManager(pa_, NULL);
+ fme_ = new cricket::FakeMediaEngine();
+
+ std::vector<cricket::AudioCodec>
+ audio_codecs(kAudioCodecs, kAudioCodecs + ARRAY_SIZE(kAudioCodecs));
+ fme_->SetAudioCodecs(audio_codecs);
+ std::vector<cricket::VideoCodec>
+ video_codecs(kVideoCodecs, kVideoCodecs + ARRAY_SIZE(kVideoCodecs));
+ fme_->SetVideoCodecs(video_codecs);
+
+ client_ = new cricket::MediaSessionClient(
+ buzz::Jid("user@domain.com/resource"), sm_,
+ fme_, new cricket::FakeDeviceManager());
+ client_->session_manager()->SignalOutgoingMessage.connect(
+ this, &MediaSessionClientTest::OnSendStanza);
+ client_->session_manager()->SignalSessionCreate.connect(
+ this, &MediaSessionClientTest::OnSessionCreate);
+ client_->SignalCallCreate.connect(
+ this, &MediaSessionClientTest::OnCallCreate);
+ client_->SignalCallDestroy.connect(
+ this, &MediaSessionClientTest::OnCallDestroy);
+
+ call_ = NULL;
+ parser_ = parser;
+ initial_protocol_ = initial_protocol;
+ expect_incoming_crypto_ = false;
+ expect_outgoing_crypto_ = false;
+ expected_video_bandwidth_ = cricket::kAutoBandwidth;
+ expected_video_rtcp_mux_ = false;
+ }
+
+ ~MediaSessionClientTest() {
+ delete client_;
+ delete sm_;
+ delete pa_;
+ delete nm_;
+ delete parser_;
+ }
+
+ buzz::XmlElement* ActionFromStanza(buzz::XmlElement* stanza) {
+ return parser_->ActionFromStanza(stanza);
+ }
+
+ buzz::XmlElement* ContentFromAction(buzz::XmlElement* action) {
+ return parser_->ContentFromAction(action);
+ }
+
+ buzz::XmlElement* PayloadTypeFromContent(buzz::XmlElement* payload) {
+ return parser_->PayloadTypeFromContent(payload);
+ }
+
+ buzz::XmlElement* NextFromPayloadType(buzz::XmlElement* payload_type) {
+ return parser_->NextFromPayloadType(payload_type);
+ }
+
+ buzz::XmlElement* EncryptionFromContent(buzz::XmlElement* content) {
+ return parser_->EncryptionFromContent(content);
+ }
+
+ buzz::XmlElement* NextFromEncryption(buzz::XmlElement* encryption) {
+ return parser_->NextFromEncryption(encryption);
+ }
+
+ cricket::AudioCodec AudioCodecFromPayloadType(
+ const buzz::XmlElement* payload_type) {
+ return parser_->AudioCodecFromPayloadType(payload_type);
+ }
+
+ const cricket::AudioContentDescription* GetFirstAudioContentDescription(
+ const cricket::SessionDescription* sdesc) {
+ const cricket::ContentInfo* content =
+ cricket::GetFirstAudioContent(sdesc);
+ if (content == NULL)
+ return NULL;
+ return static_cast<const cricket::AudioContentDescription*>(
+ content->description);
+ }
+
+ const cricket::VideoContentDescription* GetFirstVideoContentDescription(
+ const cricket::SessionDescription* sdesc) {
+ const cricket::ContentInfo* content =
+ cricket::GetFirstVideoContent(sdesc);
+ if (content == NULL)
+ return NULL;
+ return static_cast<const cricket::VideoContentDescription*>(
+ content->description);
+ }
+
+ void CheckCryptoFromGoodIncomingInitiate(const cricket::Session* session) {
+ ASSERT_TRUE(session != NULL);
+ const cricket::AudioContentDescription* content =
+ GetFirstAudioContentDescription(session->remote_description());
+ ASSERT_TRUE(content != NULL);
+ ASSERT_EQ(2U, content->cryptos().size());
+ ASSERT_EQ(145, content->cryptos()[0].tag);
+ ASSERT_EQ("AES_CM_128_HMAC_SHA1_32", content->cryptos()[0].cipher_suite);
+ ASSERT_EQ("inline:hsWuSQJxx7przmb8HM+ZkeNcG3HezSNID7LmfDa9",
+ content->cryptos()[0].key_params);
+ ASSERT_EQ(51, content->cryptos()[1].tag);
+ ASSERT_EQ("AES_CM_128_HMAC_SHA1_80", content->cryptos()[1].cipher_suite);
+ ASSERT_EQ("inline:J4lfdUL8W1F7TNJKcbuygaQuA429SJy2e9JctPUy",
+ content->cryptos()[1].key_params);
+ }
+
+ void CheckCryptoForGoodOutgoingAccept(const cricket::Session* session) {
+ const cricket::AudioContentDescription* content =
+ GetFirstAudioContentDescription(session->local_description());
+ ASSERT_EQ(1U, content->cryptos().size());
+ ASSERT_EQ(145, content->cryptos()[0].tag);
+ ASSERT_EQ("AES_CM_128_HMAC_SHA1_32", content->cryptos()[0].cipher_suite);
+ ASSERT_EQ(47U, content->cryptos()[0].key_params.size());
+ }
+
+ void CheckBadCryptoFromIncomingInitiate(const cricket::Session* session) {
+ const cricket::AudioContentDescription* content =
+ GetFirstAudioContentDescription(session->remote_description());
+ ASSERT_EQ(1U, content->cryptos().size());
+ ASSERT_EQ(145, content->cryptos()[0].tag);
+ ASSERT_EQ("NOT_SUPPORTED", content->cryptos()[0].cipher_suite);
+ ASSERT_EQ("inline:hsWuSQJxx7przmb8HM+ZkeNcG3HezSNID7LmfDa9",
+ content->cryptos()[0].key_params);
+ }
+
+ void CheckNoCryptoForOutgoingAccept(const cricket::Session* session) {
+ const cricket::AudioContentDescription* content =
+ GetFirstAudioContentDescription(session->local_description());
+ ASSERT_TRUE(content->cryptos().empty());
+ }
+
+ void CheckVideoBandwidth(int expected_bandwidth,
+ const cricket::SessionDescription* sdesc) {
+ const cricket::VideoContentDescription* video =
+ GetFirstVideoContentDescription(sdesc);
+ if (video != NULL) {
+ ASSERT_EQ(expected_bandwidth, video->bandwidth());
+ }
+ }
+
+ void CheckVideoRtcpMux(bool expected_video_rtcp_mux,
+ const cricket::SessionDescription* sdesc) {
+ const cricket::VideoContentDescription* video =
+ GetFirstVideoContentDescription(sdesc);
+ if (video != NULL) {
+ ASSERT_EQ(expected_video_rtcp_mux, video->rtcp_mux());
+ }
+ }
+
+ void CheckAudioSsrcForIncomingAccept(const cricket::Session* session) {
+ const cricket::AudioContentDescription* audio =
+ GetFirstAudioContentDescription(session->remote_description());
+ ASSERT_TRUE(audio != NULL);
+ ASSERT_EQ(kAudioSsrc, audio->first_ssrc());
+ }
+
+ void CheckVideoSsrcForIncomingAccept(const cricket::Session* session) {
+ const cricket::VideoContentDescription* video =
+ GetFirstVideoContentDescription(session->remote_description());
+ ASSERT_TRUE(video != NULL);
+ ASSERT_EQ(kVideoSsrc, video->first_ssrc());
+ }
+
+ void TestGoodIncomingInitiate(const std::string &initiate_string,
+ buzz::XmlElement** element) {
+ *element = NULL;
+
+ buzz::XmlElement* el = buzz::XmlElement::ForStr(initiate_string);
+ client_->session_manager()->OnIncomingMessage(el);
+ ASSERT_TRUE(call_ != NULL);
+ ASSERT_TRUE(call_->sessions()[0] != NULL);
+ ASSERT_EQ(cricket::Session::STATE_RECEIVEDINITIATE,
+ call_->sessions()[0]->state());
+ ASSERT_EQ(1U, stanzas_.size());
+ ASSERT_TRUE(buzz::QN_IQ == stanzas_[0]->Name());
+ ASSERT_TRUE(stanzas_[0]->HasAttr(buzz::QN_TYPE));
+ ASSERT_EQ(std::string(buzz::STR_RESULT), stanzas_[0]->Attr(buzz::QN_TYPE));
+ delete stanzas_[0];
+ stanzas_.clear();
+ CheckVideoBandwidth(expected_video_bandwidth_,
+ call_->sessions()[0]->remote_description());
+ CheckVideoRtcpMux(expected_video_rtcp_mux_,
+ call_->sessions()[0]->remote_description());
+ if (expect_incoming_crypto_) {
+ CheckCryptoFromGoodIncomingInitiate(call_->sessions()[0]);
+ }
+
+ // TODO: Add tests for sending <bandwidth> in accept.
+ cricket::CallOptions opts;
+ opts.has_video = (GetFirstVideoContentDescription(
+ call_->sessions()[0]->remote_description()) != NULL);
+ call_->AcceptSession(call_->sessions()[0], opts);
+ ASSERT_EQ(cricket::Session::STATE_SENTACCEPT,
+ call_->sessions()[0]->state());
+ ASSERT_EQ(1U, stanzas_.size());
+ ASSERT_TRUE(buzz::QN_IQ == stanzas_[0]->Name());
+ ASSERT_TRUE(stanzas_[0]->HasAttr(buzz::QN_TYPE));
+ ASSERT_EQ(std::string(buzz::STR_SET), stanzas_[0]->Attr(buzz::QN_TYPE));
+
+ buzz::XmlElement* e = ActionFromStanza(stanzas_[0]);
+ ASSERT_TRUE(e != NULL);
+ ASSERT_TRUE(ContentFromAction(e) != NULL);
+ *element = CopyElement(ContentFromAction(e));
+ ASSERT_TRUE(*element != NULL);
+ delete stanzas_[0];
+ stanzas_.clear();
+ if (expect_outgoing_crypto_) {
+ CheckCryptoForGoodOutgoingAccept(call_->sessions()[0]);
+ }
+
+ call_->Terminate();
+ ASSERT_EQ(cricket::Session::STATE_SENTTERMINATE,
+ call_->sessions()[0]->state());
+ ASSERT_EQ(1U, stanzas_.size());
+ ASSERT_TRUE(buzz::QN_IQ == stanzas_[0]->Name());
+ ASSERT_TRUE(stanzas_[0]->HasAttr(buzz::QN_TYPE));
+ ASSERT_EQ(std::string(buzz::STR_SET), stanzas_[0]->Attr(buzz::QN_TYPE));
+ e = ActionFromStanza(stanzas_[0]);
+ ASSERT_TRUE(e != NULL);
+ ASSERT_TRUE(parser_->ActionIsTerminate(e));
+ delete stanzas_[0];
+ stanzas_.clear();
+ }
+
+ void TestBadIncomingInitiate(const std::string& initiate_string) {
+ buzz::XmlElement* el = buzz::XmlElement::ForStr(initiate_string);
+ client_->session_manager()->OnIncomingMessage(el);
+ ASSERT_TRUE(call_ != NULL);
+ ASSERT_TRUE(call_->sessions()[0] != NULL);
+ ASSERT_EQ(cricket::Session::STATE_SENTREJECT,
+ call_->sessions()[0]->state());
+ ASSERT_EQ(2U, stanzas_.size());
+ ASSERT_TRUE(buzz::QN_IQ == stanzas_[0]->Name());
+ ASSERT_TRUE(stanzas_[1]->HasAttr(buzz::QN_TYPE));
+ ASSERT_EQ(std::string(buzz::STR_RESULT), stanzas_[1]->Attr(buzz::QN_TYPE));
+ delete stanzas_[0];
+ stanzas_.clear();
+ }
+
+ void TestGoodOutgoingInitiate() {
+ cricket::CallOptions options;
+ TestGoodOutgoingInitiate(options);
+ }
+
+ void TestGoodOutgoingInitiate(const cricket::CallOptions& options) {
+ client_->CreateCall();
+ ASSERT_TRUE(call_ != NULL);
+ call_->InitiateSession(buzz::Jid("me@mydomain.com"), options);
+ ASSERT_TRUE(call_->sessions()[0] != NULL);
+ ASSERT_EQ(cricket::Session::STATE_SENTINITIATE,
+ call_->sessions()[0]->state());
+ ASSERT_EQ(1U, stanzas_.size());
+ ASSERT_TRUE(buzz::QN_IQ == stanzas_[0]->Name());
+ ASSERT_TRUE(stanzas_[0]->HasAttr(buzz::QN_TYPE));
+ ASSERT_EQ(std::string(buzz::STR_SET), stanzas_[0]->Attr(buzz::QN_TYPE));
+ buzz::XmlElement* action = ActionFromStanza(stanzas_[0]);
+ ASSERT_TRUE(action != NULL);
+ buzz::XmlElement* content = ContentFromAction(action);
+ ASSERT_TRUE(content != NULL);
+
+ buzz::XmlElement* e = PayloadTypeFromContent(content);
+ ASSERT_TRUE(e != NULL);
+ cricket::AudioCodec codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(103, codec.id);
+ ASSERT_EQ("ISAC", codec.name);
+ ASSERT_EQ(16000, codec.clockrate);
+ ASSERT_EQ(0, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(104, codec.id);
+ ASSERT_EQ("ISAC", codec.name);
+ ASSERT_EQ(32000, codec.clockrate);
+ ASSERT_EQ(0, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(119, codec.id);
+ ASSERT_EQ("ISACLC", codec.name);
+ ASSERT_EQ(16000, codec.clockrate);
+ ASSERT_EQ(40000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(99, codec.id);
+ ASSERT_EQ("speex", codec.name);
+ ASSERT_EQ(16000, codec.clockrate);
+ ASSERT_EQ(22000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(97, codec.id);
+ ASSERT_EQ("IPCMWB", codec.name);
+ ASSERT_EQ(16000, codec.clockrate);
+ ASSERT_EQ(80000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(9, codec.id);
+ ASSERT_EQ("G722", codec.name);
+ ASSERT_EQ(16000, codec.clockrate);
+ ASSERT_EQ(64000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(102, codec.id);
+ ASSERT_EQ("iLBC", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(13300, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(98, codec.id);
+ ASSERT_EQ("speex", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(11000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(3, codec.id);
+ ASSERT_EQ("GSM", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(13000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(100, codec.id);
+ ASSERT_EQ("EG711U", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(64000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(101, codec.id);
+ ASSERT_EQ("EG711A", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(64000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(0, codec.id);
+ ASSERT_EQ("PCMU", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(64000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(8, codec.id);
+ ASSERT_EQ("PCMA", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(64000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(126, codec.id);
+ ASSERT_EQ("CN", codec.name);
+ ASSERT_EQ(32000, codec.clockrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(105, codec.id);
+ ASSERT_EQ("CN", codec.name);
+ ASSERT_EQ(16000, codec.clockrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(13, codec.id);
+ ASSERT_EQ("CN", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(117, codec.id);
+ ASSERT_EQ("red", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(106, codec.id);
+ ASSERT_EQ("telephone-event", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e == NULL);
+
+ if (expect_outgoing_crypto_) {
+ buzz::XmlElement* encryption = EncryptionFromContent(content);
+ ASSERT_TRUE(encryption != NULL);
+
+ if (client_->secure() == cricket::SEC_REQUIRED) {
+ ASSERT_TRUE(cricket::GetXmlAttr(
+ encryption, cricket::QN_ENCRYPTION_REQUIRED, false));
+ }
+
+ if (content->Name().Namespace() == cricket::NS_GINGLE_AUDIO) {
+ e = encryption->FirstNamed(cricket::QN_GINGLE_AUDIO_CRYPTO_USAGE);
+ ASSERT_TRUE(e != NULL);
+ ASSERT_TRUE(
+ e->NextNamed(cricket::QN_GINGLE_AUDIO_CRYPTO_USAGE) == NULL);
+ ASSERT_TRUE(
+ e->FirstNamed(cricket::QN_GINGLE_VIDEO_CRYPTO_USAGE) == NULL);
+ }
+
+ e = encryption->FirstNamed(cricket::QN_CRYPTO);
+ ASSERT_TRUE(e != NULL);
+ ASSERT_EQ("0", e->Attr(cricket::QN_CRYPTO_TAG));
+ ASSERT_EQ("AES_CM_128_HMAC_SHA1_32", e->Attr(cricket::QN_CRYPTO_SUITE));
+ std::string key_0 = e->Attr(cricket::QN_CRYPTO_KEY_PARAMS);
+ ASSERT_EQ(47U, key_0.length());
+ ASSERT_EQ("inline:", key_0.substr(0, 7));
+
+ e = e->NextNamed(cricket::QN_CRYPTO);
+ ASSERT_TRUE(e != NULL);
+ ASSERT_EQ("1", e->Attr(cricket::QN_CRYPTO_TAG));
+ ASSERT_EQ("AES_CM_128_HMAC_SHA1_80", e->Attr(cricket::QN_CRYPTO_SUITE));
+ std::string key_1 = e->Attr(cricket::QN_CRYPTO_KEY_PARAMS);
+ ASSERT_EQ(47U, key_1.length());
+ ASSERT_EQ("inline:", key_1.substr(0, 7));
+ ASSERT_NE(key_0, key_1);
+
+ encryption = NextFromEncryption(encryption);
+ ASSERT_TRUE(encryption == NULL);
+ }
+
+ if (options.has_video) {
+ CheckVideoBandwidth(options.video_bandwidth,
+ call_->sessions()[0]->local_description());
+ CheckVideoRtcpMux(expected_video_rtcp_mux_,
+ call_->sessions()[0]->remote_description());
+ content = parser_->NextContent(content);
+ const buzz::XmlElement* bandwidth =
+ parser_->BandwidthFromContent(content);
+ if (options.video_bandwidth == cricket::kAutoBandwidth) {
+ ASSERT_TRUE(bandwidth == NULL);
+ } else {
+ ASSERT_TRUE(bandwidth != NULL);
+ ASSERT_EQ("AS", bandwidth->Attr(buzz::QName("", "type")));
+ ASSERT_EQ(talk_base::ToString(options.video_bandwidth / 1000),
+ bandwidth->BodyText());
+ }
+ }
+
+ delete stanzas_[0];
+ stanzas_.clear();
+ }
+
+ void TestHasAllSupportedAudioCodecs(buzz::XmlElement* e) {
+ ASSERT_TRUE(e != NULL);
+
+ e = PayloadTypeFromContent(e);
+ ASSERT_TRUE(e != NULL);
+ cricket::AudioCodec codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(103, codec.id);
+ ASSERT_EQ("ISAC", codec.name);
+ ASSERT_EQ(16000, codec.clockrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(104, codec.id);
+ ASSERT_EQ("ISAC", codec.name);
+ ASSERT_EQ(32000, codec.clockrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(119, codec.id);
+ ASSERT_EQ("ISACLC", codec.name);
+ ASSERT_EQ(16000, codec.clockrate);
+ ASSERT_EQ(40000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(99, codec.id);
+ ASSERT_EQ("speex", codec.name);
+ ASSERT_EQ(16000, codec.clockrate);
+ ASSERT_EQ(22000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(97, codec.id);
+ ASSERT_EQ("IPCMWB", codec.name);
+ ASSERT_EQ(16000, codec.clockrate);
+ ASSERT_EQ(80000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(9, codec.id);
+ ASSERT_EQ("G722", codec.name);
+ ASSERT_EQ(16000, codec.clockrate);
+ ASSERT_EQ(64000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(102, codec.id);
+ ASSERT_EQ("iLBC", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(13300, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(98, codec.id);
+ ASSERT_EQ("speex", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(11000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(3, codec.id);
+ ASSERT_EQ("GSM", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(13000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(100, codec.id);
+ ASSERT_EQ("EG711U", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(64000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(101, codec.id);
+ ASSERT_EQ("EG711A", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(64000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(0, codec.id);
+ ASSERT_EQ("PCMU", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(64000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(8, codec.id);
+ ASSERT_EQ("PCMA", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(64000, codec.bitrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(126, codec.id);
+ ASSERT_EQ("CN", codec.name);
+ ASSERT_EQ(32000, codec.clockrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(105, codec.id);
+ ASSERT_EQ("CN", codec.name);
+ ASSERT_EQ(16000, codec.clockrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(13, codec.id);
+ ASSERT_EQ("CN", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(117, codec.id);
+ ASSERT_EQ("red", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(106, codec.id);
+ ASSERT_EQ("telephone-event", codec.name);
+ ASSERT_EQ(8000, codec.clockrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e == NULL);
+ }
+
+ void TestCodecsOfVideoInitiate(buzz::XmlElement* content) {
+ ASSERT_TRUE(content != NULL);
+ buzz::XmlElement* payload_type = PayloadTypeFromContent(content);
+ ASSERT_TRUE(payload_type != NULL);
+ cricket::AudioCodec codec = AudioCodecFromPayloadType(payload_type);
+ ASSERT_EQ(103, codec.id);
+ ASSERT_EQ("ISAC", codec.name);
+ ASSERT_EQ(16000, codec.clockrate);
+ ASSERT_EQ(1, codec.channels);
+
+ content = parser_->NextContent(content);
+ ASSERT_TRUE(content != NULL);
+ payload_type = PayloadTypeFromContent(content);
+ ASSERT_TRUE(payload_type != NULL);
+ cricket::VideoCodec vcodec =
+ parser_->VideoCodecFromPayloadType(payload_type);
+ ASSERT_EQ(99, vcodec.id);
+ ASSERT_EQ("H264-SVC", vcodec.name);
+ ASSERT_EQ(320, vcodec.width);
+ ASSERT_EQ(200, vcodec.height);
+ ASSERT_EQ(30, vcodec.framerate);
+ }
+
+ void TestHasAudioCodecsFromInitiateSomeUnsupported(buzz::XmlElement* e) {
+ ASSERT_TRUE(e != NULL);
+ e = PayloadTypeFromContent(e);
+ ASSERT_TRUE(e != NULL);
+
+ cricket::AudioCodec codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(103, codec.id);
+ ASSERT_EQ("ISAC", codec.name);
+ ASSERT_EQ(16000, codec.clockrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(100, codec.id);
+ ASSERT_EQ("EG711U", codec.name);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(101, codec.id);
+ ASSERT_EQ("EG711A", codec.name);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(0, codec.id);
+ ASSERT_EQ("PCMU", codec.name);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(13, codec.id);
+ ASSERT_EQ("CN", codec.name);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e == NULL);
+ }
+
+ void TestHasAudioCodecsFromInitiateDynamicAudioCodecs(
+ buzz::XmlElement* e) {
+ ASSERT_TRUE(e != NULL);
+ e = PayloadTypeFromContent(e);
+ ASSERT_TRUE(e != NULL);
+
+ cricket::AudioCodec codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(123, codec.id);
+ ASSERT_EQ(16000, codec.clockrate);
+ ASSERT_EQ(1, codec.channels);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e == NULL);
+ }
+
+ void TestHasDefaultAudioCodecs(buzz::XmlElement* e) {
+ ASSERT_TRUE(e != NULL);
+ e = PayloadTypeFromContent(e);
+ ASSERT_TRUE(e != NULL);
+
+ cricket::AudioCodec codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(103, codec.id);
+ ASSERT_EQ("ISAC", codec.name);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(0, codec.id);
+ ASSERT_EQ("PCMU", codec.name);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e == NULL);
+ }
+
+ void TestHasAudioCodecsFromInitiateStaticAudioCodecs(
+ buzz::XmlElement* e) {
+ ASSERT_TRUE(e != NULL);
+ e = PayloadTypeFromContent(e);
+ ASSERT_TRUE(e != NULL);
+
+ cricket::AudioCodec codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(3, codec.id);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(0, codec.id);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e != NULL);
+ codec = AudioCodecFromPayloadType(e);
+ ASSERT_EQ(8, codec.id);
+
+ e = NextFromPayloadType(e);
+ ASSERT_TRUE(e == NULL);
+ }
+
+ void TestGingleInitiateWithUnsupportedCrypto(
+ const std::string &initiate_string,
+ buzz::XmlElement** element) {
+ *element = NULL;
+
+ buzz::XmlElement* el = buzz::XmlElement::ForStr(initiate_string);
+ client_->session_manager()->OnIncomingMessage(el);
+
+ ASSERT_EQ(cricket::Session::STATE_RECEIVEDINITIATE,
+ call_->sessions()[0]->state());
+ delete stanzas_[0];
+ stanzas_.clear();
+ CheckBadCryptoFromIncomingInitiate(call_->sessions()[0]);
+
+ call_->AcceptSession(call_->sessions()[0], cricket::CallOptions());
+ delete stanzas_[0];
+ stanzas_.clear();
+ CheckNoCryptoForOutgoingAccept(call_->sessions()[0]);
+
+ call_->Terminate();
+ ASSERT_EQ(cricket::Session::STATE_SENTTERMINATE,
+ call_->sessions()[0]->state());
+ delete stanzas_[0];
+ stanzas_.clear();
+ }
+
+ void TestIncomingAcceptWithSsrcs(const std::string& accept_string) {
+ client_->CreateCall();
+ ASSERT_TRUE(call_ != NULL);
+
+ cricket::CallOptions options;
+ options.has_video = true;
+ options.is_muc = true;
+
+ call_->InitiateSession(buzz::Jid("me@mydomain.com"), options);
+ ASSERT_TRUE(call_->sessions()[0] != NULL);
+ ASSERT_EQ(cricket::Session::STATE_SENTINITIATE,
+ call_->sessions()[0]->state());
+ ASSERT_EQ(1U, stanzas_.size());
+ ASSERT_TRUE(buzz::QN_IQ == stanzas_[0]->Name());
+ ASSERT_TRUE(stanzas_[0]->HasAttr(buzz::QN_TYPE));
+ ASSERT_EQ(std::string(buzz::STR_SET), stanzas_[0]->Attr(buzz::QN_TYPE));
+ buzz::XmlElement* action = ActionFromStanza(stanzas_[0]);
+ ASSERT_TRUE(action != NULL);
+ buzz::XmlElement* content = ContentFromAction(action);
+ ASSERT_TRUE(content != NULL);
+ if (initial_protocol_ == cricket::PROTOCOL_JINGLE) {
+ buzz::XmlElement* content_desc =
+ content->FirstNamed(cricket::QN_JINGLE_RTP_CONTENT);
+ ASSERT_TRUE(content_desc != NULL);
+ ASSERT_EQ("", content_desc->Attr(cricket::QN_SSRC));
+ }
+ delete stanzas_[0];
+ stanzas_.clear();
+
+ // We need to insert the session ID into the session accept message.
+ buzz::XmlElement* el = buzz::XmlElement::ForStr(accept_string);
+ const std::string sid = call_->sessions()[0]->id();
+ if (initial_protocol_ == cricket::PROTOCOL_JINGLE) {
+ buzz::XmlElement* jingle = el->FirstNamed(cricket::QN_JINGLE);
+ jingle->SetAttr(cricket::QN_SID, sid);
+ } else {
+ buzz::XmlElement* session = el->FirstNamed(cricket::QN_GINGLE_SESSION);
+ session->SetAttr(cricket::QN_ID, sid);
+ }
+
+ client_->session_manager()->OnIncomingMessage(el);
+
+ ASSERT_EQ(cricket::Session::STATE_RECEIVEDACCEPT,
+ call_->sessions()[0]->state());
+ ASSERT_EQ(1U, stanzas_.size());
+ ASSERT_TRUE(buzz::QN_IQ == stanzas_[0]->Name());
+ ASSERT_TRUE(stanzas_[0]->HasAttr(buzz::QN_TYPE));
+ ASSERT_EQ(std::string(buzz::STR_RESULT), stanzas_[0]->Attr(buzz::QN_TYPE));
+ delete stanzas_[0];
+ stanzas_.clear();
+
+ CheckAudioSsrcForIncomingAccept(call_->sessions()[0]);
+ CheckVideoSsrcForIncomingAccept(call_->sessions()[0]);
+ }
+
+ size_t ClearStanzas() {
+ size_t size = stanzas_.size();
+ for (size_t i = 0; i < size; i++) {
+ delete stanzas_[i];
+ }
+ stanzas_.clear();
+ return size;
+ }
+
+ void SetJingleSid(buzz::XmlElement* stanza) {
+ buzz::XmlElement* jingle =
+ stanza->FirstNamed(cricket::QN_JINGLE);
+ jingle->SetAttr(cricket::QN_SID, call_->sessions()[0]->id());
+ }
+
+ void TestStreamsUpdateAndViewRequests() {
+ cricket::CallOptions options;
+ options.has_video = true;
+ options.is_muc = true;
+
+ client_->CreateCall();
+ call_->InitiateSession(buzz::Jid("me@mydomain.com"), options);
+ ASSERT_EQ(1U, ClearStanzas());
+ ASSERT_EQ(0U, last_streams_added_.audio().size());
+ ASSERT_EQ(0U, last_streams_added_.video().size());
+ ASSERT_EQ(0U, last_streams_removed_.audio().size());
+ ASSERT_EQ(0U, last_streams_removed_.video().size());
+
+ talk_base::scoped_ptr<buzz::XmlElement> accept_stanza(
+ buzz::XmlElement::ForStr(kJingleAcceptWithSsrcs));
+ SetJingleSid(accept_stanza.get());
+ client_->session_manager()->OnIncomingMessage(accept_stanza.get());
+ ASSERT_EQ(cricket::Session::STATE_RECEIVEDACCEPT,
+ call_->sessions()[0]->state());
+ ASSERT_EQ(1U, stanzas_.size());
+ ASSERT_EQ(std::string(buzz::STR_RESULT), stanzas_[0]->Attr(buzz::QN_TYPE));
+ ClearStanzas();
+ call_->sessions()[0]->SetState(cricket::Session::STATE_INPROGRESS);
+
+ talk_base::scoped_ptr<buzz::XmlElement> streams_stanza(
+ buzz::XmlElement::ForStr(
+ JingleStreamAdd("video", "Bob", "video1", "ABC")));
+ SetJingleSid(streams_stanza.get());
+ client_->session_manager()->OnIncomingMessage(streams_stanza.get());
+ // First one is ignored because of bad syntax.
+ ASSERT_EQ(1U, stanzas_.size());
+ // TODO: Figure out how to make this an ERROR rather than RESULT.
+ ASSERT_EQ(std::string(buzz::STR_ERROR), stanzas_[0]->Attr(buzz::QN_TYPE));
+ ClearStanzas();
+ ASSERT_EQ(0U, last_streams_added_.audio().size());
+ ASSERT_EQ(0U, last_streams_added_.video().size());
+ ASSERT_EQ(0U, last_streams_removed_.audio().size());
+ ASSERT_EQ(0U, last_streams_removed_.video().size());
+
+ streams_stanza.reset(buzz::XmlElement::ForStr(
+ JingleStreamAdd("audio", "Bob", "audio1", "1234")));
+ SetJingleSid(streams_stanza.get());
+ client_->session_manager()->OnIncomingMessage(streams_stanza.get());
+ ASSERT_EQ(1U, last_streams_added_.audio().size());
+ ASSERT_EQ("Bob", last_streams_added_.audio()[0].nick);
+ ASSERT_EQ(1U, last_streams_added_.audio()[0].ssrcs.size());
+ ASSERT_EQ(1234U, last_streams_added_.audio()[0].first_ssrc());
+
+ // Ignores adds without ssrcs.
+ streams_stanza.reset(buzz::XmlElement::ForStr(
+ JingleStreamAddWithoutSsrc("audio", "Bob", "audioX")));
+ SetJingleSid(streams_stanza.get());
+ client_->session_manager()->OnIncomingMessage(streams_stanza.get());
+ ASSERT_EQ(1U, last_streams_added_.audio().size());
+ ASSERT_EQ(1234U, last_streams_added_.audio()[0].first_ssrc());
+
+ // Ignores stream updates with unknown content names. (Don't terminate).
+ streams_stanza.reset(buzz::XmlElement::ForStr(
+ JingleStreamAddWithoutSsrc("foo", "Bob", "foo")));
+ SetJingleSid(streams_stanza.get());
+ client_->session_manager()->OnIncomingMessage(streams_stanza.get());
+
+ streams_stanza.reset(buzz::XmlElement::ForStr(
+ JingleStreamAdd("audio", "Joe", "audio1", "2468")));
+ SetJingleSid(streams_stanza.get());
+ client_->session_manager()->OnIncomingMessage(streams_stanza.get());
+ ASSERT_EQ(1U, last_streams_added_.audio().size());
+ ASSERT_EQ("Joe", last_streams_added_.audio()[0].nick);
+ ASSERT_EQ(1U, last_streams_added_.audio()[0].ssrcs.size());
+ ASSERT_EQ(2468U, last_streams_added_.audio()[0].first_ssrc());
+
+ streams_stanza.reset(buzz::XmlElement::ForStr(
+ JingleStreamAdd("video", "Bob", "video1", "5678")));
+ SetJingleSid(streams_stanza.get());
+ client_->session_manager()->OnIncomingMessage(streams_stanza.get());
+ ASSERT_EQ(1U, last_streams_added_.video().size());
+ ASSERT_EQ("Bob", last_streams_added_.video()[0].nick);
+ ASSERT_EQ(1U, last_streams_added_.video()[0].ssrcs.size());
+ ASSERT_EQ(5678U, last_streams_added_.video()[0].first_ssrc());
+
+ // We're testing that a "duplicate" is effectively ignored.
+ last_streams_added_.mutable_video()->clear();
+ last_streams_removed_.mutable_video()->clear();
+ streams_stanza.reset(buzz::XmlElement::ForStr(
+ JingleStreamAdd("video", "Bob", "video1", "5678")));
+ SetJingleSid(streams_stanza.get());
+ client_->session_manager()->OnIncomingMessage(streams_stanza.get());
+ ASSERT_EQ(0U, last_streams_added_.video().size());
+ ASSERT_EQ(0U, last_streams_removed_.video().size());
+
+ streams_stanza.reset(buzz::XmlElement::ForStr(
+ JingleStreamAdd("video", "Bob", "video2", "5679")));
+ SetJingleSid(streams_stanza.get());
+ client_->session_manager()->OnIncomingMessage(streams_stanza.get());
+ ASSERT_EQ(1U, last_streams_added_.video().size());
+ ASSERT_EQ("Bob", last_streams_added_.video()[0].nick);
+ ASSERT_EQ(1U, last_streams_added_.video()[0].ssrcs.size());
+ ASSERT_EQ(5679U, last_streams_added_.video()[0].first_ssrc());
+
+ cricket::FakeVoiceMediaChannel* voice_channel = fme_->GetVoiceChannel(0);
+ ASSERT_TRUE(voice_channel != NULL);
+ ASSERT_TRUE(voice_channel->HasRecvStream(1234U));
+ ASSERT_TRUE(voice_channel->HasRecvStream(2468U));
+ cricket::FakeVideoMediaChannel* video_channel = fme_->GetVideoChannel(0);
+ ASSERT_TRUE(video_channel != NULL);
+ ASSERT_TRUE(video_channel->HasRecvStream(5678U));
+ ClearStanzas();
+
+ cricket::ViewRequest viewRequest;
+ cricket::StaticVideoView staticVideoView(5678U, 640, 480, 30);
+ viewRequest.static_video_views.push_back(staticVideoView);
+ talk_base::scoped_ptr<buzz::XmlElement> expected_view_elem(
+ buzz::XmlElement::ForStr(JingleView("5678", "640", "480", "30")));
+ SetJingleSid(expected_view_elem.get());
+
+ ASSERT_TRUE(
+ call_->SendViewRequest(call_->sessions()[0], viewRequest));
+ ASSERT_EQ(1U, stanzas_.size());
+ ASSERT_EQ(expected_view_elem->Str(), stanzas_[0]->Str());
+ ClearStanzas();
+
+ streams_stanza.reset(buzz::XmlElement::ForStr(
+ JingleStreamRemove("audio", "Bob", "audio1")));
+ SetJingleSid(streams_stanza.get());
+ client_->session_manager()->OnIncomingMessage(streams_stanza.get());
+ ASSERT_EQ(1U, last_streams_removed_.audio().size());
+ ASSERT_EQ(1U, last_streams_removed_.audio()[0].ssrcs.size());
+ EXPECT_EQ(1234U, last_streams_removed_.audio()[0].first_ssrc());
+
+ streams_stanza.reset(buzz::XmlElement::ForStr(
+ JingleStreamRemove("video", "Bob", "video1")));
+ SetJingleSid(streams_stanza.get());
+ client_->session_manager()->OnIncomingMessage(streams_stanza.get());
+ ASSERT_EQ(1U, last_streams_removed_.video().size());
+ ASSERT_EQ(1U, last_streams_removed_.video()[0].ssrcs.size());
+ EXPECT_EQ(5678U, last_streams_removed_.video()[0].first_ssrc());
+
+ streams_stanza.reset(buzz::XmlElement::ForStr(
+ JingleStreamRemove("video", "Bob", "video2")));
+ SetJingleSid(streams_stanza.get());
+ client_->session_manager()->OnIncomingMessage(streams_stanza.get());
+ ASSERT_EQ(1U, last_streams_removed_.video().size());
+ ASSERT_EQ(1U, last_streams_removed_.video()[0].ssrcs.size());
+ EXPECT_EQ(5679U, last_streams_removed_.video()[0].first_ssrc());
+
+ // Duplicate removal: should be ignored.
+ last_streams_removed_.mutable_audio()->clear();
+ streams_stanza.reset(buzz::XmlElement::ForStr(
+ JingleStreamRemove("audio", "Bob", "audio1")));
+ SetJingleSid(streams_stanza.get());
+ client_->session_manager()->OnIncomingMessage(streams_stanza.get());
+ ASSERT_EQ(0U, last_streams_removed_.audio().size());
+
+ // Duplicate removal: should be ignored.
+ last_streams_removed_.mutable_video()->clear();
+ streams_stanza.reset(buzz::XmlElement::ForStr(
+ JingleStreamRemove("video", "Bob", "video1")));
+ SetJingleSid(streams_stanza.get());
+ client_->session_manager()->OnIncomingMessage(streams_stanza.get());
+ ASSERT_EQ(0U, last_streams_removed_.video().size());
+
+ voice_channel = fme_->GetVoiceChannel(0);
+ ASSERT_TRUE(voice_channel != NULL);
+ ASSERT_FALSE(voice_channel->HasRecvStream(1234U));
+ ASSERT_TRUE(voice_channel->HasRecvStream(2468U));
+ video_channel = fme_->GetVideoChannel(0);
+ ASSERT_TRUE(video_channel != NULL);
+ ASSERT_FALSE(video_channel->HasRecvStream(5678U));
+
+ // Fails because ssrc is now invalid.
+ ASSERT_FALSE(
+ call_->SendViewRequest(call_->sessions()[0], viewRequest));
+
+ ClearStanzas();
+ }
+
+ void MakeSignalingSecure(cricket::SecureMediaPolicy secure) {
+ client_->set_secure(secure);
+ }
+
+ void ExpectCrypto(cricket::SecureMediaPolicy secure) {
+ MakeSignalingSecure(secure);
+ expect_incoming_crypto_ = true;
+#ifdef HAVE_SRTP
+ expect_outgoing_crypto_ = true;
+#endif
+ }
+
+ void ExpectVideoBandwidth(int bandwidth) {
+ expected_video_bandwidth_ = bandwidth;
+ }
+
+ void ExpectVideoRtcpMux(bool rtcp_mux) {
+ expected_video_rtcp_mux_ = rtcp_mux;
+ }
+
+ private:
+ void OnSendStanza(cricket::SessionManager* manager,
+ const buzz::XmlElement* stanza) {
+ LOG(LS_INFO) << stanza->Str();
+ stanzas_.push_back(new buzz::XmlElement(*stanza));
+ }
+
+ void OnSessionCreate(cricket::Session* session, bool initiate) {
+ session->set_current_protocol(initial_protocol_);
+ }
+
+ void OnCallCreate(cricket::Call *call) {
+ call_ = call;
+ call->SignalMediaStreamsUpdate.connect(
+ this, &MediaSessionClientTest::OnMediaStreamsUpdate);
+ }
+
+ void OnCallDestroy(cricket::Call *call) {
+ call_ = NULL;
+ }
+
+ void OnMediaStreamsUpdate(cricket::Call *call,
+ cricket::Session *session,
+ const cricket::MediaStreams& added,
+ const cricket::MediaStreams& removed) {
+ last_streams_added_.CopyFrom(added);
+ last_streams_removed_.CopyFrom(removed);
+ }
+
+ talk_base::NetworkManager* nm_;
+ cricket::PortAllocator* pa_;
+ cricket::SessionManager* sm_;
+ cricket::FakeMediaEngine* fme_;
+ cricket::MediaSessionClient* client_;
+
+ cricket::Call* call_;
+ std::vector<buzz::XmlElement* > stanzas_;
+ MediaSessionTestParser* parser_;
+ cricket::SignalingProtocol initial_protocol_;
+ bool expect_incoming_crypto_;
+ bool expect_outgoing_crypto_;
+ int expected_video_bandwidth_;
+ bool expected_video_rtcp_mux_;
+ cricket::MediaStreams last_streams_added_;
+ cricket::MediaStreams last_streams_removed_;
+};
+
+MediaSessionClientTest* GingleTest() {
+ return new MediaSessionClientTest(new GingleSessionTestParser(),
+ cricket::PROTOCOL_GINGLE);
+}
+
+MediaSessionClientTest* JingleTest() {
+ return new MediaSessionClientTest(new JingleSessionTestParser(),
+ cricket::PROTOCOL_JINGLE);
+}
+
+TEST(MediaSessionTest, JingleGoodVideoInitiate) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ test->TestGoodIncomingInitiate(kJingleVideoInitiate, elem.use());
+ test->TestCodecsOfVideoInitiate(elem.get());
+}
+
+TEST(MediaSessionTest, JingleGoodVideoInitiateWithBandwidth) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ test->ExpectVideoBandwidth(42000);
+ test->TestGoodIncomingInitiate(kJingleVideoInitiateWithBandwidth, elem.use());
+}
+
+TEST(MediaSessionTest, JingleGoodVideoInitiateWithRtcpMux) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ test->ExpectVideoRtcpMux(true);
+ test->TestGoodIncomingInitiate(kJingleVideoInitiateWithRtcpMux, elem.use());
+}
+
+TEST(MediaSessionTest, JingleGoodInitiateAllSupportedAudioCodecs) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ test->TestGoodIncomingInitiate(kJingleInitiate, elem.use());
+ test->TestHasAllSupportedAudioCodecs(elem.get());
+}
+
+TEST(MediaSessionTest, JingleGoodInitiateDifferentPreferenceAudioCodecs) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ test->TestGoodIncomingInitiate(kJingleInitiateDifferentPreference,
+ elem.use());
+ test->TestHasAllSupportedAudioCodecs(elem.get());
+}
+
+TEST(MediaSessionTest, JingleGoodInitiateSomeUnsupportedAudioCodecs) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ test->TestGoodIncomingInitiate(kJingleInitiateSomeUnsupported, elem.use());
+ test->TestHasAudioCodecsFromInitiateSomeUnsupported(elem.get());
+}
+
+TEST(MediaSessionTest, JingleGoodInitiateDynamicAudioCodecs) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ test->TestGoodIncomingInitiate(kJingleInitiateDynamicAudioCodecs, elem.use());
+ test->TestHasAudioCodecsFromInitiateDynamicAudioCodecs(elem.get());
+}
+
+TEST(MediaSessionTest, JingleGoodInitiateStaticAudioCodecs) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ test->TestGoodIncomingInitiate(kJingleInitiateStaticAudioCodecs, elem.use());
+ test->TestHasAudioCodecsFromInitiateStaticAudioCodecs(elem.get());
+}
+
+TEST(MediaSessionTest, JingleBadInitiateNoAudioCodecs) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->TestBadIncomingInitiate(kJingleInitiateNoAudioCodecs);
+}
+
+TEST(MediaSessionTest, JingleBadInitiateNoSupportedAudioCodecs) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->TestBadIncomingInitiate(kJingleInitiateNoSupportedAudioCodecs);
+}
+
+TEST(MediaSessionTest, JingleBadInitiateWrongClockrates) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->TestBadIncomingInitiate(kJingleInitiateWrongClockrates);
+}
+
+TEST(MediaSessionTest, JingleBadInitiateWrongChannels) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->TestBadIncomingInitiate(kJingleInitiateWrongChannels);
+}
+
+TEST(MediaSessionTest, JingleBadInitiateNoPayloadTypes) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->TestBadIncomingInitiate(kJingleInitiateNoPayloadTypes);
+}
+
+TEST(MediaSessionTest, JingleBadInitiateDynamicWithoutNames) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->TestBadIncomingInitiate(kJingleInitiateDynamicWithoutNames);
+}
+
+TEST(MediaSessionTest, JingleGoodOutgoingInitiate) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->TestGoodOutgoingInitiate();
+}
+
+TEST(MediaSessionTest, JingleGoodOutgoingInitiateWithBandwidth) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ cricket::CallOptions options;
+ options.has_video = true;
+ options.video_bandwidth = 42000;
+ test->TestGoodOutgoingInitiate(options);
+}
+
+TEST(MediaSessionTest, JingleGoodOutgoingInitiateWithRtcpMux) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ cricket::CallOptions options;
+ options.has_video = true;
+ options.rtcp_mux_enabled = true;
+ test->TestGoodOutgoingInitiate(options);
+}
+
+// Crypto related tests.
+
+// Offer has crypto but the session is not secured, just ignore it.
+TEST(MediaSessionTest, JingleInitiateWithCryptoIsIgnoredWhenNotSecured) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ test->TestGoodIncomingInitiate(AddEncryption(kJingleVideoInitiate,
+ kJingleCryptoOffer), elem.use());
+}
+
+// Offer has crypto required but the session is not secure, fail.
+TEST(MediaSessionTest, JingleInitiateWithCryptoRequiredWhenNotSecured) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->TestBadIncomingInitiate(AddEncryption(kJingleVideoInitiate,
+ kJingleRequiredCryptoOffer));
+}
+
+// Offer has no crypto but the session is secure required, fail.
+TEST(MediaSessionTest, JingleInitiateWithNoCryptoFailsWhenSecureRequired) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->ExpectCrypto(cricket::SEC_REQUIRED);
+ test->TestBadIncomingInitiate(kJingleInitiate);
+}
+
+// Offer has crypto and session is secure, expect crypto in the answer.
+TEST(MediaSessionTest, JingleInitiateWithCryptoWhenSecureEnabled) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ test->ExpectCrypto(cricket::SEC_ENABLED);
+ test->TestGoodIncomingInitiate(AddEncryption(kJingleVideoInitiate,
+ kJingleCryptoOffer), elem.use());
+}
+
+// Offer has crypto and session is secure required, expect crypto in
+// the answer.
+TEST(MediaSessionTest, JingleInitiateWithCryptoWhenSecureRequired) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ test->ExpectCrypto(cricket::SEC_REQUIRED);
+ test->TestGoodIncomingInitiate(AddEncryption(kJingleVideoInitiate,
+ kJingleCryptoOffer), elem.use());
+}
+
+// Offer has unsupported crypto and session is secure, no crypto in
+// the answer.
+TEST(MediaSessionTest, JingleInitiateWithUnsupportedCrypto) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ test->MakeSignalingSecure(cricket::SEC_ENABLED);
+ test->TestGoodIncomingInitiate(
+ AddEncryption(kJingleInitiate, kJingleUnsupportedCryptoOffer),
+ elem.use());
+}
+
+// Offer has unsupported REQUIRED crypto and session is not secure, fail.
+TEST(MediaSessionTest, JingleInitiateWithRequiredUnsupportedCrypto) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->TestBadIncomingInitiate(
+ AddEncryption(kJingleInitiate, kJingleRequiredUnsupportedCryptoOffer));
+}
+
+// Offer has unsupported REQUIRED crypto and session is secure, fail.
+TEST(MediaSessionTest, JingleInitiateWithRequiredUnsupportedCryptoWhenSecure) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->MakeSignalingSecure(cricket::SEC_ENABLED);
+ test->TestBadIncomingInitiate(
+ AddEncryption(kJingleInitiate, kJingleRequiredUnsupportedCryptoOffer));
+}
+
+// Offer has unsupported REQUIRED crypto and session is required secure, fail.
+TEST(MediaSessionTest,
+ JingleInitiateWithRequiredUnsupportedCryptoWhenSecureRequired) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->MakeSignalingSecure(cricket::SEC_REQUIRED);
+ test->TestBadIncomingInitiate(
+ AddEncryption(kJingleInitiate, kJingleRequiredUnsupportedCryptoOffer));
+}
+
+
+TEST(MediaSessionTest, JingleGoodOutgoingInitiateWithCrypto) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->ExpectCrypto(cricket::SEC_ENABLED);
+ test->TestGoodOutgoingInitiate();
+}
+
+TEST(MediaSessionTest, JingleGoodOutgoingInitiateWithCryptoRequired) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->ExpectCrypto(cricket::SEC_REQUIRED);
+ test->TestGoodOutgoingInitiate();
+}
+
+TEST(MediaSessionTest, JingleIncomingAcceptWithSsrcs) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->TestIncomingAcceptWithSsrcs(kJingleAcceptWithSsrcs);
+}
+
+TEST(MediaSessionTest, JingleStreamsUpdateAndView) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+ test->TestStreamsUpdateAndViewRequests();
+}
+
+// Gingle tests
+
+TEST(MediaSessionTest, GingleGoodVideoInitiate) {
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestGoodIncomingInitiate(kGingleVideoInitiate, elem.use());
+ test->TestCodecsOfVideoInitiate(elem.get());
+}
+
+TEST(MediaSessionTest, GingleGoodVideoInitiateWithBandwidth) {
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->ExpectVideoBandwidth(42000);
+ test->TestGoodIncomingInitiate(kGingleVideoInitiateWithBandwidth, elem.use());
+}
+
+TEST(MediaSessionTest, GingleGoodInitiateAllSupportedAudioCodecs) {
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestGoodIncomingInitiate(kGingleInitiate, elem.use());
+ test->TestHasAllSupportedAudioCodecs(elem.get());
+}
+
+TEST(MediaSessionTest, GingleGoodInitiateAllSupportedAudioCodecsWithCrypto) {
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->ExpectCrypto(cricket::SEC_ENABLED);
+ test->TestGoodIncomingInitiate(AddEncryption(kGingleInitiate,
+ kGingleCryptoOffer), elem.use());
+ test->TestHasAllSupportedAudioCodecs(elem.get());
+}
+
+TEST(MediaSessionTest, GingleGoodInitiateDifferentPreferenceAudioCodecs) {
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestGoodIncomingInitiate(kGingleInitiateDifferentPreference,
+ elem.use());
+ test->TestHasAllSupportedAudioCodecs(elem.get());
+}
+
+TEST(MediaSessionTest, GingleGoodInitiateSomeUnsupportedAudioCodecs) {
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestGoodIncomingInitiate(kGingleInitiateSomeUnsupported, elem.use());
+ test->TestHasAudioCodecsFromInitiateSomeUnsupported(elem.get());
+}
+
+TEST(MediaSessionTest, GingleGoodInitiateDynamicAudioCodecs) {
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestGoodIncomingInitiate(kGingleInitiateDynamicAudioCodecs, elem.use());
+ test->TestHasAudioCodecsFromInitiateDynamicAudioCodecs(elem.get());
+}
+
+TEST(MediaSessionTest, GingleGoodInitiateStaticAudioCodecs) {
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestGoodIncomingInitiate(kGingleInitiateStaticAudioCodecs, elem.use());
+ test->TestHasAudioCodecsFromInitiateStaticAudioCodecs(elem.get());
+}
+
+TEST(MediaSessionTest, GingleGoodInitiateNoAudioCodecs) {
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestGoodIncomingInitiate(kGingleInitiateNoAudioCodecs, elem.use());
+ test->TestHasDefaultAudioCodecs(elem.get());
+}
+
+TEST(MediaSessionTest, GingleBadInitiateNoSupportedAudioCodecs) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestBadIncomingInitiate(kGingleInitiateNoSupportedAudioCodecs);
+}
+
+TEST(MediaSessionTest, GingleBadInitiateWrongClockrates) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestBadIncomingInitiate(kGingleInitiateWrongClockrates);
+}
+
+TEST(MediaSessionTest, GingleBadInitiateWrongChannels) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestBadIncomingInitiate(kGingleInitiateWrongChannels);
+}
+
+
+TEST(MediaSessionTest, GingleBadInitiateNoPayloadTypes) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestBadIncomingInitiate(kGingleInitiateNoPayloadTypes);
+}
+
+TEST(MediaSessionTest, GingleBadInitiateDynamicWithoutNames) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestBadIncomingInitiate(kGingleInitiateDynamicWithoutNames);
+}
+
+TEST(MediaSessionTest, GingleGoodOutgoingInitiate) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestGoodOutgoingInitiate();
+}
+
+TEST(MediaSessionTest, GingleGoodOutgoingInitiateWithBandwidth) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ cricket::CallOptions options;
+ options.has_video = true;
+ options.video_bandwidth = 42000;
+ test->TestGoodOutgoingInitiate(options);
+}
+
+// Crypto related tests.
+
+// Offer has crypto but the session is not secured, just ignore it.
+TEST(MediaSessionTest, GingleInitiateWithCryptoIsIgnoredWhenNotSecured) {
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestGoodIncomingInitiate(AddEncryption(kGingleInitiate,
+ kGingleCryptoOffer), elem.use());
+}
+
+// Offer has crypto required but the session is not secure, fail.
+TEST(MediaSessionTest, GingleInitiateWithCryptoRequiredWhenNotSecured) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestBadIncomingInitiate(AddEncryption(kGingleInitiate,
+ kGingleRequiredCryptoOffer));
+}
+
+// Offer has no crypto but the session is secure required, fail.
+TEST(MediaSessionTest, GingleInitiateWithNoCryptoFailsWhenSecureRequired) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->ExpectCrypto(cricket::SEC_REQUIRED);
+ test->TestBadIncomingInitiate(kGingleInitiate);
+}
+
+// Offer has crypto and session is secure, expect crypto in the answer.
+TEST(MediaSessionTest, GingleInitiateWithCryptoWhenSecureEnabled) {
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->ExpectCrypto(cricket::SEC_ENABLED);
+ test->TestGoodIncomingInitiate(AddEncryption(kGingleInitiate,
+ kGingleCryptoOffer), elem.use());
+}
+
+// Offer has crypto and session is secure required, expect crypto in
+// the answer.
+TEST(MediaSessionTest, GingleInitiateWithCryptoWhenSecureRequired) {
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->ExpectCrypto(cricket::SEC_REQUIRED);
+ test->TestGoodIncomingInitiate(AddEncryption(kGingleInitiate,
+ kGingleCryptoOffer), elem.use());
+}
+
+// Offer has unsupported crypto and session is secure, no crypto in
+// the answer.
+TEST(MediaSessionTest, GingleInitiateWithUnsupportedCrypto) {
+ talk_base::scoped_ptr<buzz::XmlElement> elem;
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->MakeSignalingSecure(cricket::SEC_ENABLED);
+ test->TestGoodIncomingInitiate(
+ AddEncryption(kGingleInitiate, kGingleUnsupportedCryptoOffer),
+ elem.use());
+}
+
+// Offer has unsupported REQUIRED crypto and session is not secure, fail.
+TEST(MediaSessionTest, GingleInitiateWithRequiredUnsupportedCrypto) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestBadIncomingInitiate(
+ AddEncryption(kGingleInitiate, kGingleRequiredUnsupportedCryptoOffer));
+}
+
+// Offer has unsupported REQUIRED crypto and session is secure, fail.
+TEST(MediaSessionTest, GingleInitiateWithRequiredUnsupportedCryptoWhenSecure) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->MakeSignalingSecure(cricket::SEC_ENABLED);
+ test->TestBadIncomingInitiate(
+ AddEncryption(kGingleInitiate, kGingleRequiredUnsupportedCryptoOffer));
+}
+
+// Offer has unsupported REQUIRED crypto and session is required secure, fail.
+TEST(MediaSessionTest,
+ GingleInitiateWithRequiredUnsupportedCryptoWhenSecureRequired) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->MakeSignalingSecure(cricket::SEC_REQUIRED);
+ test->TestBadIncomingInitiate(
+ AddEncryption(kGingleInitiate, kGingleRequiredUnsupportedCryptoOffer));
+}
+
+TEST(MediaSessionTest, GingleGoodOutgoingInitiateWithCrypto) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->ExpectCrypto(cricket::SEC_ENABLED);
+ test->TestGoodOutgoingInitiate();
+}
+
+TEST(MediaSessionTest, GingleGoodOutgoingInitiateWithCryptoRequired) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->ExpectCrypto(cricket::SEC_REQUIRED);
+ test->TestGoodOutgoingInitiate();
+}
+
+TEST(MediaSessionTest, GingleIncomingAcceptWithSsrcs) {
+ talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+ test->TestIncomingAcceptWithSsrcs(kGingleAcceptWithSsrcs);
+}
diff --git a/talk/session/phone/nullvideorenderer.h b/talk/session/phone/nullvideorenderer.h
new file mode 100644
index 0000000..aa48205
--- /dev/null
+++ b/talk/session/phone/nullvideorenderer.h
@@ -0,0 +1,48 @@
+/*
+ * libjingle
+ * Copyright 2004, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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_SESSION_PHONE_NULLVIDEORENDERER_H_
+#define TALK_SESSION_PHONE_NULLVIDEORENDERER_H_
+
+#include "talk/session/phone/videorenderer.h"
+
+namespace cricket {
+
+// Simple implementation for use in tests.
+class NullVideoRenderer : public VideoRenderer {
+ virtual bool SetSize(int width, int height, int reserved) {
+ return true;
+ }
+ // Called when a new frame is available for display.
+ virtual bool RenderFrame(const VideoFrame *frame) {
+ return true;
+ }
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_NULLVIDEORENDERER_H_
diff --git a/talk/session/phone/rtcpmuxfilter.cc b/talk/session/phone/rtcpmuxfilter.cc
index 8654214..1ca71e2 100644
--- a/talk/session/phone/rtcpmuxfilter.cc
+++ b/talk/session/phone/rtcpmuxfilter.cc
@@ -35,21 +35,22 @@
}
bool RtcpMuxFilter::IsActive() const {
- // We can receive muxed media prior to the accept, so we have to be able to
- // deal with that.
- return (state_ == ST_SENTOFFER || state_ == ST_ACTIVE);
+ return state_ == ST_ACTIVE;
}
bool RtcpMuxFilter::SetOffer(bool offer_enable, ContentSource source) {
- bool ret = false;
- if (state_ == ST_INIT) {
- offer_enable_ = offer_enable;
- state_ = (source == CS_LOCAL) ? ST_SENTOFFER : ST_RECEIVEDOFFER;
- ret = true;
- } else {
- LOG(LS_ERROR) << "Invalid state for RTCP mux offer";
+ // Allow to SetOffer in |state_| ST_INIT. Also allow to call SetOffer in
+ // |state_| ST_ACTIVE if |offer_enable| is true.
+ // We can't disable the filter once it has been activated.
+ if ((state_ != ST_INIT && state_ != ST_ACTIVE) ||
+ (state_ == ST_ACTIVE && offer_enable == false)) {
+ LOG(LS_ERROR) << "Invalid state for change of RTCP mux offer";
+ return false;
}
- return ret;
+
+ offer_enable_ = offer_enable;
+ state_ = (source == CS_LOCAL) ? ST_SENTOFFER : ST_RECEIVEDOFFER;
+ return true;
}
bool RtcpMuxFilter::SetAnswer(bool answer_enable, ContentSource source) {
@@ -68,6 +69,9 @@
LOG(LS_WARNING) << "Invalid parameters in RTCP mux answer";
}
}
+ } else if (state_ == ST_ACTIVE && answer_enable == offer_enable_) {
+ // It is ok as long as the answer state matches the current filter state.
+ ret = true;
} else {
LOG(LS_ERROR) << "Invalid state for RTCP mux answer";
}
@@ -81,7 +85,7 @@
// http://tools.ietf.org/html/rfc5761.
// Note that if we offer RTCP mux, we may receive muxed RTCP before we
// receive the answer, so we operate in that state too.
- if (!IsActive()) {
+ if (state_ != ST_SENTOFFER && state_ != ST_ACTIVE) {
return false;
}
diff --git a/talk/session/phone/rtcpmuxfilter_unittest.cc b/talk/session/phone/rtcpmuxfilter_unittest.cc
new file mode 100644
index 0000000..6a4c0e3
--- /dev/null
+++ b/talk/session/phone/rtcpmuxfilter_unittest.cc
@@ -0,0 +1,128 @@
+// 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/session/phone/rtcpmuxfilter.h"
+
+#include "talk/base/gunit.h"
+#include "talk/session/phone/testutils.h"
+
+TEST(RtcpMuxFilterTest, DemuxRtcpSender) {
+ cricket::RtcpMuxFilter filter;
+ const char data[] = { 0, 73, 0, 0 };
+ const int len = 4;
+
+ // Init state - refuse to demux
+ EXPECT_FALSE(filter.DemuxRtcp(data, len));
+ // After sent offer, demux should be enabled
+ filter.SetOffer(true, cricket::CS_LOCAL);
+ EXPECT_TRUE(filter.DemuxRtcp(data, len));
+ // Remote accepted, demux should be enabled
+ filter.SetAnswer(true, cricket::CS_REMOTE);
+ EXPECT_TRUE(filter.DemuxRtcp(data, len));
+}
+
+TEST(RtcpMuxFilterTest, DemuxRtcpReceiver) {
+ cricket::RtcpMuxFilter filter;
+ const char data[] = { 0, 73, 0, 0 };
+ const int len = 4;
+
+ // Init state - refuse to demux
+ EXPECT_FALSE(filter.DemuxRtcp(data, len));
+ // After received offer, demux should not be enabled
+ filter.SetOffer(true, cricket::CS_REMOTE);
+ EXPECT_FALSE(filter.DemuxRtcp(data, len));
+ // We accept, demux is now enabled.
+ filter.SetAnswer(true, cricket::CS_LOCAL);
+ EXPECT_TRUE(filter.DemuxRtcp(data, len));
+}
+
+TEST(RtcpMuxFilterTest, IsActiveSender) {
+ cricket::RtcpMuxFilter filter;
+ // Init state - not active.
+ EXPECT_FALSE(filter.IsActive());
+ // After sent offer, demux should not be active
+ filter.SetOffer(true, cricket::CS_LOCAL);
+ EXPECT_FALSE(filter.IsActive());
+ // Remote accepted, filter is now active
+ filter.SetAnswer(true, cricket::CS_REMOTE);
+ EXPECT_TRUE(filter.IsActive());
+}
+
+TEST(RtcpMuxFilterTest, IsActiveReceiver) {
+ cricket::RtcpMuxFilter filter;
+ // Init state - not active.
+ EXPECT_FALSE(filter.IsActive());
+ // After received offer, demux should not be active
+ filter.SetOffer(true, cricket::CS_REMOTE);
+ EXPECT_FALSE(filter.IsActive());
+ // We accept, filter is now active
+ filter.SetAnswer(true, cricket::CS_LOCAL);
+ EXPECT_TRUE(filter.IsActive());
+}
+
+// Test that we can enable the filter in an update.
+// We can not disable the filter later since that would mean we need to
+// recreate a rtcp transport channel.
+TEST(RtcpMuxFilterTest, EnableFilterDuringUpdate) {
+ cricket::RtcpMuxFilter filter;
+ EXPECT_FALSE(filter.IsActive());
+ EXPECT_TRUE(filter.SetOffer(false, cricket::CS_REMOTE));
+ EXPECT_TRUE(filter.SetAnswer(false, cricket::CS_LOCAL));
+ EXPECT_FALSE(filter.IsActive());
+
+ EXPECT_TRUE(filter.SetOffer(true, cricket::CS_REMOTE));
+ EXPECT_TRUE(filter.SetAnswer(true, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.IsActive());
+
+ EXPECT_FALSE(filter.SetOffer(false, cricket::CS_REMOTE));
+ EXPECT_FALSE(filter.SetAnswer(false, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.IsActive());
+}
+
+// Test that the filter can be enabled twice.
+TEST(RtcpMuxFilterTest, EnableFilterTwiceDuringUpdate) {
+ cricket::RtcpMuxFilter filter;
+
+ EXPECT_TRUE(filter.SetOffer(true, cricket::CS_REMOTE));
+ EXPECT_TRUE(filter.SetAnswer(true, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.IsActive());
+
+ EXPECT_TRUE(filter.SetOffer(true, cricket::CS_REMOTE));
+ EXPECT_TRUE(filter.SetAnswer(true, cricket::CS_LOCAL));
+ EXPECT_TRUE(filter.IsActive());
+}
+
+// Test that the filter can be kept disabled during updates.
+TEST(RtcpMuxFilterTest, KeepFilterDisabledDuringUpdate) {
+ cricket::RtcpMuxFilter filter;
+
+ EXPECT_TRUE(filter.SetOffer(false, cricket::CS_REMOTE));
+ EXPECT_TRUE(filter.SetAnswer(false, cricket::CS_LOCAL));
+ EXPECT_FALSE(filter.IsActive());
+
+ EXPECT_TRUE(filter.SetOffer(false, cricket::CS_REMOTE));
+ EXPECT_TRUE(filter.SetAnswer(false, cricket::CS_LOCAL));
+ EXPECT_FALSE(filter.IsActive());
+}
diff --git a/talk/session/phone/rtpdump.cc b/talk/session/phone/rtpdump.cc
index 50ebd2a..2db2990 100644
--- a/talk/session/phone/rtpdump.cc
+++ b/talk/session/phone/rtpdump.cc
@@ -33,7 +33,7 @@
#include "talk/base/byteorder.h"
#include "talk/base/logging.h"
-#include "talk/base/time.h"
+#include "talk/base/timeutils.h"
#include "talk/session/phone/rtputils.h"
namespace cricket {
diff --git a/talk/session/phone/rtpdump_unittest.cc b/talk/session/phone/rtpdump_unittest.cc
new file mode 100644
index 0000000..fc48858
--- /dev/null
+++ b/talk/session/phone/rtpdump_unittest.cc
@@ -0,0 +1,289 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, 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 "talk/base/bytebuffer.h"
+#include "talk/base/gunit.h"
+#include "talk/base/thread.h"
+#include "talk/session/phone/rtpdump.h"
+#include "talk/session/phone/rtputils.h"
+#include "talk/session/phone/testutils.h"
+
+namespace cricket {
+
+static const uint32 kTestSsrc = 1;
+
+// Test that we read the correct header fields from the RTP/RTCP packet.
+TEST(RtpDumpTest, ReadRtpDumpPacket) {
+ talk_base::ByteBuffer rtp_buf;
+ RtpTestUtility::kTestRawRtpPackets[0].WriteToByteBuffer(kTestSsrc, &rtp_buf);
+ RtpDumpPacket rtp_packet(rtp_buf.Data(), rtp_buf.Length(), 0, false);
+
+ int type;
+ int seq_num;
+ uint32 ts;
+ uint32 ssrc;
+ EXPECT_TRUE(rtp_packet.IsValidRtpPacket());
+ EXPECT_FALSE(rtp_packet.IsValidRtcpPacket());
+ EXPECT_TRUE(rtp_packet.GetRtpPayloadType(&type));
+ EXPECT_EQ(0, type);
+ EXPECT_TRUE(rtp_packet.GetRtpSeqNum(&seq_num));
+ EXPECT_EQ(0, seq_num);
+ EXPECT_TRUE(rtp_packet.GetRtpTimestamp(&ts));
+ EXPECT_EQ(0U, ts);
+ EXPECT_TRUE(rtp_packet.GetRtpSsrc(&ssrc));
+ EXPECT_EQ(kTestSsrc, ssrc);
+ EXPECT_FALSE(rtp_packet.GetRtcpType(&type));
+
+ talk_base::ByteBuffer rtcp_buf;
+ RtpTestUtility::kTestRawRtcpPackets[0].WriteToByteBuffer(&rtcp_buf);
+ RtpDumpPacket rtcp_packet(rtcp_buf.Data(), rtcp_buf.Length(), 0, true);
+
+ EXPECT_FALSE(rtcp_packet.IsValidRtpPacket());
+ EXPECT_TRUE(rtcp_packet.IsValidRtcpPacket());
+ EXPECT_TRUE(rtcp_packet.GetRtcpType(&type));
+ EXPECT_EQ(0, type);
+}
+
+// Test that we read only the RTP dump file.
+TEST(RtpDumpTest, ReadRtpDumpFile) {
+ RtpDumpPacket packet;
+ talk_base::MemoryStream stream;
+ RtpDumpWriter writer(&stream);
+ talk_base::scoped_ptr<RtpDumpReader> reader;
+
+ // Write a RTP packet to the stream, which is a valid RTP dump. Next, we will
+ // change the first line to make the RTP dump valid or invalid.
+ ASSERT_TRUE(RtpTestUtility::WriteTestPackets(1, false, kTestSsrc, &writer));
+ stream.Rewind();
+ reader.reset(new RtpDumpReader(&stream));
+ EXPECT_EQ(talk_base::SR_SUCCESS, reader->ReadPacket(&packet));
+
+ // The first line is correct.
+ stream.Rewind();
+ const char new_line[] = "#!rtpplay1.0 1.1.1.1/1\n";
+ EXPECT_EQ(talk_base::SR_SUCCESS,
+ stream.WriteAll(new_line, strlen(new_line), NULL, NULL));
+ stream.Rewind();
+ reader.reset(new RtpDumpReader(&stream));
+ EXPECT_EQ(talk_base::SR_SUCCESS, reader->ReadPacket(&packet));
+
+ // The first line is not correct: not started with #!rtpplay1.0.
+ stream.Rewind();
+ const char new_line2[] = "#!rtpplaz1.0 0.0.0.0/0\n";
+ EXPECT_EQ(talk_base::SR_SUCCESS,
+ stream.WriteAll(new_line2, strlen(new_line2), NULL, NULL));
+ stream.Rewind();
+ reader.reset(new RtpDumpReader(&stream));
+ EXPECT_EQ(talk_base::SR_ERROR, reader->ReadPacket(&packet));
+
+ // The first line is not correct: no port.
+ stream.Rewind();
+ const char new_line3[] = "#!rtpplay1.0 0.0.0.0//\n";
+ EXPECT_EQ(talk_base::SR_SUCCESS,
+ stream.WriteAll(new_line3, strlen(new_line3), NULL, NULL));
+ stream.Rewind();
+ reader.reset(new RtpDumpReader(&stream));
+ EXPECT_EQ(talk_base::SR_ERROR, reader->ReadPacket(&packet));
+}
+
+// Test that we read the same RTP packets that rtp dump writes.
+TEST(RtpDumpTest, WriteReadSameRtp) {
+ talk_base::MemoryStream stream;
+ RtpDumpWriter writer(&stream);
+ ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
+ RtpTestUtility::GetTestPacketCount(), false, kTestSsrc, &writer));
+ EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
+ RtpTestUtility::GetTestPacketCount(), &stream, kTestSsrc));
+
+ // Check stream has only RtpTestUtility::GetTestPacketCount() packets.
+ RtpDumpPacket packet;
+ RtpDumpReader reader(&stream);
+ for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
+ EXPECT_EQ(talk_base::SR_SUCCESS , reader.ReadPacket(&packet));
+ uint32 ssrc;
+ EXPECT_TRUE(GetRtpSsrc(&packet.data[0], packet.data.size(), &ssrc));
+ EXPECT_EQ(kTestSsrc, ssrc);
+ }
+ // No more packets to read.
+ EXPECT_EQ(talk_base::SR_EOS, reader.ReadPacket(&packet));
+
+ // Rewind the stream and read again with a specified ssrc.
+ stream.Rewind();
+ RtpDumpReader reader_w_ssrc(&stream);
+ const uint32 send_ssrc = kTestSsrc + 1;
+ reader_w_ssrc.SetSsrc(send_ssrc);
+ for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
+ EXPECT_EQ(talk_base::SR_SUCCESS , reader_w_ssrc.ReadPacket(&packet));
+ uint32 ssrc;
+ EXPECT_TRUE(GetRtpSsrc(&packet.data[0], packet.data.size(), &ssrc));
+ EXPECT_EQ(send_ssrc, ssrc);
+ }
+ // No more packets to read.
+ EXPECT_EQ(talk_base::SR_EOS, reader_w_ssrc.ReadPacket(&packet));
+}
+
+// Test that we read the same RTCP packets that rtp dump writes.
+TEST(RtpDumpTest, WriteReadSameRtcp) {
+ talk_base::MemoryStream stream;
+ RtpDumpWriter writer(&stream);
+ ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
+ RtpTestUtility::GetTestPacketCount(), true, kTestSsrc, &writer));
+ EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
+ RtpTestUtility::GetTestPacketCount(), &stream, kTestSsrc));
+
+ // Check stream has only RtpTestUtility::GetTestPacketCount() packets.
+ RtpDumpPacket packet;
+ RtpDumpReader reader(&stream);
+ reader.SetSsrc(kTestSsrc + 1); // Does not affect RTCP packet.
+ for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
+ EXPECT_EQ(talk_base::SR_SUCCESS , reader.ReadPacket(&packet));
+ }
+ // No more packets to read.
+ EXPECT_EQ(talk_base::SR_EOS, reader.ReadPacket(&packet));
+}
+
+// Test dumping only RTP packet headers.
+TEST(RtpDumpTest, WriteReadRtpHeadersOnly) {
+ talk_base::MemoryStream stream;
+ RtpDumpWriter writer(&stream);
+ writer.set_packet_filter(PF_RTPHEADER);
+
+ // Write some RTP and RTCP packets. RTP packets should only have headers;
+ // RTCP packets should be eaten.
+ ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
+ RtpTestUtility::GetTestPacketCount(), false, kTestSsrc, &writer));
+ ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
+ RtpTestUtility::GetTestPacketCount(), true, kTestSsrc, &writer));
+ stream.Rewind();
+
+ // Check that only RTP packet headers are present.
+ RtpDumpPacket packet;
+ RtpDumpReader reader(&stream);
+ for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
+ EXPECT_EQ(talk_base::SR_SUCCESS , reader.ReadPacket(&packet));
+ EXPECT_FALSE(packet.is_rtcp);
+ size_t len = 0;
+ packet.GetRtpHeaderLen(&len);
+ EXPECT_EQ(len, packet.data.size());
+ }
+ // No more packets to read.
+ EXPECT_EQ(talk_base::SR_EOS, reader.ReadPacket(&packet));
+}
+
+// Test dumping only RTCP packets.
+TEST(RtpDumpTest, WriteReadRtcpOnly) {
+ talk_base::MemoryStream stream;
+ RtpDumpWriter writer(&stream);
+ writer.set_packet_filter(PF_RTCPPACKET);
+
+ // Write some RTP and RTCP packets. RTP packets should be eaten.
+ ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
+ RtpTestUtility::GetTestPacketCount(), false, kTestSsrc, &writer));
+ ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
+ RtpTestUtility::GetTestPacketCount(), true, kTestSsrc, &writer));
+ stream.Rewind();
+
+ // Check that only RTCP packets are present.
+ RtpDumpPacket packet;
+ RtpDumpReader reader(&stream);
+ for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
+ EXPECT_EQ(talk_base::SR_SUCCESS , reader.ReadPacket(&packet));
+ EXPECT_TRUE(packet.is_rtcp);
+ }
+ // No more packets to read.
+ EXPECT_EQ(talk_base::SR_EOS, reader.ReadPacket(&packet));
+}
+
+// Test that RtpDumpLoopReader reads RTP packets continously and the elapsed
+// time, the sequence number, and timestamp are maintained properly.
+TEST(RtpDumpTest, LoopReadRtp) {
+ talk_base::MemoryStream stream;
+ RtpDumpWriter writer(&stream);
+ ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
+ RtpTestUtility::GetTestPacketCount(), false, kTestSsrc, &writer));
+ EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
+ 3 * RtpTestUtility::GetTestPacketCount(), &stream, kTestSsrc));
+}
+
+// Test that RtpDumpLoopReader reads RTCP packets continously and the elapsed
+// time is maintained properly.
+TEST(RtpDumpTest, LoopReadRtcp) {
+ talk_base::MemoryStream stream;
+ RtpDumpWriter writer(&stream);
+ ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
+ RtpTestUtility::GetTestPacketCount(), true, kTestSsrc, &writer));
+ EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
+ 3 * RtpTestUtility::GetTestPacketCount(), &stream, kTestSsrc));
+}
+
+// Test that RtpDumpLoopReader reads continously from stream with a single RTP
+// packets.
+TEST(RtpDumpTest, LoopReadSingleRtp) {
+ talk_base::MemoryStream stream;
+ RtpDumpWriter writer(&stream);
+ ASSERT_TRUE(RtpTestUtility::WriteTestPackets(1, false, kTestSsrc, &writer));
+
+ // The regular reader can read only one packet.
+ RtpDumpPacket packet;
+ stream.Rewind();
+ RtpDumpReader reader(&stream);
+ EXPECT_EQ(talk_base::SR_SUCCESS, reader.ReadPacket(&packet));
+ EXPECT_EQ(talk_base::SR_EOS, reader.ReadPacket(&packet));
+
+ // The loop reader reads three packets from the input stream.
+ stream.Rewind();
+ RtpDumpLoopReader loop_reader(&stream);
+ EXPECT_EQ(talk_base::SR_SUCCESS, loop_reader.ReadPacket(&packet));
+ EXPECT_EQ(talk_base::SR_SUCCESS, loop_reader.ReadPacket(&packet));
+ EXPECT_EQ(talk_base::SR_SUCCESS, loop_reader.ReadPacket(&packet));
+}
+
+// Test that RtpDumpLoopReader reads continously from stream with a single RTCP
+// packets.
+TEST(RtpDumpTest, LoopReadSingleRtcp) {
+ talk_base::MemoryStream stream;
+ RtpDumpWriter writer(&stream);
+ ASSERT_TRUE(RtpTestUtility::WriteTestPackets(1, true, kTestSsrc, &writer));
+
+ // The regular reader can read only one packet.
+ RtpDumpPacket packet;
+ stream.Rewind();
+ RtpDumpReader reader(&stream);
+ EXPECT_EQ(talk_base::SR_SUCCESS, reader.ReadPacket(&packet));
+ EXPECT_EQ(talk_base::SR_EOS, reader.ReadPacket(&packet));
+
+ // The loop reader reads three packets from the input stream.
+ stream.Rewind();
+ RtpDumpLoopReader loop_reader(&stream);
+ EXPECT_EQ(talk_base::SR_SUCCESS, loop_reader.ReadPacket(&packet));
+ EXPECT_EQ(talk_base::SR_SUCCESS, loop_reader.ReadPacket(&packet));
+ EXPECT_EQ(talk_base::SR_SUCCESS, loop_reader.ReadPacket(&packet));
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/rtputils.cc b/talk/session/phone/rtputils.cc
index e37c390..ded84a5 100644
--- a/talk/session/phone/rtputils.cc
+++ b/talk/session/phone/rtputils.cc
@@ -77,5 +77,18 @@
return true;
}
-} // namespace cricket
+// This method returns SSRC first of RTCP packet, except if packet is SDES.
+// TODO - Fully implement RFC 5506. This standard doesn't restrict
+// to send non-compound packets only to feedback messages.
+bool GetRtcpSsrc(const void* data, size_t len, uint32* value) {
+ // Packet should be at least of 8 bytes, to get SSRC from a RTCP packet.
+ if (!data || len < kMinRtcpPacketLen + 4 || !value) return false;
+ int pl_type;
+ if (!GetRtcpType(data, len, &pl_type)) return false;
+ // SDES packet parsing is not supported.
+ if (pl_type == kRtcpTypeSDES) return false;
+ *value = talk_base::GetBE32(static_cast<const uint8*>(data) + 4);
+ return true;
+}
+} // namespace cricket
diff --git a/talk/session/phone/rtputils.h b/talk/session/phone/rtputils.h
index 69daa83..bc2aaff 100644
--- a/talk/session/phone/rtputils.h
+++ b/talk/session/phone/rtputils.h
@@ -36,12 +36,23 @@
const size_t kMaxRtpPacketLen = 2048;
const size_t kMinRtcpPacketLen = 4;
+enum RtcpTypes {
+ kRtcpTypeSR = 200, // Sender report payload type.
+ kRtcpTypeRR = 201, // Receiver report payload type.
+ kRtcpTypeSDES = 202, // SDES payload type.
+ kRtcpTypeBye = 203, // BYE payload type.
+ kRtcpTypeApp = 204, // APP payload type.
+ kRtcpTypeRTPFB = 205, // Transport layer Feedback message payload type.
+ kRtcpTypePSFB = 206, // Payload-specific Feedback message payload type.
+};
+
bool GetRtpPayloadType(const void* data, size_t len, int* value);
bool GetRtpSeqNum(const void* data, size_t len, int* value);
bool GetRtpTimestamp(const void* data, size_t len, uint32* value);
bool GetRtpSsrc(const void* data, size_t len, uint32* value);
bool GetRtpHeaderLen(const void* data, size_t len, size_t* value);
bool GetRtcpType(const void* data, size_t len, int* value);
+bool GetRtcpSsrc(const void* data, size_t len, uint32* value);
} // namespace cricket
diff --git a/talk/session/phone/rtputils_unittest.cc b/talk/session/phone/rtputils_unittest.cc
new file mode 100644
index 0000000..b1efd0c
--- /dev/null
+++ b/talk/session/phone/rtputils_unittest.cc
@@ -0,0 +1,144 @@
+/*
+ * libjingle
+ * Copyright 2004--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/base/gunit.h"
+#include "talk/session/phone/fakertp.h"
+#include "talk/session/phone/rtputils.h"
+
+namespace cricket {
+
+static const unsigned char kRtpPacketWithMarker[] = {
+ 0x80, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
+};
+// 3 CSRCs (0x01020304, 0x12345678, 0xAABBCCDD)
+// Extension (0xBEDE, 0x1122334455667788)
+static const unsigned char kRtpPacketWithMarkerAndCsrcAndExtension[] = {
+ 0x93, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ 0x01, 0x02, 0x03, 0x04, 0x12, 0x34, 0x56, 0x78, 0xAA, 0xBB, 0xCC, 0xDD,
+ 0xBE, 0xDE, 0x00, 0x02, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88
+};
+static const unsigned char kInvalidPacket[] = { 0x80, 0x00 };
+static const unsigned char kInvalidPacketWithCsrc[] = {
+ 0x83, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ 0x01, 0x02, 0x03, 0x04, 0x12, 0x34, 0x56, 0x78, 0xAA, 0xBB, 0xCC
+};
+static const unsigned char kInvalidPacketWithCsrcAndExtension1[] = {
+ 0x93, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ 0x01, 0x02, 0x03, 0x04, 0x12, 0x34, 0x56, 0x78, 0xAA, 0xBB, 0xCC, 0xDD,
+ 0xBE, 0xDE, 0x00
+};
+static const unsigned char kInvalidPacketWithCsrcAndExtension2[] = {
+ 0x93, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ 0x01, 0x02, 0x03, 0x04, 0x12, 0x34, 0x56, 0x78, 0xAA, 0xBB, 0xCC, 0xDD,
+ 0xBE, 0xDE, 0x00, 0x02, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77
+};
+
+// PT = 206, FMT = 1, Sender SSRC = 0x1111, Media SSRC = 0x1111
+// No FCI information is needed for PLI.
+static const unsigned char kNonCompoundRtcpPliFeedbackPacket[] = {
+ 0x81, 0xCE, 0x00, 0x0C, 0x00, 0x00, 0x11, 0x11, 0x00, 0x00, 0x11, 0x11
+};
+
+// Packet has only mandatory fixed RTCP header
+// PT = 204, SSRC = 0x1111
+static const unsigned char kNonCompoundRtcpAppPacket[] = {
+ 0x81, 0xCC, 0x00, 0x0C, 0x00, 0x00, 0x11, 0x11
+};
+
+// PT = 202, Source count = 0
+static const unsigned char kNonCompoundRtcpSDESPacket[] = {
+ 0x80, 0xCA, 0x00, 0x00
+};
+
+TEST(RtpUtilsTest, GetRtp) {
+ int pt;
+ EXPECT_TRUE(GetRtpPayloadType(kPcmuFrame, sizeof(kPcmuFrame), &pt));
+ EXPECT_EQ(0, pt);
+ EXPECT_TRUE(GetRtpPayloadType(kRtpPacketWithMarker,
+ sizeof(kRtpPacketWithMarker), &pt));
+ EXPECT_EQ(0, pt);
+
+ int seq_num;
+ EXPECT_TRUE(GetRtpSeqNum(kPcmuFrame, sizeof(kPcmuFrame), &seq_num));
+ EXPECT_EQ(1, seq_num);
+
+ uint32 ts;
+ EXPECT_TRUE(GetRtpTimestamp(kPcmuFrame, sizeof(kPcmuFrame), &ts));
+ EXPECT_EQ(0u, ts);
+
+ uint32 ssrc;
+ EXPECT_TRUE(GetRtpSsrc(kPcmuFrame, sizeof(kPcmuFrame), &ssrc));
+ EXPECT_EQ(1u, ssrc);
+
+ EXPECT_FALSE(GetRtpPayloadType(kInvalidPacket, sizeof(kInvalidPacket), &pt));
+ EXPECT_FALSE(GetRtpSeqNum(kInvalidPacket, sizeof(kInvalidPacket), &seq_num));
+ EXPECT_FALSE(GetRtpTimestamp(kInvalidPacket, sizeof(kInvalidPacket), &ts));
+ EXPECT_FALSE(GetRtpSsrc(kInvalidPacket, sizeof(kInvalidPacket), &ssrc));
+}
+
+TEST(RtpUtilsTest, GetRtpHeaderLen) {
+ size_t len;
+ EXPECT_TRUE(GetRtpHeaderLen(kPcmuFrame, sizeof(kPcmuFrame), &len));
+ EXPECT_EQ(12U, len);
+
+ EXPECT_TRUE(GetRtpHeaderLen(kRtpPacketWithMarkerAndCsrcAndExtension,
+ sizeof(kRtpPacketWithMarkerAndCsrcAndExtension),
+ &len));
+ EXPECT_EQ(sizeof(kRtpPacketWithMarkerAndCsrcAndExtension), len);
+
+ EXPECT_FALSE(GetRtpHeaderLen(kInvalidPacket, sizeof(kInvalidPacket), &len));
+ EXPECT_FALSE(GetRtpHeaderLen(kInvalidPacketWithCsrc,
+ sizeof(kInvalidPacketWithCsrc), &len));
+ EXPECT_FALSE(GetRtpHeaderLen(kInvalidPacketWithCsrcAndExtension1,
+ sizeof(kInvalidPacketWithCsrcAndExtension1),
+ &len));
+ EXPECT_FALSE(GetRtpHeaderLen(kInvalidPacketWithCsrcAndExtension2,
+ sizeof(kInvalidPacketWithCsrcAndExtension2),
+ &len));
+}
+
+TEST(RtpUtilsTest, GetRtcp) {
+ int pt;
+ EXPECT_TRUE(GetRtcpType(kRtcpReport, sizeof(kRtcpReport), &pt));
+ EXPECT_EQ(0xc9, pt);
+
+ EXPECT_FALSE(GetRtcpType(kInvalidPacket, sizeof(kInvalidPacket), &pt));
+
+ uint32 ssrc;
+ EXPECT_TRUE(GetRtcpSsrc(kNonCompoundRtcpPliFeedbackPacket,
+ sizeof(kNonCompoundRtcpPliFeedbackPacket),
+ &ssrc));
+ EXPECT_TRUE(GetRtcpSsrc(kNonCompoundRtcpAppPacket,
+ sizeof(kNonCompoundRtcpAppPacket),
+ &ssrc));
+ EXPECT_FALSE(GetRtcpSsrc(kNonCompoundRtcpSDESPacket,
+ sizeof(kNonCompoundRtcpSDESPacket),
+ &ssrc));
+}
+
+} // namespace cricket
+
diff --git a/talk/session/phone/screencastid.h b/talk/session/phone/screencastid.h
new file mode 100644
index 0000000..0acc7de
--- /dev/null
+++ b/talk/session/phone/screencastid.h
@@ -0,0 +1,88 @@
+// Copyright 2012 Google Inc. All Rights Reserved
+
+//
+// Defines variant class ScreencastId that combines WindowId and DesktopId.
+
+#ifndef TALK_SESSION_PHONE_SCREENCASTID_H_
+#define TALK_SESSION_PHONE_SCREENCASTID_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/base/window.h"
+#include "talk/base/windowpicker.h"
+
+namespace cricket {
+
+class ScreencastId;
+typedef std::vector<ScreencastId> ScreencastIdList;
+
+// Used for identifying a window or desktop to be screencast.
+class ScreencastId {
+ public:
+ enum Type { INVALID, WINDOW, DESKTOP };
+
+ // Default constructor indicates invalid ScreencastId.
+ ScreencastId() : type_(INVALID) {}
+ explicit ScreencastId(const talk_base::WindowId& id)
+ : type_(WINDOW), window_(id) {
+ }
+ explicit ScreencastId(const talk_base::DesktopId& id)
+ : type_(DESKTOP), desktop_(id) {
+ }
+
+ Type type() const { return type_; }
+ const talk_base::WindowId& window() const { return window_; }
+ const talk_base::DesktopId& desktop() const { return desktop_; }
+
+ // Title is an optional parameter.
+ const std::string& title() const { return title_; }
+ void set_title(const std::string& desc) { title_ = desc; }
+
+ bool IsValid() const {
+ if (type_ == INVALID) {
+ return false;
+ } else if (type_ == WINDOW) {
+ return window_.IsValid();
+ } else {
+ return desktop_.IsValid();
+ }
+ }
+ bool IsWindow() const { return type_ == WINDOW; }
+ bool IsDesktop() const { return type_ == DESKTOP; }
+ bool EqualsId(const ScreencastId& other) const {
+ if (type_ != other.type_) {
+ return false;
+ }
+ if (type_ == INVALID) {
+ return true;
+ } else if (type_ == WINDOW) {
+ return window_.Equals(other.window());
+ }
+ return desktop_.Equals(other.desktop());
+ }
+
+ // T is assumed to be WindowDescription or DesktopDescription.
+ template<class T>
+ static cricket::ScreencastIdList Convert(const std::vector<T>& list) {
+ ScreencastIdList screencast_list;
+ screencast_list.reserve(list.size());
+ for (typename std::vector<T>::const_iterator it = list.begin();
+ it != list.end(); ++it) {
+ ScreencastId id(it->id());
+ id.set_title(it->title());
+ screencast_list.push_back(id);
+ }
+ return screencast_list;
+ }
+
+ private:
+ Type type_;
+ talk_base::WindowId window_;
+ talk_base::DesktopId desktop_;
+ std::string title_; // Optional.
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_SCREENCASTID_H_
diff --git a/talk/session/phone/srtpfilter.cc b/talk/session/phone/srtpfilter.cc
index b3578e1..7a1cb78 100644
--- a/talk/session/phone/srtpfilter.cc
+++ b/talk/session/phone/srtpfilter.cc
@@ -25,22 +25,8 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-// talk's config.h, generated from mac_config_dot_h for OSX, conflicts with the
-// one included by the libsrtp headers. Don't use it. Instead, we keep HAVE_SRTP
-// and LOGGING defined in config.h.
#undef HAVE_CONFIG_H
-#ifdef OSX
-// TODO: For the XCode build, we force SRTP (b/2500074)
-#ifndef HAVE_SRTP
-#define HAVE_SRTP 1
-#endif // HAVE_SRTP
-// If LOGGING is not defined, define it to 1 (b/3245816)
-#ifndef LOGGING
-#define LOGGING 1
-#endif // HAVE_SRTP
-#endif
-
#include "talk/session/phone/srtpfilter.h"
#include <algorithm>
@@ -48,7 +34,8 @@
#include "talk/base/base64.h"
#include "talk/base/logging.h"
-#include "talk/base/time.h"
+#include "talk/base/stringencode.h"
+#include "talk/base/timeutils.h"
#include "talk/session/phone/rtputils.h"
// Enable this line to turn on SRTP debugging
@@ -79,6 +66,8 @@
const char CS_AES_CM_128_HMAC_SHA1_80[] = "AES_CM_128_HMAC_SHA1_80";
const char CS_AES_CM_128_HMAC_SHA1_32[] = "AES_CM_128_HMAC_SHA1_32";
const int SRTP_MASTER_KEY_BASE64_LEN = SRTP_MASTER_KEY_LEN * 4 / 3;
+const int SRTP_MASTER_KEY_KEY_LEN = 16;
+const int SRTP_MASTER_KEY_SALT_LEN = 14;
#ifndef HAVE_SRTP
@@ -110,44 +99,41 @@
SrtpFilter::SrtpFilter()
: state_(ST_INIT),
- send_session_(new SrtpSession()),
- recv_session_(new SrtpSession()) {
- SignalSrtpError.repeat(send_session_->SignalSrtpError);
- SignalSrtpError.repeat(recv_session_->SignalSrtpError);
+ signal_silent_time_in_ms_(0) {
}
SrtpFilter::~SrtpFilter() {
}
bool SrtpFilter::IsActive() const {
- return (state_ == ST_ACTIVE);
+ return state_ >= ST_ACTIVE;
}
bool SrtpFilter::SetOffer(const std::vector<CryptoParams>& offer_params,
ContentSource source) {
- bool ret = false;
- if (state_ == ST_INIT) {
- ret = StoreParams(offer_params, source);
- } else {
- LOG(LS_ERROR) << "Invalid state for SRTP offer";
+ if (state_ != ST_INIT && state_ != ST_ACTIVE) {
+ LOG(LS_ERROR) << "Wrong state to update SRTP offer";
+ return false;
}
- return ret;
+ return StoreParams(offer_params, source);
}
bool SrtpFilter::SetAnswer(const std::vector<CryptoParams>& answer_params,
ContentSource source) {
bool ret = false;
if ((state_ == ST_SENTOFFER && source == CS_REMOTE) ||
- (state_ == ST_RECEIVEDOFFER && source == CS_LOCAL)) {
+ (state_ == ST_RECEIVEDOFFER && source == CS_LOCAL) ||
+ (state_ == ST_SENTUPDATEDOFFER && source == CS_REMOTE) ||
+ (state_ == ST_RECEIVEDUPDATEDOFFER && source == CS_LOCAL)) {
// If the answer requests crypto, finalize the parameters and apply them.
// Otherwise, complete the negotiation of a unencrypted session.
if (!answer_params.empty()) {
CryptoParams selected_params;
ret = NegotiateParams(answer_params, &selected_params);
if (ret) {
- if (state_ == ST_SENTOFFER) {
+ if (state_ == ST_SENTOFFER || state_ == ST_SENTUPDATEDOFFER) {
ret = ApplyParams(selected_params, answer_params[0]);
- } else { // ST_RECEIVEDOFFER
+ } else { // ST_RECEIVEDOFFER || ST_RECEIVEDUPDATEDOFFER
ret = ApplyParams(answer_params[0], selected_params);
}
}
@@ -160,6 +146,68 @@
return ret;
}
+bool SrtpFilter::SetRtpParams(const std::string& send_cs,
+ const uint8* send_key, int send_key_len,
+ const std::string& recv_cs,
+ const uint8* recv_key, int recv_key_len) {
+ if (state_ == ST_ACTIVE) {
+ LOG(LS_ERROR) << "Tried to set SRTP Params when filter already active";
+ return false;
+ }
+ CreateSrtpSessions();
+ if (!send_session_->SetSend(send_cs, send_key, send_key_len))
+ return false;
+
+ if (!recv_session_->SetRecv(recv_cs, recv_key, recv_key_len))
+ return false;
+
+ state_ = ST_ACTIVE;
+
+ LOG(LS_INFO) << "SRTP activated with negotiated parameters:"
+ << " send cipher_suite " << send_cs
+ << " recv cipher_suite " << recv_cs;
+
+ return true;
+}
+
+// This function is provided separately because DTLS-SRTP behaves
+// differently in RTP/RTCP mux and non-mux modes.
+//
+// - In the non-muxed case, RTP and RTCP are keyed with different
+// keys (from different DTLS handshakes), and so we need a new
+// SrtpSession.
+// - In the muxed case, they are keyed with the same keys, so
+// this function is not needed
+bool SrtpFilter::SetRtcpParams(const std::string& send_cs,
+ const uint8* send_key, int send_key_len,
+ const std::string& recv_cs,
+ const uint8* recv_key, int recv_key_len) {
+ // This can only be called once, but can be safely called after
+ // SetRtpParams
+ if (send_rtcp_session_.get() || send_rtcp_session_.get()) {
+ LOG(LS_ERROR) << "Tried to set SRTCP Params when filter already active";
+ return false;
+ }
+
+ send_rtcp_session_.reset(new SrtpSession());
+ SignalSrtpError.repeat(send_rtcp_session_->SignalSrtpError);
+ send_rtcp_session_->set_signal_silent_time(signal_silent_time_in_ms_);
+ if (!send_rtcp_session_->SetRecv(send_cs, send_key, send_key_len))
+ return false;
+
+ recv_rtcp_session_.reset(new SrtpSession());
+ SignalSrtpError.repeat(recv_rtcp_session_->SignalSrtpError);
+ recv_rtcp_session_->set_signal_silent_time(signal_silent_time_in_ms_);
+ if (!recv_rtcp_session_->SetRecv(recv_cs, recv_key, recv_key_len))
+ return false;
+
+ LOG(LS_INFO) << "SRTCP activated with negotiated parameters:"
+ << " send cipher_suite " << send_cs
+ << " recv cipher_suite " << recv_cs;
+
+ return true;
+}
+
bool SrtpFilter::ProtectRtp(void* p, int in_len, int max_len, int* out_len) {
if (!IsActive()) {
LOG(LS_WARNING) << "Failed to ProtectRtp: SRTP not active";
@@ -173,7 +221,11 @@
LOG(LS_WARNING) << "Failed to ProtectRtcp: SRTP not active";
return false;
}
- return send_session_->ProtectRtcp(p, in_len, max_len, out_len);
+ if (send_rtcp_session_.get()) {
+ return send_rtcp_session_->ProtectRtcp(p, in_len, max_len, out_len);
+ } else {
+ return send_session_->ProtectRtcp(p, in_len, max_len, out_len);
+ }
}
bool SrtpFilter::UnprotectRtp(void* p, int in_len, int* out_len) {
@@ -189,21 +241,47 @@
LOG(LS_WARNING) << "Failed to UnprotectRtcp: SRTP not active";
return false;
}
- return recv_session_->UnprotectRtcp(p, in_len, out_len);
+ if (recv_rtcp_session_.get()) {
+ return recv_rtcp_session_->UnprotectRtcp(p, in_len, out_len);
+ } else {
+ return recv_session_->UnprotectRtcp(p, in_len, out_len);
+ }
}
void SrtpFilter::set_signal_silent_time(uint32 signal_silent_time_in_ms) {
- send_session_->set_signal_silent_time(signal_silent_time_in_ms);
- recv_session_->set_signal_silent_time(signal_silent_time_in_ms);
+ signal_silent_time_in_ms_ = signal_silent_time_in_ms;
+ if (state_ == ST_ACTIVE) {
+ send_session_->set_signal_silent_time(signal_silent_time_in_ms);
+ recv_session_->set_signal_silent_time(signal_silent_time_in_ms);
+ if (send_rtcp_session_.get())
+ send_rtcp_session_->set_signal_silent_time(signal_silent_time_in_ms);
+ if (recv_rtcp_session_.get())
+ recv_rtcp_session_->set_signal_silent_time(signal_silent_time_in_ms);
+ }
}
bool SrtpFilter::StoreParams(const std::vector<CryptoParams>& params,
ContentSource source) {
offer_params_ = params;
- state_ = (source == CS_LOCAL) ? ST_SENTOFFER : ST_RECEIVEDOFFER;
+ if (state_ == ST_INIT) {
+ state_ = (source == CS_LOCAL) ? ST_SENTOFFER : ST_RECEIVEDOFFER;
+ } else { // ST_ACTIVE
+ state_ =
+ (source == CS_LOCAL) ? ST_SENTUPDATEDOFFER : ST_RECEIVEDUPDATEDOFFER;
+ }
return true;
}
+void SrtpFilter::CreateSrtpSessions() {
+ send_session_.reset(new SrtpSession());
+ recv_session_.reset(new SrtpSession());
+ SignalSrtpError.repeat(send_session_->SignalSrtpError);
+ SignalSrtpError.repeat(recv_session_->SignalSrtpError);
+
+ send_session_->set_signal_silent_time(signal_silent_time_in_ms_);
+ recv_session_->set_signal_silent_time(signal_silent_time_in_ms_);
+}
+
bool SrtpFilter::NegotiateParams(const std::vector<CryptoParams>& answer_params,
CryptoParams* selected_params) {
// We're processing an accept. We should have exactly one set of params,
@@ -239,6 +317,7 @@
ret = (ParseKeyParams(send_params.key_params, send_key, sizeof(send_key)) &&
ParseKeyParams(recv_params.key_params, recv_key, sizeof(recv_key)));
if (ret) {
+ CreateSrtpSessions();
ret = (send_session_->SetSend(send_params.cipher_suite,
send_key, sizeof(send_key)) &&
recv_session_->SetRecv(recv_params.cipher_suite,
@@ -290,7 +369,6 @@
#ifdef HAVE_SRTP
bool SrtpSession::inited_ = false;
-std::list<SrtpSession*> SrtpSession::sessions_;
SrtpSession::SrtpSession()
: session_(NULL),
@@ -298,12 +376,12 @@
rtcp_auth_tag_len_(0),
srtp_stat_(new SrtpStat()),
last_send_seq_num_(-1) {
- sessions_.push_back(this);
+ sessions()->push_back(this);
SignalSrtpError.repeat(srtp_stat_->SignalSrtpError);
}
SrtpSession::~SrtpSession() {
- sessions_.erase(std::find(sessions_.begin(), sessions_.end(), this));
+ sessions()->erase(std::find(sessions()->begin(), sessions()->end(), this));
if (session_) {
srtp_dealloc(session_);
}
@@ -503,8 +581,8 @@
}
void SrtpSession::HandleEventThunk(srtp_event_data_t* ev) {
- for (std::list<SrtpSession*>::iterator it = sessions_.begin();
- it != sessions_.end(); ++it) {
+ for (std::list<SrtpSession*>::iterator it = sessions()->begin();
+ it != sessions()->end(); ++it) {
if ((*it)->session_ == ev->session) {
(*it)->HandleEvent(ev);
break;
@@ -512,8 +590,14 @@
}
}
+std::list<SrtpSession*>* SrtpSession::sessions() {
+ LIBJINGLE_DEFINE_STATIC_LOCAL(std::list<SrtpSession*>, sessions, ());
+ return &sessions;
+}
+
#else // !HAVE_SRTP
+// On some systems, SRTP is not (yet) available.
SrtpSession::SrtpSession() {
LOG(WARNING) << "SRTP implementation is missing.";
@@ -628,6 +712,7 @@
#else // !HAVE_SRTP
+// On some systems, SRTP is not (yet) available.
SrtpStat::SrtpStat()
: signal_silent_time_(1000) {
diff --git a/talk/session/phone/srtpfilter.h b/talk/session/phone/srtpfilter.h
index 409a3a9..991d4bf 100644
--- a/talk/session/phone/srtpfilter.h
+++ b/talk/session/phone/srtpfilter.h
@@ -57,6 +57,10 @@
// Key is 128 bits and salt is 112 bits == 30 bytes. B64 bloat => 40 bytes.
extern const int SRTP_MASTER_KEY_BASE64_LEN;
+// Needed for DTLS-SRTP
+extern const int SRTP_MASTER_KEY_KEY_LEN;
+extern const int SRTP_MASTER_KEY_SALT_LEN;
+
class SrtpSession;
class SrtpStat;
@@ -99,6 +103,17 @@
bool SetAnswer(const std::vector<CryptoParams>& answer_params,
ContentSource source);
+ // Just set up both sets of keys directly.
+ // Used with DTLS-SRTP.
+ bool SetRtpParams(const std::string& send_cs,
+ const uint8* send_key, int send_key_len,
+ const std::string& recv_cs,
+ const uint8* recv_key, int recv_key_len);
+ bool SetRtcpParams(const std::string& send_cs,
+ const uint8* send_key, int send_key_len,
+ const std::string& recv_cs,
+ const uint8* recv_key, int recv_key_len);
+
// Encrypts/signs an individual RTP/RTCP packet, in-place.
// If an HMAC is used, this will increase the packet size.
bool ProtectRtp(void* data, int in_len, int max_len, int* out_len);
@@ -114,8 +129,9 @@
sigslot::repeater3<uint32, Mode, Error> SignalSrtpError;
protected:
- bool StoreParams(const std::vector<CryptoParams>& offer_params,
+ bool StoreParams(const std::vector<CryptoParams>& params,
ContentSource source);
+ void CreateSrtpSessions();
bool NegotiateParams(const std::vector<CryptoParams>& answer_params,
CryptoParams* selected_params);
bool ApplyParams(const CryptoParams& send_params,
@@ -124,11 +140,25 @@
static bool ParseKeyParams(const std::string& params, uint8* key, int len);
private:
- enum State { ST_INIT, ST_SENTOFFER, ST_RECEIVEDOFFER, ST_ACTIVE };
+ enum State {
+ ST_INIT, // SRTP filter unused.
+ ST_SENTOFFER, // Offer with SRTP parameters sent.
+ ST_RECEIVEDOFFER, // Offer with SRTP parameters received.
+ ST_ACTIVE, // Offer and answer set.
+ // SRTP filter is active but new parameters are offered.
+ // When the answer is set, the state transitions to ST_ACTIVE or ST_INIT.
+ ST_SENTUPDATEDOFFER,
+ // SRTP filter is active but new parameters are received.
+ // When the answer is set, the state transitions back to ST_ACTIVE.
+ ST_RECEIVEDUPDATEDOFFER
+ };
State state_;
+ uint32 signal_silent_time_in_ms_;
std::vector<CryptoParams> offer_params_;
talk_base::scoped_ptr<SrtpSession> send_session_;
talk_base::scoped_ptr<SrtpSession> recv_session_;
+ talk_base::scoped_ptr<SrtpSession> send_rtcp_session_;
+ talk_base::scoped_ptr<SrtpSession> recv_rtcp_session_;
};
// Class that wraps a libSRTP session.
@@ -164,13 +194,13 @@
static bool Init();
void HandleEvent(const srtp_event_data_t* ev);
static void HandleEventThunk(srtp_event_data_t* ev);
+ static std::list<SrtpSession*>* sessions();
srtp_t session_;
int rtp_auth_tag_len_;
int rtcp_auth_tag_len_;
talk_base::scoped_ptr<SrtpStat> srtp_stat_;
static bool inited_;
- static std::list<SrtpSession*> sessions_;
int last_send_seq_num_;
DISALLOW_COPY_AND_ASSIGN(SrtpSession);
};
@@ -228,7 +258,7 @@
FailureStat()
: last_signal_time(0) {
}
- FailureStat(uint32 in_last_signal_time)
+ explicit FailureStat(uint32 in_last_signal_time)
: last_signal_time(in_last_signal_time) {
}
void Reset() {
diff --git a/talk/session/phone/srtpfilter_unittest.cc b/talk/session/phone/srtpfilter_unittest.cc
new file mode 100644
index 0000000..276c341
--- /dev/null
+++ b/talk/session/phone/srtpfilter_unittest.cc
@@ -0,0 +1,764 @@
+/*
+ * libjingle
+ * Copyright 2004--2009, 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/base/byteorder.h"
+#include "talk/base/gunit.h"
+#include "talk/base/thread.h"
+#include "talk/p2p/base/sessiondescription.h"
+#include "talk/session/phone/cryptoparams.h"
+#include "talk/session/phone/fakertp.h"
+#include "talk/session/phone/srtpfilter.h"
+#ifdef SRTP_RELATIVE_PATH
+#include "crypto/include/err.h"
+#else
+#include "third_party/libsrtp/crypto/include/err.h"
+#endif
+
+using cricket::CS_AES_CM_128_HMAC_SHA1_80;
+using cricket::CS_AES_CM_128_HMAC_SHA1_32;
+using cricket::CryptoParams;
+using cricket::CS_LOCAL;
+using cricket::CS_REMOTE;
+
+static const uint8 kTestKey1[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234";
+static const uint8 kTestKey2[] = "4321ZYXWVUTSRQPONMLKJIHGFEDCBA";
+static const int kTestKeyLen = 30;
+static const std::string kTestKeyParams1 =
+ "inline:WVNfX19zZW1jdGwgKCkgewkyMjA7fQp9CnVubGVz";
+static const std::string kTestKeyParams2 =
+ "inline:PS1uQCVeeCFCanVmcjkpPywjNWhcYD0mXXtxaVBR";
+static const std::string kTestKeyParams3 =
+ "inline:1234X19zZW1jdGwgKCkgewkyMjA7fQp9CnVubGVz";
+static const std::string kTestKeyParams4 =
+ "inline:4567QCVeeCFCanVmcjkpPywjNWhcYD0mXXtxaVBR";
+static const cricket::CryptoParams kTestCryptoParams1(
+ 1, "AES_CM_128_HMAC_SHA1_80", kTestKeyParams1, "");
+static const cricket::CryptoParams kTestCryptoParams2(
+ 1, "AES_CM_128_HMAC_SHA1_80", kTestKeyParams2, "");
+
+static int rtp_auth_tag_len(const std::string& cs) {
+ return (cs == CS_AES_CM_128_HMAC_SHA1_32) ? 4 : 10;
+}
+static int rtcp_auth_tag_len(const std::string& cs) {
+ return 10;
+}
+
+class SrtpFilterTest : public testing::Test {
+ protected:
+ SrtpFilterTest()
+ // Need to initialize |sequence_number_|, the value does not matter.
+ : sequence_number_(1) {
+ }
+ static std::vector<CryptoParams> MakeVector(const CryptoParams& params) {
+ std::vector<CryptoParams> vec;
+ vec.push_back(params);
+ return vec;
+ }
+ void TestSetParams(const std::vector<CryptoParams>& params1,
+ const std::vector<CryptoParams>& params2) {
+ EXPECT_TRUE(f1_.SetOffer(params1, CS_LOCAL));
+ EXPECT_TRUE(f2_.SetOffer(params1, CS_REMOTE));
+ EXPECT_TRUE(f2_.SetAnswer(params2, CS_LOCAL));
+ EXPECT_TRUE(f1_.SetAnswer(params2, CS_REMOTE));
+ EXPECT_TRUE(f1_.IsActive());
+ }
+ void TestProtectUnprotect(const std::string& cs1, const std::string& cs2) {
+ char rtp_packet[sizeof(kPcmuFrame) + 10];
+ char original_rtp_packet[sizeof(kPcmuFrame)];
+ char rtcp_packet[sizeof(kRtcpReport) + 4 + 10];
+ int rtp_len = sizeof(kPcmuFrame), rtcp_len = sizeof(kRtcpReport), out_len;
+ memcpy(rtp_packet, kPcmuFrame, rtp_len);
+ // In order to be able to run this test function multiple times we can not
+ // use the same sequence number twice. Increase the sequence number by one.
+ talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet) + 2,
+ ++sequence_number_);
+ memcpy(original_rtp_packet, rtp_packet, rtp_len);
+ memcpy(rtcp_packet, kRtcpReport, rtcp_len);
+
+ EXPECT_TRUE(f1_.ProtectRtp(rtp_packet, rtp_len,
+ sizeof(rtp_packet), &out_len));
+ EXPECT_EQ(out_len, rtp_len + rtp_auth_tag_len(cs1));
+ EXPECT_NE(0, memcmp(rtp_packet, original_rtp_packet, rtp_len));
+ EXPECT_TRUE(f2_.UnprotectRtp(rtp_packet, out_len, &out_len));
+ EXPECT_EQ(rtp_len, out_len);
+ EXPECT_EQ(0, memcmp(rtp_packet, original_rtp_packet, rtp_len));
+
+ EXPECT_TRUE(f2_.ProtectRtp(rtp_packet, rtp_len,
+ sizeof(rtp_packet), &out_len));
+ EXPECT_EQ(out_len, rtp_len + rtp_auth_tag_len(cs2));
+ EXPECT_NE(0, memcmp(rtp_packet, original_rtp_packet, rtp_len));
+ EXPECT_TRUE(f1_.UnprotectRtp(rtp_packet, out_len, &out_len));
+ EXPECT_EQ(rtp_len, out_len);
+ EXPECT_EQ(0, memcmp(rtp_packet, original_rtp_packet, rtp_len));
+
+ EXPECT_TRUE(f1_.ProtectRtcp(rtcp_packet, rtcp_len,
+ sizeof(rtcp_packet), &out_len));
+ EXPECT_EQ(out_len, rtcp_len + 4 + rtcp_auth_tag_len(cs1)); // NOLINT
+ EXPECT_NE(0, memcmp(rtcp_packet, kRtcpReport, rtcp_len));
+ EXPECT_TRUE(f2_.UnprotectRtcp(rtcp_packet, out_len, &out_len));
+ EXPECT_EQ(rtcp_len, out_len);
+ EXPECT_EQ(0, memcmp(rtcp_packet, kRtcpReport, rtcp_len));
+
+ EXPECT_TRUE(f2_.ProtectRtcp(rtcp_packet, rtcp_len,
+ sizeof(rtcp_packet), &out_len));
+ EXPECT_EQ(out_len, rtcp_len + 4 + rtcp_auth_tag_len(cs2)); // NOLINT
+ EXPECT_NE(0, memcmp(rtcp_packet, kRtcpReport, rtcp_len));
+ EXPECT_TRUE(f1_.UnprotectRtcp(rtcp_packet, out_len, &out_len));
+ EXPECT_EQ(rtcp_len, out_len);
+ EXPECT_EQ(0, memcmp(rtcp_packet, kRtcpReport, rtcp_len));
+ }
+ cricket::SrtpFilter f1_;
+ cricket::SrtpFilter f2_;
+ int sequence_number_;
+};
+
+// Test that we can set up the session and keys properly.
+TEST_F(SrtpFilterTest, TestGoodSetupOneCipherSuite) {
+ EXPECT_TRUE(f1_.SetOffer(MakeVector(kTestCryptoParams1), CS_LOCAL));
+ EXPECT_TRUE(f1_.SetAnswer(MakeVector(kTestCryptoParams2), CS_REMOTE));
+ EXPECT_TRUE(f1_.IsActive());
+}
+
+// Test that we can set up things with multiple params.
+TEST_F(SrtpFilterTest, TestGoodSetupMultipleCipherSuites) {
+ std::vector<CryptoParams> offer(MakeVector(kTestCryptoParams1));
+ std::vector<CryptoParams> answer(MakeVector(kTestCryptoParams2));
+ offer.push_back(kTestCryptoParams1);
+ offer[1].tag = 2;
+ offer[1].cipher_suite = CS_AES_CM_128_HMAC_SHA1_32;
+ answer[0].tag = 2;
+ answer[0].cipher_suite = CS_AES_CM_128_HMAC_SHA1_32;
+ EXPECT_TRUE(f1_.SetOffer(offer, CS_LOCAL));
+ EXPECT_TRUE(f1_.SetAnswer(answer, CS_REMOTE));
+ EXPECT_TRUE(f1_.IsActive());
+}
+
+// Test that we handle the cases where crypto is not desired.
+TEST_F(SrtpFilterTest, TestGoodSetupNoCipherSuites) {
+ std::vector<CryptoParams> offer, answer;
+ EXPECT_TRUE(f1_.SetOffer(offer, CS_LOCAL));
+ EXPECT_TRUE(f1_.SetAnswer(answer, CS_REMOTE));
+ EXPECT_FALSE(f1_.IsActive());
+}
+
+// Test that we handle the cases where crypto is not desired by the remote side.
+TEST_F(SrtpFilterTest, TestGoodSetupNoAnswerCipherSuites) {
+ std::vector<CryptoParams> answer;
+ EXPECT_TRUE(f1_.SetOffer(MakeVector(kTestCryptoParams1), CS_LOCAL));
+ EXPECT_TRUE(f1_.SetAnswer(answer, CS_REMOTE));
+ EXPECT_FALSE(f1_.IsActive());
+}
+
+// Test that we fail if we call the functions the wrong way.
+TEST_F(SrtpFilterTest, TestBadSetup) {
+ std::vector<CryptoParams> offer(MakeVector(kTestCryptoParams1));
+ std::vector<CryptoParams> answer(MakeVector(kTestCryptoParams2));
+ EXPECT_FALSE(f1_.SetAnswer(answer, CS_LOCAL));
+ EXPECT_FALSE(f1_.SetAnswer(answer, CS_REMOTE));
+ EXPECT_TRUE(f1_.SetOffer(offer, CS_LOCAL));
+ EXPECT_FALSE(f1_.SetOffer(answer, CS_REMOTE));
+ EXPECT_FALSE(f1_.SetAnswer(answer, CS_LOCAL));
+ EXPECT_FALSE(f1_.IsActive());
+}
+
+// Test that we fail if we have params in the answer when none were offered.
+TEST_F(SrtpFilterTest, TestNoAnswerCipherSuites) {
+ std::vector<CryptoParams> offer;
+ EXPECT_TRUE(f1_.SetOffer(offer, CS_LOCAL));
+ EXPECT_FALSE(f1_.SetAnswer(MakeVector(kTestCryptoParams2), CS_REMOTE));
+ EXPECT_FALSE(f1_.IsActive());
+}
+
+// Test that we fail if we have too many params in our answer.
+TEST_F(SrtpFilterTest, TestMultipleAnswerCipherSuites) {
+ std::vector<CryptoParams> answer(MakeVector(kTestCryptoParams2));
+ answer.push_back(kTestCryptoParams2);
+ answer[1].tag = 2;
+ answer[1].cipher_suite = CS_AES_CM_128_HMAC_SHA1_32;
+ EXPECT_TRUE(f1_.SetOffer(MakeVector(kTestCryptoParams1), CS_LOCAL));
+ EXPECT_FALSE(f1_.SetAnswer(answer, CS_REMOTE));
+ EXPECT_FALSE(f1_.IsActive());
+}
+
+// Test that we fail if we don't support the cipher-suite.
+TEST_F(SrtpFilterTest, TestInvalidCipherSuite) {
+ std::vector<CryptoParams> offer(MakeVector(kTestCryptoParams1));
+ std::vector<CryptoParams> answer(MakeVector(kTestCryptoParams2));
+ offer[0].cipher_suite = answer[0].cipher_suite = "FOO";
+ EXPECT_TRUE(f1_.SetOffer(offer, CS_LOCAL));
+ EXPECT_FALSE(f1_.SetAnswer(answer, CS_REMOTE));
+ EXPECT_FALSE(f1_.IsActive());
+}
+
+// Test that we fail if we can't agree on a tag.
+TEST_F(SrtpFilterTest, TestNoMatchingTag) {
+ std::vector<CryptoParams> offer(MakeVector(kTestCryptoParams1));
+ std::vector<CryptoParams> answer(MakeVector(kTestCryptoParams2));
+ answer[0].tag = 99;
+ EXPECT_TRUE(f1_.SetOffer(offer, CS_LOCAL));
+ EXPECT_FALSE(f1_.SetAnswer(answer, CS_REMOTE));
+ EXPECT_FALSE(f1_.IsActive());
+}
+
+// Test that we fail if we can't agree on a cipher-suite.
+TEST_F(SrtpFilterTest, TestNoMatchingCipherSuite) {
+ std::vector<CryptoParams> offer(MakeVector(kTestCryptoParams1));
+ std::vector<CryptoParams> answer(MakeVector(kTestCryptoParams2));
+ answer[0].tag = 2;
+ answer[0].cipher_suite = "FOO";
+ EXPECT_TRUE(f1_.SetOffer(offer, CS_LOCAL));
+ EXPECT_FALSE(f1_.SetAnswer(answer, CS_REMOTE));
+ EXPECT_FALSE(f1_.IsActive());
+}
+
+// Test that we fail keys with bad base64 content.
+TEST_F(SrtpFilterTest, TestInvalidKeyData) {
+ std::vector<CryptoParams> offer(MakeVector(kTestCryptoParams1));
+ std::vector<CryptoParams> answer(MakeVector(kTestCryptoParams2));
+ answer[0].key_params = "inline:!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!";
+ EXPECT_TRUE(f1_.SetOffer(offer, CS_LOCAL));
+ EXPECT_FALSE(f1_.SetAnswer(answer, CS_REMOTE));
+ EXPECT_FALSE(f1_.IsActive());
+}
+
+// Test that we fail keys with the wrong key-method.
+TEST_F(SrtpFilterTest, TestWrongKeyMethod) {
+ std::vector<CryptoParams> offer(MakeVector(kTestCryptoParams1));
+ std::vector<CryptoParams> answer(MakeVector(kTestCryptoParams2));
+ answer[0].key_params = "outline:PS1uQCVeeCFCanVmcjkpPywjNWhcYD0mXXtxaVBR";
+ EXPECT_TRUE(f1_.SetOffer(offer, CS_LOCAL));
+ EXPECT_FALSE(f1_.SetAnswer(answer, CS_REMOTE));
+ EXPECT_FALSE(f1_.IsActive());
+}
+
+// Test that we fail keys of the wrong length.
+TEST_F(SrtpFilterTest, TestKeyTooShort) {
+ std::vector<CryptoParams> offer(MakeVector(kTestCryptoParams1));
+ std::vector<CryptoParams> answer(MakeVector(kTestCryptoParams2));
+ answer[0].key_params = "inline:PS1uQCVeeCFCanVmcjkpPywjNWhcYD0mXXtx";
+ EXPECT_TRUE(f1_.SetOffer(offer, CS_LOCAL));
+ EXPECT_FALSE(f1_.SetAnswer(answer, CS_REMOTE));
+ EXPECT_FALSE(f1_.IsActive());
+}
+
+// Test that we fail keys of the wrong length.
+TEST_F(SrtpFilterTest, TestKeyTooLong) {
+ std::vector<CryptoParams> offer(MakeVector(kTestCryptoParams1));
+ std::vector<CryptoParams> answer(MakeVector(kTestCryptoParams2));
+ answer[0].key_params = "inline:PS1uQCVeeCFCanVmcjkpPywjNWhcYD0mXXtxaVBRABCD";
+ EXPECT_TRUE(f1_.SetOffer(offer, CS_LOCAL));
+ EXPECT_FALSE(f1_.SetAnswer(answer, CS_REMOTE));
+ EXPECT_FALSE(f1_.IsActive());
+}
+
+// Test that we fail keys with lifetime or MKI set (since we don't support)
+TEST_F(SrtpFilterTest, TestUnsupportedOptions) {
+ std::vector<CryptoParams> offer(MakeVector(kTestCryptoParams1));
+ std::vector<CryptoParams> answer(MakeVector(kTestCryptoParams2));
+ answer[0].key_params =
+ "inline:PS1uQCVeeCFCanVmcjkpPywjNWhcYD0mXXtxaVBR|2^20|1:4";
+ EXPECT_TRUE(f1_.SetOffer(offer, CS_LOCAL));
+ EXPECT_FALSE(f1_.SetAnswer(answer, CS_REMOTE));
+ EXPECT_FALSE(f1_.IsActive());
+}
+
+// Test that we can encrypt/decrypt after negotiating AES_CM_128_HMAC_SHA1_80.
+TEST_F(SrtpFilterTest, TestProtect_AES_CM_128_HMAC_SHA1_80) {
+ std::vector<CryptoParams> offer(MakeVector(kTestCryptoParams1));
+ std::vector<CryptoParams> answer(MakeVector(kTestCryptoParams2));
+ offer.push_back(kTestCryptoParams1);
+ offer[1].tag = 2;
+ offer[1].cipher_suite = CS_AES_CM_128_HMAC_SHA1_32;
+ TestSetParams(offer, answer);
+ TestProtectUnprotect(CS_AES_CM_128_HMAC_SHA1_80, CS_AES_CM_128_HMAC_SHA1_80);
+}
+
+// Test that we can encrypt/decrypt after negotiating AES_CM_128_HMAC_SHA1_32.
+TEST_F(SrtpFilterTest, TestProtect_AES_CM_128_HMAC_SHA1_32) {
+ std::vector<CryptoParams> offer(MakeVector(kTestCryptoParams1));
+ std::vector<CryptoParams> answer(MakeVector(kTestCryptoParams2));
+ offer.push_back(kTestCryptoParams1);
+ offer[1].tag = 2;
+ offer[1].cipher_suite = CS_AES_CM_128_HMAC_SHA1_32;
+ answer[0].tag = 2;
+ answer[0].cipher_suite = CS_AES_CM_128_HMAC_SHA1_32;
+ TestSetParams(offer, answer);
+ TestProtectUnprotect(CS_AES_CM_128_HMAC_SHA1_32, CS_AES_CM_128_HMAC_SHA1_32);
+}
+
+// Test that we can change encryption parameters.
+TEST_F(SrtpFilterTest, TestChangeParameters) {
+ std::vector<CryptoParams> offer(MakeVector(kTestCryptoParams1));
+ std::vector<CryptoParams> answer(MakeVector(kTestCryptoParams2));
+
+ TestSetParams(offer, answer);
+ TestProtectUnprotect(CS_AES_CM_128_HMAC_SHA1_80, CS_AES_CM_128_HMAC_SHA1_80);
+
+ // Change the key parameters and cipher_suite.
+ offer[0].key_params = kTestKeyParams3;
+ offer[0].cipher_suite = CS_AES_CM_128_HMAC_SHA1_32;
+ answer[0].key_params = kTestKeyParams4;
+ answer[0].cipher_suite = CS_AES_CM_128_HMAC_SHA1_32;
+
+ EXPECT_TRUE(f1_.SetOffer(offer, CS_LOCAL));
+ EXPECT_TRUE(f2_.SetOffer(offer, CS_REMOTE));
+ EXPECT_TRUE(f1_.IsActive());
+ EXPECT_TRUE(f1_.IsActive());
+
+ // Test that the old keys are valid until the negotiation is complete.
+ TestProtectUnprotect(CS_AES_CM_128_HMAC_SHA1_80, CS_AES_CM_128_HMAC_SHA1_80);
+
+ // Complete the negotiation and test that we can still understand each other.
+ EXPECT_TRUE(f2_.SetAnswer(answer, CS_LOCAL));
+ EXPECT_TRUE(f1_.SetAnswer(answer, CS_REMOTE));
+
+ TestProtectUnprotect(CS_AES_CM_128_HMAC_SHA1_32, CS_AES_CM_128_HMAC_SHA1_32);
+}
+
+// Test that we can disable encryption.
+TEST_F(SrtpFilterTest, TestDisableEncryption) {
+ std::vector<CryptoParams> offer(MakeVector(kTestCryptoParams1));
+ std::vector<CryptoParams> answer(MakeVector(kTestCryptoParams2));
+
+ TestSetParams(offer, answer);
+ TestProtectUnprotect(CS_AES_CM_128_HMAC_SHA1_80, CS_AES_CM_128_HMAC_SHA1_80);
+
+ offer.clear();
+ answer.clear();
+ EXPECT_TRUE(f1_.SetOffer(offer, CS_LOCAL));
+ EXPECT_TRUE(f2_.SetOffer(offer, CS_REMOTE));
+ EXPECT_TRUE(f1_.IsActive());
+ EXPECT_TRUE(f2_.IsActive());
+
+ // Test that the old keys are valid until the negotiation is complete.
+ TestProtectUnprotect(CS_AES_CM_128_HMAC_SHA1_80, CS_AES_CM_128_HMAC_SHA1_80);
+
+ // Complete the negotiation.
+ EXPECT_TRUE(f2_.SetAnswer(answer, CS_LOCAL));
+ EXPECT_TRUE(f1_.SetAnswer(answer, CS_REMOTE));
+
+ EXPECT_FALSE(f1_.IsActive());
+ EXPECT_FALSE(f2_.IsActive());
+}
+
+// Test directly setting the params with AES_CM_128_HMAC_SHA1_80
+TEST_F(SrtpFilterTest, TestProtect_SetParamsDirect_AES_CM_128_HMAC_SHA1_80) {
+ EXPECT_TRUE(f1_.SetRtpParams(CS_AES_CM_128_HMAC_SHA1_80,
+ kTestKey1, kTestKeyLen,
+ CS_AES_CM_128_HMAC_SHA1_80,
+ kTestKey2, kTestKeyLen));
+ EXPECT_TRUE(f2_.SetRtpParams(CS_AES_CM_128_HMAC_SHA1_80,
+ kTestKey2, kTestKeyLen,
+ CS_AES_CM_128_HMAC_SHA1_80,
+ kTestKey1, kTestKeyLen));
+ EXPECT_TRUE(f1_.SetRtcpParams(CS_AES_CM_128_HMAC_SHA1_80,
+ kTestKey1, kTestKeyLen,
+ CS_AES_CM_128_HMAC_SHA1_80,
+ kTestKey2, kTestKeyLen));
+ EXPECT_TRUE(f2_.SetRtcpParams(CS_AES_CM_128_HMAC_SHA1_80,
+ kTestKey2, kTestKeyLen,
+ CS_AES_CM_128_HMAC_SHA1_80,
+ kTestKey1, kTestKeyLen));
+ EXPECT_TRUE(f1_.IsActive());
+ EXPECT_TRUE(f2_.IsActive());
+ TestProtectUnprotect(CS_AES_CM_128_HMAC_SHA1_80, CS_AES_CM_128_HMAC_SHA1_80);
+}
+
+// Test directly setting the params with AES_CM_128_HMAC_SHA1_32
+TEST_F(SrtpFilterTest, TestProtect_SetParamsDirect_AES_CM_128_HMAC_SHA1_32) {
+ EXPECT_TRUE(f1_.SetRtpParams(CS_AES_CM_128_HMAC_SHA1_32,
+ kTestKey1, kTestKeyLen,
+ CS_AES_CM_128_HMAC_SHA1_32,
+ kTestKey2, kTestKeyLen));
+ EXPECT_TRUE(f2_.SetRtpParams(CS_AES_CM_128_HMAC_SHA1_32,
+ kTestKey2, kTestKeyLen,
+ CS_AES_CM_128_HMAC_SHA1_32,
+ kTestKey1, kTestKeyLen));
+ EXPECT_TRUE(f1_.SetRtcpParams(CS_AES_CM_128_HMAC_SHA1_32,
+ kTestKey1, kTestKeyLen,
+ CS_AES_CM_128_HMAC_SHA1_32,
+ kTestKey2, kTestKeyLen));
+ EXPECT_TRUE(f2_.SetRtcpParams(CS_AES_CM_128_HMAC_SHA1_32,
+ kTestKey2, kTestKeyLen,
+ CS_AES_CM_128_HMAC_SHA1_32,
+ kTestKey1, kTestKeyLen));
+ EXPECT_TRUE(f1_.IsActive());
+ EXPECT_TRUE(f2_.IsActive());
+ TestProtectUnprotect(CS_AES_CM_128_HMAC_SHA1_32, CS_AES_CM_128_HMAC_SHA1_32);
+}
+
+// Test directly setting the params with bogus keys
+TEST_F(SrtpFilterTest, TestSetParamsKeyTooShort) {
+ EXPECT_FALSE(f1_.SetRtpParams(CS_AES_CM_128_HMAC_SHA1_80,
+ kTestKey1, kTestKeyLen - 1,
+ CS_AES_CM_128_HMAC_SHA1_80,
+ kTestKey1, kTestKeyLen - 1));
+ EXPECT_FALSE(f1_.SetRtcpParams(CS_AES_CM_128_HMAC_SHA1_80,
+ kTestKey1, kTestKeyLen - 1,
+ CS_AES_CM_128_HMAC_SHA1_80,
+ kTestKey1, kTestKeyLen - 1));
+}
+
+class SrtpSessionTest : public testing::Test {
+ protected:
+ virtual void SetUp() {
+ rtp_len_ = sizeof(kPcmuFrame);
+ rtcp_len_ = sizeof(kRtcpReport);
+ memcpy(rtp_packet_, kPcmuFrame, rtp_len_);
+ memcpy(rtcp_packet_, kRtcpReport, rtcp_len_);
+ }
+ void TestProtectRtp(const std::string& cs) {
+ int out_len = 0;
+ EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_,
+ sizeof(rtp_packet_), &out_len));
+ EXPECT_EQ(out_len, rtp_len_ + rtp_auth_tag_len(cs));
+ EXPECT_NE(0, memcmp(rtp_packet_, kPcmuFrame, rtp_len_));
+ rtp_len_ = out_len;
+ }
+ void TestProtectRtcp(const std::string& cs) {
+ int out_len = 0;
+ EXPECT_TRUE(s1_.ProtectRtcp(rtcp_packet_, rtcp_len_,
+ sizeof(rtcp_packet_), &out_len));
+ EXPECT_EQ(out_len, rtcp_len_ + 4 + rtcp_auth_tag_len(cs)); // NOLINT
+ EXPECT_NE(0, memcmp(rtcp_packet_, kRtcpReport, rtcp_len_));
+ rtcp_len_ = out_len;
+ }
+ void TestUnprotectRtp(const std::string& cs) {
+ int out_len = 0, expected_len = sizeof(kPcmuFrame);
+ EXPECT_TRUE(s2_.UnprotectRtp(rtp_packet_, rtp_len_, &out_len));
+ EXPECT_EQ(expected_len, out_len);
+ EXPECT_EQ(0, memcmp(rtp_packet_, kPcmuFrame, out_len));
+ }
+ void TestUnprotectRtcp(const std::string& cs) {
+ int out_len = 0, expected_len = sizeof(kRtcpReport);
+ EXPECT_TRUE(s2_.UnprotectRtcp(rtcp_packet_, rtcp_len_, &out_len));
+ EXPECT_EQ(expected_len, out_len);
+ EXPECT_EQ(0, memcmp(rtcp_packet_, kRtcpReport, out_len));
+ }
+ cricket::SrtpSession s1_;
+ cricket::SrtpSession s2_;
+ char rtp_packet_[sizeof(kPcmuFrame) + 10];
+ char rtcp_packet_[sizeof(kRtcpReport) + 4 + 10];
+ int rtp_len_;
+ int rtcp_len_;
+};
+
+// Test that we can set up the session and keys properly.
+TEST_F(SrtpSessionTest, TestGoodSetup) {
+ EXPECT_TRUE(s1_.SetSend(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
+ EXPECT_TRUE(s2_.SetRecv(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
+}
+
+// Test that we can't change the keys once set.
+TEST_F(SrtpSessionTest, TestBadSetup) {
+ EXPECT_TRUE(s1_.SetSend(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
+ EXPECT_TRUE(s2_.SetRecv(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
+ EXPECT_FALSE(s1_.SetSend(CS_AES_CM_128_HMAC_SHA1_80, kTestKey2, kTestKeyLen));
+ EXPECT_FALSE(s2_.SetRecv(CS_AES_CM_128_HMAC_SHA1_80, kTestKey2, kTestKeyLen));
+}
+
+// Test that we fail keys of the wrong length.
+TEST_F(SrtpSessionTest, TestKeysTooShort) {
+ EXPECT_FALSE(s1_.SetSend(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, 1));
+ EXPECT_FALSE(s2_.SetRecv(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, 1));
+}
+
+// Test that we can encrypt and decrypt RTP/RTCP using AES_CM_128_HMAC_SHA1_80.
+TEST_F(SrtpSessionTest, TestProtect_AES_CM_128_HMAC_SHA1_80) {
+ EXPECT_TRUE(s1_.SetSend(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
+ EXPECT_TRUE(s2_.SetRecv(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
+ TestProtectRtp(CS_AES_CM_128_HMAC_SHA1_80);
+ TestProtectRtcp(CS_AES_CM_128_HMAC_SHA1_80);
+ TestUnprotectRtp(CS_AES_CM_128_HMAC_SHA1_80);
+ TestUnprotectRtcp(CS_AES_CM_128_HMAC_SHA1_80);
+}
+
+// Test that we can encrypt and decrypt RTP/RTCP using AES_CM_128_HMAC_SHA1_32.
+TEST_F(SrtpSessionTest, TestProtect_AES_CM_128_HMAC_SHA1_32) {
+ EXPECT_TRUE(s1_.SetSend(CS_AES_CM_128_HMAC_SHA1_32, kTestKey1, kTestKeyLen));
+ EXPECT_TRUE(s2_.SetRecv(CS_AES_CM_128_HMAC_SHA1_32, kTestKey1, kTestKeyLen));
+ TestProtectRtp(CS_AES_CM_128_HMAC_SHA1_32);
+ TestProtectRtcp(CS_AES_CM_128_HMAC_SHA1_32);
+ TestUnprotectRtp(CS_AES_CM_128_HMAC_SHA1_32);
+ TestUnprotectRtcp(CS_AES_CM_128_HMAC_SHA1_32);
+}
+
+// Test that we fail to unprotect if someone tampers with the RTP/RTCP paylaods.
+TEST_F(SrtpSessionTest, TestTamperReject) {
+ int out_len;
+ EXPECT_TRUE(s1_.SetSend(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
+ EXPECT_TRUE(s2_.SetRecv(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
+ TestProtectRtp(CS_AES_CM_128_HMAC_SHA1_80);
+ TestProtectRtcp(CS_AES_CM_128_HMAC_SHA1_80);
+ rtp_packet_[0] = 0x12;
+ rtcp_packet_[1] = 0x34;
+ EXPECT_FALSE(s2_.UnprotectRtp(rtp_packet_, rtp_len_, &out_len));
+ EXPECT_FALSE(s2_.UnprotectRtcp(rtcp_packet_, rtcp_len_, &out_len));
+}
+
+// Test that we fail to unprotect if the payloads are not authenticated.
+TEST_F(SrtpSessionTest, TestUnencryptReject) {
+ int out_len;
+ EXPECT_TRUE(s1_.SetSend(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
+ EXPECT_TRUE(s2_.SetRecv(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
+ EXPECT_FALSE(s2_.UnprotectRtp(rtp_packet_, rtp_len_, &out_len));
+ EXPECT_FALSE(s2_.UnprotectRtcp(rtcp_packet_, rtcp_len_, &out_len));
+}
+
+// Test that we fail when using buffers that are too small.
+TEST_F(SrtpSessionTest, TestBuffersTooSmall) {
+ int out_len;
+ EXPECT_TRUE(s1_.SetSend(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
+ EXPECT_FALSE(s1_.ProtectRtp(rtp_packet_, rtp_len_,
+ sizeof(rtp_packet_) - 10, &out_len));
+ EXPECT_FALSE(s1_.ProtectRtcp(rtcp_packet_, rtcp_len_,
+ sizeof(rtcp_packet_) - 14, &out_len));
+}
+
+TEST_F(SrtpSessionTest, TestReplay) {
+ static const uint16 kMaxSeqnum = static_cast<uint16>(-1);
+ static const uint16 seqnum_big = 62275;
+ static const uint16 seqnum_small = 10;
+ static const uint16 replay_window = 1024;
+ int out_len;
+
+ EXPECT_TRUE(s1_.SetSend(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
+ EXPECT_TRUE(s2_.SetRecv(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
+
+ // Initial sequence number.
+ talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2, seqnum_big);
+ EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
+ &out_len));
+
+ // Replay within the 1024 window should succeed.
+ talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
+ seqnum_big - replay_window + 1);
+ EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
+ &out_len));
+
+ // Replay out side of the 1024 window should fail.
+ talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
+ seqnum_big - replay_window - 1);
+ EXPECT_FALSE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
+ &out_len));
+
+ // Increment sequence number to a small number.
+ talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2, seqnum_small);
+ EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
+ &out_len));
+
+ // Replay around 0 but out side of the 1024 window should fail.
+ talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
+ kMaxSeqnum + seqnum_small - replay_window - 1);
+ EXPECT_FALSE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
+ &out_len));
+
+ // Replay around 0 but within the 1024 window should succeed.
+ for (uint16 seqnum = 65000; seqnum < 65003; ++seqnum) {
+ talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2, seqnum);
+ EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
+ &out_len));
+ }
+
+ // Go back to normal sequence nubmer.
+ // NOTE: without the fix in libsrtp, this would fail. This is because
+ // without the fix, the loop above would keep incrementing local sequence
+ // number in libsrtp, eventually the new sequence number would go out side
+ // of the window.
+ talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
+ seqnum_small + 1);
+ EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
+ &out_len));
+}
+
+class SrtpStatTest
+ : public testing::Test,
+ public sigslot::has_slots<> {
+ public:
+ SrtpStatTest()
+ : ssrc_(0U),
+ mode_(-1),
+ error_(cricket::SrtpFilter::ERROR_NONE) {
+ srtp_stat_.SignalSrtpError.connect(this, &SrtpStatTest::OnSrtpError);
+ srtp_stat_.set_signal_silent_time(200);
+ }
+
+ protected:
+ void OnSrtpError(uint32 ssrc, cricket::SrtpFilter::Mode mode,
+ cricket::SrtpFilter::Error error) {
+ ssrc_ = ssrc;
+ mode_ = mode;
+ error_ = error;
+ }
+ void Reset() {
+ ssrc_ = 0U;
+ mode_ = -1;
+ error_ = cricket::SrtpFilter::ERROR_NONE;
+ }
+
+ cricket::SrtpStat srtp_stat_;
+ uint32 ssrc_;
+ int mode_;
+ cricket::SrtpFilter::Error error_;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(SrtpStatTest);
+};
+
+TEST_F(SrtpStatTest, TestProtectRtpError) {
+ Reset();
+ srtp_stat_.AddProtectRtpResult(1, err_status_ok);
+ EXPECT_EQ(0U, ssrc_);
+ EXPECT_EQ(-1, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_);
+ Reset();
+ srtp_stat_.AddProtectRtpResult(1, err_status_auth_fail);
+ EXPECT_EQ(1U, ssrc_);
+ EXPECT_EQ(cricket::SrtpFilter::PROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_AUTH, error_);
+ Reset();
+ srtp_stat_.AddProtectRtpResult(1, err_status_fail);
+ EXPECT_EQ(1U, ssrc_);
+ EXPECT_EQ(cricket::SrtpFilter::PROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_);
+ // Within 200ms, the error will not be triggered.
+ Reset();
+ srtp_stat_.AddProtectRtpResult(1, err_status_fail);
+ EXPECT_EQ(0U, ssrc_);
+ EXPECT_EQ(-1, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_);
+ // Now the error will be triggered again.
+ Reset();
+ talk_base::Thread::Current()->SleepMs(210);
+ srtp_stat_.AddProtectRtpResult(1, err_status_fail);
+ EXPECT_EQ(1U, ssrc_);
+ EXPECT_EQ(cricket::SrtpFilter::PROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_);
+}
+
+TEST_F(SrtpStatTest, TestUnprotectRtpError) {
+ Reset();
+ srtp_stat_.AddUnprotectRtpResult(1, err_status_ok);
+ EXPECT_EQ(0U, ssrc_);
+ EXPECT_EQ(-1, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_);
+ Reset();
+ srtp_stat_.AddUnprotectRtpResult(1, err_status_auth_fail);
+ EXPECT_EQ(1U, ssrc_);
+ EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_AUTH, error_);
+ Reset();
+ srtp_stat_.AddUnprotectRtpResult(1, err_status_replay_fail);
+ EXPECT_EQ(1U, ssrc_);
+ EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_REPLAY, error_);
+ Reset();
+ talk_base::Thread::Current()->SleepMs(210);
+ srtp_stat_.AddUnprotectRtpResult(1, err_status_replay_old);
+ EXPECT_EQ(1U, ssrc_);
+ EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_REPLAY, error_);
+ Reset();
+ srtp_stat_.AddUnprotectRtpResult(1, err_status_fail);
+ EXPECT_EQ(1U, ssrc_);
+ EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_);
+ // Within 200ms, the error will not be triggered.
+ Reset();
+ srtp_stat_.AddUnprotectRtpResult(1, err_status_fail);
+ EXPECT_EQ(0U, ssrc_);
+ EXPECT_EQ(-1, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_);
+ // Now the error will be triggered again.
+ Reset();
+ talk_base::Thread::Current()->SleepMs(210);
+ srtp_stat_.AddUnprotectRtpResult(1, err_status_fail);
+ EXPECT_EQ(1U, ssrc_);
+ EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_);
+}
+
+TEST_F(SrtpStatTest, TestProtectRtcpError) {
+ Reset();
+ srtp_stat_.AddProtectRtcpResult(err_status_ok);
+ EXPECT_EQ(-1, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_);
+ Reset();
+ srtp_stat_.AddProtectRtcpResult(err_status_auth_fail);
+ EXPECT_EQ(cricket::SrtpFilter::PROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_AUTH, error_);
+ Reset();
+ srtp_stat_.AddProtectRtcpResult(err_status_fail);
+ EXPECT_EQ(cricket::SrtpFilter::PROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_);
+ // Within 200ms, the error will not be triggered.
+ Reset();
+ srtp_stat_.AddProtectRtcpResult(err_status_fail);
+ EXPECT_EQ(-1, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_);
+ // Now the error will be triggered again.
+ Reset();
+ talk_base::Thread::Current()->SleepMs(210);
+ srtp_stat_.AddProtectRtcpResult(err_status_fail);
+ EXPECT_EQ(cricket::SrtpFilter::PROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_);
+}
+
+TEST_F(SrtpStatTest, TestUnprotectRtcpError) {
+ Reset();
+ srtp_stat_.AddUnprotectRtcpResult(err_status_ok);
+ EXPECT_EQ(-1, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_);
+ Reset();
+ srtp_stat_.AddUnprotectRtcpResult(err_status_auth_fail);
+ EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_AUTH, error_);
+ Reset();
+ srtp_stat_.AddUnprotectRtcpResult(err_status_replay_fail);
+ EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_REPLAY, error_);
+ Reset();
+ talk_base::Thread::Current()->SleepMs(210);
+ srtp_stat_.AddUnprotectRtcpResult(err_status_replay_fail);
+ EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_REPLAY, error_);
+ Reset();
+ srtp_stat_.AddUnprotectRtcpResult(err_status_fail);
+ EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_);
+ // Within 200ms, the error will not be triggered.
+ Reset();
+ srtp_stat_.AddUnprotectRtcpResult(err_status_fail);
+ EXPECT_EQ(-1, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_);
+ // Now the error will be triggered again.
+ Reset();
+ talk_base::Thread::Current()->SleepMs(210);
+ srtp_stat_.AddUnprotectRtcpResult(err_status_fail);
+ EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
+ EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_);
+}
diff --git a/talk/session/phone/ssrcmuxfilter.cc b/talk/session/phone/ssrcmuxfilter.cc
new file mode 100644
index 0000000..d81feab
--- /dev/null
+++ b/talk/session/phone/ssrcmuxfilter.cc
@@ -0,0 +1,90 @@
+/*
+ * libjingle
+ * Copyright 2004--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/session/phone/ssrcmuxfilter.h"
+
+#include <algorithm>
+
+#include "talk/base/logging.h"
+#include "talk/session/phone/rtputils.h"
+
+namespace cricket {
+
+static const uint32 kSsrc01 = 0x01;
+
+SsrcMuxFilter::SsrcMuxFilter() {
+}
+
+SsrcMuxFilter::~SsrcMuxFilter() {
+}
+
+bool SsrcMuxFilter::IsActive() const {
+ return !streams_.empty();
+}
+
+bool SsrcMuxFilter::DemuxPacket(const char* data, size_t len, bool rtcp) {
+ uint32 ssrc = 0;
+ if (!rtcp) {
+ GetRtpSsrc(data, len, &ssrc);
+ } else {
+ int pl_type = 0;
+ if (!GetRtcpType(data, len, &pl_type)) return false;
+ if (pl_type == kRtcpTypeSDES) {
+ // SDES packet parsing not supported.
+ LOG(LS_INFO) << "SDES packet received for demux.";
+ return true;
+ } else {
+ if (!GetRtcpSsrc(data, len, &ssrc)) return false;
+ if (ssrc == kSsrc01) {
+ // SSRC 1 has a special meaning and indicates generic feedback on
+ // some systems and should never be dropped. If it is forwarded
+ // incorrectly it will be ignored by lower layers anyway.
+ return true;
+ }
+ }
+ }
+ return FindStream(ssrc);
+}
+
+bool SsrcMuxFilter::AddStream(const StreamParams& stream) {
+ if (GetStreamBySsrc(streams_, stream.first_ssrc(), NULL)) {
+ LOG(LS_WARNING) << "Stream already added to filter";
+ return false;
+ }
+ streams_.push_back(stream);
+ return true;
+}
+
+bool SsrcMuxFilter::RemoveStream(uint32 ssrc) {
+ return RemoveStreamBySsrc(&streams_, ssrc);
+}
+
+bool SsrcMuxFilter::FindStream(uint32 ssrc) const {
+ return (GetStreamBySsrc(streams_, ssrc, NULL));
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/ssrcmuxfilter.h b/talk/session/phone/ssrcmuxfilter.h
new file mode 100644
index 0000000..2f28799
--- /dev/null
+++ b/talk/session/phone/ssrcmuxfilter.h
@@ -0,0 +1,67 @@
+/*
+ * libjingle
+ * Copyright 2004--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_SESSION_PHONE_SSRCMUXFILTER_H_
+#define TALK_SESSION_PHONE_SSRCMUXFILTER_H_
+
+#include <vector>
+
+#include "talk/base/basictypes.h"
+#include "talk/session/phone/streamparams.h"
+
+namespace cricket {
+
+// This class maintains list of recv SSRC's destined for cricket::BaseChannel.
+// In case of single RTP session and single transport channel, all session
+// ( or media) channels share a common transport channel. Hence they all get
+// SignalReadPacket when packet received on transport channel. This requires
+// cricket::BaseChannel to know all the valid sources, else media channel
+// will decode invalid packets.
+class SsrcMuxFilter {
+ public:
+ SsrcMuxFilter();
+ ~SsrcMuxFilter();
+
+ // Whether the rtp mux is active for a sdp session.
+ // Returns true if the filter contains a stream.
+ bool IsActive() const;
+ // Determines packet belongs to valid cricket::BaseChannel.
+ bool DemuxPacket(const char* data, size_t len, bool rtcp);
+ // Adding a valid source to the filter.
+ bool AddStream(const StreamParams& stream);
+ // Removes source from the filter.
+ bool RemoveStream(uint32 ssrc);
+ // Utility method added for unitest.
+ bool FindStream(uint32 ssrc) const;
+
+ private:
+ std::vector<StreamParams> streams_;
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_SSRCMUXFILTER_H_
diff --git a/talk/session/phone/ssrcmuxfilter_unittest.cc b/talk/session/phone/ssrcmuxfilter_unittest.cc
new file mode 100644
index 0000000..14f4f73
--- /dev/null
+++ b/talk/session/phone/ssrcmuxfilter_unittest.cc
@@ -0,0 +1,184 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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/base/gunit.h"
+#include "talk/session/phone/ssrcmuxfilter.h"
+
+static const int kSsrc1 = 0x1111;
+static const int kSsrc2 = 0x2222;
+static const int kSsrc3 = 0x3333;
+
+using cricket::StreamParams;
+
+// SSRC = 0x1111
+static const unsigned char kRtpPacketSsrc1[] = {
+ 0x80, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x11,
+};
+
+// SSRC = 0x2222
+static const unsigned char kRtpPacketSsrc2[] = {
+ 0x80, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22,
+};
+
+// SSRC = 0
+static const unsigned char kRtpPacketInvalidSsrc[] = {
+ 0x80, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+
+// invalid size
+static const unsigned char kRtpPacketTooSmall[] = {
+ 0x80, 0x80, 0x00, 0x00,
+};
+
+// PT = 200 = SR, len = 28, SSRC of sender = 0x0001
+// NTP TS = 0, RTP TS = 0, packet count = 0
+static const unsigned char kRtcpPacketSrSsrc01[] = {
+ 0x80, 0xC8, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+};
+
+// PT = 200 = SR, len = 28, SSRC of sender = 0x2222
+// NTP TS = 0, RTP TS = 0, packet count = 0
+static const unsigned char kRtcpPacketSrSsrc2[] = {
+ 0x80, 0xC8, 0x00, 0x1B, 0x00, 0x00, 0x22, 0x22,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+};
+
+// First packet - SR = PT = 200, len = 0, SSRC of sender = 0x1111
+// NTP TS = 0, RTP TS = 0, packet count = 0
+// second packet - SDES = PT = 202, count = 0, SSRC = 0x1111, cname len = 0
+static const unsigned char kRtcpPacketCompoundSrSdesSsrc1[] = {
+ 0x80, 0xC8, 0x00, 0x01, 0x00, 0x00, 0x11, 0x11,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x81, 0xCA, 0x00, 0x00, 0x00, 0x00, 0x11, 0x11, 0x01, 0x00,
+};
+
+// SDES = PT = 202, count = 0, SSRC = 0x2222, cname len = 0
+static const unsigned char kRtcpPacketSdesSsrc2[] = {
+ 0x81, 0xCA, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x01, 0x00,
+};
+
+// Packet has only mandatory fixed RTCP header
+static const unsigned char kRtcpPacketFixedHeaderOnly[] = {
+ 0x80, 0xC8, 0x00, 0x00,
+};
+
+// Small packet for SSRC demux.
+static const unsigned char kRtcpPacketTooSmall[] = {
+ 0x80, 0xC8, 0x00, 0x00, 0x00, 0x00,
+};
+
+// PT = 206, FMT = 1, Sender SSRC = 0x1111, Media SSRC = 0x1111
+// No FCI information is needed for PLI.
+static const unsigned char kRtcpPacketNonCompoundRtcpPliFeedback[] = {
+ 0x81, 0xCE, 0x00, 0x0C, 0x00, 0x00, 0x11, 0x11, 0x00, 0x00, 0x11, 0x11,
+};
+
+TEST(SsrcMuxFilterTest, AddRemoveStreamTest) {
+ cricket::SsrcMuxFilter ssrc_filter;
+ EXPECT_FALSE(ssrc_filter.IsActive());
+ EXPECT_TRUE(ssrc_filter.AddStream(StreamParams::CreateLegacy(kSsrc1)));
+ StreamParams stream2;
+ stream2.ssrcs.push_back(kSsrc2);
+ stream2.ssrcs.push_back(kSsrc3);
+ EXPECT_TRUE(ssrc_filter.AddStream(stream2));
+
+ EXPECT_TRUE(ssrc_filter.IsActive());
+ EXPECT_TRUE(ssrc_filter.FindStream(kSsrc1));
+ EXPECT_TRUE(ssrc_filter.FindStream(kSsrc2));
+ EXPECT_TRUE(ssrc_filter.FindStream(kSsrc3));
+ EXPECT_TRUE(ssrc_filter.RemoveStream(kSsrc1));
+ EXPECT_FALSE(ssrc_filter.FindStream(kSsrc1));
+ EXPECT_TRUE(ssrc_filter.RemoveStream(kSsrc3));
+ EXPECT_FALSE(ssrc_filter.RemoveStream(kSsrc2)); // Already removed.
+ EXPECT_FALSE(ssrc_filter.IsActive());
+}
+
+TEST(SsrcMuxFilterTest, RtpPacketTest) {
+ cricket::SsrcMuxFilter ssrc_filter;
+ EXPECT_TRUE(ssrc_filter.AddStream(StreamParams::CreateLegacy(kSsrc1)));
+ EXPECT_TRUE(ssrc_filter.DemuxPacket(
+ reinterpret_cast<const char*>(kRtpPacketSsrc1),
+ sizeof(kRtpPacketSsrc1), false));
+ EXPECT_TRUE(ssrc_filter.AddStream(StreamParams::CreateLegacy(kSsrc2)));
+ EXPECT_TRUE(ssrc_filter.DemuxPacket(
+ reinterpret_cast<const char*>(kRtpPacketSsrc2),
+ sizeof(kRtpPacketSsrc2), false));
+ EXPECT_TRUE(ssrc_filter.RemoveStream(kSsrc2));
+ EXPECT_FALSE(ssrc_filter.DemuxPacket(
+ reinterpret_cast<const char*>(kRtpPacketSsrc2),
+ sizeof(kRtpPacketSsrc2), false));
+ EXPECT_FALSE(ssrc_filter.DemuxPacket(
+ reinterpret_cast<const char*>(kRtpPacketInvalidSsrc),
+ sizeof(kRtpPacketInvalidSsrc), false));
+ EXPECT_FALSE(ssrc_filter.DemuxPacket(
+ reinterpret_cast<const char*>(kRtpPacketTooSmall),
+ sizeof(kRtpPacketTooSmall), false));
+}
+
+TEST(SsrcMuxFilterTest, RtcpPacketTest) {
+ cricket::SsrcMuxFilter ssrc_filter;
+ EXPECT_TRUE(ssrc_filter.AddStream(StreamParams::CreateLegacy(kSsrc1)));
+ EXPECT_TRUE(ssrc_filter.DemuxPacket(
+ reinterpret_cast<const char*>(kRtcpPacketCompoundSrSdesSsrc1),
+ sizeof(kRtcpPacketCompoundSrSdesSsrc1), true));
+ EXPECT_TRUE(ssrc_filter.AddStream(StreamParams::CreateLegacy(kSsrc2)));
+ EXPECT_TRUE(ssrc_filter.DemuxPacket(
+ reinterpret_cast<const char*>(kRtcpPacketSrSsrc2),
+ sizeof(kRtcpPacketSrSsrc2), true));
+ EXPECT_TRUE(ssrc_filter.DemuxPacket(
+ reinterpret_cast<const char*>(kRtcpPacketSdesSsrc2),
+ sizeof(kRtcpPacketSdesSsrc2), true));
+ EXPECT_TRUE(ssrc_filter.RemoveStream(kSsrc2));
+ // RTCP Packets other than SR and RR are demuxed regardless of SSRC.
+ EXPECT_TRUE(ssrc_filter.DemuxPacket(
+ reinterpret_cast<const char*>(kRtcpPacketSdesSsrc2),
+ sizeof(kRtcpPacketSdesSsrc2), true));
+ // RTCP Packets with 'special' SSRC 0x01 are demuxed also
+ EXPECT_TRUE(ssrc_filter.DemuxPacket(
+ reinterpret_cast<const char*>(kRtcpPacketSrSsrc01),
+ sizeof(kRtcpPacketSrSsrc01), true));
+ EXPECT_FALSE(ssrc_filter.DemuxPacket(
+ reinterpret_cast<const char*>(kRtcpPacketSrSsrc2),
+ sizeof(kRtcpPacketSrSsrc2), true));
+ EXPECT_FALSE(ssrc_filter.DemuxPacket(
+ reinterpret_cast<const char*>(kRtcpPacketFixedHeaderOnly),
+ sizeof(kRtcpPacketFixedHeaderOnly), true));
+ EXPECT_FALSE(ssrc_filter.DemuxPacket(
+ reinterpret_cast<const char*>(kRtcpPacketTooSmall),
+ sizeof(kRtcpPacketTooSmall), true));
+ EXPECT_TRUE(ssrc_filter.DemuxPacket(
+ reinterpret_cast<const char*>(kRtcpPacketNonCompoundRtcpPliFeedback),
+ sizeof(kRtcpPacketNonCompoundRtcpPliFeedback), true));
+}
diff --git a/talk/session/phone/streamparams.cc b/talk/session/phone/streamparams.cc
new file mode 100644
index 0000000..415c4c7
--- /dev/null
+++ b/talk/session/phone/streamparams.cc
@@ -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.
+ */
+
+#include "talk/session/phone/streamparams.h"
+
+namespace cricket {
+
+bool GetStreamBySsrc(const StreamParamsVec& streams, uint32 ssrc,
+ StreamParams* stream_out) {
+ for (StreamParamsVec::const_iterator stream = streams.begin();
+ stream != streams.end(); ++stream) {
+ if (stream->has_ssrc(ssrc)) {
+ if (stream_out != NULL)
+ *stream_out = *stream;
+ return true;
+ }
+ }
+ return false;
+}
+
+bool GetStreamByNickAndName(const StreamParamsVec& streams,
+ const std::string& nick,
+ const std::string& name,
+ StreamParams* stream_out) {
+ for (StreamParamsVec::const_iterator stream = streams.begin();
+ stream != streams.end(); ++stream) {
+ if (stream->nick == nick && stream->name == name) {
+ if (stream_out != NULL)
+ *stream_out = *stream;
+ return true;
+ }
+ }
+ return false;
+}
+
+bool RemoveStreamBySsrc(StreamParamsVec* streams, uint32 ssrc) {
+ bool ret = false;
+ for (StreamParamsVec::iterator stream = streams->begin();
+ stream != streams->end(); ) {
+ if (stream->has_ssrc(ssrc)) {
+ stream = streams->erase(stream);
+ ret = true;
+ } else {
+ ++stream;
+ }
+ }
+ return ret;
+}
+
+bool RemoveStreamByNickAndName(StreamParamsVec* streams,
+ const std::string& nick,
+ const std::string& name) {
+ bool ret = false;
+ for (StreamParamsVec::iterator stream = streams->begin();
+ stream != streams->end(); ) {
+ if (stream->nick == nick && stream->name == name) {
+ stream = streams->erase(stream);
+ ret = true;
+ } else {
+ ++stream;
+ }
+ }
+ return ret;
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/streamparams.h b/talk/session/phone/streamparams.h
new file mode 100644
index 0000000..e202f41
--- /dev/null
+++ b/talk/session/phone/streamparams.h
@@ -0,0 +1,148 @@
+/*
+ * 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 structures for describing SSRCs from a media source such
+// as a MediaStreamTrack when it is sent across an RTP session. Multiple media
+// sources may be sent across the same RTP session, each of them will be
+// described by one StreamParams object
+// SsrcGroup is used to describe the relationship between the SSRCs that
+// are used for this media source.
+// E.x: Consider a source that is sent as 3 simulcast streams
+// Let the simulcast elements have SSRC 10, 20, 30.
+// Let each simulcast element use FEC and let the protection packets have
+// SSRC 11,21,31.
+// To describe this 4 SsrcGroups are needed,
+// StreamParams would then contain ssrc = {10,11,20,21,30,31} and
+// ssrc_groups = {{SIM,{10,20,30}, {FEC,{10,11}, {FEC, {20,21}, {FEC {30,31}}}
+// Please see RFC 5576.
+
+#ifndef TALK_SESSION_PHONE_STREAMPARAMS_H_
+#define TALK_SESSION_PHONE_STREAMPARAMS_H_
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include "talk/base/basictypes.h"
+
+namespace cricket {
+
+struct SsrcGroup {
+ SsrcGroup(const std::string& usage, const std::vector<uint32>& ssrcs)
+ : semantics(usage), ssrcs(ssrcs) {
+ }
+
+ bool operator==(const SsrcGroup& other) const {
+ return (semantics == other.semantics && ssrcs == other.ssrcs);
+ }
+ bool operator!=(const SsrcGroup &other) const {
+ return !(*this == other);
+ }
+
+ std::string semantics; // e.g FIX, FEC, SIM.
+ std::vector<uint32> ssrcs; // SSRCs of this type.
+};
+
+struct StreamParams {
+ static StreamParams CreateLegacy(uint32 ssrc) {
+ StreamParams stream;
+ stream.ssrcs.push_back(ssrc);
+ return stream;
+ }
+ bool operator==(const StreamParams& other) const {
+ return (nick == other.nick &&
+ name == other.name &&
+ ssrcs == other.ssrcs &&
+ ssrc_groups == other.ssrc_groups &&
+ type == other.type &&
+ display == other.display &&
+ cname == other.cname &&
+ sync_label == sync_label);
+ }
+ bool operator!=(const StreamParams &other) const {
+ return !(*this == other);
+ }
+
+ uint32 first_ssrc() const {
+ if (ssrcs.empty()) {
+ return 0;
+ }
+
+ return ssrcs[0];
+ }
+ bool has_ssrcs() const {
+ return !ssrcs.empty();
+ }
+ bool has_ssrc(uint32 ssrc) const {
+ return std::find(ssrcs.begin(), ssrcs.end(), ssrc) != ssrcs.end();
+ }
+ void add_ssrc(uint32 ssrc) {
+ ssrcs.push_back(ssrc);
+ }
+
+ // Resource of the MUC jid of the participant of with this stream.
+ // For 1:1 calls, should be left empty (which means remote streams
+ // and local streams should not be mixed together).
+ std::string nick;
+ // Unique name of this source (unique per-nick, not for all nicks)
+ std::string name;
+ std::vector<uint32> ssrcs; // All SSRCs for this source
+ std::vector<SsrcGroup> ssrc_groups; // e.g. FID, FEC, SIM
+ // Examples: "camera", "screencast"
+ std::string type;
+ // Friendly name describing stream
+ std::string display;
+ std::string cname; // RTCP CNAME
+ std::string sync_label; // Friendly name of cname.
+};
+
+typedef std::vector<StreamParams> StreamParamsVec;
+
+// Finds the stream in streams with the specified ssrc.
+// If you are only interested in the stream exist it is ok to call this function
+// stream_out = NULL.
+bool GetStreamBySsrc(const StreamParamsVec& streams, uint32 ssrc,
+ StreamParams* stream_out);
+
+// Finds the stream in streams with the specified nick and name.
+// If you are only interested in the stream exist it is ok to call this function
+// stream_out = NULL.
+bool GetStreamByNickAndName(const StreamParamsVec& streams,
+ const std::string& nick,
+ const std::string& name,
+ StreamParams* stream_out);
+
+// Removes the stream with ssrc from streams. Returns true if a stream is
+// removed, false otherwise.
+bool RemoveStreamBySsrc(StreamParamsVec* streams, uint32 ssrc);
+bool RemoveStreamByNickAndName(StreamParamsVec* streams,
+ const std::string& nick,
+ const std::string& name);
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_STREAMPARAMS_H_
diff --git a/talk/session/phone/testdata/captured-320x240-2s-48.frames b/talk/session/phone/testdata/captured-320x240-2s-48.frames
new file mode 100644
index 0000000..292a170
--- /dev/null
+++ b/talk/session/phone/testdata/captured-320x240-2s-48.frames
Binary files differ
diff --git a/talk/session/phone/testdata/h264-svc-99-640x360.rtpdump b/talk/session/phone/testdata/h264-svc-99-640x360.rtpdump
new file mode 100644
index 0000000..ffa521d
--- /dev/null
+++ b/talk/session/phone/testdata/h264-svc-99-640x360.rtpdump
Binary files differ
diff --git a/talk/session/phone/testutils.cc b/talk/session/phone/testutils.cc
new file mode 100644
index 0000000..f427f96
--- /dev/null
+++ b/talk/session/phone/testutils.cc
@@ -0,0 +1,370 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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/session/phone/testutils.h"
+
+#include <math.h>
+
+#ifdef HAVE_YUV
+#include "libyuv/compare.h"
+#endif
+#include "talk/base/bytebuffer.h"
+#include "talk/base/fileutils.h"
+#include "talk/base/gunit.h"
+#include "talk/base/pathutils.h"
+#include "talk/base/stream.h"
+#include "talk/base/stringutils.h"
+#include "talk/session/phone/rtpdump.h"
+#include "talk/session/phone/videocapturer.h"
+#include "talk/session/phone/videoframe.h"
+
+namespace cricket {
+
+/////////////////////////////////////////////////////////////////////////
+// Implementation of RawRtpPacket
+/////////////////////////////////////////////////////////////////////////
+void RawRtpPacket::WriteToByteBuffer(
+ uint32 in_ssrc, talk_base::ByteBuffer *buf) const {
+ if (!buf) return;
+
+ buf->WriteUInt8(ver_to_cc);
+ buf->WriteUInt8(m_to_pt);
+ buf->WriteUInt16(sequence_number);
+ buf->WriteUInt32(timestamp);
+ buf->WriteUInt32(in_ssrc);
+ buf->WriteBytes(payload, sizeof(payload));
+}
+
+bool RawRtpPacket::ReadFromByteBuffer(talk_base::ByteBuffer* buf) {
+ if (!buf) return false;
+
+ bool ret = true;
+ ret &= buf->ReadUInt8(&ver_to_cc);
+ ret &= buf->ReadUInt8(&m_to_pt);
+ ret &= buf->ReadUInt16(&sequence_number);
+ ret &= buf->ReadUInt32(×tamp);
+ ret &= buf->ReadUInt32(&ssrc);
+ ret &= buf->ReadBytes(payload, sizeof(payload));
+ return ret;
+}
+
+bool RawRtpPacket::SameExceptSeqNumTimestampSsrc(
+ const RawRtpPacket& packet, uint16 seq, uint32 ts, uint32 ssc) const {
+ return sequence_number == seq &&
+ timestamp == ts &&
+ ver_to_cc == packet.ver_to_cc &&
+ m_to_pt == packet.m_to_pt &&
+ ssrc == ssc &&
+ 0 == memcmp(payload, packet.payload, sizeof(payload));
+}
+
+/////////////////////////////////////////////////////////////////////////
+// Implementation of RawRtcpPacket
+/////////////////////////////////////////////////////////////////////////
+void RawRtcpPacket::WriteToByteBuffer(talk_base::ByteBuffer *buf) const {
+ if (!buf) return;
+
+ buf->WriteUInt8(ver_to_count);
+ buf->WriteUInt8(type);
+ buf->WriteUInt16(length);
+ buf->WriteBytes(payload, sizeof(payload));
+}
+
+bool RawRtcpPacket::ReadFromByteBuffer(talk_base::ByteBuffer* buf) {
+ if (!buf) return false;
+
+ bool ret = true;
+ ret &= buf->ReadUInt8(&ver_to_count);
+ ret &= buf->ReadUInt8(&type);
+ ret &= buf->ReadUInt16(&length);
+ ret &= buf->ReadBytes(payload, sizeof(payload));
+ return ret;
+}
+
+bool RawRtcpPacket::EqualsTo(const RawRtcpPacket& packet) const {
+ return ver_to_count == packet.ver_to_count &&
+ type == packet.type &&
+ length == packet.length &&
+ 0 == memcmp(payload, packet.payload, sizeof(payload));
+}
+
+/////////////////////////////////////////////////////////////////////////
+// Implementation of class RtpTestUtility
+/////////////////////////////////////////////////////////////////////////
+const RawRtpPacket RtpTestUtility::kTestRawRtpPackets[] = {
+ {0x80, 0, 0, 0, RtpTestUtility::kDefaultSsrc, "RTP frame 0"},
+ {0x80, 0, 1, 30, RtpTestUtility::kDefaultSsrc, "RTP frame 1"},
+ {0x80, 0, 2, 30, RtpTestUtility::kDefaultSsrc, "RTP frame 1"},
+ {0x80, 0, 3, 60, RtpTestUtility::kDefaultSsrc, "RTP frame 2"}
+};
+const RawRtcpPacket RtpTestUtility::kTestRawRtcpPackets[] = {
+ // The Version is 2, the Length is 2, and the payload has 8 bytes.
+ {0x80, 0, 2, "RTCP0000"},
+ {0x80, 0, 2, "RTCP0001"},
+ {0x80, 0, 2, "RTCP0002"},
+ {0x80, 0, 2, "RTCP0003"},
+};
+
+size_t RtpTestUtility::GetTestPacketCount() {
+ return talk_base::_min(
+ ARRAY_SIZE(kTestRawRtpPackets),
+ ARRAY_SIZE(kTestRawRtcpPackets));
+}
+
+bool RtpTestUtility::WriteTestPackets(
+ size_t count, bool rtcp, uint32 rtp_ssrc, RtpDumpWriter* writer) {
+ if (!writer || count > GetTestPacketCount()) return false;
+
+ bool result = true;
+ uint32 elapsed_time_ms = 0;
+ for (size_t i = 0; i < count && result; ++i) {
+ talk_base::ByteBuffer buf;
+ if (rtcp) {
+ kTestRawRtcpPackets[i].WriteToByteBuffer(&buf);
+ } else {
+ kTestRawRtpPackets[i].WriteToByteBuffer(rtp_ssrc, &buf);
+ }
+
+ RtpDumpPacket dump_packet(buf.Data(), buf.Length(), elapsed_time_ms, rtcp);
+ elapsed_time_ms += kElapsedTimeInterval;
+ result &= (talk_base::SR_SUCCESS == writer->WritePacket(dump_packet));
+ }
+ return result;
+}
+
+bool RtpTestUtility::VerifyTestPacketsFromStream(
+ size_t count, talk_base::StreamInterface* stream, uint32 ssrc) {
+ if (!stream) return false;
+
+ uint32 prev_elapsed_time = 0;
+ bool result = true;
+ stream->Rewind();
+ RtpDumpLoopReader reader(stream);
+ for (size_t i = 0; i < count && result; ++i) {
+ // Which loop and which index in the loop are we reading now.
+ size_t loop = i / GetTestPacketCount();
+ size_t index = i % GetTestPacketCount();
+
+ RtpDumpPacket packet;
+ result &= (talk_base::SR_SUCCESS == reader.ReadPacket(&packet));
+ // Check the elapsed time of the dump packet.
+ result &= (packet.elapsed_time >= prev_elapsed_time);
+ prev_elapsed_time = packet.elapsed_time;
+
+ // Check the RTP or RTCP packet.
+ talk_base::ByteBuffer buf(reinterpret_cast<const char*>(&packet.data[0]),
+ packet.data.size());
+ if (packet.is_rtcp) {
+ // RTCP packet.
+ RawRtcpPacket rtcp_packet;
+ result &= rtcp_packet.ReadFromByteBuffer(&buf);
+ result &= rtcp_packet.EqualsTo(kTestRawRtcpPackets[index]);
+ } else {
+ // RTP packet.
+ RawRtpPacket rtp_packet;
+ result &= rtp_packet.ReadFromByteBuffer(&buf);
+ result &= rtp_packet.SameExceptSeqNumTimestampSsrc(
+ kTestRawRtpPackets[index],
+ kTestRawRtpPackets[index].sequence_number +
+ loop * GetTestPacketCount(),
+ kTestRawRtpPackets[index].timestamp + loop * kRtpTimestampIncrease,
+ ssrc);
+ }
+ }
+
+ stream->Rewind();
+ return result;
+}
+
+bool RtpTestUtility::VerifyPacket(const RtpDumpPacket* dump,
+ const RawRtpPacket* raw,
+ bool header_only) {
+ if (!dump || !raw) return false;
+
+ talk_base::ByteBuffer buf;
+ raw->WriteToByteBuffer(RtpTestUtility::kDefaultSsrc, &buf);
+
+ if (header_only) {
+ size_t header_len = 0;
+ dump->GetRtpHeaderLen(&header_len);
+ return header_len == dump->data.size() &&
+ buf.Length() > dump->data.size() &&
+ 0 == memcmp(buf.Data(), &dump->data[0], dump->data.size());
+ } else {
+ return buf.Length() == dump->data.size() &&
+ 0 == memcmp(buf.Data(), &dump->data[0], dump->data.size());
+ }
+}
+
+// Implementation of VideoCaptureListener.
+VideoCapturerListener::VideoCapturerListener(VideoCapturer* capturer)
+ : start_result_(CR_PENDING),
+ frame_count_(0),
+ frame_fourcc_(0),
+ frame_width_(0),
+ frame_height_(0),
+ frame_size_(0),
+ resolution_changed_(false) {
+ capturer->SignalStartResult.connect(this,
+ &VideoCapturerListener::OnStartResult);
+ capturer->SignalFrameCaptured.connect(this,
+ &VideoCapturerListener::OnFrameCaptured);
+ capturer->SignalCaptureEvent.connect(this,
+ &VideoCapturerListener::OnCaptureEvent);
+}
+
+void VideoCapturerListener::OnStartResult(VideoCapturer* capturer,
+ CaptureResult result) {
+ start_result_ = result;
+}
+
+void VideoCapturerListener::OnFrameCaptured(VideoCapturer* capturer,
+ const CapturedFrame* frame) {
+ ++frame_count_;
+ if (1 == frame_count_) {
+ frame_fourcc_ = frame->fourcc;
+ frame_width_ = frame->width;
+ frame_height_ = frame->height;
+ frame_size_ = frame->data_size;
+ } else if (frame_width_ != frame->width || frame_height_ != frame->height) {
+ resolution_changed_ = true;
+ }
+}
+
+void VideoCapturerListener::OnCaptureEvent(VideoCapturer* capturer,
+ CaptureEvent ev) {
+}
+
+
+// Returns the absolute path to a file in the testdata/ directory.
+std::string GetTestFilePath(const std::string& filename) {
+ // Locate test data directory.
+ talk_base::Pathname path = GetTalkDirectory();
+ EXPECT_FALSE(path.empty()); // must be run from inside "talk"
+ path.AppendFolder("session");
+ path.AppendFolder("phone");
+ path.AppendFolder("testdata");
+ path.SetFilename(filename);
+ return path.pathname();
+}
+
+// PSNR formula: psnr = 10 * log10 (Peak Signal^2 / mse)
+// sse is set to a small number for identical frames or sse == 0
+double ComputePSNR(double sse, double size) {
+ if (sse <= 0.)
+ sse = 65025.0 * size / pow(10., 128./10.); // produces max PSNR of 128
+ return 10.0 * log10(65025.0 * size / sse);
+}
+
+double ComputeSumSquareError(const uint8 *org, const uint8 *rec, int size) {
+#ifdef HAVE_YUV
+ return static_cast<double>(libyuv::ComputeSumSquareError(org, rec, size));
+#else
+ double sse = 0.;
+ for (int j = 0; j < size; ++j) {
+ const int diff = static_cast<int>(org[j]) - static_cast<int>(rec[j]);
+ sse += static_cast<double>(diff * diff);
+ }
+ return sse;
+#endif
+}
+
+// Loads the image with the specified prefix and size into |out|.
+bool LoadPlanarYuvTestImage(const std::string& prefix,
+ int width, int height, uint8* out) {
+ std::stringstream ss;
+ ss << prefix << "." << width << "x" << height << "_P420.yuv";
+
+ talk_base::scoped_ptr<talk_base::FileStream> stream(
+ talk_base::Filesystem::OpenFile(talk_base::Pathname(
+ GetTestFilePath(ss.str())), "rb"));
+ if (!stream.get()) {
+ return false;
+ }
+
+ talk_base::StreamResult res =
+ stream->ReadAll(out, I420_SIZE(width, height), NULL, NULL);
+ return (res == talk_base::SR_SUCCESS);
+}
+
+// Dumps the YUV image out to a file, for visual inspection.
+// PYUV tool can be used to view dump files.
+void DumpPlanarYuvTestImage(const std::string& prefix, const uint8* img,
+ int w, int h) {
+ talk_base::FileStream fs;
+ char filename[256];
+ talk_base::sprintfn(filename, sizeof(filename), "%s.%dx%d_P420.yuv",
+ prefix.c_str(), w, h);
+ fs.Open(filename, "wb", NULL);
+ fs.Write(img, I420_SIZE(w, h), NULL, NULL);
+}
+
+// Dumps the ARGB image out to a file, for visual inspection.
+// ffplay tool can be used to view dump files.
+void DumpPlanarArgbTestImage(const std::string& prefix, const uint8* img,
+ int w, int h) {
+ talk_base::FileStream fs;
+ char filename[256];
+ talk_base::sprintfn(filename, sizeof(filename), "%s.%dx%d_ARGB.raw",
+ prefix.c_str(), w, h);
+ fs.Open(filename, "wb", NULL);
+ fs.Write(img, ARGB_SIZE(w, h), NULL, NULL);
+}
+
+bool VideoFrameEqual(const VideoFrame* frame0, const VideoFrame* frame1) {
+ const uint8* y0 = frame0->GetYPlane();
+ const uint8* u0 = frame0->GetUPlane();
+ const uint8* v0 = frame0->GetVPlane();
+ const uint8* y1 = frame1->GetYPlane();
+ const uint8* u1 = frame1->GetUPlane();
+ const uint8* v1 = frame1->GetVPlane();
+
+ for (size_t i = 0; i < frame0->GetHeight(); ++i) {
+ if (0 != memcmp(y0, y1, frame0->GetWidth())) {
+ return false;
+ }
+ y0 += frame0->GetYPitch();
+ y1 += frame1->GetYPitch();
+ }
+
+ for (size_t i = 0; i < frame0->GetChromaHeight(); ++i) {
+ if (0 != memcmp(u0, u1, frame0->GetChromaWidth())) {
+ return false;
+ }
+ if (0 != memcmp(v0, v1, frame0->GetChromaWidth())) {
+ return false;
+ }
+ u0 += frame0->GetUPitch();
+ v0 += frame0->GetVPitch();
+ u1 += frame1->GetUPitch();
+ v1 += frame1->GetVPitch();
+ }
+
+ return true;
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/testutils.h b/talk/session/phone/testutils.h
new file mode 100644
index 0000000..f5556e7
--- /dev/null
+++ b/talk/session/phone/testutils.h
@@ -0,0 +1,209 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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_SESSION_PHONE_TESTUTILS_H_
+#define TALK_SESSION_PHONE_TESTUTILS_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/base/basictypes.h"
+#include "talk/base/sigslot.h"
+#include "talk/base/window.h"
+#include "talk/session/phone/mediachannel.h"
+#include "talk/session/phone/videocommon.h"
+#include "talk/session/phone/videocapturer.h"
+
+namespace talk_base {
+class ByteBuffer;
+class StreamInterface;
+}
+
+namespace cricket {
+
+// Returns size of 420 image with rounding on chroma for odd sizes.
+#define I420_SIZE(w, h) (w * h + (((w + 1) / 2) * ((h + 1) / 2)) * 2)
+// Returns size of ARGB image.
+#define ARGB_SIZE(w, h) (w * h * 4)
+
+template <class T> inline std::vector<T> MakeVector(const T a[], size_t s) {
+ return std::vector<T>(a, a + s);
+}
+#define MAKE_VECTOR(a) cricket::MakeVector(a, ARRAY_SIZE(a))
+
+struct RtpDumpPacket;
+class RtpDumpWriter;
+class VideoFrame;
+
+struct RawRtpPacket {
+ void WriteToByteBuffer(uint32 in_ssrc, talk_base::ByteBuffer* buf) const;
+ bool ReadFromByteBuffer(talk_base::ByteBuffer* buf);
+ // Check if this packet is the same as the specified packet except the
+ // sequence number and timestamp, which should be the same as the specified
+ // parameters.
+ bool SameExceptSeqNumTimestampSsrc(
+ const RawRtpPacket& packet, uint16 seq, uint32 ts, uint32 ssc) const;
+ int size() const { return 28; }
+
+ uint8 ver_to_cc;
+ uint8 m_to_pt;
+ uint16 sequence_number;
+ uint32 timestamp;
+ uint32 ssrc;
+ char payload[16];
+};
+
+struct RawRtcpPacket {
+ void WriteToByteBuffer(talk_base::ByteBuffer* buf) const;
+ bool ReadFromByteBuffer(talk_base::ByteBuffer* buf);
+ bool EqualsTo(const RawRtcpPacket& packet) const;
+
+ uint8 ver_to_count;
+ uint8 type;
+ uint16 length;
+ char payload[16];
+};
+
+class RtpTestUtility {
+ public:
+ static size_t GetTestPacketCount();
+
+ // Write the first count number of kTestRawRtcpPackets or kTestRawRtpPackets,
+ // depending on the flag rtcp. If it is RTP, use the specified SSRC. Return
+ // true if successful.
+ static bool WriteTestPackets(
+ size_t count, bool rtcp, uint32 rtp_ssrc, RtpDumpWriter* writer);
+
+ // Loop read the first count number of packets from the specified stream.
+ // Verify the elapsed time of the dump packets increase monotonically. If the
+ // stream is a RTP stream, verify the RTP sequence number, timestamp, and
+ // payload. If the stream is a RTCP stream, verify the RTCP header and
+ // payload.
+ static bool VerifyTestPacketsFromStream(
+ size_t count, talk_base::StreamInterface* stream, uint32 ssrc);
+
+ // Verify the dump packet is the same as the raw RTP packet.
+ static bool VerifyPacket(const RtpDumpPacket* dump,
+ const RawRtpPacket* raw,
+ bool header_only);
+
+ static const uint32 kDefaultSsrc = 1;
+ static const uint32 kRtpTimestampIncrease = 90;
+ static const uint32 kDefaultTimeIncrease = 30;
+ static const uint32 kElapsedTimeInterval = 10;
+ static const RawRtpPacket kTestRawRtpPackets[];
+ static const RawRtcpPacket kTestRawRtcpPackets[];
+
+ private:
+ RtpTestUtility() {}
+};
+
+// Test helper for testing VideoCapturer implementations.
+class VideoCapturerListener : public sigslot::has_slots<> {
+ public:
+ explicit VideoCapturerListener(VideoCapturer* cap);
+
+ CaptureResult start_result() const { return start_result_; }
+ int frame_count() const { return frame_count_; }
+ uint32 frame_fourcc() const { return frame_fourcc_; }
+ int frame_width() const { return frame_width_; }
+ int frame_height() const { return frame_height_; }
+ uint32 frame_size() const { return frame_size_; }
+ bool resolution_changed() const { return resolution_changed_; }
+
+ void OnStartResult(VideoCapturer* capturer, CaptureResult result);
+ void OnFrameCaptured(VideoCapturer* capturer, const CapturedFrame* frame);
+ void OnCaptureEvent(VideoCapturer* capturer, CaptureEvent ev);
+
+ private:
+ CaptureResult start_result_;
+ int frame_count_;
+ uint32 frame_fourcc_;
+ int frame_width_;
+ int frame_height_;
+ uint32 frame_size_;
+ bool resolution_changed_;
+};
+
+class ScreencastEventCatcher : public sigslot::has_slots<> {
+ public:
+ ScreencastEventCatcher() : ssrc_(0), ev_(talk_base::WE_RESIZE) { }
+ uint32 ssrc() const { return ssrc_; }
+ talk_base::WindowEvent event() const { return ev_; }
+ void OnEvent(uint32 ssrc, talk_base::WindowEvent ev) {
+ ssrc_ = ssrc;
+ ev_ = ev;
+ }
+ private:
+ uint32 ssrc_;
+ talk_base::WindowEvent ev_;
+};
+
+class VideoMediaErrorCatcher : public sigslot::has_slots<> {
+ public:
+ VideoMediaErrorCatcher() : ssrc_(0), error_(VideoMediaChannel::ERROR_NONE) { }
+ uint32 ssrc() const { return ssrc_; }
+ VideoMediaChannel::Error error() const { return error_; }
+ void OnError(uint32 ssrc, VideoMediaChannel::Error error) {
+ ssrc_ = ssrc;
+ error_ = error;
+ }
+ private:
+ uint32 ssrc_;
+ VideoMediaChannel::Error error_;
+};
+
+// Returns the absolute path to a file in the testdata/ directory.
+std::string GetTestFilePath(const std::string& filename);
+
+// PSNR formula: psnr = 10 * log10 (Peak Signal^2 / mse)
+// sse is set to a small number for identical frames or sse == 0
+double ComputePSNR(double sse, double size);
+
+double ComputeSumSquareError(const uint8 *org, const uint8 *rec,
+ int size);
+
+// Loads the image with the specified prefix and size into |out|.
+bool LoadPlanarYuvTestImage(const std::string& prefix,
+ int width, int height, uint8* out);
+
+// Dumps the YUV image out to a file, for visual inspection.
+// PYUV tool can be used to view dump files.
+void DumpPlanarYuvTestImage(const std::string& prefix, const uint8* img,
+ int w, int h);
+
+// Dumps the ARGB image out to a file, for visual inspection.
+// ffplay tool can be used to view dump files.
+void DumpPlanarArgbTestImage(const std::string& prefix, const uint8* img,
+ int w, int h);
+
+// Compare two I420 frames.
+bool VideoFrameEqual(const VideoFrame* frame0, const VideoFrame* frame1);
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_TESTUTILS_H_
diff --git a/talk/session/phone/videoadapter.cc b/talk/session/phone/videoadapter.cc
new file mode 100644
index 0000000..4313fc7
--- /dev/null
+++ b/talk/session/phone/videoadapter.cc
@@ -0,0 +1,497 @@
+// libjingle
+// Copyright 2010 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/session/phone/videoadapter.h"
+
+#include <limits.h>
+
+#include "talk/base/logging.h"
+#include "talk/base/timeutils.h"
+#include "talk/session/phone/videoframe.h"
+
+namespace cricket {
+
+// TODO: Make downgrades settable
+static const int kMaxCpuDowngrades = 2; // Downgrade at most 2 times for CPU.
+static const int kDefaultDowngradeWaitTimeMs = 2000;
+
+// Cpu system load thresholds relative to max cpus.
+static const float kHighSystemThreshold = 0.95f;
+static const float kLowSystemThreshold = 0.75f;
+
+// Cpu process load thresholds relative to current cpus.
+static const float kMediumProcessThreshold = 0.50f;
+
+// TODO: Consider making scale factor table settable, to allow
+// application to select quality vs performance tradeoff.
+// List of scale factors that adapter will scale by.
+#if defined(IOS) || defined(ANDROID)
+// Mobile needs 1/4 scale for VGA (640x360) to QQVGA (160x90)
+// or 1/4 scale for HVGA (480x270) to QQHVGA (120x67)
+static const int kMinNumPixels = 120 * 67;
+static float kScaleFactors[] = {
+ 1.f, // full size
+ 3.f/4.f, // 3/4 scale
+ 1.f/2.f, // 1/2 scale
+ 3.f/8.f, // 3/8 scale
+ 1.f/4.f, // 1/4 scale
+};
+#else
+// PC needs 1/8 scale for HD (1280x720) to QQVGA (160x90)
+static const int kMinNumPixels = 160 * 100;
+static float kScaleFactors[] = {
+ 1.f, // full size
+ 3.f/4.f, // 3/4 scale
+ 1.f/2.f, // 1/2 scale
+ 3.f/8.f, // 3/8 scale
+ 1.f/4.f, // 1/4 scale
+ 3.f/16.f, // 3/16 scale
+ 1.f/8.f // 1/8 scale
+};
+#endif
+
+// Find scale factor that applied to width and height, is best match
+// to num_pixels.
+float VideoAdapter::FindClosestScale(int width, int height,
+ int target_num_pixels) {
+ if (!target_num_pixels) {
+ return 0.f;
+ }
+ int best_distance = INT_MAX;
+ int best_index = 0; // default to unscaled
+ for (size_t i = 0u; i < ARRAY_SIZE(kScaleFactors); ++i) {
+ int test_num_pixels = static_cast<int>(width * kScaleFactors[i] *
+ height * kScaleFactors[i]);
+ int diff = test_num_pixels - target_num_pixels;
+ if (diff < 0) {
+ diff = -diff;
+ }
+ if (diff < best_distance) {
+ best_distance = diff;
+ best_index = i;
+ if (!best_distance) { // Found exact match
+ break;
+ }
+ }
+ }
+ return kScaleFactors[best_index];
+}
+
+// There are several frame sizes used by Adapter. This explains them
+// input_format - set once by server to frame size expected from the camera.
+// output_format - size that output would like to be. Includes framerate.
+// output_num_pixels - size that output should be constrained to. Used to
+// compute output_format from in_frame.
+// in_frame - actual camera captured frame size, which is typically the same
+// as input_format. This can also be rotated or cropped for aspect ratio.
+// out_frame - actual frame output by adapter. Should be a direct scale of
+// in_frame maintaining rotation and aspect ratio.
+// OnOutputFormatRequest - server requests you send this resolution based on
+// view requests.
+// OnEncoderResolutionRequest - encoder requests you send this resolution based
+// on bandwidth
+// OnCpuLoadUpdated - cpu monitor requests you send this resolution based on
+// cpu load.
+
+///////////////////////////////////////////////////////////////////////
+// Implementation of VideoAdapter
+VideoAdapter::VideoAdapter()
+ : output_num_pixels_(0),
+ black_output_(false),
+ is_black_(false),
+ drop_frame_count_(0) {
+}
+
+VideoAdapter::~VideoAdapter() {
+}
+
+// TODO: Consider SetInputFormat and SetOutputFormat without
+// VideoFormat.
+void VideoAdapter::SetInputFormat(const VideoFormat& format) {
+ talk_base::CritScope cs(&critical_section_);
+ input_format_ = format;
+ output_format_.interval = talk_base::_max(
+ output_format_.interval, input_format_.interval);
+}
+
+void VideoAdapter::SetOutputFormat(const VideoFormat& format) {
+ talk_base::CritScope cs(&critical_section_);
+ output_format_ = format;
+ output_num_pixels_ = output_format_.width * output_format_.height;
+ output_format_.interval = talk_base::_max(
+ output_format_.interval, input_format_.interval);
+ drop_frame_count_ = 0;
+}
+
+const VideoFormat& VideoAdapter::input_format() {
+ talk_base::CritScope cs(&critical_section_);
+ return input_format_;
+}
+
+const VideoFormat& VideoAdapter::output_format() {
+ talk_base::CritScope cs(&critical_section_);
+ return output_format_;
+}
+
+void VideoAdapter::SetBlackOutput(bool black) {
+ talk_base::CritScope cs(&critical_section_);
+ black_output_ = black;
+}
+
+// Constrain output resolution to this many pixels overall
+void VideoAdapter::SetOutputNumPixels(int num_pixels) {
+ output_num_pixels_ = num_pixels;
+}
+
+int VideoAdapter::GetOutputNumPixels() const {
+ return output_num_pixels_;
+}
+
+bool VideoAdapter::AdaptFrame(const VideoFrame* in_frame,
+ const VideoFrame** out_frame) {
+ talk_base::CritScope cs(&critical_section_);
+
+ if (!in_frame || !out_frame || input_format_.IsSize0x0()) {
+ return false;
+ }
+
+ // Drop the input frame if necessary.
+ bool should_drop = false;
+ if (!output_num_pixels_) {
+ // Drop all frames as the output format is 0x0.
+ should_drop = true;
+ } else {
+ // Drop some frames based on the ratio of the input fps and the output fps.
+ // We assume that the output fps is a factor of the input fps. In other
+ // words, the output interval is divided by the input interval evenly.
+ should_drop = (drop_frame_count_ > 0);
+ if (input_format_.interval > 0 &&
+ output_format_.interval > input_format_.interval) {
+ ++drop_frame_count_;
+ drop_frame_count_ %= output_format_.interval / input_format_.interval;
+ }
+ }
+
+ if (output_num_pixels_) {
+ float scale = VideoAdapter::FindClosestScale(in_frame->GetWidth(),
+ in_frame->GetHeight(),
+ output_num_pixels_);
+ output_format_.width = static_cast<int>(in_frame->GetWidth() * scale);
+ output_format_.height = static_cast<int>(in_frame->GetHeight() * scale);
+ }
+
+ if (should_drop) {
+ *out_frame = NULL;
+ return true;
+ }
+
+ if (!StretchToOutputFrame(in_frame)) {
+ return false;
+ }
+
+ *out_frame = output_frame_.get();
+ return true;
+}
+
+bool VideoAdapter::StretchToOutputFrame(const VideoFrame* in_frame) {
+ int output_width = output_format_.width;
+ int output_height = output_format_.height;
+
+ // Create and stretch the output frame if it has not been created yet or its
+ // size is not same as the expected.
+ bool stretched = false;
+ if (!output_frame_.get() ||
+ output_frame_->GetWidth() != static_cast<size_t>(output_width) ||
+ output_frame_->GetHeight() != static_cast<size_t>(output_height)) {
+ output_frame_.reset(
+ in_frame->Stretch(output_width, output_height, true, true));
+ if (!output_frame_.get()) {
+ LOG(LS_WARNING) << "Adapter failed to stretch frame to "
+ << output_width << "x" << output_height;
+ return false;
+ }
+ stretched = true;
+ is_black_ = false;
+ }
+
+ if (!black_output_) {
+ if (!stretched) {
+ // The output frame does not need to be blacken and has not been stretched
+ // from the input frame yet, stretch the input frame. This is the most
+ // common case.
+ in_frame->StretchToFrame(output_frame_.get(), true, true);
+ }
+ is_black_ = false;
+ } else {
+ if (!is_black_) {
+ output_frame_->SetToBlack();
+ is_black_ = true;
+ }
+ output_frame_->SetElapsedTime(in_frame->GetElapsedTime());
+ output_frame_->SetTimeStamp(in_frame->GetTimeStamp());
+ }
+
+ return true;
+}
+
+///////////////////////////////////////////////////////////////////////
+// Implementation of CoordinatedVideoAdapter
+CoordinatedVideoAdapter::CoordinatedVideoAdapter()
+ : cpu_adaptation_(false),
+ gd_adaptation_(true),
+ view_adaptation_(true),
+ cpu_downgrade_count_(0),
+ cpu_downgrade_wait_time_(0),
+ view_desired_num_pixels_(INT_MAX),
+ view_desired_interval_(0),
+ encoder_desired_num_pixels_(INT_MAX),
+ cpu_desired_num_pixels_(INT_MAX) {
+}
+
+// Helper function to UPGRADE or DOWNGRADE a number of pixels
+void CoordinatedVideoAdapter::StepPixelCount(
+ CoordinatedVideoAdapter::AdaptRequest request,
+ int* num_pixels) {
+ switch (request) {
+ case CoordinatedVideoAdapter::DOWNGRADE:
+ *num_pixels /= 2;
+ break;
+
+ case CoordinatedVideoAdapter::UPGRADE:
+ *num_pixels *= 2;
+ break;
+
+ default: // No change in pixel count
+ break;
+ }
+ return;
+}
+
+// Find the adaptation request of the cpu based on the load. Return UPGRADE if
+// the load is low, DOWNGRADE if the load is high, and KEEP otherwise.
+CoordinatedVideoAdapter::AdaptRequest CoordinatedVideoAdapter::FindCpuRequest(
+ int current_cpus, int max_cpus,
+ float process_load, float system_load) {
+ // Downgrade if system is high and plugin is at least more than midrange.
+ if (system_load >= kHighSystemThreshold * max_cpus &&
+ process_load >= kMediumProcessThreshold * current_cpus) {
+ return CoordinatedVideoAdapter::DOWNGRADE;
+ // Upgrade if system is low.
+ } else if (system_load < kLowSystemThreshold * max_cpus) {
+ return CoordinatedVideoAdapter::UPGRADE;
+ }
+ return CoordinatedVideoAdapter::KEEP;
+}
+
+// A remote view request for a new resolution.
+void CoordinatedVideoAdapter::OnOutputFormatRequest(const VideoFormat& format) {
+ talk_base::CritScope cs(&request_critical_section_);
+ if (!view_adaptation_) {
+ return;
+ }
+ // Set output for initial aspect ratio in mediachannel unittests.
+ int old_num_pixels = GetOutputNumPixels();
+ SetOutputFormat(format);
+ SetOutputNumPixels(old_num_pixels);
+ view_desired_num_pixels_ = format.width * format.height;
+ view_desired_interval_ = format.interval;
+ bool changed = AdaptToMinimumFormat();
+ LOG(LS_INFO) << "VAdapt View Request: "
+ << format.width << "x" << format.height
+ << " Pixels: " << view_desired_num_pixels_
+ << " Changed: " << (changed ? "true" : "false");
+}
+
+// A Bandwidth GD request for new resolution
+void CoordinatedVideoAdapter::OnEncoderResolutionRequest(
+ int width, int height, AdaptRequest request) {
+ talk_base::CritScope cs(&request_critical_section_);
+ if (!gd_adaptation_) {
+ return;
+ }
+ if (KEEP != request) {
+ int new_encoder_desired_num_pixels = width * height;
+ int old_num_pixels = GetOutputNumPixels();
+ if (new_encoder_desired_num_pixels != old_num_pixels) {
+ LOG(LS_VERBOSE) << "VAdapt GD resolution stale. Ignored";
+ } else {
+ // Update the encoder desired format based on the request.
+ encoder_desired_num_pixels_ = new_encoder_desired_num_pixels;
+ StepPixelCount(request, &encoder_desired_num_pixels_);
+ }
+ }
+ bool changed = AdaptToMinimumFormat();
+ LOG(LS_INFO) << "VAdapt GD Request: "
+ << (DOWNGRADE == request ? "down" :
+ (UPGRADE == request ? "up" : "keep"))
+ << " From: " << width << "x" << height
+ << " Pixels: " << encoder_desired_num_pixels_
+ << " Changed: " << (changed ? "true" : "false");
+}
+
+// A CPU request for new resolution
+void CoordinatedVideoAdapter::OnCpuLoadUpdated(
+ int current_cpus, int max_cpus, float process_load, float system_load) {
+ talk_base::CritScope cs(&request_critical_section_);
+ if (!cpu_adaptation_) {
+ return;
+ }
+ AdaptRequest request = FindCpuRequest(current_cpus, max_cpus,
+ process_load, system_load);
+ // Update how many times we have downgraded due to the cpu load.
+ switch (request) {
+ case DOWNGRADE:
+ if (cpu_downgrade_count_ < kMaxCpuDowngrades) {
+ // Ignore downgrades if we have downgraded the maximum times or we just
+ // downgraded in a short time.
+ if (cpu_downgrade_wait_time_ != 0 &&
+ talk_base::TimeIsLater(talk_base::Time(),
+ cpu_downgrade_wait_time_)) {
+ LOG(LS_VERBOSE) << "VAdapt CPU load high but do not downgrade until "
+ << talk_base::TimeUntil(cpu_downgrade_wait_time_)
+ << " ms.";
+ request = KEEP;
+ } else {
+ ++cpu_downgrade_count_;
+ }
+ } else {
+ LOG(LS_VERBOSE) << "VAdapt CPU load high but do not downgrade "
+ "because maximum downgrades reached";
+ }
+ break;
+ case UPGRADE:
+ if (cpu_downgrade_count_ > 0) {
+ bool is_min = IsMinimumFormat(cpu_desired_num_pixels_);
+ if (is_min) {
+ --cpu_downgrade_count_;
+ } else {
+ LOG(LS_VERBOSE) << "VAdapt CPU load low but do not upgrade "
+ "because cpu is not limiting resolution";
+ }
+ } else {
+ LOG(LS_VERBOSE) << "VAdapt CPU load low but do not upgrade "
+ "because minimum downgrades reached";
+ }
+ break;
+ case KEEP:
+ default:
+ break;
+ }
+ if (KEEP != request) {
+ // TODO: compute stepping up/down from OutputNumPixels but
+ // clamp to inputpixels / 4 (2 steps)
+ cpu_desired_num_pixels_ = static_cast<int>(
+ input_format().width * input_format().height >> cpu_downgrade_count_);
+ }
+ bool changed = AdaptToMinimumFormat();
+ LOG(LS_INFO) << "VAdapt CPU Request: "
+ << (DOWNGRADE == request ? "down" :
+ (UPGRADE == request ? "up" : "keep"))
+ << " Process: " << process_load
+ << " System: " << system_load
+ << " Steps: " << cpu_downgrade_count_
+ << " Changed: " << (changed ? "true" : "false");
+}
+
+// Called by cpu adapter on up requests.
+bool CoordinatedVideoAdapter::IsMinimumFormat(int pixels) {
+ // Find closest scale factor that matches input resolution to min_num_pixels
+ // and set that for output resolution. This is not needed for VideoAdapter,
+ // but provides feedback to unittests and users on expected resolution.
+ // Actual resolution is based on input frame.
+ VideoFormat new_output = output_format();
+ VideoFormat input = input_format();
+ if (input_format().IsSize0x0()) {
+ input = new_output;
+ }
+ float scale = 1.0f;
+ if (!input.IsSize0x0()) {
+ scale = FindClosestScale(input.width,
+ input.height,
+ pixels);
+ }
+ new_output.width = static_cast<int>(input.width * scale);
+ new_output.height = static_cast<int>(input.height * scale);
+ int new_pixels = new_output.width * new_output.height;
+ int num_pixels = GetOutputNumPixels();
+ return new_pixels <= num_pixels;
+}
+
+// Called by all coordinators when there is a change.
+bool CoordinatedVideoAdapter::AdaptToMinimumFormat() {
+ int old_num_pixels = GetOutputNumPixels();
+ // Get the min of the formats that the server, encoder, and cpu wants.
+ int min_num_pixels = view_desired_num_pixels_;
+ if (encoder_desired_num_pixels_ &&
+ (encoder_desired_num_pixels_ < min_num_pixels)) {
+ min_num_pixels = encoder_desired_num_pixels_;
+ }
+ if (cpu_adaptation_ && cpu_desired_num_pixels_ &&
+ (cpu_desired_num_pixels_ < min_num_pixels)) {
+ min_num_pixels = cpu_desired_num_pixels_;
+ // Update the cpu_downgrade_wait_time_ if we are going to downgrade video.
+ cpu_downgrade_wait_time_ =
+ talk_base::TimeAfter(kDefaultDowngradeWaitTimeMs);
+ }
+ // prevent going below QQVGA
+ if (min_num_pixels > 0 && min_num_pixels < kMinNumPixels) {
+ min_num_pixels = kMinNumPixels;
+ }
+ SetOutputNumPixels(min_num_pixels);
+
+ // Find closest scale factor that matches input resolution to min_num_pixels
+ // and set that for output resolution. This is not needed for VideoAdapter,
+ // but provides feedback to unittests and users on expected resolution.
+ // Actual resolution is based on input frame.
+ VideoFormat new_output = output_format();
+ VideoFormat input = input_format();
+ if (input_format().IsSize0x0()) {
+ input = new_output;
+ }
+ float scale = 1.0f;
+ if (!input.IsSize0x0()) {
+ scale = FindClosestScale(input.width,
+ input.height,
+ min_num_pixels);
+ }
+ new_output.width = static_cast<int>(input.width * scale);
+ new_output.height = static_cast<int>(input.height * scale);
+ new_output.interval = view_desired_interval_;
+ SetOutputFormat(new_output);
+ int new_num_pixels = GetOutputNumPixels();
+ bool changed = new_num_pixels != old_num_pixels;
+
+ LOG(LS_VERBOSE) << "VAdapt Status View: " << view_desired_num_pixels_
+ << " GD: " << encoder_desired_num_pixels_
+ << " CPU: " << cpu_desired_num_pixels_
+ << " Pixels: " << min_num_pixels
+ << " Scale: " << scale
+ << " Resolution: " << new_output.width
+ << "x" << new_output.height
+ << " Changed: " << (changed ? "true" : "false");
+ return changed;
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/videoadapter.h b/talk/session/phone/videoadapter.h
new file mode 100644
index 0000000..6c14255
--- /dev/null
+++ b/talk/session/phone/videoadapter.h
@@ -0,0 +1,145 @@
+// libjingle
+// Copyright 2010 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_SESSION_PHONE_VIDEOADAPTER_H_
+#define TALK_SESSION_PHONE_VIDEOADAPTER_H_
+
+#include "talk/base/criticalsection.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/sigslot.h"
+#include "talk/session/phone/videocommon.h"
+
+namespace cricket {
+
+class VideoFrame;
+
+// VideoAdapter adapts an input video frame to an output frame based on the
+// specified input and output formats. The adaptation includes dropping frames
+// to reduce frame rate and scaling frames. VideoAdapter is thread safe.
+class VideoAdapter {
+ public:
+ VideoAdapter();
+ virtual ~VideoAdapter();
+
+ void SetInputFormat(const VideoFormat& format);
+ void SetOutputFormat(const VideoFormat& format);
+ // Constrain output resolution to this many pixels overall
+ void SetOutputNumPixels(int num_pixels);
+ int GetOutputNumPixels() const;
+
+ const VideoFormat& input_format();
+ const VideoFormat& output_format();
+ // If the parameter black is true, the adapted frames will be black.
+ void SetBlackOutput(bool black);
+
+ // Adapt the input frame from the input format to the output format. Return
+ // true and set the output frame to NULL if the input frame is dropped. Return
+ // true and set the out frame to output_frame_ if the input frame is adapted
+ // successfully. Return false otherwise.
+ // output_frame_ is owned by the VideoAdapter that has the best knowledge on
+ // the output frame.
+ bool AdaptFrame(const VideoFrame* in_frame, const VideoFrame** out_frame);
+
+ protected:
+ float FindClosestScale(int width, int height, int target_num_pixels);
+
+ private:
+ bool StretchToOutputFrame(const VideoFrame* in_frame);
+
+ VideoFormat input_format_;
+ VideoFormat output_format_;
+ int output_num_pixels_;
+ bool black_output_; // Flag to tell if we need to black output_frame_.
+ bool is_black_; // Flag to tell if output_frame_ is currently black.
+ int64 drop_frame_count_;
+ talk_base::scoped_ptr<VideoFrame> output_frame_;
+ // The critical section to protect the above variables.
+ talk_base::CriticalSection critical_section_;
+
+ DISALLOW_COPY_AND_ASSIGN(VideoAdapter);
+};
+
+// CoordinatedVideoAdapter adapts the video input to the encoder by coordinating
+// the format request from the server, the resolution request from the encoder,
+// and the CPU load.
+class CoordinatedVideoAdapter
+ : public VideoAdapter, public sigslot::has_slots<> {
+ public:
+ enum AdaptRequest { UPGRADE, KEEP, DOWNGRADE };
+
+ CoordinatedVideoAdapter();
+ virtual ~CoordinatedVideoAdapter() {}
+
+ // Enable or disable video adaptation due to the change of the CPU load.
+ void set_cpu_adaptation(bool enable) { cpu_adaptation_ = enable; }
+ bool cpu_adaptation() const { return cpu_adaptation_; }
+ // Enable or disable video adaptation due to the change of the GD
+ void set_gd_adaptation(bool enable) { gd_adaptation_ = enable; }
+ bool gd_adaptation() const { return gd_adaptation_; }
+ // Enable or disable video adaptation due to the change of the View
+ void set_view_adaptation(bool enable) { view_adaptation_ = enable; }
+ bool view_adaptation() const { return view_adaptation_; }
+ // When the video is decreased, set the waiting time for CPU adaptation to
+ // decrease video again.
+ void set_cpu_downgrade_wait_time(uint32 ms) { cpu_downgrade_wait_time_ = ms; }
+ // Handle the format request from the server via Jingle update message.
+ void OnOutputFormatRequest(const VideoFormat& format);
+ // Handle the resolution request from the encoder due to bandwidth changes.
+ void OnEncoderResolutionRequest(int width, int height, AdaptRequest request);
+ // Handle the CPU load provided by a CPU monitor.
+ void OnCpuLoadUpdated(int current_cpus, int max_cpus,
+ float process_load, float system_load);
+
+ private:
+ // Adapt to the minimum of the formats the server requests, the CPU wants, and
+ // the encoder wants. Returns true if resolution changed.
+ bool AdaptToMinimumFormat();
+ bool IsMinimumFormat(int pixels);
+ void StepPixelCount(CoordinatedVideoAdapter::AdaptRequest request,
+ int* num_pixels);
+ CoordinatedVideoAdapter::AdaptRequest FindCpuRequest(
+ int current_cpus, int max_cpus,
+ float process_load, float system_load);
+
+ bool cpu_adaptation_; // True if cpu adaptation is enabled.
+ bool gd_adaptation_; // True if gd adaptation is enabled.
+ bool view_adaptation_; // True if view adaptation is enabled.
+ int cpu_downgrade_count_;
+ int cpu_downgrade_wait_time_;
+ // Video formats that the server view requests, the CPU wants, and the encoder
+ // wants respectively. The adapted output format is the minimum of these.
+ int view_desired_num_pixels_;
+ int64 view_desired_interval_;
+ int encoder_desired_num_pixels_;
+ int cpu_desired_num_pixels_;
+ // The critical section to protect handling requests.
+ talk_base::CriticalSection request_critical_section_;
+
+ DISALLOW_COPY_AND_ASSIGN(CoordinatedVideoAdapter);
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_VIDEOADAPTER_H_
diff --git a/talk/session/phone/videocapturer.cc b/talk/session/phone/videocapturer.cc
index d62bae8..7f86293 100644
--- a/talk/session/phone/videocapturer.cc
+++ b/talk/session/phone/videocapturer.cc
@@ -34,6 +34,7 @@
namespace cricket {
static const int64 kMaxDistance = ~(static_cast<int64>(1) << 63);
+static const int64 kMinDesirableFps = static_cast<int64>(15);
/////////////////////////////////////////////////////////////////////
// Implementation of struct CapturedFrame
@@ -51,7 +52,7 @@
data(NULL) {
}
-// TODO(fbarchard): Remove this function once lmimediaengine stops using it.
+// TODO: Remove this function once lmimediaengine stops using it.
bool CapturedFrame::GetDataSize(uint32* size) const {
if (!size || data_size == CapturedFrame::kUnknownDataSize) {
return false;
@@ -94,7 +95,7 @@
std::vector<VideoFormat>::const_iterator i;
for (i = supported_formats_->begin(); i != supported_formats_->end(); ++i) {
int64 distance = GetFormatDistance(format, *i);
- // TODO(fbarchard): Reduce to LS_VERBOSE if/when camera capture is
+ // TODO: Reduce to LS_VERBOSE if/when camera capture is
// relatively bug free.
LOG(LS_INFO) << " Supported " << i->ToString()
<< " distance " << distance;
@@ -104,6 +105,7 @@
}
}
if (supported_formats_->end() == best) {
+ LOG(LS_ERROR) << " No acceptable camera format found";
return false;
}
@@ -155,10 +157,33 @@
}
// Check resolution and fps.
- int desired_height = desired.height;
int desired_width = desired.width;
- int64 delta_w = supported.width - desired.width;
- int64 delta_fps = VideoFormat::IntervalToFps(supported.interval) -
+ int desired_height = desired.height;
+#ifdef OSX
+ // QVGA on OSX is not well supported. For 16x10, if 320x240 is used, it has
+ // 15x11 pixel aspect ratio on logitech B910/C260 and others. ComputeCrop
+ // in mediaengine does not crop, so we keep 320x240, which magiccam on Mac
+ // can not display. Some other viewers can display 320x240, but do not
+ // support pixel aspect ratio and appear distorted.
+ // This code below bumps the preferred resolution to VGA, maintaining aspect
+ // ratio. ie 320x200 -> 640x400. VGA on logitech and most cameras is 1x1
+ // pixel aspect ratio. The camera will capture 640x480, ComputeCrop will
+ // crop to 640x400, and the adapter will scale down to QVGA due to JUP view
+ // request.
+ static const int kMinWidth = 640;
+ if (desired_width > 0 && desired_width < kMinWidth) {
+ int new_desired_height = desired_height * kMinWidth / desired_width;
+ LOG(LS_VERBOSE) << " Changed desired from "
+ << desired_width << "x" << desired_height
+ << " To "
+ << kMinWidth << "x" << new_desired_height;
+ desired_width = kMinWidth;
+ desired_height = new_desired_height;
+ }
+#endif
+ int64 delta_w = supported.width - desired_width;
+ int64 supported_fps = VideoFormat::IntervalToFps(supported.interval);
+ int64 delta_fps = supported_fps -
VideoFormat::IntervalToFps(desired.interval);
// Check height of supported height compared to height we would like it to be.
int64 aspect_h = desired_width ?
@@ -172,7 +197,7 @@
// strongly avoiding going down in resolution, similar to
// the old method, but not completely ruling it out in extreme situations.
// It also ignores framerate, which is often very low at high resolutions.
- // TODO(fbarchard): Improve logic to use weighted factors.
+ // TODO: Improve logic to use weighted factors.
static const int kDownPenalty = -3;
if (delta_w < 0) {
delta_w = delta_w * kDownPenalty;
@@ -183,8 +208,12 @@
if (delta_fps < 0) {
// For same resolution, prefer higher framerate but accept lower.
// Otherwise prefer higher resolution.
- distance |= static_cast<int64>(1) << 15;
delta_fps = -delta_fps;
+ if (supported_fps < kMinDesirableFps) {
+ distance |= static_cast<int64>(1) << 62;
+ } else {
+ distance |= static_cast<int64>(1) << 15;
+ }
}
// 12 bits for width and height and 8 bits for fps and fourcc.
diff --git a/talk/session/phone/videocapturer_unittest.cc b/talk/session/phone/videocapturer_unittest.cc
new file mode 100644
index 0000000..5bd2419
--- /dev/null
+++ b/talk/session/phone/videocapturer_unittest.cc
@@ -0,0 +1,464 @@
+// Copyright 2008 Google Inc. All Rights Reserved
+
+#include <stdio.h>
+#include <vector>
+
+#include "talk/base/gunit.h"
+#include "talk/base/logging.h"
+#include "talk/base/thread.h"
+#include "talk/session/phone/videocapturer.h"
+#include "talk/session/phone/testutils.h"
+
+namespace {
+
+class FakeVideoCapturer : public cricket::VideoCapturer {
+ public:
+ FakeVideoCapturer() {
+ // Default supported formats. Use ResetSupportedFormats to over write.
+ std::vector<cricket::VideoFormat> formats;
+ formats.push_back(cricket::VideoFormat(640, 480,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ formats.push_back(cricket::VideoFormat(320, 240,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ ResetSupportedFormats(formats);
+ }
+ ~FakeVideoCapturer() {}
+
+ void ResetSupportedFormats(const std::vector<cricket::VideoFormat>& formats) {
+ SetSupportedFormats(formats);
+ }
+ virtual cricket::CaptureResult Start(const cricket::VideoFormat& format) {
+ return cricket::CR_SUCCESS;
+ }
+ virtual void Stop() {}
+ virtual bool IsRunning() { return true; }
+ bool GetPreferredFourccs(std::vector<uint32>* fourccs) {
+ fourccs->push_back(cricket::FOURCC_I420);
+ fourccs->push_back(cricket::FOURCC_MJPG);
+ return true;
+ }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(FakeVideoCapturer);
+};
+
+TEST(VideoCapturerTest, TestFourccMatch) {
+ FakeVideoCapturer capturer;
+ cricket::VideoFormat desired(640, 480,
+ cricket::VideoFormat::FpsToInterval(30),
+ cricket::FOURCC_ANY);
+ cricket::VideoFormat best;
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(desired, &best));
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
+
+ desired.fourcc = cricket::FOURCC_MJPG;
+ EXPECT_FALSE(capturer.GetBestCaptureFormat(desired, &best));
+
+ desired.fourcc = cricket::FOURCC_I420;
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(desired, &best));
+}
+
+TEST(VideoCapturerTest, TestResolutionMatch) {
+ FakeVideoCapturer capturer;
+ cricket::VideoFormat desired(960, 720,
+ cricket::VideoFormat::FpsToInterval(30),
+ cricket::FOURCC_ANY);
+ cricket::VideoFormat best;
+ // Ask for 960x720. Get VGA which is the highest.
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(desired, &best));
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
+
+ desired.width = 360;
+ desired.height = 250;
+ // Ask for a little higher than QVGA. Get QVGA. On OSX gets VGA
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(desired, &best));
+#ifdef OSX
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+#else
+ EXPECT_EQ(320, best.width);
+ EXPECT_EQ(240, best.height);
+#endif
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
+
+ desired.width = 480;
+ desired.height = 270;
+ // Ask for HVGA. Get VGA.
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(desired, &best));
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
+
+ desired.width = 320;
+ desired.height = 240;
+ // Ask for QVGA. Get QVGA. On OSX get VGA
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(desired, &best));
+#ifdef OSX
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+#else
+ EXPECT_EQ(320, best.width);
+ EXPECT_EQ(240, best.height);
+#endif
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
+
+ desired.width = 160;
+ desired.height = 120;
+ // Ask for lower than QVGA. Get QVGA, which is the lowest. OSX gets VGA
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(desired, &best));
+#ifdef OSX
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+#else
+ EXPECT_EQ(320, best.width);
+ EXPECT_EQ(240, best.height);
+#endif
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
+}
+
+TEST(VideoCapturerTest, TestHDResolutionMatch) {
+ FakeVideoCapturer capturer;
+
+ // Add some HD formats
+ std::vector<cricket::VideoFormat> formats;
+ formats.push_back(cricket::VideoFormat(320, 240,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ formats.push_back(cricket::VideoFormat(640, 480,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ formats.push_back(cricket::VideoFormat(960, 544,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ formats.push_back(cricket::VideoFormat(2592, 1944,
+ cricket::VideoFormat::FpsToInterval(15), cricket::FOURCC_I420));
+ capturer.ResetSupportedFormats(formats);
+
+ cricket::VideoFormat desired(960, 720,
+ cricket::VideoFormat::FpsToInterval(30),
+ cricket::FOURCC_ANY);
+ cricket::VideoFormat best;
+ // Ask for 960x720. Get qHD
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(desired, &best));
+ EXPECT_EQ(960, best.width);
+ EXPECT_EQ(544, best.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
+
+ desired.width = 360;
+ desired.height = 250;
+ // Ask for a litter higher than QVGA. Get QVGA. OSX gets VGA
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(desired, &best));
+#ifdef OSX
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+#else
+ EXPECT_EQ(320, best.width);
+ EXPECT_EQ(240, best.height);
+#endif
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
+
+ desired.width = 480;
+ desired.height = 270;
+ // Ask for HVGA. Get VGA.
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(desired, &best));
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
+
+ desired.width = 320;
+ desired.height = 240;
+ // Ask for QVGA. Get QVGA. OSX gets VGA
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(desired, &best));
+#ifdef OSX
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+#else
+ EXPECT_EQ(320, best.width);
+ EXPECT_EQ(240, best.height);
+#endif
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
+
+ desired.width = 160;
+ desired.height = 120;
+ // Ask for lower than QVGA. Get QVGA, which is the lowest.
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(desired, &best));
+#ifdef OSX
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+#else
+ EXPECT_EQ(320, best.width);
+ EXPECT_EQ(240, best.height);
+#endif
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
+
+ desired.width = 1280;
+ desired.height = 720;
+ // Ask for HD. Get qHD.
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(desired, &best));
+ EXPECT_EQ(960, best.width);
+ EXPECT_EQ(544, best.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
+
+ desired.width = 1920;
+ desired.height = 1080;
+ // Ask for 1080p. Get 2592x1944x15.
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(desired, &best));
+ EXPECT_EQ(2592, best.width);
+ EXPECT_EQ(1944, best.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(15), best.interval);
+}
+
+// Some cameras support 320x240 and 320x640. Verify we choose 320x240.
+// On OSX we choose VGA
+TEST(VideoCapturerTest, TestStrangeFormats) {
+ FakeVideoCapturer capturer;
+ std::vector<cricket::VideoFormat> supported_formats;
+ supported_formats.push_back(cricket::VideoFormat(320, 240,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(320, 640,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ capturer.ResetSupportedFormats(supported_formats);
+
+ std::vector<cricket::VideoFormat> required_formats;
+ required_formats.push_back(cricket::VideoFormat(320, 240,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ required_formats.push_back(cricket::VideoFormat(320, 200,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ required_formats.push_back(cricket::VideoFormat(320, 180,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ cricket::VideoFormat best;
+ for (size_t i = 0; i < required_formats.size(); ++i) {
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[i], &best));
+ EXPECT_EQ(320, best.width);
+ EXPECT_EQ(240, best.height);
+ }
+
+ supported_formats.clear();
+ supported_formats.push_back(cricket::VideoFormat(320, 640,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(320, 240,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ capturer.ResetSupportedFormats(supported_formats);
+
+ for (size_t i = 0; i < required_formats.size(); ++i) {
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[i], &best));
+ EXPECT_EQ(320, best.width);
+ EXPECT_EQ(240, best.height);
+ }
+}
+
+// Some cameras only have very low fps. Verify we choose something sensible.
+TEST(VideoCapturerTest, TestPoorFpsFormats) {
+ FakeVideoCapturer capturer;
+ // all formats are low framerate
+ std::vector<cricket::VideoFormat> supported_formats;
+ supported_formats.push_back(cricket::VideoFormat(320, 240,
+ cricket::VideoFormat::FpsToInterval(10), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 480,
+ cricket::VideoFormat::FpsToInterval(7), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(1280, 720,
+ cricket::VideoFormat::FpsToInterval(2), cricket::FOURCC_I420));
+ capturer.ResetSupportedFormats(supported_formats);
+
+ std::vector<cricket::VideoFormat> required_formats;
+ required_formats.push_back(cricket::VideoFormat(320, 240,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ required_formats.push_back(cricket::VideoFormat(640, 480,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ cricket::VideoFormat best;
+ for (size_t i = 0; i < required_formats.size(); ++i) {
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[i], &best));
+#ifdef OSX
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+#else
+ EXPECT_EQ(required_formats[i].width, best.width);
+ EXPECT_EQ(required_formats[i].height, best.height);
+#endif
+ }
+
+ // Increase framerate of 320x240. Expect low fps VGA avoided.
+ // Except on Mac, where QVGA is avoid due to aspect ratio.
+ supported_formats.clear();
+ supported_formats.push_back(cricket::VideoFormat(320, 240,
+ cricket::VideoFormat::FpsToInterval(15), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 480,
+ cricket::VideoFormat::FpsToInterval(7), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(1280, 720,
+ cricket::VideoFormat::FpsToInterval(2), cricket::FOURCC_I420));
+ capturer.ResetSupportedFormats(supported_formats);
+
+ for (size_t i = 0; i < required_formats.size(); ++i) {
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[i], &best));
+ EXPECT_EQ(320, best.width);
+ EXPECT_EQ(240, best.height);
+ }
+}
+
+// Some cameras support same size with different frame rates. Verify we choose
+// the frame rate properly.
+TEST(VideoCapturerTest, TestSameSizeDifferentFpsFormats) {
+ FakeVideoCapturer capturer;
+ std::vector<cricket::VideoFormat> supported_formats;
+ supported_formats.push_back(cricket::VideoFormat(320, 240,
+ cricket::VideoFormat::FpsToInterval(10), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(320, 240,
+ cricket::VideoFormat::FpsToInterval(20), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(320, 240,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ capturer.ResetSupportedFormats(supported_formats);
+
+ std::vector<cricket::VideoFormat> required_formats = supported_formats;
+ cricket::VideoFormat best;
+ for (size_t i = 0; i < required_formats.size(); ++i) {
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[i], &best));
+ EXPECT_EQ(320, best.width);
+ EXPECT_EQ(240, best.height);
+ EXPECT_EQ(required_formats[i].interval, best.interval);
+ }
+}
+
+// Some cameras support the correct resolution but at a lower fps than
+// we'd like. This tests we get the expected resolution and fps.
+TEST(VideoCapturerTest, TestFpsFormats) {
+ FakeVideoCapturer capturer;
+ // We have VGA but low fps. Choose VGA, not HD
+ std::vector<cricket::VideoFormat> supported_formats;
+ supported_formats.push_back(cricket::VideoFormat(1280, 720,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 480,
+ cricket::VideoFormat::FpsToInterval(15), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 400,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 360,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ capturer.ResetSupportedFormats(supported_formats);
+
+ std::vector<cricket::VideoFormat> required_formats;
+ required_formats.push_back(cricket::VideoFormat(640, 480,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_ANY));
+ required_formats.push_back(cricket::VideoFormat(640, 480,
+ cricket::VideoFormat::FpsToInterval(20), cricket::FOURCC_ANY));
+ required_formats.push_back(cricket::VideoFormat(640, 480,
+ cricket::VideoFormat::FpsToInterval(10), cricket::FOURCC_ANY));
+ cricket::VideoFormat best;
+
+ // expect 30 fps to choose 15 fps format
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[0], &best));
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(15), best.interval);
+
+ // expect 20 fps to choose 15 fps format
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[1], &best));
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(15), best.interval);
+
+ // expect 10 fps to choose 15 fps format but set fps to 10
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[2], &best));
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(10), best.interval);
+
+ // We have VGA 60 fps and 15 fps. Choose best fps.
+ supported_formats.clear();
+ supported_formats.push_back(cricket::VideoFormat(1280, 720,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 480,
+ cricket::VideoFormat::FpsToInterval(60), cricket::FOURCC_MJPG));
+ supported_formats.push_back(cricket::VideoFormat(640, 480,
+ cricket::VideoFormat::FpsToInterval(15), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 400,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 360,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ capturer.ResetSupportedFormats(supported_formats);
+
+ // expect 30 fps to choose 60 fps format, but will set best fps to 30
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[0], &best));
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
+
+ // expect 20 fps to choose 60 fps format, but will set best fps to 20
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[1], &best));
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(20), best.interval);
+
+ // expect 10 fps to choose 10 fps
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[2], &best));
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+ EXPECT_EQ(cricket::VideoFormat::FpsToInterval(10), best.interval);
+}
+
+TEST(VideoCapturerTest, TestRequest16x10_9) {
+ FakeVideoCapturer capturer;
+ std::vector<cricket::VideoFormat> supported_formats;
+ // We do not support HD, expect 4x3 for 4x3, 16x10, and 16x9 requests.
+ supported_formats.push_back(cricket::VideoFormat(640, 480,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 400,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 360,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ capturer.ResetSupportedFormats(supported_formats);
+
+ std::vector<cricket::VideoFormat> required_formats = supported_formats;
+ cricket::VideoFormat best;
+ // Expect 4x3 for 4x3, 16x10, and 16x9 requests.
+ for (size_t i = 0; i < required_formats.size(); ++i) {
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[i], &best));
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+ }
+
+ // We do not support 16x9 HD, expect 4x3 for 4x3, 16x10, and 16x9 requests.
+ supported_formats.clear();
+ supported_formats.push_back(cricket::VideoFormat(960, 720,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 480,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 400,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 360,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ capturer.ResetSupportedFormats(supported_formats);
+
+ // Expect 4x3 for 4x3, 16x10, and 16x9 requests.
+ for (size_t i = 0; i < required_formats.size(); ++i) {
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[i], &best));
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+ }
+
+ // We support 16x9HD, expect 4x3 for 4x3 and 16x10 requests and expect 16x9
+ // for 16x9 request.
+ supported_formats.clear();
+ supported_formats.push_back(cricket::VideoFormat(1280, 720,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 480,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 400,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ supported_formats.push_back(cricket::VideoFormat(640, 360,
+ cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+ capturer.ResetSupportedFormats(supported_formats);
+
+ // Expect 4x3 for 4x3 and 16x10 requests.
+ for (size_t i = 0; i < required_formats.size() - 1; ++i) {
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[i], &best));
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(480, best.height);
+ }
+
+ // Expect 16x9 for 16x9 request.
+ EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[2], &best));
+ EXPECT_EQ(640, best.width);
+ EXPECT_EQ(360, best.height);
+}
+
+} // unnamed namespace
diff --git a/talk/session/phone/videocommon.cc b/talk/session/phone/videocommon.cc
new file mode 100644
index 0000000..0d07ef1
--- /dev/null
+++ b/talk/session/phone/videocommon.cc
@@ -0,0 +1,90 @@
+// libjingle
+// Copyright 2010 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/session/phone/videocommon.h"
+
+#include <sstream>
+
+#include "talk/base/common.h"
+
+namespace cricket {
+
+struct FourCCAliasEntry {
+ uint32 alias;
+ uint32 canonical;
+};
+
+static const FourCCAliasEntry kFourCCAliases[] = {
+ {FOURCC_IYUV, FOURCC_I420},
+ {FOURCC_YU12, FOURCC_I420},
+ {FOURCC_YU16, FOURCC_I422},
+ {FOURCC_YU24, FOURCC_I444},
+ {FOURCC_YUYV, FOURCC_YUY2},
+ {FOURCC_YUVS, FOURCC_YUY2},
+ {FOURCC_HDYC, FOURCC_UYVY},
+ {FOURCC_2VUY, FOURCC_UYVY},
+ {FOURCC_BA81, FOURCC_BGGR},
+ {FOURCC_JPEG, FOURCC_MJPG}, // Note: JPEG has DHT while MJPG does not.
+ {FOURCC_DMB1, FOURCC_MJPG},
+ {FOURCC_RGB3, FOURCC_RAW},
+ {FOURCC_BGR3, FOURCC_24BG},
+};
+
+uint32 CanonicalFourCC(uint32 fourcc) {
+ for (int i = 0; i < ARRAY_SIZE(kFourCCAliases); ++i) {
+ if (kFourCCAliases[i].alias == fourcc) {
+ return kFourCCAliases[i].canonical;
+ }
+ }
+ // Not an alias, so return it as-is.
+ return fourcc;
+}
+
+// The C++ standard requires a namespace-scope definition of static const
+// integral types even when they are initialized in the declaration (see
+// [class.static.data]/4), but MSVC with /Ze is non-conforming and treats that
+// as a multiply defined symbol error (see
+// http://msdn.microsoft.com/en-us/library/34h23df8.aspx).
+#ifndef _MSC_EXTENSIONS
+const int64 VideoFormat::kMinimumInterval; // Initialized in header.
+#endif
+
+std::string VideoFormat::ToString() const {
+ std::string fourcc_name = GetFourccName(fourcc) + " ";
+ for (std::string::const_iterator i = fourcc_name.begin();
+ i < fourcc_name.end(); ++i) {
+ // Test character is printable; Avoid isprint() which asserts on negatives
+ if (*i < 32 || *i >= 127) {
+ fourcc_name = "";
+ break;
+ }
+ }
+
+ std::ostringstream ss;
+ ss << fourcc_name << width << "x" << height << "x" << IntervalToFps(interval);
+ return ss.str();
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/videocommon.h b/talk/session/phone/videocommon.h
index 995e800..fa695f0 100644
--- a/talk/session/phone/videocommon.h
+++ b/talk/session/phone/videocommon.h
@@ -31,37 +31,34 @@
#include <string>
#include "talk/base/basictypes.h"
+#include "talk/base/timeutils.h"
namespace cricket {
//////////////////////////////////////////////////////////////////////////////
-// Definition of fourcc.
+// Definition of FourCC codes
//////////////////////////////////////////////////////////////////////////////
-// Convert four characters to a fourcc code.
+// Convert four characters to a FourCC code.
// Needs to be a macro otherwise the OS X compiler complains when the kFormat*
// constants are used in a switch.
-#define FOURCC(a, b, c, d) (\
+#define FOURCC(a, b, c, d) ( \
(static_cast<uint32>(a)) | (static_cast<uint32>(b) << 8) | \
(static_cast<uint32>(c) << 16) | (static_cast<uint32>(d) << 24))
-// Get the name, that is, string with four characters, of a fourcc code.
-inline std::string GetFourccName(uint32 fourcc) {
- std::string name;
- name.push_back(static_cast<char>(fourcc & 0xFF));
- name.push_back(static_cast<char>((fourcc >> 8) & 0xFF));
- name.push_back(static_cast<char>((fourcc >> 16) & 0xFF));
- name.push_back(static_cast<char>((fourcc >> 24) & 0xFF));
- return name;
-}
-
-// FourCC codes used in Google Talk.
-// Some good pages discussing FourCC codes:
-// http://developer.apple.com/quicktime/icefloe/dispatch020.html
+// Some pages discussing FourCC codes:
// http://www.fourcc.org/yuv.php
+// http://v4l2spec.bytesex.org/spec/book1.htm
+// http://developer.apple.com/quicktime/icefloe/dispatch020.html
+
enum FourCC {
// Canonical fourcc codes used in our code.
FOURCC_I420 = FOURCC('I', '4', '2', '0'),
+ FOURCC_I422 = FOURCC('I', '4', '2', '2'),
+ FOURCC_I444 = FOURCC('I', '4', '4', '4'),
+ FOURCC_I400 = FOURCC('I', '4', '0', '0'),
FOURCC_YV12 = FOURCC('Y', 'V', '1', '2'),
+ FOURCC_YV16 = FOURCC('Y', 'V', '1', '6'),
+ FOURCC_YV24 = FOURCC('Y', 'V', '2', '4'),
FOURCC_YUY2 = FOURCC('Y', 'U', 'Y', '2'),
FOURCC_UYVY = FOURCC('U', 'Y', 'V', 'Y'),
FOURCC_M420 = FOURCC('M', '4', '2', '0'),
@@ -70,6 +67,9 @@
FOURCC_ABGR = FOURCC('A', 'B', 'G', 'R'),
FOURCC_BGRA = FOURCC('B', 'G', 'R', 'A'),
FOURCC_ARGB = FOURCC('A', 'R', 'G', 'B'),
+ FOURCC_RGBP = FOURCC('R', 'G', 'B', 'P'), // bgr565
+ FOURCC_RGBO = FOURCC('R', 'G', 'B', 'O'), // abgr1555
+ FOURCC_R444 = FOURCC('R', '4', '4', '4'), // argb4444
FOURCC_MJPG = FOURCC('M', 'J', 'P', 'G'),
FOURCC_RAW = FOURCC('r', 'a', 'w', ' '),
FOURCC_NV21 = FOURCC('N', 'V', '2', '1'),
@@ -85,6 +85,8 @@
// equivalents by CanonicalFourCC().
FOURCC_IYUV = FOURCC('I', 'Y', 'U', 'V'), // Alias for I420
FOURCC_YU12 = FOURCC('Y', 'U', '1', '2'), // Alias for I420
+ FOURCC_YU16 = FOURCC('Y', 'U', '1', '6'), // Alias for I422
+ FOURCC_YU24 = FOURCC('Y', 'U', '2', '4'), // Alias for I444
FOURCC_YUYV = FOURCC('Y', 'U', 'Y', 'V'), // Alias for YUY2
FOURCC_YUVS = FOURCC('y', 'u', 'v', 's'), // Alias for YUY2 on Mac
FOURCC_HDYC = FOURCC('H', 'D', 'Y', 'C'), // Alias for UYVY
@@ -102,39 +104,59 @@
// Converts fourcc aliases into canonical ones.
uint32 CanonicalFourCC(uint32 fourcc);
+// Get FourCC code as a string
+inline std::string GetFourccName(uint32 fourcc) {
+ std::string name;
+ name.push_back(static_cast<char>(fourcc & 0xFF));
+ name.push_back(static_cast<char>((fourcc >> 8) & 0xFF));
+ name.push_back(static_cast<char>((fourcc >> 16) & 0xFF));
+ name.push_back(static_cast<char>((fourcc >> 24) & 0xFF));
+ return name;
+}
+
//////////////////////////////////////////////////////////////////////////////
// Definition of VideoFormat.
//////////////////////////////////////////////////////////////////////////////
-static const int64 kNumNanosecsPerSec = 1000000000;
+// VideoFormat with Plain Old Data for global variables
+struct VideoFormatPod {
+ int width; // in number of pixels
+ int height; // in number of pixels
+ int64 interval; // in nanoseconds
+ uint32 fourcc; // color space. FOURCC_ANY means that any color space is OK.
+};
-struct VideoFormat {
- static const int64 kMinimumInterval = kNumNanosecsPerSec / 10000; // 10k fps
+struct VideoFormat : VideoFormatPod{
+ static const int64 kMinimumInterval =
+ talk_base::kNumNanosecsPerSec / 10000; // 10k fps
- VideoFormat() : width(0), height(0), interval(0), fourcc(0) {}
-
- VideoFormat(int w, int h, int64 interval_ns, uint32 cc)
- : width(w),
- height(h),
- interval(interval_ns),
- fourcc(cc) {
+ VideoFormat() {
+ Construct(0, 0, 0, 0);
}
- VideoFormat(const VideoFormat& format)
- : width(format.width),
- height(format.height),
- interval(format.interval),
- fourcc(format.fourcc) {
+ VideoFormat(int w, int h, int64 interval_ns, uint32 cc) {
+ Construct(w, h, interval_ns, cc);
+ }
+
+ explicit VideoFormat(const VideoFormatPod& format) {
+ Construct(format.width, format.height, format.interval, format.fourcc);
+ }
+
+ void Construct(int w, int h, int64 interval_ns, uint32 cc) {
+ width = w;
+ height = h;
+ interval = interval_ns;
+ fourcc = cc;
}
static int64 FpsToInterval(int fps) {
- return fps ? kNumNanosecsPerSec / fps : kMinimumInterval;
+ return fps ? talk_base::kNumNanosecsPerSec / fps : kMinimumInterval;
}
static int IntervalToFps(int64 interval) {
// Normalize the interval first.
interval = talk_base::_max(interval, kMinimumInterval);
- return static_cast<int>(kNumNanosecsPerSec / interval);
+ return static_cast<int>(talk_base::kNumNanosecsPerSec / interval);
}
bool operator==(const VideoFormat& format) const {
@@ -169,11 +191,6 @@
// Get a string presentation in the form of "fourcc width x height x fps"
std::string ToString() const;
-
- int width; // in number of pixels
- int height; // in number of pixels
- int64 interval; // in nanoseconds
- uint32 fourcc; // color space. FOURCC_ANY means that any color space is OK.
};
// Result of video capturer start.
diff --git a/talk/session/phone/videocommon_unittest.cc b/talk/session/phone/videocommon_unittest.cc
new file mode 100644
index 0000000..eb74c35
--- /dev/null
+++ b/talk/session/phone/videocommon_unittest.cc
@@ -0,0 +1,102 @@
+/*
+ * libjingle
+ * Copyright 2008 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/base/gunit.h"
+#include "talk/session/phone/videocommon.h"
+
+namespace cricket {
+
+TEST(VideoCommonTest, TestCanonicalFourCC) {
+ // Canonical fourccs are not changed.
+ EXPECT_EQ(FOURCC_I420, CanonicalFourCC(FOURCC_I420));
+ // The special FOURCC_ANY value is not changed.
+ EXPECT_EQ(FOURCC_ANY, CanonicalFourCC(FOURCC_ANY));
+ // Aliases are translated to the canonical equivalent.
+ EXPECT_EQ(FOURCC_I420, CanonicalFourCC(FOURCC_IYUV));
+ EXPECT_EQ(FOURCC_I422, CanonicalFourCC(FOURCC_YU16));
+ EXPECT_EQ(FOURCC_I444, CanonicalFourCC(FOURCC_YU24));
+ EXPECT_EQ(FOURCC_24BG, CanonicalFourCC(FOURCC_BGR3));
+ EXPECT_EQ(FOURCC_RAW, CanonicalFourCC(FOURCC_RGB3));
+ EXPECT_EQ(FOURCC_MJPG, CanonicalFourCC(FOURCC_DMB1));
+}
+
+// Test conversion between interval and fps
+TEST(VideoCommonTest, TestVideoFormatFps) {
+ EXPECT_EQ(VideoFormat::kMinimumInterval, VideoFormat::FpsToInterval(0));
+ EXPECT_EQ(talk_base::kNumNanosecsPerSec / 20, VideoFormat::FpsToInterval(20));
+ EXPECT_EQ(20, VideoFormat::IntervalToFps(talk_base::kNumNanosecsPerSec / 20));
+}
+
+// Test IsSize0x0
+TEST(VideoCommonTest, TestVideoFormatIsSize0x0) {
+ VideoFormat format;
+ EXPECT_TRUE(format.IsSize0x0());
+ format.width = 320;
+ EXPECT_FALSE(format.IsSize0x0());
+}
+
+// Test ToString: print fourcc when it is printable.
+TEST(VideoCommonTest, TestVideoFormatToString) {
+ VideoFormat format;
+ EXPECT_EQ("0x0x10000", format.ToString());
+
+ format.fourcc = FOURCC_I420;
+ format.width = 640;
+ format.height = 480;
+ format.interval = VideoFormat::FpsToInterval(20);
+ EXPECT_EQ("I420 640x480x20", format.ToString());
+
+ format.fourcc = FOURCC_ANY;
+ format.width = 640;
+ format.height = 480;
+ format.interval = VideoFormat::FpsToInterval(20);
+ EXPECT_EQ("640x480x20", format.ToString());
+}
+
+// Test comparison.
+TEST(VideoCommonTest, TestVideoFormatCompare) {
+ VideoFormat format(640, 480, VideoFormat::FpsToInterval(20), FOURCC_I420);
+ VideoFormat format2;
+ EXPECT_NE(format, format2);
+
+ // Same pixelrate, different fourcc.
+ format2 = format;
+ format2.fourcc = FOURCC_YUY2;
+ EXPECT_NE(format, format2);
+ EXPECT_FALSE(format.IsPixelRateLess(format2) ||
+ format2.IsPixelRateLess(format2));
+
+ format2 = format;
+ format2.interval /= 2;
+ EXPECT_TRUE(format.IsPixelRateLess(format2));
+
+ format2 = format;
+ format2.width *= 2;
+ EXPECT_TRUE(format.IsPixelRateLess(format2));
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/videoframe.cc b/talk/session/phone/videoframe.cc
new file mode 100644
index 0000000..dd02a9a
--- /dev/null
+++ b/talk/session/phone/videoframe.cc
@@ -0,0 +1,147 @@
+/*
+ * 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/session/phone/videoframe.h"
+
+#include <cstring>
+
+#ifdef HAVE_YUV
+#include "libyuv/planar_functions.h"
+#include "libyuv/scale.h"
+#endif
+
+namespace cricket {
+
+// Round to 2 pixels because Chroma channels are half size.
+#define ROUNDTO2(v) (v & ~1)
+
+// TODO: Handle odd width/height with rounding.
+void VideoFrame::StretchToPlanes(
+ uint8* y, uint8* u, uint8* v,
+ int32 dst_pitch_y, int32 dst_pitch_u, int32 dst_pitch_v,
+ size_t width, size_t height, bool interpolate, bool vert_crop) const {
+#ifdef HAVE_YUV
+ if (!GetYPlane() || !GetUPlane() || !GetVPlane())
+ return;
+
+ const uint8* in_y = GetYPlane();
+ const uint8* in_u = GetUPlane();
+ const uint8* in_v = GetVPlane();
+ int32 iwidth = GetWidth();
+ int32 iheight = GetHeight();
+
+ if (vert_crop) {
+ // Adjust the input width:height ratio to be the same as the output ratio.
+ if (iwidth * height > iheight * width) {
+ // Reduce the input width, but keep size/position aligned for YuvScaler
+ iwidth = ROUNDTO2(iheight * width / height);
+ int32 iwidth_offset = ROUNDTO2((GetWidth() - iwidth) / 2);
+ in_y += iwidth_offset;
+ in_u += iwidth_offset / 2;
+ in_v += iwidth_offset / 2;
+ } else if (iwidth * height < iheight * width) {
+ // Reduce the input height.
+ iheight = iwidth * height / width;
+ int32 iheight_offset = (GetHeight() - iheight) >> 2;
+ iheight_offset <<= 1; // Ensure that iheight_offset is even.
+ in_y += iheight_offset * GetYPitch();
+ in_u += iheight_offset / 2 * GetUPitch();
+ in_v += iheight_offset / 2 * GetVPitch();
+ }
+ }
+
+ // Scale to the output I420 frame.
+ libyuv::Scale(in_y, in_u, in_v,
+ GetYPitch(),
+ GetUPitch(),
+ GetVPitch(),
+ iwidth, iheight,
+ y, u, v, dst_pitch_y, dst_pitch_u, dst_pitch_v,
+ width, height, interpolate);
+#endif
+}
+
+size_t VideoFrame::StretchToBuffer(size_t w, size_t h,
+ uint8* buffer, size_t size,
+ bool interpolate, bool vert_crop) const {
+ if (!buffer) return 0;
+
+ size_t needed = SizeOf(w, h);
+ if (needed <= size) {
+ uint8* bufy = buffer;
+ uint8* bufu = bufy + w * h;
+ uint8* bufv = bufu + ((w + 1) >> 1) * ((h + 1) >> 1);
+ StretchToPlanes(bufy, bufu, bufv, w, (w + 1) >> 1, (w + 1) >> 1, w, h,
+ interpolate, vert_crop);
+ }
+ return needed;
+}
+
+void VideoFrame::StretchToFrame(VideoFrame *target,
+ bool interpolate, bool vert_crop) const {
+ if (!target) return;
+
+ StretchToPlanes(target->GetYPlane(),
+ target->GetUPlane(),
+ target->GetVPlane(),
+ target->GetYPitch(),
+ target->GetUPitch(),
+ target->GetVPitch(),
+ target->GetWidth(),
+ target->GetHeight(),
+ interpolate, vert_crop);
+ target->SetElapsedTime(GetElapsedTime());
+ target->SetTimeStamp(GetTimeStamp());
+}
+
+VideoFrame* VideoFrame::Stretch(size_t w, size_t h,
+ bool interpolate, bool vert_crop) const {
+ VideoFrame* dest = CreateEmptyFrame(w, h, GetPixelWidth(), GetPixelHeight(),
+ GetElapsedTime(), GetTimeStamp());
+ if (dest) {
+ StretchToFrame(dest, interpolate, vert_crop);
+ }
+ return dest;
+}
+
+bool VideoFrame::SetToBlack() {
+#ifdef HAVE_YUV
+ return libyuv::I420Rect(GetYPlane(), GetYPitch(),
+ GetUPlane(), GetUPitch(),
+ GetVPlane(), GetVPitch(),
+ 0, 0, GetWidth(), GetHeight(),
+ 16, 128, 128) == 0;
+#else
+ int uv_size = GetUPitch() * GetChromaHeight();
+ memset(GetYPlane(), 16, GetWidth() * GetHeight());
+ memset(GetUPlane(), 128, uv_size);
+ memset(GetVPlane(), 128, uv_size);
+ return true;
+#endif
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/videoframe.h b/talk/session/phone/videoframe.h
index 6f331d1..c34db88 100644
--- a/talk/session/phone/videoframe.h
+++ b/talk/session/phone/videoframe.h
@@ -1,6 +1,6 @@
/*
* libjingle
- * Copyright 2004--2011, Google Inc.
+ * Copyright 2004 Google Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
@@ -50,13 +50,24 @@
public:
VideoFrame() : rendered_(false) {}
-
virtual ~VideoFrame() {}
+ // Creates a frame from a raw sample with FourCC |format| and size |w| x |h|.
+ // |h| can be negative indicating a vertically flipped image.
+ // |dw| is destination width; can be less than |w| if cropping is desired.
+ // |dh| is destination height, like |dw|, but must be a positive number.
+ // Returns whether the function succeeded or failed.
+ virtual bool Reset(uint32 fourcc, int w, int h, int dw, int dh,
+ uint8 *sample, size_t sample_size,
+ size_t pixel_width, size_t pixel_height,
+ int64 elapsed_time, int64 time_stamp, int rotation) = 0;
+
+ // Basic accessors.
virtual size_t GetWidth() const = 0;
virtual size_t GetHeight() const = 0;
size_t GetChromaWidth() const { return (GetWidth() + 1) / 2; }
size_t GetChromaHeight() const { return (GetHeight() + 1) / 2; }
+ size_t GetChromaSize() const { return GetUPitch() * GetChromaHeight(); }
virtual const uint8 *GetYPlane() const = 0;
virtual const uint8 *GetUPlane() const = 0;
virtual const uint8 *GetVPlane() const = 0;
@@ -72,8 +83,6 @@
virtual size_t GetPixelWidth() const = 0;
virtual size_t GetPixelHeight() const = 0;
- // TODO: Add a fourcc format here and probably combine VideoFrame
- // with CapturedFrame.
virtual int64 GetElapsedTime() const = 0;
virtual int64 GetTimeStamp() const = 0;
virtual void SetElapsedTime(int64 elapsed_time) = 0;
@@ -102,10 +111,10 @@
// Converts the I420 data to RGB of a certain type such as ARGB and ABGR.
// Returns the frame's actual size, regardless of whether it was written or
- // not (like snprintf). Parameters size and pitch_rgb are in units of bytes.
+ // not (like snprintf). Parameters size and stride_rgb are in units of bytes.
// If there is insufficient space, nothing is written.
virtual size_t ConvertToRgbBuffer(uint32 to_fourcc, uint8 *buffer,
- size_t size, size_t pitch_rgb) const = 0;
+ size_t size, int stride_rgb) const = 0;
// Writes the frame into the given planes, stretched to the given width and
// height. The parameter "interpolate" controls whether to interpolate or just
@@ -114,7 +123,7 @@
virtual void StretchToPlanes(uint8 *y, uint8 *u, uint8 *v,
int32 pitchY, int32 pitchU, int32 pitchV,
size_t width, size_t height,
- bool interpolate, bool crop) const = 0;
+ bool interpolate, bool crop) const;
// Writes the frame into the given frame buffer, stretched to the given width
// and height, provided that it is of sufficient size. Returns the frame's
@@ -124,23 +133,23 @@
// nearest-point. The parameter "crop" controls whether to crop this frame to
// the aspect ratio of the given dimensions before stretching.
virtual size_t StretchToBuffer(size_t w, size_t h, uint8 *buffer, size_t size,
- bool interpolate, bool crop) const = 0;
+ bool interpolate, bool crop) const;
// Writes the frame into the target VideoFrame, stretched to the size of that
// frame. The parameter "interpolate" controls whether to interpolate or just
// take the nearest-point. The parameter "crop" controls whether to crop this
// frame to the aspect ratio of the target frame before stretching.
virtual void StretchToFrame(VideoFrame *target, bool interpolate,
- bool crop) const = 0;
+ bool crop) const;
// Stretches the frame to the given size, creating a new VideoFrame object to
// hold it. The parameter "interpolate" controls whether to interpolate or
// just take the nearest-point. The parameter "crop" controls whether to crop
// this frame to the aspect ratio of the given dimensions before stretching.
virtual VideoFrame *Stretch(size_t w, size_t h, bool interpolate,
- bool crop) const = 0;
+ bool crop) const;
- // Set the video frame to black.
+ // Sets the video frame to black.
bool SetToBlack();
// Size of an I420 image of given dimensions when stored as a frame buffer.
@@ -149,6 +158,12 @@
}
protected:
+ // Creates an empty frame.
+ virtual VideoFrame* CreateEmptyFrame(int w, int h,
+ size_t pixel_width, size_t pixel_height,
+ int64 elapsed_time,
+ int64 time_stamp) const = 0;
+
// The frame needs to be rendered to magiccam only once.
// TODO: Remove this flag once magiccam rendering is fully replaced
// by client3d rendering.
diff --git a/talk/session/phone/videoprocessor.h b/talk/session/phone/videoprocessor.h
new file mode 100644
index 0000000..d3b6249
--- /dev/null
+++ b/talk/session/phone/videoprocessor.h
@@ -0,0 +1,47 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, 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_SESSION_PHONE_VIDEOPROCESSOR_H_
+#define TALK_SESSION_PHONE_VIDEOPROCESSOR_H_
+
+#include "talk/base/sigslot.h"
+#include "talk/session/phone/videoframe.h"
+
+namespace cricket {
+
+class VideoProcessor : public sigslot::has_slots<> {
+ public:
+ virtual ~VideoProcessor() {}
+ // Contents of frame may be manipulated by the processor.
+ // The processed data is expected to be the same size as the
+ // original data
+ virtual void OnFrame(uint32 ssrc, VideoFrame* frame) = 0;
+};
+
+} // namespace cricket
+#endif // TALK_SESSION_PHONE_VIDEOPROCESSOR_H_
+
diff --git a/talk/session/phone/videorenderer.h b/talk/session/phone/videorenderer.h
index f1fe547..c428d57 100644
--- a/talk/session/phone/videorenderer.h
+++ b/talk/session/phone/videorenderer.h
@@ -28,6 +28,10 @@
#ifndef TALK_SESSION_PHONE_VIDEORENDERER_H_
#define TALK_SESSION_PHONE_VIDEORENDERER_H_
+#ifdef _DEBUG
+#include <string>
+#endif // _DEBUG
+
namespace cricket {
class VideoFrame;
@@ -40,6 +44,11 @@
virtual bool SetSize(int width, int height, int reserved) = 0;
// Called when a new frame is available for display.
virtual bool RenderFrame(const VideoFrame *frame) = 0;
+
+#ifdef _DEBUG
+ // Allow renderer dumping out rendered frames.
+ virtual bool SetDumpPath(const std::string &path) { return true; }
+#endif // _DEBUG
};
} // namespace cricket
diff --git a/talk/session/phone/voiceprocessor.h b/talk/session/phone/voiceprocessor.h
new file mode 100644
index 0000000..39bcfab
--- /dev/null
+++ b/talk/session/phone/voiceprocessor.h
@@ -0,0 +1,53 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, 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_SESSION_PHONE_VOICEPROCESSOR_H_
+#define TALK_SESSION_PHONE_VOICEPROCESSOR_H_
+
+#include "talk/base/basictypes.h"
+#include "talk/base/sigslot.h"
+#include "talk/session/phone/audioframe.h"
+
+namespace cricket {
+
+enum MediaProcessorDirection {
+ MPD_RX = 1 << 0,
+ MPD_TX = 1 << 1,
+ MPD_RX_AND_TX = MPD_RX | MPD_TX,
+};
+
+class VoiceProcessor : public sigslot::has_slots<> {
+ public:
+ virtual ~VoiceProcessor() {}
+ // Contents of frame may be manipulated by the processor.
+ // The processed data is expected to be the same size as the
+ // original data
+ virtual void OnFrame(uint32 ssrc, AudioFrame* frame) = 0;
+};
+
+} // namespace cricket
+#endif // TALK_SESSION_PHONE_VOICEPROCESSOR_H_
diff --git a/talk/session/phone/webrtcvideocapturer.cc b/talk/session/phone/webrtcvideocapturer.cc
new file mode 100644
index 0000000..c187238
--- /dev/null
+++ b/talk/session/phone/webrtcvideocapturer.cc
@@ -0,0 +1,368 @@
+// libjingle
+// Copyright 2004--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.
+//
+// Implementation of class WebRtcVideoCapturer.
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef HAVE_WEBRTC_VIDEO
+#include "talk/session/phone/webrtcvideocapturer.h"
+#include "talk/base/logging.h"
+#include "talk/base/thread.h"
+#include "talk/base/timeutils.h"
+#include "talk/session/phone/webrtcvideoframe.h"
+
+#include "talk/base/win32.h" // Need this to #include the impl files
+#ifdef WEBRTC_RELATIVE_PATH
+#include "modules/video_capture/main/interface/video_capture_factory.h"
+#else
+#include "third_party/webrtc/files/include/video_capture_factory.h"
+#endif
+
+namespace cricket {
+
+struct kVideoFourCCEntry {
+ uint32 fourcc;
+ webrtc::RawVideoType webrtc_type;
+};
+
+// This indicates our format preferences and defines a mapping between
+// webrtc::RawVideoType (from video_capture_defines.h) to our FOURCCs.
+static kVideoFourCCEntry kSupportedFourCCs[] = {
+ { FOURCC_I420, webrtc::kVideoI420 }, // 12 bpp, no conversion
+ { FOURCC_YV12, webrtc::kVideoYV12 }, // 12 bpp, no conversion
+ { FOURCC_NV12, webrtc::kVideoNV12 }, // 12 bpp, fast conversion
+ { FOURCC_NV21, webrtc::kVideoNV21 }, // 12 bpp, fast conversion
+ { FOURCC_YUY2, webrtc::kVideoYUY2 }, // 16 bpp, fast conversion
+ { FOURCC_UYVY, webrtc::kVideoUYVY }, // 16 bpp, fast conversion
+ { FOURCC_MJPG, webrtc::kVideoMJPEG }, // compressed, slow conversion
+ { FOURCC_ARGB, webrtc::kVideoARGB }, // 32 bpp, slow conversion
+ { FOURCC_24BG, webrtc::kVideoRGB24 }, // 32 bpp, slow conversion
+};
+
+class WebRtcVcmFactory : public WebRtcVcmFactoryInterface {
+ public:
+ virtual webrtc::VideoCaptureModule* Create(int id,
+ const WebRtc_UWord8* device) {
+ return webrtc::VideoCaptureFactory::Create(id, device);
+ }
+ virtual webrtc::VideoCaptureModule::DeviceInfo* CreateDeviceInfo(int id) {
+ return webrtc::VideoCaptureFactory::CreateDeviceInfo(id);
+ }
+ virtual void DestroyDeviceInfo(webrtc::VideoCaptureModule::DeviceInfo* info) {
+ delete info;
+ }
+};
+
+static bool CapabilityToFormat(const webrtc::VideoCaptureCapability& cap,
+ VideoFormat* format) {
+ uint32 fourcc = 0;
+ for (size_t i = 0; i < ARRAY_SIZE(kSupportedFourCCs); ++i) {
+ if (kSupportedFourCCs[i].webrtc_type == cap.rawType) {
+ fourcc = kSupportedFourCCs[i].fourcc;
+ break;
+ }
+ }
+ if (fourcc == 0) {
+ return false;
+ }
+
+ format->fourcc = fourcc;
+ format->width = cap.width;
+ format->height = cap.height;
+ format->interval = VideoFormat::FpsToInterval(cap.maxFPS);
+ return true;
+}
+
+static bool FormatToCapability(const VideoFormat& format,
+ webrtc::VideoCaptureCapability* cap) {
+ webrtc::RawVideoType webrtc_type = webrtc::kVideoUnknown;
+ for (size_t i = 0; i < ARRAY_SIZE(kSupportedFourCCs); ++i) {
+ if (kSupportedFourCCs[i].fourcc == format.fourcc) {
+ webrtc_type = kSupportedFourCCs[i].webrtc_type;
+ break;
+ }
+ }
+ if (webrtc_type == webrtc::kVideoUnknown) {
+ return false;
+ }
+
+ cap->width = format.width;
+ cap->height = format.height;
+ cap->maxFPS = VideoFormat::IntervalToFps(format.interval);
+ cap->expectedCaptureDelay = 0;
+ cap->rawType = webrtc_type;
+ cap->codecType = webrtc::kVideoCodecUnknown;
+ cap->interlaced = false;
+ return true;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// Implementation of class WebRtcVideoCapturer
+///////////////////////////////////////////////////////////////////////////
+
+WebRtcVideoCapturer::WebRtcVideoCapturer()
+ : factory_(new WebRtcVcmFactory),
+ module_(NULL),
+ captured_frames_(0) {
+}
+
+WebRtcVideoCapturer::WebRtcVideoCapturer(WebRtcVcmFactoryInterface* factory)
+ : factory_(factory),
+ module_(NULL),
+ captured_frames_(0) {
+}
+
+WebRtcVideoCapturer::~WebRtcVideoCapturer() {
+ if (module_) {
+ module_->Release();
+ }
+}
+
+bool WebRtcVideoCapturer::Init(const Device& device) {
+ if (module_) {
+ LOG(LS_ERROR) << "The capturer is already initialized";
+ return false;
+ }
+
+ webrtc::VideoCaptureModule::DeviceInfo* info = factory_->CreateDeviceInfo(0);
+ if (!info) {
+ return false;
+ }
+
+ // Find the desired camera, by name.
+ // In the future, comparing IDs will be more robust.
+ // TODO: Figure what's needed to allow this.
+ int num_cams = info->NumberOfDevices();
+ WebRtc_UWord8 vcm_id[256] = "";
+ bool found = false;
+ for (int index = 0; index < num_cams; ++index) {
+ WebRtc_UWord8 vcm_name[256];
+ if (info->GetDeviceName(index, vcm_name, ARRAY_SIZE(vcm_name),
+ vcm_id, ARRAY_SIZE(vcm_id)) != -1) {
+ if (device.name == reinterpret_cast<char*>(vcm_name)) {
+ found = true;
+ break;
+ }
+ }
+ }
+ if (!found) {
+ LOG(LS_WARNING) << "Failed to find capturer for id: " << device.id;
+ factory_->DestroyDeviceInfo(info);
+ return false;
+ }
+
+ // Enumerate the supported formats.
+ // TODO: Find out why this starts/stops the camera...
+ std::vector<VideoFormat> supported;
+ WebRtc_UWord32 num_caps = info->NumberOfCapabilities(vcm_id);
+ for (WebRtc_UWord8 i = 0; i < num_caps; ++i) {
+ webrtc::VideoCaptureCapability cap;
+ if (info->GetCapability(vcm_id, i, cap) != -1) {
+ VideoFormat format;
+ if (CapabilityToFormat(cap, &format)) {
+ supported.push_back(format);
+ } else {
+ LOG(LS_WARNING) << "Ignoring unsupported WebRTC capture format "
+ << cap.rawType;
+ }
+ }
+ }
+ factory_->DestroyDeviceInfo(info);
+ if (supported.empty()) {
+ LOG(LS_ERROR) << "Failed to find usable formats for id: " << device.id;
+ return false;
+ }
+
+ module_ = factory_->Create(0, vcm_id);
+ if (!module_) {
+ LOG(LS_ERROR) << "Failed to create capturer for id: " << device.id;
+ return false;
+ }
+
+ // It is safe to change member attributes now.
+ module_->AddRef();
+ SetId(device.id);
+ SetSupportedFormats(supported);
+ return true;
+}
+
+bool WebRtcVideoCapturer::Init(webrtc::VideoCaptureModule* module) {
+ if (module_) {
+ LOG(LS_ERROR) << "The capturer is already initialized";
+ return false;
+ }
+ if (!module) {
+ LOG(LS_ERROR) << "Invalid VCM supplied";
+ return false;
+ }
+ // TODO: Set id and formats.
+ (module_ = module)->AddRef();
+ return true;
+}
+
+bool WebRtcVideoCapturer::GetBestCaptureFormat(const VideoFormat& desired,
+ VideoFormat* best_format) {
+ if (!best_format) {
+ return false;
+ }
+
+ if (!VideoCapturer::GetBestCaptureFormat(desired, best_format)) {
+ // If the vcm has a list of the supported format, but didn't find the
+ // best match, then we should return fail.
+ if (GetSupportedFormats()) {
+ return false;
+ }
+
+ // We maybe using a manually injected VCM which doesn't support enum.
+ // Use the desired format as the best format.
+ best_format->width = desired.width;
+ best_format->height = desired.height;
+ best_format->fourcc = FOURCC_I420;
+ best_format->interval = desired.interval;
+ LOG(LS_INFO) << "Failed to find best capture format,"
+ << " fall back to the requested format "
+ << best_format->ToString();
+ }
+ return true;
+}
+
+CaptureResult WebRtcVideoCapturer::Start(const VideoFormat& capture_format) {
+ if (!module_) {
+ LOG(LS_ERROR) << "The capturer has not been initialized";
+ return CR_NO_DEVICE;
+ }
+
+ if (IsRunning()) {
+ LOG(LS_ERROR) << "The capturer is already running";
+ return CR_FAILURE;
+ }
+
+ SetCaptureFormat(&capture_format);
+
+ webrtc::VideoCaptureCapability cap;
+ if (!FormatToCapability(capture_format, &cap)) {
+ LOG(LS_ERROR) << "Invalid capture format specified";
+ return CR_FAILURE;
+ }
+
+ std::string camera_id(GetId());
+ uint32 start = talk_base::Time();
+ if (module_->RegisterCaptureDataCallback(*this) != 0 ||
+ module_->StartCapture(cap) != 0) {
+ LOG(LS_ERROR) << "Camera '" << camera_id << "' failed to start";
+ return CR_FAILURE;
+ }
+
+ LOG(LS_INFO) << "Camera '" << camera_id << "' started with format "
+ << capture_format.ToString() << ", elapsed time "
+ << talk_base::TimeSince(start) << " ms";
+
+ captured_frames_ = 0;
+ talk_base::Thread::Current()->Post(this);
+ return CR_PENDING;
+}
+
+void WebRtcVideoCapturer::Stop() {
+ if (IsRunning()) {
+ talk_base::Thread::Current()->Clear(this);
+ module_->StopCapture();
+ module_->DeRegisterCaptureDataCallback();
+
+ // TODO: Determine if the VCM exposes any drop stats we can use.
+ double drop_ratio = 0.0;
+ std::string camera_id(GetId());
+ LOG(LS_INFO) << "Camera '" << camera_id << "' stopped after capturing "
+ << captured_frames_ << " frames and dropping "
+ << drop_ratio << "%";
+ }
+ SetCaptureFormat(NULL);
+}
+
+bool WebRtcVideoCapturer::IsRunning() {
+ return (module_ != NULL && module_->CaptureStarted());
+}
+
+bool WebRtcVideoCapturer::GetPreferredFourccs(
+ std::vector<uint32>* fourccs) {
+ if (!fourccs) {
+ return false;
+ }
+
+ fourccs->clear();
+ for (size_t i = 0; i < ARRAY_SIZE(kSupportedFourCCs); ++i) {
+ fourccs->push_back(kSupportedFourCCs[i].fourcc);
+ }
+ return true;
+}
+
+void WebRtcVideoCapturer::OnMessage(talk_base::Message* message) {
+ // TODO: Fire SignalCaptureEvent appropriately.
+ SignalStartResult(this, CR_SUCCESS);
+}
+
+void WebRtcVideoCapturer::OnIncomingCapturedFrame(const WebRtc_Word32 id,
+ webrtc::VideoFrame& sample, webrtc::VideoCodecType codec_type) {
+ ASSERT(IsRunning());
+ ASSERT(codec_type == webrtc::kVideoCodecUnknown);
+
+ ++captured_frames_;
+ // Log the size and pixel aspect ratio of the first captured frame.
+ if (1 == captured_frames_) {
+ LOG(LS_INFO) << "Captured frame size "
+ << sample.Width() << "x" << sample.Height()
+ << ". Expected format " << GetCaptureFormat()->ToString();
+ }
+
+ // Signal down stream components on captured frame.
+ WebRtcCapturedFrame frame(sample);
+ SignalFrameCaptured(this, &frame);
+}
+
+void WebRtcVideoCapturer::OnCaptureDelayChanged(
+ const WebRtc_Word32 id, const WebRtc_Word32 delay) {
+ LOG(LS_INFO) << "Capture delay changed to " << delay << " ms";
+}
+
+// WebRtcCapturedFrame
+WebRtcCapturedFrame::WebRtcCapturedFrame(const webrtc::VideoFrame& sample) {
+ width = sample.Width();
+ height = sample.Height();
+ fourcc = FOURCC_I420;
+ pixel_width = 1;
+ pixel_height = 1;
+ // convert units from VideoFrame RenderTimeMs
+ // to CapturedFrame (nanoseconds)
+ elapsed_time = sample.RenderTimeMs() * talk_base::kNumNanosecsPerMillisec;
+ time_stamp = elapsed_time;
+ data_size = sample.Length();
+ data = const_cast<WebRtc_UWord8*>(sample.Buffer());
+}
+
+} // namespace cricket
+
+#endif // HAVE_WEBRTC_VIDEO
diff --git a/talk/session/phone/webrtcvideocapturer.h b/talk/session/phone/webrtcvideocapturer.h
new file mode 100644
index 0000000..a9cc3e8
--- /dev/null
+++ b/talk/session/phone/webrtcvideocapturer.h
@@ -0,0 +1,102 @@
+// libjingle
+// Copyright 2004 Google Inc.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+// 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_SESSION_PHONE_WEBRTCVIDEOCAPTURER_H_
+#define TALK_SESSION_PHONE_WEBRTCVIDEOCAPTURER_H_
+
+#ifdef HAVE_WEBRTC_VIDEO
+
+#include <string>
+#include <vector>
+
+#include "talk/base/messagehandler.h"
+#include "talk/session/phone/videocapturer.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 cricket {
+
+// Factory to allow injection of a VCM impl into WebRtcVideoCapturer.
+// DeviceInfos do not have a Release() and therefore need an explicit Destroy().
+class WebRtcVcmFactoryInterface {
+ public:
+ virtual ~WebRtcVcmFactoryInterface() {}
+ virtual webrtc::VideoCaptureModule* Create(
+ int id, const WebRtc_UWord8* device) = 0;
+ virtual webrtc::VideoCaptureModule::DeviceInfo* CreateDeviceInfo(int id) = 0;
+ virtual void DestroyDeviceInfo(
+ webrtc::VideoCaptureModule::DeviceInfo* info) = 0;
+};
+
+// WebRTC-based implementation of VideoCapturer.
+class WebRtcVideoCapturer : public VideoCapturer,
+ public talk_base::MessageHandler,
+ public webrtc::VideoCaptureDataCallback {
+ public:
+ WebRtcVideoCapturer();
+ explicit WebRtcVideoCapturer(WebRtcVcmFactoryInterface* factory);
+ virtual ~WebRtcVideoCapturer();
+
+ bool Init(const Device& device);
+ bool Init(webrtc::VideoCaptureModule* module);
+
+ // Override virtual methods of the parent class VideoCapturer.
+ virtual bool GetBestCaptureFormat(const VideoFormat& desired,
+ VideoFormat* best_format);
+ virtual CaptureResult Start(const VideoFormat& capture_format);
+ virtual void Stop();
+ virtual bool IsRunning();
+
+ protected:
+ // Override virtual methods of the parent class VideoCapturer.
+ virtual bool GetPreferredFourccs(std::vector<uint32>* fourccs);
+
+ private:
+ // Callback for our started event.
+ virtual void OnMessage(talk_base::Message* message);
+ // Callback when a frame is captured by camera.
+ virtual void OnIncomingCapturedFrame(const WebRtc_Word32 id,
+ webrtc::VideoFrame& frame,
+ webrtc::VideoCodecType type);
+ virtual void OnCaptureDelayChanged(const WebRtc_Word32 id,
+ const WebRtc_Word32 delay);
+
+ talk_base::scoped_ptr<WebRtcVcmFactoryInterface> factory_;
+ webrtc::VideoCaptureModule* module_;
+ int captured_frames_;
+};
+
+struct WebRtcCapturedFrame : public CapturedFrame {
+ public:
+ explicit WebRtcCapturedFrame(const webrtc::VideoFrame& frame);
+};
+
+} // namespace cricket
+
+#endif // HAVE_WEBRTC_VIDEO
+#endif // TALK_SESSION_PHONE_WEBRTCVIDEOCAPTURER_H_
diff --git a/talk/session/phone/webrtcvideocapturer_unittest.cc b/talk/session/phone/webrtcvideocapturer_unittest.cc
new file mode 100644
index 0000000..c883844
--- /dev/null
+++ b/talk/session/phone/webrtcvideocapturer_unittest.cc
@@ -0,0 +1,145 @@
+// libjingle
+// Copyright 2004--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 <stdio.h>
+#include <vector>
+#include "talk/base/gunit.h"
+#include "talk/base/logging.h"
+#include "talk/base/stringutils.h"
+#include "talk/base/thread.h"
+#include "talk/session/phone/fakewebrtcvcmfactory.h"
+#include "talk/session/phone/testutils.h"
+#include "talk/session/phone/videocommon.h"
+#include "talk/session/phone/webrtcvideocapturer.h"
+
+using cricket::VideoFormat;
+
+static const std::string kTestDeviceName = "JuberTech FakeCam Q123";
+static const std::string kTestDeviceId = "foo://bar/baz";
+const VideoFormat kDefaultVideoFormat =
+ VideoFormat(640, 400, VideoFormat::FpsToInterval(30), cricket::FOURCC_ANY);
+
+class WebRtcVideoCapturerTest : public testing::Test {
+ public:
+ WebRtcVideoCapturerTest()
+ : factory_(new FakeWebRtcVcmFactory),
+ capturer_(new cricket::WebRtcVideoCapturer(factory_)),
+ listener_(capturer_.get()) {
+ factory_->device_info.AddDevice(kTestDeviceName, kTestDeviceId);
+ // add a VGA/I420 capability
+ webrtc::VideoCaptureCapability vga;
+ vga.width = 640;
+ vga.height = 480;
+ vga.maxFPS = 30;
+ vga.rawType = webrtc::kVideoI420;
+ factory_->device_info.AddCapability(kTestDeviceId, vga);
+ }
+
+ protected:
+ FakeWebRtcVcmFactory* factory_; // owned by capturer_
+ talk_base::scoped_ptr<cricket::WebRtcVideoCapturer> capturer_;
+ cricket::VideoCapturerListener listener_;
+};
+
+TEST_F(WebRtcVideoCapturerTest, TestNotOpened) {
+ EXPECT_EQ("", capturer_->GetId());
+ EXPECT_EQ(NULL, capturer_->GetSupportedFormats());
+ EXPECT_TRUE(capturer_->GetCaptureFormat() == NULL);
+ EXPECT_FALSE(capturer_->IsRunning());
+}
+
+TEST_F(WebRtcVideoCapturerTest, TestBadInit) {
+ EXPECT_FALSE(capturer_->Init(cricket::Device("bad-name", "bad-id")));
+ EXPECT_FALSE(capturer_->IsRunning());
+}
+
+TEST_F(WebRtcVideoCapturerTest, TestInit) {
+ EXPECT_TRUE(capturer_->Init(cricket::Device(kTestDeviceName, kTestDeviceId)));
+ EXPECT_EQ(kTestDeviceId, capturer_->GetId());
+ EXPECT_TRUE(NULL != capturer_->GetSupportedFormats());
+ ASSERT_EQ(1U, capturer_->GetSupportedFormats()->size());
+ EXPECT_EQ(640, (*capturer_->GetSupportedFormats())[0].width);
+ EXPECT_EQ(480, (*capturer_->GetSupportedFormats())[0].height);
+ EXPECT_TRUE(capturer_->GetCaptureFormat() == NULL); // not started yet
+ EXPECT_FALSE(capturer_->IsRunning());
+}
+
+TEST_F(WebRtcVideoCapturerTest, TestInitVcm) {
+ EXPECT_TRUE(capturer_->Init(factory_->Create(0,
+ reinterpret_cast<const WebRtc_UWord8*>(kTestDeviceId.c_str()))));
+}
+
+TEST_F(WebRtcVideoCapturerTest, TestCapture) {
+ EXPECT_TRUE(capturer_->Init(cricket::Device(kTestDeviceName, kTestDeviceId)));
+ cricket::VideoFormat format(
+ capturer_->GetSupportedFormats()->at(0));
+ EXPECT_EQ(cricket::CR_PENDING, capturer_->Start(format));
+ EXPECT_TRUE(capturer_->IsRunning());
+ ASSERT_TRUE(capturer_->GetCaptureFormat() != NULL);
+ EXPECT_EQ(format, *capturer_->GetCaptureFormat());
+ EXPECT_EQ_WAIT(cricket::CR_SUCCESS, listener_.start_result(), 1000);
+ EXPECT_TRUE(factory_->modules[0]->SendFrame(640, 480));
+ EXPECT_TRUE_WAIT(listener_.frame_count() > 0, 5000);
+ EXPECT_EQ(capturer_->GetCaptureFormat()->fourcc, listener_.frame_fourcc());
+ EXPECT_EQ(640, listener_.frame_width());
+ EXPECT_EQ(480, listener_.frame_height());
+ EXPECT_EQ(cricket::CR_FAILURE, capturer_->Start(format));
+ capturer_->Stop();
+ EXPECT_FALSE(capturer_->IsRunning());
+ EXPECT_TRUE(capturer_->GetCaptureFormat() == NULL);
+}
+
+TEST_F(WebRtcVideoCapturerTest, TestCaptureVcm) {
+ EXPECT_TRUE(capturer_->Init(factory_->Create(0,
+ reinterpret_cast<const WebRtc_UWord8*>(kTestDeviceId.c_str()))));
+ EXPECT_FALSE(capturer_->GetSupportedFormats());
+ VideoFormat format;
+ EXPECT_TRUE(capturer_->GetBestCaptureFormat(kDefaultVideoFormat, &format));
+ EXPECT_EQ(kDefaultVideoFormat.width, format.width);
+ EXPECT_EQ(kDefaultVideoFormat.height, format.height);
+ EXPECT_EQ(kDefaultVideoFormat.interval, format.interval);
+ EXPECT_EQ(cricket::FOURCC_I420, format.fourcc);
+ EXPECT_EQ(cricket::CR_PENDING, capturer_->Start(format));
+ EXPECT_TRUE(capturer_->IsRunning());
+ ASSERT_TRUE(capturer_->GetCaptureFormat() != NULL);
+ EXPECT_EQ(format, *capturer_->GetCaptureFormat());
+ EXPECT_EQ_WAIT(cricket::CR_SUCCESS, listener_.start_result(), 1000);
+ EXPECT_TRUE(factory_->modules[0]->SendFrame(640, 480));
+ EXPECT_TRUE_WAIT(listener_.frame_count() > 0, 5000);
+ EXPECT_EQ(capturer_->GetCaptureFormat()->fourcc, listener_.frame_fourcc());
+ EXPECT_EQ(640, listener_.frame_width());
+ EXPECT_EQ(480, listener_.frame_height());
+ EXPECT_EQ(cricket::CR_FAILURE, capturer_->Start(format));
+ capturer_->Stop();
+ EXPECT_FALSE(capturer_->IsRunning());
+ EXPECT_TRUE(capturer_->GetCaptureFormat() == NULL);
+}
+
+TEST_F(WebRtcVideoCapturerTest, TestCaptureWithoutInit) {
+ cricket::VideoFormat format;
+ EXPECT_EQ(cricket::CR_NO_DEVICE, capturer_->Start(format));
+ EXPECT_TRUE(capturer_->GetCaptureFormat() == NULL);
+ EXPECT_FALSE(capturer_->IsRunning());
+}
diff --git a/talk/session/phone/webrtcvideoengine.cc b/talk/session/phone/webrtcvideoengine.cc
index d0d71ad..07ab5e6 100644
--- a/talk/session/phone/webrtcvideoengine.cc
+++ b/talk/session/phone/webrtcvideoengine.cc
@@ -25,18 +25,26 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
#ifdef HAVE_WEBRTC_VIDEO
#include "talk/session/phone/webrtcvideoengine.h"
+#include "talk/base/basictypes.h"
#include "talk/base/common.h"
#include "talk/base/buffer.h"
#include "talk/base/byteorder.h"
#include "talk/base/logging.h"
#include "talk/base/stringutils.h"
+#include "talk/session/phone/rtputils.h"
+#include "talk/session/phone/streamparams.h"
#include "talk/session/phone/videorenderer.h"
#include "talk/session/phone/webrtcpassthroughrender.h"
#include "talk/session/phone/webrtcvoiceengine.h"
+#include "talk/session/phone/webrtcvideocapturer.h"
#include "talk/session/phone/webrtcvideoframe.h"
#include "talk/session/phone/webrtcvie.h"
#include "talk/session/phone/webrtcvoe.h"
@@ -44,32 +52,75 @@
namespace cricket {
static const int kDefaultLogSeverity = talk_base::LS_WARNING;
+
+static const int kMinVideoBitrate = 100;
static const int kStartVideoBitrate = 300;
-static const int kMaxVideoBitrate = 1000;
+static const int kMaxVideoBitrate = 2000;
+static const int kConferenceModeMaxVideoBitrate = 500;
+
+static const int kVideoMtu = 1200;
+
static const int kVideoRtpBufferSize = 65536;
+static const char kVp8PayloadName[] = "VP8";
+static const char kRedPayloadName[] = "red";
+static const char kFecPayloadName[] = "ulpfec";
+
+static const int kDefaultNumberOfTemporalLayers = 3;
+
+static void LogMultiline(talk_base::LoggingSeverity sev, char* text) {
+ const char* delim = "\r\n";
+ for (char* tok = strtok(text, delim); tok; tok = strtok(NULL, delim)) {
+ LOG_V(sev) << tok;
+ }
+}
+
class WebRtcRenderAdapter : public webrtc::ExternalRenderer {
public:
explicit WebRtcRenderAdapter(VideoRenderer* renderer)
- : renderer_(renderer) {
+ : renderer_(renderer), width_(0), height_(0) {
+ }
+ virtual ~WebRtcRenderAdapter() {
}
+ void SetRenderer(VideoRenderer* renderer) {
+ talk_base::CritScope cs(&crit_);
+ renderer_ = renderer;
+ }
+ // Implementation of webrtc::ExternalRenderer.
virtual int FrameSizeChange(unsigned int width, unsigned int height,
unsigned int /*number_of_streams*/) {
- if (renderer_ == NULL)
+ talk_base::CritScope cs(&crit_);
+ if (renderer_ == NULL) {
return 0;
+ }
+ LOG(LS_INFO) << "WebRtcRenderAdapter frame size changed to: "
+ << width << "x" << height;
width_ = width;
height_ = height;
return renderer_->SetSize(width_, height_, 0) ? 0 : -1;
}
-
virtual int DeliverFrame(unsigned char* buffer, int buffer_size,
unsigned int time_stamp) {
- if (renderer_ == NULL)
+ talk_base::CritScope cs(&crit_);
+ frame_rate_tracker_.Update(1);
+ if (renderer_ == NULL) {
return 0;
+ }
WebRtcVideoFrame video_frame;
+ // Convert 90K timestamp to ns timestamp.
+ int64 time_stamp_in_ns = (time_stamp / 90) *
+ talk_base::kNumNanosecsPerMillisec;
video_frame.Attach(buffer, buffer_size, width_, height_,
- 1, 1, 0, time_stamp, 0);
+ 1, 1, 0, time_stamp_in_ns, 0);
+
+
+ // Sanity check on decoded frame size.
+ if (buffer_size != static_cast<int>(VideoFrame::SizeOf(width_, height_))) {
+ LOG(LS_WARNING) << "WebRtcRenderAdapter received a strange frame size: "
+ << buffer_size;
+ }
+
int ret = renderer_->RenderFrame(&video_frame) ? 0 : -1;
uint8* buffer_temp;
size_t buffer_size_temp;
@@ -77,71 +128,221 @@
return ret;
}
- virtual ~WebRtcRenderAdapter() {}
+ unsigned int width() {
+ talk_base::CritScope cs(&crit_);
+ return width_;
+ }
+ unsigned int height() {
+ talk_base::CritScope cs(&crit_);
+ return height_;
+ }
+ int framerate() {
+ talk_base::CritScope cs(&crit_);
+ return frame_rate_tracker_.units_second();
+ }
+ VideoRenderer* renderer() {
+ talk_base::CritScope cs(&crit_);
+ return renderer_;
+ }
private:
+ talk_base::CriticalSection crit_;
VideoRenderer* renderer_;
unsigned int width_;
unsigned int height_;
+ talk_base::RateTracker frame_rate_tracker_;
+};
+
+class WebRtcDecoderObserver : public webrtc::ViEDecoderObserver {
+ public:
+ explicit WebRtcDecoderObserver(int video_channel)
+ : video_channel_(video_channel),
+ framerate_(0),
+ bitrate_(0),
+ firs_requested_(0) {
+ }
+
+ // virtual functions from VieDecoderObserver.
+ virtual void IncomingCodecChanged(const int videoChannel,
+ const webrtc::VideoCodec& videoCodec) {}
+ virtual void IncomingRate(const int videoChannel,
+ const unsigned int framerate,
+ const unsigned int bitrate) {
+ ASSERT(video_channel_ == videoChannel);
+ framerate_ = framerate;
+ bitrate_ = bitrate;
+ }
+ virtual void RequestNewKeyFrame(const int videoChannel) {
+ ASSERT(video_channel_ == videoChannel);
+ ++firs_requested_;
+ }
+
+ int framerate() const { return framerate_; }
+ int bitrate() const { return bitrate_; }
+ int firs_requested() const { return firs_requested_; }
+
+ private:
+ int video_channel_;
+ int framerate_;
+ int bitrate_;
+ int firs_requested_;
+};
+
+class WebRtcEncoderObserver : public webrtc::ViEEncoderObserver {
+ public:
+ explicit WebRtcEncoderObserver(int video_channel)
+ : video_channel_(video_channel),
+ framerate_(0),
+ bitrate_(0) {
+ }
+
+ // virtual functions from VieEncoderObserver.
+ virtual void OutgoingRate(const int videoChannel,
+ const unsigned int framerate,
+ const unsigned int bitrate) {
+ ASSERT(video_channel_ == videoChannel);
+ framerate_ = framerate;
+ bitrate_ = bitrate;
+ }
+
+ int framerate() const { return framerate_; }
+ int bitrate() const { return bitrate_; }
+
+ private:
+ int video_channel_;
+ int framerate_;
+ int bitrate_;
+};
+
+class WebRtcLocalStreamInfo {
+ public:
+ int width() {
+ talk_base::CritScope cs(&crit_);
+ return width_;
+ }
+ int height() {
+ talk_base::CritScope cs(&crit_);
+ return height_;
+ }
+ int framerate() {
+ talk_base::CritScope cs(&crit_);
+ return rate_tracker_.units_second();
+ }
+
+ void UpdateFrame(int width, int height) {
+ talk_base::CritScope cs(&crit_);
+ width_ = width;
+ height_ = height;
+ rate_tracker_.Update(1);
+ }
+
+ private:
+ talk_base::CriticalSection crit_;
+ unsigned int width_;
+ unsigned int height_;
+ talk_base::RateTracker rate_tracker_;
+};
+
+// WebRtcVideoChannelInfo is a container class with members such as renderer
+// and a decoder observer that is used by receive channels.
+// It must exist as long as the receive channel is connected to renderer or a
+// decoder observer in this class and methods in the class should only be called
+// from the worker thread.
+class WebRtcVideoChannelInfo {
+ public:
+ explicit WebRtcVideoChannelInfo(int channel_id)
+ : channel_id_(channel_id),
+ render_adapter_(NULL),
+ decoder_observer_(channel_id) {
+ }
+ int channel_id() { return channel_id_; }
+ void SetRenderer(VideoRenderer* renderer) {
+ render_adapter_.SetRenderer(renderer);
+ }
+ WebRtcRenderAdapter* render_adapter() { return &render_adapter_; }
+ WebRtcDecoderObserver* decoder_observer() { return &decoder_observer_; }
+
+ private:
+ int channel_id_; // Webrtc video channel number.
+ // Renderer for this channel.
+ WebRtcRenderAdapter render_adapter_;
+ WebRtcDecoderObserver decoder_observer_;
};
const WebRtcVideoEngine::VideoCodecPref
WebRtcVideoEngine::kVideoCodecPrefs[] = {
- {"VP8", 120, 0},
+ {kVp8PayloadName, 100, 0},
+ {kRedPayloadName, 101, 1},
+ {kFecPayloadName, 102, 2},
};
+static const int64 kNsPerFrame = 33333333; // 30fps
+
// The formats are sorted by the descending order of width. We use the order to
// find the next format for CPU and bandwidth adaptation.
-const VideoFormat WebRtcVideoEngine::kVideoFormats[] = {
- // TODO: Understand why we have problem with 16:9 formats.
- VideoFormat(1280, 800, VideoFormat::FpsToInterval(30), FOURCC_ANY),
-//VideoFormat(1280, 720, VideoFormat::FpsToInterval(30), FOURCC_ANY),
- VideoFormat(960, 600, VideoFormat::FpsToInterval(30), FOURCC_ANY),
-//VideoFormat(960, 540, VideoFormat::FpsToInterval(30), FOURCC_ANY),
- VideoFormat(640, 400, VideoFormat::FpsToInterval(30), FOURCC_ANY),
-//VideoFormat(640, 360, VideoFormat::FpsToInterval(30), FOURCC_ANY),
- VideoFormat(480, 300, VideoFormat::FpsToInterval(30), FOURCC_ANY),
-//VideoFormat(480, 270, VideoFormat::FpsToInterval(30), FOURCC_ANY),
- VideoFormat(320, 200, VideoFormat::FpsToInterval(30), FOURCC_ANY),
-//VideoFormat(320, 180, VideoFormat::FpsToInterval(30), FOURCC_ANY),
- VideoFormat(240, 150, VideoFormat::FpsToInterval(30), FOURCC_ANY),
-//VideoFormat(240, 135, VideoFormat::FpsToInterval(30), FOURCC_ANY),
- VideoFormat(160, 100, VideoFormat::FpsToInterval(30), FOURCC_ANY),
-//VideoFormat(160, 90, VideoFormat::FpsToInterval(30), FOURCC_ANY),
+const VideoFormatPod WebRtcVideoEngine::kVideoFormats[] = {
+ {1280, 800, kNsPerFrame, FOURCC_ANY},
+ {1280, 720, kNsPerFrame, FOURCC_ANY},
+ {960, 600, kNsPerFrame, FOURCC_ANY},
+ {960, 540, kNsPerFrame, FOURCC_ANY},
+ {640, 400, kNsPerFrame, FOURCC_ANY},
+ {640, 360, kNsPerFrame, FOURCC_ANY},
+ {640, 480, kNsPerFrame, FOURCC_ANY},
+ {480, 300, kNsPerFrame, FOURCC_ANY},
+ {480, 270, kNsPerFrame, FOURCC_ANY},
+ {480, 360, kNsPerFrame, FOURCC_ANY},
+ {320, 200, kNsPerFrame, FOURCC_ANY},
+ {320, 180, kNsPerFrame, FOURCC_ANY},
+ {320, 240, kNsPerFrame, FOURCC_ANY},
+ {240, 150, kNsPerFrame, FOURCC_ANY},
+ {240, 135, kNsPerFrame, FOURCC_ANY},
+ {240, 180, kNsPerFrame, FOURCC_ANY},
+ {160, 100, kNsPerFrame, FOURCC_ANY},
+ {160, 90, kNsPerFrame, FOURCC_ANY},
+ {160, 120, kNsPerFrame, FOURCC_ANY},
};
-// TODO: Understand why 640x400 is not working.
-const VideoFormat WebRtcVideoEngine::kDefaultVideoFormat =
- VideoFormat(320, 200, VideoFormat::FpsToInterval(30), FOURCC_ANY);
+const VideoFormatPod WebRtcVideoEngine::kDefaultVideoFormat =
+ {640, 400, kNsPerFrame, FOURCC_ANY};
-WebRtcVideoEngine::WebRtcVideoEngine()
- : vie_wrapper_(new ViEWrapper()),
- voice_engine_(NULL) {
- Construct();
+WebRtcVideoEngine::WebRtcVideoEngine() {
+ Construct(new ViEWrapper(), new ViETraceWrapper(), NULL);
}
WebRtcVideoEngine::WebRtcVideoEngine(WebRtcVoiceEngine* voice_engine,
- ViEWrapper* vie_wrapper)
- : vie_wrapper_(vie_wrapper),
- voice_engine_(voice_engine) {
- Construct();
+ ViEWrapper* vie_wrapper) {
+ Construct(vie_wrapper, new ViETraceWrapper(), voice_engine);
}
-void WebRtcVideoEngine::Construct() {
- initialized_ = false;
- capture_id_ = -1;
- capture_module_ = NULL;
- external_capture_ = false;
- log_level_ = kDefaultLogSeverity;
- capture_started_ = false;
- render_module_.reset(new WebRtcPassthroughRender());
+WebRtcVideoEngine::WebRtcVideoEngine(WebRtcVoiceEngine* voice_engine,
+ ViEWrapper* vie_wrapper,
+ ViETraceWrapper* tracing) {
+ Construct(vie_wrapper, tracing, voice_engine);
+}
- ApplyLogging();
- if (vie_wrapper_->engine()->SetTraceCallback(this) != 0) {
+void WebRtcVideoEngine::Construct(ViEWrapper* vie_wrapper,
+ ViETraceWrapper* tracing,
+ WebRtcVoiceEngine* voice_engine) {
+ LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine";
+ vie_wrapper_.reset(vie_wrapper);
+ vie_wrapper_base_initialized_ = false;
+ tracing_.reset(tracing);
+ voice_engine_ = voice_engine;
+ initialized_ = false;
+ log_level_ = kDefaultLogSeverity;
+ render_module_.reset(new WebRtcPassthroughRender());
+ local_renderer_w_ = local_renderer_h_ = 0;
+ local_renderer_ = NULL;
+ owns_capturer_ = false;
+ video_capturer_ = NULL;
+ capture_started_ = false;
+
+ ApplyLogging("");
+ if (tracing_->SetTraceCallback(this) != 0) {
LOG_RTCERR1(SetTraceCallback, this);
}
- // Set default quality levels for our supported codecs. We override them here
+ // Set default quality levels for our supported codecs. We override them here
// if we know your cpu performance is low, and they can be updated explicitly
// by calling SetDefaultCodec. For example by a flute preference setting, or
// by the server with a jec in response to our reported system info.
@@ -149,20 +350,22 @@
kVideoCodecPrefs[0].name,
kDefaultVideoFormat.width,
kDefaultVideoFormat.height,
- kDefaultVideoFormat.framerate(), 0);
+ VideoFormat::IntervalToFps(kDefaultVideoFormat.interval),
+ 0);
if (!SetDefaultCodec(max_codec)) {
LOG(LS_ERROR) << "Failed to initialize list of supported codec types";
}
}
WebRtcVideoEngine::~WebRtcVideoEngine() {
- LOG(LS_INFO) << " WebRtcVideoEngine::~WebRtcVideoEngine";
- vie_wrapper_->engine()->SetTraceCallback(NULL);
- Terminate();
- vie_wrapper_.reset();
- if (capture_module_) {
- capture_module_->Release();
+ ClearCapturer();
+ LOG(LS_INFO) << "WebRtcVideoEngine::~WebRtcVideoEngine";
+ if (initialized_) {
+ Terminate();
}
+ tracing_->SetTraceCallback(NULL);
+ // Test to see if the media processor was deregistered properly.
+ ASSERT(SignalMediaFrame.is_empty());
}
bool WebRtcVideoEngine::Init() {
@@ -180,11 +383,26 @@
bool WebRtcVideoEngine::InitVideoEngine() {
LOG(LS_INFO) << "WebRtcVideoEngine::InitVideoEngine";
- if (vie_wrapper_->base()->Init() != 0) {
- LOG_RTCERR0(Init);
+ // Init WebRTC VideoEngine.
+ if (!vie_wrapper_base_initialized_) {
+ if (vie_wrapper_->base()->Init() != 0) {
+ LOG_RTCERR0(Init);
+ return false;
+ }
+ vie_wrapper_base_initialized_ = true;
+ }
+
+ // Log the VoiceEngine version info.
+ char buffer[1024] = "";
+ if (vie_wrapper_->base()->GetVersion(buffer) != 0) {
+ LOG_RTCERR0(GetVersion);
return false;
}
+ LOG(LS_INFO) << "WebRtc VideoEngine Version:";
+ LogMultiline(talk_base::LS_INFO, buffer);
+
+ // Hook up to VoiceEngine for sync purposes, if supplied.
if (!voice_engine_) {
LOG(LS_WARNING) << "NULL voice engine";
} else if ((vie_wrapper_->base()->SetVoiceEngine(
@@ -193,69 +411,460 @@
return false;
}
+ // Register for callbacks from the engine.
if ((vie_wrapper_->base()->RegisterObserver(*this)) != 0) {
LOG_RTCERR0(RegisterObserver);
return false;
}
+ // Register our custom render module.
if (vie_wrapper_->render()->RegisterVideoRenderModule(
- *render_module_.get()) != 0) {
+ *render_module_.get()) != 0) {
LOG_RTCERR0(RegisterVideoRenderModule);
return false;
}
- std::sort(video_codecs_.begin(), video_codecs_.end(),
- &VideoCodec::Preferable);
-
initialized_ = true;
return true;
}
-void WebRtcVideoEngine::PerformanceAlarm(const unsigned int cpu_load) {
- LOG(LS_INFO) << "WebRtcVideoEngine::PerformanceAlarm";
+void WebRtcVideoEngine::Terminate() {
+ LOG(LS_INFO) << "WebRtcVideoEngine::Terminate";
+ initialized_ = false;
+ SetCapture(false);
+
+ if (vie_wrapper_->render()->DeRegisterVideoRenderModule(
+ *render_module_.get()) != 0) {
+ LOG_RTCERR0(DeRegisterVideoRenderModule);
+ }
+
+ if (vie_wrapper_->base()->DeregisterObserver() != 0) {
+ LOG_RTCERR0(DeregisterObserver);
+ }
+
+ if (vie_wrapper_->base()->SetVoiceEngine(NULL) != 0) {
+ LOG_RTCERR0(SetVoiceEngine);
+ }
}
-// Ignore spammy trace messages, mostly from the stats API when we haven't
-// gotten RTCP info yet from the remote side.
-static bool ShouldIgnoreTrace(const std::string& trace) {
- static const char* kTracesToIgnore[] = {
- "\tfailed to GetReportBlockInformation",
- NULL
- };
- for (const char* const* p = kTracesToIgnore; *p; ++p) {
- if (trace.find(*p) == 0) {
+int WebRtcVideoEngine::GetCapabilities() {
+ return VIDEO_RECV | VIDEO_SEND;
+}
+
+bool WebRtcVideoEngine::SetOptions(int options) {
+ return true;
+}
+
+bool WebRtcVideoEngine::SetDefaultEncoderConfig(
+ const VideoEncoderConfig& config) {
+ return SetDefaultCodec(config.max_codec);
+}
+
+// SetDefaultCodec may be called while the capturer is running. For example, a
+// test call is started in a page with QVGA default codec, and then a real call
+// is started in another page with VGA default codec. This is the corner case
+// and happens only when a session is started. We ignore this case currently.
+bool WebRtcVideoEngine::SetDefaultCodec(const VideoCodec& codec) {
+ if (!RebuildCodecList(codec)) {
+ LOG(LS_WARNING) << "Failed to RebuildCodecList";
+ return false;
+ }
+
+ default_codec_format_ = VideoFormat(
+ video_codecs_[0].width,
+ video_codecs_[0].height,
+ VideoFormat::FpsToInterval(video_codecs_[0].framerate),
+ FOURCC_ANY);
+ return true;
+}
+
+WebRtcVideoMediaChannel* WebRtcVideoEngine::CreateChannel(
+ VoiceMediaChannel* voice_channel) {
+ WebRtcVideoMediaChannel* channel =
+ new WebRtcVideoMediaChannel(this, voice_channel);
+ if (!channel->Init()) {
+ delete channel;
+ channel = NULL;
+ }
+ return channel;
+}
+
+bool WebRtcVideoEngine::SetCaptureDevice(const Device* device) {
+ const bool owns_capturer = true;
+ if (!device) {
+ if (!SetCapturer(NULL, owns_capturer)) {
+ return false;
+ }
+ LOG(LS_INFO) << "Camera set to NULL";
+ return true;
+ }
+ // No-op if the device hasn't changed.
+ if ((video_capturer_ != NULL) && video_capturer_->GetId() == device->id) {
+ return true;
+ }
+ // Create a new capturer for the specified device.
+ VideoCapturer* capturer = CreateVideoCapturer(*device);
+ if (!capturer) {
+ LOG(LS_ERROR) << "Failed to create camera '" << device->name << "', id='"
+ << device->id << "'";
+ return false;
+ }
+ if (!SetCapturer(capturer, owns_capturer)) {
+ return false;
+ }
+ LOG(LS_INFO) << "Camera set to '" << device->name << "', id='"
+ << device->id << "'";
+ return true;
+}
+
+bool WebRtcVideoEngine::SetCaptureModule(webrtc::VideoCaptureModule* vcm) {
+ const bool owns_capturer = true;
+ if (!vcm) {
+ if (!SetCapturer(NULL, owns_capturer)) {
+ return false;
+ }
+ LOG(LS_INFO) << "Camera set to NULL";
+ return true;
+ }
+ // Create a new capturer for the specified device.
+ WebRtcVideoCapturer* capturer = new WebRtcVideoCapturer;
+ if (!capturer->Init(vcm)) {
+ LOG(LS_ERROR) << "Failed to create camera from VCM";
+ delete capturer;
+ return false;
+ }
+ if (!SetCapturer(capturer, owns_capturer)) {
+ return false;
+ }
+ LOG(LS_INFO) << "Camera created with VCM";
+ CaptureResult ret = SetCapture(true);
+ if (ret != cricket::CR_SUCCESS && ret != cricket::CR_PENDING) {
+ LOG(LS_ERROR) << "Failed to start camera.";
+ return false;
+ }
+ return true;
+}
+
+bool WebRtcVideoEngine::SetVideoCapturer(VideoCapturer* capturer,
+ uint32 /*ssrc*/) {
+ const bool owns_capturer = false;
+ return SetCapturer(capturer, owns_capturer);
+}
+
+bool WebRtcVideoEngine::SetLocalRenderer(VideoRenderer* renderer) {
+ local_renderer_w_ = local_renderer_h_ = 0;
+ local_renderer_ = renderer;
+ return true;
+}
+
+CaptureResult WebRtcVideoEngine::SetCapture(bool capture) {
+ bool old_capture = capture_started_;
+ capture_started_ = capture;
+ CaptureResult res = UpdateCapturingState();
+ if (res != CR_SUCCESS && res != CR_PENDING) {
+ capture_started_ = old_capture;
+ }
+ return res;
+}
+
+VideoCapturer* WebRtcVideoEngine::CreateVideoCapturer(const Device& device) {
+ WebRtcVideoCapturer* capturer = new WebRtcVideoCapturer;
+ if (!capturer->Init(device)) {
+ delete capturer;
+ return NULL;
+ }
+ return capturer;
+}
+
+CaptureResult WebRtcVideoEngine::UpdateCapturingState() {
+ CaptureResult result = CR_SUCCESS;
+
+ bool capture = capture_started_;
+ if (!IsCapturing() && capture) { // Start capturing.
+ if (video_capturer_ == NULL) {
+ return CR_NO_DEVICE;
+ }
+
+ VideoFormat capture_format;
+ if (!video_capturer_->GetBestCaptureFormat(default_codec_format_,
+ &capture_format)) {
+ LOG(LS_WARNING) << "Unsupported format:"
+ << " width=" << default_codec_format_.width
+ << " height=" << default_codec_format_.height
+ << ". Supported formats are:";
+ const std::vector<VideoFormat>* formats =
+ video_capturer_->GetSupportedFormats();
+ if (formats) {
+ for (std::vector<VideoFormat>::const_iterator i = formats->begin();
+ i != formats->end(); ++i) {
+ const VideoFormat& format = *i;
+ LOG(LS_WARNING) << " " << GetFourccName(format.fourcc) << ":"
+ << format.width << "x" << format.height << "x"
+ << format.framerate();
+ }
+ }
+ return CR_FAILURE;
+ }
+
+ // Start the video capturer.
+ result = video_capturer_->Start(capture_format);
+ if (CR_SUCCESS != result && CR_PENDING != result) {
+ LOG(LS_ERROR) << "Failed to start the video capturer";
+ return result;
+ }
+ } else if (IsCapturing() && !capture) { // Stop capturing.
+ video_capturer_->Stop();
+ }
+
+ return result;
+}
+
+bool WebRtcVideoEngine::IsCapturing() const {
+ return (video_capturer_ != NULL) && video_capturer_->IsRunning();
+}
+
+void WebRtcVideoEngine::OnFrameCaptured(VideoCapturer* capturer,
+ const CapturedFrame* frame) {
+ // Force 16:10 for now. We'll be smarter with the capture refactor.
+ int cropped_height = frame->width * default_codec_format_.height
+ / default_codec_format_.width;
+ if (cropped_height > frame->height) {
+ // TODO: Once we support horizontal cropping, add cropped_width.
+ cropped_height = frame->height;
+ }
+
+ // This CapturedFrame* will already be in I420. In the future, when
+ // WebRtcVideoFrame has support for independent planes, we can just attach
+ // to it and update the pointers when cropping.
+ WebRtcVideoFrame i420_frame;
+ if (!i420_frame.Init(frame, frame->width, cropped_height)) {
+ LOG(LS_ERROR) << "Couldn't convert to I420! "
+ << frame->width << " x " << cropped_height;
+ return;
+ }
+
+ // TODO: This is the trigger point for Tx video processing.
+ // Once the capturer refactoring is done, we will move this into the
+ // capturer...it's not there right now because that image is in not in the
+ // I420 color space.
+ // The clients that subscribe will obtain meta info from the frame.
+ // When this trigger is switched over to capturer, need to pass in the real
+ // ssrc.
+ {
+ talk_base::CritScope cs(&signal_media_critical_);
+ SignalMediaFrame(kDummyVideoSsrc, &i420_frame);
+ }
+
+ // Send I420 frame to the local renderer.
+ if (local_renderer_) {
+ if (local_renderer_w_ != static_cast<int>(i420_frame.GetWidth()) ||
+ local_renderer_h_ != static_cast<int>(i420_frame.GetHeight())) {
+ local_renderer_->SetSize(local_renderer_w_ = i420_frame.GetWidth(),
+ local_renderer_h_ = i420_frame.GetHeight(), 0);
+ }
+ local_renderer_->RenderFrame(&i420_frame);
+ }
+
+ // Send I420 frame to the registered senders.
+ talk_base::CritScope cs(&channels_crit_);
+ for (VideoChannels::iterator it = channels_.begin();
+ it != channels_.end(); ++it) {
+ if ((*it)->sending()) (*it)->SendFrame(0, &i420_frame);
+ }
+}
+
+const std::vector<VideoCodec>& WebRtcVideoEngine::codecs() const {
+ return video_codecs_;
+}
+
+void WebRtcVideoEngine::SetLogging(int min_sev, const char* filter) {
+ // if min_sev == -1, we keep the current log level.
+ if (min_sev >= 0) {
+ log_level_ = min_sev;
+ }
+ ApplyLogging(filter);
+}
+
+int WebRtcVideoEngine::GetLastEngineError() {
+ return vie_wrapper_->error();
+}
+
+// Checks to see whether we comprehend and could receive a particular codec
+bool WebRtcVideoEngine::FindCodec(const VideoCodec& in) {
+ for (int i = 0; i < ARRAY_SIZE(kVideoFormats); ++i) {
+ const VideoFormat fmt(kVideoFormats[i]);
+ if ((in.width == 0 && in.height == 0) ||
+ (fmt.width == in.width && fmt.height == in.height)) {
+ for (int j = 0; j < ARRAY_SIZE(kVideoCodecPrefs); ++j) {
+ VideoCodec codec(kVideoCodecPrefs[j].payload_type,
+ kVideoCodecPrefs[j].name, 0, 0, 0, 0);
+ if (codec.Matches(in)) {
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+}
+
+// Given the requested codec, returns true if we can send that codec type and
+// updates out with the best quality we could send for that codec. If current is
+// not empty, we constrain out so that its aspect ratio matches current's.
+bool WebRtcVideoEngine::CanSendCodec(const VideoCodec& requested,
+ const VideoCodec& current,
+ VideoCodec* out) {
+ if (!out) {
+ return false;
+ }
+
+ std::vector<VideoCodec>::const_iterator local_max;
+ for (local_max = video_codecs_.begin();
+ local_max < video_codecs_.end();
+ ++local_max) {
+ // First match codecs by payload type
+ if (!requested.Matches(local_max->id, local_max->name)) {
+ continue;
+ }
+
+ out->id = requested.id;
+ out->name = requested.name;
+ out->preference = requested.preference;
+ out->framerate = talk_base::_min(requested.framerate, local_max->framerate);
+ out->width = 0;
+ out->height = 0;
+
+ if (0 == requested.width && 0 == requested.height) {
+ // Special case with resolution 0. The channel should not send frames.
+ return true;
+ } else if (0 == requested.width || 0 == requested.height) {
+ // 0xn and nx0 are invalid resolutions.
+ return false;
+ }
+
+ // Pick the best quality that is within their and our bounds and has the
+ // correct aspect ratio.
+ for (int j = 0; j < ARRAY_SIZE(kVideoFormats); ++j) {
+ const VideoFormat format(kVideoFormats[j]);
+
+ // Skip any format that is larger than the local or remote maximums, or
+ // smaller than the current best match
+ if (format.width > requested.width || format.height > requested.height ||
+ format.width > local_max->width ||
+ (format.width < out->width && format.height < out->height)) {
+ continue;
+ }
+
+ bool better = false;
+
+ // Check any further constraints on this prospective format
+ if (!out->width || !out->height) {
+ // If we don't have any matches yet, this is the best so far.
+ better = true;
+ } else if (current.width && current.height) {
+ // current is set so format must match its ratio exactly.
+ better =
+ (format.width * current.height == format.height * current.width);
+ } else {
+ // Prefer closer aspect ratios i.e
+ // format.aspect - requested.aspect < out.aspect - requested.aspect
+ better = abs(format.width * requested.height * out->height -
+ requested.width * format.height * out->height) <
+ abs(out->width * format.height * requested.height -
+ requested.width * format.height * out->height);
+ }
+
+ if (better) {
+ out->width = format.width;
+ out->height = format.height;
+ }
+ }
+ if (out->width > 0) {
return true;
}
}
return false;
}
-void WebRtcVideoEngine::Print(const webrtc::TraceLevel level,
- const char* trace, const int length) {
- talk_base::LoggingSeverity sev = talk_base::LS_VERBOSE;
- if (level == webrtc::kTraceError || level == webrtc::kTraceCritical)
- sev = talk_base::LS_ERROR;
- else if (level == webrtc::kTraceWarning)
- sev = talk_base::LS_WARNING;
- else if (level == webrtc::kTraceStateInfo || level == webrtc::kTraceInfo)
- sev = talk_base::LS_INFO;
-
- if (sev >= log_level_) {
- // Skip past boilerplate prefix text
- if (length < 72) {
- std::string msg(trace, length);
- LOG(LS_ERROR) << "Malformed webrtc log message: ";
- LOG_V(sev) << msg;
- } else {
- std::string msg(trace + 71, length - 72);
- if (!ShouldIgnoreTrace(msg)) {
- LOG_V(sev) << "WebRtc ViE:" << msg;
- }
- }
- }
+void WebRtcVideoEngine::ConvertToCricketVideoCodec(
+ const webrtc::VideoCodec& in_codec, VideoCodec* out_codec) {
+ out_codec->id = in_codec.plType;
+ out_codec->name = in_codec.plName;
+ out_codec->width = in_codec.width;
+ out_codec->height = in_codec.height;
+ out_codec->framerate = in_codec.maxFramerate;
}
-void WebRtcVideoEngine::ApplyLogging() {
+bool WebRtcVideoEngine::ConvertFromCricketVideoCodec(
+ const VideoCodec& in_codec, webrtc::VideoCodec* out_codec) {
+ bool found = false;
+ int ncodecs = vie_wrapper_->codec()->NumberOfCodecs();
+ for (int i = 0; i < ncodecs; ++i) {
+ if (vie_wrapper_->codec()->GetCodec(i, *out_codec) == 0 &&
+ _stricmp(in_codec.name.c_str(), out_codec->plName) == 0) {
+ found = true;
+ break;
+ }
+ }
+
+ if (!found) {
+ LOG(LS_ERROR) << "invalid codec type";
+ return false;
+ }
+
+ if (in_codec.id != 0)
+ out_codec->plType = in_codec.id;
+
+ if (in_codec.width != 0)
+ out_codec->width = in_codec.width;
+
+ if (in_codec.height != 0)
+ out_codec->height = in_codec.height;
+
+ if (in_codec.framerate != 0)
+ out_codec->maxFramerate = in_codec.framerate;
+
+ // Init the codec with the default bandwidth options.
+ out_codec->minBitrate = kMinVideoBitrate;
+ out_codec->startBitrate = kStartVideoBitrate;
+ out_codec->maxBitrate = kMaxVideoBitrate;
+
+ return true;
+}
+
+void WebRtcVideoEngine::RegisterChannel(WebRtcVideoMediaChannel *channel) {
+ talk_base::CritScope cs(&channels_crit_);
+ channels_.push_back(channel);
+}
+
+void WebRtcVideoEngine::UnregisterChannel(WebRtcVideoMediaChannel *channel) {
+ talk_base::CritScope cs(&channels_crit_);
+ channels_.erase(std::remove(channels_.begin(), channels_.end(), channel),
+ channels_.end());
+}
+
+bool WebRtcVideoEngine::SetVoiceEngine(WebRtcVoiceEngine* voice_engine) {
+ if (initialized_) {
+ LOG(LS_WARNING) << "SetVoiceEngine can not be called after Init";
+ return false;
+ }
+ voice_engine_ = voice_engine;
+ return true;
+}
+
+bool WebRtcVideoEngine::EnableTimedRender() {
+ if (initialized_) {
+ LOG(LS_WARNING) << "EnableTimedRender can not be called after Init";
+ return false;
+ }
+ render_module_.reset(webrtc::VideoRender::CreateVideoRender(0, NULL,
+ false, webrtc::kRenderExternal));
+ return true;
+}
+
+// See https://sites.google.com/a/google.com/wavelet/
+// Home/Magic-Flute--RTC-Engine-/Magic-Flute-Command-Line-Parameters
+// for all supported command line setttings.
+void WebRtcVideoEngine::ApplyLogging(const std::string& log_filter) {
int filter = 0;
switch (log_level_) {
case talk_base::LS_VERBOSE: filter |= webrtc::kTraceAll;
@@ -264,6 +873,19 @@
case talk_base::LS_ERROR: filter |=
webrtc::kTraceError | webrtc::kTraceCritical;
}
+ tracing_->SetTraceFilter(filter);
+
+ // Set WebRTC trace file.
+ std::vector<std::string> opts;
+ talk_base::tokenize(log_filter, ' ', '"', '"', &opts);
+ std::vector<std::string>::iterator tracefile =
+ std::find(opts.begin(), opts.end(), "tracefile");
+ if (tracefile != opts.end() && ++tracefile != opts.end()) {
+ // Write WebRTC debug output (at same loglevel) to file
+ if (tracing_->SetTraceFile(tracefile->c_str()) == -1) {
+ LOG_RTCERR1(SetTraceFile, *tracefile);
+ }
+ }
}
// Rebuilds the codec list to be only those that are less intensive
@@ -290,324 +912,101 @@
return true;
}
-void WebRtcVideoEngine::Terminate() {
- LOG(LS_INFO) << "WebRtcVideoEngine::Terminate";
- initialized_ = false;
- SetCapture(false);
- if (local_renderer_.get()) {
- // If the renderer already set, stop it first
- if (vie_wrapper_->render()->StopRender(capture_id_) != 0)
- LOG_RTCERR1(StopRender, capture_id_);
- }
-
- if (vie_wrapper_->render()->DeRegisterVideoRenderModule(
- *render_module_.get()) != 0)
- LOG_RTCERR0(DeRegisterVideoRenderModule);
-
- if ((vie_wrapper_->base()->DeregisterObserver()) != 0)
- LOG_RTCERR0(DeregisterObserver);
-
- if ((vie_wrapper_->base()->SetVoiceEngine(NULL)) != 0)
- LOG_RTCERR0(SetVoiceEngine);
-
- if (vie_wrapper_->engine()->SetTraceCallback(NULL) != 0)
- LOG_RTCERR0(SetTraceCallback);
-}
-
-int WebRtcVideoEngine::GetCapabilities() {
- return VIDEO_RECV | VIDEO_SEND;
-}
-
-bool WebRtcVideoEngine::SetOptions(int options) {
- return true;
-}
-
-bool WebRtcVideoEngine::ReleaseCaptureDevice() {
- if (capture_id_ != -1) {
- // Stop capture
- SetCapture(false);
- // DisconnectCaptureDevice
- WebRtcVideoMediaChannel* channel;
- for (VideoChannels::const_iterator it = channels_.begin();
- it != channels_.end(); ++it) {
- ASSERT(*it != NULL);
- channel = *it;
- // Ignore the return value here as the channel may not have connected to
- // the capturer yet.
- vie_wrapper_->capture()->DisconnectCaptureDevice(
- channel->video_channel());
- channel->set_connected(false);
- }
- // ReleaseCaptureDevice
- vie_wrapper_->capture()->ReleaseCaptureDevice(capture_id_);
- capture_id_ = -1;
- }
-
- return true;
-}
-
-bool WebRtcVideoEngine::SetCaptureDevice(const Device* cam) {
- ASSERT(cam != NULL);
-
- ReleaseCaptureDevice();
-
- webrtc::ViECapture* vie_capture = vie_wrapper_->capture();
-
- // There's an external VCM
- if (capture_module_) {
- if (vie_capture->AllocateCaptureDevice(*capture_module_, capture_id_) != 0)
- ASSERT(capture_id_ == -1);
- } else if (!external_capture_) {
- char device_name[256], device_id[256];
- bool found = false;
- for (int i = 0; i < vie_capture->NumberOfCaptureDevices(); ++i) {
- if (vie_capture->GetCaptureDevice(i, device_name, ARRAY_SIZE(device_name),
- device_id,
- ARRAY_SIZE(device_id)) == 0) {
- // TODO: We should only compare the device_id here,
- // however the devicemanager and webrtc use different format for th v4l2
- // device id. So here we also compare the device_name for now.
- // For example "usb-0000:00:1d.7-6" vs "/dev/video0".
- if (cam->name.compare(device_name) == 0 ||
- cam->id.compare(device_id) == 0) {
- LOG(INFO) << "Found video capture device: " << device_name;
- found = true;
- break;
- }
- }
- }
- if (!found) {
+bool WebRtcVideoEngine::SetCapturer(VideoCapturer* capturer,
+ bool own_capturer) {
+ if (capturer == NULL) {
+ // Stop capturing before clearing the capturer.
+ if (SetCapture(false) != CR_SUCCESS) {
+ LOG(LS_WARNING) << "Camera failed to stop";
return false;
}
- if (vie_capture->AllocateCaptureDevice(device_id, strlen(device_id),
- capture_id_) != 0) {
- ASSERT(capture_id_ == -1);
- }
+ ClearCapturer();
+ return true;
}
-
- if (capture_id_ != -1) {
- // Connect to all the channels if there is any.
- WebRtcVideoMediaChannel* channel;
- for (VideoChannels::const_iterator it = channels_.begin();
- it != channels_.end(); ++it) {
- ASSERT(*it != NULL);
- channel = *it;
-
- // No channel should have been connected yet.
- // In case of switching device, all channel connections should have been
- // disconnected in ReleaseCaptureDevice() first.
- ASSERT(!channel->connected());
-
- if (vie_capture->ConnectCaptureDevice(capture_id_,
- channel->video_channel()) == 0) {
- channel->set_connected(true);
- } else {
- LOG(LS_WARNING) << "SetCaptureDevice failed to ConnectCaptureDevice.";
- }
- }
- SetCapture(true);
- }
-
- return (capture_id_ != -1);
-}
-
-bool WebRtcVideoEngine::SetCaptureModule(webrtc::VideoCaptureModule* vcm) {
- ReleaseCaptureDevice();
- if (capture_module_) {
- capture_module_->Release();
- capture_module_ = NULL;
- }
-
- if (vcm) {
- capture_module_ = vcm;
- capture_module_->AddRef();
- external_capture_ = true;
- } else {
- external_capture_ = false;
- }
-
- return true;
-}
-
-bool WebRtcVideoEngine::SetLocalRenderer(VideoRenderer* renderer) {
- if (local_renderer_.get()) {
- // If the renderer already set, stop and remove it first
- if (vie_wrapper_->render()->StopRender(capture_id_) != 0) {
- LOG_RTCERR1(StopRender, capture_id_);
- }
- if (vie_wrapper_->render()->RemoveRenderer(capture_id_) != 0) {
- LOG_RTCERR1(RemoveRenderer, capture_id_);
- }
- }
- local_renderer_.reset(new WebRtcRenderAdapter(renderer));
-
- int ret;
- ret = vie_wrapper_->render()->AddRenderer(capture_id_,
- webrtc::kVideoI420,
- local_renderer_.get());
- if (ret != 0)
+ // Hook up signals and install the supplied capturer.
+ SignalCaptureResult.repeat(capturer->SignalStartResult);
+ capturer->SignalFrameCaptured.connect(this,
+ &WebRtcVideoEngine::OnFrameCaptured);
+ ClearCapturer();
+ video_capturer_ = capturer;
+ owns_capturer_ = own_capturer;
+ // Possibly restart the capturer if it is supposed to be running.
+ CaptureResult result = UpdateCapturingState();
+ if (result != CR_SUCCESS && result != CR_PENDING) {
+ LOG(LS_WARNING) << "Camera failed to restart";
return false;
- ret = vie_wrapper_->render()->StartRender(capture_id_);
- return (ret == 0);
-}
-
-CaptureResult WebRtcVideoEngine::SetCapture(bool capture) {
- if ((capture_started_ != capture) && (capture_id_ != -1)) {
- int ret;
- if (capture)
- ret = vie_wrapper_->capture()->StartCapture(capture_id_);
- else
- ret = vie_wrapper_->capture()->StopCapture(capture_id_);
- if (ret != 0)
- return CR_NO_DEVICE;
- capture_started_ = capture;
}
- return CR_SUCCESS;
-}
-
-const std::vector<VideoCodec>& WebRtcVideoEngine::codecs() const {
- return video_codecs_;
-}
-
-void WebRtcVideoEngine::SetLogging(int min_sev, const char* filter) {
- log_level_ = min_sev;
- ApplyLogging();
-}
-
-int WebRtcVideoEngine::GetLastEngineError() {
- return vie_wrapper_->error();
-}
-
-bool WebRtcVideoEngine::SetDefaultEncoderConfig(
- const VideoEncoderConfig& config) {
- default_encoder_config_ = config;
return true;
}
-WebRtcVideoMediaChannel* WebRtcVideoEngine::CreateChannel(
- VoiceMediaChannel* voice_channel) {
- WebRtcVideoMediaChannel* channel =
- new WebRtcVideoMediaChannel(this, voice_channel);
- if (channel) {
- if (!channel->Init()) {
- delete channel;
- channel = NULL;
- }
- }
- return channel;
+void WebRtcVideoEngine::PerformanceAlarm(const unsigned int cpu_load) {
+ LOG(LS_INFO) << "WebRtcVideoEngine::PerformanceAlarm";
}
-// Checks to see whether we comprehend and could receive a particular codec
-bool WebRtcVideoEngine::FindCodec(const VideoCodec& in) {
- for (int i = 0; i < ARRAY_SIZE(kVideoFormats); ++i) {
- const VideoFormat& fmt = kVideoFormats[i];
- if ((in.width == 0 && in.height == 0) ||
- (fmt.width == in.width && fmt.height == in.height)) {
- for (int j = 0; j < ARRAY_SIZE(kVideoCodecPrefs); ++j) {
- VideoCodec codec(kVideoCodecPrefs[j].payload_type,
- kVideoCodecPrefs[j].name, 0, 0, 0, 0);
- if (codec.Matches(in)) {
- return true;
- }
- }
+// Ignore spammy trace messages, mostly from the stats API when we haven't
+// gotten RTCP info yet from the remote side.
+bool WebRtcVideoEngine::ShouldIgnoreTrace(const std::string& trace) {
+ static const char* const kTracesToIgnore[] = {
+ NULL
+ };
+ for (const char* const* p = kTracesToIgnore; *p; ++p) {
+ if (trace.find(*p) == 0) {
+ return true;
}
}
return false;
}
-// SetDefaultCodec may be called while the capturer is running. For example, a
-// test call is started in a page with QVGA default codec, and then a real call
-// is started in another page with VGA default codec. This is the corner case
-// and happens only when a session is started. We ignore this case currently.
-bool WebRtcVideoEngine::SetDefaultCodec(const VideoCodec& codec) {
- if (!RebuildCodecList(codec)) {
- LOG(LS_WARNING) << "Failed to RebuildCodecList";
- return false;
- }
- return true;
+int WebRtcVideoEngine::GetNumOfChannels() {
+ talk_base::CritScope cs(&channels_crit_);
+ return channels_.size();
}
-void WebRtcVideoEngine::ConvertToCricketVideoCodec(
- const webrtc::VideoCodec& in_codec, VideoCodec& out_codec) {
- out_codec.id = in_codec.plType;
- out_codec.name = in_codec.plName;
- out_codec.width = in_codec.width;
- out_codec.height = in_codec.height;
- out_codec.framerate = in_codec.maxFramerate;
-}
+void WebRtcVideoEngine::Print(const webrtc::TraceLevel level,
+ const char* trace, const int length) {
+ talk_base::LoggingSeverity sev = talk_base::LS_VERBOSE;
+ if (level == webrtc::kTraceError || level == webrtc::kTraceCritical)
+ sev = talk_base::LS_ERROR;
+ else if (level == webrtc::kTraceWarning)
+ sev = talk_base::LS_WARNING;
+ else if (level == webrtc::kTraceStateInfo || level == webrtc::kTraceInfo)
+ sev = talk_base::LS_INFO;
-bool WebRtcVideoEngine::ConvertFromCricketVideoCodec(
- const VideoCodec& in_codec, webrtc::VideoCodec& out_codec) {
- bool found = false;
- int ncodecs = vie_wrapper_->codec()->NumberOfCodecs();
- for (int i = 0; i < ncodecs; ++i) {
- if ((vie_wrapper_->codec()->GetCodec(i, out_codec) == 0) &&
- (strncmp(out_codec.plName,
- in_codec.name.c_str(),
- webrtc::kPayloadNameSize - 1) == 0)) {
- found = true;
- break;
+ if (sev >= log_level_) {
+ // Skip past boilerplate prefix text
+ if (length < 72) {
+ std::string msg(trace, length);
+ LOG(LS_ERROR) << "Malformed webrtc log message: ";
+ LOG_V(sev) << msg;
+ } else {
+ std::string msg(trace + 71, length - 72);
+ if (!ShouldIgnoreTrace(msg) &&
+ (!voice_engine_ || !voice_engine_->ShouldIgnoreTrace(msg))) {
+ LOG_V(sev) << "WebRtc:" << msg;
+ }
}
}
+}
- if (!found) {
- LOG(LS_ERROR) << "invalid codec type";
- return false;
- }
-
- if (in_codec.id != 0)
- out_codec.plType = in_codec.id;
-
- if (in_codec.width != 0)
- out_codec.width = in_codec.width;
-
- if (in_codec.height != 0)
- out_codec.height = in_codec.height;
-
- if (in_codec.framerate != 0)
- out_codec.maxFramerate = in_codec.framerate;
-
- out_codec.maxBitrate = kMaxVideoBitrate;
- out_codec.startBitrate = kStartVideoBitrate;
- out_codec.minBitrate = kStartVideoBitrate;
-
+bool WebRtcVideoEngine::RegisterProcessor(
+ VideoProcessor* video_processor) {
+ talk_base::CritScope cs(&signal_media_critical_);
+ SignalMediaFrame.connect(video_processor,
+ &VideoProcessor::OnFrame);
+ return true;
+}
+bool WebRtcVideoEngine::UnregisterProcessor(
+ VideoProcessor* video_processor) {
+ talk_base::CritScope cs(&signal_media_critical_);
+ SignalMediaFrame.disconnect(video_processor);
return true;
}
-int WebRtcVideoEngine::GetLastVideoEngineError() {
- return vie_wrapper_->base()->LastError();
-}
-
-void WebRtcVideoEngine::RegisterChannel(WebRtcVideoMediaChannel *channel) {
- channels_.push_back(channel);
-}
-
-void WebRtcVideoEngine::UnregisterChannel(WebRtcVideoMediaChannel *channel) {
- VideoChannels::iterator i = std::find(channels_.begin(),
- channels_.end(),
- channel);
- if (i != channels_.end()) {
- channels_.erase(i);
+void WebRtcVideoEngine::ClearCapturer() {
+ if (owns_capturer_) {
+ delete video_capturer_;
}
-}
-
-bool WebRtcVideoEngine::SetVoiceEngine(WebRtcVoiceEngine* voice_engine) {
- if (initialized_) {
- LOG(LS_WARNING) << "SetVoiceEngine can not be called after Init.";
- return false;
- }
- voice_engine_ = voice_engine;
- return true;
-}
-
-bool WebRtcVideoEngine::EnableTimedRender() {
- if (initialized_) {
- LOG(LS_WARNING) << "EnableTimedRender can not be called after Init.";
- return false;
- }
- render_module_.reset(webrtc::VideoRender::CreateVideoRender(0, NULL,
- false, webrtc::kRenderExternal));
- return true;
+ video_capturer_ = NULL;
}
// WebRtcVideoMediaChannel
@@ -617,296 +1016,608 @@
: engine_(engine),
voice_channel_(channel),
vie_channel_(-1),
+ vie_capture_(-1),
+ external_capture_(NULL),
sending_(false),
- connected_(false),
render_started_(false),
- send_codec_(NULL) {
+ muted_(false),
+ local_ssrc_(0),
+ first_receive_ssrc_(0),
+ send_min_bitrate_(kMinVideoBitrate),
+ send_start_bitrate_(kStartVideoBitrate),
+ send_max_bitrate_(kMaxVideoBitrate),
+ local_stream_info_(new WebRtcLocalStreamInfo()),
+ channel_options_(0) {
engine->RegisterChannel(this);
}
bool WebRtcVideoMediaChannel::Init() {
- bool ret = true;
- if (engine_->video_engine()->base()->CreateChannel(vie_channel_) != 0) {
+ if (engine_->vie()->base()->CreateChannel(vie_channel_) != 0) {
LOG_RTCERR1(CreateChannel, vie_channel_);
return false;
}
+ if (!ConfigureChannel(vie_channel_)) {
+ engine_->vie()->base()->DeleteChannel(vie_channel_);
+ vie_channel_ = -1;
+ return false;
+ }
+
+ if (!ConfigureReceiving(vie_channel_, 0)) {
+ engine_->vie()->base()->DeleteChannel(vie_channel_);
+ vie_channel_ = -1;
+ return false;
+ }
LOG(LS_INFO) << "WebRtcVideoMediaChannel::Init "
- << "video_channel " << vie_channel_ << " created";
+ << "vie_channel " << vie_channel_ << " created";
- // connect audio channel
- if (voice_channel_) {
- WebRtcVoiceMediaChannel* channel =
- static_cast<WebRtcVoiceMediaChannel*> (voice_channel_);
- if (engine_->video_engine()->base()->ConnectAudioChannel(
- vie_channel_, channel->voe_channel()) != 0) {
- LOG(LS_WARNING) << "ViE ConnectAudioChannel failed"
- << "A/V not synchronized";
- // Don't set ret to false;
- }
+ // Register external capture.
+ if (engine()->vie()->capture()->AllocateExternalCaptureDevice(
+ vie_capture_, external_capture_) != 0) {
+ LOG_RTCERR0(AllocateExternalCaptureDevice);
+ return false;
}
- // Register external transport
- if (engine_->video_engine()->network()->RegisterSendTransport(
- vie_channel_, *this) != 0) {
- ret = false;
- } else {
- EnableRtcp();
- EnablePLI();
+ // Connect external capture.
+ if (engine()->vie()->capture()->ConnectCaptureDevice(
+ vie_capture_, vie_channel_) != 0) {
+ LOG_RTCERR2(ConnectCaptureDevice, vie_capture_, vie_channel_);
+ return false;
}
- return ret;
+
+ // Register encoder observer for outgoing framerate and bitrate.
+ encoder_observer_.reset(new WebRtcEncoderObserver(vie_channel_));
+ if (engine()->vie()->codec()->RegisterEncoderObserver(
+ vie_channel_, *encoder_observer_) != 0) {
+ LOG_RTCERR1(RegisterEncoderObserver, encoder_observer_.get());
+ return false;
+ }
+
+ return true;
}
WebRtcVideoMediaChannel::~WebRtcVideoMediaChannel() {
- // Stop and remote renderer
- SetRender(false);
- if (engine()->video_engine()->render()->RemoveRenderer(vie_channel_)
- == -1) {
- LOG_RTCERR1(RemoveRenderer, vie_channel_);
+ if (vie_channel_ != -1) {
+ // Stop sending.
+ SetSend(false);
+ if (engine()->vie()->codec()->DeregisterEncoderObserver(
+ vie_channel_) != 0) {
+ LOG_RTCERR1(DeregisterEncoderObserver, vie_channel_);
+ }
+
+ // Stop the renderer.
+ SetRender(false);
+
+ // Destroy the external capture interface.
+ if (vie_capture_ != -1) {
+ if (engine()->vie()->capture()->DisconnectCaptureDevice(
+ vie_channel_) != 0) {
+ LOG_RTCERR1(DisconnectCaptureDevice, vie_channel_);
+ }
+ if (engine()->vie()->capture()->ReleaseCaptureDevice(
+ vie_capture_) != 0) {
+ LOG_RTCERR1(ReleaseCaptureDevice, vie_capture_);
+ }
+ }
+
+ // Remove all receive streams and the default channel.
+ while (!mux_channels_.empty()) {
+ RemoveRecvStream(mux_channels_.begin()->first);
+ }
}
- // DeRegister external transport
- if (engine()->video_engine()->network()->DeregisterSendTransport(
- vie_channel_) == -1) {
- LOG_RTCERR1(DeregisterSendTransport, vie_channel_);
- }
-
- // Unregister RtcChannel with the engine.
+ // Unregister the channel from the engine.
engine()->UnregisterChannel(this);
-
- // Delete VideoChannel
- if (engine()->video_engine()->base()->DeleteChannel(vie_channel_) == -1) {
- LOG_RTCERR1(DeleteChannel, vie_channel_);
- }
}
bool WebRtcVideoMediaChannel::SetRecvCodecs(
const std::vector<VideoCodec>& codecs) {
- bool ret = true;
+ receive_codecs_.clear();
for (std::vector<VideoCodec>::const_iterator iter = codecs.begin();
iter != codecs.end(); ++iter) {
if (engine()->FindCodec(*iter)) {
webrtc::VideoCodec wcodec;
- if (engine()->ConvertFromCricketVideoCodec(*iter, wcodec)) {
- if (engine()->video_engine()->codec()->SetReceiveCodec(
- vie_channel_, wcodec) != 0) {
- LOG_RTCERR2(SetReceiveCodec, vie_channel_, wcodec.plName);
- ret = false;
- }
+ if (engine()->ConvertFromCricketVideoCodec(*iter, &wcodec)) {
+ receive_codecs_.push_back(wcodec);
}
} else {
- LOG(LS_INFO) << "Unknown codec" << iter->name;
- ret = false;
+ LOG(LS_INFO) << "Unknown codec " << iter->name;
+ return false;
}
}
- // make channel ready to receive packets
- if (ret) {
- if (engine()->video_engine()->base()->StartReceive(vie_channel_) != 0) {
- LOG_RTCERR1(StartReceive, vie_channel_);
- ret = false;
- }
+ for (ChannelMap::iterator it = mux_channels_.begin();
+ it != mux_channels_.end(); ++it) {
+ if (!SetReceiveCodecs(it->second->channel_id()))
+ return false;
}
- return ret;
+ return true;
}
bool WebRtcVideoMediaChannel::SetSendCodecs(
const std::vector<VideoCodec>& codecs) {
- if (sending_) {
- LOG(LS_ERROR) << "channel is alredy sending";
- return false;
- }
-
- // match with local video codec list
+ // Match with local video codec list.
std::vector<webrtc::VideoCodec> send_codecs;
+ int red_type = -1, fec_type = -1;
+ VideoCodec checked_codec;
+ VideoCodec current; // defaults to 0x0
+ if (sending_) {
+ engine()->ConvertToCricketVideoCodec(*send_codec_, ¤t);
+ }
for (std::vector<VideoCodec>::const_iterator iter = codecs.begin();
iter != codecs.end(); ++iter) {
- if (engine()->FindCodec(*iter)) {
+ if (_stricmp(iter->name.c_str(), kRedPayloadName) == 0) {
+ red_type = iter->id;
+ } else if (_stricmp(iter->name.c_str(), kFecPayloadName) == 0) {
+ fec_type = iter->id;
+ } else if (engine()->CanSendCodec(*iter, current, &checked_codec)) {
webrtc::VideoCodec wcodec;
- if (engine()->ConvertFromCricketVideoCodec(*iter, wcodec))
+ if (engine()->ConvertFromCricketVideoCodec(checked_codec, &wcodec)) {
send_codecs.push_back(wcodec);
+ }
+ } else {
+ LOG(LS_WARNING) << "Unknown codec " << iter->name;
}
}
- // if none matches, return with set
+ // Fail if we don't have a match.
if (send_codecs.empty()) {
- LOG(LS_ERROR) << "No matching codecs avilable";
+ LOG(LS_WARNING) << "No matching codecs avilable";
return false;
}
- // select the first matched codec
- const webrtc::VideoCodec& codec(send_codecs[0]);
- send_codec_.reset(new webrtc::VideoCodec(codec));
- if (engine()->video_engine()->codec()->SetSendCodec(
- vie_channel_, codec) != 0) {
- LOG_RTCERR2(SetSendCodec, vie_channel_, codec.plName);
+ // Configure video protection.
+ if (!SetNackFec(vie_channel_, red_type, fec_type)) {
return false;
}
+
+ // Select the first matched codec.
+ webrtc::VideoCodec& codec(send_codecs[0]);
+
+ // Set the default number of temporal layers for VP8.
+ if (webrtc::kVideoCodecVP8 == codec.codecType) {
+ codec.codecSpecific.VP8.numberOfTemporalLayers =
+ kDefaultNumberOfTemporalLayers;
+ }
+
+ if (!SetSendCodec(
+ codec, send_min_bitrate_, send_start_bitrate_, send_max_bitrate_)) {
+ return false;
+ }
+
+ LOG(LS_INFO) << "Selected video codec " << send_codec_->plName << "/"
+ << send_codec_->width << "x" << send_codec_->height << "x"
+ << static_cast<int>(send_codec_->maxFramerate);
+ if (webrtc::kVideoCodecVP8 == codec.codecType) {
+ LOG(LS_INFO) << "VP8 number of layers: "
+ << static_cast<int>(
+ send_codec_->codecSpecific.VP8.numberOfTemporalLayers);
+ }
return true;
}
+bool WebRtcVideoMediaChannel::SetSendStreamFormat(uint32 ssrc,
+ const VideoFormat& format) {
+ // TODO: Handle multiple outgoing streams.
+ if (local_ssrc_ != ssrc) {
+ LOG(LS_ERROR) << "The specified ssrc " << ssrc
+ << " differs from the send ssrc " << local_ssrc_;
+ return false;
+ }
+
+ if (send_codec_.get() == NULL) {
+ LOG(LS_ERROR) << "The send codec has not been set yet.";
+ return false;
+ }
+
+ webrtc::VideoCodec codec = *send_codec_.get();
+ codec.width = format.width;
+ codec.height = format.height;
+ codec.maxFramerate = VideoFormat::IntervalToFps(format.interval);
+
+ bool ret = SetSendCodec(
+ codec, send_min_bitrate_, send_start_bitrate_, send_max_bitrate_);
+ if (ret) {
+ LOG(LS_INFO) << "Update send codec resolution to "
+ << codec.width << "x" << codec.height << "x"
+ << static_cast<int>(codec.maxFramerate);
+ }
+ return ret;
+}
+
bool WebRtcVideoMediaChannel::SetRender(bool render) {
- if (render != render_started_) {
- int ret;
- if (render) {
- ret = engine()->video_engine()->render()->StartRender(vie_channel_);
- } else {
- ret = engine()->video_engine()->render()->StopRender(vie_channel_);
- }
- if (ret != 0) {
- return false;
- }
- render_started_ = render;
- }
- return true;
-}
-
-bool WebRtcVideoMediaChannel::SetSend(bool send) {
- if (send == sending()) {
+ if (render == render_started_) {
return true; // no action required
}
bool ret = true;
- if (send) { // enable
- if (engine()->video_engine()->base()->StartSend(vie_channel_) != 0) {
- LOG_RTCERR1(StartSend, vie_channel_);
- ret = false;
- }
-
- // If the channel has not been connected to the capturer yet,
- // connect it now.
- if (!connected()) {
- if (engine()->video_engine()->capture()->ConnectCaptureDevice(
- engine()->capture_id(), vie_channel_) != 0) {
- LOG_RTCERR2(ConnectCaptureDevice, engine()->capture_id(), vie_channel_);
+ for (ChannelMap::iterator it = mux_channels_.begin();
+ it != mux_channels_.end(); ++it) {
+ if (render) {
+ if (engine()->vie()->render()->StartRender(
+ it->second->channel_id()) != 0) {
+ LOG_RTCERR1(StartRender, it->second->channel_id());
ret = false;
- } else {
- set_connected(true);
}
- }
- } else { // disable
- if (engine()->video_engine()->base()->StopSend(vie_channel_) != 0) {
- LOG_RTCERR1(StopSend, vie_channel_);
- ret = false;
+ } else {
+ if (engine()->vie()->render()->StopRender(
+ it->second->channel_id()) != 0) {
+ LOG_RTCERR1(StopRender, it->second->channel_id());
+ ret = false;
+ }
}
}
if (ret) {
- sending_ = send;
+ render_started_ = render;
}
return ret;
}
-bool WebRtcVideoMediaChannel::AddStream(uint32 ssrc, uint32 voice_ssrc) {
- return false;
-}
-
-bool WebRtcVideoMediaChannel::RemoveStream(uint32 ssrc) {
- return false;
-}
-
-bool WebRtcVideoMediaChannel::SetRenderer(
- uint32 ssrc, VideoRenderer* renderer) {
- ASSERT(vie_channel_ != -1);
- if (ssrc != 0)
+bool WebRtcVideoMediaChannel::SetSend(bool send) {
+ if (local_ssrc_ == 0 && send) {
+ LOG(LS_ERROR) << "No stream added";
return false;
- if (remote_renderer_.get()) {
- // If the renderer already set, stop and remove it first
- if (engine_->video_engine()->render()->StopRender(vie_channel_) != 0) {
- LOG_RTCERR1(StopRender, vie_channel_);
+ }
+ if (send == sending()) {
+ return true; // No action required.
+ }
+
+ if (send) {
+ // We've been asked to start sending.
+ // SetSendCodecs must have been called already.
+ if (!send_codec_.get()) {
+ return false;
}
- if (engine_->video_engine()->render()->RemoveRenderer(vie_channel_) != 0) {
- LOG_RTCERR1(RemoveRenderer, vie_channel_);
+ // Start send now.
+ if (!StartSend()) {
+ return false;
+ }
+ } else {
+ // We've been asked to stop sending.
+ if (!StopSend()) {
+ return false;
}
}
- remote_renderer_.reset(new WebRtcRenderAdapter(renderer));
+ sending_ = send;
+
+ return true;
+}
- if (engine_->video_engine()->render()->AddRenderer(vie_channel_,
- webrtc::kVideoI420, remote_renderer_.get()) != 0) {
- LOG_RTCERR3(AddRenderer, vie_channel_, webrtc::kVideoI420,
- remote_renderer_.get());
- remote_renderer_.reset();
+int WebRtcVideoMediaChannel::GetChannelNum(uint32 ssrc) {
+ ChannelMap::iterator it = mux_channels_.find(ssrc);
+ return (it != mux_channels_.end()) ? it->second->channel_id() : -1;
+}
+
+bool WebRtcVideoMediaChannel::AddSendStream(const StreamParams& sp) {
+ // TODO: Implement send media from multiple streams.
+ if (local_ssrc_ != 0) {
+ LOG(LS_ERROR) << "WebRtcVideoMediaChannel supports one sending channel";
+ return false;
+ }
+ if (sp.ssrcs.size() != 1) {
+ LOG(LS_ERROR) << "WebRtcVideoMediaChannel supports one sending SSRC per"
+ << " stream";
return false;
}
- if (engine_->video_engine()->render()->StartRender(vie_channel_) != 0) {
- LOG_RTCERR1(StartRender, vie_channel_);
+ if (engine()->vie()->rtp()->SetRTCPCName(vie_channel_,
+ sp.cname.c_str()) != 0) {
+ LOG_RTCERR2(SetRTCPCName, vie_channel_, sp.cname.c_str());
return false;
}
+ local_ssrc_ = sp.first_ssrc();
+ // Set the SSRC on the receive channels and this send channel.
+ // Receive channels have to have the same SSRC in order to send receiver
+ // reports with this SSRC.
+ for (ChannelMap::const_iterator it = mux_channels_.begin();
+ it != mux_channels_.end(); ++it) {
+ WebRtcVideoChannelInfo* info = it->second;
+ int channel_id = info->channel_id();
+ if (engine()->vie()->rtp()->SetLocalSSRC(channel_id,
+ sp.first_ssrc()) != 0) {
+ LOG_RTCERR1(SetLocalSSRC, it->first);
+ return false;
+ }
+ }
+
+ if (sending_) {
+ return StartSend();
+ }
+ return true;
+}
+
+bool WebRtcVideoMediaChannel::RemoveSendStream(uint32 ssrc) {
+ // TODO: Implement send media from multiple streams.
+ if (ssrc != local_ssrc_) {
+ return false;
+ }
+ if (sending_) {
+ StopSend();
+ }
+ local_ssrc_ = 0;
+ return true;
+}
+
+bool WebRtcVideoMediaChannel::AddRecvStream(const StreamParams& sp) {
+ // TODO Remove this once BWE works properly across different send
+ // and receive channels.
+ // Reuse default channel for recv stream in 1:1 call.
+ if ((channel_options_ & OPT_CONFERENCE) == 0 && first_receive_ssrc_ == 0) {
+ LOG(LS_INFO) << "Recv stream " << sp.first_ssrc()
+ << " reuse default channel #"
+ << vie_channel_;
+ first_receive_ssrc_ = sp.first_ssrc();
+ return true;
+ }
+
+ if (mux_channels_.find(sp.first_ssrc()) != mux_channels_.end()) {
+ LOG(LS_ERROR) << "Stream already exists";
+ return false;
+ }
+
+ // TODO: Implement recv media from multiple SSRCs per stream.
+ if (sp.ssrcs.size() != 1) {
+ LOG(LS_ERROR) << "WebRtcVideoMediaChannel supports one receiving SSRC per"
+ << " stream";
+ return false;
+ }
+
+ // Create a new channel for receiving video data.
+ // TODO: In order to support REMB we connect all receiving channels
+ // to our master send channel. This have to be done in a later cl when it have
+ // been properly implemented in webrtc.
+ int channel_id = -1;
+ if (engine_->vie()->base()->CreateChannel(channel_id) != 0) {
+ LOG_RTCERR1(CreateChannel, channel_id);
+ return false;
+ }
+
+ // Get the default renderer.
+ VideoRenderer* default_renderer = NULL;
+ if ((channel_options_ & OPT_CONFERENCE) != 0) {
+ if (mux_channels_.size() == 1 &&
+ mux_channels_.find(0) != mux_channels_.end()) {
+ GetRenderer(0, &default_renderer);
+ }
+ }
+
+ if (!ConfigureChannel(channel_id) ||
+ !ConfigureReceiving(channel_id, sp.first_ssrc())) {
+ engine_->vie()->base()->DeleteChannel(channel_id);
+ return false;
+ }
+
+ // The first recv stream reuses the default renderer (if a default renderer
+ // has been set).
+ if (default_renderer) {
+ SetRenderer(sp.first_ssrc(), default_renderer);
+ }
+
+ LOG(LS_INFO) << "New video stream " << sp.first_ssrc()
+ << " registered to VideoEngine channel #"
+ << channel_id;
+
return true;
}
+bool WebRtcVideoMediaChannel::RemoveRecvStream(uint32 ssrc) {
+ ChannelMap::iterator it = mux_channels_.find(ssrc);
+
+ if (it == mux_channels_.end()) {
+ // TODO: Remove this once BWE works properly across different send
+ // and receive channels.
+ // The default channel is reused for recv stream in 1:1 call.
+ if (first_receive_ssrc_ == ssrc) {
+ first_receive_ssrc_ = 0;
+ return true;
+ }
+ return false;
+ }
+ WebRtcVideoChannelInfo* info = it->second;
+ int channel_id = info->channel_id();
+ if (engine()->vie()->render()->RemoveRenderer(channel_id) != 0) {
+ LOG_RTCERR1(RemoveRenderer, channel_id);
+ }
+
+ if (engine()->vie()->network()->DeregisterSendTransport(channel_id) !=0) {
+ LOG_RTCERR1(DeRegisterSendTransport, channel_id);
+ }
+
+ if (engine()->vie()->codec()->DeregisterDecoderObserver(
+ channel_id) != 0) {
+ LOG_RTCERR1(DeregisterDecoderObserver, channel_id);
+ }
+
+ LOG(LS_INFO) << "Removing video stream " << ssrc
+ << " with VideoEngine channel #"
+ << channel_id;
+ if (engine()->vie()->base()->DeleteChannel(channel_id) == -1) {
+ LOG_RTCERR1(DeleteChannel, channel_id);
+ // Leak the WebRtcVideoChannelInfo owned by |it| but remove the channel from
+ // mux_channels_.
+ mux_channels_.erase(it);
+ return false;
+ }
+ // Delete the WebRtcVideoChannelInfo pointed to by it->second.
+ delete info;
+ mux_channels_.erase(it);
+ return true;
+}
+
+bool WebRtcVideoMediaChannel::StartSend() {
+ if (engine()->vie()->base()->StartSend(vie_channel_) != 0) {
+ LOG_RTCERR1(StartSend, vie_channel_);
+ return false;
+ }
+
+ // TODO Change this once REMB supporting multiple sending channels.
+ // Send remb (2nd param) and use remb for BWE (3rd param).
+ engine_->vie()->rtp()->SetRembStatus(vie_channel_, true, true);
+
+ return true;
+}
+
+bool WebRtcVideoMediaChannel::StopSend() {
+ if (engine()->vie()->base()->StopSend(vie_channel_) != 0) {
+ LOG_RTCERR1(StopSend, vie_channel_);
+ return false;
+ }
+
+ // TODO Change this once REMB supporting multiple sending channels.
+ // Don't send remb (2nd param) but use remb for BWE (3rd param).
+ engine_->vie()->rtp()->SetRembStatus(vie_channel_, false, true);
+
+ return true;
+}
+
+bool WebRtcVideoMediaChannel::SetRenderer(uint32 ssrc,
+ VideoRenderer* renderer) {
+ if (mux_channels_.find(ssrc) == mux_channels_.end()) {
+ // TODO: Remove this once BWE works properly across different send
+ // and receive channels.
+ // The default channel is reused for recv stream in 1:1 call.
+ if (first_receive_ssrc_ == ssrc &&
+ mux_channels_.find(0) != mux_channels_.end()) {
+ LOG(LS_INFO) << "SetRenderer " << ssrc
+ << " reuse default channel #"
+ << vie_channel_;
+ mux_channels_[0]->SetRenderer(renderer);
+ return true;
+ }
+ return false;
+ }
+
+ mux_channels_[ssrc]->SetRenderer(renderer);
+ return true;
+}
+
bool WebRtcVideoMediaChannel::GetStats(VideoMediaInfo* info) {
- VideoSenderInfo sinfo;
- memset(&sinfo, 0, sizeof(sinfo));
-
- unsigned int ssrc;
- if (engine_->video_engine()->rtp()->GetLocalSSRC(vie_channel_,
- ssrc) != 0) {
- LOG_RTCERR2(GetLocalSSRC, vie_channel_, ssrc);
- return false;
- }
- sinfo.ssrc = ssrc;
-
- unsigned int cumulative_lost, extended_max, jitter;
- int rtt_ms;
- uint16 fraction_lost;
-
- if (engine_->video_engine()->rtp()->GetReceivedRTCPStatistics(vie_channel_,
- fraction_lost, cumulative_lost, extended_max, jitter, rtt_ms) != 0) {
- LOG_RTCERR6(GetReceivedRTCPStatistics, vie_channel_,
- fraction_lost, cumulative_lost, extended_max, jitter, rtt_ms);
- return false;
- }
-
- sinfo.fraction_lost = fraction_lost;
- sinfo.packets_lost = cumulative_lost;
- sinfo.rtt_ms = rtt_ms;
-
+ // Get basic statistics.
unsigned int bytes_sent, packets_sent, bytes_recv, packets_recv;
- if (engine_->video_engine()->rtp()->GetRTPStatistics(vie_channel_,
+ unsigned int ssrc;
+ if (engine_->vie()->rtp()->GetRTPStatistics(vie_channel_,
bytes_sent, packets_sent, bytes_recv, packets_recv) != 0) {
- LOG_RTCERR5(GetRTPStatistics, vie_channel_,
- bytes_sent, packets_sent, bytes_recv, packets_recv);
+ LOG_RTCERR1(GetRTPStatistics, vie_channel_);
return false;
}
- sinfo.packets_sent = packets_sent;
- sinfo.bytes_sent = bytes_sent;
- sinfo.packets_lost = -1;
- sinfo.packets_cached = -1;
- info->senders.push_back(sinfo);
+ // Get sender statistics and build VideoSenderInfo.
+ if (engine_->vie()->rtp()->GetLocalSSRC(vie_channel_, ssrc) == 0) {
+ VideoSenderInfo sinfo;
+ sinfo.ssrc = ssrc;
+ sinfo.codec_name = send_codec_.get() ? send_codec_->plName : "";
+ sinfo.bytes_sent = bytes_sent;
+ sinfo.packets_sent = packets_sent;
+ sinfo.packets_cached = -1;
+ sinfo.packets_lost = -1;
+ sinfo.fraction_lost = -1;
+ sinfo.firs_rcvd = -1;
+ sinfo.nacks_rcvd = -1;
+ sinfo.rtt_ms = -1;
+ sinfo.frame_width = local_stream_info_->width();
+ sinfo.frame_height = local_stream_info_->height();
+ sinfo.framerate_input = local_stream_info_->framerate();
+ sinfo.framerate_sent = encoder_observer_->framerate();
+ sinfo.nominal_bitrate = encoder_observer_->bitrate();
+ sinfo.preferred_bitrate = send_max_bitrate_;
- // build receiver info.
- // reusing the above local variables
- VideoReceiverInfo rinfo;
- memset(&rinfo, 0, sizeof(rinfo));
- if (engine_->video_engine()->rtp()->GetSentRTCPStatistics(vie_channel_,
- fraction_lost, cumulative_lost, extended_max, jitter, rtt_ms) != 0) {
- LOG_RTCERR6(GetSentRTCPStatistics, vie_channel_,
- fraction_lost, cumulative_lost, extended_max, jitter, rtt_ms);
- return false;
+ // Get received RTCP statistics for the sender, if available.
+ // It's not a fatal error if we can't, since RTCP may not have arrived yet.
+ uint16 r_fraction_lost;
+ unsigned int r_cumulative_lost;
+ unsigned int r_extended_max;
+ unsigned int r_jitter;
+ int r_rtt_ms;
+ if (engine_->vie()->rtp()->GetSentRTCPStatistics(vie_channel_,
+ r_fraction_lost, r_cumulative_lost, r_extended_max,
+ r_jitter, r_rtt_ms) == 0) {
+ // Convert Q8 to float.
+ sinfo.packets_lost = r_cumulative_lost;
+ sinfo.fraction_lost = static_cast<float>(r_fraction_lost) / (1 << 8);
+ sinfo.rtt_ms = r_rtt_ms;
+ }
+ info->senders.push_back(sinfo);
+ } else {
+ LOG_RTCERR1(GetLocalSSRC, vie_channel_);
}
- rinfo.bytes_rcvd = bytes_recv;
- rinfo.packets_rcvd = packets_recv;
- rinfo.fraction_lost = fraction_lost;
- rinfo.packets_lost = cumulative_lost;
- if (engine_->video_engine()->rtp()->GetRemoteSSRC(vie_channel_,
- ssrc) != 0) {
- return false;
+ // Get the SSRC and stats for each receiver, based on our own calculations.
+ for (ChannelMap::const_iterator it = mux_channels_.begin();
+ it != mux_channels_.end(); ++it) {
+ // Don't report receive statistics from the default channel if we have
+ // specified receive channels.
+ if (it->first == 0 && mux_channels_.size() > 1)
+ continue;
+ WebRtcVideoChannelInfo* channel = it->second;
+
+ // Get receiver statistics and build VideoReceiverInfo, if we have data.
+ if (engine_->vie()->rtp()->GetRemoteSSRC(channel->channel_id(), ssrc) != 0)
+ continue;
+
+ if (engine_->vie()->rtp()->GetRTPStatistics(
+ channel->channel_id(), bytes_sent, packets_sent, bytes_recv,
+ packets_recv) != 0) {
+ LOG_RTCERR1(GetRTPStatistics, channel->channel_id());
+ return false;
+ }
+ VideoReceiverInfo rinfo;
+ rinfo.ssrc = ssrc;
+ rinfo.bytes_rcvd = bytes_recv;
+ rinfo.packets_rcvd = packets_recv;
+ rinfo.packets_lost = -1;
+ rinfo.packets_concealed = -1;
+ rinfo.fraction_lost = -1; // from SentRTCP
+ rinfo.firs_sent = channel->decoder_observer()->firs_requested();
+ rinfo.nacks_sent = -1;
+ rinfo.frame_width = channel->render_adapter()->width();
+ rinfo.frame_height = channel->render_adapter()->height();
+ rinfo.framerate_rcvd = channel->decoder_observer()->framerate();
+ int fps = channel->render_adapter()->framerate();
+ rinfo.framerate_decoded = fps;
+ rinfo.framerate_output = fps;
+
+ // Get sent RTCP statistics.
+ uint16 s_fraction_lost;
+ unsigned int s_cumulative_lost;
+ unsigned int s_extended_max;
+ unsigned int s_jitter;
+ int s_rtt_ms;
+ if (engine_->vie()->rtp()->GetReceivedRTCPStatistics(channel->channel_id(),
+ s_fraction_lost, s_cumulative_lost, s_extended_max,
+ s_jitter, s_rtt_ms) == 0) {
+ // Convert Q8 to float.
+ rinfo.packets_lost = s_cumulative_lost;
+ rinfo.fraction_lost = static_cast<float>(s_fraction_lost) / (1 << 8);
+ }
+ info->receivers.push_back(rinfo);
}
- rinfo.ssrc = ssrc;
- // Get codec for wxh
- info->receivers.push_back(rinfo);
+ // Build BandwidthEstimationInfo.
+ // TODO: Fill in more BWE stats once we have them.
+ unsigned int total_bitrate_sent;
+ unsigned int video_bitrate_sent;
+ unsigned int fec_bitrate_sent;
+ unsigned int nack_bitrate_sent;
+ if (engine_->vie()->rtp()->GetBandwidthUsage(vie_channel_,
+ total_bitrate_sent, video_bitrate_sent,
+ fec_bitrate_sent, nack_bitrate_sent) == 0) {
+ BandwidthEstimationInfo bwe;
+ bwe.actual_enc_bitrate = video_bitrate_sent;
+ bwe.transmit_bitrate = total_bitrate_sent;
+ bwe.retransmit_bitrate = nack_bitrate_sent;
+ info->bw_estimations.push_back(bwe);
+ } else {
+ LOG_RTCERR1(GetBandwidthUsage, vie_channel_);
+ }
+
return true;
}
bool WebRtcVideoMediaChannel::SendIntraFrame() {
bool ret = true;
- if (engine()->video_engine()->codec()->SendKeyFrame(vie_channel_) != 0) {
+ if (engine()->vie()->codec()->SendKeyFrame(vie_channel_) != 0) {
LOG_RTCERR1(SendKeyFrame, vie_channel_);
ret = false;
}
@@ -921,59 +1632,86 @@
}
void WebRtcVideoMediaChannel::OnPacketReceived(talk_base::Buffer* packet) {
- engine()->video_engine()->network()->ReceivedRTPPacket(vie_channel_,
- packet->data(),
- packet->length());
+ // Pick which channel to send this packet to. If this packet doesn't match
+ // any multiplexed streams, just send it to the default channel. Otherwise,
+ // send it to the specific decoder instance for that stream.
+ uint32 ssrc = 0;
+ if (!GetRtpSsrc(packet->data(), packet->length(), &ssrc))
+ return;
+ int which_channel = GetChannelNum(ssrc);
+ if (which_channel == -1) {
+ which_channel = video_channel();
+ }
+
+ engine()->vie()->network()->ReceivedRTPPacket(which_channel,
+ packet->data(),
+ packet->length());
}
void WebRtcVideoMediaChannel::OnRtcpReceived(talk_base::Buffer* packet) {
- engine_->video_engine()->network()->ReceivedRTCPPacket(vie_channel_,
- packet->data(),
- packet->length());
-}
+// Sending channels need all RTCP packets with feedback information.
+// Even sender reports can contain attached report blocks.
+// Receiving channels need sender reports in order to create
+// correct receiver reports.
-void WebRtcVideoMediaChannel::SetSendSsrc(uint32 id) {
- if (!sending_) {
- if (engine()->video_engine()->rtp()->SetLocalSSRC(vie_channel_,
- id) != 0) {
- LOG_RTCERR1(SetLocalSSRC, vie_channel_);
+ uint32 ssrc = 0;
+ if (!GetRtcpSsrc(packet->data(), packet->length(), &ssrc)) {
+ LOG(LS_WARNING) << "Failed to parse SSRC from received RTCP packet";
+ return;
+ }
+ int type = 0;
+ if (!GetRtcpType(packet->data(), packet->length(), & type)) {
+ LOG(LS_WARNING) << "Failed to parse type from received RTCP packet";
+ return;
+ }
+
+ // If it is a sender report, find the channel that is listening.
+ if (type == kRtcpTypeSR) {
+ int which_channel = GetChannelNum(ssrc);
+ if (which_channel != -1 && which_channel != vie_channel_) {
+ engine_->vie()->network()->ReceivedRTCPPacket(which_channel,
+ packet->data(),
+ packet->length());
}
- } else {
- LOG(LS_ERROR) << "Channel already in send state";
}
-}
-
-bool WebRtcVideoMediaChannel::SetRtcpCName(const std::string& cname) {
- if (engine()->video_engine()->rtp()->SetRTCPCName(vie_channel_,
- cname.c_str()) != 0) {
- LOG_RTCERR2(SetRTCPCName, vie_channel_, cname.c_str());
- return false;
- }
- return true;
+ // The sending channel receives all RTCP packets.
+ engine_->vie()->network()->ReceivedRTCPPacket(vie_channel_,
+ packet->data(),
+ packet->length());
}
bool WebRtcVideoMediaChannel::Mute(bool on) {
- // stop send??
- return false;
+ muted_ = on;
+ return true;
}
bool WebRtcVideoMediaChannel::SetSendBandwidth(bool autobw, int bps) {
LOG(LS_INFO) << "RtcVideoMediaChanne::SetSendBandwidth";
if (!send_codec_.get()) {
- LOG(LS_INFO) << "The send codec has not been set up yet.";
+ LOG(LS_INFO) << "The send codec has not been set up yet";
return true;
}
- if (!autobw) {
- send_codec_->startBitrate = bps;
- send_codec_->minBitrate = bps;
+ int min_bitrate;
+ int start_bitrate;
+ int max_bitrate;
+ if (autobw) {
+ // Use the default values for min bitrate.
+ min_bitrate = kMinVideoBitrate;
+ // Use the default value or the bps for the max
+ max_bitrate = (bps <= 0) ? send_max_bitrate_ : (bps / 1000);
+ // Maximum start bitrate can be kStartVideoBitrate.
+ start_bitrate = talk_base::_min(kStartVideoBitrate, max_bitrate);
+ } else {
+ // Use the default start or the bps as the target bitrate.
+ int target_bitrate = (bps <= 0) ? kStartVideoBitrate : (bps / 1000);
+ min_bitrate = target_bitrate;
+ start_bitrate = target_bitrate;
+ max_bitrate = target_bitrate;
}
- send_codec_->maxBitrate = bps;
- if (engine()->video_engine()->codec()->SetSendCodec(vie_channel_,
- *send_codec_.get()) != 0) {
- LOG_RTCERR2(SetSendCodec, vie_channel_, send_codec_->plName);
+ if (!SetSendCodec(*send_codec_, min_bitrate, start_bitrate, max_bitrate)) {
return false;
}
@@ -981,6 +1719,33 @@
}
bool WebRtcVideoMediaChannel::SetOptions(int options) {
+ // Always accept options that are unchanged.
+ if (channel_options_ == options) {
+ return true;
+ }
+
+ // Reject new options if we're already sending.
+ if (sending()) {
+ return false;
+ }
+
+ // Save the options, to be interpreted where appropriate.
+ channel_options_ = options;
+
+ // Adjust send codec bitrate if needed.
+ int expected_bitrate = (0 != (channel_options_ & OPT_CONFERENCE)) ?
+ kConferenceModeMaxVideoBitrate : kMaxVideoBitrate;
+ if (NULL != send_codec_.get() && send_max_bitrate_ != expected_bitrate) {
+ // On success, SetSendCodec() will reset send_max_bitrate_ to
+ // expected_bitrate.
+ if (!SetSendCodec(*send_codec_,
+ send_min_bitrate_,
+ send_start_bitrate_,
+ expected_bitrate)) {
+ return false;
+ }
+ }
+
return true;
}
@@ -997,18 +1762,309 @@
}
}
-void WebRtcVideoMediaChannel::EnableRtcp() {
- engine()->video_engine()->rtp()->SetRTCPStatus(
- vie_channel_, webrtc::kRtcpCompound_RFC4585);
+bool WebRtcVideoMediaChannel::GetRenderer(uint32 ssrc,
+ VideoRenderer** renderer) {
+ ChannelMap::const_iterator it = mux_channels_.find(ssrc);
+ if (it == mux_channels_.end()) {
+ if (first_receive_ssrc_ == ssrc &&
+ mux_channels_.find(0) != mux_channels_.end()) {
+ LOG(LS_INFO) << " GetRenderer " << ssrc
+ << " reuse default renderer #"
+ << vie_channel_;
+ *renderer = mux_channels_[0]->render_adapter()->renderer();
+ return true;
+ }
+ return false;
+ }
+
+ *renderer = it->second->render_adapter()->renderer();
+ return true;
}
-void WebRtcVideoMediaChannel::EnablePLI() {
- engine_->video_engine()->rtp()->SetKeyFrameRequestMethod(
- vie_channel_, webrtc::kViEKeyFrameRequestPliRtcp);
+// TODO: Add unittests to test this function.
+bool WebRtcVideoMediaChannel::SendFrame(uint32 ssrc, const VideoFrame* frame) {
+ if (ssrc != 0 || !sending() || !external_capture_) {
+ return false;
+ }
+
+ // Update local stream statistics.
+ local_stream_info_->UpdateFrame(frame->GetWidth(), frame->GetHeight());
+
+ // Checks if we need to reset vie send codec.
+ if (!MaybeResetVieSendCodec(frame->GetWidth(), frame->GetHeight(), NULL)) {
+ LOG(LS_ERROR) << "MaybeResetVieSendCodec failed with "
+ << frame->GetWidth() << "x" << frame->GetHeight();
+ return false;
+ }
+
+ // Blacken the frame if video is muted.
+ const VideoFrame* frame_out = frame;
+ talk_base::scoped_ptr<VideoFrame> black_frame;
+ if (muted_) {
+ black_frame.reset(frame->Copy());
+ black_frame->SetToBlack();
+ frame_out = black_frame.get();
+ }
+
+ webrtc::ViEVideoFrameI420 frame_i420;
+ // TODO: Update the webrtc::ViEVideoFrameI420
+ // to use const unsigned char*
+ frame_i420.y_plane = const_cast<unsigned char*>(frame_out->GetYPlane());
+ frame_i420.u_plane = const_cast<unsigned char*>(frame_out->GetUPlane());
+ frame_i420.v_plane = const_cast<unsigned char*>(frame_out->GetVPlane());
+ frame_i420.y_pitch = frame_out->GetYPitch();
+ frame_i420.u_pitch = frame_out->GetUPitch();
+ frame_i420.v_pitch = frame_out->GetVPitch();
+ frame_i420.width = frame_out->GetWidth();
+ frame_i420.height = frame_out->GetHeight();
+
+ // Convert from nanoseconds to milliseconds.
+ WebRtc_Word64 clocks = frame_out->GetTimeStamp() /
+ talk_base::kNumNanosecsPerMillisec;
+
+ return (external_capture_->IncomingFrameI420(frame_i420, clocks) == 0);
}
-void WebRtcVideoMediaChannel::EnableTMMBR() {
- engine_->video_engine()->rtp()->SetTMMBRStatus(vie_channel_, true);
+bool WebRtcVideoMediaChannel::ConfigureChannel(int channel_id) {
+ // Register external transport.
+ if (engine_->vie()->network()->RegisterSendTransport(
+ channel_id, *this) != 0) {
+ LOG_RTCERR1(RegisterSendTransport, channel_id);
+ return false;
+ }
+
+ // Set MTU.
+ if (engine_->vie()->network()->SetMTU(channel_id, kVideoMtu) != 0) {
+ LOG_RTCERR2(SetMTU, channel_id, kVideoMtu);
+ return false;
+ }
+ // Turn on RTCP and loss feedback reporting.
+ if (engine()->vie()->rtp()->SetRTCPStatus(
+ channel_id, webrtc::kRtcpCompound_RFC4585) != 0) {
+ LOG_RTCERR2(SetRTCPStatus, channel_id, webrtc::kRtcpCompound_RFC4585);
+ return false;
+ }
+ // Enable pli as key frame request method.
+ if (engine_->vie()->rtp()->SetKeyFrameRequestMethod(
+ channel_id, webrtc::kViEKeyFrameRequestPliRtcp) != 0) {
+ LOG_RTCERR2(SetKeyFrameRequestMethod,
+ channel_id, webrtc::kViEKeyFrameRequestPliRtcp);
+ return false;
+ }
+ return true;
+}
+
+bool WebRtcVideoMediaChannel::ConfigureReceiving(int channel_id,
+ uint32 remote_ssrc) {
+ // Connect the voice channel, if there is one.
+ // TODO: The A/V is synched by the receiving channel. So we need to
+ // know the SSRC of the remote audio channel in order to fetch the correct
+ // webrtc VoiceEngine channel. For now- only sync the default channel used
+ // in 1-1 calls.
+ if (remote_ssrc == 0 && voice_channel_) {
+ WebRtcVoiceMediaChannel* voice_channel =
+ static_cast<WebRtcVoiceMediaChannel*>(voice_channel_);
+ if (engine_->vie()->base()->ConnectAudioChannel(
+ vie_channel_, voice_channel->voe_channel()) != 0) {
+ LOG_RTCERR2(ConnectAudioChannel, channel_id,
+ voice_channel->voe_channel());
+ LOG(LS_WARNING) << "A/V not synchronized";
+ // Not a fatal error.
+ }
+ }
+
+ talk_base::scoped_ptr<WebRtcVideoChannelInfo> channel_info(
+ new WebRtcVideoChannelInfo(channel_id));
+
+ // Install a render adapter.
+ if (engine_->vie()->render()->AddRenderer(channel_id,
+ webrtc::kVideoI420, channel_info->render_adapter()) != 0) {
+ LOG_RTCERR3(AddRenderer, channel_id, webrtc::kVideoI420,
+ channel_info->render_adapter());
+ return false;
+ }
+
+ // TODO Change this once REMB supporting multiple sending channels.
+ // Turn off remb sending (2nd param) and turn on remb reporting (3rd param)
+ // here.
+ // For sending channel, remb sending will be turned on after StartSending.
+ engine_->vie()->rtp()->SetRembStatus(channel_id, false, true);
+
+ if (remote_ssrc != 0) {
+ // Use the same SSRC as our default channel
+ // (so the RTCP reports are correct).
+ unsigned int send_ssrc = 0;
+ webrtc::ViERTP_RTCP* rtp = engine()->vie()->rtp();
+ if (rtp->GetLocalSSRC(vie_channel_, send_ssrc) == -1) {
+ LOG_RTCERR2(GetSendSSRC, channel_id, send_ssrc);
+ return false;
+ }
+ if (rtp->SetLocalSSRC(channel_id, send_ssrc) == -1) {
+ LOG_RTCERR2(SetSendSSRC, channel_id, send_ssrc);
+ return false;
+ }
+ } // Else this is the the default channel and we don't change the SSRC.
+
+ // Disable color enhancement since it is a bit too aggressive.
+ if (engine()->vie()->image()->EnableColorEnhancement(channel_id,
+ false) != 0) {
+ LOG_RTCERR1(EnableColorEnhancement, channel_id);
+ return false;
+ }
+
+ if (!SetReceiveCodecs(channel_id)) {
+ return false;
+ }
+
+ if (render_started_) {
+ if (engine_->vie()->render()->StartRender(channel_id) != 0) {
+ LOG_RTCERR1(StartRender, channel_id);
+ return false;
+ }
+ }
+
+ // Register decoder observer for incoming framerate and bitrate.
+ if (engine()->vie()->codec()->RegisterDecoderObserver(
+ channel_id, *channel_info->decoder_observer()) != 0) {
+ LOG_RTCERR1(RegisterDecoderObserver, channel_info->decoder_observer());
+ return false;
+ }
+
+ mux_channels_[remote_ssrc] = channel_info.release();
+
+ return true;
+}
+
+bool WebRtcVideoMediaChannel::SetNackFec(int channel_id,
+ int red_payload_type,
+ int fec_payload_type) {
+ // Enable hybrid NACK/FEC if negotiated and not in a conference, use only NACK
+ // otherwise.
+ bool enable = (red_payload_type != -1 && fec_payload_type != -1 &&
+ !(channel_options_ & OPT_CONFERENCE));
+ if (enable) {
+ if (engine_->vie()->rtp()->SetHybridNACKFECStatus(
+ channel_id, enable, red_payload_type, fec_payload_type) != 0) {
+ LOG_RTCERR4(SetHybridNACKFECStatus,
+ channel_id, enable, red_payload_type, fec_payload_type);
+ return false;
+ }
+ LOG(LS_INFO) << "Hybrid NACK/FEC enabled for channel " << channel_id;
+ } else {
+ if (engine_->vie()->rtp()->SetNACKStatus(channel_id, true) != 0) {
+ LOG_RTCERR1(SetNACKStatus, channel_id);
+ return false;
+ }
+ LOG(LS_INFO) << "NACK enabled for channel " << channel_id;
+ }
+ return true;
+}
+
+bool WebRtcVideoMediaChannel::SetSendCodec(const webrtc::VideoCodec& codec,
+ int min_bitrate,
+ int start_bitrate,
+ int max_bitrate) {
+ // Make a copy of the codec
+ webrtc::VideoCodec target_codec = codec;
+ target_codec.startBitrate = start_bitrate;
+ target_codec.minBitrate = min_bitrate;
+ target_codec.maxBitrate = max_bitrate;
+
+ if (engine()->vie()->codec()->SetSendCodec(vie_channel_, target_codec) != 0) {
+ LOG_RTCERR2(SetSendCodec, vie_channel_, send_codec_->plName);
+ return false;
+ }
+
+ // Reset the send_codec_ only if SetSendCodec is success.
+ send_codec_.reset(new webrtc::VideoCodec(target_codec));
+ send_min_bitrate_ = min_bitrate;
+ send_start_bitrate_ = start_bitrate;
+ send_max_bitrate_ = max_bitrate;
+
+ return true;
+}
+
+bool WebRtcVideoMediaChannel::SetReceiveCodecs(int channel_id) {
+ int red_type = -1;
+ int fec_type = -1;
+ for (std::vector<webrtc::VideoCodec>::iterator it = receive_codecs_.begin();
+ it != receive_codecs_.end(); ++it) {
+ if (it->codecType == webrtc::kVideoCodecRED) {
+ red_type = it->plType;
+ } else if (it->codecType == webrtc::kVideoCodecULPFEC) {
+ fec_type = it->plType;
+ }
+ if (engine()->vie()->codec()->SetReceiveCodec(channel_id, *it) != 0) {
+ LOG_RTCERR2(SetReceiveCodec, channel_id, it->plName);
+ return false;
+ }
+ }
+
+ // Enable video protection. For a sending channel, this will be taken care of
+ // in SetSendCodecs.
+ if (channel_id != vie_channel_) {
+ if (!SetNackFec(channel_id, red_type, fec_type)) {
+ return false;
+ }
+ }
+
+ // Start receiving packets if at least one receive codec has been set.
+ if (!receive_codecs_.empty()) {
+ if (engine()->vie()->base()->StartReceive(channel_id) != 0) {
+ LOG_RTCERR1(StartReceive, channel_id);
+ return false;
+ }
+ }
+ return true;
+}
+
+// If the new frame size is different from the send codec size we set on vie,
+// we need to reset the send codec on vie.
+// The new send codec size should not exceed send_codec_ which is controlled
+// only by the 'jec' logic.
+bool WebRtcVideoMediaChannel::MaybeResetVieSendCodec(int new_width,
+ int new_height,
+ bool* reset) {
+ if (reset) {
+ *reset = false;
+ }
+
+ if (NULL == send_codec_.get()) {
+ return false;
+ }
+
+ // Vie send codec size should not exceed send_codec_.
+ int target_width = new_width;
+ int target_height = new_height;
+ if (new_width > send_codec_->width || new_height > send_codec_->height) {
+ target_width = send_codec_->width;
+ target_height = send_codec_->height;
+ }
+
+ // Get current vie codec.
+ webrtc::VideoCodec vie_codec;
+ if (engine()->vie()->codec()->GetSendCodec(vie_channel_, vie_codec) != 0) {
+ LOG_RTCERR1(GetSendCodec, vie_channel_);
+ return false;
+ }
+
+ // Only reset send codec when there is a size change.
+ if (target_width != vie_codec.width || target_height != vie_codec.height) {
+ // Set the new codec on vie.
+ vie_codec.width = target_width;
+ vie_codec.height = target_height;
+ if (engine()->vie()->codec()->SetSendCodec(vie_channel_, vie_codec) != 0) {
+ LOG_RTCERR1(SetSendCodec, vie_channel_);
+ return false;
+ }
+ if (reset) {
+ *reset = true;
+ }
+ LOG(LS_INFO) << "Reset vie send codec to: "
+ << vie_codec.width << "x" << vie_codec.height;
+ }
+
+ return true;
}
int WebRtcVideoMediaChannel::SendPacket(int channel, const void* data,
@@ -1021,8 +2077,8 @@
}
int WebRtcVideoMediaChannel::SendRTCPPacket(int channel,
- const void* data,
- int len) {
+ const void* data,
+ int len) {
if (!network_interface_) {
return -1;
}
@@ -1033,4 +2089,3 @@
} // namespace cricket
#endif // HAVE_WEBRTC_VIDEO
-
diff --git a/talk/session/phone/webrtcvideoengine.h b/talk/session/phone/webrtcvideoengine.h
index ffb6e7d..8eb56da 100644
--- a/talk/session/phone/webrtcvideoengine.h
+++ b/talk/session/phone/webrtcvideoengine.h
@@ -28,6 +28,7 @@
#ifndef TALK_SESSION_PHONE_WEBRTCVIDEOENGINE_H_
#define TALK_SESSION_PHONE_WEBRTCVIDEOENGINE_H_
+#include <map>
#include <vector>
#include "talk/base/scoped_ptr.h"
@@ -36,7 +37,7 @@
#include "talk/session/phone/channel.h"
#include "talk/session/phone/webrtccommon.h"
#ifdef WEBRTC_RELATIVE_PATH
-#include "video_engine/main/interface/vie_base.h"
+#include "video_engine/include/vie_base.h"
#else
#include "third_party/webrtc/files/include/vie_base.h"
#endif // WEBRTC_RELATIVE_PATH
@@ -44,72 +45,104 @@
namespace webrtc {
class VideoCaptureModule;
class VideoRender;
+class ViEExternalCapture;
}
namespace cricket {
+struct CapturedFrame;
+class WebRtcVideoChannelInfo;
struct Device;
+class WebRtcLocalStreamInfo;
class VideoCapturer;
+class VideoFrame;
+class VideoProcessor;
class VideoRenderer;
+class ViETraceWrapper;
class ViEWrapper;
class VoiceMediaChannel;
class WebRtcRenderAdapter;
class WebRtcVideoMediaChannel;
class WebRtcVoiceEngine;
+class WebRtcDecoderObserver;
+class WebRtcEncoderObserver;
-class WebRtcVideoEngine : public webrtc::ViEBaseObserver,
+class WebRtcVideoEngine : public sigslot::has_slots<>,
+ public webrtc::ViEBaseObserver,
public webrtc::TraceCallback {
public:
// Creates the WebRtcVideoEngine with internal VideoCaptureModule.
WebRtcVideoEngine();
// For testing purposes. Allows the WebRtcVoiceEngine and
// ViEWrapper to be mocks.
- WebRtcVideoEngine(WebRtcVoiceEngine* voice_engine, ViEWrapper* vie_wrapper);
+ // TODO: Remove the 2-arg ctor once fake tracing is implemented.
+ WebRtcVideoEngine(WebRtcVoiceEngine* voice_engine,
+ ViEWrapper* vie_wrapper);
+ WebRtcVideoEngine(WebRtcVoiceEngine* voice_engine,
+ ViEWrapper* vie_wrapper,
+ ViETraceWrapper* tracing);
~WebRtcVideoEngine();
+ // Basic video engine implementation.
bool Init();
void Terminate();
- WebRtcVideoMediaChannel* CreateChannel(
- VoiceMediaChannel* voice_channel);
- bool FindCodec(const VideoCodec& in);
- bool SetDefaultEncoderConfig(const VideoEncoderConfig& config);
-
- void RegisterChannel(WebRtcVideoMediaChannel* channel);
- void UnregisterChannel(WebRtcVideoMediaChannel* channel);
-
- ViEWrapper* video_engine() { return vie_wrapper_.get(); }
- int GetLastVideoEngineError();
int GetCapabilities();
bool SetOptions(int options);
- bool SetCaptureDevice(const Device* device);
- bool SetCaptureModule(webrtc::VideoCaptureModule* vcm);
- int capture_id() const { return capture_id_; }
- bool SetLocalRenderer(VideoRenderer* renderer);
- CaptureResult SetCapture(bool capture);
+ bool SetDefaultEncoderConfig(const VideoEncoderConfig& config);
+
+ WebRtcVideoMediaChannel* CreateChannel(VoiceMediaChannel* voice_channel);
+
const std::vector<VideoCodec>& codecs() const;
void SetLogging(int min_sev, const char* filter);
- int GetLastEngineError();
+ // Capture-related stuff. Will be removed with capture refactor.
+ bool SetCaptureDevice(const Device* device);
+ bool SetCaptureModule(webrtc::VideoCaptureModule* vcm);
+ // If capturer is NULL, unregisters the capturer and stops capturing.
+ // Otherwise sets the capturer and starts capturing.
+ bool SetVideoCapturer(VideoCapturer* capturer, uint32 /*ssrc*/);
+ bool SetLocalRenderer(VideoRenderer* renderer);
+ CaptureResult SetCapture(bool capture);
+ sigslot::repeater2<VideoCapturer*, CaptureResult> SignalCaptureResult;
+ virtual VideoCapturer* CreateVideoCapturer(const Device& device);
+ CaptureResult UpdateCapturingState();
+ bool IsCapturing() const;
+ void OnFrameCaptured(VideoCapturer* capturer, const CapturedFrame* frame);
// Set the VoiceEngine for A/V sync. This can only be called before Init.
bool SetVoiceEngine(WebRtcVoiceEngine* voice_engine);
-
// Enable the render module with timing control.
bool EnableTimedRender();
- VideoEncoderConfig& default_encoder_config() {
- return default_encoder_config_;
+ bool RegisterProcessor(VideoProcessor* video_processor);
+ bool UnregisterProcessor(VideoProcessor* video_processor);
+
+ // Functions called by WebRtcVideoMediaChannel.
+ ViEWrapper* vie() { return vie_wrapper_.get(); }
+ const VideoFormat& default_codec_format() const {
+ return default_codec_format_;
}
-
+ int GetLastEngineError();
+ bool FindCodec(const VideoCodec& in);
+ bool CanSendCodec(const VideoCodec& in, const VideoCodec& current,
+ VideoCodec* out);
+ void RegisterChannel(WebRtcVideoMediaChannel* channel);
+ void UnregisterChannel(WebRtcVideoMediaChannel* channel);
void ConvertToCricketVideoCodec(const webrtc::VideoCodec& in_codec,
- VideoCodec& out_codec);
-
+ VideoCodec* out_codec);
bool ConvertFromCricketVideoCodec(const VideoCodec& in_codec,
- webrtc::VideoCodec& out_codec);
+ webrtc::VideoCodec* out_codec);
+ // Check whether the supplied trace should be ignored.
+ bool ShouldIgnoreTrace(const std::string& trace);
+ int GetNumOfChannels();
- sigslot::signal2<VideoCapturer*, CaptureResult> SignalCaptureResult;
+ protected:
+ // When a video processor registers with the engine.
+ // SignalMediaFrame will be invoked for every video frame.
+ sigslot::signal2<uint32, VideoFrame*> SignalMediaFrame;
private:
+ typedef std::vector<WebRtcVideoMediaChannel*> VideoChannels;
struct VideoCodecPref {
const char* name;
int payload_type;
@@ -117,35 +150,48 @@
};
static const VideoCodecPref kVideoCodecPrefs[];
- static const VideoFormat kVideoFormats[];
- static const VideoFormat kDefaultVideoFormat;
+ static const VideoFormatPod kVideoFormats[];
+ static const VideoFormatPod kDefaultVideoFormat;
- void Construct();
+ void Construct(ViEWrapper* vie_wrapper,
+ ViETraceWrapper* tracing,
+ WebRtcVoiceEngine* voice_engine);
bool SetDefaultCodec(const VideoCodec& codec);
bool RebuildCodecList(const VideoCodec& max_codec);
-
- void ApplyLogging();
+ void ApplyLogging(const std::string& log_filter);
bool InitVideoEngine();
- void PerformanceAlarm(const unsigned int cpu_load);
- bool ReleaseCaptureDevice();
+ bool SetCapturer(VideoCapturer* capturer, bool own_capturer);
+
+ // webrtc::ViEBaseObserver implementation.
+ virtual void PerformanceAlarm(const unsigned int cpu_load);
+ // webrtc::TraceCallback implementation.
virtual void Print(const webrtc::TraceLevel level, const char* trace_string,
const int length);
- typedef std::vector<WebRtcVideoMediaChannel*> VideoChannels;
+ void ClearCapturer();
talk_base::scoped_ptr<ViEWrapper> vie_wrapper_;
- webrtc::VideoCaptureModule* capture_module_;
- bool external_capture_;
- int capture_id_;
- talk_base::scoped_ptr<webrtc::VideoRender> render_module_;
+ bool vie_wrapper_base_initialized_;
+ talk_base::scoped_ptr<ViETraceWrapper> tracing_;
WebRtcVoiceEngine* voice_engine_;
- std::vector<VideoCodec> video_codecs_;
- VideoChannels channels_;
int log_level_;
- VideoEncoderConfig default_encoder_config_;
- bool capture_started_;
- talk_base::scoped_ptr<WebRtcRenderAdapter> local_renderer_;
+ talk_base::scoped_ptr<webrtc::VideoRender> render_module_;
+ std::vector<VideoCodec> video_codecs_;
+ VideoFormat default_codec_format_;
bool initialized_;
+ talk_base::CriticalSection channels_crit_;
+ VideoChannels channels_;
+
+ bool owns_capturer_;
+ VideoCapturer* video_capturer_;
+ bool capture_started_;
+ int local_renderer_w_;
+ int local_renderer_h_;
+ VideoRenderer* local_renderer_;
+
+ // Critical section to protect the media processor register/unregister
+ // while processing a frame
+ talk_base::CriticalSection signal_media_critical_;
};
class WebRtcVideoMediaChannel : public VideoMediaChannel,
@@ -154,23 +200,37 @@
WebRtcVideoMediaChannel(
WebRtcVideoEngine* engine, VoiceMediaChannel* voice_channel);
~WebRtcVideoMediaChannel();
-
bool Init();
+
+ WebRtcVideoEngine* engine() { return engine_; }
+ VoiceMediaChannel* voice_channel() { return voice_channel_; }
+ int video_channel() const { return vie_channel_; }
+ bool sending() const { return sending_; }
+
+ // VideoMediaChannel implementation
virtual bool SetRecvCodecs(const std::vector<VideoCodec> &codecs);
virtual bool SetSendCodecs(const std::vector<VideoCodec> &codecs);
+ virtual bool SetSendStreamFormat(uint32 ssrc, const VideoFormat& format);
virtual bool SetRender(bool render);
virtual bool SetSend(bool send);
- virtual bool AddStream(uint32 ssrc, uint32 voice_ssrc);
- virtual bool RemoveStream(uint32 ssrc);
+
+ virtual bool AddSendStream(const StreamParams& sp);
+ virtual bool RemoveSendStream(uint32 ssrc);
+ virtual bool AddRecvStream(const StreamParams& sp);
+ virtual bool RemoveRecvStream(uint32 ssrc);
virtual bool SetRenderer(uint32 ssrc, VideoRenderer* renderer);
virtual bool GetStats(VideoMediaInfo* info);
+ virtual bool AddScreencast(uint32 ssrc, const ScreencastId& id) {
+ return false;
+ }
+ virtual bool RemoveScreencast(uint32 ssrc) {
+ return false;
+ }
virtual bool SendIntraFrame();
virtual bool RequestIntraFrame();
virtual void OnPacketReceived(talk_base::Buffer* packet);
virtual void OnRtcpReceived(talk_base::Buffer* packet);
- virtual void SetSendSsrc(uint32 id);
- virtual bool SetRtcpCName(const std::string& cname);
virtual bool Mute(bool on);
virtual bool SetRecvRtpHeaderExtensions(
const std::vector<RtpHeaderExtension>& extensions) {
@@ -184,12 +244,17 @@
virtual bool SetOptions(int options);
virtual void SetInterface(NetworkInterface* iface);
- WebRtcVideoEngine* engine() const { return engine_; }
- VoiceMediaChannel* voice_channel() const { return voice_channel_; }
- int video_channel() const { return vie_channel_; }
- bool sending() const { return sending_; }
- void set_connected(bool connected) { connected_ = connected; }
- bool connected() const { return connected_; }
+ // Public functions for use by tests and other specialized code.
+ uint32 send_ssrc() const { return 0; }
+ bool GetRenderer(uint32 ssrc, VideoRenderer** renderer);
+ bool SendFrame(uint32 ssrc, const VideoFrame* frame);
+
+ // Thunk functions for use with HybridVideoEngine
+ void OnLocalFrame(VideoCapturer* capturer, const VideoFrame* frame) {
+ SendFrame(0, frame);
+ }
+ void OnLocalFrameFormat(VideoCapturer* capturer, const VideoFormat* format) {
+ }
protected:
int GetLastEngineError() { return engine()->GetLastEngineError(); }
@@ -197,20 +262,55 @@
virtual int SendRTCPPacket(int channel, const void* data, int len);
private:
- void EnableRtcp();
- void EnablePLI();
- void EnableTMMBR();
+ typedef std::map<uint32, WebRtcVideoChannelInfo*> ChannelMap;
+
+ // Creates and initializes a WebRtc video channel.
+ bool ConfigureChannel(int channel_id);
+ bool ConfigureReceiving(int channel_id, uint32 remote_ssrc);
+ bool SetNackFec(int channel_id, int red_payload_type, int fec_payload_type);
+ bool SetSendCodec(const webrtc::VideoCodec& codec,
+ int min_bitrate,
+ int start_bitrate,
+ int max_bitrate);
+ // Prepares the channel with channel id |channel_id| to receive all codecs in
+ // |receive_codecs_| and start receive packets.
+ bool SetReceiveCodecs(int channel_id);
+ // Returns the channel number that receives the stream with SSRC |ssrc|.
+ int GetChannelNum(uint32 ssrc);
+ // Given captured video frame size, checks if we need to reset vie send codec.
+ // |reset| is set to whether resetting has happened on vie or not.
+ // Returns false on error.
+ bool MaybeResetVieSendCodec(int new_width, int new_height, bool* reset);
+ // Call Webrtc function to start sending media on |vie_channel_|.
+ // Does not affect |sending_|.
+ bool StartSend();
+ // Call Webrtc function to stop sending media on |vie_channel_|.
+ // Does not affect |sending_|.
+ bool StopSend();
WebRtcVideoEngine* engine_;
VoiceMediaChannel* voice_channel_;
int vie_channel_;
+ int vie_capture_;
+ webrtc::ViEExternalCapture* external_capture_;
bool sending_;
- // connected to the capture device or not.
- bool connected_;
bool render_started_;
+ bool muted_; // Flag to tell if we need to mute video.
+ // Our local SSRC. Currently only one send stream is supported.
+ uint32 local_ssrc_;
+ uint32 first_receive_ssrc_;
+ int send_min_bitrate_;
+ int send_start_bitrate_;
+ int send_max_bitrate_;
talk_base::scoped_ptr<webrtc::VideoCodec> send_codec_;
- talk_base::scoped_ptr<WebRtcRenderAdapter> remote_renderer_;
+ std::vector<webrtc::VideoCodec> receive_codecs_;
+ talk_base::scoped_ptr<WebRtcEncoderObserver> encoder_observer_;
+ talk_base::scoped_ptr<WebRtcLocalStreamInfo> local_stream_info_;
+ int channel_options_;
+
+ ChannelMap mux_channels_; // Contains all receive channels.
};
+
} // namespace cricket
#endif // TALK_SESSION_PHONE_WEBRTCVIDEOENGINE_H_
diff --git a/talk/session/phone/webrtcvideoengine_unittest.cc b/talk/session/phone/webrtcvideoengine_unittest.cc
index ee42729..b0bf813 100644
--- a/talk/session/phone/webrtcvideoengine_unittest.cc
+++ b/talk/session/phone/webrtcvideoengine_unittest.cc
@@ -1,93 +1,77 @@
-// Copyright 2008 Google Inc. All Rights Reserved.
-//
-// Author: Ronghua Wu (ronghuawu@google.com)
-// Zhurun Zhang (zhurunz@google.com)
+/*
+ * libjingle
+ * Copyright 2004--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/base/byteorder.h"
#include "talk/base/gunit.h"
-#include "talk/session/phone/channel.h"
-#include "talk/session/phone/fakemediaengine.h"
-#include "talk/session/phone/fakertp.h"
-#include "talk/session/phone/fakesession.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/session/phone/fakemediaprocessor.h"
+#include "talk/session/phone/fakewebrtcvideocapturemodule.h"
#include "talk/session/phone/fakewebrtcvideoengine.h"
#include "talk/session/phone/fakewebrtcvoiceengine.h"
+#include "talk/session/phone/mediasession.h"
+#include "talk/session/phone/videoengine_unittest.h"
+#include "talk/session/phone/webrtcvideocapturer.h"
#include "talk/session/phone/webrtcvideoengine.h"
+#include "talk/session/phone/webrtcvideoframe.h"
#include "talk/session/phone/webrtcvoiceengine.h"
// Tests for the WebRtcVideoEngine/VideoChannel code.
-static const cricket::VideoCodec kVP8Codec(104, "VP8", 320, 200, 30, 0);
+static const cricket::VideoCodec kVP8Codec(100, "VP8", 640, 400, 30, 0);
+static const cricket::VideoCodec kRedCodec(101, "red", 0, 0, 0, 0);
+static const cricket::VideoCodec kUlpFecCodec(102, "ulpfec", 0, 0, 0, 0);
static const cricket::VideoCodec* const kVideoCodecs[] = {
&kVP8Codec,
+ &kRedCodec,
+ &kUlpFecCodec
};
+static const unsigned int kMinBandwidthKbps = 100;
+static const unsigned int kStartBandwidthKbps = 300;
+static const unsigned int kMaxBandwidthKbps = 2000;
+static const unsigned int kConferenceModeMaxBandwidthKbps = 500;
+
class FakeViEWrapper : public cricket::ViEWrapper {
public:
explicit FakeViEWrapper(cricket::FakeWebRtcVideoEngine* engine)
- : cricket::ViEWrapper(engine, engine, engine, engine,
- engine, engine, engine) {
+ : cricket::ViEWrapper(engine, // base
+ engine, // codec
+ engine, // capture
+ engine, // network
+ engine, // render
+ engine, // rtp
+ engine) { // image
}
};
-class FakeNetworkInterface : public cricket::MediaChannel::NetworkInterface {
+// Test fixture to test WebRtcVideoEngine with a fake webrtc::VideoEngine.
+// Useful for testing failure paths.
+class WebRtcVideoEngineTestFake : public testing::Test {
public:
- FakeNetworkInterface()
- : recv_buffer_size_(0),
- send_buffer_size_(0) {
- }
- virtual bool SendPacket(talk_base::Buffer* packet) {
- return true;
- }
- virtual bool SendRtcp(talk_base::Buffer* packet) {
- return true;
- }
- virtual int SetOption(SocketType type, talk_base::Socket::Option opt,
- int option) {
- if (type == ST_RTP) {
- if (opt == talk_base::Socket::OPT_RCVBUF)
- recv_buffer_size_ = option;
- else if (opt == talk_base::Socket::OPT_SNDBUF)
- send_buffer_size_ = option;
- }
- return 0;
- }
- virtual ~FakeNetworkInterface() {}
- int recv_buffer_size_;
- int send_buffer_size_;
-};
-
-class WebRtcVideoEngineTest : public testing::Test {
- public:
- class ChannelErrorListener : public sigslot::has_slots<> {
- public:
- explicit ChannelErrorListener(cricket::WebRtcVideoMediaChannel* channel)
- : ssrc_(0), error_(cricket::WebRtcVideoMediaChannel::ERROR_NONE) {
- ASSERT(channel != NULL);
- channel->SignalMediaError.connect(
- this, &ChannelErrorListener::OnVideoChannelError);
- }
- void OnVideoChannelError(uint32 ssrc,
- cricket::WebRtcVideoMediaChannel::Error error) {
- ssrc_ = ssrc;
- error_ = error;
- }
- void Reset() {
- ssrc_ = 0;
- error_ = cricket::WebRtcVideoMediaChannel::ERROR_NONE;
- }
- uint32 ssrc() const {
- return ssrc_;
- }
- cricket::WebRtcVideoMediaChannel::Error error() const {
- return error_;
- }
-
- private:
- uint32 ssrc_;
- cricket::WebRtcVideoMediaChannel::Error error_;
- };
-
- WebRtcVideoEngineTest()
+ WebRtcVideoEngineTestFake()
: vie_(kVideoCodecs, ARRAY_SIZE(kVideoCodecs)),
engine_(NULL, // cricket::WebRtcVoiceEngine
new FakeViEWrapper(&vie_)),
@@ -102,9 +86,19 @@
}
return result;
}
- void DeliverPacket(const void* data, int len) {
- talk_base::Buffer packet(data, len);
- channel_->OnPacketReceived(&packet);
+ bool SendI420Frame(int width, int height) {
+ if (NULL == channel_) {
+ return false;
+ }
+ cricket::WebRtcVideoFrame frame;
+ size_t size = width * height * 3 / 2; // I420
+ talk_base::scoped_ptr<uint8> pixel(new uint8[size]);
+ if (!frame.Init(cricket::FOURCC_I420,
+ width, height, width, height,
+ pixel.get(), size, 1, 1, 0, 0, 0)) {
+ return false;
+ }
+ return channel_->SendFrame(0, &frame);
}
virtual void TearDown() {
delete channel_;
@@ -118,40 +112,580 @@
cricket::WebRtcVoiceMediaChannel* voice_channel_;
};
+// Test fixtures to test WebRtcVideoEngine with a real webrtc::VideoEngine.
+class WebRtcVideoEngineTest
+ : public VideoEngineTest<cricket::WebRtcVideoEngine> {
+ protected:
+ typedef VideoEngineTest<cricket::WebRtcVideoEngine> Base;
+};
+class WebRtcVideoMediaChannelTest
+ : public VideoMediaChannelTest<
+ cricket::WebRtcVideoEngine, cricket::WebRtcVideoMediaChannel> {
+ protected:
+ typedef VideoMediaChannelTest<cricket::WebRtcVideoEngine,
+ cricket::WebRtcVideoMediaChannel> Base;
+ virtual cricket::VideoCodec DefaultCodec() { return kVP8Codec; }
+ virtual void SetUp() {
+ Base::SetUp();
+ // Need to start the capturer to allow us to pump in frames.
+ engine_.SetCapture(true);
+ }
+ virtual void TearDown() {
+ engine_.SetCapture(false);
+ Base::TearDown();
+ }
+};
+
+/////////////////////////
+// Tests with fake ViE //
+/////////////////////////
+
// Tests that our stub library "works".
-TEST_F(WebRtcVideoEngineTest, StartupShutdown) {
+TEST_F(WebRtcVideoEngineTestFake, StartupShutdown) {
EXPECT_FALSE(vie_.IsInited());
EXPECT_TRUE(engine_.Init());
EXPECT_TRUE(vie_.IsInited());
engine_.Terminate();
- // TODO: what to expect after Terminate
- // EXPECT_FALSE(vie_.IsInited());
}
// Tests that we can create and destroy a channel.
-TEST_F(WebRtcVideoEngineTest, CreateChannel) {
+TEST_F(WebRtcVideoEngineTestFake, CreateChannel) {
EXPECT_TRUE(engine_.Init());
channel_ = engine_.CreateChannel(voice_channel_);
EXPECT_TRUE(channel_ != NULL);
+ EXPECT_EQ(1, engine_.GetNumOfChannels());
+ delete channel_;
+ channel_ = NULL;
+ EXPECT_EQ(0, engine_.GetNumOfChannels());
}
// Tests that we properly handle failures in CreateChannel.
-TEST_F(WebRtcVideoEngineTest, CreateChannelFail) {
+TEST_F(WebRtcVideoEngineTestFake, CreateChannelFail) {
vie_.set_fail_create_channel(true);
EXPECT_TRUE(engine_.Init());
channel_ = engine_.CreateChannel(voice_channel_);
EXPECT_TRUE(channel_ == NULL);
}
-// Tests that we can find codecs by name or id
+// Tests that we properly handle failures in AllocateExternalCaptureDevice.
+TEST_F(WebRtcVideoEngineTestFake, AllocateExternalCaptureDeviceFail) {
+ vie_.set_fail_alloc_capturer(true);
+ EXPECT_TRUE(engine_.Init());
+ channel_ = engine_.CreateChannel(voice_channel_);
+ EXPECT_TRUE(channel_ == NULL);
+}
+
+// Test that we apply our default codecs properly.
+TEST_F(WebRtcVideoEngineTestFake, SetSendCodecs) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ std::vector<cricket::VideoCodec> codecs(engine_.codecs());
+ EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+ webrtc::VideoCodec gcodec;
+ EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
+ EXPECT_EQ(kVP8Codec.id, gcodec.plType);
+ EXPECT_EQ(kVP8Codec.width, gcodec.width);
+ EXPECT_EQ(kVP8Codec.height, gcodec.height);
+ EXPECT_STREQ(kVP8Codec.name.c_str(), gcodec.plName);
+ EXPECT_EQ(kMinBandwidthKbps, gcodec.minBitrate);
+ EXPECT_EQ(kStartBandwidthKbps, gcodec.startBitrate);
+ EXPECT_EQ(kMaxBandwidthKbps, gcodec.maxBitrate);
+ EXPECT_TRUE(vie_.GetHybridNackFecStatus(channel_num));
+ EXPECT_FALSE(vie_.GetNackStatus(channel_num));
+ // TODO: Check RTCP, PLI, TMMBR.
+}
+
+// Test that we constrain send codecs properly.
+TEST_F(WebRtcVideoEngineTestFake, ConstrainSendCodecs) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+
+ // Set max settings of 640x400x30.
+ EXPECT_TRUE(engine_.SetDefaultEncoderConfig(
+ cricket::VideoEncoderConfig(kVP8Codec)));
+
+ // Send codec format bigger than max setting.
+ cricket::VideoCodec codec(kVP8Codec);
+ codec.width = 1280;
+ codec.height = 800;
+ codec.framerate = 60;
+ std::vector<cricket::VideoCodec> codec_list;
+ codec_list.push_back(codec);
+
+ // Set send codec and verify codec has been constrained.
+ EXPECT_TRUE(channel_->SetSendCodecs(codec_list));
+ webrtc::VideoCodec gcodec;
+ EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
+ EXPECT_EQ(kVP8Codec.id, gcodec.plType);
+ EXPECT_EQ(kVP8Codec.width, gcodec.width);
+ EXPECT_EQ(kVP8Codec.height, gcodec.height);
+ EXPECT_EQ(kVP8Codec.framerate, gcodec.maxFramerate);
+ EXPECT_STREQ(kVP8Codec.name.c_str(), gcodec.plName);
+}
+
+// Test that SetSendCodecs rejects bad format.
+TEST_F(WebRtcVideoEngineTestFake, SetSendCodecsRejectBadFormat) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+
+ // Set w = 0.
+ cricket::VideoCodec codec(kVP8Codec);
+ codec.width = 0;
+ std::vector<cricket::VideoCodec> codec_list;
+ codec_list.push_back(codec);
+
+ // Verify SetSendCodecs failed and send codec is not changed on engine.
+ EXPECT_FALSE(channel_->SetSendCodecs(codec_list));
+ webrtc::VideoCodec gcodec;
+ EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
+ EXPECT_EQ(0, gcodec.plType);
+
+ // Set h = 0.
+ codec_list[0].width = 640;
+ codec_list[0].height = 0;
+
+ // Verify SetSendCodecs failed and send codec is not changed on engine.
+ EXPECT_FALSE(channel_->SetSendCodecs(codec_list));
+ EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
+ EXPECT_EQ(0, gcodec.plType);
+}
+
+// Test that SetSendCodecs rejects bad codec.
+TEST_F(WebRtcVideoEngineTestFake, SetSendCodecsRejectBadCodec) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+
+ // Set bad codec name.
+ cricket::VideoCodec codec(kVP8Codec);
+ codec.name = "bad";
+ std::vector<cricket::VideoCodec> codec_list;
+ codec_list.push_back(codec);
+
+ // Verify SetSendCodecs failed and send codec is not changed on engine.
+ EXPECT_FALSE(channel_->SetSendCodecs(codec_list));
+ webrtc::VideoCodec gcodec;
+ EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
+ EXPECT_EQ(0, gcodec.plType);
+}
+
+// Test that vie send codec is reset on new video frame size.
+TEST_F(WebRtcVideoEngineTestFake, ResetVieSendCodecOnNewFrameSize) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+
+ // Set send codec.
+ std::vector<cricket::VideoCodec> codec_list;
+ codec_list.push_back(kVP8Codec);
+ EXPECT_TRUE(channel_->SetSendCodecs(codec_list));
+ EXPECT_TRUE(channel_->AddSendStream(
+ cricket::StreamParams::CreateLegacy(123)));
+ EXPECT_TRUE(channel_->SetSend(true));
+
+ // Capture a smaller frame and verify vie send codec has been reset to
+ // the new size.
+ SendI420Frame(kVP8Codec.width / 2, kVP8Codec.height / 2);
+ webrtc::VideoCodec gcodec;
+ EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
+ EXPECT_EQ(kVP8Codec.width / 2, gcodec.width);
+ EXPECT_EQ(kVP8Codec.height / 2, gcodec.height);
+
+ // Capture a frame bigger than send_codec_ and verify vie send codec has been
+ // reset (and clipped) to send_codec_.
+ SendI420Frame(kVP8Codec.width * 2, kVP8Codec.height * 2);
+ EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
+ EXPECT_EQ(kVP8Codec.width, gcodec.width);
+ EXPECT_EQ(kVP8Codec.height, gcodec.height);
+}
+
+// Test that we set our inbound codecs properly.
+TEST_F(WebRtcVideoEngineTestFake, SetRecvCodecs) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+
+ std::vector<cricket::VideoCodec> codecs;
+ codecs.push_back(kVP8Codec);
+ EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+
+ webrtc::VideoCodec wcodec;
+ EXPECT_TRUE(engine_.ConvertFromCricketVideoCodec(kVP8Codec, &wcodec));
+ EXPECT_TRUE(vie_.ReceiveCodecRegistered(channel_num, wcodec));
+}
+
+// Test that channel connects and disconnects external capturer correctly.
+TEST_F(WebRtcVideoEngineTestFake, HasExternalCapturer) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+
+ EXPECT_EQ(1, vie_.GetNumCapturers());
+ int capture_id = vie_.GetCaptureId(channel_num);
+ EXPECT_EQ(channel_num, vie_.GetCaptureChannelId(capture_id));
+
+ // Delete the channel should disconnect the capturer.
+ delete channel_;
+ channel_ = NULL;
+ EXPECT_EQ(0, vie_.GetNumCapturers());
+}
+
+// Test that channel adds and removes renderer correctly.
+TEST_F(WebRtcVideoEngineTestFake, HasRenderer) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+
+ EXPECT_TRUE(vie_.GetHasRenderer(channel_num));
+ EXPECT_FALSE(vie_.GetRenderStarted(channel_num));
+}
+
+// Test that rtcp is enabled on the channel.
+TEST_F(WebRtcVideoEngineTestFake, RtcpEnabled) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ EXPECT_EQ(webrtc::kRtcpCompound_RFC4585, vie_.GetRtcpStatus(channel_num));
+}
+
+// Test that key frame request method is set on the channel.
+TEST_F(WebRtcVideoEngineTestFake, KeyFrameRequestEnabled) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ EXPECT_EQ(webrtc::kViEKeyFrameRequestPliRtcp,
+ vie_.GetKeyFrameRequestMethod(channel_num));
+}
+
+// Test that remb is enabled on the default channel.
+TEST_F(WebRtcVideoEngineTestFake, RembEnabled) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ EXPECT_TRUE(channel_->AddSendStream(
+ cricket::StreamParams::CreateLegacy(1)));
+ EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+ EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+ EXPECT_FALSE(vie_.GetRembStatusSend(channel_num));
+ EXPECT_TRUE(channel_->SetSend(true));
+ EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+ EXPECT_TRUE(vie_.GetRembStatusSend(channel_num));
+}
+
+// Test that remb is enabled on a receive channel but it uses the default
+// channel for sending remb packets.
+TEST_F(WebRtcVideoEngineTestFake, RembEnabledOnReceiveChannels) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
+ EXPECT_TRUE(channel_->AddSendStream(
+ cricket::StreamParams::CreateLegacy(1)));
+ EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+ EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+ EXPECT_FALSE(vie_.GetRembStatusSend(channel_num));
+ EXPECT_TRUE(channel_->SetSend(true));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+ int new_channel_num = vie_.GetLastChannel();
+ EXPECT_NE(channel_num, new_channel_num);
+
+ EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+ EXPECT_TRUE(vie_.GetRembStatusSend(channel_num));
+ EXPECT_TRUE(vie_.GetRembStatus(new_channel_num));
+ EXPECT_FALSE(vie_.GetRembStatusSend(new_channel_num));
+}
+
+// Test that AddRecvStream doesn't create new channel for 1:1 call.
+TEST_F(WebRtcVideoEngineTestFake, AddRecvStream1On1) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+ EXPECT_EQ(channel_num, vie_.GetLastChannel());
+}
+
+// Test that AddRecvStream doesn't change remb for 1:1 call.
+TEST_F(WebRtcVideoEngineTestFake, NoRembChangeAfterAddRecvStream) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ EXPECT_TRUE(channel_->AddSendStream(
+ cricket::StreamParams::CreateLegacy(1)));
+ EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+ EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+ EXPECT_FALSE(vie_.GetRembStatusSend(channel_num));
+ EXPECT_TRUE(channel_->SetSend(true));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+ EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+ EXPECT_TRUE(vie_.GetRembStatusSend(channel_num));
+}
+
+// Test remb sending is on after StartSending and off after StopSending.
+TEST_F(WebRtcVideoEngineTestFake, RembOnOff) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+
+ // Verify remb sending is off before StartSending.
+ EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+ EXPECT_FALSE(vie_.GetRembStatusSend(channel_num));
+
+ // Verify remb sending is on after StartSending.
+ EXPECT_TRUE(channel_->AddSendStream(
+ cricket::StreamParams::CreateLegacy(1)));
+ EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+ EXPECT_TRUE(channel_->SetSend(true));
+ EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+ EXPECT_TRUE(vie_.GetRembStatusSend(channel_num));
+
+ // Verify remb sending is off after StopSending.
+ EXPECT_TRUE(channel_->SetSend(false));
+ EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+ EXPECT_FALSE(vie_.GetRembStatusSend(channel_num));
+}
+
+// Test that nack is enabled on the channel if we don't offer red/fec.
+TEST_F(WebRtcVideoEngineTestFake, NackEnabled) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ std::vector<cricket::VideoCodec> codecs(engine_.codecs());
+ codecs.resize(1); // toss out red and ulpfec
+ EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+ EXPECT_TRUE(vie_.GetNackStatus(channel_num));
+}
+
+// Test that we enable hybrid NACK FEC mode.
+TEST_F(WebRtcVideoEngineTestFake, HybridNackFec) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs()));
+ EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+ EXPECT_TRUE(vie_.GetHybridNackFecStatus(channel_num));
+ EXPECT_FALSE(vie_.GetNackStatus(channel_num));
+}
+
+// Test that we enable hybrid NACK FEC mode when calling SetSendCodecs and
+// SetReceiveCodecs in reversed order.
+TEST_F(WebRtcVideoEngineTestFake, HybridNackFecReversedOrder) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+ EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs()));
+ EXPECT_TRUE(vie_.GetHybridNackFecStatus(channel_num));
+ EXPECT_FALSE(vie_.GetNackStatus(channel_num));
+}
+
+// Test NACK vs Hybrid NACK/FEC interop call setup, i.e. only use NACK even if
+// red/fec is offered as receive codec.
+TEST_F(WebRtcVideoEngineTestFake, VideoProtectionInterop) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ std::vector<cricket::VideoCodec> recv_codecs(engine_.codecs());
+ std::vector<cricket::VideoCodec> send_codecs(engine_.codecs());
+ // Only add VP8 as send codec.
+ send_codecs.resize(1);
+ EXPECT_TRUE(channel_->SetRecvCodecs(recv_codecs));
+ EXPECT_TRUE(channel_->SetSendCodecs(send_codecs));
+ EXPECT_FALSE(vie_.GetHybridNackFecStatus(channel_num));
+ EXPECT_TRUE(vie_.GetNackStatus(channel_num));
+}
+
+// Test NACK vs Hybrid NACK/FEC interop call setup, i.e. only use NACK even if
+// red/fec is offered as receive codec. Call order reversed compared to
+// VideoProtectionInterop.
+TEST_F(WebRtcVideoEngineTestFake, VideoProtectionInteropReversed) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ std::vector<cricket::VideoCodec> recv_codecs(engine_.codecs());
+ std::vector<cricket::VideoCodec> send_codecs(engine_.codecs());
+ // Only add VP8 as send codec.
+ send_codecs.resize(1);
+ EXPECT_TRUE(channel_->SetSendCodecs(send_codecs));
+ EXPECT_TRUE(channel_->SetRecvCodecs(recv_codecs));
+ EXPECT_FALSE(vie_.GetHybridNackFecStatus(channel_num));
+ EXPECT_TRUE(vie_.GetNackStatus(channel_num));
+}
+
+// Test that NACK, not hybrid mode, is enabled in conference mode.
+TEST_F(WebRtcVideoEngineTestFake, HybridNackFecConference) {
+ EXPECT_TRUE(SetupEngine());
+ // Setup the send channel.
+ int send_channel_num = vie_.GetLastChannel();
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
+ EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs()));
+ EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+ EXPECT_FALSE(vie_.GetHybridNackFecStatus(send_channel_num));
+ EXPECT_TRUE(vie_.GetNackStatus(send_channel_num));
+ // Add a receive stream.
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+ int receive_channel_num = vie_.GetLastChannel();
+ EXPECT_FALSE(vie_.GetHybridNackFecStatus(receive_channel_num));
+ EXPECT_TRUE(vie_.GetNackStatus(receive_channel_num));
+}
+
+// Test that we can create a channel and start/stop rendering out on it.
+TEST_F(WebRtcVideoEngineTestFake, SetRender) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+
+ // Verify we can start/stop/start/stop rendering.
+ EXPECT_TRUE(channel_->SetRender(true));
+ EXPECT_TRUE(vie_.GetRenderStarted(channel_num));
+ EXPECT_TRUE(channel_->SetRender(false));
+ EXPECT_FALSE(vie_.GetRenderStarted(channel_num));
+ EXPECT_TRUE(channel_->SetRender(true));
+ EXPECT_TRUE(vie_.GetRenderStarted(channel_num));
+ EXPECT_TRUE(channel_->SetRender(false));
+ EXPECT_FALSE(vie_.GetRenderStarted(channel_num));
+}
+
+// Test that we can create a channel and start/stop sending out on it.
+TEST_F(WebRtcVideoEngineTestFake, SetSend) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+
+ // Set send codecs on the channel.
+ std::vector<cricket::VideoCodec> codecs;
+ codecs.push_back(kVP8Codec);
+ EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+ EXPECT_TRUE(channel_->AddSendStream(
+ cricket::StreamParams::CreateLegacy(123)));
+
+ // Verify we can start/stop/start/stop sending.
+ EXPECT_TRUE(channel_->SetSend(true));
+ EXPECT_TRUE(vie_.GetSend(channel_num));
+ EXPECT_TRUE(channel_->SetSend(false));
+ EXPECT_FALSE(vie_.GetSend(channel_num));
+ EXPECT_TRUE(channel_->SetSend(true));
+ EXPECT_TRUE(vie_.GetSend(channel_num));
+ EXPECT_TRUE(channel_->SetSend(false));
+ EXPECT_FALSE(vie_.GetSend(channel_num));
+}
+
+// Test that we set bandwidth properly when using full auto bandwidth mode.
+TEST_F(WebRtcVideoEngineTestFake, SetBandwidthAuto) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+ EXPECT_TRUE(channel_->SetSendBandwidth(true, cricket::kAutoBandwidth));
+ webrtc::VideoCodec gcodec;
+ EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
+ EXPECT_EQ(kVP8Codec.id, gcodec.plType);
+ EXPECT_STREQ(kVP8Codec.name.c_str(), gcodec.plName);
+ EXPECT_EQ(kMinBandwidthKbps, gcodec.minBitrate);
+ EXPECT_EQ(kStartBandwidthKbps, gcodec.startBitrate);
+ EXPECT_EQ(kMaxBandwidthKbps, gcodec.maxBitrate);
+}
+
+// Test that we set bandwidth properly when using auto with upper bound.
+TEST_F(WebRtcVideoEngineTestFake, SetBandwidthAutoCapped) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+ EXPECT_TRUE(channel_->SetSendBandwidth(true, 768000));
+ webrtc::VideoCodec gcodec;
+ EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
+ EXPECT_EQ(kVP8Codec.id, gcodec.plType);
+ EXPECT_STREQ(kVP8Codec.name.c_str(), gcodec.plName);
+ EXPECT_EQ(kMinBandwidthKbps, gcodec.minBitrate);
+ EXPECT_EQ(kStartBandwidthKbps, gcodec.startBitrate);
+ EXPECT_EQ(768U, gcodec.maxBitrate);
+}
+
+// Test that we set bandwidth properly when using a fixed bandwidth.
+TEST_F(WebRtcVideoEngineTestFake, SetBandwidthFixed) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+ EXPECT_TRUE(channel_->SetSendBandwidth(false, 768000));
+ webrtc::VideoCodec gcodec;
+ EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
+ EXPECT_EQ(kVP8Codec.id, gcodec.plType);
+ EXPECT_STREQ(kVP8Codec.name.c_str(), gcodec.plName);
+ EXPECT_EQ(768U, gcodec.minBitrate);
+ EXPECT_EQ(768U, gcodec.startBitrate);
+ EXPECT_EQ(768U, gcodec.maxBitrate);
+}
+
+// Test SetSendSsrc.
+TEST_F(WebRtcVideoEngineTestFake, SetSendSsrcAndCname) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+
+ cricket::StreamParams stream;
+ stream.ssrcs.push_back(1234);
+ stream.cname = "cname";
+ channel_->AddSendStream(stream);
+
+ unsigned int ssrc = 0;
+ EXPECT_EQ(0, vie_.GetLocalSSRC(channel_num, ssrc));
+ EXPECT_EQ(1234U, ssrc);
+
+ char rtcp_cname[256];
+ EXPECT_EQ(0, vie_.GetRTCPCName(channel_num, rtcp_cname));
+ EXPECT_STREQ("cname", rtcp_cname);
+}
+
+// Test that the local SSRC is the same on sending and receiving channels if the
+// receive channel is created before the send channel.
+TEST_F(WebRtcVideoEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) {
+ EXPECT_TRUE(SetupEngine());
+
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+ int receive_channel_num = vie_.GetLastChannel();
+ cricket::StreamParams stream = cricket::StreamParams::CreateLegacy(1234);
+ EXPECT_TRUE(channel_->AddSendStream(stream));
+ int send_channel_num = vie_.GetLastChannel();
+ unsigned int ssrc = 0;
+ EXPECT_EQ(0, vie_.GetLocalSSRC(send_channel_num, ssrc));
+ EXPECT_EQ(1234U, ssrc);
+ ssrc = 0;
+ EXPECT_EQ(0, vie_.GetLocalSSRC(receive_channel_num, ssrc));
+ EXPECT_EQ(1234U, ssrc);
+}
+
+// Test SetOptions with OPT_CONFERENCE flag.
+TEST_F(WebRtcVideoEngineTestFake, SetOptionsWithConferenceMode) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+ EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+
+ // Verify default send codec and bitrate.
+ webrtc::VideoCodec gcodec;
+ EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
+ EXPECT_EQ(kVP8Codec.id, gcodec.plType);
+ EXPECT_STREQ(kVP8Codec.name.c_str(), gcodec.plName);
+ EXPECT_EQ(kMinBandwidthKbps, gcodec.minBitrate);
+ EXPECT_EQ(kStartBandwidthKbps, gcodec.startBitrate);
+ EXPECT_EQ(kMaxBandwidthKbps, gcodec.maxBitrate);
+
+ // Set options with OPT_CONFERENCE flag.
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
+
+ // Verify channel now has new max bitrate.
+ EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
+ EXPECT_EQ(kVP8Codec.id, gcodec.plType);
+ EXPECT_STREQ(kVP8Codec.name.c_str(), gcodec.plName);
+ EXPECT_EQ(kMinBandwidthKbps, gcodec.minBitrate);
+ EXPECT_EQ(kStartBandwidthKbps, gcodec.startBitrate);
+ EXPECT_EQ(kConferenceModeMaxBandwidthKbps, gcodec.maxBitrate);
+
+ // Set options back to zero.
+ EXPECT_TRUE(channel_->SetOptions(0));
+
+ // Verify channel now has default max bitrate again.
+ EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
+ EXPECT_EQ(kVP8Codec.id, gcodec.plType);
+ EXPECT_STREQ(kVP8Codec.name.c_str(), gcodec.plName);
+ EXPECT_EQ(kMinBandwidthKbps, gcodec.minBitrate);
+ EXPECT_EQ(kStartBandwidthKbps, gcodec.startBitrate);
+ EXPECT_EQ(kMaxBandwidthKbps, gcodec.maxBitrate);
+}
+
+/////////////////////////
+// Tests with real ViE //
+/////////////////////////
+
+// Tests that we can find codecs by name or id.
TEST_F(WebRtcVideoEngineTest, FindCodec) {
// We should not need to init engine in order to get codecs.
const std::vector<cricket::VideoCodec>& c = engine_.codecs();
- EXPECT_EQ(1U, c.size());
+ EXPECT_EQ(3U, c.size());
cricket::VideoCodec vp8(104, "VP8", 320, 200, 30, 0);
EXPECT_TRUE(engine_.FindCodec(vp8));
+ cricket::VideoCodec vp8_ci(104, "vp8", 320, 200, 30, 0);
+ EXPECT_TRUE(engine_.FindCodec(vp8));
+
cricket::VideoCodec vp8_diff_fr_diff_pref(104, "VP8", 320, 200, 50, 50);
EXPECT_TRUE(engine_.FindCodec(vp8_diff_fr_diff_pref));
@@ -167,59 +701,251 @@
// Test that FindCodec can handle the case when width/height is 0.
cricket::VideoCodec vp8_zero_res(104, "VP8", 0, 0, 30, 0);
EXPECT_TRUE(engine_.FindCodec(vp8_zero_res));
+
+ cricket::VideoCodec red(101, "RED", 0, 0, 30, 0);
+ EXPECT_TRUE(engine_.FindCodec(red));
+
+ cricket::VideoCodec red_ci(101, "red", 0, 0, 30, 0);
+ EXPECT_TRUE(engine_.FindCodec(red));
+
+ cricket::VideoCodec fec(102, "ULPFEC", 0, 0, 30, 0);
+ EXPECT_TRUE(engine_.FindCodec(fec));
+
+ cricket::VideoCodec fec_ci(102, "ulpfec", 0, 0, 30, 0);
+ EXPECT_TRUE(engine_.FindCodec(fec));
}
-// Test that we set our inbound codecs properly
-TEST_F(WebRtcVideoEngineTest, SetRecvCodecs) {
- EXPECT_TRUE(SetupEngine());
+TEST_F(WebRtcVideoEngineTest, StartupShutdown) {
+ EXPECT_TRUE(engine_.Init());
+ engine_.Terminate();
+}
+
+TEST_PRE_VIDEOENGINE_INIT(WebRtcVideoEngineTest, ConstrainNewCodec)
+TEST_POST_VIDEOENGINE_INIT(WebRtcVideoEngineTest, ConstrainNewCodec)
+
+TEST_PRE_VIDEOENGINE_INIT(WebRtcVideoEngineTest, ConstrainRunningCodec)
+TEST_POST_VIDEOENGINE_INIT(WebRtcVideoEngineTest, ConstrainRunningCodec)
+
+// TODO: Figure out why ViE is munging the COM refcount.
+#ifdef WIN32
+TEST_F(WebRtcVideoEngineTest, DISABLED_CheckCoInitialize) {
+ Base::CheckCoInitialize();
+}
+#endif
+
+TEST_F(WebRtcVideoEngineTest, CreateChannel) {
+ EXPECT_TRUE(engine_.Init());
+ cricket::VideoMediaChannel* channel = engine_.CreateChannel(NULL);
+ EXPECT_TRUE(channel != NULL);
+ delete channel;
+}
+
+TEST_F(WebRtcVideoEngineTest, SetCaptureDevice) {
+ cricket::Device device;
+ EXPECT_TRUE(engine_.Init());
+
+ EXPECT_TRUE(engine_.SetCaptureDevice(&device));
+ EXPECT_FALSE(engine_.IsCapturing());
+ // FakeVideoCapturer returns CR_SUCCESS.
+ EXPECT_EQ(cricket::CR_SUCCESS, engine_.SetCapture(true));
+ EXPECT_TRUE(engine_.IsCapturing());
+
+ EXPECT_TRUE(engine_.SetCaptureDevice(NULL));
+ EXPECT_FALSE(engine_.IsCapturing());
+}
+
+TEST_F(WebRtcVideoEngineTest, SetCaptureModule) {
+ // Use 123 to verify there's no assumption to the module id
+ FakeWebRtcVideoCaptureModule* vcm =
+ new FakeWebRtcVideoCaptureModule(NULL, 123);
+ EXPECT_TRUE(engine_.Init());
+ // The ownership of the vcm is transferred to the engine.
+ // Technically we should call vcm->AddRef since we are using the vcm below,
+ // however the FakeWebRtcVideoCaptureModule didn't implemented the refcount.
+ // So for testing, this should be fine.
+ // The SetCaptureModule call always starts the capture.
+ EXPECT_TRUE(engine_.SetCaptureModule(vcm));
+ EXPECT_TRUE(engine_.IsCapturing());
+ EXPECT_EQ(engine_.default_codec_format().width, vcm->cap().width);
+ EXPECT_EQ(engine_.default_codec_format().height, vcm->cap().height);
+ EXPECT_EQ(cricket::VideoFormat::IntervalToFps(
+ engine_.default_codec_format().interval),
+ vcm->cap().maxFPS);
+ EXPECT_EQ(webrtc::kVideoI420, vcm->cap().rawType);
+ EXPECT_EQ(webrtc::kVideoCodecUnknown, vcm->cap().codecType);
+
+ EXPECT_TRUE(engine_.SetCaptureModule(NULL));
+ EXPECT_FALSE(engine_.IsCapturing());
+}
+
+TEST_F(WebRtcVideoEngineTest, SetVideoCapturer) {
+ // Use 123 to verify there's no assumption to the module id
+ FakeWebRtcVideoCaptureModule* vcm =
+ new FakeWebRtcVideoCaptureModule(NULL, 123);
+ talk_base::scoped_ptr<cricket::WebRtcVideoCapturer> capturer(
+ new cricket::WebRtcVideoCapturer);
+ EXPECT_TRUE(capturer->Init(vcm));
+ EXPECT_TRUE(engine_.Init());
+ const uint32 ssrc_dummy = 0;
+ EXPECT_TRUE(engine_.SetVideoCapturer(capturer.get(), ssrc_dummy));
+ EXPECT_FALSE(engine_.IsCapturing());
+ EXPECT_EQ(cricket::CR_PENDING, engine_.SetCapture(true));
+ EXPECT_TRUE(engine_.IsCapturing());
+
+ EXPECT_EQ(engine_.default_codec_format().width, vcm->cap().width);
+ EXPECT_EQ(engine_.default_codec_format().height, vcm->cap().height);
+ EXPECT_EQ(cricket::VideoFormat::IntervalToFps(
+ engine_.default_codec_format().interval),
+ vcm->cap().maxFPS);
+ EXPECT_EQ(webrtc::kVideoI420, vcm->cap().rawType);
+ EXPECT_EQ(webrtc::kVideoCodecUnknown, vcm->cap().codecType);
+
+ EXPECT_TRUE(engine_.SetVideoCapturer(NULL, ssrc_dummy));
+ EXPECT_FALSE(engine_.IsCapturing());
+}
+
+TEST_F(WebRtcVideoEngineTest, TestRegisterVideoProcessor) {
+ cricket::FakeMediaProcessor vp;
+ EXPECT_TRUE(engine_.Init());
+
+ EXPECT_TRUE(engine_.RegisterProcessor(&vp));
+ engine_.TriggerMediaFrame(0, NULL);
+ EXPECT_EQ(1, vp.video_frame_count());
+
+ EXPECT_TRUE(engine_.UnregisterProcessor(&vp));
+ engine_.TriggerMediaFrame(0, NULL);
+ EXPECT_EQ(1, vp.video_frame_count());
+
+ engine_.Terminate();
+}
+
+TEST_F(WebRtcVideoMediaChannelTest, SetRecvCodecs) {
std::vector<cricket::VideoCodec> codecs;
codecs.push_back(kVP8Codec);
EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
}
+TEST_F(WebRtcVideoMediaChannelTest, SetRecvCodecsWrongPayloadType) {
+ std::vector<cricket::VideoCodec> codecs;
+ codecs.push_back(kVP8Codec);
+ codecs[0].id = 99;
+ EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+}
+TEST_F(WebRtcVideoMediaChannelTest, SetRecvCodecsUnsupportedCodec) {
+ std::vector<cricket::VideoCodec> codecs;
+ codecs.push_back(kVP8Codec);
+ codecs.push_back(cricket::VideoCodec(101, "VP1", 640, 400, 30, 0));
+ EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
+}
-// Test that we apply codecs properly.
-TEST_F(WebRtcVideoEngineTest, SetSendCodecs) {
- EXPECT_TRUE(SetupEngine());
- int channel_num = vie_.GetLastChannel();
+TEST_F(WebRtcVideoMediaChannelTest, SetSend) {
+ Base::SetSend();
+}
+TEST_F(WebRtcVideoMediaChannelTest, SetSendWithoutCodecs) {
+ Base::SetSendWithoutCodecs();
+}
+TEST_F(WebRtcVideoMediaChannelTest, SetSendSetsTransportBufferSizes) {
+ Base::SetSendSetsTransportBufferSizes();
+}
+
+TEST_F(WebRtcVideoMediaChannelTest, SendAndReceiveVp8Vga) {
+ SendAndReceive(cricket::VideoCodec(100, "VP8", 640, 400, 30, 0));
+}
+TEST_F(WebRtcVideoMediaChannelTest, SendAndReceiveVp8Qvga) {
+ SendAndReceive(cricket::VideoCodec(100, "VP8", 320, 200, 30, 0));
+}
+TEST_F(WebRtcVideoMediaChannelTest, SendAndReceiveH264SvcQqvga) {
+ SendAndReceive(cricket::VideoCodec(100, "VP8", 160, 100, 30, 0));
+}
+// TODO: Figure out why this test doesn't work.
+TEST_F(WebRtcVideoMediaChannelTest, DISABLED_SendManyResizeOnce) {
+ SendManyResizeOnce();
+}
+
+// TODO: Fix this test to tolerate missing stats.
+TEST_F(WebRtcVideoMediaChannelTest, DISABLED_GetStats) {
+ Base::GetStats();
+}
+
+// TODO: Fix this test to tolerate missing stats.
+TEST_F(WebRtcVideoMediaChannelTest, DISABLED_GetStatsMultipleRecvStreams) {
+ Base::GetStatsMultipleRecvStreams();
+}
+// TODO: Restore this test once we support multiple send streams.
+TEST_F(WebRtcVideoMediaChannelTest, DISABLED_GetStatsMultipleSendStreams) {
+ Base::GetStatsMultipleSendStreams();
+}
+
+TEST_F(WebRtcVideoMediaChannelTest, SetSendBandwidth) {
+ Base::SetSendBandwidth();
+}
+TEST_F(WebRtcVideoMediaChannelTest, SetSendSsrc) {
+ Base::SetSendSsrc();
+}
+TEST_F(WebRtcVideoMediaChannelTest, SetSendSsrcAfterSetCodecs) {
+ Base::SetSendSsrcAfterSetCodecs();
+}
+
+TEST_F(WebRtcVideoMediaChannelTest, SetRenderer) {
+ Base::SetRenderer();
+}
+
+TEST_F(WebRtcVideoMediaChannelTest, AddRemoveRecvStreams) {
+ Base::AddRemoveRecvStreams();
+}
+
+TEST_F(WebRtcVideoMediaChannelTest, AddRemoveRecvStreamsNoConference) {
+ Base::AddRemoveRecvStreamsNoConference();
+}
+
+TEST_F(WebRtcVideoMediaChannelTest, AddRemoveSendStreams) {
+ Base::AddRemoveSendStreams();
+}
+
+TEST_F(WebRtcVideoMediaChannelTest, SimulateConference) {
+ Base::SimulateConference();
+}
+
+TEST_F(WebRtcVideoMediaChannelTest, SetOptionsFailsWhenSending) {
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
+
+ // Verify SetOptions returns true on a different options.
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CPU_ADAPTATION));
+
+ // Set send codecs on the channel and start sending.
std::vector<cricket::VideoCodec> codecs;
codecs.push_back(kVP8Codec);
EXPECT_TRUE(channel_->SetSendCodecs(codecs));
- webrtc::VideoCodec gcodec;
- EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
- EXPECT_EQ(kVP8Codec.id, gcodec.plType);
- EXPECT_EQ(kVP8Codec.width, gcodec.width);
- EXPECT_EQ(kVP8Codec.height, gcodec.height);
- EXPECT_STREQ(kVP8Codec.name.c_str(), gcodec.plName);
+ EXPECT_TRUE(channel_->SetSend(true));
+
+ // Verify SetOptions returns false if channel is already sending.
+ EXPECT_FALSE(channel_->SetOptions(cricket::OPT_CONFERENCE));
+
+ // Verify SetOptions returns true with the old options.
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CPU_ADAPTATION));
}
-// Tests that the rtp buffer is set properly after the SetInterface call.
-TEST_F(WebRtcVideoEngineTest, SetRtpBufferSize) {
- EXPECT_TRUE(SetupEngine());
- const int kExpectedVideoRtpBufferSize = 65536;
- FakeNetworkInterface network_interface;
- channel_->SetInterface(&network_interface);
- EXPECT_EQ(kExpectedVideoRtpBufferSize, network_interface.recv_buffer_size_);
- EXPECT_EQ(kExpectedVideoRtpBufferSize, network_interface.send_buffer_size_);
+// TODO: Investigate why this test is flaky.
+TEST_F(WebRtcVideoMediaChannelTest, DISABLED_AdaptResolution16x10) {
+ Base::AdaptResolution16x10();
}
-
-// TODO: add tests for below interfaces
-// bool SetOptions(int options);
-// bool SetCaptureDevice(const Device* device);
-// bool SetLocalRenderer(VideoRenderer* renderer);
-// CaptureResult SetCapture(bool capture);
-// virtual bool SetRender(bool render);
-// virtual bool SetSend(bool send);
-// virtual bool AddStream(uint32 ssrc, uint32 voice_ssrc);
-// virtual bool RemoveStream(uint32 ssrc);
-// virtual bool SetRenderer(uint32 ssrc, VideoRenderer* renderer);
-// virtual bool GetStats(VideoMediaInfo* info);
-// virtual bool SendIntraFrame();
-// virtual bool RequestIntraFrame();
-// virtual void OnPacketReceived(talk_base::Buffer* packet);
-// virtual void OnRtcpReceived(talk_base::Buffer* packet);
-// virtual void SetSendSsrc(uint32 id);
-// virtual bool SetRtcpCName(const std::string& cname);
-// virtual bool Mute(bool on);
-// virtual bool SetSendBandwidth(bool autobw, int bps);
-// virtual bool SetOptions(int options);
-
+// TODO: Investigate why this test is flaky.
+TEST_F(WebRtcVideoMediaChannelTest, DISABLED_AdaptResolution4x3) {
+ Base::AdaptResolution4x3();
+}
+// TODO: Restore this test once we support sending 0 fps.
+TEST_F(WebRtcVideoMediaChannelTest, DISABLED_AdaptDropAllFrames) {
+ Base::AdaptDropAllFrames();
+}
+// TODO: Understand why we get decode errors on this test.
+TEST_F(WebRtcVideoMediaChannelTest, DISABLED_AdaptFramerate) {
+ Base::AdaptFramerate();
+}
+// TODO: Understand why format is set but the encoded frames do not
+// change.
+TEST_F(WebRtcVideoMediaChannelTest, DISABLED_SetSendStreamFormat) {
+ Base::SetSendStreamFormat();
+}
+// TODO: Understand why we receive a not-quite-black frame.
+TEST_F(WebRtcVideoMediaChannelTest, DISABLED_Mute) {
+ Base::Mute();
+}
diff --git a/talk/session/phone/webrtcvideoframe.cc b/talk/session/phone/webrtcvideoframe.cc
index 8d2d6ca..5eb849d 100644
--- a/talk/session/phone/webrtcvideoframe.cc
+++ b/talk/session/phone/webrtcvideoframe.cc
@@ -1,6 +1,6 @@
/*
* libjingle
- * Copyright 2004--2011, Google Inc.
+ * 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:
@@ -27,17 +27,20 @@
#include "talk/session/phone/webrtcvideoframe.h"
+#include "libyuv/convert.h"
+#include "libyuv/planar_functions.h"
#include "talk/base/logging.h"
#include "talk/session/phone/videocapturer.h"
#include "talk/session/phone/videocommon.h"
-#ifdef WEBRTC_RELATIVE_PATH
-#include "common_video/vplib/main/interface/vplib.h"
-#else
-#include "third_party/webrtc/files/include/vplib.h"
-#endif
namespace cricket {
+static const int kWatermarkWidth = 8;
+static const int kWatermarkHeight = 8;
+static const int kWatermarkOffsetFromLeft = 8;
+static const int kWatermarkOffsetFromBottom = 8;
+static const unsigned char kWatermarkMaxYValue = 64;
+
WebRtcVideoFrame::WebRtcVideoFrame() {
}
@@ -49,36 +52,22 @@
size_t pixel_width, size_t pixel_height,
int64 elapsed_time, int64 time_stamp,
int rotation) {
- // WebRtcVideoFrame currently doesn't support color conversion or rotation.
- if (format != FOURCC_I420 || dw != w || dh != h || rotation != 0) {
- return false;
- }
-
- uint8* buffer = new uint8[sample_size];
- memcpy(buffer, sample, sample_size);
- Attach(buffer, sample_size, w, h, pixel_width, pixel_height,
- elapsed_time, time_stamp, rotation);
- return true;
+ return Reset(format, w, h, dw, dh, sample, sample_size,
+ pixel_width, pixel_height, elapsed_time, time_stamp, rotation);
}
bool WebRtcVideoFrame::Init(const CapturedFrame* frame, int dw, int dh) {
- return Init(frame->fourcc, frame->width, frame->height, dw, dh,
- static_cast<uint8*>(frame->data), frame->data_size,
- frame->pixel_width, frame->pixel_height,
- frame->elapsed_time, frame->time_stamp, frame->rotation);
+ return Reset(frame->fourcc, frame->width, frame->height, dw, dh,
+ static_cast<uint8*>(frame->data), frame->data_size,
+ frame->pixel_width, frame->pixel_height,
+ frame->elapsed_time, frame->time_stamp, frame->rotation);
}
bool WebRtcVideoFrame::InitToBlack(int w, int h,
size_t pixel_width, size_t pixel_height,
int64 elapsed_time, int64 time_stamp) {
- size_t buffer_size = VideoFrame::SizeOf(w, h);
- uint8* buffer = new uint8[buffer_size];
- Attach(buffer, buffer_size, w, h, pixel_width, pixel_height,
- elapsed_time, time_stamp, 0);
- memset(GetYPlane(), 16, w * h);
- memset(GetUPlane(), 128, w * h / 4);
- memset(GetVPlane(), 128, w * h / 4);
- return true;
+ InitToEmptyBuffer(w, h, pixel_width, pixel_height, elapsed_time, time_stamp);
+ return SetToBlack();
}
void WebRtcVideoFrame::Attach(uint8* buffer, size_t buffer_size, int w, int h,
@@ -95,7 +84,7 @@
pixel_width_ = pixel_width;
pixel_height_ = pixel_height;
elapsed_time_ = elapsed_time;
- video_frame_.SetTimeStamp(static_cast<WebRtc_UWord32>(time_stamp));
+ time_stamp_ = time_stamp;
rotation_ = rotation;
}
@@ -123,15 +112,18 @@
const uint8* WebRtcVideoFrame::GetUPlane() const {
WebRtc_UWord8* buffer = video_frame_.Buffer();
- if (buffer)
+ if (buffer) {
buffer += (video_frame_.Width() * video_frame_.Height());
+ }
return buffer;
}
const uint8* WebRtcVideoFrame::GetVPlane() const {
WebRtc_UWord8* buffer = video_frame_.Buffer();
- if (buffer)
- buffer += (video_frame_.Width() * video_frame_.Height() * 5 / 4);
+ if (buffer) {
+ int uv_size = GetChromaSize();
+ buffer += video_frame_.Width() * video_frame_.Height() + uv_size;
+ }
return buffer;
}
@@ -142,15 +134,18 @@
uint8* WebRtcVideoFrame::GetUPlane() {
WebRtc_UWord8* buffer = video_frame_.Buffer();
- if (buffer)
+ if (buffer) {
buffer += (video_frame_.Width() * video_frame_.Height());
+ }
return buffer;
}
uint8* WebRtcVideoFrame::GetVPlane() {
WebRtc_UWord8* buffer = video_frame_.Buffer();
- if (buffer)
- buffer += (video_frame_.Width() * video_frame_.Height() * 5 / 4);
+ if (buffer) {
+ int uv_size = GetChromaSize();
+ buffer += video_frame_.Width() * video_frame_.Height() + uv_size;
+ }
return buffer;
}
@@ -166,7 +161,7 @@
copy->Attach(new_buffer, new_buffer_size,
video_frame_.Width(), video_frame_.Height(),
pixel_width_, pixel_height_,
- elapsed_time_, video_frame_.TimeStamp(), rotation_);
+ elapsed_time_, time_stamp_, rotation_);
return copy;
}
@@ -188,91 +183,126 @@
return needed;
}
+// TODO: Refactor into base class and share with lmi
size_t WebRtcVideoFrame::ConvertToRgbBuffer(uint32 to_fourcc,
uint8* buffer,
size_t size,
- size_t pitch_rgb) const {
+ int stride_rgb) const {
if (!video_frame_.Buffer()) {
return 0;
}
-
size_t width = video_frame_.Width();
size_t height = video_frame_.Height();
- // See http://www.virtualdub.org/blog/pivot/entry.php?id=190 for a good
- // explanation of pitch and why this is the amount of space we need.
- size_t needed = pitch_rgb * (height - 1) + 4 * width;
-
- if (needed > size) {
+ size_t needed = (stride_rgb >= 0 ? stride_rgb : -stride_rgb) * height;
+ if (size < needed) {
LOG(LS_WARNING) << "RGB buffer is not large enough";
- return 0;
+ return needed;
}
- webrtc::VideoType to_type = webrtc::kUnknown;
- switch (to_fourcc) {
- case FOURCC_ARGB:
- to_type = webrtc::kARGB;
- break;
- default:
- LOG(LS_WARNING) << "RGB type not supported: " << to_fourcc;
- return 0;
- }
-
- if (to_type != webrtc::kUnknown) {
- webrtc::ConvertFromI420(to_type, video_frame_.Buffer(),
- width, height, buffer);
- }
-
- return needed;
-}
-
-void WebRtcVideoFrame::StretchToPlanes(
- uint8* y, uint8* u, uint8* v,
- int32 dst_pitch_y, int32 dst_pitch_u, int32 dst_pitch_v,
- size_t width, size_t height, bool interpolate, bool crop) const {
- // TODO: Implement StretchToPlanes
-}
-
-size_t WebRtcVideoFrame::StretchToBuffer(size_t w, size_t h,
- uint8* buffer, size_t size,
- bool interpolate,
- bool crop) const {
- if (!video_frame_.Buffer()) {
- return 0;
- }
-
- size_t needed = video_frame_.Length();
-
- if (needed <= size) {
- uint8* bufy = buffer;
- uint8* bufu = bufy + w * h;
- uint8* bufv = bufu + ((w + 1) >> 1) * ((h + 1) >> 1);
- StretchToPlanes(bufy, bufu, bufv, w, (w + 1) >> 1, (w + 1) >> 1, w, h,
- interpolate, crop);
+ if (libyuv::ConvertFromI420(GetYPlane(), GetYPitch(),
+ GetUPlane(), GetUPitch(),
+ GetVPlane(), GetVPitch(),
+ buffer, stride_rgb,
+ width, height,
+ to_fourcc)) {
+ LOG(LS_WARNING) << "RGB type not supported: " << to_fourcc;
+ return 0; // 0 indicates error
}
return needed;
}
-void WebRtcVideoFrame::StretchToFrame(VideoFrame* target,
- bool interpolate, bool crop) const {
- if (!target) return;
+// Add a square watermark near the left-low corner. clamp Y.
+// Returns false on error.
+bool WebRtcVideoFrame::AddWatermark() {
+ size_t w = GetWidth();
+ size_t h = GetHeight();
- StretchToPlanes(target->GetYPlane(),
- target->GetUPlane(),
- target->GetVPlane(),
- target->GetYPitch(),
- target->GetUPitch(),
- target->GetVPitch(),
- target->GetWidth(),
- target->GetHeight(),
- interpolate, crop);
- target->SetElapsedTime(GetElapsedTime());
- target->SetTimeStamp(GetTimeStamp());
+ if (w < kWatermarkWidth + kWatermarkOffsetFromLeft ||
+ h < kWatermarkHeight + kWatermarkOffsetFromBottom) {
+ return false;
+ }
+
+ uint8* buffer = GetYPlane();
+ for (size_t x = kWatermarkOffsetFromLeft;
+ x < kWatermarkOffsetFromLeft + kWatermarkWidth; ++x) {
+ for (size_t y = h - kWatermarkOffsetFromBottom - kWatermarkHeight;
+ y < h - kWatermarkOffsetFromBottom; ++y) {
+ buffer[y * w + x] = talk_base::_min(buffer[y * w + x],
+ kWatermarkMaxYValue);
+ }
+ }
+ return true;
}
-VideoFrame* WebRtcVideoFrame::Stretch(size_t w, size_t h,
- bool interpolate, bool crop) const {
- // TODO: implement
- return NULL;
+bool WebRtcVideoFrame::Reset(uint32 format, int w, int h, int dw, int dh,
+ uint8* sample, size_t sample_size,
+ size_t pixel_width, size_t pixel_height,
+ int64 elapsed_time, int64 time_stamp,
+ int rotation) {
+ // WebRtcVideoFrame currently doesn't support color conversion or rotation.
+ // TODO: Add horizontal cropping support.
+ if (format != FOURCC_I420 || dw != w || dh < 0 || dh > abs(h) ||
+ rotation != 0) {
+ return false;
+ }
+
+ // Discard the existing buffer.
+ uint8* old_buffer;
+ size_t old_buffer_size;
+ Detach(&old_buffer, &old_buffer_size);
+ delete[] old_buffer;
+
+ // Set up a new buffer.
+ size_t desired_size = SizeOf(dw, dh);
+ uint8* buffer = new uint8[desired_size];
+ Attach(buffer, desired_size, dw, dh, pixel_width, pixel_height,
+ elapsed_time, time_stamp, rotation);
+
+ if (dh == h) {
+ // Uncropped
+ memcpy(buffer, sample, desired_size);
+ } else {
+ // Cropped
+ // TODO: use I420Copy which supports horizontal crop and vertical
+ // flip.
+ int horiz_crop = ((w - dw) / 2) & ~1;
+ int vert_crop = ((abs(h) - dh) / 2) & ~1;
+ int y_crop_offset = w * vert_crop + horiz_crop;
+ int halfwidth = (w + 1) / 2;
+ int halfheight = (h + 1) / 2;
+ int uv_size = GetChromaSize();
+ int uv_crop_offset = (halfwidth * vert_crop + horiz_crop) / 2;
+ uint8* src_y = sample + y_crop_offset;
+ uint8* src_u = sample + w * h + uv_crop_offset;
+ uint8* src_v = sample + w * h + halfwidth * halfheight + uv_crop_offset;
+ memcpy(GetYPlane(), src_y, dw * dh);
+ memcpy(GetUPlane(), src_u, uv_size);
+ memcpy(GetVPlane(), src_v, uv_size);
+ }
+
+ return true;
+}
+
+VideoFrame* WebRtcVideoFrame::CreateEmptyFrame(int w, int h,
+ size_t pixel_width,
+ size_t pixel_height,
+ int64 elapsed_time,
+ int64 time_stamp) const {
+ WebRtcVideoFrame* frame = new WebRtcVideoFrame();
+ frame->InitToEmptyBuffer(w, h, pixel_width, pixel_height,
+ elapsed_time, time_stamp);
+ return frame;
+}
+
+void WebRtcVideoFrame::InitToEmptyBuffer(int w, int h,
+ size_t pixel_width,
+ size_t pixel_height,
+ int64 elapsed_time,
+ int64 time_stamp) {
+ size_t buffer_size = VideoFrame::SizeOf(w, h);
+ uint8* buffer = new uint8[buffer_size];
+ Attach(buffer, buffer_size, w, h, pixel_width, pixel_height,
+ elapsed_time, time_stamp, 0);
}
} // namespace cricket
diff --git a/talk/session/phone/webrtcvideoframe.h b/talk/session/phone/webrtcvideoframe.h
index 3431969..e041003 100644
--- a/talk/session/phone/webrtcvideoframe.h
+++ b/talk/session/phone/webrtcvideoframe.h
@@ -1,6 +1,6 @@
/*
* libjingle
- * Copyright 2004--2011, Google Inc.
+ * 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:
@@ -46,6 +46,10 @@
WebRtcVideoFrame();
~WebRtcVideoFrame();
+ // Creates a frame from a raw sample with FourCC "format" and size "w" x "h".
+ // "h" can be negative indicating a vertically flipped image.
+ // "dh" is destination height if cropping is desired and is always positive.
+ // Returns "true" if successful.
bool Init(uint32 format, int w, int h, int dw, int dh,
uint8* sample, size_t sample_size,
size_t pixel_width, size_t pixel_height,
@@ -60,8 +64,14 @@
size_t pixel_width, size_t pixel_height,
int64 elapsed_time, int64 time_stamp, int rotation);
void Detach(uint8** buffer, size_t* buffer_size);
+ bool AddWatermark();
+ webrtc::VideoFrame* frame() { return &video_frame_; }
- bool HasImage() const { return video_frame_.Buffer() != NULL; }
+ // From base class VideoFrame.
+ virtual bool Reset(uint32 format, int w, int h, int dw, int dh,
+ uint8* sample, size_t sample_size,
+ size_t pixel_width, size_t pixel_height,
+ int64 elapsed_time, int64 time_stamp, int rotation);
virtual size_t GetWidth() const;
virtual size_t GetHeight() const;
@@ -72,18 +82,18 @@
virtual uint8* GetUPlane();
virtual uint8* GetVPlane();
virtual int32 GetYPitch() const { return video_frame_.Width(); }
- virtual int32 GetUPitch() const { return video_frame_.Width() / 2; }
- virtual int32 GetVPitch() const { return video_frame_.Width() / 2; }
+ virtual int32 GetUPitch() const { return (video_frame_.Width() + 1) / 2; }
+ virtual int32 GetVPitch() const { return (video_frame_.Width() + 1) / 2; }
virtual size_t GetPixelWidth() const { return pixel_width_; }
virtual size_t GetPixelHeight() const { return pixel_height_; }
virtual int64 GetElapsedTime() const { return elapsed_time_; }
- virtual int64 GetTimeStamp() const { return video_frame_.TimeStamp(); }
+ virtual int64 GetTimeStamp() const { return time_stamp_; }
virtual void SetElapsedTime(int64 elapsed_time) {
elapsed_time_ = elapsed_time;
}
virtual void SetTimeStamp(int64 time_stamp) {
- video_frame_.SetTimeStamp(static_cast<WebRtc_UWord32>(time_stamp));
+ time_stamp_ = time_stamp;
}
virtual int GetRotation() const { return rotation_; }
@@ -92,23 +102,22 @@
virtual bool MakeExclusive();
virtual size_t CopyToBuffer(uint8* buffer, size_t size) const;
virtual size_t ConvertToRgbBuffer(uint32 to_fourcc, uint8* buffer,
- size_t size, size_t pitch_rgb) const;
- virtual void StretchToPlanes(uint8* y, uint8* u, uint8* v,
- int32 pitchY, int32 pitchU, int32 pitchV,
- size_t width, size_t height,
- bool interpolate, bool crop) const;
- virtual size_t StretchToBuffer(size_t w, size_t h, uint8* buffer, size_t size,
- bool interpolate, bool crop) const;
- virtual void StretchToFrame(VideoFrame* target, bool interpolate,
- bool crop) const;
- virtual VideoFrame* Stretch(size_t w, size_t h, bool interpolate,
- bool crop) const;
+ size_t size, int stride_rgb) const;
private:
+ virtual VideoFrame* CreateEmptyFrame(int w, int h,
+ size_t pixel_width, size_t pixel_height,
+ int64 elapsed_time,
+ int64 time_stamp) const;
+ void InitToEmptyBuffer(int w, int h,
+ size_t pixel_width, size_t pixel_height,
+ int64 elapsed_time, int64 time_stamp);
+
webrtc::VideoFrame video_frame_;
size_t pixel_width_;
size_t pixel_height_;
int64 elapsed_time_;
+ int64 time_stamp_;
int rotation_;
};
} // namespace cricket
diff --git a/talk/session/phone/webrtcvideoframe_unittest.cc b/talk/session/phone/webrtcvideoframe_unittest.cc
index cd1f033..16e5e16 100644
--- a/talk/session/phone/webrtcvideoframe_unittest.cc
+++ b/talk/session/phone/webrtcvideoframe_unittest.cc
@@ -1,439 +1,201 @@
-// Copyright 2008 Google Inc. All Rights Reserved,
-//
-// Author: Justin Uberti (juberti@google.com)
-// Frank Barchard (fbarchard@google.com)
-#include <string>
+/*
+ * 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/base/flags.h"
-#include "talk/base/gunit.h"
-#include "talk/base/pathutils.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stream.h"
-#include "talk/base/stringutils.h"
-#include "talk/session/phone/formatconversion.h"
+#include "talk/session/phone/videoframe_unittest.h"
#include "talk/session/phone/webrtcvideoframe.h"
-#include "talk/session/phone/testutils.h"
-#include "talk/session/phone/videocommon.h"
-enum {
- ROTATION_0 = 0,
- ROTATION_90 = 90,
- ROTATION_180 = 180,
- ROTATION_270 = 270
-};
+extern int FLAG_yuvconverter_repeat; // from lmivideoframe_unittest.cc
-using cricket::WebRtcVideoFrame;
-using cricket::FOURCC_I420;
-
-static const int kWidth = 1280;
-static const int kHeight = 720;
-static const int kAlignment = 16;
-static const std::string kImageFilename = "faces.1280x720_P420.yuv";
-
-class WebRtcVideoFrameTest : public testing::Test {
- protected:
- virtual void SetUp() {
- // TODO: Fix (add a new flag) or remove repeat_.
- repeat_ = 1;
- }
-
+class WebRtcVideoFrameTest : public VideoFrameTest<cricket::WebRtcVideoFrame> {
public:
- // Load a video frame from disk or a buffer.
- bool LoadFrame(const std::string& filename, uint32 format,
- int32 width, int32 height, WebRtcVideoFrame* frame,
- int rotation) {
- talk_base::scoped_ptr<talk_base::MemoryStream> ms(LoadSample(filename));
- return LoadFrame(ms.get(), format, width, height, frame, rotation);
+ WebRtcVideoFrameTest() {
+ repeat_ = FLAG_yuvconverter_repeat;
}
-
- bool LoadFrame(talk_base::MemoryStream* ms, uint32 format,
- int32 width, int32 height, WebRtcVideoFrame* frame,
- int rotation) {
- if (!ms) {
- return false;
- }
- size_t data_size;
- bool ret = ms->GetSize(&data_size);
- EXPECT_TRUE(ret);
- if (ret) {
- ret = LoadFrame(reinterpret_cast<uint8*>(ms->GetBuffer()), data_size,
- format, width, height, frame, rotation);
- }
- return ret;
- }
-
- bool LoadFrame(uint8* sample, size_t sample_size, uint32 format,
- int32 width, int32 height, WebRtcVideoFrame* frame,
- int rotation) {
- for (int i = 0; i < repeat_; ++i) {
- if (!frame->Init(format, width, height, width, height,
- sample, sample_size, 1, 1, 0, 0, 0)) {
- return false;
- }
- }
- return true;
- }
-
- talk_base::MemoryStream* LoadSample(const std::string& filename) {
- talk_base::Pathname path(cricket::GetTestFilePath(filename));
- talk_base::scoped_ptr<talk_base::FileStream> fs(
- talk_base::Filesystem::OpenFile(path, "rb"));
- if (!fs.get()) {
- return NULL;
- }
-
- char buf[4096];
- talk_base::scoped_ptr<talk_base::MemoryStream> ms(
- new talk_base::MemoryStream());
- talk_base::StreamResult res = Flow(fs.get(), buf, sizeof(buf), ms.get());
- if (res != talk_base::SR_SUCCESS) {
- return NULL;
- }
-
- return ms.release();
- }
-
- // Write an I420 frame out to disk.
- bool DumpFrame(const std::string& prefix,
- const WebRtcVideoFrame& frame) {
- char filename[256];
- talk_base::sprintfn(filename, sizeof(filename), "%s.%dx%d_P420.yuv",
- prefix.c_str(), frame.GetWidth(), frame.GetHeight());
- size_t out_size = cricket::VideoFrame::SizeOf(frame.GetWidth(),
- frame.GetHeight());
- talk_base::scoped_array<uint8> out(new uint8[out_size]);
- frame.CopyToBuffer(out.get(), out_size);
- return DumpSample(filename, out.get(), out_size);
- }
-
- bool DumpSample(const std::string& filename, const void* buffer, int size) {
- talk_base::Pathname path(filename);
- talk_base::scoped_ptr<talk_base::FileStream> fs(
- talk_base::Filesystem::OpenFile(path, "wb"));
- if (!fs.get()) {
- return false;
- }
-
- return (fs->Write(buffer, size, NULL, NULL) == talk_base::SR_SUCCESS);
- }
-
- // Create a test image for YUV 420 formats with 12 bits per pixel.
- talk_base::MemoryStream* CreateYuv420Sample(uint32 width, uint32 height) {
- talk_base::scoped_ptr<talk_base::MemoryStream> ms(
- new talk_base::MemoryStream);
- if (!ms->ReserveSize(width * height * 12 / 8)) {
- return NULL;
- }
-
- for (uint32 i = 0; i < width * height * 12 / 8; ++i) {
- char value = ((i / 63) & 1) ? 192 : 64;
- ms->Write(&value, sizeof(value), NULL, NULL);
- }
- return ms.release();
- }
-
- talk_base::MemoryStream* CreateRgbSample(uint32 fourcc,
- uint32 width, uint32 height) {
- int r_pos, g_pos, b_pos, bytes;
- if (!GetRgbPacking(fourcc, &r_pos, &g_pos, &b_pos, &bytes)) {
- return NULL;
- }
-
- talk_base::scoped_ptr<talk_base::MemoryStream> ms(
- new talk_base::MemoryStream);
- if (!ms->ReserveSize(width * height * bytes)) {
- return NULL;
- }
-
- for (uint32 y = 0; y < height; ++y) {
- for (uint32 x = 0; x < width; ++x) {
- uint8 rgb[4] = { 255, 255, 255, 255 };
- rgb[r_pos] = ((x / 63) & 1) ? 224 : 32;
- rgb[g_pos] = (x % 63 + y % 63) + 96;
- rgb[b_pos] = ((y / 63) & 1) ? 224 : 32;
- ms->Write(rgb, bytes, NULL, NULL);
- }
- }
- return ms.release();
- }
-
- // Convert RGB to 420.
- // A negative height inverts the image.
- bool ConvertRgb(const talk_base::MemoryStream* ms,
- uint32 fourcc, int32 width, int32 height,
- WebRtcVideoFrame* frame) {
- int r_pos, g_pos, b_pos, bytes;
- if (!GetRgbPacking(fourcc, &r_pos, &g_pos, &b_pos, &bytes)) {
- return false;
- }
- int stride = width * bytes;
- const uint8* start = reinterpret_cast<const uint8*>(ms->GetBuffer());
- if (height < 0) {
- height = -height;
- start = start + stride * (height - 1);
- stride = -stride;
- }
- frame->InitToBlack(width, height, 1, 1, 0, 0);
- for (int32 y = 0; y < height; y += 2) {
- for (int32 x = 0; x < width; x += 2) {
- const uint8* rgb[4];
- uint8 yuv[4][3];
- rgb[0] = start + y * stride + x * bytes;
- rgb[1] = rgb[0] + bytes;
- rgb[2] = rgb[0] + stride;
- rgb[3] = rgb[2] + bytes;
- for (size_t i = 0; i < 4; ++i) {
- ConvertRgbPixel(rgb[i][r_pos], rgb[i][g_pos], rgb[i][b_pos],
- &yuv[i][0], &yuv[i][1], &yuv[i][2]);
- }
- frame->GetYPlane()[width * y + x] = yuv[0][0];
- frame->GetYPlane()[width * y + x + 1] = yuv[1][0];
- frame->GetYPlane()[width * (y + 1) + x] = yuv[2][0];
- frame->GetYPlane()[width * (y + 1) + x + 1] = yuv[3][0];
- frame->GetUPlane()[width / 2 * (y / 2) + x / 2] =
- (yuv[0][1] + yuv[1][1] + yuv[2][1] + yuv[3][1] + 2) / 4;
- frame->GetVPlane()[width / 2 * (y / 2) + x / 2] =
- (yuv[0][2] + yuv[1][2] + yuv[2][2] + yuv[3][2] + 2) / 4;
- }
- }
- return true;
- }
-
- // Simple and slow RGB->YUV conversion. From NTSC standard, c/o Wikipedia.
- void ConvertRgbPixel(uint8 r, uint8 g, uint8 b,
- uint8* y, uint8* u, uint8* v) {
- *y = static_cast<int>(.257 * r + .504 * g + .098 * b) + 16;
- *u = static_cast<int>(-.148 * r - .291 * g + .439 * b) + 128;
- *v = static_cast<int>(.439 * r - .368 * g - .071 * b) + 128;
- }
-
- bool GetRgbPacking(uint32 fourcc,
- int* r_pos, int* g_pos, int* b_pos, int* bytes) {
- if (fourcc == cricket::FOURCC_RAW) {
- *r_pos = 0;
- *g_pos = 1;
- *b_pos = 2;
- *bytes = 3; // RGB in memory
- } else if (fourcc == cricket::FOURCC_24BG) {
- *r_pos = 2;
- *g_pos = 1;
- *b_pos = 0;
- *bytes = 3; // BGR in memory
- } else if (fourcc == cricket::FOURCC_ABGR) {
- *r_pos = 0;
- *g_pos = 1;
- *b_pos = 2;
- *bytes = 4; // RGBA in memory
- } else if (fourcc == cricket::FOURCC_BGRA) {
- *r_pos = 1;
- *g_pos = 2;
- *b_pos = 3;
- *bytes = 4; // ARGB in memory
- } else if (fourcc == cricket::FOURCC_ARGB) {
- *r_pos = 2;
- *g_pos = 1;
- *b_pos = 0;
- *bytes = 4; // BGRA in memory
- } else {
- return false;
- }
- return true;
- }
-
- // Comparison functions for testing.
- static bool IsNull(const WebRtcVideoFrame& frame) {
- return !frame.HasImage();
- }
-
- static bool IsSize(const WebRtcVideoFrame& frame,
- uint32 width, uint32 height) {
- return frame.HasImage() &&
- frame.GetYPitch() >= static_cast<int32>(width) &&
- frame.GetUPitch() >= static_cast<int32>(width) / 2 &&
- frame.GetVPitch() >= static_cast<int32>(width) / 2 &&
- frame.GetWidth() == width && frame.GetHeight() == height;
- }
-
- static bool IsPlaneEqual(const std::string& name,
- const uint8* plane1, uint32 pitch1,
- const uint8* plane2, uint32 pitch2,
- uint32 width, uint32 height,
- int max_error) {
- const uint8* r1 = plane1;
- const uint8* r2 = plane2;
- for (uint32 y = 0; y < height; ++y) {
- for (uint32 x = 0; x < width; ++x) {
- if (abs(static_cast<int>(r1[x] - r2[x])) > max_error) {
- LOG(LS_INFO) << "IsPlaneEqual(" << name << "): pixel["
- << x << "," << y << "] differs: "
- << static_cast<int>(r1[x]) << " vs "
- << static_cast<int>(r2[x]);
- return false;
- }
- }
- r1 += pitch1;
- r2 += pitch2;
- }
- return true;
- }
-
- static bool IsFrameContiguous(const WebRtcVideoFrame& frame) {
- int width = frame.GetWidth();
- int height = frame.GetHeight();
- const uint8* y = frame.GetYPlane();
- const uint8* u = frame.GetUPlane();
- const uint8* v = frame.GetVPlane();
- int size = width * height * 3 / 2;
- bool u_near = (u - y) < size;
- bool v_near = (v - y) < size;
- return u_near && v_near;
- }
-
- static bool IsEqual(const WebRtcVideoFrame& frame,
- size_t width, size_t height,
- size_t pixel_width, size_t pixel_height,
- int64 elapsed_time, int64 time_stamp,
- const uint8* y, uint32 ypitch,
- const uint8* u, uint32 upitch,
- const uint8* v, uint32 vpitch,
- int max_error) {
- if (!IsFrameContiguous(frame)) {
- LOG(LS_INFO) << "lmi frame is not contiguous";
- }
- return IsSize(frame, width, height) &&
- frame.GetPixelWidth() == pixel_width &&
- frame.GetPixelHeight() == pixel_height &&
- frame.GetElapsedTime() == elapsed_time &&
- frame.GetTimeStamp() == time_stamp &&
- IsPlaneEqual("y", frame.GetYPlane(), frame.GetYPitch(), y, ypitch,
- width, height, max_error) &&
- IsPlaneEqual("u", frame.GetUPlane(), frame.GetUPitch(), u, upitch,
- width / 2, height / 2, max_error) &&
- IsPlaneEqual("v", frame.GetVPlane(), frame.GetVPitch(), v, vpitch,
- width / 2, height / 2, max_error);
- }
-
- static bool IsEqual(const WebRtcVideoFrame& frame1,
- const WebRtcVideoFrame& frame2,
- int max_error) {
- return IsEqual(frame1, frame2.GetWidth(), frame2.GetHeight(),
- frame2.GetPixelWidth(), frame2.GetPixelHeight(),
- frame2.GetElapsedTime(), frame2.GetTimeStamp(),
- frame2.GetYPlane(), frame2.GetYPitch(),
- frame2.GetUPlane(), frame2.GetUPitch(),
- frame2.GetVPlane(), frame2.GetVPitch(),
- max_error);
- }
-
- protected:
- int repeat_;
};
-TEST_F(WebRtcVideoFrameTest, ConvertToARGBBuffer) {
- size_t out_size = kWidth * kHeight * 4;
- talk_base::scoped_array<uint8> outbuf(new uint8[out_size + kAlignment]);
- uint8 *out = ALIGNP(outbuf.get(), kAlignment);
- WebRtcVideoFrame frame;
- ASSERT_TRUE(LoadFrame(kImageFilename, FOURCC_I420, kWidth, kHeight,
- &frame, ROTATION_0));
-
- // TODO: Add test to convert these back to I420, to ensure the
- // conversion is done correctly.
- for (int i = 0; i < repeat_; ++i) {
- EXPECT_EQ(out_size, frame.ConvertToRgbBuffer(cricket::FOURCC_ARGB,
- out,
- out_size, kWidth * 4));
- }
+#define TEST_WEBRTCVIDEOFRAME(X) TEST_F(WebRtcVideoFrameTest, X) { \
+ VideoFrameTest<cricket::WebRtcVideoFrame>::X(); \
}
-// Test basic contruction of an image from an I420 buffer.
-TEST_F(WebRtcVideoFrameTest, InitI420) {
- WebRtcVideoFrame frame;
- EXPECT_TRUE(IsNull(frame));
- talk_base::scoped_ptr<talk_base::MemoryStream> ms(LoadSample(kImageFilename));
- ASSERT_TRUE(ms.get() != NULL);
- size_t data_size;
- ASSERT_TRUE(ms->GetSize(&data_size));
- uint8* buf = reinterpret_cast<uint8*>(ms->GetBuffer());
- EXPECT_TRUE(LoadFrame(buf, data_size, FOURCC_I420,
- kWidth, kHeight, &frame, ROTATION_0));
+TEST_WEBRTCVIDEOFRAME(ConstructI420)
+TEST_WEBRTCVIDEOFRAME(ConstructI4201Pixel)
+// TODO: WebRtcVideoFrame does not support horizontal crop.
+// Re-evaluate once it supports 3 independent planes, since we might want to
+// just Init normally and then crop by adjusting pointers.
+// TEST_WEBRTCVIDEOFRAME(ConstructI420CropHorizontal)
+TEST_WEBRTCVIDEOFRAME(ConstructI420CropVertical)
+// TODO: WebRtcVideoFrame is not currently refcounted.
+// TEST_WEBRTCVIDEOFRAME(ConstructCopy)
+// TEST_WEBRTCVIDEOFRAME(ConstructCopyIsRef)
+TEST_WEBRTCVIDEOFRAME(ConstructBlack)
+// TODO: Implement Jpeg
+// TEST_WEBRTCVIDEOFRAME(ConstructMjpgI420)
+// TEST_WEBRTCVIDEOFRAME(ConstructMjpgI422)
+// TEST_WEBRTCVIDEOFRAME(ConstructMjpgI444)
+// TEST_WEBRTCVIDEOFRAME(ConstructMjpgI400)
+// TODO: WebRtcVideoFrame does not support odd sizes.
+// Re-evaluate once WebRTC switches to libyuv
+// TEST_WEBRTCVIDEOFRAME(ConstructYuy2AllSizes)
+TEST_WEBRTCVIDEOFRAME(Reset)
+TEST_WEBRTCVIDEOFRAME(ConvertToABGRBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToABGRBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertToABGRBufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertToARGB1555Buffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToARGB1555BufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertToARGB1555BufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertToARGB4444Buffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToARGB4444BufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertToARGB4444BufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertToARGBBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToARGBBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertToARGBBufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertToBGRABuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToBGRABufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertToBGRABufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertToRAWBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToRAWBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertToRAWBufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertToRGB24Buffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToRGB24BufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertToRGB24BufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertToRGB565Buffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToRGB565BufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertToRGB565BufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertToBayerBGGRBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToBayerBGGRBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertToBayerBGGRBufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertToBayerGRBGBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToBayerGRBGBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertToBayerGRBGBufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertToBayerGBRGBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToBayerGBRGBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertToBayerGBRGBufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertToBayerRGGBBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToBayerRGGBBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertToBayerRGGBBufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertToI400Buffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToI400BufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertToI400BufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertToYUY2Buffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToYUY2BufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertToYUY2BufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertToUYVYBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToUYVYBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertToUYVYBufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertFromABGRBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertFromABGRBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertFromABGRBufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertFromARGB1555Buffer)
+TEST_WEBRTCVIDEOFRAME(ConvertFromARGB1555BufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertFromARGB1555BufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertFromARGB4444Buffer)
+TEST_WEBRTCVIDEOFRAME(ConvertFromARGB4444BufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertFromARGB4444BufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertFromARGBBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertFromARGBBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertFromARGBBufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertFromBGRABuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertFromBGRABufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertFromBGRABufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertFromRAWBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertFromRAWBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertFromRAWBufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertFromRGB24Buffer)
+TEST_WEBRTCVIDEOFRAME(ConvertFromRGB24BufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertFromRGB24BufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertFromRGB565Buffer)
+TEST_WEBRTCVIDEOFRAME(ConvertFromRGB565BufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertFromRGB565BufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertFromBayerBGGRBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertFromBayerBGGRBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertFromBayerBGGRBufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertFromBayerGRBGBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertFromBayerGRBGBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertFromBayerGRBGBufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertFromBayerGBRGBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertFromBayerGBRGBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertFromBayerGBRGBufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertFromBayerRGGBBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertFromBayerRGGBBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertFromBayerRGGBBufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertFromI400Buffer)
+TEST_WEBRTCVIDEOFRAME(ConvertFromI400BufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertFromI400BufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertFromYUY2Buffer)
+TEST_WEBRTCVIDEOFRAME(ConvertFromYUY2BufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertFromYUY2BufferInverted)
+TEST_WEBRTCVIDEOFRAME(ConvertFromUYVYBuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertFromUYVYBufferStride)
+TEST_WEBRTCVIDEOFRAME(ConvertFromUYVYBufferInverted)
+//TEST_WEBRTCVIDEOFRAME(ConvertToI422Buffer)
+TEST_WEBRTCVIDEOFRAME(ConvertARGBToBayerGRBG)
+TEST_WEBRTCVIDEOFRAME(ConvertARGBToBayerGBRG)
+TEST_WEBRTCVIDEOFRAME(ConvertARGBToBayerBGGR)
+TEST_WEBRTCVIDEOFRAME(ConvertARGBToBayerRGGB)
+TEST_WEBRTCVIDEOFRAME(CopyToBuffer)
+TEST_WEBRTCVIDEOFRAME(CopyToBuffer1Pixel)
+//TEST_WEBRTCVIDEOFRAME(ConstructARGBBlackWhitePixel)
- const uint8* y = reinterpret_cast<uint8*>(ms->GetBuffer());
- const uint8* u = y + kWidth * kHeight;
- const uint8* v = u + kWidth * kHeight / 4;
- EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 1, 1, 0, 0,
- y, kWidth, u, kWidth / 2, v, kWidth / 2, 0));
+TEST_WEBRTCVIDEOFRAME(StretchToFrame)
+TEST_WEBRTCVIDEOFRAME(Copy)
+// TODO: WebRtcVideoFrame is not currently refcounted.
+// TEST_WEBRTCVIDEOFRAME(CopyIsRef)
+TEST_WEBRTCVIDEOFRAME(MakeExclusive)
+
+// These functions test implementation-specific details.
+TEST_F(WebRtcVideoFrameTest, AttachAndRelease) {
+ cricket::WebRtcVideoFrame frame1, frame2;
+ ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
+ const int64 time_stamp = 0x7FFFFFFFFFFFFFF0LL;
+ frame1.SetTimeStamp(time_stamp);
+ EXPECT_EQ(time_stamp, frame1.GetTimeStamp());
+ frame2.Attach(frame1.frame()->Buffer(), frame1.frame()->Size(),
+ kWidth, kHeight, 1, 1,
+ frame1.GetElapsedTime(), frame1.GetTimeStamp(), 0);
+ EXPECT_TRUE(IsEqual(frame1, frame2, 0));
+ uint8* buffer;
+ size_t size;
+ frame2.Detach(&buffer, &size);
+ EXPECT_EQ(frame1.frame()->Buffer(), buffer);
+ EXPECT_EQ(frame1.frame()->Size(), size);
+ EXPECT_TRUE(IsNull(frame2));
+ EXPECT_TRUE(IsSize(frame1, kWidth, kHeight));
}
-// Test constructing an image from a I420 buffer
-TEST_F(WebRtcVideoFrameTest, ConstructI420) {
- WebRtcVideoFrame frame;
- talk_base::scoped_ptr<talk_base::MemoryStream> ms(
- CreateYuv420Sample(kWidth, kHeight));
- EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_I420,
- kWidth, kHeight, &frame, ROTATION_0));
-
- const uint8* y = reinterpret_cast<uint8*>(ms.get()->GetBuffer());
- const uint8* u = y + kWidth * kHeight;
- const uint8* v = u + kWidth * kHeight / 4;
- EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 1, 1, 0, 0,
- y, kWidth, u, kWidth / 2, v, kWidth / 2, 0));
+TEST_F(WebRtcVideoFrameTest, Transfer) {
+ cricket::WebRtcVideoFrame frame1, frame2;
+ ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
+ uint8* buffer;
+ size_t size;
+ frame1.Detach(&buffer, &size),
+ frame2.Attach(buffer, size, kWidth, kHeight, 1, 1,
+ frame1.GetElapsedTime(), frame1.GetTimeStamp(), 0);
+ EXPECT_TRUE(IsNull(frame1));
+ EXPECT_TRUE(IsSize(frame2, kWidth, kHeight));
}
-// Test creating an empty image and initing it to black.
-TEST_F(WebRtcVideoFrameTest, ConstructBlack) {
- WebRtcVideoFrame frame;
- for (int i = 0; i < repeat_; ++i) {
- EXPECT_TRUE(frame.InitToBlack(kWidth, kHeight, 1, 1, 0, 0));
- }
- EXPECT_TRUE(IsSize(frame, kWidth, kHeight));
- EXPECT_EQ(16, *frame.GetYPlane());
- EXPECT_EQ(128, *frame.GetUPlane());
- EXPECT_EQ(128, *frame.GetVPlane());
-}
-
-TEST_F(WebRtcVideoFrameTest, Copy) {
- WebRtcVideoFrame frame1;
- talk_base::scoped_ptr<cricket::WebRtcVideoFrame> frame2;
- ASSERT_TRUE(LoadFrame(kImageFilename, FOURCC_I420, kWidth, kHeight,
- &frame1, ROTATION_0));
- frame2.reset(static_cast<WebRtcVideoFrame*>(frame1.Copy()));
- EXPECT_TRUE(IsEqual(frame1, *frame2.get(), 0));
-}
-
-TEST_F(WebRtcVideoFrameTest, CopyToBuffer) {
- size_t out_size = kWidth * kHeight * 3 / 2;
- talk_base::scoped_array<uint8> out(new uint8[out_size]);
- WebRtcVideoFrame frame;
- talk_base::scoped_ptr<talk_base::MemoryStream> ms(LoadSample(kImageFilename));
- ASSERT_TRUE(ms.get() != NULL);
- size_t data_size;
- ASSERT_TRUE(ms->GetSize(&data_size));
- EXPECT_TRUE(LoadFrame(reinterpret_cast<uint8*>(ms->GetBuffer()),
- data_size, FOURCC_I420,
- kWidth, kHeight, &frame, ROTATION_0));
- for (int i = 0; i < repeat_; ++i) {
- EXPECT_EQ(out_size, frame.CopyToBuffer(out.get(), out_size));
- }
- EXPECT_EQ(0, memcmp(out.get(), ms->GetBuffer(), out_size));
-}
-
-TEST_F(WebRtcVideoFrameTest, CopyToBuffer1Pixel) {
- size_t out_size = 3;
- talk_base::scoped_array<uint8> out(new uint8[out_size + 1]);
- memset(out.get(), 0xfb, out_size + 1); // Fill buffer
- uint8 pixel[3] = { 1, 2, 3 };
- WebRtcVideoFrame frame;
- EXPECT_TRUE(LoadFrame(pixel, sizeof(pixel), FOURCC_I420,
- 1, 1, &frame, ROTATION_0));
- for (int i = 0; i < repeat_; ++i) {
- EXPECT_EQ(out_size, frame.CopyToBuffer(out.get(), out_size));
- }
- EXPECT_EQ(1, out.get()[0]); // Check Y. Should be 1.
- EXPECT_EQ(2, out.get()[1]); // Check U. Should be 2.
- EXPECT_EQ(3, out.get()[2]); // Check V. Should be 3.
- EXPECT_EQ(0xfb, out.get()[3]); // Check sentinel is still intact.
-}
-
-// TODO: Merge this with the LmiVideoFrame test for more test cases
-// when they are supported.
diff --git a/talk/session/phone/webrtcvie.h b/talk/session/phone/webrtcvie.h
index d6ef007..75fe837 100644
--- a/talk/session/phone/webrtcvie.h
+++ b/talk/session/phone/webrtcvie.h
@@ -37,14 +37,14 @@
#include "modules/interface/module_common_types.h"
#include "modules/video_capture/main/interface/video_capture.h"
#include "modules/video_render/main/interface/video_render.h"
-#include "video_engine/main/interface/vie_base.h"
-#include "video_engine/main/interface/vie_capture.h"
-#include "video_engine/main/interface/vie_codec.h"
-#include "video_engine/main/interface/vie_errors.h"
-#include "video_engine/main/interface/vie_image_process.h"
-#include "video_engine/main/interface/vie_network.h"
-#include "video_engine/main/interface/vie_render.h"
-#include "video_engine/main/interface/vie_rtp_rtcp.h"
+#include "video_engine/include/vie_base.h"
+#include "video_engine/include/vie_capture.h"
+#include "video_engine/include/vie_codec.h"
+#include "video_engine/include/vie_errors.h"
+#include "video_engine/include/vie_image_process.h"
+#include "video_engine/include/vie_network.h"
+#include "video_engine/include/vie_render.h"
+#include "video_engine/include/vie_rtp_rtcp.h"
#else
#include "third_party/webrtc/files/include/common_types.h"
#include "third_party/webrtc/files/include/module_common_types.h"
@@ -126,7 +126,7 @@
webrtc::ViENetwork* network() { return network_.get(); }
webrtc::ViERender* render() { return render_.get(); }
webrtc::ViERTP_RTCP* rtp() { return rtp_.get(); }
- webrtc::ViEImageProcess* sync() { return image_.get(); }
+ webrtc::ViEImageProcess* image() { return image_.get(); }
int error() { return base_->LastError(); }
private:
@@ -139,6 +139,23 @@
scoped_vie_ptr<webrtc::ViERTP_RTCP> rtp_;
scoped_vie_ptr<webrtc::ViEImageProcess> image_;
};
-}
+
+// Adds indirection to static WebRtc functions, allowing them to be mocked.
+class ViETraceWrapper {
+ public:
+ virtual ~ViETraceWrapper() {}
+
+ virtual int SetTraceFilter(const unsigned int filter) {
+ return webrtc::VideoEngine::SetTraceFilter(filter);
+ }
+ virtual int SetTraceFile(const char* fileNameUTF8) {
+ return webrtc::VideoEngine::SetTraceFile(fileNameUTF8);
+ }
+ virtual int SetTraceCallback(webrtc::TraceCallback* callback) {
+ return webrtc::VideoEngine::SetTraceCallback(callback);
+ }
+};
+
+} // namespace cricket
#endif // TALK_SESSION_PHONE_WEBRTCVIE_H_
diff --git a/talk/session/phone/webrtcvoe.h b/talk/session/phone/webrtcvoe.h
index 398928e..709b3d6 100644
--- a/talk/session/phone/webrtcvoe.h
+++ b/talk/session/phone/webrtcvoe.h
@@ -191,6 +191,7 @@
return webrtc::VoiceEngine::SetTraceCallback(callback);
}
};
-}
+
+} // namespace cricket
#endif // TALK_SESSION_PHONE_WEBRTCVOE_H_
diff --git a/talk/session/phone/webrtcvoiceengine.cc b/talk/session/phone/webrtcvoiceengine.cc
index 3dfad11..98a1b85 100644
--- a/talk/session/phone/webrtcvoiceengine.cc
+++ b/talk/session/phone/webrtcvoiceengine.cc
@@ -25,6 +25,9 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
#ifdef HAVE_WEBRTC_VOICE
@@ -42,6 +45,8 @@
#include "talk/base/logging.h"
#include "talk/base/stringencode.h"
#include "talk/base/stringutils.h"
+#include "talk/session/phone/streamparams.h"
+#include "talk/session/phone/voiceprocessor.h"
#include "talk/session/phone/webrtcvoe.h"
#ifdef WIN32
@@ -301,6 +306,10 @@
adm_sc_ = NULL;
}
+ // Test to see if the media processor was deregistered properly
+ ASSERT(SignalRxMediaFrame.is_empty());
+ ASSERT(SignalTxMediaFrame.is_empty());
+
tracing_->SetTraceCallback(NULL);
}
@@ -373,17 +382,23 @@
// First check whether there is a valid sound device for playback.
// TODO: Clean this up when we support setting the soundclip device.
#ifdef WIN32
- int num_of_devices = 0;
- if (voe_wrapper_sc_->hw()->GetNumOfPlayoutDevices(num_of_devices) != -1 &&
- num_of_devices > 0) {
- if (voe_wrapper_sc_->hw()->SetPlayoutDevice(kDefaultSoundclipDeviceId)
- == -1) {
- LOG_RTCERR1_EX(SetPlayoutDevice, kDefaultSoundclipDeviceId,
- voe_wrapper_sc_->error());
- return false;
+ // The SetPlayoutDevice may not be implemented in the case of external ADM.
+ // TODO: We should only check the adm_sc_ here, but current
+ // PeerConnection interface never set the adm_sc_, so need to check both
+ // in order to determine if the external adm is used.
+ if (!adm_ && !adm_sc_) {
+ int num_of_devices = 0;
+ if (voe_wrapper_sc_->hw()->GetNumOfPlayoutDevices(num_of_devices) != -1 &&
+ num_of_devices > 0) {
+ if (voe_wrapper_sc_->hw()->SetPlayoutDevice(kDefaultSoundclipDeviceId)
+ == -1) {
+ LOG_RTCERR1_EX(SetPlayoutDevice, kDefaultSoundclipDeviceId,
+ voe_wrapper_sc_->error());
+ return false;
+ }
+ } else {
+ LOG(LS_WARNING) << "No valid sound playout device found.";
}
- } else {
- LOG(LS_WARNING) << "No valid sound playout device found.";
}
#endif
@@ -438,6 +453,12 @@
LOG_RTCERR1(SetEcStatus, aec);
return false;
}
+ if (aec) {
+ if (voe_wrapper_->processing()->SetEcMetricsStatus(true) == -1) {
+ LOG_RTCERR1(SetEcMetricsStatus, true);
+ return false;
+ }
+ }
if (voe_wrapper_->processing()->SetAgcStatus(agc) == -1) {
LOG_RTCERR1(SetAgcStatus, agc);
@@ -480,7 +501,7 @@
}
// No typing detection support on iOS or Android.
-#endif // !IOS && !ANDROID
+#endif // !IOS && !ANDROID
return true;
}
@@ -825,15 +846,16 @@
// Ignore spammy trace messages, mostly from the stats API when we haven't
// gotten RTCP info yet from the remote side.
-static bool ShouldIgnoreTrace(const std::string& trace) {
+bool WebRtcVoiceEngine::ShouldIgnoreTrace(const std::string& trace) {
static const char* kTracesToIgnore[] = {
"\tfailed to GetReportBlockInformation",
"GetRecCodec() failed to get received codec",
- "GetRemoteRTCPData() failed to measure statistics dueto lack of received RTP and/or RTCP packets", // NOLINT
- "GetRemoteRTCPData() failed to retrieve sender info for remoteside",
- "GetRTPStatistics() failed to measure RTT since noRTP packets have been received yet", // NOLINT
+ "GetReceivedRtcpStatistics: Could not get received RTP statistics",
+ "GetRemoteRTCPData() failed to measure statistics due to lack of received RTP and/or RTCP packets", // NOLINT
+ "GetRemoteRTCPData() failed to retrieve sender info for remote side",
+ "GetRTPStatistics() failed to measure RTT since no RTP packets have been received yet", // NOLINT
"GetRTPStatistics() failed to read RTP statistics from the RTP/RTCP module",
- "GetRTPStatistics() failed to retrieve RTT fromthe RTP/RTCP module",
+ "GetRTPStatistics() failed to retrieve RTT from the RTP/RTCP module",
"webrtc::RTCPReceiver::SenderInfoReceived No received SR",
"StatisticsRTP() no statisitics availble",
NULL
@@ -865,7 +887,7 @@
} else {
std::string msg(trace + 71, length - 72);
if (!ShouldIgnoreTrace(msg)) {
- LOG_V(sev) << "WebRtc VoE:" << msg;
+ LOG_V(sev) << "WebRtc:" << msg;
}
}
}
@@ -877,13 +899,13 @@
WebRtcVoiceMediaChannel* channel = NULL;
uint32 ssrc = 0;
LOG(LS_WARNING) << "VoiceEngine error " << err_code << " reported on channel "
- << channel_num << ".";
+ << channel_num << ".";
if (FindChannelAndSsrc(channel_num, &channel, &ssrc)) {
ASSERT(channel != NULL);
channel->OnError(ssrc, err_code);
} else {
LOG(LS_ERROR) << "VoiceEngine channel " << channel_num
- << " could not be found in the channel list when error reported.";
+ << " could not be found in channel list when error reported.";
}
}
@@ -906,6 +928,35 @@
return false;
}
+// This method will search through the WebRtcVoiceMediaChannels and
+// obtain the voice engine's channel number.
+bool WebRtcVoiceEngine::FindChannelNumFromSsrc(
+ uint32 ssrc, MediaProcessorDirection direction, int* channel_num) {
+ ASSERT(channel_num != NULL);
+
+ *channel_num = -1;
+ // Find corresponding channel for ssrc.
+ for (ChannelList::const_iterator it = channels_.begin();
+ it != channels_.end(); ++it) {
+ ASSERT(*it != NULL);
+ uint32 local_ssrc;
+ if ((direction & MPD_RX) != 0) {
+ *channel_num = (*it)->GetChannelNum(ssrc);
+ }
+ if (*channel_num == -1 &&
+ voe()->rtp()->GetLocalSSRC((*it)->voe_channel(), local_ssrc) != -1) {
+ if (ssrc == local_ssrc) {
+ *channel_num = (*it)->voe_channel();
+ }
+ }
+ if (*channel_num != -1) {
+ return true;
+ }
+ }
+ LOG(LS_WARNING) << "FindChannelFromSsrc. No Channel Found for Ssrc: " << ssrc;
+ return false;
+}
+
void WebRtcVoiceEngine::RegisterChannel(WebRtcVoiceMediaChannel *channel) {
talk_base::CritScope lock(&channels_cs_);
channels_.push_back(channel);
@@ -1013,18 +1064,144 @@
return true;
}
+bool WebRtcVoiceEngine::RegisterProcessor(
+ uint32 ssrc,
+ VoiceProcessor* voice_processor,
+ MediaProcessorDirection direction) {
+ bool register_with_webrtc = false;
+ int channel_id = -1;
+ bool success = false;
+ bool found_channel = FindChannelNumFromSsrc(ssrc, direction, &channel_id);
+ if (voice_processor == NULL || !found_channel) {
+ LOG(LS_WARNING) << "Media Processing Registration Failed. ssrc: " << ssrc
+ << " foundChannel: " << found_channel;
+ return false;
+ }
+ talk_base::CritScope cs(&signal_media_critical_);
+ webrtc::ProcessingTypes processing_type;
+ if (direction == MPD_RX) {
+ processing_type = webrtc::kPlaybackPerChannel;
+ if (SignalRxMediaFrame.is_empty()) {
+ register_with_webrtc = true;
+ }
+ SignalRxMediaFrame.connect(voice_processor,
+ &VoiceProcessor::OnFrame);
+ } else {
+ processing_type = webrtc::kRecordingPerChannel;
+ if (SignalTxMediaFrame.is_empty()) {
+ register_with_webrtc = true;
+ }
+ SignalTxMediaFrame.connect(voice_processor,
+ &VoiceProcessor::OnFrame);
+ }
+ if (register_with_webrtc) {
+ if (voe()->media()->
+ RegisterExternalMediaProcessing(channel_id,
+ processing_type,
+ *this) == -1) {
+ LOG_RTCERR2(RegisterExternalMediaProcessing,
+ channel_id,
+ processing_type);
+ success = false;
+ } else {
+ LOG(LS_INFO) << "Media Processing Registration Succeeded. channel:"
+ << channel_id;
+ success = true;
+ }
+ } else {
+ // If we don't have to register with the engine, we just needed to
+ // connect a new processor, set success to true;
+ success = true;
+ }
+ return success;
+}
+
+bool WebRtcVoiceEngine::UnregisterProcessor(
+ uint32 ssrc,
+ VoiceProcessor* voice_processor,
+ MediaProcessorDirection direction) {
+ int channel_id = -1;
+ bool found_channel = FindChannelNumFromSsrc(ssrc, direction, &channel_id);
+ bool success = true;
+ if (voice_processor == NULL || !found_channel) {
+ LOG(LS_WARNING) << "Media Processing Deregistration Failed. ssrc: "
+ << ssrc
+ << " foundChannel: "
+ << found_channel;
+ return false;
+ }
+ talk_base::CritScope cs(&signal_media_critical_);
+ if ((direction & MPD_RX) != 0) {
+ SignalRxMediaFrame.disconnect(voice_processor);
+ if (SignalRxMediaFrame.is_empty()) {
+ if (voe()->media()->DeRegisterExternalMediaProcessing(channel_id,
+ webrtc::kPlaybackPerChannel) != -1) {
+ LOG(LS_INFO) << "Media Processing DeRegistration Succeeded. channel:"
+ << channel_id;
+ } else {
+ LOG_RTCERR2(DeRegisterExternalMediaProcessing,
+ channel_id,
+ webrtc::kPlaybackPerChannel);
+ success = false;
+ }
+ }
+ }
+ if ((direction & MPD_TX) != 0) {
+ SignalTxMediaFrame.disconnect(voice_processor);
+ if (SignalTxMediaFrame.is_empty()) {
+ if (voe()->media()->DeRegisterExternalMediaProcessing(channel_id,
+ webrtc::kRecordingPerChannel) != -1) {
+ LOG(LS_INFO) << "Media Processing DeRegistration Succeeded. channel:"
+ << channel_id;
+ } else {
+ LOG_RTCERR2(DeRegisterExternalMediaProcessing,
+ channel_id,
+ webrtc::kRecordingPerChannel);
+ success = false;
+ }
+ }
+ }
+ return success;
+}
+
+// Implementing method from WebRtc VoEMediaProcess interface
+void WebRtcVoiceEngine::Process(const int channel,
+ const webrtc::ProcessingTypes type,
+ WebRtc_Word16 audio10ms[],
+ const int length,
+ const int sampling_freq,
+ const bool is_stereo) {
+ uint32 ssrc;
+ WebRtcVoiceMediaChannel* media_channel;
+
+ if (FindChannelAndSsrc(channel, &media_channel, &ssrc)) {
+ talk_base::CritScope cs(&signal_media_critical_);
+ AudioFrame frame(audio10ms, length, sampling_freq, is_stereo);
+ if (type == webrtc::kPlaybackPerChannel) {
+ SignalRxMediaFrame(ssrc, &frame);
+ } else if (type == webrtc::kRecordingPerChannel) {
+ SignalTxMediaFrame(ssrc, &frame);
+ }
+ } else {
+ LOG(LS_WARNING) << "MediaProcess Callback invoked with unexpected channel: "
+ << channel;
+ }
+}
+
// WebRtcVoiceMediaChannel
WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel(WebRtcVoiceEngine *engine)
: WebRtcMediaChannel<VoiceMediaChannel, WebRtcVoiceEngine>(
engine,
engine->voe()->base()->CreateChannel()),
+ recv_codecs_set_(false),
channel_options_(0),
agc_adjusted_(false),
dtmf_allowed_(false),
desired_playout_(false),
playout_(false),
desired_send_(SEND_NOTHING),
- send_(SEND_NOTHING) {
+ send_(SEND_NOTHING),
+ local_ssrc_(0) {
engine->RegisterChannel(this);
LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel "
<< voe_channel();
@@ -1038,9 +1215,6 @@
// Enable RTCP (for quality stats and feedback messages)
EnableRtcp(voe_channel());
- // Create a random but nonzero send SSRC
- SetSendSsrc(talk_base::CreateRandomNonZeroId());
-
// Reset all recv codecs; they will be enabled via SetRecvCodecs.
ResetRecvCodecs(voe_channel());
}
@@ -1059,8 +1233,9 @@
engine()->UnregisterChannel(this);
// Remove any remaining streams.
while (!mux_channels_.empty()) {
- RemoveStream(mux_channels_.begin()->first);
+ RemoveRecvStream(mux_channels_.begin()->first);
}
+
// Delete the primary channel.
if (engine()->voe()->base()->DeleteChannel(voe_channel()) == -1) {
LOG_RTCERR1(DeleteChannel, voe_channel());
@@ -1099,12 +1274,21 @@
LOG_RTCERR2(SetRecPayloadType, voe_channel(), ToString(voe_codec));
ret = false;
}
+ // Set the receive codecs on all receiving channels.
+ for (ChannelMap::iterator it = mux_channels_.begin();
+ it != mux_channels_.end() && ret; ++it) {
+ if (engine()->voe()->codec()->SetRecPayloadType(
+ it->second, voe_codec) == -1) {
+ LOG_RTCERR2(SetRecPayloadType, it->second, ToString(voe_codec));
+ ret = false;
+ }
+ }
} else {
LOG(LS_WARNING) << "Unknown codec " << ToString(*it);
ret = false;
}
}
-
+ recv_codecs_set_ = ret;
return ret;
}
@@ -1210,6 +1394,7 @@
return false;
}
+ send_codec_.reset(new webrtc::CodecInst(send_codec));
return true;
}
@@ -1293,7 +1478,9 @@
bool WebRtcVoiceMediaChannel::SetSend(SendFlags send) {
desired_send_ = send;
- return ChangeSend(desired_send_);
+ if (local_ssrc_ != 0)
+ return ChangeSend(desired_send_);
+ return true;
}
bool WebRtcVoiceMediaChannel::PauseSend() {
@@ -1325,6 +1512,11 @@
}
#endif // CHROMEOS
+ if ((channel_options_ & OPT_AGC_MINUS_10DB) && !agc_adjusted_) {
+ if (engine()->AdjustAgcLevel(kMinus10DbAdjustment)) {
+ agc_adjusted_ = true;
+ }
+ }
// VoiceEngine resets sequence number when StopSend is called. This
// sometimes causes libSRTP to complain about packets being
@@ -1399,9 +1591,65 @@
return true;
}
-bool WebRtcVoiceMediaChannel::AddStream(uint32 ssrc) {
+bool WebRtcVoiceMediaChannel::AddSendStream(const StreamParams& sp) {
+ if (local_ssrc_ != 0) {
+ LOG(LS_ERROR) << "WebRtcVoiceMediaChannel supports one sending channel.";
+ return false;
+ }
+
+ if (engine()->voe()->rtp()->SetLocalSSRC(voe_channel(), sp.first_ssrc())
+ == -1) {
+ LOG_RTCERR2(SetSendSSRC, voe_channel(), sp.first_ssrc());
+ return false;
+ }
+ // Set the SSRC on the receive channels.
+ // Receive channels have to have the same SSRC in order to send receiver
+ // reports with this SSRC.
+ for (ChannelMap::const_iterator it = mux_channels_.begin();
+ it != mux_channels_.end(); ++it) {
+ int channel_id = it->second;
+ if (engine()->voe()->rtp()->SetLocalSSRC(channel_id,
+ sp.first_ssrc()) != 0) {
+ LOG_RTCERR1(SetLocalSSRC, it->first);
+ return false;
+ }
+ }
+
+ if (engine()->voe()->rtp()->SetRTCP_CNAME(voe_channel(),
+ sp.cname.c_str()) == -1) {
+ LOG_RTCERR2(SetRTCP_CNAME, voe_channel(), sp.cname);
+ return false;
+ }
+
+ local_ssrc_ = sp.first_ssrc();
+ if (desired_send_ != send_)
+ return ChangeSend(desired_send_);
+ return true;
+}
+
+bool WebRtcVoiceMediaChannel::RemoveSendStream(uint32 ssrc) {
+ if (ssrc != local_ssrc_) {
+ return false;
+ }
+ local_ssrc_ = 0;
+ ChangeSend(SEND_NOTHING);
+ return true;
+}
+
+bool WebRtcVoiceMediaChannel::AddRecvStream(const StreamParams& sp) {
talk_base::CritScope lock(&mux_channels_cs_);
+ // Reuse default channel for recv stream in 1:1 call.
+ if ((channel_options_ & OPT_CONFERENCE) == 0) {
+ LOG(LS_INFO) << "Recv stream " << sp.first_ssrc()
+ << " reuse default channel";
+ return true;
+ }
+
+ if (!VERIFY(sp.ssrcs.size() == 1))
+ return false;
+ uint32 ssrc = sp.first_ssrc();
+
if (mux_channels_.find(ssrc) != mux_channels_.end()) {
return false;
}
@@ -1434,17 +1682,19 @@
// Use the same recv payload types as our default channel.
ResetRecvCodecs(channel);
- int ncodecs = engine()->voe()->codec()->NumOfCodecs();
- for (int i = 0; i < ncodecs; ++i) {
- webrtc::CodecInst voe_codec;
- if (engine()->voe()->codec()->GetCodec(i, voe_codec) != -1) {
- voe_codec.rate = 0; // Needed to make GetRecPayloadType work for ISAC
- if (engine()->voe()->codec()->GetRecPayloadType(
- voe_channel(), voe_codec) != -1) {
- if (engine()->voe()->codec()->SetRecPayloadType(
- channel, voe_codec) == -1) {
- LOG_RTCERR2(SetRecPayloadType, channel, ToString(voe_codec));
- return false;
+ if (recv_codecs_set_) {
+ int ncodecs = engine()->voe()->codec()->NumOfCodecs();
+ for (int i = 0; i < ncodecs; ++i) {
+ webrtc::CodecInst voe_codec;
+ if (engine()->voe()->codec()->GetCodec(i, voe_codec) != -1) {
+ voe_codec.rate = 0; // Needed to make GetRecPayloadType work for ISAC
+ if (engine()->voe()->codec()->GetRecPayloadType(
+ voe_channel(), voe_codec) != -1) {
+ if (engine()->voe()->codec()->SetRecPayloadType(
+ channel, voe_codec) == -1) {
+ LOG_RTCERR2(SetRecPayloadType, channel, ToString(voe_codec));
+ return false;
+ }
}
}
}
@@ -1470,7 +1720,7 @@
return SetPlayout(channel, playout_);
}
-bool WebRtcVoiceMediaChannel::RemoveStream(uint32 ssrc) {
+bool WebRtcVoiceMediaChannel::RemoveRecvStream(uint32 ssrc) {
talk_base::CritScope lock(&mux_channels_cs_);
ChannelMap::iterator it = mux_channels_.find(ssrc);
@@ -1538,7 +1788,7 @@
channels.push_back(it->second);
}
} else { // Collect only the channel of the specified ssrc.
- int channel = GetChannel(ssrc);
+ int channel = GetChannelNum(ssrc);
if (-1 == channel) {
LOG(LS_WARNING) << "Cannot find channel for ssrc:" << ssrc;
return false;
@@ -1579,7 +1829,7 @@
talk_base::CritScope lock(&mux_channels_cs_);
// Determine which channel based on ssrc.
- int channel = (0 == ssrc) ? voe_channel() : GetChannel(ssrc);
+ int channel = (0 == ssrc) ? voe_channel() : GetChannelNum(ssrc);
if (channel == -1) {
LOG(LS_WARNING) << "Cannot find channel for ssrc:" << ssrc;
return false;
@@ -1619,7 +1869,7 @@
}
// Determine which VoiceEngine channel to play on.
- int channel = (ssrc == 0) ? voe_channel() : GetChannel(ssrc);
+ int channel = (ssrc == 0) ? voe_channel() : GetChannelNum(ssrc);
if (channel == -1) {
return false;
}
@@ -1637,8 +1887,8 @@
ringback_channels_.insert(channel);
LOG(LS_INFO) << "Started ringback on channel " << channel;
} else {
- if (engine()->voe()->file()->StopPlayingFileLocally(channel)
- == -1) {
+ if (engine()->voe()->file()->IsPlayingFileLocally(channel) == 1 &&
+ engine()->voe()->file()->StopPlayingFileLocally(channel) == -1) {
LOG_RTCERR1(StopPlayingFileLocally, channel);
return false;
}
@@ -1675,7 +1925,7 @@
// Pick which channel to send this packet to. If this packet doesn't match
// any multiplexed streams, just send it to the default channel. Otherwise,
// send it to the specific decoder instance for that stream.
- int which_channel = GetChannel(
+ int which_channel = GetChannelNum(
ParseSsrc(packet->data(), packet->length(), false));
if (which_channel == -1) {
which_channel = voe_channel();
@@ -1703,7 +1953,7 @@
void WebRtcVoiceMediaChannel::OnRtcpReceived(talk_base::Buffer* packet) {
// See above.
- int which_channel = GetChannel(
+ int which_channel = GetChannelNum(
ParseSsrc(packet->data(), packet->length(), true));
if (which_channel == -1) {
which_channel = voe_channel();
@@ -1714,22 +1964,6 @@
packet->length());
}
-void WebRtcVoiceMediaChannel::SetSendSsrc(uint32 ssrc) {
- if (engine()->voe()->rtp()->SetLocalSSRC(voe_channel(), ssrc)
- == -1) {
- LOG_RTCERR2(SetSendSSRC, voe_channel(), ssrc);
- }
-}
-
-bool WebRtcVoiceMediaChannel::SetRtcpCName(const std::string& cname) {
- if (engine()->voe()->rtp()->SetRTCP_CNAME(voe_channel(),
- cname.c_str()) == -1) {
- LOG_RTCERR2(SetRTCP_CNAME, voe_channel(), cname);
- return false;
- }
- return true;
-}
-
bool WebRtcVoiceMediaChannel::Mute(bool muted) {
if (engine()->voe()->volume()->SetInputMute(voe_channel(),
muted) == -1) {
@@ -1752,7 +1986,6 @@
// Fill in the sender info, based on what we know, and what the
// remote side told us it got from its RTCP report.
VoiceSenderInfo sinfo;
- memset(&sinfo, 0, sizeof(sinfo));
// Data we obtain locally.
memset(&cs, 0, sizeof(cs));
@@ -1762,6 +1995,7 @@
}
sinfo.ssrc = ssrc;
+ sinfo.codec_name = send_codec_.get() ? send_codec_->plname : "";
sinfo.bytes_sent = cs.bytesSent;
sinfo.packets_sent = cs.packetsSent;
// RTT isn't known until a RTCP report is received. Until then, VoiceEngine
@@ -1792,6 +2026,35 @@
// Local speech level.
sinfo.audio_level = (engine()->voe()->volume()->
GetSpeechInputLevelFullRange(level) != -1) ? level : -1;
+
+ bool echo_metrics_on = false;
+ // These can take on valid negative values, so use the lowest possible level
+ // as default rather than -1.
+ sinfo.echo_return_loss = -100;
+ sinfo.echo_return_loss_enhancement = -100;
+ // These can also be negative, but in practice -1 is only used to signal
+ // insufficient data, since the resolution is limited to multiples of 4 ms.
+ sinfo.echo_delay_median_ms = -1;
+ sinfo.echo_delay_std_ms = -1;
+ if (engine()->voe()->processing()->GetEcMetricsStatus(echo_metrics_on) !=
+ -1 && echo_metrics_on) {
+ // TODO: we may want to use VoECallReport::GetEchoMetricsSummary
+ // here, but it appears to be unsuitable currently. Revisit after this is
+ // investigated: http://b/issue?id=5666755
+ int erl, erle, rerl, anlp;
+ if (engine()->voe()->processing()->GetEchoMetrics(erl, erle, rerl, anlp) !=
+ -1) {
+ sinfo.echo_return_loss = erl;
+ sinfo.echo_return_loss_enhancement = erle;
+ }
+
+ int median, std;
+ if (engine()->voe()->processing()->GetEcDelayMetrics(median, std) != -1) {
+ sinfo.echo_delay_median_ms = median;
+ sinfo.echo_delay_std_ms = std;
+ }
+ }
+
info->senders.push_back(sinfo);
// Build the list of receivers, one for each mux channel, or 1 in a 1:1 call.
@@ -1812,7 +2075,6 @@
engine()->voe()->rtp()->GetRTCPStatistics(*it, cs) != -1 &&
engine()->voe()->codec()->GetRecCodec(*it, codec) != -1) {
VoiceReceiverInfo rinfo;
- memset(&rinfo, 0, sizeof(rinfo));
rinfo.ssrc = ssrc;
rinfo.bytes_rcvd = cs.bytesReceived;
rinfo.packets_rcvd = cs.packetsReceived;
@@ -1899,7 +2161,7 @@
return (ret == 0) ? static_cast<int>(ulevel) : -1;
}
-int WebRtcVoiceMediaChannel::GetChannel(uint32 ssrc) {
+int WebRtcVoiceMediaChannel::GetChannelNum(uint32 ssrc) {
ChannelMap::iterator it = mux_channels_.find(ssrc);
return (it != mux_channels_.end()) ? it->second : -1;
}
diff --git a/talk/session/phone/webrtcvoiceengine.h b/talk/session/phone/webrtcvoiceengine.h
index 66c9785..7cc148a 100644
--- a/talk/session/phone/webrtcvoiceengine.h
+++ b/talk/session/phone/webrtcvoiceengine.h
@@ -41,6 +41,7 @@
#include "talk/session/phone/channel.h"
#include "talk/session/phone/rtputils.h"
#include "talk/session/phone/webrtccommon.h"
+#include "talk/session/phone/webrtcvoe.h"
#ifdef WEBRTC_RELATIVE_PATH
#include "voice_engine/main/interface/voe_base.h"
#else
@@ -76,6 +77,7 @@
class AudioDeviceModule;
class VoETraceWrapper;
class VoEWrapper;
+class VoiceProcessor;
class WebRtcSoundclipMedia;
class WebRtcVoiceMediaChannel;
@@ -83,7 +85,8 @@
// It uses the WebRtc VoiceEngine library for audio handling.
class WebRtcVoiceEngine
: public webrtc::VoiceEngineObserver,
- public webrtc::TraceCallback {
+ public webrtc::TraceCallback,
+ public webrtc::VoEMediaProcess {
public:
WebRtcVoiceEngine();
// Dependency injection for testing.
@@ -112,6 +115,21 @@
void SetLogging(int min_sev, const char* filter);
+ bool RegisterProcessor(uint32 ssrc,
+ VoiceProcessor* voice_processor,
+ MediaProcessorDirection direction);
+ bool UnregisterProcessor(uint32 ssrc,
+ VoiceProcessor* voice_processor,
+ MediaProcessorDirection direction);
+
+ // Method from webrtc::VoEMediaProcess
+ virtual void Process(const int channel,
+ const webrtc::ProcessingTypes type,
+ WebRtc_Word16 audio10ms[],
+ const int length,
+ const int sampling_freq,
+ const bool is_stereo);
+
// For tracking WebRtc channels. Needed because we have to pause them
// all when switching devices.
// May only be called by WebRtcVoiceMediaChannel.
@@ -138,6 +156,9 @@
bool SetAudioDeviceModule(webrtc::AudioDeviceModule* adm,
webrtc::AudioDeviceModule* adm_sc);
+ // Check whether the supplied trace should be ignored.
+ bool ShouldIgnoreTrace(const std::string& trace);
+
private:
typedef std::vector<WebRtcSoundclipMedia *> SoundclipList;
typedef std::vector<WebRtcVoiceMediaChannel *> ChannelList;
@@ -162,10 +183,19 @@
bool FindChannelAndSsrc(int channel_num,
WebRtcVoiceMediaChannel** channel,
uint32* ssrc) const;
+ bool FindChannelNumFromSsrc(uint32 ssrc,
+ MediaProcessorDirection direction,
+ int* channel_num);
bool ChangeLocalMonitor(bool enable);
bool PauseLocalMonitor();
bool ResumeLocalMonitor();
+ // When a voice processor registers with the engine, it is connected
+ // to either the Rx or Tx signals, based on the direction parameter.
+ // SignalXXMediaFrame will be invoked for every audio packet.
+ sigslot::signal2<uint32, AudioFrame*> SignalRxMediaFrame;
+ sigslot::signal2<uint32, AudioFrame*> SignalTxMediaFrame;
+
static const int kDefaultLogSeverity = talk_base::LS_WARNING;
static const CodecPref kCodecPrefs[];
@@ -190,6 +220,8 @@
talk_base::CriticalSection channels_cs_;
webrtc::AgcConfig default_agc_config_;
bool initialized_;
+
+ talk_base::CriticalSection signal_media_critical_;
};
// WebRtcMediaChannel is a class that implements the common WebRtc channel
@@ -247,8 +279,7 @@
// WebRtcVoiceMediaChannel is an implementation of VoiceMediaChannel that uses
// WebRtc Voice Engine.
class WebRtcVoiceMediaChannel
- : public WebRtcMediaChannel<VoiceMediaChannel,
- WebRtcVoiceEngine> {
+ : public WebRtcMediaChannel<VoiceMediaChannel, WebRtcVoiceEngine> {
public:
explicit WebRtcVoiceMediaChannel(WebRtcVoiceEngine *engine);
virtual ~WebRtcVoiceMediaChannel();
@@ -265,8 +296,10 @@
virtual bool SetSend(SendFlags send);
bool PauseSend();
bool ResumeSend();
- virtual bool AddStream(uint32 ssrc);
- virtual bool RemoveStream(uint32 ssrc);
+ virtual bool AddSendStream(const StreamParams& sp);
+ virtual bool RemoveSendStream(uint32 ssrc);
+ virtual bool AddRecvStream(const StreamParams& sp);
+ virtual bool RemoveRecvStream(uint32 ssrc);
virtual bool GetActiveStreams(AudioInfo::StreamList* actives);
virtual int GetOutputLevel();
virtual bool SetOutputScaling(uint32 ssrc, double left, double right);
@@ -278,8 +311,6 @@
virtual void OnPacketReceived(talk_base::Buffer* packet);
virtual void OnRtcpReceived(talk_base::Buffer* packet);
- virtual void SetSendSsrc(uint32 id);
- virtual bool SetRtcpCName(const std::string& cname);
virtual bool Mute(bool mute);
virtual bool SetSendBandwidth(bool autobw, int bps) { return false; }
virtual bool GetStats(VoiceMediaInfo* info);
@@ -290,9 +321,11 @@
bool FindSsrc(int channel_num, uint32* ssrc);
void OnError(uint32 ssrc, int error);
+ bool sending() const { return send_ != SEND_NOTHING; }
+ int GetChannelNum(uint32 ssrc);
+
protected:
int GetLastEngineError() { return engine()->GetLastEngineError(); }
- int GetChannel(uint32 ssrc);
int GetOutputLevel(int channel);
bool GetRedSendCodec(const AudioCodec& red_codec,
const std::vector<AudioCodec>& all_codecs,
@@ -304,9 +337,9 @@
static Error WebRtcErrorToChannelError(int err_code);
private:
- // Tandberg-bridged conferences require a -10dB gain adjustment,
- // which is actually +10 in AgcConfig.targetLeveldBOv
- static const int kTandbergDbAdjustment = 10;
+ // A -10dB gain adjustment is actually +10 in
+ // AgcConfig.targetLeveldBOv
+ static const int kMinus10DbAdjustment = 10;
bool ChangePlayout(bool playout);
bool ChangeSend(SendFlags send);
@@ -314,6 +347,8 @@
typedef std::map<uint32, int> ChannelMap;
talk_base::scoped_ptr<WebRtcSoundclipStream> ringback_tone_;
std::set<int> ringback_channels_; // channels playing ringback
+ bool recv_codecs_set_;
+ talk_base::scoped_ptr<webrtc::CodecInst> send_codec_;
int channel_options_;
bool agc_adjusted_;
bool dtmf_allowed_;
@@ -321,12 +356,15 @@
bool playout_;
SendFlags desired_send_;
SendFlags send_;
+
+ uint32 local_ssrc_;
ChannelMap mux_channels_; // for multiple sources
// mux_channels_ can be read from WebRtc callback thread. Accesses off the
// WebRtc thread must be synchronized with edits on the worker thread. Reads
// on the worker thread are ok.
mutable talk_base::CriticalSection mux_channels_cs_;
};
-}
+
+} // namespace cricket
#endif // TALK_SESSION_PHONE_WEBRTCVOICEENGINE_H_
diff --git a/talk/session/phone/webrtcvoiceengine_unittest.cc b/talk/session/phone/webrtcvoiceengine_unittest.cc
index f4e437f..f971106 100644
--- a/talk/session/phone/webrtcvoiceengine_unittest.cc
+++ b/talk/session/phone/webrtcvoiceengine_unittest.cc
@@ -4,10 +4,11 @@
#include "talk/base/byteorder.h"
#include "talk/base/gunit.h"
+#include "talk/p2p/base/fakesession.h"
#include "talk/session/phone/channel.h"
#include "talk/session/phone/fakemediaengine.h"
+#include "talk/session/phone/fakemediaprocessor.h"
#include "talk/session/phone/fakertp.h"
-#include "talk/session/phone/fakesession.h"
#include "talk/session/phone/fakewebrtcvoiceengine.h"
#include "talk/session/phone/webrtcvoiceengine.h"
@@ -25,6 +26,7 @@
&kTelephoneEventCodec,
};
const char kRingbackTone[] = "RIFF____WAVE____ABCD1234";
+static uint32 kSsrc1 = 0x99;
class FakeVoEWrapper : public cricket::VoEWrapper {
public:
@@ -57,7 +59,7 @@
}
};
-class WebRtcVoiceEngineTest : public testing::Test {
+class WebRtcVoiceEngineTestFake : public testing::Test {
public:
class ChannelErrorListener : public sigslot::has_slots<> {
public:
@@ -88,7 +90,7 @@
cricket::VoiceMediaChannel::Error error_;
};
- WebRtcVoiceEngineTest()
+ WebRtcVoiceEngineTestFake()
: voe_(kAudioCodecs, ARRAY_SIZE(kAudioCodecs)),
voe_sc_(kAudioCodecs, ARRAY_SIZE(kAudioCodecs)),
engine_(new FakeVoEWrapper(&voe_),
@@ -102,6 +104,10 @@
channel_ = engine_.CreateChannel();
result = (channel_ != NULL);
}
+ if (result) {
+ result = channel_->AddSendStream(
+ cricket::StreamParams::CreateLegacy(kSsrc1));
+ }
return result;
}
void DeliverPacket(const void* data, int len) {
@@ -123,7 +129,7 @@
};
// Tests that our stub library "works".
-TEST_F(WebRtcVoiceEngineTest, StartupShutdown) {
+TEST_F(WebRtcVoiceEngineTestFake, StartupShutdown) {
EXPECT_FALSE(voe_.IsInited());
EXPECT_FALSE(voe_sc_.IsInited());
EXPECT_TRUE(engine_.Init());
@@ -135,14 +141,14 @@
}
// Tests that we can create and destroy a channel.
-TEST_F(WebRtcVoiceEngineTest, CreateChannel) {
+TEST_F(WebRtcVoiceEngineTestFake, CreateChannel) {
EXPECT_TRUE(engine_.Init());
channel_ = engine_.CreateChannel();
EXPECT_TRUE(channel_ != NULL);
}
// Tests that we properly handle failures in CreateChannel.
-TEST_F(WebRtcVoiceEngineTest, CreateChannelFail) {
+TEST_F(WebRtcVoiceEngineTestFake, CreateChannelFail) {
voe_.set_fail_create_channel(true);
EXPECT_TRUE(engine_.Init());
channel_ = engine_.CreateChannel();
@@ -151,7 +157,7 @@
// Tests that the list of supported codecs is created properly and ordered
// correctly
-TEST_F(WebRtcVoiceEngineTest, CodecPreference) {
+TEST_F(WebRtcVoiceEngineTestFake, CodecPreference) {
const std::vector<cricket::AudioCodec>& codecs = engine_.codecs();
ASSERT_FALSE(codecs.empty());
EXPECT_EQ("ISAC", codecs[0].name);
@@ -166,7 +172,7 @@
// Tests that we can find codecs by name or id, and that we interpret the
// clockrate and bitrate fields properly.
-TEST_F(WebRtcVoiceEngineTest, FindCodec) {
+TEST_F(WebRtcVoiceEngineTestFake, FindCodec) {
cricket::AudioCodec codec;
webrtc::CodecInst codec_inst;
// Find PCMU with explicit clockrate and bitrate.
@@ -201,7 +207,7 @@
}
// Test that we set our inbound codecs properly, including changing PT.
-TEST_F(WebRtcVoiceEngineTest, SetRecvCodecs) {
+TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -226,7 +232,7 @@
}
// Test that we fail to set an unknown inbound codec.
-TEST_F(WebRtcVoiceEngineTest, SetRecvCodecsUnsupportedCodec) {
+TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsUnsupportedCodec) {
EXPECT_TRUE(SetupEngine());
std::vector<cricket::AudioCodec> codecs;
codecs.push_back(kIsacCodec);
@@ -235,7 +241,7 @@
}
// Test that we fail if we have duplicate types in the inbound list.
-TEST_F(WebRtcVoiceEngineTest, SetRecvCodecsDuplicatePayloadType) {
+TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsDuplicatePayloadType) {
EXPECT_TRUE(SetupEngine());
std::vector<cricket::AudioCodec> codecs;
codecs.push_back(kIsacCodec);
@@ -245,8 +251,9 @@
}
// Test that changes to recv codecs are applied to all streams.
-TEST_F(WebRtcVoiceEngineTest, SetRecvCodecsWithMultipleStreams) {
+TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) {
EXPECT_TRUE(SetupEngine());
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
std::vector<cricket::AudioCodec> codecs;
codecs.push_back(kIsacCodec);
codecs.push_back(kPcmuCodec);
@@ -254,7 +261,8 @@
codecs[0].id = 106; // collide with existing telephone-event
codecs[2].id = 126;
EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
- EXPECT_TRUE(channel_->AddStream(2));
+ EXPECT_TRUE(channel_->AddRecvStream(
+ cricket::StreamParams::CreateLegacy(kSsrc1)));
int channel_num2 = voe_.GetLastChannel();
webrtc::CodecInst gcodec;
talk_base::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC");
@@ -270,8 +278,28 @@
EXPECT_STREQ("telephone-event", gcodec.plname);
}
+TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) {
+ EXPECT_TRUE(SetupEngine());
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
+ std::vector<cricket::AudioCodec> codecs;
+ codecs.push_back(kIsacCodec);
+ codecs[0].id = 106; // collide with existing telephone-event
+
+ EXPECT_TRUE(channel_->AddRecvStream(
+ cricket::StreamParams::CreateLegacy(kSsrc1)));
+ EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+
+ int channel_num2 = voe_.GetLastChannel();
+ webrtc::CodecInst gcodec;
+ talk_base::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC");
+ gcodec.plfreq = 16000;
+ EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec));
+ EXPECT_EQ(106, gcodec.pltype);
+ EXPECT_STREQ("ISAC", gcodec.plname);
+}
+
// Test that we apply codecs properly.
-TEST_F(WebRtcVoiceEngineTest, SetSendCodecs) {
+TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -292,7 +320,7 @@
}
// Test that we handle various ways of specifying bitrate.
-TEST_F(WebRtcVoiceEngineTest, SetSendCodecsBitrate) {
+TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -330,7 +358,7 @@
}
// Test that we fall back to PCMU if no codecs are specified.
-TEST_F(WebRtcVoiceEngineTest, SetSendCodecsNoCodecs) {
+TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -347,7 +375,7 @@
}
// Test that we set VAD and DTMF types correctly.
-TEST_F(WebRtcVoiceEngineTest, SetSendCodecsCNandDTMF) {
+TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMF) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -374,7 +402,7 @@
}
// Test that we perform case-insensitive matching of codec names.
-TEST_F(WebRtcVoiceEngineTest, SetSendCodecsCaseInsensitive) {
+TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -401,7 +429,7 @@
}
// Test that we set up FEC correctly.
-TEST_F(WebRtcVoiceEngineTest, SetSendCodecsRED) {
+TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsRED) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -421,7 +449,7 @@
}
// Test that we set up FEC correctly if params are omitted.
-TEST_F(WebRtcVoiceEngineTest, SetSendCodecsREDNoParams) {
+TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDNoParams) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -440,7 +468,7 @@
}
// Test that we ignore RED if the parameters aren't named the way we expect.
-TEST_F(WebRtcVoiceEngineTest, SetSendCodecsBadRED1) {
+TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED1) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -459,7 +487,7 @@
}
// Test that we ignore RED if it uses different primary/secondary encoding.
-TEST_F(WebRtcVoiceEngineTest, SetSendCodecsBadRED2) {
+TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED2) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -478,7 +506,7 @@
}
// Test that we ignore RED if it uses more than 2 encodings.
-TEST_F(WebRtcVoiceEngineTest, SetSendCodecsBadRED3) {
+TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED3) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -497,7 +525,7 @@
}
// Test that we ignore RED if it has bogus codec ids.
-TEST_F(WebRtcVoiceEngineTest, SetSendCodecsBadRED4) {
+TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED4) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -516,7 +544,7 @@
}
// Test that we ignore RED if it refers to a codec that is not present.
-TEST_F(WebRtcVoiceEngineTest, SetSendCodecsBadRED5) {
+TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED5) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -535,7 +563,7 @@
}
// Test that we support setting an empty list of recv header extensions.
-TEST_F(WebRtcVoiceEngineTest, SetRecvRtpHeaderExtensions) {
+TEST_F(WebRtcVoiceEngineTestFake, SetRecvRtpHeaderExtensions) {
EXPECT_TRUE(SetupEngine());
std::vector<cricket::RtpHeaderExtension> extensions;
int channel_num = voe_.GetLastChannel();
@@ -558,7 +586,7 @@
}
// Test that we support setting certain send header extensions.
-TEST_F(WebRtcVoiceEngineTest, SetSendRtpHeaderExtensions) {
+TEST_F(WebRtcVoiceEngineTestFake, SetSendRtpHeaderExtensions) {
EXPECT_TRUE(SetupEngine());
std::vector<cricket::RtpHeaderExtension> extensions;
int channel_num = voe_.GetLastChannel();
@@ -594,7 +622,7 @@
}
// Test that we can create a channel and start sending/playing out on it.
-TEST_F(WebRtcVoiceEngineTest, SendAndPlayout) {
+TEST_F(WebRtcVoiceEngineTestFake, SendAndPlayout) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -612,16 +640,17 @@
// Test that we can add and remove streams, and do proper send/playout.
// We can receive on multiple streams, but will only send on one.
-TEST_F(WebRtcVoiceEngineTest, SendAndPlayoutWithMultipleStreams) {
+TEST_F(WebRtcVoiceEngineTestFake, SendAndPlayoutWithMultipleStreams) {
EXPECT_TRUE(SetupEngine());
int channel_num1 = voe_.GetLastChannel();
// Start playout on the default channel.
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
EXPECT_TRUE(channel_->SetPlayout(true));
EXPECT_TRUE(voe_.GetPlayout(channel_num1));
// Adding another stream should disable playout on the default channel.
- EXPECT_TRUE(channel_->AddStream(2));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
int channel_num2 = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
codecs.push_back(kPcmuCodec);
@@ -635,7 +664,7 @@
EXPECT_TRUE(voe_.GetPlayout(channel_num2));
// Adding yet another stream should have stream 2 and 3 enabled for playout.
- EXPECT_TRUE(channel_->AddStream(3));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
int channel_num3 = voe_.GetLastChannel();
EXPECT_FALSE(voe_.GetPlayout(channel_num1));
EXPECT_TRUE(voe_.GetPlayout(channel_num2));
@@ -662,14 +691,14 @@
// Now remove the new streams and verify that the default channel is
// played out again.
- EXPECT_TRUE(channel_->RemoveStream(3));
- EXPECT_TRUE(channel_->RemoveStream(2));
+ EXPECT_TRUE(channel_->RemoveRecvStream(3));
+ EXPECT_TRUE(channel_->RemoveRecvStream(2));
EXPECT_TRUE(voe_.GetPlayout(channel_num1));
}
// Test that we can set the devices to use.
-TEST_F(WebRtcVoiceEngineTest, SetDevices) {
+TEST_F(WebRtcVoiceEngineTestFake, SetDevices) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -723,7 +752,7 @@
// Test that we can set the devices to use even if we failed to
// open the initial ones.
-TEST_F(WebRtcVoiceEngineTest, SetDevicesWithInitiallyBadDevices) {
+TEST_F(WebRtcVoiceEngineTestFake, SetDevicesWithInitiallyBadDevices) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
std::vector<cricket::AudioCodec> codecs;
@@ -763,7 +792,7 @@
// Test that we can create a channel configured for multi-point conferences,
// and start sending/playing out on it.
-TEST_F(WebRtcVoiceEngineTest, ConferenceSendAndPlayout) {
+TEST_F(WebRtcVoiceEngineTestFake, ConferenceSendAndPlayout) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
@@ -806,13 +835,13 @@
// Test that we can create a channel configured for Codian bridges,
// and start sending/playing out on it.
-TEST_F(WebRtcVoiceEngineTest, CodianSendAndPlayout) {
+TEST_F(WebRtcVoiceEngineTestFake, CodianSendAndPlayout) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
webrtc::AgcConfig agc_config;
EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
EXPECT_EQ(0, agc_config.targetLeveldBOv);
- EXPECT_TRUE(channel_->SetOptions(cricket::OPT_AGC_TANDBERG_LEVELS));
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_AGC_MINUS_10DB));
std::vector<cricket::AudioCodec> codecs;
codecs.push_back(kPcmuCodec);
EXPECT_TRUE(channel_->SetSendCodecs(codecs));
@@ -831,48 +860,72 @@
}
// Test that we can set the outgoing SSRC properly.
-TEST_F(WebRtcVoiceEngineTest, SetSendSsrc) {
+// SSRC is set in SetupEngine by calling AddSendStream.
+TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrc) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
unsigned int send_ssrc;
EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num, send_ssrc));
EXPECT_NE(0U, send_ssrc);
- channel_->SetSendSsrc(0x99);
EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num, send_ssrc));
- EXPECT_EQ(0x99U, send_ssrc);
+ EXPECT_EQ(kSsrc1, send_ssrc);
}
// Test that we can set the outgoing SSRC properly with multiple streams.
-TEST_F(WebRtcVoiceEngineTest, SetSendSsrcWithMultipleStreams) {
+// SSRC is set in SetupEngine by calling AddSendStream.
+TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcWithMultipleStreams) {
EXPECT_TRUE(SetupEngine());
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
int channel_num1 = voe_.GetLastChannel();
unsigned int send_ssrc;
- channel_->SetSendSsrc(0x99);
EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num1, send_ssrc));
- EXPECT_EQ(0x99U, send_ssrc);
- EXPECT_TRUE(channel_->AddStream(2));
+ EXPECT_EQ(kSsrc1, send_ssrc);
+
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
int channel_num2 = voe_.GetLastChannel();
EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num2, send_ssrc));
- EXPECT_EQ(0x99U, send_ssrc);
+ EXPECT_EQ(kSsrc1, send_ssrc);
+}
+
+// Test that the local SSRC is the same on sending and receiving channels if the
+// receive channel is created before the send channel.
+TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) {
+ EXPECT_TRUE(engine_.Init());
+ channel_ = engine_.CreateChannel();
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
+
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+ int receive_channel_num = voe_.GetLastChannel();
+ EXPECT_TRUE(channel_->AddSendStream(
+ cricket::StreamParams::CreateLegacy(1234)));
+ int send_channel_num = voe_.GetLastChannel();
+
+ unsigned int ssrc = 0;
+ EXPECT_EQ(0, voe_.GetLocalSSRC(send_channel_num, ssrc));
+ EXPECT_EQ(1234U, ssrc);
+ ssrc = 0;
+ EXPECT_EQ(0, voe_.GetLocalSSRC(receive_channel_num, ssrc));
+ EXPECT_EQ(1234U, ssrc);
}
// Test that we can properly receive packets.
-TEST_F(WebRtcVoiceEngineTest, Recv) {
+TEST_F(WebRtcVoiceEngineTestFake, Recv) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
EXPECT_TRUE(voe_.CheckPacket(channel_num, kPcmuFrame,
- sizeof(kPcmuFrame)));
+ sizeof(kPcmuFrame)));
}
// Test that we can properly receive packets on multiple streams.
-TEST_F(WebRtcVoiceEngineTest, RecvWithMultipleStreams) {
+TEST_F(WebRtcVoiceEngineTestFake, RecvWithMultipleStreams) {
EXPECT_TRUE(SetupEngine());
- EXPECT_TRUE(channel_->AddStream(1));
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
int channel_num1 = voe_.GetLastChannel();
- EXPECT_TRUE(channel_->AddStream(2));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
int channel_num2 = voe_.GetLastChannel();
- EXPECT_TRUE(channel_->AddStream(3));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
int channel_num3 = voe_.GetLastChannel();
// Create packets with the right SSRCs.
char packets[4][sizeof(kPcmuFrame)];
@@ -889,37 +942,51 @@
EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
DeliverPacket(packets[1], sizeof(packets[1]));
EXPECT_TRUE(voe_.CheckPacket(channel_num1, packets[1],
- sizeof(packets[1])));
+ sizeof(packets[1])));
EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
DeliverPacket(packets[2], sizeof(packets[2]));
EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
EXPECT_TRUE(voe_.CheckPacket(channel_num2, packets[2],
- sizeof(packets[2])));
+ sizeof(packets[2])));
EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
DeliverPacket(packets[3], sizeof(packets[3]));
EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
EXPECT_TRUE(voe_.CheckPacket(channel_num3, packets[3],
- sizeof(packets[3])));
- EXPECT_TRUE(channel_->RemoveStream(3));
- EXPECT_TRUE(channel_->RemoveStream(2));
- EXPECT_TRUE(channel_->RemoveStream(1));
+ sizeof(packets[3])));
+ EXPECT_TRUE(channel_->RemoveRecvStream(3));
+ EXPECT_TRUE(channel_->RemoveRecvStream(2));
+ EXPECT_TRUE(channel_->RemoveRecvStream(1));
}
// Test that we properly handle failures to add a stream.
-TEST_F(WebRtcVoiceEngineTest, AddStreamFail) {
+TEST_F(WebRtcVoiceEngineTestFake, AddStreamFail) {
EXPECT_TRUE(SetupEngine());
voe_.set_fail_create_channel(true);
- EXPECT_FALSE(channel_->AddStream(2));
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
+ EXPECT_FALSE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
+
+ // In 1:1 call, we should not try to create a new channel.
+ EXPECT_TRUE(channel_->SetOptions(0));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
+}
+
+// Test that AddRecvStream doesn't create new channel for 1:1 call.
+TEST_F(WebRtcVoiceEngineTestFake, AddRecvStream1On1) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = voe_.GetLastChannel();
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+ EXPECT_EQ(channel_num, voe_.GetLastChannel());
}
// Test that we properly clean up any streams that were added, even if
// not explicitly removed.
-TEST_F(WebRtcVoiceEngineTest, StreamCleanup) {
+TEST_F(WebRtcVoiceEngineTestFake, StreamCleanup) {
EXPECT_TRUE(SetupEngine());
- EXPECT_TRUE(channel_->AddStream(1));
- EXPECT_TRUE(channel_->AddStream(2));
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
EXPECT_EQ(3, voe_.GetNumChannels()); // default channel + 2 added
delete channel_;
channel_ = NULL;
@@ -928,7 +995,7 @@
// Test that we can send DTMF properly, but only if the other side supports
// telephone-event.
-TEST_F(WebRtcVoiceEngineTest, SendDtmf) {
+TEST_F(WebRtcVoiceEngineTestFake, SendDtmf) {
EXPECT_TRUE(SetupEngine());
std::vector<cricket::AudioCodec> codecs;
codecs.push_back(kPcmuCodec);
@@ -941,7 +1008,7 @@
}
// Test that we can play a ringback tone properly in a single-stream call.
-TEST_F(WebRtcVoiceEngineTest, PlayRingback) {
+TEST_F(WebRtcVoiceEngineTestFake, PlayRingback) {
EXPECT_TRUE(SetupEngine());
int channel_num = voe_.GetLastChannel();
EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
@@ -963,10 +1030,11 @@
}
// Test that we can play a ringback tone properly in a multi-stream call.
-TEST_F(WebRtcVoiceEngineTest, PlayRingbackWithMultipleStreams) {
+TEST_F(WebRtcVoiceEngineTestFake, PlayRingbackWithMultipleStreams) {
EXPECT_TRUE(SetupEngine());
- EXPECT_TRUE(channel_->AddStream(1));
- EXPECT_TRUE(channel_->AddStream(2));
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
int channel_num = voe_.GetLastChannel();
EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
// Check we fail if no ringback tone specified.
@@ -995,7 +1063,7 @@
}
// Tests creating soundclips, and make sure they come from the right engine.
-TEST_F(WebRtcVoiceEngineTest, CreateSoundclip) {
+TEST_F(WebRtcVoiceEngineTestFake, CreateSoundclip) {
EXPECT_TRUE(engine_.Init());
soundclip_ = engine_.CreateSoundclip();
ASSERT_TRUE(soundclip_ != NULL);
@@ -1009,7 +1077,7 @@
}
// Tests playing out a fake sound.
-TEST_F(WebRtcVoiceEngineTest, PlaySoundclip) {
+TEST_F(WebRtcVoiceEngineTestFake, PlaySoundclip) {
static const char kZeroes[16000] = {};
EXPECT_TRUE(engine_.Init());
soundclip_ = engine_.CreateSoundclip();
@@ -1017,12 +1085,13 @@
EXPECT_TRUE(soundclip_->PlaySound(kZeroes, sizeof(kZeroes), 0));
}
-TEST_F(WebRtcVoiceEngineTest, MediaEngineCallbackOnError) {
+TEST_F(WebRtcVoiceEngineTestFake, MediaEngineCallbackOnError) {
talk_base::scoped_ptr<ChannelErrorListener> listener;
cricket::WebRtcVoiceMediaChannel* media_channel;
unsigned int ssrc = 0;
EXPECT_TRUE(SetupEngine());
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
media_channel = reinterpret_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
@@ -1030,7 +1099,7 @@
// Test on WebRtc VoE channel.
voe_.TriggerCallbackOnError(media_channel->voe_channel(),
- VE_SATURATION_WARNING);
+ VE_SATURATION_WARNING);
EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_REC_DEVICE_SATURATION,
listener->error());
EXPECT_NE(-1, voe_.GetLocalSSRC(voe_.GetLastChannel(), ssrc));
@@ -1044,10 +1113,11 @@
// Add another stream and test on that.
++ssrc;
- EXPECT_TRUE(channel_->AddStream(ssrc));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(
+ ssrc)));
listener->Reset();
voe_.TriggerCallbackOnError(voe_.GetLastChannel(),
- VE_SATURATION_WARNING);
+ VE_SATURATION_WARNING);
EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_REC_DEVICE_SATURATION,
listener->error());
EXPECT_EQ(ssrc, listener->ssrc());
@@ -1055,28 +1125,103 @@
// Testing a non-existing channel.
listener->Reset();
voe_.TriggerCallbackOnError(voe_.GetLastChannel() + 2,
- VE_SATURATION_WARNING);
+ VE_SATURATION_WARNING);
EXPECT_EQ(0, listener->error());
}
-TEST_F(WebRtcVoiceEngineTest, TestSetPlayoutError) {
+TEST_F(WebRtcVoiceEngineTestFake, TestSetPlayoutError) {
EXPECT_TRUE(SetupEngine());
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
std::vector<cricket::AudioCodec> codecs;
codecs.push_back(kPcmuCodec);
EXPECT_TRUE(channel_->SetSendCodecs(codecs));
EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
- EXPECT_TRUE(channel_->AddStream(2));
- EXPECT_TRUE(channel_->AddStream(3));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
EXPECT_TRUE(channel_->SetPlayout(true));
voe_.set_playout_fail_channel(voe_.GetLastChannel() - 1);
EXPECT_TRUE(channel_->SetPlayout(false));
EXPECT_FALSE(channel_->SetPlayout(true));
}
+// Test that the Registering/Unregistering with the
+// webrtcvoiceengine works as expected
+TEST_F(WebRtcVoiceEngineTestFake, RegisterVoiceProcessor) {
+ EXPECT_TRUE(SetupEngine());
+ EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
+ EXPECT_TRUE(channel_->AddRecvStream(
+ cricket::StreamParams::CreateLegacy(kSsrc1)));
+ uint32 ssrc = 0;
+ voe_.GetLocalSSRC(0, ssrc);
+ cricket::FakeMediaProcessor vp_1;
+ cricket::FakeMediaProcessor vp_2;
+
+ EXPECT_TRUE(engine_.RegisterProcessor(ssrc, &vp_1, cricket::MPD_RX));
+ EXPECT_TRUE(engine_.RegisterProcessor(ssrc, &vp_2, cricket::MPD_RX));
+ voe_.TriggerProcessPacket(cricket::MPD_RX);
+ voe_.TriggerProcessPacket(cricket::MPD_TX);
+
+ EXPECT_TRUE(voe_.IsExternalMediaProcessorRegistered());
+ EXPECT_EQ(1, vp_1.voice_frame_count());
+ EXPECT_EQ(1, vp_2.voice_frame_count());
+
+ EXPECT_TRUE(engine_.UnregisterProcessor(ssrc,
+ &vp_2,
+ cricket::MPD_RX));
+ voe_.TriggerProcessPacket(cricket::MPD_RX);
+ EXPECT_TRUE(voe_.IsExternalMediaProcessorRegistered());
+ EXPECT_EQ(1, vp_2.voice_frame_count());
+ EXPECT_EQ(2, vp_1.voice_frame_count());
+
+ EXPECT_TRUE(engine_.UnregisterProcessor(ssrc,
+ &vp_1,
+ cricket::MPD_RX));
+ voe_.TriggerProcessPacket(cricket::MPD_RX);
+ EXPECT_FALSE(voe_.IsExternalMediaProcessorRegistered());
+ EXPECT_EQ(2, vp_1.voice_frame_count());
+
+ EXPECT_TRUE(engine_.RegisterProcessor(ssrc, &vp_1, cricket::MPD_TX));
+ voe_.TriggerProcessPacket(cricket::MPD_RX);
+ voe_.TriggerProcessPacket(cricket::MPD_TX);
+ EXPECT_TRUE(voe_.IsExternalMediaProcessorRegistered());
+ EXPECT_EQ(3, vp_1.voice_frame_count());
+
+ EXPECT_TRUE(engine_.UnregisterProcessor(ssrc,
+ &vp_1,
+ cricket::MPD_RX_AND_TX));
+ voe_.TriggerProcessPacket(cricket::MPD_TX);
+ EXPECT_FALSE(voe_.IsExternalMediaProcessorRegistered());
+ EXPECT_EQ(3, vp_1.voice_frame_count());
+ EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc1));
+
+ // Test that after removing the recvstream we can we can still register
+ // the processor. This tests the 1:1 case.
+ EXPECT_TRUE(engine_.RegisterProcessor(ssrc, &vp_1, cricket::MPD_RX));
+ EXPECT_TRUE(engine_.UnregisterProcessor(ssrc, &vp_1, cricket::MPD_RX_AND_TX));
+
+ // The following tests test that FindChannelNumFromSsrc is doing
+ // what we expect.
+ // pick an invalid ssrc and make sure we can't register
+ EXPECT_FALSE(engine_.RegisterProcessor(0,
+ &vp_1,
+ cricket::MPD_RX));
+ EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+ EXPECT_TRUE(engine_.RegisterProcessor(1,
+ &vp_1,
+ cricket::MPD_RX));
+ EXPECT_TRUE(engine_.UnregisterProcessor(1,
+ &vp_1,
+ cricket::MPD_RX));
+ EXPECT_FALSE(engine_.RegisterProcessor(1,
+ &vp_1,
+ cricket::MPD_TX));
+ EXPECT_TRUE(channel_->RemoveRecvStream(1));
+}
+
// Tests for the actual WebRtc VoE library.
// Tests that the library initializes and shuts down properly.
-TEST(WebRtcVoiceEngineLibTest, StartupShutdown) {
+TEST(WebRtcVoiceEngineTest, StartupShutdown) {
cricket::WebRtcVoiceEngine engine;
EXPECT_TRUE(engine.Init());
cricket::VoiceMediaChannel* channel = engine.CreateChannel();
@@ -1090,9 +1235,7 @@
}
// Tests that the logging from the library is cleartext.
-// TODO: This test case is disabled due to a known bug in VoE4.0
-// which sends out truncated log message. Will be fixed in next VoE release.
-TEST(WebRtcVoiceEngineLibTest, DISABLED_HasUnencryptedLogging) {
+TEST(WebRtcVoiceEngineTest, DISABLED_HasUnencryptedLogging) {
cricket::WebRtcVoiceEngine engine;
talk_base::scoped_ptr<talk_base::MemoryStream> stream(
new talk_base::MemoryStream);
@@ -1117,7 +1260,7 @@
// Tests we do not see any references to a monitor thread being spun up
// when initiating the engine.
-TEST(WebRtcVoiceEngineLibTest, HasNoMonitorThread) {
+TEST(WebRtcVoiceEngineTest, HasNoMonitorThread) {
cricket::WebRtcVoiceEngine engine;
talk_base::scoped_ptr<talk_base::MemoryStream> stream(
new talk_base::MemoryStream);
@@ -1135,7 +1278,7 @@
}
// Tests that the library is configured with the codecs we want.
-TEST(WebRtcVoiceEngineLibTest, HasCorrectCodecs) {
+TEST(WebRtcVoiceEngineTest, HasCorrectCodecs) {
cricket::WebRtcVoiceEngine engine;
// Check codecs by name.
EXPECT_TRUE(engine.FindCodec(
@@ -1211,7 +1354,7 @@
}
// Tests that VoE supports at least 32 channels
-TEST(WebRtcVoiceEngineLibTest, Has32Channels) {
+TEST(WebRtcVoiceEngineTest, Has32Channels) {
cricket::WebRtcVoiceEngine engine;
EXPECT_TRUE(engine.Init());
@@ -1238,7 +1381,7 @@
#ifdef WIN32
// Test our workarounds to WebRtc VoE' munging of the coinit count
-TEST(WebRtcVoiceEngineLibTest, CoInitialize) {
+TEST(WebRtcVoiceEngineTest, CoInitialize) {
cricket::WebRtcVoiceEngine* engine = new cricket::WebRtcVoiceEngine();
// Initial refcount should be 0.
diff --git a/talk/session/phone/win32devicemanager.cc b/talk/session/phone/win32devicemanager.cc
new file mode 100644
index 0000000..f8a928e
--- /dev/null
+++ b/talk/session/phone/win32devicemanager.cc
@@ -0,0 +1,405 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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/session/phone/win32devicemanager.h"
+
+#include <atlbase.h>
+#include <dbt.h>
+#include <strmif.h> // must come before ks.h
+#include <ks.h>
+#include <ksmedia.h>
+#define INITGUID // For PKEY_AudioEndpoint_GUID
+#include <mmdeviceapi.h>
+#include <mmsystem.h>
+#include <functiondiscoverykeys_devpkey.h>
+#include <uuids.h>
+
+#include "talk/base/win32.h" // ToUtf8
+#include "talk/base/win32window.h"
+#include "talk/base/logging.h"
+#include "talk/base/stringutils.h"
+#include "talk/base/thread.h"
+#include "talk/session/phone/mediacommon.h"
+#ifdef HAVE_LOGITECH_HEADERS
+#include "third_party/logitech/files/logitechquickcam.h"
+#endif
+
+namespace cricket {
+
+DeviceManagerInterface* DeviceManagerFactory::Create() {
+ return new Win32DeviceManager();
+}
+
+class Win32DeviceWatcher
+ : public DeviceWatcher,
+ public talk_base::Win32Window {
+ public:
+ explicit Win32DeviceWatcher(Win32DeviceManager* dm);
+ virtual ~Win32DeviceWatcher();
+ virtual bool Start();
+ virtual void Stop();
+
+ private:
+ HDEVNOTIFY Register(REFGUID guid);
+ void Unregister(HDEVNOTIFY notify);
+ virtual bool OnMessage(UINT msg, WPARAM wp, LPARAM lp, LRESULT& result);
+
+ Win32DeviceManager* manager_;
+ HDEVNOTIFY audio_notify_;
+ HDEVNOTIFY video_notify_;
+};
+
+static const char* kFilteredAudioDevicesName[] = {
+ NULL,
+};
+static const char* const kFilteredVideoDevicesName[] = {
+ "Google Camera Adapter", // Our own magiccams
+ "Asus virtual Camera", // Bad Asus desktop virtual cam
+ "Bluetooth Video", // Bad Sony viao bluetooth sharing driver
+ NULL,
+};
+static const wchar_t kFriendlyName[] = L"FriendlyName";
+static const wchar_t kDevicePath[] = L"DevicePath";
+static const char kUsbDevicePathPrefix[] = "\\\\?\\usb";
+static bool GetDevices(const CLSID& catid, std::vector<Device>* out);
+static bool GetCoreAudioDevices(bool input, std::vector<Device>* devs);
+static bool GetWaveDevices(bool input, std::vector<Device>* devs);
+
+Win32DeviceManager::Win32DeviceManager()
+ : need_couninitialize_(false) {
+ set_watcher(new Win32DeviceWatcher(this));
+}
+
+Win32DeviceManager::~Win32DeviceManager() {
+ if (initialized()) {
+ Terminate();
+ }
+}
+
+bool Win32DeviceManager::Init() {
+ if (!initialized()) {
+ HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
+ need_couninitialize_ = SUCCEEDED(hr);
+ if (FAILED(hr)) {
+ LOG(LS_ERROR) << "CoInitialize failed, hr=" << hr;
+ if (hr != RPC_E_CHANGED_MODE) {
+ return false;
+ }
+ }
+ if (!watcher()->Start()) {
+ return false;
+ }
+ set_initialized(true);
+ }
+ return true;
+}
+
+void Win32DeviceManager::Terminate() {
+ if (initialized()) {
+ watcher()->Stop();
+ if (need_couninitialize_) {
+ CoUninitialize();
+ need_couninitialize_ = false;
+ }
+ set_initialized(false);
+ }
+}
+
+bool Win32DeviceManager::GetDefaultVideoCaptureDevice(Device* device) {
+ bool ret = false;
+ // If there are multiple capture devices, we want the first USB one.
+ // This avoids issues with defaulting to virtual cameras or grabber cards.
+ std::vector<Device> devices;
+ ret = (GetVideoCaptureDevices(&devices) && !devices.empty());
+ if (ret) {
+ *device = devices[0];
+ for (size_t i = 0; i < devices.size(); ++i) {
+ if (strnicmp(devices[i].id.c_str(), kUsbDevicePathPrefix,
+ ARRAY_SIZE(kUsbDevicePathPrefix) - 1) == 0) {
+ *device = devices[i];
+ break;
+ }
+ }
+ }
+ return ret;
+}
+
+bool Win32DeviceManager::GetAudioDevices(bool input,
+ std::vector<Device>* devs) {
+ devs->clear();
+
+ if (talk_base::IsWindowsVistaOrLater()) {
+ if (!GetCoreAudioDevices(input, devs))
+ return false;
+ } else {
+ if (!GetWaveDevices(input, devs))
+ return false;
+ }
+ return FilterDevices(devs, kFilteredAudioDevicesName);
+}
+
+bool Win32DeviceManager::GetVideoCaptureDevices(std::vector<Device>* devices) {
+ devices->clear();
+ if (!GetDevices(CLSID_VideoInputDeviceCategory, devices)) {
+ return false;
+ }
+ return FilterDevices(devices, kFilteredVideoDevicesName);
+}
+
+bool GetDevices(const CLSID& catid, std::vector<Device>* devices) {
+ HRESULT hr;
+
+ // CComPtr is a scoped pointer that will be auto released when going
+ // out of scope. CoUninitialize must not be called before the
+ // release.
+ CComPtr<ICreateDevEnum> sys_dev_enum;
+ CComPtr<IEnumMoniker> cam_enum;
+ if (FAILED(hr = sys_dev_enum.CoCreateInstance(CLSID_SystemDeviceEnum)) ||
+ FAILED(hr = sys_dev_enum->CreateClassEnumerator(catid, &cam_enum, 0))) {
+ LOG(LS_ERROR) << "Failed to create device enumerator, hr=" << hr;
+ return false;
+ }
+
+ // Only enum devices if CreateClassEnumerator returns S_OK. If there are no
+ // devices available, S_FALSE will be returned, but enumMk will be NULL.
+ if (hr == S_OK) {
+ CComPtr<IMoniker> mk;
+ while (cam_enum->Next(1, &mk, NULL) == S_OK) {
+#ifdef HAVE_LOGITECH_HEADERS
+ // Initialize Logitech device if applicable
+ MaybeLogitechDeviceReset(mk);
+#endif
+ CComPtr<IPropertyBag> bag;
+ if (SUCCEEDED(mk->BindToStorage(NULL, NULL,
+ __uuidof(bag), reinterpret_cast<void**>(&bag)))) {
+ CComVariant name, path;
+ std::string name_str, path_str;
+ if (SUCCEEDED(bag->Read(kFriendlyName, &name, 0)) &&
+ name.vt == VT_BSTR) {
+ name_str = talk_base::ToUtf8(name.bstrVal);
+ // Get the device id if one exists.
+ if (SUCCEEDED(bag->Read(kDevicePath, &path, 0)) &&
+ path.vt == VT_BSTR) {
+ path_str = talk_base::ToUtf8(path.bstrVal);
+ }
+
+ devices->push_back(Device(name_str, path_str));
+ }
+ }
+ mk = NULL;
+ }
+ }
+
+ return true;
+}
+
+HRESULT GetStringProp(IPropertyStore* bag, PROPERTYKEY key, std::string* out) {
+ out->clear();
+ PROPVARIANT var;
+ PropVariantInit(&var);
+
+ HRESULT hr = bag->GetValue(key, &var);
+ if (SUCCEEDED(hr)) {
+ if (var.pwszVal)
+ *out = talk_base::ToUtf8(var.pwszVal);
+ else
+ hr = E_FAIL;
+ }
+
+ PropVariantClear(&var);
+ return hr;
+}
+
+// Adapted from http://msdn.microsoft.com/en-us/library/dd370812(v=VS.85).aspx
+HRESULT CricketDeviceFromImmDevice(IMMDevice* device, Device* out) {
+ CComPtr<IPropertyStore> props;
+
+ HRESULT hr = device->OpenPropertyStore(STGM_READ, &props);
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ // Get the endpoint's name and id.
+ std::string name, guid;
+ hr = GetStringProp(props, PKEY_Device_FriendlyName, &name);
+ if (SUCCEEDED(hr)) {
+ hr = GetStringProp(props, PKEY_AudioEndpoint_GUID, &guid);
+
+ if (SUCCEEDED(hr)) {
+ out->name = name;
+ out->id = guid;
+ }
+ }
+ return hr;
+}
+
+bool GetCoreAudioDevices(
+ bool input, std::vector<Device>* devs) {
+ HRESULT hr = S_OK;
+ CComPtr<IMMDeviceEnumerator> enumerator;
+
+ hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_ALL,
+ __uuidof(IMMDeviceEnumerator), reinterpret_cast<void**>(&enumerator));
+ if (SUCCEEDED(hr)) {
+ CComPtr<IMMDeviceCollection> devices;
+ hr = enumerator->EnumAudioEndpoints((input ? eCapture : eRender),
+ DEVICE_STATE_ACTIVE, &devices);
+ if (SUCCEEDED(hr)) {
+ unsigned int count;
+ hr = devices->GetCount(&count);
+
+ if (SUCCEEDED(hr)) {
+ for (unsigned int i = 0; i < count; i++) {
+ CComPtr<IMMDevice> device;
+
+ // Get pointer to endpoint number i.
+ hr = devices->Item(i, &device);
+ if (FAILED(hr)) {
+ break;
+ }
+
+ Device dev;
+ hr = CricketDeviceFromImmDevice(device, &dev);
+ if (SUCCEEDED(hr)) {
+ devs->push_back(dev);
+ } else {
+ LOG(LS_WARNING) << "Unable to query IMM Device, skipping. HR="
+ << hr;
+ hr = S_FALSE;
+ }
+ }
+ }
+ }
+ }
+
+ if (FAILED(hr)) {
+ LOG(LS_WARNING) << "GetCoreAudioDevices failed with hr " << hr;
+ return false;
+ }
+ return true;
+}
+
+bool GetWaveDevices(bool input, std::vector<Device>* devs) {
+ // Note, we don't use the System Device Enumerator interface here since it
+ // adds lots of pseudo-devices to the list, such as DirectSound and Wave
+ // variants of the same device.
+ if (input) {
+ int num_devs = waveInGetNumDevs();
+ for (int i = 0; i < num_devs; ++i) {
+ WAVEINCAPS caps;
+ if (waveInGetDevCaps(i, &caps, sizeof(caps)) == MMSYSERR_NOERROR &&
+ caps.wChannels > 0) {
+ devs->push_back(Device(talk_base::ToUtf8(caps.szPname),
+ talk_base::ToString(i)));
+ }
+ }
+ } else {
+ int num_devs = waveOutGetNumDevs();
+ for (int i = 0; i < num_devs; ++i) {
+ WAVEOUTCAPS caps;
+ if (waveOutGetDevCaps(i, &caps, sizeof(caps)) == MMSYSERR_NOERROR &&
+ caps.wChannels > 0) {
+ devs->push_back(Device(talk_base::ToUtf8(caps.szPname), i));
+ }
+ }
+ }
+ return true;
+}
+
+Win32DeviceWatcher::Win32DeviceWatcher(Win32DeviceManager* manager)
+ : DeviceWatcher(manager),
+ manager_(manager),
+ audio_notify_(NULL),
+ video_notify_(NULL) {
+}
+
+Win32DeviceWatcher::~Win32DeviceWatcher() {
+}
+
+bool Win32DeviceWatcher::Start() {
+ if (!Create(NULL, _T("libjingle Win32DeviceWatcher Window"),
+ 0, 0, 0, 0, 0, 0)) {
+ return false;
+ }
+
+ audio_notify_ = Register(KSCATEGORY_AUDIO);
+ if (!audio_notify_) {
+ Stop();
+ return false;
+ }
+
+ video_notify_ = Register(KSCATEGORY_VIDEO);
+ if (!video_notify_) {
+ Stop();
+ return false;
+ }
+
+ return true;
+}
+
+void Win32DeviceWatcher::Stop() {
+ UnregisterDeviceNotification(video_notify_);
+ video_notify_ = NULL;
+ UnregisterDeviceNotification(audio_notify_);
+ audio_notify_ = NULL;
+ Destroy();
+}
+
+HDEVNOTIFY Win32DeviceWatcher::Register(REFGUID guid) {
+ DEV_BROADCAST_DEVICEINTERFACE dbdi;
+ dbdi.dbcc_size = sizeof(dbdi);
+ dbdi.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
+ dbdi.dbcc_classguid = guid;
+ dbdi.dbcc_name[0] = '\0';
+ return RegisterDeviceNotification(handle(), &dbdi,
+ DEVICE_NOTIFY_WINDOW_HANDLE);
+}
+
+void Win32DeviceWatcher::Unregister(HDEVNOTIFY handle) {
+ UnregisterDeviceNotification(handle);
+}
+
+bool Win32DeviceWatcher::OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
+ LRESULT& result) {
+ if (uMsg == WM_DEVICECHANGE) {
+ if (wParam == DBT_DEVICEARRIVAL ||
+ wParam == DBT_DEVICEREMOVECOMPLETE) {
+ DEV_BROADCAST_DEVICEINTERFACE* dbdi =
+ reinterpret_cast<DEV_BROADCAST_DEVICEINTERFACE*>(lParam);
+ if (dbdi->dbcc_classguid == KSCATEGORY_AUDIO ||
+ dbdi->dbcc_classguid == KSCATEGORY_VIDEO) {
+ manager_->SignalDevicesChange();
+ }
+ }
+ result = 0;
+ return true;
+ }
+
+ return false;
+}
+
+}; // namespace cricket
diff --git a/talk/session/phone/win32devicemanager.h b/talk/session/phone/win32devicemanager.h
new file mode 100644
index 0000000..98e73c1
--- /dev/null
+++ b/talk/session/phone/win32devicemanager.h
@@ -0,0 +1,60 @@
+/*
+ * libjingle
+ * Copyright 2004 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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_SESSION_PHONE_WIN32DEVICEMANAGER_H_
+#define TALK_SESSION_PHONE_WIN32DEVICEMANAGER_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/base/sigslot.h"
+#include "talk/base/stringencode.h"
+#include "talk/session/phone/devicemanager.h"
+
+namespace cricket {
+
+class Win32DeviceManager : public DeviceManager {
+ public:
+ Win32DeviceManager();
+ virtual ~Win32DeviceManager();
+
+ // Initialization
+ virtual bool Init();
+ virtual void Terminate();
+
+ virtual bool GetVideoCaptureDevices(std::vector<Device>* devs);
+
+ private:
+ virtual bool GetAudioDevices(bool input, std::vector<Device>* devs);
+ virtual bool GetDefaultVideoCaptureDevice(Device* device);
+
+ bool need_couninitialize_;
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_WIN32DEVICEMANAGER_H_
diff --git a/talk/session/tunnel/securetunnelsessionclient.cc b/talk/session/tunnel/securetunnelsessionclient.cc
index 84ec5e0..71f38aa 100644
--- a/talk/session/tunnel/securetunnelsessionclient.cc
+++ b/talk/session/tunnel/securetunnelsessionclient.cc
@@ -44,15 +44,16 @@
// XML elements and namespaces for XMPP stanzas used in content exchanges.
-const std::string NS_SECURE_TUNNEL("http://www.google.com/talk/securetunnel");
-const buzz::QName QN_SECURE_TUNNEL_DESCRIPTION(NS_SECURE_TUNNEL,
- "description");
-const buzz::QName QN_SECURE_TUNNEL_TYPE(NS_SECURE_TUNNEL, "type");
-const buzz::QName QN_SECURE_TUNNEL_CLIENT_CERT(NS_SECURE_TUNNEL,
- "client-cert");
-const buzz::QName QN_SECURE_TUNNEL_SERVER_CERT(NS_SECURE_TUNNEL,
- "server-cert");
-const std::string CN_SECURE_TUNNEL("securetunnel");
+const char NS_SECURE_TUNNEL[] = "http://www.google.com/talk/securetunnel";
+const buzz::StaticQName QN_SECURE_TUNNEL_DESCRIPTION =
+ { NS_SECURE_TUNNEL, "description" };
+const buzz::StaticQName QN_SECURE_TUNNEL_TYPE =
+ { NS_SECURE_TUNNEL, "type" };
+const buzz::StaticQName QN_SECURE_TUNNEL_CLIENT_CERT =
+ { NS_SECURE_TUNNEL, "client-cert" };
+const buzz::StaticQName QN_SECURE_TUNNEL_SERVER_CERT =
+ { NS_SECURE_TUNNEL, "server-cert" };
+const char CN_SECURE_TUNNEL[] = "securetunnel";
// SecureTunnelContentDescription
diff --git a/talk/session/tunnel/tunnelsessionclient.cc b/talk/session/tunnel/tunnelsessionclient.cc
index 13d5c10..05cc757 100644
--- a/talk/session/tunnel/tunnelsessionclient.cc
+++ b/talk/session/tunnel/tunnelsessionclient.cc
@@ -39,10 +39,10 @@
namespace cricket {
-const std::string NS_TUNNEL("http://www.google.com/talk/tunnel");
-const buzz::QName QN_TUNNEL_DESCRIPTION(NS_TUNNEL, "description");
-const buzz::QName QN_TUNNEL_TYPE(NS_TUNNEL, "type");
-const std::string CN_TUNNEL("tunnel");
+const char NS_TUNNEL[] = "http://www.google.com/talk/tunnel";
+const buzz::StaticQName QN_TUNNEL_DESCRIPTION = { NS_TUNNEL, "description" };
+const buzz::StaticQName QN_TUNNEL_TYPE = { NS_TUNNEL, "type" };
+const char CN_TUNNEL[] = "tunnel";
enum {
MSG_CLOCK = 1,
diff --git a/talk/session/tunnel/tunnelsessionclient_unittest.cc b/talk/session/tunnel/tunnelsessionclient_unittest.cc
new file mode 100644
index 0000000..7ead1bf
--- /dev/null
+++ b/talk/session/tunnel/tunnelsessionclient_unittest.cc
@@ -0,0 +1,235 @@
+/*
+ * libjingle
+ * Copyright 2010, 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 "talk/base/gunit.h"
+#include "talk/base/messagehandler.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/stream.h"
+#include "talk/base/thread.h"
+#include "talk/base/timeutils.h"
+#include "talk/p2p/base/sessionmanager.h"
+#include "talk/p2p/base/transport.h"
+#include "talk/p2p/client/fakeportallocator.h"
+#include "talk/session/tunnel/tunnelsessionclient.h"
+
+static const int kTimeoutMs = 10000;
+static const int kBlockSize = 4096;
+static const buzz::Jid kLocalJid("local@localhost");
+static const buzz::Jid kRemoteJid("remote@localhost");
+
+// This test fixture creates the necessary plumbing to create and run
+// two TunnelSessionClients that talk to each other.
+class TunnelSessionClientTest : public testing::Test,
+ public talk_base::MessageHandler,
+ public sigslot::has_slots<> {
+ public:
+ TunnelSessionClientTest()
+ : local_pa_(talk_base::Thread::Current(), NULL),
+ remote_pa_(talk_base::Thread::Current(), NULL),
+ local_sm_(&local_pa_, talk_base::Thread::Current()),
+ remote_sm_(&remote_pa_, talk_base::Thread::Current()),
+ local_client_(kLocalJid, &local_sm_),
+ remote_client_(kRemoteJid, &remote_sm_),
+ done_(false) {
+ local_sm_.SignalSessionCreate.connect(this,
+ &TunnelSessionClientTest::OnSessionCreate);
+ local_sm_.SignalRequestSignaling.connect(this,
+ &TunnelSessionClientTest::OnLocalRequestSignaling);
+ local_sm_.SignalOutgoingMessage.connect(this,
+ &TunnelSessionClientTest::OnOutgoingMessage);
+ remote_sm_.SignalSessionCreate.connect(this,
+ &TunnelSessionClientTest::OnSessionCreate);
+ remote_sm_.SignalRequestSignaling.connect(this,
+ &TunnelSessionClientTest::OnRemoteRequestSignaling);
+ remote_sm_.SignalOutgoingMessage.connect(this,
+ &TunnelSessionClientTest::OnOutgoingMessage);
+ remote_client_.SignalIncomingTunnel.connect(this,
+ &TunnelSessionClientTest::OnIncomingTunnel);
+ }
+
+ // Transfer the desired amount of data from the local to the remote client.
+ void TestTransfer(int size) {
+ // Create some dummy data to send.
+ send_stream_.ReserveSize(size);
+ for (int i = 0; i < size; ++i) {
+ char ch = static_cast<char>(i);
+ send_stream_.Write(&ch, 1, NULL, NULL);
+ }
+ send_stream_.Rewind();
+ // Prepare the receive stream.
+ recv_stream_.ReserveSize(size);
+ // Create the tunnel and set things in motion.
+ local_tunnel_.reset(local_client_.CreateTunnel(kRemoteJid, "test"));
+ local_tunnel_->SignalEvent.connect(this,
+ &TunnelSessionClientTest::OnStreamEvent);
+ EXPECT_TRUE_WAIT(done_, kTimeoutMs);
+ // Make sure we received the right data.
+ EXPECT_EQ(0, memcmp(send_stream_.GetBuffer(),
+ recv_stream_.GetBuffer(), size));
+ }
+
+ private:
+ enum { MSG_LSIGNAL, MSG_RSIGNAL };
+
+ // Use this callback to allow local ips for this test.
+ void OnSessionCreate(cricket::Session* session, bool incoming) {
+ session->set_allow_local_ips(true);
+ }
+
+ // There's no SessionManager* argument in this callback, so we need 2 of them.
+ void OnLocalRequestSignaling() {
+ local_sm_.OnSignalingReady();
+ }
+ void OnRemoteRequestSignaling() {
+ remote_sm_.OnSignalingReady();
+ }
+
+ // Post a message, to avoid problems with directly connecting the callbacks.
+ void OnOutgoingMessage(cricket::SessionManager* manager,
+ const buzz::XmlElement* stanza) {
+ if (manager == &local_sm_) {
+ talk_base::Thread::Current()->Post(this, MSG_LSIGNAL,
+ talk_base::WrapMessageData(*stanza));
+ } else if (manager == &remote_sm_) {
+ talk_base::Thread::Current()->Post(this, MSG_RSIGNAL,
+ talk_base::WrapMessageData(*stanza));
+ }
+ }
+
+ // Need to add a "from=" attribute (normally added by the server)
+ // Then route the incoming signaling message to the "other" session manager.
+ virtual void OnMessage(talk_base::Message* message) {
+ talk_base::TypedMessageData<buzz::XmlElement>* data =
+ static_cast<talk_base::TypedMessageData<buzz::XmlElement>*>(
+ message->pdata);
+ bool response = data->data().Attr(buzz::QN_TYPE) == buzz::STR_RESULT;
+ if (message->message_id == MSG_RSIGNAL) {
+ data->data().AddAttr(buzz::QN_FROM, remote_client_.jid().Str());
+ if (!response) {
+ local_sm_.OnIncomingMessage(&data->data());
+ } else {
+ local_sm_.OnIncomingResponse(NULL, &data->data());
+ }
+ } else if (message->message_id == MSG_LSIGNAL) {
+ data->data().AddAttr(buzz::QN_FROM, local_client_.jid().Str());
+ if (!response) {
+ remote_sm_.OnIncomingMessage(&data->data());
+ } else {
+ remote_sm_.OnIncomingResponse(NULL, &data->data());
+ }
+ }
+ delete data;
+ }
+
+ // Accept the tunnel when it arrives and wire up the stream.
+ void OnIncomingTunnel(cricket::TunnelSessionClient* client,
+ buzz::Jid jid, std::string description,
+ cricket::Session* session) {
+ remote_tunnel_.reset(remote_client_.AcceptTunnel(session));
+ remote_tunnel_->SignalEvent.connect(this,
+ &TunnelSessionClientTest::OnStreamEvent);
+ }
+
+ // Send from send_stream_ as long as we're not flow-controlled.
+ // Read bytes out into recv_stream_ as they arrive.
+ // End the test when we are notified that the local side has closed the
+ // tunnel. All data has been read out at this point.
+ void OnStreamEvent(talk_base::StreamInterface* stream, int events,
+ int error) {
+ if (events & talk_base::SE_READ) {
+ if (stream == remote_tunnel_.get()) {
+ ReadData();
+ }
+ }
+ if (events & talk_base::SE_WRITE) {
+ if (stream == local_tunnel_.get()) {
+ bool done = false;
+ WriteData(&done);
+ if (done) {
+ local_tunnel_->Close();
+ }
+ }
+ }
+ if (events & talk_base::SE_CLOSE) {
+ if (stream == remote_tunnel_.get()) {
+ remote_tunnel_->Close();
+ done_ = true;
+ }
+ }
+ }
+
+ // Spool from the tunnel into recv_stream.
+ // Flow() doesn't work here because it won't write if the read blocks.
+ void ReadData() {
+ char block[kBlockSize];
+ size_t read, position;
+ talk_base::StreamResult res;
+ while ((res = remote_tunnel_->Read(block, sizeof(block), &read, NULL)) ==
+ talk_base::SR_SUCCESS) {
+ recv_stream_.Write(block, read, NULL, NULL);
+ }
+ ASSERT(res != talk_base::SR_EOS);
+ recv_stream_.GetPosition(&position);
+ LOG(LS_VERBOSE) << "Recv position: " << position;
+ }
+ // Spool from send_stream into the tunnel. Back up if we get flow controlled.
+ void WriteData(bool* done) {
+ char block[kBlockSize];
+ size_t leftover = 0, position;
+ talk_base::StreamResult res = talk_base::Flow(&send_stream_,
+ block, sizeof(block), local_tunnel_.get(), &leftover);
+ if (res == talk_base::SR_BLOCK) {
+ send_stream_.GetPosition(&position);
+ send_stream_.SetPosition(position - leftover);
+ LOG(LS_VERBOSE) << "Send position: " << position - leftover;
+ *done = false;
+ } else if (res == talk_base::SR_SUCCESS) {
+ *done = true;
+ } else {
+ ASSERT(false); // shouldn't happen
+ }
+ }
+
+ private:
+ cricket::FakePortAllocator local_pa_;
+ cricket::FakePortAllocator remote_pa_;
+ cricket::SessionManager local_sm_;
+ cricket::SessionManager remote_sm_;
+ cricket::TunnelSessionClient local_client_;
+ cricket::TunnelSessionClient remote_client_;
+ talk_base::scoped_ptr<talk_base::StreamInterface> local_tunnel_;
+ talk_base::scoped_ptr<talk_base::StreamInterface> remote_tunnel_;
+ talk_base::MemoryStream send_stream_;
+ talk_base::MemoryStream recv_stream_;
+ bool done_;
+};
+
+// Test the normal case of sending data from one side to the other.
+TEST_F(TunnelSessionClientTest, TestTransfer) {
+ TestTransfer(1000000);
+}
diff --git a/talk/site_scons/talk.py b/talk/site_scons/talk.py
index 87650fa..2989160 100644
--- a/talk/site_scons/talk.py
+++ b/talk/site_scons/talk.py
@@ -417,15 +417,6 @@
return merged
-# Whether to enable extra 64-bit targets marked with the also64bit setting. Used
-# only for the legacy mixed 32/64 desktop Linux build.
-def EnableExtra64BitTargets(env):
- return (env.Bit('linux') and env.Bit('build_platform_64bit') and
- not env.Bit('host_platform_64bit') and
- not env.Bit('host_platform_mipsel')
- )
-
-
def MergeSettingsFromLibraryDependencies(env, params):
if 'libs' in params:
for lib in params['libs']:
@@ -523,13 +514,6 @@
if values is not None:
env.Prepend(**{var : values})
- # workaround for pulse stripping link flag for unknown reason
- if EnableExtra64BitTargets(env):
- env['SHLINKCOM'] = ('$SHLINK -o $TARGET -m32 $SHLINKFLAGS $SOURCES '
- '$_LIBDIRFLAGS $_LIBFLAGS')
- env['LINKCOM'] = ('$LINK -o $TARGET -m32 $LINKFLAGS $SOURCES '
- '$_LIBDIRFLAGS $_LIBFLAGS')
-
# any other parameters are replaced without renaming
for field, value in params.items():
env.Replace(**{field : value})
@@ -556,36 +540,7 @@
node = builder(name, srcs)
- # make a parallel 64bit version if requested
- if EnableExtra64BitTargets(env) and PopEntry(params, 'also64bit'):
- env_64bit = env.Clone()
- env_64bit.FilterOut(CCFLAGS = ['-m32'], LINKFLAGS = ['-m32'])
- env_64bit.Prepend(CCFLAGS = ['-m64', '-fPIC'], LINKFLAGS = ['-m64'])
- name_64bit = name + '64'
- env_64bit.Replace(OBJSUFFIX = '64' + env_64bit['OBJSUFFIX'])
- env_64bit.Replace(SHOBJSUFFIX = '64' + env_64bit['SHOBJSUFFIX'])
- if ('ComponentProgram' == component or
- ('ComponentLibrary' == component and
- env_64bit['COMPONENT_STATIC'] == False)):
- # link 64 bit versions of libraries
- libs = []
- for lib in env_64bit['LIBS']:
- libparams = _GetLibParams(env, lib)
- if libparams and 'also64bit' in libparams:
- libs.append(lib + '64')
- else:
- libs.append(lib)
- env_64bit.Replace(LIBS = libs)
-
- env_64bit['SHLINKCOM'] = ('$SHLINK -o $TARGET -m64 $SHLINKFLAGS $SOURCES '
- '$_LIBDIRFLAGS $_LIBFLAGS')
- env_64bit['LINKCOM'] = ('$LINK -o $TARGET -m64 $LINKFLAGS $SOURCES '
- '$_LIBDIRFLAGS $_LIBFLAGS')
- builder = getattr(env_64bit, component)
- nodes = [node, builder(name_64bit, srcs)]
- return nodes
-
- if signed: # Note currently incompatible with 64Bit flag
+ if signed:
# Get the name of the built binary, then get the name of the final signed
# version from it. We need the output path since we don't know the file
# extension beforehand.
diff --git a/talk/sound/alsasoundsystem.cc b/talk/sound/alsasoundsystem.cc
index fdfb800..c6dc73a 100644
--- a/talk/sound/alsasoundsystem.cc
+++ b/talk/sound/alsasoundsystem.cc
@@ -31,6 +31,7 @@
#include "talk/base/logging.h"
#include "talk/base/scoped_ptr.h"
#include "talk/base/stringutils.h"
+#include "talk/base/timeutils.h"
#include "talk/base/worker.h"
#include "talk/sound/sounddevicelocator.h"
#include "talk/sound/soundinputstreaminterface.h"
@@ -59,9 +60,6 @@
// The latency we'll use for kNoLatencyRequirements (chosen arbitrarily).
static const int kDefaultLatencyUsecs = kMinimumLatencyUsecs * 2;
-static const int kUsecsPerSec = 1000000;
-static const int kUsecsPerMsec = 1000;
-
// We translate newlines in ALSA device descriptions to hyphens.
static const char kAlsaDescriptionSearch[] = "\n";
static const char kAlsaDescriptionReplace[] = " - ";
@@ -172,7 +170,7 @@
return 0;
}
// The delay is in frames. Convert to microseconds.
- return delay * kUsecsPerSec / freq_;
+ return delay * talk_base::kNumMicrosecsPerSec / freq_;
}
// Used to recover from certain recoverable errors, principally buffer overrun
@@ -656,7 +654,7 @@
int freq)) {
if (!IsInitialized()) {
- return false;
+ return NULL;
}
StreamInterface *stream;
@@ -686,7 +684,7 @@
} else {
// kLowLatency is 0, so we treat it the same as a request for zero latency.
// Compute what the user asked for.
- latency = kUsecsPerSec *
+ latency = talk_base::kNumMicrosecsPerSec *
params.latency /
params.freq /
FrameSize(params);
@@ -721,7 +719,7 @@
FrameSize(params),
// We set the wait time to twice the requested latency, so that wait
// timeouts should be rare.
- 2 * latency / kUsecsPerMsec,
+ 2 * latency / talk_base::kNumMicrosecsPerMillisec,
params.flags,
params.freq);
if (stream) {
diff --git a/talk/sound/automaticallychosensoundsystem_unittest.cc b/talk/sound/automaticallychosensoundsystem_unittest.cc
new file mode 100644
index 0000000..a8afeec
--- /dev/null
+++ b/talk/sound/automaticallychosensoundsystem_unittest.cc
@@ -0,0 +1,214 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, 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/base/gunit.h"
+#include "talk/sound/automaticallychosensoundsystem.h"
+#include "talk/sound/nullsoundsystem.h"
+
+namespace cricket {
+
+class NeverFailsToFailSoundSystem : public NullSoundSystem {
+ public:
+ // Overrides superclass.
+ virtual bool Init() {
+ return false;
+ }
+
+ static SoundSystemInterface *Create() {
+ return new NeverFailsToFailSoundSystem();
+ }
+};
+
+class InitCheckingSoundSystem1 : public NullSoundSystem {
+ public:
+ // Overrides superclass.
+ virtual bool Init() {
+ created_ = true;
+ return true;
+ }
+
+ static SoundSystemInterface *Create() {
+ return new InitCheckingSoundSystem1();
+ }
+
+ static bool created_;
+};
+
+bool InitCheckingSoundSystem1::created_ = false;
+
+class InitCheckingSoundSystem2 : public NullSoundSystem {
+ public:
+ // Overrides superclass.
+ virtual bool Init() {
+ created_ = true;
+ return true;
+ }
+
+ static SoundSystemInterface *Create() {
+ return new InitCheckingSoundSystem2();
+ }
+
+ static bool created_;
+};
+
+bool InitCheckingSoundSystem2::created_ = false;
+
+class DeletionCheckingSoundSystem1 : public NeverFailsToFailSoundSystem {
+ public:
+ virtual ~DeletionCheckingSoundSystem1() {
+ deleted_ = true;
+ }
+
+ static SoundSystemInterface *Create() {
+ return new DeletionCheckingSoundSystem1();
+ }
+
+ static bool deleted_;
+};
+
+bool DeletionCheckingSoundSystem1::deleted_ = false;
+
+class DeletionCheckingSoundSystem2 : public NeverFailsToFailSoundSystem {
+ public:
+ virtual ~DeletionCheckingSoundSystem2() {
+ deleted_ = true;
+ }
+
+ static SoundSystemInterface *Create() {
+ return new DeletionCheckingSoundSystem2();
+ }
+
+ static bool deleted_;
+};
+
+bool DeletionCheckingSoundSystem2::deleted_ = false;
+
+class DeletionCheckingSoundSystem3 : public NullSoundSystem {
+ public:
+ virtual ~DeletionCheckingSoundSystem3() {
+ deleted_ = true;
+ }
+
+ static SoundSystemInterface *Create() {
+ return new DeletionCheckingSoundSystem3();
+ }
+
+ static bool deleted_;
+};
+
+bool DeletionCheckingSoundSystem3::deleted_ = false;
+
+extern const SoundSystemCreator kSingleSystemFailingCreators[] = {
+ &NeverFailsToFailSoundSystem::Create,
+};
+
+TEST(AutomaticallyChosenSoundSystem, SingleSystemFailing) {
+ AutomaticallyChosenSoundSystem<
+ kSingleSystemFailingCreators,
+ ARRAY_SIZE(kSingleSystemFailingCreators)> sound_system;
+ EXPECT_FALSE(sound_system.Init());
+}
+
+extern const SoundSystemCreator kSingleSystemSucceedingCreators[] = {
+ &NullSoundSystem::Create,
+};
+
+TEST(AutomaticallyChosenSoundSystem, SingleSystemSucceeding) {
+ AutomaticallyChosenSoundSystem<
+ kSingleSystemSucceedingCreators,
+ ARRAY_SIZE(kSingleSystemSucceedingCreators)> sound_system;
+ EXPECT_TRUE(sound_system.Init());
+}
+
+extern const SoundSystemCreator
+ kFailedFirstSystemResultsInUsingSecondCreators[] = {
+ &NeverFailsToFailSoundSystem::Create,
+ &NullSoundSystem::Create,
+};
+
+TEST(AutomaticallyChosenSoundSystem, FailedFirstSystemResultsInUsingSecond) {
+ AutomaticallyChosenSoundSystem<
+ kFailedFirstSystemResultsInUsingSecondCreators,
+ ARRAY_SIZE(kFailedFirstSystemResultsInUsingSecondCreators)> sound_system;
+ EXPECT_TRUE(sound_system.Init());
+}
+
+extern const SoundSystemCreator kEarlierEntriesHavePriorityCreators[] = {
+ &InitCheckingSoundSystem1::Create,
+ &InitCheckingSoundSystem2::Create,
+};
+
+TEST(AutomaticallyChosenSoundSystem, EarlierEntriesHavePriority) {
+ AutomaticallyChosenSoundSystem<
+ kEarlierEntriesHavePriorityCreators,
+ ARRAY_SIZE(kEarlierEntriesHavePriorityCreators)> sound_system;
+ InitCheckingSoundSystem1::created_ = false;
+ InitCheckingSoundSystem2::created_ = false;
+ EXPECT_TRUE(sound_system.Init());
+ EXPECT_TRUE(InitCheckingSoundSystem1::created_);
+ EXPECT_FALSE(InitCheckingSoundSystem2::created_);
+}
+
+extern const SoundSystemCreator kManySoundSystemsCreators[] = {
+ &NullSoundSystem::Create,
+ &NullSoundSystem::Create,
+ &NullSoundSystem::Create,
+ &NullSoundSystem::Create,
+ &NullSoundSystem::Create,
+ &NullSoundSystem::Create,
+ &NullSoundSystem::Create,
+};
+
+TEST(AutomaticallyChosenSoundSystem, ManySoundSystems) {
+ AutomaticallyChosenSoundSystem<
+ kManySoundSystemsCreators,
+ ARRAY_SIZE(kManySoundSystemsCreators)> sound_system;
+ EXPECT_TRUE(sound_system.Init());
+}
+
+extern const SoundSystemCreator kDeletesAllCreatedSoundSystemsCreators[] = {
+ &DeletionCheckingSoundSystem1::Create,
+ &DeletionCheckingSoundSystem2::Create,
+ &DeletionCheckingSoundSystem3::Create,
+};
+
+TEST(AutomaticallyChosenSoundSystem, DeletesAllCreatedSoundSystems) {
+ typedef AutomaticallyChosenSoundSystem<
+ kDeletesAllCreatedSoundSystemsCreators,
+ ARRAY_SIZE(kDeletesAllCreatedSoundSystemsCreators)> TestSoundSystem;
+ TestSoundSystem *sound_system = new TestSoundSystem();
+ DeletionCheckingSoundSystem1::deleted_ = false;
+ DeletionCheckingSoundSystem2::deleted_ = false;
+ DeletionCheckingSoundSystem3::deleted_ = false;
+ EXPECT_TRUE(sound_system->Init());
+ delete sound_system;
+ EXPECT_TRUE(DeletionCheckingSoundSystem1::deleted_);
+ EXPECT_TRUE(DeletionCheckingSoundSystem2::deleted_);
+ EXPECT_TRUE(DeletionCheckingSoundSystem3::deleted_);
+}
+
+} // namespace cricket
diff --git a/talk/sound/pulseaudiosoundsystem.cc b/talk/sound/pulseaudiosoundsystem.cc
index 3b45f8c..4ccedc1 100644
--- a/talk/sound/pulseaudiosoundsystem.cc
+++ b/talk/sound/pulseaudiosoundsystem.cc
@@ -39,6 +39,7 @@
#include "talk/base/fileutils.h" // for GetApplicationName()
#include "talk/base/logging.h"
#include "talk/base/worker.h"
+#include "talk/base/timeutils.h"
#include "talk/sound/sounddevicelocator.h"
#include "talk/sound/soundinputstreaminterface.h"
#include "talk/sound/soundoutputstreaminterface.h"
@@ -48,13 +49,6 @@
// First PulseAudio protocol version that supports PA_STREAM_ADJUST_LATENCY.
static const uint32_t kAdjustLatencyProtocolVersion = 13;
-// We define this flag if it's missing from our headers, because we want to be
-// able to compile against old headers but still use PA_STREAM_ADJUST_LATENCY
-// if run against a recent version of the library.
-#ifndef PA_STREAM_ADJUST_LATENCY
-#define PA_STREAM_ADJUST_LATENCY 0x2000U
-#endif
-
// Lookup table from the cricket format enum in soundsysteminterface.h to
// Pulse's enums.
static const pa_sample_format_t kCricketFormatToPulseFormatTable[] = {
@@ -99,8 +93,6 @@
// kNoLatencyRequirements case.)
static const int kCaptureBufferExtraMsecs = 750;
-static const int kMsecsPerSec = 1000;
-
static void FillPlaybackBufferAttr(int latency,
pa_buffer_attr *attr) {
attr->maxlength = latency;
@@ -909,7 +901,8 @@
size_t bytes_per_sec = LATE(pa_bytes_per_second)(spec);
int new_latency = configured_latency_ +
- bytes_per_sec * kPlaybackLatencyIncrementMsecs / kMsecsPerSec;
+ bytes_per_sec * kPlaybackLatencyIncrementMsecs /
+ talk_base::kNumMicrosecsPerSec;
pa_buffer_attr new_attr = {0};
FillPlaybackBufferAttr(new_latency, &new_attr);
@@ -1468,7 +1461,8 @@
latency = talk_base::_max(
latency,
static_cast<int>(
- bytes_per_sec * kPlaybackLatencyMinimumMsecs / kMsecsPerSec));
+ bytes_per_sec * kPlaybackLatencyMinimumMsecs /
+ talk_base::kNumMicrosecsPerSec));
FillPlaybackBufferAttr(latency, &attr);
pattr = &attr;
}
@@ -1498,13 +1492,14 @@
if (latency != kNoLatencyRequirements) {
size_t bytes_per_sec = LATE(pa_bytes_per_second)(&spec);
if (latency == kLowLatency) {
- latency = bytes_per_sec * kLowCaptureLatencyMsecs / kMsecsPerSec;
+ latency = bytes_per_sec * kLowCaptureLatencyMsecs /
+ talk_base::kNumMicrosecsPerSec;
}
// Note: fragsize specifies a maximum transfer size, not a minimum, so it is
// not possible to force a high latency setting, only a low one.
attr.fragsize = latency;
- attr.maxlength = latency +
- bytes_per_sec * kCaptureBufferExtraMsecs / kMsecsPerSec;
+ attr.maxlength = latency + bytes_per_sec * kCaptureBufferExtraMsecs /
+ talk_base::kNumMicrosecsPerSec;
LOG(LS_VERBOSE) << "Configuring latency = " << attr.fragsize
<< ", maxlength = " << attr.maxlength;
pattr = &attr;
diff --git a/talk/xmllite/qname.cc b/talk/xmllite/qname.cc
index 7486524..0dadb79 100644
--- a/talk/xmllite/qname.cc
+++ b/talk/xmllite/qname.cc
@@ -25,138 +25,71 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include <string>
-#include "talk/base/common.h"
-#include "talk/xmllite/xmlelement.h"
#include "talk/xmllite/qname.h"
-#include "talk/xmllite/xmlconstants.h"
namespace buzz {
-static int QName_Hash(const std::string & ns, const char * local) {
- int result = static_cast<int>(ns.size()) * 101;
- while (*local) {
- result *= 19;
- result += *local;
- local += 1;
- }
- return result;
+QName::QName() {
}
-static const int bits = 9;
-static QName::Data * get_qname_table() {
- static QName::Data qname_table[1 << bits];
- return qname_table;
+QName::QName(const QName& qname)
+ : namespace_(qname.namespace_),
+ local_part_(qname.local_part_) {
}
-static QName::Data *
-AllocateOrFind(const std::string & ns, const char * local) {
- int index = QName_Hash(ns, local);
- int increment = index >> (bits - 1) | 1;
- QName::Data * qname_table = get_qname_table();
- for (;;) {
- index &= ((1 << bits) - 1);
- if (!qname_table[index].Occupied()) {
- return new QName::Data(ns, local);
- }
- if (qname_table[index].localPart_ == local &&
- qname_table[index].namespace_ == ns) {
- qname_table[index].AddRef();
- return qname_table + index;
- }
- index += increment;
- }
+QName::QName(const StaticQName& const_value)
+ : namespace_(const_value.ns),
+ local_part_(const_value.local) {
}
-static QName::Data *
-Add(const std::string & ns, const char * local) {
- int index = QName_Hash(ns, local);
- int increment = index >> (bits - 1) | 1;
- QName::Data * qname_table = get_qname_table();
- for (;;) {
- index &= ((1 << bits) - 1);
- if (!qname_table[index].Occupied()) {
- qname_table[index].namespace_ = ns;
- qname_table[index].localPart_ = local;
- qname_table[index].AddRef(); // AddRef twice so it's never deleted
- qname_table[index].AddRef();
- return qname_table + index;
- }
- if (qname_table[index].localPart_ == local &&
- qname_table[index].namespace_ == ns) {
- qname_table[index].AddRef();
- return qname_table + index;
- }
- index += increment;
+QName::QName(const std::string& ns, const std::string& local)
+ : namespace_(ns),
+ local_part_(local) {
+}
+
+QName::QName(const std::string& merged_or_local) {
+ size_t i = merged_or_local.rfind(':');
+ if (i == std::string::npos) {
+ local_part_ = merged_or_local;
+ } else {
+ namespace_ = merged_or_local.substr(0, i);
+ local_part_ = merged_or_local.substr(i + 1);
}
}
QName::~QName() {
- data_->Release();
}
-QName::QName() : data_(QN_EMPTY.data_) {
- data_->AddRef();
-}
+std::string QName::Merged() const {
+ if (namespace_[0] == '\0')
+ return local_part_;
-QName::QName(bool add, const std::string & ns, const char * local) :
- data_(add ? Add(ns, local) : AllocateOrFind(ns, local)) {}
-
-QName::QName(bool add, const std::string & ns, const std::string & local) :
- data_(add ? Add(ns, local.c_str()) : AllocateOrFind(ns, local.c_str())) {}
-
-QName::QName(const std::string & ns, const char * local) :
- data_(AllocateOrFind(ns, local)) {}
-
-static std::string
-QName_LocalPart(const std::string & name) {
- size_t i = name.rfind(':');
- if (i == std::string::npos)
- return name;
- return name.substr(i + 1);
-}
-
-static std::string
-QName_Namespace(const std::string & name) {
- size_t i = name.rfind(':');
- if (i == std::string::npos)
- return STR_EMPTY;
- return name.substr(0, i);
-}
-
-QName::QName(const std::string & mergedOrLocal) :
- data_(AllocateOrFind(QName_Namespace(mergedOrLocal),
- QName_LocalPart(mergedOrLocal).c_str())) {}
-
-std::string
-QName::Merged() const {
- if (data_->namespace_ == STR_EMPTY)
- return data_->localPart_;
-
- std::string result(data_->namespace_);
- result.reserve(result.length() + 1 + data_->localPart_.length());
+ std::string result;
+ result.reserve(namespace_.length() + 1 + local_part_.length());
+ result += namespace_;
result += ':';
- result += data_->localPart_;
+ result += local_part_;
return result;
}
-bool
-QName::operator==(const QName & other) const {
- return other.data_ == data_ ||
- (data_->localPart_ == other.data_->localPart_ &&
- data_->namespace_ == other.data_->namespace_);
+bool QName::IsEmpty() const {
+ return namespace_.empty() && local_part_.empty();
}
-int
-QName::Compare(const QName & other) const {
- if (data_ == other.data_)
- return 0;
-
- int result = data_->localPart_.compare(other.data_->localPart_);
- if (result)
+int QName::Compare(const StaticQName& other) const {
+ int result = local_part_.compare(other.local);
+ if (result != 0)
return result;
- return data_->namespace_.compare(other.data_->namespace_);
+ return namespace_.compare(other.ns);
}
+int QName::Compare(const QName& other) const {
+ int result = local_part_.compare(other.local_part_);
+ if (result != 0)
+ return result;
+
+ return namespace_.compare(other.namespace_);
}
+
+} // namespace buzz
diff --git a/talk/xmllite/qname.h b/talk/xmllite/qname.h
index 172a067..92e54d0 100644
--- a/talk/xmllite/qname.h
+++ b/talk/xmllite/qname.h
@@ -2,87 +2,99 @@
* libjingle
* Copyright 2004--2005, Google Inc.
*
- * Redistribution and use in source and binary forms, with or without
+ * 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,
+ * 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
+ * 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
+ * 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,
+ * 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
+ * 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 _qname_h_
-#define _qname_h_
+#ifndef TALK_XMLLITE_QNAME_H_
+#define TALK_XMLLITE_QNAME_H_
#include <string>
-#include "talk/base/criticalsection.h"
namespace buzz {
+class QName;
-class QName
-{
-public:
- explicit QName();
- QName(const QName & qname) : data_(qname.data_) { data_->AddRef(); }
- explicit QName(bool add, const std::string & ns, const char * local);
- explicit QName(bool add, const std::string & ns, const std::string & local);
- explicit QName(const std::string & ns, const char * local);
- explicit QName(const std::string & mergedOrLocal);
- QName & operator=(const QName & qn) {
- qn.data_->AddRef();
- data_->Release();
- data_ = qn.data_;
- return *this;
- }
- ~QName();
+// StaticQName is used to represend constant quailified names. They
+// can be initialized statically and don't need intializers code, e.g.
+// const StaticQName QN_FOO = { "foo_namespace", "foo" };
+//
+// Beside this use case, QName should be used everywhere
+// else. StaticQName instances are implicitly converted to QName
+// objects.
+struct StaticQName {
+ const char* const ns;
+ const char* const local;
- const std::string & Namespace() const { return data_->namespace_; }
- const std::string & LocalPart() const { return data_->localPart_; }
- std::string Merged() const;
- int Compare(const QName & other) const;
- bool operator==(const QName & other) const;
- bool operator!=(const QName & other) const { return !operator==(other); }
- bool operator<(const QName & other) const { return Compare(other) < 0; }
-
- class Data {
- public:
- Data(const std::string & ns, const std::string & local) :
- namespace_(ns),
- localPart_(local),
- refcount_(1) {}
-
- Data() : refcount_(0) {}
-
- std::string namespace_;
- std::string localPart_;
- void AddRef() { talk_base::AtomicOps::Increment(&refcount_); }
- void Release() { if (!talk_base::AtomicOps::Decrement(&refcount_)) { delete this; } }
- bool Occupied() { return !!refcount_; }
-
- private:
- int refcount_;
- };
-
-private:
- Data * data_;
+ bool operator==(const QName& other) const;
+ bool operator!=(const QName& other) const;
};
+class QName {
+ public:
+ QName();
+ QName(const QName& qname);
+ QName(const StaticQName& const_value);
+ QName(const std::string& ns, const std::string& local);
+ explicit QName(const std::string& merged_or_local);
+ ~QName();
+ const std::string& Namespace() const { return namespace_; }
+ const std::string& LocalPart() const { return local_part_; }
+ std::string Merged() const;
+ bool IsEmpty() const;
+
+ int Compare(const StaticQName& other) const;
+ int Compare(const QName& other) const;
+
+ bool operator==(const StaticQName& other) const {
+ return Compare(other) == 0;
+ }
+ bool operator==(const QName& other) const {
+ return Compare(other) == 0;
+ }
+ bool operator!=(const StaticQName& other) const {
+ return Compare(other) != 0;
+ }
+ bool operator!=(const QName& other) const {
+ return Compare(other) != 0;
+ }
+ bool operator<(const QName& other) const {
+ return Compare(other) < 0;
+ }
+
+ private:
+ std::string namespace_;
+ std::string local_part_;
+};
+
+inline bool StaticQName::operator==(const QName& other) const {
+ return other.Compare(*this) == 0;
}
-#endif
+inline bool StaticQName::operator!=(const QName& other) const {
+ return other.Compare(*this) != 0;
+}
+
+} // namespace buzz
+
+#endif // TALK_XMLLITE_QNAME_H_
diff --git a/talk/xmllite/qname_unittest.cc b/talk/xmllite/qname_unittest.cc
new file mode 100644
index 0000000..976d822
--- /dev/null
+++ b/talk/xmllite/qname_unittest.cc
@@ -0,0 +1,131 @@
+/*
+ * libjingle
+ * Copyright 2004, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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 "talk/base/gunit.h"
+#include "talk/xmllite/qname.h"
+
+using buzz::StaticQName;
+using buzz::QName;
+
+TEST(QNameTest, TestTrivial) {
+ QName name("test");
+ EXPECT_EQ(name.LocalPart(), "test");
+ EXPECT_EQ(name.Namespace(), "");
+}
+
+TEST(QNameTest, TestSplit) {
+ QName name("a:test");
+ EXPECT_EQ(name.LocalPart(), "test");
+ EXPECT_EQ(name.Namespace(), "a");
+ QName name2("a-very:long:namespace:test-this");
+ EXPECT_EQ(name2.LocalPart(), "test-this");
+ EXPECT_EQ(name2.Namespace(), "a-very:long:namespace");
+}
+
+TEST(QNameTest, TestMerge) {
+ QName name("a", "test");
+ EXPECT_EQ(name.LocalPart(), "test");
+ EXPECT_EQ(name.Namespace(), "a");
+ EXPECT_EQ(name.Merged(), "a:test");
+ QName name2("a-very:long:namespace", "test-this");
+ EXPECT_EQ(name2.LocalPart(), "test-this");
+ EXPECT_EQ(name2.Namespace(), "a-very:long:namespace");
+ EXPECT_EQ(name2.Merged(), "a-very:long:namespace:test-this");
+}
+
+TEST(QNameTest, TestAssignment) {
+ QName name("a", "test");
+ // copy constructor
+ QName namecopy(name);
+ EXPECT_EQ(namecopy.LocalPart(), "test");
+ EXPECT_EQ(namecopy.Namespace(), "a");
+ QName nameassigned("");
+ nameassigned = name;
+ EXPECT_EQ(nameassigned.LocalPart(), "test");
+ EXPECT_EQ(nameassigned.Namespace(), "a");
+}
+
+TEST(QNameTest, TestConstAssignment) {
+ StaticQName name = { "a", "test" };
+ QName namecopy(name);
+ EXPECT_EQ(namecopy.LocalPart(), "test");
+ EXPECT_EQ(namecopy.Namespace(), "a");
+ QName nameassigned("");
+ nameassigned = name;
+ EXPECT_EQ(nameassigned.LocalPart(), "test");
+ EXPECT_EQ(nameassigned.Namespace(), "a");
+}
+
+TEST(QNameTest, TestEquality) {
+ QName name("a-very:long:namespace:test-this");
+ QName name2("a-very:long:namespace", "test-this");
+ QName name3("a-very:long:namespaxe", "test-this");
+ EXPECT_TRUE(name == name2);
+ EXPECT_FALSE(name == name3);
+}
+
+TEST(QNameTest, TestCompare) {
+ QName name("a");
+ QName name2("nsa", "a");
+ QName name3("nsa", "b");
+ QName name4("nsb", "b");
+
+ EXPECT_TRUE(name < name2);
+ EXPECT_FALSE(name2 < name);
+
+ EXPECT_FALSE(name2 < name2);
+
+ EXPECT_TRUE(name2 < name3);
+ EXPECT_FALSE(name3 < name2);
+
+ EXPECT_TRUE(name3 < name4);
+ EXPECT_FALSE(name4 < name3);
+}
+
+TEST(QNameTest, TestStaticQName) {
+ const StaticQName const_name1 = { "namespace", "local-name1" };
+ const StaticQName const_name2 = { "namespace", "local-name2" };
+ const QName name("namespace", "local-name1");
+ const QName name1 = const_name1;
+ const QName name2 = const_name2;
+
+ EXPECT_TRUE(name == const_name1);
+ EXPECT_TRUE(const_name1 == name);
+ EXPECT_FALSE(name != const_name1);
+ EXPECT_FALSE(const_name1 != name);
+
+ EXPECT_TRUE(name == name1);
+ EXPECT_TRUE(name1 == name);
+ EXPECT_FALSE(name != name1);
+ EXPECT_FALSE(name1 != name);
+
+ EXPECT_FALSE(name == name2);
+ EXPECT_FALSE(name2 == name);
+ EXPECT_TRUE(name != name2);
+ EXPECT_TRUE(name2 != name);
+}
diff --git a/talk/xmllite/xmlbuilder.cc b/talk/xmllite/xmlbuilder.cc
index 75daa57..486b6d5 100644
--- a/talk/xmllite/xmlbuilder.cc
+++ b/talk/xmllite/xmlbuilder.cc
@@ -30,6 +30,7 @@
#include <vector>
#include <set>
#include "talk/base/common.h"
+#include "talk/xmllite/xmlconstants.h"
#include "talk/xmllite/xmlelement.h"
namespace buzz {
@@ -51,7 +52,7 @@
XmlBuilder::BuildElement(XmlParseContext * pctx,
const char * name, const char ** atts) {
QName tagName(pctx->ResolveQName(name, false));
- if (tagName == QN_EMPTY)
+ if (tagName.IsEmpty())
return NULL;
XmlElement * pelNew = new XmlElement(tagName);
@@ -63,7 +64,7 @@
while (*atts) {
QName attName(pctx->ResolveQName(*atts, true));
- if (attName == QN_EMPTY) {
+ if (attName.IsEmpty()) {
delete pelNew;
return NULL;
}
@@ -143,6 +144,4 @@
XmlBuilder::~XmlBuilder() {
}
-
-
-}
+} // namespace buzz
diff --git a/talk/xmllite/xmlbuilder_unittest.cc b/talk/xmllite/xmlbuilder_unittest.cc
new file mode 100644
index 0000000..9302276
--- /dev/null
+++ b/talk/xmllite/xmlbuilder_unittest.cc
@@ -0,0 +1,194 @@
+/*
+ * libjingle
+ * Copyright 2004, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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 <sstream>
+#include <iostream>
+#include "talk/base/common.h"
+#include "talk/base/gunit.h"
+#include "talk/xmllite/xmlbuilder.h"
+#include "talk/xmllite/xmlelement.h"
+#include "talk/xmllite/xmlparser.h"
+
+using buzz::XmlBuilder;
+using buzz::XmlElement;
+using buzz::XmlParser;
+
+TEST(XmlBuilderTest, TestTrivial) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing/>");
+ EXPECT_EQ("<testing/>", builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestAttributes1) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing a='b'/>");
+ EXPECT_EQ("<testing a=\"b\"/>", builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestAttributes2) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing e='' long='some text'/>");
+ EXPECT_EQ("<testing e=\"\" long=\"some text\"/>",
+ builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestNesting1) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder,
+ "<top><first/><second><third></third></second></top>");
+ EXPECT_EQ("<top><first/><second><third/></second></top>",
+ builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestNesting2) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder,
+ "<top><fifth><deeper><and><deeper/></and><sibling><leaf/>"
+ "</sibling></deeper></fifth><first/><second><third></third>"
+ "</second></top>");
+ EXPECT_EQ("<top><fifth><deeper><and><deeper/></and><sibling><leaf/>"
+ "</sibling></deeper></fifth><first/><second><third/>"
+ "</second></top>", builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestQuoting1) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing a='>'/>");
+ EXPECT_EQ("<testing a=\">\"/>", builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestQuoting2) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing a='<>&"'/>");
+ EXPECT_EQ("<testing a=\"<>&"\"/>",
+ builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestQuoting3) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing a='so "important"'/>");
+ EXPECT_EQ("<testing a=\"so "important"\"/>",
+ builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestQuoting4) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing a='"important", yes'/>");
+ EXPECT_EQ("<testing a=\""important", yes\"/>",
+ builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestQuoting5) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder,
+ "<testing a='<what is "important">'/>");
+ EXPECT_EQ("<testing a=\"<what is "important">\"/>",
+ builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestText1) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing>></testing>");
+ EXPECT_EQ("<testing>></testing>", builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestText2) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing><>&"</testing>");
+ EXPECT_EQ("<testing><>&\"</testing>",
+ builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestText3) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing>so <important></testing>");
+ EXPECT_EQ("<testing>so <important></testing>",
+ builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestText4) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing><important>, yes</testing>");
+ EXPECT_EQ("<testing><important>, yes</testing>",
+ builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestText5) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder,
+ "<testing>importance &<important>&</testing>");
+ EXPECT_EQ("<testing>importance &<important>&</testing>",
+ builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestNamespace1) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing xmlns='foo'/>");
+ EXPECT_EQ("<testing xmlns=\"foo\"/>", builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestNamespace2) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing xmlns:a='foo' a:b='c'/>");
+ EXPECT_EQ("<testing xmlns:a=\"foo\" a:b=\"c\"/>",
+ builder.BuiltElement()->Str());
+}
+
+TEST(XmlBuilderTest, TestNamespace3) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing xmlns:a=''/>");
+ EXPECT_TRUE(NULL == builder.BuiltElement());
+}
+
+TEST(XmlBuilderTest, TestNamespace4) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing a:b='c'/>");
+ EXPECT_TRUE(NULL == builder.BuiltElement());
+}
+
+TEST(XmlBuilderTest, TestAttrCollision1) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder, "<testing a='first' a='second'/>");
+ EXPECT_TRUE(NULL == builder.BuiltElement());
+}
+
+TEST(XmlBuilderTest, TestAttrCollision2) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder,
+ "<testing xmlns:a='foo' xmlns:b='foo' a:x='c' b:x='d'/>");
+ EXPECT_TRUE(NULL == builder.BuiltElement());
+}
+
+TEST(XmlBuilderTest, TestAttrCollision3) {
+ XmlBuilder builder;
+ XmlParser::ParseXml(&builder,
+ "<testing xmlns:a='foo'><nested xmlns:b='foo' a:x='c' b:x='d'/>"
+ "</testing>");
+ EXPECT_TRUE(NULL == builder.BuiltElement());
+}
+
diff --git a/talk/xmllite/xmlconstants.cc b/talk/xmllite/xmlconstants.cc
index 503f832..f94d779 100644
--- a/talk/xmllite/xmlconstants.cc
+++ b/talk/xmllite/xmlconstants.cc
@@ -2,64 +2,41 @@
* libjingle
* Copyright 2004--2005, Google Inc.
*
- * Redistribution and use in source and binary forms, with or without
+ * 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,
+ * 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
+ * 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
+ * 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,
+ * 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
+ * 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 "xmlconstants.h"
+#include "talk/xmllite/xmlconstants.h"
-using namespace buzz;
+namespace buzz {
-const std::string & XmlConstants::str_empty() {
- static const std::string str_empty_;
- return str_empty_;
-}
+const char STR_EMPTY[] = "";
+const char NS_XML[] = "http://www.w3.org/XML/1998/namespace";
+const char NS_XMLNS[] = "http://www.w3.org/2000/xmlns/";
+const char STR_XMLNS[] = "xmlns";
+const char STR_XML[] = "xml";
+const char STR_VERSION[] = "version";
+const char STR_ENCODING[] = "encoding";
-const std::string & XmlConstants::ns_xml() {
- static const std::string ns_xml_("http://www.w3.org/XML/1998/namespace");
- return ns_xml_;
-}
+const StaticQName QN_XMLNS = { STR_EMPTY, STR_XMLNS };
-const std::string & XmlConstants::ns_xmlns() {
- static const std::string ns_xmlns_("http://www.w3.org/2000/xmlns/");
- return ns_xmlns_;
-}
-
-const std::string & XmlConstants::str_xmlns() {
- static const std::string str_xmlns_("xmlns");
- return str_xmlns_;
-}
-
-const std::string & XmlConstants::str_xml() {
- static const std::string str_xml_("xml");
- return str_xml_;
-}
-
-const std::string & XmlConstants::str_version() {
- static const std::string str_version_("version");
- return str_version_;
-}
-
-const std::string & XmlConstants::str_encoding() {
- static const std::string str_encoding_("encoding");
- return str_encoding_;
-}
+} // namespace buzz
diff --git a/talk/xmllite/xmlconstants.h b/talk/xmllite/xmlconstants.h
index 8514d6f..3e5da98 100644
--- a/talk/xmllite/xmlconstants.h
+++ b/talk/xmllite/xmlconstants.h
@@ -2,60 +2,46 @@
* libjingle
* Copyright 2004--2005, Google Inc.
*
- * Redistribution and use in source and binary forms, with or without
+ * 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,
+ * 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
+ * 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
+ * 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,
+ * 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
+ * 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.
*/
-// Because global constant initialization order is undefined
-// globals cannot depend on other objects to be instantiated.
-// This class creates string objects within static methods
-// such that globals may refer to these constants by the
-// accessor function and they are guaranteed to be initialized.
+#ifndef TALK_XMLLITE_XMLCONSTANTS_H_
+#define TALK_XMLLITE_XMLCONSTANTS_H_
-#ifndef TALK_XMLLITE_CONSTANTS_H_
-#define TALK_XMLLITE_CONSTANTS_H_
+#include "talk/xmllite/qname.h"
-#include <string>
-
-#define STR_EMPTY XmlConstants::str_empty()
-#define NS_XML XmlConstants::ns_xml()
-#define NS_XMLNS XmlConstants::ns_xmlns()
-#define STR_XMLNS XmlConstants::str_xmlns()
-#define STR_XML XmlConstants::str_xml()
-#define STR_VERSION XmlConstants::str_version()
-#define STR_ENCODING XmlConstants::str_encoding()
namespace buzz {
-
-class XmlConstants {
- public:
- static const std::string & str_empty();
- static const std::string & ns_xml();
- static const std::string & ns_xmlns();
- static const std::string & str_xmlns();
- static const std::string & str_xml();
- static const std::string & str_version();
- static const std::string & str_encoding();
-};
-}
+extern const char STR_EMPTY[];
+extern const char NS_XML[];
+extern const char NS_XMLNS[];
+extern const char STR_XMLNS[];
+extern const char STR_XML[];
+extern const char STR_VERSION[];
+extern const char STR_ENCODING[];
-#endif // TALK_XMLLITE_CONSTANTS_H_
+extern const StaticQName QN_XMLNS;
+
+} // namespace buzz
+
+#endif // TALK_XMLLITE_XMLCONSTANTS_H_
diff --git a/talk/xmllite/xmlelement.cc b/talk/xmllite/xmlelement.cc
index bf436fb..176ce5c 100644
--- a/talk/xmllite/xmlelement.cc
+++ b/talk/xmllite/xmlelement.cc
@@ -25,12 +25,14 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include "talk/xmllite/xmlelement.h"
+
+#include <ostream>
+#include <sstream>
#include <string>
#include <vector>
-#include <sstream>
#include "talk/base/common.h"
-#include "talk/xmllite/xmlelement.h"
#include "talk/xmllite/qname.h"
#include "talk/xmllite/xmlparser.h"
#include "talk/xmllite/xmlbuilder.h"
@@ -39,242 +41,235 @@
namespace buzz {
-const QName QN_EMPTY(true, STR_EMPTY, STR_EMPTY);
-const QName QN_XMLNS(true, STR_EMPTY, STR_XMLNS);
-
-
XmlChild::~XmlChild() {
}
-bool
-XmlText::IsTextImpl() const {
+bool XmlText::IsTextImpl() const {
return true;
}
-XmlElement *
-XmlText::AsElementImpl() const {
+XmlElement* XmlText::AsElementImpl() const {
return NULL;
}
-XmlText *
-XmlText::AsTextImpl() const {
+XmlText* XmlText::AsTextImpl() const {
return const_cast<XmlText *>(this);
}
-void
-XmlText::SetText(const std::string & text) {
+void XmlText::SetText(const std::string& text) {
text_ = text;
}
-void
-XmlText::AddParsedText(const char * buf, int len) {
+void XmlText::AddParsedText(const char* buf, int len) {
text_.append(buf, len);
}
-void
-XmlText::AddText(const std::string & text) {
+void XmlText::AddText(const std::string& text) {
text_ += text;
}
XmlText::~XmlText() {
}
-XmlElement::XmlElement(const QName & name) :
+XmlElement::XmlElement(const QName& name) :
name_(name),
- pFirstAttr_(NULL),
- pLastAttr_(NULL),
- pFirstChild_(NULL),
- pLastChild_(NULL),
+ first_attr_(NULL),
+ last_attr_(NULL),
+ first_child_(NULL),
+ last_child_(NULL),
cdata_(false) {
}
-XmlElement::XmlElement(const XmlElement & elt) :
+XmlElement::XmlElement(const XmlElement& elt) :
XmlChild(),
name_(elt.name_),
- pFirstAttr_(NULL),
- pLastAttr_(NULL),
- pFirstChild_(NULL),
- pLastChild_(NULL),
+ first_attr_(NULL),
+ last_attr_(NULL),
+ first_child_(NULL),
+ last_child_(NULL),
cdata_(false) {
// copy attributes
- XmlAttr * pAttr;
- XmlAttr ** ppLastAttr = &pFirstAttr_;
- XmlAttr * newAttr = NULL;
- for (pAttr = elt.pFirstAttr_; pAttr; pAttr = pAttr->NextAttr()) {
- newAttr = new XmlAttr(*pAttr);
- *ppLastAttr = newAttr;
- ppLastAttr = &(newAttr->pNextAttr_);
+ XmlAttr* attr;
+ XmlAttr ** plast_attr = &first_attr_;
+ XmlAttr* newAttr = NULL;
+ for (attr = elt.first_attr_; attr; attr = attr->NextAttr()) {
+ newAttr = new XmlAttr(*attr);
+ *plast_attr = newAttr;
+ plast_attr = &(newAttr->next_attr_);
}
- pLastAttr_ = newAttr;
+ last_attr_ = newAttr;
// copy children
- XmlChild * pChild;
- XmlChild ** ppLast = &pFirstChild_;
- XmlChild * newChild = NULL;
+ XmlChild* pChild;
+ XmlChild ** ppLast = &first_child_;
+ XmlChild* newChild = NULL;
- for (pChild = elt.pFirstChild_; pChild; pChild = pChild->NextChild()) {
+ for (pChild = elt.first_child_; pChild; pChild = pChild->NextChild()) {
if (pChild->IsText()) {
newChild = new XmlText(*(pChild->AsText()));
} else {
newChild = new XmlElement(*(pChild->AsElement()));
}
*ppLast = newChild;
- ppLast = &(newChild->pNextChild_);
+ ppLast = &(newChild->next_child_);
}
- pLastChild_ = newChild;
+ last_child_ = newChild;
cdata_ = elt.cdata_;
}
-XmlElement::XmlElement(const QName & name, bool useDefaultNs) :
+XmlElement::XmlElement(const QName& name, bool useDefaultNs) :
name_(name),
- pFirstAttr_(useDefaultNs ? new XmlAttr(QN_XMLNS, name.Namespace()) : NULL),
- pLastAttr_(pFirstAttr_),
- pFirstChild_(NULL),
- pLastChild_(NULL),
+ first_attr_(useDefaultNs ? new XmlAttr(QN_XMLNS, name.Namespace()) : NULL),
+ last_attr_(first_attr_),
+ first_child_(NULL),
+ last_child_(NULL),
cdata_(false) {
}
-bool
-XmlElement::IsTextImpl() const {
+bool XmlElement::IsTextImpl() const {
return false;
}
-XmlElement *
-XmlElement::AsElementImpl() const {
+XmlElement* XmlElement::AsElementImpl() const {
return const_cast<XmlElement *>(this);
}
-XmlText *
-XmlElement::AsTextImpl() const {
+XmlText* XmlElement::AsTextImpl() const {
return NULL;
}
-const std::string &
-XmlElement::BodyText() const {
- if (pFirstChild_ && pFirstChild_->IsText() && pLastChild_ == pFirstChild_) {
- return pFirstChild_->AsText()->Text();
+const std::string XmlElement::BodyText() const {
+ if (first_child_ && first_child_->IsText() && last_child_ == first_child_) {
+ return first_child_->AsText()->Text();
}
- return STR_EMPTY;
+ return std::string();
}
-void
-XmlElement::SetBodyText(const std::string & text) {
- if (text == STR_EMPTY) {
+void XmlElement::SetBodyText(const std::string& text) {
+ if (text.empty()) {
ClearChildren();
- } else if (pFirstChild_ == NULL) {
+ } else if (first_child_ == NULL) {
AddText(text);
- } else if (pFirstChild_->IsText() && pLastChild_ == pFirstChild_) {
- pFirstChild_->AsText()->SetText(text);
+ } else if (first_child_->IsText() && last_child_ == first_child_) {
+ first_child_->AsText()->SetText(text);
} else {
ClearChildren();
AddText(text);
}
}
-const QName &
-XmlElement::FirstElementName() const {
- const XmlElement * element = FirstElement();
+const QName XmlElement::FirstElementName() const {
+ const XmlElement* element = FirstElement();
if (element == NULL)
- return QN_EMPTY;
+ return QName();
return element->Name();
}
-XmlAttr *
-XmlElement::FirstAttr() {
- return pFirstAttr_;
+XmlAttr* XmlElement::FirstAttr() {
+ return first_attr_;
}
-const std::string &
-XmlElement::Attr(const QName & name) const {
- XmlAttr * pattr;
- for (pattr = pFirstAttr_; pattr; pattr = pattr->pNextAttr_) {
- if (pattr->name_ == name)
- return pattr->value_;
+const std::string XmlElement::Attr(const StaticQName& name) const {
+ XmlAttr* attr;
+ for (attr = first_attr_; attr; attr = attr->next_attr_) {
+ if (attr->name_ == name)
+ return attr->value_;
}
- return STR_EMPTY;
+ return std::string();
}
-bool
-XmlElement::HasAttr(const QName & name) const {
- XmlAttr * pattr;
- for (pattr = pFirstAttr_; pattr; pattr = pattr->pNextAttr_) {
- if (pattr->name_ == name)
+const std::string XmlElement::Attr(const QName& name) const {
+ XmlAttr* attr;
+ for (attr = first_attr_; attr; attr = attr->next_attr_) {
+ if (attr->name_ == name)
+ return attr->value_;
+ }
+ return std::string();
+}
+
+bool XmlElement::HasAttr(const StaticQName& name) const {
+ XmlAttr* attr;
+ for (attr = first_attr_; attr; attr = attr->next_attr_) {
+ if (attr->name_ == name)
return true;
}
return false;
}
-void
-XmlElement::SetAttr(const QName & name, const std::string & value) {
- XmlAttr * pattr;
- for (pattr = pFirstAttr_; pattr; pattr = pattr->pNextAttr_) {
- if (pattr->name_ == name)
+bool XmlElement::HasAttr(const QName& name) const {
+ XmlAttr* attr;
+ for (attr = first_attr_; attr; attr = attr->next_attr_) {
+ if (attr->name_ == name)
+ return true;
+ }
+ return false;
+}
+
+void XmlElement::SetAttr(const QName& name, const std::string& value) {
+ XmlAttr* attr;
+ for (attr = first_attr_; attr; attr = attr->next_attr_) {
+ if (attr->name_ == name)
break;
}
- if (!pattr) {
- pattr = new XmlAttr(name, value);
- if (pLastAttr_)
- pLastAttr_->pNextAttr_ = pattr;
+ if (!attr) {
+ attr = new XmlAttr(name, value);
+ if (last_attr_)
+ last_attr_->next_attr_ = attr;
else
- pFirstAttr_ = pattr;
- pLastAttr_ = pattr;
+ first_attr_ = attr;
+ last_attr_ = attr;
return;
}
- pattr->value_ = value;
+ attr->value_ = value;
}
-void
-XmlElement::ClearAttr(const QName & name) {
- XmlAttr * pattr;
- XmlAttr *pLastAttr = NULL;
- for (pattr = pFirstAttr_; pattr; pattr = pattr->pNextAttr_) {
- if (pattr->name_ == name)
+void XmlElement::ClearAttr(const QName& name) {
+ XmlAttr* attr;
+ XmlAttr* last_attr = NULL;
+ for (attr = first_attr_; attr; attr = attr->next_attr_) {
+ if (attr->name_ == name)
break;
- pLastAttr = pattr;
+ last_attr = attr;
}
- if (!pattr)
+ if (!attr)
return;
- if (!pLastAttr)
- pFirstAttr_ = pattr->pNextAttr_;
+ if (!last_attr)
+ first_attr_ = attr->next_attr_;
else
- pLastAttr->pNextAttr_ = pattr->pNextAttr_;
- if (pLastAttr_ == pattr)
- pLastAttr_ = pLastAttr;
- delete pattr;
+ last_attr->next_attr_ = attr->next_attr_;
+ if (last_attr_ == attr)
+ last_attr_ = last_attr;
+ delete attr;
}
-XmlChild *
-XmlElement::FirstChild() {
- return pFirstChild_;
+XmlChild* XmlElement::FirstChild() {
+ return first_child_;
}
-XmlElement *
-XmlElement::FirstElement() {
- XmlChild * pChild;
- for (pChild = pFirstChild_; pChild; pChild = pChild->pNextChild_) {
+XmlElement* XmlElement::FirstElement() {
+ XmlChild* pChild;
+ for (pChild = first_child_; pChild; pChild = pChild->next_child_) {
if (!pChild->IsText())
return pChild->AsElement();
}
return NULL;
}
-XmlElement *
-XmlElement::NextElement() {
- XmlChild * pChild;
- for (pChild = pNextChild_; pChild; pChild = pChild->pNextChild_) {
+XmlElement* XmlElement::NextElement() {
+ XmlChild* pChild;
+ for (pChild = next_child_; pChild; pChild = pChild->next_child_) {
if (!pChild->IsText())
return pChild->AsElement();
}
return NULL;
}
-XmlElement *
-XmlElement::FirstWithNamespace(const std::string & ns) {
- XmlChild * pChild;
- for (pChild = pFirstChild_; pChild; pChild = pChild->pNextChild_) {
+XmlElement* XmlElement::FirstWithNamespace(const std::string& ns) {
+ XmlChild* pChild;
+ for (pChild = first_child_; pChild; pChild = pChild->next_child_) {
if (!pChild->IsText() && pChild->AsElement()->Name().Namespace() == ns)
return pChild->AsElement();
}
@@ -282,9 +277,9 @@
}
XmlElement *
-XmlElement::NextWithNamespace(const std::string & ns) {
- XmlChild * pChild;
- for (pChild = pNextChild_; pChild; pChild = pChild->pNextChild_) {
+XmlElement::NextWithNamespace(const std::string& ns) {
+ XmlChild* pChild;
+ for (pChild = next_child_; pChild; pChild = pChild->next_child_) {
if (!pChild->IsText() && pChild->AsElement()->Name().Namespace() == ns)
return pChild->AsElement();
}
@@ -292,9 +287,9 @@
}
XmlElement *
-XmlElement::FirstNamed(const QName & name) {
- XmlChild * pChild;
- for (pChild = pFirstChild_; pChild; pChild = pChild->pNextChild_) {
+XmlElement::FirstNamed(const QName& name) {
+ XmlChild* pChild;
+ for (pChild = first_child_; pChild; pChild = pChild->next_child_) {
if (!pChild->IsText() && pChild->AsElement()->Name() == name)
return pChild->AsElement();
}
@@ -302,9 +297,29 @@
}
XmlElement *
-XmlElement::NextNamed(const QName & name) {
- XmlChild * pChild;
- for (pChild = pNextChild_; pChild; pChild = pChild->pNextChild_) {
+XmlElement::FirstNamed(const StaticQName& name) {
+ XmlChild* pChild;
+ for (pChild = first_child_; pChild; pChild = pChild->next_child_) {
+ if (!pChild->IsText() && pChild->AsElement()->Name() == name)
+ return pChild->AsElement();
+ }
+ return NULL;
+}
+
+XmlElement *
+XmlElement::NextNamed(const QName& name) {
+ XmlChild* pChild;
+ for (pChild = next_child_; pChild; pChild = pChild->next_child_) {
+ if (!pChild->IsText() && pChild->AsElement()->Name() == name)
+ return pChild->AsElement();
+ }
+ return NULL;
+}
+
+XmlElement *
+XmlElement::NextNamed(const StaticQName& name) {
+ XmlChild* pChild;
+ for (pChild = next_child_; pChild; pChild = pChild->next_child_) {
if (!pChild->IsText() && pChild->AsElement()->Name() == name)
return pChild->AsElement();
}
@@ -321,132 +336,121 @@
return child;
}
-const std::string &
-XmlElement::TextNamed(const QName & name) const {
- XmlChild * pChild;
- for (pChild = pFirstChild_; pChild; pChild = pChild->pNextChild_) {
+const std::string XmlElement::TextNamed(const QName& name) const {
+ XmlChild* pChild;
+ for (pChild = first_child_; pChild; pChild = pChild->next_child_) {
if (!pChild->IsText() && pChild->AsElement()->Name() == name)
return pChild->AsElement()->BodyText();
}
- return STR_EMPTY;
+ return std::string();
}
-void
-XmlElement::InsertChildAfter(XmlChild * pPredecessor, XmlChild * pNext) {
- if (pPredecessor == NULL) {
- pNext->pNextChild_ = pFirstChild_;
- pFirstChild_ = pNext;
+void XmlElement::InsertChildAfter(XmlChild* predecessor, XmlChild* next) {
+ if (predecessor == NULL) {
+ next->next_child_ = first_child_;
+ first_child_ = next;
}
else {
- pNext->pNextChild_ = pPredecessor->pNextChild_;
- pPredecessor->pNextChild_ = pNext;
+ next->next_child_ = predecessor->next_child_;
+ predecessor->next_child_ = next;
}
}
-void
-XmlElement::RemoveChildAfter(XmlChild * pPredecessor) {
- XmlChild * pNext;
+void XmlElement::RemoveChildAfter(XmlChild* predecessor) {
+ XmlChild* next;
- if (pPredecessor == NULL) {
- pNext = pFirstChild_;
- pFirstChild_ = pNext->pNextChild_;
+ if (predecessor == NULL) {
+ next = first_child_;
+ first_child_ = next->next_child_;
}
else {
- pNext = pPredecessor->pNextChild_;
- pPredecessor->pNextChild_ = pNext->pNextChild_;
+ next = predecessor->next_child_;
+ predecessor->next_child_ = next->next_child_;
}
- if (pLastChild_ == pNext)
- pLastChild_ = pPredecessor;
+ if (last_child_ == next)
+ last_child_ = predecessor;
- delete pNext;
+ delete next;
}
-void
-XmlElement::AddAttr(const QName & name, const std::string & value) {
+void XmlElement::AddAttr(const QName& name, const std::string& value) {
ASSERT(!HasAttr(name));
- XmlAttr ** pprev = pLastAttr_ ? &(pLastAttr_->pNextAttr_) : &pFirstAttr_;
- pLastAttr_ = (*pprev = new XmlAttr(name, value));
+ XmlAttr ** pprev = last_attr_ ? &(last_attr_->next_attr_) : &first_attr_;
+ last_attr_ = (*pprev = new XmlAttr(name, value));
}
-void
-XmlElement::AddAttr(const QName & name, const std::string & value,
+void XmlElement::AddAttr(const QName& name, const std::string& value,
int depth) {
- XmlElement * element = this;
+ XmlElement* element = this;
while (depth--) {
- element = element->pLastChild_->AsElement();
+ element = element->last_child_->AsElement();
}
element->AddAttr(name, value);
}
-void
-XmlElement::AddParsedText(const char * cstr, int len) {
+void XmlElement::AddParsedText(const char* cstr, int len) {
if (len == 0)
return;
- if (pLastChild_ && pLastChild_->IsText()) {
- pLastChild_->AsText()->AddParsedText(cstr, len);
+ if (last_child_ && last_child_->IsText()) {
+ last_child_->AsText()->AddParsedText(cstr, len);
return;
}
- XmlChild ** pprev = pLastChild_ ? &(pLastChild_->pNextChild_) : &pFirstChild_;
- pLastChild_ = *pprev = new XmlText(cstr, len);
+ XmlChild ** pprev = last_child_ ? &(last_child_->next_child_) : &first_child_;
+ last_child_ = *pprev = new XmlText(cstr, len);
}
-void
-XmlElement::AddCDATAText(const char * buf, int len) {
+void XmlElement::AddCDATAText(const char* buf, int len) {
cdata_ = true;
AddParsedText(buf, len);
}
-void
-XmlElement::AddText(const std::string & text) {
+void XmlElement::AddText(const std::string& text) {
if (text == STR_EMPTY)
return;
- if (pLastChild_ && pLastChild_->IsText()) {
- pLastChild_->AsText()->AddText(text);
+ if (last_child_ && last_child_->IsText()) {
+ last_child_->AsText()->AddText(text);
return;
}
- XmlChild ** pprev = pLastChild_ ? &(pLastChild_->pNextChild_) : &pFirstChild_;
- pLastChild_ = *pprev = new XmlText(text);
+ XmlChild ** pprev = last_child_ ? &(last_child_->next_child_) : &first_child_;
+ last_child_ = *pprev = new XmlText(text);
}
-void
-XmlElement::AddText(const std::string & text, int depth) {
+void XmlElement::AddText(const std::string& text, int depth) {
// note: the first syntax is ambigious for msvc 6
- // XmlElement * pel(this);
- XmlElement * element = this;
+ // XmlElement* pel(this);
+ XmlElement* element = this;
while (depth--) {
- element = element->pLastChild_->AsElement();
+ element = element->last_child_->AsElement();
}
element->AddText(text);
}
-void
-XmlElement::AddElement(XmlElement *pelChild) {
- if (pelChild == NULL)
+void XmlElement::AddElement(XmlElement *child) {
+ if (child == NULL)
return;
- XmlChild ** pprev = pLastChild_ ? &(pLastChild_->pNextChild_) : &pFirstChild_;
- pLastChild_ = *pprev = pelChild;
- pelChild->pNextChild_ = NULL;
+ XmlChild ** pprev = last_child_ ? &(last_child_->next_child_) : &first_child_;
+ *pprev = child;
+ last_child_ = child;
+ child->next_child_ = NULL;
}
-void
-XmlElement::AddElement(XmlElement *pelChild, int depth) {
- XmlElement * element = this;
+void XmlElement::AddElement(XmlElement *child, int depth) {
+ XmlElement* element = this;
while (depth--) {
- element = element->pLastChild_->AsElement();
+ element = element->last_child_->AsElement();
}
- element->AddElement(pelChild);
+ element->AddElement(child);
}
-void
-XmlElement::ClearNamedChildren(const QName & name) {
- XmlChild * prev_child = NULL;
- XmlChild * next_child;
- XmlChild * child;
+void XmlElement::ClearNamedChildren(const QName& name) {
+ XmlChild* prev_child = NULL;
+ XmlChild* next_child;
+ XmlChild* child;
for (child = FirstChild(); child; child = next_child) {
next_child = child->NextChild();
if (!child->IsText() && child->AsElement()->Name() == name)
@@ -458,62 +462,52 @@
}
}
-void
-XmlElement::ClearAttributes() {
- XmlAttr * pattr;
- for (pattr = pFirstAttr_; pattr; ) {
- XmlAttr * pToDelete = pattr;
- pattr = pattr->pNextAttr_;
- delete pToDelete;
+void XmlElement::ClearAttributes() {
+ XmlAttr* attr;
+ for (attr = first_attr_; attr; ) {
+ XmlAttr* to_delete = attr;
+ attr = attr->next_attr_;
+ delete to_delete;
}
- pFirstAttr_ = pLastAttr_ = NULL;
+ first_attr_ = last_attr_ = NULL;
}
-void
-XmlElement::ClearChildren() {
- XmlChild * pchild;
- for (pchild = pFirstChild_; pchild; ) {
- XmlChild * pToDelete = pchild;
- pchild = pchild->pNextChild_;
- delete pToDelete;
+void XmlElement::ClearChildren() {
+ XmlChild* pchild;
+ for (pchild = first_child_; pchild; ) {
+ XmlChild* to_delete = pchild;
+ pchild = pchild->next_child_;
+ delete to_delete;
}
- pFirstChild_ = pLastChild_ = NULL;
+ first_child_ = last_child_ = NULL;
}
-std::string
-XmlElement::Str() const {
+std::string XmlElement::Str() const {
std::stringstream ss;
- Print(&ss, NULL, 0);
+ XmlPrinter::PrintXml(&ss, this);
return ss.str();
}
-XmlElement *
-XmlElement::ForStr(const std::string & str) {
+XmlElement* XmlElement::ForStr(const std::string& str) {
XmlBuilder builder;
XmlParser::ParseXml(&builder, str);
return builder.CreateElement();
}
-void
-XmlElement::Print(
- std::ostream * pout, std::string xmlns[], int xmlnsCount) const {
- XmlPrinter::PrintXml(pout, this, xmlns, xmlnsCount);
-}
-
XmlElement::~XmlElement() {
- XmlAttr * pattr;
- for (pattr = pFirstAttr_; pattr; ) {
- XmlAttr * pToDelete = pattr;
- pattr = pattr->pNextAttr_;
- delete pToDelete;
+ XmlAttr* attr;
+ for (attr = first_attr_; attr; ) {
+ XmlAttr* to_delete = attr;
+ attr = attr->next_attr_;
+ delete to_delete;
}
- XmlChild * pchild;
- for (pchild = pFirstChild_; pchild; ) {
- XmlChild * pToDelete = pchild;
- pchild = pchild->pNextChild_;
- delete pToDelete;
+ XmlChild* pchild;
+ for (pchild = first_child_; pchild; ) {
+ XmlChild* to_delete = pchild;
+ pchild = pchild->next_child_;
+ delete to_delete;
}
}
-}
+} // namespace buzz
diff --git a/talk/xmllite/xmlelement.h b/talk/xmllite/xmlelement.h
index 38e31a9..ffdc333 100644
--- a/talk/xmllite/xmlelement.h
+++ b/talk/xmllite/xmlelement.h
@@ -2,238 +2,250 @@
* libjingle
* Copyright 2004--2005, Google Inc.
*
- * Redistribution and use in source and binary forms, with or without
+ * 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,
+ * 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
+ * 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
+ * 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,
+ * 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
+ * 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 _xmlelement_h_
-#define _xmlelement_h_
+#ifndef TALK_XMLLITE_XMLELEMENT_H_
+#define TALK_XMLLITE_XMLELEMENT_H_
#include <iosfwd>
#include <string>
+
#include "talk/base/scoped_ptr.h"
#include "talk/xmllite/qname.h"
namespace buzz {
-extern const QName QN_EMPTY;
-extern const QName QN_XMLNS;
-
-
class XmlChild;
class XmlText;
class XmlElement;
class XmlAttr;
class XmlChild {
-friend class XmlElement;
-
-public:
-
- XmlChild * NextChild() { return pNextChild_; }
- const XmlChild * NextChild() const { return pNextChild_; }
+ public:
+ XmlChild* NextChild() { return next_child_; }
+ const XmlChild* NextChild() const { return next_child_; }
bool IsText() const { return IsTextImpl(); }
- XmlElement * AsElement() { return AsElementImpl(); }
- const XmlElement * AsElement() const { return AsElementImpl(); }
+ XmlElement* AsElement() { return AsElementImpl(); }
+ const XmlElement* AsElement() const { return AsElementImpl(); }
- XmlText * AsText() { return AsTextImpl(); }
- const XmlText * AsText() const { return AsTextImpl(); }
+ XmlText* AsText() { return AsTextImpl(); }
+ const XmlText* AsText() const { return AsTextImpl(); }
-protected:
-
+ protected:
XmlChild() :
- pNextChild_(NULL) {
+ next_child_(NULL) {
}
virtual bool IsTextImpl() const = 0;
- virtual XmlElement * AsElementImpl() const = 0;
- virtual XmlText * AsTextImpl() const = 0;
+ virtual XmlElement* AsElementImpl() const = 0;
+ virtual XmlText* AsTextImpl() const = 0;
virtual ~XmlChild();
-private:
- XmlChild(const XmlChild & noimpl);
+ private:
+ friend class XmlElement;
- XmlChild * pNextChild_;
+ XmlChild(const XmlChild& noimpl);
+ XmlChild* next_child_;
};
class XmlText : public XmlChild {
-public:
- explicit XmlText(const std::string & text) :
+ public:
+ explicit XmlText(const std::string& text) :
XmlChild(),
text_(text) {
}
- explicit XmlText(const XmlText & t) :
+ explicit XmlText(const XmlText& t) :
XmlChild(),
text_(t.text_) {
}
- explicit XmlText(const char * cstr, size_t len) :
+ explicit XmlText(const char* cstr, size_t len) :
XmlChild(),
text_(cstr, len) {
}
virtual ~XmlText();
- const std::string & Text() const { return text_; }
- void SetText(const std::string & text);
- void AddParsedText(const char * buf, int len);
- void AddText(const std::string & text);
+ const std::string& Text() const { return text_; }
+ void SetText(const std::string& text);
+ void AddParsedText(const char* buf, int len);
+ void AddText(const std::string& text);
-protected:
+ protected:
virtual bool IsTextImpl() const;
- virtual XmlElement * AsElementImpl() const;
- virtual XmlText * AsTextImpl() const;
+ virtual XmlElement* AsElementImpl() const;
+ virtual XmlText* AsTextImpl() const;
-private:
+ private:
std::string text_;
};
class XmlAttr {
-friend class XmlElement;
+ public:
+ XmlAttr* NextAttr() const { return next_attr_; }
+ const QName& Name() const { return name_; }
+ const std::string& Value() const { return value_; }
-public:
- XmlAttr * NextAttr() const { return pNextAttr_; }
- const QName & Name() const { return name_; }
- const std::string & Value() const { return value_; }
+ private:
+ friend class XmlElement;
-private:
- explicit XmlAttr(const QName & name, const std::string & value) :
- pNextAttr_(NULL),
+ explicit XmlAttr(const QName& name, const std::string& value) :
+ next_attr_(NULL),
name_(name),
value_(value) {
}
- explicit XmlAttr(const XmlAttr & att) :
- pNextAttr_(NULL),
+ explicit XmlAttr(const XmlAttr& att) :
+ next_attr_(NULL),
name_(att.name_),
value_(att.value_) {
}
- XmlAttr * pNextAttr_;
+ XmlAttr* next_attr_;
QName name_;
std::string value_;
};
class XmlElement : public XmlChild {
-public:
- explicit XmlElement(const QName & name);
- explicit XmlElement(const QName & name, bool useDefaultNs);
- explicit XmlElement(const XmlElement & elt);
+ public:
+ explicit XmlElement(const QName& name);
+ explicit XmlElement(const QName& name, bool useDefaultNs);
+ explicit XmlElement(const XmlElement& elt);
virtual ~XmlElement();
const QName& Name() const { return name_; }
void SetName(const QName& name) { name_ = name; }
- const std::string & BodyText() const;
- void SetBodyText(const std::string & text);
+ const std::string BodyText() const;
+ void SetBodyText(const std::string& text);
- const QName & FirstElementName() const;
+ const QName FirstElementName() const;
- XmlAttr * FirstAttr();
- const XmlAttr * FirstAttr() const
+ XmlAttr* FirstAttr();
+ const XmlAttr* FirstAttr() const
{ return const_cast<XmlElement *>(this)->FirstAttr(); }
- //! Attr will return STR_EMPTY if the attribute isn't there:
- //! use HasAttr to test presence of an attribute.
- const std::string & Attr(const QName & name) const;
- bool HasAttr(const QName & name) const;
- void SetAttr(const QName & name, const std::string & value);
- void ClearAttr(const QName & name);
+ // Attr will return an empty string if the attribute isn't there:
+ // use HasAttr to test presence of an attribute.
+ const std::string Attr(const StaticQName& name) const;
+ const std::string Attr(const QName& name) const;
+ bool HasAttr(const StaticQName& name) const;
+ bool HasAttr(const QName& name) const;
+ void SetAttr(const QName& name, const std::string& value);
+ void ClearAttr(const QName& name);
- XmlChild * FirstChild();
- const XmlChild * FirstChild() const
- { return const_cast<XmlElement *>(this)->FirstChild(); }
+ XmlChild* FirstChild();
+ const XmlChild* FirstChild() const {
+ return const_cast<XmlElement *>(this)->FirstChild();
+ }
- XmlElement * FirstElement();
- const XmlElement * FirstElement() const
- { return const_cast<XmlElement *>(this)->FirstElement(); }
+ XmlElement* FirstElement();
+ const XmlElement* FirstElement() const {
+ return const_cast<XmlElement *>(this)->FirstElement();
+ }
- XmlElement * NextElement();
- const XmlElement * NextElement() const
- { return const_cast<XmlElement *>(this)->NextElement(); }
+ XmlElement* NextElement();
+ const XmlElement* NextElement() const {
+ return const_cast<XmlElement *>(this)->NextElement();
+ }
- XmlElement * FirstWithNamespace(const std::string & ns);
- const XmlElement * FirstWithNamespace(const std::string & ns) const
- { return const_cast<XmlElement *>(this)->FirstWithNamespace(ns); }
+ XmlElement* FirstWithNamespace(const std::string& ns);
+ const XmlElement* FirstWithNamespace(const std::string& ns) const {
+ return const_cast<XmlElement *>(this)->FirstWithNamespace(ns);
+ }
- XmlElement * NextWithNamespace(const std::string & ns);
- const XmlElement * NextWithNamespace(const std::string & ns) const
- { return const_cast<XmlElement *>(this)->NextWithNamespace(ns); }
+ XmlElement* NextWithNamespace(const std::string& ns);
+ const XmlElement* NextWithNamespace(const std::string& ns) const {
+ return const_cast<XmlElement *>(this)->NextWithNamespace(ns);
+ }
- XmlElement * FirstNamed(const QName & name);
- const XmlElement * FirstNamed(const QName & name) const
- { return const_cast<XmlElement *>(this)->FirstNamed(name); }
+ XmlElement* FirstNamed(const StaticQName& name);
+ const XmlElement* FirstNamed(const StaticQName& name) const {
+ return const_cast<XmlElement *>(this)->FirstNamed(name);
+ }
- XmlElement * NextNamed(const QName & name);
- const XmlElement * NextNamed(const QName & name) const
- { return const_cast<XmlElement *>(this)->NextNamed(name); }
+ XmlElement* FirstNamed(const QName& name);
+ const XmlElement* FirstNamed(const QName& name) const {
+ return const_cast<XmlElement *>(this)->FirstNamed(name);
+ }
+
+ XmlElement* NextNamed(const StaticQName& name);
+ const XmlElement* NextNamed(const StaticQName& name) const {
+ return const_cast<XmlElement *>(this)->NextNamed(name);
+ }
+
+ XmlElement* NextNamed(const QName& name);
+ const XmlElement* NextNamed(const QName& name) const {
+ return const_cast<XmlElement *>(this)->NextNamed(name);
+ }
// Finds the first element named 'name'. If that element can't be found then
// adds one and returns it.
XmlElement* FindOrAddNamedChild(const QName& name);
- const std::string & TextNamed(const QName & name) const;
+ const std::string TextNamed(const QName& name) const;
- void InsertChildAfter(XmlChild * pPredecessor, XmlChild * pNewChild);
- void RemoveChildAfter(XmlChild * pPredecessor);
+ void InsertChildAfter(XmlChild* predecessor, XmlChild* new_child);
+ void RemoveChildAfter(XmlChild* predecessor);
- void AddParsedText(const char * buf, int len);
+ void AddParsedText(const char* buf, int len);
// Note: CDATA is not supported by XMPP, therefore using this function will
// generate non-XMPP compatible XML.
- void AddCDATAText(const char * buf, int len);
- void AddText(const std::string & text);
- void AddText(const std::string & text, int depth);
- void AddElement(XmlElement * pelChild);
- void AddElement(XmlElement * pelChild, int depth);
- void AddAttr(const QName & name, const std::string & value);
- void AddAttr(const QName & name, const std::string & value, int depth);
- void ClearNamedChildren(const QName & name);
+ void AddCDATAText(const char* buf, int len);
+ void AddText(const std::string& text);
+ void AddText(const std::string& text, int depth);
+ void AddElement(XmlElement* child);
+ void AddElement(XmlElement* child, int depth);
+ void AddAttr(const QName& name, const std::string& value);
+ void AddAttr(const QName& name, const std::string& value, int depth);
+ void ClearNamedChildren(const QName& name);
void ClearAttributes();
void ClearChildren();
- static XmlElement * ForStr(const std::string & str);
+ static XmlElement* ForStr(const std::string& str);
std::string Str() const;
- void Print(std::ostream * pout, std::string xmlns[], int xmlnsCount) const;
-
bool IsCDATA() const { return cdata_; }
-protected:
+ protected:
virtual bool IsTextImpl() const;
- virtual XmlElement * AsElementImpl() const;
- virtual XmlText * AsTextImpl() const;
+ virtual XmlElement* AsElementImpl() const;
+ virtual XmlText* AsTextImpl() const;
-private:
+ private:
QName name_;
- XmlAttr * pFirstAttr_;
- XmlAttr * pLastAttr_;
- XmlChild * pFirstChild_;
- XmlChild * pLastChild_;
+ XmlAttr* first_attr_;
+ XmlAttr* last_attr_;
+ XmlChild* first_child_;
+ XmlChild* last_child_;
bool cdata_;
};
-}
-#endif
+} // namespace buzz
+
+#endif // TALK_XMLLITE_XMLELEMENT_H_
diff --git a/talk/xmllite/xmlelement_unittest.cc b/talk/xmllite/xmlelement_unittest.cc
new file mode 100644
index 0000000..6d488fa
--- /dev/null
+++ b/talk/xmllite/xmlelement_unittest.cc
@@ -0,0 +1,271 @@
+/*
+ * libjingle
+ * Copyright 2004, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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 <sstream>
+#include <iostream>
+#include "talk/base/common.h"
+#include "talk/base/gunit.h"
+#include "talk/base/thread.h"
+#include "talk/xmllite/xmlelement.h"
+
+using buzz::QName;
+using buzz::XmlAttr;
+using buzz::XmlChild;
+using buzz::XmlElement;
+
+std::ostream& operator<<(std::ostream& os, const QName& name) {
+ os << name.Namespace() << ":" << name.LocalPart();
+ return os;
+}
+
+TEST(XmlElementTest, TestConstructors) {
+ XmlElement elt(QName("google:test", "first"));
+ EXPECT_EQ("<test:first xmlns:test=\"google:test\"/>", elt.Str());
+
+ XmlElement elt2(QName("google:test", "first"), true);
+ EXPECT_EQ("<first xmlns=\"google:test\"/>", elt2.Str());
+}
+
+TEST(XmlElementTest, TestAdd) {
+ XmlElement elt(QName("google:test", "root"), true);
+ elt.AddElement(new XmlElement(QName("google:test", "first")));
+ elt.AddElement(new XmlElement(QName("google:test", "nested")), 1);
+ elt.AddText("nested-value", 2);
+ elt.AddText("between-", 1);
+ elt.AddText("value", 1);
+ elt.AddElement(new XmlElement(QName("google:test", "nested2")), 1);
+ elt.AddElement(new XmlElement(QName("google:test", "second")));
+ elt.AddText("init-value", 1);
+ elt.AddElement(new XmlElement(QName("google:test", "nested3")), 1);
+ elt.AddText("trailing-value", 1);
+
+ // make sure it looks ok overall
+ EXPECT_EQ("<root xmlns=\"google:test\">"
+ "<first><nested>nested-value</nested>between-value<nested2/></first>"
+ "<second>init-value<nested3/>trailing-value</second></root>",
+ elt.Str());
+
+ // make sure text was concatenated
+ XmlChild * pchild =
+ elt.FirstChild()->AsElement()->FirstChild()->NextChild();
+ EXPECT_TRUE(pchild->IsText());
+ EXPECT_EQ("between-value", pchild->AsText()->Text());
+}
+
+TEST(XmlElementTest, TestAttrs) {
+ XmlElement elt(QName("", "root"));
+ elt.SetAttr(QName("", "a"), "avalue");
+ EXPECT_EQ("<root a=\"avalue\"/>", elt.Str());
+
+ elt.SetAttr(QName("", "b"), "bvalue");
+ EXPECT_EQ("<root a=\"avalue\" b=\"bvalue\"/>", elt.Str());
+
+ elt.SetAttr(QName("", "a"), "avalue2");
+ EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue\"/>", elt.Str());
+
+ elt.SetAttr(QName("", "b"), "bvalue2");
+ EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\"/>", elt.Str());
+
+ elt.SetAttr(QName("", "c"), "cvalue");
+ EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\" c=\"cvalue\"/>", elt.Str());
+
+ XmlAttr * patt = elt.FirstAttr();
+ EXPECT_EQ(QName("", "a"), patt->Name());
+ EXPECT_EQ("avalue2", patt->Value());
+
+ patt = patt->NextAttr();
+ EXPECT_EQ(QName("", "b"), patt->Name());
+ EXPECT_EQ("bvalue2", patt->Value());
+
+ patt = patt->NextAttr();
+ EXPECT_EQ(QName("", "c"), patt->Name());
+ EXPECT_EQ("cvalue", patt->Value());
+
+ patt = patt->NextAttr();
+ EXPECT_TRUE(NULL == patt);
+
+ EXPECT_TRUE(elt.HasAttr(QName("", "a")));
+ EXPECT_TRUE(elt.HasAttr(QName("", "b")));
+ EXPECT_TRUE(elt.HasAttr(QName("", "c")));
+ EXPECT_FALSE(elt.HasAttr(QName("", "d")));
+
+ elt.SetAttr(QName("", "d"), "dvalue");
+ EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\" c=\"cvalue\" d=\"dvalue\"/>",
+ elt.Str());
+ EXPECT_TRUE(elt.HasAttr(QName("", "d")));
+
+ elt.ClearAttr(QName("", "z")); // not found, no effect
+ EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\" c=\"cvalue\" d=\"dvalue\"/>",
+ elt.Str());
+
+ elt.ClearAttr(QName("", "b"));
+ EXPECT_EQ("<root a=\"avalue2\" c=\"cvalue\" d=\"dvalue\"/>", elt.Str());
+
+ elt.ClearAttr(QName("", "a"));
+ EXPECT_EQ("<root c=\"cvalue\" d=\"dvalue\"/>", elt.Str());
+
+ elt.ClearAttr(QName("", "d"));
+ EXPECT_EQ("<root c=\"cvalue\"/>", elt.Str());
+
+ elt.ClearAttr(QName("", "c"));
+ EXPECT_EQ("<root/>", elt.Str());
+}
+
+TEST(XmlElementTest, TestBodyText) {
+ XmlElement elt(QName("", "root"));
+ EXPECT_EQ("", elt.BodyText());
+
+ elt.AddText("body value text");
+
+ EXPECT_EQ("body value text", elt.BodyText());
+
+ elt.ClearChildren();
+ elt.AddText("more value ");
+ elt.AddText("text");
+
+ EXPECT_EQ("more value text", elt.BodyText());
+
+ elt.ClearChildren();
+ elt.AddText("decoy");
+ elt.AddElement(new XmlElement(QName("", "dummy")));
+ EXPECT_EQ("", elt.BodyText());
+
+ elt.SetBodyText("replacement");
+ EXPECT_EQ("replacement", elt.BodyText());
+
+ elt.SetBodyText("");
+ EXPECT_TRUE(NULL == elt.FirstChild());
+
+ elt.SetBodyText("goodbye");
+ EXPECT_EQ("goodbye", elt.FirstChild()->AsText()->Text());
+ EXPECT_EQ("goodbye", elt.BodyText());
+}
+
+TEST(XmlElementTest, TestCopyConstructor) {
+ XmlElement * element = XmlElement::ForStr(
+ "<root xmlns='test-foo'>This is a <em a='avalue' b='bvalue'>"
+ "little <b>little</b></em> test</root>");
+
+ XmlElement * pelCopy = new XmlElement(*element);
+ EXPECT_EQ("<root xmlns=\"test-foo\">This is a <em a=\"avalue\" b=\"bvalue\">"
+ "little <b>little</b></em> test</root>", pelCopy->Str());
+ delete pelCopy;
+
+ pelCopy = new XmlElement(*(element->FirstChild()->NextChild()->AsElement()));
+ EXPECT_EQ("<foo:em a=\"avalue\" b=\"bvalue\" xmlns:foo=\"test-foo\">"
+ "little <foo:b>little</foo:b></foo:em>", pelCopy->Str());
+
+ XmlAttr * patt = pelCopy->FirstAttr();
+ EXPECT_EQ(QName("", "a"), patt->Name());
+ EXPECT_EQ("avalue", patt->Value());
+
+ patt = patt->NextAttr();
+ EXPECT_EQ(QName("", "b"), patt->Name());
+ EXPECT_EQ("bvalue", patt->Value());
+
+ patt = patt->NextAttr();
+ EXPECT_TRUE(NULL == patt);
+ delete pelCopy;
+ delete element;
+}
+
+TEST(XmlElementTest, TestNameSearch) {
+ XmlElement * element = XmlElement::ForStr(
+ "<root xmlns='test-foo'>"
+ "<firstname>George</firstname>"
+ "<middlename>X.</middlename>"
+ "some text"
+ "<lastname>Harrison</lastname>"
+ "<firstname>John</firstname>"
+ "<middlename>Y.</middlename>"
+ "<lastname>Lennon</lastname>"
+ "</root>");
+ EXPECT_TRUE(NULL ==
+ element->FirstNamed(QName("", "firstname")));
+ EXPECT_EQ(element->FirstChild(),
+ element->FirstNamed(QName("test-foo", "firstname")));
+ EXPECT_EQ(element->FirstChild()->NextChild(),
+ element->FirstNamed(QName("test-foo", "middlename")));
+ EXPECT_EQ(element->FirstElement()->NextElement(),
+ element->FirstNamed(QName("test-foo", "middlename")));
+ EXPECT_EQ("Harrison",
+ element->TextNamed(QName("test-foo", "lastname")));
+ EXPECT_EQ(element->FirstElement()->NextElement()->NextElement(),
+ element->FirstNamed(QName("test-foo", "lastname")));
+ EXPECT_EQ("John", element->FirstNamed(QName("test-foo", "firstname"))->
+ NextNamed(QName("test-foo", "firstname"))->BodyText());
+ EXPECT_EQ("Y.", element->FirstNamed(QName("test-foo", "middlename"))->
+ NextNamed(QName("test-foo", "middlename"))->BodyText());
+ EXPECT_EQ("Lennon", element->FirstNamed(QName("test-foo", "lastname"))->
+ NextNamed(QName("test-foo", "lastname"))->BodyText());
+ EXPECT_TRUE(NULL == element->FirstNamed(QName("test-foo", "firstname"))->
+ NextNamed(QName("test-foo", "firstname"))->
+ NextNamed(QName("test-foo", "firstname")));
+
+ delete element;
+}
+
+class XmlElementCreatorThread : public talk_base::Thread {
+ public:
+ XmlElementCreatorThread(int count, buzz::QName qname) :
+ count_(count), qname_(qname) {}
+
+ virtual void Run() {
+ std::vector<buzz::XmlElement*> elems;
+ for (int i = 0; i < count_; i++) {
+ elems.push_back(new XmlElement(qname_));
+ }
+ for (int i = 0; i < count_; i++) {
+ delete elems[i];
+ }
+ }
+
+ private:
+ int count_;
+ buzz::QName qname_;
+};
+
+// If XmlElement creation and destruction isn't thread safe,
+// this test should crash.
+TEST(XmlElementTest, TestMultithread) {
+ int thread_count = 2; // Was 100, but that's too slow.
+ int elem_count = 100; // Was 100000, but that's too slow.
+ buzz::QName qname("foo", "bar");
+
+ std::vector<talk_base::Thread*> threads;
+ for (int i = 0; i < thread_count; i++) {
+ threads.push_back(
+ new XmlElementCreatorThread(elem_count, qname));
+ threads[i]->Start();
+ }
+
+ for (int i = 0; i < thread_count; i++) {
+ threads[i]->Stop();
+ delete threads[i];
+ }
+}
diff --git a/talk/xmllite/xmlnsstack.cc b/talk/xmllite/xmlnsstack.cc
index b2bf370..26e27f8 100644
--- a/talk/xmllite/xmlnsstack.cc
+++ b/talk/xmllite/xmlnsstack.cc
@@ -25,11 +25,13 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include "talk/xmllite/xmlnsstack.h"
+
+#include <sstream>
#include <string>
#include <vector>
-#include <sstream>
+
#include "talk/xmllite/xmlelement.h"
-#include "talk/xmllite/xmlnsstack.h"
#include "talk/xmllite/xmlconstants.h"
namespace buzz {
@@ -41,13 +43,11 @@
XmlnsStack::~XmlnsStack() {}
-void
-XmlnsStack::PushFrame() {
+void XmlnsStack::PushFrame() {
pxmlnsDepthStack_->push_back(pxmlnsStack_->size());
}
-void
-XmlnsStack::PopFrame() {
+void XmlnsStack::PopFrame() {
size_t prev_size = pxmlnsDepthStack_->back();
pxmlnsDepthStack_->pop_back();
if (prev_size < pxmlnsStack_->size()) {
@@ -56,42 +56,41 @@
}
}
-const std::string *
-XmlnsStack::NsForPrefix(const std::string & prefix) {
+std::pair<std::string, bool> XmlnsStack::NsForPrefix(
+ const std::string& prefix) {
if (prefix.length() >= 3 &&
(prefix[0] == 'x' || prefix[0] == 'X') &&
(prefix[1] == 'm' || prefix[1] == 'M') &&
(prefix[2] == 'l' || prefix[2] == 'L')) {
if (prefix == "xml")
- return &(NS_XML);
+ return std::make_pair(NS_XML, true);
if (prefix == "xmlns")
- return &(NS_XMLNS);
- return NULL;
+ return std::make_pair(NS_XMLNS, true);
+ // Other names with xml prefix are illegal.
+ return std::make_pair(STR_EMPTY, false);
}
std::vector<std::string>::iterator pos;
for (pos = pxmlnsStack_->end(); pos > pxmlnsStack_->begin(); ) {
pos -= 2;
if (*pos == prefix)
- return &(*(pos + 1));
+ return std::make_pair(*(pos + 1), true);
}
if (prefix == STR_EMPTY)
- return &(STR_EMPTY); // default namespace
+ return std::make_pair(STR_EMPTY, true); // default namespace
- return NULL; // none found
+ return std::make_pair(STR_EMPTY, false); // none found
}
-bool
-XmlnsStack::PrefixMatchesNs(const std::string & prefix, const std::string & ns) {
- const std::string * match = NsForPrefix(prefix);
- if (match == NULL)
- return false;
- return (*match == ns);
+bool XmlnsStack::PrefixMatchesNs(const std::string& prefix,
+ const std::string& ns) {
+ const std::pair<std::string, bool> match = NsForPrefix(prefix);
+ return match.second && (match.first == ns);
}
-std::pair<std::string, bool>
-XmlnsStack::PrefixForNs(const std::string & ns, bool isattr) {
+std::pair<std::string, bool> XmlnsStack::PrefixForNs(const std::string& ns,
+ bool isattr) {
if (ns == NS_XML)
return std::make_pair(std::string("xml"), true);
if (ns == NS_XMLNS)
@@ -110,8 +109,7 @@
return std::make_pair(STR_EMPTY, false); // none found
}
-std::string
-XmlnsStack::FormatQName(const QName & name, bool isAttr) {
+std::string XmlnsStack::FormatQName(const QName& name, bool isAttr) {
std::string prefix(PrefixForNs(name.Namespace(), isAttr).first);
if (prefix == STR_EMPTY)
return name.LocalPart();
@@ -119,14 +117,12 @@
return prefix + ':' + name.LocalPart();
}
-void
-XmlnsStack::AddXmlns(const std::string & prefix, const std::string & ns) {
+void XmlnsStack::AddXmlns(const std::string & prefix, const std::string & ns) {
pxmlnsStack_->push_back(prefix);
pxmlnsStack_->push_back(ns);
}
-void
-XmlnsStack::RemoveXmlns() {
+void XmlnsStack::RemoveXmlns() {
pxmlnsStack_->pop_back();
pxmlnsStack_->pop_back();
}
@@ -173,16 +169,15 @@
return "ns";
}
-
-std::pair<std::string, bool>
-XmlnsStack::AddNewPrefix(const std::string & ns, bool isAttr) {
+std::pair<std::string, bool> XmlnsStack::AddNewPrefix(const std::string& ns,
+ bool isAttr) {
if (PrefixForNs(ns, isAttr).second)
return std::make_pair(STR_EMPTY, false);
std::string base(SuggestPrefix(ns));
std::string result(base);
int i = 2;
- while (NsForPrefix(result) != NULL) {
+ while (NsForPrefix(result).second) {
std::stringstream ss;
ss << base;
ss << (i++);
diff --git a/talk/xmllite/xmlnsstack.h b/talk/xmllite/xmlnsstack.h
index c7e9f89..f6b4b81 100644
--- a/talk/xmllite/xmlnsstack.h
+++ b/talk/xmllite/xmlnsstack.h
@@ -25,8 +25,8 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef _xmlnsstack_h_
-#define _xmlnsstack_h_
+#ifndef TALK_XMLLITE_XMLNSSTACK_H_
+#define TALK_XMLLITE_XMLNSSTACK_H_
#include <string>
#include <vector>
@@ -40,16 +40,16 @@
XmlnsStack();
~XmlnsStack();
- void AddXmlns(const std::string & prefix, const std::string & ns);
+ void AddXmlns(const std::string& prefix, const std::string& ns);
void RemoveXmlns();
void PushFrame();
void PopFrame();
void Reset();
- const std::string * NsForPrefix(const std::string & prefix);
+ std::pair<std::string, bool> NsForPrefix(const std::string& prefix);
bool PrefixMatchesNs(const std::string & prefix, const std::string & ns);
- std::pair<std::string, bool> PrefixForNs(const std::string & ns, bool isAttr);
- std::pair<std::string, bool> AddNewPrefix(const std::string & ns, bool isAttr);
+ std::pair<std::string, bool> PrefixForNs(const std::string& ns, bool isAttr);
+ std::pair<std::string, bool> AddNewPrefix(const std::string& ns, bool isAttr);
std::string FormatQName(const QName & name, bool isAttr);
private:
@@ -59,4 +59,4 @@
};
}
-#endif
+#endif // TALK_XMLLITE_XMLNSSTACK_H_
diff --git a/talk/xmllite/xmlnsstack_unittest.cc b/talk/xmllite/xmlnsstack_unittest.cc
new file mode 100644
index 0000000..21e157b
--- /dev/null
+++ b/talk/xmllite/xmlnsstack_unittest.cc
@@ -0,0 +1,258 @@
+/*
+ * libjingle
+ * Copyright 2004, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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/xmllite/xmlnsstack.h"
+
+#include <string>
+#include <sstream>
+#include <iostream>
+
+#include "talk/base/common.h"
+#include "talk/base/gunit.h"
+#include "talk/xmllite/xmlconstants.h"
+
+using buzz::NS_XML;
+using buzz::NS_XMLNS;
+using buzz::QName;
+using buzz::XmlnsStack;
+
+TEST(XmlnsStackTest, TestBuiltin) {
+ XmlnsStack stack;
+
+ EXPECT_EQ(std::string(NS_XML), stack.NsForPrefix("xml").first);
+ EXPECT_EQ(std::string(NS_XMLNS), stack.NsForPrefix("xmlns").first);
+ EXPECT_EQ("", stack.NsForPrefix("").first);
+
+ EXPECT_EQ("xml", stack.PrefixForNs(NS_XML, false).first);
+ EXPECT_EQ("xmlns", stack.PrefixForNs(NS_XMLNS, false).first);
+ EXPECT_EQ("", stack.PrefixForNs("", false).first);
+ EXPECT_EQ("", stack.PrefixForNs("", true).first);
+}
+
+TEST(XmlnsStackTest, TestNsForPrefix) {
+ XmlnsStack stack;
+ stack.AddXmlns("pre1", "ns1");
+ stack.AddXmlns("pre2", "ns2");
+ stack.AddXmlns("pre1", "ns3");
+ stack.AddXmlns("", "ns4");
+
+ EXPECT_EQ("ns3", stack.NsForPrefix("pre1").first);
+ EXPECT_TRUE(stack.NsForPrefix("pre1").second);
+ EXPECT_EQ("ns2", stack.NsForPrefix("pre2").first);
+ EXPECT_EQ("ns4", stack.NsForPrefix("").first);
+ EXPECT_EQ("", stack.NsForPrefix("pre3").first);
+ EXPECT_EQ(false, stack.NsForPrefix("pre3").second);
+}
+
+TEST(XmlnsStackTest, TestPrefixForNs) {
+ XmlnsStack stack;
+ stack.AddXmlns("pre1", "ns1");
+ stack.AddXmlns("pre2", "ns2");
+ stack.AddXmlns("pre1", "ns3");
+ stack.AddXmlns("pre3", "ns2");
+ stack.AddXmlns("pre4", "ns4");
+ stack.AddXmlns("", "ns4");
+
+ EXPECT_EQ("", stack.PrefixForNs("ns1", false).first);
+ EXPECT_FALSE(stack.PrefixForNs("ns1", false).second);
+ EXPECT_EQ("", stack.PrefixForNs("ns1", true).first);
+ EXPECT_FALSE(stack.PrefixForNs("ns1", true).second);
+ EXPECT_EQ("pre3", stack.PrefixForNs("ns2", false).first);
+ EXPECT_TRUE(stack.PrefixForNs("ns2", false).second);
+ EXPECT_EQ("pre3", stack.PrefixForNs("ns2", true).first);
+ EXPECT_TRUE(stack.PrefixForNs("ns2", true).second);
+ EXPECT_EQ("pre1", stack.PrefixForNs("ns3", false).first);
+ EXPECT_EQ("pre1", stack.PrefixForNs("ns3", true).first);
+ EXPECT_EQ("", stack.PrefixForNs("ns4", false).first);
+ EXPECT_TRUE(stack.PrefixForNs("ns4", false).second);
+ EXPECT_EQ("pre4", stack.PrefixForNs("ns4", true).first);
+ EXPECT_EQ("", stack.PrefixForNs("ns5", false).first);
+ EXPECT_FALSE(stack.PrefixForNs("ns5", false).second);
+ EXPECT_EQ("", stack.PrefixForNs("ns5", true).first);
+ EXPECT_EQ("", stack.PrefixForNs("", false).first);
+ EXPECT_EQ("", stack.PrefixForNs("", true).first);
+
+ stack.AddXmlns("", "ns6");
+ EXPECT_EQ("", stack.PrefixForNs("ns6", false).first);
+ EXPECT_TRUE(stack.PrefixForNs("ns6", false).second);
+ EXPECT_EQ("", stack.PrefixForNs("ns6", true).first);
+ EXPECT_FALSE(stack.PrefixForNs("ns6", true).second);
+}
+
+TEST(XmlnsStackTest, TestFrames) {
+ XmlnsStack stack;
+ stack.PushFrame();
+ stack.AddXmlns("pre1", "ns1");
+ stack.AddXmlns("pre2", "ns2");
+
+ stack.PushFrame();
+ stack.AddXmlns("pre1", "ns3");
+ stack.AddXmlns("pre3", "ns2");
+ stack.AddXmlns("pre4", "ns4");
+
+ stack.PushFrame();
+ stack.PushFrame();
+ stack.AddXmlns("", "ns4");
+
+ // basic test
+ EXPECT_EQ("ns3", stack.NsForPrefix("pre1").first);
+ EXPECT_EQ("ns2", stack.NsForPrefix("pre2").first);
+ EXPECT_EQ("ns2", stack.NsForPrefix("pre3").first);
+ EXPECT_EQ("ns4", stack.NsForPrefix("pre4").first);
+ EXPECT_EQ("", stack.NsForPrefix("pre5").first);
+ EXPECT_FALSE(stack.NsForPrefix("pre5").second);
+ EXPECT_EQ("ns4", stack.NsForPrefix("").first);
+ EXPECT_TRUE(stack.NsForPrefix("").second);
+
+ // pop the default xmlns definition
+ stack.PopFrame();
+ EXPECT_EQ("ns3", stack.NsForPrefix("pre1").first);
+ EXPECT_EQ("ns2", stack.NsForPrefix("pre2").first);
+ EXPECT_EQ("ns2", stack.NsForPrefix("pre3").first);
+ EXPECT_EQ("ns4", stack.NsForPrefix("pre4").first);
+ EXPECT_EQ("", stack.NsForPrefix("pre5").first);
+ EXPECT_FALSE(stack.NsForPrefix("pre5").second);
+ EXPECT_EQ("", stack.NsForPrefix("").first);
+ EXPECT_TRUE(stack.NsForPrefix("").second);
+
+ // pop empty frame (nop)
+ stack.PopFrame();
+ EXPECT_EQ("ns3", stack.NsForPrefix("pre1").first);
+ EXPECT_EQ("ns2", stack.NsForPrefix("pre2").first);
+ EXPECT_EQ("ns2", stack.NsForPrefix("pre3").first);
+ EXPECT_EQ("ns4", stack.NsForPrefix("pre4").first);
+ EXPECT_EQ("", stack.NsForPrefix("pre5").first);
+ EXPECT_FALSE(stack.NsForPrefix("pre5").second);
+ EXPECT_EQ("", stack.NsForPrefix("").first);
+ EXPECT_TRUE(stack.NsForPrefix("").second);
+
+ // pop frame with three defs
+ stack.PopFrame();
+ EXPECT_EQ("ns1", stack.NsForPrefix("pre1").first);
+ EXPECT_EQ("ns2", stack.NsForPrefix("pre2").first);
+ EXPECT_EQ("", stack.NsForPrefix("pre3").first);
+ EXPECT_FALSE(stack.NsForPrefix("pre3").second);
+ EXPECT_EQ("", stack.NsForPrefix("pre4").first);
+ EXPECT_FALSE(stack.NsForPrefix("pre4").second);
+ EXPECT_EQ("", stack.NsForPrefix("pre5").first);
+ EXPECT_FALSE(stack.NsForPrefix("pre5").second);
+ EXPECT_EQ("", stack.NsForPrefix("").first);
+ EXPECT_TRUE(stack.NsForPrefix("").second);
+
+ // pop frame with last two defs
+ stack.PopFrame();
+ EXPECT_FALSE(stack.NsForPrefix("pre1").second);
+ EXPECT_FALSE(stack.NsForPrefix("pre2").second);
+ EXPECT_FALSE(stack.NsForPrefix("pre3").second);
+ EXPECT_FALSE(stack.NsForPrefix("pre4").second);
+ EXPECT_FALSE(stack.NsForPrefix("pre5").second);
+ EXPECT_TRUE(stack.NsForPrefix("").second);
+ EXPECT_EQ("", stack.NsForPrefix("pre1").first);
+ EXPECT_EQ("", stack.NsForPrefix("pre2").first);
+ EXPECT_EQ("", stack.NsForPrefix("pre3").first);
+ EXPECT_EQ("", stack.NsForPrefix("pre4").first);
+ EXPECT_EQ("", stack.NsForPrefix("pre5").first);
+ EXPECT_EQ("", stack.NsForPrefix("").first);
+}
+
+TEST(XmlnsStackTest, TestAddNewPrefix) {
+ XmlnsStack stack;
+
+ // builtin namespaces cannot be added
+ EXPECT_FALSE(stack.AddNewPrefix("", true).second);
+ EXPECT_FALSE(stack.AddNewPrefix("", false).second);
+ EXPECT_FALSE(stack.AddNewPrefix(NS_XML, true).second);
+ EXPECT_FALSE(stack.AddNewPrefix(NS_XML, false).second);
+ EXPECT_FALSE(stack.AddNewPrefix(NS_XMLNS, true).second);
+ EXPECT_FALSE(stack.AddNewPrefix(NS_XMLNS, false).second);
+
+ // namespaces already added cannot be added again.
+ EXPECT_EQ("foo", stack.AddNewPrefix("http://a.b.com/foo.htm", true).first);
+ EXPECT_EQ("bare", stack.AddNewPrefix("http://a.b.com/bare", false).first);
+ EXPECT_EQ("z", stack.AddNewPrefix("z", false).first);
+ EXPECT_FALSE(stack.AddNewPrefix("http://a.b.com/foo.htm", true).second);
+ EXPECT_FALSE(stack.AddNewPrefix("http://a.b.com/bare", true).second);
+ EXPECT_FALSE(stack.AddNewPrefix("z", true).second);
+ EXPECT_FALSE(stack.AddNewPrefix("http://a.b.com/foo.htm", false).second);
+ EXPECT_FALSE(stack.AddNewPrefix("http://a.b.com/bare", false).second);
+ EXPECT_FALSE(stack.AddNewPrefix("z", false).second);
+
+ // default namespace usable by non-attributes only
+ stack.AddXmlns("", "http://my/default");
+ EXPECT_FALSE(stack.AddNewPrefix("http://my/default", false).second);
+ EXPECT_EQ("def", stack.AddNewPrefix("http://my/default", true).first);
+
+ // namespace cannot start with 'xml'
+ EXPECT_EQ("ns", stack.AddNewPrefix("http://a.b.com/xmltest", true).first);
+ EXPECT_EQ("ns2", stack.AddNewPrefix("xmlagain", false).first);
+
+ // verify added namespaces are still defined
+ EXPECT_EQ("http://a.b.com/foo.htm", stack.NsForPrefix("foo").first);
+ EXPECT_TRUE(stack.NsForPrefix("foo").second);
+ EXPECT_EQ("http://a.b.com/bare", stack.NsForPrefix("bare").first);
+ EXPECT_TRUE(stack.NsForPrefix("bare").second);
+ EXPECT_EQ("z", stack.NsForPrefix("z").first);
+ EXPECT_TRUE(stack.NsForPrefix("z").second);
+ EXPECT_EQ("http://my/default", stack.NsForPrefix("").first);
+ EXPECT_TRUE(stack.NsForPrefix("").second);
+ EXPECT_EQ("http://my/default", stack.NsForPrefix("def").first);
+ EXPECT_TRUE(stack.NsForPrefix("def").second);
+ EXPECT_EQ("http://a.b.com/xmltest", stack.NsForPrefix("ns").first);
+ EXPECT_TRUE(stack.NsForPrefix("ns").second);
+ EXPECT_EQ("xmlagain", stack.NsForPrefix("ns2").first);
+ EXPECT_TRUE(stack.NsForPrefix("ns2").second);
+}
+
+TEST(XmlnsStackTest, TestFormatQName) {
+ XmlnsStack stack;
+ stack.AddXmlns("pre1", "ns1");
+ stack.AddXmlns("pre2", "ns2");
+ stack.AddXmlns("pre1", "ns3");
+ stack.AddXmlns("", "ns4");
+
+ EXPECT_EQ("zip",
+ stack.FormatQName(QName("ns1", "zip"), false)); // no match
+ EXPECT_EQ("pre2:abracadabra",
+ stack.FormatQName(QName("ns2", "abracadabra"), false));
+ EXPECT_EQ("pre1:a",
+ stack.FormatQName(QName("ns3", "a"), false));
+ EXPECT_EQ("simple",
+ stack.FormatQName(QName("ns4", "simple"), false));
+ EXPECT_EQ("root",
+ stack.FormatQName(QName("", "root"), false)); // no match
+
+ EXPECT_EQ("zip",
+ stack.FormatQName(QName("ns1", "zip"), true)); // no match
+ EXPECT_EQ("pre2:abracadabra",
+ stack.FormatQName(QName("ns2", "abracadabra"), true));
+ EXPECT_EQ("pre1:a",
+ stack.FormatQName(QName("ns3", "a"), true));
+ EXPECT_EQ("simple",
+ stack.FormatQName(QName("ns4", "simple"), true)); // no match
+ EXPECT_EQ("root",
+ stack.FormatQName(QName("", "root"), true));
+}
diff --git a/talk/xmllite/xmlparser.cc b/talk/xmllite/xmlparser.cc
index b267414..3e4d733 100644
--- a/talk/xmllite/xmlparser.cc
+++ b/talk/xmllite/xmlparser.cc
@@ -29,6 +29,7 @@
#include <string>
#include <vector>
+
#include "talk/base/common.h"
#include "talk/xmllite/xmlconstants.h"
#include "talk/xmllite/xmlelement.h"
@@ -206,12 +207,7 @@
void
XmlParser::ParseContext::StartNamespace(const char *prefix, const char *ns) {
- xmlnsstack_.AddXmlns(
- *prefix ? std::string(prefix) : STR_EMPTY,
-// ns == NS_CLIENT ? NS_CLIENT :
-// ns == NS_ROSTER ? NS_ROSTER :
-// ns == NS_GR ? NS_GR :
- std::string(ns));
+ xmlnsstack_.AddXmlns(*prefix ? prefix : STR_EMPTY, ns);
}
void
@@ -225,28 +221,25 @@
}
QName
-XmlParser::ParseContext::ResolveQName(const char *qname, bool isAttr) {
+XmlParser::ParseContext::ResolveQName(const char* qname, bool isAttr) {
const char *c;
for (c = qname; *c; ++c) {
if (*c == ':') {
- const std::string * result;
- result = xmlnsstack_.NsForPrefix(std::string(qname, c - qname));
- if (result == NULL)
- return QN_EMPTY;
- const char * localname = c + 1;
- return QName(*result, localname);
+ const std::pair<std::string, bool> result =
+ xmlnsstack_.NsForPrefix(std::string(qname, c - qname));
+ if (!result.second)
+ return QName();
+ return QName(result.first, c + 1);
}
}
- if (isAttr) {
+ if (isAttr)
return QName(STR_EMPTY, qname);
- }
- const std::string * result;
- result = xmlnsstack_.NsForPrefix(STR_EMPTY);
- if (result == NULL)
- return QN_EMPTY;
+ std::pair<std::string, bool> result = xmlnsstack_.NsForPrefix(STR_EMPTY);
+ if (!result.second)
+ return QName();
- return QName(*result, qname);
+ return QName(result.first, qname);
}
void
@@ -283,4 +276,4 @@
XmlParser::ParseContext::~ParseContext() {
}
-}
+} // namespace buzz
diff --git a/talk/xmllite/xmlparser.h b/talk/xmllite/xmlparser.h
index b461e7e..69cde75 100644
--- a/talk/xmllite/xmlparser.h
+++ b/talk/xmllite/xmlparser.h
@@ -25,8 +25,8 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef _xmlparser_h_
-#define _xmlparser_h_
+#ifndef TALK_XMLLITE_XMLPARSER_H_
+#define TALK_XMLLITE_XMLPARSER_H_
#include <string>
@@ -116,6 +116,6 @@
bool sentError_;
};
-}
+} // namespace buzz
-#endif
+#endif // TALK_XMLLITE_XMLPARSER_H_
diff --git a/talk/xmllite/xmlparser_unittest.cc b/talk/xmllite/xmlparser_unittest.cc
new file mode 100644
index 0000000..24947fb
--- /dev/null
+++ b/talk/xmllite/xmlparser_unittest.cc
@@ -0,0 +1,302 @@
+/*
+ * libjingle
+ * Copyright 2004, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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 <sstream>
+#include <iostream>
+#include "talk/base/common.h"
+#include "talk/base/gunit.h"
+#include "talk/xmllite/qname.h"
+#include "talk/xmllite/xmlparser.h"
+
+using buzz::QName;
+using buzz::XmlParser;
+using buzz::XmlParseContext;
+using buzz::XmlParseHandler;
+
+class XmlParserTestHandler : public XmlParseHandler {
+ public:
+ virtual void StartElement(XmlParseContext * pctx,
+ const char * name, const char ** atts) {
+ ss_ << "START (" << pctx->ResolveQName(name, false).Merged();
+ while (*atts) {
+ ss_ << ", " << pctx->ResolveQName(*atts, true).Merged()
+ << "='" << *(atts+1) << "'";
+ atts += 2;
+ }
+ ss_ << ") ";
+ }
+ virtual void EndElement(XmlParseContext * pctx, const char * name) {
+ UNUSED(pctx);
+ UNUSED(name);
+ ss_ << "END ";
+ }
+ virtual void CharacterData(XmlParseContext * pctx,
+ const char * text, int len) {
+ UNUSED(pctx);
+ ss_ << "TEXT (" << std::string(text, len) << ") ";
+ }
+ virtual void Error(XmlParseContext * pctx, XML_Error code) {
+ UNUSED(pctx);
+ ss_ << "ERROR (" << static_cast<int>(code) << ") ";
+ }
+ virtual ~XmlParserTestHandler() {
+ }
+
+ std::string Str() {
+ return ss_.str();
+ }
+
+ std::string StrClear() {
+ std::string result = ss_.str();
+ ss_.str("");
+ return result;
+ }
+
+ private:
+ std::stringstream ss_;
+};
+
+
+TEST(XmlParserTest, TestTrivial) {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler, "<testing/>");
+ EXPECT_EQ("START (testing) END ", handler.Str());
+}
+
+TEST(XmlParserTest, TestAttributes) {
+ {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler, "<testing a='b'/>");
+ EXPECT_EQ("START (testing, a='b') END ", handler.Str());
+ }
+ {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler, "<testing e='' long='some text'/>");
+ EXPECT_EQ("START (testing, e='', long='some text') END ", handler.Str());
+ }
+}
+
+TEST(XmlParserTest, TestNesting) {
+ {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler,
+ "<top><first/><second><third></third></second></top>");
+ EXPECT_EQ("START (top) START (first) END START (second) START (third) "
+ "END END END ", handler.Str());
+ }
+ {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler, "<top><fifth><deeper><and><deeper/></and>"
+ "<sibling><leaf/></sibling></deeper></fifth><first/><second>"
+ "<third></third></second></top>");
+ EXPECT_EQ("START (top) START (fifth) START (deeper) START (and) START "
+ "(deeper) END END START (sibling) START (leaf) END END END "
+ "END START (first) END START (second) START (third) END END END ",
+ handler.Str());
+ }
+}
+
+TEST(XmlParserTest, TestXmlDecl) {
+ {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler, "<?xml version=\"1.0\"?><testing/>");
+ EXPECT_EQ("START (testing) END ", handler.Str());
+ }
+ {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler,
+ "<?xml version=\"1.0\" encoding=\"utf-8\"?><testing/>");
+ EXPECT_EQ("START (testing) END ", handler.Str());
+ }
+ {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler,
+ "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
+ "<testing/>");
+ EXPECT_EQ("START (testing) END ", handler.Str());
+ }
+}
+
+TEST(XmlParserTest, TestNamespace) {
+ {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler, "<top xmlns='my-namespace' a='b'/>");
+ EXPECT_EQ("START (my-namespace:top, xmlns='my-namespace', a='b') END ",
+ handler.Str());
+ }
+ {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler, "<foo:top xmlns:foo='my-namespace' "
+ "a='b' foo:c='d'/>");
+ EXPECT_EQ("START (my-namespace:top, "
+ "http://www.w3.org/2000/xmlns/:foo='my-namespace', "
+ "a='b', my-namespace:c='d') END ", handler.Str());
+ }
+ {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler, "<top><nested xmlns='my-namespace'><leaf/>"
+ "</nested><sibling/></top>");
+ EXPECT_EQ("START (top) START (my-namespace:nested, xmlns='my-namespace') "
+ "START (my-namespace:leaf) END END START (sibling) END END ",
+ handler.Str());
+ }
+}
+
+TEST(XmlParserTest, TestIncremental) {
+ XmlParserTestHandler handler;
+ XmlParser parser(&handler);
+ std::string fragment;
+
+ fragment = "<stream:stream";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("", handler.StrClear());
+
+ fragment = " id=\"abcdefg\" xmlns=\"";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("", handler.StrClear());
+
+ fragment = "j:c\" xmlns:stream='hm";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("", handler.StrClear());
+
+ fragment = "ph'><test";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("START (hmph:stream, id='abcdefg', xmlns='j:c', "
+ "http://www.w3.org/2000/xmlns/:stream='hmph') ", handler.StrClear());
+
+ fragment = "ing/><again/>abracad";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("START (j:c:testing) END START (j:c:again) END TEXT (abracad) ",
+ handler.StrClear());
+
+ fragment = "abra</stream:";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("TEXT (abra) ", handler.StrClear());
+
+ fragment = "stream>";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("END ", handler.StrClear());
+}
+
+TEST(XmlParserTest, TestReset) {
+ {
+ XmlParserTestHandler handler;
+ XmlParser parser(&handler);
+ std::string fragment;
+
+ fragment = "<top><first/><second><third></third>";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("START (top) START (first) END START (second) START (third) END ",
+ handler.StrClear());
+
+ parser.Reset();
+ fragment = "<tip><first/><second><third></third>";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("START (tip) START (first) END START (second) START (third) END ",
+ handler.StrClear());
+ }
+ {
+ XmlParserTestHandler handler;
+ XmlParser parser(&handler);
+ std::string fragment;
+
+ fragment = "<top xmlns='m'>";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("START (m:top, xmlns='m') ", handler.StrClear());
+
+ fragment = "<testing/><frag";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("START (m:testing) END ", handler.StrClear());
+
+ parser.Reset();
+ fragment = "<testing><fragment/";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("START (testing) ", handler.StrClear());
+
+ fragment = ">";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("START (fragment) END ", handler.StrClear());
+ }
+}
+
+TEST(XmlParserTest, TestError) {
+ {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler, "junk");
+ EXPECT_EQ("ERROR (2) ", handler.Str());
+ }
+ {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler, "<top/> garbage ");
+ EXPECT_EQ("START (top) END ERROR (9) ", handler.Str());
+ }
+ {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler, "<-hm->");
+ EXPECT_EQ("ERROR (4) ", handler.Str());
+ }
+ {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler, "<hello>&foobar;</hello>");
+ EXPECT_EQ("START (hello) ERROR (11) ", handler.Str());
+ }
+ {
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler,
+ "<!DOCTYPE HTML PUBLIC \"foobar\" \"barfoo\">");
+ EXPECT_EQ("ERROR (3) ", handler.Str());
+ }
+ {
+ // XmlParser requires utf-8
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler,
+ "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?><test/>");
+ EXPECT_EQ("ERROR (19) ", handler.Str());
+ }
+ {
+ // XmlParser requires version 1.0
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler,
+ "<?xml version=\"2.0\"?><test/>");
+ EXPECT_EQ("ERROR (2) ", handler.Str());
+ }
+ {
+ // XmlParser requires standalone documents
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler,
+ "<?xml version=\"1.0\" standalone=\"no\"?><test/>");
+ EXPECT_EQ("ERROR (2) ", handler.Str());
+ }
+ {
+ // XmlParser doesn't like empty namespace URIs
+ XmlParserTestHandler handler;
+ XmlParser::ParseXml(&handler,
+ "<test xmlns:foo='' foo:bar='huh?'>");
+ EXPECT_EQ("ERROR (2) ", handler.Str());
+ }
+}
diff --git a/talk/xmllite/xmlprinter.cc b/talk/xmllite/xmlprinter.cc
index db6704b..1350454 100644
--- a/talk/xmllite/xmlprinter.cc
+++ b/talk/xmllite/xmlprinter.cc
@@ -25,130 +25,125 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include <ostream>
+#include "talk/xmllite/xmlprinter.h"
+
#include <sstream>
#include <string>
#include <vector>
-#include "talk/xmllite/xmlelement.h"
-#include "talk/xmllite/xmlprinter.h"
-#include "talk/xmllite/xmlnsstack.h"
+
#include "talk/xmllite/xmlconstants.h"
+#include "talk/xmllite/xmlelement.h"
+#include "talk/xmllite/xmlnsstack.h"
namespace buzz {
class XmlPrinterImpl {
public:
- XmlPrinterImpl(std::ostream * pout,
- const std::string * const xmlns, int xmlnsCount);
- void PrintElement(const XmlElement * element);
- void PrintQuotedValue(const std::string & text);
- void PrintBodyText(const std::string & text);
- void PrintCDATAText(const std::string & text);
+ XmlPrinterImpl(std::ostream* pout, XmlnsStack* ns_stack);
+ void PrintElement(const XmlElement* element);
+ void PrintQuotedValue(const std::string& text);
+ void PrintBodyText(const std::string& text);
+ void PrintCDATAText(const std::string& text);
private:
std::ostream *pout_;
- XmlnsStack xmlnsStack_;
+ XmlnsStack* ns_stack_;
};
-void
-XmlPrinter::PrintXml(std::ostream * pout, const XmlElement * element) {
- PrintXml(pout, element, NULL, 0);
+void XmlPrinter::PrintXml(std::ostream* pout, const XmlElement* element) {
+ XmlnsStack ns_stack;
+ PrintXml(pout, element, &ns_stack);
}
-void
-XmlPrinter::PrintXml(std::ostream * pout, const XmlElement * element,
- const std::string * const xmlns, int xmlnsCount) {
- XmlPrinterImpl printer(pout, xmlns, xmlnsCount);
+void XmlPrinter::PrintXml(std::ostream* pout, const XmlElement* element,
+ XmlnsStack* ns_stack) {
+ XmlPrinterImpl printer(pout, ns_stack);
printer.PrintElement(element);
}
-XmlPrinterImpl::XmlPrinterImpl(std::ostream * pout,
- const std::string * const xmlns, int xmlnsCount) :
- pout_(pout),
- xmlnsStack_() {
- int i;
- for (i = 0; i < xmlnsCount; i += 2) {
- xmlnsStack_.AddXmlns(xmlns[i], xmlns[i + 1]);
- }
+XmlPrinterImpl::XmlPrinterImpl(std::ostream* pout, XmlnsStack* ns_stack)
+ : pout_(pout),
+ ns_stack_(ns_stack) {
}
-void
-XmlPrinterImpl::PrintElement(const XmlElement * element) {
- xmlnsStack_.PushFrame();
+void XmlPrinterImpl::PrintElement(const XmlElement* element) {
+ ns_stack_->PushFrame();
// first go through attrs of pel to add xmlns definitions
- const XmlAttr * pattr;
- for (pattr = element->FirstAttr(); pattr; pattr = pattr->NextAttr()) {
- if (pattr->Name() == QN_XMLNS)
- xmlnsStack_.AddXmlns(STR_EMPTY, pattr->Value());
- else if (pattr->Name().Namespace() == NS_XMLNS)
- xmlnsStack_.AddXmlns(pattr->Name().LocalPart(),
- pattr->Value());
+ const XmlAttr* attr;
+ for (attr = element->FirstAttr(); attr; attr = attr->NextAttr()) {
+ if (attr->Name() == QN_XMLNS) {
+ ns_stack_->AddXmlns(STR_EMPTY, attr->Value());
+ } else if (attr->Name().Namespace() == NS_XMLNS) {
+ ns_stack_->AddXmlns(attr->Name().LocalPart(),
+ attr->Value());
+ }
}
// then go through qnames to make sure needed xmlns definitons are added
- std::vector<std::string> newXmlns;
+ std::vector<std::string> new_ns;
std::pair<std::string, bool> prefix;
- prefix = xmlnsStack_.AddNewPrefix(element->Name().Namespace(), false);
+ prefix = ns_stack_->AddNewPrefix(element->Name().Namespace(), false);
if (prefix.second) {
- newXmlns.push_back(prefix.first);
- newXmlns.push_back(element->Name().Namespace());
+ new_ns.push_back(prefix.first);
+ new_ns.push_back(element->Name().Namespace());
}
- for (pattr = element->FirstAttr(); pattr; pattr = pattr->NextAttr()) {
- prefix = xmlnsStack_.AddNewPrefix(pattr->Name().Namespace(), true);
+ for (attr = element->FirstAttr(); attr; attr = attr->NextAttr()) {
+ prefix = ns_stack_->AddNewPrefix(attr->Name().Namespace(), true);
if (prefix.second) {
- newXmlns.push_back(prefix.first);
- newXmlns.push_back(pattr->Name().Namespace());
+ new_ns.push_back(prefix.first);
+ new_ns.push_back(attr->Name().Namespace());
}
}
// print the element name
- *pout_ << '<' << xmlnsStack_.FormatQName(element->Name(), false);
+ *pout_ << '<' << ns_stack_->FormatQName(element->Name(), false);
// and the attributes
- for (pattr = element->FirstAttr(); pattr; pattr = pattr->NextAttr()) {
- *pout_ << ' ' << xmlnsStack_.FormatQName(pattr->Name(), true) << "=\"";
- PrintQuotedValue(pattr->Value());
+ for (attr = element->FirstAttr(); attr; attr = attr->NextAttr()) {
+ *pout_ << ' ' << ns_stack_->FormatQName(attr->Name(), true) << "=\"";
+ PrintQuotedValue(attr->Value());
*pout_ << '"';
}
// and the extra xmlns declarations
- std::vector<std::string>::iterator i(newXmlns.begin());
- while (i < newXmlns.end()) {
- if (*i == STR_EMPTY)
+ std::vector<std::string>::iterator i(new_ns.begin());
+ while (i < new_ns.end()) {
+ if (*i == STR_EMPTY) {
*pout_ << " xmlns=\"" << *(i + 1) << '"';
- else
+ } else {
*pout_ << " xmlns:" << *i << "=\"" << *(i + 1) << '"';
+ }
i += 2;
}
// now the children
- const XmlChild * pchild = element->FirstChild();
+ const XmlChild* child = element->FirstChild();
- if (pchild == NULL)
+ if (child == NULL)
*pout_ << "/>";
else {
*pout_ << '>';
- while (pchild) {
- if (pchild->IsText()) {
+ while (child) {
+ if (child->IsText()) {
if (element->IsCDATA()) {
- PrintCDATAText(pchild->AsText()->Text());
+ PrintCDATAText(child->AsText()->Text());
} else {
- PrintBodyText(pchild->AsText()->Text());
+ PrintBodyText(child->AsText()->Text());
}
- } else
- PrintElement(pchild->AsElement());
- pchild = pchild->NextChild();
+ } else {
+ PrintElement(child->AsElement());
+ }
+ child = child->NextChild();
}
- *pout_ << "</" << xmlnsStack_.FormatQName(element->Name(), false) << '>';
+ *pout_ << "</" << ns_stack_->FormatQName(element->Name(), false) << '>';
}
- xmlnsStack_.PopFrame();
+ ns_stack_->PopFrame();
}
-void
-XmlPrinterImpl::PrintQuotedValue(const std::string & text) {
+void XmlPrinterImpl::PrintQuotedValue(const std::string& text) {
size_t safe = 0;
for (;;) {
size_t unsafe = text.find_first_of("<>&\"", safe);
@@ -169,8 +164,7 @@
}
}
-void
-XmlPrinterImpl::PrintBodyText(const std::string & text) {
+void XmlPrinterImpl::PrintBodyText(const std::string& text) {
size_t safe = 0;
for (;;) {
size_t unsafe = text.find_first_of("<>&", safe);
@@ -190,9 +184,8 @@
}
}
-void
-XmlPrinterImpl::PrintCDATAText(const std::string & text) {
+void XmlPrinterImpl::PrintCDATAText(const std::string& text) {
*pout_ << "<![CDATA[" << text << "]]>";
}
-}
+} // namespace buzz
diff --git a/talk/xmllite/xmlprinter.h b/talk/xmllite/xmlprinter.h
index 96900d0..90cc255 100644
--- a/talk/xmllite/xmlprinter.h
+++ b/talk/xmllite/xmlprinter.h
@@ -2,48 +2,48 @@
* libjingle
* Copyright 2004--2005, Google Inc.
*
- * Redistribution and use in source and binary forms, with or without
+ * 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,
+ * 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
+ * 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
+ * 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,
+ * 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
+ * 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 _xmlprinter_h_
-#define _xmlprinter_h_
+#ifndef TALK_XMLLITE_XMLPRINTER_H_
+#define TALK_XMLLITE_XMLPRINTER_H_
#include <iosfwd>
#include <string>
-#include "talk/base/scoped_ptr.h"
namespace buzz {
class XmlElement;
+class XmlnsStack;
class XmlPrinter {
-public:
- static void PrintXml(std::ostream * pout, const XmlElement * pelt);
+ public:
+ static void PrintXml(std::ostream* pout, const XmlElement* pelt);
- static void PrintXml(std::ostream * pout, const XmlElement * pelt,
- const std::string * const xmlns, int xmlnsCount);
+ static void PrintXml(std::ostream* pout, const XmlElement* pelt,
+ XmlnsStack* ns_stack);
};
-}
+} // namespace buzz
-#endif
+#endif // TALK_XMLLITE_XMLPRINTER_H_
diff --git a/talk/xmllite/xmlprinter_unittest.cc b/talk/xmllite/xmlprinter_unittest.cc
new file mode 100644
index 0000000..60b0e42
--- /dev/null
+++ b/talk/xmllite/xmlprinter_unittest.cc
@@ -0,0 +1,62 @@
+/*
+ * libjingle
+ * Copyright 2004, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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/xmllite/xmlprinter.h"
+
+#include <sstream>
+#include <string>
+
+#include "talk/base/common.h"
+#include "talk/base/gunit.h"
+#include "talk/xmllite/qname.h"
+#include "talk/xmllite/xmlelement.h"
+#include "talk/xmllite/xmlnsstack.h"
+
+using buzz::QName;
+using buzz::XmlElement;
+using buzz::XmlnsStack;
+using buzz::XmlPrinter;
+
+TEST(XmlPrinterTest, TestBasicPrinting) {
+ XmlElement elt(QName("google:test", "first"));
+ std::stringstream ss;
+ XmlPrinter::PrintXml(&ss, &elt);
+ EXPECT_EQ("<test:first xmlns:test=\"google:test\"/>", ss.str());
+}
+
+TEST(XmlPrinterTest, TestNamespacedPrinting) {
+ XmlElement elt(QName("google:test", "first"));
+ elt.AddElement(new XmlElement(QName("nested:test", "second")));
+ std::stringstream ss;
+
+ XmlnsStack ns_stack;
+ ns_stack.AddXmlns("gg", "google:test");
+ ns_stack.AddXmlns("", "nested:test");
+
+ XmlPrinter::PrintXml(&ss, &elt, &ns_stack);
+ EXPECT_EQ("<gg:first><second/></gg:first>", ss.str());
+}
diff --git a/talk/xmpp/asyncsocket.h b/talk/xmpp/asyncsocket.h
index e4bce7f..fb4ef02 100644
--- a/talk/xmpp/asyncsocket.h
+++ b/talk/xmpp/asyncsocket.h
@@ -69,8 +69,9 @@
virtual bool Write(const char * data, size_t len) = 0;
virtual bool Close() = 0;
#if defined(FEATURE_ENABLE_SSL)
- // We allow matching any passed domain.
- // If both names are passed as empty, we do not require a match.
+ // We allow matching any passed domain. This allows us to avoid
+ // handling the valuable certificates for logins into proxies. If
+ // both names are passed as empty, we do not require a match.
virtual bool StartTls(const std::string & domainname) = 0;
#endif
diff --git a/talk/xmpp/chatroommodule.h b/talk/xmpp/chatroommodule.h
new file mode 100644
index 0000000..fddbecd
--- /dev/null
+++ b/talk/xmpp/chatroommodule.h
@@ -0,0 +1,258 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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 _multiuserchatmodule_h_
+#define _multiuserchatmodule_h_
+
+#include "talk/xmpp/module.h"
+#include "talk/xmpp/rostermodule.h"
+
+namespace buzz {
+
+// forward declarations
+class XmppChatroomModule;
+class XmppChatroomHandler;
+class XmppChatroomMember;
+class XmppChatroomMemberEnumerator;
+
+enum XmppChatroomState {
+ XMPP_CHATROOM_STATE_NOT_IN_ROOM = 0,
+ XMPP_CHATROOM_STATE_REQUESTED_ENTER = 1,
+ XMPP_CHATROOM_STATE_IN_ROOM = 2,
+ XMPP_CHATROOM_STATE_REQUESTED_EXIT = 3,
+};
+
+//! Module that encapsulates a chatroom.
+class XmppChatroomModule : public XmppModule {
+public:
+
+ //! Creates a new XmppChatroomModule
+ static XmppChatroomModule* Create();
+ virtual ~XmppChatroomModule() {}
+
+ //! Sets the chatroom handler (callbacks) for the chatroom
+ virtual XmppReturnStatus set_chatroom_handler(XmppChatroomHandler* handler) = 0;
+
+ //! Gets the chatroom handler for the module
+ virtual XmppChatroomHandler* chatroom_handler() = 0;
+
+ //! Sets the jid of the chatroom.
+ //! Has to be set before entering the chatroom and can't be changed
+ //! while in the chatroom
+ virtual XmppReturnStatus set_chatroom_jid(const Jid& chatroom_jid) = 0;
+
+ //! The jid for the chatroom
+ virtual const Jid& chatroom_jid() const = 0;
+
+ //! Sets the nickname of the member
+ //! Has to be set before entering the chatroom and can't be changed
+ //! while in the chatroom
+ virtual XmppReturnStatus set_nickname(const std::string& nickname) = 0;
+
+ //! The nickname of the member in the chatroom
+ virtual const std::string& nickname() const = 0;
+
+ //! Returns the jid of the member (this is the chatroom_jid plus the
+ //! nickname as the resource name)
+ virtual const Jid member_jid() const = 0;
+
+ //! Requests that the user enter a chatroom
+ //! The EnterChatroom callback will be called when the request is complete.
+ //! Password should be empty for a room that doesn't require a password
+ //! If the room doesn't exist, the server will create an "Instant Room" if the
+ //! server policy supports this action.
+ //! There will be different methods for creating/configuring a "Reserved Room"
+ //! Async callback for this method is ChatroomEnteredStatus
+ virtual XmppReturnStatus RequestEnterChatroom(const std::string& password) = 0;
+
+ //! Requests that the user exit a chatroom
+ //! Async callback for this method is ChatroomExitedStatus
+ virtual XmppReturnStatus RequestExitChatroom() = 0;
+
+ //! Requests a status change
+ //! status is the standard XMPP status code
+ //! extended_status is the extended status when status is XMPP_PRESENCE_XA
+ virtual XmppReturnStatus RequestStatusChange(XmppPresenceShow status,
+ const std::string& extended_status) = 0;
+
+ //! Returns the number of members in the room
+ virtual size_t GetChatroomMemberCount() = 0;
+
+ //! Gets an enumerator for the members in the chatroom
+ //! The caller must delete the enumerator when the caller is finished with it.
+ //! The caller must also ensure that the lifetime of the enumerator is
+ //! scoped by the XmppChatRoomModule that created it.
+ virtual XmppReturnStatus CreateMemberEnumerator(XmppChatroomMemberEnumerator** enumerator) = 0;
+
+ //! Gets the subject of the chatroom
+ virtual const std::string& subject() = 0;
+
+ //! Returns the current state of the user with respect to the chatroom
+ virtual XmppChatroomState state() = 0;
+
+ virtual XmppReturnStatus SendMessage(const XmlElement& message) = 0;
+};
+
+//! Class for enumerating participatns
+class XmppChatroomMemberEnumerator {
+public:
+ virtual ~XmppChatroomMemberEnumerator() { }
+ //! Returns the member at the current position
+ //! Returns null if the enumerator is before the beginning
+ //! or after the end of the collection
+ virtual XmppChatroomMember* current() = 0;
+
+ //! Returns whether the enumerator is valid
+ //! This returns true if the collection has changed
+ //! since the enumerator was created
+ virtual bool IsValid() = 0;
+
+ //! Returns whether the enumerator is before the beginning
+ //! This is the initial state of the enumerator
+ virtual bool IsBeforeBeginning() = 0;
+
+ //! Returns whether the enumerator is after the end
+ virtual bool IsAfterEnd() = 0;
+
+ //! Advances the enumerator to the next position
+ //! Returns false is the enumerator is advanced
+ //! off the end of the collection
+ virtual bool Next() = 0;
+
+ //! Advances the enumerator to the previous position
+ //! Returns false is the enumerator is advanced
+ //! off the end of the collection
+ virtual bool Prev() = 0;
+};
+
+
+//! Represents a single member in a chatroom
+class XmppChatroomMember {
+public:
+ virtual ~XmppChatroomMember() { }
+
+ //! The jid for the member in the chatroom
+ virtual const Jid member_jid() const = 0;
+
+ //! The full jid for the member
+ //! This is only available in non-anonymous rooms.
+ //! If the room is anonymous, this returns JID_EMPTY
+ virtual const Jid full_jid() const = 0;
+
+ //! Returns the backing presence for this member
+ virtual const XmppPresence* presence() const = 0;
+
+ //! The nickname for this member
+ virtual const std::string name() const = 0;
+};
+
+//! Status codes for ChatroomEnteredStatus callback
+enum XmppChatroomEnteredStatus
+{
+ //! User successfully entered the room
+ XMPP_CHATROOM_ENTERED_SUCCESS = 0,
+ //! The nickname confliced with somebody already in the room
+ XMPP_CHATROOM_ENTERED_FAILURE_NICKNAME_CONFLICT = 1,
+ //! A password is required to enter the room
+ XMPP_CHATROOM_ENTERED_FAILURE_PASSWORD_REQUIRED = 2,
+ //! The specified password was incorrect
+ XMPP_CHATROOM_ENTERED_FAILURE_PASSWORD_INCORRECT = 3,
+ //! The user is not a member of a member-only room
+ XMPP_CHATROOM_ENTERED_FAILURE_NOT_A_MEMBER = 4,
+ //! The user cannot enter because the user has been banned
+ XMPP_CHATROOM_ENTERED_FAILURE_MEMBER_BANNED = 5,
+ //! The room has the maximum number of users already
+ XMPP_CHATROOM_ENTERED_FAILURE_MAX_USERS = 6,
+ //! The room has been locked by an administrator
+ XMPP_CHATROOM_ENTERED_FAILURE_ROOM_LOCKED = 7,
+ //! Some other reason
+ XMPP_CHATROOM_ENTERED_FAILURE_UNSPECIFIED = 2000,
+};
+
+//! Status codes for ChatroomExitedStatus callback
+enum XmppChatroomExitedStatus
+{
+ //! The user requested to exit and did so
+ XMPP_CHATROOM_EXITED_REQUESTED = 0,
+ //! The user was banned from the room
+ XMPP_CHATROOM_EXITED_BANNED = 1,
+ //! The user has been kicked out of the room
+ XMPP_CHATROOM_EXITED_KICKED = 2,
+ //! The user has been removed from the room because the
+ //! user is no longer a member of a member-only room
+ //! or the room has changed to membership-only
+ XMPP_CHATROOM_EXITED_NOT_A_MEMBER = 3,
+ //! The system is shutting down
+ XMPP_CHATROOM_EXITED_SYSTEM_SHUTDOWN = 4,
+ //! For some other reason
+ XMPP_CHATROOM_EXITED_UNSPECIFIED = 5,
+};
+
+//! The XmppChatroomHandler is the interface for callbacks from the
+//! the chatroom
+class XmppChatroomHandler {
+public:
+ //! Indicates the response to RequestEnterChatroom method
+ //! XMPP_CHATROOM_SUCCESS represents success.
+ //! Other status codes are for errors
+ virtual void ChatroomEnteredStatus(XmppChatroomModule* room,
+ XmppChatroomEnteredStatus status) = 0;
+
+
+ //! Indicates that the user has exited the chatroom, either due to
+ //! a call to RequestExitChatroom or for some other reason.
+ //! status indicates the reason the user exited
+ virtual void ChatroomExitedStatus(XmppChatroomModule* room,
+ XmppChatroomExitedStatus status) = 0;
+
+ //! Indicates a member entered the room.
+ virtual void MemberEntered(XmppChatroomModule* room,
+ const XmppChatroomMember* entered_member) = 0;
+
+ //! Indicates that a member exited the room.
+ virtual void MemberExited(XmppChatroomModule* room,
+ const XmppChatroomMember* exited_member) = 0;
+
+ //! Indicates that the data for the member has changed
+ //! (such as the nickname or presence)
+ virtual void MemberChanged(XmppChatroomModule* room,
+ size_t index) = 0;
+
+ //! Indicates a new message has been received
+ //! message is the message -
+ // $TODO - message should be changed
+ //! to a strongly-typed message class that contains info
+ //! such as the sender, message bodies, etc.,
+ virtual void MessageReceived(XmppChatroomModule* room,
+ const XmlElement& message) = 0;
+};
+
+
+}
+
+#endif
+
diff --git a/talk/xmpp/chatroommodule_unittest.cc b/talk/xmpp/chatroommodule_unittest.cc
new file mode 100644
index 0000000..b857551
--- /dev/null
+++ b/talk/xmpp/chatroommodule_unittest.cc
@@ -0,0 +1,295 @@
+/*
+ * libjingle
+ * Copyright 2004, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * 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 <sstream>
+#include <iostream>
+#include "common/common.h"
+#include "buzz/xmppengine.h"
+#include "buzz/xmlelement.h"
+#include "buzz/chatroommodule.h"
+#include "buzz/constants.h"
+#include "engine/util_unittest.h"
+#include "test/unittest.h"
+#include "test/unittest-inl.h"
+
+#define TEST_OK(x) TEST_EQ((x),XMPP_RETURN_OK)
+#define TEST_BADARGUMENT(x) TEST_EQ((x),XMPP_RETURN_BADARGUMENT)
+
+namespace buzz {
+
+class MultiUserChatModuleTest;
+
+static void
+WriteEnteredStatus(std::ostream& os, XmppChatroomEnteredStatus status) {
+ switch(status) {
+ case XMPP_CHATROOM_ENTERED_SUCCESS:
+ os<<"success";
+ break;
+ case XMPP_CHATROOM_ENTERED_FAILURE_NICKNAME_CONFLICT:
+ os<<"failure(nickname conflict)";
+ break;
+ case XMPP_CHATROOM_ENTERED_FAILURE_PASSWORD_REQUIRED:
+ os<<"failure(password required)";
+ break;
+ case XMPP_CHATROOM_ENTERED_FAILURE_PASSWORD_INCORRECT:
+ os<<"failure(password incorrect)";
+ break;
+ case XMPP_CHATROOM_ENTERED_FAILURE_NOT_A_MEMBER:
+ os<<"failure(not a member)";
+ break;
+ case XMPP_CHATROOM_ENTERED_FAILURE_MEMBER_BANNED:
+ os<<"failure(member banned)";
+ break;
+ case XMPP_CHATROOM_ENTERED_FAILURE_MAX_USERS:
+ os<<"failure(max users)";
+ break;
+ case XMPP_CHATROOM_ENTERED_FAILURE_ROOM_LOCKED:
+ os<<"failure(room locked)";
+ break;
+ case XMPP_CHATROOM_ENTERED_FAILURE_UNSPECIFIED:
+ os<<"failure(unspecified)";
+ break;
+ default:
+ os<<"unknown";
+ break;
+ }
+}
+
+static void
+WriteExitedStatus(std::ostream& os, XmppChatroomExitedStatus status) {
+ switch (status) {
+ case XMPP_CHATROOM_EXITED_REQUESTED:
+ os<<"requested";
+ break;
+ case XMPP_CHATROOM_EXITED_BANNED:
+ os<<"banned";
+ break;
+ case XMPP_CHATROOM_EXITED_KICKED:
+ os<<"kicked";
+ break;
+ case XMPP_CHATROOM_EXITED_NOT_A_MEMBER:
+ os<<"not member";
+ break;
+ case XMPP_CHATROOM_EXITED_SYSTEM_SHUTDOWN:
+ os<<"system shutdown";
+ break;
+ case XMPP_CHATROOM_EXITED_UNSPECIFIED:
+ os<<"unspecified";
+ break;
+ default:
+ os<<"unknown";
+ break;
+ }
+}
+
+//! This session handler saves all calls to a string. These are events and
+//! data delivered form the engine to application code.
+class XmppTestChatroomHandler : public XmppChatroomHandler {
+public:
+ XmppTestChatroomHandler() {}
+ virtual ~XmppTestChatroomHandler() {}
+
+ void ChatroomEnteredStatus(XmppChatroomModule* room,
+ XmppChatroomEnteredStatus status) {
+ UNUSED(room);
+ ss_ <<"[ChatroomEnteredStatus status: ";
+ WriteEnteredStatus(ss_, status);
+ ss_ <<"]";
+ }
+
+
+ void ChatroomExitedStatus(XmppChatroomModule* room,
+ XmppChatroomExitedStatus status) {
+ UNUSED(room);
+ ss_ <<"[ChatroomExitedStatus status: ";
+ WriteExitedStatus(ss_, status);
+ ss_ <<"]";
+ }
+
+ void MemberEntered(XmppChatroomModule* room,
+ const XmppChatroomMember* entered_member) {
+ UNUSED(room);
+ ss_ << "[MemberEntered " << entered_member->member_jid().Str() << "]";
+ }
+
+ void MemberExited(XmppChatroomModule* room,
+ const XmppChatroomMember* exited_member) {
+ UNUSED(room);
+ ss_ << "[MemberExited " << exited_member->member_jid().Str() << "]";
+ }
+
+ void MemberChanged(XmppChatroomModule* room, size_t index) {
+ UNUSED2(room, index);
+ }
+
+ virtual void MessageReceived(XmppChatroomModule* room, const XmlElement& message) {
+ UNUSED2(room, message);
+ }
+
+
+ std::string Str() {
+ return ss_.str();
+ }
+
+ std::string StrClear() {
+ std::string result = ss_.str();
+ ss_.str("");
+ return result;
+ }
+
+private:
+ std::stringstream ss_;
+};
+
+//! This is the class that holds all of the unit test code for the
+//! roster module
+class XmppChatroomModuleTest : public UnitTest {
+public:
+ XmppChatroomModuleTest() {}
+
+ void TestEnterExitChatroom() {
+ std::stringstream dump;
+
+ // Configure the engine
+ scoped_ptr<XmppEngine> engine(XmppEngine::Create());
+ XmppTestHandler handler(engine.get());
+
+ // Configure the module and handler
+ scoped_ptr<XmppChatroomModule> chatroom(XmppChatroomModule::Create());
+
+ // Configure the module handler
+ chatroom->RegisterEngine(engine.get());
+
+ // Set up callbacks
+ engine->SetOutputHandler(&handler);
+ engine->AddStanzaHandler(&handler);
+ engine->SetSessionHandler(&handler);
+
+ // Set up minimal login info
+ engine->SetUser(Jid("david@my-server"));
+ engine->SetPassword("david");
+
+ // Do the whole login handshake
+ RunLogin(this, engine.get(), &handler);
+ TEST_EQ("", handler.OutputActivity());
+
+ // Get the chatroom and set the handler
+ XmppTestChatroomHandler chatroom_handler;
+ chatroom->set_chatroom_handler(static_cast<XmppChatroomHandler*>(&chatroom_handler));
+
+ // try to enter the chatroom
+ TEST_EQ(chatroom->state(), XMPP_CHATROOM_STATE_NOT_IN_ROOM);
+ chatroom->set_nickname("thirdwitch");
+ chatroom->set_chatroom_jid(Jid("darkcave@my-server"));
+ chatroom->RequestEnterChatroom("");
+ TEST_EQ(chatroom_handler.StrClear(), "");
+ TEST_EQ(handler.OutputActivity(),
+ "<presence to=\"darkcave@my-server/thirdwitch\">"
+ "<muc:x xmlns:muc=\"http://jabber.org/protocol/muc\"/>"
+ "</presence>");
+ TEST_EQ(chatroom->state(), XMPP_CHATROOM_STATE_REQUESTED_ENTER);
+
+ // simulate the server and test the client
+ std::string input;
+ input = "<presence from=\"darkcave@my-server/firstwitch\" to=\"david@my-server\">"
+ "<x xmlns=\"http://jabber.org/protocol/muc#user\">"
+ "<item affiliation=\"owner\" role=\"participant\"/>"
+ "</x>"
+ "</presence>";
+ TEST_OK(engine->HandleInput(input.c_str(), input.length()));
+ TEST_EQ(chatroom_handler.StrClear(), "");
+ TEST_EQ(chatroom->state(), XMPP_CHATROOM_STATE_REQUESTED_ENTER);
+
+ input = "<presence from=\"darkcave@my-server/secondwitch\" to=\"david@my-server\">"
+ "<x xmlns=\"http://jabber.org/protocol/muc#user\">"
+ "<item affiliation=\"member\" role=\"participant\"/>"
+ "</x>"
+ "</presence>";
+ TEST_OK(engine->HandleInput(input.c_str(), input.length()));
+ TEST_EQ(chatroom_handler.StrClear(), "");
+ TEST_EQ(chatroom->state(), XMPP_CHATROOM_STATE_REQUESTED_ENTER);
+
+ input = "<presence from=\"darkcave@my-server/thirdwitch\" to=\"david@my-server\">"
+ "<x xmlns=\"http://jabber.org/protocol/muc#user\">"
+ "<item affiliation=\"member\" role=\"participant\"/>"
+ "</x>"
+ "</presence>";
+ TEST_OK(engine->HandleInput(input.c_str(), input.length()));
+ TEST_EQ(chatroom_handler.StrClear(),
+ "[ChatroomEnteredStatus status: success]");
+ TEST_EQ(chatroom->state(), XMPP_CHATROOM_STATE_IN_ROOM);
+
+ // simulate somebody else entering the room after we entered
+ input = "<presence from=\"darkcave@my-server/fourthwitch\" to=\"david@my-server\">"
+ "<x xmlns=\"http://jabber.org/protocol/muc#user\">"
+ "<item affiliation=\"member\" role=\"participant\"/>"
+ "</x>"
+ "</presence>";
+ TEST_OK(engine->HandleInput(input.c_str(), input.length()));
+ TEST_EQ(chatroom_handler.StrClear(), "[MemberEntered darkcave@my-server/fourthwitch]");
+ TEST_EQ(chatroom->state(), XMPP_CHATROOM_STATE_IN_ROOM);
+
+ // simulate somebody else leaving the room after we entered
+ input = "<presence from=\"darkcave@my-server/secondwitch\" to=\"david@my-server\" type=\"unavailable\">"
+ "<x xmlns=\"http://jabber.org/protocol/muc#user\">"
+ "<item affiliation=\"member\" role=\"participant\"/>"
+ "</x>"
+ "</presence>";
+ TEST_OK(engine->HandleInput(input.c_str(), input.length()));
+ TEST_EQ(chatroom_handler.StrClear(), "[MemberExited darkcave@my-server/secondwitch]");
+ TEST_EQ(chatroom->state(), XMPP_CHATROOM_STATE_IN_ROOM);
+
+ // try to leave the room
+ chatroom->RequestExitChatroom();
+ TEST_EQ(chatroom_handler.StrClear(), "");
+ TEST_EQ(handler.OutputActivity(),
+ "<presence to=\"darkcave@my-server/thirdwitch\" type=\"unavailable\"/>");
+ TEST_EQ(chatroom->state(), XMPP_CHATROOM_STATE_REQUESTED_EXIT);
+
+ // simulate the server and test the client
+ input = "<presence from=\"darkcave@my-server/thirdwitch\" to=\"david@my-server\" type=\"unavailable\">"
+ "<x xmlns=\"http://jabber.org/protocol/muc#user\">"
+ "<item affiliation=\"member\" role=\"participant\"/>"
+ "</x>"
+ "</presence>";
+ TEST_OK(engine->HandleInput(input.c_str(), input.length()));
+ TEST_EQ(chatroom_handler.StrClear(),
+ "[ChatroomExitedStatus status: requested]");
+ TEST_EQ(chatroom->state(), XMPP_CHATROOM_STATE_NOT_IN_ROOM);
+ }
+
+};
+
+// A global function that creates the test suite for this set of tests.
+TestBase* ChatroomModuleTest_Create() {
+ TestSuite* suite = new TestSuite("ChatroomModuleTest");
+ ADD_TEST(suite, XmppChatroomModuleTest, TestEnterExitChatroom);
+ return suite;
+}
+
+}
diff --git a/talk/xmpp/chatroommoduleimpl.cc b/talk/xmpp/chatroommoduleimpl.cc
new file mode 100644
index 0000000..0fbbe7e
--- /dev/null
+++ b/talk/xmpp/chatroommoduleimpl.cc
@@ -0,0 +1,676 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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 <vector>
+#include <string>
+#include <map>
+#include <algorithm>
+#include <sstream>
+#include <iostream>
+#include "talk/base/common.h"
+#include "talk/xmpp/constants.h"
+#include "talk/xmpp/moduleimpl.h"
+#include "talk/xmpp/chatroommodule.h"
+
+namespace buzz {
+
+// forward declarations
+class XmppChatroomImpl;
+class XmppChatroomMemberImpl;
+
+//! Module that encapsulates multiple chatrooms.
+//! Each chatroom is represented by an XmppChatroomImpl instance
+class XmppChatroomModuleImpl : public XmppChatroomModule,
+ public XmppModuleImpl, public XmppIqHandler {
+public:
+ IMPLEMENT_XMPPMODULE
+
+ // Creates a chatroom with specified Jid
+ XmppChatroomModuleImpl();
+ ~XmppChatroomModuleImpl();
+
+ // XmppChatroomModule
+ virtual XmppReturnStatus set_chatroom_handler(XmppChatroomHandler* handler);
+ virtual XmppChatroomHandler* chatroom_handler();
+ virtual XmppReturnStatus set_chatroom_jid(const Jid& chatroom_jid);
+ virtual const Jid& chatroom_jid() const;
+ virtual XmppReturnStatus set_nickname(const std::string& nickname);
+ virtual const std::string& nickname() const;
+ virtual const Jid member_jid() const;
+ virtual XmppReturnStatus RequestEnterChatroom(const std::string& password);
+ virtual XmppReturnStatus RequestExitChatroom();
+ virtual XmppReturnStatus RequestStatusChange(XmppPresenceShow status,
+ const std::string& extended_status);
+ virtual size_t GetChatroomMemberCount();
+ virtual XmppReturnStatus CreateMemberEnumerator(XmppChatroomMemberEnumerator** enumerator);
+ virtual const std::string& subject();
+ virtual XmppChatroomState state() { return chatroom_state_; }
+ virtual XmppReturnStatus SendMessage(const XmlElement& message);
+
+ // XmppModule
+ virtual void IqResponse(XmppIqCookie cookie, const XmlElement * pelStanza) {UNUSED2(cookie, pelStanza);}
+ virtual bool HandleStanza(const XmlElement *);
+
+private:
+ friend class XmppChatroomMemberEnumeratorImpl;
+
+ XmppReturnStatus ServerChangeMyPresence(const XmlElement& presence);
+ XmppReturnStatus ClientChangeMyPresence(XmppChatroomState new_state);
+ XmppReturnStatus ChangePresence(XmppChatroomState new_state, const XmlElement* presence, bool isServer);
+ XmppReturnStatus ServerChangedOtherPresence(const XmlElement& presence_element);
+ XmppChatroomEnteredStatus GetEnterFailureFromXml(const XmlElement* presence);
+ XmppChatroomExitedStatus GetExitFailureFromXml(const XmlElement* presence);
+
+ bool CheckEnterChatroomStateOk();
+
+ void FireEnteredStatus(XmppChatroomEnteredStatus status);
+ void FireExitStatus(XmppChatroomExitedStatus status);
+ void FireMessageReceived(const XmlElement& message);
+ void FireMemberEntered(const XmppChatroomMember* entered_member);
+ void FireMemberExited(const XmppChatroomMember* exited_member);
+
+
+ typedef std::map<Jid, XmppChatroomMemberImpl*> JidMemberMap;
+
+ XmppChatroomHandler* chatroom_handler_;
+ Jid chatroom_jid_;
+ std::string nickname_;
+ XmppChatroomState chatroom_state_;
+ JidMemberMap chatroom_jid_members_;
+ int chatroom_jid_members_version_;
+};
+
+
+class XmppChatroomMemberImpl : public XmppChatroomMember {
+public:
+ ~XmppChatroomMemberImpl() {}
+ XmppReturnStatus SetPresence(const XmppPresence* presence);
+
+ // XmppChatroomMember
+ const Jid member_jid() const;
+ const Jid full_jid() const;
+ const std::string name() const;
+ const XmppPresence* presence() const;
+
+private:
+ talk_base::scoped_ptr<XmppPresence> presence_;
+};
+
+class XmppChatroomMemberEnumeratorImpl :
+ public XmppChatroomMemberEnumerator {
+public:
+ XmppChatroomMemberEnumeratorImpl(XmppChatroomModuleImpl::JidMemberMap* chatroom_jid_members,
+ int* map_version);
+
+ // XmppChatroomMemberEnumerator
+ virtual XmppChatroomMember* current();
+ virtual bool Next();
+ virtual bool Prev();
+ virtual bool IsValid();
+ virtual bool IsBeforeBeginning();
+ virtual bool IsAfterEnd();
+
+private:
+ XmppChatroomModuleImpl::JidMemberMap* map_;
+ int map_version_created_;
+ int* map_version_;
+ XmppChatroomModuleImpl::JidMemberMap::iterator iterator_;
+ bool before_beginning_;
+};
+
+
+// XmppChatroomModuleImpl ------------------------------------------------
+XmppChatroomModule *
+XmppChatroomModule::Create() {
+ return new XmppChatroomModuleImpl();
+}
+
+XmppChatroomModuleImpl::XmppChatroomModuleImpl() :
+ chatroom_handler_(NULL),
+ chatroom_jid_(STR_EMPTY),
+ chatroom_state_(XMPP_CHATROOM_STATE_NOT_IN_ROOM),
+ chatroom_jid_members_version_(0) {
+}
+
+XmppChatroomModuleImpl::~XmppChatroomModuleImpl() {
+ JidMemberMap::iterator iterator = chatroom_jid_members_.begin();
+ while (iterator != chatroom_jid_members_.end()) {
+ delete iterator->second;
+ iterator++;
+ }
+}
+
+
+bool
+XmppChatroomModuleImpl::HandleStanza(const XmlElement* stanza) {
+ ASSERT(engine() != NULL);
+
+ // we handle stanzas that are for one of our chatrooms
+ Jid from_jid = Jid(stanza->Attr(QN_FROM));
+ // see if it's one of our chatrooms
+ if (chatroom_jid_ != from_jid.BareJid()) {
+ return false; // not one of our chatrooms
+ } else {
+ // handle presence stanza
+ if (stanza->Name() == QN_PRESENCE) {
+ if (from_jid == member_jid()) {
+ ServerChangeMyPresence(*stanza);
+ } else {
+ ServerChangedOtherPresence(*stanza);
+ }
+ } else if (stanza->Name() == QN_MESSAGE) {
+ FireMessageReceived(*stanza);
+ }
+ return true;
+ }
+}
+
+
+XmppReturnStatus
+XmppChatroomModuleImpl::set_chatroom_handler(XmppChatroomHandler* handler) {
+ // Calling with NULL removes the handler.
+ chatroom_handler_ = handler;
+ return XMPP_RETURN_OK;
+}
+
+
+XmppChatroomHandler*
+XmppChatroomModuleImpl::chatroom_handler() {
+ return chatroom_handler_;
+}
+
+XmppReturnStatus
+XmppChatroomModuleImpl::set_chatroom_jid(const Jid& chatroom_jid) {
+ if (chatroom_state_ != XMPP_CHATROOM_STATE_NOT_IN_ROOM) {
+ return XMPP_RETURN_BADSTATE; // $TODO - this isn't a bad state, it's a bad call, diff error code?
+ }
+ if (chatroom_jid != chatroom_jid.BareJid()) {
+ // chatroom_jid must be a bare jid
+ return XMPP_RETURN_BADARGUMENT;
+ }
+
+ chatroom_jid_ = chatroom_jid;
+ return XMPP_RETURN_OK;
+}
+
+const Jid&
+XmppChatroomModuleImpl::chatroom_jid() const {
+ return chatroom_jid_;
+}
+
+ XmppReturnStatus
+ XmppChatroomModuleImpl::set_nickname(const std::string& nickname) {
+ if (chatroom_state_ != XMPP_CHATROOM_STATE_NOT_IN_ROOM) {
+ return XMPP_RETURN_BADSTATE; // $TODO - this isn't a bad state, it's a bad call, diff error code?
+ }
+ nickname_ = nickname;
+ return XMPP_RETURN_OK;
+ }
+
+ const std::string&
+ XmppChatroomModuleImpl::nickname() const {
+ return nickname_;
+ }
+
+const Jid
+XmppChatroomModuleImpl::member_jid() const {
+ return Jid(chatroom_jid_.node(), chatroom_jid_.domain(), nickname_);
+}
+
+
+bool
+XmppChatroomModuleImpl::CheckEnterChatroomStateOk() {
+ if (chatroom_jid_.IsValid() == false) {
+ ASSERT(0);
+ return false;
+ }
+ if (nickname_ == STR_EMPTY) {
+ ASSERT(0);
+ return false;
+ }
+ return true;
+}
+
+XmppReturnStatus
+XmppChatroomModuleImpl::RequestEnterChatroom(const std::string& password) {
+ UNUSED(password);
+ if (!engine())
+ return XMPP_RETURN_BADSTATE;
+
+ if (chatroom_state_ != XMPP_CHATROOM_STATE_NOT_IN_ROOM)
+ return XMPP_RETURN_BADSTATE; // $TODO - this isn't a bad state, it's a bad call, diff error code?
+
+ if (CheckEnterChatroomStateOk() == false) {
+ return XMPP_RETURN_BADSTATE;
+ }
+
+ // entering a chatroom is a presence request to the server
+ XmlElement element(QN_PRESENCE);
+ element.AddAttr(QN_TO, member_jid().Str());
+ element.AddElement(new XmlElement(QN_MUC_X));
+ XmppReturnStatus status = engine()->SendStanza(&element);
+ if (status == XMPP_RETURN_OK) {
+ return ClientChangeMyPresence(XMPP_CHATROOM_STATE_REQUESTED_ENTER);
+ }
+ return status;
+}
+
+
+XmppReturnStatus
+XmppChatroomModuleImpl::RequestExitChatroom() {
+ if (!engine())
+ return XMPP_RETURN_BADSTATE;
+
+ // currently, can't leave a room unless you've entered
+ // no way to cancel a pending enter call - is that bad?
+ if (chatroom_state_ != XMPP_CHATROOM_STATE_IN_ROOM)
+ return XMPP_RETURN_BADSTATE; // $TODO - this isn't a bad state, it's a bad call, diff error code?
+
+ // exiting a chatroom is a presence request to the server
+ XmlElement element(QN_PRESENCE);
+ element.AddAttr(QN_TO, member_jid().Str());
+ element.AddAttr(QN_TYPE, "unavailable");
+ XmppReturnStatus status = engine()->SendStanza(&element);
+ if (status == XMPP_RETURN_OK) {
+ return ClientChangeMyPresence(XMPP_CHATROOM_STATE_REQUESTED_EXIT);
+ }
+ return status;
+}
+
+XmppReturnStatus
+XmppChatroomModuleImpl::RequestStatusChange(XmppPresenceShow status,
+ const std::string& extended_status) {
+ UNUSED2(status, extended_status);
+ return XMPP_RETURN_BADSTATE; //NYI
+}
+
+
+
+size_t
+XmppChatroomModuleImpl::GetChatroomMemberCount() {
+ return chatroom_jid_members_.size();
+}
+
+XmppReturnStatus
+XmppChatroomModuleImpl::CreateMemberEnumerator(XmppChatroomMemberEnumerator** enumerator) {
+ *enumerator = new XmppChatroomMemberEnumeratorImpl(&chatroom_jid_members_, &chatroom_jid_members_version_);
+ return XMPP_RETURN_OK;
+}
+
+const std::string&
+XmppChatroomModuleImpl::subject() {
+ return STR_EMPTY; //NYI
+}
+
+XmppReturnStatus
+XmppChatroomModuleImpl::SendMessage(const XmlElement& message) {
+ XmppReturnStatus xmpp_status = XMPP_RETURN_OK;
+
+ // can only send a message if we're in the room
+ if (chatroom_state_ != XMPP_CHATROOM_STATE_IN_ROOM) {
+ return XMPP_RETURN_BADSTATE; // $TODO - this isn't a bad state, it's a bad call, diff error code?
+ }
+
+ if (message.Name() != QN_MESSAGE) {
+ IFR(XMPP_RETURN_BADARGUMENT);
+ }
+
+ const std::string& type = message.Attr(QN_TYPE);
+ if (type != "groupchat") {
+ IFR(XMPP_RETURN_BADARGUMENT);
+ }
+
+ if (message.HasAttr(QN_FROM)) {
+ IFR(XMPP_RETURN_BADARGUMENT);
+ }
+
+ if (message.Attr(QN_TO) != chatroom_jid_.Str()) {
+ IFR(XMPP_RETURN_BADARGUMENT);
+ }
+
+ IFR(engine()->SendStanza(&message));
+
+ return xmpp_status;
+}
+
+enum TransitionType {
+ TRANSITION_TYPE_NONE = 0,
+ TRANSITION_TYPE_ENTER_SUCCESS = 1,
+ TRANSITION_TYPE_ENTER_FAILURE = 2,
+ TRANSITION_TYPE_EXIT_VOLUNTARILY = 3,
+ TRANSITION_TYPE_EXIT_INVOLUNTARILY = 4,
+};
+
+struct StateTransitionDescription {
+ XmppChatroomState old_state;
+ XmppChatroomState new_state;
+ bool is_valid_server_transition;
+ bool is_valid_client_transition;
+ TransitionType transition_type;
+};
+
+StateTransitionDescription Transitions[] = {
+ { XMPP_CHATROOM_STATE_NOT_IN_ROOM, XMPP_CHATROOM_STATE_REQUESTED_ENTER, false, true, TRANSITION_TYPE_NONE, },
+ { XMPP_CHATROOM_STATE_NOT_IN_ROOM, XMPP_CHATROOM_STATE_IN_ROOM, false, false, TRANSITION_TYPE_ENTER_SUCCESS, },
+ { XMPP_CHATROOM_STATE_NOT_IN_ROOM, XMPP_CHATROOM_STATE_REQUESTED_EXIT, false, false, TRANSITION_TYPE_NONE, },
+ { XMPP_CHATROOM_STATE_REQUESTED_ENTER, XMPP_CHATROOM_STATE_NOT_IN_ROOM, true, false, TRANSITION_TYPE_ENTER_FAILURE, },
+ { XMPP_CHATROOM_STATE_REQUESTED_ENTER, XMPP_CHATROOM_STATE_IN_ROOM, true, false, TRANSITION_TYPE_ENTER_SUCCESS, },
+ { XMPP_CHATROOM_STATE_REQUESTED_ENTER, XMPP_CHATROOM_STATE_REQUESTED_EXIT, false, false, TRANSITION_TYPE_NONE, },
+ { XMPP_CHATROOM_STATE_IN_ROOM, XMPP_CHATROOM_STATE_NOT_IN_ROOM, true, false, TRANSITION_TYPE_EXIT_INVOLUNTARILY, },
+ { XMPP_CHATROOM_STATE_IN_ROOM, XMPP_CHATROOM_STATE_REQUESTED_ENTER, false, false, TRANSITION_TYPE_NONE, },
+ { XMPP_CHATROOM_STATE_IN_ROOM, XMPP_CHATROOM_STATE_REQUESTED_EXIT, false, true, TRANSITION_TYPE_NONE, },
+ { XMPP_CHATROOM_STATE_REQUESTED_EXIT, XMPP_CHATROOM_STATE_NOT_IN_ROOM, true, false, TRANSITION_TYPE_EXIT_VOLUNTARILY, },
+ { XMPP_CHATROOM_STATE_REQUESTED_EXIT, XMPP_CHATROOM_STATE_REQUESTED_ENTER, false, false, TRANSITION_TYPE_NONE, },
+ { XMPP_CHATROOM_STATE_REQUESTED_EXIT, XMPP_CHATROOM_STATE_IN_ROOM, false, false, TRANSITION_TYPE_NONE, },
+};
+
+
+
+void
+XmppChatroomModuleImpl::FireEnteredStatus(XmppChatroomEnteredStatus status) {
+ if (chatroom_handler_)
+ chatroom_handler_->ChatroomEnteredStatus(this, status);
+}
+
+void
+XmppChatroomModuleImpl::FireExitStatus(XmppChatroomExitedStatus status) {
+ if (chatroom_handler_)
+ chatroom_handler_->ChatroomExitedStatus(this, status);
+}
+
+void
+XmppChatroomModuleImpl::FireMessageReceived(const XmlElement& message) {
+ if (chatroom_handler_)
+ chatroom_handler_->MessageReceived(this, message);
+}
+
+void
+XmppChatroomModuleImpl::FireMemberEntered(const XmppChatroomMember* entered_member) {
+ // only fire if we're in the room
+ if (chatroom_state_ == XMPP_CHATROOM_STATE_IN_ROOM) {
+ if (chatroom_handler_)
+ chatroom_handler_->MemberEntered(this, entered_member);
+ }
+}
+
+void
+XmppChatroomModuleImpl::FireMemberExited(const XmppChatroomMember* exited_member) {
+ // only fire if we're in the room
+ if (chatroom_state_ == XMPP_CHATROOM_STATE_IN_ROOM) {
+ if (chatroom_handler_)
+ chatroom_handler_->MemberExited(this, exited_member);
+ }
+}
+
+
+XmppReturnStatus
+XmppChatroomModuleImpl::ServerChangedOtherPresence(const XmlElement&
+ presence_element) {
+ XmppReturnStatus xmpp_status = XMPP_RETURN_OK;
+ talk_base::scoped_ptr<XmppPresence> presence(XmppPresence::Create());
+ IFR(presence->set_raw_xml(&presence_element));
+
+ JidMemberMap::iterator pos = chatroom_jid_members_.find(presence->jid());
+
+ if (pos == chatroom_jid_members_.end()) {
+ if (presence->available() == XMPP_PRESENCE_AVAILABLE) {
+ XmppChatroomMemberImpl* member = new XmppChatroomMemberImpl();
+ member->SetPresence(presence.get());
+ chatroom_jid_members_.insert(std::make_pair(member->member_jid(), member));
+ chatroom_jid_members_version_++;
+ FireMemberEntered(member);
+ }
+ } else {
+ XmppChatroomMemberImpl* member = pos->second;
+ if (presence->available() == XMPP_PRESENCE_AVAILABLE) {
+ member->SetPresence(presence.get());
+ chatroom_jid_members_version_++;
+ // $TODO - fire change
+ }
+ else if (presence->available() == XMPP_PRESENCE_UNAVAILABLE) {
+ chatroom_jid_members_.erase(pos);
+ chatroom_jid_members_version_++;
+ FireMemberExited(member);
+ delete member;
+ }
+ }
+
+ return xmpp_status;
+}
+
+XmppReturnStatus
+XmppChatroomModuleImpl::ClientChangeMyPresence(XmppChatroomState new_state) {
+ return ChangePresence(new_state, NULL, false);
+}
+
+XmppReturnStatus
+XmppChatroomModuleImpl::ServerChangeMyPresence(const XmlElement& presence) {
+ XmppChatroomState new_state;
+
+ if (presence.HasAttr(QN_TYPE) == false) {
+ new_state = XMPP_CHATROOM_STATE_IN_ROOM;
+ } else {
+ new_state = XMPP_CHATROOM_STATE_NOT_IN_ROOM;
+ }
+ return ChangePresence(new_state, &presence, true);
+
+}
+
+XmppReturnStatus
+XmppChatroomModuleImpl::ChangePresence(XmppChatroomState new_state,
+ const XmlElement* presence,
+ bool isServer) {
+ UNUSED(presence);
+
+ XmppChatroomState old_state = chatroom_state_;
+
+ // do nothing if state hasn't changed
+ if (old_state == new_state)
+ return XMPP_RETURN_OK;
+
+ // find the right transition description
+ StateTransitionDescription* transition_desc = NULL;
+ for (int i=0; i < ARRAY_SIZE(Transitions); i++) {
+ if (Transitions[i].old_state == old_state &&
+ Transitions[i].new_state == new_state) {
+ transition_desc = &Transitions[i];
+ break;
+ }
+ }
+
+ if (transition_desc == NULL) {
+ ASSERT(0);
+ return XMPP_RETURN_BADSTATE;
+ }
+
+ // we assert for any invalid transition states, and we'll
+ if (isServer) {
+ // $TODO send original stanza back to server and log an error?
+ ASSERT(transition_desc->is_valid_server_transition);
+ } else {
+ if (transition_desc->is_valid_client_transition == false) {
+ ASSERT(0);
+ return XMPP_RETURN_BADARGUMENT;
+ }
+ }
+
+ // set the new state and then fire any notifications to the handler
+ chatroom_state_ = new_state;
+
+ switch (transition_desc->transition_type) {
+ case TRANSITION_TYPE_ENTER_SUCCESS:
+ FireEnteredStatus(XMPP_CHATROOM_ENTERED_SUCCESS);
+ break;
+ case TRANSITION_TYPE_ENTER_FAILURE:
+ FireEnteredStatus(GetEnterFailureFromXml(presence));
+ break;
+ case TRANSITION_TYPE_EXIT_INVOLUNTARILY:
+ FireExitStatus(GetExitFailureFromXml(presence));
+ break;
+ case TRANSITION_TYPE_EXIT_VOLUNTARILY:
+ FireExitStatus(XMPP_CHATROOM_EXITED_REQUESTED);
+ break;
+ case TRANSITION_TYPE_NONE:
+ break;
+ }
+
+ return XMPP_RETURN_OK;
+}
+
+XmppChatroomEnteredStatus
+XmppChatroomModuleImpl::GetEnterFailureFromXml(const XmlElement* presence) {
+ XmppChatroomEnteredStatus status = XMPP_CHATROOM_ENTERED_FAILURE_UNSPECIFIED;
+ const XmlElement* error = presence->FirstNamed(QN_ERROR);
+ if (error != NULL && error->HasAttr(QN_CODE)) {
+ int code = atoi(error->Attr(QN_CODE).c_str());
+ switch (code) {
+ case 401: status = XMPP_CHATROOM_ENTERED_FAILURE_PASSWORD_REQUIRED; break;
+ case 403: status = XMPP_CHATROOM_ENTERED_FAILURE_MEMBER_BANNED; break;
+ case 405: status = XMPP_CHATROOM_ENTERED_FAILURE_MAX_USERS; break;
+ case 407: status = XMPP_CHATROOM_ENTERED_FAILURE_NOT_A_MEMBER; break;
+ case 409: status = XMPP_CHATROOM_ENTERED_FAILURE_NICKNAME_CONFLICT; break;
+ }
+ }
+ return status;
+}
+
+XmppChatroomExitedStatus
+XmppChatroomModuleImpl::GetExitFailureFromXml(const XmlElement* presence) {
+ XmppChatroomExitedStatus status = XMPP_CHATROOM_EXITED_UNSPECIFIED;
+ const XmlElement* error = presence->FirstNamed(QN_ERROR);
+ if (error != NULL && error->HasAttr(QN_CODE)) {
+ int code = atoi(error->Attr(QN_CODE).c_str());
+ switch (code) {
+ case 307: status = XMPP_CHATROOM_EXITED_KICKED; break;
+ case 322: status = XMPP_CHATROOM_EXITED_NOT_A_MEMBER; break;
+ case 332: status = XMPP_CHATROOM_EXITED_SYSTEM_SHUTDOWN; break;
+ }
+ }
+ return status;
+}
+
+XmppReturnStatus
+XmppChatroomMemberImpl::SetPresence(const XmppPresence* presence) {
+ ASSERT(presence != NULL);
+
+ // copy presence
+ presence_.reset(XmppPresence::Create());
+ presence_->set_raw_xml(presence->raw_xml());
+ return XMPP_RETURN_OK;
+}
+
+const Jid
+XmppChatroomMemberImpl::member_jid() const {
+ return presence_->jid();
+}
+
+const Jid
+XmppChatroomMemberImpl::full_jid() const {
+ return Jid("");
+}
+
+const std::string
+XmppChatroomMemberImpl::name() const {
+ return member_jid().resource();
+}
+
+const XmppPresence*
+XmppChatroomMemberImpl::presence() const {
+ return presence_.get();
+}
+
+
+// XmppChatroomMemberEnumeratorImpl --------------------------------------
+XmppChatroomMemberEnumeratorImpl::XmppChatroomMemberEnumeratorImpl(
+ XmppChatroomModuleImpl::JidMemberMap* map, int* map_version) {
+ map_ = map;
+ map_version_ = map_version;
+ map_version_created_ = *map_version_;
+ iterator_ = map->begin();
+ before_beginning_ = true;
+}
+
+XmppChatroomMember*
+XmppChatroomMemberEnumeratorImpl::current() {
+ if (IsValid() == false) {
+ return NULL;
+ } else if (IsBeforeBeginning() || IsAfterEnd()) {
+ return NULL;
+ } else {
+ return iterator_->second;
+ }
+}
+
+bool
+XmppChatroomMemberEnumeratorImpl::Prev() {
+ if (IsValid() == false) {
+ return false;
+ } else if (IsBeforeBeginning()) {
+ return false;
+ } else if (iterator_ == map_->begin()) {
+ before_beginning_ = true;
+ return false;
+ } else {
+ iterator_--;
+ return current() != NULL;
+ }
+}
+
+bool
+XmppChatroomMemberEnumeratorImpl::Next() {
+ if (IsValid() == false) {
+ return false;
+ } else if (IsBeforeBeginning()) {
+ before_beginning_ = false;
+ iterator_ = map_->begin();
+ return current() != NULL;
+ } else if (IsAfterEnd()) {
+ return false;
+ } else {
+ iterator_++;
+ return current() != NULL;
+ }
+}
+
+bool
+XmppChatroomMemberEnumeratorImpl::IsValid() {
+ return map_version_created_ == *map_version_;
+}
+
+bool
+XmppChatroomMemberEnumeratorImpl::IsBeforeBeginning() {
+ return before_beginning_;
+}
+
+bool
+XmppChatroomMemberEnumeratorImpl::IsAfterEnd() {
+ return (iterator_ == map_->end());
+}
+
+
+
+} // namespace buzz
diff --git a/talk/xmpp/constants.cc b/talk/xmpp/constants.cc
index 1003f39..421fd8e 100644
--- a/talk/xmpp/constants.cc
+++ b/talk/xmpp/constants.cc
@@ -25,568 +25,532 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include "talk/xmpp/constants.h"
+
#include <string>
+
#include "talk/base/basicdefs.h"
#include "talk/xmllite/xmlconstants.h"
#include "talk/xmllite/xmlelement.h"
#include "talk/xmllite/qname.h"
#include "talk/xmpp/jid.h"
-#include "talk/xmpp/constants.h"
+
namespace buzz {
-const Jid JID_EMPTY(STR_EMPTY);
+// TODO: Remove static objects of complex types, particularly
+// Jid and QName.
-const std::string & Constants::ns_client() {
- static const std::string ns_client_("jabber:client");
- return ns_client_;
-}
+const char NS_CLIENT[] = "jabber:client";
+const char NS_SERVER[] = "jabber:server";
+const char NS_STREAM[] = "http://etherx.jabber.org/streams";
+const char NS_XSTREAM[] = "urn:ietf:params:xml:ns:xmpp-streams";
+const char NS_TLS[] = "urn:ietf:params:xml:ns:xmpp-tls";
+const char NS_SASL[] = "urn:ietf:params:xml:ns:xmpp-sasl";
+const char NS_BIND[] = "urn:ietf:params:xml:ns:xmpp-bind";
+const char NS_DIALBACK[] = "jabber:server:dialback";
+const char NS_SESSION[] = "urn:ietf:params:xml:ns:xmpp-session";
+const char NS_STANZA[] = "urn:ietf:params:xml:ns:xmpp-stanzas";
+const char NS_PRIVACY[] = "jabber:iq:privacy";
+const char NS_ROSTER[] = "jabber:iq:roster";
+const char NS_VCARD[] = "vcard-temp";
+const char NS_AVATAR_HASH[] = "google:avatar";
+const char NS_VCARD_UPDATE[] = "vcard-temp:x:update";
+const char STR_CLIENT[] = "client";
+const char STR_SERVER[] = "server";
+const char STR_STREAM[] = "stream";
-const std::string & Constants::ns_server() {
- static const std::string ns_server_("jabber:server");
- return ns_server_;
-}
+const char STR_GET[] = "get";
+const char STR_SET[] = "set";
+const char STR_RESULT[] = "result";
+const char STR_ERROR[] = "error";
-const std::string & Constants::ns_stream() {
- static const std::string ns_stream_("http://etherx.jabber.org/streams");
- return ns_stream_;
-}
+const char STR_FORM[] = "form";
+const char STR_SUBMIT[] = "submit";
+const char STR_TEXT_SINGLE[] = "text-single";
+const char STR_LIST_SINGLE[] = "list-single";
+const char STR_LIST_MULTI[] = "list-multi";
+const char STR_HIDDEN[] = "hidden";
+const char STR_FORM_TYPE[] = "FORM_TYPE";
-const std::string & Constants::ns_xstream() {
- static const std::string ns_xstream_("urn:ietf:params:xml:ns:xmpp-streams");
- return ns_xstream_;
-}
+const char STR_FROM[] = "from";
+const char STR_TO[] = "to";
+const char STR_BOTH[] = "both";
+const char STR_REMOVE[] = "remove";
-const std::string & Constants::ns_tls() {
- static const std::string ns_tls_("urn:ietf:params:xml:ns:xmpp-tls");
- return ns_tls_;
-}
-
-const std::string & Constants::ns_sasl() {
- static const std::string ns_sasl_("urn:ietf:params:xml:ns:xmpp-sasl");
- return ns_sasl_;
-}
-
-const std::string & Constants::ns_bind() {
- static const std::string ns_bind_("urn:ietf:params:xml:ns:xmpp-bind");
- return ns_bind_;
-}
-
-const std::string & Constants::ns_dialback() {
- static const std::string ns_dialback_("jabber:server:dialback");
- return ns_dialback_;
-}
-
-const std::string & Constants::ns_session() {
- static const std::string ns_session_("urn:ietf:params:xml:ns:xmpp-session");
- return ns_session_;
-}
-
-const std::string & Constants::ns_stanza() {
- static const std::string ns_stanza_("urn:ietf:params:xml:ns:xmpp-stanzas");
- return ns_stanza_;
-}
-
-const std::string & Constants::ns_privacy() {
- static const std::string ns_privacy_("jabber:iq:privacy");
- return ns_privacy_;
-}
-
-const std::string & Constants::ns_roster() {
- static const std::string ns_roster_("jabber:iq:roster");
- return ns_roster_;
-}
-
-const std::string & Constants::ns_vcard() {
- static const std::string ns_vcard_("vcard-temp");
- return ns_vcard_;
-}
-
-const std::string & Constants::ns_avatar_hash() {
- static const std::string ns_avatar_hash_("google:avatar");
- return ns_avatar_hash_;
-}
-
-const std::string & Constants::ns_vcard_update() {
- static const std::string ns_vcard_update_("vcard-temp:x:update");
- return ns_vcard_update_;
-}
-
-const std::string & Constants::str_client() {
- static const std::string str_client_("client");
- return str_client_;
-}
-
-const std::string & Constants::str_server() {
- static const std::string str_server_("server");
- return str_server_;
-}
-
-const std::string & Constants::str_stream() {
- static const std::string str_stream_("stream");
- return str_stream_;
-}
-
-const std::string STR_GET("get");
-const std::string STR_SET("set");
-const std::string STR_RESULT("result");
-const std::string STR_ERROR("error");
-
-const std::string STR_FORM("form");
-const std::string STR_SUBMIT("submit");
-const std::string STR_TEXT_SINGLE("text-single");
-const std::string STR_LIST_SINGLE("list-single");
-const std::string STR_LIST_MULTI("list-multi");
-const std::string STR_HIDDEN("hidden");
-const std::string STR_FORM_TYPE("FORM_TYPE");
-
-const std::string STR_FROM("from");
-const std::string STR_TO("to");
-const std::string STR_BOTH("both");
-const std::string STR_REMOVE("remove");
-
-const std::string STR_TYPE("type");
-const std::string STR_NAME("name");
-const std::string STR_ID("id");
-const std::string STR_JID("jid");
-const std::string STR_SUBSCRIPTION("subscription");
-const std::string STR_ASK("ask");
-const std::string STR_X("x");
-const std::string STR_GOOGLE_COM("google.com");
-const std::string STR_GMAIL_COM("gmail.com");
-const std::string STR_GOOGLEMAIL_COM("googlemail.com");
-const std::string STR_DEFAULT_DOMAIN("default.talk.google.com");
-const std::string STR_TALK_GOOGLE_COM("talk.google.com");
-const std::string STR_TALKX_L_GOOGLE_COM("talkx.l.google.com");
-const std::string STR_XMPP_GOOGLE_COM("xmpp.google.com");
-const std::string STR_XMPPX_L_GOOGLE_COM("xmppx.l.google.com");
+const char STR_TYPE[] = "type";
+const char STR_NAME[] = "name";
+const char STR_ID[] = "id";
+const char STR_JID[] = "jid";
+const char STR_SUBSCRIPTION[] = "subscription";
+const char STR_ASK[] = "ask";
+const char STR_X[] = "x";
+const char STR_GOOGLE_COM[] = "google.com";
+const char STR_GMAIL_COM[] = "gmail.com";
+const char STR_GOOGLEMAIL_COM[] = "googlemail.com";
+const char STR_DEFAULT_DOMAIN[] = "default.talk.google.com";
+const char STR_TALK_GOOGLE_COM[] = "talk.google.com";
+const char STR_TALKX_L_GOOGLE_COM[] = "talkx.l.google.com";
+const char STR_XMPP_GOOGLE_COM[] = "xmpp.google.com";
+const char STR_XMPPX_L_GOOGLE_COM[] = "xmppx.l.google.com";
#ifdef FEATURE_ENABLE_VOICEMAIL
-const std::string STR_VOICEMAIL("voicemail");
-const std::string STR_OUTGOINGVOICEMAIL("outgoingvoicemail");
+const char STR_VOICEMAIL[] = "voicemail";
+const char STR_OUTGOINGVOICEMAIL[] = "outgoingvoicemail";
#endif
-const std::string STR_UNAVAILABLE("unavailable");
+const char STR_UNAVAILABLE[] = "unavailable";
-const Jid JID_GOOGLE_MUC_LOOKUP("lookup.groupchat.google.com");
-const std::string STR_MUC_ROOMCONFIG_ROOMNAME("muc#roomconfig_roomname");
-const std::string STR_MUC_ROOMCONFIG_FEATURES("muc#roomconfig_features");
-const std::string STR_MUC_ROOM_FEATURE_ENTERPRISE("muc_enterprise");
-const std::string STR_MUC_ROOMCONFIG("http://jabber.org/protocol/muc#roomconfig");
+const char STR_GOOGLE_MUC_LOOKUP_JID[] = "lookup.groupchat.google.com";
+const char STR_MUC_ROOMCONFIG_ROOMNAME[] = "muc#roomconfig_roomname";
+const char STR_MUC_ROOMCONFIG_FEATURES[] = "muc#roomconfig_features";
+const char STR_MUC_ROOM_FEATURE_ENTERPRISE[] = "muc_enterprise";
+const char STR_MUC_ROOMCONFIG[] = "http://jabber.org/protocol/muc#roomconfig";
-const QName QN_STREAM_STREAM(true, NS_STREAM, STR_STREAM);
-const QName QN_STREAM_FEATURES(true, NS_STREAM, "features");
-const QName QN_STREAM_ERROR(true, NS_STREAM, "error");
+const StaticQName QN_STREAM_STREAM = { NS_STREAM, STR_STREAM };
+const StaticQName QN_STREAM_FEATURES = { NS_STREAM, "features" };
+const StaticQName QN_STREAM_ERROR = { NS_STREAM, "error" };
-const QName QN_XSTREAM_BAD_FORMAT(true, NS_XSTREAM, "bad-format");
-const QName QN_XSTREAM_BAD_NAMESPACE_PREFIX(true, NS_XSTREAM, "bad-namespace-prefix");
-const QName QN_XSTREAM_CONFLICT(true, NS_XSTREAM, "conflict");
-const QName QN_XSTREAM_CONNECTION_TIMEOUT(true, NS_XSTREAM, "connection-timeout");
-const QName QN_XSTREAM_HOST_GONE(true, NS_XSTREAM, "host-gone");
-const QName QN_XSTREAM_HOST_UNKNOWN(true, NS_XSTREAM, "host-unknown");
-const QName QN_XSTREAM_IMPROPER_ADDRESSIING(true, NS_XSTREAM, "improper-addressing");
-const QName QN_XSTREAM_INTERNAL_SERVER_ERROR(true, NS_XSTREAM, "internal-server-error");
-const QName QN_XSTREAM_INVALID_FROM(true, NS_XSTREAM, "invalid-from");
-const QName QN_XSTREAM_INVALID_ID(true, NS_XSTREAM, "invalid-id");
-const QName QN_XSTREAM_INVALID_NAMESPACE(true, NS_XSTREAM, "invalid-namespace");
-const QName QN_XSTREAM_INVALID_XML(true, NS_XSTREAM, "invalid-xml");
-const QName QN_XSTREAM_NOT_AUTHORIZED(true, NS_XSTREAM, "not-authorized");
-const QName QN_XSTREAM_POLICY_VIOLATION(true, NS_XSTREAM, "policy-violation");
-const QName QN_XSTREAM_REMOTE_CONNECTION_FAILED(true, NS_XSTREAM, "remote-connection-failed");
-const QName QN_XSTREAM_RESOURCE_CONSTRAINT(true, NS_XSTREAM, "resource-constraint");
-const QName QN_XSTREAM_RESTRICTED_XML(true, NS_XSTREAM, "restricted-xml");
-const QName QN_XSTREAM_SEE_OTHER_HOST(true, NS_XSTREAM, "see-other-host");
-const QName QN_XSTREAM_SYSTEM_SHUTDOWN(true, NS_XSTREAM, "system-shutdown");
-const QName QN_XSTREAM_UNDEFINED_CONDITION(true, NS_XSTREAM, "undefined-condition");
-const QName QN_XSTREAM_UNSUPPORTED_ENCODING(true, NS_XSTREAM, "unsupported-encoding");
-const QName QN_XSTREAM_UNSUPPORTED_STANZA_TYPE(true, NS_XSTREAM, "unsupported-stanza-type");
-const QName QN_XSTREAM_UNSUPPORTED_VERSION(true, NS_XSTREAM, "unsupported-version");
-const QName QN_XSTREAM_XML_NOT_WELL_FORMED(true, NS_XSTREAM, "xml-not-well-formed");
-const QName QN_XSTREAM_TEXT(true, NS_XSTREAM, "text");
+const StaticQName QN_XSTREAM_BAD_FORMAT = { NS_XSTREAM, "bad-format" };
+const StaticQName QN_XSTREAM_BAD_NAMESPACE_PREFIX =
+ { NS_XSTREAM, "bad-namespace-prefix" };
+const StaticQName QN_XSTREAM_CONFLICT = { NS_XSTREAM, "conflict" };
+const StaticQName QN_XSTREAM_CONNECTION_TIMEOUT =
+ { NS_XSTREAM, "connection-timeout" };
+const StaticQName QN_XSTREAM_HOST_GONE = { NS_XSTREAM, "host-gone" };
+const StaticQName QN_XSTREAM_HOST_UNKNOWN = { NS_XSTREAM, "host-unknown" };
+const StaticQName QN_XSTREAM_IMPROPER_ADDRESSIING =
+ { NS_XSTREAM, "improper-addressing" };
+const StaticQName QN_XSTREAM_INTERNAL_SERVER_ERROR =
+ { NS_XSTREAM, "internal-server-error" };
+const StaticQName QN_XSTREAM_INVALID_FROM = { NS_XSTREAM, "invalid-from" };
+const StaticQName QN_XSTREAM_INVALID_ID = { NS_XSTREAM, "invalid-id" };
+const StaticQName QN_XSTREAM_INVALID_NAMESPACE =
+ { NS_XSTREAM, "invalid-namespace" };
+const StaticQName QN_XSTREAM_INVALID_XML = { NS_XSTREAM, "invalid-xml" };
+const StaticQName QN_XSTREAM_NOT_AUTHORIZED = { NS_XSTREAM, "not-authorized" };
+const StaticQName QN_XSTREAM_POLICY_VIOLATION =
+ { NS_XSTREAM, "policy-violation" };
+const StaticQName QN_XSTREAM_REMOTE_CONNECTION_FAILED =
+ { NS_XSTREAM, "remote-connection-failed" };
+const StaticQName QN_XSTREAM_RESOURCE_CONSTRAINT =
+ { NS_XSTREAM, "resource-constraint" };
+const StaticQName QN_XSTREAM_RESTRICTED_XML = { NS_XSTREAM, "restricted-xml" };
+const StaticQName QN_XSTREAM_SEE_OTHER_HOST = { NS_XSTREAM, "see-other-host" };
+const StaticQName QN_XSTREAM_SYSTEM_SHUTDOWN =
+ { NS_XSTREAM, "system-shutdown" };
+const StaticQName QN_XSTREAM_UNDEFINED_CONDITION =
+ { NS_XSTREAM, "undefined-condition" };
+const StaticQName QN_XSTREAM_UNSUPPORTED_ENCODING =
+ { NS_XSTREAM, "unsupported-encoding" };
+const StaticQName QN_XSTREAM_UNSUPPORTED_STANZA_TYPE =
+ { NS_XSTREAM, "unsupported-stanza-type" };
+const StaticQName QN_XSTREAM_UNSUPPORTED_VERSION =
+ { NS_XSTREAM, "unsupported-version" };
+const StaticQName QN_XSTREAM_XML_NOT_WELL_FORMED =
+ { NS_XSTREAM, "xml-not-well-formed" };
+const StaticQName QN_XSTREAM_TEXT = { NS_XSTREAM, "text" };
-const QName QN_TLS_STARTTLS(true, NS_TLS, "starttls");
-const QName QN_TLS_REQUIRED(true, NS_TLS, "required");
-const QName QN_TLS_PROCEED(true, NS_TLS, "proceed");
-const QName QN_TLS_FAILURE(true, NS_TLS, "failure");
+const StaticQName QN_TLS_STARTTLS = { NS_TLS, "starttls" };
+const StaticQName QN_TLS_REQUIRED = { NS_TLS, "required" };
+const StaticQName QN_TLS_PROCEED = { NS_TLS, "proceed" };
+const StaticQName QN_TLS_FAILURE = { NS_TLS, "failure" };
-const QName QN_SASL_MECHANISMS(true, NS_SASL, "mechanisms");
-const QName QN_SASL_MECHANISM(true, NS_SASL, "mechanism");
-const QName QN_SASL_AUTH(true, NS_SASL, "auth");
-const QName QN_SASL_CHALLENGE(true, NS_SASL, "challenge");
-const QName QN_SASL_RESPONSE(true, NS_SASL, "response");
-const QName QN_SASL_ABORT(true, NS_SASL, "abort");
-const QName QN_SASL_SUCCESS(true, NS_SASL, "success");
-const QName QN_SASL_FAILURE(true, NS_SASL, "failure");
-const QName QN_SASL_ABORTED(true, NS_SASL, "aborted");
-const QName QN_SASL_INCORRECT_ENCODING(true, NS_SASL, "incorrect-encoding");
-const QName QN_SASL_INVALID_AUTHZID(true, NS_SASL, "invalid-authzid");
-const QName QN_SASL_INVALID_MECHANISM(true, NS_SASL, "invalid-mechanism");
-const QName QN_SASL_MECHANISM_TOO_WEAK(true, NS_SASL, "mechanism-too-weak");
-const QName QN_SASL_NOT_AUTHORIZED(true, NS_SASL, "not-authorized");
-const QName QN_SASL_TEMPORARY_AUTH_FAILURE(true, NS_SASL, "temporary-auth-failure");
+const StaticQName QN_SASL_MECHANISMS = { NS_SASL, "mechanisms" };
+const StaticQName QN_SASL_MECHANISM = { NS_SASL, "mechanism" };
+const StaticQName QN_SASL_AUTH = { NS_SASL, "auth" };
+const StaticQName QN_SASL_CHALLENGE = { NS_SASL, "challenge" };
+const StaticQName QN_SASL_RESPONSE = { NS_SASL, "response" };
+const StaticQName QN_SASL_ABORT = { NS_SASL, "abort" };
+const StaticQName QN_SASL_SUCCESS = { NS_SASL, "success" };
+const StaticQName QN_SASL_FAILURE = { NS_SASL, "failure" };
+const StaticQName QN_SASL_ABORTED = { NS_SASL, "aborted" };
+const StaticQName QN_SASL_INCORRECT_ENCODING =
+ { NS_SASL, "incorrect-encoding" };
+const StaticQName QN_SASL_INVALID_AUTHZID = { NS_SASL, "invalid-authzid" };
+const StaticQName QN_SASL_INVALID_MECHANISM = { NS_SASL, "invalid-mechanism" };
+const StaticQName QN_SASL_MECHANISM_TOO_WEAK =
+ { NS_SASL, "mechanism-too-weak" };
+const StaticQName QN_SASL_NOT_AUTHORIZED = { NS_SASL, "not-authorized" };
+const StaticQName QN_SASL_TEMPORARY_AUTH_FAILURE =
+ { NS_SASL, "temporary-auth-failure" };
-const QName QN_DIALBACK_RESULT(true, NS_DIALBACK, "result");
-const QName QN_DIALBACK_VERIFY(true, NS_DIALBACK, "verify");
+// These are non-standard.
+const char NS_GOOGLE_AUTH_PROTOCOL[] =
+ "http://www.google.com/talk/protocol/auth";
+const StaticQName QN_GOOGLE_AUTH_CLIENT_USES_FULL_BIND_RESULT =
+ { NS_GOOGLE_AUTH_PROTOCOL, "client-uses-full-bind-result" };
+const char NS_GOOGLE_AUTH_OLD[] = "google:auth";
+const StaticQName QN_GOOGLE_ALLOW_NON_GOOGLE_ID_XMPP_LOGIN =
+ { NS_GOOGLE_AUTH_PROTOCOL, "allow-non-google-login" };
-const QName QN_STANZA_BAD_REQUEST(true, NS_STANZA, "bad-request");
-const QName QN_STANZA_CONFLICT(true, NS_STANZA, "conflict");
-const QName QN_STANZA_FEATURE_NOT_IMPLEMENTED(true, NS_STANZA, "feature-not-implemented");
-const QName QN_STANZA_FORBIDDEN(true, NS_STANZA, "forbidden");
-const QName QN_STANZA_GONE(true, NS_STANZA, "gone");
-const QName QN_STANZA_INTERNAL_SERVER_ERROR(true, NS_STANZA, "internal-server-error");
-const QName QN_STANZA_ITEM_NOT_FOUND(true, NS_STANZA, "item-not-found");
-const QName QN_STANZA_JID_MALFORMED(true, NS_STANZA, "jid-malformed");
-const QName QN_STANZA_NOT_ACCEPTABLE(true, NS_STANZA, "not-acceptable");
-const QName QN_STANZA_NOT_ALLOWED(true, NS_STANZA, "not-allowed");
-const QName QN_STANZA_PAYMENT_REQUIRED(true, NS_STANZA, "payment-required");
-const QName QN_STANZA_RECIPIENT_UNAVAILABLE(true, NS_STANZA, "recipient-unavailable");
-const QName QN_STANZA_REDIRECT(true, NS_STANZA, "redirect");
-const QName QN_STANZA_REGISTRATION_REQUIRED(true, NS_STANZA, "registration-required");
-const QName QN_STANZA_REMOTE_SERVER_NOT_FOUND(true, NS_STANZA, "remote-server-not-found");
-const QName QN_STANZA_REMOTE_SERVER_TIMEOUT(true, NS_STANZA, "remote-server-timeout");
-const QName QN_STANZA_RESOURCE_CONSTRAINT(true, NS_STANZA, "resource-constraint");
-const QName QN_STANZA_SERVICE_UNAVAILABLE(true, NS_STANZA, "service-unavailable");
-const QName QN_STANZA_SUBSCRIPTION_REQUIRED(true, NS_STANZA, "subscription-required");
-const QName QN_STANZA_UNDEFINED_CONDITION(true, NS_STANZA, "undefined-condition");
-const QName QN_STANZA_UNEXPECTED_REQUEST(true, NS_STANZA, "unexpected-request");
-const QName QN_STANZA_TEXT(true, NS_STANZA, "text");
+const StaticQName QN_DIALBACK_RESULT = { NS_DIALBACK, "result" };
+const StaticQName QN_DIALBACK_VERIFY = { NS_DIALBACK, "verify" };
-const QName QN_BIND_BIND(true, NS_BIND, "bind");
-const QName QN_BIND_RESOURCE(true, NS_BIND, "resource");
-const QName QN_BIND_JID(true, NS_BIND, "jid");
+const StaticQName QN_STANZA_BAD_REQUEST = { NS_STANZA, "bad-request" };
+const StaticQName QN_STANZA_CONFLICT = { NS_STANZA, "conflict" };
+const StaticQName QN_STANZA_FEATURE_NOT_IMPLEMENTED =
+ { NS_STANZA, "feature-not-implemented" };
+const StaticQName QN_STANZA_FORBIDDEN = { NS_STANZA, "forbidden" };
+const StaticQName QN_STANZA_GONE = { NS_STANZA, "gone" };
+const StaticQName QN_STANZA_INTERNAL_SERVER_ERROR =
+ { NS_STANZA, "internal-server-error" };
+const StaticQName QN_STANZA_ITEM_NOT_FOUND = { NS_STANZA, "item-not-found" };
+const StaticQName QN_STANZA_JID_MALFORMED = { NS_STANZA, "jid-malformed" };
+const StaticQName QN_STANZA_NOT_ACCEPTABLE = { NS_STANZA, "not-acceptable" };
+const StaticQName QN_STANZA_NOT_ALLOWED = { NS_STANZA, "not-allowed" };
+const StaticQName QN_STANZA_PAYMENT_REQUIRED =
+ { NS_STANZA, "payment-required" };
+const StaticQName QN_STANZA_RECIPIENT_UNAVAILABLE =
+ { NS_STANZA, "recipient-unavailable" };
+const StaticQName QN_STANZA_REDIRECT = { NS_STANZA, "redirect" };
+const StaticQName QN_STANZA_REGISTRATION_REQUIRED =
+ { NS_STANZA, "registration-required" };
+const StaticQName QN_STANZA_REMOTE_SERVER_NOT_FOUND =
+ { NS_STANZA, "remote-server-not-found" };
+const StaticQName QN_STANZA_REMOTE_SERVER_TIMEOUT =
+ { NS_STANZA, "remote-server-timeout" };
+const StaticQName QN_STANZA_RESOURCE_CONSTRAINT =
+ { NS_STANZA, "resource-constraint" };
+const StaticQName QN_STANZA_SERVICE_UNAVAILABLE =
+ { NS_STANZA, "service-unavailable" };
+const StaticQName QN_STANZA_SUBSCRIPTION_REQUIRED =
+ { NS_STANZA, "subscription-required" };
+const StaticQName QN_STANZA_UNDEFINED_CONDITION =
+ { NS_STANZA, "undefined-condition" };
+const StaticQName QN_STANZA_UNEXPECTED_REQUEST =
+ { NS_STANZA, "unexpected-request" };
+const StaticQName QN_STANZA_TEXT = { NS_STANZA, "text" };
-const QName QN_MESSAGE(true, NS_CLIENT, "message");
-const QName QN_BODY(true, NS_CLIENT, "body");
-const QName QN_SUBJECT(true, NS_CLIENT, "subject");
-const QName QN_THREAD(true, NS_CLIENT, "thread");
-const QName QN_PRESENCE(true, NS_CLIENT, "presence");
-const QName QN_SHOW(true, NS_CLIENT, "show");
-const QName QN_STATUS(true, NS_CLIENT, "status");
-const QName QN_LANG(true, NS_CLIENT, "lang");
-const QName QN_PRIORITY(true, NS_CLIENT, "priority");
-const QName QN_IQ(true, NS_CLIENT, "iq");
-const QName QN_ERROR(true, NS_CLIENT, "error");
+const StaticQName QN_BIND_BIND = { NS_BIND, "bind" };
+const StaticQName QN_BIND_RESOURCE = { NS_BIND, "resource" };
+const StaticQName QN_BIND_JID = { NS_BIND, "jid" };
-const QName QN_SERVER_MESSAGE(true, NS_SERVER, "message");
-const QName QN_SERVER_BODY(true, NS_SERVER, "body");
-const QName QN_SERVER_SUBJECT(true, NS_SERVER, "subject");
-const QName QN_SERVER_THREAD(true, NS_SERVER, "thread");
-const QName QN_SERVER_PRESENCE(true, NS_SERVER, "presence");
-const QName QN_SERVER_SHOW(true, NS_SERVER, "show");
-const QName QN_SERVER_STATUS(true, NS_SERVER, "status");
-const QName QN_SERVER_LANG(true, NS_SERVER, "lang");
-const QName QN_SERVER_PRIORITY(true, NS_SERVER, "priority");
-const QName QN_SERVER_IQ(true, NS_SERVER, "iq");
-const QName QN_SERVER_ERROR(true, NS_SERVER, "error");
+const StaticQName QN_MESSAGE = { NS_CLIENT, "message" };
+const StaticQName QN_BODY = { NS_CLIENT, "body" };
+const StaticQName QN_SUBJECT = { NS_CLIENT, "subject" };
+const StaticQName QN_THREAD = { NS_CLIENT, "thread" };
+const StaticQName QN_PRESENCE = { NS_CLIENT, "presence" };
+const StaticQName QN_SHOW = { NS_CLIENT, "show" };
+const StaticQName QN_STATUS = { NS_CLIENT, "status" };
+const StaticQName QN_LANG = { NS_CLIENT, "lang" };
+const StaticQName QN_PRIORITY = { NS_CLIENT, "priority" };
+const StaticQName QN_IQ = { NS_CLIENT, "iq" };
+const StaticQName QN_ERROR = { NS_CLIENT, "error" };
-const QName QN_SESSION_SESSION(true, NS_SESSION, "session");
+const StaticQName QN_SERVER_MESSAGE = { NS_SERVER, "message" };
+const StaticQName QN_SERVER_BODY = { NS_SERVER, "body" };
+const StaticQName QN_SERVER_SUBJECT = { NS_SERVER, "subject" };
+const StaticQName QN_SERVER_THREAD = { NS_SERVER, "thread" };
+const StaticQName QN_SERVER_PRESENCE = { NS_SERVER, "presence" };
+const StaticQName QN_SERVER_SHOW = { NS_SERVER, "show" };
+const StaticQName QN_SERVER_STATUS = { NS_SERVER, "status" };
+const StaticQName QN_SERVER_LANG = { NS_SERVER, "lang" };
+const StaticQName QN_SERVER_PRIORITY = { NS_SERVER, "priority" };
+const StaticQName QN_SERVER_IQ = { NS_SERVER, "iq" };
+const StaticQName QN_SERVER_ERROR = { NS_SERVER, "error" };
-const QName QN_PRIVACY_QUERY(true, NS_PRIVACY, "query");
-const QName QN_PRIVACY_ACTIVE(true, NS_PRIVACY, "active");
-const QName QN_PRIVACY_DEFAULT(true, NS_PRIVACY, "default");
-const QName QN_PRIVACY_LIST(true, NS_PRIVACY, "list");
-const QName QN_PRIVACY_ITEM(true, NS_PRIVACY, "item");
-const QName QN_PRIVACY_IQ(true, NS_PRIVACY, "iq");
-const QName QN_PRIVACY_MESSAGE(true, NS_PRIVACY, "message");
-const QName QN_PRIVACY_PRESENCE_IN(true, NS_PRIVACY, "presence-in");
-const QName QN_PRIVACY_PRESENCE_OUT(true, NS_PRIVACY, "presence-out");
+const StaticQName QN_SESSION_SESSION = { NS_SESSION, "session" };
-const QName QN_ROSTER_QUERY(true, NS_ROSTER, "query");
-const QName QN_ROSTER_ITEM(true, NS_ROSTER, "item");
-const QName QN_ROSTER_GROUP(true, NS_ROSTER, "group");
+const StaticQName QN_PRIVACY_QUERY = { NS_PRIVACY, "query" };
+const StaticQName QN_PRIVACY_ACTIVE = { NS_PRIVACY, "active" };
+const StaticQName QN_PRIVACY_DEFAULT = { NS_PRIVACY, "default" };
+const StaticQName QN_PRIVACY_LIST = { NS_PRIVACY, "list" };
+const StaticQName QN_PRIVACY_ITEM = { NS_PRIVACY, "item" };
+const StaticQName QN_PRIVACY_IQ = { NS_PRIVACY, "iq" };
+const StaticQName QN_PRIVACY_MESSAGE = { NS_PRIVACY, "message" };
+const StaticQName QN_PRIVACY_PRESENCE_IN = { NS_PRIVACY, "presence-in" };
+const StaticQName QN_PRIVACY_PRESENCE_OUT = { NS_PRIVACY, "presence-out" };
-const QName QN_VCARD(true, NS_VCARD, "vCard");
-const QName QN_VCARD_FN(true, NS_VCARD, "FN");
-const QName QN_VCARD_PHOTO(true, NS_VCARD, "PHOTO");
-const QName QN_VCARD_PHOTO_BINVAL(true, NS_VCARD, "BINVAL");
-const QName QN_VCARD_AVATAR_HASH(true, NS_AVATAR_HASH, "hash");
-const QName QN_VCARD_AVATAR_HASH_MODIFIED(true, NS_AVATAR_HASH, "modified");
+const StaticQName QN_ROSTER_QUERY = { NS_ROSTER, "query" };
+const StaticQName QN_ROSTER_ITEM = { NS_ROSTER, "item" };
+const StaticQName QN_ROSTER_GROUP = { NS_ROSTER, "group" };
-const QName QN_NAME(true, STR_EMPTY, "name");
-const QName QN_AFFILIATION(true, STR_EMPTY, "affiliation");
-const QName QN_ROLE(true, STR_EMPTY, "role");
+const StaticQName QN_VCARD = { NS_VCARD, "vCard" };
+const StaticQName QN_VCARD_FN = { NS_VCARD, "FN" };
+const StaticQName QN_VCARD_PHOTO = { NS_VCARD, "PHOTO" };
+const StaticQName QN_VCARD_PHOTO_BINVAL = { NS_VCARD, "BINVAL" };
+const StaticQName QN_VCARD_AVATAR_HASH = { NS_AVATAR_HASH, "hash" };
+const StaticQName QN_VCARD_AVATAR_HASH_MODIFIED =
+ { NS_AVATAR_HASH, "modified" };
+
+const StaticQName QN_NAME = { STR_EMPTY, "name" };
+const StaticQName QN_AFFILIATION = { STR_EMPTY, "affiliation" };
+const StaticQName QN_ROLE = { STR_EMPTY, "role" };
#if defined(FEATURE_ENABLE_PSTN)
-const QName QN_VCARD_TEL(true, NS_VCARD, "TEL");
-const QName QN_VCARD_VOICE(true, NS_VCARD, "VOICE");
-const QName QN_VCARD_HOME(true, NS_VCARD, "HOME");
-const QName QN_VCARD_WORK(true, NS_VCARD, "WORK");
-const QName QN_VCARD_CELL(true, NS_VCARD, "CELL");
-const QName QN_VCARD_NUMBER(true, NS_VCARD, "NUMBER");
+const StaticQName QN_VCARD_TEL = { NS_VCARD, "TEL" };
+const StaticQName QN_VCARD_VOICE = { NS_VCARD, "VOICE" };
+const StaticQName QN_VCARD_HOME = { NS_VCARD, "HOME" };
+const StaticQName QN_VCARD_WORK = { NS_VCARD, "WORK" };
+const StaticQName QN_VCARD_CELL = { NS_VCARD, "CELL" };
+const StaticQName QN_VCARD_NUMBER = { NS_VCARD, "NUMBER" };
#endif
-const QName QN_XML_LANG(true, NS_XML, "lang");
+const StaticQName QN_XML_LANG = { NS_XML, "lang" };
-const QName QN_ENCODING(true, STR_EMPTY, STR_ENCODING);
-const QName QN_VERSION(true, STR_EMPTY, STR_VERSION);
-const QName QN_TO(true, STR_EMPTY, "to");
-const QName QN_FROM(true, STR_EMPTY, "from");
-const QName QN_TYPE(true, STR_EMPTY, "type");
-const QName QN_ID(true, STR_EMPTY, "id");
-const QName QN_CODE(true, STR_EMPTY, "code");
+const StaticQName QN_ENCODING = { STR_EMPTY, STR_ENCODING };
+const StaticQName QN_VERSION = { STR_EMPTY, STR_VERSION };
+const StaticQName QN_TO = { STR_EMPTY, "to" };
+const StaticQName QN_FROM = { STR_EMPTY, "from" };
+const StaticQName QN_TYPE = { STR_EMPTY, "type" };
+const StaticQName QN_ID = { STR_EMPTY, "id" };
+const StaticQName QN_CODE = { STR_EMPTY, "code" };
-const QName QN_VALUE(true, STR_EMPTY, "value");
-const QName QN_ACTION(true, STR_EMPTY, "action");
-const QName QN_ORDER(true, STR_EMPTY, "order");
-const QName QN_MECHANISM(true, STR_EMPTY, "mechanism");
-const QName QN_ASK(true, STR_EMPTY, "ask");
-const QName QN_JID(true, STR_EMPTY, "jid");
-const QName QN_NICK(true, STR_EMPTY, "nick");
-const QName QN_SUBSCRIPTION(true, STR_EMPTY, "subscription");
-const QName QN_TITLE1(true, STR_EMPTY, "title1");
-const QName QN_TITLE2(true, STR_EMPTY, "title2");
-const QName QN_SOURCE(true, STR_EMPTY, "source");
-const QName QN_TIME(true, STR_EMPTY, "time");
+const StaticQName QN_VALUE = { STR_EMPTY, "value" };
+const StaticQName QN_ACTION = { STR_EMPTY, "action" };
+const StaticQName QN_ORDER = { STR_EMPTY, "order" };
+const StaticQName QN_MECHANISM = { STR_EMPTY, "mechanism" };
+const StaticQName QN_ASK = { STR_EMPTY, "ask" };
+const StaticQName QN_JID = { STR_EMPTY, "jid" };
+const StaticQName QN_NICK = { STR_EMPTY, "nick" };
+const StaticQName QN_SUBSCRIPTION = { STR_EMPTY, "subscription" };
+const StaticQName QN_TITLE1 = { STR_EMPTY, "title1" };
+const StaticQName QN_TITLE2 = { STR_EMPTY, "title2" };
+const StaticQName QN_SOURCE = { STR_EMPTY, "source" };
+const StaticQName QN_TIME = { STR_EMPTY, "time" };
-const QName QN_XMLNS_CLIENT(true, NS_XMLNS, STR_CLIENT);
-const QName QN_XMLNS_SERVER(true, NS_XMLNS, STR_SERVER);
-const QName QN_XMLNS_STREAM(true, NS_XMLNS, STR_STREAM);
+const StaticQName QN_XMLNS_CLIENT = { NS_XMLNS, STR_CLIENT };
+const StaticQName QN_XMLNS_SERVER = { NS_XMLNS, STR_SERVER };
+const StaticQName QN_XMLNS_STREAM = { NS_XMLNS, STR_STREAM };
// Presence
-const std::string STR_SHOW_AWAY("away");
-const std::string STR_SHOW_CHAT("chat");
-const std::string STR_SHOW_DND("dnd");
-const std::string STR_SHOW_XA("xa");
-const std::string STR_SHOW_OFFLINE("offline");
+const char STR_SHOW_AWAY[] = "away";
+const char STR_SHOW_CHAT[] = "chat";
+const char STR_SHOW_DND[] = "dnd";
+const char STR_SHOW_XA[] = "xa";
+const char STR_SHOW_OFFLINE[] = "offline";
// Subscription
-const std::string STR_SUBSCRIBE("subscribe");
-const std::string STR_SUBSCRIBED("subscribed");
-const std::string STR_UNSUBSCRIBE("unsubscribe");
-const std::string STR_UNSUBSCRIBED("unsubscribed");
+const char STR_SUBSCRIBE[] = "subscribe";
+const char STR_SUBSCRIBED[] = "subscribed";
+const char STR_UNSUBSCRIBE[] = "unsubscribe";
+const char STR_UNSUBSCRIBED[] = "unsubscribed";
// Google Invite
-const std::string NS_GOOGLE_INVITE("google:subscribe");
-const QName QN_INVITATION(true, NS_GOOGLE_INVITE, "invitation");
-const QName QN_INVITE_NAME(true, NS_GOOGLE_INVITE, "name");
-const QName QN_INVITE_SUBJECT(true, NS_GOOGLE_INVITE, "subject");
-const QName QN_INVITE_MESSAGE(true, NS_GOOGLE_INVITE, "body");
+const char NS_GOOGLE_INVITE[] = "google:subscribe";
+const StaticQName QN_INVITATION = { NS_GOOGLE_INVITE, "invitation" };
+const StaticQName QN_INVITE_NAME = { NS_GOOGLE_INVITE, "name" };
+const StaticQName QN_INVITE_SUBJECT = { NS_GOOGLE_INVITE, "subject" };
+const StaticQName QN_INVITE_MESSAGE = { NS_GOOGLE_INVITE, "body" };
// PubSub: http://xmpp.org/extensions/xep-0060.html
-const std::string NS_PUBSUB("http://jabber.org/protocol/pubsub");
-const QName QN_PUBSUB(true, NS_PUBSUB, "pubsub");
-const QName QN_PUBSUB_ITEMS(true, NS_PUBSUB, "items");
-const QName QN_PUBSUB_ITEM(true, NS_PUBSUB, "item");
-const QName QN_PUBSUB_PUBLISH(true, NS_PUBSUB, "publish");
-const QName QN_PUBSUB_RETRACT(true, NS_PUBSUB, "retract");
-const QName QN_ATTR_PUBLISHER(true, STR_EMPTY, "publisher");
+const char NS_PUBSUB[] = "http://jabber.org/protocol/pubsub";
+const StaticQName QN_PUBSUB = { NS_PUBSUB, "pubsub" };
+const StaticQName QN_PUBSUB_ITEMS = { NS_PUBSUB, "items" };
+const StaticQName QN_PUBSUB_ITEM = { NS_PUBSUB, "item" };
+const StaticQName QN_PUBSUB_PUBLISH = { NS_PUBSUB, "publish" };
+const StaticQName QN_PUBSUB_RETRACT = { NS_PUBSUB, "retract" };
+const StaticQName QN_ATTR_PUBLISHER = { STR_EMPTY, "publisher" };
-const std::string NS_PUBSUB_EVENT("http://jabber.org/protocol/pubsub#event");
-const QName QN_NODE(true, STR_EMPTY, "node");
-const QName QN_PUBSUB_EVENT(true, NS_PUBSUB_EVENT, "event");
-const QName QN_PUBSUB_EVENT_ITEMS(true, NS_PUBSUB_EVENT, "items");
-const QName QN_PUBSUB_EVENT_ITEM(true, NS_PUBSUB_EVENT, "item");
-const QName QN_PUBSUB_EVENT_RETRACT(true, NS_PUBSUB_EVENT, "retract");
-const QName QN_NOTIFY(true, STR_EMPTY, "notify");
+const char NS_PUBSUB_EVENT[] = "http://jabber.org/protocol/pubsub#event";
+const StaticQName QN_NODE = { STR_EMPTY, "node" };
+const StaticQName QN_PUBSUB_EVENT = { NS_PUBSUB_EVENT, "event" };
+const StaticQName QN_PUBSUB_EVENT_ITEMS = { NS_PUBSUB_EVENT, "items" };
+const StaticQName QN_PUBSUB_EVENT_ITEM = { NS_PUBSUB_EVENT, "item" };
+const StaticQName QN_PUBSUB_EVENT_RETRACT = { NS_PUBSUB_EVENT, "retract" };
+const StaticQName QN_NOTIFY = { STR_EMPTY, "notify" };
-
-
-const std::string NS_PRESENTER("google:presenter");
-const QName QN_PRESENTER_PRESENTER(true, NS_PRESENTER, "presenter");
-const QName QN_PRESENTER_PRESENTATION_ITEM(
- true, NS_PRESENTER, "presentation-item");
-const QName QN_PRESENTER_PRESENTATION_TYPE(
- true, NS_PRESENTER, "presentation-type");
-const QName QN_PRESENTER_PRESENTATION_ID(true, NS_PRESENTER, "presentation-id");
-
-
+const char NS_PRESENTER[] = "google:presenter";
+const StaticQName QN_PRESENTER_PRESENTER = { NS_PRESENTER, "presenter" };
+const StaticQName QN_PRESENTER_PRESENTATION_ITEM =
+ { NS_PRESENTER, "presentation-item" };
+const StaticQName QN_PRESENTER_PRESENTATION_TYPE =
+ { NS_PRESENTER, "presentation-type" };
+const StaticQName QN_PRESENTER_PRESENTATION_ID =
+ { NS_PRESENTER, "presentation-id" };
// JEP 0030
-const QName QN_CATEGORY(true, STR_EMPTY, "category");
-const QName QN_VAR(true, STR_EMPTY, "var");
-const std::string NS_DISCO_INFO("http://jabber.org/protocol/disco#info");
-const std::string NS_DISCO_ITEMS("http://jabber.org/protocol/disco#items");
-const QName QN_DISCO_INFO_QUERY(true, NS_DISCO_INFO, "query");
-const QName QN_DISCO_IDENTITY(true, NS_DISCO_INFO, "identity");
-const QName QN_DISCO_FEATURE(true, NS_DISCO_INFO, "feature");
+const StaticQName QN_CATEGORY = { STR_EMPTY, "category" };
+const StaticQName QN_VAR = { STR_EMPTY, "var" };
+const char NS_DISCO_INFO[] = "http://jabber.org/protocol/disco#info";
+const char NS_DISCO_ITEMS[] = "http://jabber.org/protocol/disco#items";
+const StaticQName QN_DISCO_INFO_QUERY = { NS_DISCO_INFO, "query" };
+const StaticQName QN_DISCO_IDENTITY = { NS_DISCO_INFO, "identity" };
+const StaticQName QN_DISCO_FEATURE = { NS_DISCO_INFO, "feature" };
-const QName QN_DISCO_ITEMS_QUERY(true, NS_DISCO_ITEMS, "query");
-const QName QN_DISCO_ITEM(true, NS_DISCO_ITEMS, "item");
+const StaticQName QN_DISCO_ITEMS_QUERY = { NS_DISCO_ITEMS, "query" };
+const StaticQName QN_DISCO_ITEM = { NS_DISCO_ITEMS, "item" };
// JEP 0020
-const std::string NS_FEATURE("http://jabber.org/protocol/feature-neg");
-const QName QN_FEATURE_FEATURE(true, NS_FEATURE, "feature");
+const char NS_FEATURE[] = "http://jabber.org/protocol/feature-neg";
+const StaticQName QN_FEATURE_FEATURE = { NS_FEATURE, "feature" };
// JEP 0004
-const std::string NS_XDATA("jabber:x:data");
-const QName QN_XDATA_X(true, NS_XDATA, "x");
-const QName QN_XDATA_INSTRUCTIONS(true, NS_XDATA, "instructions");
-const QName QN_XDATA_TITLE(true, NS_XDATA, "title");
-const QName QN_XDATA_FIELD(true, NS_XDATA, "field");
-const QName QN_XDATA_REPORTED(true, NS_XDATA, "reported");
-const QName QN_XDATA_ITEM(true, NS_XDATA, "item");
-const QName QN_XDATA_DESC(true, NS_XDATA, "desc");
-const QName QN_XDATA_REQUIRED(true, NS_XDATA, "required");
-const QName QN_XDATA_VALUE(true, NS_XDATA, "value");
-const QName QN_XDATA_OPTION(true, NS_XDATA, "option");
+const char NS_XDATA[] = "jabber:x:data";
+const StaticQName QN_XDATA_X = { NS_XDATA, "x" };
+const StaticQName QN_XDATA_INSTRUCTIONS = { NS_XDATA, "instructions" };
+const StaticQName QN_XDATA_TITLE = { NS_XDATA, "title" };
+const StaticQName QN_XDATA_FIELD = { NS_XDATA, "field" };
+const StaticQName QN_XDATA_REPORTED = { NS_XDATA, "reported" };
+const StaticQName QN_XDATA_ITEM = { NS_XDATA, "item" };
+const StaticQName QN_XDATA_DESC = { NS_XDATA, "desc" };
+const StaticQName QN_XDATA_REQUIRED = { NS_XDATA, "required" };
+const StaticQName QN_XDATA_VALUE = { NS_XDATA, "value" };
+const StaticQName QN_XDATA_OPTION = { NS_XDATA, "option" };
// JEP 0045
-const std::string NS_MUC("http://jabber.org/protocol/muc");
-const QName QN_MUC_X(true, NS_MUC, "x");
-const QName QN_MUC_ITEM(true, NS_MUC, "item");
-const QName QN_MUC_AFFILIATION(true, NS_MUC, "affiliation");
-const QName QN_MUC_ROLE(true, NS_MUC, "role");
-const std::string STR_AFFILIATION_NONE("none");
-const std::string STR_ROLE_PARTICIPANT("participant");
+const char NS_MUC[] = "http://jabber.org/protocol/muc";
+const StaticQName QN_MUC_X = { NS_MUC, "x" };
+const StaticQName QN_MUC_ITEM = { NS_MUC, "item" };
+const StaticQName QN_MUC_AFFILIATION = { NS_MUC, "affiliation" };
+const StaticQName QN_MUC_ROLE = { NS_MUC, "role" };
+const char STR_AFFILIATION_NONE[] = "none";
+const char STR_ROLE_PARTICIPANT[] = "participant";
-const std::string NS_MUC_OWNER("http://jabber.org/protocol/muc#owner");
-const QName QN_MUC_OWNER_QUERY(true, NS_MUC_OWNER, "query");
+const char NS_MUC_OWNER[] = "http://jabber.org/protocol/muc#owner";
+const StaticQName QN_MUC_OWNER_QUERY = { NS_MUC_OWNER, "query" };
-const std::string NS_MUC_USER("http://jabber.org/protocol/muc#user");
-const QName QN_MUC_USER_CONTINUE(true, NS_MUC_USER, "continue");
-const QName QN_MUC_USER_X(true, NS_MUC_USER, "x");
-const QName QN_MUC_USER_ITEM(true, NS_MUC_USER, "item");
-const QName QN_MUC_USER_STATUS(true, NS_MUC_USER, "status");
-
+const char NS_MUC_USER[] = "http://jabber.org/protocol/muc#user";
+const StaticQName QN_MUC_USER_CONTINUE = { NS_MUC_USER, "continue" };
+const StaticQName QN_MUC_USER_X = { NS_MUC_USER, "x" };
+const StaticQName QN_MUC_USER_ITEM = { NS_MUC_USER, "item" };
+const StaticQName QN_MUC_USER_STATUS = { NS_MUC_USER, "status" };
// JEP 0055 - Jabber Search
-const std::string NS_SEARCH("jabber:iq:search");
-const QName QN_SEARCH_QUERY(true, NS_SEARCH, "query");
-const QName QN_SEARCH_ITEM(true, NS_SEARCH, "item");
-const QName QN_SEARCH_ROOM_NAME(true, NS_SEARCH, "room-name");
-const QName QN_SEARCH_ROOM_DOMAIN(true, NS_SEARCH, "room-domain");
-const QName QN_SEARCH_ROOM_JID(true, NS_SEARCH, "room-jid");
-
+const char NS_SEARCH[] = "jabber:iq:search";
+const StaticQName QN_SEARCH_QUERY = { NS_SEARCH, "query" };
+const StaticQName QN_SEARCH_ITEM = { NS_SEARCH, "item" };
+const StaticQName QN_SEARCH_ROOM_NAME = { NS_SEARCH, "room-name" };
+const StaticQName QN_SEARCH_ROOM_DOMAIN = { NS_SEARCH, "room-domain" };
+const StaticQName QN_SEARCH_ROOM_JID = { NS_SEARCH, "room-jid" };
// JEP 0115
-const std::string NS_CAPS("http://jabber.org/protocol/caps");
-const QName QN_CAPS_C(true, NS_CAPS, "c");
-const QName QN_VER(true, STR_EMPTY, "ver");
-const QName QN_EXT(true, STR_EMPTY, "ext");
+const char NS_CAPS[] = "http://jabber.org/protocol/caps";
+const StaticQName QN_CAPS_C = { NS_CAPS, "c" };
+const StaticQName QN_VER = { STR_EMPTY, "ver" };
+const StaticQName QN_EXT = { STR_EMPTY, "ext" };
// JEP 0153
-const std::string kNSVCard("vcard-temp:x:update");
-const QName kQnVCardX(true, kNSVCard, "x");
-const QName kQnVCardPhoto(true, kNSVCard, "photo");
+const char kNSVCard[] = "vcard-temp:x:update";
+const StaticQName kQnVCardX = { kNSVCard, "x" };
+const StaticQName kQnVCardPhoto = { kNSVCard, "photo" };
// JEP 0172 User Nickname
-const std::string NS_NICKNAME("http://jabber.org/protocol/nick");
-const QName QN_NICKNAME(true, NS_NICKNAME, "nick");
-
+const char NS_NICKNAME[] = "http://jabber.org/protocol/nick";
+const StaticQName QN_NICKNAME = { NS_NICKNAME, "nick" };
// JEP 0085 chat state
-const std::string NS_CHATSTATE("http://jabber.org/protocol/chatstates");
-const QName QN_CS_ACTIVE(true, NS_CHATSTATE, "active");
-const QName QN_CS_COMPOSING(true, NS_CHATSTATE, "composing");
-const QName QN_CS_PAUSED(true, NS_CHATSTATE, "paused");
-const QName QN_CS_INACTIVE(true, NS_CHATSTATE, "inactive");
-const QName QN_CS_GONE(true, NS_CHATSTATE, "gone");
+const char NS_CHATSTATE[] = "http://jabber.org/protocol/chatstates";
+const StaticQName QN_CS_ACTIVE = { NS_CHATSTATE, "active" };
+const StaticQName QN_CS_COMPOSING = { NS_CHATSTATE, "composing" };
+const StaticQName QN_CS_PAUSED = { NS_CHATSTATE, "paused" };
+const StaticQName QN_CS_INACTIVE = { NS_CHATSTATE, "inactive" };
+const StaticQName QN_CS_GONE = { NS_CHATSTATE, "gone" };
// JEP 0091 Delayed Delivery
-const std::string kNSDelay("jabber:x:delay");
-const QName kQnDelayX(true, kNSDelay, "x");
-const QName kQnStamp(true, STR_EMPTY, "stamp");
+const char kNSDelay[] = "jabber:x:delay";
+const StaticQName kQnDelayX = { kNSDelay, "x" };
+const StaticQName kQnStamp = { STR_EMPTY, "stamp" };
// Google time stamping (higher resolution)
-const std::string kNSTimestamp("google:timestamp");
-const QName kQnTime(true, kNSTimestamp, "time");
-const QName kQnMilliseconds(true, STR_EMPTY, "ms");
-
-
-// Event tracking
-#ifdef FEATURE_ENABLE_TRACKING
-const std::string NS_GOOGLE_EVENT_TRACKING("google:client-usability-testing");
-const QName QN_EVENT_TRACKING(true, NS_GOOGLE_EVENT_TRACKING, "usage-stats");
-const QName QN_EVENT_TRACKING_BRANDID(true, NS_GOOGLE_EVENT_TRACKING, "bid");
-const QName QN_EVENT_TRACKING_EVENT(true, NS_GOOGLE_EVENT_TRACKING, "event");
-const QName QN_EVENT_TRACKING_VARIABLE_KEY(true, STR_EMPTY, "key");
-const QName QN_EVENT_TRACKING_VARIABLE_VALUE(true, STR_EMPTY, "value");
-const QName QN_EVENT_TRACKING_VARIABLE_TIME(true, STR_EMPTY, "time");
-const QName QN_EVENT_TRACKING_EVENT_GROUP(true,
- NS_GOOGLE_EVENT_TRACKING, "events");
-#endif
-
+const char kNSTimestamp[] = "google:timestamp";
+const StaticQName kQnTime = { kNSTimestamp, "time" };
+const StaticQName kQnMilliseconds = { STR_EMPTY, "ms" };
// Jingle Info
-const std::string NS_JINGLE_INFO("google:jingleinfo");
-const QName QN_JINGLE_INFO_QUERY(true, NS_JINGLE_INFO, "query");
-const QName QN_JINGLE_INFO_STUN(true, NS_JINGLE_INFO, "stun");
-const QName QN_JINGLE_INFO_RELAY(true, NS_JINGLE_INFO, "relay");
-const QName QN_JINGLE_INFO_SERVER(true, NS_JINGLE_INFO, "server");
-const QName QN_JINGLE_INFO_TOKEN(true, NS_JINGLE_INFO, "token");
-const QName QN_JINGLE_INFO_HOST(true, STR_EMPTY, "host");
-const QName QN_JINGLE_INFO_TCP(true, STR_EMPTY, "tcp");
-const QName QN_JINGLE_INFO_UDP(true, STR_EMPTY, "udp");
-const QName QN_JINGLE_INFO_TCPSSL(true, STR_EMPTY, "tcpssl");
+const char NS_JINGLE_INFO[] = "google:jingleinfo";
+const StaticQName QN_JINGLE_INFO_QUERY = { NS_JINGLE_INFO, "query" };
+const StaticQName QN_JINGLE_INFO_STUN = { NS_JINGLE_INFO, "stun" };
+const StaticQName QN_JINGLE_INFO_RELAY = { NS_JINGLE_INFO, "relay" };
+const StaticQName QN_JINGLE_INFO_SERVER = { NS_JINGLE_INFO, "server" };
+const StaticQName QN_JINGLE_INFO_TOKEN = { NS_JINGLE_INFO, "token" };
+const StaticQName QN_JINGLE_INFO_HOST = { STR_EMPTY, "host" };
+const StaticQName QN_JINGLE_INFO_TCP = { STR_EMPTY, "tcp" };
+const StaticQName QN_JINGLE_INFO_UDP = { STR_EMPTY, "udp" };
+const StaticQName QN_JINGLE_INFO_TCPSSL = { STR_EMPTY, "tcpssl" };
// Call Performance Logging
-const std::string NS_GOOGLE_CALLPERF_STATS("google:call-perf-stats");
-const QName QN_CALLPERF_STATS(true, NS_GOOGLE_CALLPERF_STATS, "callPerfStats");
-const QName QN_CALLPERF_SESSIONID(true, STR_EMPTY, "sessionId");
-const QName QN_CALLPERF_LOCALUSER(true, STR_EMPTY, "localUser");
-const QName QN_CALLPERF_REMOTEUSER(true, STR_EMPTY, "remoteUser");
-const QName QN_CALLPERF_STARTTIME(true, STR_EMPTY, "startTime");
-const QName QN_CALLPERF_CALL_LENGTH(true, STR_EMPTY, "callLength");
-const QName QN_CALLPERF_CALL_ACCEPTED(STR_EMPTY, "callAccepted");
-const QName QN_CALLPERF_CALL_ERROR_CODE(STR_EMPTY, "callErrorCode");
-const QName QN_CALLPERF_TERMINATE_CODE(STR_EMPTY, "terminateCode");
-const QName QN_CALLPERF_DATAPOINT(true, NS_GOOGLE_CALLPERF_STATS, "dataPoint");
-const QName QN_CALLPERF_DATAPOINT_TIME(true, STR_EMPTY, "timeStamp");
-const QName QN_CALLPERF_DATAPOINT_FRACTION_LOST(true, STR_EMPTY, "fraction_lost");
-const QName QN_CALLPERF_DATAPOINT_CUM_LOST(true, STR_EMPTY, "cum_lost");
-const QName QN_CALLPERF_DATAPOINT_EXT_MAX(true, STR_EMPTY, "ext_max");
-const QName QN_CALLPERF_DATAPOINT_JITTER(true, STR_EMPTY, "jitter");
-const QName QN_CALLPERF_DATAPOINT_RTT(true, STR_EMPTY, "RTT");
-const QName QN_CALLPERF_DATAPOINT_BYTES_R(true, STR_EMPTY, "bytesReceived");
-const QName QN_CALLPERF_DATAPOINT_PACKETS_R(true, STR_EMPTY, "packetsReceived");
-const QName QN_CALLPERF_DATAPOINT_BYTES_S(true, STR_EMPTY, "bytesSent");
-const QName QN_CALLPERF_DATAPOINT_PACKETS_S(true, STR_EMPTY, "packetsSent");
-const QName QN_CALLPERF_DATAPOINT_PROCESS_CPU(STR_EMPTY, "processCpu");
-const QName QN_CALLPERF_DATAPOINT_SYSTEM_CPU(STR_EMPTY, "systemCpu");
-const QName QN_CALLPERF_DATAPOINT_CPUS(STR_EMPTY, "cpus");
-const QName QN_CALLPERF_CONNECTION(true, NS_GOOGLE_CALLPERF_STATS, "connection");
-const QName QN_CALLPERF_CONNECTION_LOCAL_ADDRESS(true, STR_EMPTY, "localAddress");
-const QName QN_CALLPERF_CONNECTION_REMOTE_ADDRESS(true, STR_EMPTY, "remoteAddress");
-const QName QN_CALLPERF_CONNECTION_FLAGS(STR_EMPTY, "flags");
-const QName QN_CALLPERF_CONNECTION_RTT(STR_EMPTY, "rtt");
-const QName QN_CALLPERF_CONNECTION_TOTAL_BYTES_S(
- STR_EMPTY, "totalBytesSent");
-const QName QN_CALLPERF_CONNECTION_BYTES_SECOND_S(
- STR_EMPTY, "bytesSecondSent");
-const QName QN_CALLPERF_CONNECTION_TOTAL_BYTES_R(
- STR_EMPTY, "totalBytesRecv");
-const QName QN_CALLPERF_CONNECTION_BYTES_SECOND_R(
- STR_EMPTY, "bytesSecondRecv");
-const QName QN_CALLPERF_CANDIDATE(NS_GOOGLE_CALLPERF_STATS, "candidate");
-const QName QN_CALLPERF_CANDIDATE_ENDPOINT(STR_EMPTY, "endpoint");
-const QName QN_CALLPERF_CANDIDATE_PROTOCOL(STR_EMPTY, "protocol");
-const QName QN_CALLPERF_CANDIDATE_ADDRESS(STR_EMPTY, "address");
-const QName QN_CALLPERF_MEDIA(NS_GOOGLE_CALLPERF_STATS, "media");
-const QName QN_CALLPERF_MEDIA_DIRECTION(STR_EMPTY, "direction");
-const QName QN_CALLPERF_MEDIA_SSRC(STR_EMPTY, "SSRC");
-const QName QN_CALLPERF_MEDIA_ENERGY(STR_EMPTY, "energy");
-const QName QN_CALLPERF_MEDIA_FIR(STR_EMPTY, "fir");
-const QName QN_CALLPERF_MEDIA_NACK(STR_EMPTY, "nack");
-const QName QN_CALLPERF_MEDIA_FPS(STR_EMPTY, "fps");
-const QName QN_CALLPERF_MEDIA_FPS_NETWORK(STR_EMPTY, "fpsNetwork");
-const QName QN_CALLPERF_MEDIA_FPS_DECODED(STR_EMPTY, "fpsDecoded");
-const QName QN_CALLPERF_MEDIA_JITTER_BUFFER_SIZE(
- STR_EMPTY, "jitterBufferSize");
-const QName QN_CALLPERF_MEDIA_PREFERRED_JITTER_BUFFER_SIZE(
- STR_EMPTY, "preferredJitterBufferSize");
-const QName QN_CALLPERF_MEDIA_TOTAL_PLAYOUT_DELAY(
- STR_EMPTY, "totalPlayoutDelay");
+const char NS_GOOGLE_CALLPERF_STATS[] = "google:call-perf-stats";
+const StaticQName QN_CALLPERF_STATS =
+ { NS_GOOGLE_CALLPERF_STATS, "callPerfStats" };
+const StaticQName QN_CALLPERF_SESSIONID = { STR_EMPTY, "sessionId" };
+const StaticQName QN_CALLPERF_LOCALUSER = { STR_EMPTY, "localUser" };
+const StaticQName QN_CALLPERF_REMOTEUSER = { STR_EMPTY, "remoteUser" };
+const StaticQName QN_CALLPERF_STARTTIME = { STR_EMPTY, "startTime" };
+const StaticQName QN_CALLPERF_CALL_LENGTH = { STR_EMPTY, "callLength" };
+const StaticQName QN_CALLPERF_CALL_ACCEPTED = { STR_EMPTY, "callAccepted" };
+const StaticQName QN_CALLPERF_CALL_ERROR_CODE = { STR_EMPTY, "callErrorCode" };
+const StaticQName QN_CALLPERF_TERMINATE_CODE = { STR_EMPTY, "terminateCode" };
+const StaticQName QN_CALLPERF_DATAPOINT =
+ { NS_GOOGLE_CALLPERF_STATS, "dataPoint" };
+const StaticQName QN_CALLPERF_DATAPOINT_TIME = { STR_EMPTY, "timeStamp" };
+const StaticQName QN_CALLPERF_DATAPOINT_FRACTION_LOST =
+ { STR_EMPTY, "fraction_lost" };
+const StaticQName QN_CALLPERF_DATAPOINT_CUM_LOST = { STR_EMPTY, "cum_lost" };
+const StaticQName QN_CALLPERF_DATAPOINT_EXT_MAX = { STR_EMPTY, "ext_max" };
+const StaticQName QN_CALLPERF_DATAPOINT_JITTER = { STR_EMPTY, "jitter" };
+const StaticQName QN_CALLPERF_DATAPOINT_RTT = { STR_EMPTY, "RTT" };
+const StaticQName QN_CALLPERF_DATAPOINT_BYTES_R =
+ { STR_EMPTY, "bytesReceived" };
+const StaticQName QN_CALLPERF_DATAPOINT_PACKETS_R =
+ { STR_EMPTY, "packetsReceived" };
+const StaticQName QN_CALLPERF_DATAPOINT_BYTES_S = { STR_EMPTY, "bytesSent" };
+const StaticQName QN_CALLPERF_DATAPOINT_PACKETS_S =
+ { STR_EMPTY, "packetsSent" };
+const StaticQName QN_CALLPERF_DATAPOINT_PROCESS_CPU =
+ { STR_EMPTY, "processCpu" };
+const StaticQName QN_CALLPERF_DATAPOINT_SYSTEM_CPU = { STR_EMPTY, "systemCpu" };
+const StaticQName QN_CALLPERF_DATAPOINT_CPUS = { STR_EMPTY, "cpus" };
+const StaticQName QN_CALLPERF_CONNECTION =
+ { NS_GOOGLE_CALLPERF_STATS, "connection" };
+const StaticQName QN_CALLPERF_CONNECTION_LOCAL_ADDRESS =
+ { STR_EMPTY, "localAddress" };
+const StaticQName QN_CALLPERF_CONNECTION_REMOTE_ADDRESS =
+ { STR_EMPTY, "remoteAddress" };
+const StaticQName QN_CALLPERF_CONNECTION_FLAGS = { STR_EMPTY, "flags" };
+const StaticQName QN_CALLPERF_CONNECTION_RTT = { STR_EMPTY, "rtt" };
+const StaticQName QN_CALLPERF_CONNECTION_TOTAL_BYTES_S =
+ { STR_EMPTY, "totalBytesSent" };
+const StaticQName QN_CALLPERF_CONNECTION_BYTES_SECOND_S =
+ { STR_EMPTY, "bytesSecondSent" };
+const StaticQName QN_CALLPERF_CONNECTION_TOTAL_BYTES_R =
+ { STR_EMPTY, "totalBytesRecv" };
+const StaticQName QN_CALLPERF_CONNECTION_BYTES_SECOND_R =
+ { STR_EMPTY, "bytesSecondRecv" };
+const StaticQName QN_CALLPERF_CANDIDATE =
+ { NS_GOOGLE_CALLPERF_STATS, "candidate" };
+const StaticQName QN_CALLPERF_CANDIDATE_ENDPOINT = { STR_EMPTY, "endpoint" };
+const StaticQName QN_CALLPERF_CANDIDATE_PROTOCOL = { STR_EMPTY, "protocol" };
+const StaticQName QN_CALLPERF_CANDIDATE_ADDRESS = { STR_EMPTY, "address" };
+const StaticQName QN_CALLPERF_MEDIA = { NS_GOOGLE_CALLPERF_STATS, "media" };
+const StaticQName QN_CALLPERF_MEDIA_DIRECTION = { STR_EMPTY, "direction" };
+const StaticQName QN_CALLPERF_MEDIA_SSRC = { STR_EMPTY, "SSRC" };
+const StaticQName QN_CALLPERF_MEDIA_ENERGY = { STR_EMPTY, "energy" };
+const StaticQName QN_CALLPERF_MEDIA_FIR = { STR_EMPTY, "fir" };
+const StaticQName QN_CALLPERF_MEDIA_NACK = { STR_EMPTY, "nack" };
+const StaticQName QN_CALLPERF_MEDIA_FPS = { STR_EMPTY, "fps" };
+const StaticQName QN_CALLPERF_MEDIA_FPS_NETWORK = { STR_EMPTY, "fpsNetwork" };
+const StaticQName QN_CALLPERF_MEDIA_FPS_DECODED = { STR_EMPTY, "fpsDecoded" };
+const StaticQName QN_CALLPERF_MEDIA_JITTER_BUFFER_SIZE =
+ { STR_EMPTY, "jitterBufferSize" };
+const StaticQName QN_CALLPERF_MEDIA_PREFERRED_JITTER_BUFFER_SIZE =
+ { STR_EMPTY, "preferredJitterBufferSize" };
+const StaticQName QN_CALLPERF_MEDIA_TOTAL_PLAYOUT_DELAY =
+ { STR_EMPTY, "totalPlayoutDelay" };
// Muc invites.
-const QName QN_MUC_USER_INVITE(true, NS_MUC_USER, "invite");
+const StaticQName QN_MUC_USER_INVITE = { NS_MUC_USER, "invite" };
// Multiway audio/video.
-const std::string NS_GOOGLE_MUC_USER("google:muc#user");
-const QName QN_GOOGLE_MUC_USER_AVAILABLE_MEDIA(true, NS_GOOGLE_MUC_USER, "available-media");
-const QName QN_GOOGLE_MUC_USER_ENTRY(true, NS_GOOGLE_MUC_USER, "entry");
-const QName QN_GOOGLE_MUC_USER_MEDIA(true, NS_GOOGLE_MUC_USER, "media");
-const QName QN_GOOGLE_MUC_USER_TYPE(true, NS_GOOGLE_MUC_USER, "type");
-const QName QN_GOOGLE_MUC_USER_SRC_ID(true, NS_GOOGLE_MUC_USER, "src-id");
-const QName QN_GOOGLE_MUC_USER_STATUS(true, NS_GOOGLE_MUC_USER, "status");
-const QName QN_LABEL(true, STR_EMPTY, "label");
+const char NS_GOOGLE_MUC_USER[] = "google:muc#user";
+const StaticQName QN_GOOGLE_MUC_USER_AVAILABLE_MEDIA =
+ { NS_GOOGLE_MUC_USER, "available-media" };
+const StaticQName QN_GOOGLE_MUC_USER_ENTRY = { NS_GOOGLE_MUC_USER, "entry" };
+const StaticQName QN_GOOGLE_MUC_USER_MEDIA = { NS_GOOGLE_MUC_USER, "media" };
+const StaticQName QN_GOOGLE_MUC_USER_TYPE = { NS_GOOGLE_MUC_USER, "type" };
+const StaticQName QN_GOOGLE_MUC_USER_SRC_ID = { NS_GOOGLE_MUC_USER, "src-id" };
+const StaticQName QN_GOOGLE_MUC_USER_STATUS = { NS_GOOGLE_MUC_USER, "status" };
+const StaticQName QN_LABEL = { STR_EMPTY, "label" };
-const std::string NS_GOOGLE_MUC_MEDIA("google:muc#media");
-const QName QN_GOOGLE_MUC_AUDIO_MUTE(
- true, NS_GOOGLE_MUC_MEDIA, "audio-mute");
-const QName QN_GOOGLE_MUC_VIDEO_MUTE(
- true, NS_GOOGLE_MUC_MEDIA, "video-mute");
-const QName QN_GOOGLE_MUC_RECORDING(
- true, NS_GOOGLE_MUC_MEDIA, "recording");
-const QName QN_STATE_ATTR(true, STR_EMPTY, "state");
+const char NS_GOOGLE_MUC_MEDIA[] = "google:muc#media";
+const StaticQName QN_GOOGLE_MUC_AUDIO_MUTE =
+ { NS_GOOGLE_MUC_MEDIA, "audio-mute" };
+const StaticQName QN_GOOGLE_MUC_VIDEO_MUTE =
+ { NS_GOOGLE_MUC_MEDIA, "video-mute" };
+const StaticQName QN_GOOGLE_MUC_RECORDING =
+ { NS_GOOGLE_MUC_MEDIA, "recording" };
+const StaticQName QN_GOOGLE_MUC_MEDIA_BLOCK = { NS_GOOGLE_MUC_MEDIA, "block" };
+const StaticQName QN_STATE_ATTR = { STR_EMPTY, "state" };
}
diff --git a/talk/xmpp/constants.h b/talk/xmpp/constants.h
index 4409283..ad7d829 100644
--- a/talk/xmpp/constants.h
+++ b/talk/xmpp/constants.h
@@ -32,500 +32,472 @@
#include "talk/xmllite/qname.h"
#include "talk/xmpp/jid.h"
-
-#define NS_CLIENT Constants::ns_client()
-#define NS_SERVER Constants::ns_server()
-#define NS_STREAM Constants::ns_stream()
-#define NS_XSTREAM Constants::ns_xstream()
-#define NS_TLS Constants::ns_tls()
-#define NS_SASL Constants::ns_sasl()
-#define NS_BIND Constants::ns_bind()
-#define NS_DIALBACK Constants::ns_dialback()
-#define NS_SESSION Constants::ns_session()
-#define NS_STANZA Constants::ns_stanza()
-#define NS_PRIVACY Constants::ns_privacy()
-#define NS_ROSTER Constants::ns_roster()
-#define NS_VCARD Constants::ns_vcard()
-#define NS_AVATAR_HASH Constants::ns_avatar_hash()
-#define NS_VCARD_UPDATE Constants::ns_vcard_update()
-#define STR_CLIENT Constants::str_client()
-#define STR_SERVER Constants::str_server()
-#define STR_STREAM Constants::str_stream()
-
-
namespace buzz {
-extern const Jid JID_EMPTY;
+extern const char NS_CLIENT[];
+extern const char NS_SERVER[];
+extern const char NS_STREAM[];
+extern const char NS_XSTREAM[];
+extern const char NS_TLS[];
+extern const char NS_SASL[];
+extern const char NS_BIND[];
+extern const char NS_DIALBACK[];
+extern const char NS_SESSION[];
+extern const char NS_STANZA[];
+extern const char NS_PRIVACY[];
+extern const char NS_ROSTER[];
+extern const char NS_VCARD[];
+extern const char NS_AVATAR_HASH[];
+extern const char NS_VCARD_UPDATE[];
+extern const char STR_CLIENT[];
+extern const char STR_SERVER[];
+extern const char STR_STREAM[];
-class Constants {
- public:
- static const std::string & ns_client();
- static const std::string & ns_server();
- static const std::string & ns_stream();
- static const std::string & ns_xstream();
- static const std::string & ns_tls();
- static const std::string & ns_sasl();
- static const std::string & ns_bind();
- static const std::string & ns_dialback();
- static const std::string & ns_session();
- static const std::string & ns_stanza();
- static const std::string & ns_privacy();
- static const std::string & ns_roster();
- static const std::string & ns_vcard();
- static const std::string & ns_avatar_hash();
- static const std::string & ns_vcard_update();
+extern const char STR_GET[];
+extern const char STR_SET[];
+extern const char STR_RESULT[];
+extern const char STR_ERROR[];
- static const std::string & str_client();
- static const std::string & str_server();
- static const std::string & str_stream();
-};
+extern const char STR_FORM[];
+extern const char STR_SUBMIT[];
+extern const char STR_TEXT_SINGLE[];
+extern const char STR_LIST_SINGLE[];
+extern const char STR_LIST_MULTI[];
+extern const char STR_HIDDEN[];
+extern const char STR_FORM_TYPE[];
-extern const std::string STR_GET;
-extern const std::string STR_SET;
-extern const std::string STR_RESULT;
-extern const std::string STR_ERROR;
+extern const char STR_FROM[];
+extern const char STR_TO[];
+extern const char STR_BOTH[];
+extern const char STR_REMOVE[];
-extern const std::string STR_FORM;
-extern const std::string STR_SUBMIT;
-extern const std::string STR_TEXT_SINGLE;
-extern const std::string STR_LIST_SINGLE;
-extern const std::string STR_LIST_MULTI;
-extern const std::string STR_HIDDEN;
-extern const std::string STR_FORM_TYPE;
-
-extern const std::string STR_FROM;
-extern const std::string STR_TO;
-extern const std::string STR_BOTH;
-extern const std::string STR_REMOVE;
-
-extern const std::string STR_TYPE;
-extern const std::string STR_NAME;
-extern const std::string STR_ID;
-extern const std::string STR_JID;
-extern const std::string STR_SUBSCRIPTION;
-extern const std::string STR_ASK;
-extern const std::string STR_X;
-extern const std::string STR_GOOGLE_COM;
-extern const std::string STR_GMAIL_COM;
-extern const std::string STR_GOOGLEMAIL_COM;
-extern const std::string STR_DEFAULT_DOMAIN;
-extern const std::string STR_TALK_GOOGLE_COM;
-extern const std::string STR_TALKX_L_GOOGLE_COM;
-extern const std::string STR_XMPP_GOOGLE_COM;
-extern const std::string STR_XMPPX_L_GOOGLE_COM;
+extern const char STR_TYPE[];
+extern const char STR_NAME[];
+extern const char STR_ID[];
+extern const char STR_JID[];
+extern const char STR_SUBSCRIPTION[];
+extern const char STR_ASK[];
+extern const char STR_X[];
+extern const char STR_GOOGLE_COM[];
+extern const char STR_GMAIL_COM[];
+extern const char STR_GOOGLEMAIL_COM[];
+extern const char STR_DEFAULT_DOMAIN[];
+extern const char STR_TALK_GOOGLE_COM[];
+extern const char STR_TALKX_L_GOOGLE_COM[];
+extern const char STR_XMPP_GOOGLE_COM[];
+extern const char STR_XMPPX_L_GOOGLE_COM[];
#ifdef FEATURE_ENABLE_VOICEMAIL
-extern const std::string STR_VOICEMAIL;
-extern const std::string STR_OUTGOINGVOICEMAIL;
+extern const char STR_VOICEMAIL[];
+extern const char STR_OUTGOINGVOICEMAIL[];
#endif
-extern const std::string STR_UNAVAILABLE;
+extern const char STR_UNAVAILABLE[];
-extern const Jid JID_GOOGLE_MUC_LOOKUP;
-extern const std::string STR_MUC_ROOMCONFIG_ROOMNAME;
-extern const std::string STR_MUC_ROOMCONFIG_FEATURES;
-extern const std::string STR_MUC_ROOM_FEATURE_ENTERPRISE;
+extern const char STR_GOOGLE_MUC_LOOKUP_JID[];
+extern const char STR_MUC_ROOMCONFIG_ROOMNAME[];
+extern const char STR_MUC_ROOMCONFIG_FEATURES[];
+extern const char STR_MUC_ROOM_FEATURE_ENTERPRISE[];
+extern const char STR_MUC_ROOMCONFIG[];
-extern const QName QN_STREAM_STREAM;
-extern const QName QN_STREAM_FEATURES;
-extern const QName QN_STREAM_ERROR;
+extern const StaticQName QN_STREAM_STREAM;
+extern const StaticQName QN_STREAM_FEATURES;
+extern const StaticQName QN_STREAM_ERROR;
-extern const QName QN_XSTREAM_BAD_FORMAT;
-extern const QName QN_XSTREAM_BAD_NAMESPACE_PREFIX;
-extern const QName QN_XSTREAM_CONFLICT;
-extern const QName QN_XSTREAM_CONNECTION_TIMEOUT;
-extern const QName QN_XSTREAM_HOST_GONE;
-extern const QName QN_XSTREAM_HOST_UNKNOWN;
-extern const QName QN_XSTREAM_IMPROPER_ADDRESSIING;
-extern const QName QN_XSTREAM_INTERNAL_SERVER_ERROR;
-extern const QName QN_XSTREAM_INVALID_FROM;
-extern const QName QN_XSTREAM_INVALID_ID;
-extern const QName QN_XSTREAM_INVALID_NAMESPACE;
-extern const QName QN_XSTREAM_INVALID_XML;
-extern const QName QN_XSTREAM_NOT_AUTHORIZED;
-extern const QName QN_XSTREAM_POLICY_VIOLATION;
-extern const QName QN_XSTREAM_REMOTE_CONNECTION_FAILED;
-extern const QName QN_XSTREAM_RESOURCE_CONSTRAINT;
-extern const QName QN_XSTREAM_RESTRICTED_XML;
-extern const QName QN_XSTREAM_SEE_OTHER_HOST;
-extern const QName QN_XSTREAM_SYSTEM_SHUTDOWN;
-extern const QName QN_XSTREAM_UNDEFINED_CONDITION;
-extern const QName QN_XSTREAM_UNSUPPORTED_ENCODING;
-extern const QName QN_XSTREAM_UNSUPPORTED_STANZA_TYPE;
-extern const QName QN_XSTREAM_UNSUPPORTED_VERSION;
-extern const QName QN_XSTREAM_XML_NOT_WELL_FORMED;
-extern const QName QN_XSTREAM_TEXT;
+extern const StaticQName QN_XSTREAM_BAD_FORMAT;
+extern const StaticQName QN_XSTREAM_BAD_NAMESPACE_PREFIX;
+extern const StaticQName QN_XSTREAM_CONFLICT;
+extern const StaticQName QN_XSTREAM_CONNECTION_TIMEOUT;
+extern const StaticQName QN_XSTREAM_HOST_GONE;
+extern const StaticQName QN_XSTREAM_HOST_UNKNOWN;
+extern const StaticQName QN_XSTREAM_IMPROPER_ADDRESSIING;
+extern const StaticQName QN_XSTREAM_INTERNAL_SERVER_ERROR;
+extern const StaticQName QN_XSTREAM_INVALID_FROM;
+extern const StaticQName QN_XSTREAM_INVALID_ID;
+extern const StaticQName QN_XSTREAM_INVALID_NAMESPACE;
+extern const StaticQName QN_XSTREAM_INVALID_XML;
+extern const StaticQName QN_XSTREAM_NOT_AUTHORIZED;
+extern const StaticQName QN_XSTREAM_POLICY_VIOLATION;
+extern const StaticQName QN_XSTREAM_REMOTE_CONNECTION_FAILED;
+extern const StaticQName QN_XSTREAM_RESOURCE_CONSTRAINT;
+extern const StaticQName QN_XSTREAM_RESTRICTED_XML;
+extern const StaticQName QN_XSTREAM_SEE_OTHER_HOST;
+extern const StaticQName QN_XSTREAM_SYSTEM_SHUTDOWN;
+extern const StaticQName QN_XSTREAM_UNDEFINED_CONDITION;
+extern const StaticQName QN_XSTREAM_UNSUPPORTED_ENCODING;
+extern const StaticQName QN_XSTREAM_UNSUPPORTED_STANZA_TYPE;
+extern const StaticQName QN_XSTREAM_UNSUPPORTED_VERSION;
+extern const StaticQName QN_XSTREAM_XML_NOT_WELL_FORMED;
+extern const StaticQName QN_XSTREAM_TEXT;
-extern const QName QN_TLS_STARTTLS;
-extern const QName QN_TLS_REQUIRED;
-extern const QName QN_TLS_PROCEED;
-extern const QName QN_TLS_FAILURE;
+extern const StaticQName QN_TLS_STARTTLS;
+extern const StaticQName QN_TLS_REQUIRED;
+extern const StaticQName QN_TLS_PROCEED;
+extern const StaticQName QN_TLS_FAILURE;
-extern const QName QN_SASL_MECHANISMS;
-extern const QName QN_SASL_MECHANISM;
-extern const QName QN_SASL_AUTH;
-extern const QName QN_SASL_CHALLENGE;
-extern const QName QN_SASL_RESPONSE;
-extern const QName QN_SASL_ABORT;
-extern const QName QN_SASL_SUCCESS;
-extern const QName QN_SASL_FAILURE;
-extern const QName QN_SASL_ABORTED;
-extern const QName QN_SASL_INCORRECT_ENCODING;
-extern const QName QN_SASL_INVALID_AUTHZID;
-extern const QName QN_SASL_INVALID_MECHANISM;
-extern const QName QN_SASL_MECHANISM_TOO_WEAK;
-extern const QName QN_SASL_NOT_AUTHORIZED;
-extern const QName QN_SASL_TEMPORARY_AUTH_FAILURE;
+extern const StaticQName QN_SASL_MECHANISMS;
+extern const StaticQName QN_SASL_MECHANISM;
+extern const StaticQName QN_SASL_AUTH;
+extern const StaticQName QN_SASL_CHALLENGE;
+extern const StaticQName QN_SASL_RESPONSE;
+extern const StaticQName QN_SASL_ABORT;
+extern const StaticQName QN_SASL_SUCCESS;
+extern const StaticQName QN_SASL_FAILURE;
+extern const StaticQName QN_SASL_ABORTED;
+extern const StaticQName QN_SASL_INCORRECT_ENCODING;
+extern const StaticQName QN_SASL_INVALID_AUTHZID;
+extern const StaticQName QN_SASL_INVALID_MECHANISM;
+extern const StaticQName QN_SASL_MECHANISM_TOO_WEAK;
+extern const StaticQName QN_SASL_NOT_AUTHORIZED;
+extern const StaticQName QN_SASL_TEMPORARY_AUTH_FAILURE;
-extern const QName QN_DIALBACK_RESULT;
-extern const QName QN_DIALBACK_VERIFY;
+// These are non-standard.
+extern const char NS_GOOGLE_AUTH[];
+extern const char NS_GOOGLE_AUTH_PROTOCOL[];
+extern const StaticQName QN_GOOGLE_AUTH_CLIENT_USES_FULL_BIND_RESULT;
+extern const StaticQName QN_GOOGLE_ALLOW_NON_GOOGLE_ID_XMPP_LOGIN;
-extern const QName QN_STANZA_BAD_REQUEST;
-extern const QName QN_STANZA_CONFLICT;
-extern const QName QN_STANZA_FEATURE_NOT_IMPLEMENTED;
-extern const QName QN_STANZA_FORBIDDEN;
-extern const QName QN_STANZA_GONE;
-extern const QName QN_STANZA_INTERNAL_SERVER_ERROR;
-extern const QName QN_STANZA_ITEM_NOT_FOUND;
-extern const QName QN_STANZA_JID_MALFORMED;
-extern const QName QN_STANZA_NOT_ACCEPTABLE;
-extern const QName QN_STANZA_NOT_ALLOWED;
-extern const QName QN_STANZA_PAYMENT_REQUIRED;
-extern const QName QN_STANZA_RECIPIENT_UNAVAILABLE;
-extern const QName QN_STANZA_REDIRECT;
-extern const QName QN_STANZA_REGISTRATION_REQUIRED;
-extern const QName QN_STANZA_REMOTE_SERVER_NOT_FOUND;
-extern const QName QN_STANZA_REMOTE_SERVER_TIMEOUT;
-extern const QName QN_STANZA_RESOURCE_CONSTRAINT;
-extern const QName QN_STANZA_SERVICE_UNAVAILABLE;
-extern const QName QN_STANZA_SUBSCRIPTION_REQUIRED;
-extern const QName QN_STANZA_UNDEFINED_CONDITION;
-extern const QName QN_STANZA_UNEXPECTED_REQUEST;
-extern const QName QN_STANZA_TEXT;
+extern const StaticQName QN_DIALBACK_RESULT;
+extern const StaticQName QN_DIALBACK_VERIFY;
-extern const QName QN_BIND_BIND;
-extern const QName QN_BIND_RESOURCE;
-extern const QName QN_BIND_JID;
+extern const StaticQName QN_STANZA_BAD_REQUEST;
+extern const StaticQName QN_STANZA_CONFLICT;
+extern const StaticQName QN_STANZA_FEATURE_NOT_IMPLEMENTED;
+extern const StaticQName QN_STANZA_FORBIDDEN;
+extern const StaticQName QN_STANZA_GONE;
+extern const StaticQName QN_STANZA_INTERNAL_SERVER_ERROR;
+extern const StaticQName QN_STANZA_ITEM_NOT_FOUND;
+extern const StaticQName QN_STANZA_JID_MALFORMED;
+extern const StaticQName QN_STANZA_NOT_ACCEPTABLE;
+extern const StaticQName QN_STANZA_NOT_ALLOWED;
+extern const StaticQName QN_STANZA_PAYMENT_REQUIRED;
+extern const StaticQName QN_STANZA_RECIPIENT_UNAVAILABLE;
+extern const StaticQName QN_STANZA_REDIRECT;
+extern const StaticQName QN_STANZA_REGISTRATION_REQUIRED;
+extern const StaticQName QN_STANZA_REMOTE_SERVER_NOT_FOUND;
+extern const StaticQName QN_STANZA_REMOTE_SERVER_TIMEOUT;
+extern const StaticQName QN_STANZA_RESOURCE_CONSTRAINT;
+extern const StaticQName QN_STANZA_SERVICE_UNAVAILABLE;
+extern const StaticQName QN_STANZA_SUBSCRIPTION_REQUIRED;
+extern const StaticQName QN_STANZA_UNDEFINED_CONDITION;
+extern const StaticQName QN_STANZA_UNEXPECTED_REQUEST;
+extern const StaticQName QN_STANZA_TEXT;
-extern const QName QN_MESSAGE;
-extern const QName QN_BODY;
-extern const QName QN_SUBJECT;
-extern const QName QN_THREAD;
-extern const QName QN_PRESENCE;
-extern const QName QN_SHOW;
-extern const QName QN_STATUS;
-extern const QName QN_LANG;
-extern const QName QN_PRIORITY;
-extern const QName QN_IQ;
-extern const QName QN_ERROR;
+extern const StaticQName QN_BIND_BIND;
+extern const StaticQName QN_BIND_RESOURCE;
+extern const StaticQName QN_BIND_JID;
-extern const QName QN_SERVER_MESSAGE;
-extern const QName QN_SERVER_BODY;
-extern const QName QN_SERVER_SUBJECT;
-extern const QName QN_SERVER_THREAD;
-extern const QName QN_SERVER_PRESENCE;
-extern const QName QN_SERVER_SHOW;
-extern const QName QN_SERVER_STATUS;
-extern const QName QN_SERVER_LANG;
-extern const QName QN_SERVER_PRIORITY;
-extern const QName QN_SERVER_IQ;
-extern const QName QN_SERVER_ERROR;
+extern const StaticQName QN_MESSAGE;
+extern const StaticQName QN_BODY;
+extern const StaticQName QN_SUBJECT;
+extern const StaticQName QN_THREAD;
+extern const StaticQName QN_PRESENCE;
+extern const StaticQName QN_SHOW;
+extern const StaticQName QN_STATUS;
+extern const StaticQName QN_LANG;
+extern const StaticQName QN_PRIORITY;
+extern const StaticQName QN_IQ;
+extern const StaticQName QN_ERROR;
-extern const QName QN_SESSION_SESSION;
+extern const StaticQName QN_SERVER_MESSAGE;
+extern const StaticQName QN_SERVER_BODY;
+extern const StaticQName QN_SERVER_SUBJECT;
+extern const StaticQName QN_SERVER_THREAD;
+extern const StaticQName QN_SERVER_PRESENCE;
+extern const StaticQName QN_SERVER_SHOW;
+extern const StaticQName QN_SERVER_STATUS;
+extern const StaticQName QN_SERVER_LANG;
+extern const StaticQName QN_SERVER_PRIORITY;
+extern const StaticQName QN_SERVER_IQ;
+extern const StaticQName QN_SERVER_ERROR;
-extern const QName QN_PRIVACY_QUERY;
-extern const QName QN_PRIVACY_ACTIVE;
-extern const QName QN_PRIVACY_DEFAULT;
-extern const QName QN_PRIVACY_LIST;
-extern const QName QN_PRIVACY_ITEM;
-extern const QName QN_PRIVACY_IQ;
-extern const QName QN_PRIVACY_MESSAGE;
-extern const QName QN_PRIVACY_PRESENCE_IN;
-extern const QName QN_PRIVACY_PRESENCE_OUT;
+extern const StaticQName QN_SESSION_SESSION;
-extern const QName QN_ROSTER_QUERY;
-extern const QName QN_ROSTER_ITEM;
-extern const QName QN_ROSTER_GROUP;
+extern const StaticQName QN_PRIVACY_QUERY;
+extern const StaticQName QN_PRIVACY_ACTIVE;
+extern const StaticQName QN_PRIVACY_DEFAULT;
+extern const StaticQName QN_PRIVACY_LIST;
+extern const StaticQName QN_PRIVACY_ITEM;
+extern const StaticQName QN_PRIVACY_IQ;
+extern const StaticQName QN_PRIVACY_MESSAGE;
+extern const StaticQName QN_PRIVACY_PRESENCE_IN;
+extern const StaticQName QN_PRIVACY_PRESENCE_OUT;
-extern const QName QN_VCARD;
-extern const QName QN_VCARD_FN;
-extern const QName QN_VCARD_PHOTO;
-extern const QName QN_VCARD_PHOTO_BINVAL;
-extern const QName QN_VCARD_AVATAR_HASH;
-extern const QName QN_VCARD_AVATAR_HASH_MODIFIED;
+extern const StaticQName QN_ROSTER_QUERY;
+extern const StaticQName QN_ROSTER_ITEM;
+extern const StaticQName QN_ROSTER_GROUP;
+
+extern const StaticQName QN_VCARD;
+extern const StaticQName QN_VCARD_FN;
+extern const StaticQName QN_VCARD_PHOTO;
+extern const StaticQName QN_VCARD_PHOTO_BINVAL;
+extern const StaticQName QN_VCARD_AVATAR_HASH;
+extern const StaticQName QN_VCARD_AVATAR_HASH_MODIFIED;
#if defined(FEATURE_ENABLE_PSTN)
-extern const QName QN_VCARD_TEL;
-extern const QName QN_VCARD_VOICE;
-extern const QName QN_VCARD_HOME;
-extern const QName QN_VCARD_WORK;
-extern const QName QN_VCARD_CELL;
-extern const QName QN_VCARD_NUMBER;
+extern const StaticQName QN_VCARD_TEL;
+extern const StaticQName QN_VCARD_VOICE;
+extern const StaticQName QN_VCARD_HOME;
+extern const StaticQName QN_VCARD_WORK;
+extern const StaticQName QN_VCARD_CELL;
+extern const StaticQName QN_VCARD_NUMBER;
#endif
#if defined(FEATURE_ENABLE_RICHPROFILES)
-extern const QName QN_USER_PROFILE_QUERY;
-extern const QName QN_USER_PROFILE_URL;
+extern const StaticQName QN_USER_PROFILE_QUERY;
+extern const StaticQName QN_USER_PROFILE_URL;
-extern const QName QN_ATOM_FEED;
-extern const QName QN_ATOM_ENTRY;
-extern const QName QN_ATOM_TITLE;
-extern const QName QN_ATOM_ID;
-extern const QName QN_ATOM_MODIFIED;
-extern const QName QN_ATOM_IMAGE;
-extern const QName QN_ATOM_LINK;
-extern const QName QN_ATOM_HREF;
+extern const StaticQName QN_ATOM_FEED;
+extern const StaticQName QN_ATOM_ENTRY;
+extern const StaticQName QN_ATOM_TITLE;
+extern const StaticQName QN_ATOM_ID;
+extern const StaticQName QN_ATOM_MODIFIED;
+extern const StaticQName QN_ATOM_IMAGE;
+extern const StaticQName QN_ATOM_LINK;
+extern const StaticQName QN_ATOM_HREF;
#endif
-extern const QName QN_XML_LANG;
+extern const StaticQName QN_XML_LANG;
-extern const QName QN_ENCODING;
-extern const QName QN_VERSION;
-extern const QName QN_TO;
-extern const QName QN_FROM;
-extern const QName QN_TYPE;
-extern const QName QN_ID;
-extern const QName QN_CODE;
-extern const QName QN_NAME;
-extern const QName QN_VALUE;
-extern const QName QN_ACTION;
-extern const QName QN_ORDER;
-extern const QName QN_MECHANISM;
-extern const QName QN_ASK;
-extern const QName QN_JID;
-extern const QName QN_NICK;
-extern const QName QN_SUBSCRIPTION;
-extern const QName QN_TITLE1;
-extern const QName QN_TITLE2;
-extern const QName QN_AFFILIATION;
-extern const QName QN_ROLE;
-extern const QName QN_TIME;
+extern const StaticQName QN_ENCODING;
+extern const StaticQName QN_VERSION;
+extern const StaticQName QN_TO;
+extern const StaticQName QN_FROM;
+extern const StaticQName QN_TYPE;
+extern const StaticQName QN_ID;
+extern const StaticQName QN_CODE;
+extern const StaticQName QN_NAME;
+extern const StaticQName QN_VALUE;
+extern const StaticQName QN_ACTION;
+extern const StaticQName QN_ORDER;
+extern const StaticQName QN_MECHANISM;
+extern const StaticQName QN_ASK;
+extern const StaticQName QN_JID;
+extern const StaticQName QN_NICK;
+extern const StaticQName QN_SUBSCRIPTION;
+extern const StaticQName QN_TITLE1;
+extern const StaticQName QN_TITLE2;
+extern const StaticQName QN_AFFILIATION;
+extern const StaticQName QN_ROLE;
+extern const StaticQName QN_TIME;
-
-extern const QName QN_XMLNS_CLIENT;
-extern const QName QN_XMLNS_SERVER;
-extern const QName QN_XMLNS_STREAM;
+extern const StaticQName QN_XMLNS_CLIENT;
+extern const StaticQName QN_XMLNS_SERVER;
+extern const StaticQName QN_XMLNS_STREAM;
// Presence
-extern const std::string STR_SHOW_AWAY;
-extern const std::string STR_SHOW_CHAT;
-extern const std::string STR_SHOW_DND;
-extern const std::string STR_SHOW_XA;
-extern const std::string STR_SHOW_OFFLINE;
+extern const char STR_SHOW_AWAY[];
+extern const char STR_SHOW_CHAT[];
+extern const char STR_SHOW_DND[];
+extern const char STR_SHOW_XA[];
+extern const char STR_SHOW_OFFLINE[];
// Subscription
-extern const std::string STR_SUBSCRIBE;
-extern const std::string STR_SUBSCRIBED;
-extern const std::string STR_UNSUBSCRIBE;
-extern const std::string STR_UNSUBSCRIBED;
+extern const char STR_SUBSCRIBE[];
+extern const char STR_SUBSCRIBED[];
+extern const char STR_UNSUBSCRIBE[];
+extern const char STR_UNSUBSCRIBED[];
// Google Invite
-extern const std::string NS_GOOGLE_SUBSCRIBE;
-extern const QName QN_INVITATION;
-extern const QName QN_INVITE_NAME;
-extern const QName QN_INVITE_SUBJECT;
-extern const QName QN_INVITE_MESSAGE;
+extern const char NS_GOOGLE_SUBSCRIBE[];
+extern const StaticQName QN_INVITATION;
+extern const StaticQName QN_INVITE_NAME;
+extern const StaticQName QN_INVITE_SUBJECT;
+extern const StaticQName QN_INVITE_MESSAGE;
// PubSub: http://xmpp.org/extensions/xep-0060.html
-extern const std::string NS_PUBSUB;
-extern const QName QN_PUBSUB;
-extern const QName QN_PUBSUB_ITEMS;
-extern const QName QN_PUBSUB_ITEM;
-extern const QName QN_PUBSUB_PUBLISH;
-extern const QName QN_PUBSUB_RETRACT;
-extern const QName QN_ATTR_PUBLISHER;
+extern const char NS_PUBSUB[];
+extern const StaticQName QN_PUBSUB;
+extern const StaticQName QN_PUBSUB_ITEMS;
+extern const StaticQName QN_PUBSUB_ITEM;
+extern const StaticQName QN_PUBSUB_PUBLISH;
+extern const StaticQName QN_PUBSUB_RETRACT;
+extern const StaticQName QN_ATTR_PUBLISHER;
-extern const std::string NS_PUBSUB_EVENT;
-extern const QName QN_NODE;
-extern const QName QN_PUBSUB_EVENT;
-extern const QName QN_PUBSUB_EVENT_ITEMS;
-extern const QName QN_PUBSUB_EVENT_ITEM;
-extern const QName QN_PUBSUB_EVENT_RETRACT;
-extern const QName QN_NOTIFY;
+extern const char NS_PUBSUB_EVENT[];
+extern const StaticQName QN_NODE;
+extern const StaticQName QN_PUBSUB_EVENT;
+extern const StaticQName QN_PUBSUB_EVENT_ITEMS;
+extern const StaticQName QN_PUBSUB_EVENT_ITEM;
+extern const StaticQName QN_PUBSUB_EVENT_RETRACT;
+extern const StaticQName QN_NOTIFY;
-
-extern const std::string NS_PRESENTER;
-extern const QName QN_PRESENTER_PRESENTER;
-extern const QName QN_PRESENTER_PRESENTATION_ITEM;
-extern const QName QN_PRESENTER_PRESENTATION_TYPE;
-extern const QName QN_PRESENTER_PRESENTATION_ID;
-
-
-
+extern const char NS_PRESENTER[];
+extern const StaticQName QN_PRESENTER_PRESENTER;
+extern const StaticQName QN_PRESENTER_PRESENTATION_ITEM;
+extern const StaticQName QN_PRESENTER_PRESENTATION_TYPE;
+extern const StaticQName QN_PRESENTER_PRESENTATION_ID;
// JEP 0030
-extern const QName QN_CATEGORY;
-extern const QName QN_VAR;
-extern const std::string NS_DISCO_INFO;
-extern const std::string NS_DISCO_ITEMS;
+extern const StaticQName QN_CATEGORY;
+extern const StaticQName QN_VAR;
+extern const char NS_DISCO_INFO[];
+extern const char NS_DISCO_ITEMS[];
-extern const QName QN_DISCO_INFO_QUERY;
-extern const QName QN_DISCO_IDENTITY;
-extern const QName QN_DISCO_FEATURE;
+extern const StaticQName QN_DISCO_INFO_QUERY;
+extern const StaticQName QN_DISCO_IDENTITY;
+extern const StaticQName QN_DISCO_FEATURE;
-extern const QName QN_DISCO_ITEMS_QUERY;
-extern const QName QN_DISCO_ITEM;
+extern const StaticQName QN_DISCO_ITEMS_QUERY;
+extern const StaticQName QN_DISCO_ITEM;
// JEP 0020
-extern const std::string NS_FEATURE;
-extern const QName QN_FEATURE_FEATURE;
+extern const char NS_FEATURE[];
+extern const StaticQName QN_FEATURE_FEATURE;
// JEP 0004
-extern const std::string NS_XDATA;
-extern const QName QN_XDATA_X;
-extern const QName QN_XDATA_INSTRUCTIONS;
-extern const QName QN_XDATA_TITLE;
-extern const QName QN_XDATA_FIELD;
-extern const QName QN_XDATA_REPORTED;
-extern const QName QN_XDATA_ITEM;
-extern const QName QN_XDATA_DESC;
-extern const QName QN_XDATA_REQUIRED;
-extern const QName QN_XDATA_VALUE;
-extern const QName QN_XDATA_OPTION;
+extern const char NS_XDATA[];
+extern const StaticQName QN_XDATA_X;
+extern const StaticQName QN_XDATA_INSTRUCTIONS;
+extern const StaticQName QN_XDATA_TITLE;
+extern const StaticQName QN_XDATA_FIELD;
+extern const StaticQName QN_XDATA_REPORTED;
+extern const StaticQName QN_XDATA_ITEM;
+extern const StaticQName QN_XDATA_DESC;
+extern const StaticQName QN_XDATA_REQUIRED;
+extern const StaticQName QN_XDATA_VALUE;
+extern const StaticQName QN_XDATA_OPTION;
// JEP 0045
-extern const std::string NS_MUC;
-extern const QName QN_MUC_X;
-extern const QName QN_MUC_ITEM;
-extern const QName QN_MUC_AFFILIATION;
-extern const QName QN_MUC_ROLE;
-extern const std::string STR_AFFILIATION_NONE;
-extern const std::string STR_ROLE_PARTICIPANT;
+extern const char NS_MUC[];
+extern const StaticQName QN_MUC_X;
+extern const StaticQName QN_MUC_ITEM;
+extern const StaticQName QN_MUC_AFFILIATION;
+extern const StaticQName QN_MUC_ROLE;
+extern const char STR_AFFILIATION_NONE[];
+extern const char STR_ROLE_PARTICIPANT[];
-extern const std::string NS_MUC_OWNER;
-extern const QName QN_MUC_OWNER_QUERY;
+extern const char NS_MUC_OWNER[];
+extern const StaticQName QN_MUC_OWNER_QUERY;
-extern const std::string NS_MUC_USER;
-extern const QName QN_MUC_USER_CONTINUE;
-extern const QName QN_MUC_USER_X;
-extern const QName QN_MUC_USER_ITEM;
-extern const QName QN_MUC_USER_STATUS;
-
+extern const char NS_MUC_USER[];
+extern const StaticQName QN_MUC_USER_CONTINUE;
+extern const StaticQName QN_MUC_USER_X;
+extern const StaticQName QN_MUC_USER_ITEM;
+extern const StaticQName QN_MUC_USER_STATUS;
// JEP 0055 - Jabber Search
-extern const std::string NS_SEARCH;
-extern const QName QN_SEARCH_QUERY;
-extern const QName QN_SEARCH_ITEM;
-extern const QName QN_SEARCH_ROOM_NAME;
-extern const QName QN_SEARCH_ROOM_JID;
-extern const QName QN_SEARCH_ROOM_DOMAIN;
-
+extern const char NS_SEARCH[];
+extern const StaticQName QN_SEARCH_QUERY;
+extern const StaticQName QN_SEARCH_ITEM;
+extern const StaticQName QN_SEARCH_ROOM_NAME;
+extern const StaticQName QN_SEARCH_ROOM_JID;
+extern const StaticQName QN_SEARCH_ROOM_DOMAIN;
// JEP 0115
-extern const std::string NS_CAPS;
-extern const QName QN_CAPS_C;
-extern const QName QN_VER;
-extern const QName QN_EXT;
+extern const char NS_CAPS[];
+extern const StaticQName QN_CAPS_C;
+extern const StaticQName QN_VER;
+extern const StaticQName QN_EXT;
// Avatar - JEP 0153
-extern const std::string kNSVCard;
-extern const QName kQnVCardX;
-extern const QName kQnVCardPhoto;
+extern const char kNSVCard[];
+extern const StaticQName kQnVCardX;
+extern const StaticQName kQnVCardPhoto;
// JEP 0172 User Nickname
-extern const std::string NS_NICKNAME;
-extern const QName QN_NICKNAME;
-
+extern const char NS_NICKNAME[];
+extern const StaticQName QN_NICKNAME;
// JEP 0085 chat state
-extern const std::string NS_CHATSTATE;
-extern const QName QN_CS_ACTIVE;
-extern const QName QN_CS_COMPOSING;
-extern const QName QN_CS_PAUSED;
-extern const QName QN_CS_INACTIVE;
-extern const QName QN_CS_GONE;
+extern const char NS_CHATSTATE[];
+extern const StaticQName QN_CS_ACTIVE;
+extern const StaticQName QN_CS_COMPOSING;
+extern const StaticQName QN_CS_PAUSED;
+extern const StaticQName QN_CS_INACTIVE;
+extern const StaticQName QN_CS_GONE;
// JEP 0091 Delayed Delivery
-extern const std::string kNSDelay;
-extern const QName kQnDelayX;
-extern const QName kQnStamp;
+extern const char kNSDelay[];
+extern const StaticQName kQnDelayX;
+extern const StaticQName kQnStamp;
// Google time stamping (higher resolution)
-extern const std::string kNSTimestamp;
-extern const QName kQnTime;
-extern const QName kQnMilliseconds;
+extern const char kNSTimestamp[];
+extern const StaticQName kQnTime;
+extern const StaticQName kQnMilliseconds;
+extern const char NS_JINGLE_INFO[];
+extern const StaticQName QN_JINGLE_INFO_QUERY;
+extern const StaticQName QN_JINGLE_INFO_STUN;
+extern const StaticQName QN_JINGLE_INFO_RELAY;
+extern const StaticQName QN_JINGLE_INFO_SERVER;
+extern const StaticQName QN_JINGLE_INFO_TOKEN;
+extern const StaticQName QN_JINGLE_INFO_HOST;
+extern const StaticQName QN_JINGLE_INFO_TCP;
+extern const StaticQName QN_JINGLE_INFO_UDP;
+extern const StaticQName QN_JINGLE_INFO_TCPSSL;
-extern const std::string NS_JINGLE_INFO;
-extern const QName QN_JINGLE_INFO_QUERY;
-extern const QName QN_JINGLE_INFO_STUN;
-extern const QName QN_JINGLE_INFO_RELAY;
-extern const QName QN_JINGLE_INFO_SERVER;
-extern const QName QN_JINGLE_INFO_TOKEN;
-extern const QName QN_JINGLE_INFO_HOST;
-extern const QName QN_JINGLE_INFO_TCP;
-extern const QName QN_JINGLE_INFO_UDP;
-extern const QName QN_JINGLE_INFO_TCPSSL;
-
-extern const std::string NS_GOOGLE_CALLPERF_STATS;
-extern const QName QN_CALLPERF_STATS;
-extern const QName QN_CALLPERF_SESSIONID;
-extern const QName QN_CALLPERF_LOCALUSER;
-extern const QName QN_CALLPERF_REMOTEUSER;
-extern const QName QN_CALLPERF_STARTTIME;
-extern const QName QN_CALLPERF_CALL_LENGTH;
-extern const QName QN_CALLPERF_CALL_ACCEPTED;
-extern const QName QN_CALLPERF_CALL_ERROR_CODE;
-extern const QName QN_CALLPERF_TERMINATE_CODE;
-extern const QName QN_CALLPERF_DATAPOINT;
-extern const QName QN_CALLPERF_DATAPOINT_TIME;
-extern const QName QN_CALLPERF_DATAPOINT_FRACTION_LOST;
-extern const QName QN_CALLPERF_DATAPOINT_CUM_LOST;
-extern const QName QN_CALLPERF_DATAPOINT_EXT_MAX;
-extern const QName QN_CALLPERF_DATAPOINT_JITTER;
-extern const QName QN_CALLPERF_DATAPOINT_RTT;
-extern const QName QN_CALLPERF_DATAPOINT_BYTES_R;
-extern const QName QN_CALLPERF_DATAPOINT_PACKETS_R;
-extern const QName QN_CALLPERF_DATAPOINT_BYTES_S;
-extern const QName QN_CALLPERF_DATAPOINT_PACKETS_S;
-extern const QName QN_CALLPERF_DATAPOINT_PROCESS_CPU;
-extern const QName QN_CALLPERF_DATAPOINT_SYSTEM_CPU;
-extern const QName QN_CALLPERF_DATAPOINT_CPUS;
-extern const QName QN_CALLPERF_CONNECTION;
-extern const QName QN_CALLPERF_CONNECTION_LOCAL_ADDRESS;
-extern const QName QN_CALLPERF_CONNECTION_REMOTE_ADDRESS;
-extern const QName QN_CALLPERF_CONNECTION_FLAGS;
-extern const QName QN_CALLPERF_CONNECTION_RTT;
-extern const QName QN_CALLPERF_CONNECTION_TOTAL_BYTES_S;
-extern const QName QN_CALLPERF_CONNECTION_BYTES_SECOND_S;
-extern const QName QN_CALLPERF_CONNECTION_TOTAL_BYTES_R;
-extern const QName QN_CALLPERF_CONNECTION_BYTES_SECOND_R;
-extern const QName QN_CALLPERF_CANDIDATE;
-extern const QName QN_CALLPERF_CANDIDATE_ENDPOINT;
-extern const QName QN_CALLPERF_CANDIDATE_PROTOCOL;
-extern const QName QN_CALLPERF_CANDIDATE_ADDRESS;
-extern const QName QN_CALLPERF_MEDIA;
-extern const QName QN_CALLPERF_MEDIA_DIRECTION;
-extern const QName QN_CALLPERF_MEDIA_SSRC;
-extern const QName QN_CALLPERF_MEDIA_ENERGY;
-extern const QName QN_CALLPERF_MEDIA_FIR;
-extern const QName QN_CALLPERF_MEDIA_NACK;
-extern const QName QN_CALLPERF_MEDIA_FPS;
-extern const QName QN_CALLPERF_MEDIA_FPS_NETWORK;
-extern const QName QN_CALLPERF_MEDIA_FPS_DECODED;
-extern const QName QN_CALLPERF_MEDIA_JITTER_BUFFER_SIZE;
-extern const QName QN_CALLPERF_MEDIA_PREFERRED_JITTER_BUFFER_SIZE;
-extern const QName QN_CALLPERF_MEDIA_TOTAL_PLAYOUT_DELAY;
+extern const char NS_GOOGLE_CALLPERF_STATS[];
+extern const StaticQName QN_CALLPERF_STATS;
+extern const StaticQName QN_CALLPERF_SESSIONID;
+extern const StaticQName QN_CALLPERF_LOCALUSER;
+extern const StaticQName QN_CALLPERF_REMOTEUSER;
+extern const StaticQName QN_CALLPERF_STARTTIME;
+extern const StaticQName QN_CALLPERF_CALL_LENGTH;
+extern const StaticQName QN_CALLPERF_CALL_ACCEPTED;
+extern const StaticQName QN_CALLPERF_CALL_ERROR_CODE;
+extern const StaticQName QN_CALLPERF_TERMINATE_CODE;
+extern const StaticQName QN_CALLPERF_DATAPOINT;
+extern const StaticQName QN_CALLPERF_DATAPOINT_TIME;
+extern const StaticQName QN_CALLPERF_DATAPOINT_FRACTION_LOST;
+extern const StaticQName QN_CALLPERF_DATAPOINT_CUM_LOST;
+extern const StaticQName QN_CALLPERF_DATAPOINT_EXT_MAX;
+extern const StaticQName QN_CALLPERF_DATAPOINT_JITTER;
+extern const StaticQName QN_CALLPERF_DATAPOINT_RTT;
+extern const StaticQName QN_CALLPERF_DATAPOINT_BYTES_R;
+extern const StaticQName QN_CALLPERF_DATAPOINT_PACKETS_R;
+extern const StaticQName QN_CALLPERF_DATAPOINT_BYTES_S;
+extern const StaticQName QN_CALLPERF_DATAPOINT_PACKETS_S;
+extern const StaticQName QN_CALLPERF_DATAPOINT_PROCESS_CPU;
+extern const StaticQName QN_CALLPERF_DATAPOINT_SYSTEM_CPU;
+extern const StaticQName QN_CALLPERF_DATAPOINT_CPUS;
+extern const StaticQName QN_CALLPERF_CONNECTION;
+extern const StaticQName QN_CALLPERF_CONNECTION_LOCAL_ADDRESS;
+extern const StaticQName QN_CALLPERF_CONNECTION_REMOTE_ADDRESS;
+extern const StaticQName QN_CALLPERF_CONNECTION_FLAGS;
+extern const StaticQName QN_CALLPERF_CONNECTION_RTT;
+extern const StaticQName QN_CALLPERF_CONNECTION_TOTAL_BYTES_S;
+extern const StaticQName QN_CALLPERF_CONNECTION_BYTES_SECOND_S;
+extern const StaticQName QN_CALLPERF_CONNECTION_TOTAL_BYTES_R;
+extern const StaticQName QN_CALLPERF_CONNECTION_BYTES_SECOND_R;
+extern const StaticQName QN_CALLPERF_CANDIDATE;
+extern const StaticQName QN_CALLPERF_CANDIDATE_ENDPOINT;
+extern const StaticQName QN_CALLPERF_CANDIDATE_PROTOCOL;
+extern const StaticQName QN_CALLPERF_CANDIDATE_ADDRESS;
+extern const StaticQName QN_CALLPERF_MEDIA;
+extern const StaticQName QN_CALLPERF_MEDIA_DIRECTION;
+extern const StaticQName QN_CALLPERF_MEDIA_SSRC;
+extern const StaticQName QN_CALLPERF_MEDIA_ENERGY;
+extern const StaticQName QN_CALLPERF_MEDIA_FIR;
+extern const StaticQName QN_CALLPERF_MEDIA_NACK;
+extern const StaticQName QN_CALLPERF_MEDIA_FPS;
+extern const StaticQName QN_CALLPERF_MEDIA_FPS_NETWORK;
+extern const StaticQName QN_CALLPERF_MEDIA_FPS_DECODED;
+extern const StaticQName QN_CALLPERF_MEDIA_JITTER_BUFFER_SIZE;
+extern const StaticQName QN_CALLPERF_MEDIA_PREFERRED_JITTER_BUFFER_SIZE;
+extern const StaticQName QN_CALLPERF_MEDIA_TOTAL_PLAYOUT_DELAY;
// Muc invites.
-extern const QName QN_MUC_USER_INVITE;
+extern const StaticQName QN_MUC_USER_INVITE;
// Multiway audio/video.
-extern const std::string NS_GOOGLE_MUC_USER;
-extern const QName QN_GOOGLE_MUC_USER_AVAILABLE_MEDIA;
-extern const QName QN_GOOGLE_MUC_USER_ENTRY;
-extern const QName QN_GOOGLE_MUC_USER_MEDIA;
-extern const QName QN_GOOGLE_MUC_USER_TYPE;
-extern const QName QN_GOOGLE_MUC_USER_SRC_ID;
-extern const QName QN_GOOGLE_MUC_USER_STATUS;
-extern const QName QN_LABEL;
+extern const char NS_GOOGLE_MUC_USER[];
+extern const StaticQName QN_GOOGLE_MUC_USER_AVAILABLE_MEDIA;
+extern const StaticQName QN_GOOGLE_MUC_USER_ENTRY;
+extern const StaticQName QN_GOOGLE_MUC_USER_MEDIA;
+extern const StaticQName QN_GOOGLE_MUC_USER_TYPE;
+extern const StaticQName QN_GOOGLE_MUC_USER_SRC_ID;
+extern const StaticQName QN_GOOGLE_MUC_USER_STATUS;
+extern const StaticQName QN_LABEL;
-extern const std::string NS_GOOGLE_MUC_MEDIA;
-extern const QName QN_GOOGLE_MUC_AUDIO_MUTE;
-extern const QName QN_GOOGLE_MUC_VIDEO_MUTE;
-extern const QName QN_GOOGLE_MUC_RECORDING;
-extern const QName QN_STATE_ATTR;
+extern const char NS_GOOGLE_MUC_MEDIA[];
+extern const StaticQName QN_GOOGLE_MUC_AUDIO_MUTE;
+extern const StaticQName QN_GOOGLE_MUC_VIDEO_MUTE;
+extern const StaticQName QN_GOOGLE_MUC_RECORDING;
+extern const StaticQName QN_GOOGLE_MUC_MEDIA_BLOCK;
+extern const StaticQName QN_STATE_ATTR;
} // namespace buzz
diff --git a/talk/xmpp/fakexmppclient.h b/talk/xmpp/fakexmppclient.h
new file mode 100644
index 0000000..83b8e82
--- /dev/null
+++ b/talk/xmpp/fakexmppclient.h
@@ -0,0 +1,123 @@
+/*
+ * 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.
+ */
+
+// A fake XmppClient for use in unit tests.
+
+#ifndef TALK_XMPP_FAKEXMPPCLIENT_H_
+#define TALK_XMPP_FAKEXMPPCLIENT_H_
+
+#include <string>
+#include <vector>
+
+#include "talk/xmpp/xmpptask.h"
+
+namespace buzz {
+
+class XmlElement;
+
+class FakeXmppClient : public XmppTaskParentInterface,
+ public XmppClientInterface {
+ public:
+ explicit FakeXmppClient(talk_base::TaskParent* parent)
+ : XmppTaskParentInterface(parent) {
+ }
+
+ // As XmppTaskParentInterface
+ virtual XmppClientInterface* GetClient() {
+ return this;
+ }
+
+ virtual int ProcessStart() {
+ return STATE_RESPONSE;
+ }
+
+ // As XmppClientInterface
+ virtual XmppEngine::State GetState() const {
+ return XmppEngine::STATE_OPEN;
+ }
+
+ virtual const Jid& jid() const {
+ return jid_;
+ }
+
+ virtual std::string NextId() {
+ // Implement if needed for tests.
+ return "0";
+ }
+
+ virtual XmppReturnStatus SendStanza(const XmlElement* stanza) {
+ sent_stanzas_.push_back(stanza);
+ return XMPP_RETURN_OK;
+ }
+
+ const std::vector<const XmlElement*>& sent_stanzas() {
+ return sent_stanzas_;
+ }
+
+ virtual XmppReturnStatus SendStanzaError(
+ const XmlElement * pelOriginal,
+ XmppStanzaError code,
+ const std::string & text) {
+ // Implement if needed for tests.
+ return XMPP_RETURN_OK;
+ }
+
+ virtual void AddXmppTask(XmppTask* task,
+ XmppEngine::HandlerLevel level) {
+ tasks_.push_back(task);
+ }
+
+ virtual void RemoveXmppTask(XmppTask* task) {
+ std::remove(tasks_.begin(), tasks_.end(), task);
+ }
+
+ // As FakeXmppClient
+ void set_jid(const Jid& jid) {
+ jid_ = jid;
+ }
+
+ // Takes ownership of stanza.
+ void HandleStanza(XmlElement* stanza) {
+ for (std::vector<XmppTask*>::iterator task = tasks_.begin();
+ task != tasks_.end(); ++task) {
+ if ((*task)->HandleStanza(stanza)) {
+ delete stanza;
+ return;
+ }
+ }
+ delete stanza;
+ }
+
+ private:
+ Jid jid_;
+ std::vector<XmppTask*> tasks_;
+ std::vector<const XmlElement*> sent_stanzas_;
+};
+
+} // namespace buzz
+
+#endif // TALK_XMPP_FAKEXMPPCLIENT_H_
diff --git a/talk/xmpp/hangoutpubsubclient.cc b/talk/xmpp/hangoutpubsubclient.cc
index ea5534d..8db2d45 100644
--- a/talk/xmpp/hangoutpubsubclient.cc
+++ b/talk/xmpp/hangoutpubsubclient.cc
@@ -40,8 +40,18 @@
namespace buzz {
namespace {
-const std::string kPresenting = "s";
-const std::string kNotPresenting = "o";
+const char kPresenting[] = "s";
+const char kNotPresenting[] = "o";
+const char kEmpty[] = "";
+
+const std::string GetPublisherNickFromPubSubItem(const XmlElement* item_elem) {
+ if (item_elem == NULL) {
+ return "";
+ }
+
+ return Jid(item_elem->Attr(QN_ATTR_PUBLISHER)).resource();
+}
+
} // namespace
@@ -49,10 +59,39 @@
template <typename C>
class PubSubStateSerializer {
public:
+ virtual ~PubSubStateSerializer() {}
virtual XmlElement* Write(const QName& state_name, const C& state) = 0;
virtual C Parse(const XmlElement* state_elem) = 0;
};
+// Knows how to create "keys" for states, which determines their
+// uniqueness. Most states are per-nick, but block is
+// per-blocker-and-blockee. This is independent of itemid, especially
+// in the case of presenter state.
+class PubSubStateKeySerializer {
+ public:
+ virtual ~PubSubStateKeySerializer() {}
+ virtual std::string GetKey(const std::string& publisher_nick,
+ const std::string& published_nick) = 0;
+};
+
+class PublishedNickKeySerializer : public PubSubStateKeySerializer {
+ public:
+ virtual std::string GetKey(const std::string& publisher_nick,
+ const std::string& published_nick) {
+ return published_nick;
+ }
+};
+
+class PublisherAndPublishedNicksKeySerializer
+ : public PubSubStateKeySerializer {
+ public:
+ virtual std::string GetKey(const std::string& publisher_nick,
+ const std::string& published_nick) {
+ return publisher_nick + ":" + published_nick;
+ }
+};
+
// A simple serialiazer where presence of item => true, lack of item
// => false.
class BoolStateSerializer : public PubSubStateSerializer<bool> {
@@ -77,15 +116,19 @@
template <typename C>
class PubSubStateClient : public sigslot::has_slots<> {
public:
- // Gets ownership of the serializer, but not the client.
- PubSubStateClient(PubSubClient* client,
+ // Gets ownership of the serializers, but not the client.
+ PubSubStateClient(const std::string& publisher_nick,
+ PubSubClient* client,
const QName& state_name,
C default_state,
- PubSubStateSerializer<C>* serializer)
- : client_(client),
+ PubSubStateKeySerializer* key_serializer,
+ PubSubStateSerializer<C>* state_serializer)
+ : publisher_nick_(publisher_nick),
+ client_(client),
state_name_(state_name),
default_state_(default_state) {
- serializer_.reset(serializer);
+ key_serializer_.reset(key_serializer);
+ state_serializer_.reset(state_serializer);
client_->SignalItems.connect(
this, &PubSubStateClient<C>::OnItems);
client_->SignalPublishResult.connect(
@@ -100,16 +143,16 @@
virtual ~PubSubStateClient() {}
- virtual void Publish(const std::string& key, const C& state,
+ virtual void Publish(const std::string& published_nick,
+ const C& state,
std::string* task_id_out) {
- const std::string& nick = key;
-
- std::string itemid = state_name_.LocalPart() + ":" + nick;
+ std::string key = key_serializer_->GetKey(publisher_nick_, published_nick);
+ std::string itemid = state_name_.LocalPart() + ":" + key;
if (StatesEqual(state, default_state_)) {
client_->RetractItem(itemid, task_id_out);
} else {
- XmlElement* state_elem = serializer_->Write(state_name_, state);
- state_elem->AddAttr(QN_NICK, nick);
+ XmlElement* state_elem = state_serializer_->Write(state_name_, state);
+ state_elem->AddAttr(QN_NICK, published_nick);
client_->PublishItem(itemid, state_elem, task_id_out);
}
};
@@ -124,17 +167,18 @@
const XmlElement*> SignalPublishError;
protected:
- // return false if retracted item (no state given)
- virtual bool ParseState(const PubSubItem& item,
- std::string* key_out,
- bool* state_out) {
+ // return false if retracted item (no info or state given)
+ virtual bool ParseStateItem(const PubSubItem& item,
+ StateItemInfo* info_out,
+ bool* state_out) {
const XmlElement* state_elem = item.elem->FirstNamed(state_name_);
if (state_elem == NULL) {
return false;
}
- *key_out = state_elem->Attr(QN_NICK);
- *state_out = serializer_->Parse(state_elem);
+ info_out->publisher_nick = GetPublisherNickFromPubSubItem(item.elem);
+ info_out->published_nick = state_elem->Attr(QN_NICK);
+ *state_out = state_serializer_->Parse(state_elem);
return true;
};
@@ -155,27 +199,30 @@
void OnItem(const PubSubItem& item) {
const std::string& itemid = item.itemid;
-
- std::string key;
+ StateItemInfo info;
C new_state;
- bool retracted = !ParseState(item, &key, &new_state);
+
+ bool retracted = !ParseStateItem(item, &info, &new_state);
if (retracted) {
- bool known_itemid = (key_by_itemid_.find(itemid) != key_by_itemid_.end());
+ bool known_itemid =
+ (info_by_itemid_.find(itemid) != info_by_itemid_.end());
if (!known_itemid) {
// Nothing to retract, and nothing to publish.
// Probably a different state type.
return;
} else {
- key = key_by_itemid_[itemid];
- key_by_itemid_.erase(itemid);
+ info = info_by_itemid_[itemid];
+ info_by_itemid_.erase(itemid);
new_state = default_state_;
}
} else {
- // TODO: Assert parsed key matches the known key when
- // not retracted. It shouldn't change!
- key_by_itemid_[itemid] = key;
+ // TODO: Assert new key matches the known key. It
+ // shouldn't change!
+ info_by_itemid_[itemid] = info;
}
+ std::string key = key_serializer_->GetKey(
+ info.publisher_nick, info.published_nick);
bool has_old_state = (state_by_key_.find(key) != state_by_key_.end());
const C& old_state = has_old_state ? state_by_key_[key] : default_state_;
if ((retracted && !has_old_state) || StatesEqual(new_state, old_state)) {
@@ -191,11 +238,10 @@
}
PubSubStateChange<C> change;
- change.key = key;
+ change.publisher_nick = info.publisher_nick;
+ change.published_nick = info.published_nick;
change.old_state = old_state;
change.new_state = new_state;
- change.publisher_nick =
- Jid(item.elem->Attr(QN_ATTR_PUBLISHER)).resource();
SignalStateChange(change);
}
@@ -231,33 +277,36 @@
SignalPublishError(task_id, item, stanza);
}
+ std::string publisher_nick_;
PubSubClient* client_;
- const QName& state_name_;
+ const QName state_name_;
C default_state_;
- talk_base::scoped_ptr<PubSubStateSerializer<C> > serializer_;
+ talk_base::scoped_ptr<PubSubStateKeySerializer> key_serializer_;
+ talk_base::scoped_ptr<PubSubStateSerializer<C> > state_serializer_;
// key => state
std::map<std::string, C> state_by_key_;
- // itemid => key
- std::map<std::string, std::string> key_by_itemid_;
+ // itemid => StateItemInfo
+ std::map<std::string, StateItemInfo> info_by_itemid_;
};
class PresenterStateClient : public PubSubStateClient<bool> {
public:
- PresenterStateClient(PubSubClient* client,
+ PresenterStateClient(const std::string& publisher_nick,
+ PubSubClient* client,
const QName& state_name,
- bool default_state,
- PubSubStateSerializer<bool>* serializer = NULL)
- : PubSubStateClient<bool>(client, state_name, default_state, serializer) {
+ bool default_state)
+ : PubSubStateClient<bool>(
+ publisher_nick, client, state_name, default_state,
+ new PublishedNickKeySerializer(), NULL) {
}
- virtual void Publish(const std::string& key, const bool& state,
+ virtual void Publish(const std::string& published_nick,
+ const bool& state,
std::string* task_id_out) {
- const std::string& nick = key;
-
XmlElement* presenter_elem = new XmlElement(QN_PRESENTER_PRESENTER, true);
// There's a dummy value, not used, but required.
presenter_elem->AddAttr(QN_JID, "dummy@value.net");
- presenter_elem->AddAttr(QN_NICK, nick);
+ presenter_elem->AddAttr(QN_NICK, published_nick);
XmlElement* presentation_item_elem =
new XmlElement(QN_PRESENTER_PRESENTATION_ITEM, false);
@@ -267,7 +316,7 @@
// The Presenter state is kind of dumb in that it doesn't use
// retracts. It relies on setting the "type" to a special value.
- std::string itemid = nick;
+ std::string itemid = published_nick;
std::vector<XmlElement*> children;
children.push_back(presenter_elem);
children.push_back(presentation_item_elem);
@@ -275,9 +324,9 @@
}
protected:
- virtual bool ParseState(const PubSubItem& item,
- std::string* key_out,
- bool* state_out) {
+ virtual bool ParseStateItem(const PubSubItem& item,
+ StateItemInfo* info_out,
+ bool* state_out) {
const XmlElement* presenter_elem =
item.elem->FirstNamed(QN_PRESENTER_PRESENTER);
const XmlElement* presentation_item_elem =
@@ -286,11 +335,16 @@
return false;
}
- *key_out = presenter_elem->Attr(QN_NICK);
+ info_out->publisher_nick = GetPublisherNickFromPubSubItem(item.elem);
+ info_out->published_nick = presenter_elem->Attr(QN_NICK);
*state_out = (presentation_item_elem->Attr(
QN_PRESENTER_PRESENTATION_TYPE) != kNotPresenting);
return true;
}
+
+ virtual bool StatesEqual(bool state1, bool state2) {
+ return false; // Make every item trigger an event, even if state doesn't change.
+ }
};
HangoutPubSubClient::HangoutPubSubClient(XmppTaskParentInterface* parent,
@@ -307,7 +361,7 @@
this, &HangoutPubSubClient::OnMediaRequestError);
presenter_state_client_.reset(new PresenterStateClient(
- presenter_client_.get(), QN_PRESENTER_PRESENTER, false));
+ nick_, presenter_client_.get(), QN_PRESENTER_PRESENTER, false));
presenter_state_client_->SignalStateChange.connect(
this, &HangoutPubSubClient::OnPresenterStateChange);
presenter_state_client_->SignalPublishResult.connect(
@@ -316,8 +370,8 @@
this, &HangoutPubSubClient::OnPresenterPublishError);
audio_mute_state_client_.reset(new PubSubStateClient<bool>(
- media_client_.get(), QN_GOOGLE_MUC_AUDIO_MUTE, false,
- new BoolStateSerializer()));
+ nick_, media_client_.get(), QN_GOOGLE_MUC_AUDIO_MUTE, false,
+ new PublishedNickKeySerializer(), new BoolStateSerializer()));
// Can't just repeat because we need to watch for remote mutes.
audio_mute_state_client_->SignalStateChange.connect(
this, &HangoutPubSubClient::OnAudioMuteStateChange);
@@ -327,14 +381,25 @@
this, &HangoutPubSubClient::OnAudioMutePublishError);
recording_state_client_.reset(new PubSubStateClient<bool>(
- media_client_.get(), QN_GOOGLE_MUC_RECORDING, false,
- new BoolStateSerializer()));
+ nick_, media_client_.get(), QN_GOOGLE_MUC_RECORDING, false,
+ new PublishedNickKeySerializer(), new BoolStateSerializer()));
recording_state_client_->SignalStateChange.connect(
this, &HangoutPubSubClient::OnRecordingStateChange);
recording_state_client_->SignalPublishResult.connect(
this, &HangoutPubSubClient::OnRecordingPublishResult);
recording_state_client_->SignalPublishError.connect(
this, &HangoutPubSubClient::OnRecordingPublishError);
+
+ media_block_state_client_.reset(new PubSubStateClient<bool>(
+ nick_, media_client_.get(), QN_GOOGLE_MUC_MEDIA_BLOCK, false,
+ new PublisherAndPublishedNicksKeySerializer(),
+ new BoolStateSerializer()));
+ media_block_state_client_->SignalStateChange.connect(
+ this, &HangoutPubSubClient::OnMediaBlockStateChange);
+ media_block_state_client_->SignalPublishResult.connect(
+ this, &HangoutPubSubClient::OnMediaBlockPublishResult);
+ media_block_state_client_->SignalPublishError.connect(
+ this, &HangoutPubSubClient::OnMediaBlockPublishError);
}
HangoutPubSubClient::~HangoutPubSubClient() {
@@ -376,10 +441,17 @@
audio_mute_state_client_->Publish(mutee_nick, true, task_id_out);
}
+// Block media is accomplished by setting another client's block
+// state, kind of like remote mute.
+void HangoutPubSubClient::BlockMedia(
+ const std::string& blockee_nick, std::string* task_id_out) {
+ media_block_state_client_->Publish(blockee_nick, true, task_id_out);
+}
+
void HangoutPubSubClient::OnPresenterStateChange(
const PubSubStateChange<bool>& change) {
- const std::string& nick = change.key;
- SignalPresenterStateChange(nick, change.old_state, change.new_state);
+ SignalPresenterStateChange(
+ change.published_nick, change.old_state, change.new_state);
}
void HangoutPubSubClient::OnPresenterPublishResult(
@@ -398,23 +470,21 @@
// ourselves. Note that we never remote un-mute, though.
void HangoutPubSubClient::OnAudioMuteStateChange(
const PubSubStateChange<bool>& change) {
- const std::string& nick = change.key;
-
bool was_muted = change.old_state;
bool is_muted = change.new_state;
- bool remote_action =
- !change.publisher_nick.empty() && (change.publisher_nick != nick);
+ bool remote_action = (!change.publisher_nick.empty() &&
+ (change.publisher_nick != change.published_nick));
if (is_muted && remote_action) {
- const std::string& mutee_nick = nick;
+ const std::string& mutee_nick = change.published_nick;
const std::string& muter_nick = change.publisher_nick;
bool should_mute_locally = (mutee_nick == nick_);
SignalRemoteMute(mutee_nick, muter_nick, should_mute_locally);
} else {
- SignalAudioMuteStateChange(nick, was_muted, is_muted);
+ SignalAudioMuteStateChange(change.published_nick, was_muted, is_muted);
}
}
-const std::string& GetAudioMuteNickFromItem(const XmlElement* item) {
+const std::string GetAudioMuteNickFromItem(const XmlElement* item) {
if (item != NULL) {
const XmlElement* audio_mute_state =
item->FirstNamed(QN_GOOGLE_MUC_AUDIO_MUTE);
@@ -422,7 +492,18 @@
return audio_mute_state->Attr(QN_NICK);
}
}
- return STR_EMPTY;
+ return std::string();
+}
+
+const std::string GetBlockeeNickFromItem(const XmlElement* item) {
+ if (item != NULL) {
+ const XmlElement* media_block_state =
+ item->FirstNamed(QN_GOOGLE_MUC_MEDIA_BLOCK);
+ if (media_block_state != NULL) {
+ return media_block_state->Attr(QN_NICK);
+ }
+ }
+ return std::string();
}
void HangoutPubSubClient::OnAudioMutePublishResult(
@@ -448,8 +529,8 @@
void HangoutPubSubClient::OnRecordingStateChange(
const PubSubStateChange<bool>& change) {
- const std::string& nick = change.key;
- SignalRecordingStateChange(nick, change.old_state, change.new_state);
+ SignalRecordingStateChange(
+ change.published_nick, change.old_state, change.new_state);
}
void HangoutPubSubClient::OnRecordingPublishResult(
@@ -463,4 +544,32 @@
SignalPublishRecordingError(task_id, stanza);
}
+void HangoutPubSubClient::OnMediaBlockStateChange(
+ const PubSubStateChange<bool>& change) {
+ const std::string& blockee_nick = change.published_nick;
+ const std::string& blocker_nick = change.publisher_nick;
+
+ bool was_blockee = change.old_state;
+ bool is_blockee = change.new_state;
+ if (!was_blockee && is_blockee) {
+ SignalMediaBlock(blockee_nick, blocker_nick);
+ }
+ // TODO: Should we bother signaling unblock? Currently
+ // it isn't allowed, but it might happen when a participant leaves
+ // the room and the item is retracted.
+}
+
+void HangoutPubSubClient::OnMediaBlockPublishResult(
+ const std::string& task_id, const XmlElement* item) {
+ const std::string& blockee_nick = GetBlockeeNickFromItem(item);
+ SignalMediaBlockResult(task_id, blockee_nick);
+}
+
+void HangoutPubSubClient::OnMediaBlockPublishError(
+ const std::string& task_id, const XmlElement* item,
+ const XmlElement* stanza) {
+ const std::string& blockee_nick = GetBlockeeNickFromItem(item);
+ SignalMediaBlockError(task_id, blockee_nick, stanza);
+}
+
} // namespace buzz
diff --git a/talk/xmpp/hangoutpubsubclient.h b/talk/xmpp/hangoutpubsubclient.h
index e740738..ae9dc57 100644
--- a/talk/xmpp/hangoutpubsubclient.h
+++ b/talk/xmpp/hangoutpubsubclient.h
@@ -47,14 +47,26 @@
class XmlElement;
class XmppTaskParentInterface;
+// To handle retracts correctly, we need to remember certain details
+// about an item. We could just cache the entire XML element, but
+// that would take more memory and require re-parsing.
+struct StateItemInfo {
+ std::string published_nick;
+ std::string publisher_nick;
+};
+
// Represents a PubSub state change. Usually, the key is the nick,
-// but not always. It's a per-state-type thing.
+// but not always. It's a per-state-type thing. Currently documented
+// at https://docs.google.com/a/google.com/document/d/
+// 1QyHu_ufyVdf0VICdfc_DtJbrOdrdIUm4eM73RZqnivI/edit?hl=en_US
template <typename C>
struct PubSubStateChange {
- std::string key;
+ // The nick of the user changing the state.
+ std::string publisher_nick;
+ // The nick of the user whose state is changing.
+ std::string published_nick;
C old_state;
C new_state;
- std::string publisher_nick;
};
template <typename C> class PubSubStateClient;
@@ -80,10 +92,12 @@
sigslot::signal3<const std::string&, bool, bool> SignalAudioMuteStateChange;
// Signal (nick, was_recording, is_recording)
sigslot::signal3<const std::string&, bool, bool> SignalRecordingStateChange;
- // Signal (muter_nick, mutee_nick, should_mute_locally)
+ // Signal (mutee_nick, muter_nick, should_mute_locally)
sigslot::signal3<const std::string&,
const std::string&,
bool> SignalRemoteMute;
+ // Signal (blockee_nick, blocker_nick)
+ sigslot::signal2<const std::string&, const std::string&> SignalMediaBlock;
// Signal (node, error stanza)
sigslot::signal2<const std::string&, const XmlElement*> SignalRequestError;
@@ -98,6 +112,8 @@
bool recording, std::string* task_id_out = NULL);
void RemoteMute(
const std::string& mutee_nick, std::string* task_id_out = NULL);
+ void BlockMedia(
+ const std::string& blockee_nick, std::string* task_id_out = NULL);
// Signal task_id
sigslot::signal1<const std::string&> SignalPublishAudioMuteResult;
@@ -106,6 +122,9 @@
// Signal (task_id, mutee_nick)
sigslot::signal2<const std::string&,
const std::string&> SignalRemoteMuteResult;
+ // Signal (task_id, blockee_nick)
+ sigslot::signal2<const std::string&,
+ const std::string&> SignalMediaBlockResult;
// Signal (task_id, error stanza)
sigslot::signal2<const std::string&,
@@ -114,10 +133,17 @@
const XmlElement*> SignalPublishPresenterError;
sigslot::signal2<const std::string&,
const XmlElement*> SignalPublishRecordingError;
+ sigslot::signal2<const std::string&,
+ const XmlElement*> SignalPublishMediaBlockError;
// Signal (task_id, mutee_nick, error stanza)
sigslot::signal3<const std::string&,
const std::string&,
const XmlElement*> SignalRemoteMuteError;
+ // Signal (task_id, blockee_nick, error stanza)
+ sigslot::signal3<const std::string&,
+ const std::string&,
+ const XmlElement*> SignalMediaBlockError;
+
private:
void OnPresenterRequestError(PubSubClient* client,
@@ -143,6 +169,12 @@
void OnRecordingPublishError(const std::string& task_id,
const XmlElement* item,
const XmlElement* stanza);
+ void OnMediaBlockStateChange(const PubSubStateChange<bool>& change);
+ void OnMediaBlockPublishResult(const std::string& task_id,
+ const XmlElement* item);
+ void OnMediaBlockPublishError(const std::string& task_id,
+ const XmlElement* item,
+ const XmlElement* stanza);
Jid mucjid_;
std::string nick_;
talk_base::scoped_ptr<PubSubClient> media_client_;
@@ -150,6 +182,7 @@
talk_base::scoped_ptr<PubSubStateClient<bool> > presenter_state_client_;
talk_base::scoped_ptr<PubSubStateClient<bool> > audio_mute_state_client_;
talk_base::scoped_ptr<PubSubStateClient<bool> > recording_state_client_;
+ talk_base::scoped_ptr<PubSubStateClient<bool> > media_block_state_client_;
};
} // namespace buzz
diff --git a/talk/xmpp/hangoutpubsubclient_unittest.cc b/talk/xmpp/hangoutpubsubclient_unittest.cc
new file mode 100644
index 0000000..a0c2439
--- /dev/null
+++ b/talk/xmpp/hangoutpubsubclient_unittest.cc
@@ -0,0 +1,625 @@
+// Copyright 2011 Google Inc. All Rights Reserved
+
+
+#include <string>
+
+#include "talk/base/faketaskrunner.h"
+#include "talk/base/gunit.h"
+#include "talk/base/sigslot.h"
+#include "talk/xmllite/qname.h"
+#include "talk/xmllite/xmlelement.h"
+#include "talk/xmpp/constants.h"
+#include "talk/xmpp/jid.h"
+#include "talk/xmpp/fakexmppclient.h"
+#include "talk/xmpp/hangoutpubsubclient.h"
+
+class TestHangoutPubSubListener : public sigslot::has_slots<> {
+ public:
+ TestHangoutPubSubListener() :
+ request_error_count(0),
+ publish_audio_mute_error_count(0),
+ publish_presenter_error_count(0),
+ publish_recording_error_count(0),
+ remote_mute_error_count(0) {
+ }
+
+ void OnPresenterStateChange(
+ const std::string& nick, bool was_presenting, bool is_presenting) {
+ last_presenter_nick = nick;
+ last_was_presenting = was_presenting;
+ last_is_presenting = is_presenting;
+ }
+
+ void OnAudioMuteStateChange(
+ const std::string& nick, bool was_muted, bool is_muted) {
+ last_audio_muted_nick = nick;
+ last_was_audio_muted = was_muted;
+ last_is_audio_muted = is_muted;
+ }
+
+ void OnRecordingStateChange(
+ const std::string& nick, bool was_recording, bool is_recording) {
+ last_recording_nick = nick;
+ last_was_recording = was_recording;
+ last_is_recording = is_recording;
+ }
+
+ void OnRemoteMute(
+ const std::string& mutee_nick,
+ const std::string& muter_nick,
+ bool should_mute_locally) {
+ last_mutee_nick = mutee_nick;
+ last_muter_nick = muter_nick;
+ last_should_mute = should_mute_locally;
+ }
+
+ void OnMediaBlock(
+ const std::string& blockee_nick,
+ const std::string& blocker_nick) {
+ last_blockee_nick = blockee_nick;
+ last_blocker_nick = blocker_nick;
+ }
+
+ void OnRequestError(const std::string& node, const buzz::XmlElement* stanza) {
+ ++request_error_count;
+ request_error_node = node;
+ }
+
+ void OnPublishAudioMuteError(const std::string& task_id,
+ const buzz::XmlElement* stanza) {
+ ++publish_audio_mute_error_count;
+ error_task_id = task_id;
+ }
+
+ void OnPublishPresenterError(const std::string& task_id,
+ const buzz::XmlElement* stanza) {
+ ++publish_presenter_error_count;
+ error_task_id = task_id;
+ }
+
+ void OnPublishRecordingError(const std::string& task_id,
+ const buzz::XmlElement* stanza) {
+ ++publish_recording_error_count;
+ error_task_id = task_id;
+ }
+
+ void OnRemoteMuteResult(const std::string& task_id,
+ const std::string& mutee_nick) {
+ result_task_id = task_id;
+ remote_mute_mutee_nick = mutee_nick;
+ }
+
+ void OnRemoteMuteError(const std::string& task_id,
+ const std::string& mutee_nick,
+ const buzz::XmlElement* stanza) {
+ ++remote_mute_error_count;
+ error_task_id = task_id;
+ remote_mute_mutee_nick = mutee_nick;
+ }
+
+ void OnMediaBlockResult(const std::string& task_id,
+ const std::string& blockee_nick) {
+ result_task_id = task_id;
+ media_blockee_nick = blockee_nick;
+ }
+
+ void OnMediaBlockError(const std::string& task_id,
+ const std::string& blockee_nick,
+ const buzz::XmlElement* stanza) {
+ ++media_block_error_count;
+ error_task_id = task_id;
+ media_blockee_nick = blockee_nick;
+ }
+
+ std::string last_presenter_nick;
+ bool last_is_presenting;
+ bool last_was_presenting;
+ std::string last_audio_muted_nick;
+ bool last_is_audio_muted;
+ bool last_was_audio_muted;
+ std::string last_recording_nick;
+ bool last_is_recording;
+ bool last_was_recording;
+ std::string last_mutee_nick;
+ std::string last_muter_nick;
+ bool last_should_mute;
+ std::string last_blockee_nick;
+ std::string last_blocker_nick;
+
+ int request_error_count;
+ std::string request_error_node;
+ int publish_audio_mute_error_count;
+ int publish_presenter_error_count;
+ int publish_recording_error_count;
+ int remote_mute_error_count;
+ std::string result_task_id;
+ std::string error_task_id;
+ std::string remote_mute_mutee_nick;
+ int media_block_error_count;
+ std::string media_blockee_nick;
+};
+
+class HangoutPubSubClientTest : public testing::Test {
+ public:
+ HangoutPubSubClientTest() :
+ pubsubjid("room@domain.com"),
+ nick("me") {
+
+ runner.reset(new talk_base::FakeTaskRunner());
+ xmpp_client = new buzz::FakeXmppClient(runner.get());
+ client.reset(new buzz::HangoutPubSubClient(xmpp_client, pubsubjid, nick));
+ listener.reset(new TestHangoutPubSubListener());
+ client->SignalPresenterStateChange.connect(
+ listener.get(), &TestHangoutPubSubListener::OnPresenterStateChange);
+ client->SignalAudioMuteStateChange.connect(
+ listener.get(), &TestHangoutPubSubListener::OnAudioMuteStateChange);
+ client->SignalRecordingStateChange.connect(
+ listener.get(), &TestHangoutPubSubListener::OnRecordingStateChange);
+ client->SignalRemoteMute.connect(
+ listener.get(), &TestHangoutPubSubListener::OnRemoteMute);
+ client->SignalMediaBlock.connect(
+ listener.get(), &TestHangoutPubSubListener::OnMediaBlock);
+ client->SignalRequestError.connect(
+ listener.get(), &TestHangoutPubSubListener::OnRequestError);
+ client->SignalPublishAudioMuteError.connect(
+ listener.get(), &TestHangoutPubSubListener::OnPublishAudioMuteError);
+ client->SignalPublishPresenterError.connect(
+ listener.get(), &TestHangoutPubSubListener::OnPublishPresenterError);
+ client->SignalPublishRecordingError.connect(
+ listener.get(), &TestHangoutPubSubListener::OnPublishRecordingError);
+ client->SignalRemoteMuteResult.connect(
+ listener.get(), &TestHangoutPubSubListener::OnRemoteMuteResult);
+ client->SignalRemoteMuteError.connect(
+ listener.get(), &TestHangoutPubSubListener::OnRemoteMuteError);
+ client->SignalMediaBlockResult.connect(
+ listener.get(), &TestHangoutPubSubListener::OnMediaBlockResult);
+ client->SignalMediaBlockError.connect(
+ listener.get(), &TestHangoutPubSubListener::OnMediaBlockError);
+ }
+
+ talk_base::scoped_ptr<talk_base::FakeTaskRunner> runner;
+ // xmpp_client deleted by deleting runner.
+ buzz::FakeXmppClient* xmpp_client;
+ talk_base::scoped_ptr<buzz::HangoutPubSubClient> client;
+ talk_base::scoped_ptr<TestHangoutPubSubListener> listener;
+ buzz::Jid pubsubjid;
+ std::string nick;
+};
+
+TEST_F(HangoutPubSubClientTest, TestRequest) {
+ ASSERT_EQ(0U, xmpp_client->sent_stanzas().size());
+
+ client->RequestAll();
+ std::string expected_presenter_request =
+ "<cli:iq type=\"get\" to=\"room@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<pub:pubsub xmlns:pub=\"http://jabber.org/protocol/pubsub\">"
+ "<pub:items node=\"google:presenter\"/>"
+ "</pub:pubsub>"
+ "</cli:iq>";
+
+ std::string expected_media_request =
+ "<cli:iq type=\"get\" to=\"room@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<pub:pubsub xmlns:pub=\"http://jabber.org/protocol/pubsub\">"
+ "<pub:items node=\"google:muc#media\"/>"
+ "</pub:pubsub>"
+ "</cli:iq>";
+
+ ASSERT_EQ(2U, xmpp_client->sent_stanzas().size());
+ EXPECT_EQ(expected_presenter_request, xmpp_client->sent_stanzas()[0]->Str());
+ EXPECT_EQ(expected_media_request, xmpp_client->sent_stanzas()[1]->Str());
+
+ std::string presenter_response =
+ "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'>"
+ " <pubsub xmlns='http://jabber.org/protocol/pubsub'>"
+ " <items node='google:presenter'>"
+ " <item id='12345'>"
+ " <presenter xmlns='google:presenter' nick='presenting-nick'/>"
+ " <pre:presentation-item xmlns:pre='google:presenter'"
+ " pre:presentation-type='o'/>"
+ " </item>"
+ // Some clients are "bad" in that they'll jam multiple states in
+ // all at once. We have to deal with it.
+ " <item id='12346'>"
+ " <presenter xmlns='google:presenter' nick='presenting-nick'/>"
+ " <pre:presentation-item xmlns:pre='google:presenter'"
+ " pre:presentation-type='s'/>"
+ " </item>"
+ " <item id='12347'>"
+ " <presenter xmlns='google:presenter' nick='presenting-nick2'/>"
+ " <pre:presentation-item xmlns:pre='google:presenter'"
+ " pre:presentation-type='s'/>"
+ " </item>"
+ " </items>"
+ " </pubsub>"
+ "</iq>";
+
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(presenter_response));
+ EXPECT_EQ("presenting-nick2", listener->last_presenter_nick);
+ EXPECT_FALSE(listener->last_was_presenting);
+ EXPECT_TRUE(listener->last_is_presenting);
+
+ std::string media_response =
+ "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'>"
+ " <pubsub xmlns='http://jabber.org/protocol/pubsub'>"
+ " <items node='google:muc#media'>"
+ " <item id='audio-mute:muted-nick'>"
+ " <audio-mute nick='muted-nick' xmlns='google:muc#media'/>"
+ " </item>"
+ " <item id='recording:recording-nick'>"
+ " <recording nick='recording-nick' xmlns='google:muc#media'/>"
+ " </item>"
+ " </items>"
+ " </pubsub>"
+ "</iq>";
+
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(media_response));
+ EXPECT_EQ("muted-nick", listener->last_audio_muted_nick);
+ EXPECT_FALSE(listener->last_was_audio_muted);
+ EXPECT_TRUE(listener->last_is_audio_muted);
+ EXPECT_EQ("recording-nick", listener->last_recording_nick);
+ EXPECT_FALSE(listener->last_was_recording);
+ EXPECT_TRUE(listener->last_is_recording);
+
+ std::string incoming_presenter_resets_message =
+ "<message xmlns='jabber:client' from='room@domain.com'>"
+ " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
+ " <items node='google:presenter'>"
+ " <item id='12348'>"
+ " <presenter xmlns='google:presenter' nick='presenting-nick'/>"
+ " <pre:presentation-item xmlns:pre='google:presenter'"
+ " pre:presentation-type='o'/>"
+ " </item>"
+ " </items>"
+ " </event>"
+ "</message>";
+
+ xmpp_client->HandleStanza(
+ buzz::XmlElement::ForStr(incoming_presenter_resets_message));
+ EXPECT_EQ("presenting-nick", listener->last_presenter_nick);
+ //EXPECT_TRUE(listener->last_was_presenting);
+ EXPECT_FALSE(listener->last_is_presenting);
+
+ std::string incoming_presenter_retracts_message =
+ "<message xmlns='jabber:client' from='room@domain.com'>"
+ " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
+ " <items node='google:presenter'>"
+ " <retract id='12347'/>"
+ " </items>"
+ " </event>"
+ "</message>";
+
+ xmpp_client->HandleStanza(
+ buzz::XmlElement::ForStr(incoming_presenter_retracts_message));
+ EXPECT_EQ("presenting-nick2", listener->last_presenter_nick);
+ EXPECT_TRUE(listener->last_was_presenting);
+ EXPECT_FALSE(listener->last_is_presenting);
+
+ std::string incoming_media_retracts_message =
+ "<message xmlns='jabber:client' from='room@domain.com'>"
+ " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
+ " <items node='google:muc#media'>"
+ " <item id='audio-mute:muted-nick'>"
+ " </item>"
+ " <retract id='recording:recording-nick'/>"
+ " </items>"
+ " </event>"
+ "</message>";
+
+ xmpp_client->HandleStanza(
+ buzz::XmlElement::ForStr(incoming_media_retracts_message));
+ EXPECT_EQ("muted-nick", listener->last_audio_muted_nick);
+ EXPECT_TRUE(listener->last_was_audio_muted);
+ EXPECT_FALSE(listener->last_is_audio_muted);
+ EXPECT_EQ("recording-nick", listener->last_recording_nick);
+ EXPECT_TRUE(listener->last_was_recording);
+ EXPECT_FALSE(listener->last_is_recording);
+
+ std::string incoming_presenter_changes_message =
+ "<message xmlns='jabber:client' from='room@domain.com'>"
+ " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
+ " <items node='google:presenter'>"
+ " <item id='presenting-nick2'>"
+ " <presenter xmlns='google:presenter' nick='presenting-nick2'/>"
+ " <pre:presentation-item xmlns:pre='google:presenter'"
+ " pre:presentation-type='s'/>"
+ " </item>"
+ " </items>"
+ " </event>"
+ "</message>";
+
+ xmpp_client->HandleStanza(
+ buzz::XmlElement::ForStr(incoming_presenter_changes_message));
+ EXPECT_EQ("presenting-nick2", listener->last_presenter_nick);
+ EXPECT_FALSE(listener->last_was_presenting);
+ EXPECT_TRUE(listener->last_is_presenting);
+
+ xmpp_client->HandleStanza(
+ buzz::XmlElement::ForStr(incoming_presenter_changes_message));
+ EXPECT_EQ("presenting-nick2", listener->last_presenter_nick);
+ EXPECT_TRUE(listener->last_was_presenting);
+ EXPECT_TRUE(listener->last_is_presenting);
+
+ std::string incoming_media_changes_message =
+ "<message xmlns='jabber:client' from='room@domain.com'>"
+ " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
+ " <items node='google:muc#media'>"
+ " <item id='audio-mute:muted-nick2'>"
+ " <audio-mute nick='muted-nick2' xmlns='google:muc#media'/>"
+ " </item>"
+ " <item id='recording:recording-nick2'>"
+ " <recording nick='recording-nick2' xmlns='google:muc#media'/>"
+ " </item>"
+ " </items>"
+ " </event>"
+ "</message>";
+
+ xmpp_client->HandleStanza(
+ buzz::XmlElement::ForStr(incoming_media_changes_message));
+ EXPECT_EQ("muted-nick2", listener->last_audio_muted_nick);
+ EXPECT_FALSE(listener->last_was_audio_muted);
+ EXPECT_TRUE(listener->last_is_audio_muted);
+ EXPECT_EQ("recording-nick2", listener->last_recording_nick);
+ EXPECT_FALSE(listener->last_was_recording);
+ EXPECT_TRUE(listener->last_is_recording);
+
+ std::string incoming_remote_mute_message =
+ "<message xmlns='jabber:client' from='room@domain.com'>"
+ " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
+ " <items node='google:muc#media'>"
+ " <item id='audio-mute:mutee' publisher='room@domain.com/muter'>"
+ " <audio-mute nick='mutee' xmlns='google:muc#media'/>"
+ " </item>"
+ " </items>"
+ " </event>"
+ "</message>";
+
+ xmpp_client->HandleStanza(
+ buzz::XmlElement::ForStr(incoming_remote_mute_message));
+ EXPECT_EQ("mutee", listener->last_mutee_nick);
+ EXPECT_EQ("muter", listener->last_muter_nick);
+ EXPECT_FALSE(listener->last_should_mute);
+
+ std::string incoming_remote_mute_me_message =
+ "<message xmlns='jabber:client' from='room@domain.com'>"
+ " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
+ " <items node='google:muc#media'>"
+ " <item id='audio-mute:me' publisher='room@domain.com/muter'>"
+ " <audio-mute nick='me' xmlns='google:muc#media'/>"
+ " </item>"
+ " </items>"
+ " </event>"
+ "</message>";
+
+ xmpp_client->HandleStanza(
+ buzz::XmlElement::ForStr(incoming_remote_mute_me_message));
+ EXPECT_EQ("me", listener->last_mutee_nick);
+ EXPECT_EQ("muter", listener->last_muter_nick);
+ EXPECT_TRUE(listener->last_should_mute);
+
+ std::string incoming_media_block_message =
+ "<message xmlns='jabber:client' from='room@domain.com'>"
+ " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
+ " <items node='google:muc#media'>"
+ " <item id='block:blocker:blockee'"
+ " publisher='room@domain.com/blocker'>"
+ " <block nick='blockee' xmlns='google:muc#media'/>"
+ " </item>"
+ " </items>"
+ " </event>"
+ "</message>";
+
+ xmpp_client->HandleStanza(
+ buzz::XmlElement::ForStr(incoming_media_block_message));
+ EXPECT_EQ("blockee", listener->last_blockee_nick);
+ EXPECT_EQ("blocker", listener->last_blocker_nick);
+}
+
+TEST_F(HangoutPubSubClientTest, TestRequestError) {
+ client->RequestAll();
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'>"
+ " <error type='auth'>"
+ " <forbidden xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>"
+ " </error>"
+ "</iq>";
+
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+ EXPECT_EQ(1, listener->request_error_count);
+ EXPECT_EQ("google:presenter", listener->request_error_node);
+}
+
+TEST_F(HangoutPubSubClientTest, TestPublish) {
+ client->PublishPresenterState(true);
+ std::string expected_presenter_iq =
+ "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
+ "<publish node=\"google:presenter\">"
+ "<item id=\"me\">"
+ "<presenter xmlns=\"google:presenter\""
+ " jid=\"dummy@value.net\" nick=\"me\"/>"
+ "<pre:presentation-item"
+ " pre:presentation-type=\"s\" xmlns:pre=\"google:presenter\"/>"
+ "</item>"
+ "</publish>"
+ "</pubsub>"
+ "</cli:iq>";
+
+ ASSERT_EQ(1U, xmpp_client->sent_stanzas().size());
+ EXPECT_EQ(expected_presenter_iq,
+ xmpp_client->sent_stanzas()[0]->Str());
+
+ client->PublishAudioMuteState(true);
+ std::string expected_audio_mute_iq =
+ "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
+ "<publish node=\"google:muc#media\">"
+ "<item id=\"audio-mute:me\">"
+ "<audio-mute xmlns=\"google:muc#media\" nick=\"me\"/>"
+ "</item>"
+ "</publish>"
+ "</pubsub>"
+ "</cli:iq>";
+
+ ASSERT_EQ(2U, xmpp_client->sent_stanzas().size());
+ EXPECT_EQ(expected_audio_mute_iq, xmpp_client->sent_stanzas()[1]->Str());
+
+ client->PublishRecordingState(true);
+ std::string expected_recording_iq =
+ "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
+ "<publish node=\"google:muc#media\">"
+ "<item id=\"recording:me\">"
+ "<recording xmlns=\"google:muc#media\" nick=\"me\"/>"
+ "</item>"
+ "</publish>"
+ "</pubsub>"
+ "</cli:iq>";
+
+ ASSERT_EQ(3U, xmpp_client->sent_stanzas().size());
+ EXPECT_EQ(expected_recording_iq, xmpp_client->sent_stanzas()[2]->Str());
+
+ client->RemoteMute("mutee");
+ std::string expected_remote_mute_iq =
+ "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
+ "<publish node=\"google:muc#media\">"
+ "<item id=\"audio-mute:mutee\">"
+ "<audio-mute xmlns=\"google:muc#media\" nick=\"mutee\"/>"
+ "</item>"
+ "</publish>"
+ "</pubsub>"
+ "</cli:iq>";
+
+ ASSERT_EQ(4U, xmpp_client->sent_stanzas().size());
+ EXPECT_EQ(expected_remote_mute_iq, xmpp_client->sent_stanzas()[3]->Str());
+
+ client->PublishPresenterState(false);
+ std::string expected_presenter_retract_iq =
+ "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
+ "<publish node=\"google:presenter\">"
+ "<item id=\"me\">"
+ "<presenter xmlns=\"google:presenter\""
+ " jid=\"dummy@value.net\" nick=\"me\"/>"
+ "<pre:presentation-item"
+ " pre:presentation-type=\"o\" xmlns:pre=\"google:presenter\"/>"
+ "</item>"
+ "</publish>"
+ "</pubsub>"
+ "</cli:iq>";
+
+ ASSERT_EQ(5U, xmpp_client->sent_stanzas().size());
+ EXPECT_EQ(expected_presenter_retract_iq,
+ xmpp_client->sent_stanzas()[4]->Str());
+
+ client->PublishAudioMuteState(false);
+ std::string expected_audio_mute_retract_iq =
+ "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
+ "<retract node=\"google:muc#media\" notify=\"true\">"
+ "<item id=\"audio-mute:me\"/>"
+ "</retract>"
+ "</pubsub>"
+ "</cli:iq>";
+
+ ASSERT_EQ(6U, xmpp_client->sent_stanzas().size());
+ EXPECT_EQ(expected_audio_mute_retract_iq,
+ xmpp_client->sent_stanzas()[5]->Str());
+
+ client->BlockMedia("blockee");
+ std::string expected_media_block_iq =
+ "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
+ "<publish node=\"google:muc#media\">"
+ "<item id=\"block:me:blockee\">"
+ "<block xmlns=\"google:muc#media\" nick=\"blockee\"/>"
+ "</item>"
+ "</publish>"
+ "</pubsub>"
+ "</cli:iq>";
+
+ ASSERT_EQ(7U, xmpp_client->sent_stanzas().size());
+ EXPECT_EQ(expected_media_block_iq, xmpp_client->sent_stanzas()[6]->Str());
+}
+
+TEST_F(HangoutPubSubClientTest, TestPublishPresenterError) {
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'/>";
+
+ client->PublishPresenterState(true);
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+ EXPECT_EQ(1, listener->publish_presenter_error_count);
+ EXPECT_EQ("0", listener->error_task_id);
+}
+
+
+TEST_F(HangoutPubSubClientTest, TestPublishAudioMuteError) {
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'/>";
+
+ client->PublishAudioMuteState(true);
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+ EXPECT_EQ(1, listener->publish_audio_mute_error_count);
+ EXPECT_EQ("0", listener->error_task_id);
+}
+
+TEST_F(HangoutPubSubClientTest, TestPublishRecordingError) {
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'/>";
+
+ client->PublishRecordingState(true);
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+ EXPECT_EQ(1, listener->publish_recording_error_count);
+ EXPECT_EQ("0", listener->error_task_id);
+}
+
+TEST_F(HangoutPubSubClientTest, TestPublishRemoteMuteResult) {
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'/>";
+
+ client->RemoteMute("joe");
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+ EXPECT_EQ("joe", listener->remote_mute_mutee_nick);
+ EXPECT_EQ("0", listener->result_task_id);
+}
+
+TEST_F(HangoutPubSubClientTest, TestRemoteMuteError) {
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'/>";
+
+ client->RemoteMute("joe");
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+ EXPECT_EQ(1, listener->remote_mute_error_count);
+ EXPECT_EQ("joe", listener->remote_mute_mutee_nick);
+ EXPECT_EQ("0", listener->error_task_id);
+}
+
+TEST_F(HangoutPubSubClientTest, TestPublishMediaBlockResult) {
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'/>";
+
+ client->BlockMedia("joe");
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+ EXPECT_EQ("joe", listener->media_blockee_nick);
+ EXPECT_EQ("0", listener->result_task_id);
+}
+
+TEST_F(HangoutPubSubClientTest, TestMediaBlockError) {
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'/>";
+
+ client->BlockMedia("joe");
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+ EXPECT_EQ(1, listener->remote_mute_error_count);
+ EXPECT_EQ("joe", listener->media_blockee_nick);
+ EXPECT_EQ("0", listener->error_task_id);
+}
diff --git a/talk/xmpp/jid.cc b/talk/xmpp/jid.cc
index 01a025f..ae01e5d 100644
--- a/talk/xmpp/jid.cc
+++ b/talk/xmpp/jid.cc
@@ -2,26 +2,26 @@
* libjingle
* Copyright 2004--2005, Google Inc.
*
- * Redistribution and use in source and binary forms, with or without
+ * 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,
+ * 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
+ * 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
+ * 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,
+ * 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
+ * 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.
*/
@@ -38,106 +38,59 @@
namespace buzz {
-Jid::Jid() : data_(NULL) {
+Jid::Jid() {
}
-Jid::Jid(bool is_special, const std::string & special) {
- data_ = is_special ? new Data(special, STR_EMPTY, STR_EMPTY) : NULL;
-}
-
-Jid::Jid(const std::string & jid_string) {
- if (jid_string == STR_EMPTY) {
- data_ = NULL;
+Jid::Jid(const std::string& jid_string) {
+ if (jid_string.empty())
return;
- }
- // First find the slash and slice of that part
+ // First find the slash and slice off that part
size_t slash = jid_string.find('/');
- std::string resource_name = (slash == std::string::npos ? STR_EMPTY :
+ resource_name_ = (slash == std::string::npos ? STR_EMPTY :
jid_string.substr(slash + 1));
// Now look for the node
- std::string node_name;
size_t at = jid_string.find('@');
size_t domain_begin;
if (at < slash && at != std::string::npos) {
- node_name = jid_string.substr(0, at);
+ node_name_ = jid_string.substr(0, at);
domain_begin = at + 1;
} else {
domain_begin = 0;
}
// Now take what is left as the domain
- size_t domain_length =
- ( slash == std::string::npos
- ? jid_string.length() - domain_begin
- : slash - domain_begin);
+ size_t domain_length = (slash == std::string::npos) ?
+ (jid_string.length() - domain_begin) : (slash - domain_begin);
+ domain_name_ = jid_string.substr(domain_begin, domain_length);
- // avoid allocating these constants repeatedly
- std::string domain_name;
-
- if (domain_length == 9 && jid_string.find("gmail.com", domain_begin) == domain_begin) {
- domain_name = STR_GMAIL_COM;
- }
- else if (domain_length == 14 && jid_string.find("googlemail.com", domain_begin) == domain_begin) {
- domain_name = STR_GOOGLEMAIL_COM;
- }
- else if (domain_length == 10 && jid_string.find("google.com", domain_begin) == domain_begin) {
- domain_name = STR_GOOGLE_COM;
- }
- else {
- domain_name = jid_string.substr(domain_begin, domain_length);
- }
-
- // If the domain is empty we have a non-valid jid and we should empty
- // everything else out
- if (domain_name.empty()) {
- data_ = NULL;
- return;
- }
-
- bool valid_node;
- std::string validated_node = prepNode(node_name,
- node_name.begin(), node_name.end(), &valid_node);
- bool valid_domain;
- std::string validated_domain = prepDomain(domain_name,
- domain_name.begin(), domain_name.end(), &valid_domain);
- bool valid_resource;
- std::string validated_resource = prepResource(resource_name,
- resource_name.begin(), resource_name.end(), &valid_resource);
-
- if (!valid_node || !valid_domain || !valid_resource) {
- data_ = NULL;
- return;
- }
-
- data_ = new Data(validated_node, validated_domain, validated_resource);
+ ValidateOrReset();
}
-Jid::Jid(const std::string & node_name,
- const std::string & domain_name,
- const std::string & resource_name) {
- if (domain_name.empty()) {
- data_ = NULL;
- return;
- }
+Jid::Jid(const std::string& node_name,
+ const std::string& domain_name,
+ const std::string& resource_name)
+ : node_name_(node_name),
+ domain_name_(domain_name),
+ resource_name_(resource_name) {
+ ValidateOrReset();
+}
+void Jid::ValidateOrReset() {
bool valid_node;
- std::string validated_node = prepNode(node_name,
- node_name.begin(), node_name.end(), &valid_node);
bool valid_domain;
- std::string validated_domain = prepDomain(domain_name,
- domain_name.begin(), domain_name.end(), &valid_domain);
bool valid_resource;
- std::string validated_resource = prepResource(resource_name,
- resource_name.begin(), resource_name.end(), &valid_resource);
+
+ node_name_ = PrepNode(node_name_, &valid_node);
+ domain_name_ = PrepDomain(domain_name_, &valid_domain);
+ resource_name_ = PrepResource(resource_name_, &valid_resource);
if (!valid_node || !valid_domain || !valid_resource) {
- data_ = NULL;
- return;
+ node_name_.clear();
+ domain_name_.clear();
+ resource_name_.clear();
}
-
- data_ = new Data(validated_node, validated_domain, validated_resource);
}
std::string Jid::Str() const {
@@ -146,143 +99,85 @@
std::string ret;
- if (!data_->node_name_.empty())
- ret = data_->node_name_ + "@";
+ if (!node_name_.empty())
+ ret = node_name_ + "@";
- ASSERT(data_->domain_name_ != STR_EMPTY);
- ret += data_->domain_name_;
+ ASSERT(domain_name_ != STR_EMPTY);
+ ret += domain_name_;
- if (!data_->resource_name_.empty())
- ret += "/" + data_->resource_name_;
+ if (!resource_name_.empty())
+ ret += "/" + resource_name_;
return ret;
}
-bool
-Jid::IsValid() const {
- return data_ != NULL && !data_->domain_name_.empty();
+Jid::~Jid() {
}
-bool
-Jid::IsBare() const {
- if (Compare(JID_EMPTY) == 0) {
- LOG(LS_VERBOSE) << "Warning: Calling IsBare() on the empty jid";
+bool Jid::IsEmpty() const {
+ return (node_name_.empty() && domain_name_.empty() &&
+ resource_name_.empty());
+}
+
+bool Jid::IsValid() const {
+ return !domain_name_.empty();
+}
+
+bool Jid::IsBare() const {
+ if (IsEmpty()) {
+ LOG(LS_VERBOSE) << "Warning: Calling IsBare() on the empty jid.";
return true;
}
- return IsValid() &&
- data_->resource_name_.empty();
+ return IsValid() && resource_name_.empty();
}
-bool
-Jid::IsFull() const {
- return IsValid() &&
- !data_->resource_name_.empty();
+bool Jid::IsFull() const {
+ return IsValid() && !resource_name_.empty();
}
-Jid
-Jid::BareJid() const {
+Jid Jid::BareJid() const {
if (!IsValid())
return Jid();
if (!IsFull())
return *this;
- return Jid(data_->node_name_, data_->domain_name_, STR_EMPTY);
+ return Jid(node_name_, domain_name_, STR_EMPTY);
}
-#if 0
-void
-Jid::set_node(const std::string & node_name) {
- data_->node_name_ = node_name;
-}
-void
-Jid::set_domain(const std::string & domain_name) {
- data_->domain_name_ = domain_name;
-}
-void
-Jid::set_resource(const std::string & res_name) {
- data_->resource_name_ = res_name;
-}
-#endif
-
-bool
-Jid::BareEquals(const Jid & other) const {
- return (other.data_ == data_ ||
- (data_ != NULL &&
- other.data_ != NULL &&
- other.data_->node_name_ == data_->node_name_ &&
- other.data_->domain_name_ == data_->domain_name_));
+bool Jid::BareEquals(const Jid& other) const {
+ return other.node_name_ == node_name_ &&
+ other.domain_name_ == domain_name_;
}
-bool
-Jid::operator==(const Jid & other) const {
- return (other.data_ == data_ ||
- (data_ != NULL &&
- other.data_ != NULL &&
- other.data_->node_name_ == data_->node_name_ &&
- other.data_->domain_name_ == data_->domain_name_ &&
- other.data_->resource_name_ == data_->resource_name_));
+bool Jid::operator==(const Jid& other) const {
+ return other.node_name_ == node_name_ &&
+ other.domain_name_ == domain_name_ &&
+ other.resource_name_ == resource_name_;
}
-int
-Jid::Compare(const Jid & other) const {
- if (other.data_ == data_)
- return 0;
- if (data_ == NULL)
- return -1;
- if (other.data_ == NULL)
- return 1;
-
+int Jid::Compare(const Jid& other) const {
int compare_result;
- compare_result = data_->node_name_.compare(other.data_->node_name_);
+ compare_result = node_name_.compare(other.node_name_);
if (0 != compare_result)
return compare_result;
- compare_result = data_->domain_name_.compare(other.data_->domain_name_);
+ compare_result = domain_name_.compare(other.domain_name_);
if (0 != compare_result)
return compare_result;
- compare_result = data_->resource_name_.compare(other.data_->resource_name_);
+ compare_result = resource_name_.compare(other.resource_name_);
return compare_result;
}
-uint32 Jid::ComputeLameHash() const {
- uint32 hash = 0;
- // Hash the node portion
- {
- const std::string &str = node();
- for (int i = 0; i < static_cast<int>(str.size()); ++i) {
- hash = ((hash << 2) + hash) + str[i];
- }
- }
-
- // Hash the domain portion
- {
- const std::string &str = domain();
- for (int i = 0; i < static_cast<int>(str.size()); ++i)
- hash = ((hash << 2) + hash) + str[i];
- }
-
- // Hash the resource portion
- {
- const std::string &str = resource();
- for (int i = 0; i < static_cast<int>(str.size()); ++i)
- hash = ((hash << 2) + hash) + str[i];
- }
-
- return hash;
-}
-
// --- JID parsing code: ---
// Checks and normalizes the node part of a JID.
-std::string
-Jid::prepNode(const std::string str, std::string::const_iterator start,
- std::string::const_iterator end, bool *valid) {
+std::string Jid::PrepNode(const std::string& node, bool* valid) {
*valid = false;
std::string result;
- for (std::string::const_iterator i = start; i < end; i++) {
+ for (std::string::const_iterator i = node.begin(); i < node.end(); ++i) {
bool char_valid = true;
unsigned char ch = *i;
if (ch <= 0x7F) {
- result += prepNodeAscii(ch, &char_valid);
+ result += PrepNodeAscii(ch, &char_valid);
}
else {
// TODO: implement the correct stringprep protocol for these
@@ -302,8 +197,7 @@
// Returns the appropriate mapping for an ASCII character in a node.
-char
-Jid::prepNodeAscii(char ch, bool *valid) {
+char Jid::PrepNodeAscii(char ch, bool* valid) {
*valid = true;
switch (ch) {
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
@@ -329,17 +223,16 @@
// Checks and normalizes the resource part of a JID.
-std::string
-Jid::prepResource(const std::string str, std::string::const_iterator start,
- std::string::const_iterator end, bool *valid) {
+std::string Jid::PrepResource(const std::string& resource, bool* valid) {
*valid = false;
std::string result;
- for (std::string::const_iterator i = start; i < end; i++) {
+ for (std::string::const_iterator i = resource.begin();
+ i < resource.end(); ++i) {
bool char_valid = true;
unsigned char ch = *i;
if (ch <= 0x7F) {
- result += prepResourceAscii(ch, &char_valid);
+ result += PrepResourceAscii(ch, &char_valid);
}
else {
// TODO: implement the correct stringprep protocol for these
@@ -355,8 +248,7 @@
}
// Returns the appropriate mapping for an ASCII character in a resource.
-char
-Jid::prepResourceAscii(char ch, bool *valid) {
+char Jid::PrepResourceAscii(char ch, bool* valid) {
*valid = true;
switch (ch) {
case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05:
@@ -373,15 +265,13 @@
}
// Checks and normalizes the domain part of a JID.
-std::string
-Jid::prepDomain(const std::string str, std::string::const_iterator start,
- std::string::const_iterator end, bool *valid) {
+std::string Jid::PrepDomain(const std::string& domain, bool* valid) {
*valid = false;
std::string result;
// TODO: if the domain contains a ':', then we should parse it
// as an IPv6 address rather than giving an error about illegal domain.
- prepDomain(str, start, end, &result, valid);
+ PrepDomain(domain, &result, valid);
if (!*valid) {
return STR_EMPTY;
}
@@ -395,12 +285,10 @@
// Checks and normalizes an IDNA domain.
-void
-Jid::prepDomain(const std::string str, std::string::const_iterator start,
- std::string::const_iterator end, std::string *buf, bool *valid) {
+void Jid::PrepDomain(const std::string& domain, std::string* buf, bool* valid) {
*valid = false;
- std::string::const_iterator last = start;
- for (std::string::const_iterator i = start; i < end; i++) {
+ std::string::const_iterator last = domain.begin();
+ for (std::string::const_iterator i = domain.begin(); i < domain.end(); ++i) {
bool label_valid = true;
char ch = *i;
switch (ch) {
@@ -410,7 +298,7 @@
case 0xFF0E:
case 0xFF61:
#endif
- prepDomainLabel(str, last, i, buf, &label_valid);
+ PrepDomainLabel(last, i, buf, &label_valid);
*buf += '.';
last = i + 1;
break;
@@ -419,21 +307,21 @@
return;
}
}
- prepDomainLabel(str, last, end, buf, valid);
+ PrepDomainLabel(last, domain.end(), buf, valid);
}
// Checks and normalizes a domain label.
-void
-Jid::prepDomainLabel(const std::string str, std::string::const_iterator start,
- std::string::const_iterator end, std::string *buf, bool *valid) {
+void Jid::PrepDomainLabel(
+ std::string::const_iterator start, std::string::const_iterator end,
+ std::string* buf, bool* valid) {
*valid = false;
- int startLen = buf->length();
- for (std::string::const_iterator i = start; i < end; i++) {
+ int start_len = buf->length();
+ for (std::string::const_iterator i = start; i < end; ++i) {
bool char_valid = true;
unsigned char ch = *i;
if (ch <= 0x7F) {
- *buf += prepDomainLabelAscii(ch, &char_valid);
+ *buf += PrepDomainLabelAscii(ch, &char_valid);
}
else {
// TODO: implement ToASCII for these
@@ -444,7 +332,7 @@
}
}
- int count = buf->length() - startLen;
+ int count = buf->length() - start_len;
if (count == 0) {
return;
}
@@ -452,8 +340,8 @@
return;
}
- // Is this check needed? See comment in prepDomainLabelAscii.
- if ((*buf)[startLen] == '-') {
+ // Is this check needed? See comment in PrepDomainLabelAscii.
+ if ((*buf)[start_len] == '-') {
return;
}
if ((*buf)[buf->length() - 1] == '-') {
@@ -464,8 +352,7 @@
// Returns the appropriate mapping for an ASCII character in a domain label.
-char
-Jid::prepDomainLabelAscii(char ch, bool *valid) {
+char Jid::PrepDomainLabelAscii(char ch, bool* valid) {
*valid = true;
// TODO: A literal reading of the spec seems to say that we do
// not need to check for these illegal characters (an "internationalized
@@ -500,4 +387,4 @@
}
}
-}
+} // namespace buzz
diff --git a/talk/xmpp/jid.h b/talk/xmpp/jid.h
index 6831bda..9daadb0 100644
--- a/talk/xmpp/jid.h
+++ b/talk/xmpp/jid.h
@@ -24,8 +24,9 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef _jid_h_
-#define _jid_h_
+
+#ifndef TALK_XMPP_JID_H_
+#define TALK_XMPP_JID_H_
#include <string>
#include "talk/base/basictypes.h"
@@ -33,116 +34,65 @@
namespace buzz {
-//! The Jid class encapsulates and provides parsing help for Jids
-//! A Jid consists of three parts. The node, the domain and the resource.
-//!
-//! node@domain/resource
-//!
-//! The node and resource are both optional. A valid jid is defined to have
-//! a domain. A bare jid is defined to not have a resource and a full jid
-//! *does* have a resource.
+// The Jid class encapsulates and provides parsing help for Jids. A Jid
+// consists of three parts: the node, the domain and the resource, e.g.:
+//
+// node@domain/resource
+//
+// The node and resource are both optional. A valid jid is defined to have
+// a domain. A bare jid is defined to not have a resource and a full jid
+// *does* have a resource.
class Jid {
public:
explicit Jid();
- explicit Jid(const std::string & jid_string);
- explicit Jid(const std::string & node_name,
- const std::string & domain_name,
- const std::string & resource_name);
- explicit Jid(bool special, const std::string & special_string);
- Jid(const Jid & jid) : data_(jid.data_) {
- if (data_ != NULL) {
- data_->AddRef();
- }
- }
- Jid & operator=(const Jid & jid) {
- if (jid.data_ != NULL) {
- jid.data_->AddRef();
- }
- if (data_ != NULL) {
- data_->Release();
- }
- data_ = jid.data_;
- return *this;
- }
- ~Jid() {
- if (data_ != NULL) {
- data_->Release();
- }
- }
-
+ explicit Jid(const std::string& jid_string);
+ explicit Jid(const std::string& node_name,
+ const std::string& domain_name,
+ const std::string& resource_name);
+ ~Jid();
- const std::string & node() const { return !data_ ? STR_EMPTY : data_->node_name_; }
- // void set_node(const std::string & node_name);
- const std::string & domain() const { return !data_ ? STR_EMPTY : data_->domain_name_; }
- // void set_domain(const std::string & domain_name);
- const std::string & resource() const { return !data_ ? STR_EMPTY : data_->resource_name_; }
- // void set_resource(const std::string & res_name);
+ const std::string & node() const { return node_name_; }
+ const std::string & domain() const { return domain_name_; }
+ const std::string & resource() const { return resource_name_; }
std::string Str() const;
Jid BareJid() const;
+ bool IsEmpty() const;
bool IsValid() const;
bool IsBare() const;
bool IsFull() const;
- bool BareEquals(const Jid & other) const;
+ bool BareEquals(const Jid& other) const;
- bool operator==(const Jid & other) const;
- bool operator!=(const Jid & other) const { return !operator==(other); }
+ bool operator==(const Jid& other) const;
+ bool operator!=(const Jid& other) const { return !operator==(other); }
- bool operator<(const Jid & other) const { return Compare(other) < 0; };
- bool operator>(const Jid & other) const { return Compare(other) > 0; };
-
+ bool operator<(const Jid& other) const { return Compare(other) < 0; };
+ bool operator>(const Jid& other) const { return Compare(other) > 0; };
+
int Compare(const Jid & other) const;
- // A quick and dirty hash. Don't count on this producing a great
- // distribution.
- uint32 ComputeLameHash() const;
-
private:
+ void ValidateOrReset();
- static std::string prepNode(const std::string str,
- std::string::const_iterator start, std::string::const_iterator end,
- bool *valid);
- static char prepNodeAscii(char ch, bool *valid);
- static std::string prepResource(const std::string str,
- std::string::const_iterator start, std::string::const_iterator end,
- bool *valid);
- static char prepResourceAscii(char ch, bool *valid);
- static std::string prepDomain(const std::string str,
- std::string::const_iterator start, std::string::const_iterator end,
- bool *valid);
- static void prepDomain(const std::string str,
- std::string::const_iterator start, std::string::const_iterator end,
- std::string *buf, bool *valid);
- static void prepDomainLabel(const std::string str,
- std::string::const_iterator start, std::string::const_iterator end,
- std::string *buf, bool *valid);
- static char prepDomainLabelAscii(char ch, bool *valid);
+ static std::string PrepNode(const std::string& node, bool* valid);
+ static char PrepNodeAscii(char ch, bool* valid);
+ static std::string PrepResource(const std::string& start, bool* valid);
+ static char PrepResourceAscii(char ch, bool* valid);
+ static std::string PrepDomain(const std::string& domain, bool* valid);
+ static void PrepDomain(const std::string& domain,
+ std::string* buf, bool* valid);
+ static void PrepDomainLabel(
+ std::string::const_iterator start, std::string::const_iterator end,
+ std::string* buf, bool* valid);
+ static char PrepDomainLabelAscii(char ch, bool *valid);
- class Data {
- public:
- Data() : refcount_(1) {}
- Data(const std::string & node, const std::string &domain, const std::string & resource) :
- node_name_(node),
- domain_name_(domain),
- resource_name_(resource),
- refcount_(1) {}
- const std::string node_name_;
- const std::string domain_name_;
- const std::string resource_name_;
-
- void AddRef() { refcount_++; }
- void Release() { if (!--refcount_) delete this; }
- private:
- int refcount_;
- };
-
- Data * data_;
+ std::string node_name_;
+ std::string domain_name_;
+ std::string resource_name_;
};
}
-
-
-#endif
+#endif // TALK_XMPP_JID_H_
diff --git a/talk/xmpp/jid_unittest.cc b/talk/xmpp/jid_unittest.cc
new file mode 100644
index 0000000..b9597da
--- /dev/null
+++ b/talk/xmpp/jid_unittest.cc
@@ -0,0 +1,115 @@
+// Copyright 2004 Google Inc. All Rights Reserved
+
+
+#include "talk/base/gunit.h"
+#include "talk/xmpp/jid.h"
+
+using buzz::Jid;
+
+TEST(JidTest, TestDomain) {
+ Jid jid("dude");
+ EXPECT_EQ("", jid.node());
+ EXPECT_EQ("dude", jid.domain());
+ EXPECT_EQ("", jid.resource());
+ EXPECT_EQ("dude", jid.Str());
+ EXPECT_EQ("dude", jid.BareJid().Str());
+ EXPECT_TRUE(jid.IsValid());
+ EXPECT_TRUE(jid.IsBare());
+ EXPECT_FALSE(jid.IsFull());
+}
+
+TEST(JidTest, TestNodeDomain) {
+ Jid jid("walter@dude");
+ EXPECT_EQ("walter", jid.node());
+ EXPECT_EQ("dude", jid.domain());
+ EXPECT_EQ("", jid.resource());
+ EXPECT_EQ("walter@dude", jid.Str());
+ EXPECT_EQ("walter@dude", jid.BareJid().Str());
+ EXPECT_TRUE(jid.IsValid());
+ EXPECT_TRUE(jid.IsBare());
+ EXPECT_FALSE(jid.IsFull());
+}
+
+TEST(JidTest, TestDomainResource) {
+ Jid jid("dude/bowlingalley");
+ EXPECT_EQ("", jid.node());
+ EXPECT_EQ("dude", jid.domain());
+ EXPECT_EQ("bowlingalley", jid.resource());
+ EXPECT_EQ("dude/bowlingalley", jid.Str());
+ EXPECT_EQ("dude", jid.BareJid().Str());
+ EXPECT_TRUE(jid.IsValid());
+ EXPECT_FALSE(jid.IsBare());
+ EXPECT_TRUE(jid.IsFull());
+}
+
+TEST(JidTest, TestNodeDomainResource) {
+ Jid jid("walter@dude/bowlingalley");
+ EXPECT_EQ("walter", jid.node());
+ EXPECT_EQ("dude", jid.domain());
+ EXPECT_EQ("bowlingalley", jid.resource());
+ EXPECT_EQ("walter@dude/bowlingalley", jid.Str());
+ EXPECT_EQ("walter@dude", jid.BareJid().Str());
+ EXPECT_TRUE(jid.IsValid());
+ EXPECT_FALSE(jid.IsBare());
+ EXPECT_TRUE(jid.IsFull());
+}
+
+TEST(JidTest, TestNode) {
+ Jid jid("walter@");
+ EXPECT_EQ("", jid.node());
+ EXPECT_EQ("", jid.domain());
+ EXPECT_EQ("", jid.resource());
+ EXPECT_EQ("", jid.Str());
+ EXPECT_EQ("", jid.BareJid().Str());
+ EXPECT_FALSE(jid.IsValid());
+ EXPECT_TRUE(jid.IsBare());
+ EXPECT_FALSE(jid.IsFull());
+}
+
+TEST(JidTest, TestResource) {
+ Jid jid("/bowlingalley");
+ EXPECT_EQ("", jid.node());
+ EXPECT_EQ("", jid.domain());
+ EXPECT_EQ("", jid.resource());
+ EXPECT_EQ("", jid.Str());
+ EXPECT_EQ("", jid.BareJid().Str());
+ EXPECT_FALSE(jid.IsValid());
+ EXPECT_TRUE(jid.IsBare());
+ EXPECT_FALSE(jid.IsFull());
+}
+
+TEST(JidTest, TestNodeResource) {
+ Jid jid("walter@/bowlingalley");
+ EXPECT_EQ("", jid.node());
+ EXPECT_EQ("", jid.domain());
+ EXPECT_EQ("", jid.resource());
+ EXPECT_EQ("", jid.Str());
+ EXPECT_EQ("", jid.BareJid().Str());
+ EXPECT_FALSE(jid.IsValid());
+ EXPECT_TRUE(jid.IsBare());
+ EXPECT_FALSE(jid.IsFull());
+}
+
+TEST(JidTest, TestFunky) {
+ Jid jid("bowling@muchat/walter@dude");
+ EXPECT_EQ("bowling", jid.node());
+ EXPECT_EQ("muchat", jid.domain());
+ EXPECT_EQ("walter@dude", jid.resource());
+ EXPECT_EQ("bowling@muchat/walter@dude", jid.Str());
+ EXPECT_EQ("bowling@muchat", jid.BareJid().Str());
+ EXPECT_TRUE(jid.IsValid());
+ EXPECT_FALSE(jid.IsBare());
+ EXPECT_TRUE(jid.IsFull());
+}
+
+TEST(JidTest, TestFunky2) {
+ Jid jid("muchat/walter@dude");
+ EXPECT_EQ("", jid.node());
+ EXPECT_EQ("muchat", jid.domain());
+ EXPECT_EQ("walter@dude", jid.resource());
+ EXPECT_EQ("muchat/walter@dude", jid.Str());
+ EXPECT_EQ("muchat", jid.BareJid().Str());
+ EXPECT_TRUE(jid.IsValid());
+ EXPECT_FALSE(jid.IsBare());
+ EXPECT_TRUE(jid.IsFull());
+}
diff --git a/talk/xmpp/module.h b/talk/xmpp/module.h
new file mode 100644
index 0000000..75a190d
--- /dev/null
+++ b/talk/xmpp/module.h
@@ -0,0 +1,51 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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 _module_h_
+#define _module_h_
+
+namespace buzz {
+
+class XmppEngine;
+enum XmppReturnStatus;
+
+//! This is the base class for extension modules.
+//! An engine is registered with the module and the module then hooks the
+//! appropriate parts of the engine to implement that set of features. It is
+//! important to unregister modules before destructing the engine.
+class XmppModule {
+public:
+ virtual ~XmppModule() {}
+
+ //! Register the engine with the module. Only one engine can be associated
+ //! with a module at a time. This method will return an error if there is
+ //! already an engine registered.
+ virtual XmppReturnStatus RegisterEngine(XmppEngine* engine) = 0;
+};
+
+}
+#endif
diff --git a/talk/xmpp/moduleimpl.cc b/talk/xmpp/moduleimpl.cc
new file mode 100644
index 0000000..b23ca29
--- /dev/null
+++ b/talk/xmpp/moduleimpl.cc
@@ -0,0 +1,65 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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/base/common.h"
+#include "talk/xmpp/moduleimpl.h"
+
+namespace buzz {
+
+XmppModuleImpl::XmppModuleImpl() :
+ engine_(NULL),
+ stanza_handler_(this) {
+}
+
+XmppModuleImpl::~XmppModuleImpl()
+{
+ if (engine_ != NULL) {
+ engine_->RemoveStanzaHandler(&stanza_handler_);
+ engine_ = NULL;
+ }
+}
+
+XmppReturnStatus
+XmppModuleImpl::RegisterEngine(XmppEngine* engine)
+{
+ if (NULL == engine || NULL != engine_)
+ return XMPP_RETURN_BADARGUMENT;
+
+ engine->AddStanzaHandler(&stanza_handler_);
+ engine_ = engine;
+
+ return XMPP_RETURN_OK;
+}
+
+XmppEngine*
+XmppModuleImpl::engine() {
+ ASSERT(NULL != engine_);
+ return engine_;
+}
+
+}
+
diff --git a/talk/xmpp/moduleimpl.h b/talk/xmpp/moduleimpl.h
new file mode 100644
index 0000000..085c83a
--- /dev/null
+++ b/talk/xmpp/moduleimpl.h
@@ -0,0 +1,93 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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 _moduleimpl_h_
+#define _moduleimpl_h_
+
+#include "talk/xmpp/xmppengine.h"
+#include "talk/xmpp/module.h"
+
+namespace buzz {
+
+//! This is the base implementation class for extension modules.
+//! An engine is registered with the module and the module then hooks the
+//! appropriate parts of the engine to implement that set of features. It is
+//! important to unregister modules before destructing the engine.
+class XmppModuleImpl {
+protected:
+ XmppModuleImpl();
+ virtual ~XmppModuleImpl();
+
+ //! Register the engine with the module. Only one engine can be associated
+ //! with a module at a time. This method will return an error if there is
+ //! already an engine registered.
+ XmppReturnStatus RegisterEngine(XmppEngine* engine);
+
+ //! Gets the engine that this module is attached to.
+ XmppEngine* engine();
+
+ //! Process the given stanza.
+ //! The module must return true if it has handled the stanza.
+ //! A false return value causes the stanza to be passed on to
+ //! the next registered handler.
+ virtual bool HandleStanza(const XmlElement *) { return false; };
+
+private:
+
+ //! The ModuleSessionHelper nested class allows the Module
+ //! to hook into and get stanzas and events from the engine.
+ class ModuleStanzaHandler : public XmppStanzaHandler {
+ friend class XmppModuleImpl;
+
+ ModuleStanzaHandler(XmppModuleImpl* module) :
+ module_(module) {
+ }
+
+ bool HandleStanza(const XmlElement* stanza) {
+ return module_->HandleStanza(stanza);
+ }
+
+ XmppModuleImpl* module_;
+ };
+
+ friend class ModuleStanzaHandler;
+
+ XmppEngine* engine_;
+ ModuleStanzaHandler stanza_handler_;
+};
+
+
+// This macro will implement the XmppModule interface for a class
+// that derives from both XmppModuleImpl and XmppModule
+#define IMPLEMENT_XMPPMODULE \
+ XmppReturnStatus RegisterEngine(XmppEngine* engine) { \
+ return XmppModuleImpl::RegisterEngine(engine); \
+ }
+
+}
+
+#endif
diff --git a/talk/xmpp/mucroomconfigtask_unittest.cc b/talk/xmpp/mucroomconfigtask_unittest.cc
new file mode 100644
index 0000000..e0a8aca
--- /dev/null
+++ b/talk/xmpp/mucroomconfigtask_unittest.cc
@@ -0,0 +1,144 @@
+/*
+ * 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 <vector>
+
+#include "talk/base/faketaskrunner.h"
+#include "talk/base/gunit.h"
+#include "talk/base/sigslot.h"
+#include "talk/xmllite/xmlelement.h"
+#include "talk/xmpp/constants.h"
+#include "talk/xmpp/fakexmppclient.h"
+#include "talk/xmpp/mucroomconfigtask.h"
+
+class MucRoomConfigListener : public sigslot::has_slots<> {
+ public:
+ MucRoomConfigListener() : result_count(0), error_count(0) {}
+
+ void OnResult(buzz::MucRoomConfigTask*) {
+ ++result_count;
+ }
+
+ void OnError(buzz::IqTask* task,
+ const buzz::XmlElement* error) {
+ ++error_count;
+ }
+
+ int result_count;
+ int error_count;
+};
+
+class MucRoomConfigTaskTest : public testing::Test {
+ public:
+ MucRoomConfigTaskTest() :
+ room_jid("muc-jid-ponies@domain.com"),
+ room_name("ponies") {
+ }
+
+ virtual void SetUp() {
+ runner = new talk_base::FakeTaskRunner();
+ xmpp_client = new buzz::FakeXmppClient(runner);
+ listener = new MucRoomConfigListener();
+ }
+
+ virtual void TearDown() {
+ delete listener;
+ // delete xmpp_client; Deleted by deleting runner.
+ delete runner;
+ }
+
+ talk_base::FakeTaskRunner* runner;
+ buzz::FakeXmppClient* xmpp_client;
+ MucRoomConfigListener* listener;
+ buzz::Jid room_jid;
+ std::string room_name;
+};
+
+TEST_F(MucRoomConfigTaskTest, TestConfigEnterprise) {
+ ASSERT_EQ(0U, xmpp_client->sent_stanzas().size());
+
+ std::vector<std::string> room_features;
+ room_features.push_back("feature1");
+ room_features.push_back("feature2");
+ buzz::MucRoomConfigTask* task = new buzz::MucRoomConfigTask(
+ xmpp_client, room_jid, "ponies", room_features);
+ EXPECT_EQ(room_jid, task->room_jid());
+
+ task->SignalResult.connect(listener, &MucRoomConfigListener::OnResult);
+ task->Start();
+
+ std::string expected_iq =
+ "<cli:iq type=\"set\" to=\"muc-jid-ponies@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<query xmlns=\"http://jabber.org/protocol/muc#owner\">"
+ "<x xmlns=\"jabber:x:data\" type=\"form\">"
+ "<field var=\"muc#roomconfig_roomname\" type=\"text-single\">"
+ "<value>ponies</value>"
+ "</field>"
+ "<field var=\"muc#roomconfig_features\" type=\"list-multi\">"
+ "<value>feature1</value>"
+ "<value>feature2</value>"
+ "</field>"
+ "</x>"
+ "</query>"
+ "</cli:iq>";
+
+ ASSERT_EQ(1U, xmpp_client->sent_stanzas().size());
+ EXPECT_EQ(expected_iq, xmpp_client->sent_stanzas()[0]->Str());
+
+ EXPECT_EQ(0, listener->result_count);
+ EXPECT_EQ(0, listener->error_count);
+
+ std::string response_iq =
+ "<iq xmlns='jabber:client' id='0' type='result'"
+ " from='muc-jid-ponies@domain.com'>"
+ "</iq>";
+
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(response_iq));
+
+ EXPECT_EQ(1, listener->result_count);
+ EXPECT_EQ(0, listener->error_count);
+}
+
+TEST_F(MucRoomConfigTaskTest, TestError) {
+ std::vector<std::string> room_features;
+ buzz::MucRoomConfigTask* task = new buzz::MucRoomConfigTask(
+ xmpp_client, room_jid, "ponies", room_features);
+ task->SignalError.connect(listener, &MucRoomConfigListener::OnError);
+ task->Start();
+
+ std::string error_iq =
+ "<iq xmlns='jabber:client' id='0' type='error'"
+ " from='muc-jid-ponies@domain.com'>"
+ "</iq>";
+
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(error_iq));
+
+ EXPECT_EQ(0, listener->result_count);
+ EXPECT_EQ(1, listener->error_count);
+}
diff --git a/talk/xmpp/mucroomhistorytask.cc b/talk/xmpp/mucroomhistorytask.cc
new file mode 100644
index 0000000..08c907a
--- /dev/null
+++ b/talk/xmpp/mucroomhistorytask.cc
@@ -0,0 +1,146 @@
+/*
+ * 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/xmpp/mucroomhistorytask.h"
+#include "talk/xmpp/constants.h"
+
+namespace buzz {
+
+// TODO: Move these to xmpp/constants.cc once it's publicly
+// viewable.
+const char NS_GOOGLE_SETTING[] = "google:setting";
+const StaticQName QN_MEETING_HISTORY = { NS_GOOGLE_SETTING, "meetinghistory" };
+const StaticQName QN_MEETING_ITEM = { NS_GOOGLE_SETTING, "item" };
+
+MucRoomHistoryGetTask::MucRoomHistoryGetTask(XmppTaskParentInterface* parent,
+ const buzz::Jid& user_jid)
+ : IqTask(parent, STR_GET, user_jid, MakeRequest()) {
+}
+
+// <iq type='get' id='user-setting-1'>
+// <meetinghistory xmlns='google:setting' />
+// </iq>
+XmlElement* MucRoomHistoryGetTask::MakeRequest() {
+ XmlElement* history = new XmlElement(QN_MEETING_HISTORY, true);
+ return history;
+}
+
+// <iq type='result'
+// to='romeo@gmail.com/orchard'
+// id='user-setting-1'>
+// <meetinghistory xmlns='google:setting'>
+// <item jid=’private-muc-abc-...@groupchat.google.com’ name=’Hangout'
+// time=’2011-01-31T13:20:00Z’ />
+// <item jid=’private-muc-abc-...@groupchat.google.com’ name=’Planning’
+// time=’2011-02-11T 14:20:00Z />
+// <item jid=’private-muc-abc-...@groupchat.google.com’ name=’TGIF’
+// time=’2011-03-21T15:20:00Z’ />
+// </meetinghistory>
+// </iq>
+void MucRoomHistoryGetTask::HandleResult(const XmlElement* stanza) {
+ std::vector<MucRoomHistoryInfo> meeting_rooms;
+
+ const XmlElement* history = stanza->FirstNamed(QN_MEETING_HISTORY);
+ if (history == NULL) {
+ SignalResult(meeting_rooms);
+ return;
+ }
+
+ const XmlElement* history_item = history->FirstNamed(QN_MEETING_ITEM);
+ while (history_item != NULL) {
+ MucRoomHistoryInfo room;
+ room.room_name = history_item->Attr(QN_NAME);
+ room.last_enter_time = history_item->Attr(QN_TIME);
+ meeting_rooms.push_back(room);
+
+ history_item = history_item->NextNamed(QN_MEETING_ITEM);
+ }
+
+ SignalResult(meeting_rooms);
+}
+
+MucRoomHistorySetTask::MucRoomHistorySetTask(XmppTaskParentInterface* parent,
+ MucRoomHistoryTaskCommand command,
+ const buzz::Jid& user_jid,
+ const std::string& room_name)
+ : IqTask(parent, STR_SET, user_jid, MakeRequest(command, room_name)) {
+}
+
+// ADD
+// <iq type='set'
+// to='romeo@gmail.com'
+// id='user-setting-3'>
+// <meetinghistory xmlns='google:setting'>
+// <item jid=’private-muc-abc@groupchat.google.com’
+// name=’Hangout' action=’add’ />
+// </meetinghistory>
+// </iq>
+
+// DELETE
+// <iq type='set'
+// to='romeo@gmail.com'
+// id='user-setting-3'>
+// <meetinghistory xmlns='google:setting'>
+// <item jid=’private-muc-abc@groupchat.google.com’
+// name=’Hangout' action=’remove’ />
+// </meetinghistory>
+// </iq>
+
+// CLEAR ALL
+// <iq type='set'
+// from='romeo@gmail.com/orchard'
+// to='romeo@gmail.com'
+// id='user-setting-3'>
+// <meetinghistory xmlns='google:setting' />
+// </iq>
+XmlElement* MucRoomHistorySetTask::MakeRequest(
+ MucRoomHistoryTaskCommand command, const std::string& room_name) {
+ XmlElement* history = new XmlElement(QN_MEETING_HISTORY, true);
+ if (command != HT_CLEAR_ALL) {
+ XmlElement* item = new XmlElement(QN_MEETING_ITEM, false);
+ // TODO - remove QN_JID attribute when 21446107 is submitted &
+ // deployed. no harm to leave in after the change is made.
+ item->AddAttr(QN_JID, room_name);
+ item->AddAttr(QN_NAME, room_name);
+ item->AddAttr(QN_ACTION, command == HT_ADD ? "add" : "remove");
+
+ history->AddElement(item);
+ }
+
+ return history;
+}
+
+// MODIFY & CLEAR
+// <iq type='result'
+// to='romeo@gmail.com/orchard'
+// from='romeo@gmail.com'
+// id='user-setting-3' />
+void MucRoomHistorySetTask::HandleResult(const XmlElement* stanza) {
+ SignalResult();
+}
+
+} // namespace buzz
diff --git a/talk/xmpp/mucroomhistorytask.h b/talk/xmpp/mucroomhistorytask.h
new file mode 100644
index 0000000..79d1bfa
--- /dev/null
+++ b/talk/xmpp/mucroomhistorytask.h
@@ -0,0 +1,75 @@
+/*
+ * 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.
+ */
+
+// https://docs.google.com/a/google.com/document/d/1PObnyJbdEWDOrgDZJFIH1peMvRoUkSTv6382zq3hbuM/edit?hl=en#
+
+#include <string>
+#include <vector>
+
+#include "talk/xmpp/iqtask.h"
+
+namespace buzz {
+
+struct MucRoomHistoryInfo {
+ std::string room_name;
+ std::string last_enter_time;
+};
+
+enum MucRoomHistoryTaskCommand {
+ HT_ADD = 0,
+ HT_CLEAR_ALL = 1,
+ HT_DELETE = 2,
+};
+
+class MucRoomHistoryGetTask : public IqTask {
+ public:
+ MucRoomHistoryGetTask(XmppTaskParentInterface* parent,
+ const buzz::Jid& user_jid);
+
+ sigslot::signal1<const std::vector<MucRoomHistoryInfo>&> SignalResult;
+
+ protected:
+ static XmlElement* MakeRequest();
+ virtual void HandleResult(const XmlElement* stanza);
+};
+
+class MucRoomHistorySetTask : public IqTask {
+ public:
+ MucRoomHistorySetTask(XmppTaskParentInterface* parent,
+ MucRoomHistoryTaskCommand command,
+ const buzz::Jid& user_jid,
+ const std::string& room_name);
+
+ sigslot::signal0<> SignalResult;
+
+ protected:
+ static XmlElement* MakeRequest(MucRoomHistoryTaskCommand command,
+ const std::string& room_name);
+ virtual void HandleResult(const XmlElement* stanza);
+};
+
+} // namespace buzz
diff --git a/talk/xmpp/mucroomlookuptask_unittest.cc b/talk/xmpp/mucroomlookuptask_unittest.cc
new file mode 100644
index 0000000..99a78c7
--- /dev/null
+++ b/talk/xmpp/mucroomlookuptask_unittest.cc
@@ -0,0 +1,162 @@
+/*
+ * 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 <vector>
+
+#include "talk/base/faketaskrunner.h"
+#include "talk/base/gunit.h"
+#include "talk/base/sigslot.h"
+#include "talk/xmllite/xmlelement.h"
+#include "talk/xmpp/constants.h"
+#include "talk/xmpp/fakexmppclient.h"
+#include "talk/xmpp/mucroomlookuptask.h"
+
+class MucRoomLookupListener : public sigslot::has_slots<> {
+ public:
+ MucRoomLookupListener() : error_count(0) {}
+
+ void OnResult(buzz::MucRoomLookupTask* task,
+ const buzz::MucRoomInfo& room) {
+ last_room = room;
+ }
+
+ void OnError(buzz::IqTask* task,
+ const buzz::XmlElement* error) {
+ ++error_count;
+ }
+
+ buzz::MucRoomInfo last_room;
+ int error_count;
+};
+
+class MucRoomLookupTaskTest : public testing::Test {
+ public:
+ MucRoomLookupTaskTest() :
+ lookup_server_jid("lookup@domain.com"),
+ room_jid("muc-jid-ponies@domain.com"),
+ room_name("ponies"),
+ room_domain("domain.com"),
+ room_full_name("ponies@domain.com") {
+ }
+
+ virtual void SetUp() {
+ runner = new talk_base::FakeTaskRunner();
+ xmpp_client = new buzz::FakeXmppClient(runner);
+ listener = new MucRoomLookupListener();
+ }
+
+ virtual void TearDown() {
+ delete listener;
+ // delete xmpp_client; Deleted by deleting runner.
+ delete runner;
+ }
+
+ talk_base::FakeTaskRunner* runner;
+ buzz::FakeXmppClient* xmpp_client;
+ MucRoomLookupListener* listener;
+ buzz::Jid lookup_server_jid;
+ buzz::Jid room_jid;
+ std::string room_name;
+ std::string room_domain;
+ std::string room_full_name;
+};
+
+TEST_F(MucRoomLookupTaskTest, TestLookupName) {
+ ASSERT_EQ(0U, xmpp_client->sent_stanzas().size());
+
+ buzz::MucRoomLookupTask* task = new buzz::MucRoomLookupTask(
+ xmpp_client, lookup_server_jid, room_name, room_domain);
+ task->SignalResult.connect(listener, &MucRoomLookupListener::OnResult);
+ task->Start();
+
+ std::string expected_iq =
+ "<cli:iq type=\"set\" to=\"lookup@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<query xmlns=\"jabber:iq:search\">"
+ "<room-name>ponies</room-name>"
+ "<room-domain>domain.com</room-domain>"
+ "</query>"
+ "</cli:iq>";
+
+ ASSERT_EQ(1U, xmpp_client->sent_stanzas().size());
+ EXPECT_EQ(expected_iq, xmpp_client->sent_stanzas()[0]->Str());
+
+ EXPECT_EQ("", listener->last_room.name);
+
+ std::string response_iq =
+ "<iq xmlns='jabber:client' from='lookup@domain.com' id='0' type='result'>"
+ " <query xmlns='jabber:iq:search'>"
+ " <item jid='muc-jid-ponies@domain.com'>"
+ " <room-name>ponies</room-name>"
+ " <room-domain>domain.com</room-domain>"
+ " </item>"
+ " </query>"
+ "</iq>";
+
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(response_iq));
+
+ EXPECT_EQ(room_name, listener->last_room.name);
+ EXPECT_EQ(room_domain, listener->last_room.domain);
+ EXPECT_EQ(room_jid, listener->last_room.jid);
+ EXPECT_EQ(room_full_name, listener->last_room.full_name());
+ EXPECT_EQ(0, listener->error_count);
+}
+
+TEST_F(MucRoomLookupTaskTest, TestError) {
+ buzz::MucRoomLookupTask* task = new buzz::MucRoomLookupTask(
+ xmpp_client, lookup_server_jid, room_name, room_domain);
+ task->SignalError.connect(listener, &MucRoomLookupListener::OnError);
+ task->Start();
+
+ std::string error_iq =
+ "<iq xmlns='jabber:client' id='0' type='error'"
+ " from='lookup@domain.com'>"
+ "</iq>";
+
+ EXPECT_EQ(0, listener->error_count);
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(error_iq));
+ EXPECT_EQ(1, listener->error_count);
+}
+
+TEST_F(MucRoomLookupTaskTest, TestBadJid) {
+ buzz::MucRoomLookupTask* task = new buzz::MucRoomLookupTask(
+ xmpp_client, lookup_server_jid, room_name, room_domain);
+ task->SignalError.connect(listener, &MucRoomLookupListener::OnError);
+ task->Start();
+
+ std::string response_iq =
+ "<iq xmlns='jabber:client' from='lookup@domain.com' id='0' type='result'>"
+ " <query xmlns='jabber:iq:search'>"
+ " <item/>"
+ " </query>"
+ "</iq>";
+
+ EXPECT_EQ(0, listener->error_count);
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(response_iq));
+ EXPECT_EQ(1, listener->error_count);
+}
diff --git a/talk/xmpp/pubsub_task.cc b/talk/xmpp/pubsub_task.cc
new file mode 100644
index 0000000..97e0d4d
--- /dev/null
+++ b/talk/xmpp/pubsub_task.cc
@@ -0,0 +1,217 @@
+/*
+ * libjingle
+ * Copyright 2004--2006, 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/xmpp/pubsub_task.h"
+
+#include <map>
+#include <string>
+
+#include "talk/base/common.h"
+#include "talk/xmpp/constants.h"
+#include "talk/xmpp/xmppengine.h"
+
+namespace buzz {
+
+PubsubTask::PubsubTask(XmppTaskParentInterface* parent,
+ const buzz::Jid& pubsub_node_jid)
+ : buzz::XmppTask(parent, buzz::XmppEngine::HL_SENDER),
+ pubsub_node_jid_(pubsub_node_jid) {
+}
+
+PubsubTask::~PubsubTask() {
+}
+
+// Checks for pubsub publish events as well as responses to get IQs.
+bool PubsubTask::HandleStanza(const buzz::XmlElement* stanza) {
+ const buzz::QName& stanza_name(stanza->Name());
+ if (stanza_name == buzz::QN_MESSAGE) {
+ if (MatchStanzaFrom(stanza, pubsub_node_jid_)) {
+ const buzz::XmlElement* pubsub_event_item =
+ stanza->FirstNamed(QN_PUBSUB_EVENT);
+ if (pubsub_event_item != NULL) {
+ QueueStanza(pubsub_event_item);
+ return true;
+ }
+ }
+ } else if (stanza_name == buzz::QN_IQ) {
+ if (MatchResponseIq(stanza, pubsub_node_jid_, task_id())) {
+ const buzz::XmlElement* pubsub_item = stanza->FirstNamed(QN_PUBSUB);
+ if (pubsub_item != NULL) {
+ QueueStanza(pubsub_item);
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+int PubsubTask::ProcessResponse() {
+ const buzz::XmlElement* stanza = NextStanza();
+ if (stanza == NULL) {
+ return STATE_BLOCKED;
+ }
+
+ if (stanza->Attr(buzz::QN_TYPE) == buzz::STR_ERROR) {
+ OnPubsubError(stanza->FirstNamed(buzz::QN_ERROR));
+ return STATE_RESPONSE;
+ }
+
+ const buzz::QName& stanza_name(stanza->Name());
+ if (stanza_name == QN_PUBSUB_EVENT) {
+ HandlePubsubEventMessage(stanza);
+ } else if (stanza_name == QN_PUBSUB) {
+ HandlePubsubIqGetResponse(stanza);
+ }
+
+ return STATE_RESPONSE;
+}
+
+// Registers a function pointer to be called when the value of the pubsub
+// node changes.
+// Note that this does not actually change the XMPP pubsub
+// subscription. All publish events are always received by everyone in the
+// MUC. This function just controls whether the handle function will get
+// called when the event is received.
+bool PubsubTask::SubscribeToNode(const std::string& pubsub_node,
+ NodeHandler handler) {
+ subscribed_nodes_[pubsub_node] = handler;
+ talk_base::scoped_ptr<buzz::XmlElement> get_iq_request(
+ MakeIq(buzz::STR_GET, pubsub_node_jid_, task_id()));
+ if (get_iq_request.get() == NULL) {
+ return false;
+ }
+ buzz::XmlElement* pubsub_element = new buzz::XmlElement(QN_PUBSUB, true);
+ buzz::XmlElement* items_element = new buzz::XmlElement(QN_PUBSUB_ITEMS, true);
+
+ items_element->AddAttr(buzz::QN_NODE, pubsub_node);
+ pubsub_element->AddElement(items_element);
+ get_iq_request->AddElement(pubsub_element);
+
+ if (SendStanza(get_iq_request.get()) != buzz::XMPP_RETURN_OK) {
+ return false;
+ }
+
+ return true;
+}
+
+void PubsubTask::UnsubscribeFromNode(const std::string& pubsub_node) {
+ subscribed_nodes_.erase(pubsub_node);
+}
+
+void PubsubTask::OnPubsubError(const buzz::XmlElement* error_stanza) {
+}
+
+// Checks for a pubsub event message like the following:
+//
+// <message from="muvc-private-chat-some-id@groupchat.google.com"
+// to="john@site.com/gcomm582B14C9">
+// <event xmlns:"http://jabber.org/protocol/pubsub#event">
+// <items node="node-name">
+// <item id="some-id">
+// <payload/>
+// </item>
+// </items>
+// </event>
+// </message>
+//
+// It also checks for retraction event messages like the following:
+//
+// <message from="muvc-private-chat-some-id@groupchat.google.com"
+// to="john@site.com/gcomm582B14C9">
+// <event xmlns:"http://jabber.org/protocol/pubsub#event">
+// <items node="node-name">
+// <retract id="some-id"/>
+// </items>
+// </event>
+// </message>
+void PubsubTask::HandlePubsubEventMessage(
+ const buzz::XmlElement* pubsub_event) {
+ ASSERT(pubsub_event->Name() == QN_PUBSUB_EVENT);
+ for (const buzz::XmlChild* child = pubsub_event->FirstChild();
+ child != NULL;
+ child = child->NextChild()) {
+ const buzz::XmlElement* child_element = child->AsElement();
+ const buzz::QName& child_name(child_element->Name());
+ if (child_name == QN_PUBSUB_EVENT_ITEMS) {
+ HandlePubsubItems(child_element);
+ }
+ }
+}
+
+// Checks for a response to an pubsub IQ get like the following:
+//
+// <iq from="muvc-private-chat-some-id@groupchat.google.com"
+// to="john@site.com/gcomm582B14C9"
+// type="result">
+// <pubsub xmlns:"http://jabber.org/protocol/pubsub">
+// <items node="node-name">
+// <item id="some-id">
+// <payload/>
+// </item>
+// </items>
+// </event>
+// </message>
+void PubsubTask::HandlePubsubIqGetResponse(
+ const buzz::XmlElement* pubsub_iq_response) {
+ ASSERT(pubsub_iq_response->Name() == QN_PUBSUB);
+ for (const buzz::XmlChild* child = pubsub_iq_response->FirstChild();
+ child != NULL;
+ child = child->NextChild()) {
+ const buzz::XmlElement* child_element = child->AsElement();
+ const buzz::QName& child_name(child_element->Name());
+ if (child_name == QN_PUBSUB_ITEMS) {
+ HandlePubsubItems(child_element);
+ }
+ }
+}
+
+// Calls registered handlers in response to pubsub event or response to
+// IQ pubsub get.
+// 'items' is the child of a pubsub#event:event node or pubsub:pubsub node.
+void PubsubTask::HandlePubsubItems(const buzz::XmlElement* items) {
+ ASSERT(items->HasAttr(QN_NODE));
+ const std::string& node_name(items->Attr(QN_NODE));
+ NodeSubscriptions::iterator iter = subscribed_nodes_.find(node_name);
+ if (iter != subscribed_nodes_.end()) {
+ NodeHandler handler = iter->second;
+ const buzz::XmlElement* item = items->FirstElement();
+ while (item != NULL) {
+ const buzz::QName& item_name(item->Name());
+ if (item_name != QN_PUBSUB_EVENT_ITEM &&
+ item_name != QN_PUBSUB_EVENT_RETRACT &&
+ item_name != QN_PUBSUB_ITEM) {
+ continue;
+ }
+
+ (this->*handler)(item);
+ item = item->NextElement();
+ }
+ return;
+ }
+}
+
+}
diff --git a/talk/xmpp/pubsub_task.h b/talk/xmpp/pubsub_task.h
new file mode 100644
index 0000000..45a7462
--- /dev/null
+++ b/talk/xmpp/pubsub_task.h
@@ -0,0 +1,75 @@
+/*
+ * libjingle
+ * Copyright 2004--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_XMPP_PUBSUB_TASK_H_
+#define TALK_XMPP_PUBSUB_TASK_H_
+
+#include <map>
+#include <string>
+#include "talk/xmllite/xmlelement.h"
+#include "talk/xmpp/jid.h"
+#include "talk/xmpp/xmpptask.h"
+
+namespace buzz {
+
+// Base class to help write pubsub tasks.
+// In ProcessStart call SubscribeNode with namespaces of interest along with
+// NodeHandlers.
+// When pubsub notifications arrive and matches the namespace, the NodeHandlers
+// will be called back.
+class PubsubTask : public buzz::XmppTask {
+ public:
+ virtual ~PubsubTask();
+
+ protected:
+ typedef void (PubsubTask::*NodeHandler)(const buzz::XmlElement* node);
+
+ PubsubTask(XmppTaskParentInterface* parent, const buzz::Jid& pubsub_node_jid);
+
+ virtual bool HandleStanza(const buzz::XmlElement* stanza);
+ virtual int ProcessResponse();
+
+ bool SubscribeToNode(const std::string& pubsub_node, NodeHandler handler);
+ void UnsubscribeFromNode(const std::string& pubsub_node);
+
+ // Called when there is an error. Derived class can do what it needs to.
+ virtual void OnPubsubError(const buzz::XmlElement* error_stanza);
+
+ private:
+ typedef std::map<std::string, NodeHandler> NodeSubscriptions;
+
+ void HandlePubsubIqGetResponse(const buzz::XmlElement* pubsub_iq_response);
+ void HandlePubsubEventMessage(const buzz::XmlElement* pubsub_event_message);
+ void HandlePubsubItems(const buzz::XmlElement* items);
+
+ buzz::Jid pubsub_node_jid_;
+ NodeSubscriptions subscribed_nodes_;
+};
+
+} // namespace buzz
+
+#endif // TALK_XMPP_PUBSUB_TASK_H_
diff --git a/talk/xmpp/pubsubclient_unittest.cc b/talk/xmpp/pubsubclient_unittest.cc
new file mode 100644
index 0000000..2e4c511
--- /dev/null
+++ b/talk/xmpp/pubsubclient_unittest.cc
@@ -0,0 +1,271 @@
+// Copyright 2011 Google Inc. All Rights Reserved
+
+
+#include <string>
+
+#include "talk/base/faketaskrunner.h"
+#include "talk/base/gunit.h"
+#include "talk/base/sigslot.h"
+#include "talk/xmllite/qname.h"
+#include "talk/xmllite/xmlelement.h"
+#include "talk/xmpp/constants.h"
+#include "talk/xmpp/fakexmppclient.h"
+#include "talk/xmpp/jid.h"
+#include "talk/xmpp/pubsubclient.h"
+
+struct HandledPubSubItem {
+ std::string itemid;
+ std::string payload;
+};
+
+class TestPubSubItemsListener : public sigslot::has_slots<> {
+ public:
+ TestPubSubItemsListener() : error_count(0) {}
+
+ void OnItems(buzz::PubSubClient*,
+ const std::vector<buzz::PubSubItem>& items) {
+ for (std::vector<buzz::PubSubItem>::const_iterator item = items.begin();
+ item != items.end(); ++item) {
+ HandledPubSubItem handled_item;
+ handled_item.itemid = item->itemid;
+ if (item->elem->FirstElement() != NULL) {
+ handled_item.payload = item->elem->FirstElement()->Str();
+ }
+ this->items.push_back(handled_item);
+ }
+ }
+
+ void OnRequestError(buzz::PubSubClient* client,
+ const buzz::XmlElement* stanza) {
+ error_count++;
+ }
+
+ void OnPublishResult(buzz::PubSubClient* client,
+ const std::string& task_id,
+ const buzz::XmlElement* item) {
+ result_task_id = task_id;
+ }
+
+ void OnPublishError(buzz::PubSubClient* client,
+ const std::string& task_id,
+ const buzz::XmlElement* item,
+ const buzz::XmlElement* stanza) {
+ error_count++;
+ error_task_id = task_id;
+ }
+
+ void OnRetractResult(buzz::PubSubClient* client,
+ const std::string& task_id) {
+ result_task_id = task_id;
+ }
+
+ void OnRetractError(buzz::PubSubClient* client,
+ const std::string& task_id,
+ const buzz::XmlElement* stanza) {
+ error_count++;
+ error_task_id = task_id;
+ }
+
+ std::vector<HandledPubSubItem> items;
+ int error_count;
+ std::string error_task_id;
+ std::string result_task_id;
+};
+
+class PubSubClientTest : public testing::Test {
+ public:
+ PubSubClientTest() :
+ pubsubjid("room@domain.com"),
+ node("topic"),
+ itemid("key") {
+ runner.reset(new talk_base::FakeTaskRunner());
+ xmpp_client = new buzz::FakeXmppClient(runner.get());
+ client.reset(new buzz::PubSubClient(xmpp_client, pubsubjid, node));
+ listener.reset(new TestPubSubItemsListener());
+ client->SignalItems.connect(
+ listener.get(), &TestPubSubItemsListener::OnItems);
+ client->SignalRequestError.connect(
+ listener.get(), &TestPubSubItemsListener::OnRequestError);
+ client->SignalPublishResult.connect(
+ listener.get(), &TestPubSubItemsListener::OnPublishResult);
+ client->SignalPublishError.connect(
+ listener.get(), &TestPubSubItemsListener::OnPublishError);
+ client->SignalRetractResult.connect(
+ listener.get(), &TestPubSubItemsListener::OnRetractResult);
+ client->SignalRetractError.connect(
+ listener.get(), &TestPubSubItemsListener::OnRetractError);
+ }
+
+ talk_base::scoped_ptr<talk_base::FakeTaskRunner> runner;
+ // xmpp_client deleted by deleting runner.
+ buzz::FakeXmppClient* xmpp_client;
+ talk_base::scoped_ptr<buzz::PubSubClient> client;
+ talk_base::scoped_ptr<TestPubSubItemsListener> listener;
+ buzz::Jid pubsubjid;
+ std::string node;
+ std::string itemid;
+};
+
+TEST_F(PubSubClientTest, TestRequest) {
+ client->RequestItems();
+
+ std::string expected_iq =
+ "<cli:iq type=\"get\" to=\"room@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<pub:pubsub xmlns:pub=\"http://jabber.org/protocol/pubsub\">"
+ "<pub:items node=\"topic\"/>"
+ "</pub:pubsub>"
+ "</cli:iq>";
+
+ ASSERT_EQ(1U, xmpp_client->sent_stanzas().size());
+ EXPECT_EQ(expected_iq, xmpp_client->sent_stanzas()[0]->Str());
+
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'>"
+ " <pubsub xmlns='http://jabber.org/protocol/pubsub'>"
+ " <items node='topic'>"
+ " <item id='key0'>"
+ " <value0a/>"
+ " </item>"
+ " <item id='key1'>"
+ " <value1a/>"
+ " </item>"
+ " </items>"
+ " </pubsub>"
+ "</iq>";
+
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+ ASSERT_EQ(2U, listener->items.size());
+ EXPECT_EQ("key0", listener->items[0].itemid);
+ EXPECT_EQ("<pub:value0a xmlns:pub=\"http://jabber.org/protocol/pubsub\"/>",
+ listener->items[0].payload);
+ EXPECT_EQ("key1", listener->items[1].itemid);
+ EXPECT_EQ("<pub:value1a xmlns:pub=\"http://jabber.org/protocol/pubsub\"/>",
+ listener->items[1].payload);
+
+ std::string items_message =
+ "<message xmlns='jabber:client' from='room@domain.com'>"
+ " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
+ " <items node='topic'>"
+ " <item id='key0'>"
+ " <value0b/>"
+ " </item>"
+ " <item id='key1'>"
+ " <value1b/>"
+ " </item>"
+ " </items>"
+ " </event>"
+ "</message>";
+
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(items_message));
+ ASSERT_EQ(4U, listener->items.size());
+ EXPECT_EQ("key0", listener->items[2].itemid);
+ EXPECT_EQ("<eve:value0b"
+ " xmlns:eve=\"http://jabber.org/protocol/pubsub#event\"/>",
+ listener->items[2].payload);
+ EXPECT_EQ("key1", listener->items[3].itemid);
+ EXPECT_EQ("<eve:value1b"
+ " xmlns:eve=\"http://jabber.org/protocol/pubsub#event\"/>",
+ listener->items[3].payload);
+}
+
+TEST_F(PubSubClientTest, TestRequestError) {
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'>"
+ " <error type='auth'>"
+ " <forbidden xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>"
+ " </error>"
+ "</iq>";
+
+ client->RequestItems();
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+ EXPECT_EQ(1, listener->error_count);
+}
+
+TEST_F(PubSubClientTest, TestPublish) {
+ buzz::XmlElement* payload =
+ new buzz::XmlElement(buzz::QName(buzz::NS_PUBSUB, "value"));
+
+ std::string task_id;
+ client->PublishItem(itemid, payload, &task_id);
+
+ std::string expected_iq =
+ "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
+ "<publish node=\"topic\">"
+ "<item id=\"key\">"
+ "<value/>"
+ "</item>"
+ "</publish>"
+ "</pubsub>"
+ "</cli:iq>";
+
+ ASSERT_EQ(1U, xmpp_client->sent_stanzas().size());
+ EXPECT_EQ(expected_iq, xmpp_client->sent_stanzas()[0]->Str());
+
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'/>";
+
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+ EXPECT_EQ(task_id, listener->result_task_id);
+}
+
+TEST_F(PubSubClientTest, TestPublishError) {
+ buzz::XmlElement* payload =
+ new buzz::XmlElement(buzz::QName(buzz::NS_PUBSUB, "value"));
+
+ std::string task_id;
+ client->PublishItem(itemid, payload, &task_id);
+
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'>"
+ " <error type='auth'>"
+ " <forbidden xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>"
+ " </error>"
+ "</iq>";
+
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+ EXPECT_EQ(1, listener->error_count);
+ EXPECT_EQ(task_id, listener->error_task_id);
+}
+
+TEST_F(PubSubClientTest, TestRetract) {
+ std::string task_id;
+ client->RetractItem(itemid, &task_id);
+
+ std::string expected_iq =
+ "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
+ "<retract node=\"topic\" notify=\"true\">"
+ "<item id=\"key\"/>"
+ "</retract>"
+ "</pubsub>"
+ "</cli:iq>";
+
+ ASSERT_EQ(1U, xmpp_client->sent_stanzas().size());
+ EXPECT_EQ(expected_iq, xmpp_client->sent_stanzas()[0]->Str());
+
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'/>";
+
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+ EXPECT_EQ(task_id, listener->result_task_id);
+}
+
+TEST_F(PubSubClientTest, TestRetractError) {
+ std::string task_id;
+ client->RetractItem(itemid, &task_id);
+
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'>"
+ " <error type='auth'>"
+ " <forbidden xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>"
+ " </error>"
+ "</iq>";
+
+ xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+ EXPECT_EQ(1, listener->error_count);
+ EXPECT_EQ(task_id, listener->error_task_id);
+}
diff --git a/talk/xmpp/pubsubtasks_unittest.cc b/talk/xmpp/pubsubtasks_unittest.cc
new file mode 100644
index 0000000..67fc306
--- /dev/null
+++ b/talk/xmpp/pubsubtasks_unittest.cc
@@ -0,0 +1,273 @@
+// Copyright 2011 Google Inc. All Rights Reserved
+
+
+#include <string>
+
+#include "talk/base/faketaskrunner.h"
+#include "talk/base/gunit.h"
+#include "talk/base/sigslot.h"
+#include "talk/xmllite/qname.h"
+#include "talk/xmllite/xmlelement.h"
+#include "talk/xmpp/constants.h"
+#include "talk/xmpp/iqtask.h"
+#include "talk/xmpp/fakexmppclient.h"
+#include "talk/xmpp/jid.h"
+#include "talk/xmpp/pubsubtasks.h"
+
+struct HandledPubSubItem {
+ std::string itemid;
+ std::string payload;
+};
+
+class TestPubSubTasksListener : public sigslot::has_slots<> {
+ public:
+ TestPubSubTasksListener() : result_count(0), error_count(0) {}
+
+ void OnReceiveUpdate(buzz::PubSubReceiveTask* task,
+ const std::vector<buzz::PubSubItem>& items) {
+ OnItems(items);
+ }
+
+ void OnRequestResult(buzz::PubSubRequestTask* task,
+ const std::vector<buzz::PubSubItem>& items) {
+ OnItems(items);
+ }
+
+ void OnItems(const std::vector<buzz::PubSubItem>& items) {
+ for (std::vector<buzz::PubSubItem>::const_iterator item = items.begin();
+ item != items.end(); ++item) {
+ HandledPubSubItem handled_item;
+ handled_item.itemid = item->itemid;
+ if (item->elem->FirstElement() != NULL) {
+ handled_item.payload = item->elem->FirstElement()->Str();
+ }
+ this->items.push_back(handled_item);
+ }
+ }
+
+ void OnPublishResult(buzz::PubSubPublishTask* task) {
+ ++result_count;
+ }
+
+ void OnRetractResult(buzz::PubSubRetractTask* task) {
+ ++result_count;
+ }
+
+ void OnError(buzz::IqTask* task, const buzz::XmlElement* stanza) {
+ ++error_count;
+ }
+
+ std::vector<HandledPubSubItem> items;
+ int result_count;
+ int error_count;
+};
+
+class PubSubTasksTest : public testing::Test {
+ public:
+ PubSubTasksTest() :
+ pubsubjid("room@domain.com"),
+ node("topic"),
+ itemid("key") {
+ runner.reset(new talk_base::FakeTaskRunner());
+ client = new buzz::FakeXmppClient(runner.get());
+ listener.reset(new TestPubSubTasksListener());
+ }
+
+ talk_base::scoped_ptr<talk_base::FakeTaskRunner> runner;
+ // Client deleted by deleting runner.
+ buzz::FakeXmppClient* client;
+ talk_base::scoped_ptr<TestPubSubTasksListener> listener;
+ buzz::Jid pubsubjid;
+ std::string node;
+ std::string itemid;
+};
+
+TEST_F(PubSubTasksTest, TestRequest) {
+ buzz::PubSubRequestTask* task =
+ new buzz::PubSubRequestTask(client, pubsubjid, node);
+ task->SignalResult.connect(
+ listener.get(), &TestPubSubTasksListener::OnRequestResult);
+ task->Start();
+
+ std::string expected_iq =
+ "<cli:iq type=\"get\" to=\"room@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<pub:pubsub xmlns:pub=\"http://jabber.org/protocol/pubsub\">"
+ "<pub:items node=\"topic\"/>"
+ "</pub:pubsub>"
+ "</cli:iq>";
+
+ ASSERT_EQ(1U, client->sent_stanzas().size());
+ EXPECT_EQ(expected_iq, client->sent_stanzas()[0]->Str());
+
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'>"
+ " <pubsub xmlns='http://jabber.org/protocol/pubsub'>"
+ " <items node='topic'>"
+ " <item id='key0'>"
+ " <value0/>"
+ " </item>"
+ " <item id='key1'>"
+ " <value1/>"
+ " </item>"
+ " </items>"
+ " </pubsub>"
+ "</iq>";
+
+ client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+
+ ASSERT_EQ(2U, listener->items.size());
+ EXPECT_EQ("key0", listener->items[0].itemid);
+ EXPECT_EQ("<pub:value0 xmlns:pub=\"http://jabber.org/protocol/pubsub\"/>",
+ listener->items[0].payload);
+ EXPECT_EQ("key1", listener->items[1].itemid);
+ EXPECT_EQ("<pub:value1 xmlns:pub=\"http://jabber.org/protocol/pubsub\"/>",
+ listener->items[1].payload);
+}
+
+TEST_F(PubSubTasksTest, TestRequestError) {
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'>"
+ " <error type='auth'>"
+ " <forbidden xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>"
+ " </error>"
+ "</iq>";
+
+ buzz::PubSubRequestTask* task =
+ new buzz::PubSubRequestTask(client, pubsubjid, node);
+ task->SignalResult.connect(
+ listener.get(), &TestPubSubTasksListener::OnRequestResult);
+ task->SignalError.connect(
+ listener.get(), &TestPubSubTasksListener::OnError);
+ task->Start();
+ client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+
+ EXPECT_EQ(0, listener->result_count);
+ EXPECT_EQ(1, listener->error_count);
+}
+
+TEST_F(PubSubTasksTest, TestReceive) {
+ std::string items_message =
+ "<message xmlns='jabber:client' from='room@domain.com'>"
+ " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
+ " <items node='topic'>"
+ " <item id='key0'>"
+ " <value0/>"
+ " </item>"
+ " <item id='key1'>"
+ " <value1/>"
+ " </item>"
+ " </items>"
+ " </event>"
+ "</message>";
+
+ buzz::PubSubReceiveTask* task =
+ new buzz::PubSubReceiveTask(client, pubsubjid, node);
+ task->SignalUpdate.connect(
+ listener.get(), &TestPubSubTasksListener::OnReceiveUpdate);
+ task->Start();
+ client->HandleStanza(buzz::XmlElement::ForStr(items_message));
+
+ ASSERT_EQ(2U, listener->items.size());
+ EXPECT_EQ("key0", listener->items[0].itemid);
+ EXPECT_EQ(
+ "<eve:value0 xmlns:eve=\"http://jabber.org/protocol/pubsub#event\"/>",
+ listener->items[0].payload);
+ EXPECT_EQ("key1", listener->items[1].itemid);
+ EXPECT_EQ(
+ "<eve:value1 xmlns:eve=\"http://jabber.org/protocol/pubsub#event\"/>",
+ listener->items[1].payload);
+}
+
+TEST_F(PubSubTasksTest, TestPublish) {
+ buzz::XmlElement* payload =
+ new buzz::XmlElement(buzz::QName(buzz::NS_PUBSUB, "value"));
+ std::string expected_iq =
+ "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
+ "<publish node=\"topic\">"
+ "<item id=\"key\">"
+ "<value/>"
+ "</item>"
+ "</publish>"
+ "</pubsub>"
+ "</cli:iq>";
+
+ std::vector<buzz::XmlElement*> children;
+ children.push_back(payload);
+ buzz::PubSubPublishTask* task =
+ new buzz::PubSubPublishTask(client, pubsubjid, node, itemid, children);
+ task->SignalResult.connect(
+ listener.get(), &TestPubSubTasksListener::OnPublishResult);
+ task->Start();
+
+ ASSERT_EQ(1U, client->sent_stanzas().size());
+ EXPECT_EQ(expected_iq, client->sent_stanzas()[0]->Str());
+
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'/>";
+
+ client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+
+ EXPECT_EQ(1, listener->result_count);
+ EXPECT_EQ(0, listener->error_count);
+}
+
+TEST_F(PubSubTasksTest, TestPublishError) {
+ buzz::XmlElement* payload =
+ new buzz::XmlElement(buzz::QName(buzz::NS_PUBSUB, "value"));
+
+ std::vector<buzz::XmlElement*> children;
+ children.push_back(payload);
+ buzz::PubSubPublishTask* task =
+ new buzz::PubSubPublishTask(client, pubsubjid, node, itemid, children);
+ task->SignalResult.connect(
+ listener.get(), &TestPubSubTasksListener::OnPublishResult);
+ task->SignalError.connect(
+ listener.get(), &TestPubSubTasksListener::OnError);
+ task->Start();
+
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'>"
+ " <error type='auth'>"
+ " <forbidden xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>"
+ " </error>"
+ "</iq>";
+
+ client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+
+ EXPECT_EQ(0, listener->result_count);
+ EXPECT_EQ(1, listener->error_count);
+}
+
+TEST_F(PubSubTasksTest, TestRetract) {
+ buzz::PubSubRetractTask* task =
+ new buzz::PubSubRetractTask(client, pubsubjid, node, itemid);
+ task->SignalResult.connect(
+ listener.get(), &TestPubSubTasksListener::OnRetractResult);
+ task->SignalError.connect(
+ listener.get(), &TestPubSubTasksListener::OnError);
+ task->Start();
+
+ std::string expected_iq =
+ "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
+ "xmlns:cli=\"jabber:client\">"
+ "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
+ "<retract node=\"topic\" notify=\"true\">"
+ "<item id=\"key\"/>"
+ "</retract>"
+ "</pubsub>"
+ "</cli:iq>";
+
+ ASSERT_EQ(1U, client->sent_stanzas().size());
+ EXPECT_EQ(expected_iq, client->sent_stanzas()[0]->Str());
+
+ std::string result_iq =
+ "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'/>";
+
+ client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
+
+ EXPECT_EQ(1, listener->result_count);
+ EXPECT_EQ(0, listener->error_count);
+}
diff --git a/talk/xmpp/ratelimitmanager.h b/talk/xmpp/ratelimitmanager.h
index 1a7fc82..288084f 100644
--- a/talk/xmpp/ratelimitmanager.h
+++ b/talk/xmpp/ratelimitmanager.h
@@ -28,7 +28,7 @@
#ifndef _RATELIMITMANAGER_H_
#define _RATELIMITMANAGER_H_
-#include "talk/base/time.h"
+#include "talk/base/timeutils.h"
#include "talk/base/taskrunner.h"
#include <map>
diff --git a/talk/xmpp/rostermodule.h b/talk/xmpp/rostermodule.h
new file mode 100644
index 0000000..e81c4f0
--- /dev/null
+++ b/talk/xmpp/rostermodule.h
@@ -0,0 +1,325 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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 _rostermodule_h_
+#define _rostermodule_h_
+
+#include "talk/xmpp/module.h"
+
+namespace buzz {
+
+class XmppRosterModule;
+
+// The main way you initialize and use the module would be like this:
+// XmppRosterModule *roster_module = XmppRosterModule::Create();
+// roster_module->RegisterEngine(engine);
+// roster_module->BroadcastPresence();
+// roster_module->RequestRosterUpdate();
+
+//! This enum captures the valid values for the show attribute in a presence
+//! stanza
+enum XmppPresenceShow
+{
+ XMPP_PRESENCE_CHAT = 0,
+ XMPP_PRESENCE_DEFAULT = 1,
+ XMPP_PRESENCE_AWAY = 2,
+ XMPP_PRESENCE_XA = 3,
+ XMPP_PRESENCE_DND = 4,
+};
+
+//! These are the valid subscription states in a roster contact. This
+//! represents the combination of the subscription and ask attributes
+enum XmppSubscriptionState
+{
+ XMPP_SUBSCRIPTION_NONE = 0,
+ XMPP_SUBSCRIPTION_NONE_ASKED = 1,
+ XMPP_SUBSCRIPTION_TO = 2,
+ XMPP_SUBSCRIPTION_FROM = 3,
+ XMPP_SUBSCRIPTION_FROM_ASKED = 4,
+ XMPP_SUBSCRIPTION_BOTH = 5,
+};
+
+//! These represent the valid types of presence stanzas for managing
+//! subscriptions
+enum XmppSubscriptionRequestType
+{
+ XMPP_REQUEST_SUBSCRIBE = 0,
+ XMPP_REQUEST_UNSUBSCRIBE = 1,
+ XMPP_REQUEST_SUBSCRIBED = 2,
+ XMPP_REQUEST_UNSUBSCRIBED = 3,
+};
+
+enum XmppPresenceAvailable {
+ XMPP_PRESENCE_UNAVAILABLE = 0,
+ XMPP_PRESENCE_AVAILABLE = 1,
+ XMPP_PRESENCE_ERROR = 2,
+};
+
+//! Presence Information
+//! This class stores both presence information for outgoing presence and is
+//! returned by methods in XmppRosterModule to represent recieved incoming
+//! presence information. When this class is writeable (non-const) then each
+//! update to any property will set the inner xml. Setting the raw_xml will
+//! rederive all of the other properties.
+class XmppPresence {
+public:
+ virtual ~XmppPresence() {}
+
+ //! Create a new Presence
+ //! This is typically only used when sending a directed presence
+ static XmppPresence* Create();
+
+ //! The Jid of for the presence information.
+ //! Typically this will be a full Jid with resource specified.
+ virtual const Jid jid() const = 0;
+
+ //! Is the contact available?
+ virtual XmppPresenceAvailable available() const = 0;
+
+ //! Sets if the user is available or not
+ virtual XmppReturnStatus set_available(XmppPresenceAvailable available) = 0;
+
+ //! The show value of the presence info
+ virtual XmppPresenceShow presence_show() const = 0;
+
+ //! Set the presence show value
+ virtual XmppReturnStatus set_presence_show(XmppPresenceShow show) = 0;
+
+ //! The Priority of the presence info
+ virtual int priority() const = 0;
+
+ //! Set the priority of the presence
+ virtual XmppReturnStatus set_priority(int priority) = 0;
+
+ //! The plain text status of the presence info.
+ //! If there are multiple status because of language, this will either be a
+ //! status that is not tagged for language or the first available
+ virtual const std::string& status() const = 0;
+
+ //! Sets the status for the presence info.
+ //! If there is more than one status present already then this will remove
+ //! them all and replace it with one status element we no specified language
+ virtual XmppReturnStatus set_status(const std::string& status) = 0;
+
+ //! The raw xml of the presence update
+ virtual const XmlElement* raw_xml() const = 0;
+
+ //! Sets the raw presence stanza for the presence update
+ //! This will cause all other data items in this structure to be rederived
+ virtual XmppReturnStatus set_raw_xml(const XmlElement * xml) = 0;
+};
+
+//! A contact as given by the server
+class XmppRosterContact {
+public:
+ virtual ~XmppRosterContact() {}
+
+ //! Create a new roster contact
+ //! This is typically only used when doing a roster update/add
+ static XmppRosterContact* Create();
+
+ //! The jid for the contact.
+ //! Typically this will be a bare Jid.
+ virtual const Jid jid() const = 0;
+
+ //! Sets the jid for the roster contact update
+ virtual XmppReturnStatus set_jid(const Jid& jid) = 0;
+
+ //! The name (nickname) stored for this contact
+ virtual const std::string& name() const = 0;
+
+ //! Sets the name
+ virtual XmppReturnStatus set_name(const std::string& name) = 0;
+
+ //! The Presence subscription state stored on the server for this contact
+ //! This is never settable and will be ignored when generating a roster
+ //! add/update request
+ virtual XmppSubscriptionState subscription_state() const = 0;
+
+ //! The number of Groups applied to this contact
+ virtual size_t GetGroupCount() const = 0;
+
+ //! Gets a Group applied to the contact based on index.
+ //! range
+ virtual const std::string& GetGroup(size_t index) const = 0;
+
+ //! Adds a group to this contact.
+ //! This will return a bad argument error if the group is already there.
+ virtual XmppReturnStatus AddGroup(const std::string& group) = 0;
+
+ //! Removes a group from the contact.
+ //! This will return an error if the group cannot be found in the group list.
+ virtual XmppReturnStatus RemoveGroup(const std::string& group) = 0;
+
+ //! The raw xml for this roster contact
+ virtual const XmlElement* raw_xml() const = 0;
+
+ //! Sets the raw presence stanza for the contact update/add
+ //! This will cause all other data items in this structure to be rederived
+ virtual XmppReturnStatus set_raw_xml(const XmlElement * xml) = 0;
+};
+
+//! The XmppRosterHandler is an interface for callbacks from the module
+class XmppRosterHandler {
+public:
+ //! A request for a subscription has come in.
+ //! Typically, the UI will ask the user if it is okay to let the requester
+ //! get presence notifications for the user. The response is send back
+ //! by calling ApproveSubscriber or CancelSubscriber.
+ virtual void SubscriptionRequest(XmppRosterModule* roster,
+ const Jid& requesting_jid,
+ XmppSubscriptionRequestType type,
+ const XmlElement* raw_xml) = 0;
+
+ //! Some type of presence error has occured
+ virtual void SubscriptionError(XmppRosterModule* roster,
+ const Jid& from,
+ const XmlElement* raw_xml) = 0;
+
+ virtual void RosterError(XmppRosterModule* roster,
+ const XmlElement* raw_xml) = 0;
+
+ //! New presence information has come in
+ //! The user is notified with the presence object directly. This info is also
+ //! added to the store accessable from the engine.
+ virtual void IncomingPresenceChanged(XmppRosterModule* roster,
+ const XmppPresence* presence) = 0;
+
+ //! A contact has changed
+ //! This indicates that the data for a contact may have changed. No
+ //! contacts have been added or removed.
+ virtual void ContactChanged(XmppRosterModule* roster,
+ const XmppRosterContact* old_contact,
+ size_t index) = 0;
+
+ //! A set of contacts have been added
+ //! These contacts may have been added in response to the original roster
+ //! request or due to a "roster push" from the server.
+ virtual void ContactsAdded(XmppRosterModule* roster,
+ size_t index, size_t number) = 0;
+
+ //! A contact has been removed
+ //! This contact has been removed form the list.
+ virtual void ContactRemoved(XmppRosterModule* roster,
+ const XmppRosterContact* removed_contact,
+ size_t index) = 0;
+
+};
+
+//! An XmppModule for handle roster and presence functionality
+class XmppRosterModule : public XmppModule {
+public:
+ //! Creates a new XmppRosterModule
+ static XmppRosterModule * Create();
+ virtual ~XmppRosterModule() {}
+
+ //! Sets the roster handler (callbacks) for the module
+ virtual XmppReturnStatus set_roster_handler(XmppRosterHandler * handler) = 0;
+
+ //! Gets the roster handler for the module
+ virtual XmppRosterHandler* roster_handler() = 0;
+
+ // USER PRESENCE STATE -------------------------------------------------------
+
+ //! Gets the aggregate outgoing presence
+ //! This object is non-const and be edited directly. No update is sent
+ //! to the server until a Broadcast is sent
+ virtual XmppPresence* outgoing_presence() = 0;
+
+ //! Broadcasts that the user is available.
+ //! Nothing with respect to presence is sent until this is called.
+ virtual XmppReturnStatus BroadcastPresence() = 0;
+
+ //! Sends a directed presence to a Jid
+ //! Note that the client doesn't store where directed presence notifications
+ //! have been sent. The server can keep the appropriate state
+ virtual XmppReturnStatus SendDirectedPresence(const XmppPresence* presence,
+ const Jid& to_jid) = 0;
+
+ // INCOMING PRESENCE STATUS --------------------------------------------------
+
+ //! Returns the number of incoming presence data recorded
+ virtual size_t GetIncomingPresenceCount() = 0;
+
+ //! Returns an incoming presence datum based on index
+ virtual const XmppPresence* GetIncomingPresence(size_t index) = 0;
+
+ //! Gets the number of presence data for a bare Jid
+ //! There may be a datum per resource
+ virtual size_t GetIncomingPresenceForJidCount(const Jid& jid) = 0;
+
+ //! Returns a single presence data for a Jid based on index
+ virtual const XmppPresence* GetIncomingPresenceForJid(const Jid& jid,
+ size_t index) = 0;
+
+ // ROSTER MANAGEMENT ---------------------------------------------------------
+
+ //! Requests an update of the roster from the server
+ //! This must be called to initialize the client side cache of the roster
+ //! After this is sent the server should keep this module apprised of any
+ //! changes.
+ virtual XmppReturnStatus RequestRosterUpdate() = 0;
+
+ //! Returns the number of contacts in the roster
+ virtual size_t GetRosterContactCount() = 0;
+
+ //! Returns a contact by index
+ virtual const XmppRosterContact* GetRosterContact(size_t index) = 0;
+
+ //! Finds a contact by Jid
+ virtual const XmppRosterContact* FindRosterContact(const Jid& jid) = 0;
+
+ //! Send a request to the server to add a contact
+ //! Note that the contact won't show up in the roster until the server can
+ //! respond. This happens async when the socket is being serviced
+ virtual XmppReturnStatus RequestRosterChange(
+ const XmppRosterContact* contact) = 0;
+
+ //! Request that the server remove a contact
+ //! The jabber protocol specifies that the server should also cancel any
+ //! subscriptions when this is done. Like adding, this contact won't be
+ //! removed until the server responds.
+ virtual XmppReturnStatus RequestRosterRemove(const Jid& jid) = 0;
+
+ // SUBSCRIPTION MANAGEMENT ---------------------------------------------------
+
+ //! Request a subscription to presence notifications form a Jid
+ virtual XmppReturnStatus RequestSubscription(const Jid& jid) = 0;
+
+ //! Cancel a subscription to presence notifications from a Jid
+ virtual XmppReturnStatus CancelSubscription(const Jid& jid) = 0;
+
+ //! Approve a request to deliver presence notifications to a jid
+ virtual XmppReturnStatus ApproveSubscriber(const Jid& jid) = 0;
+
+ //! Deny or cancel presence notification deliver to a jid
+ virtual XmppReturnStatus CancelSubscriber(const Jid& jid) = 0;
+};
+
+}
+
+#endif
diff --git a/talk/xmpp/rostermoduleimpl.cc b/talk/xmpp/rostermoduleimpl.cc
new file mode 100644
index 0000000..c5da5a9
--- /dev/null
+++ b/talk/xmpp/rostermoduleimpl.cc
@@ -0,0 +1,1041 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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 <vector>
+#include <string>
+#include <map>
+#include <algorithm>
+#include <sstream>
+#include <iostream>
+#include "talk/base/common.h"
+#include "talk/base/stringencode.h"
+#include "talk/xmpp/constants.h"
+#include "talk/xmpp/rostermoduleimpl.h"
+
+namespace buzz {
+
+// enum prase and persist helpers ----------------------------------------------
+static bool
+StringToPresenceShow(const std::string& input, XmppPresenceShow* show)
+{
+ // If this becomes a perf issue we can use a hash or a map here
+ if (STR_SHOW_AWAY == input)
+ *show = XMPP_PRESENCE_AWAY;
+ else if (STR_SHOW_DND == input)
+ *show = XMPP_PRESENCE_DND;
+ else if (STR_SHOW_XA == input)
+ *show = XMPP_PRESENCE_XA;
+ else if (STR_SHOW_CHAT == input)
+ *show = XMPP_PRESENCE_CHAT;
+ else if (STR_EMPTY == input)
+ *show = XMPP_PRESENCE_DEFAULT;
+ else
+ return false;
+
+ return true;
+}
+
+static bool
+PresenceShowToString(XmppPresenceShow show, const std::string ** output)
+{
+ switch(show) {
+ case XMPP_PRESENCE_AWAY:
+ *output = &STR_SHOW_AWAY;
+ return true;
+ case XMPP_PRESENCE_CHAT:
+ *output = &STR_SHOW_CHAT;
+ return true;
+ case XMPP_PRESENCE_XA:
+ *output = &STR_SHOW_XA;
+ return true;
+ case XMPP_PRESENCE_DND:
+ *output = &STR_SHOW_DND;
+ return true;
+ case XMPP_PRESENCE_DEFAULT:
+ *output = &STR_EMPTY;
+ return true;
+ }
+
+ *output = &STR_EMPTY;
+ return false;
+}
+
+static bool
+StringToSubscriptionState(const std::string& subscription,
+ const std::string& ask,
+ XmppSubscriptionState* state)
+{
+ if (ask == "subscribe")
+ {
+ if (subscription == "none") {
+ *state = XMPP_SUBSCRIPTION_NONE_ASKED;
+ return true;
+ }
+ if (subscription == "from") {
+ *state = XMPP_SUBSCRIPTION_FROM_ASKED;
+ return true;
+ }
+ } else if (ask == STR_EMPTY)
+ {
+ if (subscription == "none") {
+ *state = XMPP_SUBSCRIPTION_NONE;
+ return true;
+ }
+ if (subscription == "from") {
+ *state = XMPP_SUBSCRIPTION_FROM;
+ return true;
+ }
+ if (subscription == "to") {
+ *state = XMPP_SUBSCRIPTION_TO;
+ return true;
+ }
+ if (subscription == "both") {
+ *state = XMPP_SUBSCRIPTION_BOTH;
+ return true;
+ }
+ }
+
+ return false;
+}
+
+static bool
+StringToSubscriptionRequestType(const std::string& string,
+ XmppSubscriptionRequestType* type)
+{
+ if (string == "subscribe")
+ *type = XMPP_REQUEST_SUBSCRIBE;
+ else if (string == "unsubscribe")
+ *type = XMPP_REQUEST_UNSUBSCRIBE;
+ else if (string == "subscribed")
+ *type = XMPP_REQUEST_SUBSCRIBED;
+ else if (string == "unsubscribed")
+ *type = XMPP_REQUEST_UNSUBSCRIBED;
+ else
+ return false;
+ return true;
+}
+
+// XmppPresenceImpl class ------------------------------------------------------
+XmppPresence*
+XmppPresence::Create() {
+ return new XmppPresenceImpl();
+}
+
+XmppPresenceImpl::XmppPresenceImpl() {
+}
+
+const Jid
+XmppPresenceImpl::jid() const {
+ if (!raw_xml_.get())
+ return JID_EMPTY;
+
+ return Jid(raw_xml_->Attr(QN_FROM));
+}
+
+XmppPresenceAvailable
+XmppPresenceImpl::available() const {
+ if (!raw_xml_.get())
+ return XMPP_PRESENCE_UNAVAILABLE;
+
+ if (raw_xml_->Attr(QN_TYPE) == "unavailable")
+ return XMPP_PRESENCE_UNAVAILABLE;
+ else if (raw_xml_->Attr(QN_TYPE) == "error")
+ return XMPP_PRESENCE_ERROR;
+ else
+ return XMPP_PRESENCE_AVAILABLE;
+}
+
+XmppReturnStatus
+XmppPresenceImpl::set_available(XmppPresenceAvailable available) {
+ if (!raw_xml_.get())
+ CreateRawXmlSkeleton();
+
+ if (available == XMPP_PRESENCE_AVAILABLE)
+ raw_xml_->ClearAttr(QN_TYPE);
+ else if (available == XMPP_PRESENCE_UNAVAILABLE)
+ raw_xml_->SetAttr(QN_TYPE, "unavailable");
+ else if (available == XMPP_PRESENCE_ERROR)
+ raw_xml_->SetAttr(QN_TYPE, "error");
+ return XMPP_RETURN_OK;
+}
+
+XmppPresenceShow
+XmppPresenceImpl::presence_show() const {
+ if (!raw_xml_.get())
+ return XMPP_PRESENCE_DEFAULT;
+
+ XmppPresenceShow show;
+
+ if (StringToPresenceShow(raw_xml_->TextNamed(QN_SHOW), &show))
+ return show;
+
+ return XMPP_PRESENCE_DEFAULT;
+}
+
+XmppReturnStatus
+XmppPresenceImpl::set_presence_show(XmppPresenceShow show) {
+ if (!raw_xml_.get())
+ CreateRawXmlSkeleton();
+
+ const std::string* show_string;
+
+ if(!PresenceShowToString(show, &show_string))
+ return XMPP_RETURN_BADARGUMENT;
+
+ raw_xml_->ClearNamedChildren(QN_SHOW);
+
+ if (show!=XMPP_PRESENCE_DEFAULT) {
+ raw_xml_->AddElement(new XmlElement(QN_SHOW));
+ raw_xml_->AddText(*show_string, 1);
+ }
+
+ return XMPP_RETURN_OK;
+}
+
+int
+XmppPresenceImpl::priority() const {
+ if (!raw_xml_.get())
+ return 0;
+
+ int raw_priority;
+ if (!talk_base::FromString(raw_xml_->TextNamed(QN_PRIORITY), &raw_priority))
+ raw_priority = 0;
+ if (raw_priority < -128)
+ raw_priority = -128;
+ if (raw_priority > 127)
+ raw_priority = 127;
+
+ return raw_priority;
+}
+
+XmppReturnStatus
+XmppPresenceImpl::set_priority(int priority) {
+ if (!raw_xml_.get())
+ CreateRawXmlSkeleton();
+
+ if (priority < -128 || priority > 127)
+ return XMPP_RETURN_BADARGUMENT;
+
+ raw_xml_->ClearNamedChildren(QN_PRIORITY);
+ if (0 != priority) {
+ std::string priority_string;
+ if (talk_base::ToString(priority, &priority_string)) {
+ raw_xml_->AddElement(new XmlElement(QN_PRIORITY));
+ raw_xml_->AddText(priority_string, 1);
+ }
+ }
+
+ return XMPP_RETURN_OK;
+}
+
+const std::string&
+XmppPresenceImpl::status() const {
+ if (!raw_xml_.get())
+ return STR_EMPTY;
+
+ XmlElement* status_element;
+ XmlElement* element;
+
+ // Search for a status element with no xml:lang attribute on it. if we can't
+ // find that then just return the first status element in the stanza.
+ for (status_element = element = raw_xml_->FirstNamed(QN_STATUS);
+ element;
+ element = element->NextNamed(QN_STATUS)) {
+ if (!element->HasAttr(QN_XML_LANG)) {
+ status_element = element;
+ break;
+ }
+ }
+
+ if (status_element) {
+ return status_element->BodyText();
+ }
+
+ return STR_EMPTY;
+}
+
+XmppReturnStatus
+XmppPresenceImpl::set_status(const std::string& status) {
+ if (!raw_xml_.get())
+ CreateRawXmlSkeleton();
+
+ raw_xml_->ClearNamedChildren(QN_STATUS);
+
+ if (status != STR_EMPTY) {
+ raw_xml_->AddElement(new XmlElement(QN_STATUS));
+ raw_xml_->AddText(status, 1);
+ }
+
+ return XMPP_RETURN_OK;
+}
+
+const XmlElement*
+XmppPresenceImpl::raw_xml() const {
+ if (!raw_xml_.get())
+ const_cast<XmppPresenceImpl*>(this)->CreateRawXmlSkeleton();
+ return raw_xml_.get();
+}
+
+XmppReturnStatus
+XmppPresenceImpl::set_raw_xml(const XmlElement * xml) {
+ if (!xml ||
+ xml->Name() != QN_PRESENCE)
+ return XMPP_RETURN_BADARGUMENT;
+
+ const std::string& type = xml->Attr(QN_TYPE);
+ if (type != STR_EMPTY && type != "unavailable")
+ return XMPP_RETURN_BADARGUMENT;
+
+ raw_xml_.reset(new XmlElement(*xml));
+
+ return XMPP_RETURN_OK;
+}
+
+void
+XmppPresenceImpl::CreateRawXmlSkeleton() {
+ raw_xml_.reset(new XmlElement(QN_PRESENCE));
+}
+
+// XmppRosterContactImpl -------------------------------------------------------
+XmppRosterContact*
+XmppRosterContact::Create() {
+ return new XmppRosterContactImpl();
+}
+
+XmppRosterContactImpl::XmppRosterContactImpl() {
+ ResetGroupCache();
+}
+
+void
+XmppRosterContactImpl::SetXmlFromWire(const XmlElement* xml) {
+ ResetGroupCache();
+ if (xml)
+ raw_xml_.reset(new XmlElement(*xml));
+ else
+ raw_xml_.reset(NULL);
+}
+
+void
+XmppRosterContactImpl::ResetGroupCache() {
+ group_count_ = -1;
+ group_index_returned_ = -1;
+ group_returned_ = NULL;
+}
+
+const Jid
+XmppRosterContactImpl::jid() const {
+ return Jid(raw_xml_->Attr(QN_JID));
+}
+
+XmppReturnStatus
+XmppRosterContactImpl::set_jid(const Jid& jid)
+{
+ if (!raw_xml_.get())
+ CreateRawXmlSkeleton();
+
+ if (!jid.IsValid())
+ return XMPP_RETURN_BADARGUMENT;
+
+ raw_xml_->SetAttr(QN_JID, jid.Str());
+
+ return XMPP_RETURN_OK;
+}
+
+const std::string&
+XmppRosterContactImpl::name() const {
+ return raw_xml_->Attr(QN_NAME);
+}
+
+XmppReturnStatus
+XmppRosterContactImpl::set_name(const std::string& name) {
+ if (!raw_xml_.get())
+ CreateRawXmlSkeleton();
+
+ if (name == STR_EMPTY)
+ raw_xml_->ClearAttr(QN_NAME);
+ else
+ raw_xml_->SetAttr(QN_NAME, name);
+
+ return XMPP_RETURN_OK;
+}
+
+XmppSubscriptionState
+XmppRosterContactImpl::subscription_state() const {
+ if (!raw_xml_.get())
+ return XMPP_SUBSCRIPTION_NONE;
+
+ XmppSubscriptionState state;
+
+ if (StringToSubscriptionState(raw_xml_->Attr(QN_SUBSCRIPTION),
+ raw_xml_->Attr(QN_ASK),
+ &state))
+ return state;
+
+ return XMPP_SUBSCRIPTION_NONE;
+}
+
+size_t
+XmppRosterContactImpl::GetGroupCount() const {
+ if (!raw_xml_.get())
+ return 0;
+
+ if (-1 == group_count_) {
+ XmlElement *group_element = raw_xml_->FirstNamed(QN_ROSTER_GROUP);
+ int group_count = 0;
+ while(group_element) {
+ group_count++;
+ group_element = group_element->NextNamed(QN_ROSTER_GROUP);
+ }
+
+ ASSERT(group_count > 0); // protect the cast
+ XmppRosterContactImpl * me = const_cast<XmppRosterContactImpl*>(this);
+ me->group_count_ = group_count;
+ }
+
+ return group_count_;
+}
+
+const std::string&
+XmppRosterContactImpl::GetGroup(size_t index) const {
+ if (index >= GetGroupCount())
+ return STR_EMPTY;
+
+ // We cache the last group index and element that we returned. This way
+ // going through the groups in order is order n and not n^2. This could be
+ // enhanced if necessary by starting at the cached value if the index asked
+ // is after the cached one.
+ if (group_index_returned_ >= 0 &&
+ index == static_cast<size_t>(group_index_returned_) + 1)
+ {
+ XmppRosterContactImpl * me = const_cast<XmppRosterContactImpl*>(this);
+ me->group_returned_ = group_returned_->NextNamed(QN_ROSTER_GROUP);
+ ASSERT(group_returned_ != NULL);
+ me->group_index_returned_++;
+ } else if (group_index_returned_ < 0 ||
+ static_cast<size_t>(group_index_returned_) != index) {
+ XmlElement * group_element = raw_xml_->FirstNamed(QN_ROSTER_GROUP);
+ size_t group_index = 0;
+ while(group_index < index) {
+ ASSERT(group_element != NULL);
+ group_index++;
+ group_element = group_element->NextNamed(QN_ROSTER_GROUP);
+ }
+
+ XmppRosterContactImpl * me = const_cast<XmppRosterContactImpl*>(this);
+ me->group_index_returned_ = static_cast<int>(group_index);
+ me->group_returned_ = group_element;
+ }
+
+ return group_returned_->BodyText();
+}
+
+XmppReturnStatus
+XmppRosterContactImpl::AddGroup(const std::string& group) {
+ if (group == STR_EMPTY)
+ return XMPP_RETURN_BADARGUMENT;
+
+ if (!raw_xml_.get())
+ CreateRawXmlSkeleton();
+
+ if (FindGroup(group, NULL, NULL))
+ return XMPP_RETURN_OK;
+
+ raw_xml_->AddElement(new XmlElement(QN_ROSTER_GROUP));
+ raw_xml_->AddText(group, 1);
+ ++group_count_;
+
+ return XMPP_RETURN_OK;
+}
+
+XmppReturnStatus
+XmppRosterContactImpl::RemoveGroup(const std::string& group) {
+ if (group == STR_EMPTY)
+ return XMPP_RETURN_BADARGUMENT;
+
+ if (!raw_xml_.get())
+ return XMPP_RETURN_OK;
+
+ XmlChild * child_before;
+ if (FindGroup(group, NULL, &child_before)) {
+ raw_xml_->RemoveChildAfter(child_before);
+ ResetGroupCache();
+ }
+ return XMPP_RETURN_OK;
+}
+
+bool
+XmppRosterContactImpl::FindGroup(const std::string& group,
+ XmlElement** element,
+ XmlChild** child_before) {
+ XmlChild * prev_child = NULL;
+ XmlChild * next_child;
+ XmlChild * child;
+ for (child = raw_xml_->FirstChild(); child; child = next_child) {
+ next_child = child->NextChild();
+ if (!child->IsText() &&
+ child->AsElement()->Name() == QN_ROSTER_GROUP &&
+ child->AsElement()->BodyText() == group) {
+ if (element)
+ *element = child->AsElement();
+ if (child_before)
+ *child_before = prev_child;
+ return true;
+ }
+ prev_child = child;
+ }
+
+ return false;
+}
+
+const XmlElement*
+XmppRosterContactImpl::raw_xml() const {
+ if (!raw_xml_.get())
+ const_cast<XmppRosterContactImpl*>(this)->CreateRawXmlSkeleton();
+ return raw_xml_.get();
+}
+
+XmppReturnStatus
+XmppRosterContactImpl::set_raw_xml(const XmlElement* xml) {
+ if (!xml ||
+ xml->Name() != QN_ROSTER_ITEM ||
+ xml->HasAttr(QN_SUBSCRIPTION) ||
+ xml->HasAttr(QN_ASK))
+ return XMPP_RETURN_BADARGUMENT;
+
+ ResetGroupCache();
+
+ raw_xml_.reset(new XmlElement(*xml));
+
+ return XMPP_RETURN_OK;
+}
+
+void
+XmppRosterContactImpl::CreateRawXmlSkeleton() {
+ raw_xml_.reset(new XmlElement(QN_ROSTER_ITEM));
+}
+
+// XmppRosterModuleImpl --------------------------------------------------------
+XmppRosterModule *
+XmppRosterModule::Create() {
+ return new XmppRosterModuleImpl();
+}
+
+XmppRosterModuleImpl::XmppRosterModuleImpl() :
+ roster_handler_(NULL),
+ incoming_presence_map_(new JidPresenceVectorMap()),
+ incoming_presence_vector_(new PresenceVector()),
+ contacts_(new ContactVector()) {
+
+}
+
+XmppRosterModuleImpl::~XmppRosterModuleImpl() {
+ DeleteIncomingPresence();
+ DeleteContacts();
+}
+
+XmppReturnStatus
+XmppRosterModuleImpl::set_roster_handler(XmppRosterHandler * handler) {
+ roster_handler_ = handler;
+ return XMPP_RETURN_OK;
+}
+
+XmppRosterHandler*
+XmppRosterModuleImpl::roster_handler() {
+ return roster_handler_;
+}
+
+XmppPresence*
+XmppRosterModuleImpl::outgoing_presence() {
+ return &outgoing_presence_;
+}
+
+XmppReturnStatus
+XmppRosterModuleImpl::BroadcastPresence() {
+ // Scrub the outgoing presence
+ const XmlElement* element = outgoing_presence_.raw_xml();
+
+ ASSERT(!element->HasAttr(QN_TO) &&
+ !element->HasAttr(QN_FROM) &&
+ (element->Attr(QN_TYPE) == STR_EMPTY ||
+ element->Attr(QN_TYPE) == "unavailable"));
+
+ if (!engine())
+ return XMPP_RETURN_BADSTATE;
+
+ return engine()->SendStanza(element);
+}
+
+XmppReturnStatus
+XmppRosterModuleImpl::SendDirectedPresence(const XmppPresence* presence,
+ const Jid& to_jid) {
+ if (!presence)
+ return XMPP_RETURN_BADARGUMENT;
+
+ if (!engine())
+ return XMPP_RETURN_BADSTATE;
+
+ XmlElement element(*(presence->raw_xml()));
+
+ if (element.Name() != QN_PRESENCE ||
+ element.HasAttr(QN_TO) ||
+ element.HasAttr(QN_FROM))
+ return XMPP_RETURN_BADARGUMENT;
+
+ if (element.HasAttr(QN_TYPE)) {
+ if (element.Attr(QN_TYPE) != STR_EMPTY &&
+ element.Attr(QN_TYPE) != "unavailable") {
+ return XMPP_RETURN_BADARGUMENT;
+ }
+ }
+
+ element.SetAttr(QN_TO, to_jid.Str());
+
+ return engine()->SendStanza(&element);
+}
+
+size_t
+XmppRosterModuleImpl::GetIncomingPresenceCount() {
+ return incoming_presence_vector_->size();
+}
+
+const XmppPresence*
+XmppRosterModuleImpl::GetIncomingPresence(size_t index) {
+ if (index >= incoming_presence_vector_->size())
+ return NULL;
+ return (*incoming_presence_vector_)[index];
+}
+
+size_t
+XmppRosterModuleImpl::GetIncomingPresenceForJidCount(const Jid& jid)
+{
+ // find the vector in the map
+ JidPresenceVectorMap::iterator pos;
+ pos = incoming_presence_map_->find(jid);
+ if (pos == incoming_presence_map_->end())
+ return 0;
+
+ ASSERT(pos->second != NULL);
+
+ return pos->second->size();
+}
+
+const XmppPresence*
+XmppRosterModuleImpl::GetIncomingPresenceForJid(const Jid& jid,
+ size_t index) {
+ JidPresenceVectorMap::iterator pos;
+ pos = incoming_presence_map_->find(jid);
+ if (pos == incoming_presence_map_->end())
+ return NULL;
+
+ ASSERT(pos->second != NULL);
+
+ if (index >= pos->second->size())
+ return NULL;
+
+ return (*pos->second)[index];
+}
+
+XmppReturnStatus
+XmppRosterModuleImpl::RequestRosterUpdate() {
+ if (!engine())
+ return XMPP_RETURN_BADSTATE;
+
+ XmlElement roster_get(QN_IQ);
+ roster_get.AddAttr(QN_TYPE, "get");
+ roster_get.AddAttr(QN_ID, engine()->NextId());
+ roster_get.AddElement(new XmlElement(QN_ROSTER_QUERY, true));
+ return engine()->SendIq(&roster_get, this, NULL);
+}
+
+size_t
+XmppRosterModuleImpl::GetRosterContactCount() {
+ return contacts_->size();
+}
+
+const XmppRosterContact*
+XmppRosterModuleImpl::GetRosterContact(size_t index) {
+ if (index >= contacts_->size())
+ return NULL;
+ return (*contacts_)[index];
+}
+
+class RosterPredicate {
+public:
+ explicit RosterPredicate(const Jid& jid) : jid_(jid) {
+ }
+
+ bool operator() (XmppRosterContactImpl *& contact) {
+ return contact->jid() == jid_;
+ }
+
+private:
+ Jid jid_;
+};
+
+const XmppRosterContact*
+XmppRosterModuleImpl::FindRosterContact(const Jid& jid) {
+ ContactVector::iterator pos;
+
+ pos = std::find_if(contacts_->begin(),
+ contacts_->end(),
+ RosterPredicate(jid));
+ if (pos == contacts_->end())
+ return NULL;
+
+ return *pos;
+}
+
+XmppReturnStatus
+XmppRosterModuleImpl::RequestRosterChange(
+ const XmppRosterContact* contact) {
+ if (!contact)
+ return XMPP_RETURN_BADARGUMENT;
+
+ Jid jid = contact->jid();
+
+ if (!jid.IsValid())
+ return XMPP_RETURN_BADARGUMENT;
+
+ if (!engine())
+ return XMPP_RETURN_BADSTATE;
+
+ const XmlElement* contact_xml = contact->raw_xml();
+ if (contact_xml->Name() != QN_ROSTER_ITEM ||
+ contact_xml->HasAttr(QN_SUBSCRIPTION) ||
+ contact_xml->HasAttr(QN_ASK))
+ return XMPP_RETURN_BADARGUMENT;
+
+ XmlElement roster_add(QN_IQ);
+ roster_add.AddAttr(QN_TYPE, "set");
+ roster_add.AddAttr(QN_ID, engine()->NextId());
+ roster_add.AddElement(new XmlElement(QN_ROSTER_QUERY, true));
+ roster_add.AddElement(new XmlElement(*contact_xml), 1);
+
+ return engine()->SendIq(&roster_add, this, NULL);
+}
+
+XmppReturnStatus
+XmppRosterModuleImpl::RequestRosterRemove(const Jid& jid) {
+ if (!jid.IsValid())
+ return XMPP_RETURN_BADARGUMENT;
+
+ if (!engine())
+ return XMPP_RETURN_BADSTATE;
+
+ XmlElement roster_add(QN_IQ);
+ roster_add.AddAttr(QN_TYPE, "set");
+ roster_add.AddAttr(QN_ID, engine()->NextId());
+ roster_add.AddElement(new XmlElement(QN_ROSTER_QUERY, true));
+ roster_add.AddAttr(QN_JID, jid.Str(), 1);
+ roster_add.AddAttr(QN_SUBSCRIPTION, "remove", 1);
+
+ return engine()->SendIq(&roster_add, this, NULL);
+}
+
+XmppReturnStatus
+XmppRosterModuleImpl::RequestSubscription(const Jid& jid) {
+ return SendSubscriptionRequest(jid, "subscribe");
+}
+
+XmppReturnStatus
+XmppRosterModuleImpl::CancelSubscription(const Jid& jid) {
+ return SendSubscriptionRequest(jid, "unsubscribe");
+}
+
+XmppReturnStatus
+XmppRosterModuleImpl::ApproveSubscriber(const Jid& jid) {
+ return SendSubscriptionRequest(jid, "subscribed");
+}
+
+XmppReturnStatus
+XmppRosterModuleImpl::CancelSubscriber(const Jid& jid) {
+ return SendSubscriptionRequest(jid, "unsubscribed");
+}
+
+void
+XmppRosterModuleImpl::IqResponse(XmppIqCookie, const XmlElement * stanza) {
+ // The only real Iq response that we expect to recieve are initial roster
+ // population
+ if (stanza->Attr(QN_TYPE) == "error")
+ {
+ if (roster_handler_)
+ roster_handler_->RosterError(this, stanza);
+
+ return;
+ }
+
+ ASSERT(stanza->Attr(QN_TYPE) == "result");
+
+ InternalRosterItems(stanza);
+}
+
+bool
+XmppRosterModuleImpl::HandleStanza(const XmlElement * stanza)
+{
+ ASSERT(engine() != NULL);
+
+ // There are two types of stanzas that we care about: presence and roster push
+ // Iqs
+ if (stanza->Name() == QN_PRESENCE) {
+ const std::string& jid_string = stanza->Attr(QN_FROM);
+ Jid jid(jid_string);
+
+ if (!jid.IsValid())
+ return false; // if the Jid isn't valid, don't process
+
+ const std::string& type = stanza->Attr(QN_TYPE);
+ XmppSubscriptionRequestType request_type;
+ if (StringToSubscriptionRequestType(type, &request_type))
+ InternalSubscriptionRequest(jid, stanza, request_type);
+ else if (type == "unavailable" || type == STR_EMPTY)
+ InternalIncomingPresence(jid, stanza);
+ else if (type == "error")
+ InternalIncomingPresenceError(jid, stanza);
+ else
+ return false;
+
+ return true;
+ } else if (stanza->Name() == QN_IQ) {
+ const XmlElement * roster_query = stanza->FirstNamed(QN_ROSTER_QUERY);
+ if (!roster_query || stanza->Attr(QN_TYPE) != "set")
+ return false;
+
+ InternalRosterItems(stanza);
+
+ // respond to the IQ
+ XmlElement result(QN_IQ);
+ result.AddAttr(QN_TYPE, "result");
+ result.AddAttr(QN_TO, stanza->Attr(QN_FROM));
+ result.AddAttr(QN_ID, stanza->Attr(QN_ID));
+
+ engine()->SendStanza(&result);
+ return true;
+ }
+
+ return false;
+}
+
+void
+XmppRosterModuleImpl::DeleteIncomingPresence() {
+ // Clear out the vector of all presence notifications
+ {
+ PresenceVector::iterator pos;
+ for (pos = incoming_presence_vector_->begin();
+ pos < incoming_presence_vector_->end();
+ ++pos) {
+ XmppPresenceImpl * presence = *pos;
+ *pos = NULL;
+ delete presence;
+ }
+ incoming_presence_vector_->clear();
+ }
+
+ // Clear out all of the small presence vectors per Jid
+ {
+ JidPresenceVectorMap::iterator pos;
+ for (pos = incoming_presence_map_->begin();
+ pos != incoming_presence_map_->end();
+ ++pos) {
+ PresenceVector* presence_vector = pos->second;
+ pos->second = NULL;
+ delete presence_vector;
+ }
+ incoming_presence_map_->clear();
+ }
+}
+
+void
+XmppRosterModuleImpl::DeleteContacts() {
+ ContactVector::iterator pos;
+ for (pos = contacts_->begin();
+ pos < contacts_->end();
+ ++pos) {
+ XmppRosterContact* contact = *pos;
+ *pos = NULL;
+ delete contact;
+ }
+ contacts_->clear();
+}
+
+XmppReturnStatus
+XmppRosterModuleImpl::SendSubscriptionRequest(const Jid& jid,
+ const std::string& type) {
+ if (!jid.IsValid())
+ return XMPP_RETURN_BADARGUMENT;
+
+ if (!engine())
+ return XMPP_RETURN_BADSTATE;
+
+ XmlElement presence_request(QN_PRESENCE);
+ presence_request.AddAttr(QN_TO, jid.Str());
+ presence_request.AddAttr(QN_TYPE, type);
+
+ return engine()->SendStanza(&presence_request);
+}
+
+
+void
+XmppRosterModuleImpl::InternalSubscriptionRequest(const Jid& jid,
+ const XmlElement* stanza,
+ XmppSubscriptionRequestType
+ request_type) {
+ if (roster_handler_)
+ roster_handler_->SubscriptionRequest(this, jid, request_type, stanza);
+}
+
+class PresencePredicate {
+public:
+ explicit PresencePredicate(const Jid& jid) : jid_(jid) {
+ }
+
+ bool operator() (XmppPresenceImpl *& contact) {
+ return contact->jid() == jid_;
+ }
+
+private:
+ Jid jid_;
+};
+
+void
+XmppRosterModuleImpl::InternalIncomingPresence(const Jid& jid,
+ const XmlElement* stanza) {
+ bool added = false;
+ Jid bare_jid = jid.BareJid();
+
+ // First add the presence to the map
+ JidPresenceVectorMap::iterator pos;
+ pos = incoming_presence_map_->find(jid.BareJid());
+ if (pos == incoming_presence_map_->end()) {
+ // Insert a new entry into the map. Get the position of this new entry
+ pos = (incoming_presence_map_->insert(
+ std::make_pair(bare_jid, new PresenceVector()))).first;
+ }
+
+ PresenceVector * presence_vector = pos->second;
+ ASSERT(presence_vector != NULL);
+
+ // Try to find this jid in the bare jid bucket
+ PresenceVector::iterator presence_pos;
+ XmppPresenceImpl* presence;
+ presence_pos = std::find_if(presence_vector->begin(),
+ presence_vector->end(),
+ PresencePredicate(jid));
+
+ // Update/add it to the bucket
+ if (presence_pos == presence_vector->end()) {
+ presence = new XmppPresenceImpl();
+ if (XMPP_RETURN_OK == presence->set_raw_xml(stanza)) {
+ added = true;
+ presence_vector->push_back(presence);
+ } else {
+ delete presence;
+ presence = NULL;
+ }
+ } else {
+ presence = *presence_pos;
+ presence->set_raw_xml(stanza);
+ }
+
+ // now add to the comprehensive vector
+ if (added)
+ incoming_presence_vector_->push_back(presence);
+
+ // Call back to the user with the changed presence information
+ if (roster_handler_)
+ roster_handler_->IncomingPresenceChanged(this, presence);
+}
+
+
+void
+XmppRosterModuleImpl::InternalIncomingPresenceError(const Jid& jid,
+ const XmlElement* stanza) {
+ if (roster_handler_)
+ roster_handler_->SubscriptionError(this, jid, stanza);
+}
+
+void
+XmppRosterModuleImpl::InternalRosterItems(const XmlElement* stanza) {
+ const XmlElement* result_data = stanza->FirstNamed(QN_ROSTER_QUERY);
+ if (!result_data)
+ return; // unknown stuff in result!
+
+ bool all_new = contacts_->empty();
+
+ for (const XmlElement* roster_item = result_data->FirstNamed(QN_ROSTER_ITEM);
+ roster_item;
+ roster_item = roster_item->NextNamed(QN_ROSTER_ITEM))
+ {
+ const std::string& jid_string = roster_item->Attr(QN_JID);
+ Jid jid(jid_string);
+ if (!jid.IsValid())
+ continue;
+
+ // This algorithm is N^2 on the number of incoming contacts after the
+ // initial load. There is no way to do this faster without allowing
+ // duplicates, introducing more data structures or write a custom data
+ // structure. We'll see if this becomes a perf problem and fix it if it
+ // does.
+ ContactVector::iterator pos = contacts_->end();
+
+ if (!all_new) {
+ pos = std::find_if(contacts_->begin(),
+ contacts_->end(),
+ RosterPredicate(jid));
+ }
+
+ if (pos != contacts_->end()) { // Update/remove a current contact
+ if (roster_item->Attr(QN_SUBSCRIPTION) == "remove") {
+ XmppRosterContact* contact = *pos;
+ contacts_->erase(pos);
+ if (roster_handler_)
+ roster_handler_->ContactRemoved(this, contact,
+ std::distance(contacts_->begin(), pos));
+ delete contact;
+ } else {
+ XmppRosterContact* old_contact = *pos;
+ *pos = new XmppRosterContactImpl();
+ (*pos)->SetXmlFromWire(roster_item);
+ if (roster_handler_)
+ roster_handler_->ContactChanged(this, old_contact,
+ std::distance(contacts_->begin(), pos));
+ delete old_contact;
+ }
+ } else { // Add a new contact
+ XmppRosterContactImpl* contact = new XmppRosterContactImpl();
+ contact->SetXmlFromWire(roster_item);
+ contacts_->push_back(contact);
+ if (roster_handler_ && !all_new)
+ roster_handler_->ContactsAdded(this, contacts_->size() - 1, 1);
+ }
+ }
+
+ // Send a consolidated update if all contacts are new
+ if (roster_handler_ && all_new)
+ roster_handler_->ContactsAdded(this, 0, contacts_->size());
+}
+
+}
diff --git a/talk/xmpp/rostermoduleimpl.h b/talk/xmpp/rostermoduleimpl.h
new file mode 100644
index 0000000..48ad5e5
--- /dev/null
+++ b/talk/xmpp/rostermoduleimpl.h
@@ -0,0 +1,293 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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 _rostermoduleimpl_h_
+#define _rostermoduleimpl_h_
+
+#include "talk/xmpp/moduleimpl.h"
+#include "talk/xmpp/rostermodule.h"
+
+namespace buzz {
+
+//! Presence Information
+//! This class stores both presence information for outgoing presence and is
+//! returned by methods in XmppRosterModule to represent recieved incoming
+//! presence information. When this class is writeable (non-const) then each
+//! update to any property will set the inner xml. Setting the raw_xml will
+//! rederive all of the other properties.
+class XmppPresenceImpl : public XmppPresence {
+public:
+ virtual ~XmppPresenceImpl() {}
+
+ //! The from Jid of for the presence information.
+ //! Typically this will be a full Jid with resource specified. For outgoing
+ //! presence this should remain JID_NULL and will be scrubbed from the
+ //! stanza when being sent.
+ virtual const Jid jid() const;
+
+ //! Is the contact available?
+ virtual XmppPresenceAvailable available() const;
+
+ //! Sets if the user is available or not
+ virtual XmppReturnStatus set_available(XmppPresenceAvailable available);
+
+ //! The show value of the presence info
+ virtual XmppPresenceShow presence_show() const;
+
+ //! Set the presence show value
+ virtual XmppReturnStatus set_presence_show(XmppPresenceShow show);
+
+ //! The Priority of the presence info
+ virtual int priority() const;
+
+ //! Set the priority of the presence
+ virtual XmppReturnStatus set_priority(int priority);
+
+ //! The plain text status of the presence info.
+ //! If there are multiple status because of language, this will either be a
+ //! status that is not tagged for language or the first available
+ virtual const std::string& status() const;
+
+ //! Sets the status for the presence info.
+ //! If there is more than one status present already then this will remove
+ //! them all and replace it with one status element we no specified language
+ virtual XmppReturnStatus set_status(const std::string& status);
+
+ //! The raw xml of the presence update
+ virtual const XmlElement* raw_xml() const;
+
+ //! Sets the raw presence stanza for the presence update
+ //! This will cause all other data items in this structure to be rederived
+ virtual XmppReturnStatus set_raw_xml(const XmlElement * xml);
+
+private:
+ XmppPresenceImpl();
+
+ friend class XmppPresence;
+ friend class XmppRosterModuleImpl;
+
+ void CreateRawXmlSkeleton();
+
+ // Store everything in the XML element. If this becomes a perf issue we can
+ // cache the data.
+ talk_base::scoped_ptr<XmlElement> raw_xml_;
+};
+
+//! A contact as given by the server
+class XmppRosterContactImpl : public XmppRosterContact {
+public:
+ virtual ~XmppRosterContactImpl() {}
+
+ //! The jid for the contact.
+ //! Typically this will be a bare Jid.
+ virtual const Jid jid() const;
+
+ //! Sets the jid for the roster contact update
+ virtual XmppReturnStatus set_jid(const Jid& jid);
+
+ //! The name (nickname) stored for this contact
+ virtual const std::string& name() const;
+
+ //! Sets the name
+ virtual XmppReturnStatus set_name(const std::string& name);
+
+ //! The Presence subscription state stored on the server for this contact
+ //! This is never settable and will be ignored when generating a roster
+ //! add/update request
+ virtual XmppSubscriptionState subscription_state() const;
+
+ //! The number of Groups applied to this contact
+ virtual size_t GetGroupCount() const;
+
+ //! Gets a Group applied to the contact based on index.
+ virtual const std::string& GetGroup(size_t index) const;
+
+ //! Adds a group to this contact.
+ //! This will return a no error if the group is already present.
+ virtual XmppReturnStatus AddGroup(const std::string& group);
+
+ //! Removes a group from the contact.
+ //! This will return no error if the group isn't there
+ virtual XmppReturnStatus RemoveGroup(const std::string& group);
+
+ //! The raw xml for this roster contact
+ virtual const XmlElement* raw_xml() const;
+
+ //! Sets the raw presence stanza for the presence update
+ //! This will cause all other data items in this structure to be rederived
+ virtual XmppReturnStatus set_raw_xml(const XmlElement * xml);
+
+private:
+ XmppRosterContactImpl();
+
+ void CreateRawXmlSkeleton();
+ void SetXmlFromWire(const XmlElement * xml);
+ void ResetGroupCache();
+
+ bool FindGroup(const std::string& group,
+ XmlElement** element,
+ XmlChild** child_before);
+
+
+ friend class XmppRosterContact;
+ friend class XmppRosterModuleImpl;
+
+ int group_count_;
+ int group_index_returned_;
+ XmlElement * group_returned_;
+ talk_base::scoped_ptr<XmlElement> raw_xml_;
+};
+
+//! An XmppModule for handle roster and presence functionality
+class XmppRosterModuleImpl : public XmppModuleImpl,
+ public XmppRosterModule, public XmppIqHandler {
+public:
+ virtual ~XmppRosterModuleImpl();
+
+ IMPLEMENT_XMPPMODULE
+
+ //! Sets the roster handler (callbacks) for the module
+ virtual XmppReturnStatus set_roster_handler(XmppRosterHandler * handler);
+
+ //! Gets the roster handler for the module
+ virtual XmppRosterHandler* roster_handler();
+
+ // USER PRESENCE STATE -------------------------------------------------------
+
+ //! Gets the aggregate outgoing presence
+ //! This object is non-const and be edited directly. No update is sent
+ //! to the server until a Broadcast is sent
+ virtual XmppPresence* outgoing_presence();
+
+ //! Broadcasts that the user is available.
+ //! Nothing with respect to presence is sent until this is called.
+ virtual XmppReturnStatus BroadcastPresence();
+
+ //! Sends a directed presence to a Jid
+ //! Note that the client doesn't store where directed presence notifications
+ //! have been sent. The server can keep the appropriate state
+ virtual XmppReturnStatus SendDirectedPresence(const XmppPresence* presence,
+ const Jid& to_jid);
+
+ // INCOMING PRESENCE STATUS --------------------------------------------------
+
+ //! Returns the number of incoming presence data recorded
+ virtual size_t GetIncomingPresenceCount();
+
+ //! Returns an incoming presence datum based on index
+ virtual const XmppPresence* GetIncomingPresence(size_t index);
+
+ //! Gets the number of presence data for a bare Jid
+ //! There may be a datum per resource
+ virtual size_t GetIncomingPresenceForJidCount(const Jid& jid);
+
+ //! Returns a single presence data for a Jid based on index
+ virtual const XmppPresence* GetIncomingPresenceForJid(const Jid& jid,
+ size_t index);
+
+ // ROSTER MANAGEMENT ---------------------------------------------------------
+
+ //! Requests an update of the roster from the server
+ //! This must be called to initialize the client side cache of the roster
+ //! After this is sent the server should keep this module apprised of any
+ //! changes.
+ virtual XmppReturnStatus RequestRosterUpdate();
+
+ //! Returns the number of contacts in the roster
+ virtual size_t GetRosterContactCount();
+
+ //! Returns a contact by index
+ virtual const XmppRosterContact* GetRosterContact(size_t index);
+
+ //! Finds a contact by Jid
+ virtual const XmppRosterContact* FindRosterContact(const Jid& jid);
+
+ //! Send a request to the server to add a contact
+ //! Note that the contact won't show up in the roster until the server can
+ //! respond. This happens async when the socket is being serviced
+ virtual XmppReturnStatus RequestRosterChange(
+ const XmppRosterContact* contact);
+
+ //! Request that the server remove a contact
+ //! The jabber protocol specifies that the server should also cancel any
+ //! subscriptions when this is done. Like adding, this contact won't be
+ //! removed until the server responds.
+ virtual XmppReturnStatus RequestRosterRemove(const Jid& jid);
+
+ // SUBSCRIPTION MANAGEMENT ---------------------------------------------------
+
+ //! Request a subscription to presence notifications form a Jid
+ virtual XmppReturnStatus RequestSubscription(const Jid& jid);
+
+ //! Cancel a subscription to presence notifications from a Jid
+ virtual XmppReturnStatus CancelSubscription(const Jid& jid);
+
+ //! Approve a request to deliver presence notifications to a jid
+ virtual XmppReturnStatus ApproveSubscriber(const Jid& jid);
+
+ //! Deny or cancel presence notification deliver to a jid
+ virtual XmppReturnStatus CancelSubscriber(const Jid& jid);
+
+ // XmppIqHandler IMPLEMENTATION ----------------------------------------------
+ virtual void IqResponse(XmppIqCookie cookie, const XmlElement * stanza);
+
+protected:
+ // XmppModuleImpl OVERRIDES --------------------------------------------------
+ virtual bool HandleStanza(const XmlElement *);
+
+ // PRIVATE DATA --------------------------------------------------------------
+private:
+ friend class XmppRosterModule;
+ XmppRosterModuleImpl();
+
+ // Helper functions
+ void DeleteIncomingPresence();
+ void DeleteContacts();
+ XmppReturnStatus SendSubscriptionRequest(const Jid& jid,
+ const std::string& type);
+ void InternalSubscriptionRequest(const Jid& jid, const XmlElement* stanza,
+ XmppSubscriptionRequestType request_type);
+ void InternalIncomingPresence(const Jid& jid, const XmlElement* stanza);
+ void InternalIncomingPresenceError(const Jid& jid, const XmlElement* stanza);
+ void InternalRosterItems(const XmlElement* stanza);
+
+ // Member data
+ XmppPresenceImpl outgoing_presence_;
+ XmppRosterHandler* roster_handler_;
+
+ typedef std::vector<XmppPresenceImpl*> PresenceVector;
+ typedef std::map<Jid, PresenceVector*> JidPresenceVectorMap;
+ talk_base::scoped_ptr<JidPresenceVectorMap> incoming_presence_map_;
+ talk_base::scoped_ptr<PresenceVector> incoming_presence_vector_;
+
+ typedef std::vector<XmppRosterContactImpl*> ContactVector;
+ talk_base::scoped_ptr<ContactVector> contacts_;
+};
+
+}
+
+#endif
diff --git a/talk/xmpp/saslcookiemechanism.h b/talk/xmpp/saslcookiemechanism.h
index 92cff4d..fd65b94 100644
--- a/talk/xmpp/saslcookiemechanism.h
+++ b/talk/xmpp/saslcookiemechanism.h
@@ -56,15 +56,14 @@
token_service_("") {}
virtual std::string GetMechanismName() { return mechanism_; }
-
+
virtual XmlElement * StartSaslAuth() {
// send initial request
XmlElement * el = new XmlElement(QN_SASL_AUTH, true);
el->AddAttr(QN_MECHANISM, mechanism_);
if (!token_service_.empty()) {
- el->AddAttr(
- QName(true, "http://www.google.com/talk/protocol/auth", "service"),
- token_service_);
+ el->AddAttr(QName("http://www.google.com/talk/protocol/auth", "service"),
+ token_service_);
}
std::string credential;
@@ -75,7 +74,7 @@
el->AddText(Base64Encode(credential));
return el;
}
-
+
private:
std::string mechanism_;
std::string username_;
diff --git a/talk/xmpp/util_unittest.cc b/talk/xmpp/util_unittest.cc
new file mode 100644
index 0000000..91ecb69
--- /dev/null
+++ b/talk/xmpp/util_unittest.cc
@@ -0,0 +1,98 @@
+// Copyright 2004 Google, Inc. All Rights Reserved.
+// Author: Joe Beda
+
+#include <string>
+#include <sstream>
+#include <iostream>
+#include "talk/base/gunit.h"
+#include "talk/xmllite/xmlelement.h"
+#include "talk/xmpp/xmppengine.h"
+#include "talk/xmpp/util_unittest.h"
+
+namespace buzz {
+
+void XmppTestHandler::WriteOutput(const char * bytes, size_t len) {
+ output_ << std::string(bytes, len);
+}
+
+void XmppTestHandler::StartTls(const std::string & cname) {
+ output_ << "[START-TLS " << cname << "]";
+}
+
+void XmppTestHandler::CloseConnection() {
+ output_ << "[CLOSED]";
+}
+
+void XmppTestHandler::OnStateChange(int state) {
+ switch (static_cast<XmppEngine::State>(state)) {
+ case XmppEngine::STATE_START:
+ session_ << "[START]";
+ break;
+ case XmppEngine::STATE_OPENING:
+ session_ << "[OPENING]";
+ break;
+ case XmppEngine::STATE_OPEN:
+ session_ << "[OPEN]";
+ break;
+ case XmppEngine::STATE_CLOSED:
+ session_ << "[CLOSED]";
+ switch (engine_->GetError(NULL)) {
+ case XmppEngine::ERROR_NONE:
+ // do nothing
+ break;
+ case XmppEngine::ERROR_XML:
+ session_ << "[ERROR-XML]";
+ break;
+ case XmppEngine::ERROR_STREAM:
+ session_ << "[ERROR-STREAM]";
+ break;
+ case XmppEngine::ERROR_VERSION:
+ session_ << "[ERROR-VERSION]";
+ break;
+ case XmppEngine::ERROR_UNAUTHORIZED:
+ session_ << "[ERROR-UNAUTHORIZED]";
+ break;
+ case XmppEngine::ERROR_TLS:
+ session_ << "[ERROR-TLS]";
+ break;
+ case XmppEngine::ERROR_AUTH:
+ session_ << "[ERROR-AUTH]";
+ break;
+ case XmppEngine::ERROR_BIND:
+ session_ << "[ERROR-BIND]";
+ break;
+ case XmppEngine::ERROR_CONNECTION_CLOSED:
+ session_ << "[ERROR-CONNECTION-CLOSED]";
+ break;
+ case XmppEngine::ERROR_DOCUMENT_CLOSED:
+ session_ << "[ERROR-DOCUMENT-CLOSED]";
+ break;
+ }
+ break;
+ }
+}
+
+bool XmppTestHandler::HandleStanza(const XmlElement * stanza) {
+ stanza_ << stanza->Str();
+ return true;
+}
+
+std::string XmppTestHandler::OutputActivity() {
+ std::string result = output_.str();
+ output_.str("");
+ return result;
+}
+
+std::string XmppTestHandler::SessionActivity() {
+ std::string result = session_.str();
+ session_.str("");
+ return result;
+}
+
+std::string XmppTestHandler::StanzaActivity() {
+ std::string result = stanza_.str();
+ stanza_.str("");
+ return result;
+}
+
+} // namespace buzz
diff --git a/talk/xmpp/util_unittest.h b/talk/xmpp/util_unittest.h
new file mode 100644
index 0000000..bb0656c
--- /dev/null
+++ b/talk/xmpp/util_unittest.h
@@ -0,0 +1,75 @@
+/*
+ * libjingle
+ * Copyright 2004--2005, 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_XMPP_UTIL_UNITTEST_H_
+#define TALK_XMPP_UTIL_UNITTEST_H_
+
+#include <string>
+#include <sstream>
+#include "talk/xmpp/xmppengine.h"
+
+namespace buzz {
+
+// This class captures callbacks from engine.
+class XmppTestHandler : public XmppOutputHandler, public XmppSessionHandler,
+ public XmppStanzaHandler {
+ public:
+ explicit XmppTestHandler(XmppEngine* engine) : engine_(engine) {}
+ virtual ~XmppTestHandler() {}
+
+ void SetEngine(XmppEngine* engine);
+
+ // Output handler
+ virtual void WriteOutput(const char * bytes, size_t len);
+ virtual void StartTls(const std::string & cname);
+ virtual void CloseConnection();
+
+ // Session handler
+ virtual void OnStateChange(int state);
+
+ // Stanza handler
+ virtual bool HandleStanza(const XmlElement* stanza);
+
+ std::string OutputActivity();
+ std::string SessionActivity();
+ std::string StanzaActivity();
+
+ private:
+ XmppEngine* engine_;
+ std::stringstream output_;
+ std::stringstream session_;
+ std::stringstream stanza_;
+};
+
+} // namespace buzz
+
+inline std::ostream& operator<<(std::ostream& os, const buzz::Jid& jid) {
+ os << jid.Str();
+ return os;
+}
+
+#endif // TALK_XMPP_UTIL_UNITTEST_H_
diff --git a/talk/xmpp/xmppclient.cc b/talk/xmpp/xmppclient.cc
index 3207ed5..563dc2a 100644
--- a/talk/xmpp/xmppclient.cc
+++ b/talk/xmpp/xmppclient.cc
@@ -27,11 +27,12 @@
#include "xmppclient.h"
#include "xmpptask.h"
-#include "talk/xmpp/constants.h"
#include "talk/base/sigslot.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/stringutils.h"
+#include "talk/xmpp/constants.h"
#include "talk/xmpp/saslplainmechanism.h"
#include "talk/xmpp/prexmppauth.h"
-#include "talk/base/scoped_ptr.h"
#include "talk/xmpp/plainsaslhandler.h"
namespace buzz {
@@ -82,8 +83,16 @@
void OnSocketClosed();
};
+bool IsTestServer(const std::string& server_name,
+ const std::string& test_server_domain) {
+ return (!test_server_domain.empty() &&
+ talk_base::ends_with(server_name.c_str(),
+ test_server_domain.c_str()));
+}
+
XmppReturnStatus
-XmppClient::Connect(const XmppClientSettings & settings, const std::string & lang, AsyncSocket * socket, PreXmppAuth * pre_auth) {
+XmppClient::Connect(const XmppClientSettings & settings,
+ const std::string & lang, AsyncSocket * socket, PreXmppAuth * pre_auth) {
if (socket == NULL)
return XMPP_RETURN_BADARGUMENT;
if (d_->socket_.get() != NULL)
@@ -101,7 +110,7 @@
if (!settings.resource().empty()) {
d_->engine_->SetRequestedResource(settings.resource());
}
- d_->engine_->SetUseTls(settings.use_tls());
+ d_->engine_->SetTls(settings.use_tls());
// The talk.google.com server returns a certificate with common-name:
// CN="gmail.com" for @gmail.com accounts,
@@ -116,7 +125,8 @@
if (server_name == buzz::STR_TALK_GOOGLE_COM ||
server_name == buzz::STR_TALKX_L_GOOGLE_COM ||
server_name == buzz::STR_XMPP_GOOGLE_COM ||
- server_name == buzz::STR_XMPPX_L_GOOGLE_COM) {
+ server_name == buzz::STR_XMPPX_L_GOOGLE_COM ||
+ IsTestServer(server_name, settings.test_server_domain())) {
if (settings.host() != STR_GMAIL_COM &&
settings.host() != STR_GOOGLEMAIL_COM) {
d_->engine_->SetTlsServer("", STR_TALK_GOOGLE_COM);
diff --git a/talk/xmpp/xmppclientsettings.h b/talk/xmpp/xmppclientsettings.h
index 4f821ab..29dfeec 100644
--- a/talk/xmpp/xmppclientsettings.h
+++ b/talk/xmpp/xmppclientsettings.h
@@ -30,13 +30,14 @@
#include "talk/p2p/base/port.h"
#include "talk/base/cryptstring.h"
+#include "talk/xmpp/xmppengine.h"
namespace buzz {
class XmppUserSettings {
public:
XmppUserSettings()
- : use_tls_(false),
+ : use_tls_(buzz::TLS_DISABLED),
allow_plain_(false) {
}
@@ -45,8 +46,11 @@
void set_pass(const talk_base::CryptString & pass) { pass_ = pass; }
void set_auth_cookie(const std::string & cookie) { auth_cookie_ = cookie; }
void set_resource(const std::string & resource) { resource_ = resource; }
- void set_use_tls(bool use_tls) { use_tls_ = use_tls; }
+ void set_use_tls(const TlsOptions use_tls) { use_tls_ = use_tls; }
void set_allow_plain(bool f) { allow_plain_ = f; }
+ void set_test_server_domain(const std::string & test_server_domain) {
+ test_server_domain_ = test_server_domain;
+ }
void set_token_service(const std::string & token_service) {
token_service_ = token_service;
}
@@ -56,8 +60,9 @@
const talk_base::CryptString & pass() const { return pass_; }
const std::string & auth_cookie() const { return auth_cookie_; }
const std::string & resource() const { return resource_; }
- bool use_tls() const { return use_tls_; }
+ TlsOptions use_tls() const { return use_tls_; }
bool allow_plain() const { return allow_plain_; }
+ const std::string & test_server_domain() const { return test_server_domain_; }
const std::string & token_service() const { return token_service_; }
private:
@@ -66,8 +71,9 @@
talk_base::CryptString pass_;
std::string auth_cookie_;
std::string resource_;
- bool use_tls_;
+ TlsOptions use_tls_;
bool allow_plain_;
+ std::string test_server_domain_;
std::string token_service_;
};
@@ -80,8 +86,8 @@
use_proxy_auth_(false) {
}
- void set_server(const talk_base::SocketAddress & server) {
- server_ = server;
+ void set_server(const talk_base::SocketAddress & server) {
+ server_ = server;
}
void set_protocol(cricket::ProtocolType protocol) { protocol_ = protocol; }
void set_proxy(talk_base::ProxyType f) { proxy_ = f; }
diff --git a/talk/xmpp/xmppengine.h b/talk/xmpp/xmppengine.h
index 44ed83d..e1b35a3 100644
--- a/talk/xmpp/xmppengine.h
+++ b/talk/xmpp/xmppengine.h
@@ -77,6 +77,14 @@
XMPP_RETURN_NOTYETIMPLEMENTED,
};
+// TlsOptions
+// This is used by API to identify TLS setting.
+enum TlsOptions {
+ TLS_DISABLED,
+ TLS_ENABLED,
+ TLS_REQUIRED
+};
+
//! Callback for socket output for an XmppEngine connection.
//! Register via XmppEngine.SetOutputHandler. An XmppEngine
//! can call back to this handler while it is processing
@@ -197,7 +205,7 @@
virtual XmppReturnStatus SetSaslHandler(SaslHandler * h) = 0;
//! Sets whether TLS will be used within the connection (default true).
- virtual XmppReturnStatus SetUseTls(bool useTls) = 0;
+ virtual XmppReturnStatus SetTls(TlsOptions useTls) = 0;
//! Sets an alternate domain from which we allows TLS certificates.
//! This is for use in the case where a we want to allow a proxy to
@@ -207,7 +215,7 @@
const std::string & proxy_domain) = 0;
//! Gets whether TLS will be used within the connection.
- virtual bool GetUseTls() = 0;
+ virtual TlsOptions GetTls() = 0;
//! Sets the request resource name, if any (optional).
//! Note that the resource name may be overridden by the server; after
diff --git a/talk/xmpp/xmppengine_unittest.cc b/talk/xmpp/xmppengine_unittest.cc
new file mode 100644
index 0000000..46b79c6
--- /dev/null
+++ b/talk/xmpp/xmppengine_unittest.cc
@@ -0,0 +1,318 @@
+// Copyright 2004 Google Inc. All Rights Reserved
+// Author: David Bau
+
+#include <string>
+#include <sstream>
+#include <iostream>
+#include "talk/base/common.h"
+#include "talk/base/gunit.h"
+#include "talk/xmllite/xmlelement.h"
+#include "talk/xmpp/constants.h"
+#include "talk/xmpp/util_unittest.h"
+#include "talk/xmpp/saslplainmechanism.h"
+#include "talk/xmpp/plainsaslhandler.h"
+#include "talk/xmpp/xmppengine.h"
+
+using buzz::Jid;
+using buzz::QName;
+using buzz::XmlElement;
+using buzz::XmppEngine;
+using buzz::XmppIqCookie;
+using buzz::XmppIqHandler;
+using buzz::XmppTestHandler;
+using buzz::QN_ID;
+using buzz::QN_IQ;
+using buzz::QN_TYPE;
+using buzz::QN_ROSTER_QUERY;
+using buzz::XMPP_RETURN_OK;
+using buzz::XMPP_RETURN_BADARGUMENT;
+
+// XmppEngineTestIqHandler
+// This class grabs the response to an IQ stanza and stores it in a string.
+class XmppEngineTestIqHandler : public XmppIqHandler {
+ public:
+ virtual void IqResponse(XmppIqCookie, const XmlElement * stanza) {
+ ss_ << stanza->Str();
+ }
+
+ std::string IqResponseActivity() {
+ std::string result = ss_.str();
+ ss_.str("");
+ return result;
+ }
+
+ private:
+ std::stringstream ss_;
+};
+
+class XmppEngineTest : public testing::Test {
+ public:
+ XmppEngine* engine() { return engine_.get(); }
+ XmppTestHandler* handler() { return handler_.get(); }
+ virtual void SetUp() {
+ engine_.reset(XmppEngine::Create());
+ handler_.reset(new XmppTestHandler(engine_.get()));
+
+ Jid jid("david@my-server");
+ talk_base::InsecureCryptStringImpl pass;
+ pass.password() = "david";
+ engine_->SetSessionHandler(handler_.get());
+ engine_->SetOutputHandler(handler_.get());
+ engine_->AddStanzaHandler(handler_.get());
+ engine_->SetUser(jid);
+ engine_->SetSaslHandler(
+ new buzz::PlainSaslHandler(jid, talk_base::CryptString(pass), true));
+ }
+ virtual void TearDown() {
+ handler_.reset();
+ engine_.reset();
+ }
+ void RunLogin();
+
+ private:
+ talk_base::scoped_ptr<XmppEngine> engine_;
+ talk_base::scoped_ptr<XmppTestHandler> handler_;
+};
+
+void XmppEngineTest::RunLogin() {
+ // Connect
+ EXPECT_EQ(XmppEngine::STATE_START, engine()->GetState());
+ engine()->Connect();
+ EXPECT_EQ(XmppEngine::STATE_OPENING, engine()->GetState());
+
+ EXPECT_EQ("[OPENING]", handler_->SessionActivity());
+
+ EXPECT_EQ("<stream:stream to=\"my-server\" xml:lang=\"*\" version=\"1.0\" "
+ "xmlns:stream=\"http://etherx.jabber.org/streams\" "
+ "xmlns=\"jabber:client\">\r\n", handler_->OutputActivity());
+
+ std::string input =
+ "<stream:stream id=\"a5f2d8c9\" version=\"1.0\" "
+ "xmlns:stream=\"http://etherx.jabber.org/streams\" "
+ "xmlns=\"jabber:client\">";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ input =
+ "<stream:features>"
+ "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'>"
+ "<required/>"
+ "</starttls>"
+ "<mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>"
+ "<mechanism>DIGEST-MD5</mechanism>"
+ "<mechanism>PLAIN</mechanism>"
+ "</mechanisms>"
+ "</stream:features>";
+ engine()->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("<starttls xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\"/>",
+ handler_->OutputActivity());
+
+ EXPECT_EQ("", handler_->SessionActivity());
+ EXPECT_EQ("", handler_->StanzaActivity());
+
+ input = "<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>";
+ engine()->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("[START-TLS my-server]"
+ "<stream:stream to=\"my-server\" xml:lang=\"*\" "
+ "version=\"1.0\" xmlns:stream=\"http://etherx.jabber.org/streams\" "
+ "xmlns=\"jabber:client\">\r\n", handler_->OutputActivity());
+
+ EXPECT_EQ("", handler_->SessionActivity());
+ EXPECT_EQ("", handler_->StanzaActivity());
+
+ input = "<stream:stream id=\"01234567\" version=\"1.0\" "
+ "xmlns:stream=\"http://etherx.jabber.org/streams\" "
+ "xmlns=\"jabber:client\">";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ input =
+ "<stream:features>"
+ "<mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>"
+ "<mechanism>DIGEST-MD5</mechanism>"
+ "<mechanism>PLAIN</mechanism>"
+ "</mechanisms>"
+ "</stream:features>";
+ engine()->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" "
+ "mechanism=\"PLAIN\" "
+ "auth:allow-non-google-login=\"true\" "
+ "auth:client-uses-full-bind-result=\"true\" "
+ "xmlns:auth=\"http://www.google.com/talk/protocol/auth\""
+ ">AGRhdmlkAGRhdmlk</auth>",
+ handler_->OutputActivity());
+
+ EXPECT_EQ("", handler_->SessionActivity());
+ EXPECT_EQ("", handler_->StanzaActivity());
+
+ input = "<success xmlns='urn:ietf:params:xml:ns:xmpp-sasl'/>";
+ engine()->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("<stream:stream to=\"my-server\" xml:lang=\"*\" version=\"1.0\" "
+ "xmlns:stream=\"http://etherx.jabber.org/streams\" "
+ "xmlns=\"jabber:client\">\r\n", handler_->OutputActivity());
+
+ EXPECT_EQ("", handler_->SessionActivity());
+ EXPECT_EQ("", handler_->StanzaActivity());
+
+ input = "<stream:stream id=\"01234567\" version=\"1.0\" "
+ "xmlns:stream=\"http://etherx.jabber.org/streams\" "
+ "xmlns=\"jabber:client\">";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ input = "<stream:features>"
+ "<bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'/>"
+ "<session xmlns='urn:ietf:params:xml:ns:xmpp-session'/>"
+ "</stream:features>";
+ engine()->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("<iq type=\"set\" id=\"0\">"
+ "<bind xmlns=\"urn:ietf:params:xml:ns:xmpp-bind\"/></iq>",
+ handler_->OutputActivity());
+
+ EXPECT_EQ("", handler_->SessionActivity());
+ EXPECT_EQ("", handler_->StanzaActivity());
+
+ input = "<iq type='result' id='0'>"
+ "<bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'><jid>"
+ "david@my-server/test</jid></bind></iq>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("<iq type=\"set\" id=\"1\">"
+ "<session xmlns=\"urn:ietf:params:xml:ns:xmpp-session\"/></iq>",
+ handler_->OutputActivity());
+
+ EXPECT_EQ("", handler_->SessionActivity());
+ EXPECT_EQ("", handler_->StanzaActivity());
+
+ input = "<iq type='result' id='1'/>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[OPEN]", handler_->SessionActivity());
+ EXPECT_EQ("", handler_->StanzaActivity());
+ EXPECT_EQ(Jid("david@my-server/test"), engine()->FullJid());
+}
+
+// TestSuccessfulLogin()
+// This function simply tests to see if a login works. This includes
+// encryption and authentication
+TEST_F(XmppEngineTest, TestSuccessfulLoginAndDisconnect) {
+ RunLogin();
+ engine()->Disconnect();
+ EXPECT_EQ("</stream:stream>[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED]", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppEngineTest, TestSuccessfulLoginAndConnectionClosed) {
+ RunLogin();
+ engine()->ConnectionClosed(0);
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-CONNECTION-CLOSED]", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+
+// TestNotXmpp()
+// This tests the error case when connecting to a non XMPP service
+TEST_F(XmppEngineTest, TestNotXmpp) {
+ // Connect
+ engine()->Connect();
+ EXPECT_EQ("<stream:stream to=\"my-server\" xml:lang=\"*\" version=\"1.0\" "
+ "xmlns:stream=\"http://etherx.jabber.org/streams\" "
+ "xmlns=\"jabber:client\">\r\n", handler()->OutputActivity());
+
+ // Send garbage response (courtesy of apache)
+ std::string input = "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[OPENING][CLOSED][ERROR-XML]", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+// TestPassthrough()
+// This tests that arbitrary stanzas can be passed to the server through
+// the engine.
+TEST_F(XmppEngineTest, TestPassthrough) {
+ // Queue up an app stanza
+ XmlElement application_stanza(QName("test", "app-stanza"));
+ application_stanza.AddText("this-is-a-test");
+ engine()->SendStanza(&application_stanza);
+
+ // Do the whole login handshake
+ RunLogin();
+
+ EXPECT_EQ("<test:app-stanza xmlns:test=\"test\">this-is-a-test"
+ "</test:app-stanza>", handler()->OutputActivity());
+
+ // do another stanza
+ XmlElement roster_get(QN_IQ);
+ roster_get.AddAttr(QN_TYPE, "get");
+ roster_get.AddAttr(QN_ID, engine()->NextId());
+ roster_get.AddElement(new XmlElement(QN_ROSTER_QUERY, true));
+ engine()->SendStanza(&roster_get);
+ EXPECT_EQ("<iq type=\"get\" id=\"2\"><query xmlns=\"jabber:iq:roster\"/>"
+ "</iq>", handler()->OutputActivity());
+
+ // now say the server ends the stream
+ engine()->HandleInput("</stream:stream>", 16);
+ EXPECT_EQ("[CLOSED][ERROR-DOCUMENT-CLOSED]", handler()->SessionActivity());
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+// TestIqCallback()
+// This tests the routing of Iq stanzas and responses.
+TEST_F(XmppEngineTest, TestIqCallback) {
+ XmppEngineTestIqHandler iq_response;
+ XmppIqCookie cookie;
+
+ // Do the whole login handshake
+ RunLogin();
+
+ // Build an iq request
+ XmlElement roster_get(QN_IQ);
+ roster_get.AddAttr(QN_TYPE, "get");
+ roster_get.AddAttr(QN_ID, engine()->NextId());
+ roster_get.AddElement(new XmlElement(QN_ROSTER_QUERY, true));
+ engine()->SendIq(&roster_get, &iq_response, &cookie);
+ EXPECT_EQ("<iq type=\"get\" id=\"2\"><query xmlns=\"jabber:iq:roster\"/>"
+ "</iq>", handler()->OutputActivity());
+ EXPECT_EQ("", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+ EXPECT_EQ("", iq_response.IqResponseActivity());
+
+ // now say the server responds to the iq
+ std::string input = "<iq type='result' id='2'>"
+ "<query xmlns='jabber:iq:roster'><item>foo</item>"
+ "</query></iq>";
+ engine()->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("", handler()->OutputActivity());
+ EXPECT_EQ("", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+ EXPECT_EQ("<cli:iq type=\"result\" id=\"2\" xmlns:cli=\"jabber:client\">"
+ "<query xmlns=\"jabber:iq:roster\"><item>foo</item></query>"
+ "</cli:iq>", iq_response.IqResponseActivity());
+
+ EXPECT_EQ(XMPP_RETURN_BADARGUMENT, engine()->RemoveIqHandler(cookie, NULL));
+
+ // Do it again with another id to test cancel
+ roster_get.SetAttr(QN_ID, engine()->NextId());
+ engine()->SendIq(&roster_get, &iq_response, &cookie);
+ EXPECT_EQ("<iq type=\"get\" id=\"3\"><query xmlns=\"jabber:iq:roster\"/>"
+ "</iq>", handler()->OutputActivity());
+ EXPECT_EQ("", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+ EXPECT_EQ("", iq_response.IqResponseActivity());
+
+ // cancel the handler this time
+ EXPECT_EQ(XMPP_RETURN_OK, engine()->RemoveIqHandler(cookie, NULL));
+
+ // now say the server responds to the iq: the iq handler should not get it.
+ input = "<iq type='result' id='3'><query xmlns='jabber:iq:roster'><item>bar"
+ "</item></query></iq>";
+ engine()->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("<cli:iq type=\"result\" id=\"3\" xmlns:cli=\"jabber:client\">"
+ "<query xmlns=\"jabber:iq:roster\"><item>bar</item></query>"
+ "</cli:iq>", handler()->StanzaActivity());
+ EXPECT_EQ("", iq_response.IqResponseActivity());
+ EXPECT_EQ("", handler()->OutputActivity());
+ EXPECT_EQ("", handler()->SessionActivity());
+}
diff --git a/talk/xmpp/xmppengineimpl.cc b/talk/xmpp/xmppengineimpl.cc
index 262c531..9e21249 100644
--- a/talk/xmpp/xmppengineimpl.cc
+++ b/talk/xmpp/xmppengineimpl.cc
@@ -2,89 +2,84 @@
* libjingle
* Copyright 2004--2005, Google Inc.
*
- * Redistribution and use in source and binary forms, with or without
+ * 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,
+ * 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
+ * 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
+ * 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,
+ * 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
+ * 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.
*/
-#define TRACK_ARRAY_ALLOC_PROBLEM
-
-#include <vector>
-#include <sstream>
-#include <algorithm>
-#include "talk/xmllite/xmlelement.h"
-#include "talk/base/common.h"
#include "talk/xmpp/xmppengineimpl.h"
-#include "talk/xmpp/xmpplogintask.h"
-#include "talk/xmpp/constants.h"
+
+#include <algorithm>
+#include <sstream>
+#include <vector>
+
+#include "talk/base/common.h"
+#include "talk/xmllite/xmlelement.h"
#include "talk/xmllite/xmlprinter.h"
+#include "talk/xmpp/constants.h"
#include "talk/xmpp/saslhandler.h"
+#include "talk/xmpp/xmpplogintask.h"
namespace buzz {
-static const std::string XMPP_CLIENT_NAMESPACES[] = {
- "stream", "http://etherx.jabber.org/streams",
- "", "jabber:client",
-};
-
-static const size_t XMPP_CLIENT_NAMESPACES_LEN = 4;
-
-XmppEngine * XmppEngine::Create() {
+XmppEngine* XmppEngine::Create() {
return new XmppEngineImpl();
}
-XmppEngineImpl::XmppEngineImpl() :
- stanzaParseHandler_(this),
- stanzaParser_(&stanzaParseHandler_),
- engine_entered_(0),
- user_jid_(JID_EMPTY),
- password_(),
- requested_resource_(STR_EMPTY),
- tls_needed_(true),
- login_task_(new XmppLoginTask(this)),
- next_id_(0),
- bound_jid_(JID_EMPTY),
- state_(STATE_START),
- encrypted_(false),
- error_code_(ERROR_NONE),
- subcode_(0),
- stream_error_(NULL),
- raised_reset_(false),
- output_handler_(NULL),
- session_handler_(NULL),
- iq_entries_(new IqEntryVector()),
- sasl_handler_(NULL),
- output_(new std::stringstream()) {
+XmppEngineImpl::XmppEngineImpl()
+ : stanza_parse_handler_(this),
+ stanza_parser_(&stanza_parse_handler_),
+ engine_entered_(0),
+ password_(),
+ requested_resource_(STR_EMPTY),
+ tls_option_(buzz::TLS_REQUIRED),
+ login_task_(new XmppLoginTask(this)),
+ next_id_(0),
+ state_(STATE_START),
+ encrypted_(false),
+ error_code_(ERROR_NONE),
+ subcode_(0),
+ stream_error_(NULL),
+ raised_reset_(false),
+ output_handler_(NULL),
+ session_handler_(NULL),
+ iq_entries_(new IqEntryVector()),
+ sasl_handler_(NULL),
+ output_(new std::stringstream()) {
for (int i = 0; i < HL_COUNT; i+= 1) {
stanza_handlers_[i].reset(new StanzaHandlerVector());
}
+
+ // Add XMPP namespaces to XML namespaces stack.
+ xmlns_stack_.AddXmlns("stream", "http://etherx.jabber.org/streams");
+ xmlns_stack_.AddXmlns("", "jabber:client");
}
XmppEngineImpl::~XmppEngineImpl() {
DeleteIqCookies();
}
-XmppReturnStatus
-XmppEngineImpl::SetOutputHandler(XmppOutputHandler* output_handler) {
+XmppReturnStatus XmppEngineImpl::SetOutputHandler(
+ XmppOutputHandler* output_handler) {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
@@ -93,8 +88,8 @@
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::SetSessionHandler(XmppSessionHandler* session_handler) {
+XmppReturnStatus XmppEngineImpl::SetSessionHandler(
+ XmppSessionHandler* session_handler) {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
@@ -103,21 +98,20 @@
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::HandleInput(const char * bytes, size_t len) {
+XmppReturnStatus XmppEngineImpl::HandleInput(
+ const char* bytes, size_t len) {
if (state_ < STATE_OPENING || state_ > STATE_OPEN)
return XMPP_RETURN_BADSTATE;
EnterExit ee(this);
// TODO: The return value of the xml parser is not checked.
- stanzaParser_.Parse(bytes, len, false);
+ stanza_parser_.Parse(bytes, len, false);
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::ConnectionClosed(int subcode) {
+XmppReturnStatus XmppEngineImpl::ConnectionClosed(int subcode) {
if (state_ != STATE_CLOSED) {
EnterExit ee(this);
// If told that connection closed and not already closed,
@@ -131,19 +125,16 @@
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::SetUseTls(bool useTls) {
+XmppReturnStatus XmppEngineImpl::SetTls(TlsOptions use_tls) {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
-
- tls_needed_ = useTls;
-
+ tls_option_ = use_tls;
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::SetTlsServer(const std::string & tls_server_hostname,
- const std::string & tls_server_domain) {
+XmppReturnStatus XmppEngineImpl::SetTlsServer(
+ const std::string& tls_server_hostname,
+ const std::string& tls_server_domain) {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
@@ -153,13 +144,11 @@
return XMPP_RETURN_OK;
}
-bool
-XmppEngineImpl::GetUseTls() {
- return tls_needed_;
+TlsOptions XmppEngineImpl::GetTls() {
+ return tls_option_;
}
-XmppReturnStatus
-XmppEngineImpl::SetUser(const Jid & jid) {
+XmppReturnStatus XmppEngineImpl::SetUser(const Jid& jid) {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
@@ -168,13 +157,11 @@
return XMPP_RETURN_OK;
}
-const Jid &
-XmppEngineImpl::GetUser() {
+const Jid& XmppEngineImpl::GetUser() {
return user_jid_;
}
-XmppReturnStatus
-XmppEngineImpl::SetSaslHandler(SaslHandler * sasl_handler) {
+XmppReturnStatus XmppEngineImpl::SetSaslHandler(SaslHandler* sasl_handler) {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
@@ -182,8 +169,8 @@
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::SetRequestedResource(const std::string & resource) {
+XmppReturnStatus XmppEngineImpl::SetRequestedResource(
+ const std::string& resource) {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
@@ -192,14 +179,13 @@
return XMPP_RETURN_OK;
}
-const std::string &
-XmppEngineImpl::GetRequestedResource() {
+const std::string& XmppEngineImpl::GetRequestedResource() {
return requested_resource_;
}
-XmppReturnStatus
-XmppEngineImpl::AddStanzaHandler(XmppStanzaHandler * stanza_handler,
- XmppEngine::HandlerLevel level) {
+XmppReturnStatus XmppEngineImpl::AddStanzaHandler(
+ XmppStanzaHandler* stanza_handler,
+ XmppEngine::HandlerLevel level) {
if (state_ == STATE_CLOSED)
return XMPP_RETURN_BADSTATE;
@@ -208,9 +194,8 @@
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::RemoveStanzaHandler(XmppStanzaHandler * stanza_handler) {
-
+XmppReturnStatus XmppEngineImpl::RemoveStanzaHandler(
+ XmppStanzaHandler* stanza_handler) {
bool found = false;
for (int level = 0; level < HL_COUNT; level += 1) {
@@ -225,15 +210,13 @@
}
}
- if (!found) {
+ if (!found)
return XMPP_RETURN_BADARGUMENT;
- }
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::Connect() {
+XmppReturnStatus XmppEngineImpl::Connect() {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
@@ -250,8 +233,7 @@
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::SendStanza(const XmlElement * element) {
+XmppReturnStatus XmppEngineImpl::SendStanza(const XmlElement* element) {
if (state_ == STATE_CLOSED)
return XMPP_RETURN_BADSTATE;
@@ -268,8 +250,7 @@
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::SendRaw(const std::string & text) {
+XmppReturnStatus XmppEngineImpl::SendRaw(const std::string& text) {
if (state_ == STATE_CLOSED || login_task_.get())
return XMPP_RETURN_BADSTATE;
@@ -280,16 +261,13 @@
return XMPP_RETURN_OK;
}
-std::string
-XmppEngineImpl::NextId() {
+std::string XmppEngineImpl::NextId() {
std::stringstream ss;
ss << next_id_++;
return ss.str();
}
-XmppReturnStatus
-XmppEngineImpl::Disconnect() {
-
+XmppReturnStatus XmppEngineImpl::Disconnect() {
if (state_ != STATE_CLOSED) {
EnterExit ee(this);
if (state_ == STATE_OPEN)
@@ -300,14 +278,13 @@
return XMPP_RETURN_OK;
}
-void
-XmppEngineImpl::IncomingStart(const XmlElement * pelStart) {
+void XmppEngineImpl::IncomingStart(const XmlElement* start) {
if (HasError() || raised_reset_)
return;
if (login_task_.get()) {
// start-stream should go to login task
- login_task_->IncomingStanza(pelStart, true);
+ login_task_->IncomingStanza(start, true);
if (login_task_->IsDone())
login_task_.reset();
}
@@ -317,8 +294,7 @@
}
}
-void
-XmppEngineImpl::IncomingStanza(const XmlElement * stanza) {
+void XmppEngineImpl::IncomingStanza(const XmlElement* stanza) {
if (HasError() || raised_reset_)
return;
@@ -342,7 +318,7 @@
for (int level = HL_SINGLE; level <= HL_ALL; level += 1) {
for (size_t i = 0; i < stanza_handlers_[level]->size(); i += 1) {
if ((*stanza_handlers_[level])[i]->HandleStanza(stanza))
- goto Handled;
+ return;
}
}
@@ -350,29 +326,24 @@
// Only do this for IQ stanzas as messages should probably just be dropped
// and presence stanzas should certainly be dropped.
std::string type = stanza->Attr(QN_TYPE);
- if (stanza->Name() == QN_IQ &&
+ if (stanza->Name() == QN_IQ &&
!(type == "error" || type == "result")) {
SendStanzaError(stanza, XSE_FEATURE_NOT_IMPLEMENTED, STR_EMPTY);
}
}
- Handled:
- ; // handled - we're done
}
-void
-XmppEngineImpl::IncomingEnd(bool isError) {
+void XmppEngineImpl::IncomingEnd(bool isError) {
if (HasError() || raised_reset_)
return;
SignalError(isError ? ERROR_XML : ERROR_DOCUMENT_CLOSED, 0);
}
-void
-XmppEngineImpl::InternalSendStart(const std::string & to) {
+void XmppEngineImpl::InternalSendStart(const std::string& to) {
std::string hostname = tls_server_hostname_;
- if (hostname.empty()) {
+ if (hostname.empty())
hostname = to;
- }
// If not language is specified, the spec says use *
std::string lang = lang_;
@@ -389,61 +360,56 @@
<< "xmlns=\"jabber:client\">\r\n";
}
-void
-XmppEngineImpl::InternalSendStanza(const XmlElement * element) {
+void XmppEngineImpl::InternalSendStanza(const XmlElement* element) {
// It should really never be necessary to set a FROM attribute on a stanza.
// It is implied by the bind on the stream and if you get it wrong
// (by flipping from/to on a message?) the server will close the stream.
ASSERT(!element->HasAttr(QN_FROM));
- // TODO: consider caching the XmlPrinter
- XmlPrinter::PrintXml(output_.get(), element,
- XMPP_CLIENT_NAMESPACES, XMPP_CLIENT_NAMESPACES_LEN);
+ XmlPrinter::PrintXml(output_.get(), element, &xmlns_stack_);
}
-std::string
-XmppEngineImpl::ChooseBestSaslMechanism(const std::vector<std::string> & mechanisms, bool encrypted) {
+std::string XmppEngineImpl::ChooseBestSaslMechanism(
+ const std::vector<std::string>& mechanisms, bool encrypted) {
return sasl_handler_->ChooseBestSaslMechanism(mechanisms, encrypted);
}
-SaslMechanism *
-XmppEngineImpl::GetSaslMechanism(const std::string & name) {
+SaslMechanism* XmppEngineImpl::GetSaslMechanism(const std::string& name) {
return sasl_handler_->CreateSaslMechanism(name);
}
-void
-XmppEngineImpl::SignalBound(const Jid & fullJid) {
+void XmppEngineImpl::SignalBound(const Jid& fullJid) {
if (state_ == STATE_OPENING) {
bound_jid_ = fullJid;
state_ = STATE_OPEN;
}
}
-void
-XmppEngineImpl::SignalStreamError(const XmlElement * pelStreamError) {
+void XmppEngineImpl::SignalStreamError(const XmlElement* stream_error) {
if (state_ != STATE_CLOSED) {
- stream_error_.reset(new XmlElement(*pelStreamError));
+ stream_error_.reset(new XmlElement(*stream_error));
SignalError(ERROR_STREAM, 0);
}
}
-void
-XmppEngineImpl::SignalError(Error errorCode, int subCode) {
+void XmppEngineImpl::SignalError(Error error_code, int sub_code) {
if (state_ != STATE_CLOSED) {
- error_code_ = errorCode;
- subcode_ = subCode;
+ error_code_ = error_code;
+ subcode_ = sub_code;
state_ = STATE_CLOSED;
}
}
-bool
-XmppEngineImpl::HasError() {
+bool XmppEngineImpl::HasError() {
return error_code_ != ERROR_NONE;
}
-void
-XmppEngineImpl::StartTls(const std::string & domain) {
+void XmppEngineImpl::StartTls(const std::string& domain) {
if (output_handler_) {
+ // As substitute for the real (login jid's) domain, we permit
+ // verifying a tls_server_domain_ instead, if one was passed.
+ // This allows us to avoid running a proxy that needs to handle
+ // valuable certificates.
output_handler_->StartTls(
tls_server_domain_.empty() ? domain : tls_server_domain_);
encrypted_ = true;
@@ -451,7 +417,7 @@
}
XmppEngineImpl::EnterExit::EnterExit(XmppEngineImpl* engine)
- : engine_(engine),
+ : engine_(engine),
state_(engine->state_),
error_(engine->error_code_) {
engine->engine_entered_ += 1;
@@ -482,17 +448,17 @@
return;
if (engine->raised_reset_) {
- engine->stanzaParser_.Reset();
+ engine->stanza_parser_.Reset();
engine->raised_reset_ = false;
}
if (engine->session_handler_) {
if (engine->state_ != state_)
engine->session_handler_->OnStateChange(engine->state_);
- // Note: Handling of OnStateChange(CLOSED) should allow for the
- // deletion of the engine, so no members should be accessed
- // after this line.
+ // Note: Handling of OnStateChange(CLOSED) should allow for the
+ // deletion of the engine, so no members should be accessed
+ // after this line.
}
}
-}
+} // namespace buzz
diff --git a/talk/xmpp/xmppengineimpl.h b/talk/xmpp/xmppengineimpl.h
index e5d3dc6..e292e75 100644
--- a/talk/xmpp/xmppengineimpl.h
+++ b/talk/xmpp/xmppengineimpl.h
@@ -25,8 +25,8 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef _xmppengineimpl_h_
-#define _xmppengineimpl_h_
+#ifndef TALK_XMPP_XMPPENGINEIMPL_H_
+#define TALK_XMPP_XMPPENGINEIMPL_H_
#include <sstream>
#include <vector>
@@ -41,7 +41,6 @@
class SaslHandler;
class SaslMechanism;
-
//! The XMPP connection engine.
//! This engine implements the client side of the 'core' XMPP protocol.
//! To use it, register an XmppOutputHandler to handle socket output
@@ -51,7 +50,7 @@
//! An application can listen for events and receive stanzas by
//! registering an XmppStanzaHandler via AddStanzaHandler().
class XmppEngineImpl : public XmppEngine {
-public:
+ public:
XmppEngineImpl();
virtual ~XmppEngineImpl();
@@ -61,7 +60,7 @@
virtual XmppReturnStatus SetOutputHandler(XmppOutputHandler *pxoh);
//! Provides socket input to the engine
- virtual XmppReturnStatus HandleInput(const char * bytes, size_t len);
+ virtual XmppReturnStatus HandleInput(const char* bytes, size_t len);
//! Advises the engine that the socket has closed
virtual XmppReturnStatus ConnectionClosed(int subcode);
@@ -69,26 +68,26 @@
// SESSION SETUP ---------------------------------------------------------
//! Indicates the (bare) JID for the user to use.
- virtual XmppReturnStatus SetUser(const Jid & jid);
+ virtual XmppReturnStatus SetUser(const Jid& jid);
//! Get the login (bare) JID.
- virtual const Jid & GetUser();
+ virtual const Jid& GetUser();
//! Indicates the autentication to use. Takes ownership of the object.
- virtual XmppReturnStatus SetSaslHandler(SaslHandler * sasl_handler);
+ virtual XmppReturnStatus SetSaslHandler(SaslHandler* sasl_handler);
//! Sets whether TLS will be used within the connection (default true).
- virtual XmppReturnStatus SetUseTls(bool useTls);
+ virtual XmppReturnStatus SetTls(TlsOptions use_tls);
//! Sets an alternate domain from which we allows TLS certificates.
//! This is for use in the case where a we want to allow a proxy to
//! serve up its own certificate rather than one owned by the underlying
//! domain.
- virtual XmppReturnStatus SetTlsServer(const std::string & proxy_hostname,
- const std::string & proxy_domain);
+ virtual XmppReturnStatus SetTlsServer(const std::string& proxy_hostname,
+ const std::string& proxy_domain);
//! Gets whether TLS will be used within the connection.
- virtual bool GetUseTls();
+ virtual TlsOptions GetTls();
//! Sets the request resource name, if any (optional).
//! Note that the resource name may be overridden by the server; after
@@ -96,10 +95,10 @@
virtual XmppReturnStatus SetRequestedResource(const std::string& resource);
//! Gets the request resource name.
- virtual const std::string & GetRequestedResource();
+ virtual const std::string& GetRequestedResource();
//! Sets language
- virtual void SetLanguage(const std::string & lang) {
+ virtual void SetLanguage(const std::string& lang) {
lang_ = lang;
}
@@ -131,7 +130,7 @@
//! The stream:error stanza, when the error is XmppEngine::ERROR_STREAM.
//! Notice the stanza returned is owned by the XmppEngine and
//! is deleted when the engine is destroyed.
- virtual const XmlElement * GetStreamError() { return stream_error_.get(); }
+ virtual const XmlElement* GetStreamError() { return stream_error_.get(); }
//! Closes down the connection.
//! Sends CloseConnection to output, and disconnects and registered
@@ -151,14 +150,14 @@
virtual XmppReturnStatus RemoveStanzaHandler(XmppStanzaHandler* handler);
//! Sends a stanza to the server.
- virtual XmppReturnStatus SendStanza(const XmlElement * pelStanza);
+ virtual XmppReturnStatus SendStanza(const XmlElement* stanza);
//! Sends raw text to the server
- virtual XmppReturnStatus SendRaw(const std::string & text);
+ virtual XmppReturnStatus SendRaw(const std::string& text);
//! Sends an iq to the server, and registers a callback for the result.
//! Returns the cookie passed to the result handler.
- virtual XmppReturnStatus SendIq(const XmlElement* pelStanza,
+ virtual XmppReturnStatus SendIq(const XmlElement* stanza,
XmppIqHandler* iq_handler,
XmppIqCookie* cookie);
@@ -170,55 +169,62 @@
//! Forms and sends an error in response to the given stanza.
//! Swaps to and from, sets type to "error", and adds error information
//! based on the passed code. Text is optional and may be STR_EMPTY.
- virtual XmppReturnStatus SendStanzaError(const XmlElement * pelOriginal,
+ virtual XmppReturnStatus SendStanzaError(const XmlElement* pelOriginal,
XmppStanzaError code,
- const std::string & text);
+ const std::string& text);
//! The fullly bound JID.
//! This JID is only valid after binding has succeeded. If the value
//! is JID_NULL, the binding has not succeeded.
- virtual const Jid & FullJid() { return bound_jid_; }
+ virtual const Jid& FullJid() { return bound_jid_; }
//! The next unused iq id for this connection.
//! Call this when building iq stanzas, to ensure that each iq
//! gets its own unique id.
virtual std::string NextId();
-private:
+ private:
friend class XmppLoginTask;
friend class XmppIqEntry;
- void IncomingStanza(const XmlElement *pelStanza);
- void IncomingStart(const XmlElement *pelStanza);
+ void IncomingStanza(const XmlElement *stanza);
+ void IncomingStart(const XmlElement *stanza);
void IncomingEnd(bool isError);
- void InternalSendStart(const std::string & domainName);
- void InternalSendStanza(const XmlElement * pelStanza);
- std::string ChooseBestSaslMechanism(const std::vector<std::string> & mechanisms, bool encrypted);
- SaslMechanism * GetSaslMechanism(const std::string & name);
- void SignalBound(const Jid & fullJid);
- void SignalStreamError(const XmlElement * pelStreamError);
+ void InternalSendStart(const std::string& domainName);
+ void InternalSendStanza(const XmlElement* stanza);
+ std::string ChooseBestSaslMechanism(
+ const std::vector<std::string>& mechanisms, bool encrypted);
+ SaslMechanism* GetSaslMechanism(const std::string& name);
+ void SignalBound(const Jid& fullJid);
+ void SignalStreamError(const XmlElement* streamError);
void SignalError(Error errorCode, int subCode);
bool HasError();
void DeleteIqCookies();
- bool HandleIqResponse(const XmlElement * element);
- void StartTls(const std::string & domain);
+ bool HandleIqResponse(const XmlElement* element);
+ void StartTls(const std::string& domain);
void RaiseReset() { raised_reset_ = true; }
class StanzaParseHandler : public XmppStanzaParseHandler {
- public:
- StanzaParseHandler(XmppEngineImpl * outer) : outer_(outer) {}
+ public:
+ StanzaParseHandler(XmppEngineImpl* outer) : outer_(outer) {}
virtual ~StanzaParseHandler() {}
- virtual void StartStream(const XmlElement * pelStream)
- { outer_->IncomingStart(pelStream); }
- virtual void Stanza(const XmlElement * pelStanza)
- { outer_->IncomingStanza(pelStanza); }
- virtual void EndStream()
- { outer_->IncomingEnd(false); }
- virtual void XmlError()
- { outer_->IncomingEnd(true); }
- private:
- XmppEngineImpl * const outer_;
+
+ virtual void StartStream(const XmlElement* stream) {
+ outer_->IncomingStart(stream);
+ }
+ virtual void Stanza(const XmlElement* stanza) {
+ outer_->IncomingStanza(stanza);
+ }
+ virtual void EndStream() {
+ outer_->IncomingEnd(false);
+ }
+ virtual void XmlError() {
+ outer_->IncomingEnd(true);
+ }
+
+ private:
+ XmppEngineImpl* const outer_;
};
class EnterExit {
@@ -235,16 +241,15 @@
friend class StanzaParseHandler;
friend class EnterExit;
- StanzaParseHandler stanzaParseHandler_;
- XmppStanzaParser stanzaParser_;
-
+ StanzaParseHandler stanza_parse_handler_;
+ XmppStanzaParser stanza_parser_;
// state
int engine_entered_;
Jid user_jid_;
std::string password_;
std::string requested_resource_;
- bool tls_needed_;
+ TlsOptions tls_option_;
std::string tls_server_hostname_;
std::string tls_server_domain_;
talk_base::scoped_ptr<XmppLoginTask> login_task_;
@@ -261,6 +266,8 @@
XmppOutputHandler* output_handler_;
XmppSessionHandler* session_handler_;
+ XmlnsStack xmlns_stack_;
+
typedef std::vector<XmppStanzaHandler*> StanzaHandlerVector;
talk_base::scoped_ptr<StanzaHandlerVector> stanza_handlers_[HL_COUNT];
@@ -272,7 +279,6 @@
talk_base::scoped_ptr<std::stringstream> output_;
};
-}
+} // namespace buzz
-
-#endif
+#endif // TALK_XMPP_XMPPENGINEIMPL_H_
diff --git a/talk/xmpp/xmpplogintask.cc b/talk/xmpp/xmpplogintask.cc
index 340d95d..726802d 100644
--- a/talk/xmpp/xmpplogintask.cc
+++ b/talk/xmpp/xmpplogintask.cc
@@ -25,8 +25,11 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include "talk/xmpp/xmpplogintask.h"
+
#include <string>
#include <vector>
+
#include "talk/base/base64.h"
#include "talk/base/common.h"
#include "talk/xmllite/xmlelement.h"
@@ -34,7 +37,6 @@
#include "talk/xmpp/jid.h"
#include "talk/xmpp/saslmechanism.h"
#include "talk/xmpp/xmppengineimpl.h"
-#include "talk/xmpp/xmpplogintask.h"
using talk_base::ConstantLabel;
@@ -56,10 +58,10 @@
LASTLABEL
};
#endif // _DEBUG
-
XmppLoginTask::XmppLoginTask(XmppEngineImpl * pctx) :
pctx_(pctx),
authNeeded_(true),
+ allowNonGoogleLogin_(true),
state_(LOGINSTATE_INIT),
pelStanza_(NULL),
isStart_(false),
@@ -138,8 +140,14 @@
if (!HandleFeatures(element))
return Failure(XmppEngine::ERROR_VERSION);
- // Use TLS if forced, or if available
- if (pctx_->tls_needed_ || GetFeature(QN_TLS_STARTTLS) != NULL) {
+ bool tls_present = (GetFeature(QN_TLS_STARTTLS) != NULL);
+ // Error if TLS required but not present.
+ if (pctx_->tls_option_ == buzz::TLS_REQUIRED && !tls_present) {
+ return Failure(XmppEngine::ERROR_TLS);
+ }
+ // Use TLS if required or enabled, and also available
+ if ((pctx_->tls_option_ == buzz::TLS_REQUIRED ||
+ pctx_->tls_option_ == buzz::TLS_ENABLED) && tls_present) {
state_ = LOGINSTATE_TLS_INIT;
continue;
}
@@ -176,7 +184,7 @@
// to do so - see the implementation of XmppEngineImpl::StartTls and
// XmppEngine::SetTlsServerDomain to see how you can use that feature
pctx_->StartTls(pctx_->user_jid_.domain());
- pctx_->tls_needed_ = false;
+ pctx_->tls_option_ = buzz::TLS_ENABLED;
state_ = LOGINSTATE_INIT;
continue;
}
@@ -214,6 +222,16 @@
if (auth == NULL) {
return Failure(XmppEngine::ERROR_AUTH);
}
+ if (allowNonGoogleLogin_) {
+ // Setting the following two attributes is required to support
+ // non-google ids.
+
+ // Allow login with non-google id accounts.
+ auth->SetAttr(QN_GOOGLE_ALLOW_NON_GOOGLE_ID_XMPP_LOGIN, "true");
+
+ // Allow login with either the non-google id or the friendly email.
+ auth->SetAttr(QN_GOOGLE_AUTH_CLIENT_USES_FULL_BIND_RESULT, "true");
+ }
pctx_->InternalSendStanza(auth);
delete auth;
diff --git a/talk/xmpp/xmpplogintask.h b/talk/xmpp/xmpplogintask.h
index a6507b5..9b3f5ae 100644
--- a/talk/xmpp/xmpplogintask.h
+++ b/talk/xmpp/xmpplogintask.h
@@ -25,10 +25,12 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef _logintask_h_
-#define _logintask_h_
+#ifndef TALK_XMPP_LOGINTASK_H_
+#define TALK_XMPP_LOGINTASK_H_
#include <string>
+#include <vector>
+
#include "talk/base/logging.h"
#include "talk/base/scoped_ptr.h"
#include "talk/xmpp/jid.h"
@@ -41,6 +43,7 @@
class SaslMechanism;
+// TODO: Rename to LoginTask.
class XmppLoginTask {
public:
@@ -51,6 +54,8 @@
{ return state_ == LOGINSTATE_DONE; }
void IncomingStanza(const XmlElement * element, bool isStart);
void OutgoingStanza(const XmlElement *element);
+ void set_allow_non_google_login(bool b)
+ { allowNonGoogleLogin_ = b; }
private:
enum LoginTaskState {
@@ -77,6 +82,7 @@
XmppEngineImpl * pctx_;
bool authNeeded_;
+ bool allowNonGoogleLogin_;
LoginTaskState state_;
const XmlElement * pelStanza_;
bool isStart_;
@@ -95,4 +101,4 @@
}
-#endif
+#endif // TALK_XMPP_LOGINTASK_H_
diff --git a/talk/xmpp/xmpplogintask_unittest.cc b/talk/xmpp/xmpplogintask_unittest.cc
new file mode 100644
index 0000000..51af81a
--- /dev/null
+++ b/talk/xmpp/xmpplogintask_unittest.cc
@@ -0,0 +1,614 @@
+// Copyright 2004 Google Inc. All Rights Reserved
+
+
+#include <string>
+#include <sstream>
+#include <iostream>
+#include "talk/base/common.h"
+#include "talk/base/cryptstring.h"
+#include "talk/base/gunit.h"
+#include "talk/xmllite/xmlelement.h"
+#include "talk/xmpp/util_unittest.h"
+#include "talk/xmpp/constants.h"
+#include "talk/xmpp/saslplainmechanism.h"
+#include "talk/xmpp/plainsaslhandler.h"
+#include "talk/xmpp/xmppengine.h"
+
+using buzz::Jid;
+using buzz::QName;
+using buzz::XmlElement;
+using buzz::XmppEngine;
+using buzz::XmppTestHandler;
+
+enum XlttStage {
+ XLTT_STAGE_CONNECT = 0,
+ XLTT_STAGE_STREAMSTART,
+ XLTT_STAGE_TLS_FEATURES,
+ XLTT_STAGE_TLS_PROCEED,
+ XLTT_STAGE_ENCRYPTED_START,
+ XLTT_STAGE_AUTH_FEATURES,
+ XLTT_STAGE_AUTH_SUCCESS,
+ XLTT_STAGE_AUTHENTICATED_START,
+ XLTT_STAGE_BIND_FEATURES,
+ XLTT_STAGE_BIND_SUCCESS,
+ XLTT_STAGE_SESSION_SUCCESS,
+};
+
+class XmppLoginTaskTest : public testing::Test {
+ public:
+ XmppEngine* engine() { return engine_.get(); }
+ XmppTestHandler* handler() { return handler_.get(); }
+ virtual void SetUp() {
+ engine_.reset(XmppEngine::Create());
+ handler_.reset(new XmppTestHandler(engine_.get()));
+
+ Jid jid("david@my-server");
+ talk_base::InsecureCryptStringImpl pass;
+ pass.password() = "david";
+ engine_->SetSessionHandler(handler_.get());
+ engine_->SetOutputHandler(handler_.get());
+ engine_->AddStanzaHandler(handler_.get());
+ engine_->SetUser(jid);
+ engine_->SetSaslHandler(
+ new buzz::PlainSaslHandler(jid, talk_base::CryptString(pass), true));
+ }
+ virtual void TearDown() {
+ handler_.reset();
+ engine_.reset();
+ }
+ void RunPartialLogin(XlttStage startstage, XlttStage endstage);
+ void SetTlsOptions(buzz::TlsOptions option);
+
+ private:
+ talk_base::scoped_ptr<XmppEngine> engine_;
+ talk_base::scoped_ptr<XmppTestHandler> handler_;
+};
+
+void XmppLoginTaskTest::SetTlsOptions(buzz::TlsOptions option) {
+ engine_->SetTls(option);
+}
+void XmppLoginTaskTest::RunPartialLogin(XlttStage startstage,
+ XlttStage endstage) {
+ std::string input;
+
+ switch (startstage) {
+ case XLTT_STAGE_CONNECT: {
+ engine_->Connect();
+ XmlElement appStanza(QName("test", "app-stanza"));
+ appStanza.AddText("this-is-a-test");
+ engine_->SendStanza(&appStanza);
+
+ EXPECT_EQ("<stream:stream to=\"my-server\" xml:lang=\"*\" "
+ "version=\"1.0\" xmlns:stream=\"http://etherx.jabber.org/streams\" "
+ "xmlns=\"jabber:client\">\r\n", handler_->OutputActivity());
+ EXPECT_EQ("[OPENING]", handler_->SessionActivity());
+ EXPECT_EQ("", handler_->StanzaActivity());
+ if (endstage == XLTT_STAGE_CONNECT)
+ return;
+ }
+
+ case XLTT_STAGE_STREAMSTART: {
+ input = "<stream:stream id=\"a5f2d8c9\" version=\"1.0\" "
+ "xmlns:stream=\"http://etherx.jabber.org/streams\" "
+ "xmlns=\"jabber:client\">";
+ engine_->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("", handler_->StanzaActivity());
+ EXPECT_EQ("", handler_->SessionActivity());
+ EXPECT_EQ("", handler_->OutputActivity());
+ if (endstage == XLTT_STAGE_STREAMSTART)
+ return;
+ }
+
+ case XLTT_STAGE_TLS_FEATURES: {
+ input = "<stream:features>"
+ "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>"
+ "</stream:features>";
+ engine_->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("<starttls xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\"/>",
+ handler_->OutputActivity());
+ EXPECT_EQ("", handler_->StanzaActivity());
+ EXPECT_EQ("", handler_->SessionActivity());
+ if (endstage == XLTT_STAGE_TLS_FEATURES)
+ return;
+ }
+
+ case XLTT_STAGE_TLS_PROCEED: {
+ input = std::string("<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>");
+ engine_->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("[START-TLS my-server]"
+ "<stream:stream to=\"my-server\" xml:lang=\"*\" "
+ "version=\"1.0\" xmlns:stream=\"http://etherx.jabber.org/streams\" "
+ "xmlns=\"jabber:client\">\r\n", handler_->OutputActivity());
+ EXPECT_EQ("", handler_->StanzaActivity());
+ EXPECT_EQ("", handler_->SessionActivity());
+ if (endstage == XLTT_STAGE_TLS_PROCEED)
+ return;
+ }
+
+ case XLTT_STAGE_ENCRYPTED_START: {
+ input = std::string("<stream:stream id=\"01234567\" version=\"1.0\" "
+ "xmlns:stream=\"http://etherx.jabber.org/streams\" "
+ "xmlns=\"jabber:client\">");
+ engine_->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("", handler_->StanzaActivity());
+ EXPECT_EQ("", handler_->SessionActivity());
+ EXPECT_EQ("", handler_->OutputActivity());
+ if (endstage == XLTT_STAGE_ENCRYPTED_START)
+ return;
+ }
+
+ case XLTT_STAGE_AUTH_FEATURES: {
+ input = "<stream:features>"
+ "<mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>"
+ "<mechanism>DIGEST-MD5</mechanism>"
+ "<mechanism>PLAIN</mechanism>"
+ "</mechanisms>"
+ "</stream:features>";
+ engine_->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" "
+ "mechanism=\"PLAIN\" "
+ "auth:allow-non-google-login=\"true\" "
+ "auth:client-uses-full-bind-result=\"true\" "
+ "xmlns:auth=\"http://www.google.com/talk/protocol/auth\""
+ ">AGRhdmlkAGRhdmlk</auth>",
+ handler_->OutputActivity());
+ EXPECT_EQ("", handler_->StanzaActivity());
+ EXPECT_EQ("", handler_->SessionActivity());
+ if (endstage == XLTT_STAGE_AUTH_FEATURES)
+ return;
+ }
+
+ case XLTT_STAGE_AUTH_SUCCESS: {
+ input = "<success xmlns='urn:ietf:params:xml:ns:xmpp-sasl'/>";
+ engine_->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("<stream:stream to=\"my-server\" xml:lang=\"*\" "
+ "version=\"1.0\" xmlns:stream=\"http://etherx.jabber.org/streams\" "
+ "xmlns=\"jabber:client\">\r\n", handler_->OutputActivity());
+ EXPECT_EQ("", handler_->StanzaActivity());
+ EXPECT_EQ("", handler_->SessionActivity());
+ if (endstage == XLTT_STAGE_AUTH_SUCCESS)
+ return;
+ }
+
+ case XLTT_STAGE_AUTHENTICATED_START: {
+ input = std::string("<stream:stream id=\"01234567\" version=\"1.0\" "
+ "xmlns:stream=\"http://etherx.jabber.org/streams\" "
+ "xmlns=\"jabber:client\">");
+ engine_->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("", handler_->StanzaActivity());
+ EXPECT_EQ("", handler_->SessionActivity());
+ EXPECT_EQ("", handler_->OutputActivity());
+ if (endstage == XLTT_STAGE_AUTHENTICATED_START)
+ return;
+ }
+
+ case XLTT_STAGE_BIND_FEATURES: {
+ input = "<stream:features>"
+ "<bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'/>"
+ "<session xmlns='urn:ietf:params:xml:ns:xmpp-session'/>"
+ "</stream:features>";
+ engine_->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("<iq type=\"set\" id=\"0\">"
+ "<bind xmlns=\"urn:ietf:params:xml:ns:xmpp-bind\"/></iq>",
+ handler_->OutputActivity());
+ EXPECT_EQ("", handler_->StanzaActivity());
+ EXPECT_EQ("", handler_->SessionActivity());
+ if (endstage == XLTT_STAGE_BIND_FEATURES)
+ return;
+ }
+
+ case XLTT_STAGE_BIND_SUCCESS: {
+ input = "<iq type='result' id='0'>"
+ "<bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'>"
+ "<jid>david@my-server/test</jid></bind></iq>";
+ engine_->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("<iq type=\"set\" id=\"1\">"
+ "<session xmlns=\"urn:ietf:params:xml:ns:xmpp-session\"/></iq>",
+ handler_->OutputActivity());
+ EXPECT_EQ("", handler_->StanzaActivity());
+ EXPECT_EQ("", handler_->SessionActivity());
+ if (endstage == XLTT_STAGE_BIND_SUCCESS)
+ return;
+ }
+
+ case XLTT_STAGE_SESSION_SUCCESS: {
+ input = "<iq type='result' id='1'/>";
+ engine_->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("<test:app-stanza xmlns:test=\"test\">this-is-a-test"
+ "</test:app-stanza>", handler_->OutputActivity());
+ EXPECT_EQ("[OPEN]", handler_->SessionActivity());
+ EXPECT_EQ("", handler_->StanzaActivity());
+ if (endstage == XLTT_STAGE_SESSION_SUCCESS)
+ return;
+ }
+ }
+}
+
+TEST_F(XmppLoginTaskTest, TestUtf8Good) {
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_CONNECT);
+
+ std::string input = "<?xml version='1.0' encoding='UTF-8'?>"
+ "<stream:stream id=\"a5f2d8c9\" version=\"1.0\" "
+ "xmlns:stream=\"http://etherx.jabber.org/streams\" "
+ "xmlns=\"jabber:client\">";
+ engine()->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("", handler()->OutputActivity());
+ EXPECT_EQ("", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestNonUtf8Bad) {
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_CONNECT);
+
+ std::string input = "<?xml version='1.0' encoding='ISO-8859-1'?>"
+ "<stream:stream id=\"a5f2d8c9\" version=\"1.0\" "
+ "xmlns:stream=\"http://etherx.jabber.org/streams\" "
+ "xmlns=\"jabber:client\">";
+ engine()->HandleInput(input.c_str(), input.length());
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-XML]", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestNoFeatures) {
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_STREAMSTART);
+
+ std::string input = "<iq type='get' id='1'/>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-VERSION]", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestTlsRequiredNotPresent) {
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_STREAMSTART);
+
+ std::string input = "<stream:features>"
+ "<mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>"
+ "<mechanism>DIGEST-MD5</mechanism>"
+ "<mechanism>PLAIN</mechanism>"
+ "</mechanisms>"
+ "</stream:features>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-TLS]", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestTlsRequeiredAndPresent) {
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_STREAMSTART);
+
+ std::string input = "<stream:features>"
+ "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'>"
+ "<required/>"
+ "</starttls>"
+ "<mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>"
+ "<mechanism>X-GOOGLE-TOKEN</mechanism>"
+ "<mechanism>PLAIN</mechanism>"
+ "<mechanism>X-OAUTH2</mechanism>"
+ "</mechanisms>"
+ "</stream:features>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("<starttls xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\"/>",
+ handler()->OutputActivity());
+ EXPECT_EQ("", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestTlsEnabledNotPresent) {
+ SetTlsOptions(buzz::TLS_ENABLED);
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_STREAMSTART);
+
+ std::string input = "<stream:features>"
+ "<mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>"
+ "<mechanism>DIGEST-MD5</mechanism>"
+ "<mechanism>PLAIN</mechanism>"
+ "</mechanisms>"
+ "</stream:features>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" "
+ "mechanism=\"PLAIN\" auth:allow-non-google-login=\"true\" "
+ "auth:client-uses-full-bind-result=\"true\" "
+ "xmlns:auth=\"http://www.google.com/talk/protocol/auth\""
+ ">AGRhdmlkAGRhdmlk</auth>", handler()->OutputActivity());
+ EXPECT_EQ("", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestTlsEnabledAndPresent) {
+ SetTlsOptions(buzz::TLS_ENABLED);
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_STREAMSTART);
+
+ std::string input = "<stream:features>"
+ "<mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>"
+ "<mechanism>X-GOOGLE-TOKEN</mechanism>"
+ "<mechanism>PLAIN</mechanism>"
+ "<mechanism>X-OAUTH2</mechanism>"
+ "</mechanisms>"
+ "</stream:features>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" "
+ "mechanism=\"PLAIN\" auth:allow-non-google-login=\"true\" "
+ "auth:client-uses-full-bind-result=\"true\" "
+ "xmlns:auth=\"http://www.google.com/talk/protocol/auth\""
+ ">AGRhdmlkAGRhdmlk</auth>", handler()->OutputActivity());
+ EXPECT_EQ("", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestTlsDisabledNotPresent) {
+ SetTlsOptions(buzz::TLS_DISABLED);
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_STREAMSTART);
+
+ std::string input = "<stream:features>"
+ "<mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>"
+ "<mechanism>DIGEST-MD5</mechanism>"
+ "<mechanism>PLAIN</mechanism>"
+ "</mechanisms>"
+ "</stream:features>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" "
+ "mechanism=\"PLAIN\" auth:allow-non-google-login=\"true\" "
+ "auth:client-uses-full-bind-result=\"true\" "
+ "xmlns:auth=\"http://www.google.com/talk/protocol/auth\""
+ ">AGRhdmlkAGRhdmlk</auth>", handler()->OutputActivity());
+ EXPECT_EQ("", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestTlsDisabledAndPresent) {
+ SetTlsOptions(buzz::TLS_DISABLED);
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_STREAMSTART);
+
+ std::string input = "<stream:features>"
+ "<mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>"
+ "<mechanism>X-GOOGLE-TOKEN</mechanism>"
+ "<mechanism>PLAIN</mechanism>"
+ "<mechanism>X-OAUTH2</mechanism>"
+ "</mechanisms>"
+ "</stream:features>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" "
+ "mechanism=\"PLAIN\" auth:allow-non-google-login=\"true\" "
+ "auth:client-uses-full-bind-result=\"true\" "
+ "xmlns:auth=\"http://www.google.com/talk/protocol/auth\""
+ ">AGRhdmlkAGRhdmlk</auth>", handler()->OutputActivity());
+ EXPECT_EQ("", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestTlsFailure) {
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_TLS_FEATURES);
+
+ std::string input = "<failure xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-TLS]", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestTlsBadStream) {
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_TLS_PROCEED);
+
+ std::string input = "<wrongtag>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-VERSION]", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestMissingSaslPlain) {
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_ENCRYPTED_START);
+
+ std::string input = "<stream:features>"
+ "<mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>"
+ "<mechanism>DIGEST-MD5</mechanism>"
+ "</mechanisms>"
+ "</stream:features>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-AUTH]", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestWrongPassword) {
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_AUTH_FEATURES);
+
+ std::string input = "<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl'/>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-UNAUTHORIZED]", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestAuthBadStream) {
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_AUTH_SUCCESS);
+
+ std::string input = "<wrongtag>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-VERSION]", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestMissingBindFeature) {
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_AUTHENTICATED_START);
+
+ std::string input = "<stream:features>"
+ "<session xmlns='urn:ietf:params:xml:ns:xmpp-session'/>"
+ "</stream:features>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-BIND]", handler()->SessionActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestMissingSessionFeature) {
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_AUTHENTICATED_START);
+
+ std::string input = "<stream:features>"
+ "<bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'/>"
+ "</stream:features>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-BIND]", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+/* TODO: Handle this case properly inside XmppLoginTask.
+TEST_F(XmppLoginTaskTest, TestBindFailure1) {
+ // check wrong JID
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_BIND_FEATURES);
+
+ std::string input = "<iq type='result' id='0'>"
+ "<bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'>"
+ "<jid>davey@my-server/test</jid></bind></iq>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-BIND]", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+*/
+
+TEST_F(XmppLoginTaskTest, TestBindFailure2) {
+ // check missing JID
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_BIND_FEATURES);
+
+ std::string input = "<iq type='result' id='0'>"
+ "<bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'/></iq>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-BIND]", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestBindFailure3) {
+ // check plain failure
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_BIND_FEATURES);
+
+ std::string input = "<iq type='error' id='0'/>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-BIND]", handler()->SessionActivity());
+ EXPECT_EQ("", handler()->StanzaActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestBindFailure4) {
+ // check wrong id to ignore
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_BIND_FEATURES);
+
+ std::string input = "<iq type='error' id='1'/>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ // continue after an ignored iq
+ RunPartialLogin(XLTT_STAGE_BIND_SUCCESS, XLTT_STAGE_SESSION_SUCCESS);
+}
+
+TEST_F(XmppLoginTaskTest, TestSessionFailurePlain1) {
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_BIND_SUCCESS);
+
+ std::string input = "<iq type='error' id='1'/>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-BIND]", handler()->SessionActivity());
+}
+
+TEST_F(XmppLoginTaskTest, TestSessionFailurePlain2) {
+ RunPartialLogin(XLTT_STAGE_CONNECT, XLTT_STAGE_BIND_SUCCESS);
+
+ // check reverse iq to ignore
+ // TODO: consider queueing or passing through?
+ std::string input = "<iq type='get' id='1'/>";
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("", handler()->OutputActivity());
+ EXPECT_EQ("", handler()->SessionActivity());
+
+ // continue after an ignored iq
+ RunPartialLogin(XLTT_STAGE_SESSION_SUCCESS, XLTT_STAGE_SESSION_SUCCESS);
+}
+
+TEST_F(XmppLoginTaskTest, TestBadXml) {
+ int errorKind = 0;
+ for (XlttStage stage = XLTT_STAGE_CONNECT;
+ stage <= XLTT_STAGE_SESSION_SUCCESS;
+ stage = static_cast<XlttStage>(stage + 1)) {
+ RunPartialLogin(XLTT_STAGE_CONNECT, stage);
+
+ std::string input;
+ switch (errorKind++ % 5) {
+ case 0: input = "&syntax;"; break;
+ case 1: input = "<nons:iq/>"; break;
+ case 2: input = "<iq a='b' a='dupe'/>"; break;
+ case 3: input = "<>"; break;
+ case 4: input = "<iq a='<wrong>'>"; break;
+ }
+
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-XML]", handler()->SessionActivity());
+
+ TearDown();
+ SetUp();
+ }
+}
+
+TEST_F(XmppLoginTaskTest, TestStreamError) {
+ for (XlttStage stage = XLTT_STAGE_CONNECT;
+ stage <= XLTT_STAGE_SESSION_SUCCESS;
+ stage = static_cast<XlttStage>(stage + 1)) {
+ switch (stage) {
+ case XLTT_STAGE_CONNECT:
+ case XLTT_STAGE_TLS_PROCEED:
+ case XLTT_STAGE_AUTH_SUCCESS:
+ continue;
+ default:
+ break;
+ }
+
+ RunPartialLogin(XLTT_STAGE_CONNECT, stage);
+
+ std::string input = "<stream:error>"
+ "<xml-not-well-formed xmlns='urn:ietf:params:xml:ns:xmpp-streams'/>"
+ "<text xml:lang='en' xmlns='urn:ietf:params:xml:ns:xmpp-streams'>"
+ "Some special application diagnostic information!"
+ "</text>"
+ "<escape-your-data xmlns='application-ns'/>"
+ "</stream:error>";
+
+ engine()->HandleInput(input.c_str(), input.length());
+
+ EXPECT_EQ("[CLOSED]", handler()->OutputActivity());
+ EXPECT_EQ("[CLOSED][ERROR-STREAM]", handler()->SessionActivity());
+
+ EXPECT_EQ("<str:error xmlns:str=\"http://etherx.jabber.org/streams\">"
+ "<xml-not-well-formed xmlns=\"urn:ietf:params:xml:ns:xmpp-streams\"/>"
+ "<text xml:lang=\"en\" xmlns=\"urn:ietf:params:xml:ns:xmpp-streams\">"
+ "Some special application diagnostic information!"
+ "</text>"
+ "<escape-your-data xmlns=\"application-ns\"/>"
+ "</str:error>", engine()->GetStreamError()->Str());
+
+ TearDown();
+ SetUp();
+ }
+}
+
diff --git a/talk/xmpp/xmppstanzaparser_unittest.cc b/talk/xmpp/xmppstanzaparser_unittest.cc
new file mode 100644
index 0000000..06faf87
--- /dev/null
+++ b/talk/xmpp/xmppstanzaparser_unittest.cc
@@ -0,0 +1,168 @@
+// Copyright 2004 Google Inc. All Rights Reserved
+
+
+#include <string>
+#include <sstream>
+#include <iostream>
+#include "talk/base/common.h"
+#include "talk/base/gunit.h"
+#include "talk/xmllite/xmlelement.h"
+#include "talk/xmpp/xmppstanzaparser.h"
+
+using buzz::QName;
+using buzz::XmlElement;
+using buzz::XmppStanzaParser;
+using buzz::XmppStanzaParseHandler;
+
+class XmppStanzaParserTestHandler : public XmppStanzaParseHandler {
+ public:
+ virtual void StartStream(const XmlElement * element) {
+ ss_ << "START" << element->Str();
+ }
+ virtual void Stanza(const XmlElement * element) {
+ ss_ << "STANZA" << element->Str();
+ }
+ virtual void EndStream() {
+ ss_ << "END";
+ }
+ virtual void XmlError() {
+ ss_ << "ERROR";
+ }
+
+ std::string Str() {
+ return ss_.str();
+ }
+
+ std::string StrClear() {
+ std::string result = ss_.str();
+ ss_.str("");
+ return result;
+ }
+
+ private:
+ std::stringstream ss_;
+};
+
+
+TEST(XmppStanzaParserTest, TestTrivial) {
+ XmppStanzaParserTestHandler handler;
+ XmppStanzaParser parser(&handler);
+ std::string fragment;
+
+ fragment = "<trivial/>";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("START<trivial/>END", handler.StrClear());
+}
+
+TEST(XmppStanzaParserTest, TestStanzaAtATime) {
+ XmppStanzaParserTestHandler handler;
+ XmppStanzaParser parser(&handler);
+ std::string fragment;
+
+ fragment = "<stream:stream id='abc' xmlns='j:c' xmlns:stream='str'>";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("START<stream:stream id=\"abc\" xmlns=\"j:c\" "
+ "xmlns:stream=\"str\"/>", handler.StrClear());
+
+ fragment = "<message type='foo'><body>hello</body></message>";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("STANZA<c:message type=\"foo\" xmlns:c=\"j:c\">"
+ "<c:body>hello</c:body></c:message>", handler.StrClear());
+
+ fragment = " SOME TEXT TO IGNORE ";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("", handler.StrClear());
+
+ fragment = "<iq type='set' id='123'><abc xmlns='def'/></iq>";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("STANZA<c:iq type=\"set\" id=\"123\" xmlns:c=\"j:c\">"
+ "<abc xmlns=\"def\"/></c:iq>", handler.StrClear());
+
+ fragment = "</stream:stream>";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("END", handler.StrClear());
+}
+
+TEST(XmppStanzaParserTest, TestFragmentedStanzas) {
+ XmppStanzaParserTestHandler handler;
+ XmppStanzaParser parser(&handler);
+ std::string fragment;
+
+ fragment = "<stream:stream id='abc' xmlns='j:c' xml";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("", handler.StrClear());
+
+ fragment = "ns:stream='str'><message type='foo'><body>hel";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("START<stream:stream id=\"abc\" xmlns=\"j:c\" "
+ "xmlns:stream=\"str\"/>", handler.StrClear());
+
+ fragment = "lo</body></message> IGNORE ME <iq type='set' id='123'>"
+ "<abc xmlns='def'/></iq></st";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("STANZA<c:message type=\"foo\" xmlns:c=\"j:c\">"
+ "<c:body>hello</c:body></c:message>STANZA<c:iq type=\"set\" id=\"123\" "
+ "xmlns:c=\"j:c\"><abc xmlns=\"def\"/></c:iq>", handler.StrClear());
+
+ fragment = "ream:stream>";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("END", handler.StrClear());
+}
+
+TEST(XmppStanzaParserTest, TestReset) {
+ XmppStanzaParserTestHandler handler;
+ XmppStanzaParser parser(&handler);
+ std::string fragment;
+
+ fragment = "<stream:stream id='abc' xmlns='j:c' xml";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("", handler.StrClear());
+
+ parser.Reset();
+ fragment = "<stream:stream id='abc' xmlns='j:c' xml";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("", handler.StrClear());
+
+ fragment = "ns:stream='str'><message type='foo'><body>hel";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("START<stream:stream id=\"abc\" xmlns=\"j:c\" "
+ "xmlns:stream=\"str\"/>", handler.StrClear());
+ parser.Reset();
+
+ fragment = "<stream:stream id='abc' xmlns='j:c' xmlns:stream='str'>";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("START<stream:stream id=\"abc\" xmlns=\"j:c\" "
+ "xmlns:stream=\"str\"/>", handler.StrClear());
+
+ fragment = "<message type='foo'><body>hello</body></message>";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("STANZA<c:message type=\"foo\" xmlns:c=\"j:c\">"
+ "<c:body>hello</c:body></c:message>", handler.StrClear());
+}
+
+TEST(XmppStanzaParserTest, TestError) {
+ XmppStanzaParserTestHandler handler;
+ XmppStanzaParser parser(&handler);
+ std::string fragment;
+
+ fragment = "<-foobar/>";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("ERROR", handler.StrClear());
+
+ parser.Reset();
+ fragment = "<stream:stream/>";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("ERROR", handler.StrClear());
+ parser.Reset();
+
+ fragment = "ns:stream='str'><message type='foo'><body>hel";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("ERROR", handler.StrClear());
+ parser.Reset();
+
+ fragment = "<stream:stream xmlns:stream='st' xmlns='jc'>"
+ "<foo/><bar><st:foobar/></bar>";
+ parser.Parse(fragment.c_str(), fragment.length(), false);
+ EXPECT_EQ("START<stream:stream xmlns:stream=\"st\" xmlns=\"jc\"/>STANZA"
+ "<jc:foo xmlns:jc=\"jc\"/>ERROR", handler.StrClear());
+}
diff --git a/talk/xmpp/xmpptask.cc b/talk/xmpp/xmpptask.cc
index 60841d4..046f7a1 100644
--- a/talk/xmpp/xmpptask.cc
+++ b/talk/xmpp/xmpptask.cc
@@ -29,12 +29,9 @@
#include "talk/xmpp/xmppclient.h"
#include "talk/xmpp/xmppengine.h"
#include "talk/xmpp/constants.h"
-#include "talk/xmpp/ratelimitmanager.h"
namespace buzz {
-RateLimitManager task_rate_manager;
-
XmppClientInterface::XmppClientInterface() {
}
@@ -115,7 +112,7 @@
XmlElement* result = new XmlElement(QN_IQ);
if (!type.empty())
result->AddAttr(QN_TYPE, type);
- if (to != JID_EMPTY)
+ if (!to.IsEmpty())
result->AddAttr(QN_TO, to.Str());
if (!id.empty())
result->AddAttr(QN_ID, id);
@@ -151,7 +148,7 @@
return true;
// We address the server as "", check if we are doing so here.
- if (to != JID_EMPTY)
+ if (!to.IsEmpty())
return false;
// It is legal for the server to identify itself with "domain" or
@@ -175,10 +172,4 @@
return true;
}
-bool XmppTask::VerifyTaskRateLimit(const std::string task_name, int max_count,
- int per_x_seconds) {
- return task_rate_manager.VerifyRateLimit(task_name, max_count,
- per_x_seconds);
-}
-
}
