Oilpan: Prepare to move ResourceLoader and ResourceLoaderSet to Oilpan heap.

Also, this CL adds missing ResourceLoaderSet factory.

BUG=393516

Review URL: https://codereview.chromium.org/414423003

git-svn-id: svn://svn.chromium.org/blink/trunk@179120 bbb929c8-8fbe-4397-9dbb-9b2b20218538

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

@@ -157,6 +157,7 @@ void Resource::dispose()
 
 void Resource::trace(Visitor* visitor)
 {
+    visitor->trace(m_loader);
     visitor->trace(m_resourceToRevalidate);
     visitor->trace(m_proxyResource);
 }

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

@@ -326,7 +326,7 @@ protected:
 
     ResourceRequest m_resourceRequest;
     AtomicString m_accept;
-    RefPtr<ResourceLoader> m_loader;
+    RefPtrWillBeMember<ResourceLoader> m_loader;
     ResourceLoaderOptions m_options;
 
     ResourceResponse m_response;

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

@@ -1344,7 +1344,7 @@ void ResourceFetcher::didDownloadData(const Resource* resource, int dataLength,
 void ResourceFetcher::subresourceLoaderFinishedLoadingOnePart(ResourceLoader* loader)
 {
     if (!m_multipartLoaders)
-        m_multipartLoaders = adoptPtr(new ResourceLoaderSet());
+        m_multipartLoaders = ResourceLoaderSet::create();
     m_multipartLoaders->add(loader);
     m_loaders->remove(loader);
     if (LocalFrame* frame = this->frame())
@@ -1356,7 +1356,7 @@ void ResourceFetcher::didInitializeResourceLoader(ResourceLoader* loader)
     if (!m_document)
         return;
     if (!m_loaders)
-        m_loaders = adoptPtr(new ResourceLoaderSet());
+        m_loaders = ResourceLoaderSet::create();
     ASSERT(!m_loaders->contains(loader));
     m_loaders->add(loader);
 }
@@ -1540,6 +1540,8 @@ void ResourceFetcher::DeadResourceStatsRecorder::update(RevalidationPolicy polic
 void ResourceFetcher::trace(Visitor* visitor)
 {
     visitor->trace(m_document);
+    visitor->trace(m_loaders);
+    visitor->trace(m_multipartLoaders);
     ResourceLoaderHost::trace(visitor);
 }
 

third_party/WebKit/Source/core/fetch/ResourceFetcher.h

@@ -222,8 +222,8 @@ private:
 
     HashMap<RefPtr<ResourceTimingInfo>, bool> m_scheduledResourceTimingReports;
 
-    OwnPtr<ResourceLoaderSet> m_loaders;
-    OwnPtr<ResourceLoaderSet> m_multipartLoaders;
+    OwnPtrWillBeMember<ResourceLoaderSet> m_loaders;
+    OwnPtrWillBeMember<ResourceLoaderSet> m_multipartLoaders;
 
     // Used in hit rate histograms.
     class DeadResourceStatsRecorder {

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

@@ -68,9 +68,9 @@ ResourceLoader::RequestCountTracker::RequestCountTracker(const RequestCountTrack
     m_host->incrementRequestCount(m_resource);
 }
 
-PassRefPtr<ResourceLoader> ResourceLoader::create(ResourceLoaderHost* host, Resource* resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
+PassRefPtrWillBeRawPtr<ResourceLoader> ResourceLoader::create(ResourceLoaderHost* host, Resource* resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
 {
-    RefPtr<ResourceLoader> loader(adoptRef(new ResourceLoader(host, resource, options)));
+    RefPtrWillBeRawPtr<ResourceLoader> loader(adoptRefWillBeNoop(new ResourceLoader(host, resource, options)));
     loader->init(request);
     return loader.release();
 }
@@ -92,6 +92,12 @@ ResourceLoader::~ResourceLoader()
     ASSERT(m_state == Terminated);
 }
 
+void ResourceLoader::trace(Visitor* visitor)
+{
+    visitor->trace(m_host);
+    visitor->trace(m_resource);
+}
+
 void ResourceLoader::releaseResources()
 {
     ASSERT(m_state != Terminated);
@@ -109,7 +115,7 @@ void ResourceLoader::releaseResources()
     // deallocated and release the last reference to this object.
     // We need to retain to avoid accessing the object after it
     // has been deallocated and also to avoid reentering this method.
-    RefPtr<ResourceLoader> protector(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protector(this);
 
     m_host.clear();
     m_state = Terminated;
@@ -200,7 +206,7 @@ void ResourceLoader::attachThreadedDataReceiver(PassOwnPtr<blink::WebThreadedDat
 
 void ResourceLoader::didDownloadData(blink::WebURLLoader*, int length, int encodedDataLength)
 {
-    RefPtr<ResourceLoader> protect(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     RELEASE_ASSERT(m_connectionState == ConnectionStateReceivedResponse);
     m_host->didDownloadData(m_resource, length, encodedDataLength);
     m_resource->didDownloadData(length);
@@ -253,7 +259,7 @@ void ResourceLoader::cancel(const ResourceError& error)
 
     // This function calls out to clients at several points that might do
     // something that causes the last reference to this object to go away.
-    RefPtr<ResourceLoader> protector(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protector(this);
 
     WTF_LOG(ResourceLoading, "Cancelled load of '%s'.\n", m_resource->url().string().latin1().data());
     if (m_state == Initialized)
@@ -279,7 +285,7 @@ void ResourceLoader::cancel(const ResourceError& error)
 
 void ResourceLoader::willSendRequest(blink::WebURLLoader*, blink::WebURLRequest& passedRequest, const blink::WebURLResponse& passedRedirectResponse)
 {
-    RefPtr<ResourceLoader> protect(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
 
     ResourceRequest& request(applyOptions(passedRequest.toMutableResourceRequest()));
 
@@ -316,7 +322,7 @@ void ResourceLoader::didReceiveCachedMetadata(blink::WebURLLoader*, const char*
 void ResourceLoader::didSendData(blink::WebURLLoader*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
 {
     ASSERT(m_state == Initialized);
-    RefPtr<ResourceLoader> protect(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     m_resource->didSendData(bytesSent, totalBytesToBeSent);
 }
 
@@ -357,7 +363,7 @@ void ResourceLoader::didReceiveResponse(blink::WebURLLoader*, const blink::WebUR
 
     // Reference the object in this method since the additional processing can do
     // anything including removing the last reference to this object.
-    RefPtr<ResourceLoader> protect(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     m_resource->responseReceived(resourceResponse);
     if (m_state == Terminated)
         return;
@@ -404,7 +410,7 @@ void ResourceLoader::didReceiveData(blink::WebURLLoader*, const char* data, int
 
     // Reference the object in this method since the additional processing can do
     // anything including removing the last reference to this object.
-    RefPtr<ResourceLoader> protect(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
 
     // FIXME: If we get a resource with more than 2B bytes, this code won't do the right thing.
     // However, with today's computers and networking speeds, this won't happen in practice.
@@ -422,7 +428,7 @@ void ResourceLoader::didFinishLoading(blink::WebURLLoader*, double finishTime, i
     ASSERT(m_state != Terminated);
     WTF_LOG(ResourceLoading, "Received '%s'.", m_resource->url().string().latin1().data());
 
-    RefPtr<ResourceLoader> protect(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     ResourcePtr<Resource> protectResource(m_resource);
     m_state = Finishing;
     didFinishLoadingOnePart(finishTime, encodedDataLength);
@@ -441,7 +447,7 @@ void ResourceLoader::didFail(blink::WebURLLoader*, const blink::WebURLError& err
     ASSERT(m_state != Terminated);
     WTF_LOG(ResourceLoading, "Failed to load '%s'.\n", m_resource->url().string().latin1().data());
 
-    RefPtr<ResourceLoader> protect(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     RefPtrWillBeRawPtr<ResourceLoaderHost> protectHost(m_host.get());
     ResourcePtr<Resource> protectResource(m_resource);
     m_state = Finishing;
@@ -473,7 +479,7 @@ void ResourceLoader::requestSynchronously()
     // downloadToFile is not supported for synchronous requests.
     ASSERT(!m_request.downloadToFile());
 
-    RefPtr<ResourceLoader> protect(this);
+    RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     RefPtrWillBeRawPtr<ResourceLoaderHost> protectHost(m_host.get());
     ResourcePtr<Resource> protectResource(m_resource);
 

third_party/WebKit/Source/core/fetch/ResourceLoader.h

@@ -48,10 +48,11 @@ class ResourceError;
 class ResourceResponse;
 class ResourceLoaderHost;
 
-class ResourceLoader FINAL : public RefCounted<ResourceLoader>, protected blink::WebURLLoaderClient {
+class ResourceLoader FINAL : public RefCountedWillBeGarbageCollectedFinalized<ResourceLoader>, protected WebURLLoaderClient {
 public:
-    static PassRefPtr<ResourceLoader> create(ResourceLoaderHost*, Resource*, const ResourceRequest&, const ResourceLoaderOptions&);
+    static PassRefPtrWillBeRawPtr<ResourceLoader> create(ResourceLoaderHost*, Resource*, const ResourceRequest&, const ResourceLoaderOptions&);
     virtual ~ResourceLoader();
+    void trace(Visitor*);
 
     void start();
     void changeToSynchronous();
@@ -112,7 +113,7 @@ private:
     ResourceRequest& applyOptions(ResourceRequest&) const;
 
     OwnPtr<blink::WebURLLoader> m_loader;
-    RefPtrWillBePersistent<ResourceLoaderHost> m_host;
+    RefPtrWillBeMember<ResourceLoaderHost> m_host;
 
     ResourceRequest m_request;
     ResourceRequest m_originalRequest; // Before redirects.
@@ -139,7 +140,7 @@ private:
         ConnectionStateFailed,
     };
 
-    Resource* m_resource;
+    RawPtrWillBeMember<Resource> m_resource;
     ResourceLoaderState m_state;
 
     // Used for sanity checking to make sure we don't experience illegal state

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

@@ -35,9 +35,21 @@
 
 namespace blink {
 
+PassOwnPtrWillBeRawPtr<ResourceLoaderSet> ResourceLoaderSet::create()
+{
+    return adoptPtrWillBeNoop(new ResourceLoaderSet);
+}
+
+void ResourceLoaderSet::trace(Visitor* visitor)
+{
+#if ENABLE(OILPAN)
+    visitor->trace(m_set);
+#endif
+}
+
 void ResourceLoaderSet::cancelAll()
 {
-    Vector<RefPtr<ResourceLoader> > loadersCopy;
+    WillBeHeapVector<RefPtrWillBeMember<ResourceLoader> > loadersCopy;
     copyToVector(m_set, loadersCopy);
     size_t size = loadersCopy.size();
     for (size_t i = 0; i < size; ++i)
@@ -46,7 +58,7 @@ void ResourceLoaderSet::cancelAll()
 
 void ResourceLoaderSet::setAllDefersLoading(bool defers)
 {
-    Vector<RefPtr<ResourceLoader> > loadersCopy;
+    WillBeHeapVector<RefPtrWillBeMember<ResourceLoader> > loadersCopy;
     copyToVector(m_set, loadersCopy);
     size_t size = loadersCopy.size();
     for (size_t i = 0; i < size; ++i)

third_party/WebKit/Source/core/fetch/ResourceLoaderSet.h

@@ -36,14 +36,17 @@
 
 namespace blink {
 
-class ResourceLoaderSet {
+class ResourceLoaderSet FINAL : public NoBaseWillBeGarbageCollected<ResourceLoaderSet> {
 public:
-    typedef HashSet<RefPtr<ResourceLoader> > SetType;
+    typedef WillBeHeapHashSet<RefPtrWillBeMember<ResourceLoader> > SetType;
 
-    void add(const RefPtr<ResourceLoader>& loader) { m_set.add(loader); }
-    void remove(const RefPtr<ResourceLoader>& loader) { m_set.remove(loader); }
+    static PassOwnPtrWillBeRawPtr<ResourceLoaderSet> create();
+    void trace(Visitor*);
+
+    void add(const RefPtrWillBeRawPtr<ResourceLoader>& loader) { m_set.add(loader); }
+    void remove(const RefPtrWillBeRawPtr<ResourceLoader>& loader) { m_set.remove(loader); }
     bool isEmpty() const { return m_set.isEmpty(); }
-    bool contains(const RefPtr<ResourceLoader>& loader) const { return m_set.contains(loader); }
+    bool contains(const RefPtrWillBeRawPtr<ResourceLoader>& loader) const { return m_set.contains(loader); }
     void cancelAll();
     void setAllDefersLoading(bool);