Refactor DevFS for kernel code (#7529)

Refactor DevFS so that it's easier to add new types of content such as kernel code
* add tests for DevFS package scanning
* add tests for DevFS over VMService protocol
* which covers _DevFSHttpWriter and ServiceProtocolDevFSOperations
* replace AssetBundleEntry and DevFSEntry with DevFSContent
* refactor to cleanup common code and replace some fields with locals
* rework .package file generation refactor away DevFSOperations.writeSource
* only update .package file if it has changed
* only write/delete/evict assets that have been changed/removed

packages/flutter_tools/lib/src/asset.dart

@@ -12,45 +12,20 @@ import 'package:yaml/yaml.dart';
 import 'base/file_system.dart';
 import 'build_info.dart';
 import 'cache.dart';
+import 'devfs.dart';
 import 'dart/package_map.dart';
 import 'globals.dart';
 
-/// An entry in an asset bundle.
-class AssetBundleEntry {
-  /// An entry backed by a File.
-  AssetBundleEntry.fromFile(this.archivePath, this.file)
-      : _contents = null;
-
-  /// An entry backed by a String.
-  AssetBundleEntry.fromString(this.archivePath, this._contents)
-      : file = null;
-
-  /// The path within the bundle.
-  final String archivePath;
-
-  /// The payload.
-  List<int> contentsAsBytes() {
-    if (_contents != null) {
-      return UTF8.encode(_contents);
-    } else {
-      return file.readAsBytesSync();
-    }
-  }
-
-  bool get isStringEntry => _contents != null;
-  int get contentsLength => _contents.length;
-
-  final File file;
-  final String _contents;
-}
-
 /// A bundle of assets.
 class AssetBundle {
-  final Set<AssetBundleEntry> entries = new Set<AssetBundleEntry>();
+  final Map<String, DevFSContent> entries = <String, DevFSContent>{};
 
   static const String defaultManifestPath = 'flutter.yaml';
+  static const String _kAssetManifestJson = 'AssetManifest.json';
+  static const String _kFontManifestJson = 'FontManifest.json';
   static const String _kFontSetMaterial = 'material';
   static const String _kFontSetRoboto = 'roboto';
+  static const String _kLICENSE = 'LICENSE';
 
   bool _fixed = false;
   DateTime _lastBuildTimestamp;
@@ -73,8 +48,7 @@ class AssetBundle {
         continue;
       final String assetPath = path.join(projectRoot, asset);
       final String archivePath = asset;
-      entries.add(
-          new AssetBundleEntry.fromFile(archivePath, fs.file(assetPath)));
+      entries[archivePath] = new DevFSFileContent(fs.file(assetPath));
     }
   }
 
@@ -111,7 +85,7 @@ class AssetBundle {
     }
     if (manifest == null) {
       // No manifest file found for this application.
-      entries.add(new AssetBundleEntry.fromString('AssetManifest.json', '{}'));
+      entries[_kAssetManifestJson] = new DevFSStringContent('{}');
       return 0;
     }
     if (manifest != null) {
@@ -141,16 +115,11 @@ class AssetBundle {
         manifestDescriptor['uses-material-design'];
 
     for (_Asset asset in assetVariants.keys) {
-      AssetBundleEntry assetEntry = _createAssetEntry(asset);
-      if (assetEntry == null)
-        return 1;
-      entries.add(assetEntry);
-
+      assert(asset.assetFileExists);
+      entries[asset.assetEntry] = new DevFSFileContent(asset.assetFile);
       for (_Asset variant in assetVariants[asset]) {
-        AssetBundleEntry variantEntry = _createAssetEntry(variant);
-        if (variantEntry == null)
-          return 1;
-        entries.add(variantEntry);
+        assert(variant.assetFileExists);
+        entries[variant.assetEntry] = new DevFSFileContent(variant.assetFile);
       }
     }
 
@@ -161,29 +130,27 @@ class AssetBundle {
         materialAssets.addAll(_getMaterialAssets(_kFontSetRoboto));
     }
     for (_Asset asset in materialAssets) {
-      AssetBundleEntry assetEntry = _createAssetEntry(asset);
-      if (assetEntry == null)
-        return 1;
-      entries.add(assetEntry);
+      assert(asset.assetFileExists);
+      entries[asset.assetEntry] = new DevFSFileContent(asset.assetFile);
     }
 
-    entries.add(_createAssetManifest(assetVariants));
+    entries[_kAssetManifestJson] = _createAssetManifest(assetVariants);
 
-    AssetBundleEntry fontManifest =
+    DevFSContent fontManifest =
         _createFontManifest(manifestDescriptor, usesMaterialDesign, includeDefaultFonts, includeRobotoFonts);
     if (fontManifest != null)
-      entries.add(fontManifest);
+      entries[_kFontManifestJson] = fontManifest;
 
     // TODO(ianh): Only do the following line if we've changed packages or if our LICENSE file changed
-    entries.add(await _obtainLicenses(packageMap, assetBasePath, reportPackages: reportLicensedPackages));
+    entries[_kLICENSE] = await _obtainLicenses(packageMap, assetBasePath, reportPackages: reportLicensedPackages);
 
     return 0;
   }
 
   void dump() {
     printTrace('Dumping AssetBundle:');
-    for (AssetBundleEntry entry in entries) {
-      printTrace(entry.archivePath);
+    for (String archivePath in entries.keys.toList()..sort()) {
+      printTrace(archivePath);
     }
   }
 }
@@ -256,8 +223,8 @@ List<_Asset> _getMaterialAssets(String fontSet) {
 
 final String _licenseSeparator = '\n' + ('-' * 80) + '\n';
 
-/// Returns a AssetBundleEntry representing the license file.
-Future<AssetBundleEntry> _obtainLicenses(
+/// Returns a DevFSContent representing the license file.
+Future<DevFSContent> _obtainLicenses(
   PackageMap packageMap,
   String assetBase,
   { bool reportPackages }
@@ -323,17 +290,10 @@ Future<AssetBundleEntry> _obtainLicenses(
 
   final String combinedLicenses = combinedLicensesList.join(_licenseSeparator);
 
-  return new AssetBundleEntry.fromString('LICENSE', combinedLicenses);
-}
-
-
-/// Create a [AssetBundleEntry] from the given [_Asset]; the asset must exist.
-AssetBundleEntry _createAssetEntry(_Asset asset) {
-  assert(asset.assetFileExists);
-  return new AssetBundleEntry.fromFile(asset.assetEntry, asset.assetFile);
+  return new DevFSStringContent(combinedLicenses);
 }
 
-AssetBundleEntry _createAssetManifest(Map<_Asset, List<_Asset>> assetVariants) {
+DevFSContent _createAssetManifest(Map<_Asset, List<_Asset>> assetVariants) {
   Map<String, List<String>> json = <String, List<String>>{};
   for (_Asset main in assetVariants.keys) {
     List<String> variants = <String>[];
@@ -341,10 +301,10 @@ AssetBundleEntry _createAssetManifest(Map<_Asset, List<_Asset>> assetVariants) {
       variants.add(variant.relativePath);
     json[main.relativePath] = variants;
   }
-  return new AssetBundleEntry.fromString('AssetManifest.json', JSON.encode(json));
+  return new DevFSStringContent(JSON.encode(json));
 }
 
-AssetBundleEntry _createFontManifest(Map<String, dynamic> manifestDescriptor,
+DevFSContent _createFontManifest(Map<String, dynamic> manifestDescriptor,
                              bool usesMaterialDesign,
                              bool includeDefaultFonts,
                              bool includeRobotoFonts) {
@@ -358,7 +318,7 @@ AssetBundleEntry _createFontManifest(Map<String, dynamic> manifestDescriptor,
     fonts.addAll(manifestDescriptor['fonts']);
   if (fonts.isEmpty)
     return null;
-  return new AssetBundleEntry.fromString('FontManifest.json', JSON.encode(fonts));
+  return new DevFSStringContent(JSON.encode(fonts));
 }
 
 /// Given an assetBase location and a flutter.yaml manifest, return a map of

packages/flutter_tools/lib/src/devfs.dart

@@ -27,60 +27,45 @@ class DevFSConfig {
 
 DevFSConfig get devFSConfig => context[DevFSConfig];
 
-// A file that has been added to a DevFS.
-class DevFSEntry {
-  DevFSEntry(this.devicePath, this.file)
-      : bundleEntry = null;
+/// Common superclass for content copied to the device.
+abstract class DevFSContent {
+  bool _exists = true;
 
-  DevFSEntry.bundle(this.devicePath, AssetBundleEntry bundleEntry)
-      : bundleEntry = bundleEntry,
-        file = bundleEntry.file;
+  /// Return `true` if this is the first time this method is called
+  /// or if the entry has been modified since this method was last called.
+  bool get isModified;
 
-  final String devicePath;
-  final AssetBundleEntry bundleEntry;
-  String get assetPath => bundleEntry.archivePath;
+  int get size;
+
+  Future<List<int>> contentsAsBytes();
+
+  Stream<List<int>> contentsAsStream();
+
+  Stream<List<int>> contentsAsCompressedStream() {
+    return contentsAsStream().transform(GZIP.encoder);
+  }
+}
+
+// File content to be copied to the device.
+class DevFSFileContent extends DevFSContent {
+  DevFSFileContent(this.file);
 
   final FileSystemEntity file;
   FileSystemEntity _linkTarget;
   FileStat _fileStat;
-  // When we scanned for files, did this still exist?
-  bool _exists = false;
-  DateTime get lastModified => _fileStat?.modified;
-  bool get _isSourceEntry => file == null;
-  bool get _isAssetEntry => bundleEntry != null;
-  bool get stillExists {
-    if (_isSourceEntry)
-      return true;
-    _stat();
-    return _fileStat.type != FileSystemEntityType.NOT_FOUND;
-  }
-  bool get isModified {
-    if (_isSourceEntry)
-      return true;
 
-    if (_fileStat == null) {
-      _stat();
-      return true;
+  File _getFile() {
+    if (_linkTarget != null) {
+      return _linkTarget;
     }
-    FileStat _oldFileStat = _fileStat;
-    _stat();
-    return _fileStat.modified.isAfter(_oldFileStat.modified);
-  }
-
-  int get size {
-    if (_isSourceEntry) {
-      return bundleEntry.contentsLength;
-    } else {
-      if (_fileStat == null) {
-        _stat();
-      }
-      return _fileStat.size;
+    if (file is Link) {
+      // The link target.
+      return fs.file(file.resolveSymbolicLinksSync());
     }
+    return file;
   }
 
   void _stat() {
-    if (_isSourceEntry)
-      return;
     if (_linkTarget != null) {
       // Stat the cached symlink target.
       _fileStat = _linkTarget.statSync();
@@ -99,48 +84,86 @@ class DevFSEntry {
     }
   }
 
-  File _getFile() {
-    if (_linkTarget != null) {
-      return _linkTarget;
-    }
-    if (file is Link) {
-      // The link target.
-      return fs.file(file.resolveSymbolicLinksSync());
-    }
-    return file;
+  @override
+  bool get isModified {
+    FileStat _oldFileStat = _fileStat;
+    _stat();
+    return _oldFileStat == null || _fileStat.modified.isAfter(_oldFileStat.modified);
   }
 
-  Future<List<int>> contentsAsBytes() async {
-    if (_isSourceEntry)
-      return bundleEntry.contentsAsBytes();
-    final File file = _getFile();
-    return file.readAsBytes();
+  @override
+  int get size {
+    if (_fileStat == null)
+      _stat();
+    return _fileStat.size;
   }
 
-  Stream<List<int>> contentsAsStream() {
-    if (_isSourceEntry) {
-      return new Stream<List<int>>.fromIterable(
-          <List<int>>[bundleEntry.contentsAsBytes()]);
-    }
-    final File file = _getFile();
-    return file.openRead();
+  @override
+  Future<List<int>> contentsAsBytes() => _getFile().readAsBytes();
+
+  @override
+  Stream<List<int>> contentsAsStream() => _getFile().openRead();
+}
+
+/// Byte content to be copied to the device.
+class DevFSByteContent extends DevFSContent {
+  DevFSByteContent(this._bytes);
+
+  List<int> _bytes;
+
+  bool _isModified = true;
+
+  List<int> get bytes => _bytes;
+
+  set bytes(List<int> newBytes) {
+    _bytes = newBytes;
+    _isModified = true;
   }
 
-  Stream<List<int>> contentsAsCompressedStream() {
-    return contentsAsStream().transform(GZIP.encoder);
+  /// Return `true` only once so that the content is written to the device only once.
+  @override
+  bool get isModified {
+    bool modified = _isModified;
+    _isModified = false;
+    return modified;
   }
+
+  @override
+  int get size => _bytes.length;
+
+  @override
+  Future<List<int>> contentsAsBytes() async => _bytes;
+
+  @override
+  Stream<List<int>> contentsAsStream() =>
+      new Stream<List<int>>.fromIterable(<List<int>>[_bytes]);
 }
 
+/// String content to be copied to the device.
+class DevFSStringContent extends DevFSByteContent {
+  DevFSStringContent(String string) : _string = string, super(UTF8.encode(string));
+
+  String _string;
+
+  String get string => _string;
+
+  set string(String newString) {
+    _string = newString;
+    super.bytes = UTF8.encode(_string);
+  }
+
+  @override
+  set bytes(List<int> newBytes) {
+    string = UTF8.decode(newBytes);
+  }
+}
 
 /// Abstract DevFS operations interface.
 abstract class DevFSOperations {
   Future<Uri> create(String fsName);
   Future<dynamic> destroy(String fsName);
-  Future<dynamic> writeFile(String fsName, DevFSEntry entry);
-  Future<dynamic> deleteFile(String fsName, DevFSEntry entry);
-  Future<dynamic> writeSource(String fsName,
-                              String devicePath,
-                              String contents);
+  Future<dynamic> writeFile(String fsName, String devicePath, DevFSContent content);
+  Future<dynamic> deleteFile(String fsName, String devicePath);
 }
 
 /// An implementation of [DevFSOperations] that speaks to the
@@ -163,10 +186,10 @@ class ServiceProtocolDevFSOperations implements DevFSOperations {
   }
 
   @override
-  Future<dynamic> writeFile(String fsName, DevFSEntry entry) async {
+  Future<dynamic> writeFile(String fsName, String devicePath, DevFSContent content) async {
     List<int> bytes;
     try {
-      bytes = await entry.contentsAsBytes();
+      bytes = await content.contentsAsBytes();
     } catch (e) {
       return e;
     }
@@ -175,31 +198,18 @@ class ServiceProtocolDevFSOperations implements DevFSOperations {
       return await vmService.vm.invokeRpcRaw('_writeDevFSFile',
                                              <String, dynamic> {
                                                 'fsName': fsName,
-                                                'path': entry.devicePath,
+                                                'path': devicePath,
                                                 'fileContents': fileContents
                                              });
     } catch (e) {
-      printTrace('DevFS: Failed to write ${entry.devicePath}: $e');
+      printTrace('DevFS: Failed to write $devicePath: $e');
     }
   }
 
   @override
-  Future<dynamic> deleteFile(String fsName, DevFSEntry entry) async {
+  Future<dynamic> deleteFile(String fsName, String devicePath) async {
     // TODO(johnmccutchan): Add file deletion to the devFS protocol.
   }
-
-  @override
-  Future<dynamic> writeSource(String fsName,
-                              String devicePath,
-                              String contents) async {
-    String fileContents = BASE64.encode(UTF8.encode(contents));
-    return await vmService.vm.invokeRpcRaw('_writeDevFSFile',
-                                           <String, dynamic> {
-                                              'fsName': fsName,
-                                              'path': devicePath,
-                                              'fileContents': fileContents
-                                           });
-  }
 }
 
 class _DevFSHttpWriter {
@@ -212,18 +222,18 @@ class _DevFSHttpWriter {
   static const int kMaxInFlight = 6;
 
   int _inFlight = 0;
-  List<DevFSEntry> _outstanding;
+  Map<String, DevFSContent> _outstanding;
   Completer<Null> _completer;
   HttpClient _client;
   int _done;
   int _max;
 
-  Future<Null> write(Set<DevFSEntry> entries,
+  Future<Null> write(Map<String, DevFSContent> entries,
                      {DevFSProgressReporter progressReporter}) async {
     _client = new HttpClient();
     _client.maxConnectionsPerHost = kMaxInFlight;
     _completer = new Completer<Null>();
-    _outstanding = entries.toList();
+    _outstanding = new Map<String, DevFSContent>.from(entries);
     _done = 0;
     _max = _outstanding.length;
     _scheduleWrites(progressReporter);
@@ -233,30 +243,32 @@ class _DevFSHttpWriter {
 
   void _scheduleWrites(DevFSProgressReporter progressReporter) {
     while (_inFlight < kMaxInFlight) {
-       if (_outstanding.length == 0) {
+      if (_outstanding.length == 0) {
         // Finished.
         break;
       }
-      DevFSEntry entry = _outstanding.removeLast();
-      _scheduleWrite(entry, progressReporter);
+      String devicePath = _outstanding.keys.first;
+      DevFSContent content = _outstanding.remove(devicePath);
+      _scheduleWrite(devicePath, content, progressReporter);
       _inFlight++;
     }
   }
 
-  Future<Null> _scheduleWrite(DevFSEntry entry,
+  Future<Null> _scheduleWrite(String devicePath,
+                              DevFSContent content,
                               DevFSProgressReporter progressReporter) async {
     try {
       HttpClientRequest request = await _client.putUrl(httpAddress);
       request.headers.removeAll(HttpHeaders.ACCEPT_ENCODING);
       request.headers.add('dev_fs_name', fsName);
       request.headers.add('dev_fs_path_b64',
-                          BASE64.encode(UTF8.encode(entry.devicePath)));
-      Stream<List<int>> contents = entry.contentsAsCompressedStream();
+                          BASE64.encode(UTF8.encode(devicePath)));
+      Stream<List<int>> contents = content.contentsAsCompressedStream();
       await request.addStream(contents);
       HttpClientResponse response = await request.close();
       await response.drain();
     } catch (e) {
-      printError('Error writing "${entry.devicePath}" to DevFS: $e');
+      printError('Error writing "$devicePath" to DevFS: $e');
     }
     if (progressReporter != null) {
       _done++;
@@ -300,16 +312,12 @@ class DevFS {
   final String fsName;
   final Directory rootDirectory;
   String _packagesFilePath;
-  final Map<String, DevFSEntry> _entries = <String, DevFSEntry>{};
-  final Set<DevFSEntry> _dirtyEntries = new Set<DevFSEntry>();
-  final Set<DevFSEntry> _deletedEntries = new Set<DevFSEntry>();
-  final Set<DevFSEntry> dirtyAssetEntries = new Set<DevFSEntry>();
+  final Map<String, DevFSContent> _entries = <String, DevFSContent>{};
+  final Set<String> assetPathsToEvict = new Set<String>();
 
   final List<Future<Map<String, dynamic>>> _pendingOperations =
       new List<Future<Map<String, dynamic>>>();
 
-  int _bytes = 0;
-  int get bytes => _bytes;
   Uri _baseUri;
   Uri get baseUri => _baseUri;
 
@@ -324,118 +332,88 @@ class DevFS {
     return _operations.destroy(fsName);
   }
 
-  void _reset() {
-    // Reset the dirty byte count.
-    _bytes = 0;
-    // Mark all entries as possibly deleted.
-    _entries.forEach((String path, DevFSEntry entry) {
-      entry._exists = false;
-    });
-    // Clear the dirt entries list.
-    _dirtyEntries.clear();
-    // Clear the deleted entries list.
-    _deletedEntries.clear();
-    // Clear the dirty asset entries.
-    dirtyAssetEntries.clear();
-  }
-
-  Future<dynamic> update({ DevFSProgressReporter progressReporter,
+  /// Update files on the device and return the number of bytes sync'd
+  Future<int> update({ DevFSProgressReporter progressReporter,
                            AssetBundle bundle,
                            bool bundleDirty: false,
                            Set<String> fileFilter}) async {
-    _reset();
+    // Mark all entries as possibly deleted.
+    for (DevFSContent content in _entries.values) {
+      content._exists = false;
+    }
+
+    // Scan workspace, packages, and assets
     printTrace('DevFS: Starting sync from $rootDirectory');
     logger.printTrace('Scanning project files');
-    Directory directory = rootDirectory;
-    await _scanDirectory(directory,
+    await _scanDirectory(rootDirectory,
                          recursive: true,
                          fileFilter: fileFilter);
-
-    printTrace('Scanning package files');
-
-    StringBuffer sb;
     if (fs.isFileSync(_packagesFilePath)) {
-      PackageMap packageMap = new PackageMap(_packagesFilePath);
-
-      for (String packageName in packageMap.map.keys) {
-        Uri uri = packageMap.map[packageName];
-        // This project's own package.
-        final bool isProjectPackage = uri.toString() == 'lib/';
-        final String directoryName =
-            isProjectPackage ? 'lib' : 'packages/$packageName';
-        // If this is the project's package, we need to pass both
-        // package:<package_name> and lib/ as paths to be checked against
-        // the filter because we must support both package: imports and relative
-        // path imports within the project's own code.
-        final String packagesDirectoryName =
-            isProjectPackage ? 'packages/$packageName' : null;
-        Directory directory = fs.directory(uri);
-        bool packageExists =
-            await _scanDirectory(directory,
-                                 directoryName: directoryName,
-                                 recursive: true,
-                                 packagesDirectoryName: packagesDirectoryName,
-                                 fileFilter: fileFilter);
-        if (packageExists) {
-          sb ??= new StringBuffer();
-          sb.writeln('$packageName:$directoryName');
-        }
-      }
+      printTrace('Scanning package files');
+      await _scanPackages(fileFilter);
     }
     if (bundle != null) {
       printTrace('Scanning asset files');
-      // Synchronize asset bundle.
-      for (AssetBundleEntry entry in bundle.entries) {
-        // We write the assets into the AssetBundle working dir so that they
-        // are in the same location in DevFS and the iOS simulator.
-        final String devicePath =
-            path.join(getAssetBuildDirectory(), entry.archivePath);
-        _scanBundleEntry(devicePath, entry, bundleDirty);
-      }
+      bundle.entries.forEach((String archivePath, DevFSContent content) {
+        _scanBundleEntry(archivePath, content, bundleDirty);
+      });
     }
+
     // Handle deletions.
     printTrace('Scanning for deleted files');
+    String assetBuildDirPrefix = getAssetBuildDirectory() + path.separator;
     final List<String> toRemove = new List<String>();
-    _entries.forEach((String path, DevFSEntry entry) {
-      if (!entry._exists) {
-        _deletedEntries.add(entry);
-        toRemove.add(path);
-      }
-    });
-    for (int i = 0; i < toRemove.length; i++) {
-      _entries.remove(toRemove[i]);
-    }
-
-    if (_deletedEntries.length > 0) {
-      printTrace('Removing deleted files');
-      for (DevFSEntry entry in _deletedEntries) {
+    _entries.forEach((String devicePath, DevFSContent content) {
+      if (!content._exists) {
         Future<Map<String, dynamic>> operation =
-            _operations.deleteFile(fsName, entry);
+            _operations.deleteFile(fsName, devicePath);
         if (operation != null)
           _pendingOperations.add(operation);
+        toRemove.add(devicePath);
+        if (devicePath.startsWith(assetBuildDirPrefix)) {
+          String archivePath = devicePath.substring(assetBuildDirPrefix.length);
+          assetPathsToEvict.add(archivePath);
+        }
       }
+    });
+    if (toRemove.isNotEmpty) {
+      printTrace('Removing deleted files');
+      toRemove.forEach(_entries.remove);
       await Future.wait(_pendingOperations);
       _pendingOperations.clear();
-      _deletedEntries.clear();
     }
 
-    if (_dirtyEntries.length > 0) {
+    // Update modified files
+    int numBytes = 0;
+    Map<String, DevFSContent> dirtyEntries = <String, DevFSContent>{};
+    _entries.forEach((String devicePath, DevFSContent content) {
+      String archivePath;
+      if (devicePath.startsWith(assetBuildDirPrefix))
+        archivePath = devicePath.substring(assetBuildDirPrefix.length);
+      if (content.isModified || (bundleDirty && archivePath != null)) {
+        dirtyEntries[devicePath] = content;
+        numBytes += content.size;
+        if (archivePath != null)
+          assetPathsToEvict.add(archivePath);
+      }
+    });
+    if (dirtyEntries.length > 0) {
       printTrace('Updating files');
       if (_httpWriter != null) {
         try {
-          await _httpWriter.write(_dirtyEntries,
+          await _httpWriter.write(dirtyEntries,
                                   progressReporter: progressReporter);
         } catch (e) {
           printError("Could not update files on device: $e");
         }
       } else {
         // Make service protocol requests for each.
-        for (DevFSEntry entry in _dirtyEntries) {
+        dirtyEntries.forEach((String devicePath, DevFSContent content) {
           Future<Map<String, dynamic>> operation =
-              _operations.writeFile(fsName, entry);
+              _operations.writeFile(fsName, devicePath, content);
           if (operation != null)
             _pendingOperations.add(operation);
-        }
+        });
         if (progressReporter != null) {
           final int max = _pendingOperations.length;
           int complete = 0;
@@ -447,53 +425,24 @@ class DevFS {
         await Future.wait(_pendingOperations, eagerError: true);
         _pendingOperations.clear();
       }
-      _dirtyEntries.clear();
     }
 
-    if (sb != null)
-      await _operations.writeSource(fsName, '.packages', sb.toString());
-
     printTrace('DevFS: Sync finished');
+    return numBytes;
   }
 
   void _scanFile(String devicePath, FileSystemEntity file) {
-    DevFSEntry entry = _entries[devicePath];
-    if (entry == null) {
-      // New file.
-      entry = new DevFSEntry(devicePath, file);
-      _entries[devicePath] = entry;
-    }
-    entry._exists = true;
-    bool needsWrite = entry.isModified;
-    if (needsWrite) {
-      if (_dirtyEntries.add(entry))
-        _bytes += entry.size;
-    }
+    DevFSContent content = _entries.putIfAbsent(devicePath, () => new DevFSFileContent(file));
+    content._exists = true;
   }
 
-  void _scanBundleEntry(String devicePath,
-                        AssetBundleEntry assetBundleEntry,
-                        bool bundleDirty) {
-    DevFSEntry entry = _entries[devicePath];
-    if (entry == null) {
-      // New file.
-      entry = new DevFSEntry.bundle(devicePath, assetBundleEntry);
-      _entries[devicePath] = entry;
-    }
-    entry._exists = true;
-    if (!bundleDirty && assetBundleEntry.isStringEntry) {
-      // String bundle entries are synthetic files that only change if the
-      // bundle itself changes. Skip them if the bundle is not dirty.
-      return;
-    }
-    bool needsWrite = entry.isModified;
-    if (needsWrite) {
-      if (_dirtyEntries.add(entry)) {
-        _bytes += entry.size;
-        if (entry._isAssetEntry)
-          dirtyAssetEntries.add(entry);
-      }
-    }
+  void _scanBundleEntry(String archivePath, DevFSContent content, bool bundleDirty) {
+    // We write the assets into the AssetBundle working dir so that they
+    // are in the same location in DevFS and the iOS simulator.
+    final String devicePath = path.join(getAssetBuildDirectory(), archivePath);
+
+    _entries[devicePath] = content;
+    content._exists = true;
   }
 
   bool _shouldIgnore(String devicePath) {
@@ -578,4 +527,42 @@ class DevFS {
     }
     return true;
   }
+
+  Future<Null> _scanPackages(Set<String> fileFilter) async {
+    StringBuffer sb;
+    PackageMap packageMap = new PackageMap(_packagesFilePath);
+
+    for (String packageName in packageMap.map.keys) {
+      Uri uri = packageMap.map[packageName];
+      // This project's own package.
+      final bool isProjectPackage = uri.toString() == 'lib/';
+      final String directoryName =
+          isProjectPackage ? 'lib' : 'packages/$packageName';
+      // If this is the project's package, we need to pass both
+      // package:<package_name> and lib/ as paths to be checked against
+      // the filter because we must support both package: imports and relative
+      // path imports within the project's own code.
+      final String packagesDirectoryName =
+          isProjectPackage ? 'packages/$packageName' : null;
+      Directory directory = fs.directory(uri);
+      bool packageExists =
+          await _scanDirectory(directory,
+                               directoryName: directoryName,
+                               recursive: true,
+                               packagesDirectoryName: packagesDirectoryName,
+                               fileFilter: fileFilter);
+      if (packageExists) {
+        sb ??= new StringBuffer();
+        sb.writeln('$packageName:$directoryName');
+      }
+    }
+    if (sb != null) {
+      DevFSContent content = _entries['.packages'];
+      if (content is DevFSStringContent && content.string == sb.toString()) {
+        content._exists = true;
+        return;
+      }
+      _entries['.packages'] = new DevFSStringContent(sb.toString());
+    }
+  }
 }

packages/flutter_tools/lib/src/flx.dart

@@ -11,6 +11,7 @@ import 'base/common.dart';
 import 'base/file_system.dart';
 import 'base/process.dart';
 import 'dart/package_map.dart';
+import 'devfs.dart';
 import 'build_info.dart';
 import 'globals.dart';
 import 'toolchain.dart';
@@ -156,12 +157,12 @@ Future<Null> assemble({
   zipBuilder.entries.addAll(assetBundle.entries);
 
   if (snapshotFile != null)
-    zipBuilder.addEntry(new AssetBundleEntry.fromFile(_kSnapshotKey, snapshotFile));
+    zipBuilder.entries[_kSnapshotKey] = new DevFSFileContent(snapshotFile);
 
   ensureDirectoryExists(outputPath);
 
   printTrace('Encoding zip file to $outputPath');
-  zipBuilder.createZip(fs.file(outputPath), fs.directory(workingDirPath));
+  await zipBuilder.createZip(fs.file(outputPath), fs.directory(workingDirPath));
 
   printTrace('Built $outputPath.');
 }

packages/flutter_tools/lib/src/hot.dart

@@ -273,7 +273,7 @@ class HotRunner extends ResidentRunner {
         return false;
     }
     Status devFSStatus = logger.startProgress('Syncing files to device...');
-    await _devFS.update(progressReporter: progressReporter,
+    int bytes = await _devFS.update(progressReporter: progressReporter,
                         bundle: assetBundle,
                         bundleDirty: rebuildBundle,
                         fileFilter: _dartDependencies);
@@ -282,18 +282,19 @@ class HotRunner extends ResidentRunner {
       // Clear the set after the sync so they are recomputed next time.
       _dartDependencies = null;
     }
-    printTrace('Synced ${getSizeAsMB(_devFS.bytes)}.');
+    printTrace('Synced ${getSizeAsMB(bytes)}.');
     return true;
   }
 
   Future<Null> _evictDirtyAssets() async {
-    if (_devFS.dirtyAssetEntries.length == 0)
+    if (_devFS.assetPathsToEvict.isEmpty)
       return;
     if (currentView.uiIsolate == null)
       throw 'Application isolate not found';
-    for (DevFSEntry entry in _devFS.dirtyAssetEntries) {
-      await currentView.uiIsolate.flutterEvictAsset(entry.assetPath);
+    for (String assetPath in _devFS.assetPathsToEvict) {
+      await currentView.uiIsolate.flutterEvictAsset(assetPath);
     }
+    _devFS.assetPathsToEvict.clear();
   }
 
   Future<Null> _cleanupDevFS() async {

packages/flutter_tools/lib/src/zip.dart

@@ -2,10 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import 'dart:async';
+
 import 'package:archive/archive.dart';
 import 'package:path/path.dart' as path;
 
-import 'asset.dart';
+import 'devfs.dart';
 import 'base/file_system.dart';
 import 'base/process.dart';
 
@@ -20,27 +22,32 @@ abstract class ZipBuilder {
 
   ZipBuilder._();
 
-  List<AssetBundleEntry> entries = <AssetBundleEntry>[];
-
-  void addEntry(AssetBundleEntry entry) => entries.add(entry);
+  Map<String, DevFSContent> entries = <String, DevFSContent>{};
 
-  void createZip(File outFile, Directory zipBuildDir);
+  Future<Null> createZip(File outFile, Directory zipBuildDir);
 }
 
 class _ArchiveZipBuilder extends ZipBuilder {
   _ArchiveZipBuilder() : super._();
 
   @override
-  void createZip(File outFile, Directory zipBuildDir) {
+  Future<Null> createZip(File outFile, Directory zipBuildDir) async {
     Archive archive = new Archive();
 
-    for (AssetBundleEntry entry in entries) {
-      List<int> data = entry.contentsAsBytes();
-      archive.addFile(new ArchiveFile.noCompress(entry.archivePath, data.length, data));
-    }
+    final Completer<Null> finished = new Completer<Null>();
+    int count = entries.length;
+    entries.forEach((String archivePath, DevFSContent content) {
+      content.contentsAsBytes().then((List<int> data) {
+        archive.addFile(new ArchiveFile.noCompress(archivePath, data.length, data));
+        --count;
+        if (count == 0)
+          finished.complete();
+      });
+    });
+    await finished.future;
 
     List<int> zipData = new ZipEncoder().encode(archive);
-    outFile.writeAsBytesSync(zipData);
+    await outFile.writeAsBytes(zipData);
   }
 }
 
@@ -48,11 +55,11 @@ class _ZipToolBuilder extends ZipBuilder {
   _ZipToolBuilder() : super._();
 
   @override
-  void createZip(File outFile, Directory zipBuildDir) {
+  Future<Null> createZip(File outFile, Directory zipBuildDir) async {
     // If there are no assets, then create an empty zip file.
     if (entries.isEmpty) {
       List<int> zipData = new ZipEncoder().encode(new Archive());
-      outFile.writeAsBytesSync(zipData);
+      await outFile.writeAsBytes(zipData);
       return;
     }
 
@@ -63,23 +70,33 @@ class _ZipToolBuilder extends ZipBuilder {
       zipBuildDir.deleteSync(recursive: true);
     zipBuildDir.createSync(recursive: true);
 
-    for (AssetBundleEntry entry in entries) {
-      List<int> data = entry.contentsAsBytes();
-      File file = fs.file(path.join(zipBuildDir.path, entry.archivePath));
-      file.parent.createSync(recursive: true);
-      file.writeAsBytesSync(data);
-    }
-
-    if (_getCompressedNames().isNotEmpty) {
+    final Completer<Null> finished = new Completer<Null>();
+    int count = entries.length;
+    entries.forEach((String archivePath, DevFSContent content) {
+      content.contentsAsBytes().then((List<int> data) {
+        File file = fs.file(path.join(zipBuildDir.path, archivePath));
+        file.parent.createSync(recursive: true);
+        file.writeAsBytes(data).then((_) {
+          --count;
+          if (count == 0)
+            finished.complete();
+        });
+      });
+    });
+    await finished.future;
+
+    final Iterable<String> compressedNames = _getCompressedNames();
+    if (compressedNames.isNotEmpty) {
       runCheckedSync(
-        <String>['zip', '-q', outFile.absolute.path]..addAll(_getCompressedNames()),
+        <String>['zip', '-q', outFile.absolute.path]..addAll(compressedNames),
         workingDirectory: zipBuildDir.path
       );
     }
 
-    if (_getStoredNames().isNotEmpty) {
+    final Iterable<String> storedNames = _getStoredNames();
+    if (storedNames.isNotEmpty) {
       runCheckedSync(
-        <String>['zip', '-q', '-0', outFile.absolute.path]..addAll(_getStoredNames()),
+        <String>['zip', '-q', '-0', outFile.absolute.path]..addAll(storedNames),
         workingDirectory: zipBuildDir.path
       );
     }
@@ -87,21 +104,14 @@ class _ZipToolBuilder extends ZipBuilder {
 
   static const List<String> _kNoCompressFileExtensions = const <String>['.png', '.jpg'];
 
-  bool isAssetCompressed(AssetBundleEntry entry) {
+  bool isAssetCompressed(String archivePath) {
     return !_kNoCompressFileExtensions.any(
-        (String extension) => entry.archivePath.endsWith(extension)
+        (String extension) => archivePath.endsWith(extension)
     );
   }
 
-  Iterable<String> _getCompressedNames() {
-    return entries
-      .where(isAssetCompressed)
-      .map((AssetBundleEntry entry) => entry.archivePath);
-  }
+  Iterable<String> _getCompressedNames() => entries.keys.where(isAssetCompressed);
 
-  Iterable<String> _getStoredNames() {
-    return entries
-      .where((AssetBundleEntry entry) => !isAssetCompressed(entry))
-      .map((AssetBundleEntry entry) => entry.archivePath);
-  }
+  Iterable<String> _getStoredNames() => entries.keys
+      .where((String archivePath) => !isAssetCompressed(archivePath));
 }

packages/flutter_tools/test/asset_bundle_test.dart

@@ -5,6 +5,7 @@
 import 'dart:convert';
 import 'package:flutter_tools/src/asset.dart';
 import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/devfs.dart';
 import 'package:path/path.dart' as path;
 import 'package:test/test.dart';
 
@@ -37,29 +38,26 @@ void main()  {
       AssetBundle ab = new AssetBundle.fixed('', 'apple.txt');
       expect(ab.entries, isNotEmpty);
       expect(ab.entries.length, 1);
-      AssetBundleEntry entry = ab.entries.first;
-      expect(entry, isNotNull);
-      expect(entry.archivePath, 'apple.txt');
+      String archivePath = ab.entries.keys.first;
+      expect(archivePath, isNotNull);
+      expect(archivePath, 'apple.txt');
     });
     test('two entries', () async {
       AssetBundle ab = new AssetBundle.fixed('', 'apple.txt,packages/flutter_gallery_assets/shrine/products/heels.png');
       expect(ab.entries, isNotEmpty);
       expect(ab.entries.length, 2);
-      AssetBundleEntry firstEntry = ab.entries.first;
-      expect(firstEntry, isNotNull);
-      expect(firstEntry.archivePath, 'apple.txt');
-      AssetBundleEntry lastEntry = ab.entries.last;
-      expect(lastEntry, isNotNull);
-      expect(lastEntry.archivePath, 'packages/flutter_gallery_assets/shrine/products/heels.png');
+      List<String> archivePaths = ab.entries.keys.toList()..sort();
+      expect(archivePaths[0], 'apple.txt');
+      expect(archivePaths[1], 'packages/flutter_gallery_assets/shrine/products/heels.png');
     });
     test('file contents', () async {
       AssetBundle ab = new AssetBundle.fixed(projectRoot, assetPath);
       expect(ab.entries, isNotEmpty);
       expect(ab.entries.length, 1);
-      AssetBundleEntry entry = ab.entries.first;
-      expect(entry, isNotNull);
-      expect(entry.archivePath, assetPath);
-      expect(assetContents, UTF8.decode(entry.contentsAsBytes()));
+      String archivePath = ab.entries.keys.first;
+      DevFSContent content = ab.entries[archivePath];
+      expect(archivePath, assetPath);
+      expect(assetContents, UTF8.decode(await content.contentsAsBytes()));
     });
   });
 

packages/flutter_tools/test/devfs_test.dart

@@ -2,10 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import 'dart:async';
+import 'dart:convert';
+
 import 'package:flutter_tools/src/asset.dart';
+import 'package:flutter_tools/src/base/io.dart';
 import 'package:flutter_tools/src/build_info.dart';
 import 'package:flutter_tools/src/devfs.dart';
 import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/vmservice.dart';
 import 'package:path/path.dart' as path;
 import 'package:test/test.dart';
 
@@ -14,72 +19,319 @@ import 'src/context.dart';
 import 'src/mocks.dart';
 
 void main() {
-  String filePath = 'bar/foo.txt';
-  String filePath2 = 'foo/bar.txt';
+  final String filePath = 'bar/foo.txt';
+  final String filePath2 = 'foo/bar.txt';
   Directory tempDir;
   String basePath;
-  MockDevFSOperations devFSOperations = new MockDevFSOperations();
   DevFS devFS;
-  AssetBundle assetBundle = new AssetBundle();
-  assetBundle.entries.add(new AssetBundleEntry.fromString('a.txt', ''));
-  group('devfs', () {
-    testUsingContext('create local file system', () async {
-      tempDir = fs.systemTempDirectory.createTempSync();
+  final AssetBundle assetBundle = new AssetBundle();
+
+  group('DevFSContent', () {
+    test('bytes', () {
+      DevFSByteContent content = new DevFSByteContent(<int>[4, 5, 6]);
+      expect(content.bytes, orderedEquals(<int>[4, 5, 6]));
+      expect(content.isModified, isTrue);
+      expect(content.isModified, isFalse);
+      content.bytes = <int>[7, 8, 9, 2];
+      expect(content.bytes, orderedEquals(<int>[7, 8, 9, 2]));
+      expect(content.isModified, isTrue);
+      expect(content.isModified, isFalse);
+    });
+    test('string', () {
+      DevFSStringContent content = new DevFSStringContent('some string');
+      expect(content.string, 'some string');
+      expect(content.bytes, orderedEquals(UTF8.encode('some string')));
+      expect(content.isModified, isTrue);
+      expect(content.isModified, isFalse);
+      content.string = 'another string';
+      expect(content.string, 'another string');
+      expect(content.bytes, orderedEquals(UTF8.encode('another string')));
+      expect(content.isModified, isTrue);
+      expect(content.isModified, isFalse);
+      content.bytes = UTF8.encode('foo bar');
+      expect(content.string, 'foo bar');
+      expect(content.bytes, orderedEquals(UTF8.encode('foo bar')));
+      expect(content.isModified, isTrue);
+      expect(content.isModified, isFalse);
+    });
+  });
+
+  group('devfs local', () {
+    MockDevFSOperations devFSOperations = new MockDevFSOperations();
+
+    setUpAll(() {
+      tempDir = _newTempDir();
       basePath = tempDir.path;
+    });
+    tearDownAll(_cleanupTempDirs);
+
+    testUsingContext('create dev file system', () async {
+      // simulate workspace
       File file = fs.file(path.join(basePath, filePath));
       await file.parent.create(recursive: true);
       file.writeAsBytesSync(<int>[1, 2, 3]);
-    });
-    testUsingContext('create dev file system', () async {
+
+      // simulate package
+      await _createPackage('somepkg', 'somefile.txt');
+
       devFS = new DevFS.operations(devFSOperations, 'test', tempDir);
       await devFS.create();
-      expect(devFSOperations.contains('create test'), isTrue);
-    });
-    testUsingContext('populate dev file system', () async {
-      await devFS.update();
-      expect(devFSOperations.contains('writeFile test bar/foo.txt'), isTrue);
+      devFSOperations.expectMessages(<String>['create test']);
+      expect(devFS.assetPathsToEvict, isEmpty);
+
+      int bytes = await devFS.update();
+      devFSOperations.expectMessages(<String>[
+        'writeFile test .packages',
+        'writeFile test bar/foo.txt',
+        'writeFile test packages/somepkg/somefile.txt',
+      ]);
+      expect(devFS.assetPathsToEvict, isEmpty);
+      expect(bytes, 31);
     });
     testUsingContext('add new file to local file system', () async {
       File file = fs.file(path.join(basePath, filePath2));
       await file.parent.create(recursive: true);
       file.writeAsBytesSync(<int>[1, 2, 3, 4, 5, 6, 7]);
-      await devFS.update();
-      expect(devFSOperations.contains('writeFile test foo/bar.txt'), isTrue);
+      int bytes = await devFS.update();
+      devFSOperations.expectMessages(<String>[
+        'writeFile test foo/bar.txt',
+      ]);
+      expect(devFS.assetPathsToEvict, isEmpty);
+      expect(bytes, 7);
     });
     testUsingContext('modify existing file on local file system', () async {
       File file = fs.file(path.join(basePath, filePath));
       // Set the last modified time to 5 seconds in the past.
       updateFileModificationTime(file.path, new DateTime.now(), -5);
-      await devFS.update();
+      int bytes = await devFS.update();
+      devFSOperations.expectMessages(<String>[]);
+      expect(devFS.assetPathsToEvict, isEmpty);
+      expect(bytes, 0);
+
       await file.writeAsBytes(<int>[1, 2, 3, 4, 5, 6]);
-      await devFS.update();
-      expect(devFSOperations.contains('writeFile test bar/foo.txt'), isTrue);
+      bytes = await devFS.update();
+      devFSOperations.expectMessages(<String>[
+        'writeFile test bar/foo.txt',
+      ]);
+      expect(devFS.assetPathsToEvict, isEmpty);
+      expect(bytes, 6);
     });
     testUsingContext('delete a file from the local file system', () async {
       File file = fs.file(path.join(basePath, filePath));
       await file.delete();
-      await devFS.update();
-      expect(devFSOperations.contains('deleteFile test bar/foo.txt'), isTrue);
+      int bytes = await devFS.update();
+      devFSOperations.expectMessages(<String>[
+        'deleteFile test bar/foo.txt',
+      ]);
+      expect(devFS.assetPathsToEvict, isEmpty);
+      expect(bytes, 0);
+    });
+    testUsingContext('add new package', () async {
+      await _createPackage('newpkg', 'anotherfile.txt');
+      int bytes = await devFS.update();
+      devFSOperations.expectMessages(<String>[
+        'writeFile test .packages',
+        'writeFile test packages/newpkg/anotherfile.txt',
+      ]);
+      expect(devFS.assetPathsToEvict, isEmpty);
+      expect(bytes, 51);
     });
-    testUsingContext('add file in an asset bundle', () async {
-      await devFS.update(bundle: assetBundle, bundleDirty: true);
-      expect(devFSOperations.contains(
-          'writeFile test ${getAssetBuildDirectory()}/a.txt'), isTrue);
+    testUsingContext('add an asset bundle', () async {
+      assetBundle.entries['a.txt'] = new DevFSStringContent('abc');
+      int bytes = await devFS.update(bundle: assetBundle, bundleDirty: true);
+      devFSOperations.expectMessages(<String>[
+        'writeFile test ${getAssetBuildDirectory()}/a.txt',
+      ]);
+      expect(devFS.assetPathsToEvict, unorderedMatches(<String>['a.txt']));
+      devFS.assetPathsToEvict.clear();
+      expect(bytes, 3);
+    });
+    testUsingContext('add a file to the asset bundle - bundleDirty', () async {
+      assetBundle.entries['b.txt'] = new DevFSStringContent('abcd');
+      int bytes = await devFS.update(bundle: assetBundle, bundleDirty: true);
+      // Expect entire asset bundle written because bundleDirty is true
+      devFSOperations.expectMessages(<String>[
+        'writeFile test ${getAssetBuildDirectory()}/a.txt',
+        'writeFile test ${getAssetBuildDirectory()}/b.txt',
+      ]);
+      expect(devFS.assetPathsToEvict, unorderedMatches(<String>[
+        'a.txt', 'b.txt']));
+      devFS.assetPathsToEvict.clear();
+      expect(bytes, 7);
     });
     testUsingContext('add a file to the asset bundle', () async {
-      assetBundle.entries.add(new AssetBundleEntry.fromString('b.txt', ''));
-      await devFS.update(bundle: assetBundle, bundleDirty: true);
-      expect(devFSOperations.contains(
-          'writeFile test ${getAssetBuildDirectory()}/b.txt'), isTrue);
+      assetBundle.entries['c.txt'] = new DevFSStringContent('12');
+      int bytes = await devFS.update(bundle: assetBundle);
+      devFSOperations.expectMessages(<String>[
+        'writeFile test ${getAssetBuildDirectory()}/c.txt',
+      ]);
+      expect(devFS.assetPathsToEvict, unorderedMatches(<String>[
+        'c.txt']));
+      devFS.assetPathsToEvict.clear();
+      expect(bytes, 2);
     });
     testUsingContext('delete a file from the asset bundle', () async {
+      assetBundle.entries.remove('c.txt');
+      int bytes = await devFS.update(bundle: assetBundle);
+      devFSOperations.expectMessages(<String>[
+        'deleteFile test ${getAssetBuildDirectory()}/c.txt',
+      ]);
+      expect(devFS.assetPathsToEvict, unorderedMatches(<String>['c.txt']));
+      devFS.assetPathsToEvict.clear();
+      expect(bytes, 0);
+    });
+    testUsingContext('delete all files from the asset bundle', () async {
       assetBundle.entries.clear();
-      await devFS.update(bundle: assetBundle, bundleDirty: true);
-      expect(devFSOperations.contains(
-          'deleteFile test ${getAssetBuildDirectory()}/b.txt'), isTrue);
+      int bytes = await devFS.update(bundle: assetBundle, bundleDirty: true);
+      devFSOperations.expectMessages(<String>[
+        'deleteFile test ${getAssetBuildDirectory()}/a.txt',
+        'deleteFile test ${getAssetBuildDirectory()}/b.txt',
+      ]);
+      expect(devFS.assetPathsToEvict, unorderedMatches(<String>[
+        'a.txt', 'b.txt'
+      ]));
+      devFS.assetPathsToEvict.clear();
+      expect(bytes, 0);
     });
     testUsingContext('delete dev file system', () async {
       await devFS.destroy();
+      devFSOperations.expectMessages(<String>['destroy test']);
+      expect(devFS.assetPathsToEvict, isEmpty);
+    });
+  });
+
+  group('devfs remote', () {
+    MockVMService vmService;
+
+    setUpAll(() async {
+      tempDir = _newTempDir();
+      basePath = tempDir.path;
+      vmService = new MockVMService();
+      await vmService.setUp();
+    });
+    tearDownAll(() async {
+      await vmService.tearDown();
+      _cleanupTempDirs();
     });
+
+    testUsingContext('create dev file system', () async {
+      // simulate workspace
+      File file = fs.file(path.join(basePath, filePath));
+      await file.parent.create(recursive: true);
+      file.writeAsBytesSync(<int>[1, 2, 3]);
+
+      // simulate package
+      await _createPackage('somepkg', 'somefile.txt');
+
+      devFS = new DevFS(vmService, 'test', tempDir);
+      await devFS.create();
+      vmService.expectMessages(<String>['create test']);
+      expect(devFS.assetPathsToEvict, isEmpty);
+
+      int bytes = await devFS.update();
+      vmService.expectMessages(<String>[
+        'writeFile test .packages',
+        'writeFile test bar/foo.txt',
+        'writeFile test packages/somepkg/somefile.txt',
+      ]);
+      expect(devFS.assetPathsToEvict, isEmpty);
+      expect(bytes, 31);
+    }, timeout: new Timeout(new Duration(seconds: 5)));
+
+    testUsingContext('delete dev file system', () async {
+      await devFS.destroy();
+      vmService.expectMessages(<String>['_deleteDevFS {fsName: test}']);
+      expect(devFS.assetPathsToEvict, isEmpty);
+    });
+  });
+}
+
+class MockVMService extends BasicMock implements VMService {
+  Uri _httpAddress;
+  HttpServer _server;
+  MockVM _vm;
+
+  MockVMService() {
+    _vm = new MockVM(this);
+  }
+
+  @override
+  Uri get httpAddress => _httpAddress;
+
+  @override
+  VM get vm => _vm;
+
+  Future<Null> setUp() async {
+    _server = await HttpServer.bind(InternetAddress.LOOPBACK_IP_V4, 0);
+    _httpAddress = Uri.parse('http://127.0.0.1:${_server.port}');
+    _server.listen((HttpRequest request) {
+      String fsName = request.headers.value('dev_fs_name');
+      String devicePath = UTF8.decode(BASE64.decode(request.headers.value('dev_fs_path_b64')));
+      messages.add('writeFile $fsName $devicePath');
+      request.drain().then((_) {
+        request.response
+          ..write('Got it')
+          ..close();
+      });
+    });
+  }
+
+  Future<Null> tearDown() async {
+    await _server.close();
+  }
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+class MockVM implements VM {
+  final MockVMService _service;
+  final Uri _baseUri = Uri.parse('file:///tmp/devfs/test');
+
+  MockVM(this._service);
+
+  @override
+  Future<Map<String, dynamic>> createDevFS(String fsName) async {
+    _service.messages.add('create $fsName');
+    return <String, dynamic>{'uri': '$_baseUri'};
+  }
+
+  @override
+  Future<Map<String, dynamic>> invokeRpcRaw(
+      String method, [Map<String, dynamic> params, Duration timeout]) async {
+    _service.messages.add('$method $params');
+    return <String, dynamic>{'success': true};
+  }
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+
+final List<Directory> _tempDirs = <Directory>[];
+final Map <String, Directory> _packages = <String, Directory>{};
+
+Directory _newTempDir() {
+  Directory tempDir = fs.systemTempDirectory.createTempSync('devfs${_tempDirs.length}');
+  _tempDirs.add(tempDir);
+  return tempDir;
+}
+
+void _cleanupTempDirs() {
+  while (_tempDirs.length > 0) {
+    _tempDirs.removeLast().deleteSync(recursive: true);
+  }
+}
+
+Future<Null> _createPackage(String pkgName, String pkgFileName) async {
+  final Directory pkgTempDir = _newTempDir();
+  File pkgFile = fs.file(path.join(pkgTempDir.path, pkgName, 'lib', pkgFileName));
+  await pkgFile.parent.create(recursive: true);
+  pkgFile.writeAsBytesSync(<int>[11, 12, 13]);
+  _packages[pkgName] = pkgTempDir;
+  StringBuffer sb = new StringBuffer();
+  _packages.forEach((String pkgName, Directory pkgTempDir) {
+    sb.writeln('$pkgName:${pkgTempDir.path}/$pkgName/lib');
   });
+  fs.file(path.join(_tempDirs[0].path, '.packages')).writeAsStringSync(sb.toString());
 }

packages/flutter_tools/test/src/mocks.dart

@@ -13,6 +13,7 @@ import 'package:flutter_tools/src/ios/devices.dart';
 import 'package:flutter_tools/src/ios/simulators.dart';
 import 'package:flutter_tools/src/runner/flutter_command.dart';
 import 'package:mockito/mockito.dart';
+import 'package:test/test.dart';
 
 class MockApplicationPackageStore extends ApplicationPackageStore {
   MockApplicationPackageStore() : super(
@@ -74,9 +75,16 @@ void applyMocksToCommand(FlutterCommand command) {
     ..commandValidator = () => true;
 }
 
-class MockDevFSOperations implements DevFSOperations {
+/// Common functionality for tracking mock interaction
+class BasicMock {
   final List<String> messages = new List<String>();
 
+  void expectMessages(List<String> expectedMessages) {
+    List<String> actualMessages = new List<String>.from(messages);
+    messages.clear();
+    expect(actualMessages, unorderedEquals(expectedMessages));
+  }
+
   bool contains(String match) {
     print('Checking for `$match` in:');
     print(messages);
@@ -84,7 +92,9 @@ class MockDevFSOperations implements DevFSOperations {
     messages.clear();
     return result;
   }
+}
 
+class MockDevFSOperations extends BasicMock implements DevFSOperations {
   @override
   Future<Uri> create(String fsName) async {
     messages.add('create $fsName');
@@ -97,19 +107,12 @@ class MockDevFSOperations implements DevFSOperations {
   }
 
   @override
-  Future<dynamic> writeFile(String fsName, DevFSEntry entry) async {
-    messages.add('writeFile $fsName ${entry.devicePath}');
-  }
-
-  @override
-  Future<dynamic> deleteFile(String fsName, DevFSEntry entry) async {
-    messages.add('deleteFile $fsName ${entry.devicePath}');
+  Future<dynamic> writeFile(String fsName, String devicePath, DevFSContent content) async {
+    messages.add('writeFile $fsName $devicePath');
   }
 
   @override
-  Future<dynamic> writeSource(String fsName,
-                              String devicePath,
-                              String contents) async {
-    messages.add('writeSource $fsName $devicePath');
+  Future<dynamic> deleteFile(String fsName, String devicePath) async {
+    messages.add('deleteFile $fsName $devicePath');
   }
 }