Attachment #182608 for bug #274784

Attachment #182608: pref'd off patch w/ short circuit and crash fix for bug #274784

View | Details | Raw Unified | Return to bug 274784
Collapse All | Expand All

(-)accessible/src/base/nsAccessNode.cpp (-1 / +3 lines)

Line	Link Here

Lines 498-504 nsAccessNode::GetDocShellTreeItemFor(nsI	Link Here

498

  NS_ASSERTION(doc, "No document for node passed in");

498

  NS_ASSERTION(doc, "No document for node passed in");

499

  nsCOMPtr<nsISupports> container = doc->GetContainer();

499

  nsCOMPtr<nsISupports> container = doc->GetContainer();

500

  nsIDocShellTreeItem *docShellTreeItem = nsnull;

500

  nsIDocShellTreeItem *docShellTreeItem = nsnull;

501

  CallQueryInterface(container, &docShellTreeItem);

501

  if (container) {

502

    CallQueryInterface(container, &docShellTreeItem);

503

502

504

503

  return docShellTreeItem;

505

  return docShellTreeItem;

504

506

-      Line
+  Link Here
-       Lines 88-97
      class nsHTMLStyleSheet;
+  Link Here
 class nsIHTMLCSSStyleSheet;
 // IID for the nsIDocument interface
+// f01b47c6-6271-4c0d-b786-eb5eee222b45
 #define NS_IDOCUMENT_IID      \
+{ 0x8bc6ae5f, 0xb396, 0x11d9, \
+  { 0xb1, 0x4f, 0x00, 0x11, 0x24, 0x78, 0xd6, 0x26 } }
 // The base value for the content ID counter.
 // This counter is used by the document to
-       Lines 665-670
      public:
+  Link Here
     return mPartID;
+  }
+  /**
+   * 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.
+   * The enumerator callback should return PR_TRUE to continue enumerating, or
+   * PR_FALSE to stop.
+   */
+  typedef PRBool (*nsSubDocEnumFunc)(nsIDocument *aDocument, void *aData);
+  virtual void EnumerateSubDocuments(nsSubDocEnumFunc aCallback,
+                                     void *aData) = 0;
+  /**
+   * Check whether it is safe to cache the presentation of this document
+   * and all of its subdocuments. This method checks the following conditions
+   * recursively:
+   *  - Some document types, such as plugin documents, cannot be safely cached.
+   *  - If there are any pending requests, we don't allow the presentation
+   *    to be cached.  Ideally these requests would be suspended and resumed,
+   *    but that is difficult in some cases, such as XMLHttpRequest.
+   *  - If there are any beforeunload or unload listeners, we must fire them
+   *    for correctness, but this likely puts the document into a state where
+   *    it would not function correctly if restored.
+   *
+   * |aNewRequest| should be the request for a new document which will
+   * replace this document in the docshell.  The new document's request
+   * will be ignored when checking for active requests.  If there is no
+   * request associated with the new document, this parameter may be null.
+   */
+  virtual PRBool CanSavePresentation(nsIRequest *aNewRequest) = 0;
+  /**
+   * Notify the document that its associated ContentViewer is being destroyed.
+   * This releases circular references so that the document can go away.
+   * Destroy() is only called on documents that have a content viewer.
+   */
+  virtual void Destroy() = 0;
 protected:
   ~nsIDocument()
+  {

-      Line
+  Link Here
-       Lines 126-131
      static NS_DEFINE_CID(kDOMEventGroupCID,
+  Link Here
 #include "nsIScriptContext.h"
 #include "nsBindingManager.h"
+#include "nsIDOMHTMLFormElement.h"
+#include "nsIRequest.h"
 #include "nsICharsetAlias.h"
 static NS_DEFINE_CID(kCharsetAliasCID, NS_CHARSETALIAS_CID);
-       Lines 1851-1887
      nsDocument::GetScriptGlobalObject() cons
+  Link Here
 void
 nsDocument::SetScriptGlobalObject(nsIScriptGlobalObject *aScriptGlobalObject)
+{
+  // XXX HACK ALERT! If the script context owner is null, the document
+  // will soon be going away. So tell our content that to lose its
+  // reference to the document. This has to be done before we actually
+  // set the script context owner to null so that the content elements
+  // can remove references to their script objects.
+  if (!aScriptGlobalObject) {
+    PRInt32 count, indx;
+    count = mChildren.Count();
+    mIsGoingAway = PR_TRUE;
+    for (indx = 0; indx < count; ++indx) {
+      mChildren[indx]->UnbindFromTree();
+    }
+    // Propagate the out-of-band notification to each PresShell's
+    // anonymous content as well. This ensures that there aren't any
+    // accidental script references left in anonymous content keeping
+    // the document alive. (While not strictly necessary -- the
+    // PresShell owns us -- it's tidy.)
+    for (count = mPresShells.Count() - 1; count >= 0; --count) {
+      nsCOMPtr<nsIPresShell> shell =
+        NS_STATIC_CAST(nsIPresShell*, mPresShells[count]);
+      if (!shell)
+        continue;
+      shell->ReleaseAnonymousContent();
+    }
+  }
   mScriptGlobalObject = aScriptGlobalObject;
+}
-       Lines 4609-4611
      nsDocument::UnsetProperty(nsIAtom *aProp
+  Link Here
+{
   return mPropertyTable.UnsetProperty(this, aPropertyName, aStatus);
+}
+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;
+  nsAutoString value;
+  PRUint32 i;
+  for (i = 0; i < length; ++i) {
+    nodes->Item(i, getter_AddRefs(item));
+    NS_ASSERTION(item, "null item in node list!");
+    nsCOMPtr<nsIDOMHTMLInputElement> 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);
+  for (i = 0; i < length; ++i) {
+    nodes->Item(i, getter_AddRefs(item));
+    NS_ASSERTION(item, "null item in nodelist");
+    nsCOMPtr<nsIDOMHTMLFormElement> form = do_QueryInterface(item);
+    if (!form)
+      continue;
+    form->GetAttribute(NS_LITERAL_STRING("autocomplete"), value);
+    if (value.LowerCaseEqualsLiteral("off"))
+      form->Reset();
+  }
+  return NS_OK;
+}
+struct SubDocEnumArgs
+{
+  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);
+  SubDocEnumArgs *args = NS_STATIC_CAST(SubDocEnumArgs*, arg);
+  nsIDocument *subdoc = entry->mSubDocument;
+  PRBool next = subdoc ? args->callback(subdoc, args->data) : PR_TRUE;
+  return next ? PL_DHASH_NEXT : PL_DHASH_STOP;
+}
+void
+nsDocument::EnumerateSubDocuments(nsSubDocEnumFunc aCallback, void *aData)
+{
+  if (mSubDocuments) {
+    SubDocEnumArgs args = { aCallback, aData };
+    PL_DHashTableEnumerate(mSubDocuments, SubDocHashEnum, &args);
+  }
+}
+PR_STATIC_CALLBACK(PLDHashOperator)
+CanCacheSubDocument(PLDHashTable *table, PLDHashEntryHdr *hdr,
+                    PRUint32 number, void *arg)
+{
+  SubDocMapEntry *entry = NS_STATIC_CAST(SubDocMapEntry*, hdr);
+  PRBool *canCacheArg = NS_STATIC_CAST(PRBool*, arg);
+  nsIDocument *subdoc = entry->mSubDocument;
+  // The aIgnoreRequest we were passed is only for us, so don't pass it on.
+  PRBool canCache = subdoc ? subdoc->CanSavePresentation(nsnull) : PR_FALSE;
+  if (!canCache) {
+    *canCacheArg = PR_FALSE;
+    return PL_DHASH_STOP;
+  }
+  return PL_DHASH_NEXT;
+}
+#ifdef DEBUG_bryner
+#define DEBUG_PAGE_CACHE
+#endif
+PRBool
+nsDocument::CanSavePresentation(nsIRequest *aNewRequest)
+{
+  // Check our event listneer manager for unload/beforeunload listeners.
+  nsCOMPtr<nsIDOMEventReceiver> er = do_QueryInterface(mScriptGlobalObject);
+  if (er) {
+    nsCOMPtr<nsIEventListenerManager> manager;
+    er->GetListenerManager(getter_AddRefs(manager));
+    if (manager && manager->HasUnloadListeners()) {
+      return PR_FALSE;
+    }
+  }
+  nsCOMPtr<nsILoadGroup> loadGroup = GetDocumentLoadGroup();
+  if (loadGroup) {
+    nsCOMPtr<nsISimpleEnumerator> requests;
+    loadGroup->GetRequests(getter_AddRefs(requests));
+    PRBool hasMore = PR_FALSE;
+    while (NS_SUCCEEDED(requests->HasMoreElements(&hasMore)) && hasMore) {
+      nsCOMPtr<nsISupports> elem;
+      requests->GetNext(getter_AddRefs(elem));
+      nsCOMPtr<nsIRequest> request = do_QueryInterface(elem);
+      if (request && request != aNewRequest) {
+#ifdef DEBUG_PAGE_CACHE
+        nsCAutoString requestName, docSpec;
+        request->GetName(requestName);
+        if (mDocumentURI)
+          mDocumentURI->GetSpec(docSpec);
+        printf("document %s has request %s\n",
+               docSpec.get(), requestName.get());
+#endif
+        return PR_FALSE;
+      }
+    }
+  }
+  PRBool canCache = PR_TRUE;
+  if (mSubDocuments)
+    PL_DHashTableEnumerate(mSubDocuments, CanCacheSubDocument, &canCache);
+  return canCache;
+}
+void
+nsDocument::Destroy()
+{
+  // The ContentViewer wants to release the document now.  So, tell our content
+  // to drop any references to the document so that it can be destroyed.
+  PRInt32 count = mChildren.Count();
+  mIsGoingAway = PR_TRUE;
+  for (PRInt32 indx = 0; indx < count; ++indx) {
+    mChildren[indx]->UnbindFromTree();
+  }
+  // Propagate the out-of-band notification to each PresShell's anonymous
+  // content as well. This ensures that there aren't any accidental references
+  // left in anonymous content keeping the document alive. (While not strictly
+  // necessary -- the PresShell owns us -- it's tidy.)
+  for (count = mPresShells.Count() - 1; count >= 0; --count) {
+    nsCOMPtr<nsIPresShell> shell =
+      NS_STATIC_CAST(nsIPresShell*, mPresShells[count]);
+    if (!shell)
+      continue;
+    shell->ReleaseAnonymousContent();
+  }
+}





  virtual NS_HIDDEN_(void*) UnsetProperty(nsIAtom  *aPropertyName,
                                          nsresult *aStatus = nsnull);

  virtual NS_HIDDEN_(nsresult) Sanitize();

  virtual NS_HIDDEN_(void) EnumerateSubDocuments(nsSubDocEnumFunc aCallback,
                                                 void *aData);

  virtual NS_HIDDEN_(PRBool) CanSavePresentation(nsIRequest *aNewRequest);
  virtual NS_HIDDEN_(void) Destroy();

protected:

  void RetrieveRelevantHeaders(nsIChannel *aChannel);


  nsHashtable mRadioGroups;

  // True if the document has been detached from its content viewer.
  PRPackedBool mIsGoingAway;

  // True if the document is being destroyed.

(-)content/base/src/nsGenericElement.cpp (-1 / +3 lines)

Line	Link Here

Lines 2586-2592 nsGenericElement::SetFocus(nsPresContext	Link Here

2586

PRBool

2586

PRBool

2587

nsGenericElement::ShouldFocus(nsIContent *aContent)

2587

nsGenericElement::ShouldFocus(nsIContent *aContent)

2588

2589

  PRBool visible = PR_TRUE;

2589

  // Default to false, since if the document is not attached to a window,

2590

  // we should not focus any of its content.

2591

  PRBool visible = PR_FALSE;

2590

2592

2591

  // Figure out if we're focusing an element in an inactive (hidden)

2593

  // Figure out if we're focusing an element in an inactive (hidden)

2592

  // tab (whose docshell is not visible), if so, drop this focus

2594

  // tab (whose docshell is not visible), if so, drop this focus





    NS_IMETHOD Unload(nsIDOMEvent* aEvent);
    NS_IMETHOD Abort(nsIDOMEvent* aEvent);
    NS_IMETHOD Error(nsIDOMEvent* aEvent);
    NS_IMETHOD PageRestore(nsIDOMEvent* aEvent);

    NS_DECL_NSICHANNELEVENTSINK


    NS_IMETHOD Unload(nsIDOMEvent* aEvent);
    NS_IMETHOD Abort(nsIDOMEvent* aEvent);
    NS_IMETHOD Error(nsIDOMEvent* aEvent);
    NS_IMETHOD PageRestore(nsIDOMEvent* aEvent);

protected:
    nsWeakPtr  mParent;

    return NS_OK;
}

NS_IMETHODIMP
txLoadListenerProxy::PageRestore(nsIDOMEvent* aEvent)
{
    nsCOMPtr<nsIDOMLoadListener> listener = do_QueryReferent(mParent);

    if (listener) {
        return listener->PageRestore(aEvent);
    }

    return NS_OK;
}

class nsForceXMLListener : public nsIStreamListener
{
public:

}

NS_IMETHODIMP
nsSyncLoader::PageRestore(nsIDOMEvent* aEvent)
{
    return NS_OK;
}

NS_IMETHODIMP
nsSyncLoader::OnChannelRedirect(nsIChannel *aOldChannel,
                                nsIChannel *aNewChannel,
                                PRUint32    aFlags)





 * Event listener manager interface.
 */
#define NS_IEVENTLISTENERMANAGER_IID \
{0xc23b877c, 0xb396, 0x11d9, \
{0x86, 0xbd, 0x00, 0x11, 0x24, 0x78, 0xd6, 0x26} }
{0xbd, 0x85, 0x00, 0x80, 0x5f, 0x8a, 0xe3, 0xf4} }

class nsIEventListenerManager : public nsISupports {


  * Loop pass for evaluation of system event listeners.
  */
  NS_IMETHOD GetSystemEventGroupLM(nsIDOMEventGroup** aGroup) = 0;

  /**
   * Allows us to quickly determine whether we have unload or beforeunload
   * listeners registered.
   */
  virtual PRBool HasUnloadListeners() = 0;
};

nsresult

(-)content/events/src/nsDOMEvent.cpp (-2 / +6 lines)

Line	Link Here

Lines 58-65 static const char* const sEventNames[] =	Link Here

  "mousedown", "mouseup", "click", "dblclick", "mouseover",

  "mousedown", "mouseup", "click", "dblclick", "mouseover",

  "mouseout", "mousemove", "contextmenu", "keydown", "keyup", "keypress",

  "mouseout", "mousemove", "contextmenu", "keydown", "keyup", "keypress",

  "focus", "blur", "load", "beforeunload", "unload", "abort", "error",

  "focus", "blur", "load", "beforeunload", "unload", "abort", "error",

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

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

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

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

  "popuphiding", "popuphidden", "close", "command", "broadcast", "commandupdate",

  "popuphiding", "popuphidden", "close", "command", "broadcast", "commandupdate",

  "dragenter", "dragover", "dragexit", "dragdrop", "draggesture", "resize",

  "dragenter", "dragover", "dragexit", "dragdrop", "draggesture", "resize",

  "scroll","overflow", "underflow", "overflowchanged",

  "scroll","overflow", "underflow", "overflowchanged",

Lines 434-439 nsDOMEvent::SetEventType(const nsAString	Link Here

434

      mEvent->message = NS_IMAGE_ABORT;

434

      mEvent->message = NS_IMAGE_ABORT;

435

    else if (atom == nsLayoutAtoms::onerror)

435

    else if (atom == nsLayoutAtoms::onerror)

436

      mEvent->message = NS_IMAGE_ERROR;

436

      mEvent->message = NS_IMAGE_ERROR;

437

    else if (atom == nsLayoutAtoms::onDOMPageRestore)

438

      mEvent->message = NS_PAGE_RESTORE;

437

  } else if (mEvent->eventStructType == NS_MUTATION_EVENT) {

439

  } else if (mEvent->eventStructType == NS_MUTATION_EVENT) {

438

    if (atom == nsLayoutAtoms::onDOMAttrModified)

440

    if (atom == nsLayoutAtoms::onDOMAttrModified)

439

      mEvent->message = NS_MUTATION_ATTRMODIFIED;

441

      mEvent->message = NS_MUTATION_ATTRMODIFIED;

Lines 794-799 const char* nsDOMEvent::GetEventName(PRU	Link Here

794

  case NS_IMAGE_ERROR:

796

  case NS_IMAGE_ERROR:

795

  case NS_SCRIPT_ERROR:

797

  case NS_SCRIPT_ERROR:

796

    return sEventNames[eDOMEvents_error];

798

    return sEventNames[eDOMEvents_error];

799

  case NS_PAGE_RESTORE:

800

    return sEventNames[eDOMEvents_DOMPageRestore];

797

  case NS_FORM_SUBMIT:

801

  case NS_FORM_SUBMIT:

798

    return sEventNames[eDOMEvents_submit];

802

    return sEventNames[eDOMEvents_submit];

799

  case NS_FORM_RESET:

803

  case NS_FORM_RESET:

(-)content/events/src/nsDOMEvent.h (+1 lines)

Line	Link Here

Lines 85-90 public:	Link Here

    eDOMEvents_unload,

    eDOMEvents_unload,

    eDOMEvents_abort,

    eDOMEvents_abort,

    eDOMEvents_error,

    eDOMEvents_error,

    eDOMEvents_DOMPageRestore,

    eDOMEvents_submit,

    eDOMEvents_submit,

    eDOMEvents_reset,

    eDOMEvents_reset,

    eDOMEvents_change,

    eDOMEvents_change,

(-)content/events/src/nsEventListenerManager.cpp (-1 / +26 lines)

Line	Link Here

Lines 241-247 static const EventDispatchData sLoadEven	Link Here

241

  {NS_PAGE_UNLOAD, HANDLER(&nsIDOMLoadListener::Unload),NS_EVENT_BITS_LOAD_UNLOAD},

241

  {NS_PAGE_UNLOAD, HANDLER(&nsIDOMLoadListener::Unload),NS_EVENT_BITS_LOAD_UNLOAD},

242

  {NS_IMAGE_ERROR, HANDLER(&nsIDOMLoadListener::Error), NS_EVENT_BITS_LOAD_ERROR},

242

  {NS_IMAGE_ERROR, HANDLER(&nsIDOMLoadListener::Error), NS_EVENT_BITS_LOAD_ERROR},

243

  {NS_SCRIPT_ERROR,HANDLER(&nsIDOMLoadListener::Error), NS_EVENT_BITS_LOAD_ERROR},

243

  {NS_SCRIPT_ERROR,HANDLER(&nsIDOMLoadListener::Error), NS_EVENT_BITS_LOAD_ERROR},

244

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

244

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

245

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

245

};

246

};

246

247

static const EventDispatchData sPaintEvents[] = {

248

static const EventDispatchData sPaintEvents[] = {

Lines 891-896 nsEventListenerManager::GetIdentifiersFo	Link Here

891

    *aArrayType = eEventArrayType_Load;

892

    *aArrayType = eEventArrayType_Load;

892

    *aFlags = NS_EVENT_BITS_LOAD_ERROR;

893

    *aFlags = NS_EVENT_BITS_LOAD_ERROR;

893

894

895

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

896

    *aArrayType = eEventArrayType_Load;

897

    *aFlags = NS_EVENT_BITS_LOAD_PAGE_RESTORE;

898

894

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

899

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

895

    *aArrayType = eEventArrayType_Paint;

900

    *aArrayType = eEventArrayType_Paint;

896

    *aFlags = NS_EVENT_BITS_PAINT_PAINT;

901

    *aFlags = NS_EVENT_BITS_PAINT_PAINT;

Lines 2232-2237 nsEventListenerManager::GetCoordinatesFo	Link Here

2232

2237

2233

2238

2234

2239

2240

PRBool

2241

nsEventListenerManager::HasUnloadListeners()

2242

2243

  nsVoidArray *listeners = GetListenersByType(eEventArrayType_Load, nsnull,

2244

                                              PR_FALSE);

2245

  if (listeners) {

2246

    PRInt32 count = listeners->Count();

2247

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

2248

      PRUint32 subtype = NS_STATIC_CAST(nsListenerStruct*,

2249

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

2250

      if (subtype == NS_EVENT_BITS_NONE ||

2251

          subtype & (NS_EVENT_BITS_LOAD_UNLOAD |

2252

                     NS_EVENT_BITS_LOAD_BEFORE_UNLOAD))

2253

        return PR_TRUE;

2254

2255

2256

2257

  return PR_FALSE;

2258

2259

2235

nsresult

2260

nsresult

2236

NS_NewEventListenerManager(nsIEventListenerManager** aInstancePtrResult)

2261

NS_NewEventListenerManager(nsIEventListenerManager** aInstancePtrResult)

2237

2262

(-)content/events/src/nsEventListenerManager.h (+3 lines)

Line	Link Here

Lines 164-169 public:	Link Here

164

165

  NS_IMETHOD GetSystemEventGroupLM(nsIDOMEventGroup** aGroup);

165

  NS_IMETHOD GetSystemEventGroupLM(nsIDOMEventGroup** aGroup);

166

167

  virtual PRBool HasUnloadListeners();

168

167

  static nsresult GetIdentifiersForType(nsIAtom* aType,

169

  static nsresult GetIdentifiersForType(nsIAtom* aType,

168

                                        EventArrayType* aArrayType,

170

                                        EventArrayType* aArrayType,

169

                                        PRInt32* aSubType);

171

                                        PRInt32* aSubType);

Lines 301-306 protected:	Link Here

301

#define NS_EVENT_BITS_LOAD_ABORT             0x04

303

#define NS_EVENT_BITS_LOAD_ABORT             0x04

302

#define NS_EVENT_BITS_LOAD_ERROR             0x08

304

#define NS_EVENT_BITS_LOAD_ERROR             0x08

303

#define NS_EVENT_BITS_LOAD_BEFORE_UNLOAD     0x10

305

#define NS_EVENT_BITS_LOAD_BEFORE_UNLOAD     0x10

306

#define NS_EVENT_BITS_LOAD_PAGE_RESTORE      0x20

304

307

305

//nsIDOMXULListener

308

//nsIDOMXULListener

306

#define NS_EVENT_BITS_XUL_NONE               0x00

309

#define NS_EVENT_BITS_XUL_NONE               0x00





            // nothing else.
            nsCOMPtr<nsPIDOMWindow> win =
              do_QueryInterface(document->GetScriptGlobalObject());
            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;
              }
            }
  
            aPresContext->EventStateManager()->





  // nothing else.
  nsCOMPtr<nsPIDOMWindow> win =
    do_QueryInterface(doc->GetScriptGlobalObject());
  if (win) {
    nsIFocusController *focusController = win->GetRootFocusController();
    PRBool isActive = PR_FALSE;
    focusController->GetActive(&isActive);
    if (!isActive) {
      focusController->SetFocusedWindow(win);
      focusController->SetFocusedElement(this);

      return;
    }
  }

  aPresContext->EventStateManager()->SetContentState(this,

    // nothing else.
    nsCOMPtr<nsPIDOMWindow> win =
      do_QueryInterface(doc->GetScriptGlobalObject());
    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;
      }
    }

    // Just like SetFocus() but without the ScrollIntoView()!





                                     nsIContentSink*     aSink = nsnull);

  virtual void SetScriptGlobalObject(nsIScriptGlobalObject* aScriptGlobalObject);
  virtual void Destroy();

  NS_DECL_NSIIMAGEDOCUMENT


}

