Attachment #182197 for bug #274784

Attachment #182197: pref'd off patch, with some review comments addressed 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





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 

    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 there are any requests in our loadgroup or the loadgroups
   * of any child documents, recursively.  aIgnoreRequest may be set to a
   * specific request to ignore (it can be null).
   */
  virtual PRBool HasRequests(nsIRequest *aIgnoreRequest) = 0;

  /**
   * Notify the document that its associated ContentViewer is being destroyed.
   * This releases circular references so that the document can go away.
   */
  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 4602-4604
      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 = PR_TRUE;
+  if (subdoc)
+    next = args->callback(subdoc, args->data);
+  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)
+SubDocHasRequests(PLDHashTable *table, PLDHashEntryHdr *hdr,
+                  PRUint32 number, void *arg)
+{
+  SubDocMapEntry *entry = NS_STATIC_CAST(SubDocMapEntry*, hdr);
+  PRBool *hasRequests = 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 hasRequest = subdoc ? subdoc->HasRequests(nsnull) : PR_FALSE;
+  if (hasRequest) {
+    *hasRequests = PR_TRUE;
+    return PL_DHASH_STOP;
+  }
+  return PL_DHASH_NEXT;
+}
+#ifdef DEBUG_bryner
+#define DEBUG_PAGE_CACHE
+#endif
+PRBool
+nsDocument::HasRequests(nsIRequest *aIgnoreRequest)
+{
+  nsCOMPtr<nsILoadGroup> loadGroup = GetDocumentLoadGroup();
+  if (loadGroup) {
+    nsCOMPtr<nsISimpleEnumerator> requests;
+    loadGroup->GetRequests(getter_AddRefs(requests));
+    PRBool hasMore = PR_FALSE;
+    nsCOMPtr<nsISupports> elem;
+    nsCOMPtr<nsIRequest> request;
+    while (NS_SUCCEEDED(requests->HasMoreElements(&hasMore)) && hasMore) {
+      requests->GetNext(getter_AddRefs(elem));
+      request = do_QueryInterface(elem);
+      if (request && request != aIgnoreRequest) {
+#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_TRUE;
+      }
+    }
+  }
+  PRBool subDocsHaveRequests = PR_FALSE;
+  if (mSubDocuments) {
+    PL_DHashTableEnumerate(mSubDocuments, SubDocHasRequests,
+                           &subDocsHaveRequests);
+  }
+  return subDocsHaveRequests;
+}
+void
+nsDocument::Destroy()
+{
+  // 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.
+  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();
+  }
+}





  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) HasRequests(nsIRequest *aIgnoreRequest);

  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.





    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 {


  NS_IMETHOD SetListenerTarget(nsISupports* aTarget) = 0;

  /**
  * Allows us to quickly determine whether we have mutation listeners
  * registered.
  */
  NS_IMETHOD HasMutationListeners(PRBool* aListener) = 0;


  * 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 890-895 nsEventListenerManager::GetIdentifiersFo	Link Here

890

    *aArrayType = eEventArrayType_Load;

891

    *aArrayType = eEventArrayType_Load;

891

    *aFlags = NS_EVENT_BITS_LOAD_ERROR;

892

    *aFlags = NS_EVENT_BITS_LOAD_ERROR;

892

893

894

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

895

    *aArrayType = eEventArrayType_Load;

896

    *aFlags = NS_EVENT_BITS_LOAD_PAGE_RESTORE;

897

893

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

898

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

894

    *aArrayType = eEventArrayType_Paint;

899

    *aArrayType = eEventArrayType_Paint;

895

    *aFlags = NS_EVENT_BITS_PAINT_PAINT;

900

    *aFlags = NS_EVENT_BITS_PAINT_PAINT;

Lines 2231-2236 nsEventListenerManager::GetCoordinatesFo	Link Here

2231

2236

2232

2237

2233

2238

2239

PRBool

2240

nsEventListenerManager::HasUnloadListeners()

2241

2242

  nsVoidArray *listeners = GetListenersByType(eEventArrayType_Load, nsnull,

2243

                                              PR_FALSE);

2244

  if (listeners) {

2245

    PRInt32 count = listeners->Count();

2246

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

2247

      PRUint32 subtype = NS_STATIC_CAST(nsListenerStruct*,

2248

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

2249

      if (subtype == NS_EVENT_BITS_NONE ||

2250

          subtype & (NS_EVENT_BITS_LOAD_UNLOAD |

2251

                     NS_EVENT_BITS_LOAD_BEFORE_UNLOAD))

2252

        return PR_TRUE;

2253

2254

2255

2256

  return PR_FALSE;

2257

2258

2234

nsresult

2259

nsresult

2235

NS_NewEventListenerManager(nsIEventListenerManager** aInstancePtrResult)

2260

NS_NewEventListenerManager(nsIEventListenerManager** aInstancePtrResult)

2236

2261

(-)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()!

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

Line	Link Here

Lines 291-297 nsXBLPrototypeHandler::ExecuteHandler(ns	Link Here

291

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

291

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

292

293

294

      focusController = privateWindow->GetRootFocusController();

294

      if (privateWindow)

295

        focusController = privateWindow->GetRootFocusController();

295

296

297

    NS_LossyConvertUCS2toASCII command(mHandlerText);

298

    NS_LossyConvertUCS2toASCII command(mHandlerText);

(-)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"
+#include "nsIDOMEventReceiver.h"
+#include "nsIEventListenerManager.h"
+#include "nsIPluginDocument.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 4311-4317
      nsDocShell::CancelRefreshURITimers()
+  Link Here
     return NS_OK;
+}
+void
+nsDocShell::SuspendRefreshURIs()
+{
+    if (!mRefreshURIList)
+        return;
+    PRUint32 n = 0;
+    mRefreshURIList->Count(&n);
+    nsCOMPtr<nsITimer> timer;
+    nsCOMPtr<nsITimerCallback> callback;
+    nsCOMPtr<nsRefreshTimer> rt;
+    for (PRUint32 i = 0;  i < n; ++i) {
+        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);
+    }
+}
+nsresult
 nsDocShell::RefreshURIFromQueue()
+{
     if (!mRefreshURIList)
-       Lines 4697-4702
      nsDocShell::CreateAboutBlankContentViewe
+  Link Here
   return rv;
+}
+PRBool
+nsDocShell::CanSavePresentation(nsIRequest *aNewRequest)
+{
+    // If max_viewers is set to 0, don't ever try to save the presentation.
+    // This check should be removed once we've established that the
+    // immediate-evict case works correctly (see bug 274784).
+    PRInt32 maxViewers = 0;
+    mPrefs->GetIntPref("browser.sessionhistory.max_viewers", &maxViewers);
+    if (maxViewers == 0)
+        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;
+    // If there are any active requests in the document load group, don't cache
+    // the document.  Ideally we would instead suspend these requests and
+    // resume them when restoring the presentation, but that is potentially
+    // difficult (e.g. XMLHttpRequest).
+    nsCOMPtr<nsIDocument> doc = do_QueryInterface(pWin->GetExtantDocument());
+    if (doc && doc->HasRequests(aNewRequest))
+        return PR_FALSE;
+    // Don't save plugin documents; we have no easy way of retrieving the
+    // plugin data after it is loaded.
+    nsCOMPtr<nsIPluginDocument> pluginDoc = do_QueryInterface(doc);
+    if (pluginDoc)
+        return PR_FALSE;
+    // Only save presentation for "normal" loads and link loads.  Anything else
+    // probably wants to refetch the page, so caching the old presentation
+    // would be incorrect.
+    if (mLoadType != LOAD_NORMAL &&
+        mLoadType != LOAD_HISTORY &&
+        mLoadType != LOAD_LINK)
+        return PR_FALSE;
+    // If there is an unload or beforeunload listener on the window, then we do
+    // not save the presentation into the session history cache.
+    nsCOMPtr<nsIDOMEventReceiver> er = do_QueryInterface(mScriptGlobal);
+    if (er) {
+        nsCOMPtr<nsIEventListenerManager> eventManager;
+        er->GetListenerManager(getter_AddRefs(eventManager));
+        if (eventManager && eventManager->HasUnloadListeners())
+            return PR_FALSE;
+    }
+    // If the session history entry has the saveLayoutState flag set to false,
+    // then we should not cache the presentation.
+    if (!mOSHE)
+        return PR_FALSE; // no entry to save into
+    PRBool canSaveState;
+    mOSHE->GetSaveLayoutStateFlag(&canSaveState);
+    return canSaveState;
+}
+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.
+    PRInt32 childCount = mChildList.Count();
+    nsCOMPtr<nsIDocShellTreeItem> childShell;
+    mOSHE->ClearChildShells();
+    for (PRInt32 i = 0; i < childCount; ++i) {
+        childShell = do_QueryInterface(ChildAt(i));
+        NS_ASSERTION(childShell, "null child shell");
+        mOSHE->AddChildShell(childShell);
+    }
+    // Capture the security state.
+    nsCOMPtr<nsISecureBrowserUIState> securityState;
+    if (mSecurityUI)
+        mSecurityUI->CaptureState(getter_AddRefs(securityState));
+    return mOSHE->SetSecurityState(securityState);
+}
+nsresult
+nsDocShell::RestorePresentation(nsISHEntry *aSHEntry, PRBool aSavePresentation)
+{
+    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
+    if (!viewer) {
+#ifdef DEBUG_PAGE_CACHE
+        printf("no saved presentation for uri: %s\n", spec.get());
+#endif
+        return NS_ERROR_NOT_AVAILABLE;
+    }
+    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 automatically
+    // sets itself as sticky in Destroy() to avoid teardown.
+    PRBool sticky;
+    aSHEntry->GetSticky(&sticky);
+    mContentViewer->SetSticky(sticky);
+    // save 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");
+            shell->InvalidateViewManagers();
+        }
+    }
+    // restore the state of the window object
+    nsCOMPtr<nsPIDOMWindow> privWin =
+        do_GetInterface(NS_STATIC_CAST(nsIInterfaceRequestor*, this));
+    NS_ASSERTION(privWin, "could not get nsPIDOMWindow interface");
+    nsCOMPtr<nsISupports> windowState;
+    aSHEntry->GetWindowState(getter_AddRefs(windowState));
+    rv = privWin->RestoreWindowState(windowState);
+    NS_ENSURE_SUCCESS(rv, rv);
+    aSHEntry->SetWindowState(nsnull);
+    // Restore the refresh URI list.
+    aSHEntry->GetRefreshURIList(getter_AddRefs(mRefreshURIList));
+    aSHEntry->SetRefreshURIList(nsnull);
+    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);
+    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<nsISecureBrowserUIState> securityState;
+        aSHEntry->GetSecurityState(getter_AddRefs(securityState));
+        if (securityState)
+            mSecurityUI->TransitionToState(securityState);
+    }
+    SetCurrentURI(uri);
+    // 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.
+    if (shell) {
+        nsEvent event(PR_TRUE, NS_PAGE_LOAD);
+        nsEventStatus status = nsEventStatus_eIgnore;
+        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();
+        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);
+        mScriptGlobal->HandleDOMEvent(pc, &restoreEvent, nsnull,
+                                      NS_EVENT_FLAG_INIT, &status);
+    }
+    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?
+    return mParentWidget->Invalidate(PR_FALSE);
+}
 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;
