base::Bind: Convert HostResolver::Resolve.

jingle/notifier/communicator/xmpp_connection_generator.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.
 //
 // XmppConnectionGenerator does the following algorithm:
 //   proxy = ResolveProxyInformation(connection_options)
 //   for server in server_list
 //     get dns_addresses for server
 //     connection_list = (dns_addresses X connection methods X proxy).shuffle()
 //     for connection in connection_list
 //       yield connection
 
 #include "jingle/notifier/communicator/xmpp_connection_generator.h"
 
 #if defined(OS_WIN)
 #include <winsock2.h>
 #elif defined(OS_POSIX)
 #include <arpa/inet.h>
 #endif
 
 #include <vector>
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "jingle/notifier/base/server_information.h"
 #include "jingle/notifier/communicator/connection_options.h"
 #include "jingle/notifier/communicator/connection_settings.h"
 #include "net/base/net_errors.h"
 #include "net/base/sys_addrinfo.h"
 #include "talk/base/httpcommon-inl.h"
 #include "talk/base/task.h"
 #include "talk/base/thread.h"
 #include "talk/xmpp/prexmppauth.h"
 #include "talk/xmpp/xmppclientsettings.h"
 #include "talk/xmpp/xmppengine.h"
 
 namespace notifier {
 
 XmppConnectionGenerator::XmppConnectionGenerator(
     Delegate* delegate,
     net::HostResolver* host_resolver,
     const ConnectionOptions* options,
     bool try_ssltcp_first,
     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),
       current_server_(servers_.end()),
       try_ssltcp_first_(try_ssltcp_first),
       successfully_resolved_dns_(false),
       first_dns_error_(0),
       should_resolve_dns_(true),
       options_(options) {
   DCHECK(delegate_);
@@ skipping 57 matching lines @@
           successfully_resolved_dns_, first_dns_error_);
       return;
     }
 
     if (should_resolve_dns_) {
       // Resolve the server.
       const net::HostPortPair& server = current_server_->server;
       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).
       // Generate settings using an empty IP list (which will just use the
       // host name for the current server).
       std::vector<uint32> ip_list;
       GenerateSettingsForIPList(ip_list);
     }
   }
 }
@@ skipping 44 matching lines @@
   settings_list_->ClearPermutations();
   settings_list_->AddPermutations(
       current_server_->server.host(),
       ip_list,
       current_server_->server.port(),
       current_server_->special_port_magic,
       try_ssltcp_first_);
 }
 
 }  // namespace notifier