dlls/mshtml/nsiface.idl

   1 /*
   2  * Copyright 2005-2012 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 /*
  20  * NOTE:
  21  * This file is not a typical idl file. Interfaces in this file are XPCOM
  22  * interfaces (NOT MSCOM!), but we generate the header file with WIDL
  23  * compatible with XPCOM, usable in C code.
  24  */
  25
  26 cpp_quote("#define GECKO_VERSION \"2.36\"")
  27 cpp_quote("#define GECKO_VERSION_STRING \"Wine Gecko \" GECKO_VERSION")
  28
  29 import "wtypes.idl";
  30
  31 cpp_quote("#ifdef WINE_NO_UNICODE_MACROS")
  32 cpp_quote("#undef GetForm")
  33 cpp_quote("#undef SetPort")
  34 cpp_quote("#undef GetClassName")
  35 cpp_quote("#endif")
  36
  37 typedef HRESULT nsresult;
  38 typedef ULONG nsrefcnt;
  39
  40 typedef IID nsID;
  41 typedef IID nsIID;
  42 typedef nsIID nsCID;
  43 typedef REFIID nsIIDRef;
  44 typedef nsIIDRef nsCIDRef;
  45
  46 typedef WCHAR PRUnichar;
  47
  48 /*
  49  * Mozilla uses stdint.h types for its headers. Following defines make this IDL file
  50  * more similar to original declarations. Note that it's only a widl trick, we can't
  51  * use stdint.h types in C.
  52  */
  53 #define int16_t short
  54 #define int32_t LONG
  55 #define int64_t INT64
  56
  57 #define uint8_t UINT8
  58 #define uint16_t UINT16
  59 #define uint32_t UINT32
  60 #define uint64_t UINT64
  61
  62 #define char16_t PRUnichar
  63
  64 typedef uint64_t DOMTimeStamp;
  65 typedef uint32_t nsLoadFlags;
  66 typedef int64_t PRTime;
  67
  68 /* Similar trick to stdint.h types for C++ bool type */
  69 typedef unsigned char cpp_bool;
  70 #define bool cpp_bool
  71
  72 typedef struct {
  73     void *v;
  74     void *d1;
  75     uint32_t d2;
  76     void *d3;
  77 } nsCStringContainer;
  78
  79 typedef struct {
  80     void *v;
  81     void *d1;
  82     uint32_t d2;
  83     void *d3;
  84 } nsStringContainer;
  85
  86 typedef nsCStringContainer nsACString;
  87 typedef nsStringContainer nsAString;
  88
  89 interface nsIWebBrowserChrome;
  90 interface nsILoadGroup;
  91 interface nsIDOMNode;
  92 interface nsIDOMAttr;
  93 interface nsIDOMDocument;
  94 interface nsIDOMEvent;
  95 interface nsIEditor;
  96 interface nsISelectionController;
  97 interface nsITransactionManager;
  98 interface nsITransaction;
  99 interface nsIInlineSpellChecker;
 100 interface nsIOutputStream;
 101 interface nsIEditorObserver;
 102 interface nsIEditActionListener;
 103 interface nsIDocumentStateListener;
 104 interface nsIDOMCSSStyleSheet;
 105 interface nsIDOMDocumentView;
 106 interface nsIDOMWindow;
 107 interface nsIDOMElement;
 108 interface nsIDOMRange;
 109 interface nsIDOMEventTarget;
 110 interface nsISelection;
 111 interface nsIDOMHTMLSelectElement;
 112 interface nsIFile;
 113 interface nsIDocShell;
 114
 115 interface IMoniker;
 116
 117 [
 118     object,
 119     uuid(00000000-0000-0000-c000-000000000046),
 120     local
 121 ]
 122 interface nsISupports
 123 {
 124     nsresult QueryInterface(nsIIDRef riid, void **result);
 125     nsrefcnt AddRef();
 126     nsrefcnt Release();
 127 }
 128
 129 /* Currently we don't need a full declaration of these interfaces */
 130 typedef nsISupports nsISHistory;
 131 typedef nsISupports nsIWidget;
 132 typedef nsISupports nsIPrompt;
 133 typedef nsISupports nsIAuthPrompt;
 134 typedef nsISupports nsIDOMDocumentType;
 135 typedef nsISupports nsIDOMDOMImplementation;
 136 typedef nsISupports nsIDOMCDATASection;
 137 typedef nsISupports nsIDOMProcessingInstruction;
 138 typedef nsISupports nsIDOMEntityReference;
 139 typedef nsISupports nsIWebProgressListener;
 140 typedef nsISupports nsIDOMCSSValue;
 141 typedef nsISupports nsIPrintSession;
 142 typedef nsISupports nsIControllerCommandTable;
 143 typedef nsISupports nsIPrincipal;
 144 typedef nsISupports nsIAtom;
 145 typedef nsISupports nsISupportsArray;
 146 typedef nsISupports nsIContentFilter;
 147 typedef nsISupports nsIDOMMediaList;
 148 typedef nsISupports nsIDOMHTMLTableCaptionElement;
 149 typedef nsISupports nsIDOMHTMLTableSectionElement;
 150 typedef nsISupports nsIDOMClientRectList;
 151 typedef nsISupports nsINode;
 152 typedef nsISupports nsIStyleSheet;
 153 typedef nsISupports nsIStyleRule;
 154 typedef nsISupports nsIDOMUserDataHandler;
 155 typedef nsISupports nsISHEntry;
 156 typedef nsISupports nsIPresShell;
 157 typedef nsISupports nsIDocumentCharsetInfo;
 158 typedef nsISupports nsILayoutHistoryState;
 159 typedef nsISupports nsISecureBrowserUI;
 160 typedef nsISupports nsIDOMStorage;
 161 typedef nsISupports nsIDOMDOMTokenList;
 162 typedef nsISupports nsITransferable;
 163 typedef nsISupports nsIDOMFileList;
 164 typedef nsISupports nsIDOMFile;
 165 typedef nsISupports nsIControllers;
 166 typedef nsISupports nsIDOMValidityState;
 167 typedef nsISupports nsIPluginInstanceOwner;
 168 typedef nsISupports nsIPluginStreamListener;
 169 typedef nsISupports nsIContentSink;
 170 typedef nsISupports nsIParserFilter;
 171 typedef nsISupports nsIDTD;
 172 typedef nsISupports nsIObserver;
 173 typedef nsISupports nsIDOMNodeFilter;
 174 typedef nsISupports nsIDOMNodeIterator;
 175 typedef nsISupports nsIDOMTreeWalker;
 176 typedef nsISupports nsIHttpUpgradeListener;
 177 typedef nsISupports nsIDOMOfflineResourceList;
 178 typedef nsISupports nsIDOMNavigator;
 179 typedef nsISupports nsIDOMScreen;
 180 typedef nsISupports nsIAnimationFrameListener;
 181 typedef nsISupports nsIDOMStorageList;
 182 typedef nsISupports nsILocalFile;
 183 typedef nsISupports nsIDOMHTMLMenuElement;
 184 typedef nsISupports nsIDOMCaretPosition;
 185 typedef nsISupports nsIFrameRequestCallback;
 186 typedef nsISupports nsICycleCollectorListener;
 187 typedef nsISupports nsIDOMHTMLCanvasElement;
 188 typedef nsISupports nsIQueryContentEventResult;
 189 typedef nsISupports nsIDOMBlob;
 190 typedef nsISupports nsIPrivacyTransitionObserver;
 191 typedef nsISupports nsIDOMHTMLPropertiesCollection;
 192 typedef nsISupports mozIDOMApplication;
 193 typedef nsISupports nsILoadGroupConnectionInfo;
 194 typedef nsISupports nsIDOMCrypto;
 195 typedef nsISupports nsIDOMPkcs11;
 196 typedef nsISupports nsIDocShellTreeOwner;
 197 typedef nsISupports nsIArray;
 198 typedef nsISupports nsILoadInfo;
 199
 200 typedef void *JSContext;
 201 typedef void *JSObject;
 202 typedef uint64_t jsval;
 203
 204 [
 205     object,
 206     uuid(8bb35ed9-e332-462d-9155-4a002ab5c958),
 207     local
 208 ]
 209 interface nsIServiceManager : nsISupports
 210 {
 211     nsresult GetService(nsCIDRef aClass, nsIIDRef aIID, void **result);
 212     nsresult GetServiceByContractID(const char *aContractID, nsIIDRef aIID, void **result);
 213     nsresult IsServiceInstantiated(nsCIDRef aClass, nsIIDRef aIID, BOOL *_retval);
 214     nsresult IsServiceInstantiatedByContractID(const char *aContractID, nsIIDRef aIID, BOOL *_retval);
 215 }
 216
 217 [
 218     object,
 219     uuid(00000001-0000-0000-c000-000000000046),
 220     local
 221 ]
 222 interface nsIFactory : nsISupports
 223 {
 224     nsresult CreateInstance(nsISupports *aOuter, const nsIID *iid, void **result);
 225     nsresult LockFactory(bool lock);
 226 }
 227
 228 [
 229     object,
 230     uuid(9188bc85-f92e-11d2-81ef-0060083a0bcf),
 231     local
 232 ]
 233 interface nsIWeakReference : nsISupports
 234 {
 235     nsresult QueryReferent(const nsIID *riid, void **result);
 236 }
 237
 238 [
 239     object,
 240     uuid(9188bc86-f92e-11d2-81ef-0060083a0bcf),
 241     local
 242 ]
 243 interface nsISupportsWeakReference : nsISupports
 244 {
 245     nsresult GetWeakReference(nsIWeakReference **_retval);
 246 }
 247
 248 [
 249     object,
 250     uuid(033a1470-8b2a-11d3-af88-00a024ffc08c),
 251     local
 252 ]
 253 interface nsIInterfaceRequestor : nsISupports
 254 {
 255     nsresult GetInterface(const nsIID *riid, void **result);
 256 }
 257
 258 [
 259     object,
 260     uuid(4a2abaf0-6886-11d3-9382-00104ba0fd40),
 261     local
 262 ]
 263 interface nsIRunnable : nsISupports
 264 {
 265     nsresult Run();
 266 }
 267
 268 [
 269     object,
 270     uuid(d1899240-f9d2-11d2-bdd6-000064657374),
 271     local
 272 ]
 273 interface nsISimpleEnumerator : nsISupports
 274 {
 275     nsresult HasMoreElements(bool *_retval);
 276     nsresult GetNext(nsISupports **_retval);
 277 }
 278
 279 [
 280     object,
 281     uuid(81e4c2de-acac-4ad6-901a-b5fb1b851a0d),
 282     local
 283 ]
 284 interface nsIVariant : nsISupports
 285 {
 286     nsresult GetDataType(uint16_t *aDataType);
 287     nsresult GetAsInt8(uint8_t *_retval);
 288     nsresult GetAsInt16(int16_t *_retval);
 289     nsresult GetAsInt32(int32_t *_retval);
 290     nsresult GetAsInt64(int64_t *_retval);
 291     nsresult GetAsUint8(uint8_t *_retval);
 292     nsresult GetAsUint16(uint16_t *_retval);
 293     nsresult GetAsUint32(uint32_t *_retval);
 294     nsresult GetAsUint64(uint64_t *_retval);
 295     nsresult GetAsFloat(float *_retval);
 296     nsresult GetAsDouble(double *_retval);
 297     nsresult GetAsBool(bool *_retval);
 298     nsresult GetAsChar(char *_retval);
 299     nsresult GetAsWChar(PRUnichar *_retval);
 300     nsresult GetAsID(nsID *retval);
 301     nsresult GetAsAString(nsAString *_retval);
 302     nsresult GetAsDOMString(nsAString *_retval);
 303     nsresult GetAsACString(nsACString *_retval);
 304     nsresult GetAsAUTF8String(nsACString *_retval);
 305     nsresult GetAsString(char * *_retval);
 306     nsresult GetAsWString(PRUnichar * *_retval);
 307     nsresult GetAsISupports(nsISupports * *_retval);
 308     nsresult GetAsJSVal(long /*jsval*/ *_retval);
 309     nsresult GetAsInterface(nsIID **iid, void **iface);
 310     nsresult GetAsArray(uint16_t *type, nsIID *iid, uint32_t *count, void **ptr);
 311     nsresult GetAsStringWithSize(uint32_t *size, char **str);
 312     nsresult GetAsWStringWithSize(uint32_t *size, PRUnichar **str);
 313 }
 314
 315 [
 316     object,
 317     uuid(5586a590-8c82-11d5-90f3-0010a4e73d9a),
 318     local
 319 ]
 320 interface nsIWritableVariant : nsIVariant
 321 {
 322     nsresult GetWritable(bool *aWritable);
 323     nsresult SetWritable(bool aWritable);
 324     nsresult SetAsInt8(uint8_t aValue);
 325     nsresult SetAsInt16(int16_t aValue);
 326     nsresult SetAsInt32(int32_t aValue);
 327     nsresult SetAsInt64(int64_t aValue);
 328     nsresult SetAsUint8(uint8_t aValue);
 329     nsresult SetAsUint16(uint16_t aValue);
 330     nsresult SetAsUint32(uint32_t aValue);
 331     nsresult SetAsUint64(uint64_t aValue);
 332     nsresult SetAsFloat(float aValue);
 333     nsresult SetAsDouble(double aValue);
 334     nsresult SetAsBool(bool aValue);
 335     nsresult SetAsChar(char aValue);
 336     nsresult SetAsWChar(PRUnichar aValue);
 337     nsresult SetAsID(const nsID *aValue);
 338     nsresult SetAsAString(const nsAString *aValue);
 339     nsresult SetAsDOMString(const nsAString *aValue);
 340     nsresult SetAsACString(const nsACString *aValue);
 341     nsresult SetAsAUTF8String(const nsACString *aValue);
 342     nsresult SetAsString(const char * aValue);
 343     nsresult SetAsWString(const PRUnichar * aValue);
 344     nsresult SetAsISupports(nsISupports *aValue);
 345     nsresult SetAsInterface(const nsIID *iid, void *iface);
 346     nsresult SetAsArray(uint16_t type, const nsIID *iid, uint32_t count, void *ptr);
 347     nsresult SetAsStringWithSize(uint32_t size, const char *str);
 348     nsresult SetAsWStringWithSize(uint32_t size, const PRUnichar *str);
 349     nsresult SetAsVoid();
 350     nsresult SetAsEmpty();
 351     nsresult SetAsEmptyArray();
 352     nsresult SetFromVariant(nsIVariant *aValue);
 353 }
 354
 355 [
 356     object,
 357     uuid(53cdbc97-c2d7-4e30-b2c3-45b2ee79db18),
 358     local
 359 ]
 360 interface nsIInputStream : nsISupports
 361 {
 362     nsresult Close();
 363     nsresult Available(uint64_t *_retval);
 364     nsresult Read(char *aBuf, uint32_t aCount, uint32_t *_retval);
 365     nsresult ReadSegments(nsresult (*aWriter)(nsIInputStream *aInStream,
 366             void *aClosure, const char *aFromSegment, uint32_t aToOffset,
 367             uint32_t aCount, uint32_t *aWriteCount),
 368             void *aClosure, uint32_t aCount, uint32_t *_retval);
 369     nsresult IsNonBlocking(bool *_retval);
 370 }
 371
 372 [
 373     object,
 374     uuid(8429d350-1040-4661-8b71-f2a6ba455980),
 375     local
 376 ]
 377 interface nsISeekableStream : nsISupports
 378 {
 379     enum {
 380         NS_SEEK_SET = 0,
 381         NS_SEEK_CUR = 1,
 382         NS_SEEK_END = 2
 383     };
 384
 385     nsresult Seek(int32_t whence, int64_t offset);
 386     nsresult Tell(int64_t *_retval);
 387     nsresult SetEOF();
 388 }
 389
 390 [
 391     object,
 392     uuid(395fe045-7d18-4adb-a3fd-af98c8a1af11),
 393     local
 394 ]
 395 interface nsIURI : nsISupports
 396 {
 397     nsresult GetSpec(nsACString *aSpec);
 398     nsresult SetSpec(const nsACString *aSpec);
 399     nsresult GetPrePath(nsACString *aPrePath);
 400     nsresult GetScheme(nsACString *aScheme);
 401     nsresult SetScheme(const nsACString *aScheme);
 402     nsresult GetUserPass(nsACString *aUserPass);
 403     nsresult SetUserPass(const nsACString *aUserPass);
 404     nsresult GetUsername(nsACString *aUsername);
 405     nsresult SetUsername(const nsACString *aUsername);
 406     nsresult GetPassword(nsACString *aPassword);
 407     nsresult SetPassword(const nsACString *aPassword);
 408     nsresult GetHostPort(nsACString *aHostPort);
 409     nsresult SetHostPort(const nsACString *aHostPort);
 410     nsresult GetHost(nsACString *aHost);
 411     nsresult SetHost(const nsACString *aHost);
 412     nsresult GetPort(int32_t *aPort);
 413     nsresult SetPort(int32_t aPort);
 414     nsresult GetPath(nsACString *aPath);
 415     nsresult SetPath(const nsACString *aPath);
 416     nsresult Equals(nsIURI *other, bool *_retval);
 417     nsresult SchemeIs(const char *scheme, bool *_retval);
 418     nsresult Clone(nsIURI **_retval);
 419     nsresult Resolve(const nsACString *relativePath, nsACString *_retval);
 420     nsresult GetAsciiSpec(nsACString *aAsciiSpec);
 421     nsresult GetAsciiHost(nsACString *aAsciiHost);
 422     nsresult GetOriginCharset(nsACString *aOriginCharset);
 423     nsresult GetRef(nsACString *aRef);
 424     nsresult SetRef(const nsACString *aRef);
 425     nsresult EqualsExceptRef(nsIURI *other, bool *_retval);
 426     nsresult CloneIgnoringRef(nsIURI **_retval);
 427     nsresult GetSpecIgnoringRef(nsACString *aSpecIgnoringRef);
 428     nsresult GetHasRef(bool *aHasRef);
 429 }
 430
 431 [
 432     object,
 433     uuid(1419aa16-f134-4154-9886-00c7c5147a13),
 434     local
 435 ]
 436 interface nsIURL : nsIURI
 437 {
 438     nsresult GetFilePath(nsACString *aFilePath);
 439     nsresult SetFilePath(const nsACString *aFilePath);
 440     nsresult GetQuery(nsACString *aQuery);
 441     nsresult SetQuery(const nsACString *aQuery);
 442     nsresult GetDirectory(nsACString *aDirectory);
 443     nsresult SetDirectory(const nsACString *aDirectory);
 444     nsresult GetFileName(nsACString *aFileName);
 445     nsresult SetFileName(const nsACString *aFileName);
 446     nsresult GetFileBaseName(nsACString *aFileBaseName);
 447     nsresult SetFileBaseName(const nsACString *aFileBaseName);
 448     nsresult GetFileExtension(nsACString *aFileExtension);
 449     nsresult SetFileExtension(const nsACString *aFileExtension);
 450     nsresult GetCommonBaseSpec(nsIURI *aURIToCompare, nsACString *_retval);
 451     nsresult GetRelativeSpec(nsIURI *aURIToCompare, nsACString *_retval);
 452 }
 453
 454 [
 455     object,
 456     uuid(7750029c-1b0a-414e-8359-a77f24a2a0a6),
 457     local
 458 ]
 459 interface nsIFileURL : nsIURL
 460 {
 461     nsresult GetFile(nsIFile **aFile);
 462     nsresult SetFile(nsIFile *aFile);
 463 }
 464
 465 [
 466     object,
 467     uuid(321578d0-03c1-4d95-8821-021ac612d18d),
 468     local
 469 ]
 470 interface nsIMutable : nsISupports
 471 {
 472     nsresult GetMutable(bool *aMutable);
 473     nsresult SetMutable(bool aMutable);
 474 }
 475
 476 [
 477     object,
 478     uuid(babd6cca-ebe7-4329-967c-d6b9e33caa81),
 479     local
 480 ]
 481 interface nsIStandardURL : nsIMutable
 482 {
 483     nsresult Init(uint32_t aUrlType, int32_t aDefaultPort, const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI);
 484 }
 485
 486 [
 487     object,
 488     uuid(ef6bfbd2-fd46-48d8-96b7-9f8f0fd387fe),
 489     local
 490 ]
 491 interface nsIRequest : nsISupports
 492 {
 493     nsresult GetName(nsACString *aName);
 494     nsresult IsPending(bool *_retval);
 495     nsresult GetStatus(nsresult *aStatus);
 496     nsresult Cancel(nsresult aStatus);
 497     nsresult Suspend();
 498     nsresult Resume();
 499     nsresult GetLoadGroup(nsILoadGroup **aLoadGroup);
 500     nsresult SetLoadGroup(nsILoadGroup *aLoadGroup);
 501     nsresult GetLoadFlags(nsLoadFlags *aLoadFlags);
 502     nsresult SetLoadFlags(nsLoadFlags aLoadFlags);
 503 }
 504
 505 [
 506     object,
 507     uuid(fd91e2e0-1481-11d3-9333-00104ba0fd40),
 508     local
 509 ]
 510 interface nsIRequestObserver : nsISupports
 511 {
 512     nsresult OnStartRequest(nsIRequest *aRequest, nsISupports *aContext);
 513     nsresult OnStopRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatusCode);
 514 }
 515
 516 [
 517     object,
 518     uuid(3b4c8a77-76ba-4610-b316-678c73a3b88c),
 519     local
 520 ]
 521 interface nsIStreamListener : nsIRequestObserver
 522 {
 523     nsresult OnDataAvailable(nsIRequest *aRequest, nsISupports *aContext,
 524                              nsIInputStream *aInputStream, uint64_t aOffset, uint32_t aCount);
 525 }
 526
 527 [
 528     object,
 529     uuid(afb57ac2-bce5-4ee3-bb34-385089a9ba5c),
 530     local
 531 ]
 532 interface nsILoadGroup : nsIRequest
 533 {
 534     nsresult GetGroupObserver(nsIRequestObserver **aGroupObserver);
 535     nsresult SetGroupObserver(nsIRequestObserver *aGroupObserver);
 536     nsresult GetDefaultLoadRequest(nsIRequest **aDefaultLoadRequest);
 537     nsresult SetDefaultLoadRequest(nsIRequest *aDefaultLoadRequest);
 538     nsresult AddRequest(nsIRequest *aRequest, nsISupports *aContext);
 539     nsresult RemoveRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatus);
 540     nsresult GetRequests(nsISimpleEnumerator **aRequests);
 541     nsresult GetActiveCount(uint32_t *aActiveCount);
 542     nsresult GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
 543     nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
 544     nsresult GetConnectionInfo(nsILoadGroupConnectionInfo **aConnectionInfo);
 545     nsresult GetDefaultLoadFlags(nsLoadFlags *aDefaultLoadFlags);
 546     nsresult SetDefaultLoadFlags(nsLoadFlags aDefaultLoadFlags);
 547 }
 548
 549 [
 550     object,
 551     uuid(1bc48693-c45d-45f4-8ab1-46e323037fe1),
 552     local
 553 ]
 554 interface nsIChannel : nsIRequest
 555 {
 556     const UINT LOAD_DOCUMENT_URI            = 1 << 16;
 557     const UINT LOAD_RETARGETED_DOCUMENT_URI = 1 << 17;
 558     const UINT LOAD_REPLACE                 = 1 << 18;
 559     const UINT LOAD_INITIAL_DOCUMENT_URI    = 1 << 19;
 560     const UINT LOAD_TARGETED                = 1 << 20;
 561     const UINT LOAD_CALL_CONTENT_SNIFFERS   = 1 << 21;
 562     const UINT LOAD_CLASSIFY_URI            = 1 << 22;
 563     const UINT LOAD_MEDIA_SNIFFER_OVERRIDES_CONTENT_TYPE = 1 << 23;
 564     const UINT LOAD_EXPLICIT_CREDENTIALS    = 1 << 24;
 565
 566     nsresult GetOriginalURI(nsIURI **aOriginalURI);
 567     nsresult SetOriginalURI(nsIURI *aOriginalURI);
 568     nsresult GetURI(nsIURI **aURI);
 569     nsresult GetOwner(nsISupports **aOwner);
 570     nsresult SetOwner(nsISupports *aOwner);
 571     nsresult GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
 572     nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
 573     nsresult GetSecurityInfo(nsISupports **aSecurityInfo);
 574     nsresult GetContentType(nsACString *aContentType);
 575     nsresult SetContentType(const nsACString *aContentType);
 576     nsresult GetContentCharset(nsACString *aContentCharset);
 577     nsresult SetContentCharset(const nsACString *aContentCharset);
 578     nsresult GetContentLength(int64_t *aContentLength);
 579     nsresult SetContentLength(int64_t aContentLength);
 580     nsresult Open(nsIInputStream **_retval);
 581     nsresult AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext);
 582     nsresult GetContentDisposition(uint32_t *aContentDisposition);
 583     nsresult SetContentDisposition(uint32_t aContentDisposition);
 584     nsresult GetContentDispositionFilename(nsAString *aContentDispositionFilename);
 585     nsresult SetContentDispositionFilename(const nsAString *aContentDispositionFilename);
 586     nsresult GetContentDispositionHeader(nsACString *aContentDispositionHeader);
 587     nsresult GetLoadInfo(nsILoadInfo **aLoadInfo);
 588     nsresult SetLoadInfo(nsILoadInfo *aLoadInfo);
 589 }
 590
 591 [
 592     object,
 593     uuid(35412859-b9d9-423c-8866-2d4559fdd2be),
 594     local
 595 ]
 596 interface nsIHttpHeaderVisitor : nsISupports
 597 {
 598     nsresult VisitHeader(const nsACString *aHeader, const nsACString *aValue);
 599 }
 600
 601 [
 602     object,
 603     uuid(82083578-fb78-4f9a-953c-cecbae500697),
 604     local
 605 ]
 606 interface nsIHttpChannel : nsIChannel
 607 {
 608     nsresult GetRequestMethod(nsACString *aRequestMethod);
 609     nsresult SetRequestMethod(const nsACString *aRequestMethod);
 610     nsresult GetReferrer(nsIURI **aReferrer);
 611     nsresult SetReferrer(nsIURI *aReferrer);
 612     nsresult GetReferrerPolicy(uint32_t *aReferrerPolicy);
 613     nsresult SetReferrerWithPolicy(nsIURI *referrer, uint32_t referrerPolicy);
 614     nsresult GetRequestHeader(const nsACString *aHeader, nsACString *_retval);
 615     nsresult SetRequestHeader(const nsACString *aHeader, const nsACString *aValue, bool aMerge);
 616     nsresult VisitRequestHeaders(nsIHttpHeaderVisitor *aVisitor);
 617     nsresult GetAllowPipelining(bool *aAllowPipelining);
 618     nsresult SetAllowPipelining(bool aAllowPipelining);
 619     nsresult GetAllowSTS(bool *aAllowSTS);
 620     nsresult SetAllowSTS(bool aAllowSTS);
 621     nsresult GetRedirectionLimit(uint32_t *aRedirectionLimit);
 622     nsresult SetRedirectionLimit(uint32_t aRedirectionLimit);
 623     nsresult GetResponseStatus(uint32_t *aResponseStatus);
 624     nsresult GetResponseStatusText(nsACString *aResponseStatusText);
 625     nsresult GetRequestSucceeded(bool *aRequestSucceeded);
 626     nsresult GetResponseHeader(const nsACString *header, nsACString *_retval);
 627     nsresult SetResponseHeader(const nsACString *header, const nsACString *value, bool merge);
 628     nsresult VisitResponseHeaders(nsIHttpHeaderVisitor *aVisitor);
 629     nsresult IsNoStoreResponse(bool *_retval);
 630     nsresult IsNoCacheResponse(bool *_retval);
 631     nsresult RedirectTo(nsIURI *aNewURI);
 632 }
 633
 634 [
 635     object,
 636     uuid(62a8d6e2-3418-4c6f-9d90-88573838f6dd),
 637     local
 638 ]
 639 interface nsIHttpChannelInternal : nsISupports
 640 {
 641     nsresult GetDocumentURI(nsIURI **aDocumentURI);
 642     nsresult SetDocumentURI(nsIURI *aDocumentURI);
 643     nsresult GetRequestVersion(uint32_t *major, uint32_t *minor);
 644     nsresult GetResponseVersion(uint32_t *major, uint32_t *minor);
 645     nsresult TakeAllSecurityMessages(void /*securityMessagesArray*/ *aMessages);
 646     nsresult SetCookie(const char *aCookieHeader);
 647     nsresult SetupFallbackChannel(const char *aFallbackKey);
 648     nsresult GetForceAllowThirdPartyCookie(bool *aForceAllowThirdPartyCookie);
 649     nsresult SetForceAllowThirdPartyCookie(bool aForceAllowThirdPartyCookie);
 650     nsresult GetCanceled(bool *aCanceled);
 651     nsresult GetChannelIsForDownload(bool *aChannelIsForDownload);
 652     nsresult SetChannelIsForDownload(bool aChannelIsForDownload);
 653     nsresult GetLocalAddress(nsACString *aLocalAddress);
 654     nsresult GetLocalPort(int32_t *aLocalPort);
 655     nsresult GetRemoteAddress(nsACString *aRemoteAddress);
 656     nsresult GetRemotePort(int32_t *aRemotePort);
 657     nsresult SetCacheKeysRedirectChain(void /*nsTArray<nsCString>*/ *cacheKeys);
 658     nsresult HTTPUpgrade(const nsACString *aProtocolName, nsIHttpUpgradeListener *aListener);
 659     nsresult GetAllowSpdy(bool *aAllowSpdy);
 660     nsresult SetAllowSpdy(bool aAllowSpdy);
 661     nsresult GetLoadAsBlocking(bool *aLoadAsBlocking);
 662     nsresult SetLoadAsBlocking(bool aLoadAsBlocking);
 663     nsresult GetLoadUnblocked(bool *aLoadUnblocked);
 664     nsresult SetLoadUnblocked(bool aLoadUnblocked);
 665     nsresult GetResponseTimeoutEnabled(bool *aResponseTimeoutEnabled);
 666     nsresult SetResponseTimeoutEnabled(bool aResponseTimeoutEnabled);
 667     nsresult GetApiRedirectToURI(nsIURI **aApiRedirectToURI);
 668     nsresult AddRedirect(nsIPrincipal *aPrincipal);
 669     nsresult GetLastModifiedTime(PRTime *aLastModifiedTime);
 670     nsresult ForceNoIntercept();
 671     nsresult GetTopWindowURI(nsIURI **aTopWindowURI);
 672 }
 673
 674 [
 675     object,
 676     uuid(5cfe15bd-5adb-4a7f-9e55-4f5a67d15794),
 677     local
 678 ]
 679 interface nsIUploadChannel : nsISupports
 680 {
 681     nsresult SetUploadStream(nsIInputStream *aStream, const nsACString *aContentType,
 682                              int64_t aContentLength);
 683     nsresult GetUploadStream(nsIInputStream **aUploadStream);
 684 }
 685
 686 [
 687     object,
 688     uuid(8d171460-a716-41f1-92be-8c659db39b45),
 689     local
 690 ]
 691 interface nsIAsyncVerifyRedirectCallback : nsISupports
 692 {
 693     nsresult OnRedirectVerifyCallback(nsresult result);
 694 }
 695
 696 [
 697     object,
 698     uuid(a430d870-df77-4502-9570-d46a8de33154),
 699     local
 700 ]
 701 interface nsIChannelEventSink : nsISupports
 702 {
 703     const UINT REDIRECT_TEMPORARY = 1;
 704     const UINT REDIRECT_PERMANENT = 2;
 705     const UINT REDIRECT_INTERNAL  = 4;
 706
 707     nsresult AsyncOnChannelRedirect(nsIChannel *oldChannel, nsIChannel *newChannel, uint32_t flags,
 708                                     nsIAsyncVerifyRedirectCallback *callback);
 709 }
 710
 711 [
 712     object,
 713     uuid(79de76e5-994e-4f6b-81aa-42d9adb6e67e),
 714     local
 715 ]
 716 interface nsIDOMLocation : nsISupports
 717 {
 718     nsresult GetHash(nsAString *aHash);
 719     nsresult SetHash(const nsAString *aHash);
 720     nsresult GetHost(nsAString *aHost);
 721     nsresult SetHost(const nsAString *aHost);
 722     nsresult GetHostname(nsAString *aHostname);
 723     nsresult SetHostname(const nsAString *aHostname);
 724     nsresult GetHref(nsAString *aHref);
 725     nsresult SetHref(const nsAString *aHref);
 726     nsresult GetPathname(nsAString *aPathname);
 727     nsresult SetPathname(const nsAString *aPathname);
 728     nsresult GetPort(nsAString *aPort);
 729     nsresult SetPort(const nsAString *aPort);
 730     nsresult GetProtocol(nsAString *aProtocol);
 731     nsresult SetProtocol(const nsAString *aProtocol);
 732     nsresult GetSearch(nsAString *aSearch);
 733     nsresult SetSearch(const nsAString *aSearch);
 734     nsresult GetOrigin(nsAString *aOrigin);
 735     nsresult Reload(bool forceget);
 736     nsresult Replace(const nsAString *url);
 737     nsresult Assign(const nsAString *url);
 738     nsresult ToString(nsAString *_retval);
 739     nsresult ValueOf(nsIDOMLocation **_retval);
 740 }
 741
 742 [
 743     object,
 744     uuid(4d6b3bad-f53c-4585-82f6-62982e27ede8),
 745     local
 746 ]
 747 interface nsIDOMCSSRule : nsISupports
 748 {
 749     nsresult GetType(uint16_t *aType);
 750     nsresult GetCssText(nsAString *aCssText);
 751     nsresult SetCssText(const nsAString *aCssText);
 752     nsresult GetParentStyleSheet(nsIDOMCSSStyleSheet **aParentStyleSheet);
 753     nsresult GetParentRule(nsIDOMCSSRule **aParentRule);
 754     int /* thiscall mozilla::css::Rule */ GetCSSRule();
 755 }
 756
 757 [
 758     object,
 759     uuid(a6cf90be-15b3-11d2-932e-00805f8add32),
 760     local
 761 ]
 762 interface nsIDOMCSSStyleDeclaration : nsISupports
 763 {
 764     nsresult GetCssText(nsAString *aCssText);
 765     nsresult SetCssText(const nsAString *aCssText);
 766     nsresult GetPropertyValue(const nsAString *propertyName, nsAString *_retval);
 767     nsresult GetPropertyCSSValue(const nsAString *propertyName, nsIDOMCSSValue **_retval);
 768     nsresult RemoveProperty(const nsAString *propertyName, nsAString *_retval);
 769     nsresult GetPropertyPriority(const nsAString *propertyName, nsAString *_retval);
 770     nsresult SetProperty(const nsAString *propertyName, const nsAString *value,
 771                          const nsAString *priority);
 772     nsresult GetLength(uint32_t *aLength);
 773     nsresult Item(uint32_t index, nsAString *_retval);
 774     nsresult GetParentRule(nsIDOMCSSRule **aParentRule);
 775 }
 776
 777 [
 778     object,
 779     uuid(a6cf90c0-15b3-11d2-932e-00805f8add32),
 780     local
 781 ]
 782 interface nsIDOMCSSRuleList : nsISupports
 783 {
 784     nsresult GetLength(uint32_t *aLength);
 785     nsresult Item(uint32_t index, nsIDOMCSSRule **_retval);
 786 }
 787
 788 [
 789     object,
 790     uuid(a6cf9080-15b3-11d2-932e-00805f8add32),
 791     local
 792 ]
 793 interface nsIDOMStyleSheet : nsISupports
 794 {
 795     nsresult GetType(nsAString *aType);
 796     nsresult GetDisabled(bool *aDisabled);
 797     nsresult SetDisabled(bool aDisabled);
 798     nsresult GetOwnerNode(nsIDOMNode **aOwnerNode);
 799     nsresult GetParentStyleSheet(nsIDOMStyleSheet **aParentStyleSheet);
 800     nsresult GetHref(nsAString *aHref);
 801     nsresult GetTitle(nsAString *aTitle);
 802     nsresult GetMedia(nsIDOMMediaList **aMedia);
 803 }
 804
 805 [
 806     object,
 807     uuid(a6cf90c2-15b3-11d2-932e-00805f8add32),
 808     local
 809 ]
 810 interface nsIDOMCSSStyleSheet : nsIDOMStyleSheet
 811 {
 812     nsresult GetOwnerRule(nsIDOMCSSRule **aOwnerRule);
 813     nsresult GetCssRules(nsIDOMCSSRuleList **aCssRules);
 814     nsresult InsertRule(const nsAString *rule, uint32_t index, uint32_t *_retval);
 815     nsresult DeleteRule(uint32_t index);
 816 }
 817
 818 [
 819     object,
 820     uuid(0e424250-ac2a-4fe2-bccd-a45824af090e),
 821     local
 822 ]
 823 interface nsIDOMStyleSheetList : nsISupports
 824 {
 825     nsresult GetLength(uint32_t *aLength);
 826     nsresult Item(uint32_t index, nsIDOMStyleSheet **_retval);
 827 }
 828
 829 [
 830     object,
 831     uuid(450cf0ba-de90-4f86-85bf-e10cc8b8713f),
 832     local
 833 ]
 834 interface nsIDOMNodeList : nsISupports
 835 {
 836     nsresult Item(uint32_t index, nsIDOMNode **_retval);
 837     nsresult GetLength(uint32_t *aLength);
 838 }
 839
 840 [
 841     object,
 842     uuid(bb07f567-5b37-4172-92aa-7d00ceed4809),
 843     local
 844 ]
 845 interface nsIDOMHTMLCollection : nsISupports
 846 {
 847     nsresult GetLength(uint32_t *aLength);
 848     nsresult Item(uint32_t index, nsIDOMNode **_retval);
 849     nsresult NamedItem(const nsAString *name, nsIDOMNode **_retval);
 850 }
 851
 852 [
 853     object,
 854     uuid(cb5564cd-26ec-418f-a6d6-1d57cd2c971c),
 855     local
 856 ]
 857 interface nsIDOMMozNamedAttrMap : nsISupports
 858 {
 859     nsresult GetNamedItem(const nsAString *name, nsIDOMAttr **_retval);
 860     nsresult SetNamedItem(nsIDOMAttr *arg, nsIDOMAttr **_retval);
 861     nsresult RemoveNamedItem(const nsAString *name, nsIDOMAttr **_retval);
 862     nsresult Item(uint32_t index, nsIDOMAttr **_retval);
 863     nsresult GetLength(uint32_t *aLength);
 864     nsresult GetNamedItemNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMAttr **_retval);
 865     nsresult SetNamedItemNS(nsIDOMAttr *arg, nsIDOMAttr **_retval);
 866     nsresult RemoveNamedItemNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMAttr **_retval);
 867 }
 868
 869 [
 870     object,
 871     uuid(cc35b412-009b-46a3-9be0-76448f12548d),
 872     local
 873 ]
 874 interface nsIDOMNode : nsISupports
 875 {
 876     enum NSNODETYPE {
 877         ELEMENT_NODE = 1,
 878         ATTRIBUTE_NODE = 2,
 879         TEXT_NODE = 3,
 880         CDATA_SELECTION_NODE = 4,
 881         ENTITY_REFERENCE_NODE = 5,
 882         ENTITY_NODE = 6,
 883         PROCESSING_INSTRUCTION_NODE = 7,
 884         COMMENT_NODE = 8,
 885         DOCUMENT_NODE = 9,
 886         DOCUMENT_TYPE_NODE = 10,
 887         DOCUMENT_FRAGMENT_NODE = 11,
 888         NOTATION_NODE = 12
 889     };
 890
 891     enum {
 892         DOCUMENT_POSITION_DISCONNECTED = 1,
 893         DOCUMENT_POSITION_PRECEDING = 2,
 894         DOCUMENT_POSITION_FOLLOWING = 4,
 895         DOCUMENT_POSITION_CONTAINS = 8,
 896         DOCUMENT_POSITION_CONTAINED_BY = 16,
 897         DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32
 898     };
 899
 900     nsresult GetNodeName(nsAString *aNodeName);
 901     nsresult GetNodeValue(nsAString *aNodeValue);
 902     nsresult SetNodeValue(const nsAString *aNodeValue);
 903     nsresult GetNodeType(uint16_t *aNodeType);
 904     nsresult GetParentNode(nsIDOMNode **aParentNode);
 905     nsresult GetParentElement(nsIDOMElement **aParentElement);
 906     nsresult GetChildNodes(nsIDOMNodeList **aChildNodes);
 907     nsresult GetFirstChild(nsIDOMNode **aFirstChild);
 908     nsresult GetLastChild(nsIDOMNode **aLastChild);
 909     nsresult GetPreviousSibling(nsIDOMNode **aPreviousSibling);
 910     nsresult GetNextSibling(nsIDOMNode **aNextSibling);
 911     nsresult GetOwnerDocument(nsIDOMDocument **aOwnerDocument);
 912     nsresult InsertBefore(nsIDOMNode *newChild, nsIDOMNode *refChild, nsIDOMNode **_retval);
 913     nsresult ReplaceChild(nsIDOMNode *newChild, nsIDOMNode *oldChild, nsIDOMNode **_retval);
 914     nsresult RemoveChild(nsIDOMNode *oldChild, nsIDOMNode **_retval);
 915     nsresult AppendChild(nsIDOMNode *newChild, nsIDOMNode **_retval);
 916     nsresult HasChildNodes(bool *_retval);
 917     nsresult CloneNode(bool deep, uint8_t _argc, nsIDOMNode **_retval);
 918     nsresult Normalize();
 919     nsresult GetNamespaceURI(nsAString *aNamespaceURI);
 920     nsresult GetPrefix(nsAString *aPrefix);
 921     nsresult GetLocalName(nsAString *aLocalName);
 922     nsresult UnusedPlaceholder(bool *_retval);
 923     nsresult GetDOMBaseURI(nsAString *aBaseURI);
 924     nsresult CompareDocumentPosition(nsIDOMNode *other, uint16_t *_retval);
 925     nsresult GetTextContent(nsAString *aTextContent);
 926     nsresult SetTextContent(const nsAString *aTextContent);
 927     nsresult LookupPrefix(const nsAString *namespaceURI, nsAString *_retval);
 928     nsresult IsDefaultNamespace(const nsAString *namespaceURI, bool *_retval);
 929     nsresult LookupNamespaceURI(const nsAString *prefix, nsAString *_retval);
 930     nsresult IsEqualNode(nsIDOMNode *arg, bool *_retval);
 931     nsresult SetUserData(const nsAString *key, nsIVariant *data, nsIVariant **_retval);
 932     nsresult GetUserData(const nsAString *key, nsIVariant **_retval);
 933     nsresult Contains(nsIDOMNode *aOther, bool *_retval);
 934
 935     nsresult GetMshtmlNode(nsISupports **aMshtmlNode);
 936     nsresult SetMshtmlNode(nsISupports *aMshtmlNode);
 937 }
 938
 939 [
 940     object,
 941     uuid(7db491e8-a3a3-4432-ad67-e6c33e24ac6d),
 942     local
 943 ]
 944 interface nsIDOMAttr : nsIDOMNode
 945 {
 946     nsresult GetName(nsAString *aName);
 947     nsresult GetSpecified(bool *aSpecified);
 948     nsresult GetValue(nsAString *aValue);
 949     nsresult SetValue(const nsAString *aValue);
 950     nsresult GetOwnerElement(nsIDOMElement **aOwnerElement);
 951     nsresult GetIsId(bool *aIsId);
 952 }
 953
 954 [
 955     object,
 956     uuid(b2f824c4-d9d3-499b-8d3b-45c8245497c6),
 957     local
 958 ]
 959 interface nsIDOMClientRect : nsISupports
 960 {
 961     nsresult GetLeft(float *aLeft);
 962     nsresult GetTop(float *aTop);
 963     nsresult GetRight(float *aRight);
 964     nsresult GetBottom(float *aBottom);
 965     nsresult GetWidth(float *aWidth);
 966     nsresult GetHeight(float *aHeight);
 967 }
 968
 969 [
 970     object,
 971     uuid(6289999b-1008-4269-b42a-413ec5a9d3f4),
 972     local
 973 ]
 974 interface nsIDOMElement : nsIDOMNode
 975 {
 976     nsresult GetTagName(nsAString *aTagName);
 977     nsresult GetId(nsAString *aId);
 978     nsresult SetId(const nsAString *aId);
 979     nsresult GetClassName(nsAString *aClassName);
 980     nsresult SetClassName(const nsAString *aClassName) ;
 981     nsresult GetClassList(nsISupports **aClassList);
 982     nsresult GetAttributes(nsIDOMMozNamedAttrMap **aAttributes);
 983     nsresult GetAttribute(const nsAString *name, nsAString *_retval);
 984     nsresult GetAttributeNS(const nsAString *namespaceURI, const nsAString *localName, nsAString *_retval);
 985     nsresult SetAttribute(const nsAString *name, const nsAString *value);
 986     nsresult SetAttributeNS(const nsAString *namespaceURI, const nsAString *qualifiedName, const nsAString *value);
 987     nsresult RemoveAttribute(const nsAString *name);
 988     nsresult RemoveAttributeNS(const nsAString *namespaceURI, const nsAString *localName);
 989     nsresult HasAttribute(const nsAString *name, bool *_retval);
 990     nsresult HasAttributeNS(const nsAString *namespaceURI, const nsAString *localName, bool *_retval);
 991     nsresult HasAttributes(bool *_retval);
 992     nsresult GetAttributeNode(const nsAString *name, nsIDOMAttr **_retval);
 993     nsresult SetAttributeNode(nsIDOMAttr *newAttr, nsIDOMAttr **_retval);
 994     nsresult RemoveAttributeNode(nsIDOMAttr *oldAttr, nsIDOMAttr **_retval);
 995     nsresult GetAttributeNodeNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMAttr **_retval);
 996     nsresult SetAttributeNodeNS(nsIDOMAttr *newAttr, nsIDOMAttr **_retval);
 997     nsresult GetElementsByTagName(const nsAString *name, nsIDOMHTMLCollection **_retval);
 998     nsresult GetElementsByTagNameNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMHTMLCollection **_retval);
 999     nsresult GetElementsByClassName(const nsAString *classes, nsIDOMHTMLCollection **_retval);
