diff --git a/src/node_internals.h b/src/node_internals.h
index b92c19734f..d215feb537 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -213,82 +213,82 @@ void ClearFatalExceptionHandlers(Environment* env);
 enum NodeInstanceType { MAIN, WORKER, REMOTE_DEBUG_SERVER };
 
 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;
-    }
-
-    bool is_remote_debug_server() {
-      return node_instance_type_ == REMOTE_DEBUG_SERVER;
-    }
-
-    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;
+  }
+
+  bool is_remote_debug_server() {
+    return node_instance_type_ == REMOTE_DEBUG_SERVER;
+  }
+
+  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 {
diff --git a/src/node_watchdog.h b/src/node_watchdog.h
index 56d5af322b..d56b7624de 100644
--- a/src/node_watchdog.h
+++ b/src/node_watchdog.h
@@ -39,56 +39,57 @@ class Watchdog {
 };
 
 class SigintWatchdog {
-  public:
-    explicit SigintWatchdog(v8::Isolate* isolate);
-    ~SigintWatchdog();
+ public:
+  explicit SigintWatchdog(v8::Isolate* isolate);
+  ~SigintWatchdog();
 
-    void Dispose();
+  void Dispose();
 
-    v8::Isolate* isolate() { return isolate_; }
-    bool HasReceivedSignal() { return received_signal_; }
-    void HandleSigint();
-  private:
-    void Destroy();
+  v8::Isolate* isolate() { return isolate_; }
+  bool HasReceivedSignal() { return received_signal_; }
+  void HandleSigint();
+
+ private:
+  void Destroy();
 
-    v8::Isolate* isolate_;
-    bool received_signal_;
-    bool destroyed_;
+  v8::Isolate* isolate_;
+  bool received_signal_;
+  bool destroyed_;
 };
 
 class SigintWatchdogHelper {
-  public:
-    static SigintWatchdogHelper* GetInstance() { return &instance; }
-    void Register(SigintWatchdog* watchdog);
-    void Unregister(SigintWatchdog* watchdog);
+ public:
+  static SigintWatchdogHelper* GetInstance() { return &instance; }
+  void Register(SigintWatchdog* watchdog);
+  void Unregister(SigintWatchdog* watchdog);
 
-    int Start();
-    bool Stop();
+  int Start();
+  bool Stop();
 
-  private:
-    SigintWatchdogHelper();
-    ~SigintWatchdogHelper();
+ private:
+  SigintWatchdogHelper();
+  ~SigintWatchdogHelper();
 
-    static bool InformWatchdogsAboutSignal();
-    static SigintWatchdogHelper instance;
+  static bool InformWatchdogsAboutSignal();
+  static SigintWatchdogHelper instance;
 
-    int start_stop_count_;
+  int start_stop_count_;
 
-    uv_mutex_t mutex_;
-    uv_mutex_t list_mutex_;
-    std::vector<SigintWatchdog*> watchdogs_;
-    bool has_pending_signal_;
+  uv_mutex_t mutex_;
+  uv_mutex_t list_mutex_;
+  std::vector<SigintWatchdog*> watchdogs_;
+  bool has_pending_signal_;
 
 #ifdef __POSIX__
-    pthread_t thread_;
-    uv_sem_t sem_;
-    bool has_running_thread_;
-    bool stopping_;
+  pthread_t thread_;
+  uv_sem_t sem_;
+  bool has_running_thread_;
+  bool stopping_;
 
-    static void* RunSigintWatchdog(void* arg);
-    static void HandleSignal(int signum);
+  static void* RunSigintWatchdog(void* arg);
+  static void HandleSignal(int signum);
 #else
-    static BOOL WINAPI WinCtrlCHandlerRoutine(DWORD dwCtrlType);
+  static BOOL WINAPI WinCtrlCHandlerRoutine(DWORD dwCtrlType);
 #endif
 };
 
diff --git a/src/string_bytes.cc b/src/string_bytes.cc
index 31c1934306..6f15ad4884 100644
--- a/src/string_bytes.cc
+++ b/src/string_bytes.cc
@@ -27,78 +27,78 @@ using v8::Value;
 
 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);
 
-      ExternString* h_str = new ExternString<ResourceType, TypeName>(isolate,
-                                                                     data,
-                                                                     length);
-      MaybeLocal<String> str = NewExternal(isolate, h_str);
-      isolate->AdjustAmountOfExternalAllocatedMemory(h_str->byte_length());
+    if (length == 0)
+      return scope.Escape(String::Empty(isolate));
 
-      if (str.IsEmpty()) {
-        delete h_str;
-        return Local<String>();
-      }
+    ExternString* h_str = new ExternString<ResourceType, TypeName>(isolate,
+                                                                   data,
+                                                                   length);
+    MaybeLocal<String> str = NewExternal(isolate, h_str);
+    isolate->AdjustAmountOfExternalAllocatedMemory(h_str->byte_length());
 
-      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) { }
-    static MaybeLocal<String> NewExternal(Isolate* isolate,
-                                          ExternString* h_str);
+ private:
+  ExternString(Isolate* isolate, const TypeName* data, size_t length)
+    : isolate_(isolate), data_(data), length_(length) { }
+  static MaybeLocal<String> NewExternal(Isolate* isolate,
+                                        ExternString* h_str);
 
-    Isolate* isolate_;
-    const TypeName* data_;
-    size_t length_;
+  Isolate* isolate_;
+  const TypeName* data_;
+  size_t length_;
 };
 
 
