mozilla-central/__GENERATED__/dist/xpcrs/rt
Name Description Size
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 /// 11179
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. /// 40340
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); 18516
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. /// 21616
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. /// 17528
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 /// 15225
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); 9121
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); /// 15167
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; 24619
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. /// 18953
nsIAlertsService.rs 69092
nsIAndroidBridge.rs [implicit_jscontext] void onSuccess ([optional] in jsval data); 32639
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); 15555
nsIAppStartup.rs void createHiddenWindow (); 24032
nsIAppWindow.rs readonly attribute nsIDocShell docShell; 20523
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; 10351
nsIAutoCompleteResult.rs readonly attribute AString searchString; 12705
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. /// 20174
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. /// 17196
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. /// 48723
nsIBlocklistService.rs readonly attribute boolean isLoaded; 5433
nsIBounceTrackingProtection.rs void clearAll (); 9717
nsIBrowser.rs void dropLinks (in Array<AString> links, in nsIPrincipal triggeringPrincipal); 19964
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; 25346
nsIBrowserHandler.rs attribute AUTF8String startPage; 9592
nsIBrowserUsage.rs uint32_t getUniqueDomainsVisitedInPast24Hours (); 5450
nsIBrowserWindowTracker.rs attribute AString contentTitle; 12459
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; 41153
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. /// 62313
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. /// 10583
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; 7878
nsIClearDataService.rs /// * nsIClearDataService /// * /// * Provides methods for cleaning data from a nsIPrincipal and/or from a time /// * range. /// 30294
nsIClickRule.rs [must_use] readonly attribute ACString id; 9922
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); 44005
nsIClipboardHelper.rs /// * helper service for common uses of nsIClipboard. /// 8324
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. /// 14462
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 65224
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). /// 14066
nsIContentPrefService2.rs void onContentPrefSet (in AString aGroup, in AString aName, in nsIVariant aValue, [optional] in boolean aIsPrivate); 54923
nsIContentProcess.rs readonly attribute boolean isAlive; 13915
nsIContentSecurityManager.rs /// * nsIContentSecurityManager /// * Describes an XPCOM component used to perform security checks. /// 7009
nsIContentSecurityPolicy.rs [binaryname(GetPolicyString)] AString getPolicy (in unsigned long index); 36880
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. /// 14787
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). /// 19483
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 /// 23043
nsICookieNotification.rs /// * Meta object dispatched by cookie change notifications. /// 9195
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 /// 15261
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
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
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); 17656
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; 69005
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 /// 27657
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 /// 82002
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); 31022
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 nsICategoryManager to find an entry /// * with the mimetype as its name in the category "Gecko-Content-Viewers". /// * The value of the entry is the contractid of the component. /// * The component is a service, so use GetService, not CreateInstance to get it. /// 7658
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 nsIntRectRef aBounds, in WindowGlobalChildPtr aWindowActor); 30939
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; 214381
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] void invokeDragSession (in Node aDOMNode, in nsIPrincipal aPrincipal, in nsIContentSecurityPolicy aCsp, in nsICookieJarSettings aCookieJarSettings, in nsIArray aTransferables, in unsigned long aActionType, [optional] in nsContentPolicyType aContentPolicyType); 19189
nsIDragSession.rs attribute boolean canDrop; 23298
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; 53513
nsIEditorMailSupport.rs [can_run_script] Node insertAsCitedQuotation (in AString aQuotedText, in AString aCitation, in boolean aInsertHTML); 9269
nsIEditorSpellCheck.rs boolean canSpellCheck (); 24382
nsIEffectiveTLDService.rs ACString getPublicSuffix (in nsIURI aURI); 20397
nsIEncodedChannel.rs /// * A channel interface which allows special handling of encoded content /// 10504
nsIEnterprisePolicies.rs readonly attribute short status; 10401
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 AString filename; 16977
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. /// 31476
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. /// 16740
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); 33327
nsIFile.rs void append (in AString node); 59321
nsIFileChannel.rs /// * nsIFileChannel /// 5207
nsIFilePicker.rs void init (in BrowsingContext browsingContext, in AString title, in nsIFilePicker_Mode mode); 31964
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. /// 25214
nsIFOG.rs void initializeFOG ([optional] in AUTF8String aDataPathOverride, [optional] in AUTF8String aAppIdOverride, [optional] in boolean aDisableInternalPings); 19456
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
nsIFormHistoryAutoComplete.rs 7083
nsIFormPOSTActionChannel.rs /// * nsIFormPOSTActionChannel /// * /// * Channel classes that want to be allowed for HTML form POST action must /// * implement this interface. /// 5218
nsIGeolocationProvider.rs /// /// * Interface provides a way for a geolocation provider to /// * notify the system that a new location is available. /// 13719
nsIGfxInfo.rs readonly attribute boolean D2DEnabled; 33462
nsIGfxInfoDebug.rs void spoofVendorID (in AString aVendorID); 6544
nsIGIOService.rs readonly attribute AUTF8String id; 19392
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; 8464
nsIHTMLEditor.rs [can_run_script] void setInlineProperty (in AString aProperty, in AString aAttribute, in AString aValue); 33873
nsIHTMLInlineTableEditor.rs [setter_can_run_script] attribute boolean inlineTableEditingEnabled; 6821
nsIHTMLObjectResizer.rs [setter_can_run_script] attribute boolean objectResizingEnabled; 7023
nsIHttpActivityObserver.rs /// * nsIHttpActivityObserver /// * /// * This interface provides a way for http activities to be reported /// * to observers. /// 22882
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() /// 74907
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 /// * An interface to test for cookie permissions /// 5778
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 10187
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 /// * nsIIDNService interface. /// * /// * IDN (Internationalized Domain Name) support. Provides facilities /// * for manipulating IDN hostnames according to the specification set /// * forth by the IETF. /// * /// * IDN effort: /// * http://www.ietf.org/html.characters/idn-charter.html /// * http://www.i-dns.net /// * /// * IDNA specification: /// * http://search.ietf.org/internet-drafts/draft-ietf-idn-idna-06.txt /// 8442
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. /// 12341
nsIIncrementalStreamLoader.rs 16976
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. /// 39350
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); 12012
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 file. 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. /// 63411
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
nsILegacyJumpListBuilder.rs 20391
nsILegacyJumpListItem.rs /// * Implements Win7 Taskbar jump list item interfaces. /// * /// * Note to consumers: it's reasonable to expect we'll need support for other types /// * of jump list items (an audio file, an email message, etc.). To add types, /// * create the specific interface here, add an implementation class to WinJumpListItem, /// * and add support to addListBuild & removed items processing. /// * /// 28998
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; 17339
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; 169770
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
nsILoginAutoCompleteSearch.rs 6894
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. /// 11021
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 /// 20858
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 8242
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); 7064
nsINotificationStorage.rs 17557
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); 36058
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
nsIOpenWindowInfo.rs 15579
nsIOSKeyStore.rs [implicit_jscontext,must_use] Promise asyncGenerateSecret (in ACString label); 11150
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); 24811
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. /// 29365
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); 64782
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
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. /// 27099
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); 12279
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?" /// 49463
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. /// 24513
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. /// 14575
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. /// 44176
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
nsIQuotaCallbacks.rs void onUsageResult (in nsIQuotaUsageRequest aRequest); 10529
nsIQuotaManagerService.rs [must_use] nsIQuotaRequest storageName (); 33932
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. /// 8523
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
nsIRemoteTab.rs attribute boolean renderLayers; 15212
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. /// 11813
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; 30351
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; 6410
nsISDBResults.rs [must_use] Array<uint8_t> getAsArray (); 5430
nsISearchService.rs readonly attribute nsIInputStream postData; 67120
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); 25868
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 62623
nsISessionStorageService.rs void clearStoragesForOrigin (in nsIPrincipal aPrincipal); 5740
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. /// 29367
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 /// 6722
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); 18688
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
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. /// 7210
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 (); 58363
nsITellableStream.rs long long tell (); 5457
nsITerminatorTest.rs [implicit_jscontext] jsval getTicksForShutdownPhases (); 5369
nsITextInputProcessor.rs 45852
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. /// 19355
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 (); 23764
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; 39050
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. /// 17058
nsIToolkitProfileService.rs [infallible] readonly attribute boolean isListOutdated; 17310
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); 8738
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); 13776
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 7270
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. /// 50878
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. /// 114181
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). /// 26216
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 /// 30772
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. /// 7310
nsIURLQueryStrippingListService.rs /// * Observer for query stripping list updates. /// 19603
nsIUserCharacteristicsPageService.rs 5797
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. /// 11143
nsIWebBrowserChrome.rs /// * nsIWebBrowserChrome corresponds to the top-level, outermost window /// * containing an embedded Gecko web browser. /// 11496
nsIWebBrowserChromeFocus.rs /// * The nsIWebBrowserChromeFocus is implemented by the same object as the /// * nsIEmbeddingSiteWindow. It represents the focus up-calls from mozilla /// * to the embedding chrome. See mozilla bug #70224 for gratuitous info. /// 6644
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. /// 27821
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. /// 38203
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); 5753
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); 22153
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 13428
nsIWindowsUIUtils.rs readonly attribute long systemSmallIconSize; 8888
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; 17026
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 (); 17855
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; 48391
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. /// 34947
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); 12783
nsrootidl.rs /// * Root idl declarations to be used by all. /// 236
SessionStoreFunctions.rs 6071
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) /// 98667
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