[net/auth] Reset AuthChallengeInfo before picking a new HttpAuthHandler.

net/http/http_auth_controller.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_controller.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
@@ skipping 128 matching lines @@
 
 HttpAuthController::~HttpAuthController() {
   DCHECK(CalledOnValidThread());
 }
 
 int HttpAuthController::MaybeGenerateAuthToken(
     const HttpRequestInfo* request,
     const CompletionCallback& callback,
     const NetLogWithSource& net_log) {
   DCHECK(CalledOnValidThread());
+  DCHECK(!auth_info_);
   bool needs_auth = HaveAuth() || SelectPreemptiveAuth(net_log);
   if (!needs_auth)
     return OK;
   const AuthCredentials* credentials = NULL;
   if (identity_.source != HttpAuth::IDENT_SRC_DEFAULT_CREDENTIALS)
     credentials = &identity_.credentials;
   DCHECK(auth_token_.empty());
   DCHECK(callback_.is_null());
   int rv = handler_->GenerateAuthToken(
       credentials, request,
@@ skipping 61 matching lines @@
 
 int HttpAuthController::HandleAuthChallenge(
     scoped_refptr<HttpResponseHeaders> headers,
     const SSLInfo& ssl_info,
     bool do_not_send_server_auth,
     bool establishing_tunnel,
     const NetLogWithSource& net_log) {
   DCHECK(CalledOnValidThread());
   DCHECK(headers.get());
   DCHECK(auth_origin_.is_valid());
+  DCHECK(!auth_info_);
 
   // Give the existing auth handler first try at the authentication headers.
   // This will also evict the entry in the HttpAuthCache if the previous
   // challenge appeared to be rejected, or is using a stale nonce in the Digest
   // case.
   if (HaveAuth()) {
     std::string challenge_used;
     HttpAuth::AuthorizationResult result = HttpAuth::HandleChallengeResponse(
         handler_.get(), *headers, target_, disabled_schemes_, &challenge_used);
     switch (result) {
@@ skipping 30 matching lines @@
             INVALIDATE_HANDLER :
             INVALIDATE_HANDLER_AND_CACHED_CREDENTIALS);
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   identity_.invalid = true;
-
   bool can_send_auth = (target_ != HttpAuth::AUTH_SERVER ||
                         !do_not_send_server_auth);
 
   do {
     if (!handler_.get() && can_send_auth) {
       // Find the best authentication challenge that we support.
       HttpAuth::ChooseBestChallenge(http_auth_handler_factory_, *headers,
                                     ssl_info, target_, auth_origin_,
                                     disabled_schemes_, net_log, &handler_);
       if (handler_.get())
@@ skipping 28 matching lines @@
       // We have exhausted all identity possibilities.
       if (!handler_->AllowsExplicitCredentials()) {
         // If the handler doesn't accept explicit credentials, then we need to
         // choose a different auth scheme.
         HistogramAuthEvent(handler_.get(), AUTH_EVENT_REJECT);
         InvalidateCurrentHandler(INVALIDATE_HANDLER_AND_DISABLE_SCHEME);
       } else {
         // Pass the challenge information back to the client.
         PopulateAuthChallenge();
       }
-    } else {
-      auth_info_ = NULL;
     }
 
     // If we get here and we don't have a handler_, that's because we
     // invalidated it due to not having any viable identities to use with it. Go
     // back and try again.
     // TODO(asanka): Instead we should create a priority list of
     //     <handler,identity> and iterate through that.
   } while(!handler_.get());
   return OK;
 }
 
 void HttpAuthController::ResetAuth(const AuthCredentials& credentials) {
   DCHECK(CalledOnValidThread());
   DCHECK(identity_.invalid || credentials.Empty());
 
   if (identity_.invalid) {
     // Update the credentials.
     identity_.source = HttpAuth::IDENT_SRC_EXTERNAL;
     identity_.invalid = false;
     identity_.credentials = credentials;
+
+    // auth_info_ is no longer necessary.
+    auth_info_ = nullptr;
   }
 
   DCHECK(identity_.source != HttpAuth::IDENT_SRC_PATH_LOOKUP);
 
   // Add the auth entry to the cache before restarting. We don't know whether
   // the identity is valid yet, but if it is valid we want other transactions
   // to know about it. If an entry for (origin, handler->realm()) already
   // exists, we update it.
   //
   // If identity_.source is HttpAuth::IDENT_SRC_NONE or
@@ skipping 178 matching lines @@
   DCHECK(CalledOnValidThread());
   disabled_schemes_.insert(scheme);
 }
 
 void HttpAuthController::DisableEmbeddedIdentity() {
   DCHECK(CalledOnValidThread());
   embedded_identity_used_ = true;
 }
 
 }  // namespace net