Oilpan: enable appcache + move DocumentLoader to the heap.

Source/core/loader/DocumentLoader.h

 /*
  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 30 matching lines @@
 #include "core/loader/DocumentWriter.h"
 #include "core/loader/FrameLoaderTypes.h"
 #include "core/loader/NavigationPolicy.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
 #include "wtf/HashSet.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
+
     class ApplicationCacheHost;
     class ResourceFetcher;
     class DocumentInit;
     class LocalFrame;
     class FrameLoader;
     class MHTMLArchive;
     class ResourceLoader;
     class ThreadedDataReceiver;
 
-    class CORE_EXPORT DocumentLoader : public RefCounted<DocumentLoader>, private RawResourceClient {
-        WTF_MAKE_FAST_ALLOCATED(DocumentLoader);
+    class CORE_EXPORT DocumentLoader : public RefCountedWillBeGarbageCollectedFinalized<DocumentLoader>, private RawResourceClient {
+        WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(DocumentLoader);
     public:
-        static PassRefPtr<DocumentLoader> create(LocalFrame* frame, const ResourceRequest& request, const SubstituteData& data)
+        static PassRefPtrWillBeRawPtr<DocumentLoader> create(LocalFrame* frame, const ResourceRequest& request, const SubstituteData& data)
         {
-            return adoptRef(new DocumentLoader(frame, request, data));
+            return adoptRefWillBeNoop(new DocumentLoader(frame, request, data));
         }
         virtual ~DocumentLoader();
 
         LocalFrame* frame() const { return m_frame; }
 
-        void detachFromFrame();
+        virtual void detachFromFrame();
 
         unsigned long mainResourceIdentifier() const;
 
         void replaceDocumentWhileExecutingJavaScriptURL(const DocumentInit&, const String& source, Document*);
 
         const AtomicString& mimeType() const;
 
         const ResourceRequest& originalRequest() const;
 
         const ResourceRequest& request() const;
@@ skipping 52 matching lines @@
 
             // TODO(skobes): Move FrameView::m_wasScrolledByUser into here.
             bool didRestoreFromHistory;
         };
         InitialScrollState& initialScrollState() { return m_initialScrollState; }
 
         bool loadingMultipartContent() const;
 
         void startPreload(Resource::Type, FetchRequest&);
 
+        EAGERLY_FINALIZE();

[haraken, 2015/06/22 01:57:58]

Can we add a comment for why this needs to be eagerly finalized?

[sof, 2015/06/22 06:49:18]

I've removed it, as DocumentLoader currently requires that an explicit detach is
first called. We can take care of the 'eager' operations via that detach
operation instead.

+        DECLARE_VIRTUAL_TRACE();
+
     protected:
         DocumentLoader(LocalFrame*, const ResourceRequest&, const SubstituteData&);
 
         Vector<KURL> m_redirectChain;
 
     private:
         static PassRefPtrWillBeRawPtr<DocumentWriter> createWriterFor(const Document* ownerDocument, const DocumentInit&, const AtomicString& mimeType, const AtomicString& encoding, bool dispatch, ParserSynchronizationPolicy);
 
         void ensureWriter(const AtomicString& mimeType, const KURL& overridingURL = KURL());
         void endWriting(DocumentWriter*);
@@ skipping 20 matching lines @@
         virtual void responseReceived(Resource*, const ResourceResponse&, PassOwnPtr<WebDataConsumerHandle>) override final;
         virtual void dataReceived(Resource*, const char* data, unsigned length) override final;
         virtual void notifyFinished(Resource*) override final;
 
         bool maybeLoadEmpty();
 
         bool isRedirectAfterPost(const ResourceRequest&, const ResourceResponse&);
 
         bool shouldContinueForResponse() const;
 
         LocalFrame* m_frame;

[haraken, 2015/06/22 01:57:58]

Can we make this a Member?

[sof, 2015/06/22 06:49:18]

Done.

-        RefPtrWillBePersistent<ResourceFetcher> m_fetcher;
+        RefPtrWillBeMember<ResourceFetcher> m_fetcher;
 
         ResourcePtr<RawResource> m_mainResource;
 
-        RefPtrWillBePersistent<DocumentWriter> m_writer;
+        RefPtrWillBeMember<DocumentWriter> m_writer;
 
         // A reference to actual request used to create the data source.
         // The only part of this request that should change is the url, and
         // that only in the case of a same-document navigation.
         ResourceRequest m_originalRequest;
 
         SubstituteData m_substituteData;
 
         // The 'working' request. It may be mutated
         // several times from the original request to include additional
         // headers, cookie information, canonicalization and redirects.
         ResourceRequest m_request;
 
         ResourceResponse m_response;
 
         ResourceError m_mainDocumentError;
 
         bool m_committed;
         bool m_isClientRedirect;
         bool m_replacesCurrentHistoryItem;
 
         NavigationType m_navigationType;
 
-        RefPtrWillBePersistent<MHTMLArchive> m_archive;
+        RefPtrWillBeMember<MHTMLArchive> m_archive;
 
         bool m_loadingMainResource;
         DocumentLoadTiming m_documentLoadTiming;
 
         double m_timeOfLastDataReceived;
 
-        friend class ApplicationCacheHost;  // for substitute resource delivery
-        OwnPtrWillBePersistent<ApplicationCacheHost> m_applicationCacheHost;
+        PersistentWillBeMember<ApplicationCacheHost> m_applicationCacheHost;
 
         RefPtr<ContentSecurityPolicy> m_contentSecurityPolicy;
         ClientHintsPreferences m_clientHintsPreferences;
         InitialScrollState m_initialScrollState;
     };
-}
+
+} // namespace blink
 
 #endif // DocumentLoader_h