Make CompilerTask independent of compiler.

pkg/compiler/lib/src/deferred_load.dart

 // 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 deferred_load;
 
 import 'common/backend_api.dart' show Backend;
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
@@ skipping 134 matching lines @@
   final Map<_DeferredImport, ImportDescription> _deferredImportDescriptions =
       <_DeferredImport, ImportDescription>{};
 
   // For each deferred import we want to know exactly what elements have to
   // be loaded.
   Map<_DeferredImport, Set<Element>> _importedDeferredBy = null;
   Map<_DeferredImport, Set<ConstantValue>> _constantsDeferredBy = null;
 
   Set<Element> _mainElements = new Set<Element>();
 
-  DeferredLoadTask(Compiler compiler) : super(compiler) {
+  final Compiler compiler;
+  DeferredLoadTask(Compiler compiler)
+      : compiler = compiler,
+        super(compiler.measurer) {
     mainOutputUnit.imports.add(_fakeMainImport);
   }
 
   Backend get backend => compiler.backend;
+  DiagnosticReporter get reporter => compiler.reporter;
 
   /// Returns the [OutputUnit] where [element] belongs.
   OutputUnit outputUnitForElement(Element element) {
     if (!isProgramSplit) return mainOutputUnit;
 
     element = element.implementation;
     while (!_elementToOutputUnit.containsKey(element)) {
       // TODO(21051): workaround: it looks like we output annotation constants
       // for classes that we don't include in the output. This seems to happen
       // when we have reflection but can see that some classes are not needed.
@@ skipping 452 matching lines @@
     if (!isProgramSplit) {
       allOutputUnits.add(mainOutputUnit);
       return;
     }
     if (main == null) return;
     LibraryElement mainLibrary = main.library;
     _importedDeferredBy = new Map<_DeferredImport, Set<Element>>();
     _constantsDeferredBy = new Map<_DeferredImport, Set<ConstantValue>>();
     _importedDeferredBy[_fakeMainImport] = _mainElements;
 
-    measureElement(mainLibrary, () {
+    reporter.withCurrentElement(mainLibrary, () => measure(() {
       // Starting from main, traverse the program and find all dependencies.
       _mapDependencies(element: compiler.mainFunction, import: _fakeMainImport);
 
       // Also add "global" dependencies to the main OutputUnit.  These are
       // things that the backend needs but cannot associate with a particular
       // element, for example, startRootIsolate.  This set also contains
       // elements for which we lack precise information.
       for (Element element in compiler.globalDependencies.otherDependencies) {
         _mapDependencies(element: element, import: _fakeMainImport);
       }
@@ skipping 60 matching lines @@
         OutputUnit representative = allOutputUnits.lookup(outputUnit);
         if (representative == null) {
           representative = outputUnit;
           allOutputUnits.add(representative);
         }
         _constantToOutputUnit[constant] = representative;
       });
 
       // Generate a unique name for each OutputUnit.
       _assignNamesToOutputUnits(allOutputUnits);
-    });
+    }));
     // Notify the impact strategy impacts are no longer needed for deferred
     // load.
     compiler.impactStrategy.onImpactUsed(IMPACT_USE);
   }
 
   void beforeResolution(Compiler compiler) {
     if (compiler.mainApp == null) return;
     _allDeferredImports[_fakeMainImport] = compiler.mainApp;
     var lastDeferred;
     // When detecting duplicate prefixes of deferred libraries there are 4
@@ skipping 274 matching lines @@
     return result;
   }
 
   bool operator ==(other) {
     if (other is! _DeclaredDeferredImport) return false;
     return declaration == other.declaration;
   }
 
   int get hashCode => declaration.hashCode * 17;
 }