1000     nsresult GetChildElements(nsIDOMNodeList **aChildren);
1001     nsresult GetFirstElementChild(nsIDOMElement **aFirstElementChild);
1002     nsresult GetLastElementChild(nsIDOMElement **aLastElementChild);
1003     nsresult GetPreviousElementSibling(nsIDOMElement **aPreviousElementSibling);
1004     nsresult GetNextElementSibling(nsIDOMElement **aNextElementSibling);
1005     nsresult GetChildElementCount(uint32_t *aChildElementCount);
1006     nsresult Remove();
1007     nsresult GetClientRects(nsIDOMClientRectList **_retval);
1008     nsresult GetBoundingClientRect(nsIDOMClientRect **_retval);
1009     nsresult GetScrollTop(int32_t *aScrollTop);
1010     nsresult SetScrollTop(int32_t aScrollTop);
1011     nsresult GetScrollLeft(int32_t *aScrollLeft);
1012     nsresult SetScrollLeft(int32_t aScrollLeft);
1013     nsresult GetScrollWidth(int32_t *aScrollWidth);
1014     nsresult GetScrollHeight(int32_t *aScrollHeight);
1015     nsresult GetClientTop(int32_t *aClientTop);
1016     nsresult GetClientLeft(int32_t *aClientLeft);
1017     nsresult GetClientWidth(int32_t *aClientWidth);
1018     nsresult GetClientHeight(int32_t *aClientHeight);
1019     nsresult GetScrollLeftMax(int32_t *aScrollLeftMax);
1020     nsresult GetScrollTopMax(int32_t *aScrollTopMax);
1021     nsresult MozMatchesSelector(const nsAString *selector, bool *_retval);
1022     nsresult SetCapture(bool retargetToElement);
1023     nsresult ReleaseCapture();
1024     nsresult MozRequestFullScreen();
1025     nsresult MozRequestPointerLock();
1026     nsresult QuerySelector(const nsAString *selectors, nsIDOMElement **_retval);
1027     nsresult QuerySelectorAll(const nsAString *selectors, nsIDOMNodeList **_retval);
1028 }
1029
1030 [
1031     object,
1032     uuid(99715845-95fc-4a56-aa53-214b65c26e22),
1033     local
1034 ]
1035 interface nsIDOMElementCSSInlineStyle : nsISupports
1036 {
1037     nsresult GetStyle(nsIDOMCSSStyleDeclaration **aStyle);
1038 }
1039
1040 [
1041     object,
1042     uuid(b0c42392-d0e7-4f6a-beb5-a698ce648945),
1043     local
1044 ]
1045 interface nsIDOMHTMLElement : nsIDOMElement
1046 {
1047     nsresult GetTitle(nsAString *aTitle);
1048     nsresult SetTitle(const nsAString *aTitle);
1049     nsresult GetLang(nsAString *aLang);
1050     nsresult SetLang(const nsAString *aLang);
1051     nsresult GetDir(nsAString *aDir);
1052     nsresult SetDir(const nsAString *aDir);
1053     nsresult GetDataset(nsISupports **aDataset);
1054     nsresult GetItemScope(bool *aItemScope);
1055     nsresult SetItemScope(bool aItemScope);
1056     nsresult GetItemType(nsIVariant **aItemType);
1057     nsresult SetItemType(nsIVariant *aItemType);
1058     nsresult GetItemId(nsAString *aItemId);
1059     nsresult SetItemId(const nsAString *aItemId);
1060     nsresult GetProperties(nsISupports **aProperties);
1061     nsresult GetItemValue(nsIVariant **aItemValue);
1062     nsresult SetItemValue(nsIVariant *aItemValue);
1063     nsresult GetItemProp(nsIVariant **aItemProp);
1064     nsresult SetItemProp(nsIVariant *aItemProp);
1065     nsresult GetItemRef(nsIVariant **aItemRef);
1066     nsresult SetItemRef(nsIVariant *aItemRef);
1067     nsresult GetHidden(bool *aHidden);
1068     nsresult SetHidden(bool aHidden);
1069     nsresult Click();
1070     nsresult GetTabIndex(int32_t *aTabIndex);
1071     nsresult SetTabIndex(int32_t aTabIndex);
1072     nsresult Focus();
1073     nsresult Blur();
1074     nsresult GetAccessKey(nsAString *aAccessKey);
1075     nsresult SetAccessKey(const nsAString *aAccessKey);
1076     nsresult GetAccessKeyLabel(nsAString *aAccessKeyLabel);
1077     nsresult GetDraggable(bool *aDraggable);
1078     nsresult SetDraggable(bool aDraggable);
1079     nsresult GetContentEditable(nsAString *aContentEditable);
1080     nsresult SetContentEditable(const nsAString *aContentEditable);
1081     nsresult GetIsContentEditable(bool *aIsContentEditable);
1082     nsresult GetContextMenu(nsIDOMHTMLMenuElement **aContextMenu);
1083     nsresult GetSpellcheck(bool *aSpellcheck);
1084     nsresult SetSpellcheck(bool aSpellcheck);
1085     nsresult GetInnerHTML(nsAString *aInnerHTML);
1086     nsresult SetInnerHTML(const nsAString *aInnerHTML);
1087     nsresult GetOuterHTML(nsAString *aInnerHTML);
1088     nsresult SetOuterHTML(const nsAString *aInnerHTML);
1089     nsresult InsertAdjacentHTML(const nsAString *position, const nsAString *text);
1090     nsresult ScrollIntoView(bool top, uint8_t _argc);
1091     nsresult GetOffsetParent(nsIDOMElement * *aOffsetParent);
1092     nsresult GetOffsetTop(int32_t *aOffsetTop);
1093     nsresult GetOffsetLeft(int32_t *aOffsetLeft);
1094     nsresult GetOffsetWidth(int32_t *aOffsetWidth);
1095     nsresult GetOffsetHeight(int32_t *aOffsetHeight);
1096 }
1097
1098 [
1099     object,
1100     uuid(59b80014-00f5-412d-846f-725494122d42),
1101     local
1102 ]
1103 interface nsIDOMHTMLHeadElement : nsISupports
1104 {
1105 }
1106
1107 [
1108     object,
1109     uuid(4109a2d2-e7af-445d-bb72-c7c9b875f35e),
1110     local
1111 ]
1112 interface nsIDOMCharacterData : nsIDOMNode
1113 {
1114     nsresult GetData(nsAString *aData);
1115     nsresult SetData(const nsAString *aData);
1116     nsresult GetLength(uint32_t *aLength);
1117     nsresult SubstringData(uint32_t offset, uint32_t count, nsAString *_retval);
1118     nsresult AppendData(const nsAString *arg);
1119     nsresult InsertData(uint32_t offset, const nsAString *arg);
1120     nsresult DeleteData(uint32_t offset, uint32_t count);
1121     nsresult ReplaceData(uint32_t offset, uint32_t count, const nsAString *arg);
1122     nsresult Remove();
1123 }
1124
1125 [
1126     object,
1127     uuid(67273994-6aff-4091-9de9-b788a249f783),
1128     local
1129 ]
1130 interface nsIDOMText : nsIDOMCharacterData
1131 {
1132     nsresult SplitText(uint32_t offset, nsIDOMText **_retval);
1133     nsresult GetWholeText(nsAString *aWholeText);
1134 }
1135
1136 [
1137     object,
1138     uuid(e7866ff8-b7fc-494f-87c0-fb017d8a4d30),
1139     local
1140 ]
1141 interface nsIDOMComment : nsIDOMCharacterData
1142 {
1143 }
1144
1145 [
1146     object,
1147     uuid(48eb8d72-95bb-402e-a8fc-f2b187abcbdb),
1148     local
1149 ]
1150 interface nsIDOMDocumentFragment : nsIDOMNode
1151 {
1152     nsresult QuerySelector(const nsAString *selectors, nsIDOMElement **_retval);
1153     nsresult QuerySelectorAll(const nsAString *selectors, nsIDOMNodeList **_retval);
1154 }
1155
1156 [
1157     object,
1158     uuid(35dc5030-dc83-4291-88a2-0906c549788e),
1159     local
1160 ]
1161 interface nsIDOMDocument : nsIDOMNode
1162 {
1163     nsresult GetDoctype(nsIDOMDocumentType **aDoctype);
1164     nsresult GetImplementation(nsIDOMDOMImplementation **aImplementation);
1165     nsresult GetDocumentElement(nsIDOMElement **aDocumentElement);
1166     nsresult CreateElement(const nsAString *tagName, nsIDOMElement **_retval);
1167     nsresult CreateDocumentFragment(nsIDOMDocumentFragment **_retval);
1168     nsresult CreateTextNode(const nsAString *data, nsIDOMText **_retval);
1169     nsresult CreateComment(const nsAString *data, nsIDOMComment **_retval);
1170     nsresult CreateCDATASection(const nsAString *data, nsIDOMCDATASection **_retval);
1171     nsresult CreateProcessingInstruction(const nsAString *target, const nsAString *data, nsIDOMProcessingInstruction **_retval);
1172     nsresult CreateAttribute(const nsAString *name, nsIDOMAttr **_retval);
1173     nsresult GetElementsByTagName(const nsAString *tagname, nsIDOMNodeList **_retval);
1174     nsresult ImportNode(nsIDOMNode *importedNode, bool deep, uint8_t _argc, nsIDOMNode **_retval);
1175     nsresult CreateElementNS(const nsAString *namespaceURI, const nsAString *qualifiedName, nsIDOMElement **_retval);
1176     nsresult CreateAttributeNS(const nsAString *namespaceURI, const nsAString *qualifiedName, nsIDOMAttr **_retval);
1177     nsresult GetElementsByTagNameNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMNodeList **_retval);
1178     nsresult GetElementById(const nsAString *elementId, nsIDOMElement **_retval);
1179     nsresult GetInputEncoding(nsAString *aInputEncoding);
1180     nsresult GetDocumentURI(nsAString *aDocumentURI);
1181     nsresult GetURL(nsAString *aURL);
1182     nsresult AdoptNode(nsIDOMNode *source, nsIDOMNode **_retval);
1183     nsresult CreateRange(nsIDOMRange **_retval);
1184     nsresult CreateNodeIterator(nsIDOMNode *root, uint32_t whatToShow, nsIDOMNodeFilter *filter, uint8_t _argc,
1185             nsIDOMNodeIterator **_retval);
1186     nsresult CreateTreeWalker(nsIDOMNode *root, uint32_t whatToShow, nsIDOMNodeFilter *filter, uint8_t _argc,
1187             nsIDOMTreeWalker **_retval);
1188     cpp_quote("#undef CreateEvent")
1189     nsresult CreateEvent(const nsAString *eventType, nsIDOMEvent **_retval);
1190     nsresult GetDefaultView(nsIDOMWindow **aDefaultView);
1191     nsresult GetCharacterSet(nsAString *aCharacterSet);
1192     nsresult GetDir(nsAString *aDir);
1193     nsresult SetDir(const nsAString *aDir);
1194     nsresult GetLocation(nsIDOMLocation **aLocation);
1195     nsresult GetTitle(nsAString *aTitle);
1196     nsresult SetTitle(const nsAString *aTitle);
1197     nsresult GetReadyState(nsAString *aReadyState);
1198     nsresult GetLastModified(nsAString *aLastModified);
1199     nsresult GetReferrer(nsAString *aReferrer);
1200     nsresult HasFocus(bool *_retval);
1201     nsresult GetActiveElement(nsIDOMElement **aActiveElement);
1202     nsresult GetElementsByClassName(const nsAString *classes, nsIDOMNodeList **_retval);
1203     nsresult GetStyleSheets(nsIDOMStyleSheetList **aStyleSheets);
1204     nsresult GetPreferredStyleSheetSet(nsAString *aPreferredStyleSheetSet);
1205     nsresult GetSelectedStyleSheetSet(nsAString *aSelectedStyleSheetSet);
1206     nsresult SetSelectedStyleSheetSet(const nsAString *aSelectedStyleSheetSet);
1207     nsresult GetLastStyleSheetSet(nsAString *aLastStyleSheetSet);
1208     nsresult GetStyleSheetSets(nsISupports **aStyleSheetSets);
1209     nsresult EnableStyleSheetsForSet(const nsAString *name);
1210     nsresult ElementFromPoint(float x, float y, nsIDOMElement **_retval);
1211     nsresult GetContentType(nsAString *aContentType);
1212     nsresult GetMozSyntheticDocument(bool *aMozSyntheticDocument);
1213     nsresult GetCurrentScript(nsIDOMElement **aCurrentScript);
1214     nsresult ReleaseCapture();
1215     nsresult MozSetImageElement(const nsAString *aImageElementId, nsIDOMElement *aImageElement);
1216     nsresult GetMozFullScreenElement(nsIDOMElement **aMozFullScreenElement);
1217     nsresult MozCancelFullScreen();
1218     nsresult GetMozFullScreen(bool *aMozFullScreen);
1219     nsresult GetMozFullScreenEnabled(bool *aMozFullScreenEnabled);
1220     nsresult GetMozPointerLockElement(nsIDOMElement **aMozPointerLockElement);
1221     nsresult CaretPositionFromPoint(float x, float y, nsISupports **_retval);
1222     nsresult MozExitPointerLock();
1223     nsresult GetHidden(bool *aHidden);
1224     nsresult GetMozHidden(bool *aMozHidden);
1225     nsresult GetVisibilityState(nsAString *aVisibilityState);
1226     nsresult GetMozVisibilityState(nsAString *aMozVisibilityState);
1227     nsresult GetCompatMode(nsAString *aCompatMode);
1228     nsresult QuerySelector(const nsAString *selectors, nsIDOMElement **_retval);
1229     nsresult QuerySelectorAll(const nsAString *selectors, nsIDOMNodeList **_retval);
1230 }
1231
1232 [
1233     object,
1234     uuid(bd2a0a46-17e4-46ea-9e5d-6a97cf5e3b28),
1235     local
1236 ]
1237 interface nsIDOMHTMLDocument : nsIDOMDocument
1238 {
1239     nsresult GetDomain(nsAString *aDomain);
1240     nsresult SetDomain(const nsAString *aDomain);
1241     nsresult GetCookie(nsAString *aCookie);
1242     nsresult SetCookie(const nsAString *aCookie);
1243     nsresult GetHead(nsIDOMHTMLHeadElement **aHead);
1244     nsresult GetBody(nsIDOMHTMLElement **aBody);
1245     nsresult SetBody(nsIDOMHTMLElement *aBody);
1246     nsresult GetImages(nsIDOMHTMLCollection **aImages);
1247     nsresult GetEmbeds(nsIDOMHTMLCollection **aEmbeds);
1248     nsresult GetPlugins(nsIDOMHTMLCollection **aPlugins);
1249     nsresult GetLinks(nsIDOMHTMLCollection **aLinks);
1250     nsresult GetForms(nsIDOMHTMLCollection **aForms);
1251     nsresult GetScripts(nsIDOMHTMLCollection **aScripts);
1252     nsresult GetElementsByName(const nsAString *elementName, nsIDOMNodeList **_retval);
1253     nsresult GetItems(const nsAString *types, nsIDOMNodeList **_retval);
1254     nsresult Open(const nsAString *aContentTypeOrUrl, const nsAString *aReplaceOrName, const nsAString *aFeatures,
1255             JSContext *cx, uint8_t _argc, nsISupports **_retval);
1256     nsresult Close();
1257     nsresult Write(const nsAString *text, JSContext *cx);
1258     nsresult Writeln(const nsAString *text, JSContext *cx);
1259     nsresult GetDesignMode(nsAString *aDesignMode);
1260     nsresult SetDesignMode(const nsAString *aDesignMode);
1261     nsresult ExecCommand(const nsAString *commandID, bool doShowUI, const nsAString *value, bool *_retval);
1262     nsresult QueryCommandEnabled(const nsAString *commandID, bool *_retval);
1263     nsresult QueryCommandIndeterm(const nsAString *commandID, bool *_retval);
1264     nsresult QueryCommandState(const nsAString *commandID, bool *_retval);
1265     nsresult QueryCommandSupported(const nsAString *commandID, bool *_retval);
1266     nsresult QueryCommandValue(const nsAString *commandID, nsAString *_retval);
1267     nsresult GetFgColor(nsAString *aFgColor);
1268     nsresult SetFgColor(const nsAString *aFgColor);
1269     nsresult GetBgColor(nsAString *aBgColor);
1270     nsresult SetBgColor(const nsAString *aBgColor);
1271     nsresult GetLinkColor(nsAString *aLinkColor);
1272     nsresult SetLinkColor(const nsAString *aLinkColor);
1273     nsresult GetVlinkColor(nsAString *aVlinkColor);
1274     nsresult SetVlinkColor(const nsAString *aVlinkColor);
1275     nsresult GetAlinkColor(nsAString *aAlinkColor);
1276     nsresult SetAlinkColor(const nsAString *aAlinkColor);
1277     nsresult GetAnchors(nsIDOMHTMLCollection **aAnchors);
1278     nsresult GetApplets(nsIDOMHTMLCollection **aApplets);
1279     nsresult Clear();
1280     nsresult GetSelection(nsISelection **_retval);
1281     nsresult CaptureEvents();
1282     nsresult ReleaseEvents();
1283 }
1284
1285 [
1286     object,
1287     uuid(1f94055c-42e7-4a30-96a1-6a804f1c2d1e),
1288     local
1289 ]
1290 interface nsIDOMRange : nsISupports
1291 {
1292     enum {
1293         NS_START_TO_START,
1294         NS_START_TO_END,
1295         NS_END_TO_END,
1296         NS_END_TO_START
1297     };
1298
1299     nsresult GetStartContainer(nsIDOMNode **aStartContainer);
1300     nsresult GetStartOffset(int32_t *aStartOffset);
1301     nsresult GetEndContainer(nsIDOMNode **aEndContainer);
1302     nsresult GetEndOffset(int32_t *aEndOffset);
1303     nsresult GetCollapsed(bool *aCollapsed);
1304     nsresult GetCommonAncestorContainer(nsIDOMNode **aCommonAncestorContainer);
1305     nsresult SetStart(nsIDOMNode *refNode, int32_t offset);
1306     nsresult SetEnd(nsIDOMNode *refNode, int32_t offset);
1307     nsresult SetStartBefore(nsIDOMNode *refNode);
1308     nsresult SetStartAfter(nsIDOMNode *refNode);
1309     nsresult SetEndBefore(nsIDOMNode *refNode);
1310     nsresult SetEndAfter(nsIDOMNode *refNode);
1311     nsresult Collapse(bool toStart);
1312     nsresult SelectNode(nsIDOMNode *refNode);
1313     nsresult SelectNodeContents(nsIDOMNode *refNode);
1314     nsresult CompareBoundaryPoints(uint16_t how, nsIDOMRange *sourceRange, int16_t *_retval);
1315     nsresult DeleteContents();
1316     nsresult ExtractContents(nsIDOMDocumentFragment **_retval);
1317     nsresult CloneContents(nsIDOMDocumentFragment **_retval);
1318     nsresult InsertNode(nsIDOMNode *newNode);
1319     nsresult SurroundContents(nsIDOMNode *newParent);
1320     nsresult CloneRange(nsIDOMRange **_retval);
1321     nsresult ToString(nsAString *_retval);
1322     nsresult Detach();
1323     nsresult CreateContextualFragment([in] const nsAString *fragment, [out] nsIDOMDocumentFragment **_retval);
1324     nsresult IsPointInRange([in] nsIDOMNode *parent, [in] int32_t offset, [out] bool *_retval);
1325     nsresult ComparePoint([in] nsIDOMNode *parent, [in] int32_t offset, [out] int16_t *_retval);
1326     nsresult IntersectsNode(nsIDOMNode *node, bool *_retval);
1327     nsresult GetClientRects(nsIDOMClientRectList **_retval);
1328     nsresult GetBoundingClientRect(nsIDOMClientRect **_retval);
1329 }
1330
1331 [
1332     object,
1333     uuid(e0a4d4b3-f34e-44bd-b1f2-4e3bde9b6915),
1334     local
1335 ]
1336 interface nsISelection : nsISupports
1337 {
1338     nsresult GetAnchorNode(nsIDOMNode **aAnchorNode);
1339     nsresult GetAnchorOffset(int32_t *aAnchorOffset);
1340     nsresult GetFocusNode(nsIDOMNode **aFocusNode);
1341     nsresult GetFocusOffset(int32_t *aFocusOffset);
1342     nsresult GetIsCollapsed(bool *aIsCollapsed);
1343     bool /* don't use */ Collapsed();
1344     nsresult GetRangeCount(int32_t *aRangeCount);
1345     nsresult GetRangeAt(int32_t index, nsIDOMRange **_retval);
1346     nsresult Collapse(nsIDOMNode *parentNode, int32_t offset);
1347     nsresult CollapseNative(nsINode *parentNode, int32_t offset);
1348     nsresult Extend(nsIDOMNode *parentNode, int32_t offset);
1349     nsresult ExtendNative(nsINode *parentNode, int32_t offset);
1350     nsresult CollapseToStart();
1351     nsresult CollapseToEnd();
1352     nsresult ContainsNode(nsIDOMNode *node, bool entirelyContained, bool *_retval);
1353     nsresult SelectAllChildren(nsIDOMNode *parentNode);
1354     nsresult AddRange(nsIDOMRange *range);
1355     nsresult RemoveRange(nsIDOMRange *range);
1356     nsresult RemoveAllRanges();
1357     nsresult DeleteFromDocument();
1358     nsresult ToString(nsAString *_retval);
1359     nsresult Modify(const nsAString *alter, const nsAString *direction, const nsAString *granularity);
1360 }
1361
1362 [
1363     object,
1364     uuid(a6cf906f-15b3-11d2-932e-00805f8add32),
1365     local
1366 ]
1367 interface nsIDOMWindowCollection : nsISupports
1368 {
1369     nsresult GetLength(uint32_t *aLength);
1370     nsresult Item(uint32_t index, nsIDOMWindow **_retval);
1371     nsresult NamedItem(const nsAString *name, nsIDOMWindow **_retval);
1372 }
1373
1374 [
1375     object,
1376     uuid(ed7cc4e4-cf5b-42af-9c2e-8df074a01470),
1377     local
1378 ]
1379 interface nsIDOMWindow : nsISupports
1380 {
1381     nsresult GetWindow(nsIDOMWindow **aWindow);
1382     nsresult GetSelf(nsIDOMWindow **aSelf);
1383     nsresult GetDocument(nsIDOMDocument **aDocument);
1384     nsresult GetName(nsAString *aName);
1385     nsresult SetName(const nsAString *aName);
1386     nsresult GetLocation(nsIDOMLocation **aLocation);
1387     nsresult GetHistory(nsISupports **aHistory);
1388     nsresult GetLocationbar(nsISupports **aLocationbar);
1389     nsresult GetMenubar(nsISupports **aMenubar);
1390     nsresult GetPersonalbar(nsISupports **aPersonalbar);
1391     nsresult GetScrollbars(nsISupports **aScrollbars);
1392     nsresult GetStatusbar(nsISupports **aStatusbar);
1393     nsresult GetToolbar(nsISupports **aToolbar);
1394     nsresult GetStatus(nsAString *aStatus);
1395     nsresult SetStatus(const nsAString *aStatus);
1396     nsresult Close();
1397     nsresult Stop();
1398     nsresult Focus();
1399     nsresult Blur();
1400     nsresult GetLength(uint32_t *aLength);
1401     nsresult GetScriptableTop(nsIDOMWindow **aTop);
1402     nsresult GetRealTop(nsIDOMWindow **aTop);
1403     nsresult GetScriptableParent(nsIDOMWindow **aParent);
1404     nsresult GetRealParent(nsIDOMWindow **aParent);
1405     nsresult GetScriptableOpener(JSContext* cx, int /* JS::MutableHandleValue */ aOpener);
1406     nsresult SetScriptableOpener(JSContext* cx, int /* JS::HandleValue */ aOpener);
1407     nsresult GetOpener(nsIDOMWindow **aOpenerWindow);
1408     nsresult SetOpener(nsIDOMWindow *aOpenerWindow);
1409     nsresult GetScriptableFrameElement(nsIDOMElement **aFrameElement);
1410     nsresult GetRealFrameElement(nsIDOMElement **aFrameElement);
1411     nsresult GetNavigator(nsIDOMNavigator **aNavigator);
1412     nsresult GetApplicationCache(nsIDOMOfflineResourceList **aApplicationCache);
1413     nsresult Alert(const nsAString *text);
1414     nsresult Confirm(const nsAString *text, bool *_retval);
1415     nsresult Prompt(const nsAString *aMessage, const nsAString *aInitial, nsAString *_retval);
1416     nsresult Print();
1417     nsresult ShowModalDialog(const nsAString *aURI, nsIVariant *aArgs, const nsAString *aOptions, uint8_t _argc, nsIVariant **_retval);
1418     nsresult PostMessageMoz(const long /*jsval*/ *message, const nsAString *targetOrigin, const /*JS::Value*/ void *transfer, JSContext *cx);
1419     nsresult Atob(const nsAString *aAsciiString, nsAString *_retval);
1420     nsresult Btoa(const nsAString *aBase64Data, nsAString *_retval);
1421     nsresult GetSessionStorage(nsISupports **aSessionStorage);
1422     nsresult GetLocalStorage(nsISupports **aLocalStorage);
1423     nsresult GetIndexedDB(nsISupports **aIndexedDB);
1424     nsresult GetMozIndexedDB(nsISupports **aMozIndexedDB);
1425     nsresult GetSelection(nsISelection **_retval);
1426     nsresult MatchMedia(const nsAString *media_query_list, nsISupports **_retval);
1427     nsresult GetScreen(nsIDOMScreen **aScreen);
1428     nsresult GetInnerWidth(int32_t *aInnerWidth);
1429     nsresult SetInnerWidth(int32_t aInnerWidth);
1430     nsresult GetInnerHeight(int32_t *aInnerHeight);
1431     nsresult SetInnerHeight(int32_t aInnerHeight);
1432     nsresult GetScrollX(int32_t *aScrollX);
1433     nsresult GetPageXOffset(int32_t *aPageXOffset);
1434     nsresult GetScrollY(int32_t *aScrollY);
1435     nsresult GetPageYOffset(int32_t *aPageYOffset);
1436     nsresult Scroll(int32_t xScroll, int32_t yScroll);
1437     nsresult ScrollTo(int32_t xScroll, int32_t yScroll);
1438     nsresult ScrollBy(int32_t xScrollDif, int32_t yScrollDif);
1439     nsresult GetScreenX(int32_t *aScreenX);
1440     nsresult SetScreenX(int32_t aScreenX);
1441     nsresult GetScreenY(int32_t *aScreenY);
1442     nsresult SetScreenY(int32_t aScreenY);
1443     nsresult GetOuterWidth(int32_t *aOuterWidth);
1444     nsresult SetOuterWidth(int32_t aOuterWidth);
1445     nsresult GetOuterHeight(int32_t *aOuterHeight);
1446     nsresult SetOuterHeight(int32_t aOuterHeight);
1447     nsresult GetComputedStyle(nsIDOMElement *elt, const nsAString *pseudoElt, nsIDOMCSSStyleDeclaration **_retval);
1448     nsresult GetDefaultComputedStyle(nsIDOMElement *elt, const nsAString *pseudoElt, nsIDOMCSSStyleDeclaration **_retval);
1449     nsresult GetWindowRoot(nsIDOMEventTarget **aWindowRoot);
1450     nsresult GetFrames(nsIDOMWindowCollection **aFrames);
1451     nsresult GetTextZoom(float *aTextZoom);
1452     nsresult SetTextZoom(float aTextZoom);
1453     nsresult ScrollByLines(int32_t numLines);
1454     nsresult ScrollByPages(int32_t numPages);
1455     nsresult SizeToContent();
1456     nsresult GetContent(nsIDOMWindow **aContent);
1457     nsresult GetPrompter(nsIPrompt **aPrompter);
1458     nsresult GetClosed(bool *aClosed);
1459     nsresult GetCrypto(nsIDOMCrypto **aCrypto);
1460     nsresult GetControllers(nsIControllers **aControllers);
1461     nsresult GetMozInnerScreenX(float *aMozInnerScreenX);
1462     nsresult GetMozInnerScreenY(float *aMozInnerScreenY);
1463     nsresult GetDevicePixelRatio(float *aDevicePixelRatio);
1464     nsresult GetScrollMaxX(int32_t *aScrollMaxX);
1465     nsresult GetScrollMaxY(int32_t *aScrollMaxY);
1466     nsresult GetFullScreen(bool *aFullScreen);
1467     nsresult SetFullScreen(bool aFullScreen);
1468     nsresult Back();
1469     nsresult Forward();
1470     nsresult Home();
1471     nsresult MoveTo(int32_t xPos, int32_t yPos);
1472     nsresult MoveBy(int32_t xDif, int32_t yDif);
1473     nsresult ResizeTo(int32_t width, int32_t height);
1474     nsresult ResizeBy(int32_t widthDif, int32_t heightDif);
1475     nsresult Open(const nsAString *url, const nsAString *name, const nsAString *options, nsIDOMWindow **_retval);
1476     nsresult OpenDialog(const nsAString *url, const nsAString *name, const nsAString *options, nsISupports *aExtraArgument,
1477             nsIDOMWindow **_retval);
1478     nsresult UpdateCommands(const nsAString *action, nsISelection *sel, int16_t reason);
1479     nsresult Find(const nsAString *str, bool caseSensitive, bool backwards, bool wrapAround, bool wholeWord,
1480             bool searchInFrames, bool showDialog, bool *_retval);
1481     nsresult GetMozPaintCount(uint64_t *aMozPaintCount);
1482     nsresult MozRequestAnimationFrame(nsIFrameRequestCallback *aCallback, int32_t *_retval);
1483     nsresult RequestAnimationFrame(void /*const JS::Value*/ *aCallback, JSContext* cx, int32_t *_retval);
1484     nsresult MozCancelAnimationFrame(int32_t aHandle);
1485     nsresult MozCancelRequestAnimationFrame(int32_t aHandle);
1486     nsresult CancelAnimationFrame(int32_t aHandle);
1487     nsresult GetMozAnimationStartTime(int64_t *aMozAnimationStartTime);
1488     nsresult GetConsole(JSContext *cx, jsval *aConsole);
1489     nsresult SetConsole(JSContext *cx, const jsval *aConsole);
1490 }
1491
1492 [
1493     object,
1494     uuid(068630db-2c00-43dd-b167-495757a88236),
1495     local
1496 ]
1497 interface nsIDOMHTMLBodyElement : nsISupports
1498 {
1499     nsresult GetALink(nsAString *aALink);
1500     nsresult SetALink(const nsAString *aALink);
1501     nsresult GetBackground(nsAString *aBackground);
1502     nsresult SetBackground(const nsAString *aBackground);
1503     nsresult GetBgColor(nsAString *aBgColor);
1504     nsresult SetBgColor(const nsAString *aBgColor);
1505     nsresult GetLink(nsAString *aLink);
1506     nsresult SetLink(const nsAString *aLink);
1507     nsresult GetText(nsAString *aText);
1508     nsresult SetText(const nsAString *aText);
1509     nsresult GetVLink(nsAString *aVLink);
1510     nsresult SetVLink(const nsAString *aVLink);
1511 }
1512
1513 [
1514     object,
1515     uuid(ad9b2ad0-9d29-43f6-b1a2-a1fd24627e6b),
1516     local
1517 ]
1518 interface nsIDOMHTMLFormElement : nsISupports
1519 {
1520     nsresult GetAcceptCharset(nsAString *aAcceptCharset);
1521     nsresult SetAcceptCharset(const nsAString *aAcceptCharset);
1522     nsresult GetAction(nsAString *aAction);
1523     nsresult SetAction(const nsAString *aAction);
1524     nsresult GetAutocomplete(nsAString *aAutocomplete);
1525     nsresult SetAutocomplete(const nsAString *aAutocomplete);
1526     nsresult GetEnctype(nsAString *aEnctype);
1527     nsresult SetEnctype(const nsAString *aEnctype);
1528     nsresult GetEncoding(nsAString *aEncoding);
1529     nsresult SetEncoding(const nsAString *aEncoding);
1530     nsresult GetMethod(nsAString *aMethod);
1531     nsresult SetMethod(const nsAString *aMethod);
1532     nsresult GetName(nsAString *aName);
1533     nsresult SetName(const nsAString *aName);
1534     nsresult GetNoValidate(bool *aNoValidate);
1535     nsresult SetNoValidate(bool aNoValidate);
1536     nsresult GetTarget(nsAString *aTarget);
1537     nsresult SetTarget(const nsAString *aTarget);
1538     nsresult GetElements(nsIDOMHTMLCollection **aElements);
1539     nsresult GetLength(int32_t *aLength);
1540     nsresult Submit();
1541     nsresult Reset();
1542     nsresult CheckValidity(bool *_retval);
1543     nsresult GetFormData(nsIDOMHTMLElement *aOriginatingElement, nsAString *aActionURI, nsIInputStream **aPostDataStream);
1544 }
1545
1546 [
1547     object,
1548     uuid(64aeda0b-e9b5-4868-a4f9-e4776e32e733),
1549     local
1550 ]
1551 interface nsIDOMHTMLInputElement : nsISupports
1552 {
1553     nsresult GetAccept(nsAString *aAccept);
1554     nsresult SetAccept(const nsAString *aAccept);
1555     nsresult GetAlt(nsAString *aAlt);
1556     nsresult SetAlt(const nsAString *aAlt);
1557     nsresult GetAutocomplete(nsAString *aAutocomplete);
1558     nsresult SetAutocomplete(const nsAString *aAutocomplete);
1559     nsresult GetAutofocus(bool *aAutofocus);
1560     nsresult SetAutofocus(bool aAutofocus);
1561     nsresult GetDefaultChecked(bool *aDefaultChecked);
1562     nsresult SetDefaultChecked(bool aDefaultChecked);
1563     nsresult GetChecked(bool *aChecked);
1564     nsresult SetChecked(bool aChecked);
1565     nsresult GetDisabled(bool *aDisabled);
1566     nsresult SetDisabled(bool aDisabled);
1567     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1568     nsresult GetFormAction(nsAString *aFormAction);
1569     nsresult SetFormAction(const nsAString *aFormAction);
1570     nsresult GetFormEnctype(nsAString *aFormEnctype);
1571     nsresult SetFormEnctype(const nsAString *aFormEnctype);
1572     nsresult GetFormMethod(nsAString *aFormMethod);
1573     nsresult SetFormMethod(const nsAString *aFormMethod);
1574     nsresult GetFormNoValidate(bool *aFormNoValidate);
1575     nsresult SetFormNoValidate(bool aFormNoValidate);
1576     nsresult GetFormTarget(nsAString *aFormTarget);
1577     nsresult SetFormTarget(const nsAString *aFormTarget);
1578     nsresult GetFiles(nsIDOMFileList **aFiles);
1579     nsresult GetHeight(uint32_t *aHeight);
1580     nsresult SetHeight(uint32_t aHeight);
1581     nsresult GetIndeterminate(bool *aIndeterminate);
1582     nsresult SetIndeterminate(bool aIndeterminate);
1583     nsresult GetInputMode(nsAString *aInputMode);
1584     nsresult SetInputMode(const nsAString *aInputMode);
1585     nsresult GetList(nsIDOMHTMLElement **aList);
1586     nsresult GetMax(nsAString *aMax);
1587     nsresult SetMax(const nsAString *aMax);
1588     nsresult GetMaxLength(int32_t *aMaxLength);
1589     nsresult SetMaxLength(int32_t aMaxLength);
1590     nsresult GetMin(nsAString *aMin);
1591     nsresult SetMin(const nsAString *aMin);
1592     nsresult GetMultiple(bool *aMultiple);
1593     nsresult SetMultiple(bool aMultiple);
1594     nsresult GetName(nsAString *aName);
1595     nsresult SetName(const nsAString *aName);
1596     nsresult GetPattern(nsAString *aPattern);
1597     nsresult SetPattern(const nsAString *aPattern);
1598     nsresult GetPlaceholder(nsAString *aPlaceholder);
1599     nsresult SetPlaceholder(const nsAString *aPlaceholder);
1600     nsresult GetReadOnly(bool *aReadOnly);
1601     nsresult SetReadOnly(bool aReadOnly);
1602     nsresult GetRequired(bool *aRequired);
1603     nsresult SetRequired(bool aRequired);
1604     nsresult GetStep(nsAString *aStep);
1605     nsresult SetStep(const nsAString *aStep);
1606     nsresult GetAlign(nsAString *aAlign);
1607     nsresult SetAlign(const nsAString *aAlign);
1608     nsresult GetSize(uint32_t *aSize);
1609     nsresult SetSize(uint32_t aSize);
1610     nsresult GetWidth(uint32_t *aWidth);
1611     nsresult SetWidth(uint32_t aWidth);
1612     nsresult GetSrc(nsAString *aSrc);
1613     nsresult SetSrc(const nsAString *aSrc);
1614     nsresult GetType(nsAString *aType);
1615     nsresult SetType(const nsAString *aType);
1616     nsresult GetDefaultValue(nsAString *aDefaultValue);
1617     nsresult SetDefaultValue(const nsAString *aDefaultValue);
1618     nsresult GetValue(nsAString *aValue);
1619     nsresult SetValue(const nsAString *aValue);
1620     nsresult GetValueAsNumber(double *aValueAsNumber);
1621     nsresult SetValueAsNumber(double aValueAsNumber);
1622     nsresult StepDown(int32_t n, uint8_t _argc);
1623     nsresult StepUp(int32_t n, uint8_t _argc);
1624     nsresult GetWillValidate(bool *aWillValidate);
1625     nsresult GetValidity(nsIDOMValidityState **aValidity);
1626     nsresult GetValidationMessage(nsAString *aValidationMessage);
1627     nsresult CheckValidity(bool *_retval);
1628     nsresult SetCustomValidity(const nsAString *error);
1629     nsresult Select();
1630     nsresult GetSelectionStart(int32_t *aSelectionStart);
1631     nsresult SetSelectionStart(int32_t aSelectionStart);
1632     nsresult GetSelectionEnd(int32_t *aSelectionEnd);
1633     nsresult SetSelectionEnd(int32_t aSelectionEnd);
1634     nsresult SetSelectionRange(int32_t selectionStart, int32_t selectionEnd, const nsAString *direction);
1635     nsresult GetSelectionDirection(nsAString *aSelectionDirection);
1636     nsresult SetSelectionDirection(const nsAString *aSelectionDirection);
1637     nsresult GetUseMap(nsAString *aUseMap);
1638     nsresult SetUseMap(const nsAString *aUseMap);
1639     nsresult GetControllers(nsIControllers **aControllers);
1640     nsresult GetTextLength(int32_t *aTextLength);
1641     nsresult MozGetFileNameArray(uint32_t *aLength, PRUnichar ***aFileNames);
1642     nsresult MozSetFileNameArray(const PRUnichar **aFileNames, uint32_t aLength);
1643     nsresult MozIsTextField(bool aExcludePassword, bool *_retval);
1644 }
1645
1646 [
1647     object,
1648     uuid(c2b3e9ff-6b36-4158-ace3-05a9c5b8e1c1),
1649     local
1650 ]
1651 interface nsIDOMHTMLOptionElement : nsISupports
1652 {
1653     nsresult GetDisabled(bool *aDisabled);
1654     nsresult SetDisabled(bool aDisabled);
1655     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1656     nsresult GetLabel(nsAString *aLabel);
1657     nsresult SetLabel(const nsAString *aLabel);
1658     nsresult GetDefaultSelected(bool *aDefaultSelected);
1659     nsresult SetDefaultSelected(bool aDefaultSelected);
1660     nsresult GetSelected(bool *aSelected);
1661     nsresult SetSelected(bool aSelected);
1662     nsresult GetValue(nsAString *aValue);
1663     nsresult SetValue(const nsAString *aValue);
1664     nsresult GetText(nsAString *aText);
1665     nsresult SetText(const nsAString *aText);
1666     nsresult GetIndex(int32_t *aIndex);
1667 }
1668
1669 [
1670     object,
1671     uuid(44b7a468-7dba-4f0c-9b4e-ee46dc0f26c7),
1672     local
1673 ]
1674 interface nsIDOMHTMLButtonElement : nsISupports
1675 {
1676     nsresult GetAutofocus(bool *aAutofocus);
1677     nsresult SetAutofocus(bool aAutofocus);
1678     nsresult GetDisabled(bool *aDisabled);
1679     nsresult SetDisabled(bool aDisabled);
1680     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1681     nsresult GetFormAction(nsAString *aFormAction);
1682     nsresult SetFormAction(const nsAString *aFormAction);
1683     nsresult GetFormEnctype(nsAString *aFormEnctype);
1684     nsresult SetFormEnctype(const nsAString *aFormEnctype);
1685     nsresult GetFormMethod(nsAString *aFormMethod);
1686     nsresult SetFormMethod(const nsAString *aFormMethod);
1687     nsresult GetFormNoValidate(bool *aFormNoValidate);
1688     nsresult SetFormNoValidate(bool aFormNoValidate);
1689     nsresult GetFormTarget(nsAString *aFormTarget);
1690     nsresult SetFormTarget(const nsAString *aFormTarget);
1691     nsresult GetName(nsAString *aName);
1692     nsresult SetName(const nsAString *aName);
1693     nsresult GetType(nsAString *aType);
1694     nsresult SetType(const nsAString *aType);
1695     nsresult GetValue(nsAString *aValue);
1696     nsresult SetValue(const nsAString *aValue);
1697     nsresult GetWillValidate(bool *aWillValidate);
1698     nsresult GetValidity(nsIDOMValidityState **aValidity);
1699     nsresult GetValidationMessage(nsAString *aValidationMessage);
1700     nsresult CheckValidity(bool *_retval);
1701     nsresult SetCustomValidity(const nsAString *error);
1702 }
1703
1704 [
1705     object,
1706     uuid(4173cc53-30f6-4d12-a770-981ba53164e2),
1707     local
1708 ]
1709 interface nsIDOMHTMLOptionsCollection : nsISupports
1710 {
1711     typedef int nsWrapperCache;
1712
1713     nsresult GetLength(uint32_t *aLength);
1714     nsresult SetLength(uint32_t aLength);
1715     nsresult Item(uint32_t index, nsIDOMNode **_retval);
1716     nsresult NamedItem(const nsAString *name, nsIDOMNode **_retval);
1717     nsresult GetSelectedIndex(int32_t *aSelectedIndex);
1718     nsresult SetSelectedIndex(int32_t aSelectedIndex);
1719     nsresult SetOption(uint32_t index, nsIDOMHTMLOptionElement *option);
1720     nsresult GetSelect(nsIDOMHTMLSelectElement **aSelect);
1721     nsresult Add(nsIDOMHTMLOptionElement *option, nsIVariant *before);
1722     nsresult Remove(int32_t index);
1723 }
1724
1725 [
1726     object,
1727     uuid(d8914a2d-3556-4b66-911c-a84c4394e7fa),
1728     local
1729 ]
1730 interface nsIDOMHTMLSelectElement : nsISupports
1731 {
1732     nsresult GetAutofocus(bool *aAutofocus);
1733     nsresult SetAutofocus(bool aAutofocus);
1734     nsresult GetDisabled(bool *aDisabled);
1735     nsresult SetDisabled(bool aDisabled);
1736     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1737     nsresult GetMultiple(bool *aMultiple);
1738     nsresult SetMultiple(bool aMultiple);
1739     nsresult GetName(nsAString *aName);
1740     nsresult SetName(const nsAString *aName);
1741     nsresult GetSize(uint32_t *aSize);
1742     nsresult SetSize(uint32_t aSize);
1743     nsresult GetType(nsAString *aType);
1744     nsresult GetOptions(nsIDOMHTMLOptionsCollection **aOptions);
1745     nsresult GetLength(uint32_t *aLength);
1746     nsresult SetLength(uint32_t aLength);
1747     nsresult Item(uint32_t index, nsIDOMNode **_retval);
1748     nsresult NamedItem(const nsAString *name, nsIDOMNode **_retval);
1749     nsresult Add(nsIDOMHTMLElement *element, nsIVariant *before);
1750     nsresult select_Remove(int32_t index);
1751     nsresult GetSelectedOptions(nsIDOMHTMLCollection **aSelectedOptions);
1752     nsresult GetSelectedIndex(int32_t *aSelectedIndex);
1753     nsresult SetSelectedIndex(int32_t aSelectedIndex);
1754     nsresult GetValue(nsAString *aValue);
1755     nsresult SetValue(const nsAString *aValue);
1756     nsresult GetWillValidate(bool *aWillValidate);
1757     nsresult GetValidity(nsIDOMValidityState **aValidity);
1758     nsresult GetValidationMessage(nsAString *aValidationMessage);
1759     nsresult CheckValidity(bool *_retval);
1760     nsresult SetCustomValidity(const nsAString *error);
1761     nsresult GetRequired(bool *aRequired);
1762     nsresult SetRequired(bool aRequired);
1763 }
1764
1765 [
1766     object,
1767     uuid(7a4aeb2e-fcf3-443e-b002-ca1c8ea322e9),
1768     local
1769 ]
1770 interface nsIDOMHTMLTextAreaElement : nsISupports
1771 {
1772     nsresult GetAutofocus(bool *aAutofocus);
1773     nsresult SetAutofocus(bool aAutofocus);
1774     nsresult GetCols(uint32_t *aCols);
1775     nsresult SetCols(uint32_t aCols);
1776     nsresult GetDisabled(bool *aDisabled);
1777     nsresult SetDisabled(bool aDisabled);
1778     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1779     nsresult GetMaxLength(int32_t *aMaxLength);
1780     nsresult SetMaxLength(int32_t aMaxLength);
1781     nsresult GetName(nsAString *aName);
1782     nsresult SetName(const nsAString *aName);
1783     nsresult GetPlaceholder(nsAString *aPlaceholder);
1784     nsresult SetPlaceholder(const nsAString *aPlaceholder);
1785     nsresult GetReadOnly(bool *aReadOnly);
1786     nsresult SetReadOnly(bool aReadOnly);
1787     nsresult GetRequired(bool *aRequired);
1788     nsresult SetRequired(bool aRequired);
1789     nsresult GetRows(uint32_t *aRows);
1790     nsresult SetRows(uint32_t aRows);
1791     nsresult GetWrap(nsAString *aWrap);
1792     nsresult SetWrap(const nsAString *aWrap);
1793     nsresult GetType(nsAString *aType);
1794     nsresult GetDefaultValue(nsAString *aDefaultValue);
1795     nsresult SetDefaultValue(const nsAString *aDefaultValue);
1796     nsresult GetValue(nsAString *aValue);
1797     nsresult SetValue(const nsAString *aValue);
1798     nsresult GetTextLength(int32_t *aTextLength);
1799     nsresult GetWillValidate(bool *aWillValidate);
1800     nsresult GetValidity(nsIDOMValidityState **aValidity);
1801     nsresult GetValidationMessage(nsAString *aValidationMessage);
1802     nsresult CheckValidity(bool *_retval);
1803     nsresult SetCustomValidity(const nsAString *error);
1804     nsresult Select();
1805     nsresult GetSelectionStart(int32_t *aSelectionStart);
1806     nsresult SetSelectionStart(int32_t aSelectionStart);
1807     nsresult GetSelectionEnd(int32_t *aSelectionEnd);
1808     nsresult SetSelectionEnd(int32_t aSelectionEnd);
1809     nsresult SetSelectionRange(int32_t selectionStart, int32_t selectionEnd, const nsAString *direction);
1810     nsresult GetSelectionDirection(nsAString *aSelectionDirection);
1811     nsresult SetSelectionDirection(const nsAString *aSelectionDirection);
1812     nsresult GetControllers(nsIControllers **aControllers);
1813 }
1814
1815 [
1816     object,
1817     uuid(fe96dc1c-40e4-4974-9354-e3fce663c3d5),
1818     local
1819 ]
1820 interface nsIDOMHTMLScriptElement : nsISupports
1821 {
1822     nsresult GetSrc(nsAString *aSrc);
1823     nsresult SetSrc(const nsAString *aSrc);
1824     nsresult GetAsync(bool *aAsync);
1825     nsresult SetAsync(bool aAsync);
1826     nsresult GetDefer(bool *aDefer);
1827     nsresult SetDefer(bool aDefer);
1828     nsresult GetType(nsAString *aType);
1829     nsresult SetType(const nsAString *aType);
1830     nsresult GetCharset(nsAString *aCharset);
1831     nsresult SetCharset(const nsAString *aCharset);
1832     nsresult GetText(nsAString *aText);
1833     nsresult SetText(const nsAString *aText);
1834     nsresult GetHtmlFor(nsAString *aHtmlFor);
1835     nsresult SetHtmlFor(const nsAString *aHtmlFor);
1836     nsresult GetEvent(nsAString *aEvent);
1837     nsresult SetEvent(const nsAString *aEvent);
1838 }
1839
1840 [
1841     object,
1842     uuid(ec18e71c-4f5c-4cc3-aa36-5273168644dc),
1843     local
1844 ]
1845 interface nsIDOMHTMLImageElement : nsISupports
1846 {
1847     nsresult GetAlt(nsAString *aAlt);
1848     nsresult SetAlt(const nsAString *aAlt);
1849     nsresult GetSrc(nsAString *aSrc);
1850     nsresult SetSrc(const nsAString *aSrc);
1851     nsresult GetSrcset(nsAString *aSrcset);
1852     nsresult SetSrcset(const nsAString *aSrcset) ;
1853     nsresult GetSizes(nsAString *aSizes);
1854     nsresult SetSizes(const nsAString *aSizes);
1855     nsresult GetUseMap(nsAString *aUseMap);
1856     nsresult SetUseMap(const nsAString *aUseMap);
1857     nsresult GetIsMap(bool *aIsMap);
1858     nsresult SetIsMap(bool aIsMap);
1859     nsresult GetWidth(uint32_t *aWidth);
1860     nsresult SetWidth(uint32_t aWidth);
1861     nsresult GetHeight(uint32_t *aHeight);
1862     nsresult SetHeight(uint32_t aHeight);
1863     nsresult GetNaturalWidth(uint32_t *aNaturalWidth);
1864     nsresult GetNaturalHeight(uint32_t *aNaturalHeight);
1865     nsresult GetComplete(bool *aComplete);
1866     nsresult GetName(nsAString *aName);
1867     nsresult SetName(const nsAString *aName);
1868     nsresult GetAlign(nsAString *aAlign);
1869     nsresult SetAlign(const nsAString *aAlign);
1870     nsresult GetBorder(nsAString *aBorder);
1871     nsresult SetBorder(const nsAString *aBorder);
1872     nsresult GetHspace(int32_t *aHspace);
1873     nsresult SetHspace(int32_t aHspace);
1874     nsresult GetLongDesc(nsAString *aLongDesc);
1875     nsresult SetLongDesc(const nsAString *aLongDesc);
1876     nsresult GetVspace(int32_t *aVspace);
1877     nsresult SetVspace(int32_t aVspace);
1878     nsresult GetLowsrc(nsAString *aLowsrc);
1879     nsresult SetLowsrc(const nsAString *aLowsrc);
1880     nsresult GetCurrentSrc(nsAString *aCurrentSrc);
1881     nsresult GetX(int32_t *aX);
1882     nsresult GetY(int32_t *aY);
1883 }
1884
1885 [
1886     object,
1887     uuid(339c01c8-2d41-4626-b231-eec63f0241b6),
1888     local
1889 ]
1890 interface nsIDOMHTMLAnchorElement : nsISupports
1891 {
1892     nsresult GetHref(nsAString *aHref);
1893     nsresult SetHref(const nsAString *aHref);
1894     nsresult GetTarget(nsAString *aTarget);
1895     nsresult SetTarget(const nsAString *aTarget);
1896     nsresult GetPing(nsAString *aPing);
1897     nsresult SetPing(const nsAString *aPing);
1898     nsresult GetDownload(nsAString *aPing);
1899     nsresult SetDownload(const nsAString *aPing);
1900     nsresult GetRel(nsAString *aRel);
1901     nsresult SetRel(const nsAString *aRel);
1902     nsresult GetHreflang(nsAString *aHreflang);
1903     nsresult SetHreflang(const nsAString *aHreflang);
1904     nsresult GetType(nsAString *aType);
1905     nsresult SetType(const nsAString *aType);
1906     nsresult GetText(nsAString *aText);
1907     nsresult SetText(const nsAString *aText);
1908     nsresult GetProtocol(nsAString *aProtocol);
1909     nsresult SetProtocol(const nsAString *aProtocol);
1910     nsresult GetHost(nsAString *aHost);
1911     nsresult SetHost(const nsAString *aHost);
1912     nsresult GetHostname(nsAString *aHostname);
1913     nsresult SetHostname(const nsAString *aHostname);
1914     nsresult GetPort(nsAString *aPort);
1915     nsresult SetPort(const nsAString *aPort);
1916     nsresult GetPathname(nsAString *aPathname);
1917     nsresult SetPathname(const nsAString *aPathname);
1918     nsresult GetSearch(nsAString *aSearch);
1919     nsresult SetSearch(const nsAString *aSearch);
1920     nsresult GetHash(nsAString *aHash);
1921     nsresult SetHash(const nsAString *aHash);
1922     nsresult GetCharset(nsAString *aCharset);
1923     nsresult SetCharset(const nsAString *aCharset);
1924     nsresult GetCoords(nsAString *aCoords);
1925     nsresult SetCoords(const nsAString *aCoords);
1926     nsresult GetName(nsAString *aName);
1927     nsresult SetName(const nsAString *aName);
1928     nsresult GetRev(nsAString *aRev);
1929     nsresult SetRev(const nsAString *aRev);
1930     nsresult GetShape(nsAString *aShape);
1931     nsresult SetShape(const nsAString *aShape);
1932     nsresult ToString(nsAString *_retval);
1933 }
1934
1935 [
1936     object,
1937     uuid(ee50b7ab-0015-4fbe-89e0-e3feacd4ffde),
1938     local
1939 ]
1940 interface nsIDOMHTMLLinkElement : nsISupports
1941 {
1942     nsresult GetDisabled(bool *aDisabled);
1943     nsresult SetDisabled(bool aDisabled);
1944     nsresult GetCharset(nsAString *aCharset);
1945     nsresult SetCharset(const nsAString *aCharset);
1946     nsresult GetHref(nsAString *aHref);
1947     nsresult SetHref(const nsAString *aHref);
1948     nsresult GetHreflang(nsAString *aHreflang);
1949     nsresult SetHreflang(const nsAString *aHreflang);
1950     nsresult GetMedia(nsAString *aMedia);
1951     nsresult SetMedia(const nsAString *aMedia);
1952     nsresult GetRel(nsAString *aRel);
1953     nsresult SetRel(const nsAString *aRel);
1954     nsresult GetRev(nsAString *aRev);
1955     nsresult SetRev(const nsAString *aRev);
1956     nsresult GetTarget(nsAString *aTarget);
1957     nsresult SetTarget(const nsAString *aTarget);
1958     nsresult GetType(nsAString *aType);
1959     nsresult SetType(const nsAString *aType);
1960 }
1961
1962 [
1963     object,
1964     uuid(135a30ee-0374-4ee7-9d36-91736bff5fb1),
1965     local
1966 ]
1967 interface nsIDOMHTMLTableElement : nsISupports
1968 {
1969     nsresult GetCaption(nsIDOMHTMLTableCaptionElement **aCaption);
1970     nsresult SetCaption(nsIDOMHTMLTableCaptionElement *aCaption);
1971     nsresult GetTHead(nsIDOMHTMLElement **aTHead);
1972     nsresult SetTHead(nsIDOMHTMLElement *aTHead);
1973     nsresult GetTFoot(nsIDOMHTMLElement **aTFoot);
1974     nsresult SetTFoot(nsIDOMHTMLElement *aTFoot);
1975     nsresult GetRows(nsIDOMHTMLCollection **aRows);
1976     nsresult GetTBodies(nsIDOMHTMLCollection **aTBodies);
1977     nsresult GetAlign(nsAString *aAlign);
1978     nsresult SetAlign(const nsAString *aAlign);
1979     nsresult GetBgColor(nsAString *aBgColor);
1980     nsresult SetBgColor(const nsAString *aBgColor);
1981     nsresult GetBorder(nsAString *aBorder);
1982     nsresult SetBorder(const nsAString *aBorder);
1983     nsresult GetCellPadding(nsAString *aCellPadding);
1984     nsresult SetCellPadding(const nsAString *aCellPadding);
1985     nsresult GetCellSpacing(nsAString *aCellSpacing);
1986     nsresult SetCellSpacing(const nsAString *aCellSpacing);
1987     nsresult GetFrame(nsAString *aFrame);
1988     nsresult SetFrame(const nsAString *aFrame);
1989     nsresult GetRules(nsAString *aRules);
1990     nsresult SetRules(const nsAString *aRules);
1991     nsresult GetSummary(nsAString *aSummary);
1992     nsresult SetSummary(const nsAString *aSummary);
1993     nsresult GetWidth(nsAString *aWidth);
1994     nsresult SetWidth(const nsAString *aWidth);
1995     nsresult CreateTHead(nsIDOMHTMLElement **_retval);
1996     nsresult xpidlDeleteTHead();
1997     nsresult CreateTFoot(nsIDOMHTMLElement **_retval);
1998     nsresult xpidlDeleteTFoot();
1999     nsresult CreateCaption(nsIDOMHTMLElement **_retval);
2000     nsresult xpidlDeleteCaption();
2001     nsresult InsertRow(int32_t index, nsIDOMHTMLElement **_retval);
2002     nsresult DeleteRow(int32_t index);
2003 }
2004
2005 [
2006     object,
2007     uuid(02094366-0d3d-47e3-949c-89113a9bcc15),
2008     local
2009 ]
2010 interface nsIDOMHTMLTableRowElement : nsISupports
2011 {
2012     nsresult GetRowIndex(int32_t *aRowIndex);
2013     nsresult GetSectionRowIndex(int32_t *aSectionRowIndex);
2014     nsresult GetCells(nsIDOMHTMLCollection **aCells);
2015     nsresult GetAlign(nsAString *aAlign);
2016     nsresult SetAlign(const nsAString *aAlign);
2017     nsresult GetBgColor(nsAString *aBgColor);
2018     nsresult SetBgColor(const nsAString *aBgColor);
2019     nsresult GetCh(nsAString *aCh);
2020     nsresult SetCh(const nsAString *aCh);
2021     nsresult GetChOff(nsAString *aChOff);
2022     nsresult SetChOff(const nsAString *aChOff);
2023     nsresult GetVAlign(nsAString *aVAlign);
2024     nsresult SetVAlign(const nsAString *aVAlign);
2025     nsresult InsertCell(int32_t index, nsIDOMHTMLElement * *_retval);
2026     nsresult DeleteCell(int32_t index);
2027 }
2028
2029 [
2030     object,
2031     uuid(3203c36f-33fd-4628-8c88-77e82d38df1e),
2032     local
2033 ]
2034 interface nsIDOMHTMLTableCellElement : nsISupports
2035 {
2036     nsresult GetCellIndex(int32_t *aCellIndex);
2037     nsresult GetAbbr(nsAString *aAbbr);
2038     nsresult SetAbbr(const nsAString *aAbbr);
2039     nsresult GetAlign(nsAString *aAlign);
2040     nsresult SetAlign(const nsAString *aAlign);
2041     nsresult GetAxis(nsAString *aAxis);
2042     nsresult SetAxis(const nsAString *aAxis);
2043     nsresult GetBgColor(nsAString *aBgColor);
2044     nsresult SetBgColor(const nsAString *aBgColor);
2045     nsresult GetCh(nsAString *aCh);
2046     nsresult SetCh(const nsAString *aCh);
2047     nsresult GetChOff(nsAString *aChOff);
2048     nsresult SetChOff(const nsAString *aChOff);
2049     nsresult GetColSpan(int32_t *aColSpan);
2050     nsresult SetColSpan(int32_t aColSpan);
2051     nsresult GetHeaders(nsAString *aHeaders);
2052     nsresult SetHeaders(const nsAString *aHeaders);
2053     nsresult GetHeight(nsAString *aHeight);
2054     nsresult SetHeight(const nsAString *aHeight);
2055     nsresult GetNoWrap(bool *aNoWrap);
2056     nsresult SetNoWrap(bool aNoWrap);
2057     nsresult GetRowSpan(int32_t *aRowSpan);
2058     nsresult SetRowSpan(int32_t aRowSpan);
2059     nsresult GetScope(nsAString *aScope);
2060     nsresult SetScope(const nsAString *aScope);
2061     nsresult GetVAlign(nsAString *aVAlign);
2062     nsresult SetVAlign(const nsAString *aVAlign);
2063     nsresult GetWidth(nsAString *aWidth);
2064     nsresult SetWidth(const nsAString *aWidth);
2065 }
2066
2067 [
2068     object,
2069     uuid(9fd7b656-1055-4cb2-b8b1-ed13efe24457),
2070     local
2071 ]
2072 interface nsIDOMHTMLIFrameElement : nsISupports
2073 {
2074     nsresult GetAlign(nsAString *aAlign);
2075     nsresult SetAlign(const nsAString *aAlign);
2076     nsresult GetFrameBorder(nsAString *aFrameBorder);
2077     nsresult SetFrameBorder(const nsAString *aFrameBorder);
2078     nsresult GetHeight(nsAString *aHeight);
2079     nsresult SetHeight(const nsAString *aHeight);
2080     nsresult GetLongDesc(nsAString *aLongDesc);
2081     nsresult SetLongDesc(const nsAString *aLongDesc);
2082     nsresult GetMarginHeight(nsAString *aMarginHeight);
2083     nsresult SetMarginHeight(const nsAString *aMarginHeight);
2084     nsresult GetMarginWidth(nsAString *aMarginWidth);
2085     nsresult SetMarginWidth(const nsAString *aMarginWidth);
2086     nsresult GetName(nsAString *aName);
2087     nsresult SetName(const nsAString *aName);
2088     nsresult GetScrolling(nsAString *aScrolling);
2089     nsresult SetScrolling(const nsAString *aScrolling);
2090     nsresult GetSrc(nsAString *aSrc);
2091     nsresult SetSrc(const nsAString *aSrc);
2092     nsresult GetSrcdoc(nsAString *aSrcdoc);
2093     nsresult SetSrcdoc(const nsAString *aSrcdoc);
2094     nsresult GetWidth(nsAString *aWidth);
2095     nsresult SetWidth(const nsAString *aWidth);
2096     nsresult GetContentDocument(nsIDOMDocument **aContentDocument);
2097     nsresult GetContentWindow(nsIDOMWindow **aContentWindow);
2098     nsresult GetAllowFullscreen(bool *aAllowFullscreen);
2099     nsresult SetAllowFullscreen(bool aAllowFullscreen);
2100 }
2101
2102 [
2103     object,
2104     uuid(60ab25b9-3246-4f50-b0d4-21e73ba88cd6),
2105     local
2106 ]
2107 interface nsIDOMHTMLFrameElement : nsISupports
2108 {
2109     nsresult GetFrameBorder(nsAString *aFrameBorder);
2110     nsresult SetFrameBorder(const nsAString *aFrameBorder);
2111     nsresult GetLongDesc(nsAString *aLongDesc);
2112     nsresult SetLongDesc(const nsAString *aLongDesc);
2113     nsresult GetMarginHeight(nsAString *aMarginHeight);
2114     nsresult SetMarginHeight(const nsAString *aMarginHeight);
2115     nsresult GetMarginWidth(nsAString *aMarginWidth);
2116     nsresult SetMarginWidth(const nsAString *aMarginWidth);
2117     nsresult GetName(nsAString *aName);
2118     nsresult SetName(const nsAString *aName);
2119     nsresult GetNoResize(bool *aNoResize);
2120     nsresult SetNoResize(bool aNoResize);
2121     nsresult GetScrolling(nsAString *aScrolling);
2122     nsresult SetScrolling(const nsAString *aScrolling);
2123     nsresult GetSrc(nsAString *aSrc);
2124     nsresult SetSrc(const nsAString *aSrc);
2125     nsresult GetContentDocument(nsIDOMDocument **aContentDocument);
2126     nsresult GetContentWindow(nsIDOMWindow **aContentWindow);
2127 }
2128
2129 [
2130     object,
2131     uuid(baf443d2-da5d-40c9-be3c-c65a69a25250),
2132     local
2133 ]
2134 interface nsIDOMHTMLObjectElement : nsISupports
2135 {
2136     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
2137     nsresult GetCode(nsAString *aCode);
2138     nsresult SetCode(const nsAString *aCode);
2139     nsresult GetAlign(nsAString *aAlign);
2140     nsresult SetAlign(const nsAString *aAlign);
2141     nsresult GetArchive(nsAString *aArchive);
2142     nsresult SetArchive(const nsAString *aArchive);
2143     nsresult GetBorder(nsAString *aBorder);
2144     nsresult SetBorder(const nsAString *aBorder);
2145     nsresult GetCodeBase(nsAString *aCodeBase);
2146     nsresult SetCodeBase(const nsAString *aCodeBase);
2147     nsresult GetCodeType(nsAString *aCodeType);
2148     nsresult SetCodeType(const nsAString *aCodeType);
2149     nsresult GetData(nsAString *aData);
2150     nsresult SetData(const nsAString *aData);
2151     nsresult GetDeclare(bool *aDeclare);
2152     nsresult SetDeclare(bool aDeclare);
2153     nsresult GetHeight(nsAString *aHeight);
2154     nsresult SetHeight(const nsAString *aHeight);
2155     nsresult GetHspace(int32_t *aHspace);
2156     nsresult SetHspace(int32_t aHspace);
2157     nsresult GetName(nsAString *aName);
2158     nsresult SetName(const nsAString *aName);
2159     nsresult GetStandby(nsAString *aStandby);
2160     nsresult SetStandby(const nsAString *aStandby);
2161     nsresult GetType(nsAString *aType);
2162     nsresult SetType(const nsAString *aType);
2163     nsresult GetUseMap(nsAString *aUseMap);
2164     nsresult SetUseMap(const nsAString *aUseMap);
2165     nsresult GetVspace(int32_t *aVspace);
2166     nsresult SetVspace(int32_t aVspace);
2167     nsresult GetWidth(nsAString *aWidth);
2168     nsresult SetWidth(const nsAString *aWidth);
2169     nsresult GetContentDocument(nsIDOMDocument **aContentDocument);
2170     nsresult GetWillValidate(bool *aWillValidate);
2171     nsresult GetValidity(nsIDOMValidityState **aValidity);
2172     nsresult GetValidationMessage(nsAString *aValidationMessage);
2173     nsresult CheckValidity(bool *_retval);
2174     nsresult SetCustomValidity(const nsAString *error);
2175 }
2176
2177 [
2178     object,
2179     uuid(fa326d22-8739-4eef-a80e-6449bde605d2),
2180     local
2181 ]
2182 interface nsIDOMHTMLStyleElement : nsISupports
2183 {
2184     nsresult GetDisabled(bool *aDisabled);
2185     nsresult SetDisabled(bool aDisabled);
2186     nsresult GetMedia(nsAString *aMedia);
2187     nsresult SetMedia(const nsAString *aMedia);
2188     nsresult GetType(nsAString *aType);
2189     nsresult SetType(const nsAString *aType);
2190     nsresult GetScoped(bool *aScoped);
2191     nsresult SetScoped(bool aScoped);
2192     nsresult GetDOMStyleSheet(nsIDOMStyleSheet **aDOMStyleSheet);
2193 }
2194
2195 [
2196     object,
2197     uuid(94928ab3-8b63-11d3-989d-001083010e9b),
2198     local
2199 ]
2200 interface nsIURIContentListener : nsISupports
2201 {
2202     nsresult OnStartURIOpen(nsIURI *aURI, bool *_retval);
2203     nsresult DoContent(const char *aContentType, bool aIsContentPreferred, nsIRequest *aRequest,
2204         nsIStreamListener **aContentHandler, bool *_retval);
2205     nsresult IsPreferred(const char *aContentType, char **aDesiredContentType, bool *_retval);
2206     nsresult CanHandleContent(const char *aContentType, bool aIsContentPreferred,
2207         char **aDesiredContentType, bool *_retval);
2208     nsresult GetLoadCookie(nsISupports **aLoadCookie);
2209     nsresult SetLoadCookie(nsISupports *aLoadCookie);
2210     nsresult GetParentContentListener(nsIURIContentListener **aParentContentListener);
2211     nsresult SetParentContentListener(nsIURIContentListener *aParentContentListener);
2212 }
2213
2214 [
2215     object,
2216     uuid(44b78386-1dd2-11b2-9ad2-e4eee2ca1916),
2217     local
2218 ]
2219 interface nsITooltipListener : nsISupports
2220 {
2221     nsresult OnShowTooltip(int32_t aXCoords, int32_t aYCoords, const PRUnichar *aTipText);
2222     nsresult OnHideTooltip();
2223 }
2224
2225 [
2226     object,
2227     uuid(33e9d001-caab-4ba9-8961-54902f197202),
2228     local
2229 ]
2230 interface nsIWebBrowser : nsISupports
2231 {
2232     nsresult AddWebBrowserListener(nsIWeakReference *aListener, const nsIID *aIID);
2233     nsresult RemoveWebBrowserListener(nsIWeakReference *aListener, const nsIID *aIID);
2234     nsresult GetContainerWindow(nsIWebBrowserChrome **aContainerWindow);
2235     nsresult SetContainerWindow(nsIWebBrowserChrome *aContainerWindow);
2236     nsresult GetParentURIContentListener(nsIURIContentListener **aParentURIContentListener);
2237     nsresult SetParentURIContentListener(nsIURIContentListener *aParentURIContentListener);
2238     nsresult GetContentDOMWindow(nsIDOMWindow **aContentDOMWindow);
2239     nsresult GetIsActive(bool *aIsActive);
2240     nsresult SetIsActive(bool aIsActive);
2241 }
2242
2243 cpp_quote("#define SETUP_ALLOW_JAVASCRIPT  2")
2244 cpp_quote("#define SETUP_IS_CHROME_WRAPPER 7")
2245 cpp_quote("#define SETUP_DISABLE_NOSCRIPT  16")
2246
2247 [
2248     object,
2249     uuid(f15398a0-8018-11d3-af70-00a024ffc08c),
2250     local
2251 ]
2252 interface nsIWebBrowserSetup : nsISupports
2253 {
2254     nsresult SetProperty(uint32_t aId, uint32_t aValue);
2255 }
2256
2257 typedef void* nativeWindow;
2258
2259 [
2260     object,
2261     uuid(9da319f3-eee6-4504-81a5-6A19cf6215bf),
2262     local
2263 ]
2264 interface nsIBaseWindow : nsISupports
2265 {
2266     nsresult InitWindow(nativeWindow parentNativeWindow, nsIWidget *parentWidget, int32_t x,
2267             int32_t y, int32_t cx, int32_t cy);
2268     nsresult Create();
2269     nsresult Destroy();
2270     nsresult SetPosition(int32_t x, int32_t y);
2271     nsresult GetPosition(int32_t *x, int32_t *y);
2272     nsresult SetSize(int32_t cx, int32_t cy, bool fRepaint);
2273     nsresult GetSize(int32_t *cx, int32_t *cy);
2274     nsresult SetPositionAndSize(int32_t x, int32_t y, int32_t cx, int32_t cy, bool fRepaint);
2275     nsresult GetPositionAndSize(int32_t *x, int32_t *y, int32_t *cx, int32_t *cy);
2276     nsresult Repaint(bool force);
2277     nsresult GetParentWidget(nsIWidget **aParentWidget);
2278     nsresult SetParentWidget(nsIWidget *aParentWidget);
2279     nsresult GetParentNativeWindow(nativeWindow *aParentNativeWindow);
2280     nsresult SetParentNativeWindow(nativeWindow aParentNativeWindow);
2281     nsresult GetNativeHandle(nsAString *aNativeHandle);
2282     nsresult GetVisibility(bool *aVisibility);
2283     nsresult SetVisibility(bool aVisibility);
2284     nsresult GetEnabled(bool *aEnabled);
2285     nsresult SetEnabled(bool aEnabled);
2286     nsresult GetMainWidget(nsIWidget **aMainWidget);
2287     nsresult GetUnscaledDevicePixelsPerCSSPixel(double *aUnscaledDevicePixelsPerCSSPixel);
2288     nsresult SetFocus();
2289     nsresult GetTitle(PRUnichar **aTitle);
2290     nsresult SetTitle(const PRUnichar *aTitle);
2291 }
2292
2293 [
2294     object,
2295     uuid(b7568a50-4c50-442c-a6be-3a340a48d89a),
2296     local
2297 ]
2298 interface nsIWebNavigation : nsISupports
2299 {
2300     const UINT LOAD_FLAGS_MASK                    =  0xffff;
2301     const UINT LOAD_FLAGS_NONE                    =       0;
2302     const UINT LOAD_FLAGS_IS_REFRESH              =  0x0010;
2303     const UINT LOAD_FLAGS_IS_LINK                 =  0x0020;
2304     const UINT LOAD_FLAGS_BYPASS_HISTORY          =  0x0040;
2305     const UINT LOAD_FLAGS_REPLACE_HISTORY         =  0x0080;
2306     const UINT LOAD_FLAGS_BYPASS_CACHE            =  0x0100;
2307     const UINT LOAD_FLAGS_BYPASS_PROXY            =  0x0200;
2308     const UINT LOAD_FLAGS_CHARSET_CHANGE          =  0x0400;
2309     const UINT LOAD_FLAGS_STOP_CONTENT            =  0x0800;
2310     const UINT LOAD_FLAGS_FROM_EXTERNAL           =  0x1000;
2311     const UINT LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP =  0x2000;
2312     const UINT LOAD_FLAGS_FIRST_LOAD              =  0x4000;
2313     const UINT LOAD_FLAGS_ALLOW_POPUPS            =  0x8000;
2314     const UINT LOAD_FLAGS_BYPASS_CLASSIFIER       = 0x10000;
2315     const UINT LOAD_FLAGS_FORCE_ALLOW_COOKIES     = 0x20000;
2316     const UINT LOAD_FLAGS_DISALLOW_INHERIT_OWNER  = 0x40000;
2317
2318     nsresult GetCanGoBack(bool *aCanGoBack);
2319     nsresult GetCanGoForward(bool *aCanGoForward);
2320     nsresult GoBack();
2321     nsresult GoForward();
2322     nsresult GotoIndex(int32_t index);
2323     nsresult LoadURI(const PRUnichar *aURI, uint32_t aLoadFlags, nsIURI *aReferrer,
2324             nsIInputStream *aPostData, nsIInputStream *aHeaders);
2325     nsresult LoadURIWithBase(const PRUnichar *aURI, uint32_t aLoadFlags, nsIURI *aReferrer,
2326             nsIInputStream *aPostData, nsIInputStream *aHeaders, nsIURI *aBaseURI);
2327     nsresult Reload(uint32_t aReloadFlags);
2328     nsresult Stop(uint32_t aStopFlags);
2329     nsresult GetDocument(nsIDOMDocument **aDocument);
2330     nsresult GetCurrentURI(nsIURI **aCurrentURI);
2331     nsresult GetReferringURI(nsIURI **aReferringURI);
2332     nsresult GetSessionHistory(nsISHistory **aSessionHistory);
2333     nsresult SetSessionHistory(nsISHistory *aSessionHistory);
2334 }
2335
2336 [
2337     object,
2338     uuid(bd0efb3b-1c81-4fb0-b16d-576a2be48a95),
2339     local
2340 ]
2341 interface nsIWebProgress : nsISupports
2342 {
2343     nsresult AddProgressListener(nsIWebProgressListener *aListener, uint32_t aNotifyMask);
2344     nsresult RemoveProgressListener(nsIWebProgressListener *aListener);
2345     nsresult GetDOMWindow(nsIDOMWindow **aDOMWindow);
2346     nsresult GetDOMWindowID(uint64_t *aDOMWindowID);
2347     nsresult GetIsTopLevel(bool *aIsTopLevel);
2348     nsresult GetIsLoadingDocument(bool *aIsLoadingDocument);
2349     nsresult GetLoadType(uint32_t *aLoadType);
2350 }
2351
2352 [
2353     object,
2354     uuid(1bcfc611-8941-4c39-9e06-7116e564a1ce),
2355     local
2356 ]
2357 interface nsIPrintSettings : nsISupports
2358 {
2359     typedef struct { char dummy; } nsIntMargin;
2360
2361     nsresult SetPrintOptions(int32_t aType, bool aTurnOnOff);
2362     nsresult GetPrintOptions(int32_t aType, bool *_retval);
2363     nsresult GetPrintOptionsBits(int32_t *_retval);
2364     nsresult GetEffectivePageSize(double *aWidth, double *aHeight);
2365     nsresult Clone(nsIPrintSettings **_retval);
2366     nsresult Assign(nsIPrintSettings *aPS);
2367     nsresult GetPrintSession(nsIPrintSession **aPrintSession);
2368     nsresult SetPrintSession(nsIPrintSession *aPrintSession);
2369     nsresult GetStartPageRange(int32_t *aStartPageRange);
2370     nsresult SetStartPageRange(int32_t aStartPageRange);
2371     nsresult GetEndPageRange(int32_t *aEndPageRange);
2372     nsresult SetEndPageRange(int32_t aEndPageRange);
2373     nsresult GetEdgeTop(double *aEdgeTop);
2374     nsresult SetEdgeTop(double aEdgeTop);
2375     nsresult GetEdgeLeft(double *aEdgeLeft);
2376     nsresult SetEdgeLeft(double aEdgeLeft);
2377     nsresult GetEdgeBottom(double *aEdgeBottom);
2378     nsresult SetEdgeBottom(double aEdgeBottom);
2379     nsresult GetEdgeRight(double *aEdgeRight);
2380     nsresult SetEdgeRight(double aEdgeRight);
2381     nsresult GetMarginTop(double *aMarginTop);
2382     nsresult SetMarginTop(double aMarginTop);
2383     nsresult GetMarginLeft(double *aMarginLeft);
2384     nsresult SetMarginLeft(double aMarginLeft);
2385     nsresult GetMarginBottom(double *aMarginBottom);
2386     nsresult SetMarginBottom(double aMarginBottom);
2387     nsresult GetMarginRight(double *aMarginRight);
2388     nsresult SetMarginRight(double aMarginRight);
2389     nsresult GetUnwriteableMarginTop(double *aUnwriteableMarginTop);
2390     nsresult SetUnwriteableMarginTop(double aUnwriteableMarginTop);
2391     nsresult GetUnwriteableMarginLeft(double *aUnwriteableMarginLeft);
2392     nsresult SetUnwriteableMarginLeft(double aUnwriteableMarginLeft);
2393     nsresult GetUnwriteableMarginBottom(double *aUnwriteableMarginBottom);
2394     nsresult SetUnwriteableMarginBottom(double aUnwriteableMarginBottom);
2395     nsresult GetUnwriteableMarginRight(double *aUnwriteableMarginRight);
2396     nsresult SetUnwriteableMarginRight(double aUnwriteableMarginRight);
2397     nsresult GetScaling(double *aScaling);
2398     nsresult SetScaling(double aScaling);
2399     nsresult GetPrintBGColors(bool *aPrintBGColors);
2400     nsresult SetPrintBGColors(bool aPrintBGColors);
2401     nsresult GetPrintBGImages(bool *aPrintBGImages);
2402     nsresult SetPrintBGImages(bool aPrintBGImages);
2403     nsresult GetPrintRange(int16_t *aPrintRange);
2404     nsresult SetPrintRange(int16_t aPrintRange);
2405     nsresult GetTitle(PRUnichar **aTitle);
2406     nsresult SetTitle(const PRUnichar *aTitle);
2407     nsresult GetDocURL(PRUnichar **aDocURL);
2408     nsresult SetDocURL(const PRUnichar *aDocURL);
2409     nsresult GetHeaderStrLeft(PRUnichar **aHeaderStrLeft);
2410     nsresult SetHeaderStrLeft(const PRUnichar *aHeaderStrLeft);
2411     nsresult GetHeaderStrCenter(PRUnichar **aHeaderStrCenter);
2412     nsresult SetHeaderStrCenter(const PRUnichar *aHeaderStrCenter);
2413     nsresult GetHeaderStrRight(PRUnichar **aHeaderStrRight);
2414     nsresult SetHeaderStrRight(const PRUnichar *aHeaderStrRight);
2415     nsresult GetFooterStrLeft(PRUnichar **aFooterStrLeft);
2416     nsresult SetFooterStrLeft(const PRUnichar *aFooterStrLeft);
2417     nsresult GetFooterStrCenter(PRUnichar **aFooterStrCenter);
2418     nsresult SetFooterStrCenter(const PRUnichar *aFooterStrCenter);
2419     nsresult GetFooterStrRight(PRUnichar **aFooterStrRight);
2420     nsresult SetFooterStrRight(const PRUnichar *aFooterStrRight);
2421     nsresult GetHowToEnableFrameUI(int16_t *aHowToEnableFrameUI);
2422     nsresult SetHowToEnableFrameUI(int16_t aHowToEnableFrameUI);
2423     nsresult GetIsCancelled(bool *aIsCancelled);
2424     nsresult SetIsCancelled(bool aIsCancelled);
2425     nsresult GetPrintFrameTypeUsage(int16_t *aPrintFrameTypeUsage);
2426     nsresult SetPrintFrameTypeUsage(int16_t aPrintFrameTypeUsage);
2427     nsresult GetPrintFrameType(int16_t *aPrintFrameType);
2428     nsresult SetPrintFrameType(int16_t aPrintFrameType);
2429     nsresult GetPrintSilent(bool *aPrintSilent);
2430     nsresult SetPrintSilent(bool aPrintSilent);
2431     nsresult GetShrinkToFit(bool *aShrinkToFit);
2432     nsresult SetShrinkToFit(bool aShrinkToFit);
2433     nsresult GetShowPrintProgress(bool *aShowPrintProgress);
2434     nsresult SetShowPrintProgress(bool aShowPrintProgress);
2435     nsresult GetPaperName(PRUnichar **aPaperName);
2436     nsresult SetPaperName(const PRUnichar *aPaperName);
2437     nsresult GetPaperSizeType(int16_t *aPaperSizeType);
2438     nsresult SetPaperSizeType(int16_t aPaperSizeType);
2439     nsresult GetPaperData(int16_t *aPaperData);
2440     nsresult SetPaperData(int16_t aPaperData);
2441     nsresult GetPaperWidth(double *aPaperWidth);
2442     nsresult SetPaperWidth(double aPaperWidth);
2443     nsresult GetPaperHeight(double *aPaperHeight);
2444     nsresult SetPaperHeight(double aPaperHeight);
2445     nsresult GetPaperSizeUnit(int16_t *aPaperSizeUnit);
2446     nsresult SetPaperSizeUnit(int16_t aPaperSizeUnit);
2447     nsresult GetPlexName(PRUnichar **aPlexName);
2448     nsresult SetPlexName(const PRUnichar *aPlexName);
2449     nsresult GetColorspace(PRUnichar **aColorspace);
2450     nsresult SetColorspace(const PRUnichar *aColorspace);
2451     nsresult GetResolutionName(PRUnichar **aResolutionName);
2452     nsresult SetResolutionName(const PRUnichar aResolutionName);
2453     nsresult GetDownloadFonts(bool *aDownloadFonts);
2454     nsresult SetDownloadFonts(bool aDownloadFonts);
2455     nsresult GetPrintReversed(bool *aPrintReversed);
2456     nsresult SetPrintReversed(bool aPrintReversed);
2457     nsresult GetPrintInColor(bool *aPrintInColor);
2458     nsresult SetPrintInColor(bool aPrintInColor);
2459     nsresult GetOrientation(int32_t *aOrientation);
2460     nsresult SetOrientation(int32_t aOrientation);
2461     nsresult GetPrintCommand(PRUnichar **aPrintCommand);
2462     nsresult SetPrintCommand(const PRUnichar *aPrintCommand);
2463     nsresult GetNumCopies(int32_t *aNumCopies);
2464     nsresult SetNumCopies(int32_t aNumCopies);
2465     nsresult GetPrinterName(PRUnichar **aPrinterName);
2466     nsresult SetPrinterName(const PRUnichar *aPrinterName);
2467     nsresult GetPrintToFile(bool *aPrintToFile);
2468     nsresult SetPrintToFile(bool aPrintToFile);
2469     nsresult GetToFileName(PRUnichar **aToFileName);
2470     nsresult SetToFileName(const PRUnichar *aToFileName);
2471     nsresult GetOutputFormat(int16_t *aOutputFormat);
2472     nsresult SetOutputFormat(int16_t aOutputFormat);
2473     nsresult GetPrintPageDelay(int32_t *aPrintPageDelay);
2474     nsresult SetPrintPageDelay(int32_t aPrintPageDelay);
2475     nsresult GetResolution(int32_t *aResolution) = 0;
2476     nsresult SetResolution(int32_t aResolution) = 0;
2477     nsresult GetDuplex(int32_t *aDuplex);
2478     nsresult SetDuplex(int32_t aDuplex);
2479     nsresult GetIsInitializedFromPrinter(bool *aIsInitializedFromPrinter);
2480     nsresult SetIsInitializedFromPrinter(bool aIsInitializedFromPrinter);
2481     nsresult GetIsInitializedFromPrefs(bool *aIsInitializedFromPrefs);
2482     nsresult SetIsInitializedFromPrefs(bool aIsInitializedFromPrefs);
2483     nsresult GetPersistMarginBoxSettings(bool *aPersistMarginBoxSettings);
2484     nsresult SetPersistMarginBoxSettings(bool aPersistMarginBoxSettings);
2485     nsresult SetMarginInTwips(nsIntMargin *aMargin);
2486     nsresult SetEdgeInTwips(nsIntMargin *aEdge);
2487     nsresult GetMarginInTwips(nsIntMargin *aMargin);
2488     nsresult GetEdgeInTwips(nsIntMargin *aEdge);
2489     nsresult SetupSilentPrinting();
2490     nsresult SetUnwriteableMarginInTwips(nsIntMargin *aEdge);
2491     nsresult GetUnwriteableMarginInTwips(nsIntMargin *aEdge);
2492     nsresult GetPageRanges(void * /*nsTArray<int32_t>*/ aPages);
2493 }
2494
2495 [
2496     object,
2497     uuid(9a7ca4b0-fbba-11d4-a869-00105a183419),
2498     local
2499 ]
2500 interface nsIWebBrowserPrint : nsISupports
2501 {
2502     nsresult GetGlobalPrintSettings(nsIPrintSettings **aGlobalPrintSettings);
2503     nsresult GetCurrentPrintSettings(nsIPrintSettings **aCurrentPrintSettings);
2504     nsresult GetCurrentChildDOMWindow(nsIDOMWindow **aCurrentChildDOMWindow);
2505     nsresult GetDoingPrint(bool *aDoingPrint);
2506     nsresult GetDoingPrintPreview(bool *aDoingPrintPreview);
2507     nsresult GetIsFramesetDocument(bool *aIsFramesetDocument);
2508     nsresult GetIsFramesetFrameSelected(bool *aIsFramesetFrameSelected);
2509     nsresult GetIsIFrameSelected(bool *aIsIFrameSelected);
2510     nsresult GetIsRangeSelection(bool *aIsRangeSelection);
2511     nsresult GetPrintPreviewNumPages(int32_t *aPrintPreviewNumPages);
2512     nsresult Print(nsIPrintSettings *aThePrintSettings, nsIWebProgressListener *aWPListener);
2513     nsresult PrintPreview(nsIPrintSettings *aThePrintSettings, nsIDOMWindow *aChildDOMWin,
2514                           nsIWebProgressListener *aWPListener);
2515     nsresult PrintPreviewNavigate(int16_t aNavType, int32_t aPageNum);
2516     nsresult Cancel();
2517     nsresult EnumerateDocumentNames(uint32_t *aCount, PRUnichar ***aResult);
2518     nsresult ExitPrintPreview();
2519 }
2520
2521 [
2522     object,
2523     uuid(3507fc93-313e-4a4c-8ca8-4d0ea0f97315),
2524     local
2525 ]
2526 interface nsIScrollable : nsISupports
2527 {
2528     enum {
2529         ScrollOrientation_X = 1,
2530         ScrollOrientation_Y = 2
2531     };
2532
2533     enum {
2534         Scrollbar_Auto   = 1,
2535         Scrollbar_Never  = 2,
2536         Scrollbar_Always = 3
2537     };
2538
2539     nsresult GetDefaultScrollbarPreferences(int32_t scrollOrientation, int32_t *_retval);
2540     nsresult SetDefaultScrollbarPreferences(int32_t scrollOrientation, int32_t scrollbarPref);
2541     nsresult GetScrollbarVisibility(bool *verticalVisible, bool *horizontalVisible);
2542 }
2543
2544 [
2545     object,
2546     uuid(dfb5a307-7ecf-41dd-aee2-f1d623459c44),
2547     local
2548 ]
2549 interface nsIFile : nsISupports
2550 {
2551     typedef struct {
2552         /* Currently not needed */
2553         char dummy;
2554     } PRFileDesc, PRLibrary, widl_FILE;
2555 #define FILE widl_FILE
2556
2557     nsresult Append(const nsAString *node);
2558     nsresult AppendNative(const nsAString *node);
2559     nsresult Normalize();
2560     nsresult Create(uint32_t type, uint32_t permission);
2561     nsresult GetLeafName(nsAString *aLeafName);
2562     nsresult SetLeafName(const nsAString *aLeafName);
2563     nsresult GetNativeLeafName(nsAString *aLeafName);
2564     nsresult SetNativeLeafName(const nsAString *aLeafName);
2565     nsresult CopyTo(nsIFile *newParentDir, const nsAString *newName);
2566     nsresult CopyToNative(nsIFile *newParentDir, const nsAString *newName);
2567     nsresult CopyToFollowingLinks(nsIFile *newParentDir, const nsAString *newName);
2568     nsresult CopyToFollowingLinksNative(nsIFile *newParentDir, const nsAString *newName);
2569     nsresult MoveTo(nsIFile *newParentDir, const nsAString *newName);
2570     nsresult MoveToNative(nsIFile *newParentDir, const nsAString *newName);
2571     nsresult RenameTo(nsIFile *newParentDir, const nsAString *newName);
2572     nsresult Remove(bool recursive);
2573     nsresult GetPermissions(uint32_t *aPermissions);
2574     nsresult SetPermissions(uint32_t pPermissions);
2575     nsresult GetPermissionsOfLink(uint32_t *aPermissions);
2576     nsresult SetPermissionsOfLink(uint32_t pPermissions);
2577     nsresult GetLastModifiedTime(PRTime *aLastModifiedTime);
2578     nsresult SetLastModifiedTime(PRTime aLastModifiedTime);
2579     nsresult GetLastModifiedTimeOfLink(PRTime *aLastModifiedTimeOfLink);
2580     nsresult SetLastModifiedTimeOfLink(PRTime aLastModifiedTimeOfLink);
2581     nsresult GetFileSize(int64_t *aFileSize);
2582     nsresult SetFileSize(int64_t aFileSize);
2583     nsresult GetFileSizeOfLink(int64_t *aFileSizeOfLink);
2584     nsresult GetTarget(nsAString *aTarget);
2585     nsresult GetNativeTarget(nsACString *aNativeTarget);
2586     nsresult GetPath(nsAString *aPath);
2587     nsresult GetNativePath(nsACString *aNativePath);
2588     nsresult Exists(bool *_retval);
2589     nsresult IsWritable(bool *_retval);
2590     nsresult IsReadable(bool *_retval);
2591     nsresult IsExecutable(bool *_retval);
2592     nsresult IsHidden(bool *_retval);
2593     nsresult IsDirectory(bool *_retval);
2594     nsresult IsFile(bool *_retval);
2595     nsresult IsSymlink(bool *_retval);
2596     nsresult IsSpecial(bool *_retval);
2597     nsresult CreateUnique(uint32_t type, uint32_t permission);
2598     nsresult Clone(nsIFile **_retval);
2599     nsresult Equals(nsIFile *inFile, bool *_retval);
2600     nsresult Contains(nsIFile *inFile, bool *_retval);
2601     nsresult GetParent(nsIFile **aParent);
2602     nsresult GetDirectoryEntries(nsISimpleEnumerator **aDirectoryEntries);
2603     nsresult InitWithPath(const nsAString *filePath);
2604     nsresult InitWithNativePath(const nsACString *filePath);
2605     nsresult InitWithFile(nsIFile *aFile);
2606     nsresult GetFollowLinks(bool *aFollowLinks);
2607     nsresult SetFollowLinks(bool aFollowLinks);
2608     nsresult OpenNSPRFileDesc(int32_t flags, int32_t mode, PRFileDesc **_retval);
2609     nsresult OpenANSIFileDesc(const char *mode, FILE **_retval);
2610     nsresult Load(PRLibrary **_retval);
2611     nsresult GetDiskSpaceAvailable(int64_t *aDiskSpaceAvailable);
2612     nsresult AppendRelativePath(const nsAString *relativeFilePath);
2613     nsresult AppendRelativeNativePath(const nsACString *relativeFilePath);
2614     nsresult GetPersistentDescriptor(nsACString *aPersistentDescriptor);
2615     nsresult SetPersistentDescriptor(const nsACString *aPersistentDescriptor);
2616     nsresult Reveal();
2617     nsresult Launch();
2618     nsresult GetRelativeDescriptor(nsIFile *fromFile, nsACString *_retval);
2619     nsresult SetRelativeDescriptor(nsIFile *fromFile, const nsACString *relativeDesc);
2620 }
2621
2622 [
2623     object,
2624     uuid(d604ffc3-1ba3-4f6c-b65f-1ed4199364c3),
2625     local
2626 ]
2627 interface nsIComponentManager : nsISupports
2628 {
2629     nsresult GetClassObject(nsCIDRef aClass, nsIIDRef aIID, void **result);
2630     nsresult GetClassObjectByContractID(const char *aContractID, nsIIDRef aIID, void **result);
2631     nsresult CreateInstance(nsCIDRef aClass, nsISupports *aDelegate, nsIIDRef aIID,
2632             void **result);
2633     nsresult CreateInstanceByContractID(const char *aContractID, nsISupports *aDelegate,
2634             nsIIDRef aIID, void **result);
2635     nsresult AddBootstrappedManifestLocation(nsIFile *aLocation);
2636     nsresult RemoveBootstrappedManifestLocation(nsIFile *aLocation);
2637     nsresult GetManifestLocations(nsIArray **_retval);
2638 }
2639
2640 [
2641     object,
2642     uuid(55d25e49-793f-4727-a69f-de8b15f4b985),
2643     local
2644 ]
2645 interface nsIPrefBranch : nsISupports
2646 {
2647     nsresult GetRoot(char **aRoot);
2648     nsresult GetPrefType(const char *aPrefName, int32_t *_retval);
2649     nsresult GetBoolPref(const char *aPrefName, bool *_retval);
2650     nsresult SetBoolPref(const char *aPrefName, bool aValue);
2651     nsresult GetFloatPref(const char *aPrefName, float *_retval);
2652     nsresult GetCharPref(const char *aPrefName, char **_retval);
2653     nsresult SetCharPref(const char *aPrefName, const char *aValue);
2654     nsresult GetIntPref(const char *aPrefName, int32_t *_retval);
2655     nsresult SetIntPref(const char *aPrefName, int32_t aValue);
2656     nsresult GetComplexValue(const char *aPrefName, const nsIID *aType, void **aValue);
2657     nsresult SetComplexValue(const char *aPrefName, const nsIID *aType, nsISupports *aValue);
2658     nsresult ClearUserPref(const char *aPrefName);
2659     nsresult LockPref(const char *aPrefName);
2660     nsresult PrefHasUserValue(const char *aPrefName, bool *_retval);
2661     nsresult PrefIsLocked(const char *aPrefName, bool *_retval);
2662     nsresult UnlockPref(const char *aPrefName);
2663     nsresult DeleteBranch(const char *aStartingAt);
2664     nsresult GetChildList(const char *aStartingAt, uint32_t *aCount, char ***aChildArray);
2665     nsresult ResetBranch(const char *aStartingAt);
2666     nsresult AddObserver(const char *aDomain, nsIObserver *aObserver, bool aHoldWeak);
2667     nsresult RemoveObserver(const char *aDomain, nsIObserver *aObserver);
2668 }
2669
2670 [
2671     object,
2672     uuid(bbf8cab0-d43a-11d3-8cc2-00609792278c),
2673     local
2674 ]
2675 interface nsIDirectoryServiceProvider : nsISupports
2676 {
2677     nsresult GetFile(const char *prop, bool *persistent, nsIFile **_retval);
2678 }
2679
2680 [
2681     object,
2682     uuid(2f977d4b-5485-11d4-87e2-0010a4e75ef2),
2683     local
2684 ]
2685 interface nsIDirectoryServiceProvider2 : nsIDirectoryServiceProvider
2686 {
2687     nsresult GetFiles(const char *prop, nsISimpleEnumerator **_retval);
2688 }
2689
2690 [
2691     object,
2692     uuid(a7aad716-e72c-435d-82f1-7582dffae661),
2693     local
2694 ]
2695 interface nsIProtocolHandler : nsISupports
2696 {
2697     const unsigned long URI_STD = 0;
2698     const unsigned long URI_NORELATIVE = (1<<0);
2699     const unsigned long URI_NOAUTH = (1<<1);
2700     const unsigned long ALLOWS_PROXY = (1<<2);
2701     const unsigned long ALLOWS_PROXY_HTTP = (1<<3);
2702     const unsigned long URI_INHERITS_SECURITY_CONTEXT = (1<<4);
2703     const unsigned long URI_FORBIDS_AUTOMATIC_DOCUMENT_REPLACEMENT = (1<<5);
2704     const unsigned long URI_LOADABLE_BY_ANYONE = (1<<6);
2705     const unsigned long URI_DANGEROUS_TO_LOAD = (1<<7);
2706     const unsigned long URI_IS_UI_RESOURCE = (1<<8);
2707     const unsigned long URI_IS_LOCAL_FILE = (1<<9);
2708     const unsigned long URI_LOADABLE_BY_SUBSUMERS = (1<<10);
2709     const unsigned long URI_DOES_NOT_RETURN_DATA = (1<<11);
2710     const unsigned long URI_IS_LOCAL_RESOURCE = (1<<12);
2711     const unsigned long URI_OPENING_EXECUTES_SCRIPT = (1<<13);
2712     const unsigned long URI_NON_PERSISTABLE = (1<<14);
2713     const unsigned long URI_FORBIDS_COOKIE_ACCESS = (1<<15);
2714     const unsigned long URI_CROSS_ORIGIN_NEEDS_WEBAPPS_PERM = (1<<16);
2715     const unsigned long URI_SYNC_LOAD_IS_OK = (1<<17);
2716     const unsigned long URI_SAFE_TO_LOAD_IN_SECURE_CONTEXT = (1<<18);
2717
2718     nsresult GetScheme(nsACString *aScheme);
2719     nsresult GetDefaultPort(int32_t *aDefaultPort);
2720     nsresult GetProtocolFlags(uint32_t *aProtocolFlags);
2721     nsresult NewURI(const nsACString *aSpec, const char *aOriginCharset,
2722                     nsIURI *aBaseURI, nsIURI **_retval);
2723     nsresult NewChannel2(nsIURI *aURI, nsILoadInfo *aLoadinfo, nsIChannel **_retval);
2724     nsresult NewChannel(nsIURI *aURI, nsIChannel **_retval);
2725     nsresult AllowPort(int32_t port, const char *scheme, bool *_retval);
2726 }
2727
2728 [
2729     object,
2730     uuid(0e61f3b2-34d7-4c79-bfdc-4860bc7341b7),
2731     local
2732 ]
2733 interface nsIExternalProtocolHandler : nsIProtocolHandler
2734 {
2735     nsresult ExternalAppExistsForScheme(const nsACString *scheme, bool *_retval);
2736 }
2737
2738 [
2739     object,
2740     uuid(d8555f58-203a-465a-a33e-442ae4c6c4cf),
2741     local
2742 ]
2743 interface nsIIOService : nsISupports
2744 {
2745     nsresult GetProtocolHandler(const char *aScheme, nsIProtocolHandler **_retval);
2746     nsresult GetProtocolFlags(const char *aScheme, uint32_t *_retval);
2747     nsresult NewURI(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
2748                     nsIURI **_retval);
2749     nsresult NewFileURI(nsIFile *aFile, nsIURI **_retval);
2750     nsresult NewChannelFromURI2(nsIURI *aURI, nsIDOMNode *aLoadingNode, nsIPrincipal *aLoadingPrincipal,
2751             nsIPrincipal *aTriggeringPrincipal, uint32_t aSecurityFlags, uint32_t aContentPolicyType,
2752             nsIChannel **_retval);
2753     nsresult NewChannelFromURI(nsIURI *aURI, nsIChannel **_retval);
2754     nsresult NewChannel2(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
2755             nsIDOMNode *aLoadingNode, nsIPrincipal *aLoadingPrincipal, nsIPrincipal *aTriggeringPrincipal,
2756             uint32_t aSecurityFlags, uint32_t aContentPolicyType, nsIChannel **_retval);
2757     nsresult NewChannel(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
2758                         nsIChannel **_retval);
2759     nsresult GetOffline(bool *aOffline);
2760     nsresult SetOffline(bool aOffline);
2761     nsresult SetAppOffline(uint32_t appId, int32_t state);
2762     nsresult IsAppOffline(uint32_t appId, bool *_retval);
2763     nsresult GetAppOfflineState(uint32_t appId, int32_t *_retval);
2764     nsresult AllowPort(int32_t aPort, const char *aScheme, bool *_retval);
2765     nsresult ExtractScheme(const nsACString *urlString, nsACString *_retval);
2766 }
2767
2768 [
2769     object,
2770     uuid(ca68c485-9db3-4c12-82a6-4fab7948e2d5),
2771     local,
2772 ]
2773 interface nsINetUtil : nsISupports
2774 {
2775     nsresult ParseContentType(const nsACString *aTypeHeader, nsACString *aCharset,
2776             bool *aHadCharset, nsACString *_retval);
2777     nsresult ProtocolHasFlags(nsIURI *aURI, uint32_t aFlag, bool *_retval);
2778     nsresult URIChainHasFlags(nsIURI *aURI, uint32_t aFlags, bool *_retval);
2779     nsresult ToImmutableURI(nsIURI *aURI, nsIURI **_retval);
2780     nsresult NewSimpleNestedURI(nsIURI *aURI, nsIURI **_retval);
2781     nsresult EscapeString(const nsACString *aString, uint32_t aEscapeType, nsACString *_retval);
2782     nsresult EscapeURL(const nsACString *aStr, uint32_t aFlags, nsACString *_retval);
2783     nsresult UnescapeString(const nsACString *aStr, uint32_t aFlags, nsACString *_retval);
2784     nsresult ExtractCharsetFromContentType(const nsACString *aTypeHeader, nsACString *aCharset,
2785             int32_t *aCharsetStart, int32_t *aCharsetEnd, bool *_retval);
2786 }
2787
2788 [
2789     object,
2790     uuid(9c5d3c58-1dd1-11b2-a1c9-f3699284657a),
2791     local
2792 ]
2793 interface nsIWebBrowserFocus : nsISupports
2794 {
2795     nsresult Activate();
2796     nsresult Deactivate();
2797     nsresult SetFocusAtFirstElement();
2798     nsresult SetFocusAtLastElement();
2799     nsresult GetFocusedWindow(nsIDOMWindow **aFocusedWindow);
2800     nsresult SetFocusedWindow(nsIDOMWindow *aFocusedWindow);
2801     nsresult GetFocusedElement(nsIDOMElement **aFocusedElement);
2802     nsresult SetFocusedElement(nsIDOMElement *aFocusedElement);
2803 }
2804
2805 [
2806     object,
2807     uuid(e8c414c4-dc38-4ba3-ab4e-ec4cbbe22907),
2808     local
2809 ]
2810 interface nsIWebBrowserChrome : nsISupports
2811 {
2812     nsresult SetStatus(uint32_t statusType, const PRUnichar *status);
2813     nsresult GetWebBrowser(nsIWebBrowser **aWebBrowser);
2814     nsresult SetWebBrowser(nsIWebBrowser *aWebBrowser);
2815     nsresult GetChromeFlags(uint32_t *aChromeFlags);
2816     nsresult SetChromeFlags(uint32_t aChromeFlags);
2817     nsresult DestroyBrowserWindow();
2818     nsresult SizeBrowserTo(int32_t aCX, int32_t aCY);
2819     nsresult ShowAsModal();
2820     nsresult IsWindowModal(bool *_retval);
2821     nsresult ExitModalEventLoop(nsresult aStatus);
2822 }
2823
2824 [
2825     object,
2826     uuid(df31c120-ded6-11d1-bd85-00805f8ae3f4),
2827     local
2828 ]
2829 interface nsIDOMEventListener : nsISupports
2830 {
2831     nsresult HandleEvent(nsIDOMEvent *event);
2832 }
2833
2834 [
2835     object,
2836     uuid(9a78ac3c-9507-4d00-b2d6-10b508d2ec31),
2837     local
2838 ]
2839 interface nsIDOMEventTarget : nsISupports
2840 {
2841     nsresult AddEventListener(const nsAString *type, nsIDOMEventListener *listener, bool useCapture, bool wantsUntrusted, uint8_t _argc);
2842     nsresult AddSystemEventListener(const nsAString *type, nsIDOMEventListener *listener, bool aUseCapture, bool aWantsUntrusted, uint8_t _argc);
2843     nsresult RemoveEventListener(const nsAString *type, nsIDOMEventListener *listener, bool useCapture);
2844     nsresult RemoveSystemEventListener(const nsAString *type, nsIDOMEventListener *listener, bool aUseCapture);
2845     nsresult DispatchEvent(nsIDOMEvent *evt, bool *_retval);
2846
2847     /* Followed by methods we should try to avoid using */
2848 }
2849
2850 [
2851     object,
2852     uuid(02d54f52-a1f5-4ad2-b560-36f14012935e),
2853     local
2854 ]
2855 interface nsIDOMEvent : nsISupports
2856 {
2857     nsresult GetType(nsAString *aType);
2858     nsresult GetTarget(nsIDOMEventTarget **aTarget);
2859     nsresult GetCurrentTarget(nsIDOMEventTarget **aCurrentTarget);
2860     nsresult GetEventPhase(uint16_t *aEventPhase);
2861     nsresult GetBubbles(bool *aBubbles);
2862     nsresult GetCancelable(bool *aCancelable);
2863     nsresult GetTimeStamp(DOMTimeStamp *aTimeStamp);
2864     nsresult StopPropagation();
2865     nsresult PreventDefault();
2866     nsresult InitEvent(const nsAString *eventTypeArg, bool canBubbleArg, bool cancelableArg);
2867     nsresult GetDefaultPrevented(bool *aDefaultPrevented);
2868     nsresult StopImmediatePropagation();
2869     nsresult GetOriginalTarget(nsIDOMEventTarget **aOriginalTarget);
2870     nsresult GetExplicitOriginalTarget(nsIDOMEventTarget * *aExplicitOriginalTarget);
2871     nsresult GetPreventDefault(bool *_retval);
2872     nsresult GetIsTrusted(bool *aIsTrusted);
2873     nsresult DuplicatePrivateData();
2874     nsresult SetTarget(nsIDOMEventTarget *aTarget);
2875     bool IsDispatchStopped();
2876     /*nsEvent*/ void *GetInternalNSEvent();
2877     void SetTrusted(bool aTrusted);
2878     void Serialize(/*IPC::Message*/ void *aMsg, bool aSerializeInterfaceType);
2879     bool Deserialize(const /*IPC::Message*/ void *aMsg, void **aIter);
2880     void SetOwner(void /*mozilla::dom::EventTarget*/ *aOwner);
2881     void /*nsDOMEvent*/ *InternalDOMEvent();
2882 }
2883
2884 [
2885     object,
2886     uuid(9621eb05-b498-4e87-a012-95d817987624),
2887     local
2888 ]
2889 interface nsIDOMWindowUtils : nsISupports
2890 {
2891     nsresult GetImageAnimationMode(uint16_t *aImageAnimationMode);
2892     nsresult SetImageAnimationMode(uint16_t aImageAnimationMode);
2893     nsresult GetDocCharsetIsForced(bool *aDocCharsetIsForced);
2894     nsresult GetCursorType(int16_t *_retval);
2895     nsresult GetDocumentMetadata(const nsAString *aName, nsAString *_retval);
2896     nsresult Redraw(uint32_t aCount, uint32_t *_retval);
2897     nsresult UpdateLayerTree();
2898     nsresult SetCSSViewport(float aWidthPx, float aHeightPx);
2899     nsresult GetViewportInfo(uint32_t aDisplayWidth, uint32_t aDisplayHeight, double *aDefaultZoom, bool *aAllowZoom,
2900             double *aMinZoom, double *aMaxZoom, uint32_t *aWidth, uint32_t *aHeight, bool *aAutoSize);
2901     nsresult SetDisplayPortForElement(float aXPx, float aYPx, float aWidthPx, float aHeightPx,
2902             nsIDOMElement *aElement, uint32_t aPriority);
2903     nsresult SetDisplayPortMarginsForElement(float aLeftMargin, float aTopMargin, float aRightMargin, float aBottomMargin,
2904             uint32_t aAlignmentX, uint32_t aAlignmentY, nsIDOMElement *aElement, uint32_t aPriority);
2905     nsresult SetDisplayPortBaseForElement(int32_t aX, int32_t aY, int32_t aWidth, int32_t aHeight, nsIDOMElement *aElement);
2906     nsresult SetResolution(float aXResolution, float aYResolution);
2907     nsresult GetResolution(float *aXResolution, float *aYResolution);
2908     nsresult GetIsResolutionSet(bool *aIsResolutionSet);
2909     nsresult GetIsFirstPaint(bool *aIsFirstPaint);
2910     nsresult SetIsFirstPaint(bool aIsFirstPaint);
2911     nsresult GetPresShellId(uint32_t *aPresShellId);
2912     nsresult SendMouseEvent(const nsAString *aType, float aX, float aY, int32_t aButton, int32_t aClickCount,
2913             int32_t aModifiers, bool aIgnoreRootScrollFrame, float aPressure, uint16_t aInputSourceArg, bool aIsSynthesized,
2914             uint8_t _argc, bool *_retval);
2915     nsresult SendPointerEvent(const nsAString *aType, float aX, float aY, int32_t aButton, int32_t aClickCount,
2916             int32_t aModifiers, bool aIgnoreRootScrollFrame, float aPressure, uint16_t aInputSourceArg, int32_t aPointerId,
2917             int32_t aWidth, int32_t aHeight, int32_t tiltX, int32_t tiltY, bool aIsPrimary, bool aIsSynthesized,
2918             uint8_t _argc, bool *_retval);
2919     nsresult SendTouchEvent(const nsAString *aType, uint32_t *aIdentifiers, int32_t *aXs, int32_t *aYs,
2920             uint32_t *aRxs, uint32_t *aRys, float *aRotationAngles, float *aForces, uint32_t count, int32_t aModifiers,
2921             bool aIgnoreRootScrollFrame, bool *_retval);
2922     nsresult SendMouseEventToWindow(const nsAString *aType, float aX, float aY, int32_t aButton, int32_t aClickCount,
2923             int32_t aModifiers, bool aIgnoreRootScrollFrame, float aPressure, uint16_t aInputSourceArg, bool aIsSynthesized,
2924             uint8_t _argc);
2925     nsresult SendPointerEventToWindow(const nsAString *aType, float aX, float aY, int32_t aButton, int32_t aClickCount,
2926             int32_t aModifiers, bool aIgnoreRootScrollFrame, float aPressure, uint16_t aInputSourceArg, int32_t aPointerId,
2927             int32_t aWidth, int32_t aHeight, int32_t aTiltX, int32_t aTiltY, bool aIsPrimary, bool aIsSynthesized, uint8_t _argc);
2928     nsresult SendTouchEventToWindow(const nsAString *aType, uint32_t *aIdentifiers, int32_t *aXs, int32_t *aYs, uint32_t *aRxs,
2929             uint32_t *aRys, float *aRotationAngles, float *aForces, uint32_t count, int32_t aModifiers,
2930             bool aIgnoreRootScrollFrame, bool *_retval);
2931     nsresult SendWheelEvent(float aX, float aY, double aDeltaX, double aDeltaY, double aDeltaZ, uint32_t aDeltaMode,
2932            int32_t aModifiers, int32_t aLineOrPageDeltaX, int32_t aLineOrPageDeltaY, uint32_t aOptions);
2933     nsresult SendKeyEvent(const nsAString *aType, int32_t aKeyCode, int32_t aCharCode, int32_t aModifiers,
2934            uint32_t aAdditionalFlags, bool *_retval);
2935     nsresult SendNativeKeyEvent(int32_t aNativeKeyboardLayout, int32_t aNativeKeyCode, int32_t aModifierFlags,
2936            const nsAString *aCharacters, const nsAString *aUnmodifiedCharacters);
2937     nsresult SendNativeMouseEvent(int32_t aScreenX, int32_t aScreenY, int32_t aNativeMessage, int32_t aModifierFlags,
2938            nsIDOMElement *aElement);
2939     nsresult SendNativeMouseScrollEvent(int32_t aScreenX, int32_t aScreenY, uint32_t aNativeMessage, double aDeltaX,
2940            double aDeltaY, double aDeltaZ, uint32_t aModifierFlags, uint32_t aAdditionalFlags, nsIDOMElement *aElement);
2941     nsresult SendNativeTouchPoint(uint32_t aPointerId, uint32_t aTouchState, int32_t aScreenX, int32_t aScreenY,
2942            double aPressure, uint32_t aOrientation);
2943     nsresult SendNativeTouchTap(int32_t aScreenX, int32_t aScreenY, bool aLongTap);
2944     nsresult ClearNativeTouchSequence();
2945     nsresult ActivateNativeMenuItemAt(const nsAString *indexString);
2946     nsresult ForceUpdateNativeMenuAt(const nsAString *indexString);
2947     nsresult Focus(nsIDOMElement *aElement);
2948     nsresult GarbageCollect(nsICycleCollectorListener *aListener, int32_t aExtraForgetSkippableCalls);
2949     nsresult CycleCollect(nsICycleCollectorListener *aListener, int32_t aExtraForgetSkippableCalls);
2950     nsresult RunNextCollectorTimer();
2951     nsresult SendSimpleGestureEvent(const nsAString *aType, float aX, float aY, uint32_t aDirection, double aDelta,
2952            int32_t aModifiers, uint32_t aClickCount);
2953     nsresult ElementFromPoint(float aX, float aY, bool aIgnoreRootScrollFrame, bool aFlushLayout, nsIDOMElement **_retval);
2954     nsresult NodesFromRect(float aX, float aY, float aTopSize, float aRightSize, float aBottomSize, float aLeftSize,
2955            bool aIgnoreRootScrollFrame, bool aFlushLayout, nsIDOMNodeList **_retval);
2956     nsresult GetTranslationNodes(nsIDOMNode *aRoot, int /*nsITranslationNodeList*/ **_retval);
2957     nsresult CompareCanvases(nsIDOMHTMLCanvasElement *aCanvas1, nsIDOMHTMLCanvasElement *aCanvas2,
2958            uint32_t *aMaxDifference, uint32_t *_retval);
2959     nsresult GetIsMozAfterPaintPending(bool *aIsMozAfterPaintPending);
2960     nsresult SuppressEventHandling(bool aSuppress);
2961     nsresult ClearMozAfterPaintEvents();
2962     nsresult DisableNonTestMouseEvents(bool aDisable);
2963     nsresult GetScrollXY(bool aFlushLayout, int32_t *aScrollX, int32_t *aScrollY);
2964     nsresult GetScrollXYFloat(bool aFlushLayout, float *aScrollX, float *aScrollY);
2965     nsresult GetScrollbarSize(bool aFlushLayout, int32_t *aWidth, int32_t *aHeight);
2966     nsresult GetBoundsWithoutFlushing(nsIDOMElement *aElement, nsIDOMClientRect **_retval);
2967     nsresult GetRootBounds(nsIDOMClientRect **_retval);
2968     nsresult GetIMEIsOpen(bool *aIMEIsOpen);
2969     nsresult GetIMEStatus(uint32_t *aIMEStatus);
2970     nsresult GetScreenPixelsPerCSSPixel(float *aScreenPixelsPerCSSPixel);
2971     nsresult GetFullZoom(float *aFullZoom);
2972     nsresult DispatchDOMEventViaPresShell(nsIDOMNode *aTarget, nsIDOMEvent *aEvent, bool aTrusted, bool *_retval);
2973     nsresult DispatchEventToChromeOnly(nsIDOMEventTarget *aTarget, nsIDOMEvent *aEvent, bool *_retval);
2974     nsresult GetClassName(const /*JS::Value*/ void *aObject, JSContext *cx, char **_retval);
2975     nsresult SendContentCommandEvent(const nsAString *aType, nsITransferable *aTransferable);
2976     nsresult SendCompositionEvent(const nsAString *aType, const nsAString *aData, const nsAString *aLocale);
2977     nsresult CreateCompositionStringSynthesizer(int /*nsICompositionStringSynthesizer*/ **_retval);
2978     nsresult SendQueryContentEvent(uint32_t aType, uint32_t aOffset, uint32_t aLength, int32_t aX, int32_t aY,
2979             uint32_t aAdditionalFlags, nsIQueryContentEventResult **_retval);
2980     nsresult RemoteFrameFullscreenChanged(nsIDOMElement *aFrameElement, const nsAString *aNewOrigin);
2981     nsresult RemoteFrameFullscreenReverted();
2982     nsresult ExitFullscreen();
2983     nsresult SendSelectionSetEvent(uint32_t aOffset, uint32_t aLength, uint32_t aAdditionalFlags, bool *_retval);
2984     nsresult SelectAtPoint(float aX, float aY, uint32_t aSelectBehavior, bool *_retval);
2985     nsresult GetVisitedDependentComputedStyle(nsIDOMElement *aElement, const nsAString *aPseudoElement,
2986            const nsAString *aPropertyName, nsAString *_retval);
2987     nsresult GetParent(const /*JS::Value*/ void *obj, JSContext *cx, /*JS::Value*/ void *_retval);
2988     nsresult GetOuterWindowID(uint64_t *aOuterWindowID);
2989     nsresult GetCurrentInnerWindowID(uint64_t *aCurrentInnerWindowID);
2990     nsresult EnterModalState();
2991     nsresult LeaveModalState();
2992     nsresult IsInModalState(bool *_retval);
2993     nsresult SuspendTimeouts();
2994     nsresult ResumeTimeouts();
2995     nsresult GetLayerManagerType(nsAString *aLayerManagerType);
2996     nsresult GetLayerManagerRemote(bool *aLayerManagerRemote);
2997     nsresult StartFrameTimeRecording(uint32_t *startIndex);
2998     nsresult StopFrameTimeRecording(uint32_t startIndex, uint32_t *frameCount, float **frameIntervals);
2999     nsresult BeginTabSwitch();
3000     nsresult GetDisplayDPI(float *aDisplayDPI);
3001     nsresult GetOuterWindowWithId(uint64_t aOuterWindowID, nsIDOMWindow **_retval);
3002     nsresult GetContainerElement(nsIDOMElement **aContainerElement);
3003     nsresult RenderDocument(const void /*nsRect*/ *aRect, uint32_t aFlags, int /*nscolor*/ aBackgroundColor,
3004            void /*gfxContext*/ *aThebesContext);
3005     nsresult AdvanceTimeAndRefresh(int64_t aMilliseconds);
3006     nsresult RestoreNormalRefresh();
3007     nsresult GetIsTestControllingRefreshes(bool *aIsTestControllingRefreshes);
3008     nsresult SetAsyncScrollOffset(nsIDOMNode *aNode, int32_t aX, int32_t aY);
3009     nsresult ComputeAnimationDistance(nsIDOMElement *element, const nsAString *property, const nsAString *value1,
3010            const nsAString *value2, double *_retval);
3011     nsresult WrapDOMFile(nsIFile *aFile, nsIDOMFile **_retval);
3012     nsresult GetFocusedInputType(char **aFocusedInputType);
3013     nsresult FindElementWithViewId(long /*nsViewID*/ aId, nsIDOMElement **_retval);
3014     nsresult GetViewId(nsIDOMElement *aElement, long /*nsViewID*/ *_retval);
3015     nsresult LeafLayersPartitionWindow(bool *_retval);
3016     nsresult GetMayHaveTouchEventListeners(bool *aMayHaveTouchEventListeners);
3017     nsresult CheckAndClearPaintedState(nsIDOMElement *aElement, bool *_retval);
3018     nsresult GetFileId(const /*JS::Value*/ void *aFile, JSContext *cx, int64_t *_retval);
3019     nsresult GetFilePath(void /*JS::HandleValue*/ *aFile, JSContext *cx, nsAString *_retval);
3020     nsresult GetFileReferences(const nsAString *aDatabaseName, int64_t aId, void /*JS::HandleValue*/ *aOptions,
3021            int32_t *aRefCnt, int32_t *aDBRefCnt, int32_t *aSliceRefCnt, JSContext* cx, bool *_retval);
3022     nsresult IsIncrementalGCEnabled(JSContext *cx, bool *_retval);
3023     nsresult StartPCCountProfiling(JSContext *cx);
3024     nsresult StopPCCountProfiling(JSContext *cx);
3025     nsresult PurgePCCounts(JSContext *cx);
3026     nsresult GetPCCountScriptCount(JSContext *cx, int32_t *_retval);
3027     nsresult GetPCCountScriptSummary(int32_t script, JSContext *cx, nsAString *_retval);
3028     nsresult GetPCCountScriptContents(int32_t script, JSContext *cx, nsAString *_retval);
3029     nsresult GetPaintingSuppressed(bool *aPaintingSuppressed);
3030     nsresult GetPlugins(JSContext *cx, /*JS::Value*/ void *aPlugins);
3031     nsresult SetScrollPositionClampingScrollPortSize(float aWidth, float aHeight);
3032     nsresult SetContentDocumentFixedPositionMargins(float aTop, float aRight, float aBottom, float aLeft);
3033     nsresult DisableDialogs();
3034     nsresult EnableDialogs();
3035     nsresult AreDialogsEnabled(bool *_retval);
3036     nsresult LoadSheet(nsIURI *sheetURI, uint32_t type);
3037     nsresult LoadSheetUsingURIString(const nsACString *sheetURI, uint32_t type);
3038     nsresult AddSheet(nsIDOMStyleSheet *sheet, uint32_t type);
3039     nsresult RemoveSheet(nsIURI *sheetURI, uint32_t type);
3040     nsresult  RemoveSheetUsingURIString(const nsACString *sheetURI, uint32_t type);
3041     nsresult GetIsHandlingUserInput(bool *aIsHandlingUserInput);
3042     nsresult AllowScriptsToClose();
3043     nsresult GetIsParentWindowMainWidgetVisible(bool *aIsParentWindowMainWidgetVisible);
3044     nsresult IsNodeDisabledForEvents(nsIDOMNode *aNode, bool *_retval);
3045     nsresult GetPaintFlashing(bool *aPaintFlashing);
3046     nsresult SetPaintFlashing(bool aPaintFlashing);
3047     nsresult RunInStableState(nsIRunnable *runnable);
3048     nsresult RunBeforeNextEvent(nsIRunnable *runnable);
3049     nsresult GetOMTAStyle(nsIDOMElement *aElement, const nsAString *aProperty, nsAString *_retval);
3050     nsresult RequestCompositorProperty(const nsAString *aProperty, float *_retval);
3051     nsresult SetHandlingUserInput(bool aHandlingInput, void /*nsIJSRAIIHelper*/ **_retval);
3052     nsresult GetContentAPZTestData(JSContext *cx, int /*JS::MutableHandleValue*/ _retval);
3053     nsresult GetCompositorAPZTestData(JSContext *cx, void /*JS::MutableHandleValue*/ *_retval);
3054     nsresult GetAudioMuted(bool *aAudioMuted) ;
3055     nsresult SetAudioMuted(bool aAudioMuted);
3056     nsresult GetAudioVolume(float *aAudioVolume);
3057     nsresult SetAudioVolume(float aAudioVolume);
3058     nsresult XpconnectArgument(nsIDOMWindowUtils *aThis);
3059     nsresult AskPermission(void /*nsIContentPermissionRequest*/ *aRequest);
3060 }
3061
3062 cpp_quote("#define CONTEXT_NONE              0x00")
3063 cpp_quote("#define CONTEXT_LINK              0x01")
3064 cpp_quote("#define CONTEXT_IMAGE             0x02")
3065 cpp_quote("#define CONTEXT_DOCUMENT          0x04")
3066 cpp_quote("#define CONTEXT_TEXT              0x08")
3067 cpp_quote("#define CONTEXT_INPUT             0x10")
3068 cpp_quote("#define CONTEXT_BACKGROUND_IMAGE  0x20")
3069
3070 [
3071     object,
3072     uuid(3478b6b0-3875-11d4-94ef-0020183bf181),
3073     local
3074 ]
3075 interface nsIContextMenuListener : nsISupports
3076 {
3077     nsresult OnShowContextMenu(uint32_t aContextFlags, nsIDOMEvent *aEvent, nsIDOMNode *aNode);
3078 }
3079
3080 [
3081     object,
3082     uuid(d73852f8-7bd6-477d-8233-117dbf83860b),
3083     local
3084 ]
3085 interface nsIDOMUIEvent : nsIDOMEvent
3086 {
3087     nsresult GetView(nsIDOMWindow **aView);
3088     nsresult GetDetail(int32_t *aDetail);
3089     nsresult InitUIEvent(const nsAString *typeArg, bool canBubbleArg, bool cancelableArg,
3090             nsIDOMWindow *viewArg, int32_t detailArg);
3091     nsresult GetLayerX(int32_t *aLayerX);
3092     nsresult GetLayerY(int32_t *aLayerY);
3093     nsresult GetPageX(int32_t *aPageX);
3094     nsresult GetPageY(int32_t *aPageY);
3095     nsresult GetWhich(uint32_t *aWhich);
3096     nsresult GetRangeParent(nsIDOMNode **aRangeParent);
3097     nsresult GetRangeOffset(int32_t *aRangeOffset);
3098     nsresult GetCancelBubble(bool *aCancelBubble);
3099     nsresult SetCancelBubble(bool aCancelBubble);
3100     nsresult GetIsChar(bool *aIsChar);
3101 }
3102
3103 [
3104     object,
3105     uuid(df068636-9a5b-11e3-b71f-2c27d728e7f9),
3106     local
3107 ]
3108 interface nsIDOMMouseEvent : nsIDOMUIEvent
3109 {
3110     nsresult GetScreenX(int32_t *aScreenX);
3111     nsresult GetScreenY(int32_t *aScreenY);
3112     nsresult GetMozMovementX(int32_t *aMozMovementX);
3113     nsresult GetMozMovementY(int32_t *aMozMovementY);
3114     nsresult GetClientX(int32_t *aClientX);
3115     nsresult GetClientY(int32_t *aClientY);
3116     nsresult GetCtrlKey(bool *aCtrlKey);
3117     nsresult GetShiftKey(bool *aShiftKey);
3118     nsresult GetAltKey(bool *aAltKey);
3119     nsresult GetMetaKey(bool *aMetaKey);
3120     nsresult GetButton(int16_t *aButton);
3121     nsresult GetButtons(uint16_t *aButtons);
3122     nsresult GetRelatedTarget(nsIDOMEventTarget **aRelatedTarget);
3123     nsresult InitMouseEvent(const nsAString *typeArg, bool canBubbleArg, bool cancelableArg,
3124             nsIDOMWindow *viewArg, int32_t detailArg, int32_t screenXArg, int32_t screenYArg,
3125             int32_t clientXArg, int32_t clientYArg, bool ctrlKeyArg, bool altKeyArg,
3126             bool shiftKeyArg, bool metaKeyArg, uint16_t buttonArg,
3127             nsIDOMEventTarget *relatedTargetArg);
3128     nsresult GetMozPressure(float *aMozPressure);
3129     nsresult GetMozInputSource(uint16_t *aMozInputSource);
3130     nsresult InitNSMouseEvent(const nsAString *typeArg, bool canBubbleArg, bool cancelableArg,
3131             nsIDOMWindow *viewArg, int32_t detailArg, int32_t screenXArg, int32_t screenYArg,
3132             int32_t clientXArg, int32_t clientYArg, bool ctrlKeyArg, bool altKeyArg, bool shiftKeyArg,
3133             bool metaKeyArg, uint16_t buttonArg, nsIDOMEventTarget *relatedTargetArg, float pressure,
3134             uint16_t inputSourceArg);
3135     nsresult GetModifierState(const nsAString *keyArg, bool *_retval);
3136 }
3137
3138 [
3139     object,
3140     uuid(d2b3e35f-8627-4732-a92d-cda54c8f8054),
3141     local
3142 ]
3143 interface nsIDOMKeyEvent : nsIDOMUIEvent
3144 {
3145     nsresult GetCharCode(uint32_t *aCharCode);
3146     nsresult GetKeyCode(uint32_t *aKeyCode);
3147     nsresult GetAltKey(bool *aAltKey);
3148     nsresult GetCtrlKey(bool *aCtrlKey);
3149     nsresult GetShiftKey(bool *aShiftKey);
3150     nsresult GetMetaKey(bool *aMetaKey);
3151     nsresult InitKeyEvent(const nsAString *typeArg, bool canBubbleArg,
3152             bool cancelableArg, nsIDOMWindow *viewArg, bool ctrlKeyArg,
3153             bool altKeyArg, bool shiftKeyArg, bool metaKeyArg, uint32_t keyCodeArg,
3154             uint32_t charCodeArg);
3155     nsresult GetModifierState(const nsAString *keyArg, bool *_retval);
3156     nsresult GetLocation(uint32_t *aLocation);
3157     nsresult GetRepeat(bool *aRepeat);
3158     nsresult GetKey(nsAString *aKey);
3159 }
3160
3161 [
3162     object,
3163     uuid(0b976267-4aaa-4f36-a2d4-27b5ca8d73bb),
3164     local
3165 ]
3166 interface nsIEmbeddingSiteWindow : nsISupports
3167 {
3168     nsresult SetDimensions(uint32_t flags, int32_t x, int32_t y, int32_t cx, int32_t cy);
3169     nsresult GetDimensions(uint32_t flags, int32_t *x, int32_t *y, int32_t *cx, int32_t *cy);
3170     nsresult SetFocus();
3171     nsresult GetVisibility(bool *aVisibility);
3172     nsresult SetVisibility(bool aVisibility);
3173     nsresult GetTitle(PRUnichar **aTitle);
3174     nsresult SetTitle(const PRUnichar *aTitle);
3175     nsresult GetSiteWindow(void **aSiteWindow);
3176     nsresult Blur();
3177 }
3178
3179 [
3180     object,
3181     uuid(2417cbfe-65ad-48a6-b4b6-eb84db174392),
3182     local
3183 ]
3184 interface nsIComponentRegistrar : nsISupports
3185 {
3186     nsresult AutoRegister(nsIFile *aSpec);
3187     nsresult AutoUnregister(nsIFile *aSpec);
3188     nsresult RegisterFactory(const nsCID *aClass, const char *aClassName,
3189             const char *aContractID, nsIFactory *aFactory);
3190     nsresult UnregisterFactory(const nsCID *aClass, nsIFactory *aFactory);
3191     nsresult RegisterFactoryLocation(const nsCID *aClass, const char *aClassName,
3192             const char *aContractID, nsIFile *aFile, const char *aLoaderStr,
3193             const char *aType);
3194     nsresult UnregisterFactoryLocation(const nsCID *aClass, nsIFile *aFile);
3195     nsresult IsCIDRegistered(const nsCID *aClass, bool *_retval);
3196     nsresult IsContractIDRegistered(const char *aContractID, bool *_retval);
3197     nsresult EnumerateCIDs(nsISimpleEnumerator **_retval);
3198     nsresult EnumerateContractIDs(nsISimpleEnumerator **_retval);
3199     nsresult CIDToContractID(const nsCID *aClass, char **_retval);
3200     nsresult ContractIDToCID(const char *aContractID, nsCID **_retval);
3201 }
3202
3203 [
3204     object,
3205     uuid(1630c61a-325e-49ca-8759-a31b16c47aa5),
3206     local
3207 ]
3208 interface nsIPromptService : nsISupports
3209 {
3210     nsresult Alert(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
3211             const PRUnichar *aText);
3212     nsresult AlertCheck(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
3213             const PRUnichar *aText, const PRUnichar *aCheckMsg, bool *aCheckState);
3214     nsresult Confirm(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
3215             const PRUnichar *aText, bool *_retval);
3216     nsresult ConfirmCheck(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
3217             const PRUnichar *aText, const PRUnichar *aCheckMsg, bool *aCheckState,
3218             bool *_retval);
3219     nsresult ConfirmEx(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
3220             const PRUnichar *aText, uint32_t aButtonFlags, const PRUnichar *aButton0Title,
3221             const PRUnichar *aButton1Title, const PRUnichar *aButton2Title,
3222             const PRUnichar *aCheckMsg, bool *aCheckState, int32_t *_retval);
3223     nsresult Prompt(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
3224             const PRUnichar *aText, PRUnichar **aValue, const PRUnichar *aCheckMsg,
3225             bool *aCheckState, bool *_retval);
3226     nsresult PromptUsernameAndPassword(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
3227             const PRUnichar *aText, PRUnichar **aUsername, PRUnichar **aPassword,
3228             const PRUnichar *aCheckMsg, bool *aCheckState, bool *_retval);
3229     nsresult PromptPassword(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
3230             const PRUnichar *aText, PRUnichar **aPassword, const PRUnichar *aCheckMsg,
3231             bool *aCheckState, bool *_retval);
3232     nsresult Select(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
3233             const PRUnichar *aText, uint32_t aCount, const PRUnichar **aSelectList,
3234             int32_t *aOutSelection, bool *_retval);
3235 }
3236
3237 [
3238     object,
3239     uuid(b128a1e6-44f3-4331-8fbe-5af360ff21ee),
3240     local
3241 ]
3242 interface nsITooltipTextProvider : nsISupports
3243 {
3244     nsresult GetNodeText(nsIDOMNode *aNode, PRUnichar **aText, bool *_retval);
3245 }
3246
3247 [
3248     object,
3249     uuid(24f3f4da-18a4-448d-876d-7360fefac029),
3250     local
3251 ]
3252 interface nsIEditingSession : nsISupports
3253 {
3254     nsresult GetEditorStatus(uint32_t *aEditorStatus);
3255     nsresult MakeWindowEditable(nsIDOMWindow *window, const char *aEditorType,
3256             bool doAfterUriLoad, bool aMakeWholeDocumentEditable, bool aInteractive);
3257     nsresult WindowIsEditable(nsIDOMWindow *window, bool *_retval);
3258     nsresult GetEditorForWindow(nsIDOMWindow *window, nsIEditor **_retval);
3259     nsresult SetupEditorOnWindow(nsIDOMWindow *window);
3260     nsresult TearDownEditorOnWindow(nsIDOMWindow *window);
3261     nsresult SetEditorOnControllers(nsIDOMWindow *aWindow, nsIEditor *aEditor);
3262     nsresult DisableJSAndPlugins(nsIDOMWindow *aWindow);
3263     nsresult RestoreJSAndPlugins(nsIDOMWindow *aWindow);
3264     nsresult DetachFromWindow(nsIDOMWindow *aWindow);
3265     nsresult ReattachToWindow(nsIDOMWindow *aWindow);
3266     nsresult GetJsAndPluginsDisabled(bool *aJsAndPluginsDisabled);
3267 }
3268
3269 [
3270     object,
3271     uuid(b1fdf3c4-74e3-4f7d-a14d-2b76bcf53482),
3272     local
3273 ]
3274 interface nsICommandParams : nsISupports
3275 {
3276     nsresult GetValueType(const char *name, int16_t *_retval);
3277     nsresult GetBooleanValue(const char *name, bool *_retval);
3278     nsresult GetLongValue(const char *name, int32_t *_retval);
3279     nsresult GetDoubleValue(const char *name, double *_retval);
3280     nsresult GetStringValue(const char *name, nsAString *_retval);
3281     nsresult GetCStringValue(const char *name, char **_retval);
3282     nsresult GetISupportsValue(const char *name, nsISupports **_retval);
3283     nsresult SetBooleanValue(const char *name, bool value);
3284     nsresult SetLongValue(const char *name, int32_t value);
3285     nsresult SetDoubleValue(const char *name, double value);
3286     nsresult SetStringValue(const char *name, const nsAString *value);
3287     nsresult SetCStringValue(const char *name, const char *value);
3288     nsresult SetISupportsValue(const char *name, nsISupports *value);
3289     nsresult RemoveValue(const char *name);
3290 }
3291
3292 [
3293     object,
3294     uuid(080d2001-f91e-11d4-a73c-f9242928207c),
3295     local
3296 ]
3297 interface nsICommandManager : nsISupports
3298 {
3299     nsresult AddCommandObserver(nsIObserver *aCommandObserver, const char *aCommandToObserve);
3300     nsresult RemoveCommandObserver(nsIObserver *aCommandObserver, const char *aCommandObserved);
3301     nsresult IsCommandSupported(const char *aCommandName, nsIDOMWindow *aTargetWindow, bool *_retval);
3302     nsresult IsCommandEnabled(const char *aCommandName, nsIDOMWindow *aTargetWindow, bool *_retval);
3303     nsresult GetCommandState(const char *aCommandName, nsIDOMWindow *aTargetWindow,
3304             nsICommandParams *aCommandParams);
3305     nsresult DoCommand(const char *aCommandName, nsICommandParams *aCommandParams,
3306             nsIDOMWindow *aTargetWindow);
3307 }
3308
3309 [
3310     object,
3311     uuid(3275b2cd-af6d-429a-80d7-f0c5120342ac),
3312     local
3313 ]
3314 interface nsICategoryManager : nsISupports
3315 {
3316     nsresult GetCategoryEntry(const char *aCategory, const char *aEntry, char **_retval);
3317     nsresult AddCategoryEntry(const char *aCategory, const char *aEntry, const char *aValue, bool aPersist,
3318             bool aReplace, char **_retval);
3319     nsresult DeleteCategoryEntry(const char *aCategory, const char *aEntry, bool aPersist);
3320     nsresult DeleteCategory(const char *aCategory);
3321     nsresult EnumerateCategory(const char *aCategory, nsISimpleEnumerator **_retval);
3322     nsresult EnumerateCategories(nsISimpleEnumerator **_retval);
3323 }
3324
3325 [
3326     object,
3327     uuid(47b82b60-a36f-4167-8072-6f421151ed50),
3328     local
3329 ]
3330 interface nsIControllerContext : nsISupports
3331 {
3332     nsresult Init(nsIControllerCommandTable *aCommandTable);
3333     nsresult SetCommandContext(nsISupports *aCommandContext);
3334 }
3335
3336 [
3337     object,
3338     uuid(d5b61b82-1da4-11d3-bf87-00105a1b0627),
3339     local
3340 ]
3341 interface nsIController : nsISupports
3342 {
3343     nsresult IsCommandEnabled(const char *command, bool *_retval);
3344     nsresult SupportsCommand(const char *command, bool *_retval);
3345     nsresult DoCommand(const char *command);
3346     nsresult OnEvent(const char *eventName);
3347 }
3348
3349 [
3350     object,
3351     uuid(697a2fe1-5549-48e7-9a1a-c29dab14e239),
3352     local
3353 ]
3354 interface nsIContent : nsISupports
3355 {
3356     /* This is not a real interface declaration. It's too internal for us. */
3357 }
3358
3359 [
3360     object,
3361     uuid(f63d2f6e-d1c1-49b9-8826-d59e5d722a42),
3362     local
3363 ]
3364 interface nsIDocument : nsISupports
3365 {
3366     /* This is not a real interface declaration. It's too internal for us. */
3367 }
3368
3369 [
3370     object,
3371     uuid(b1ee32f2-b8c4-49b9-93df-b6fab5d54688),
3372     local
3373 ]
3374 interface nsIContentSerializer : nsISupports
3375 {
3376     nsresult Init(uint32_t flags, uint32_t aWrapColumn, const char *aCharSet, bool aIsCopying,
3377             bool aIsWholeDocument);
3378     nsresult AppendText(nsIContent *aText, int32_t aStartOffset, int32_t aEndOffset, nsAString *aStr);
3379     nsresult AppendCDATASection(nsIContent *aCDATASection, int32_t aStartOffset,
3380             int32_t aEndOffset, nsAString *aStr);
3381     nsresult AppendProcessingInstruction(nsIContent *aPI, int32_t aStartOffset,
3382             int32_t aEndOffset, nsAString *aStr);
3383     nsresult AppendComment(nsIContent *aComment, int32_t aStartOffset, int32_t aEndOffset,
3384             nsAString *aStr);
3385     nsresult AppendDoctype(nsIContent *aDoctype, nsAString *aStr);
3386     nsresult AppendElementStart(nsIContent *aElement, nsIContent *aOriginalElement,
3387                                 nsAString *aStr);
3388     nsresult AppendElementEnd(nsIContent *aElement, nsAString *aStr);
3389     nsresult Flush(nsAString *aStr);
3390     nsresult AppendDocumentStart(nsIDocument *aDocument, nsAString *aStr);
3391 }
3392
3393 [
3394     object,
3395     uuid(094be624-f0bf-400f-89e2-6a84baab9474),
3396     local
3397 ]
3398 interface nsIEditor  : nsISupports
3399 {
3400     nsresult GetSelection([out] nsISelection *_retval);
3401     nsresult FinalizeSelection();
3402     nsresult Init([in] nsIDOMDocument *doc, nsIContent *aRoot, nsISelectionController *aSelCon, uint32_t aFlags, nsAString *initialValue);
3403     nsresult SetAttributeOrEquivalent([in] nsIDOMElement *element, [in] const nsAString *sourceAttrName, [in] const nsAString *sourceAttrValue, [in] bool aSuppressTransaction);
3404     nsresult RemoveAttributeOrEquivalent([in] nsIDOMElement *element, [in] const nsAString *sourceAttrName, [in] bool aSuppressTransaction);
3405     nsresult PostCreate();
3406     nsresult PreDestroy();
3407     nsresult GetFlags([out] uint32_t *_retval);
3408     nsresult SetFlags([in] uint32_t val);
3409     nsresult GetContentsMIMEType([out] char **_retval);
3410     nsresult SetContentsMIMEType([in] const char *val);
3411     nsresult GetIsDocumentEditable([out] bool *_retval);
3412     nsresult GetIsSelectionEditable(bool *aIsSelectionEditable);
3413     nsresult GetDocument([out] nsIDOMDocument **_retval);
3414     nsresult GetRootElement([out] nsIDOMElement **_retval);
3415     nsresult GetSelectionController([out] nsISelectionController **_retval);
3416     nsresult DeleteSelection(int16_t action, int16_t aStripWrappers);
3417     nsresult GetDocumentIsEmpty([out] bool *_retval);
3418     nsresult GetDocumentModified([out] bool *_retval);
3419     nsresult GetDocumentCharacterSet([out] nsACString *_retval);
3420     nsresult SetDocumentCharacterSet([in] const nsACString *val);
3421     nsresult ResetModificationCount();
3422     nsresult GetModificationCount([out] int32_t *_retval);
3423     nsresult IncrementModificationCount([in] int32_t aModCount);
3424     nsresult GetTransactionManager([out] nsITransactionManager **_retval);
3425     nsresult SetTransactionManager(nsITransactionManager *aTransactionManager);
3426     nsresult DoTransaction([in] nsITransaction *txn);
3427     nsresult EnableUndo([in] bool enable);
3428     nsresult GetNumberOfUndoItems(int32_t *aNumberOfUndoItems);
3429     nsresult GetNumberOfRedoItems(int32_t *aNumberOfRedoItems);
3430     nsresult Undo([in] uint32_t count);
3431     nsresult CanUndo([out] bool *isEnabled, [out] bool *canUndo);
3432     nsresult Redo([in] uint32_t count);
3433     nsresult CanRedo([out] bool *isEnabled, [out] bool *canRedo);
3434     nsresult BeginTransaction();
3435     nsresult EndTransaction();
3436     nsresult BeginPlaceHolderTransaction([in] nsIAtom *name);
3437     nsresult EndPlaceHolderTransaction();
3438     nsresult ShouldTxnSetSelection([out] bool *_retval);
3439     nsresult SetShouldTxnSetSelection([in] bool should);
3440     nsresult GetInlineSpellChecker([out] nsIInlineSpellChecker **_retval);
3441     nsresult SyncRealTimeSpell();
3442     nsresult SetSpellcheckUserOverride(bool enable);
3443     nsresult Cut();
3444     nsresult CanCut([out] bool *_retval);
3445     nsresult Copy();
3446     nsresult CanCopy([out] bool *_retval);
3447     nsresult CanDelete(bool *_retval);
3448     nsresult Paste([in] int32_t aSelectionType);
3449     nsresult PasteTransferable(nsITransferable *aTransferable);
3450     nsresult CanPaste([in] int32_t aSelectionType, [out] bool *_retval);
3451     nsresult CanPasteTransferable(nsITransferable *aTransferable, bool *_retval);
3452     nsresult SelectAll();
3453     nsresult BeginningOfDocument();
3454     nsresult EndOfDocument();
3455     nsresult SetAttribute([in] nsIDOMElement *aElement, [in] const nsAString *attributestr, [in] const nsAString *attvalue);
3456     nsresult GetAttributeValue([in] nsIDOMElement *aElement, [in] const nsAString *attributestr, [out] nsAString *resultValue, bool *_retval);
3457     nsresult RemoveAttribute([in] nsIDOMElement *aElement, [in] const nsAString *aAttribute);
3458     nsresult CloneAttribute([in] const nsAString *aAttribute, [in] nsIDOMNode *aDestNode, [in] nsIDOMNode *aSourceNode);
3459     nsresult CloneAttributes([in] nsIDOMNode *destNode, [in] nsIDOMNode *sourceNode);
3460     nsresult CreateNode([in] const nsAString *tag, [in] nsIDOMNode *parent, [in] int32_t position, [out] nsIDOMNode **_retval);
3461     nsresult InsertNode([in] nsIDOMNode *node, [in] nsIDOMNode *parent, [in] int32_t aPosition);
3462     nsresult SplitNode([in] nsIDOMNode *existingRightNode, [in] int32_t offset, [out] nsIDOMNode **newLeftNode);
3463     nsresult JoinNodes([in] nsIDOMNode *leftNode, [in] nsIDOMNode *rightNode, [in] nsIDOMNode *parent);
3464     nsresult DeleteNode([in] nsIDOMNode *child);
3465     bool OutputsMozDirty();
3466     nsresult MarkNodeDirty([in] nsIDOMNode *node);
3467     nsresult SwitchTextDirection();
3468     nsresult OutputToString([in] nsAString formatType, [in] uint32_t flags, [out] nsAString *_retval);
3469     nsresult OutputToStream([in] nsIOutputStream *aStream, [in] nsAString *formatType, [in] nsACString *charsetOverride, [in] uint32_t flags);
3470     nsresult AddEditorObserver(nsIEditorObserver *observer);
3471     nsresult RemoveEditorObserver(nsIEditorObserver *observer);
3472     nsresult AddEditActionListener([in] nsIEditActionListener *listener);
3473     nsresult RemoveEditActionListener([in] nsIEditActionListener *listener);
3474     nsresult AddDocumentStateListener([in] nsIDocumentStateListener *listener);
3475     nsresult RemoveDocumentStateListener([in] nsIDocumentStateListener *listener);
3476     nsresult DumpContentTree();
3477     nsresult DebugDumpContent();
3478     nsresult DebugUnitTests([out] int32_t *outNumTests, [out] int32_t *outNumTestsFailed);
3479     bool IsModifiableNode(nsIDOMNode *aNode);
3480     nsresult GetSuppressDispatchingInputEvent(bool *aSuppressDispatchingInputEvent);
3481     nsresult SetSuppressDispatchingInputEvent(bool aSuppressDispatchingInputEvent);
3482     nsresult GetIsInEditAction(bool *aIsInEditAction);
3483 }
3484
3485 [
3486     object,
3487     uuid(393a364f-e8e2-48a1-a271-a0067b6bac9b),
3488     local
3489 ]
3490 interface nsIHTMLEditor : nsISupports
3491 {
3492     nsresult AddDefaultProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
3493     nsresult RemoveDefaultProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
3494     nsresult RemoveAllDefaultProperties();
3495     nsresult SetInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
3496     nsresult GetInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue, [out] bool *aFirst, [out] bool *aAny, [out] bool *aAll);
3497     nsresult GetInlinePropertyWithAttrValue([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue, [out] bool *aFirst, [out] bool *aAny, [out] bool *aAll, [out] nsAString *_retval);
3498     nsresult RemoveAllInlineProperties();
3499     nsresult RemoveInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute);
3500     nsresult IncreaseFontSize();
3501     nsresult DecreaseFontSize();
3502     nsresult NodeIsBlock([in] nsIDOMNode *node, bool *_retval);
3503     nsresult InsertHTML([in] nsAString *aInputString);
3504     nsresult PasteNoFormatting([in] int32_t aSelectionType);
3505     nsresult RebuildDocumentFromSource([in] nsAString *aSourceString);
3506     nsresult InsertHTMLWithContext([in] nsAString *aInputString, [in] nsAString *aContextStr, [in] nsAString *aInfoStr, [in] nsAString *aFlavor, [in] nsIDOMDocument *aSourceDoc, [in] nsIDOMNode *aDestinationNode, [in] int32_t aDestinationOffset, [in] bool aDeleteSelection);
3507     nsresult InsertElementAtSelection([in] nsIDOMElement *aElement, [in] bool aDeleteSelection);
3508     nsresult SetDocumentTitle([in] nsAString *aTitle);
3509     nsresult UpdateBaseURL();
3510     nsresult SelectElement([in] nsIDOMElement *aElement);
3511     nsresult SetCaretAfterElement([in] nsIDOMElement *aElement);
3512     nsresult SetParagraphFormat([in] nsAString *aParagraphFormat);
3513     nsresult GetParagraphState([out] bool *aMixed, [out] nsAString *_retval);
3514     nsresult GetFontFaceState([out] bool *aMixed, [out] nsAString *_retval);
3515     nsresult GetFontColorState([out] bool *aMixed, [out] nsAString *_retval);
3516     nsresult GetBackgroundColorState([out] bool *aMixed, [out] nsAString *_retval);
3517     nsresult GetHighlightColorState([out] bool *aMixed, [out] nsAString *_retval);
3518     nsresult GetListState([out] bool *aMixed, [out] bool *aOL, [out] bool *aUL, [out] bool *aDL);
3519     nsresult GetListItemState([out] bool *aMixed, [out] bool *aLI, [out] bool *aDT, [out] bool *aDD);
3520     nsresult GetAlignment([out] bool *aMixed, [out] int16_t *aAlign);
3521     nsresult GetIndentState([out] bool *aCanIndent, [out] bool *aCanOutdent);
3522     nsresult MakeOrChangeList([in] nsAString *aListType, [in] bool entireList, [in] nsAString *aBulletType);
3523     nsresult RemoveList([in] nsAString *aListType);
3524     nsresult Indent([in] nsAString *aIndent);
3525     nsresult Align([in] nsAString *aAlign);
3526     nsresult GetElementOrParentByTagName([in] nsAString *aTagName, [in] nsIDOMNode *aNode, [out] nsIDOMElement **_retval);
3527     nsresult GetSelectedElement([in] nsAString *aTagName, [out] nsIDOMElement **_retval);
3528     nsresult GetHeadContentsAsHTML([out] nsAString *_retval);
3529     nsresult ReplaceHeadContentsWithHTML([in] nsAString *aSourceToInsert);
3530     nsresult CreateElementWithDefaults([in] nsAString *aTagName, [out] nsIDOMElement **_retval);
3531     nsresult InsertLinkAroundSelection([in] nsIDOMElement *aAnchorElement);
3532     nsresult SetBackgroundColor([in] nsAString *aColor);
3533     nsresult SetBodyAttribute([in] nsAString *aAttr, [in] nsAString *aValue);
3534     nsresult GetLinkedObjects([out] nsISupportsArray **_retval);
3535     nsresult GetIsCSSEnabled([out] bool *_retval);
3536     nsresult SetIsCSSEnabled([in] bool prb);
3537     nsresult AddInsertionListener([in] nsIContentFilter *inFilter);
3538     nsresult RemoveInsertionListener([in] nsIContentFilter *inFilter);
3539     nsresult CreateAnonymousElement([in] nsAString *aTag, [in] nsIDOMNode *aParentNode, [in] nsAString *aAnonClass, [in] bool aIsCreatedHidden, [out] nsIDOMElement **_retval);
3540     nsresult GetSelectionContainer([out] nsIDOMElement **_retval);
3541     nsresult CheckSelectionStateForAnonymousButtons([in] nsISelection *aSelection);
3542     nsresult IsAnonymousElement([in] nsIDOMElement *aElement, [out] bool *_retval);
3543     nsresult GetReturnInParagraphCreatesNewParagraph([out] bool *_retval);
3544     nsresult SetReturnInParagraphCreatesNewParagraph([in] bool prb);
3545     nsresult BreakIsVisible(nsIDOMNode *aNode, bool *_retval);
3546     void /*Element*/ *GetActiveEditingHost();
3547 }
3548
3549 [
3550     object,
3551     uuid(b8100c90-73be-11d2-92a5-00105a1b0d64),
3552     local
3553 ]
3554 interface nsIClipboardCommands : nsISupports
3555 {
3556     nsresult CanCutSelection(bool *_retval);
3557     nsresult CanCopySelection(bool *_retval);
3558     nsresult CanCopyLinkLocation(bool *_retval);
3559     nsresult CanCopyImageLocation(bool *_retval);
3560     nsresult CanCopyImageContents(bool *_retval);
3561     nsresult CanPaste(bool *_retval);
3562     nsresult CutSelection();
3563     nsresult CopySelection();
3564     nsresult CopyLinkLocation();
3565     nsresult CopyImageLocation();
3566     nsresult CopyImageContents();
3567     nsresult Paste();
3568     nsresult SelectAll();
3569     nsresult SelectNone();
3570 }
3571
3572 [
3573     object,
3574     uuid(edb99640-8378-4106-8673-e701a086eb1c),
3575     local
3576 ]
3577 interface nsIDocShellTreeItem : nsISupports
3578 {
3579     nsresult GetName(nsAString *aName);
3580     nsresult SetName(const nsAString *aName);
3581     nsresult NameEquals(const PRUnichar *name, bool *_retval);
3582     nsresult GetItemType(int32_t *aItemType);
3583     nsresult SetItemType(int32_t aItemType);
3584     int32_t ItemType();
3585     nsresult GetParent(nsIDocShellTreeItem **aParent);
3586     nsresult GetSameTypeParent(nsIDocShellTreeItem **aSameTypeParent);
3587     nsresult GetRootTreeItem(nsIDocShellTreeItem **aRootTreeItem);
3588     nsresult GetSameTypeRootTreeItem(nsIDocShellTreeItem **aSameTypeRootTreeItem);
3589     nsresult FindItemWithName(const PRUnichar *name, nsISupports *aRequestor, nsIDocShellTreeItem *aOriginalRequestor,
3590             nsIDocShellTreeItem **_retval);
3591     nsresult GetTreeOwner(nsIDocShellTreeOwner **aTreeOwner);
3592     nsresult SetTreeOwner(nsIDocShellTreeOwner *treeOwner);
3593     nsresult GetChildCount(int32_t *aChildCount);
3594     nsresult AddChild(nsIDocShellTreeItem *child);
3595     nsresult RemoveChild(nsIDocShellTreeItem *child);
3596     nsresult GetChildAt(int32_t index, nsIDocShellTreeItem **_retval);
3597     nsresult FindChildWithName(const PRUnichar *aName, bool aRecurse, bool aSameType, nsIDocShellTreeItem *aRequestor,
3598             nsIDocShellTreeItem *aOriginalRequestor, nsIDocShellTreeItem **_retval);
3599     nsIDocument /* thiscall */ *GetDocument();
3600     void /* thiscall nsPIDOMWindow */ *GetWindow();
3601 }
3602
3603 [
3604     object,
3605     uuid(702e0a92-7d63-490e-b5ee-d247e6bd4588),
3606     local
3607 ]
3608 interface nsIContentViewer : nsISupports
3609 {
3610     nsresult Init(nsIWidget *aParentWidget, const void /*nsIntRect*/ *aBounds);
3611     nsresult GetContainer(nsIDocShell **aContainer);
3612     nsresult SetContainer(nsIDocShell *aContainer);
3613     void /* thiscall */ LoadStart(nsIDocument *aDoc);
3614     nsresult LoadComplete(nsresult aStatus);
3615     nsresult PermitUnload(bool aCallerClosesWindow, bool *_retval);
3616     nsresult GetInPermitUnload(bool *aInPermitUnload);
3617     nsresult /* thiscall */ PermitUnloadInternal(bool aCallerClosesWindow, bool *aShouldPrompt, bool *_retval);
3618     nsresult GetBeforeUnloadFiring(bool *aBeforeUnloadFiring);
3619     nsresult ResetCloseWindow();
3620     nsresult PageHide(bool isUnload);
3621     nsresult Close(nsISHEntry *historyEntry);
3622     nsresult Destroy();
3623     nsresult Stop();
3624     nsresult GetDOMDocument(nsIDOMDocument **aDOMDocument);
3625     nsresult SetDOMDocument(nsIDOMDocument *aDOMDocument);
3626     void /* thiscall nsresult_(nsIDocument *) */ GetDocument();
3627     nsresult GetBounds(void /*nsIntRect*/ *aBounds);
3628     nsresult SetBounds(const void /*nsIntRect*/ *aBounds);
3629     nsresult GetPreviousViewer(nsIContentViewer **aPreviousViewer);
3630     nsresult SetPreviousViewer(nsIContentViewer *aPreviousViewer);
3631     nsresult Move(int32_t aX, int32_t aY);
3632     nsresult Show();
3633     nsresult Hide();
3634     nsresult GetSticky(bool *aSticky);
3635     nsresult SetSticky(bool aSticky);
3636     nsresult RequestWindowClose(bool *_retval);
3637     nsresult Open(nsISupports *aState, nsISHEntry *aSHEntry);
3638     nsresult ClearHistoryEntry();
3639     nsresult SetPageMode(bool aPageMode, nsIPrintSettings *aPrintSettings);
3640     nsresult GetHistoryEntry(nsISHEntry **aHistoryEntry);
3641     nsresult GetIsTabModalPromptAllowed(bool *aIsTabModalPromptAllowed);
3642     nsresult GetIsHidden(bool *aIsHidden);
3643     nsresult SetIsHidden(bool aIsHidden);
3644     nsresult GetPresShell(nsIPresShell **aPresShell);
3645     nsresult GetPresContext(void /*nsPresContext*/ **aPresContext);
3646     nsresult SetDocumentInternal(nsIDocument *aDocument, bool aForceReuseInnerWindow);
3647     void /* thiscall nsView */ *FindContainerView(void);
3648     void /* thiscall */ SetNavigationTiming(void /*nsDOMNavigationTiming*/ *aTiming);
3649     nsresult ScrollToNode(nsIDOMNode *node);
3650     nsresult GetTextZoom(float *aTextZoom);
3651     nsresult SetTextZoom(float aTextZoom);
3652     nsresult GetFullZoom(float *aFullZoom);
3653     nsresult SetFullZoom(float aFullZoom);
3654     nsresult GetAuthorStyleDisabled(bool *aAuthorStyleDisabled);
3655     nsresult SetAuthorStyleDisabled(bool aAuthorStyleDisabled);
3656     nsresult GetForceCharacterSet(nsACString *aForceCharacterSet);
3657     nsresult SetForceCharacterSet(const nsACString *aForceCharacterSet);
3658     nsresult GetHintCharacterSet(nsACString *aHintCharacterSet);
3659     nsresult SetHintCharacterSet(const nsACString *aHintCharacterSet);
3660     nsresult GetHintCharacterSetSource(int32_t *aHintCharacterSetSource);
3661     nsresult SetHintCharacterSetSource(int32_t aHintCharacterSetSource);
3662     nsresult GetContentSize(int32_t *width, int32_t *height);
3663     nsresult GetMinFontSize(int32_t *aMinFontSize);
3664     nsresult SetMinFontSize(int32_t aMinFontSize);
3665     nsresult AppendSubtree(void /*nsTArray<nsCOMPtr<nsIContentViewer> >*/ *array);
3666     nsresult ChangeMaxLineBoxWidth(int32_t maxLineBoxWidth);
3667     nsresult PausePainting();
3668     nsresult ResumePainting();
3669     nsresult EmulateMedium(const nsAString *aMediaType);
3670     nsresult StopEmulatingMedium();
3671 }
3672
3673 [
3674     object,
3675     uuid(c8d3b1e1-565a-427e-9d68-b109910ce9b7),
3676     local
3677 ]
3678 interface nsIDocShellLoadInfo : nsISupports
3679 {
3680     typedef int nsDocShellInfoLoadType;
3681
3682     nsresult GetReferrer(nsIURI **aReferrer);
3683     nsresult SetReferrer(nsIURI *aReferrer);
3684     nsresult GetOwner(nsISupports **aOwner);
3685     nsresult SetOwner(nsISupports *aOwner);
3686     nsresult GetInheritOwner(bool *aInheritOwner);
3687     nsresult SetInheritOwner(bool aInheritOwner);
3688     nsresult GetOwnerIsExplicit(bool *aOwnerIsExplicit);
3689     nsresult SetOwnerIsExplicit(bool aOwnerIsExplicit);
3690     nsresult GetLoadType(nsDocShellInfoLoadType *aLoadType);
3691     nsresult SetLoadType(nsDocShellInfoLoadType aLoadType);
3692     nsresult GetSHEntry(nsISHEntry **aSHEntry);
3693     nsresult SetSHEntry(nsISHEntry *aSHEntry);
3694     nsresult GetTarget(char16_t **aTarget);
3695     nsresult SetTarget(const char16_t * aTarget);
3696     nsresult GetPostDataStream(nsIInputStream **aPostDataStream);
3697     nsresult SetPostDataStream(nsIInputStream *aPostDataStream);
3698     nsresult GetHeadersStream(nsIInputStream * *aHeadersStream);
3699     nsresult SetHeadersStream(nsIInputStream *aHeadersStream);
3700     nsresult GetSendReferrer(bool *aSendReferrer);
3701     nsresult SetSendReferrer(bool aSendReferrer);
3702     nsresult GetIsSrcdocLoad(bool *aIsSrcdocLoad);
3703     nsresult GetSrcdocData(nsAString *aSrcdocData);
3704     nsresult SetSrcdocData(const nsAString *aSrcdocData);
3705     nsresult GetSourceDocShell(nsIDocShell * *aSourceDocShell);
3706     nsresult SetSourceDocShell(nsIDocShell *aSourceDocShell);
3707     nsresult GetBaseURI(nsIURI **aBaseURI);
3708     nsresult SetBaseURI(nsIURI *aBaseURI);
3709 }
3710
3711 [
3712     object,
3713     uuid(c2756385-bc54-417b-9ae4-c5a40053a2a3),
3714     local
3715 ]
3716 interface nsIDocShell : nsIDocShellTreeItem
3717 {
3718     nsresult LoadURI(nsIURI *uri, nsIDocShellLoadInfo *loadInfo, uint32_t aLoadFlags, bool firstParty);
3719     nsresult LoadStream(nsIInputStream *aStream, nsIURI *aURI, const nsACString *aContentType,
3720             const nsACString *aContentCharset, nsIDocShellLoadInfo *aLoadInfo);
3721     nsresult InternalLoad(nsIURI *aURI, nsIURI *aReferrer, uint32_t aReferrerPolicy, nsISupports *aOwner,
3722             uint32_t aFlags, const PRUnichar *aWindowTarget, const char *aTypeHint, nsACString *aFileName,
3723             nsIInputStream *aPostDataStream, nsIInputStream *aHeadersStream, uint32_t aLoadFlags,
3724             nsISHEntry *aSHEntry, bool firstParty, const nsAString *aSrcdoc, nsIDocShell *aSourceDocShell,
3725             nsIURI *aBaseURI, nsIDocShell **aDocShell, nsIRequest **aRequest);
3726     nsresult AddState(jsval *aData, const nsAString *aTitle, const nsAString *aURL, bool aReplace, JSContext *cx);
3727     nsresult CreateLoadInfo(nsIDocShellLoadInfo **loadInfo);
3728     nsresult PrepareForNewContentModel();
3729     nsresult SetCurrentURI(nsIURI *aURI);
3730     nsresult FirePageHideNotification(bool isUnload);
3731     nsresult GetPresContext(void /*nsPresContext*/ **aPresContext);
3732     nsIPresShell *GetPresShell();
3733     nsresult GetEldestPresShell(nsIPresShell **aEldestPresShell);
3734     nsresult GetContentViewer(nsIContentViewer **aContentViewer);
3735     nsresult GetChromeEventHandler(nsIDOMEventTarget **aChromeEventHandler);
3736     nsresult SetChromeEventHandler(nsIDOMEventTarget *aChromeEventHandler);
3737     nsresult GetAllowPlugins(bool *aAllowPlugins);
3738     nsresult SetAllowPlugins(bool aAllowPlugins);
3739     nsresult GetAllowJavascript(bool *aAllowJavascript);
3740     nsresult SetAllowJavascript(bool aAllowJavascript);
3741     nsresult GetDisableNoScript(bool *aDisableNoScript);
3742     nsresult SetDisableNoScript(bool aDisableNoScript);
3743     nsresult GetAllowMetaRedirects(bool *aAllowMetaRedirects);
3744     nsresult SetAllowMetaRedirects(bool aAllowMetaRedirects);
3745     nsresult GetAllowSubframes(bool *aAllowSubframes);
3746     nsresult SetAllowSubframes(bool aAllowSubframes);
3747     nsresult GetAllowImages(bool *aAllowImages);
3748     nsresult SetAllowImages(bool aAllowImages);
3749     nsresult GetAllowMedia(bool *aAllowMedia);
3750     nsresult SetAllowMedia(bool aAllowMedia);
3751     nsresult GetAllowDNSPrefetch(bool *aAllowDNSPrefetch);
3752     nsresult SetAllowDNSPrefetch(bool aAllowDNSPrefetch);
3753     nsresult GetAllowWindowControl(bool *aAllowWindowControl);
3754     nsresult SetAllowWindowControl(bool aAllowWindowControl);
3755     nsresult GetAllowContentRetargeting(bool *aAllowContentRetargeting);
3756     nsresult SetAllowContentRetargeting(bool aAllowContentRetargeting);
3757     nsresult GetDocShellEnumerator(int32_t aItemType, int32_t aDirection, nsISimpleEnumerator **_retval);
3758     nsresult GetAppType(uint32_t *aAppType);
3759     nsresult SetAppType(uint32_t aAppType);
3760     nsresult GetAllowAuth(bool *aAllowAuth);
3761     nsresult SetAllowAuth(bool aAllowAuth);
3762     nsresult GetZoom(float *aZoom);
3763     nsresult SetZoom(float aZoom);
3764     nsresult GetMarginWidth(int32_t *aMarginWidth);
3765     nsresult SetMarginWidth(int32_t aMarginWidth);
3766     nsresult GetMarginHeight(int32_t *aMarginHeight);
3767     nsresult SetMarginHeight(int32_t aMarginHeight);
3768     nsresult TabToTreeOwner(bool forward, bool *tookFocus);
3769     nsresult GetBusyFlags(uint32_t *aBusyFlags);
3770     nsresult GetLoadType(uint32_t *aLoadType);
3771     nsresult SetLoadType(uint32_t aLoadType);
3772     nsresult GetDefaultLoadFlags(nsLoadFlags *aDefaultLoadFlags);
3773     nsresult SetDefaultLoadFlags(nsLoadFlags aDefaultLoadFlags);
3774     nsresult IsBeingDestroyed(bool *_retval);
3775     nsresult GetIsExecutingOnLoadHandler(bool *aIsExecutingOnLoadHandler);
3776     nsresult GetLayoutHistoryState(nsILayoutHistoryState **aLayoutHistoryState);
3777     nsresult SetLayoutHistoryState(nsILayoutHistoryState *aLayoutHistoryState);
3778     nsresult GetShouldSaveLayoutState(bool *aShouldSaveLayoutState);
3779     nsresult GetSecurityUI(nsISecureBrowserUI **aSecurityUI);
3780     nsresult SetSecurityUI(nsISecureBrowserUI *aSecurityUI);
3781     nsresult SuspendRefreshURIs();
3782     nsresult ResumeRefreshURIs();
3783     nsresult BeginRestore(nsIContentViewer *viewer, bool top);
3784     nsresult FinishRestore();
3785     nsresult GetRestoringDocument(bool *aRestoringDocument);
3786     nsresult GetUseErrorPages(bool *aUseErrorPages);
3787     nsresult SetUseErrorPages(bool aUseErrorPages);
3788     nsresult DisplayLoadError(nsresult aError, nsIURI *aURI, const PRUnichar *aURL, nsIChannel *aFailedChannel);
3789     nsresult GetFailedChannel(nsIChannel **aFailedChannel);
3790     nsresult GetPreviousTransIndex(int32_t *aPreviousTransIndex);
3791     nsresult GetLoadedTransIndex(int32_t *aLoadedTransIndex);
3792     nsresult HistoryPurged(int32_t numEntries);
3793     nsresult GetSessionStorageForPrincipal(nsIPrincipal *principal, const nsAString *documentURI,
3794             bool create, nsIDOMStorage **_retval);
3795     nsresult AddSessionStorage(nsIPrincipal *principal, nsIDOMStorage *storage);
3796     nsresult GetCurrentDocumentChannel(nsIChannel **aCurrentDocumentChannel);
3797     nsresult SetChildOffset(uint32_t offset);
3798     nsresult GetIsInUnload(bool *aIsInUnload);
3799     nsresult GetChannelIsUnsafe(bool *aChannelIsUnsafe);
3800     nsresult GetHasMixedActiveContentLoaded(bool *aHasMixedActiveContentLoaded);
3801     nsresult GetHasMixedActiveContentBlocked(bool *aHasMixedActiveContentBlocked);
3802     nsresult GetHasMixedDisplayContentLoaded(bool *aHasMixedDisplayContentLoaded);
3803     nsresult GetHasMixedDisplayContentBlocked(bool *aHasMixedDisplayContentBlocked);
3804     nsresult GetHasTrackingContentBlocked(bool *aHasTrackingContentBlocked);
3805     nsresult GetHasTrackingContentLoaded(bool *aHasTrackingContentLoaded);
3806     void DetachEditorFromWindow();
3807     nsresult GetIsOffScreenBrowser(bool *aIsOffScreenBrowser);
3808     nsresult SetIsOffScreenBrowser(bool aIsOffScreenBrowser);
3809     nsresult GetPrintPreview(nsIWebBrowserPrint **aPrintPreview);
3810     nsresult GetCanExecuteScripts(bool *aCanExecuteScripts);
3811     nsresult GetIsActive(bool *aIsActive);
3812     nsresult SetIsActive(bool aIsActive);
3813     nsresult GetHistoryID(uint64_t *aHistoryID);
3814     nsresult GetIsAppTab(bool *aIsAppTab);
3815     nsresult SetIsAppTab(bool aIsAppTab);
3816     nsresult CreateAboutBlankContentViewer(nsIPrincipal *aPrincipal);
3817     nsresult GetCharset(nsACString *aCharset);
3818     nsresult SetCharset(nsACString *aCharset);
3819     nsresult GatherCharsetMenuTelemetry();
3820     nsresult GetForcedCharset(nsIAtom **aForcedCharset);
3821     nsresult SetForcedCharset(nsIAtom *aForcedCharset);
3822     void SetParentCharset(const nsACString *parentCharset, int32_t parentCharsetSource, nsIPrincipal *parentCharsetPrincipal);
3823     void GetParentCharset(nsACString *parentCharset, int32_t *parentCharsetSource, nsIPrincipal **parentCharsetPrincipal);
3824     nsresult GetRecordProfileTimelineMarkers(bool *aRecordProfileTimelineMarkers);
3825     nsresult SetRecordProfileTimelineMarkers(bool aRecordProfileTimelineMarkers);
3826     nsresult Now(int /* DOMHighResTimeStamp */ *_retval);
3827     nsresult PopProfileTimelineMarkers(JSContext *cx, void /*JS::MutableHandleValue*/ *_retval);
3828     nsresult AddWeakPrivacyTransitionObserver(nsIPrivacyTransitionObserver *obs);
3829     nsresult AddWeakReflowObserver(nsISupports /*nsIReflowObserver*/ *obs);
3830     nsresult RemoveWeakReflowObserver(nsISupports /*nsIReflowObserver*/ *obs);
3831     nsresult NotifyReflowObservers(bool interruptible, int /*DOMHighResTimeStamp*/ start, int /*DOMHighResTimeStamp*/ end);
3832     nsresult AddWeakScrollObserver(void /*nsIScrollObserver*/ *obs);
3833     nsresult RemoveWeakScrollObserver(void /*nsIScrollObserver*/ *obs);
3834     nsresult NotifyScrollObservers();
3835     nsresult GetIsBrowserElement(bool *aIsBrowserElement);
3836     nsresult GetIsApp(bool *aIsApp);
3837     nsresult GetIsBrowserOrApp(bool *aIsBrowserOrApp);
3838     nsresult GetIsInBrowserElement(bool *aIsInBrowserElement);
3839     nsresult GetIsInBrowserOrApp(bool *aIsInBrowserOrApp);
3840     nsresult SetIsApp(uint32_t ownAppId);
3841     nsresult SetIsBrowserInsideApp(uint32_t containingAppId);
3842     nsresult GetAppId(uint32_t *aAppId);
3843     nsresult GetAppManifestURL(nsAString *aAppManifestURL);
3844     nsresult GetSameTypeParentIgnoreBrowserAndAppBoundaries(nsIDocShell **_retval);
3845     nsresult GetAsyncPanZoomEnabled(bool *aAsyncPanZoomEnabled);
3846     nsresult GetSandboxFlags(uint32_t *aSandboxFlags);
3847     nsresult SetSandboxFlags(uint32_t aSandboxFlags);
3848     nsresult GetOnePermittedSandboxedNavigator(nsIDocShell **aOnePermittedSandboxedNavigator);
3849     nsresult SetOnePermittedSandboxedNavigator(nsIDocShell *aOnePermittedSandboxedNavigator);
3850     bool IsSandboxedFrom(nsIDocShell *aTargetDocShell);
3851     nsresult GetMixedContentChannel(nsIChannel **aMixedContentChannel);
3852     nsresult SetMixedContentChannel(nsIChannel *aMixedContentChannel);
3853     nsresult GetAllowMixedContentAndConnectionData(bool *rootHasSecureConnection, bool *allowMixedContent, bool *isRootDocShell);
3854     bool PluginsAllowedInCurrentDoc();
3855     nsresult GetFullscreenAllowed(bool *aFullscreenAllowed);
3856     nsresult SetFullscreenAllowed(bool allowed);
3857     nsresult GetAffectPrivateSessionLifetime(bool *aAffectPrivateSessionLifetime);
3858     nsresult SetAffectPrivateSessionLifetime(bool aAffectPrivateSessionLifetime);
3859     nsresult GetMayEnableCharacterEncodingMenu(bool *aMayEnableCharacterEncodingMenu);
3860     nsresult GetEditor(nsIEditor **aEditor);
3861     nsresult SetEditor(nsIEditor *aEditor);
3862     nsresult GetEditable(bool *aEditable);
3863     nsresult GetHasEditingSession(bool *aHasEditingSession);
3864     nsresult MakeEditable(bool inWaitForUriLoad);
3865     nsresult GetChildSHEntry(int32_t aChildOffset, nsISHEntry **_retval);
3866     nsresult AddChildSHEntry(nsISHEntry *aCloneReference, nsISHEntry *aHistoryEntry, int32_t aChildOffset, uint32_t aLoadType, bool aCloneChildren);
3867     nsresult GetUseGlobalHistory(bool *aUseGlobalHistory);
3868     nsresult SetUseGlobalHistory(bool aUseGlobalHistory);
3869     nsresult RemoveFromSessionHistory();
3870     nsresult GetCreatedDynamically(bool *aCreatedDynamically);
3871     nsresult SetCreatedDynamically(bool aCreatedDynamically);
3872     nsresult GetCurrentSHEntry(nsISHEntry **aEntry, bool *_retval);
3873     nsresult IsCommandEnabled(const char *command, bool *_retval);
3874     nsresult DoCommand(const char *command);
3875     bool IsInvisible();
3876     void SetInvisible(bool aIsInvisibleDochsell);
3877     void /*nsIScriptGlobalObject*/ *GetScriptGlobalObject();
3878     nsresult GetDeviceSizeIsPageSize(bool *aDeviceSizeIsPageSize);
3879     nsresult SetDeviceSizeIsPageSize(bool aDeviceSizeIsPageSize);
3880     void /* thiscall */ SetOpener(void /*nsITabParent*/ *aOpener);
3881     void /* thiscall nsITabParent */ *GetOpener();
3882     void /* thiscall */ SetOpenedRemote(void /*nsITabParent*/ *aOpenedRemote);
3883     void /* thiscall nsITabParent */ *GetOpenedRemote();
3884     void /*mozilla::dom::URLSearchParams */ *GetURLSearchParams();
3885     void /* thiscall */ NotifyJSRunToCompletionStart();
3886     void /* thiscall */ NotifyJSRunToCompletionStop();
3887     nsresult GetHasLoadedNonBlankURI(bool *aHasLoadedNonBlankURI);
3888
3889 }
3890
3891 [
3892     object,
3893     uuid(16fe5e3e-eadc-4312-9d44-b6bedd6b5474),
3894     local
3895 ]
3896 interface nsIMutationObserver : nsISupports
3897 {
3898     void CharacterDataWillChange(nsIDocument *aDocument, nsIContent *aContent,
3899                                  void /*CharacterDataChangeInfo*/ *aInfo);
3900     void CharacterDataChanged(nsIDocument *aDocument, nsIContent *aContent,
3901                               void /*CharacterDataChangeInfo*/ *aInfo);
3902     void AttributeWillChange(nsIDocument *aDocument, nsIContent *aContent, int32_t aNameSpaceID,
3903                              nsIAtom *aAttribute, int32_t aModType);
3904     void AttributeChanged(nsIDocument *aDocument, nsIContent *aContent, int32_t aNameSpaceID,
3905                           nsIAtom *aAttribute, int32_t aModType);
3906     void AttributeSetToCurrentValue(nsIDocument *aDocument, /*mozilla::dom::Element*/ void *aElement,
3907                                     int32_t aNameSpaceID, nsIAtom *aAttribute);
3908     void ContentAppended(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aFirstNewContent,
3909                          int32_t aNewIndexInContainer);
3910     void ContentInserted(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild,
3911                          int32_t aIndexInContainer);
3912     void ContentRemoved(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild,
3913                         int32_t aIndexInContainer, nsIContent *aPreviousSibling);
3914     void NodeWillBeDestroyed(const nsINode *aNode);
3915     void ParentChainChanged(nsIContent *aContent);
3916 }
3917
3918 [
3919     object,
3920     uuid(2c4ad90a-740e-4212-ba3f-feacda4b929e),
3921     local
3922 ]
3923 interface nsIParser : nsISupports
3924 {
3925     typedef int nsDTDMode;
3926     typedef int eParserCommands;
3927
3928     /* From nsParserBase: */
3929     bool IsParserEnabled();
3930     nsresult GetChannel(nsIChannel **aChannel);
3931
3932     void SetContentSink(nsIContentSink *aSink);
3933     nsIContentSink *GetContentSink();
3934     void GetCommand(nsACString *aCommand);
3935     void SetCommand2(const char *aCommand);
3936     void SetCommand(eParserCommands aParserCommand);
3937     void SetDocumentCharset(const nsACString *aCharset, int32_t aSource);
3938     void GetDocumentCharset(nsACString *oCharset, int32_t *oSource);
3939     /* nsresult GetChannel(nsIChannel **aChannel); in nsParserBase */
3940     nsresult GetDTD(nsIDTD **aDTD);
3941     nsIStreamListener *GetStreamListener();
3942     nsresult ContinueInterruptedParsing();
3943     void BlockParser();
3944     void UnblockParser();
3945     void ContinueInterruptedParsingAsync();
3946     /* bool IsParserEnabled(); in nsParserBase */
3947     bool IsComplete();
3948     nsresult Parse(nsIURI *aURL, nsIRequestObserver *aListener, void *aKey, nsDTDMode aMode);
3949     nsresult Terminate();
3950     nsresult ParseFragment(const nsAString *aSourceBuffer, void /*nsTArray<nsString>*/ *aTagStack);
3951     nsresult BuildModel();
3952     nsresult CancelParsingEvents();
3953     void Reset();
3954     bool IsInsertionPointDefined();
3955     void BeginEvaluatingParserInsertedScript();
3956     void EndEvaluatingParserInsertedScript();
3957     void MarkAsNotScriptCreated(const char *aCommand);
3958     bool IsScriptCreated();
3959 }
3960
3961 [
3962     object,
3963     uuid(900bc4bc-8b6c-4cba-82fa-568a80fffd3e),
3964     local
3965 ]
3966 interface nsIDocumentObserver : nsIMutationObserver
3967 {
3968     typedef uint32_t nsUpdateType;
3969
3970     typedef struct {
3971         uint64_t mStates;
3972     } EventStates;
3973
3974     void BeginUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType);
3975     void EndUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType);
3976     void BeginLoad(nsIDocument *aDocument);
3977     void EndLoad(nsIDocument *aDocument);
3978     void ContentStatesChanged(nsIDocument *aDocument, nsIContent *aContent, EventStates aStateMask);
3979     void DocumentStatesChanged(nsIDocument *aDocument, EventStates aStateMask);
3980     void StyleSheetAdded(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, bool aDocumentSheet);
3981     void StyleSheetRemoved(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, bool aDocumentSheet);
3982     void StyleSheetApplicableStateChanged(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet,
3983                                           bool aApplicable);
3984     void StyleRuleChanged(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aOldStyleRule,
3985                           nsIStyleRule *aNewStyleRule);
3986     void StyleRuleAdded(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule);
3987     void StyleRuleRemoved(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule);
3988     void BindToDocument(nsIDocument *aDocument, nsIContent *aContent);
3989     void AttemptToExecuteScript(nsIContent *aContent, nsIParser *aParser, bool *aBlock);
3990 }
3991
3992 [
3993     object,
3994     uuid(3682dd99-8560-44f4-9b8f-ccce9d7b96fb),
3995     local
3996 ]
3997 interface nsIContentUtils : nsISupports
3998 {
3999     bool IsSafeToRunScript();
4000     nsresult AddDocumentObserver(nsIDocument *aDocument, nsIDocumentObserver *aObserver);
4001     nsresult RemoveDocumentObserver(nsIDocument *aDocument, nsIDocumentObserver *aObserver);
4002     nsresult AddMutationObserver(nsINode *aNode, nsIMutationObserver *aObserver);
4003     nsresult RemoveMutationObserver(nsINode *aNode, nsIMutationObserver *aObserver);
4004     nsresult AddScriptRunner(nsIRunnable *aRunnable);
4005     JSContext *GetContextFromDocument(nsIDocument *aDocument);
4006 }
4007
4008 [
4009     object,
4010     uuid(8f672000-bab9-4c60-aaaf-2673c4e2a4c6),
4011     local
4012 ]
4013 interface nsIPluginInstance : nsISupports
4014 {
4015     nsresult GetDOMElement(nsIDOMElement **aDOMElement);
4016 }
4017
4018 cpp_quote("DEFINE_GUID(IID_nsCycleCollectionISupports, 0xc61eac14,0x5f7a,0x4481,0x96,0x5e,0x7e,0xaa,0x6e,0xff,0xa8,0x5f);")