VM: Re-format to use at most one newline between functions

runtime/bin/file_system_watcher_macos.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #if !defined(DART_IO_DISABLED)
 
 #include "platform/globals.h"
 #if defined(HOST_OS_MACOS)
 
 #include "bin/file_system_watcher.h"
 
 #if !HOST_OS_IOS
 
+#include <CoreServices/CoreServices.h>  // NOLINT
 #include <errno.h>                      // NOLINT
 #include <fcntl.h>                      // NOLINT
 #include <unistd.h>                     // NOLINT
-#include <CoreServices/CoreServices.h>  // NOLINT
 
 #include "bin/eventhandler.h"
 #include "bin/fdutils.h"
 #include "bin/file.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "platform/signal_blocker.h"
 
 #ifndef MAC_OS_X_VERSION_10_7
 enum { kFSEventStreamCreateFlagFileEvents = 0x00000010 };
@@ skipping 17 matching lines @@
 
 union FSEvent {
   struct {
     uint32_t exists;
     uint32_t flags;
     char path[PATH_MAX];
   } data;
   uint8_t bytes[PATH_MAX + 8];
 };
 
-
 class FSEventsWatcher {
  public:
   class Node {
    public:
     Node(FSEventsWatcher* watcher,
          char* base_path,
          int read_fd,
          int write_fd,
          bool recursive)
         : watcher_(watcher),
@@ skipping 104 matching lines @@
     intptr_t base_path_length_;
     CFStringRef path_ref_;
     int read_fd_;
     int write_fd_;
     bool recursive_;
     FSEventStreamRef ref_;
 
     DISALLOW_COPY_AND_ASSIGN(Node);
   };
 
-
   FSEventsWatcher() : run_loop_(0) { Start(); }
 
   void Start() {
     Thread::Start(Run, reinterpret_cast<uword>(this));
     monitor_.Enter();
     while (run_loop_ == NULL) {
       monitor_.Wait(Monitor::kNoTimeout);
     }
     monitor_.Exit();
   }
@@ skipping 101 matching lines @@
     }
   }
 
   Monitor monitor_;
   CFRunLoopRef run_loop_;
   ThreadId threadId_;
 
   DISALLOW_COPY_AND_ASSIGN(FSEventsWatcher);
 };
 
-
 #define kCFCoreFoundationVersionNumber10_7 635.00
 bool FileSystemWatcher::IsSupported() {
   return kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber10_7;
 }
 
-
 intptr_t FileSystemWatcher::Init() {
   return reinterpret_cast<intptr_t>(new FSEventsWatcher());
 }
 
-
 void FileSystemWatcher::Close(intptr_t id) {
   delete reinterpret_cast<FSEventsWatcher*>(id);
 }
 
-
 intptr_t FileSystemWatcher::WatchPath(intptr_t id,
                                       const char* path,
                                       int events,
                                       bool recursive) {
   FSEventsWatcher* watcher = reinterpret_cast<FSEventsWatcher*>(id);
   return reinterpret_cast<intptr_t>(watcher->AddPath(path, events, recursive));
 }
 
-
 void FileSystemWatcher::UnwatchPath(intptr_t id, intptr_t path_id) {
   USE(id);
   delete reinterpret_cast<FSEventsWatcher::Node*>(path_id);
 }
 
-
 intptr_t FileSystemWatcher::GetSocketId(intptr_t id, intptr_t path_id) {
   return reinterpret_cast<FSEventsWatcher::Node*>(path_id)->read_fd();
 }
 
-
 Dart_Handle FileSystemWatcher::ReadEvents(intptr_t id, intptr_t path_id) {
   intptr_t fd = GetSocketId(id, path_id);
   intptr_t avail = FDUtils::AvailableBytes(fd);
   int count = avail / sizeof(FSEvent);
   if (count <= 0) {
     return Dart_NewList(0);
   }
   Dart_Handle events = Dart_NewList(count);
   FSEvent e;
   for (int i = 0; i < count; i++) {
@@ skipping 51 matching lines @@
 #else  // !HOST_OS_IOS
 
 namespace dart {
 namespace bin {
 
 // FSEvents are unavailable on iOS. Stub out related methods
 Dart_Handle FileSystemWatcher::ReadEvents(intptr_t id, intptr_t path_id) {
   return DartUtils::NewDartOSError();
 }
 
-
 intptr_t FileSystemWatcher::GetSocketId(intptr_t id, intptr_t path_id) {
   return -1;
 }
 
-
 bool FileSystemWatcher::IsSupported() {
   return false;
 }
 
-
 void FileSystemWatcher::UnwatchPath(intptr_t id, intptr_t path_id) {}
 
-
 intptr_t FileSystemWatcher::Init() {
   return -1;
 }
 
-
 void FileSystemWatcher::Close(intptr_t id) {}
 
-
 intptr_t FileSystemWatcher::WatchPath(intptr_t id,
                                       const char* path,
                                       int events,
                                       bool recursive) {
   return -1;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // !HOST_OS_IOS
 #endif  // defined(HOST_OS_MACOS)
 
 #endif  // !defined(DART_IO_DISABLED)