From b2295b0cec258dba9b265e43b29b6c7cc5a973c8 Mon Sep 17 00:00:00 2001 From: "akalin@chromium.org" Date: Wed, 1 Sep 2010 04:16:54 +0000 Subject: Added XmppClientSocketFactory for use with ChromeAsyncSocket XmppClientSocketFactory serves up regular TCP sockets or fake SSL TCP sockets. This way, ChromeAsyncSocket has feature parity with XmppSocketAdapter. BUG=45612 TEST=existing unittests Review URL: http://codereview.chromium.org/3299001 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@58121 0039d316-1c4b-4281-b951-d872f2087c98 --- jingle/jingle.gyp | 2 + jingle/notifier/base/chrome_async_socket.cc | 2 +- jingle/notifier/base/chrome_async_socket.h | 5 +- .../notifier/base/chrome_async_socket_unittest.cc | 173 +++++++++++---------- jingle/notifier/base/xmpp_client_socket_factory.cc | 41 +++++ jingle/notifier/base/xmpp_client_socket_factory.h | 40 +++++ .../notifier/communicator/single_login_attempt.cc | 7 +- 7 files changed, 179 insertions(+), 91 deletions(-) create mode 100644 jingle/notifier/base/xmpp_client_socket_factory.cc create mode 100644 jingle/notifier/base/xmpp_client_socket_factory.h (limited to 'jingle') diff --git a/jingle/jingle.gyp b/jingle/jingle.gyp index 0b093fa..dd76e04 100644 --- a/jingle/jingle.gyp +++ b/jingle/jingle.gyp @@ -25,6 +25,8 @@ 'notifier/base/static_assert.h', 'notifier/base/task_pump.cc', 'notifier/base/task_pump.h', + 'notifier/base/xmpp_client_socket_factory.cc', + 'notifier/base/xmpp_client_socket_factory.h', 'notifier/communicator/connection_options.cc', 'notifier/communicator/connection_options.h', 'notifier/communicator/connection_settings.cc', diff --git a/jingle/notifier/base/chrome_async_socket.cc b/jingle/notifier/base/chrome_async_socket.cc index dc8bc7e..f9a852e 100644 --- a/jingle/notifier/base/chrome_async_socket.cc +++ b/jingle/notifier/base/chrome_async_socket.cc @@ -57,7 +57,7 @@ ChromeAsyncSocket::ChromeAsyncSocket( write_state_(IDLE), write_buf_(new net::IOBufferWithSize(write_buf_size)), write_end_(0U) { - DCHECK(client_socket_factory_); + DCHECK(client_socket_factory_.get()); DCHECK_GT(read_buf_size, 0U); DCHECK_GT(write_buf_size, 0U); } diff --git a/jingle/notifier/base/chrome_async_socket.h b/jingle/notifier/base/chrome_async_socket.h index ebf8b38..1af5dad 100644 --- a/jingle/notifier/base/chrome_async_socket.h +++ b/jingle/notifier/base/chrome_async_socket.h @@ -34,7 +34,7 @@ namespace notifier { class ChromeAsyncSocket : public buzz::AsyncSocket { public: - // Does not take ownership of |client_socket_factory| or |net_log|. + // Takes ownership of |client_socket_factory| but not |net_log|. // |net_log| may be NULL. ChromeAsyncSocket(net::ClientSocketFactory* client_socket_factory, const net::SSLConfig& ssl_config, @@ -185,8 +185,7 @@ class ChromeAsyncSocket : public buzz::AsyncSocket { net::CompletionCallbackImpl write_callback_; net::CompletionCallbackImpl ssl_connect_callback_; - // Weak pointer. - net::ClientSocketFactory* const client_socket_factory_; + scoped_ptr client_socket_factory_; const net::SSLConfig ssl_config_; net::BoundNetLog bound_net_log_; diff --git a/jingle/notifier/base/chrome_async_socket_unittest.cc b/jingle/notifier/base/chrome_async_socket_unittest.cc index a975d6f..fa95f91 100644 --- a/jingle/notifier/base/chrome_async_socket_unittest.cc +++ b/jingle/notifier/base/chrome_async_socket_unittest.cc @@ -10,6 +10,7 @@ #include "base/basictypes.h" #include "base/logging.h" #include "base/message_loop.h" +#include "base/scoped_ptr.h" #include "net/base/ssl_config_service.h" #include "net/base/capturing_net_log.h" #include "net/base/net_errors.h" @@ -100,27 +101,31 @@ class ChromeAsyncSocketTest ChromeAsyncSocketTest() : ssl_socket_data_provider_(true, net::OK), capturing_net_log_(net::CapturingNetLog::kUnbounded), - chrome_async_socket_(&mock_client_socket_factory_, - ssl_config_, 14, 20, &capturing_net_log_), addr_(0xaabbccdd, 35) {} virtual ~ChromeAsyncSocketTest() {} virtual void SetUp() { - mock_client_socket_factory_.AddSocketDataProvider( + scoped_ptr mock_client_socket_factory( + new net::MockClientSocketFactory()); + mock_client_socket_factory->AddSocketDataProvider( &async_socket_data_provider_); - mock_client_socket_factory_.AddSSLSocketDataProvider( + mock_client_socket_factory->AddSSLSocketDataProvider( &ssl_socket_data_provider_); - chrome_async_socket_.SignalConnected.connect( + chrome_async_socket_.reset( + new ChromeAsyncSocket(mock_client_socket_factory.release(), + ssl_config_, 14, 20, &capturing_net_log_)), + + chrome_async_socket_->SignalConnected.connect( this, &ChromeAsyncSocketTest::OnConnect); - chrome_async_socket_.SignalSSLConnected.connect( + chrome_async_socket_->SignalSSLConnected.connect( this, &ChromeAsyncSocketTest::OnSSLConnect); - chrome_async_socket_.SignalClosed.connect( + chrome_async_socket_->SignalClosed.connect( this, &ChromeAsyncSocketTest::OnClose); - chrome_async_socket_.SignalRead.connect( + chrome_async_socket_->SignalRead.connect( this, &ChromeAsyncSocketTest::OnRead); - chrome_async_socket_.SignalError.connect( + chrome_async_socket_->SignalError.connect( this, &ChromeAsyncSocketTest::OnError); } @@ -129,11 +134,7 @@ class ChromeAsyncSocketTest message_loop_.RunAllPending(); ExpectClosed(); ExpectNoSignal(); - chrome_async_socket_.SignalConnected.disconnect(this); - chrome_async_socket_.SignalSSLConnected.disconnect(this); - chrome_async_socket_.SignalClosed.disconnect(this); - chrome_async_socket_.SignalRead.disconnect(this); - chrome_async_socket_.SignalError.disconnect(this); + chrome_async_socket_.reset(); } enum Signal { @@ -196,7 +197,8 @@ class ChromeAsyncSocketTest void CaptureSocketState(Signal signal) { signal_socket_states_.push_back( - SignalSocketState::FromAsyncSocket(signal, &chrome_async_socket_)); + SignalSocketState::FromAsyncSocket( + signal, chrome_async_socket_.get())); } void OnConnect() { @@ -224,9 +226,9 @@ class ChromeAsyncSocketTest void ExpectState(ChromeAsyncSocket::State state, ChromeAsyncSocket::Error error, net::Error net_error) { - EXPECT_EQ(state, chrome_async_socket_.state()); - EXPECT_EQ(error, chrome_async_socket_.error()); - EXPECT_EQ(net_error, chrome_async_socket_.GetError()); + EXPECT_EQ(state, chrome_async_socket_->state()); + EXPECT_EQ(error, chrome_async_socket_->error()); + EXPECT_EQ(net_error, chrome_async_socket_->GetError()); } void ExpectNonErrorState(ChromeAsyncSocket::State state) { @@ -286,7 +288,7 @@ class ChromeAsyncSocketTest ExpectClosed(); async_socket_data_provider_.set_connect_data( net::MockConnect(false, net::OK)); - EXPECT_TRUE(chrome_async_socket_.Connect(addr_)); + EXPECT_TRUE(chrome_async_socket_->Connect(addr_)); ExpectNonErrorState(ChromeAsyncSocket::STATE_CONNECTING); message_loop_.RunAllPending(); @@ -299,8 +301,8 @@ class ChromeAsyncSocketTest void DoCloseOpened(SignalSocketState expected_signal_socket_state) { // We may be in an error state, so just compare state(). - EXPECT_EQ(ChromeAsyncSocket::STATE_OPEN, chrome_async_socket_.state()); - EXPECT_TRUE(chrome_async_socket_.Close()); + EXPECT_EQ(ChromeAsyncSocket::STATE_OPEN, chrome_async_socket_->state()); + EXPECT_TRUE(chrome_async_socket_->Close()); ExpectSignalSocketState(expected_signal_socket_state); ExpectNonErrorState(ChromeAsyncSocket::STATE_CLOSED); } @@ -318,7 +320,7 @@ class ChromeAsyncSocketTest ExpectReadSignal(); EXPECT_EQ(kDummyData, DrainRead(1)); - EXPECT_TRUE(chrome_async_socket_.StartTls("fakedomain.com")); + EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com")); message_loop_.RunAllPending(); ExpectSSLConnectSignal(); ExpectNoSignal(); @@ -328,8 +330,8 @@ class ChromeAsyncSocketTest void DoSSLCloseOpened(SignalSocketState expected_signal_socket_state) { // We may be in an error state, so just compare state(). EXPECT_EQ(ChromeAsyncSocket::STATE_TLS_OPEN, - chrome_async_socket_.state()); - EXPECT_TRUE(chrome_async_socket_.Close()); + chrome_async_socket_->state()); + EXPECT_TRUE(chrome_async_socket_->Close()); ExpectSignalSocketState(expected_signal_socket_state); ExpectNonErrorState(ChromeAsyncSocket::STATE_CLOSED); } @@ -348,7 +350,7 @@ class ChromeAsyncSocketTest size_t len_read; while (true) { bool success = - chrome_async_socket_.Read(buf.get(), buf_size, &len_read); + chrome_async_socket_->Read(buf.get(), buf_size, &len_read); if (!success) { ADD_FAILURE(); break; @@ -364,13 +366,12 @@ class ChromeAsyncSocketTest // ChromeAsyncSocket expects a message loop. MessageLoop message_loop_; - net::MockClientSocketFactory mock_client_socket_factory_; AsyncSocketDataProvider async_socket_data_provider_; net::SSLSocketDataProvider ssl_socket_data_provider_; net::CapturingNetLog capturing_net_log_; net::SSLConfig ssl_config_; - ChromeAsyncSocket chrome_async_socket_; + scoped_ptr chrome_async_socket_; std::deque signal_socket_states_; const talk_base::SocketAddress addr_; @@ -385,7 +386,7 @@ TEST_F(ChromeAsyncSocketTest, InitialState) { TEST_F(ChromeAsyncSocketTest, EmptyClose) { ExpectClosed(); - EXPECT_TRUE(chrome_async_socket_.Close()); + EXPECT_TRUE(chrome_async_socket_->Close()); ExpectClosed(); } @@ -403,23 +404,23 @@ TEST_F(ChromeAsyncSocketTest, ImmediateConnectAndClose) { TEST_F(ChromeAsyncSocketTest, DoubleClose) { DoOpenClosed(); - EXPECT_TRUE(chrome_async_socket_.Close()); + EXPECT_TRUE(chrome_async_socket_->Close()); ExpectClosed(); ExpectSignalSocketState( SignalSocketState::NoError( SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED)); - EXPECT_TRUE(chrome_async_socket_.Close()); + EXPECT_TRUE(chrome_async_socket_->Close()); ExpectClosed(); } TEST_F(ChromeAsyncSocketTest, UnresolvedConnect) { const talk_base::SocketAddress unresolved_addr(0, 0); - EXPECT_FALSE(chrome_async_socket_.Connect(unresolved_addr)); + EXPECT_FALSE(chrome_async_socket_->Connect(unresolved_addr)); ExpectErrorState(ChromeAsyncSocket::STATE_CLOSED, ChromeAsyncSocket::ERROR_DNS); - EXPECT_TRUE(chrome_async_socket_.Close()); + EXPECT_TRUE(chrome_async_socket_->Close()); ExpectClosed(); } @@ -427,7 +428,7 @@ TEST_F(ChromeAsyncSocketTest, DoubleConnect) { EXPECT_DEBUG_DEATH({ DoOpenClosed(); - EXPECT_FALSE(chrome_async_socket_.Connect(addr_)); + EXPECT_FALSE(chrome_async_socket_->Connect(addr_)); ExpectErrorState(ChromeAsyncSocket::STATE_OPEN, ChromeAsyncSocket::ERROR_WRONGSTATE); @@ -442,7 +443,7 @@ TEST_F(ChromeAsyncSocketTest, DoubleConnect) { TEST_F(ChromeAsyncSocketTest, ImmediateConnectCloseBeforeRead) { DoOpenClosed(); - EXPECT_TRUE(chrome_async_socket_.Close()); + EXPECT_TRUE(chrome_async_socket_->Close()); ExpectClosed(); ExpectSignalSocketState( SignalSocketState::NoError( @@ -452,11 +453,11 @@ TEST_F(ChromeAsyncSocketTest, ImmediateConnectCloseBeforeRead) { } TEST_F(ChromeAsyncSocketTest, HangingConnect) { - EXPECT_TRUE(chrome_async_socket_.Connect(addr_)); + EXPECT_TRUE(chrome_async_socket_->Connect(addr_)); ExpectNonErrorState(ChromeAsyncSocket::STATE_CONNECTING); ExpectNoSignal(); - EXPECT_TRUE(chrome_async_socket_.Close()); + EXPECT_TRUE(chrome_async_socket_->Close()); ExpectClosed(); ExpectSignalSocketState( SignalSocketState::NoError( @@ -466,7 +467,7 @@ TEST_F(ChromeAsyncSocketTest, HangingConnect) { TEST_F(ChromeAsyncSocketTest, PendingConnect) { async_socket_data_provider_.set_connect_data( net::MockConnect(true, net::OK)); - EXPECT_TRUE(chrome_async_socket_.Connect(addr_)); + EXPECT_TRUE(chrome_async_socket_->Connect(addr_)); ExpectNonErrorState(ChromeAsyncSocket::STATE_CONNECTING); ExpectNoSignal(); @@ -488,7 +489,7 @@ TEST_F(ChromeAsyncSocketTest, PendingConnect) { TEST_F(ChromeAsyncSocketTest, PendingConnectCloseBeforeRead) { async_socket_data_provider_.set_connect_data( net::MockConnect(true, net::OK)); - EXPECT_TRUE(chrome_async_socket_.Connect(addr_)); + EXPECT_TRUE(chrome_async_socket_->Connect(addr_)); message_loop_.RunAllPending(); ExpectSignalSocketState( @@ -503,7 +504,7 @@ TEST_F(ChromeAsyncSocketTest, PendingConnectCloseBeforeRead) { TEST_F(ChromeAsyncSocketTest, PendingConnectError) { async_socket_data_provider_.set_connect_data( net::MockConnect(true, net::ERR_TIMED_OUT)); - EXPECT_TRUE(chrome_async_socket_.Connect(addr_)); + EXPECT_TRUE(chrome_async_socket_->Connect(addr_)); message_loop_.RunAllPending(); @@ -520,7 +521,7 @@ TEST_F(ChromeAsyncSocketTest, EmptyRead) { char buf[4096]; size_t len_read = 10000U; - EXPECT_TRUE(chrome_async_socket_.Read(buf, sizeof(buf), &len_read)); + EXPECT_TRUE(chrome_async_socket_->Read(buf, sizeof(buf), &len_read)); EXPECT_EQ(0U, len_read); DoCloseOpenedNoError(); @@ -530,26 +531,26 @@ TEST_F(ChromeAsyncSocketTest, WrongRead) { EXPECT_DEBUG_DEATH({ async_socket_data_provider_.set_connect_data( net::MockConnect(true, net::OK)); - EXPECT_TRUE(chrome_async_socket_.Connect(addr_)); + EXPECT_TRUE(chrome_async_socket_->Connect(addr_)); ExpectNonErrorState(ChromeAsyncSocket::STATE_CONNECTING); ExpectNoSignal(); char buf[4096]; size_t len_read; - EXPECT_FALSE(chrome_async_socket_.Read(buf, sizeof(buf), &len_read)); + EXPECT_FALSE(chrome_async_socket_->Read(buf, sizeof(buf), &len_read)); ExpectErrorState(ChromeAsyncSocket::STATE_CLOSED, ChromeAsyncSocket::ERROR_WRONGSTATE); - EXPECT_TRUE(chrome_async_socket_.Close()); + EXPECT_TRUE(chrome_async_socket_->Close()); }, "non-open"); } TEST_F(ChromeAsyncSocketTest, WrongReadClosed) { char buf[4096]; size_t len_read; - EXPECT_FALSE(chrome_async_socket_.Read(buf, sizeof(buf), &len_read)); + EXPECT_FALSE(chrome_async_socket_->Read(buf, sizeof(buf), &len_read)); ExpectErrorState(ChromeAsyncSocket::STATE_CLOSED, ChromeAsyncSocket::ERROR_WRONGSTATE); - EXPECT_TRUE(chrome_async_socket_.Close()); + EXPECT_TRUE(chrome_async_socket_->Close()); } const char kReadData[] = "mydatatoread"; @@ -669,10 +670,10 @@ TEST_F(ChromeAsyncSocketTest, PendingReadError) { TEST_F(ChromeAsyncSocketTest, WrongWrite) { EXPECT_DEBUG_DEATH({ std::string data("foo"); - EXPECT_FALSE(chrome_async_socket_.Write(data.data(), data.size())); + EXPECT_FALSE(chrome_async_socket_->Write(data.data(), data.size())); ExpectErrorState(ChromeAsyncSocket::STATE_CLOSED, ChromeAsyncSocket::ERROR_WRONGSTATE); - EXPECT_TRUE(chrome_async_socket_.Close()); + EXPECT_TRUE(chrome_async_socket_->Close()); }, "non-open"); } @@ -687,12 +688,12 @@ TEST_F(ChromeAsyncSocketTest, SyncWrite) { net::MockWrite(false, kWriteData + 8, arraysize(kWriteData) - 8)); DoOpenClosed(); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData, 3)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3)); message_loop_.RunAllPending(); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData + 3, 5)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5)); message_loop_.RunAllPending(); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData + 8, - arraysize(kWriteData) - 8)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8, + arraysize(kWriteData) - 8)); message_loop_.RunAllPending(); ExpectNoSignal(); @@ -710,12 +711,12 @@ TEST_F(ChromeAsyncSocketTest, AsyncWrite) { async_socket_data_provider_.AddWrite( net::MockWrite(true, kWriteData + 8, arraysize(kWriteData) - 8)); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData, 3)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3)); message_loop_.RunAllPending(); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData + 3, 5)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5)); message_loop_.RunAllPending(); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData + 8, - arraysize(kWriteData) - 8)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8, + arraysize(kWriteData) - 8)); message_loop_.RunAllPending(); ExpectNoSignal(); @@ -733,12 +734,12 @@ TEST_F(ChromeAsyncSocketTest, AsyncWriteError) { async_socket_data_provider_.AddWrite( net::MockWrite(true, net::ERR_TIMED_OUT)); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData, 3)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3)); message_loop_.RunAllPending(); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData + 3, 5)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5)); message_loop_.RunAllPending(); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData + 8, - arraysize(kWriteData) - 8)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8, + arraysize(kWriteData) - 8)); message_loop_.RunAllPending(); ExpectSignalSocketState( @@ -752,8 +753,8 @@ TEST_F(ChromeAsyncSocketTest, LargeWrite) { DoOpenClosed(); std::string large_data(100, 'x'); - EXPECT_FALSE(chrome_async_socket_.Write(large_data.data(), - large_data.size())); + EXPECT_FALSE(chrome_async_socket_->Write(large_data.data(), + large_data.size())); ExpectState(ChromeAsyncSocket::STATE_OPEN, ChromeAsyncSocket::ERROR_WINSOCK, net::ERR_INSUFFICIENT_RESOURCES); @@ -770,8 +771,8 @@ TEST_F(ChromeAsyncSocketTest, LargeAccumulatedWrite) { DoOpenClosed(); std::string data(15, 'x'); - EXPECT_TRUE(chrome_async_socket_.Write(data.data(), data.size())); - EXPECT_FALSE(chrome_async_socket_.Write(data.data(), data.size())); + EXPECT_TRUE(chrome_async_socket_->Write(data.data(), data.size())); + EXPECT_FALSE(chrome_async_socket_->Write(data.data(), data.size())); ExpectState(ChromeAsyncSocket::STATE_OPEN, ChromeAsyncSocket::ERROR_WINSOCK, net::ERR_INSUFFICIENT_RESOURCES); @@ -790,11 +791,11 @@ TEST_F(ChromeAsyncSocketTest, HangingSSLConnect) { DoOpenClosed(); ExpectReadSignal(); - EXPECT_TRUE(chrome_async_socket_.StartTls("fakedomain.com")); + EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com")); ExpectNoSignal(); ExpectNonErrorState(ChromeAsyncSocket::STATE_TLS_CONNECTING); - EXPECT_TRUE(chrome_async_socket_.Close()); + EXPECT_TRUE(chrome_async_socket_->Close()); ExpectSignalSocketState( SignalSocketState::NoError(SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED)); @@ -806,7 +807,7 @@ TEST_F(ChromeAsyncSocketTest, ImmediateSSLConnect) { DoOpenClosed(); ExpectReadSignal(); - EXPECT_TRUE(chrome_async_socket_.StartTls("fakedomain.com")); + EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com")); message_loop_.RunAllPending(); ExpectSSLConnectSignal(); ExpectNoSignal(); @@ -821,13 +822,13 @@ TEST_F(ChromeAsyncSocketTest, DoubleSSLConnect) { DoOpenClosed(); ExpectReadSignal(); - EXPECT_TRUE(chrome_async_socket_.StartTls("fakedomain.com")); + EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com")); message_loop_.RunAllPending(); ExpectSSLConnectSignal(); ExpectNoSignal(); ExpectNonErrorState(ChromeAsyncSocket::STATE_TLS_OPEN); - EXPECT_FALSE(chrome_async_socket_.StartTls("fakedomain.com")); + EXPECT_FALSE(chrome_async_socket_->StartTls("fakedomain.com")); DoSSLCloseOpened( SignalSocketState(SIGNAL_CLOSE, @@ -845,7 +846,7 @@ TEST_F(ChromeAsyncSocketTest, FailedSSLConnect) { DoOpenClosed(); ExpectReadSignal(); - EXPECT_TRUE(chrome_async_socket_.StartTls("fakedomain.com")); + EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com")); message_loop_.RunAllPending(); ExpectSignalSocketState( SignalSocketState( @@ -853,7 +854,7 @@ TEST_F(ChromeAsyncSocketTest, FailedSSLConnect) { ChromeAsyncSocket::ERROR_WINSOCK, net::ERR_CERT_COMMON_NAME_INVALID)); - EXPECT_TRUE(chrome_async_socket_.Close()); + EXPECT_TRUE(chrome_async_socket_->Close()); ExpectClosed(); } @@ -863,7 +864,7 @@ TEST_F(ChromeAsyncSocketTest, ReadDuringSSLConnecting) { ExpectReadSignal(); EXPECT_EQ(kReadData, DrainRead(1)); - EXPECT_TRUE(chrome_async_socket_.StartTls("fakedomain.com")); + EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com")); ExpectNoSignal(); // Shouldn't do anything. @@ -871,7 +872,7 @@ TEST_F(ChromeAsyncSocketTest, ReadDuringSSLConnecting) { char buf[4096]; size_t len_read = 10000U; - EXPECT_TRUE(chrome_async_socket_.Read(buf, sizeof(buf), &len_read)); + EXPECT_TRUE(chrome_async_socket_->Read(buf, sizeof(buf), &len_read)); EXPECT_EQ(0U, len_read); message_loop_.RunAllPending(); @@ -881,7 +882,7 @@ TEST_F(ChromeAsyncSocketTest, ReadDuringSSLConnecting) { ExpectNonErrorState(ChromeAsyncSocket::STATE_TLS_OPEN); len_read = 10000U; - EXPECT_TRUE(chrome_async_socket_.Read(buf, sizeof(buf), &len_read)); + EXPECT_TRUE(chrome_async_socket_->Read(buf, sizeof(buf), &len_read)); EXPECT_EQ(kReadData, std::string(buf, len_read)); DoSSLCloseOpenedNoError(); @@ -892,7 +893,7 @@ TEST_F(ChromeAsyncSocketTest, WriteDuringSSLConnecting) { DoOpenClosed(); ExpectReadSignal(); - EXPECT_TRUE(chrome_async_socket_.StartTls("fakedomain.com")); + EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com")); ExpectNoSignal(); ExpectNonErrorState(ChromeAsyncSocket::STATE_TLS_CONNECTING); @@ -900,7 +901,7 @@ TEST_F(ChromeAsyncSocketTest, WriteDuringSSLConnecting) { net::MockWrite(true, kWriteData, 3)); // Shouldn't do anything. - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData, 3)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3)); // TODO(akalin): Figure out how to test that the write happens // *after* the SSL connect. @@ -918,7 +919,7 @@ TEST_F(ChromeAsyncSocketTest, SSLConnectDuringPendingRead) { EXPECT_DEBUG_DEATH({ DoOpenClosed(); - EXPECT_FALSE(chrome_async_socket_.StartTls("fakedomain.com")); + EXPECT_FALSE(chrome_async_socket_->StartTls("fakedomain.com")); DoCloseOpened( SignalSocketState(SIGNAL_CLOSE, @@ -934,9 +935,9 @@ TEST_F(ChromeAsyncSocketTest, SSLConnectDuringPostedWrite) { async_socket_data_provider_.AddWrite( net::MockWrite(true, kWriteData, 3)); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData, 3)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3)); - EXPECT_FALSE(chrome_async_socket_.StartTls("fakedomain.com")); + EXPECT_FALSE(chrome_async_socket_->StartTls("fakedomain.com")); message_loop_.RunAllPending(); @@ -974,12 +975,12 @@ TEST_F(ChromeAsyncSocketTest, SSLSyncWrite) { net::MockWrite(false, kWriteData + 8, arraysize(kWriteData) - 8)); DoSSLOpenClosed(); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData, 3)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3)); message_loop_.RunAllPending(); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData + 3, 5)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5)); message_loop_.RunAllPending(); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData + 8, - arraysize(kWriteData) - 8)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8, + arraysize(kWriteData) - 8)); message_loop_.RunAllPending(); ExpectNoSignal(); @@ -997,12 +998,12 @@ TEST_F(ChromeAsyncSocketTest, SSLAsyncWrite) { async_socket_data_provider_.AddWrite( net::MockWrite(true, kWriteData + 8, arraysize(kWriteData) - 8)); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData, 3)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3)); message_loop_.RunAllPending(); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData + 3, 5)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5)); message_loop_.RunAllPending(); - EXPECT_TRUE(chrome_async_socket_.Write(kWriteData + 8, - arraysize(kWriteData) - 8)); + EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8, + arraysize(kWriteData) - 8)); message_loop_.RunAllPending(); ExpectNoSignal(); diff --git a/jingle/notifier/base/xmpp_client_socket_factory.cc b/jingle/notifier/base/xmpp_client_socket_factory.cc new file mode 100644 index 0000000..c0ced61 --- /dev/null +++ b/jingle/notifier/base/xmpp_client_socket_factory.cc @@ -0,0 +1,41 @@ +// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "jingle/notifier/base/xmpp_client_socket_factory.h" + +#include "base/logging.h" +#include "jingle/notifier/base/fake_ssl_client_socket.h" + +namespace notifier { + +XmppClientSocketFactory::XmppClientSocketFactory( + net::ClientSocketFactory* client_socket_factory, + bool use_fake_ssl_client_socket) + : client_socket_factory_(client_socket_factory), + use_fake_ssl_client_socket_(use_fake_ssl_client_socket) { + CHECK(client_socket_factory_); +} + +XmppClientSocketFactory::~XmppClientSocketFactory() {} + +net::ClientSocket* XmppClientSocketFactory::CreateTCPClientSocket( + const net::AddressList& addresses, + net::NetLog* net_log, + const net::NetLog::Source& source) { + net::ClientSocket* transport_socket = + client_socket_factory_->CreateTCPClientSocket( + addresses, net_log, source); + return (use_fake_ssl_client_socket_ ? + new FakeSSLClientSocket(transport_socket) : transport_socket); +} + +net::SSLClientSocket* XmppClientSocketFactory::CreateSSLClientSocket( + net::ClientSocketHandle* transport_socket, + const std::string& hostname, + const net::SSLConfig& ssl_config) { + return client_socket_factory_->CreateSSLClientSocket( + transport_socket, hostname, ssl_config); +} + +} // namespace diff --git a/jingle/notifier/base/xmpp_client_socket_factory.h b/jingle/notifier/base/xmpp_client_socket_factory.h new file mode 100644 index 0000000..73b2d8d --- /dev/null +++ b/jingle/notifier/base/xmpp_client_socket_factory.h @@ -0,0 +1,40 @@ +// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef JINGLE_NOTIFIER_BASE_XMPP_CLIENT_SOCKET_FACTORY_H_ +#define JINGLE_NOTIFIER_BASE_XMPP_CLIENT_SOCKET_FACTORY_H_ + +#include + +#include "net/socket/client_socket_factory.h" + +namespace notifier { + +class XmppClientSocketFactory : public net::ClientSocketFactory { + public: + // Does not take ownership of |client_socket_factory|. + XmppClientSocketFactory( + net::ClientSocketFactory* client_socket_factory, + bool use_fake_ssl_client_socket); + + virtual ~XmppClientSocketFactory(); + + // net::ClientSocketFactory implementation. + virtual net::ClientSocket* CreateTCPClientSocket( + const net::AddressList& addresses, net::NetLog* net_log, + const net::NetLog::Source& source); + virtual net::SSLClientSocket* CreateSSLClientSocket( + net::ClientSocketHandle* transport_socket, const std::string& hostname, + const net::SSLConfig& ssl_config); + + private: + net::ClientSocketFactory* const client_socket_factory_; + const bool use_fake_ssl_client_socket_; + + DISALLOW_COPY_AND_ASSIGN(XmppClientSocketFactory); +}; + +} // namespace notifier + +#endif // JINGLE_NOTIFIER_BASE_XMPP_CLIENT_SOCKET_FACTORY_H_ diff --git a/jingle/notifier/communicator/single_login_attempt.cc b/jingle/notifier/communicator/single_login_attempt.cc index 810b814..ccdf0ce 100644 --- a/jingle/notifier/communicator/single_login_attempt.cc +++ b/jingle/notifier/communicator/single_login_attempt.cc @@ -11,6 +11,7 @@ #include "base/logging.h" #include "jingle/notifier/base/chrome_async_socket.h" +#include "jingle/notifier/base/xmpp_client_socket_factory.h" #include "jingle/notifier/communicator/connection_options.h" #include "jingle/notifier/communicator/connection_settings.h" #include "jingle/notifier/communicator/const_communicator.h" @@ -225,8 +226,12 @@ void SingleLoginAttempt::OnCertificateExpired() { buzz::AsyncSocket* SingleLoginAttempt::CreateSocket( const buzz::XmppClientSettings& xcs) { if (use_chrome_async_socket_) { + bool use_fake_ssl_client_socket = + (xcs.protocol() == cricket::PROTO_SSLTCP); net::ClientSocketFactory* const client_socket_factory = - net::ClientSocketFactory::GetDefaultFactory(); + new XmppClientSocketFactory( + net::ClientSocketFactory::GetDefaultFactory(), + use_fake_ssl_client_socket); // The default SSLConfig is good enough for us for now. const net::SSLConfig ssl_config; // A read buffer of 64k ought to be sufficient. -- cgit v1.1