diff --git a/src/util.h b/src/util.h
index dd2da89e4e..0a6b5e0dbe 100644
--- a/src/util.h
+++ b/src/util.h
@@ -213,99 +213,99 @@ inline bool StringEqualNoCaseN(const char* a, const char* b, size_t length);
 // the stack is used, otherwise malloc().
 template <typename T, size_t kStackStorageSize = 1024>
 class MaybeStackBuffer {
-  public:
-    const T* out() const {
-      return buf_;
-    }
-
-    T* out() {
-      return buf_;
-    }
-
-    // operator* for compatibility with `v8::String::(Utf8)Value`
-    T* operator*() {
-      return buf_;
-    }
-
-    const T* operator*() const {
-      return buf_;
-    }
-
-    size_t length() const {
-      return length_;
-    }
-
-    // Call to make sure enough space for `storage` entries is available.
-    // There can only be 1 call to AllocateSufficientStorage or Invalidate
-    // per instance.
-    void AllocateSufficientStorage(size_t storage) {
-      if (storage <= kStackStorageSize) {
-        buf_ = buf_st_;
-      } else {
-        // Guard against overflow.
-        CHECK_LE(storage, sizeof(T) * storage);
-
-        buf_ = static_cast<T*>(malloc(sizeof(T) * storage));
-        CHECK_NE(buf_, nullptr);
-      }
-
-      // Remember how much was allocated to check against that in SetLength().
-      length_ = storage;
-    }
-
-    void SetLength(size_t length) {
-      // length_ stores how much memory was allocated.
-      CHECK_LE(length, length_);
-      length_ = length;
-    }
-
-    void SetLengthAndZeroTerminate(size_t length) {
-      // length_ stores how much memory was allocated.
-      CHECK_LE(length + 1, length_);
-      SetLength(length);
-
-      // T() is 0 for integer types, nullptr for pointers, etc.
-      buf_[length] = T();
-    }
-
-    // Make derefencing this object return nullptr.
-    // Calling this is mutually exclusive with calling
-    // AllocateSufficientStorage.
-    void Invalidate() {
-      CHECK_EQ(buf_, buf_st_);
-      length_ = 0;
-      buf_ = nullptr;
-    }
-
-    MaybeStackBuffer() : length_(0), buf_(buf_st_) {
-      // Default to a zero-length, null-terminated buffer.
-      buf_[0] = T();
+ public:
+  const T* out() const {
+    return buf_;
+  }
+
+  T* out() {
+    return buf_;
+  }
+
+  // operator* for compatibility with `v8::String::(Utf8)Value`
+  T* operator*() {
+    return buf_;
+  }
+
+  const T* operator*() const {
+    return buf_;
+  }
+
+  size_t length() const {
+    return length_;
+  }
+
+  // Call to make sure enough space for `storage` entries is available.
+  // There can only be 1 call to AllocateSufficientStorage or Invalidate
+  // per instance.
+  void AllocateSufficientStorage(size_t storage) {
+    if (storage <= kStackStorageSize) {
+      buf_ = buf_st_;
+    } else {
+      // Guard against overflow.
+      CHECK_LE(storage, sizeof(T) * storage);
+
+      buf_ = static_cast<T*>(malloc(sizeof(T) * storage));
+      CHECK_NE(buf_, nullptr);
     }
 
-    ~MaybeStackBuffer() {
-      if (buf_ != buf_st_)
-        free(buf_);
-    }
+    // Remember how much was allocated to check against that in SetLength().
+    length_ = storage;
+  }
+
+  void SetLength(size_t length) {
+    // length_ stores how much memory was allocated.
+    CHECK_LE(length, length_);
+    length_ = length;
+  }
+
+  void SetLengthAndZeroTerminate(size_t length) {
+    // length_ stores how much memory was allocated.
+    CHECK_LE(length + 1, length_);
+    SetLength(length);
+
+    // T() is 0 for integer types, nullptr for pointers, etc.
+    buf_[length] = T();
+  }
+
+  // Make derefencing this object return nullptr.
+  // Calling this is mutually exclusive with calling
+  // AllocateSufficientStorage.
+  void Invalidate() {
+    CHECK_EQ(buf_, buf_st_);
+    length_ = 0;
+    buf_ = nullptr;
+  }
+
+  MaybeStackBuffer() : length_(0), buf_(buf_st_) {
+    // Default to a zero-length, null-terminated buffer.
+    buf_[0] = T();
+  }
+
+  ~MaybeStackBuffer() {
+    if (buf_ != buf_st_)
+      free(buf_);
+  }
 
-  private:
-    size_t length_;
-    T* buf_;
-    T buf_st_[kStackStorageSize];
+ private:
+  size_t length_;
+  T* buf_;
+  T buf_st_[kStackStorageSize];
 };
 
 class Utf8Value : public MaybeStackBuffer<char> {
-  public:
-    explicit Utf8Value(v8::Isolate* isolate, v8::Local<v8::Value> value);
+ public:
+  explicit Utf8Value(v8::Isolate* isolate, v8::Local<v8::Value> value);
 };
 
 class TwoByteValue : public MaybeStackBuffer<uint16_t> {
-  public:
-    explicit TwoByteValue(v8::Isolate* isolate, v8::Local<v8::Value> value);
+ public:
+  explicit TwoByteValue(v8::Isolate* isolate, v8::Local<v8::Value> value);
 };
 
 class BufferValue : public MaybeStackBuffer<char> {
-  public:
-    explicit BufferValue(v8::Isolate* isolate, v8::Local<v8::Value> value);
+ public:
+  explicit BufferValue(v8::Isolate* isolate, v8::Local<v8::Value> value);
 };
 
 }  // namespace node