**This is a breaking change on iOS**

Previously, the `paused` state was entered when the application resigned
active status. `inactive` now maps to this status. `paused` now maps to
an app that has been backgrounded.

`inactive` is currently emitted on iOS only and corresponds to iOS's
foreground inactive state.

Current state transitions are:
`resumed` <--> `inactive` <--> `paused`

suspending is currently emitted on Android only and corresponds to the
transition to Android's stopped state.

Current state transitions are:
`resumed` <--> `paused` --> `suspending` --> `resumed`

These transitions may change in future.

This is intended to match the exit codes returned by the Dart command line tool

The script will be finished when the microtask queue has been drained and
Dart_HasLivePorts is returning false for the main isolate

* This allows the tests to add their own FLX files but still use consistent fonts.
* The test fonts are only embedded on the desktop test shells. The option is not available on mobile platforms.
* Right now, all fonts will resolve to the test font. If we want tests to be able to use the fonts they embed in FLX files but use the test font for platform fallbacks, we will need to add font selector fallbacks. I can do this in an another patch. So far, there are no users of this functionality.

After this patch, we no longer link with Mojo. We still use some gn definitions
from //mojo to create Dart packages.

We no longer use mojom to transport messages. We still use the Mojo EDK
to spin the event loop, however.

Now they all flow through some common routines.

Now we just pass the data directly.

Previously, these signals were sent over Mojo. Now we send them through
platform messages.

Instead, just use JNI and Objective-C directly.

We no longer offer mojo handles via this mechanism.

This patch removes the use of the host messages mojom and switch all
message routing over to platform messages.

This plugin is implemented internally by the engine to integrate with the asset
system.

Previously we had a mix of the two.

Add plunbing for Host-to-Dart platform messages

We'll use the plumbing in this direction for things like key events.

After this patch, platform messages now take the same path through the system
that semantics data does (on Android). Support on iOS will be in another patch.

TalkBack still isn't fully working, but this patch gets us much closer.

This patch moves the rest of the clients to use the new PointerData
transport.

This patch prepares us to switch sending semantics information over mojom to
using dart:ui directly. Currently the recorded information is dropped on the
floor, but that will improve in future patches.

We now use JNI rather than Mojo to transport pointer data from Java to Dart.
Also, fill in a few more of the pointer data fields from information in Java.

Long live pointer data packets.

Rather than using mojom to encode pointer data, we now encode and decode it
manually. A future patch will remove the mojom codepath once the framework is
updated.

* Namespaces have been updated to reflect the move from //flutter/sky/shell to //flutter/shell.
* shell/BUILD.gn file has been split into smaller GN files for each subcomponent of the shell (common, GPU, diagnostic, testing).
* GN dependencies have been rewritten to stop exposing common shell dependencies as public. Duplicates have also been removed.
* GPU subcomponent has been updated make it more suitable for Vulkan integration.
* The GLFW backend has been resurrected.

This patch makes three API changes:

 * The dart:ui library now always communicates in physical pixels. The
   framework is responsible for converting to whatever logical coordinate
   system it wishes to use.
 * The textBaselien property is now on TextStyle rather than ParagraphStyle,
   which will let us choose which baseline to use on a per-span basis rather
   than on a per-paragraph basis.
 * This patch also removes the old MojoServices function endpoints.

Fixes https://github.com/flutter/flutter/issues/3779
Fixes https://github.com/flutter/flutter/issues/1360

This patch makes it easier to share the code with
//flutter/content_handler on Fuchsia.

This makes the code easier to share between Fuchsia and stand-alone
Flutter.

After this patch, Flutter apps on Fuchsia can access their asset
bundles. Unlike other platforms, the asset bundles are stored in memory
rather than in the file system.

This patch abstracts where the content of the zip file is stored.
Currently, zip files are stored in the file system, but in Fuchsia,
we're going to store them in memory (at least for the time being).
Rather than represent a zip file as a path in the file system, we
instead use an UnzipperProvider, which can create zip::UniqueUnzipper
objects on demand.

Depending on the type of bundle path specified, initialize either the zip or directory asset bundle. (#2933)

Regression introduced in https://github.com/flutter/engine/commit/cee7fef7