Improve LayoutTable outer collapsed border calculation

third_party/WebKit/Source/core/layout/LayoutTable.h

 /*
  * Copyright (C) 1997 Martin Jones (mjones@kde.org)
  *           (C) 1997 Torben Weis (weis@kde.org)
  *           (C) 1998 Waldo Bastian (bastian@kde.org)
  *           (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2009, 2010 Apple Inc.
  *               All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 131 matching lines @@
   // 'border-spacing' property represent spacing between columns and rows
   // respectively, not necessarily the horizontal and vertical spacing
   // respectively".
   int HBorderSpacing() const { return h_spacing_; }
   int VBorderSpacing() const { return v_spacing_; }
 
   bool ShouldCollapseBorders() const {
     return Style()->BorderCollapse() == EBorderCollapse::kCollapse;
   }
 
-  LayoutUnit BorderStart() const override { return LayoutUnit(border_start_); }
-  LayoutUnit BorderEnd() const override { return LayoutUnit(border_end_); }
+  LayoutUnit BorderStart() const override;
+  LayoutUnit BorderEnd() const override;
   LayoutUnit BorderBefore() const override;
   LayoutUnit BorderAfter() const override;
 
   LayoutUnit BorderLeft() const override {
     if (Style()->IsHorizontalWritingMode())
       return Style()->IsLeftToRightDirection() ? BorderStart() : BorderEnd();
     return Style()->IsFlippedBlocksWritingMode() ? BorderAfter()
                                                  : BorderBefore();
   }
 
@@ skipping 11 matching lines @@
     return Style()->IsLeftToRightDirection() ? BorderStart() : BorderEnd();
   }
 
   LayoutUnit BorderBottom() const override {
     if (Style()->IsHorizontalWritingMode())
       return Style()->IsFlippedBlocksWritingMode() ? BorderBefore()
                                                    : BorderAfter();
     return Style()->IsLeftToRightDirection() ? BorderEnd() : BorderStart();
   }
 
-  int OuterBorderBefore() const;
-  int OuterBorderAfter() const;
-  int OuterBorderStart() const;
-  int OuterBorderEnd() const;
-
-  int OuterBorderLeft() const {
-    if (Style()->IsHorizontalWritingMode())
-      return Style()->IsLeftToRightDirection() ? OuterBorderStart()
-                                               : OuterBorderEnd();
-    return Style()->IsFlippedBlocksWritingMode() ? OuterBorderAfter()
-                                                 : OuterBorderBefore();
-  }
-
-  int OuterBorderRight() const {
-    if (Style()->IsHorizontalWritingMode())
-      return Style()->IsLeftToRightDirection() ? OuterBorderEnd()
-                                               : OuterBorderStart();
-    return Style()->IsFlippedBlocksWritingMode() ? OuterBorderBefore()
-                                                 : OuterBorderAfter();
-  }
-
-  int OuterBorderTop() const {
-    if (Style()->IsHorizontalWritingMode())
-      return Style()->IsFlippedBlocksWritingMode() ? OuterBorderAfter()
-                                                   : OuterBorderBefore();
-    return Style()->IsLeftToRightDirection() ? OuterBorderStart()
-                                             : OuterBorderEnd();
-  }
-
-  int OuterBorderBottom() const {
-    if (Style()->IsHorizontalWritingMode())
-      return Style()->IsFlippedBlocksWritingMode() ? OuterBorderBefore()
-                                                   : OuterBorderAfter();
-    return Style()->IsLeftToRightDirection() ? OuterBorderEnd()
-                                             : OuterBorderStart();
-  }
-
-  int CalcBorderStart() const;
-  int CalcBorderEnd() const;
-  void RecalcBordersInRowDirection();
-
   void AddChild(LayoutObject* child,
                 LayoutObject* before_child = nullptr) override;
 
   struct ColumnStruct {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
     explicit ColumnStruct(unsigned initial_span = 1) : span(initial_span) {}
 
     unsigned span;
   };
 
@@ skipping 31 matching lines @@
     return first_body_;
   }
 
   void SetRowOffsetFromRepeatingHeader(LayoutUnit offset) {
     row_offset_from_repeating_header_ = offset;
   }
   LayoutUnit RowOffsetFromRepeatingHeader() const {
     return row_offset_from_repeating_header_;
   }
 
-  // This function returns 0 if the table has no section.
+  // These functions return nullptr if the table has no section.
   LayoutTableSection* TopSection() const;
   LayoutTableSection* BottomSection() const;
 
-  // This function returns 0 if the table has no non-empty sections.
+  // These functions returns null if the table has no non-empty sections.
   LayoutTableSection* TopNonEmptySection() const;
+  LayoutTableSection* BottomNonEmptySection() const;
 
   unsigned LastEffectiveColumnIndex() const {
     return NumEffectiveColumns() - 1;
   }
 
   void SplitEffectiveColumn(unsigned index, unsigned first_span);
   void AppendEffectiveColumn(unsigned span);
   unsigned NumEffectiveColumns() const { return effective_columns_.size(); }
   unsigned SpanOfEffectiveColumn(unsigned effective_column_index) const {
     return effective_columns_[effective_column_index].span;
@@ skipping 221 matching lines @@
       const Length& style_logical_height) const;
 
   LayoutRect OverflowClipRect(
       const LayoutPoint& location,
       OverlayScrollbarClipBehavior =
           kIgnorePlatformOverlayScrollbarSize) const override;
 
   void AddOverflowFromChildren() override;
 
   void RecalcSections() const;
+
+  void UpdateCollapsedOuterBorders() const;
+  unsigned ComputeCollapsedOuterBorderBefore() const;
+  unsigned ComputeCollapsedOuterBorderAfter() const;
+  unsigned ComputeCollapsedOuterBorderStart() const;
+  unsigned ComputeCollapsedOuterBorderEnd() const;
+
   void LayoutCaption(LayoutTableCaption&, SubtreeLayoutScope&);
   void LayoutSection(LayoutTableSection&,
                      SubtreeLayoutScope&,
                      LayoutUnit logical_left,
                      TableHeightChangingValue);
 
   // Return the logical height based on the height, min-height and max-height
   // properties from CSS. Will return 0 if auto.
   LayoutUnit LogicalHeightFromStyle() const;
 
@@ skipping 47 matching lines @@
 
   // A sorted list of all unique border values that we want to paint.
   //
   // Collapsed borders are SUPER EXPENSIVE to compute. The reason is that we
   // need to compare a cells border against all the adjoining cells, rows,
   // row groups, column, column groups and table. Thus we cache them in this
   // field.
   CollapsedBorderValues collapsed_borders_;
   bool collapsed_borders_valid_ : 1;
   bool needs_invalidate_collapsed_borders_for_all_cells_ : 1;
+  mutable bool collapsed_outer_borders_valid_ : 1;
 
   mutable bool has_col_elements_ : 1;
   mutable bool needs_section_recalc_ : 1;
 
   bool column_logical_width_changed_ : 1;
   mutable bool column_layout_objects_valid_ : 1;
   mutable unsigned no_cell_colspan_at_least_;
   unsigned CalcNoCellColspanAtLeast() const {
     for (unsigned c = 0; c < NumEffectiveColumns(); c++) {
       if (effective_columns_[c].span > 1)
         return c;
     }
     return NumEffectiveColumns();
   }
 
   short h_spacing_;
   short v_spacing_;
-  int border_start_;
-  int border_end_;
+
+  mutable unsigned collapsed_outer_border_start_;
+  mutable unsigned collapsed_outer_border_end_;
+  mutable unsigned collapsed_outer_border_before_;
+  mutable unsigned collapsed_outer_border_after_;
 
   LayoutUnit block_offset_to_first_repeatable_header_;
   LayoutUnit row_offset_from_repeating_header_;
   LayoutUnit old_available_logical_height_;
 };
 
 inline LayoutTableSection* LayoutTable::TopSection() const {
   DCHECK(!NeedsSectionRecalc());
   if (head_)
     return head_;
   if (first_body_)
     return first_body_;
   return foot_;
 }
 
 DEFINE_LAYOUT_OBJECT_TYPE_CASTS(LayoutTable, IsTable());
 
 }  // namespace blink
 
 #endif  // LayoutTable_h