Changeset 183563 in webkit

Timestamp:

Apr 29, 2015 11:51:23 AM (9 years ago)

Author:

Antti Koivisto

Message:

ResourceLoadPriority should be enum class
​https://bugs.webkit.org/show_bug.cgi?id=144326

Reviewed by Darin Adler.

Source/WebCore:

• html/HTMLLinkElement.cpp:

(WebCore::HTMLLinkElement::process):

• loader/LinkLoader.cpp:

(WebCore::LinkLoader::loadLink):

• loader/ResourceLoadScheduler.cpp:

(WebCore::ResourceLoadScheduler::scheduleLoad):
(WebCore::ResourceLoadScheduler::servePendingRequests):
(WebCore::ResourceLoadScheduler::HostInformation::~HostInformation):
(WebCore::ResourceLoadScheduler::HostInformation::priorityToIndex):
(WebCore::ResourceLoadScheduler::HostInformation::schedule):
(WebCore::ResourceLoadScheduler::HostInformation::remove):
(WebCore::ResourceLoadScheduler::HostInformation::hasRequests):
(WebCore::ResourceLoadScheduler::HostInformation::limitRequests):

• loader/ResourceLoadScheduler.h:

(WebCore::ResourceLoadScheduler::HostInformation::requestsPending):

Modernize ResourceLoadScheduler code a bit while switching to enum class.

• loader/cache/CachedResource.cpp:

(WebCore::defaultPriorityForResourceType):

• loader/cache/CachedResourceLoader.cpp:

(WebCore::CachedResourceLoader::requestResource):

• loader/icon/IconLoader.cpp:

(WebCore::IconLoader::startLoading):

• platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm:

(WebCore::WebCoreAVFResourceLoader::startLoading):

• platform/network/ResourceLoadPriority.h:

(WebCore::operator++):
(WebCore::operator--):

• platform/network/ResourceRequestBase.cpp:

(WebCore::ResourceRequestBase::adopt):
(WebCore::ResourceRequestBase::copyData):
(WebCore::ResourceRequestBase::cachePolicy):
(WebCore::ResourceRequestBase::priority):
(WebCore::ResourceRequestBase::setPriority):

• platform/network/ResourceRequestBase.h:

Remove bitfields. ResourceRequests are not present in large enough numbers to require this kind of optimization.
Use modern initialization syntax.

(WebCore::ResourceRequestBase::ResourceRequestBase):
(WebCore::CrossThreadResourceRequestDataBase::CrossThreadResourceRequestDataBase): Deleted.

• platform/network/cf/ResourceRequestCFNet.cpp:

(WebCore::initializeMaximumHTTPConnectionCountPerHost):
(WebCore::initializeHTTPConnectionSettingsOnStartup):

• platform/network/cf/ResourceRequestCFNet.h:

(WebCore::toResourceLoadPriority):
(WebCore::toPlatformRequestPriority):

• platform/network/soup/ResourceRequest.h:

(WebCore::toSoupMessagePriority):

• testing/Internals.cpp:

(WebCore::stringToResourceLoadPriority):

Source/WebKit2:

• NetworkProcess/NetworkConnectionToWebProcess.cpp:

(WebKit::NetworkConnectionToWebProcess::servePendingRequests): Deleted.

Remove this unused message.

• NetworkProcess/NetworkConnectionToWebProcess.h:
• NetworkProcess/NetworkConnectionToWebProcess.messages.in:
• NetworkProcess/cache/NetworkCache.cpp:

(WebKit::NetworkCache::makeStoreDecision):
(WebKit::NetworkCache::Cache::retrieve):

• NetworkProcess/mac/NetworkResourceLoadSchedulerMac.mm:

(WebKit::NetworkResourceLoadScheduler::platformInitializeNetworkSettings):

• WebProcess/Network/WebResourceLoadScheduler.cpp:

(WebKit::WebResourceLoadScheduler::servePendingRequests):

• WebProcess/Network/WebResourceLoadScheduler.h:

Location:

trunk/Source

Files:

