Improve DEFINE_STATIC_LOCAL()'s handling of Blink GCed objects.

third_party/WebKit/Source/core/fetch/Resource.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
@@ skipping 126 matching lines @@
 CachedMetadata* Resource::CacheHandler::cachedMetadata(unsigned dataTypeID) const
 {
     return m_resource->cachedMetadata(dataTypeID);
 }
 
 String Resource::CacheHandler::encoding() const
 {
     return m_resource->encoding();
 }
 
+class Resource::ResourceCallback final : public GarbageCollectedFinalized<ResourceCallback> {
+public:
+    static ResourceCallback& callbackHandler();
+    DECLARE_TRACE();
+    void schedule(Resource*);
+    void cancel(Resource*);
+    bool isScheduled(Resource*) const;
+private:
+    ResourceCallback();
+
+    void runTask();
+    OwnPtr<CancellableTaskFactory> m_callbackTaskFactory;
+    HeapHashSet<Member<Resource>> m_resourcesWithPendingClients;
+};
+
+Resource::ResourceCallback& Resource::ResourceCallback::callbackHandler()
+{
+    // Oilpan + LSan: as the callbackHandler() singleton is used by Resource
+    // and ResourcePtr finalizers, it cannot be released upon shutdown in
+    // preparation for leak detection.
+    //
+    // Keep it out of LSan's reach instead.
+    LEAK_SANITIZER_DISABLED_SCOPE;
+    DEFINE_STATIC_LOCAL(ResourceCallback, callbackHandler, (new ResourceCallback));
+    return callbackHandler;
+}
+
+DEFINE_TRACE(Resource::ResourceCallback)
+{
+    visitor->trace(m_resourcesWithPendingClients);
+}
+
+Resource::ResourceCallback::ResourceCallback()
+    : m_callbackTaskFactory(CancellableTaskFactory::create(this, &ResourceCallback::runTask))
+{
+}
+
+void Resource::ResourceCallback::schedule(Resource* resource)
+{
+    if (!m_callbackTaskFactory->isPending())
+        Platform::current()->currentThread()->scheduler()->loadingTaskRunner()->postTask(BLINK_FROM_HERE, m_callbackTaskFactory->cancelAndCreate());
+    m_resourcesWithPendingClients.add(resource);
+}
+
+void Resource::ResourceCallback::cancel(Resource* resource)
+{
+    m_resourcesWithPendingClients.remove(resource);
+    if (m_callbackTaskFactory->isPending() && m_resourcesWithPendingClients.isEmpty())
+        m_callbackTaskFactory->cancel();
+}
+
+bool Resource::ResourceCallback::isScheduled(Resource* resource) const
+{
+    return m_resourcesWithPendingClients.contains(resource);
+}
+
+void Resource::ResourceCallback::runTask()
+{
+    HeapVector<Member<Resource>> resources;
+    for (const Member<Resource>& resource : m_resourcesWithPendingClients)
+        resources.append(resource.get());
+    m_resourcesWithPendingClients.clear();
+
+    for (const auto& resource : resources)
+        resource->finishPendingClients();
+}
+
 Resource::Resource(const ResourceRequest& request, Type type, const ResourceLoaderOptions& options)
     : m_resourceRequest(request)
     , m_options(options)
     , m_responseTimestamp(currentTime())
     , m_cancelTimer(this, &Resource::cancelTimerFired)
 #if !ENABLE(OILPAN)
     , m_weakPtrFactory(this)
 #endif
     , m_loadFinishTime(0)
     , m_identifier(0)
