Bugzilla

  if (container) {

    CallQueryInterface(container, &docShellTreeItem);

  }

pref("browser.sessionhistory.max_viewers", 5);

#include "pldhash.h"

  /**

   * Sanitize the document by resetting all input elements and forms that have

   * autocomplete=off to their default values.

   */

  virtual nsresult Sanitize() = 0;

  /**

   * Enumerate all subdocuments.

   */

  typedef PRBool (*nsSubDocEnumFunc)(nsIDocument *aDocument, void *aData);

  virtual void EnumerateSubDocuments(nsSubDocEnumFunc aCallback,

                                     void *aData) = 0;

#include "nsIDOMHTMLFormElement.h"

nsresult

nsDocument::Sanitize()

{

    // Sanitize the document by resetting all password fields and any form

    // fields with autocomplete=off to their default values.  We do this now,

    // instead of when the presentation is restored, to offer some protection

    // in case there is ever an exploit that allows a cached document to be

    // accessed from a different document.

    // First locate all input elements, regardless of whether they are

    // in a form, and reset the password and autocomplete=off elements.

    nsCOMPtr<nsIDOMNodeList> nodes;

    nsresult rv = GetElementsByTagName(NS_LITERAL_STRING("input"),

                                       getter_AddRefs(nodes));

    NS_ENSURE_SUCCESS(rv, rv);

    PRUint32 length = 0;

    if (nodes)

        nodes->GetLength(&length);

    nsCOMPtr<nsIDOMNode> item;

    nsCOMPtr<nsIDOMHTMLInputElement> input;

    nsAutoString value;

    PRUint32 i;

    for (i = 0; i < length; ++i) {

        nodes->Item(i, getter_AddRefs(item));

        NS_ASSERTION(item, "null item in node list!");

        input = do_QueryInterface(item);

        if (!input)

            continue;

        PRBool resetValue = PR_FALSE;

        input->GetAttribute(NS_LITERAL_STRING("autocomplete"), value);

        if (value.LowerCaseEqualsLiteral("off")) {

            resetValue = PR_TRUE;

        } else {

            input->GetType(value);

            if (value.LowerCaseEqualsLiteral("password"))

                resetValue = PR_TRUE;

        }

        if (resetValue) {

            nsCOMPtr<nsIFormControl> fc = do_QueryInterface(input);

            fc->Reset();

        }

    }

    // Now locate all _form_ elements that have autocomplete=off and reset them

    rv = GetElementsByTagName(NS_LITERAL_STRING("form"),

                              getter_AddRefs(nodes));

    NS_ENSURE_SUCCESS(rv, rv);

    length = 0;

    if (nodes)

        nodes->GetLength(&length);

    nsCOMPtr<nsIDOMHTMLFormElement> form;

    for (i = 0; i < length; ++i) {

        nodes->Item(i, getter_AddRefs(item));

        NS_ASSERTION(item, "null item in nodelist");

        form = do_QueryInterface(item);

        if (!form)

            continue;

        form->GetAttribute(NS_LITERAL_STRING("autocomplete"), value);

        if (value.LowerCaseEqualsLiteral("off"))

            form->Reset();

    }

    return NS_OK;

}

struct SubDocEnumData

{

  nsIDocument::nsSubDocEnumFunc callback;

  void *data;

};

PR_STATIC_CALLBACK(PLDHashOperator)

SubDocHashEnum(PLDHashTable *table, PLDHashEntryHdr *hdr,

               PRUint32 number, void *arg)

{

  SubDocMapEntry *entry = NS_STATIC_CAST(SubDocMapEntry*, hdr);

  SubDocEnumData *data = NS_STATIC_CAST(SubDocEnumData*, arg);

  nsIDocument *subdoc = entry->mSubDocument;

  PRBool next = PR_TRUE;

  if (subdoc)

    next = data->callback(subdoc, data->data);

  return next ? PL_DHASH_NEXT : PL_DHASH_STOP;

}

void

nsDocument::EnumerateSubDocuments(nsSubDocEnumFunc aCallback, void *aData)

{

  if (mSubDocuments) {

    SubDocEnumData data = { aCallback, aData };

    PL_DHashTableEnumerate(mSubDocuments, SubDocHashEnum, &data);

  }

}

  virtual NS_HIDDEN_(nsresult) Sanitize();

  virtual NS_HIDDEN_(void) EnumerateSubDocuments(nsSubDocEnumFunc aCallback,

                                                 void *aData);

    NS_IMETHOD PageRestore(nsIDOMEvent* aEvent);

    NS_IMETHOD PageRestore(nsIDOMEvent* aEvent);

NS_IMETHODIMP

txLoadListenerProxy::PageRestore(nsIDOMEvent* aEvent)

