Properly update git binary snapshots during pub upgrade.

sdk/lib/_internal/pub_generated/lib/src/solver/backtracking_solver.dart

 // Copyright (c) 2012, 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.
 
 /// A back-tracking depth-first solver.
 ///
 /// Attempts to find the best solution for a root package's transitive
 /// dependency graph, where a "solution" is a set of concrete package versions.
 /// A valid solution will select concrete versions for every package reached
 /// from the root package's dependency graph, and each of those packages will
@@ skipping 109 matching lines @@
     for (var override in root.dependencyOverrides) {
       _overrides[override.name] = override;
     }
   }
 
   /// Run the solver.
   ///
   /// Completes with a list of specific package versions if successful or an
   /// error if it failed to find a solution.
   Future<SolveResult> solve() {
-    var stopwatch = new Stopwatch();
-
-    _logParameters();
-
-    // Sort the overrides by package name to make sure they're deterministic.
-    var overrides = _overrides.values.toList();
-    overrides.sort((a, b) => a.name.compareTo(b.name));
-
-    return newFuture(() {
-      stopwatch.start();
-
-      // Pre-cache the root package's known pubspec.
-      cache.cache(new PackageId.root(root), root.pubspec);
-
-      _validateSdkConstraint(root.pubspec);
-      return _traverseSolution();
-    }).then((packages) {
-      var pubspecs = new Map.fromIterable(
-          packages,
-          key: (id) => id.name,
-          value: (id) => cache.getCachedPubspec(id));
-
-      return new SolveResult.success(
-          sources,
-          root,
-          lockFile,
-          packages,
-          overrides,
-          pubspecs,
-          _getAvailableVersions(packages),
-          attemptedSolutions);
-    }).catchError((error) {
-      if (error is! SolveFailure) throw error;
-
-      // Wrap a failure in a result so we can attach some other data.
-      return new SolveResult.failure(
-          sources,
-          root,
-          lockFile,
-          overrides,
-          error,
-          attemptedSolutions);
-    }).whenComplete(() {
-      // Gather some solving metrics.
-      var buffer = new StringBuffer();
-      buffer.writeln('${runtimeType} took ${stopwatch.elapsed} seconds.');
-      buffer.writeln(cache.describeResults());
-      log.solver(buffer);
+    final completer0 = new Completer();
+    scheduleMicrotask(() {
+      try {
+        var stopwatch = new Stopwatch();
+        _logParameters();
+        var overrides = _overrides.values.toList();
+        overrides.sort(((a, b) {
+          return a.name.compareTo(b.name);
+        }));
+        join0() {
+          completer0.complete();
+        }
+        finally0(cont0) {
+          try {
+            var buffer = new StringBuffer();
+            buffer.writeln('${runtimeType} took ${stopwatch.elapsed} seconds.');
+            buffer.writeln(cache.describeResults());
+            log.solver(buffer);
+            cont0();
+          } catch (e0, s0) {
+            completer0.completeError(e0, s0);
+          }
+        }
+        catch0(error, s1) {
+          try {
+            if (error is SolveFailure) {
+              final v0 = new SolveResult.failure(
+                  sources,
+                  root,
+                  lockFile,
+                  overrides,
+                  error,
+                  attemptedSolutions);
+              finally0(() {
+                completer0.complete(v0);
+              });
+            } else {
+              throw error;
+            }
+          } catch (error, s1) {
+            finally0(() => completer0.completeError(error, s1));
+          }
+        }
+        try {
+          stopwatch.start();
+          cache.cache(new PackageId.root(root), root.pubspec);
+          _validateSdkConstraint(root.pubspec);
+          new Future.value(_traverseSolution()).then((x0) {
+            try {
+              var packages = x0;
+              var pubspecs = new Map.fromIterable(packages, key: ((id) {
+                return id.name;
+              }), value: ((id) {
+                return cache.getCachedPubspec(id);
+              }));
+              new Future.value(Future.wait(packages.map(((id) {
+                return sources[id.source].resolveId(id);
+              })))).then((x1) {
+                try {
+                  packages = x1;
+                  final v1 = new SolveResult.success(
+                      sources,
+                      root,
+                      lockFile,
+                      packages,
+                      overrides,
+                      pubspecs,
+                      _getAvailableVersions(packages),
+                      attemptedSolutions);
+                  finally0(() {
+                    completer0.complete(v1);
+                  });
+                } catch (e1, s2) {
+                  catch0(e1, s2);
+                }
+              }, onError: catch0);
+            } catch (e2, s3) {
+              catch0(e2, s3);
+            }
+          }, onError: catch0);
+        } catch (e3, s4) {
+          catch0(e3, s4);
+        }
+      } catch (e, s) {
+        completer0.completeError(e, s);
+      }
     });
+    return completer0.future;
   }
 
   /// Generates a map containing all of the known available versions for each
   /// package in [packages].
   ///
   /// The version list may not always be complete. The the package is the root
   /// root package, or its a package that we didn't unlock while solving
   /// because we weren't trying to upgrade it, we will just know the current
   /// version.
   Map<String, List<Version>> _getAvailableVersions(List<PackageId> packages) {
@@ skipping 608 matching lines @@
 ///
 /// Throws a [SolveFailure] if not.
 void _validateSdkConstraint(Pubspec pubspec) {
   if (pubspec.environment.sdkVersion.allows(sdk.version)) return;
 
   throw new BadSdkVersionException(
       pubspec.name,
       'Package ${pubspec.name} requires SDK version '
           '${pubspec.environment.sdkVersion} but the current SDK is ' '${sdk.version}.');
 }