Title: [203064] trunk/Source
Revision
203064
Author
[email protected]
Date
2016-07-11 09:01:04 -0700 (Mon, 11 Jul 2016)

Log Message

Use refs for ResourceLoaders
https://bugs.webkit.org/show_bug.cgi?id=159592

Reviewed by Chris Dumez.

Source/WebCore:

No new tests.  No change in behavior except a fixed memory leak in WebKit1.

* loader/LoaderStrategy.h:
* loader/ResourceLoader.cpp:
(WebCore::ResourceLoader::finishNetworkLoad):
(WebCore::ResourceLoader::setDefersLoading):
(WebCore::ResourceLoader::frameLoader):
(WebCore::ResourceLoader::willSwitchToSubstituteResource):
(WebCore::ResourceLoader::willSendRequestInternal):

Source/WebKit:

* WebCoreSupport/WebResourceLoadScheduler.cpp:
(webResourceLoadScheduler):
(WebResourceLoadScheduler::hostForURL):
(WebResourceLoadScheduler::WebResourceLoadScheduler):
(WebResourceLoadScheduler::loadResource):
(WebResourceLoadScheduler::schedulePluginStreamLoad):
(WebResourceLoadScheduler::scheduleLoad):
(WebResourceLoadScheduler::remove):
(WebResourceLoadScheduler::setDefersLoading):
(WebResourceLoadScheduler::crossOriginRedirectReceived):
(WebResourceLoadScheduler::servePendingRequests):
(WebResourceLoadScheduler::resumePendingRequests):
(WebResourceLoadScheduler::HostInformation::priorityToIndex):
(WebResourceLoadScheduler::HostInformation::schedule):
(WebResourceLoadScheduler::HostInformation::addLoadInProgress):
(WebResourceLoadScheduler::HostInformation::remove):
* WebCoreSupport/WebResourceLoadScheduler.h:
(WebResourceLoadScheduler::HostInformation::name):
(WebResourceLoadScheduler::HostInformation::requestsPending):
m_nonHTTPProtocolHost used to be a leaked pointer, and now it's a member variable.

Source/WebKit2:

* WebProcess/Network/WebLoaderStrategy.cpp:
(WebKit::WebLoaderStrategy::scheduleInternallyFailedLoad):
(WebKit::WebLoaderStrategy::internallyFailedLoadTimerFired):
(WebKit::WebLoaderStrategy::startLocalLoad):
(WebKit::WebLoaderStrategy::remove):
(WebKit::WebLoaderStrategy::setDefersLoading):
(WebKit::WebLoaderStrategy::crossOriginRedirectReceived):
* WebProcess/Network/WebLoaderStrategy.h:

Modified Paths

Diff

Modified: trunk/Source/WebCore/ChangeLog (203063 => 203064)


--- trunk/Source/WebCore/ChangeLog	2016-07-11 15:55:57 UTC (rev 203063)
+++ trunk/Source/WebCore/ChangeLog	2016-07-11 16:01:04 UTC (rev 203064)
@@ -1,3 +1,20 @@
+2016-07-08  Alex Christensen  <[email protected]>
+
+        Use refs for ResourceLoaders
+        https://bugs.webkit.org/show_bug.cgi?id=159592
+
+        Reviewed by Chris Dumez.
+
+        No new tests.  No change in behavior except a fixed memory leak in WebKit1.
+
+        * loader/LoaderStrategy.h:
+        * loader/ResourceLoader.cpp:
+        (WebCore::ResourceLoader::finishNetworkLoad):
+        (WebCore::ResourceLoader::setDefersLoading):
+        (WebCore::ResourceLoader::frameLoader):
+        (WebCore::ResourceLoader::willSwitchToSubstituteResource):
+        (WebCore::ResourceLoader::willSendRequestInternal):
+
 2016-07-11  Fujii Hironori  <[email protected]>
 
         Using dpi unit in sizes attribute raises SIGSEGV

Modified: trunk/Source/WebCore/loader/LoaderStrategy.h (203063 => 203064)


