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

mojo/public/dart/third_party/analyzer/lib/src/generated/utilities_general.dart

Index: mojo/public/dart/third_party/analyzer/lib/src/generated/utilities_general.dart
diff --git a/mojo/public/dart/third_party/analyzer/lib/src/generated/utilities_general.dart b/mojo/public/dart/third_party/analyzer/lib/src/generated/utilities_general.dart
new file mode 100644
index 0000000000000000000000000000000000000000..83bfaa1a7db664dfbeed99aae9bb84e4adbf7f11
--- /dev/null
+++ b/mojo/public/dart/third_party/analyzer/lib/src/generated/utilities_general.dart
@@ -0,0 +1,154 @@
+// 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.
+
+library engine.utilities.general;
+
+import 'dart:profiler';
+
+/**
+ * Jenkins hash function, optimized for small integers.
+ * Borrowed from sdk/lib/math/jenkins_smi_hash.dart.
+ */
+class JenkinsSmiHash {
+  static int combine(int hash, int value) {
+    hash = 0x1fffffff & (hash + value);
+    hash = 0x1fffffff & (hash + ((0x0007ffff & hash) << 10));
+    return hash ^ (hash >> 6);
+  }
+
+  static int finish(int hash) {
+    hash = 0x1fffffff & (hash + ((0x03ffffff & hash) << 3));
+    hash = hash ^ (hash >> 11);
+    return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
+  }
+
+  static int hash2(a, b) => finish(combine(combine(0, a), b));
+
+  static int hash3(a, b, c) => finish(combine(combine(combine(0, a), b), c));
+
+  static int hash4(a, b, c, d) =>
+      finish(combine(combine(combine(combine(0, a), b), c), d));
+}
+
+/**
+ * Helper class for gathering performance statistics.  This class is modeled on
+ * the UserTag class in dart:profiler so that it can interoperate easily with
+ * it.
+ */
+abstract class PerformanceTag {
+  /**
+   * Return a list of all [PerformanceTag]s which have been created.
+   */
+  static List<PerformanceTag> get all => _PerformanceTagImpl.all.toList();
+
+  /**
+   * Return the current [PerformanceTag] for the isolate.
+   */
+  static PerformanceTag get current => _PerformanceTagImpl.current;
+
+  /**
+   * Return the [PerformanceTag] that is initially current.  This is intended
+   * to track time when the system is performing unknown operations.
+   */
+  static PerformanceTag get UNKNOWN => _PerformanceTagImpl.UNKNOWN;
+
+  /**
+   * Create a [PerformanceTag] having the given [label].  A [UserTag] will also
+   * be created, having the same [label], so that performance information can
+   * be queried using the observatory.
+   */
+  factory PerformanceTag(String label) = _PerformanceTagImpl;
+
+  /**
+   * Return the total number of milliseconds that this [PerformanceTag] has
+   * been the current [PerformanceTag] for the isolate.
+   *
+   * This call is safe even if this [PerformanceTag] is current.
+   */
+  int get elapsedMs;
+
+  /**
+   * Return the label for this [PerformanceTag].
+   */
+  String get label;
+
+  /**
+   * Make this the current tag for the isolate, and return the previous tag.
+   */
+  PerformanceTag makeCurrent();
+
+  /**
+   * Make this the current tag for the isolate, run [f], and restore the
+   * previous tag. Returns the result of invoking [f].
+   */
+  makeCurrentWhile(f());
+
+  /**
+   * Reset the total time tracked by all [PerformanceTag]s to zero.
+   */
+  static void reset() {
+    for (_PerformanceTagImpl tag in _PerformanceTagImpl.all) {
+      tag.stopwatch.reset();
+    }
+  }
+}
+
+class _PerformanceTagImpl implements PerformanceTag {
+  /**
+   * The current performance tag for the isolate.
+   */
+  static _PerformanceTagImpl current = UNKNOWN;
+
+  static final _PerformanceTagImpl UNKNOWN = new _PerformanceTagImpl('unknown');
+
+  /**
+   * A list of all performance tags that have been created so far.
+   */
+  static List<_PerformanceTagImpl> all = <_PerformanceTagImpl>[];
+
+  /**
+   * The [UserTag] associated with this [PerformanceTag].
+   */
+  final UserTag userTag;
+
+  /**
+   * Stopwatch tracking the amount of time this [PerformanceTag] has been the
+   * current tag for the isolate.
+   */
+  final Stopwatch stopwatch;
+
+  _PerformanceTagImpl(String label)
+      : userTag = new UserTag(label),
+        stopwatch = new Stopwatch() {
+    all.add(this);
+  }
+
+  @override
+  int get elapsedMs => stopwatch.elapsedMilliseconds;
+
+  @override
+  String get label => userTag.label;
+
+  @override
+  PerformanceTag makeCurrent() {
+    if (identical(this, current)) {
+      return current;
+    }
+    _PerformanceTagImpl previous = current;
+    previous.stopwatch.stop();
+    stopwatch.start();
+    current = this;
+    userTag.makeCurrent();
+    return previous;
+  }
+
+  makeCurrentWhile(f()) {
+    PerformanceTag prevTag = makeCurrent();
+    try {
+      return f();
+    } finally {
+      prevTag.makeCurrent();
+    }
+  }
+}