diff options
Diffstat (limited to 'toolkit/components/sessionstore/SessionStoreUtils.cpp')
| -rw-r--r-- | toolkit/components/sessionstore/SessionStoreUtils.cpp | 1745 |
1 files changed, 1745 insertions, 0 deletions
diff --git a/toolkit/components/sessionstore/SessionStoreUtils.cpp b/toolkit/components/sessionstore/SessionStoreUtils.cpp new file mode 100644 index 0000000000..eb10ca8a93 --- /dev/null +++ b/toolkit/components/sessionstore/SessionStoreUtils.cpp @@ -0,0 +1,1745 @@ +/* -*- 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/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; + HTMLTextAreaElement* textArea = HTMLTextAreaElement::FromNode(aElement); + if (textArea) { + textArea->SetValue(aValue, rv); + if (!rv.Failed()) { + nsContentUtils::DispatchInputEvent(aElement); + } + return; + } + HTMLInputElement* input = HTMLInputElement::FromNode(aElement); + if (input) { + input->SetValue(aValue, CallerType::NonSystem, rv); + if (!rv.Failed()) { + nsContentUtils::DispatchInputEvent(aElement); + return; + } + } + input = HTMLInputElement::FromNodeOrNull( + nsFocusManager::GetRedirectedFocus(aElement)); + if (input) { + input->SetValue(aValue, CallerType::NonSystem, rv); + if (!rv.Failed()) { + nsContentUtils::DispatchInputEvent(aElement); + } + } +} + +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)) { + 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; + } + + MOZ_DIAGNOSTIC_ASSERT(aContext.GetSessionHistory()); + aContext.GetSessionHistory()->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); +} |