[net/http auth] Use strings to identify authentication schemes.

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 49 matching lines @@
 };
 
 enum AuthTarget {
   AUTH_TARGET_PROXY = 0,
   AUTH_TARGET_SECURE_PROXY,
   AUTH_TARGET_SERVER,
   AUTH_TARGET_SECURE_SERVER,
   AUTH_TARGET_MAX,
 };
 
+// Known authentication schemes.
+enum AuthScheme {
+  AUTH_SCHEME_BASIC = 0,
+  AUTH_SCHEME_DIGEST,
+  AUTH_SCHEME_NTLM,
+  AUTH_SCHEME_NEGOTIATE,
+  AUTH_SCHEME_SPDYPROXY_DEPRECATED,
+  AUTH_SCHEME_MOCK,
+
+  // Add new schemes above this line and don't remove any values. This
+  // enumeration is used for UMA.
+  AUTH_SCHEME_MAX,
+};
+
+AuthScheme AuthSchemeForUMA(const std::string& scheme) {
+  DCHECK(HttpAuth::IsValidNormalizedScheme(scheme));
+
+  if (scheme == "basic")
+    return AUTH_SCHEME_BASIC;
+
+  if (scheme == "digest")
+    return AUTH_SCHEME_DIGEST;
+
+  if (scheme == "ntlm")
+    return AUTH_SCHEME_NTLM;
+
+  if (scheme == "negotiate")
+    return AUTH_SCHEME_NEGOTIATE;
+
+  if (scheme == "mock")
+    return AUTH_SCHEME_MOCK;
+
+  return AUTH_SCHEME_MAX;
+}
+
 AuthTarget DetermineAuthTarget(const HttpAuthHandler* handler) {
   switch (handler->target()) {
     case HttpAuth::AUTH_PROXY:
       if (handler->origin().SchemeIsCryptographic())
         return AUTH_TARGET_SECURE_PROXY;
       else
         return AUTH_TARGET_PROXY;
     case HttpAuth::AUTH_SERVER:
       if (handler->origin().SchemeIsCryptographic())
         return AUTH_TARGET_SECURE_SERVER;
@@ skipping 11 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);
+  AuthScheme auth_scheme = AuthSchemeForUMA(handler->auth_scheme());
+  // Only measure known auth schemes.
+  if (auth_scheme == AUTH_SCHEME_MAX)
+    return;
 
   // 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 =
-      HttpAuth::AUTH_SCHEME_MAX * AUTH_EVENT_MAX;
+  static const int kEventBucketsEnd = 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 =
-      HttpAuth::AUTH_SCHEME_MAX * AUTH_TARGET_MAX;
+  static const int kTargetBucketsEnd = 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 348 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();
+  return disabled_schemes_.Contains(scheme);
 }
 
-void HttpAuthController::DisableAuthScheme(HttpAuth::Scheme scheme) {
+void HttpAuthController::DisableAuthScheme(const std::string& scheme) {
   DCHECK(CalledOnValidThread());
-  disabled_schemes_.insert(scheme);
+  disabled_schemes_.Add(scheme);
 }
 
 void HttpAuthController::DisableEmbeddedIdentity() {
   DCHECK(CalledOnValidThread());
   embedded_identity_used_ = true;
 }
 
 }  // namespace net