Make CompilerTask independent of compiler.

pkg/compiler/lib/src/library_loader.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.
 
 library dart2js.library_loader;
 
 import 'dart:async';
 
 import 'common/names.dart' show Uris;
-import 'common/tasks.dart' show CompilerTask;
+import 'common/tasks.dart' show CompilerTask, GenericTask;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'elements/elements.dart'
     show
         CompilationUnitElement,
         Element,
         ImportElement,
         ExportElement,
         LibraryElement;
 import 'elements/modelx.dart'
@@ skipping 269 matching lines @@
   final LibraryDeserializer deserializer;
 
   /// Hooks to inform others about progress done by this loader.
   // TODO(sigmund): move away from this.
   final LibraryLoaderListener listener;
 
   /// Definitions provided via the `-D` command line flags. Used to resolve
   /// conditional imports.
   final Environment environment;
 
+  final Compiler compiler;
+  DiagnosticReporter get reporter => compiler.reporter;
+
   _LibraryLoaderTask(Compiler compiler, this.uriTranslator, this.scriptLoader,
       this.scanner, this.deserializer, this.listener, this.environment)
-      // TODO(sigmund): make measurements separate from compiler
-      : super(compiler);
+      : compiler = compiler,
+        super(compiler.measurer);
 
   String get name => 'LibraryLoader';
 
   final Map<Uri, LibraryElement> libraryCanonicalUriMap =
       new Map<Uri, LibraryElement>();
   final Map<Uri, LibraryElement> libraryResourceUriMap =
       new Map<Uri, LibraryElement>();
   final Map<String, LibraryElement> libraryNames =
       new Map<String, LibraryElement>();
 
   LibraryDependencyHandler currentHandler;
 
   Iterable<LibraryElement> get libraries => libraryCanonicalUriMap.values;
 
   LibraryElement lookupLibrary(Uri canonicalUri) {
     return libraryCanonicalUriMap[canonicalUri];
   }
 
   void reset({bool reuseLibrary(LibraryElement library)}) {
     measure(() {
       assert(currentHandler == null);
 
       Iterable<LibraryElement> reusedLibraries = null;
       if (reuseLibrary != null) {
-        // TODO(sigmund): make measurements separate from compiler
-        reusedLibraries = compiler.reuseLibraryTask.measure(() {
+        reusedLibraries = measureSubtask(_reuseLibrarySubtaskName, () {
           // Call [toList] to force eager calls to [reuseLibrary].
           return libraryCanonicalUriMap.values.where(reuseLibrary).toList();
         });
       }
 
       resetImplementation(reusedLibraries);
     });
   }
 
   void resetImplementation(Iterable<LibraryElement> reusedLibraries) {
@@ skipping 17 matching lines @@
           return reuseLibrary(library)
               .then((bool reuse) => reuse ? library : null);
         } catch (exception, trace) {
           reporter.onCrashInUserCode(
               'Uncaught exception in reuseLibrary', exception, trace);
           rethrow;
         }
       }
 
       List<Future<LibraryElement>> reusedLibrariesFuture =
-          // TODO(sigmund): make measurements separate from compiler
-          compiler.reuseLibraryTask.measure(
+          measureSubtask(_reuseLibrarySubtaskName,
               () => libraryCanonicalUriMap.values.map(wrapper).toList());
 
       return Future
           .wait(reusedLibrariesFuture)
           .then((Iterable<LibraryElement> reusedLibraries) {
         resetImplementation(reusedLibraries.where((e) => e != null));
       });
     });
   }
 
   Future<Null> resetLibraries(
       Future<Iterable<LibraryElement>> reuseLibraries(
           Iterable<LibraryElement> libraries)) {
     assert(currentHandler == null);
-    return compiler.reuseLibraryTask.measure(() {
+    return measureSubtask(_reuseLibrarySubtaskName, () {
       return new Future<Iterable<LibraryElement>>(() {
         // Wrap in Future to shield against errors in user code.
         return reuseLibraries(libraryCanonicalUriMap.values);
       }).catchError((exception, StackTrace trace) {
         compiler.reportCrashInUserCode(
             'Uncaught exception in reuseLibraries', exception, trace);
         throw exception; // Async rethrow.
       }).then((Iterable<LibraryElement> reusedLibraries) {
         measure(() {
           resetImplementation(reusedLibraries);
@@ skipping 1107 matching lines @@
   /// Called after a request to load a library. The [results] will include all
   /// transitive libraries loaded as a result of the initial request.
   Future onLibrariesLoaded(LoadedLibraries results);
 
   /// Called whenever a library element is created.
   void onLibraryCreated(LibraryElement library);
 
   /// Called whenever a library is scanned from a script file.
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader);
 }
+
+const _reuseLibrarySubtaskName = "Reuse library";