An implementation of chrome.socket.secure().

extensions/browser/api/socket/tcp_socket.cc

 // Copyright 2014 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 "extensions/browser/api/socket/tcp_socket.h"
 
+#include "base/logging.h"
+#include "base/macros.h"
 #include "extensions/browser/api/api_resource.h"
 #include "net/base/address_list.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/rand_callback.h"
 #include "net/socket/tcp_client_socket.h"
 
 namespace extensions {
 
 const char kTCPSocketTypeInvalidError[] =
@@ skipping 280 matching lines @@
   DCHECK(!accept_callback_.is_null());
   if (result == net::OK && accept_socket_.get()) {
     accept_callback_.Run(
         result, static_cast<net::TCPClientSocket*>(accept_socket_.release()));
   } else {
     accept_callback_.Run(result, NULL);
   }
   accept_callback_.Reset();
 }
 
+void TCPSocket::Release() {
+  // Release() is only invoked when the underlying sockets are taken (via
+  // ClientStream()) by TLSSocket. TLSSocket only supports CLIENT-mode
+  // sockets.
+  DCHECK(!server_socket_.release() && !accept_socket_.release() &&
+         socket_mode_ == CLIENT)
+      << "Called in server mode.";
+
+  // Release() doesn't disconnect the underlying sockets, but it does
+  // disconnect them from this TCPSocket.
+  is_connected_ = false;
+
+  connect_callback_.Reset();
+  read_callback_.Reset();
+  accept_callback_.Reset();
+
+  DCHECK(socket_.get()) << "Called on null client socket.";
+  ignore_result(socket_.release());
+}
+
+net::TCPClientSocket* TCPSocket::ClientStream() {
+  if (socket_mode_ != CLIENT || GetSocketType() != TYPE_TCP)
+    return NULL;
+  return socket_.get();
+}
+
+bool TCPSocket::HasPendingRead() const {
+  return !read_callback_.is_null();
+}
+
 ResumableTCPSocket::ResumableTCPSocket(const std::string& owner_extension_id)
     : TCPSocket(owner_extension_id),
       persistent_(false),
       buffer_size_(0),
       paused_(false) {}
 
 ResumableTCPSocket::ResumableTCPSocket(net::TCPClientSocket* tcp_client_socket,
                                        const std::string& owner_extension_id,
                                        bool is_connected)
     : TCPSocket(tcp_client_socket, owner_extension_id, is_connected),
       persistent_(false),
       buffer_size_(0),
       paused_(false) {}
 
 bool ResumableTCPSocket::IsPersistent() const { return persistent(); }
 
 ResumableTCPServerSocket::ResumableTCPServerSocket(
     const std::string& owner_extension_id)
     : TCPSocket(owner_extension_id), persistent_(false), paused_(false) {}
 
 bool ResumableTCPServerSocket::IsPersistent() const { return persistent(); }
 
 }  // namespace extensions