Keep frames to navigate alive in HistoryController::goToEntry()

Source/core/page/HistoryController.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 135 matching lines @@
 HistoryController::~HistoryController()
 {
 }
 
 void HistoryController::updateBackForwardListForFragmentScroll(Frame* frame, HistoryItem* item)
 {
     m_provisionalEntry.clear();
     createNewBackForwardItem(frame, item, false);
 }
 
+class HistoryController::HistoryFrameLoad {
+public:
+    HistoryFrameLoad(Frame* frame, HistoryItem* item)
+        : m_frame(frame)
+        , m_item(item)
+    {
+    }
+
+    Frame* frame() { return m_frame.get(); }
+    HistoryItem* item() { return m_item; }
+
+private:
+    RefPtr<Frame> m_frame;
+    HistoryItem* m_item;
+};
+
 void HistoryController::goToEntry(PassOwnPtr<HistoryEntry> targetEntry, ResourceRequestCachePolicy cachePolicy)
 {
     HistoryFrameLoadSet sameDocumentLoads;
     HistoryFrameLoadSet differentDocumentLoads;
 
     m_provisionalEntry = targetEntry;
     if (m_currentEntry)
         recursiveGoToEntry(m_page->mainFrame(), sameDocumentLoads, differentDocumentLoads);
     else
-        differentDocumentLoads.set(m_page->mainFrame(), m_provisionalEntry->root());
+        differentDocumentLoads.set(m_page->mainFrame(), adoptPtr(new HistoryFrameLoad(m_page->mainFrame(), m_provisionalEntry->root())));
 
     if (sameDocumentLoads.isEmpty() && differentDocumentLoads.isEmpty())
-        sameDocumentLoads.set(m_page->mainFrame(), m_provisionalEntry->root());
+        sameDocumentLoads.set(m_page->mainFrame(), adoptPtr(new HistoryFrameLoad(m_page->mainFrame(), m_provisionalEntry->root())));
 
     if (differentDocumentLoads.isEmpty()) {
         m_previousEntry = m_currentEntry.release();
         m_currentEntry = m_provisionalEntry.release();
     }
 
     for (HistoryFrameLoadSet::iterator it = sameDocumentLoads.begin(); it != sameDocumentLoads.end(); ++it)
-        it->key->loader().loadHistoryItem(it->value, HistorySameDocumentLoad, cachePolicy);
+        it->key->loader().loadHistoryItem(it->value->item(), HistorySameDocumentLoad, cachePolicy);

[Nate Chapin, 2014/01/23 18:19:11]

Rather than checking m_client in loadHistoryItem(), we could just null-check
it->key->host() here.

Conceptually, we really shouldn't be trying to start a load if the frame is
detached, so maybe we should then ASSERT we're attached at the start of
loadHistoryItem().

     for (HistoryFrameLoadSet::iterator it = differentDocumentLoads.begin(); it != differentDocumentLoads.end(); ++it)
-        it->key->loader().loadHistoryItem(it->value, HistoryDifferentDocumentLoad, cachePolicy);
+        it->key->loader().loadHistoryItem(it->value->item(), HistoryDifferentDocumentLoad, cachePolicy);
 }
 
 void HistoryController::recursiveGoToEntry(Frame* frame, HistoryFrameLoadSet& sameDocumentLoads, HistoryFrameLoadSet& differentDocumentLoads)
 {
     ASSERT(m_provisionalEntry);
     ASSERT(m_currentEntry);
     HistoryItem* newItem = m_provisionalEntry->itemForFrame(frame);
     HistoryItem* oldItem = m_currentEntry->itemForFrame(frame);
     if (!newItem)
         return;
 
     if (!oldItem || (newItem != oldItem && newItem->itemSequenceNumber() != oldItem->itemSequenceNumber())) {
         if (oldItem && newItem->documentSequenceNumber() == oldItem->documentSequenceNumber())
-            sameDocumentLoads.set(frame, newItem);
+            sameDocumentLoads.set(frame, adoptPtr(new HistoryFrameLoad(frame, newItem)));
         else
-            differentDocumentLoads.set(frame, newItem);
+            differentDocumentLoads.set(frame, adoptPtr(new HistoryFrameLoad(frame, newItem)));
         return;
     }
 
     for (Frame* child = frame->tree().firstChild(); child; child = child->tree().nextSibling())
         recursiveGoToEntry(child, sameDocumentLoads, differentDocumentLoads);
 }
 
 void HistoryController::goToItem(HistoryItem* targetItem, ResourceRequestCachePolicy cachePolicy)
 {
     if (m_defersLoading) {
@@ skipping 108 matching lines @@
     } else {
         HistoryItem* oldItem = m_currentEntry->itemForFrame(targetFrame);
         if (!clipAtTarget && oldItem)
             newItem->setDocumentSequenceNumber(oldItem->documentSequenceNumber());
         m_previousEntry = m_currentEntry.release();
         m_currentEntry = m_previousEntry->cloneAndReplace(newItem.get(), clipAtTarget, targetFrame, m_page);
     }
 }
 
 } // namespace WebCore