Oilpan: Remove guardRef and guardDeref from TreeScope.

Source/core/dom/Document.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
@@ skipping 360 matching lines @@
 };
 
 DocumentVisibilityObserver::DocumentVisibilityObserver(Document& document)
     : m_document(0)
 {
     registerObserver(document);
 }
 
 DocumentVisibilityObserver::~DocumentVisibilityObserver()
 {
+#if !ENABLE(OILPAN)
     unregisterObserver();
+#endif
 }
 
 void DocumentVisibilityObserver::unregisterObserver()
 {
     if (m_document) {
         m_document->unregisterVisibilityObserver(this);
         m_document = 0;
     }
 }
 
@@ skipping 123 matching lines @@
     // CSSFontSelector, need to initialize m_styleEngine after initializing
     // m_fetcher.
     m_styleEngine = StyleEngine::create(*this);
 }
 
 Document::~Document()
 {
     ASSERT(!renderView());
     ASSERT(m_ranges.isEmpty());
     ASSERT(!parentTreeScope());
+#if !ENABLE(OILPAN)
     ASSERT(!hasGuardRefCount());
+    // With Oilpan, either the document outlives the visibility observers
+    // or the visibility observers and the document die in the same GC round.
+    // When they die in the same GC round, the list of visibility observers
+    // will not be empty on Document destruction.

[Erik Corry, 2014/04/24 13:53:16]

Is it worth checking that they are all dead at this point?

[Mads Ager (chromium), 2014/04/24 14:12:14]

I don't think so, no.

     ASSERT(m_visibilityObservers.isEmpty());
+#endif
 
     if (m_templateDocument)
         m_templateDocument->m_templateDocumentHost = 0; // balanced in ensureTemplateDocument().
 
     m_scriptRunner.clear();
 
     removeAllEventListenersRecursively();
 
     // Currently we believe that Document can never outlive the parser.
     // Although the Document may be replaced synchronously, DocumentParsers
     // generally keep at least one reference to an Element which would in turn
     // has a reference to the Document.  If you hit this ASSERT, then that
     // assumption is wrong.  DocumentParser::detach() should ensure that even
     // if the DocumentParser outlives the Document it won't cause badness.
     ASSERT(!m_parser || m_parser->refCount() == 1);
     detachParser();
 
     if (this == topDocument())
         clearAXObjectCache();
 
+#if !ENABLE(OILPAN)
     if (m_styleSheetList)
         m_styleSheetList->detachFromDocument();
+#endif
 
     if (m_importsController) {
         m_importsController->wasDetachedFrom(*this);
         m_importsController = 0;
     }
 
     m_timeline->detachFromDocument();
     m_transitionTimeline->detachFromDocument();
 
     // We need to destroy CSSFontSelector before destroying m_fetcher.
@@ skipping 869 matching lines @@
     return pageVisibilityState() != PageVisibilityStateVisible;
 }
 
 void Document::didChangeVisibilityState()
 {
     dispatchEvent(Event::create(EventTypeNames::visibilitychange));
     // Also send out the deprecated version until it can be removed.
     dispatchEvent(Event::create(EventTypeNames::webkitvisibilitychange));
 
     PageVisibilityState state = pageVisibilityState();
-    HashSet<DocumentVisibilityObserver*>::const_iterator observerEnd = m_visibilityObservers.end();
-    for (HashSet<DocumentVisibilityObserver*>::const_iterator it = m_visibilityObservers.begin(); it != observerEnd; ++it)
+    WillBeHeapHashSet<RawPtrWillBeWeakMember<DocumentVisibilityObserver> >::const_iterator observerEnd = m_visibilityObservers.end();

[Erik Corry, 2014/04/24 13:53:16]

I think a typedef would be good here.

[Mads Ager (chromium), 2014/04/24 14:12:14]

Done.

+    for (WillBeHeapHashSet<RawPtrWillBeWeakMember<DocumentVisibilityObserver> >::const_iterator it = m_visibilityObservers.begin(); it != observerEnd; ++it)
         (*it)->didChangeVisibilityState(state);
 }
 
 void Document::registerVisibilityObserver(DocumentVisibilityObserver* observer)
 {
     ASSERT(!m_visibilityObservers.contains(observer));
     m_visibilityObservers.add(observer);
 }
 
 void Document::unregisterVisibilityObserver(DocumentVisibilityObserver* observer)
@@ skipping 3382 matching lines @@
     m_ranges.add(range);
 }
 
 void Document::detachRange(Range* range)
 {
     // We don't ASSERT m_ranges.contains(range) to allow us to call this
     // unconditionally to fix: https://bugs.webkit.org/show_bug.cgi?id=26044
     m_ranges.remove(range);
 }
 
