Refactor FrameLoader loading interface

Source/core/loader/FrameLoader.h

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) Research In Motion Limited 2009. 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:
  *
@@ skipping 48 matching lines @@
 class SubstituteData;
 
 struct FrameLoadRequest;
 
 CORE_EXPORT bool isBackForwardLoadType(FrameLoadType);
 
 class CORE_EXPORT FrameLoader final {
     WTF_MAKE_NONCOPYABLE(FrameLoader);
     DISALLOW_ALLOCATION();
 public:
-    static ResourceRequest requestFromHistoryItem(HistoryItem*, ResourceRequestCachePolicy);
+    static ResourceRequest resourceRequestFromHistoryItem(HistoryItem*, ResourceRequestCachePolicy);
+    static FrameLoadRequest frameRequestForReload(

[Nate Chapin, 2015/06/04 23:23:09]

I'm not convinced this helper does enough to be worthwhile, but I don't feel
strongly.

[clamy, 2015/06/05 14:11:48]

I removed it.

+        const ResourceRequest&, ClientRedirectPolicy = NotClientRedirect);
 
     FrameLoader(LocalFrame*);
     ~FrameLoader();
 
     void init();
 
+    ResourceRequest resourceRequestForReload(FrameLoadType, const KURL& overrideURL = KURL(),
+        ClientRedirectPolicy = NotClientRedirect);
+
     ProgressTracker& progress() const { return *m_progressTracker; }
 
-    // These functions start a load. All eventually call into startLoad() or loadInSameDocument().
-    void load(const FrameLoadRequest&); // The entry point for non-reload, non-history loads.
-    void reload(ReloadPolicy, const KURL& overrideURL = KURL(), ClientRedirectPolicy = NotClientRedirect);
-    void loadHistoryItem(HistoryItem*, FrameLoadType = FrameLoadTypeBackForward,
-        HistoryLoadType = HistoryDifferentDocumentLoad,
-        ResourceRequestCachePolicy = UseProtocolCachePolicy); // The entry point for all back/forward loads
+    // Starts a load. It will eventually call startLoad() or
+    // loadInSameDocument(). For history navigations or reloads, an appropriate
+    // FrameLoadType should be given. Otherwise, FrameLoadTypeStandard should be
+    // used (and the final FrameLoadType will be computed). For history
+    // navigations, a history item and a HistoryLoadType should also be provided.
+    void load(const FrameLoadRequest&, FrameLoadType = FrameLoadTypeStandard,
+        HistoryItem* = nullptr, HistoryLoadType = HistoryDifferentDocumentLoad);
 
     static void reportLocalLoadFailed(LocalFrame*, const String& url);
 
     // Warning: stopAllLoaders can and will detach the LocalFrame out from under you. All callers need to either protect the LocalFrame
     // or guarantee they won't in any way access the LocalFrame after stopAllLoaders returns.
     void stopAllLoaders();
 
     // FIXME: clear() is trying to do too many things. We should break it down into smaller functions.
     void clear();
 
@@ skipping 121 matching lines @@
     // E.g. while a new request is in the "policy" state, the old document loader may
     // be consulted in particular as it makes sense to imply certain settings on the new loader.
     RefPtr<DocumentLoader> m_documentLoader;
     RefPtr<DocumentLoader> m_provisionalDocumentLoader;
     RefPtr<DocumentLoader> m_policyDocumentLoader;
 
     RefPtrWillBeMember<HistoryItem> m_currentItem;
     RefPtrWillBeMember<HistoryItem> m_provisionalItem;
 
     struct DeferredHistoryLoad {
-        DISALLOW_ALLOCATION();
+        DISALLOW_COPY(DeferredHistoryLoad);
     public:
-        DeferredHistoryLoad(HistoryItem* item, HistoryLoadType type, ResourceRequestCachePolicy cachePolicy)
-            : m_item(item)
-            , m_type(type)
-            , m_cachePolicy(cachePolicy)
+        DeferredHistoryLoad(ResourceRequest request, HistoryItem* item, FrameLoadType loadType,
+            HistoryLoadType historyLoadType)
+            : m_request(request)
+            , m_item(item)
+            , m_loadType(loadType)
+            , m_historyLoadType(historyLoadType)
         {
         }
 
         DeferredHistoryLoad() { }
 
-        bool isValid() { return m_item; }
-
         DEFINE_INLINE_TRACE()
         {
             visitor->trace(m_item);
         }
 
+        ResourceRequest m_request;
         RefPtrWillBeMember<HistoryItem> m_item;
-        HistoryLoadType m_type;
-        ResourceRequestCachePolicy m_cachePolicy;
+        FrameLoadType m_loadType;
+        HistoryLoadType m_historyLoadType;
     };
 
-    DeferredHistoryLoad m_deferredHistoryLoad;
+    OwnPtr<DeferredHistoryLoad> m_deferredHistoryLoad;
 
     bool m_inStopAllLoaders;
 
     Timer<FrameLoader> m_checkTimer;
 
     bool m_didAccessInitialDocument;
     Timer<FrameLoader> m_didAccessInitialDocumentTimer;
 
     SandboxFlags m_forcedSandboxFlags;
 
     bool m_dispatchingDidClearWindowObjectInMainWorld;
 };
 
 } // namespace blink
 
 #endif // FrameLoader_h