{

    nsCOMPtr<nsIDOMLoadListener> listener = do_QueryReferent(mParent);

    if (listener) {

        return listener->PageRestore(aEvent);

    }

    return NS_OK;

}

nsSyncLoader::PageRestore(nsIDOMEvent* aEvent)

{

    return NS_OK;

}

NS_IMETHODIMP

  /**

   * Allows us to quickly determine if we have unload or beforeunload

   * listeners registered.

   */

  virtual PRBool HasUnloadListeners() = 0;

  "DOMPageRestore", "submit", "reset", "change", "select", "input", "paint",

  "text", "compositionstart", "compositionend", "popupshowing", "popupshown",

    else if (atom == nsLayoutAtoms::onDOMPageRestore)

      mEvent->message = NS_PAGE_RESTORE;

  case NS_PAGE_RESTORE:

    return sEventNames[eDOMEvents_DOMPageRestore];

    eDOMEvents_DOMPageRestore,

  {NS_BEFORE_PAGE_UNLOAD,HANDLER(&nsIDOMLoadListener::BeforeUnload), NS_EVENT_BITS_LOAD_BEFORE_UNLOAD},

  {NS_PAGE_RESTORE,HANDLER(&nsIDOMLoadListener::PageRestore), NS_EVENT_BITS_LOAD_PAGE_RESTORE}

  else if (aType == nsLayoutAtoms::onDOMPageRestore) {

    *aArrayType = eEventArrayType_Load;

    *aFlags = NS_EVENT_BITS_LOAD_PAGE_RESTORE;

  }

PRBool

nsEventListenerManager::HasUnloadListeners()

{

  nsVoidArray *listeners = GetListenersByType(eEventArrayType_Load, nsnull,

                                              PR_FALSE);

  if (listeners) {

    PRInt32 count = listeners->Count();

    for (PRInt32 i = 0; i < count; ++i) {

      PRUint32 subtype = NS_STATIC_CAST(nsListenerStruct*,

                                        listeners->FastElementAt(i))->mSubType;

      if (subtype == NS_EVENT_BITS_NONE || subtype & NS_EVENT_BITS_LOAD_UNLOAD)

        return PR_TRUE;

    }

  }

  return PR_FALSE;

}

  virtual PRBool HasUnloadListeners();