+        // XXX this isn't really fatal, necessarily...
+        // should we try to fire unload if NS_FAILED(rv) ?
+    }
     // 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.
+    PRBool savePresentation =
+        aSHEntry ? CanSavePresentation(nsnull) : PR_FALSE;
     // 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)
+            FireUnloadNotification();
+        mFiredUnloadEvent = PR_FALSE;
+        if (savePresentation)
+            rv = CaptureState();
+        rv = RestorePresentation(aSHEntry, savePresentation &&
+                                 NS_SUCCEEDED(rv));
+        if (NS_SUCCEEDED(rv))
+            return rv;
+    }
     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();
    void       SuspendRefreshURIs();
    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.
    nsresult RestorePresentation(nsISHEntry *aSHEntry,
                                 PRBool aSavePresentation);

    // Disable the caret in |aRoot| and all children.
    static void DisableCaret(nsIDocShellTreeItem *aRoot);

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);
};

(-)docshell/base/nsIDocShell.idl (+7 lines)

Line	Link Here

Lines 64-69 interface nsIInputStream;	Link Here

interface nsIRequest;

interface nsIRequest;

interface nsISHEntry;

interface nsISHEntry;

interface nsILayoutHistoryState;

interface nsILayoutHistoryState;

interface nsISecureBrowserUI;

