Add metadata to messages emitted by live tests.

doc/json_reporter.md

 JSON Reporter Protocol
 ======================
 
 The test runner supports a JSON reporter which provides a machine-readable
 representation of the test runner's progress. This reporter is intended for use
 by IDEs and other tools to present a custom view of the test runner's operation
 without needing to parse output intended for humans.
 
 Note that the test runner is highly asynchronous, and users of this protocol
 shouldn't make assumptions about the ordering of events beyond what's explicitly
@@ skipping 135 matching lines @@
 A group event is emitted before any `TestStartEvent`s for tests in a given
 group. This is the only event that contains the full metadata about a group;
 future events will refer to the group by its opaque ID.
 
 This includes the implicit group at the root of each suite, which has a `null`
 name. However, it does *not* include implicit groups for the virtual suites
 generated to represent loading test files.
 
 If the group is skipped, a single `TestStartEvent` will be emitted for a test
 within the group, followed by a `TestDoneEvent` marked as skipped. The
-`group.metadata.skip` field should *not* be considered authoritative for
-determining whether a group is skipped.
+`group.metadata` field should *not* be used for determining whether a group is
+skipped.
 
 ### TestStartEvent
 
 ```
 class TestStartEvent extends Event {
   String type = "testStart";
 
   // Metadata about the test that started.
   Test test;
 }
 ```
 
 An event emitted when a test begins running. This is the only event that
 contains the full metadata about a test; future events will refer to the test by
 its opaque ID.
 
 If the test is skipped, its `TestDoneEvent` will have `skipped` set to `true`.
-The `test.metadata.skip` field should *not* be considered authoritative for
-determining whether a test is skipped.
+The `test.metadata` should *not* be used for determining whether a test is
+skipped.
 
-### PrintEvent
+### MessageEvent
 
 ```
-class PrintEvent extends Event {
+class MessageEvent extends Event {
   String type = "print";
 
   // The ID of the test that printed a message.
   int testID;
 
+  // The type of message being printed.
+  String messageType;
+
   // The message that was printed.
   String message;
 }
 ```
 
-A `PrintEvent` indicates that a test called `print()` and wishes to display
-output.
+A `MessageEvent` indicates that a test emitted a message that should be
+displayed to the user. The `messageType` field indicates the precise type of
+this message. Different message types should be visually distinguishable.
+
+A message of type "print" comes from a user explicitly calling `print()`.
+
+A message of type "skip" comes from a test, or a section of a test, being
+skipped. A skip message shouldn't be considered the authoritative source that a
+test was skipped; the `TestDoneEvent.skipped` field should be used instead.
 
 ### ErrorEvent
 
 ```
 class ErrorEvent extends Event {
   String type = "error";
 
   // The ID of the test that experienced the error.
   int testID;
 
@@ skipping 83 matching lines @@
   // The name of the test, including prefixes from any containing groups.
   String name;
 
   // The ID of the suite containing this test.
   int suiteID;
 
   // The IDs of groups containing this test, in order from outermost to
   // innermost.
   List<int> groupIDs;
 
-  // The test's metadata, including metadata from any containing groups.
-  Metadata metadata;
-
   // The (1-based) line on which the test was defined, or `null`.
   int line;
 
   // The (1-based) column on which the test was defined, or `null`.
   int column;
 
   // The URL for the file in which the test was defined, or `null`.
   String url;
+
+  // This field is deprecated and should not be used.
+  Metadata metadata;
 }
 ```
 
 A single test case. The test's ID is unique in the context of this test run.
 It's used elsewhere in the protocol to refer to this test without including its
 full representation.
 
 Most tests will have at least one group ID, representing the implicit root
 group. However, some may not; these should be treated as having no group
 metadata.
@@ skipping 20 matching lines @@
 
 A test suite corresponding to a loaded test file. The suite's ID is unique in
 the context of this test run. It's used elsewhere in the protocol to refer to
 this suite without including its full representation.
 
 A suite's platform is one of the platforms that can be passed to the
 `--platform` option, or `null` if there is no platform (for example if the file
 doesn't exist at all). Its path is either absolute or relative to the root of
 the current package.
 
-Suites don't include their own metadata. Instead, that metadata is present on
-the root-level group.
-
 ### Group
 
 ```
 class Group {
   // An opaque ID for the group.
   int id;
 
   // The name of the group, including prefixes from any containing groups.
   String? name;
 
   // The ID of the suite containing this group.
   int suiteID;
 
   // The ID of the group's parent group, unless it's the root group.
   int? parentID;
 
-  // The group's metadata, including metadata from any containing groups.
-  Metadata metadata;
-
   // The number of tests (recursively) within this group.
   int testCount;
 
   // The (1-based) line on which the group was defined, or `null`.
   int line;
 
   // The (1-based) column on which the group was defined, or `null`.
   int column;
 
   // The URL for the file in which the group was defined, or `null`.
   String url;
+
+  // This field is deprecated and should not be used.
+  Metadata metadata;
 }
 ```
 
 A group containing test cases. The group's ID is unique in the context of this
 test run. It's used elsewhere in the protocol to refer to this group without
 including its full representation.
 
 The implicit group at the root of each test suite has `null` `name` and
 `parentID` attributes.
 
 The `line`, `column`, and `url` fields indicate the location the `group()`
 function was called to create this group. They're treated as a unit: they'll
 either all be `null` or they'll all be non-`null`. The URL is always absolute,
 and may be a `package:` URL.
 
 ### Metadata
 
 ```
 class Metadata {
-  // Whether the test case will be skipped by the test runner.
   bool skip;
-
-  // The reason the test case is skipped, if the user provided it.
   String? skipReason;
 }
 ```
 
-The metadata attached to a test by a user.
-
-Note that the `skip` field should not be considered authoritative. A test may be
-skipped even if `skip` is set to `false`.
+The metadata class is deprecated and should not be used.