Fixes #774

Well, all the easy ones, anyway.

For some reason `// ignore:` isn't working for me so I've disabled
lints that need that. Also disabled those that require a ton of work
(which I'm doing, but not in this PR, to keep it reviewable).

This adds:
- avoid_init_to_null
- library_names
- package_api_docs
- package_names
- package_prefixed_library_names
- prefer_is_not_empty
- sort_constructors_first
- sort_unnamed_constructors_first
- unnecessary_getters_setters

Otherwise, changing the order of your children (e.g. shuffling a list of
children) will have no visible effect.

...so that it's easier to copy/paste between the rendering and settings layers.

This makes it match the material spec more.
https://www.google.com/design/spec/style/icons.html

Fixes https://github.com/flutter/flutter/issues/1357

Each layer is supposed to reexport the parts of the previous layer
that are part of its API.

- In painting.dart, export from dart:ui all the Canvas-related APIs
  that make sense to be used at higher levels, e.g. PaintingStyle.

- Delete painting/shadows.dart. It was dead code.

- In rendering/object.dart, export all of painting.dart.

- In widgets/basic.dart, export all of painting.dart and
  animation.dart. Some classes in animation/ are renamed to make this
  less disruptive and confusing to the namespace.

- Split out Stocks back into an import model rather than a part model,
  so that it's easier to manage its dependencies on a per-file basis.

- Move Ticker to scheduler library.

- Remove as many redundant imports as possible now.

- Some minor nit picking cleanup in various files.

The asserting will continue until morale improves!

* Convert all assert(*.isNormalized) checks to use the new
  debugAssertIsNormalized technology.
* Convert CustomMultiChildLayout to use the new RenderingError
  technology to greatly improve the detail in errors you get when
  writing CustomMultiChildLayout delegates.
* Add BoxConstraints.copyWith().
* Indent the descendants in the rendering exception data dump so that
  when you have multiple children it's clearer what's going on.

Negative constraints never make sense, so catch those too.

Make RenderObject.layout's isNormalized assert use the newer more fancy
debug version of isNormalized.

There aren't any clients anymore.

Fixes #1684

This patch includes documentation for transitions.dart and for
scrollable.dart.

* Use actual exceptions rather than assertions containing code
  containing strings when trying to give messages to authors.
* Introduce RenderingError which is an AssertionError that takes a
  string argument, to support the above.
* Provide a BoxDimensions.hasBoundedWidth/hasBoundedHeight API.
* Document BoxDimensions.isNormalized.
* Provide more useful information when we assert isNormalized and find
  that it is false.
* When finding the size is infinite, crawl the tree to figure out which
  render box is likely responsible for the infinite constraints.
* Provide more information when size doesn't match the constraints.
* Provide more information when intrinsic dimension methods violate the
  constraints.
* Only spam a huge amount of information for the first exception from
  the rendering library. I've noticed a lot of people looking at the
  last exception printed rather than the first and that's very
  misleading -- after the rendering library hits an exception, all bets
  are off regarding what'll happen in the future. All kinds of asserts
  might fire.
* Improve docs around the debug methods and flags for the above.
* Make Block default to have no children. Previously, giving no children
  crashed with a confusing message about a null deref in an assert.

This patch sketches out the basic widgets for creating Mozart child
views. We're still missing some of the machinery, so we can't quite
create child views yet, but once we supply the ViewHost and teach the
compositor how to actually display the child scenes, we'll have
something that works.

We were getting confused about our layer tree offsets, which caused us
to set an incorrect cull rect for the recording inside a viewport.

This patch does away with layer tree offsets almost entirely. We now use
them only at repaint boundaries, which is where we want the layer tree
to be mutable.

Fixes #1460

This patch changes the framework to walk the child list forwards so that build
functions with global side effects do sensible things. Specifically, if you
have a number of autofocusable children, the first one the list will acquire
the focus because it gets built first now.

Fixes #182

RenderBlock wasn't constraining the results.
RenderPadding wasn't constraining the results (which matters
especially when the constraints can't fit the padding in the first
place).
RenderViewport wasn't constraining the results.

