An implementation of chrome.socket.secure().

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 <vector>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "chrome/browser/browser_process.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/tcp_socket.h"
+#include "chrome/browser/extensions/api/socket/tls_socket.h"
 #include "chrome/browser/extensions/api/socket/udp_socket.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/common/extensions/permissions/socket_permission.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/permissions_data.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"
@@ skipping 44 matching lines @@
 }
 
 int SocketAsyncApiFunction::AddSocket(Socket* socket) {
   return manager_->Add(socket);
 }
 
 Socket* SocketAsyncApiFunction::GetSocket(int api_resource_id) {
   return manager_->Get(extension_->id(), api_resource_id);
 }
 
+void SocketAsyncApiFunction::SetSocket(int api_resource_id,
+                                       Socket* socket) {
+  manager_->Set(extension_->id(), api_resource_id, socket);
+}
+
 base::hash_set<int>* SocketAsyncApiFunction::GetSocketIds() {
   return manager_->GetResourceIds(extension_->id());
 }
 
 void SocketAsyncApiFunction::RemoveSocket(int api_resource_id) {
   manager_->Remove(extension_->id(), api_resource_id);
 }
 
 SocketExtensionWithDnsLookupFunction::SocketExtensionWithDnsLookupFunction()
     : io_thread_(g_browser_process->io_thread()),
@@ skipping 143 matching lines @@
 void SocketConnectFunction::AfterDnsLookup(int lookup_result) {
   if (lookup_result == net::OK) {
     StartConnect();
   } else {
     SetResult(new base::FundamentalValue(lookup_result));
     AsyncWorkCompleted();
   }
 }
 
 void SocketConnectFunction::StartConnect() {
+  socket_->SetHostname(hostname_);
   socket_->Connect(resolved_address_, port_,
                    base::Bind(&SocketConnectFunction::OnConnect, this));
 }
 
 void SocketConnectFunction::OnConnect(int result) {
   SetResult(new base::FundamentalValue(result));
   AsyncWorkCompleted();
 }
 
 bool SocketDisconnectFunction::Prepare() {
@@ skipping 637 matching lines @@
     SetResult(new base::FundamentalValue(result));
     return;
   }
 
   base::ListValue* values = new base::ListValue();
   values->AppendStrings((std::vector<std::string>&)
       static_cast<UDPSocket*>(socket)->GetJoinedGroups());
   SetResult(values);
 }
 
+SocketSecureFunction::SocketSecureFunction() {}
+SocketSecureFunction::~SocketSecureFunction() {}
+
+bool SocketSecureFunction::Prepare() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  params_ = api::socket::Secure::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params_.get());
+  url_request_getter_ = GetProfile()->GetRequestContext();
+  return true;
+}
+
+void SocketSecureFunction::Work() {

[rpaquay, 2013/12/09 23:02:03]

Using "Work" is slightly different than the convention we use. I would change to
1) not override the "Work" method at all and 2) move the code to the
"AsyncWorkStart" method.

[lally, 2013/12/12 02:31:39]

Done.

+  base::Value *result;
+  async_completed_needs_invocation_ = false;
+  const char * error_str =  TLSSocket::SecureTCPSocket(

[rpaquay, 2013/12/09 23:02:03]

There are issues with the way error handling is done here. I would change the
code like this:
1) Move the initial code of TLSSocket::SecureTCPSocket into this method, and
call "AsyncWorkCompleted()" whenever you set an error string (see for example
SocketsUdpSendFunction::AsyncWorkStart)
2) Change TLSSocket::SecureTCPSocket to return "void" and to have no "result"
parameter.
3) Ensure the callback is always called
4) Remove the ""async_completed_needs_invocation_" field
5) Update the end of the "TlsConnectDone" method to do something along the lines
of (see SocketsUdpSendFunction::SetSendResult):
  if (net_result != net::OK)
    error_ = net::ErrorToString(net_result);
  results_ = socket::Secure::Results::Create(net_result);
  AsyncWorkCompleted();

[lally, 2013/12/12 02:31:39]

Done.

+       GetSocket(params_->socket_id),
+       GetProfile(),
+       url_request_getter_,
+       extension_id(),
+       params_->options.get(),
+       base::Bind(&SocketSecureFunction::TlsConnectDone, this),
+       &result);
+  if (error_str) {
+    error_ = error_str;
+  }
+  SetResult(result);
+
+  if (async_completed_needs_invocation_) {
+    AsyncWorkCompleted();
+    async_completed_needs_invocation_ = false;
+  } else {
+    async_completed_needs_invocation_ = true;
+  }
+}
+
+// Override the regular implementation, which would call AsyncWorkCompleted
+// immediately after Work().
+void SocketSecureFunction::AsyncWorkStart() {
+  Work();
+}
+
+void SocketSecureFunction::TlsConnectDone(Socket *sock, int result) {
+  if (sock) {
+    SetSocket(params_->socket_id, sock);
+  } else {
+    RemoveSocket(params_->socket_id);
+  }
+
+  if (async_completed_needs_invocation_) {

[rpaquay, 2013/12/09 23:02:03]

As mentioned above, the code here should be something along the lines of:
if (net_result != net::OK)
    error_ = net::ErrorToString(net_result);
  results_ = socket::Secure::Results::Create(net_result);
  AsyncWorkCompleted();

[lally, 2013/12/12 02:31:39]

Done.

+    AsyncWorkCompleted();
+    async_completed_needs_invocation_ = false;
+  } else {
+    async_completed_needs_invocation_ = true;
+  }
+}
+
 }  // namespace extensions