base::Bind: Convert HostResolver::Resolve.

net/dns/async_host_resolver.cc

 // 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.
 
 #include "net/dns/async_host_resolver.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 67 matching lines @@
 // the destruction of AsyncHostResolver, which would destruct pending or
 // in-progress requests, causing them to be cancelled.  Synchronous
 // resolution sets |callback_| to NULL, thus, if in the destructor we still
 // have a non-NULL |callback_|, we are being cancelled.
 class AsyncHostResolver::Request {
  public:
   Request(AsyncHostResolver* resolver,
           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),
         request_net_log_(request_net_log),
         info_(info),
         callback_(callback),
         addresses_(addresses),
         result_(ERR_UNEXPECTED) {
     DCHECK(addresses_);
     DCHECK(resolver_);
     resolver_->OnStart(this);
     std::string dns_name;
     if (DNSDomainFromDot(info.hostname(), &dns_name))
       key_ = Key(dns_name, QueryTypeFromAddressFamily(info.address_family()));
   }
 
   ~Request() {
-    if (callback_)
+    if (!callback_.is_null())
       resolver_->OnCancel(this);
   }
 
   int result() const { return result_; }
   const Key& key() const {
     DCHECK(IsValid());
     return key_;
   }
   const HostResolver::RequestInfo& info() const { return info_; }
   RequestPriority priority() const { return info_.priority(); }
@@ skipping 37 matching lines @@
     }
     return false;
   }
 
   // Called when a request completes synchronously; we do not have an
   // AddressList argument, since in case of a successful synchronous
   // completion, either ResolveAsIp or ServerFromCache would set the
   // |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);
   }
 
   // Called when a request completes asynchronously.
   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.
   bool IsValid() const {
     return !info_.hostname().empty() && !key_.first.empty();
   }
 
  private:
   AsyncHostResolver* resolver_;
   BoundNetLog source_net_log_;
   BoundNetLog request_net_log_;
   const HostResolver::RequestInfo info_;
   Key key_;
-  OldCompletionCallback* callback_;
+  CompletionCallback callback_;
   AddressList* addresses_;
   int result_;
 };
 
 //-----------------------------------------------------------------------------
 AsyncHostResolver::AsyncHostResolver(const IPEndPoint& dns_server,
                                      size_t max_transactions,
                                      size_t max_pending_requests,
                                      const RandIntCallback& rand_int_cb,
                                      HostCache* cache,
@@ skipping 17 matching lines @@
   // Destroy transactions.
   STLDeleteElements(&transactions_);
 
   // Destroy pending requests.
   for (size_t i = 0; i < arraysize(pending_requests_); ++i)
     STLDeleteElements(&pending_requests_[i]);
 }
 
 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));
 
   int rv = ERR_UNEXPECTED;
   if (!request->IsValid())
     rv = ERR_NAME_NOT_RESOLVED;
   else if (request->ResolveAsIp() || request->ServeFromCache())
     rv = request->result();
   else if (AttachToRequestList(request.get()))
     rv = ERR_IO_PENDING;
   else if (transactions_.size() < max_transactions_)
     rv = StartNewTransactionFor(request.get());
   else
     rv = Enqueue(request.get());
 
   if (rv != ERR_IO_PENDING) {
     request->OnSyncComplete(rv);
   } else {
     Request* req = request.release();
     if (out_req)
       *out_req = reinterpret_cast<RequestHandle>(req);
   }
   return rv;
 }
 
 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;
   else if (request->ResolveAsIp() || request->ServeFromCache())
     rv = request->result();
   else
     rv = ERR_DNS_CACHE_MISS;
   request->OnSyncComplete(rv);
   return rv;
 }
@@ skipping 102 matching lines @@
   requestlist_map_.erase(transaction->key());
 
   // Cleanup transaction and start a new one if there are pending requests.
   delete transaction;
   transactions_.remove(transaction);
   ProcessPending();
 }
 
 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_,
       NetLog::SOURCE_ASYNC_HOST_RESOLVER_REQUEST);
   return new Request(
       this, source_net_log, request_net_log, info, callback, addresses);
 }
 
 bool AsyncHostResolver::AttachToRequestList(Request* request) {
   KeyRequestListMap::iterator it = requestlist_map_.find(request->key());
@@ skipping 91 matching lines @@
         it = requests.erase(it);
       } else {
         ++it;
       }
     }
   }
   StartNewTransactionFor(request);
 }
 
 }  // namespace net