Bug 1323651 - Rename Partial/GroupedSessionHistory to Partial/GroupedSHistory. r=ehsan
authorSamael Wang <freesamael@gmail.com>
Thu, 22 Dec 2016 16:06:50 +0800
changeset 374297 664f73663acba298c8451e1ea446d9af3120512a
parent 374296 aef8ecf9b6518d3676c50a94b0e7ac05654cf858
child 374298 06723029caa10fbdaf3ede5ee94fb0d46ee9a44b
push id1419
push userjlund@mozilla.com
push dateMon, 10 Apr 2017 20:44:07 +0000
treeherdermozilla-release@5e6801b73ef6 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersehsan
bugs1323651
milestone53.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1323651 - Rename Partial/GroupedSessionHistory to Partial/GroupedSHistory. r=ehsan MozReview-Commit-ID: G2GW4ZPIfH3
browser/base/content/tabbrowser.xml
browser/base/content/test/general/browser_close_dependent_tabs.js
browser/components/sessionstore/SessionStore.jsm
browser/components/sessionstore/test/browser_grouped_session_store.js
docshell/base/nsDocShell.cpp
docshell/shistory/nsIGroupedSHistory.idl
docshell/shistory/nsIPartialSHistory.idl
docshell/shistory/nsISHistory.idl
docshell/shistory/nsSHistory.cpp
docshell/test/browser/browser_grouped_shistory_bfcache_cleaning.js
docshell/test/browser/browser_grouped_shistory_crossproc.js
docshell/test/browser/browser_grouped_shistory_dead_navigate.js
dom/base/GroupedSHistory.cpp
dom/base/PartialSHistory.cpp
dom/base/nsFrameLoader.cpp
dom/base/nsFrameLoader.h
dom/base/nsIFrameLoader.idl
dom/base/test/chrome/window_groupedSHistory.xul
dom/ipc/PBrowser.ipdl
dom/ipc/TabChild.cpp
dom/ipc/TabChild.h
dom/ipc/TabParent.cpp
dom/tests/browser/browser_prerendering.js
--- a/browser/base/content/tabbrowser.xml
+++ b/browser/base/content/tabbrowser.xml
@@ -4843,32 +4843,32 @@
               let newTab = this.loadOneTab(data.href, {
                 referrerURI: (data.referrer ? makeURI(data.referrer) : null),
                 referrerPolicy: Ci.nsIHttpChannel.REFERRER_POLICY_DEFAULT,
                 postData: null,
                 allowThirdPartyFixup: true,
                 relatedToCurrent: true,
                 isPrerendered: true,
               });
-              let partialSHistory = newTab.linkedBrowser.frameLoader.partialSessionHistory;
+              let partialSHistory = newTab.linkedBrowser.frameLoader.partialSHistory;
               groupedSHistory.addPrerenderingPartialSHistory(partialSHistory, data.id);
               break;
             }
 
             case "Prerender:Cancel": {
-              let groupedSHistory = browser.frameLoader.groupedSessionHistory;
+              let groupedSHistory = browser.frameLoader.groupedSHistory;
               if (groupedSHistory) {
                 groupedSHistory.cancelPrerendering(data.id);
               }
               break;
             }
 
             case "Prerender:Swap": {
               let frameloader = browser.frameLoader;
-              let groupedSHistory = browser.frameLoader.groupedSessionHistory;
+              let groupedSHistory = browser.frameLoader.groupedSHistory;
               if (groupedSHistory) {
                 groupedSHistory.activatePrerendering(data.id).then(
                   () => frameloader.messageManager.sendAsyncMessage("Prerender:Swapped", data),
                   () => frameloader.messageManager.sendAsyncMessage("Prerender:Canceled", data),
                 );
               }
               break;
             }
--- a/browser/base/content/test/general/browser_close_dependent_tabs.js
+++ b/browser/base/content/test/general/browser_close_dependent_tabs.js
@@ -63,17 +63,16 @@ add_task(function* () {
     // Set up the grouped SHEntry setup
     let tab2 = gBrowser.loadOneTab("data:text/html,b", {
       referrerPolicy: Ci.nsIHttpChannel.REFERRER_POLICY_DEFAULT,
       allowThirdPartyFixup: true,
       relatedToCurrent: true,
       isPrerendered: true,
     });
     yield BrowserTestUtils.browserLoaded(tab2.linkedBrowser);
-    browser1.frameLoader.appendPartialSessionHistoryAndSwap(
-      tab2.linkedBrowser.frameLoader);
+    browser1.frameLoader.appendPartialSHistoryAndSwap(tab2.linkedBrowser.frameLoader);
     yield awaitProcessChange(browser1);
   });
   yield closed2;
 
   // At this point prerendered tab should be closed
   is(gBrowser.tabs.length, 1, "The new tab and the prerendered 'tab' should be closed");
 });
