Don't cache reflection drawings

Source/platform/graphics/paint/DisplayItemList.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 DisplayItemList_h
 #define DisplayItemList_h
 
 #include "platform/PlatformExport.h"
 #include "platform/graphics/paint/DisplayItem.h"
 #include "wtf/HashMap.h"
@@ skipping 17 matching lines @@
 
     // These methods are called during paint invalidation.
     void invalidate(DisplayItemClient);
     void invalidateAll();
 
     // These methods are called during painting.
     void add(WTF::PassOwnPtr<DisplayItem>);
     void beginScope(DisplayItemClient);
     void endScope(DisplayItemClient);
 
+    void beginSkippingCache() { ++m_skippingCacheCount; }
+    void endSkippingCache() { ASSERT(m_skippingCacheCount > 0); --m_skippingCacheCount; }
+    bool skippingCache() const { return m_skippingCacheCount; }
+
     // Must be called when a painting is finished.
     void commitNewDisplayItems();
 
     // Get the paint list generated after the last painting.
     const DisplayItems& displayItems() const;
 
     bool clientCacheIsValid(DisplayItemClient) const;
 
     // Commits the new display items and plays back the updated display items into the given context.
     void commitNewDisplayItemsAndReplay(GraphicsContext& context)
     {
         commitNewDisplayItems();
         replay(context);
     }
 
     bool displayItemConstructionIsDisabled() const { return m_constructionDisabled; }
     void setDisplayItemConstructionIsDisabled(const bool disable) { m_constructionDisabled = disable; }
 
 #if ENABLE(ASSERT)
     size_t newDisplayItemsSize() const { return m_newDisplayItems.size(); }
 #endif
 
 #ifndef NDEBUG
     void showDebugData() const;
 #endif
 
 protected:
     DisplayItemList()
         : m_validlyCachedClientsDirty(false)
-        , m_constructionDisabled(false) { }
+        , m_constructionDisabled(false)
+        , m_skippingCacheCount(0) { }
 
 private:
     friend class DisplayItemListTest;
     friend class DisplayItemListPaintTest;
     friend class LayoutObjectDrawingRecorderTest;
 
     void updateValidlyCachedClientsIfNeeded() const;
 
 #ifndef NDEBUG
     WTF::String displayItemsAsDebugString(const DisplayItems&) const;
@@ skipping 24 matching lines @@
     // It's lazily updated in updateValidlyCachedClientsIfNeeded().
     // FIXME: In the future we can replace this with client-side repaint flags
     // to avoid the cost of building and querying the hash table.
     mutable HashSet<DisplayItemClient> m_validlyCachedClients;
     mutable bool m_validlyCachedClientsDirty;
 
     // Allow display item construction to be disabled to isolate the costs of construction
     // in performance metrics.
     bool m_constructionDisabled;
 
+    int m_skippingCacheCount;
+
     // Scope ids are allocated per client to ensure that the ids are stable for non-invalidated
     // clients between frames, so that we can use the id to match new display items to cached
     // display items.
     struct Scope {
         Scope(DisplayItemClient c, int i) : client(c), id(i) { }
         DisplayItemClient client;
         int id;
     };
     typedef HashMap<DisplayItemClient, int> ClientScopeIdMap;
     ClientScopeIdMap m_clientScopeIdMap;
     Vector<Scope> m_scopeStack;
 
 #if ENABLE(ASSERT)
     // This is used to check duplicated ids during add(). We could also check during
     // updatePaintList(), but checking during add() helps developer easily find where
     // the duplicated ids are from.
     DisplayItemIndicesByClientMap m_newDisplayItemIndicesByClient;
 #endif
 };
 
 } // namespace blink
 
 #endif // DisplayItemList_h