--- trunk/Source/WebCore/loader/LoaderStrategy.h	2016-07-11 15:55:57 UTC (rev 203063)
+++ trunk/Source/WebCore/loader/LoaderStrategy.h	2016-07-11 16:01:04 UTC (rev 203064)
@@ -51,9 +51,9 @@
     virtual RefPtr<SubresourceLoader> loadResource(Frame&, CachedResource&, const ResourceRequest&, const ResourceLoaderOptions&) = 0;
     virtual void loadResourceSynchronously(NetworkingContext*, unsigned long identifier, const ResourceRequest&, StoredCredentials, ClientCredentialPolicy, ResourceError&, ResourceResponse&, Vector<char>& data) = 0;
 
-    virtual void remove(ResourceLoader*) = 0;
-    virtual void setDefersLoading(ResourceLoader*, bool) = 0;
-    virtual void crossOriginRedirectReceived(ResourceLoader*, const URL& redirectURL) = 0;
+    virtual void remove(ResourceLoader&) = 0;
+    virtual void setDefersLoading(ResourceLoader&, bool) = 0;
+    virtual void crossOriginRedirectReceived(ResourceLoader&, const URL& redirectURL) = 0;
 
     virtual void servePendingRequests(ResourceLoadPriority minimumPriority = ResourceLoadPriority::VeryLow) = 0;
     virtual void suspendPendingRequests() = 0;

Modified: trunk/Source/WebCore/loader/ResourceLoader.cpp (203063 => 203064)


--- trunk/Source/WebCore/loader/ResourceLoader.cpp	2016-07-11 15:55:57 UTC (rev 203063)
+++ trunk/Source/WebCore/loader/ResourceLoader.cpp	2016-07-11 16:01:04 UTC (rev 203064)
@@ -73,7 +73,7 @@
 
 void ResourceLoader::finishNetworkLoad()
 {
-    platformStrategies()->loaderStrategy()->remove(this);
+    platformStrategies()->loaderStrategy()->remove(*this);
 
     if (m_handle) {
         ASSERT(m_handle->client() == this);
@@ -223,7 +223,7 @@
         start();
     }
 
-    platformStrategies()->loaderStrategy()->setDefersLoading(this, defers);
+    platformStrategies()->loaderStrategy()->setDefersLoading(*this, defers);
 }
 
 FrameLoader* ResourceLoader::frameLoader() const
@@ -279,7 +279,7 @@
 void ResourceLoader::willSwitchToSubstituteResource()
 {
     ASSERT(!m_documentLoader->isSubstituteLoadPending(this));
-    platformStrategies()->loaderStrategy()->remove(this);
+    platformStrategies()->loaderStrategy()->remove(*this);
     if (m_handle)
         m_handle->cancel();
 }
@@ -367,7 +367,7 @@
 
     bool isRedirect = !redirectResponse.isNull();
     if (isRedirect)
-        platformStrategies()->loaderStrategy()->crossOriginRedirectReceived(this, request.url());
+        platformStrategies()->loaderStrategy()->crossOriginRedirectReceived(*this, request.url());
 
     m_request = request;
 

Modified: trunk/Source/WebKit/ChangeLog (203063 => 203064)


--- trunk/Source/WebKit/ChangeLog	2016-07-11 15:55:57 UTC (rev 203063)
+++ trunk/Source/WebKit/ChangeLog	2016-07-11 16:01:04 UTC (rev 203064)
@@ -1,3 +1,31 @@
+2016-07-08  Alex Christensen  <[email protected]>
+
+        Use refs for ResourceLoaders
+        https://bugs.webkit.org/show_bug.cgi?id=159592
+
+        Reviewed by Chris Dumez.
+
+        * WebCoreSupport/WebResourceLoadScheduler.cpp:
+        (webResourceLoadScheduler):
+        (WebResourceLoadScheduler::hostForURL):
+        (WebResourceLoadScheduler::WebResourceLoadScheduler):
+        (WebResourceLoadScheduler::loadResource):
+        (WebResourceLoadScheduler::schedulePluginStreamLoad):
+        (WebResourceLoadScheduler::scheduleLoad):
+        (WebResourceLoadScheduler::remove):
+        (WebResourceLoadScheduler::setDefersLoading):
+        (WebResourceLoadScheduler::crossOriginRedirectReceived):
+        (WebResourceLoadScheduler::servePendingRequests):
+        (WebResourceLoadScheduler::resumePendingRequests):
+        (WebResourceLoadScheduler::HostInformation::priorityToIndex):
+        (WebResourceLoadScheduler::HostInformation::schedule):
+        (WebResourceLoadScheduler::HostInformation::addLoadInProgress):
+        (WebResourceLoadScheduler::HostInformation::remove):
+        * WebCoreSupport/WebResourceLoadScheduler.h:
+        (WebResourceLoadScheduler::HostInformation::name):
+        (WebResourceLoadScheduler::HostInformation::requestsPending):
+        m_nonHTTPProtocolHost used to be a leaked pointer, and now it's a member variable.
+
 2016-07-08  Commit Queue  <[email protected]>
 
         Unreviewed, rolling out r202799.

