All that's left is two task runners, which should be statics somewhere.

There are now three ways to start Dart applications:

1) From a precompiled snapshot
2) From a snapshot
3) From source

When loading from source, we no longer use the complex data pipe /
dependency catcher mechanism. Instead, we just load the source
synchronously from the file system. This is appropriate because running
from source is used only during development and not during production.

The previous design was built assuming we would want to run from source
over the network, which meant we needed to be able to load source
asynchronously over a high latency channel.

We now just call stat directly to test whether a file exists.

This patch hides the base::SingleThreadedTaskRunner, which pulls a big
switchover to ftl::WeakPtr and std::function.

Add an association between FlutterViews and Dart Isolates to the PlatformView service protocol support (#2886)

This patch centralizes the asset bundle processing in //flutter/assets and
removes the //base dependency from the code.

The ftl::TaskRunner is still based on a base::MessageLoop, but this patch paves
the way to replace the message loop on Fuchsia.

* Remove time

* Remove rand

* Remove array buffers

* Remove more code

* Remove more image decoding code

* Remove more code

* Remove old public API

* Remove more old public headers

* Remove layout test support

* Remove WebPrivateOwnPtr

* Remove WebString

* Remove worker pool

This patch removes almost all //base dependency of //flow. The only dependency
left is on tracing.

* Update to mojo 7d579155cc597aa3befcbfad66eef54bda06b57c

* Update to new API

* Update to mojo 9a791294e429f9f2ca4f427796a284edb6f6768e

* Update to account for Mojo API changes

Previously we would hold the layer tree until the we returned from Dart. Now we
send the layer tree to the rasterizer thread immediately.

Fixes #212

Fixes #3095

The layout protocol in Mozart changed. Now we need to pipe a scene version
through the system to the compositor.

SkyShell now supports --packages instead of --package-root.

This patch cleans up the way we expose Mojo services into Dart. It also adds a
service provider for "view services," which will evetually contain the raw
keyboard service.

Previously this value was the temp directory that we used to store the FLX
bundle. Now it's the URL given to us by MojoShell.

Allow specification of the FLX bundle (containing no Dart snapshot) outside the iOS/Mac application bundle.

Allows launching of apps without having any Xcodebuild step in the simulator.

The FLX will contain a font manifest JSON file that maps font family names
to custom font assets.  Flutter will provide a FontSelector that loads
fonts on demand and caches typeface and style data.

This patch merges these functions into dart:ui, which is simpler.

Fixes #83

Currently, during application startup we:
  * copy the FLX file to a Mojo pipe
  * write the Mojo pipe contents back to a temporary file on disk
  * unzip the FLX contents into cache storage
This contributes to startup latency and requires that we later clean up the
cache.

With this change, the assets will be extracted from the FLX archive
on demand with no writes to storage. Runtime cost should be minimal
given that most assets (except for the snapshot) are not compressed
in the archive.

When the engine starts a new version of the Dart application, the animator may
have pending callbacks and other state related to the previous run of the app.
This state must be cleared before the new vsync provider is assigned.

Everything should work except the keyboard.

We have enough geometry classes kicking around. We don't need the
ui/gfx/geometry types too.

Now that we understand window insets, we don't need to hard-code the size of
the status bar. Also, convert the viewport metrics to be consistently in
physical pixels.

We used to share memory between Dart strings and WTF::String objects by
way of the Dart externalized strings. That used to be important when the
DOM shared many strings between C++ and Dart. However, now that we don't
retain strings in C++ much anymore, we don't need this complexity.

This patch removes DartStringCache and the integration. It also unwinds
several cases where we were converting back and forth between
WTF::String and std::string for no reason. Now we use std::string more
consistently.

For the case of ParagraphBuilder::addText, we now take a raw const
char*, which more closely matches the API the DartVM exposes. That means
we do a single copy out of the VM and into the render tree at that
point.

Now that the compositor doesn't have any tricky deps, we can make it a
top-level project, which saves a bunch of typing.

This complex machinery made sense for Blink, which has hundreds of
developers. In our case, we're just moving around two bools. We can do
that in a much simpler way.