Fixes some memory leaks in //runtime/bin

runtime/bin/file_macos.cc

 // Copyright (c) 2012, 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.h"
 
 #include <errno.h>  // NOLINT
@@ skipping 96 matching lines @@
 
 
 bool File::Flush() {
   ASSERT(handle_->fd() >= 0);
   return NO_RETRY_EXPECTED(fsync(handle_->fd())) != -1;
 }
 
 
 bool File::Lock(File::LockType lock, int64_t start, int64_t end) {
   ASSERT(handle_->fd() >= 0);
-  ASSERT(end == -1 || end > start);
+  ASSERT((end == -1) || (end > start));
   struct flock fl;
   switch (lock) {
     case File::kLockUnlock:
       fl.l_type = F_UNLCK;
       break;
     case File::kLockShared:
       fl.l_type = F_RDLCK;
       break;
     case File::kLockExclusive:
       fl.l_type = F_WRLCK;
@@ skipping 13 matching lines @@
 int64_t File::Length() {
   ASSERT(handle_->fd() >= 0);
   struct stat st;
   if (NO_RETRY_EXPECTED(fstat(handle_->fd(), &st)) == 0) {
     return st.st_size;
   }
   return -1;
 }
 
 
-File* File::Open(const char* name, FileOpenMode mode) {
+File* File::FileOpenW(const wchar_t* system_name, FileOpenMode mode) {
+  UNREACHABLE();
+  return NULL;
+}
+
+
+File* File::ScopedOpen(const char* name, FileOpenMode mode) {
   // Report errors for non-regular files.
   struct stat st;
   if (NO_RETRY_EXPECTED(stat(name, &st)) == 0) {
     // Only accept regular files and character devices.
     if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
       errno = (S_ISDIR(st.st_mode)) ? EISDIR : ENOENT;
       return NULL;
     }
   }
   int flags = O_RDONLY;
@@ skipping 17 matching lines @@
       (((mode & kWriteOnly) != 0) && ((mode & kTruncate) == 0))) {
     int64_t position = lseek(fd, 0, SEEK_END);
     if (position < 0) {
       return NULL;
     }
   }
   return new File(new FileHandle(fd));
 }
 
 
+File* File::Open(const char* path, FileOpenMode mode) {
+  // ScopedOpen doesn't actually need a scope.
+  return ScopedOpen(path, mode);
+}
+
+
 File* File::OpenStdio(int fd) {
-  if (fd < 0 || 2 < fd) return NULL;
+  if ((fd < 0) || (2 < fd)) {
+    return NULL;
+  }
   return new File(new FileHandle(fd));
 }
 
 
 bool File::Exists(const char* name) {
   struct stat st;
   if (NO_RETRY_EXPECTED(stat(name, &st)) == 0) {
     return S_ISREG(st.st_mode);
   } else {
     return false;
@@ skipping 121 matching lines @@
 
 time_t File::LastModified(const char* name) {
   struct stat st;
   if (NO_RETRY_EXPECTED(stat(name, &st)) == 0) {
     return st.st_mtime;
   }
   return -1;
 }
 
 
-char* File::LinkTarget(const char* pathname) {
+const char* File::LinkTarget(const char* pathname) {
   struct stat link_stats;
-  if (lstat(pathname, &link_stats) != 0) return NULL;
+  if (lstat(pathname, &link_stats) != 0) {
+    return NULL;
+  }
   if (!S_ISLNK(link_stats.st_mode)) {
     errno = ENOENT;
     return NULL;
   }
   // Don't rely on the link_stats.st_size for the size of the link
   // target. The link might have changed before the readlink call.
   const int kBufferSize = 1024;
   char target[kBufferSize];
   size_t target_size = TEMP_FAILURE_RETRY(
       readlink(pathname, target, kBufferSize));
   if (target_size <= 0) {
     return NULL;
   }
-  char* target_name = reinterpret_cast<char*>(malloc(target_size + 1));
-  if (target_name == NULL) {
-    return NULL;
-  }
+  char* target_name = DartUtils::ScopedCString(target_size + 1);
+  ASSERT(target_name != NULL);
   memmove(target_name, target, target_size);
   target_name[target_size] = '\0';
   return target_name;
 }
 
 
 bool File::IsAbsolutePath(const char* pathname) {
   return (pathname != NULL && pathname[0] == '/');
 }
 
 
-char* File::GetCanonicalPath(const char* pathname) {
+const char* File::GetCanonicalPath(const char* pathname) {
   char* abs_path = NULL;
   if (pathname != NULL) {
     // On some older MacOs versions the default behaviour of realpath allocating
     // space for the resolved_path when a NULL is passed in does not seem to
-    // work, so we explicitly allocate space. The caller is responsible for
-    // freeing this space as in a regular realpath call.
-    char* resolved_path = reinterpret_cast<char*>(malloc(PATH_MAX + 1));
+    // work, so we explicitly allocate space.
+    char* resolved_path = DartUtils::ScopedCString(PATH_MAX + 1);
     ASSERT(resolved_path != NULL);
     do {
-      abs_path = realpath(pathname, NULL);
-    } while (abs_path == NULL && errno == EINTR);
-    ASSERT(abs_path == NULL || IsAbsolutePath(abs_path));
+      abs_path = realpath(pathname, resolved_path);
+    } while ((abs_path == NULL) && (errno == EINTR));
+    ASSERT((abs_path == NULL) || IsAbsolutePath(abs_path));
+    ASSERT((abs_path == NULL) || (abs_path == resolved_path));
   }
   return abs_path;
 }
 
 
 const char* File::PathSeparator() {
   return "/";
 }
 
 
 const char* File::StringEscapedPathSeparator() {
   return "/";
 }
 
 
 File::StdioHandleType File::GetStdioHandleType(int fd) {
-  ASSERT(0 <= fd && fd <= 2);
+  ASSERT((0 <= fd) && (fd <= 2));
   struct stat buf;
   int result = fstat(fd, &buf);
   if (result == -1) {
     const int kBufferSize = 1024;
     char error_message[kBufferSize];
     Utils::StrError(errno, error_message, kBufferSize);
     FATAL2("Failed stat on file descriptor %d: %s", fd, error_message);
   }
-  if (S_ISCHR(buf.st_mode)) return kTerminal;
-  if (S_ISFIFO(buf.st_mode)) return kPipe;
-  if (S_ISSOCK(buf.st_mode)) return kSocket;
-  if (S_ISREG(buf.st_mode)) return kFile;
+  if (S_ISCHR(buf.st_mode)) {
+    return kTerminal;
+  }
+  if (S_ISFIFO(buf.st_mode)) {
+    return kPipe;
+  }
+  if (S_ISSOCK(buf.st_mode)) {
+    return kSocket;
+  }
+  if (S_ISREG(buf.st_mode)) {
+    return kFile;
+  }
   return kOther;
 }
 
 
 File::Type File::GetType(const char* pathname, bool follow_links) {
   struct stat entry_info;
   int stat_success;
   if (follow_links) {
     stat_success = NO_RETRY_EXPECTED(stat(pathname, &entry_info));
   } else {
     stat_success = NO_RETRY_EXPECTED(lstat(pathname, &entry_info));
   }
-  if (stat_success == -1) return File::kDoesNotExist;
-  if (S_ISDIR(entry_info.st_mode)) return File::kIsDirectory;
-  if (S_ISREG(entry_info.st_mode)) return File::kIsFile;
-  if (S_ISLNK(entry_info.st_mode)) return File::kIsLink;
+  if (stat_success == -1) {
+    return File::kDoesNotExist;
+  }
+  if (S_ISDIR(entry_info.st_mode)) {
+    return File::kIsDirectory;
+  }
+  if (S_ISREG(entry_info.st_mode)) {
+    return File::kIsFile;
+  }
+  if (S_ISLNK(entry_info.st_mode)) {
+    return File::kIsLink;
+  }
   return File::kDoesNotExist;
 }
 
 
 File::Identical File::AreIdentical(const char* file_1, const char* file_2) {
   struct stat file_1_info;
   struct stat file_2_info;
-  if (NO_RETRY_EXPECTED(lstat(file_1, &file_1_info)) == -1 ||
-      NO_RETRY_EXPECTED(lstat(file_2, &file_2_info)) == -1) {
+  if ((NO_RETRY_EXPECTED(lstat(file_1, &file_1_info)) == -1) ||
+      (NO_RETRY_EXPECTED(lstat(file_2, &file_2_info)) == -1)) {
     return File::kError;
   }
-  return (file_1_info.st_ino == file_2_info.st_ino &&
-          file_1_info.st_dev == file_2_info.st_dev) ?
+  return ((file_1_info.st_ino == file_2_info.st_ino) &&
+          (file_1_info.st_dev == file_2_info.st_dev)) ?
       File::kIdentical :
       File::kDifferent;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_MACOS)