Cleanup in //runtime/bin

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.
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_MACOS)
 
 #include "bin/file_system_watcher.h"
 
 #if !TARGET_OS_IOS
 
 #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
 };
 enum {
   kFSEventStreamEventFlagItemCreated = 0x00000100,
   kFSEventStreamEventFlagItemRemoved = 0x00000200,
   kFSEventStreamEventFlagItemInodeMetaMod = 0x00000400,
   kFSEventStreamEventFlagItemRenamed = 0x00000800,
   kFSEventStreamEventFlagItemModified = 0x00001000,
   kFSEventStreamEventFlagItemFinderInfoMod = 0x00002000,
   kFSEventStreamEventFlagItemChangeOwner = 0x00004000,
   kFSEventStreamEventFlagItemXattrMod = 0x00008000,
   kFSEventStreamEventFlagItemIsFile = 0x00010000,
   kFSEventStreamEventFlagItemIsDir = 0x00020000,
   kFSEventStreamEventFlagItemIsSymlink = 0x00040000
 };
 #endif
 
-
 namespace dart {
 namespace bin {
 
 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),
           ready_(false),
           base_path_length_(strlen(base_path)),
           path_ref_(CFStringCreateWithCString(
@@ skipping 105 matching lines @@
 
    private:
     FSEventsWatcher* watcher_;
     bool ready_;
     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();
@@ skipping 87 matching lines @@
                        void* client,
                        size_t num_events,
                        void* event_paths,
                        const FSEventStreamEventFlags event_flags[],
                        const FSEventStreamEventId event_ids[]) {
     Node* node = reinterpret_cast<Node*>(client);
     ASSERT(Thread::Compare(node->watcher()->threadId_,
                            Thread::GetCurrentThreadId()));
     // `ready` is set on same thread as this callback is invoked, so we don't
     // need to lock here.
-    if (!node->ready()) return;
+    if (!node->ready()) {
+      return;
+    }
     for (size_t i = 0; i < num_events; i++) {
       char *path = reinterpret_cast<char**>(event_paths)[i];
       FSEvent event;
       event.data.exists = File::GetType(path, false) != File::kDoesNotExist;
       path += node->base_path_length();
       // If path is longer the base, skip next character ('/').
-      if (path[0] != '\0') path += 1;
-      if (!node->recursive() && strstr(path, "/") != NULL) continue;
+      if (path[0] != '\0') {
+        path += 1;
+      }
+      if (!node->recursive() && (strstr(path, "/") != NULL)) {
+        continue;
+      }
       event.data.flags = event_flags[i];
       memmove(event.data.path, path, strlen(path) + 1);
       write(node->write_fd(), event.bytes, sizeof(event));
     }
   }
 
   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() {
@@ skipping 23 matching lines @@
 
 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);
+  if (count <= 0) {
+    return Dart_NewList(0);
+  }
   Dart_Handle events = Dart_NewList(count);
   FSEvent e;
   for (int i = 0; i < count; i++) {
     intptr_t bytes = TEMP_FAILURE_RETRY(read(fd, e.bytes, sizeof(e)));
     if (bytes < 0) {
       return DartUtils::NewDartOSError();
     }
     size_t path_len = strlen(e.data.path);
     Dart_Handle event = Dart_NewList(5);
     int flags = e.data.flags;
     int mask = 0;
-    if (flags & kFSEventStreamEventFlagItemRenamed) {
+    if ((flags & kFSEventStreamEventFlagItemRenamed) != 0) {
       if (path_len == 0) {
         // The moved path is the path being watched.
         mask |= kDeleteSelf;
       } else {
         mask |= e.data.exists ? kCreate : kDelete;
       }
     }
-    if (flags & kFSEventStreamEventFlagItemModified) mask |= kModifyContent;
-    if (flags & kFSEventStreamEventFlagItemXattrMod) mask |= kModefyAttribute;
-    if (flags & kFSEventStreamEventFlagItemCreated) mask |= kCreate;
-    if (flags & kFSEventStreamEventFlagItemIsDir) mask |= kIsDir;
-    if (flags & kFSEventStreamEventFlagItemRemoved) {
+    if ((flags & kFSEventStreamEventFlagItemModified) != 0) {
+      mask |= kModifyContent;
+    }
+    if ((flags & kFSEventStreamEventFlagItemXattrMod) != 0) {
+      mask |= kModefyAttribute;
+    }
+    if ((flags & kFSEventStreamEventFlagItemCreated) != 0) {
+      mask |= kCreate;
+    }
+    if ((flags & kFSEventStreamEventFlagItemIsDir) != 0) {
+      mask |= kIsDir;
+    }
+    if ((flags & kFSEventStreamEventFlagItemRemoved) != 0) {
       if (path_len == 0) {
         // The removed path is the path being watched.
         mask |= kDeleteSelf;
       } else {
         mask |= kDelete;
       }
     }
     Dart_ListSetAt(event, 0, Dart_NewInteger(mask));
     Dart_ListSetAt(event, 1, Dart_NewInteger(1));
     Dart_ListSetAt(event, 2, Dart_NewStringFromUTF8(
@@ skipping 11 matching lines @@
 #else  // !TARGET_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  // !TARGET_OS_IOS
-
 #endif  // defined(TARGET_OS_MACOS)