Rate limit devfs writes

runtime/bin/vmservice/vmservice_io.dart

 // 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.
 
 library vmservice_io;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
@@ skipping 53 matching lines @@
 Future<Uri> createTempDirCallback(String base) async {
   Directory temp = await Directory.systemTemp.createTemp(base);
   return temp.uri;
 }
 
 Future deleteDirCallback(Uri path) async {
   Directory dir = new Directory.fromUri(path);
   await dir.delete(recursive: true);
 }
 
+class PendingWrite {
+  PendingWrite(this.uri, this.bytes);
+  final Completer completer = new Completer();
+  final Uri uri;
+  final List<int> bytes;
+
+  Future write() async {
+    var file = new File.fromUri(uri);
+    var parent_directory = file.parent;
+    await parent_directory.create(recursive: true);
+    var result = await file.writeAsBytes(bytes);
+    completer.complete(null);
+    WriteLimiter._writeCompleted();
+  }
+}
+
+class WriteLimiter {
+  static final List<PendingWrite> pendingWrites = new List<PendingWrite>();
+
+  // non-rooted Android devices have a very low limit for the number of
+  // open files. Artificially cap ourselves to 16.
+  static const kMaxOpenWrites = 16;
+  static int openWrites = 0;
+
+  static Future scheduleWrite(Uri path, List<int> bytes) async {
+    // Create a new pending write.
+    PendingWrite pw = new PendingWrite(path, bytes);
+    pendingWrites.add(pw);
+    _maybeWriteFiles();
+    return pw.completer.future;
+  }
+
+  static _maybeWriteFiles() {
+    while (openWrites < kMaxOpenWrites) {
+      if (pendingWrites.length > 0) {
+        PendingWrite pw = pendingWrites.removeLast();
+        pw.write();
+        openWrites++;
+      } else {
+        break;
+      }
+    }
+  }
+
+  static _writeCompleted() {
+    openWrites--;
+    assert(openWrites >= 0);
+    _maybeWriteFiles();
+  }
+}
+
 Future writeFileCallback(Uri path, List<int> bytes) async {
-  var file = new File.fromUri(path);
-  var parent_directory = file.parent;
-  await parent_directory.create(recursive: true);
-  await file.writeAsBytes(bytes);
+  return WriteLimiter.scheduleWrite(path, bytes);
 }
 
 Future<List<int>> readFileCallback(Uri path) async {
   var file = new File.fromUri(path);
   return await file.readAsBytes();
 }
 
 Future<List<Map<String,String>>> listFilesCallback(Uri dirPath) async {
   var dir = new Directory.fromUri(dirPath);
   var dirPathStr = dirPath.path;
@@ skipping 66 matching lines @@
     Timer.run(() {});
   }
   scriptLoadPort.handler = _processLoadRequest;
   // Register signal handler after a small delay to avoid stalling main
   // isolate startup.
   _registerSignalHandlerTimer = new Timer(shortDelay, _registerSignalHandler);
   return scriptLoadPort;
 }
 
 _shutdown() native "VMServiceIO_Shutdown";