Oilpan: Remove WillBe types (part 9)

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 207 matching lines @@
 {
     if (!m_context)
         return nullptr;
 
     return m_context->loadingTaskRunner();
 }
 
 Resource* ResourceFetcher::cachedResource(const KURL& resourceURL) const
 {
     KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(resourceURL);
-    const WeakPtrWillBeWeakMember<Resource>& resource = m_documentResources.get(url);
+    const WeakMember<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->getType(), resource->resourceRequest(), url, resource->options(), forPreload, FetchRequest::UseDefaultOriginRestrictionForType))
         return false;
 
@@ skipping 56 matching lines @@
     m_validatedURLs.add(request.resourceRequest().url());
 }
 
 static PassOwnPtr<TracedValue> urlForTraceEvent(const KURL& url)
 {
     OwnPtr<TracedValue> value = TracedValue::create();
     value->setString("url", url.getString());
     return value.release();
 }
 
-PassRefPtrWillBeRawPtr<Resource> ResourceFetcher::resourceForStaticData(const FetchRequest& request, const ResourceFactory& factory, const SubstituteData& substituteData)
+RawPtr<Resource> ResourceFetcher::resourceForStaticData(const FetchRequest& request, const ResourceFactory& factory, const SubstituteData& substituteData)
 {
     const KURL& url = request.resourceRequest().url();
     ASSERT(url.protocolIsData() || substituteData.isValid() || m_archive);
 
     // TODO(japhet): We only send main resource data: urls through WebURLLoader for the benefit of
     // a service worker test (RenderViewImplTest.ServiceWorkerNetworkProviderSetup), which is at a
     // layer where it isn't easy to mock out a network load. It uses data: urls to emulate the
     // behavior it wants to test, which would otherwise be reserved for network loads.
     if (!m_archive && !substituteData.isValid() && (factory.type() == Resource::MainResource || factory.type() == Resource::Raw))
         return nullptr;
@@ skipping 24 matching lines @@
             return nullptr;
         mimetype = archiveResource->mimeType();
         charset = archiveResource->textEncoding();
         data = archiveResource->data();
     }
 
     ResourceResponse response(url, mimetype, data->size(), charset, String());
     response.setHTTPStatusCode(200);
     response.setHTTPStatusText("OK");
 
-    RefPtrWillBeRawPtr<Resource> resource = factory.create(request.resourceRequest(), request.options(), request.charset());
+    RawPtr<Resource> resource = factory.create(request.resourceRequest(), request.options(), request.charset());
     resource->setNeedsSynchronousCacheHit(substituteData.forceSynchronousLoad());
     // FIXME: We should provide a body stream here.
     resource->responseReceived(response, nullptr);
     resource->setDataBufferingPolicy(BufferData);
     if (data->size())
         resource->setResourceBuffer(data);
     resource->setIdentifier(createUniqueIdentifier());
     resource->setCacheIdentifier(cacheIdentifier);
     resource->finish();
 
@@ skipping 28 matching lines @@
 
     // Aims to count Resource only referenced from MemoryCache (i.e. what
     // would be dead if MemoryCache holds weak references to Resource).
     // Currently we check references to Resource from ResourceClient and
     // |m_preloads| only, because they are major sources of references.
     if (resource && !resource->hasClientsOrObservers() && (!m_preloads || !m_preloads->contains(resource))) {
         DEFINE_RESOURCE_HISTOGRAM("Dead.");
     }
 }
 
-PassRefPtrWillBeRawPtr<Resource> ResourceFetcher::requestResource(FetchRequest& request, const ResourceFactory& factory, const SubstituteData& substituteData)
+RawPtr<Resource> ResourceFetcher::requestResource(FetchRequest& request, const ResourceFactory& factory, const SubstituteData& substituteData)
 {
     ASSERT(request.options().synchronousPolicy == RequestAsynchronously || factory.type() == Resource::Raw || factory.type() == Resource::XSLStyleSheet);
 
     context().upgradeInsecureRequest(request);
     context().addClientHintsIfNecessary(request);
     context().addCSPHeaderIfNecessary(factory.type(), request);
 
     KURL url = request.resourceRequest().url();
     TRACE_EVENT1("blink", "ResourceFetcher::requestResource", "url", urlForTraceEvent(url));
 
@@ skipping 17 matching lines @@
 
         if (activityLogger) {
             Vector<String> argv;
             argv.append(Resource::resourceTypeToString(factory.type(), request.options().initiatorInfo));
             argv.append(url);
             activityLogger->logEvent("blinkRequestResource", argv.size(), argv.data());
         }
     }
 
     bool isStaticData = request.resourceRequest().url().protocolIsData() || substituteData.isValid() || m_archive;
-    RefPtrWillBeRawPtr<Resource> resource(nullptr);
+    RawPtr<Resource> resource(nullptr);
     if (isStaticData)
         resource = resourceForStaticData(request, factory, substituteData);
     if (!resource)
         resource = memoryCache()->resourceForURL(url, getCacheIdentifier());
 
     // See if we can use an existing resource from the cache. If so, we need to move it to be load blocking.
     moveCachedNonBlockingResourceToBlocking(resource.get(), request);
 
     const RevalidationPolicy policy = determineRevalidationPolicy(factory.type(), request, resource.get(), isStaticData);
 
@@ skipping 115 matching lines @@
         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())));
     }
 
     resource->setRevalidatingRequest(revalidatingRequest);
 }
 
-PassRefPtrWillBeRawPtr<Resource> ResourceFetcher::createResourceForLoading(FetchRequest& request, const String& charset, const ResourceFactory& factory)
+RawPtr<Resource> ResourceFetcher::createResourceForLoading(FetchRequest& request, const String& charset, const ResourceFactory& factory)
 {
     const String cacheIdentifier = getCacheIdentifier();
     ASSERT(!memoryCache()->resourceForURL(request.resourceRequest().url(), cacheIdentifier));
 
     WTF_LOG(ResourceLoading, "Loading Resource for '%s'.", request.resourceRequest().url().elidedString().latin1().data());
 
-    RefPtrWillBeRawPtr<Resource> resource = factory.create(request.resourceRequest(), request.options(), charset);
+    RawPtr<Resource> resource = factory.create(request.resourceRequest(), request.options(), charset);
     resource->setLinkPreload(request.isLinkPreload());
     resource->setCacheIdentifier(cacheIdentifier);
 
     // Don't add main resource to cache to prevent reuse.
     if (factory.type() != Resource::MainResource)
         memoryCache()->add(resource.get());
     return resource;
 }
 
 void ResourceFetcher::storeResourceTimingInitiatorInformation(Resource* resource)
@@ skipping 256 matching lines @@
 }
 
 void ResourceFetcher::preloadStarted(Resource* resource)
 {
     if (m_preloads && m_preloads->contains(resource))
         return;
     TRACE_EVENT_ASYNC_STEP_INTO0("blink.net", "Resource", resource, "Preload");
     resource->increasePreloadCount();
 
     if (!m_preloads)
-        m_preloads = adoptPtrWillBeNoop(new WillBeHeapListHashSet<RefPtrWillBeMember<Resource>>);
+        m_preloads = adoptPtrWillBeNoop(new HeapListHashSet<Member<Resource>>);
     m_preloads->add(resource);
 
 #if PRELOAD_DEBUG
     printf("PRELOADING %s\n",  resource->url().string().latin1().data());
 #endif
 }
 
 bool ResourceFetcher::isPreloaded(const KURL& url) const
 {
     if (m_preloads) {
@@ skipping 325 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