src: extracting OnConnection from pipe_wrap and tcp_wrap

node.gyp

@@ -141,6 +141,7 @@
         'src/env.cc',
         'src/fs_event_wrap.cc',
         'src/cares_wrap.cc',
+        'src/connection_wrap.cc',
         'src/handle_wrap.cc',
         'src/js_stream.cc',
         'src/node.cc',
@@ -177,6 +178,7 @@
         'src/async-wrap-inl.h',
         'src/base-object.h',
         'src/base-object-inl.h',
+        'src/connection_wrap.h',
         'src/debug-agent.h',
         'src/env.h',
         'src/env-inl.h',

src/connection_wrap.cc

@@ -0,0 +1,73 @@
+#include "connection_wrap.h"
+
+#include "env-inl.h"
+#include "env.h"
+#include "pipe_wrap.h"
+#include "tcp_wrap.h"
+#include "util.h"
+#include "util-inl.h"
+
+namespace node {
+
+using v8::Context;
+using v8::HandleScope;
+using v8::Integer;
+using v8::Local;
+using v8::Object;
+using v8::Value;
+
+
+template<typename WrapType, typename UVType>
+void ConnectionWrap<WrapType, UVType>::OnConnection(uv_stream_t* handle,
+                                                    int status) {
+  WrapType* wrap_data = static_cast<WrapType*>(handle->data);
+  CHECK_EQ(&wrap_data->uvhandle_, reinterpret_cast<UVType*>(handle));
+
+  Environment* env = wrap_data->env();
+  HandleScope handle_scope(env->isolate());
+  Context::Scope context_scope(env->context());
+
+  // We should not be getting this callback if someone as already called
+  // uv_close() on the handle.
+  CHECK_EQ(wrap_data->persistent().IsEmpty(), false);
+
+  Local<Value> argv[] = {
+    Integer::New(env->isolate(), status),
+    Undefined(env->isolate())
+  };
+
+  if (status == 0) {
+    // Instanciate the client javascript object and handle.
+    Local<Object> client_obj = WrapType::Instantiate(env, wrap_data);
+
+    // Unwrap the client javascript object.
+    WrapType* wrap;
+    ASSIGN_OR_RETURN_UNWRAP(&wrap, client_obj);
+    uv_stream_t* client_handle =
+        reinterpret_cast<uv_stream_t*>(&wrap->uvhandle_);
+    if (uv_accept(handle, client_handle))
+      return;
+
+    // Successful accept. Call the onconnection callback in JavaScript land.
+    argv[1] = client_obj;
+  }
+  wrap_data->MakeCallback(env->onconnection_string(), arraysize(argv), argv);
+}
+
+template void ConnectionWrap<PipeWrap, uv_pipe_t>::OnConnection(
+    uv_stream_t* handle, int status);
+
+template void ConnectionWrap<TCPWrap, uv_tcp_t>::OnConnection(
+    uv_stream_t* handle, int status);
+
+template<typename WrapType, typename UVType>
+UVType* ConnectionWrap<WrapType, UVType>::UVHandle() {
+  return &uvhandle_;
+}
+
+template uv_pipe_t* ConnectionWrap<PipeWrap, uv_pipe_t>::UVHandle();
+
+template uv_tcp_t* ConnectionWrap<TCPWrap, uv_tcp_t>::UVHandle();
+
+
+}  // namespace node

src/connection_wrap.h