• WebCore/ChangeLog (modified) (1 diff)
• WebCore/html/HTMLLinkElement.cpp (modified) (1 diff)
• WebCore/loader/LinkLoader.cpp (modified) (1 diff)
• WebCore/loader/ResourceLoadScheduler.cpp (modified) (10 diffs)
• WebCore/loader/ResourceLoadScheduler.h (modified) (4 diffs)
• WebCore/loader/cache/CachedResource.cpp (modified) (2 diffs)
• WebCore/loader/cache/CachedResourceLoader.cpp (modified) (1 diff)
• WebCore/loader/icon/IconLoader.cpp (modified) (1 diff)
• WebCore/platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp (modified) (1 diff)
• WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm (modified) (1 diff)
• WebCore/platform/network/ResourceLoadPriority.h (modified) (1 diff)
• WebCore/platform/network/ResourceRequestBase.cpp (modified) (5 diffs)
• WebCore/platform/network/ResourceRequestBase.h (modified) (4 diffs)
• WebCore/platform/network/cf/ResourceRequestCFNet.cpp (modified) (2 diffs)
• WebCore/platform/network/cf/ResourceRequestCFNet.h (modified) (2 diffs)
• WebCore/platform/network/soup/ResourceRequest.h (modified) (1 diff)
• WebCore/testing/Internals.cpp (modified) (1 diff)
• WebKit2/ChangeLog (modified) (1 diff)
• WebKit2/NetworkProcess/NetworkConnectionToWebProcess.cpp (modified) (1 diff)
• WebKit2/NetworkProcess/NetworkConnectionToWebProcess.h (modified) (1 diff)
• WebKit2/NetworkProcess/NetworkConnectionToWebProcess.messages.in (modified) (1 diff)
• WebKit2/NetworkProcess/cache/NetworkCache.cpp (modified) (2 diffs)
• WebKit2/NetworkProcess/mac/NetworkResourceLoadSchedulerMac.mm (modified) (1 diff)
• WebKit2/WebProcess/InjectedBundle/InjectedBundle.cpp (modified) (1 diff)
• WebKit2/WebProcess/Network/WebResourceLoadScheduler.cpp (modified) (1 diff)
• WebKit2/WebProcess/Network/WebResourceLoadScheduler.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2015-04-29  Antti Koivisto  <antti@apple.com>
+
+        ResourceLoadPriority should be enum class
+        https://bugs.webkit.org/show_bug.cgi?id=144326
+
+        Reviewed by Darin Adler.
+
+        * html/HTMLLinkElement.cpp:
+        (WebCore::HTMLLinkElement::process):
+        * loader/LinkLoader.cpp:
+        (WebCore::LinkLoader::loadLink):
+        * loader/ResourceLoadScheduler.cpp:
+        (WebCore::ResourceLoadScheduler::scheduleLoad):
+        (WebCore::ResourceLoadScheduler::servePendingRequests):
+        (WebCore::ResourceLoadScheduler::HostInformation::~HostInformation):
+        (WebCore::ResourceLoadScheduler::HostInformation::priorityToIndex):
+        (WebCore::ResourceLoadScheduler::HostInformation::schedule):
+        (WebCore::ResourceLoadScheduler::HostInformation::remove):
+        (WebCore::ResourceLoadScheduler::HostInformation::hasRequests):
+        (WebCore::ResourceLoadScheduler::HostInformation::limitRequests):
+        * loader/ResourceLoadScheduler.h:
+        (WebCore::ResourceLoadScheduler::HostInformation::requestsPending):
+
+            Modernize ResourceLoadScheduler code a bit while switching to enum class.
+
+        * loader/cache/CachedResource.cpp:
+        (WebCore::defaultPriorityForResourceType):
+        * loader/cache/CachedResourceLoader.cpp:
+        (WebCore::CachedResourceLoader::requestResource):
+        * loader/icon/IconLoader.cpp:
+        (WebCore::IconLoader::startLoading):
+        * platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm:
+        (WebCore::WebCoreAVFResourceLoader::startLoading):
+        * platform/network/ResourceLoadPriority.h:
+        (WebCore::operator++):
+        (WebCore::operator--):
+        * platform/network/ResourceRequestBase.cpp:
+        (WebCore::ResourceRequestBase::adopt):
+        (WebCore::ResourceRequestBase::copyData):
+        (WebCore::ResourceRequestBase::cachePolicy):
+        (WebCore::ResourceRequestBase::priority):
+        (WebCore::ResourceRequestBase::setPriority):
+        * platform/network/ResourceRequestBase.h:
+
+            Remove bitfields. ResourceRequests are not present in large enough numbers to require this kind of optimization.
+            Use modern initialization syntax.
+
+        (WebCore::ResourceRequestBase::ResourceRequestBase):
+        (WebCore::CrossThreadResourceRequestDataBase::CrossThreadResourceRequestDataBase): Deleted.
+        * platform/network/cf/ResourceRequestCFNet.cpp:
+        (WebCore::initializeMaximumHTTPConnectionCountPerHost):
+        (WebCore::initializeHTTPConnectionSettingsOnStartup):
+        * platform/network/cf/ResourceRequestCFNet.h:
+        (WebCore::toResourceLoadPriority):
+        (WebCore::toPlatformRequestPriority):
+        * platform/network/soup/ResourceRequest.h:
+        (WebCore::toSoupMessagePriority):
+        * testing/Internals.cpp:
+        (WebCore::stringToResourceLoadPriority):
+
 2015-04-29  Myles C. Maxfield  <mmaxfield@apple.com>
 

trunk/Source/WebCore/html/HTMLLinkElement.cpp

@@ -241 +241 @@
         Optional<ResourceLoadPriority> priority;
         if (!isActive)
-            priority = ResourceLoadPriorityVeryLow;
+            priority = ResourceLoadPriority::VeryLow;
         CachedResourceRequest request(ResourceRequest(document().completeURL(url)), charset, priority);
         request.setInitiator(this);

trunk/Source/WebCore/loader/LinkLoader.cpp

@@ -113 +113 @@
             // We only make one request to the cached resource loader if multiple rel types are specified;
             // this is the higher priority, which should overwrite the lower priority.
-            priority = ResourceLoadPriorityLow;
+            priority = ResourceLoadPriority::Low;
             type = CachedResource::LinkSubresource;
         }

trunk/Source/WebCore/loader/ResourceLoadScheduler.cpp

@@ -172 +172 @@
         // 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, ResourceLoadPriorityVeryLow);
-        return;
-    }
-#endif
-
-#if PLATFORM(IOS)
-    if ((priority > ResourceLoadPriorityLow || !resourceLoader->iOSOriginalRequest().url().protocolIsInHTTPFamily() || (priority == ResourceLoadPriorityLow && !hadRequests)) && !isSuspendingPendingRequests()) {
+        servePendingRequests(host, ResourceLoadPriority::VeryLow);
+        return;
+    }
+#endif
+
+#if PLATFORM(IOS)
+    if ((priority > ResourceLoadPriority::Low || !resourceLoader->iOSOriginalRequest().url().protocolIsInHTTPFamily() || (priority == ResourceLoadPriority::Low && !hadRequests)) && !isSuspendingPendingRequests()) {
         // Try to request important resources immediately.
         servePendingRequests(host, priority);
@@ -184 +184 @@
     }
 #else