[scriptable, uuid(BBFDF99E-D675-42FD-B3EA-EA341C2331A6)]

[scriptable, uuid(BBFDF99E-D675-42FD-B3EA-EA341C2331A6)]

interface nsIDocShell : nsISupports

interface nsIDocShell : nsISupports

Lines 340-344 interface nsIDocShell : nsISupports	Link Here

340

  attribute nsILayoutHistoryState layoutHistoryState;

341

  attribute nsILayoutHistoryState layoutHistoryState;

341

342

  readonly attribute boolean shouldSaveLayoutState;

343

  readonly attribute boolean shouldSaveLayoutState;

344

345

/**

346

   * The SecureBrowserUI object for this docshell.  This is set by XUL

347

   * <browser> or nsWebBrowser for their root docshell.

348

*/

349

  attribute nsISecureBrowserUI securityUI;

343

};

350

};

344

351

(-)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 "nsIDOMNSHTMLElement.h"
+#include "nsIDOMXULElement.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 4292-4301
      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 5788-5793
      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), mSavedTimeouts(nsnull)
+{
+  NS_ASSERTION(aWindow, "null window");
+  aWindow->GetListenerManager(getter_AddRefs(mListenerManager));
+  nsIFocusController *fc = aWindow->GetRootFocusController();
+  NS_ASSERTION(fc, "null focus controller");
+  // We want to save the focused element/window only if they are inside of
+  // this window.
+  nsCOMPtr<nsIDOMWindowInternal> focusWinInternal;
+  fc->GetFocusedWindow(getter_AddRefs(focusWinInternal));
+  nsPIDOMWindow *focusedWindow =
+    NS_STATIC_CAST(nsPIDOMWindow*,
+                   NS_STATIC_CAST(nsGlobalWindow*,
+                                  NS_STATIC_CAST(nsIDOMWindowInternal*,
+                                                 focusWinInternal)));
+  while (focusedWindow) {
+    if (focusedWindow == aWindow) {
+      fc->GetFocusedWindow(getter_AddRefs(mFocusedWindow));
+      fc->GetFocusedElement(getter_AddRefs(mFocusedElement));
+      break;
+    }
+    focusedWindow =
+      NS_STATIC_CAST(nsGlobalWindow*, focusedWindow)->GetPrivateParent();
+  }
+  aWindow->SuspendTimeouts();
+  // Clear the timeout list for aWindow (but we don't need to for children)
+  mSavedTimeouts = aWindow->mTimeouts;
+  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;
+  jsint i;
+  for (i = 0; i < length; ++i) {
+    jsval propname_value;
+    if (!::JS_IdToValue(cx, props->vector[i], &propname_value) ||
+        !JSVAL_IS_STRING(propname_value)) {
+      NS_WARNING("Failed to copy non-string-named window property\n");
+      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);
+    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);
+    // We may hit an exception trying to retrieve the property value, so
+    // save off the exception state and ignore any exceptions we hit.
+    JSExceptionState *state = ::JS_SaveExceptionState(cx);
+    NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
+    jsval propvalue;
+    if (!::JS_GetUCProperty(cx, aSource, propname_str,
+                            propname_len, &propvalue)) {
+      // An exception was hit, so just define this value with a void value.
+      // This can happen if there was a native getter.
+      propvalue = JSVAL_VOID;
+    }
+    ::JS_RestoreExceptionState(cx, state);
+    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 will remove the
+  // XPConnect properties.
+  nsCOMPtr<WindowStateHolder> holder = do_QueryInterface(aState);
+  if (holder) {
+#ifdef DEBUG_PAGE_CACHE
+    printf("restoring window state, stateObj = %p\n", holder->GetObject());
+#endif
+    nsresult rv = CopyJSProperties(cx, holder->GetObject(), mJSObject);
+    NS_ENSURE_SUCCESS(rv, rv);
+    mListenerManager = holder->GetListenerManager();
+    nsIDOMElement *focusedElement = holder->GetFocusedElement();
+    if (focusedElement) {
+      nsCOMPtr<nsIDOMNSHTMLElement> htmlElement =
+        do_QueryInterface(focusedElement);
+      if (htmlElement) {
+        htmlElement->Focus();
+      } else {
+        nsCOMPtr<nsIDOMXULElement> xulElement =
+          do_QueryInterface(focusedElement);
+        if (xulElement) {
+          xulElement->Focus();
+        }
+      }
+    } else {
+      nsIDOMWindowInternal *focusedWindow = holder->GetFocusedWindow();
+      if (focusedWindow) {
+        focusedWindow->Focus();
+      }
+    }
+  }
+  mTimeouts = holder->GetSavedTimeouts();
+  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()
+{
+  PRInt64 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(0, t->mWhen - now);
+    // Drop the XPCOM timer; we'll reschedule when restoring the state.
+    if (t->mTimer) {
+      t->mTimer->Cancel();
+      t->mTimer = nsnull;
+    }
+    // We don't Release() the timeout because we still need it.
+  }
+  // Suspend our children as well.
+  nsCOMPtr<nsIDocShellTreeNode> node = do_QueryInterface(mDocShell);
+  if (node) {
+    PRInt32 childCount = 0;
+    node->GetChildCount(&childCount);
+    nsCOMPtr<nsIDocShellTreeItem> childShell;
+    for (PRInt32 i = 0; i < childCount; ++i) {
+      node->GetChildAt(i, getter_AddRefs(childShell));
+      NS_ASSERTION(childShell, "null child shell");
+      nsCOMPtr<nsPIDOMWindow> pWin = do_GetInterface(childShell);
+      if (pWin) {
+        nsGlobalWindow *win =
+          NS_STATIC_CAST(nsGlobalWindow*,
+                         NS_STATIC_CAST(nsPIDOMWindow*, pWin));
+        win->SuspendTimeouts();
+      }
+    }
+  }
+}
+nsresult
+nsGlobalWindow::ResumeTimeouts()
+{
+  // Restore all of the timeouts, using the stored time remaining.
+  PRInt64 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;
+    t->mTimer = do_CreateInstance("@mozilla.org/timer;1");
+    NS_ENSURE_TRUE(t->mTimer, NS_ERROR_OUT_OF_MEMORY);
+    rv = t->mTimer->InitWithFuncCallback(TimerCallback, t, interval,
+                                         nsITimer::TYPE_ONE_SHOT);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  // Resume our children as well.
+  nsCOMPtr<nsIDocShellTreeNode> node = do_QueryInterface(mDocShell);
+  if (node) {
+    PRInt32 childCount = 0;
+    node->GetChildCount(&childCount);
+    nsCOMPtr<nsIDocShellTreeItem> childShell;
+    for (PRInt32 i = 0; i < childCount; ++i) {
+      node->GetChildAt(i, getter_AddRefs(childShell));
+      NS_ASSERTION(childShell, "null child shell");
+      nsCOMPtr<nsPIDOMWindow> pWin = do_GetInterface(childShell);
+      if (pWin) {
+        nsGlobalWindow *win =
+          NS_STATIC_CAST(nsGlobalWindow*,
+                         NS_STATIC_CAST(nsPIDOMWindow*, pWin));
+        rv = win->ResumeTimeouts();
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+    }
+  }
+  return NS_OK;
+}
 // QueryInterface implementation for nsGlobalChromeWindow
 NS_INTERFACE_MAP_BEGIN(nsGlobalChromeWindow)
   NS_INTERFACE_MAP_ENTRY(nsIDOMChromeWindow)

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

Line	Link Here

Lines 204-210 public:	Link Here

204

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

204

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

205

206

  virtual NS_HIDDEN_(void) ClearAllTimeouts();

206

  virtual NS_HIDDEN_(void) ClearAllTimeouts();

207

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

208

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

209

  virtual NS_HIDDEN_(void) SuspendTimeouts();

210

  virtual NS_HIDDEN_(nsresult) ResumeTimeouts();

211

208

  // nsIDOMViewCSS

212

  // nsIDOMViewCSS

209

  NS_DECL_NSIDOMVIEWCSS

213

  NS_DECL_NSIDOMVIEWCSS

210

214

Lines 220-225 public:	Link Here

220

  static void ShutDown();

224

  static void ShutDown();

221

  static PRBool IsCallerChrome();

225

  static PRBool IsCallerChrome();

222

226

227

  friend class WindowStateHolder;

228

223

protected:

229

protected:

224

  // Object Management

230

  // Object Management

225

  virtual ~nsGlobalWindow();

231

  virtual ~nsGlobalWindow();





    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 1738-1743 nsXMLHttpRequest::Error(nsIDOMEvent* aEv	Link Here

1738

  return NS_OK;

1738

  return NS_OK;

1739

1740

1741

NS_IMETHODIMP

1742

nsXMLHttpRequest::PageRestore(nsIDOMEvent* aEvent)

1743

1744

  return NS_OK;

1745

1746

1741

nsresult

1747

nsresult

1742

nsXMLHttpRequest::ChangeState(PRUint32 aState, PRBool aBroadcast,

1748

nsXMLHttpRequest::ChangeState(PRUint32 aState, PRBool aBroadcast,

1743

                              PRBool aClearEventListeners)

1749

                              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"

//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);

  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 {
    // out of band cleanup of webshell
      mDocument->SetScriptGlobalObject(nsnull);
    }
#else
    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.
  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);
            }
          }
        }
      }

      mPresShell->InvalidateViewManagers();
    }

    mSHEntry = nsnull;

    Hide();

    // This is after Hide() so that the user doesn't see the inputs clear.
    if (mDocument)
      mDocument->Sanitize();

    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) {
    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

  virtual void ListStyleSheets(FILE *out, PRInt32 aIndent = 0) = 0;
#endif

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

  /**
   * Restarts active elements (plugins) in this presentation.
   */
  virtual void Thaw() = 0;

  /**
   * Call InvalidateHierarchy() on our view manager and the view manager
   * of any child documents, recursively.
   */
  virtual void InvalidateViewManagers() = 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"
+#include "nsIDocShellTreeNode.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();
+  virtual void InvalidateViewManagers();
 #ifdef IBMBIDI
   NS_IMETHOD SetCaretBidiLevel(PRUint8 aLevel);
-       Lines 1391-1396
      protected:
+  Link Here
   nsresult GetSelectionForCopy(nsISelection** outSelection);
+  void HideCaret();
   nsICSSStyleSheet*         mPrefStyleSheet; // mStyleSet owns it but we maintain a ref, may be null
 #ifdef DEBUG
   PRUint32                  mUpdateCount;
-       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 6470-6475
      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);
