Experimental support for SSL in platform apps sockets.

chrome/browser/extensions/api/socket/socket_api.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 "chrome/browser/extensions/api/socket/socket_api.h"
 
 #include "base/bind.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/api_resource_controller.h"
 #include "chrome/browser/extensions/api/dns/host_resolver_wrapper.h"
 #include "chrome/browser/extensions/api/socket/socket.h"
+#include "chrome/browser/extensions/api/socket/ssl_socket.h"
 #include "chrome/browser/extensions/api/socket/tcp_socket.h"
 #include "chrome/browser/extensions/api/socket/udp_socket.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/io_thread.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 
 namespace extensions {
 
 const char kAddressKey[] = "address";
 const char kPortKey[] = "port";
 const char kBytesWrittenKey[] = "bytesWritten";
 const char kDataKey[] = "data";
 const char kResultCodeKey[] = "resultCode";
 const char kSocketIdKey[] = "socketId";
 const char kTCPOption[] = "tcp";
 const char kUDPOption[] = "udp";
+const char kSSLOption[] = "ssl";
 
 const char kSocketNotFoundError[] = "Socket not found";
 const char kSocketTypeInvalidError[] = "Socket type is not supported";
 const char kDnsLookupFailedError[] = "DNS resolution failed";
 
 void SocketExtensionFunction::Work() {
 }
 
 bool SocketExtensionFunction::Respond() {
   return error_.empty();
@@ skipping 50 matching lines @@
 SocketCreateFunction::~SocketCreateFunction() {}
 
 bool SocketCreateFunction::Prepare() {
   params_ = api::experimental_socket::Create::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   if (params_->type == kTCPOption) {
     socket_type_ = kSocketTypeTCP;
   } else if (params_->type == kUDPOption) {
     socket_type_ = kSocketTypeUDP;
+  } else if (params_->type == kSSLOption) {
+    socket_type_ = kSocketTypeSSL;
   } else {
     error_ = kSocketTypeInvalidError;
     return false;
   }
   if (params_->options.get()) {
     scoped_ptr<DictionaryValue> options = params_->options->ToValue();
     src_id_ = ExtractSrcId(options.get());
     event_notifier_ = CreateEventNotifier(src_id_);
   }
 
   return true;
 }
 
 void SocketCreateFunction::Work() {
   Socket* socket = NULL;
   if (socket_type_ == kSocketTypeTCP) {
     socket = new TCPSocket(event_notifier_);
-  } else if (socket_type_== kSocketTypeUDP) {
+  } else if (socket_type_ == kSocketTypeUDP) {
     socket = new UDPSocket(event_notifier_);
+  } else if (socket_type_ == kSocketTypeSSL) {
+    socket = new SSLSocket(event_notifier_);
   }
   DCHECK(socket);
 
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(kSocketIdKey, controller()->AddAPIResource(socket));
   result_.reset(result);
 }
 
 bool SocketDestroyFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
@@ skipping 41 matching lines @@
 
   socket->Connect(resolved_address_, port_,
                   base::Bind(&SocketConnectFunction::OnConnect, this));
 }
 
 void SocketConnectFunction::OnConnect(int result) {
   result_.reset(Value::CreateIntegerValue(result));
   AsyncWorkCompleted();
 }
 
+bool SocketHandshakeFunction::Prepare() {
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &ssl_hostname_));
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(2, &ssl_port_));
+  return true;
+}
+
+void SocketHandshakeFunction::AsyncWorkStart() {
+  Socket* socket = controller()->GetSocket(socket_id_);
+  if (!socket) {
+    error_ = kSocketNotFoundError;
+    OnCompleted(-1);
+    return;
+  }
+  socket->PerformSSLHandshake(ssl_hostname_,
+                              ssl_port_,
+                              base::Bind(&SocketHandshakeFunction::OnCompleted,
+                                         this));
+}
+
+void SocketHandshakeFunction::OnCompleted(int result) {
+  result_.reset(Value::CreateIntegerValue(result));
+  AsyncWorkCompleted();
+}
+
 bool SocketDisconnectFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   return true;
 }
 
 void SocketDisconnectFunction::Work() {
   Socket* socket = controller()->GetSocket(socket_id_);
   if (socket)
     socket->Disconnect();
   else
@@ skipping 241 matching lines @@
   bool result = false;
   Socket* socket = controller()->GetSocket(params_->socket_id);
   if (socket)
     result = socket->SetNoDelay(params_->no_delay);
   else
     error_ = kSocketNotFoundError;
   result_.reset(Value::CreateBooleanValue(result));
 }
 
 }  // namespace extensions