Refactor FrameLoader loading interface

Source/core/loader/FrameLoader.h

Index: Source/core/loader/FrameLoader.h
diff --git a/Source/core/loader/FrameLoader.h b/Source/core/loader/FrameLoader.h
index 9f575075104c3be4628e253ee493d08b2328ef5f..cb98ae0bfefa600911fde6ee82bc4de5a879bb9b 100644
--- a/Source/core/loader/FrameLoader.h
+++ b/Source/core/loader/FrameLoader.h
@@ -66,21 +66,27 @@ 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);
 
@@ -222,30 +228,31 @@ private:
     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;