Implement recursive directory deletion.

runtime/bin/directory_impl.dart

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// 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.
 
 
 // Used for holding error code and error message for failed OS system calls.
 class _OSStatus {
   int _errorCode;
   String _errorMessage;
 }
 
@@ skipping 75 matching lines @@
     } else {
       _replyPort.send(result, port.toSendPort());
     }
   }
 
   String _path;
 }
 
 
 class _DirDeleteOperation extends _DirectoryOperation {
-  _DirDeleteOperation(String this._path);
+  _DirDeleteOperation(String this._path, bool this._recursive);
 
   void execute(ReceivePort port) {
-    _replyPort.send(_Directory._delete(_path), port.toSendPort());
+    _replyPort.send(_Directory._delete(_path, _recursive), port.toSendPort());
   }
 
   String _path;
+  bool _recursive;
 }
 
 
 class _DirectoryOperationIsolate extends Isolate {
   _DirectoryOperationIsolate() : super.heavy();
 
   void handleOperation(_DirectoryOperation message, SendPort ignored) {
     message.execute(port);
     port.receive(handleOperation);
   }
@@ skipping 44 matching lines @@
 
 class _Directory implements Directory {
 
   _Directory(String this._path)
       : _scheduler = new _DirectoryOperationScheduler();
 
   static String _createTemp(String template,
                             _OSStatus status) native "Directory_CreateTemp";
   static int _exists(String path) native "Directory_Exists";
   static bool _create(String path) native "Directory_Create";
-  static bool _delete(String path) native "Directory_Delete";
+  static bool _delete(String path, bool recursive) native "Directory_Delete";
 
   void exists() {
-    var handler = (_existsHandler != null) ? _existsHandler : (result) => null;
     var operation = new _DirExistsOperation(_path);
     _scheduler.enqueue(operation, (result, ignored) {
+      var handler =
+          (_existsHandler != null) ? _existsHandler : (result) => null;
       if (result < 0) {
         if (_errorHandler != null) {
           _errorHandler("Diretory exists test failed: $_path");
         }
       } else {
         handler(result == 1);
       }
     });
   }
 
   bool existsSync() {
     int exists = _exists(_path);
     if (exists < 0) {
       throw new DirectoryException("Diretory exists test failed: $_path");
     }
     return (exists == 1);
   }
 
   void create() {
-    var handler = (_createHandler != null) ? _createHandler : () => null;
     var operation = new _DirCreateOperation(_path);
     _scheduler.enqueue(operation, (result, ignored) {
+      var handler = (_createHandler != null) ? _createHandler : () => null;
       if (result) {
         handler();
       } else if (_errorHandler != null) {
         _errorHandler("Directory creation failed: $_path");
       }
     });
   }
 
   void createSync() {
     if (!_create(_path)) {
       throw new DirectoryException("Directory creation failed: $_path");
     }
   }
 
   void createTemp() {
-    var handler =
-        (_createTempHandler != null) ? _createTempHandler : () => null;
     var operation = new _DirCreateTempOperation(_path);
     _scheduler.enqueue(operation, (result, ignored) {
+      var handler =
+          (_createTempHandler != null) ? _createTempHandler : () => null;
       if (result is !_OSStatus) {
         _path = result;
         handler();
       } else if (_errorHandler !== null) {
         _errorHandler("Could not create temporary directory [$_path]: " +
                       "${result._errorMessage}");
       }
     });
   }
 
   void createTempSync() {
     var status = new _OSStatus();
     var result = _createTemp(path, status);
     if (result != null) {
       _path = result;
     } else {
       throw new DirectoryException(
           "Could not create temporary directory [$_path]: " +
           "${status._errorMessage}",
           status._errorCode);
     }
   }
 
-  void delete() {
-    var handler = (_deleteHandler != null) ? _deleteHandler : () => null;
-    var operation = new _DirDeleteOperation(_path);
+  void delete([bool recursive = false]) {
+    var operation = new _DirDeleteOperation(_path, recursive);
     _scheduler.enqueue(operation, (result, ignored) {
+      var handler = (_deleteHandler != null) ? _deleteHandler : () => null;
       if (result) {
         handler();
       } else if (_errorHandler != null) {
-        _errorHandler("Directory deletion failed: $_path");
+        if (recursive) {
+          _errorHandler("Recursive directory deletion failed: $_path");
+        } else {
+          _errorHandler("Non-recursive directory deletion failed: $_path");
+        }
       }
     });
   }
 
-  void deleteSync() {
-    if (!_delete(_path)) {
+  void deleteSync([bool recursive = false]) {
+    if (!_delete(_path, recursive)) {
       throw new DirectoryException("Directory deletion failed: $_path");
     }
   }
 
   void list([bool recursive = false]) {
     new _DirectoryListingIsolate().spawn().then((port) {
       // Build a map of parameters to the directory listing isolate.
       Map listingParameters = new Map();
       listingParameters['dir'] = _path;
       listingParameters['recursive'] = recursive;
@@ skipping 100 matching lines @@
   var _doneHandler;
   var _existsHandler;
   var _createHandler;
   var _createTempHandler;
   var _deleteHandler;
   var _errorHandler;
 
   String _path;
   _DirectoryOperationScheduler _scheduler;
 }