Let collapsed border drawings be cacheable

Source/platform/graphics/paint/DisplayItem.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef DisplayItem_h
 #define DisplayItem_h
 
 #include "platform/PlatformExport.h"
 #include "platform/graphics/ContiguousContainer.h"
 #include "platform/graphics/paint/DisplayItemClient.h"
@@ skipping 73 matching lines @@
         ScrollbarForwardButtonStart,
         ScrollbarForwardTrack,
         ScrollbarHorizontal, // For ScrollbarThemeMacNonOverlayAPI only.
         ScrollbarThumb,
         ScrollbarTickmarks,
         ScrollbarTrackBackground,
         ScrollbarVertical, // For ScrollbarThemeMacNonOverlayAPI only.
         SelectionGap,
         SelectionTint,
         TableCellBackgroundFromSelfPaintingRow, // FIXME: To be deprecated.
+        TableCollapsedBorderUnalignedBase,

[pdr., 2015/08/20 07:07:15]

This represents a whole bunch of new types just for collapsed borders. Are they
really special enough to require a new approach that wasn't needed for other
types? I didn't follow the patches that added these cases originally, so I may
be rehashing old discussion :(

It looks like we paint collapsed borders by themselves (i.e., not interleaved
with potentially-overlapping cells). Could we just introduce a single display
item for the entire table's collapsed borders? Or, maybe one per row or column?

[Xianzhu, 2015/08/20 16:39:51]

I know the 16 new types may look scary :), but this doesn't increase the number
of generated actual display items. Each cell still generate at most four display
items for collapsed borders if the borders are all of different priorities
(caused by e.g. different widths). Previously we couldn't distinguish them so
used ScopeRecorder which disabled caching of them.

The following scenarios may help understand the method:
- If all cell have borders which are of the same priority, each cell generates
one display item for collapsed borders with type
TableCollapsedBorderTopLeftRightBottom;
- Given two adjacent cells with certain collapsed border styles, we may generate
the following display items (cell1 border: 2px 4px 2px 4px; cell2 border: 5px
4px 1px 4px)
   cell2, TableCollapsedBorderBottom
   cell1, TableCollapsedBorderTopBottom
   cell2, TableCollapsedBorderRightLeft
   cell1, TableCollapsedBorderRightLeft
   cell2, TableCollapsedBorderTop
(Previously, we also generated 5 display items, all with type
DrawingPaintPhaseTableCollapsedBorder.)

Another way is just to add 4 new display items: TableCollapsedBorder[1-4] (1~4
are the sequence of the collapsed border display items for a cell), then the
above display items will be:
   cell2, TableCollapsedBorder1 (for bottom)
   cell1, TableCollapsedBorder1 (for top and bottom)
   cell2, TableCollapsedBorder2 (for right and left)
   cell1, TableCollapsedBorder2 (for right and left)
   cell2, TableCollapsedBorder3 (for top)
In this way, it seems harder to debug, and we need a counter somewhere
associated with each cell during painting.
They do interleave, so TablePainter iterate the cells multiple passes to paint
collapsed borders of different priorities. The example above also explains this.
Tried this, but finally I found that this conflicts with the painting
optimization in TableSectionPainter::paintObject() which skips painting of table
rows outside of the paint rect. If we used a single display item, the item will
be different when paint rect changes.
This will make the situation more complex. The number of display items for
collapsed borders for a row or column is deterministic depending on how many
priorities of collapsed borders are, and I see no way to distinguish them except
using scopes. In contrast, a cell generates at most 4 display items.

+        TableCollapsedBorderBase = (((TableCollapsedBorderUnalignedBase - 1) >> 4) + 1) << 4,
+        TableCollapsedBorderLast = TableCollapsedBorderBase + 0x0f,
         VideoBitmap,
         WebPlugin,
         WebFont,
         DrawingLast = WebFont,
 
         CachedDrawingFirst,
         CachedDrawingLast = CachedDrawingFirst + DrawingLast - DrawingFirst,
 
         ClipFirst,
         ClipBoxPaintPhaseFirst = ClipFirst,
@@ skipping 67 matching lines @@
 
         EndSubtreeFirst,
         EndSubtreePaintPhaseFirst = EndSubtreeFirst,
         EndSubtreePaintPhaseLast = EndSubtreePaintPhaseFirst + PaintPhaseMax,
         EndSubtreeLast = EndSubtreePaintPhaseLast,
 
         UninitializedType,
         TypeLast = UninitializedType
     };
 
+    static_assert(TableCollapsedBorderBase >= TableCollapsedBorderUnalignedBase, "TableCollapsedBorder types overlap with other types");
+    static_assert((TableCollapsedBorderBase & 0xf) == 0, "The lowest 4 bits of TableCollapsedBorderBase should be zero");
+    enum TableCollspaedBorderSides {
+        // Bits or'ed onto TableCollapsedBorderBase to generate a real table collapsed border type.
+        TableCollapsedBorderTop = 1 << 0,
+        TableCollapsedBorderRight = 1 << 1,
+        TableCollapsedBorderBottom = 1 << 2,
+        TableCollapsedBorderLeft = 1 << 3,
+    };
+
     DisplayItem(const DisplayItemClientWrapper& client, Type type, size_t derivedSize)
         : m_client(client.displayItemClient())
         , m_scope(0)
         , m_type(type)
         , m_derivedSize(derivedSize)
         , m_skippedCache(false)
 #ifndef NDEBUG
         , m_clientDebugString(client.debugName())
 #endif
     {
@@ skipping 21 matching lines @@
                 && type == item.m_type
                 && scope == item.m_scope;
         }
 
         const DisplayItemClient client;
         const Type type;
         const unsigned scope;
     };
 
     // Convert cached type to non-cached type (e.g., Type::CachedSVGImage -> Type::SVGImage).
-    Type nonCachedType() const
+    static Type nonCachedType(Type type)
     {
-        if (isCachedDrawingType(m_type))
-            return cachedDrawingTypeToDrawingType(m_type);
-        if (isCachedSubtreeType(m_type))
-            return cachedSubtreeTypeToBeginSubtreeType(m_type);
-        return m_type;
+        if (isCachedDrawingType(type))
+            return cachedDrawingTypeToDrawingType(type);
+        if (isCachedSubtreeType(type))
+            return cachedSubtreeTypeToBeginSubtreeType(type);
+        return type;
     }
 
     // Return the Id with cached type converted to non-cached type.
     Id nonCachedId() const
     {
-        return Id(m_client, nonCachedType(), m_scope);
+        return Id(m_client, nonCachedType(m_type), m_scope);
     }
 
     virtual void replay(GraphicsContext&) { }
 
     DisplayItemClient client() const { return m_client; }
     Type type() const { return m_type; }
 
     void setScope(unsigned scope) { m_scope = scope; }
     unsigned scope() { return m_scope; }
 
@@ skipping 138 matching lines @@
     bool isEndAndPairedWith(DisplayItem::Type otherType) const override = 0;
 #endif
 
 private:
     bool isEnd() const final { return true; }
 };
 
 } // namespace blink
 
 #endif // DisplayItem_h