Add a test for the block case.

To catch this kind of thing in the future, add some asserts to
debugDoesMeetConstraints() that all four intrinsic functions return
values that are within the constraints.

RenderBlockViewport doesn't support returning intrinsics, so turn off
the "no intrinsic support" asserts (and return zero) when we're doing
this new assert.

This new assert screwed up the custom layout classes' tests, so adjust
those tests to ignore the callbacks invoked from these asserts.

Add to the _debugReportException() method a short summary of the
descendants of this node. It's important to have this information when
debugging errors like these intrinsic constraints contract violations
because often nodes just pass the values through to their child so you
have to go several steps down to find the actual problem.

Fixes https://github.com/flutter/flutter/issues/1210

We were painting the contents of the RRect clip at the wrong offset. This patch
makes RRect match Rect and Path clips.

Fixes #1194

Fixes #961

We no longer need to pass bounds to SceneBuilder. Instead, the
compositor computes these bounds itself from the RTrees in the
SkPictures.

This patch adds ShaderLayer and makes ShaderMask use it.

Fixes #1155

We don't know how to accuately compute paint bounds in the render tree.
Instead, we can rely on the compositor to compute the paint bounds for
us if we use OpacityLayer to do our opacity blends.

Fixes the shadow when closing the menu in the stocks app.

Also, introduce alwaysNeedsCompositing to force the "needs compositing"
bit to true without necessarily introducing a ContainerLayer into the
layer tree. A future patch will make use of alwaysNeedsCompositing to
optimize opacity layers.

See: https://github.com/flutter/flutter/issues/1080

Previously, we triggered a layout (and hence a repaint) when sliding the
draw because we gave the draw loose constraints. The drawer uses an
Align to move itself to the proper side of the screen, so it can have
tight constraints, which makes it a layout boundary.

Also, don't trigger a layout just because the Scaffold rebuilds. There
isn't any state in the scaffold custom layout, so it doesn't need to
repaint just because we created a new instance of the delegate.

Finally, add the debugging infrastructure I used to find these issues.

- make them all have the same style
- make them all include the stack trace last
- make them all stop printing if their callback is set (if
  appropriate, they don't yet all have callbacks)

I think I wanted to use this at some point but ended up going a
different direction. Instead, object.dart has a private field that
serves a similar purpose.

When assigning a new overlayPainter, we were detaching the old overlay
painter even if the render object itself wasn't attached. Now we only
twiddle the attach/detach state of the overlay painter when we're
attached ourselves.

Fixes #1047

Use the same technique for updating compositing bits as layout and
painting. This avoids walking the entire rendering tree when all you
need to update is a small subtree.

Previously, applyPaintTransform() had to know how it was positioned in
its parent, even though that's really the parent's responsibility.

Now, applyPaintTransform() is given a child and applies the transform
that it would give the child during paint.

This makes it possible for applyPaintTransform() to work across
coordinate system boundaries (e.g. box to sector, or view to box --
previously, view to box only worked because we explicitly skipped that
step -- since view doesn't actually apply a transform, it doesn't
really matter).

debugDoingPaint is an internal flag and really shouldn't be globally settable.

Add BoxConstraints.isNormalized feature.

Use this feature in asserts in all the intrinsic dimension methods, in
various relevant BoxConstraints methods, and in layout().

Wrap the _DebugSize logic in BoxConstraints.constrain() in an assert
block to avoid a branch in release mode.

Remove the logic in BoxConstraints.isSatisfiedBy() that dealt with
non-normalized values.

Add BoxConstraints.normalize().

Make RenderCustomOneChildLayoutBox.performLayout() only set
parentUsesSize on the child if the constraints aren't tight.

Instead of PointerInputEvent having a "type" field, we now have a
different class for each pointer type.

This has ripple effects throughout the system.

I also did code cleanup in affected files while I was there.

We can just use Canvas now.  The two are the same thing.