nsIDocShell.idl (24317B)
1 /* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- 2 * 3 * This Source Code Form is subject to the terms of the Mozilla Public 4 * License, v. 2.0. If a copy of the MPL was not distributed with this 5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ 6 7 #include "domstubs.idl" 8 #include "nsIDocShellTreeItem.idl" 9 #include "nsIRequest.idl" 10 11 %{ C++ 12 #include "js/TypeDecls.h" 13 #include "mozilla/Maybe.h" 14 #include "mozilla/NotNull.h" 15 #include "mozilla/UniquePtr.h" 16 #include "nsCOMPtr.h" 17 #include "nsIURI.h" 18 class nsCommandManager; 19 class nsPresContext; 20 class nsDocShellLoadState; 21 namespace mozilla { 22 class Encoding; 23 class HTMLEditor; 24 class PresShell; 25 namespace dom { 26 class BrowsingContext; 27 class ClientSource; 28 } // namespace dom 29 } 30 %} 31 32 /** 33 * The nsIDocShell interface. 34 */ 35 36 [ptr] native nsPresContext(nsPresContext); 37 [ptr] native nsCommandManager(nsCommandManager); 38 [ptr] native PresShell(mozilla::PresShell); 39 [ref] native MaybeURI(mozilla::Maybe<nsCOMPtr<nsIURI>>); 40 [ref] native Encoding(const mozilla::Encoding*); 41 native UniqueClientSource(mozilla::UniquePtr<mozilla::dom::ClientSource>); 42 43 interface nsIURI; 44 interface nsIChannel; 45 interface nsIPolicyContainer; 46 interface nsIDocumentViewer; 47 interface nsIEditor; 48 interface nsIEditingSession; 49 interface nsIInputStream; 50 interface nsIRequest; 51 interface nsISHEntry; 52 interface nsILayoutHistoryState; 53 interface nsISecureBrowserUI; 54 interface nsIScriptGlobalObject; 55 interface nsIStructuredCloneContainer; 56 interface nsIDOMStorage; 57 interface nsIPrincipal; 58 interface nsIPrivacyTransitionObserver; 59 interface nsIReflowObserver; 60 interface nsIScrollObserver; 61 interface nsIRemoteTab; 62 interface nsIBrowserChild; 63 interface nsICommandParams; 64 interface nsILoadURIDelegate; 65 native BrowserChildRef(already_AddRefed<nsIBrowserChild>); 66 native nsDocShellLoadStatePtr(nsDocShellLoadState*); 67 68 webidl BrowsingContext; 69 webidl ContentFrameMessageManager; 70 webidl EventTarget; 71 webidl Document; 72 73 /** 74 * nsIDocShell is an interface corresponding to the native nsDocShell object, 75 * which is a legacy in-process object roughly corresponding to a 'browsing 76 * context', as created for a browser tab or an iframe, for example. 77 * 78 * nsIDocShell has a 1:1 relationship with its paired dom::BrowsingContext and 79 * nsGlobalWindowOuter. It may be replaced during navigation. 80 * 81 * See also the comment documenting dom::BrowsingContext and the documentation 82 * at: 83 * 84 * https://html.spec.whatwg.org/multipage/document-sequences.html#browsing-context 85 * https://firefox-source-docs.mozilla.org/dom/navigation/embedding.html 86 * https://firefox-source-docs.mozilla.org/dom/navigation/nav_replace.html 87 */ 88 [scriptable, builtinclass, uuid(049234fe-da10-478b-bc5d-bc6f9a1ba63d)] 89 interface nsIDocShell : nsIDocShellTreeItem 90 { 91 void setCancelContentJSEpoch(in long aEpoch); 92 93 /** 94 * Loads a given URI. This will give priority to loading the requested URI 95 * in the object implementing this interface. If it can't be loaded here 96 * however, the URL dispatcher will go through its normal process of content 97 * loading. 98 * 99 * @param aLoadState This is the extended load info for this load. 100 * @param aSetNavigating If we should set isNavigating to true while initiating 101 * the load. 102 */ 103 [noscript]void loadURI(in nsDocShellLoadStatePtr aLoadState, in boolean aSetNavigating); 104 105 /** 106 * Do either a history.pushState() or history.replaceState() operation, 107 * depending on the value of aReplace. 108 */ 109 [implicit_jscontext, can_run_script] 110 void addState(in jsval aData, in AString aTitle, 111 in AString aURL, in boolean aReplace); 112 113 /** 114 * Reset state to a new content model within the current document and the document 115 * viewer. Called by the document before initiating an out of band document.write(). 116 */ 117 void prepareForNewContentModel(); 118 119 /** 120 * Helper for the session store to change the URI associated with the 121 * document. 122 */ 123 void setCurrentURIForSessionStore(in nsIURI aURI); 124 125 /** 126 * Notify the associated content viewer and all child docshells that they are 127 * about to be hidden. If |isUnload| is true, then the document is being 128 * unloaded and all dynamic subframe history entries are removed as well. 129 * 130 * @param isUnload 131 * True to fire the unload event in addition to the pagehide event, 132 * and remove all dynamic subframe history entries. 133 */ 134 [noscript] void firePageHideNotification(in boolean isUnload); 135 136 /** 137 * Presentation context for the currently loaded document. This may be null. 138 */ 139 [notxpcom,nostdcall] readonly attribute nsPresContext presContext; 140 141 /** 142 * Presentation shell for the currently loaded document. This may be null. 143 */ 144 [notxpcom,nostdcall] readonly attribute PresShell presShell; 145 146 /** 147 * Presentation shell for the oldest document, if this docshell is 148 * currently transitioning between documents. 149 */ 150 [notxpcom,nostdcall] readonly attribute PresShell eldestPresShell; 151 152 /** 153 * Document Viewer that is currently loaded for this DocShell. This may 154 * change as the underlying content changes. 155 */ 156 [infallible] readonly attribute nsIDocumentViewer docViewer; 157 158 /** 159 * Get the id of the outer window that is or will be in this docshell. 160 */ 161 [infallible] readonly attribute unsigned long long outerWindowID; 162 163 /** 164 * This attribute allows chrome to tie in to handle DOM events that may 165 * be of interest to chrome. 166 */ 167 attribute EventTarget chromeEventHandler; 168 169 /** 170 * This allows chrome to set a custom User agent on a specific docshell 171 */ 172 attribute AString customUserAgent; 173 174 /** 175 * Whether CSS error reporting is enabled. 176 */ 177 attribute boolean cssErrorReportingEnabled; 178 179 /** 180 * Attribute stating if refresh based redirects can be allowed 181 */ 182 attribute boolean allowMetaRedirects; 183 184 /** 185 * Attribute stating if it should allow subframes (framesets/iframes) or not 186 */ 187 attribute boolean allowSubframes; 188 189 /** 190 * Attribute stating whether or not images should be loaded. 191 */ 192 attribute boolean allowImages; 193 194 /** 195 * Attribute stating whether or not media (audio/video) should be loaded. 196 */ 197 [infallible] attribute boolean allowMedia; 198 199 /** 200 * Attribute that determines whether DNS prefetch is allowed for this subtree 201 * of the docshell tree. Defaults to true. Setting this will make it take 202 * effect starting with the next document loaded in the docshell. 203 */ 204 attribute boolean allowDNSPrefetch; 205 206 /** 207 * Attribute that determines whether window control (move/resize) is allowed. 208 */ 209 attribute boolean allowWindowControl; 210 211 /** 212 * True if the docshell allows its content to be handled by a content listener 213 * other than the docshell itself, including the external helper app service, 214 * and false otherwise. Defaults to true. 215 */ 216 [infallible] attribute boolean allowContentRetargeting; 217 218 /** 219 * True if new child docshells should allow content retargeting. 220 * Setting allowContentRetargeting also overwrites this value. 221 */ 222 [infallible] attribute boolean allowContentRetargetingOnChildren; 223 224 /** 225 * Get an array of this docShell and its children. 226 * 227 * @param aItemType - Only include docShells of this type, or if typeAll, 228 * include all child shells. 229 * Uses types from nsIDocShellTreeItem. 230 * @param aDirection - Whether to enumerate forwards or backwards. 231 */ 232 233 cenum DocShellEnumeratorDirection : 8 { 234 ENUMERATE_FORWARDS = 0, 235 ENUMERATE_BACKWARDS = 1 236 }; 237 238 Array<nsIDocShell> getAllDocShellsInSubtree(in long aItemType, 239 in nsIDocShell_DocShellEnumeratorDirection aDirection); 240 241 /** 242 * The type of application that created this window. 243 * 244 * DO NOT DELETE, see bug 176166. For firefox, this value will always be 245 * UNKNOWN. However, it is used heavily in Thunderbird/comm-central and we 246 * don't really have a great replacement at the moment, so we'll just leave it 247 * here. 248 */ 249 cenum AppType : 8 { 250 APP_TYPE_UNKNOWN = 0, 251 APP_TYPE_MAIL = 1, 252 APP_TYPE_EDITOR = 2 253 }; 254 255 [infallible] attribute nsIDocShell_AppType appType; 256 257 /** 258 * certain docshells (like the message pane) 259 * should not throw up auth dialogs 260 * because it can act as a password trojan 261 */ 262 attribute boolean allowAuth; 263 264 /** 265 * Set/Get the document scale factor. When setting this attribute, a 266 * NS_ERROR_NOT_IMPLEMENTED error may be returned by implementations 267 * not supporting zoom. Implementations not supporting zoom should return 268 * 1.0 all the time for the Get operation. 1.0 by the way is the default 269 * of zoom. This means 100% of normal scaling or in other words normal size 270 * no zoom. 271 */ 272 attribute float zoom; 273 274 /** 275 * Current busy state for DocShell 276 */ 277 cenum BusyFlags : 8 { 278 BUSY_FLAGS_NONE = 0, 279 BUSY_FLAGS_BUSY = 1, 280 BUSY_FLAGS_BEFORE_PAGE_LOAD = 2, 281 BUSY_FLAGS_PAGE_LOADING = 4, 282 }; 283 284 [infallible] readonly attribute nsIDocShell_BusyFlags busyFlags; 285 286 /** 287 * Load commands for the document 288 */ 289 cenum LoadCommand : 8 { 290 LOAD_CMD_NORMAL = 0x1, // Normal load 291 LOAD_CMD_RELOAD = 0x2, // Reload 292 LOAD_CMD_HISTORY = 0x4, // Load from history 293 LOAD_CMD_PUSHSTATE = 0x8, // History.pushState() 294 }; 295 296 /* 297 * Attribute to access the loadtype for the document. LoadType Enum is 298 * defined in nsDocShellLoadTypes.h 299 */ 300 [infallible] attribute unsigned long loadType; 301 302 /* 303 * Default load flags (as defined in nsIRequest) that will be set on all 304 * requests made by this docShell and propagated to all child docShells and 305 * to nsILoadGroup::defaultLoadFlags for the docShell's loadGroup. 306 * Default is no flags. Once set, only future requests initiated by the 307 * docShell are affected, so in general, these flags should be set before 308 * the docShell loads any content. 309 */ 310 attribute nsLoadFlags defaultLoadFlags; 311 312 /* 313 * returns true if the docshell is being destroyed, false otherwise 314 */ 315 [infallible] boolean isBeingDestroyed(); 316 317 /* 318 * Returns true if the docshell is currently executing the onLoad Handler 319 */ 320 readonly attribute boolean isExecutingOnLoadHandler; 321 322 attribute nsILayoutHistoryState layoutHistoryState; 323 324 /** 325 * Object used to delegate URI loading to an upper context. 326 * Currently only set for GeckoView to allow handling of load requests 327 * at the application level. 328 */ 329 readonly attribute nsILoadURIDelegate loadURIDelegate; 330 331 /** 332 * Cancel the XPCOM timers for each meta-refresh URI in this docshell, 333 * and this docshell's children, recursively. The meta-refresh timers can be 334 * restarted using resumeRefreshURIs(). If the timers are already suspended, 335 * this has no effect. 336 */ 337 void suspendRefreshURIs(); 338 339 /** 340 * Restart the XPCOM timers for each meta-refresh URI in this docshell, 341 * and this docshell's children, recursively. If the timers are already 342 * running, this has no effect. 343 */ 344 void resumeRefreshURIs(); 345 346 /** 347 * Begin firing WebProgressListener notifications for restoring a page 348 * presentation. |viewer| is the content viewer whose document we are 349 * starting to load. If null, it defaults to the docshell's current content 350 * viewer, creating one if necessary. |top| should be true for the toplevel 351 * docshell that is being restored; it will be set to false when this method 352 * is called for child docshells. This method will post an event to 353 * complete the simulated load after returning to the event loop. 354 */ 355 void beginRestore(in nsIDocumentViewer viewer, in boolean top); 356 357 /** 358 * Finish firing WebProgressListener notifications and DOM events for 359 * restoring a page presentation. This should only be called via 360 * beginRestore(). 361 */ 362 void finishRestore(); 363 364 void clearCachedUserAgent(); 365 366 void clearCachedPlatform(); 367 368 /* Track whether we're currently restoring a document presentation. */ 369 readonly attribute boolean restoringDocument; 370 371 /* attribute to access whether error pages are enabled */ 372 attribute boolean useErrorPages; 373 374 /** 375 * Display a load error in a frame while keeping that frame's currentURI 376 * pointing correctly to the page where the error ocurred, rather than to 377 * the error document page. You must provide either the aURI or aURL parameter. 378 * 379 * @param aError The error code to be displayed 380 * @param aURI nsIURI of the page where the error happened 381 * @param aURL wstring of the page where the error happened 382 * @param aFailedChannel The channel related to this error 383 * 384 * Returns whether or not we displayed an error page (note: will always 385 * return false if in-content error pages are disabled!) 386 */ 387 boolean displayLoadError(in nsresult aError, 388 in nsIURI aURI, 389 in wstring aURL, 390 [optional] in nsIChannel aFailedChannel); 391 392 /** 393 * The channel that failed to load and resulted in an error page. 394 * May be null. Relevant only to error pages. 395 */ 396 readonly attribute nsIChannel failedChannel; 397 398 /** 399 * Keeps track of the previous nsISHEntry index and the current 400 * nsISHEntry index at the time that the doc shell begins to load. 401 * Used for DocumentViewer eviction. 402 */ 403 readonly attribute long previousEntryIndex; 404 readonly attribute long loadedEntryIndex; 405 406 /** 407 * Notification that entries have been removed from the beginning of a 408 * nsSHistory which has this as its rootDocShell. 409 * 410 * @param numEntries - The number of entries removed 411 */ 412 void historyPurged(in long numEntries); 413 414 /** 415 * Gets the channel for the currently loaded document, if any. 416 * For a new document load, this will be the channel of the previous document 417 * until after OnLocationChange fires. 418 */ 419 readonly attribute nsIChannel currentDocumentChannel; 420 421 /** 422 * Find out whether the docshell is currently in the middle of a page 423 * transition. This is set just before the pagehide/unload events fire. 424 */ 425 [infallible] readonly attribute boolean isInUnload; 426 427 /** 428 * Disconnects this docshell's editor from its window, and stores the 429 * editor data in the open document's session history entry. This 430 * should be called only during page transitions. 431 */ 432 [noscript, notxpcom] void DetachEditorFromWindow(); 433 434 /** 435 * Propagated to the print preview document viewer. Must only be called on 436 * a document viewer that has been initialized for print preview. 437 */ 438 void exitPrintPreview(); 439 440 /** 441 * The ID of the docshell in the session history. 442 */ 443 readonly attribute nsIDRef historyID; 444 445 /** 446 * Helper method for accessing this value from C++ 447 */ 448 [noscript, notxpcom] nsIDRef HistoryID(); 449 450 /** 451 * Create a new about:blank document and content viewer. 452 * @param aPrincipal the principal to use for the new document. 453 * @param aPartitionedPrincipal the partitioned principal to use for the new 454 * document. 455 * @param aPolicyContainer the policyContainer to use for the new document. 456 */ 457 void createAboutBlankDocumentViewer(in nsIPrincipal aPrincipal, 458 in nsIPrincipal aPartitionedPrincipal, 459 [optional] in nsIPolicyContainer aPolicyContainer); 460 461 /** 462 * Upon getting, returns the canonical encoding label of the document 463 * currently loaded into this docshell. 464 */ 465 readonly attribute ACString charset; 466 467 void forceEncodingDetection(); 468 469 /** 470 * In a child docshell, this is the charset of the parent docshell 471 */ 472 [noscript, notxpcom, nostdcall] void setParentCharset( 473 in Encoding parentCharset, 474 in int32_t parentCharsetSource, 475 in nsIPrincipal parentCharsetPrincipal); 476 [noscript, notxpcom, nostdcall] void getParentCharset( 477 out Encoding parentCharset, 478 out int32_t parentCharsetSource, 479 out nsIPrincipal parentCharsetPrincipal); 480 481 /** 482 * Return a DOMHighResTimeStamp representing the number of 483 * milliseconds from an arbitrary point in time. The reference 484 * point is shared by all DocShells and is also used by timestamps 485 * on markers. 486 */ 487 DOMHighResTimeStamp now(); 488 489 /** 490 * Add an observer to the list of parties to be notified when this docshell's 491 * private browsing status is changed. |obs| must support weak references. 492 */ 493 void addWeakPrivacyTransitionObserver(in nsIPrivacyTransitionObserver obs); 494 495 /** 496 * Add an observer to the list of parties to be notified when reflows are 497 * occurring. |obs| must support weak references. 498 */ 499 void addWeakReflowObserver(in nsIReflowObserver obs); 500 501 /** 502 * Remove an observer from the list of parties to be notified about reflows. 503 */ 504 void removeWeakReflowObserver(in nsIReflowObserver obs); 505 506 /** 507 * Notify all attached observers that a reflow has just occurred. 508 * 509 * @param interruptible if true, the reflow was interruptible. 510 * @param start timestamp when reflow started, in milliseconds since 511 * navigationStart (accurate to 1/1000 of a ms) 512 * @param end timestamp when reflow ended, in milliseconds since 513 * navigationStart (accurate to 1/1000 of a ms) 514 */ 515 [noscript] void notifyReflowObservers(in boolean interruptible, 516 in DOMHighResTimeStamp start, 517 in DOMHighResTimeStamp end); 518 519 /** 520 * Add an observer to the list of parties to be notified when scroll position 521 * of some elements is changed. 522 */ 523 [noscript] void addWeakScrollObserver(in nsIScrollObserver obs); 524 525 /** 526 * Add an observer to the list of parties to be notified when scroll position 527 * of some elements is changed. 528 */ 529 [noscript] void removeWeakScrollObserver(in nsIScrollObserver obs); 530 531 /** 532 * Notify all attached observers that the scroll position of some element 533 * has changed. 534 */ 535 [noscript] void notifyScrollObservers(); 536 537 /** 538 * Returns true if this docshell is the top level content docshell. 539 */ 540 [infallible] readonly attribute boolean isTopLevelContentDocShell; 541 542 /** 543 * True iff asynchronous panning and zooming is enabled for this 544 * docshell. 545 */ 546 readonly attribute boolean asyncPanZoomEnabled; 547 548 /** 549 * Indicates whether the UI may enable the character encoding menu. The UI 550 * must disable the menu when this property is false. 551 */ 552 [infallible] readonly attribute boolean mayEnableCharacterEncodingMenu; 553 554 attribute nsIEditor editor; 555 readonly attribute boolean editable; /* this docShell is editable */ 556 readonly attribute boolean hasEditingSession; /* this docShell has an editing session */ 557 558 /** 559 * Make this docShell editable, setting a flag that causes 560 * an editor to get created, either immediately, or after 561 * a url has been loaded. 562 * @param inWaitForUriLoad true to wait for a URI before 563 * creating the editor. 564 */ 565 void makeEditable(in boolean inWaitForUriLoad); 566 567 /** 568 * Returns false for mLSHE, true for mOSHE 569 */ 570 boolean getCurrentSHEntry(out nsISHEntry aEntry); 571 572 /** 573 * Cherry picked parts of nsIController. 574 * They are here, because we want to call these functions 575 * from JS. 576 */ 577 boolean isCommandEnabled(in string command); 578 [can_run_script] 579 void doCommand(in string command); 580 [can_run_script] 581 void doCommandWithParams(in string command, in nsICommandParams aParams); 582 583 /** 584 * Invisible DocShell are dummy construct to simulate DOM windows 585 * without any actual visual representation. They have to be marked 586 * at construction time, to avoid any painting activity. 587 */ 588 [noscript, notxpcom] boolean IsInvisible(); 589 [noscript, notxpcom] void SetInvisible(in boolean aIsInvisibleDocshell); 590 591 /** 592 * Get the script global for the document in this docshell. 593 */ 594 [noscript,notxpcom,nostdcall] nsIScriptGlobalObject GetScriptGlobalObject(); 595 596 [noscript,notxpcom,nostdcall] Document getExtantDocument(); 597 598 /** 599 * This attribute determines whether a document which is not about:blank has 600 * already be loaded by this docShell. 601 */ 602 [infallible] readonly attribute boolean hasLoadedNonBlankURI; 603 604 /** 605 * Allow usage of -moz-window-dragging:drag for content docshells. 606 * True for top level chrome docshells. Throws if set to false with 607 * top level chrome docshell. 608 */ 609 attribute boolean windowDraggingAllowed; 610 611 /** 612 * Sets/gets the current scroll restoration mode. 613 * @see https://html.spec.whatwg.org/#dom-history-scroll-restoration 614 */ 615 attribute boolean currentScrollRestorationIsManual; 616 617 /** 618 * Setter and getter for the origin attributes living on this docshell. 619 */ 620 [implicit_jscontext] 621 jsval getOriginAttributes(); 622 623 [implicit_jscontext] 624 void setOriginAttributes(in jsval aAttrs); 625 626 /** 627 * The editing session for this docshell. 628 */ 629 readonly attribute nsIEditingSession editingSession; 630 631 /** 632 * The browser child for this docshell. 633 */ 634 [binaryname(ScriptableBrowserChild)] readonly attribute nsIBrowserChild browserChild; 635 [noscript,notxpcom,nostdcall] BrowserChildRef GetBrowserChild(); 636 637 [noscript,nostdcall,notxpcom] nsCommandManager GetCommandManager(); 638 639 /** 640 * Attribute that determines whether tracking protection is enabled. 641 */ 642 attribute boolean useTrackingProtection; 643 644 /** 645 * Fire a dummy location change event asynchronously. 646 */ 647 [noscript] void dispatchLocationChangeEvent(); 648 649 650 /** 651 * Start delayed autoplay media which are in the current document. 652 */ 653 [noscript] void startDelayedAutoplayMediaComponents(); 654 655 /** 656 * Take ownership of the ClientSource representing an initial about:blank 657 * document that was never needed. As an optimization we avoid creating 658 * this document if no code calls GetDocument(), but we still need a 659 * ClientSource object to represent the about:blank window. This may return 660 * nullptr; for example if the docshell has created a real window and document 661 * already. 662 */ 663 [noscript, nostdcall, notxpcom] 664 UniqueClientSource TakeInitialClientSource(); 665 666 void setColorMatrix(in Array<float> aMatrix); 667 668 /** 669 * Returns true if the current load is a forced reload, 670 * e.g. started by holding shift whilst triggering reload. 671 */ 672 readonly attribute boolean isForceReloading; 673 674 Array<float> getColorMatrix(); 675 676 %{C++ 677 /** 678 * These methods call nsDocShell::GetHTMLEditorInternal() and 679 * nsDocShell::SetHTMLEditorInternal() with static_cast. 680 */ 681 mozilla::HTMLEditor* GetHTMLEditor(); 682 nsresult SetHTMLEditor(mozilla::HTMLEditor* aHTMLEditor); 683 %} 684 685 /** 686 * The message manager for this docshell. This does not throw, but 687 * can return null if the docshell has no message manager. 688 */ 689 [infallible] readonly attribute ContentFrameMessageManager messageManager; 690 691 /** 692 * This returns a Promise which resolves to a boolean. True when the 693 * document has Tracking Content that has been blocked from loading, false 694 * otherwise. 695 */ 696 Promise getHasTrackingContentBlocked(); 697 698 /** 699 * Return whether this docshell is "attempting to navigate" in the 700 * sense that's relevant to document.open. 701 */ 702 [notxpcom, nostdcall] readonly attribute boolean isAttemptingToNavigate; 703 704 /* 705 * Whether or not this docshell is executing a nsIWebNavigation navigation 706 * method. 707 * 708 * This will be true when the following methods are executing: 709 * nsIWebNavigation.binaryLoadURI 710 * nsIWebNavigation.goBack 711 * nsIWebNavigation.goForward 712 * nsIWebNavigation.gotoIndex 713 * nsIWebNavigation.loadURI 714 */ 715 [infallible] readonly attribute boolean isNavigating; 716 717 /** 718 * @see nsISHEntry synchronizeLayoutHistoryState(). 719 */ 720 void synchronizeLayoutHistoryState(); 721 722 /** 723 * This attempts to save any applicable layout history state (like 724 * scroll position) in the nsISHEntry. This is normally done 725 * automatically when transitioning from page to page in the 726 * same process. We expose this function to support transitioning 727 * from page to page across processes as a workaround for bug 1630234 728 * until session history state is moved into the parent process. 729 */ 730 void persistLayoutHistoryState(); 731 };