Revert CLs landed in HttpStreamFactoryImpl to track down a crasher

net/http/http_network_transaction_unittest.cc

 // Copyright 2013 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_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <stdint.h>
 
@@ skipping 54 matching lines @@
 #include "net/log/net_log.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_source.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/log/test_net_log_util.h"
 #include "net/proxy/mock_proxy_resolver.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver.h"
-#include "net/proxy/proxy_resolver_factory.h"
 #include "net/proxy/proxy_server.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_pool.h"
 #include "net/socket/client_socket_pool_manager.h"
 #include "net/socket/connection_attempts.h"
 #include "net/socket/mock_client_socket_pool_manager.h"
 #include "net/socket/next_proto.h"
 #include "net/socket/socket_test_util.h"
 #include "net/socket/ssl_client_socket.h"
@@ skipping 286 matching lines @@
   std::unique_ptr<TestNetworkStreamThrottler> owned_throttler(
       new TestNetworkStreamThrottler);
   *throttler = owned_throttler.get();
 
   HttpNetworkSessionPeer peer(session.get());
   peer.SetNetworkStreamThrottler(std::move(owned_throttler));
 
   return session;
 }
 
-class FailingProxyResolverFactory : public ProxyResolverFactory {
- public:
-  FailingProxyResolverFactory() : ProxyResolverFactory(false) {}
-
-  // ProxyResolverFactory override.
-  int CreateProxyResolver(
-      const scoped_refptr<ProxyResolverScriptData>& script_data,
-      std::unique_ptr<ProxyResolver>* result,
-      const CompletionCallback& callback,
-      std::unique_ptr<Request>* request) override {
-    return ERR_PAC_SCRIPT_FAILED;
-  }
-};
-
 }  // namespace
 
 class HttpNetworkTransactionTest : public PlatformTest {
  public:
   ~HttpNetworkTransactionTest() override {
     // Important to restore the per-pool limit first, since the pool limit must
     // always be greater than group limit, and the tests reduce both limits.
     ClientSocketPoolManager::set_max_sockets_per_pool(
         HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_pool_sockets_);
     ClientSocketPoolManager::set_max_sockets_per_group(
@@ skipping 14811 matching lines @@
  public:
   FakeStreamFactory() {}
   ~FakeStreamFactory() override {}
 
   // Returns a WeakPtr<> to the last HttpStreamRequest returned by
   // RequestStream() (which may be NULL if it was destroyed already).
   base::WeakPtr<FakeStreamRequest> last_stream_request() {
     return last_stream_request_;
   }
 
-  std::unique_ptr<HttpStreamRequest> RequestStream(
+  HttpStreamRequest* RequestStream(const HttpRequestInfo& info,
+                                   RequestPriority priority,
+                                   const SSLConfig& server_ssl_config,
+                                   const SSLConfig& proxy_ssl_config,
+                                   HttpStreamRequest::Delegate* delegate,
+                                   bool enable_ip_based_pooling,
+                                   bool enable_alternative_services,
+                                   const NetLogWithSource& net_log) override {
+    FakeStreamRequest* fake_request = new FakeStreamRequest(priority, delegate);
+    last_stream_request_ = fake_request->AsWeakPtr();
+    return fake_request;
+  }
+
+  HttpStreamRequest* RequestBidirectionalStreamImpl(
       const HttpRequestInfo& info,
       RequestPriority priority,
       const SSLConfig& server_ssl_config,
-      const SSLConfig& proxy_ssl_config,
-      HttpStreamRequest::Delegate* delegate,
-      bool enable_ip_based_pooling,
-      bool enable_alternative_services,
-      const NetLogWithSource& net_log) override {
-    auto fake_request = base::MakeUnique<FakeStreamRequest>(priority, delegate);
-    last_stream_request_ = fake_request->AsWeakPtr();
-    return std::move(fake_request);
-  }
-
-  std::unique_ptr<HttpStreamRequest> RequestBidirectionalStreamImpl(
-      const HttpRequestInfo& info,
-      RequestPriority priority,
-      const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HttpStreamRequest::Delegate* delegate,
       bool enable_ip_based_pooling,
       bool enable_alternative_services,
       const NetLogWithSource& net_log) override {
     NOTREACHED();
     return nullptr;
   }
 
-  std::unique_ptr<HttpStreamRequest> RequestWebSocketHandshakeStream(
+  HttpStreamRequest* RequestWebSocketHandshakeStream(
       const HttpRequestInfo& info,
       RequestPriority priority,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HttpStreamRequest::Delegate* delegate,
       WebSocketHandshakeStreamBase::CreateHelper* create_helper,
       bool enable_ip_based_pooling,
       bool enable_alternative_services,
       const NetLogWithSource& net_log) override {
-    auto fake_request =
-        base::MakeUnique<FakeStreamRequest>(priority, delegate, create_helper);
+    FakeStreamRequest* fake_request =
+        new FakeStreamRequest(priority, delegate, create_helper);
     last_stream_request_ = fake_request->AsWeakPtr();
-    return std::move(fake_request);
+    return fake_request;
   }
 
   void PreconnectStreams(int num_streams,
                          const HttpRequestInfo& info) override {
     ADD_FAILURE();
   }
 
   const HostMappingRules* GetHostMappingRules() const override {
     ADD_FAILURE();
     return NULL;
@@ skipping 1592 matching lines @@
 TEST_F(HttpNetworkTransactionTest, MatchContentEncoding3) {
   CheckContentEncodingMatching(&session_deps_, "identity;q=1, *;q=0", "gzip",
                                "", false);
 }
 
 TEST_F(HttpNetworkTransactionTest, MatchContentEncoding4) {
   CheckContentEncodingMatching(&session_deps_, "identity;q=1, *;q=0", "gzip",
                                "www.foo.com/other", true);
 }
 
-TEST_F(HttpNetworkTransactionTest, ProxyResolutionFailsSync) {
-  ProxyConfig proxy_config;
-  proxy_config.set_pac_url(GURL("http://fooproxyurl"));
-  proxy_config.set_pac_mandatory(true);
-  MockAsyncProxyResolver resolver;
-  session_deps_.proxy_service.reset(new ProxyService(
-      base::MakeUnique<ProxyConfigServiceFixed>(proxy_config),
-      base::WrapUnique(new FailingProxyResolverFactory), nullptr));
-
-  HttpRequestInfo request;
-  request.method = "GET";
-  request.url = GURL("http://www.example.org/");
-
-  std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
-  HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
-
-  TestCompletionCallback callback;
-
-  int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
-  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
-  EXPECT_THAT(callback.WaitForResult(),
-              IsError(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED));
-}
-
-TEST_F(HttpNetworkTransactionTest, ProxyResolutionFailsAsync) {
-  ProxyConfig proxy_config;
-  proxy_config.set_pac_url(GURL("http://fooproxyurl"));
-  proxy_config.set_pac_mandatory(true);
-  MockAsyncProxyResolverFactory* proxy_resolver_factory =
-      new MockAsyncProxyResolverFactory(false);
-  MockAsyncProxyResolver resolver;
-  session_deps_.proxy_service.reset(
-      new ProxyService(base::MakeUnique<ProxyConfigServiceFixed>(proxy_config),
-                       base::WrapUnique(proxy_resolver_factory), nullptr));
-  HttpRequestInfo request;
-  request.method = "GET";
-  request.url = GURL("http://www.example.org/");
-
-  std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
-  HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
-
-  TestCompletionCallback callback;
-  int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
-  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
-
-  proxy_resolver_factory->pending_requests()[0]->CompleteNowWithForwarder(
-      ERR_FAILED, &resolver);
-  EXPECT_THAT(callback.WaitForResult(),
-              IsError(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED));
-}
-
-TEST_F(HttpNetworkTransactionTest, NoSupportedProxies) {
-  session_deps_.proxy_service =
-      ProxyService::CreateFixedFromPacResult("QUIC myproxy.org:443");
-  session_deps_.enable_quic = false;
-  std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
-
-  HttpRequestInfo request;
-  request.method = "GET";
-  request.url = GURL("http://www.example.org/");
-
-  TestCompletionCallback callback;
-  HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
-  int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
-  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
-
-  EXPECT_THAT(callback.WaitForResult(), IsError(ERR_NO_SUPPORTED_PROXIES));
-}
-
 }  // namespace net