Unwind the SSL connection holdback experiment and remove related code

net/socket/socket_test_util.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_SOCKET_TEST_UTIL_H_
 #define NET_SOCKET_SOCKET_TEST_UTIL_H_
 
 #include <cstring>
 #include <deque>
 #include <string>
@@ skipping 318 matching lines @@
   std::string next_proto;
   bool was_npn_negotiated;
   NextProto protocol_negotiated;
   NextProtoVector next_protos_expected_in_ssl_config;
   bool client_cert_sent;
   SSLCertRequestInfo* cert_request_info;
   scoped_refptr<X509Certificate> cert;
   bool channel_id_sent;
   ChannelIDService* channel_id_service;
   int connection_status;
-  // Indicates that the socket should pause in the Connect method.
-  bool should_pause_on_connect;
-  // Whether or not the Socket should behave like there is a pre-existing
-  // session to resume. Whether or not such a session is reported as
-  // resumed is controlled by |connection_status|.
-  bool is_in_session_cache;
 };
 
 // A DataProvider where the client must write a request before the reads (e.g.
 // the response) will complete.
 class DelayedSocketData : public StaticSocketDataProvider {
  public:
   // |write_delay| the number of MockWrites to complete before allowing
   //               a MockRead to complete.
   // |reads| the list of MockRead completions.
   // |writes| the list of MockWrite completions.
@@ skipping 283 matching lines @@
   ~MockClientSocketFactory() override;
 
   void AddSocketDataProvider(SocketDataProvider* socket);
   void AddSSLSocketDataProvider(SSLSocketDataProvider* socket);
   void ResetNextMockIndexes();
 
   SocketDataProviderArray<SocketDataProvider>& mock_data() {
     return mock_data_;
   }
 
-  // Note: this method is unsafe; the elements of the returned vector
-  // are not necessarily valid.
-  const std::vector<MockSSLClientSocket*>& ssl_client_sockets() const {
-    return ssl_client_sockets_;
-  }
-
   // ClientSocketFactory
   scoped_ptr<DatagramClientSocket> CreateDatagramClientSocket(
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       NetLog* net_log,
       const NetLog::Source& source) override;
   scoped_ptr<StreamSocket> CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
       const NetLog::Source& source) override;
   scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
       scoped_ptr<ClientSocketHandle> transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
       const SSLClientSocketContext& context) override;
   void ClearSSLSessionCache() override;
 
  private:
   SocketDataProviderArray<SocketDataProvider> mock_data_;
   SocketDataProviderArray<SSLSocketDataProvider> mock_ssl_data_;
-  std::vector<MockSSLClientSocket*> ssl_client_sockets_;
 };
 
 class MockClientSocket : public SSLClientSocket {
  public:
   // Value returned by GetTLSUniqueChannelBinding().
   static const char kTlsUnique[];
 
   // The BoundNetLog is needed to test LoadTimingInfo, which uses NetLog IDs as
   // unique socket IDs.
   explicit MockClientSocket(const BoundNetLog& net_log);
@@ skipping 13 matching lines @@
   void Disconnect() override;
   bool IsConnected() const override;
   bool IsConnectedAndIdle() const override;
   int GetPeerAddress(IPEndPoint* address) const override;
   int GetLocalAddress(IPEndPoint* address) const override;
   const BoundNetLog& NetLog() const override;
   void SetSubresourceSpeculation() override {}
   void SetOmniboxSpeculation() override {}
 
   // SSLClientSocket implementation.
-  std::string GetSessionCacheKey() const override;
-  bool InSessionCache() const override;
-  void SetHandshakeCompletionCallback(const base::Closure& cb) override;
   void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override;
   int ExportKeyingMaterial(const base::StringPiece& label,
                            bool has_context,
                            const base::StringPiece& context,
                            unsigned char* out,
                            unsigned int outlen) override;
   int GetTLSUniqueChannelBinding(std::string* out) override;
   NextProtoStatus GetNextProto(std::string* proto) override;
   ChannelIDService* GetChannelIDService() const override;
 
@@ skipping 238 matching lines @@
   int Connect(const CompletionCallback& callback) override;
   void Disconnect() override;
   bool IsConnected() const override;
   bool WasEverUsed() const override;
   bool UsingTCPFastOpen() const override;
   int GetPeerAddress(IPEndPoint* address) const override;
   bool WasNpnNegotiated() const override;
   bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // SSLClientSocket implementation.
-  std::string GetSessionCacheKey() const override;
-  bool InSessionCache() const override;
-  void SetHandshakeCompletionCallback(const base::Closure& cb) override;
   void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override;
   NextProtoStatus GetNextProto(std::string* proto) override;
   bool set_was_npn_negotiated(bool negotiated) override;
   void set_protocol_negotiated(NextProto protocol_negotiated) override;
   NextProto GetNegotiatedProtocol() const override;
 
   // This MockSocket does not implement the manual async IO feature.
   void OnReadComplete(const MockRead& data) override;
   void OnConnectComplete(const MockConnect& data) override;
 
   bool WasChannelIDSent() const override;
   void set_channel_id_sent(bool channel_id_sent) override;
   ChannelIDService* GetChannelIDService() const override;
 
-  bool reached_connect() const { return reached_connect_; }
-
-  // Resumes the connection of a socket that was paused for testing.
-  // |connect_callback_| should be set before invoking this method.
-  void RestartPausedConnect();
-
  private:
-  enum ConnectState {
-    STATE_NONE,
-    STATE_SSL_CONNECT,
-    STATE_SSL_CONNECT_COMPLETE,
-  };
-
-  void OnIOComplete(int result);
-
-  // Runs the state transistion loop.
-  int DoConnectLoop(int result);
-
-  int DoSSLConnect();
-  int DoSSLConnectComplete(int result);
+  static void ConnectCallback(MockSSLClientSocket* ssl_client_socket,
+                              const CompletionCallback& callback,
+                              int rv);
 
   scoped_ptr<ClientSocketHandle> transport_;
-  HostPortPair host_port_pair_;
   SSLSocketDataProvider* data_;
   bool is_npn_state_set_;
   bool new_npn_value_;
   bool is_protocol_negotiated_set_;
   NextProto protocol_negotiated_;
 
-  CompletionCallback connect_callback_;
-  // Indicates what state of Connect the socket should enter.
-  ConnectState next_connect_state_;
-  // True if the Connect method has been called on the socket.
-  bool reached_connect_;
-
-  base::Closure handshake_completion_callback_;
-
-  base::WeakPtrFactory<MockSSLClientSocket> weak_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(MockSSLClientSocket);
 };
 
 class MockUDPClientSocket : public DatagramClientSocket, public AsyncSocket {
  public:
   MockUDPClientSocket(SocketDataProvider* data, net::NetLog* net_log);
   ~MockUDPClientSocket() override;
 
   // Socket implementation.
   int Read(IOBuffer* buf,
@@ skipping 306 matching lines @@
 
 extern const char kSOCKS5OkRequest[];
 extern const int kSOCKS5OkRequestLength;
 
 extern const char kSOCKS5OkResponse[];
 extern const int kSOCKS5OkResponseLength;
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_