Cleanup: Use AUTH_SCHEME enum instead of a string.

net/http/http_auth_controller.cc

 // 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.
 
 #include "net/http/http_auth_controller.h"
 
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
@@ skipping 78 matching lines @@
   // Note: The on-same-thread check is intentionally not using a lock
   // to protect access to first_thread. This method is meant to be only
   // used on the same thread, in which case there are no race conditions. If
   // there are race conditions (say, a read completes during a partial write),
   // the DCHECK will correctly fail.
   static base::PlatformThreadId first_thread =
       base::PlatformThread::CurrentId();
   DCHECK_EQ(first_thread, base::PlatformThread::CurrentId());
 #endif
 
-  HttpAuthHandler::AuthScheme auth_scheme = handler->auth_scheme();
-  DCHECK(auth_scheme >= 0 && auth_scheme < HttpAuthHandler::AUTH_SCHEME_MAX);
+  HttpAuth::Scheme auth_scheme = handler->auth_scheme();
+  DCHECK(auth_scheme >= 0 && auth_scheme < HttpAuth::AUTH_SCHEME_MAX);
 
   // Record start and rejection events for authentication.
   //
   // The results map to:
   //   Basic Start: 0
   //   Basic Reject: 1
   //   Digest Start: 2
   //   Digest Reject: 3
   //   NTLM Start: 4
   //   NTLM Reject: 5
   //   Negotiate Start: 6
   //   Negotiate Reject: 7
   static const int kEventBucketsEnd =
-      HttpAuthHandler::AUTH_SCHEME_MAX * AUTH_EVENT_MAX;
+      HttpAuth::AUTH_SCHEME_MAX * AUTH_EVENT_MAX;
   int event_bucket = auth_scheme * AUTH_EVENT_MAX + auth_event;
   DCHECK(event_bucket >= 0 && event_bucket < kEventBucketsEnd);
   UMA_HISTOGRAM_ENUMERATION("Net.HttpAuthCount", event_bucket,
                             kEventBucketsEnd);
 
   // Record the target of the authentication.
   //
   // The results map to:
   //   Basic Proxy: 0
   //   Basic Secure Proxy: 1
   //   Basic Server: 2
   //   Basic Secure Server: 3
   //   Digest Proxy: 4
   //   Digest Secure Proxy: 5
   //   Digest Server: 6
   //   Digest Secure Server: 7
   //   NTLM Proxy: 8
   //   NTLM Secure Proxy: 9
   //   NTLM Server: 10
   //   NTLM Secure Server: 11
   //   Negotiate Proxy: 12
   //   Negotiate Secure Proxy: 13
   //   Negotiate Server: 14
   //   Negotiate Secure Server: 15
   if (auth_event != AUTH_EVENT_START)
     return;
   static const int kTargetBucketsEnd =
-      HttpAuthHandler::AUTH_SCHEME_MAX * AUTH_TARGET_MAX;
+      HttpAuth::AUTH_SCHEME_MAX * AUTH_TARGET_MAX;
   AuthTarget auth_target = DetermineAuthTarget(handler);
   int target_bucket = auth_scheme * AUTH_TARGET_MAX + auth_target;
   DCHECK(target_bucket >= 0 && target_bucket < kTargetBucketsEnd);
   UMA_HISTOGRAM_ENUMERATION("Net.HttpAuthTarget", target_bucket,
                             kTargetBucketsEnd);
 }
 
 }  // namespace
 
 HttpAuthController::HttpAuthController(
@@ skipping 122 matching lines @@
       case HttpAuth::AUTHORIZATION_RESULT_INVALID:
         InvalidateCurrentHandler();
         break;
       case HttpAuth::AUTHORIZATION_RESULT_REJECT:
         HistogramAuthEvent(handler_.get(), AUTH_EVENT_REJECT);
         InvalidateCurrentHandler();
         break;
       case HttpAuth::AUTHORIZATION_RESULT_STALE:
         if (http_auth_cache_->UpdateStaleChallenge(auth_origin_,
                                                    handler_->realm(),
-                                                   handler_->scheme(),
+                                                   handler_->auth_scheme(),
                                                    challenge_used)) {
           handler_.reset();
           identity_ = HttpAuth::Identity();
         } else {
           // It's possible that a server could incorrectly issue a stale
           // response when the entry is not in the cache. Just evict the
           // current value from the cache.
           InvalidateCurrentHandler();
         }
         break;
@@ skipping 85 matching lines @@
   // TODO(wtc): For NTLM_SSPI, we add the same auth entry to the cache in
   // round 1 and round 2, which is redundant but correct.  It would be nice
   // to add an auth entry to the cache only once, preferrably in round 1.
   // See http://crbug.com/21015.
   switch (identity_.source) {
     case HttpAuth::IDENT_SRC_NONE:
     case HttpAuth::IDENT_SRC_DEFAULT_CREDENTIALS:
       break;
     default:
       http_auth_cache_->Add(auth_origin_, handler_->realm(),
-                            handler_->scheme(), handler_->challenge(),
+                            handler_->auth_scheme(), handler_->challenge(),
                             identity_.username, identity_.password,
                             auth_path_);
       break;
   }
 }
 
 bool HttpAuthController::HaveAuthHandler() const {
   return handler_.get() != NULL;
 }
 