Modified: trunk/Source/WebKit/WebCoreSupport/WebResourceLoadScheduler.cpp (203063 => 203064)


--- trunk/Source/WebKit/WebCoreSupport/WebResourceLoadScheduler.cpp	2016-07-11 15:55:57 UTC (rev 203063)
+++ trunk/Source/WebKit/WebCoreSupport/WebResourceLoadScheduler.cpp	2016-07-11 16:01:04 UTC (rev 203064)
@@ -67,20 +67,21 @@
 WebResourceLoadScheduler::HostInformation* WebResourceLoadScheduler::hostForURL(const URL& url, CreateHostPolicy createHostPolicy)
 {
     if (!url.protocolIsInHTTPFamily())
-        return m_nonHTTPProtocolHost;
+        return &m_nonHTTPProtocolHost;
 
     m_hosts.checkConsistency();
     String hostName = url.host();
     HostInformation* host = m_hosts.get(hostName);
     if (!host && createHostPolicy == CreateIfNotFound) {
-        host = new HostInformation(hostName, maxRequestsInFlightPerHost);
-        m_hosts.add(hostName, host);
+        auto newHost = std::make_unique<HostInformation>(hostName, maxRequestsInFlightPerHost);
+        host = newHost.get();
+        m_hosts.add(hostName, WTFMove(newHost));
     }
     return host;
 }
 
 WebResourceLoadScheduler::WebResourceLoadScheduler()
-    : m_nonHTTPProtocolHost(new HostInformation(String(), maxRequestsInFlightForNonHTTPProtocols))
+    : m_nonHTTPProtocolHost(String(), maxRequestsInFlightForNonHTTPProtocols)
     , m_requestTimer(*this, &WebResourceLoadScheduler::requestTimerFired)
     , m_suspendPendingRequestsCount(0)
     , m_isSerialLoadingEnabled(false)
