Send CacheCleanUpRequest instead of a List.

pkg/analyzer/lib/src/dart/analysis/file_byte_store.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.
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
 
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:path/path.dart';
 
 /**
+ * The request that is sent from the main isolate to the clean-up isolate.
+ */
+class CacheCleanUpRequest {
+  final String cachePath;
+  final int maxSizeBytes;
+  final SendPort replyTo;
+
+  CacheCleanUpRequest(this.cachePath, this.maxSizeBytes, this.replyTo);
+}
+
+/**
  * [ByteStore] that stores values as files.
  */
 class FileByteStore implements ByteStore {
   static bool _cleanUpSendPortShouldBePrepared = true;
   static SendPort _cleanUpSendPort;
 
   final String _cachePath;
   final String _tempName = 'temp_${pid}';
   final int _maxSizeBytes;
 
@@ skipping 44 matching lines @@
     } else {
       while (_cleanUpSendPort == null) {
         await new Future.delayed(new Duration(milliseconds: 100), () {});
       }
     }
 
     if (!_evictionIsolateIsRunning) {
       _evictionIsolateIsRunning = true;
       try {
         ReceivePort response = new ReceivePort();
-        _cleanUpSendPort.send([_cachePath, _maxSizeBytes, response.sendPort]);
+        _cleanUpSendPort.send(new CacheCleanUpRequest(
+            _cachePath, _maxSizeBytes, response.sendPort));
         await response.first;
       } finally {
         _evictionIsolateIsRunning = false;
         _bytesWrittenSinceCleanup = 0;
       }
     }
   }
 
   /**
    * This function is started in a new isolate, receives cache folder clean up
    * requests and evicts older files from the folder.
    */
   static void _cacheCleanUpFunction(SendPort initialReplyTo) {
     ReceivePort port = new ReceivePort();
     initialReplyTo.send(port.sendPort);
-    port.listen((args) async {
-      if (args is List &&
-          args.length == 3 &&
-          args[0] is String &&
-          args[1] is int &&
-          args[2] is SendPort) {
-        String cachePath = args[0] as String;
-        int maxSizeBytes = args[1] as int;
-        await _cleanUpFolder(cachePath, maxSizeBytes);
-        // Let that client know that we're done.
-        SendPort replyTo = args[2] as SendPort;
-        replyTo.send(true);
+    port.listen((request) async {
+      if (request is CacheCleanUpRequest) {
+        await _cleanUpFolder(request.cachePath, request.maxSizeBytes);
+        // Let the client know that we're done.
+        request.replyTo.send(true);
       }
     });
   }
 
   static Future<Null> _cleanUpFolder(String cachePath, int maxSizeBytes) async {
     // Prepare the list of files and their statistics.
     List<File> files = <File>[];
     Map<File, FileStat> fileStatMap = {};
     int currentSizeBytes = 0;
     List<FileSystemEntity> resources = new Directory(cachePath).listSync();
@@ skipping 17 matching lines @@
       if (currentSizeBytes < maxSizeBytes) {
         break;
       }
       try {
         await file.delete();
       } catch (_) {}
       currentSizeBytes -= fileStatMap[file].size;
     }
   }
 }