Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
#include "nsISupports.idl"
interface nsIInputStream;
interface nsISHistory;
interface nsIURI;
interface nsIPrincipal;
interface nsIChildSHistory;
webidl Document;
%{ C++
#include "mozilla/dom/ChildSHistory.h"
namespace mozilla {
namespace dom {
struct LoadURIOptions;
} // namespace dom
} // namespace mozilla
%}
[ref] native LoadURIOptionsRef(const mozilla::dom::LoadURIOptions);
/**
* The nsIWebNavigation interface defines an interface for navigating the web.
* It provides methods and attributes to direct an object to navigate to a new
* location, stop or restart an in process load, or determine where the object
* has previously gone.
*
* Even though this is builtinclass, most of the interface is also implemented
* in RemoteWebNavigation, so if this interface changes, the implementation
* there may also need to change.
*/
[scriptable, builtinclass, uuid(3ade79d4-8cb9-4952-b18d-4f9b63ca0d31)]
interface nsIWebNavigation : nsISupports
{
/**
* Indicates if the object can go back. If true this indicates that
* there is back session history available for navigation.
*/
readonly attribute boolean canGoBack;
/**
* Indicates if the object can go forward. If true this indicates that
* there is forward session history available for navigation
*/
readonly attribute boolean canGoForward;
/**
* Tells the object to navigate to the previous session history item. When a
* page is loaded from session history, all content is loaded from the cache
* (if available) and page state (such as form values and scroll position) is
* restored.
*
* @param {boolean} aRequireUserInteraction
* Tells goBack to skip history items that did not record any user
* interaction on their corresponding document while they were active.
* This means in case of multiple entries mapping to the same document,
* each entry has to have been flagged with user interaction separately.
* If no items have user interaction, the function will fall back
* to the first session history entry.
*
* @param {boolean} aUserActivation
* Tells goBack that the call was triggered by a user action (e.g.:
* The user clicked the back button).
*
* @throw NS_ERROR_UNEXPECTED
* Indicates that the call was unexpected at this time, which implies
* that canGoBack is false.
*/
void goBack([optional] in boolean aRequireUserInteraction, [optional] in boolean aUserActivation);
/**
* Tells the object to navigate to the next session history item. When a
* page is loaded from session history, all content is loaded from the cache
* (if available) and page state (such as form values and scroll position) is
* restored.
*
* @param {boolean} aRequireUserInteraction
* Tells goForward to skip history items that did not record any user
* interaction on their corresponding document while they were active.
* This means in case of multiple entries mapping to the same document,
* each entry has to have been flagged with user interaction separately.
* If no items have user interaction, the function will fall back
* to the latest session history entry.
*
* @param {boolean} aUserActivation
* Tells goForward that the call was triggered by a user action (e.g.:
* The user clicked the forward button).
*
* @throw NS_ERROR_UNEXPECTED
* Indicates that the call was unexpected at this time, which implies
* that canGoForward is false.
*/
void goForward([optional] in boolean aRequireUserInteraction, [optional] in boolean aUserActivation);
/**
* Tells the object to navigate to the session history item at a given index.
*
* @param {boolean} aUserActivation
* Tells goForward that the call was triggered by a user action (e.g.:
* The user clicked the forward button).
*
* @throw NS_ERROR_UNEXPECTED
* Indicates that the call was unexpected at this time, which implies
* that session history entry at the given index does not exist.
*/
void gotoIndex(in long index, [optional] in boolean aUserActivation);
/****************************************************************************
* The following flags may be bitwise combined to form the load flags
* parameter passed to either the loadURI or reload method. Some of these
* flags are only applicable to loadURI.
*/
/**
* This flags defines the range of bits that may be specified. Flags
* outside this range may be used, but may not be passed to Reload().
*/
const unsigned long LOAD_FLAGS_MASK = 0xffff;
/**
* This is the default value for the load flags parameter.
*/
const unsigned long LOAD_FLAGS_NONE = 0x0000;
/**
* Flags 0x1, 0x2, 0x4, 0x8 are reserved for internal use by
* nsIWebNavigation implementations for now.
*/
/**
* This flag specifies that the load should have the semantics of an HTML
* Meta-refresh tag (i.e., that the cache should be bypassed). This flag
* is only applicable to loadURI.
* XXX the meaning of this flag is poorly defined.
* XXX no one uses this, so we should probably deprecate and remove it.
*/
const unsigned long LOAD_FLAGS_IS_REFRESH = 0x0010;
/**
* This flag specifies that the load should have the semantics of a link
* click. This flag is only applicable to loadURI.
* XXX the meaning of this flag is poorly defined.
*/
const unsigned long LOAD_FLAGS_IS_LINK = 0x0020;
/**
* This flag specifies that history should not be updated. This flag is only
* applicable to loadURI.
*/
const unsigned long LOAD_FLAGS_BYPASS_HISTORY = 0x0040;
/**
* This flag specifies that any existing history entry should be replaced.
* This flag is only applicable to loadURI.
*/
const unsigned long LOAD_FLAGS_REPLACE_HISTORY = 0x0080;
/**
* This flag specifies that the local web cache should be bypassed, but an
* intermediate proxy cache could still be used to satisfy the load.
*/
const unsigned long LOAD_FLAGS_BYPASS_CACHE = 0x0100;
/**
* This flag specifies that any intermediate proxy caches should be bypassed
* (i.e., that the content should be loaded from the origin server).
*/
const unsigned long LOAD_FLAGS_BYPASS_PROXY = 0x0200;
/**
* This flag specifies that a reload was triggered as a result of detecting
* an incorrect character encoding while parsing a previously loaded
* document.
*/
const unsigned long LOAD_FLAGS_CHARSET_CHANGE = 0x0400;
/**
* If this flag is set, Stop() will be called before the load starts
* and will stop both content and network activity (the default is to
* only stop network activity). Effectively, this passes the
* STOP_CONTENT flag to Stop(), in addition to the STOP_NETWORK flag.
*/
const unsigned long LOAD_FLAGS_STOP_CONTENT = 0x0800;
/**
* A hint this load was prompted by an external program: take care!
*/
const unsigned long LOAD_FLAGS_FROM_EXTERNAL = 0x1000;
/**
* This flag specifies that this is the first load in this object.
* Set with care, since setting incorrectly can cause us to assume that
* nothing was actually loaded in this object if the load ends up being
* handled by an external application. This flag must not be passed to
* Reload.
*/
const unsigned long LOAD_FLAGS_FIRST_LOAD = 0x4000;
/**
* This flag specifies that the load should not be subject to popup
* blocking checks. This flag must not be passed to Reload.
*/
const unsigned long LOAD_FLAGS_ALLOW_POPUPS = 0x8000;
/**
* This flag specifies that the URI classifier should not be checked for
* this load. This flag must not be passed to Reload.
*/
const unsigned long LOAD_FLAGS_BYPASS_CLASSIFIER = 0x10000;
/**
* Force relevant cookies to be sent with this load even if normally they
* wouldn't be.
*/
const unsigned long LOAD_FLAGS_FORCE_ALLOW_COOKIES = 0x20000;
/**
* Prevent the owner principal from being inherited for this load.
*/
const unsigned long LOAD_FLAGS_DISALLOW_INHERIT_PRINCIPAL = 0x40000;
/**
* Overwrite the returned error code with a specific result code
* when an error page is displayed.
*/
const unsigned long LOAD_FLAGS_ERROR_LOAD_CHANGES_RV = 0x80000;
/**
* This flag specifies that the URI may be submitted to a third-party
* server for correction. This should only be applied to non-sensitive
* URIs entered by users. This flag must not be passed to Reload.
*/
const unsigned long LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP = 0x100000;
/**
* This flag specifies that common scheme typos should be corrected.
*/
const unsigned long LOAD_FLAGS_FIXUP_SCHEME_TYPOS = 0x200000;
/**
* Allows a top-level data: navigation to occur. E.g. view-image
* is an explicit user action which should be allowed.
*/
const unsigned long LOAD_FLAGS_FORCE_ALLOW_DATA_URI = 0x400000;
/**
* This load is the result of an HTTP redirect.
*/
const unsigned long LOAD_FLAGS_IS_REDIRECT = 0x800000;
/**
* These flags force TRR modes 1 or 3 for the load.
*/
const unsigned long LOAD_FLAGS_DISABLE_TRR = 0x1000000;
const unsigned long LOAD_FLAGS_FORCE_TRR = 0x2000000;
/**
* This load should bypass the LoadURIDelegate.loadUri.
*/
const unsigned long LOAD_FLAGS_BYPASS_LOAD_URI_DELEGATE = 0x4000000;
/**
* This load has a user activation. (e.g: reload button was clicked)
*/
const unsigned long LOAD_FLAGS_USER_ACTIVATION = 0x8000000;
/**
* Loads a given URI. This will give priority to loading the requested URI
* in the object implementing this interface. If it can't be loaded here
* however, the URI dispatcher will go through its normal process of content
* loading.
*
* @param aURI
* The URI to load.
* @param aLoadURIOptions
* A JSObject defined in LoadURIOptions.webidl holding info like e.g.
* the triggeringPrincipal, the referrer info.
*/
[implicit_jscontext, binaryname(LoadURIFromScript)]
void loadURI(in nsIURI aURI,
in jsval aLoadURIOptions);
/**
* Parse / fix up a URI out of the string and load it.
* This will give priority to loading the requested URI
* in the object implementing this interface. If it can't be loaded here
* however, the URI dispatcher will go through its normal process of content
* loading.
*
* @param aURIString
* The URI string to load. For HTTP and FTP URLs and possibly others,
* characters above U+007F will be converted to UTF-8 and then URL-
* escaped per the rules of RFC 2396.
* This method may use nsIURIFixup to try to fix up typos etc. in the
* input string based on the load flag arguments in aLoadURIOptions.
* It can even convert the input to a search results page using the
* default search service.
* If you have an nsIURI anyway, prefer calling `loadURI`, above.
* @param aLoadURIOptions
* A JSObject defined in LoadURIOptions.webidl holding info like e.g.
* the triggeringPrincipal, the referrer info.
*/
[implicit_jscontext, binaryname(FixupAndLoadURIStringFromScript)]
void fixupAndLoadURIString(in AString aURIString,
in jsval aLoadURIOptions);
/**
* A C++ friendly version of loadURI
*/
[nostdcall, binaryname(LoadURI)]
void binaryLoadURI(in nsIURI aURI,
in LoadURIOptionsRef aLoadURIOptions);
/**
* A C++ friendly version of fixupAndLoadURIString
*/
[nostdcall, binaryname(FixupAndLoadURIString)]
void binaryFixupAndLoadURIString(in AString aURIString,
in LoadURIOptionsRef aLoadURIOptions);
/**
* Tells the Object to reload the current page. There may be cases where the
* user will be asked to confirm the reload (for example, when it is
* determined that the request is non-idempotent).
*
* @param aReloadFlags
* Flags modifying load behaviour. This parameter is a bitwise
* combination of the Load Flags defined above. (Undefined bits are
* reserved for future use.) Generally you will pass LOAD_FLAGS_NONE
* for this parameter.
*
* @throw NS_BINDING_ABORTED
* Indicating that the user canceled the reload.
*/
void reload(in unsigned long aReloadFlags);
/****************************************************************************
* The following flags may be passed as the stop flags parameter to the stop
* method defined on this interface.
*/
/**
* This flag specifies that all network activity should be stopped. This
* includes both active network loads and pending META-refreshes.
*/
const unsigned long STOP_NETWORK = 0x01;
/**
* This flag specifies that all content activity should be stopped. This
* includes animated images, plugins and pending Javascript timeouts.
*/
const unsigned long STOP_CONTENT = 0x02;
/**
* This flag specifies that all activity should be stopped.
*/
const unsigned long STOP_ALL = 0x03;
/**
* Stops a load of a URI.
*
* @param aStopFlags
* This parameter is one of the stop flags defined above.
*/
void stop(in unsigned long aStopFlags);
/**
* Retrieves the current DOM document for the frame, or lazily creates a
* blank document if there is none. This attribute never returns null except
* for unexpected error situations.
*/
readonly attribute Document document;
/**
* The currently loaded URI or null.
*/
readonly attribute nsIURI currentURI;
/**
* The session history object used by this web navigation instance. This
* object will be a mozilla::dom::ChildSHistory object, but is returned as
* nsISupports so it can be called from JS code.
*/
[binaryname(SessionHistoryXPCOM)]
readonly attribute nsISupports sessionHistory;
%{ C++
/**
* Get the session history object used by this nsIWebNavigation instance.
* Use this method instead of the XPCOM method when getting the
* SessionHistory from C++ code.
*/
already_AddRefed<mozilla::dom::ChildSHistory>
GetSessionHistory()
{
nsCOMPtr<nsISupports> history;
GetSessionHistoryXPCOM(getter_AddRefs(history));
return history.forget()
.downcast<mozilla::dom::ChildSHistory>();
}
%}
/**
* Resume a load which has been redirected from another process.
*
* A negative |aHistoryIndex| value corresponds to a non-history load being
* resumed.
*/
void resumeRedirectedLoad(in unsigned long long aLoadIdentifier,
in long aHistoryIndex);
};