Compute margin block start for 1st block in LayoutNG root constraint space

third_party/WebKit/Source/core/layout/ng/ng_constraint_space.cc

 // Copyright 2016 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.
 
 #include "core/layout/ng/ng_constraint_space.h"
 
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/ng/ng_layout_opportunity_iterator.h"
 #include "core/layout/ng/ng_units.h"
 
 namespace blink {
 
 NGConstraintSpace::NGConstraintSpace(NGWritingMode writing_mode,
                                      NGDirection direction,
                                      NGLogicalSize container_size)
     : physical_space_(new NGPhysicalConstraintSpace(
           container_size.ConvertToPhysical(writing_mode))),
       size_(container_size),
       writing_mode_(writing_mode),
-      direction_(direction) {}
+      direction_(direction),
+      is_new_fc_(false) {}
 
 NGConstraintSpace::NGConstraintSpace(NGWritingMode writing_mode,
                                      NGDirection direction,
                                      NGPhysicalConstraintSpace* physical_space)
     : physical_space_(physical_space),
       size_(physical_space->ContainerSize().ConvertToLogical(writing_mode)),
       writing_mode_(writing_mode),
-      direction_(direction) {}
+      direction_(direction),
+      is_new_fc_(false) {}
 
 NGConstraintSpace::NGConstraintSpace(NGWritingMode writing_mode,
                                      NGDirection direction,
                                      const NGConstraintSpace* constraint_space)
     : physical_space_(constraint_space->PhysicalSpace()),
       offset_(constraint_space->Offset()),
       size_(constraint_space->Size()),
       writing_mode_(writing_mode),
-      direction_(direction) {}
+      direction_(direction),
+      is_new_fc_(false) {}
 
 NGConstraintSpace::NGConstraintSpace(const NGConstraintSpace& other,
                                      NGLogicalOffset offset,
                                      NGLogicalSize size)
     : physical_space_(other.PhysicalSpace()),
       offset_(offset),
       size_(size),
       writing_mode_(other.WritingMode()),
-      direction_(other.Direction()) {}
+      direction_(other.Direction()),
+      is_new_fc_(false) {}
 
 NGConstraintSpace::NGConstraintSpace(NGWritingMode writing_mode,
                                      NGDirection direction,
                                      const NGConstraintSpace& other,
                                      NGLogicalSize size)
-    : size_(size), writing_mode_(writing_mode), direction_(direction) {
+    : size_(size),
+      writing_mode_(writing_mode),
+      direction_(direction),
+      is_new_fc_(false) {
   physical_space_ =
       new NGPhysicalConstraintSpace(size.ConvertToPhysical(writing_mode));
   for (const NGExclusion& exclusion : other.PhysicalSpace()->Exclusions()) {
     physical_space_->AddExclusion(exclusion);
   }
 }
 
 NGConstraintSpace* NGConstraintSpace::CreateFromLayoutObject(
     const LayoutBox& box) {
   bool fixed_inline = false, fixed_block = false;
@@ skipping 115 matching lines @@
 
 String NGConstraintSpace::ToString() const {
   return String::format("%s,%s %sx%s",
                         offset_.inline_offset.toString().ascii().data(),
                         offset_.block_offset.toString().ascii().data(),
                         size_.inline_size.toString().ascii().data(),
                         size_.block_size.toString().ascii().data());
 }
 
 }  // namespace blink