More net/ method ordering.

net/http/http_network_layer.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_network_layer.h"
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_transaction.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 
 namespace net {
 
 //-----------------------------------------------------------------------------
 
-// static
-HttpTransactionFactory* HttpNetworkLayer::CreateFactory(
-    HostResolver* host_resolver,
-    CertVerifier* cert_verifier,
-    DnsRRResolver* dnsrr_resolver,
-    DnsCertProvenanceChecker* dns_cert_checker,
-    SSLHostInfoFactory* ssl_host_info_factory,
-    ProxyService* proxy_service,
-    SSLConfigService* ssl_config_service,
-    HttpAuthHandlerFactory* http_auth_handler_factory,
-    HttpNetworkDelegate* network_delegate,
-    NetLog* net_log) {
-  DCHECK(proxy_service);
-
-  return new HttpNetworkLayer(ClientSocketFactory::GetDefaultFactory(),
-                              host_resolver, cert_verifier, dnsrr_resolver,
-                              dns_cert_checker,
-                              ssl_host_info_factory, proxy_service,
-                              ssl_config_service, http_auth_handler_factory,
-                              network_delegate,
-                              net_log);
-}
-
-// static
-HttpTransactionFactory* HttpNetworkLayer::CreateFactory(
-    HttpNetworkSession* session) {
-  DCHECK(session);
-
-  return new HttpNetworkLayer(session);
-}
-
-//-----------------------------------------------------------------------------
 HttpNetworkLayer::HttpNetworkLayer(
     ClientSocketFactory* socket_factory,
     HostResolver* host_resolver,
     CertVerifier* cert_verifier,
     DnsRRResolver* dnsrr_resolver,
     DnsCertProvenanceChecker* dns_cert_checker,
     SSLHostInfoFactory* ssl_host_info_factory,
     ProxyService* proxy_service,
     SSLConfigService* ssl_config_service,
     HttpAuthHandlerFactory* http_auth_handler_factory,
@@ skipping 61 matching lines @@
       http_auth_handler_factory_(NULL),
       network_delegate_(NULL),
       net_log_(NULL),
       suspended_(false) {
   DCHECK(session_.get());
 }
 
 HttpNetworkLayer::~HttpNetworkLayer() {
 }
 
-int HttpNetworkLayer::CreateTransaction(scoped_ptr<HttpTransaction>* trans) {
-  if (suspended_)
-    return ERR_NETWORK_IO_SUSPENDED;
+//-----------------------------------------------------------------------------
 
-  trans->reset(new HttpNetworkTransaction(GetSession()));
-  return OK;
-}
+// static
+HttpTransactionFactory* HttpNetworkLayer::CreateFactory(
+    HostResolver* host_resolver,
+    CertVerifier* cert_verifier,
+    DnsRRResolver* dnsrr_resolver,
+    DnsCertProvenanceChecker* dns_cert_checker,
+    SSLHostInfoFactory* ssl_host_info_factory,
+    ProxyService* proxy_service,
+    SSLConfigService* ssl_config_service,
+    HttpAuthHandlerFactory* http_auth_handler_factory,
+    HttpNetworkDelegate* network_delegate,
+    NetLog* net_log) {
+  DCHECK(proxy_service);
 
-HttpCache* HttpNetworkLayer::GetCache() {
-  return NULL;
-}
-
-void HttpNetworkLayer::Suspend(bool suspend) {
-  suspended_ = suspend;
-
-  if (suspend && session_)
-    session_->tcp_socket_pool()->CloseIdleSockets();
-}
-
-HttpNetworkSession* HttpNetworkLayer::GetSession() {
-  if (!session_) {
-    DCHECK(proxy_service_);
-    if (!spdy_session_pool_.get())
-      spdy_session_pool_.reset(new SpdySessionPool(ssl_config_service_));
-    session_ = new HttpNetworkSession(
-        host_resolver_,
-        cert_verifier_,
-        dnsrr_resolver_,
-        dns_cert_checker_,
-        ssl_host_info_factory_,
-        proxy_service_,
-        socket_factory_,
-        ssl_config_service_,
-        spdy_session_pool_.release(),
-        http_auth_handler_factory_,
-        network_delegate_,
-        net_log_);
-    // These were just temps for lazy-initializing HttpNetworkSession.
-    host_resolver_ = NULL;
-    cert_verifier_ = NULL;
-    dnsrr_resolver_ = NULL;
-    dns_cert_checker_ = NULL;
-    ssl_host_info_factory_ = NULL;
-    proxy_service_ = NULL;
-    socket_factory_ = NULL;
-    http_auth_handler_factory_ = NULL;
-    net_log_ = NULL;
-    network_delegate_ = NULL;
-  }
-  return session_;
+  return new HttpNetworkLayer(ClientSocketFactory::GetDefaultFactory(),
+                              host_resolver, cert_verifier, dnsrr_resolver,
+                              dns_cert_checker,
+                              ssl_host_info_factory, proxy_service,
+                              ssl_config_service, http_auth_handler_factory,
+                              network_delegate,
+                              net_log);
 }
 
 // static
+HttpTransactionFactory* HttpNetworkLayer::CreateFactory(
+    HttpNetworkSession* session) {
+  DCHECK(session);
+
+  return new HttpNetworkLayer(session);
+}
+
+// static
 void HttpNetworkLayer::EnableSpdy(const std::string& mode) {
   static const char kOff[] = "off";
   static const char kSSL[] = "ssl";
   static const char kDisableSSL[] = "no-ssl";
   static const char kExclude[] = "exclude";  // Hosts to exclude
   static const char kDisableCompression[] = "no-compress";
   static const char kDisableAltProtocols[] = "no-alt-protocols";
   static const char kEnableVersionOne[] = "v1";
   static const char kForceAltProtocols[] = "force-alt-protocols";
 
@@ skipping 72 matching lines @@
       pair.port = 443;
       pair.protocol = HttpAlternateProtocols::NPN_SPDY_2;
       HttpAlternateProtocols::ForceAlternateProtocol(pair);
     } else if (option.empty() && it == spdy_options.begin()) {
       continue;
     } else {
       LOG(DFATAL) << "Unrecognized spdy option: " << option;
     }
   }
 }
+
+//-----------------------------------------------------------------------------
+
+int HttpNetworkLayer::CreateTransaction(scoped_ptr<HttpTransaction>* trans) {
+  if (suspended_)
+    return ERR_NETWORK_IO_SUSPENDED;
+
+  trans->reset(new HttpNetworkTransaction(GetSession()));
+  return OK;
+}
+
+HttpCache* HttpNetworkLayer::GetCache() {
+  return NULL;
+}
+
+HttpNetworkSession* HttpNetworkLayer::GetSession() {
+  if (!session_) {
+    DCHECK(proxy_service_);
+    if (!spdy_session_pool_.get())
+      spdy_session_pool_.reset(new SpdySessionPool(ssl_config_service_));
+    session_ = new HttpNetworkSession(
+        host_resolver_,
+        cert_verifier_,
+        dnsrr_resolver_,
+        dns_cert_checker_,
+        ssl_host_info_factory_,
+        proxy_service_,
+        socket_factory_,
+        ssl_config_service_,
+        spdy_session_pool_.release(),
+        http_auth_handler_factory_,
+        network_delegate_,
+        net_log_);
+    // These were just temps for lazy-initializing HttpNetworkSession.
+    host_resolver_ = NULL;
+    cert_verifier_ = NULL;
+    dnsrr_resolver_ = NULL;
+    dns_cert_checker_ = NULL;
+    ssl_host_info_factory_ = NULL;
+    proxy_service_ = NULL;
+    socket_factory_ = NULL;
+    http_auth_handler_factory_ = NULL;
+    net_log_ = NULL;
+    network_delegate_ = NULL;
+  }
+  return session_;
+}
+
+void HttpNetworkLayer::Suspend(bool suspend) {
+  suspended_ = suspend;
+
+  if (suspend && session_)
+    session_->tcp_socket_pool()->CloseIdleSockets();
+}
+
 }  // namespace net