base::Bind: Convert HostResolver::Resolve.

net/base/mock_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/base/mock_host_resolver.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
@@ skipping 42 matching lines @@
       *addrlist = AddressList::CreateByCopyingFirstAddress(result.head());
     else
       addrlist->Append(result.head());
   }
   return OK;
 }
 
 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() {
   STLDeleteValues(&requests_);
 }
 
 int MockHostResolverBase::Resolve(const RequestInfo& info,
                                   AddressList* addresses,
-                                  OldCompletionCallback* callback,
+                                  const CompletionCallback& callback,
                                   RequestHandle* handle,
                                   const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
   size_t id = next_request_id_++;
   FOR_EACH_OBSERVER(Observer, observers_, OnStartResolution(id, info));
   int rv = ResolveFromIPLiteralOrCache(info, addresses);
   if (rv != ERR_DNS_CACHE_MISS) {
     FOR_EACH_OBSERVER(Observer, observers_,
                       OnFinishResolutionWithStatus(id, rv == OK, info));
     return rv;
@@ skipping 111 matching lines @@
 }
 
 void MockHostResolverBase::ResolveNow(size_t id) {
   RequestMap::iterator it = requests_.find(id);
   if (it == requests_.end())
     return;  // was canceled
 
   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);
 }
 
 //-----------------------------------------------------------------------------
 
 struct RuleBasedHostResolverProc::Rule {
   enum ResolverType {
     kResolverTypeFail,
     kResolverTypeSystem,
     kResolverTypeIPLiteral,
   };
@@ skipping 154 matching lines @@
 #endif
 
   // Next add a rules-based layer the use controls.
   return new RuleBasedHostResolverProc(catchall);
 }
 
 //-----------------------------------------------------------------------------
 
 int HangingHostResolver::Resolve(const RequestInfo& info,
                                  AddressList* addresses,
-                                 OldCompletionCallback* callback,
+                                 const CompletionCallback& callback,
                                  RequestHandle* out_req,
                                  const BoundNetLog& net_log) {
   return ERR_IO_PENDING;
 }
 
 int HangingHostResolver::ResolveFromCache(const RequestInfo& info,
                                           AddressList* addresses,
                                           const BoundNetLog& net_log) {
   return ERR_DNS_CACHE_MISS;
 }
@@ skipping 13 matching lines @@
   CHECK_EQ(old_proc, current_proc_);
 }
 
 void ScopedDefaultHostResolverProc::Init(HostResolverProc* proc) {
   current_proc_ = proc;
   previous_proc_ = HostResolverProc::SetDefault(current_proc_);
   current_proc_->SetLastProc(previous_proc_);
 }
 
 }  // namespace net