Implement PPB_Flash_TCPSocket.InitiateSSL.

BUG=None
TEST=None


Review URL: http://codereview.chromium.org/7535007

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@97005 0039d316-1c4b-4281-b951-d872f2087c98

content/ppapi_plugin/ppapi_thread.cc

@@ -74,6 +74,8 @@ bool PpapiThread::OnMessageReceived(const IPC::Message& msg) {
     IPC_MESSAGE_HANDLER(PpapiMsg_CreateChannel, OnMsgCreateChannel)
     IPC_MESSAGE_HANDLER_GENERIC(PpapiMsg_PPBFlashTCPSocket_ConnectACK,
                                 OnPluginDispatcherMessageReceived(msg))
+    IPC_MESSAGE_HANDLER_GENERIC(PpapiMsg_PPBFlashTCPSocket_SSLHandshakeACK,
+                                OnPluginDispatcherMessageReceived(msg))
     IPC_MESSAGE_HANDLER_GENERIC(PpapiMsg_PPBFlashTCPSocket_ReadACK,
                                 OnPluginDispatcherMessageReceived(msg))
     IPC_MESSAGE_HANDLER_GENERIC(PpapiMsg_PPBFlashTCPSocket_WriteACK,

net/socket/client_socket_factory.h

@@ -47,6 +47,9 @@ class NET_EXPORT ClientSocketFactory {
       NetLog* net_log,
       const NetLog::Source& source) = 0;
 
+  // It is allowed to pass in a |transport_socket| that is not obtained from a
+  // socket pool. The caller could create a ClientSocketHandle directly and call
+  // set_socket() on it to set a valid StreamSocket instance.
   virtual SSLClientSocket* CreateSSLClientSocket(
       ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,

net/socket/ssl_client_socket_unittest.cc

@@ -14,6 +14,7 @@
 #include "net/base/ssl_config_service.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket/client_socket_factory.h"
+#include "net/socket/client_socket_handle.h"
 #include "net/socket/socket_test_util.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/test/test_server.h"
@@ -705,3 +706,39 @@ TEST_F(SSLClientSocketTest, CipherSuiteDisables) {
   EXPECT_TRUE(LogContainsSSLConnectEndEvent(entries, -1) ||
               LogContainsSSLConnectEndEvent(entries, -2));
 }
+
+// When creating an SSLClientSocket, it is allowed to pass in a
+// ClientSocketHandle that is not obtained from a client socket pool.
+// Here we verify that such a simple ClientSocketHandle, not associated with any
+// client socket pool, can be destroyed safely.
+TEST_F(SSLClientSocketTest, ClientSocketHandleNotFromPool) {
+  net::TestServer test_server(net::TestServer::TYPE_HTTPS, FilePath());
+  ASSERT_TRUE(test_server.Start());
+
+  net::AddressList addr;
+  ASSERT_TRUE(test_server.GetAddressList(&addr));
+
+  TestCompletionCallback callback;
+  net::StreamSocket* transport = new net::TCPClientSocket(
+      addr, NULL, net::NetLog::Source());
+  int rv = transport->Connect(&callback);
+  if (rv == net::ERR_IO_PENDING)
+    rv = callback.WaitForResult();
+  EXPECT_EQ(net::OK, rv);
+
+  net::ClientSocketHandle* socket_handle = new net::ClientSocketHandle();
+  socket_handle->set_socket(transport);
+
+  net::SSLClientSocketContext context;
+  context.cert_verifier = cert_verifier_.get();
+  scoped_ptr<net::SSLClientSocket> ssl_socket(
+      socket_factory_->CreateSSLClientSocket(
+          socket_handle, test_server.host_port_pair(), kDefaultSSLConfig,
+          NULL, context));
+
+  EXPECT_FALSE(ssl_socket->IsConnected());
+  rv = ssl_socket->Connect(&callback);
+  if (rv == net::ERR_IO_PENDING)
+    rv = callback.WaitForResult();
+  EXPECT_EQ(net::OK, rv);
+}

ppapi/c/private/ppb_flash_tcp_socket.h

@@ -17,7 +17,7 @@ struct PP_Flash_NetAddress {
   char data[128];
 };
 
-#define PPB_FLASH_TCPSOCKET_INTERFACE "PPB_Flash_TCPSocket;0.1"
+#define PPB_FLASH_TCPSOCKET_INTERFACE "PPB_Flash_TCPSocket;0.2"
 
 struct PPB_Flash_TCPSocket {
   PP_Resource (*Create)(PP_Instance instance);
@@ -25,6 +25,8 @@ struct PPB_Flash_TCPSocket {
   PP_Bool (*IsFlashTCPSocket)(PP_Resource resource);
 
   // Connects to a TCP port given as a host-port pair.
+  // When a proxy server is used, |host| and |port| refer to the proxy server
+  // instead of the destination server.
   int32_t (*Connect)(PP_Resource tcp_socket,
                      const char* host,
                      uint16_t port,
@@ -49,10 +51,14 @@ struct PPB_Flash_TCPSocket {
   // Does SSL handshake and moves to sending and receiving encrypted data. The
   // socket must have been successfully connected. |server_name| will be
   // compared with the name(s) in the server's certificate during the SSL
-  // handshake.
-  int32_t (*InitiateSSL)(PP_Resource tcp_socket,
-                         const char* server_name,
-                         struct PP_CompletionCallback callback);
+  // handshake. |server_port| is only used to identify an SSL server in the SSL
+  // session cache.
+  // When a proxy server is used, |server_name| and |server_port| refer to the
+  // destination server.
+  int32_t (*SSLHandshake)(PP_Resource tcp_socket,
+                          const char* server_name,
+                          uint16_t server_port,
+                          struct PP_CompletionCallback callback);
 
   // Reads data from the socket. The size of |buffer| must be at least as large
   // as |bytes_to_read|. May perform a partial read. Returns the number of bytes

ppapi/cpp/private/flash_tcp_socket.cc

@@ -66,12 +66,14 @@ bool TCPSocket::GetRemoteAddress(PP_Flash_NetAddress* remote_addr) {
   return PP_ToBool(result);
 }
 
-int32_t TCPSocket::InitiateSSL(const char* server_name,
-                               const CompletionCallback& callback) {
+int32_t TCPSocket::SSLHandshake(const char* server_name,
+                                uint16_t server_port,
+                                const CompletionCallback& callback) {
   if (!has_interface<PPB_Flash_TCPSocket>())
     return callback.MayForce(PP_ERROR_NOINTERFACE);
-  return get_interface<PPB_Flash_TCPSocket>()->InitiateSSL(
-      pp_resource(), server_name, callback.pp_completion_callback());
+  return get_interface<PPB_Flash_TCPSocket>()->SSLHandshake(
+      pp_resource(), server_name, server_port,
+      callback.pp_completion_callback());
 }
 
 int32_t TCPSocket::Read(char* buffer,

ppapi/cpp/private/flash_tcp_socket.h

@@ -31,8 +31,9 @@ class TCPSocket : public Resource {
                                 const CompletionCallback& callback);
   bool GetLocalAddress(PP_Flash_NetAddress* local_addr);
   bool GetRemoteAddress(PP_Flash_NetAddress* remote_addr);
-  int32_t InitiateSSL(const char* server_name,
-                      const CompletionCallback& callback);
+  int32_t SSLHandshake(const char* server_name,
+                       uint16_t server_port,
+                       const CompletionCallback& callback);
   int32_t Read(char* buffer,
                int32_t bytes_to_read,
                const CompletionCallback& callback);

ppapi/proxy/ppapi_messages.h

@@ -212,6 +212,10 @@ IPC_MESSAGE_ROUTED5(PpapiMsg_PPBFlashTCPSocket_ConnectACK,
                     bool /* succeeded */,
                     PP_Flash_NetAddress /* local_addr */,
                     PP_Flash_NetAddress /* remote_addr */)
+IPC_MESSAGE_ROUTED3(PpapiMsg_PPBFlashTCPSocket_SSLHandshakeACK,
+                    uint32 /* plugin_dispatcher_id */,
+                    uint32 /* socket_id */,
+                    bool /* succeeded */)
 IPC_MESSAGE_ROUTED4(PpapiMsg_PPBFlashTCPSocket_ReadACK,
                     uint32 /* plugin_dispatcher_id */,
                     uint32 /* socket_id */,
@@ -680,6 +684,10 @@ IPC_MESSAGE_CONTROL3(PpapiHostMsg_PPBFlashTCPSocket_Connect,
 IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBFlashTCPSocket_ConnectWithNetAddress,
                      uint32 /* socket_id */,
                      PP_Flash_NetAddress /* net_addr */)
+IPC_MESSAGE_CONTROL3(PpapiHostMsg_PPBFlashTCPSocket_SSLHandshake,
+                     uint32 /* socket_id */,
+                     std::string /* server_name */,
+                     uint16_t /* server_port */)
 IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBFlashTCPSocket_Read,
                      uint32 /* socket_id */,
                      int32_t /* bytes_to_read */)

ppapi/proxy/ppb_flash_tcp_socket_proxy.cc

@@ -75,8 +75,9 @@ class FlashTCPSocket : public PPB_Flash_TCPSocket_API,
       PP_CompletionCallback callback) OVERRIDE;
   virtual PP_Bool GetLocalAddress(PP_Flash_NetAddress* local_addr) OVERRIDE;
   virtual PP_Bool GetRemoteAddress(PP_Flash_NetAddress* remote_addr) OVERRIDE;
-  virtual int32_t InitiateSSL(const char* server_name,
-                              PP_CompletionCallback callback) OVERRIDE;
+  virtual int32_t SSLHandshake(const char* server_name,
+                               uint16_t server_port,
+                               PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t Read(char* buffer,
                        int32_t bytes_to_read,
                        PP_CompletionCallback callback) OVERRIDE;
@@ -89,6 +90,7 @@ class FlashTCPSocket : public PPB_Flash_TCPSocket_API,
   void OnConnectCompleted(bool succeeded,
                           const PP_Flash_NetAddress& local_addr,
                           const PP_Flash_NetAddress& remote_addr);
+  void OnSSLHandshakeCompleted(bool succeeded);
   void OnReadCompleted(bool succeeded, const std::string& data);
   void OnWriteCompleted(bool succeeded, int32_t bytes_written);
 
@@ -97,10 +99,17 @@ class FlashTCPSocket : public PPB_Flash_TCPSocket_API,
     // Before a connection is successfully established (including a connect
     // request is pending or a previous connect request failed).
     BEFORE_CONNECT,
+    // A connection has been successfully established (including a request of
+    // initiating SSL is pending).
     CONNECTED,
+    // An SSL connection has been successfully established.
+    SSL_CONNECTED,
+    // The connection has been ended.
     DISCONNECTED
   };
 
+  bool IsConnected() const;
+
   // Backend for both Connect() and ConnectWithNetAddress(). To keep things
   // generic, the message is passed in (on error, it's deleted).
   int32_t ConnectWithMessage(IPC::Message* msg,
@@ -112,6 +121,7 @@ class FlashTCPSocket : public PPB_Flash_TCPSocket_API,
   ConnectionState connection_state_;
 
   PP_CompletionCallback connect_callback_;
+  PP_CompletionCallback ssl_handshake_callback_;
   PP_CompletionCallback read_callback_;
   PP_CompletionCallback write_callback_;
 
@@ -129,6 +139,7 @@ FlashTCPSocket::FlashTCPSocket(const HostResource& resource, uint32 socket_id)
       socket_id_(socket_id),
       connection_state_(BEFORE_CONNECT),
       connect_callback_(PP_BlockUntilComplete()),
+      ssl_handshake_callback_(PP_BlockUntilComplete()),
       read_callback_(PP_BlockUntilComplete()),
       write_callback_(PP_BlockUntilComplete()),
       read_buffer_(NULL),
@@ -178,7 +189,7 @@ int32_t FlashTCPSocket::ConnectWithNetAddress(
 }
 
 PP_Bool FlashTCPSocket::GetLocalAddress(PP_Flash_NetAddress* local_addr) {
-  if (connection_state_ != CONNECTED || !local_addr)
+  if (!IsConnected() || !local_addr)
     return PP_FALSE;
 
   *local_addr = local_addr_;
@@ -186,17 +197,32 @@ PP_Bool FlashTCPSocket::GetLocalAddress(PP_Flash_NetAddress* local_addr) {
 }
 
 PP_Bool FlashTCPSocket::GetRemoteAddress(PP_Flash_NetAddress* remote_addr) {
-  if (connection_state_ != CONNECTED || !remote_addr)
+  if (!IsConnected() || !remote_addr)
     return PP_FALSE;
 
   *remote_addr = remote_addr_;
   return PP_TRUE;
 }
 
-int32_t FlashTCPSocket::InitiateSSL(const char* server_name,
-                                    PP_CompletionCallback callback) {
-  // TODO(yzshen): add it.
-  return PP_ERROR_FAILED;
+int32_t FlashTCPSocket::SSLHandshake(const char* server_name,
+                                     uint16_t server_port,
+                                     PP_CompletionCallback callback) {
+  if (!server_name || !callback.func)
+    return PP_ERROR_BADARGUMENT;
+
+  if (connection_state_ != CONNECTED)
+    return PP_ERROR_FAILED;
+  if (ssl_handshake_callback_.func || read_callback_.func ||
+      write_callback_.func)
+    return PP_ERROR_INPROGRESS;
+
+  ssl_handshake_callback_ = callback;
+
+  // Send the request, the browser will call us back via SSLHandshakeACK.
+  GetDispatcher()->SendToBrowser(
+      new PpapiHostMsg_PPBFlashTCPSocket_SSLHandshake(
+          socket_id_, std::string(server_name), server_port));
+  return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t FlashTCPSocket::Read(char* buffer,
@@ -205,9 +231,9 @@ int32_t FlashTCPSocket::Read(char* buffer,
   if (!buffer || bytes_to_read <= 0 || !callback.func)
     return PP_ERROR_BADARGUMENT;
 
-  if (connection_state_ != CONNECTED)
+  if (!IsConnected())
     return PP_ERROR_FAILED;
-  if (read_callback_.func)
+  if (read_callback_.func || ssl_handshake_callback_.func)
     return PP_ERROR_INPROGRESS;
 
   read_buffer_ = buffer;
@@ -226,9 +252,9 @@ int32_t FlashTCPSocket::Write(const char* buffer,
   if (!buffer || bytes_to_write <= 0 || !callback.func)
     return PP_ERROR_BADARGUMENT;
 
-  if (connection_state_ != CONNECTED)
+  if (!IsConnected())
     return PP_ERROR_FAILED;
-  if (write_callback_.func)
+  if (write_callback_.func || ssl_handshake_callback_.func)
     return PP_ERROR_INPROGRESS;
 
   if (bytes_to_write > kFlashTCPSocketMaxWriteSize)
@@ -248,7 +274,7 @@ void FlashTCPSocket::Disconnect() {
     return;
 
   connection_state_ = DISCONNECTED;
-  // After removed from the mapping, this object won't receive any notfications
+  // After removed from the mapping, this object won't receive any notifications
   // from the proxy.
   DCHECK(g_id_to_socket->find(socket_id_) != g_id_to_socket->end());
   g_id_to_socket->erase(socket_id_);
@@ -258,6 +284,7 @@ void FlashTCPSocket::Disconnect() {
   socket_id_ = 0;
 
   PostAbortAndClearIfNecessary(&connect_callback_);
+  PostAbortAndClearIfNecessary(&ssl_handshake_callback_);
   PostAbortAndClearIfNecessary(&read_callback_);
   PostAbortAndClearIfNecessary(&write_callback_);
   read_buffer_ = NULL;
@@ -282,6 +309,21 @@ void FlashTCPSocket::OnConnectCompleted(
                                    succeeded ? PP_OK : PP_ERROR_FAILED);
 }
 
+void FlashTCPSocket::OnSSLHandshakeCompleted(bool succeeded) {
+  if (connection_state_ != CONNECTED || !ssl_handshake_callback_.func) {
+    NOTREACHED();
+    return;
+  }
+
+  if (succeeded) {
+    connection_state_ = SSL_CONNECTED;
+    PP_RunAndClearCompletionCallback(&ssl_handshake_callback_, PP_OK);
+  } else {
+    PP_RunAndClearCompletionCallback(&ssl_handshake_callback_, PP_ERROR_FAILED);
+    Disconnect();
+  }
+}
+
 void FlashTCPSocket::OnReadCompleted(bool succeeded, const std::string& data) {
   if (!read_callback_.func || !read_buffer_) {
     NOTREACHED();
@@ -313,6 +355,10 @@ void FlashTCPSocket::OnWriteCompleted(bool succeeded, int32_t bytes_written) {
       succeeded ? bytes_written : static_cast<int32_t>(PP_ERROR_FAILED));
 }
 
+bool FlashTCPSocket::IsConnected() const {
+  return connection_state_ == CONNECTED || connection_state_ == SSL_CONNECTED;
+}
+
 int32_t FlashTCPSocket::ConnectWithMessage(IPC::Message* msg,
                                            PP_CompletionCallback callback) {
   scoped_ptr<IPC::Message> msg_deletor(msg);
@@ -383,6 +429,8 @@ bool PPB_Flash_TCPSocket_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Flash_TCPSocket_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashTCPSocket_ConnectACK, OnMsgConnectACK)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashTCPSocket_SSLHandshakeACK,
+                        OnMsgSSLHandshakeACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashTCPSocket_ReadACK, OnMsgReadACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashTCPSocket_WriteACK, OnMsgWriteACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
@@ -406,6 +454,20 @@ void PPB_Flash_TCPSocket_Proxy::OnMsgConnectACK(
   iter->second->OnConnectCompleted(succeeded, local_addr, remote_addr);
 }
 
+void PPB_Flash_TCPSocket_Proxy::OnMsgSSLHandshakeACK(
+    uint32 /* plugin_dispatcher_id */,
+    uint32 socket_id,
+    bool succeeded) {
+  if (!g_id_to_socket) {
+    NOTREACHED();
+    return;
+  }
+  IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
+  if (iter == g_id_to_socket->end())
+    return;
+  iter->second->OnSSLHandshakeCompleted(succeeded);
+}
+
 void PPB_Flash_TCPSocket_Proxy::OnMsgReadACK(uint32 /* plugin_dispatcher_id */,
                                              uint32 socket_id,
                                              bool succeeded,

ppapi/proxy/ppb_flash_tcp_socket_proxy.h

@@ -43,6 +43,9 @@ class PPB_Flash_TCPSocket_Proxy : public InterfaceProxy {
                        bool succeeded,
                        const PP_Flash_NetAddress& local_addr,
                        const PP_Flash_NetAddress& remote_addr);
+  void OnMsgSSLHandshakeACK(uint32 plugin_dispatcher_id,
+                            uint32 socket_id,
+                            bool succeeded);
   void OnMsgReadACK(uint32 plugin_dispatcher_id,
                     uint32 socket_id,
                     bool succeeded,

ppapi/thunk/ppb_flash_tcp_socket_api.h

@@ -21,8 +21,9 @@ class PPB_Flash_TCPSocket_API {
                                         PP_CompletionCallback callback) = 0;
   virtual PP_Bool GetLocalAddress(PP_Flash_NetAddress* local_addr) = 0;
   virtual PP_Bool GetRemoteAddress(PP_Flash_NetAddress* remote_addr) = 0;
-  virtual int32_t InitiateSSL(const char* server_name,
-                              PP_CompletionCallback callback) = 0;
+  virtual int32_t SSLHandshake(const char* server_name,
+                               uint16_t server_port,
+                               PP_CompletionCallback callback) = 0;
   virtual int32_t Read(char* buffer,
                        int32_t bytes_to_read,
                        PP_CompletionCallback callback) = 0;

ppapi/thunk/ppb_flash_tcp_socket_thunk.cc

@@ -65,13 +65,15 @@ PP_Bool GetRemoteAddress(PP_Resource tcp_socket,
   return enter.object()->GetRemoteAddress(remote_addr);
 }
 
-int32_t InitiateSSL(PP_Resource tcp_socket,
-                    const char* server_name,
-                    PP_CompletionCallback callback) {
+int32_t SSLHandshake(PP_Resource tcp_socket,
+                     const char* server_name,
+                     uint16_t server_port,
+                     PP_CompletionCallback callback) {
   EnterResource<PPB_Flash_TCPSocket_API> enter(tcp_socket, true);
   if (enter.failed())
     return MayForceCallback(callback, PP_ERROR_BADRESOURCE);
-  int32_t result = enter.object()->InitiateSSL(server_name, callback);
+  int32_t result = enter.object()->SSLHandshake(server_name, server_port,
+                                                callback);
   return MayForceCallback(callback, result);
 }
 
@@ -110,7 +112,7 @@ const PPB_Flash_TCPSocket g_ppb_flash_tcp_socket_thunk = {
   &ConnectWithNetAddress,
   &GetLocalAddress,
   &GetRemoteAddress,
-  &InitiateSSL,
+  &SSLHandshake,
   &Read,
   &Write,
   &Disconnect