Trial: build trunk with Oilpan everywhere.

third_party/WebKit/Source/core/css/CSSDefaultStyleSheets.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 28 matching lines @@
 #include "core/layout/LayoutTheme.h"
 #include "platform/PlatformResourceLoader.h"
 #include "wtf/LeakAnnotations.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 CSSDefaultStyleSheets& CSSDefaultStyleSheets::instance()
 {
-    DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<CSSDefaultStyleSheets>, cssDefaultStyleSheets, (adoptPtrWillBeNoop(new CSSDefaultStyleSheets())));
+    WTF_ANNOTATE_SCOPED_MEMORY_LEAK;
+    DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<CSSDefaultStyleSheets>, cssDefaultStyleSheets, (adoptPtrWillBeNoop(new CSSDefaultStyleSheets)));

[haraken, 2015/11/30 01:48:47]

What happens if we insert WTF_ANNOTATE_SCOPED_MEMORY_LEAK into
DEFINE_STATIC_LOCAL (and its family)? I guess it would be reasonable to mark all
DEFINE_STATIC_LOCALs as leaking.

[sof, 2015/11/30 21:53:39]

I think it will mostly be non-harmful, with or without Oilpan, but it isn't
sufficient to solve the problem for Oilpan.

The reason why is that Oilpan heap pages are registered root regions to LSan,
meaning that the leak detector will scan those regions for pointers into other
heaps (e.g., PartitionAlloc's) and check if those pointed-to objects are
LSan-controlled allocations. If they are, we've got a leak.

Which means it will be able to scan some of the stylesheet heap objects that
instance() retains and refers to, and from those locate their off-heap &
LSan-controlled allocations. So, if we just use WTF_ANNOTATE_SCOPED_MEMORY_LEAK
when instantiating instance(), only the allocations that the constructor makes
will be exempted from LSan's consideration. e.g., what
instance()::m_defaultSheet initially allocates will not be seen as leaking.

However, any allocation made subsequently and then attached to instance() will
not be exempted from LSan leak detection & will be seen as leaking. e.g.,
instance()::m_defaultViewSourceStyle and all it points will leak if it is ever
lazily created.

Which means we have to turn off LSan whenever we create objects and update a
global singleton Persistent<> to refer to those. Hence all the uses of
WTF_ANNOTATE_SCOPED_MEMORY_LEAK here. Which is a brittle arrangement.

We sort of want LSan to flood fill kIgnored tags from the global
cache/singleton, but that is not what LSan (also) does.

iow, I don't have a good solution or approach to suggest atm.

     return *cssDefaultStyleSheets;
 }
 
 static const MediaQueryEvaluator& screenEval()
 {
     DEFINE_STATIC_LOCAL(const MediaQueryEvaluator, staticScreenEval, ("screen"));
     return staticScreenEval;
 }
 
 static const MediaQueryEvaluator& printEval()
@@ skipping 39 matching lines @@
 
     // Quirks-mode rules.
     String quirksRules = loadResourceAsASCIIString("quirks.css") + LayoutTheme::theme().extraQuirksStyleSheet();
     m_quirksStyleSheet = parseUASheet(quirksRules);
     m_defaultQuirksStyle->addRulesFromSheet(quirksStyleSheet(), screenEval());
 }
 
 RuleSet* CSSDefaultStyleSheets::defaultViewSourceStyle()
 {
     if (!m_defaultViewSourceStyle) {
+        WTF_ANNOTATE_SCOPED_MEMORY_LEAK;
         m_defaultViewSourceStyle = RuleSet::create();
         // Loaded stylesheet is leaked on purpose.
         RefPtrWillBeRawPtr<StyleSheetContents> stylesheet = parseUASheet(loadResourceAsASCIIString("view-source.css"));
         m_defaultViewSourceStyle->addRulesFromSheet(stylesheet.release().leakRef(), screenEval());
     }
     return m_defaultViewSourceStyle.get();
 }
 
 RuleSet* CSSDefaultStyleSheets::defaultXHTMLMobileProfileStyle()
 {
     if (!m_defaultXHTMLMobileProfileStyle) {
+        WTF_ANNOTATE_SCOPED_MEMORY_LEAK;
         m_defaultXHTMLMobileProfileStyle = RuleSet::create();
         // Loaded stylesheet is leaked on purpose.
         RefPtrWillBeRawPtr<StyleSheetContents> stylesheet = parseUASheet(loadResourceAsASCIIString("xhtmlmp.css"));
         m_defaultXHTMLMobileProfileStyle->addRulesFromSheet(stylesheet.release().leakRef(), screenEval());
     }
     return m_defaultXHTMLMobileProfileStyle.get();
 }
 
 RuleSet* CSSDefaultStyleSheets::defaultMobileViewportStyle()
 {
     if (!m_defaultMobileViewportStyle) {
+        WTF_ANNOTATE_SCOPED_MEMORY_LEAK;
         m_defaultMobileViewportStyle = RuleSet::create();
         m_mobileViewportStyleSheet = parseUASheet(loadResourceAsASCIIString("viewportAndroid.css"));
         m_defaultMobileViewportStyle->addRulesFromSheet(m_mobileViewportStyleSheet.get(), screenEval());
     }
     return m_defaultMobileViewportStyle.get();
 }
 
 void CSSDefaultStyleSheets::ensureDefaultStyleSheetsForElement(const Element& element, bool& changedDefaultStyle)
 {
     // FIXME: We should assert that the sheet only styles SVG elements.
     if (element.isSVGElement() && !m_svgStyleSheet) {
+        WTF_ANNOTATE_SCOPED_MEMORY_LEAK;
         m_svgStyleSheet = parseUASheet(loadResourceAsASCIIString("svg.css"));
         m_defaultStyle->addRulesFromSheet(svgStyleSheet(), screenEval());
         m_defaultPrintStyle->addRulesFromSheet(svgStyleSheet(), printEval());
         changedDefaultStyle = true;
     }
 
     // FIXME: We should assert that the sheet only styles MathML elements.
     if (element.namespaceURI() == MathMLNames::mathmlNamespaceURI
         && !m_mathmlStyleSheet) {
         m_mathmlStyleSheet = parseUASheet(loadResourceAsASCIIString("mathml.css"));
@@ skipping 39 matching lines @@
     visitor->trace(m_defaultStyleSheet);
     visitor->trace(m_mobileViewportStyleSheet);
     visitor->trace(m_quirksStyleSheet);
     visitor->trace(m_svgStyleSheet);
     visitor->trace(m_mathmlStyleSheet);
     visitor->trace(m_mediaControlsStyleSheet);
     visitor->trace(m_fullscreenStyleSheet);
 }
 
 } // namespace blink