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

net/http/http_auth_cache.cc

 // Copyright (c) 2011 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_cache.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 
@@ skipping 62 matching lines @@
 
 HttpAuthCache::HttpAuthCache() {
 }
 
 HttpAuthCache::~HttpAuthCache() {
 }
 
 // Performance: O(n), where n is the number of realm entries.
 HttpAuthCache::Entry* HttpAuthCache::Lookup(const GURL& origin,
                                             const std::string& realm,
-                                            HttpAuth::Scheme scheme) {
+                                            const std::string& scheme) {
   CheckOriginIsValid(origin);
+  DCHECK(HttpAuth::IsValidNormalizedScheme(scheme));
 
   int entries_examined = 0;
   // Linear scan through the realm entries.
   for (EntryList::iterator it = entries_.begin(); it != entries_.end(); ++it) {
     ++entries_examined;
     if (it->origin() == origin && it->realm() == realm &&
         it->scheme() == scheme) {
       it->last_use_time_ = base::TimeTicks::Now();
       RecordLookupPosition(entries_examined);
       return &(*it);
@@ skipping 33 matching lines @@
     }
   }
   if (best_match)
     best_match->last_use_time_ = base::TimeTicks::Now();
   RecordLookupByPathPosition(best_match_position);
   return best_match;
 }
 
 HttpAuthCache::Entry* HttpAuthCache::Add(const GURL& origin,
                                          const std::string& realm,
-                                         HttpAuth::Scheme scheme,
+                                         const std::string& scheme,
                                          const std::string& auth_challenge,
                                          const AuthCredentials& credentials,
                                          const std::string& path) {
   CheckOriginIsValid(origin);
   CheckPathIsValid(path);
+  DCHECK(HttpAuth::IsValidNormalizedScheme(scheme));
 
   base::TimeTicks now = base::TimeTicks::Now();
 
   // Check for existing entry (we will re-use it if present).
   HttpAuthCache::Entry* entry = Lookup(origin, realm, scheme);
   if (!entry) {
     bool evicted = false;
     // Failsafe to prevent unbounded memory growth of the cache.
     if (entries_.size() >= kMaxNumRealmEntries) {
       LOG(WARNING) << "Num auth cache entries reached limit -- evicting";
@@ skipping 28 matching lines @@
 
 HttpAuthCache::Entry::~Entry() {
 }
 
 void HttpAuthCache::Entry::UpdateStaleChallenge(
     const std::string& auth_challenge) {
   auth_challenge_ = auth_challenge;
   nonce_count_ = 1;
 }
 
-HttpAuthCache::Entry::Entry()
-    : scheme_(HttpAuth::AUTH_SCHEME_MAX),
-      nonce_count_(0) {
-}
+HttpAuthCache::Entry::Entry() : nonce_count_(0) {}
 
 void HttpAuthCache::Entry::AddPath(const std::string& path) {
   std::string parent_dir = GetParentDirectory(path);
   if (!HasEnclosingPath(parent_dir, NULL)) {
     // Remove any entries that have been subsumed by the new entry.
     paths_.remove_if(IsEnclosedBy(parent_dir));
 
     bool evicted = false;
     // Failsafe to prevent unbounded memory growth of the cache.
     if (paths_.size() >= kMaxNumPathsPerRealmEntry) {
@@ skipping 22 matching lines @@
       if (path_len)
         *path_len = it->length();
       return true;
     }
   }
   return false;
 }
 
 bool HttpAuthCache::Remove(const GURL& origin,
                            const std::string& realm,
-                           HttpAuth::Scheme scheme,
+                           const std::string& scheme,
                            const AuthCredentials& credentials) {
+  DCHECK(HttpAuth::IsValidNormalizedScheme(scheme));
   for (EntryList::iterator it = entries_.begin(); it != entries_.end(); ++it) {
     if (it->origin() == origin && it->realm() == realm &&
         it->scheme() == scheme) {
       if (credentials.Equals(it->credentials())) {
         entries_.erase(it);
         return true;
       }
       return false;
     }
   }
   return false;
 }
 
 void HttpAuthCache::Clear() {
   entries_.clear();
 }
 
 bool HttpAuthCache::UpdateStaleChallenge(const GURL& origin,
                                          const std::string& realm,
-                                         HttpAuth::Scheme scheme,
+                                         const std::string& scheme,
                                          const std::string& auth_challenge) {
+  DCHECK(HttpAuth::IsValidNormalizedScheme(scheme));
   HttpAuthCache::Entry* entry = Lookup(origin, realm, scheme);
   if (!entry)
     return false;
   entry->UpdateStaleChallenge(auth_challenge);
   entry->last_use_time_ = base::TimeTicks::Now();
   return true;
 }
 
 void HttpAuthCache::UpdateAllFrom(const HttpAuthCache& other) {
   for (EntryList::const_iterator it = other.entries_.begin();
        it != other.entries_.end(); ++it) {
     // Add an Entry with one of the original entry's paths.
     DCHECK(it->paths_.size() > 0);
     Entry* entry = Add(it->origin(), it->realm(), it->scheme(),
                        it->auth_challenge(), it->credentials(),
                        it->paths_.back());
     // Copy all other paths.
     for (Entry::PathList::const_reverse_iterator it2 = ++it->paths_.rbegin();
          it2 != it->paths_.rend(); ++it2)
       entry->AddPath(*it2);
     // Copy nonce count (for digest authentication).
     entry->nonce_count_ = it->nonce_count_;
   }
 }
 
 }  // namespace net