diff options
Diffstat (limited to 'toolkit/components/sessionstore')
28 files changed, 5460 insertions, 0 deletions
diff --git a/toolkit/components/sessionstore/BrowserSessionStore.cpp b/toolkit/components/sessionstore/BrowserSessionStore.cpp new file mode 100644 index 0000000000..f4da9646b2 --- /dev/null +++ b/toolkit/components/sessionstore/BrowserSessionStore.cpp @@ -0,0 +1,292 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/BrowserSessionStore.h" +#include <algorithm> +#include <cstdint> +#include <functional> + +#include "mozilla/AlreadyAddRefed.h" +#include "mozilla/Assertions.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/IntegerRange.h" +#include "mozilla/RefPtr.h" +#include "mozilla/ScopeExit.h" +#include "mozilla/StaticPtr.h" + +#include "mozilla/dom/BrowserSessionStoreBinding.h" +#include "mozilla/dom/CanonicalBrowsingContext.h" +#include "mozilla/dom/SessionStoreFormData.h" +#include "mozilla/dom/SessionStoreScrollData.h" +#include "mozilla/dom/WindowGlobalParent.h" + +#include "nsTHashMap.h" +#include "nsHashtablesFwd.h" + +#include "js/RootingAPI.h" + +using namespace mozilla; +using namespace mozilla::dom; + +static StaticAutoPtr<nsTHashMap<nsUint64HashKey, BrowserSessionStore*>> + sSessionStore; + +NS_IMPL_CYCLE_COLLECTION(BrowserSessionStore, mBrowsingContext, mFormData, + mScrollData) + +/* static */ +already_AddRefed<BrowserSessionStore> BrowserSessionStore::GetOrCreate( + CanonicalBrowsingContext* aBrowsingContext) { + if (!aBrowsingContext->IsTop()) { + return nullptr; + } + + if (!sSessionStore) { + sSessionStore = new nsTHashMap<nsUint64HashKey, BrowserSessionStore*>(); + ClearOnShutdown(&sSessionStore); + } + + return do_AddRef(sSessionStore->LookupOrInsertWith( + aBrowsingContext->Id(), + [&] { return new BrowserSessionStore(aBrowsingContext); })); +} + +BrowserSessionStore::BrowserSessionStore( + CanonicalBrowsingContext* aBrowsingContext) + : mBrowsingContext(aBrowsingContext) {} + +SessionStoreFormData* BrowserSessionStore::GetFormdata() { return mFormData; } + +SessionStoreScrollData* BrowserSessionStore::GetScroll() { return mScrollData; } + +static bool ShouldUpdateSessionStore(CanonicalBrowsingContext* aBrowsingContext, + uint32_t aEpoch) { + if (!aBrowsingContext) { + return false; + } + + if (aBrowsingContext->Top()->GetSessionStoreEpoch() != aEpoch) { + return false; + } + + if (aBrowsingContext->IsReplaced()) { + return false; + } + + if (aBrowsingContext->IsDynamic()) { + return false; + } + + return true; +} + +// With GetOrCreate we can create either of the weak fields: +// WeakPtr<SessionStoreFormData> mFormdata; +// WeakPtr<SessionStoreScrollData> mScroll; +// in CanonicalBrowsingContext. If one already exists, then we return that. +template <typename T, WeakPtr<T>& (CanonicalBrowsingContext::*GetWeakRef)()> +static already_AddRefed<T> GetOrCreateEntry( + CanonicalBrowsingContext* aBrowsingContext) { + typename T::LocationType& location = (aBrowsingContext->*GetWeakRef)(); + RefPtr<T> entry = location.get(); + if (!entry) { + entry = MakeRefPtr<T>(); + location = entry; + } + + return entry.forget(); +} + +// With InsertEntry we can insert an entry in the session store data tree in +// either of the weak fields: +// WeakPtr<SessionStoreFormData> mFormdata; +// WeakPtr<SessionStoreScrollData> mScroll; +// in CanonicalBrowsingContext. If an entry is inserted where there is no parent +// entry, a spine of entries will be created until one is found, or we reach the +// top browsing context. +template <typename T> +void InsertEntry(BrowsingContext* aBrowsingContext, T* aParent, T* aUpdate) { + int32_t offset = aBrowsingContext->ChildOffset(); + if (offset < 0) { + return; + } + + aParent->ClearCachedChildren(); + + auto& children = aParent->Children(); + + children.EnsureLengthAtLeast(offset + 1); + if (children[offset] && !aBrowsingContext->Children().IsEmpty()) { + children[offset]->ClearCachedChildren(); + aUpdate->ClearCachedChildren(); + } + + children[offset] = aUpdate; +} + +// With RemoveEntry we can remove an entry in the session store data tree in +// either of the weak fields: +// WeakPtr<SessionStoreFormData> mFormdata; +// WeakPtr<SessionStoreScrollData> mScroll; +// in CanonicalBrowsingContext. If an entry is removed, where its parent doesn't +// contain data, we'll remove the parent and repeat until we either find an +// entry with data or reach the top browsing context. +template <typename T> +void RemoveEntry(BrowsingContext* aBrowsingContext, T* aParent) { + int32_t offset = aBrowsingContext->ChildOffset(); + if (offset < 0) { + return; + } + + if (!aParent) { + return; + } + + aParent->ClearCachedChildren(); + + auto& children = aParent->Children(); + size_t length = children.Length(); + if (children.Length() <= static_cast<size_t>(offset)) { + // The children array doesn't extend to offset. + return; + } + + if (static_cast<size_t>(offset) < length - 1) { + // offset is before the last item in the children array. + children[offset] = nullptr; + return; + } + + // offset is the last item, find the first non-null item before it + // and remove anything after that item. + while (offset > 0 && !children[offset - 1]) { + --offset; + } + + children.TruncateLength(offset); +} + +// With UpdateSessionStoreField we can update an entry in the session store +// data tree in either of the weak fields: +// WeakPtr<SessionStoreFormData> mFormdata; +// WeakPtr<SessionStoreScrollData> mScroll; +// in CanonicalBrowsingContext. UpdateSessionStoreField uses the above +// functions, `GetOrCreateEntry`, `InsertEntry` and `RemoveEntry` to operate on +// the weak fields. We return the top-level entry attached to the top browsing +// context through `aEntry`. If the entire browsing context tree contains no +// session store data this will be set to nullptr. +template <typename T, WeakPtr<T>& (CanonicalBrowsingContext::*GetWeakRef)()> +void UpdateSessionStoreField(CanonicalBrowsingContext* aBrowsingContext, + const typename T::CollectedType& aUpdate, + T** aEntry) { + RefPtr<T> currentEntry; + + if (T::HasData(aUpdate)) { + currentEntry = GetOrCreateEntry<T, GetWeakRef>(aBrowsingContext); + currentEntry->Update(aUpdate); + + CanonicalBrowsingContext* currentBrowsingContext = aBrowsingContext; + while (CanonicalBrowsingContext* parent = + currentBrowsingContext->GetParent()) { + WeakPtr<T>& parentEntry = (parent->*GetWeakRef)(); + if (parentEntry) { + InsertEntry(aBrowsingContext, parentEntry.get(), currentEntry.get()); + break; + } + + RefPtr<T> entry = GetOrCreateEntry<T, GetWeakRef>(parent); + InsertEntry(currentBrowsingContext, entry.get(), currentEntry.get()); + + currentEntry = entry; + currentBrowsingContext = parent; + } + + currentEntry = (aBrowsingContext->Top()->*GetWeakRef)().get(); + } else if ((currentEntry = (aBrowsingContext->*GetWeakRef)())) { + currentEntry->Update(aUpdate); + + CanonicalBrowsingContext* currentBrowsingContext = aBrowsingContext; + while (CanonicalBrowsingContext* parent = + currentBrowsingContext->GetParent()) { + if (!currentEntry || !currentEntry->IsEmpty()) { + break; + } + + T* parentEntry = (parent->*GetWeakRef)().get(); + RemoveEntry(currentBrowsingContext, parentEntry); + + currentEntry = parentEntry; + currentBrowsingContext = parent; + } + + if (currentEntry && currentEntry->IsEmpty()) { + currentEntry = nullptr; + } else { + currentEntry = (aBrowsingContext->Top()->*GetWeakRef)().get(); + } + } else { + currentEntry = (aBrowsingContext->Top()->*GetWeakRef)().get(); + } + + *aEntry = currentEntry.forget().take(); +} + +void BrowserSessionStore::UpdateSessionStore( + CanonicalBrowsingContext* aBrowsingContext, + const Maybe<sessionstore::FormData>& aFormData, + const Maybe<nsPoint>& aScrollPosition, uint32_t aEpoch) { + if (!aFormData && !aScrollPosition) { + return; + } + + if (!ShouldUpdateSessionStore(aBrowsingContext, aEpoch)) { + return; + } + + if (aFormData) { + UpdateSessionStoreField< + SessionStoreFormData, + &CanonicalBrowsingContext::GetSessionStoreFormDataRef>( + aBrowsingContext, *aFormData, getter_AddRefs(mFormData)); + } + + if (aScrollPosition) { + UpdateSessionStoreField< + SessionStoreScrollData, + &CanonicalBrowsingContext::GetSessionStoreScrollDataRef>( + aBrowsingContext, *aScrollPosition, getter_AddRefs(mScrollData)); + } +} + +void BrowserSessionStore::RemoveSessionStore( + CanonicalBrowsingContext* aBrowsingContext) { + if (!aBrowsingContext) { + return; + } + + CanonicalBrowsingContext* parentContext = aBrowsingContext->GetParent(); + + if (parentContext) { + RemoveEntry(aBrowsingContext, + parentContext->GetSessionStoreFormDataRef().get()); + + RemoveEntry(aBrowsingContext, + parentContext->GetSessionStoreScrollDataRef().get()); + + return; + } + + if (aBrowsingContext->IsTop()) { + mFormData = nullptr; + mScrollData = nullptr; + } +} + +BrowserSessionStore::~BrowserSessionStore() { + if (sSessionStore) { + sSessionStore->Remove(mBrowsingContext->Id()); + } +} diff --git a/toolkit/components/sessionstore/BrowserSessionStore.h b/toolkit/components/sessionstore/BrowserSessionStore.h new file mode 100644 index 0000000000..011e7673ec --- /dev/null +++ b/toolkit/components/sessionstore/BrowserSessionStore.h @@ -0,0 +1,57 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_SessionStore_h +#define mozilla_dom_SessionStore_h + +#include "nsWrapperCache.h" + +#include "mozilla/Maybe.h" + +struct nsPoint; + +namespace mozilla::dom { + +class CanonicalBrowsingContext; +class GlobalObject; +class SessionStoreFormData; +class SessionStoreScrollData; +class WindowGlobalParent; + +namespace sessionstore { +class FormData; +} + +class BrowserSessionStore final { + public: + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(BrowserSessionStore) + NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(BrowserSessionStore) + + static already_AddRefed<BrowserSessionStore> GetOrCreate( + CanonicalBrowsingContext* aBrowsingContext); + + SessionStoreFormData* GetFormdata(); + SessionStoreScrollData* GetScroll(); + + void UpdateSessionStore(CanonicalBrowsingContext* aBrowsingContext, + const Maybe<sessionstore::FormData>& aFormData, + const Maybe<nsPoint>& aScrollPosition, + uint32_t aEpoch); + + void RemoveSessionStore(CanonicalBrowsingContext* aBrowsingContext); + + private: + explicit BrowserSessionStore(CanonicalBrowsingContext* aBrowsingContext); + virtual ~BrowserSessionStore(); + + RefPtr<CanonicalBrowsingContext> mBrowsingContext; + RefPtr<SessionStoreFormData> mFormData; + RefPtr<SessionStoreScrollData> mScrollData; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_SessionStore_h diff --git a/toolkit/components/sessionstore/PSessionStore.ipdl b/toolkit/components/sessionstore/PSessionStore.ipdl new file mode 100644 index 0000000000..4b7bb48849 --- /dev/null +++ b/toolkit/components/sessionstore/PSessionStore.ipdl @@ -0,0 +1,63 @@ +/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */ +/* vim: set sw=2 ts=8 et tw=80 ft=cpp : */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +include "mozilla/GfxMessageUtils.h"; + +include protocol PBrowser; +include protocol PInProcess; +include SessionStoreTypes; + +using mozilla::dom::MaybeDiscardedBrowsingContext from "mozilla/dom/BrowsingContext.h"; +using mozilla::dom::MaybeSessionStoreZoom from "mozilla/dom/SessionStoreScrollData.h"; + +namespace mozilla { +namespace dom { + +/** + * The PSessionStore actor handles collection of session store data from content + * type documents. It can be used both in a content process and in the parent + * process. In particular it solves the problem of handling incremental updates + * to the session store, since we're collecting from potentially several content + * processes. + */ +async protocol PSessionStore +{ + manager PBrowser or PInProcess; + +parent: + /** + * Sends data to be stored and instructions to the session store to + * potentially collect data in the parent. This is data that is not + * collected incrementally. + */ + async SessionStoreUpdate( + nsCString? aDocShellCaps, bool? aPrivateMode, MaybeSessionStoreZoom aZoom, + bool aNeedCollectSHistory, uint32_t aEpoch); + + /** + * Sends data to be stored to the session store. The collected data + * is all the collected changed data from all the in-process documents + * in the process in which the SessionStoreChild actor lives. + */ + async IncrementalSessionStoreUpdate( + MaybeDiscardedBrowsingContext aBrowsingContext, FormData? aFormData, + nsPoint? aScrollPosition, uint32_t aEpoch); + + /** + * Drop all the collected data associated with the provided browsing + * context. + */ + async ResetSessionStore( + MaybeDiscardedBrowsingContext aBrowsingContext, uint32_t aEpoch); + +child: + async FlushTabState() returns(bool aHadContext); + + async __delete__(); +}; + +} // namespace dom +} // namespace mozilla diff --git a/toolkit/components/sessionstore/RestoreTabContentObserver.cpp b/toolkit/components/sessionstore/RestoreTabContentObserver.cpp new file mode 100644 index 0000000000..b0dda66ff0 --- /dev/null +++ b/toolkit/components/sessionstore/RestoreTabContentObserver.cpp @@ -0,0 +1,112 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +#include "mozilla/dom/BrowsingContext.h" +#include "mozilla/dom/CanonicalBrowsingContext.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/WindowGlobalChild.h" +#include "mozilla/dom/WindowGlobalParent.h" +#include "mozilla/Services.h" +#include "nsIObserverService.h" +#include "nsIURI.h" +#include "nsNetUtil.h" +#include "nsPIDOMWindow.h" +#include "nsReadableUtils.h" +#include "nsThreadUtils.h" +#include "RestoreTabContentObserver.h" + +using namespace mozilla::dom; + +NS_IMPL_ISUPPORTS(RestoreTabContentObserver, nsIObserver) + +const char* const kAboutReaderTopic = "AboutReader:Ready"; +const char* const kContentDocumentLoaded = "content-document-loaded"; +const char* const kChromeDocumentLoaded = "chrome-document-loaded"; + +/* static */ +void RestoreTabContentObserver::Initialize() { + MOZ_ASSERT(!gRestoreTabContentObserver); + MOZ_ASSERT(NS_IsMainThread()); + + RefPtr<RestoreTabContentObserver> observer = new RestoreTabContentObserver(); + + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (NS_WARN_IF(!obs)) { + return; + } + + obs->AddObserver(observer, kAboutReaderTopic, false); + obs->AddObserver(observer, kContentDocumentLoaded, false); + obs->AddObserver(observer, kChromeDocumentLoaded, false); + + gRestoreTabContentObserver = observer; +} + +/* static */ +void RestoreTabContentObserver::Shutdown() { + MOZ_ASSERT(NS_IsMainThread()); + + if (!gRestoreTabContentObserver) { + return; + } + + RefPtr<RestoreTabContentObserver> observer = gRestoreTabContentObserver; + gRestoreTabContentObserver = nullptr; + + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (!obs) { + return; + } + + obs->RemoveObserver(observer, kAboutReaderTopic); + obs->RemoveObserver(observer, kContentDocumentLoaded); + obs->RemoveObserver(observer, kChromeDocumentLoaded); +} + +NS_IMETHODIMP +RestoreTabContentObserver::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + nsCOMPtr<nsPIDOMWindowInner> inner; + if (!strcmp(aTopic, kAboutReaderTopic)) { + inner = do_QueryInterface(aSubject); + } else if (!strcmp(aTopic, kContentDocumentLoaded) || + !strcmp(aTopic, kChromeDocumentLoaded)) { + nsCOMPtr<Document> doc = do_QueryInterface(aSubject); + inner = doc ? doc->GetInnerWindow() : nullptr; + } + if (!inner) { + return NS_OK; + } + + nsCOMPtr<nsIURI> uri = inner->GetDocumentURI(); + if (!uri) { + return NS_OK; + } + + // We'll handle loading about:reader with "AboutReader:Ready" + // rather than "content-document-loaded". + if (uri->SchemeIs("about") && + StringBeginsWith(uri->GetSpecOrDefault(), "about:reader"_ns) && + strcmp(aTopic, kAboutReaderTopic) != 0) { + return NS_OK; + } + + RefPtr<BrowsingContext> bc = inner->GetBrowsingContext(); + if (!bc || !bc->Top()->GetHasRestoreData()) { + return NS_OK; + } + if (XRE_IsParentProcess()) { + if (WindowGlobalParent* wgp = bc->Canonical()->GetCurrentWindowGlobal()) { + bc->Canonical()->Top()->RequestRestoreTabContent(wgp); + } + } else if (WindowContext* windowContext = bc->GetCurrentWindowContext()) { + if (WindowGlobalChild* wgc = windowContext->GetWindowGlobalChild()) { + wgc->SendRequestRestoreTabContent(); + } + } + return NS_OK; +} + +mozilla::StaticRefPtr<RestoreTabContentObserver> + RestoreTabContentObserver::gRestoreTabContentObserver; diff --git a/toolkit/components/sessionstore/RestoreTabContentObserver.h b/toolkit/components/sessionstore/RestoreTabContentObserver.h new file mode 100644 index 0000000000..edab379a55 --- /dev/null +++ b/toolkit/components/sessionstore/RestoreTabContentObserver.h @@ -0,0 +1,34 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_RestoreTabContentObserver_h +#define mozilla_dom_RestoreTabContentObserver_h + +#include "mozilla/StaticPtr.h" +#include "nsIObserver.h" +#include "nsISupportsImpl.h" + +namespace mozilla { +namespace dom { + +// An observer for restoring session store data at a correct time. +class RestoreTabContentObserver final : public nsIObserver { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIOBSERVER + + static void Initialize(); + static void Shutdown(); + + private: + RestoreTabContentObserver() = default; + + virtual ~RestoreTabContentObserver() = default; + static mozilla::StaticRefPtr<RestoreTabContentObserver> + gRestoreTabContentObserver; +}; +} // namespace dom +} // namespace mozilla +#endif // mozilla_dom_RestoreTabContentObserver_h diff --git a/toolkit/components/sessionstore/SessionStoreChangeListener.cpp b/toolkit/components/sessionstore/SessionStoreChangeListener.cpp new file mode 100644 index 0000000000..1418774a37 --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreChangeListener.cpp @@ -0,0 +1,393 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/SessionStoreChangeListener.h" + +#include "mozilla/dom/BrowsingContext.h" +#include "mozilla/dom/Element.h" +#include "mozilla/dom/Event.h" +#include "mozilla/dom/EventTarget.h" +#include "mozilla/dom/SessionStoreChild.h" +#include "mozilla/dom/SessionStoreUtils.h" +#include "mozilla/dom/WindowGlobalChild.h" +#include "mozilla/Preferences.h" +#include "mozilla/PresShell.h" +#include "mozilla/StaticPrefs_browser.h" + +#include "nsBaseHashtable.h" +#include "nsDocShell.h" +#include "nsGenericHTMLElement.h" +#include "nsIXULRuntime.h" +#include "nsPIDOMWindow.h" +#include "nsTHashMap.h" +#include "nsTHashtable.h" +#include "nsLayoutUtils.h" + +using namespace mozilla; +using namespace mozilla::dom; + +namespace { +constexpr auto kInput = u"input"_ns; +constexpr auto kScroll = u"mozvisualscroll"_ns; +constexpr auto kResize = u"mozvisualresize"_ns; + +static constexpr char kNoAutoUpdates[] = + "browser.sessionstore.debug.no_auto_updates"; +static constexpr char kInterval[] = "browser.sessionstore.interval"; +static const char* kObservedPrefs[] = {kNoAutoUpdates, kInterval, nullptr}; +} // namespace + +inline void ImplCycleCollectionUnlink( + SessionStoreChangeListener::SessionStoreChangeTable& aField) { + aField.Clear(); +} + +inline void ImplCycleCollectionTraverse( + nsCycleCollectionTraversalCallback& aCallback, + const SessionStoreChangeListener::SessionStoreChangeTable& aField, + const char* aName, uint32_t aFlags = 0) { + for (auto iter = aField.ConstIter(); !iter.Done(); iter.Next()) { + CycleCollectionNoteChild(aCallback, iter.Key(), aName, aFlags); + } +} + +NS_IMPL_CYCLE_COLLECTION(SessionStoreChangeListener, mBrowsingContext, + mCurrentEventTarget, mSessionStoreChild, + mSessionStoreChanges) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SessionStoreChangeListener) + NS_INTERFACE_MAP_ENTRY(nsINamed) + NS_INTERFACE_MAP_ENTRY(nsIObserver) + NS_INTERFACE_MAP_ENTRY(nsITimerCallback) + NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIObserver) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(SessionStoreChangeListener) +NS_IMPL_CYCLE_COLLECTING_RELEASE(SessionStoreChangeListener) + +NS_IMETHODIMP +SessionStoreChangeListener::GetName(nsACString& aName) { + aName.AssignLiteral("SessionStoreChangeListener"); + return NS_OK; +} + +NS_IMETHODIMP +SessionStoreChangeListener::Notify(nsITimer* aTimer) { + FlushSessionStore(); + return NS_OK; +} + +NS_IMETHODIMP +SessionStoreChangeListener::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + FlushSessionStore(); + return NS_OK; +} + +NS_IMETHODIMP +SessionStoreChangeListener::HandleEvent(dom::Event* aEvent) { + EventTarget* target = aEvent->GetTarget(); + if (!target) { + return NS_OK; + } + + nsIGlobalObject* global = target->GetOwnerGlobal(); + if (!global) { + return NS_OK; + } + + nsPIDOMWindowInner* inner = global->AsInnerWindow(); + if (!inner) { + return NS_OK; + } + + WindowContext* windowContext = inner->GetWindowContext(); + if (!windowContext) { + return NS_OK; + } + + BrowsingContext* browsingContext = windowContext->GetBrowsingContext(); + if (!browsingContext) { + return NS_OK; + } + + if (browsingContext->IsDynamic()) { + return NS_OK; + } + + nsAutoString eventType; + aEvent->GetType(eventType); + + if (eventType == kInput) { + RecordChange(windowContext, Change::Input); + } else if (eventType == kScroll) { + RecordChange(windowContext, Change::Scroll); + } else if (eventType == kResize && browsingContext->IsTop()) { + RecordChange(windowContext, Change::Resize); + } + return NS_OK; +} + +/* static */ already_AddRefed<SessionStoreChangeListener> +SessionStoreChangeListener::Create(BrowsingContext* aBrowsingContext) { + MOZ_RELEASE_ASSERT( + StaticPrefs::browser_sessionstore_platform_collection_AtStartup()); + if (!aBrowsingContext) { + return nullptr; + } + + RefPtr<SessionStoreChangeListener> listener = + new SessionStoreChangeListener(aBrowsingContext); + listener->Init(); + + return listener.forget(); +} + +void SessionStoreChangeListener::Stop() { + RemoveEventListeners(); + Preferences::RemoveObservers(this, kObservedPrefs); +} + +void SessionStoreChangeListener::UpdateEventTargets() { + RemoveEventListeners(); + AddEventListeners(); +} + +static void CollectFormData(Document* aDocument, + Maybe<sessionstore::FormData>& aFormData) { + aFormData.emplace(); + auto& formData = aFormData.ref(); + uint32_t size = SessionStoreUtils::CollectFormData(aDocument, formData); + + Element* body = aDocument->GetBody(); + if (aDocument->HasFlag(NODE_IS_EDITABLE) && body) { + IgnoredErrorResult result; + body->GetInnerHTML(formData.innerHTML(), result); + size += formData.innerHTML().Length(); + if (!result.Failed()) { + formData.hasData() = true; + } + } + + if (!formData.hasData()) { + return; + } + + nsIURI* documentURI = aDocument->GetDocumentURI(); + if (!documentURI) { + return; + } + + documentURI->GetSpecIgnoringRef(formData.uri()); + + if (size > StaticPrefs::browser_sessionstore_dom_form_max_limit()) { + aFormData = Nothing(); + } +} + +static void GetZoom(BrowsingContext* aBrowsingContext, + Maybe<SessionStoreZoom>& aZoom) { + nsIDocShell* docShell = aBrowsingContext->GetDocShell(); + if (!docShell) { + return; + } + + PresShell* presShell = docShell->GetPresShell(); + if (!presShell) { + return; + } + + LayoutDeviceIntSize displaySize; + + if (!nsLayoutUtils::GetContentViewerSize(presShell->GetPresContext(), + displaySize)) { + return; + } + + aZoom.emplace(presShell->GetResolution(), displaySize.width, + displaySize.height); +} + +void SessionStoreChangeListener::FlushSessionStore() { + if (mTimer) { + mTimer->Cancel(); + mTimer = nullptr; + } + + bool collectSessionHistory = false; + bool collectWireFrame = false; + bool didResize = false; + + for (auto& iter : mSessionStoreChanges) { + WindowContext* windowContext = iter.GetKey(); + if (!windowContext) { + continue; + } + + BrowsingContext* browsingContext = windowContext->GetBrowsingContext(); + + // This is a bit unfortunate, but is needed when a window context with a + // recorded change has become non-current before its data has been + // collected. This can happen either due to navigation or destruction, and + // in the previous case we don't want to collect, but in the latter we do. + // This could be cleaned up if we change. See bug 1770773. + if (!windowContext->IsCurrent() && !browsingContext->IsDiscarded()) { + continue; + } + + RefPtr<Document> document = windowContext->GetDocument(); + if (!document) { + continue; + } + + EnumSet<Change> changes = iter.GetData(); + Maybe<sessionstore::FormData> maybeFormData; + if (changes.contains(Change::Input)) { + CollectFormData(document, maybeFormData); + } + + Maybe<nsPoint> maybeScroll; + PresShell* presShell = document->GetPresShell(); + + if (presShell && changes.contains(Change::Scroll)) { + maybeScroll = Some(presShell->GetVisualViewportOffset()); + } + + collectWireFrame = collectWireFrame || changes.contains(Change::WireFrame); + + collectSessionHistory = + collectSessionHistory || changes.contains(Change::SessionHistory); + + if (presShell && changes.contains(Change::Resize)) { + didResize = true; + } + + mSessionStoreChild->IncrementalSessionStoreUpdate( + browsingContext, maybeFormData, maybeScroll, mEpoch); + } + + if (collectWireFrame) { + collectSessionHistory = CollectWireframe() || collectSessionHistory; + } + + mSessionStoreChanges.Clear(); + + Maybe<SessionStoreZoom> zoom; + if (didResize) { + GetZoom(mBrowsingContext->Top(), zoom); + } + + mSessionStoreChild->UpdateSessionStore(collectSessionHistory, zoom); +} + +/* static */ +SessionStoreChangeListener* SessionStoreChangeListener::CollectSessionStoreData( + WindowContext* aWindowContext, const EnumSet<Change>& aChanges) { + SessionStoreChild* sessionStoreChild = + SessionStoreChild::From(aWindowContext->GetWindowGlobalChild()); + if (!sessionStoreChild) { + return nullptr; + } + + SessionStoreChangeListener* sessionStoreChangeListener = + sessionStoreChild->GetSessionStoreChangeListener(); + + if (!sessionStoreChangeListener) { + return nullptr; + } + + sessionStoreChangeListener->RecordChange(aWindowContext, aChanges); + + return sessionStoreChangeListener; +} + +void SessionStoreChangeListener::SetActor( + SessionStoreChild* aSessionStoreChild) { + mSessionStoreChild = aSessionStoreChild; +} + +bool SessionStoreChangeListener::CollectWireframe() { + if (auto* docShell = nsDocShell::Cast(mBrowsingContext->GetDocShell())) { + return docShell->CollectWireframe(); + } + + return false; +} + +void SessionStoreChangeListener::RecordChange(WindowContext* aWindowContext, + EnumSet<Change> aChange) { + EnsureTimer(); + + Unused << mSessionStoreChanges.WithEntryHandle( + aWindowContext, [&](auto entryHandle) -> EnumSet<Change>& { + if (entryHandle) { + *entryHandle += aChange; + return *entryHandle; + } + + return entryHandle.Insert(aChange); + }); +} + +SessionStoreChangeListener::SessionStoreChangeListener( + BrowsingContext* aBrowsingContext) + : mBrowsingContext(aBrowsingContext), + mEpoch(aBrowsingContext->GetSessionStoreEpoch()) {} + +void SessionStoreChangeListener::Init() { + AddEventListeners(); + + Preferences::AddStrongObservers(this, kObservedPrefs); +} + +EventTarget* SessionStoreChangeListener::GetEventTarget() { + if (mBrowsingContext->GetDOMWindow()) { + return mBrowsingContext->GetDOMWindow()->GetChromeEventHandler(); + } + + return nullptr; +} + +void SessionStoreChangeListener::AddEventListeners() { + if (EventTarget* target = GetEventTarget()) { + target->AddSystemEventListener(kInput, this, false); + target->AddSystemEventListener(kScroll, this, false); + if (StaticPrefs::browser_sessionstore_collect_zoom_AtStartup()) { + target->AddSystemEventListener(kResize, this, false); + } + mCurrentEventTarget = target; + } +} + +void SessionStoreChangeListener::RemoveEventListeners() { + if (mCurrentEventTarget) { + mCurrentEventTarget->RemoveSystemEventListener(kInput, this, false); + mCurrentEventTarget->RemoveSystemEventListener(kScroll, this, false); + if (StaticPrefs::browser_sessionstore_collect_zoom_AtStartup()) { + mCurrentEventTarget->RemoveSystemEventListener(kResize, this, false); + } + } + + mCurrentEventTarget = nullptr; +} + +void SessionStoreChangeListener::EnsureTimer() { + if (mTimer) { + return; + } + + if (!StaticPrefs::browser_sessionstore_debug_no_auto_updates()) { + auto result = NS_NewTimerWithCallback( + this, StaticPrefs::browser_sessionstore_interval(), + nsITimer::TYPE_ONE_SHOT); + if (result.isErr()) { + return; + } + + mTimer = result.unwrap(); + } +} diff --git a/toolkit/components/sessionstore/SessionStoreChangeListener.h b/toolkit/components/sessionstore/SessionStoreChangeListener.h new file mode 100644 index 0000000000..803a2137bd --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreChangeListener.h @@ -0,0 +1,103 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_SessionStoreChangeListener_h +#define mozilla_dom_SessionStoreChangeListener_h + +#include "ErrorList.h" + +#include "PLDHashTable.h" +#include "mozilla/EnumSet.h" +#include "nsCycleCollectionParticipant.h" +#include "nsHashKeys.h" +#include "nsIDOMEventListener.h" +#include "nsIObserver.h" +#include "nsISupports.h" +#include "nsITimer.h" +#include "nsINamed.h" +#include "nsHashtablesFwd.h" + +#include "mozilla/EnumSet.h" +#include "mozilla/RefPtr.h" +#include "mozilla/Result.h" + +#include "mozilla/dom/WindowGlobalChild.h" + +namespace mozilla::dom { + +class BrowsingContext; +class Element; +class EventTarget; +class SessionStoreChild; +class WindowContext; + +class SessionStoreChangeListener final : public nsINamed, + public nsIObserver, + public nsITimerCallback, + public nsIDOMEventListener { + public: + NS_DECL_NSINAMED + NS_DECL_NSIOBSERVER + NS_DECL_NSITIMERCALLBACK + NS_DECL_NSIDOMEVENTLISTENER + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(SessionStoreChangeListener, + nsIObserver) + + static already_AddRefed<SessionStoreChangeListener> Create( + BrowsingContext* aBrowsingContext); + + void Stop(); + + void UpdateEventTargets(); + + void FlushSessionStore(); + + enum class Change { Input, Scroll, SessionHistory, WireFrame, Resize }; + + static SessionStoreChangeListener* CollectSessionStoreData( + WindowContext* aWindowContext, const EnumSet<Change>& aChanges); + + void SetActor(SessionStoreChild* aSessionStoreChild); + + void SetEpoch(uint32_t aEpoch) { mEpoch = aEpoch; } + + uint32_t GetEpoch() const { return mEpoch; } + + bool CollectWireframe(); + + private: + void RecordChange(WindowContext* aWindowContext, EnumSet<Change> aChanges); + + public: + using SessionStoreChangeTable = + nsTHashMap<RefPtr<WindowContext>, EnumSet<Change>>; + + private: + explicit SessionStoreChangeListener(BrowsingContext* aBrowsingContext); + ~SessionStoreChangeListener() = default; + + void Init(); + + EventTarget* GetEventTarget(); + + void AddEventListeners(); + void RemoveEventListeners(); + + void EnsureTimer(); + + RefPtr<BrowsingContext> mBrowsingContext; + RefPtr<EventTarget> mCurrentEventTarget; + + uint32_t mEpoch; + nsCOMPtr<nsITimer> mTimer; + RefPtr<SessionStoreChild> mSessionStoreChild; + SessionStoreChangeTable mSessionStoreChanges; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_SessionStoreChangeListener_h diff --git a/toolkit/components/sessionstore/SessionStoreChild.cpp b/toolkit/components/sessionstore/SessionStoreChild.cpp new file mode 100644 index 0000000000..0b6d0dd17e --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreChild.cpp @@ -0,0 +1,261 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/SessionStoreChild.h" + +#include "mozilla/AlreadyAddRefed.h" +#include "mozilla/Assertions.h" +#include "mozilla/RefPtr.h" +#include "mozilla/ScopeExit.h" +#include "mozilla/dom/BrowserChild.h" +#include "mozilla/dom/BrowsingContext.h" +#include "mozilla/dom/InProcessChild.h" +#include "mozilla/dom/InProcessParent.h" +#include "mozilla/dom/BrowserSessionStore.h" +#include "mozilla/dom/SessionStoreChangeListener.h" +#include "mozilla/dom/SessionStoreParent.h" +#include "mozilla/dom/WindowGlobalParent.h" +#include "mozilla/ipc/Endpoint.h" +#include "nsCOMPtr.h" +#include "nsFrameLoader.h" + +using namespace mozilla; +using namespace mozilla::dom; + +class nsIDocShell; + +static already_AddRefed<TabListener> CreateTabListener(nsIDocShell* aDocShell) { + RefPtr<TabListener> tabListener = + mozilla::MakeRefPtr<TabListener>(aDocShell, nullptr); + nsresult rv = tabListener->Init(); + if (NS_FAILED(rv)) { + return nullptr; + } + + return tabListener.forget(); +} + +already_AddRefed<SessionStoreChild> SessionStoreChild::GetOrCreate( + BrowsingContext* aBrowsingContext, Element* aOwnerElement) { + RefPtr<TabListener> tabListener = + CreateTabListener(aBrowsingContext->GetDocShell()); + if (!tabListener) { + return nullptr; + } + + RefPtr<SessionStoreChangeListener> sessionStoreChangeListener = + SessionStoreChangeListener::Create(aBrowsingContext); + if (!sessionStoreChangeListener) { + return nullptr; + } + + RefPtr<SessionStoreChild> sessionStoreChild = + new SessionStoreChild(tabListener, sessionStoreChangeListener); + + sessionStoreChangeListener->SetActor(sessionStoreChild); + + if (XRE_IsParentProcess()) { + MOZ_DIAGNOSTIC_ASSERT(aOwnerElement); + InProcessChild* inProcessChild = InProcessChild::Singleton(); + InProcessParent* inProcessParent = InProcessParent::Singleton(); + if (!inProcessChild || !inProcessParent) { + return nullptr; + } + + RefPtr<BrowserSessionStore> sessionStore = + BrowserSessionStore::GetOrCreate(aBrowsingContext->Canonical()->Top()); + if (!sessionStore) { + return nullptr; + } + + CanonicalBrowsingContext* browsingContext = aBrowsingContext->Canonical(); + RefPtr<SessionStoreParent> sessionStoreParent = + new SessionStoreParent(browsingContext, sessionStore); + ManagedEndpoint<PSessionStoreParent> endpoint = + inProcessChild->OpenPSessionStoreEndpoint(sessionStoreChild); + inProcessParent->BindPSessionStoreEndpoint(std::move(endpoint), + sessionStoreParent); + } else { + MOZ_DIAGNOSTIC_ASSERT(!aOwnerElement); + RefPtr<BrowserChild> browserChild = + BrowserChild::GetFrom(aBrowsingContext->GetDOMWindow()); + + MOZ_DIAGNOSTIC_ASSERT(browserChild); + MOZ_DIAGNOSTIC_ASSERT(aBrowsingContext->IsInProcess()); + sessionStoreChild = static_cast<SessionStoreChild*>( + browserChild->SendPSessionStoreConstructor(sessionStoreChild)); + } + + return sessionStoreChild.forget(); +} + +/* static */ +SessionStoreChild* SessionStoreChild::From(WindowGlobalChild* aWindowChild) { + if (!aWindowChild) { + return nullptr; + } + + // If `aWindowChild` is inprocess + if (RefPtr<BrowserChild> browserChild = aWindowChild->GetBrowserChild()) { + return browserChild->GetSessionStoreChild(); + } + + if (XRE_IsContentProcess()) { + return nullptr; + } + + WindowGlobalParent* windowParent = aWindowChild->WindowContext()->Canonical(); + if (!windowParent) { + return nullptr; + } + + RefPtr<nsFrameLoader> frameLoader = windowParent->GetRootFrameLoader(); + if (!frameLoader) { + return nullptr; + } + + return frameLoader->GetSessionStoreChild(); +} + +SessionStoreChild::SessionStoreChild( + TabListener* aSessionStoreListener, + SessionStoreChangeListener* aSessionStoreChangeListener) + : mSessionStoreListener(aSessionStoreListener), + mSessionStoreChangeListener(aSessionStoreChangeListener) {} + +void SessionStoreChild::SetEpoch(uint32_t aEpoch) { + if (mSessionStoreListener) { + mSessionStoreListener->SetEpoch(aEpoch); + } + + if (mSessionStoreChangeListener) { + mSessionStoreChangeListener->SetEpoch(aEpoch); + } +} + +void SessionStoreChild::SetOwnerContent(Element* aElement) { + if (mSessionStoreChangeListener) { + mSessionStoreChangeListener->FlushSessionStore(); + } + + if (!aElement) { + return; + } + + if (mSessionStoreListener) { + mSessionStoreListener->SetOwnerContent(aElement); + } +} + +void SessionStoreChild::Stop() { + if (mSessionStoreListener) { + mSessionStoreListener->RemoveListeners(); + mSessionStoreListener = nullptr; + } + + if (mSessionStoreChangeListener) { + mSessionStoreChangeListener->Stop(); + } +} + +void SessionStoreChild::UpdateEventTargets() { + if (mSessionStoreChangeListener) { + mSessionStoreChangeListener->UpdateEventTargets(); + } +} + +void SessionStoreChild::UpdateSessionStore(bool aSessionHistoryUpdate, + const MaybeSessionStoreZoom& aZoom) { + if (!mSessionStoreListener) { + // This is the case when we're shutting down, and expect a final update. + SessionStoreUpdate(Nothing(), Nothing(), Nothing(), aSessionHistoryUpdate, + 0); + return; + } + + RefPtr<ContentSessionStore> store = mSessionStoreListener->GetSessionStore(); + + Maybe<nsCString> docShellCaps; + if (store->IsDocCapChanged()) { + docShellCaps.emplace(store->GetDocShellCaps()); + } + + Maybe<bool> privatedMode; + if (store->IsPrivateChanged()) { + privatedMode.emplace(store->GetPrivateModeEnabled()); + } + + SessionStoreUpdate( + docShellCaps, privatedMode, aZoom, + store->GetAndClearSHistoryChanged() || aSessionHistoryUpdate, + mSessionStoreListener->GetEpoch()); +} + +void SessionStoreChild::FlushSessionStore() { + if (mSessionStoreChangeListener) { + mSessionStoreChangeListener->FlushSessionStore(); + } +} + +void SessionStoreChild::UpdateSHistoryChanges() { + if (mSessionStoreListener) { + mSessionStoreListener->UpdateSHistoryChanges(); + } +} + +mozilla::ipc::IPCResult SessionStoreChild::RecvFlushTabState( + FlushTabStateResolver&& aResolver) { + if (mSessionStoreChangeListener) { + mSessionStoreChangeListener->FlushSessionStore(); + } + aResolver(true); + + return IPC_OK(); +} + +void SessionStoreChild::SessionStoreUpdate( + const Maybe<nsCString>& aDocShellCaps, const Maybe<bool>& aPrivatedMode, + const MaybeSessionStoreZoom& aZoom, const bool aNeedCollectSHistory, + const uint32_t& aEpoch) { + if (XRE_IsContentProcess()) { + Unused << SendSessionStoreUpdate(aDocShellCaps, aPrivatedMode, aZoom, + aNeedCollectSHistory, aEpoch); + } else if (SessionStoreParent* sessionStoreParent = + static_cast<SessionStoreParent*>( + InProcessChild::ParentActorFor(this))) { + sessionStoreParent->SessionStoreUpdate(aDocShellCaps, aPrivatedMode, aZoom, + aNeedCollectSHistory, aEpoch); + } +} + +void SessionStoreChild::IncrementalSessionStoreUpdate( + const MaybeDiscarded<BrowsingContext>& aBrowsingContext, + const Maybe<FormData>& aFormData, const Maybe<nsPoint>& aScrollPosition, + uint32_t aEpoch) { + if (XRE_IsContentProcess()) { + Unused << SendIncrementalSessionStoreUpdate(aBrowsingContext, aFormData, + aScrollPosition, aEpoch); + } else if (SessionStoreParent* sessionStoreParent = + static_cast<SessionStoreParent*>( + InProcessChild::ParentActorFor(this))) { + sessionStoreParent->IncrementalSessionStoreUpdate( + aBrowsingContext, aFormData, aScrollPosition, aEpoch); + } +} + +void SessionStoreChild::ResetSessionStore( + const MaybeDiscarded<BrowsingContext>& aBrowsingContext, uint32_t aEpoch) { + if (XRE_IsContentProcess()) { + Unused << SendResetSessionStore(aBrowsingContext, aEpoch); + } else if (SessionStoreParent* sessionStoreParent = + static_cast<SessionStoreParent*>( + InProcessChild::ParentActorFor(this))) { + sessionStoreParent->ResetSessionStore(aBrowsingContext, aEpoch); + } +} + +NS_IMPL_CYCLE_COLLECTION(SessionStoreChild, mSessionStoreListener, + mSessionStoreChangeListener) diff --git a/toolkit/components/sessionstore/SessionStoreChild.h b/toolkit/components/sessionstore/SessionStoreChild.h new file mode 100644 index 0000000000..606aa0f441 --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreChild.h @@ -0,0 +1,73 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_SessionStoreChild_h +#define mozilla_dom_SessionStoreChild_h + +#include "mozilla/AlreadyAddRefed.h" +#include "mozilla/dom/PSessionStoreChild.h" +#include "mozilla/dom/SessionStoreScrollData.h" +#include "mozilla/dom/SessionStoreChangeListener.h" +#include "mozilla/dom/SessionStoreListener.h" +#include "mozilla/RefPtr.h" + +#include "nsCycleCollectionParticipant.h" + +namespace mozilla::dom { +class BrowsingContext; +class SessionStoreChangeListener; +class TabListener; + +class SessionStoreChild final : public PSessionStoreChild { + public: + static already_AddRefed<SessionStoreChild> GetOrCreate( + BrowsingContext* aBrowsingContext, Element* aOwnerElement = nullptr); + + static SessionStoreChild* From(WindowGlobalChild* aWindowChild); + + void SetEpoch(uint32_t aEpoch); + void SetOwnerContent(Element* aElement); + void Stop(); + void UpdateEventTargets(); + void UpdateSessionStore(bool aSessionHistoryUpdate = false, + const MaybeSessionStoreZoom& aZoom = Nothing()); + void FlushSessionStore(); + void UpdateSHistoryChanges(); + + void SessionStoreUpdate(const Maybe<nsCString>& aDocShellCaps, + const Maybe<bool>& aPrivatedMode, + const MaybeSessionStoreZoom& aZoom, + const bool aNeedCollectSHistory, + const uint32_t& aEpoch); + + void IncrementalSessionStoreUpdate( + const MaybeDiscarded<BrowsingContext>& aBrowsingContext, + const Maybe<FormData>& aFormData, const Maybe<nsPoint>& aScrollPosition, + uint32_t aEpoch); + + void ResetSessionStore( + const MaybeDiscarded<BrowsingContext>& aBrowsingContext, uint32_t aEpoch); + + SessionStoreChangeListener* GetSessionStoreChangeListener() const { + return mSessionStoreChangeListener; + } + + mozilla::ipc::IPCResult RecvFlushTabState(FlushTabStateResolver&& aResolver); + + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(SessionStoreChild) + NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(SessionStoreChild) + + private: + SessionStoreChild(TabListener* aSessionStoreListener, + SessionStoreChangeListener* aSessionStoreChangeListener); + ~SessionStoreChild() = default; + + RefPtr<TabListener> mSessionStoreListener; + RefPtr<SessionStoreChangeListener> mSessionStoreChangeListener; +}; +} // namespace mozilla::dom + +#endif // mozilla_dom_SessionStoreChild_h diff --git a/toolkit/components/sessionstore/SessionStoreData.h b/toolkit/components/sessionstore/SessionStoreData.h new file mode 100644 index 0000000000..0df1ea5bf5 --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreData.h @@ -0,0 +1,61 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_SessionStoreData_h +#define mozilla_dom_SessionStoreData_h + +#include "nsString.h" +#include "nsTArray.h" +#include "mozilla/dom/SessionStoreUtilsBinding.h" +#include "mozilla/Variant.h" + +typedef mozilla::Variant<nsString, bool, + mozilla::dom::CollectedNonMultipleSelectValue, + CopyableTArray<nsString>> + InputDataValue; + +/* + * Need two arrays based on this struct. + * One is for elements with id one is for XPath. + * + * id: id or XPath + * type: type of this input element + * bool: value is boolean + * string: value is nsString + * file: value is "arrayVal" + * singleSelect: value is "singleSelect" + * multipleSelect: value is "arrayVal" + * + * There are four value types: + * strVal: nsString + * boolVal: boolean + * singleSelect: single select value + * arrayVal: nsString array + */ +struct CollectedInputDataValue { + nsString id; + nsString type; + InputDataValue value{false}; + + CollectedInputDataValue() = default; +}; + +/* + * Each index of the following array is corresponging to each frame. + * descendants: number of child frames of this frame + * innerHTML: innerHTML of this frame + * url: url of this frame + * numId: number of containing elements with id for this frame + * numXPath: number of containing elements with XPath for this frame + */ +struct InputFormData { + int32_t descendants; + nsString innerHTML; + nsCString url; + int32_t numId; + int32_t numXPath; +}; + +#endif /* mozilla_dom_SessionStoreData_h */ diff --git a/toolkit/components/sessionstore/SessionStoreFormData.cpp b/toolkit/components/sessionstore/SessionStoreFormData.cpp new file mode 100644 index 0000000000..c792b3f2f0 --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreFormData.cpp @@ -0,0 +1,172 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/SessionStoreFormData.h" + +#include "mozilla/Assertions.h" +#include "mozilla/ScopeExit.h" +#include "mozilla/dom/BindingUtils.h" +#include "mozilla/dom/BrowserSessionStoreBinding.h" +#include "mozilla/dom/BrowsingContext.h" +#include "mozilla/dom/sessionstore/SessionStoreTypes.h" + +#include "nsContentUtils.h" +#include "js/JSON.h" + +using namespace mozilla::dom; + +NS_IMPL_CYCLE_COLLECTING_ADDREF(SessionStoreFormData) +NS_IMPL_CYCLE_COLLECTING_RELEASE(SessionStoreFormData) + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_WEAK_PTR(SessionStoreFormData, mChildren) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SessionStoreFormData) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +nsISupports* SessionStoreFormData::GetParentObject() const { + return xpc::NativeGlobal(xpc::PrivilegedJunkScope()); +} + +JSObject* SessionStoreFormData::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return SessionStoreFormData_Binding::Wrap(aCx, this, aGivenProto); +} + +void SessionStoreFormData::GetUrl(nsACString& aUrl) const { + if (mUrl.IsEmpty()) { + aUrl.SetIsVoid(true); + } else { + aUrl = mUrl; + } +} + +void SessionStoreFormData::GetId( + JSContext* aCx, + Nullable<Record<nsString, OwningStringOrBooleanOrObject>>& aId) { + if (mId.IsEmpty() || + NS_FAILED(SessionStoreUtils::ConstructFormDataValues( + aCx, mId, aId.SetValue().Entries(), mParseSessionData))) { + aId.SetNull(); + } + + // SessionStoreFormData.id is now stored in a slot, so we can free our + // internal state. + mId.Clear(); +} + +void SessionStoreFormData::GetXpath( + JSContext* aCx, + Nullable<Record<nsString, OwningStringOrBooleanOrObject>>& aXpath) { + if (mXpath.IsEmpty() || + NS_FAILED(SessionStoreUtils::ConstructFormDataValues( + aCx, mXpath, aXpath.SetValue().Entries(), mParseSessionData))) { + aXpath.SetNull(); + } + + // SessionStoreFormData.xpath is now stored in a slot, so we can free our + // internal state. + mXpath.Clear(); +} + +void SessionStoreFormData::GetInnerHTML(nsAString& aInnerHTML) { + if (mInnerHTML.IsEmpty()) { + SetDOMStringToNull(aInnerHTML); + } else { + aInnerHTML = mInnerHTML; + } + + // SessionStoreFormData.innerHTML is now stored in a slot, so we can free our + // internal state. + mInnerHTML.SetIsVoid(true); +} + +SessionStoreFormData::ChildrenArray& SessionStoreFormData::Children() { + return mChildren; +} + +void SessionStoreFormData::GetChildren( + Nullable<ChildrenArray>& aChildren) const { + if (!mChildren.IsEmpty()) { + aChildren.SetValue() = mChildren.Clone(); + } else { + aChildren.SetNull(); + } +} + +void SessionStoreFormData::ToJSON(JSContext* aCx, + JS::MutableHandle<JSObject*> aRetval) { + JS::Rooted<JSObject*> self(aCx); + { + JS::Rooted<JS::Value> value(aCx); + if (!GetOrCreateDOMReflector(aCx, this, &value)) { + return; + } + + self.set(value.toObjectOrNull()); + } + + JS::Rooted<JSObject*> result(aCx, JS_NewPlainObject(aCx)); + + if (!IsEmpty()) { + for (const auto& name : + {u"url"_ns, u"id"_ns, u"xpath"_ns, u"innerHTML"_ns}) { + if (!SessionStoreUtils::CopyProperty(aCx, result, self, name)) { + return; + } + } + + SessionStoreUtils::CopyChildren(aCx, result, mChildren); + } + + aRetval.set(result); +} + +void SessionStoreFormData::Update(const CollectedType& aFormData) { + SessionStoreFormData_Binding::ClearCachedUrlValue(this); + SessionStoreFormData_Binding::ClearCachedIdValue(this); + SessionStoreFormData_Binding::ClearCachedXpathValue(this); + SessionStoreFormData_Binding::ClearCachedInnerHTMLValue(this); + + if (!aFormData.hasData()) { + mParseSessionData = false; + mHasData = false; + mUrl = ""_ns; + mId.Clear(); + mXpath.Clear(); + mInnerHTML = u""_ns; + + return; + } + + mHasData = true; + + mUrl = aFormData.uri(); + // We want to avoid saving data for about:sessionrestore as a string. + // Since it's stored in the form as stringified JSON, stringifying + // further causes an explosion of escape characters. cf. bug 467409 + mParseSessionData = + mUrl == "about:sessionrestore"_ns || mUrl == "about:welcomeback"_ns; + + mInnerHTML = aFormData.innerHTML(); + + mId.Assign(aFormData.id()); + mXpath.Assign(aFormData.xpath()); +} + +void SessionStoreFormData::ClearCachedChildren() { + SessionStoreFormData_Binding::ClearCachedChildrenValue(this); +} + +/* static */ bool SessionStoreFormData::HasData( + const CollectedType& aFormData) { + return aFormData.hasData(); +} + +bool SessionStoreFormData::IsEmpty() const { + return !mHasData && mChildren.IsEmpty(); +} diff --git a/toolkit/components/sessionstore/SessionStoreFormData.h b/toolkit/components/sessionstore/SessionStoreFormData.h new file mode 100644 index 0000000000..0466d98441 --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreFormData.h @@ -0,0 +1,83 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_SessionStoreFormData_h +#define mozilla_dom_SessionStoreFormData_h + +#include "mozilla/WeakPtr.h" +#include "mozilla/dom/UnionTypes.h" +#include "mozilla/dom/WindowGlobalParent.h" + +#include "nsTArrayForwardDeclare.h" +#include "nsWrapperCache.h" + +class nsIGlobalObject; + +namespace mozilla::dom { + +namespace sessionstore { +class FormData; +} + +class BrowsingContext; +class OwningByteStringOrObjectOrNull; +class OwningStringOrObjectOrNull; +class WindowGlobalParent; + +class SessionStoreFormData final : public nsISupports, + public nsWrapperCache, + public SupportsWeakPtr { + public: + using CollectedType = sessionstore::FormData; + using LocationType = WeakPtr<SessionStoreFormData>; + using ChildrenArray = nsTArray<RefPtr<SessionStoreFormData>>; + + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(SessionStoreFormData) + nsISupports* GetParentObject() const; + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + void GetUrl(nsACString& aUrl) const; + + void GetId(JSContext* aCx, + Nullable<Record<nsString, OwningStringOrBooleanOrObject>>& aId); + + void GetXpath( + JSContext* aCx, + Nullable<Record<nsString, OwningStringOrBooleanOrObject>>& aXpath); + + void GetInnerHTML(nsAString& aInnerHTML); + + ChildrenArray& Children(); + + void GetChildren(Nullable<ChildrenArray>& aChildren) const; + + void ToJSON(JSContext* aCx, JS::MutableHandle<JSObject*> aRetval); + + void Update(const CollectedType& aFormData); + + void ClearCachedChildren(); + + static bool HasData(const CollectedType& aFormData); + + bool IsEmpty() const; + + private: + ~SessionStoreFormData() = default; + + bool mParseSessionData = false; + bool mHasData = false; + nsCString mUrl; + nsTArray<sessionstore::FormEntry> mId; + nsTArray<sessionstore::FormEntry> mXpath; + nsString mInnerHTML; + ChildrenArray mChildren; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_SessionStoreFormData_h diff --git a/toolkit/components/sessionstore/SessionStoreFunctions.idl b/toolkit/components/sessionstore/SessionStoreFunctions.idl new file mode 100644 index 0000000000..3c17015437 --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreFunctions.idl @@ -0,0 +1,23 @@ +/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +webidl BrowsingContext; +webidl Element; + +[scriptable, uuid(1A060FBA-A19D-11E9-B7EB-580D0EDD8E6F)] +interface nsISessionStoreFunctions : nsISupports { + // update sessionStore from the tabListener implemented by C++ + // aData is a UpdateSessionStoreData dictionary (From SessionStoreUtils.webidl) + void UpdateSessionStore( + in Element aBrowser, in BrowsingContext aBrowsingContext, + in jsval aPermanentKey, in uint32_t aEpoch, in boolean aCollectSHistory, + in jsval aData); + + void UpdateSessionStoreForStorage( + in Element aBrowser, in BrowsingContext aBrowsingContext, + in jsval aPermanentKey, in uint32_t aEpoch, in jsval aData); +}; diff --git a/toolkit/components/sessionstore/SessionStoreFunctions.sys.mjs b/toolkit/components/sessionstore/SessionStoreFunctions.sys.mjs new file mode 100644 index 0000000000..f42c371264 --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreFunctions.sys.mjs @@ -0,0 +1,87 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +import { SessionStore } from "resource:///modules/sessionstore/SessionStore.sys.mjs"; + +export function UpdateSessionStore( + aBrowser, + aBrowsingContext, + aPermanentKey, + aEpoch, + aCollectSHistory, + aData +) { + return SessionStoreFuncInternal.updateSessionStore( + aBrowser, + aBrowsingContext, + aPermanentKey, + aEpoch, + aCollectSHistory, + aData + ); +} + +export function UpdateSessionStoreForStorage( + aBrowser, + aBrowsingContext, + aPermanentKey, + aEpoch, + aData +) { + return SessionStoreFuncInternal.updateSessionStoreForStorage( + aBrowser, + aBrowsingContext, + aPermanentKey, + aEpoch, + aData + ); +} + +var SessionStoreFuncInternal = { + updateSessionStore: function SSF_updateSessionStore( + aBrowser, + aBrowsingContext, + aPermanentKey, + aEpoch, + aCollectSHistory, + aData + ) { + let { formdata, scroll } = aData; + + if (formdata) { + aData.formdata = formdata.toJSON(); + } + + if (scroll) { + aData.scroll = scroll.toJSON(); + } + + SessionStore.updateSessionStoreFromTablistener( + aBrowser, + aBrowsingContext, + aPermanentKey, + { + data: aData, + epoch: aEpoch, + sHistoryNeeded: aCollectSHistory, + } + ); + }, + + updateSessionStoreForStorage: function SSF_updateSessionStoreForStorage( + aBrowser, + aBrowsingContext, + aPermanentKey, + aEpoch, + aData + ) { + SessionStore.updateSessionStoreFromTablistener( + aBrowser, + aBrowsingContext, + aPermanentKey, + { data: { storage: aData }, epoch: aEpoch }, + true + ); + }, +}; diff --git a/toolkit/components/sessionstore/SessionStoreListener.cpp b/toolkit/components/sessionstore/SessionStoreListener.cpp new file mode 100644 index 0000000000..19612af786 --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreListener.cpp @@ -0,0 +1,494 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/PresShell.h" +#include "mozilla/dom/BrowserSessionStoreBinding.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/SessionStoreListener.h" +#include "mozilla/dom/SessionStoreUtils.h" +#include "mozilla/dom/SessionStoreUtilsBinding.h" +#include "mozilla/dom/BrowserChild.h" +#include "mozilla/StaticPrefs_browser.h" +#include "nsGenericHTMLElement.h" +#include "nsDocShell.h" +#include "nsIAppWindow.h" +#include "nsIDocShell.h" +#include "nsIDocShellTreeOwner.h" +#include "nsImportModule.h" +#include "nsIPrefBranch.h" +#include "nsIPrefService.h" +#include "nsITimer.h" +#include "nsIWebProgress.h" +#include "nsIXPConnect.h" +#include "nsIXULRuntime.h" +#include "nsPresContext.h" +#include "nsPrintfCString.h" +#include "SessionStoreFunctions.h" + +using namespace mozilla; +using namespace mozilla::dom; + +// This pref controls whether or not we send updates to the parent on a timeout +// or not, and should only be used for tests or debugging. +static const char kTimeOutDisable[] = + "browser.sessionstore.debug.no_auto_updates"; +// Timeout for waiting an idle period to send data. +static const char kPrefInterval[] = "browser.sessionstore.interval"; + +NS_IMPL_CYCLE_COLLECTION(ContentSessionStore, mDocShell) + +ContentSessionStore::ContentSessionStore(nsIDocShell* aDocShell) + : mDocShell(aDocShell), + mPrivateChanged(false), + mIsPrivate(false), + mDocCapChanged(false), + mSHistoryChanged(false) { + MOZ_ASSERT(mDocShell); + // Check that value at startup as it might have + // been set before the frame script was loaded. + if (NS_SUCCEEDED(nsDocShell::Cast(mDocShell)->GetUsePrivateBrowsing( + &mPrivateChanged)) && + mPrivateChanged) { + mIsPrivate = true; + } +} + +nsCString ContentSessionStore::CollectDocShellCapabilities() { + bool allow; + nsCString aRetVal; + +#define TRY_ALLOWPROP(y) \ + PR_BEGIN_MACRO \ + nsresult rv = mDocShell->GetAllow##y(&allow); \ + if (NS_SUCCEEDED(rv) && !allow) { \ + if (!aRetVal.IsEmpty()) { \ + aRetVal.Append(','); \ + } \ + aRetVal.Append(#y); \ + } \ + PR_END_MACRO + + TRY_ALLOWPROP(Plugins); + // Bug 1328013 : Don't collect "AllowJavascript" property + // TRY_ALLOWPROP(Javascript); + TRY_ALLOWPROP(MetaRedirects); + TRY_ALLOWPROP(Subframes); + TRY_ALLOWPROP(Images); + TRY_ALLOWPROP(Media); + TRY_ALLOWPROP(DNSPrefetch); + TRY_ALLOWPROP(WindowControl); + TRY_ALLOWPROP(Auth); + TRY_ALLOWPROP(ContentRetargeting); + TRY_ALLOWPROP(ContentRetargetingOnChildren); +#undef TRY_ALLOWPROP + return aRetVal; +} + +void ContentSessionStore::OnPrivateModeChanged(bool aEnabled) { + mPrivateChanged = true; + mIsPrivate = aEnabled; +} + +nsCString ContentSessionStore::GetDocShellCaps() { + mDocCapChanged = false; + return mDocCaps; +} + +bool ContentSessionStore::GetPrivateModeEnabled() { + mPrivateChanged = false; + return mIsPrivate; +} + +void ContentSessionStore::SetSHistoryChanged() { + mSHistoryChanged = mozilla::SessionHistoryInParent(); +} + +void ContentSessionStore::OnDocumentStart() { + nsCString caps = CollectDocShellCapabilities(); + if (!mDocCaps.Equals(caps)) { + mDocCaps = caps; + mDocCapChanged = true; + } + + if (mozilla::SessionHistoryInParent()) { + mSHistoryChanged = true; + } +} + +void ContentSessionStore::OnDocumentEnd() { + if (mozilla::SessionHistoryInParent()) { + mSHistoryChanged = true; + } +} + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TabListener) + NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener) + NS_INTERFACE_MAP_ENTRY(nsIObserver) + NS_INTERFACE_MAP_ENTRY(nsIPrivacyTransitionObserver) + NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener) + NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMEventListener) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTION_WEAK(TabListener, mDocShell, mSessionStore, + mOwnerContent) +NS_IMPL_CYCLE_COLLECTING_ADDREF(TabListener) +NS_IMPL_CYCLE_COLLECTING_RELEASE(TabListener) + +TabListener::TabListener(nsIDocShell* aDocShell, Element* aElement) + : mDocShell(aDocShell), + mSessionStore(new ContentSessionStore(aDocShell)), + mOwnerContent(aElement), + mProgressListenerRegistered(false), + mEventListenerRegistered(false), + mPrefObserverRegistered(false), + mUpdatedTimer(nullptr), + mTimeoutDisabled(false), + mUpdateInterval(15000), + mEpoch(0) { + MOZ_ASSERT(mDocShell); +} + +EventTarget* TabListener::GetEventTarget() { + if (mOwnerContent) { + return mOwnerContent; + } + + nsCOMPtr<nsPIDOMWindowOuter> window = do_GetInterface(mDocShell); + if (window) { + return window->GetChromeEventHandler(); + } + + return nullptr; +} + +nsresult TabListener::Init() { + TabListener::UpdateSessionStore(); + nsresult rv = mDocShell->AddWeakPrivacyTransitionObserver(this); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIWebProgress> webProgress = do_QueryInterface(mDocShell); + rv = webProgress->AddProgressListener(this, + nsIWebProgress::NOTIFY_STATE_DOCUMENT); + NS_ENSURE_SUCCESS(rv, rv); + mProgressListenerRegistered = true; + + nsCOMPtr<nsIPrefBranch> prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID); + NS_WARNING_ASSERTION(prefBranch, "no prefservice"); + if (prefBranch) { + prefBranch->AddObserver(kTimeOutDisable, this, true); + prefBranch->AddObserver(kPrefInterval, this, true); + mPrefObserverRegistered = true; + } + + AddEventListeners(); + return NS_OK; +} + +void TabListener::AddEventListeners() { + if (nsCOMPtr<EventTarget> eventTarget = GetEventTarget()) { + if (mozilla::SessionHistoryInParent()) { + eventTarget->AddSystemEventListener(u"DOMTitleChanged"_ns, this, false); + } + mEventListenerRegistered = true; + } +} + +void TabListener::RemoveEventListeners() { + if (nsCOMPtr<EventTarget> eventTarget = GetEventTarget()) { + if (mEventListenerRegistered) { + if (mozilla::SessionHistoryInParent()) { + eventTarget->RemoveSystemEventListener(u"DOMTitleChanged"_ns, this, + false); + } + mEventListenerRegistered = false; + } + } +} + +void TabListener::SetOwnerContent(Element* aElement) { + MOZ_DIAGNOSTIC_ASSERT(aElement); + RemoveEventListeners(); + mOwnerContent = aElement; + AddEventListeners(); +} + +/* static */ +void TabListener::TimerCallback(nsITimer* aTimer, void* aClosure) { + auto listener = static_cast<TabListener*>(aClosure); + listener->UpdateSessionStore(); + listener->StopTimerForUpdate(); +} + +void TabListener::StopTimerForUpdate() { + if (mUpdatedTimer) { + mUpdatedTimer->Cancel(); + mUpdatedTimer = nullptr; + } +} + +void TabListener::AddTimerForUpdate() { + if (mUpdatedTimer) { + return; + } + + if (mTimeoutDisabled) { + UpdateSessionStore(); + return; + } + + NS_NewTimerWithFuncCallback(getter_AddRefs(mUpdatedTimer), TimerCallback, + this, mUpdateInterval, nsITimer::TYPE_ONE_SHOT, + "TabListener::TimerCallback"); +} + +NS_IMETHODIMP TabListener::PrivateModeChanged(bool aEnabled) { + mSessionStore->OnPrivateModeChanged(aEnabled); + AddTimerForUpdate(); + return NS_OK; +} + +NS_IMETHODIMP TabListener::OnStateChange(nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + uint32_t aStateFlags, + nsresult aStatus) { + if (!mSessionStore) { + return NS_OK; + } + + // Ignore state changes for subframes because we're only interested in the + // top-document starting or stopping its load. + bool isTopLevel = false; + nsresult rv = aWebProgress->GetIsTopLevel(&isTopLevel); + NS_ENSURE_SUCCESS(rv, rv); + if (!isTopLevel) { + return NS_OK; + } + + nsCOMPtr<nsIWebProgress> webProgress = do_QueryInterface(mDocShell); + if (webProgress != aWebProgress) { + return NS_OK; + } + + // onStateChange will be fired when loading the initial about:blank URI for + // a browser, which we don't actually care about. This is particularly for + // the case of unrestored background tabs, where the content has not yet + // been restored: we don't want to accidentally send any updates to the + // parent when the about:blank placeholder page has loaded. + if (!mDocShell->GetHasLoadedNonBlankURI()) { + return NS_OK; + } + + if (aStateFlags & (nsIWebProgressListener::STATE_START)) { + mSessionStore->OnDocumentStart(); + } else if (aStateFlags & (nsIWebProgressListener::STATE_STOP)) { + mSessionStore->OnDocumentEnd(); + } + + return NS_OK; +} + +NS_IMETHODIMP +TabListener::HandleEvent(Event* aEvent) { + EventTarget* target = aEvent->GetTarget(); + if (!target) { + return NS_OK; + } + + nsPIDOMWindowOuter* outer = target->GetOwnerGlobalForBindingsInternal(); + if (!outer || !outer->GetDocShell()) { + return NS_OK; + } + + RefPtr<BrowsingContext> context = outer->GetBrowsingContext(); + if (!context || context->CreatedDynamically()) { + return NS_OK; + } + + nsAutoString eventType; + aEvent->GetType(eventType); + if (eventType.EqualsLiteral("DOMTitleChanged")) { + mSessionStore->SetSHistoryChanged(); + AddTimerForUpdate(); + } + + return NS_OK; +} + +NS_IMETHODIMP TabListener::OnProgressChange(nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + int32_t aCurSelfProgress, + int32_t aMaxSelfProgress, + int32_t aCurTotalProgress, + int32_t aMaxTotalProgress) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP TabListener::OnLocationChange(nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + nsIURI* aLocation, + uint32_t aFlags) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP TabListener::OnStatusChange(nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + nsresult aStatus, + const char16_t* aMessage) { + return NS_ERROR_NOT_IMPLEMENTED; +} +NS_IMETHODIMP TabListener::OnSecurityChange(nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + uint32_t aState) { + return NS_ERROR_NOT_IMPLEMENTED; +} +NS_IMETHODIMP TabListener::OnContentBlockingEvent(nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + uint32_t aEvent) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsresult TabListener::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + if (!strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) { + nsCOMPtr<nsIPrefBranch> prefBranch = do_QueryInterface(aSubject); + + bool timeoutDisabled; + if (NS_SUCCEEDED( + prefBranch->GetBoolPref(kTimeOutDisable, &timeoutDisabled))) { + if (mTimeoutDisabled != timeoutDisabled) { + mTimeoutDisabled = timeoutDisabled; + if (mUpdatedTimer) { + StopTimerForUpdate(); + AddTimerForUpdate(); + } + } + } + + int32_t interval = 0; + if (NS_SUCCEEDED(prefBranch->GetIntPref(kPrefInterval, &interval))) { + if (mUpdateInterval != interval) { + mUpdateInterval = interval; + if (mUpdatedTimer) { + StopTimerForUpdate(); + AddTimerForUpdate(); + } + } + } + return NS_OK; + } + + NS_ERROR("Unexpected topic"); + return NS_ERROR_UNEXPECTED; +} + +void TabListener::ForceFlushFromParent() { + if (!XRE_IsParentProcess()) { + return; + } + if (!mSessionStore) { + return; + } + + UpdateSessionStore(true); +} + +void TabListener::UpdateSessionStore(bool aIsFlush) { + if (!aIsFlush) { + if (!mSessionStore || !mSessionStore->UpdateNeeded()) { + return; + } + } + + if (!XRE_IsParentProcess()) { + BrowserChild* browserChild = BrowserChild::GetFrom(mDocShell); + if (browserChild) { + StopTimerForUpdate(); + browserChild->UpdateSessionStore(); + } + return; + } + + BrowsingContext* context = mDocShell->GetBrowsingContext(); + if (!context) { + return; + } + + uint32_t chromeFlags = 0; + nsCOMPtr<nsIDocShellTreeOwner> treeOwner; + mDocShell->GetTreeOwner(getter_AddRefs(treeOwner)); + if (!treeOwner) { + return; + } + nsCOMPtr<nsIAppWindow> window(do_GetInterface(treeOwner)); + if (!window) { + return; + } + if (window && NS_FAILED(window->GetChromeFlags(&chromeFlags))) { + return; + } + + UpdateSessionStoreData data; + if (mSessionStore->IsDocCapChanged()) { + data.mDisallow.Construct() = mSessionStore->GetDocShellCaps(); + } + if (mSessionStore->IsPrivateChanged()) { + data.mIsPrivate.Construct() = mSessionStore->GetPrivateModeEnabled(); + } + + nsCOMPtr<nsISessionStoreFunctions> funcs = do_ImportESModule( + "resource://gre/modules/SessionStoreFunctions.sys.mjs", fallible); + nsCOMPtr<nsIXPConnectWrappedJS> wrapped = do_QueryInterface(funcs); + if (!wrapped) { + return; + } + + AutoJSAPI jsapi; + if (!jsapi.Init(wrapped->GetJSObjectGlobal())) { + return; + } + + JS::Rooted<JS::Value> update(jsapi.cx()); + if (!ToJSValue(jsapi.cx(), data, &update)) { + return; + } + + JS::Rooted<JS::Value> key(jsapi.cx(), + context->Canonical()->Top()->PermanentKey()); + + nsresult rv = funcs->UpdateSessionStore( + mOwnerContent, context, key, mEpoch, + mSessionStore->GetAndClearSHistoryChanged(), update); + if (NS_FAILED(rv)) { + return; + } + + StopTimerForUpdate(); +} + +void TabListener::RemoveListeners() { + if (mProgressListenerRegistered) { + nsCOMPtr<nsIWebProgress> webProgress = do_QueryInterface(mDocShell); + if (webProgress) { + webProgress->RemoveProgressListener(this); + mProgressListenerRegistered = false; + } + } + + RemoveEventListeners(); + + if (mPrefObserverRegistered) { + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (!obs) { + return; + } + if (mPrefObserverRegistered) { + obs->RemoveObserver(this, kTimeOutDisable); + obs->RemoveObserver(this, kPrefInterval); + mPrefObserverRegistered = false; + } + } +} + +TabListener::~TabListener() { RemoveListeners(); } diff --git a/toolkit/components/sessionstore/SessionStoreListener.h b/toolkit/components/sessionstore/SessionStoreListener.h new file mode 100644 index 0000000000..2cd35a00f5 --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreListener.h @@ -0,0 +1,114 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_SessionStoreListener_h +#define mozilla_dom_SessionStoreListener_h + +#include "SessionStoreData.h" +#include "nsIDOMEventListener.h" +#include "nsIObserver.h" +#include "nsIPrivacyTransitionObserver.h" +#include "nsIWebProgressListener.h" +#include "nsWeakReference.h" + +class nsITimer; + +namespace mozilla::dom { + +class ContentSessionStore { + public: + explicit ContentSessionStore(nsIDocShell* aDocShell); + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(ContentSessionStore) + NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(ContentSessionStore) + + void OnPrivateModeChanged(bool aEnabled); + bool IsDocCapChanged() { return mDocCapChanged; } + nsCString GetDocShellCaps(); + bool IsPrivateChanged() { return mPrivateChanged; } + bool GetPrivateModeEnabled(); + + void SetSHistoryChanged(); + // request "collect sessionHistory" which is happened in the parent process + bool GetAndClearSHistoryChanged() { + bool ret = mSHistoryChanged; + mSHistoryChanged = false; + return ret; + } + + void OnDocumentStart(); + void OnDocumentEnd(); + bool UpdateNeeded() { + return mPrivateChanged || mDocCapChanged || mSHistoryChanged; + } + + private: + virtual ~ContentSessionStore() = default; + nsCString CollectDocShellCapabilities(); + + nsCOMPtr<nsIDocShell> mDocShell; + bool mPrivateChanged; + bool mIsPrivate; + bool mDocCapChanged; + nsCString mDocCaps; + // mSHistoryChanged means there are history changes which are found + // in the child process. The flag is set when + // 1. webProgress changes to STATE_START + // 2. webProgress changes to STATE_STOP + // 3. receiving "DOMTitleChanged" event + bool mSHistoryChanged; +}; + +class TabListener : public nsIDOMEventListener, + public nsIObserver, + public nsIPrivacyTransitionObserver, + public nsIWebProgressListener, + public nsSupportsWeakReference { + public: + explicit TabListener(nsIDocShell* aDocShell, Element* aElement); + EventTarget* GetEventTarget(); + nsresult Init(); + ContentSessionStore* GetSessionStore() { return mSessionStore; } + // the function is called only when TabListener is in parent process + void ForceFlushFromParent(); + void RemoveListeners(); + void SetEpoch(uint32_t aEpoch) { mEpoch = aEpoch; } + uint32_t GetEpoch() { return mEpoch; } + void UpdateSHistoryChanges() { AddTimerForUpdate(); } + void SetOwnerContent(Element* aElement); + + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(TabListener, nsIDOMEventListener) + + NS_DECL_NSIDOMEVENTLISTENER + NS_DECL_NSIOBSERVER + NS_DECL_NSIPRIVACYTRANSITIONOBSERVER + NS_DECL_NSIWEBPROGRESSLISTENER + + private: + static void TimerCallback(nsITimer* aTimer, void* aClosure); + void AddTimerForUpdate(); + void StopTimerForUpdate(); + void AddEventListeners(); + void RemoveEventListeners(); + void UpdateSessionStore(bool aIsFlush = false); + virtual ~TabListener(); + + nsCOMPtr<nsIDocShell> mDocShell; + RefPtr<ContentSessionStore> mSessionStore; + RefPtr<mozilla::dom::Element> mOwnerContent; + bool mProgressListenerRegistered; + bool mEventListenerRegistered; + bool mPrefObserverRegistered; + // Timer used to update data + nsCOMPtr<nsITimer> mUpdatedTimer; + bool mTimeoutDisabled; + int32_t mUpdateInterval; + uint32_t mEpoch; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_SessionStoreListener_h diff --git a/toolkit/components/sessionstore/SessionStoreMessageUtils.h b/toolkit/components/sessionstore/SessionStoreMessageUtils.h new file mode 100644 index 0000000000..8475955f87 --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreMessageUtils.h @@ -0,0 +1,134 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_SessionStoreMessageUtils_h +#define mozilla_dom_SessionStoreMessageUtils_h + +#include "ipc/IPCMessageUtils.h" +#include "mozilla/ipc/IPDLParamTraits.h" +#include "mozilla/ipc/URIUtils.h" +#include "SessionStoreData.h" +#include "SessionStoreUtils.h" +#include "SessionStoreRestoreData.h" + +namespace IPC { + +template <> +struct ParamTraits<mozilla::dom::CollectedNonMultipleSelectValue> { + typedef mozilla::dom::CollectedNonMultipleSelectValue paramType; + + static void Write(MessageWriter* aWriter, const paramType& aParam) { + WriteParam(aWriter, aParam.mSelectedIndex); + WriteParam(aWriter, aParam.mValue); + } + + static bool Read(MessageReader* aReader, paramType* aResult) { + return ReadParam(aReader, &aResult->mSelectedIndex) && + ReadParam(aReader, &aResult->mValue); + } +}; + +template <> +struct ParamTraits<CollectedInputDataValue> { + typedef CollectedInputDataValue paramType; + + static void Write(MessageWriter* aWriter, const paramType& aParam) { + WriteParam(aWriter, aParam.id); + WriteParam(aWriter, aParam.type); + WriteParam(aWriter, aParam.value); + } + + static bool Read(MessageReader* aReader, paramType* aResult) { + return ReadParam(aReader, &aResult->id) && + ReadParam(aReader, &aResult->type) && + ReadParam(aReader, &aResult->value); + } +}; + +template <> +struct ParamTraits<InputFormData> { + typedef InputFormData paramType; + + static void Write(MessageWriter* aWriter, const paramType& aParam) { + WriteParam(aWriter, aParam.descendants); + WriteParam(aWriter, aParam.innerHTML); + WriteParam(aWriter, aParam.url); + WriteParam(aWriter, aParam.numId); + WriteParam(aWriter, aParam.numXPath); + } + + static bool Read(MessageReader* aReader, paramType* aResult) { + return ReadParam(aReader, &aResult->descendants) && + ReadParam(aReader, &aResult->innerHTML) && + ReadParam(aReader, &aResult->url) && + ReadParam(aReader, &aResult->numId) && + ReadParam(aReader, &aResult->numXPath); + } +}; + +} // namespace IPC + +namespace mozilla { +namespace ipc { + +template <> +struct IPDLParamTraits<mozilla::dom::SessionStoreRestoreData*> { + // Note that we intentionally don't de/serialize mChildren here. The receiver + // won't be doing anything with the children lists, and it avoids sending form + // data for subframes to the content processes of their embedders. + + static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor, + mozilla::dom::SessionStoreRestoreData* aParam) { + bool isNull = !aParam; + WriteIPDLParam(aWriter, aActor, isNull); + if (isNull) { + return; + } + WriteIPDLParam(aWriter, aActor, aParam->mURI); + WriteIPDLParam(aWriter, aActor, aParam->mInnerHTML); + WriteIPDLParam(aWriter, aActor, aParam->mScroll); + WriteIPDLParam(aWriter, aActor, aParam->mEntries); + } + + static bool Read(IPC::MessageReader* aReader, IProtocol* aActor, + RefPtr<mozilla::dom::SessionStoreRestoreData>* aResult) { + *aResult = nullptr; + bool isNull; + if (!ReadIPDLParam(aReader, aActor, &isNull)) { + return false; + } + if (isNull) { + return true; + } + auto data = MakeRefPtr<mozilla::dom::SessionStoreRestoreData>(); + if (!ReadIPDLParam(aReader, aActor, &data->mURI) || + !ReadIPDLParam(aReader, aActor, &data->mInnerHTML) || + !ReadIPDLParam(aReader, aActor, &data->mScroll) || + !ReadIPDLParam(aReader, aActor, &data->mEntries)) { + return false; + } + *aResult = std::move(data); + return true; + } +}; + +template <> +struct IPDLParamTraits<mozilla::dom::SessionStoreRestoreData::Entry> { + static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor, + mozilla::dom::SessionStoreRestoreData::Entry aParam) { + WriteIPDLParam(aWriter, aActor, aParam.mData); + WriteIPDLParam(aWriter, aActor, aParam.mIsXPath); + } + + static bool Read(IPC::MessageReader* aReader, IProtocol* aActor, + mozilla::dom::SessionStoreRestoreData::Entry* aResult) { + return ReadIPDLParam(aReader, aActor, &aResult->mData) && + ReadIPDLParam(aReader, aActor, &aResult->mIsXPath); + } +}; + +} // namespace ipc +} // namespace mozilla + +#endif // mozilla_dom_SessionStoreMessageUtils_h diff --git a/toolkit/components/sessionstore/SessionStoreParent.cpp b/toolkit/components/sessionstore/SessionStoreParent.cpp new file mode 100644 index 0000000000..58be84d4d9 --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreParent.cpp @@ -0,0 +1,318 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/SessionStoreParent.h" + +#include "mozilla/AlreadyAddRefed.h" +#include "mozilla/Assertions.h" +#include "mozilla/Maybe.h" +#include "mozilla/RefPtr.h" +#include "mozilla/ScopeExit.h" +#include "mozilla/dom/BrowserParent.h" +#include "mozilla/dom/BrowserSessionStore.h" +#include "mozilla/dom/BrowserSessionStoreBinding.h" +#include "mozilla/dom/BrowsingContext.h" +#include "mozilla/dom/InProcessChild.h" +#include "mozilla/dom/InProcessParent.h" +#include "mozilla/dom/SessionStoreChild.h" +#include "mozilla/dom/SessionStoreUtilsBinding.h" +#include "SessionStoreFunctions.h" +#include "nsISupports.h" +#include "nsIXULRuntime.h" +#include "nsImportModule.h" +#include "nsIXPConnect.h" + +#ifdef ANDROID +# include "mozilla/widget/nsWindow.h" +# include "mozilla/jni/GeckoBundleUtils.h" +# include "JavaBuiltins.h" +#endif /* ANDROID */ + +using namespace mozilla; +using namespace mozilla::dom; + +SessionStoreParent::SessionStoreParent( + CanonicalBrowsingContext* aBrowsingContext, + BrowserSessionStore* aSessionStore) + : mBrowsingContext(aBrowsingContext), mSessionStore(aSessionStore) {} + +#ifdef ANDROID +static void DoSessionStoreUpdate(CanonicalBrowsingContext* aBrowsingContext, + const Maybe<nsCString>& aDocShellCaps, + const Maybe<bool>& aPrivatedMode, + SessionStoreFormData* aFormData, + SessionStoreScrollData* aScroll, + const MaybeSessionStoreZoom& aZoom, + bool aNeedCollectSHistory, uint32_t aEpoch) { + RefPtr<BrowserSessionStore> sessionStore = + BrowserSessionStore::GetOrCreate(aBrowsingContext->Top()); + + nsCOMPtr<nsIWidget> widget = + aBrowsingContext->GetParentProcessWidgetContaining(); + if (RefPtr<nsWindow> window = nsWindow::From(widget)) { + AutoJSAPI jsapi; + if (!jsapi.Init(xpc::PrivilegedJunkScope())) { + return; + } + jni::Object::LocalRef formDataBundle(jni::GetGeckoThreadEnv()); + jni::Object::LocalRef scrollBundle(jni::GetGeckoThreadEnv()); + + if (aFormData) { + JS::Rooted<JSObject*> object(jsapi.cx()); + ErrorResult rv; + aFormData->ToJSON(jsapi.cx(), &object); + + JS::Rooted<JS::Value> value(jsapi.cx(), JS::ObjectValue(*object)); + + if (NS_FAILED(jni::BoxData(jsapi.cx(), value, formDataBundle, true))) { + JS_ClearPendingException(jsapi.cx()); + return; + } + } + + if (aScroll) { + JS::Rooted<JSObject*> object(jsapi.cx()); + ErrorResult rv; + aScroll->ToJSON(jsapi.cx(), &object); + JS::Rooted<JS::Value> value(jsapi.cx(), JS::ObjectValue(*object)); + + if (NS_FAILED(jni::BoxData(jsapi.cx(), value, scrollBundle, true))) { + JS_ClearPendingException(jsapi.cx()); + return; + } + } + + GECKOBUNDLE_START(update); + GECKOBUNDLE_PUT(update, "formdata", formDataBundle); + GECKOBUNDLE_PUT(update, "scroll", scrollBundle); + if (aZoom) { + GECKOBUNDLE_START(zoomBundle); + GECKOBUNDLE_PUT(zoomBundle, "resolution", + java::sdk::Double::New(std::get<0>(*aZoom))); + GECKOBUNDLE_START(displaySizeBundle); + GECKOBUNDLE_PUT(displaySizeBundle, "width", + java::sdk::Integer::ValueOf(std::get<1>(*aZoom))); + GECKOBUNDLE_PUT(displaySizeBundle, "height", + java::sdk::Integer::ValueOf(std::get<2>(*aZoom))); + GECKOBUNDLE_FINISH(displaySizeBundle); + GECKOBUNDLE_PUT(zoomBundle, "displaySize", displaySizeBundle); + GECKOBUNDLE_FINISH(zoomBundle); + GECKOBUNDLE_PUT(update, "zoom", zoomBundle); + } + GECKOBUNDLE_FINISH(update); + + window->OnUpdateSessionStore(update); + } +} +#else +static void DoSessionStoreUpdate(CanonicalBrowsingContext* aBrowsingContext, + const Maybe<nsCString>& aDocShellCaps, + const Maybe<bool>& aPrivatedMode, + SessionStoreFormData* aFormData, + SessionStoreScrollData* aScroll, + const MaybeSessionStoreZoom& aZoom, + bool aNeedCollectSHistory, uint32_t aEpoch) { + UpdateSessionStoreData data; + if (aDocShellCaps.isSome()) { + auto& disallow = data.mDisallow.Construct(); + if (!aDocShellCaps->IsEmpty()) { + disallow = aDocShellCaps.value(); + } else { + disallow.SetIsVoid(true); + } + } + + if (aPrivatedMode.isSome()) { + data.mIsPrivate.Construct() = aPrivatedMode.value(); + } + + RefPtr<BrowserSessionStore> sessionStore = + BrowserSessionStore::GetOrCreate(aBrowsingContext->Top()); + + if (!aFormData) { + SessionStoreFormData* formData = sessionStore->GetFormdata(); + data.mFormdata.Construct(formData); + } else { + data.mFormdata.Construct(aFormData); + } + + if (!aScroll) { + SessionStoreScrollData* scroll = sessionStore->GetScroll(); + data.mScroll.Construct(scroll); + } else { + data.mScroll.Construct(aScroll); + } + + nsCOMPtr<nsISessionStoreFunctions> funcs = do_ImportESModule( + "resource://gre/modules/SessionStoreFunctions.sys.mjs", fallible); + nsCOMPtr<nsIXPConnectWrappedJS> wrapped = do_QueryInterface(funcs); + if (!wrapped) { + return; + } + + AutoJSAPI jsapi; + if (!jsapi.Init(wrapped->GetJSObjectGlobal())) { + return; + } + + JS::Rooted<JS::Value> update(jsapi.cx()); + if (!ToJSValue(jsapi.cx(), data, &update)) { + return; + } + + JS::Rooted<JS::Value> key(jsapi.cx(), + aBrowsingContext->Top()->PermanentKey()); + + Unused << funcs->UpdateSessionStore(nullptr, aBrowsingContext, key, aEpoch, + aNeedCollectSHistory, update); +} +#endif + +void SessionStoreParent::FlushAllSessionStoreChildren( + const std::function<void()>& aDone) { + if (!mBrowsingContext) { + aDone(); + return; + } + + nsTArray<RefPtr<SessionStoreParent::FlushTabStatePromise>> flushPromises; + + // We're special casing this for when the SessionStore{Child, Parent} have + // been created in the same process. This is only ever true for the parent + // process session store actor, and is needed because + // nsFrameLoader::RequestTabStateFlush expect flushes to happen faster than we + // can manage by using the common path of sending a message the + // SessionStoreChild. Ideally we should be able to do just that, but not + // without more work. + if (InProcessParent::ChildActorFor(this)) { + // Here we assume that the session store data collection only collect for in + // (parent-)process content type browsing contexts, which we only flush one + // session store actor. + flushPromises.AppendElement(FlushSessionStore()); + } else { + // While here we flush all participating actors. + BrowserParent* browserParent = static_cast<BrowserParent*>(Manager()); + browserParent->VisitAll([&flushPromises](BrowserParent* aBrowser) { + if (PSessionStoreParent* sessionStoreParent = + SingleManagedOrNull(aBrowser->ManagedPSessionStoreParent())) { + flushPromises.AppendElement( + static_cast<SessionStoreParent*>(sessionStoreParent) + ->FlushSessionStore()); + } + }); + } + + RefPtr<SessionStoreParent::FlushTabStatePromise::AllPromiseType> + flushPromise = SessionStoreParent::FlushTabStatePromise::All( + GetMainThreadSerialEventTarget(), flushPromises); + + mBrowsingContext->UpdateSessionStoreSessionStorage([aDone, flushPromise]() { + flushPromise->Then(GetCurrentSerialEventTarget(), __func__, + [aDone]() { aDone(); }); + }); +} + +already_AddRefed<SessionStoreParent::FlushTabStatePromise> +SessionStoreParent::FlushSessionStore() { + if (!mBrowsingContext) { + return nullptr; + } + + RefPtr<SessionStoreParent::FlushTabStatePromise> promise = + SendFlushTabState(); + return promise.forget(); +} + +void SessionStoreParent::FinalFlushAllSessionStoreChildren( + const std::function<void()>& aDone) { + if (!mBrowsingContext) { + aDone(); + return; + } + + SessionStoreChild* sessionStoreChild = + static_cast<SessionStoreChild*>(InProcessParent::ChildActorFor(this)); + if (!sessionStoreChild || mozilla::SessionHistoryInParent()) { + return FlushAllSessionStoreChildren(aDone); + } + + sessionStoreChild->FlushSessionStore(); + mBrowsingContext->UpdateSessionStoreSessionStorage(aDone); +} + +mozilla::ipc::IPCResult SessionStoreParent::RecvSessionStoreUpdate( + const Maybe<nsCString>& aDocShellCaps, const Maybe<bool>& aPrivatedMode, + const MaybeSessionStoreZoom& aZoom, const bool aNeedCollectSHistory, + const uint32_t& aEpoch) { + if (!mBrowsingContext) { + return IPC_OK(); + } + + RefPtr<SessionStoreFormData> formData = + mHasNewFormData ? mSessionStore->GetFormdata() : nullptr; + RefPtr<SessionStoreScrollData> scroll = + mHasNewScrollPosition ? mSessionStore->GetScroll() : nullptr; + + DoSessionStoreUpdate(mBrowsingContext, aDocShellCaps, aPrivatedMode, formData, + scroll, aZoom, aNeedCollectSHistory, aEpoch); + + mHasNewFormData = false; + mHasNewScrollPosition = false; + + return IPC_OK(); +} + +mozilla::ipc::IPCResult SessionStoreParent::RecvIncrementalSessionStoreUpdate( + const MaybeDiscarded<BrowsingContext>& aBrowsingContext, + const Maybe<FormData>& aFormData, const Maybe<nsPoint>& aScrollPosition, + uint32_t aEpoch) { + if (!aBrowsingContext.IsNull()) { + if (aFormData.isSome()) { + mHasNewFormData = true; + } + if (aScrollPosition.isSome()) { + mHasNewScrollPosition = true; + } + + mSessionStore->UpdateSessionStore( + aBrowsingContext.GetMaybeDiscarded()->Canonical(), aFormData, + aScrollPosition, aEpoch); + } + + return IPC_OK(); +} + +mozilla::ipc::IPCResult SessionStoreParent::RecvResetSessionStore( + const MaybeDiscarded<BrowsingContext>& aBrowsingContext, uint32_t aEpoch) { + if (!aBrowsingContext.IsNull()) { + mSessionStore->RemoveSessionStore( + aBrowsingContext.GetMaybeDiscarded()->Canonical()); + } + return IPC_OK(); +} + +void SessionStoreParent::SessionStoreUpdate( + const Maybe<nsCString>& aDocShellCaps, const Maybe<bool>& aPrivatedMode, + const MaybeSessionStoreZoom& aZoom, const bool aNeedCollectSHistory, + const uint32_t& aEpoch) { + Unused << RecvSessionStoreUpdate(aDocShellCaps, aPrivatedMode, aZoom, + aNeedCollectSHistory, aEpoch); +} + +void SessionStoreParent::IncrementalSessionStoreUpdate( + const MaybeDiscarded<BrowsingContext>& aBrowsingContext, + const Maybe<FormData>& aFormData, const Maybe<nsPoint>& aScrollPosition, + uint32_t aEpoch) { + Unused << RecvIncrementalSessionStoreUpdate(aBrowsingContext, aFormData, + aScrollPosition, aEpoch); +} + +void SessionStoreParent::ResetSessionStore( + const MaybeDiscarded<BrowsingContext>& aBrowsingContext, uint32_t aEpoch) { + Unused << RecvResetSessionStore(aBrowsingContext, aEpoch); +} + +NS_IMPL_CYCLE_COLLECTION(SessionStoreParent, mBrowsingContext, mSessionStore) diff --git a/toolkit/components/sessionstore/SessionStoreParent.h b/toolkit/components/sessionstore/SessionStoreParent.h new file mode 100644 index 0000000000..0cf723985e --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreParent.h @@ -0,0 +1,79 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_SessionStoreParent_h +#define mozilla_dom_SessionStoreParent_h + +#include "mozilla/dom/BrowserSessionStore.h" +#include "mozilla/dom/CanonicalBrowsingContext.h" +#include "mozilla/dom/Element.h" +#include "mozilla/dom/PSessionStoreParent.h" +#include "mozilla/dom/WindowGlobalParent.h" +#include "mozilla/dom/SessionStoreScrollData.h" + +namespace mozilla::dom { +class BrowserParent; + +class SessionStoreParent final : public PSessionStoreParent { + public: + SessionStoreParent(CanonicalBrowsingContext* aBrowsingContext, + BrowserSessionStore* aSessionStore); + + void FlushAllSessionStoreChildren(const std::function<void()>& aDone); + + void FinalFlushAllSessionStoreChildren(const std::function<void()>& aDone); + + /** + * Sends data to be stored and instructions to the session store to + * potentially collect data in the parent. + */ + mozilla::ipc::IPCResult RecvSessionStoreUpdate( + const Maybe<nsCString>& aDocShellCaps, const Maybe<bool>& aPrivatedMode, + const MaybeSessionStoreZoom& aZoom, const bool aNeedCollectSHistory, + const uint32_t& aEpoch); + + mozilla::ipc::IPCResult RecvIncrementalSessionStoreUpdate( + const MaybeDiscarded<BrowsingContext>& aBrowsingContext, + const Maybe<FormData>& aFormData, const Maybe<nsPoint>& aScrollPosition, + uint32_t aEpoch); + + mozilla::ipc::IPCResult RecvResetSessionStore( + const MaybeDiscarded<BrowsingContext>& aBrowsingContext, uint32_t aEpoch); + + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(SessionStoreParent) + NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(SessionStoreParent) + + protected: + friend class SessionStoreChild; + void SessionStoreUpdate(const Maybe<nsCString>& aDocShellCaps, + const Maybe<bool>& aPrivatedMode, + const MaybeSessionStoreZoom& aZoom, + const bool aNeedCollectSHistory, + const uint32_t& aEpoch); + + void IncrementalSessionStoreUpdate( + const MaybeDiscarded<BrowsingContext>& aBrowsingContext, + const Maybe<FormData>& aFormData, const Maybe<nsPoint>& aScrollPosition, + uint32_t aEpoch); + + void ResetSessionStore( + const MaybeDiscarded<BrowsingContext>& aBrowsingContext, uint32_t aEpoch); + + private: + ~SessionStoreParent() = default; + + already_AddRefed<SessionStoreParent::FlushTabStatePromise> + FlushSessionStore(); + + bool mHasNewFormData = false; + bool mHasNewScrollPosition = false; + + RefPtr<CanonicalBrowsingContext> mBrowsingContext; + RefPtr<BrowserSessionStore> mSessionStore; +}; +} // namespace mozilla::dom + +#endif // mozilla_dom_SessionStoreParent_h diff --git a/toolkit/components/sessionstore/SessionStoreRestoreData.cpp b/toolkit/components/sessionstore/SessionStoreRestoreData.cpp new file mode 100644 index 0000000000..c7a92cf8ad --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreRestoreData.cpp @@ -0,0 +1,186 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/BrowsingContext.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/SessionStoreUtils.h" +#include "mozilla/dom/sessionstore/SessionStoreTypes.h" +#include "mozilla/dom/WindowContext.h" +#include "nsISessionStoreRestoreData.h" +#include "nsNetUtil.h" + +namespace mozilla { +namespace dom { + +bool SessionStoreRestoreData::IsEmpty() { + return (!mURI && mScroll.IsEmpty() && mInnerHTML.IsEmpty() && + mEntries.IsEmpty() && mChildren.IsEmpty()); +} + +SessionStoreRestoreData* SessionStoreRestoreData::FindDataForChild( + BrowsingContext* aContext) { + nsTArray<uint32_t> path; + if (!aContext->GetOffsetPath(path)) { + return nullptr; + } + + SessionStoreRestoreData* data = this; + + for (uint32_t offset : Reversed(path)) { + if (!data || data->mChildren.Length() <= offset || + !data->mChildren[offset] || data->mChildren[offset]->IsEmpty()) { + return nullptr; + } + data = data->mChildren[offset]; + } + + return data; +} + +bool SessionStoreRestoreData::CanRestoreInto(nsIURI* aDocumentURI) { + if (!mURI) { + // This should mean that we don't have form data. It's fine to restore this + // data into any document — the worst that will happen is that we restore an + // incorrect scroll position. + MOZ_ASSERT(mEntries.IsEmpty()); + MOZ_ASSERT(mInnerHTML.IsEmpty()); + return true; + } + bool equalsExceptRef = false; + return (aDocumentURI && + NS_SUCCEEDED(mURI->EqualsExceptRef(aDocumentURI, &equalsExceptRef)) && + equalsExceptRef); +} + +bool SessionStoreRestoreData::RestoreInto(RefPtr<BrowsingContext> aContext) { + if (!aContext->IsInProcess()) { + return false; + } + + if (WindowContext* window = aContext->GetCurrentWindowContext()) { + if (!mScroll.IsEmpty()) { + if (nsGlobalWindowInner* inner = window->GetInnerWindow()) { + SessionStoreUtils::RestoreScrollPosition(*inner, mScroll); + } + } + if (mURI) { + if (nsCOMPtr<Document> doc = window->GetExtantDoc()) { + if (!CanRestoreInto(doc->GetDocumentURI())) { + return false; + } + SessionStoreUtils::RestoreFormData(*doc, mInnerHTML, mEntries); + } + } + } + + return true; +} + +void SessionStoreRestoreData::AddFormEntry( + bool aIsXPath, const nsAString& aIdOrXPath, + sessionstore::FormEntryValue aValue) { + mEntries.AppendElement( + Entry{sessionstore::FormEntry{nsString(aIdOrXPath), aValue}, aIsXPath}); +} + +NS_IMPL_ISUPPORTS(SessionStoreRestoreData, nsISessionStoreRestoreData, + SessionStoreRestoreData) + +NS_IMETHODIMP +SessionStoreRestoreData::GetUrl(nsACString& aURL) { + if (mURI) { + nsresult rv = mURI->GetSpec(aURL); + NS_ENSURE_SUCCESS(rv, rv); + } + return NS_OK; +} + +NS_IMETHODIMP +SessionStoreRestoreData::SetUrl(const nsACString& aURL) { + nsresult rv = NS_NewURI(getter_AddRefs(mURI), aURL); + NS_ENSURE_SUCCESS(rv, rv); + return NS_OK; +} + +NS_IMETHODIMP +SessionStoreRestoreData::GetInnerHTML(nsAString& aInnerHTML) { + aInnerHTML = mInnerHTML; + return NS_OK; +} + +NS_IMETHODIMP +SessionStoreRestoreData::SetInnerHTML(const nsAString& aInnerHTML) { + mInnerHTML = aInnerHTML; + return NS_OK; +} + +NS_IMETHODIMP +SessionStoreRestoreData::GetScroll(nsACString& aScroll) { + aScroll = mScroll; + return NS_OK; +} + +NS_IMETHODIMP +SessionStoreRestoreData::SetScroll(const nsACString& aScroll) { + mScroll = aScroll; + return NS_OK; +} + +NS_IMETHODIMP +SessionStoreRestoreData::AddTextField(bool aIsXPath, + const nsAString& aIdOrXPath, + const nsAString& aValue) { + AddFormEntry(aIsXPath, aIdOrXPath, sessionstore::TextField{nsString(aValue)}); + return NS_OK; +} + +NS_IMETHODIMP +SessionStoreRestoreData::AddCheckbox(bool aIsXPath, const nsAString& aIdOrXPath, + const bool aValue) { + AddFormEntry(aIsXPath, aIdOrXPath, sessionstore::Checkbox{aValue}); + return NS_OK; +} + +NS_IMETHODIMP +SessionStoreRestoreData::AddFileList(bool aIsXPath, const nsAString& aIdOrXPath, + const nsAString& aType, + const nsTArray<nsString>& aFileList) { + AddFormEntry(aIsXPath, aIdOrXPath, sessionstore::FileList{aFileList}); + return NS_OK; +} + +NS_IMETHODIMP +SessionStoreRestoreData::AddSingleSelect(bool aIsXPath, + const nsAString& aIdOrXPath, + uint32_t aSelectedIndex, + const nsAString& aValue) { + AddFormEntry(aIsXPath, aIdOrXPath, + sessionstore::SingleSelect{aSelectedIndex, nsString(aValue)}); + return NS_OK; +} + +NS_IMETHODIMP +SessionStoreRestoreData::AddMultipleSelect(bool aIsXPath, + const nsAString& aIdOrXPath, + const nsTArray<nsString>& aValues) { + AddFormEntry(aIsXPath, aIdOrXPath, sessionstore::MultipleSelect{aValues}); + return NS_OK; +} + +NS_IMETHODIMP +SessionStoreRestoreData::AddChild(nsISessionStoreRestoreData* aChild, + uint32_t aIndex) { + if (nsCOMPtr<SessionStoreRestoreData> child = do_QueryInterface(aChild)) { + if (aIndex > mChildren.Length()) { + mChildren.SetLength(aIndex); + } + mChildren.InsertElementAt(aIndex, child); + } + return NS_OK; +} + +} // namespace dom +} // namespace mozilla diff --git a/toolkit/components/sessionstore/SessionStoreRestoreData.h b/toolkit/components/sessionstore/SessionStoreRestoreData.h new file mode 100644 index 0000000000..4952045e9d --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreRestoreData.h @@ -0,0 +1,59 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_SessionStoreRestoreData_h +#define mozilla_dom_SessionStoreRestoreData_h + +#include "mozilla/dom/sessionstore/SessionStoreTypes.h" +#include "mozilla/dom/SessionStoreData.h" +#include "nsISessionStoreRestoreData.h" + +namespace mozilla::dom { + +#define NS_SESSIONSTORERESTOREDATA_IID \ + { \ + 0x88800c5b, 0xe142, 0x4ac6, { \ + 0x91, 0x52, 0xca, 0xbd, 0x3b, 0x74, 0xb9, 0xf8 \ + } \ + } + +class SessionStoreRestoreData final : public nsISessionStoreRestoreData { + public: + SessionStoreRestoreData() = default; + bool IsEmpty(); + SessionStoreRestoreData* FindDataForChild(BrowsingContext* aContext); + bool CanRestoreInto(nsIURI* aDocumentURI); + MOZ_CAN_RUN_SCRIPT bool RestoreInto(RefPtr<BrowsingContext> aContext); + + NS_DECL_ISUPPORTS + NS_DECL_NSISESSIONSTORERESTOREDATA + NS_DECLARE_STATIC_IID_ACCESSOR(NS_SESSIONSTORERESTOREDATA_IID) + + struct Entry { + sessionstore::FormEntry mData; + bool mIsXPath; + }; + + private: + virtual ~SessionStoreRestoreData() = default; + void AddFormEntry(bool aIsXPath, const nsAString& aIdOrXPath, + sessionstore::FormEntryValue aValue); + + nsCString mScroll; + nsCOMPtr<nsIURI> mURI; + nsString mInnerHTML; + nsTArray<Entry> mEntries; + nsTArray<RefPtr<SessionStoreRestoreData>> mChildren; + + friend struct mozilla::ipc::IPDLParamTraits<SessionStoreRestoreData*>; +}; + +NS_DEFINE_STATIC_IID_ACCESSOR(SessionStoreRestoreData, + NS_SESSIONSTORERESTOREDATA_IID) + +} // namespace mozilla::dom + +#endif diff --git a/toolkit/components/sessionstore/SessionStoreScrollData.cpp b/toolkit/components/sessionstore/SessionStoreScrollData.cpp new file mode 100644 index 0000000000..29d58befaa --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreScrollData.cpp @@ -0,0 +1,123 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/SessionStoreScrollData.h" +#include <utility> + +#include "js/PropertyAndElement.h" +#include "js/TypeDecls.h" +#include "mozilla/Assertions.h" +#include "mozilla/RefPtr.h" +#include "mozilla/dom/BindingUtils.h" +#include "mozilla/dom/BrowserSessionStoreBinding.h" +#include "mozilla/dom/BrowsingContext.h" + +#include "nsPresContext.h" + +#include "mozilla/dom/WebIDLGlobalNameHash.h" +#include "js/PropertyDescriptor.h" + +#include "mozilla/dom/ToJSValue.h" +#include "mozilla/dom/GeneratedAtomList.h" +#include "js/StructuredClone.h" +#include "mozilla/dom/DOMJSClass.h" +#include "mozilla/dom/StructuredCloneHolder.h" +#include "nsContentUtils.h" +#include "js/Array.h" +#include "js/JSON.h" + +using namespace mozilla::dom; + +NS_IMPL_CYCLE_COLLECTING_ADDREF(SessionStoreScrollData) +NS_IMPL_CYCLE_COLLECTING_RELEASE(SessionStoreScrollData) + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_WEAK_PTR(SessionStoreScrollData, + mChildren) +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SessionStoreScrollData) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +nsISupports* SessionStoreScrollData::GetParentObject() const { + return xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + ; +} + +JSObject* SessionStoreScrollData::WrapObject( + JSContext* aCx, JS::Handle<JSObject*> aGivenProto) { + return SessionStoreScrollData_Binding::Wrap(aCx, this, aGivenProto); +} + +void SessionStoreScrollData::GetScroll(nsACString& aScroll) const { + int scrollX = nsPresContext::AppUnitsToIntCSSPixels(mScroll.x); + int scrollY = nsPresContext::AppUnitsToIntCSSPixels(mScroll.y); + + if ((scrollX != 0) || (scrollY != 0)) { + aScroll = nsPrintfCString("%d,%d", scrollX, scrollY); + } else { + aScroll.SetIsVoid(true); + } +} + +SessionStoreScrollData::ChildrenArray& SessionStoreScrollData::Children() { + return mChildren; +} + +void SessionStoreScrollData::GetChildren( + Nullable<ChildrenArray>& aChildren) const { + if (!mChildren.IsEmpty()) { + aChildren.SetValue() = mChildren.Clone(); + } else { + aChildren.SetNull(); + } +} + +void SessionStoreScrollData::ToJSON(JSContext* aCx, + JS::MutableHandle<JSObject*> aRetval) { + JS::Rooted<JSObject*> self(aCx); + { + JS::Rooted<JS::Value> value(aCx); + if (!GetOrCreateDOMReflector(aCx, this, &value)) { + return; + } + + self.set(value.toObjectOrNull()); + } + + JS::Rooted<JSObject*> result(aCx, JS_NewPlainObject(aCx)); + + if (!IsEmpty()) { + if (HasData(mScroll)) { + if (!SessionStoreUtils::CopyProperty(aCx, result, self, u"scroll"_ns)) { + return; + } + } + + SessionStoreUtils::CopyChildren(aCx, result, mChildren); + } + + aRetval.set(result); +} + +void SessionStoreScrollData::Update(const CollectedType& aUpdate) { + SessionStoreScrollData_Binding::ClearCachedScrollValue(this); + mScroll = aUpdate; +} + +void SessionStoreScrollData::ClearCachedChildren() { + SessionStoreScrollData_Binding::ClearCachedChildrenValue(this); +} + +/* static */ +bool SessionStoreScrollData::HasData(const CollectedType& aPoint) { + int scrollX = nsPresContext::AppUnitsToIntCSSPixels(aPoint.x); + int scrollY = nsPresContext::AppUnitsToIntCSSPixels(aPoint.y); + return scrollX != 0 || scrollY != 0; +} + +bool SessionStoreScrollData::IsEmpty() const { + return !HasData(mScroll) && mChildren.IsEmpty(); +} diff --git a/toolkit/components/sessionstore/SessionStoreScrollData.h b/toolkit/components/sessionstore/SessionStoreScrollData.h new file mode 100644 index 0000000000..b2f5d4bd32 --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreScrollData.h @@ -0,0 +1,69 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_SessionStoreScrollData_h +#define mozilla_dom_SessionStoreScrollData_h + +#include "js/TypeDecls.h" +#include "mozilla/WeakPtr.h" +#include "nsPoint.h" +#include "nsTArray.h" +#include "nsWrapperCache.h" +#include "mozilla/dom/WindowGlobalParent.h" +#include "mozilla/dom/SessionStoreChangeListener.h" + +namespace mozilla::dom { + +class BrowsingContext; +class WindowGlobalParent; +class OwningByteStringOrObjectOrNull; +struct SessionStoreZoomData; + +using SessionStoreZoom = std::tuple<float, uint32_t, uint32_t>; +using MaybeSessionStoreZoom = + mozilla::Maybe<std::tuple<float, uint32_t, uint32_t>>; + +class SessionStoreScrollData final : public nsISupports, + public nsWrapperCache, + public SupportsWeakPtr { + public: + using CollectedType = nsPoint; + using LocationType = WeakPtr<SessionStoreScrollData>; + using ChildrenArray = nsTArray<RefPtr<SessionStoreScrollData>>; + + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(SessionStoreScrollData) + nsISupports* GetParentObject() const; + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + void GetScroll(nsACString& aScroll) const; + + ChildrenArray& Children(); + + void GetChildren(Nullable<ChildrenArray>& aChildren) const; + + void ToJSON(JSContext* aCx, JS::MutableHandle<JSObject*> aRetval); + + void Update(const CollectedType& aUpdate); + + void ClearCachedChildren(); + + static bool HasData(const CollectedType& aPoint); + + bool IsEmpty() const; + + private: + ~SessionStoreScrollData() = default; + + nsPoint mScroll; + MaybeSessionStoreZoom mZoom; + nsTArray<RefPtr<SessionStoreScrollData>> mChildren; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_SessionStoreScrollData_h diff --git a/toolkit/components/sessionstore/SessionStoreTypes.ipdlh b/toolkit/components/sessionstore/SessionStoreTypes.ipdlh new file mode 100644 index 0000000000..c375fa0b36 --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreTypes.ipdlh @@ -0,0 +1,66 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +using struct CollectedInputDataValue from "mozilla/dom/SessionStoreMessageUtils.h"; +using struct nsPoint from "nsPoint.h"; + +include DOMTypes; + +namespace mozilla { +namespace dom { + +namespace sessionstore { +struct Checkbox { + bool value; +}; + +struct TextField { + nsString value; +}; + +struct FileList { + nsString[] valueList; +}; + +struct SingleSelect { + uint32_t index; + nsString value; +}; + +struct MultipleSelect { + nsString[] valueList; +}; + +union FormEntryValue { + Checkbox; + TextField; + FileList; + SingleSelect; + MultipleSelect; +}; + +struct FormEntry { + nsString id; + FormEntryValue value; +}; + +struct FormData { + bool hasData; + FormEntry[] id; + FormEntry[] xpath; + nsString innerHTML; + nsCString uri; +}; + +struct DocShellRestoreState { + nullable nsIURI URI; + nsCString docShellCaps; +}; + +} // sessionstore + +} // dom +} // mozilla diff --git a/toolkit/components/sessionstore/SessionStoreUtils.cpp b/toolkit/components/sessionstore/SessionStoreUtils.cpp new file mode 100644 index 0000000000..a1e78e19aa --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreUtils.cpp @@ -0,0 +1,1738 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "js/Array.h" // JS::GetArrayLength, JS::IsArrayObject +#include "js/JSON.h" +#include "js/PropertyAndElement.h" // JS_GetElement +#include "js/TypeDecls.h" +#include "jsapi.h" +#include "mozilla/BasePrincipal.h" +#include "mozilla/PresShell.h" +#include "mozilla/dom/AutocompleteInfoBinding.h" +#include "mozilla/dom/CanonicalBrowsingContext.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/DocumentInlines.h" +#include "mozilla/dom/HTMLInputElement.h" +#include "mozilla/dom/HTMLSelectElement.h" +#include "mozilla/dom/HTMLTextAreaElement.h" +#include "mozilla/dom/RootedDictionary.h" +#include "mozilla/dom/SessionStorageManager.h" +#include "mozilla/dom/PBackgroundSessionStorageCache.h" +#include "mozilla/dom/SessionStoreChangeListener.h" +#include "mozilla/dom/SessionStoreChild.h" +#include "mozilla/dom/SessionStoreUtils.h" +#include "mozilla/dom/txIXPathContext.h" +#include "mozilla/dom/WindowGlobalParent.h" +#include "mozilla/dom/WindowProxyHolder.h" +#include "mozilla/dom/XPathResult.h" +#include "mozilla/dom/XPathEvaluator.h" +#include "mozilla/dom/XPathExpression.h" +#include "mozilla/dom/PBackgroundSessionStorageCache.h" +#include "mozilla/ipc/BackgroundUtils.h" +#include "mozilla/ReverseIterator.h" +#include "mozilla/UniquePtr.h" +#include "nsCharSeparatedTokenizer.h" +#include "nsContentList.h" +#include "nsContentUtils.h" +#include "nsFocusManager.h" +#include "nsGlobalWindowOuter.h" +#include "nsIContentInlines.h" +#include "nsIDocShell.h" +#include "nsIFormControl.h" +#include "nsIScrollableFrame.h" +#include "nsISHistory.h" +#include "nsIXULRuntime.h" +#include "nsPresContext.h" +#include "nsPrintfCString.h" + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::dom::sessionstore; + +namespace { + +class DynamicFrameEventFilter final : public nsIDOMEventListener { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_CLASS(DynamicFrameEventFilter) + + explicit DynamicFrameEventFilter(EventListener* aListener) + : mListener(aListener) {} + + NS_IMETHODIMP HandleEvent(Event* aEvent) override { + if (mListener && TargetInNonDynamicDocShell(aEvent)) { + mListener->HandleEvent(*aEvent); + } + + return NS_OK; + } + + private: + ~DynamicFrameEventFilter() = default; + + bool TargetInNonDynamicDocShell(Event* aEvent) { + EventTarget* target = aEvent->GetTarget(); + if (!target) { + return false; + } + + nsPIDOMWindowOuter* outer = target->GetOwnerGlobalForBindingsInternal(); + if (!outer || !outer->GetDocShell()) { + return false; + } + + RefPtr<BrowsingContext> context = outer->GetBrowsingContext(); + return context && !context->CreatedDynamically(); + } + + RefPtr<EventListener> mListener; +}; + +NS_IMPL_CYCLE_COLLECTION(DynamicFrameEventFilter, mListener) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DynamicFrameEventFilter) + NS_INTERFACE_MAP_ENTRY(nsISupports) + NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(DynamicFrameEventFilter) +NS_IMPL_CYCLE_COLLECTING_RELEASE(DynamicFrameEventFilter) + +} // anonymous namespace + +/* static */ +void SessionStoreUtils::ForEachNonDynamicChildFrame( + const GlobalObject& aGlobal, WindowProxyHolder& aWindow, + SessionStoreUtilsFrameCallback& aCallback, ErrorResult& aRv) { + if (!aWindow.get()) { + aRv.Throw(NS_ERROR_INVALID_ARG); + return; + } + + nsCOMPtr<nsIDocShell> docShell = aWindow.get()->GetDocShell(); + if (!docShell) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + int32_t length; + aRv = docShell->GetInProcessChildCount(&length); + if (aRv.Failed()) { + return; + } + + for (int32_t i = 0; i < length; ++i) { + nsCOMPtr<nsIDocShellTreeItem> item; + docShell->GetInProcessChildAt(i, getter_AddRefs(item)); + if (!item) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + RefPtr<BrowsingContext> context = item->GetBrowsingContext(); + if (!context) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + if (!context->CreatedDynamically()) { + int32_t childOffset = context->ChildOffset(); + aCallback.Call(WindowProxyHolder(context.forget()), childOffset); + } + } +} + +/* static */ +already_AddRefed<nsISupports> +SessionStoreUtils::AddDynamicFrameFilteredListener( + const GlobalObject& aGlobal, EventTarget& aTarget, const nsAString& aType, + JS::Handle<JS::Value> aListener, bool aUseCapture, bool aMozSystemGroup, + ErrorResult& aRv) { + if (NS_WARN_IF(!aListener.isObject())) { + aRv.Throw(NS_ERROR_INVALID_ARG); + return nullptr; + } + + JSContext* cx = aGlobal.Context(); + JS::Rooted<JSObject*> obj(cx, &aListener.toObject()); + JS::Rooted<JSObject*> global(cx, JS::CurrentGlobalOrNull(cx)); + RefPtr<EventListener> listener = + new EventListener(cx, obj, global, GetIncumbentGlobal()); + + nsCOMPtr<nsIDOMEventListener> filter(new DynamicFrameEventFilter(listener)); + if (aMozSystemGroup) { + aRv = aTarget.AddSystemEventListener(aType, filter, aUseCapture); + } else { + aRv = aTarget.AddEventListener(aType, filter, aUseCapture); + } + if (aRv.Failed()) { + return nullptr; + } + + return filter.forget(); +} + +/* static */ +void SessionStoreUtils::RemoveDynamicFrameFilteredListener( + const GlobalObject& global, EventTarget& aTarget, const nsAString& aType, + nsISupports* aListener, bool aUseCapture, bool aMozSystemGroup, + ErrorResult& aRv) { + nsCOMPtr<nsIDOMEventListener> listener = do_QueryInterface(aListener); + if (!listener) { + aRv.Throw(NS_ERROR_NO_INTERFACE); + return; + } + + if (aMozSystemGroup) { + aTarget.RemoveSystemEventListener(aType, listener, aUseCapture); + } else { + aTarget.RemoveEventListener(aType, listener, aUseCapture); + } +} + +/* static */ +void SessionStoreUtils::CollectDocShellCapabilities(const GlobalObject& aGlobal, + nsIDocShell* aDocShell, + nsCString& aRetVal) { + bool allow; + +#define TRY_ALLOWPROP(y) \ + PR_BEGIN_MACRO \ + aDocShell->GetAllow##y(&allow); \ + if (!allow) { \ + if (!aRetVal.IsEmpty()) { \ + aRetVal.Append(','); \ + } \ + aRetVal.Append(#y); \ + } \ + PR_END_MACRO + + TRY_ALLOWPROP(Plugins); + // Bug 1328013 : Don't collect "AllowJavascript" property + // TRY_ALLOWPROP(Javascript); + TRY_ALLOWPROP(MetaRedirects); + TRY_ALLOWPROP(Subframes); + TRY_ALLOWPROP(Images); + TRY_ALLOWPROP(Media); + TRY_ALLOWPROP(DNSPrefetch); + TRY_ALLOWPROP(WindowControl); + TRY_ALLOWPROP(Auth); + TRY_ALLOWPROP(ContentRetargeting); + TRY_ALLOWPROP(ContentRetargetingOnChildren); +#undef TRY_ALLOWPROP +} + +/* static */ +void SessionStoreUtils::RestoreDocShellCapabilities( + nsIDocShell* aDocShell, const nsCString& aDisallowCapabilities) { + aDocShell->SetAllowPlugins(true); + aDocShell->SetAllowMetaRedirects(true); + aDocShell->SetAllowSubframes(true); + aDocShell->SetAllowImages(true); + aDocShell->SetAllowMedia(true); + aDocShell->SetAllowDNSPrefetch(true); + aDocShell->SetAllowWindowControl(true); + aDocShell->SetAllowContentRetargeting(true); + aDocShell->SetAllowContentRetargetingOnChildren(true); + + bool allowJavascript = true; + for (const nsACString& token : + nsCCharSeparatedTokenizer(aDisallowCapabilities, ',').ToRange()) { + if (token.EqualsLiteral("Plugins")) { + aDocShell->SetAllowPlugins(false); + } else if (token.EqualsLiteral("Javascript")) { + allowJavascript = false; + } else if (token.EqualsLiteral("MetaRedirects")) { + aDocShell->SetAllowMetaRedirects(false); + } else if (token.EqualsLiteral("Subframes")) { + aDocShell->SetAllowSubframes(false); + } else if (token.EqualsLiteral("Images")) { + aDocShell->SetAllowImages(false); + } else if (token.EqualsLiteral("Media")) { + aDocShell->SetAllowMedia(false); + } else if (token.EqualsLiteral("DNSPrefetch")) { + aDocShell->SetAllowDNSPrefetch(false); + } else if (token.EqualsLiteral("WindowControl")) { + aDocShell->SetAllowWindowControl(false); + } else if (token.EqualsLiteral("ContentRetargeting")) { + bool allow; + aDocShell->GetAllowContentRetargetingOnChildren(&allow); + aDocShell->SetAllowContentRetargeting( + false); // will also set AllowContentRetargetingOnChildren + aDocShell->SetAllowContentRetargetingOnChildren( + allow); // restore the allowProp to original + } else if (token.EqualsLiteral("ContentRetargetingOnChildren")) { + aDocShell->SetAllowContentRetargetingOnChildren(false); + } + } + + if (!mozilla::SessionHistoryInParent()) { + // With SessionHistoryInParent, this is set from the parent process. + BrowsingContext* bc = aDocShell->GetBrowsingContext(); + Unused << bc->SetAllowJavascript(allowJavascript); + } +} + +static void CollectCurrentScrollPosition(JSContext* aCx, Document& aDocument, + Nullable<CollectedData>& aRetVal) { + PresShell* presShell = aDocument.GetPresShell(); + if (!presShell) { + return; + } + nsPoint scrollPos = presShell->GetVisualViewportOffset(); + int scrollX = nsPresContext::AppUnitsToIntCSSPixels(scrollPos.x); + int scrollY = nsPresContext::AppUnitsToIntCSSPixels(scrollPos.y); + + if ((scrollX != 0) || (scrollY != 0)) { + aRetVal.SetValue().mScroll.Construct() = + nsPrintfCString("%d,%d", scrollX, scrollY); + } +} + +/* static */ +void SessionStoreUtils::RestoreScrollPosition(const GlobalObject& aGlobal, + nsGlobalWindowInner& aWindow, + const CollectedData& aData) { + if (aData.mScroll.WasPassed()) { + RestoreScrollPosition(aWindow, aData.mScroll.Value()); + } +} + +/* static */ +void SessionStoreUtils::RestoreScrollPosition( + nsGlobalWindowInner& aWindow, const nsCString& aScrollPosition) { + using Change = mozilla::dom::SessionStoreChangeListener::Change; + SessionStoreChangeListener::CollectSessionStoreData( + aWindow.GetWindowContext(), EnumSet<Change>(Change::Scroll)); + + nsCCharSeparatedTokenizer tokenizer(aScrollPosition, ','); + nsAutoCString token(tokenizer.nextToken()); + int pos_X = atoi(token.get()); + token = tokenizer.nextToken(); + int pos_Y = atoi(token.get()); + + aWindow.ScrollTo(pos_X, pos_Y); + + if (nsCOMPtr<Document> doc = aWindow.GetExtantDoc()) { + if (nsPresContext* presContext = doc->GetPresContext()) { + if (presContext->IsRootContentDocumentCrossProcess()) { + // Use eMainThread so this takes precedence over session history + // (ScrollFrameHelper::ScrollToRestoredPosition()). + presContext->PresShell()->ScrollToVisual( + CSSPoint::ToAppUnits(CSSPoint(pos_X, pos_Y)), + layers::FrameMetrics::eMainThread, ScrollMode::Instant); + } + } + } +} + +// Implements the Luhn checksum algorithm as described at +// http://wikipedia.org/wiki/Luhn_algorithm +// Number digit lengths vary with network, but should fall within 12-19 range. +// [2] More details at https://en.wikipedia.org/wiki/Payment_card_number +static bool IsValidCCNumber(nsAString& aValue) { + uint32_t total = 0; + uint32_t numLength = 0; + uint32_t strLen = aValue.Length(); + for (uint32_t i = 0; i < strLen; ++i) { + uint32_t idx = strLen - i - 1; + // ignore whitespace and dashes) + char16_t chr = aValue[idx]; + if (IsSpaceCharacter(chr) || chr == '-') { + continue; + } + // If our number is too long, note that fact + ++numLength; + if (numLength > 19) { + return false; + } + // Try to parse the character as a base-10 integer. + nsresult rv = NS_OK; + uint32_t val = Substring(aValue, idx, 1).ToInteger(&rv, 10); + if (NS_FAILED(rv)) { + return false; + } + if (i % 2 == 1) { + val *= 2; + if (val > 9) { + val -= 9; + } + } + total += val; + } + + return numLength >= 12 && total % 10 == 0; +} + +// Limit the number of XPath expressions for performance reasons. See bug +// 477564. +static const uint16_t kMaxTraversedXPaths = 100; + +// A helper function to append a element into mId or mXpath of CollectedData +static Record<nsString, OwningStringOrBooleanOrObject>::EntryType* +AppendEntryToCollectedData(nsINode* aNode, const nsAString& aId, + uint16_t& aGeneratedCount, + Nullable<CollectedData>& aRetVal) { + Record<nsString, OwningStringOrBooleanOrObject>::EntryType* entry; + if (!aId.IsEmpty()) { + if (!aRetVal.SetValue().mId.WasPassed()) { + aRetVal.SetValue().mId.Construct(); + } + auto& recordEntries = aRetVal.SetValue().mId.Value().Entries(); + entry = recordEntries.AppendElement(); + entry->mKey = aId; + } else { + if (!aRetVal.SetValue().mXpath.WasPassed()) { + aRetVal.SetValue().mXpath.Construct(); + } + auto& recordEntries = aRetVal.SetValue().mXpath.Value().Entries(); + entry = recordEntries.AppendElement(); + nsAutoString xpath; + aNode->GenerateXPath(xpath); + aGeneratedCount++; + entry->mKey = xpath; + } + return entry; +} + +/* for bool value */ +static void AppendValueToCollectedData(nsINode* aNode, const nsAString& aId, + const bool& aValue, + uint16_t& aGeneratedCount, + JSContext* aCx, + Nullable<CollectedData>& aRetVal) { + Record<nsString, OwningStringOrBooleanOrObject>::EntryType* entry = + AppendEntryToCollectedData(aNode, aId, aGeneratedCount, aRetVal); + entry->mValue.SetAsBoolean() = aValue; +} + +/* for nsString value */ +static void AppendValueToCollectedData(nsINode* aNode, const nsAString& aId, + const nsString& aValue, + uint16_t& aGeneratedCount, + Nullable<CollectedData>& aRetVal) { + Record<nsString, OwningStringOrBooleanOrObject>::EntryType* entry = + AppendEntryToCollectedData(aNode, aId, aGeneratedCount, aRetVal); + entry->mValue.SetAsString() = aValue; +} + +/* for single select value */ +static void AppendValueToCollectedData( + nsINode* aNode, const nsAString& aId, + const CollectedNonMultipleSelectValue& aValue, uint16_t& aGeneratedCount, + JSContext* aCx, Nullable<CollectedData>& aRetVal) { + JS::Rooted<JS::Value> jsval(aCx); + if (!ToJSValue(aCx, aValue, &jsval)) { + JS_ClearPendingException(aCx); + return; + } + Record<nsString, OwningStringOrBooleanOrObject>::EntryType* entry = + AppendEntryToCollectedData(aNode, aId, aGeneratedCount, aRetVal); + entry->mValue.SetAsObject() = &jsval.toObject(); +} + +/* special handing for input element with string type */ +static void AppendValueToCollectedData(Document& aDocument, nsINode* aNode, + const nsAString& aId, + const nsString& aValue, + uint16_t& aGeneratedCount, + JSContext* aCx, + Nullable<CollectedData>& aRetVal) { + if (!aId.IsEmpty()) { + // We want to avoid saving data for about:sessionrestore as a string. + // Since it's stored in the form as stringified JSON, stringifying + // further causes an explosion of escape characters. cf. bug 467409 + if (aId.EqualsLiteral("sessionData")) { + nsAutoCString url; + Unused << aDocument.GetDocumentURI()->GetSpecIgnoringRef(url); + if (url.EqualsLiteral("about:sessionrestore") || + url.EqualsLiteral("about:welcomeback")) { + JS::Rooted<JS::Value> jsval(aCx); + if (JS_ParseJSON(aCx, aValue.get(), aValue.Length(), &jsval) && + jsval.isObject()) { + Record<nsString, OwningStringOrBooleanOrObject>::EntryType* entry = + AppendEntryToCollectedData(aNode, aId, aGeneratedCount, aRetVal); + entry->mValue.SetAsObject() = &jsval.toObject(); + } else { + JS_ClearPendingException(aCx); + } + return; + } + } + } + AppendValueToCollectedData(aNode, aId, aValue, aGeneratedCount, aRetVal); +} + +/* for nsTArray<nsString>: file and multipleSelect */ +static void AppendValueToCollectedData(nsINode* aNode, const nsAString& aId, + const nsAString& aValueType, + nsTArray<nsString>& aValue, + uint16_t& aGeneratedCount, + JSContext* aCx, + Nullable<CollectedData>& aRetVal) { + JS::Rooted<JS::Value> jsval(aCx); + if (aValueType.EqualsLiteral("file")) { + CollectedFileListValue val; + val.mType = aValueType; + val.mFileList = std::move(aValue); + if (!ToJSValue(aCx, val, &jsval)) { + JS_ClearPendingException(aCx); + return; + } + } else { + if (!ToJSValue(aCx, aValue, &jsval)) { + JS_ClearPendingException(aCx); + return; + } + } + Record<nsString, OwningStringOrBooleanOrObject>::EntryType* entry = + AppendEntryToCollectedData(aNode, aId, aGeneratedCount, aRetVal); + entry->mValue.SetAsObject() = &jsval.toObject(); +} + +// This isn't size as in binary size, just a heuristic to not store too large +// fields in session store. See StaticPrefs::browser_sessionstore_dom_form_limit +static uint32_t SizeOfFormEntry(const FormEntryValue& aValue) { + uint32_t size = 0; + switch (aValue.type()) { + case FormEntryValue::TCheckbox: + size = aValue.get_Checkbox().value() ? 4 : 5; + break; + case FormEntryValue::TTextField: + size = aValue.get_TextField().value().Length(); + break; + case FormEntryValue::TFileList: { + for (const auto& value : aValue.get_FileList().valueList()) { + size += value.Length(); + } + break; + } + case FormEntryValue::TSingleSelect: + size = aValue.get_SingleSelect().value().Length(); + break; + case FormEntryValue::TMultipleSelect: { + for (const auto& value : aValue.get_MultipleSelect().valueList()) { + size += value.Length(); + } + break; + } + default: + break; + } + return size; +} + +static uint32_t AppendEntry(nsINode* aNode, const nsString& aId, + const FormEntryValue& aValue, + sessionstore::FormData& aFormData) { + uint32_t size = SizeOfFormEntry(aValue); + if (size > StaticPrefs::browser_sessionstore_dom_form_limit()) { + return 0; + } + + if (aId.IsEmpty()) { + FormEntry* entry = aFormData.xpath().AppendElement(); + entry->value() = aValue; + aNode->GenerateXPath(entry->id()); + size += entry->id().Length(); + } else { + aFormData.id().AppendElement(FormEntry{aId, aValue}); + size += aId.Length(); + } + + return size; +} + +static uint32_t CollectTextAreaElement(Document* aDocument, + sessionstore::FormData& aFormData) { + uint32_t size = 0; + RefPtr<nsContentList> textlist = + NS_GetContentList(aDocument, kNameSpaceID_XHTML, u"textarea"_ns); + uint32_t length = textlist->Length(); + for (uint32_t i = 0; i < length; ++i) { + MOZ_ASSERT(textlist->Item(i), "null item in node list!"); + + HTMLTextAreaElement* textArea = + HTMLTextAreaElement::FromNodeOrNull(textlist->Item(i)); + if (!textArea) { + continue; + } + DOMString autocomplete; + textArea->GetAutocomplete(autocomplete); + if (autocomplete.AsAString().EqualsLiteral("off")) { + continue; + } + nsAutoString id; + textArea->GetId(id); + if (id.IsEmpty() && (aFormData.xpath().Length() > kMaxTraversedXPaths)) { + continue; + } + nsString value; + textArea->GetValue(value); + // In order to reduce XPath generation (which is slow), we only save data + // for form fields that have been changed. (cf. bug 537289) + if (textArea->AttrValueIs(kNameSpaceID_None, nsGkAtoms::value, value, + eCaseMatters)) { + continue; + } + + size += AppendEntry(textArea, id, TextField{value}, aFormData); + } + + return size; +} + +static uint32_t CollectInputElement(Document* aDocument, + sessionstore::FormData& aFormData) { + uint32_t size = 0; + RefPtr<nsContentList> inputlist = + NS_GetContentList(aDocument, kNameSpaceID_XHTML, u"input"_ns); + uint32_t length = inputlist->Length(); + for (uint32_t i = 0; i < length; ++i) { + MOZ_ASSERT(inputlist->Item(i), "null item in node list!"); + nsCOMPtr<nsIFormControl> formControl = + do_QueryInterface(inputlist->Item(i)); + if (formControl) { + auto controlType = formControl->ControlType(); + if (controlType == FormControlType::InputPassword || + controlType == FormControlType::InputHidden || + controlType == FormControlType::InputButton || + controlType == FormControlType::InputImage || + controlType == FormControlType::InputSubmit || + controlType == FormControlType::InputReset) { + continue; + } + } + RefPtr<HTMLInputElement> input = + HTMLInputElement::FromNodeOrNull(inputlist->Item(i)); + if (!input || !nsContentUtils::IsAutocompleteEnabled(input)) { + continue; + } + nsAutoString id; + input->GetId(id); + if (id.IsEmpty() && (aFormData.xpath().Length() > kMaxTraversedXPaths)) { + continue; + } + Nullable<AutocompleteInfo> aInfo; + input->GetAutocompleteInfo(aInfo); + if (!aInfo.IsNull() && !aInfo.Value().mCanAutomaticallyPersist) { + continue; + } + + FormEntryValue value; + if (input->ControlType() == FormControlType::InputCheckbox || + input->ControlType() == FormControlType::InputRadio) { + bool checked = input->Checked(); + if (checked == input->DefaultChecked()) { + continue; + } + size += AppendEntry(input, id, Checkbox{checked}, aFormData); + } else if (input->ControlType() == FormControlType::InputFile) { + IgnoredErrorResult rv; + sessionstore::FileList file; + input->MozGetFileNameArray(file.valueList(), rv); + if (rv.Failed() || file.valueList().IsEmpty()) { + continue; + } + size += AppendEntry(input, id, file, aFormData); + } else { + TextField field; + input->GetValue(field.value(), CallerType::System); + auto& value = field.value(); + // In order to reduce XPath generation (which is slow), we only save data + // for form fields that have been changed. (cf. bug 537289) + // Also, don't want to collect credit card number. + if (value.IsEmpty() || IsValidCCNumber(value) || + input->HasBeenTypePassword() || + input->AttrValueIs(kNameSpaceID_None, nsGkAtoms::value, value, + eCaseMatters)) { + continue; + } + size += AppendEntry(input, id, field, aFormData); + } + } + + return size; +} + +static uint32_t CollectSelectElement(Document* aDocument, + sessionstore::FormData& aFormData) { + uint32_t size = 0; + RefPtr<nsContentList> selectlist = + NS_GetContentList(aDocument, kNameSpaceID_XHTML, u"select"_ns); + uint32_t length = selectlist->Length(); + for (uint32_t i = 0; i < length; ++i) { + MOZ_ASSERT(selectlist->Item(i), "null item in node list!"); + RefPtr<HTMLSelectElement> select = + HTMLSelectElement::FromNodeOrNull(selectlist->Item(i)); + if (!select) { + continue; + } + nsAutoString id; + select->GetId(id); + if (id.IsEmpty() && (aFormData.xpath().Length() > kMaxTraversedXPaths)) { + continue; + } + AutocompleteInfo aInfo; + select->GetAutocompleteInfo(aInfo); + if (!aInfo.mCanAutomaticallyPersist) { + continue; + } + + if (!select->Multiple()) { + HTMLOptionsCollection* options = select->GetOptions(); + if (!options) { + continue; + } + + uint32_t numOptions = options->Length(); + int32_t defaultIndex = 0; + for (uint32_t idx = 0; idx < numOptions; idx++) { + HTMLOptionElement* option = options->ItemAsOption(idx); + if (option->DefaultSelected()) { + defaultIndex = option->Index(); + } + } + + int32_t selectedIndex = select->SelectedIndex(); + if (selectedIndex == defaultIndex || selectedIndex < 0) { + continue; + } + + DOMString selectVal; + select->GetValue(selectVal); + size += AppendEntry(select, id, + SingleSelect{static_cast<uint32_t>(selectedIndex), + selectVal.AsAString()}, + aFormData); + } else { + HTMLOptionsCollection* options = select->GetOptions(); + if (!options) { + continue; + } + bool hasDefaultValue = true; + nsTArray<nsString> selectslist; + uint32_t numOptions = options->Length(); + for (uint32_t idx = 0; idx < numOptions; idx++) { + HTMLOptionElement* option = options->ItemAsOption(idx); + bool selected = option->Selected(); + + hasDefaultValue = + hasDefaultValue && (selected == option->DefaultSelected()); + + if (!selected) { + continue; + } + option->GetValue(*selectslist.AppendElement()); + } + // In order to reduce XPath generation (which is slow), we only save data + // for form fields that have been changed. (cf. bug 537289) + if (hasDefaultValue) { + continue; + } + + size += AppendEntry(select, id, MultipleSelect{selectslist}, aFormData); + } + } + + return size; +} + +/* static */ +uint32_t SessionStoreUtils::CollectFormData(Document* aDocument, + sessionstore::FormData& aFormData) { + MOZ_DIAGNOSTIC_ASSERT(aDocument); + uint32_t size = 0; + size += CollectTextAreaElement(aDocument, aFormData); + size += CollectInputElement(aDocument, aFormData); + size += CollectSelectElement(aDocument, aFormData); + + aFormData.hasData() = + !aFormData.id().IsEmpty() || !aFormData.xpath().IsEmpty(); + + return size; +} + +/* static */ +template <typename... ArgsT> +void SessionStoreUtils::CollectFromTextAreaElement(Document& aDocument, + uint16_t& aGeneratedCount, + ArgsT&&... args) { + RefPtr<nsContentList> textlist = + NS_GetContentList(&aDocument, kNameSpaceID_XHTML, u"textarea"_ns); + uint32_t length = textlist->Length(true); + for (uint32_t i = 0; i < length; ++i) { + MOZ_ASSERT(textlist->Item(i), "null item in node list!"); + + HTMLTextAreaElement* textArea = + HTMLTextAreaElement::FromNodeOrNull(textlist->Item(i)); + if (!textArea) { + continue; + } + DOMString autocomplete; + textArea->GetAutocomplete(autocomplete); + if (autocomplete.AsAString().EqualsLiteral("off")) { + continue; + } + nsAutoString id; + textArea->GetId(id); + if (id.IsEmpty() && (aGeneratedCount > kMaxTraversedXPaths)) { + continue; + } + nsString value; + textArea->GetValue(value); + // In order to reduce XPath generation (which is slow), we only save data + // for form fields that have been changed. (cf. bug 537289) + if (textArea->AttrValueIs(kNameSpaceID_None, nsGkAtoms::value, value, + eCaseMatters)) { + continue; + } + AppendValueToCollectedData(textArea, id, value, aGeneratedCount, + std::forward<ArgsT>(args)...); + } +} + +/* static */ +template <typename... ArgsT> +void SessionStoreUtils::CollectFromInputElement(Document& aDocument, + uint16_t& aGeneratedCount, + ArgsT&&... args) { + RefPtr<nsContentList> inputlist = + NS_GetContentList(&aDocument, kNameSpaceID_XHTML, u"input"_ns); + uint32_t length = inputlist->Length(true); + for (uint32_t i = 0; i < length; ++i) { + MOZ_ASSERT(inputlist->Item(i), "null item in node list!"); + nsCOMPtr<nsIFormControl> formControl = + do_QueryInterface(inputlist->Item(i)); + if (formControl) { + auto controlType = formControl->ControlType(); + if (controlType == FormControlType::InputPassword || + controlType == FormControlType::InputHidden || + controlType == FormControlType::InputButton || + controlType == FormControlType::InputImage || + controlType == FormControlType::InputSubmit || + controlType == FormControlType::InputReset) { + continue; + } + } + RefPtr<HTMLInputElement> input = + HTMLInputElement::FromNodeOrNull(inputlist->Item(i)); + if (!input || !nsContentUtils::IsAutocompleteEnabled(input)) { + continue; + } + nsAutoString id; + input->GetId(id); + if (id.IsEmpty() && (aGeneratedCount > kMaxTraversedXPaths)) { + continue; + } + Nullable<AutocompleteInfo> aInfo; + input->GetAutocompleteInfo(aInfo); + if (!aInfo.IsNull() && !aInfo.Value().mCanAutomaticallyPersist) { + continue; + } + + if (input->ControlType() == FormControlType::InputCheckbox || + input->ControlType() == FormControlType::InputRadio) { + bool checked = input->Checked(); + if (checked == input->DefaultChecked()) { + continue; + } + AppendValueToCollectedData(input, id, checked, aGeneratedCount, + std::forward<ArgsT>(args)...); + } else if (input->ControlType() == FormControlType::InputFile) { + IgnoredErrorResult rv; + nsTArray<nsString> result; + input->MozGetFileNameArray(result, rv); + if (rv.Failed() || result.Length() == 0) { + continue; + } + AppendValueToCollectedData(input, id, u"file"_ns, result, aGeneratedCount, + std::forward<ArgsT>(args)...); + } else { + nsString value; + input->GetValue(value, CallerType::System); + // In order to reduce XPath generation (which is slow), we only save data + // for form fields that have been changed. (cf. bug 537289) + // Also, don't want to collect credit card number. + if (value.IsEmpty() || IsValidCCNumber(value) || + input->HasBeenTypePassword() || + input->AttrValueIs(kNameSpaceID_None, nsGkAtoms::value, value, + eCaseMatters)) { + continue; + } + AppendValueToCollectedData(aDocument, input, id, value, aGeneratedCount, + std::forward<ArgsT>(args)...); + } + } +} + +/* static */ +template <typename... ArgsT> +void SessionStoreUtils::CollectFromSelectElement(Document& aDocument, + uint16_t& aGeneratedCount, + ArgsT&&... args) { + RefPtr<nsContentList> selectlist = + NS_GetContentList(&aDocument, kNameSpaceID_XHTML, u"select"_ns); + uint32_t length = selectlist->Length(true); + for (uint32_t i = 0; i < length; ++i) { + MOZ_ASSERT(selectlist->Item(i), "null item in node list!"); + RefPtr<HTMLSelectElement> select = + HTMLSelectElement::FromNodeOrNull(selectlist->Item(i)); + if (!select) { + continue; + } + nsAutoString id; + select->GetId(id); + if (id.IsEmpty() && (aGeneratedCount > kMaxTraversedXPaths)) { + continue; + } + AutocompleteInfo aInfo; + select->GetAutocompleteInfo(aInfo); + if (!aInfo.mCanAutomaticallyPersist) { + continue; + } + nsAutoCString value; + if (!select->Multiple()) { + // <select>s without the multiple attribute are hard to determine the + // default value, so assume we don't have the default. + DOMString selectVal; + select->GetValue(selectVal); + CollectedNonMultipleSelectValue val; + val.mSelectedIndex = select->SelectedIndex(); + val.mValue = selectVal.AsAString(); + AppendValueToCollectedData(select, id, val, aGeneratedCount, + std::forward<ArgsT>(args)...); + } else { + // <select>s with the multiple attribute are easier to determine the + // default value since each <option> has a defaultSelected property + HTMLOptionsCollection* options = select->GetOptions(); + if (!options) { + continue; + } + bool hasDefaultValue = true; + nsTArray<nsString> selectslist; + uint32_t numOptions = options->Length(); + for (uint32_t idx = 0; idx < numOptions; idx++) { + HTMLOptionElement* option = options->ItemAsOption(idx); + bool selected = option->Selected(); + if (!selected) { + continue; + } + option->GetValue(*selectslist.AppendElement()); + hasDefaultValue = + hasDefaultValue && (selected == option->DefaultSelected()); + } + // In order to reduce XPath generation (which is slow), we only save data + // for form fields that have been changed. (cf. bug 537289) + if (hasDefaultValue) { + continue; + } + + AppendValueToCollectedData(select, id, u"multipleSelect"_ns, selectslist, + aGeneratedCount, std::forward<ArgsT>(args)...); + } + } +} + +static void CollectCurrentFormData(JSContext* aCx, Document& aDocument, + Nullable<CollectedData>& aRetVal) { + uint16_t generatedCount = 0; + /* textarea element */ + SessionStoreUtils::CollectFromTextAreaElement(aDocument, generatedCount, + aRetVal); + /* input element */ + SessionStoreUtils::CollectFromInputElement(aDocument, generatedCount, aCx, + aRetVal); + /* select element */ + SessionStoreUtils::CollectFromSelectElement(aDocument, generatedCount, aCx, + aRetVal); + + Element* bodyElement = aDocument.GetBody(); + if (bodyElement && bodyElement->IsInDesignMode()) { + bodyElement->GetInnerHTML(aRetVal.SetValue().mInnerHTML.Construct(), + IgnoreErrors()); + } + + if (aRetVal.IsNull()) { + return; + } + + // Store the frame's current URL with its form data so that we can compare + // it when restoring data to not inject form data into the wrong document. + nsIURI* uri = aDocument.GetDocumentURI(); + if (uri) { + uri->GetSpecIgnoringRef(aRetVal.SetValue().mUrl.Construct()); + } +} + +MOZ_CAN_RUN_SCRIPT +static void SetElementAsString(Element* aElement, const nsAString& aValue) { + IgnoredErrorResult rv; + if (auto* textArea = HTMLTextAreaElement::FromNode(aElement)) { + textArea->SetValue(aValue, rv); + if (!rv.Failed()) { + nsContentUtils::DispatchInputEvent(aElement); + } + return; + } + if (auto* input = HTMLInputElement::FromNode(aElement)) { + input->SetValue(aValue, CallerType::NonSystem, rv); + if (!rv.Failed()) { + nsContentUtils::DispatchInputEvent(aElement); + } + return; + } +} + +MOZ_CAN_RUN_SCRIPT +static void SetElementAsBool(Element* aElement, bool aValue) { + HTMLInputElement* input = HTMLInputElement::FromNode(aElement); + if (input) { + bool checked = input->Checked(); + if (aValue != checked) { + input->SetChecked(aValue); + nsContentUtils::DispatchInputEvent(aElement); + } + } +} + +MOZ_CAN_RUN_SCRIPT +static void SetElementAsFiles(HTMLInputElement* aElement, + const CollectedFileListValue& aValue) { + IgnoredErrorResult rv; + aElement->MozSetFileNameArray(aValue.mFileList, rv); + if (rv.Failed()) { + return; + } + nsContentUtils::DispatchInputEvent(aElement); +} + +MOZ_CAN_RUN_SCRIPT +static void SetElementAsSelect(HTMLSelectElement* aElement, + const CollectedNonMultipleSelectValue& aValue) { + HTMLOptionsCollection* options = aElement->GetOptions(); + if (!options) { + return; + } + int32_t selectIdx = options->SelectedIndex(); + if (selectIdx >= 0) { + nsAutoString selectOptionVal; + options->ItemAsOption(selectIdx)->GetValue(selectOptionVal); + if (aValue.mValue.Equals(selectOptionVal)) { + return; + } + } + uint32_t numOptions = options->Length(); + for (uint32_t idx = 0; idx < numOptions; idx++) { + HTMLOptionElement* option = options->ItemAsOption(idx); + nsAutoString optionValue; + option->GetValue(optionValue); + if (aValue.mValue.Equals(optionValue)) { + aElement->SetSelectedIndex(idx); + nsContentUtils::DispatchInputEvent(aElement); + } + } +} + +MOZ_CAN_RUN_SCRIPT +static void SetElementAsMultiSelect(HTMLSelectElement* aElement, + const nsTArray<nsString>& aValueArray) { + bool fireEvent = false; + HTMLOptionsCollection* options = aElement->GetOptions(); + if (!options) { + return; + } + uint32_t numOptions = options->Length(); + for (uint32_t idx = 0; idx < numOptions; idx++) { + HTMLOptionElement* option = options->ItemAsOption(idx); + nsAutoString optionValue; + option->GetValue(optionValue); + for (uint32_t i = 0, l = aValueArray.Length(); i < l; ++i) { + if (optionValue.Equals(aValueArray[i])) { + option->SetSelected(true); + if (!option->DefaultSelected()) { + fireEvent = true; + } + } + } + } + if (fireEvent) { + nsContentUtils::DispatchInputEvent(aElement); + } +} + +MOZ_CAN_RUN_SCRIPT +static void SetElementAsObject(JSContext* aCx, Element* aElement, + JS::Handle<JS::Value> aObject) { + RefPtr<HTMLInputElement> input = HTMLInputElement::FromNode(aElement); + if (input) { + if (input->ControlType() == FormControlType::InputFile) { + CollectedFileListValue value; + if (value.Init(aCx, aObject)) { + SetElementAsFiles(input, value); + } else { + JS_ClearPendingException(aCx); + } + } + return; + } + RefPtr<HTMLSelectElement> select = HTMLSelectElement::FromNode(aElement); + if (select) { + // For Single Select Element + if (!select->Multiple()) { + CollectedNonMultipleSelectValue value; + if (value.Init(aCx, aObject)) { + SetElementAsSelect(select, value); + } else { + JS_ClearPendingException(aCx); + } + return; + } + + // For Multiple Selects Element + bool isArray = false; + JS::IsArrayObject(aCx, aObject, &isArray); + if (!isArray) { + return; + } + JS::Rooted<JSObject*> arrayObj(aCx, &aObject.toObject()); + uint32_t arrayLength = 0; + if (!JS::GetArrayLength(aCx, arrayObj, &arrayLength)) { + JS_ClearPendingException(aCx); + return; + } + nsTArray<nsString> array(arrayLength); + for (uint32_t arrayIdx = 0; arrayIdx < arrayLength; arrayIdx++) { + JS::Rooted<JS::Value> element(aCx); + if (!JS_GetElement(aCx, arrayObj, arrayIdx, &element)) { + JS_ClearPendingException(aCx); + return; + } + if (!element.isString()) { + return; + } + nsAutoJSString value; + if (!value.init(aCx, element)) { + JS_ClearPendingException(aCx); + return; + } + array.AppendElement(value); + } + SetElementAsMultiSelect(select, array); + } +} + +MOZ_CAN_RUN_SCRIPT +static void SetSessionData(JSContext* aCx, Element* aElement, + JS::MutableHandle<JS::Value> aObject) { + nsAutoString data; + if (nsContentUtils::StringifyJSON(aCx, aObject, data, + UndefinedIsNullStringLiteral)) { + SetElementAsString(aElement, data); + } else { + JS_ClearPendingException(aCx); + } +} + +MOZ_CAN_RUN_SCRIPT +static void SetInnerHTML(Document& aDocument, const nsString& aInnerHTML) { + RefPtr<Element> bodyElement = aDocument.GetBody(); + if (bodyElement && bodyElement->IsInDesignMode()) { + IgnoredErrorResult rv; + bodyElement->SetInnerHTML(aInnerHTML, aDocument.NodePrincipal(), rv); + if (!rv.Failed()) { + nsContentUtils::DispatchInputEvent(bodyElement); + } + } +} + +class FormDataParseContext : public txIParseContext { + public: + explicit FormDataParseContext(bool aCaseInsensitive) + : mIsCaseInsensitive(aCaseInsensitive) {} + + nsresult resolveNamespacePrefix(nsAtom* aPrefix, int32_t& aID) override { + if (aPrefix == nsGkAtoms::xul) { + aID = kNameSpaceID_XUL; + } else { + MOZ_ASSERT(nsDependentAtomString(aPrefix).EqualsLiteral("xhtml")); + aID = kNameSpaceID_XHTML; + } + return NS_OK; + } + + nsresult resolveFunctionCall(nsAtom* aName, int32_t aID, + FunctionCall** aFunction) override { + return NS_ERROR_XPATH_UNKNOWN_FUNCTION; + } + + bool caseInsensitiveNameTests() override { return mIsCaseInsensitive; } + + void SetErrorOffset(uint32_t aOffset) override {} + + private: + bool mIsCaseInsensitive; +}; + +static Element* FindNodeByXPath(Document& aDocument, + const nsAString& aExpression) { + FormDataParseContext parsingContext(aDocument.IsHTMLDocument()); + IgnoredErrorResult rv; + UniquePtr<XPathExpression> expression( + aDocument.XPathEvaluator()->CreateExpression(aExpression, &parsingContext, + &aDocument, rv)); + if (rv.Failed()) { + return nullptr; + } + RefPtr<XPathResult> result = expression->Evaluate( + aDocument, XPathResult::FIRST_ORDERED_NODE_TYPE, nullptr, rv); + if (rv.Failed()) { + return nullptr; + } + return Element::FromNodeOrNull(result->GetSingleNodeValue(rv)); +} + +/* static */ +bool SessionStoreUtils::RestoreFormData(const GlobalObject& aGlobal, + Document& aDocument, + const CollectedData& aData) { + if (!aData.mUrl.WasPassed()) { + return true; + } + + // Don't restore any data for the given frame if the URL + // stored in the form data doesn't match its current URL. + nsAutoCString url; + Unused << aDocument.GetDocumentURI()->GetSpecIgnoringRef(url); + if (!aData.mUrl.Value().Equals(url)) { + return false; + } + + using Change = SessionStoreChangeListener::Change; + SessionStoreChangeListener::CollectSessionStoreData( + aDocument.GetWindowContext(), EnumSet<Change>(Change::Input)); + + if (aData.mInnerHTML.WasPassed()) { + SetInnerHTML(aDocument, aData.mInnerHTML.Value()); + } + if (aData.mId.WasPassed()) { + for (auto& entry : aData.mId.Value().Entries()) { + RefPtr<Element> node = aDocument.GetElementById(entry.mKey); + if (node == nullptr) { + continue; + } + if (entry.mValue.IsString()) { + SetElementAsString(node, entry.mValue.GetAsString()); + } else if (entry.mValue.IsBoolean()) { + SetElementAsBool(node, entry.mValue.GetAsBoolean()); + } else { + // For about:{sessionrestore,welcomeback} we saved the field as JSON to + // avoid nested instances causing humongous sessionstore.js files. + // cf. bug 467409 + JSContext* cx = aGlobal.Context(); + if (entry.mKey.EqualsLiteral("sessionData")) { + if (url.EqualsLiteral("about:sessionrestore") || + url.EqualsLiteral("about:welcomeback")) { + JS::Rooted<JS::Value> object( + cx, JS::ObjectValue(*entry.mValue.GetAsObject())); + SetSessionData(cx, node, &object); + continue; + } + } + JS::Rooted<JS::Value> object( + cx, JS::ObjectValue(*entry.mValue.GetAsObject())); + SetElementAsObject(cx, node, object); + } + } + } + + if (aData.mXpath.WasPassed()) { + for (auto& entry : aData.mXpath.Value().Entries()) { + RefPtr<Element> node = FindNodeByXPath(aDocument, entry.mKey); + if (node == nullptr) { + continue; + } + if (entry.mValue.IsString()) { + SetElementAsString(node, entry.mValue.GetAsString()); + } else if (entry.mValue.IsBoolean()) { + SetElementAsBool(node, entry.mValue.GetAsBoolean()); + } else { + JS::Rooted<JS::Value> object( + aGlobal.Context(), JS::ObjectValue(*entry.mValue.GetAsObject())); + SetElementAsObject(aGlobal.Context(), node, object); + } + } + } + + return true; +} + +MOZ_CAN_RUN_SCRIPT +void RestoreFormEntry(Element* aNode, const FormEntryValue& aValue) { + using Type = sessionstore::FormEntryValue::Type; + switch (aValue.type()) { + case Type::TCheckbox: + SetElementAsBool(aNode, aValue.get_Checkbox().value()); + break; + case Type::TTextField: + SetElementAsString(aNode, aValue.get_TextField().value()); + break; + case Type::TFileList: { + if (RefPtr<HTMLInputElement> input = HTMLInputElement::FromNode(aNode); + input && input->ControlType() == FormControlType::InputFile) { + CollectedFileListValue value; + value.mFileList = aValue.get_FileList().valueList().Clone(); + SetElementAsFiles(input, value); + } + break; + } + case Type::TSingleSelect: { + if (RefPtr<HTMLSelectElement> select = HTMLSelectElement::FromNode(aNode); + select && !select->Multiple()) { + CollectedNonMultipleSelectValue value; + value.mSelectedIndex = aValue.get_SingleSelect().index(); + value.mValue = aValue.get_SingleSelect().value(); + SetElementAsSelect(select, value); + } + break; + } + case Type::TMultipleSelect: { + if (RefPtr<HTMLSelectElement> select = HTMLSelectElement::FromNode(aNode); + select && select->Multiple()) { + SetElementAsMultiSelect(select, + aValue.get_MultipleSelect().valueList()); + } + break; + } + default: + MOZ_ASSERT_UNREACHABLE(); + } +} + +/* static */ +void SessionStoreUtils::RestoreFormData( + Document& aDocument, const nsString& aInnerHTML, + const nsTArray<SessionStoreRestoreData::Entry>& aEntries) { + using Change = SessionStoreChangeListener::Change; + SessionStoreChangeListener::CollectSessionStoreData( + aDocument.GetWindowContext(), EnumSet<Change>(Change::Input)); + + if (!aInnerHTML.IsEmpty()) { + SetInnerHTML(aDocument, aInnerHTML); + } + + for (const auto& entry : aEntries) { + RefPtr<Element> node = entry.mIsXPath + ? FindNodeByXPath(aDocument, entry.mData.id()) + : aDocument.GetElementById(entry.mData.id()); + if (node) { + RestoreFormEntry(node, entry.mData.value()); + } + } +} + +typedef void (*CollectorFunc)(JSContext* aCx, Document& aDocument, + Nullable<CollectedData>& aRetVal); + +/** + * A function that will recursively call |CollectorFunc| to collect data for all + * non-dynamic frames in the current frame/docShell tree. + */ +static void CollectFrameTreeData(JSContext* aCx, + BrowsingContext* aBrowsingContext, + Nullable<CollectedData>& aRetVal, + CollectorFunc aFunc) { + if (aBrowsingContext->CreatedDynamically()) { + return; + } + + nsPIDOMWindowOuter* window = aBrowsingContext->GetDOMWindow(); + if (!window || !window->GetDocShell()) { + return; + } + + Document* document = window->GetExtantDoc(); + if (!document) { + return; + } + + /* Collect data from current frame */ + aFunc(aCx, *document, aRetVal); + + /* Collect data from all child frame */ + nsTArray<JSObject*> childrenData; + SequenceRooter<JSObject*> rooter(aCx, &childrenData); + uint32_t trailingNullCounter = 0; + + // This is not going to work for fission. Bug 1572084 for tracking it. + for (auto& child : aBrowsingContext->Children()) { + NullableRootedDictionary<CollectedData> data(aCx); + CollectFrameTreeData(aCx, child, data, aFunc); + if (data.IsNull()) { + childrenData.AppendElement(nullptr); + trailingNullCounter++; + continue; + } + JS::Rooted<JS::Value> jsval(aCx); + if (!ToJSValue(aCx, data.SetValue(), &jsval)) { + JS_ClearPendingException(aCx); + continue; + } + childrenData.AppendElement(&jsval.toObject()); + trailingNullCounter = 0; + } + + if (trailingNullCounter != childrenData.Length()) { + childrenData.TruncateLength(childrenData.Length() - trailingNullCounter); + aRetVal.SetValue().mChildren.Construct() = std::move(childrenData); + } +} + +/* static */ void SessionStoreUtils::CollectScrollPosition( + const GlobalObject& aGlobal, WindowProxyHolder& aWindow, + Nullable<CollectedData>& aRetVal) { + CollectFrameTreeData(aGlobal.Context(), aWindow.get(), aRetVal, + CollectCurrentScrollPosition); +} + +/* static */ void SessionStoreUtils::CollectFormData( + const GlobalObject& aGlobal, WindowProxyHolder& aWindow, + Nullable<CollectedData>& aRetVal) { + CollectFrameTreeData(aGlobal.Context(), aWindow.get(), aRetVal, + CollectCurrentFormData); +} + +/* static */ void SessionStoreUtils::ComposeInputData( + const nsTArray<CollectedInputDataValue>& aData, InputElementData& ret) { + nsTArray<int> selectedIndex, valueIdx; + nsTArray<nsString> id, selectVal, strVal, type; + nsTArray<bool> boolVal; + + for (const CollectedInputDataValue& data : aData) { + id.AppendElement(data.id); + type.AppendElement(data.type); + + if (data.value.is<mozilla::dom::CollectedNonMultipleSelectValue>()) { + valueIdx.AppendElement(selectVal.Length()); + selectedIndex.AppendElement( + data.value.as<mozilla::dom::CollectedNonMultipleSelectValue>() + .mSelectedIndex); + selectVal.AppendElement( + data.value.as<mozilla::dom::CollectedNonMultipleSelectValue>() + .mValue); + } else if (data.value.is<CopyableTArray<nsString>>()) { + // The first valueIdx is "index of the first string value" + valueIdx.AppendElement(strVal.Length()); + strVal.AppendElements(data.value.as<CopyableTArray<nsString>>()); + // The second valueIdx is "index of the last string value" + 1 + id.AppendElement(data.id); + type.AppendElement(data.type); + valueIdx.AppendElement(strVal.Length()); + } else if (data.value.is<nsString>()) { + valueIdx.AppendElement(strVal.Length()); + strVal.AppendElement(data.value.as<nsString>()); + } else if (data.type.EqualsLiteral("bool")) { + valueIdx.AppendElement(boolVal.Length()); + boolVal.AppendElement(data.value.as<bool>()); + } + } + + if (selectedIndex.Length() != 0) { + ret.mSelectedIndex.Construct(std::move(selectedIndex)); + } + if (valueIdx.Length() != 0) { + ret.mValueIdx.Construct(std::move(valueIdx)); + } + if (id.Length() != 0) { + ret.mId.Construct(std::move(id)); + } + if (selectVal.Length() != 0) { + ret.mSelectVal.Construct(std::move(selectVal)); + } + if (strVal.Length() != 0) { + ret.mStrVal.Construct(std::move(strVal)); + } + if (type.Length() != 0) { + ret.mType.Construct(std::move(type)); + } + if (boolVal.Length() != 0) { + ret.mBoolVal.Construct(std::move(boolVal)); + } +} + +already_AddRefed<nsISessionStoreRestoreData> +SessionStoreUtils::ConstructSessionStoreRestoreData( + const GlobalObject& aGlobal) { + nsCOMPtr<nsISessionStoreRestoreData> data = new SessionStoreRestoreData(); + return data.forget(); +} + +/* static */ +already_AddRefed<Promise> SessionStoreUtils::InitializeRestore( + const GlobalObject& aGlobal, CanonicalBrowsingContext& aContext, + nsISessionStoreRestoreData* aData, ErrorResult& aError) { + if (!mozilla::SessionHistoryInParent()) { + MOZ_CRASH("why were we called?"); + } + + MOZ_DIAGNOSTIC_ASSERT(aContext.IsTop()); + + MOZ_DIAGNOSTIC_ASSERT(aData); + nsCOMPtr<SessionStoreRestoreData> data = do_QueryInterface(aData); + aContext.SetRestoreData(data, aError); + if (aError.Failed()) { + return nullptr; + } + + nsCOMPtr<nsISHistory> shistory = aContext.GetSessionHistory(); + MOZ_DIAGNOSTIC_ASSERT(shistory); + shistory->ReloadCurrentEntry(); + + return aContext.GetRestorePromise(); +} + +/* static */ +void SessionStoreUtils::RestoreDocShellState( + nsIDocShell* aDocShell, const DocShellRestoreState& aState) { + if (aDocShell) { + if (aState.URI()) { + aDocShell->SetCurrentURIForSessionStore(aState.URI()); + } + RestoreDocShellCapabilities(aDocShell, aState.docShellCaps()); + } +} + +/* static */ +already_AddRefed<Promise> SessionStoreUtils::RestoreDocShellState( + const GlobalObject& aGlobal, CanonicalBrowsingContext& aContext, + const nsACString& aURL, const nsCString& aDocShellCaps, + ErrorResult& aError) { + MOZ_RELEASE_ASSERT(mozilla::SessionHistoryInParent()); + MOZ_RELEASE_ASSERT(aContext.IsTop()); + + WindowGlobalParent* wgp = aContext.GetCurrentWindowGlobal(); + if (!wgp) { + aError.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports()); + MOZ_DIAGNOSTIC_ASSERT(global); + + RefPtr<Promise> promise = Promise::Create(global, aError); + if (aError.Failed()) { + return nullptr; + } + + nsCOMPtr<nsIURI> uri; + if (!aURL.IsEmpty()) { + if (NS_FAILED(NS_NewURI(getter_AddRefs(uri), aURL))) { + aError.Throw(NS_ERROR_FAILURE); + return nullptr; + } + } + + bool allowJavascript = true; + for (const nsACString& token : + nsCCharSeparatedTokenizer(aDocShellCaps, ',').ToRange()) { + if (token.EqualsLiteral("Javascript")) { + allowJavascript = false; + } + } + + Unused << aContext.SetAllowJavascript(allowJavascript); + + DocShellRestoreState state = {uri, aDocShellCaps}; + + // TODO (anny): Investigate removing this roundtrip. + wgp->SendRestoreDocShellState(state)->Then( + GetMainThreadSerialEventTarget(), __func__, + [promise](void) { promise->MaybeResolveWithUndefined(); }, + [promise](void) { promise->MaybeRejectWithUndefined(); }); + + return promise.forget(); +} + +/* static */ +void SessionStoreUtils::RestoreSessionStorageFromParent( + const GlobalObject& aGlobal, const CanonicalBrowsingContext& aContext, + const Record<nsCString, Record<nsString, nsString>>& aSessionStorage) { + nsTArray<SSCacheCopy> cacheInitList; + for (const auto& originEntry : aSessionStorage.Entries()) { + nsCOMPtr<nsIPrincipal> storagePrincipal = + BasePrincipal::CreateContentPrincipal(originEntry.mKey); + + nsCString originKey; + nsresult rv = storagePrincipal->GetStorageOriginKey(originKey); + if (NS_FAILED(rv)) { + continue; + } + + SSCacheCopy& cacheInit = *cacheInitList.AppendElement(); + + cacheInit.originKey() = originKey; + PrincipalToPrincipalInfo(storagePrincipal, &cacheInit.principalInfo()); + + for (const auto& entry : originEntry.mValue.Entries()) { + SSSetItemInfo& setItemInfo = *cacheInit.data().AppendElement(); + setItemInfo.key() = entry.mKey; + setItemInfo.value() = entry.mValue; + } + } + + BackgroundSessionStorageManager::LoadData(aContext.Id(), cacheInitList); +} + +/* static */ +nsresult SessionStoreUtils::ConstructFormDataValues( + JSContext* aCx, const nsTArray<sessionstore::FormEntry>& aValues, + nsTArray<Record<nsString, OwningStringOrBooleanOrObject>::EntryType>& + aEntries, + bool aParseSessionData) { + using EntryType = Record<nsString, OwningStringOrBooleanOrObject>::EntryType; + + if (!aEntries.SetCapacity(aValues.Length(), fallible)) { + return NS_ERROR_FAILURE; + } + + for (const auto& value : aValues) { + EntryType* entry = aEntries.AppendElement(); + + using Type = sessionstore::FormEntryValue::Type; + switch (value.value().type()) { + case Type::TCheckbox: + entry->mValue.SetAsBoolean() = value.value().get_Checkbox().value(); + break; + case Type::TTextField: { + if (aParseSessionData && value.id() == u"sessionData"_ns) { + JS::Rooted<JS::Value> jsval(aCx); + const auto& fieldValue = value.value().get_TextField().value(); + if (!JS_ParseJSON(aCx, fieldValue.get(), fieldValue.Length(), + &jsval) || + !jsval.isObject()) { + return NS_ERROR_FAILURE; + } + entry->mValue.SetAsObject() = &jsval.toObject(); + } else { + entry->mValue.SetAsString() = value.value().get_TextField().value(); + } + break; + } + case Type::TFileList: { + CollectedFileListValue file; + file.mFileList = value.value().get_FileList().valueList().Clone(); + + JS::Rooted<JS::Value> jsval(aCx); + if (!ToJSValue(aCx, file, &jsval) || !jsval.isObject()) { + return NS_ERROR_FAILURE; + } + entry->mValue.SetAsObject() = &jsval.toObject(); + break; + } + case Type::TSingleSelect: { + CollectedNonMultipleSelectValue select; + select.mSelectedIndex = value.value().get_SingleSelect().index(); + select.mValue = value.value().get_SingleSelect().value(); + + JS::Rooted<JS::Value> jsval(aCx); + if (!ToJSValue(aCx, select, &jsval) || !jsval.isObject()) { + return NS_ERROR_FAILURE; + } + entry->mValue.SetAsObject() = &jsval.toObject(); + break; + } + case Type::TMultipleSelect: { + JS::Rooted<JS::Value> jsval(aCx); + if (!ToJSValue(aCx, value.value().get_MultipleSelect().valueList(), + &jsval) || + !jsval.isObject()) { + return NS_ERROR_FAILURE; + } + entry->mValue.SetAsObject() = &jsval.toObject(); + break; + } + default: + break; + } + + entry->mKey = value.id(); + } + + return NS_OK; +} + +static nsresult ConstructSessionStorageValue( + const nsTArray<SSSetItemInfo>& aValues, + Record<nsString, nsString>& aRecord) { + auto& entries = aRecord.Entries(); + for (const auto& value : aValues) { + auto entry = entries.AppendElement(); + entry->mKey = value.key(); + entry->mValue = value.value(); + } + + return NS_OK; +} + +/* static */ +nsresult SessionStoreUtils::ConstructSessionStorageValues( + CanonicalBrowsingContext* aBrowsingContext, + const nsTArray<SSCacheCopy>& aValues, + Record<nsCString, Record<nsString, nsString>>& aRecord) { + if (!aRecord.Entries().SetCapacity(aValues.Length(), fallible)) { + return NS_ERROR_FAILURE; + } + + for (const auto& value : aValues) { + auto storagePrincipal = PrincipalInfoToPrincipal(value.principalInfo()); + if (storagePrincipal.isErr()) { + continue; + } + + auto entry = aRecord.Entries().AppendElement(); + + if (!entry->mValue.Entries().SetCapacity(value.data().Length(), fallible)) { + return NS_ERROR_FAILURE; + } + + if (NS_FAILED(storagePrincipal.inspect()->GetOrigin(entry->mKey))) { + return NS_ERROR_FAILURE; + } + + ConstructSessionStorageValue(value.data(), entry->mValue); + } + + return NS_OK; +} + +/* static */ +bool SessionStoreUtils::CopyProperty(JSContext* aCx, JS::Handle<JSObject*> aDst, + JS::Handle<JSObject*> aSrc, + const nsAString& aName) { + JS::Rooted<JS::PropertyKey> name(aCx); + const char16_t* data; + size_t length = aName.GetData(&data); + + if (!JS_CharsToId(aCx, JS::TwoByteChars(data, length), &name)) { + return false; + } + + bool found = false; + if (!JS_HasPropertyById(aCx, aSrc, name, &found) || !found) { + return true; + } + + JS::Rooted<JS::Value> value(aCx); + if (!JS_GetPropertyById(aCx, aSrc, name, &value)) { + return false; + } + + if (value.isNullOrUndefined()) { + return true; + } + + return JS_DefinePropertyById(aCx, aDst, name, value, JSPROP_ENUMERATE); +} diff --git a/toolkit/components/sessionstore/SessionStoreUtils.h b/toolkit/components/sessionstore/SessionStoreUtils.h new file mode 100644 index 0000000000..27922f1b51 --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreUtils.h @@ -0,0 +1,178 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_SessionStoreUtils_h +#define mozilla_dom_SessionStoreUtils_h + +#include "mozilla/Attributes.h" +#include "mozilla/IntegerRange.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/dom/SessionStoreUtilsBinding.h" +#include "SessionStoreData.h" +#include "SessionStoreRestoreData.h" + +class nsIDocument; +class nsGlobalWindowInner; + +namespace mozilla { +class ErrorResult; + +namespace dom { + +class CanonicalBrowsingContext; +class GlobalObject; +struct SSScrollPositionDict; +class SSCacheCopy; +class SSSetItemInfo; + +namespace sessionstore { +class DocShellRestoreState; +class FormData; +class FormEntry; +class StorageEntry; +} // namespace sessionstore + +class SessionStoreUtils { + public: + MOZ_CAN_RUN_SCRIPT + static void ForEachNonDynamicChildFrame( + const GlobalObject& aGlobal, WindowProxyHolder& aWindow, + SessionStoreUtilsFrameCallback& aCallback, ErrorResult& aRv); + + static already_AddRefed<nsISupports> AddDynamicFrameFilteredListener( + const GlobalObject& aGlobal, EventTarget& aTarget, const nsAString& aType, + JS::Handle<JS::Value> aListener, bool aUseCapture, bool aMozSystemGroup, + ErrorResult& aRv); + + static void RemoveDynamicFrameFilteredListener( + const GlobalObject& aGlobal, EventTarget& aTarget, const nsAString& aType, + nsISupports* aListener, bool aUseCapture, bool aMozSystemGroup, + ErrorResult& aRv); + + static void CollectDocShellCapabilities(const GlobalObject& aGlobal, + nsIDocShell* aDocShell, + nsCString& aRetVal); + + static void RestoreDocShellCapabilities( + nsIDocShell* aDocShell, const nsCString& aDisallowCapabilities); + static void RestoreDocShellCapabilities( + const GlobalObject& aGlobal, nsIDocShell* aDocShell, + const nsCString& aDisallowCapabilities) { + return RestoreDocShellCapabilities(aDocShell, aDisallowCapabilities); + } + + static void CollectScrollPosition(const GlobalObject& aGlobal, + WindowProxyHolder& aWindow, + Nullable<CollectedData>& aRetVal); + + static void RestoreScrollPosition(const GlobalObject& aGlobal, + nsGlobalWindowInner& aWindow, + const CollectedData& data); + static void RestoreScrollPosition(nsGlobalWindowInner& aWindow, + const nsCString& aScrollPosition); + + static uint32_t CollectFormData(Document* aDocument, + sessionstore::FormData& aFormData); + + /* + @param aDocument: DOMDocument instance to obtain form data for. + @param aGeneratedCount: the current number of XPath expressions in the + returned object. + */ + template <typename... ArgsT> + static void CollectFromTextAreaElement(Document& aDocument, + uint16_t& aGeneratedCount, + ArgsT&&... args); + template <typename... ArgsT> + static void CollectFromInputElement(Document& aDocument, + uint16_t& aGeneratedCount, + ArgsT&&... args); + template <typename... ArgsT> + static void CollectFromSelectElement(Document& aDocument, + uint16_t& aGeneratedCount, + ArgsT&&... args); + + static void CollectFormData(const GlobalObject& aGlobal, + WindowProxyHolder& aWindow, + Nullable<CollectedData>& aRetVal); + + MOZ_CAN_RUN_SCRIPT_BOUNDARY + static bool RestoreFormData(const GlobalObject& aGlobal, Document& aDocument, + const CollectedData& aData); + MOZ_CAN_RUN_SCRIPT static void RestoreFormData( + Document& aDocument, const nsString& aInnerHTML, + const nsTArray<SessionStoreRestoreData::Entry>& aEntries); + + static void ComposeInputData(const nsTArray<CollectedInputDataValue>& aData, + InputElementData& ret); + + MOZ_CAN_RUN_SCRIPT static already_AddRefed<nsISessionStoreRestoreData> + ConstructSessionStoreRestoreData(const GlobalObject& aGlobal); + + MOZ_CAN_RUN_SCRIPT static already_AddRefed<Promise> InitializeRestore( + const GlobalObject& aGlobal, CanonicalBrowsingContext& aContext, + nsISessionStoreRestoreData* aData, ErrorResult& aError); + + static void RestoreDocShellState( + nsIDocShell* aDocShell, const sessionstore::DocShellRestoreState& aState); + + static already_AddRefed<Promise> RestoreDocShellState( + const GlobalObject& aGlobal, CanonicalBrowsingContext& aContext, + const nsACString& aURL, const nsCString& aDocShellCaps, + ErrorResult& aError); + + static void RestoreSessionStorageFromParent( + const GlobalObject& aGlobal, const CanonicalBrowsingContext& aContext, + const Record<nsCString, Record<nsString, nsString>>& aSessionStorage); + + static nsresult ConstructFormDataValues( + JSContext* aCx, const nsTArray<sessionstore::FormEntry>& aValues, + nsTArray<Record<nsString, OwningStringOrBooleanOrObject>::EntryType>& + aEntries, + bool aParseSessionData = false); + + static nsresult ConstructSessionStorageValues( + CanonicalBrowsingContext* aBrowsingContext, + const nsTArray<SSCacheCopy>& aValues, + Record<nsCString, Record<nsString, nsString>>& aStorage); + + static bool CopyProperty(JSContext* aCx, JS::Handle<JSObject*> aDst, + JS::Handle<JSObject*> aSrc, const nsAString& aName); + + template <typename T> + static bool CopyChildren(JSContext* aCx, JS::Handle<JSObject*> aDst, + const nsTArray<RefPtr<T>>& aChildren) { + if (!aChildren.IsEmpty()) { + JS::Rooted<JSObject*> children( + aCx, JS::NewArrayObject(aCx, aChildren.Length())); + + for (const auto index : IntegerRange(aChildren.Length())) { + if (!aChildren[index]) { + continue; + } + + JS::Rooted<JSObject*> object(aCx); + aChildren[index]->ToJSON(aCx, &object); + + if (!JS_DefineElement(aCx, children, index, object, JSPROP_ENUMERATE)) { + return false; + } + } + + if (!JS_DefineProperty(aCx, aDst, "children", children, + JSPROP_ENUMERATE)) { + return false; + } + } + + return true; + } +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_SessionStoreUtils_h diff --git a/toolkit/components/sessionstore/moz.build b/toolkit/components/sessionstore/moz.build new file mode 100644 index 0000000000..9e8d2eb45e --- /dev/null +++ b/toolkit/components/sessionstore/moz.build @@ -0,0 +1,55 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +EXPORTS.mozilla.dom += [ + "BrowserSessionStore.h", + "SessionStoreChangeListener.h", + "SessionStoreChild.h", + "SessionStoreData.h", + "SessionStoreFormData.h", + "SessionStoreListener.h", + "SessionStoreMessageUtils.h", + "SessionStoreParent.h", + "SessionStoreRestoreData.h", + "SessionStoreScrollData.h", + "SessionStoreUtils.h", +] + +UNIFIED_SOURCES += [ + "BrowserSessionStore.cpp", + "RestoreTabContentObserver.cpp", + "SessionStoreChangeListener.cpp", + "SessionStoreChild.cpp", + "SessionStoreFormData.cpp", + "SessionStoreListener.cpp", + "SessionStoreParent.cpp", + "SessionStoreRestoreData.cpp", + "SessionStoreScrollData.cpp", + "SessionStoreUtils.cpp", +] + +EXTRA_JS_MODULES += [ + "SessionStoreFunctions.sys.mjs", +] + +XPIDL_MODULE = "sessionstore" + +XPIDL_SOURCES += [ + "nsISessionStoreRestoreData.idl", + "SessionStoreFunctions.idl", +] + +IPDL_SOURCES += [ + "PSessionStore.ipdl", + "SessionStoreTypes.ipdlh", +] + +include("/ipc/chromium/chromium-config.mozbuild") + +FINAL_LIBRARY = "xul" + +with Files("**"): + BUG_COMPONENT = ("Firefox", "Session Restore") diff --git a/toolkit/components/sessionstore/nsISessionStoreRestoreData.idl b/toolkit/components/sessionstore/nsISessionStoreRestoreData.idl new file mode 100644 index 0000000000..8e8dc8b636 --- /dev/null +++ b/toolkit/components/sessionstore/nsISessionStoreRestoreData.idl @@ -0,0 +1,33 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +[scriptable, uuid(cd9f33c5-460d-4bbf-a459-f375ca9566d8)] +interface nsISessionStoreRestoreData : nsISupports { + // Setters for form data. + attribute AUTF8String url; + attribute AString innerHTML; + + // Setters for scroll data. + attribute ACString scroll; + + // Methods for adding individual form fields which are called as the JS code + // finds them. + void addTextField(in boolean aIsXPath, in AString aIdOrXPath, + in AString aValue); + void addCheckbox(in boolean aIsXPath, in AString aIdOrXPath, + in boolean aValue); + void addFileList(in boolean aIsXPath, in AString aIdOrXPath, in AString aType, + in Array<AString> aFileList); + void addSingleSelect(in boolean aIsXPath, in AString aIdOrXPath, + in unsigned long aSelectedIndex, in AString aValue); + void addMultipleSelect(in boolean aIsXPath, in AString aIdOrXPath, + in Array<AString> aValues); + + // Add a child data object to our children list. + void addChild(in nsISessionStoreRestoreData aChild, in unsigned long aIndex); +}; |