Start fixing code style

nodejs · luminosuslight · Oct 27, 2017 · Oct 27, 2017 · Oct 26, 2017 · Oct 29, 2017
commit fe6a38ac492411fd513dbe5fa5717a4901f2c6c4
diff --git a/src/node.cc b/src/node.cc
@@ -5012,32 +5012,31 @@ class CmdArgs {
    * @param arguments the arguments for the program
    */
   CmdArgs(const std::string& program_name, const std::vector<std::string>& arguments)
-    : argc(0)
-    , argv(nullptr)
-  {
+    : argc(0),
+      argv(nullptr) {
     size_t total_size = 0;
     total_size += program_name.size() + 1;
     for (const auto& argument: arguments) {
       total_size += argument.size() + 1;
     }
 
     std::vector<std::size_t> offsets;
-    argument_data.reserve(total_size);
-    offsets.push_back(argument_data.size());
-    argument_data += program_name;
-    argument_data += char(0x0);
+    argument_data_.reserve(total_size);
+    offsets.push_back(argument_data_.size());
+    argument_data_ += program_name;
+    argument_data_ += char(0x0);
     for (const auto& argument: arguments) {
-      offsets.push_back(argument_data.size());
-      argument_data += argument;
-      argument_data += char(0x0);
+      offsets.push_back(argument_data_.size());
+      argument_data_ += argument;
+      argument_data_ += char(0x0);
     }
 
-    argument_pointers.resize(offsets.size());
-    for (std::size_t i=0; i<argument_pointers.size(); ++i) {
-      argument_pointers[i] = argument_data.data() + offsets[i];
+    argument_pointers_.resize(offsets.size());
+    for (std::size_t i=0; i<argument_pointers_.size(); ++i) {
+      argument_pointers_[i] = argument_data_.data() + offsets[i];
     }
-    argc = argument_pointers.size();
-    argv = argument_pointers.data();
+    argc = argument_pointers_.size();
+    argv = argument_pointers_.data();
   }
 
   ~CmdArgs() = default;
@@ -5056,11 +5055,11 @@ class CmdArgs {
   /**
    * @brief argument_data contains the program name and the arguments separated by null bytes
    */
-  std::string argument_data;
+  std::string argument_data_;
   /**
    * @brief argument_pointers contains pointers to the beginnings of the strings in argument_data
    */
-  std::vector<const char*> argument_pointers;
+  std::vector<const char*> argument_pointers_;
 };
 
 ArrayBufferAllocator* allocator;
@@ -5091,8 +5090,8 @@ namespace internal {
 }
 
 void _RegisterModuleCallback(v8::Local<v8::Object> exports,
-          v8::Local<v8::Value> module,
-          v8::Local<v8::Context> context,
+          v8::Local<v8::Value> /*module*/,
+          v8::Local<v8::Context> /*context*/,
           void* priv) {
     auto module_functions = static_cast<std::map<std::string, v8::FunctionCallback>*>(priv);
     if (!module_functions) {
@@ -5102,13 +5101,12 @@ void _RegisterModuleCallback(v8::Local<v8::Object> exports,
     for (std::pair<std::string, v8::FunctionCallback> element : *module_functions) {
         NODE_SET_METHOD(exports, element.first.c_str(), element.second);
     }
-
     delete module_functions;
 }
 
 namespace deinitialize {
 
-void deleteCmdArgs() {
+void _DeleteCmdArgs() {
   if (!cmd_args) {
     return;
   }
@@ -5129,14 +5127,14 @@ int _StopEnv() {
   return exit_code;
 }
 
-void deleteIsolate() {
+void _DeleteIsolate() {
   Mutex::ScopedLock scoped_lock(node_isolate_mutex);
   CHECK_EQ(node_isolate, _isolate);
   node_isolate = nullptr;
   _isolate->Dispose();
 }
 
-void deinitV8() {
+void _DeinitV8() {
   if (trace_enabled) {
     v8_platform.StopTracingAgent();
   }
@@ -5157,7 +5155,7 @@ void deinitV8() {
 
 namespace initialize {
 
-void initV8() {
+void _InitV8() {
   v8_platform.Initialize(v8_thread_pool_size, uv_default_loop());
   // Enable tracing when argv has --trace-events-enabled.
   if (trace_enabled) {
@@ -5170,7 +5168,7 @@ void initV8() {
   v8_initialized = true;
 }
 
-void createIsolate() {
+void _CreateIsolate() {
   allocator = new ArrayBufferAllocator();
   params.array_buffer_allocator = allocator;
 #ifdef NODE_ENABLE_VTUNE_PROFILING
@@ -5201,7 +5199,7 @@ void createIsolate() {
   }
 }
 
-void createInitialEnvironment() {
+void _CreateInitialEnvironment() {
   locker = new Locker(_isolate);
   isolate_scope = new Isolate::Scope(_isolate);
   static HandleScope handle_scope(_isolate); // TODO (jh): Once we write a Deinit(), we need to put this on the heap to call the deconstructor.
@@ -5218,7 +5216,7 @@ void createInitialEnvironment() {
   uv_key_set(&thread_local_env, _environment);
 }
 
-void configureOpenSsl() {
+void _ConfigureOpenSsl() {
 #if HAVE_OPENSSL
   {
     std::string extra_ca_certs;
@@ -5238,34 +5236,34 @@ void configureOpenSsl() {
 
 void _StartEnv(int argc,
                const char* const* argv) {
-    std::cout << "Starting environment" << std::endl;
+  std::cout << "Starting environment" << std::endl;
 
-    int v8_argc = 0;
-    const char* const* v8_argv = nullptr;
-    _environment->Start(argc, argv, v8_argc, v8_argv, v8_is_profiling);
+  int v8_argc = 0;
+  const char* const* v8_argv = nullptr;
+  _environment->Start(argc, argv, v8_argc, v8_argv, v8_is_profiling);
 
-    const char* path = argc > 1 ? argv[1] : nullptr;
-    StartInspector(_environment, path, debug_options);
+  const char* path = argc > 1 ? argv[1] : nullptr;
+  StartInspector(_environment, path, debug_options);
 
-    if (debug_options.inspector_enabled() && !v8_platform.InspectorStarted(_environment)) {
-      return; // TODO (jh): Handle error
-      //return 12;  // Signal internal error.
-    }
+  if (debug_options.inspector_enabled() && !v8_platform.InspectorStarted(_environment)) {
+    return; // TODO (jh): Handle error
+    //return 12;  // Signal internal error.
+  }
 
-    _environment->set_abort_on_uncaught_exception(abort_on_uncaught_exception);
+  _environment->set_abort_on_uncaught_exception(abort_on_uncaught_exception);
 
-    if (no_force_async_hooks_checks) {
-      _environment->async_hooks()->no_force_checks();
-    }
+  if (no_force_async_hooks_checks) {
+    _environment->async_hooks()->no_force_checks();
+  }
 
-    {
-      Environment::AsyncCallbackScope callback_scope(_environment);
-      _environment->async_hooks()->push_async_ids(1, 0);
-      LoadEnvironment(_environment);
-      _environment->async_hooks()->pop_async_id(1);
-    }
+  {
+    Environment::AsyncCallbackScope callback_scope(_environment);
+    _environment->async_hooks()->push_async_ids(1, 0);
+    LoadEnvironment(_environment);
+    _environment->async_hooks()->pop_async_id(1);
+  }
 
-    _environment->set_trace_sync_io(trace_sync_io);
+  _environment->set_trace_sync_io(trace_sync_io);
 }
 
 }  // namespace initialize
@@ -5292,17 +5290,17 @@ void Initialize(const std::string& program_name, const std::vector<std::string>&
   const char** exec_argv = nullptr;
   Init(&cmd_args->argc, cmd_args->argv, &exec_argc, &exec_argv);
 
-  initialize::configureOpenSsl();
+  initialize::_ConfigureOpenSsl();
 
-  initialize::initV8();
+  initialize::_InitV8();
 
   //////////
   // Start 2
   //////////
 
-  initialize::createIsolate();
+  initialize::_CreateIsolate();
 
-  initialize::createInitialEnvironment();
+  initialize::_CreateInitialEnvironment();
 
   //////////
   // Start environment
@@ -5322,11 +5320,11 @@ int Deinitialize() {
   __lsan_do_leak_check();
 #endif
 
-  deinitialize::deleteIsolate();
+  deinitialize::_DeleteIsolate();
 
-  deinitialize::deinitV8();
+  deinitialize::_DeinitV8();
 
-  deinitialize::deleteCmdArgs();
+  deinitialize::_DeleteCmdArgs();
 
   return exit_code;
 }
@@ -5350,7 +5348,10 @@ v8::MaybeLocal<v8::Value> Evaluate(const std::string& java_script_code) {
   try_catch.SetVerbose(false);
 
   //ScriptOrigin origin(filename); // TODO jh: set reasonable ScriptOrigin. This is used for debugging
-  MaybeLocal<v8::Script> script = v8::Script::Compile(_environment->context(), v8::String::NewFromUtf8(_isolate, java_script_code.c_str())/*, origin*/);
+  MaybeLocal<v8::Script> script = v8::Script::Compile(_environment->context(),
+                                                      v8::String::NewFromUtf8(_isolate,
+                                                                              java_script_code.c_str())
+                                                                              /*origin*/);
   if (script.IsEmpty()) {
     ReportException(_environment, try_catch);
     return MaybeLocal<v8::Value>();
@@ -5383,15 +5384,18 @@ v8::MaybeLocal<v8::Object> GetRootObject() {
 }
 
 
-v8::MaybeLocal<v8::Value> Call(v8::Local<v8::Object> receiver, v8::Local<v8::Function> function, const std::vector<v8::Local<v8::Value>> & args) {
-    return function->Call(receiver, args.size(), const_cast<v8::Local<v8::Value>*>(&args[0]));
+v8::MaybeLocal<v8::Value> Call(v8::Local<v8::Object> receiver, v8::Local<v8::Function> function,
+                               const std::vector<v8::Local<v8::Value>> & args) {
+  return function->Call(receiver, args.size(), const_cast<v8::Local<v8::Value>*>(&args[0]));
 }
 
-v8::MaybeLocal<v8::Value> Call(v8::Local<v8::Object> receiver, v8::Local<v8::Function> function, std::initializer_list<v8::Local<v8::Value>> args) {
-    return Call(receiver, function, std::vector<v8::Local<v8::Value>>(args));
+v8::MaybeLocal<v8::Value> Call(v8::Local<v8::Object> receiver, v8::Local<v8::Function> function,
+                               std::initializer_list<v8::Local<v8::Value>> args) {
+  return Call(receiver, function, std::vector<v8::Local<v8::Value>>(args));
 }
 
-v8::MaybeLocal<v8::Value> Call(v8::Local<v8::Object> object, const std::string& function_name, const std::vector<v8::Local<v8::Value>>& args) {
+v8::MaybeLocal<v8::Value> Call(v8::Local<v8::Object> object, const std::string& function_name,
+                               const std::vector<v8::Local<v8::Value>>& args) {
   MaybeLocal<v8::String> maybe_function_name = v8::String::NewFromUtf8(_isolate, function_name.c_str());
   Local<v8::String> v8_function_name;
 
@@ -5414,8 +5418,10 @@ v8::MaybeLocal<v8::Value> Call(v8::Local<v8::Object> object, const std::string&
   return Call(object, v8::Local<v8::Function>::Cast(value), args);
 }
 
-v8::MaybeLocal<v8::Value> Call(v8::Local<v8::Object> object, const std::string & function_name, std::initializer_list<v8::Local<v8::Value>> args) {
-    return Call(object, function_name, std::vector<v8::Local<v8::Value>>(args));
+v8::MaybeLocal<v8::Value> Call(v8::Local<v8::Object> object,
+                               const std::string & function_name,
+                               std::initializer_list<v8::Local<v8::Value>> args) {
+  return Call(object, function_name, std::vector<v8::Local<v8::Value>>(args));
 }
 
 v8::MaybeLocal<v8::Object> IncludeModule(const std::string& module_name) {
@@ -5479,8 +5485,8 @@ void RegisterModule(const std::string & name, const addon_context_register_func
 void RegisterModule(const std::string & name,
                     const std::map<std::string, v8::FunctionCallback> & module_functions,
                     const std::string & target) {
-    auto map_on_heap = new const std::map<std::string, v8::FunctionCallback>(module_functions);
-    RegisterModule(name, node::lib::_RegisterModuleCallback, const_cast<std::map<std::string, v8::FunctionCallback>*>(map_on_heap), target);
+  auto map_on_heap = new const std::map<std::string, v8::FunctionCallback>(module_functions);
+  RegisterModule(name, node::lib::_RegisterModuleCallback, const_cast<std::map<std::string, v8::FunctionCallback>*>(map_on_heap), target);
 }
 
 void StopEventLoop() {