--- a/browser/components/sessionstore/SessionStore.jsm
+++ b/browser/components/sessionstore/SessionStore.jsm
@@ -3636,17 +3636,17 @@ var SessionStoreInternal = {
     // browser, which removes it from the display list. We cannot
     // flip the remoteness of any browser that is not being displayed.
     this.markTabAsRestoring(aTab);
 
     // We need a new frameloader either if we are reloading into a fresh
     // process, or we have a browser with a grouped session history (as we don't
     // support restoring into browsers with grouped session histories directly).
     let newFrameloader =
-      aReloadInFreshProcess || !!browser.frameLoader.groupedSessionHistory;
+      aReloadInFreshProcess || !!browser.frameLoader.groupedSHistory;
     let isRemotenessUpdate =
       tabbrowser.updateBrowserRemotenessByURL(browser, uri, {
         freshProcess: aReloadInFreshProcess,
         newFrameloader: newFrameloader,
       });
 
     if (isRemotenessUpdate) {
       // We updated the remoteness, so we need to send the history down again.
--- a/browser/components/sessionstore/test/browser_grouped_session_store.js
+++ b/browser/components/sessionstore/test/browser_grouped_session_store.js
@@ -65,18 +65,17 @@ add_task(function* () {
     // Create a new hidden prerendered tab to swap to.
     let tab2 = gBrowser.loadOneTab(URIs[2], {
       referrerPolicy: Ci.nsIHttpChannel.REFERRER_POLICY_DEFAULT,
       allowThirdPartyFixup: true,
       relatedToCurrent: true,
       isPrerendered: true,
     });
     yield BrowserTestUtils.browserLoaded(tab2.linkedBrowser);
-    browser1.frameLoader.appendPartialSessionHistoryAndSwap(
-      tab2.linkedBrowser.frameLoader);
+    browser1.frameLoader.appendPartialSHistoryAndSwap(tab2.linkedBrowser.frameLoader);
     yield awaitProcessChange(browser1);
     yield* validate(browser1, 3, 3);
 
     browser1.loadURI(URIs[3], null, null);
     yield BrowserTestUtils.browserLoaded(browser1);
     yield* validate(browser1, 4, 4);
 
     // In process navigate back.
@@ -108,18 +107,17 @@ add_task(function* () {
     // Create a new hidden prerendered tab to swap to
     let tab3 = gBrowser.loadOneTab(URIs[4], {
       referrerPolicy: Ci.nsIHttpChannel.REFERRER_POLICY_DEFAULT,
       allowThirdPartyFixup: true,
       relatedToCurrent: true,
       isPrerendered: true,
     });
     yield BrowserTestUtils.browserLoaded(tab3.linkedBrowser);
-    browser1.frameLoader.appendPartialSessionHistoryAndSwap(
-      tab3.linkedBrowser.frameLoader);
+    browser1.frameLoader.appendPartialSHistoryAndSwap(tab3.linkedBrowser.frameLoader);
     yield awaitProcessChange(browser1);
     yield* validate(browser1, 5, 5);
 
     browser1.gotoIndex(0);
     yield awaitProcessChange(browser1);
     yield* validate(browser1, 5, 1);
 
     browser1.gotoIndex(2);
--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -10546,17 +10546,17 @@ nsDocShell::InternalLoad(nsIURI* aURI,
     nsCOMPtr<nsIRunnable> ev =
       new InternalLoadEvent(this, aURI, aOriginalURI, aLoadReplace,
                             aReferrer, aReferrerPolicy,
                             aTriggeringPrincipal, principalToInherit,
                             aFlags, aTypeHint, aPostData, aHeadersData,
                             aLoadType, aSHEntry, aFirstParty, aSrcdoc,
                             aSourceDocShell, aBaseURI, false);
     // We don't need any success handler since in that case
-    // OnPartialSessionHistoryDeactive would be called, and it would ensure
+    // OnPartialSHistoryDeactive would be called, and it would ensure
     // docshell loads about:blank.
     bool shouldSwitch = false;
     rv = browserChrome3->ShouldSwitchToPrerenderedDocument(
       aURI, mCurrentURI, nullptr, ev, &shouldSwitch);
     if (NS_SUCCEEDED(rv) && shouldSwitch) {
       return NS_OK;
     }
   }
--- a/docshell/shistory/nsIGroupedSHistory.idl
+++ b/docshell/shistory/nsIGroupedSHistory.idl
@@ -25,17 +25,17 @@ interface nsIGroupedSHistory : nsISuppor
    * The currently active frameloader controlled by this nsIGroupedSHistory.
    */
   readonly attribute nsIFrameLoader activeFrameLoader;
 
   /**
    * Remove all partial histories after currently active one (if any) and then
    * append the given partial session history to the end of the list.
    */
-  void appendPartialSessionHistory(in nsIPartialSHistory aPartialHistory);
+  void appendPartialSHistory(in nsIPartialSHistory aPartialHistory);
 
   /**
    * Notify the grouped session history that the active partial session history
    * has been modified.
    *
    * @param aPartialHistory The partial history which was updated
    * @param aTruncate If this parameter is true, all partial session histories
    *                  after this one will be removed.
--- a/docshell/shistory/nsIPartialSHistory.idl
+++ b/docshell/shistory/nsIPartialSHistory.idl
@@ -44,18 +44,17 @@ interface nsIPartialSHistory : nsISuppor
    * it's becoming the active partial history of the group.
    *
    * @param aGroup                 The GroupedSHistory which this partialSHistory
    *                               is joining.
    *
    * @param aOffset                The number of entries in preceding partial
    *                               session histories.
    */
-  void onAttachGroupedSessionHistory(in nsIGroupedSHistory aGroup,
-                                     in unsigned long aOffset);
+  void onAttachGroupedSHistory(in nsIGroupedSHistory aGroup, in unsigned long aOffset);
 
   /**
    * This method is used by the TabParent to notify the PartialSHistory
    * that the state of its corresponding nsISHistory in the content process
    * has been updated. It is unused in the in-process case.
    *
    * @param aCount      The number of entries in the associated session history.
    * @param aLocalIndex The local index of the currently active entry in the
--- a/docshell/shistory/nsISHistory.idl
+++ b/docshell/shistory/nsISHistory.idl
@@ -219,24 +219,24 @@ interface nsISHistory: nsISupports
   /**
    * Called when this nsISHistory has became the active history of a grouped
    * session history.
    *
    * @param globalLength      The up to date number of entries in the grouped
    *                          session history.
    * @param targetIndex       The local index to navigate to.
    */
-   void onPartialSessionHistoryActive(in long globalLength, in long targetIndex);
+   void onPartialSHistoryActive(in long globalLength, in long targetIndex);
 
   /**
    * Called when this nsISHistory has became inactive history of a grouped
    * session history.
    */
-   void onPartialSessionHistoryDeactive();
+   void onPartialSHistoryDeactive();
 
   /**
    * Called when it's attached to a nsIGroupedSHistory instance.
    *
    * @param offset            The number of entries in the grouped session
    *                          history before this session history object.
    */
-   void onAttachGroupedSessionHistory(in long offset);
+   void onAttachGroupedSHistory(in long offset);
 };
--- a/docshell/shistory/nsSHistory.cpp
+++ b/docshell/shistory/nsSHistory.cpp
@@ -478,32 +478,32 @@ NS_IMETHODIMP
 nsSHistory::GetGlobalIndexOffset(int32_t* aResult)
 {
   NS_ENSURE_ARG_POINTER(aResult);
   *aResult = mGlobalIndexOffset;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsSHistory::OnPartialSessionHistoryActive(int32_t aGlobalLength, int32_t aTargetIndex)
+nsSHistory::OnPartialSHistoryActive(int32_t aGlobalLength, int32_t aTargetIndex)
 {
   NS_ENSURE_TRUE(mRootDocShell && mIsPartial, NS_ERROR_UNEXPECTED);
 
   int32_t extraLength = aGlobalLength - mLength - mGlobalIndexOffset;
   NS_ENSURE_TRUE(extraLength >= 0, NS_ERROR_UNEXPECTED);
 
   if (extraLength != mEntriesInFollowingPartialHistories) {
     mEntriesInFollowingPartialHistories = extraLength;
   }
 
   return RestoreToEntryAtIndex(aTargetIndex);
 }
 
 NS_IMETHODIMP
-nsSHistory::OnPartialSessionHistoryDeactive()
+nsSHistory::OnPartialSHistoryDeactive()
 {
   NS_ENSURE_TRUE(mRootDocShell && mIsPartial, NS_ERROR_UNEXPECTED);
 
   // Ensure the deactive docshell loads about:blank.
   nsCOMPtr<nsIWebNavigation> webNav = do_QueryInterface(mRootDocShell);
   nsCOMPtr<nsIURI> currentURI;
   webNav->GetCurrentURI(getter_AddRefs(currentURI));
   if (NS_IsAboutBlank(currentURI)) {
@@ -1916,17 +1916,17 @@ nsSHistory::GetSHistoryEnumerator(nsISim
 {
   NS_ENSURE_ARG_POINTER(aEnumerator);
   RefPtr<nsSHEnumerator> iterator = new nsSHEnumerator(this);
   iterator.forget(aEnumerator);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsSHistory::OnAttachGroupedSessionHistory(int32_t aOffset)
+nsSHistory::OnAttachGroupedSHistory(int32_t aOffset)
 {
   NS_ENSURE_TRUE(!mIsPartial && mRootDocShell, NS_ERROR_UNEXPECTED);
   NS_ENSURE_TRUE(aOffset >= 0, NS_ERROR_ILLEGAL_VALUE);
 
   mIsPartial = true;
   mGlobalIndexOffset = aOffset;
 
   // The last attached history is always at the end of the group.
--- a/docshell/test/browser/browser_grouped_shistory_bfcache_cleaning.js
+++ b/docshell/test/browser/browser_grouped_shistory_bfcache_cleaning.js
@@ -24,18 +24,17 @@ add_task(function* () {
     // Set up the grouped SHEntry setup
     let tab2 = gBrowser.loadOneTab("data:text/html,b", {
       referrerPolicy: Ci.nsIHttpChannel.REFERRER_POLICY_DEFAULT,
       allowThirdPartyFixup: true,
       relatedToCurrent: true,
       isPrerendered: true,
     });
     yield BrowserTestUtils.browserLoaded(tab2.linkedBrowser);
-    browser1.frameLoader.appendPartialSessionHistoryAndSwap(
-      tab2.linkedBrowser.frameLoader);
+    browser1.frameLoader.appendPartialSHistoryAndSwap(tab2.linkedBrowser.frameLoader);
     yield awaitProcessChange(browser1);
     ok(isAlive(tab2));
 
     // Load some URIs and make sure that we lose the old process once we are 3 history entries away.
     browser1.loadURI("data:text/html,c", null, null);
     yield BrowserTestUtils.browserLoaded(browser1);
     ok(isAlive(tab2), "frameloader should still be alive");
     browser1.loadURI("data:text/html,d", null, null);
--- a/docshell/test/browser/browser_grouped_shistory_crossproc.js
+++ b/docshell/test/browser/browser_grouped_shistory_crossproc.js
@@ -29,26 +29,25 @@ add_task(function* () {
     // Set up the grouped SHEntry setup
     let tab2 = gBrowser.loadOneTab("data:text/html,b", {
       referrerPolicy: Ci.nsIHttpChannel.REFERRER_POLICY_DEFAULT,
       allowThirdPartyFixup: true,
       relatedToCurrent: true,
       isPrerendered: true,
     });
     yield BrowserTestUtils.browserLoaded(tab2.linkedBrowser);
-    browser1.frameLoader.appendPartialSessionHistoryAndSwap(
-      tab2.linkedBrowser.frameLoader);
+    browser1.frameLoader.appendPartialSHistoryAndSwap(tab2.linkedBrowser.frameLoader);
     yield awaitProcessChange(browser1);
 
     // Load a URI which will involve loading in the parent process
     let tabClose = awaitTabClose(tab2);
     browser1.loadURI("about:config", Ci.nsIWebNavigation.LOAD_FLAGS_NONE, null, null, null);
     yield BrowserTestUtils.browserLoaded(browser1);
     let docshell = browser1.frameLoader.docShell.QueryInterface(Ci.nsIWebNavigation);
     ok(docshell, "The browser should be loaded in the chrome process");
     is(docshell.canGoForward, false, "canGoForward is correct");
     is(docshell.canGoBack, true, "canGoBack is correct");
     is(docshell.sessionHistory.count, 3, "Count is correct");
-    is(browser1.frameLoader.groupedSessionHistory, null,
+    is(browser1.frameLoader.groupedSHistory, null,
        "browser1's session history is now complete");
     yield tabClose;
   });
 });
--- a/docshell/test/browser/browser_grouped_shistory_dead_navigate.js
+++ b/docshell/test/browser/browser_grouped_shistory_dead_navigate.js
@@ -18,27 +18,26 @@ add_task(function* () {
     // Set up the grouped SHEntry setup
     let tab2 = gBrowser.loadOneTab("data:text/html,b", {
       referrerPolicy: Ci.nsIHttpChannel.REFERRER_POLICY_DEFAULT,
       allowThirdPartyFixup: true,
       relatedToCurrent: true,
       isPrerendered: true,
     });
     yield BrowserTestUtils.browserLoaded(tab2.linkedBrowser);
-    browser1.frameLoader.appendPartialSessionHistoryAndSwap(
-      tab2.linkedBrowser.frameLoader);
+    browser1.frameLoader.appendPartialSHistoryAndSwap(tab2.linkedBrowser.frameLoader);
     yield awaitProcessChange(browser1);
 
     // Close tab2 such that the back frameloader is dead
     yield BrowserTestUtils.removeTab(tab2);
     browser1.goBack();
     yield BrowserTestUtils.browserLoaded(browser1);
     yield ContentTask.spawn(browser1, null, function() {
       is(content.window.location + "", "data:text/html,a");
       let webNav = content.window.QueryInterface(Ci.nsIInterfaceRequestor)
             .getInterface(Ci.nsIWebNavigation);
       is(webNav.canGoForward, true, "canGoForward is correct");
       is(webNav.canGoBack, false, "canGoBack is correct");
     });
-    is(browser1.frameLoader.groupedSessionHistory, null,
+    is(browser1.frameLoader.groupedSHistory, null,
        "browser1's session history is now complete");
   });
 });
--- a/dom/base/GroupedSHistory.cpp
+++ b/dom/base/GroupedSHistory.cpp
@@ -43,17 +43,17 @@ NS_IMETHODIMP
 GroupedSHistory::GetCount(uint32_t* aResult)
 {
   MOZ_ASSERT(aResult);
   *aResult = mCount;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-GroupedSHistory::AppendPartialSessionHistory(nsIPartialSHistory* aPartialHistory)
+GroupedSHistory::AppendPartialSHistory(nsIPartialSHistory* aPartialHistory)
 {
   if (!aPartialHistory) {
     return NS_ERROR_INVALID_POINTER;
   }
 
   nsCOMPtr<nsIPartialSHistory> partialHistory(aPartialHistory);
   if (!partialHistory || mPartialHistories.Contains(partialHistory)) {
     return NS_ERROR_FAILURE;
@@ -71,17 +71,17 @@ GroupedSHistory::AppendPartialSessionHis
     }
     prevPartialHistory->OnDeactive();
   }
 
   // Attach the partial history.
   uint32_t offset = mCount;
   mCount += partialHistory->GetCount();
   mPartialHistories.AppendElement(partialHistory);
-  partialHistory->OnAttachGroupedSessionHistory(this, offset);
+  partialHistory->OnAttachGroupedSHistory(this, offset);
   mIndexOfActivePartialHistory = mPartialHistories.Count() - 1;
 
   // Remove the prerendered documents, as there was a history navigation
   PurgePrerendering();
 
   return NS_OK;
 }
 
@@ -307,17 +307,17 @@ GroupedSHistory::ActivatePrerendering(in
 
       nsCOMPtr<nsIFrameLoader> activeFl;
       GetActiveFrameLoader(getter_AddRefs(activeFl));
       NS_ENSURE_TRUE(activeFl, NS_ERROR_FAILURE);
 
       nsresult rv = fl->MakePrerenderedLoaderActive();
       NS_ENSURE_SUCCESS(rv, rv);
 
-      return activeFl->AppendPartialSessionHistoryAndSwap(fl, aPromise);
+      return activeFl->AppendPartialSHistoryAndSwap(fl, aPromise);
     }
   }
 
   // Generate a rejected promise as the entry was not found.
   nsCOMPtr<nsIGlobalObject> go = xpc::NativeGlobal(JS::CurrentGlobalOrNull(aCx));
   if (NS_WARN_IF(!go)) {
     return NS_ERROR_FAILURE;
   }
--- a/dom/base/PartialSHistory.cpp
+++ b/dom/base/PartialSHistory.cpp
@@ -140,42 +140,42 @@ NS_IMETHODIMP
 PartialSHistory::GetOwnerFrameLoader(nsIFrameLoader** aResult)
 {
   nsCOMPtr<nsIFrameLoader> loader(mOwnerFrameLoader);
   loader.forget(aResult);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-PartialSHistory::OnAttachGroupedSessionHistory(nsIGroupedSHistory* aGroup, uint32_t aOffset)
+PartialSHistory::OnAttachGroupedSHistory(nsIGroupedSHistory* aGroup, uint32_t aOffset)
 {
   MOZ_ASSERT(!mGroupedSHistory, "Only may join a single GroupedSHistory");
 
   mActive = nsIPartialSHistory::STATE_ACTIVE;
   mGlobalIndexOffset = aOffset;
   mGroupedSHistory = aGroup;
 
   // If we have direct reference to nsISHistory, simply pass through.
   nsCOMPtr<nsISHistory> shistory(GetSessionHistory());
   if (shistory) {
     // nsISHistory uses int32_t
     if (aOffset > INT32_MAX) {
       return NS_ERROR_FAILURE;
     }
-    return shistory->OnAttachGroupedSessionHistory(aOffset);
+    return shistory->OnAttachGroupedSHistory(aOffset);
   }
 
   // Otherwise notify through TabParent.
   RefPtr<TabParent> tabParent(GetTabParent());
   if (!tabParent) {
     // We have neither shistory nor tabParent?
     NS_WARNING("Unable to get shitory nor tabParent!");
     return NS_ERROR_UNEXPECTED;
   }
-  Unused << tabParent->SendNotifyAttachGroupedSessionHistory(aOffset);
+  Unused << tabParent->SendNotifyAttachGroupedSHistory(aOffset);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 PartialSHistory::HandleSHistoryUpdate(uint32_t aCount, uint32_t aIndex, bool aTruncate)
 {
   // Update our local cache of mCount and mIndex
@@ -211,57 +211,56 @@ PartialSHistory::OnActive(uint32_t aGlob
 
   // In-process case.
   nsCOMPtr<nsISHistory> shistory(GetSessionHistory());
   if (shistory) {
     // nsISHistory uses int32_t
     if (aGlobalLength > INT32_MAX || aTargetLocalIndex > INT32_MAX) {
       return NS_ERROR_FAILURE;
     }
-    return shistory->OnPartialSessionHistoryActive(aGlobalLength,
-                                                   aTargetLocalIndex);
+    return shistory->OnPartialSHistoryActive(aGlobalLength, aTargetLocalIndex);
   }
 
   // Cross-process case.
   RefPtr<TabParent> tabParent(GetTabParent());
   if (!tabParent) {
     // We have neither shistory nor tabParent?
     NS_WARNING("Unable to get shitory nor tabParent!");
     return NS_ERROR_UNEXPECTED;
   }
-  Unused << tabParent->SendNotifyPartialSessionHistoryActive(aGlobalLength,
-                                                             aTargetLocalIndex);
+  Unused << tabParent->SendNotifyPartialSHistoryActive(aGlobalLength,
+                                                       aTargetLocalIndex);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 PartialSHistory::OnDeactive()
 {
   MOZ_ASSERT(mGroupedSHistory);
 
   mActive = nsIPartialSHistory::STATE_INACTIVE;
 
   // In-process case.
   nsCOMPtr<nsISHistory> shistory(GetSessionHistory());
   if (shistory) {
-    if (NS_FAILED(shistory->OnPartialSessionHistoryDeactive())) {
+    if (NS_FAILED(shistory->OnPartialSHistoryDeactive())) {
       return NS_ERROR_FAILURE;
     }
     return NS_OK;
   }
 
   // Cross-process case.
   RefPtr<TabParent> tabParent(GetTabParent());
   if (!tabParent) {
     // We have neither shistory nor tabParent?
     NS_WARNING("Unable to get shitory nor tabParent!");
     return NS_ERROR_UNEXPECTED;
   }
-  Unused << tabParent->SendNotifyPartialSessionHistoryDeactive();
+  Unused << tabParent->SendNotifyPartialSHistoryDeactive();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 PartialSHistory::GetActiveState(int32_t* aActive)
 {
   *aActive = mActive;
   return NS_OK;
--- a/dom/base/nsFrameLoader.cpp
+++ b/dom/base/nsFrameLoader.cpp
@@ -136,17 +136,17 @@ typedef FrameMetrics::ViewID ViewID;
 // we'd need to re-institute a fixed version of bug 98158.
 #define MAX_DEPTH_CONTENT_FRAMES 10
 
 NS_IMPL_CYCLE_COLLECTION(nsFrameLoader,
                          mDocShell,
                          mMessageManager,
                          mChildMessageManager,
                          mOpener,
-                         mPartialSessionHistory)
+                         mPartialSHistory)
 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsFrameLoader)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsFrameLoader)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsFrameLoader)
   NS_INTERFACE_MAP_ENTRY(nsIFrameLoader)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIFrameLoader)
   NS_INTERFACE_MAP_ENTRY(nsIWebBrowserPersistable)
 NS_INTERFACE_MAP_END
@@ -359,59 +359,59 @@ nsFrameLoader::MakePrerenderedLoaderActi
     nsresult rv = mDocShell->SetIsActive(true);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsFrameLoader::GetPartialSessionHistory(nsIPartialSHistory** aResult)
+nsFrameLoader::GetPartialSHistory(nsIPartialSHistory** aResult)
 {
-  if (mRemoteBrowser && !mPartialSessionHistory) {
+  if (mRemoteBrowser && !mPartialSHistory) {
     // For remote case we can lazy initialize PartialSHistory since
     // it doens't need to be registered as a listener to nsISHistory directly.
-    mPartialSessionHistory = new PartialSHistory(this);
+    mPartialSHistory = new PartialSHistory(this);
   }
 
-  nsCOMPtr<nsIPartialSHistory> partialHistory(mPartialSessionHistory);
+  nsCOMPtr<nsIPartialSHistory> partialHistory(mPartialSHistory);
   partialHistory.forget(aResult);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsFrameLoader::EnsureGroupedSHistory(nsIGroupedSHistory** aResult)
 {
   nsCOMPtr<nsIPartialSHistory> partialHistory;
-  GetPartialSessionHistory(getter_AddRefs(partialHistory));
+  GetPartialSHistory(getter_AddRefs(partialHistory));
   MOZ_ASSERT(partialHistory);
 
   nsCOMPtr<nsIGroupedSHistory> groupedHistory;
   partialHistory->GetGroupedSHistory(getter_AddRefs(groupedHistory));
   if (!groupedHistory) {
     groupedHistory = new GroupedSHistory();
-    groupedHistory->AppendPartialSessionHistory(partialHistory);
+    groupedHistory->AppendPartialSHistory(partialHistory);
 
 #ifdef DEBUG
     nsCOMPtr<nsIGroupedSHistory> test;
-    GetGroupedSessionHistory(getter_AddRefs(test));
+    GetGroupedSHistory(getter_AddRefs(test));
     MOZ_ASSERT(test == groupedHistory, "GroupedHistory must match");
 #endif
   }
 
   groupedHistory.forget(aResult);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsFrameLoader::GetGroupedSessionHistory(nsIGroupedSHistory** aResult)
+nsFrameLoader::GetGroupedSHistory(nsIGroupedSHistory** aResult)
 {
   nsCOMPtr<nsIGroupedSHistory> groupedSHistory;
-  if (mPartialSessionHistory) {
-    mPartialSessionHistory->GetGroupedSHistory(getter_AddRefs(groupedSHistory));
+  if (mPartialSHistory) {
+    mPartialSHistory->GetGroupedSHistory(getter_AddRefs(groupedSHistory));
   }
   groupedSHistory.forget(aResult);
   return NS_OK;
 }
 
 bool
 nsFrameLoader::SwapBrowsersAndNotify(nsFrameLoader* aOther)
 {
@@ -444,32 +444,32 @@ nsFrameLoader::SwapBrowsersAndNotify(nsF
                                      eventInit);
   event->SetTrusted(true);
   bool dummy;
   primaryContent->DispatchEvent(event, &dummy);
 
   return true;
 }
 
-class AppendPartialSessionHistoryAndSwapHelper : public PromiseNativeHandler
+class AppendPartialSHistoryAndSwapHelper : public PromiseNativeHandler
 {
 public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_CLASS(AppendPartialSessionHistoryAndSwapHelper)
-
-  AppendPartialSessionHistoryAndSwapHelper(nsFrameLoader* aThis,
-                                           nsFrameLoader* aOther,
-                                           Promise* aPromise)
+  NS_DECL_CYCLE_COLLECTION_CLASS(AppendPartialSHistoryAndSwapHelper)
+
+  AppendPartialSHistoryAndSwapHelper(nsFrameLoader* aThis,
+                                     nsFrameLoader* aOther,
+                                     Promise* aPromise)
     : mThis(aThis), mOther(aOther), mPromise(aPromise) {}
 
   void
   ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override
   {
     nsCOMPtr<nsIGroupedSHistory> otherGroupedHistory;
-    mOther->GetGroupedSessionHistory(getter_AddRefs(otherGroupedHistory));
+    mOther->GetGroupedSHistory(getter_AddRefs(otherGroupedHistory));
     MOZ_ASSERT(!otherGroupedHistory,
                "Cannot append a GroupedSHistory owner to another.");
     if (otherGroupedHistory) {
       mPromise->MaybeRejectWithUndefined();
       return;
     }
 
     // Append ourselves.
@@ -478,18 +478,18 @@ public:
     rv = mThis->EnsureGroupedSHistory(getter_AddRefs(groupedSHistory));
     if (NS_WARN_IF(NS_FAILED(rv))) {
       mPromise->MaybeRejectWithUndefined();
       return;
     }
 
     // Append the other.
     nsCOMPtr<nsIPartialSHistory> otherPartialSHistory;
-    MOZ_ALWAYS_SUCCEEDS(mOther->GetPartialSessionHistory(getter_AddRefs(otherPartialSHistory)));
-    rv = groupedSHistory->AppendPartialSessionHistory(otherPartialSHistory);
+    MOZ_ALWAYS_SUCCEEDS(mOther->GetPartialSHistory(getter_AddRefs(otherPartialSHistory)));
+    rv = groupedSHistory->AppendPartialSHistory(otherPartialSHistory);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       mPromise->MaybeRejectWithUndefined();
       return;
     }
 
     // Swap the browsers and fire the BrowserChangedProcess event.
     if (mThis->SwapBrowsersAndNotify(mOther)) {
       mPromise->MaybeResolveWithUndefined();
@@ -500,28 +500,28 @@ public:
 
   void
   RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override
   {
     mPromise->MaybeRejectWithUndefined();
   }
 
 private:
-  ~AppendPartialSessionHistoryAndSwapHelper() {}
+  ~AppendPartialSHistoryAndSwapHelper() {}
   RefPtr<nsFrameLoader> mThis;
   RefPtr<nsFrameLoader> mOther;
   RefPtr<Promise> mPromise;
 };
 
-NS_IMPL_CYCLE_COLLECTING_ADDREF(AppendPartialSessionHistoryAndSwapHelper)
-NS_IMPL_CYCLE_COLLECTING_RELEASE(AppendPartialSessionHistoryAndSwapHelper)
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(AppendPartialSessionHistoryAndSwapHelper)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(AppendPartialSHistoryAndSwapHelper)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(AppendPartialSHistoryAndSwapHelper)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(AppendPartialSHistoryAndSwapHelper)
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
-NS_IMPL_CYCLE_COLLECTION(AppendPartialSessionHistoryAndSwapHelper,
+NS_IMPL_CYCLE_COLLECTION(AppendPartialSHistoryAndSwapHelper,
                          mThis, mPromise)
 
 class RequestGroupedHistoryNavigationHelper : public PromiseNativeHandler
 {
 public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_CLASS(RequestGroupedHistoryNavigationHelper)
 
@@ -534,17 +534,17 @@ public:
   ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override
   {
     if (NS_WARN_IF(!mThis->mOwnerContent)) {
       mPromise->MaybeRejectWithUndefined();
       return;
     }
 
     nsCOMPtr<nsIGroupedSHistory> groupedSHistory;
-    mThis->GetGroupedSessionHistory(getter_AddRefs(groupedSHistory));
+    mThis->GetGroupedSHistory(getter_AddRefs(groupedSHistory));
     if (NS_WARN_IF(!groupedSHistory)) {
       mPromise->MaybeRejectWithUndefined();
       return;
     }
 
     // Navigate the loader to the new index
     nsCOMPtr<nsIFrameLoader> otherLoader;
     nsresult rv = groupedSHistory->GotoIndex(mGlobalIndex, getter_AddRefs(otherLoader));
@@ -668,17 +668,17 @@ nsFrameLoader::FireWillChangeProcessEven
   mBrowserChangingProcessBlockers = nullptr;
 
   ErrorResult rv;
   RefPtr<Promise> allPromise = Promise::All(global, blockers, rv);
   return allPromise.forget();
 }
 
 NS_IMETHODIMP
-nsFrameLoader::AppendPartialSessionHistoryAndSwap(nsIFrameLoader* aOther, nsISupports** aPromise)
+nsFrameLoader::AppendPartialSHistoryAndSwap(nsIFrameLoader* aOther, nsISupports** aPromise)
 {
   if (!aOther) {
     return NS_ERROR_INVALID_POINTER;
   }
 
   if (aOther == this) {
     return NS_OK;
   }
@@ -695,18 +695,18 @@ nsFrameLoader::AppendPartialSessionHisto
   ErrorResult rv;
   RefPtr<Promise> complete = Promise::Create(mOwnerContent->GetOwnerGlobal(), rv);
   if (NS_WARN_IF(rv.Failed())) {
     return rv.StealNSResult();
   }
 
   // Attach our handler to the ready promise, and make it fulfil the complete
   // promise when we are done.
-  RefPtr<AppendPartialSessionHistoryAndSwapHelper> helper =
-    new AppendPartialSessionHistoryAndSwapHelper(this, otherLoader, complete);
+  RefPtr<AppendPartialSHistoryAndSwapHelper> helper =
+    new AppendPartialSHistoryAndSwapHelper(this, otherLoader, complete);
   ready->AppendNativeHandler(helper);
   complete.forget(aPromise);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsFrameLoader::RequestGroupedHistoryNavigation(uint32_t aGlobalIndex, nsISupports** aPromise)
 {
@@ -2005,20 +2005,20 @@ nsFrameLoader::StartDestroy()
   if (mDocShell) {
     nsCOMPtr<nsPIDOMWindowOuter> win_private(mDocShell->GetWindow());
     if (win_private) {
       win_private->SetFrameElementInternal(nullptr);
     }
   }
 
   // Destroy the other frame loader owners now that we are being destroyed.
-  if (mPartialSessionHistory &&
-      mPartialSessionHistory->GetActiveState() == nsIPartialSHistory::STATE_ACTIVE) {
+  if (mPartialSHistory &&
+      mPartialSHistory->GetActiveState() == nsIPartialSHistory::STATE_ACTIVE) {
     nsCOMPtr<nsIGroupedSHistory> groupedSHistory;
-    GetGroupedSessionHistory(getter_AddRefs(groupedSHistory));
+    GetGroupedSHistory(getter_AddRefs(groupedSHistory));
     if (groupedSHistory) {
       NS_DispatchToCurrentThread(NS_NewRunnableFunction([groupedSHistory] () {
         groupedSHistory->CloseInactiveFrameLoaderOwners();
       }));
     }
   }
 
   nsCOMPtr<nsIRunnable> destroyRunnable = new nsFrameLoaderDestroyRunnable(this);
@@ -2386,19 +2386,19 @@ nsFrameLoader::MaybeCreateDocShell()
       do_CreateInstance(NS_SHISTORY_CONTRACTID, &rv);
     NS_ENSURE_SUCCESS(rv, rv);
 
     nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(mDocShell));
     webNav->SetSessionHistory(sessionHistory);
 
 
     if (GroupedSHistory::GroupedHistoryEnabled()) {
-      mPartialSessionHistory = new PartialSHistory(this);
-      nsCOMPtr<nsISHistoryListener> listener(do_QueryInterface(mPartialSessionHistory));
-      nsCOMPtr<nsIPartialSHistoryListener> partialListener(do_QueryInterface(mPartialSessionHistory));
+      mPartialSHistory = new PartialSHistory(this);
+      nsCOMPtr<nsISHistoryListener> listener(do_QueryInterface(mPartialSHistory));
+      nsCOMPtr<nsIPartialSHistoryListener> partialListener(do_QueryInterface(mPartialSHistory));
       sessionHistory->AddSHistoryListener(listener);
       sessionHistory->SetPartialSHistoryListener(partialListener);
     }
   }
 
   DocShellOriginAttributes attrs;
   if (docShell->ItemType() == mDocShell->ItemType()) {
     attrs = nsDocShell::Cast(docShell)->GetOriginAttributes();
--- a/dom/base/nsFrameLoader.h
+++ b/dom/base/nsFrameLoader.h
@@ -65,17 +65,17 @@ typedef struct _GtkWidget GtkWidget;
 
 class nsFrameLoader final : public nsIFrameLoader,
                             public nsIWebBrowserPersistable,
                             public nsStubMutationObserver,
                             public mozilla::dom::ipc::MessageManagerCallback
 {
   friend class AutoResetInShow;
   friend class AutoResetInFrameSwap;
-  friend class AppendPartialSessionHistoryAndSwapHelper;
+  friend class AppendPartialSHistoryAndSwapHelper;
   friend class RequestGroupedHistoryNavigationHelper;
   typedef mozilla::dom::PBrowserParent PBrowserParent;
   typedef mozilla::dom::TabParent TabParent;
   typedef mozilla::layout::RenderFrameParent RenderFrameParent;
 
 public:
   static nsFrameLoader* Create(mozilla::dom::Element* aOwner,
                                nsPIDOMWindowOuter* aOpener,
@@ -345,17 +345,17 @@ private:
 
   // See nsIFrameLoader.idl. EVENT_MODE_NORMAL_DISPATCH automatically
   // forwards some input events to out-of-process content.
   uint32_t mEventMode;
 
   // Holds the last known size of the frame.
   mozilla::ScreenIntSize mLazySize;
 
-  nsCOMPtr<nsIPartialSHistory> mPartialSessionHistory;
+  nsCOMPtr<nsIPartialSHistory> mPartialSHistory;
 
   // A stack-maintained reference to an array of promises which are blocking
   // grouped history navigation
   nsTArray<RefPtr<mozilla::dom::Promise>>* mBrowserChangingProcessBlockers;
 
   bool mIsPrerendered : 1;
   bool mDepthTooGreat : 1;
   bool mIsTopLevelContent : 1;
--- a/dom/base/nsIFrameLoader.idl
+++ b/dom/base/nsIFrameLoader.idl
@@ -63,17 +63,17 @@ interface nsIFrameLoader : nsISupports
    */
   void makePrerenderedLoaderActive();
 
   /**
    * Append partial session history from another frame loader.
    *
    * @return A promise which will be resolved when the navigation is complete.
    */
-  nsISupports appendPartialSessionHistoryAndSwap(in nsIFrameLoader aOther);
+  nsISupports appendPartialSHistoryAndSwap(in nsIFrameLoader aOther);
 
   /**
    * If grouped session history is applied, use this function to navigate to
    * an entry of session history object of another frameloader.
    *
    * @return A promise which will be resolved when the navigation is complete.
    */
   nsISupports requestGroupedHistoryNavigation(in unsigned long aGlobalIndex);
@@ -251,23 +251,23 @@ interface nsIFrameLoader : nsISupports
    * should only be used in asynchronous APIs where values are not guaranteed
    * to be up-to-date when received.
    */
   readonly attribute unsigned long lazyHeight;
 
   /**
    * The partial session history.
    */
-  readonly attribute nsIPartialSHistory partialSessionHistory;
+  readonly attribute nsIPartialSHistory partialSHistory;
 
   /**
    * The grouped session history composed of multiple session history objects
    * across root docshells.
    */
-  readonly attribute nsIGroupedSHistory groupedSessionHistory;
+  readonly attribute nsIGroupedSHistory groupedSHistory;
 
   /**
    * Is `true` if the frameloader is dead (destroy has been called on it)
    */
   [infallible] readonly attribute boolean isDead;
 };
 
 %{C++
--- a/dom/base/test/chrome/window_groupedSHistory.xul
+++ b/dom/base/test/chrome/window_groupedSHistory.xul
@@ -555,17 +555,17 @@ https://bugzilla.mozilla.org/show_bug.cg
       // after calling PartialSHistory::OnActive(). Therefore the message could
       // only be handled after swapping.
       promises.push(BrowserTestUtils.waitForMessage(b1.messageManager, 'Content:LocationChange'));
     }
 
     promises.push(Promise.resolve().then(() => {
       let f1 = b1.QueryInterface(Components.interfaces.nsIFrameLoaderOwner).frameLoader;
       let f2 = b2.QueryInterface(Components.interfaces.nsIFrameLoaderOwner).frameLoader;
-      return f1.appendPartialSessionHistoryAndSwap(f2);
+      return f1.appendPartialSHistoryAndSwap(f2);
     }));
 
     return Promise.all(promises);
   }
 
   function wrapHistoryNavFn(browser, navFn, prevTitle, nextTitle, browserToSwap) {
     let promises = [];
 
@@ -606,17 +606,17 @@ https://bugzilla.mozilla.org/show_bug.cg
   }
 
   function verifyBrowser(browser, title, index, length, canGoBack, canGoForward,
                          partial, offset = 0, globalLength = length, bfcached = false) {
     is(browser.canGoBack, canGoBack, 'check browser.canGoBack');
     is(browser.canGoForward, canGoForward, 'check browser.canGoForward');
     if (partial) {
       let frameLoader = browser.QueryInterface(Components.interfaces.nsIFrameLoaderOwner).frameLoader;
-      is(frameLoader.groupedSessionHistory.count, globalLength, 'check groupedSHistory.count');
+      is(frameLoader.groupedSHistory.count, globalLength, 'check groupedSHistory.count');
     }
 
     return ContentTask.spawn(browser,
         { title, index, length, canGoBack, canGoForward, partial, offset, globalLength, bfcached },
         ({ title, index, length, canGoBack, canGoForward, partial, offset, globalLength, bfcached }) => {
       let webNav = docShell.QueryInterface(Ci.nsIWebNavigation);
       let shistory = webNav.sessionHistory;
       is(webNav.canGoBack, canGoBack, 'check webNav.canGoBack');
--- a/dom/ipc/PBrowser.ipdl
+++ b/dom/ipc/PBrowser.ipdl
@@ -879,34 +879,34 @@ child:
 
     /**
      * Called when the session history of this particular PBrowser has been
      * attached to a grouped session history.
      *
      * @param aOffset           The number of entries in the grouped session
      *                          history before this session history object.
      */
-    async NotifyAttachGroupedSessionHistory(uint32_t aOffset);
+    async NotifyAttachGroupedSHistory(uint32_t aOffset);
 
     /**
      * Notify that the session history associated to this PBrowser has become
      * the active history in the grouped session history.
      *
      * @param aGlobalLength      The up-to-date number of entries in the grouped
      *                           session history.
      * @param aTargetLocalIndex  The target local index to navigate to.
      */
-    async NotifyPartialSessionHistoryActive(uint32_t aGlobalLength,
-                                            uint32_t aTargetLocalIndex);
+    async NotifyPartialSHistoryActive(uint32_t aGlobalLength,
+                                      uint32_t aTargetLocalIndex);
 
     /**
      * Notify that the session history asssociates to this PBrowser has become
      * an inactive history in the grouped session history.
      */
-    async NotifyPartialSessionHistoryDeactive();
+    async NotifyPartialSHistoryDeactive();
 
     /**
      * Tell the child that it is a fresh process created for a Large-Allocation
      * load.
      */
     async SetFreshProcess();
 
 /*
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -1496,58 +1496,58 @@ TabChild::RecvStopIMEStateManagement()
 mozilla::ipc::IPCResult
 TabChild::RecvMenuKeyboardListenerInstalled(const bool& aInstalled)
 {
   IMEStateManager::OnInstalledMenuKeyboardListener(aInstalled);
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
-TabChild::RecvNotifyAttachGroupedSessionHistory(const uint32_t& aOffset)
+TabChild::RecvNotifyAttachGroupedSHistory(const uint32_t& aOffset)
 {
   // nsISHistory uses int32_t
   if (NS_WARN_IF(aOffset > INT32_MAX)) {
     return IPC_FAIL_NO_REASON(this);
   }
 
   nsCOMPtr<nsISHistory> shistory = GetRelatedSHistory();
   NS_ENSURE_TRUE(shistory, IPC_FAIL_NO_REASON(this));
 
-  if (NS_FAILED(shistory->OnAttachGroupedSessionHistory(aOffset))) {
+  if (NS_FAILED(shistory->OnAttachGroupedSHistory(aOffset))) {
     return IPC_FAIL_NO_REASON(this);
   }
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
-TabChild::RecvNotifyPartialSessionHistoryActive(const uint32_t& aGlobalLength,
-                                                const uint32_t& aTargetLocalIndex)
+TabChild::RecvNotifyPartialSHistoryActive(const uint32_t& aGlobalLength,
+                                          const uint32_t& aTargetLocalIndex)
 {
   // nsISHistory uses int32_t
   if (NS_WARN_IF(aGlobalLength > INT32_MAX || aTargetLocalIndex > INT32_MAX)) {
     return IPC_FAIL_NO_REASON(this);
   }
 
   nsCOMPtr<nsISHistory> shistory = GetRelatedSHistory();
   NS_ENSURE_TRUE(shistory, IPC_FAIL_NO_REASON(this));
 
-  if (NS_FAILED(shistory->OnPartialSessionHistoryActive(aGlobalLength,
-                                                        aTargetLocalIndex))) {
+  if (NS_FAILED(shistory->OnPartialSHistoryActive(aGlobalLength,
+                                                  aTargetLocalIndex))) {
     return IPC_FAIL_NO_REASON(this);
   }
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
-TabChild::RecvNotifyPartialSessionHistoryDeactive()
+TabChild::RecvNotifyPartialSHistoryDeactive()
 {
   nsCOMPtr<nsISHistory> shistory = GetRelatedSHistory();
   NS_ENSURE_TRUE(shistory, IPC_FAIL_NO_REASON(this));
 
-  if (NS_FAILED(shistory->OnPartialSessionHistoryDeactive())) {
+  if (NS_FAILED(shistory->OnPartialSHistoryDeactive())) {
     return IPC_FAIL_NO_REASON(this);
   }
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 TabChild::RecvMouseEvent(const nsString& aType,
                          const float&    aX,
--- a/dom/ipc/TabChild.h
+++ b/dom/ipc/TabChild.h
@@ -690,22 +690,22 @@ protected:
   virtual mozilla::ipc::IPCResult RecvSetKeyboardIndicators(const UIStateChangeType& aShowAccelerators,
                                                             const UIStateChangeType& aShowFocusRings) override;
 
   virtual mozilla::ipc::IPCResult RecvStopIMEStateManagement() override;
 
   virtual mozilla::ipc::IPCResult RecvMenuKeyboardListenerInstalled(
     const bool& aInstalled) override;
 
-  virtual mozilla::ipc::IPCResult RecvNotifyAttachGroupedSessionHistory(const uint32_t& aOffset) override;
+  virtual mozilla::ipc::IPCResult RecvNotifyAttachGroupedSHistory(const uint32_t& aOffset) override;
 
-  virtual mozilla::ipc::IPCResult RecvNotifyPartialSessionHistoryActive(const uint32_t& aGlobalLength,
-                                                                        const uint32_t& aTargetLocalIndex) override;
+  virtual mozilla::ipc::IPCResult RecvNotifyPartialSHistoryActive(const uint32_t& aGlobalLength,
+                                                                  const uint32_t& aTargetLocalIndex) override;
 
-  virtual mozilla::ipc::IPCResult RecvNotifyPartialSessionHistoryDeactive() override;
+  virtual mozilla::ipc::IPCResult RecvNotifyPartialSHistoryDeactive() override;
 
   virtual mozilla::ipc::IPCResult RecvSetFreshProcess() override;
 
 private:
   void HandleDoubleTap(const CSSPoint& aPoint, const Modifiers& aModifiers,
                        const ScrollableLayerGuid& aGuid);
 
   // Notify others that our TabContext has been updated.
--- a/dom/ipc/TabParent.cpp
+++ b/dom/ipc/TabParent.cpp
@@ -3213,17 +3213,17 @@ TabParent::RecvSHistoryUpdate(const uint
   RefPtr<nsFrameLoader> frameLoader(GetFrameLoader());
   if (!frameLoader) {
     // FrameLoader can be nullptr if the it is destroying.
     // In this case session history change can simply be ignored.
     return IPC_OK();
   }
 
   nsCOMPtr<nsIPartialSHistory> partialHistory;
-  frameLoader->GetPartialSessionHistory(getter_AddRefs(partialHistory));
+  frameLoader->GetPartialSHistory(getter_AddRefs(partialHistory));
   if (!partialHistory) {
     // PartialSHistory is not enabled
     return IPC_OK();
   }
 
   partialHistory->HandleSHistoryUpdate(aCount, aLocalIndex, aTruncate);
   return IPC_OK();
 }
--- a/dom/tests/browser/browser_prerendering.js
+++ b/dom/tests/browser/browser_prerendering.js
@@ -77,17 +77,17 @@ add_task(function* () {
   yield awaitProcessChange(tab.linkedBrowser);
 
   yield ContentTask.spawn(tab.linkedBrowser, null, function*() {
     is(content.document.location.toString(), "data:text/html,b");
     is(content.document.visibilityState, "visible",
        "VisibilityState of formerly prerendered window must be visible");
   });
 
-  let groupedSHistory = tab.linkedBrowser.frameLoader.groupedSessionHistory;
+  let groupedSHistory = tab.linkedBrowser.frameLoader.groupedSHistory;
   is(groupedSHistory.count, 2, "Check total length of grouped shistory.");
   is(gBrowser.tabs.length, 3, "Check number of opened tabs.");
 
   // We don't touch the about:blank tab opened when browser mochitest runs.
   // The tabs under test are the other 2 tabs, so we're expecting 2 TabClose.
   let closed = new Promise(resolve => {
     let seen = 0;
     gBrowser.tabContainer.addEventListener("TabClose", function f() {