The implementation of the move-ctor of DoLaunchSessionParams has the
noexcept keyword, but the declaration doesn't have it. That causes
a build error on C++17 mode build.
This CL maintains them consistently to avoid the failure.

Since there are inherent races between "force submit" mode and
"page is not visible", it's possible for VideoFrameSubmitter to
inject an empty frame in the middle of a stream that auto-PiPs.

In particular, VideoFrameSubmitter finds out first that the page
is not visible, so it tries to clean up resources immediately with
an empty frame. Shortly afterwards, auto-PiP succeeds and sets
"force submit", so real frames are sent again. Unfortunately,
the empty frame shows up as a flicker in the PiP window.

This CL delays the empty frame for a few hundred milliseconds.
Before sending the empty frame after that time, it checks again if
an empty frame is still needed. If not, then it skips it.

While this is still a race, it's hard to avoid situations like this.
At least, it should be fairly robust to other races; we really don't
want to send an empty frame unless the resources are actually not
needed for display. Delaying resource cleanup by a small amount of
time seems reasonable.

This introduces FpsCounter which can measure multiple animtions
instead of individual transform animations.

This also splits the overview animation smoothness into
Clamshell/SingleClamshell/Tablet/SplitView because they
perform quite different animations.

No logical change but contains a few refacotring:
* notify OverviewGrid the cancelation of starting animation so
that we can measure this scenario.
* Split the animation type computation and applying them so that
we can specify the type of overview animation in fps counter.

CSSPrimitiveValue::CustomCSSText can be called huge amount of times
through InspectorDOMSnapshotAgent::getSnapshot. It underlyingly calls
WTF::String::format which is sort of expensive by considering the huge
call volume.

Actually CustomCSSText only needs to convert number to string. And
WTF::String provides a cheaper way, String::Number, to achieve same
goal.

However String::Number(double) uses WTF fast dtoa function to mimic "%.[precision]g" format,
but it doesn't comply with C11 standard (http://port70.net/~nsz/c/c11/n1570.html#7.21.6) like
what the String::format does.
According to C11 standard. when using "%[.percisiong]g" to format number in exponential format,

(1) The exponent always contains at least two digits, and only as many more digits as
necessary to represent the exponent. If the value is zero, the exponent is zero.
(2) Finally, unless the # flag is used, any trailing zeros are removed from the
fractional portion of the result and the decimal-point character is removed if there
is no fractional portion remaining.

WTF fast dtoa doesn't comply with above rules and we don't want to break CSS universe, so only use
WFT String::Number(int) to generate css text when css value is in small integer range.

Assistant Reminders, Settings, etc. needs to be able to distinguish
between being loaded in the browser and being embedded in Assistant UI.
They need this information to fork behavior and UI treatments, such as
deep links that should only be provided if embedded UI or top bars that
should only be shown if in the browser.

To indicate that we are in an embedded state, we will use a URL
parameter: |source|.

Note that we will default |source| to Assistant, and can support
parameterizing this value later if need be.

Delete the main provisional (speculative) frame during ~WebContentsImpl

The FrameTreeNode destruction attempts to CleanUpNavigation() which
should DeleteRenderFrame() but the ~WebContentsImpl destructor ruins
that by calling SetRenderFrameCreated(false) earlier, in order to
notify observers earlier. This then prevents DeleteRenderFrame() from
doing its job, and the RenderFrame is left orphaned in the renderer
process, with pointers to a RenderWidget that gets deleted shortly
after, causing explosions.

To avoid leaking the RenderFrame, have ~WebContentsImpl explicitly
DeleteRenderFrame() since it is going to SetRenderFrameCreated(false)
on the speculative RenderFrameHost. Then CleanUpNavigation() does not
need to do anything for the renderer objects, but just cleans up the
browser side.

A quad transform can be non-invertible if the client sends bad data.
These can always be skipped since they won't produce pixels. Rather
than fail on debug builds and go ahead in release builds, this simply
skips the quads.

The DCHECK was verifying that, on a navigate to an element's first
child, that child's parent is the node being navigated from. The check
was failing when navigating from a content fragment root to its first
child, which turned out to be the root node of an iframe rather than
the root node of the root frame.

The issue was that document load in the iframe was incorrectly
triggering a switch-out of the node tracked by the fragment root as its
sole child. The fix is to only perform that switch when the root node
of the root frame changes.

If Chrome for the Mac is restarted to take an update, the relauncher
will need to wait for the update to be applied. Add a class that
knows how to watch for the staging key, and have the relauncher
use it.

Add a properties struct to OzonePlatform for properties that are known
after host process initialization. This struct is used to store if we
support overlays and replaces OverlayManagerOzone::SupportsOverlays().

The overlay validation logic is moving out of the host process and into
the GPU process with OOP-D, so OverlayManagerOzone will no longer exist
in the host process.

Also remove the caching logic of RendererSettings in
HostContextFactoryPrivate. We need to create the RendererSettings object
after OzonePlatform::InitializeForUI() has run.

- Move the client ID from WebView's special "metrics_guid" file into
prefs, like Chrome. This requires 2 steps:

1. In this change, we check for any existing metrics_guid file. If it
exists, copy the client ID into prefs and delete the file.

2. In a follow-up change, after ~all clients have deleted the
file, we'll remove the file-handling code.

- Generate client IDs in MetricsStateManager::ForceClientIdCreation(),
like Chrome. (WebView previously generated its client ID in its own
special function, AwMetricsServiceClient::LoadOrCreateClientId().)

- Simplify the communication between the Java and native
AwMetricsServiceClient classes. Make the native side wholly
responsible for managing the race condition between native
initialization and getting the consent setting back from GMS.
Previously, native would inform Java when native initialization was
finished, and only then would the Java side pass the consent setting
to native. Now, the Java side passes the consent setting as soon as
possible, so the Java side needn't keep track of the native side's
state. See the new comments in aw_metrics_service_client.h for
details. (This will all get simpler in the follow-up change, after
which native initialization will no longer be asynchronous, because we
won't have to load the metrics_guid file.)

- Add lots of tests and comments, since AwMetricsServiceClient has
become rather complicated since it was first added.

One for "style has changed" and one for "available space has changed".
This allows for more exact fragment caching in LayoutNG; when style
has changed, we always need to relayout, but when the available space
has changed, we may be able to reuse our cached fragment (subject to
existing logic in LayoutNGMixin<Base>::CachedLayoutResult).

In a followup CL, I would like to switch some ForceChildLayout calls
to use this new flag as well.

Allows events to pass through shadows on secondary UI.
Did not use GetWindowMask to determine hit testing outside the bounds of
border due to GetWindowMask not supporting Dialogs with arrows and not returning
a mask for some dialogs. We also avoid using expensive SkPath contains logic
by just using RRectF contains method.