Drop replacesCurrentHistoryItem, NavigationType

third_party/WebKit/public/web/WebFrameClient.h

 /*
  * Copyright (C) 2011, 2012 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 25 matching lines @@
 #include "WebDOMMessageEvent.h"
 #include "WebDataSource.h"
 #include "WebFileChooserParams.h"
 #include "WebFormElement.h"
 #include "WebFrame.h"
 #include "WebFrameOwnerProperties.h"
 #include "WebHistoryCommitType.h"
 #include "WebHistoryItem.h"
 #include "WebIconURL.h"
 #include "WebNavigationPolicy.h"
-#include "WebNavigationType.h"
 #include "WebNavigatorContentUtilsClient.h"
 #include "WebSandboxFlags.h"
 #include "WebTextDirection.h"
 #include "public/platform/BlameContext.h"
 #include "public/platform/WebCommon.h"
 #include "public/platform/WebEffectiveConnectionType.h"
 #include "public/platform/WebFeaturePolicy.h"
 #include "public/platform/WebFileSystem.h"
 #include "public/platform/WebFileSystemType.h"
 #include "public/platform/WebInsecureRequestPolicy.h"
@@ skipping 208 matching lines @@
                                       const WebString& sourceName,
                                       unsigned sourceLine,
                                       const WebString& stackTrace) {}
 
   // Load commands -------------------------------------------------------
 
   // The client should handle the navigation externally.
   virtual void loadURLExternally(const WebURLRequest&,
                                  WebNavigationPolicy,
                                  const WebString& downloadName,
-                                 bool shouldReplaceCurrentEntry) {}
+                                 WebFrameLoadType loadType) {}
 
   // The client should load an error page in the current frame.
   virtual void loadErrorPage(int reason) {}
 
   // Navigational queries ------------------------------------------------
 
   // The client may choose to alter the navigation policy.  Otherwise,
   // defaultPolicy should just be returned.
 
   struct NavigationPolicyInfo {
     WebDataSource::ExtraData* extraData;
 
     // Note: if browser side navigations are enabled, the client may modify
     // the urlRequest. However, should this happen, the client should change
     // the WebNavigationPolicy to WebNavigationPolicyIgnore, and the load
     // should stop in blink. In all other cases, the urlRequest should not
     // be modified.
     WebURLRequest& urlRequest;
-    WebNavigationType navigationType;
     WebNavigationPolicy defaultPolicy;
-    bool replacesCurrentHistoryItem;
-    bool isHistoryNavigationInNewChildFrame;
+    WebFrameLoadType loadType;
     bool isClientRedirect;
     WebFormElement form;
     bool isCacheDisabled;
 
     NavigationPolicyInfo(WebURLRequest& urlRequest)
         : extraData(nullptr),
           urlRequest(urlRequest),
-          navigationType(WebNavigationTypeOther),
           defaultPolicy(WebNavigationPolicyIgnore),
-          replacesCurrentHistoryItem(false),
-          isHistoryNavigationInNewChildFrame(false),
+          loadType(WebFrameLoadType::Standard),
           isClientRedirect(false),
           isCacheDisabled(false) {}
   };
 
   virtual WebNavigationPolicy decidePolicyForNavigation(
       const NavigationPolicyInfo& info) {
     return info.defaultPolicy;
   }
 
   // During a history navigation, we may choose to load new subframes from
@@ skipping 18 matching lines @@
   virtual void willSendSubmitEvent(const WebFormElement&) {}
 
   // A form submission is about to occur.
   virtual void willSubmitForm(const WebFormElement&) {}
 
   // A datasource has been created for a new navigation.  The given
   // datasource will become the provisional datasource for the frame.
   virtual void didCreateDataSource(WebLocalFrame*, WebDataSource*) {}
 
   // A new provisional load has been started.
-  virtual void didStartProvisionalLoad(WebLocalFrame* localFrame) {}
+  virtual void didStartProvisionalLoad(WebDataSource*, WebFrameLoadType) {}
 
   // The provisional load was redirected via a HTTP 3xx response.
   virtual void didReceiveServerRedirectForProvisionalLoad(WebLocalFrame*) {}
 
   // The provisional load failed. The WebHistoryCommitType is the commit type
   // that would have been used had the load succeeded.
   virtual void didFailProvisionalLoad(WebLocalFrame*,
                                       const WebURLError&,
                                       WebHistoryCommitType) {}
 
   // The provisional datasource is now committed.  The first part of the
   // response body has been received, and the encoding of the response
   // body is known.
-  virtual void didCommitProvisionalLoad(WebLocalFrame*,
+  virtual void didCommitProvisionalLoad(WebDataSource*,
+                                        WebFrameLoadType,
                                         const WebHistoryItem&,
                                         WebHistoryCommitType) {}
 
   // The frame's document has just been initialized.
   virtual void didCreateNewDocument(WebLocalFrame* frame) {}
 
   // The window object for the frame has been cleared of any extra
   // properties that may have been set by script from the previously
   // loaded document.
   virtual void didClearWindowObject(WebLocalFrame* frame) {}
@@ skipping 32 matching lines @@
   virtual void didFailLoad(WebLocalFrame*,
                            const WebURLError&,
                            WebHistoryCommitType) {}
 
   // The frame's document and all of its subresources succeeded to load.
   virtual void didFinishLoad(WebLocalFrame*) {}
 
   // The navigation resulted in no change to the documents within the page.
   // For example, the navigation may have just resulted in scrolling to a
   // named anchor or a PopState event may have been dispatched.
-  virtual void didNavigateWithinPage(WebLocalFrame*,
+  virtual void didNavigateWithinPage(WebDataSource*,
+                                     WebFrameLoadType,
                                      const WebHistoryItem&,
                                      WebHistoryCommitType,
                                      bool contentInitiated) {}
 
   // Called upon update to scroll position, document state, and other
   // non-navigational events related to the data held by WebHistoryItem.
   // WARNING: This method may be called very frequently.
   virtual void didUpdateCurrentHistoryItem() {}
 
   // The frame's manifest has changed.
@@ skipping 98 matching lines @@
 
   // This method is called in response to WebView's saveImageAt(x, y).
   // A data url from <canvas> or <img> is passed to the method's argument.
   virtual void saveImageFromDataURL(const WebString&) {}
 
   // Low-level resource notifications ------------------------------------
 
   // A request is about to be sent out, and the client may modify it.  Request
   // is writable, and changes to the URL, for example, will change the request
   // made.
-  virtual void willSendRequest(WebLocalFrame*, WebURLRequest&) {}
+  virtual void willSendRequest(WebLocalFrame*,
+                               WebURLRequest&,
+                               blink::WebFrameLoadType) {}
 
   // Response headers have been received.
   virtual void didReceiveResponse(const WebURLResponse&) {}
 
   // The specified request was satified from WebCore's memory cache.
   virtual void didLoadResourceFromMemoryCache(const WebURLRequest&,
                                               const WebURLResponse&) {}
 
   // This frame has displayed inactive content (such as an image) from an
   // insecure source.  Inactive content cannot spread to other frames.
@@ skipping 208 matching lines @@
   // Overwrites the given URL to use an HTML5 embed if possible.
   // An empty URL is returned if the URL is not overriden.
   virtual WebURL overrideFlashEmbedWithHTML(const WebURL& url) {
     return WebURL();
   }
 };
 
 }  // namespace blink
 
 #endif