Use AuthCredentials throughout the network stack instead of username/password.

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/string_util.h"
 
 namespace {
@@ skipping 94 matching lines @@
       best_match = &(*it);
     }
   }
   return best_match;
 }
 
 HttpAuthCache::Entry* HttpAuthCache::Add(const GURL& origin,
                                          const std::string& realm,
                                          HttpAuth::Scheme scheme,
                                          const std::string& auth_challenge,
-                                         const string16& username,
-                                         const string16& password,
+                                         const AuthCredentials& credentials,
                                          const std::string& path) {
   CheckOriginIsValid(origin);
   CheckPathIsValid(path);
 
   // Check for existing entry (we will re-use it if present).
   HttpAuthCache::Entry* entry = Lookup(origin, realm, scheme);
   if (!entry) {
     // Failsafe to prevent unbounded memory growth of the cache.
     if (entries_.size() >= kMaxNumRealmEntries) {
       LOG(WARNING) << "Num auth cache entries reached limit -- evicting";
       entries_.pop_back();
     }
 
     entries_.push_front(Entry());
     entry = &entries_.front();
     entry->origin_ = origin;
     entry->realm_ = realm;
     entry->scheme_ = scheme;
   }
   DCHECK_EQ(origin, entry->origin_);
   DCHECK_EQ(realm, entry->realm_);
   DCHECK_EQ(scheme, entry->scheme_);
 
   entry->auth_challenge_ = auth_challenge;
-  entry->username_ = username;
-  entry->password_ = password;
+  entry->credentials_ = credentials;
   entry->nonce_count_ = 1;
   entry->AddPath(path);
 
   return entry;
 }
 
 HttpAuthCache::Entry::~Entry() {
 }
 
 void HttpAuthCache::Entry::UpdateStaleChallenge(
@@ skipping 39 matching lines @@
         *path_len = it->length();
       return true;
     }
   }
   return false;
 }
 
 bool HttpAuthCache::Remove(const GURL& origin,
                            const std::string& realm,
                            HttpAuth::Scheme scheme,
-                           const string16& username,
-                           const string16& password) {
+                           const AuthCredentials& credentials) {
   for (EntryList::iterator it = entries_.begin(); it != entries_.end(); ++it) {
     if (it->origin() == origin && it->realm() == realm &&
         it->scheme() == scheme) {
-      if (username == it->username() && password == it->password()) {
+      if (credentials.Equals(it->credentials())) {
         entries_.erase(it);
         return true;
       }
       return false;
     }
   }
   return false;
 }
 
 bool HttpAuthCache::UpdateStaleChallenge(const GURL& origin,
                                          const std::string& realm,
                                          HttpAuth::Scheme scheme,
                                          const std::string& auth_challenge) {
   HttpAuthCache::Entry* entry = Lookup(origin, realm, scheme);
   if (!entry)
     return false;
   entry->UpdateStaleChallenge(auth_challenge);
   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->username(), it->password(),
+                       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