@@ skipping 445 matching lines @@
     willAddClientOrObserver();
 
     if (!m_revalidatingRequest.isNull()) {
         m_clients.add(client);
         return;
     }
 
     // If we have existing data to send to the new client and the resource type supprts it, send it asynchronously.
     if (!m_response.isNull() && !shouldSendCachedDataSynchronouslyForType(getType()) && !m_needsSynchronousCacheHit) {
         m_clientsAwaitingCallback.add(client);
-        ResourceCallback::callbackHandler()->schedule(this);
+        ResourceCallback::callbackHandler().schedule(this);
         return;
     }
 
     m_clients.add(client);
     didAddClient(client);
     return;
 }
 
 void Resource::removeClient(ResourceClient* client)
 {
     ASSERT(hasClient(client));
     if (m_finishedClients.contains(client))
         m_finishedClients.remove(client);
     else if (m_clientsAwaitingCallback.contains(client))
         m_clientsAwaitingCallback.remove(client);
     else
         m_clients.remove(client);
 
     if (m_clientsAwaitingCallback.isEmpty())
-        ResourceCallback::callbackHandler()->cancel(this);
+        ResourceCallback::callbackHandler().cancel(this);
 
     didRemoveClientOrObserver();
     // This object may be dead here.
 }
 
 void Resource::didRemoveClientOrObserver()
 {
     if (!hasClientsOrObservers()) {
         RawPtr<Resource> protect(this);
         memoryCache()->makeDead(this);
@@ skipping 77 matching lines @@
     for (const auto& client : clientsToNotify) {
         // Handle case (2) to skip removed clients.
         if (!m_clientsAwaitingCallback.remove(client))
             continue;
         m_clients.add(client);
         didAddClient(client);
     }
 
     // It is still possible for the above loop to finish a new client synchronously.
     // If there's no client waiting we should deschedule.
-    bool scheduled = ResourceCallback::callbackHandler()->isScheduled(this);
+    bool scheduled = ResourceCallback::callbackHandler().isScheduled(this);
     if (scheduled && m_clientsAwaitingCallback.isEmpty())
-        ResourceCallback::callbackHandler()->cancel(this);
+        ResourceCallback::callbackHandler().cancel(this);
 
     // Prevent the case when there are clients waiting but no callback scheduled.
     ASSERT(m_clientsAwaitingCallback.isEmpty() || scheduled);
 }
 
 void Resource::prune()
 {
     destroyDecodedDataIfPossible();
     unlock();
 }
@@ skipping 162 matching lines @@
     return sizeof(Resource) + m_response.memoryUsage() + kAverageClientsHashMapSize + m_resourceRequest.url().getString().length() * 2;
 }
 
 void Resource::didChangePriority(ResourceLoadPriority loadPriority, int intraPriorityValue)
 {
     m_resourceRequest.setPriority(loadPriority, intraPriorityValue);
     if (m_loader)
         m_loader->didChangePriority(loadPriority, intraPriorityValue);
 }
 
-Resource::ResourceCallback* Resource::ResourceCallback::callbackHandler()
-{
-    // Oilpan + LSan: as the callbackHandler() singleton is used by Resource
-    // and ResourcePtr finalizers, it cannot be released upon shutdown in
-    // preparation for leak detection.
-    //
-    // Keep it out of LSan's reach instead.
-    LEAK_SANITIZER_DISABLED_SCOPE;
-    DEFINE_STATIC_LOCAL(Persistent<ResourceCallback>, callbackHandler, (new ResourceCallback));
-    return callbackHandler.get();
-}
-
-DEFINE_TRACE(Resource::ResourceCallback)
-{
-#if ENABLE(OILPAN)
-    visitor->trace(m_resourcesWithPendingClients);
-#endif
-}
-
-Resource::ResourceCallback::ResourceCallback()
-    : m_callbackTaskFactory(CancellableTaskFactory::create(this, &ResourceCallback::runTask))
-{
-}
-
-void Resource::ResourceCallback::schedule(Resource* resource)
-{
-    if (!m_callbackTaskFactory->isPending())
-        Platform::current()->currentThread()->scheduler()->loadingTaskRunner()->postTask(BLINK_FROM_HERE, m_callbackTaskFactory->cancelAndCreate());
-    m_resourcesWithPendingClients.add(resource);
-}
-
-void Resource::ResourceCallback::cancel(Resource* resource)
-{
-    m_resourcesWithPendingClients.remove(resource);
-    if (m_callbackTaskFactory->isPending() && m_resourcesWithPendingClients.isEmpty())
-        m_callbackTaskFactory->cancel();
-}
-
-bool Resource::ResourceCallback::isScheduled(Resource* resource) const
-{
-    return m_resourcesWithPendingClients.contains(resource);
-}
-
-void Resource::ResourceCallback::runTask()
-{
-    HeapVector<Member<Resource>> resources;
-    for (const Member<Resource>& resource : m_resourcesWithPendingClients)
-        resources.append(resource.get());
-    m_resourcesWithPendingClients.clear();
-
-    for (const auto& resource : resources)
-        resource->finishPendingClients();
-}
-
 static const char* initatorTypeNameToString(const AtomicString& initiatorTypeName)
 {
     if (initiatorTypeName == FetchInitiatorTypeNames::css)
         return "CSS resource";
     if (initiatorTypeName == FetchInitiatorTypeNames::document)
         return "Document";
     if (initiatorTypeName == FetchInitiatorTypeNames::icon)
         return "Icon";
     if (initiatorTypeName == FetchInitiatorTypeNames::internal)
         return "Internal resource";
@@ skipping 108 matching lines @@
     case Resource::Media:
         return "Media";
     case Resource::Manifest:
         return "Manifest";
     }
     ASSERT_NOT_REACHED();
     return "Unknown";
 }
 
 } // namespace blink