Rename enums/functions that collide in chromium style.

third_party/WebKit/Source/core/fetch/ResourceFetcher.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) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
     Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
 
     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 214 matching lines @@
 {
     KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(resourceURL);
     const WeakPtrWillBeWeakMember<Resource>& resource = m_documentResources.get(url);
     return resource.get();
 }
 
 bool ResourceFetcher::canAccessResource(Resource* resource, SecurityOrigin* sourceOrigin, const KURL& url, AccessControlLoggingDecision logErrorsDecision) const
 {
     // Redirects can change the response URL different from one of request.
     bool forPreload = resource->isUnusedPreload();
-    if (!context().canRequest(resource->type(), resource->resourceRequest(), url, resource->options(), forPreload, FetchRequest::UseDefaultOriginRestrictionForType))
+    if (!context().canRequest(resource->getType(), resource->resourceRequest(), url, resource->options(), forPreload, FetchRequest::UseDefaultOriginRestrictionForType))
         return false;
 
     if (!sourceOrigin)
         sourceOrigin = context().securityOrigin();
 
     if (sourceOrigin->canRequestNoSuborigin(url))
         return true;
 
     String errorDescription;
     if (!resource->passesAccessControlCheck(sourceOrigin, errorDescription)) {
         resource->setCORSFailed();
         if (!forPreload && (logErrorsDecision == ShouldLogAccessControlErrors)) {
-            String resourceType = Resource::resourceTypeToString(resource->type(), resource->options().initiatorInfo);
+            String resourceType = Resource::resourceTypeToString(resource->getType(), resource->options().initiatorInfo);
             context().addConsoleMessage(resourceType + " from origin '" + SecurityOrigin::create(url)->toString() + "' has been blocked from loading by Cross-Origin Resource Sharing policy: " + errorDescription);
         }
         return false;
     }
     return true;
 }
 
 bool ResourceFetcher::isControlledByServiceWorker() const
 {
     return context().isControlledByServiceWorker();
 }
 
 bool ResourceFetcher::resourceNeedsLoad(Resource* resource, const FetchRequest& request, RevalidationPolicy policy)
 {
     if (FetchRequest::DeferredByClient == request.defer())
         return false;
     if (policy != Use)
         return true;
     if (resource->stillNeedsLoad())
         return true;
     return request.options().synchronousPolicy == RequestSynchronously && resource->isLoading();
 }
 
 // Limit the number of URLs in m_validatedURLs to avoid memory bloat.
 // http://crbug.com/52411
 static const int kMaxValidatedURLsSize = 10000;
 
 void ResourceFetcher::requestLoadStarted(Resource* resource, const FetchRequest& request, ResourceLoadStartType type, bool isStaticData)
 {
-    if (type == ResourceLoadingFromCache && resource->status() == Resource::Cached && !m_validatedURLs.contains(resource->url()))
+    if (type == ResourceLoadingFromCache && resource->getStatus() == Resource::Cached && !m_validatedURLs.contains(resource->url()))
         context().dispatchDidLoadResourceFromMemoryCache(resource, request.resourceRequest().frameType(), request.resourceRequest().requestContext());
 
     if (isStaticData)
         return;
 
     if (type == ResourceLoadingFromCache && !resource->stillNeedsLoad() && !m_validatedURLs.contains(request.resourceRequest().url())) {
         // Resources loaded from memory cache should be reported the first time they're used.
-        OwnPtr<ResourceTimingInfo> info = ResourceTimingInfo::create(request.options().initiatorInfo.name, monotonicallyIncreasingTime(), resource->type() == Resource::MainResource);
+        OwnPtr<ResourceTimingInfo> info = ResourceTimingInfo::create(request.options().initiatorInfo.name, monotonicallyIncreasingTime(), resource->getType() == Resource::MainResource);
         populateResourceTiming(info.get(), resource, true);
         m_scheduledResourceTimingReports.append(info.release());
         if (!m_resourceTimingReportTimer.isActive())
             m_resourceTimingReportTimer.startOneShot(0, BLINK_FROM_HERE);
     }
 
     if (m_validatedURLs.size() >= kMaxValidatedURLsSize) {
         m_validatedURLs.clear();
     }
     m_validatedURLs.add(request.resourceRequest().url());
@@ skipping 80 matching lines @@
     TRACE_EVENT1("blink", "ResourceFetcher::requestResource", "url", urlForTraceEvent(url));
 
     WTF_LOG(ResourceLoading, "ResourceFetcher::requestResource '%s', charset '%s', priority=%d, forPreload=%u, type=%s", url.elidedString().latin1().data(), request.charset().latin1().data(), request.priority(), request.forPreload(), Resource::resourceTypeName(factory.type()));
 
     // If only the fragment identifiers differ, it is the same resource.
     url = MemoryCache::removeFragmentIdentifierIfNeeded(url);
 
     if (!url.isValid())
         return nullptr;
 
-    if (!context().canRequest(factory.type(), request.resourceRequest(), url, request.options(), request.forPreload(), request.originRestriction()))
+    if (!context().canRequest(factory.type(), request.resourceRequest(), url, request.options(), request.forPreload(), request.getOriginRestriction()))
         return nullptr;
 
     if (!request.forPreload()) {
         V8DOMActivityLogger* activityLogger = nullptr;
         if (request.options().initiatorInfo.name == FetchInitiatorTypeNames::xmlhttprequest)
             activityLogger = V8DOMActivityLogger::currentActivityLogger();
         else
             activityLogger = V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
 
         if (activityLogger) {
@@ skipping 37 matching lines @@
     case Revalidate:
         initializeRevalidation(request, resource.get());
         break;
     case Use:
         memoryCache()->updateForAccess(resource.get());
         break;
     }
 
     if (!resource)
         return nullptr;
-    if (resource->type() != factory.type()) {
+    if (resource->getType() != factory.type()) {
         ASSERT(request.forPreload());
         return nullptr;
     }
 
     if (!resource->hasClients())
         m_deadStatsRecorder.update(policy);
 
     if (policy != Use)
         resource->setIdentifier(createUniqueIdentifier());
 
@@ skipping 64 matching lines @@
     request.setRequestContext(requestContext);
 }
 
 void ResourceFetcher::determineRequestContext(ResourceRequest& request, Resource::Type type)
 {
     determineRequestContext(request, type, context().isMainFrame());
 }
 
 void ResourceFetcher::initializeResourceRequest(ResourceRequest& request, Resource::Type type)
 {
-    if (request.cachePolicy() == UseProtocolCachePolicy)
+    if (request.getCachePolicy() == UseProtocolCachePolicy)
         request.setCachePolicy(context().resourceRequestCachePolicy(request, type));
     if (request.requestContext() == WebURLRequest::RequestContextUnspecified)
         determineRequestContext(request, type);
     if (type == Resource::LinkPrefetch)
         request.setHTTPHeaderField(HTTPNames::Purpose, "prefetch");
 
     context().addAdditionalRequestHeaders(request, (type == Resource::MainResource) ? FetchMainResource : FetchSubresource);
 }
 
 void ResourceFetcher::initializeRevalidation(const FetchRequest& request, Resource* resource)
 {
     ASSERT(resource);
     ASSERT(memoryCache()->contains(resource));
     ASSERT(resource->isLoaded());
     ASSERT(resource->canUseCacheValidator());
     ASSERT(!resource->isCacheValidator());
     ASSERT(!context().isControlledByServiceWorker());
 
     ResourceRequest revalidatingRequest(resource->resourceRequest());
     revalidatingRequest.clearHTTPReferrer();
-    initializeResourceRequest(revalidatingRequest, resource->type());
+    initializeResourceRequest(revalidatingRequest, resource->getType());
 
     const AtomicString& lastModified = resource->response().httpHeaderField(HTTPNames::Last_Modified);
     const AtomicString& eTag = resource->response().httpHeaderField(HTTPNames::ETag);
     if (!lastModified.isEmpty() || !eTag.isEmpty()) {
-        ASSERT(context().cachePolicy() != CachePolicyReload);
-        if (context().cachePolicy() == CachePolicyRevalidate)
+        ASSERT(context().getCachePolicy() != CachePolicyReload);
+        if (context().getCachePolicy() == CachePolicyRevalidate)
             revalidatingRequest.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=0");
     }
     if (!lastModified.isEmpty())
         revalidatingRequest.setHTTPHeaderField(HTTPNames::If_Modified_Since, lastModified);
     if (!eTag.isEmpty())
         revalidatingRequest.setHTTPHeaderField(HTTPNames::If_None_Match, eTag);
 
     double stalenessLifetime = resource->stalenessLifetime();
     if (std::isfinite(stalenessLifetime) && stalenessLifetime > 0) {
         revalidatingRequest.setHTTPHeaderField(HTTPNames::Resource_Freshness, AtomicString(String::format("max-age=%.0lf,stale-while-revalidate=%.0lf,age=%.0lf", resource->freshnessLifetime(), stalenessLifetime, resource->currentAge())));
@@ skipping 16 matching lines @@
 
     memoryCache()->add(resource.get());
     return resource;
 }
 
 void ResourceFetcher::storeResourceTimingInitiatorInformation(Resource* resource)
 {
     if (resource->options().initiatorInfo.name == FetchInitiatorTypeNames::internal)
         return;
 
-    OwnPtr<ResourceTimingInfo> info = ResourceTimingInfo::create(resource->options().initiatorInfo.name, monotonicallyIncreasingTime(), resource->type() == Resource::MainResource);
+    OwnPtr<ResourceTimingInfo> info = ResourceTimingInfo::create(resource->options().initiatorInfo.name, monotonicallyIncreasingTime(), resource->getType() == Resource::MainResource);
 
     if (resource->isCacheValidator()) {
         const AtomicString& timingAllowOrigin = resource->response().httpHeaderField(HTTPNames::Timing_Allow_Origin);
         if (!timingAllowOrigin.isEmpty())
             info->setOriginalTimingAllowOrigin(timingAllowOrigin);
     }
 
-    if (resource->type() != Resource::MainResource || context().updateTimingInfoForIFrameNavigation(info.get()))
+    if (resource->getType() != Resource::MainResource || context().updateTimingInfoForIFrameNavigation(info.get()))
         m_resourceTimingInfoMap.add(resource, info.release());
 }
 
 ResourceFetcher::RevalidationPolicy ResourceFetcher::determineRevalidationPolicy(Resource::Type type, const FetchRequest& fetchRequest, Resource* existingResource, bool isStaticData) const
 {
     const ResourceRequest& request = fetchRequest.resourceRequest();
 
     if (!existingResource)
         return Load;
 
@@ skipping 22 matching lines @@
 
     // Service Worker's CORS fallback message must not be cached.
     if (existingResource->response().wasFallbackRequiredByServiceWorker())
         return Reload;
 
     // We already have a preload going for this URL.
     if (fetchRequest.forPreload() && existingResource->isPreloaded())
         return Use;
 
     // If the same URL has been loaded as a different type, we need to reload.
-    if (existingResource->type() != type) {
+    if (existingResource->getType() != type) {
         // FIXME: If existingResource is a Preload and the new type is LinkPrefetch
         // We really should discard the new prefetch since the preload has more
         // specific type information! crbug.com/379893
         // fast/dom/HTMLLinkElement/link-and-subresource-test hits this case.
         WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicy reloading due to type mismatch.");
         return Reload;
     }
 
     // Do not load from cache if images are not enabled. The load for this image will be blocked
     // in ImageResource::load.
@@ skipping 15 matching lines @@
     // Certain requests (e.g., XHRs) might have manually set headers that require revalidation.
     // FIXME: In theory, this should be a Revalidate case. In practice, the MemoryCache revalidation path assumes a whole bunch
     // of things about how revalidation works that manual headers violate, so punt to Reload instead.
     if (request.isConditional())
         return Reload;
 
     // Don't reload resources while pasting.
     if (m_allowStaleResources)
         return Use;
 
-    if (request.cachePolicy() == ResourceRequestCachePolicy::ReloadBypassingCache)
+    if (request.getCachePolicy() == ResourceRequestCachePolicy::ReloadBypassingCache)
         return Reload;
 
     if (!fetchRequest.options().canReuseRequest(existingResource->options()))
         return Reload;
 
     // Always use preloads.
     if (existingResource->isPreloaded())
         return Use;
 
     // CachePolicyHistoryBuffer uses the cache no matter what.
-    CachePolicy cachePolicy = context().cachePolicy();
+    CachePolicy cachePolicy = context().getCachePolicy();
     if (cachePolicy == CachePolicyHistoryBuffer)
         return Use;
 
     // Don't reuse resources with Cache-control: no-store.
     if (existingResource->hasCacheControlNoStoreHeader()) {
         WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicy reloading due to Cache-control: no-store.");
         return Reload;
     }
 
     // If credentials were sent with the previous request and won't be
@@ skipping 108 matching lines @@
     return clientDefersImage(url) || !m_autoLoadImages;
 }
 
 void ResourceFetcher::reloadImagesIfNotDeferred()
 {
     // TODO(japhet): Once oilpan ships, the const auto&
     // can be replaced with a Resource*. Also, null checking
     // the resource probably won't be necesssary.
     for (const auto& documentResource : m_documentResources) {
         Resource* resource = documentResource.value.get();
-        if (resource && resource->type() == Resource::Image && resource->stillNeedsLoad() && !clientDefersImage(resource->url()))
+        if (resource && resource->getType() == Resource::Image && resource->stillNeedsLoad() && !clientDefersImage(resource->url()))
             const_cast<Resource*>(resource)->load(this, defaultResourceOptions());
     }
 }
 
 void ResourceFetcher::redirectReceived(Resource* resource, const ResourceResponse& redirectResponse)
 {
     ResourceTimingInfoMap::iterator it = m_resourceTimingInfoMap.find(resource);
     if (it != m_resourceTimingInfoMap.end())
         it->value->addRedirect(redirectResponse);
 }
@@ skipping 39 matching lines @@
 void ResourceFetcher::clearPreloads(ClearPreloadsPolicy policy)
 {
 #if PRELOAD_DEBUG
     printPreloadStats();
 #endif
     if (!m_preloads)
         return;
 
     for (auto resource : *m_preloads) {
         resource->decreasePreloadCount();
-        if (resource->preloadResult() == Resource::PreloadNotReferenced && (policy == ClearAllPreloads || !resource->isLinkPreload()))
+        if (resource->getPreloadResult() == Resource::PreloadNotReferenced && (policy == ClearAllPreloads || !resource->isLinkPreload()))
             memoryCache()->remove(resource.get());
     }
     m_preloads.clear();
 }
 
 ArchiveResource* ResourceFetcher::createArchive(Resource* resource)
 {
     // Only the top-frame can load MHTML.
     if (!context().isMainFrame())
         return nullptr;
     m_archive = MHTMLArchive::create(resource->url(), resource->resourceBuffer());
     return m_archive ? m_archive->mainResource() : nullptr;
 }
 
 bool ResourceFetcher::scheduleArchiveLoad(Resource* resource, const ResourceRequest& request)
 {
-    if (resource->type() == Resource::MainResource && !context().isMainFrame())
+    if (resource->getType() == Resource::MainResource && !context().isMainFrame())
         m_archive = context().archive();
 
     if (!m_archive)
         return false;
 
     ArchiveResource* archiveResource = m_archive->subresourceForURL(request.url());
     if (!archiveResource) {
         resource->error(Resource::LoadError);
         return false;
     }
@@ skipping 39 matching lines @@
     context().dispatchWillSendRequest(identifier, request, redirectResponse, initiatorInfo);
 }
 
 void ResourceFetcher::didReceiveResponse(const Resource* resource, const ResourceResponse& response)
 {
     // If the response is fetched via ServiceWorker, the original URL of the response could be different from the URL of the request.
     // We check the URL not to load the resources which are forbidden by the page CSP.
     // https://w3c.github.io/webappsec-csp/#should-block-response
     if (response.wasFetchedViaServiceWorker()) {
         const KURL& originalURL = response.originalURLViaServiceWorker();
-        if (!originalURL.isEmpty() && !context().allowResponse(resource->type(), resource->resourceRequest(), originalURL, resource->options())) {
+        if (!originalURL.isEmpty() && !context().allowResponse(resource->getType(), resource->resourceRequest(), originalURL, resource->options())) {
             resource->loader()->cancel();
             bool isInternalRequest = resource->options().initiatorInfo.name == FetchInitiatorTypeNames::internal;
             context().dispatchDidFail(resource->identifier(), ResourceError(errorDomainBlinkInternal, 0, originalURL.string(), "Unsafe attempt to load URL " + originalURL.elidedString() + " fetched by a ServiceWorker."), isInternalRequest);
             return;
         }
     }
     context().dispatchDidReceiveResponse(resource->identifier(), response, resource->resourceRequest().frameType(), resource->resourceRequest().requestContext(), resource->loader());
 }
 
 void ResourceFetcher::didReceiveData(const Resource* resource, const char* data, int dataLength, int encodedDataLength)
@@ skipping 76 matching lines @@
     return context().defersLoading();
 }
 
 bool ResourceFetcher::isLoadedBy(ResourceFetcher* possibleOwner) const
 {
     return this == possibleOwner;
 }
 
 bool ResourceFetcher::canAccessRedirect(Resource* resource, ResourceRequest& newRequest, const ResourceResponse& redirectResponse, ResourceLoaderOptions& options)
 {
-    if (!context().canRequest(resource->type(), newRequest, newRequest.url(), options, resource->isUnusedPreload(), FetchRequest::UseDefaultOriginRestrictionForType))
+    if (!context().canRequest(resource->getType(), newRequest, newRequest.url(), options, resource->isUnusedPreload(), FetchRequest::UseDefaultOriginRestrictionForType))
         return false;
     if (options.corsEnabled == IsCORSEnabled) {
         SecurityOrigin* sourceOrigin = options.securityOrigin.get();
         if (!sourceOrigin)
             sourceOrigin = context().securityOrigin();
 
         String errorMessage;
         StoredCredentials withCredentials = resource->lastResourceRequest().allowStoredCredentials() ? AllowStoredCredentials : DoNotAllowStoredCredentials;
         if (!CrossOriginAccessControl::handleRedirect(sourceOrigin, newRequest, redirectResponse, withCredentials, options, errorMessage)) {
             resource->setCORSFailed();
             context().addConsoleMessage(errorMessage);
             return false;
         }
     }
-    if (resource->type() == Resource::Image && shouldDeferImageLoad(newRequest.url()))
+    if (resource->getType() == Resource::Image && shouldDeferImageLoad(newRequest.url()))
         return false;
     return true;
 }
 
 void ResourceFetcher::updateAllImageResourcePriorities()
 {
     if (!m_loaders)
         return;
 
     TRACE_EVENT0("blink", "ResourceLoadPriorityOptimizer::updateAllImageResourcePriorities");
@@ skipping 32 matching lines @@
     if (!m_preloads)
         return;
 
     unsigned scripts = 0;
     unsigned scriptMisses = 0;
     unsigned stylesheets = 0;
     unsigned stylesheetMisses = 0;
     unsigned images = 0;
     unsigned imageMisses = 0;
     for (auto resource : *m_preloads) {
-        if (resource->preloadResult() == Resource::PreloadNotReferenced)
+        if (resource->getPreloadResult() == Resource::PreloadNotReferenced)
             printf("!! UNREFERENCED PRELOAD %s\n", resource->url().string().latin1().data());
-        else if (resource->preloadResult() == Resource::PreloadReferencedWhileComplete)
+        else if (resource->getPreloadResult() == Resource::PreloadReferencedWhileComplete)
             printf("HIT COMPLETE PRELOAD %s\n", resource->url().string().latin1().data());
-        else if (resource->preloadResult() == Resource::PreloadReferencedWhileLoading)
+        else if (resource->getPreloadResult() == Resource::PreloadReferencedWhileLoading)
             printf("HIT LOADING PRELOAD %s\n", resource->url().string().latin1().data());
 
-        if (resource->type() == Resource::Script) {
+        if (resource->getType() == Resource::Script) {
             scripts++;
-            if (resource->preloadResult() < Resource::PreloadReferencedWhileLoading)
+            if (resource->getPreloadResult() < Resource::PreloadReferencedWhileLoading)
                 scriptMisses++;
-        } else if (resource->type() == Resource::CSSStyleSheet) {
+        } else if (resource->getType() == Resource::CSSStyleSheet) {
             stylesheets++;
-            if (resource->preloadResult() < Resource::PreloadReferencedWhileLoading)
+            if (resource->getPreloadResult() < Resource::PreloadReferencedWhileLoading)
                 stylesheetMisses++;
         } else {
             images++;
-            if (resource->preloadResult() < Resource::PreloadReferencedWhileLoading)
+            if (resource->getPreloadResult() < Resource::PreloadReferencedWhileLoading)
                 imageMisses++;
         }
 
         if (resource->errorOccurred())
             memoryCache()->remove(resource.get());
 
         resource->decreasePreloadCount();
     }
     m_preloads.clear();
 
@@ skipping 59 matching lines @@
     visitor->trace(m_loaders);
     visitor->trace(m_nonBlockingLoaders);
 #if ENABLE(OILPAN)
     visitor->trace(m_documentResources);
     visitor->trace(m_preloads);
     visitor->trace(m_resourceTimingInfoMap);
 #endif
 }
 
 } // namespace blink