@@ -96,7 +97,7 @@
 {
     RefPtr<SubresourceLoader> loader = SubresourceLoader::create(frame, resource, request, options);
     if (loader)
-        scheduleLoad(loader.get());
+        scheduleLoad(*loader);
 #if PLATFORM(IOS)
     // Since we defer loader initialization until scheduling on iOS, the frame
     // load delegate that would be called in SubresourceLoader::create() on
@@ -118,36 +119,35 @@
 {
     RefPtr<NetscapePlugInStreamLoader> loader = NetscapePlugInStreamLoader::create(frame, client, request);
     if (loader)
-        scheduleLoad(loader.get());
+        scheduleLoad(*loader);
     return loader;
 }
 
-void WebResourceLoadScheduler::scheduleLoad(ResourceLoader* resourceLoader)
+void WebResourceLoadScheduler::scheduleLoad(ResourceLoader& resourceLoader)
 {
-    ASSERT(resourceLoader);
+    LOG(ResourceLoading, "WebResourceLoadScheduler::load resource %p '%s'", &resourceLoader, resourceLoader.url().string().latin1().data());
 
-    LOG(ResourceLoading, "WebResourceLoadScheduler::load resource %p '%s'", resourceLoader, resourceLoader->url().string().latin1().data());
-
 #if PLATFORM(IOS)
     // If there's a web archive resource for this URL, we don't need to schedule the load since it will never touch the network.
-    if (!isSuspendingPendingRequests() && resourceLoader->documentLoader()->archiveResourceForURL(resourceLoader->iOSOriginalRequest().url())) {
-        resourceLoader->startLoading();
+    if (!isSuspendingPendingRequests() && resourceLoader.documentLoader()->archiveResourceForURL(resourceLoader.iOSOriginalRequest().url())) {
+        resourceLoader.startLoading();
         return;
     }
 #else
-    if (resourceLoader->documentLoader()->archiveResourceForURL(resourceLoader->request().url())) {
-        resourceLoader->start();
+    if (resourceLoader.documentLoader()->archiveResourceForURL(resourceLoader.request().url())) {
+        resourceLoader.start();
         return;
     }
 #endif
 
 #if PLATFORM(IOS)
-    HostInformation* host = hostForURL(resourceLoader->iOSOriginalRequest().url(), CreateIfNotFound);
+    HostInformation* host = hostForURL(resourceLoader.iOSOriginalRequest().url(), CreateIfNotFound);
 #else
-    HostInformation* host = hostForURL(resourceLoader->url(), CreateIfNotFound);
+    HostInformation* host = hostForURL(resourceLoader.url(), CreateIfNotFound);
 #endif
+    ASSERT(host);
 
-    ResourceLoadPriority priority = resourceLoader->request().priority();
+    ResourceLoadPriority priority = resourceLoader.request().priority();
 
     bool hadRequests = host->hasRequests();
     host->schedule(resourceLoader, priority);
@@ -156,21 +156,21 @@
     if (ResourceRequest::resourcePrioritiesEnabled() && !isSuspendingPendingRequests()) {
         // Serve all requests at once to keep the pipeline full at the network layer.
         // FIXME: Does this code do anything useful, given that we also set maxRequestsInFlightPerHost to effectively unlimited on these platforms?
-        servePendingRequests(host, ResourceLoadPriority::VeryLow);
+        servePendingRequests(*host, ResourceLoadPriority::VeryLow);
         return;
     }
 #endif
 
 #if PLATFORM(IOS)
-    if ((priority > ResourceLoadPriority::Low || !resourceLoader->iOSOriginalRequest().url().protocolIsInHTTPFamily() || (priority == ResourceLoadPriority::Low && !hadRequests)) && !isSuspendingPendingRequests()) {
+    if ((priority > ResourceLoadPriority::Low || !resourceLoader.iOSOriginalRequest().url().protocolIsInHTTPFamily() || (priority == ResourceLoadPriority::Low && !hadRequests)) && !isSuspendingPendingRequests()) {
         // Try to request important resources immediately.
-        servePendingRequests(host, priority);
+        servePendingRequests(*host, priority);
         return;
     }
 #else
-    if (priority > ResourceLoadPriority::Low || !resourceLoader->url().protocolIsInHTTPFamily() || (priority == ResourceLoadPriority::Low && !hadRequests)) {
+    if (priority > ResourceLoadPriority::Low || !resourceLoader.url().protocolIsInHTTPFamily() || (priority == ResourceLoadPriority::Low && !hadRequests)) {
         // Try to request important resources immediately.
-        servePendingRequests(host, priority);
+        servePendingRequests(*host, priority);
         return;
     }
 #endif
@@ -180,18 +180,16 @@
     scheduleServePendingRequests();
 }
 
-void WebResourceLoadScheduler::remove(ResourceLoader* resourceLoader)
+void WebResourceLoadScheduler::remove(ResourceLoader& resourceLoader)
 {
-    ASSERT(resourceLoader);
-
-    HostInformation* host = hostForURL(resourceLoader->url());
+    HostInformation* host = hostForURL(resourceLoader.url());
     if (host)
         host->remove(resourceLoader);
 #if PLATFORM(IOS)
     // ResourceLoader::url() doesn't start returning the correct value until the load starts. If we get canceled before that, we need to look for originalRequest url instead.
     // FIXME: ResourceLoader::url() should be made to return a sensible value at all times.
-    if (!resourceLoader->iOSOriginalRequest().isNull()) {
-        HostInformation* originalHost = hostForURL(resourceLoader->iOSOriginalRequest().url());
+    if (!resourceLoader.iOSOriginalRequest().isNull()) {
+        HostInformation* originalHost = hostForURL(resourceLoader.iOSOriginalRequest().url());
         if (originalHost && originalHost != host)
             originalHost->remove(resourceLoader);
     }
@@ -199,18 +197,19 @@
     scheduleServePendingRequests();
 }
 
-void WebResourceLoadScheduler::setDefersLoading(ResourceLoader*, bool)
+void WebResourceLoadScheduler::setDefersLoading(ResourceLoader&, bool)
 {
 }
 
-void WebResourceLoadScheduler::crossOriginRedirectReceived(ResourceLoader* resourceLoader, const URL& redirectURL)
+void WebResourceLoadScheduler::crossOriginRedirectReceived(ResourceLoader& resourceLoader, const URL& redirectURL)
 {
-    HostInformation* oldHost = hostForURL(resourceLoader->url());
+    HostInformation* oldHost = hostForURL(resourceLoader.url());
     ASSERT(oldHost);
     if (!oldHost)
         return;
 
     HostInformation* newHost = hostForURL(redirectURL, CreateIfNotFound);
+    ASSERT(newHost);
 
     if (oldHost->name() == newHost->name())
         return;
@@ -230,36 +229,38 @@
     servePendingRequests(m_nonHTTPProtocolHost, minimumPriority);
 
     Vector<HostInformation*> hostsToServe;
-    copyValuesToVector(m_hosts, hostsToServe);
+    hostsToServe.reserveInitialCapacity(m_hosts.size());
+    for (const auto& host : m_hosts.values())
+        hostsToServe.uncheckedAppend(host.get());
 
     for (auto* host : hostsToServe) {
         if (host->hasRequests())
-            servePendingRequests(host, minimumPriority);
+            servePendingRequests(*host, minimumPriority);
         else
-            delete m_hosts.take(host->name());
+            m_hosts.remove(host->name());
     }
 }
 
-void WebResourceLoadScheduler::servePendingRequests(HostInformation* host, ResourceLoadPriority minimumPriority)
+void WebResourceLoadScheduler::servePendingRequests(HostInformation& host, ResourceLoadPriority minimumPriority)
 {
-    LOG(ResourceLoading, "WebResourceLoadScheduler::servePendingRequests HostInformation.m_name='%s'", host->name().latin1().data());
+    LOG(ResourceLoading, "WebResourceLoadScheduler::servePendingRequests HostInformation.m_name='%s'", host.name().latin1().data());
 
     auto priority = ResourceLoadPriority::Highest;
     while (true) {
-        auto& requestsPending = host->requestsPending(priority);
+        auto& requestsPending = host.requestsPending(priority);
         while (!requestsPending.isEmpty()) {
-            RefPtr<ResourceLoader> resourceLoader = requestsPending.first();
+            Ref<ResourceLoader> resourceLoader = requestsPending.first().copyRef();
 
             // For named hosts - which are only http(s) hosts - we should always enforce the connection limit.
             // For non-named hosts - everything but http(s) - we should only enforce the limit if the document isn't done parsing 
             // and we don't know all stylesheets yet.
             Document* document = resourceLoader->frameLoader() ? resourceLoader->frameLoader()->frame().document() : 0;
-            bool shouldLimitRequests = !host->name().isNull() || (document && (document->parsing() || !document->haveStylesheetsLoaded()));
-            if (shouldLimitRequests && host->limitRequests(priority))
+            bool shouldLimitRequests = !host.name().isNull() || (document && (document->parsing() || !document->haveStylesheetsLoaded()));
+            if (shouldLimitRequests && host.limitRequests(priority))
                 return;
 
             requestsPending.removeFirst();
-            host->addLoadInProgress(resourceLoader.get());
+            host.addLoadInProgress(resourceLoader.get());
 #if PLATFORM(IOS)
             if (!IOSApplication::isWebProcess()) {
                 resourceLoader->startLoading();
@@ -285,7 +286,7 @@
     --m_suspendPendingRequestsCount;
     if (m_suspendPendingRequestsCount)
         return;
-    if (!m_hosts.isEmpty() || m_nonHTTPProtocolHost->hasRequests())
+    if (!m_hosts.isEmpty() || m_nonHTTPProtocolHost.hasRequests())
         scheduleServePendingRequests();
 }
     
@@ -331,18 +332,18 @@
     return 0;
 }
 
-void WebResourceLoadScheduler::HostInformation::schedule(ResourceLoader* resourceLoader, ResourceLoadPriority priority)
+void WebResourceLoadScheduler::HostInformation::schedule(ResourceLoader& resourceLoader, ResourceLoadPriority priority)
 {
     m_requestsPending[priorityToIndex(priority)].append(resourceLoader);
 }
     
-void WebResourceLoadScheduler::HostInformation::addLoadInProgress(ResourceLoader* resourceLoader)
+void WebResourceLoadScheduler::HostInformation::addLoadInProgress(ResourceLoader& resourceLoader)
 {
-    LOG(ResourceLoading, "HostInformation '%s' loading '%s'. Current count %d", m_name.latin1().data(), resourceLoader->url().string().latin1().data(), m_requestsLoading.size());
+    LOG(ResourceLoading, "HostInformation '%s' loading '%s'. Current count %d", m_name.latin1().data(), resourceLoader.url().string().latin1().data(), m_requestsLoading.size());
     m_requestsLoading.add(resourceLoader);
 }
     
-void WebResourceLoadScheduler::HostInformation::remove(ResourceLoader* resourceLoader)
+void WebResourceLoadScheduler::HostInformation::remove(ResourceLoader& resourceLoader)
 {
     if (m_requestsLoading.remove(resourceLoader))
         return;
@@ -349,7 +350,7 @@
     
     for (auto& requestQueue : m_requestsPending) {
         for (auto it = requestQueue.begin(), end = requestQueue.end(); it != end; ++it) {
-            if (*it == resourceLoader) {
+            if (it->ptr() == &resourceLoader) {
                 requestQueue.remove(it);
                 return;
             }

Modified: trunk/Source/WebKit/WebCoreSupport/WebResourceLoadScheduler.h (203063 => 203064)


--- trunk/Source/WebKit/WebCoreSupport/WebResourceLoadScheduler.h	2016-07-11 15:55:57 UTC (rev 203063)
+++ trunk/Source/WebKit/WebCoreSupport/WebResourceLoadScheduler.h	2016-07-11 16:01:04 UTC (rev 203064)
@@ -20,8 +20,7 @@
     Boston, MA 02110-1301, USA.
  */
 
-#ifndef WebResourceLoadScheduler_h
-#define WebResourceLoadScheduler_h
+#pragma once
 
 #include <WebCore/FrameLoaderTypes.h>
 #include <WebCore/LoaderStrategy.h>
@@ -47,9 +46,9 @@
 
     RefPtr<WebCore::SubresourceLoader> loadResource(WebCore::Frame&, WebCore::CachedResource&, const WebCore::ResourceRequest&, const WebCore::ResourceLoaderOptions&) override;
     void loadResourceSynchronously(WebCore::NetworkingContext*, unsigned long, const WebCore::ResourceRequest&, WebCore::StoredCredentials, WebCore::ClientCredentialPolicy, WebCore::ResourceError&, WebCore::ResourceResponse&, Vector<char>&) override;
-    void remove(WebCore::ResourceLoader*) override;
-    void setDefersLoading(WebCore::ResourceLoader*, bool) override;
-    void crossOriginRedirectReceived(WebCore::ResourceLoader*, const WebCore::URL& redirectURL) override;
+    void remove(WebCore::ResourceLoader&) override;
+    void setDefersLoading(WebCore::ResourceLoader&, bool) override;
+    void crossOriginRedirectReceived(WebCore::ResourceLoader&, const WebCore::URL& redirectURL) override;
     
     void servePendingRequests(WebCore::ResourceLoadPriority minimumPriority = WebCore::ResourceLoadPriority::VeryLow) override;
     void suspendPendingRequests() override;
@@ -66,7 +65,7 @@
     virtual ~WebResourceLoadScheduler();
 
 private:
-    void scheduleLoad(WebCore::ResourceLoader*);
+    void scheduleLoad(WebCore::ResourceLoader&);
     void scheduleServePendingRequests();
     void requestTimerFired();
 
@@ -79,13 +78,13 @@
         ~HostInformation();
         
         const String& name() const { return m_name; }
-        void schedule(WebCore::ResourceLoader*, WebCore::ResourceLoadPriority = WebCore::ResourceLoadPriority::VeryLow);
-        void addLoadInProgress(WebCore::ResourceLoader*);
-        void remove(WebCore::ResourceLoader*);
+        void schedule(WebCore::ResourceLoader&, WebCore::ResourceLoadPriority = WebCore::ResourceLoadPriority::VeryLow);
+        void addLoadInProgress(WebCore::ResourceLoader&);
+        void remove(WebCore::ResourceLoader&);
         bool hasRequests() const;
         bool limitRequests(WebCore::ResourceLoadPriority) const;
 
-        typedef Deque<RefPtr<WebCore::ResourceLoader>> RequestQueue;
+        typedef Deque<Ref<WebCore::ResourceLoader>> RequestQueue;
         RequestQueue& requestsPending(WebCore::ResourceLoadPriority priority) { return m_requestsPending[priorityToIndex(priority)]; }
 
     private:
@@ -92,7 +91,7 @@
         static unsigned priorityToIndex(WebCore::ResourceLoadPriority);
 
         std::array<RequestQueue, WebCore::resourceLoadPriorityCount> m_requestsPending;
-        typedef HashSet<RefPtr<WebCore::ResourceLoader>> RequestMap;
+        typedef HashSet<Ref<WebCore::ResourceLoader>> RequestMap;
         RequestMap m_requestsLoading;
         const String m_name;
         const unsigned m_maxRequestsInFlight;
@@ -104,11 +103,10 @@
     };
     
     HostInformation* hostForURL(const WebCore::URL&, CreateHostPolicy = FindOnly);
-    WEBCORE_EXPORT void servePendingRequests(HostInformation*, WebCore::ResourceLoadPriority);
+    void servePendingRequests(HostInformation&, WebCore::ResourceLoadPriority);
 
-    typedef HashMap<String, HostInformation*, StringHash> HostMap;
-    HostMap m_hosts;
-    HostInformation* m_nonHTTPProtocolHost;
+    HashMap<String, std::unique_ptr<HostInformation>> m_hosts;
+    HostInformation m_nonHTTPProtocolHost;
         
     WebCore::Timer m_requestTimer;
 
@@ -115,5 +113,3 @@
     unsigned m_suspendPendingRequestsCount;
     bool m_isSerialLoadingEnabled;
 };
-
-#endif

Modified: trunk/Source/WebKit2/ChangeLog (203063 => 203064)


--- trunk/Source/WebKit2/ChangeLog	2016-07-11 15:55:57 UTC (rev 203063)
+++ trunk/Source/WebKit2/ChangeLog	2016-07-11 16:01:04 UTC (rev 203064)
@@ -1,3 +1,19 @@
+2016-07-08  Alex Christensen  <[email protected]>
+
+        Use refs for ResourceLoaders
+        https://bugs.webkit.org/show_bug.cgi?id=159592
+
+        Reviewed by Chris Dumez.
+
+        * WebProcess/Network/WebLoaderStrategy.cpp:
+        (WebKit::WebLoaderStrategy::scheduleInternallyFailedLoad):
+        (WebKit::WebLoaderStrategy::internallyFailedLoadTimerFired):
+        (WebKit::WebLoaderStrategy::startLocalLoad):
+        (WebKit::WebLoaderStrategy::remove):
+        (WebKit::WebLoaderStrategy::setDefersLoading):
+        (WebKit::WebLoaderStrategy::crossOriginRedirectReceived):
+        * WebProcess/Network/WebLoaderStrategy.h:
+
 2016-07-11  Antti Koivisto  <[email protected]>
 
         Update stable cache version in NetworkCache::Storage::deleteOldVersions()

Modified: trunk/Source/WebKit2/WebProcess/Network/WebLoaderStrategy.cpp (203063 => 203064)


--- trunk/Source/WebKit2/WebProcess/Network/WebLoaderStrategy.cpp	2016-07-11 15:55:57 UTC (rev 203063)
+++ trunk/Source/WebKit2/WebProcess/Network/WebLoaderStrategy.cpp	2016-07-11 16:01:04 UTC (rev 203064)
@@ -217,17 +217,19 @@
 
 void WebLoaderStrategy::scheduleInternallyFailedLoad(WebCore::ResourceLoader& resourceLoader)
 {
-    m_internallyFailedResourceLoaders.add(&resourceLoader);
+    m_internallyFailedResourceLoaders.add(resourceLoader);
     m_internallyFailedLoadTimer.startOneShot(0);
 }
 
 void WebLoaderStrategy::internallyFailedLoadTimerFired()
 {
-    Vector<RefPtr<ResourceLoader>> internallyFailedResourceLoaders;
-    copyToVector(m_internallyFailedResourceLoaders, internallyFailedResourceLoaders);
+    Vector<Ref<ResourceLoader>> internallyFailedResourceLoaders;
+    internallyFailedResourceLoaders.reserveInitialCapacity(m_internallyFailedResourceLoaders.size());
+    for (auto& loader : m_internallyFailedResourceLoaders)
+        internallyFailedResourceLoaders.uncheckedAppend(loader.copyRef());
     
-    for (size_t i = 0; i < internallyFailedResourceLoaders.size(); ++i)
-        internallyFailedResourceLoaders[i]->didFail(internalError(internallyFailedResourceLoaders[i]->url()));
+    for (auto& loader : internallyFailedResourceLoaders)
+        loader->didFail(internalError(loader->url()));
 }
 
 void WebLoaderStrategy::startLocalLoad(WebCore::ResourceLoader& resourceLoader)
@@ -236,10 +238,9 @@
     m_webResourceLoaders.set(resourceLoader.identifier(), WebResourceLoader::create(resourceLoader));
 }
 
-void WebLoaderStrategy::remove(ResourceLoader* resourceLoader)
+void WebLoaderStrategy::remove(ResourceLoader& resourceLoader)
 {
-    ASSERT(resourceLoader);
-    LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::remove, url '%s'", resourceLoader->url().string().utf8().data());
+    LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::remove, url '%s'", resourceLoader.url().string().utf8().data());
 
     if (m_internallyFailedResourceLoaders.contains(resourceLoader)) {
         m_internallyFailedResourceLoaders.remove(resourceLoader);
@@ -246,7 +247,7 @@
         return;
     }
     
-    ResourceLoadIdentifier identifier = resourceLoader->identifier();
+    ResourceLoadIdentifier identifier = resourceLoader.identifier();
     if (!identifier) {
         LOG_ERROR("WebLoaderStrategy removing a ResourceLoader that has no identifier.");
         return;
@@ -264,13 +265,13 @@
     loader->detachFromCoreLoader();
 }
 
-void WebLoaderStrategy::setDefersLoading(ResourceLoader* resourceLoader, bool defers)
+void WebLoaderStrategy::setDefersLoading(ResourceLoader& resourceLoader, bool defers)
 {
-    ResourceLoadIdentifier identifier = resourceLoader->identifier();
+    ResourceLoadIdentifier identifier = resourceLoader.identifier();
     WebProcess::singleton().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::SetDefersLoading(identifier, defers), 0);
 }
 
-void WebLoaderStrategy::crossOriginRedirectReceived(ResourceLoader*, const URL&)
+void WebLoaderStrategy::crossOriginRedirectReceived(ResourceLoader&, const URL&)
 {
     // We handle cross origin redirects entirely within the NetworkProcess.
     // We override this call in the WebProcess to make it a no-op.

Modified: trunk/Source/WebKit2/WebProcess/Network/WebLoaderStrategy.h (203063 => 203064)


--- trunk/Source/WebKit2/WebProcess/Network/WebLoaderStrategy.h	2016-07-11 15:55:57 UTC (rev 203063)
+++ trunk/Source/WebKit2/WebProcess/Network/WebLoaderStrategy.h	2016-07-11 16:01:04 UTC (rev 203064)
@@ -46,9 +46,9 @@
     RefPtr<WebCore::SubresourceLoader> loadResource(WebCore::Frame&, WebCore::CachedResource&, const WebCore::ResourceRequest&, const WebCore::ResourceLoaderOptions&) override;
     void loadResourceSynchronously(WebCore::NetworkingContext*, unsigned long resourceLoadIdentifier, const WebCore::ResourceRequest&, WebCore::StoredCredentials, WebCore::ClientCredentialPolicy, WebCore::ResourceError&, WebCore::ResourceResponse&, Vector<char>& data) override;
 
-    void remove(WebCore::ResourceLoader*) override;
-    void setDefersLoading(WebCore::ResourceLoader*, bool) override;
-    void crossOriginRedirectReceived(WebCore::ResourceLoader*, const WebCore::URL& redirectURL) override;
+    void remove(WebCore::ResourceLoader&) override;
+    void setDefersLoading(WebCore::ResourceLoader&, bool) override;
+    void crossOriginRedirectReceived(WebCore::ResourceLoader&, const WebCore::URL& redirectURL) override;
     
     void servePendingRequests(WebCore::ResourceLoadPriority minimumPriority) override;
 
@@ -68,7 +68,7 @@
     void internallyFailedLoadTimerFired();
     void startLocalLoad(WebCore::ResourceLoader&);
 
-    HashSet<RefPtr<WebCore::ResourceLoader>> m_internallyFailedResourceLoaders;
+    HashSet<Ref<WebCore::ResourceLoader>> m_internallyFailedResourceLoaders;
     RunLoop::Timer<WebLoaderStrategy> m_internallyFailedLoadTimer;
     
     HashMap<unsigned long, RefPtr<WebResourceLoader>> m_webResourceLoaders;
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to