-void Document::getCSSCanvasContext(const String& type, const String& name, int width, int height, bool& is2d, RefPtr<CanvasRenderingContext2D>& context2d, bool& is3d, RefPtr<WebGLRenderingContext>& context3d)
+void Document::getCSSCanvasContext(const String& type, const String& name, int width, int height, bool& is2d, RefPtrWillBeRawPtr<CanvasRenderingContext2D>& context2d, bool& is3d, RefPtrWillBeRawPtr<WebGLRenderingContext>& context3d)
 {
     HTMLCanvasElement& element = getCSSCanvasElement(name);
     element.setSize(IntSize(width, height));
     CanvasRenderingContext* context = element.getContext(type);
     if (!context)
         return;
 
     if (context->is2d()) {
         is2d = true;
         context2d = toCanvasRenderingContext2D(context);
@@ skipping 182 matching lines @@
             return element;
     }
     return 0;
 }
 
 void Document::decrementLoadEventDelayCount()
 {
     ASSERT(m_loadEventDelayCount);
     --m_loadEventDelayCount;
 
-    if (frame() && !m_loadEventDelayCount && !m_loadEventDelayTimer.isActive())
+    if (!m_loadEventDelayCount)

[Erik Corry, 2014/04/24 13:53:16]

Style guide was just revised so you can write == 0 instead of using ! here.

[Mads Ager (chromium), 2014/04/24 14:12:14]

OK, not going to bother with that right now. The rest of the code in this file
uses the other style.

+        checkLoadEventSoon();
+}
+
+void Document::checkLoadEventSoon()
+{
+    if (frame() && !m_loadEventDelayTimer.isActive())
         m_loadEventDelayTimer.startOneShot(0, FROM_HERE);
 }
 
+bool Document::isDelayingLoadEvent()
+{
+#if ENABLE(OILPAN)
+    // With Oilpan, always delay load events until after garbage collection.

[Erik Corry, 2014/04/24 13:53:16]

The "With Oilpan" part of the comment is obsolete when we remove the ifdefs, and
right now it is superfluous due to its proximity to the ifdef, so I suggest it
be removed.

[Mads Ager (chromium), 2014/04/24 14:12:14]

Yes, true. Done.

+    // This way we don't have to explicitly delay load events via
+    // incrementLoadEventDelayCount and decrementLoadEventDelayCount in
+    // Node destructors.
+    if (!m_loadEventDelayCount && ThreadState::current()->isSweepInProgress()) {
+        checkLoadEventSoon();

[Erik Corry, 2014/04/24 13:53:16]

Just because we asked whether load events are being delayed we have to check for
load events?  Seems like you should only call this if a sweep is in progress, or
perhaps we could call it once in the GC epilogue?

[Mads Ager (chromium), 2014/04/24 14:12:14]

Good point. Done. If we are sweeping, we check for load events soon if we are
not otherwise delaying load events.

+        return true;
+    }
+#endif
+    return m_loadEventDelayCount;

[Erik Corry, 2014/04/24 13:53:16]

!= 0

[Mads Ager (chromium), 2014/04/24 14:12:14]

Nah, not in this change. The rest of this code uses the old style and I'm not
going to start changing the style of one method here.

+}
+
+
 void Document::loadEventDelayTimerFired(Timer<Document>*)
 {
     if (frame())
         frame()->loader().checkCompleted();
 }
 
 void Document::loadPluginsSoon()
 {
     // FIXME: Remove this timer once we don't need to compute layout to load plugins.
     if (!m_pluginLoadingTimer.isActive())
@@ skipping 533 matching lines @@
     return false;
 }
 
 void Document::invalidateNodeListCaches(const QualifiedName* attrName)
 {
     HashSet<LiveNodeListBase*>::iterator end = m_listsInvalidatedAtDocument.end();
     for (HashSet<LiveNodeListBase*>::iterator it = m_listsInvalidatedAtDocument.begin(); it != end; ++it)
         (*it)->invalidateCacheForAttribute(attrName);
 }
 
+void Document::clearWeakMembers(Visitor* visitor)
+{
+    if (m_axObjectCache)
+        m_axObjectCache->clearWeakMembers(visitor);
+
+    if (m_markers)
+        m_markers->clearWeakMembers(visitor);
+
+    // FIXME: Oilpan: Use a weak counted set instead.
+    if (m_touchEventTargets) {
+        Vector<Node*> deadNodes;
+        for (TouchEventTargetSet::iterator it = m_touchEventTargets->begin(); it != m_touchEventTargets->end(); ++it) {
+            if (!visitor->isAlive(it->key))
+                deadNodes.append(it->key);
+        }
+        for (unsigned i = 0; i < deadNodes.size(); ++i)
+            didClearTouchEventHandlers(deadNodes[i]);
+    }
+}
+
 void Document::trace(Visitor* visitor)
 {
+    visitor->trace(m_styleSheetList);
+    visitor->trace(m_visibilityObservers);
+    visitor->registerWeakMembers<Document, &Document::clearWeakMembers>(this);
     Supplementable<Document>::trace(visitor);
+    TreeScope::trace(visitor);
     ContainerNode::trace(visitor);
 }
 
 } // namespace WebCore