DO NOT LAND

net/http/http_auth_cache_unittest.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 <string>
 
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 61 matching lines @@
 
 AuthCredentials CreateASCIICredentials(const char* username,
                                        const char* password) {
   return AuthCredentials(ASCIIToUTF16(username), ASCIIToUTF16(password));
 }
 
 }  // namespace
 
 // Test adding and looking-up cache entries (both by realm and by path).
 TEST(HttpAuthCacheTest, Basic) {
-  GURL origin("http://www.google.com");
+  url::Origin origin("http://www.google.com");
   HttpAuthCache cache;
   HttpAuthCache::Entry* entry;
 
   // Add cache entries for 4 realms: "Realm1", "Realm2", "Realm3" and
   // "Realm4"
 
   scoped_ptr<HttpAuthHandler> realm1_handler(
       new MockAuthHandler(HttpAuth::AUTH_SCHEME_BASIC,
                           kRealm1,
                           HttpAuth::AUTH_SERVER));
@@ skipping 41 matching lines @@
             realm4_basic_handler->auth_scheme(), "Basic realm=Realm4",
             CreateASCIICredentials("realm4-basic-user",
                                    "realm4-basic-password"),
             "/");
 
   // There is no Realm5
   entry = cache.Lookup(origin, kRealm5, HttpAuth::AUTH_SCHEME_BASIC);
   EXPECT_TRUE(NULL == entry);
 
   // While Realm3 does exist, the origin scheme is wrong.
