DO NOT LAND

net/http/http_auth_handler_digest_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/basictypes.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_auth_challenge_tokenizer.h"
 #include "net/http/http_auth_handler_digest.h"
 #include "net/http/http_request_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "url/origin.h"
 
 namespace net {
 
 namespace {
 
 const char* const kSimpleChallenge =
   "Digest realm=\"Oblivion\", nonce=\"nonce-value\"";
 
 // RespondToChallenge creates an HttpAuthHandlerDigest for the specified
 // |challenge|, and generates a response to the challenge which is returned in
@@ skipping 20 matching lines @@
 
   token->clear();
   scoped_ptr<HttpAuthHandlerDigest::Factory> factory(
       new HttpAuthHandlerDigest::Factory());
   HttpAuthHandlerDigest::NonceGenerator* nonce_generator =
       new HttpAuthHandlerDigest::FixedNonceGenerator("client_nonce");
   factory->set_nonce_generator(nonce_generator);
   scoped_ptr<HttpAuthHandler> handler;
 
   // Create a handler for a particular challenge.
-  GURL url_origin(target == HttpAuth::AUTH_SERVER ? request_url : proxy_name);
+  url::Origin url_origin(target == HttpAuth::AUTH_SERVER ? request_url
+                                                         : proxy_name);
   int rv_create = factory->CreateAuthHandlerFromString(
-    challenge, target, url_origin.GetOrigin(), BoundNetLog(), &handler);
+      challenge, target, url_origin, BoundNetLog(), &handler);
   if (rv_create != OK || handler.get() == NULL) {
     ADD_FAILURE() << "Unable to create auth handler.";
     return false;
   }
 
   // Create a token in response to the challenge.
   // NOTE: HttpAuthHandlerDigest's implementation of GenerateAuthToken always
   // completes synchronously. That's why this test can get away with a
   // TestCompletionCallback without an IO thread.
   TestCompletionCallback callback;
@@ skipping 272 matching lines @@
       "",
       "",
       "",
       "",
       false,
       HttpAuthHandlerDigest::ALGORITHM_UNSPECIFIED,
       HttpAuthHandlerDigest::QOP_UNSPECIFIED
     },
   };
 
-  GURL origin("http://www.example.com");
+  url::Origin origin("http://www.example.com");
   scoped_ptr<HttpAuthHandlerDigest::Factory> factory(
       new HttpAuthHandlerDigest::Factory());
   for (size_t i = 0; i < arraysize(tests); ++i) {
     scoped_ptr<HttpAuthHandler> handler;
     int rv = factory->CreateAuthHandlerFromString(tests[i].challenge,
                                                   HttpAuth::AUTH_SERVER,
                                                   origin,
                                                   BoundNetLog(),
                                                   &handler);
     if (tests[i].parsed_success) {
@@ skipping 144 matching lines @@
       "15c07961ed8575c4", // cnonce
       1, // nc
 
       // Authorization
       "Digest username=\"USER\", realm=\"Baztastic\", "
       "nonce=\"AAAAAAAA\", uri=\"/\", algorithm=MD5-sess, "
       "response=\"cbc1139821ee7192069580570c541a03\", "
       "qop=auth, nc=00000001, cnonce=\"15c07961ed8575c4\""
     }
   };
-  GURL origin("http://www.example.com");
+  url::Origin origin("http://www.example.com");
   scoped_ptr<HttpAuthHandlerDigest::Factory> factory(
       new HttpAuthHandlerDigest::Factory());
   for (size_t i = 0; i < arraysize(tests); ++i) {
     scoped_ptr<HttpAuthHandler> handler;
     int rv = factory->CreateAuthHandlerFromString(tests[i].challenge,
                                                   HttpAuth::AUTH_SERVER,
                                                   origin,
                                                   BoundNetLog(),
                                                   &handler);
     EXPECT_EQ(OK, rv);
@@ skipping 13 matching lines @@
     EXPECT_STREQ(tests[i].expected_creds, creds.c_str());
   }
 }
 
 TEST(HttpAuthHandlerDigest, HandleAnotherChallenge) {
   scoped_ptr<HttpAuthHandlerDigest::Factory> factory(
       new HttpAuthHandlerDigest::Factory());
   scoped_ptr<HttpAuthHandler> handler;
   std::string default_challenge =
       "Digest realm=\"Oblivion\", nonce=\"nonce-value\"";
-  GURL origin("intranet.google.com");
+  url::Origin origin("http://intranet.google.com");
   int rv = factory->CreateAuthHandlerFromString(
       default_challenge, HttpAuth::AUTH_SERVER, origin, BoundNetLog(),
       &handler);
   EXPECT_EQ(OK, rv);
   ASSERT_TRUE(handler.get() != NULL);
   HttpAuthChallengeTokenizer tok_default(default_challenge.begin(),
                                          default_challenge.end());
   EXPECT_EQ(HttpAuth::AUTHORIZATION_RESULT_REJECT,
             handler->HandleAnotherChallenge(&tok_default));
 
@@ skipping 128 matching lines @@
   EXPECT_EQ("Digest username=\"foo\", realm=\"Oblivion\", "
             "nonce=\"nonce-value\", uri=\"/path/to/resource\", "
             "response=\"5b1459beda5cee30d6ff9e970a69c0ea\", "
             "opaque=\"opaque text\", "
             "qop=auth, nc=00000001, cnonce=\"client_nonce\"",
             auth_token);
 }
 
 
 } // namespace net