#define NS_EVENT_BITS_LOAD_PAGE_RESTORE      0x20

            if (win) {

              nsIFocusController *focusController =

                win->GetRootFocusController();

              PRBool isActive = PR_FALSE;

              focusController->GetActive(&isActive);

              if (!isActive) {

                nsCOMPtr<nsIDOMElement> domElement = do_QueryInterface(this);

                if(domElement)

                  focusController->SetFocusedElement(domElement);

                break;

              }

  if (win) {

    nsIFocusController *focusController = win->GetRootFocusController();

    PRBool isActive = PR_FALSE;

    focusController->GetActive(&isActive);

    if (!isActive) {

      focusController->SetFocusedWindow(win);

      focusController->SetFocusedElement(this);

      return;

    }

    if (win) {

      nsIFocusController *focusController = win->GetRootFocusController();

      PRBool isActive = PR_FALSE;

      focusController->GetActive(&isActive);

      if (!isActive) {

        focusController->SetFocusedWindow(win);

        focusController->SetFocusedElement(this);

        SelectAll(presContext);

        return NS_OK;

      }

      if (privateWindow)

        focusController = privateWindow->GetRootFocusController();

  NS_IMETHOD BeforeUnload(nsIDOMEvent* aEvent) { return NS_OK; }

  NS_IMETHOD Unload(nsIDOMEvent* aEvent) { return NS_OK; }

  NS_IMETHOD Abort(nsIDOMEvent* aEvent) { return NS_OK; }

  NS_IMETHOD Error(nsIDOMEvent* aEvent) { return NS_OK; }

  NS_IMETHOD PageRestore(nsIDOMEvent* aEvent) { return NS_OK; }

  NS_IMETHOD HandleEvent(nsIDOMEvent* aEvent) { return NS_OK; }

#define DEBUG_PAGE_CACHE

#include "nsGUIEvent.h"

#include "nsIPrivateDOMEvent.h"

#include "nsIDOMEventReceiver.h"

#include "nsIEventListenerManager.h"

        mLSHE->GetIsSubFrame(&isSubFrame);

        rv = shEntry->GetURI(getter_AddRefs(oldUri));

        mOSHE->SetTitle(mTitle);    

PRBool

nsDocShell::CanSavePresentation()

{

    // If the document is not done loading, don't cache it.

    nsCOMPtr<nsPIDOMWindow> pWin = do_QueryInterface(mScriptGlobal);

    if (pWin && pWin->IsLoading())

        return PR_FALSE;

    // Only save presentation for "normal" loads and link loads.  Anything else

    // probably wants to refetch the page, so caching the old presentation

    // would be incorrect.

    if (mLoadType != LOAD_NORMAL &&

        mLoadType != LOAD_HISTORY &&

        mLoadType != LOAD_LINK)

        return PR_FALSE;

    // If there is an unload or beforeunload listener on the window, then we do

    // not save the presentation into the session history cache.

    nsCOMPtr<nsIDOMEventReceiver> er = do_QueryInterface(mScriptGlobal);

    if (er) {

        nsCOMPtr<nsIEventListenerManager> eventManager;

        er->GetListenerManager(getter_AddRefs(eventManager));

        if (eventManager && eventManager->HasUnloadListeners())

            return PR_FALSE;

    }

    // If the session history entry has the saveLayoutState flag set to false,

    // then we should not cache the presentation.

    if (!mOSHE)

        return PR_FALSE; // no entry to save into

    PRBool canSaveState;

    mOSHE->GetSaveLayoutStateFlag(&canSaveState);

    return canSaveState;

}

// CaptureState() is called when saving presentation into session history,

// before any teardown of the document or content viewer.

nsresult

nsDocShell::CaptureState()

{

    nsCOMPtr<nsPIDOMWindow> privWin = do_QueryInterface(mScriptGlobal);

    if (!privWin || !mOSHE)

        return NS_ERROR_FAILURE;

    nsCOMPtr<nsISupports> windowState;

    nsresult rv = privWin->SaveWindowState(getter_AddRefs(windowState));

    NS_ENSURE_SUCCESS(rv, rv);

#ifdef DEBUG_PAGE_CACHE

    nsCOMPtr<nsIURI> uri;

    mOSHE->GetURI(getter_AddRefs(uri));

    nsCAutoString spec;

    if (uri)

        uri->GetSpec(spec);

    printf("Saving presentation into session history\n");

    printf("  SH URI: %s\n", spec.get());

#endif

    rv = mOSHE->SetWindowState(windowState);

    NS_ENSURE_SUCCESS(rv, rv);

    nsCOMPtr<nsIPresShell> shell;

    nsDocShell::GetPresShell(getter_AddRefs(shell));

    if (shell) {

        nsIViewManager *vm = shell->GetViewManager();

        if (vm) {

            nsIView *rootView = nsnull;

            vm->GetRootView(rootView);

            if (rootView) {

                nsIWidget *widget = rootView->GetWidget();

                if (widget) {

                    nsRect bounds(0, 0, 0, 0);

                    widget->GetBounds(bounds);

                    rv = mOSHE->SetViewerBounds(bounds);

                }

            }

        }

    }

    // Capture the docshell hierarchy

    PRInt32 childCount = mChildList.Count();

    nsCOMPtr<nsIDocShellTreeItem> childShell;

    mOSHE->ClearChildShells();

    for (PRInt32 i = 0; i < childCount; ++i) {

        childShell = do_QueryInterface(ChildAt(i));

        NS_ASSERTION(childShell, "null child shell");

        mOSHE->AddChildShell(childShell);

    }

    return rv;

}

nsresult

nsDocShell::RestorePresentation(nsIURI *aURI, nsISHEntry *aSHEntry)

{

    nsCOMPtr<nsIContentViewer> viewer;

    aSHEntry->GetContentViewer(getter_AddRefs(viewer));

#ifdef DEBUG_PAGE_CACHE

    nsCAutoString spec;

    if (aURI)

        aURI->GetSpec(spec);

#endif

    if (!viewer) {

#ifdef DEBUG_PAGE_CACHE

        printf("no saved presentation for uri: %s\n", spec.get());

#endif

        return NS_ERROR_FAILURE;

    }

    NS_ASSERTION(mContentViewer != viewer, "Restoring existing presentation");

#ifdef DEBUG_PAGE_CACHE

    printf("restoring presentation from session history: %s\n", spec.get());

#endif

    // Save off the root view's parent and sibling so that we can insert the

    // new content viewer's root view at the same position.  Also save the

    // bounds of the root view's widget.

    nsIView *rootViewSibling = nsnull, *rootViewParent = nsnull;

    nsRect newBounds(0, 0, 0, 0);

    nsCOMPtr<nsIPresShell> oldPresShell;

    nsDocShell::GetPresShell(getter_AddRefs(oldPresShell));

    if (oldPresShell) {

        nsIViewManager *vm = oldPresShell->GetViewManager();

        if (vm) {

            nsIView *oldRootView = nsnull;

            vm->GetRootView(oldRootView);

            if (oldRootView) {

                rootViewSibling = oldRootView->GetNextSibling();

                rootViewParent = oldRootView->GetParent();

                nsIWidget *widget = oldRootView->GetWidget();

                if (widget) {

                    widget->GetBounds(newBounds);

                }

            }

        }

    }

    // Transfer ownership to mContentViewer.  By ensuring that either the

    // docshell or the session history, but not both, have references to the

    // content viewer, we prevent the viewer from being torn down after

    // Destroy() is called.

    PRBool savePresentation = CanSavePresentation();

    if (!savePresentation)

        FireUnloadNotification();

    mFiredUnloadEvent = PR_FALSE;

    if (mContentViewer) {

        mContentViewer->Close();

        if (savePresentation)

            mContentViewer->SetHistoryEntry(mOSHE);

        mContentViewer->Destroy();

    }

    mContentViewer.swap(viewer);

    viewer = nsnull; // force a release to complete ownership transfer

    // Pulling the viewer out of the CachedPresentation will thaw() it.

    // We must first open it to prevent pending destruction.

    nsresult rv = mContentViewer->Open();

    NS_ENSURE_SUCCESS(rv, rv);

    // Now remove it from the cached presentation.

    aSHEntry->SetContentViewer(nsnull);

    // Restore our child docshell hierarchy.

    PRInt32 i = 0;

    nsCOMPtr<nsIDocShellTreeItem> childShell;

    DestroyChildren();

    while (NS_SUCCEEDED(aSHEntry->ChildShellAt(i++,

                                               getter_AddRefs(childShell))) &&

           childShell) {

        AddChild(childShell);

    }

    // And release the references in the history entry.

    aSHEntry->ClearChildShells();

    // restore the sticky state of the viewer

    PRBool sticky;

    aSHEntry->GetSticky(&sticky);

    mContentViewer->SetSticky(sticky);

    // save the previous content viewer size

    nsRect oldBounds(0, 0, 0, 0);

    aSHEntry->GetViewerBounds(oldBounds);

    // Insert the new root view at the correct location in the view tree.

    if (rootViewParent) {

        nsIViewManager *parentVM = rootViewParent->GetViewManager();

        nsCOMPtr<nsIPresShell> shell;

        nsDocShell::GetPresShell(getter_AddRefs(shell));

        if (parentVM && shell) {

            nsIViewManager *newVM = shell->GetViewManager();

            if (newVM) {

                nsIView *newRootView = nsnull;

                newVM->GetRootView(newRootView);

                if (newRootView) {

                    parentVM->InsertChild(rootViewParent, newRootView,

                                          rootViewSibling, PR_TRUE);

                    NS_ASSERTION(newRootView->GetNextSibling() ==

                                 rootViewSibling,

                                 "error in InsertChild");

                    if (oldPresShell)

                        oldPresShell->InvalidateViewManagers();

                }

            }

        }

    }

    // restore the state of the window object

    nsCOMPtr<nsPIDOMWindow> privWin =

        do_GetInterface(NS_STATIC_CAST(nsIInterfaceRequestor*, this));

    NS_ASSERTION(privWin, "could not get nsPIDOMWindow interface");

    nsCOMPtr<nsISupports> windowState;

    aSHEntry->GetWindowState(getter_AddRefs(windowState));

    rv = privWin->RestoreWindowState(windowState);

    NS_ENSURE_SUCCESS(rv, rv);

    aSHEntry->SetWindowState(nsnull);

    mOSHE = aSHEntry;

    EndPageLoad(nsnull, nsnull, NS_OK);

    nsCOMPtr<nsISHistory> rootSH;

    GetRootSessionHistory(getter_AddRefs(rootSH));

    if (rootSH && (mLoadType & LOAD_CMD_HISTORY)) {

        nsCOMPtr<nsISHistoryInternal> hist = do_QueryInterface(rootSH);

        hist->UpdateIndex();

    }

    // Make sure this presentation is the same size as the previous

    // presentation.  If this is not the same size we showed it at last time,

    // then we need to resize the widget.

    // XXXbryner   This interacts poorly with Firefox's infobar.  If the old

    // presentation had the infobar visible, then we will resize the new

    // presentation to that smaller size.  However, firing the locationchanged

    // event will hide the infobar, which will immediately resize the window

    // back to the larger size.  A future optimization might be to restore

    // the presentation at the "wrong" size, then fire the locationchanged

    // event and check whether the docshell's new size is the same as the

    // cached viewer size (skipping the resize if they are equal).

    nsCOMPtr<nsIPresShell> shell;

    nsDocShell::GetPresShell(getter_AddRefs(shell));

    if (shell) {

        nsIViewManager *vm = shell->GetViewManager();

        if (vm) {

            nsIView *rootView = nsnull;

            vm->GetRootView(rootView);

            if (rootView) {

                nsIWidget *widget = rootView->GetWidget();

                if (widget && !newBounds.IsEmpty()) {

#ifdef DEBUG_PAGE_CACHE

                    printf("resize widget(%d, %d, %d, %d)\n", newBounds.x,

                           newBounds.y, newBounds.width, newBounds.height);

#endif

                    widget->Resize(newBounds.x, newBounds.y, newBounds.width,

                                   newBounds.height, PR_FALSE);

                }

            }

        }

    }

    SetCurrentURI(aURI);

    // Dispatch events.  This is a little messy.  We need to avoid firing

    // onload so that it is visible from the content DOM window, but we _do_

    // want the chrome to see it for chrome/extensions that look for page load.

    // In addition, we need to fire DOMPageRestore on the content window.

    nsEvent event(NS_PAGE_LOAD);

    nsEventStatus status = nsEventStatus_eIgnore;

    nsCOMPtr<nsIChromeEventHandler> handler = privWin->GetChromeEventHandler();

    nsCOMPtr<nsPresContext> presContext;

    GetPresContext(getter_AddRefs(presContext));

    PRUint32 flags = NS_EVENT_FLAG_INIT;

    event.flags |= flags;

    flags &= ~(NS_EVENT_FLAG_CANT_BUBBLE | NS_EVENT_FLAG_CANT_CANCEL);

    flags |= NS_EVENT_FLAG_BUBBLE | NS_EVENT_FLAG_CAPTURE;

    nsIDOMEvent *domEvt = nsnull;

    rv = handler->HandleChromeEvent(presContext, &event, &domEvt,

                                    flags & NS_EVENT_CAPTURE_MASK, &status);

    NS_ENSURE_SUCCESS(rv, rv);

    if (domEvt) {

        nsrefcnt rc;

        NS_RELEASE2(domEvt, rc);

        if (0 != rc) {

            // Okay, so someone in the DOM loop (a listener, JS object)

            // still has a ref to the DOM Event but the internal data

            // hasn't been malloc'd.  Force a copy of the data here so the

            // DOM Event is still valid.

            nsCOMPtr<nsIPrivateDOMEvent> privateEvent =

                do_QueryInterface(domEvt);

            if (privateEvent) {

                privateEvent->DuplicatePrivateData();

            }

        }

    }

    if (mScriptGlobal) {

        nsEventStatus status = nsEventStatus_eIgnore;

        nsEvent restoreEvent(NS_PAGE_RESTORE);

        nsCOMPtr<nsPresContext> presContext;

        nsDocShell::GetPresContext(getter_AddRefs(presContext));

        if (presContext) {

            mScriptGlobal->HandleDOMEvent(presContext, &restoreEvent, nsnull,

                                          NS_EVENT_FLAG_INIT, &status);

        }

    }

    rv = mContentViewer->Show();

    NS_ENSURE_SUCCESS(rv, rv);

    // Restart plugins

    if (shell)

        shell->StartPlugins();

    // XXXbryner  Making this invalidate synchronous causes unpainted areas

    // (on Mac, at least) if the above locationchanged event hides Firefox's

    // infobar.  Doing it asynchronously seems to work around the problem, but

    // shouldn't the style change that hides the infobar handle all necessary

    // invalidation, including the newly-exposed area?

    return mParentWidget->Invalidate(PR_FALSE);

}

    PRBool savePresentation = CanSavePresentation();

    if (!savePresentation)

        FireUnloadNotification();

    if (savePresentation) {

        // The old content viewer will be saved during the call to Embed().

        rv = CaptureState();

        // XXX this isn't really fatal, necessarily...

        // should we try to fire unload if NS_FAILED(rv) ?

    }

    nsCOMPtr<nsIDOMDocument> oldDocument;

        mContentViewer->GetDOMDocument(getter_AddRefs(oldDocument));

        if (CanSavePresentation()) {

            // Tell the old content viewer to hibernate in session history when

            // it is destroyed.

            mContentViewer->SetHistoryEntry(mOSHE);

        }

                    shEntry->SetTitle(mTitle);

    // If we have a saved content viewer in history, restore and show it now.

    if (aSHEntry) {

        if (!CanSavePresentation())

            FireUnloadNotification();

        mFiredUnloadEvent = PR_FALSE;

        CaptureState();

        rv = RestorePresentation(aURI, aSHEntry);

        if (NS_SUCCEEDED(rv))

            return rv;

    }

    entry->Create(aURI,              // uri

                  EmptyString(),     // Title

                  inputStream,       // Post data stream

                  nsnull,            // LayoutHistory state

                  cacheKey,          // CacheKey

    NS_ENSURE_SUCCESS(aEntry->GetURI(getter_AddRefs(uri)), NS_ERROR_FAILURE);

    if (!src || !replaceEntry)

    PRBool CanSavePresentation();

    nsresult CaptureState();

    nsresult RestorePresentation(nsIURI *aURI, nsISHEntry *aSHEntry);

interface nsISHEntry;

  /**

   * Attach the content viewer to its DOM window and docshell.

   */

  void open();

  /**

   * Set the  session history entry for the content viewer.  If this is set,

   * then the following actions will happen when destroy() is called (*):

   *  - Sanitize() will be called on the viewer's document

   *  - The content viewer will set the contentViewer property on the

   *    history entry, and release its reference (ownership reversal).

   *  - hide() will be called, and no further destruction will happen.

   *

   *  (*) unless the document is currently being printed

   */

  void setHistoryEntry(in nsISHEntry entry);

  // Check whether a document is currently loading

  PRBool IsLoading() const

  {

    return !mIsDocumentLoaded;

  }

  // Returns an object containing the window's state.

  virtual nsresult SaveWindowState(nsISupports **aState) = 0;

  // Restore the window state from aState.

  virtual nsresult RestoreWindowState(nsISupports *aState) = 0;

{0x0f7fa587, 0xaac5, 0x11d9, \

{0xba, 0x4e, 0x00, 0x11, 0x24, 0x78, 0xd6, 0x26} }

  /**

   * Processes a DOMPageRestore event.  This is dispatched when a page's

   * presentation is restored from session history (onload does not fire

   * in this case).

   * @param aEvent The event object

   */

  NS_IMETHOD PageRestore(nsIDOMEvent* aEvent) = 0;

#include "nsIDOMNSHTMLElement.h"

#include "nsIDOMXULElement.h"

#ifdef DEBUG_bryner

#define DEBUG_PAGE_CACHE

#endif

      if (parent) {

        nsCOMPtr<nsIDOMWindow> tempParent;

        parent->GetTop(getter_AddRefs(tempParent));

        return NS_STATIC_CAST(nsGlobalWindow *,

                              NS_STATIC_CAST(nsIDOMWindow*, tempParent));

      }

#define WINDOWSTATEHOLDER_IID \

{0xae1c7401, 0xcdee, 0x404a, {0xbd, 0x63, 0x05, 0xc0, 0x35, 0x0d, 0xa7, 0x72}}

class WindowStateHolder : public nsISupports

{

public:

  NS_DEFINE_STATIC_IID_ACCESSOR(WINDOWSTATEHOLDER_IID)

  NS_DECL_ISUPPORTS

  WindowStateHolder(JSContext *cx, JSObject *aObject, nsGlobalWindow *aWindow);

  JSObject* GetObject() { return mJSObj; }

  nsIEventListenerManager* GetListenerManager() { return mListenerManager; }

  nsIDOMElement* GetFocusedElement() { return mFocusedElement; }

  nsIDOMWindowInternal* GetFocusedWindow() { return mFocusedWindow; }

  nsTimeout* GetSavedTimeouts() { return mSavedTimeouts; }

  void ClearSavedTimeouts() { mSavedTimeouts = nsnull; }

private:

  ~WindowStateHolder();

  JSRuntime *mRuntime;

  JSObject *mJSObj;

  nsCOMPtr<nsIEventListenerManager> mListenerManager;

  nsCOMPtr<nsIDOMElement> mFocusedElement;

  nsCOMPtr<nsIDOMWindowInternal> mFocusedWindow;

  nsTimeout *mSavedTimeouts;

};

WindowStateHolder::WindowStateHolder(JSContext *cx, JSObject *aObject,

                                     nsGlobalWindow *aWindow)

  : mRuntime(::JS_GetRuntime(cx)), mJSObj(aObject), mSavedTimeouts(nsnull)

{

  NS_ASSERTION(aWindow, "null window");

  aWindow->GetListenerManager(getter_AddRefs(mListenerManager));

  nsIFocusController *fc = aWindow->GetRootFocusController();

  NS_ASSERTION(fc, "null focus controller");

  // We want to save the focused element/window only if they are inside of

  // this window.

  nsCOMPtr<nsIDOMWindowInternal> focusWinInternal;

  fc->GetFocusedWindow(getter_AddRefs(focusWinInternal));

  nsPIDOMWindow *focusedWindow =

    NS_STATIC_CAST(nsPIDOMWindow*,

                   NS_STATIC_CAST(nsGlobalWindow*,

                                  NS_STATIC_CAST(nsIDOMWindowInternal*,

                                                 focusWinInternal)));

  while (focusedWindow) {

    if (focusedWindow == aWindow) {

      fc->GetFocusedWindow(getter_AddRefs(mFocusedWindow));

      fc->GetFocusedElement(getter_AddRefs(mFocusedElement));

      break;

    }

    focusedWindow =

      NS_STATIC_CAST(nsGlobalWindow*, focusedWindow)->GetPrivateParent();

  }

  aWindow->SuspendTimeouts();

  // Clear the timeout list for aWindow (but we don't need to for children)

  mSavedTimeouts = aWindow->mTimeouts;

  aWindow->mTimeouts = nsnull;

  ::JS_AddNamedRoot(cx, &mJSObj, "WindowStateHolder::mJSObj");

}

WindowStateHolder::~WindowStateHolder()

{

  ::JS_RemoveRootRT(mRuntime, &mJSObj);

}

NS_IMPL_ISUPPORTS1(WindowStateHolder, WindowStateHolder)

static JSClass sWindowStateClass = {

  "window state", 0,

  JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,

  JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, JS_FinalizeStub,

  JSCLASS_NO_OPTIONAL_MEMBERS

};

static void

CopyJSPropertyArray(JSContext *cx, JSObject *aSource, JSObject *aDest,

                    JSIdArray *props)

{

  jsint length = props->length;

  jsint i;

  for (i = 0; i < length; ++i) {

    jsval propname_value;

    if (!::JS_IdToValue(cx, props->vector[i], &propname_value) ||

        !JSVAL_IS_STRING(propname_value)) {

      NS_WARNING("Failed to copy non-string window property\n");

      continue;

    }

    char *propname_str = ::JS_GetStringBytes(JSVAL_TO_STRING(propname_value));

    uintN attrs;

    JSBool found;

    if (!::JS_GetPropertyAttributes(cx, aSource, propname_str, &attrs, &found))

      continue;

    if (!found)

      continue;

    jsval propvalue;

    if (!::JS_GetProperty(cx, aSource, propname_str, &propvalue)) {

      NS_WARNING("property was found, but get failed");

      continue;

    }

    PRBool res = ::JS_DefineProperty(cx, aDest, propname_str, propvalue,

                                     NULL, NULL, attrs);

#ifdef DEBUG_PAGE_CACHE

    if (res)

      printf("Copied window property: %s\n", propname_str);

#endif

#ifdef DEBUG

    if (!res)

      printf("failed to copy property: %s\n", propname_str);

#endif

  }

}

static void

CopyJSProperties(JSContext *cx, JSObject *aSource, JSObject *aDest)

{

  // Enumerate all of the properties on aSource and install them on aDest.

  JSIdArray *props = ::JS_Enumerate(cx, aSource);

  if (!props) {

#ifdef DEBUG_PAGE_CACHE

    printf("[no properties]\n");

#endif

    return;

  }

#ifdef DEBUG_PAGE_CACHE

  printf("props length = %d\n", props->length);

#endif

  CopyJSPropertyArray(cx, aSource, aDest, props);

  ::JS_DestroyIdArray(cx, props);

}

nsresult

nsGlobalWindow::SaveWindowState(nsISupports **aState)

{

  *aState = nsnull;

  if (!mContext || !mJSObject) {

    // The window may be getting torn down; don't bother saving state.

    return NS_OK;

  }

  JSContext *cx = NS_STATIC_CAST(JSContext*, mContext->GetNativeContext());

  NS_ENSURE_TRUE(cx, NS_ERROR_FAILURE);

  JSObject *stateObj = ::JS_NewObject(cx, &sWindowStateClass, NULL, NULL);

  NS_ENSURE_TRUE(stateObj, NS_ERROR_OUT_OF_MEMORY);

#ifdef DEBUG_PAGE_CACHE

  printf("saving window state, stateObj = %p\n", stateObj);

#endif

  CopyJSProperties(cx, mJSObject, stateObj);

  *aState = new WindowStateHolder(cx, stateObj, this);

  NS_ENSURE_TRUE(*aState, NS_ERROR_OUT_OF_MEMORY);

  NS_ADDREF(*aState);

  return NS_OK;

}

nsresult

nsGlobalWindow::RestoreWindowState(nsISupports *aState)

{

  if (!mContext || !mJSObject) {

    // The window may be getting torn down; don't bother restoring state.

    return NS_OK;

  }

  JSContext *cx = NS_STATIC_CAST(JSContext*, mContext->GetNativeContext());

  NS_ENSURE_TRUE(cx, NS_ERROR_FAILURE);

  // Note that we don't need to call JS_ClearScope here.  The scope is already

  // cleared by SetNewDocument(), and calling it again here will remove the

  // XPConnect properties.

  nsCOMPtr<WindowStateHolder> holder = do_QueryInterface(aState);

  if (holder) {

#ifdef DEBUG_PAGE_CACHE

    printf("restoring window state, stateObj = %p\n", holder->GetObject());

#endif

    CopyJSProperties(cx, holder->GetObject(), mJSObject);

    mListenerManager = holder->GetListenerManager();

    nsIDOMElement *focusedElement = holder->GetFocusedElement();

    if (focusedElement) {

      nsCOMPtr<nsIDOMNSHTMLElement> htmlElement =

        do_QueryInterface(focusedElement);

      if (htmlElement) {

        htmlElement->Focus();

      } else {

        nsCOMPtr<nsIDOMXULElement> xulElement =

          do_QueryInterface(focusedElement);

        if (xulElement) {

          xulElement->Focus();

        }

      }

    } else {

      nsIDOMWindowInternal *focusedWindow = holder->GetFocusedWindow();

      if (focusedWindow) {

        focusedWindow->Focus();

      }

    }

  }

  mTimeouts = holder->GetSavedTimeouts();

  holder->ClearSavedTimeouts();

  return ResumeTimeouts();

}

void

nsGlobalWindow::SuspendTimeouts()

{

  PRInt64 now = PR_IntervalNow();

  for (nsTimeout *t = mTimeouts; t; t = t->mNext) {

    // For each non-interval timeout, we change mWhen to be the time remaining.

    if (!t->mInterval)

      t->mWhen = PR_MAX(0, t->mWhen - now);

    // Drop the XPCOM timer; we'll reschedule when restoring the state.

    if (t->mTimer) {

      t->mTimer->Cancel();

      t->mTimer = nsnull;

    }

    // We don't Release() the timeout because we still need it.

  }

  // Suspend our children as well.

  nsCOMPtr<nsIDocShellTreeNode> node = do_QueryInterface(mDocShell);

  if (node) {

    PRInt32 childCount = 0;

    node->GetChildCount(&childCount);

    nsCOMPtr<nsIDocShellTreeItem> childShell;

    for (PRInt32 i = 0; i < childCount; ++i) {

      node->GetChildAt(i, getter_AddRefs(childShell));

      NS_ASSERTION(childShell, "null child shell");

      nsCOMPtr<nsPIDOMWindow> pWin = do_GetInterface(childShell);

      if (pWin) {

        nsGlobalWindow *win =

          NS_STATIC_CAST(nsGlobalWindow*,

                         NS_STATIC_CAST(nsPIDOMWindow*, pWin));

        win->SuspendTimeouts();

      }

    }

  }

}

nsresult

nsGlobalWindow::ResumeTimeouts()

{

  // Restore all of the timeouts.  Interval timeouts are rescheduled as before;

  // non-interval timers are scheduled using the stored time remaining.

  PRInt64 now = PR_IntervalNow();

  nsresult rv;

  for (nsTimeout *t = mTimeouts; t; t = t->mNext) {

    PRInt32 interval;

    if (t->mInterval) {

      interval = t->mInterval;

    } else {

      interval = t->mWhen;

      t->mWhen += now;

    }

    t->mTimer = do_CreateInstance("@mozilla.org/timer;1");

    NS_ENSURE_TRUE(t->mTimer, NS_ERROR_OUT_OF_MEMORY);

    rv = t->mTimer->InitWithFuncCallback(TimerCallback, t, interval,

                                         nsITimer::TYPE_ONE_SHOT);

    NS_ENSURE_SUCCESS(rv, rv);

  }

  // Resume our children as well.

  nsCOMPtr<nsIDocShellTreeNode> node = do_QueryInterface(mDocShell);

  if (node) {

    PRInt32 childCount = 0;

    node->GetChildCount(&childCount);

    nsCOMPtr<nsIDocShellTreeItem> childShell;

    for (PRInt32 i = 0; i < childCount; ++i) {

      node->GetChildAt(i, getter_AddRefs(childShell));

      NS_ASSERTION(childShell, "null child shell");

      nsCOMPtr<nsPIDOMWindow> pWin = do_GetInterface(childShell);

      if (pWin) {

        nsGlobalWindow *win =

          NS_STATIC_CAST(nsGlobalWindow*,

                         NS_STATIC_CAST(nsPIDOMWindow*, pWin));

        rv = win->ResumeTimeouts();

        NS_ENSURE_SUCCESS(rv, rv);

      }

    }

  }

  return NS_OK;

}

  virtual NS_HIDDEN_(nsresult) SaveWindowState(nsISupports **aState);

  virtual NS_HIDDEN_(nsresult) RestoreWindowState(nsISupports *aState);

  virtual NS_HIDDEN_(void) SuspendTimeouts();

  virtual NS_HIDDEN_(nsresult) ResumeTimeouts();

  friend class WindowStateHolder;

    if (window) {

      PRInt32 scrollX, scrollY;

      window->GetScrollX(&scrollX);

      window->GetScrollY(&scrollY);

      xDelta += scrollX; // Normal direction.

      yDelta -= scrollY; // Remember, y is flipped.

      xDelta += XMENUOFFSET;

      yDelta -= MENUHEIGHT*(selIndex+1);

      NSEvent* event = [NSApp currentEvent];

      NSPoint point = [event locationInWindow];

      point.x -= xDelta;

      point.y -= yDelta;