Optimize collapsed border calculation (step 1)

third_party/WebKit/Source/core/layout/LayoutTableCell.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, 2007, 2009, 2013 Apple Inc.
  *               All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 17 matching lines @@
 
 #include "core/CoreExport.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutTableRow.h"
 #include "core/layout/LayoutTableSection.h"
 #include "platform/LengthFunctions.h"
 #include <memory>
 
 namespace blink {
 
-static const unsigned kUnsetColumnIndex = 0x1FFFFFFF;
-static const unsigned kMaxColumnIndex = 0x1FFFFFFE;  // 536,870,910
-
-enum IncludeBorderColorOrNot { kDoNotIncludeBorderColor, kIncludeBorderColor };
+static const unsigned kUnsetColumnIndex = 0x07FFFFFF;

[wkorman, 2017/04/27 20:11:15]

How are these numbers here and below determined and why do they change as part
of this patch? Worth adding comment for future readers as well.

[Xianzhu, 2017/04/28 20:31:45]

Changed to self-explanation code:
#define BITS_OF_ABSOLUTE_COLUMN_INDEX 27
static const unsigned kUnsetColumnIndex =
    (1u << BITS_OF_ABSOLUTE_COLUMN_INDEX) - 1;
static const unsigned kMaxColumnIndex = kUnsetColumnIndex - 1;

and in LayoutTableCell:
  unsigned absolute_column_index_ : BITS_OF_ABSOLUTE_COLUMN_INDEX;

  // When adding or removing bits here, we should also adjust
  // BITS_OF_ABSOLUTE_COLUMN_INDEX to use remaining bits of a 32-bit word.

add added a test LayoutTableCellTest.AbsoluteColumnIndex.

+static const unsigned kMaxColumnIndex = 0x07FFFFFE;  // 134,217,726
 
 class SubtreeLayoutScope;
 
 // LayoutTableCell is used to represent a table cell (display: table-cell).
 //
 // Because rows are as tall as the tallest cell, cells need to be aligned into
 // the enclosing row space. To achieve this, LayoutTableCell introduces the
 // concept of 'intrinsic padding'. Those 2 paddings are used to shift the box
 // into the row as follows:
 //
@@ skipping 268 matching lines @@
    private:
     const LayoutTableCell& layout_table_cell_;
     CollapsedBorderValue start_border_;
     CollapsedBorderValue end_border_;
     CollapsedBorderValue before_border_;
     CollapsedBorderValue after_border_;
   };
 
   bool UsesCompositedCellDisplayItemClients() const;
   const CollapsedBorderValues* GetCollapsedBorderValues() const {
+    DCHECK(collapsed_border_values_valid_);
     return collapsed_border_values_.get();
   }
+  void InvalidateCollapsedBorderValues() {
+    collapsed_border_values_valid_ = false;

[wkorman, 2017/04/27 20:11:15]

When are they valid/invalid? Worth documenting in a comment somewhere, perhaps
on the member data? I wondered same re: visually_changed member data.

[Xianzhu, 2017/04/28 20:31:45]

Done.

+  }
 
   LayoutRect DebugRect() const override;
 
   void AdjustChildDebugRect(LayoutRect&) const override;
 
   // A table cell's location is relative to its containing section.
   LayoutBox* LocationContainer() const override { return Section(); }
 
   bool HasLineIfEmpty() const override;
 
@@ skipping 55 matching lines @@
   // column, column group).
   // TODO(jchaffraix): It should be easier to compute all the borders in
   // physical coordinates. However this is not the design of the current code.
   //
   // Blink's support for mixed directionality is currently partial. We only
   // support the directionality up to |styleForCellFlow|. See comment on the
   // function above for more details.
   // See also https://code.google.com/p/chromium/issues/detail?id=128227 for
   // some history.
   //
-  // Those functions are called when the cache (m_collapsedBorders) is
-  // invalidated on LayoutTable.
-  CollapsedBorderValue ComputeCollapsedStartBorder(
-      IncludeBorderColorOrNot = kIncludeBorderColor) const;
-  CollapsedBorderValue ComputeCollapsedEndBorder(
-      IncludeBorderColorOrNot = kIncludeBorderColor) const;
-  CollapsedBorderValue ComputeCollapsedBeforeBorder(
-      IncludeBorderColorOrNot = kIncludeBorderColor) const;
-  CollapsedBorderValue ComputeCollapsedAfterBorder(
-      IncludeBorderColorOrNot = kIncludeBorderColor) const;
+  // Those functions are called during recalcCollapsedBorderValuesIfNeeded().
+  CollapsedBorderValue ComputeCollapsedStartBorder() const;
+  CollapsedBorderValue ComputeCollapsedEndBorder() const;
+  CollapsedBorderValue ComputeCollapsedBeforeBorder() const;
+  CollapsedBorderValue ComputeCollapsedAfterBorder() const;
+
+  void RecalcCollapsedBorderValuesIfNeeded() const;
 
   Length LogicalWidthFromColumns(LayoutTableCol* first_col_for_this_cell,
                                  Length width_from_style) const;
 
   void UpdateColAndRowSpanFlags();
 
   unsigned ParseRowSpanFromDOM() const;
   unsigned ParseColSpanFromDOM() const;
 
   void NextSibling() const = delete;
   void PreviousSibling() const = delete;
 
   // Note MSVC will only pack members if they have identical types, hence we use
   // unsigned instead of bool here.
-  unsigned absolute_column_index_ : 29;
+  unsigned absolute_column_index_ : 27;
   unsigned cell_width_changed_ : 1;
   unsigned has_col_span_ : 1;
   unsigned has_row_span_ : 1;
 
+  mutable unsigned collapsed_border_values_valid_ : 1;
+  mutable unsigned collapsed_borders_visually_changed_ : 1;
+  mutable std::unique_ptr<CollapsedBorderValues> collapsed_border_values_;
+
   // The intrinsic padding.
   // See class comment for what they are.
   //
   // Note: Those fields are using non-subpixel units (int)
   // because we don't do fractional arithmetic on tables.
   int intrinsic_padding_before_;
   int intrinsic_padding_after_;
-
-  std::unique_ptr<CollapsedBorderValues> collapsed_border_values_;
 };
 
 DEFINE_LAYOUT_OBJECT_TYPE_CASTS(LayoutTableCell, IsTableCell());
 
 inline LayoutTableCell* LayoutTableCell::PreviousCell() const {
   return ToLayoutTableCell(LayoutObject::PreviousSibling());
 }
 
 inline LayoutTableCell* LayoutTableCell::NextCell() const {
   return ToLayoutTableCell(LayoutObject::NextSibling());
 }
 
 inline LayoutTableCell* LayoutTableRow::FirstCell() const {
   return ToLayoutTableCell(FirstChild());
 }
 
 inline LayoutTableCell* LayoutTableRow::LastCell() const {
   return ToLayoutTableCell(LastChild());
 }
 
 }  // namespace blink
 
 #endif  // LayoutTableCell_h