[net/auth] Don't abort network transaction over non-permanent auth errors.

net/http/http_auth_controller.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_AUTH_CONTROLLER_H_
 #define NET_HTTP_HTTP_AUTH_CONTROLLER_H_
 
 #include <memory>
 #include <set>
 #include <string>
@@ skipping 24 matching lines @@
   // The arguments are self explanatory except possibly for |auth_url|, which
   // should be both the auth target and auth path in a single url argument.
   HttpAuthController(HttpAuth::Target target,
                      const GURL& auth_url,
                      HttpAuthCache* http_auth_cache,
                      HttpAuthHandlerFactory* http_auth_handler_factory);
 
   // Generate an authentication token for |target| if necessary. The return
   // value is a net error code. |OK| will be returned both in the case that
   // a token is correctly generated synchronously, as well as when no tokens
   // were necessary.

[mmenke, 2016/10/04 19:42:14]

We're returning OK, but don't seem to be generating a token, and I don't think
no token was necessary?

[asanka, 2016/10/06 14:16:35]

Yeah, we'll need to update the documentation. It was always the case that for
permanent errors we'll return OK with no token. The caller, in general, only
wants to know whether the transaction can continue in the state the auth
controller is in after MaybeGenerateAuthToken returns. The answer to that is
yes.

We may want to consider some other error code if we, for instance, want to force
the transaction to restart with a new socket and mark the current socket as
poisoned. That's a larger change.

   virtual int MaybeGenerateAuthToken(const HttpRequestInfo* request,
                                      const CompletionCallback& callback,
                                      const NetLogWithSource& net_log);
 
   // Adds either the proxy auth header, or the origin server auth header,
   // as specified by |target_|.
   virtual void AddAuthorizationHeader(
       HttpRequestHeaders* authorization_headers);
 
   // Checks for and handles HTTP status code 401 or 407.
@@ skipping 47 matching lines @@
 
   // Sets |identity_| to the next identity that the transaction should try. It
   // chooses candidates by searching the auth cache and the URL for a
   // username:password. Returns true if an identity was found.
   bool SelectNextAuthIdentityToTry();
 
   // Populates auth_info_ with the challenge information, so that
   // URLRequestHttpJob can prompt for credentials.
   void PopulateAuthChallenge();
 
-  // If |result| indicates a permanent failure, disables the current
-  // auth scheme for this controller and returns true.  Returns false
-  // otherwise.
-  bool DisableOnAuthHandlerResult(int result);
+  // Handle the result of calling GenerateAuthToken on an HttpAuthHandler. The
+  // return value of this function should be used as the return value of the
+  // GenerateAuthToken operation.
+  int HandleGenerateTokenResult(int result);
 
   void OnIOComplete(int result);
 
   // Indicates if this handler is for Proxy auth or Server auth.
   HttpAuth::Target target_;
 
   // Holds the {scheme, host, path, port} for the authentication target.
   const GURL auth_url_;
 
   // Holds the {scheme, host, port} for the authentication target.
@@ skipping 36 matching lines @@
   HttpAuthHandlerFactory* const http_auth_handler_factory_;
 
   std::set<HttpAuth::Scheme> disabled_schemes_;
 
   CompletionCallback callback_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_AUTH_CONTROLLER_H_