+}
+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);
+  }
+  HideCaret();
+}
+static void
+StartPluginInstance(PresShell *aShell, nsIContent *aContent)
+{
+  // For now we just reconstruct the frame.
+  aShell->RecreateFramesFor(aContent);
+}
+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);
+  }
+}
+void
+PresShell::HideCaret()
+{
+  if (mCaret)
+    mCaret->SetCaretVisible(PR_FALSE);
+  if (!mPresContext)
+    return;
+  nsCOMPtr<nsISupports> container = mPresContext->GetContainer();
+  nsCOMPtr<nsIDocShellTreeNode> shell = do_QueryInterface(container);
+  if (!shell)
+    return;
+  PRInt32 childCount = 0;
+  shell->GetChildCount(&childCount);
+  nsCOMPtr<nsIDocShellTreeItem> child;
+  nsCOMPtr<nsIPresShell> childShell;
+  for (PRInt32 i = 0; i < childCount; ++i) {
+    shell->GetChildAt(i, getter_AddRefs(child));
+    childShell = do_GetInterface(child);
+    if (childShell)
+      NS_STATIC_CAST(PresShell*,
+                     NS_STATIC_CAST(nsIPresShell*, childShell))->HideCaret();
+  }
+}
+static PRBool
+InvalidateVMCallback(nsIDocument *aDocument, void *aData)
+{
+  NS_ASSERTION(aDocument, "null document passed to callback");
+  nsIPresShell *shell = aDocument->GetShellAt(0);
+  if (shell)
+    shell->InvalidateViewManagers();
+  return PR_TRUE;
+}
+void
+PresShell::InvalidateViewManagers()
+{
+  if (mViewManager)
+    mViewManager->InvalidateHierarchy();
+  // Get the list of child documents.
+  if (mDocument)
+    mDocument->EnumerateSubDocuments(InvalidateVMCallback, nsnull);
+}
 //--------------------------------------------------------
 // Start of protected and private methods on the PresShell
 //--------------------------------------------------------
