Use HttpAuthController in SocketStream

net/socket_stream/socket_stream.h

 // 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.
 
 #ifndef NET_SOCKET_STREAM_SOCKET_STREAM_H_
 #define NET_SOCKET_STREAM_SOCKET_STREAM_H_
 
 #include <deque>
 #include <map>
 #include <string>
 
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_config_service.h"
 #include "net/http/http_auth.h"

[cbentzel, 2012/08/15 18:08:01]

The net/http/http_auth*.h includes look like they are no longer needed.

[bashi, 2012/08/20 01:35:10]

Done.

 #include "net/http/http_auth_cache.h"
 #include "net/http/http_auth_handler.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 
 namespace net {
 
 class AuthChallengeInfo;
 class ClientSocketFactory;
 class CookieOptions;
 class HostResolver;
+class HttpAuthController;
 class HttpAuthHandlerFactory;

[cbentzel, 2012/08/15 18:08:01]

You no longer need to forward declare HttpAuthController.

[bashi, 2012/08/20 01:35:10]

HttpAuthHandlerFactory? Removed.

 class SSLConfigService;
 class SSLInfo;
 class SingleRequestHostResolver;
 class SocketStreamMetrics;
 
 // SocketStream is used to implement Web Sockets.
 // It provides plain full-duplex stream with proxy and SSL support.
 // For proxy authentication, only basic mechanisum is supported.  It will try
 // authentication identity for proxy URL first.  If server requires proxy
 // authentication, it will try authentication identity for realm that server
@@ skipping 176 matching lines @@
     STATE_BEFORE_CONNECT,
     STATE_BEFORE_CONNECT_COMPLETE,
     STATE_RESOLVE_PROXY,
     STATE_RESOLVE_PROXY_COMPLETE,
     STATE_RESOLVE_HOST,
     STATE_RESOLVE_HOST_COMPLETE,
     STATE_RESOLVE_PROTOCOL,
     STATE_RESOLVE_PROTOCOL_COMPLETE,
     STATE_TCP_CONNECT,
     STATE_TCP_CONNECT_COMPLETE,
+    STATE_GENERATE_PROXY_AUTH_TOKEN,
+    STATE_GENERATE_PROXY_AUTH_TOKEN_COMPLETE,
     STATE_WRITE_TUNNEL_HEADERS,
     STATE_WRITE_TUNNEL_HEADERS_COMPLETE,
     STATE_READ_TUNNEL_HEADERS,
     STATE_READ_TUNNEL_HEADERS_COMPLETE,
     STATE_SOCKS_CONNECT,
     STATE_SOCKS_CONNECT_COMPLETE,
     STATE_SECURE_PROXY_CONNECT,
     STATE_SECURE_PROXY_CONNECT_COMPLETE,
     STATE_SECURE_PROXY_HANDLE_CERT_ERROR,
     STATE_SECURE_PROXY_HANDLE_CERT_ERROR_COMPLETE,
@@ skipping 38 matching lines @@
   int DoBeforeConnect();
   int DoBeforeConnectComplete(int result);
   int DoResolveProxy();
   int DoResolveProxyComplete(int result);
   int DoResolveHost();
   int DoResolveHostComplete(int result);
   int DoResolveProtocol(int result);
   int DoResolveProtocolComplete(int result);
   int DoTcpConnect(int result);
   int DoTcpConnectComplete(int result);
+  int DoGenerateProxyAuthToken();
+  int DoGenerateProxyAuthTokenComplete(int result);
   int DoWriteTunnelHeaders();
   int DoWriteTunnelHeadersComplete(int result);
   int DoReadTunnelHeaders();
   int DoReadTunnelHeadersComplete(int result);
   int DoSOCKSConnect();
   int DoSOCKSConnectComplete(int result);
   int DoSecureProxyConnect();
   int DoSecureProxyConnectComplete(int result);
   int DoSecureProxyHandleCertError(int result);
   int DoSecureProxyHandleCertErrorComplete(int result);
   int DoSSLConnect();
   int DoSSLConnectComplete(int result);
   int DoSSLHandleCertError(int result);
   int DoSSLHandleCertErrorComplete(int result);
   int DoReadWrite(int result);
 
   GURL ProxyAuthOrigin() const;
   int HandleAuthChallenge(const HttpResponseHeaders* headers);
   int HandleCertificateRequest(int result, SSLConfig* ssl_config);
   void DoAuthRequired();
   void DoRestartWithAuth();
 
   int HandleCertificateError(int result);
   int AllowCertErrorForReconnection(SSLConfig* ssl_config);
 
+  bool ShouldApplyProxyAuth() const;
+
   SSLConfigService* ssl_config_service() const;
   ProxyService* proxy_service() const;
 
   BoundNetLog net_log_;
 
   GURL url_;
   int max_pending_send_allowed_;
   const URLRequestContext* context_;
 
   UserDataMap user_data_;
 
   State next_state_;
   HostResolver* host_resolver_;
   CertVerifier* cert_verifier_;
   ServerBoundCertService* server_bound_cert_service_;
-  HttpAuthHandlerFactory* http_auth_handler_factory_;
   ClientSocketFactory* factory_;
 
   ProxyMode proxy_mode_;
 
   GURL proxy_url_;
   ProxyService::PacRequest* pac_request_;
   ProxyInfo proxy_info_;
 
-  HttpAuthCache auth_cache_;
-  scoped_ptr<HttpAuthHandler> auth_handler_;
-  HttpAuth::Identity auth_identity_;
-  scoped_refptr<AuthChallengeInfo> auth_info_;
+  scoped_refptr<HttpAuthController> proxy_auth_controller_;
 
   scoped_refptr<RequestHeaders> tunnel_request_headers_;
   size_t tunnel_request_headers_bytes_sent_;
   scoped_refptr<ResponseHeaders> tunnel_response_headers_;
   int tunnel_response_headers_capacity_;
   int tunnel_response_headers_len_;
 
   scoped_ptr<SingleRequestHostResolver> resolver_;
   AddressList addresses_;
   scoped_ptr<StreamSocket> socket_;
@@ skipping 22 matching lines @@
   bool server_closed_;
 
   scoped_ptr<SocketStreamMetrics> metrics_;
 
   DISALLOW_COPY_AND_ASSIGN(SocketStream);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_STREAM_SOCKET_STREAM_H_