Stop running pub get at gclient sync time and fix build bugs

mojo/public/dart/third_party/barback/test/package_graph/transform/concurrency_test.dart

Index: mojo/public/dart/third_party/barback/test/package_graph/transform/concurrency_test.dart
diff --git a/mojo/public/dart/third_party/barback/test/package_graph/transform/concurrency_test.dart b/mojo/public/dart/third_party/barback/test/package_graph/transform/concurrency_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..f8927bb8c36b46644e60928a289971312fb98176
--- /dev/null
+++ b/mojo/public/dart/third_party/barback/test/package_graph/transform/concurrency_test.dart
@@ -0,0 +1,594 @@
+// Copyright (c) 2014, 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.
+
+/// This library contains tests for transformer behavior that relates to actions
+/// happening concurrently or other complex asynchronous timing behavior.
+library barback.test.package_graph.transform.concurrency_test;
+
+import 'package:barback/src/utils.dart';
+import 'package:scheduled_test/scheduled_test.dart';
+
+import '../../utils.dart';
+
+main() {
+  initConfig();
+  test("runs transforms in the same phase in parallel", () {
+    var transformerA = new RewriteTransformer("txt", "a");
+    var transformerB = new RewriteTransformer("txt", "b");
+    initGraph(["app|foo.txt"], {"app": [[transformerA, transformerB]]});
+
+    transformerA.pauseApply();
+    transformerB.pauseApply();
+
+    updateSources(["app|foo.txt"]);
+
+    transformerA.waitUntilStarted();
+    transformerB.waitUntilStarted();
+
+    // They should both still be running.
+    expect(transformerA.isRunning, completion(isTrue));
+    expect(transformerB.isRunning, completion(isTrue));
+
+    transformerA.resumeApply();
+    transformerB.resumeApply();
+
+    expectAsset("app|foo.a", "foo.a");
+    expectAsset("app|foo.b", "foo.b");
+    buildShouldSucceed();
+  });
+
+  test("discards outputs from a transform whose primary input is removed "
+      "during processing", () {
+    var rewrite = new RewriteTransformer("txt", "out");
+    initGraph(["app|foo.txt"], {"app": [[rewrite]]});
+
+    rewrite.pauseApply();
+    updateSources(["app|foo.txt"]);
+    rewrite.waitUntilStarted();
+
+    removeSources(["app|foo.txt"]);
+    rewrite.resumeApply();
+    expectNoAsset("app|foo.out");
+    buildShouldSucceed();
+  });
+
+  test("applies the correct transform if an asset is modified during isPrimary",
+      () {
+    var check1 = new CheckContentTransformer("first", "#1");
+    var check2 = new CheckContentTransformer("second", "#2");
+    initGraph({
+      "app|foo.txt": "first",
+    }, {"app": [[check1, check2]]});
+
+    check1.pauseIsPrimary("app|foo.txt");
+    updateSources(["app|foo.txt"]);
+    // Ensure that we're waiting on check1's isPrimary.
+    schedule(pumpEventQueue);
+
+    modifyAsset("app|foo.txt", "second");
+    updateSources(["app|foo.txt"]);
+    check1.resumeIsPrimary("app|foo.txt");
+
+    expectAsset("app|foo.txt", "second#2");
+    buildShouldSucceed();
+  });
+
+  test("applies the correct transform if an asset is removed and added during "
+      "isPrimary", () {
+    var check1 = new CheckContentTransformer("first", "#1");
+    var check2 = new CheckContentTransformer("second", "#2");
+    initGraph({
+      "app|foo.txt": "first",
+    }, {"app": [[check1, check2]]});
+
+    check1.pauseIsPrimary("app|foo.txt");
+    updateSources(["app|foo.txt"]);
+    // Ensure that we're waiting on check1's isPrimary.
+    schedule(pumpEventQueue);
+
+    removeSources(["app|foo.txt"]);
+    modifyAsset("app|foo.txt", "second");
+    updateSources(["app|foo.txt"]);
+    check1.resumeIsPrimary("app|foo.txt");
+
+    expectAsset("app|foo.txt", "second#2");
+    buildShouldSucceed();
+  });
+
+  test("restarts processing if a change occurs during processing", () {
+    var transformer = new RewriteTransformer("txt", "out");
+    initGraph(["app|foo.txt"], {"app": [[transformer]]});
+
+    transformer.pauseApply();
+
+    updateSources(["app|foo.txt"]);
+    transformer.waitUntilStarted();
+
+    // Now update the graph during it.
+    updateSources(["app|foo.txt"]);
+    transformer.resumeApply();
+
+    expectAsset("app|foo.out", "foo.out");
+    buildShouldSucceed();
+
+    expect(transformer.numRuns, completion(equals(2)));
+  });
+
+  test("aborts processing if the primary input is removed during processing",
+      () {
+    var transformer = new RewriteTransformer("txt", "out");
+    initGraph(["app|foo.txt"], {"app": [[transformer]]});
+
+    transformer.pauseApply();
+
+    updateSources(["app|foo.txt"]);
+    transformer.waitUntilStarted();
+
+    // Now remove its primary input while it's running.
+    removeSources(["app|foo.txt"]);
+    transformer.resumeApply();
+
+    expectNoAsset("app|foo.out");
+    buildShouldSucceed();
+
+    expect(transformer.numRuns, completion(equals(1)));
+  });
+
+  test("restarts processing if a change to a new secondary input occurs during "
+      "processing", () {
+    var transformer = new ManyToOneTransformer("txt");
+    initGraph({
+      "app|foo.txt": "bar.inc",
+      "app|bar.inc": "bar"
+    }, {"app": [[transformer]]});
+
+    transformer.pauseApply();
+
+    updateSources(["app|foo.txt", "app|bar.inc"]);
+    transformer.waitUntilStarted();
+
+    // Give the transform time to load bar.inc the first time.
+    schedule(pumpEventQueue);
+
+    // Now update the secondary input before the transform finishes.
+    modifyAsset("app|bar.inc", "baz");
+    updateSources(["app|bar.inc"]);
+    // Give bar.inc enough time to be loaded and marked available before the
+    // transformer completes.
+    schedule(pumpEventQueue);
+
+    transformer.resumeApply();
+
+    expectAsset("app|foo.out", "baz");
+    buildShouldSucceed();
+
+    expect(transformer.numRuns, completion(equals(2)));
+  });
+
+  test("doesn't restart processing if a change to an old secondary input "
+      "occurs during processing", () {
+    var transformer = new ManyToOneTransformer("txt");
+    initGraph({
+      "app|foo.txt": "bar.inc",
+      "app|bar.inc": "bar",
+      "app|baz.inc": "baz"
+    }, {"app": [[transformer]]});
+
+    updateSources(["app|foo.txt", "app|bar.inc", "app|baz.inc"]);
+    expectAsset("app|foo.out", "bar");
+    buildShouldSucceed();
+
+    transformer.pauseApply();
+    modifyAsset("app|foo.txt", "baz.inc");
+    updateSources(["app|foo.txt"]);
+    transformer.waitUntilStarted();
+
+    // Now update the old secondary input before the transform finishes.
+    modifyAsset("app|bar.inc", "new bar");
+    updateSources(["app|bar.inc"]);
+    // Give bar.inc enough time to be loaded and marked available before the
+    // transformer completes.
+    schedule(pumpEventQueue);
+
+    transformer.resumeApply();
+    expectAsset("app|foo.out", "baz");
+    buildShouldSucceed();
+
+    // Should have run once the first time, then again when switching to
+    // baz.inc. Should not run a third time because of bar.inc being modified.
+    expect(transformer.numRuns, completion(equals(2)));
+  });
+
+  test("restarts before finishing later phases when a change occurs", () {
+    var txtToInt = new RewriteTransformer("txt", "int");
+    var intToOut = new RewriteTransformer("int", "out");
+    initGraph(["app|foo.txt", "app|bar.txt"],
+        {"app": [[txtToInt], [intToOut]]});
+
+    txtToInt.pauseApply();
+
+    updateSources(["app|foo.txt"]);
+    txtToInt.waitUntilStarted();
+
+    // Now update the graph during it.
+    updateSources(["app|bar.txt"]);
+    txtToInt.resumeApply();
+
+    expectAsset("app|foo.out", "foo.int.out");
+    expectAsset("app|bar.out", "bar.int.out");
+    buildShouldSucceed();
+
+    // Should only have run each transform once for each primary.
+    expect(txtToInt.numRuns, completion(equals(2)));
+    expect(intToOut.numRuns, completion(equals(2)));
+  });
+
+  test("doesn't return an asset until it's finished rebuilding", () {
+    initGraph(["app|foo.in"], {"app": [
+      [new RewriteTransformer("in", "mid")],
+      [new RewriteTransformer("mid", "out")]
+    ]});
+
+    updateSources(["app|foo.in"]);
+    expectAsset("app|foo.out", "foo.mid.out");
+    buildShouldSucceed();
+
+    pauseProvider();
+    modifyAsset("app|foo.in", "new");
+    updateSources(["app|foo.in"]);
+    expectAssetDoesNotComplete("app|foo.out");
+    buildShouldNotBeDone();
+
+    resumeProvider();
+    expectAsset("app|foo.out", "new.mid.out");
+    buildShouldSucceed();
+  });
+
+  test("doesn't return an asset until its in-place transform is done", () {
+    var rewrite = new RewriteTransformer("txt", "txt");
+    initGraph(["app|foo.txt"], {"app": [[rewrite]]});
+
+    rewrite.pauseApply();
+    updateSources(["app|foo.txt"]);
+    expectAssetDoesNotComplete("app|foo.txt");
+
+    rewrite.resumeApply();
+    expectAsset("app|foo.txt", "foo.txt");
+    buildShouldSucceed();
+  });
+
+  test("doesn't return an asset that's removed during isPrimary", () {
+    var rewrite = new RewriteTransformer("txt", "txt");
+    initGraph(["app|foo.txt"], {"app": [[rewrite]]});
+
+    rewrite.pauseIsPrimary("app|foo.txt");
+    updateSources(["app|foo.txt"]);
+    // Make sure we're waiting on isPrimary.
+    schedule(pumpEventQueue);
+
+    removeSources(["app|foo.txt"]);
+    rewrite.resumeIsPrimary("app|foo.txt");
+    expectNoAsset("app|foo.txt");
+    buildShouldSucceed();
+  });
+
+  test("doesn't transform an asset that goes from primary to non-primary "
+      "during isPrimary", () {
+    var check = new CheckContentTransformer(new RegExp(r"^do$"), "ne");
+    initGraph({
+      "app|foo.txt": "do"
+    }, {"app": [[check]]});
+
+    check.pauseIsPrimary("app|foo.txt");
+    updateSources(["app|foo.txt"]);
+    // Make sure we're waiting on isPrimary.
+    schedule(pumpEventQueue);
+
+    modifyAsset("app|foo.txt", "don't");
+    updateSources(["app|foo.txt"]);
+    check.resumeIsPrimary("app|foo.txt");
+
+    expectAsset("app|foo.txt", "don't");
+    buildShouldSucceed();
+  });
+
+  test("transforms an asset that goes from non-primary to primary "
+      "during isPrimary", () {
+    var check = new CheckContentTransformer("do", "ne");
+    initGraph({
+      "app|foo.txt": "don't"
+    }, {"app": [[check]]});
+
+    check.pauseIsPrimary("app|foo.txt");
+    updateSources(["app|foo.txt"]);
+    // Make sure we're waiting on isPrimary.
+    schedule(pumpEventQueue);
+
+    modifyAsset("app|foo.txt", "do");
+    updateSources(["app|foo.txt"]);
+    check.resumeIsPrimary("app|foo.txt");
+
+    expectAsset("app|foo.txt", "done");
+    buildShouldSucceed();
+  });
+
+  test("doesn't return an asset that's removed during another transformer's "
+      "isPrimary", () {
+    var rewrite1 = new RewriteTransformer("txt", "txt");
+    var rewrite2 = new RewriteTransformer("md", "md");
+    initGraph(["app|foo.txt", "app|foo.md"], {"app": [[rewrite1, rewrite2]]});
+
+    rewrite2.pauseIsPrimary("app|foo.md");
+    updateSources(["app|foo.txt", "app|foo.md"]);
+    // Make sure we're waiting on the correct isPrimary.
+    schedule(pumpEventQueue);
+
+    removeSources(["app|foo.txt"]);
+    rewrite2.resumeIsPrimary("app|foo.md");
+    expectNoAsset("app|foo.txt");
+    expectAsset("app|foo.md", "foo.md");
+    buildShouldSucceed();
+  });
+
+  test("doesn't transform an asset that goes from primary to non-primary "
+      "during another transformer's isPrimary", () {
+    var rewrite = new RewriteTransformer("md", "md");
+    var check = new CheckContentTransformer(new RegExp(r"^do$"), "ne");
+    initGraph({
+      "app|foo.txt": "do",
+      "app|foo.md": "foo"
+    }, {"app": [[rewrite, check]]});
+
+    rewrite.pauseIsPrimary("app|foo.md");
+    updateSources(["app|foo.txt", "app|foo.md"]);
+    // Make sure we're waiting on the correct isPrimary.
+    schedule(pumpEventQueue);
+
+    modifyAsset("app|foo.txt", "don't");
+    updateSources(["app|foo.txt"]);
+    rewrite.resumeIsPrimary("app|foo.md");
+
+    expectAsset("app|foo.txt", "don't");
+    expectAsset("app|foo.md", "foo.md");
+    buildShouldSucceed();
+  });
+
+  test("transforms an asset that goes from non-primary to primary "
+      "during another transformer's isPrimary", () {
+    var rewrite = new RewriteTransformer("md", "md");
+    var check = new CheckContentTransformer("do", "ne");
+    initGraph({
+      "app|foo.txt": "don't",
+      "app|foo.md": "foo"
+    }, {"app": [[rewrite, check]]});
+
+    rewrite.pauseIsPrimary("app|foo.md");
+    updateSources(["app|foo.txt", "app|foo.md"]);
+    // Make sure we're waiting on the correct isPrimary.
+    schedule(pumpEventQueue);
+
+    modifyAsset("app|foo.txt", "do");
+    updateSources(["app|foo.txt"]);
+    rewrite.resumeIsPrimary("app|foo.md");
+
+    expectAsset("app|foo.txt", "done");
+    expectAsset("app|foo.md", "foo.md");
+    buildShouldSucceed();
+  });
+
+  test("returns an asset even if an unrelated build is running", () {
+    initGraph([
+      "app|foo.in",
+      "app|bar.in",
+    ], {"app": [[new RewriteTransformer("in", "out")]]});
+
+    updateSources(["app|foo.in", "app|bar.in"]);
+    expectAsset("app|foo.out", "foo.out");
+    expectAsset("app|bar.out", "bar.out");
+    buildShouldSucceed();
+
+    pauseProvider();
+    modifyAsset("app|foo.in", "new");
+    updateSources(["app|foo.in"]);
+    expectAssetDoesNotComplete("app|foo.out");
+    expectAsset("app|bar.out", "bar.out");
+    buildShouldNotBeDone();
+
+    resumeProvider();
+    expectAsset("app|foo.out", "new.out");
+    buildShouldSucceed();
+  });
+
+  test("doesn't report AssetNotFound until all builds are finished", () {
+    initGraph([
+      "app|foo.in",
+    ], {"app": [[new RewriteTransformer("in", "out")]]});
+
+    updateSources(["app|foo.in"]);
+    expectAsset("app|foo.out", "foo.out");
+    buildShouldSucceed();
+
+    pauseProvider();
+    updateSources(["app|foo.in"]);
+    expectAssetDoesNotComplete("app|foo.out");
+    expectAssetDoesNotComplete("app|non-existent.out");
+    buildShouldNotBeDone();
+
+    resumeProvider();
+    expectAsset("app|foo.out", "foo.out");
+    expectNoAsset("app|non-existent.out");
+    buildShouldSucceed();
+  });
+
+  test("doesn't emit a result until all builds are finished", () {
+    var rewrite = new RewriteTransformer("txt", "out");
+    initGraph([
+      "pkg1|foo.txt",
+      "pkg2|foo.txt"
+    ], {"pkg1": [[rewrite]], "pkg2": [[rewrite]]});
+
+    // First, run both packages' transformers so both packages are successful.
+    updateSources(["pkg1|foo.txt", "pkg2|foo.txt"]);
+    expectAsset("pkg1|foo.out", "foo.out");
+    expectAsset("pkg2|foo.out", "foo.out");
+    buildShouldSucceed();
+
+    // pkg1 is still successful, but pkg2 is waiting on the provider, so the
+    // overall build shouldn't finish.
+    pauseProvider();
+    updateSources(["pkg2|foo.txt"]);
+    expectAsset("pkg1|foo.out", "foo.out");
+    buildShouldNotBeDone();
+
+    // Now that the provider is unpaused, pkg2's transforms finish and the
+    // overall build succeeds.
+    resumeProvider();
+    buildShouldSucceed();
+  });
+
+  test("one transformer takes a long time while the other finishes, then "
+      "the input is removed", () {
+    var rewrite1 = new RewriteTransformer("txt", "out1");
+    var rewrite2 = new RewriteTransformer("txt", "out2");
+    initGraph(["app|foo.txt"], {"app": [[rewrite1, rewrite2]]});
+
+    rewrite1.pauseApply();
+
+    updateSources(["app|foo.txt"]);
+
+    // Wait for rewrite1 to pause and rewrite2 to finish.
+    schedule(pumpEventQueue);
+
+    removeSources(["app|foo.txt"]);
+
+    // Make sure the removal is processed completely before we restart rewrite2.
+    schedule(pumpEventQueue);
+    rewrite1.resumeApply();
+
+    buildShouldSucceed();
+    expectNoAsset("app|foo.out1");
+    expectNoAsset("app|foo.out2");
+  });
+
+  test("a transformer in a later phase gets a slow secondary input from an "
+      "earlier phase", () {
+    var rewrite = new RewriteTransformer("in", "in");
+    initGraph({
+      "app|foo.in": "foo",
+      "app|bar.txt": "foo.in"
+    }, {"app": [
+      [rewrite],
+      [new ManyToOneTransformer("txt")]
+    ]});
+
+    rewrite.pauseApply();
+    updateSources(["app|foo.in", "app|bar.txt"]);
+    expectAssetDoesNotComplete("app|bar.out");
+
+    rewrite.resumeApply();
+    expectAsset("app|bar.out", "foo.in");
+    buildShouldSucceed();
+  });
+
+  test("materializes a passed-through asset that was emitted before it was "
+      "available", () {
+    initGraph(["app|foo.in"], {"app": [
+      [new RewriteTransformer("txt", "txt")]
+    ]});
+
+    pauseProvider();
+    updateSources(["app|foo.in"]);
+    expectAssetDoesNotComplete("app|foo.in");
+
+    resumeProvider();
+    expectAsset("app|foo.in", "foo");
+    buildShouldSucceed();
+  });
+
+  test("re-runs if the primary input is invalidated before accessing", () {
+    var transformer1 = new RewriteTransformer("txt", "mid");
+    var transformer2 = new RewriteTransformer("mid", "out");
+
+    initGraph([
+      "app|foo.txt"
+    ], {"app": [
+      [transformer1],
+      [transformer2]
+    ]});
+
+    transformer2.pausePrimaryInput();
+    updateSources(["app|foo.txt"]);
+
+    // Wait long enough to ensure that transformer1 has completed and
+    // transformer2 has started.
+    schedule(pumpEventQueue);
+
+    // Update the source again so that transformer1 invalidates the primary
+    // input of transformer2.
+    transformer1.pauseApply();
+    modifyAsset("app|foo.txt", "new foo");
+    updateSources(["app|foo.txt"]);
+
+    transformer2.resumePrimaryInput();
+    transformer1.resumeApply();
+
+    expectAsset("app|foo.out", "new foo.mid.out");
+    buildShouldSucceed();
+
+    expect(transformer1.numRuns, completion(equals(2)));
+    expect(transformer2.numRuns, completion(equals(2)));
+  });
+
+  // Regression test for issue 19038.
+  test("a secondary input that's marked dirty followed by the primary input "
+      "being synchronously marked dirty re-runs a transformer", () {
+    // Issue 19038 was caused by the following sequence of events:
+    //
+    // * Several inputs are marked dirty at once, causing dirty events to
+    //   propagate synchronously throughout the transform graph.
+    //
+    // * A transform (ManyToOneTransformer in this test case) has a secondary
+    //   input ("one.in") and a primary input ("foo.txt") that will both be
+    //   marked dirty.
+    //
+    // * The secondary input is marked dirty before the primary input. This
+    //   causes the transform to start running `apply`. Since as far as it knows
+    //   its primary input is still available, it passes that input to `apply`.
+    //
+    // * Now the primary input is marked dirty. The transform node checks to see
+    //   if this primary input has already been added to the transform
+    //   controller. This is where the bug existed: the answer to this was
+    //   incorrectly "no" until after some asynchronous processing occurred.
+    //
+    // * Since the transform thought the primary input hadn't yet been passed to
+    //   the transform controller, it didn't bother restarting the transform,
+    //   causing the old output to be preserved incorrectly.
+    initGraph({
+      "app|foo.txt": "one",
+      "app|one.in": "1",
+      "app|two.in": "2"
+    }, {"app": [
+      // We need to use CheckContentTransformer here so that
+      // ManyToOneTransformer reads its primary input from memory rather than
+      // from the filesystem. If it read from the filesystem, it might
+      // accidentally get the correct output despite accessing the incorrect
+      // asset, which would cause false positives for the test.
+      [new CheckContentTransformer(new RegExp("one|two"), ".in")],
+      [new ManyToOneTransformer("txt")]
+    ]});
+
+    updateSources(["app|foo.txt", "app|one.in", "app|two.in"]);
+    expectAsset("app|foo.out", "1");
+    buildShouldSucceed();
+
+    modifyAsset("app|foo.txt", "two");
+
+    // It's important that "one.in" come first in this list, since
+    // ManyToOneTransformer needs to see its secondary input change first.
+    updateSources(["app|one.in", "app|foo.txt"]);
+
+    expectAsset("app|foo.out", "2");
+    buildShouldSucceed();
+  });
+}