| amIAddonManagerStartup.rs |
[implicit_jscontext] jsval readStartupData (); |
10539 |
| amIWebInstallPrompt.rs |
/// * amIWebInstallPrompt is used, if available, by the default implementation of
/// * amIWebInstallInfo to display a confirmation UI to the user before running
/// * installs.
/// |
6219 |
| domstubs.rs |
|
413 |
| extIWebNavigation.rs |
void onDocumentChange (in BrowsingContext bc, in jsval transitionData, in nsIURI location); |
7699 |
| IJSDebugger.rs |
/// * Do not use this interface. Instead, write:
/// * const { addDebuggerToGlobal } = ChromeUtils.importESModule(
/// * "resource://gre/modules/jsdebugger.sys.mjs"
/// * );
/// * addDebuggerToGlobal(global);
/// |
5398 |
| imgICache.rs |
/// * imgICache interface
/// *
/// * @author Stuart Parmenter <pavlov@netscape.com>
/// * @version 0.1
/// * @see imagelib2
/// |
11073 |
| imgIContainer.rs |
/// * imgIContainer is the interface that represents an image. It allows
/// * access to frames as Thebes surfaces. It also allows drawing of images
/// * onto Thebes contexts.
/// *
/// * Internally, imgIContainer also manages animation of images.
/// |
40423 |
| imgIContainerDebug.rs |
/// * This interface is used in debug builds (and only there) in
/// * order to let automatic tests running JavaScript access
/// * internal state of imgContainers. This lets us test
/// * things like animation.
/// |
5874 |
| imgIEncoder.rs |
/// * imgIEncoder interface
/// |
8747 |
| imgILoader.rs |
/// * imgILoader interface
/// *
/// * @author Stuart Parmenter <pavlov@netscape.com>
/// * @version 0.3
/// * @see imagelib2
/// |
10257 |
| imgINotificationObserver.rs |
[noscript,nostdcall,notxpcom] void notify (in imgIRequest aProxy, in long aType, [const] in nsIntRect aRect); |
5740 |
| imgIRequest.rs |
/// * imgIRequest interface
/// *
/// * @author Stuart Parmenter <stuart@mozilla.com>
/// * @version 0.1
/// * @see imagelib2
/// |
25596 |
| imgIScriptedNotificationObserver.rs |
|
8621 |
| imgITools.rs |
imgIContainer decodeImageFromBuffer (in string aBuffer, in unsigned long aSize, in ACString aMimeType); |
24143 |
| inIDeepTreeWalker.rs |
attribute boolean showAnonymousContent; |
11655 |
| IPeerConnection.rs |
|
10986 |
| IUrlClassifierUITelemetry.rs |
|
7117 |
| mozIAppServicesLogger.rs |
void register (in AString target, in mozIServicesLogSink logger); |
5483 |
| mozIAsyncHistory.rs |
readonly attribute long long visitId; |
36592 |
| mozIBridgedSyncEngine.rs |
void handleSuccess (in nsIVariant result); |
25547 |
| mozIDOMWindow.rs |
|
9514 |
| mozIDownloadPlatform.rs |
[implicit_jscontext] Promise downloadDone (in nsIURI aSource, in nsIURI aReferrer, in nsIFile aTarget, in ACString aContentType, in boolean aIsPrivate); |
7543 |
| mozIExtensionAPIRequestHandling.rs |
|
45380 |
| mozIExtensionProcessScript.rs |
void preloadContentScript (in nsISupports contentScript); |
6598 |
| mozIExtensionStorageArea.rs |
void set (in AUTF8String extensionId, in AUTF8String json, in mozIExtensionStorageCallback callback); |
32507 |
| mozIGeckoMediaPluginChromeService.rs |
|
10257 |
| mozIGeckoMediaPluginService.rs |
readonly attribute nsIThread thread; |
10471 |
| mozIInterruptible.rs |
void interrupt (); |
5136 |
| mozIJSSubScriptLoader.rs |
/// * Interface for synchronous script loads from local file: or jar: sources.
/// * For asynchronous script loads, ChromeUtils.compileScript() should be used
/// * instead.
/// |
7942 |
| mozILocaleService.rs |
readonly attribute ACString defaultLocale; |
20823 |
| mozIMozIntl.rs |
/// * This is a set of APIs that are of general usefulness for user interface
/// * internationalization.
/// *
/// * They're all in various stages of the standardization process through
/// * ECMA402, so they are exposed to privileged content only but are written
/// * in the way to allow for easy migration to standard Intl object once
/// * the appropriate stage of the ECMA402 is achieved.
/// *
/// * The exact structure of the code is a little bit complex because of that:
/// *
/// * 1) The core is in SpiderMonkey together with other Intl APIs
/// *
/// * This allows us to write the code once, stick to the spec language
/// * of the proposal, reuse our ICU bindings in Spidermonkey and use
/// * the code to inform us on refining the spec proposal for the given API itself.
/// *
/// * 2) The MozIntlHelper API exposes the SpiderMonkey APIs
/// *
/// * This helper API allows attaching the new APIs on any regular object.
/// *
/// * 3) The MozIntl API provides the access to those APIs
/// *
/// * This API exposes the actual functionality and wraps around the MozIntlHelper
/// * lazily retrieving and setting the accessors.
/// * On top of that, the API also binds additional functionality like using
/// * current application locale by default, and fetching OS regional preferences
/// * for date time format.
/// |
11901 |
| mozIMozIntlHelper.rs |
/// * This is an internal helper for mozIMozIntl API. There should be virtually
/// * no reason for you to call this API except from mozIMozIntl implementation.
/// *
/// * This API helps accessing the SpiderMonkey Intl APIs, but it is mozIMozIntl
/// * that exposes the thin wrapper around them that binds the functionality
/// * to Gecko.
/// |
8541 |
| mozIOSPreferences.rs |
readonly attribute Array<ACString> systemLocales; |
10424 |
| mozIPersonalDictionary.rs |
/// * This interface represents a Personal Dictionary.
/// |
8830 |
| mozIPlacesAutoComplete.rs |
/// * This interface provides some constants used by the Places AutoComplete
/// * search provider as well as methods to track opened pages for AutoComplete
/// * purposes.
/// |
8141 |
| mozIPlacesPendingOperation.rs |
void cancel (); |
5531 |
| mozIRemoteLazyInputStream.rs |
[noscript] nsIInputStream TakeInternalStream (); |
6512 |
| mozISandboxReporter.rs |
readonly attribute uint64_t msecAgo; |
18767 |
| mozISandboxSettings.rs |
readonly attribute long effectiveContentSandboxLevel; |
6563 |
| mozISandboxTest.rs |
void startTests (in Array<ACString> aProcessesList); |
5607 |
| mozIServicesLogSink.rs |
attribute short maxLevel; |
7766 |
| mozISpellCheckingEngine.rs |
/// * This interface represents a SpellChecker.
/// |
13475 |
| mozIStorageAsyncConnection.rs |
/// * mozIStorageAsyncConnection represents an asynchronous database
/// * connection attached to a specific file or to an in-memory data
/// * storage. It is the primary interface for interacting with a
/// * database from the main thread, including creating prepared
/// * statements, executing SQL, and examining database errors.
/// |
42257 |
| mozIStorageAsyncStatement.rs |
/// * An asynchronous SQL statement. This differs from mozIStorageStatement by
/// * only being usable for asynchronous execution. (mozIStorageStatement can
/// * be used for both synchronous and asynchronous purposes.) This specialization
/// * for asynchronous operation allows us to avoid needing to acquire
/// * synchronization primitives also used by the asynchronous execution thread.
/// * In contrast, mozIStorageStatement may need to acquire the primitives and
/// * consequently can cause the main thread to lock for extended intervals while
/// * the asynchronous thread performs some long-running operation.
/// |
5762 |
| mozIStorageBaseStatement.rs |
/// * The base interface for both pure asynchronous storage statements
/// * (mozIStorageAsyncStatement) and 'classic' storage statements
/// * (mozIStorageStatement) that can be used for both synchronous and asynchronous
/// * purposes.
/// |
13421 |
| mozIStorageBindingParams.rs |
void bindByName (in AUTF8String aName, in nsIVariant aValue); |
23803 |
| mozIStorageBindingParamsArray.rs |
mozIStorageBindingParams newBindingParams (); |
7129 |
| mozIStorageCompletionCallback.rs |
void complete (in nsresult status, [optional] in nsISupports value); |
6140 |
| mozIStorageConnection.rs |
/// * mozIStorageConnection represents a database connection attached to
/// * a specific file or to the in-memory data storage. It is the
/// * primary interface for interacting with a database, including
/// * creating prepared statements, executing SQL, and examining database
/// * errors.
/// *
/// * @note From the main thread, you should rather use mozIStorageAsyncConnection.
/// *
/// * @threadsafe
/// |
25116 |
| mozIStorageError.rs |
readonly attribute long result; |
9320 |
| mozIStorageFunction.rs |
/// * mozIStorageFunction is to be implemented by storage consumers that
/// * wish to receive callbacks during the request execution.
/// *
/// * SQL can apply functions to values from tables. Examples of
/// * such functions are MIN(a1,a2) or SQRT(num). Many functions are
/// * implemented in SQL engine.
/// *
/// * This interface allows consumers to implement their own,
/// * problem-specific functions.
/// * These functions can be called from triggers, too.
/// *
/// |
6393 |
| mozIStoragePendingStatement.rs |
void cancel (); |
5705 |
| mozIStorageProgressHandler.rs |
/// * mozIProgressHandler is to be implemented by storage consumers that
/// * wish to receive callbacks during the request execution.
/// |
6096 |
| mozIStorageResultSet.rs |
mozIStorageRow getNextRow (); |
5607 |
| mozIStorageRow.rs |
nsIVariant getResultByIndex (in unsigned long aIndex); |
6662 |
| mozIStorageService.rs |
/// * PRIVACY WARNING
/// * ===============
/// *
/// * Database file names can be exposed through telemetry and in crash reports on
/// * the https://crash-stats.mozilla.org site, to allow recognizing the affected
/// * database.
/// * if your database name may contain privacy sensitive information, e.g. an
/// * URL origin, you should use openDatabaseWithFileURL and pass an explicit
/// * TelemetryFilename to it. That name will be used both for telemetry and for
/// * thread names in crash reports.
/// * If you have different needs (e.g. using the javascript module or an async
/// * connection from the main thread) please coordinate with the mozStorage peers.
/// |
22036 |
| mozIStorageStatement.rs |
/// * A SQL statement that can be used for both synchronous and asynchronous
/// * purposes.
/// |
24807 |
| mozIStorageStatementCallback.rs |
void handleResult (in mozIStorageResultSet aResultSet); |
7816 |
| mozIStorageVacuumParticipant.rs |
/// * This interface contains the information that the Storage service needs to
/// * vacuum a database. This interface is created as a service through the
/// * category manager with the category "vacuum-participant".
/// * Please see https://developer.mozilla.org/en/mozIStorageVacuumParticipant for
/// * more information.
/// |
9841 |
| mozIStorageValueArray.rs |
/// * mozIStorageValueArray wraps an array of SQL values, such as a single database
/// * row.
/// |
14090 |
| mozISyncedBookmarksMirror.rs |
|
29325 |
| mozITestInterfaceJS.rs |
/// * An interface to allow testing of binding interactions with JS-implemented
/// * XPCOM components. The actual implementation is TestInterfaceJS, just like
/// * for TestInteraceJS.webidl.
/// |
5840 |
| mozIThirdPartyUtil.rs |
/// * Utility functions for determining whether a given URI, channel, or window
/// * hierarchy is third party with respect to a known URI.
/// |
16250 |
| mozITXTToHTMLConv.rs |
AString scanTXT (in AString text, in unsigned long whattodo); |
9987 |
| NotXPCOMTest.rs |
void method1 (); |
10282 |
| nsCExternalHandlerService.rs |
|
112 |
| nsCURILoader.rs |
|
93 |
| nsIAboutModule.rs |
nsIChannel newChannel (in nsIURI aURI, in nsILoadInfo aLoadInfo); |
10058 |
| nsIAboutNewTabService.rs |
readonly attribute ACString defaultURL; |
7185 |
| nsIAboutThirdParty.rs |
readonly attribute AString name; |
15820 |
| nsIAboutWindowsMessages.rs |
void getMessages (in mozIDOMWindowProxy currentWindow, out Array<Array<ACString>> messages, out Array<AString> windowTitles); |
5911 |
| nsIAccessibilityService.rs |
/// * An interface for in-process accessibility clients wishing to get an
/// * nsIAccessible for a given DOM node. More documentation at:
/// * http://www.mozilla.org/projects/ui/accessibility
/// |
16027 |
| nsIAccessible.rs |
/// * A cross-platform interface that supports platform-specific
/// * accessibility APIs like MSAA and ATK. Contains the sum of what's needed
/// * to support IAccessible as well as ATK's generic accessibility objects.
/// * Can also be used by in-process accessibility clients to get information
/// * about objects in the accessible tree. The accessible tree is a subset of
/// * nodes in the DOM tree -- such as documents, focusable elements and text.
/// * Mozilla creates the implementations of nsIAccessible on demand.
/// * See http://www.mozilla.org/projects/ui/accessibility for more information.
/// |
36997 |
| nsIAccessibleAnnouncementEvent.rs |
/// * Fired when announce() is called on the target accessible.
/// |
6224 |
| nsIAccessibleApplication.rs |
/// * This interface is implemented by top level accessible object in hierarchy and
/// * provides information about application.
/// |
7390 |
| nsIAccessibleCaretMoveEvent.rs |
/// * Fired when the caret changes position in text.
/// |
7384 |
| nsIAccessibleDocument.rs |
/// * An interface for in-process accessibility clients
/// * that wish to retrieve information about a document.
/// * When accessibility is turned on in Gecko,
/// * there is an nsIAccessibleDocument for each document
/// * whether it is XUL, HTML or whatever.
/// * You can QueryInterface to nsIAccessibleDocument from the nsIAccessible for
/// * the root node of a document or you can get one from
/// * nsIAccessible::GetDocument().
/// |
10526 |
| nsIAccessibleEditableText.rs |
void setTextContents (in AString text); |
9459 |
| nsIAccessibleEvent.rs |
/// * An interface for accessibility events listened to
/// * by in-process accessibility clients, which can be used
/// * to find out how to get accessibility and DOM interfaces for
/// * the event and its target. To listen to in-process accessibility invents,
/// * make your object an nsIObserver, and listen for accessible-event by
/// * using code something like this:
/// * nsCOMPtr<nsIObserverService> observerService =
/// * do_GetService("@mozilla.org/observer-service;1", &rv);
/// * if (NS_SUCCEEDED(rv))
/// * rv = observerService->AddObserver(this, "accessible-event", PR_TRUE);
/// |
15343 |
| nsIAccessibleHideEvent.rs |
/// * Fired when a accessible and its subtree are removed from the tree.
/// |
6967 |
| nsIAccessibleHyperLink.rs |
/// * A cross-platform interface that supports hyperlink-specific properties and
/// * methods. Anchors, image maps, xul:labels with class="text-link" implement this interface.
/// |
9484 |
| nsIAccessibleHyperText.rs |
/// * A cross-platform interface that deals with text which contains hyperlinks.
/// * Each link is an embedded object representing exactly 1 character within
/// * the hypertext.
/// *
/// * Current implementation assumes every embedded object is a link.
/// |
7873 |
| nsIAccessibleImage.rs |
void getImagePosition (in unsigned long coordType, out long x, out long y); |
6424 |
| nsIAccessibleMacInterface.rs |
/// * A generic NSISupports wrapper for native NSObjects.
/// |
21374 |
| nsIAccessibleObjectAttributeChangedEvent.rs |
/// * Fired when an attribute of an accessible changes.
/// |
6134 |
| nsIAccessiblePivot.rs |
/// * The pivot interface encapsulates a reference to a single place in an accessible
/// * subtree. The pivot is a point or a range in the accessible tree. This interface
/// * provides traversal methods to move the pivot to next/prev state that complies
/// * to a given rule.
/// |
15863 |
| nsIAccessibleRelation.rs |
/// * This interface gives access to an accessible's set of relations.
/// |
13175 |
| nsIAccessibleRole.rs |
/// * Defines cross platform (Gecko) roles.
/// |
35954 |
| nsIAccessibleScrollingEvent.rs |
readonly attribute unsigned long scrollX; |
7317 |
| nsIAccessibleSelectable.rs |
/// * An accessibility interface for selectable widgets.
/// |
9516 |
| nsIAccessibleStateChangeEvent.rs |
/// * Fired when a state of an accessible changes.
/// |
6865 |
| nsIAccessibleStates.rs |
|
7733 |
| nsIAccessibleTable.rs |
readonly attribute nsIAccessible caption; |
31288 |
| nsIAccessibleTableChangeEvent.rs |
|
6244 |
| nsIAccessibleText.rs |
attribute long caretOffset; |
24681 |
| nsIAccessibleTextChangeEvent.rs |
/// * Fired when an accessible's text changes.
/// |
7300 |
| nsIAccessibleTextLeafRange.rs |
attribute nsIAccessible accessible; |
8206 |
| nsIAccessibleTextRange.rs |
/// * A range representing a piece of text in the document.
/// |
9951 |
| nsIAccessibleTextSelectionChangeEvent.rs |
/// * Fired when the caret changes position in text.
/// |
6092 |
| nsIAccessibleTypes.rs |
/// * These constants control the scrolling of an object or substring into a
/// * window. Note, keep them synchronized with IA2ScrollType.
/// |
12532 |
| nsIAccessibleValue.rs |
readonly attribute double maximumValue; |
7023 |
| nsIAddonPolicyService.rs |
/// * This interface allows the security manager to query custom per-addon security
/// * policy.
/// |
19136 |
| nsIAlertsService.rs |
|
68242 |
| nsIApplicationChooser.rs |
|
12548 |
| nsIApplicationReputation.rs |
|
24421 |
| nsIAppShell.rs |
/// * Interface for the native event system layer. This interface is designed
/// * to be used on the main application thread only.
/// |
8711 |
| nsIAppShellService.rs |
nsIAppWindow createTopLevelWindow (in nsIAppWindow aParent, in nsIURI aUrl, in uint32_t aChromeMask, in long aInitialWidth, in long aInitialHeight); |
13604 |
| nsIAppStartup.rs |
[noscript] void createHiddenWindow (); |
23044 |
| nsIAppWindow.rs |
readonly attribute nsIDocShell docShell; |
20241 |
| nsIArray.rs |
/// * nsIArray
/// *
/// * An indexed collection of elements. Provides basic functionality for
/// * retrieving elements at a specific position, searching for
/// * elements. Indexes are zero-based, such that the last element in the
/// * array is stored at the index length-1.
/// *
/// * For an array which can be modified, see nsIMutableArray below.
/// *
/// * Neither interface makes any attempt to protect the individual
/// * elements from modification. The convention is that the elements of
/// * the array should not be modified. Documentation within a specific
/// * interface should describe variations from this convention.
/// *
/// * It is also convention that if an interface provides access to an
/// * nsIArray, that the array should not be QueryInterfaced to an
/// * nsIMutableArray for modification. If the interface in question had
/// * intended the array to be modified, it would have returned an
/// * nsIMutableArray!
/// *
/// * null is a valid entry in the array, and as such any nsISupports
/// * parameters may be null, except where noted.
/// |
10326 |
| nsIArrayBufferInputStream.rs |
/// * nsIArrayBufferInputStream
/// *
/// * Provides scriptable methods for initializing a nsIInputStream
/// * implementation with an ArrayBuffer.
/// |
6532 |
| nsIArrayExtensions.rs |
/// * Helper interface for allowing scripts to treat nsIArray instances as if
/// * they were nsISupportsArray instances while iterating.
/// *
/// * nsISupportsArray is convenient to iterate over in JavaScript:
/// *
/// * for (let i = 0; i < array.Count(); ++i) {
/// * let elem = array.GetElementAt(i);
/// * ...
/// * }
/// *
/// * but doing the same with nsIArray is somewhat less convenient, since
/// * queryElementAt is not nearly so nice to use from JavaScript. So we provide
/// * this extension interface so interfaces that currently return
/// * nsISupportsArray can start returning nsIArrayExtensions and all JavaScript
/// * should Just Work. Eventually we'll roll this interface into nsIArray
/// * itself, possibly getting rid of the Count() method, as it duplicates
/// * nsIArray functionality.
/// |
7224 |
| nsIAsyncInputStream.rs |
/// * If an input stream is non-blocking, it may return NS_BASE_STREAM_WOULD_BLOCK
/// * when read. The caller must then wait for the stream to have some data to
/// * read. If the stream implements nsIAsyncInputStream, then the caller can use
/// * this interface to request an asynchronous notification when the stream
/// * becomes readable or closed (via the AsyncWait method).
/// *
/// * While this interface is almost exclusively used with non-blocking streams, it
/// * is not necessary that nsIInputStream::isNonBlocking return true. Nor is it
/// * necessary that a non-blocking nsIInputStream implementation also implement
/// * nsIAsyncInputStream.
/// |
16322 |
| nsIAsyncOutputStream.rs |
/// * If an output stream is non-blocking, it may return NS_BASE_STREAM_WOULD_BLOCK
/// * when written to. The caller must then wait for the stream to become
/// * writable. If the stream implements nsIAsyncOutputStream, then the caller can
/// * use this interface to request an asynchronous notification when the stream
/// * becomes writable or closed (via the AsyncWait method).
/// *
/// * While this interface is almost exclusively used with non-blocking streams, it
/// * is not necessary that nsIOutputStream::isNonBlocking return true. Nor is it
/// * necessary that a non-blocking nsIOutputStream implementation also implement
/// * nsIAsyncOutputStream.
/// |
16310 |
| nsIAsyncShutdown.rs |
/// * A blocker installed by a client to be informed during some stage of
/// * shutdown and block shutdown asynchronously until some condition is
/// * complete.
/// *
/// * If you wish to use AsyncShutdown, you will need to implement this
/// * interface (and only this interface).
/// |
39792 |
| nsIAsyncStreamCopier.rs |
void init (in nsIInputStream aSource, in nsIOutputStream aSink, in nsIEventTarget aTarget, in boolean aSourceBuffered, in boolean aSinkBuffered, in unsigned long aChunkSize, in boolean aCloseSource, in boolean aCloseSink); |
8464 |
| nsIAsyncStreamCopier2.rs |
void init (in nsIInputStream aSource, in nsIOutputStream aSink, in nsIEventTarget aTarget, in unsigned long aChunkSize, in boolean aCloseSource, in boolean aCloseSink); |
8128 |
| nsIAsyncVerifyRedirectCallback.rs |
void onRedirectVerifyCallback (in nsresult result); |
6049 |
| nsIAudioChannelAgent.rs |
|
22547 |
| nsIAudioDeviceInfo.rs |
readonly attribute AString name; |
11083 |
| nsIAuthInformation.rs |
/// * A object that hold authentication information. The caller of
/// * nsIAuthPrompt2::promptUsernameAndPassword or
/// * nsIAuthPrompt2::promptPasswordAsync provides an object implementing this
/// * interface; the prompt implementation can then read the values here to prefill
/// * the dialog. After the user entered the authentication information, it should
/// * set the attributes of this object to indicate to the caller what was entered
/// * by the user.
/// |
14108 |
| nsIAuthModule.rs |
void init (in ACString aServiceName, in unsigned long aServiceFlags, in AString aDomain, in AString aUsername, in AString aPassword); |
13229 |
| nsIAuthPrompt.rs |
boolean prompt (in wstring dialogTitle, in wstring text, in wstring passwordRealm, in uint32_t savePassword, in wstring defaultText, out wstring result); |
13523 |
| nsIAuthPrompt2.rs |
/// * An interface allowing to prompt for a username and password. This interface
/// * is usually acquired using getInterface on notification callbacks or similar.
/// * It can be used to prompt users for authentication information, either
/// * synchronously or asynchronously.
/// |
10416 |
| nsIAuthPromptAdapterFactory.rs |
/// * An interface for wrapping nsIAuthPrompt interfaces to make
/// * them usable via an nsIAuthPrompt2 interface.
/// |
5933 |
| nsIAuthPromptCallback.rs |
/// * Interface for callback methods for the asynchronous nsIAuthPrompt2 method.
/// * Callers MUST call exactly one method if nsIAuthPrompt2::promptPasswordAsync
/// * returns successfully. They MUST NOT call any method on this interface before
/// * promptPasswordAsync returns.
/// |
7306 |
| nsIAuthPromptProvider.rs |
void getAuthPrompt (in uint32_t aPromptReason, in nsIIDRef iid, [iid_is (iid), retval] out nsQIResult result); |
6513 |
| nsIAutoCompleteController.rs |
[setter_can_run_script] attribute nsIAutoCompleteInput input; |
15638 |
| nsIAutoCompleteInput.rs |
readonly attribute Element popupElement; |
21413 |
| nsIAutoCompletePopup.rs |
readonly attribute nsIAutoCompleteInput input; |
10798 |
| nsIAutoCompleteResult.rs |
readonly attribute AString searchString; |
13049 |
| nsIAutoCompleteSearch.rs |
void startSearch (in AString searchString, in AString searchParam, in nsIAutoCompleteResult previousResult, in nsIAutoCompleteObserver listener); |
11723 |
| nsIAutoCompleteSimpleResult.rs |
/// * This class implements nsIAutoCompleteResult and provides simple methods
/// * for setting the value and result items. It can be used whenever some basic
/// * auto complete results are needed that can be pre-generated and filled into
/// * an array.
/// |
20358 |
| nsIAutoCompleteSimpleSearch.rs |
|
5771 |
| nsIAutoplay.rs |
|
4815 |
| nsIAvailableMemoryWatcherBase.rs |
/// * nsITabUnloader: interface to represent TabUnloader
/// *
/// * nsIAvailableMemoryWatcherBase: interface to watch the system's memory
/// * status and invoke a registered TabUnloader when it detected a low-memory
/// * and high-memory situation. The logic to detect such a memory situation
/// * is defined per platform.
/// |
11446 |
| nsIBackgroundChannelRegistrar.rs |
|
6321 |
| nsIBackgroundFileSaver.rs |
/// * Allows saving data to a file, while handling all the input/output on a
/// * background thread, including the initial file name assignment and any
/// * subsequent renaming of the target file.
/// *
/// * This interface is designed for file downloads. Generally, they start in the
/// * temporary directory, while the user is selecting the final name. Then, they
/// * are moved to the chosen target directory with a ".part" extension appended to
/// * the file name. Finally, they are renamed when the download is completed.
/// *
/// * Components implementing both nsIBackgroundFileSaver and nsIStreamListener
/// * allow data to be fed using an implementation of OnDataAvailable that never
/// * blocks the calling thread. They suspend the request that drives the stream
/// * listener in case too much data is being fed, and resume it when the data has
/// * been written. Calling OnStopRequest does not necessarily close the target
/// * file, and the Finish method must be called to complete the operation.
/// *
/// * Components implementing both nsIBackgroundFileSaver and nsIAsyncOutputStream
/// * allow data to be fed directly to the non-blocking output stream, that however
/// * may return NS_BASE_STREAM_WOULD_BLOCK in case too much data is being fed.
/// * Closing the output stream does not necessarily close the target file, and the
/// * Finish method must be called to complete the operation.
/// *
/// * @remarks Implementations may require the consumer to always call Finish. If
/// * the object reference is released without calling Finish, a memory
/// * leak may occur, and the target file might be kept locked. All
/// * public methods of the interface may only be called from the main
/// * thread.
/// |
23529 |
| nsIBackgroundTasks.rs |
/// * Determine if this instance is running background task mode and
/// * what, if any, task is active.
/// |
7025 |
| nsIBackgroundTasksManager.rs |
/// * Import and run named backgroundtask implementations.
/// |
6303 |
| nsIBackgroundTasksRunner.rs |
void runInDetachedProcess (in ACString aTaskName, in Array<ACString> aCommandLine); |
8030 |
| nsIBaseChannel.rs |
attribute ContentRangeRef contentRange; |
7003 |
| nsIBaseWindow.rs |
/// * The nsIBaseWindow describes a generic window and basic operations that
/// * can be performed on it. This is not to be a complete windowing interface
/// * but rather a common set that nearly all windowed objects support.
/// |
16158 |
| nsIBFCacheEntry.rs |
/// * This interface lets you evict a document from the back/forward cache.
/// |
5615 |
| nsIBidiKeyboard.rs |
void reset (); |
6506 |
| nsIBinaryHttp.rs |
readonly attribute ACString method; |
21498 |
| nsIBinaryInputStream.rs |
/// * This interface allows consumption of primitive data types from a "binary
/// * stream" containing untagged, big-endian binary data, i.e. as produced by an
/// * implementation of nsIBinaryOutputStream. This might be used, for example,
/// * to implement network protocols or to read from architecture-neutral disk
/// * files, i.e. ones that can be read and written by both big-endian and
/// * little-endian platforms.
/// *
/// * @See nsIBinaryOutputStream
/// |
12228 |
| nsIBinaryOutputStream.rs |
/// * This interface allows writing of primitive data types (integers,
/// * floating-point values, booleans, etc.) to a stream in a binary, untagged,
/// * fixed-endianness format. This might be used, for example, to implement
/// * network protocols or to produce architecture-neutral binary disk files,
/// * i.e. ones that can be read and written by both big-endian and little-endian
/// * platforms. Output is written in big-endian order (high-order byte first),
/// * as this is traditional network order.
/// *
/// * @See nsIBinaryInputStream
/// |
12236 |
| nsIBits.rs |
/// * An interface for interacting with Windows Background Intelligent Transfer
/// * Service. This should only be used on Windows.
/// *
/// * It would be preferable for the functions in this interface to return
/// * Promises, but this interface is implemented in Rust, which does not yet have
/// * support for Promises. There is a JS wrapper around this class that should be
/// * preferred over using this interface directly, located in Bits.sys.mjs.
/// *
/// * Methods of this class that take a nsIBitsNewRequestCallback do not return or
/// * throw errors. All errors will be reported through the callback. The only
/// * things that should cause methods to directly throw errors are null arguments.
/// |
49210 |
| nsIBlocklistService.rs |
readonly attribute boolean isLoaded; |
5433 |
| nsIBounceTrackingMapEntry.rs |
/// * This interface represents an entry in the global bounce tracker or user activation map.
/// |
11584 |
| nsIBounceTrackingProtection.rs |
void clearAll (); |
13164 |
| nsIBrowser.rs |
void dropLinks (in Array<AString> links, in nsIPrincipal triggeringPrincipal); |
20431 |
| nsIBrowserChild.rs |
readonly attribute ContentFrameMessageManager messageManager; |
8158 |
| nsIBrowserController.rs |
/// * This interface is used to accompany the nsIController for a
/// * <browser> element. It is used to update the commands in the
/// * parent process when the set of child command have changed.
/// |
6057 |
| nsIBrowserDOMWindow.rs |
readonly attribute nsIOpenWindowInfo openWindowInfo; |
25730 |
| nsIBrowserHandler.rs |
attribute AUTF8String startPage; |
10021 |
| nsIBrowserUsage.rs |
uint32_t getUniqueDomainsVisitedInPast24Hours (); |
5450 |
| nsIBrowserWindowTracker.rs |
attribute AString contentTitle; |
12459 |
| nsIBTPRemoteExceptionList.rs |
/// * Helper for syncing remote settings exception list to
/// * BounceTrackingProtection.
/// |
6079 |
| nsIBufferedStreams.rs |
/// * An input stream that reads ahead and keeps a buffer coming from another input
/// * stream so that fewer accesses to the underlying stream are necessary.
/// |
12804 |
| nsIByteRangeRequest.rs |
readonly attribute boolean isByteRangeRequest; |
6715 |
| nsICacheEntry.rs |
readonly attribute ACString key; |
38200 |
| nsICacheEntryDoomCallback.rs |
void onCacheEntryDoomed (in nsresult aResult); |
5635 |
| nsICacheEntryOpenCallback.rs |
unsigned long onCacheEntryCheck (in nsICacheEntry aEntry); |
9693 |
| nsICacheInfoChannel.rs |
void onInputStreamReady (in nsIInputStream aStream); |
28030 |
| nsICachePurgeLock.rs |
/// * This object is a wrapper of MultiInstanceLock.
/// * It's intended to be used to ensure exclusive access to folders being
/// * deleted by the purgeHTTPCache background task.
/// |
7578 |
| nsICacheStorage.rs |
/// * Representation of a cache storage. There can be just-in-mem,
/// * in-mem+on-disk, in-mem+on-disk+app-cache or just a specific
/// * app-cache storage.
/// |
14582 |
| nsICacheStorageService.rs |
/// * Provides access to particual cache storages of the network URI cache.
/// |
20434 |
| nsICacheStorageVisitor.rs |
void onCacheStorageInfo (in uint32_t aEntryCount, in uint64_t aConsumption, in uint64_t aCapacity, in nsIFile aDiskDirectory); |
7574 |
| nsICacheTesting.rs |
/// * This is an internal interface used only for testing purposes.
/// *
/// * THIS IS NOT AN API TO BE USED BY EXTENSIONS! ONLY USED BY MOZILLA TESTS.
/// |
6121 |
| nsICachingChannel.rs |
/// * A channel may optionally implement this interface to allow clients
/// * to affect its behavior with respect to how it uses the cache service.
/// *
/// * This interface provides:
/// * 1) Support for "stream as file" semantics (for JAR and plugins).
/// * 2) Support for "pinning" cached data in the cache (for printing and save-as).
/// * 3) Support for uniquely identifying cached data in cases when the URL
/// * is insufficient (e.g., HTTP form submission).
/// |
12656 |
| nsICancelable.rs |
/// * This interface provides a means to cancel an operation that is in progress.
/// |
5622 |
| nsICaptivePortalDetector.rs |
void prepare (); |
13927 |
| nsICaptivePortalService.rs |
|
12801 |
| nsICascadeFilter.rs |
/// * A consumer of a filter cascade, i.e. a cascaded bloom filter as generated by
/// * https://github.com/mozilla/filter-cascade
/// |
6507 |
| nsICategoryManager.rs |
readonly attribute ACString entry; |
16095 |
| nsICertificateDialogs.rs |
/// * Functions that implement user interface dialogs to manage certificates.
/// |
8966 |
| nsICertOverrideService.rs |
readonly attribute ACString asciiHost; |
20703 |
| nsICertStorage.rs |
/// * Callback type used to notify callers that an operation performed by
/// * nsICertStorage has completed. Indicates the result of the requested
/// * operation, as well as any data returned by the operation.
/// |
63533 |
| nsICertTree.rs |
[must_use] readonly attribute nsIX509Cert cert; |
11786 |
| nsIChannel.rs |
attribute nsIURI originalURI; |
43908 |
| nsIChannelClassifierService.rs |
readonly attribute uint8_t reason; |
14626 |
| nsIChannelEventSink.rs |
/// * Implement this interface to receive control over various channel events.
/// * Channels will try to get this interface from a channel's
/// * notificationCallbacks or, if not available there, from the loadGroup's
/// * notificationCallbacks.
/// *
/// * These methods are called before onStartRequest.
/// |
10982 |
| nsIChildChannel.rs |
/// * Implemented by content side of IPC protocols.
/// |
6607 |
| nsIChromeRegistry.rs |
nsIURI convertChromeURL (in nsIURI aChromeURL); |
14941 |
| nsIClassifiedChannel.rs |
/// * nsIClassifiedChannel
/// *
/// * A channel may optionally implement this interface if it carries classified
/// * result information of channel classifier. The information contains, for
/// * example, the name of matched table and the name of matched provider.
/// |
16106 |
| nsIClassInfo.rs |
/// * Provides information about a specific implementation class. If you want
/// * your class to implement nsIClassInfo, see nsIClassInfoImpl.h for
/// * instructions--you most likely do not want to inherit from nsIClassInfo.
/// |
9701 |
| nsIClassOfService.rs |
attribute unsigned long classFlags; |
9311 |
| nsIClearDataService.rs |
/// * nsIClearDataService
/// *
/// * Provides methods for cleaning data from a nsIPrincipal and/or from a time
/// * range.
/// |
33485 |
| nsIClickRule.rs |
[must_use] readonly attribute ACString presence; |
8323 |
| nsIClientAuthDialogService.rs |
void certificateChosen (in nsIX509Cert cert, in boolean rememberDecision); |
12454 |
| nsIClientAuthRememberService.rs |
readonly attribute ACString asciiHost; |
15170 |
| nsIClipboard.rs |
void setData (in nsITransferable aTransferable, [optional] in nsIClipboardOwner aOwner); |
45651 |
| nsIClipboardHelper.rs |
/// * helper service for common uses of nsIClipboard.
/// |
8370 |
| nsIClipboardOwner.rs |
void LosingOwnership (in nsITransferable aTransferable); |
5612 |
| nsICloneableInputStream.rs |
[infallible] readonly attribute boolean cloneable; |
11571 |
| nsIColorPicker.rs |
/// * nsIColorPicker is representing colors as strings because the internal
/// * representation will depend on the underlying backend.
/// * The format of the colors taken in input and returned will always follow the
/// * format of the <input type='color'> value as described in the HTML
/// * specifications.
/// |
14499 |
| nsICommandLine.rs |
/// * Represents the command line used to invoke a XUL application. This may be the
/// * original command-line of this instance, or a command line remoted from another
/// * instance of the application.
/// *
/// * DEFINITIONS:
/// * "arguments" are any values found on the command line.
/// * "flags" are switches. In normalized form they are preceded by a single dash.
/// * Some flags may take "parameters", e.g. "--url <param>".
/// |
16182 |
| nsICommandLineHandler.rs |
/// * Handles arguments on the command line of an XUL application.
/// *
/// * Each handler is registered in the category "command-line-handler".
/// * The entries in this category are read in alphabetical order, and each
/// * category value is treated as a service contractid implementing this
/// * interface.
/// *
/// * By convention, handler with ordinary priority should begin with "m".
/// *
/// * Example:
/// * Category Entry Value
/// * command-line-handler c-extensions @mozilla.org/extension-manager/clh;1
/// * command-line-handler m-edit @mozilla.org/composer/clh;1
/// * command-line-handler m-irc @mozilla.org/chatzilla/clh;1
/// * command-line-handler y-final @mozilla.org/browser/clh-final;1
/// *
/// * @note What do we do about localizing helpInfo? Do we make each handler do it,
/// * or provide a generic solution of some sort? Don't freeze this interface
/// * without thinking about this!
/// |
7811 |
| nsICommandLineRunner.rs |
/// * Extension of nsICommandLine that allows for initialization of new command lines
/// * and running the command line actions by processing the command line handlers.
/// *
/// * @status INTERNAL - This interface is not meant for use by embedders, and is
/// * not intended to be frozen. If you are an embedder and need
/// * functionality provided by this interface, talk to Benjamin
/// * Smedberg <benjamin@smedbergs.us>.
/// |
7772 |
| nsICommandLineValidator.rs |
/// * Validates arguments on the command line of an XUL application.
/// *
/// * Each validator is registered in the category "command-line-validator".
/// * The entries in this category are read in alphabetical order, and each
/// * category value is treated as a service contractid implementing this
/// * interface.
/// *
/// * By convention, validator with ordinary priority should begin with "m".
/// *
/// * Example:
/// * Category Entry Value
/// * command-line-validator b-browser @mozilla.org/browser/clh;1
/// * command-line-validator m-edit @mozilla.org/composer/clh;1
/// * command-line-validator m-irc @mozilla.org/chatzilla/clh;1
/// *
/// |
6530 |
| nsICommandManager.rs |
void addCommandObserver (in nsIObserver aCommandObserver, in string aCommandToObserve); |
9080 |
| nsICommandParams.rs |
short getValueType (in string name); |
11707 |
| nsIComponentManager.rs |
void getClassObject (in nsCIDRef aClass, in nsIIDRef aIID, [iid_is (aIID), retval] out nsQIResult result); |
12852 |
| nsIComponentRegistrar.rs |
void autoRegister (in nsIFile aSpec); |
11512 |
| nsICompressConvStats.rs |
/// * nsICompressConvStats
/// *
/// * This interface allows for the observation of decoded resource sizes
/// |
5533 |
| nsIConsoleAPIStorage.rs |
jsval getEvents ([optional] in AString aId); |
8604 |
| nsIConsoleListener.rs |
void observe (in nsIConsoleMessage aMessage); |
5277 |
| nsIConsoleMessage.rs |
/// * This is intended as a base interface; implementations may want to
/// * provide an object that can be qi'ed to provide more specific
/// * message information.
/// |
9049 |
| nsIConsoleService.rs |
void logMessage (in nsIConsoleMessage message); |
9813 |
| nsIContentAnalysis.rs |
|
70348 |
| nsIContentBlockingAllowList.rs |
/// * This file contains an interface to the ContentBlockingAllowList.
/// |
6215 |
| nsIContentDispatchChooser.rs |
/// * This is used to ask a user what they would like to do with a given piece of
/// * content.
/// |
7038 |
| nsIContentHandler.rs |
void handleContent (in string aContentType, in nsIInterfaceRequestor aWindowContext, in nsIRequest aRequest); |
6598 |
| nsIContentPermissionPrompt.rs |
/// * Interface provides the request type and its access.
/// |
22321 |
| nsIContentPolicy.rs |
/// * Interface for content policy mechanism. Implementations of this
/// * interface can be used to control loading of various types of out-of-line
/// * content, or processing of certain types of in-line content.
/// *
/// * WARNING: do not block the caller from shouldLoad or shouldProcess (e.g.,
/// * by launching a dialog to prompt the user for something).
/// |
14192 |
| nsIContentPrefService2.rs |
void onContentPrefSet (in AString aGroup, in AString aName, in nsIVariant aValue, [optional] in boolean aIsPrivate); |
56866 |
| nsIContentSecurityManager.rs |
/// * nsIContentSecurityManager
/// * Describes an XPCOM component used to perform security checks.
/// |
7009 |
| nsIContentSecurityPolicy.rs |
[binaryname(GetPolicyString)] AString getPolicy (in unsigned long index); |
39262 |
| nsIContentSignatureVerifier.rs |
/// * An interface for verifying content-signatures, inspired by
/// * https://tools.ietf.org/html/draft-thomson-http-content-signature-00
/// * described here https://github.com/franziskuskiefer/content-signature/tree/pki
/// |
7477 |
| nsIContentSniffer.rs |
/// * Content sniffer interface. Components implementing this interface can
/// * determine a MIME type from a chunk of bytes.
/// |
6564 |
| nsIController.rs |
boolean isCommandEnabled (in string command); |
13070 |
| nsIControllerCommand.rs |
/// * nsIControllerCommand
/// *
/// * A generic command interface. You can register an nsIControllerCommand
/// * with the nsIControllerCommandTable.
/// |
9117 |
| nsIControllerCommandTable.rs |
/// * nsIControllerCommandTable
/// *
/// * An interface via which a controller can maintain a series of commands,
/// * and efficiently dispatch commands to their respective handlers.
/// *
/// * Controllers that use an nsIControllerCommandTable should support
/// * nsIInterfaceRequestor, and be able to return an interface to their
/// * controller command table via getInterface().
/// *
/// |
14127 |
| nsIControllerContext.rs |
void setCommandContext (in nsISupports aCommandContext); |
5880 |
| nsIControllers.rs |
nsIController getControllerForCommand (in string command); |
9175 |
| nsIConverterInputStream.rs |
/// * A unichar input stream that wraps an input stream.
/// * This allows reading unicode strings from a stream, automatically converting
/// * the bytes from a selected character encoding.
/// |
7208 |
| nsIConverterOutputStream.rs |
/// * This interface allows writing strings to a stream, doing automatic
/// * character encoding conversion.
/// |
6355 |
| nsICookie.rs |
readonly attribute ACString name; |
15964 |
| nsICookieBannerListService.rs |
/// * Service singleton for initializing and updating the list of cookie banner
/// * handling rules.
/// |
6847 |
| nsICookieBannerRule.rs |
/// * A rule containing instructions on how to handle a cookie banner for a specific
/// * domain.
/// |
14013 |
| nsICookieBannerService.rs |
/// * Service singleton which owns the cookie banner feature.
/// * This service owns the cookie banner handling rules.
/// * It initializes both the component for importing rules
/// * (nsICookieBannerListService) and injecting cookies (nsICookieInjector).
/// |
18655 |
| nsICookieBannerTelemetryService.rs |
/// * Service singleton which collect cookie banner telemetry.
/// |
5288 |
| nsICookieJarSettings.rs |
/// * Cookie jar settings for top-level documents. Please see CookieJarSettings.h
/// * for more details.
/// |
15294 |
| nsICookieManager.rs |
/// * An optional interface for accessing or removing the cookies
/// * that are in the cookie list
/// |
24535 |
| nsICookieNotification.rs |
/// * Meta object dispatched by cookie change notifications.
/// |
10483 |
| nsICookiePermission.rs |
/// * An interface to test for cookie permissions
/// |
5707 |
| nsICookieRule.rs |
/// * Rule which specifies a cookie to be set in order to handle a cookie banner.
/// |
7760 |
| nsICookieService.rs |
/// * @see nsICookieService::runInTransaction
/// |
16272 |
| nsICrashReporter.rs |
/// * Provides access to crash reporting functionality.
/// *
/// * @status UNSTABLE - This interface is not frozen and will probably change in
/// * future releases.
/// |
20123 |
| nsICrashService.rs |
Promise addCrash (in long processType, in long crashType, in AString id); |
5702 |
| nsICredentialChooserService.rs |
|
7513 |
| nsICredentialChosenCallback.rs |
void notify (in AUTF8String aChosenID); |
5642 |
| nsICryptoHash.rs |
/// * nsICryptoHash
/// * This interface provides crytographic hashing algorithms.
/// |
10730 |
| nsICycleCollectorListener.rs |
/// * A set of interfaces for recording the cycle collector's work. An instance
/// * of nsICycleCollectorListener can be configured to enable various
/// * options, then passed to the cycle collector when it runs.
/// * Note that additional logging options are available by setting environment
/// * variables, as described at the top of nsCycleCollector.cpp.
/// |
29344 |
| nsIDAPTelemetry.rs |
void GetReportU8 (in Array<uint8_t> leaderHpkeConfig, in Array<uint8_t> helperHpkeConfig, in uint8_t measurement, in Array<uint8_t> task_id, in uint64_t time_precision, out Array<uint8_t> report); |
9316 |
| nsIDashboard.rs |
void onDashboardDataAvailable (in jsval data); |
15569 |
| nsIDashboardEventNotifier.rs |
void addHost (in ACString aHost, in unsigned long aSerial, in boolean aEncrypted); |
7317 |
| nsIDataChannel.rs |
/// * nsIDataChannel
/// *
/// * This interface allows JS to check if a given channel is a data channel.
/// |
4930 |
| nsIDataStorage.rs |
nsIDataStorage get (in nsIDataStorageManager_DataStorage dataStorage); |
18898 |
| nsIDebug2.rs |
/// * @note C/C++ consumers who are planning to use the nsIDebug2 interface with
/// * the "@mozilla.org/xpcom;1" contract should use NS_DebugBreak from xpcom
/// * glue instead.
/// *
/// |
11572 |
| nsIDefaultAgent.rs |
void registerTask (in AString aUniqueToken); |
17750 |
| nsIDeviceSensors.rs |
readonly attribute unsigned long type; |
13658 |
| nsIDHCPClient.rs |
/// * This interface allows the proxy code to access the DHCP Options in a platform-specific way
/// |
5462 |
| nsIDialogParamBlock.rs |
/// * An interface to pass strings, integers and nsISupports to a dialog
/// |
8696 |
| nsIDirectoryEnumerator.rs |
/// * This interface provides a means for enumerating the contents of a directory.
/// * It is similar to nsISimpleEnumerator except the retrieved entries are QI'ed
/// * to nsIFile, and there is a mechanism for closing the directory when the
/// * enumeration is complete.
/// |
6606 |
| nsIDirectoryService.rs |
/// * nsIDirectoryServiceProvider
/// *
/// * Used by Directory Service to get file locations.
/// |
19789 |
| nsIDirectTaskDispatcher.rs |
[noscript] void dispatchDirectTask (in alreadyAddRefed_nsIRunnable event); |
6745 |
| nsIDirIndex.rs |
A class holding information about a directory index.
/// * These have no reference back to their original source -
/// * changing these attributes won't affect the directory
/// |
9828 |
| nsIDirIndexListener.rs |
/// * This interface is used to receive contents of directory index listings
/// * from a protocol. They can then be transformed into an output format
/// * (such as rdf, html, etc)
/// |
11856 |
| nsIDisplayInfo.rs |
readonly attribute long id; |
5475 |
| nsIDNSAdditionalInfo.rs |
readonly attribute int32_t port; |
5706 |
| nsIDNSByTypeRecord.rs |
readonly attribute unsigned long type; |
70333 |
| nsIDNSListener.rs |
/// * nsIDNSListener
/// |
6232 |
| nsIDNSRecord.rs |
/// * nsIDNSRecord
/// *
/// * this interface represents the result of a DNS lookup. since a DNS
/// * query may return more than one resolved IP address, the record acts
/// * like an enumerator, allowing the caller to easily step through the
/// * list of IP addresses.
/// |
20014 |
| nsIDNSService.rs |
/// * nsIDNSService
/// |
27785 |
| nsIDocShell.rs |
/// * nsIDocShell is an interface corresponding to the native nsDocShell object,
/// * which is a legacy in-process object roughly corresponding to a 'browsing
/// * context', as created for a browser tab or an iframe, for example.
/// *
/// * nsIDocShell has a 1:1 relationship with its paired dom::BrowsingContext and
/// * nsGlobalWindowOuter. It may be replaced during navigation.
/// *
/// * See also the comment documenting dom::BrowsingContext and the documentation
/// * at:
/// *
/// * https://html.spec.whatwg.org/multipage/document-sequences.html#browsing-context
/// * https://firefox-source-docs.mozilla.org/dom/navigation/embedding.html
/// * https://firefox-source-docs.mozilla.org/dom/navigation/nav_replace.html
/// |
81420 |
| nsIDocShellTreeItem.rs |
/// * The nsIDocShellTreeItem supplies the methods that are required of any item
/// * that wishes to be able to live within the docshell tree either as a middle
/// * node or a leaf.
/// |
15358 |
| nsIDocShellTreeOwner.rs |
void contentShellAdded (in nsIDocShellTreeItem aContentShell, in boolean aPrimary); |
14029 |
| nsIDocumentEncoder.rs |
Node fixupNode (in Node aNode, out boolean aSerializeCloneKids); |
31377 |
| nsIDocumentLoader.rs |
/// * An nsIDocumentLoader is an interface responsible for tracking groups of
/// * loads that belong together (images, external scripts, etc) and subdocuments
/// * (<iframe>, <frame>, etc). It is also responsible for sending
/// * nsIWebProgressListener notifications.
/// * XXXbz this interface should go away, we think...
/// |
6799 |
| nsIDocumentLoaderFactory.rs |
/// * To get a component that implements nsIDocumentLoaderFactory
/// * for a given mimetype, use nsContentUtils::FindInternalDocumentViewer.
/// * This will look up the MIME type within the "Gecko-Content-Viewers" category,
/// * with additional handlers for other content types.
/// |
7579 |
| nsIDocumentStateListener.rs |
/// * Due to the historical reason, this listener interface says "document state",
/// * but this listener listens to HTML editor state.
/// |
6759 |
| nsIDocumentViewer.rs |
[noscript] void init (in nsIWidgetPtr aParentWidget, [const] in LayoutDeviceIntRectRef aBounds, in WindowGlobalChildPtr aWindowActor); |
31077 |
| nsIDocumentViewerEdit.rs |
void clearSelection (); |
9309 |
| nsIDomainPolicy.rs |
readonly attribute nsIDomainSet blocklist; |
14076 |
| nsIDOMEventListener.rs |
[can_run_script] void handleEvent (in Event event); |
6107 |
| nsIDOMGeoPosition.rs |
readonly attribute EpochTimeStamp timestamp; |
5728 |
| nsIDOMGeoPositionCallback.rs |
void handleEvent (in nsIDOMGeoPosition position); |
5481 |
| nsIDOMGeoPositionCoords.rs |
readonly attribute double latitude; |
7874 |
| nsIDOMGeoPositionErrorCallback.rs |
|
5630 |
| nsIDOMGlobalPropertyInitializer.rs |
|
5407 |
| nsIDOMProcessChild.rs |
/// * Child actor interface for a process which can host DOM content.
/// *
/// * Implemented by either `InProcessChild` for the parent process, or
/// * `ContentChild` for a content process.
/// |
8024 |
| nsIDOMProcessParent.rs |
/// * Parent actor interface for a process which can host DOM content.
/// *
/// * Implemented by either `InProcessParent` for the parent process, or
/// * `ContentParent` for a content process.
/// |
9188 |
| nsIDOMStorageManager.rs |
/// * General purpose interface that has two implementations, for localStorage
/// * with "@mozilla.org/dom/localStorage-manager;1".
/// |
18279 |
| nsIDOMWakeLockListener.rs |
void callback (in AString aTopic, in AString aState); |
6215 |
| nsIDOMWindow.rs |
|
4734 |
| nsIDOMWindowUtils.rs |
attribute unsigned short imageAnimationMode; |
218195 |
| nsIDOMXULButtonElement.rs |
attribute AString type; |
7905 |
| nsIDOMXULCommandDispatcher.rs |
[setter_can_run_script] attribute Element focusedElement; |
11317 |
| nsIDOMXULContainerElement.rs |
readonly attribute Element parentContainer; |
10722 |
| nsIDOMXULControlElement.rs |
attribute boolean disabled; |
5714 |
| nsIDOMXULMenuListElement.rs |
attribute boolean editable; |
7662 |
| nsIDOMXULMultSelectCntrlEl.rs |
|
12738 |
| nsIDOMXULRadioGroupElement.rs |
attribute Element focusedItem; |
5897 |
| nsIDOMXULRelatedElement.rs |
Element getRelatedElement (in Node aElement); |
5897 |
| nsIDOMXULSelectCntrlEl.rs |
|
9052 |
| nsIDOMXULSelectCntrlItemEl.rs |
|
10791 |
| nsIDownloader.rs |
/// * nsIDownloader
/// *
/// * A downloader is a special implementation of a nsIStreamListener that will
/// * make the contents of the stream available as a file. This may utilize the
/// * disk cache as an optimization to avoid an extra copy of the data on disk.
/// * The resulting file is valid from the time the downloader completes until
/// * the last reference to the downloader is released.
/// |
12266 |
| nsIDragService.rs |
[can_run_script,noscript] void invokeDragSessionWithImage (in Node aDOMNode, in nsIPrincipal aPrincipal, in nsIContentSecurityPolicy aCsp, in nsICookieJarSettings aCookieJarSettings, in nsIArray aTransferableArray, in unsigned long aActionType, in Node aImage, in long aImageX, in long aImageY, in DragEvent aDragEvent, in DataTransferPtr aDataTransfer); |
19628 |
| nsIDragSession.rs |
attribute boolean canDrop; |
32245 |
| nsIDroppedLinkHandler.rs |
readonly attribute AString url; |
17376 |
| nsIEarlyHintObserver.rs |
void earlyHint (in ACString linkHeader, in ACString referrerPolicy, in ACString cspHeader); |
5865 |
| nsIEdgeMigrationUtils.rs |
/// * Utilities for migrating from legacy (non-Chromimum-based) Edge.
/// |
5710 |
| nsIEditActionListener.rs |
/// * A generic editor action listener interface.
/// * <P>
/// * nsIEditActionListener is the interface used by applications wishing to be notified
/// * when the editor modifies the DOM tree.
/// *
/// * Note: this is the wrong class to implement if you are interested in generic
/// * change notifications. For generic notifications, you should implement
/// * nsIDocumentObserver.
/// |
9786 |
| nsIEditingSession.rs |
readonly attribute unsigned long editorStatus; |
9762 |
| nsIEditor.rs |
readonly attribute Selection selection; |
53605 |
| nsIEditorMailSupport.rs |
[can_run_script] Node insertAsCitedQuotation (in AString aQuotedText, in AString aCitation, in boolean aInsertHTML); |
9269 |
| nsIEditorSpellCheck.rs |
boolean canSpellCheck (); |
22973 |
| nsIEffectiveTLDService.rs |
ACString getPublicSuffix (in nsIURI aURI); |
23630 |
| nsIEncodedChannel.rs |
/// * A channel interface which allows special handling of encoded content
/// |
10504 |
| nsIEnterprisePolicies.rs |
readonly attribute short status; |
10813 |
| nsIEnvironment.rs |
/// * Scriptable access to the current process environment.
/// *
/// |
8132 |
| nsIEventListenerService.rs |
/// * Contains an event target along with a count of event listener changes
/// * affecting accessibility.
/// |
29499 |
| nsIEventSourceEventService.rs |
[must_use] void eventSourceConnectionOpened (in uint64_t aHttpChannelId); |
13952 |
| nsIEventTarget.rs |
[noscript,notxpcom] boolean isOnCurrentThreadInfallible (); |
15908 |
| nsIException.rs |
[binaryname(FilenameXPCOM),implicit_jscontext] readonly attribute AUTF8String filename; |
16555 |
| nsIExpatSink.rs |
/// * This interface should be implemented by any content sink that wants
/// * to get output from expat and do something with it; in other words,
/// * by any sink that handles some sort of XML dialect.
/// |
13978 |
| nsIExternalHelperAppService.rs |
/// * The external helper app service is used for finding and launching
/// * platform specific external applications for a given mime content type.
/// |
32482 |
| nsIExternalProtocolHandler.rs |
boolean externalAppExistsForScheme (in ACString scheme); |
5946 |
| nsIExternalProtocolService.rs |
/// * The external protocol service is used for finding and launching
/// * web handlers (a la registerProtocolHandler in the HTML5 draft) or
/// * platform-specific applications for handling particular protocols.
/// *
/// * You can ask the external protocol service if it has an external
/// * handler for a given protocol scheme. And you can ask it to load
/// * the url using the default handler.
/// |
17110 |
| nsIFactory.rs |
/// * A class factory allows the creation of nsISupports derived
/// * components without specifying a concrete base class.
/// |
5867 |
| nsIFaviconService.rs |
nsIURI getFaviconLinkForIcon (in nsIURI aFaviconURI); |
25973 |
| nsIFile.rs |
void append (in AString node); |
60090 |
| nsIFileChannel.rs |
/// * nsIFileChannel
/// |
5207 |
| nsIFilePicker.rs |
void init (in BrowsingContext browsingContext, in AString title, in nsIFilePicker_Mode mode); |
31594 |
| nsIFileProtocolHandler.rs |
nsIURI newFileURI (in nsIFile aFile); |
12856 |
| nsIFileStreams.rs |
/// * An input stream that allows you to read from a file.
/// |
42355 |
| nsIFileURL.rs |
/// * nsIFileURL provides access to the underlying nsIFile object corresponding to
/// * an URL. The URL scheme need not be file:, since other local protocols may
/// * map URLs to files (e.g., resource:).
/// |
11129 |
| nsIFinalizationWitnessService.rs |
|
6069 |
| nsIFind.rs |
attribute boolean findBackwards; |
9394 |
| nsIFindService.rs |
attribute AString searchString; |
10314 |
| nsIFingerprintingWebCompatService.rs |
/// * The object to represent a fingerprinting override entry.
/// |
12978 |
| nsIFocusManager.rs |
/// * The focus manager deals with all focus related behaviour. Only one element
/// * in the entire application may have the focus at a time; this element
/// * receives any keyboard events. While there is only one application-wide
/// * focused element, each nsIDOMWindow maintains a reference to the element
/// * that would be focused if the window was active.
/// *
/// * If the window's reference is to a frame element (iframe, browser,
/// * editor), then the child window contains the element that is currently
/// * focused. If the window's reference is to a root element, then the root is
/// * focused. If a window's reference is null, then no element is focused, yet
/// * the window is still focused.
/// *
/// * The blur event is fired on an element when it loses the application focus.
/// * After this blur event, if the focus is moving away from a document, two
/// * additional blur events are fired on the old document and window containing
/// * the focus respectively.
/// *
/// * When a new document is focused, two focus events are fired on the new
/// * document and window respectively. Then the focus event is fired on an
/// * element when it gains the application focus.
/// *
/// * A special case is that the root element may be focused, yet does not
/// * receive the element focus and blur events. Instead a focus outline may be
/// * drawn around the document.
/// *
/// * Blur and focus events do not bubble as per the W3C DOM Events spec.
/// |
25966 |
| nsIFOG.rs |
void initializeFOG ([optional] in AUTF8String aDataPathOverride, [optional] in AUTF8String aAppIdOverride, [optional] in boolean aDisableInternalPings); |
19785 |
| nsIFontEnumerator.rs |
Array<AString> EnumerateAllFonts (); |
10284 |
| nsIFontLoadCompleteCallback.rs |
void fontLoadComplete (); |
5402 |
| nsIForcePendingChannel.rs |
/// * nsIForcePending interface exposes a function that enables overwriting of the normal
/// * behavior for the channel's IsPending(), forcing 'true' to be returned.
/// |
5869 |
| nsIFormatConverter.rs |
Array<ACString> getInputDataFlavors (); |
8556 |
| nsIFormFillController.rs |
readonly attribute HTMLInputElement focusedInput; |
12327 |
| nsIFormPOSTActionChannel.rs |
/// * nsIFormPOSTActionChannel
/// *
/// * Channel classes that want to be allowed for HTML form POST action must
/// * implement this interface.
/// |
5218 |
| nsIGeckoViewBridge.rs |
[implicit_jscontext] void onSuccess ([optional] in jsval data); |
32949 |
| nsIGeckoViewServiceWorker.rs |
Promise openWindow (in nsIURI uri, in nsIOpenWindowInfo aOpenWindowInfo); |
5617 |
| nsIGeolocationProvider.rs |
///
/// * Interface provides a way for a geolocation provider to
/// * notify the system that a new location is available.
/// |
13719 |
| nsIGeolocationUIUtilsWin.rs |
/// * JS utility functions used in display of parts of the geolocation UI.
/// |
5842 |
| nsIGfxInfo.rs |
readonly attribute boolean D2DEnabled; |
32154 |
| nsIGfxInfoDebug.rs |
void spoofVendorID (in AString aVendorID); |
6544 |
| nsIGIOService.rs |
readonly attribute AUTF8String id; |
25896 |
| nsIGleanPing.rs |
void call (in ACString aReason); |
12494 |
| nsIGNOMEShellService.rs |
readonly attribute boolean canSetDesktopBackground; |
6517 |
| nsIGSettingsService.rs |
void setString (in AUTF8String key, in AUTF8String value); |
13711 |
| nsIGtkTaskbarProgress.rs |
/// * Allow the TaskbarProgress instance to set a new target window.
/// |
5717 |
| nsIHandlerService.rs |
void asyncInit (); |
16886 |
| nsIHangDetails.rs |
/// * A scriptable interface for getting information about a BHR detected hang.
/// * This is the type of the subject of the "bhr-thread-hang" observer topic.
/// |
10040 |
| nsIHangReport.rs |
/// * When a content process hangs, Gecko notifies "process-hang-report" observers
/// * and passes an nsIHangReport for the subject parameter. There is at most one
/// * nsIHangReport associated with a given content process. As long as the content
/// * process stays stuck, the "process-hang-report" observer will continue to be
/// * notified at regular intervals (approximately once per second). The content
/// * process will continue to run uninhibitedly during this time.
/// |
9266 |
| nsIHapticFeedback.rs |
void performSimpleAction (in long isLongPress); |
5572 |
| nsIHelperAppLauncherDialog.rs |
/// * This interface is used to display a confirmation dialog before
/// * launching a "helper app" to handle content not handled by
/// * Mozilla.
/// *
/// * Usage: Clients (of which there is one: the nsIExternalHelperAppService
/// * implementation in mozilla/uriloader/exthandler) create an instance of
/// * this interface (using the contract ID) and then call the show() method.
/// *
/// * The dialog is shown non-modally. The implementation of the dialog
/// * will access methods of the nsIHelperAppLauncher passed in to show()
/// * in order to cause a "save to disk" or "open using" action.
/// |
9768 |
| nsIHTMLAbsPosEditor.rs |
[setter_can_run_script] attribute boolean absolutePositioningEnabled; |
9238 |
| nsIHTMLEditor.rs |
[can_run_script] void setInlineProperty (in AString aProperty, in AString aAttribute, in AString aValue); |
33803 |
| nsIHTMLInlineTableEditor.rs |
[setter_can_run_script] attribute boolean inlineTableEditingEnabled; |
7569 |
| nsIHTMLObjectResizer.rs |
[setter_can_run_script] attribute boolean objectResizingEnabled; |
7738 |
| nsIHttpActivityObserver.rs |
/// * nsIHttpActivityObserver
/// *
/// * This interface provides a way for http activities to be reported
/// * to observers.
/// |
22955 |
| nsIHttpAuthenticableChannel.rs |
[must_use] readonly attribute boolean isSSL; |
16439 |
| nsIHttpAuthenticator.rs |
/// * nsIHttpAuthenticator
/// *
/// * Interface designed to allow for pluggable HTTP authentication modules.
/// * Implementations are registered under the ContractID:
/// *
/// * "@mozilla.org/network/http-authenticator;1?scheme=<auth-scheme>"
/// *
/// * where <auth-scheme> is the lower-cased value of the authentication scheme
/// * found in the server challenge per the rules of RFC 2617.
/// |
19475 |
| nsIHttpAuthenticatorCallback.rs |
|
6663 |
| nsIHttpAuthManager.rs |
/// * nsIHttpAuthManager
/// *
/// * This service provides access to cached HTTP authentication
/// * user credentials (domain, username, password) for sites
/// * visited during the current browser session.
/// *
/// * This interface exists to provide other HTTP stacks with the
/// * ability to share HTTP authentication credentials with Necko.
/// * This is currently used by the Java plugin (version 1.5 and
/// * higher) to avoid duplicate authentication prompts when the
/// * Java client fetches content from a HTTP site that the user
/// * has already logged into.
/// |
12449 |
| nsIHttpChannel.rs |
/// * nsIHttpChannel
/// *
/// * This interface allows for the modification of HTTP request parameters and
/// * the inspection of the resulting HTTP response status and headers when they
/// * become available.
/// |
55270 |
| nsIHttpChannelAuthProvider.rs |
/// * nsIHttpChannelAuthProvider
/// *
/// * This interface is intended for providing authentication for http-style
/// * channels, like nsIHttpChannel and nsIWebSocket, which implement the
/// * nsIHttpAuthenticableChannel interface.
/// *
/// * When requesting pages AddAuthorizationHeaders MUST be called
/// * in order to get the http cached headers credentials. When the request is
/// * unsuccessful because of receiving either a 401 or 407 http response code
/// * ProcessAuthentication MUST be called and the page MUST be requested again
/// * with the new credentials that the user has provided. After a successful
/// * request, checkForSuperfluousAuth MAY be called, and disconnect MUST be
/// * called.
/// |
10727 |
| nsIHttpChannelChild.rs |
[must_use] void addCookiesToRequest (); |
6635 |
| nsIHttpChannelInternal.rs |
/// * The callback interface for nsIHttpChannelInternal::HTTPUpgrade()
/// |
78503 |
| nsIHttpHeaderVisitor.rs |
/// * Implement this interface to visit http headers.
/// |
6040 |
| nsIHttpProtocolHandler.rs |
[must_use] readonly attribute ACString userAgent; |
12200 |
| nsIHttpPushListener.rs |
/// * nsIHttpPushListener
/// *
/// * Used for triggering when a HTTP/2 push is received.
/// *
/// |
6488 |
| nsIHttpServer.rs |
void start (in long port); |
79074 |
| nsIHttpsOnlyModePermission.rs |
/// * HTTPS-Only/First permission types
/// |
6192 |
| nsIIconURI.rs |
/// * nsIIconURI
/// *
/// * This interface derives from nsIURI, to provide additional information
/// * about moz-icon URIs.
/// *
/// * What *is* a moz-icon URI you ask? Well, it has the following syntax:
/// *
/// * moz-icon:[<valid-url> | //<file-with-extension> | //stock/<stock-icon>]?
/// * ['?'[<parameter-value-pairs>]]
/// *
/// * <valid-url> is a valid URL spec.
/// *
/// * <file-with-extension> is any filename with an extension, e.g. "dummy.html".
/// * If the file you want an icon for isn't known to exist, you can use this
/// * instead of a URL and just place a dummy file name with the extension or
/// * content type you want.
/// *
/// * <stock-icon> is the name of a platform-dependant stock icon.
/// *
/// * Legal parameter value pairs are listed below:
/// *
/// * Parameter: size
/// * Values: [<integer> | button | toolbar | toolbarsmall | menu |
/// * dialog]
/// * Description: If integer, this is the desired size in square pixels of
/// * the icon
/// * Else, use the OS default for the specified keyword context.
/// *
/// * Parameter: state
/// * Values: [normal | disabled]
/// * Description: The state of the icon.
/// *
/// * Parameter: contentType
/// * Values: <mime-type>
/// * Description: The mime type we want an icon for. This is ignored by
/// * stock images.
/// |
9225 |
| nsIIDBPermissionsRequest.rs |
readonly attribute Element browserElement; |
5956 |
| nsIIdentityCredentialPromptService.rs |
|
7103 |
| nsIIdentityCredentialStorageService.rs |
|
11809 |
| nsIIdlePeriod.rs |
/// * An instance implementing nsIIdlePeriod is used by an associated
/// * nsIThread to estimate when it is likely that it will receive an
/// * event.
/// |
5609 |
| nsIIDNService.rs |
/// * IDN (Internationalized Domain Name) support. Provides facilities
/// * for manipulating IDN hostnames according to UTS #46 as parametrized
/// * by the WHATWG URL Standard.
/// *
/// * UTS #46: https://www.unicode.org/reports/tr46/
/// *
/// * URL Standard: https://url.spec.whatwg.org/
/// |
10528 |
| nsIImageLoadingContent.rs |
/// * This interface represents a content node that loads images. The interface
/// * exists to allow getting information on the images that the content node
/// * loads and to allow registration of observers for the image loads.
/// *
/// * Implementors of this interface should handle all the mechanics of actually
/// * loading an image -- getting the URI, checking with content policies and
/// * the security manager to see whether loading the URI is allowed, performing
/// * the load, firing any DOM events as needed.
/// *
/// * An implementation of this interface may support the concepts of a
/// * "current" image and a "pending" image. If it does, a request to change
/// * the currently loaded image will start a "pending" request which will
/// * become current only when the image is loaded. It is the responsibility of
/// * observers to check which request they are getting notifications for.
/// *
/// * Please make sure to update the MozImageLoadingContent WebIDL
/// * mixin to mirror this interface when changing it.
/// |
15288 |
| nsIIncrementalDownload.rs |
/// * An incremental download object attempts to fetch a file piecemeal over time
/// * in an effort to minimize network bandwidth usage.
/// *
/// * Canceling a background download does not cause the file on disk to be
/// * deleted.
/// |
12582 |
| nsIIncrementalStreamLoader.rs |
|
17669 |
| nsIIndexedDatabaseManager.rs |
[implicit_jscontext] Promise doMaintenance (); |
6070 |
| nsIINIParser.rs |
void initFromString (in AUTF8String aData); |
19289 |
| nsIInlineSpellChecker.rs |
readonly attribute nsIEditorSpellCheck spellChecker; |
11426 |
| nsIInputStream.rs |
void close (); |
13385 |
| nsIInputStreamChannel.rs |
/// * nsIInputStreamChannel
/// *
/// * This interface provides methods to initialize an input stream channel.
/// * The input stream channel serves as a data pump for an input stream.
/// |
11768 |
| nsIInputStreamLength.rs |
/// * Note: Instead of using these interfaces directly, consider to use
/// * InputStreamLengthHelper class.
/// |
19351 |
| nsIInputStreamPriority.rs |
attribute unsigned long priority; |
6125 |
| nsIInputStreamPump.rs |
/// * nsIInputStreamPump
/// *
/// * This interface provides a means to configure and use a input stream pump
/// * instance. The input stream pump will asynchronously read from an input
/// * stream, and push data to an nsIStreamListener instance. It utilizes the
/// * current thread's nsIEventTarget in order to make reading from the stream
/// * asynchronous. A different thread can be used if the pump also implements
/// * nsIThreadRetargetableRequest.
/// *
/// * If the given stream supports nsIAsyncInputStream, then the stream pump will
/// * call the stream's AsyncWait method to drive the stream listener. Otherwise,
/// * the stream will be read on a background thread utilizing the stream
/// * transport service. More details are provided below.
/// |
8709 |
| nsIInputStreamTee.rs |
/// * A nsIInputStreamTee is a wrapper for an input stream, that when read
/// * reads the specified amount of data from its |source| and copies that
/// * data to its |sink|. |sink| must be a blocking output stream.
/// |
8132 |
| nsIInterceptionInfo.rs |
/// * nsIInterceptionInfo is used to record the needed information of the
/// * InterceptedHttpChannel.
/// * This infomration need to be propagated to the new channel which created by
/// * FetchEvent.request or ServiceWorker NavigationPreload.
/// |
9500 |
| nsIInterfaceRequestor.rs |
/// * The nsIInterfaceRequestor interface defines a generic interface for
/// * requesting interfaces that a given object might provide access to.
/// * This is very similar to QueryInterface found in nsISupports.
/// * The main difference is that interfaces returned from GetInterface()
/// * are not required to provide a way back to the object implementing this
/// * interface. The semantics of QI() dictate that given an interface A that
/// * you QI() on to get to interface B, you must be able to QI on B to get back
/// * to A. This interface however allows you to obtain an interface C from A
/// * that may or most likely will not have the ability to get back to A.
/// |
6654 |
| nsIIOService.rs |
/// * nsIIOService provides a set of network utility functions. This interface
/// * duplicates many of the nsIProtocolHandler methods in a protocol handler
/// * independent way (e.g., NewURI inspects the scheme in order to delegate
/// * creation of the new URI to the appropriate protocol handler). nsIIOService
/// * also provides a set of URL parsing utility functions. These are provided
/// * as a convenience to the programmer and in some cases to improve performance
/// * by eliminating intermediate data structures and interfaces.
/// |
42884 |
| nsIIOUtil.rs |
/// * nsIIOUtil provdes various xpcom/io-related utility methods.
/// |
6518 |
| nsIJARChannel.rs |
attribute nsIFile jarFile; |
7731 |
| nsIJARURI.rs |
/// * JAR URLs have the following syntax
/// *
/// * jar:<jar-file-uri>!/<jar-entry>
/// *
/// * EXAMPLE: jar:http://www.big.com/blue.jar!/ocean.html
/// *
/// * The nsIURL methods operate on the <jar-entry> part of the spec.
/// |
11632 |
| nsIJSInspector.rs |
/// * Utilities for running nested event loops, asking them to return, and
/// * keeping track of which ones are still running.
/// |
9501 |
| nsIJumpListBuilder.rs |
AString obtainAndCacheFavicon (in nsIURI faviconURL); |
13298 |
| nsIKeychainMigrationUtils.rs |
ACString getGenericPassword (in ACString aServiceName, in ACString aAccountName); |
5779 |
| nsIKeyValue.rs |
/// * The nsIKeyValue* interfaces provide a simple, asynchronous API to a key/value
/// * storage engine. Basic put/get/has/delete operations are supported, as is
/// * enumeration of key/value pairs and the use of multiple named databases within
/// * a single storage directory. Operations have ACID semantics.
/// *
/// * This API does not (yet) support transactions, so it will not be appropriate
/// * for all use cases. Extension of this API to support transactions is tracked
/// * by bug 1499238.
/// *
/// * The kvstore.sys.mjs module wraps this API in a more idiomatic, Promise-based
/// * JS API that supports async/await. In most cases, you're better off using
/// * that API from JS rather than using this one directly. Bug 1512319 tracks
/// * native support for Promise in Rust-implemented XPCOM methods.
/// |
91486 |
| nsILayoutDebuggingTools.rs |
/// * A series of hooks into non-IDL-ized layout code to allow all the
/// * layout debugging functions to be used from chrome.
/// |
9842 |
| nsILayoutHistoryState.rs |
readonly attribute boolean hasStates; |
11936 |
| nsILineInputStream.rs |
boolean readLine (out ACString aLine); |
5965 |
| nsILoadContext.rs |
/// * An nsILoadContext represents the context of a load. This interface
/// * can be queried for various information about where the load is
/// * happening.
/// |
14416 |
| nsILoadContextInfo.rs |
/// * Helper interface to carry informatin about the load context
/// * encapsulating origin attributes and IsAnonymous, IsPrivite properties.
/// * It shall be used where nsILoadContext cannot be used or is not
/// * available.
/// |
15265 |
| nsILoadGroup.rs |
attribute nsIRequestObserver groupObserver; |
18799 |
| nsILoadGroupChild.rs |
/// * nsILoadGroupChild provides a hierarchy of load groups so that the
/// * root load group can be used to conceptually tie a series of loading
/// * operations into a logical whole while still leaving them separate
/// * for the purposes of cancellation and status events.
/// |
8225 |
| nsILoadInfo.rs |
readonly attribute nsIPrincipal loadingPrincipal; |
182105 |
| nsILoadURIDelegate.rs |
/// * The nsILoadURIDelegate interface.
/// * Used for delegating URI loads to GeckoView's application, e.g., Custom Tabs
/// * or Progressive Web Apps.
/// |
6233 |
| nsILocalFileMac.rs |
[noscript] void initWithCFURL (in CFURLRef aCFURL); |
18691 |
| nsILocalFileWin.rs |
void initWithCommandLine (in AString aCommandLine); |
13708 |
| nsILocalStorageManager.rs |
/// * Methods specific to LocalStorage, see nsIDOMStorageManager for methods shared
/// * with SessionStorage. Methods may migrate there as SessionStorage is
/// * overhauled.
/// |
7123 |
| nsILoginDetectionService.rs |
void init (); |
5952 |
| nsILoginInfo.rs |
/// * An object containing information for a login stored by the
/// * password manager.
/// |
25884 |
| nsILoginManager.rs |
void onSearchComplete (in Array<nsILoginInfo> aLogins); |
34009 |
| nsILoginManagerAuthPrompter.rs |
void init (in nsIDOMWindow aWindow); |
7744 |
| nsILoginManagerCrypto.rs |
AString encrypt (in AString plainText); |
9941 |
| nsILoginManagerPrompter.rs |
|
10527 |
| nsILoginMetaInfo.rs |
/// * An object containing metainfo for a login stored by the login manager.
/// *
/// * Code using login manager can generally ignore this interface. When adding
/// * logins, default value will be created. When modifying logins, these
/// * properties will be unchanged unless a change is explicitly requested [by
/// * using modifyLogin() with a nsIPropertyBag]. When deleting a login or
/// * comparing logins, these properties are ignored.
/// |
12019 |
| nsIMacDockSupport.rs |
/// * Allow applications to interface with the Mac OS X Dock.
/// *
/// * Applications may indicate progress on their Dock icon. Only one such
/// * progress indicator is available to the entire application.
/// |
12027 |
| nsIMacFinderProgress.rs |
|
12624 |
| nsIMacPreferencesReader.rs |
/// * This interface is designed to provide scriptable access to the macOS
/// * preferences system.
/// *
/// * This interface is highly macOS specific.
/// |
6249 |
| nsIMacSharingService.rs |
/// * Allow applications to interface with the Mac OS X Sharing APIs.
/// |
6741 |
| nsIMacShellService.rs |
void showDesktopPreferences (); |
7105 |
| nsIMacUserActivityUpdater.rs |
/// * Updates macOS widget code with the current URI and page title. Widget code
/// * can use this information to update NSUserActivity, enabling Handoff
/// * functionality.
/// |
6067 |
| nsIMacWebAppUtils.rs |
void trashAppFinished (in nsresult rv); |
12188 |
| nsIMarionette.rs |
Interface for accessing the Marionette server instance. |
5306 |
| nsIMediaDevice.rs |
readonly attribute AString type; |
7599 |
| nsIMediaManager.rs |
readonly attribute nsIArray activeMediaCaptureWindows; |
7344 |
| nsIMemoryInfoDumper.rs |
void callback (in nsISupports data); |
25830 |
| nsIMemoryReporter.rs |
void callback (in ACString process, in AUTF8String path, in int32_t kind, in int32_t units, in int64_t amount, in AUTF8String description, in nsISupports data); |
48577 |
| nsIMessageManager.rs |
|
10417 |
| nsIMIMEHeaderParam.rs |
AString getParameter (in ACString aHeaderVal, in string aParamName, in ACString aFallbackCharset, in boolean aTryLocaleCharset, out string aLang); |
20614 |
| nsIMIMEInfo.rs |
/// * nsIHandlerInfo gives access to the information about how a given protocol
/// * scheme or MIME-type is handled.
/// |
67140 |
| nsIMIMEInputStream.rs |
/// * The MIME stream separates headers and a datastream. It also allows
/// * automatic creation of the content-length header.
/// |
7965 |
| nsIMIMEService.rs |
/// * The MIME service is responsible for mapping file extensions to MIME-types
/// * (see RFC 2045). It also provides access to nsIMIMEInfo interfaces and
/// * acts as a general convenience wrapper of nsIMIMEInfo interfaces.
/// *
/// * The MIME service maintains a database with a <b>one</b> MIME type <b>to many</b>
/// * file extensions rule. Adding the same file extension to multiple MIME types
/// * is illegal and behavior is undefined.
/// *
/// * @see nsIMIMEInfo
/// |
21191 |
| nsIMLUtils.rs |
boolean hasEnoughMemoryToInfer (in unsigned long long aModelSizeInMemory, in unsigned long aThresholdPercentage, in unsigned long long aMinMemoryRequirement); |
6356 |
| nsIMockDragServiceController.rs |
/// * A driver for MockDragService, so that tests can mock system DND behavior.
/// * (System DND is not permitted in tests.)
/// |
8971 |
| nsIMultiPartChannel.rs |
/// * An interface to access the the base channel
/// * associated with a MultiPartChannel.
/// |
13000 |
| nsIMultiplexInputStream.rs |
/// * The multiplex stream concatenates a list of input streams into a single
/// * stream.
/// |
7237 |
| nsIMutableArray.rs |
/// * nsIMutableArray
/// * A separate set of methods that will act on the array. Consumers of
/// * nsIArray should not QueryInterface to nsIMutableArray unless they
/// * own the array.
/// *
/// * As above, it is legal to add null elements to the array. Note also
/// * that null elements can be created as a side effect of
/// * insertElementAt(). Conversely, if insertElementAt() is never used,
/// * and null elements are never explicitly added to the array, then it
/// * is guaranteed that queryElementAt() will never return a null value.
/// *
/// * Any of these methods may throw NS_ERROR_OUT_OF_MEMORY when the
/// * array must grow to complete the call, but the allocation fails.
/// |
10398 |
| nsINamed.rs |
/// * Represents an object with a name, such as a runnable or a timer.
/// |
5131 |
| nsINamedPipeService.rs |
/// * nsINamedPipeDataObserver
/// *
/// * This is the callback interface for nsINamedPipeService.
/// * The functions are called by the internal thread in the nsINamedPipeService.
/// |
14313 |
| nsINativeAppSupport.rs |
boolean start (); |
6100 |
| nsINativeDNSResolverOverride.rs |
void addIPOverride (in AUTF8String aHost, in ACString aIPLiteral); |
8446 |
| nsINavBookmarksService.rs |
/// * The BookmarksService interface provides methods for managing bookmarked
/// * history items. Bookmarks consist of a set of user-customizable
/// * folders. A URI in history can be contained in one or more such folders.
/// |
18528 |
| nsINavHistoryService.rs |
readonly attribute nsINavHistoryContainerResultNode parent; |
151041 |
| nsINestedURI.rs |
/// * nsINestedURI is an interface that must be implemented by any nsIURI
/// * implementation which has an "inner" URI that it actually gets data
/// * from.
/// *
/// * For example, if URIs for the scheme "sanitize" have the structure:
/// *
/// * sanitize:http://example.com
/// *
/// * and opening a channel on such a sanitize: URI gets the data from
/// * http://example.com, sanitizes it, and returns it, then the sanitize: URI
/// * should implement nsINestedURI and return the http://example.com URI as its
/// * inner URI.
/// |
22799 |
| nsINetAddr.rs |
/// * nsINetAddr
/// *
/// * This interface represents a native NetAddr struct in a readonly
/// * interface.
/// |
9580 |
| nsINetUtil.rs |
/// * nsINetUtil provides various network-related utility methods.
/// |
19659 |
| nsINetworkConnectivityService.rs |
|
8748 |
| nsINetworkErrorLogging.rs |
void registerPolicy (in nsIHttpChannel aChannel); |
6113 |
| nsINetworkInfoService.rs |
/// * Listener for getting list of addresses.
/// |
18779 |
| nsINetworkInterceptController.rs |
/// * Interface allowing the nsIInterceptedChannel to callback when it is
/// * done reading from the body stream.
/// |
29830 |
| nsINetworkLinkService.rs |
/// * Network link status monitoring service.
/// |
10594 |
| nsINetworkPredictor.rs |
/// * nsINetworkPredictor - learn about pages users visit, and allow us to take
/// * predictive actions upon future visits.
/// * NOTE: nsINetworkPredictor should only
/// * be used on the main thread.
/// |
11848 |
| nsINetworkPredictorVerifier.rs |
void onPredictPrefetch (in nsIURI uri, in uint32_t status); |
7062 |
| nsINotificationStorage.rs |
|
17561 |
| nsINSSComponent.rs |
[noscript] void logoutAuthenticatedPK11 (); |
14473 |
| nsINSSErrorsService.rs |
[must_use] boolean isNSSErrorCode (in int32_t aNSPRCode); |
9737 |
| nsINSSVersion.rs |
[must_use] readonly attribute AString NSPR_MinVersion; |
9664 |
| nsINullChannel.rs |
/// * This interface is only used in order to mark the fact that
/// * an object isn't a complete implementation of its interfaces.
/// * For example, a consumer can QI NullHttpChannel to nsINullChannel,
/// * to determine if the object is just a dummy implementation of nsIHttpChannel.
/// |
5104 |
| nsIObjectInputStream.rs |
/// * @see nsIObjectOutputStream
/// * @see nsIBinaryInputStream
/// |
7461 |
| nsIObjectLoadingContent.rs |
/// * This interface represents a content node that loads objects.
/// *
/// * Please make sure to update the MozObjectLoadingContent WebIDL
/// * mixin to mirror this interface when changing it.
/// |
8054 |
| nsIObjectOutputStream.rs |
/// * @See nsIObjectInputStream
/// * @See nsIBinaryOutputStream
/// |
9839 |
| nsIObliviousHttp.rs |
Array<octet> decapsulate (in Array<octet> encResponse); |
36711 |
| nsIObliviousHttpChannel.rs |
/// * nsIObliviousHttpChannel
/// *
/// * This interface allows consumers to differentiate between the
/// * relayChannel request that transports the OHTTP payload
/// * and the virtual OHTTP channel represented by the
/// * nsIObliviousHttpChannel implementation.
/// |
6126 |
| nsIObserver.rs |
/// * This interface is implemented by an object that wants
/// * to observe an event corresponding to a topic.
/// |
6277 |
| nsIObserverService.rs |
/// * nsIObserverService
/// *
/// * Service allows a client listener (nsIObserver) to register and unregister for
/// * notifications of specific string referenced topic. Service also provides a
/// * way to notify registered listeners and a way to enumerate registered client
/// * listeners.
/// |
10349 |
| nsIOpenTabsProvider.rs |
Array<AUTF8String> getOpenTabs (); |
6018 |
| nsIOpenWindowInfo.rs |
|
18479 |
| nsIOSKeyStore.rs |
[implicit_jscontext,must_use] Promise asyncGenerateSecret (in ACString label); |
11784 |
| nsIOSPermissionRequest.rs |
void getMediaCapturePermissionState (out uint16_t aVideo, out uint16_t aAudio); |
8295 |
| nsIOSReauthenticator.rs |
[implicit_jscontext,must_use] Promise asyncReauthenticateUser (in AString prompt, in AString caption, in mozIDOMWindow parentWindow); |
7040 |
| nsIOutputStream.rs |
void close (); |
13500 |
| nsIPageThumbsStorageService.rs |
/// * A service which returns information about file paths where the
/// * screenshots for URLs are stored. These screenshots are used by the
/// * moz-page-thumb protocol
/// |
7179 |
| nsIPaper.rs |
readonly attribute AString id; |
7688 |
| nsIPaperMargin.rs |
[infallible] readonly attribute double top; |
6821 |
| nsIParentalControlsService.rs |
readonly attribute boolean parentalControlsEnabled; |
10600 |
| nsIParentChannel.rs |
/// * Implemented by chrome side of IPC protocols.
/// |
9701 |
| nsIParentRedirectingChannel.rs |
|
14461 |
| nsIParserUtils.rs |
/// * Non-Web HTML parser functionality to Firefox extensions and XULRunner apps.
/// * Don't use this from within Gecko--use nsContentUtils, nsTreeSanitizer, etc.
/// * directly instead.
/// |
12772 |
| nsIPartitioningExceptionListService.rs |
/// * Observer for exception list updates.
/// |
13693 |
| nsIPaymentActionResponse.rs |
/// * The base interface of response data for the specified payment method.
/// * The response data is the content of the PaymentResponse's detail attribute.
/// |
80513 |
| nsIPaymentAddress.rs |
readonly attribute AString country; |
11336 |
| nsIPaymentRequest.rs |
readonly attribute AString supportedMethods; |
54924 |
| nsIPaymentRequestService.rs |
/// * nsPaymentRequestService is used to manage the created PaymentRequest in the
/// * chrome process. It is also the IPC agent for payment UI to communicate with
/// * merchant side.
/// |
13097 |
| nsIPaymentUIService.rs |
/// * nsIPaymentUIService is the interface used by Gecko to communicate with the
/// * payment UI.
/// * In general, the implementation of this interface should be a service that
/// * manages all payment UI components and receives the requested payment actions
/// * from Gecko and perform the corresponding UI behavior.
/// |
10428 |
| nsIPermission.rs |
/// * This interface defines a "permission" object,
/// * used to specify allowed/blocked objects from
/// * user-specified sites (cookies, images etc).
/// |
10786 |
| nsIPermissionDelegateHandler.rs |
boolean maybeUnsafePermissionDelegate (in Array<ACString> aTypes); |
5723 |
| nsIPermissionManager.rs |
Array<nsIPermission> getAllForPrincipal (in nsIPrincipal principal); |
29285 |
| nsIPersistentProperties2.rs |
attribute AUTF8String key; |
15284 |
| nsIPipe.rs |
/// * nsIPipe represents an in-process buffer that can be read using nsIInputStream
/// * and written using nsIOutputStream. The reader and writer of a pipe do not
/// * have to be on the same thread. As a result, the pipe is an ideal mechanism
/// * to bridge data exchange between two threads. For example, a worker thread
/// * might write data to a pipe from which the main thread will read.
/// *
/// * Each end of the pipe can be either blocking or non-blocking. Recall that a
/// * non-blocking stream will return NS_BASE_STREAM_WOULD_BLOCK if it cannot be
/// * read or written to without blocking the calling thread. For example, if you
/// * try to read from an empty pipe that has not yet been closed, then if that
/// * pipe's input end is non-blocking, then the read call will fail immediately
/// * with NS_BASE_STREAM_WOULD_BLOCK as the error condition. However, if that
/// * pipe's input end is blocking, then the read call will not return until the
/// * pipe has data or until the pipe is closed. This example presumes that the
/// * pipe is being filled asynchronously on some background thread.
/// *
/// * The pipe supports nsIAsyncInputStream and nsIAsyncOutputStream, which give
/// * the user of a non-blocking pipe the ability to wait for the pipe to become
/// * ready again. For example, in the case of an empty non-blocking pipe, the
/// * user can call AsyncWait on the input end of the pipe to be notified when
/// * the pipe has data to read (or when the pipe becomes closed).
/// *
/// * NS_NewPipe2 and NS_NewPipe provide convenient pipe constructors. In most
/// * cases nsIPipe is not actually used. It is usually enough to just get
/// * references to the pipe's input and output end. In which case, the pipe is
/// * automatically closed when the respective pipe ends are released.
/// |
15990 |
| nsIPK11Token.rs |
[must_use] readonly attribute AUTF8String tokenName; |
12879 |
| nsIPK11TokenDB.rs |
/// * The PK11 Token Database provides access to the PK11 modules
/// * that are installed, and the tokens that are available.
/// * Interfaces: nsIPK11TokenDB
/// * Threading: ??
/// |
5488 |
| nsIPKCS11Module.rs |
[must_use] readonly attribute AUTF8String name; |
6080 |
| nsIPKCS11ModuleDB.rs |
[must_use] void deleteModule (in AString moduleName); |
7809 |
| nsIPKCS11Slot.rs |
[must_use] readonly attribute AUTF8String name; |
8705 |
| nsIPlacesPreviewsHelperService.rs |
/// * A service which returns information about file paths where the
/// * previews for URLs are stored. These previews are used by the
/// * moz-page-thumb protocol
/// |
6040 |
| nsIPlatformInfo.rs |
readonly attribute ACString platformVersion; |
5986 |
| nsIPowerManagerService.rs |
/// * For use with non-content code.
/// |
7531 |
| nsIPrefBranch.rs |
/// * The nsIPrefBranch interface is used to manipulate the preferences data. This
/// * object may be obtained from the preferences service (nsIPrefService) and
/// * used to get and set default and/or user preferences across the application.
/// *
/// * This object is created with a "root" value which describes the base point in
/// * the preferences "tree" from which this "branch" stems. Preferences are
/// * accessed off of this root by using just the final portion of the preference.
/// * For example, if this object is created with the root "browser.startup.",
/// * the preferences "browser.startup.page", "browser.startup.homepage",
/// * and "browser.startup.homepage_override" can be accessed by simply passing
/// * "page", "homepage", or "homepage_override" to the various Get/Set methods.
/// *
/// * @see nsIPrefService
/// |
37324 |
| nsIPrefetchService.rs |
void prefetchURI (in nsIURI aURI, in nsIReferrerInfo aReferrerInfo, in Node aSource, in boolean aExplicit); |
8580 |
| nsIPrefLocalizedString.rs |
/// * The nsIPrefLocalizedString interface is simply a wrapper interface for
/// * nsISupportsString so the preferences service can have a unique identifier
/// * to distinguish between requests for normal wide strings (nsISupportsString)
/// * and "localized" wide strings, which get their default values from properites
/// * files.
/// *
/// * @see nsIPrefBranch
/// * @see nsISupportsString
/// |
5433 |
| nsIPrefService.rs |
/// * A helper function for reading access statistics for preferences.
/// * See nsIPrefService.readStats for more details.
/// |
30198 |
| nsIPreloadedStyleSheet.rs |
/// * The nsIPreloadedStyleSheet interface is an opaque interface for
/// * style sheets returned by nsIStyleSheetService.preloadSheet, and
/// * which can be passed to nsIDOMWindowUtils.addSheet.
/// |
5196 |
| nsIPrincipal.rs |
boolean equals (in nsIPrincipal other); |
65083 |
| nsIPrintDialogService.rs |
/// * Service for opening native print dialogs provided by the operating system.
/// * (The widget code may customize the dialog.)
/// |
8473 |
| nsIPrinter.rs |
readonly attribute Array<nsIPaper> paperList; |
15160 |
| nsIPrinterList.rs |
void initPrintSettingsFromPrinter (in AString aPrinterName, in nsIPrintSettings aPrintSettings); |
9363 |
| nsIPrintSettings.rs |
/// * Simplified graphics interface for JS rendering.
/// |
70872 |
| nsIPrintSettingsService.rs |
[noscript] readonly attribute nsIPrintSettings defaultPrintSettingsForPrinting; |
14488 |
| nsIPrintSettingsWin.rs |
/// * Simplified PrintSettings for Windows interface
/// |
9330 |
| nsIPrivacyTransitionObserver.rs |
void privateModeChanged (in boolean enabled); |
5510 |
| nsIPrivateAttributionService.rs |
|
7379 |
| nsIPrivateBrowsingChannel.rs |
/// * This interface is implemented by channels which support overriding the
/// * privacy state of the channel.
/// *
/// * This interface must be used only from the XPCOM main thread.
/// |
8392 |
| nsIProcess.rs |
void init (in nsIFile executable); |
14858 |
| nsIProcessToolsService.rs |
void kill (in unsigned long long pid); |
7551 |
| nsIProfileMigrator.rs |
/// * Helper interface for nsIProfileMigrator.
/// *
/// * @provider Toolkit (Startup code)
/// * @client Application (Profile-migration code)
/// * @obtainable nsIProfileMigrator.migrate
/// |
13153 |
| nsIProfiler.rs |
/// * Start-up parameters for subprocesses are passed through nsIObserverService,
/// * which, unfortunately, means we need to implement nsISupports in order to
/// * go through it.
/// |
27899 |
| nsIProfileUnlocker.rs |
void unlock (in unsigned long aSeverity); |
5643 |
| nsIProgressEventSink.rs |
/// * nsIProgressEventSink
/// *
/// * This interface is used to asynchronously convey channel status and progress
/// * information that is generally not critical to the processing of the channel.
/// * The information is intended to be displayed to the user in some meaningful
/// * way.
/// *
/// * An implementation of this interface can be passed to a channel via the
/// * channel's notificationCallbacks attribute. See nsIChannel for more info.
/// *
/// * The channel will begin passing notifications to the progress event sink
/// * after its asyncOpen method has been called. Notifications will cease once
/// * the channel calls its listener's onStopRequest method or once the channel
/// * is canceled (via nsIRequest::cancel).
/// *
/// * NOTE: This interface is actually not specific to channels and may be used
/// * with other implementations of nsIRequest.
/// |
8747 |
| nsIPrompt.rs |
void alert (in wstring dialogTitle, in wstring text); |
12442 |
| nsIPromptCollection.rs |
/// * This interface contains various specialized prompts that the app can
/// * implement.
/// |
7776 |
| nsIPromptFactory.rs |
/// * This interface allows creating various prompts that have a specific parent.
/// |
5809 |
| nsIPromptInstance.rs |
/// * An object representing a prompt or doorhanger.
/// |
5368 |
| nsIPromptService.rs |
/// * This is the interface to the embeddable prompt service; the service that
/// * implements nsIPrompt. Its interface is designed to be just nsIPrompt, each
/// * method modified to take a parent window parameter.
/// *
/// * Accesskeys can be attached to buttons and checkboxes by inserting an &
/// * before the accesskey character in the checkbox message or button title. For
/// * a real &, use && instead. (A "button title" generally refers to the text
/// * label of a button.)
/// *
/// * One note: in all cases, the parent window parameter can be null. However,
/// * these windows are all intended to have parents. So when no parent is
/// * specified, the implementation should try hard to find a suitable foster
/// * parent.
/// *
/// * Implementations are free to choose how they present the various button
/// * types. For example, while prompts that give the user a choice between OK
/// * and Cancel are required to return a boolean value indicating whether or not
/// * the user accepted the prompt (pressed OK) or rejected the prompt (pressed
/// * Cancel), the implementation of this interface could very well speak the
/// * prompt to the user instead of rendering any visual user-interface. The
/// * standard button types are merely idioms used to convey the nature of the
/// * choice the user is to make.
/// *
/// * Because implementations of this interface may loosely interpret the various
/// * button types, it is advised that text messages passed to these prompts do
/// * not refer to the button types by name. For example, it is inadvisable to
/// * tell the user to "Press OK to proceed." Instead, such a prompt might be
/// * rewritten to ask the user: "Would you like to proceed?"
/// |
50439 |
| nsIProperties.rs |
void get (in string prop, in nsIIDRef iid, [iid_is (iid), retval] out nsQIResult result); |
7850 |
| nsIProperty.rs |
readonly attribute AString name; |
5677 |
| nsIPropertyBag.rs |
readonly attribute nsISimpleEnumerator enumerator; |
6077 |
| nsIPropertyBag2.rs |
int32_t getPropertyAsInt32 (in AString prop); |
11549 |
| nsIProtocolHandler.rs |
/// * nsIProtocolHandlerWithDynamicFlags
/// *
/// * Protocols that wish to return different flags depending on the URI should
/// * implement this interface.
/// |
24255 |
| nsIProtocolProxyCallback.rs |
/// * This interface serves as a closure for nsIProtocolProxyService's
/// * asyncResolve method.
/// |
6921 |
| nsIProtocolProxyFilter.rs |
/// * Recipient of the result of implementers of nsIProtocolProxy(Channel)Filter
/// * allowing the proxyinfo be provided asynchronously.
/// |
20421 |
| nsIProtocolProxyService.rs |
void onProxyConfigChanged (); |
33688 |
| nsIProtocolProxyService2.rs |
/// * An extension of nsIProtocolProxyService
/// |
7089 |
| nsIProxiedChannel.rs |
/// * An interface for accessing the proxy info that a channel was
/// * constructed with.
/// *
/// * @see nsIProxiedProtocolHandler
/// |
6806 |
| nsIProxiedProtocolHandler.rs |
|
7127 |
| nsIProxyInfo.rs |
/// * This interface identifies a proxy server.
/// |
14820 |
| nsIPublicKeyPinningService.rs |
[must_use] boolean hostHasPins (in nsIURI aURI); |
5688 |
| nsIPurgeTrackerService.rs |
Promise purgeTrackingCookieJars (); |
5420 |
| nsIPushErrorReporter.rs |
void reportDeliveryError (in AString messageId, [optional] in uint16_t reason); |
7047 |
| nsIPushNotifier.rs |
/// * Fires XPCOM observer notifications and service worker events for
/// * messages sent to push subscriptions.
/// |
21485 |
| nsIPushService.rs |
/// * A push subscription, passed as an argument to a subscription callback.
/// * Similar to the `PushSubscription` WebIDL interface.
/// |
44819 |
| nsIQueryContentEventResult.rs |
/// * The result of query content events. succeeded propery can be used always.
/// * Whether other properties can be used or not depends on the event.
/// * See nsIDOMWindowUtils.idl, which properites can be used was documented.
/// |
10428 |
| nsIQuotaArtificialFailure.rs |
|
5238 |
| nsIQuotaCallbacks.rs |
void onUsageResult (in nsIQuotaUsageRequest aRequest); |
10529 |
| nsIQuotaManagerService.rs |
[must_use] nsIQuotaRequest storageName (); |
44377 |
| nsIQuotaRequests.rs |
readonly attribute nsIPrincipal principal; |
18644 |
| nsIQuotaResults.rs |
|
28202 |
| nsIRaceCacheWithNetwork.rs |
/// * This holds methods used to race the cache with the network for a specific
/// * channel. This interface is was designed with nsHttpChannel in mind, and it's
/// * expected this will be the only class implementing it.
/// |
9601 |
| nsIRandomAccessStream.rs |
/// * nsIRandomAccessStream
/// *
/// * An interface which supports both reading and writing to a storage starting
/// * at the current offset. Both the input stream and the output stream share the
/// * offset in the stream. Read operations invoked on the input stream start at
/// * the offset and advance it past the bytes read. Write operations invoked on
/// * the output stream start the offset and advance it past the bytes written.
/// * The offset can be set to an arbitrary value prior reading or writting. Each
/// * call to getInputStream or getOutputStream always returns the same object,
/// * rather than creating a new stream. It's recommended for objects implementing
/// * this interface to also implement nsIInputStream and nsIOutputStream, so they
/// * can be easilly used with e.g. NS_AsyncCopy.
/// |
8416 |
| nsIRandomGenerator.rs |
/// * Interface used to generate random data.
/// *
/// * @threadsafe
/// |
6729 |
| nsIRddProcessTest.rs |
[implicit_jscontext] Promise testTelemetryProbes (); |
5750 |
| nsIRedirectChannelRegistrar.rs |
/// * Used on the chrome process as a service to join channel implementation
/// * and parent IPC protocol side under a unique id. Provides this way a generic
/// * communication while redirecting to various protocols.
/// *
/// * See also nsIChildChannel and nsIParentChannel.
/// |
10073 |
| nsIRedirectHistoryEntry.rs |
/// * This nsIRedirectHistoryEntry defines an interface for specifying channel
/// * redirect information
/// |
6818 |
| nsIRedirectResultListener.rs |
void onRedirectResult (in nsresult status); |
5892 |
| nsIReferrerInfo.rs |
[infallible] readonly attribute nsIURI originalReferrer; |
12567 |
| nsIReflowObserver.rs |
void reflow (in DOMHighResTimeStamp start, in DOMHighResTimeStamp end); |
6780 |
| nsIRefreshURI.rs |
void refreshURI (in nsIURI aURI, in nsIPrincipal aPrincipal, in unsigned long aMillis); |
8180 |
| nsIRegion.rs |
readonly attribute AString current; |
5642 |
| nsIRelativeFilePref.rs |
/// * The nsIRelativeFilePref interface is a wrapper for an nsIFile and
/// * and a directory service key. When used as a pref value, it stores a
/// * relative path to the file from the location pointed to by the directory
/// * service key. The path has the same syntax across all platforms.
/// *
/// * @see nsIPrefBranch::getComplexValue
/// * @see nsIPrefBranch::setComplexValue
/// *
/// |
7639 |
| nsIRemoteAgent.rs |
/// * The Gecko remote agent is an RPC subsystem that exposes
/// * browser-internal interfaces and services to the surrounding
/// * system.
/// *
/// * Consumers, whether remote or browser-local, can interface with
/// * the browser through an assorted set of services ranging from
/// * document introspection and script evaluation, to instrumentation,
/// * user interaction simulation, and event subscription.
/// |
6346 |
| nsIRemotePermissionService.rs |
/// * Service to import default permissions from Remote Settings. Will be
/// * initialized by permission manager after it itself has completed its
/// * initialization, and will then import default permissions from Remote Settings
/// * asynchronously. This also means default permissions aren't guranteed to be
/// * available directly after startup.
/// |
7876 |
| nsIRemoteService.rs |
void sendCommandLine (in ACString aProfile, in Array<ACString> aArgs, [optional] in boolean aRaise); |
6638 |
| nsIRemoteTab.rs |
attribute boolean renderLayers; |
15212 |
| nsIReplacedHttpResponse.rs |
/// * nsIHttpChannel
/// *
/// * This interface allows to create an object holding mocked data which will
/// * replace the response for a channel. To override the channel's response
/// * use nsIHttpChannelInternal::setResponseOverride with an instance of
/// * nsIReplacedHttpResponse as parameter.
/// |
9648 |
| nsIRequest.rs |
/// * nsIRequest
/// |
22838 |
| nsIRequestContext.rs |
/// * Requests capable of tail-blocking must implement this
/// * interfaces (typically channels).
/// * If the request is tail-blocked, it will be held in its request
/// * context queue until unblocked.
/// |
27180 |
| nsIRequestObserver.rs |
/// * nsIRequestObserver
/// |
7005 |
| nsIRequestObserverProxy.rs |
/// * A request observer proxy is used to ship data over to another thread
/// * specified by the thread's dispatch target. The "true" request observer's
/// * methods are invoked on the other thread.
/// *
/// * This interface only provides the initialization needed after construction.
/// * Otherwise, these objects are used simply as nsIRequestObserver's.
/// |
6488 |
| nsIResProtocolHandler.rs |
/// * Protocol handler interface for the resource:// protocol
/// |
5608 |
| nsIResumableChannel.rs |
void resumeAt (in unsigned long long startPos, in ACString entityID); |
7272 |
| nsIRFPService.rs |
/// * The singleton serivce which handles fingerprinting protection stuffs.
/// |
11744 |
| nsIRunnable.rs |
/// * Represents a task which can be dispatched to a thread for execution.
/// |
16066 |
| nsISafeOutputStream.rs |
/// * This interface provides a mechanism to control an output stream
/// * that takes care not to overwrite an existing target until it is known
/// * that all writes to the destination succeeded.
/// *
/// * An object that supports this interface is intended to also support
/// * nsIOutputStream.
/// *
/// * For example, a file output stream that supports this interface writes to
/// * a temporary file, and moves it over the original file when |finish| is
/// * called only if the stream can be successfully closed and all writes
/// * succeeded. If |finish| is called but something went wrong during
/// * writing, it will delete the temporary file and not touch the original.
/// * If the stream is closed by calling |close| directly, or the stream
/// * goes away, the original file will not be overwritten, and the temporary
/// * file will be deleted.
/// *
/// * Currently, this interface is implemented only for file output streams.
/// |
6739 |
| nsIScreen.rs |
void GetRect (out long left, out long top, out long width, out long height); |
12829 |
| nsIScreenManager.rs |
nsIScreen screenForRect (in long left, in long top, in long width, in long height); |
6328 |
| nsIScriptableBase64Encoder.rs |
/// * nsIScriptableBase64Encoder efficiently encodes the contents
/// * of a nsIInputStream to a Base64 string. This avoids the need
/// * to read the entire stream into a buffer, and only then do the
/// * Base64 encoding.
/// *
/// * If you already have a buffer full of data, you should use
/// * btoa instead!
/// |
7099 |
| nsIScriptableContentIterator.rs |
/// * nsIScriptableContentIterator is designed to testing concrete classes of
/// * ContentIteratorBase.
/// |
10874 |
| nsIScriptableInputStream.rs |
/// * nsIScriptableInputStream provides scriptable access to an nsIInputStream
/// * instance.
/// |
8983 |
| nsIScriptableUConv.rs |
/// * In new code, please use the WebIDL TextDecoder and TextEncoder
/// * instead. They represent bytes as Uint8Array (or as view to such
/// * array), which is the current best practice for representing bytes
/// * in JavaScript.
/// *
/// * This interface converts between UTF-16 in JavaScript strings
/// * and bytes transported as the unsigned value of each byte
/// * transported in a code unit of the same numeric value in
/// * a JavaScript string.
/// *
/// * @created 8/Jun/2000
/// * @author Makoto Kato [m_kato@ga2.so-net.ne.jp]
/// |
9974 |
| nsIScriptChannel.rs |
/// * An interface representing a channel which will have to execute some sort of
/// * program provided via its URI to compute the data it should return.
/// *
/// * If a channel implements this interface, the execution of the program in
/// * question will be restricted in the following ways:
/// *
/// * - If the channel does not have an owner principal, the program will not be
/// * executed at all, no matter what. This is necessary because in this
/// * circumstance we have no way to tell whether script execution is allowed at
/// * all for the originating security context of this channel.
/// * - If the channel has an owner principal, how it is executed is controlled by
/// * this interface. However if the owner principal does not subsume the
/// * principal of the environment in which the program is to be executed the
/// * execution will be forced to happen in a sandbox.
/// |
10602 |
| nsIScriptError.rs |
readonly attribute AString errorMessage; |
29374 |
| nsIScriptSecurityManager.rs |
[noscript] void canCreateWrapper (in JSContextPtr aJSContext, in nsIIDRef aIID, in nsISupports aObj, in nsIClassInfo aClassInfo); |
29619 |
| nsISDBCallbacks.rs |
void onComplete (in nsISDBRequest aRequest); |
10399 |
| nsISDBConnection.rs |
[must_use] void init (in nsIPrincipal aPrincipal, [optional] in ACString aPersistenceType); |
8456 |
| nsISDBRequest.rs |
[must_use] readonly attribute nsIVariant result; |
6864 |
| nsISDBResults.rs |
[must_use] Array<uint8_t> getAsArray (); |
5430 |
| nsISearchService.rs |
readonly attribute nsIInputStream postData; |
68789 |
| nsISecCheckWrapChannel.rs |
/// * nsISecCheckWrapChannel
/// * Describes an XPCOM component used to wrap channels for performing
/// * security checks. Channels wrapped inside this class can use
/// * this interface to query the wrapped inner channel.
/// |
5794 |
| nsISecretDecoderRing.rs |
[must_use] ACString encryptString (in ACString text); |
10272 |
| nsISecureBrowserUI.rs |
readonly attribute unsigned long state; |
6132 |
| nsISecurityConsoleMessage.rs |
attribute AString tag; |
6574 |
| nsISecurityUITelemetry.rs |
|
5375 |
| nsISeekableStream.rs |
void seek (in long whence, in long long offset); |
6783 |
| nsISelectionController.rs |
void setDisplaySelection (in short toggle); |
25133 |
| nsISelectionDisplay.rs |
void setSelectionFlags (in short toggle); |
5807 |
| nsISelectionListener.rs |
[can_run_script] void notifySelectionChanged (in Document doc, in Selection sel, in short reason, in long amount); |
6392 |
| nsISensitiveInfoHiddenURI.rs |
AUTF8String getSensitiveInfoHiddenSpec (); |
5763 |
| nsISerialEventTarget.rs |
/// * A serial event target is an event dispatching interface like
/// * nsIEventTarget. Runnables dispatched to an nsISerialEventTarget are required
/// * to execute serially. That is, two different runnables dispatched to the
/// * target should never be allowed to execute simultaneously. One exception to
/// * this rule is nested event loops. If a runnable spins a nested event loop,
/// * causing another runnable dispatched to the target to run, the target may
/// * still be considered "serial".
/// *
/// * Examples:
/// * - nsIThread is a serial event target.
/// * - Thread pools are not serial event targets.
/// * - However, one can "convert" a thread pool into an nsISerialEventTarget
/// * by putting a TaskQueue in front of it.
/// |
6055 |
| nsISerializable.rs |
[must_use] void read (in nsIObjectInputStream aInputStream); |
6604 |
| nsISerializationHelper.rs |
ACString serializeToString (in nsISerializable serializable); |
6518 |
| nsIServerSocket.rs |
/// * nsIServerSocket
/// *
/// * An interface to a server socket that can accept incoming connections.
/// |
26323 |
| nsIServiceManager.rs |
/// * The nsIServiceManager manager interface provides a means to obtain
/// * global services in an application. The service manager depends on the
/// * repository to find and instantiate factories to obtain services.
/// *
/// * Users of the service manager must first obtain a pointer to the global
/// * service manager by calling NS_GetServiceManager. After that,
/// * they can request specific services by calling GetService. When they are
/// * finished they can NS_RELEASE() the service as usual.
/// *
/// * A user of a service may keep references to particular services indefinitely
/// * and only must call Release when it shuts down.
/// |
9284 |
| nsIServiceWorkerManager.rs |
|
63785 |
| nsISessionStorageService.rs |
void clearStoragesForOrigin (in nsIPrincipal aPrincipal); |
5740 |
| nsISessionStoreFunctions.rs |
|
6074 |
| nsISessionStoreRestoreData.rs |
attribute AUTF8String url; |
11989 |
| nsISharePicker.rs |
void init (in mozIDOMWindowProxy openerWindow); |
6435 |
| nsISharingHandlerApp.rs |
void share (in AString data, [optional] in AString title); |
5442 |
| nsIShellService.rs |
boolean isDefaultBrowser ([optional] in boolean aForAllTypes); |
9840 |
| nsISHEntry.rs |
[infallible] attribute nsIURI URI; |
75923 |
| nsISHistory.rs |
/// * An interface to the primary properties of the Session History
/// * component. In an embedded browser environment, the nsIWebBrowser
/// * object creates an instance of session history for each open window.
/// * A handle to the session history object can be obtained from
/// * nsIWebNavigation. In a non-embedded situation, the owner of the
/// * session history component must create a instance of it and set
/// * it in the nsIWebNavigation object.
/// * This interface is accessible from javascript.
/// |
30116 |
| nsISHistoryListener.rs |
/// * nsISHistoryListener defines the interface one can implement to receive
/// * notifications about activities in session history and (for reloads) to be
/// * able to cancel them.
/// *
/// * A session history listener will be notified when pages are added, removed
/// * and loaded from session history. In the case of reloads, it can prevent them
/// * from happening by returning false from the corresponding callback method.
/// *
/// * A session history listener can be registered on a particular nsISHistory
/// * instance via the nsISHistory::addSHistoryListener() method.
/// *
/// * Listener methods should not alter the session history. Things are likely to
/// * go haywire if they do.
/// |
11010 |
| nsISimpleEnumerator.rs |
/// * Used to enumerate over elements defined by its implementor.
/// * Although hasMoreElements() can be called independently of getNext(),
/// * getNext() must be pre-ceeded by a call to hasMoreElements(). There is
/// * no way to "reset" an enumerator, once you obtain one.
/// *
/// * @version 1.0
/// |
19118 |
| nsISimpleStreamListener.rs |
/// * A simple stream listener can be used with AsyncRead to supply data to
/// * a output stream.
/// |
6029 |
| nsISimpleURIMutator.rs |
nsIURIMutator setSpecAndFilterWhitespace (in AUTF8String aSpec); |
5623 |
| nsISiteSecurityService.rs |
|
13130 |
| nsISlowScriptDebug.rs |
void handleSlowScriptDebug (in nsIDOMWindow aWindow); |
23833 |
| nsISocketFilter.rs |
/// * Filters are created and run on the parent, and filter all packets, both
/// * ingoing and outgoing. The child must specify the name of a recognized filter
/// * in order to create a socket.
/// |
10922 |
| nsISocketProvider.rs |
/// * nsISocketProvider
/// |
11102 |
| nsISocketProviderService.rs |
/// * nsISocketProviderService
/// *
/// * Provides a mapping between a socket type and its associated socket provider
/// * instance. One could also use the service manager directly.
/// |
5795 |
| nsISocketTransport.rs |
/// * nsISocketTransport
/// *
/// * NOTE: Connection setup is triggered by opening an input or output stream,
/// * it does not start on its own. Completion of the connection setup is
/// * indicated by a STATUS_CONNECTED_TO notification to the event sink (if set).
/// *
/// * NOTE: This is a free-threaded interface, meaning that the methods on
/// * this interface may be called from any thread.
/// |
37514 |
| nsISocketTransportService.rs |
void observe (); |
25893 |
| nsISound.rs |
void play (in nsIURL aURL); |
6681 |
| nsISpeculativeConnect.rs |
void speculativeConnect (in nsIURI aURI, in nsIPrincipal aPrincipal, in nsIInterfaceRequestor aCallbacks, in boolean aAnonymous); |
16395 |
| nsISpeechRecognitionService.rs |
|
12342 |
| nsISpeechService.rs |
/// * A callback is implemented by the service.
/// |
24260 |
| nsIStandaloneNativeMenu.rs |
/// * Platform-independent interface to platform native menu objects.
/// |
8592 |
| nsIStandardURL.rs |
/// * nsIStandardURL defines the interface to an URL with the standard
/// * file path format common to protocols like http, ftp, and file.
/// * It supports initialization from a relative path and provides
/// * some customization on how URLs are normalized.
/// |
14204 |
| nsIStartupCacheInfo.rs |
readonly attribute boolean IgnoreDiskCache; |
7636 |
| nsIStorageActivityService.rs |
/// * nsIStorageActivityService is a service that can be used to know which
/// * origins have been active in a time range. This information can be used to
/// * implement "Clear Recent History" or similar features.
/// *
/// * If you are implementing a new Storage component, you should use
/// * QuotaManager. But if you don't do it, remember to call
/// * StorageActivityService methods in order to inform this service about
/// * 'writing' operations executed by origins.
/// |
6902 |
| nsIStorageStream.rs |
/// * The nsIStorageStream interface maintains an internal data buffer that can be
/// * filled using a single output stream. One or more independent input streams
/// * can be created to read the data from the buffer non-destructively.
/// |
10038 |
| nsIStreamBufferAccess.rs |
/// * An interface for access to a buffering stream implementation's underlying
/// * memory buffer.
/// *
/// * Stream implementations that QueryInterface to nsIStreamBufferAccess must
/// * ensure that all buffers are aligned on the most restrictive type size for
/// * the current architecture (e.g., sizeof(double) for RISCy CPUs). malloc(3)
/// * satisfies this requirement.
/// |
10216 |
| nsIStreamConverter.rs |
/// * nsIStreamConverter provides an interface to implement when you have code
/// * that converts data from one type to another.
/// *
/// * Suppose you had code that converted plain text into HTML. You could implement
/// * this interface to allow everyone else to use your conversion logic using a
/// * standard api.
/// * <p>
/// * <b>STREAM CONVERTER USERS</b>
/// *
/// * There are currently two ways to use a stream converter:
/// * <ol>
/// * <li> <b>SYNCHRONOUS</b> Stream to Stream
/// * You can supply the service with a stream of type X
/// * and it will convert it to your desired output type and return
/// * a converted (blocking) stream to you.</li>
/// *
/// * <li> <b>ASYNCHRONOUS</b> nsIStreamListener to nsIStreamListener
/// * You can supply data directly to the converter by calling it's
/// * nsIStreamListener::OnDataAvailable() method. It will then
/// * convert that data from type X to your desired output type and
/// * return converted data to you via the nsIStreamListener you passed
/// * in by calling its OnDataAvailable() method.</li>
/// * </ol>
/// * <p>
/// *
/// * <b>STREAM CONVERTER SUPPLIERS</b>
/// *
/// * Registering a stream converter:
/// * Stream converter registration is a two step process. First of all the stream
/// * converter implementation must register itself with the component manager using
/// * a contractid in the format below. Second, the stream converter must add the contractid
/// * to the registry.
/// *
/// * Stream converter contractid format (the stream converter root key is defined in this
/// * file):
/// *
/// * <pre>@mozilla.org/streamconv;1?from=FROM_MIME_TYPE&to=TO_MIME_TYPE</pre>
/// *
/// * @author Jud Valeski
/// * @see nsIStreamConverterService
/// |
12313 |
| nsIStreamConverterService.rs |
/// * The nsIStreamConverterService is a higher level stream converter factory
/// * responsible for locating and creating stream converters
/// * (nsIStreamConverter).
/// *
/// * This service retrieves an interface that can convert data from a particular
/// * MIME type, to a particular MIME type. It is responsible for any intermediary
/// * conversion required in order to get from X to Z, assuming direct conversion
/// * is not possible.
/// *
/// * @author Jud Valeski
/// * @see nsIStreamConverter
/// |
11325 |
| nsIStreamListener.rs |
/// * nsIStreamListener
/// |
6767 |
| nsIStreamListenerTee.rs |
/// * As data "flows" into a stream listener tee, it is copied to the output stream
/// * and then forwarded to the real listener.
/// |
8084 |
| nsIStreamLoader.rs |
void onStreamComplete (in nsIStreamLoader loader, in nsISupports ctxt, in nsresult status, in unsigned long resultLength, [array, size_is (resultLength), const] in octet result); |
14524 |
| nsIStreamTransportService.rs |
/// * This service read/writes a stream on a background thread.
/// *
/// * Note: instead of using this interface, probably you want to use
/// * NS_MakeAsyncNonBlockingInputStream.
/// *
/// * Use this service to transform any blocking stream (e.g., file stream)
/// * into a fully asynchronous stream that can be read/written without
/// * blocking the main thread.
/// |
6659 |
| nsIStringBundle.rs |
AString GetStringFromID (in long aID); |
18704 |
| nsIStringEnumerator.rs |
/// * Used to enumerate over an ordered list of strings.
/// |
16871 |
| nsIStringStream.rs |
/// * nsIStringInputStream
/// *
/// * Provides scriptable and specialized C++-only methods for initializing a
/// * nsIInputStream implementation with a simple character array.
/// |
10335 |
| nsIStructuredCloneContainer.rs |
/// * This interface acts as a container for an object serialized using the
/// * structured clone algorithm.
/// *
/// * You can copy an object into an nsIStructuredCloneContainer using
/// * initFromJSVal or initFromBase64. It's an error to initialize an
/// * nsIStructuredCloneContainer more than once.
/// *
/// * Once you've initialized the container, you can get a copy of the object it
/// * stores by calling deserializeToVariant. You can also get a base-64-encoded
/// * string containing a copy of the container's serialized data, using
/// * getDataAsBase64.
/// |
9347 |
| nsIStructuredFieldValues.rs |
/// * Conceptually, there are three types of structured field (header) values:
/// *
/// * Item - can be an Integer, Decimal, String, Token, Byte Sequence, or Boolean.
/// * It can have associated Parameters.
/// * List - array of zero or more members, each of which can be an Item or an InnerList,
/// * both of which can be Parameterized.
/// * Dictionary - ordered map of name-value pairs, where the names are short textual strings
/// * and the values are Items or arrays of Items (represented with InnerList),
/// * both of which can be Parameterized. There can be zero or more members,
/// * and their names are unique in the scope of the Dictionary they occur within.
/// *
/// *
/// * There's also a few primitive types used to construct structured field values:
/// * - BareItem used as Item's value or as a parameter value in Parameters.
/// * - Parameters are an ordered map of key-value pairs that are associated with an Item or InnerList.
/// * The keys are unique within the scope the Parameters they occur within, and the values are BareItem.
/// * - InnerList is an array of zero or more Items. Can have Parameters.
/// * - ListEntry represents either Item or InnerList as a member of List or as member-value in Dictionary.
/// |
102785 |
| nsIStyleSheetService.rs |
void loadAndRegisterSheet (in nsIURI sheetURI, in unsigned long type); |
9414 |
| nsISubstitutingProtocolHandler.rs |
/// * Protocol handler superinterface for a protocol which performs substitutions
/// * from URIs of its scheme to URIs of another scheme.
/// |
9811 |
| nsISupports.rs |
/// * Basic component object model interface. Objects which implement
/// * this interface support runtime interface discovery (QueryInterface)
/// * and a reference counted memory model (AddRef/Release). This is
/// * modelled after the win32 IUnknown API.
/// *
/// * Historically, nsISupports needed to be binary compatible with COM's
/// * IUnknown, so the IID of nsISupports is the same as it. That is no
/// * longer a goal, and hopefully nobody depends on it. We may break
/// * this compatibility at any time.
/// |
6691 |
| nsISupportsIterators.rs |
/// * ...
/// |
47569 |
| nsISupportsPrimitives.rs |
/// * Primitive base interface.
/// *
/// * These first three are pointer types and do data copying
/// * using the nsIMemory. Be careful!
/// |
101920 |
| nsISupportsPriority.rs |
/// * This interface exposes the general notion of a scheduled object with a
/// * integral priority value. Following UNIX conventions, smaller (and possibly
/// * negative) values have higher priority.
/// *
/// * This interface does not strictly define what happens when the priority of an
/// * object is changed. An implementation of this interface is free to define
/// * the side-effects of changing the priority of an object. In some cases,
/// * changing the priority of an object may be disallowed (resulting in an
/// * exception being thrown) or may simply be ignored.
/// |
8073 |
| nsISVGPaintContext.rs |
readonly attribute ACString fillColor; |
7036 |
| nsISyncStreamListener.rs |
readonly attribute nsIInputStream inputStream; |
5905 |
| nsISynthVoiceRegistry.rs |
void addVoice (in nsISpeechService aService, in AString aUri, in AString aName, in AString aLang, in boolean aLocalService, in boolean aQueuesUtterances); |
12057 |
| nsISystemInfo.rs |
[implicit_jscontext] readonly attribute Promise diskInfo; |
6865 |
| nsISystemProxySettings.rs |
/// * This interface allows the proxy code to use platform-specific proxy
/// * settings when the proxy preference is set to "automatic discovery". This service
/// * acts like a PAC parser to netwerk, but it will actually read the system settings and
/// * either return the proper proxy data from the autoconfig URL specified in the system proxy,
/// * or generate proxy data based on the system's manual proxy settings.
/// |
8793 |
| nsISystemStatusBar.rs |
/// * Allow applications to interface with the Mac OS X system status bar.
/// |
6974 |
| nsITableEditor.rs |
[can_run_script] void insertTableCell (in long aNumberOfColumnsToInsert, in boolean aInsertAfterSelectedCell); |
41305 |
| nsITaggingService.rs |
void tagURI (in nsIURI aURI, in nsIVariant aTags, [optional] in unsigned short aSource); |
8195 |
| nsITaskbarOverlayIconController.rs |
/// * Starting in Windows 7, applications can display an overlay on the icon in
/// * the taskbar. This class wraps around the native functionality to do this.
/// |
7710 |
| nsITaskbarPreview.rs |
/// * nsITaskbarPreview
/// *
/// * Common interface for both window and tab taskbar previews. This interface
/// * cannot be instantiated directly.
/// *
/// |
11848 |
| nsITaskbarPreviewButton.rs |
/// * nsITaskbarPreviewButton
/// *
/// * Provides access to a window preview's toolbar button's properties.
/// |
11916 |
| nsITaskbarPreviewController.rs |
/// * nsITaskbarPreviewCallback
/// *
/// * Provides an interface for async image result callbacks. See
/// * nsITaskbarPreviewController request apis below.
/// |
17210 |
| nsITaskbarProgress.rs |
/// * Starting in Windows 7, applications can display a progress notification in
/// * the taskbar. This class wraps around the native functionality to do this.
/// |
7468 |
| nsITaskbarTabPreview.rs |
attribute AString title; |
8958 |
| nsITaskbarWindowPreview.rs |
nsITaskbarPreviewButton getButton (in unsigned long index); |
7317 |
| nsITCPSocketCallback.rs |
void fireErrorEvent (in AString name, in AString type, in nsresult errorCode); |
8137 |
| nsITelemetry.rs |
void complete (); |
49626 |
| nsITellableStream.rs |
long long tell (); |
5457 |
| nsITerminatorTest.rs |
[implicit_jscontext] jsval getTicksForShutdownPhases (); |
5369 |
| nsITextInputProcessor.rs |
|
47164 |
| nsITextInputProcessorCallback.rs |
/// * nsITextInputProcessorNotification stores the type of notification to IME and
/// * its detail. See each explanation of attribute for the detail.
/// |
29314 |
| nsITextToSubURI.rs |
ACString ConvertAndEscape (in ACString charset, in AString text); |
9149 |
| nsIThread.rs |
/// * This interface provides a high-level abstraction for an operating system
/// * thread.
/// *
/// * Threads have a built-in event queue, and a thread is an event target that
/// * can receive nsIRunnable objects (events) to be processed on the thread.
/// *
/// * See nsIThreadManager for the API used to create and locate threads.
/// |
18864 |
| nsIThreadInternal.rs |
/// * The XPCOM thread object implements this interface, which allows a consumer
/// * to observe dispatch activity on the thread.
/// |
17759 |
| nsIThreadManager.rs |
boolean isDone (); |
20080 |
| nsIThreadPool.rs |
void onThreadCreated (); |
24288 |
| nsIThreadRetargetableRequest.rs |
/// * nsIThreadRetargetableRequest
/// *
/// * Should be implemented by requests that support retargeting delivery of
/// * data off the main thread.
/// |
7420 |
| nsIThreadRetargetableStreamListener.rs |
/// * nsIThreadRetargetableStreamListener
/// *
/// * To be used by classes which implement nsIStreamListener and whose
/// * OnDataAvailable callback may be retargeted for delivery off the main thread.
/// |
8003 |
| nsIThreadShutdown.rs |
/// * Handle for the ongoing shutdown progress of a given thread which can be used
/// * to observe and interrupt async shutdown progress. Methods on this interface
/// * may generally only be used on the thread which called
/// * `nsIThread::beginShutdown`.
/// |
8112 |
| nsIThrottledInputChannel.rs |
/// * An instance of this interface can be used to throttle the uploads
/// * of a group of associated channels.
/// |
17097 |
| nsITimedChannel.rs |
[must_use] readonly attribute ACString name; |
39773 |
| nsITimer.rs |
void notify (in nsITimer timer); |
32781 |
| nsITlsHandshakeListener.rs |
|
6313 |
| nsITLSServerSocket.rs |
attribute nsIX509Cert serverCert; |
31610 |
| nsITLSSocketControl.rs |
[noscript] void proxyStartSSL (); |
22544 |
| nsITokenPasswordDialogs.rs |
/// * This is the interface for setting and changing password
/// * on a PKCS11 token.
/// |
6052 |
| nsIToolkitChromeRegistry.rs |
nsIUTF8StringEnumerator getLocalesForPackage (in AUTF8String aPackage); |
5796 |
| nsIToolkitProfile.rs |
/// * Hold on to a profile lock. Once you release the last reference to this
/// * interface, the profile lock is released.
/// |
20490 |
| nsIToolkitProfileService.rs |
[infallible] readonly attribute boolean isListOutdated; |
21923 |
| nsIToolkitShellService.rs |
boolean isDefaultApplication (); |
5754 |
| nsITooltipListener.rs |
/// * An optional interface for embedding clients wishing to receive
/// * notifications for when a tooltip should be displayed or removed.
/// * The embedder implements this interface on the web browser chrome
/// * object associated with the window that notifications are required
/// * for.
/// *
/// * @see nsITooltipTextProvider
/// |
7312 |
| nsITooltipTextProvider.rs |
/// * An interface implemented by a tooltip text provider service. This
/// * service is called to discover what tooltip text is associated
/// * with the node that the pointer is positioned over.
/// *
/// * Embedders may implement and register their own tooltip text provider
/// * service if they wish to provide different tooltip text.
/// *
/// * The default service returns the text stored in the TITLE
/// * attribute of the node or a containing parent.
/// *
/// * @note
/// * The tooltip text provider service is registered with the contract
/// * defined in NS_TOOLTIPTEXTPROVIDER_CONTRACTID.
/// *
/// * @see nsITooltipListener
/// * @see nsIComponentManager
/// * @see Node
/// |
6900 |
| nsITouchBarHelper.rs |
/// * Back-to-frontend communication for the Touch Bar
/// |
10435 |
| nsITouchBarInput.rs |
void onCommand (); |
19438 |
| nsITouchBarUpdater.rs |
/// * Front-to-backend communication to keep Touch Bar updated
/// |
8294 |
| nsITraceableChannel.rs |
/// * A channel implementing this interface allows one to intercept its data by
/// * inserting intermediate stream listeners.
/// |
5826 |
| nsITrackingDBService.rs |
void recordContentBlockingLog (in ACString data); |
8782 |
| nsITransaction.rs |
[can_run_script] void doTransaction (); |
9223 |
| nsITransactionManager.rs |
/// * The nsITransactionManager interface.
/// * <P>
/// * This interface is implemented by an object that wants to
/// * manage/track transactions.
/// |
16639 |
| nsITransfer.rs |
void init (in nsIURI aSource, in nsIURI aSourceOriginalURI, in nsIURI aTarget, in AString aDisplayName, in nsIMIMEInfo aMIMEInfo, in PRTime startTime, in nsIFile aTempFile, in nsICancelable aCancelable, in boolean aIsPrivate, in long aDownloadClassification, in nsIReferrerInfo aReferrerInfo, [optional] in boolean aOpenDownloadsListOnStart); |
14056 |
| nsITransferable.rs |
void getFlavorData (in nsITransferable aTransferable, in string aFlavor, out nsISupports aData); |
24865 |
| nsITransport.rs |
/// * nsITransport
/// *
/// * This interface provides a common way of accessing i/o streams connected
/// * to some resource. This interface does not in any way specify the resource.
/// * It provides methods to open blocking or non-blocking, buffered or unbuffered
/// * streams to the resource. The name "transport" is meant to connote the
/// * inherent data transfer implied by this interface (i.e., data is being
/// * transfered in some fashion via the streams exposed by this interface).
/// *
/// * A transport can have an event sink associated with it. The event sink
/// * receives transport-specific events as the transfer is occuring. For a
/// * socket transport, these events can include status about the connection.
/// * See nsISocketTransport for more info about socket transport specifics.
/// |
19448 |
| nsITransportProvider.rs |
/// * An interface which can be used to asynchronously request a nsITransport
/// * together with the input and output streams that go together with it.
/// |
5925 |
| nsITransportSecurityInfo.rs |
readonly attribute unsigned long securityState; |
19236 |
| nsITreeSelection.rs |
attribute XULTreeElement tree; |
22006 |
| nsITreeView.rs |
readonly attribute long rowCount; |
22651 |
| nsITRRSkipReason.rs |
|
7368 |
| nsITXTToHTMLConv.rs |
void setTitle (in wstring text); |
6218 |
| nsITypeAheadFind.rs |
nsTypeAheadFind ***************************** |
13820 |
| nsIUDPSocket.rs |
/// * nsIUDPSocket
/// *
/// * An interface to a UDP socket that can accept incoming connections.
/// |
53047 |
| nsIUDPSocketChild.rs |
void callListenerOpened (); |
7322 |
| nsIUnicharInputStream.rs |
[noscript] unsigned long read ([array, size_is (aCount)] in char16_t aBuf, in unsigned long aCount); |
8962 |
| nsIUnicharLineInputStream.rs |
boolean readLine (out AString aLine); |
6129 |
| nsIUnicharOutputStream.rs |
/// * An interface that allows writing unicode data.
/// |
7665 |
| nsIUpdateService.rs |
/// * An interface that describes an object representing a patch file that can
/// * be downloaded and applied to a version of this application so that it
/// * can be updated.
/// |
151675 |
| nsIUpdateTimerManager.rs |
/// * An interface describing a global application service that allows long
/// * duration (e.g. 1-7 or more days, weeks or months) timers to be registered
/// * and then fired.
/// |
8473 |
| nsIUploadChannel.rs |
/// * nsIUploadChannel
/// *
/// * A channel may optionally implement this interface if it supports the
/// * notion of uploading a data stream. The upload stream may only be set
/// * prior to the invocation of asyncOpen on the channel.
/// |
8141 |
| nsIUploadChannel2.rs |
void explicitSetUploadStream (in nsIInputStream aStream, in ACString aContentType, in long long aContentLength, in ACString aMethod, in boolean aStreamHasHeaders); |
8713 |
| nsIURI.rs |
/// * nsIURI - interface for an uniform resource identifier w/ i18n support.
/// *
/// * AUTF8String attributes may contain unescaped UTF-8 characters.
/// * Consumers should be careful to escape the UTF-8 strings as necessary, but
/// * should always try to "display" the UTF-8 version as provided by this
/// * interface.
/// *
/// * AUTF8String attributes may also contain escaped characters.
/// *
/// * Unescaping URI segments is unadvised unless there is intimate
/// * knowledge of the underlying charset or there is no plan to display (or
/// * otherwise enforce a charset on) the resulting URI substring.
/// *
/// * The correct way to create an nsIURI from a string is via
/// * nsIIOService.newURI.
/// *
/// * NOTE: nsBinaryInputStream::ReadObject contains a hackaround to intercept the
/// * old (pre-gecko6) nsIURI IID and swap in the current IID instead, in order
/// * for sessionstore to work after an upgrade. If this IID is revved further,
/// * we will need to add additional checks there for all intermediate IIDs, until
/// * ContentPrincipal is fixed to serialize its URIs as nsISupports (bug 662693).
/// |
25729 |
| nsIURIClassifier.rs |
/// * Callback function for nsIURIClassifier lookups.
/// |
17954 |
| nsIURIContentListener.rs |
/// * nsIURIContentListener is an interface used by components which
/// * want to know (and have a chance to handle) a particular content type.
/// * Typical usage scenarios will include running applications which register
/// * a nsIURIContentListener for each of its content windows with the uri
/// * dispatcher service.
/// |
16242 |
| nsIURIFixup.rs |
/// * Interface indicating what we found/corrected when fixing up a URI
/// |
30814 |
| nsIURILoader.rs |
/// * The uri dispatcher is responsible for taking uri's, determining
/// * the content and routing the opened url to the correct content
/// * handler.
/// *
/// * When you encounter a url you want to open, you typically call
/// * openURI, passing it the content listener for the window the uri is
/// * originating from. The uri dispatcher opens the url to discover the
/// * content type. It then gives the content listener first crack at
/// * handling the content. If it doesn't want it, the dispatcher tries
/// * to hand it off one of the registered content listeners. This allows
/// * running applications the chance to jump in and handle the content.
/// *
/// * If that also fails, then the uri dispatcher goes to the registry
/// * looking for the preferred content handler for the content type
/// * of the uri. The content handler may create an app instance
/// * or it may hand the contents off to a platform specific plugin
/// * or helper app. Or it may hand the url off to an OS registered
/// * application.
/// |
13350 |
| nsIURIMutator.rs |
[must_use] nsIURIMutator setSpec (in AUTF8String aSpec); |
23263 |
| nsIURIWithSpecialOrigin.rs |
/// * nsIURIWithSpecialOrigin is implemented by URIs need to supply an origin that
/// * does not match the spec. This is exclusively used in comm-central's Mailnews module.
/// |
5675 |
| nsIURL.rs |
/// * The nsIURL interface provides convenience methods that further
/// * break down the path portion of nsIURI:
/// *
/// * http://host/directory/fileBaseName.fileExtension?query
/// * http://host/directory/fileBaseName.fileExtension#ref
/// * \ \ /
/// * \ -----------------------
/// * \ | /
/// * \ fileName /
/// * ----------------------------
/// * |
/// * filePath
/// |
18715 |
| nsIUrlClassifierDBService.rs |
void handleEvent (in ACString value); |
43472 |
| nsIUrlClassifierExceptionListService.rs |
/// * Observer for exception list updates.
/// |
15118 |
| nsIUrlClassifierFeature.rs |
/// * A single URLClassifier feature.
/// |
23536 |
| nsIUrlClassifierHashCompleter.rs |
/// * This interface contains feilds in Matches object of FullHashResponse(V4).
/// * Reference from:
/// * https://developers.google.com/safe-browsing/v4/update-api#http-post-response_2
/// |
22064 |
| nsIUrlClassifierInfo.rs |
/// * nsIUrlClassifierPositiveCacheEntry Represents a positive cache entry.
/// |
30207 |
| nsIUrlClassifierPrefixSet.rs |
void init (in ACString aName); |
7349 |
| nsIUrlClassifierRemoteSettingsService.rs |
/// * A service that serves Safe Browsing list data (V2 protocol) via
/// * Remote Settings.
/// |
6915 |
| nsIUrlClassifierStreamUpdater.rs |
/// * This is a class to manage large table updates from the server. Rather than
/// * downloading the whole update and then updating the sqlite database, we
/// * update tables as the data is streaming in.
/// |
7998 |
| nsIUrlClassifierUtils.rs |
/// * Interface for parseFindFullHashResponseV4 callback
/// |
23293 |
| nsIURLDecorationAnnotationsService.rs |
/// * A service that monitors updates to the anti-tracking URL decoration
/// * annotations from remote settings.
/// |
6275 |
| nsIURLFormatter.rs |
AString formatURL (in AString aFormat); |
7312 |
| nsIUrlListManager.rs |
/// * Interface for a class that manages updates of the url classifier database.
/// |
13491 |
| nsIURLParser.rs |
/// * nsIURLParser specifies the interface to an URL parser that attempts to
/// * follow the definitions of RFC 2396.
/// |
14220 |
| nsIURLQueryStringStripper.rs |
/// * nsIURLQueryStringStripper is responsible for stripping certain part of the
/// * query string of the given URI to address the bounce(redirect) tracking
/// * issues. It will strip every query parameter which matches the strip list
/// * defined in the pref 'privacy.query_stripping.strip_list'. Note that It's
/// * different from URLDecorationStripper which strips the entire query string
/// * from the referrer if there is a tracking query parameter present in the URI.
/// *
/// * TODO: Given that nsIURLQueryStringStripper and URLDecorationStripper are
/// * doing similar things. We could somehow combine these two modules into
/// * one. We will improve this in the future.
/// |
7769 |
| nsIURLQueryStrippingListService.rs |
/// * Observer for query stripping list updates.
/// |
19603 |
| nsIUserCharacteristicsPageService.rs |
|
5847 |
| nsIUserIdleService.rs |
/// * This interface lets you monitor how long the user has been 'idle',
/// * i.e. not used their mouse or keyboard. You can get the idle time directly,
/// * but in most cases you will want to register an observer for a predefined
/// * interval. The observer will get an 'idle' notification when the user is idle
/// * for that interval (or longer), and receive an 'active' notification when the
/// * user starts using their computer again.
/// |
10144 |
| nsIUserIdleServiceInternal.rs |
void resetIdleTimeOut (in unsigned long idleDeltaInMS); |
5776 |
| nsIUtilityProcessTest.rs |
[implicit_jscontext] Promise startProcess ([optional] in Array<ACString> actorsToAdd); |
8239 |
| nsIUUIDGenerator.rs |
/// * nsIUUIDGenerator is implemented by a service that can generate
/// * universally unique identifiers, ideally using any platform-native
/// * method for generating UUIDs.
/// |
6618 |
| nsIVariant.rs |
/// * XPConnect has magic to transparently convert between nsIVariant and JS types.
/// * We mark the interface [scriptable] so that JS can use methods
/// * that refer to this interface. But we mark all the methods and attributes
/// * [noscript] since any nsIVariant object will be automatically converted to a
/// * JS type anyway.
/// |
31961 |
| nsIVersionComparator.rs |
/// * Version strings are dot-separated sequences of version-parts.
/// *
/// * A version-part consists of up to four parts, all of which are optional:
/// *
/// * <number-a><string-b><number-c><string-d (everything else)>
/// *
/// * A version-part may also consist of a single asterisk "*" which indicates
/// * "infinity".
/// *
/// * Numbers are base-10, and are zero if left out.
/// * Strings are compared bytewise.
/// *
/// * For additional backwards compatibility, if "string-b" is "+" then
/// * "number-a" is incremented by 1 and "string-b" becomes "pre".
/// *
/// * 1.0pre1
/// * < 1.0pre2
/// * < 1.0 == 1.0.0 == 1.0.0.0
/// * < 1.1pre == 1.1pre0 == 1.0+
/// * < 1.1pre1a
/// * < 1.1pre1
/// * < 1.1pre10a
/// * < 1.1pre10
/// *
/// * Although not required by this interface, it is recommended that
/// * numbers remain within the limits of a signed char, i.e. -127 to 128.
/// |
6724 |
| nsIViewSourceChannel.rs |
[must_use] attribute ACString originalContentType; |
9545 |
| nsIWakeLock.rs |
void unlock (); |
4967 |
| nsIWeakReference.rs |
/// * An instance of |nsIWeakReference| is a proxy object that cooperates with
/// * its referent to give clients a non-owning, non-dangling reference. Clients
/// * own the proxy, and should generally manage it with an |nsCOMPtr| (see the
/// * type |nsWeakPtr| for a |typedef| name that stands out) as they would any
/// * other XPCOM object. The |QueryReferent| member function provides a
/// * (hopefully short-lived) owning reference on demand, through which clients
/// * can get useful access to the referent, while it still exists.
/// *
/// * @version 1.0
/// * @see nsISupportsWeakReference
/// * @see nsWeakReference
/// * @see nsWeakPtr
/// |
13100 |
| nsIWebAuthnArgs.rs |
readonly attribute AString origin; |
24738 |
| nsIWebAuthnAttObj.rs |
readonly attribute Array<octet> attestationObject; |
7162 |
| nsIWebAuthnPromise.rs |
|
12277 |
| nsIWebAuthnResult.rs |
readonly attribute ACString clientDataJSON; |
18493 |
| nsIWebAuthnService.rs |
readonly attribute ACString credentialId; |
31752 |
| nsIWebBrowser.rs |
/// * The nsIWebBrowser interface is implemented by web browser objects.
/// * Embedders use this interface during initialisation to associate
/// * the new web browser instance with the embedders chrome and
/// * to register any listeners. The interface may also be used at runtime
/// * to obtain the content DOM window and from that the rest of the DOM.
/// |
10945 |
| nsIWebBrowserChrome.rs |
/// * nsIWebBrowserChrome corresponds to the top-level, outermost window
/// * containing an embedded Gecko web browser.
/// |
11387 |
| nsIWebBrowserFind.rs |
/// * nsIWebBrowserFind
/// *
/// * Searches for text in a web browser.
/// *
/// * Get one by doing a GetInterface on an nsIWebBrowser.
/// *
/// * By default, the implementation will search the focussed frame, or
/// * if there is no focussed frame, the web browser content area. It
/// * does not by default search subframes or iframes. To change this
/// * behaviour, and to explicitly set the frame to search,
/// * QueryInterface to nsIWebBrowserFindInFrames.
/// |
26831 |
| nsIWebBrowserPersist.rs |
/// * Interface for persisting DOM documents and URIs to local or remote storage.
/// |
23924 |
| nsIWebBrowserPersistDocument.rs |
/// * Interface for the URI-mapping information that can be supplied when
/// * serializing the DOM of an nsIWebBrowserPersistDocument.
/// *
/// * @see nsIWebBrowserPersistDocument
/// |
46841 |
| nsIWebBrowserPrint.rs |
/// * nsIWebBrowserPrint corresponds to the main interface
/// * for printing an embedded Gecko web browser window/document
/// |
13740 |
| nsIWebNavigation.rs |
/// * 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.
/// |
29008 |
| nsIWebNavigationInfo.rs |
/// * The nsIWebNavigationInfo interface exposes a way to get information
/// * on the capabilities of Gecko webnavigation objects.
/// |
7178 |
| nsIWebPageDescriptor.rs |
/// * The nsIWebPageDescriptor interface allows content being displayed in one
/// * window to be loaded into another window without refetching it from the
/// * network.
/// |
6730 |
| nsIWebProgress.rs |
/// * The nsIWebProgress interface is used to add or remove nsIWebProgressListener
/// * instances to observe the loading of asynchronous requests (usually in the
/// * context of a DOM window).
/// *
/// * nsIWebProgress instances may be arranged in a parent-child configuration,
/// * corresponding to the parent-child configuration of their respective DOM
/// * windows. However, in some cases a nsIWebProgress instance may not have an
/// * associated DOM window. The parent-child relationship of nsIWebProgress
/// * instances is not made explicit by this interface, but the relationship may
/// * exist in some implementations.
/// *
/// * A nsIWebProgressListener instance receives notifications for the
/// * nsIWebProgress instance to which it added itself, and it may also receive
/// * notifications from any nsIWebProgress instances that are children of that
/// * nsIWebProgress instance.
/// |
16526 |
| nsIWebProgressListener.rs |
/// * The nsIWebProgressListener interface is implemented by clients wishing to
/// * listen in on the progress associated with the loading of asynchronous
/// * requests in the context of a nsIWebProgress instance as well as any child
/// * nsIWebProgress instances. nsIWebProgress.idl describes the parent-child
/// * relationship of nsIWebProgress instances.
/// |
38655 |
| nsIWebProgressListener2.rs |
/// * An extended version of nsIWebProgressListener.
/// |
9413 |
| nsIWebProtocolHandlerRegistrar.rs |
/// * nsIWebProtocolHandlerRegistrar
/// *
/// * Applications wishing to use web protocol handlers need to implement this
/// * interface. Typically they will prompt the user to confirm adding an entry
/// * to the local list.
/// *
/// * The component must have the contract id defined below so that the Navigator
/// * implementation can invoke it.
/// |
7832 |
| nsIWebSocketChannel.rs |
/// * Low-level websocket API: handles network protocol.
/// *
/// * This is primarly intended for use by the higher-level nsIWebSocket.idl.
/// * We are also making it scriptable for now, but this may change once we have
/// * WebSockets for Workers.
/// |
28156 |
| nsIWebSocketEventService.rs |
[must_use] readonly attribute DOMHighResTimeStamp timeStamp; |
25626 |
| nsIWebSocketImpl.rs |
[must_use] void sendMessage (in AString aMessage); |
5477 |
| nsIWebSocketListener.rs |
/// * nsIWebSocketListener: passed to nsIWebSocketChannel::AsyncOpen. Receives
/// * websocket traffic events as they arrive.
/// |
11745 |
| nsIWebTransport.rs |
void asyncConnect (in nsIURI aURI, in boolean aDedicated, in Array<nsIWebTransportHash> aServerCertHashes, in nsIPrincipal aLoadingPrincipal, in unsigned long aSecurityFlags, in WebTransportSessionEventListener aListener); |
44839 |
| nsIWebTransportStream.rs |
|
41317 |
| nsIWebVTTListener.rs |
/// * Listener for a JS WebVTT parser (vtt.js).
/// |
6498 |
| nsIWebVTTParserWrapper.rs |
/// * Interface for a wrapper of a JS WebVTT parser (vtt.js).
/// |
11238 |
| nsIWellKnownOpportunisticUtils.rs |
|
6094 |
| nsIWifiAccessPoint.rs |
readonly attribute ACString mac; |
6401 |
| nsIWifiListener.rs |
void onChange (in Array<nsIWifiAccessPoint> accessPoints); |
5686 |
| nsIWifiMonitor.rs |
void startWatching (in nsIWifiListener aListener, in boolean aForcePolling); |
6239 |
| nsIWinAppHelper.rs |
/// * A scriptable interface used on Windows only to do some work from
/// * a special process that gets created with elevated privileges.
/// *
/// * @status UNSTABLE - This interface is not frozen and will probably change in
/// * future releases.
/// |
5535 |
| nsIWindowCreator.rs |
nsIWebBrowserChrome createChromeWindow (in nsIWebBrowserChrome parent, in uint32_t chromeFlags, in nsIOpenWindowInfo aOpenWindowInfo, out boolean cancel); |
6893 |
| nsIWindowlessBrowser.rs |
/// * This interface represents a nsIWebBrowser instance with no associated OS
/// * window. Its main function is to manage the lifetimes of those windows.
/// * A strong reference to this object must be held until the window is
/// * ready to be destroyed.
/// |
7152 |
| nsIWindowMediator.rs |
nsISimpleEnumerator getEnumerator (in wstring aWindowType); |
16173 |
| nsIWindowMediatorListener.rs |
void onOpenWindow (in nsIAppWindow window); |
5866 |
| nsIWindowProvider.rs |
/// * The nsIWindowProvider interface exists so that the window watcher's default
/// * behavior of opening a new window can be easly modified. When the window
/// * watcher needs to open a new window, it will first check with the
/// * nsIWindowProvider it gets from the parent window. If there is no provider
/// * or the provider does not provide a window, the window watcher will proceed
/// * to actually open a new window.
/// |
10466 |
| nsIWindowsAlertsService.rs |
attribute boolean handleActions; |
16020 |
| nsIWindowsMutex.rs |
/// * Interact with Windows named mutexes.
/// *
/// * Generally you don't want a Windows named mutex, you want one of the many Gecko
/// * locking primitives. But when you do want cross-application instance or even
/// * cross-installation coordination, a Windows named mutex might be an
/// * appropriate tool.
/// |
12757 |
| nsIWindowsPackageManager.rs |
Array<AString> findUserInstalledPackages (in Array<AString> prefix); |
6362 |
| nsIWindowsRegKey.rs |
/// * This interface is designed to provide scriptable access to the Windows
/// * registry system ("With Great Power Comes Great Responsibility"). The
/// * interface represents a single key in the registry.
/// *
/// * This interface is highly Win32 specific.
/// |
25668 |
| nsIWindowsShellService.rs |
|
15785 |
| nsIWindowsUIUtils.rs |
readonly attribute long systemSmallIconSize; |
10001 |
| nsIWindowWatcher.rs |
/// * nsIWindowWatcher is the keeper of Gecko/DOM Windows. It maintains
/// * a list of open top-level windows, and allows some operations on them.
///
/// * Usage notes:
///
/// * This component has an |activeWindow| property. Clients may expect
/// * this property to be always current, so to properly integrate this component
/// * the application will need to keep it current by setting the property
/// * as the active window changes.
/// * This component should not keep a (XPCOM) reference to any windows;
/// * the implementation will claim no ownership. Windows must notify
/// * this component when they are created or destroyed, so only a weak
/// * reference is kept. Note that there is no interface for such notifications
/// * (not a public one, anyway). This is taken care of both in Mozilla and
/// * by common embedding code. Embedding clients need do nothing special
/// * about that requirement.
/// * This component must be initialized at application startup by calling
/// * setWindowCreator.
/// |
17418 |
| nsIWinTaskbar.rs |
readonly attribute boolean available; |
15810 |
| nsIWinTaskSchedulerService.rs |
/// * An interface for Windows Task Scheduler 2.0.
/// * Documentation for the underlying APIs can be found at
/// * https://docs.microsoft.com/en-us/windows/win32/taskschd/task-scheduler-start-page
/// |
14287 |
| nsIWorkerChannelInfo.rs |
[infallible] attribute unsigned long long workerAssociatedBrowsingContextID; |
13041 |
| nsIWorkerDebugger.rs |
void onClose (); |
17859 |
| nsIWorkerDebuggerManager.rs |
|
12506 |
| nsIWritablePropertyBag.rs |
void setProperty (in AString name, in nsIVariant value); |
6349 |
| nsIWritablePropertyBag2.rs |
void setPropertyAsInt32 (in AString prop, in int32_t value); |
10417 |
| nsIX509Cert.rs |
/// * This represents a X.509 certificate.
/// *
/// * NOTE: Service workers persist x.509 certs in object form on disk. If you
/// * change this uuid you probably need a hack in nsBinaryInputStream to
/// * read the old uuid. If you change the format of the object
/// * serialization then more complex changes will be needed.
/// |
20370 |
| nsIX509CertDB.rs |
readonly attribute nsIX509Cert signerCert; |
48777 |
| nsIX509CertValidity.rs |
/// * Information on the validity period of a X.509 certificate.
/// |
6072 |
| nsIXPCScriptable.rs |
readonly attribute AUTF8String className; |
9161 |
| nsIXREDirProvider.rs |
void setUserDataDirectory (in nsIFile aFile, in boolean aLocal); |
6151 |
| nsIXULAppInfo.rs |
/// * A scriptable interface to the nsXULAppAPI structure. See nsXULAppAPI.h for
/// * a detailed description of each attribute.
/// |
9655 |
| nsIXULBrowserWindow.rs |
/// * The nsIXULBrowserWindow supplies the methods that may be called from the
/// * internals of the browser area to tell the containing xul window to update
/// * its ui.
/// |
8397 |
| nsIXULRuntime.rs |
/// * Provides information about the XUL runtime.
/// * @status UNSTABLE - This interface is not frozen and will probably change in
/// * future releases. If you need this functionality to be
/// * stable/frozen, please contact Benjamin Smedberg.
/// |
34075 |
| nsIXULStore.rs |
/// * The XUL store is used to store information related to a XUL document/application.
/// * Typically it is used to store the persisted state for the document, such as
/// * window location, toolbars that are open and nodes that are open and closed in a tree.
/// *
/// * The data is serialized to [profile directory]/xulstore.json
/// |
12175 |
| nsIZipReader.rs |
[infallible] readonly attribute unsigned short compression; |
34432 |
| nsIZipWriter.rs |
/// * nsIZipWriter
/// *
/// * An interface for a zip archiver that can be used from script.
/// *
/// * The interface supports both a synchronous method of archiving data and a
/// * queueing system to allow operations to be prepared then run in sequence
/// * with notification after completion.
/// *
/// * Operations added to the queue do not get performed until performQueue is
/// * called at which point they will be performed in the order that they were
/// * added to the queue.
/// *
/// * Operations performed on the queue will throw any errors out to the
/// * observer.
/// *
/// * An attempt to perform a synchronous operation while the background queue
/// * is in progress will throw NS_ERROR_IN_PROGRESS.
/// *
/// * Entry names should use /'s as path separators and should not start with
/// * a /.
/// *
/// * It is not generally necessary to add directory entries in order to add file
/// * entries within them, however it is possible that some zip programs may
/// * experience problems what that.
/// |
21660 |
| nsPIDNSService.rs |
/// * This is a private interface used by the internals of the networking library.
/// * It will never be frozen. Do not use it in external code.
/// |
7137 |
| nsPISocketTransportService.rs |
/// * This is a private interface used by the internals of the networking library.
/// * It will never be frozen. Do not use it in external code.
/// |
9640 |
| nsPIWindowWatcher.rs |
void addWindow (in mozIDOMWindowProxy aWindow, in nsIWebBrowserChrome aChrome); |
12773 |
| nsrootidl.rs |
/// * Root idl declarations to be used by all.
/// |
236 |
| txIEXSLTFunctions.rs |
DocumentFragment match (in AString str, in AString regex, in AString flags, in Document doc); |
7117 |
| xpccomponents.rs |
/// * interface of Components.interfaces
/// * (interesting stuff only reflected into JavaScript)
/// |
99258 |
| xpcIJSWeakReference.rs |
[implicit_jscontext] jsval get (); |
5341 |
| xpctest_attributes.rs |
readonly attribute string strReadOnly; |
18698 |
| xpctest_bug809674.rs |
[implicit_jscontext] unsigned long addArgs (in unsigned long x, in unsigned long y); |
8578 |
| xpctest_cenums.rs |
void testCEnumInput (in nsIXPCTestCEnums_testFlagsExplicit abc); |
6279 |
| xpctest_interfaces.rs |
attribute string name; |
16725 |
| xpctest_params.rs |
boolean testBoolean (in boolean a, inout boolean b); |
33610 |
| xpctest_returncode.rs |
nsresult callChild (in long childBehavior); |
10994 |
| xpctest_utils.rs |
string echo (in string arg); |
24276 |