Oilpan: Remove most WillBe types from the code base

third_party/WebKit/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 40 matching lines @@
 namespace blink {
 
 class ApplicationCacheHost;
 class ResourceFetcher;
 class DocumentInit;
 class LocalFrame;
 class FrameLoader;
 class ResourceLoader;
 class ThreadedDataReceiver;
 
-class CORE_EXPORT DocumentLoader : public RefCountedWillBeGarbageCollectedFinalized<DocumentLoader>, private RawResourceClient {
-    USING_FAST_MALLOC_WILL_BE_REMOVED(DocumentLoader);
+class CORE_EXPORT DocumentLoader : public GarbageCollectedFinalized<DocumentLoader>, private RawResourceClient {
 public:
-    static PassRefPtrWillBeRawPtr<DocumentLoader> create(LocalFrame* frame, const ResourceRequest& request, const SubstituteData& data)
+    static RawPtr<DocumentLoader> create(LocalFrame* frame, const ResourceRequest& request, const SubstituteData& data)
     {
-        return adoptRefWillBeNoop(new DocumentLoader(frame, request, data));
+        return (new DocumentLoader(frame, request, data));
     }
     ~DocumentLoader() override;
 
     LocalFrame* frame() const { return m_frame; }
 
     virtual void detachFromFrame();
 
     unsigned long mainResourceIdentifier() const;
 
     void replaceDocumentWhileExecutingJavaScriptURL(const DocumentInit&, const String& source, Document*);
@@ skipping 30 matching lines @@
     bool sentDidFinishLoad() const { return m_state == SentDidFinishLoad; }
 
     NavigationType navigationType() const { return m_navigationType; }
     void setNavigationType(NavigationType navigationType) { m_navigationType = navigationType; }
 
     void setDefersLoading(bool);
 
     void startLoadingMainResource();
     void cancelMainResourceLoad(const ResourceError&);
 
-    void attachThreadedDataReceiver(PassRefPtrWillBeRawPtr<ThreadedDataReceiver>);
+    void attachThreadedDataReceiver(RawPtr<ThreadedDataReceiver>);
     void acceptDataFromThreadedReceiver(const char* data, int dataLength, int encodedDataLength);
     DocumentLoadTiming& timing() { return m_documentLoadTiming; }
     const DocumentLoadTiming& timing() const { return m_documentLoadTiming; }
 
     ApplicationCacheHost* applicationCacheHost() const { return m_applicationCacheHost.get(); }
 
     void clearRedirectChain();
     void appendRedirect(const KURL&);
 
-    PassRefPtrWillBeRawPtr<ContentSecurityPolicy> releaseContentSecurityPolicy() { return m_contentSecurityPolicy.release(); }
+    RawPtr<ContentSecurityPolicy> releaseContentSecurityPolicy() { return m_contentSecurityPolicy.release(); }
 
     ClientHintsPreferences& clientHintsPreferences() { return m_clientHintsPreferences; }
 
     struct InitialScrollState {
         DISALLOW_NEW();
         InitialScrollState()
             : wasScrolledByUser(false)
             , didRestoreFromHistory(false)
         {
         }
 
         bool wasScrolledByUser;
         bool didRestoreFromHistory;
     };
     InitialScrollState& initialScrollState() { return m_initialScrollState; }
 
     bool loadingMultipartContent() const;
 
     Resource* startPreload(Resource::Type, FetchRequest&);
 
     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);
+    static RawPtr<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*);
 
     Document* document() const;
     FrameLoader* frameLoader() const;
 
     void commitIfReady();
     void commitData(const char* bytes, size_t length);
     ResourceLoader* mainResourceLoader() const;
@@ skipping 11 matching lines @@
     void processData(const char* data, size_t length);
     void notifyFinished(Resource*) final;
     String debugName() const override { return "DocumentLoader"; }
 
     bool maybeLoadEmpty();
 
     bool isRedirectAfterPost(const ResourceRequest&, const ResourceResponse&);
 
     bool shouldContinueForResponse() const;
 
-    RawPtrWillBeMember<LocalFrame> m_frame;
-    PersistentWillBeMember<ResourceFetcher> m_fetcher;
+    Member<LocalFrame> m_frame;
+    Member<ResourceFetcher> m_fetcher;
 
-    RefPtrWillBeMember<RawResource> m_mainResource;
+    Member<RawResource> m_mainResource;
 
-    RefPtrWillBeMember<DocumentWriter> m_writer;
+    Member<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;
 
     bool m_isClientRedirect;
     bool m_replacesCurrentHistoryItem;
 
     NavigationType m_navigationType;
 
     DocumentLoadTiming m_documentLoadTiming;
 
     double m_timeOfLastDataReceived;
 
-    PersistentWillBeMember<ApplicationCacheHost> m_applicationCacheHost;
+    Member<ApplicationCacheHost> m_applicationCacheHost;
 
-    RefPtrWillBeMember<ContentSecurityPolicy> m_contentSecurityPolicy;
+    Member<ContentSecurityPolicy> m_contentSecurityPolicy;
     ClientHintsPreferences m_clientHintsPreferences;
     InitialScrollState m_initialScrollState;
 
     enum State {
         NotStarted,
         Provisional,
         Committed,
         DataReceived,
         MainResourceDone,
         SentDidFinishLoad
     };
     State m_state;
 
     // Used to protect against reentrancy into dataReceived().
     bool m_inDataReceived;
     RefPtr<SharedBuffer> m_dataBuffer;
 };
 
 DECLARE_WEAK_IDENTIFIER_MAP(DocumentLoader);
 
 } // namespace blink
 
 #endif // DocumentLoader_h