Fix Border collapsing with colpsan / rowspan cells

third_party/WebKit/Source/core/layout/LayoutTableCol.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, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 83 matching lines @@
   Table()->AddColumn(this);
 }
 
 void LayoutTableCol::WillBeRemovedFromTree() {
   LayoutTableBoxComponent::WillBeRemovedFromTree();
   Table()->RemoveColumn(this);
 }
 
 bool LayoutTableCol::IsChildAllowed(LayoutObject* child,
                                     const ComputedStyle& style) const {
-  // We cannot use isTableColumn here as style() may return 0.
+  // We cannot use IsTableColumn here as style() may return 0.
   return child->IsLayoutTableCol() && style.Display() == EDisplay::kTableColumn;
 }
 
 bool LayoutTableCol::CanHaveChildren() const {
   // Cols cannot have children. This is actually necessary to fix a bug
   // with libraries.uc.edu, which makes a <p> be a table-column.
   return IsTableColumnGroup();
 }
 
 LayoutRect LayoutTableCol::LocalVisualRect() const {
@@ skipping 28 matching lines @@
 LayoutTableCol* LayoutTableCol::EnclosingColumnGroup() const {
   if (!Parent()->IsLayoutTableCol())
     return nullptr;
 
   LayoutTableCol* parent_column_group = ToLayoutTableCol(Parent());
   DCHECK(parent_column_group->IsTableColumnGroup());
   DCHECK(IsTableColumn());
   return parent_column_group;
 }
 
+LayoutTableCol* LayoutTableCol::LastColumnInGroup() const {
+  DCHECK(this->IsTableColumnGroupWithColumnChildren());
+  LayoutTableCol* end_col = nullptr;
+  LayoutTableCol* current_col = this->NextColumn();
+  // If column has children, traverse the children to find last.
+  if (this->FirstChild()) {
+    while (current_col && current_col->EnclosingColumnGroup() == this) {
+      end_col = current_col;
+      current_col = current_col->NextColumn();
+    }
+  }
+  return end_col;
+}
+
 LayoutTableCol* LayoutTableCol::NextColumn() const {
   // If |this| is a column-group, the next column is the colgroup's first child
   // column.
   if (LayoutObject* first_child = this->FirstChild())
     return ToLayoutTableCol(first_child);
 
   // Otherwise it's the next column along.
   LayoutObject* next = NextSibling();
 
   // Failing that, the child is the last column in a column-group, so the next
   // column is the next column/column-group after its column-group.
-  if (!next && Parent()->IsLayoutTableCol())
-    next = Parent()->NextSibling();
+  auto p = Parent();
+  if (!next && p && p->IsLayoutTableCol())
+    next = p->NextSibling();
 
   for (; next && !next->IsLayoutTableCol(); next = next->NextSibling()) {
   }
 
   return ToLayoutTableCol(next);
 }
 
 const BorderValue& LayoutTableCol::BorderAdjoiningCellStartBorder(
     const LayoutTableCell*) const {
   return Style()->BorderStart();
@@ skipping 16 matching lines @@
 
 const BorderValue& LayoutTableCol::BorderAdjoiningCellAfter(
     const LayoutTableCell* cell) const {
   DCHECK_EQ(Table()
                 ->ColElementAtAbsoluteColumn(cell->AbsoluteColumnIndex() - 1)
                 .InnermostColOrColGroup(),
             this);
   return Style()->BorderEnd();
 }
 
+Vector<unsigned> LayoutTableCol::GetEffectiveColumnIndexes() const {
+  LayoutTable* table = this->Table();
+  Vector<unsigned> indexes;
+  if (!table)
+    return indexes;
+  unsigned last_effective_column = table->LastEffectiveColumnIndex();
+  if (IsTableColumn()) {
+    unsigned idx = table->ColElementToAbsoluteColumn(this);
+    auto span = this->Span();
+    unsigned last_seen_column = 0xFFFFFFFF;
+    while (span--) {
+      unsigned effective_column = table->AbsoluteColumnToEffectiveColumn(idx++);
+      if (effective_column != last_seen_column &&
+          effective_column <= last_effective_column) {
+        indexes.push_back(effective_column);
+        last_seen_column = effective_column;
+      }
+    }
+  } else {  // IsTableColumnGroup
+    if (IsTableColumnGroupWithColumnChildren()) {
+      LayoutTableCol* current_col = nullptr;
+      auto last_col = LastColumnInGroup();
+      do {
+        current_col = current_col ? current_col->NextColumn() : NextColumn();
+        if (current_col) {
+          auto colIndexes = current_col->GetEffectiveColumnIndexes();
+          for (auto c = colIndexes.begin(); c != colIndexes.end(); c++)
+            indexes.push_back(*c);
+        }
+      } while (current_col && current_col != last_col);
+    } else {  // tableColumnGroup with no children
+      // its covers span columns
+      unsigned idx = table->ColElementToAbsoluteColumn(this);
+      auto span = this->Span();
+      unsigned last_seen_column = 0xFFFFFFFF;
+      while (span--) {
+        unsigned effective_column =
+            table->AbsoluteColumnToEffectiveColumn(idx++);
+        if (effective_column != last_seen_column &&
+            effective_column <= last_effective_column) {
+          indexes.push_back(effective_column);
+          last_seen_column = effective_column;
+        }
+      }
+    }
+  }
+  return indexes;
+}
+
 }  // namespace blink