-  entry = cache.Lookup(GURL("https://www.google.com"), kRealm3,
+  entry = cache.Lookup(url::Origin("https://www.google.com"), kRealm3,
                        HttpAuth::AUTH_SCHEME_BASIC);
   EXPECT_TRUE(NULL == entry);
 
   // Realm, origin scheme ok, authentication scheme wrong
-  entry = cache.Lookup
-      (GURL("http://www.google.com"), kRealm1, HttpAuth::AUTH_SCHEME_DIGEST);
+  entry = cache.Lookup(url::Origin("http://www.google.com"), kRealm1,
+                       HttpAuth::AUTH_SCHEME_DIGEST);
   EXPECT_TRUE(NULL == entry);
 
   // Valid lookup by origin, realm, scheme.
-  entry = cache.Lookup(
-      GURL("http://www.google.com:80"), kRealm3, HttpAuth::AUTH_SCHEME_BASIC);
+  entry = cache.Lookup(url::Origin("http://www.google.com:80"), kRealm3,
+                       HttpAuth::AUTH_SCHEME_BASIC);
   ASSERT_FALSE(NULL == entry);
   EXPECT_EQ(HttpAuth::AUTH_SCHEME_BASIC, entry->scheme());
   EXPECT_EQ(kRealm3, entry->realm());
   EXPECT_EQ("Basic realm=Realm3", entry->auth_challenge());
   EXPECT_EQ(ASCIIToUTF16("realm3-basic-user"), entry->credentials().username());
   EXPECT_EQ(ASCIIToUTF16("realm3-basic-password"),
             entry->credentials().password());
 
   // Valid lookup by origin, realm, scheme when there's a duplicate
   // origin, realm in the cache
-  entry = cache.Lookup(
-      GURL("http://www.google.com:80"), kRealm3, HttpAuth::AUTH_SCHEME_DIGEST);
+  entry = cache.Lookup(url::Origin("http://www.google.com:80"), kRealm3,
+                       HttpAuth::AUTH_SCHEME_DIGEST);
   ASSERT_FALSE(NULL == entry);
   EXPECT_EQ(HttpAuth::AUTH_SCHEME_DIGEST, entry->scheme());
   EXPECT_EQ(kRealm3, entry->realm());
   EXPECT_EQ("Digest realm=Realm3", entry->auth_challenge());
   EXPECT_EQ(ASCIIToUTF16("realm3-digest-user"),
             entry->credentials().username());
   EXPECT_EQ(ASCIIToUTF16("realm3-digest-password"),
             entry->credentials().password());
 
   // Valid lookup by realm.
@@ skipping 92 matching lines @@
 
   entry.AddPath("/index.html");
   EXPECT_EQ(1U, entry.paths_.size());
   EXPECT_EQ("/", entry.paths_.front());
 }
 
 // Calling Add when the realm entry already exists, should append that
 // path.
 TEST(HttpAuthCacheTest, AddToExistingEntry) {
   HttpAuthCache cache;
-  GURL origin("http://www.foobar.com:70");
+  url::Origin origin("http://www.foobar.com:70");
   const std::string auth_challenge = "Basic realm=MyRealm";
 
   scoped_ptr<HttpAuthHandler> handler(
       new MockAuthHandler(
           HttpAuth::AUTH_SCHEME_BASIC, "MyRealm", HttpAuth::AUTH_SERVER));
   HttpAuthCache::Entry* orig_entry = cache.Add(
       origin, handler->realm(), handler->auth_scheme(), auth_challenge,
       CreateASCIICredentials("user1", "password1"), "/x/y/z/");
   cache.Add(origin, handler->realm(), handler->auth_scheme(), auth_challenge,
             CreateASCIICredentials("user2", "password2"), "/z/y/x/");
   cache.Add(origin, handler->realm(), handler->auth_scheme(), auth_challenge,
             CreateASCIICredentials("user3", "password3"), "/z/y");
 
   HttpAuthCache::Entry* entry = cache.Lookup(
       origin, "MyRealm", HttpAuth::AUTH_SCHEME_BASIC);
 
   EXPECT_TRUE(entry == orig_entry);
   EXPECT_EQ(ASCIIToUTF16("user3"), entry->credentials().username());
   EXPECT_EQ(ASCIIToUTF16("password3"), entry->credentials().password());
 
   EXPECT_EQ(2U, entry->paths_.size());
   EXPECT_EQ("/z/", entry->paths_.front());
   EXPECT_EQ("/x/y/z/", entry->paths_.back());
 }
 
 TEST(HttpAuthCacheTest, Remove) {
-  GURL origin("http://foobar2.com");
+  url::Origin origin("http://foobar2.com");
 
   scoped_ptr<HttpAuthHandler> realm1_handler(
       new MockAuthHandler(
           HttpAuth::AUTH_SCHEME_BASIC, kRealm1, HttpAuth::AUTH_SERVER));
 
   scoped_ptr<HttpAuthHandler> realm2_handler(
       new MockAuthHandler(
           HttpAuth::AUTH_SCHEME_BASIC, kRealm2, HttpAuth::AUTH_SERVER));
 
   scoped_ptr<HttpAuthHandler> realm3_basic_handler(
@@ skipping 16 matching lines @@
   cache.Add(origin, realm3_digest_handler->realm(),
             realm3_digest_handler->auth_scheme(), "digest realm=Realm3",
             AuthCredentials(kRoot, kWileCoyote), "/");
 
   // Fails, because there is no realm "Realm5".
   EXPECT_FALSE(cache.Remove(
       origin, kRealm5, HttpAuth::AUTH_SCHEME_BASIC,
       AuthCredentials(kAlice, k123)));
 
   // Fails because the origin is wrong.
-  EXPECT_FALSE(cache.Remove(GURL("http://foobar2.com:100"),
-                            kRealm1,
+  EXPECT_FALSE(cache.Remove(url::Origin("http://foobar2.com:100"), kRealm1,
                             HttpAuth::AUTH_SCHEME_BASIC,
                             AuthCredentials(kAlice, k123)));
 
   // Fails because the username is wrong.
   EXPECT_FALSE(cache.Remove(
       origin, kRealm1, HttpAuth::AUTH_SCHEME_BASIC,
       AuthCredentials(kAlice2, k123)));
 
   // Fails because the password is wrong.
   EXPECT_FALSE(cache.Remove(
@@ skipping 30 matching lines @@
 
   // Make sure that removing one entry still leaves the other available for
   // lookup.
   HttpAuthCache::Entry* entry = cache.Lookup(
       origin, kRealm3, HttpAuth::AUTH_SCHEME_DIGEST);
   EXPECT_FALSE(NULL == entry);
 }
 
 TEST(HttpAuthCacheTest, UpdateStaleChallenge) {
   HttpAuthCache cache;
-  GURL origin("http://foobar2.com");
+  url::Origin origin("http://foobar2.com");
   scoped_ptr<HttpAuthHandler> digest_handler(
       new MockAuthHandler(
           HttpAuth::AUTH_SCHEME_DIGEST, kRealm1, HttpAuth::AUTH_PROXY));
   HttpAuthCache::Entry* entry_pre = cache.Add(
       origin,
       digest_handler->realm(),
       digest_handler->auth_scheme(),
       "Digest realm=Realm1,"
       "nonce=\"s3MzvFhaBAA=4c520af5acd9d8d7ae26947529d18c8eae1e98f4\"",
       CreateASCIICredentials("realm-digest-user", "realm-digest-password"),
@@ skipping 27 matching lines @@
       origin,
       kRealm2,
       digest_handler->auth_scheme(),
       "Digest realm=Realm2,"
       "nonce=\"claGgoRXBAA=7583377687842fdb7b56ba0555d175baa0b800e3\","
       "stale=\"true\"");
   EXPECT_FALSE(update_failure);
 }
 
 TEST(HttpAuthCacheTest, UpdateAllFrom) {
-  GURL origin("http://example.com");
+  url::Origin origin("http://example.com");
   std::string path("/some/path");
   std::string another_path("/another/path");
 
   scoped_ptr<HttpAuthHandler> realm1_handler(
       new MockAuthHandler(
           HttpAuth::AUTH_SCHEME_BASIC, kRealm1, HttpAuth::AUTH_SERVER));
 
   scoped_ptr<HttpAuthHandler> realm2_handler(
       new MockAuthHandler(
           HttpAuth::AUTH_SCHEME_BASIC, kRealm2, HttpAuth::AUTH_PROXY));
@@ skipping 113 matching lines @@
     const HttpAuthCache::Entry* entry =
         cache_.LookupByPath(origin_, GeneratePath(realm_i, path_i));
     if (exists) {
       EXPECT_FALSE(entry == NULL);
       EXPECT_EQ(GenerateRealm(realm_i), entry->realm());
     } else {
       EXPECT_TRUE(entry == NULL);
     }
   }
 
-  GURL origin_;
+  url::Origin origin_;
   HttpAuthCache cache_;
 
   static const int kMaxPaths = HttpAuthCache::kMaxNumPathsPerRealmEntry;
   static const int kMaxRealms = HttpAuthCache::kMaxNumRealmEntries;
 };
 
 // Add the maxinim number of realm entries to the cache. Each of these entries
 // must still be retrievable. Next add three more entries -- since the cache is
 // full this causes FIFO eviction of the first three entries.
 TEST_F(HttpAuthCacheEvictionTest, RealmEntryEviction) {
@@ skipping 30 matching lines @@
     CheckPathExistence(0, i, false);
 
   for (int i = 0; i < kMaxPaths; ++i)
     CheckPathExistence(0, i + 3, true);
 
   for (int i = 0; i < kMaxRealms; ++i)
     CheckRealmExistence(i, true);
 }
 
 }  // namespace net