Move HistoryItem handling to DocumentLoader

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 44 matching lines @@
 #include "wtf/RefPtr.h"
 
 #include <memory>
 
 namespace blink {
 
 class ApplicationCacheHost;
 class SubresourceFilter;
 class ResourceFetcher;
 class DocumentInit;
+class HistoryItem;
 class LocalFrame;
 class LocalFrameClient;
 class FrameLoader;
 class ResourceTimingInfo;
+class SerializedScriptValue;
 class WebServiceWorkerNetworkProvider;
 struct ViewportDescriptionWrapper;
 
 class CORE_EXPORT DocumentLoader
     : public GarbageCollectedFinalized<DocumentLoader>,
       private RawResourceClient {
   USING_GARBAGE_COLLECTED_MIXIN(DocumentLoader);
 
  public:
   static DocumentLoader* create(LocalFrame* frame,
@@ skipping 34 matching lines @@
 
   const KURL& url() const;
   const KURL& unreachableURL() const;
   const KURL& urlForHistory() const;
 
   const AtomicString& responseMIMEType() const;
 
   void didChangePerformanceTiming();
   void didObserveLoadingBehavior(WebLoadingBehaviorFlag);
   void updateForSameDocumentNavigation(const KURL&,
-                                       SameDocumentNavigationSource);
+                                       SameDocumentNavigationSource,
+                                       PassRefPtr<SerializedScriptValue>,
+                                       HistoryScrollRestorationType,
+                                       FrameLoadType,
+                                       Document*);
   const ResourceResponse& response() const { return m_response; }
   bool isClientRedirect() const { return m_isClientRedirect; }
   void setIsClientRedirect(bool isClientRedirect) {
     m_isClientRedirect = isClientRedirect;
   }
   bool replacesCurrentHistoryItem() const {
     return m_replacesCurrentHistoryItem;
   }
   void setReplacesCurrentHistoryItem(bool replacesCurrentHistoryItem) {
     m_replacesCurrentHistoryItem = replacesCurrentHistoryItem;
   }
 
   bool isCommittedButEmpty() const {
     return m_state >= Committed && !m_dataReceived;
   }
 
   // Without PlzNavigate, this is only false for a narrow window during
   // navigation start. For PlzNavigate, a navigation sent to the browser will
   // leave a dummy DocumentLoader in the NotStarted state until the navigation
   // is actually handled in the renderer.
   bool didStart() const { return m_state != NotStarted; }
 
+  void markAsCommitted() {

[kinuko, 2017/03/30 05:05:00]

Is the DCHECK the reason you wanted to use different naming pattern from simple
setters like below?  (nit: Could we move the code into .cpp if it's not meant to
be a simplest setter (conceptually)?)

[Nate Chapin, 2017/03/30 20:13:56]

The DCHECK is part of the reason. The other is that "setCommitted()" just didn't
feel right to me, for reasons I can't quite justify. :) If you feel strongly,
I'll switch it.

Moved to .cpp.

+    DCHECK_LT(m_state, Committed);
+    m_state = Committed;
+  }
   void setSentDidFinishLoad() { m_state = SentDidFinishLoad; }
   bool sentDidFinishLoad() const { return m_state == SentDidFinishLoad; }
 
   FrameLoadType loadType() const { return m_loadType; }
   void setLoadType(FrameLoadType loadType) { m_loadType = loadType; }
 
   NavigationType getNavigationType() const { return m_navigationType; }
   void setNavigationType(NavigationType navigationType) {
     m_navigationType = navigationType;
   }
 
+  void setItemForHistoryNavigation(HistoryItem* item) { m_historyItem = item; }
+  HistoryItem* historyItem() const { return m_historyItem; }
+
   void startLoadingMainResource();
 
   DocumentLoadTiming& timing() { return m_documentLoadTiming; }
   const DocumentLoadTiming& timing() const { return m_documentLoadTiming; }
 
   ApplicationCacheHost* applicationCacheHost() const {
     return m_applicationCacheHost.get();
   }
 
   void clearRedirectChain();
@@ skipping 27 matching lines @@
   // May return null before the first HTML tag is inserted by the
   // parser (before didCreateDataSource is called), after the document
   // is detached from frame, or in tests.
   WebServiceWorkerNetworkProvider* getServiceWorkerNetworkProvider() {
     return m_serviceWorkerNetworkProvider.get();
   }
 
   std::unique_ptr<SourceLocation> copySourceLocation() const;
   void setSourceLocation(std::unique_ptr<SourceLocation>);
 
+  void loadFailed(const ResourceError&);
+
   DECLARE_VIRTUAL_TRACE();
 
  protected:
   DocumentLoader(LocalFrame*,
                  const ResourceRequest&,
                  const SubstituteData&,
                  ClientRedirectPolicy);
 
   Vector<KURL> m_redirectChain;
 
@@ skipping 14 matching lines @@
 
   void ensureWriter(const AtomicString& mimeType,
                     const KURL& overridingURL = KURL());
   void endWriting();
 
   // Use these method only where it's guaranteed that |m_frame| hasn't been
   // cleared.
   FrameLoader& frameLoader() const;
   LocalFrameClient& localFrameClient() const;
 
-  void commitIfReady();
   void commitData(const char* bytes, size_t length);
   void clearMainResourceHandle();
 
   bool maybeCreateArchive();
 
   void finishedLoading(double finishTime);
   void cancelLoadAfterCSPDenied(const ResourceResponse&);
 
+  enum class HistoryNavigationType { DifferentDocument, Fragment, HistoryApi };

[kinuko, 2017/03/30 05:05:00]

nit: prefixing 'k' for new enums? (other enums in this class seem to have it)

[Nate Chapin, 2017/03/30 20:13:56]

Aww...that makes it have to line wrap :(

Done.

+  void setHistoryItemStateForCommit(HistoryItem* oldItem,
+                                    FrameLoadType,
+                                    HistoryNavigationType);
+
   // RawResourceClient implementation
   bool redirectReceived(Resource*,
                         const ResourceRequest&,
                         const ResourceResponse&) final;
   void responseReceived(Resource*,
                         const ResourceResponse&,
                         std::unique_ptr<WebDataConsumerHandle>) final;
   void dataReceived(Resource*, const char* data, size_t length) final;
 
   // ResourceClient implementation
   void notifyFinished(Resource*) final;
   String debugName() const override { return "DocumentLoader"; }
 
   void processData(const char* data, size_t length);
 
   bool maybeLoadEmpty();
 
   bool isRedirectAfterPost(const ResourceRequest&, const ResourceResponse&);
 
   bool shouldContinueForResponse() const;
 
   Member<LocalFrame> m_frame;
   Member<ResourceFetcher> m_fetcher;
 
   Member<RawResource> m_mainResource;
+  Member<HistoryItem> m_historyItem;
 
   Member<DocumentWriter> m_writer;
 
   Member<SubresourceFilter> m_subresourceFilter;
 
   // 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;
 
@@ skipping 45 matching lines @@
   // Used to protect against reentrancy into dataReceived().
   bool m_inDataReceived;
   RefPtr<SharedBuffer> m_dataBuffer;
 };
 
 DECLARE_WEAK_IDENTIFIER_MAP(DocumentLoader);
 
 }  // namespace blink
 
 #endif  // DocumentLoader_h