Drop replacesCurrentHistoryItem, NavigationType

third_party/WebKit/Source/web/FrameLoaderClientImpl.cpp

 /*
  * Copyright (C) 2009, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2011 Apple 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 324 matching lines @@
   // place at this point since we are no longer associated with the Page.
   m_webFrame->setClient(0);
 
   client->frameDetached(m_webFrame,
                         static_cast<WebFrameClient::DetachType>(type));
   // Clear our reference to LocalFrame at the very end, in case the client
   // refers to it.
   m_webFrame->setCoreFrame(nullptr);
 }
 
-void FrameLoaderClientImpl::dispatchWillSendRequest(ResourceRequest& request) {
+void FrameLoaderClientImpl::willSendRequest(ResourceRequest& request,
+                                            FrameLoadType type) {
   // Give the WebFrameClient a crack at the request.
   if (m_webFrame->client()) {
     WrappedResourceRequest webreq(request);
-    m_webFrame->client()->willSendRequest(m_webFrame, webreq);
+    m_webFrame->client()->willSendRequest(m_webFrame, webreq,
+                                          static_cast<WebFrameLoadType>(type));
   }
 }
 
 void FrameLoaderClientImpl::dispatchDidReceiveResponse(
     const ResourceResponse& response) {
   if (m_webFrame->client()) {
     WrappedResourceResponse webresp(response);
     m_webFrame->client()->didReceiveResponse(webresp);
   }
 }
@@ skipping 20 matching lines @@
     m_webFrame->client()->didHandleOnloadEvents(m_webFrame);
 }
 
 void FrameLoaderClientImpl::
     dispatchDidReceiveServerRedirectForProvisionalLoad() {
   if (m_webFrame->client())
     m_webFrame->client()->didReceiveServerRedirectForProvisionalLoad(
         m_webFrame);
 }
 
-void FrameLoaderClientImpl::dispatchDidNavigateWithinPage(
-    HistoryItem* item,
-    HistoryCommitType commitType,
-    bool contentInitiated) {
+void FrameLoaderClientImpl::didNavigateWithinPage(DocumentLoader* loader,
+                                                  FrameLoadType frameLoadType,
+                                                  HistoryItem* item,
+                                                  HistoryCommitType commitType,
+                                                  bool contentInitiated) {
   bool shouldCreateHistoryEntry = commitType == StandardCommit;
   // TODO(dglazkov): Does this need to be called for subframes?
   m_webFrame->viewImpl()->didCommitLoad(shouldCreateHistoryEntry, true);
-  if (m_webFrame->client())
+  if (m_webFrame->client()) {
     m_webFrame->client()->didNavigateWithinPage(
-        m_webFrame, WebHistoryItem(item),
+        WebDataSourceImpl::fromDocumentLoader(loader),
+        static_cast<WebFrameLoadType>(frameLoadType), WebHistoryItem(item),
         static_cast<WebHistoryCommitType>(commitType), contentInitiated);
+  }
 }
 
 void FrameLoaderClientImpl::dispatchWillCommitProvisionalLoad() {
   if (m_webFrame->client())
     m_webFrame->client()->willCommitProvisionalLoad(m_webFrame);
 }
 
-void FrameLoaderClientImpl::dispatchDidStartProvisionalLoad() {
-  if (m_webFrame->client())
-    m_webFrame->client()->didStartProvisionalLoad(m_webFrame);
+void FrameLoaderClientImpl::didStartProvisionalLoad(
+    DocumentLoader* loader,
+    FrameLoadType frameLoadType) {
+  if (m_webFrame->client()) {
+    m_webFrame->client()->didStartProvisionalLoad(
+        WebDataSourceImpl::fromDocumentLoader(loader),
+        static_cast<WebFrameLoadType>(frameLoadType));
+  }
   if (WebDevToolsAgentImpl* devTools = devToolsAgent())
     devTools->didStartProvisionalLoad(m_webFrame->frame());
 }
 
 void FrameLoaderClientImpl::dispatchDidReceiveTitle(const String& title) {
   if (m_webFrame->client())
     m_webFrame->client()->didReceiveTitle(m_webFrame, title,
                                           WebTextDirectionLeftToRight);
 }
 
 void FrameLoaderClientImpl::dispatchDidChangeIcons(IconType type) {
   if (m_webFrame->client())
     m_webFrame->client()->didChangeIcon(m_webFrame,
                                         static_cast<WebIconURL::Type>(type));
 }
 
-void FrameLoaderClientImpl::dispatchDidCommitLoad(
+void FrameLoaderClientImpl::didCommitProvisionalLoad(
+    DocumentLoader* loader,
+    FrameLoadType frameLoadType,
     HistoryItem* item,
     HistoryCommitType commitType) {
   if (!m_webFrame->parent()) {
     m_webFrame->viewImpl()->didCommitLoad(commitType == StandardCommit, false);
   }
 
-  if (m_webFrame->client())
+  if (m_webFrame->client()) {
     m_webFrame->client()->didCommitProvisionalLoad(
-        m_webFrame, WebHistoryItem(item),
+        WebDataSourceImpl::fromDocumentLoader(loader),
+        static_cast<WebFrameLoadType>(frameLoadType), WebHistoryItem(item),
         static_cast<WebHistoryCommitType>(commitType));
+  }
   if (WebDevToolsAgentImpl* devTools = devToolsAgent())
     devTools->didCommitLoadForLocalFrame(m_webFrame->frame());
 }
 
 void FrameLoaderClientImpl::dispatchDidFailProvisionalLoad(
     const ResourceError& error,
     HistoryCommitType commitType) {
   m_webFrame->didFail(error, true, commitType);
 }
 
@@ skipping 49 matching lines @@
   NavigationPolicy userPolicy;
   if (!navigationPolicyFromMouseEvent(buttonNumber, ctrl, shift, alt, meta,
                                       &userPolicy))
     return false;
   return userPolicy == NavigationPolicyNewBackgroundTab;
 }
 
 NavigationPolicy FrameLoaderClientImpl::decidePolicyForNavigation(
     const ResourceRequest& request,
     DocumentLoader* loader,
-    NavigationType type,
     NavigationPolicy policy,
-    bool replacesCurrentHistoryItem,
+    FrameLoadType frameLoadType,
     bool isClientRedirect,
     HTMLFormElement* form) {
   if (!m_webFrame->client())
     return NavigationPolicyIgnore;
 
   if (policy == NavigationPolicyNewBackgroundTab &&
       !allowCreatingBackgroundTabs() &&
       !UIEventWithKeyState::newTabModifierSetFromIsolatedWorld())
     policy = NavigationPolicyNewForegroundTab;
 
   WebDataSourceImpl* ds = WebDataSourceImpl::fromDocumentLoader(loader);
 
-  // Newly created child frames may need to be navigated to a history item
-  // during a back/forward navigation. This will only happen when the parent
-  // is a LocalFrame doing a back/forward navigation that has not completed.
-  // (If the load has completed and the parent later adds a frame with script,
-  // we do not want to use a history item for it.)
-  bool isHistoryNavigationInNewChildFrame =
-      m_webFrame->parent() && m_webFrame->parent()->isWebLocalFrame() &&
-      isBackForwardLoadType(toWebLocalFrameImpl(m_webFrame->parent())
-                                ->frame()
-                                ->loader()
-                                .documentLoader()
-                                ->loadType()) &&
-      !toWebLocalFrameImpl(m_webFrame->parent())
-           ->frame()
-           ->document()
-           ->loadEventFinished();
-
   WrappedResourceRequest wrappedResourceRequest(request);
   WebFrameClient::NavigationPolicyInfo navigationInfo(wrappedResourceRequest);
-  navigationInfo.navigationType = static_cast<WebNavigationType>(type);
   navigationInfo.defaultPolicy = static_cast<WebNavigationPolicy>(policy);
   navigationInfo.extraData = ds ? ds->getExtraData() : nullptr;
-  navigationInfo.replacesCurrentHistoryItem = replacesCurrentHistoryItem;
-  navigationInfo.isHistoryNavigationInNewChildFrame =
-      isHistoryNavigationInNewChildFrame;
+  navigationInfo.loadType = static_cast<WebFrameLoadType>(frameLoadType);
   navigationInfo.isClientRedirect = isClientRedirect;
   // Caching could be disabled for requests initiated by DevTools.
   // TODO(ananta)
   // We should extract the network cache state into a global component which
   // can be queried here and wherever necessary.
   navigationInfo.isCacheDisabled =
       devToolsAgent() ? devToolsAgent()->cacheDisabled() : false;
   if (form)
     navigationInfo.form = WebFormElement(form);
 
@@ skipping 24 matching lines @@
 }
 
 void FrameLoaderClientImpl::didStopLoading() {
   if (m_webFrame->client())
     m_webFrame->client()->didStopLoading();
 }
 
 void FrameLoaderClientImpl::loadURLExternally(const ResourceRequest& request,
                                               NavigationPolicy policy,
                                               const String& suggestedName,
-                                              bool shouldReplaceCurrentEntry) {
+                                              FrameLoadType loadType) {
   if (!m_webFrame->client())
     return;
   DCHECK(m_webFrame->frame()->document());
   Fullscreen::fullyExitFullscreen(*m_webFrame->frame()->document());
   m_webFrame->client()->loadURLExternally(
       WrappedResourceRequest(request), static_cast<WebNavigationPolicy>(policy),
-      suggestedName, shouldReplaceCurrentEntry);
+      suggestedName, static_cast<WebFrameLoadType>(loadType));
 }
 
 void FrameLoaderClientImpl::loadErrorPage(int reason) {
   if (m_webFrame->client())
     m_webFrame->client()->loadErrorPage(reason);
 }
 
 bool FrameLoaderClientImpl::navigateBackForward(int offset) const {
   WebViewImpl* webview = m_webFrame->viewImpl();
   if (!webview->client())
@@ skipping 390 matching lines @@
 KURL FrameLoaderClientImpl::overrideFlashEmbedWithHTML(const KURL& url) {
   return m_webFrame->client()->overrideFlashEmbedWithHTML(WebURL(url));
 }
 
 void FrameLoaderClientImpl::setHasReceivedUserGesture() {
   if (m_webFrame->client())
     m_webFrame->client()->setHasReceivedUserGesture();
 }
 
 }  // namespace blink