BASELINE: Update Chromium to 59.0.3071.134

Change-Id: Id02ef6fb2204c5fd21668a1c3e6911c83b17585a
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

1 files changed, 181 insertions, 128 deletions

diff --git a/chromium/third_party/WebKit/Source/core/loader/DocumentLoader.h b/chromium/third_party/WebKit/Source/core/loader/DocumentLoader.h
index bc1e5d3ff5c..895a01ea4a6 100644
--- a/chromium/third_party/WebKit/Source/core/loader/DocumentLoader.h
+++ b/chromium/third_party/WebKit/Source/core/loader/DocumentLoader.h
@@ -30,6 +30,8 @@
 #ifndef DocumentLoader_h
 #define DocumentLoader_h
 
+#include <memory>
+#include "bindings/core/v8/SourceLocation.h"
 #include "core/CoreExport.h"
 #include "core/dom/ViewportDescription.h"
 #include "core/dom/WeakIdentifierMap.h"
@@ -43,14 +45,14 @@
 #include "platform/SharedBuffer.h"
 #include "platform/loader/fetch/ClientHintsPreferences.h"
 #include "platform/loader/fetch/RawResource.h"
+#include "platform/loader/fetch/ResourceError.h"
 #include "platform/loader/fetch/ResourceLoaderOptions.h"
+#include "platform/loader/fetch/ResourceRequest.h"
+#include "platform/loader/fetch/ResourceResponse.h"
 #include "platform/loader/fetch/SubstituteData.h"
-#include "platform/network/ResourceError.h"
-#include "platform/network/ResourceRequest.h"
-#include "platform/network/ResourceResponse.h"
+#include "platform/wtf/HashSet.h"
+#include "platform/wtf/RefPtr.h"
 #include "public/platform/WebLoadingBehaviorFlag.h"
-#include "wtf/HashSet.h"
-#include "wtf/RefPtr.h"
 
 #include <memory>
 
@@ -60,10 +62,13 @@ 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
@@ -72,116 +77,141 @@ class CORE_EXPORT DocumentLoader
   USING_GARBAGE_COLLECTED_MIXIN(DocumentLoader);
 
  public:
