Introduce FragmentData, and put ObjectPaintProperties into it.

third_party/WebKit/Source/core/paint/README.md

 # `Source/core/paint`
 
 This directory contains implementation of painters of layout objects. It covers
 the following document lifecycle states:
 
 *   PaintInvalidation (`InPaintInvalidation` and `PaintInvalidationClean`)
 *   PrePaint (`InPrePaint` and `PrePaintClean`)
 *   Paint (`InPaint` and `PaintClean`)
 
 ## Glossaries
@@ skipping 183 matching lines @@
 *   The normal paint invalidation is based on whole LayoutObject's, not aware of the first line.
 
 We have a special path for first line style change: the style system informs the layout system
 when the computed first-line style changes through `LayoutObject::firstLineStyleDidChange()`.
 When this happens, we invalidate all `InlineBox`es in the first line.
 
 ### Slimming paint v2
 
 TODO(wangxianzhu): add details
 
-## [`PrePaintTreeWalk`](PrePaintTreeWalk.h) (Slimming paint v2 only)
+## [`PrePaintTreeWalk`](PrePaintTreeWalk.h) (Slimming Paint invalidaiton/v2 only)
 
 During `InPrePaint` document lifecycle state, this class is called to walk the whole
 layout tree, beginning from the root FrameView, across frame boundaries. We do the
 following during the tree walk:
 
-*   Building paint property tree: creates paint property tree nodes for special
-    things in the layout tree, including but not limit to: overflow clip, transform,
-    fixed-pos, animation, mask, filter, etc. Also sets direct compositing reasons to be
-    used later for compositing.
+### Building paint property trees (`PaintPropertyTreeBuilder`](PaintPropertyTreeBuilder.h)
 
-*   Paint invalidation: Not implemented yet. TODO(wangxianzhu): add details after
-    it's implemented.
+This class is responsible for building property trees

[pdr., 2017/04/28 23:13:40]

Nit: please fix the column wrapping.

[chrishtr, 2017/05/02 00:55:55]

Done.

+(see [the platform paint README file](../../platform/graphics/paint/README.md)).
+
+Each `PaintLayer`'s `LayoutObject` has one or more `FragmentData` objects (see
+below for more on fragments). Every `FragmentData` has an `ObjectPaintProperties` object if any property nodes
+are induced by it. For example, if the object has a transform, its `ObjectPaintProperties::Transform()`
+field points at the `TransformPaintPropertyNode` representing that transform.
+
+The `NeedsPaintPropertyUpdate`, `SubtreeNeedsPaintPropertyUpdate` and `DescendantNeedsPaintPropertyUpdate`
+dirty bits on `LayoutObject` control how much of the layout tree is traversed during each `PrePaintTreeWalk`.
+
+#### Fragments
+
+In the absence of multicolumn/pagination, there is a 1:1 correspondence betwen

[pdr., 2017/04/28 23:13:41]

between

[chrishtr, 2017/05/02 00:55:55]

Done

+self-painting `PaintLayer`s and `FragmentData`. If there is multicolumn/pagination, there
+may be more fragments. If a `PaintLayer` has a property node, each of its fragments will have

[pdr., 2017/04/28 23:13:40]

... may be more `FragmentData`s.

[chrishtr, 2017/05/02 00:55:55]

Done.

+one. The parent of a fragment's property node is the property node that belongs to the ancestor
+`PaintLayer` which part of the same column. For example, if there are 3 columns and both

[pdr., 2017/04/28 23:13:40]

...which [is] part...

[chrishtr, 2017/05/02 00:55:56]

Done.

+a parent and child `PaintLayer` have a transform, there wil be 3 `FragmentData`

[pdr., 2017/04/28 23:13:41]

will

[chrishtr, 2017/05/02 00:55:56]

Done.

+objects for the parent, 3 for the child, each `FragmentData` will have its own 
+`TransformPaintPropertyNode`, and the child's ith fragment's transform will point to the ith
+parent's transform.
+
+See [`LayoutMultiColumnFlowThread.h`](../layout/LayoutMultiColumnFlowThread.h)
+for a much more detail about multicolumn/pagination.
+
+###   Paint invalidation: `PaintInvalidator` implements a tree walk that performs
+paint invalidation. TODO(wangxianzhu): expand on this.
+
+# [`PaintPropertyTreeBuilder`](PaintPropertyTreeBuilder.h) (Slimming Paint invalidation only)
+
 
 ## Paint result caching
 
 `PaintController` holds the previous painting result as a cache of display items.
 If some painter would generate results same as those of the previous painting,
 we'll skip the painting and reuse the display items from cache.
 
 ### Display item caching
 
 When a painter would create a `DrawingDisplayItem` exactly the same as the display item
@@ skipping 41 matching lines @@
 
 When layer structure changes, and we are not invalidate paint of the changed subtree,
 we need to manually update the `needsPaintPhaseXXX` flags. For example, if an object changes
 style and creates a self-painting-layer, we copy the flags from its containing self-painting
 layer to this layer, assuming that this layer needs all paint phases that its container
 self-painting layer needs.
 
 We could update the `needsPaintPhaseXXX` flags in a separate tree walk, but that would regress
 performance of the first paint. For slimming paint v2, we can update the flags during the
 pre-painting tree walk to simplify the logics.