Support devFS writes via HTTP PUT

sdk/lib/vmservice/vmservice.dart

 // Copyright (c) 2015, 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 dart._vmservice;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:isolate';
@@ skipping 98 matching lines @@
 
 /// Called to create a temporary directory
 typedef Future<Uri> CreateTempDirCallback(String base);
 
 /// Called to delete a directory
 typedef Future DeleteDirCallback(Uri path);
 
 /// Called to write a file.
 typedef Future WriteFileCallback(Uri path, List<int> bytes);
 
+/// Called to write a stream into a file.
+typedef Future WriteStreamFileCallback(Uri path, Stream<List<int>> bytes);
+
 /// Called to read a file.
 typedef Future<List<int>> ReadFileCallback(Uri path);
 
 /// Called to list all files under some path.
 typedef Future<List<Map<String,String>>> ListFilesCallback(Uri path);
 
 /// Hooks that are setup by the embedder.
 class VMServiceEmbedderHooks {
   static ServerStartCallback serverStart;
   static ServerStopCallback serverStop;
   static CleanupCallback cleanup;
   static CreateTempDirCallback createTempDir;
   static DeleteDirCallback deleteDir;
   static WriteFileCallback writeFile;
+  static WriteStreamFileCallback writeStreamFile;
   static ReadFileCallback readFile;
   static ListFilesCallback listFiles;
 }
 
 class VMService extends MessageRouter {
   static VMService _instance;
 
   /// Collection of currently connected clients.
   final Set<Client> clients = new Set<Client>();
 
   /// Collection of currently running isolates.
   RunningIsolates runningIsolates = new RunningIsolates();
 
   /// A port used to receive events from the VM.
   final RawReceivePort eventPort;
 
-  final _devfs = new DevFS();
+  final devfs = new DevFS();
 
   void _addClient(Client client) {
     assert(client.streams.isEmpty);
     clients.add(client);
   }
 
   void _removeClient(Client client) {
     clients.remove(client);
     for (var streamId in client.streams) {
       if (!_isAnyClientSubscribed(streamId)) {
@@ skipping 39 matching lines @@
     // Close receive ports.
     isolateLifecyclePort.close();
     scriptLoadPort.close();
 
     // Create a copy of the set as a list because client.disconnect() will
     // alter the connected clients set.
     var clientsList = clients.toList();
     for (var client in clientsList) {
       client.disconnect();
     }
-    _devfs.cleanup();
+    devfs.cleanup();
     if (VMServiceEmbedderHooks.cleanup != null) {
       await VMServiceEmbedderHooks.cleanup();
     }
     // Notify the VM that we have exited.
     _onExit();
   }
 
   void messageHandler(message) {
     if (message is List) {
       if (message.length == 2) {
@@ skipping 174 matching lines @@
     }
     if (message.method == 'streamListen') {
       return _streamListen(message);
     }
     if (message.method == 'streamCancel') {
       return _streamCancel(message);
     }
     if (message.method == '_spawnUri') {
       return _spawnUri(message);
     }
-    if (_devfs.shouldHandleMessage(message)) {
-      return _devfs.handleMessage(message);
+    if (devfs.shouldHandleMessage(message)) {
+      return devfs.handleMessage(message);
     }
     if (message.params['isolateId'] != null) {
       return runningIsolates.route(message);
     }
     return message.sendToVM();
   }
 }
 
 RawReceivePort boot() {
   // Return the port we expect isolate startup and shutdown messages on.
@@ skipping 18 matching lines @@
 external bool _vmListenStream(String streamId);
 
 /// Cancel a subscription to a service stream.
 external void _vmCancelStream(String streamId);
 
 /// Get the bytes to the tar archive.
 external Uint8List _requestAssets();
 
 /// Notify the vm service that an isolate has been spawned via rpc.
 external void _spawnUriNotify(obj, String token);