-  static DocumentLoader* create(LocalFrame* frame,
+  static DocumentLoader* Create(LocalFrame* frame,
                                 const ResourceRequest& request,
                                 const SubstituteData& data,
-                                ClientRedirectPolicy clientRedirectPolicy) {
+                                ClientRedirectPolicy client_redirect_policy) {
     DCHECK(frame);
 
-    return new DocumentLoader(frame, request, data, clientRedirectPolicy);
+    return new DocumentLoader(frame, request, data, client_redirect_policy);
   }
   ~DocumentLoader() override;
 
-  LocalFrame* frame() const { return m_frame; }
+  LocalFrame* GetFrame() const { return frame_; }
 
-  ResourceTimingInfo* getNavigationTimingInfo() const;
+  ResourceTimingInfo* GetNavigationTimingInfo() const;
 
-  virtual void detachFromFrame();
+  virtual void DetachFromFrame();
 
-  unsigned long mainResourceIdentifier() const;
+  unsigned long MainResourceIdentifier() const;
 
-  void replaceDocumentWhileExecutingJavaScriptURL(const DocumentInit&,
+  void ReplaceDocumentWhileExecutingJavaScriptURL(const DocumentInit&,
                                                   const String& source);
 
-  const AtomicString& mimeType() const;
+  const AtomicString& MimeType() const;
 
-  const ResourceRequest& originalRequest() const;
+  const ResourceRequest& OriginalRequest() const;
 
-  const ResourceRequest& getRequest() const;
+  const ResourceRequest& GetRequest() const;
 
-  ResourceFetcher* fetcher() const { return m_fetcher.get(); }
+  ResourceFetcher* Fetcher() const { return fetcher_.Get(); }
 
-  void setSubresourceFilter(SubresourceFilter*);
-  SubresourceFilter* subresourceFilter() const {
-    return m_subresourceFilter.get();
+  void SetSubresourceFilter(SubresourceFilter*);
+  SubresourceFilter* GetSubresourceFilter() const {
+    return subresource_filter_.Get();
   }
 
-  const SubstituteData& substituteData() const { return m_substituteData; }
-
-  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);
-  const ResourceResponse& response() const { return m_response; }
-  bool isClientRedirect() const { return m_isClientRedirect; }
-  void setIsClientRedirect(bool isClientRedirect) {
-    m_isClientRedirect = isClientRedirect;
+  const SubstituteData& GetSubstituteData() const { return substitute_data_; }
+
+  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,
+                                       PassRefPtr<SerializedScriptValue>,
+                                       HistoryScrollRestorationType,
+                                       FrameLoadType,
+                                       Document*);
+  const ResourceResponse& GetResponse() const { return response_; }
+  bool IsClientRedirect() const { return is_client_redirect_; }
+  void SetIsClientRedirect(bool is_client_redirect) {
+    is_client_redirect_ = is_client_redirect;
   }
-  bool replacesCurrentHistoryItem() const {
-    return m_replacesCurrentHistoryItem;
+  bool ReplacesCurrentHistoryItem() const {
+    return replaces_current_history_item_;
   }
-  void setReplacesCurrentHistoryItem(bool replacesCurrentHistoryItem) {
-    m_replacesCurrentHistoryItem = replacesCurrentHistoryItem;
+  void SetReplacesCurrentHistoryItem(bool replaces_current_history_item) {
+    replaces_current_history_item_ = replaces_current_history_item;
   }
 
-  bool isCommittedButEmpty() const {
-    return m_state >= Committed && !m_dataReceived;
+  bool IsCommittedButEmpty() const {
+    return state_ >= kCommitted && !data_received_;
   }
 
-  void setSentDidFinishLoad() { m_state = SentDidFinishLoad; }
-  bool sentDidFinishLoad() const { return m_state == SentDidFinishLoad; }
+  // 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 state_ != kNotStarted; }
 
-  FrameLoadType loadType() const { return m_loadType; }
-  void setLoadType(FrameLoadType loadType) { m_loadType = loadType; }
+  void MarkAsCommitted();
+  void SetSentDidFinishLoad() { state_ = kSentDidFinishLoad; }
+  bool SentDidFinishLoad() const { return state_ == kSentDidFinishLoad; }
 
-  NavigationType getNavigationType() const { return m_navigationType; }
-  void setNavigationType(NavigationType navigationType) {
-    m_navigationType = navigationType;
-  }
+  FrameLoadType LoadType() const { return load_type_; }
+  void SetLoadType(FrameLoadType load_type) { load_type_ = load_type; }
 
-  void startLoadingMainResource();
+  NavigationType GetNavigationType() const { return navigation_type_; }
+  void SetNavigationType(NavigationType navigation_type) {
+    navigation_type_ = navigation_type;
+  }
 
-  DocumentLoadTiming& timing() { return m_documentLoadTiming; }
-  const DocumentLoadTiming& timing() const { return m_documentLoadTiming; }
+  void SetItemForHistoryNavigation(HistoryItem* item) { history_item_ = item; }
+  HistoryItem* GetHistoryItem() const { return history_item_; }
 
-  ApplicationCacheHost* applicationCacheHost() const {
-    return m_applicationCacheHost.get();
-  }
+  void StartLoadingMainResource();
 
-  void clearRedirectChain();
-  void appendRedirect(const KURL&);
+  DocumentLoadTiming& GetTiming() { return document_load_timing_; }
+  const DocumentLoadTiming& GetTiming() const { return document_load_timing_; }
 
-  ContentSecurityPolicy* releaseContentSecurityPolicy() {
-    return m_contentSecurityPolicy.release();
+  ApplicationCacheHost* GetApplicationCacheHost() const {
+    return application_cache_host_.Get();
   }
 
-  ClientHintsPreferences& clientHintsPreferences() {
-    return m_clientHintsPreferences;
+  void ClearRedirectChain();
+  void AppendRedirect(const KURL&);
+
+  ClientHintsPreferences& GetClientHintsPreferences() {
+    return client_hints_preferences_;
   }
 
   struct InitialScrollState {
     DISALLOW_NEW();
     InitialScrollState()
-        : wasScrolledByUser(false), didRestoreFromHistory(false) {}
+        : was_scrolled_by_user(false), did_restore_from_history(false) {}
 
-    bool wasScrolledByUser;
-    bool didRestoreFromHistory;
+    bool was_scrolled_by_user;
+    bool did_restore_from_history;
   };
-  InitialScrollState& initialScrollState() { return m_initialScrollState; }
+  InitialScrollState& GetInitialScrollState() { return initial_scroll_state_; }
 
-  void setWasBlockedAfterCSP() { m_wasBlockedAfterCSP = true; }
-  bool wasBlockedAfterCSP() { return m_wasBlockedAfterCSP; }
+  void SetWasBlockedAfterCSP() { was_blocked_after_csp_ = true; }
+  bool WasBlockedAfterCSP() { return was_blocked_after_csp_; }
 
-  void dispatchLinkHeaderPreloads(ViewportDescriptionWrapper*,
+  void DispatchLinkHeaderPreloads(ViewportDescriptionWrapper*,
                                   LinkLoader::MediaPreloadPolicy);
 
-  Resource* startPreload(Resource::Type, FetchRequest&);
+  Resource* StartPreload(Resource::Type, FetchParameters&);
+
+  void SetServiceWorkerNetworkProvider(
+      std::unique_ptr<WebServiceWorkerNetworkProvider>);
+
+  // 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 service_worker_network_provider_.get();
+  }
+
+  std::unique_ptr<SourceLocation> CopySourceLocation() const;
+  void SetSourceLocation(std::unique_ptr<SourceLocation>);
+
+  void LoadFailed(const ResourceError&);
 
   DECLARE_VIRTUAL_TRACE();
 
@@ -191,109 +221,132 @@ class CORE_EXPORT DocumentLoader
                  const SubstituteData&,
                  ClientRedirectPolicy);
 
-  Vector<KURL> m_redirectChain;
+  static bool ShouldClearWindowName(const LocalFrame&,
+                                    SecurityOrigin* previous_security_origin,
+                                    const Document& new_document);
 
- private:
-  static DocumentWriter* createWriterFor(const DocumentInit&,
-                                         const AtomicString& mimeType,
-                                         const AtomicString& encoding,
-                                         bool dispatchWindowObjectAvailable,
-                                         ParserSynchronizationPolicy,
-                                         const KURL& overridingURL = KURL());
+  Vector<KURL> redirect_chain_;
 
-  void ensureWriter(const AtomicString& mimeType,
-                    const KURL& overridingURL = KURL());
-  void endWriting();
+ private:
+  // installNewDocument() does the work of creating a Document and
+  // DocumentWriter, as well as creating a new LocalDOMWindow if needed. It also
+  // initalizes a bunch of state on the Document (e.g., the state based on
+  // response headers).
+  enum class InstallNewDocumentReason { kNavigation, kJavascriptURL };
+  void InstallNewDocument(const DocumentInit&,
+                          const AtomicString& mime_type,
+                          const AtomicString& encoding,
+                          InstallNewDocumentReason,
+                          ParserSynchronizationPolicy,
+                          const KURL& overriding_url);
+  void DidInstallNewDocument(Document*);
+  void DidCommitNavigation();
+
+  void EnsureWriter(const AtomicString& mime_type,
+                    const KURL& overriding_url = KURL());
+  void EndWriting();
 
   // Use these method only where it's guaranteed that |m_frame| hasn't been
   // cleared.
-  FrameLoader& frameLoader() const;
-  LocalFrameClient& localFrameClient() const;
+  FrameLoader& GetFrameLoader() const;
+  LocalFrameClient& GetLocalFrameClient() const;
 
-  void commitIfReady();
-  void commitData(const char* bytes, size_t length);
-  void clearMainResourceHandle();
+  void CommitData(const char* bytes, size_t length);
+  void ClearMainResourceHandle();
 
-  bool maybeCreateArchive();
+  bool MaybeCreateArchive();
 
-  void finishedLoading(double finishTime);
-  void cancelLoadAfterCSPDenied(const ResourceResponse&);
+  void FinishedLoading(double finish_time);
+  void CancelLoadAfterCSPDenied(const ResourceResponse&);
+
+  enum class HistoryNavigationType {
+    kDifferentDocument,
+    kFragment,
+    kHistoryApi
+  };
+  void SetHistoryItemStateForCommit(HistoryItem* old_item,
+                                    FrameLoadType,
+                                    HistoryNavigationType);
 
   // RawResourceClient implementation
-  bool redirectReceived(Resource*,
+  bool RedirectReceived(Resource*,
                         const ResourceRequest&,
                         const ResourceResponse&) final;
-  void responseReceived(Resource*,
+  void ResponseReceived(Resource*,
                         const ResourceResponse&,
                         std::unique_ptr<WebDataConsumerHandle>) final;
-  void dataReceived(Resource*, const char* data, size_t length) final;
+  void DataReceived(Resource*, const char* data, size_t length) final;
 
   // ResourceClient implementation
-  void notifyFinished(Resource*) final;
-  String debugName() const override { return "DocumentLoader"; }
+  void NotifyFinished(Resource*) final;
+  String DebugName() const override { return "DocumentLoader"; }
 
-  void processData(const char* data, size_t length);
+  void ProcessData(const char* data, size_t length);
 
-  bool maybeLoadEmpty();
+  bool MaybeLoadEmpty();
 
-  bool isRedirectAfterPost(const ResourceRequest&, const ResourceResponse&);
+  bool IsRedirectAfterPost(const ResourceRequest&, const ResourceResponse&);
 
-  bool shouldContinueForResponse() const;
+  bool ShouldContinueForResponse() const;
 
-  Member<LocalFrame> m_frame;
-  Member<ResourceFetcher> m_fetcher;
+  Member<LocalFrame> frame_;
+  Member<ResourceFetcher> fetcher_;
 
-  Member<RawResource> m_mainResource;
+  Member<RawResource> main_resource_;
+  Member<HistoryItem> history_item_;
 
-  Member<DocumentWriter> m_writer;
+  Member<DocumentWriter> writer_;
 
-  Member<SubresourceFilter> m_subresourceFilter;
+  Member<SubresourceFilter> subresource_filter_;
 
   // 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;
+  ResourceRequest original_request_;
 
-  SubstituteData m_substituteData;
+  SubstituteData substitute_data_;
 
   // 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;
+  ResourceRequest request_;
 
-  ResourceResponse m_response;
+  ResourceResponse response_;
 
-  FrameLoadType m_loadType;
+  FrameLoadType load_type_;
 
-  bool m_isClientRedirect;
-  bool m_replacesCurrentHistoryItem;
-  bool m_dataReceived;
+  bool is_client_redirect_;
+  bool replaces_current_history_item_;
+  bool data_received_;
 
-  NavigationType m_navigationType;
+  NavigationType navigation_type_;
 
-  DocumentLoadTiming m_documentLoadTiming;
+  DocumentLoadTiming document_load_timing_;
 
-  double m_timeOfLastDataReceived;
+  double time_of_last_data_received_;
 
-  Member<ApplicationCacheHost> m_applicationCacheHost;
+  Member<ApplicationCacheHost> application_cache_host_;
 
-  Member<ContentSecurityPolicy> m_contentSecurityPolicy;
-  ClientHintsPreferences m_clientHintsPreferences;
-  InitialScrollState m_initialScrollState;
+  std::unique_ptr<WebServiceWorkerNetworkProvider>
+      service_worker_network_provider_;
 
-  bool m_wasBlockedAfterCSP;
+  Member<ContentSecurityPolicy> content_security_policy_;
+  ClientHintsPreferences client_hints_preferences_;
+  InitialScrollState initial_scroll_state_;
 
-  enum State {
-    NotStarted,
-    Provisional,
-    Committed,
-    SentDidFinishLoad
-  };
-  State m_state;
+  bool was_blocked_after_csp_;
+
+  // PlzNavigate: set when committing a navigation. The data has originally been
+  // captured when the navigation was sent to the browser process, and it is
+  // sent back at commit time.
+  std::unique_ptr<SourceLocation> source_location_;
+
+  enum State { kNotStarted, kProvisional, kCommitted, kSentDidFinishLoad };
+  State state_;
 
   // Used to protect against reentrancy into dataReceived().
-  bool m_inDataReceived;
-  RefPtr<SharedBuffer> m_dataBuffer;
+  bool in_data_received_;
+  RefPtr<SharedBuffer> data_buffer_;
 };
 
 DECLARE_WEAK_IDENTIFIER_MAP(DocumentLoader);