No longer preconnect to unsafe ports.

net/http/http_stream_factory_impl_unittest.cc

 // 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.
 
 #include "net/http/http_stream_factory_impl.h"
 
 #include <string>
 
 #include "base/basictypes.h"
-#include "net/base/capturing_net_log.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_log.h"
 #include "net/base/ssl_config_service_defaults.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_session_peer.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_server_properties_impl.h"
@@ skipping 21 matching lines @@
   void WaitForPreconnects() {
     while (!preconnect_done_) {
       waiting_for_preconnect_ = true;
       MessageLoop::current()->Run();
       waiting_for_preconnect_ = false;
     }
   }
 
  private:
   // HttpStreamFactoryImpl methods.
-  virtual void OnPreconnectsCompleteInternal() {
+  virtual void OnPreconnectsCompleteInternal() OVERRIDE {
     preconnect_done_ = true;
     if (waiting_for_preconnect_)
       MessageLoop::current()->Quit();
   }
 
   bool preconnect_done_;
   bool waiting_for_preconnect_;
 };
 
 class StreamRequestWaiter : public HttpStreamRequest::Delegate {
@@ skipping 92 matching lines @@
   bool ssl;
 };
 
 TestCase kTests[] = {
   { 1, false },
   { 2, false },
   { 1, true},
   { 2, true},
 };
 
