Report timing on failed executions too (#9661)

* handle errors

* review notes

packages/flutter_tools/lib/src/runner/flutter_command.dart

@@ -34,13 +34,11 @@ enum ExitStatus {
 /// provide a [FlutterCommandResult] to furnish additional information for
 /// analytics.
 class FlutterCommandResult {
-  FlutterCommandResult(
+  const FlutterCommandResult(
     this.exitStatus, {
     this.analyticsParameters,
     this.endTimeOverride,
-  }) { 
-    assert(exitStatus != null); 
-  }
+  });
 
   final ExitStatus exitStatus;
 
@@ -153,10 +151,15 @@ abstract class FlutterCommand extends Command<Null> {
     if (flutterUsage.isFirstRun)
       flutterUsage.printWelcome();
 
-    final FlutterCommandResult commandResult = await verifyThenRunCommand();
-
+    FlutterCommandResult commandResult;
+    try {
+      commandResult = await verifyThenRunCommand();
+    } on ToolExit {
+      commandResult = const FlutterCommandResult(ExitStatus.fail);
+      rethrow;
+    } finally {
       final DateTime endTime = clock.now();
-    printTrace("'flutter $name' took ${getElapsedAsMilliseconds(endTime.difference(startTime))}.");
+      printTrace('"flutter $name" took ${getElapsedAsMilliseconds(endTime.difference(startTime))}.');
       if (usagePath != null) {
         final List<String> labels = <String>[];
         if (commandResult?.exitStatus != null)
@@ -180,6 +183,8 @@ abstract class FlutterCommand extends Command<Null> {
       }
     }
 
+  }
+
   /// Perform validation then call [runCommand] to execute the command.
   /// Return a [Future] that completes with an exit code
   /// indicating whether execution was successful.
@@ -202,7 +207,7 @@ abstract class FlutterCommand extends Command<Null> {
     final String commandPath = await usagePath;
     if (commandPath != null)
       flutterUsage.sendCommand(commandPath);
-    return runCommand();
+    return await runCommand();
   }
 
   /// Subclasses must implement this to execute the command.

packages/flutter_tools/test/src/runner/flutter_command_test.dart

@@ -6,6 +6,7 @@ import 'dart:async';
 
 import 'package:flutter_tools/src/cache.dart';
 import 'package:flutter_tools/src/usage.dart';
+import 'package:flutter_tools/src/base/common.dart';
 import 'package:flutter_tools/src/runner/flutter_command.dart';
 import 'package:mockito/mockito.dart';
 import 'package:quiver/time.dart';
@@ -88,14 +89,15 @@ void main() {
       mockTimes = <int>[1000, 2000];
 
       final FlutterCommandResult commandResult = new FlutterCommandResult(
-        ExitStatus.fail,
+        ExitStatus.success,
         // nulls should be cleaned up.
         analyticsParameters: <String> ['blah1', 'blah2', null, 'blah3'],
         endTimeOverride: new DateTime.fromMillisecondsSinceEpoch(1500)
       );
 
-      final DummyFlutterCommand flutterCommand = 
-          new DummyFlutterCommand(flutterCommandResult: commandResult);
+      final DummyFlutterCommand flutterCommand = new DummyFlutterCommand(
+        commandFunction: () async => commandResult
+      );
       await flutterCommand.run();
       verify(clock.now()).called(2);
       expect(
@@ -104,7 +106,7 @@ void main() {
           'flutter',
           'dummy',
           const Duration(milliseconds: 500), // FlutterCommandResult's end time used instead.
-          'fail-blah1-blah2-blah3',
+          'success-blah1-blah2-blah3',
         ],
       );
     },
@@ -113,20 +115,47 @@ void main() {
       Usage: () => usage,
     });
 
+    testUsingContext('report failed execution timing too', () async {
+      // Crash if called a third time which is unexpected.
+      mockTimes = <int>[1000, 2000];
+
+      final DummyFlutterCommand flutterCommand =
+          new DummyFlutterCommand(commandFunction: () async { throwToolExit('fail'); });
+
+      try {
+        await flutterCommand.run();
+        fail('Mock should make this fail');
+      } on ToolExit {
+        // Should have still checked time twice.
+        verify(clock.now()).called(2);
+
+        expect(
+          verify(usage.sendTiming(captureAny, captureAny, captureAny, label: captureAny)).captured,
+          <dynamic>['flutter', 'dummy', const Duration(milliseconds: 1000), 'fail']
+        );
+      }
+    },
+    overrides: <Type, Generator>{
+      Clock: () => clock,
+      Usage: () => usage,
+    });
+
   });
 
 }
 
+typedef Future<FlutterCommandResult> CommandFunction();
+
 class DummyFlutterCommand extends FlutterCommand {
 
   DummyFlutterCommand({
     this.shouldUpdateCache : false,
     this.noUsagePath : false,
-    this.flutterCommandResult
+    this.commandFunction,
   });
 
   final bool noUsagePath;
-  final FlutterCommandResult flutterCommandResult;
+  final CommandFunction commandFunction;
 
   @override
   final bool shouldUpdateCache;
@@ -142,7 +171,7 @@ class DummyFlutterCommand extends FlutterCommand {
 
   @override
   Future<FlutterCommandResult> runCommand() async {
-    return flutterCommandResult;
+    return commandFunction == null ? null : commandFunction();
   }
 }