Change the SSL Socket to be capable of having reads and...

net/socket/ssl_client_socket_win.h

 // Copyright (c) 2006-2009 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_SSL_CLIENT_SOCKET_WIN_H_
 #define NET_SOCKET_SSL_CLIENT_SOCKET_WIN_H_
 
 #define SECURITY_WIN32  // Needs to be defined before including security.h
 
 #include <windows.h>
@@ skipping 35 matching lines @@
   virtual bool IsConnectedAndIdle() const;
 
   // Socket methods:
   virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback);
   virtual int Write(IOBuffer* buf, int buf_len, CompletionCallback* callback);
 
   virtual bool SetReceiveBufferSize(int32 size);
   virtual bool SetSendBufferSize(int32 size);
 
  private:
-  void DoCallback(int result);
-  void OnIOComplete(int result);
+  bool completed_handshake() const {
+    return next_state_ == STATE_COMPLETED_HANDSHAKE;
+  }
+
+  void OnHandshakeIOComplete(int result);
+  void OnReadComplete(int result);
+  void OnWriteComplete(int result);
 
   int DoLoop(int last_io_result);
   int DoHandshakeRead();
   int DoHandshakeReadComplete(int result);
   int DoHandshakeWrite();
   int DoHandshakeWriteComplete(int result);
   int DoVerifyCert();
   int DoVerifyCertComplete(int result);
+
   int DoPayloadRead();
   int DoPayloadReadComplete(int result);
+  int DoPayloadDecrypt();
   int DoPayloadEncrypt();
   int DoPayloadWrite();
   int DoPayloadWriteComplete(int result);
+  int DoCompletedRenegotiation(int result);
 
   int DidCallInitializeSecurityContext();
   int DidCompleteHandshake();
-  void DidCompleteRenegotiation(int result);
+  void DidCompleteRenegotiation();
   void LogConnectionTypeMetrics() const;
-  void SetNextStateForRead();
   void FreeSendBuffer();
 
-  CompletionCallbackImpl<SSLClientSocketWin> io_callback_;
+  // Internal callbacks as async operations complete.
+  CompletionCallbackImpl<SSLClientSocketWin> handshake_io_callback_;
+  CompletionCallbackImpl<SSLClientSocketWin> read_callback_;
+  CompletionCallbackImpl<SSLClientSocketWin> write_callback_;
+
   scoped_ptr<ClientSocket> transport_;
   std::string hostname_;
   SSLConfig ssl_config_;
 
-  CompletionCallback* user_callback_;
+  // User function to callback when the Connect() completes.
+  CompletionCallback* user_connect_callback_;
 
-  // Used by both Read and Write functions.
-  scoped_refptr<IOBuffer> user_buf_;
-  int user_buf_len_;
+  // User function to callback when a Read() completes.
+  CompletionCallback* user_read_callback_;
+  scoped_refptr<IOBuffer> user_read_buf_;
+  int user_read_buf_len_;
+
+  // User function to callback when a Write() completes.
+  CompletionCallback* user_write_callback_;
+  scoped_refptr<IOBuffer> user_write_buf_;
+  int user_write_buf_len_;
 
   // Used to Read and Write using transport_.
-  scoped_refptr<IOBuffer> transport_buf_;
+  scoped_refptr<IOBuffer> transport_read_buf_;
+  scoped_refptr<IOBuffer> transport_write_buf_;
 
   enum State {
     STATE_NONE,
     STATE_HANDSHAKE_READ,
     STATE_HANDSHAKE_READ_COMPLETE,
     STATE_HANDSHAKE_WRITE,
     STATE_HANDSHAKE_WRITE_COMPLETE,
     STATE_VERIFY_CERT,
     STATE_VERIFY_CERT_COMPLETE,
-    STATE_PAYLOAD_ENCRYPT,
-    STATE_PAYLOAD_WRITE,
-    STATE_PAYLOAD_WRITE_COMPLETE,
-    STATE_PAYLOAD_READ,
-    STATE_PAYLOAD_READ_COMPLETE,
+    STATE_COMPLETED_RENEGOTIATION,
+    STATE_COMPLETED_HANDSHAKE
+    // After the handshake, the socket remains
+    // in the STATE_COMPLETED_HANDSHAKE state,
+    // unless a renegotiate handshake occurs.
   };
   State next_state_;
 
   SecPkgContext_StreamSizes stream_sizes_;
   scoped_refptr<X509Certificate> server_cert_;
   scoped_ptr<CertVerifier> verifier_;
   CertVerifyResult server_cert_verify_result_;
 
   CredHandle* creds_;
   CtxtHandle ctxt_;
@@ skipping 31 matching lines @@
   //
   // The reason we need this flag is that OK means not only "0 bytes of data
   // were read" but also EOF.  We set ignore_ok_result_ to true when we need
   // to continue processing previously read data without reading more data.
   // We have to pass a 'result' of OK to the DoLoop method, and don't want it
   // to be interpreted as EOF.
   bool ignore_ok_result_;
 
   // Renegotiation is in progress.
   bool renegotiating_;
+
+  // True when the decrypter needs more data in order to decrypt.
+  bool need_more_data_;
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SSL_CLIENT_SOCKET_WIN_H_