Move HistoryItem handling to DocumentLoader

third_party/WebKit/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 37 matching lines @@
 #include "platform/loader/fetch/ResourceLoaderOptions.h"
 #include "platform/loader/fetch/ResourceRequest.h"
 #include "public/platform/WebInsecureRequestPolicy.h"
 #include "wtf/Forward.h"
 #include "wtf/HashSet.h"
 
 #include <memory>
 
 namespace blink {
 
+class Document;
 class DocumentLoader;
 class HTMLFormElement;
 class Frame;
 class LocalFrameClient;
 class ProgressTracker;
 class ResourceError;
 class SerializedScriptValue;
 class SubstituteData;
-enum class WebCachePolicy;
 struct FrameLoadRequest;
 
 CORE_EXPORT bool isBackForwardLoadType(FrameLoadType);
 CORE_EXPORT bool isReloadLoadType(FrameLoadType);
 
 class CORE_EXPORT FrameLoader final {
   WTF_MAKE_NONCOPYABLE(FrameLoader);
   DISALLOW_NEW();
 
  public:
-  static ResourceRequest resourceRequestFromHistoryItem(HistoryItem*,
-                                                        WebCachePolicy);
-
   explicit FrameLoader(LocalFrame*);
   ~FrameLoader();
 
   void init();
 
   ResourceRequest resourceRequestForReload(
       FrameLoadType,
       const KURL& overrideURL = KURL(),
       ClientRedirectPolicy = ClientRedirectPolicy::NotClientRedirect);
 
@@ skipping 39 matching lines @@
 
   bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
   bool shouldTreatURLAsSrcdocDocument(const KURL&) const;
 
   LocalFrameClient* client() const;
 
   void setDefersLoading(bool);
 
   void didExplicitOpen();
 
-  // Callbacks from DocumentWriter
-  void didInstallNewDocument();
-
-  void receivedFirstData();
-
   String userAgent() const;
 
   void dispatchDidClearWindowObjectInMainWorld();
   void dispatchDidClearDocumentOfWindowObject();
   void dispatchDocumentElementAvailable();
   void runScriptsAtDocumentElementAvailable();
 
   // The following sandbox flags will be forced, regardless of changes to the
   // sandbox attribute of any parent frames.
   void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
   SandboxFlags effectiveSandboxFlags() const;
 
   WebInsecureRequestPolicy getInsecureRequestPolicy() const;
   SecurityContext::InsecureNavigationsSet* insecureNavigationsToUpgrade() const;
   void modifyRequestForCSP(ResourceRequest&, Document*) const;
 
   Frame* opener();
   void setOpener(LocalFrame*);
 
   const AtomicString& requiredCSP() const { return m_requiredCSP; }
   void recordLatestRequiredCSP();
 
   void detach();
 
   void finishedParsing();
   void checkCompleted();
 
-  void clearProvisionalHistoryItem();
-
   // This prepares the FrameLoader for the next commit. It will dispatch unload
   // events, abort XHR requests and detach the document. Returns true if the
   // frame is ready to receive the next commit, or false otherwise.
   bool prepareForCommit();
 
   void commitProvisionalLoad();
 
   FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
 
   void applyUserAgent(ResourceRequest&);
 
   bool allAncestorsAreComplete() const;  // including this
 
   bool shouldClose(bool isReload = false);
   void dispatchUnloadEvent();
 
   bool allowPlugins(ReasonForCallingAllowPlugins);
 
   void updateForSameDocumentNavigation(const KURL&,
                                        SameDocumentNavigationSource,
                                        PassRefPtr<SerializedScriptValue>,
                                        HistoryScrollRestorationType,
                                        FrameLoadType,
                                        Document*);
 
-  HistoryItem* currentItem() const { return m_currentItem.get(); }
   void saveScrollState();
-
   void restoreScrollPositionAndViewState();
 
   // The navigation should only be continued immediately in this frame if this
   // returns NavigationPolicyCurrentTab.
   NavigationPolicy shouldContinueForNavigationPolicy(
       const ResourceRequest&,
       const SubstituteData&,
       DocumentLoader*,
       ContentSecurityPolicyDisposition,
       NavigationType,
       NavigationPolicy,
       FrameLoadType,
       bool isClientRedirect,
       HTMLFormElement*);
 
   // Note: When a PlzNavigtate navigation is handled by the client, we will
   // have created a dummy provisional DocumentLoader, so this will return true
   // while the client handles the navigation.
   bool hasProvisionalNavigation() const { return provisionalDocumentLoader(); }
 
+  void detachProvisionalDocumentLoader(DocumentLoader*);
+
   DECLARE_TRACE();
 
   static void setReferrerForFrameRequest(FrameLoadRequest&);
 
  private:
   void checkTimerFired(TimerBase*);
 
   bool prepareRequestForThisFrame(FrameLoadRequest&);
   FrameLoadType determineFrameLoadType(const FrameLoadRequest&);
 
   SubstituteData defaultSubstituteDataForURL(const KURL&);
 
   bool shouldPerformFragmentNavigation(bool isFormSubmission,
                                        const String& httpMethod,
                                        FrameLoadType,
                                        const KURL&);
   void processFragment(const KURL&, FrameLoadType, LoadStartType);
 
   NavigationPolicy checkLoadCanStart(FrameLoadRequest&,
                                      FrameLoadType,
                                      NavigationPolicy,
                                      NavigationType);
-  void startLoad(FrameLoadRequest&, FrameLoadType, NavigationPolicy);
-
-  enum class HistoryNavigationType { DifferentDocument, Fragment, HistoryApi };
-  void setHistoryItemStateForCommit(FrameLoadType,
-                                    HistoryCommitType,
-                                    HistoryNavigationType);
+  void startLoad(FrameLoadRequest&,
+                 FrameLoadType,
+                 NavigationPolicy,
+                 HistoryItem*);
 
   void loadInSameDocument(const KURL&,
                           PassRefPtr<SerializedScriptValue> stateObject,
                           FrameLoadType,
-                          HistoryLoadType,
+                          HistoryItem*,
                           ClientRedirectPolicy,
                           Document*);
   void restoreScrollPositionAndViewStateForLoadType(FrameLoadType);
 
   void scheduleCheckCompleted();
 
   void detachDocumentLoader(Member<DocumentLoader>&);
 
   void upgradeInsecureRequest(ResourceRequest&, Document*) const;
 
@@ skipping 16 matching lines @@
   Member<ProgressTracker> m_progressTracker;
 
   // Document loaders for the three phases of frame loading. Note that while a
   // new request is being loaded, the old document loader may still be
   // referenced. 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.
   Member<DocumentLoader> m_documentLoader;
   Member<DocumentLoader> m_provisionalDocumentLoader;
 
-  Member<HistoryItem> m_currentItem;
-  Member<HistoryItem> m_provisionalItem;
-
   class DeferredHistoryLoad
       : public GarbageCollectedFinalized<DeferredHistoryLoad> {
     WTF_MAKE_NONCOPYABLE(DeferredHistoryLoad);
 
    public:
     static DeferredHistoryLoad* create(ResourceRequest request,
                                        HistoryItem* item,
                                        FrameLoadType loadType,
                                        HistoryLoadType historyLoadType) {
       return new DeferredHistoryLoad(request, item, loadType, historyLoadType);
@@ skipping 25 matching lines @@
   SandboxFlags m_forcedSandboxFlags;
 
   bool m_dispatchingDidClearWindowObjectInMainWorld;
   bool m_protectProvisionalLoader;
   bool m_detached;
 };
 
 }  // namespace blink
 
 #endif  // FrameLoader_h