1 files changed, 0 insertions, 276 deletions
diff --git a/src/node/ext/call_credentials.cc b/src/node/ext/call_credentials.cc
deleted file mode 100644
index 0644a812e9..0000000000
--- a/src/node/ext/call_credentials.cc
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <nan.h>
-#include <node.h>
-#include <uv.h>
-
-#include <queue>
-
-#include "call.h"
-#include "call_credentials.h"
-#include "grpc/grpc.h"
-#include "grpc/grpc_security.h"
-#include "grpc/support/log.h"
-
-namespace grpc {
-namespace node {
-
-using Nan::Callback;
-using Nan::EscapableHandleScope;
-using Nan::HandleScope;
-using Nan::Maybe;
-using Nan::MaybeLocal;
-using Nan::ObjectWrap;
-using Nan::Persistent;
-using Nan::Utf8String;
-
-using v8::Exception;
-using v8::External;
-using v8::Function;
-using v8::FunctionTemplate;
-using v8::Integer;
-using v8::Local;
-using v8::Object;
-using v8::ObjectTemplate;
-using v8::Value;
-
-Nan::Callback *CallCredentials::constructor;
-Persistent<FunctionTemplate> CallCredentials::fun_tpl;
-
-static Callback *plugin_callback;
-
-CallCredentials::CallCredentials(grpc_call_credentials *credentials)
-    : wrapped_credentials(credentials) {}
-
-CallCredentials::~CallCredentials() {
-  grpc_call_credentials_release(wrapped_credentials);
-}
-
-void CallCredentials::Init(Local<Object> exports) {
-  HandleScope scope;
-  Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
-  tpl->SetClassName(Nan::New("CallCredentials").ToLocalChecked());
-  tpl->InstanceTemplate()->SetInternalFieldCount(1);
-  Nan::SetPrototypeMethod(tpl, "compose", Compose);
-  fun_tpl.Reset(tpl);
-  Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked();
-  Nan::Set(ctr, Nan::New("createFromPlugin").ToLocalChecked(),
-           Nan::GetFunction(Nan::New<FunctionTemplate>(CreateFromPlugin))
-               .ToLocalChecked());
-  Nan::Set(exports, Nan::New("CallCredentials").ToLocalChecked(), ctr);
-  constructor = new Nan::Callback(ctr);
-
-  Local<FunctionTemplate> callback_tpl =
-      Nan::New<FunctionTemplate>(PluginCallback);
-  plugin_callback =
-      new Callback(Nan::GetFunction(callback_tpl).ToLocalChecked());
-}
-
-bool CallCredentials::HasInstance(Local<Value> val) {
-  HandleScope scope;
-  return Nan::New(fun_tpl)->HasInstance(val);
-}
-
-Local<Value> CallCredentials::WrapStruct(grpc_call_credentials *credentials) {
-  EscapableHandleScope scope;
-  const int argc = 1;
-  if (credentials == NULL) {
-    return scope.Escape(Nan::Null());
-  }
-  Local<Value> argv[argc] = {
-      Nan::New<External>(reinterpret_cast<void *>(credentials))};
-  MaybeLocal<Object> maybe_instance =
-      Nan::NewInstance(constructor->GetFunction(), argc, argv);
-  if (maybe_instance.IsEmpty()) {
-    return scope.Escape(Nan::Null());
-  } else {
-    return scope.Escape(maybe_instance.ToLocalChecked());
-  }
-}
-
-grpc_call_credentials *CallCredentials::GetWrappedCredentials() {
-  return wrapped_credentials;
-}
-
-NAN_METHOD(CallCredentials::New) {
-  if (info.IsConstructCall()) {
-    if (!info[0]->IsExternal()) {
-      return Nan::ThrowTypeError(
-          "CallCredentials can only be created with the provided functions");
-    }
-    Local<External> ext = info[0].As<External>();
-    grpc_call_credentials *creds_value =
-        reinterpret_cast<grpc_call_credentials *>(ext->Value());
-    CallCredentials *credentials = new CallCredentials(creds_value);
-    credentials->Wrap(info.This());
-    info.GetReturnValue().Set(info.This());
-    return;
-  } else {
-    // This should never be called directly
-    return Nan::ThrowTypeError(
-        "CallCredentials can only be created with the provided functions");
-  }
-}
-
-NAN_METHOD(CallCredentials::Compose) {
-  if (!CallCredentials::HasInstance(info.This())) {
-    return Nan::ThrowTypeError(
-        "compose can only be called on CallCredentials objects");
-  }
-  if (!CallCredentials::HasInstance(info[0])) {
-    return Nan::ThrowTypeError(
-        "compose's first argument must be a CallCredentials object");
-  }
-  CallCredentials *self = ObjectWrap::Unwrap<CallCredentials>(info.This());
-  CallCredentials *other = ObjectWrap::Unwrap<CallCredentials>(
-      Nan::To<Object>(info[0]).ToLocalChecked());
-  grpc_call_credentials *creds = grpc_composite_call_credentials_create(
-      self->wrapped_credentials, other->wrapped_credentials, NULL);
-  info.GetReturnValue().Set(WrapStruct(creds));
-}
-
-NAN_METHOD(CallCredentials::CreateFromPlugin) {
-  if (!info[0]->IsFunction()) {
-    return Nan::ThrowTypeError(
-        "createFromPlugin's argument must be a function");
-  }
-  grpc_metadata_credentials_plugin plugin;
-  plugin_state *state = new plugin_state;
-  state->callback = new Nan::Callback(info[0].As<Function>());
-  state->pending_callbacks = new std::queue<plugin_callback_data *>();
-  uv_mutex_init(&state->plugin_mutex);
-  uv_async_init(uv_default_loop(), &state->plugin_async, SendPluginCallback);
-  uv_unref((uv_handle_t *)&state->plugin_async);
-
-  state->plugin_async.data = state;
-
-  plugin.get_metadata = plugin_get_metadata;
-  plugin.destroy = plugin_destroy_state;
-  plugin.state = reinterpret_cast<void *>(state);
-  plugin.type = "";
-  grpc_call_credentials *creds =
-      grpc_metadata_credentials_create_from_plugin(plugin, NULL);
-  info.GetReturnValue().Set(WrapStruct(creds));
-}
-
-NAN_METHOD(PluginCallback) {
-  // Arguments: status code, error details, metadata
-  if (!info[0]->IsUint32()) {
-    return Nan::ThrowTypeError(
-        "The callback's first argument must be a status code");
-  }
-  if (!info[1]->IsString()) {
-    return Nan::ThrowTypeError(
-        "The callback's second argument must be a string");
-  }
-  if (!info[2]->IsObject()) {
-    return Nan::ThrowTypeError(
-        "The callback's third argument must be an object");
-  }
-  if (!info[3]->IsObject()) {
-    return Nan::ThrowTypeError(
-        "The callback's fourth argument must be an object");
-  }
-  grpc_status_code code =
-      static_cast<grpc_status_code>(Nan::To<uint32_t>(info[0]).FromJust());
-  Utf8String details_utf8_str(info[1]);
-  char *details = *details_utf8_str;
-  grpc_metadata_array array;
-  grpc_metadata_array_init(&array);
-  Local<Object> callback_data = Nan::To<Object>(info[3]).ToLocalChecked();
-  if (!CreateMetadataArray(Nan::To<Object>(info[2]).ToLocalChecked(), &array)) {
-    return Nan::ThrowError("Failed to parse metadata");
-  }
-  grpc_credentials_plugin_metadata_cb cb =
-      reinterpret_cast<grpc_credentials_plugin_metadata_cb>(
-          Nan::Get(callback_data, Nan::New("cb").ToLocalChecked())
-              .ToLocalChecked()
-              .As<External>()
-              ->Value());
-  void *user_data =
-      Nan::Get(callback_data, Nan::New("user_data").ToLocalChecked())
-          .ToLocalChecked()
-          .As<External>()
-          ->Value();
-  cb(user_data, array.metadata, array.count, code, details);
-  DestroyMetadataArray(&array);
-}
-
-NAUV_WORK_CB(SendPluginCallback) {
-  Nan::HandleScope scope;
-  plugin_state *state = reinterpret_cast<plugin_state *>(async->data);
-  std::queue<plugin_callback_data *> callbacks;
-  uv_mutex_lock(&state->plugin_mutex);
-  state->pending_callbacks->swap(callbacks);
-  uv_mutex_unlock(&state->plugin_mutex);
-  while (!callbacks.empty()) {
-    plugin_callback_data *data = callbacks.front();
-    callbacks.pop();
-    Local<Object> callback_data = Nan::New<Object>();
-    Nan::Set(callback_data, Nan::New("cb").ToLocalChecked(),
-             Nan::New<v8::External>(reinterpret_cast<void *>(data->cb)));
-    Nan::Set(callback_data, Nan::New("user_data").ToLocalChecked(),
-             Nan::New<v8::External>(data->user_data));
-    const int argc = 3;
-    v8::Local<v8::Value> argv[argc] = {
-        Nan::New(data->service_url).ToLocalChecked(), callback_data,
-        // Get Local<Function> from Nan::Callback*
-        **plugin_callback};
-    Nan::Callback *callback = state->callback;
-    callback->Call(argc, argv);
-    delete data;
-  }
-}
-
-int plugin_get_metadata(
-    void *state, grpc_auth_metadata_context context,
-    grpc_credentials_plugin_metadata_cb cb, void *user_data,
-    grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX],
-    size_t *num_creds_md, grpc_status_code *status,
-    const char **error_details) {
-  plugin_state *p_state = reinterpret_cast<plugin_state *>(state);
-  plugin_callback_data *data = new plugin_callback_data;
-  data->service_url = context.service_url;
-  data->cb = cb;
-  data->user_data = user_data;
-
-  uv_mutex_lock(&p_state->plugin_mutex);
-  p_state->pending_callbacks->push(data);
-  uv_mutex_unlock(&p_state->plugin_mutex);
-
-  uv_async_send(&p_state->plugin_async);
-  return 0;  // Async processing.
-}
-
-void plugin_uv_close_cb(uv_handle_t *handle) {
-  uv_async_t *async = reinterpret_cast<uv_async_t *>(handle);
-  plugin_state *state = reinterpret_cast<plugin_state *>(async->data);
-  uv_mutex_destroy(&state->plugin_mutex);
-  delete state->pending_callbacks;
-  delete state->callback;
-  delete state;
-}
-
-void plugin_destroy_state(void *ptr) {
-  plugin_state *state = reinterpret_cast<plugin_state *>(ptr);
-  uv_close((uv_handle_t *)&state->plugin_async, plugin_uv_close_cb);
-}
-
-}  // namespace node
-}  // namespace grpc