Replace call sites to BorderValue functions to save the BorderValue construction cost

third_party/WebKit/Source/core/layout/LayoutTableSection.cpp

 /*
  * 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, 2008, 2009, 2010, 2013 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
@@ skipping 1342 matching lines @@
   }
 }
 
 int LayoutTableSection::CalcBlockDirectionOuterBorder(
     BlockBorderSide side) const {
   if (!grid_.size() || !Table()->NumEffectiveColumns())
     return 0;
 
   int border_width = 0;
 
-  const BorderValue& sb =
-      side == kBorderBefore ? Style()->BorderBefore() : Style()->BorderAfter();
-  if (sb.Style() == EBorderStyle::kHidden)
+  EBorderStyle section_border_style = side == kBorderBefore
+                                          ? Style()->BorderBeforeStyle()
+                                          : Style()->BorderAfterStyle();
+  if (section_border_style == EBorderStyle::kHidden)
     return -1;
-  if (ComputedStyle::BorderStyleIsVisible(sb.Style()))
-    border_width = sb.Width();
+  if (ComputedStyle::BorderStyleIsVisible(section_border_style)) {
+    border_width = side == kBorderBefore ? Style()->BorderBeforeWidth()
+                                         : Style()->BorderAfterWidth();
+  }
 
-  const BorderValue& rb = side == kBorderBefore
-                              ? FirstRow()->Style()->BorderBefore()
-                              : LastRow()->Style()->BorderAfter();
-  if (rb.Style() == EBorderStyle::kHidden)
+  EBorderStyle row_border_style = side == kBorderBefore
+                                      ? FirstRow()->Style()->BorderBeforeStyle()
+                                      : LastRow()->Style()->BorderAfterStyle();
+  float row_border_width = side == kBorderBefore
+                               ? FirstRow()->Style()->BorderBeforeWidth()
+                               : LastRow()->Style()->BorderAfterWidth();
+  if (row_border_style == EBorderStyle::kHidden)
     return -1;
-  if (ComputedStyle::BorderStyleIsVisible(rb.Style()) &&
-      rb.Width() > border_width)
-    border_width = rb.Width();
-
+  if (ComputedStyle::BorderStyleIsVisible(row_border_style) &&
+      row_border_width > border_width)
+    border_width = row_border_width;
   bool all_hidden = true;
   unsigned r = side == kBorderBefore ? 0 : grid_.size() - 1;
   unsigned n_cols = NumCols(r);
   for (unsigned c = 0; c < n_cols; c++) {
     const auto& grid_cell = GridCellAt(r, c);
     if (grid_cell.InColSpan() || !grid_cell.HasCells())
       continue;
     const ComputedStyle& primary_cell_style =
         grid_cell.PrimaryCell()->StyleRef();
     // FIXME: Make this work with perpendicular and flipped cells.
-    const BorderValue& cb = side == kBorderBefore
-                                ? primary_cell_style.BorderBefore()
-                                : primary_cell_style.BorderAfter();
+    EBorderStyle cell_border_style =
+        side == kBorderBefore ? primary_cell_style.BorderBeforeStyle()
+                              : primary_cell_style.BorderAfterStyle();
+    float cell_border_width = side == kBorderBefore
+                                  ? primary_cell_style.BorderBeforeWidth()
+                                  : primary_cell_style.BorderAfterWidth();
     // FIXME: Don't repeat for the same col group
     LayoutTableCol* col =
         Table()->ColElementAtAbsoluteColumn(c).InnermostColOrColGroup();
     if (col) {
-      const BorderValue& gb = side == kBorderBefore
-                                  ? col->Style()->BorderBefore()
-                                  : col->Style()->BorderAfter();
-      if (gb.Style() == EBorderStyle::kHidden ||
-          cb.Style() == EBorderStyle::kHidden)
+      EBorderStyle col_border_style = side == kBorderBefore
+                                          ? col->Style()->BorderBeforeStyle()
+                                          : col->Style()->BorderAfterStyle();
+      const float col_border_width = side == kBorderBefore
+                                         ? col->Style()->BorderBeforeWidth()
+                                         : col->Style()->BorderAfterWidth();
+      if (col_border_style == EBorderStyle::kHidden ||
+          cell_border_style == EBorderStyle::kHidden)
         continue;
       all_hidden = false;
-      if (ComputedStyle::BorderStyleIsVisible(gb.Style()) &&
-          gb.Width() > border_width)
-        border_width = gb.Width();
-      if (ComputedStyle::BorderStyleIsVisible(cb.Style()) &&
-          cb.Width() > border_width)
-        border_width = cb.Width();
+      if (ComputedStyle::BorderStyleIsVisible(col_border_style) &&
+          col_border_width > border_width)
+        border_width = col_border_width;
+      if (ComputedStyle::BorderStyleIsVisible(cell_border_style) &&
+          cell_border_width > border_width)
+        border_width = cell_border_width;
     } else {
-      if (cb.Style() == EBorderStyle::kHidden)
+      if (cell_border_style == EBorderStyle::kHidden)
         continue;
       all_hidden = false;
-      if (ComputedStyle::BorderStyleIsVisible(cb.Style()) &&
-          cb.Width() > border_width)
-        border_width = cb.Width();
+      if (ComputedStyle::BorderStyleIsVisible(cell_border_style) &&
+          cell_border_width > border_width)
+        border_width = cell_border_width;
     }
   }
   if (all_hidden)
     return -1;
 
   if (side == kBorderAfter)
     border_width++;  // Distribute rounding error
   return border_width / 2;
 }
 
 int LayoutTableSection::CalcInlineDirectionOuterBorder(
     InlineBorderSide side) const {
   unsigned total_cols = Table()->NumEffectiveColumns();
   if (!grid_.size() || !total_cols)
     return 0;
   unsigned col_index = side == kBorderStart ? 0 : total_cols - 1;
 
   int border_width = 0;
 
-  const BorderValue& sb =
-      side == kBorderStart ? Style()->BorderStart() : Style()->BorderEnd();
-  if (sb.Style() == EBorderStyle::kHidden)
+  EBorderStyle section_border_style = side == kBorderStart
+                                          ? Style()->BorderStartStyle()
+                                          : Style()->BorderEndStyle();
+  const float section_border_width = side == kBorderStart
+                                         ? Style()->BorderStartWidth()
+                                         : Style()->BorderEndWidth();
+  if (section_border_style == EBorderStyle::kHidden)
     return -1;
-  if (ComputedStyle::BorderStyleIsVisible(sb.Style()))
-    border_width = sb.Width();
+  if (ComputedStyle::BorderStyleIsVisible(section_border_style))
+    border_width = section_border_width;
 
   if (LayoutTableCol* col = Table()
                                 ->ColElementAtAbsoluteColumn(col_index)
                                 .InnermostColOrColGroup()) {
-    const BorderValue& gb = side == kBorderStart ? col->Style()->BorderStart()
-                                                 : col->Style()->BorderEnd();
-    if (gb.Style() == EBorderStyle::kHidden)
+    EBorderStyle col_border_style = side == kBorderStart
+                                        ? col->Style()->BorderStartStyle()
+                                        : col->Style()->BorderEndStyle();
+    const float col_border_width = side == kBorderStart
+                                       ? col->Style()->BorderStartWidth()
+                                       : col->Style()->BorderEndWidth();
+    if (col_border_style == EBorderStyle::kHidden)
       return -1;
-    if (ComputedStyle::BorderStyleIsVisible(gb.Style()) &&
-        gb.Width() > border_width)
-      border_width = gb.Width();
+    if (ComputedStyle::BorderStyleIsVisible(col_border_style) &&
+        col_border_width > border_width)
+      border_width = col_border_width;
   }
 
   bool all_hidden = true;
   for (unsigned r = 0; r < grid_.size(); r++) {
     if (col_index >= NumCols(r))
       continue;
     const auto& grid_cell = GridCellAt(r, col_index);
     if (!grid_cell.HasCells())
       continue;
     // FIXME: Don't repeat for the same cell
     const ComputedStyle& primary_cell_style =
         grid_cell.PrimaryCell()->StyleRef();
     const ComputedStyle& primary_cell_parent_style =
         grid_cell.PrimaryCell()->Parent()->StyleRef();
     // FIXME: Make this work with perpendicular and flipped cells.
-    const BorderValue& cb = side == kBorderStart
-                                ? primary_cell_style.BorderStart()
-                                : primary_cell_style.BorderEnd();
-    const BorderValue& rb = side == kBorderStart
-                                ? primary_cell_parent_style.BorderStart()
-                                : primary_cell_parent_style.BorderEnd();
-    if (cb.Style() == EBorderStyle::kHidden ||
-        rb.Style() == EBorderStyle::kHidden)
+    EBorderStyle cell_border_style = side == kBorderStart
+                                         ? primary_cell_style.BorderStartStyle()
+                                         : primary_cell_style.BorderEndStyle();
+    EBorderStyle row_border_style =
+        side == kBorderStart ? primary_cell_parent_style.BorderStartStyle()
+                             : primary_cell_parent_style.BorderEndStyle();
+    const float cell_border_width = side == kBorderStart
+                                        ? primary_cell_style.BorderStartWidth()
+                                        : primary_cell_style.BorderEndWidth();
+    const float row_border_width =
+        side == kBorderStart ? primary_cell_parent_style.BorderStartWidth()
+                             : primary_cell_parent_style.BorderEndWidth();
+    if (cell_border_style == EBorderStyle::kHidden ||
+        row_border_style == EBorderStyle::kHidden)
       continue;
     all_hidden = false;
-    if (ComputedStyle::BorderStyleIsVisible(cb.Style()) &&
-        cb.Width() > border_width)
-      border_width = cb.Width();
-    if (ComputedStyle::BorderStyleIsVisible(rb.Style()) &&
-        rb.Width() > border_width)
-      border_width = rb.Width();
+    if (ComputedStyle::BorderStyleIsVisible(cell_border_style) &&
+        cell_border_width > border_width)
+      border_width = cell_border_width;
+    if (ComputedStyle::BorderStyleIsVisible(row_border_style) &&
+        row_border_width > border_width)
+      border_width = row_border_width;
   }
   if (all_hidden)
     return -1;
 
   if ((side == kBorderStart) != Table()->Style()->IsLeftToRightDirection())
     border_width++;  // Distribute rounding error
   return border_width / 2;
 }
 
 void LayoutTableSection::RecalcOuterBorder() {
@@ skipping 651 matching lines @@
 bool LayoutTableSection::PaintedOutputOfObjectHasNoEffectRegardlessOfSize()
     const {
   // LayoutTableSection paints background from columns.
   if (Table()->HasColElements())
     return false;
   return LayoutTableBoxComponent::
       PaintedOutputOfObjectHasNoEffectRegardlessOfSize();
 }
 
 }  // namespace blink