DO NOT LAND

net/http/http_auth_handler_negotiate.cc

 // Copyright (c) 2012 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_handler_negotiate.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
@@ skipping 21 matching lines @@
 }
 
 void HttpAuthHandlerNegotiate::Factory::set_host_resolver(
     HostResolver* resolver) {
   resolver_ = resolver;
 }
 
 int HttpAuthHandlerNegotiate::Factory::CreateAuthHandler(
     HttpAuthChallengeTokenizer* challenge,
     HttpAuth::Target target,
-    const GURL& origin,
+    const url::Origin& origin,
     CreateReason reason,
     int digest_nonce_count,
     const BoundNetLog& net_log,
     scoped_ptr<HttpAuthHandler>* handler) {
 #if defined(OS_WIN)
   if (is_unsupported_ || reason == CREATE_PREEMPTIVE)
     return ERR_UNSUPPORTED_AUTH_SCHEME;
   if (max_token_length_ == 0) {
     int rv = DetermineMaxTokenLength(auth_library_.get(), NEGOSSP_NAME,
                                      &max_token_length_);
@@ skipping 52 matching lines @@
       already_called_(false),
       has_credentials_(false),
       auth_token_(NULL),
       next_state_(STATE_NONE),
       url_security_manager_(url_security_manager) {
 }
 
 HttpAuthHandlerNegotiate::~HttpAuthHandlerNegotiate() {
 }
 
-std::string HttpAuthHandlerNegotiate::CreateSPN(
-    const AddressList& address_list, const GURL& origin) {
+std::string HttpAuthHandlerNegotiate::CreateSPN(const AddressList& address_list,
+                                                const url::Origin& origin) {
   // Kerberos Web Server SPNs are in the form HTTP/<host>:<port> through SSPI,
   // and in the form HTTP@<host>:<port> through GSSAPI
   //   http://msdn.microsoft.com/en-us/library/ms677601%28VS.85%29.aspx
   //
   // However, reality differs from the specification. A good description of
   // the problems can be found here:
   //   http://blog.michelbarneveld.nl/michel/archive/2009/11/14/the-reason-why-kb911149-and-kb908209-are-not-the-soluton.aspx
   //
   // Typically the <host> portion should be the canonical FQDN for the service.
   // If this could not be resolved, the original hostname in the URL will be
   // attempted instead. However, some intranets register SPNs using aliases
   // for the same canonical DNS name to allow multiple web services to reside
   // on the same host machine without requiring different ports. IE6 and IE7
   // have hotpatches that allow the default behavior to be overridden.
   //   http://support.microsoft.com/kb/911149
   //   http://support.microsoft.com/kb/938305
   //
   // According to the spec, the <port> option should be included if it is a
   // non-standard port (i.e. not 80 or 443 in the HTTP case). However,
   // historically browsers have not included the port, even on non-standard
   // ports. IE6 required a hotpatch and a registry setting to enable
   // including non-standard ports, and IE7 and IE8 also require the same
   // registry setting, but no hotpatch. Firefox does not appear to have an
   // option to include non-standard ports as of 3.6.
   //   http://support.microsoft.com/kb/908209
   //
   // Without any command-line flags, Chrome matches the behavior of Firefox
   // and IE. Users can override the behavior so aliases are allowed and
   // non-standard ports are included.
-  int port = origin.EffectiveIntPort();
+  int port = origin.port();
   std::string server = address_list.canonical_name();
   if (server.empty())
     server = origin.host();
 #if defined(OS_WIN)
   static const char kSpnSeparator = '/';
 #elif defined(OS_POSIX)
   static const char kSpnSeparator = '@';
 #endif
   if (port != 80 && port != 443 && use_port_) {
     return base::StringPrintf("HTTP%c%s:%d", kSpnSeparator, server.c_str(),
@@ skipping 171 matching lines @@
 bool HttpAuthHandlerNegotiate::CanDelegate() const {
   // TODO(cbentzel): Should delegation be allowed on proxies?
   if (target_ == HttpAuth::AUTH_PROXY)
     return false;
   if (!url_security_manager_)
     return false;
   return url_security_manager_->CanDelegate(origin_);
 }
 
 }  // namespace net