pkg/analyzer: support latest pkg/crypto version

pkg/analyzer/lib/src/summary/incremental_cache.dart

 // Copyright (c) 2016, 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:convert' show UTF8;
+import 'dart:convert' show ChunkedConversionSink, UTF8;
 import 'dart:core' hide Resource;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/summarize_elements.dart';
+import 'package:convert/convert.dart';
 import 'package:crypto/crypto.dart';
 
 /**
  * Storage for cache data.
  */
 abstract class CacheStorage {
   /**
    * Return bytes for the given [key], `null` if [key] is not in the storage.
    */
   List<int> get(String key);
@@ skipping 210 matching lines @@
       _sourceContentMap[source] = content;
     }
     return content;
   }
 
   /**
    * Return the key of the content based [source] information.
    */
   String _getCacheSourceContentKey(Source source) {
     List<int> hash = _getSourceContentHash(source);
-    String hashStr = CryptoUtils.bytesToHex(hash);
+    String hashStr = hex.encode(hash);
     return '$hashStr.content';
   }
 
   /**
    * Get the bundle for the given key.
    */
   PackageBundle _getLibraryBundle(String key) {
     PackageBundle bundle = _bundleMap[key];
     if (bundle == null) {
       List<int> bytes = storage.get(key);
       if (bytes == null) {
         return null;
       }
       bundle = new PackageBundle.fromBuffer(bytes);
       _bundleMap[key] = bundle;
     }
     return bundle;
   }
 
   /**
    * Return the key of the bundle of the [librarySource].
    */
   String _getLibraryBundleKey(Source librarySource) {
     List<int> hash = _getLibraryClosureHash(librarySource);
-    String hashStr = CryptoUtils.bytesToHex(hash);
+    String hashStr = hex.encode(hash);
     return '$hashStr.summary';
   }
 
   /**
    * Return the whole source closure of the library with the given
    * [librarySource]. It includes defining units and parts of the library and
    * of all its directly or indirectly imported or exported libraries.
    */
   List<Source> _getLibraryClosure(Source librarySource) {
     return _libraryClosureMap.putIfAbsent(librarySource, () {
       Set<Source> closure = new Set<Source>();
       _appendLibraryClosure(closure, librarySource);
       return closure.toList();
     });
   }
 
   /**
    * Return the [context]-specific hash of the closure of the library with
    * the given [librarySource].
    */
   List<int> _getLibraryClosureHash(Source librarySource) {
     return _libraryClosureHashMap.putIfAbsent(librarySource, () {
       List<Source> closure = _getLibraryClosure(librarySource);
-      MD5 md5 = new MD5();
+
+      var digestList = <int>[];
+
+      var sink = new ChunkedConversionSink<List<int>>.withCallback((value) {
+        digestList = value;
+      });
+
       for (Source source in closure) {
         List<int> sourceHash = _getSourceContentHash(source);
-        md5.add(sourceHash);
+        sink.add(sourceHash);
       }
-      md5.add(configSalt);
-      return md5.close();
+      sink.add(configSalt);
+      return md5.convert(digestList).bytes;

[nweiz, 2016/04/14 21:53:09]

All you're doing here is a very roundabout way of adding a bunch of ints to a
list and then passing them wholesale to [md5.convert]. If you want to
iteratively build the hash, you need to pass a ChunkedConversionSink<Digest> to
[md5.startChunkedConversion].

[kevmoo, 2016/04/14 23:13:35]

Done.

     });
   }
 
   /**
    * Compute a hash of the given [source] contents.
    */
   List<int> _getSourceContentHash(Source source) {
     return _sourceContentHashMap.putIfAbsent(source, () {
       String sourceText = source.contents.data;
       List<int> sourceBytes = UTF8.encode(sourceText);
-      return (new MD5()..add(sourceBytes)).close();
+      return md5.convert(sourceBytes).bytes;
     });
   }
 
   /**
    * Return a source representing the URI that results from resolving the given
    * (possibly relative) [containedUri] against the URI associated with the
    * [containingSource], whether or not the resulting source exists, or `null`
    * if either the [containedUri] is invalid or if it cannot be resolved against
    * the [containingSource]'s URI.
    */
@@ skipping 89 matching lines @@
    */
   final String id;
 
   /**
    * The payload bundle.
    */
   final PackageBundle bundle;
 
   LibraryBundleWithId(this.source, this.id, this.bundle);
 }