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/21 00:08:22]

Lets add a comment here describing why collapsed borders are different. Maybe
something like:

// Collapsed borders can be painted together (e.g., left & top) but there are at
most 4 phases of collapsed
// border painting for a single cell. To disambiguate these phases of collapsed
border painting, a mask is used.
//
// TableCollapsedBorderBase can be larger than TableCollapsedBorderUnalignedBase
to ensure the base lower bits are 0's.

[Xianzhu, 2015/08/21 17:11:52]

Done.

+        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