First step to remove SingleRequestHostResolver.

net/http/http_auth_handler_negotiate.cc

 // Copyright (c) 2012 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/http/http_auth_handler_negotiate.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "net/base/address_family.h"
 #include "net/base/net_errors.h"
 #include "net/cert/x509_util.h"
 #include "net/dns/host_resolver.h"
-#include "net/dns/single_request_host_resolver.h"
 #include "net/http/http_auth_filter.h"
 #include "net/http/http_auth_preferences.h"
 #include "net/log/net_log.h"
 #include "net/ssl/ssl_info.h"
 
 namespace net {
 
 namespace {
 
 std::unique_ptr<base::Value> NetLogParameterChannelBindings(
     const std::string& channel_binding_token,
     NetLogCaptureMode capture_mode) {
   std::unique_ptr<base::DictionaryValue> dict;
   if (!capture_mode.include_socket_bytes())
     return std::move(dict);
 
   dict.reset(new base::DictionaryValue());
   dict->SetString("token", base::HexEncode(channel_binding_token.data(),
                                            channel_binding_token.size()));
   return std::move(dict);
 }
 
 }  // namespace
 
 HttpAuthHandlerNegotiate::Factory::Factory()
-    : resolver_(NULL),
+    : resolver_(nullptr),
 #if defined(OS_WIN)
       max_token_length_(0),
 #endif
       is_unsupported_(false) {
 }
 
 HttpAuthHandlerNegotiate::Factory::~Factory() {
 }
 
 void HttpAuthHandlerNegotiate::Factory::set_host_resolver(
@@ skipping 262 matching lines @@
 }
 
 int HttpAuthHandlerNegotiate::DoResolveCanonicalName() {
   next_state_ = STATE_RESOLVE_CANONICAL_NAME_COMPLETE;
   if ((http_auth_preferences_ &&
        http_auth_preferences_->NegotiateDisableCnameLookup()) ||
       !resolver_)
     return OK;
 
   // TODO(cbentzel): Add reverse DNS lookup for numeric addresses.
-  DCHECK(!single_resolve_.get());
   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,
-      DEFAULT_PRIORITY,
-      &address_list_,
-      base::Bind(&HttpAuthHandlerNegotiate::OnIOComplete,
-                 base::Unretained(this)),
-      net_log_);
+  return resolver_->Resolve(info, DEFAULT_PRIORITY, &address_list_,
+                            base::Bind(&HttpAuthHandlerNegotiate::OnIOComplete,
+                                       base::Unretained(this)),
+                            &request_, net_log_);
 }
 
 int HttpAuthHandlerNegotiate::DoResolveCanonicalNameComplete(int rv) {
   DCHECK_NE(ERR_IO_PENDING, rv);
   if (rv != OK) {
     // Even in the error case, try to use origin_.host instead of
     // passing the failure on to the caller.
     VLOG(1) << "Problem finding canonical name for SPN for host "
             << origin_.host() << ": " << ErrorToString(rv);
     rv = OK;
@@ skipping 23 matching lines @@
 bool HttpAuthHandlerNegotiate::CanDelegate() const {
   // TODO(cbentzel): Should delegation be allowed on proxies?
   if (target_ == HttpAuth::AUTH_PROXY)
     return false;
   if (!http_auth_preferences_)
     return false;
   return http_auth_preferences_->CanDelegate(origin_);
 }
 
 }  // namespace net