@@ -0,0 +1,26 @@
+#ifndef SRC_CONNECTION_WRAP_H_
+#define SRC_CONNECTION_WRAP_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "env.h"
+#include "v8.h"
+
+namespace node {
+
+template<typename WrapType, typename UVType>
+class ConnectionWrap {
+ public:
+  UVType* UVHandle();
+
+ protected:
+  static void OnConnection(uv_stream_t* handle, int status);
+  UVType uvhandle_;
+};
+
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_CONNECTION_WRAP_H_

src/node_internals.h

@@ -86,7 +86,7 @@ void GetSockOrPeerName(const v8::FunctionCallbackInfo<v8::Value>& args) {
   sockaddr_storage storage;
   int addrlen = sizeof(storage);
   sockaddr* const addr = reinterpret_cast<sockaddr*>(&storage);
-  const int err = F(&wrap->handle_, addr, &addrlen);
+  const int err = F(&wrap->uvhandle_, addr, &addrlen);
   if (err == 0)
     AddressToJS(wrap->env(), addr, args[0].As<v8::Object>());
   args.GetReturnValue().Set(err);

src/pipe_wrap.cc

@@ -10,6 +10,7 @@
 #include "req-wrap.h"
 #include "req-wrap-inl.h"
 #include "stream_wrap.h"
+#include "connection_wrap.h"
 #include "util-inl.h"
 #include "util.h"
 
@@ -27,7 +28,6 @@ using v8::Integer;
 using v8::Local;
 using v8::Object;
 using v8::String;
-using v8::Undefined;
 using v8::Value;
 
 
@@ -51,11 +51,6 @@ static void NewPipeConnectWrap(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-uv_pipe_t* PipeWrap::UVHandle() {
-  return &handle_;
-}
-
-
 Local<Object> PipeWrap::Instantiate(Environment* env, AsyncWrap* parent) {
   EscapableHandleScope handle_scope(env->isolate());
   CHECK_EQ(false, env->pipe_constructor_template().IsEmpty());
@@ -127,10 +122,10 @@ PipeWrap::PipeWrap(Environment* env,
                    AsyncWrap* parent)
     : StreamWrap(env,
                  object,
-                 reinterpret_cast<uv_stream_t*>(&handle_),
+                 reinterpret_cast<uv_stream_t*>(&uvhandle_),
                  AsyncWrap::PROVIDER_PIPEWRAP,
                  parent) {
-  int r = uv_pipe_init(env->event_loop(), &handle_, ipc);
+  int r = uv_pipe_init(env->event_loop(), &uvhandle_, ipc);
   CHECK_EQ(r, 0);  // How do we proxy this error up to javascript?
                    // Suggestion: uv_pipe_init() returns void.
   UpdateWriteQueueSize();
@@ -141,7 +136,7 @@ void PipeWrap::Bind(const FunctionCallbackInfo<Value>& args) {
   PipeWrap* wrap;
   ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
   node::Utf8Value name(args.GetIsolate(), args[0]);
-  int err = uv_pipe_bind(&wrap->handle_, *name);
+  int err = uv_pipe_bind(&wrap->uvhandle_, *name);
   args.GetReturnValue().Set(err);
 }
 
@@ -151,7 +146,7 @@ void PipeWrap::SetPendingInstances(const FunctionCallbackInfo<Value>& args) {
   PipeWrap* wrap;
   ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
   int instances = args[0]->Int32Value();
-  uv_pipe_pending_instances(&wrap->handle_, instances);
+  uv_pipe_pending_instances(&wrap->uvhandle_, instances);
 }
 #endif
 
@@ -160,51 +155,13 @@ void PipeWrap::Listen(const FunctionCallbackInfo<Value>& args) {
   PipeWrap* wrap;
   ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
   int backlog = args[0]->Int32Value();
-  int err = uv_listen(reinterpret_cast<uv_stream_t*>(&wrap->handle_),
+  int err = uv_listen(reinterpret_cast<uv_stream_t*>(&wrap->uvhandle_),
                       backlog,
                       OnConnection);
   args.GetReturnValue().Set(err);
 }
 
 
-// TODO(bnoordhuis) maybe share with TCPWrap?
-void PipeWrap::OnConnection(uv_stream_t* handle, int status) {
-  PipeWrap* pipe_wrap = static_cast<PipeWrap*>(handle->data);
-  CHECK_EQ(&pipe_wrap->handle_, reinterpret_cast<uv_pipe_t*>(handle));
-
-  Environment* env = pipe_wrap->env();
-  HandleScope handle_scope(env->isolate());
-  Context::Scope context_scope(env->context());
-
-  // We should not be getting this callback if someone as already called
-  // uv_close() on the handle.
-  CHECK_EQ(pipe_wrap->persistent().IsEmpty(), false);
-
-  Local<Value> argv[] = {
-    Integer::New(env->isolate(), status),
-    Undefined(env->isolate())
-  };
-
-  if (status != 0) {
-    pipe_wrap->MakeCallback(env->onconnection_string(), arraysize(argv), argv);
-    return;
-  }
-
-  // Instanciate the client javascript object and handle.
-  Local<Object> client_obj = Instantiate(env, pipe_wrap);
-
-  // Unwrap the client javascript object.
-  PipeWrap* wrap;
-  ASSIGN_OR_RETURN_UNWRAP(&wrap, client_obj);
-  uv_stream_t* client_handle = reinterpret_cast<uv_stream_t*>(&wrap->handle_);
-  if (uv_accept(handle, client_handle))
-    return;
-
-  // Successful accept. Call the onconnection callback in JavaScript land.
-  argv[1] = client_obj;
-  pipe_wrap->MakeCallback(env->onconnection_string(), arraysize(argv), argv);
-}
-
 // TODO(bnoordhuis) Maybe share this with TCPWrap?
 void PipeWrap::AfterConnect(uv_connect_t* req, int status) {
   PipeConnectWrap* req_wrap = static_cast<PipeConnectWrap*>(req->data);
@@ -251,7 +208,7 @@ void PipeWrap::Open(const FunctionCallbackInfo<Value>& args) {
 
   int fd = args[0]->Int32Value();
 
-  int err = uv_pipe_open(&wrap->handle_, fd);
+  int err = uv_pipe_open(&wrap->uvhandle_, fd);
 
   if (err != 0)
     env->isolate()->ThrowException(UVException(err, "uv_pipe_open"));
@@ -272,7 +229,7 @@ void PipeWrap::Connect(const FunctionCallbackInfo<Value>& args) {
 
   PipeConnectWrap* req_wrap = new PipeConnectWrap(env, req_wrap_obj);
   uv_pipe_connect(&req_wrap->req_,
-                  &wrap->handle_,
+                  &wrap->uvhandle_,
                   *name,
                   AfterConnect);
   req_wrap->Dispatched();

src/pipe_wrap.h

@@ -6,13 +6,12 @@
 #include "async-wrap.h"
 #include "env.h"
 #include "stream_wrap.h"
+#include "connection_wrap.h"
 
 namespace node {
 
-class PipeWrap : public StreamWrap {
+class PipeWrap : public StreamWrap, public ConnectionWrap<PipeWrap, uv_pipe_t> {
  public:
-  uv_pipe_t* UVHandle();
-
   static v8::Local<v8::Object> Instantiate(Environment* env, AsyncWrap* parent);
   static void Initialize(v8::Local<v8::Object> target,
                          v8::Local<v8::Value> unused,
@@ -21,6 +20,7 @@ class PipeWrap : public StreamWrap {
   size_t self_size() const override { return sizeof(*this); }
 
  private:
+  friend class ConnectionWrap;  // So handle_ can be accessed
   PipeWrap(Environment* env,
            v8::Local<v8::Object> object,
            bool ipc,
@@ -37,10 +37,7 @@ class PipeWrap : public StreamWrap {
       const v8::FunctionCallbackInfo<v8::Value>& args);
 #endif
 
-  static void OnConnection(uv_stream_t* handle, int status);
   static void AfterConnect(uv_connect_t* req, int status);
-
-  uv_pipe_t handle_;
 };