Net: Convert username and password to string16.

net/http/http_auth_cache.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.
 
 #include "net/http/http_auth_cache.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 
 namespace {
@@ skipping 30 matching lines @@
 
 // Debug helper to check that |origin| arguments are properly formed.
 void CheckOriginIsValid(const GURL& origin) {
   DCHECK(origin.is_valid());
   DCHECK(origin.SchemeIs("http") || origin.SchemeIs("https"));
   DCHECK(origin.GetOrigin() == origin);
 }
 
 // Functor used by remove_if.
 struct IsEnclosedBy {
-  IsEnclosedBy(const std::string& path) : path(path) { }
+  explicit IsEnclosedBy(const std::string& path) : path(path) { }
   bool operator() (const std::string& x) {
     return IsEnclosingPath(path, x);
   }
   const std::string& path;
 };
 
-} // namespace
+}  // namespace
 
 namespace net {
 
 // Performance: O(n), where n is the number of realm entries.
 HttpAuthCache::Entry* HttpAuthCache::Lookup(const GURL& origin,
                                             const std::string& realm,
                                             const std::string& scheme) {
   CheckOriginIsValid(origin);
 
   // Linear scan through the realm entries.
   for (EntryList::iterator it = entries_.begin(); it != entries_.end(); ++it) {
     if (it->origin() == origin && it->realm() == realm &&
         it->scheme() == scheme)
       return &(*it);
   }
-  return NULL; // No realm entry found.
+  return NULL;  // No realm entry found.
 }
 
 // Performance: O(n*m), where n is the number of realm entries, m is the number
 // of path entries per realm. Both n amd m are expected to be small; m is
 // kept small because AddPath() only keeps the shallowest entry.
 HttpAuthCache::Entry* HttpAuthCache::LookupByPath(const GURL& origin,
                                                   const std::string& path) {
   CheckOriginIsValid(origin);
   CheckPathIsValid(path);
 
   // RFC 2617 section 2:
   // A client SHOULD assume that all paths at or deeper than the depth of
   // the last symbolic element in the path field of the Request-URI also are
   // within the protection space ...
   std::string parent_dir = GetParentDirectory(path);
 
   // Linear scan through the realm entries.
   for (EntryList::iterator it = entries_.begin(); it != entries_.end(); ++it) {
     if (it->origin() == origin && it->HasEnclosingPath(parent_dir))
       return &(*it);
   }
-  return NULL; // No entry found.
+  return NULL;  // No entry found.
 }
 
 HttpAuthCache::Entry* HttpAuthCache::Add(const GURL& origin,
                                          const std::string& realm,
                                          const std::string& scheme,
                                          const std::string& auth_challenge,
-                                         const std::wstring& username,
-                                         const std::wstring& password,
+                                         const string16& username,
+                                         const string16& password,
                                          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";
@@ skipping 43 matching lines @@
        ++it) {
     if (IsEnclosingPath(*it, dir))
       return true;
   }
   return false;
 }
 
 bool HttpAuthCache::Remove(const GURL& origin,
                            const std::string& realm,
                            const std::string& scheme,
-                           const std::wstring& username,
-                           const std::wstring& password) {
+                           const string16& username,
+                           const string16& password) {
   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()) {
         entries_.erase(it);
         return true;
       }
       return false;
     }
   }
   return false;
 }
 
-} // namespace net
+}  // namespace net