Add PoiTask to better measure timing.

dart/site/try/poi/poi.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 trydart.poi;
 
 import 'dart:async' show
     Completer,
     Future;
 
 import 'dart:io' as io;
 
 import 'dart:convert' show
     UTF8;
 
 import 'package:dart2js_incremental/dart2js_incremental.dart' show
     reuseCompiler;
 
 import 'package:dart2js_incremental/library_updater.dart' show
     LibraryUpdater;
 
 import 'package:compiler/implementation/source_file_provider.dart' show
     FormattingDiagnosticHandler;
 
 import 'package:compiler/compiler.dart' as api;
 
 import 'package:compiler/implementation/dart2jslib.dart' show
     Compiler,
+    CompilerTask,
     Enqueuer,
     QueueFilter,
     WorkItem;
 
 import 'package:compiler/implementation/elements/visitor.dart' show
     ElementVisitor;
 
 import 'package:compiler/implementation/elements/elements.dart' show
     AbstractFieldElement,
     ClassElement,
@@ skipping 49 matching lines @@
 /// really need.
 bool isVerbose = false;
 
 /// When true (the default value) print serialized scope information at the
 /// provided position.
 const bool PRINT_SCOPE_INFO =
     const bool.fromEnvironment('PRINT_SCOPE_INFO', defaultValue: true);
 
 Stopwatch wallClock = new Stopwatch();
 
+PoiTask poiTask;
+
 Compiler cachedCompiler;
 
 /// Iterator for reading lines from [io.stdin].
 class StdinIterator implements Iterator<String> {
   String current;
 
   bool moveNext() {
     current = io.stdin.readLineSync();
     return true;
   }
@@ skipping 255 matching lines @@
       '--no-source-maps',
       '--verbose',
       '--categories=Client,Server',
       '--incremental-support',
       '--disable-type-inference',
   ];
 
   LibraryUpdater updater =
       new LibraryUpdater(
           cachedCompiler, inputProvider, script, printWallClock, printVerbose);
+  Future<bool> reuseLibrary(LibraryElement library) {
+    return poiTask.measure(() => updater.reuseLibrary(library));
+  }
 
   return reuseCompiler(
       diagnosticHandler: handler,
       inputProvider: inputProvider,
       options: options,
       cachedCompiler: cachedCompiler,
       libraryRoot: libraryRoot,
       packageRoot: packageRoot,
       packagesAreImmutable: true,
-      reuseLibrary: updater.reuseLibrary).then((Compiler newCompiler) {
+      reuseLibrary: reuseLibrary).then((Compiler newCompiler) {
     var filter = new ScriptOnlyFilter(script);
     newCompiler.enqueuerFilter = filter;
     return runPoiInternal(newCompiler, updater, position);
   });
 }
 
 Future<Element> runPoiInternal(
     Compiler newCompiler,
     LibraryUpdater updater,
     int position) {
+
   cachedCompiler = newCompiler;
+  if (poiTask == null || poiTask.compiler != cachedCompiler) {
+    poiTask = new PoiTask(cachedCompiler);
+    cachedCompiler.tasks.add(poiTask);
+  }
 
   Future<bool> compilation = cachedCompiler.run(updater.uri);
 
   return compilation.then((success) {
     if (isVerbose) {
       for (final task in cachedCompiler.tasks) {
         int time = task.timingMicroseconds;
         if (time != 0) {
           printFormattedTime('${task.name} took', time);
         }
@@ skipping 314 matching lines @@
     buffer.write('\n');
     indented.write('}');
   }
 }
 
 modelx.ScopeX localScope(modelx.LibraryElementX element) => element.localScope;
 
 modelx.ImportScope importScope(modelx.LibraryElementX element) {
   return element.importScope;
 }
+
+class PoiTask extends CompilerTask {
+  PoiTask(Compiler compiler) : super(compiler);
+
+  String get name => 'POI';
+}