Don't cache subsequence whose layer is not fully contained by repaint rect

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 171 matching lines @@
         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)
+        , m_isUncacheable(false)
 #ifndef NDEBUG
         , m_clientDebugString(client.debugName())
 #endif
     {
         // derivedSize must fit in m_derivedSize.
         // If it doesn't, enlarge m_derivedSize and fix this assert.
         ASSERT_WITH_SECURITY_IMPLICATION(derivedSize < (1 << 8));
         ASSERT_WITH_SECURITY_IMPLICATION(derivedSize >= sizeof(*this));
     }
 
@@ skipping 48 matching lines @@
     // Size of this object in memory, used to move it with memcpy.
     // This is not sizeof(*this), because it needs to account for the size of
     // the derived class (i.e. runtime type). Derived classes are expected to
     // supply this to the DisplayItem constructor.
     size_t derivedSize() const { return m_derivedSize; }
 
     // For DisplayItemList only. Painters should use DisplayItemCacheSkipper instead.
     void setSkippedCache() { m_skippedCache = true; }
     bool skippedCache() const { return m_skippedCache; }
 
+    void setUncacheable() { m_isUncacheable = true; }
+    bool isUncacheable() const { return m_isUncacheable; }

[chrishtr, 2015/09/08 22:48:00]

This can be private.

+
     virtual void appendToWebDisplayItemList(WebDisplayItemList*) const { }
 
     // See comments of enum Type for usage of the following macros.
 #define DEFINE_CATEGORY_METHODS(Category) \
     static bool is##Category##Type(Type type) { return type >= Category##First && type <= Category##Last; } \
     bool is##Category() const { return is##Category##Type(type()); }
 
 #define DEFINE_CONVERSION_METHODS(Category1, category1, Category2, category2) \
     static Type category1##TypeTo##Category2##Type(Type type) \
     { \
@@ skipping 35 matching lines @@
     DEFINE_PAINT_PHASE_CONVERSION_METHOD(FloatClip)
 
     DEFINE_PAIRED_CATEGORY_METHODS(Scroll, scroll)
     DEFINE_PAINT_PHASE_CONVERSION_METHOD(Scroll)
 
     DEFINE_PAIRED_CATEGORY_METHODS(Transform3D, transform3D);
 
     static bool isCachedType(Type type) { return isCachedDrawingType(type) || type == CachedSubsequence; }
     bool isCached() const { return isCachedType(m_type); }
     static bool isCacheableType(Type type) { return isDrawingType(type) || type == BeginSubsequence; }
-    bool isCacheable() const { return !skippedCache() && isCacheableType(m_type); }
+    bool isCacheable() const { return !isUncacheable() && isCacheableType(m_type); }
 
     virtual bool isBegin() const { return false; }
     virtual bool isEnd() const { return false; }
 
 #if ENABLE(ASSERT)
     virtual bool isEndAndPairedWith(DisplayItem::Type otherType) const { return false; }
 #endif
 
     virtual bool drawsContent() const { return false; }
 
@@ skipping 13 matching lines @@
     // ContiguousContainer::appendByMoving where an invalid DisplaItem is
     // constructed at the source location.
     template <typename T, unsigned alignment> friend class ContiguousContainer;
 
     DisplayItem()
         : m_client(nullptr)
         , m_scope(0)
         , m_type(UninitializedType)
         , m_derivedSize(sizeof(*this))
         , m_skippedCache(false)
+        , m_isUncacheable(false)
     { }
 
     DisplayItemClient m_client;
     unsigned m_scope;
     static_assert(TypeLast < (1 << 16), "DisplayItem::Type should fit in 16 bits");
     const Type m_type : 16;
     unsigned m_derivedSize : 8; // size of the actual derived class
     unsigned m_skippedCache : 1;
+    unsigned m_isUncacheable : 1;
 
 #ifndef NDEBUG
     WTF::String m_clientDebugString;
 #endif
 };
 
 class PLATFORM_EXPORT PairedBeginDisplayItem : public DisplayItem {
 protected:
     PairedBeginDisplayItem(const DisplayItemClientWrapper& client, Type type, size_t derivedSize) : DisplayItem(client, type, derivedSize) { }
 
 private:
     bool isBegin() const final { return true; }
 };
 
 class PLATFORM_EXPORT PairedEndDisplayItem : public DisplayItem {
 protected:
     PairedEndDisplayItem(const DisplayItemClientWrapper& client, Type type, size_t derivedSize) : DisplayItem(client, type, derivedSize) { }
 
 #if ENABLE(ASSERT)
     bool isEndAndPairedWith(DisplayItem::Type otherType) const override = 0;
 #endif
 
 private:
     bool isEnd() const final { return true; }
 };
 
 } // namespace blink
 
 #endif // DisplayItem_h