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

third_party/WebKit/Source/core/layout/LayoutTableCell.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, 2007, 2008, 2009 Apple Inc.
  *               All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 623 matching lines @@
                ? cell_before->GetCollapsedBorderValues()->EndBorder()
                : CollapsedBorderValue();
   }
 
   // For the start border, we need to check, in order of precedence:
   // (1) Our start border.
   int start_color_property =
       ResolveBorderProperty(CSSPropertyWebkitBorderStartColor);
   int end_color_property =
       ResolveBorderProperty(CSSPropertyWebkitBorderEndColor);
-  CollapsedBorderValue result(Style()->BorderStart(),
-                              ResolveColor(start_color_property),
-                              kBorderPrecedenceCell);
+  CollapsedBorderValue result(
+      Style()->BorderStartStyle(), Style()->BorderStartWidth(),
+      ResolveColor(start_color_property), kBorderPrecedenceCell);
 
   // (2) The end border of the preceding cell.
   if (cell_before) {
     CollapsedBorderValue cell_before_adjoining_border = CollapsedBorderValue(
         cell_before->BorderAdjoiningCellAfter(this),
         cell_before->ResolveColor(end_color_property), kBorderPrecedenceCell);
     // |result| should be the 2nd argument as |cellBefore| should win in case of
     // equality per CSS 2.1 (Border conflict resolution, point 4).
     result = ChooseBorder(cell_before_adjoining_border, result);
     if (!result.Exists())
@@ skipping 111 matching lines @@
                : CollapsedBorderValue();
   }
 
   // For end border, we need to check, in order of precedence:
   // (1) Our end border.
   int start_color_property =
       ResolveBorderProperty(CSSPropertyWebkitBorderStartColor);
   int end_color_property =
       ResolveBorderProperty(CSSPropertyWebkitBorderEndColor);
   CollapsedBorderValue result = CollapsedBorderValue(
-      Style()->BorderEnd(), ResolveColor(end_color_property),
-      kBorderPrecedenceCell);
+      Style()->BorderEndStyle(), Style()->BorderEndWidth(),
+      ResolveColor(end_color_property), kBorderPrecedenceCell);
 
   // (2) The start border of the following cell.
   if (cell_after) {
     CollapsedBorderValue cell_after_adjoining_border = CollapsedBorderValue(
         cell_after->BorderAdjoiningCellBefore(this),
         cell_after->ResolveColor(start_color_property), kBorderPrecedenceCell);
     result = ChooseBorder(result, cell_after_adjoining_border);
     if (!result.Exists())
       return result;
   }
