2 files changed, 4 insertions, 3 deletions
diff --git a/Swiften/Component/ComponentSession.cpp b/Swiften/Component/ComponentSession.cpp
index af11146..51d9d15 100644
--- a/Swiften/Component/ComponentSession.cpp
+++ b/Swiften/Component/ComponentSession.cpp
@@ -1,44 +1,45 @@
 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include <Swiften/Component/ComponentSession.h>
 
 #include <boost/bind.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
 
 #include <Swiften/Elements/ProtocolHeader.h>
 #include <Swiften/Elements/ComponentHandshake.h>
 #include <Swiften/Session/SessionStream.h>
 #include <Swiften/Component/ComponentHandshakeGenerator.h>
 
 namespace Swift {
 
 ComponentSession::ComponentSession(const JID& jid, const std::string& secret, boost::shared_ptr<SessionStream> stream) : jid(jid), secret(secret), stream(stream), state(Initial) {
 }
 
 ComponentSession::~ComponentSession() {
 }
 
 void ComponentSession::start() {
 	stream->onStreamStartReceived.connect(boost::bind(&ComponentSession::handleStreamStart, shared_from_this(), _1));
 	stream->onElementReceived.connect(boost::bind(&ComponentSession::handleElement, shared_from_this(), _1));
 	stream->onClosed.connect(boost::bind(&ComponentSession::handleStreamClosed, shared_from_this(), _1));
 
 	assert(state == Initial);
 	state = WaitingForStreamStart;
 	sendStreamHeader();
 }
 
 void ComponentSession::sendStreamHeader() {
 	ProtocolHeader header;
 	header.setTo(jid);
 	stream->writeHeader(header);
 }
 
 void ComponentSession::sendStanza(boost::shared_ptr<Stanza> stanza) {
 	stream->writeElement(stanza);
 }
 
 void ComponentSession::handleStreamStart(const ProtocolHeader& header) {
@@ -69,47 +70,47 @@ void ComponentSession::handleElement(boost::shared_ptr<Element> element) {
 		finishSession(Error::AuthenticationFailedError);
 	}
 	else {
 		finishSession(Error::UnexpectedElementError);
 	}
 }
 
 bool ComponentSession::checkState(State state) {
 	if (this->state != state) {
 		finishSession(Error::UnexpectedElementError);
 		return false;
 	}
 	return true;
 }
 
 void ComponentSession::handleStreamClosed(boost::shared_ptr<Swift::Error> streamError) {
 	State oldState = state;
 	state = Finished;
 	stream->setWhitespacePingEnabled(false);
 	stream->onStreamStartReceived.disconnect(boost::bind(&ComponentSession::handleStreamStart, shared_from_this(), _1));
 	stream->onElementReceived.disconnect(boost::bind(&ComponentSession::handleElement, shared_from_this(), _1));
 	stream->onClosed.disconnect(boost::bind(&ComponentSession::handleStreamClosed, shared_from_this(), _1));
 	if (oldState == Finishing) {
 		onFinished(error);
 	}
 	else {
 		onFinished(streamError);
 	}
 }
 
 void ComponentSession::finish() {
 	finishSession(boost::shared_ptr<Error>());
 }
 
 void ComponentSession::finishSession(Error::Type error) {
-	finishSession(boost::shared_ptr<Swift::ComponentSession::Error>(new Swift::ComponentSession::Error(error)));
+	finishSession(boost::make_shared<Swift::ComponentSession::Error>(error));
 }
 
 void ComponentSession::finishSession(boost::shared_ptr<Swift::Error> finishError) {
 	state = Finishing;
 	error = finishError;
 	assert(stream->isOpen());
 	stream->writeFooter();
 	stream->close();
 }
 
 }
