SignalHanlder now uses EventSource too

ry · ry · commit d1f7ffa2ffd8 · 2010-08-21T16:52:49.000-07:00
diff --git a/src/node.js b/src/node.js
@@ -546,7 +546,8 @@ var events = module.requireNative('events');
     if (isSignal(type)) {
       if (!signalWatchers.hasOwnProperty(type)) {
         var b = process.binding('signal_watcher'),
-          w = new b.SignalWatcher(process[type]);
+          w = new b.SignalWatcher();
+          w.set(process[type]);
           w.callback = function () {
             process.emit(type);
           }
diff --git a/src/node_signal_watcher.cc b/src/node_signal_watcher.cc
@@ -6,95 +6,76 @@ namespace node {
 
 using namespace v8;
 
-Persistent<FunctionTemplate> SignalWatcher::constructor_template;
-static Persistent<String> callback_symbol;
 
 void SignalWatcher::Initialize(Handle<Object> target) {
   HandleScope scope;
 
-  Local<FunctionTemplate> t = FunctionTemplate::New(SignalWatcher::New);
-  constructor_template = Persistent<FunctionTemplate>::New(t);
-  constructor_template->InstanceTemplate()->SetInternalFieldCount(1);
-  constructor_template->SetClassName(String::NewSymbol("SignalWatcher"));
+  Local<FunctionTemplate> t = BuildTemplate<SignalWatcher>("SignalWatcher");
 
-  NODE_SET_PROTOTYPE_METHOD(constructor_template, "start", SignalWatcher::Start);
-  NODE_SET_PROTOTYPE_METHOD(constructor_template, "stop", SignalWatcher::Stop);
+  NODE_SET_PROTOTYPE_METHOD(t, "start", Start);
+  NODE_SET_PROTOTYPE_METHOD(t, "stop", Stop);
+  NODE_SET_PROTOTYPE_METHOD(t, "set", Set);
 
-  target->Set(String::NewSymbol("SignalWatcher"),
-      constructor_template->GetFunction());
-
-  callback_symbol = NODE_PSYMBOL("callback");
+  target->Set(String::NewSymbol("SignalWatcher"), t->GetFunction());
 }
 
+
 void SignalWatcher::Callback(EV_P_ ev_signal *watcher, int revents) {
   SignalWatcher *w = static_cast<SignalWatcher*>(watcher->data);
-
   assert(watcher == &w->watcher_);
-
-  HandleScope scope;
-
-  Local<Value> callback_v = w->handle_->Get(callback_symbol);
-  if (!callback_v->IsFunction()) {
-    w->Stop();
-    return;
-  }
-
-  Local<Function> callback = Local<Function>::Cast(callback_v);
-
-  TryCatch try_catch;
-
-  callback->Call(w->handle_, 0, NULL);
-
-  if (try_catch.HasCaught()) {
-    FatalException(try_catch);
-  }
+  w->MakeCallback(0, NULL);
 }
 
-Handle<Value> SignalWatcher::New(const Arguments& args) {
+
+Handle<Value> SignalWatcher::Set(const Arguments& args) {
   HandleScope scope;
+  SignalWatcher *w = ObjectWrap::Unwrap<SignalWatcher>(args.Holder());
 
   if (args.Length() != 1 || !args[0]->IsInt32()) {
     return ThrowException(String::New("Bad arguments"));
   }
 
   int sig = args[0]->Int32Value();
 
-  SignalWatcher *w = new SignalWatcher(sig);
-  w->Wrap(args.Holder());
-
-  return args.This();
+  ev_signal_set(&w->watcher_, sig);
+  return Undefined();
 }
 
+
 Handle<Value> SignalWatcher::Start(const Arguments& args) {
   HandleScope scope;
   SignalWatcher *w = ObjectWrap::Unwrap<SignalWatcher>(args.Holder());
   w->Start();
   return Undefined();
 }
 
+
 void SignalWatcher::Start () {
-  if (!watcher_.active) {
+  if (!ev_is_active(&watcher_)) {
     ev_signal_start(EV_DEFAULT_UC_ &watcher_);
     ev_unref(EV_DEFAULT_UC);
-    Ref();
+    Active();
   }
 }
 
+
 Handle<Value> SignalWatcher::Stop(const Arguments& args) {
   HandleScope scope;
   SignalWatcher *w = ObjectWrap::Unwrap<SignalWatcher>(args.Holder());
   w->Stop();
   return Undefined();
 }
 
+
 void SignalWatcher::Stop () {
-  if (watcher_.active) {
+  if (ev_is_active(&watcher_)) {
     ev_ref(EV_DEFAULT_UC);
     ev_signal_stop(EV_DEFAULT_UC_ &watcher_);
-    Unref();
+    Inactive();
   }
 }
 
+
 }  // namespace node
 
 NODE_MODULE(node_signal_watcher, node::SignalWatcher::Initialize);
diff --git a/src/node_signal_watcher.h b/src/node_signal_watcher.h
@@ -10,25 +10,23 @@
 
 namespace node {
 
-class SignalWatcher : ObjectWrap {
+class SignalWatcher : public EventSource {
  public:
   static void Initialize(v8::Handle<v8::Object> target);
 
- protected:
-  static v8::Persistent<v8::FunctionTemplate> constructor_template;
-
-  SignalWatcher(int sig) : ObjectWrap() {
-    ev_signal_init(&watcher_, SignalWatcher::Callback, sig);
+  SignalWatcher() : EventSource() {
+    ev_signal_init(&watcher_, SignalWatcher::Callback, SIGINT);
     watcher_.data = this;
   }
 
   ~SignalWatcher() {
     ev_signal_stop(EV_DEFAULT_UC_ &watcher_);
   }
 
-  static v8::Handle<v8::Value> New(const v8::Arguments& args);
+ protected:
   static v8::Handle<v8::Value> Start(const v8::Arguments& args);
   static v8::Handle<v8::Value> Stop(const v8::Arguments& args);
+  static v8::Handle<v8::Value> Set(const v8::Arguments& args);
 
  private:
   static void Callback(EV_P_ ev_signal *watcher, int revents);
