Expose a cachePolicy parameter to loadHistoryItem.

Source/core/loader/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 101 matching lines @@
 HistoryItem* HistoryEntry::itemForFrame(Frame* frame)
 {
     if (HistoryNode* historyNode = historyNodeForFrame(frame))
         return historyNode->value();
     return 0;
 }
 
 HistoryController::HistoryController(Page* page)
     : m_page(page)
     , m_defersLoading(false)
+    , m_deferredCachePolicy(UseProtocolCachePolicy)
 {
 }
 
 HistoryController::~HistoryController()
 {
 }
 
 void HistoryController::updateBackForwardListForFragmentScroll(Frame* frame, HistoryItem* item)
 {
     m_provisionalEntry.clear();
     createNewBackForwardItem(frame, item, false);
 }
 
-void HistoryController::goToEntry(PassOwnPtr<HistoryEntry> targetEntry)
+void HistoryController::goToEntry(PassOwnPtr<HistoryEntry> targetEntry, ResourceRequestCachePolicy cachePolicy)
 {
     ASSERT(m_sameDocumentLoadsInProgress.isEmpty());
     ASSERT(m_differentDocumentLoadsInProgress.isEmpty());
 
     m_provisionalEntry = targetEntry;
     recursiveGoToEntry(m_page->mainFrame());
 
     if (m_sameDocumentLoadsInProgress.isEmpty() && m_differentDocumentLoadsInProgress.isEmpty())
         m_sameDocumentLoadsInProgress.set(m_page->mainFrame(), m_provisionalEntry->root());
 
     if (m_differentDocumentLoadsInProgress.isEmpty()) {
         m_previousEntry = m_currentEntry.release();
         m_currentEntry = m_provisionalEntry.release();
     }
 
     for (HistoryFrameLoadSet::iterator it = m_sameDocumentLoadsInProgress.begin(); it != m_sameDocumentLoadsInProgress.end(); ++it)
-        it->key->loader().loadHistoryItem(it->value, HistorySameDocumentLoad);
+        it->key->loader().loadHistoryItem(it->value, HistorySameDocumentLoad, cachePolicy);
     for (HistoryFrameLoadSet::iterator it = m_differentDocumentLoadsInProgress.begin(); it != m_differentDocumentLoadsInProgress.end(); ++it)
-        it->key->loader().loadHistoryItem(it->value, HistoryDifferentDocumentLoad);
+        it->key->loader().loadHistoryItem(it->value, HistoryDifferentDocumentLoad, cachePolicy);
     m_sameDocumentLoadsInProgress.clear();
     m_differentDocumentLoadsInProgress.clear();
 }
 
 void HistoryController::recursiveGoToEntry(Frame* frame)
 {
     HistoryItem* newItem = m_provisionalEntry->itemForFrame(frame);
     HistoryItem* oldItem = m_currentEntry ? m_currentEntry->itemForFrame(frame) : 0;
     if (!newItem)
         return;
 
     if (!oldItem || (newItem != oldItem && newItem->itemSequenceNumber() != oldItem->itemSequenceNumber())) {
         if (oldItem && newItem->documentSequenceNumber() == oldItem->documentSequenceNumber())
             m_sameDocumentLoadsInProgress.set(frame, newItem);
         else
             m_differentDocumentLoadsInProgress.set(frame, newItem);
         return;
     }
 
     for (Frame* child = frame->tree().firstChild(); child; child = child->tree().nextSibling())
         recursiveGoToEntry(child);
 }
 
-void HistoryController::goToItem(HistoryItem* targetItem)
+void HistoryController::goToItem(HistoryItem* targetItem, ResourceRequestCachePolicy cachePolicy)
 {
     if (m_defersLoading) {
         m_deferredItem = targetItem;
+        m_deferredCachePolicy = cachePolicy;
         return;
     }
 
     OwnPtr<HistoryEntry> newEntry = HistoryEntry::create(targetItem);
     Deque<HistoryNode*> historyNodes;
     historyNodes.append(newEntry->rootHistoryNode());
     while (!historyNodes.isEmpty()) {
         // For each item, read the children (if any) off the HistoryItem,
         // create a new HistoryNode for each child and attach it,
         // then clear the children on the HistoryItem.
         HistoryNode* historyNode = historyNodes.takeFirst();
         const HistoryItemVector& children = historyNode->value()->children();
         for (size_t i = 0; i < children.size(); i++) {
             HistoryNode* childHistoryNode = historyNode->addChild(children[i].get());
             historyNodes.append(childHistoryNode);
         }
         historyNode->value()->clearChildren();
     }
-    goToEntry(newEntry.release());
+    goToEntry(newEntry.release(), cachePolicy);
 }
 
 void HistoryController::setDefersLoading(bool defer)
 {
     m_defersLoading = defer;
     if (!defer && m_deferredItem) {
-        goToItem(m_deferredItem.get());
+        goToItem(m_deferredItem.get(), m_deferredCachePolicy);
         m_deferredItem = 0;
+        m_deferredCachePolicy = UseProtocolCachePolicy;
     }
 }
 
 void HistoryController::updateForInitialLoadInChildFrame(Frame* frame, HistoryItem* item)
 {
     ASSERT(frame->tree().parent());
     if (!m_currentEntry || m_currentEntry->historyNodeForFrame(frame))
         return;
     if (HistoryNode* parentHistoryNode = m_currentEntry->historyNodeForFrame(frame->tree().parent()))
         parentHistoryNode->addChild(item);
@@ skipping 67 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