diff --git a/Swiften/Component/UnitTest/ComponentSessionTest.cpp b/Swiften/Component/UnitTest/ComponentSessionTest.cpp
index 1541cce..9763c7f 100644
--- a/Swiften/Component/UnitTest/ComponentSessionTest.cpp
+++ b/Swiften/Component/UnitTest/ComponentSessionTest.cpp
@@ -1,64 +1,64 @@
 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <deque>
 #include <boost/bind.hpp>
 #include <boost/optional.hpp>
 
 #include <Swiften/Session/SessionStream.h>
 #include <Swiften/Component/ComponentSession.h>
 #include <Swiften/Elements/ComponentHandshake.h>
 #include <Swiften/Elements/AuthFailure.h>
 
 using namespace Swift;
 
 class ComponentSessionTest : public CppUnit::TestFixture {
 		CPPUNIT_TEST_SUITE(ComponentSessionTest);
 		CPPUNIT_TEST(testStart);
 		CPPUNIT_TEST(testStart_Error);
 		CPPUNIT_TEST(testStart_Unauthorized);
 		CPPUNIT_TEST_SUITE_END();
 
 	public:
 		void setUp() {
-			server = boost::shared_ptr<MockSessionStream>(new MockSessionStream());
+			server = boost::make_shared<MockSessionStream>();
 			sessionFinishedReceived = false;
 		}
 
 		void testStart() {
 			boost::shared_ptr<ComponentSession> session(createSession());
 			session->start();
 			server->receiveStreamStart();
 			server->sendStreamStart();
 			server->receiveHandshake();
 			server->sendHandshakeResponse();
 
 			CPPUNIT_ASSERT(server->whitespacePingEnabled);
 
 			session->finish();
 			CPPUNIT_ASSERT(!server->whitespacePingEnabled);
 
 		}
 
 		void testStart_Error() {
 			boost::shared_ptr<ComponentSession> session(createSession());
 			session->start();
 			server->breakConnection();
 
 			CPPUNIT_ASSERT_EQUAL(ComponentSession::Finished, session->getState());
 			CPPUNIT_ASSERT(sessionFinishedReceived);
 			CPPUNIT_ASSERT(sessionFinishedError);
 		}
 
 		void testStart_Unauthorized() {
 			boost::shared_ptr<ComponentSession> session(createSession());
 			session->start();
 			server->receiveStreamStart();
 			server->sendStreamStart();
 			server->receiveHandshake();
 			server->sendHandshakeError();
@@ -127,71 +127,71 @@ class ComponentSessionTest : public CppUnit::TestFixture {
 				}
 
 				virtual bool isTLSEncrypted() {
 					return false;
 				}
 
 				virtual ByteArray getTLSFinishMessage() const {
 					return ByteArray();
 				}
 
 				virtual Certificate::ref getPeerCertificate() const {
 					return Certificate::ref();
 				}
 
 				virtual boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const {
 					return boost::shared_ptr<CertificateVerificationError>();
 				}
 
 				virtual bool supportsZLibCompression() {
 					return true;
 				}
 
 				virtual void addZLibCompression() {
 					assert(false);
 				}
 
 				virtual void setWhitespacePingEnabled(bool enabled) {
 					whitespacePingEnabled = enabled;
 				}
 
 				virtual void resetXMPPParser() {
 					resetCount++;
 				}
 
 				void breakConnection() {
-					onClosed(boost::shared_ptr<SessionStream::Error>(new SessionStream::Error(SessionStream::Error::ConnectionReadError)));
+					onClosed(boost::make_shared<SessionStream::Error>(SessionStream::Error::ConnectionReadError));
 				}
 
 				void sendStreamStart() {
 					ProtocolHeader header;
 					header.setFrom("service.foo.com");
 					return onStreamStartReceived(header);
 				}
 
 				void sendHandshakeResponse() {
 					onElementReceived(ComponentHandshake::ref(new ComponentHandshake()));
 				}
 
 				void sendHandshakeError() {
 					// FIXME: This isn't the correct element
 					onElementReceived(AuthFailure::ref(new AuthFailure()));
 				}
 
 				void receiveStreamStart() {
 					Event event = popEvent();
 					CPPUNIT_ASSERT(event.header);
 				}
 
 				void receiveHandshake() {
 					Event event = popEvent();
 					CPPUNIT_ASSERT(event.element);
 					ComponentHandshake::ref handshake(boost::dynamic_pointer_cast<ComponentHandshake>(event.element));
 					CPPUNIT_ASSERT(handshake);
 					CPPUNIT_ASSERT_EQUAL(std::string("4c4f8a41141722c8bbfbdd92d827f7b2fc0a542b"), handshake->getData());
 				}
 
 				Event popEvent() {
 					CPPUNIT_ASSERT(!receivedEvents.empty());
 					Event event = receivedEvents.front();
 					receivedEvents.pop_front();
 					return event;