-void PreconnectHelper(const TestCase& test,
-                      HttpNetworkSession* session) {
+void PreconnectHelperForURL(int num_streams,
+                            const GURL& url,
+                            HttpNetworkSession* session) {
   HttpNetworkSessionPeer peer(session);
   MockHttpStreamFactoryImpl* mock_factory =
       new MockHttpStreamFactoryImpl(session);
   peer.SetHttpStreamFactory(mock_factory);
   SSLConfig ssl_config;
   session->ssl_config_service()->GetSSLConfig(&ssl_config);
 
   HttpRequestInfo request;
   request.method = "GET";
-  request.url = test.ssl ?  GURL("https://www.google.com") :
-      GURL("http://www.google.com");
+  request.url = url;
   request.load_flags = 0;
 
-  ProxyInfo proxy_info;
-  TestOldCompletionCallback callback;
+  session->http_stream_factory()->PreconnectStreams(
+      num_streams, request, ssl_config, ssl_config, BoundNetLog());
+  mock_factory->WaitForPreconnects();
+};
 
-  session->http_stream_factory()->PreconnectStreams(
-      test.num_streams, request, ssl_config, ssl_config, BoundNetLog());
-  mock_factory->WaitForPreconnects();
+void PreconnectHelper(const TestCase& test,
+                      HttpNetworkSession* session) {
+  GURL url = test.ssl ? GURL("https://www.google.com") :
+      GURL("http://www.google.com");
+  PreconnectHelperForURL(test.num_streams, url, session);
 };
 
 template<typename ParentPool>
 class CapturePreconnectsSocketPool : public ParentPool {
  public:
   CapturePreconnectsSocketPool(HostResolver* host_resolver,
                                CertVerifier* cert_verifier);
 
   int last_num_streams() const {
     return last_num_streams_;
   }
 
   virtual int RequestSocket(const std::string& group_name,
                             const void* socket_params,
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             OldCompletionCallback* callback,
-                            const BoundNetLog& net_log) {
+                            const BoundNetLog& net_log) OVERRIDE {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
 
   virtual void RequestSockets(const std::string& group_name,
                               const void* socket_params,
                               int num_sockets,
-                              const BoundNetLog& net_log) {
+                              const BoundNetLog& net_log) OVERRIDE {
     last_num_streams_ = num_sockets;
   }
 
   virtual void CancelRequest(const std::string& group_name,
-                             ClientSocketHandle* handle) {
+                             ClientSocketHandle* handle) OVERRIDE {
     ADD_FAILURE();
   }
   virtual void ReleaseSocket(const std::string& group_name,
                              StreamSocket* socket,
-                             int id) {
+                             int id) OVERRIDE {
     ADD_FAILURE();
   }
-  virtual void CloseIdleSockets() {
+  virtual void CloseIdleSockets() OVERRIDE {
     ADD_FAILURE();
   }
-  virtual int IdleSocketCount() const {
+  virtual int IdleSocketCount() const OVERRIDE {
     ADD_FAILURE();
     return 0;
   }
-  virtual int IdleSocketCountInGroup(const std::string& group_name) const {
+  virtual int IdleSocketCountInGroup(
+      const std::string& group_name) const OVERRIDE {
     ADD_FAILURE();
     return 0;
   }
-  virtual LoadState GetLoadState(const std::string& group_name,
-                                 const ClientSocketHandle* handle) const {
+  virtual LoadState GetLoadState(
+      const std::string& group_name,
+      const ClientSocketHandle* handle) const OVERRIDE {
     ADD_FAILURE();
     return LOAD_STATE_IDLE;
   }
-  virtual base::TimeDelta ConnectionTimeout() const {
+  virtual base::TimeDelta ConnectionTimeout() const OVERRIDE {
     return base::TimeDelta();
   }
 
  private:
   int last_num_streams_;
 };
 
 typedef CapturePreconnectsSocketPool<TransportClientSocketPool>
 CapturePreconnectsTransportSocketPool;
 typedef CapturePreconnectsSocketPool<HttpProxyClientSocketPool>
@@ skipping 131 matching lines @@
     PreconnectHelper(kTests[i], session);
     // We shouldn't be preconnecting if we have an existing session, which is
     // the case for https://www.google.com.
     if (kTests[i].ssl)
       EXPECT_EQ(-1, ssl_conn_pool->last_num_streams());
     else
       EXPECT_EQ(kTests[i].num_streams, transport_conn_pool->last_num_streams());
   }
 }
 
+// Verify that preconnects to unsafe ports are cancelled before they reach
+// the SocketPool.
+TEST(HttpStreamFactoryTest, PreconnectUnsafePort) {
+  ASSERT_FALSE(IsPortAllowedByDefault(7));
+  ASSERT_FALSE(IsPortAllowedByOverride(7));
+
+  SessionDependencies session_deps(ProxyService::CreateDirect());
+  scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
+  HttpNetworkSessionPeer peer(session);
+  CapturePreconnectsTransportSocketPool* transport_conn_pool =
+      new CapturePreconnectsTransportSocketPool(
+          session_deps.host_resolver.get(),
+          session_deps.cert_verifier.get());
+  MockClientSocketPoolManager* mock_pool_manager =
+      new MockClientSocketPoolManager;
+  mock_pool_manager->SetTransportSocketPool(transport_conn_pool);
+  peer.SetClientSocketPoolManager(mock_pool_manager);
+
+  PreconnectHelperForURL(1, GURL("http://www.google.com:7"), session);
+
+  EXPECT_EQ(-1, transport_conn_pool->last_num_streams());
+}
+
 TEST(HttpStreamFactoryTest, JobNotifiesProxy) {
   const char* kProxyString = "PROXY bad:99; PROXY maybe:80; DIRECT";
   SessionDependencies session_deps(
       ProxyService::CreateFixedFromPacResult(kProxyString));
 
   // First connection attempt fails
   StaticSocketDataProvider socket_data1;
   socket_data1.set_connect_data(MockConnect(true, ERR_ADDRESS_UNREACHABLE));
   session_deps.socket_factory.AddSocketDataProvider(&socket_data1);
 
   // Second connection attempt succeeds
   StaticSocketDataProvider socket_data2;
   socket_data2.set_connect_data(MockConnect(true, OK));
   session_deps.socket_factory.AddSocketDataProvider(&socket_data2);
 
-  CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
-  EXPECT_TRUE(log.bound().IsLoggingAllEvents());
-
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   // Now request a stream.  It should succeed using the second proxy in the
   // list.
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://www.google.com");
   request_info.load_flags = 0;
 
   SSLConfig ssl_config;
   StreamRequestWaiter waiter;
   scoped_ptr<HttpStreamRequest> request(
       session->http_stream_factory()->RequestStream(request_info, ssl_config,
                                                     ssl_config, &waiter,
-                                                    log.bound()));
+                                                    BoundNetLog()));
   waiter.WaitForStream();
 
   // The proxy that failed should now be known to the proxy_service as bad.
   const ProxyRetryInfoMap& retry_info =
       session->proxy_service()->proxy_retry_info();
   EXPECT_EQ(1u, retry_info.size());
   ProxyRetryInfoMap::const_iterator iter = retry_info.find("bad:99");
   EXPECT_TRUE(iter != retry_info.end());
 }
 
 }  // namespace
 
 }  // namespace net