Cleanup: Use AUTH_SCHEME enum instead of a string.

net/socket_stream/socket_stream.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.
 //
 // TODO(ukai): code is similar with http_network_transaction.cc.  We should
 //   think about ways to share code, if possible.
 
 #include "net/socket_stream/socket_stream.h"
 
 #include <set>
@@ skipping 596 matching lines @@
           auth_identity_.username = entry->username();
           auth_identity_.password = entry->password();
           auth_handler_.swap(handler_preemptive);
         }
       }
     }
 
     // Support basic authentication scheme only, because we don't have
     // HttpRequestInfo.
     // TODO(ukai): Add support other authentication scheme.
-    if (auth_handler_.get() && auth_handler_->scheme() == "basic") {
+    if (auth_handler_.get() &&
+        auth_handler_->auth_scheme() == HttpAuth::AUTH_SCHEME_BASIC) {
       HttpRequestInfo request_info;
       std::string auth_token;
       int rv = auth_handler_->GenerateAuthToken(
           &auth_identity_.username,
           &auth_identity_.password,
           &request_info,
           NULL,
           &auth_token);
       // TODO(cbentzel): Support async auth handlers.
       DCHECK_NE(ERR_IO_PENDING, rv);
@@ skipping 114 matching lines @@
       return OK;
     case 407:  // Proxy Authentication Required.
       result = HandleAuthChallenge(headers.get());
       if (result == ERR_PROXY_AUTH_UNSUPPORTED &&
           auth_handler_.get() && delegate_) {
         DCHECK(!proxy_info_.is_empty());
         auth_info_ = new AuthChallengeInfo;
         auth_info_->is_proxy = true;
         auth_info_->host_and_port =
             ASCIIToWide(proxy_info_.proxy_server().host_port_pair().ToString());
-        auth_info_->scheme = ASCIIToWide(auth_handler_->scheme());
+        auth_info_->scheme = ASCIIToWide(
+            HttpAuth::GetSchemeName(auth_handler_->auth_scheme()));
         auth_info_->realm = ASCIIToWide(auth_handler_->realm());
         // Wait until RestartWithAuth or Close is called.
         MessageLoop::current()->PostTask(
             FROM_HERE,
             NewRunnableMethod(this, &SocketStream::DoAuthRequired));
         next_state_ = STATE_AUTH_REQUIRED;
         return ERR_IO_PENDING;
       }
     default:
       break;
@@ skipping 174 matching lines @@
   VLOG(1) << "The proxy " << auth_origin << " requested auth";
 
   // TODO(cbentzel): Since SocketStream only suppports basic authentication
   // right now, another challenge is always treated as a rejection.
   // Ultimately this should be converted to use HttpAuthController like the
   // HttpNetworkTransaction has.
   if (auth_handler_.get() && !auth_identity_.invalid) {
     if (auth_identity_.source != HttpAuth::IDENT_SRC_PATH_LOOKUP)
       auth_cache_.Remove(auth_origin,
                          auth_handler_->realm(),
-                         auth_handler_->scheme(),
+                         auth_handler_->auth_scheme(),
                          auth_identity_.username,
                          auth_identity_.password);
     auth_handler_.reset();
     auth_identity_ = HttpAuth::Identity();
   }
 
   auth_identity_.invalid = true;
-  std::set<std::string> disabled_schemes;
+  std::set<HttpAuth::Scheme> disabled_schemes;
   HttpAuth::ChooseBestChallenge(http_auth_handler_factory_, headers,
                                 HttpAuth::AUTH_PROXY,
                                 auth_origin, disabled_schemes,
                                 net_log_, &auth_handler_);
   if (!auth_handler_.get()) {
     LOG(ERROR) << "Can't perform auth to the proxy " << auth_origin;
     return ERR_TUNNEL_CONNECTION_FAILED;
   }
   if (auth_handler_->NeedsIdentity()) {
     // We only support basic authentication scheme now.
     // TODO(ukai): Support other authentication scheme.
-    HttpAuthCache::Entry* entry =
-      auth_cache_.Lookup(auth_origin, auth_handler_->realm(), "basic");
+    HttpAuthCache::Entry* entry = auth_cache_.Lookup(
+        auth_origin, auth_handler_->realm(), HttpAuth::AUTH_SCHEME_BASIC);
     if (entry) {
       auth_identity_.source = HttpAuth::IDENT_SRC_REALM_LOOKUP;
       auth_identity_.invalid = false;
       auth_identity_.username = entry->username();
       auth_identity_.password = entry->password();
       // Restart with auth info.
     }
     return ERR_PROXY_AUTH_UNSUPPORTED;
   } else {
     auth_identity_.invalid = false;
   }
   return ERR_TUNNEL_CONNECTION_FAILED;
 }
 
 void SocketStream::DoAuthRequired() {
   if (delegate_ && auth_info_.get())
     delegate_->OnAuthRequired(this, auth_info_.get());
   else
     DoLoop(net::ERR_UNEXPECTED);
 }
 
 void SocketStream::DoRestartWithAuth() {
   DCHECK_EQ(next_state_, STATE_AUTH_REQUIRED);
   auth_cache_.Add(ProxyAuthOrigin(),
                   auth_handler_->realm(),
-                  auth_handler_->scheme(),
+                  auth_handler_->auth_scheme(),
                   auth_handler_->challenge(),
                   auth_identity_.username,
                   auth_identity_.password,
                   std::string());
 
   tunnel_request_headers_ = NULL;
   tunnel_request_headers_bytes_sent_ = 0;
   tunnel_response_headers_ = NULL;
   tunnel_response_headers_capacity_ = 0;
   tunnel_response_headers_len_ = 0;
@@ skipping 22 matching lines @@
 
 SSLConfigService* SocketStream::ssl_config_service() const {
   return context_->ssl_config_service();
 }
 
 ProxyService* SocketStream::proxy_service() const {
   return context_->proxy_service();
 }
 
 }  // namespace net