@@ skipping 17 matching lines @@
   // the preemptively used auth entry matches the realm of the subsequent
   // challenge, then we can invalidate the preemptively used entry.
   // Otherwise as-is we may send the failed credentials one extra time.
   if (identity_.source == HttpAuth::IDENT_SRC_PATH_LOOKUP)
     return;
 
   // Clear the cache entry for the identity we just failed on.
   // Note: we require the username/password to match before invalidating
   // since the entry in the cache may be newer than what we used last time.
   http_auth_cache_->Remove(auth_origin_, handler_->realm(),
-                           handler_->scheme(), identity_.username,
+                           handler_->auth_scheme(), identity_.username,
                            identity_.password);
 }
 
 bool HttpAuthController::SelectNextAuthIdentityToTry() {
   DCHECK(CalledOnValidThread());
   DCHECK(handler_.get());
   DCHECK(identity_.invalid);
 
   // Try to use the username/password encoded into the URL first.
   if (target_ == HttpAuth::AUTH_SERVER && auth_url_.has_username() &&
       !embedded_identity_used_) {
     identity_.source = HttpAuth::IDENT_SRC_URL;
     identity_.invalid = false;
     // Extract the username:password from the URL.
     GetIdentityFromURL(auth_url_,
                        &identity_.username,
                        &identity_.password);
     embedded_identity_used_ = true;
     // TODO(eroman): If the password is blank, should we also try combining
     // with a password from the cache?
     return true;
   }
 
   // Check the auth cache for a realm entry.
   HttpAuthCache::Entry* entry =
       http_auth_cache_->Lookup(auth_origin_, handler_->realm(),
-                               handler_->scheme());
+                               handler_->auth_scheme());
 
   if (entry) {
     identity_.source = HttpAuth::IDENT_SRC_REALM_LOOKUP;
     identity_.invalid = false;
     identity_.username = entry->username();
     identity_.password = entry->password();
     return true;
   }
 
   // Use default credentials (single sign on) if this is the first attempt
@@ skipping 13 matching lines @@
 
 void HttpAuthController::PopulateAuthChallenge() {
   DCHECK(CalledOnValidThread());
 
   // Populates response_.auth_challenge with the authentication challenge info.
   // This info is consumed by URLRequestHttpJob::GetAuthChallengeInfo().
 
   auth_info_ = new AuthChallengeInfo;
   auth_info_->is_proxy = target_ == HttpAuth::AUTH_PROXY;
   auth_info_->host_and_port = ASCIIToWide(GetHostAndPort(auth_origin_));
-  auth_info_->scheme = ASCIIToWide(handler_->scheme());
+  auth_info_->scheme = ASCIIToWide(
+      HttpAuth::SchemeToString(handler_->auth_scheme()));
   // TODO(eroman): decode realm according to RFC 2047.
   auth_info_->realm = ASCIIToWide(handler_->realm());
 }
 
 void HttpAuthController::OnIOComplete(int result) {
   DCHECK(CalledOnValidThread());
   // This error occurs with GSSAPI, if the user has not already logged in.
   // In that case, disable the current scheme as it cannot succeed.
   if (result == ERR_MISSING_AUTH_CREDENTIALS) {
-    DisableAuthScheme(handler_->scheme());
+    DisableAuthScheme(handler_->auth_scheme());
     auth_token_.clear();
     result = OK;
   }
   if (user_callback_) {
     CompletionCallback* c = user_callback_;
     user_callback_ = NULL;
     c->Run(result);
   }
 }
 
 scoped_refptr<AuthChallengeInfo> HttpAuthController::auth_info() {
   DCHECK(CalledOnValidThread());
   return auth_info_;
 }
 
-bool HttpAuthController::IsAuthSchemeDisabled(const std::string& scheme) const {
+bool HttpAuthController::IsAuthSchemeDisabled(HttpAuth::Scheme scheme) const {
   DCHECK(CalledOnValidThread());
   return disabled_schemes_.find(scheme) != disabled_schemes_.end();
 }
 
-void HttpAuthController::DisableAuthScheme(const std::string& scheme) {
+void HttpAuthController::DisableAuthScheme(HttpAuth::Scheme scheme) {
   DCHECK(CalledOnValidThread());
   disabled_schemes_.insert(scheme);
 }
 
 }  // namespace net