Add functionality to pppapi TCPSocket to support secure sockets in flash

ppapi/proxy/ppb_tcp_socket_private_proxy.cc

 // 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.
 
 #include "ppapi/proxy/ppb_tcp_socket_private_proxy.h"
 
 #include <map>
 
 #include "base/logging.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/proxy/plugin_proxy_delegate.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/shared_impl/private/ppb_x509_certificate_private_shared.h"
 #include "ppapi/shared_impl/private/tcp_socket_private_impl.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/thunk/thunk.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 typedef std::map<uint32, TCPSocketPrivateImpl*> IDToSocketMap;
 IDToSocketMap* g_id_to_socket = NULL;
 
 class TCPSocket : public TCPSocketPrivateImpl {
  public:
   // C-tor for new sockets.
   TCPSocket(const HostResource& resource, uint32 socket_id);
   // C-tor for already connected sockets.
   TCPSocket(const HostResource& resource,
             uint32 socket_id,
             const PP_NetAddress_Private& local_addr,
             const PP_NetAddress_Private& remote_addr);
   virtual ~TCPSocket();
 
   virtual void SendConnect(const std::string& host, uint16_t port) OVERRIDE;
   virtual void SendConnectWithNetAddress(
       const PP_NetAddress_Private& addr) OVERRIDE;
-  virtual void SendSSLHandshake(const std::string& server_name,
-                                uint16_t server_port) OVERRIDE;
+  virtual void SendSSLHandshake(
+      const std::string& server_name,
+      uint16_t server_port,
+      const std::vector<std::vector<char> >& trusted_certs,
+      const std::vector<std::vector<char> >& untrusted_certs) OVERRIDE;
   virtual void SendRead(int32_t bytes_to_read) OVERRIDE;
   virtual void SendWrite(const std::string& buffer) OVERRIDE;
   virtual void SendDisconnect() OVERRIDE;
 
  private:
   void SendToBrowser(IPC::Message* msg);
 
   DISALLOW_COPY_AND_ASSIGN(TCPSocket);
 };
 
@@ skipping 28 matching lines @@
 void TCPSocket::SendConnect(const std::string& host, uint16_t port) {
   SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Connect(
       API_ID_PPB_TCPSOCKET_PRIVATE, socket_id_, host, port));
 }
 
 void TCPSocket::SendConnectWithNetAddress(const PP_NetAddress_Private& addr) {
   SendToBrowser(new PpapiHostMsg_PPBTCPSocket_ConnectWithNetAddress(
       API_ID_PPB_TCPSOCKET_PRIVATE, socket_id_, addr));
 }
 
-void TCPSocket::SendSSLHandshake(const std::string& server_name,
-                                 uint16_t server_port) {
+void TCPSocket::SendSSLHandshake(
+    const std::string& server_name,
+    uint16_t server_port,
+    const std::vector<std::vector<char> >& trusted_certs,
+    const std::vector<std::vector<char> >& untrusted_certs) {
   SendToBrowser(new PpapiHostMsg_PPBTCPSocket_SSLHandshake(
-      socket_id_, server_name, server_port));
+      socket_id_, server_name, server_port, trusted_certs, untrusted_certs));
 }
 
 void TCPSocket::SendRead(int32_t bytes_to_read) {
   SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Read(socket_id_, bytes_to_read));
 }
 
 void TCPSocket::SendWrite(const std::string& buffer) {
   SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Write(socket_id_, buffer));
 }
 
@@ skipping 76 matching lines @@
   }
   IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
   if (iter == g_id_to_socket->end())
     return;
   iter->second->OnConnectCompleted(succeeded, local_addr, remote_addr);
 }
 
 void PPB_TCPSocket_Private_Proxy::OnMsgSSLHandshakeACK(
     uint32 /* plugin_dispatcher_id */,
     uint32 socket_id,
-    bool succeeded) {
+    bool succeeded,
+    const PPB_X509Certificate_Fields& certificate_fields) {
   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);
+  iter->second->OnSSLHandshakeCompleted(succeeded, certificate_fields);
 }
 
 void PPB_TCPSocket_Private_Proxy::OnMsgReadACK(
     uint32 /* plugin_dispatcher_id */,
     uint32 socket_id,
     bool succeeded,
     const std::string& data) {
   if (!g_id_to_socket) {
     NOTREACHED();
     return;
@@ skipping 14 matching lines @@
     return;
   }
   IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
   if (iter == g_id_to_socket->end())
     return;
   iter->second->OnWriteCompleted(succeeded, bytes_written);
 }
 
 }  // namespace proxy
 }  // namespace ppapi