@@ skipping 103 matching lines @@
                : CollapsedBorderValue();
   }
 
   // For before border, we need to check, in order of precedence:
   // (1) Our before border.
   int before_color_property =
       ResolveBorderProperty(CSSPropertyWebkitBorderBeforeColor);
   int after_color_property =
       ResolveBorderProperty(CSSPropertyWebkitBorderAfterColor);
   CollapsedBorderValue result = CollapsedBorderValue(
-      Style()->BorderBefore(), ResolveColor(before_color_property),
-      kBorderPrecedenceCell);
+      Style()->BorderBeforeStyle(), Style()->BorderBeforeWidth(),
+      ResolveColor(before_color_property), kBorderPrecedenceCell);
 
   if (prev_cell) {
     // (2) A before cell's after border.
     result = ChooseBorder(
-        CollapsedBorderValue(prev_cell->Style()->BorderAfter(),
+        CollapsedBorderValue(prev_cell->Style()->BorderAfterStyle(),
+                             prev_cell->Style()->BorderAfterWidth(),
                              prev_cell->ResolveColor(after_color_property),
                              kBorderPrecedenceCell),
         result);
     if (!result.Exists())
       return result;
   }
 
   // (3) Our row's before border.
   result = ChooseBorder(
       result,
-      CollapsedBorderValue(Parent()->Style()->BorderBefore(),
+      CollapsedBorderValue(Parent()->Style()->BorderBeforeStyle(),
+                           Parent()->Style()->BorderBeforeWidth(),
                            Parent()->ResolveColor(before_color_property),
                            kBorderPrecedenceRow));
   if (!result.Exists())
     return result;
 
   // (4) The previous row's after border.
   if (prev_cell) {
     LayoutObject* prev_row = nullptr;
     if (prev_cell->Section() == Section())
       prev_row = Parent()->PreviousSibling();
     else
       prev_row = prev_cell->Section()->LastRow();
 
     if (prev_row) {
       result = ChooseBorder(
-          CollapsedBorderValue(prev_row->Style()->BorderAfter(),
+          CollapsedBorderValue(prev_row->Style()->BorderAfterStyle(),
+                               prev_row->Style()->BorderAfterWidth(),
                                prev_row->ResolveColor(after_color_property),
                                kBorderPrecedenceRow),
           result);
       if (!result.Exists())
         return result;
     }
   }
 
   // Now check row groups.
   LayoutTableSection* curr_section = Section();
   if (!RowIndex()) {
     // (5) Our row group's before border.
     result = ChooseBorder(
         result,
-        CollapsedBorderValue(curr_section->Style()->BorderBefore(),
+        CollapsedBorderValue(curr_section->Style()->BorderBeforeStyle(),
+                             curr_section->Style()->BorderBeforeWidth(),
                              curr_section->ResolveColor(before_color_property),
                              kBorderPrecedenceRowGroup));
     if (!result.Exists())
       return result;
 
     // (6) Previous row group's after border.
     curr_section = table->SectionAbove(curr_section, kSkipEmptySections);
     if (curr_section) {
       result = ChooseBorder(
-          CollapsedBorderValue(curr_section->Style()->BorderAfter(),
+          CollapsedBorderValue(curr_section->Style()->BorderAfterStyle(),
+                               curr_section->Style()->BorderAfterWidth(),
                                curr_section->ResolveColor(after_color_property),
                                kBorderPrecedenceRowGroup),
           result);
       if (!result.Exists())
         return result;
     }
   }
 
   if (!curr_section) {
     // (8) Our column and column group's before borders.
     LayoutTableCol* col_elt =
         table->ColElementAtAbsoluteColumn(AbsoluteColumnIndex())
             .InnermostColOrColGroup();
     if (col_elt) {
       result = ChooseBorder(
           result,
-          CollapsedBorderValue(col_elt->Style()->BorderBefore(),
+          CollapsedBorderValue(col_elt->Style()->BorderBeforeStyle(),
+                               col_elt->Style()->BorderBeforeWidth(),
                                col_elt->ResolveColor(before_color_property),
                                kBorderPrecedenceColumn));
       if (!result.Exists())
         return result;
       if (LayoutTableCol* enclosing_column_group =
               col_elt->EnclosingColumnGroup()) {
         result = ChooseBorder(
             result,
             CollapsedBorderValue(
-                enclosing_column_group->Style()->BorderBefore(),
+                enclosing_column_group->Style()->BorderBeforeStyle(),
+                enclosing_column_group->Style()->BorderBeforeWidth(),
                 enclosing_column_group->ResolveColor(before_color_property),
                 kBorderPrecedenceColumnGroup));
         if (!result.Exists())
           return result;
       }
     }
 
     // (9) The table's before border.
     result = ChooseBorder(
-        result, CollapsedBorderValue(table->Style()->BorderBefore(),
+        result, CollapsedBorderValue(table->Style()->BorderBeforeStyle(),
+                                     table->Style()->BorderBeforeWidth(),
                                      table->ResolveColor(before_color_property),
                                      kBorderPrecedenceTable));
     if (!result.Exists())
       return result;
   }
 
   return result;
 }
 
 CollapsedBorderValue LayoutTableCell::ComputeCollapsedAfterBorder() const {
   LayoutTable* table = this->Table();
   LayoutTableCell* next_cell = table->CellBelow(this);
   // We can use the border shared with |next_cell| if it is valid.
   if (next_cell && next_cell->collapsed_border_values_valid_ &&
       next_cell->AbsoluteColumnIndex() == AbsoluteColumnIndex()) {
     return next_cell->GetCollapsedBorderValues()
                ? next_cell->GetCollapsedBorderValues()->BeforeBorder()
                : CollapsedBorderValue();
   }
 
   // For after border, we need to check, in order of precedence:
   // (1) Our after border.
   int before_color_property =
       ResolveBorderProperty(CSSPropertyWebkitBorderBeforeColor);
   int after_color_property =
       ResolveBorderProperty(CSSPropertyWebkitBorderAfterColor);
   CollapsedBorderValue result = CollapsedBorderValue(
-      Style()->BorderAfter(), ResolveColor(after_color_property),
-      kBorderPrecedenceCell);
+      Style()->BorderAfterStyle(), Style()->BorderAfterWidth(),
+      ResolveColor(after_color_property), kBorderPrecedenceCell);
 
   if (next_cell) {
     // (2) An after cell's before border.
     result = ChooseBorder(
         result,
-        CollapsedBorderValue(next_cell->Style()->BorderBefore(),
+        CollapsedBorderValue(next_cell->Style()->BorderBeforeStyle(),
+                             next_cell->Style()->BorderBeforeWidth(),
                              next_cell->ResolveColor(before_color_property),
                              kBorderPrecedenceCell));
     if (!result.Exists())
       return result;
   }
 
   // (3) Our row's after border. (FIXME: Deal with rowspan!)
   result = ChooseBorder(
-      result, CollapsedBorderValue(Parent()->Style()->BorderAfter(),
+      result, CollapsedBorderValue(Parent()->Style()->BorderAfterStyle(),
+                                   Parent()->Style()->BorderAfterWidth(),
                                    Parent()->ResolveColor(after_color_property),
                                    kBorderPrecedenceRow));
   if (!result.Exists())
     return result;
 
   // (4) The next row's before border.
   if (next_cell) {
     result = ChooseBorder(
         result, CollapsedBorderValue(
-                    next_cell->Parent()->Style()->BorderBefore(),
+                    next_cell->Parent()->Style()->BorderBeforeStyle(),
+                    next_cell->Parent()->Style()->BorderBeforeWidth(),
                     next_cell->Parent()->ResolveColor(before_color_property),
                     kBorderPrecedenceRow));
     if (!result.Exists())
       return result;
   }
 
   // Now check row groups.
   LayoutTableSection* curr_section = Section();
   if (RowIndex() + RowSpan() >= curr_section->NumRows()) {
     // (5) Our row group's after border.
     result = ChooseBorder(
         result,
-        CollapsedBorderValue(curr_section->Style()->BorderAfter(),
+        CollapsedBorderValue(curr_section->Style()->BorderAfterStyle(),
+                             curr_section->Style()->BorderAfterWidth(),
                              curr_section->ResolveColor(after_color_property),
                              kBorderPrecedenceRowGroup));
     if (!result.Exists())
       return result;
 
     // (6) Following row group's before border.
     curr_section = table->SectionBelow(curr_section, kSkipEmptySections);
     if (curr_section) {
       result = ChooseBorder(
           result, CollapsedBorderValue(
-                      curr_section->Style()->BorderBefore(),
+                      curr_section->Style()->BorderBeforeStyle(),
+                      curr_section->Style()->BorderBeforeWidth(),
                       curr_section->ResolveColor(before_color_property),
                       kBorderPrecedenceRowGroup));
       if (!result.Exists())
         return result;
     }
   }
 
   if (!curr_section) {
     // (8) Our column and column group's after borders.
     LayoutTableCol* col_elt =
         table->ColElementAtAbsoluteColumn(AbsoluteColumnIndex())
             .InnermostColOrColGroup();
     if (col_elt) {
       result = ChooseBorder(
           result,
-          CollapsedBorderValue(col_elt->Style()->BorderAfter(),
+          CollapsedBorderValue(col_elt->Style()->BorderAfterStyle(),
+                               col_elt->Style()->BorderAfterWidth(),
                                col_elt->ResolveColor(after_color_property),
                                kBorderPrecedenceColumn));
       if (!result.Exists())
         return result;
       if (LayoutTableCol* enclosing_column_group =
               col_elt->EnclosingColumnGroup()) {
         result = ChooseBorder(
             result,
             CollapsedBorderValue(
-                enclosing_column_group->Style()->BorderAfter(),
+                enclosing_column_group->Style()->BorderAfterStyle(),
+                enclosing_column_group->Style()->BorderAfterWidth(),
                 enclosing_column_group->ResolveColor(after_color_property),
                 kBorderPrecedenceColumnGroup));
         if (!result.Exists())
           return result;
       }
     }
 
     // (9) The table's after border.
     result = ChooseBorder(
-        result, CollapsedBorderValue(table->Style()->BorderAfter(),
+        result, CollapsedBorderValue(table->Style()->BorderAfterStyle(),
+                                     table->Style()->BorderAfterWidth(),
                                      table->ResolveColor(after_color_property),
                                      kBorderPrecedenceTable));
     if (!result.Exists())
       return result;
   }
 
   return result;
 }
 
 LayoutUnit LayoutTableCell::BorderLeft() const {
@@ skipping 372 matching lines @@
 
   return LayoutBlock::HasLineIfEmpty();
 }
 
 PaintInvalidationReason LayoutTableCell::InvalidatePaint(
     const PaintInvalidatorContext& context) const {
   return TableCellPaintInvalidator(*this, context).InvalidatePaint();
 }
 
 }  // namespace blink