Fixes leak of native File objects.

runtime/bin/file.h

 // 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.
 
 #ifndef BIN_FILE_H_
 #define BIN_FILE_H_
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
+#include "bin/log.h"
+#include "bin/reference_counting.h"
 
 namespace dart {
 namespace bin {
 
 // Forward declaration.
 class FileHandle;
 
-class File {
+class File : public ReferenceCounted<File> {
  public:
   enum FileOpenMode {
     kRead = 0,
     kWrite = 1,
     kTruncate = 1 << 2,
     kWriteOnly = 1 << 3,
     kWriteTruncate = kWrite | kTruncate,
     kWriteOnlyTruncate = kWriteOnly | kTruncate
   };
 
@@ skipping 42 matching lines @@
 
   enum LockType {
     // These match the constants in FileStat in file_impl.dart.
     kLockMin = 0,
     kLockUnlock = 0,
     kLockShared = 1,
     kLockExclusive = 2,
     kLockMax = 2
   };
 
-  ~File();
-
   intptr_t GetFD();
 
   // Read/Write attempt to transfer num_bytes to/from buffer. It returns
   // the number of bytes read/written.
   int64_t Read(void* buffer, int64_t num_bytes);
   int64_t Write(const void* buffer, int64_t num_bytes);
 
   // ReadFully and WriteFully do attempt to transfer num_bytes to/from
   // the buffer. In the event of short accesses they will loop internally until
   // the whole buffer has been transferred or an error occurs. If an error
@@ skipping 20 matching lines @@
 
   // Flush contents of file.
   bool Flush();
 
   // Lock range of a file.
   bool Lock(LockType lock, int64_t start, int64_t end);
 
   // Returns whether the file has been closed.
   bool IsClosed();
 
+  // Calls the platform-specific functions to close the file.
+  void Close();
+
+  // Returns the weak persistent handle for the File's Dart wrapper.
+  Dart_WeakPersistentHandle WeakHandle() const { return weak_handle_; }
+
+  // Set the weak persistent handle for the File's Dart wrapper.
+  void SetWeakHandle(Dart_WeakPersistentHandle handle) {
+    ASSERT(weak_handle_ == NULL);
+    weak_handle_ = handle;
+  }
+
+  // Deletes the weak persistent handle for the File's Dart wrapper. Call
+  // when the file is explicitly closed and the finalizer is no longer
+  // needed.
+  void DeleteWeakHandle(Dart_Isolate isolate) {
+    Dart_DeleteWeakPersistentHandle(isolate, weak_handle_);
+    weak_handle_ = NULL;
+  }
+
   // Open the file with the given path. The file is always opened for
   // reading. If mode contains kWrite the file is opened for both
   // reading and writing. If mode contains kWrite and the file does
   // not exist the file is created. The file is truncated to length 0 if
   // mode contains kTruncate. Assumes we are in an API scope.
   static File* ScopedOpen(const char* path, FileOpenMode mode);
 
   // Like ScopedOpen(), but no API scope is needed.
   static File* Open(const char* path, FileOpenMode mode);
 
@@ skipping 46 matching lines @@
   static CObject* CreateLinkRequest(const CObjectArray& request);
   static CObject* DeleteLinkRequest(const CObjectArray& request);
   static CObject* RenameLinkRequest(const CObjectArray& request);
   static CObject* LinkTargetRequest(const CObjectArray& request);
   static CObject* TypeRequest(const CObjectArray& request);
   static CObject* IdenticalRequest(const CObjectArray& request);
   static CObject* StatRequest(const CObjectArray& request);
   static CObject* LockRequest(const CObjectArray& request);
 
  private:
-  explicit File(FileHandle* handle) : handle_(handle) { }
-  void Close();
+  explicit File(FileHandle* handle) :
+      ReferenceCounted(),
+      handle_(handle),
+      weak_handle_(NULL) {}
+
+  ~File();
 
   static File* FileOpenW(const wchar_t* system_name, FileOpenMode mode);
 
   static const int kClosedFd = -1;
 
   // FileHandle is an OS specific class which stores data about the file.
   FileHandle* handle_;  // OS specific handle for the file.
 
+  // We retain the weak handle because we can do cleanup eagerly when Dart code
+  // calls closeSync(). In that case, we delete the weak handle so that the
+  // finalizer doesn't run.
+  Dart_WeakPersistentHandle weak_handle_;
+
+  friend class ReferenceCounted<File>;
   DISALLOW_COPY_AND_ASSIGN(File);
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // BIN_FILE_H_