[LayoutNG] Add fields required for new multi-col approach.

third_party/WebKit/Source/core/layout/ng/ng_block_break_token.h

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NGBlockBreakToken_h
 #define NGBlockBreakToken_h
 
 #include "core/layout/ng/ng_break_token.h"
 #include "platform/LayoutUnit.h"
 
 namespace blink {
 
 class NGBlockNode;
 
+// Represents a break token for a block node.
 class NGBlockBreakToken : public NGBreakToken {
  public:
+  // Creates a break token for a node which did fragment, and can potentially
+  // produce more fragments.
+  NGBlockBreakToken(NGBlockNode* node,
+                    LayoutUnit used_block_size,
+                    HeapVector<Member<NGBreakToken>>& child_break_tokens)
+      : NGBreakToken(kBlockBreakToken, /* is_finished */ false, node),

[cbiesinger, 2017/02/15 19:23:19]

Consider an enum instead of a bool?

[ikilpatrick, 2017/02/16 17:01:30]

Yeah I looked at doing that, but decided against as it's just internal to this
class hierarchy, and is publicly exposed as different ctors, and the
IsFinished() method.

[ikilpatrick, 2017/02/16 17:02:10]

I can also change if you feel strongly about this :)

[cbiesinger, 2017/02/16 22:03:49]

Well, I think /* is_finished */ false looks hideous so I still prefer an enum
but I don't care strongly enough that I'll insist on it. :)

+        used_block_size_(used_block_size) {
+    child_break_tokens_.swap(child_break_tokens);
+  }
+
+  // Creates a break token for a node which cannot produce any more fragments.
+  explicit NGBlockBreakToken(NGBlockNode* node)
+      : NGBreakToken(kBlockBreakToken, /* is_finished */ true, node) {}
+
+  // TODO(ikilpatrick): Remove this constructor and break_offset once we've
+  // switched to new multi-col approach.
   NGBlockBreakToken(NGBlockNode* node, LayoutUnit break_offset)
-      : NGBreakToken(kBlockBreakToken),
-        node_(node),
+      : NGBreakToken(kBlockBreakToken, false, node),
         break_offset_(break_offset) {}
 
-  NGBlockNode& InputNode() const { return *node_.get(); }
+  // Represents the amount of block size used in previous fragments.
+  //
+  // E.g. if the layout node specifies a block size of 200px and the used block
+  // size is 150px the next fragment should have a size of 50px (assuming no

[cbiesinger, 2017/02/15 19:24:22]

Also, I'm confused by this comment. Typically blocks do not fill the available
size in the block direction. Why should the next fragment be exactly 50px high
in this example?

[ikilpatrick, 2017/02/15 19:45:35]

So consider this:
https://software.hixie.ch/utilities/js/live-dom-viewer/?%3C!DOCTYPE%20html%3E...

In the above example the first fragment is 75px high as it hit a fragmentation
line at 75px. On the break_token for the first fragment it's used_block_size is
75px.

Inside the second fragment it calculates it's size by:  (block_size -
used_block_size) = (150px - 75px) = 75x.

Would a better comment be?

Represents the amount of block size used in previous fragments.
E.g. if the layout node has a definite height of 200px, and the used block size
of preceding fragments is 150px the next fragment will have a block size of 50px
(assuming no additional fragmentation).

[cbiesinger1, 2017/02/16 00:14:55]

Oh I see. I missed the fact that 200px is the size of this object, not its
container. Hm.. maybe just say "used size of its preceding fragments"? Or "of
the previous fragments of this block"?

[ikilpatrick, 2017/02/16 17:01:30]

Tried some rewording...

[cbiesinger, 2017/02/16 22:03:48]

Thanks!

+  // additional fragmentation).
+  LayoutUnit UsedBlockSize() const { return used_block_size_; }
+
+  // The break tokens for children of the layout node.
+  //
+  // This is used to resume layout of any children which fragmented, it may
+  // contain "finished" break tokens so we know which children to skip for the
+  // next fragment.
+  const HeapVector<Member<NGBreakToken>>& ChildBreakTokens() const {
+    return child_break_tokens_;
+  }
+
+  // TODO(ikilpatrick): Remove this accessor.
   LayoutUnit BreakOffset() const { return break_offset_; }
 
   DEFINE_INLINE_VIRTUAL_TRACE() {
     NGBreakToken::trace(visitor);
-    visitor->trace(node_);
+    visitor->trace(child_break_tokens_);
   }
 
  private:
-  Member<NGBlockNode> node_;
   LayoutUnit break_offset_;
+  LayoutUnit used_block_size_;
+  HeapVector<Member<NGBreakToken>> child_break_tokens_;
 };
 
 DEFINE_TYPE_CASTS(NGBlockBreakToken,
                   NGBreakToken,
                   token,
                   token->Type() == NGBreakToken::kBlockBreakToken,
                   token.Type() == NGBreakToken::kBlockBreakToken);
 
 }  // namespace blink
 
 #endif  // NGBlockBreakToken_h