Remove HttpAuth::Scheme enum in favor of a string.

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.h"
 #include "base/string_util.h"
@@ skipping 80 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
 
-  HttpAuth::Scheme auth_scheme = handler->auth_scheme();
-  DCHECK(auth_scheme >= 0 && auth_scheme < HttpAuth::AUTH_SCHEME_MAX);
+  std::string auth_scheme = handler->auth_scheme();
+
+#if 0
+  // TODO(cbentzel): This would need to convert to string -> bucket conversion.
 
   // 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
@@ skipping 27 matching lines @@
   //   Negotiate Secure Server: 15
   if (auth_event != AUTH_EVENT_START)
     return;
   static const int kTargetBucketsEnd =
       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);
+#endif
 }
 
 }  // namespace
 
 HttpAuthController::HttpAuthController(
     HttpAuth::Target target,
     const GURL& auth_url,
     HttpAuthCache* http_auth_cache,
     HttpAuthHandlerFactory* http_auth_handler_factory)
     : target_(target),
@@ skipping 336 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_->challenger = HostPortPair::FromURL(auth_origin_);
-  auth_info_->scheme = HttpAuth::SchemeToString(handler_->auth_scheme());
+  auth_info_->scheme = handler_->auth_scheme();
   auth_info_->realm = handler_->realm();
 }
 
 bool HttpAuthController::DisableOnAuthHandlerResult(int result) {
   DCHECK(CalledOnValidThread());
 
   switch (result) {
     // Occurs with GSSAPI, if the user has not already logged in.
     case ERR_MISSING_AUTH_CREDENTIALS:
 
@@ skipping 29 matching lines @@
     callback_.Reset();
     c.Run(result);
   }
 }
 
 scoped_refptr<AuthChallengeInfo> HttpAuthController::auth_info() {
   DCHECK(CalledOnValidThread());
   return auth_info_;
 }
 
-bool HttpAuthController::IsAuthSchemeDisabled(HttpAuth::Scheme scheme) const {
+bool HttpAuthController::IsAuthSchemeDisabled(const std::string& scheme) const {
   DCHECK(CalledOnValidThread());
-  return disabled_schemes_.find(scheme) != disabled_schemes_.end();
+  // TODO(cbentzel): Needed?
+  std::string lower_scheme = StringToLowerASCII(scheme);
+  return disabled_schemes_.find(lower_scheme) != disabled_schemes_.end();
 }
 
-void HttpAuthController::DisableAuthScheme(HttpAuth::Scheme scheme) {
+void HttpAuthController::DisableAuthScheme(const std::string& scheme) {
   DCHECK(CalledOnValidThread());
-  disabled_schemes_.insert(scheme);
+  // TODO(cbentzel): Needed?
+  std::string lower_scheme = StringToLowerASCII(scheme);
+  disabled_schemes_.insert(lower_scheme);
 }
 
 }  // namespace net