-       Lines 7038-7043
      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);
+  nsCOMPtr<nsIDOMNode> node;
+  nsCOMPtr<nsIContent> content;
+  //  nsFrameManager *fm = FrameManager();
+  for (PRUint32 i = 0; i < length; ++i) {
+    nodes->Item(i, getter_AddRefs(node));
+    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 nsIWebProgress;
interface nsIURI;

[uuid(625481c5-b2dc-11d9-bc8f-00112478d626)]
interface nsISecureBrowserUIState : nsISupports
{
};

[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. */
    nsISecureBrowserUIState captureState();

    /**
     * Restore the state captured by captureState(), firing transition
     * notifications as necessary.
     */
    void transitionToState(in nsISecureBrowserUIState 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;
}

class nsSecureBrowserUIImpl::State : public nsISecureBrowserUIState
{
public:
  State(lockIconState aState, nsISupports *aSSLStatus);

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

  NS_DECL_ISUPPORTS
  NS_DECL_NSISECUREBROWSERUISTATE

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

NS_IMPL_ISUPPORTS1(nsSecureBrowserUIImpl::State, nsISecureBrowserUIState)

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

NS_IMETHODIMP
nsSecureBrowserUIImpl::CaptureState(nsISecureBrowserUIState **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(nsISecureBrowserUIState *aState)
{
  NS_ENSURE_TRUE(aState, NS_ERROR_NULL_POINTER);

  State *state = NS_STATIC_CAST(State*, aState);

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

(-)security/manager/boot/src/nsSecureBrowserUIImpl.h (+5 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 143-148 protected:	Link Here

143

  // Support functions

144

  // Support functions

144

  nsresult GetNSSDialogs(nsISecurityWarningDialogs **);

145

  nsresult GetNSSDialogs(nsISecurityWarningDialogs **);

145

146

147

  class State;

148

  nsresult HandleStateChange(PRBool aIsToplevel, nsIURI *aURI,

149

                             PRUint32 aLoadFlags, PRUint32 aProgressStateFlgs);

150

146

  PLDHashTable mTransferringRequests;

151

  PLDHashTable mTransferringRequests;

147

};

152

};

148

153

(-)toolkit/components/passwordmgr/base/nsPasswordManager.cpp (-5 / +76 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"

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

265

264

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

266

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

265

267

268

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

269

  // event listener.

270

271

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

272

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

273

274

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

275

  // get notifications for those.

276

277

  nsCOMPtr<nsIWindowWatcher> watcher =

278

    do_GetService(NS_WINDOWWATCHER_CONTRACTID);

279

  if (watcher) {

280

    nsCOMPtr<nsISimpleEnumerator> enumerator;

281

    watcher->GetWindowEnumerator(getter_AddRefs(enumerator));

282

    if (enumerator) {

283

      PRBool hasMore;

284

      nsCOMPtr<nsISupports> item;

285

      nsCOMPtr<nsIDOMEventTarget> targ;

286

287

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

288

        enumerator->GetNext(getter_AddRefs(item));

289

        targ = do_QueryInterface(item);

290

        if (targ) {

291

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

292

                                 NS_STATIC_CAST(nsIDOMLoadListener*, this),

293

                                 PR_FALSE);

294

295

296

297

298

266

  // Now read in the signon file

299

  // Now read in the signon file

267

  nsXPIDLCString signonFile;

300

  nsXPIDLCString signonFile;

268

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

301

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

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

747

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

780

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

748

781

749

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

782

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

783

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

784

    nsCOMPtr<nsIDOMEventTarget> targ = do_QueryInterface(aSubject);

785

    if (targ) {

786

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

787

                             NS_STATIC_CAST(nsIDOMLoadListener*, this),

788

                             PR_FALSE);

789

790

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

791

    nsCOMPtr<nsIDOMEventTarget> targ = do_QueryInterface(aSubject);

792

    if (targ) {

793

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

794

                                NS_STATIC_CAST(nsIDOMLoadListener*, this),

795

                                PR_FALSE);

796

750

797

751

798

752

  return NS_OK;

799

  return NS_OK;

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

765

      !(aStateFlags & nsIWebProgressListener::STATE_STOP))

812

      !(aStateFlags & nsIWebProgressListener::STATE_STOP))

766

    return NS_OK;

813

    return NS_OK;

767

814

768

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

769

  if (!SingleSignonEnabled())

770

    return NS_OK;

771

772

  nsCOMPtr<nsIDOMWindow> domWin;

815

  nsCOMPtr<nsIDOMWindow> domWin;

773

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

816

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

774

  NS_ENSURE_SUCCESS(rv, rv);

817

  NS_ENSURE_SUCCESS(rv, rv);

775

818

819

  return DoPrefill(domWin);

820

821

822

nsresult

823

nsPasswordManager::DoPrefill(nsIDOMWindow *aDOMWindow)

824

825

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

826

  if (!SingleSignonEnabled())

827

    return NS_OK;

828

776

  nsCOMPtr<nsIDOMDocument> domDoc;

829

  nsCOMPtr<nsIDOMDocument> domDoc;

777

  domWin->GetDocument(getter_AddRefs(domDoc));

830

  aDOMWindow->GetDocument(getter_AddRefs(domDoc));

778

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

831

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

779

832

780

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

833

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

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

1568

  return NS_OK;

1621

  return NS_OK;

1569

1622

1570

1623

1624

NS_IMETHODIMP

1625

nsPasswordManager::PageRestore(nsIDOMEvent* aEvent)

1626

1627

  nsCOMPtr<nsIDOMEventTarget> target;

1628

  aEvent->GetTarget(getter_AddRefs(target));

1629

1630

  nsCOMPtr<nsIDocument> doc = do_QueryInterface(target);

1631

  if (doc) {

1632

    nsCOMPtr<nsIDOMWindow> win =

1633

      do_QueryInterface(doc->GetScriptGlobalObject());

1634

    if (win) {

1635

      return DoPrefill(win);

1636

1637

1638

1639

  return NS_OK;

1640

1641

1571

1642

1572

// internal methods

1643

// internal methods

1573

1644

(-)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/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/public/nsIViewManager.h (-2 / +8 lines)

Line	Link Here

Lines 62-69 enum nsRectVisibility {	Link Here

#define NS_IVIEWMANAGER_IID   \

#define NS_IVIEWMANAGER_IID   \

{ 0xd9af8f22, 0xc64d, 0x4036, \

{ 0x5a381922, 0xb397, 0x11d9, \

  { 0x9e, 0x8b, 0x69, 0x5a, 0x63, 0x69, 0x3f, 0xd3 } }

  { 0x8f, 0x7c, 0x00, 0x11, 0x24, 0x78, 0xd6, 0x26 } }

class nsIViewManager : public nsISupports

class nsIViewManager : public nsISupports

Lines 566-571 public:	Link Here

566

   * (aFromScroll is false) or scrolled (aFromScroll is true).

566

   * (aFromScroll is false) or scrolled (aFromScroll is true).

567

*/

567

*/

568

  NS_IMETHOD SynthesizeMouseMove(PRBool aFromScroll)=0;

568

  NS_IMETHOD SynthesizeMouseMove(PRBool aFromScroll)=0;

569

570

/**

571

   * Force any cached information about the view hierarchy (such as the root

572

   * view manager) to be recomputed.  Note that this is non-recursive.

573

*/

574

  NS_IMETHOD InvalidateHierarchy()=0;

569

};

575

};

570

576

571

// Paint timing mode flags

577

// Paint timing mode flags

-      Line
+  Link Here
-       Lines 4440-4442
      nsViewManager::ProcessSynthMouseMoveEven
+  Link Here
   if (!aFromScroll)
     mSynthMouseMoveEventQueue = nsnull;
+}
+NS_IMETHODIMP
+nsViewManager::InvalidateHierarchy()
+{
+  if (mRootView) {
+    if (mRootViewManager != this) {
+      NS_IF_RELEASE(mRootViewManager);
+    }
+    nsView *parent = mRootView->GetParent();
+    if (parent) {
+      mRootViewManager = parent->GetViewManager()->RootViewManager();
+      NS_ADDREF(mRootViewManager);
+    } else {
+      mRootViewManager = this;
+    }
+  }
+  return NS_OK;
+}

(-)view/src/nsViewManager.h (+2 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

  NS_IMETHOD InvalidateHierarchy();

271

270

protected:

272

protected:

271

  virtual ~nsViewManager();

273

  virtual ~nsViewManager();

272

274

(-)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 / +110 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

*/

*/

    void addChildShell(in nsIDocShellTreeItem shell);

attribute unsigned long ID;

    nsIDocShellTreeItem childShellAt(in long index);

    void clearChildShells();

/**

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

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

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

    attribute nsISecureBrowserUIState securityState;

 * 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

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

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

100

    attribute nsISupportsArray refreshURIList;

 * frame).

101

*/

102

    /** Title for the document */

attribute unsigned long pageIdentifier;

103

    void setTitle(in AString aTitle);

104

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

105

    /** Post Data for the document */

100

attribute nsISupports cacheKey;

106

    attribute nsIInputStream postData;

101

107

102

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

108

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

103

attribute boolean saveLayoutStateFlag;

109

    attribute nsILayoutHistoryState layoutHistoryState;

104

110

105

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

111

    /** parent of this entry */

106

attribute boolean expirationStatus;

112

    attribute nsISHEntry parent;

107

113

108

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

114

/**

109

    is a session history entry for */

115

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

110

attribute ACString contentType;

116

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

117

*/

118

    attribute unsigned long loadType;

119

120

/**

121

     * An ID to help identify this entry from others during

122

     * subframe navigation

123

*/

124

    attribute unsigned long ID;

125

126

/**

127

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

128

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

129

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

130

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

131

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

132

     * some other frame).

133

*/

134

    attribute unsigned long pageIdentifier;

135

136

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

137

    attribute nsISupports cacheKey;

138

139

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

140

    attribute boolean saveLayoutStateFlag;

141

142

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

143

    attribute boolean expirationStatus;

144

145

/**

146

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

147

     * is a session history entry for

148

*/

149

    attribute ACString contentType;

111

150

112

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

151

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

113

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

152

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

114

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

153

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

115

154

116

/** Additional ways to create an entry */

155

    /** Additional ways to create an entry */

117

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

156

    void create(in nsIURI URI, in AString title,

118

            in nsIInputStream aInputStream, in nsILayoutHistoryState aHistoryLayoutState,

157

                in nsIInputStream inputStream,

119

            in nsISupports aCacheKey, in ACString aContentType);

158

                in nsILayoutHistoryState layoutHistoryState,

120

159

                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

160

161

    nsISHEntry clone();

126

162

163

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

164

    void setIsSubFrame(in boolean aFlag);

127

};

165

};

128

166

129

167

(-)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_brymer
#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(other.mSticky)
  // XXX why not copy mContentType?
  , mCacheKey(other.mCacheKey)
  , mParent(other.mParent)
  , mViewerBounds(other.mViewerBounds)
{
}

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(nsISecureBrowserUIState **aState)
{
  NS_IF_ADDREF(*aState = mSecurityState);
  return NS_OK;
}

NS_IMETHODIMP
nsSHEntry::SetSecurityState(nsISecureBrowserUIState *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;
}

(-)xpfe/components/shistory/src/nsSHEntry.h (-5 / +14 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 "nsISecureBrowserUI.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<nsISecureBrowserUIState> mSecurityState;

100

  nsCOMPtr<nsISupportsArray>      mRefreshURIList;

};

101

};

102

#endif /* nsSHEntry_h */

103

#endif /* nsSHEntry_h */

(-)xpfe/components/shistory/src/nsSHistory.cpp (-7 / +58 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 69-75 enum HistCmd{	Link Here

//***    nsSHistory: Object Management

//***    nsSHistory: Object Management

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

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

nsSHistory::nsSHistory() : mListRoot(nsnull), mIndex(-1), mLength(0), mRequestedIndex(-1)

nsSHistory::nsSHistory() : mListRoot(nsnull), mIndex(-1), mLength(0), mRequestedIndex(-1), mNumViewers(0)

Lines 104-113 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) {

107

    nsCOMPtr<nsIPrefBranch> defaultBranch;

112

    nsCOMPtr<nsIPrefBranch> branch = do_QueryInterface(prefs);

108

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

113

    if (branch) {

109

    if (defaultBranch) {

114

      branch->GetIntPref(PREF_SHISTORY_SIZE, &gHistoryMaxSize);

110

      defaultBranch->GetIntPref(PREF_SHISTORY_SIZE, &gHistoryMaxSize);

115

      branch->GetIntPref(PREF_SHISTORY_VIEWERS, &gHistoryMaxViewers);

111

116

112

117

113

  return NS_OK;

118

  return NS_OK;

Lines 171-177 nsSHistory::AddEntry(nsISHEntry * aSHEnt	Link Here

171

  //Purge History list if it is too long

176

  //Purge History list if it is too long

172

  if ((gHistoryMaxSize >= 0) && (mLength > gHistoryMaxSize))

177

  if ((gHistoryMaxSize >= 0) && (mLength > gHistoryMaxSize))

173

    PurgeHistory(mLength-gHistoryMaxSize);

178

    PurgeHistory(mLength-gHistoryMaxSize);

174

179

180

  // Evict content viewers if there are too many.

181

  EvictContentViewers(mIndex - 1, mIndex);

182

175

  return NS_OK;

183

  return NS_OK;

176

184

177

185

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

207

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

215

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

208

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

216

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

209

      if (aModifyIndex) {

217

      if (aModifyIndex) {

218

        EvictContentViewers(mIndex, aIndex);

210

        mIndex = aIndex;

219

        mIndex = aIndex;

211

220

212

    } //entry

221

    } //entry

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

583

	return LoadEntry(mIndex, loadType, HIST_CMD_RELOAD);

592

	return LoadEntry(mIndex, loadType, HIST_CMD_RELOAD);

584

593

585

594

595

void

596

nsSHistory::EvictContentViewers(PRInt32 aFromIndex, PRInt32 aToIndex)

597

598

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

599

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

600

  // ends/begins at aToIndex.

601

602

  PRInt32 startIndex, endIndex;

603

  if (aToIndex > aFromIndex) { // going forward

604

    startIndex = PR_MAX(0, aFromIndex - gHistoryMaxViewers);

605

    endIndex = aToIndex - gHistoryMaxViewers;

606

  } else { // going backward

607

    startIndex = aToIndex + gHistoryMaxViewers;

608

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

609

610

611

  nsCOMPtr<nsISHEntry> entry;

612

  nsCOMPtr<nsIContentViewer> viewer;

613

  nsISHTransaction *temp;

614

  nsCOMPtr<nsISHTransaction> trans;

615

  GetTransactionAtIndex(startIndex, getter_AddRefs(trans));

616

617

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

618

    trans->GetSHEntry(getter_AddRefs(entry));

619

    entry->GetContentViewer(getter_AddRefs(viewer));

620

    if (viewer) {

621

      viewer->Destroy();

622

      entry->SetContentViewer(nsnull);

623

624

625

    entry->SetWindowState(nsnull);

626

    temp = trans;

627

    temp->GetNext(getter_AddRefs(trans));

628

629

630

586

NS_IMETHODIMP

631

NS_IMETHODIMP

587

nsSHistory::UpdateIndex()

632

nsSHistory::UpdateIndex()

588

633

589

  // Update the actual index with the right value.

634

  // Update the actual index with the right value.

590

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

635

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

636

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

637

    // the max number of content viewers.

638

639

    EvictContentViewers(mIndex, mRequestedIndex);

591

    mIndex = mRequestedIndex;

640

    mIndex = mRequestedIndex;

641

642

592

  return NS_OK;

643

  return NS_OK;

593

644

594

645

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

Line	Link Here

Lines 85-95 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;

  PRInt32 mLength;

  PRInt32 mLength;

  PRInt32 mRequestedIndex;

  PRInt32 mRequestedIndex;

  PRInt32 mNumViewers;

  // Session History listener

  // Session History listener

  nsWeakPtr mListener;

  nsWeakPtr mListener;

  // Weak reference. Do not refcount this.

  // Weak reference. Do not refcount this.

Return to bug 274784