diff options
Diffstat (limited to 'net/socket/socket_test_util.cc')
| -rw-r--r-- | net/socket/socket_test_util.cc | 476 |
1 files changed, 131 insertions, 345 deletions
diff --git a/net/socket/socket_test_util.cc b/net/socket/socket_test_util.cc index 376d542..6b4e00f 100644 --- a/net/socket/socket_test_util.cc +++ b/net/socket/socket_test_util.cc @@ -176,7 +176,7 @@ MockWriteResult StaticSocketDataProvider::OnWrite(const std::string& data) { // Check that what we are writing matches the expectation. // Then give the mocked return value. - net::MockWrite* w = &writes_[write_index_++]; + MockWrite* w = &writes_[write_index_++]; w->time_stamp = base::Time::Now(); int result = w->result; if (w->data) { @@ -191,8 +191,8 @@ MockWriteResult StaticSocketDataProvider::OnWrite(const std::string& data) { std::string actual_data(data.substr(0, w->data_len)); EXPECT_EQ(expected_data, actual_data); if (expected_data != actual_data) - return MockWriteResult(false, net::ERR_UNEXPECTED); - if (result == net::OK) + return MockWriteResult(false, ERR_UNEXPECTED); + if (result == OK) result = w->data_len; } return MockWriteResult(w->async, result); @@ -252,7 +252,7 @@ DelayedSocketData::DelayedSocketData( MockWrite* writes, size_t writes_count) : StaticSocketDataProvider(reads, reads_count, writes, writes_count), write_delay_(write_delay), - ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) { + ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) { DCHECK_GE(write_delay_, 0); } @@ -261,7 +261,7 @@ DelayedSocketData::DelayedSocketData( size_t reads_count, MockWrite* writes, size_t writes_count) : StaticSocketDataProvider(reads, reads_count, writes, writes_count), write_delay_(write_delay), - ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) { + ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) { DCHECK_GE(write_delay_, 0); set_connect_data(connect); } @@ -284,14 +284,17 @@ MockWriteResult DelayedSocketData::OnWrite(const std::string& data) { MockWriteResult rv = StaticSocketDataProvider::OnWrite(data); // Now that our write has completed, we can allow reads to continue. if (!--write_delay_) - MessageLoop::current()->PostDelayedTask(FROM_HERE, - factory_.NewRunnableMethod(&DelayedSocketData::CompleteRead), 100); + MessageLoop::current()->PostDelayedTask( + FROM_HERE, + base::Bind(&DelayedSocketData::CompleteRead, + weak_factory_.GetWeakPtr()), + 100); return rv; } void DelayedSocketData::Reset() { set_socket(NULL); - factory_.RevokeAll(); + weak_factory_.InvalidateWeakPtrs(); StaticSocketDataProvider::Reset(); } @@ -303,8 +306,8 @@ void DelayedSocketData::CompleteRead() { OrderedSocketData::OrderedSocketData( MockRead* reads, size_t reads_count, MockWrite* writes, size_t writes_count) : StaticSocketDataProvider(reads, reads_count, writes, writes_count), - sequence_number_(0), loop_stop_stage_(0), callback_(NULL), - blocked_(false), ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) { + sequence_number_(0), loop_stop_stage_(0), + blocked_(false), ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) { } OrderedSocketData::OrderedSocketData( @@ -312,8 +315,8 @@ OrderedSocketData::OrderedSocketData( MockRead* reads, size_t reads_count, MockWrite* writes, size_t writes_count) : StaticSocketDataProvider(reads, reads_count, writes, writes_count), - sequence_number_(0), loop_stop_stage_(0), callback_(NULL), - blocked_(false), ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) { + sequence_number_(0), loop_stop_stage_(0), + blocked_(false), ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) { set_connect_data(connect); } @@ -336,12 +339,12 @@ void OrderedSocketData::EndLoop() { NET_TRACE(INFO, " *** ") << "Stage " << sequence_number_ << ": Posting Quit at read " << read_index(); loop_stop_stage_ = sequence_number_; - if (callback_) - callback_->RunWithParams(Tuple1<int>(ERR_IO_PENDING)); + if (!callback_.is_null()) + callback_.Run(ERR_IO_PENDING); } MockRead OrderedSocketData::GetNextRead() { - factory_.RevokeAll(); + weak_factory_.InvalidateWeakPtrs(); blocked_ = false; const MockRead& next_read = StaticSocketDataProvider::PeekRead(); if (next_read.sequence_number & MockRead::STOPLOOP) @@ -374,7 +377,9 @@ MockWriteResult OrderedSocketData::OnWrite(const std::string& data) { // SpdyStream::ReadResponseHeaders() is called, we hit a NOTREACHED(). MessageLoop::current()->PostDelayedTask( FROM_HERE, - factory_.NewRunnableMethod(&OrderedSocketData::CompleteRead), 100); + base::Bind(&OrderedSocketData::CompleteRead, + weak_factory_.GetWeakPtr()), + 100); } return StaticSocketDataProvider::OnWrite(data); } @@ -385,7 +390,7 @@ void OrderedSocketData::Reset() { sequence_number_ = 0; loop_stop_stage_ = 0; set_socket(NULL); - factory_.RevokeAll(); + weak_factory_.InvalidateWeakPtrs(); StaticSocketDataProvider::Reset(); } @@ -593,8 +598,8 @@ MockSSLClientSocket* MockClientSocketFactory::GetMockSSLClientSocket( DatagramClientSocket* MockClientSocketFactory::CreateDatagramClientSocket( DatagramSocket::BindType bind_type, const RandIntCallback& rand_int_cb, - NetLog* net_log, - const NetLog::Source& source) { + net::NetLog* net_log, + const net::NetLog::Source& source) { SocketDataProvider* data_provider = mock_data_.GetNext(); MockUDPClientSocket* socket = new MockUDPClientSocket(data_provider, net_log); data_provider->set_socket(socket); @@ -605,7 +610,7 @@ DatagramClientSocket* MockClientSocketFactory::CreateDatagramClientSocket( StreamSocket* MockClientSocketFactory::CreateTransportClientSocket( const AddressList& addresses, net::NetLog* net_log, - const NetLog::Source& source) { + const net::NetLog::Source& source) { SocketDataProvider* data_provider = mock_data_.GetNext(); MockTCPClientSocket* socket = new MockTCPClientSocket(addresses, net_log, data_provider); @@ -633,7 +638,7 @@ void MockClientSocketFactory::ClearSSLSessionCache() { MockClientSocket::MockClientSocket(net::NetLog* net_log) : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)), connected_(false), - net_log_(NetLog::Source(), net_log) { + net_log_(net::NetLog::Source(), net_log) { } bool MockClientSocket::SetReceiveBufferSize(int32 size) { @@ -676,12 +681,12 @@ const BoundNetLog& MockClientSocket::NetLog() const { return net_log_; } -void MockClientSocket::GetSSLInfo(net::SSLInfo* ssl_info) { +void MockClientSocket::GetSSLInfo(SSLInfo* ssl_info) { NOTREACHED(); } void MockClientSocket::GetSSLCertRequestInfo( - net::SSLCertRequestInfo* cert_request_info) { + SSLCertRequestInfo* cert_request_info) { } int MockClientSocket::ExportKeyingMaterial(const base::StringPiece& label, @@ -701,44 +706,32 @@ MockClientSocket::GetNextProto(std::string* proto, std::string* server_protos) { MockClientSocket::~MockClientSocket() {} -void MockClientSocket::RunCallbackAsync(net::OldCompletionCallback* callback, - int result) { - MessageLoop::current()->PostTask(FROM_HERE, - base::Bind(&MockClientSocket::RunOldCallback, weak_factory_.GetWeakPtr(), - callback, result)); -} -void MockClientSocket::RunCallbackAsync(const net::CompletionCallback& callback, +void MockClientSocket::RunCallbackAsync(const CompletionCallback& callback, int result) { MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&MockClientSocket::RunCallback, weak_factory_.GetWeakPtr(), callback, result)); } -void MockClientSocket::RunOldCallback(net::OldCompletionCallback* callback, - int result) { - if (callback) - callback->Run(result); -} void MockClientSocket::RunCallback(const net::CompletionCallback& callback, int result) { if (!callback.is_null()) callback.Run(result); } -MockTCPClientSocket::MockTCPClientSocket(const net::AddressList& addresses, +MockTCPClientSocket::MockTCPClientSocket(const AddressList& addresses, net::NetLog* net_log, - net::SocketDataProvider* data) + SocketDataProvider* data) : MockClientSocket(net_log), addresses_(addresses), data_(data), read_offset_(0), num_bytes_read_(0), - read_data_(false, net::ERR_UNEXPECTED), + read_data_(false, ERR_UNEXPECTED), need_read_data_(true), peer_closed_connection_(false), pending_buf_(NULL), pending_buf_len_(0), - old_pending_callback_(NULL), was_used_to_convey_data_(false) { DCHECK(data_); data_->Reset(); @@ -746,42 +739,10 @@ MockTCPClientSocket::MockTCPClientSocket(const net::AddressList& addresses, MockTCPClientSocket::~MockTCPClientSocket() {} -int MockTCPClientSocket::Read(net::IOBuffer* buf, int buf_len, - net::OldCompletionCallback* callback) { +int MockTCPClientSocket::Read(IOBuffer* buf, int buf_len, + const CompletionCallback& callback) { if (!connected_) - return net::ERR_UNEXPECTED; - - // If the buffer is already in use, a read is already in progress! - DCHECK(pending_buf_ == NULL); - - // Store our async IO data. - pending_buf_ = buf; - pending_buf_len_ = buf_len; - old_pending_callback_ = callback; - - if (need_read_data_) { - read_data_ = data_->GetNextRead(); - if (read_data_.result == ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ) { - // This MockRead is just a marker to instruct us to set - // peer_closed_connection_. Skip it and get the next one. - read_data_ = data_->GetNextRead(); - peer_closed_connection_ = true; - } - // ERR_IO_PENDING means that the SocketDataProvider is taking responsibility - // to complete the async IO manually later (via OnReadComplete). - if (read_data_.result == ERR_IO_PENDING) { - DCHECK(callback); // We need to be using async IO in this case. - return ERR_IO_PENDING; - } - need_read_data_ = false; - } - - return CompleteRead(); -} -int MockTCPClientSocket::Read(net::IOBuffer* buf, int buf_len, - const net::CompletionCallback& callback) { - if (!connected_) - return net::ERR_UNEXPECTED; + return ERR_UNEXPECTED; // If the buffer is already in use, a read is already in progress! DCHECK(pending_buf_ == NULL); @@ -812,55 +773,41 @@ int MockTCPClientSocket::Read(net::IOBuffer* buf, int buf_len, return CompleteRead(); } -int MockTCPClientSocket::Write(net::IOBuffer* buf, int buf_len, - net::OldCompletionCallback* callback) { +int MockTCPClientSocket::Write(IOBuffer* buf, int buf_len, + const CompletionCallback& callback) { DCHECK(buf); DCHECK_GT(buf_len, 0); if (!connected_) - return net::ERR_UNEXPECTED; + return ERR_UNEXPECTED; std::string data(buf->data(), buf_len); - net::MockWriteResult write_result = data_->OnWrite(data); + MockWriteResult write_result = data_->OnWrite(data); was_used_to_convey_data_ = true; if (write_result.async) { RunCallbackAsync(callback, write_result.result); - return net::ERR_IO_PENDING; + return ERR_IO_PENDING; } return write_result.result; } -int MockTCPClientSocket::Connect(net::OldCompletionCallback* callback) { - if (connected_) - return net::OK; - connected_ = true; - peer_closed_connection_ = false; - if (data_->connect_data().async) { - RunCallbackAsync(callback, data_->connect_data().result); - return net::ERR_IO_PENDING; - } - return data_->connect_data().result; -} -int MockTCPClientSocket::Connect(const net::CompletionCallback& callback) { +int MockTCPClientSocket::Connect(const CompletionCallback& callback) { if (connected_) - return net::OK; - + return OK; connected_ = true; peer_closed_connection_ = false; if (data_->connect_data().async) { RunCallbackAsync(callback, data_->connect_data().result); - return net::ERR_IO_PENDING; + return ERR_IO_PENDING; } - return data_->connect_data().result; } void MockTCPClientSocket::Disconnect() { MockClientSocket::Disconnect(); - old_pending_callback_ = NULL; pending_callback_.Reset(); } @@ -912,15 +859,9 @@ void MockTCPClientSocket::OnReadComplete(const MockRead& data) { // let CompleteRead() schedule a callback. read_data_.async = false; - if (old_pending_callback_) { - net::OldCompletionCallback* callback = old_pending_callback_; - int rv = CompleteRead(); - RunOldCallback(callback, rv); - } else { - net::CompletionCallback callback = pending_callback_; - int rv = CompleteRead(); - RunCallback(callback, rv); - } + CompletionCallback callback = pending_callback_; + int rv = CompleteRead(); + RunCallback(callback, rv); } int MockTCPClientSocket::CompleteRead() { @@ -930,13 +871,11 @@ int MockTCPClientSocket::CompleteRead() { was_used_to_convey_data_ = true; // Save the pending async IO data and reset our |pending_| state. - net::IOBuffer* buf = pending_buf_; + IOBuffer* buf = pending_buf_; int buf_len = pending_buf_len_; - net::OldCompletionCallback* old_callback = old_pending_callback_; - net::CompletionCallback callback = pending_callback_; + CompletionCallback callback = pending_callback_; pending_buf_ = NULL; pending_buf_len_ = 0; - old_pending_callback_ = NULL; pending_callback_.Reset(); int result = read_data_.result; @@ -958,27 +897,22 @@ int MockTCPClientSocket::CompleteRead() { } if (read_data_.async) { - DCHECK(old_callback || !callback.is_null()); - if (old_callback) - RunCallbackAsync(old_callback, result); - else - RunCallbackAsync(callback, result); - return net::ERR_IO_PENDING; + DCHECK(!callback.is_null()); + RunCallbackAsync(callback, result); + return ERR_IO_PENDING; } return result; } DeterministicMockTCPClientSocket::DeterministicMockTCPClientSocket( - net::NetLog* net_log, net::DeterministicSocketData* data) + net::NetLog* net_log, DeterministicSocketData* data) : MockClientSocket(net_log), write_pending_(false), - write_callback_(NULL), write_result_(0), read_data_(), read_buf_(NULL), read_buf_len_(0), read_pending_(false), - old_read_callback_(NULL), data_(data), was_used_to_convey_data_(false) {} @@ -987,7 +921,7 @@ DeterministicMockTCPClientSocket::~DeterministicMockTCPClientSocket() {} void DeterministicMockTCPClientSocket::CompleteWrite() { was_used_to_convey_data_ = true; write_pending_ = false; - write_callback_->Run(write_result_); + write_callback_.Run(write_result_); } int DeterministicMockTCPClientSocket::CompleteRead() { @@ -1012,32 +946,29 @@ int DeterministicMockTCPClientSocket::CompleteRead() { if (read_pending_) { read_pending_ = false; - if (old_read_callback_) - old_read_callback_->Run(result); - else - read_callback_.Run(result); + read_callback_.Run(result); } return result; } int DeterministicMockTCPClientSocket::Write( - net::IOBuffer* buf, int buf_len, net::OldCompletionCallback* callback) { + IOBuffer* buf, int buf_len, const CompletionCallback& callback) { DCHECK(buf); DCHECK_GT(buf_len, 0); if (!connected_) - return net::ERR_UNEXPECTED; + return ERR_UNEXPECTED; std::string data(buf->data(), buf_len); - net::MockWriteResult write_result = data_->OnWrite(data); + MockWriteResult write_result = data_->OnWrite(data); if (write_result.async) { write_callback_ = callback; write_result_ = write_result.result; - DCHECK(write_callback_ != NULL); + DCHECK(!write_callback_.is_null()); write_pending_ = true; - return net::ERR_IO_PENDING; + return ERR_IO_PENDING; } was_used_to_convey_data_ = true; @@ -1046,32 +977,9 @@ int DeterministicMockTCPClientSocket::Write( } int DeterministicMockTCPClientSocket::Read( - net::IOBuffer* buf, int buf_len, net::OldCompletionCallback* callback) { - if (!connected_) - return net::ERR_UNEXPECTED; - - read_data_ = data_->GetNextRead(); - // The buffer should always be big enough to contain all the MockRead data. To - // use small buffers, split the data into multiple MockReads. - DCHECK_LE(read_data_.data_len, buf_len); - - read_buf_ = buf; - read_buf_len_ = buf_len; - old_read_callback_ = callback; - - if (read_data_.async || (read_data_.result == ERR_IO_PENDING)) { - read_pending_ = true; - DCHECK(old_read_callback_); - return ERR_IO_PENDING; - } - - was_used_to_convey_data_ = true; - return CompleteRead(); -} -int DeterministicMockTCPClientSocket::Read( - net::IOBuffer* buf, int buf_len, const net::CompletionCallback& callback) { + IOBuffer* buf, int buf_len, const CompletionCallback& callback) { if (!connected_) - return net::ERR_UNEXPECTED; + return ERR_UNEXPECTED; read_data_ = data_->GetNextRead(); // The buffer should always be big enough to contain all the MockRead data. To @@ -1094,27 +1002,14 @@ int DeterministicMockTCPClientSocket::Read( // TODO(erikchen): Support connect sequencing. int DeterministicMockTCPClientSocket::Connect( - net::OldCompletionCallback* callback) { - if (connected_) - return net::OK; - connected_ = true; - if (data_->connect_data().async) { - RunCallbackAsync(callback, data_->connect_data().result); - return net::ERR_IO_PENDING; - } - return data_->connect_data().result; -} -int DeterministicMockTCPClientSocket::Connect( - const net::CompletionCallback& callback) { + const CompletionCallback& callback) { if (connected_) - return net::OK; - + return OK; connected_ = true; if (data_->connect_data().async) { RunCallbackAsync(callback, data_->connect_data().result); - return net::ERR_IO_PENDING; + return ERR_IO_PENDING; } - return data_->connect_data().result; } @@ -1148,67 +1043,22 @@ base::TimeDelta DeterministicMockTCPClientSocket::GetConnectTimeMicros() const { void DeterministicMockTCPClientSocket::OnReadComplete(const MockRead& data) {} -class MockSSLClientSocket::OldConnectCallback - : public net::OldCompletionCallbackImpl< - MockSSLClientSocket::OldConnectCallback> { - public: - OldConnectCallback(MockSSLClientSocket *ssl_client_socket, - net::OldCompletionCallback* user_callback, - int rv) - : ALLOW_THIS_IN_INITIALIZER_LIST( - net::OldCompletionCallbackImpl< - MockSSLClientSocket::OldConnectCallback>( - this, &OldConnectCallback::Wrapper)), - ssl_client_socket_(ssl_client_socket), - user_callback_(user_callback), - rv_(rv) { - } - - private: - void Wrapper(int rv) { - if (rv_ == net::OK) - ssl_client_socket_->connected_ = true; - user_callback_->Run(rv_); - delete this; - } - - MockSSLClientSocket* ssl_client_socket_; - net::OldCompletionCallback* user_callback_; - int rv_; -}; -class MockSSLClientSocket::ConnectCallback { - public: - ConnectCallback(MockSSLClientSocket *ssl_client_socket, - const CompletionCallback& user_callback, - int rv) - : ALLOW_THIS_IN_INITIALIZER_LIST(callback_( - base::Bind(&ConnectCallback::Wrapper, base::Unretained(this)))), - ssl_client_socket_(ssl_client_socket), - user_callback_(user_callback), - rv_(rv) { - } - - const CompletionCallback& callback() const { return callback_; } - - private: - void Wrapper(int rv) { - if (rv_ == net::OK) - ssl_client_socket_->connected_ = true; - user_callback_.Run(rv_); - } - - CompletionCallback callback_; - MockSSLClientSocket* ssl_client_socket_; - CompletionCallback user_callback_; - int rv_; -}; +// static +void MockSSLClientSocket::ConnectCallback( + MockSSLClientSocket *ssl_client_socket, + const CompletionCallback& callback, + int rv) { + if (rv == OK) + ssl_client_socket->connected_ = true; + callback.Run(rv); +} MockSSLClientSocket::MockSSLClientSocket( - net::ClientSocketHandle* transport_socket, + ClientSocketHandle* transport_socket, const HostPortPair& host_port_pair, - const net::SSLConfig& ssl_config, + const SSLConfig& ssl_config, SSLHostInfo* ssl_host_info, - net::SSLSocketDataProvider* data) + SSLSocketDataProvider* data) : MockClientSocket(transport_socket->socket()->NetLog().net_log()), transport_(transport_socket), data_(data), @@ -1222,45 +1072,25 @@ MockSSLClientSocket::~MockSSLClientSocket() { Disconnect(); } -int MockSSLClientSocket::Read(net::IOBuffer* buf, int buf_len, - net::OldCompletionCallback* callback) { - return transport_->socket()->Read(buf, buf_len, callback); -} -int MockSSLClientSocket::Read(net::IOBuffer* buf, int buf_len, - const net::CompletionCallback& callback) { +int MockSSLClientSocket::Read(IOBuffer* buf, int buf_len, + const CompletionCallback& callback) { return transport_->socket()->Read(buf, buf_len, callback); } -int MockSSLClientSocket::Write(net::IOBuffer* buf, int buf_len, - net::OldCompletionCallback* callback) { +int MockSSLClientSocket::Write(IOBuffer* buf, int buf_len, + const CompletionCallback& callback) { return transport_->socket()->Write(buf, buf_len, callback); } -int MockSSLClientSocket::Connect(net::OldCompletionCallback* callback) { - OldConnectCallback* connect_callback = new OldConnectCallback( - this, callback, data_->connect.result); - int rv = transport_->socket()->Connect(connect_callback); - if (rv == net::OK) { - delete connect_callback; - if (data_->connect.result == net::OK) - connected_ = true; - if (data_->connect.async) { - RunCallbackAsync(callback, data_->connect.result); - return net::ERR_IO_PENDING; - } - return data_->connect.result; - } - return rv; -} -int MockSSLClientSocket::Connect(const net::CompletionCallback& callback) { - ConnectCallback connect_callback(this, callback, data_->connect.result); - int rv = transport_->socket()->Connect(connect_callback.callback()); - if (rv == net::OK) { - if (data_->connect.result == net::OK) +int MockSSLClientSocket::Connect(const CompletionCallback& callback) { + int rv = transport_->socket()->Connect( + base::Bind(&ConnectCallback, base::Unretained(this), callback)); + if (rv == OK) { + if (data_->connect.result == OK) connected_ = true; if (data_->connect.async) { RunCallbackAsync(callback, data_->connect.result); - return net::ERR_IO_PENDING; + return ERR_IO_PENDING; } return data_->connect.result; } @@ -1293,14 +1123,14 @@ base::TimeDelta MockSSLClientSocket::GetConnectTimeMicros() const { return base::TimeDelta::FromMicroseconds(-1); } -void MockSSLClientSocket::GetSSLInfo(net::SSLInfo* ssl_info) { +void MockSSLClientSocket::GetSSLInfo(SSLInfo* ssl_info) { ssl_info->Reset(); ssl_info->cert = data_->cert; ssl_info->client_cert_sent = data_->client_cert_sent; } void MockSSLClientSocket::GetSSLCertRequestInfo( - net::SSLCertRequestInfo* cert_request_info) { + SSLCertRequestInfo* cert_request_info) { DCHECK(cert_request_info); if (data_->cert_request_info) { cert_request_info->host_and_port = @@ -1338,12 +1168,11 @@ MockUDPClientSocket::MockUDPClientSocket(SocketDataProvider* data, : connected_(false), data_(data), read_offset_(0), - read_data_(false, net::ERR_UNEXPECTED), + read_data_(false, ERR_UNEXPECTED), need_read_data_(true), pending_buf_(NULL), pending_buf_len_(0), - old_pending_callback_(NULL), - net_log_(NetLog::Source(), net_log), + net_log_(net::NetLog::Source(), net_log), ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) { DCHECK(data_); data_->Reset(); @@ -1351,36 +1180,10 @@ MockUDPClientSocket::MockUDPClientSocket(SocketDataProvider* data, MockUDPClientSocket::~MockUDPClientSocket() {} -int MockUDPClientSocket::Read(net::IOBuffer* buf, int buf_len, - net::OldCompletionCallback* callback) { +int MockUDPClientSocket::Read(IOBuffer* buf, int buf_len, + const CompletionCallback& callback) { if (!connected_) - return net::ERR_UNEXPECTED; - - // If the buffer is already in use, a read is already in progress! - DCHECK(pending_buf_ == NULL); - - // Store our async IO data. - pending_buf_ = buf; - pending_buf_len_ = buf_len; - old_pending_callback_ = callback; - - if (need_read_data_) { - read_data_ = data_->GetNextRead(); - // ERR_IO_PENDING means that the SocketDataProvider is taking responsibility - // to complete the async IO manually later (via OnReadComplete). - if (read_data_.result == ERR_IO_PENDING) { - DCHECK(callback); // We need to be using async IO in this case. - return ERR_IO_PENDING; - } - need_read_data_ = false; - } - - return CompleteRead(); -} -int MockUDPClientSocket::Read(net::IOBuffer* buf, int buf_len, - const net::CompletionCallback& callback) { - if (!connected_) - return net::ERR_UNEXPECTED; + return ERR_UNEXPECTED; // If the buffer is already in use, a read is already in progress! DCHECK(pending_buf_ == NULL); @@ -1405,8 +1208,8 @@ int MockUDPClientSocket::Read(net::IOBuffer* buf, int buf_len, return CompleteRead(); } -int MockUDPClientSocket::Write(net::IOBuffer* buf, int buf_len, - net::OldCompletionCallback* callback) { +int MockUDPClientSocket::Write(IOBuffer* buf, int buf_len, + const CompletionCallback& callback) { DCHECK(buf); DCHECK_GT(buf_len, 0); @@ -1469,15 +1272,9 @@ void MockUDPClientSocket::OnReadComplete(const MockRead& data) { // let CompleteRead() schedule a callback. read_data_.async = false; - if (old_pending_callback_) { - net::OldCompletionCallback* callback = old_pending_callback_; - int rv = CompleteRead(); - RunOldCallback(callback, rv); - } else { - net::CompletionCallback callback = pending_callback_; - int rv = CompleteRead(); - RunCallback(callback, rv); - } + net::CompletionCallback callback = pending_callback_; + int rv = CompleteRead(); + RunCallback(callback, rv); } int MockUDPClientSocket::CompleteRead() { @@ -1485,14 +1282,11 @@ int MockUDPClientSocket::CompleteRead() { DCHECK(pending_buf_len_ > 0); // Save the pending async IO data and reset our |pending_| state. - net::IOBuffer* buf = pending_buf_; + IOBuffer* buf = pending_buf_; int buf_len = pending_buf_len_; - net::OldCompletionCallback* old_callback = old_pending_callback_; - net::CompletionCallback callback = pending_callback_; + CompletionCallback callback = pending_callback_; pending_buf_ = NULL; pending_buf_len_ = 0; - old_pending_callback_ = NULL; - pending_callback_.Reset(); pending_callback_.Reset(); int result = read_data_.result; @@ -1513,35 +1307,22 @@ int MockUDPClientSocket::CompleteRead() { } if (read_data_.async) { - DCHECK(old_callback || !callback.is_null()); - if (old_callback) - RunCallbackAsync(old_callback, result); - else - RunCallbackAsync(callback, result); - return net::ERR_IO_PENDING; + DCHECK(!callback.is_null()); + RunCallbackAsync(callback, result); + return ERR_IO_PENDING; } return result; } -void MockUDPClientSocket::RunCallbackAsync(net::OldCompletionCallback* callback, +void MockUDPClientSocket::RunCallbackAsync(const CompletionCallback& callback, int result) { - MessageLoop::current()->PostTask(FROM_HERE, - base::Bind(&MockUDPClientSocket::RunOldCallback, - weak_factory_.GetWeakPtr(), callback, result)); -} -void MockUDPClientSocket::RunCallbackAsync( - const net::CompletionCallback& callback, int result) { - MessageLoop::current()->PostTask(FROM_HERE, + MessageLoop::current()->PostTask( + FROM_HERE, base::Bind(&MockUDPClientSocket::RunCallback, weak_factory_.GetWeakPtr(), callback, result)); } -void MockUDPClientSocket::RunOldCallback(net::OldCompletionCallback* callback, - int result) { - if (callback) - callback->Run(result); -} -void MockUDPClientSocket::RunCallback(const net::CompletionCallback& callback, +void MockUDPClientSocket::RunCallback(const CompletionCallback& callback, int result) { if (!callback.is_null()) callback.Run(result); @@ -1614,20 +1395,19 @@ void ClientSocketPoolTest::ReleaseAllConnections(KeepAlive keep_alive) { MockTransportClientSocketPool::MockConnectJob::MockConnectJob( StreamSocket* socket, ClientSocketHandle* handle, - OldCompletionCallback* callback) + const CompletionCallback& callback) : socket_(socket), handle_(handle), - user_callback_(callback), - ALLOW_THIS_IN_INITIALIZER_LIST( - connect_callback_(this, &MockConnectJob::OnConnect)) { + user_callback_(callback) { } MockTransportClientSocketPool::MockConnectJob::~MockConnectJob() {} int MockTransportClientSocketPool::MockConnectJob::Connect() { - int rv = socket_->Connect(&connect_callback_); + int rv = socket_->Connect(base::Bind(&MockConnectJob::OnConnect, + base::Unretained(this))); if (rv == OK) { - user_callback_ = NULL; + user_callback_.Reset(); OnConnect(OK); } return rv; @@ -1639,7 +1419,7 @@ bool MockTransportClientSocketPool::MockConnectJob::CancelHandle( return false; socket_.reset(); handle_ = NULL; - user_callback_ = NULL; + user_callback_.Reset(); return true; } @@ -1654,10 +1434,10 @@ void MockTransportClientSocketPool::MockConnectJob::OnConnect(int rv) { handle_ = NULL; - if (user_callback_) { - OldCompletionCallback* callback = user_callback_; - user_callback_ = NULL; - callback->Run(rv); + if (!user_callback_.is_null()) { + CompletionCallback callback = user_callback_; + user_callback_.Reset(); + callback.Run(rv); } } @@ -1675,15 +1455,21 @@ MockTransportClientSocketPool::MockTransportClientSocketPool( MockTransportClientSocketPool::~MockTransportClientSocketPool() {} -int MockTransportClientSocketPool::RequestSocket(const std::string& group_name, - const void* socket_params, - RequestPriority priority, - ClientSocketHandle* handle, - OldCompletionCallback* callback, - const BoundNetLog& net_log) { +int MockTransportClientSocketPool::RequestSocket( + const std::string& group_name, + const void* socket_params, + RequestPriority priority, + ClientSocketHandle* handle, + OldCompletionCallback* callback, + const BoundNetLog& net_log) { StreamSocket* socket = client_socket_factory_->CreateTransportClientSocket( AddressList(), net_log.net_log(), net::NetLog::Source()); - MockConnectJob* job = new MockConnectJob(socket, handle, callback); + CompletionCallback cb; + if (callback) { + cb = base::Bind(&OldCompletionCallback::Run<int>, + base::Unretained(callback)); + } + MockConnectJob* job = new MockConnectJob(socket, handle, cb); job_list_.push_back(job); handle->set_pool_id(1); return job->Connect(); @@ -1736,7 +1522,7 @@ DatagramClientSocket* DeterministicMockClientSocketFactory::CreateDatagramClientSocket( DatagramSocket::BindType bind_type, const RandIntCallback& rand_int_cb, - NetLog* net_log, + net::NetLog* net_log, const NetLog::Source& source) { NOTREACHED(); return NULL; |