Cleanup: Use AUTH_SCHEME enum instead of a string.

net/http/http_auth.h

 // Copyright (c) 2010 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_H_
 #define NET_HTTP_HTTP_AUTH_H_
 #pragma once
 
 #include <set>
 #include <string>
@@ skipping 62 matching lines @@
 
     // The identity was provided by RestartWithAuth -- it likely
     // came from a prompt (or maybe the password manager).
     IDENT_SRC_EXTERNAL,
 
     // The identity used the default credentials for the computer,
     // on schemes that support single sign-on.
     IDENT_SRC_DEFAULT_CREDENTIALS,
   };
 
+  enum Scheme {
+    AUTH_SCHEME_BASIC = 0,
+    AUTH_SCHEME_DIGEST,
+    AUTH_SCHEME_NTLM,
+    AUTH_SCHEME_NEGOTIATE,
+    AUTH_SCHEME_MOCK,
+    AUTH_SCHEME_MAX,
+  };
+
   // Helper structure used by HttpNetworkTransaction to track
   // the current identity being used for authorization.
   struct Identity {
     Identity();
 
     IdentitySource source;
     bool invalid;
     string16 username;
     string16 password;
   };
 
+  // TODO(cbentzel): Change these to return const char* instead.

[eroman, 2011/01/10 19:32:39]

What function(s) is this comment referring to?

[cbentzel, 2011/01/11 16:54:18]

For the GetChallengeHaeaderName/GetAuthorizationHeaderName/GetAuthTargetString +
GetSchemeName.

I removed for now and made GetSchemeName return const char* [and renamed to
SchemeToString as you suggested].

+
   // Get the name of the header containing the auth challenge
   // (either WWW-Authenticate or Proxy-Authenticate).
   static std::string GetChallengeHeaderName(Target target);
 
   // Get the name of the header where the credentials go
   // (either Authorization or Proxy-Authorization).
   static std::string GetAuthorizationHeaderName(Target target);
 
   // Returns a string representation of a Target value that can be used in log
   // messages.
   static std::string GetAuthTargetString(Target target);
 
+  // Returns a string representation of an authentication Scheme.
+  static std::string GetSchemeName(Scheme scheme);

[eroman, 2011/01/10 19:32:39]

nit: I suggest calling this:
  const char* SchemeToString(Scheme scheme);

Which is consistent with some others like ErrorToString().

[cbentzel, 2011/01/11 16:54:18]

Done.

+
   // Iterate through the challenge headers, and pick the best one that
   // we support. Obtains the implementation class for handling the challenge,
   // and passes it back in |*handler|. If no supported challenge was found,
   // |*handler| is set to NULL.
   //
   // |disabled_schemes| is the set of schemes that we should not use.
   //
   // |origin| is used by the NTLM and Negotiation authentication scheme to
   // construct the service principal name.  It is ignored by other schemes.
   static void ChooseBestChallenge(
       HttpAuthHandlerFactory* http_auth_handler_factory,
       const HttpResponseHeaders* headers,
       Target target,
       const GURL& origin,
-      const std::set<std::string>& disabled_schemes,
+      const std::set<Scheme>& disabled_schemes,
       const BoundNetLog& net_log,
       scoped_ptr<HttpAuthHandler>* handler);
 
   // Handle a 401/407 response from a server/proxy after a previous
   // authentication attempt. For connection-based authentication schemes, the
   // new response may be another round in a multi-round authentication sequence.
   // For request-based schemes, a 401/407 response is typically treated like a
   // rejection of the previous challenge, except in the Digest case when a
   // "stale" attribute is present.
   //
   // |handler| must be non-NULL, and is the HttpAuthHandler from the previous
   // authentication round.
   //
   // |headers| must be non-NULL and contain the new HTTP response.
   //
   // |target| specifies whether the authentication challenge response came
   // from a server or a proxy.
   //
   // |disabled_schemes| are the authentication schemes to ignore.
   //
   // |challenge_used| is the text of the authentication challenge used in
   // support of the returned AuthorizationResult. If no headers were used for
   // the result (for example, all headers have unknown authentication schemes),
   // the value is cleared.
   static AuthorizationResult HandleChallengeResponse(
       HttpAuthHandler* handler,
       const HttpResponseHeaders* headers,
       Target target,
-      const std::set<std::string>& disabled_schemes,
+      const std::set<Scheme>& disabled_schemes,
       std::string* challenge_used);
 
   // Breaks up a challenge string into the the auth scheme and parameter list,
   // according to RFC 2617 Sec 1.2:
   //    challenge = auth-scheme 1*SP 1#auth-param
   //
   // Depending on the challenge scheme, it may be appropriate to interpret the
   // parameters as either a base-64 encoded string or a comma-delimited list
   // of name-value pairs. param_pairs() and base64_param() methods are provided
   // to support either usage.
@@ skipping 36 matching lines @@
     std::string::const_iterator scheme_end_;
 
     std::string::const_iterator params_begin_;
     std::string::const_iterator params_end_;
   };
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_AUTH_H_