void
nsImageDocument::Destroy()
{
  // Remove our event listener from the image content.
  if (mImageResizingEnabled) {
    nsCOMPtr<nsIDOMEventTarget> target = do_QueryInterface(mImageContent);
    target->RemoveEventListener(NS_LITERAL_STRING("click"), this, PR_FALSE);
  }

  // Break reference cycle with mImageContent, if we have one
  nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mImageContent);
  if (imageLoader) {
    imageLoader->RemoveObserver(this);
  }

  mImageContent = nsnull;

  nsMediaDocument::Destroy();
}

void
nsImageDocument::SetScriptGlobalObject(nsIScriptGlobalObject* aScriptGlobalObject)
{
  // If the script global object is changing, we need to unhook our event
  // listeners on the window.
  nsCOMPtr<nsIDOMEventTarget> target;
  if (mImageResizingEnabled && mScriptGlobalObject &&
      aScriptGlobalObject != mScriptGlobalObject) {
    target = do_QueryInterface(mScriptGlobalObject);
    target->RemoveEventListener(NS_LITERAL_STRING("resize"), this, PR_FALSE);
    target->RemoveEventListener(NS_LITERAL_STRING("keypress"), this,
                                PR_FALSE);
  }

  // Set the script global object on the superclass before doing

  nsHTMLDocument::SetScriptGlobalObject(aScriptGlobalObject);

  if (aScriptGlobalObject) {
    if (!mRootContent) {
      // Create synthetic document
      nsresult rv = CreateSyntheticDocument();
      NS_ASSERTION(NS_SUCCEEDED(rv), "failed to create synthetic document");

      if (mImageResizingEnabled) {
        target = do_QueryInterface(mImageContent);
        target->AddEventListener(NS_LITERAL_STRING("click"), this, PR_FALSE);
      }
    }

    if (mImageResizingEnabled) {
      nsCOMPtr<nsIDOMEventTarget> target = do_QueryInterface(mImageContent);
      target->AddEventListener(NS_LITERAL_STRING("click"), this, PR_FALSE);

      target = do_QueryInterface(aScriptGlobalObject);
      target->AddEventListener(NS_LITERAL_STRING("resize"), this, PR_FALSE);
      target->AddEventListener(NS_LITERAL_STRING("keypress"), this, PR_FALSE);





                                     nsIContentSink*     aSink = nsnull);

  virtual void SetScriptGlobalObject(nsIScriptGlobalObject* aScriptGlobalObject);
  virtual PRBool CanSavePresentation(nsIRequest *aNewRequest);

protected:
  nsresult CreateSyntheticPluginDocument();

}


PRBool
nsPluginDocument::CanSavePresentation(nsIRequest *aNewRequest)
{
  // Full-page plugins cannot be cached, currently, because we don't have
  // the stream listener data to feed to the plugin instance.
  return PR_FALSE;
}


nsresult
nsPluginDocument::StartDocumentLoad(const char*         aCommand,
                                    nsIChannel*         aChannel,

(-)content/xbl/src/nsXBLPrototypeHandler.cpp (+2 lines)

Line	Link Here

Lines 289-294 nsXBLPrototypeHandler::ExecuteHandler(ns	Link Here

289

          return NS_ERROR_FAILURE;

289

          return NS_ERROR_FAILURE;

290

291

        privateWindow = do_QueryInterface(doc->GetScriptGlobalObject());

291

        privateWindow = do_QueryInterface(doc->GetScriptGlobalObject());

292

        if (!privateWindow)

293

          return NS_ERROR_FAILURE;

292

294

293

295

294

      focusController = privateWindow->GetRootFocusController();

296

      focusController = privateWindow->GetRootFocusController();

(-)content/xbl/src/nsXBLService.cpp (-5 / +6 lines)

Line	Link Here

Lines 229-239 public:	Link Here

229

  NS_DECL_NSIREQUESTOBSERVER

229

  NS_DECL_NSIREQUESTOBSERVER

230

231

  NS_IMETHOD Load(nsIDOMEvent* aEvent);

231

  NS_IMETHOD Load(nsIDOMEvent* aEvent);

232

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

232

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

233

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

233

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

234

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

234

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

235

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

235

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

236

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

236

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

237

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

237

238

#ifdef MOZ_XUL

239

#ifdef MOZ_XUL

239

  static nsIXULPrototypeCache* gXULCache;

240

  static nsIXULPrototypeCache* gXULCache;

-      Line
+  Link Here
-       Lines 166-174
      static NS_DEFINE_CID(kDOMScriptObjectFac
+  Link Here
 #if defined(DEBUG_bryner)
 //#define DEBUG_DOCSHELL_FOCUS
+#define DEBUG_PAGE_CACHE
 #endif
 #include "plevent.h"
+#include "nsGUIEvent.h"
+#include "nsIPrivateDOMEvent.h"
 // Number of documents currently loading
 static PRInt32 gNumberOfDocumentsLoading = 0;
-       Lines 246-251
      nsDocShell::nsDocShell():
+  Link Here
     mIsBeingDestroyed(PR_FALSE),
     mIsExecutingOnLoadHandler(PR_FALSE),
     mIsPrintingOrPP(PR_FALSE),
+    mSavingOldViewer(PR_FALSE),
     mAppType(nsIDocShell::APP_TYPE_UNKNOWN),
     mChildOffset(0),
     mBusyFlags(BUSY_FLAGS_NONE),
-       Lines 1355-1366
      nsDocShell::SetCurrentURI(nsIURI *aURI,
+  Link Here
         isRoot = PR_TRUE;
+    }
     if (mLSHE) {
+        mLSHE->GetIsSubFrame(&isSubFrame);
+      // Check if this is a subframe navigation
+      if (historyEntry) {
+        historyEntry->GetIsSubFrame(&isSubFrame);
+      }
+    }
     if (!isSubFrame && !isRoot) {
-       Lines 1675-1680
      nsDocShell::TabToTreeOwner(PRBool aForwa
+  Link Here
     return NS_OK;
+}
+NS_IMETHODIMP
+nsDocShell::GetSecurityUI(nsISecureBrowserUI **aSecurityUI)
+{
+    NS_IF_ADDREF(*aSecurityUI = mSecurityUI);
+    return NS_OK;
+}
+NS_IMETHODIMP
+nsDocShell::SetSecurityUI(nsISecureBrowserUI *aSecurityUI)
+{
+    mSecurityUI = aSecurityUI;
+    return NS_OK;
+}
 //*****************************************************************************
 // nsDocShell::nsIDocShellTreeItem
 //*****************************************************************************
-       Lines 3257-3268
      nsDocShell::LoadPage(nsISupports *aPageD
+  Link Here
     // load the page as view-source
     //
     if (nsIWebPageDescriptor::DISPLAY_AS_SOURCE == aDisplayType) {
+        nsCOMPtr<nsIHistoryEntry> srcHE(do_QueryInterface(shEntry));
         nsCOMPtr<nsIURI> oldUri, newUri;
         nsCString spec, newSpec;
         // Create a new view-source URI and replace the original.
+        rv = shEntry->GetURI(getter_AddRefs(oldUri));
         if (NS_FAILED(rv))
               return rv;
-       Lines 3716-3722
      nsDocShell::SetTitle(const PRUnichar * a
+  Link Here
     // would suffice.
     if (mOSHE && (mLoadType != LOAD_BYPASS_HISTORY) &&
         (mLoadType != LOAD_HISTORY) && (mLoadType != LOAD_ERROR_PAGE)) {
+        mOSHE->SetTitle(mTitle);
+    }
-       Lines 4312-4317
      nsDocShell::CancelRefreshURITimers()
+  Link Here
+}
 NS_IMETHODIMP
+nsDocShell::SuspendRefreshURIs()
+{
+    if (mRefreshURIList) {
+        PRUint32 n = 0;
+        mRefreshURIList->Count(&n);
+        for (PRUint32 i = 0;  i < n; ++i) {
+            nsCOMPtr<nsITimer> timer = do_QueryElementAt(mRefreshURIList, i);
+            if (!timer)
+                continue;  // this must be a nsRefreshURI already
+            // Replace this timer object with a nsRefreshTimer object.
+            nsCOMPtr<nsITimerCallback> callback;
+            timer->GetCallback(getter_AddRefs(callback));
+            timer->Cancel();
+            nsCOMPtr<nsRefreshTimer> rt = do_QueryInterface(callback);
+            NS_ASSERTION(rt, "RefreshURIList timer callbacks should only be RefreshTimer objects");
+            mRefreshURIList->ReplaceElementAt(rt, i);
+        }
+    }
+    // Suspend refresh URIs for our child shells as well.
+    PRInt32 n = mChildList.Count();
+    for (PRInt32 i = 0; i < n; ++i) {
+        nsCOMPtr<nsIDocShell> shell = do_QueryInterface(ChildAt(i));
+        if (shell)
+            shell->SuspendRefreshURIs();
+    }
+    return NS_OK;
+}
+NS_IMETHODIMP
+nsDocShell::ResumeRefreshURIs()
+{
+    RefreshURIFromQueue();
+    // Resume refresh URIs for our child shells as well.
+    PRInt32 n = mChildList.Count();
+    for (PRInt32 i = 0; i < n; ++i) {
+        nsCOMPtr<nsIDocShell> shell = do_QueryInterface(ChildAt(i));
+        if (shell)
+            shell->ResumeRefreshURIs();
+    }
+    return NS_OK;
+}
+nsresult
 nsDocShell::RefreshURIFromQueue()
+{
     if (!mRefreshURIList)
-       Lines 4697-4702
      nsDocShell::CreateAboutBlankContentViewe
+  Link Here
   return rv;
+}
+PRBool
+nsDocShell::CanSavePresentation(nsIRequest *aNewRequest)
+{
+    if (!mOSHE)
+        return PR_FALSE; // no entry to save into
+    // 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 the session history entry has the saveLayoutState flag set to false,
+    // then we should not cache the presentation.
+    PRBool canSaveState;
+    mOSHE->GetSaveLayoutStateFlag(&canSaveState);
+    if (canSaveState == PR_FALSE)
+        return PR_FALSE;
+    // If the document is not done loading, don't cache it.
+    nsCOMPtr<nsPIDOMWindow> pWin = do_QueryInterface(mScriptGlobal);
+    if (!pWin || pWin->IsLoading())
+        return PR_FALSE;
+    // Avoid doing the work of saving the presentation state in the case where
+    // the content viewer cache is disabled.
+    PRInt32 maxViewers = 0;
+    mPrefs->GetIntPref("browser.sessionhistory.max_viewers", &maxViewers);
+    if (maxViewers == 0)
+        return PR_FALSE;
+    // If the document does not want its presentation cached, then don't.
+    nsCOMPtr<nsIDocument> doc = do_QueryInterface(pWin->GetExtantDocument());
+    if (!doc || !doc->CanSavePresentation(aNewRequest))
+        return PR_FALSE;
+    return PR_TRUE;
+}
+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);
+    // Suspend refresh URIs and save off the timer queue
+    SuspendRefreshURIs();
+    rv = mOSHE->SetRefreshURIList(mRefreshURIList);
+    NS_ENSURE_SUCCESS(rv, rv);
+    mRefreshURIList = nsnull;
+    // Capture the current content viewer bounds.
+    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.
+    mOSHE->ClearChildShells();
+    PRInt32 childCount = mChildList.Count();
+    for (PRInt32 i = 0; i < childCount; ++i) {
+        nsCOMPtr<nsIDocShellTreeItem> childShell = do_QueryInterface(ChildAt(i));
+        NS_ASSERTION(childShell, "null child shell");
+        mOSHE->AddChildShell(childShell);
+    }
+    // Capture the security state.
+    nsCOMPtr<nsISupports> securityState;
+    if (mSecurityUI)
+        mSecurityUI->CaptureState(getter_AddRefs(securityState));
+    return mOSHE->SetSecurityState(securityState);
+}
+NS_IMETHODIMP
+nsDocShell::FireRestoreEvents()
+{
+    // These events fire bottom-up, so call this on our children first.
+    PRInt32 n = mChildList.Count();
+    for (PRInt32 i = 0; i < n; ++i) {
+        nsCOMPtr<nsIDocShell> child = do_QueryInterface(ChildAt(i));
+        if (child) {
+            child->FireRestoreEvents();
+        }
+    }
+    // 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.
+    nsCOMPtr<nsIDocumentViewer> docViewer = do_QueryInterface(mContentViewer);
+    NS_ASSERTION(docViewer, "should not be called with a null viewer");
+    nsCOMPtr<nsIPresShell> shell;
+    docViewer->GetPresShell(getter_AddRefs(shell));
+    NS_ENSURE_TRUE(shell, NS_ERROR_UNEXPECTED);
+    nsEvent event(PR_TRUE, NS_PAGE_LOAD);
+    nsEventStatus status = nsEventStatus_eIgnore;
+    nsCOMPtr<nsPIDOMWindow> privWin = do_QueryInterface(mScriptGlobal);
+    NS_ENSURE_TRUE(privWin, NS_ERROR_UNEXPECTED);
+    nsCOMPtr<nsIChromeEventHandler> handler = privWin->GetChromeEventHandler();
+    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;
+    nsPresContext *pc = shell->GetPresContext();
+    nsresult rv = handler->HandleChromeEvent(pc, &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();
+            }
+        }
+    }
+    status = nsEventStatus_eIgnore;
+    nsEvent restoreEvent(PR_TRUE, NS_PAGE_RESTORE);
+    return mScriptGlobal->HandleDOMEvent(pc, &restoreEvent, nsnull,
+                                         NS_EVENT_FLAG_INIT, &status);
+}
+nsresult
+nsDocShell::RestorePresentation(nsISHEntry *aSHEntry, PRBool aSavePresentation,
+                                PRBool *aRestored)
+{
+    NS_ASSERTION(mLoadType & LOAD_CMD_HISTORY,
+                 "RestorePresentation should only be called for history loads");
+    nsCOMPtr<nsIURI> uri;
+    aSHEntry->GetURI(getter_AddRefs(uri));
+    nsCOMPtr<nsIContentViewer> viewer;
+    aSHEntry->GetContentViewer(getter_AddRefs(viewer));
+#ifdef DEBUG_PAGE_CACHE
+    nsCAutoString spec;
+    if (uri)
+        uri->GetSpec(spec);
+#endif
+    *aRestored = PR_FALSE;
+    if (!viewer) {
+#ifdef DEBUG_PAGE_CACHE
+        printf("no saved presentation for uri: %s\n", spec.get());
+#endif
+        return NS_OK;
+    }
+    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.
+    if (!aSavePresentation)
+        FireUnloadNotification();
+    mFiredUnloadEvent = PR_FALSE;
+    if (mContentViewer) {
+        mContentViewer->Close();
+        if (aSavePresentation)
+            mContentViewer->SetHistoryEntry(mOSHE);
+        mContentViewer->Destroy();
+    }
+    mContentViewer.swap(viewer);
+    viewer = nsnull; // force a release to complete ownership transfer
+    // Reattach to the window object.
+    nsresult rv = mContentViewer->Open();
+    // Now remove it from the cached presentation.
+    aSHEntry->SetContentViewer(nsnull);
+    // Restore our child docshell hierarchy.
+    DestroyChildren();
+    NS_ENSURE_SUCCESS(rv, rv);
+    PRInt32 i = 0;
+    nsCOMPtr<nsIDocShellTreeItem> childShell;
+    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.  The viewer has set this state
+    // on the history entry in Destroy() just before marking itself non-sticky,
+    // to avoid teardown of the presentation.
+    PRBool sticky;
+    aSHEntry->GetSticky(&sticky);
+    mContentViewer->SetSticky(sticky);
+    // get the previous content viewer size
+    nsRect oldBounds(0, 0, 0, 0);
+    aSHEntry->GetViewerBounds(oldBounds);
+    nsCOMPtr<nsIPresShell> shell;
+    nsDocShell::GetPresShell(getter_AddRefs(shell));
+    nsIViewManager *newVM = shell ? shell->GetViewManager() : nsnull;
+    nsIView *newRootView = nsnull;
+    if (newVM)
+        newVM->GetRootView(newRootView);
+    // Insert the new root view at the correct location in the view tree.
+    if (rootViewParent) {
+        nsIViewManager *parentVM = rootViewParent->GetViewManager();
+        if (parentVM && newRootView) {
+            parentVM->InsertChild(rootViewParent, newRootView,
+                                  rootViewSibling, PR_TRUE);
+            NS_ASSERTION(newRootView->GetNextSibling() == rootViewSibling,
+                         "error in InsertChild");
+        }
+    }
+    // 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);
+    // Restore the refresh URI list.  The refresh timers will be restarted
+    // when EndPageLoad() is called.
+    aSHEntry->GetRefreshURIList(getter_AddRefs(mRefreshURIList));
+    aSHEntry->SetRefreshURIList(nsnull);
+    // Restore the page title.  Re-setting the current title on the document
+    // will update the docshell title and dispatch DOMTitleChanged.
+    nsIDocument *doc = shell->GetDocument();
+    nsCOMPtr<nsIDOMNSDocument> nsDoc = do_QueryInterface(doc);
+    if (doc && nsDoc) {
+        const nsAFlatString &title = doc->GetDocumentTitle();
+        nsDoc->SetTitle(title);
+    }
+    mOSHE = aSHEntry;
+    // mEODForCurrentDocument is true here, so EndPageLoad will not fire
+    // onload (we fire that below, in a special way so that the content window
+    // does not see it).
+    EndPageLoad(nsnull, nsnull, NS_OK);
+    // Meta-refresh timers have been restarted for this shell, but not
+    // for our children.  Walk the child shells and restart their timers.
+    PRInt32 n = mChildList.Count();
+    for (i = 0; i < n; ++i) {
+        nsCOMPtr<nsIDocShell> child = do_QueryInterface(ChildAt(i));
+        if (child)
+            child->ResumeRefreshURIs();
+    }
+    nsCOMPtr<nsISHistory> rootSH;
+    GetRootSessionHistory(getter_AddRefs(rootSH));
+    if (rootSH) {
+        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).
+    if (newRootView) {
+        nsIWidget *widget = newRootView->GetWidget();
+        if (widget && !newBounds.IsEmpty() && newBounds != oldBounds) {
+#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);
+        }
+    }
+    // Reset the security state
+    if (mSecurityUI) {
+        nsCOMPtr<nsISupports> securityState;
+        aSHEntry->GetSecurityState(getter_AddRefs(securityState));
+        if (securityState)
+            mSecurityUI->TransitionToState(securityState);
+    }
+    SetCurrentURI(uri);
+    // Dispatch onload and DOMPageRestore.
+    rv = FireRestoreEvents();
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = mContentViewer->Show();
+    NS_ENSURE_SUCCESS(rv, rv);
+    // Restart plugins
+    if (shell)
+        shell->Thaw();
+    // 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?
+    rv = mParentWidget->Invalidate(PR_FALSE);
+    NS_ENSURE_SUCCESS(rv, rv);
+    *aRestored = PR_TRUE;
+    return NS_OK;
+}
 NS_IMETHODIMP
 nsDocShell::CreateContentViewer(const char *aContentType,
                                 nsIRequest * request,
-       Lines 4723-4729
      nsDocShell::CreateContentViewer(const ch
+  Link Here
     // is changed within the DocShell - otherwise, javascript will get the
     // wrong information :-(
     //
+    PRBool savePresentation = CanSavePresentation(request);
+    if (!savePresentation)
+        FireUnloadNotification();
     // Set mFiredUnloadEvent = PR_FALSE so that the unload handler for the
     // *new* document will fire.
-       Lines 4738-4743
      nsDocShell::CreateContentViewer(const ch
+  Link Here
     PRBool onLocationChangeNeeded = OnLoadingSite(aOpenedChannel, PR_FALSE);
+    if (savePresentation) {
+        // The old content viewer will be saved during the call to Embed().
+        rv = CaptureState();
+        if (NS_SUCCEEDED(rv)) {
+            mSavingOldViewer = PR_TRUE;
+        } else {
+            if (mOSHE) {
+                mOSHE->SyncPresentationState();
+            }
+        }
+    }
     // let's try resetting the load group if we need to...
     nsCOMPtr<nsILoadGroup> currentLoadGroup;
     NS_ENSURE_SUCCESS(aOpenedChannel->
-       Lines 4779-4784
      nsDocShell::CreateContentViewer(const ch
+  Link Here
     NS_ENSURE_SUCCESS(Embed(viewer, "", (nsISupports *) nsnull),
                       NS_ERROR_FAILURE);
+    mSavingOldViewer = PR_FALSE;
     mEODForCurrentDocument = PR_FALSE;
     // if this document is part of a multipart document,
-       Lines 5028-5033
      nsDocShell::SetupNewViewer(nsIContentVie
+  Link Here
         mContentViewer->Close();
         aNewViewer->SetPreviousViewer(mContentViewer);
+        if (mSavingOldViewer) {
+            // Tell the old content viewer to hibernate in session history when
+            // it is destroyed.
+            mContentViewer->SetHistoryEntry(mOSHE);
+        }
         mContentViewer = nsnull;
+    }
-       Lines 5568-5574
      nsDocShell::InternalLoad(nsIURI * aURI,
+  Link Here
                 NS_ENSURE_TRUE(hEntry, NS_ERROR_FAILURE);
                 nsCOMPtr<nsISHEntry> shEntry(do_QueryInterface(hEntry));
                 if (shEntry)
+                    shEntry->SetTitle(mTitle);
+            }
             return NS_OK;
-       Lines 5588-5593
      nsDocShell::InternalLoad(nsIURI * aURI,
+  Link Here
+        }
+    }
+    // Check for saving the presentation here, before calling Stop().
+    // This is necessary so that we can catch any pending requests.
+    // Since the new request has not been created yet, we pass null for the
+    // new request parameter.
+    PRBool savePresentation = CanSavePresentation(nsnull);
     // Don't stop current network activity for javascript: URL's since
     // they might not result in any data, and thus nothing should be
     // stopped in those cases. In the case where they do result in
-       Lines 5623-5628
      nsDocShell::InternalLoad(nsIURI * aURI,
+  Link Here
     // been called.
     mLSHE = aSHEntry;
+    // If we have a saved content viewer in history, restore and show it now.
+    if (aSHEntry) {
+        if (savePresentation) {
+            rv = CaptureState();
+            if (NS_FAILED(rv) && mOSHE)
+                mOSHE->SyncPresentationState();
+        }
+        nsCOMPtr<nsISHEntry> oldEntry = mOSHE;
+        PRBool restored;
+        rv = RestorePresentation(aSHEntry, savePresentation &&
+                                 NS_SUCCEEDED(rv), &restored);
+        if (restored)
+            return rv;
+        // We failed to restore the presentation, so clean up.
+        // Both the old and new history entries could potentially be in
+        // an inconsistent state.
+        if (oldEntry)
+            oldEntry->SyncPresentationState();
+        aSHEntry->SyncPresentationState();
+    }
     nsCOMPtr<nsIRequest> req;
     rv = DoURILoad(aURI, aReferrer,
                    !(aFlags & INTERNAL_LOAD_FLAGS_DONT_SEND_REFERRER),
-       Lines 6520-6531
      nsDocShell::AddToSessionHistory(nsIURI *
+  Link Here
+    }
     //Title is set in nsDocShell::SetTitle()
+    entry->Create(aURI,              // uri
+                  EmptyString(),     // Title
+                  inputStream,       // Post data stream
+                  nsnull,            // LayoutHistory state
+                  cacheKey,          // CacheKey
                   mContentTypeHint); // Content-type
     entry->SetReferrerURI(referrerURI);
     /* If cache got a 'no-store', ask SH not to store
-       Lines 6556-6562
      nsDocShell::AddToSessionHistory(nsIURI *
+  Link Here
         if (LOAD_TYPE_HAS_FLAGS(mLoadType, LOAD_FLAGS_REPLACE_HISTORY)) {
             // Replace current entry in session history.
             PRInt32  index = 0;
+            nsCOMPtr<nsIHistoryEntry> hEntry;
             mSessionHistory->GetIndex(&index);
             nsCOMPtr<nsISHistoryInternal>   shPrivate(do_QueryInterface(mSessionHistory));
             // Replace the current entry with the new entry
-       Lines 6601-6610
      nsDocShell::LoadHistoryEntry(nsISHEntry
+  Link Here
     nsCAutoString contentType;
     NS_ENSURE_TRUE(aEntry, NS_ERROR_FAILURE);
+    nsCOMPtr<nsIHistoryEntry> hEntry(do_QueryInterface(aEntry));
+    NS_ENSURE_TRUE(hEntry, NS_ERROR_FAILURE);
+    NS_ENSURE_SUCCESS(aEntry->GetURI(getter_AddRefs(uri)), NS_ERROR_FAILURE);
     NS_ENSURE_SUCCESS(aEntry->GetReferrerURI(getter_AddRefs(referrerURI)),
                       NS_ERROR_FAILURE);
     NS_ENSURE_SUCCESS(aEntry->GetPostData(getter_AddRefs(postData)),
-       Lines 6699-6707
      nsDocShell::CloneAndReplace(nsISHEntry *
+  Link Here
     nsISHEntry *dest = (nsISHEntry *) nsnull;
     PRUint32 srcID;
     src->GetID(&srcID);
+    nsCOMPtr<nsIHistoryEntry> srcHE(do_QueryInterface(src));
+    if (!src || !replaceEntry)
         return NS_ERROR_FAILURE;
     if (srcID == aCloneID) {





#include "nsIHttpChannel.h"
#include "nsDocShellTransferableHooks.h"
#include "nsIAuthPromptProvider.h"
#include "nsISecureBrowserUI.h"

/**
 * Load flag for error pages. This should be bigger than all flags on

    NS_IMETHOD EnsureEditorData();
    nsresult   EnsureTransferableHookData();
    NS_IMETHOD EnsureFind();
    nsresult   RefreshURIFromQueue();
    NS_IMETHOD DisplayLoadError(nsresult aError, nsIURI *aURI,
                                const PRUnichar *aURL,
                                nsIChannel* aFailedChannel = nsnull);

    PRBool SetCurrentURI(nsIURI *aURI, nsIRequest *aRequest,
                         PRBool aFireOnLocationChange);

    // The following methods deal with saving and restoring content viewers
    // in session history.

    // mContentViewer points to the current content viewer associated with
    // this docshell.  When loading a new document, the content viewer is
    // either destroyed or stored into a session history entry.  To make sure
    // that destruction happens in a controlled fashion, a given content viewer
    // is always owned in exactly one of these ways:
    //   1) The content viewer is active and owned by a docshell's
    //      mContentViewer.
    //   2) The content viewer is still being displayed while we begin loading
    //      a new document.  The content viewer is owned by the _new_
    //      content viewer's mPreviousViewer, and has a pointer to the
    //      nsISHEntry where it will eventually be stored.  The content viewer
    //      has been close()d by the docshell, which detaches the document from
    //      the window object.
    //   3) The content viewer is cached in session history.  The nsISHEntry
    //      has the only owning reference to the content viewer.  The viewer
    //      has released its nsISHEntry pointer to prevent circular ownership.
    //
    // When restoring a content viewer from session history, open() is called
    // to reattach the document to the window object.  The content viewer is
    // then placed into mContentViewer and removed from the history entry.
    // (mContentViewer is put into session history as described above, if
    // applicable).

    // Determines whether we can safely cache the current mContentViewer in
    // session history.  This checks a number of factors such as cache policy,
    // pending requests, and unload handlers.  |aNewRequest| should be the
    // request for the document to be loaded in place of the current document.
    PRBool CanSavePresentation(nsIRequest *aNewRequest);

    // Captures the state of the supporting elements of the presentation
    // (the "window" object, docshell tree, meta-refresh loads, and security
    // state) and stores them on |mOSHE|.
    nsresult CaptureState();

    // Restores the presentation stored in |aSHEntry|.  The old presentation
    // is saved in session history if |aSavePresentation| is true.
    // If a presentation could be restored, |aRestored| is set to true.
    nsresult RestorePresentation(nsISHEntry *aSHEntry,
                                 PRBool aSavePresentation,
                                 PRBool *aRestored);

protected:
    // Override the parent setter from nsDocLoader
    virtual nsresult SetDocLoaderParent(nsDocLoader * aLoader);

    // Indicates that a DocShell in this "docshell tree" is printing
    PRPackedBool               mIsPrintingOrPP;

    // Indicates to SetupNewViewer() that we are in the process of saving the
    // presentation for mContentViewer.
    PRPackedBool               mSavingOldViewer;

    PRUint32                   mAppType;

    // Offset in the parent's child list.

    // Transferable hooks/callbacks
    nsCOMPtr<nsIClipboardDragDropHookList>  mTransferableHookData;

    // Secure browser UI object
    nsCOMPtr<nsISecureBrowserUI> mSecurityUI;

    // WEAK REFERENCES BELOW HERE.
    // Note these are intentionally not addrefd.  Doing so will create a cycle.
    // For that reasons don't use nsCOMPtr.





#include "nsISupports.idl"

interface nsIDOMDocument;
interface nsISHEntry;


%{ C++

[ptr] native nsIDeviceContextPtr(nsIDeviceContext);
[ref] native nsRectRef(nsRect);

[scriptable, uuid(e2c68a4d-b396-11d9-a3d1-00112478d626)]
interface nsIContentViewer : nsISupports
{


   */

  boolean requestWindowClose();

  /**
   * 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, in which case
   *      it will never be saved in session history.
   */
  void setHistoryEntry(in nsISHEntry entry);
};





interface nsIRequest;
interface nsISHEntry;
interface nsILayoutHistoryState;
interface nsISecureBrowserUI;

[scriptable, uuid(b0228925-9242-467b-842f-dc739a6e478f)]
interface nsIDocShell : nsISupports
{
  /**

  attribute nsILayoutHistoryState layoutHistoryState;

  readonly attribute boolean shouldSaveLayoutState;

  /**
   * The SecureBrowserUI object for this docshell.  This is set by XUL
   * <browser> or nsWebBrowser for their root docshell.
   */
  attribute nsISecureBrowserUI securityUI;

  /**
   * Cancel the XPCOM timers for each meta-refresh URI in this docshell,
   * and this docshell's children, recursively. The meta-refresh timers can be
   * restarted using resumeRefreshURIs().  If the timers are already suspended,
   * this has no effect.
   */
  void suspendRefreshURIs();

  /**
   * Restart the XPCOM timers for each meta-refresh URI in this docshell,
   * and this docshell's children, recursively.  If the timers are already
   * running, this has no effect.
   */
  void resumeRefreshURIs();

  /**
   * Fire the onload and DOMPageRestore events as part of restoring a
   * presentation from sessino history.  The onload event is fired starting
   * at the chrome event handler; the DOMPageRestore event is fired starting
   * at the window object.  This first recurses into child docshells so that
   * events fire in a bottom-up order.
   */
  void fireRestoreEvents();
};


(-)dom/public/base/nsPIDOMWindow.h (+13 lines)

Line	Link Here

Lines 124-129 public:	Link Here

124

    return !mIsDocumentLoaded || mRunningTimeout;

124

    return !mIsDocumentLoaded || mRunningTimeout;

125

126

127

  // Check whether a document is currently loading

128

  PRBool IsLoading() const

129

130

    return !mIsDocumentLoaded;

131

132

127

  PRBool IsHandlingResizeEvent() const

133

  PRBool IsHandlingResizeEvent() const

128

134

129

    return mIsHandlingResizeEvent;

135

    return mIsHandlingResizeEvent;

Lines 139-144 public:	Link Here

139

  // Clear all pending timeouts and intervals.

145

  // Clear all pending timeouts and intervals.

140

  virtual void ClearAllTimeouts() = 0;

146

  virtual void ClearAllTimeouts() = 0;

141

147

148

  // Returns an object containing the window's state.  This also suspends

149

  // all running timeouts in the window.

150

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

151

152

  // Restore the window state from aState.

153

  virtual nsresult RestoreWindowState(nsISupports *aState) = 0;

154

142

protected:

155

protected:

143

  nsPIDOMWindow()

156

  nsPIDOMWindow()

144

    : mRunningTimeout(nsnull), mMutationBits(0), mIsDocumentLoaded(PR_FALSE),

157

    : mRunningTimeout(nsnull), mMutationBits(0), mIsDocumentLoaded(PR_FALSE),





 *
 */
#define NS_IDOMLOADLISTENER_IID \
{0x0f7fa587, 0xaac5, 0x11d9, \
{0xba, 0x4e, 0x00, 0x11, 0x24, 0x78, 0xd6, 0x26} }
{0x9b, 0x96, 0x96, 0xbe, 0xdb, 0x9d, 0xe7, 0xbe} }

class nsIDOMLoadListener : public nsIDOMEventListener {


   */
  NS_IMETHOD Error(nsIDOMEvent* aEvent) = 0;

  /**
   * 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;
};

#endif // nsIDOMLoadListener_h__

-      Line
+  Link Here
-       Lines 153-158
+  Link Here
 #include "nsIBindingManager.h"
 #include "nsIXBLService.h"
+#include "nsInt64.h"
 // used for popup blocking, needs to be converted to something
 // belonging to the back-end like nsIContentPolicy
-       Lines 171-176
      static PRInt32              gRunningTime
+  Link Here
 PRInt32 gTimeoutCnt                                    = 0;
 #endif
+#ifdef DEBUG_bryner
+#define DEBUG_PAGE_CACHE
+#endif
 #define DOM_MIN_TIMEOUT_VALUE 10 // 10ms
 // CIDs
-       Lines 4301-4310
      nsGlobalWindow::GetPrivateRoot()
+  Link Here
     nsIDocument* doc = chromeElement->GetDocument();
     if (doc) {
       parent = do_QueryInterface(doc->GetScriptGlobalObject());
+      if (parent) {
+        nsCOMPtr<nsIDOMWindow> tempParent;
+        parent->GetTop(getter_AddRefs(tempParent));
+        return NS_STATIC_CAST(nsGlobalWindow *,
+                              NS_STATIC_CAST(nsIDOMWindow*, tempParent));
+      }
+    }
+  }
-       Lines 5797-5802
      nsGlobalWindow::EnsureSizeUpToDate()
+  Link Here
+  }
+}
+#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,  // The JSContext for the window
+                    JSObject *aObject, // An object to save the properties onto
+                    nsGlobalWindow *aWindow); // The window to operate on
+  // This is the property store object that holds the window properties.
+  JSObject* GetObject() { return mJSObj; }
+  // Get the listener manager, which holds all event handlers for the window.
+  nsIEventListenerManager* GetListenerManager() { return mListenerManager; }
+  // Get the contents of focus memory when the state was saved
+  // (if the focus was inside of this window).
+  nsIDOMElement* GetFocusedElement() { return mFocusedElement; }
+  nsIDOMWindowInternal* GetFocusedWindow() { return mFocusedWindow; }
+  // Manage the list of saved timeouts for the window.
+  nsTimeout* GetSavedTimeouts() { return mSavedTimeouts; }
+  nsTimeout** GetTimeoutInsertionPoint() { return mTimeoutInsertionPoint; }
+  void ClearSavedTimeouts() { mSavedTimeouts = nsnull; }
+private:
+  ~WindowStateHolder();
+  JSRuntime *mRuntime;
+  JSObject *mJSObj;
+  nsCOMPtr<nsIEventListenerManager> mListenerManager;
+  nsCOMPtr<nsIDOMElement> mFocusedElement;
+  nsCOMPtr<nsIDOMWindowInternal> mFocusedWindow;
+  nsTimeout *mSavedTimeouts;
+  nsTimeout **mTimeoutInsertionPoint;
+};
+WindowStateHolder::WindowStateHolder(JSContext *cx, JSObject *aObject,
+                                     nsGlobalWindow *aWindow)
+  : mRuntime(::JS_GetRuntime(cx)), mJSObj(aObject)
+{
+  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));
+  nsCOMPtr<nsPIDOMWindow> focusedWindow = do_QueryInterface(focusWinInternal);
+  while (focusedWindow) {
+    if (focusedWindow == aWindow) {
+      fc->GetFocusedWindow(getter_AddRefs(mFocusedWindow));
+      fc->GetFocusedElement(getter_AddRefs(mFocusedElement));
+      break;
+    }
+    focusedWindow =
+      NS_STATIC_CAST(nsGlobalWindow*,
+                     NS_STATIC_CAST(nsPIDOMWindow*,
+                                    focusedWindow))->GetPrivateParent();
+  }
+  aWindow->SuspendTimeouts();
+  // Clear the timeout list for aWindow (but we don't need to for children)
+  mSavedTimeouts = aWindow->mTimeouts;
+  mTimeoutInsertionPoint = aWindow->mTimeoutInsertionPoint;
+  aWindow->mTimeouts = nsnull;
+  aWindow->mTimeoutInsertionPoint = &aWindow->mTimeouts;
+  ::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 nsresult
+CopyJSPropertyArray(JSContext *cx, JSObject *aSource, JSObject *aDest,
+                    JSIdArray *props)
+{
+  jsint length = props->length;
+  for (jsint 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-named window property");
+      return NS_ERROR_FAILURE;
+    }
+    JSString *propname = JSVAL_TO_STRING(propname_value);
+    jschar *propname_str = ::JS_GetStringChars(propname);
+    NS_ENSURE_TRUE(propname_str, NS_ERROR_FAILURE);
+    // We exclude the "location" property because restoring it this way is
+    // problematic.  It will "just work" without us explicitly saving or
+    // restoring the value.
+    if (!nsCRT::strcmp(NS_STATIC_CAST(PRUnichar*, propname_str),
+                       NS_LITERAL_STRING("location").get())) {
+      continue;
+    }
+    size_t propname_len = ::JS_GetStringLength(propname);
+    JSPropertyOp getter, setter;
+    uintN attrs;
+    JSBool found;
+    if (!::JS_GetUCPropertyAttrsGetterAndSetter(cx, aSource, propname_str,
+                                                propname_len, &attrs, &found,
+                                                &getter, &setter))
+      return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(found, NS_ERROR_UNEXPECTED);
+    jsval propvalue;
+    if (!::JS_LookupUCProperty(cx, aSource, propname_str,
+                               propname_len, &propvalue))
+      return NS_ERROR_FAILURE;
+    PRBool res = ::JS_DefineUCProperty(cx, aDest, propname_str, propname_len,
+                                       propvalue, getter, setter, attrs);
+#ifdef DEBUG_PAGE_CACHE
+    if (res)
+      printf("Copied window property: %s\n",
+             NS_ConvertUTF16toUTF8(NS_STATIC_CAST(PRUnichar*,
+                                                  propname_str)).get());
+#endif
+    if (!res) {
+#ifdef DEBUG
+      printf("failed to copy property: %s\n",
+             NS_ConvertUTF16toUTF8(NS_STATIC_CAST(PRUnichar*,
+                                                  propname_str)).get());
+#endif
+      return NS_ERROR_FAILURE;
+    }
+  }
+  return NS_OK;
+}
+static nsresult
+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 NS_OK;
+  }
+#ifdef DEBUG_PAGE_CACHE
+  printf("props length = %d\n", props->length);
+#endif
+  nsresult rv = CopyJSPropertyArray(cx, aSource, aDest, props);
+  ::JS_DestroyIdArray(cx, props);
+  return rv;
+}
+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);
+  // The window state object will root the JSObject.
+  *aState = new WindowStateHolder(cx, stateObj, this);
+  NS_ENSURE_TRUE(*aState, NS_ERROR_OUT_OF_MEMORY);
+#ifdef DEBUG_PAGE_CACHE
+  printf("saving window state, stateObj = %p\n", stateObj);
+#endif
+  nsresult rv = CopyJSProperties(cx, mJSObject, stateObj);
+  NS_ENSURE_SUCCESS(rv, rv);
+  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 would remove the
+  // XPConnect properties.
+  nsCOMPtr<WindowStateHolder> holder = do_QueryInterface(aState);
+  NS_ENSURE_TRUE(holder, NS_ERROR_FAILURE);
+#ifdef DEBUG_PAGE_CACHE
+  printf("restoring window state, stateObj = %p\n", holder->GetObject());
+#endif
+  nsresult rv = CopyJSProperties(cx, holder->GetObject(), mJSObject);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mListenerManager = holder->GetListenerManager();
+  nsIDOMElement *focusedElement = holder->GetFocusedElement();
+  nsIDOMWindowInternal *focusedWindow = holder->GetFocusedWindow();
+  // If the toplevel window isn't focused, just update the focus controller.
+  nsIFocusController *fc = nsGlobalWindow::GetRootFocusController();
+  NS_ENSURE_TRUE(fc, NS_ERROR_UNEXPECTED);
+  PRBool active;
+  fc->GetActive(&active);
+  if (active) {
+    PRBool didFocusContent = PR_FALSE;
+    nsCOMPtr<nsIContent> focusedContent = do_QueryInterface(focusedElement);
+    if (focusedContent) {
+      // We don't bother checking whether the element or frame is focusable.
+      // If it was focusable when we stored the presentation, it must be
+      // focusable now.
+      PRBool didFocusContent = PR_FALSE;
+      nsIDocument *doc = focusedContent->GetCurrentDoc();
+      if (doc) {
+        nsIPresShell *shell = doc->GetShellAt(0);
+        if (shell) {
+          nsPresContext *pc = shell->GetPresContext();
+          if (pc) {
+            pc->EventStateManager()->SetContentState(focusedContent,
+                                                     NS_EVENT_STATE_FOCUS);
+            didFocusContent = PR_TRUE;
+          }
+        }
+      }
+    }
+    if (!didFocusContent && focusedWindow)
+      focusedWindow->Focus();
+  } else if (focusedWindow) {
+    // Just update the saved focus memory.
+    fc->SetFocusedWindow(focusedWindow);
+    fc->SetFocusedElement(focusedElement);
+  }
+  mTimeouts = holder->GetSavedTimeouts();
+  mTimeoutInsertionPoint = holder->GetTimeoutInsertionPoint();
+  holder->ClearSavedTimeouts();
+  // If our state is being restored from history, we won't be getting an onload
+  // event.  Make sure we're marked as being completely loaded.
+  mIsDocumentLoaded = PR_TRUE;
+  return ResumeTimeouts();
+}
+void
+nsGlobalWindow::SuspendTimeouts()
+{
+  nsInt64 now = PR_IntervalNow();
+  for (nsTimeout *t = mTimeouts; t; t = t->mNext) {
+    // Change mWhen to be the time remaining for this timer.
+    t->mWhen = PR_MAX(nsInt64(0), nsInt64(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);
+    for (PRInt32 i = 0; i < childCount; ++i) {
+      nsCOMPtr<nsIDocShellTreeItem> childShell;
+      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, using the stored time remaining.
+  nsInt64 now = PR_IntervalNow();
+  nsresult rv;
+  for (nsTimeout *t = mTimeouts; t; t = t->mNext) {
+    PRInt32 interval = PR_MAX(t->mWhen, DOM_MIN_TIMEOUT_VALUE);
+    t->mWhen = now + nsInt64(t->mWhen);
+    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);
+    for (PRInt32 i = 0; i < childCount; ++i) {
+      nsCOMPtr<nsIDocShellTreeItem> childShell;
+      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;
+}
 // QueryInterface implementation for nsGlobalChromeWindow
 NS_INTERFACE_MAP_BEGIN(nsGlobalChromeWindow)
   NS_INTERFACE_MAP_ENTRY(nsIDOMChromeWindow)

(-)dom/src/base/nsGlobalWindow.h (+8 lines)

Line	Link Here

Lines 105-110 class nsNavigator;	Link Here

105

class nsScreen;

105

class nsScreen;

106

class nsHistory;

106

class nsHistory;

107

class nsIDocShellLoadInfo;

107

class nsIDocShellLoadInfo;

108

class WindowStateHolder;

108

109

//*****************************************************************************

110

//*****************************************************************************

110

// nsGlobalWindow: Global Object for Scripting

111

// nsGlobalWindow: Global Object for Scripting

Lines 204-209 public:	Link Here

204

  virtual NS_HIDDEN_(OpenAllowValue) GetOpenAllow(const nsAString &aName);

205

  virtual NS_HIDDEN_(OpenAllowValue) GetOpenAllow(const nsAString &aName);

205

206

  virtual NS_HIDDEN_(void) ClearAllTimeouts();

207

  virtual NS_HIDDEN_(void) ClearAllTimeouts();

208

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

209

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

207

210

208

  // nsIDOMViewCSS

211

  // nsIDOMViewCSS

209

  NS_DECL_NSIDOMVIEWCSS

212

  NS_DECL_NSIDOMVIEWCSS

Lines 220-225 public:	Link Here

220

  static void ShutDown();

223

  static void ShutDown();

221

  static PRBool IsCallerChrome();

224

  static PRBool IsCallerChrome();

222

225

226

  friend class WindowStateHolder;

227

223

protected:

228

protected:

224

  // Object Management

229

  // Object Management

225

  virtual ~nsGlobalWindow();

230

  virtual ~nsGlobalWindow();

Lines 304-309 protected:	Link Here

304

309

305

  already_AddRefed<nsIWidget> GetMainWidget();

310

  already_AddRefed<nsIWidget> GetMainWidget();

306

311

312

  void SuspendTimeouts();

313

  nsresult ResumeTimeouts();

314

307

  // When adding new member variables, be careful not to create cycles

315

  // When adding new member variables, be careful not to create cycles

308

  // through JavaScript.  If there is any chance that a member variable

316

  // through JavaScript.  If there is any chance that a member variable

309

  // could own objects that are implemented in JavaScript, then those

317

  // could own objects that are implemented in JavaScript, then those





    nsCOMPtr<nsIScriptGlobalObject> sgo;
    doc->GetScriptGlobalObject(getter_AddRefs(sgo));
    nsCOMPtr<nsIDOMWindow> window = do_QueryInterface(sgo);
    if (window) {
      PRInt32 scrollX, scrollY;
      window->GetScrollX(&scrollX);
      window->GetScrollY(&scrollY);
      xDelta += scrollX; // Normal direction.
      yDelta -= scrollY; // Remember, y is flipped.
    
#define XMENUOFFSET 20
#define MENUHEIGHT 20
    
      xDelta += XMENUOFFSET;
      yDelta -= MENUHEIGHT*(selIndex+1);
    
      NSEvent* event = [NSApp currentEvent];
      NSPoint point = [event locationInWindow];
      point.x -= xDelta;
      point.y -= yDelta;

      NSEvent* mouseEvent = [NSEvent mouseEventWithType: NSLeftMouseDown location: point
                                          modifierFlags: 0 timestamp: [event timestamp]
                                           windowNumber: [event windowNumber] context: [event context]
                                            eventNumber: [event eventNumber] clickCount: [event clickCount] 																						 pressure: [event pressure]];
      [NSMenu popUpContextMenu: menu withEvent: mouseEvent forView: [[event window] contentView]];
    }
  }
  return NS_OK;
}

(-)embedding/browser/webBrowser/nsWebBrowser.cpp (-2 / +3 lines)

Line	Link Here

Lines 1215-1222 NS_IMETHODIMP nsWebBrowser::Create()	Link Here

1215

   rv = GetContentDOMWindow(getter_AddRefs(domWindow));

1215

   rv = GetContentDOMWindow(getter_AddRefs(domWindow));

1216

   if (NS_SUCCEEDED(rv))

1216

   if (NS_SUCCEEDED(rv))

1217

1218

       mSecurityUI = do_CreateInstance(NS_SECURE_BROWSER_UI_CONTRACTID, &rv);

1218

       nsCOMPtr<nsISecureBrowserUI> securityUI =

1219

       if (NS_SUCCEEDED(rv))mSecurityUI->Init(domWindow);

1219

           do_CreateInstance(NS_SECURE_BROWSER_UI_CONTRACTID, &rv);

1220

       if (NS_SUCCEEDED(rv)) securityUI->Init(domWindow);

1220

1221

1222

   mDocShellTreeOwner->AddToWatcher(); // evil twin of Remove in SetDocShell(0)

1223

   mDocShellTreeOwner->AddToWatcher(); // evil twin of Remove in SetDocShell(0)

(-)embedding/browser/webBrowser/nsWebBrowser.h (-1 lines)

Line	Link Here

Lines 168-174 protected:	Link Here

168

   nativeWindow               mParentNativeWindow;

168

   nativeWindow               mParentNativeWindow;

169

   nsIWebProgressListener    *mProgressListener;

169

   nsIWebProgressListener    *mProgressListener;

170

   nsCOMPtr<nsIWebProgress>      mWebProgress;

170

   nsCOMPtr<nsIWebProgress>      mWebProgress;

171

   nsCOMPtr<nsISecureBrowserUI> mSecurityUI;

172

171

173

   nsCOMPtr<nsIPrintSettings> mPrintSettings;

172

   nsCOMPtr<nsIPrintSettings> mPrintSettings;

174

173

(-)embedding/tests/mfcembed/StdAfx.h (+1 lines)

Line	Link Here

Lines 115-120	Link Here

115

#include "nsIEmbeddingSiteWindow2.h"

115

#include "nsIEmbeddingSiteWindow2.h"

116

#include "nsIWebBrowserFind.h"

116

#include "nsIWebBrowserFind.h"

117

#include "nsIWebBrowserFocus.h"

117

#include "nsIWebBrowserFocus.h"

118

#include "nsIURI.h"

118

119

// Printer Includes

120

// Printer Includes

120

#include "nsIWebBrowserPrint.h"

121

#include "nsIWebBrowserPrint.h"

(-)extensions/xmlextras/base/src/nsDOMParser.cpp (+6 lines)

Line	Link Here

Lines 333-338 nsDOMParser::Error(nsIDOMEvent* aEvent)	Link Here

333

  return NS_OK;

333

  return NS_OK;

334

335

336

NS_IMETHODIMP

337

nsDOMParser::PageRestore(nsIDOMEvent* aEvent)

338

339

  return NS_OK;

340

341

336

nsDOMParser::nsDOMParser()

342

nsDOMParser::nsDOMParser()

337

  : mLoopingForSyncLoad(PR_FALSE)

343

  : mLoopingForSyncLoad(PR_FALSE)

338

344

(-)extensions/xmlextras/base/src/nsDOMParser.h (+1 lines)

Line	Link Here

Lines 67-72 public:	Link Here

  NS_IMETHOD Unload(nsIDOMEvent* aEvent);

  NS_IMETHOD Unload(nsIDOMEvent* aEvent);

  NS_IMETHOD Abort(nsIDOMEvent* aEvent);

  NS_IMETHOD Abort(nsIDOMEvent* aEvent);

  NS_IMETHOD Error(nsIDOMEvent* aEvent);

  NS_IMETHOD Error(nsIDOMEvent* aEvent);

  NS_IMETHOD PageRestore(nsIDOMEvent* aEvent);

private:

private:

  nsCOMPtr<nsIURI> mBaseURI;

  nsCOMPtr<nsIURI> mBaseURI;

(-)extensions/xmlextras/base/src/nsLoadListenerProxy.cpp (+12 lines)

Line	Link Here

Lines 121-123 nsLoadListenerProxy::Error(nsIDOMEvent*	Link Here

121

122

  return NS_OK;

122

  return NS_OK;

123

124

125

NS_IMETHODIMP

126

nsLoadListenerProxy::PageRestore(nsIDOMEvent* aEvent)

127

128

  nsCOMPtr<nsIDOMLoadListener> listener(do_QueryReferent(mParent));

129

130

  if (listener) {

131

    return listener->PageRestore(aEvent);

132

133

134

  return NS_OK;

135

(-)extensions/xmlextras/base/src/nsLoadListenerProxy.h (+1 lines)

Line	Link Here

Lines 69-74 public:	Link Here

  NS_IMETHOD Unload(nsIDOMEvent* aEvent);

  NS_IMETHOD Unload(nsIDOMEvent* aEvent);

  NS_IMETHOD Abort(nsIDOMEvent* aEvent);

  NS_IMETHOD Abort(nsIDOMEvent* aEvent);

  NS_IMETHOD Error(nsIDOMEvent* aEvent);

  NS_IMETHOD Error(nsIDOMEvent* aEvent);

  NS_IMETHOD PageRestore(nsIDOMEvent* aEvent);

protected:

protected:

  nsWeakPtr  mParent;

  nsWeakPtr  mParent;

(-)extensions/xmlextras/base/src/nsXMLHttpRequest.cpp (+6 lines)

Line	Link Here

Lines 1743-1748 nsXMLHttpRequest::Error(nsIDOMEvent* aEv	Link Here

1743

  return NS_OK;

1743

  return NS_OK;

1744

1745

1746

NS_IMETHODIMP

1747

nsXMLHttpRequest::PageRestore(nsIDOMEvent* aEvent)

1748

1749

  return NS_OK;

1750

1751

1746

nsresult

1752

nsresult

1747

nsXMLHttpRequest::ChangeState(PRUint32 aState, PRBool aBroadcast,

1753

nsXMLHttpRequest::ChangeState(PRUint32 aState, PRBool aBroadcast,

1748

                              PRBool aClearEventListeners)

1754

                              PRBool aClearEventListeners)

(-)extensions/xmlextras/base/src/nsXMLHttpRequest.h (+1 lines)

Line	Link Here

Lines 97-102 public:	Link Here

  NS_IMETHOD Unload(nsIDOMEvent* aEvent);

  NS_IMETHOD Unload(nsIDOMEvent* aEvent);

  NS_IMETHOD Abort(nsIDOMEvent* aEvent);

  NS_IMETHOD Abort(nsIDOMEvent* aEvent);

  NS_IMETHOD Error(nsIDOMEvent* aEvent);

  NS_IMETHOD Error(nsIDOMEvent* aEvent);

100

  NS_IMETHOD PageRestore(nsIDOMEvent* aEvent);

100

101

  // nsIStreamListener

102

  // nsIStreamListener

102

  NS_DECL_NSISTREAMLISTENER

103

  NS_DECL_NSISTREAMLISTENER

(-)extensions/xmlextras/tests/TestXMLExtras.cpp (+1 lines)

Line	Link Here

Lines 78-83 public:	Link Here

  virtual nsresult Unload(nsIDOMEvent* aEvent) {printf("Unload\n"); return NS_OK;}

  virtual nsresult Unload(nsIDOMEvent* aEvent) {printf("Unload\n"); return NS_OK;}

  virtual nsresult Abort(nsIDOMEvent* aEvent)  {printf("Abort\n"); return NS_OK;}

  virtual nsresult Abort(nsIDOMEvent* aEvent)  {printf("Abort\n"); return NS_OK;}

  virtual nsresult Error(nsIDOMEvent* aEvent)  {printf("Error\n"); return NS_OK;}

  virtual nsresult Error(nsIDOMEvent* aEvent)  {printf("Error\n"); return NS_OK;}

  NS_IMETHOD PageRestore(nsIDOMEvent* aEvent) {printf("PageRestore\n"); return NS_OK;}

};

};

NS_IMPL_ADDREF(nsMyListener)

NS_IMPL_ADDREF(nsMyListener)

(-)layout/base/Makefile.in (+1 lines)

Line

Link Here

Lines 73-78 REQUIRES = xpcom \

Link Here

		  util \

		  util \

		  windowwatcher \

		  windowwatcher \

		  accessibility \

		  accessibility \

		  shistory \

		  $(NULL)

		  $(NULL)

XPIDLSRCS	= \

XPIDLSRCS	= \





#include "nsISupportsPrimitives.h"

// PrintOptions is now implemented by PrintSettingsService
static const char sPrintSettingsServiceContractID[] = "@mozilla.org/gfx/printsettings-service;1";
static const char sPrintOptionsContractID[]         = "@mozilla.org/gfx/printsettings-service;1";

// Printing Events

#include "nsISelectionController.h"

#include "nsBidiUtils.h"
#include "nsISHEntry.h"
#include "nsISHistory.h"
#include "nsISHistoryInternal.h"
#include "nsIWebNavigation.h"

//paint forcing
#include "prenv.h"

  virtual ~DocumentViewerImpl();

private:
  void ForceRefresh(void);
  nsresult MakeWindow(nsIWidget* aParentWidget,
                      const nsRect& aBounds);
  nsresult InitInternal(nsIWidget* aParentWidget,

  nsCOMPtr<nsIDOMFocusListener> mFocusListener;

  nsCOMPtr<nsIContentViewer> mPreviousViewer;
  nsCOMPtr<nsISHEntry> mSHEntry;
  PRPackedBool  mEnableRendering;
  PRPackedBool  mStopped;
  PRPackedBool  mLoaded;
  PRPackedBool  mDeferredWindowClose;
  PRInt16 mNumURLStarts;
  PRInt16 mDestroyRefCount;     // a second "refcount" for the document viewer's "destroy"

  nsIWidget* mParentWidget;          // purposely won't be ref counted

  PRInt16 mNumURLStarts;
  PRInt16 mDestroyRefCount;    // a second "refcount" for the document viewer's "destroy"

  unsigned      mEnableRendering : 1;
  unsigned      mStopped : 1;
  unsigned      mLoaded : 1;
  unsigned      mDeferredWindowClose : 1;
  // document management data
  //   these items are specific to markup documents (html and xml)
  //   may consider splitting these out into a subclass
  unsigned      mIsSticky : 1;
  unsigned      mInPermitUnload : 1;

#ifdef NS_PRINTING
  unsigned      mClosingWhilePrinting : 1;

  nsCOMPtr<nsIDOMWindowInternal> mDialogParentWin;
#if NS_PRINT_PREVIEW
  // These data members support delayed printing when the document is loading
  unsigned                         mPrintIsPending : 1;
  unsigned                         mPrintDocIsFullyLoaded : 1;
  nsCOMPtr<nsIPrintSettings>       mCachedPrintSettings;
  nsCOMPtr<nsIWebProgressListener> mCachedPrintWebProgressListner;
  PRPackedBool                     mPrintIsPending;
  PRPackedBool                     mPrintDocIsFullyLoaded;
#endif // NS_PRINT_PREVIEW

  nsPrintEngine*        mPrintEngine;
  nsCOMPtr<nsIDOMWindowInternal> mDialogParentWin;

#ifdef NS_DEBUG
  FILE* mDebugFile;
#endif // NS_DEBUG

  nsCString mForceCharacterSet;
  nsCString mPrevDocCharacterSet;
  
  // document management data
  //   these items are specific to markup documents (html and xml)
  //   may consider splitting these out into a subclass
  PRPackedBool mIsSticky;

};


// Note: operator new zeros our memory, so no need to init things to null.
DocumentViewerImpl::DocumentViewerImpl(nsPresContext* aPresContext)
  : mPresContext(aPresContext),
    mIsSticky(PR_TRUE),
    mHintCharsetSource(kCharsetUninitialized)
{
  PrepareToStartLoad();
}


DocumentViewerImpl::~DocumentViewerImpl()
{
  NS_ASSERTION(!mDocument, "User did not call nsIContentViewer::Close");
  if (mDocument) {
    Close();
    mDocument->Destroy();
  }

  NS_ASSERTION(!mPresShell && !mPresContext,

      makeCX = PR_TRUE;
#endif
    }
  }

    if (mPresContext) {
      // Create the ViewManager and Root View...

      // We must do this before we tell the script global object about
      // this new document since doing that will cause us to re-enter
      // into nsSubDocumentFrame code through reflows caused by
      // FlushPendingNotifications() calls down the road...

      rv = MakeWindow(aParentWidget, aBounds);
      NS_ENSURE_SUCCESS(rv, rv);
      Hide();
    }
  }

  nsCOMPtr<nsIInterfaceRequestor> requestor(do_QueryInterface(mContainer));

}

NS_IMETHODIMP
DocumentViewerImpl::Open()
{
  NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_INITIALIZED);

  nsRect bounds;
  mWindow->GetBounds(bounds);

  nsresult rv = InitInternal(mParentWidget, mDeviceContext, bounds,
                             PR_FALSE, PR_FALSE);
  NS_ENSURE_SUCCESS(rv, rv);

  if (mDocument)
    mDocument->SetContainer(mContainer);

  SyncParentSubDocMap();

  // XXX re-enable image animations once that works correctly

  return NS_OK;
}

NS_IMETHODIMP
DocumentViewerImpl::Close()
{
  // All callers are supposed to call close to break circular

  // for an object that can be switched in and out so that we don't need
  // to disable scripts during paint suppression.

  if (!mDocument)
    return NS_OK;

#if defined(NS_PRINTING) && defined(NS_PRINT_PREVIEW)
  // Turn scripting back on
  // after PrintPreview had turned it off
  if (GetIsPrintPreview() && mPrintEngine) {
    mPrintEngine->TurnScriptingOn(PR_TRUE);
  }
#endif

  // Break global object circular reference on the document created
  // in the DocViewer Init
  nsIScriptGlobalObject* globalObject = mDocument->GetScriptGlobalObject();

  if (globalObject) {
    globalObject->SetNewDocument(nsnull, PR_TRUE, PR_TRUE);
  }

#ifdef NS_PRINTING
  // A Close was called while we were printing
  // so don't clear the ScriptGlobalObject
  // or clear the mDocument below
  // Also, do an extra addref to keep the viewer from going away.
  if (mPrintEngine && !mClosingWhilePrinting) {
    mClosingWhilePrinting = PR_TRUE;
    NS_ADDREF_THIS();
  } else
#endif
    {
      // out of band cleanup of webshell
      mDocument->SetScriptGlobalObject(nsnull);
    }
#else
    mDocument->SetScriptGlobalObject(nsnull);
#endif

  if (mFocusListener) {
    // get the DOM event receiver
    nsCOMPtr<nsIDOMEventReceiver> erP(do_QueryInterface(mDocument));
    NS_WARN_IF_FALSE(erP, "No event receiver in document!");

    if (erP) {
      erP->RemoveEventListenerByIID(mFocusListener,
                                    NS_GET_IID(nsIDOMFocusListener));
      }
    }
  }

#ifdef NS_PRINTING
  // Don't clear the document if we are printing.
  if (!mClosingWhilePrinting) {
    mDocument = nsnull;
  }
#else
    mDocument = nsnull;
#endif

  return NS_OK;
}

NS_IMETHODIMP
DocumentViewerImpl::Destroy()
{
  NS_ASSERTION(mDocument, "No document in Destroy()!");

#ifdef NS_PRINTING
  // Here is where we check to see if the docment was still being prepared 
  // for printing when it was asked to be destroy from someone externally

  }
#endif

  // Don't let the document get unloaded while we are printing.
  // this could happen if we hit the back button during printing.
  // We also keep the viewer from being cached in session history, since
  // we require all documents there to be sanitized.
  if (mDestroyRefCount != 0) {
    --mDestroyRefCount;
    return NS_OK;
  }

  // If we were told to put ourselves into session history instead of destroy
  // the presentation, do that now.
  PRBool updateHistory = (mSHEntry != nsnull);

  if (mSHEntry) {
    if (mPresShell)
      mPresShell->Freeze();

    // Make sure the presentation isn't torn down by Hide().
    mSHEntry->SetSticky(mIsSticky);
    mIsSticky = PR_TRUE;

    mSHEntry->SetContentViewer(this);

    // Remove our root view from the view hierarchy.
    if (mPresShell) {
      nsIViewManager *vm = mPresShell->GetViewManager();
      if (vm) {
        nsIView *rootView = nsnull;
        vm->GetRootView(rootView);

        if (rootView) {
          nsIView *rootViewParent = rootView->GetParent();
          if (rootViewParent) {
            nsIViewManager *parentVM = rootViewParent->GetViewManager();
            if (parentVM) {
              parentVM->RemoveChild(rootView);
            }
          }
        }
      }
    }

    Hide();

    // This is after Hide() so that the user doesn't see the inputs clear.
    if (mDocument) {
      nsresult rv = mDocument->Sanitize();
      if (NS_FAILED(rv)) {
        // If we failed to sanitize, remove the document immediately.
        mSHEntry->SetContentViewer(nsnull);
        mSHEntry->SyncPresentationState();
      }
    }


    mSHEntry = nsnull;

    // If we put ourselves into session history, make sure there aren't
    // too many content viewers around.  Note: if max_viewers is set to 0,
    // this can reenter Destroy() and dispose of this content viewer!

    nsCOMPtr<nsIWebNavigation> webNav = do_QueryInterface(mContainer);
    if (webNav) {
      nsCOMPtr<nsISHistory> history;
      webNav->GetSessionHistory(getter_AddRefs(history));
      nsCOMPtr<nsISHistoryInternal> historyInt = do_QueryInterface(history);
      if (historyInt) {
        historyInt->EvictContentViewers();
      }
    }

    // Break the link from the document/presentation to the docshell, so that
    // link traversals cannot affect the currently-loaded document.
    // When the presentation is restored, Open() and InitInternal() will reset
    // these pointers to their original values.

    if (mDocument)
      mDocument->SetContainer(nsnull);
    if (mPresContext)
      mPresContext->SetLinkHandler(nsnull);

    return NS_OK;
  }

  mDocument->Destroy();
  mDocument = nsnull;

  // All callers are supposed to call destroy to break circular
  // references.  If we do this stuff in the destructor, the
  // destructor might never be called (especially if we're being

    mDocument->StopDocumentLoad();
  }

  if (mEnableRendering && (mLoaded || mStopped) && mPresContext && !mSHEntry)
    mPresContext->SetImageAnimationMode(imgIContainer::kDontAnimMode);

  mStopped = PR_TRUE;

    return NS_OK;
  }

  NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
  NS_PRECONDITION(mWindow, "null window");
  if (mWindow) {
    mWindow->Show(PR_FALSE);

}

NS_IMETHODIMP
DocumentViewerImpl::SetHistoryEntry(nsISHEntry *aEntry)
{
  mSHEntry = aEntry;
  return NS_OK;
}

NS_IMETHODIMP
DocumentViewerImpl::GetEnableRendering(PRBool* aResult)
{
  NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);

  return NS_OK;
}


void
DocumentViewerImpl::ForceRefresh()
{
  mWindow->Invalidate(PR_TRUE);
}

NS_DEFINE_CID(kCSSLoaderCID, NS_CSS_LOADER_CID);

PR_STATIC_CALLBACK(PRBool)

(-)layout/base/nsIDocumentViewer.h (-1 / +1 lines)

Line

Link Here

Lines 45-51 class nsIPresShell;

Link Here

class nsIStyleSheet;

class nsIStyleSheet;

#define NS_IDOCUMENT_VIEWER_IID \

#define NS_IDOCUMENT_VIEWER_IID \

 { 0xa6cf9057, 0x15b3, 0x11d2,{0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32}}

 { 0x09ad1126, 0xb397, 0x11d9,{0xa5, 0x2c, 0x00, 0x11, 0x24, 0x78, 0xd6, 0x26}}

/**

/**

 * A document viewer is a kind of content viewer that uses NGLayout

 * A document viewer is a kind of content viewer that uses NGLayout





class nsCSSFrameConstructor;

#define NS_IPRESSHELL_IID     \
{ 0x3861ee48, 0xb397, 0x11d9, \
  {0x86, 0x9e, 0x00, 0x11, 0x24, 0x78, 0xd6, 0x26} }

// Constants uses for ScrollFrameIntoView() function
#define NS_PRESSHELL_SCROLL_TOP      0


  PRBool IsAccessibilityActive() { return mIsAccessibilityActive; }

  /**
   * Stop all active elements (plugins and the caret) in this presentation and
   * in the presentations of subdocuments.
   * XXX this should include image animations
   */
  virtual void Freeze() = 0;

  /**
   * Restarts active elements (plugins) in this presentation and in the
   * presentations of subdocuments.
   */
  virtual void Thaw() = 0;

protected:
  // IMPORTANT: The ownership implicit in the following member variables
  // has been explicitly checked.  If you add any members to this class,

(-)layout/base/nsLayoutAtomList.h (+1 lines)

Line

Link Here

Lines 164-169 LAYOUT_ATOM(oncontextmenu, "oncontextmen

Link Here

164

LAYOUT_ATOM(onDOMActivate, "onDOMActivate")

164

LAYOUT_ATOM(onDOMActivate, "onDOMActivate")

165

LAYOUT_ATOM(onDOMFocusIn, "onDOMFocusIn")

165

LAYOUT_ATOM(onDOMFocusIn, "onDOMFocusIn")

166

LAYOUT_ATOM(onDOMFocusOut, "onDOMFocusOut")

166

LAYOUT_ATOM(onDOMFocusOut, "onDOMFocusOut")

167

LAYOUT_ATOM(onDOMPageRestore, "onDOMPageRestore")

167

LAYOUT_ATOM(ondblclick, "ondblclick")

168

LAYOUT_ATOM(ondblclick, "ondblclick")

168

LAYOUT_ATOM(ondragdrop, "ondragdrop")

169

LAYOUT_ATOM(ondragdrop, "ondragdrop")

169

LAYOUT_ATOM(ondragenter, "ondragenter")

170

LAYOUT_ATOM(ondragenter, "ondragenter")

-      Line
+  Link Here
-       Lines 151-156
+  Link Here
 #include "nsIDOMWindowInternal.h"
 #include "nsPIDOMWindow.h"
 #include "nsIFocusController.h"
+#include "nsIPluginInstance.h"
+#include "nsIObjectFrame.h"
+#include "nsIPluginHost.h"
 // Drag & Drop, Clipboard
 #include "nsWidgetsCID.h"
-       Lines 1204-1209
      public:
+  Link Here
   NS_IMETHOD IsReflowLocked(PRBool* aIsLocked);
   virtual nsresult ReconstructFrames(void);
+  virtual void Freeze();
+  virtual void Thaw();
 #ifdef IBMBIDI
   NS_IMETHOD SetCaretBidiLevel(PRUint8 aLevel);
-       Lines 1513-1518
      private:
+  Link Here
   void FireResizeEvent();
   static void sResizeEventCallback(nsITimer* aTimer, void* aPresShell) ;
   nsCOMPtr<nsITimer> mResizeEventTimer;
+  typedef void (*nsPluginEnumCallback)(PresShell*, nsIContent*);
+  void EnumeratePlugins(nsIDOMDocument *aDocument,
+                        const nsString &aPluginTag,
+                        nsPluginEnumCallback aCallback);
 };
 #ifdef PR_LOGGING
-       Lines 6482-6487
      PresShell::RemoveOverrideStyleSheet(nsIS
+  Link Here
   return mStyleSet->RemoveStyleSheet(nsStyleSet::eOverrideSheet, aSheet);
+}
+static void
+StopPluginInstance(PresShell *aShell, nsIContent *aContent)
+{
+  nsIFrame *frame = aShell->FrameManager()->GetPrimaryFrameFor(aContent);
+  nsIObjectFrame *objectFrame = nsnull;
+  if (frame)
+    CallQueryInterface(frame, &objectFrame);
+  if (!objectFrame)
+    return;
+  nsCOMPtr<nsIPluginInstance> instance;
+  objectFrame->GetPluginInstance(*getter_AddRefs(instance));
+  if (!instance)
+    return;
+  // Check whether the plugin wants SetWindow to be called before or after
+  // Stop/Destroy.  This is similar to nsObjectFrame::Destroy(), but we
+  // don't want to destroy the frame just yet.
+  PRBool callSetWindowLast = PR_FALSE;
+  instance->GetValue(nsPluginInstanceVariable_CallSetWindowAfterDestroyBool,
+                     (void *) &callSetWindowLast);
+  if (callSetWindowLast) {
+    instance->Stop();
+    instance->Destroy();
+    instance->SetWindow(nsnull);
+  } else {
+    instance->SetWindow(nsnull);
+    instance->Stop();
+    instance->Destroy();
+  }
+  nsCOMPtr<nsIPluginHost> pluginHost =
+    do_GetService("@mozilla.org/plugin/host;1");
+  if (pluginHost)
+    pluginHost->StopPluginInstance(instance);
+}
+PR_STATIC_CALLBACK(PRBool)
+FreezeSubDocument(nsIDocument *aDocument, void *aData)
+{
+  nsIPresShell *shell = aDocument->GetShellAt(0);
+  if (shell)
+    shell->Freeze();
+  return PR_TRUE;
+}
+void
+PresShell::Freeze()
+{
+  nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(mDocument);
+  if (domDoc) {
+    EnumeratePlugins(domDoc, NS_LITERAL_STRING("object"), StopPluginInstance);
+    EnumeratePlugins(domDoc, NS_LITERAL_STRING("applet"), StopPluginInstance);
+    EnumeratePlugins(domDoc, NS_LITERAL_STRING("embed"), StopPluginInstance);
+  }
+  if (mCaret)
+    mCaret->SetCaretVisible(PR_FALSE);
+  if (mDocument)
+    mDocument->EnumerateSubDocuments(FreezeSubDocument, nsnull);
+}
+static void
+StartPluginInstance(PresShell *aShell, nsIContent *aContent)
+{
+  // For now we just reconstruct the frame.
+  aShell->RecreateFramesFor(aContent);
+}
+PR_STATIC_CALLBACK(PRBool)
+ThawSubDocument(nsIDocument *aDocument, void *aData)
+{
+  nsIPresShell *shell = aDocument->GetShellAt(0);
+  if (shell)
+    shell->Thaw();
+  return PR_TRUE;
+}
+void
+PresShell::Thaw()
+{
+  nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(mDocument);
+  if (domDoc) {
+    EnumeratePlugins(domDoc, NS_LITERAL_STRING("object"), StartPluginInstance);
+    EnumeratePlugins(domDoc, NS_LITERAL_STRING("applet"), StartPluginInstance);
+    EnumeratePlugins(domDoc, NS_LITERAL_STRING("embed"), StartPluginInstance);
+  }
+  if (mDocument)
+    mDocument->EnumerateSubDocuments(ThawSubDocument, nsnull);
+}
 //--------------------------------------------------------
 // Start of protected and private methods on the PresShell
 //--------------------------------------------------------
-       Lines 7050-7055
      PresShell::Observe(nsISupports* aSubject
+  Link Here
   return NS_ERROR_FAILURE;
+}
+void
+PresShell::EnumeratePlugins(nsIDOMDocument *aDocument,
+                            const nsString &aPluginTag,
+                            nsPluginEnumCallback aCallback)
+{
+  nsCOMPtr<nsIDOMNodeList> nodes;
+  aDocument->GetElementsByTagName(aPluginTag, getter_AddRefs(nodes));
+  if (!nodes)
+    return;
+  PRUint32 length;
+  nodes->GetLength(&length);
+  for (PRUint32 i = 0; i < length; ++i) {
+    nsCOMPtr<nsIDOMNode> node;
+    nodes->Item(i, getter_AddRefs(node));
+    nsCOMPtr<nsIContent> content = do_QueryInterface(node);
+    if (content)
+      aCallback(this, content);
+  }
+}
 //------------------------------------------------------
 // End of protected and private methods on the PresShell
 //------------------------------------------------------

(-)layout/printing/nsPrintEngine.cpp (-4 / +5 lines)

Line

Link Here

Lines 4435-4444 nsPrintEngine::TurnScriptingOn(PRBool aD

Link Here

4435

4436

  // get the script global object

4436

  // get the script global object

4437

  nsIScriptGlobalObject *scriptGlobalObj = mDocument->GetScriptGlobalObject();

4437

  nsIScriptGlobalObject *scriptGlobalObj = mDocument->GetScriptGlobalObject();

4438

  NS_ASSERTION(scriptGlobalObj, "Can't get nsIScriptGlobalObject");

4438

  if (scriptGlobalObj) {

4439

  nsIScriptContext *scx = scriptGlobalObj->GetContext();

4439

    nsIScriptContext *scx = scriptGlobalObj->GetContext();

4440

  NS_ASSERTION(scx, "Can't get nsIScriptContext");

4440

    NS_ASSERTION(scx, "Can't get nsIScriptContext");

4441

  scx->SetScriptsEnabled(aDoTurnOn, PR_TRUE);

4441

    scx->SetScriptsEnabled(aDoTurnOn, PR_TRUE);

4442

4443

4444

//-----------------------------------------------------------------

4445

//-----------------------------------------------------------------

(-)layout/xul/base/src/nsMenuPopupFrame.cpp (+3 lines)

Line

Link Here

Lines 840-845 nsMenuPopupFrame::SyncViewWithFrame(nsPr

Link Here

840

  // the left or top sides of the screen may be in negative space (main monitor is on the

840

  // the left or top sides of the screen may be in negative space (main monitor is on the

841

  // right, etc). We need to be sure to do the right thing.

841

  // right, etc). We need to be sure to do the right thing.

842

  nsCOMPtr<nsIDOMWindowInternal> window(do_QueryInterface(document->GetScriptGlobalObject()));

842

  nsCOMPtr<nsIDOMWindowInternal> window(do_QueryInterface(document->GetScriptGlobalObject()));

843

  if (!window)

844

    return NS_OK;

845

843

  nsCOMPtr<nsIDOMScreen> screen;

846

  nsCOMPtr<nsIDOMScreen> screen;

844

  window->GetScreen(getter_AddRefs(screen));

847

  window->GetScreen(getter_AddRefs(screen));

845

  PRInt32 screenWidth = 0, screenHeight = 0;

848

  PRInt32 screenWidth = 0, screenHeight = 0;

(-)layout/xul/base/src/nsTitleBarFrame.cpp (-9 / +4 lines)

Line

Link Here

Lines 169-183 nsTitleBarFrame::HandleEvent(nsPresConte

Link Here

169

			   nsCOMPtr<nsIDOMWindowInternal>

169

			   nsCOMPtr<nsIDOMWindowInternal>

170

           window(do_QueryInterface(aPresContext->PresShell()->GetDocument()->GetScriptGlobalObject()));

170

           window(do_QueryInterface(aPresContext->PresShell()->GetDocument()->GetScriptGlobalObject()));

171

172

         if (window) {

173

           nsPoint nsMoveBy = aEvent->refPoint - mLastPoint;

174

				 nsPoint nsMoveBy;

174

           window->MoveBy(nsMoveBy.x,nsMoveBy.y);

175

				 nsMoveBy = aEvent->refPoint - mLastPoint;

175

176

177

178

				 window->MoveBy(nsMoveBy.x,nsMoveBy.y);

179

180

181

176

182

				 *aEventStatus = nsEventStatus_eConsumeNoDefault;

177

				 *aEventStatus = nsEventStatus_eConsumeNoDefault;

183

178





#include "nsISupports.idl"

interface nsIDOMWindow;
interface nsIDOMElement;

[scriptable, uuid(c5ca429c-b5c2-11d9-8547-00112478d626)]
interface nsISecureBrowserUI : nsISupports
{
    void init(in nsIDOMWindow window);

    readonly attribute unsigned long state;
    readonly attribute AString tooltipText;

    /* Returns an object that encapsulates the current security state. */
    nsISupports captureState();

    /**
     * Restore the state captured by captureState(), firing transition
     * notifications as necessary.
     */
    void transitionToState(in nsISupports state);
};

%{C++





    rv = svc->AddObserver(this, NS_FORMSUBMIT_SUBJECT, PR_TRUE);
  }
  
  /* GetWebProgress(mWindow) */
  // hook up to the webprogress notifications.
  nsCOMPtr<nsIScriptGlobalObject> sgo(do_QueryInterface(mWindow));
  if (!sgo) return NS_ERROR_FAILURE;

  nsIDocShell *docShell = sgo->GetDocShell();

  // The Docshell will own the SecureBrowserUI object
  if (!docShell)
    return NS_ERROR_FAILURE;

  docShell->SetSecurityUI(this);

  /* GetWebProgress(mWindow) */
  // hook up to the webprogress notifications.
  nsCOMPtr<nsIWebProgress> wp(do_GetInterface(docShell));
  if (!wp) return NS_ERROR_FAILURE;
  /* end GetWebProgress */
  

    newSecurityState = lis_no_security;
  }

  return UpdateSecurityState(newSecurityState, aRequest);
}

nsresult
nsSecureBrowserUIImpl::UpdateSecurityState(lockIconState aNewState,
                                           nsIRequest *aRequest)
{
  PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
         ("SecureUI:%p: UpdateSecurityState:  old-new  %d - %d\n", this,
         mPreviousSecurityState, aNewState
          ));

  if (mPreviousSecurityState != aNewState)
  {
    // must show alert
    

    {
      case lis_no_security:
      case lis_broken_security:
        switch (aNewState)
        {
          case lis_no_security:
          case lis_broken_security:

    
    if (showWarning)
    {
      switch (aNewState)
      {
        case lis_no_security:
        case lis_broken_security:

      }
    }

    mPreviousSecurityState = aNewState;

    if (lis_no_security == aNewState)
    {
      mSSLStatus = nsnull;
      mInfoTooltip.Truncate();

  {
    PRUint32 newState = STATE_IS_INSECURE;

    switch (aNewState)
    {
      case lis_broken_security:
        newState = STATE_IS_BROKEN;


  return result;
}

#define NS_SECUREBROWSERUISTATE_IID \
{0x086c5daf, 0xbb0a, 0x45cb, {0x98, 0x2b, 0xf1, 0x62, 0x49, 0xd5, 0x0e, 0x28}}

class nsSecureBrowserUIImpl::State : public nsISupports
{
public:
  NS_DEFINE_STATIC_IID_ACCESSOR(NS_SECUREBROWSERUISTATE_IID)
  NS_DECL_ISUPPORTS

  State(lockIconState aState, nsISupports *aSSLStatus);

  lockIconState GetState() const { return mState; }
  nsISupports* GetSSLStatus() { return mSSLStatus; }

private:
  lockIconState mState;
  nsCOMPtr<nsISupports> mSSLStatus;
};

NS_IMPL_ISUPPORTS1(nsSecureBrowserUIImpl::State, nsSecureBrowserUIImpl::State)

nsSecureBrowserUIImpl::State::State(lockIconState aState,
                                    nsISupports *aSSLStatus)
  : mState(aState), mSSLStatus(aSSLStatus)
{
}

NS_IMETHODIMP
nsSecureBrowserUIImpl::CaptureState(nsISupports **aState)
{
  *aState = new State(mPreviousSecurityState, mSSLStatus);
  NS_ENSURE_TRUE(aState, NS_ERROR_OUT_OF_MEMORY);

  NS_ADDREF(*aState);
  return NS_OK;
}

NS_IMETHODIMP
nsSecureBrowserUIImpl::TransitionToState(nsISupports *aState)
{
  nsCOMPtr<nsSecureBrowserUIImpl::State> state = do_QueryInterface(aState);
  NS_ENSURE_TRUE(state, NS_ERROR_NULL_POINTER);

  mSSLStatus = state->GetSSLStatus();
  return UpdateSecurityState(state->GetState(), nsnull);
}

(-)security/manager/boot/src/nsSecureBrowserUIImpl.h (+2 lines)

Line	Link Here

Lines 121-126 protected:	Link Here

121

  PRInt32 mSubRequestsNoSecurity;

121

  PRInt32 mSubRequestsNoSecurity;

122

123

  nsresult UpdateSecurityState(nsIRequest* aRequest);

123

  nsresult UpdateSecurityState(nsIRequest* aRequest);

124

  nsresult UpdateSecurityState(lockIconState aNewState, nsIRequest *aRequest);

124

  nsresult EvaluateAndUpdateSecurityState(nsIRequest *aRequest);

125

  nsresult EvaluateAndUpdateSecurityState(nsIRequest *aRequest);

125

  void UpdateSubrequestMembers(nsIRequest *aRequest);

126

  void UpdateSubrequestMembers(nsIRequest *aRequest);

126

127

Lines 144-149 protected:	Link Here

144

  nsresult GetNSSDialogs(nsISecurityWarningDialogs **);

145

  nsresult GetNSSDialogs(nsISecurityWarningDialogs **);

145

146

  PLDHashTable mTransferringRequests;

147

  PLDHashTable mTransferringRequests;

148

  class State;

147

};

149

};

148

150

149

151

(-)toolkit/components/passwordmgr/base/nsPasswordManager.cpp (-5 / +85 lines)

Line	Link Here

Lines 71-76	Link Here

#include "nsIAutoCompleteResult.h"

#include "nsIAutoCompleteResult.h"

#include "nsIPK11TokenDB.h"

#include "nsIPK11TokenDB.h"

#include "nsIPK11Token.h"

#include "nsIPK11Token.h"

#include "nsIScriptGlobalObject.h"

#include "nsIWindowWatcher.h"

#include "nsIDOMNSEvent.h"

static const char kPMPropertiesURL[] = "chrome://passwordmgr/locale/passwordmgr.properties";

static const char kPMPropertiesURL[] = "chrome://passwordmgr/locale/passwordmgr.properties";

static PRBool sRememberPasswords = PR_FALSE;

static PRBool sRememberPasswords = PR_FALSE;

Lines 263-268 nsPasswordManager::Init()	Link Here

263

266

264

  progress->AddProgressListener(this, nsIWebProgress::NOTIFY_STATE_DOCUMENT);

267

  progress->AddProgressListener(this, nsIWebProgress::NOTIFY_STATE_DOCUMENT);

265

268

269

  // Listen for "domwindowopened", this will let us attach our DOMPageRestore

270

  // event listener.

271

272

  obsService->AddObserver(this, "domwindowopened", PR_FALSE);

273

  obsService->AddObserver(this, "domwindowclosed", PR_FALSE);

274

275

  // Also register on any open windows that already exist, since we don't

276

  // get notifications for those.

277

278

  nsCOMPtr<nsIWindowWatcher> watcher =

279

    do_GetService(NS_WINDOWWATCHER_CONTRACTID);

280

  if (watcher) {

281

    nsCOMPtr<nsISimpleEnumerator> enumerator;

282

    watcher->GetWindowEnumerator(getter_AddRefs(enumerator));

283

    if (enumerator) {

284

      PRBool hasMore;

285

286

      while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMore)) && hasMore) {

287

        nsCOMPtr<nsISupports> item;

288

        enumerator->GetNext(getter_AddRefs(item));

289

290

        nsCOMPtr<nsIDOMEventTarget> targ = do_QueryInterface(item);

291

        if (targ) {

292

          targ->AddEventListener(NS_LITERAL_STRING("DOMPageRestore"),

293

                                 NS_STATIC_CAST(nsIDOMLoadListener*, this),

294

                                 PR_FALSE);

295

296

297

298

299

266

  // Now read in the signon file

300

  // Now read in the signon file

267

  nsXPIDLCString signonFile;

301

  nsXPIDLCString signonFile;

268

  mPrefBranch->GetCharPref("SignonFileName", getter_Copies(signonFile));

302

  mPrefBranch->GetCharPref("SignonFileName", getter_Copies(signonFile));

Lines 747-752 nsPasswordManager::Observe(nsISupports*	Link Here

747

    NS_ASSERTION(branch == mPrefBranch, "unexpected pref change notification");

781

    NS_ASSERTION(branch == mPrefBranch, "unexpected pref change notification");

748

782

749

    branch->GetBoolPref("rememberSignons", &sRememberPasswords);

783

    branch->GetBoolPref("rememberSignons", &sRememberPasswords);

784

  } else if (!strcmp(aTopic, "domwindowopened")) {

785

    nsCOMPtr<nsIDOMEventTarget> targ = do_QueryInterface(aSubject);

786

    if (targ) {

787

      targ->AddEventListener(NS_LITERAL_STRING("DOMPageRestore"),

788

                             NS_STATIC_CAST(nsIDOMLoadListener*, this),

789

                             PR_FALSE);

790

791

  } else if (!strcmp(aTopic, "domwindowclosed")) {

792

    nsCOMPtr<nsIDOMEventTarget> targ = do_QueryInterface(aSubject);

793

    if (targ) {

794

      targ->RemoveEventListener(NS_LITERAL_STRING("DOMPageRestore"),

795

                                NS_STATIC_CAST(nsIDOMLoadListener*, this),

796

                                PR_FALSE);

797

750

798

751

799

752

  return NS_OK;

800

  return NS_OK;

Lines 765-780 nsPasswordManager::OnStateChange(nsIWebP	Link Here

765

      !(aStateFlags & nsIWebProgressListener::STATE_STOP))

813

      !(aStateFlags & nsIWebProgressListener::STATE_STOP))

766

    return NS_OK;

814

    return NS_OK;

767

815

768

  // Don't do anything if the global signon pref is disabled

769

  if (!SingleSignonEnabled())

770

    return NS_OK;

771

772

  nsCOMPtr<nsIDOMWindow> domWin;

816

  nsCOMPtr<nsIDOMWindow> domWin;

773

  nsresult rv = aWebProgress->GetDOMWindow(getter_AddRefs(domWin));

817

  nsresult rv = aWebProgress->GetDOMWindow(getter_AddRefs(domWin));

774

  NS_ENSURE_SUCCESS(rv, rv);

818

  NS_ENSURE_SUCCESS(rv, rv);

775

819

820

  return DoPrefill(domWin);

821

822

823

nsresult

824

nsPasswordManager::DoPrefill(nsIDOMWindow *aDOMWindow)

825

826

  // Don't do anything if the global signon pref is disabled

827

  if (!SingleSignonEnabled())

828

    return NS_OK;

829

776

  nsCOMPtr<nsIDOMDocument> domDoc;

830

  nsCOMPtr<nsIDOMDocument> domDoc;

777

  domWin->GetDocument(getter_AddRefs(domDoc));

831

  aDOMWindow->GetDocument(getter_AddRefs(domDoc));

778

  NS_ASSERTION(domDoc, "DOM window should always have a document!");

832

  NS_ASSERTION(domDoc, "DOM window should always have a document!");

779

833

780

  // For now, only prefill forms in HTML documents.

834

  // For now, only prefill forms in HTML documents.

Lines 1568-1573 nsPasswordManager::Error(nsIDOMEvent* aE	Link Here

1568

  return NS_OK;

1622

  return NS_OK;

1569

1623

1570

1624

1625

NS_IMETHODIMP

1626

nsPasswordManager::PageRestore(nsIDOMEvent* aEvent)

1627

1628

  // Only autofill for trusted events.

1629

  nsCOMPtr<nsIDOMNSEvent> nsevent = do_QueryInterface(aEvent);

1630

  PRBool trusted = PR_FALSE;

1631

  if (nsevent)

1632

    nsevent->GetIsTrusted(&trusted);

1633

  if (!trusted)

1634

    return NS_OK;

1635

1636

  nsCOMPtr<nsIDOMEventTarget> target;

1637

  aEvent->GetTarget(getter_AddRefs(target));

1638

1639

  nsCOMPtr<nsIDocument> doc = do_QueryInterface(target);

1640

  if (doc) {

1641

    nsCOMPtr<nsIDOMWindow> win =

1642

      do_QueryInterface(doc->GetScriptGlobalObject());

1643

    if (win) {

1644

      return DoPrefill(win);

1645

1646

1647

1648

  return NS_OK;

1649

1650

1571

1651

1572

// internal methods

1652

// internal methods

1573

1653

(-)toolkit/components/passwordmgr/base/nsPasswordManager.h (+2 lines)

Line	Link Here

Lines 136-141 public:	Link Here

136

  NS_IMETHOD BeforeUnload(nsIDOMEvent* aEvent);

136

  NS_IMETHOD BeforeUnload(nsIDOMEvent* aEvent);

137

  NS_IMETHOD Abort(nsIDOMEvent* aEvent);

137

  NS_IMETHOD Abort(nsIDOMEvent* aEvent);

138

  NS_IMETHOD Error(nsIDOMEvent* aEvent);

138

  NS_IMETHOD Error(nsIDOMEvent* aEvent);

139

  NS_IMETHOD PageRestore(nsIDOMEvent* aEvent);

139

140

  // Autocomplete

141

  // Autocomplete

141

  PRBool AutoCompleteSearch(const nsAString& aSearchString,

142

  PRBool AutoCompleteSearch(const nsAString& aSearchString,

Lines 157-162 protected:	Link Here

157

  nsresult FillPassword(nsIDOMEvent* aEvent);

158

  nsresult FillPassword(nsIDOMEvent* aEvent);

158

  void AttachToInput(nsIDOMHTMLInputElement* aElement);

159

  void AttachToInput(nsIDOMHTMLInputElement* aElement);

159

  PRBool GetPasswordRealm(nsIURI* aURI, nsACString& aRealm);

160

  PRBool GetPasswordRealm(nsIURI* aURI, nsACString& aRealm);

161

  nsresult DoPrefill(nsIDOMWindow *aDOMWindw);

160

162

161

  static PLDHashOperator PR_CALLBACK FindEntryEnumerator(const nsACString& aKey,

163

  static PLDHashOperator PR_CALLBACK FindEntryEnumerator(const nsACString& aKey,

162

                                                         SignonHashEntry* aEntry,

164

                                                         SignonHashEntry* aEntry,

(-)toolkit/components/satchel/src/nsFormFillController.cpp (+6 lines)

Line	Link Here

Lines 880-885 nsFormFillController::Error(nsIDOMEvent	Link Here

880

  return NS_OK;

880

  return NS_OK;

881

882

883

NS_IMETHODIMP

884

nsFormFillController::PageRestore(nsIDOMEvent *aLoadEvent)

885

886

  return NS_OK;

887

888

883

////////////////////////////////////////////////////////////////////////

889

////////////////////////////////////////////////////////////////////////

884

//// nsFormFillController

890

//// nsFormFillController

885

891

(-)toolkit/components/satchel/src/nsFormFillController.h (+1 lines)

Line	Link Here

Lines 112-117 public:	Link Here

112

  NS_IMETHOD Unload(nsIDOMEvent *aLoadEvent);

112

  NS_IMETHOD Unload(nsIDOMEvent *aLoadEvent);

113

  NS_IMETHOD Abort(nsIDOMEvent *aLoadEvent);

113

  NS_IMETHOD Abort(nsIDOMEvent *aLoadEvent);

114

  NS_IMETHOD Error(nsIDOMEvent *aLoadEvent);

114

  NS_IMETHOD Error(nsIDOMEvent *aLoadEvent);

115

  NS_IMETHOD PageRestore(nsIDOMEvent* aLoadEvent);

115

116

  nsFormFillController();

117

  nsFormFillController();

117

  virtual ~nsFormFillController();

118

  virtual ~nsFormFillController();

(-)toolkit/components/typeaheadfind/src/nsTypeAheadFind.cpp (+1 lines)

Line	Link Here

Lines 104-109 NS_INTERFACE_MAP_BEGIN(nsTypeAheadFind)	Link Here

104

  NS_INTERFACE_MAP_ENTRY(nsITypeAheadFind)

104

  NS_INTERFACE_MAP_ENTRY(nsITypeAheadFind)

105

  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsITypeAheadFind)

105

  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsITypeAheadFind)

106

  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)

106

  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)

107

  NS_INTERFACE_MAP_ENTRY(nsIObserver)

107

NS_INTERFACE_MAP_END

108

NS_INTERFACE_MAP_END

108

109

NS_IMPL_ADDREF(nsTypeAheadFind)

110

NS_IMPL_ADDREF(nsTypeAheadFind)

(-)toolkit/content/widgets/browser.xml (-5 / +5 lines)

Line	Link Here

Lines 484-492	Link Here

484

        null

484

        null

485

      </field>

485

      </field>

486

487

      <field name="securityUI">

487

      <property name="securityUI"

488

        null

488

                onget="return this.docShell.securityUI;"

489

      </field>

489

                onset="this.docShell.securityUI = val;"/>

490

491

      <field name="userTypedClear">

491

      <field name="userTypedClear">

492

        true

492

        true

Lines 544-551	Link Here

544

            const SECUREBROWSERUI_CONTRACTID = "@mozilla.org/secure_browser_ui;1";

544

            const SECUREBROWSERUI_CONTRACTID = "@mozilla.org/secure_browser_ui;1";

545

            if (!this.hasAttribute("disablesecurity") &&

545

            if (!this.hasAttribute("disablesecurity") &&

546

                SECUREBROWSERUI_CONTRACTID in Components.classes) {

546

                SECUREBROWSERUI_CONTRACTID in Components.classes) {

547

              this.securityUI = Components.classes[SECUREBROWSERUI_CONTRACTID].createInstance(Components.interfaces.nsISecureBrowserUI);

547

              var securityUI = Components.classes[SECUREBROWSERUI_CONTRACTID].createInstance(Components.interfaces.nsISecureBrowserUI);

548

              this.securityUI.init(this.contentWindow);

548

	      securityUI.init(this.contentWindow);

549

550

551

          catch (e) {

551

          catch (e) {

(-)view/src/nsView.cpp (+27 lines)

Line	Link Here

Lines 491-496 NS_IMETHODIMP nsView::SetFloating(PRBool	Link Here

491

	return NS_OK;

491

	return NS_OK;

492

493

494

void nsView::InvalidateHierarchy()

495

496

  if (mViewManager->GetRootView() == this)

497

    mViewManager->InvalidateHierarchy();

498

499

  for (nsView *child = mFirstChild; child; child = child->GetNextSibling())

500

    child->InvalidateHierarchy();

501

502

494

void nsView::InsertChild(nsView *aChild, nsView *aSibling)

503

void nsView::InsertChild(nsView *aChild, nsView *aSibling)

495

504

496

  NS_PRECONDITION(nsnull != aChild, "null ptr");

505

  NS_PRECONDITION(nsnull != aChild, "null ptr");

Lines 512-517 void nsView::InsertChild(nsView *aChild,	Link Here

512

      mFirstChild = aChild;

521

      mFirstChild = aChild;

513

522

514

    aChild->SetParent(this);

523

    aChild->SetParent(this);

524

525

    // If we just inserted a root view, then update the RootViewManager

526

    // on all view managers in the new subtree.

527

528

    nsViewManager *vm = aChild->GetViewManager();

529

    if (vm->GetRootView() == aChild)

530

531

      aChild->InvalidateHierarchy();

532

515

533

516

534

517

535

Lines 540-545 void nsView::RemoveChild(nsView *child)	Link Here

540

	    kid = kid->GetNextSibling();

558

	    kid = kid->GetNextSibling();

541

559

542

    NS_ASSERTION(found, "tried to remove non child");

560

    NS_ASSERTION(found, "tried to remove non child");

561

562

    // If we just removed a root view, then update the RootViewManager

563

    // on all view managers in the removed subtree.

564

565

    nsViewManager *vm = child->GetViewManager();

566

    if (vm->GetRootView() == child)

567

568

      child->InvalidateHierarchy();

569

543

570

544

571

545

572

(-)view/src/nsView.h (+3 lines)

Line	Link Here

Lines 291-296 public:	Link Here

291

  void SetPositionIgnoringChildWidgets(nscoord aX, nscoord aY);

291

  void SetPositionIgnoringChildWidgets(nscoord aX, nscoord aY);

292

  nsresult LoadWidget(const nsCID &aClassIID);

292

  nsresult LoadWidget(const nsCID &aClassIID);

293

294

  // Update the cached RootViewManager for all view manager descendents.

295

  void InvalidateHierarchy();

296

294

  virtual ~nsView();

297

  virtual ~nsView();

295

298

296

protected:

299

protected:

-      Line
+  Link Here
-       Lines 4440-4442
      nsViewManager::ProcessSynthMouseMoveEven
+  Link Here
   if (!aFromScroll)
     mSynthMouseMoveEventQueue = nsnull;
+}
+void
+nsViewManager::InvalidateHierarchy()
+{
+  if (mRootView) {
+    if (mRootViewManager != this) {
+      NS_IF_RELEASE(mRootViewManager);
+    }
+    nsView *parent = mRootView->GetParent();
+    if (parent) {
+      mRootViewManager = parent->GetViewManager()->RootViewManager();
+      NS_ADDREF(mRootViewManager);
+      NS_ASSERTION(mRootViewManager != this,
+                   "Root view had a parent, but it has the same view manager");
+    } else {
+      mRootViewManager = this;
+    }
+  }
+}

(-)view/src/nsViewManager.h (+3 lines)

Line	Link Here

Lines 267-272 public:	Link Here

267

  NS_IMETHOD SynthesizeMouseMove(PRBool aFromScroll);

267

  NS_IMETHOD SynthesizeMouseMove(PRBool aFromScroll);

268

  void ProcessSynthMouseMoveEvent(PRBool aFromScroll);

268

  void ProcessSynthMouseMoveEvent(PRBool aFromScroll);

269

270

  /* Update the cached RootViewManager pointer on this view manager. */

271

  void InvalidateHierarchy();

272

270

protected:

273

protected:

271

  virtual ~nsViewManager();

274

  virtual ~nsViewManager();

272

275

(-)widget/public/nsGUIEvent.h (+1 lines)

235

#define NS_IMAGE_ERROR                  (NS_STREAM_EVENT_START + 4)

235

#define NS_IMAGE_ERROR                  (NS_STREAM_EVENT_START + 4)

236

#define NS_SCRIPT_LOAD                  (NS_STREAM_EVENT_START + 5)

236

#define NS_SCRIPT_LOAD                  (NS_STREAM_EVENT_START + 5)

237

#define NS_BEFORE_PAGE_UNLOAD           (NS_STREAM_EVENT_START + 6)

237

#define NS_BEFORE_PAGE_UNLOAD           (NS_STREAM_EVENT_START + 6)

238

#define NS_PAGE_RESTORE                 (NS_STREAM_EVENT_START + 7)

238

239

#define NS_FORM_EVENT_START             1200

240

#define NS_FORM_EVENT_START             1200

240

#define NS_FORM_SUBMIT                  (NS_FORM_EVENT_START)

241

#define NS_FORM_SUBMIT                  (NS_FORM_EVENT_START)






%{C++
/**
 * The signature of the timer callback function passed to initWithFuncCallback.
 * This is the function that will get called when the timer expires if the
 * timer is initialized via initWithFuncCallback.
 *
 * @param aTimer the timer which has expired
 * @param aClosure opaque parameter passed to initWithFuncCallback
 *
 * Implementers should return the following:
 *

 * delay to avoid the overhead of destroying and creating a timer.  It is not
 * necessary to cancel the timer in that case.
 */
[scriptable, uuid(436a83fa-b396-11d9-bcfa-00112478d626)]
interface nsITimer : nsISupports
{
  /* Timer types */

  attribute unsigned long type;

  /**
   * The opaque pointer pass to initWithFuncCallback.
   */  
  [noscript] readonly attribute voidPtr closure;

  /**
   * The nsITimerCallback object passed to initWithCallback.
   */
  readonly attribute nsITimerCallback callback;
};

%{C++





}


NS_IMETHODIMP nsTimerImpl::GetCallback(nsITimerCallback **aCallback)
{
  if (mCallbackType == CALLBACK_TYPE_INTERFACE)
    NS_IF_ADDREF(*aCallback = mCallback.i);
  else
    *aCallback = nsnull;

  return NS_OK;
}


NS_IMETHODIMP nsTimerImpl::GetIdle(PRBool *aIdle)
{
  *aIdle = mIdle;





interface nsIHistoryEntry : nsISupports 
{

    /** 
     * A readonly property that returns the URI
     * of the current entry. The object returned is
     * of type nsIURI
     */
    readonly attribute nsIURI URI;

    /** 
     * A readonly property that returns the title
     * of the current entry.  The object returned
     * is a encoded string
     */
    readonly attribute wstring title;

    /** 
     * A readonly property that returns a boolean
     * flag which indicates if the entry was created as a 
     * result of a subframe navigation. This flag will be
     * 'false' when a frameset page is visited for
     * the first time. This flag will be 'true' for all
     * history entries created as a result of a subframe
     * navigation.
     */
    readonly attribute boolean isSubFrame;

};


(-)xpfe/components/shistory/public/nsISHEntry.idl (-72 / +129 lines)

Line	Link Here

Lines 42-129	Link Here

 * hold all information required to recreate the document from history

 * hold all information required to recreate the document from history

*/

*/

#include "nsISupports.idl"

#include "nsIHistoryEntry.idl"

#include "nsIURI.idl"

#include "nsIInputStream.idl"

interface nsILayoutHistoryState;

interface nsILayoutHistoryState;

interface nsIDOMDocument;

interface nsIContentViewer;

interface nsIURI;

interface nsIInputStream;

interface nsIDocShellTreeItem;

interface nsISecureBrowserUIState;

interface nsISupportsArray;

%{C++

struct nsRect;

%}

[ref] native nsRect(nsRect);

[scriptable, uuid(6b596e1f-a3bd-40f9-a7ee-ab3edc7f9960)]

[scriptable, uuid(e47bf412-3bc2-4306-a82f-ea2bdf950432)]

interface nsISHEntry : nsISupports

interface nsISHEntry : nsIHistoryEntry

    /** URI for the document */

    void setURI(in nsIURI aURI);

/** URI for the document */

    /** Referrer URI */

void SetURI(in nsIURI aURI);

    attribute nsIURI referrerURI;

/** Referrer URI */

attribute nsIURI referrerURI;

/**  DOM Document */

    /** Content viewer, for fast restoration of presentation */

attribute nsIDOMDocument document;

    attribute nsIContentViewer contentViewer;

/** Title for the document */

    /** Whether the content viewer is marked "sticky" */

void SetTitle(in wstring aTitle);

    attribute boolean sticky;

/** Post Data for the document */

    /** Saved state of the global window object */

attribute nsIInputStream postData;

    attribute nsISupports windowState;

/** LayoutHistoryState for scroll position and form values */

/**

attribute nsILayoutHistoryState layoutHistoryState;

     * Saved position and dimensions of the content viewer; we must adjust the

     * root view's widget accordingly if this has changed when the presentation

/** parent of this entry */

     * is restored.

attribute nsISHEntry parent;

*/

    [noscript] void getViewerBounds(in nsRect bounds);

/**

    [noscript] void setViewerBounds([const] in nsRect bounds);

 * The loadType for this entry. This is typically loadHistory except

 * when reload is pressed, it has the appropriate reload flag

/**

*/

     * Saved child docshells corresponding to contentViewer.  There are weak

attribute  unsigned long loadType;

     * references since it's assumed that the content viewer's document has

     * an owning reference to the subdocument for each shell.  The child shells

/**

     * are restored as children of the parent docshell, in this order, when the

 * An ID to help identify this entry from others during

     * parent docshell restores a saved presentation.

 * subframe navigation

*/

*/

attribute unsigned long ID;

    /** Append a child shell to the end of our list. */

    void addChildShell(in nsIDocShellTreeItem shell);

/**

 * pageIdentifier is an integer that should be the same for two entries

/**

 * attached to the same docshell only if the two entries are entries for the

     * Get the child shell at |index|; returns null if |index| is out of bounds.

 * same page in the sense that one could go from the state represented by one

*/

 * to the state represented by the other simply by scrolling (so the entries

    nsIDocShellTreeItem childShellAt(in long index);

 * are separated by an anchor traversal or a subframe navigation in some other

100

 * frame).

101

/**

*/

102

     * Clear the child shell list.

attribute unsigned long pageIdentifier;

103

*/

104

    void clearChildShells();

/** attribute to set and get the cache key for the entry */

105

100

attribute nsISupports cacheKey;

106

    /** Saved security state for the content viewer */

101

107

    attribute nsISupports securityState;

102

/** attribute to indicate whether layoutHistoryState should be saved */

108

103

attribute boolean saveLayoutStateFlag;

109

    /** Saved refresh URI list for the content viewer */

104

110

    attribute nsISupportsArray refreshURIList;

105

/** attribute to indicate whether the page is already expired in cache */

111

106

attribute boolean expirationStatus;

112

/**

107

113

     * Ensure that the cached presentation members are self-consistent.

108

/** attribute to indicate the content-type of the document that this

114

     * If either |contentViewer| or |windowState| are null, then all of the

109

    is a session history entry for */

115

     * following members are cleared/reset:

110

attribute ACString contentType;

116

     *  contentViewer, sticky, windowState, viewerBounds, childShells,

117

     *  refreshURIList.

118

*/

119

    void syncPresentationState();

120

121

    /** Title for the document */

122

    void setTitle(in AString aTitle);

123

124

    /** Post Data for the document */

125

    attribute nsIInputStream postData;

126

127

    /** LayoutHistoryState for scroll position and form values */

128

    attribute nsILayoutHistoryState layoutHistoryState;

129

130

    /** parent of this entry */

131

    attribute nsISHEntry parent;

132

133

/**

134

     * The loadType for this entry. This is typically loadHistory except

135

     * when reload is pressed, it has the appropriate reload flag

136

*/

137

    attribute unsigned long loadType;

138

139

/**

140

     * An ID to help identify this entry from others during

141

     * subframe navigation

142

*/

143

    attribute unsigned long ID;

144

145

/**

146

     * pageIdentifier is an integer that should be the same for two entries

147

     * attached to the same docshell only if the two entries are entries for

148

     * the same page in the sense that one could go from the state represented

149

     * by one to the state represented by the other simply by scrolling (so the

150

     * entries are separated by an anchor traversal or a subframe navigation in

151

     * some other frame).

152

*/

153

    attribute unsigned long pageIdentifier;

154

155

    /** attribute to set and get the cache key for the entry */

156

    attribute nsISupports cacheKey;

157

158

    /** attribute to indicate whether layoutHistoryState should be saved */

159

    attribute boolean saveLayoutStateFlag;

160

161

    /** attribute to indicate whether the page is already expired in cache */

162

    attribute boolean expirationStatus;

163

164

/**

165

     * attribute to indicate the content-type of the document that this

166

     * is a session history entry for

167

*/

168

    attribute ACString contentType;

111

169

112

/** Set/Get scrollers' positon in anchored pages */

170

    /** Set/Get scrollers' positon in anchored pages */

113

void setScrollPosition(in PRInt32 x, in PRInt32 y);

171

    void setScrollPosition(in long x, in long y);

114

void getScrollPosition(out PRInt32 x, out PRInt32 y);

172

    void getScrollPosition(out long x, out long y);

115

173

116

/** Additional ways to create an entry */

174

    /** Additional ways to create an entry */

117

void create(in nsIURI aURI, in wstring aTitle, in nsIDOMDocument aDocument,

175

    void create(in nsIURI URI, in AString title,

118

            in nsIInputStream aInputStream, in nsILayoutHistoryState aHistoryLayoutState,

176

                in nsIInputStream inputStream,

119

            in nsISupports aCacheKey, in ACString aContentType);

177

                in nsILayoutHistoryState layoutHistoryState,

120

178

                in nsISupports cacheKey, in ACString contentType);

121

nsISHEntry clone();

122

123

/** Attribute that indicates if this entry is for a subframe navigation */

124

void SetIsSubFrame(in boolean aFlag);

125

179

180

    nsISHEntry clone();

126

181

182

    /** Attribute that indicates if this entry is for a subframe navigation */

183

    void setIsSubFrame(in boolean aFlag);

127

};

184

};

128

185

129

186

(-)xpfe/components/shistory/public/nsISHistoryInternal.idl (-1 / +8 lines)

Line	Link Here

Lines 46-52 interface nsIDocShell;	Link Here

%{C++

%{C++

#define NS_SHISTORY_INTERNAL_CID \

#define NS_SHISTORY_INTERNAL_CID \

{0xdd335422, 0xb8b8, 0x11d3, {0xbd, 0xc8, 0x00, 0x50, 0x04, 0x0a, 0x9b, 0x44}}

{0x5b4cba4c, 0xbf67, 0x499a, {0xae, 0x2c, 0x3f, 0x76, 0x65, 0x6f, 0x4a, 0x4e}}

#define NS_SHISTORY_INTERNAL_CONTRACTID "@mozilla.org/browser/shistory-internal;1"

#define NS_SHISTORY_INTERNAL_CONTRACTID "@mozilla.org/browser/shistory-internal;1"

%}

%}

Lines 90-93 interface nsISHistoryInternal: nsISuppor	Link Here

*/

*/

   readonly attribute nsISHistoryListener listener;

   readonly attribute nsISHistoryListener listener;

/**

   * Evict content viewers until the number of content viewers is no more than

   * browser.sessionhistory.max_viewers.  This is done automatically by

   * updateIndex(), but should be called explicitly if a new history entry

   * is added and later has a content viewer set.

*/

   void evictContentViewers();

};

100

};

(-)xpfe/components/shistory/src/Makefile.in (+1 lines)

Line	Link Here

Lines 55-60 REQUIRES = xpcom \	Link Here

		  layout \

		  layout \

		  docshell \

		  docshell \

		  pref \

		  pref \

		  gfx \

		  $(NULL)

		  $(NULL)

CPPSRCS		= nsSHEntry.cpp        \

CPPSRCS		= nsSHEntry.cpp        \





 *
 * ***** END LICENSE BLOCK ***** */

#ifdef DEBUG_bryner
#define DEBUG_PAGE_CACHE
#endif

// Local Includes
#include "nsSHEntry.h"
#include "nsXPIDLString.h"
#include "nsReadableUtils.h"
#include "nsIDocShellLoadInfo.h"
#include "nsIDocShellTreeItem.h"

static PRUint32 gEntryID = 0;


  , mIsFrameNavigation(PR_FALSE)
  , mSaveLayoutState(PR_TRUE)
  , mExpired(PR_FALSE)
  , mSticky(PR_TRUE)
  , mParent(nsnull)
  , mViewerBounds(0, 0, 0, 0)
{
}


  , mIsFrameNavigation(other.mIsFrameNavigation)
  , mSaveLayoutState(other.mSaveLayoutState)
  , mExpired(other.mExpired)
  , mSticky(PR_TRUE)
  // XXX why not copy mContentType?
  , mCacheKey(other.mCacheKey)
  , mParent(other.mParent)
  , mViewerBounds(0, 0, 0, 0)
{
}

nsSHEntry::~nsSHEntry()
{
  mChildren.Clear();
  if (mContentViewer)
    mContentViewer->Destroy();
}

//*****************************************************************************
//    nsSHEntry: nsISupports
//*****************************************************************************

  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::SetContentViewer(nsIContentViewer *aViewer)
{
  mContentViewer = aViewer;
  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::GetContentViewer(nsIContentViewer **aResult)
{
  *aResult = mContentViewer;
  NS_IF_ADDREF(*aResult);
  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::SetSticky(PRBool aSticky)
{
  mSticky = aSticky;
  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::GetSticky(PRBool *aSticky)
{
  *aSticky = mSticky;
  return NS_OK;
}

NS_IMETHODIMP nsSHEntry::GetTitle(PRUnichar** aTitle)
{
  // Check for empty title...

  return NS_OK;
}

NS_IMETHODIMP nsSHEntry::SetTitle(const nsAString &aTitle)
{
  mTitle = aTitle;
  return NS_OK;

}

NS_IMETHODIMP
nsSHEntry::Create(nsIURI * aURI, const nsAString &aTitle,
                  nsIInputStream * aInputStream,
                  nsILayoutHistoryState * aLayoutHistoryState,
                  nsISupports * aCacheKey, const nsACString& aContentType)
{
  mURI = aURI;
  mTitle = aTitle;
  mDocument = aDOMDocument;
  mPostData = aInputStream;
  mCacheKey = aCacheKey;
  mContentType = aContentType;

  // all subframe navigations, sets the flag to true.
  mIsFrameNavigation = PR_FALSE;

  // By default we save LayoutHistoryState
  mSaveLayoutState = PR_TRUE;
  mLayoutHistoryState = aLayoutHistoryState;

  //By default the page is not expired
  mExpired = PR_FALSE;

  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::SetWindowState(nsISupports *aState)
{
  mWindowState = aState;
  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::GetWindowState(nsISupports **aState)
{
  NS_IF_ADDREF(*aState = mWindowState);
  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::SetViewerBounds(const nsRect &aBounds)
{
  mViewerBounds = aBounds;
  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::GetViewerBounds(nsRect &aBounds)
{
  aBounds = mViewerBounds;
  return NS_OK;
}

//*****************************************************************************
//    nsSHEntry: nsISHContainer
//*****************************************************************************

  }
  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::AddChildShell(nsIDocShellTreeItem *aShell)
{
  NS_ASSERTION(aShell, "Null child shell added to history entry");
  mChildShells.AppendElement(aShell);
  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::ChildShellAt(PRInt32 aIndex, nsIDocShellTreeItem **aShell)
{
  NS_IF_ADDREF(*aShell =
               NS_STATIC_CAST(nsIDocShellTreeItem*,
                              mChildShells.SafeElementAt(aIndex)));
  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::ClearChildShells()
{
  mChildShells.Clear();
  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::GetSecurityState(nsISupports **aState)
{
  NS_IF_ADDREF(*aState = mSecurityState);
  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::SetSecurityState(nsISupports *aState)
{
  mSecurityState = aState;
  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::GetRefreshURIList(nsISupportsArray **aList)
{
  NS_IF_ADDREF(*aList = mRefreshURIList);
  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::SetRefreshURIList(nsISupportsArray *aList)
{
  mRefreshURIList = aList;
  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::SyncPresentationState()
{
  if (mContentViewer && mWindowState) {
    // If we have a content viewer and a window state, we should be ok.
    return NS_OK;
  }

  // If not, then nuke all of the presentation-related members.
  if (mContentViewer)
    mContentViewer->SetHistoryEntry(nsnull);

  mContentViewer = nsnull;
  mSticky = PR_TRUE;
  mWindowState = nsnull;
  mViewerBounds.SetRect(0, 0, 0, 0);
  mChildShells.Clear();
  mSecurityState = nsnull;
  mRefreshURIList = nsnull;
  return NS_OK;
}

(-)xpfe/components/shistory/src/nsSHEntry.h (-5 / +13 lines)

Line	Link Here

Lines 44-52	Link Here

#include "nsCOMPtr.h"

#include "nsCOMPtr.h"

#include "nsCOMArray.h"

#include "nsCOMArray.h"

#include "nsString.h"

#include "nsString.h"

#include "nsVoidArray.h"

// Interfaces needed

// Interfaces needed

#include "nsIDOMDocument.h"

#include "nsIContentViewer.h"

#include "nsIInputStream.h"

#include "nsIInputStream.h"

#include "nsILayoutHistoryState.h"

#include "nsILayoutHistoryState.h"

#include "nsISHEntry.h"

#include "nsISHEntry.h"

Lines 54-62	Link Here

#include "nsIURI.h"

#include "nsIURI.h"

#include "nsIEnumerator.h"

#include "nsIEnumerator.h"

#include "nsIHistoryEntry.h"

#include "nsIHistoryEntry.h"

#include "nsRect.h"

#include "nsSupportsArray.h"

class nsSHEntry : public nsIHistoryEntry,

class nsSHEntry : public nsISHEntry,

                  public nsISHEntry,

                  public nsISHContainer

                  public nsISHContainer

public:

public:

Lines 69-79 public:	Link Here

  NS_DECL_NSISHCONTAINER

  NS_DECL_NSISHCONTAINER

private:

private:

  ~nsSHEntry() { mChildren.Clear(); }

  ~nsSHEntry();

  nsCOMPtr<nsIURI>                mURI;

  nsCOMPtr<nsIURI>                mURI;

  nsCOMPtr<nsIURI>                mReferrerURI;

  nsCOMPtr<nsIURI>                mReferrerURI;

  nsCOMPtr<nsIDOMDocument>        mDocument;

  nsCOMPtr<nsIContentViewer>      mContentViewer;

  nsString                        mTitle;

  nsString                        mTitle;

  nsCOMPtr<nsIInputStream>        mPostData;

  nsCOMPtr<nsIInputStream>        mPostData;

  nsCOMPtr<nsILayoutHistoryState> mLayoutHistoryState;

  nsCOMPtr<nsILayoutHistoryState> mLayoutHistoryState;

Lines 86-94 private:	Link Here

  PRPackedBool                    mIsFrameNavigation;

  PRPackedBool                    mIsFrameNavigation;

  PRPackedBool                    mSaveLayoutState;

  PRPackedBool                    mSaveLayoutState;

  PRPackedBool                    mExpired;

  PRPackedBool                    mExpired;

  PRPackedBool                    mSticky;

  nsCString                       mContentType;

  nsCString                       mContentType;

  nsCOMPtr<nsISupports>           mCacheKey;

  nsCOMPtr<nsISupports>           mCacheKey;

  nsISHEntry *                    mParent;  // weak reference

  nsISHEntry *                    mParent;  // weak reference

  nsCOMPtr<nsISupports>           mWindowState;

  nsRect                          mViewerBounds;

  nsVoidArray                     mChildShells;

  nsCOMPtr<nsISupports>           mSecurityState;

  nsCOMPtr<nsISupportsArray>      mRefreshURIList;

};

100

};

101

#endif /* nsSHEntry_h */

102

#endif /* nsSHEntry_h */

(-)xpfe/components/shistory/src/nsSHistory.cpp (-1 / +76 lines)

Line	Link Here

Lines 54-62	Link Here

#include "nsIDocShellLoadInfo.h"

#include "nsIDocShellLoadInfo.h"

#include "nsIServiceManager.h"

#include "nsIServiceManager.h"

#include "nsIPrefService.h"

#include "nsIPrefService.h"

#include "nsIURI.h"

#include "nsIContentViewer.h"

#define PREF_SHISTORY_SIZE "browser.sessionhistory.max_entries"

#define PREF_SHISTORY_SIZE "browser.sessionhistory.max_entries"

#define PREF_SHISTORY_VIEWERS "browser.sessionhistory.max_viewers"

static PRInt32  gHistoryMaxSize = 50;

static PRInt32  gHistoryMaxSize = 50;

static PRInt32  gHistoryMaxViewers = 0;

enum HistCmd{

enum HistCmd{

  HIST_CMD_BACK,

  HIST_CMD_BACK,

Lines 104-114 nsSHistory::Init()	Link Here

104

109

105

  nsCOMPtr<nsIPrefService> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);

110

  nsCOMPtr<nsIPrefService> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);

106

  if (prefs) {

111

  if (prefs) {

112

    // Session history size is only taken from the default prefs branch.

113

    // This means that it's only configurable on a per-application basis.

114

    // The goal of this is to unbreak users who have inadvertently set their

115

    // session history size to -1.

107

    nsCOMPtr<nsIPrefBranch> defaultBranch;

116

    nsCOMPtr<nsIPrefBranch> defaultBranch;

108

    prefs->GetDefaultBranch(nsnull, getter_AddRefs(defaultBranch));

117

    prefs->GetDefaultBranch(nsnull, getter_AddRefs(defaultBranch));

109

    if (defaultBranch) {

118

    if (defaultBranch) {

110

      defaultBranch->GetIntPref(PREF_SHISTORY_SIZE, &gHistoryMaxSize);

119

      defaultBranch->GetIntPref(PREF_SHISTORY_SIZE, &gHistoryMaxSize);

111

120

121

122

    // The size of the content viewer cache does not suffer from this problem,

123

    // so we allow it to be overridden by user prefs.

124

    nsCOMPtr<nsIPrefBranch> branch = do_QueryInterface(prefs);

125

    if (branch)

126

      branch->GetIntPref(PREF_SHISTORY_VIEWERS, &gHistoryMaxViewers);

112

127

113

  return NS_OK;

128

  return NS_OK;

114

129

Lines 207-212 nsSHistory::GetEntryAtIndex(PRInt32 aInd	Link Here

207

    if (NS_SUCCEEDED(rv) && (*aResult)) {

222

    if (NS_SUCCEEDED(rv) && (*aResult)) {

208

      // Set mIndex to the requested index, if asked to do so..

223

      // Set mIndex to the requested index, if asked to do so..

209

      if (aModifyIndex) {

224

      if (aModifyIndex) {

225

        EvictContentViewers(mIndex, aIndex);

210

        mIndex = aIndex;

226

        mIndex = aIndex;

211

227

212

    } //entry

228

    } //entry

Lines 476-481 nsSHistory::GetListener(nsISHistoryListe	Link Here

476

  return NS_OK;

492

  return NS_OK;

477

493

478

494

495

NS_IMETHODIMP

496

nsSHistory::EvictContentViewers()

497

498

  // This is called after a new entry has been appended to the end of the list.

499

  EvictContentViewers(mIndex - 1, mIndex);

500

  return NS_OK;

501

502

479

//*****************************************************************************

503

//*****************************************************************************

480

//    nsSHistory: nsIWebNavigation

504

//    nsSHistory: nsIWebNavigation

481

//*****************************************************************************

505

//*****************************************************************************

Lines 583-594 nsSHistory::Reload(PRUint32 aReloadFlags	Link Here

583

	return LoadEntry(mIndex, loadType, HIST_CMD_RELOAD);

607

	return LoadEntry(mIndex, loadType, HIST_CMD_RELOAD);

584

608

585

609

610

void

611

nsSHistory::EvictContentViewers(PRInt32 aFromIndex, PRInt32 aToIndex)

612

613

  // To enforce the limit on cached content viewers, we need to release all

614

  // of the content viewers that are no longer in the "window" that now

615

  // ends/begins at aToIndex.

616

617

  PRInt32 startIndex, endIndex;

618

  if (aToIndex > aFromIndex) { // going forward

619

    startIndex = PR_MAX(0, aFromIndex - gHistoryMaxViewers);

620

    endIndex = PR_MAX(0, aToIndex - gHistoryMaxViewers);

621

  } else { // going backward

622

    startIndex = PR_MIN(mLength - 1, aToIndex + gHistoryMaxViewers);

623

    endIndex = PR_MIN(mLength - 1, aFromIndex + gHistoryMaxViewers);

624

625

626

  nsCOMPtr<nsISHTransaction> trans;

627

  GetTransactionAtIndex(startIndex, getter_AddRefs(trans));

628

629

  for (PRInt32 i = startIndex; trans && i < endIndex; ++i) {

630

    nsCOMPtr<nsISHEntry> entry;

631

    trans->GetSHEntry(getter_AddRefs(entry));

632

    nsCOMPtr<nsIContentViewer> viewer;

633

    entry->GetContentViewer(getter_AddRefs(viewer));

634

    if (viewer) {

635

#ifdef DEBUG_PAGE_CACHE

636

      nsCOMPtr<nsIURI> uri;

637

      entry->GetURI(getter_AddRefs(uri));

638

      nsCAutoString spec;

639

      if (uri)

640

        uri->GetSpec(spec);

641

642

      printf("Evicting content viewer: %s\n", spec.get());

643

#endif

644

645

      viewer->Destroy();

646

      entry->SetContentViewer(nsnull);

647

      entry->SyncPresentationState();

648

649

650

    nsISHTransaction *temp = trans;

651

    temp->GetNext(getter_AddRefs(trans));

652

653

654

586

NS_IMETHODIMP

655

NS_IMETHODIMP

587

nsSHistory::UpdateIndex()

656

nsSHistory::UpdateIndex()

588

657

589

  // Update the actual index with the right value.

658

  // Update the actual index with the right value.

590

  if (mIndex != mRequestedIndex && mRequestedIndex != -1)

659

  if (mIndex != mRequestedIndex && mRequestedIndex != -1) {

660

    // We've just finished a history navigation (back or forward), so enforce

661

    // the max number of content viewers.

662

663

    EvictContentViewers(mIndex, mRequestedIndex);

591

    mIndex = mRequestedIndex;

664

    mIndex = mRequestedIndex;

665

666

592

  return NS_OK;

667

  return NS_OK;

593

668

594

669

(-)xpfe/components/shistory/src/nsSHistory.h (+2 lines)

Line	Link Here

Lines 85-90 protected:	Link Here

   nsresult PrintHistory();

   nsresult PrintHistory();

#endif

#endif

  void EvictContentViewers(PRInt32 aFromIndex, PRInt32 aToIndex);

protected:

protected:

  nsCOMPtr<nsISHTransaction> mListRoot;

  nsCOMPtr<nsISHTransaction> mListRoot;

  PRInt32 mIndex;

  PRInt32 mIndex;

(-)xpfe/global/resources/content/bindings/browser.xml (-5 / +5 lines)

Line	Link Here

Lines 305-313	Link Here

305

        null

305

        null

306

      </field>

306

      </field>

307

308

      <field name="securityUI">

308

      <property name="securityUI"

309

        null

309

                onget="return this.docShell.securityUI;"

310

      </field>

310

                onset="this.docShell.securityUI = val;"/>

311

312

      <field name="userTypedClear">

312

      <field name="userTypedClear">

313

Lines 356-363	Link Here

356

            const SECUREBROWSERUI_CONTRACTID = "@mozilla.org/secure_browser_ui;1";

356

            const SECUREBROWSERUI_CONTRACTID = "@mozilla.org/secure_browser_ui;1";

357

            if (!this.hasAttribute("disablesecurity") &&

357

            if (!this.hasAttribute("disablesecurity") &&

358

                SECUREBROWSERUI_CONTRACTID in Components.classes) {

358

                SECUREBROWSERUI_CONTRACTID in Components.classes) {

359

              this.securityUI = Components.classes[SECUREBROWSERUI_CONTRACTID].createInstance(Components.interfaces.nsISecureBrowserUI);

359

              var securityUI = Components.classes[SECUREBROWSERUI_CONTRACTID].createInstance(Components.interfaces.nsISecureBrowserUI);

360

              this.securityUI.init(this.contentWindow);

360

              securityUI.init(this.contentWindow);

361

362

363

          catch (e) {

363

          catch (e) {

Return to bug 274784