DO NOT LAND

net/http/http_auth_handler.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_AUTH_HANDLER_H_
 #define NET_HTTP_HTTP_AUTH_HANDLER_H_
 
 #include <string>
 
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
 #include "net/http/http_auth.h"
 #include "net/log/net_log.h"
+#include "url/origin.h"
 
 namespace net {
 
 class HttpAuthChallengeTokenizer;
 struct HttpRequestInfo;
 
 // HttpAuthHandler is the interface for the authentication schemes
 // (basic, digest, NTLM, Negotiate).
 // HttpAuthHandler objects are typically created by an HttpAuthHandlerFactory.
 class NET_EXPORT_PRIVATE HttpAuthHandler {
  public:
   HttpAuthHandler();
   virtual ~HttpAuthHandler();
 
   // Initializes the handler using a challenge issued by a server.
   // |challenge| must be non-NULL and have already tokenized the
   // authentication scheme, but none of the tokens occurring after the
   // authentication scheme. |target| and |origin| are both stored
   // for later use, and are not part of the initial challenge.
   bool InitFromChallenge(HttpAuthChallengeTokenizer* challenge,
                          HttpAuth::Target target,
-                         const GURL& origin,
+                         const url::Origin& origin,
                          const BoundNetLog& net_log);
 
   // Determines how the previous authorization attempt was received.
   //
   // This is called when the server/proxy responds with a 401/407 after an
   // earlier authorization attempt. Although this normally means that the
   // previous attempt was rejected, in multi-round schemes such as
   // NTLM+Negotiate it may indicate that another round of challenge+response
   // is required. For Digest authentication it may also mean that the previous
   // attempt used a stale nonce (and nonce-count) and that a new attempt should
@@ skipping 49 matching lines @@
     return score_;
   }
 
   HttpAuth::Target target() const {
     return target_;
   }
 
   // Returns the proxy or server which issued the authentication challenge
   // that this HttpAuthHandler is handling. The URL includes scheme, host, and
   // port, but does not include path.
-  const GURL& origin() const {
-    return origin_;
-  }
+  const url::Origin& origin() const { return origin_; }
 
   // Returns true if the authentication scheme does not send the username and
   // password in the clear.
   bool encrypts_identity() const {
     return (properties_ & ENCRYPTS_IDENTITY) != 0;
   }
 
   // Returns true if the authentication scheme is connection-based, for
   // example, NTLM.  A connection-based authentication scheme does not support
   // preemptive authentication, and must use the same handler object
@@ skipping 46 matching lines @@
   HttpAuth::Scheme auth_scheme_;
 
   // The realm, encoded as UTF-8. Used by "basic" and "digest".
   std::string realm_;
 
   // The auth challenge.
   std::string auth_challenge_;
 
   // The {scheme, host, port} for the authentication target.  Used by "ntlm"
   // and "negotiate" to construct the service principal name.
-  GURL origin_;
+  url::Origin origin_;
 
   // The score for this challenge. Higher numbers are better.
   int score_;
 
   // Whether this authentication request is for a proxy server, or an
   // origin server.
   HttpAuth::Target target_;
 
   // A bitmask of the properties of the authentication scheme.
   int properties_;
 
   BoundNetLog net_log_;
 
  private:
   void OnGenerateAuthTokenComplete(int rv);
   void FinishGenerateAuthToken();
 
   CompletionCallback callback_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_AUTH_HANDLER_H_