Simply FrameLoaderStateMachine and FrameLoader::transitionToCommitted().

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 290 matching lines @@
     // When reloading the page, we may end up redirecting to a different URL
     // this time (e.g., due to cookies).  See http://webkit.org/b/4072.
     updateCurrentItem();
 }
 
 // There are 2 things you might think of as "history", all of which are handled by these functions.
 //
 //     1) Back/forward: The m_currentItem is part of this mechanism.
 //     2) Global history: Handled by the client.
 //
-void HistoryController::updateForStandardLoad(HistoryUpdateType updateType)
+void HistoryController::updateForStandardLoad()
 {
     LOG(History, "WebCoreHistory: Updating History for Standard Load in frame %s", m_frame->loader()->documentLoader()->url().string().ascii().data());
 
     FrameLoader* frameLoader = m_frame->loader();
 
     const KURL& historyURL = frameLoader->documentLoader()->urlForHistory();
 
     if (!frameLoader->documentLoader()->isClientRedirect()) {
-        if (!historyURL.isEmpty()) {
-            if (updateType != UpdateAllExceptBackForwardList)
-                updateBackForwardListClippedAtTarget(true);
-        }
+        if (!historyURL.isEmpty())
+            updateBackForwardListClippedAtTarget(true);
     } else {
         // The client redirect replaces the current history item.
         updateCurrentItem();
     }
 }
 
 void HistoryController::updateForRedirectWithLockedBackForwardList()
 {
 #if !LOG_DISABLED
     if (m_frame->loader()->documentLoader())
@@ skipping 34 matching lines @@
 void HistoryController::updateForCommit()
 {
     FrameLoader* frameLoader = m_frame->loader();
 #if !LOG_DISABLED
     if (frameLoader->documentLoader())
         LOG(History, "WebCoreHistory: Updating History for commit in frame %s", frameLoader->documentLoader()->title().string().utf8().data());
 #endif
     FrameLoadType type = frameLoader->loadType();
     if (isBackForwardLoadType(type)
         || isReplaceLoadTypeWithProvisionalItem(type)
-        || (isReloadTypeWithProvisionalItem(type) && !frameLoader->provisionalDocumentLoader()->unreachableURL().isEmpty())) {
+        || (isReloadTypeWithProvisionalItem(type) && !frameLoader->documentLoader()->unreachableURL().isEmpty())) {

[Nate Chapin, 2013/05/01 21:38:34]

This used to be called just before the provisional document loader was promoted
to the committed document loader. With this patch, it is called just after.

[abarth-chromium, 2013/05/06 17:09:42]

Makes sense.

         // Once committed, we want to use current item for saving DocState, and
         // the provisional item for restoring state.
         // Note previousItem must be set before we close the URL, which will
         // happen when the data source is made non-provisional below
         m_frameLoadComplete = false;
         m_previousItem = m_currentItem;
         ASSERT(m_provisionalItem);
         m_currentItem = m_provisionalItem;
         m_provisionalItem = 0;
 
         // Tell all other frames in the tree to commit their provisional items and
         // restore their scroll position.  We'll avoid this frame (which has already
         // committed) and its children (which will be replaced).
         Page* page = m_frame->page();
         ASSERT(page);
         page->mainFrame()->loader()->history()->recursiveUpdateForCommit();
     }
+
+    switch (type) {
+        case FrameLoadTypeForward:
+        case FrameLoadTypeBack:
+        case FrameLoadTypeIndexedBackForward:
+            updateForBackForwardNavigation();
+            return;
+        case FrameLoadTypeReload:
+        case FrameLoadTypeReloadFromOrigin:
+        case FrameLoadTypeSame:
+        case FrameLoadTypeReplace:
+            updateForReload();
+            return;
+        case FrameLoadTypeStandard:
+            updateForStandardLoad();
+            return;
+        case FrameLoadTypeRedirectWithLockedBackForwardList:
+            updateForRedirectWithLockedBackForwardList();
+            return;
+        default:
+            ASSERT_NOT_REACHED();
+    }
 }
 
 bool HistoryController::isReplaceLoadTypeWithProvisionalItem(FrameLoadType type)
 {
     // Going back to an error page in a subframe can trigger a FrameLoadTypeReplace
     // while m_provisionalItem is set, so we need to commit it.
     return type == FrameLoadTypeReplace && m_provisionalItem;
 }
 
 bool HistoryController::isReloadTypeWithProvisionalItem(FrameLoadType type)
@@ skipping 368 matching lines @@
         m_currentItem->setURLString(urlString);
     m_currentItem->setTitle(title);
     m_currentItem->setStateObject(stateObject);
     m_currentItem->setFormData(0);
     m_currentItem->setFormContentType(String());
 
     ASSERT(m_frame->page());
 }
 
 } // namespace WebCore