-    if (priority > ResourceLoadPriorityLow || !resourceLoader->url().protocolIsInHTTPFamily() || (priority == ResourceLoadPriorityLow && !hadRequests)) {
+    if (priority > ResourceLoadPriority::Low || !resourceLoader->url().protocolIsInHTTPFamily() || (priority == ResourceLoadPriority::Low && !hadRequests)) {
         // Try to request important resources immediately.
         servePendingRequests(host, priority);
@@ -257 +257 @@
 
     Vector<HostInformation*> hostsToServe;
-    m_hosts.checkConsistency();
-    HostMap::iterator end = m_hosts.end();
-    for (HostMap::iterator iter = m_hosts.begin(); iter != end; ++iter)
-        hostsToServe.append(iter->value);
-
-    int size = hostsToServe.size();
-    for (int i = 0; i < size; ++i) {
-        HostInformation* host = hostsToServe[i];
+    copyValuesToVector(m_hosts, hostsToServe);
+
+    for (auto* host : hostsToServe) {
         if (host->hasRequests())
             servePendingRequests(host, minimumPriority);
@@ -276 +271 @@
     LOG(ResourceLoading, "ResourceLoadScheduler::servePendingRequests HostInformation.m_name='%s'", host->name().latin1().data());
 
-    for (int priority = ResourceLoadPriorityHighest; priority >= minimumPriority; --priority) {
-        HostInformation::RequestQueue& requestsPending = host->requestsPending(ResourceLoadPriority(priority));
-
+    auto priority = ResourceLoadPriority::Highest;
+    while (true) {
+        auto& requestsPending = host->requestsPending(priority);
         while (!requestsPending.isEmpty()) {
             RefPtr<ResourceLoader> resourceLoader = requestsPending.first();
@@ -287 +282 @@
             Document* document = resourceLoader->frameLoader() ? resourceLoader->frameLoader()->frame().document() : 0;
             bool shouldLimitRequests = !host->name().isNull() || (document && (document->parsing() || !document->haveStylesheetsLoaded()));
-            if (shouldLimitRequests && host->limitRequests(ResourceLoadPriority(priority)))
+            if (shouldLimitRequests && host->limitRequests(priority))
                 return;
 
@@ -300 +295 @@
             resourceLoader->start();
         }
+        if (priority == minimumPriority)
+            return;
+        --priority;
     }
 }
@@ -339 +337 @@
 ResourceLoadScheduler::HostInformation::~HostInformation()
 {
-    ASSERT(m_requestsLoading.isEmpty());
-    for (unsigned p = 0; p <= ResourceLoadPriorityHighest; p++)
-        ASSERT(m_requestsPending[p].isEmpty());
-}
-    
+    ASSERT(!hasRequests());
+}
+
+unsigned ResourceLoadScheduler::HostInformation::priorityToIndex(ResourceLoadPriority priority)
+{
+    switch (priority) {
+    case ResourceLoadPriority::VeryLow:
+        return 0;
+    case ResourceLoadPriority::Low:
+        return 1;
+    case ResourceLoadPriority::Medium:
+        return 2;
+    case ResourceLoadPriority::High:
+        return 3;
+    case ResourceLoadPriority::VeryHigh:
+        return 4;
+    }
+    ASSERT_NOT_REACHED();
+    return 0;
+}
+
 void ResourceLoadScheduler::HostInformation::schedule(ResourceLoader* resourceLoader, ResourceLoadPriority priority)
 {
-    m_requestsPending[priority].append(resourceLoader);
+    m_requestsPending[priorityToIndex(priority)].append(resourceLoader);
 }
     
@@ -360 +374 @@
         return;
     
-    for (int priority = ResourceLoadPriorityHighest; priority >= ResourceLoadPriorityLowest; --priority) {  
-        RequestQueue::iterator end = m_requestsPending[priority].end();
-        for (RequestQueue::iterator it = m_requestsPending[priority].begin(); it != end; ++it) {
+    for (auto& requestQueue : m_requestsPending) {
+        for (auto it = requestQueue.begin(), end = requestQueue.end(); it != end; ++it) {
             if (*it == resourceLoader) {
-                m_requestsPending[priority].remove(it);
+                requestQueue.remove(it);
                 return;
             }
@@ -375 +388 @@
     if (!m_requestsLoading.isEmpty())
         return true;
-    for (unsigned p = 0; p <= ResourceLoadPriorityHighest; p++) {
-        if (!m_requestsPending[p].isEmpty())
+    for (auto& requestQueue : m_requestsPending) {
+        if (!requestQueue.isEmpty())
             return true;
     }
@@ -384 +397 @@
 bool ResourceLoadScheduler::HostInformation::limitRequests(ResourceLoadPriority priority) const 
 {
-    if (priority == ResourceLoadPriorityVeryLow && !m_requestsLoading.isEmpty())
+    if (priority == ResourceLoadPriority::VeryLow && !m_requestsLoading.isEmpty())
         return true;
     return m_requestsLoading.size() >= (resourceLoadScheduler()->isSerialLoadingEnabled() ? 1 : m_maxRequestsInFlight);

trunk/Source/WebCore/loader/ResourceLoadScheduler.h

@@ -28 +28 @@
 #include "ResourceLoadPriority.h"
 #include "Timer.h"
+#include <array>
 #include <wtf/Deque.h>
 #include <wtf/HashMap.h>
@@ -57 +58 @@
     virtual void crossOriginRedirectReceived(ResourceLoader*, const URL& redirectURL);
     
-    WEBCORE_EXPORT virtual void servePendingRequests(ResourceLoadPriority minimumPriority = ResourceLoadPriorityVeryLow);
+    WEBCORE_EXPORT virtual void servePendingRequests(ResourceLoadPriority minimumPriority = ResourceLoadPriority::VeryLow);
     WEBCORE_EXPORT virtual void suspendPendingRequests();
     WEBCORE_EXPORT virtual void resumePendingRequests();
@@ -94 +95 @@
         
         const String& name() const { return m_name; }
-        void schedule(ResourceLoader*, ResourceLoadPriority = ResourceLoadPriorityVeryLow);
+        void schedule(ResourceLoader*, ResourceLoadPriority = ResourceLoadPriority::VeryLow);
         void addLoadInProgress(ResourceLoader*);
         void remove(ResourceLoader*);
@@ -101 +102 @@
 
         typedef Deque<RefPtr<ResourceLoader>> RequestQueue;
-        RequestQueue& requestsPending(ResourceLoadPriority priority) { return m_requestsPending[priority]; }
+        RequestQueue& requestsPending(ResourceLoadPriority priority) { return m_requestsPending[priorityToIndex(priority)]; }
 
-    private:                    
-        RequestQueue m_requestsPending[ResourceLoadPriorityHighest + 1];
+    private:
+        static unsigned priorityToIndex(ResourceLoadPriority);
+
+        std::array<RequestQueue, resourceLoadPriorityCount> m_requestsPending;
         typedef HashSet<RefPtr<ResourceLoader>> RequestMap;
         RequestMap m_requestsLoading;

trunk/Source/WebCore/loader/cache/CachedResource.cpp

@@ -69 +69 @@
     switch (type) {
     case CachedResource::MainResource:
-        return ResourceLoadPriorityVeryHigh;
+        return ResourceLoadPriority::VeryHigh;
     case CachedResource::CSSStyleSheet:
-        return ResourceLoadPriorityHigh;
+        return ResourceLoadPriority::High;
     case CachedResource::Script:
 #if ENABLE(SVG_FONTS)
@@ -78 +78 @@
     case CachedResource::FontResource:
     case CachedResource::RawResource:
-        return ResourceLoadPriorityMedium;
+        return ResourceLoadPriority::Medium;
     case CachedResource::ImageResource:
-        return ResourceLoadPriorityLow;
+        return ResourceLoadPriority::Low;
 #if ENABLE(XSLT)
     case CachedResource::XSLStyleSheet:
-        return ResourceLoadPriorityHigh;
+        return ResourceLoadPriority::High;
 #endif
     case CachedResource::SVGDocumentResource:
-        return ResourceLoadPriorityLow;
+        return ResourceLoadPriority::Low;
 #if ENABLE(LINK_PREFETCH)
     case CachedResource::LinkPrefetch:
-        return ResourceLoadPriorityVeryLow;
+        return ResourceLoadPriority::VeryLow;
     case CachedResource::LinkSubresource:
-        return ResourceLoadPriorityVeryLow;
+        return ResourceLoadPriority::VeryLow;
 #endif
 #if ENABLE(VIDEO_TRACK)
     case CachedResource::TextTrackResource:
-        return ResourceLoadPriorityLow;
+        return ResourceLoadPriority::Low;
 #endif
     }
     ASSERT_NOT_REACHED();
-    return ResourceLoadPriorityLow;
+    return ResourceLoadPriority::Low;
 }
 

trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp

@@ -497 +497 @@
     URL url = request.resourceRequest().url();
     
-    LOG(ResourceLoading, "CachedResourceLoader::requestResource '%s', charset '%s', priority=%d, forPreload=%u", url.stringCenterEllipsizedToLength().latin1().data(), request.charset().latin1().data(), request.priority() ? request.priority().value() : -1, request.forPreload());
+    LOG(ResourceLoading, "CachedResourceLoader::requestResource '%s', charset '%s', priority=%d, forPreload=%u", url.stringCenterEllipsizedToLength().latin1().data(), request.charset().latin1().data(), request.priority() ? static_cast<int>(request.priority().value()) : -1, request.forPreload());
     
     // If only the fragment identifiers differ, it is the same resource.

trunk/Source/WebCore/loader/icon/IconLoader.cpp

@@ -61 +61 @@
     CachedResourceRequest request(ResourceRequest(m_frame.loader().icon().url()), ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, DoNotAllowStoredCredentials, DoNotAskClientForAnyCredentials, DoSecurityCheck, UseDefaultOriginRestrictionsForType, DoNotIncludeCertificateInfo));
 
-    request.mutableResourceRequest().setPriority(ResourceLoadPriorityLow);
+    request.mutableResourceRequest().setPriority(ResourceLoadPriority::Low);
     request.setInitiator(cachedResourceRequestInitiators().icon);
 

trunk/Source/WebCore/platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp

@@ -74 +74 @@
     CachedResourceRequest request(ResourceRequest(requestURL), ResourceLoaderOptions(SendCallbacks, DoNotSniffContent, BufferData, DoNotAllowStoredCredentials, DoNotAskClientForCrossOriginCredentials, DoSecurityCheck, UseDefaultOriginRestrictionsForType, DoNotIncludeCertificateInfo));
 
-    request.mutableResourceRequest().setPriority(ResourceLoadPriorityLow);
+    request.mutableResourceRequest().setPriority(ResourceLoadPriority::Low);
     CachedResourceLoader* loader = m_parent->player()->cachedResourceLoader();
     m_resource = loader ? loader->requestRawResource(request) : 0;

trunk/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm

@@ -70 +70 @@
     CachedResourceRequest request(ResourceRequest(requestURL), ResourceLoaderOptions(SendCallbacks, DoNotSniffContent, BufferData, DoNotAllowStoredCredentials, DoNotAskClientForCrossOriginCredentials, DoSecurityCheck, UseDefaultOriginRestrictionsForType, DoNotIncludeCertificateInfo));
 
-    request.mutableResourceRequest().setPriority(ResourceLoadPriorityLow);
+    request.mutableResourceRequest().setPriority(ResourceLoadPriority::Low);
     CachedResourceLoader* loader = m_parent->player()->cachedResourceLoader();
     m_resource = loader ? loader->requestRawResource(request) : 0;

trunk/Source/WebCore/platform/network/ResourceLoadPriority.h

@@ -29 +29 @@
 namespace WebCore {
 
-enum ResourceLoadPriority {
-    ResourceLoadPriorityVeryLow,
-    ResourceLoadPriorityLow,
-    ResourceLoadPriorityMedium,
-    ResourceLoadPriorityHigh,
-    ResourceLoadPriorityVeryHigh,
-    ResourceLoadPriorityLowest = ResourceLoadPriorityVeryLow,
-    ResourceLoadPriorityHighest = ResourceLoadPriorityVeryHigh,
+enum class ResourceLoadPriority {
+    VeryLow,
+    Low,
+    Medium,
+    High,
+    VeryHigh,
+    Lowest = VeryLow,
+    Highest = VeryHigh,
 };
+
+static const unsigned resourceLoadPriorityCount { static_cast<unsigned>(ResourceLoadPriority::Highest) + 1 };
+
+inline ResourceLoadPriority& operator++(ResourceLoadPriority& priority)
+{
+    ASSERT(priority != ResourceLoadPriority::Highest);
+    return priority = static_cast<ResourceLoadPriority>(static_cast<int>(priority) + 1);
+}
+
+inline ResourceLoadPriority& operator--(ResourceLoadPriority& priority)
+{
+    ASSERT(priority != ResourceLoadPriority::Lowest);
+    return priority = static_cast<ResourceLoadPriority>(static_cast<int>(priority) - 1);
+}
 
 }

trunk/Source/WebCore/platform/network/ResourceRequestBase.cpp

@@ -52 +52 @@
 {
     auto request = std::make_unique<ResourceRequest>();
-    request->setURL(data->m_url);
-    request->setCachePolicy(data->m_cachePolicy);
-    request->setTimeoutInterval(data->m_timeoutInterval);
-    request->setFirstPartyForCookies(data->m_firstPartyForCookies);
-    request->setHTTPMethod(data->m_httpMethod);
-    request->setPriority(data->m_priority);
-    request->setRequester(data->m_requester);
+    request->setURL(data->url);
+    request->setCachePolicy(data->cachePolicy);
+    request->setTimeoutInterval(data->timeoutInterval);
+    request->setFirstPartyForCookies(data->firstPartyForCookies);
+    request->setHTTPMethod(data->httpMethod);
+    request->setPriority(data->priority);
+    request->setRequester(data->requester);
 
     request->updateResourceRequest();
-    request->m_httpHeaderFields.adopt(WTF::move(data->m_httpHeaders));
-
-    size_t encodingCount = data->m_responseContentDispositionEncodingFallbackArray.size();
+    request->m_httpHeaderFields.adopt(WTF::move(data->httpHeaders));
+
+    size_t encodingCount = data->responseContentDispositionEncodingFallbackArray.size();
     if (encodingCount > 0) {
-        String encoding1 = data->m_responseContentDispositionEncodingFallbackArray[0];
+        String encoding1 = data->responseContentDispositionEncodingFallbackArray[0];
         String encoding2;
         String encoding3;
         if (encodingCount > 1) {
-            encoding2 = data->m_responseContentDispositionEncodingFallbackArray[1];
+            encoding2 = data->responseContentDispositionEncodingFallbackArray[1];
             if (encodingCount > 2)
-                encoding3 = data->m_responseContentDispositionEncodingFallbackArray[2];
+                encoding3 = data->responseContentDispositionEncodingFallbackArray[2];
         }
         ASSERT(encodingCount <= 3);
         request->setResponseContentDispositionEncodingFallbackArray(encoding1, encoding2, encoding3);
     }
-    request->setHTTPBody(data->m_httpBody);
-    request->setAllowCookies(data->m_allowCookies);
+    request->setHTTPBody(data->httpBody);
+    request->setAllowCookies(data->allowCookies);
     request->doPlatformAdopt(WTF::move(data));
     return request;
@@ -85 +85 @@
 {
     auto data = std::make_unique<CrossThreadResourceRequestData>();
-    data->m_url = url().copy();
-    data->m_cachePolicy = cachePolicy();
-    data->m_timeoutInterval = timeoutInterval();
-    data->m_firstPartyForCookies = firstPartyForCookies().copy();
-    data->m_httpMethod = httpMethod().isolatedCopy();
-    data->m_httpHeaders = httpHeaderFields().copyData();
-    data->m_priority = priority();
-    data->m_requester = m_requester;
-
-    data->m_responseContentDispositionEncodingFallbackArray.reserveInitialCapacity(m_responseContentDispositionEncodingFallbackArray.size());
+    data->url = url().copy();
+    data->cachePolicy = m_cachePolicy;
+    data->timeoutInterval = timeoutInterval();
+    data->firstPartyForCookies = firstPartyForCookies().copy();
+    data->httpMethod = httpMethod().isolatedCopy();
+    data->httpHeaders = httpHeaderFields().copyData();
+    data->priority = m_priority;
+    data->requester = m_requester;
+
+    data->responseContentDispositionEncodingFallbackArray.reserveInitialCapacity(m_responseContentDispositionEncodingFallbackArray.size());
     size_t encodingArraySize = m_responseContentDispositionEncodingFallbackArray.size();
     for (size_t index = 0; index < encodingArraySize; ++index) {
-        data->m_responseContentDispositionEncodingFallbackArray.append(m_responseContentDispositionEncodingFallbackArray[index].isolatedCopy());
+        data->responseContentDispositionEncodingFallbackArray.append(m_responseContentDispositionEncodingFallbackArray[index].isolatedCopy());
     }
     if (m_httpBody)
-        data->m_httpBody = m_httpBody->deepCopy();
-    data->m_allowCookies = m_allowCookies;
+        data->httpBody = m_httpBody->deepCopy();
+    data->allowCookies = m_allowCookies;
     return asResourceRequest().doPlatformCopyData(WTF::move(data));
 }
@@ -152 +152 @@
     updateResourceRequest(); 
     
-    return static_cast<ResourceRequestCachePolicy>(m_cachePolicy);
+    return m_cachePolicy;
 }
 
@@ -439 +439 @@
     updateResourceRequest();
 
-    return static_cast<ResourceLoadPriority>(m_priority);
+    return m_priority;
 }
 
@@ -450 +450 @@
 
     m_priority = priority;
-    ASSERT(static_cast<ResourceLoadPriority>(m_priority) == priority); // Make sure it fits in the bitfield.
 
     if (url().protocolIsInHTTPFamily())

trunk/Source/WebCore/platform/network/ResourceRequestBase.h

@@ -171 +171 @@
         // Used when ResourceRequest is initialized from a platform representation of the request
         ResourceRequestBase()
-            : m_resourceRequestUpdated(false)
-            , m_platformRequestUpdated(true)
-            , m_resourceRequestBodyUpdated(false)
+            : m_platformRequestUpdated(true)
             , m_platformRequestBodyUpdated(true)
-            , m_reportUploadProgress(false)
-            , m_reportLoadTiming(false)
-            , m_reportRawHeaders(false)
-            , m_hiddenFromInspector(false)
-            , m_priority(ResourceLoadPriorityLow)
         {
         }
@@ -194 +187 @@
 #endif
             , m_resourceRequestUpdated(true)
-            , m_platformRequestUpdated(false)
             , m_resourceRequestBodyUpdated(true)
-            , m_platformRequestBodyUpdated(false)
-            , m_reportUploadProgress(false)
-            , m_reportLoadTiming(false)
-            , m_reportRawHeaders(false)
-            , m_hiddenFromInspector(false)
-            , m_priority(ResourceLoadPriorityLow)
         {
         }
@@ -218 +204 @@
         Vector<String> m_responseContentDispositionEncodingFallbackArray;
         RefPtr<FormData> m_httpBody;
-        unsigned m_cachePolicy : 3;
-        unsigned m_allowCookies : 1;
-        mutable unsigned m_resourceRequestUpdated : 1;
-        mutable unsigned m_platformRequestUpdated : 1;
-        mutable unsigned m_resourceRequestBodyUpdated : 1;
-        mutable unsigned m_platformRequestBodyUpdated : 1;
-        unsigned m_reportUploadProgress : 1;
-        unsigned m_reportLoadTiming : 1;
-        unsigned m_reportRawHeaders : 1;
-        unsigned m_hiddenFromInspector : 1;
-        unsigned m_priority : 4;
+        ResourceRequestCachePolicy m_cachePolicy { UseProtocolCachePolicy };
+        bool m_allowCookies { false };
+        mutable bool m_resourceRequestUpdated { false };
+        mutable bool m_platformRequestUpdated { false };
+        mutable bool m_resourceRequestBodyUpdated { false };
+        mutable bool m_platformRequestBodyUpdated { false };
+        bool m_reportUploadProgress { false };
+        bool m_reportLoadTiming { false };
+        bool m_reportRawHeaders { false };
+        bool m_hiddenFromInspector { false };
+        ResourceLoadPriority m_priority { ResourceLoadPriority::Low };
         Requester m_requester { Requester::Unspecified };
 
@@ -246 +232 @@
 
     struct CrossThreadResourceRequestDataBase {
-        WTF_MAKE_NONCOPYABLE(CrossThreadResourceRequestDataBase); WTF_MAKE_FAST_ALLOCATED;
-    public:
-        CrossThreadResourceRequestDataBase() { }
-        URL m_url;
-
-        ResourceRequestCachePolicy m_cachePolicy;
-        double m_timeoutInterval;
-        URL m_firstPartyForCookies;
-
-        String m_httpMethod;
-        std::unique_ptr<CrossThreadHTTPHeaderMapData> m_httpHeaders;
-        Vector<String> m_responseContentDispositionEncodingFallbackArray;
-        RefPtr<FormData> m_httpBody;
-        bool m_allowCookies;
-        ResourceLoadPriority m_priority;
-        ResourceRequestBase::Requester m_requester;
+        URL url;
+        ResourceRequestCachePolicy cachePolicy;
+        double timeoutInterval;
+        URL firstPartyForCookies;
+        String httpMethod;
+        std::unique_ptr<CrossThreadHTTPHeaderMapData> httpHeaders;
+        Vector<String> responseContentDispositionEncodingFallbackArray;
+        RefPtr<FormData> httpBody;
+        bool allowCookies;
+        ResourceLoadPriority priority;
+        ResourceRequestBase::Requester requester;
     };
     

trunk/Source/WebCore/platform/network/cf/ResourceRequestCFNet.cpp

@@ -400 +400 @@
         return maximumHTTPConnectionCountPerHost;
 
-    wkSetHTTPRequestMaximumPriority(toPlatformRequestPriority(ResourceLoadPriorityHighest));
+    wkSetHTTPRequestMaximumPriority(toPlatformRequestPriority(ResourceLoadPriority::Highest));
 #if !PLATFORM(WIN)
     // FIXME: <rdar://problem/9375609> Implement minimum fast lane priority setting on Windows
-    wkSetHTTPRequestMinimumFastLanePriority(toPlatformRequestPriority(ResourceLoadPriorityMedium));
+    wkSetHTTPRequestMinimumFastLanePriority(toPlatformRequestPriority(ResourceLoadPriority::Medium));
 #endif
 
@@ -419 +419 @@
     static const unsigned fastLaneConnectionCount = 1;
     wkInitializeMaximumHTTPConnectionCountPerHost(preferredConnectionCount);
-    wkSetHTTPRequestMaximumPriority(ResourceLoadPriorityHighest);
-    wkSetHTTPRequestMinimumFastLanePriority(ResourceLoadPriorityMedium);
+    wkSetHTTPRequestMaximumPriority(toPlatformRequestPriority(ResourceLoadPriority::Highest));
+    wkSetHTTPRequestMinimumFastLanePriority(toPlatformRequestPriority(ResourceLoadPriority::Medium));
     _CFNetworkHTTPConnectionCacheSetLimit(kHTTPNumFastLanes, fastLaneConnectionCount);
 }

trunk/Source/WebCore/platform/network/cf/ResourceRequestCFNet.h

@@ -47 +47 @@
     case -1:
     case 0:
-        return ResourceLoadPriorityVeryLow;
+        return ResourceLoadPriority::VeryLow;
     case 1:
-        return ResourceLoadPriorityLow;
+        return ResourceLoadPriority::Low;
     case 2:
-        return ResourceLoadPriorityMedium;
+        return ResourceLoadPriority::Medium;
     case 3:
-        return ResourceLoadPriorityHigh;
+        return ResourceLoadPriority::High;
     case 4:
-        return ResourceLoadPriorityVeryHigh;
+        return ResourceLoadPriority::VeryHigh;
     default:
         ASSERT_NOT_REACHED();
-        return ResourceLoadPriorityLowest;
+        return ResourceLoadPriority::Lowest;
     }
 }
@@ -65 +65 @@
 {
     switch (priority) {
-    case ResourceLoadPriorityVeryLow:
+    case ResourceLoadPriority::VeryLow:
         return 0;
-    case ResourceLoadPriorityLow:
+    case ResourceLoadPriority::Low:
         return 1;
-    case ResourceLoadPriorityMedium:
+    case ResourceLoadPriority::Medium:
         return 2;
-    case ResourceLoadPriorityHigh:
+    case ResourceLoadPriority::High:
         return 3;
-    case ResourceLoadPriorityVeryHigh:
+    case ResourceLoadPriority::VeryHigh:
         return 4;
     }

trunk/Source/WebCore/platform/network/soup/ResourceRequest.h

@@ -132 +132 @@
 {
     switch (priority) {
-    case ResourceLoadPriorityVeryLow:
+    case ResourceLoadPriority::VeryLow:
         return SOUP_MESSAGE_PRIORITY_VERY_LOW;
-    case ResourceLoadPriorityLow:
+    case ResourceLoadPriority::Low:
         return SOUP_MESSAGE_PRIORITY_LOW;
-    case ResourceLoadPriorityMedium:
+    case ResourceLoadPriority::Medium:
         return SOUP_MESSAGE_PRIORITY_NORMAL;
-    case ResourceLoadPriorityHigh:
+    case ResourceLoadPriority::High:
         return SOUP_MESSAGE_PRIORITY_HIGH;
-    case ResourceLoadPriorityVeryHigh:
+    case ResourceLoadPriority::VeryHigh:
         return SOUP_MESSAGE_PRIORITY_VERY_HIGH;
     }

trunk/Source/WebCore/testing/Internals.cpp

@@ -462 +462 @@
 {
     if (policy == "ResourceLoadPriorityVeryLow")
-        return ResourceLoadPriorityVeryLow;
+        return ResourceLoadPriority::VeryLow;
     if (policy == "ResourceLoadPriorityLow")
-        return ResourceLoadPriorityLow;
+        return ResourceLoadPriority::Low;
     if (policy == "ResourceLoadPriorityMedium")
-        return ResourceLoadPriorityMedium;
+        return ResourceLoadPriority::Medium;
     if (policy == "ResourceLoadPriorityHigh")
-        return ResourceLoadPriorityHigh;
+        return ResourceLoadPriority::High;
     if (policy == "ResourceLoadPriorityVeryHigh")
-        return ResourceLoadPriorityVeryHigh;
+        return ResourceLoadPriority::VeryHigh;
     ASSERT_NOT_REACHED();
-    return ResourceLoadPriorityLow;
+    return ResourceLoadPriority::Low;
 }
 

trunk/Source/WebKit2/ChangeLog

@@ +1 @@
+2015-04-29  Antti Koivisto  <antti@apple.com>
+
+        ResourceLoadPriority should be enum class
+        https://bugs.webkit.org/show_bug.cgi?id=144326
+
+        Reviewed by Darin Adler.
+
+        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
+        (WebKit::NetworkConnectionToWebProcess::servePendingRequests): Deleted.
+
+            Remove this unused message.
+
+        * NetworkProcess/NetworkConnectionToWebProcess.h:
+        * NetworkProcess/NetworkConnectionToWebProcess.messages.in:
+        * NetworkProcess/cache/NetworkCache.cpp:
+        (WebKit::NetworkCache::makeStoreDecision):
+        (WebKit::NetworkCache::Cache::retrieve):
+        * NetworkProcess/mac/NetworkResourceLoadSchedulerMac.mm:
+        (WebKit::NetworkResourceLoadScheduler::platformInitializeNetworkSettings):
+        * WebProcess/Network/WebResourceLoadScheduler.cpp:
+        (WebKit::WebResourceLoadScheduler::servePendingRequests):
+        * WebProcess/Network/WebResourceLoadScheduler.h:
+
 2015-04-29  Myles C. Maxfield  <mmaxfield@apple.com>
 

trunk/Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.cpp

@@ -152 +152 @@
 }
 
-void NetworkConnectionToWebProcess::servePendingRequests(uint32_t)
-{
-}
-
 void NetworkConnectionToWebProcess::setSerialLoadingEnabled(bool enabled)
 {

trunk/Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.h

@@ -79 +79 @@
     void setDefersLoading(ResourceLoadIdentifier, bool);
     void crossOriginRedirectReceived(ResourceLoadIdentifier, const WebCore::URL& redirectURL);
-    void servePendingRequests(uint32_t resourceLoadPriority);
     void setSerialLoadingEnabled(bool);
     void startDownload(WebCore::SessionID, uint64_t downloadID, const WebCore::ResourceRequest&);

trunk/Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.messages.in

@@ -29 +29 @@
     RemoveLoadIdentifier(uint64_t resourceLoadIdentifier)
     SetDefersLoading(uint64_t resourceLoadIdentifier, bool defers)
-    
-    ServePendingRequests(uint32_t resourceLoadPriority)
-    
     SetSerialLoadingEnabled(bool enabled) -> ()
 

trunk/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp

@@ -301 +301 @@
 
     bool isMainResource = originalRequest.requester() == WebCore::ResourceRequest::Requester::Main;
-    bool storeUnconditionallyForHistoryNavigation = isMainResource || originalRequest.priority() == WebCore::ResourceLoadPriorityVeryHigh;
+    bool storeUnconditionallyForHistoryNavigation = isMainResource || originalRequest.priority() == WebCore::ResourceLoadPriority::VeryHigh;
     if (!storeUnconditionallyForHistoryNavigation) {
         auto now = std::chrono::system_clock::now();
@@ -343 +343 @@
 
     auto startTime = std::chrono::system_clock::now();
-    unsigned priority = originalRequest.priority();
+    auto priority = static_cast<unsigned>(originalRequest.priority());
 
     m_storage->retrieve(storageKey, priority, [this, originalRequest, completionHandler, startTime, storageKey, webPageID](std::unique_ptr<Storage::Record> record) {

trunk/Source/WebKit2/NetworkProcess/mac/NetworkResourceLoadSchedulerMac.mm

@@ -50 +50 @@
 
     if (ResourceRequest::resourcePrioritiesEnabled()) {
-        WKSetHTTPRequestMaximumPriority(toPlatformRequestPriority(ResourceLoadPriorityHighest));
-        WKSetHTTPRequestMinimumFastLanePriority(toPlatformRequestPriority(ResourceLoadPriorityMedium));
+        WKSetHTTPRequestMaximumPriority(toPlatformRequestPriority(ResourceLoadPriority::Highest));
+        WKSetHTTPRequestMinimumFastLanePriority(toPlatformRequestPriority(ResourceLoadPriority::Medium));
     }
 }

trunk/Source/WebKit2/WebProcess/InjectedBundle/InjectedBundle.cpp

@@ -638 +638 @@
 void InjectedBundle::dispatchPendingLoadRequests()
 {
-    resourceLoadScheduler()->servePendingRequests();
+    // FIXME: This should be removed along with the bundle API.
 }
 

trunk/Source/WebKit2/WebProcess/Network/WebResourceLoadScheduler.cpp

@@ -245 +245 @@
 }
 
-void WebResourceLoadScheduler::servePendingRequests(ResourceLoadPriority minimumPriority)
-{
-    LOG(NetworkScheduling, "(WebProcess) WebResourceLoadScheduler::servePendingRequests");
-    
-    // The NetworkProcess scheduler is good at making sure loads are serviced until there are no more pending requests.
-    // If this WebProcess isn't expecting requests to be served then we can ignore messaging the NetworkProcess right now.
-    if (m_suspendPendingRequestsCount)
-        return;
-
-    WebProcess::singleton().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::ServePendingRequests(minimumPriority), 0);
+void WebResourceLoadScheduler::servePendingRequests(ResourceLoadPriority)
+{
+    // This overrides the base class version.
+    // We don't need to do anything as this is handled by the network process.
 }
 

trunk/Source/WebKit2/WebProcess/Network/WebResourceLoadScheduler.h

@@ -53 +53 @@
     virtual void crossOriginRedirectReceived(WebCore::ResourceLoader*, const WebCore::URL& redirectURL) override;
     
-    virtual void servePendingRequests(WebCore::ResourceLoadPriority minimumPriority = WebCore::ResourceLoadPriorityVeryLow) override;
+    virtual void servePendingRequests(WebCore::ResourceLoadPriority minimumPriority) override;
 
     virtual void suspendPendingRequests() override;