diff options
39 files changed, 306 insertions, 279 deletions
diff --git a/chrome/browser/net/network_stats.cc b/chrome/browser/net/network_stats.cc index 210bc15..1892a4e 100644 --- a/chrome/browser/net/network_stats.cc +++ b/chrome/browser/net/network_stats.cc @@ -82,8 +82,6 @@ NetworkStats::NetworkStats() bytes_to_send_(0), encoded_message_(""), ALLOW_THIS_IN_INITIALIZER_LIST( - resolve_callback_(this, &NetworkStats::OnResolveComplete)), - ALLOW_THIS_IN_INITIALIZER_LIST( read_callback_(this, &NetworkStats::OnReadComplete)), ALLOW_THIS_IN_INITIALIZER_LIST( write_callback_(this, &NetworkStats::OnWriteComplete)), @@ -105,11 +103,11 @@ bool NetworkStats::Start(net::HostResolver* host_resolver, Initialize(bytes_to_send, finished_callback); net::HostResolver::RequestInfo request(server_host_port_pair); - int rv = host_resolver->Resolve(request, - &addresses_, - &resolve_callback_, - NULL, - net::BoundNetLog()); + int rv = host_resolver->Resolve( + request, &addresses_, + base::Bind(&NetworkStats::OnResolveComplete, + base::Unretained(this)), + NULL, net::BoundNetLog()); if (rv == net::ERR_IO_PENDING) return true; return DoConnect(rv); diff --git a/chrome/browser/net/network_stats.h b/chrome/browser/net/network_stats.h index 65742b6..8fcee6d 100644 --- a/chrome/browser/net/network_stats.h +++ b/chrome/browser/net/network_stats.h @@ -176,9 +176,6 @@ class NetworkStats { // HostResolver fills out the |addresses_| after host resolution is completed. net::AddressList addresses_; - // Callback to call when host resolution is completed. - net::OldCompletionCallbackImpl<NetworkStats> resolve_callback_; - // Callback to call when data is read from the server. net::OldCompletionCallbackImpl<NetworkStats> read_callback_; diff --git a/chrome/browser/net/predictor.cc b/chrome/browser/net/predictor.cc index 51bc4ae..365e7e1 100644 --- a/chrome/browser/net/predictor.cc +++ b/chrome/browser/net/predictor.cc @@ -82,9 +82,7 @@ class Predictor::LookupRequest { LookupRequest(Predictor* predictor, net::HostResolver* host_resolver, const GURL& url) - : ALLOW_THIS_IN_INITIALIZER_LIST( - net_callback_(this, &LookupRequest::OnLookupFinished)), - predictor_(predictor), + : predictor_(predictor), url_(url), resolver_(host_resolver) { } @@ -102,7 +100,9 @@ class Predictor::LookupRequest { // lets the HostResolver know it can de-prioritize it. resolve_info.set_is_speculative(true); return resolver_.Resolve( - resolve_info, &addresses_, &net_callback_, net::BoundNetLog()); + resolve_info, &addresses_, + base::Bind(&LookupRequest::OnLookupFinished, base::Unretained(this)), + net::BoundNetLog()); } private: @@ -110,9 +110,6 @@ class Predictor::LookupRequest { predictor_->OnLookupFinished(this, url_, result == net::OK); } - // HostResolver will call us using this callback when resolution is complete. - net::OldCompletionCallbackImpl<LookupRequest> net_callback_; - Predictor* predictor_; // The predictor which started us. const GURL url_; // Hostname to resolve. diff --git a/content/browser/renderer_host/p2p/socket_dispatcher_host.cc b/content/browser/renderer_host/p2p/socket_dispatcher_host.cc index 3ff79e3..ee337ce 100644 --- a/content/browser/renderer_host/p2p/socket_dispatcher_host.cc +++ b/content/browser/renderer_host/p2p/socket_dispatcher_host.cc @@ -28,9 +28,7 @@ class P2PSocketDispatcherHost::DnsRequest { net::HostResolver* host_resolver) : routing_id_(routing_id), request_id_(request_id), - resolver_(host_resolver), - ALLOW_THIS_IN_INITIALIZER_LIST(completion_callback_( - this, &P2PSocketDispatcherHost::DnsRequest::OnDone)) { + resolver_(host_resolver) { } void Resolve(const std::string& host_name, @@ -52,8 +50,11 @@ class P2PSocketDispatcherHost::DnsRequest { host_name_ = host_name_ + '.'; net::HostResolver::RequestInfo info(net::HostPortPair(host_name_, 0)); - int result = resolver_.Resolve(info, &addresses_, &completion_callback_, - net::BoundNetLog()); + int result = resolver_.Resolve( + info, &addresses_, + base::Bind(&P2PSocketDispatcherHost::DnsRequest::OnDone, + base::Unretained(this)), + net::BoundNetLog()); if (result != net::ERR_IO_PENDING) OnDone(result); } @@ -96,8 +97,6 @@ class P2PSocketDispatcherHost::DnsRequest { net::SingleRequestHostResolver resolver_; DoneCallback done_callback_; - - net::OldCompletionCallbackImpl<DnsRequest> completion_callback_; }; P2PSocketDispatcherHost::P2PSocketDispatcherHost( diff --git a/content/browser/renderer_host/pepper_message_filter.cc b/content/browser/renderer_host/pepper_message_filter.cc index de155a5..9895dfb 100644 --- a/content/browser/renderer_host/pepper_message_filter.cc +++ b/content/browser/renderer_host/pepper_message_filter.cc @@ -181,7 +181,6 @@ class PepperMessageFilter::TCPSocket { ConnectionState connection_state_; bool end_of_file_reached_; - net::OldCompletionCallbackImpl<TCPSocket> resolve_callback_; net::OldCompletionCallbackImpl<TCPSocket> connect_callback_; net::OldCompletionCallbackImpl<TCPSocket> ssl_handshake_callback_; net::OldCompletionCallbackImpl<TCPSocket> read_callback_; @@ -304,8 +303,6 @@ PepperMessageFilter::TCPSocket::TCPSocket( connection_state_(BEFORE_CONNECT), end_of_file_reached_(false), ALLOW_THIS_IN_INITIALIZER_LIST( - resolve_callback_(this, &TCPSocket::OnResolveCompleted)), - ALLOW_THIS_IN_INITIALIZER_LIST( connect_callback_(this, &TCPSocket::OnConnectCompleted)), ALLOW_THIS_IN_INITIALIZER_LIST( ssl_handshake_callback_(this, &TCPSocket::OnSSLHandshakeCompleted)), @@ -335,8 +332,10 @@ void PepperMessageFilter::TCPSocket::Connect(const std::string& host, net::HostResolver::RequestInfo request_info(net::HostPortPair(host, port)); resolver_.reset(new net::SingleRequestHostResolver( manager_->GetHostResolver())); - int result = resolver_->Resolve(request_info, &address_list_, - &resolve_callback_, net::BoundNetLog()); + int result = resolver_->Resolve( + request_info, &address_list_, + base::Bind(&TCPSocket::OnResolveCompleted, base::Unretained(this)), + net::BoundNetLog()); if (result != net::ERR_IO_PENDING) OnResolveCompleted(result); } diff --git a/jingle/notifier/communicator/xmpp_connection_generator.cc b/jingle/notifier/communicator/xmpp_connection_generator.cc index 5a234e7..b19d16b 100644 --- a/jingle/notifier/communicator/xmpp_connection_generator.cc +++ b/jingle/notifier/communicator/xmpp_connection_generator.cc @@ -20,6 +20,7 @@ #include <vector> +#include "base/bind.h" #include "base/callback.h" #include "base/compiler_specific.h" #include "base/logging.h" @@ -45,10 +46,6 @@ XmppConnectionGenerator::XmppConnectionGenerator( const ServerList& servers) : delegate_(delegate), host_resolver_(host_resolver), - resolve_callback_( - ALLOW_THIS_IN_INITIALIZER_LIST( - NewCallback(this, - &XmppConnectionGenerator::OnServerDNSResolved))), settings_list_(new ConnectionSettingsList()), settings_index_(0), servers_(servers), @@ -126,12 +123,13 @@ void XmppConnectionGenerator::UseNextConnection() { net::HostResolver::RequestInfo request_info(server); int status = host_resolver_.Resolve( - request_info, &address_list_, resolve_callback_.get(), + request_info, &address_list_, + base::Bind(&XmppConnectionGenerator::OnServerDNSResolved, + base::Unretained(this)), bound_net_log_); - if (status == net::ERR_IO_PENDING) { - // resolve_callback_ will call us when it's called. + if (status == net::ERR_IO_PENDING) // OnServerDNSResolved will be called. return; - } + HandleServerDNSResolved(status); } else { // We are not resolving DNS here (DNS will be resolved by a lower layer). diff --git a/jingle/notifier/communicator/xmpp_connection_generator.h b/jingle/notifier/communicator/xmpp_connection_generator.h index 1100575..9f3ad79 100644 --- a/jingle/notifier/communicator/xmpp_connection_generator.h +++ b/jingle/notifier/communicator/xmpp_connection_generator.h @@ -9,7 +9,6 @@ #include "base/memory/scoped_ptr.h" #include "net/base/address_list.h" -#include "net/base/completion_callback.h" #include "net/base/host_resolver.h" #include "net/base/net_log.h" #include "net/base/single_request_host_resolver.h" @@ -65,7 +64,6 @@ class XmppConnectionGenerator { Delegate* delegate_; net::SingleRequestHostResolver host_resolver_; - scoped_ptr<net::OldCompletionCallback> resolve_callback_; net::AddressList address_list_; net::BoundNetLog bound_net_log_; scoped_ptr<ConnectionSettingsList> settings_list_; diff --git a/net/base/host_resolver.h b/net/base/host_resolver.h index b47fa81..a596610 100644 --- a/net/base/host_resolver.h +++ b/net/base/host_resolver.h @@ -116,7 +116,7 @@ class NET_EXPORT HostResolver { // incompatible IP literal (e.g. IPv6 is disabled and it is an IPv6 // literal). // - // If the operation cannnot be completed synchronously, ERR_IO_PENDING will + // If the operation cannot be completed synchronously, ERR_IO_PENDING will // be returned and the real result code will be passed to the completion // callback. Otherwise the result code is returned immediately from this // call. @@ -128,7 +128,7 @@ class NET_EXPORT HostResolver { // Profiling information for the request is saved to |net_log| if non-NULL. virtual int Resolve(const RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, RequestHandle* out_req, const BoundNetLog& net_log) = 0; diff --git a/net/base/host_resolver_impl.cc b/net/base/host_resolver_impl.cc index 31f08c0..d01820b 100644 --- a/net/base/host_resolver_impl.cc +++ b/net/base/host_resolver_impl.cc @@ -16,6 +16,7 @@ #include "base/basictypes.h" #include "base/bind.h" +#include "base/bind_helpers.h" #include "base/compiler_specific.h" #include "base/debug/debugger.h" #include "base/debug/stack_trace.h" @@ -262,7 +263,7 @@ class HostResolverImpl::Request { Request(const BoundNetLog& source_net_log, const BoundNetLog& request_net_log, const RequestInfo& info, - OldCompletionCallback* callback, + const CompletionCallback& callback, AddressList* addresses) : source_net_log_(source_net_log), request_net_log_(request_net_log), @@ -275,12 +276,12 @@ class HostResolverImpl::Request { // Mark the request as cancelled. void MarkAsCancelled() { job_ = NULL; - callback_ = NULL; addresses_ = NULL; + callback_.Reset(); } bool was_cancelled() const { - return callback_ == NULL; + return callback_.is_null(); } void set_job(Job* job) { @@ -292,9 +293,9 @@ class HostResolverImpl::Request { void OnComplete(int error, const AddressList& addrlist) { if (error == OK) *addresses_ = CreateAddressListUsingPort(addrlist, port()); - OldCompletionCallback* callback = callback_; + CompletionCallback callback = callback_; MarkAsCancelled(); - callback->Run(error); + callback.Run(error); } int port() const { @@ -328,7 +329,7 @@ class HostResolverImpl::Request { Job* job_; // The user's callback to invoke when the request completes. - OldCompletionCallback* callback_; + CompletionCallback callback_; // The address list to save result into. AddressList* addresses_; @@ -1120,12 +1121,12 @@ void HostResolverImpl::SetPoolConstraints(JobPoolIndex pool_index, int HostResolverImpl::Resolve(const RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, RequestHandle* out_req, const BoundNetLog& source_net_log) { DCHECK(addresses); - DCHECK(callback); DCHECK(CalledOnValidThread()); + DCHECK_EQ(false, callback.is_null()); // Make a log item for the request. BoundNetLog request_net_log = BoundNetLog::Make(net_log_, @@ -1146,7 +1147,7 @@ int HostResolverImpl::Resolve(const RequestInfo& info, return rv; } - // Create a handle for this request, and pass it back to the user if they + // Create a handle for this request, and pass it back to the user if they // asked for it (out_req != NULL). Request* req = new Request(source_net_log, request_net_log, info, callback, addresses); diff --git a/net/base/host_resolver_impl.h b/net/base/host_resolver_impl.h index a32cce0..da69451 100644 --- a/net/base/host_resolver_impl.h +++ b/net/base/host_resolver_impl.h @@ -129,7 +129,7 @@ class NET_EXPORT HostResolverImpl // HostResolver methods: virtual int Resolve(const RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, RequestHandle* out_req, const BoundNetLog& source_net_log) OVERRIDE; virtual int ResolveFromCache(const RequestInfo& info, diff --git a/net/base/host_resolver_impl_unittest.cc b/net/base/host_resolver_impl_unittest.cc index a4d1954..487520d 100644 --- a/net/base/host_resolver_impl_unittest.cc +++ b/net/base/host_resolver_impl_unittest.cc @@ -6,6 +6,8 @@ #include <string> +#include "base/bind.h" +#include "base/bind_helpers.h" #include "base/compiler_specific.h" #include "base/memory/ref_counted.h" #include "base/message_loop.h" @@ -267,24 +269,25 @@ class ResolveRequest { Delegate* delegate) : info_(HostPortPair(hostname, port)), resolver_(resolver), - delegate_(delegate), - ALLOW_THIS_IN_INITIALIZER_LIST( - callback_(this, &ResolveRequest::OnLookupFinished)) { + delegate_(delegate) { // Start the request. - int err = resolver->Resolve(info_, &addrlist_, &callback_, &req_, - BoundNetLog()); + int err = resolver->Resolve( + info_, &addrlist_, + base::Bind(&ResolveRequest::OnLookupFinished, base::Unretained(this)), + &req_, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, err); } ResolveRequest(HostResolver* resolver, const HostResolver::RequestInfo& info, Delegate* delegate) - : info_(info), resolver_(resolver), delegate_(delegate), - ALLOW_THIS_IN_INITIALIZER_LIST( - callback_(this, &ResolveRequest::OnLookupFinished)) { + : info_(info), resolver_(resolver), delegate_(delegate) { // Start the request. - int err = resolver->Resolve(info, &addrlist_, &callback_, &req_, - BoundNetLog()); + int err = resolver->Resolve( + info, &addrlist_, + base::Bind(&ResolveRequest::OnLookupFinished, + base::Unretained(this)), + &req_, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, err); } @@ -329,7 +332,6 @@ class ResolveRequest { HostResolver* resolver_; Delegate* delegate_; - OldCompletionCallbackImpl<ResolveRequest> callback_; DISALLOW_COPY_AND_ASSIGN(ResolveRequest); }; @@ -338,21 +340,21 @@ class HostResolverImplTest : public testing::Test { public: HostResolverImplTest() : callback_called_(false), - ALLOW_THIS_IN_INITIALIZER_LIST( - callback_(this, &HostResolverImplTest::OnLookupFinished)) { + ALLOW_THIS_IN_INITIALIZER_LIST(callback_( + base::Bind(&HostResolverImplTest::OnLookupFinished, + base::Unretained(this)))) { } protected: - bool callback_called_; - int callback_result_; - OldCompletionCallbackImpl<HostResolverImplTest> callback_; - - private: void OnLookupFinished(int result) { callback_called_ = true; callback_result_ = result; MessageLoop::current()->Quit(); } + + bool callback_called_; + int callback_result_; + CompletionCallback callback_; }; TEST_F(HostResolverImplTest, AsynchronousLookup) { @@ -368,7 +370,7 @@ TEST_F(HostResolverImplTest, AsynchronousLookup) { HostResolver::RequestInfo info(HostPortPair("just.testing", kPortnum)); CapturingBoundNetLog log(CapturingNetLog::kUnbounded); - int err = host_resolver->Resolve(info, &addrlist, &callback_, NULL, + int err = host_resolver->Resolve(info, &addrlist, callback_, NULL, log.bound()); EXPECT_EQ(ERR_IO_PENDING, err); @@ -458,7 +460,7 @@ TEST_F(HostResolverImplTest, CanceledAsynchronousLookup) { const int kPortnum = 80; HostResolver::RequestInfo info(HostPortPair("just.testing", kPortnum)); - int err = host_resolver->Resolve(info, &addrlist, &callback_, NULL, + int err = host_resolver->Resolve(info, &addrlist, callback_, NULL, log.bound()); EXPECT_EQ(ERR_IO_PENDING, err); @@ -515,9 +517,9 @@ TEST_F(HostResolverImplTest, NumericIPv4Address) { CreateHostResolverImpl(resolver_proc)); AddressList addrlist; const int kPortnum = 5555; - TestOldCompletionCallback callback; + TestCompletionCallback callback; HostResolver::RequestInfo info(HostPortPair("127.1.2.3", kPortnum)); - int err = host_resolver->Resolve(info, &addrlist, &callback, NULL, + int err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL, BoundNetLog()); EXPECT_EQ(OK, err); @@ -542,9 +544,9 @@ TEST_F(HostResolverImplTest, NumericIPv6Address) { CreateHostResolverImpl(resolver_proc)); AddressList addrlist; const int kPortnum = 5555; - TestOldCompletionCallback callback; + TestCompletionCallback callback; HostResolver::RequestInfo info(HostPortPair("2001:db8::1", kPortnum)); - int err = host_resolver->Resolve(info, &addrlist, &callback, NULL, + int err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL, BoundNetLog()); EXPECT_EQ(OK, err); @@ -574,9 +576,9 @@ TEST_F(HostResolverImplTest, EmptyHost) { CreateHostResolverImpl(resolver_proc)); AddressList addrlist; const int kPortnum = 5555; - TestOldCompletionCallback callback; + TestCompletionCallback callback; HostResolver::RequestInfo info(HostPortPair("", kPortnum)); - int err = host_resolver->Resolve(info, &addrlist, &callback, NULL, + int err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_NAME_NOT_RESOLVED, err); } @@ -591,9 +593,9 @@ TEST_F(HostResolverImplTest, LongHost) { AddressList addrlist; const int kPortnum = 5555; std::string hostname(4097, 'a'); - TestOldCompletionCallback callback; + TestCompletionCallback callback; HostResolver::RequestInfo info(HostPortPair(hostname, kPortnum)); - int err = host_resolver->Resolve(info, &addrlist, &callback, NULL, + int err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_NAME_NOT_RESOLVED, err); } @@ -937,15 +939,13 @@ class BypassCacheVerifier : public ResolveRequest::Delegate { // Since caching is enabled, this should complete synchronously. // Note that |junk_callback| shouldn't be used since we are going to - // complete synchronously. We can't specify NULL though since that would - // mean synchronous mode so we give it a value of 1. - OldCompletionCallback* junk_callback = - reinterpret_cast<OldCompletionCallback*> (1); + // complete synchronously. + TestCompletionCallback junk_callback; AddressList addrlist; HostResolver::RequestInfo info(HostPortPair("a", 70)); - int error = resolver->Resolve(info, &addrlist, junk_callback, NULL, - BoundNetLog()); + int error = resolver->Resolve(info, &addrlist, junk_callback.callback(), + NULL, BoundNetLog()); EXPECT_EQ(OK, error); // Ok good. Now make sure that if we ask to bypass the cache, it can no @@ -991,15 +991,16 @@ TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange) { // Resolve "host1". HostResolver::RequestInfo info1(HostPortPair("host1", 70)); - TestOldCompletionCallback callback; - int rv = host_resolver->Resolve(info1, &addrlist, &callback, NULL, + TestCompletionCallback callback; + int rv = host_resolver->Resolve(info1, &addrlist, callback.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); EXPECT_EQ(OK, callback.WaitForResult()); // Resolve "host1" again -- this time it will be served from cache, but it // should still notify of completion. - rv = host_resolver->Resolve(info1, &addrlist, &callback, NULL, BoundNetLog()); + rv = host_resolver->Resolve(info1, &addrlist, callback.callback(), NULL, + BoundNetLog()); ASSERT_EQ(OK, rv); // Should complete synchronously. // Flush cache by triggering an IP address change. @@ -1008,7 +1009,8 @@ TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange) { // Resolve "host1" again -- this time it won't be served from cache, so it // will complete asynchronously. - rv = host_resolver->Resolve(info1, &addrlist, &callback, NULL, BoundNetLog()); + rv = host_resolver->Resolve(info1, &addrlist, callback.callback(), NULL, + BoundNetLog()); ASSERT_EQ(ERR_IO_PENDING, rv); // Should complete asynchronously. EXPECT_EQ(OK, callback.WaitForResult()); } @@ -1021,9 +1023,9 @@ TEST_F(HostResolverImplTest, AbortOnIPAddressChanged) { // Resolve "host1". HostResolver::RequestInfo info(HostPortPair("host1", 70)); - TestOldCompletionCallback callback; + TestCompletionCallback callback; AddressList addrlist; - int rv = host_resolver->Resolve(info, &addrlist, &callback, NULL, + int rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); @@ -1053,9 +1055,9 @@ TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) { // Resolve "host1". HostResolver::RequestInfo info(HostPortPair("host1", 70)); - TestOldCompletionCallback callback; + TestCompletionCallback callback; AddressList addrlist; - int rv = host_resolver->Resolve(info, &addrlist, &callback, NULL, + int rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); @@ -1069,7 +1071,7 @@ TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) { EXPECT_EQ(ERR_ABORTED, callback.WaitForResult()); - rv = host_resolver->Resolve(info, &addrlist, &callback, NULL, + rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); resolver_proc->Wait(); @@ -1077,24 +1079,24 @@ TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) { EXPECT_EQ(OK, callback.WaitForResult()); } -class ResolveWithinCallback : public CallbackRunner< Tuple1<int> > { +class ResolveWithinCallback { public: explicit ResolveWithinCallback(const HostResolver::RequestInfo& info) : info_(info) {} - virtual void RunWithParams(const Tuple1<int>& params) { + const CompletionCallback& callback() const { return callback_.callback(); } + + int WaitForResult() { + int result = callback_.WaitForResult(); // Ditch the WaitingHostResolverProc so that the subsequent request // succeeds. - callback_.RunWithParams(params); host_resolver_.reset( CreateHostResolverImpl(CreateCatchAllHostResolverProc())); EXPECT_EQ(ERR_IO_PENDING, - host_resolver_->Resolve(info_, &addrlist_, &nested_callback_, - NULL, BoundNetLog())); - } - - int WaitForResult() { - return callback_.WaitForResult(); + host_resolver_->Resolve(info_, &addrlist_, + nested_callback_.callback(), NULL, + BoundNetLog())); + return result; } int WaitForNestedResult() { @@ -1104,8 +1106,8 @@ class ResolveWithinCallback : public CallbackRunner< Tuple1<int> > { private: const HostResolver::RequestInfo info_; AddressList addrlist_; - TestOldCompletionCallback callback_; - TestOldCompletionCallback nested_callback_; + TestCompletionCallback callback_; + TestCompletionCallback nested_callback_; scoped_ptr<HostResolver> host_resolver_; }; @@ -1118,7 +1120,7 @@ TEST_F(HostResolverImplTest, OnlyAbortExistingRequestsOnIPAddressChange) { HostResolver::RequestInfo info(HostPortPair("host1", 70)); ResolveWithinCallback callback(info); AddressList addrlist; - int rv = host_resolver->Resolve(info, &addrlist, &callback, NULL, + int rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); @@ -1158,13 +1160,14 @@ TEST_F(HostResolverImplTest, HigherPriorityRequestsStartedFirst) { CreateResolverRequest("req5", HIGHEST), }; - TestOldCompletionCallback callback[arraysize(req)]; + TestCompletionCallback callback[arraysize(req)]; AddressList addrlist[arraysize(req)]; // Start all of the requests. for (size_t i = 0; i < arraysize(req); ++i) { int rv = host_resolver->Resolve(req[i], &addrlist[i], - &callback[i], NULL, BoundNetLog()); + callback[i].callback(), NULL, + BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); } @@ -1218,14 +1221,15 @@ TEST_F(HostResolverImplTest, CancelPendingRequest) { CreateResolverRequest("req6", MEDIUM), }; - TestOldCompletionCallback callback[arraysize(req)]; + TestCompletionCallback callback[arraysize(req)]; AddressList addrlist[arraysize(req)]; HostResolver::RequestHandle handle[arraysize(req)]; // Start all of the requests. for (size_t i = 0; i < arraysize(req); ++i) { int rv = host_resolver->Resolve(req[i], &addrlist[i], - &callback[i], &handle[i], BoundNetLog()); + callback[i].callback(), &handle[i], + BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); } @@ -1294,14 +1298,15 @@ TEST_F(HostResolverImplTest, QueueOverflow) { CreateResolverRequest("req7", MEDIUM), // Evicts req2. }; - TestOldCompletionCallback callback[arraysize(req)]; + TestCompletionCallback callback[arraysize(req)]; AddressList addrlist[arraysize(req)]; HostResolver::RequestHandle handle[arraysize(req)]; // Start all of the requests. for (size_t i = 0; i < arraysize(req); ++i) { int rv = host_resolver->Resolve(req[i], &addrlist[i], - &callback[i], &handle[i], BoundNetLog()); + callback[i].callback(), &handle[i], + BoundNetLog()); if (i == 4u) EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, rv); else @@ -1361,14 +1366,15 @@ TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv4) { CreateResolverRequestForAddressFamily("h1", MEDIUM, ADDRESS_FAMILY_IPV6), }; - TestOldCompletionCallback callback[arraysize(req)]; + TestCompletionCallback callback[arraysize(req)]; AddressList addrlist[arraysize(req)]; HostResolver::RequestHandle handle[arraysize(req)]; // Start all of the requests. for (size_t i = 0; i < arraysize(req); ++i) { int rv = host_resolver->Resolve(req[i], &addrlist[i], - &callback[i], &handle[i], BoundNetLog()); + callback[i].callback(), &handle[i], + BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv) << i; } @@ -1431,14 +1437,15 @@ TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv6) { CreateResolverRequestForAddressFamily("h1", MEDIUM, ADDRESS_FAMILY_IPV4), }; - TestOldCompletionCallback callback[arraysize(req)]; + TestCompletionCallback callback[arraysize(req)]; AddressList addrlist[arraysize(req)]; HostResolver::RequestHandle handle[arraysize(req)]; // Start all of the requests. for (size_t i = 0; i < arraysize(req); ++i) { int rv = host_resolver->Resolve(req[i], &addrlist[i], - &callback[i], &handle[i], BoundNetLog()); + callback[i].callback(), &handle[i], + BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv) << i; } @@ -1493,8 +1500,9 @@ TEST_F(HostResolverImplTest, DisallowNonCachedResponses) { EXPECT_EQ(ERR_DNS_CACHE_MISS, err); // This time, we fetch normally. - TestOldCompletionCallback callback; - err = host_resolver->Resolve(info, &addrlist, &callback, NULL, log.bound()); + TestCompletionCallback callback; + err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL, + log.bound()); EXPECT_EQ(ERR_IO_PENDING, err); err = callback.WaitForResult(); EXPECT_EQ(OK, err); @@ -1538,9 +1546,9 @@ TEST_F(HostResolverImplTest, MultipleAttempts) { // Resolve "host1". HostResolver::RequestInfo info(HostPortPair("host1", 70)); - TestOldCompletionCallback callback; + TestCompletionCallback callback; AddressList addrlist; - int rv = host_resolver->Resolve(info, &addrlist, &callback, NULL, + int rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); diff --git a/net/base/mapped_host_resolver.cc b/net/base/mapped_host_resolver.cc index cb036f4..0166c33 100644 --- a/net/base/mapped_host_resolver.cc +++ b/net/base/mapped_host_resolver.cc @@ -21,11 +21,11 @@ MappedHostResolver::~MappedHostResolver() { int MappedHostResolver::Resolve(const RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, RequestHandle* out_req, const BoundNetLog& net_log) { DCHECK(addresses); - DCHECK(callback); + DCHECK_EQ(false, callback.is_null()); // Modify the request before forwarding it to |impl_|. RequestInfo modified_info = info; HostPortPair host_port(info.host_port_pair()); diff --git a/net/base/mapped_host_resolver.h b/net/base/mapped_host_resolver.h index aa98b97..a781f7e 100644 --- a/net/base/mapped_host_resolver.h +++ b/net/base/mapped_host_resolver.h @@ -46,7 +46,7 @@ class NET_EXPORT MappedHostResolver : public HostResolver { // HostResolver methods: virtual int Resolve(const RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, RequestHandle* out_req, const BoundNetLog& net_log) OVERRIDE; virtual int ResolveFromCache(const RequestInfo& info, diff --git a/net/base/mapped_host_resolver_unittest.cc b/net/base/mapped_host_resolver_unittest.cc index e24fca3..7e691be 100644 --- a/net/base/mapped_host_resolver_unittest.cc +++ b/net/base/mapped_host_resolver_unittest.cc @@ -33,10 +33,11 @@ TEST(MappedHostResolverTest, Inclusion) { // Try resolving "www.google.com:80". There are no mappings yet, so this // hits |resolver_impl| and fails. - TestOldCompletionCallback callback; + TestCompletionCallback callback; rv = resolver->Resolve(HostResolver::RequestInfo( HostPortPair("www.google.com", 80)), - &address_list, &callback, NULL, BoundNetLog()); + &address_list, callback.callback(), NULL, + BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback.WaitForResult(); EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv); @@ -47,7 +48,8 @@ TEST(MappedHostResolverTest, Inclusion) { // Try resolving "www.google.com:80". Should be remapped to "baz.com:80". rv = resolver->Resolve(HostResolver::RequestInfo( HostPortPair("www.google.com", 80)), - &address_list, &callback, NULL, BoundNetLog()); + &address_list, callback.callback(), NULL, + BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback.WaitForResult(); EXPECT_EQ(OK, rv); @@ -57,7 +59,8 @@ TEST(MappedHostResolverTest, Inclusion) { // Try resolving "foo.com:77". This will NOT be remapped, so result // is "foo.com:77". rv = resolver->Resolve(HostResolver::RequestInfo(HostPortPair("foo.com", 77)), - &address_list, &callback, NULL, BoundNetLog()); + &address_list, callback.callback(), NULL, + BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback.WaitForResult(); EXPECT_EQ(OK, rv); @@ -70,7 +73,8 @@ TEST(MappedHostResolverTest, Inclusion) { // Try resolving "chromium.org:61". Should be remapped to "proxy:99". rv = resolver->Resolve(HostResolver::RequestInfo (HostPortPair("chromium.org", 61)), - &address_list, &callback, NULL, BoundNetLog()); + &address_list, callback.callback(), NULL, + BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback.WaitForResult(); EXPECT_EQ(OK, rv); @@ -91,7 +95,7 @@ TEST(MappedHostResolverTest, Exclusion) { int rv; AddressList address_list; - TestOldCompletionCallback callback; + TestCompletionCallback callback; // Remap "*.com" to "baz". EXPECT_TRUE(resolver->AddRuleFromString("map *.com baz")); @@ -102,7 +106,8 @@ TEST(MappedHostResolverTest, Exclusion) { // Try resolving "www.google.com". Should not be remapped due to exclusion). rv = resolver->Resolve(HostResolver::RequestInfo( HostPortPair("www.google.com", 80)), - &address_list, &callback, NULL, BoundNetLog()); + &address_list, callback.callback(), NULL, + BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback.WaitForResult(); EXPECT_EQ(OK, rv); @@ -112,7 +117,8 @@ TEST(MappedHostResolverTest, Exclusion) { // Try resolving "chrome.com:80". Should be remapped to "baz:80". rv = resolver->Resolve(HostResolver::RequestInfo( HostPortPair("chrome.com", 80)), - &address_list, &callback, NULL, BoundNetLog()); + &address_list, callback.callback(), NULL, + BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback.WaitForResult(); EXPECT_EQ(OK, rv); @@ -132,7 +138,7 @@ TEST(MappedHostResolverTest, SetRulesFromString) { int rv; AddressList address_list; - TestOldCompletionCallback callback; + TestCompletionCallback callback; // Remap "*.com" to "baz", and *.net to "bar:60". resolver->SetRulesFromString("map *.com baz , map *.net bar:60"); @@ -140,7 +146,8 @@ TEST(MappedHostResolverTest, SetRulesFromString) { // Try resolving "www.google.com". Should be remapped to "baz". rv = resolver->Resolve(HostResolver::RequestInfo( HostPortPair("www.google.com", 80)), - &address_list, &callback, NULL, BoundNetLog()); + &address_list, callback.callback(), NULL, + BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback.WaitForResult(); EXPECT_EQ(OK, rv); @@ -150,7 +157,8 @@ TEST(MappedHostResolverTest, SetRulesFromString) { // Try resolving "chrome.net:80". Should be remapped to "bar:60". rv = resolver->Resolve(HostResolver::RequestInfo( HostPortPair("chrome.net", 80)), - &address_list, &callback, NULL, BoundNetLog()); + &address_list, callback.callback(), NULL, + BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback.WaitForResult(); EXPECT_EQ(OK, rv); diff --git a/net/base/mock_host_resolver.cc b/net/base/mock_host_resolver.cc index 6d4b185..612c600 100644 --- a/net/base/mock_host_resolver.cc +++ b/net/base/mock_host_resolver.cc @@ -60,11 +60,11 @@ int ParseAddressList(const std::string& host_list, struct MockHostResolverBase::Request { Request(const RequestInfo& req_info, AddressList* addr, - OldCompletionCallback* cb) + const CompletionCallback& cb) : info(req_info), addresses(addr), callback(cb) {} RequestInfo info; AddressList* addresses; - OldCompletionCallback* callback; + CompletionCallback callback; }; MockHostResolverBase::~MockHostResolverBase() { @@ -73,7 +73,7 @@ MockHostResolverBase::~MockHostResolverBase() { int MockHostResolverBase::Resolve(const RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, RequestHandle* handle, const BoundNetLog& net_log) { DCHECK(CalledOnValidThread()); @@ -188,8 +188,8 @@ void MockHostResolverBase::ResolveNow(size_t id) { scoped_ptr<Request> req(it->second); requests_.erase(it); int rv = ResolveProc(id, req->info, req->addresses); - if (req->callback) - req->callback->Run(rv); + if (!req->callback.is_null()) + req->callback.Run(rv); } //----------------------------------------------------------------------------- @@ -364,7 +364,7 @@ RuleBasedHostResolverProc* CreateCatchAllHostResolverProc() { int HangingHostResolver::Resolve(const RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, RequestHandle* out_req, const BoundNetLog& net_log) { return ERR_IO_PENDING; diff --git a/net/base/mock_host_resolver.h b/net/base/mock_host_resolver.h index 1aff3cb..76b7ce1 100644 --- a/net/base/mock_host_resolver.h +++ b/net/base/mock_host_resolver.h @@ -65,7 +65,7 @@ class MockHostResolverBase : public HostResolver, // HostResolver methods: virtual int Resolve(const RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, RequestHandle* out_req, const BoundNetLog& net_log) OVERRIDE; virtual int ResolveFromCache(const RequestInfo& info, @@ -179,7 +179,7 @@ class HangingHostResolver : public HostResolver { public: virtual int Resolve(const RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, RequestHandle* out_req, const BoundNetLog& net_log) OVERRIDE; virtual int ResolveFromCache(const RequestInfo& info, diff --git a/net/base/single_request_host_resolver.cc b/net/base/single_request_host_resolver.cc index 5af3dd5..b975c00 100644 --- a/net/base/single_request_host_resolver.cc +++ b/net/base/single_request_host_resolver.cc @@ -4,6 +4,8 @@ #include "net/base/single_request_host_resolver.h" +#include "base/bind.h" +#include "base/bind_helpers.h" #include "base/compiler_specific.h" #include "base/logging.h" #include "net/base/net_errors.h" @@ -13,9 +15,9 @@ namespace net { SingleRequestHostResolver::SingleRequestHostResolver(HostResolver* resolver) : resolver_(resolver), cur_request_(NULL), - cur_request_callback_(NULL), - ALLOW_THIS_IN_INITIALIZER_LIST( - callback_(this, &SingleRequestHostResolver::OnResolveCompletion)) { + ALLOW_THIS_IN_INITIALIZER_LIST(callback_( + base::Bind(&SingleRequestHostResolver::OnResolveCompletion, + base::Unretained(this)))) { DCHECK(resolver_ != NULL); } @@ -23,25 +25,25 @@ SingleRequestHostResolver::~SingleRequestHostResolver() { Cancel(); } -int SingleRequestHostResolver::Resolve(const HostResolver::RequestInfo& info, - AddressList* addresses, - OldCompletionCallback* callback, - const BoundNetLog& net_log) { +int SingleRequestHostResolver::Resolve( + const HostResolver::RequestInfo& info, AddressList* addresses, + const CompletionCallback& callback, const BoundNetLog& net_log) { DCHECK(addresses); - DCHECK(callback); - DCHECK(!cur_request_callback_) << "resolver already in use"; + DCHECK_EQ(false, callback.is_null()); + DCHECK(cur_request_callback_.is_null()) << "resolver already in use"; HostResolver::RequestHandle request = NULL; // We need to be notified of completion before |callback| is called, so that // we can clear out |cur_request_*|. - OldCompletionCallback* transient_callback = callback ? &callback_ : NULL; + CompletionCallback transient_callback = + callback.is_null() ? CompletionCallback() : callback_; int rv = resolver_->Resolve( info, addresses, transient_callback, &request, net_log); if (rv == ERR_IO_PENDING) { - DCHECK(callback); + DCHECK_EQ(false, callback.is_null()); // Cleared in OnResolveCompletion(). cur_request_ = request; cur_request_callback_ = callback; @@ -51,24 +53,25 @@ int SingleRequestHostResolver::Resolve(const HostResolver::RequestInfo& info, } void SingleRequestHostResolver::Cancel() { - if (cur_request_callback_) { + if (!cur_request_callback_.is_null()) { resolver_->CancelRequest(cur_request_); cur_request_ = NULL; - cur_request_callback_ = NULL; + cur_request_callback_.Reset(); } } void SingleRequestHostResolver::OnResolveCompletion(int result) { - DCHECK(cur_request_ && cur_request_callback_); + DCHECK(cur_request_); + DCHECK_EQ(false, cur_request_callback_.is_null()); - OldCompletionCallback* callback = cur_request_callback_; + CompletionCallback callback = cur_request_callback_; // Clear the outstanding request information. cur_request_ = NULL; - cur_request_callback_ = NULL; + cur_request_callback_.Reset(); // Call the user's original callback. - callback->Run(result); + callback.Run(result); } } // namespace net diff --git a/net/base/single_request_host_resolver.h b/net/base/single_request_host_resolver.h index fb5c91e..03b646f 100644 --- a/net/base/single_request_host_resolver.h +++ b/net/base/single_request_host_resolver.h @@ -27,7 +27,7 @@ class NET_EXPORT SingleRequestHostResolver { // |addresses| object upon success. See HostResolver::Resolve() for details. int Resolve(const HostResolver::RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, const BoundNetLog& net_log); // Cancels the in-progress request, if any. This prevents the callback @@ -44,10 +44,10 @@ class NET_EXPORT SingleRequestHostResolver { // The current request (if any). HostResolver::RequestHandle cur_request_; - OldCompletionCallback* cur_request_callback_; + CompletionCallback cur_request_callback_; // Completion callback for when request to |resolver_| completes. - OldCompletionCallbackImpl<SingleRequestHostResolver> callback_; + CompletionCallback callback_; DISALLOW_COPY_AND_ASSIGN(SingleRequestHostResolver); }; diff --git a/net/base/single_request_host_resolver_unittest.cc b/net/base/single_request_host_resolver_unittest.cc index 7106af5f..295a318 100644 --- a/net/base/single_request_host_resolver_unittest.cc +++ b/net/base/single_request_host_resolver_unittest.cc @@ -32,7 +32,7 @@ class HangingHostResolver : public HostResolver { virtual int Resolve(const RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, RequestHandle* out_req, const BoundNetLog& net_log) OVERRIDE { EXPECT_FALSE(has_outstanding_request()); @@ -74,10 +74,10 @@ TEST(SingleRequestHostResolverTest, NormalResolve) { // Resolve "watsup:90" using our SingleRequestHostResolver. AddressList addrlist; - TestOldCompletionCallback callback; + TestCompletionCallback callback; HostResolver::RequestInfo request(HostPortPair("watsup", 90)); int rv = single_request_resolver.Resolve( - request, &addrlist, &callback, BoundNetLog()); + request, &addrlist, callback.callback(), BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); EXPECT_EQ(OK, callback.WaitForResult()); @@ -94,10 +94,10 @@ TEST(SingleRequestHostResolverTest, Cancel) { // Resolve "watsup:90" using our SingleRequestHostResolver. AddressList addrlist; - TestOldCompletionCallback callback; + TestCompletionCallback callback; HostResolver::RequestInfo request(HostPortPair("watsup", 90)); int rv = single_request_resolver.Resolve( - request, &addrlist, &callback, BoundNetLog()); + request, &addrlist, callback.callback(), BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); EXPECT_TRUE(resolver.has_outstanding_request()); } diff --git a/net/curvecp/test_client.cc b/net/curvecp/test_client.cc index abf5957..d57a13f 100644 --- a/net/curvecp/test_client.cc +++ b/net/curvecp/test_client.cc @@ -57,7 +57,8 @@ bool TestClient::Start(const HostPortPair& server_host_port_pair, SingleRequestHostResolver host_resolver(system_host_resolver.get()); HostResolver::RequestInfo request(server_host_port_pair); AddressList addresses; - int rv = host_resolver.Resolve(request, &addresses, NULL, BoundNetLog()); + int rv = host_resolver.Resolve(request, &addresses, CompletionCallback(), + BoundNetLog()); if (rv != OK) { LOG(ERROR) << "Could not resolve host"; return false; diff --git a/net/dns/async_host_resolver.cc b/net/dns/async_host_resolver.cc index 31e612e..1666e04 100644 --- a/net/dns/async_host_resolver.cc +++ b/net/dns/async_host_resolver.cc @@ -85,7 +85,7 @@ class AsyncHostResolver::Request { const BoundNetLog& source_net_log, const BoundNetLog& request_net_log, const HostResolver::RequestInfo& info, - OldCompletionCallback* callback, + const CompletionCallback& callback, AddressList* addresses) : resolver_(resolver), source_net_log_(source_net_log), @@ -103,7 +103,7 @@ class AsyncHostResolver::Request { } ~Request() { - if (callback_) + if (!callback_.is_null()) resolver_->OnCancel(this); } @@ -161,7 +161,7 @@ class AsyncHostResolver::Request { // |addresses_| and in case of an unsuccessful synchronous completion, we // do not touch |addresses_|. void OnSyncComplete(int result) { - callback_ = NULL; + callback_.Reset(); resolver_->OnFinish(this, result); } @@ -169,11 +169,11 @@ class AsyncHostResolver::Request { void OnAsyncComplete(int result, const AddressList& addresses) { if (result == OK) *addresses_ = CreateAddressListUsingPort(addresses, info_.port()); - DCHECK(callback_); - OldCompletionCallback* callback = callback_; - callback_ = NULL; + DCHECK_EQ(false, callback_.is_null()); + CompletionCallback callback = callback_; + callback_.Reset(); resolver_->OnFinish(this, result); - callback->Run(result); + callback.Run(result); } // Returns true if request has a validly formed hostname. @@ -187,7 +187,7 @@ class AsyncHostResolver::Request { BoundNetLog request_net_log_; const HostResolver::RequestInfo info_; Key key_; - OldCompletionCallback* callback_; + CompletionCallback callback_; AddressList* addresses_; int result_; }; @@ -225,11 +225,11 @@ AsyncHostResolver::~AsyncHostResolver() { int AsyncHostResolver::Resolve(const RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, RequestHandle* out_req, const BoundNetLog& source_net_log) { DCHECK(addresses); - DCHECK(callback); + DCHECK_EQ(false, callback.is_null()); scoped_ptr<Request> request( CreateNewRequest(info, callback, addresses, source_net_log)); @@ -259,7 +259,7 @@ int AsyncHostResolver::ResolveFromCache(const RequestInfo& info, AddressList* addresses, const BoundNetLog& source_net_log) { scoped_ptr<Request> request( - CreateNewRequest(info, NULL, addresses, source_net_log)); + CreateNewRequest(info, CompletionCallback(), addresses, source_net_log)); int rv = ERR_UNEXPECTED; if (!request->IsValid()) rv = ERR_NAME_NOT_RESOLVED; @@ -382,7 +382,7 @@ void AsyncHostResolver::OnTransactionComplete( AsyncHostResolver::Request* AsyncHostResolver::CreateNewRequest( const RequestInfo& info, - OldCompletionCallback* callback, + const CompletionCallback& callback, AddressList* addresses, const BoundNetLog& source_net_log) { BoundNetLog request_net_log = BoundNetLog::Make(net_log_, diff --git a/net/dns/async_host_resolver.h b/net/dns/async_host_resolver.h index 5d09ecf..c501d65 100644 --- a/net/dns/async_host_resolver.h +++ b/net/dns/async_host_resolver.h @@ -39,7 +39,7 @@ class NET_EXPORT AsyncHostResolver // HostResolver interface virtual int Resolve(const RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, RequestHandle* out_req, const BoundNetLog& source_net_log) OVERRIDE; virtual int ResolveFromCache(const RequestInfo& info, @@ -75,7 +75,7 @@ class NET_EXPORT AsyncHostResolver // Create a new request for the incoming Resolve() call. Request* CreateNewRequest(const RequestInfo& info, - OldCompletionCallback* callback, + const CompletionCallback& callback, AddressList* addresses, const BoundNetLog& source_net_log); diff --git a/net/dns/async_host_resolver_unittest.cc b/net/dns/async_host_resolver_unittest.cc index d0de625..d92887e 100644 --- a/net/dns/async_host_resolver_unittest.cc +++ b/net/dns/async_host_resolver_unittest.cc @@ -147,12 +147,12 @@ class AsyncHostResolverTest : public testing::Test { TestPrng test_prng_; RandIntCallback rand_int_cb_; scoped_ptr<HostResolver> resolver_; - TestOldCompletionCallback callback0_, callback1_, callback2_, callback3_; + TestCompletionCallback callback0_, callback1_, callback2_, callback3_; }; TEST_F(AsyncHostResolverTest, EmptyHostLookup) { info0_.set_host_port_pair(HostPortPair("", kPortNum)); - int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL, + int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv); } @@ -161,7 +161,7 @@ TEST_F(AsyncHostResolverTest, IPv4LiteralLookup) { const char* kIPLiteral = "192.168.1.2"; info0_.set_host_port_pair(HostPortPair(kIPLiteral, kPortNum)); info0_.set_host_resolver_flags(HOST_RESOLVER_CANONNAME); - int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL, + int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, BoundNetLog()); EXPECT_EQ(OK, rv); std::vector<const char*> ip_addresses(1, kIPLiteral); @@ -171,7 +171,7 @@ TEST_F(AsyncHostResolverTest, IPv4LiteralLookup) { TEST_F(AsyncHostResolverTest, IPv6LiteralLookup) { info0_.set_host_port_pair(HostPortPair("2001:db8:0::42", kPortNum)); - int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL, + int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, BoundNetLog()); // When support for IPv6 is added, this should succeed. EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv); @@ -182,7 +182,7 @@ TEST_F(AsyncHostResolverTest, CachedLookup) { EXPECT_EQ(ERR_DNS_CACHE_MISS, rv); // Cache the result of |info0_| lookup. - rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL, + rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback0_.WaitForResult(); @@ -199,19 +199,19 @@ TEST_F(AsyncHostResolverTest, CachedLookup) { TEST_F(AsyncHostResolverTest, InvalidHostNameLookup) { const std::string kHostName1(64, 'a'); info0_.set_host_port_pair(HostPortPair(kHostName1, kPortNum)); - int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL, + int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv); const std::string kHostName2(4097, 'b'); info0_.set_host_port_pair(HostPortPair(kHostName2, kPortNum)); - rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL, + rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv); } TEST_F(AsyncHostResolverTest, Lookup) { - int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL, + int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback0_.WaitForResult(); @@ -220,11 +220,11 @@ TEST_F(AsyncHostResolverTest, Lookup) { } TEST_F(AsyncHostResolverTest, ConcurrentLookup) { - int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL, + int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, BoundNetLog()); - int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL, + int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL, BoundNetLog()); - int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL, + int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv0); EXPECT_EQ(ERR_IO_PENDING, rv1); @@ -247,11 +247,11 @@ TEST_F(AsyncHostResolverTest, ConcurrentLookup) { TEST_F(AsyncHostResolverTest, SameHostLookupsConsumeSingleTransaction) { // We pass the info0_ to all requests. - int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL, + int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, BoundNetLog()); - int rv1 = resolver_->Resolve(info0_, &addrlist1_, &callback1_, NULL, + int rv1 = resolver_->Resolve(info0_, &addrlist1_, callback1_.callback(), NULL, BoundNetLog()); - int rv2 = resolver_->Resolve(info0_, &addrlist2_, &callback2_, NULL, + int rv2 = resolver_->Resolve(info0_, &addrlist2_, callback2_.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv0); EXPECT_EQ(ERR_IO_PENDING, rv1); @@ -275,12 +275,12 @@ TEST_F(AsyncHostResolverTest, SameHostLookupsConsumeSingleTransaction) { TEST_F(AsyncHostResolverTest, CancelLookup) { HostResolver::RequestHandle req0 = NULL, req2 = NULL; - int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, &req0, - BoundNetLog()); - int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL, - BoundNetLog()); - int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, &req2, + int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), + &req0, BoundNetLog()); + int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL, BoundNetLog()); + int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), + &req2, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv0); EXPECT_EQ(ERR_IO_PENDING, rv1); EXPECT_EQ(ERR_IO_PENDING, rv2); @@ -304,9 +304,9 @@ TEST_F(AsyncHostResolverTest, CancelSameHostLookup) { HostResolver::RequestHandle req0 = NULL; // Pass the info0_ to both requests. - int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, &req0, - BoundNetLog()); - int rv1 = resolver_->Resolve(info0_, &addrlist1_, &callback1_, NULL, + int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), + &req0, BoundNetLog()); + int rv1 = resolver_->Resolve(info0_, &addrlist1_, callback1_.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv0); EXPECT_EQ(ERR_IO_PENDING, rv1); @@ -326,15 +326,15 @@ TEST_F(AsyncHostResolverTest, CancelSameHostLookup) { TEST_F(AsyncHostResolverTest, QueuedLookup) { // kMaxTransactions is 2, thus the following requests consume all // available transactions. - int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL, + int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, BoundNetLog()); - int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL, + int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv0); EXPECT_EQ(ERR_IO_PENDING, rv1); // The following request will end up in queue. - int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL, + int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv2); EXPECT_EQ(1u, @@ -358,17 +358,17 @@ TEST_F(AsyncHostResolverTest, QueuedLookup) { TEST_F(AsyncHostResolverTest, CancelPendingLookup) { // kMaxTransactions is 2, thus the following requests consume all // available transactions. - int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL, + int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, BoundNetLog()); - int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL, + int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv0); EXPECT_EQ(ERR_IO_PENDING, rv1); // The following request will end up in queue. HostResolver::RequestHandle req2 = NULL; - int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, &req2, - BoundNetLog()); + int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), + &req2, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv2); EXPECT_EQ(1u, static_cast<AsyncHostResolver*>(resolver_.get())->GetNumPending()); @@ -389,12 +389,12 @@ TEST_F(AsyncHostResolverTest, CancelPendingLookup) { } TEST_F(AsyncHostResolverTest, ResolverDestructionCancelsLookups) { - int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL, + int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, BoundNetLog()); - int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL, + int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL, BoundNetLog()); // This one is queued. - int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL, + int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL, BoundNetLog()); EXPECT_EQ(1u, static_cast<AsyncHostResolver*>(resolver_.get())->GetNumPending()); @@ -415,12 +415,12 @@ TEST_F(AsyncHostResolverTest, ResolverDestructionCancelsLookups) { // Test that when the number of pending lookups is at max, a new lookup // with a priority lower than all of those in the queue fails. TEST_F(AsyncHostResolverTest, OverflowQueueWithLowPriorityLookup) { - int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL, + int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, BoundNetLog()); - int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL, + int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL, BoundNetLog()); // This one is queued and fills up the queue since its size is 1. - int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL, + int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL, BoundNetLog()); EXPECT_EQ(1u, static_cast<AsyncHostResolver*>(resolver_.get())->GetNumPending()); @@ -431,7 +431,7 @@ TEST_F(AsyncHostResolverTest, OverflowQueueWithLowPriorityLookup) { // This one fails. info3_.set_priority(LOWEST); - int rv3 = resolver_->Resolve(info3_, &addrlist3_, &callback3_, NULL, + int rv3 = resolver_->Resolve(info3_, &addrlist3_, callback3_.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, rv3); @@ -443,9 +443,9 @@ TEST_F(AsyncHostResolverTest, OverflowQueueWithLowPriorityLookup) { // with a priority higher than any of those in the queue succeeds and // causes the lowest priority lookup in the queue to fail. TEST_F(AsyncHostResolverTest, OverflowQueueWithHighPriorityLookup) { - int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL, + int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, BoundNetLog()); - int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL, + int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL, BoundNetLog()); // Next lookup is queued. Since this will be ejected from the queue and @@ -454,8 +454,9 @@ TEST_F(AsyncHostResolverTest, OverflowQueueWithHighPriorityLookup) { HostResolver::RequestInfo info(HostPortPair("cnn.com", 80)); info.set_address_family(ADDRESS_FAMILY_IPV4); AddressList addrlist_fail; - TestOldCompletionCallback callback_fail; - int rv_fail = resolver_->Resolve(info, &addrlist_fail, &callback_fail, NULL, + TestCompletionCallback callback_fail; + int rv_fail = resolver_->Resolve(info, &addrlist_fail, + callback_fail.callback(), NULL, BoundNetLog()); EXPECT_EQ(1u, static_cast<AsyncHostResolver*>(resolver_.get())->GetNumPending()); @@ -466,7 +467,7 @@ TEST_F(AsyncHostResolverTest, OverflowQueueWithHighPriorityLookup) { // Lookup 2 causes the above to fail, but itself should succeed. info2_.set_priority(HIGHEST); - int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL, + int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL, BoundNetLog()); rv0 = callback0_.WaitForResult(); diff --git a/net/ftp/ftp_network_transaction.cc b/net/ftp/ftp_network_transaction.cc index 24ab0f9..f5ef45e 100644 --- a/net/ftp/ftp_network_transaction.cc +++ b/net/ftp/ftp_network_transaction.cc @@ -4,6 +4,8 @@ #include "net/ftp/ftp_network_transaction.h" +#include "base/bind.h" +#include "base/bind_helpers.h" #include "base/compiler_specific.h" #include "base/metrics/histogram.h" #include "base/string_number_conversions.h" @@ -627,7 +629,10 @@ int FtpNetworkTransaction::DoCtrlResolveHost() { HostResolver::RequestInfo info(HostPortPair::FromURL(request_->url)); // No known referrer. - return resolver_.Resolve(info, &addresses_, &io_callback_, net_log_); + return resolver_.Resolve( + info, &addresses_, + base::Bind(&FtpNetworkTransaction::OnIOComplete, base::Unretained(this)), + net_log_); } int FtpNetworkTransaction::DoCtrlResolveHostComplete(int result) { diff --git a/net/http/http_auth_handler_negotiate.cc b/net/http/http_auth_handler_negotiate.cc index 05604bd..814cecd 100644 --- a/net/http/http_auth_handler_negotiate.cc +++ b/net/http/http_auth_handler_negotiate.cc @@ -4,6 +4,8 @@ #include "net/http/http_auth_handler_negotiate.h" +#include "base/bind.h" +#include "base/bind_helpers.h" #include "base/logging.h" #include "base/string_util.h" #include "base/stringprintf.h" @@ -101,8 +103,6 @@ HttpAuthHandlerNegotiate::HttpAuthHandlerNegotiate( #endif disable_cname_lookup_(disable_cname_lookup), use_port_(use_port), - ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_( - this, &HttpAuthHandlerNegotiate::OnIOComplete)), resolver_(resolver), already_called_(false), has_credentials_(false), @@ -293,8 +293,11 @@ int HttpAuthHandlerNegotiate::DoResolveCanonicalName() { HostResolver::RequestInfo info(HostPortPair(origin_.host(), 0)); info.set_host_resolver_flags(HOST_RESOLVER_CANONNAME); single_resolve_.reset(new SingleRequestHostResolver(resolver_)); - return single_resolve_->Resolve(info, &address_list_, &io_callback_, - net_log_); + return single_resolve_->Resolve( + info, &address_list_, + base::Bind(&HttpAuthHandlerNegotiate::OnIOComplete, + base::Unretained(this)), + net_log_); } int HttpAuthHandlerNegotiate::DoResolveCanonicalNameComplete(int rv) { diff --git a/net/http/http_auth_handler_negotiate.h b/net/http/http_auth_handler_negotiate.h index 2731f5f..868d88a 100644 --- a/net/http/http_auth_handler_negotiate.h +++ b/net/http/http_auth_handler_negotiate.h @@ -143,7 +143,6 @@ class NET_EXPORT_PRIVATE HttpAuthHandlerNegotiate : public HttpAuthHandler { AuthSystem auth_system_; bool disable_cname_lookup_; bool use_port_; - OldCompletionCallbackImpl<HttpAuthHandlerNegotiate> io_callback_; HostResolver* const resolver_; // Members which are needed for DNS lookup + SPN. diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc index f5afd74..2af99c2 100644 --- a/net/http/http_network_transaction_unittest.cc +++ b/net/http/http_network_transaction_unittest.cc @@ -5813,10 +5813,11 @@ void BypassHostCacheOnRefreshHelper(int load_flags) { // Warm up the host cache so it has an entry for "www.google.com". AddressList addrlist; - TestOldCompletionCallback callback; + TestCompletionCallback callback; + TestOldCompletionCallback old_callback; int rv = session_deps.host_resolver->Resolve( HostResolver::RequestInfo(HostPortPair("www.google.com", 80)), &addrlist, - &callback, NULL, BoundNetLog()); + callback.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback.WaitForResult(); EXPECT_EQ(OK, rv); @@ -5825,7 +5826,7 @@ void BypassHostCacheOnRefreshHelper(int load_flags) { // and confirming it completes synchronously. rv = session_deps.host_resolver->Resolve( HostResolver::RequestInfo(HostPortPair("www.google.com", 80)), &addrlist, - &callback, NULL, BoundNetLog()); + callback.callback(), NULL, BoundNetLog()); ASSERT_EQ(OK, rv); // Inject a failure the next time that "www.google.com" is resolved. This way @@ -5840,9 +5841,9 @@ void BypassHostCacheOnRefreshHelper(int load_flags) { session_deps.socket_factory.AddSocketDataProvider(&data); // Run the request. - rv = trans->Start(&request, &callback, BoundNetLog()); + rv = trans->Start(&request, &old_callback, BoundNetLog()); ASSERT_EQ(ERR_IO_PENDING, rv); - rv = callback.WaitForResult(); + rv = old_callback.WaitForResult(); // If we bypassed the cache, we would have gotten a failure while resolving // "www.google.com". @@ -8901,8 +8902,8 @@ void IPPoolingAddAlias(MockCachingHostResolver* host_resolver, // Resolve the host and port. AddressList addresses; HostResolver::RequestInfo info(host_port_pair); - TestOldCompletionCallback callback; - int rv = host_resolver->Resolve(info, &addresses, &callback, NULL, + TestCompletionCallback callback; + int rv = host_resolver->Resolve(info, &addresses, callback.callback(), NULL, BoundNetLog()); if (rv == ERR_IO_PENDING) rv = callback.WaitForResult(); @@ -8970,16 +8971,17 @@ TEST_F(HttpNetworkTransactionTest, UseIPConnectionPooling) { spdy_writes, arraysize(spdy_writes))); session_deps.socket_factory.AddSocketDataProvider(spdy_data); - TestOldCompletionCallback callback; + TestCompletionCallback callback; + TestOldCompletionCallback old_callback; HttpRequestInfo request1; request1.method = "GET"; request1.url = GURL("https://www.google.com/"); request1.load_flags = 0; HttpNetworkTransaction trans1(session); - int rv = trans1.Start(&request1, &callback, BoundNetLog()); + int rv = trans1.Start(&request1, &old_callback, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); - EXPECT_EQ(OK, callback.WaitForResult()); + EXPECT_EQ(OK, old_callback.WaitForResult()); const HttpResponseInfo* response = trans1.GetResponseInfo(); ASSERT_TRUE(response != NULL); @@ -8994,7 +8996,7 @@ TEST_F(HttpNetworkTransactionTest, UseIPConnectionPooling) { HostPortPair host_port("www.gmail.com", 443); HostResolver::RequestInfo resolve_info(host_port); AddressList ignored; - rv = host_resolver.Resolve(resolve_info, &ignored, &callback, NULL, + rv = host_resolver.Resolve(resolve_info, &ignored, callback.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback.WaitForResult(); @@ -9012,9 +9014,9 @@ TEST_F(HttpNetworkTransactionTest, UseIPConnectionPooling) { request2.load_flags = 0; HttpNetworkTransaction trans2(session); - rv = trans2.Start(&request2, &callback, BoundNetLog()); + rv = trans2.Start(&request2, &old_callback, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); - EXPECT_EQ(OK, callback.WaitForResult()); + EXPECT_EQ(OK, old_callback.WaitForResult()); response = trans2.GetResponseInfo(); ASSERT_TRUE(response != NULL); @@ -9040,7 +9042,7 @@ class OneTimeCachingHostResolver : public net::HostResolver { // HostResolver methods: virtual int Resolve(const RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, RequestHandle* out_req, const BoundNetLog& net_log) OVERRIDE { return host_resolver_.Resolve( @@ -9123,16 +9125,17 @@ TEST_F(HttpNetworkTransactionTest, spdy_writes, arraysize(spdy_writes))); session_deps.socket_factory.AddSocketDataProvider(spdy_data); - TestOldCompletionCallback callback; + TestCompletionCallback callback; HttpRequestInfo request1; request1.method = "GET"; request1.url = GURL("https://www.google.com/"); request1.load_flags = 0; HttpNetworkTransaction trans1(session); - int rv = trans1.Start(&request1, &callback, BoundNetLog()); + TestOldCompletionCallback old_callback; + int rv = trans1.Start(&request1, &old_callback, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); - EXPECT_EQ(OK, callback.WaitForResult()); + EXPECT_EQ(OK, old_callback.WaitForResult()); const HttpResponseInfo* response = trans1.GetResponseInfo(); ASSERT_TRUE(response != NULL); @@ -9146,7 +9149,7 @@ TEST_F(HttpNetworkTransactionTest, // Preload cache entries into HostCache. HostResolver::RequestInfo resolve_info(HostPortPair("www.gmail.com", 443)); AddressList ignored; - rv = host_resolver.Resolve(resolve_info, &ignored, &callback, NULL, + rv = host_resolver.Resolve(resolve_info, &ignored, callback.callback(), NULL, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback.WaitForResult(); @@ -9164,9 +9167,9 @@ TEST_F(HttpNetworkTransactionTest, IPPoolingAddAlias(host_resolver.GetMockHostResolver(), &pool_peer, "www.google.com", 443, "127.0.0.1"); - rv = trans2.Start(&request2, &callback, BoundNetLog()); + rv = trans2.Start(&request2, &old_callback, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); - EXPECT_EQ(OK, callback.WaitForResult()); + EXPECT_EQ(OK, old_callback.WaitForResult()); response = trans2.GetResponseInfo(); ASSERT_TRUE(response != NULL); diff --git a/net/proxy/proxy_resolver_js_bindings_unittest.cc b/net/proxy/proxy_resolver_js_bindings_unittest.cc index e4fa389..6ead6ef 100644 --- a/net/proxy/proxy_resolver_js_bindings_unittest.cc +++ b/net/proxy/proxy_resolver_js_bindings_unittest.cc @@ -73,7 +73,8 @@ class MockSyncHostResolver : public SyncHostResolver { virtual int Resolve(const HostResolver::RequestInfo& info, AddressList* addresses) OVERRIDE { - return resolver_.Resolve(info, addresses, NULL, NULL, BoundNetLog()); + return resolver_.Resolve(info, addresses, CompletionCallback(), NULL, + BoundNetLog()); } virtual void Shutdown() OVERRIDE {} diff --git a/net/proxy/sync_host_resolver_bridge.cc b/net/proxy/sync_host_resolver_bridge.cc index 7bd20c6..69dce07 100644 --- a/net/proxy/sync_host_resolver_bridge.cc +++ b/net/proxy/sync_host_resolver_bridge.cc @@ -4,6 +4,7 @@ #include "net/proxy/sync_host_resolver_bridge.h" +#include "base/bind.h" #include "base/compiler_specific.h" #include "base/logging.h" #include "base/message_loop.h" @@ -52,7 +53,6 @@ class SyncHostResolverBridge::Core HostResolver* const host_resolver_; MessageLoop* const host_resolver_loop_; - net::OldCompletionCallbackImpl<Core> callback_; // The result from the current request (set on |host_resolver_loop_|). int err_; // The currently outstanding request to |host_resolver_|, or NULL. @@ -75,8 +75,6 @@ SyncHostResolverBridge::Core::Core(HostResolver* host_resolver, MessageLoop* host_resolver_loop) : host_resolver_(host_resolver), host_resolver_loop_(host_resolver_loop), - ALLOW_THIS_IN_INITIALIZER_LIST( - callback_(this, &Core::OnResolveCompletion)), err_(0), outstanding_request_(NULL), event_(true, false), @@ -104,7 +102,8 @@ void SyncHostResolverBridge::Core::StartResolve( return; int error = host_resolver_->Resolve( - info, addresses, &callback_, &outstanding_request_, BoundNetLog()); + info, addresses, base::Bind(&Core::OnResolveCompletion, this), + &outstanding_request_, BoundNetLog()); if (error != ERR_IO_PENDING) OnResolveCompletion(error); // Completed synchronously. } diff --git a/net/proxy/sync_host_resolver_bridge_unittest.cc b/net/proxy/sync_host_resolver_bridge_unittest.cc index 36586d3..d862255 100644 --- a/net/proxy/sync_host_resolver_bridge_unittest.cc +++ b/net/proxy/sync_host_resolver_bridge_unittest.cc @@ -32,10 +32,10 @@ class BlockableHostResolver : public HostResolver { virtual int Resolve(const RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, RequestHandle* out_req, const BoundNetLog& net_log) OVERRIDE { - EXPECT_TRUE(callback); + EXPECT_FALSE(callback.is_null()); EXPECT_TRUE(out_req); *out_req = reinterpret_cast<RequestHandle*>(1); // Magic value. diff --git a/net/socket/socks5_client_socket_unittest.cc b/net/socket/socks5_client_socket_unittest.cc index 9cd45db..85b07b8 100644 --- a/net/socket/socks5_client_socket_unittest.cc +++ b/net/socket/socks5_client_socket_unittest.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// Copyright (c) 2011 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. @@ -67,9 +67,9 @@ void SOCKS5ClientSocketTest::SetUp() { // Resolve the "localhost" AddressList used by the TCP connection to connect. HostResolver::RequestInfo info(HostPortPair("www.socks-proxy.com", 1080)); - TestOldCompletionCallback callback; - int rv = host_resolver_->Resolve(info, &address_list_, &callback, NULL, - BoundNetLog()); + TestCompletionCallback callback; + int rv = host_resolver_->Resolve(info, &address_list_, callback.callback(), + NULL, BoundNetLog()); ASSERT_EQ(ERR_IO_PENDING, rv); rv = callback.WaitForResult(); ASSERT_EQ(OK, rv); diff --git a/net/socket/socks_client_socket.cc b/net/socket/socks_client_socket.cc index d05f1f9..3ce723e 100644 --- a/net/socket/socks_client_socket.cc +++ b/net/socket/socks_client_socket.cc @@ -5,6 +5,7 @@ #include "net/socket/socks_client_socket.h" #include "base/basictypes.h" +#include "base/bind.h" #include "base/compiler_specific.h" #include "net/base/io_buffer.h" #include "net/base/net_log.h" @@ -280,7 +281,9 @@ int SOCKSClientSocket::DoResolveHost() { // addresses for the target host. host_request_info_.set_address_family(ADDRESS_FAMILY_IPV4); return host_resolver_.Resolve( - host_request_info_, &addresses_, &io_callback_, net_log_); + host_request_info_, &addresses_, + base::Bind(&SOCKSClientSocket::OnIOComplete, base::Unretained(this)), + net_log_); } int SOCKSClientSocket::DoResolveHostComplete(int result) { diff --git a/net/socket/socks_client_socket_unittest.cc b/net/socket/socks_client_socket_unittest.cc index 2f7645f..6762e1bb 100644 --- a/net/socket/socks_client_socket_unittest.cc +++ b/net/socket/socks_client_socket_unittest.cc @@ -87,11 +87,11 @@ class HangingHostResolverWithCancel : public HostResolver { virtual int Resolve(const RequestInfo& info, AddressList* addresses, - OldCompletionCallback* callback, + const CompletionCallback& callback, RequestHandle* out_req, const BoundNetLog& net_log) OVERRIDE { DCHECK(addresses); - DCHECK(callback); + DCHECK_EQ(false, callback.is_null()); EXPECT_FALSE(HasOutstandingRequest()); outstanding_request_ = reinterpret_cast<RequestHandle>(1); *out_req = outstanding_request_; diff --git a/net/socket/ssl_client_socket_pool_unittest.cc b/net/socket/ssl_client_socket_pool_unittest.cc index e0bca7c..7ade2e8 100644 --- a/net/socket/ssl_client_socket_pool_unittest.cc +++ b/net/socket/ssl_client_socket_pool_unittest.cc @@ -675,8 +675,8 @@ TEST_F(SSLClientSocketPoolTest, IPPooling) { // This test requires that the HostResolver cache be populated. Normal // code would have done this already, but we do it manually. HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort)); - host_resolver_.Resolve(info, &test_hosts[i].addresses, NULL, NULL, - BoundNetLog()); + host_resolver_.Resolve(info, &test_hosts[i].addresses, CompletionCallback(), + NULL, BoundNetLog()); // Setup a HostPortProxyPair test_hosts[i].pair = HostPortProxyPair( @@ -751,7 +751,8 @@ TEST_F(SSLClientSocketPoolTest, IPPoolingClientCert) { { "js.webkit.org", "192.168.0.4,192.168.0.1,192.0.2.33" }, }; - TestOldCompletionCallback callback; + TestCompletionCallback callback; + TestOldCompletionCallback old_callback; int rv; for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) { host_resolver_.rules()->AddIPLiteralRule(test_hosts[i].name, @@ -760,8 +761,8 @@ TEST_F(SSLClientSocketPoolTest, IPPoolingClientCert) { // This test requires that the HostResolver cache be populated. Normal // code would have done this already, but we do it manually. HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort)); - rv = host_resolver_.Resolve(info, &test_hosts[i].addresses, &callback, - NULL, BoundNetLog()); + rv = host_resolver_.Resolve(info, &test_hosts[i].addresses, + callback.callback(), NULL, BoundNetLog()); EXPECT_EQ(OK, callback.GetResult(rv)); // Setup a HostPortProxyPair @@ -788,12 +789,12 @@ TEST_F(SSLClientSocketPoolTest, IPPoolingClientCert) { scoped_ptr<ClientSocketHandle> handle(new ClientSocketHandle()); rv = handle->Init( - "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); + "a", params, MEDIUM, &old_callback, pool_.get(), BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); EXPECT_FALSE(handle->is_initialized()); EXPECT_FALSE(handle->socket()); - EXPECT_EQ(OK, callback.WaitForResult()); + EXPECT_EQ(OK, old_callback.WaitForResult()); EXPECT_TRUE(handle->is_initialized()); EXPECT_TRUE(handle->socket()); diff --git a/net/socket/transport_client_socket_pool.cc b/net/socket/transport_client_socket_pool.cc index 803e9e9..38ac74e 100644 --- a/net/socket/transport_client_socket_pool.cc +++ b/net/socket/transport_client_socket_pool.cc @@ -199,8 +199,10 @@ int TransportConnectJob::DoLoop(int result) { int TransportConnectJob::DoResolveHost() { next_state_ = STATE_RESOLVE_HOST_COMPLETE; - return resolver_.Resolve(params_->destination(), &addresses_, &callback_, - net_log()); + return resolver_.Resolve( + params_->destination(), &addresses_, + base::Bind(&TransportConnectJob::OnIOComplete, base::Unretained(this)), + net_log()); } int TransportConnectJob::DoResolveHostComplete(int result) { diff --git a/net/socket/transport_client_socket_unittest.cc b/net/socket/transport_client_socket_unittest.cc index 62473fe..d661e02 100644 --- a/net/socket/transport_client_socket_unittest.cc +++ b/net/socket/transport_client_socket_unittest.cc @@ -122,8 +122,9 @@ void TransportClientSocketTest::SetUp() { HostResolver::kDefaultRetryAttempts, NULL)); HostResolver::RequestInfo info(HostPortPair("localhost", listen_port_)); - TestOldCompletionCallback callback; - int rv = resolver->Resolve(info, &addr, &callback, NULL, BoundNetLog()); + TestCompletionCallback callback; + int rv = resolver->Resolve(info, &addr, callback.callback(), NULL, + BoundNetLog()); CHECK_EQ(ERR_IO_PENDING, rv); rv = callback.WaitForResult(); CHECK_EQ(rv, OK); diff --git a/net/socket_stream/socket_stream.cc b/net/socket_stream/socket_stream.cc index 5051b64..89cfd8f 100644 --- a/net/socket_stream/socket_stream.cc +++ b/net/socket_stream/socket_stream.cc @@ -608,8 +608,9 @@ int SocketStream::DoResolveHost() { DCHECK(host_resolver_); resolver_.reset(new SingleRequestHostResolver(host_resolver_)); - return resolver_->Resolve(resolve_info, &addresses_, &io_callback_, - net_log_); + return resolver_->Resolve( + resolve_info, &addresses_, base::Bind(&SocketStream::OnIOCompleted, this), + net_log_); } int SocketStream::DoResolveHostComplete(int result) { diff --git a/net/spdy/spdy_session_unittest.cc b/net/spdy/spdy_session_unittest.cc index 8e8125a..17eef50 100644 --- a/net/spdy/spdy_session_unittest.cc +++ b/net/spdy/spdy_session_unittest.cc @@ -771,7 +771,8 @@ void IPPoolingTest(bool clean_via_close_current_sessions) { // code would have done this already, but we do it manually. HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort)); session_deps.host_resolver->Resolve( - info, &test_hosts[i].addresses, NULL, NULL, BoundNetLog()); + info, &test_hosts[i].addresses, CompletionCallback(), NULL, + BoundNetLog()); // Setup a HostPortProxyPair test_hosts[i].pair = HostPortProxyPair( diff --git a/net/test/test_server.cc b/net/test/test_server.cc index 4850f4f..c27f73b 100644 --- a/net/test/test_server.cc +++ b/net/test/test_server.cc @@ -196,8 +196,8 @@ bool TestServer::GetAddressList(AddressList* address_list) const { HostResolver::kDefaultRetryAttempts, NULL)); HostResolver::RequestInfo info(host_port_pair_); - TestOldCompletionCallback callback; - int rv = resolver->Resolve(info, address_list, &callback, NULL, + TestCompletionCallback callback; + int rv = resolver->Resolve(info, address_list, callback.callback(), NULL, BoundNetLog()); if (rv == ERR_IO_PENDING) rv = callback.WaitForResult(); |