More net/ reordering.

net/http/http_proxy_client_socket_pool.cc

 // Copyright (c) 2010 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_proxy_client_socket_pool.h"
 
 #include <algorithm>
 
 #include "base/time.h"
 #include "base/values.h"
@@ skipping 87 matching lines @@
     case STATE_HTTP_PROXY_CONNECT_COMPLETE:
     case STATE_SPDY_PROXY_CREATE_STREAM:
     case STATE_SPDY_PROXY_CREATE_STREAM_COMPLETE:
       return LOAD_STATE_ESTABLISHING_PROXY_TUNNEL;
     default:
       NOTREACHED();
       return LOAD_STATE_IDLE;
   }
 }
 
-int HttpProxyConnectJob::ConnectInternal() {
-  if (params_->tcp_params())
-    next_state_ = STATE_TCP_CONNECT;
-  else
-    next_state_ = STATE_SSL_CONNECT;
-  return DoLoop(OK);
+void HttpProxyConnectJob::GetAdditionalErrorState(ClientSocketHandle * handle) {
+  if (error_response_info_.cert_request_info) {
+    handle->set_ssl_error_response_info(error_response_info_);
+    handle->set_is_ssl_error(true);
+  }
 }
 
 void HttpProxyConnectJob::OnIOComplete(int result) {
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING)
     NotifyDelegateOfCompletion(rv);  // Deletes |this|
 }
 
 int HttpProxyConnectJob::DoLoop(int result) {
   DCHECK_NE(next_state_, STATE_NONE);
@@ skipping 117 matching lines @@
   // need to add a predicate to this if statement so we fall through
   // to the else case. (HttpProxyClientSocket currently acts as
   // a "trusted" SPDY proxy).
   if (using_spdy_ && params_->tunnel())
     next_state_ = STATE_SPDY_PROXY_CREATE_STREAM;
   else
     next_state_ = STATE_HTTP_PROXY_CONNECT;
   return result;
 }
 
-void HttpProxyConnectJob::GetAdditionalErrorState(ClientSocketHandle * handle) {
-  if (error_response_info_.cert_request_info) {
-    handle->set_ssl_error_response_info(error_response_info_);
-    handle->set_is_ssl_error(true);
+int HttpProxyConnectJob::DoHttpProxyConnect() {
+  next_state_ = STATE_HTTP_PROXY_CONNECT_COMPLETE;
+  const HostResolver::RequestInfo& tcp_destination = params_->destination();
+  const HostPortPair& proxy_server = tcp_destination.host_port_pair();
+
+  // Add a HttpProxy connection on top of the tcp socket.
+  transport_socket_.reset(
+      new HttpProxyClientSocket(transport_socket_handle_.release(),
+                                params_->request_url(),
+                                params_->user_agent(),
+                                params_->endpoint(),
+                                proxy_server,
+                                params_->http_auth_cache(),
+                                params_->http_auth_handler_factory(),
+                                params_->tunnel(),
+                                using_spdy_,
+                                params_->ssl_params() != NULL));
+  return transport_socket_->Connect(&callback_);
+}
+
+int HttpProxyConnectJob::DoHttpProxyConnectComplete(int result) {
+  if (result == OK || result == ERR_PROXY_AUTH_REQUESTED ||
+      result == ERR_HTTPS_PROXY_TUNNEL_RESPONSE) {
+      set_socket(transport_socket_.release());
   }
+
+  return result;
 }
 
 int HttpProxyConnectJob::DoSpdyProxyCreateStream() {
   DCHECK(using_spdy_);
   DCHECK(params_->tunnel());
 
   HostPortProxyPair pair(params_->destination().host_port_pair(),
                          ProxyServer::Direct());
   SpdySessionPool* spdy_pool = params_->spdy_session_pool();
   scoped_refptr<SpdySession> spdy_session;
@@ skipping 30 matching lines @@
       new SpdyProxyClientSocket(spdy_stream_,
                                 params_->user_agent(),
                                 params_->endpoint(),
                                 params_->request_url(),
                                 params_->destination().host_port_pair(),
                                 params_->http_auth_cache(),
                                 params_->http_auth_handler_factory()));
   return transport_socket_->Connect(&callback_);
 }
 
-int HttpProxyConnectJob::DoHttpProxyConnect() {
-  next_state_ = STATE_HTTP_PROXY_CONNECT_COMPLETE;
-  const HostResolver::RequestInfo& tcp_destination = params_->destination();
-  const HostPortPair& proxy_server = tcp_destination.host_port_pair();
-
-  // Add a HttpProxy connection on top of the tcp socket.
-  transport_socket_.reset(
-      new HttpProxyClientSocket(transport_socket_handle_.release(),
-                                params_->request_url(),
-                                params_->user_agent(),
-                                params_->endpoint(),
-                                proxy_server,
-                                params_->http_auth_cache(),
-                                params_->http_auth_handler_factory(),
-                                params_->tunnel(),
-                                using_spdy_,
-                                params_->ssl_params() != NULL));
-  return transport_socket_->Connect(&callback_);
-}
-
-int HttpProxyConnectJob::DoHttpProxyConnectComplete(int result) {
-  if (result == OK || result == ERR_PROXY_AUTH_REQUESTED ||
-      result == ERR_HTTPS_PROXY_TUNNEL_RESPONSE) {
-      set_socket(transport_socket_.release());
-  }
-
-  return result;
+int HttpProxyConnectJob::ConnectInternal() {
+  if (params_->tcp_params())
+    next_state_ = STATE_TCP_CONNECT;
+  else
+    next_state_ = STATE_SSL_CONNECT;
+  return DoLoop(OK);
 }
 
 HttpProxyClientSocketPool::
 HttpProxyConnectJobFactory::HttpProxyConnectJobFactory(
     TCPClientSocketPool* tcp_pool,
     SSLClientSocketPool* ssl_pool,
     HostResolver* host_resolver,
     NetLog* net_log)
     : tcp_pool_(tcp_pool),
       ssl_pool_(ssl_pool),
@@ skipping 120 matching lines @@
 
 base::TimeDelta HttpProxyClientSocketPool::ConnectionTimeout() const {
   return base_.ConnectionTimeout();
 }
 
 ClientSocketPoolHistograms* HttpProxyClientSocketPool::histograms() const {
   return base_.histograms();
 }
 
 }  // namespace net