src: fix whitespace/indent cpplint warnings

PR-URL: #7462
Reviewed-By: Trevor Norris <[email protected]>

Author: bnoordhuis

src/node_internals.h

@@ -247,78 +247,78 @@ void ClearFatalExceptionHandlers(Environment* env);
 enum NodeInstanceType { MAIN, WORKER };
 
 class NodeInstanceData {
-  public:
-    NodeInstanceData(NodeInstanceType node_instance_type,
-                     uv_loop_t* event_loop,
-                     int argc,
-                     const char** argv,
-                     int exec_argc,
-                     const char** exec_argv,
-                     bool use_debug_agent_flag)
-        : node_instance_type_(node_instance_type),
-          exit_code_(1),
-          event_loop_(event_loop),
-          argc_(argc),
-          argv_(argv),
-          exec_argc_(exec_argc),
-          exec_argv_(exec_argv),
-          use_debug_agent_flag_(use_debug_agent_flag) {
-      CHECK_NE(event_loop_, nullptr);
-    }
-
-    uv_loop_t* event_loop() const {
-      return event_loop_;
-    }
-
-    int exit_code() {
-      CHECK(is_main());
-      return exit_code_;
-    }
-
-    void set_exit_code(int exit_code) {
-      CHECK(is_main());
-      exit_code_ = exit_code;
-    }
-
-    bool is_main() {
-      return node_instance_type_ == MAIN;
-    }
-
-    bool is_worker() {
-      return node_instance_type_ == WORKER;
-    }
-
-    int argc() {
-      return argc_;
-    }
-
-    const char** argv() {
-      return argv_;
-    }
-
-    int exec_argc() {
-      return exec_argc_;
-    }
-
-    const char** exec_argv() {
-      return exec_argv_;
-    }
-
-    bool use_debug_agent() {
-      return is_main() && use_debug_agent_flag_;
-    }
-
-  private:
-    const NodeInstanceType node_instance_type_;
-    int exit_code_;
-    uv_loop_t* const event_loop_;
-    const int argc_;
-    const char** argv_;
-    const int exec_argc_;
-    const char** exec_argv_;
-    const bool use_debug_agent_flag_;
-
-    DISALLOW_COPY_AND_ASSIGN(NodeInstanceData);
+ public:
+  NodeInstanceData(NodeInstanceType node_instance_type,
+                   uv_loop_t* event_loop,
+                   int argc,
+                   const char** argv,
+                   int exec_argc,
+                   const char** exec_argv,
+                   bool use_debug_agent_flag)
+      : node_instance_type_(node_instance_type),
+        exit_code_(1),
+        event_loop_(event_loop),
+        argc_(argc),
+        argv_(argv),
+        exec_argc_(exec_argc),
+        exec_argv_(exec_argv),
+        use_debug_agent_flag_(use_debug_agent_flag) {
+    CHECK_NE(event_loop_, nullptr);
+  }
+
+  uv_loop_t* event_loop() const {
+    return event_loop_;
+  }
+
+  int exit_code() {
+    CHECK(is_main());
+    return exit_code_;
+  }
+
+  void set_exit_code(int exit_code) {
+    CHECK(is_main());
+    exit_code_ = exit_code;
+  }
+
+  bool is_main() {
+    return node_instance_type_ == MAIN;
+  }
+
+  bool is_worker() {
+    return node_instance_type_ == WORKER;
+  }
+
+  int argc() {
+    return argc_;
+  }
+
+  const char** argv() {
+    return argv_;
+  }
+
+  int exec_argc() {
+    return exec_argc_;
+  }
+
+  const char** exec_argv() {
+    return exec_argv_;
+  }
+
+  bool use_debug_agent() {
+    return is_main() && use_debug_agent_flag_;
+  }
+
+ private:
+  const NodeInstanceType node_instance_type_;
+  int exit_code_;
+  uv_loop_t* const event_loop_;
+  const int argc_;
+  const char** argv_;
+  const int exec_argc_;
+  const char** exec_argv_;
+  const bool use_debug_agent_flag_;
+
+  DISALLOW_COPY_AND_ASSIGN(NodeInstanceData);
 };
 
 namespace Buffer {

src/string_bytes.cc

@@ -27,75 +27,75 @@ using v8::MaybeLocal;
 
 template <typename ResourceType, typename TypeName>
 class ExternString: public ResourceType {
-  public:
-    ~ExternString() override {
-      free(const_cast<TypeName*>(data_));
-      isolate()->AdjustAmountOfExternalAllocatedMemory(-byte_length());
-    }
-
-    const TypeName* data() const override {
-      return data_;
-    }
+ public:
+  ~ExternString() override {
+    free(const_cast<TypeName*>(data_));
+    isolate()->AdjustAmountOfExternalAllocatedMemory(-byte_length());
+  }
 
-    size_t length() const override {
-      return length_;
-    }
+  const TypeName* data() const override {
+    return data_;
+  }
 
-    int64_t byte_length() const {
-      return length() * sizeof(*data());
-    }
+  size_t length() const override {
+    return length_;
+  }
 
-    static Local<String> NewFromCopy(Isolate* isolate,
-                                     const TypeName* data,
-                                     size_t length) {
-      EscapableHandleScope scope(isolate);
+  int64_t byte_length() const {
+    return length() * sizeof(*data());
+  }
 
-      if (length == 0)
-        return scope.Escape(String::Empty(isolate));
+  static Local<String> NewFromCopy(Isolate* isolate,
+                                   const TypeName* data,
+                                   size_t length) {
+    EscapableHandleScope scope(isolate);
 
-      TypeName* new_data =
-          static_cast<TypeName*>(malloc(length * sizeof(*new_data)));
-      if (new_data == nullptr) {
-        return Local<String>();
-      }
-      memcpy(new_data, data, length * sizeof(*new_data));
+    if (length == 0)
+      return scope.Escape(String::Empty(isolate));
 
-      return scope.Escape(ExternString<ResourceType, TypeName>::New(isolate,
-                                                                    new_data,
-                                                                    length));
+    TypeName* new_data =
+        static_cast<TypeName*>(malloc(length * sizeof(*new_data)));
+    if (new_data == nullptr) {
+      return Local<String>();
     }
+    memcpy(new_data, data, length * sizeof(*new_data));
 
-    // uses "data" for external resource, and will be free'd on gc
-    static Local<String> New(Isolate* isolate,
-                             const TypeName* data,
-                             size_t length) {
-      EscapableHandleScope scope(isolate);
+    return scope.Escape(ExternString<ResourceType, TypeName>::New(isolate,
+                                                                  new_data,
+                                                                  length));
+  }
 
-      if (length == 0)
-        return scope.Escape(String::Empty(isolate));
+  // uses "data" for external resource, and will be free'd on gc
+  static Local<String> New(Isolate* isolate,
+                           const TypeName* data,
+                           size_t length) {
+    EscapableHandleScope scope(isolate);
+    if (length == 0)
+      return scope.Escape(String::Empty(isolate));
 
-      ExternString* h_str = new ExternString<ResourceType, TypeName>(isolate,
-                                                                     data,
-                                                                     length);
-      MaybeLocal<String> str = String::NewExternal(isolate, h_str);
-      isolate->AdjustAmountOfExternalAllocatedMemory(h_str->byte_length());
+    ExternString* h_str = new ExternString<ResourceType, TypeName>(isolate,
+                                                                   data,
+                                                                   length);
+    MaybeLocal<String> str = String::NewExternal(isolate, h_str);
+    isolate->AdjustAmountOfExternalAllocatedMemory(h_str->byte_length());
 
-      if (str.IsEmpty()) {
-        delete h_str;
-        return Local<String>();
-      }
 
-      return scope.Escape(str.ToLocalChecked());
+    if (str.IsEmpty()) {
+      delete h_str;
+      return Local<String>();
     }
 
-    inline Isolate* isolate() const { return isolate_; }
+    return scope.Escape(str.ToLocalChecked());
+  }
+
+  inline Isolate* isolate() const { return isolate_; }
 
-  private:
-    ExternString(Isolate* isolate, const TypeName* data, size_t length)
-      : isolate_(isolate), data_(data), length_(length) { }
-    Isolate* isolate_;
-    const TypeName* data_;
-    size_t length_;
+ private:
+  ExternString(Isolate* isolate, const TypeName* data, size_t length)
+    : isolate_(isolate), data_(data), length_(length) { }
+  Isolate* isolate_;
+  const TypeName* data_;
+  size_t length_;
 };